Wi-SUN Timing configuration is selected based on network size and dat…

…a rate

Network size and data rate are used in combination when selecting
the timing configuration used by the Wi-SUN stack.

Faster data rate allows more devices to use same timing settings.
Added different device amount limits for
50kbs, 150kbs, 300kbs, 600kbs data rates.

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## Release vxx.x.x
 
 ### Features
+* Wi-SUN timing parameters are selected based on Data rate and network size.
 *
 
 ### Changes

source/6LoWPAN/ws/ws_bbr_api.c

@@ -176,12 +176,12 @@ static void ws_bbr_rpl_version_timer_start(protocol_interface_info_entry_t *cur,
         //stable version for RPL so slow timer update is ok
         cur->ws_info->rpl_version_timer = RPL_VERSION_LIFETIME;
     } else {
-        if (cur->ws_info->cfg->gen.network_size <= NETWORK_SIZE_SMALL) {
-            // handles also NETWORK_SIZE_CERTIFICATE
+        if (ws_cfg_network_config_get(cur) <= CONFIG_SMALL) {
+            // Also handles CONFIG_CERTIFICATE
             cur->ws_info->rpl_version_timer = RPL_VERSION_LIFETIME_RESTART_SMALL;
-        } else if (cur->ws_info->cfg->gen.network_size <= NETWORK_SIZE_MEDIUM) {
+        } else if (ws_cfg_network_config_get(cur) <= CONFIG_MEDIUM) {
             cur->ws_info->rpl_version_timer = RPL_VERSION_LIFETIME_RESTART_MEDIUM;
-        } else if (cur->ws_info->cfg->gen.network_size <= NETWORK_SIZE_LARGE) {
+        } else if (ws_cfg_network_config_get(cur) <= CONFIG_LARGE) {
             cur->ws_info->rpl_version_timer = RPL_VERSION_LIFETIME_RESTART_LARGE;
         } else  {
             cur->ws_info->rpl_version_timer = RPL_VERSION_LIFETIME_RESTART_EXTRA_LARGE;

source/6LoWPAN/ws/ws_bootstrap.c

@@ -1550,10 +1550,10 @@ static void ws_bootstrap_pan_advertisement_solicit_analyse(struct protocol_inter
      */
     trickle_consistent_heard(&cur->ws_info->trickle_pan_advertisement_solicit);
     /*
-     *  Optimized PAN discovery to select faster the parent if we hear solicit from someone else
+     *  Optimized PAN discovery to select the parent faster if we hear solicit from someone else
      */
 
-    if (ws_bootstrap_state_discovery(cur)  && cur->ws_info->cfg->gen.network_size <= NETWORK_SIZE_MEDIUM &&
+    if (ws_bootstrap_state_discovery(cur)  && ws_cfg_network_config_get(cur) <= CONFIG_MEDIUM &&
             cur->bootsrap_state_machine_cnt > cur->ws_info->trickle_params_pan_discovery.Imin * 2) {
 
         cur->bootsrap_state_machine_cnt = cur->ws_info->trickle_params_pan_discovery.Imin + randLIB_get_random_in_range(0, cur->ws_info->trickle_params_pan_discovery.Imin);
@@ -2044,7 +2044,7 @@ static void ws_neighbor_entry_remove_notify(mac_neighbor_table_entry_t *entry_pt
 
 static uint32_t ws_probe_init_time_get(protocol_interface_info_entry_t *cur)
 {
-    if (cur->ws_info->cfg->gen.network_size <= NETWORK_SIZE_SMALL) {
+    if (ws_cfg_network_config_get(cur) <= CONFIG_SMALL) {
         return WS_SMALL_PROBE_INIT_BASE_SECONDS;
     }
 
@@ -3084,9 +3084,9 @@ static void ws_bootstrap_rpl_scan_start(protocol_interface_info_entry_t *cur)
     tr_debug("Start RPL learn");
     // routers wait until RPL root is contacted
     ws_bootstrap_state_change(cur, ER_RPL_SCAN);
-    //For Large network and medium shuold do passive scan
-    if (cur->ws_info->cfg->gen.network_size > NETWORK_SIZE_SMALL) {
-        // Set timeout for check to 30 -60 seconds
+    //For Large network and medium should do passive scan
+    if (ws_cfg_network_config_get(cur) > CONFIG_SMALL) {
+        // Set timeout for check to 30 - 60 seconds
         cur->bootsrap_state_machine_cnt = randLIB_get_random_in_range(WS_RPL_DIS_INITIAL_TIMEOUT / 2, WS_RPL_DIS_INITIAL_TIMEOUT);
     }
     /* While in Join State 4, if a non Border Router determines it has been unable to communicate with the PAN Border

source/6LoWPAN/ws/ws_cfg_settings.c

@@ -79,6 +79,32 @@ typedef union {
     ws_sec_prot_cfg_t sec_prot;
 } ws_cfgs_t;
 
+
+typedef struct cfg_devices_in_config {
+    uint8_t max_for_small;
+    uint8_t max_for_medium;
+    uint8_t max_for_large;
+    uint8_t max_for_xlarge;
+} cfg_devices_in_config_t;
+
+/* Table for amount of devices that certain configuration should be used
+ *
+ * larger data rates allow more devices to be used with faster settings.
+ *
+ * For example with network the size of 2000 devices we use
+ * Xlrage configuration with 50kbs data rate.
+ * Large configuration with 300kbs data rate.
+ * and with 600kbs data rate it is possible to use medium network settings.
+ *
+ */
+const cfg_devices_in_config_t devices_by_datarate[] = {
+    { 1,  4, 10,  25}, // Configuration for 50 -100kbs
+    { 1,  8, 15,  25}, // Configuration for 150kbs - 200kbs
+    { 2, 15, 25,  50}, // Configuration for 300kbs
+    { 3, 20, 40, 100}, // Configuration for 600kbs - 2400kbs
+};
+
+
 static int8_t ws_cfg_to_get(ws_cfgs_t **cfg, ws_cfgs_t *new_cfg, ws_cfg_validate valid_cb, ws_cfgs_t *external_cfg, uint8_t *cfg_flags, uint8_t *flags);
 
 static void ws_cfg_network_size_config_set_small(ws_cfg_nw_size_t *cfg);
@@ -258,13 +284,13 @@ int8_t ws_cfg_network_size_set(protocol_interface_info_entry_t *cur, ws_gen_cfg_
 
     ws_cfg_network_size_config_set_size set_function = NULL;
 
-    if (cfg->network_size == NETWORK_SIZE_CERTIFICATE) {
+    if (ws_cfg_network_config_get(cur) == CONFIG_CERTIFICATE) {
         set_function = ws_cfg_network_size_config_set_certificate;
-    } else if (cfg->network_size <= NETWORK_SIZE_SMALL || cfg->network_size == NETWORK_SIZE_AUTOMATIC) {
+    } else if (ws_cfg_network_config_get(cur) == CONFIG_SMALL || cfg->network_size == NETWORK_SIZE_AUTOMATIC) {
         set_function = ws_cfg_network_size_config_set_small;
-    } else if (cfg->network_size <=  NETWORK_SIZE_MEDIUM) {
+    } else if (ws_cfg_network_config_get(cur) == CONFIG_MEDIUM) {
         set_function = ws_cfg_network_size_config_set_medium;
-    } else if (cfg->network_size <=  NETWORK_SIZE_LARGE) {
+    } else if (ws_cfg_network_config_get(cur) == CONFIG_LARGE) {
         set_function = ws_cfg_network_size_config_set_large;
     } else {
         set_function = ws_cfg_network_size_config_set_xlarge;
@@ -360,6 +386,47 @@ int8_t ws_cfg_network_size_configure(protocol_interface_info_entry_t *cur, uint1
     return CFG_SETTINGS_OK;
 }
 
+cfg_network_size_type_e ws_cfg_network_config_get(protocol_interface_info_entry_t *cur)
+{
+    // Get size of the network Amount of devices in the network
+    // Get the data rate of the network
+    // Adjust the configuration type based on the network size and data rate
+
+    (void)cur;
+
+    ws_gen_cfg_t cfg;
+    if (ws_cfg_gen_get(&cfg, NULL) < 0) {
+        return CONFIG_SMALL;
+    }
+    ws_phy_cfg_t phy_cfg;
+    if (ws_cfg_phy_get(&phy_cfg, NULL) < 0) {
+        return CONFIG_SMALL;
+    }
+
+    uint32_t data_rate = ws_get_datarate_using_operating_mode(phy_cfg.operating_mode);
+    uint8_t index;
+    if (data_rate < 150000) {
+        index = 0;
+    } else if (data_rate < 300000) {
+        index = 1;
+    } else if (data_rate < 600000) {
+        index = 2;
+    } else {
+        index = 3;
+    }
+
+    if (cfg.network_size == NETWORK_SIZE_CERTIFICATE) {
+        return CONFIG_CERTIFICATE;
+    } else if (cfg.network_size <= devices_by_datarate[index].max_for_small) {
+        return CONFIG_SMALL;
+    } else if (cfg.network_size <= devices_by_datarate[index].max_for_medium) {
+        return CONFIG_MEDIUM;
+    } else if (cfg.network_size <= devices_by_datarate[index].max_for_large) {
+        return CONFIG_LARGE;
+    }
+    return CONFIG_XLARGE;
+}
+
 
 static void ws_cfg_network_size_config_set_small(ws_cfg_nw_size_t *cfg)
 {

source/6LoWPAN/ws/ws_cfg_settings.h

@@ -148,11 +148,23 @@ typedef struct ws_cfg_s {
 #define CFG_SETTINGS_ERROR_SEC_TIMER_CONF    -17   /**< Security timers configuration error */
 #define CFG_SETTINGS_ERROR_SEC_PROT_CONF     -18   /**< Security protocols configuration error */
 
+/** Network configuration parameters sets for different network sizes*/
+typedef enum {
+    CONFIG_CERTIFICATE = 0,  ///< Configuration used in Wi-SUN Certification
+    CONFIG_SMALL = 1,        ///< Small networks that can utilize fast recovery
+    CONFIG_MEDIUM = 2,       ///< Medium networks that can form quickly but require balance on load
+    CONFIG_LARGE = 3,        ///< Large networks that needs to throttle joining and maintenance
+    CONFIG_XLARGE = 4        ///< Xlarge networks with very slow joining, maintenance and recovery profile
+} cfg_network_size_type_e;
+
+
 int8_t ws_cfg_settings_init(void);
 int8_t ws_cfg_settings_default_set(void);
 int8_t ws_cfg_settings_interface_set(protocol_interface_info_entry_t *cur);
 int8_t ws_cfg_network_size_configure(protocol_interface_info_entry_t *cur, uint16_t network_size);
 
+cfg_network_size_type_e ws_cfg_network_config_get(protocol_interface_info_entry_t *cur);
+
 int8_t ws_cfg_network_size_get(ws_gen_cfg_t *cfg, uint8_t *flags);
 int8_t ws_cfg_network_size_validate(ws_gen_cfg_t *cfg, ws_gen_cfg_t *new_cfg);
 int8_t ws_cfg_network_size_set(protocol_interface_info_entry_t *cur, ws_gen_cfg_t *cfg, ws_gen_cfg_t *new_cfg, uint8_t *flags);

source/6LoWPAN/ws/ws_common.c

@@ -564,18 +564,13 @@ bool ws_common_negative_aro_mark(protocol_interface_info_entry_t *interface, con
 uint32_t ws_common_latency_estimate_get(protocol_interface_info_entry_t *cur)
 {
     uint32_t latency = 0;
-    uint8_t network_size = cur->ws_info->cfg->gen.network_size;
 
-    if (network_size == NETWORK_SIZE_AUTOMATIC) {
-        network_size = cur->ws_info->pan_information.pan_size / 100;
-    }
-
-    if (network_size <= NETWORK_SIZE_SMALL) {
-        // handles also NETWORK_SIZE_CERTIFICATE
+    if (ws_cfg_network_config_get(cur) <= CONFIG_SMALL) {
+        // Also has the certificate settings
         latency = 5000;
-    } else if (network_size <= NETWORK_SIZE_MEDIUM) {
+    } else if (ws_cfg_network_config_get(cur) <= CONFIG_MEDIUM) {
         latency = 10000;
-    } else if (network_size <= NETWORK_SIZE_LARGE) {
+    } else if (ws_cfg_network_config_get(cur) <= CONFIG_LARGE) {
         latency = 20000;
     } else  {
         latency = 30000;

test/nanostack/unittest/stub/ws_common_stub.c

@@ -95,6 +95,11 @@ uint32_t ws_common_datarate_get(protocol_interface_info_entry_t *cur)
     return 0;
 }
 
+uint32_t ws_get_datarate_using_operating_mode(uint8_t operating_mode)
+{
+    return 150000;
+}
+
 uint32_t ws_common_network_size_estimate_get(protocol_interface_info_entry_t *cur)
 {
     return 0;