Merge pull request ARMmbed#1807 from ARMmbed/rpl_parent_candidate

RPL, FHSS and Wisun Update

source/6LoWPAN/ws/ws_bbr_api.c

@@ -55,7 +55,7 @@ static void ws_bbr_rpl_root_activate(uint8_t *dodag_prefix, uint8_t *dodag_id)
         .lifetime_unit = 60,
         .objective_code_point = 1, // MRHOF algorithm used
         .authentication = 0,
-        .path_control_size = 0,
+        .path_control_size = 1,
         .dag_max_rank_increase = 2048,
         .min_hop_rank_increase = 128,
         // DIO configuration

source/6LoWPAN/ws/ws_bootstrap.c

@@ -368,8 +368,9 @@ uint16_t ws_etx_read(protocol_interface_info_entry_t *interface, addrtype_t addr
     }
     attribute_index = mac_neighbor->index;
     ws_neighbor_class_entry_t *ws_neighbour = ws_neighbor_class_entry_get(&interface->ws_info->neighbor_storage, attribute_index);
+    etx_storage_t *etx_entry = etx_storage_entry_get(interface->id, attribute_index);
 
-    if (!ws_neighbour ||
+    if (!ws_neighbour || !etx_entry || etx_entry->etx_samples < 1 ||
         !ws_neighbour->candidate_parent) {
         // if RSL value is not good enough candidate parent flag is removed and device not accepted as parent
         //tr_debug("ws_etx_read not valid parent");
@@ -405,6 +406,8 @@ static int8_t ws_bootstrap_up(protocol_interface_info_entry_t *cur)
         tr_error("fhss initialization failed");
         return -3;
     }
+
+
     // Save FHSS api
     cur->ws_info->fhss_api = ns_sw_mac_get_fhss_api(cur->mac_api);
 
@@ -420,6 +423,8 @@ static int8_t ws_bootstrap_up(protocol_interface_info_entry_t *cur)
     cur->ipv6_neighbour_cache.use_eui64_as_slla_in_aro = true;
     /* Omit sending of NA if ARO SUCCESS */
     cur->ipv6_neighbour_cache.omit_aro_success = true;
+    /* Disable NUD Probes */
+    cur->ipv6_neighbour_cache.send_nud_probes = false;
 
     ws_bootstrap_event_discovery_start(cur);
 
@@ -722,7 +727,6 @@ static void ws_bootstrap_pan_config_analyse(struct protocol_interface_info_entry
     ws_neighbor_class_neighbor_unicast_schedule_set(neighbor_info.ws_neighbor, ws_us);
     ws_neighbor_class_neighbor_broadcast_time_info_update(neighbor_info.ws_neighbor, &ws_bt_ie, data->timestamp);
     ws_neighbor_class_neighbor_broadcast_schedule_set(neighbor_info.ws_neighbor, &ws_bs_ie);
-    neighbor_info.neighbor->trusted_device = true;
 
     if (cur->ws_info->configuration_learned) {
         // received version is lower se we need to reset the trickle
@@ -980,24 +984,55 @@ static void ws_neighbor_entry_remove_notify(mac_neighbor_table_entry_t *entry_pt
     ws_bootstrap_neighbor_delete(cur,entry_ptr->index);
 }
 
-
 static bool ws_neighbor_entry_nud_notify(mac_neighbor_table_entry_t *entry_ptr, void *user_data)
 {
     uint32_t time_from_start = entry_ptr->link_lifetime - entry_ptr->lifetime;
     bool activate_nud = false;
-    if ((entry_ptr->link_role == PRIORITY_PARENT_NEIGHBOUR || entry_ptr->link_role == SECONDARY_PARENT_NEIGHBOUR)  && time_from_start > WS_NEIGHBOR_NUD_TIMEOUT) {
-        if (entry_ptr->trusted_device) {
+    protocol_interface_info_entry_t *cur = user_data;
+
+    ws_neighbor_class_entry_t *ws_neighbor = ws_neighbor_class_entry_get(&cur->ws_info->neighbor_storage, entry_ptr->index);
+    etx_storage_t *etx_entry = etx_storage_entry_get(cur->id, entry_ptr->index);
+
+    if (!entry_ptr->trusted_device || !ws_neighbor || !etx_entry) {
+        return false;
+    }
+
+    if (time_from_start > WS_NEIGHBOR_NUD_TIMEOUT) {
+
+        if (time_from_start > WS_NEIGHBOR_NUD_TIMEOUT * 1.5) {
             activate_nud = true;
+        } else {
+            uint16_t switch_prob = randLIB_get_random_in_range(0, WS_NUD_RANDOM_SAMPLE_LENGTH -1);
+            //Take Random from time WS_NEIGHBOR_NUD_TIMEOUT - WS_NEIGHBOR_NUD_TIMEOUT*1.5
+            if (switch_prob < WS_NUD_RANDOM_COMPARE) {
+                activate_nud = true;
+            }
+        }
+    } else if (etx_entry->etx_samples < WS_NEIGBOR_ETX_SAMPLE_MAX) {
+        //Take Random number for trig a prope.
+        //ETX Sample 0: random 1-8
+        //ETX Sample 1: random 2-16
+        //ETX Sample 2: random 4-32
+        uint32_t probe_period = WS_PROBE_INIT_BASE_SECONDS << etx_entry->etx_samples;
+        uint32_t time_block = 1 << etx_entry->etx_samples;
+        if (time_from_start >= probe_period) {
+            tr_debug("Link Probe test %u Sample trig", etx_entry->etx_samples);
+            activate_nud = true;
+        } else if (time_from_start > time_block) {
+            uint16_t switch_prob = randLIB_get_random_in_range(0, probe_period -1);
+            //Take Random from time WS_NEIGHBOR_NUD_TIMEOUT - WS_NEIGHBOR_NUD_TIMEOUT*1.5
+            if (switch_prob < 2) {
+                tr_debug("Link Probe test with jitter %u, sample %u", time_from_start, etx_entry->etx_samples);
+                activate_nud = true;
+            }
         }
-
     }
+
     if (!activate_nud) {
         return false;
     }
 
 
-    protocol_interface_info_entry_t *cur = user_data;
-
     uint8_t ll_target[16];
     memcpy(ll_target, ADDR_LINK_LOCAL_PREFIX, 8);
     memcpy(ll_target + 8, entry_ptr->mac64, 8);

source/6LoWPAN/ws/ws_common_defines.h

@@ -184,9 +184,19 @@ typedef struct ws_bs_ie {
 
 #define WS_FAN_VERSION_1_0 1
 
-#define WS_NEIGHBOR_LINK_TIMEOUT 240
+#define WS_NEIGHBOR_LINK_TIMEOUT 2200
 #define WS_NEIGHBOR_NUD_TIMEOUT WS_NEIGHBOR_LINK_TIMEOUT / 2
 
+#define WS_NEIGBOR_ETX_SAMPLE_MAX 3
+
+#define WS_PROBE_INIT_BASE_SECONDS 8
+
+#define WS_NUD_RAND_PROBABILITY 1
+
+#define WS_NUD_RANDOM_SAMPLE_LENGTH WS_NEIGHBOR_NUD_TIMEOUT / 2
+
+#define WS_NUD_RANDOM_COMPARE (WS_NUD_RAND_PROBABILITY*WS_NUD_RANDOM_SAMPLE_LENGTH) / 100
+
 /*
  * Threshold (referenced to DEVICE_MIN_SENS) above which a neighbor node may be considered for inclusion into candidate parent set
  */

source/6LoWPAN/ws/ws_neighbor_class.c

@@ -27,7 +27,7 @@
 
 #ifdef HAVE_WS
 
-#define RSL_UNITITIALIZED 0x7fff
+
 #define TRACE_GROUP "wsne"
 
 

source/6LoWPAN/ws/ws_neighbor_class.h

@@ -21,6 +21,8 @@
 #include "fhss_ws_extension.h"
 #include "6LoWPAN/ws/ws_common_defines.h"
 
+#define RSL_UNITITIALIZED 0x7fff
+
 typedef struct ws_neighbor_class_entry {
     fhss_ws_neighbor_timing_info_t   fhss_data;
     uint16_t rsl_in;                                       /*!< RSL EWMA heard from neighbour*/

source/MAC/IEEE802_15_4/mac_fhss_callbacks.c

@@ -82,7 +82,7 @@ int mac_set_channel(const fhss_api_t *fhss_api, uint8_t channel_number)
     if (!mac_setup) {
         return -1;
     }
-    if (mac_setup->mac_ack_tx_active || (mac_setup->active_pd_data_request && mac_setup->active_pd_data_request->asynch_request)) {
+    if (mac_setup->mac_ack_tx_active || (mac_setup->active_pd_data_request && (mac_setup->active_pd_data_request->asynch_request || mac_setup->timer_mac_event == MAC_TIMER_ACK))) {
         return -1;
     }
     return mac_mlme_rf_channel_change(mac_setup, channel_number);

source/MAC/IEEE802_15_4/mac_mcps_sap.c

@@ -1053,6 +1053,14 @@ static void mac_data_interface_frame_handler(mac_pre_parsed_frame_t *buf)
 
 }
 
+static void mac_mcps_asynch_finish(protocol_interface_rf_mac_setup_s *rf_mac_setup, mac_pre_build_frame_t *buffer)
+{
+    if (buffer->asynch_request && rf_mac_setup->fhss_api) {
+        // Must return to scheduled channel after asynch process by calling TX done
+        rf_mac_setup->fhss_api->data_tx_done(rf_mac_setup->fhss_api, false, true, buffer->msduHandle);
+    }
+}
+
 void mac_mcps_trig_buffer_from_queue(protocol_interface_rf_mac_setup_s *rf_mac_setup)
 {
     if (!rf_mac_setup) {
@@ -1075,6 +1083,7 @@ void mac_mcps_trig_buffer_from_queue(protocol_interface_rf_mac_setup_s *rf_mac_s
             mac_data_request_init(rf_mac_setup, buffer);
             if (mcps_pd_data_request(rf_mac_setup, buffer) != 0) {
                 rf_mac_setup->active_pd_data_request = NULL;
+                mac_mcps_asynch_finish(rf_mac_setup, buffer);
                 mcps_data_confirm_handle(rf_mac_setup, buffer, NULL);
             } else {
                 return;
@@ -1120,14 +1129,12 @@ static void mac_pd_data_confirm_handle(protocol_interface_rf_mac_setup_s *rf_mac
         mac_pre_build_frame_t *buffer = rf_mac_setup->active_pd_data_request;
         if (mac_data_request_confirmation_finnish(rf_mac_setup, buffer) ) {
             rf_mac_setup->active_pd_data_request = NULL;
-            if (buffer->asynch_request && rf_mac_setup->fhss_api) {
-                // Must return to scheduled channel after asynch process by calling TX done
-                rf_mac_setup->fhss_api->data_tx_done(rf_mac_setup->fhss_api, false, true, buffer->msduHandle);
-            }
+            mac_mcps_asynch_finish(rf_mac_setup, buffer);
             mcps_data_confirm_handle(rf_mac_setup, buffer, NULL);
         } else {
             if (mcps_pd_data_request(rf_mac_setup, buffer) != 0) {
                 rf_mac_setup->active_pd_data_request = NULL;
+                mac_mcps_asynch_finish(rf_mac_setup, buffer);
                 mcps_data_confirm_handle(rf_mac_setup, buffer, NULL);
             } else {
                 return;
@@ -1155,10 +1162,6 @@ static void mac_pd_data_ack_handler(mac_pre_parsed_frame_t *buf) {
         }
 
         rf_mac_setup->active_pd_data_request = NULL;
-        if (buffer->asynch_request && rf_mac_setup->fhss_api) {
-            // Must return to scheduled channel after asynch process by calling TX done
-            rf_mac_setup->fhss_api->data_tx_done(rf_mac_setup->fhss_api, false, true, buffer->msduHandle);
-        }
         mcps_data_confirm_handle(rf_mac_setup, buffer, buf);
         mcps_sap_pre_parsed_frame_buffer_free(buf);
 
@@ -1423,7 +1426,7 @@ static void mcps_data_confirm_handle(protocol_interface_rf_mac_setup_s *rf_ptr,
     sw_mac_stats_update(rf_ptr, STAT_MAC_TX_CCA_ATT, rf_ptr->mac_tx_status.cca_cnt);
     sw_mac_stats_update(rf_ptr, STAT_MAC_TX_RETRY, rf_ptr->mac_tx_status.retry);
     mcps_data_conf_t confirm;
-    if (rf_ptr->fhss_api) {
+    if (rf_ptr->fhss_api && !buffer->asynch_request) {
         // FHSS checks if this failed buffer needs to be pushed back to TX queue and retransmitted
         if ((rf_ptr->mac_tx_result == MAC_TX_FAIL) || (rf_ptr->mac_tx_result == MAC_CCA_FAIL)) {
             if (rf_ptr->fhss_api->data_tx_fail(rf_ptr->fhss_api, buffer->msduHandle, mac_convert_frame_type_to_fhss(buffer->fcf_dsn.frametype)) == true) {
@@ -1989,7 +1992,7 @@ static mac_pre_build_frame_t * mcps_sap_pd_req_queue_read(protocol_interface_rf_
     // With FHSS, check TX conditions
     if (rf_mac_setup->fhss_api) {
         while (buffer) {
-            if ((flush == true) || (rf_mac_setup->fhss_api->check_tx_conditions(rf_mac_setup->fhss_api, !mac_is_ack_request_set(buffer),
+            if (buffer->asynch_request || (flush == true) || (rf_mac_setup->fhss_api->check_tx_conditions(rf_mac_setup->fhss_api, !mac_is_ack_request_set(buffer),
                     buffer->msduHandle, mac_convert_frame_type_to_fhss(buffer->fcf_dsn.frametype), buffer->mac_payload_length,
                     rf_mac_setup->dev_driver->phy_driver->phy_header_length, rf_mac_setup->dev_driver->phy_driver->phy_tail_length) == true)) {
                 break;

source/MAC/IEEE802_15_4/mac_pd_sap.c

@@ -387,6 +387,10 @@ static int8_t mac_data_interface_tx_done_cb(protocol_interface_rf_mac_setup_s *r
 
     if (rf_ptr->mac_ack_tx_active) {
         rf_ptr->mac_ack_tx_active = false;
+        if (rf_ptr->fhss_api) {
+            //SET tx completed false because ack isnot never queued
+            rf_ptr->fhss_api->data_tx_done(rf_ptr->fhss_api, false, false, 0xff);
+        }
         if (rf_ptr->active_pd_data_request) {
 
             if (rf_ptr->active_pd_data_request->fcf_dsn.securityEnabled) {
@@ -464,7 +468,7 @@ static int8_t mac_data_interface_tx_done_cb(protocol_interface_rf_mac_setup_s *r
 static int8_t mac_data_interface_tx_done_by_ack_cb(protocol_interface_rf_mac_setup_s *rf_ptr, mac_pre_parsed_frame_t *buf)
 {
 
-    if (!rf_ptr->macRfRadioTxActive) {
+    if (!rf_ptr->macRfRadioTxActive || !rf_ptr->active_pd_data_request || rf_ptr->active_pd_data_request->fcf_dsn.DSN != buf->fcf_dsn.DSN) {
         return -1;
     }
 
@@ -479,9 +483,7 @@ static int8_t mac_data_interface_tx_done_by_ack_cb(protocol_interface_rf_mac_set
     mcps_sap_pd_ack(buf);
 
     if (rf_ptr->fhss_api) {
-        if (rf_ptr->active_pd_data_request->asynch_request == false) {
-            rf_ptr->fhss_api->data_tx_done(rf_ptr->fhss_api, false, true, rf_ptr->active_pd_data_request->msduHandle);
-        }
+        rf_ptr->fhss_api->data_tx_done(rf_ptr->fhss_api, false, true, rf_ptr->active_pd_data_request->msduHandle);
     }
     return 0;
 }

source/RPL/rpl_structures.h

@@ -134,6 +134,7 @@ typedef struct rpl_dao_non_root
     uint32_t refresh_timer;             /* Refresh timer (seconds) - 0xFFFFFFFF = infinite, 0 = not yet set */
 } rpl_dao_non_root_t;
 
+
 /* Descriptor for a RPL DAO target */
 struct rpl_dao_target
 {

source/RPL/rpl_upward.c

@@ -1555,6 +1555,7 @@ void rpl_instance_slow_timer(rpl_instance_t *instance, uint16_t seconds)
     }
 }
 
+
 void rpl_upward_dio_timer(rpl_instance_t *instance, uint16_t ticks)
 {
     rpl_dodag_version_t *dodag_version = instance->current_dodag_version;

source/Service_Libs/etx/etx.c

@@ -81,6 +81,9 @@ void etx_transm_attempts_update(int8_t interface_id, uint8_t attempts, bool succ
     if (!entry) {
         return;
     }
+    if (entry->etx_samples < 7) {
+        entry->etx_samples++;
+    }
 
     accumulated_failures = entry->accumulated_failures;
 

source/Service_Libs/etx/etx.h

@@ -38,6 +38,7 @@ typedef struct etx_storage_s {
     unsigned        accumulated_failures: 5;
     unsigned        tmp_etx: 1;
     unsigned        linkIdr: 4;
+    unsigned        etx_samples: 3;
 } etx_storage_t;
 
 /**

source/Service_Libs/fhss/fhss_ws.c

@@ -652,10 +652,14 @@ int fhss_ws_set_parent(fhss_structure_t *fhss_structure, const uint8_t eui64[8],
         return -1;
     }
     platform_enter_critical();
+    fhss_structure->platform_functions.fhss_timer_stop(fhss_broadcast_handler, fhss_structure->fhss_api);
     uint32_t time_from_reception_ms = (fhss_structure->callbacks.read_timestamp(fhss_structure->fhss_api) - bc_timing_info->bt_rx_timestamp)/1000;
     uint32_t true_bc_interval_offset = (bc_timing_info->broadcast_interval_offset + time_from_reception_ms) % bc_timing_info->broadcast_interval;
     uint32_t timeout = ((bc_timing_info->broadcast_interval-true_bc_interval_offset)*1000);
-    fhss_structure->ws->is_on_bc_channel = false;
+
+    if (fhss_structure->ws->is_on_bc_channel) {
+        timeout -= ((bc_timing_info->broadcast_interval - bc_timing_info->broadcast_dwell_interval) *1000);
+    }
     fhss_start_timer(fhss_structure, timeout, fhss_broadcast_handler);
     uint16_t slots_since_reception = (bc_timing_info->broadcast_interval_offset + time_from_reception_ms) / bc_timing_info->broadcast_interval;
     // TODO: Calculate drift error

source/Service_Libs/mac_neighbor_table/mac_neighbor_table.c

@@ -192,6 +192,9 @@ void mac_neighbor_table_neighbor_connected(mac_neighbor_table_t *table_class, ma
 void mac_neighbor_table_trusted_neighbor(mac_neighbor_table_t *table_class, mac_neighbor_table_entry_t *neighbor_entry, bool trusted_device)
 {
     (void)table_class;
+    if (!neighbor_entry->trusted_device && trusted_device) {
+        neighbor_entry->lifetime = neighbor_entry->link_lifetime;
+    }
     neighbor_entry->trusted_device = trusted_device;
 }
 

test/nanostack/unittest/service_libs/mac_neighbor_table/test_mac_neighbor_table.c

@@ -133,19 +133,19 @@ bool test_mac_neighbor_table_use()
 
     mac_neighbor_table_trusted_neighbor(entry, mac_entry3, true);
 
-    if (!mac_entry3->trusted_device) {
+    if (!mac_entry3->trusted_device && mac_entry3->lifetime != 240) {
         return false;
     }
 
     mac_neighbor_table_neighbor_timeout_update(entry, 31);
 
-    if (mac_entry3->lifetime != 199 || mac_entry2->lifetime != 199 || mac_entry1->lifetime != 199) {
+    if (mac_entry3->lifetime != 209 || mac_entry2->lifetime != 199 || mac_entry1->lifetime != 199) {
         return false;
     }
 
     mac_neighbor_table_neighbor_timeout_update(entry, 170);
 
-    if (mac_entry3->lifetime != 29 || mac_entry2->lifetime != 29 || mac_entry1->lifetime != 29) {
+    if (mac_entry3->lifetime != 39 || mac_entry2->lifetime != 29 || mac_entry1->lifetime != 29) {
             return false;
         }