* receiving 0 byte pending packages aswell, some may come from appiot

* read bytes should be pending bytes, not buffer size

CMakeLists.txt

@@ -7,22 +7,29 @@ add_definitions(-DSerialOut=SerialUSB)
 if(DTLS)
     message(FATAL_ERROR "DTLS option is not supported." )
 endif()
+set(ARDUINO_USER_LIBDIR $ENV{HOME}/Arduino/libraries)
 
-include(${CMAKE_CURRENT_LIST_DIR}/../wakaama-core/src/wakaama.cmake)
-include(${CMAKE_CURRENT_LIST_DIR}/../wakaama-shared/src/arduino-base.cmake)
-include(${CMAKE_CURRENT_LIST_DIR}/../wakaama-shared/src/shared.cmake)
+include(${CMAKE_CURRENT_LIST_DIR}/../wakaama-arduino-core/src/wakaama.cmake)
+include(${CMAKE_CURRENT_LIST_DIR}/../wakaama-arduino-connection/src/arduino-base.cmake)
+include(${CMAKE_CURRENT_LIST_DIR}/../wakaama-arduino-connection/src/shared.cmake)
 
 add_definitions(-DLWM2M_CLIENT_MODE)
 add_definitions(${SHARED_DEFINITIONS} ${WAKAAMA_DEFINITIONS})
 
-include_directories (${WAKAAMA_SOURCES_DIR} ${SHARED_INCLUDE_DIRS} ${ARDUINO_INCLUDE_DIRS})
+include_directories(
+    ${WAKAAMA_SOURCES_DIR}
+    ${SHARED_INCLUDE_DIRS}
+    ${ARDUINO_INCLUDE_DIRS}
+    ${ARDUINO_USER_LIBDIR}/Sodaq_wdt/src
+    ${ARDUINO_USER_LIBDIR}/Sodaq_nbIOT/src
+)
 
-SET(SOURCES
-    ${CMAKE_CURRENT_LIST_DIR}/wakaama-client.cpp
-    ${CMAKE_CURRENT_LIST_DIR}/object_security.c
-    ${CMAKE_CURRENT_LIST_DIR}/object_server.c
-    ${CMAKE_CURRENT_LIST_DIR}/object_device.c
-    ${CMAKE_CURRENT_LIST_DIR}/test_object.c
+set(SOURCES
+    ${CMAKE_CURRENT_LIST_DIR}/src/wakaama-client.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/object_security.c
+    ${CMAKE_CURRENT_LIST_DIR}/src/object_server.c
+    ${CMAKE_CURRENT_LIST_DIR}/src/object_device.c
+    ${CMAKE_CURRENT_LIST_DIR}/src/test_object.c
 )
 
 add_executable(${PROJECT_NAME} ${SOURCES} ${WAKAAMA_SOURCES} ${SHARED_SOURCES})

src/wakaama-client.cpp

@@ -1,6 +1,5 @@
 #include "wakaama-client.h"
 #include <liblwm2m.h>
-#include <USB/USBAPI.h>
 #include <Dns.h>
 #include <Ethernet.h>
 
@@ -15,47 +14,47 @@ extern void lwm2m_printf(const char * format, ...);
  * @param uri
  * @todo init and use uri in security object
  */
-void ArduinoClient::init() {
-    SerialOut.println(F("init():start"));
+void ArduinoClient::init(Sodaq_nbIOT * nbiot) {
+    SerialUSB.println(F("init():start"));
     memset(&data, 0, sizeof(client_data_t));
 
     const __FlashStringHelper * objFail = F("Failed to create object");
 
     // create udp listener
-    data.udp = new EthernetUDP();
-    data.udp->begin(localPort);
+    data.nbIOT = nbiot;
+    data.sock = data.nbIOT->createSocket(localPort);
 
     // init objects
-    SerialOut.println(F("*object:security"));
+    SerialUSB.println(F("*object:security"));
     objArray[0] = get_security_object(uri);
     if (nullptr == objArray[0])
     {
-        SerialOut.println(objFail);
+        SerialUSB.println(objFail);
         exit(0);
     }
     data.securityObjP = objArray[0];
 
-    SerialOut.println(F("*object:server"));
+    SerialUSB.println(F("*object:server"));
     objArray[1] = get_server_object();
     if (nullptr == objArray[1])
     {
-        SerialOut.println(objFail);
+        SerialUSB.println(objFail);
         exit(0);
     }
 
-    SerialOut.println(F("*object:device"));
+    SerialUSB.println(F("*object:device"));
     objArray[2] = get_object_device();
     if (nullptr == objArray[2])
     {
-        SerialOut.println(objFail);
+        SerialUSB.println(objFail);
         exit(0);
     }
 
-    SerialOut.println(F("*object:test"));
+    SerialUSB.println(F("*object:test"));
     objArray[3] = get_test_object();
     if (nullptr == objArray[3])
     {
-        SerialOut.println(objFail);
+        SerialUSB.println(objFail);
         exit(0);
     }
 
@@ -63,11 +62,11 @@ void ArduinoClient::init() {
      * The liblwm2m library is now initialized with the functions that will be in
      * charge of communication
      */
-    SerialOut.println(F("*lwm2m_init()"));
+    SerialUSB.println(F("*lwm2m_init()"));
     lwm2mH = lwm2m_init(&data);
     if (NULL == lwm2mH)
     {
-        SerialOut.println(F("lwm2m_init() failed"));
+        SerialUSB.println(F("lwm2m_init() failed"));
         exit(0);
     }
 
@@ -75,19 +74,19 @@ void ArduinoClient::init() {
      * We configure the liblwm2m library with the name of the client - which shall be unique for each client -
      * the number of objects we will be passing through and the objects array
      */
-    SerialOut.println(F("*lwm2m_configure()"));
+    SerialUSB.println(F("*lwm2m_configure()"));
     result = lwm2m_configure(lwm2mH, name, NULL, NULL, OBJ_COUNT, objArray);
     if (result != 0)
     {
-        SerialOut.println(F("lwm2m_configure() failed"));
+        SerialUSB.println(F("lwm2m_configure() failed"));
         exit(0);
     }
-    SerialOut.println(F("init():done"));
+    SerialUSB.println(F("init():done"));
 }
 
 
 void ArduinoClient::doWorkStep() {
-    SerialOut.println(F("doWorkStep():start"));
+    SerialUSB.println(F("doWorkStep():start"));
 
     /*
      * This function does two things:
@@ -95,22 +94,26 @@ void ArduinoClient::doWorkStep() {
      *  - Secondly it adjusts the timeout value (default 60s) depending on the state of the transaction
      *    (eg. retransmission) and the time before the next operation
      */
-    SerialOut.println(F("lwm2m_step()"));
+    SerialUSB.println(F("lwm2m_step()"));
     result = lwm2m_step(lwm2mH, &step_delay);
     if (result != 0)
     {
-        SerialOut.print(F("lwm2m_step() failed"));
-        exit(0);
+        SerialUSB.print(F("lwm2m_step(): failed with error code "));
+        SerialUSB.println(result);
+        return;
     }
 
     // wait for socket event
-    SerialOut.println(F("parsePacket()"));
-    int packetSize = data.udp->parsePacket();
-    if (packetSize) {
-        int numBytes = data.udp->read(packetBuffer, UDP_TX_PACKET_MAX_SIZE);
+    SerialUSB.println(F("parsePacket()"));
+    size_t pending = data.nbIOT->socketBytesPending(data.sock);
+    if (pending >= 0) {
+        size_t numBytes = data.nbIOT->socketReceive(data.sock, packetBuffer, pending);
+        if (pending == 0) {
+            return;
+        }
 
         connection_t * connP;
-        connP = connection_find(data.connList, data.udp);
+        connP = connection_find(data.connList, data.sock);
         if (connP != nullptr)
         {
             /*
@@ -119,7 +122,7 @@ void ArduinoClient::doWorkStep() {
             lwm2m_handle_packet(lwm2mH, (uint8_t*)packetBuffer, numBytes, connP);
         }
     }
-    SerialOut.println(F("doWorkStep():done"));
+    SerialUSB.println(F("doWorkStep():done"));
 }
 
 /**
@@ -127,7 +130,7 @@ void ArduinoClient::doWorkStep() {
  */
 ArduinoClient::~ArduinoClient() {
     lwm2m_close(lwm2mH);
-    data.udp->stop();
+    data.nbIOT->closeSocket(data.sock);
     connection_free(data.connList);
 
     free_security_object(objArray[0]);
@@ -156,8 +159,8 @@ void * lwm2m_connect_server(uint16_t secObjInstID, void *userData) {
 
     if (uri == nullptr) return nullptr;
 
-    SerialOut.print(F("Connecting to "));
-    SerialOut.println(uri);
+    SerialUSB.print(F("Connecting to "));
+    SerialUSB.println(uri);
 
     // parse uri in the form "coaps://[host]:[port]"
     if (0 == strncmp(uri, "coaps://", strlen("coaps://")))
@@ -195,23 +198,26 @@ void * lwm2m_connect_server(uint16_t secObjInstID, void *userData) {
     *port = 0;
     port++;
 
-    auto * remoteIp = new IPAddress();
-    if(!remoteIp->fromString(host)) {
-        DNSClient dns;
-        dns.begin(Ethernet.dnsServerIP());
-        dns.getHostByName(host, *remoteIp);
-    }
+//    IPAddress * remoteIp = new IPAddress();
+//    if(!remoteIp->fromString(host)) {
+//        DNSClient dns;
+//        dns.begin(Ethernet.dnsServerIP());
+//        dns.getHostByName(host, *remoteIp);
+//    }
+
+    SerialUSB.print(F("Host is "));
+    SerialUSB.println(host);
 
     String portStr = port;
 
-    newConnP = connection_create(dataP->connList, dataP->udp, remoteIp, portStr.toInt());
+    newConnP = connection_create(dataP->connList, dataP->sock, dataP->nbIOT, host, portStr.toInt());
     if (newConnP == nullptr) {
-        SerialOut.println(F("Connection creation failed"));
+        SerialUSB.println(F("Connection creation failed"));
     }
     else {
         dataP->connList = newConnP;
     }
-    SerialOut.println(F("Connection created"));
+    SerialUSB.println(F("Connection created"));
 
     lwm2m_free(uri);
     return (void *)newConnP;
@@ -254,5 +260,5 @@ void lwm2m_close_connection(void *sessionH, void *userData) {
 
 void lwm2m_printf(const char * format, ...)
 {
-    SerialOut.println(format);
+    SerialUSB.println(format);
 }

src/wakaama-client.h

@@ -1,10 +1,10 @@
 #ifndef WAKAAMA_CLIENT_H_
 #define WAKAAMA_CLIENT_H_
 
-#include <Udp.h>
+
 #include <EthernetUdp.h>
-#include <connection.h>
-#include <serialout.h>
+#include <Sodaq_nbIOT.h>
+#include "connection.h"
 
 #define OBJ_COUNT 4
 
@@ -24,7 +24,8 @@ typedef struct
 {
     lwm2m_object_t * securityObjP;
     connection_t   * connList;
-    EthernetUDP    * udp;
+    Sodaq_nbIOT    * nbIOT;
+    int              sock;
 } client_data_t;
 
 
@@ -32,17 +33,18 @@ class ArduinoClient {
 
 public:
     ArduinoClient(const char *uri) : uri(uri) {};
-    void init();
+    ArduinoClient(const char *name, const char *uri) : name(name),uri(uri) {};
+    void init(Sodaq_nbIOT *nbiot);
     ~ArduinoClient();
     void doWorkStep();
 private:
     const char * uri;
     const uint16_t localPort = 56830;
-    const char * name = "wakaamArduino";
+    const char * name = "wakaama_device";
     time_t step_delay = 60;
     int result;
 
-    char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
+    char packetBuffer[512];
 
     client_data_t data;
     lwm2m_context_t * lwm2mH = nullptr;