Added Queue Mode implementation in LwM2M

examples/ipso-objects/zoul/module-macros.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018, RISE SICS AB.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*---------------------------------------------------------------------------*/
+/* Only sleep mode 1 on Zoul to enable full 32 KiB RAM */
+#define LPM_CONF_MAX_PM 1
+/*---------------------------------------------------------------------------*/

examples/lwm2m-ipso-objects/Makefile

@@ -11,4 +11,7 @@ MODULES += os/services/lwm2m
 MODULES += os/services/ipso-objects
 
 CONTIKI=../..
+include $(CONTIKI)/Makefile.identify-target
+MODULES_REL += $(TARGET)
+
 include $(CONTIKI)/Makefile.include

examples/lwm2m-ipso-objects/project-conf.h

@@ -30,9 +30,6 @@
 #ifndef PROJECT_CONF_H_
 #define PROJECT_CONF_H_
 
-/* No sleep on CC2538 to enable full 32 KiB RAM */
-#define LPM_CONF_ENABLE 0
-
 #ifdef BOARD_STRING
 #define LWM2M_DEVICE_MODEL_NUMBER BOARD_STRING
 #elif defined(CONTIKI_TARGET_WISMOTE)
@@ -62,4 +59,11 @@
 /* Enable client-side support for COAP observe */
 #define COAP_OBSERVE_CLIENT 1
 
+/* Definitions to enable Queue Mode, include the dynamic adaptation and change the default parameters  */
+/* #define LWM2M_Q_MODE_CONF_ENABLED 1
+   #define LWM2M_Q_MODE_CONF_INCLUDE_DYNAMIC_ADAPTATION 1
+   #define LWM2M_Q_MODE_CONF_DEFAULT_CLIENT_AWAKE_TIME 2000
+   #define LWM2M_Q_MODE_CONF_DEFAULT_CLIENT_SLEEP_TIME 10000
+   #define LWM2M_Q_MODE_CONF_DEFAULT_DYNAMIC_ADAPTATION_FLAG 1 */
+
 #endif /* PROJECT_CONF_H_ */

os/net/app-layer/coap/coap-observe.c

@@ -353,4 +353,18 @@ coap_observe_handler(coap_resource_t *resource, coap_message_t *coap_req,
   }
 }
 /*---------------------------------------------------------------------------*/
+uint8_t
+coap_has_observers(char *path)
+{
+  coap_observer_t *obs = NULL;
+
+  for(obs = (coap_observer_t *)list_head(observers_list); obs;
+      obs = obs->next) {
+    if((strncmp(obs->url, path, strlen(path))) == 0) {
+      return 1;
+    }
+  }
+  return 0;
+}
+/*---------------------------------------------------------------------------*/
 /** @} */

os/net/app-layer/coap/coap-observe.h

@@ -80,5 +80,7 @@ void coap_notify_observers_sub(coap_resource_t *resource, const char *subpath);
 void coap_observe_handler(coap_resource_t *resource, coap_message_t *request,
                           coap_message_t *response);
 
+uint8_t coap_has_observers(char *path);
+
 #endif /* COAP_OBSERVE_H_ */
 /** @} */

os/services/lwm2m/lwm2m-engine.c

@@ -39,6 +39,7 @@
  * \author
  *         Joakim Eriksson <joakime@sics.se>
  *         Niclas Finne <nfi@sics.se>
+ *         Carlos Gonzalo Peces <carlosgp143@gmail.com>
  */
 
 #include "lwm2m-engine.h"
@@ -56,7 +57,6 @@
 #include <stdio.h>
 #include <string.h>
 #include <inttypes.h>
-
 #ifndef LWM2M_ENGINE_CLIENT_ENDPOINT_NAME
 #include "net/ipv6/uip-ds6.h"
 #endif /* LWM2M_ENGINE_CLIENT_ENDPOINT_NAME */
@@ -80,10 +80,24 @@
 #define USE_RD_CLIENT 1
 #endif /* LWM2M_ENGINE_CONF_USE_RD_CLIENT */
 
+
+#if LWM2M_Q_MODE_ENABLED
+ /* Queue Mode is handled using the RD Client and the Q-Mode object */
+#define USE_RD_CLIENT 1
+/* Queue Mode dynamic adaptation masks */
+#define FIRST_REQUEST_MASK 0x01
+#define HANDLER_FROM_NOTIFICATION_MASK 0x02
+#endif
+
 #if USE_RD_CLIENT
 #include "lwm2m-rd-client.h"
 #endif
 
+#if LWM2M_Q_MODE_ENABLED
+#include "lwm2m-qmode-object.h"
+#include "lwm2m-notification-queue.h"
+#endif
+
 /* MACRO for getting out resource ID from resource array ID + flags */
 #define RSC_ID(x)       ((uint16_t)(x & 0xffff))
 #define RSC_READABLE(x) ((x & LWM2M_RESOURCE_READ) > 0)
@@ -129,6 +143,18 @@ static struct {
   /* in the future also a timeout */
 } created;
 
+#if LWM2M_Q_MODE_ENABLED
+static uint8_t waked_up_by_notification;
+/* For the dynamic adaptation of the awake time */ 
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+static uint8_t dynamic_adaptation_params = 0x00; /* bit0: first_request, bit1: handler from notification */
+static uint64_t previous_request_time;
+static inline void clear_first_request();
+static inline uint8_t is_first_request();
+static inline void clear_handler_from_notification();
+static inline uint8_t get_handler_from_notification();
+#endif /* LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION */
+#endif /* LWM2M_Q_MODE_ENABLED */
 
 COAP_HANDLER(lwm2m_handler, lwm2m_handler_callback);
 LIST(object_list);
@@ -554,6 +580,10 @@ lwm2m_engine_init(void)
 #if USE_RD_CLIENT
   lwm2m_rd_client_init(endpoint);
 #endif
+
+#if LWM2M_Q_MODE_ENABLED
+  lwm2m_q_object_init();
+#endif
 }
 /*---------------------------------------------------------------------------*/
 /*
@@ -1373,6 +1403,31 @@ lwm2m_handler_callback(coap_message_t *request, coap_message_t *response,
   context.inbuf->size = coap_get_payload(request, (const uint8_t **)&context.inbuf->buffer);
   context.inbuf->pos = 0;
 
+  /*If Queue Mode, restart the client awake timer */
+#if LWM2M_Q_MODE_ENABLED 
+  if(lwm2m_rd_client_is_client_awake()) {
+    lwm2m_rd_client_restart_client_awake_timer();
+  }
+
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+  if(lwm2m_q_object_get_dynamic_adaptation_flag() && !get_handler_from_notification()) {
+    if(is_first_request()) {
+      previous_request_time = coap_timer_uptime();
+      clear_first_request();
+    }else{
+      if(coap_timer_uptime()-previous_request_time >= 0) {
+        lwm2m_q_object_add_time_object(coap_timer_uptime()-previous_request_time);
+
+      }
+      previous_request_time = coap_timer_uptime();
+    }
+  }
+  if(get_handler_from_notification()) {
+    clear_handler_from_notification();
+  }
+#endif /* LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION */
+#endif /* LWM2M_Q_MODE_ENABLED */
+
   /* Maybe this should be part of CoAP itself - this seems not to be working
      with the leshan server */
 #define LWM2M_CONF_ENTITY_TOO_LARGE_BLOCK1 0
@@ -1632,14 +1687,99 @@ lwm2m_handler_callback(coap_message_t *request, coap_message_t *response,
   return COAP_HANDLER_STATUS_PROCESSED;
 }
 /*---------------------------------------------------------------------------*/
-void lwm2m_notify_object_observers(lwm2m_object_instance_t *obj,
+static void
+lwm2m_send_notification(char* path)
+{
+#if LWM2M_Q_MODE_ENABLED && LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+    if(lwm2m_q_object_get_dynamic_adaptation_flag()){
+      lwm2m_engine_set_handler_from_notification();
+    } 
+#endif
+  coap_notify_observers_sub(NULL, path);
+}
+/*---------------------------------------------------------------------------*/
+void 
+lwm2m_notify_object_observers(lwm2m_object_instance_t *obj,
                                    uint16_t resource)
 {
   char path[20]; /* 60000/60000/60000 */
   if(obj != NULL) {
     snprintf(path, 20, "%d/%d/%d", obj->object_id, obj->instance_id, resource);
-    coap_notify_observers_sub(NULL, path);
   }
+
+#if LWM2M_Q_MODE_ENABLED
+  
+  if(coap_has_observers(path)) {
+    /* Client is sleeping -> add the notification to the list */
+    if(!lwm2m_rd_client_is_client_awake()) {
+      lwm2m_notification_queue_add_notification_path(path);
+
+      /* if it is the first notification -> wake up and send update */
+      if(!waked_up_by_notification) {
+        waked_up_by_notification = 1;
+        lwm2m_rd_client_fsm_execute_q_mode_update();
+      }
+    /* Client is awake -> send the notification */  
+    } else {
+      lwm2m_send_notification(path);
+    }
+  }
+#else 
+  lwm2m_send_notification(path);
+#endif
 }
 /*---------------------------------------------------------------------------*/
+/* Queue Mode Support and dynamic adaptation of the client awake time */
+#if LWM2M_Q_MODE_ENABLED
+uint8_t 
+lwm2m_engine_is_waked_up_by_notification()
+{
+ return waked_up_by_notification;
+}
+/*---------------------------------------------------------------------------*/
+void 
+lwm2m_engine_clear_waked_up_by_notification()
+{
+ waked_up_by_notification = 0;
+}
+/*---------------------------------------------------------------------------*/
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+void
+lwm2m_engine_set_first_request()
+{
+  dynamic_adaptation_params |= FIRST_REQUEST_MASK;
+}
+/*---------------------------------------------------------------------------*/
+void
+lwm2m_engine_set_handler_from_notification()
+{
+  dynamic_adaptation_params |= HANDLER_FROM_NOTIFICATION_MASK;
+}
+/*---------------------------------------------------------------------------*/
+static inline uint8_t
+is_first_request()
+{
+  return dynamic_adaptation_params & FIRST_REQUEST_MASK;
+}
+/*---------------------------------------------------------------------------*/
+static inline uint8_t
+get_handler_from_notification()
+{
+  return (dynamic_adaptation_params & HANDLER_FROM_NOTIFICATION_MASK) != 0;
+}
+/*---------------------------------------------------------------------------*/
+static inline void
+clear_first_request()
+{
+  dynamic_adaptation_params &= ~FIRST_REQUEST_MASK;
+}
+/*---------------------------------------------------------------------------*/
+static inline void
+clear_handler_from_notification()
+{
+  dynamic_adaptation_params &= ~HANDLER_FROM_NOTIFICATION_MASK;
+}
+#endif /* LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION */
+#endif /* LWM2M_Q_MODE_ENABLED */
+/*---------------------------------------------------------------------------*/
 /** @} */

os/services/lwm2m/lwm2m-engine.h

@@ -39,12 +39,14 @@
  * \author
  *         Joakim Eriksson <joakime@sics.se>
  *         Niclas Finne <nfi@sics.se>
+ *         Carlos Gonzalo Peces <carlosgp143@gmail.com>
  */
 
 #ifndef LWM2M_ENGINE_H
 #define LWM2M_ENGINE_H
 
 #include "lwm2m-object.h"
+#include "lwm2m-qmode-conf.h"
 
 #define LWM2M_FLOAT32_BITS  10
 #define LWM2M_FLOAT32_FRAC (1L << LWM2M_FLOAT32_BITS)
@@ -114,6 +116,14 @@ void lwm2m_notify_object_observers(lwm2m_object_instance_t *obj,
 
 void lwm2m_engine_set_opaque_callback(lwm2m_context_t *ctx, lwm2m_write_opaque_callback cb);
 
+#if LWM2M_Q_MODE_ENABLED
+uint8_t lwm2m_engine_is_waked_up_by_notification();
+void lwm2m_engine_clear_waked_up_by_notification();
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+void lwm2m_engine_set_first_request();
+void lwm2m_engine_set_handler_from_notification();
+#endif /* LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION */
+#endif /* LWM2M_Q_MODE_ENABLED */
 
 #endif /* LWM2M_ENGINE_H */
 /** @} */

os/services/lwm2m/lwm2m-notification-queue.c

@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2017, RISE SICS AB.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * \addtogroup lwm2m
+ * @{
+ */
+
+/**
+ * \file
+ *         Implementation of functions to manage the queue of notifications
+ * \author
+ *         Carlos Gonzalo Peces <carlosgp143@gmail.com>
+ */
+/*---------------------------------------------------------------------------*/
+#include "lwm2m-notification-queue.h"
+
+#if LWM2M_Q_MODE_ENABLED
+
+#include "lwm2m-qmode-object.h"
+#include "lwm2m-engine.h"
+#include "coap-engine.h"
+#include "lib/memb.h"
+#include "lib/list.h"
+#include <string.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/* Log configuration */
+#include "coap-log.h"
+#define LOG_MODULE "lwm2m-notification-queue"
+#define LOG_LEVEL  LOG_LEVEL_LWM2M
+
+#ifdef LWM2M_NOTIFICATION_QUEUE_CONF_LENGTH
+#define LWM2M_NOTIFICATION_QUEUE_LENGTH LWM2M_NOTIFICATION_QUEUE_CONF_LENGTH
+#else
+#define LWM2M_NOTIFICATION_QUEUE_LENGTH 3
+#endif
+
+/*---------------------------------------------------------------------------*/
+/* Queue to store the notifications in the period when the client has woken up, sent the update and it's waiting for the server response*/
+MEMB(notification_memb, notification_path_t, LWM2M_NOTIFICATION_QUEUE_LENGTH + 1); /* Length + 1 to allocate the new path to add */
+LIST(notification_paths_queue);
+/*---------------------------------------------------------------------------*/
+void
+lwm2m_notification_queue_init(void)
+{
+  list_init(notification_paths_queue);
+}
+/*---------------------------------------------------------------------------*/
+static void
+reduce_path(notification_path_t *path_object, char *path)
+{
+  char *cut = strtok(path, "/");
+  int i;
+  for(i = 0; i < 3; i++) {
+    if(cut != NULL) {
+      path_object->reduced_path[i] = (uint16_t)atoi(cut);
+      cut = strtok(NULL, "/");
+    } else {
+      break;
+    }
+  }
+  path_object->level = i;
+}
+/*---------------------------------------------------------------------------*/
+static void
+extend_path(notification_path_t *path_object, char *path)
+{
+  switch(path_object->level) {
+  case 1:
+    snprintf(path, sizeof(path) - 1, "%u", path_object->reduced_path[0]);
+    break;
+  case 2:
+    snprintf(path, sizeof(path) - 1, "%u/%u", path_object->reduced_path[0], path_object->reduced_path[1]);
+    break;
+  case 3:
+    snprintf(path, sizeof(path) - 1, "%u/%u/%u", path_object->reduced_path[0], path_object->reduced_path[1], path_object->reduced_path[2]);
+    break;
+  }
+}
+/*---------------------------------------------------------------------------*/
+static void
+add_notification_path_object_ordered(notification_path_t *path)
+{
+  notification_path_t *iteration_path = (notification_path_t *)list_head(notification_paths_queue);
+  if(list_length(notification_paths_queue) == 0) {
+    list_add(notification_paths_queue, path);
+  } else if(path->level < iteration_path->level) {
+    list_push(notification_paths_queue, path);
+  } else if(memcmp((path->reduced_path), (iteration_path->reduced_path), (path->level) * sizeof(uint16_t)) <= 0) {
+    list_push(notification_paths_queue, path);
+  } else {
+    notification_path_t *previous_path = iteration_path;
+    while(iteration_path != NULL) {
+      if(path->level < iteration_path->level) {
+        path->next = iteration_path;
+        previous_path->next = path;
+        return;
+      }
+      if(memcmp((path->reduced_path), (iteration_path->reduced_path), (path->level) * sizeof(uint16_t)) <= 0) {
+        path->next = iteration_path;
+        previous_path->next = path;
+        return;
+      }
+      previous_path = iteration_path;
+      iteration_path = iteration_path->next;
+    }
+    list_add(notification_paths_queue, path);
+  }
+}
+/*---------------------------------------------------------------------------*/
+static void
+remove_notification_path(notification_path_t *path)
+{
+  list_remove(notification_paths_queue, path);
+  memb_free(&notification_memb, path);
+}
+/*---------------------------------------------------------------------------*/
+static void
+notification_queue_remove_policy(uint16_t *reduced_path, uint8_t level)
+{
+  uint8_t path_removed_flag = 0;
+
+  notification_path_t *path_object = NULL;
+  notification_path_t *iteration_path = NULL;
+  notification_path_t *previous = NULL;
+  notification_path_t *next_next = NULL;
+  notification_path_t *path_to_remove = NULL;
+
+  for(iteration_path = (notification_path_t *)list_head(notification_paths_queue); iteration_path != NULL;
+      iteration_path = iteration_path->next) {
+    /* 1. check if there is one event of the same path -> remove it and add the new one */
+    if((level == iteration_path->level) && memcmp(iteration_path->reduced_path, reduced_path, level * sizeof(uint16_t)) == 0) {
+      remove_notification_path(iteration_path);
+      path_object = memb_alloc(&notification_memb);
+      memcpy(path_object->reduced_path, reduced_path, level * sizeof(uint16_t));
+      path_object->level = level;
+      add_notification_path_object_ordered(path_object);
+      return;
+    }
+    /* 2. If there is no event of the same type, look for repeated events of the same resource and remove the oldest one */
+    if(iteration_path->next != NULL && (iteration_path->level == iteration_path->next->level)
+       && (memcmp(iteration_path->reduced_path, (iteration_path->next)->reduced_path, iteration_path->level * sizeof(uint16_t)) == 0)) {
+      path_removed_flag = 1;
+      next_next = iteration_path->next->next;
+      path_to_remove = iteration_path->next;
+      previous = iteration_path;
+    }
+  }
+  /* 3. If there are no events for the same path, we remove a the oldest repeated event of another resource */
+  if(path_removed_flag) {
+    memb_free(&notification_memb, path_to_remove);
+    previous->next = next_next;
+    path_object = memb_alloc(&notification_memb);
+    memcpy(path_object->reduced_path, reduced_path, level * sizeof(uint16_t));
+    path_object->level = level;
+    add_notification_path_object_ordered(path_object);
+  } else {
+    /* 4. If all the events are from different resources, remove the last one */
+    list_chop(notification_paths_queue);
+    path_object = memb_alloc(&notification_memb);
+    memcpy(path_object->reduced_path, reduced_path, level * sizeof(uint16_t));
+    path_object->level = level;
+    add_notification_path_object_ordered(path_object);
+  }
+  return;
+}
+/*---------------------------------------------------------------------------*/
+/* For adding objects to the list in an ordered way, depending on the path*/
+void
+lwm2m_notification_queue_add_notification_path(char *path)
+{
+  notification_path_t *path_object = memb_alloc(&notification_memb);
+  if(path_object == NULL) {
+    LOG_DBG("Could not allocate new notification in the queue\n");
+    return;
+  }
+  reduce_path(path_object, path);
+  if(list_length(notification_paths_queue) >= LWM2M_NOTIFICATION_QUEUE_LENGTH) {
+    /* The queue is full, apply policy to remove */
+    notification_queue_remove_policy(path_object->reduced_path, path_object->level);
+  } else {
+    add_notification_path_object_ordered(path_object);
+  }
+  LOG_DBG("Notification path added to the list: %s\n", path);
+}
+/*---------------------------------------------------------------------------*/
+void
+lwm2m_notification_queue_send_notifications()
+{
+  char path[20];
+  notification_path_t *iteration_path = (notification_path_t *)list_head(notification_paths_queue);
+  notification_path_t *aux = iteration_path;
+
+  while(iteration_path != NULL) {
+    extend_path(iteration_path, path);
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+    if(lwm2m_q_object_get_dynamic_adaptation_flag()) {
+      lwm2m_engine_set_handler_from_notification();
+    }
+#endif
+    LOG_DBG("Sending stored notification with path: %s\n", path);
+    coap_notify_observers_sub(NULL, path);
+    aux = iteration_path;
+    iteration_path = iteration_path->next;
+    remove_notification_path(aux);
+  }
+}
+#endif /* LWM2M_Q_MODE_ENABLED */
+/** @} */

os/services/lwm2m/lwm2m-notification-queue.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2017, RISE SICS AB.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * \addtogroup lwm2m
+ * @{
+ */
+
+/**
+ * \file
+ *         Header file for functions to manage the queue of notifications
+ * \author
+ *         Carlos Gonzalo Peces <carlosgp143@gmail.com>
+ */
+
+#ifndef LWM2M_NOTIFICATION_QUEUE_H
+#define LWM2M_NOTIFICATION_QUEUE_H
+
+#include "contiki.h"
+#include "lwm2m-qmode-conf.h"
+
+#if LWM2M_Q_MODE_ENABLED
+#include <inttypes.h>
+
+typedef struct notification_path {
+  struct notification_path *next;
+  uint16_t reduced_path[3];
+  uint8_t level; /* The depth level of the path: 1. object, 2. object/instance, 3. object/instance/resource */
+} notification_path_t;
+
+void lwm2m_notification_queue_init(void);
+
+/* For adding objects to the list in an ordered way, depending on the path*/
+void lwm2m_notification_queue_add_notification_path(char *path);
+
+void lwm2m_notification_queue_send_notifications();
+
+#endif /* LWM2M_Q_MODE_ENABLED */
+#endif /* LWM2M_NOTIFICATION_QUEUE_H */
+/** @} */

os/services/lwm2m/lwm2m-qmode-conf.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2017, RISE SICS AB.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * \addtogroup lwm2m
+ * @{
+ */
+
+/**
+ * \file
+ *         Queue Mode Configuration Parameters
+ * \author
+ *         Carlos Gonzalo Peces <carlosgp143@gmail.com>
+ */
+
+#ifndef LWM2M_QMODE_CONF_H
+#define LWM2M_QMODE_CONF_H
+
+/* Enable the Queue Mode */
+#ifdef LWM2M_Q_MODE_CONF_ENABLED
+#define LWM2M_Q_MODE_ENABLED LWM2M_Q_MODE_CONF_ENABLED
+#else
+#define LWM2M_Q_MODE_ENABLED 0
+#endif /* LWM2M_Q_MODE_CONF_ENABLED */
+
+/* Default Sleeping Time */
+#ifdef LWM2M_Q_MODE_CONF_DEFAULT_CLIENT_SLEEP_TIME
+#define LWM2M_Q_MODE_DEFAULT_CLIENT_SLEEP_TIME LWM2M_Q_MODE_CONF_DEFAULT_CLIENT_SLEEP_TIME
+#else
+#define LWM2M_Q_MODE_DEFAULT_CLIENT_SLEEP_TIME 10000 /* msec */
+#endif /* LWM2M_Q_MODE_DEFAULT_CLIENT_SLEEPING_TIME */
+
+/* Default Awake Time */
+#ifdef LWM2M_Q_MODE_CONF_DEFAULT_CLIENT_AWAKE_TIME
+#define LWM2M_Q_MODE_DEFAULT_CLIENT_AWAKE_TIME LWM2M_Q_MODE_CONF_DEFAULT_CLIENT_AWAKE_TIME
+#else
+#define LWM2M_Q_MODE_DEFAULT_CLIENT_AWAKE_TIME 5000 /* msec */
+#endif /* LWM2M_Q_MODE_DEFAULT_CLIENT_AWAKE_TIME */
+
+/* Include the possibility to do the dynamic adaptation of the client awake time */
+#ifdef LWM2M_Q_MODE_CONF_INCLUDE_DYNAMIC_ADAPTATION
+#define LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION LWM2M_Q_MODE_CONF_INCLUDE_DYNAMIC_ADAPTATION
+#else
+#define LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION 0 /* not included */
+#endif /* LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION */
+
+/* Default value for the dynamic adaptation flag */
+#ifdef LWM2M_Q_MODE_CONF_DEFAULT_DYNAMIC_ADAPTATION_FLAG
+#define LWM2M_Q_MODE_DEFAULT_DYNAMIC_ADAPTATION_FLAG LWM2M_Q_MODE_CONF_DEFAULT_DYNAMIC_ADAPTATION_FLAG
+#else
+#define LWM2M_Q_MODE_DEFAULT_DYNAMIC_ADAPTATION_FLAG 0 /* disabled */
+#endif /* LWM2M_Q_MODE_DEFAULT_DYNAMIC_ADAPTATION_FLAG */
+
+/* Length of the list of times for the dynamic adaptation */
+#define LWM2M_Q_MODE_DYNAMIC_ADAPTATION_WINDOW_LENGTH 10
+
+#endif /* LWM2M_QMODE_CONF_H */
+/** @} */

os/services/lwm2m/lwm2m-qmode-object.c

@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) 2017, RISE SICS AB.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * \addtogroup lwm2m
+ * @{
+ */
+
+/**
+ * \file
+ *         Implementation of the Contiki OMA LWM2M Queue Object for managing the queue mode
+ * \author
+ *         Carlos Gonzalo Peces <carlosgp143@gmail.com>
+ */
+
+#include "lwm2m-qmode-object.h"
+
+#if LWM2M_Q_MODE_ENABLED
+
+#include "lwm2m-object.h"
+#include "lwm2m-engine.h"
+#include "lwm2m-rd-client.h"
+#include "lib/memb.h"
+#include "lib/list.h"
+#include <string.h>
+
+/* Log configuration */
+#include "coap-log.h"
+#define LOG_MODULE "lwm2m-qmode-object"
+#define LOG_LEVEL  LOG_LEVEL_LWM2M
+
+#define LWM2M_Q_OBJECT_ID 6000
+#define LWM2M_AWAKE_TIME_ID 3000
+#define LWM2M_SLEEP_TIME_ID 3001
+
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+#define LWM2M_DYNAMIC_ADAPTATION_FLAG_ID 3002
+#define UPDATE_WITH_MEAN 0 /* 1-mean time 0-maximum time */
+#endif
+
+static const lwm2m_resource_id_t resources[] =
+{ RW(LWM2M_AWAKE_TIME_ID),
+  RW(LWM2M_SLEEP_TIME_ID),
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+  RW(LWM2M_DYNAMIC_ADAPTATION_FLAG_ID),
+#endif
+};
+
+static uint16_t q_mode_awake_time = LWM2M_Q_MODE_DEFAULT_CLIENT_AWAKE_TIME;
+static uint32_t q_mode_sleep_time = LWM2M_Q_MODE_DEFAULT_CLIENT_SLEEP_TIME;
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+static uint8_t q_mode_dynamic_adaptation_flag = LWM2M_Q_MODE_DEFAULT_DYNAMIC_ADAPTATION_FLAG;
+
+typedef struct time_object {
+  struct times_object *next;
+  uint64_t time;
+} time_object_t;
+
+/* Window to save the times and do the dynamic adaptation of the awake time*/
+MEMB(times_memb, time_object_t, LWM2M_Q_MODE_DYNAMIC_ADAPTATION_WINDOW_LENGTH);
+LIST(time_object_list);
+
+#endif
+/*---------------------------------------------------------------------------*/
+uint16_t
+lwm2m_q_object_get_awake_time()
+{
+  LOG_DBG("Client Awake Time: %d ms\n", (int)q_mode_awake_time);
+  return q_mode_awake_time;
+}
+/*---------------------------------------------------------------------------*/
+static void
+lwm2m_q_object_set_awake_time(uint16_t time)
+{
+  q_mode_awake_time = time;
+}
+/*---------------------------------------------------------------------------*/
+uint32_t
+lwm2m_q_object_get_sleep_time()
+{
+  LOG_DBG("Client Sleep Time: %d ms\n", (int)q_mode_sleep_time);
+  return q_mode_sleep_time;
+}
+/*---------------------------------------------------------------------------*/
+static void
+lwm2m_q_object_set_sleep_time(uint32_t time)
+{
+  q_mode_sleep_time = time;
+}
+/*---------------------------------------------------------------------------*/
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+uint8_t
+lwm2m_q_object_get_dynamic_adaptation_flag()
+{
+  LOG_DBG("Dynamic Adaptation Flag: %d ms\n", (int)q_mode_dynamic_adaptation_flag);
+  return q_mode_dynamic_adaptation_flag;
+}
+/*---------------------------------------------------------------------------*/
+static void
+lwm2m_q_object_set_dynamic_adaptation_flag(uint8_t flag)
+{
+  q_mode_dynamic_adaptation_flag = flag;
+}
+/*---------------------------------------------------------------------------*/
+#if !UPDATE_WITH_MEAN
+static uint64_t
+get_maximum_time()
+{
+  uint64_t max_time = 0;
+  time_object_t *iteration_time = NULL;
+  for(iteration_time = (time_object_t *)list_head(time_object_list); iteration_time;
+      iteration_time = (time_object_t *)iteration_time->next) {
+
+    if(iteration_time->time > max_time) {
+      max_time = iteration_time->time;
+    }
+  }
+  return max_time;
+}
+#endif
+/*---------------------------------------------------------------------------*/
+#if UPDATE_WITH_MEAN
+static uint64_t
+get_mean_time()
+{
+  uint64_t mean_time = 0;
+  time_object_t *iteration_time = NULL;
+  for(iteration_time = (time_object_t *)list_head(time_object_list); iteration_time;
+      (time_object_t *)iteration_time = iteration_time->next) {
+
+    if(mean_time == 0) {
+      mean_time = iteration_time->time;
+    } else {
+      mean_time = (mean_time + iteration_time->time) / 2;
+    }
+  }
+  return mean_time;
+}
+#endif
+/*---------------------------------------------------------------------------*/
+static void
+update_awake_time()
+{
+#if UPDATE_WITH_MEAN
+  uint64_t mean_time = get_mean_time();
+  LOG_DBG("Dynamic Adaptation: updated awake time: %d ms\n", (int)mean_time);
+  lwm2m_q_object_set_awake_time(mean_time + (mean_time >> 1)); /* 50% margin */
+  return;
+#else
+  uint64_t max_time = get_maximum_time();
+  LOG_DBG("Dynamic Adaptation: updated awake time: %d ms\n", (int)max_time);
+  lwm2m_q_object_set_awake_time(max_time + (max_time >> 1)); /* 50% margin */
+  return;
+#endif
+}
+/*---------------------------------------------------------------------------*/
+static void
+remove_time_object(time_object_t *time_object)
+{
+  memb_free(&times_memb, time_object);
+  list_remove(time_object_list, time_object);
+}
+/*---------------------------------------------------------------------------*/
+void
+lwm2m_q_object_add_time_object(uint64_t time)
+{
+  time_object_t *time_object;
+  time_object = memb_alloc(&times_memb);
+  if(time_object != NULL) {
+    time_object->time = time;
+    list_add(time_object_list, time_object);
+  } else {
+    remove_time_object((time_object_t *)list_head(time_object_list));
+    time_object = memb_alloc(&times_memb);
+    time_object->time = time;
+    list_add(time_object_list, time_object);
+  }
+  update_awake_time();
+}
+#endif /* LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION */
+/*---------------------------------------------------------------------------*/
+static lwm2m_status_t
+lwm2m_callback(lwm2m_object_instance_t *object, lwm2m_context_t *ctx)
+{
+  if(ctx->operation == LWM2M_OP_READ) {
+    switch(ctx->resource_id) {
+    case LWM2M_AWAKE_TIME_ID:
+      lwm2m_object_write_int(ctx, (int32_t)q_mode_awake_time);
+      return LWM2M_STATUS_OK;
+    case LWM2M_SLEEP_TIME_ID:
+      lwm2m_object_write_int(ctx, (int32_t)q_mode_sleep_time);
+      return LWM2M_STATUS_OK;
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+    case LWM2M_DYNAMIC_ADAPTATION_FLAG_ID:
+      lwm2m_object_write_int(ctx, (int32_t)q_mode_dynamic_adaptation_flag);
+      return LWM2M_STATUS_OK;
+#endif
+    }
+  } else if(ctx->operation == LWM2M_OP_WRITE) {
+    switch(ctx->resource_id) {
+      int32_t value_read;
+      size_t len;
+
+    case LWM2M_AWAKE_TIME_ID:
+
+      len = lwm2m_object_read_int(ctx, ctx->inbuf->buffer, ctx->inbuf->size,
+                                  &value_read);
+      LOG_DBG("Client Awake Time write request value: %d\n", (int)value_read);
+      if(len == 0) {
+        LOG_WARN("FAIL: could not write awake time\n");
+        return LWM2M_STATUS_WRITE_ERROR;
+      } else {
+        lwm2m_q_object_set_awake_time(value_read);
+        return LWM2M_STATUS_OK;
+      }
+
+    case LWM2M_SLEEP_TIME_ID:
+      len = lwm2m_object_read_int(ctx, ctx->inbuf->buffer, ctx->inbuf->size,
+                                  &value_read);
+      LOG_DBG("Client Sleep Time write request value: %d\n", (int)value_read);
+      if(len == 0) {
+        LOG_WARN("FAIL: could not write sleep time\n");
+        return LWM2M_STATUS_WRITE_ERROR;
+      } else {
+        lwm2m_q_object_set_sleep_time(value_read);
+        return LWM2M_STATUS_OK;
+      }
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+    case LWM2M_DYNAMIC_ADAPTATION_FLAG_ID:
+      len = lwm2m_object_read_int(ctx, ctx->inbuf->buffer, ctx->inbuf->size,
+                                  &value_read);
+      LOG_DBG("Dynamic Adaptation Flag request value: %d\n", (int)value_read);
+      if(len == 0) {
+        LOG_WARN("FAIL: could not write dynamic flag\n");
+        return LWM2M_STATUS_WRITE_ERROR;
+      } else {
+        lwm2m_q_object_set_dynamic_adaptation_flag(value_read);
+        return LWM2M_STATUS_OK;
+      }
+#endif
+    }
+  }
+
+  return LWM2M_STATUS_OPERATION_NOT_ALLOWED;
+}
+/*---------------------------------------------------------------------------*/
+static lwm2m_object_instance_t queue_object = {
+  .object_id = LWM2M_Q_OBJECT_ID,
+  .instance_id = 0,
+  .resource_ids = resources,
+  .resource_count = sizeof(resources) / sizeof(lwm2m_resource_id_t),
+  .resource_dim_callback = NULL,
+  .callback = lwm2m_callback,
+};
+/*---------------------------------------------------------------------------*/
+void
+lwm2m_q_object_init(void)
+{
+  lwm2m_engine_add_object(&queue_object);
+}
+/*---------------------------------------------------------------------------*/
+void
+lwm2m_q_object_send_notifications()
+{
+  lwm2m_notify_object_observers(&queue_object, LWM2M_AWAKE_TIME_ID);
+  lwm2m_notify_object_observers(&queue_object, LWM2M_SLEEP_TIME_ID);
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+  lwm2m_notify_object_observers(&queue_object, LWM2M_DYNAMIC_ADAPTATION_FLAG_ID);
+#endif
+}
+/*---------------------------------------------------------------------------*/
+#endif /* LWM2M_Q_MODE_ENABLED */
+/** @} */
+

os/services/lwm2m/lwm2m-qmode-object.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2017, RISE SICS AB.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * \addtogroup oma-lwm2m
+ * @{
+ */
+
+/**
+ * \file
+ *         Header file for the Contiki OMA LWM2M Queue Object for managing the queue mode
+ * \author
+ *         Carlos Gonzalo Peces <carlosgp143@gmail.com>
+ */
+
+#ifndef LWM2M_Q_OBJECT_H_
+#define LWM2M_Q_OBJECT_H_
+
+#include "contiki.h"
+#include "lwm2m-qmode-conf.h"
+
+#if LWM2M_Q_MODE_ENABLED
+#include <inttypes.h>
+
+uint16_t lwm2m_q_object_get_awake_time();
+uint32_t lwm2m_q_object_get_sleep_time();
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+uint8_t lwm2m_q_object_get_dynamic_adaptation_flag();
+void lwm2m_q_object_add_time_object(uint64_t time);
+#endif
+
+void lwm2m_q_object_send_notifications();
+
+void lwm2m_q_object_init(void);
+
+#endif /* LWM2M_Q_MODE_ENABLED */
+#endif /* LWM2M_Q_OBJECT_H_ */
+/** @} */

os/services/lwm2m/lwm2m-rd-client.c

@@ -41,6 +41,7 @@
  *         Joakim Eriksson <joakime@sics.se>
  *         Niclas Finne <nfi@sics.se>
  *         Joel Hoglund <joel@sics.se>
+ *         Carlos Gonzalo Peces <carlosgp143@gmail.com>
  */
 
 #include "lwm2m-engine.h"
@@ -57,6 +58,10 @@
 #include <stdio.h>
 #include <string.h>
 #include <inttypes.h>
+#if LWM2M_Q_MODE_ENABLED
+#include "lwm2m-qmode-object.h"
+#include "lwm2m-notification-queue.h"
+#endif
 
 #if UIP_CONF_IPV6_RPL
 #include "rpl.h"
@@ -100,6 +105,10 @@ static coap_message_t request[1];      /* This way the message can be treated as
 #define DEREGISTER_SENT   11
 #define DEREGISTER_FAILED 12
 #define DEREGISTERED      13
+#if LWM2M_Q_MODE_ENABLED
+#define Q_MODE_AWAKE 14
+#define Q_MODE_SEND_UPDATE 15
+#endif
 
 #define FLAG_RD_DATA_DIRTY            0x01
 #define FLAG_RD_DATA_UPDATE_TRIGGERED 0x02
@@ -121,6 +130,13 @@ static void (*rd_callback)(coap_request_state_t *state);
 
 static coap_timer_t block1_timer;
 
+#if LWM2M_Q_MODE_ENABLED
+static coap_timer_t q_mode_client_awake_timer; /* Timer to control the client awake time */
+static uint8_t q_mode_client_awake; /* 1 - client is awake, 0 - client is sleeping */
+static uint16_t q_mode_client_awake_time; /* The time to be awake */
+static void q_mode_awake_timer_callback(coap_timer_t *timer); /* Callback for the client awake timer */
+#endif
+
 static void check_periodic_observations();
 static void update_callback(coap_request_state_t *state);
 
@@ -147,7 +163,8 @@ set_rd_data(coap_message_t *request)
 }
 /*---------------------------------------------------------------------------*/
 static void
-prepare_update(coap_message_t *request, int triggered) {
+prepare_update(coap_message_t *request, int triggered)
+{
   coap_init_message(request, COAP_TYPE_CON, COAP_POST, 0);
   coap_set_header_uri_path(request, session_info.assigned_ep);
 
@@ -423,7 +440,16 @@ registration_callback(coap_request_state_t *state)
                state->response->location_path_len);
         session_info.assigned_ep[state->response->location_path_len] = 0;
         /* if we decide to not pass the lt-argument on registration, we should force an initial "update" to register lifetime with server */
+#if LWM2M_Q_MODE_ENABLED
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+        if(lwm2m_q_object_get_dynamic_adaptation_flag()) {
+          lwm2m_engine_set_first_request();
+        }
+#endif
+        lwm2m_rd_client_fsm_execute_q_mode_awake(); /* Avoid 500 ms delay and move directly to the state*/
+#else
         rd_state = REGISTRATION_DONE;
+#endif
         /* remember the last reg time */
         last_update = coap_timer_uptime();
         LOG_DBG_("Done (assigned EP='%s')!\n", session_info.assigned_ep);
@@ -468,8 +494,23 @@ update_callback(coap_request_state_t *state)
       LOG_DBG_("Done!\n");
       /* remember the last reg time */
       last_update = coap_timer_uptime();
+#if LWM2M_Q_MODE_ENABLED
+      /* If it has been waked up by a notification, send the stored notifications in queue */
+      if(lwm2m_engine_is_waked_up_by_notification()) {
+
+        lwm2m_engine_clear_waked_up_by_notification();
+        lwm2m_notification_queue_send_notifications();
+      }
+#if LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION
+      if(lwm2m_q_object_get_dynamic_adaptation_flag()) {
+        lwm2m_engine_set_first_request();
+      }
+#endif /* LWM2M_Q_MODE_INCLUDE_DYNAMIC_ADAPTATION */
+      lwm2m_rd_client_fsm_execute_q_mode_awake(); /* Avoid 500 ms delay and move directly to the state*/
+#else
       rd_state = REGISTRATION_DONE;
       rd_flags &= ~FLAG_RD_DATA_UPDATE_TRIGGERED;
+#endif /* LWM2M_Q_MODE_ENABLED */
     } else {
       /* Possible error response codes are 4.00 Bad request & 4.04 Not Found */
       LOG_DBG_("Failed with code %d. Retrying registration\n",
@@ -516,7 +557,15 @@ periodic_process(coap_timer_t *timer)
   uint64_t now;
 
   /* reschedule the CoAP timer */
+#if LWM2M_Q_MODE_ENABLED
+  /* In Queue Mode, the machine is not executed periodically, but with the awake/sleeping times */
+  if(!((rd_state & 0xF) == 0xE)) {
+    coap_timer_reset(&rd_timer, STATE_MACHINE_UPDATE_INTERVAL);
+  }
+#else
   coap_timer_reset(&rd_timer, STATE_MACHINE_UPDATE_INTERVAL);
+#endif
+
   now = coap_timer_uptime();
 
   LOG_DBG("RD Client - state: %d, ms: %lu\n", rd_state,
@@ -685,6 +734,24 @@ periodic_process(coap_timer_t *timer)
       rd_state = UPDATE_SENT;
     }
     break;
+#if LWM2M_Q_MODE_ENABLED
+  case Q_MODE_AWAKE:
+    LOG_DBG("Queue Mode: Client is AWAKE at %lu\n", (unsigned long)coap_timer_uptime());
+    q_mode_client_awake = 1;
+    q_mode_client_awake_time = lwm2m_q_object_get_awake_time();
+    coap_timer_set(&q_mode_client_awake_timer, q_mode_client_awake_time);
+    break;
+  case Q_MODE_SEND_UPDATE:
+#if !STANDALONE
+    NETSTACK_MAC.on();
+#endif
+    prepare_update(request, rd_flags & FLAG_RD_DATA_UPDATE_TRIGGERED);
+    coap_send_request(&rd_request_state, &session_info.server_ep, request,
+                      update_callback);
+    last_rd_progress = coap_timer_uptime();
+    rd_state = UPDATE_SENT;
+    break;
+#endif
 
   case UPDATE_SENT:
     /* just wait until the callback kicks us to the next state... */
@@ -718,15 +785,26 @@ lwm2m_rd_client_init(const char *ep)
 {
   session_info.ep = ep;
   /* default binding U = UDP, UQ = UDP Q-mode*/
+#if LWM2M_Q_MODE_ENABLED
+  session_info.binding = "UQ";
+  session_info.lifetime = (LWM2M_Q_MODE_DEFAULT_CLIENT_SLEEP_TIME / 1000) * 2; /* Enough margin to ensure that the client is not unregistered (we
+                                                                                * do not know the time it can stay awake)
+                                                                                */
+#else
   session_info.binding = "U";
   if(session_info.lifetime == 0) {
     session_info.lifetime = LWM2M_DEFAULT_CLIENT_LIFETIME;
   }
+#endif
+
   rd_state = INIT;
 
   /* call the RD client periodically */
   coap_timer_set_callback(&rd_timer, periodic_process);
   coap_timer_set(&rd_timer, STATE_MACHINE_UPDATE_INTERVAL);
+#if LWM2M_Q_MODE_ENABLED
+  coap_timer_set_callback(&q_mode_client_awake_timer, q_mode_awake_timer_callback);
+#endif
 }
 /*---------------------------------------------------------------------------*/
 static void
@@ -735,4 +813,55 @@ check_periodic_observations(void)
 /* TODO */
 }
 /*---------------------------------------------------------------------------*/
+/*
+   *Queue Mode Support
+ */
+#if LWM2M_Q_MODE_ENABLED
+/*---------------------------------------------------------------------------*/
+void
+lwm2m_rd_client_restart_client_awake_timer(void)
+{
+  coap_timer_set(&q_mode_client_awake_timer, q_mode_client_awake_time);
+}
+/*---------------------------------------------------------------------------*/
+uint8_t
+lwm2m_rd_client_is_client_awake(void)
+{
+  return q_mode_client_awake;
+}
+/*---------------------------------------------------------------------------*/
+static void
+q_mode_awake_timer_callback(coap_timer_t *timer)
+{
+  /* Timer has expired, no requests has been received, client can go to sleep */
+  LOG_DBG("Queue Mode: Client is SLEEPING at %lu\n", (unsigned long)coap_timer_uptime());
+  q_mode_client_awake = 0;
+#if !STANDALONE
+  /* Turn off the radio and start sleeping timer. LPM will be entered since the radio 
+     and the peripherals are off, and there is a sleep timer started for waking up */
+  NETSTACK_MAC.off();
+  rtimer_arch_schedule(RTIMER_NOW() + ((lwm2m_q_object_get_sleep_time() / 1000) * RTIMER_SECOND));
+#endif
+  rd_state = Q_MODE_SEND_UPDATE;
+  coap_timer_set(&rd_timer, lwm2m_q_object_get_sleep_time());
+}
+/*---------------------------------------------------------------------------*/
+void
+lwm2m_rd_client_fsm_execute_q_mode_awake()
+{
+  coap_timer_stop(&rd_timer);
+  rd_state = Q_MODE_AWAKE;
+  periodic_process(&rd_timer);
+}
+/*---------------------------------------------------------------------------*/
+void
+lwm2m_rd_client_fsm_execute_q_mode_update()
+{
+  coap_timer_stop(&rd_timer);
+  rd_state = Q_MODE_SEND_UPDATE;
+  periodic_process(&rd_timer);
+}
+/*---------------------------------------------------------------------------*/
+#endif
+/*---------------------------------------------------------------------------*/
 /** @} */

os/services/lwm2m/lwm2m-rd-client.h

@@ -40,6 +40,7 @@
  * \author
  *         Joakim Eriksson <joakime@sics.se>
  *         Niclas Finne <nfi@sics.se>
+ *         Carlos Gonzalo Peces <carlosgp143@gmail.com>
  */
 
 #ifndef LWM2M_RD_CLIENT_H_
@@ -52,6 +53,7 @@
 #define LWM2M_RD_CLIENT_DISCONNECTED       5
 
 #include "lwm2m-object.h"
+#include "lwm2m-qmode-conf.h"
 
 struct lwm2m_session_info;
 typedef void (*session_callback_t)(struct lwm2m_session_info *session, int status);
@@ -75,6 +77,13 @@ void lwm2m_rd_client_init(const char *ep);
 
 void lwm2m_rd_client_set_session_callback(session_callback_t cb);
 
+#if LWM2M_Q_MODE_ENABLED
+uint8_t lwm2m_rd_client_is_client_awake(void);
+void lwm2m_rd_client_restart_client_awake_timer(void);
+void lwm2m_rd_client_fsm_execute_q_mode_awake();
+void lwm2m_rd_client_fsm_execute_q_mode_update();
+#endif
+
 #ifndef LWM2M_RD_CLIENT_ASSIGNED_ENDPOINT_MAX_LEN
 #define LWM2M_RD_CLIENT_ASSIGNED_ENDPOINT_MAX_LEN    15
 #endif /* LWM2M_RD_CLIENT_ASSIGNED_ENDPOINT_MAX_LEN */

tests/01-compile-base/Makefile

@@ -15,6 +15,8 @@ libs/data-structures/sky \
 libs/stack-check/sky \
 lwm2m-ipso-objects/native \
 lwm2m-ipso-objects/native:MAKE_WITH_DTLS=1 \
+lwm2m-ipso-objects/native:DEFINES=LWM2M_Q_MODE_CONF_ENABLED=1 \
+lwm2m-ipso-objects/native:DEFINES=LWM2M_Q_MODE_CONF_ENABLED=1,LWM2M_Q_MODE_CONF_INCLUDE_DYNAMIC_ADAPTATION=1\
 rpl-udp/sky \
 rpl-border-router/native \
 rpl-border-router/native:MAKE_ROUTING=MAKE_ROUTING_RPL_CLASSIC \

tests/02-compile-arm-ports-01/Makefile

@@ -43,6 +43,8 @@ coap/coap-example-client/cc2538dk \
 coap/coap-example-server/cc2538dk \
 slip-radio/cc2538dk \
 lwm2m-ipso-objects/cc2538dk \
+lwm2m-ipso-objects/cc2538dk:DEFINES=LWM2M_Q_MODE_CONF_ENABLED=1 \
+lwm2m-ipso-objects/native:DEFINES=LWM2M_Q_MODE_CONF_ENABLED=1,LWM2M_Q_MODE_CONF_INCLUDE_DYNAMIC_ADAPTATION=1\
 multicast/cc2538dk \
 dev/gpio-hal/cc2538dk \
 dev/leds/cc2538dk \

tests/03-compile-arm-ports-02/Makefile

@@ -17,6 +17,8 @@ coap/coap-example-server/zoul \
 multicast/zoul \
 lwm2m-ipso-objects/zoul \
 lwm2m-ipso-objects/zoul:MAKE_WITH_DTLS=1 \
+lwm2m-ipso-objects/zoul:DEFINES=LWM2M_Q_MODE_CONF_ENABLED=1 \
+lwm2m-ipso-objects/zoul:DEFINES=LWM2M_Q_MODE_CONF_ENABLED=1,LWM2M_Q_MODE_CONF_INCLUDE_DYNAMIC_ADAPTATION=1\
 hello-world/zoul \
 sensniff/zoul \
 sensniff/zoul:ZOUL_CONF_SUB_GHZ_SNIFFER=1 \