Merge pull request ARMmbed#1689 from ARMmbed/IOTTHD-2475

Iotthd 2475

Author: Jarkko Paso

nanostack/fhss_ws_extension.h

@@ -98,6 +98,13 @@ extern int ns_fhss_ws_remove_parent(const fhss_api_t *fhss_api, const uint8_t eu
  */
 extern int ns_fhss_set_neighbor_info_fp(const fhss_api_t *fhss_api, fhss_get_neighbor_info *get_neighbor_info);
 
+/**
+ * @brief Set node hop count. Hop count is used to specify TX/RX slot. When hop count is set to 0xFF, TX/RX slots are ignored.
+ * @param fhss_api FHSS instance.
+ * @param hop_count Hop count to be set.
+ * @return 0 on success, -1 on fail.
+ */
+extern int ns_fhss_ws_set_hop_count(const fhss_api_t *fhss_api, const uint8_t hop_count);
 
 #ifdef __cplusplus
 }

source/6LoWPAN/ws/ws_bootstrap.c

@@ -78,6 +78,8 @@ static bool ws_bootstrap_state_wait_rpl(struct protocol_interface_info_entry *cu
 static int8_t ws_bootsrap_event_trig(ws_bootsrap_event_type_e event_type, int8_t interface_id, arm_library_event_priority_e priority, void *event_data);
 
 static bool ws_bootstrap_neighbor_info_request(struct protocol_interface_info_entry *interface, const uint8_t *mac_64, llc_neighbour_req_t * neighbor_buffer, bool request_new);
+static uint16_t ws_bootstrap_route_cost_calculate(protocol_interface_info_entry_t *cur);
+static uint16_t ws_bootstrap_get_min_rank_inc(protocol_interface_info_entry_t *cur);
 
 mac_neighbor_table_entry_t * ws_bootstrap_mac_neighbor_add(struct protocol_interface_info_entry *interface, const uint8_t *src64)
 {
@@ -208,6 +210,9 @@ static int8_t ws_enable_fhss(protocol_interface_info_entry_t *cur)
     if (ns_fhss_set_neighbor_info_fp(fhss_api, &ws_get_neighbor_info)) {
         return -1;
     }
+    if (cur->bootsrap_mode == ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER) {
+        ns_fhss_ws_set_hop_count(fhss_api, 0);
+    }
     cur->ws_info->fhss_api = fhss_api;
     return 0;
 }
@@ -976,6 +981,19 @@ static void ws_bootstrap_ip_stack_activate(protocol_interface_info_entry_t *cur)
     ws_bootstrap_ip_stack_reset(cur);
 }
 
+static void ws_set_fhss_hop(protocol_interface_info_entry_t *cur)
+{
+    uint16_t own_rank = ws_bootstrap_route_cost_calculate(cur);
+    uint16_t rank_inc = ws_bootstrap_get_min_rank_inc(cur);
+    if (own_rank == 0xffff || rank_inc == 0xffff) {
+        return;
+    }
+    // Calculate own hop count. This method gets inaccurate when hop count increases.
+    uint8_t own_hop = (own_rank - rank_inc) / rank_inc;
+    ns_fhss_ws_set_hop_count(cur->ws_info->fhss_api, own_hop);
+}
+
+
 static void ws_bootstrap_rpl_callback(rpl_event_t event, void *handle)
 {
 
@@ -987,6 +1005,8 @@ static void ws_bootstrap_rpl_callback(rpl_event_t event, void *handle)
     if (event == RPL_EVENT_DAO_DONE) {
         // Trigger statemachine check
         cur->bootsrap_state_machine_cnt = 1;
+        ws_set_fhss_hop(cur);
+
     } else if(event == RPL_EVENT_LOCAL_REPAIR_NO_MORE_DIS) {
         /*
          * RPL goes to passive mode, but does not require any extra changed
@@ -1168,22 +1188,40 @@ static void ws_bootstrap_pan_config_solicit(protocol_interface_info_entry_t *cur
 
     ws_llc_asynch_request(cur, &async_req);
 }
-static uint16_t ws_bootstrap_route_cost_calculate(protocol_interface_info_entry_t *cur)
-{
-    // Find selected parent from RPL
 
-    struct rpl_instance *best_instance = NULL;
-    if (!cur->rpl_domain) {
-        return 0xffff;
+static struct rpl_instance *ws_get_rpl_instance(protocol_interface_info_entry_t *cur)
+{
+    if (!cur || !cur->rpl_domain) {
+        return NULL;
     }
+    struct rpl_instance *best_instance = NULL;
     ns_list_foreach(struct rpl_instance, instance, &cur->rpl_domain->instances) {
         best_instance = instance;
         // Select best grounded and lowest rank? But there should be only one really
     }
-    if (!best_instance) {
+    return best_instance;
+}
+
+static uint16_t ws_bootstrap_route_cost_calculate(protocol_interface_info_entry_t *cur)
+{
+    struct rpl_instance *rpl_instance = ws_get_rpl_instance(cur);
+    if (!rpl_instance) {
+        return 0xffff;
+    }
+    return rpl_control_current_rank(rpl_instance);
+}
+
+static uint16_t ws_bootstrap_get_min_rank_inc(protocol_interface_info_entry_t *cur)
+{
+    struct rpl_instance *rpl_instance = ws_get_rpl_instance(cur);
+    if (!rpl_instance) {
+        return 0xffff;
+    }
+    struct rpl_dodag_info_t dodag_info;
+    if (!rpl_control_read_dodag_info(rpl_instance, &dodag_info)) {
         return 0xffff;
     }
-    return rpl_control_current_rank(best_instance);
+    return dodag_info.dag_min_hop_rank_inc;
 }
 
 static void ws_bootstrap_pan_advert(protocol_interface_info_entry_t *cur)

source/Service_Libs/fhss/fhss.c

@@ -79,7 +79,7 @@ fhss_structure_t *fhss_enable(fhss_api_t *fhss_api, const fhss_configuration_t *
         fhss_struct->bs->fhss_configuration.fhss_max_synch_interval = 240;
     }
     ns_list_init(&fhss_struct->fhss_failed_tx_list);
-    fhss_struct->bs->own_hop = 0xff;
+    fhss_struct->own_hop = 0xff;
     fhss_reset(fhss_struct);
 
     if (fhss_beacon_create_tasklet(fhss_struct) < 0) {
@@ -93,7 +93,7 @@ fhss_structure_t *fhss_enable(fhss_api_t *fhss_api, const fhss_configuration_t *
 
 bool fhss_is_synch_root(fhss_structure_t *fhss_structure)
 {
-    if (fhss_structure->bs->own_hop > 0) {
+    if (fhss_structure->own_hop > 0) {
         return false;
     }
     return true;
@@ -241,7 +241,7 @@ static int fhss_update_txrx_slots(fhss_structure_t *fhss_structure)
      *
      */
 
-    if ((fhss_structure->bs->own_hop % 2)) {
+    if ((fhss_structure->own_hop % 2)) {
         tx_slot_up_limit += tx_slot_length;
     }
     while(number_of_tx_slots--)
@@ -367,12 +367,12 @@ static int fhss_sync_with_beacon(fhss_structure_t *fhss_structure,
         configuration->fhss_number_of_superframes = payload->number_of_superframes_per_channel;
         // todo:
         // * payload->time_since_last_beacon
-        uint8_t own_hop_tmp = fhss_structure->bs->own_hop;
+        uint8_t own_hop_tmp = fhss_structure->own_hop;
         if (fhss_is_synch_root(fhss_structure) == false) {
             // my own hop count is one more than the parent's
-            fhss_structure->bs->own_hop = payload->hop_count + 1;
+            fhss_structure->own_hop = payload->hop_count + 1;
         }
-        fhss_stats_update(fhss_structure, STATS_FHSS_HOP_COUNT, fhss_structure->bs->own_hop);
+        fhss_stats_update(fhss_structure, STATS_FHSS_HOP_COUNT, fhss_structure->own_hop);
         fhss_structure->bs->channel_list_counter = payload->channel_list_counter;
         fhss_structure->bs->current_channel_index = payload->channel_index;
         uint8_t mac_address[8];
@@ -427,7 +427,7 @@ static int fhss_sync_with_beacon(fhss_structure_t *fhss_structure,
             fhss_beacon_periodic_start(fhss_structure, fhss_structure->bs->synch_interval + beacon_interval_random);
         }
         // Our hop has changed, needs to inform possible children by sending Beacon
-        if ((own_hop_tmp != 0) && (own_hop_tmp != fhss_structure->bs->own_hop)) {
+        if ((own_hop_tmp != 0) && (own_hop_tmp != fhss_structure->own_hop)) {
             fhss_structure->bs->send_synch_info_on_next_broadcast_channel = true;
         }
         ret_val = 0;
@@ -458,7 +458,7 @@ static uint32_t fhss_get_remaining_tx_time(fhss_structure_t *fhss_structure)
         uint8_t tx_slot_up_limit = tx_slot_length;
         uint16_t superframe_length = fhss_structure->bs->synch_configuration.fhss_superframe_length;
 
-        if ((fhss_structure->bs->own_hop % 2)) {
+        if ((fhss_structure->own_hop % 2)) {
             tx_slot_up_limit += tx_slot_length;
         }
         while(number_of_tx_slots--)
@@ -645,7 +645,7 @@ static int fhss_reset(fhss_structure_t *fhss_structure)
     fhss_structure->bs->current_channel_index = 0;
     fhss_structure->bs->channel_list_counter = 0;
     if (fhss_is_synch_root(fhss_structure) == false) {
-        fhss_structure->bs->own_hop = 0xff;
+        fhss_structure->own_hop = 0xff;
     }
     fhss_structure->bs->tx_allowed = false;
     fhss_structure->bs->synch_interval = (uint32_t) (fhss_structure->bs->fhss_configuration.fhss_max_synch_interval/BEACON_INTERVAL_INIT_DIVIDER) * 1000;
@@ -1031,7 +1031,7 @@ static void fhss_update_channel_callback(fhss_structure_t *fhss_structure)
     // If channel is broadcast channel (true), send event
     if (fhss_change_to_next_channel(fhss_structure) == true) {
         // Only if device is border router
-        if (fhss_structure->bs->own_hop == 0) {
+        if (fhss_structure->own_hop == 0) {
             fhss_trig_event(fhss_structure, FHSS_BROADCAST_CHANNEL);
         }
     }
@@ -1068,7 +1068,7 @@ static void fhss_beacon_build(fhss_structure_t *fhss_structure, uint8_t* dest)
     // should be the case as the superframe length field is also in that range.
     temp_payload.remaining_slots = (uint16_t) fhss_get_remaining_time_to_next_superframe(fhss_structure);
     temp_payload.channel_list_counter = fhss_structure->bs->channel_list_counter;
-    temp_payload.hop_count = fhss_structure->bs->own_hop;
+    temp_payload.hop_count = fhss_structure->own_hop;
     temp_payload.number_of_broadcast_channels = config->fhss_number_of_bc_channels;
     temp_payload.number_of_tx_slots = config->fhss_number_of_tx_slots;
     temp_payload.time_since_last_beacon = 0; // XXX not available yet
@@ -1303,7 +1303,7 @@ int8_t fhss_set_synch_configuration(fhss_structure_t *fhss_structure, const fhss
         return -4;
     }
     fhss_structure->bs->synch_configuration = *fhss_synch_configuration;
-    fhss_structure->bs->own_hop = 0;
+    fhss_structure->own_hop = 0;
     return 0;
 }
 

source/Service_Libs/fhss/fhss.h

@@ -92,7 +92,6 @@ struct fhss_bs
     uint8_t uc_channel_index;
     uint8_t current_superframe;
     uint8_t current_channel_index;
-    uint8_t own_hop;
     uint8_t beacons_received_timer;
     uint8_t broadcast_start_superframe;
     uint8_t synch_infos_sent_counter;

source/Service_Libs/fhss/fhss_common.h

@@ -35,6 +35,7 @@ typedef NS_LIST_HEAD(fhss_failed_tx_t, link) fhss_failed_tx_list_t;
 
 struct fhss_structure
 {
+    uint8_t own_hop;
     uint8_t fhss_resolution_divider;
     uint8_t rx_channel;
     int8_t beacon_tasklet_id;

source/Service_Libs/fhss/fhss_configuration_interface.c

@@ -129,3 +129,12 @@ int ns_fhss_ws_configuration_set(const fhss_api_t *fhss_api, const fhss_ws_confi
     }
     return fhss_ws_configuration_set(fhss_structure, fhss_configuration);
 }
+
+int ns_fhss_ws_set_hop_count(const fhss_api_t *fhss_api, const uint8_t hop_count)
+{
+    fhss_structure_t *fhss_structure = fhss_get_object_with_api(fhss_api);
+    if (!fhss_structure || !fhss_structure->ws) {
+        return -1;
+    }
+    return fhss_ws_set_hop_count(fhss_structure, hop_count);
+}

source/Service_Libs/fhss/fhss_ws.c

@@ -76,6 +76,7 @@ fhss_structure_t *fhss_ws_enable(fhss_api_t *fhss_api, const fhss_ws_configurati
 
     fhss_struct->ws->fhss_configuration = *fhss_configuration;
     fhss_struct->number_of_channels = channel_count;
+    fhss_struct->own_hop = 0xff;
     ns_list_init(&fhss_struct->fhss_failed_tx_list);
     return fhss_struct;
 }
@@ -306,6 +307,33 @@ static bool fhss_check_bad_channel(fhss_structure_t *fhss_structure, uint8_t han
     return true;
 }
 
+static bool fhss_ws_check_tx_allowed(fhss_structure_t *fhss_structure)
+{
+    // Ignore TX/RX slots
+    if (fhss_structure->own_hop == 0xff) {
+        return true;
+    }
+    // Currently on broadcast channel
+    if (fhss_structure->ws->is_on_bc_channel == true) {
+        return true;
+    }
+    uint32_t slot_len_ms = (fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) / (WS_NUMBER_OF_TX_SLOTS * 2);
+    uint32_t remaining_time_ms = fhss_structure->platform_functions.fhss_get_remaining_slots(fhss_broadcast_handler, fhss_structure->fhss_api) / 1000;
+    uint32_t tx_slot_begin = (fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) - (slot_len_ms * (fhss_structure->own_hop & 1));
+    uint32_t rx_slot_begin = tx_slot_begin - slot_len_ms;
+    uint8_t n_o_tx_slots = WS_NUMBER_OF_TX_SLOTS;
+
+    while (n_o_tx_slots--) {
+        if ((remaining_time_ms <= tx_slot_begin) && (remaining_time_ms > rx_slot_begin)) {
+            return true;
+        }
+        tx_slot_begin -= (2*slot_len_ms);
+        rx_slot_begin = tx_slot_begin - slot_len_ms;
+    }
+
+    return false;
+}
+
 static bool fhss_ws_check_tx_conditions_callback(const fhss_api_t *api, bool is_broadcast_addr, uint8_t handle, int frame_type, uint16_t frame_length, uint8_t phy_header_length, uint8_t phy_tail_length)
 {
     (void) handle;
@@ -332,6 +360,10 @@ static bool fhss_ws_check_tx_conditions_callback(const fhss_api_t *api, bool is_
     if (!is_broadcast_addr && (fhss_structure->ws->is_on_bc_channel == true)) {
         return false;
     }
+    // Check TX/RX slot for unicast frames
+    if (!is_broadcast_addr && !fhss_ws_check_tx_allowed(fhss_structure)) {
+        return false;
+    }
     return true;
 }
 
@@ -573,3 +605,9 @@ int fhss_ws_configuration_set(fhss_structure_t *fhss_structure, const fhss_ws_co
     fhss_structure->number_of_channels = channel_count;
     return 0;
 }
+
+int fhss_ws_set_hop_count(fhss_structure_t *fhss_structure, const uint8_t hop_count)
+{
+    fhss_structure->own_hop = hop_count;
+    return 0;
+}

source/Service_Libs/fhss/fhss_ws.h

@@ -21,6 +21,8 @@
  * At least 4 channel retries must be used: (Initial channel + WS_NUMBER_OF_CHANNEL_RETRIES) * MAC attempts = (1+4)*4=20 attempts
  */
 #define WS_NUMBER_OF_CHANNEL_RETRIES    4
+//TODO: Make this configurable
+#define WS_NUMBER_OF_TX_SLOTS           2
 typedef struct fhss_ws fhss_ws_t;
 
 struct fhss_ws
@@ -39,5 +41,6 @@ int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure);
 int fhss_ws_set_parent(fhss_structure_t *fhss_structure, const uint8_t eui64[8], const broadcast_timing_info_t *bc_timing_info);
 int fhss_ws_remove_parent(fhss_structure_t *fhss_structure, const uint8_t eui64[8]);
 int fhss_ws_configuration_set(fhss_structure_t *fhss_structure, const fhss_ws_configuration_t *fhss_configuration);
+int fhss_ws_set_hop_count(fhss_structure_t *fhss_structure, const uint8_t hop_count);
 
 #endif /*FHSS_WS_H_*/

test/nanostack/unittest/service_libs/fhss/test_fhss.c

@@ -118,7 +118,7 @@ static void test_set_fhss_default_configs(void)
     FHSS.rx_channel = DEFAULT_CHANNEL;
     FHSS.fhss_state = FHSS_UNSYNCHRONIZED;
     FHSS.datarate = 250000;
-    FHSS.bs->own_hop = 2;
+    FHSS.own_hop = 2;
 }
 
 static fhss_api_t *test_generate_fhss_api(void)
@@ -454,15 +454,15 @@ bool test_fhss_synch_state_set_callback()
     // Test when device is synch root
     FHSS.fhss_state = FHSS_UNSYNCHRONIZED;
     FHSS.bs->synch_panid = 0xffff;
-    FHSS.bs->own_hop = 0;
+    FHSS.own_hop = 0;
     FHSS.fhss_api->synch_state_set(api, DEFAULT_FHSS_STATE, DEFAULT_PANID);
     if (FHSS.fhss_state != DEFAULT_FHSS_STATE) {
         return false;
     }
     // Test when synch info not found
     FHSS.fhss_state = FHSS_UNSYNCHRONIZED;
     FHSS.bs->synch_panid = 0xffff;
-    FHSS.bs->own_hop = 1;
+    FHSS.own_hop = 1;
     FHSS.fhss_api->synch_state_set(api, DEFAULT_FHSS_STATE, DEFAULT_PANID);
     if (FHSS.fhss_state != FHSS_UNSYNCHRONIZED) {
         return false;
@@ -524,7 +524,7 @@ bool test_fhss_superframe_handler()
     fhss_api_t *api = test_generate_fhss_api();
     // Set superframe handler callback
     enable_fhss_struct();
-    FHSS.bs->own_hop = 0;
+    FHSS.own_hop = 0;
     FHSS.fhss_api->synch_state_set(api, DEFAULT_FHSS_STATE, DEFAULT_PANID);
 
     // Test when FHSS struct not found
@@ -533,7 +533,7 @@ bool test_fhss_superframe_handler()
 
     // Test updating channel for node
     enable_fhss_struct();
-    FHSS.bs->own_hop = 1;
+    FHSS.own_hop = 1;
     FHSS.bs->synch_infos_sent_counter = 1;
     FHSS.bs->current_superframe = FHSS.bs->synch_configuration.fhss_number_of_superframes - 1;
     FHSS.bs->current_channel_index = FHSS.number_of_channels - 1;
@@ -544,7 +544,7 @@ bool test_fhss_superframe_handler()
     }
 
     // Test updating channel for synch root
-    FHSS.bs->own_hop = 0;
+    FHSS.own_hop = 0;
     FHSS.bs->tx_allowed = false;
     fhss_channel_stub.channel_bool_value = true;
     FHSS.bs->synch_infos_sent_counter = 1;
@@ -560,7 +560,7 @@ bool test_fhss_superframe_handler()
     fhss_channel_stub.channel_bool_value = true;
     fhss_callbacks_stub.uint8_value = 1;
     FHSS.bs->send_synch_info_on_next_broadcast_channel = true;
-    FHSS.bs->own_hop = 1;
+    FHSS.own_hop = 1;
     FHSS.bs->tx_allowed = false;
     FHSS.bs->synch_infos_sent_counter = 0;
     FHSS.bs->current_superframe = FHSS.bs->synch_configuration.fhss_number_of_superframes - 2;
@@ -689,13 +689,13 @@ bool test_fhss_set_synch_configuration()
         return false;
     }
     // Test success
-    FHSS.bs->own_hop = 0xff;
+    FHSS.own_hop = 0xff;
     FHSS.number_of_channels = 25;
     fhss_synch_configuration.fhss_number_of_bc_channels = 5;
     fhss_synch_configuration.fhss_number_of_superframes = 4;
     fhss_synch_configuration.fhss_number_of_tx_slots = 1;
     fhss_synch_configuration.fhss_superframe_length = 25000;
-    if ((fhss_set_synch_configuration(&FHSS, &fhss_synch_configuration) != 0) || memcmp(&fhss_synch_configuration, &FHSS.bs->synch_configuration, sizeof(fhss_synch_configuration_t)) || FHSS.bs->own_hop) {
+    if ((fhss_set_synch_configuration(&FHSS, &fhss_synch_configuration) != 0) || memcmp(&fhss_synch_configuration, &FHSS.bs->synch_configuration, sizeof(fhss_synch_configuration_t)) || FHSS.own_hop) {
         return false;
     }