Cellular: Documenting the support for Non-IP data delivery feature

Author: Mirela Chirica

docs/api/networksocket/CellularNonIPSocket.md

@@ -0,0 +1,84 @@
+## Non-IP cellular socket
+
+The CellularNonIPSocket class provides, through standard socket `send` and `recv` member functions, the ability to send and receive Non-IP datagrams using Control Plane CIoT EPS optimisation feature of the NB-IoT networks. This feature is implemented in [`ControlPlane_netif`](https://os.mbed.com/docs/development/mbed-os-api-doxy/classmbed_1_1_control_plane__netif.html) class.
+
+The constructor takes no parameters. To initialize the socket on a specified NetworkInterface, you must call `open` method, which takes a CellularContext pointer.
+
+[`CellularContext`](https://os.mbed.com/docs/development/mbed-os-api-doxy/_cellular_context_8h.html) is setting up the modem into the Control Plane CIoT EPS optimisation mode of operation if it is requested and cellular network supports it.
+
+Control Plane CIoT EPS optimisation mode can be requested either on CellularDevice's [`create_context`](https://os.mbed.com/docs/development/mbed-os-api-doxy/classmbed_1_1_cellular_device.html#a43b9e992dff1cb5d880acec576e9d06f) or configured in cellular mbed_lib.json:
+
+```json
+{
+    "name": "cellular",
+    "config": {
+        ...
+        "control-plane-opt": {
+            "help": "Enables control plane CIoT EPS optimisation",
+            "value": true
+        }
+    }
+}
+```
+ControlPlane
+### CellularNonIPSocket class reference
+
+[![View code](https://www.mbed.com/embed/?type=library)](https://os.mbed.com/docs/development/mbed-os-api-doxy/classmbed_1_1_cellular_non_i_p_socket.html)
+
+The following code demonstrates how to create and use a cellular Non-IP socket:
+```
+
+#include "mbed.h"
+#include "CellularNonIPSocket.h"
+#include "CellularDevice.h"
+
+// Network interface
+NetworkInterface *iface;
+
+int main() {
+    // Bring up the cellular interface
+    iface = CellularContext::get_default_nonip_instance();
+    MBED_ASSERT(iface);
+
+    // sim pin, apn, credentials and possible plmn are taken automatically from json when using NetworkInterface::set_default_parameters()
+    iface->set_default_parameters();
+
+    printf("Cellular Non-IP Socket example\n");
+    if(NSAPI_ERROR_OK != iface->connect() || NSAPI_STATUS_GLOBAL_UP != iface->get_connection_status()) {
+        printf("Error connecting\n");
+        return -1;
+    }
+
+    CellularNonIPSocket sock;
+
+    nsapi_error_t retcode = sock.open((CellularContext*)iface);
+
+    if (retcode != NSAPI_ERROR_OK) {
+        printf("CellularNonIPSocket.open() fails, code: %d\n", retcode);
+        return -1;
+    }
+
+    const char *send_string = "TEST";
+
+    if(0 > sock.send((void*) send_string, sizeof(send_string))) {
+        printf("Error sending data\n");
+        return -1;
+    }
+
+    printf("Success sending data\n");
+
+    char recv_buf[4];
+    if(0 > sock.recv((void *)recv_buf, sizeof(recv_buf))) {
+        printf("Error receiving data\n");
+        return -1;
+    }
+
+    printf("Success receiving data\n");
+
+    // Close the socket and bring down the network interface
+    sock.close();
+    iface->disconnect();
+    return 0;
+}
+
+```

docs/api/networksocket/networksocket.md

@@ -1,6 +1,6 @@
 <h2 id="network-socket">Network socket overview</h2>
 
-The application programming interface for IP networking is the Socket API. As described in the [IP networking](../reference/ip-networking.html) section, the Socket API relates to OSI layer 4, the Transport layer. In Mbed OS, the Socket API supports both TCP and UDP protocols.
+The application programming interface for IP networking is the Socket API. As described in the [IP networking](../reference/ip-networking.html) section, the Socket API relates to OSI layer 4, the Transport layer. In Mbed OS, the Socket API is abstract and supports various protocols such as TCP, UDP and Non-IP data delivery for NB-IoT cellular networks.
 
 <span class="images">![](https://s3-us-west-2.amazonaws.com/mbed-os-docs-images/ip-networking.png)<span>Sockets</span></span>
 
@@ -97,6 +97,7 @@ The network socket API provides a common interface for using sockets on network
 - [UDPSocket](udpsocket.html): This class provides the ability to send packets of data over UDP.
 - [TCPSocket](tcpsocket.html): This class provides the ability to send a stream of data over TCP.
 - [SocketAddress](socketaddress.html): You can use this class to represent the IP address and port pair of a unique network endpoint.
+- [CellularNonIPSocket](cellularnonipsocket.html): This class provides the ability to send Non-IP datagrams using Control Plane CIoT EPS optimisation feature of the NB-IoT cellular networks.
 - [Network status](network-status.html): API for monitoring network status changes.
 - [DNS resolver](dns-resolver.html): API for resolving DNS names
 

docs/reference/technology/connectivity/connectivity.md

@@ -12,9 +12,10 @@ For IP devices:
 * NB-IoT.
 * Bluetooth Low Energy (BLE).
 
-Non-IP devices require a gateway:
+Non-IP devices:
 
 * LoRaWAN.
+* Cellular.
 
 ### Choosing your connectivity method
 
@@ -101,6 +102,12 @@ Near-field communication (NFC) is a short range (few centimeters) wireless techn
 
 To learn how to use NFC with Mbed OS, please refer to the [Mbed OS NFC overview](../apis/nfc.html).
 
+#### NB-IoT Cellular
+
+Non-IP Data Delivery(NIDD) is a new feature for communication over NB-IoT. It is enabled by Control Plane CIoT EPS optimization and meant to provide improved support of small data transfer. It does this by transporting user data encapsulated in NAS messages, thus reducing the total number of control plane messages when handling a short data transaction.
+
+To learn how to use this feature with Mbed OS, please refer to [CellularNonIPSocket](../apis/cellularnonipsocket.html).
+
 #### Memory needs for Pelion-connected devices
 
 Mbed OS's baseline memory footprint, without Pelion connectivity, is 2.8kb of RAM and 8.2kb of flash. When you add connectivity and full functionality, the footprint grows: