FHSS: Set neighbor info get function

- Use neighbor info to find destination channel

Author: Jarkko Paso

nanostack/fhss_ws_extension.h

@@ -36,6 +36,7 @@ extern "C" {
 typedef struct unicast_timing_info {
     unsigned unicast_channel_function:3;        /**< Unicast schedule channel function */
     uint8_t unicast_dwell_interval;             /**< Unicast dwell interval */
+    uint16_t unicast_number_of_channels;        /**< Unicast number of channels */
     uint_fast24_t ufsi;                         /**< Unicast fractional sequence interval */
     uint32_t utt_rx_timestamp;                  /**< UTT-IE reception timestamp */
 } unicast_timing_info_t;

source/6LoWPAN/ws/ws_bootstrap.c

@@ -138,6 +138,23 @@ static int8_t ws_bootsrap_event_trig(ws_bootsrap_event_type_e event_type, int8_t
     return eventOS_event_send(&event);
 }
 
+static fhss_ws_neighbor_timing_info_t *ws_get_neighbor_info(const fhss_api_t *api, uint8_t eui64[8])
+{
+    protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_fhss_api(api);
+    if (!cur || !cur->mac_parameters || !cur->mac_parameters->mac_neighbor_table) {
+        return NULL;
+    }
+    mac_neighbor_table_entry_t *mac_neighbor = mac_neighbor_table_address_discover(cur->mac_parameters->mac_neighbor_table, eui64, MAC_ADDR_MODE_64_BIT);
+    if (!mac_neighbor) {
+        return NULL;
+    }
+    ws_neighbor_class_entry_t *ws_neighbor =  ws_neighbor_class_entry_get(&cur->ws_info->neighbor_storage, mac_neighbor->index);
+    if (!ws_neighbor) {
+        return NULL;
+    }
+    return &ws_neighbor->fhss_data;
+}
+
 static int8_t ws_enable_fhss(protocol_interface_info_entry_t *cur)
 {
     fhss_ws_configuration_t fhss_configuration;
@@ -146,10 +163,12 @@ static int8_t ws_enable_fhss(protocol_interface_info_entry_t *cur)
     fhss_configuration.fhss_bc_dwell_interval = cur->ws_info->hopping_schdule.fhss_bc_dwell_interval;
     fhss_configuration.fhss_broadcast_interval = cur->ws_info->hopping_schdule.fhss_broadcast_interval;
     fhss_configuration.fhss_uc_dwell_interval = cur->ws_info->hopping_schdule.fhss_uc_dwell_interval;
+    fhss_configuration.get_neighbor_info = &ws_get_neighbor_info;
     fhss_configuration.ws_channel_function = cur->ws_info->hopping_schdule.channel_function;
     fhss_api_t *fhss_api = ns_fhss_ws_create(&fhss_configuration, cur->ws_info->fhss_timer_ptr);
     if (fhss_api) {
         ns_sw_mac_fhss_register(cur->mac_api, fhss_api);
+        cur->ws_info->fhss_api = fhss_api;
     }
     return 0;
 }

source/6LoWPAN/ws/ws_common.h

@@ -56,6 +56,7 @@ typedef struct ws_info_s {
     ws_hopping_schedule_t hopping_schdule;
     struct ws_neighbor_class_s neighbor_storage;
     struct fhss_timer *fhss_timer_ptr; // Platform adaptation for FHSS timers.
+    struct fhss_api *fhss_api;
 } ws_info_t;
 
 #ifdef HAVE_WS

source/6LoWPAN/ws/ws_ie_lib.c

@@ -256,7 +256,7 @@ bool ws_wh_utt_read(uint8_t *data, uint16_t length, struct ws_utt_ie *utt_ie)
     }
     data = utt_ie_data.content_ptr;
     utt_ie->message_type = *data++;
-    utt_ie->ufsi = common_read_24_bit_inverse(data + 1);
+    utt_ie->ufsi = common_read_24_bit_inverse(data);
     return true;
 }
 

source/MAC/IEEE802_15_4/mac_mcps_sap.c

@@ -698,6 +698,7 @@ static int8_t mac_data_sap_rx_handler(mac_pre_parsed_frame_t *buf, protocol_inte
 
     data_ind->mpduLinkQuality = buf->LQI;
     data_ind->signal_dbm = buf->dbm;
+    data_ind->timestamp = buf->timestamp;
     /* Parse security part */
     mac_header_security_components_read(buf, &data_ind->Key);
 

source/MAC/IEEE802_15_4/mac_pd_sap.c

@@ -218,7 +218,7 @@ void mac_pd_sap_state_machine(protocol_interface_rf_mac_setup_s *rf_mac_setup)
                 int tx_handle_retval = rf_mac_setup->fhss_api->tx_handle(rf_mac_setup->fhss_api, !mac_is_ack_request_set(active_buf),
                         active_buf->DstAddr, mac_convert_frame_type_to_fhss(active_buf->fcf_dsn.frametype),
                         active_buf->mac_payload_length, rf_mac_setup->dev_driver->phy_driver->phy_header_length,
-                        rf_mac_setup->dev_driver->phy_driver->phy_tail_length, 0);
+                        rf_mac_setup->dev_driver->phy_driver->phy_tail_length, active_buf->tx_time);
                 // When FHSS TX handle returns -1, transmission of the packet is currently not allowed -> restart CCA timer
                 if (tx_handle_retval == -1) {
                     timer_mac_start(rf_mac_setup, MAC_TIMER_CCA, randLIB_get_random_in_range(20, 400) + 1);

source/NWK_INTERFACE/Include/protocol_abstract.h

@@ -21,6 +21,7 @@
 #include "ns_types.h"
 
 struct rpl_domain;
+struct fhss_api;
 
 /*!
  * \enum nwk_interface_id
@@ -43,5 +44,6 @@ extern int protocol_core_buffers_in_event_queue;
 protocol_interface_info_entry_t *protocol_stack_interface_info_get_by_id(int8_t nwk_id);
 protocol_interface_info_entry_t *protocol_stack_interface_info_get_by_bootstrap_id(int8_t id);
 protocol_interface_info_entry_t *protocol_stack_interface_info_get_by_rpl_domain(const struct rpl_domain *domain, int8_t last_id);
+protocol_interface_info_entry_t *protocol_stack_interface_info_get_by_fhss_api(const struct fhss_api *fhss_api);
 
 #endif /* NWK_INTERFACE_INCLUDE_PROTOCOL_ABSTRACT_H_ */

source/NWK_INTERFACE/protocol_core.c

@@ -767,6 +767,18 @@ protocol_interface_info_entry_t *protocol_stack_interface_info_get_by_rpl_domain
     return NULL;
 }
 
+protocol_interface_info_entry_t *protocol_stack_interface_info_get_by_fhss_api(const struct fhss_api *fhss_api)
+{
+#ifdef HAVE_WS
+    ns_list_foreach(protocol_interface_info_entry_t, cur, &protocol_interface_info_list) {
+        if (cur->ws_info->fhss_api == fhss_api) {
+            return cur;
+        }
+    }
+#endif //HAVE_WS
+    return NULL;
+}
+
 protocol_interface_info_entry_t *protocol_stack_interface_sleep_possibility(void)
 {
     ns_list_foreach(protocol_interface_info_entry_t, cur, &protocol_interface_info_list) {

source/Service_Libs/fhss/fhss_ws.c

@@ -148,22 +148,22 @@ static uint32_t fhss_ws_calculate_ufsi(fhss_structure_t *fhss_structure, uint32_
     uint32_t remaining_time = (fhss_structure->platform_functions.fhss_get_remaining_slots(fhss_unicast_handler, fhss_structure->fhss_api) / 1000);
     uint32_t time_to_tx = (tx_time - fhss_structure->fhss_api->read_timestamp(fhss_structure->fhss_api)) / 1000;
     uint64_t ms_since_seq_start = (cur_slot * dwell_time) + (dwell_time-remaining_time) + time_to_tx;
-    ms_since_seq_start %= (dwell_time*fhss_structure->number_of_channels);
     uint32_t seq_length = 0x10000;
     if (fhss_structure->ws->fhss_configuration.ws_channel_function == WS_TR51CF) {
+        ms_since_seq_start %= (dwell_time*fhss_structure->number_of_channels);
         seq_length = fhss_structure->number_of_channels;
     }
     return own_floor((float)(ms_since_seq_start * DEF_2E24) / (seq_length*dwell_time));
 }
 
-static uint16_t fhss_ws_calculate_destination_slot(fhss_structure_t *fhss_structure, fhss_ws_neighbor_timing_info_t *neighbor_timing_info, uint32_t tx_time)
+static uint16_t fhss_ws_calculate_destination_slot(fhss_ws_neighbor_timing_info_t *neighbor_timing_info, uint32_t tx_time)
 {
     uint_fast24_t ufsi = neighbor_timing_info->uc_timing_info.ufsi;
     uint32_t ufsi_timestamp = neighbor_timing_info->uc_timing_info.utt_rx_timestamp;
     uint8_t dwell_time = neighbor_timing_info->uc_timing_info.unicast_dwell_interval;
     uint32_t seq_length = 0x10000;
-    if (fhss_structure->ws->fhss_configuration.ws_channel_function  == WS_TR51CF) {
-        seq_length = fhss_structure->number_of_channels;
+    if (neighbor_timing_info->uc_timing_info.unicast_channel_function  == WS_TR51CF) {
+        seq_length = neighbor_timing_info->uc_timing_info.unicast_number_of_channels;
     }
     uint32_t dest_ms_since_seq_start = own_ceil((float)(ufsi*seq_length*dwell_time) / DEF_2E24);
     return (own_floor(((float)((tx_time - ufsi_timestamp)/1000 + dest_ms_since_seq_start) / dwell_time)) % seq_length);
@@ -242,29 +242,27 @@ static int fhss_ws_tx_handle_callback(const fhss_api_t *api, bool is_broadcast_a
         return 0;
     }
     if (fhss_structure->fhss_state == FHSS_SYNCHRONIZED) {
-        // TODO: Waits for neighbor table support
-        if (fhss_structure->ws->fhss_configuration.ws_channel_function == WS_FIXED_CHANNEL) {
-            return -2;
-        }
-
         fhss_ws_neighbor_timing_info_t *neighbor_timing_info = fhss_structure->ws->fhss_configuration.get_neighbor_info(api, destination_address);
         if (!neighbor_timing_info) {
-            return -1;
+            tr_err("FHSS: No neighbor info: %s", trace_array(destination_address, 8));
+            return -2;
         }
-        uint16_t destination_slot = fhss_ws_calculate_destination_slot(fhss_structure, neighbor_timing_info, tx_time);
+        // TODO: WS bootstrap has to store neighbors number of channels
+        neighbor_timing_info->uc_timing_info.unicast_number_of_channels = fhss_structure->number_of_channels;
+        uint16_t destination_slot = fhss_ws_calculate_destination_slot(neighbor_timing_info, tx_time);
         int32_t tx_channel;
-        if (fhss_structure->ws->fhss_configuration.ws_channel_function == WS_TR51CF) {
-            tx_channel = tr51_get_uc_channel_index(destination_slot, destination_address, fhss_structure->number_of_channels, NULL, 0);
-        } else if(fhss_structure->ws->fhss_configuration.ws_channel_function == WS_DH1CF) {
-            tx_channel = dh1cf_get_uc_channel_index(destination_slot, destination_address, fhss_structure->number_of_channels);
-        } else if (fhss_structure->ws->fhss_configuration.ws_channel_function == WS_VENDOR_DEF_CF) {
+        if (neighbor_timing_info->uc_timing_info.unicast_channel_function == WS_TR51CF) {
+            tx_channel = tr51_get_uc_channel_index(destination_slot, destination_address, neighbor_timing_info->uc_timing_info.unicast_number_of_channels, NULL, 0);
+        } else if(neighbor_timing_info->uc_timing_info.unicast_channel_function == WS_DH1CF) {
+            tx_channel = dh1cf_get_uc_channel_index(destination_slot, destination_address, neighbor_timing_info->uc_timing_info.unicast_number_of_channels);
+        } else if (neighbor_timing_info->uc_timing_info.unicast_channel_function == WS_VENDOR_DEF_CF) {
             if (fhss_structure->ws->fhss_configuration.vendor_defined_cf) {
-                tx_channel = fhss_structure->ws->fhss_configuration.vendor_defined_cf(fhss_structure->fhss_api, fhss_structure->ws->bc_slot, destination_address, fhss_structure->ws->fhss_configuration.bsi, fhss_structure->number_of_channels);
+                tx_channel = fhss_structure->ws->fhss_configuration.vendor_defined_cf(fhss_structure->fhss_api, fhss_structure->ws->bc_slot, destination_address, fhss_structure->ws->fhss_configuration.bsi, neighbor_timing_info->uc_timing_info.unicast_number_of_channels);
             } else {
                 return -1;
             }
         } else {
-            return -1;
+            return 0;
         }
 #ifdef FHSS_CHANNEL_DEBUG
         tr_debug("TX channel: %u %u", tx_channel, destination_slot+1);
@@ -334,6 +332,11 @@ static void fhss_ws_data_tx_done_callback(const fhss_api_t *api, bool waiting_ac
     if (!fhss_structure) {
         return;
     }
+    if (fhss_structure->fhss_state == FHSS_SYNCHRONIZED) {
+        if ((waiting_ack == false) && (fhss_structure->ws->is_on_bc_channel == false)) {
+            fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, fhss_structure->rx_channel);
+        }
+    }
 }
 
 static bool fhss_ws_data_tx_fail_callback(const fhss_api_t *api, uint8_t handle, int frame_type)

test/nanostack/unittest/service_libs/fhss_ws/test_fhss_ws.c

@@ -208,24 +208,25 @@ bool test_fhss_ws_tx_handle_callback()
         return false;
     }
     // Test when no neighbor info found
-    fhss_common_stub.fhss_struct.ws->fhss_configuration.ws_channel_function = WS_TR51CF;
+    neighbor_info.uc_timing_info.unicast_channel_function = WS_TR51CF;
+    neighbor_info.uc_timing_info.unicast_number_of_channels = fhss_common_stub.fhss_struct.number_of_channels;
     fhss_common_stub.fhss_struct.fhss_state = DEFAULT_FHSS_STATE;
     fhss_common_stub.fhss_struct.ws->fhss_configuration.get_neighbor_info = &app_no_neighbor_info;
-    if (fhss_common_stub.fhss_struct.fhss_api->tx_handle(api, DEFAULT_IS_BC_DEST, dest_address, DEFAULT_FRAME_TYPE, DEFAULT_FRAME_LENGTH, DEFAULT_PHY_HEAD_LENGTH, DEFAULT_PHY_TAIL_LENGTH, DEFAULT_TX_TIME) != -1) {
+    if (fhss_common_stub.fhss_struct.fhss_api->tx_handle(api, DEFAULT_IS_BC_DEST, dest_address, DEFAULT_FRAME_TYPE, DEFAULT_FRAME_LENGTH, DEFAULT_PHY_HEAD_LENGTH, DEFAULT_PHY_TAIL_LENGTH, DEFAULT_TX_TIME) != -2) {
         return false;
     }
     // Test fixed channel
     fhss_common_stub.fhss_struct.ws->fhss_configuration.get_neighbor_info = &app_get_neighbor_info;
-    fhss_common_stub.fhss_struct.ws->fhss_configuration.ws_channel_function = WS_FIXED_CHANNEL;
-    if (fhss_common_stub.fhss_struct.fhss_api->tx_handle(api, DEFAULT_IS_BC_DEST, dest_address, DEFAULT_FRAME_TYPE, DEFAULT_FRAME_LENGTH, DEFAULT_PHY_HEAD_LENGTH, DEFAULT_PHY_TAIL_LENGTH, DEFAULT_TX_TIME) != -2) {
+    neighbor_info.uc_timing_info.unicast_channel_function = WS_FIXED_CHANNEL;
+    if (fhss_common_stub.fhss_struct.fhss_api->tx_handle(api, DEFAULT_IS_BC_DEST, dest_address, DEFAULT_FRAME_TYPE, DEFAULT_FRAME_LENGTH, DEFAULT_PHY_HEAD_LENGTH, DEFAULT_PHY_TAIL_LENGTH, DEFAULT_TX_TIME) != 0) {
         return false;
     }
     /* Test TR51 channel function
      * Dest. slot:     | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
      *                 |dest. ufsi|     900ms        |
      * timestamps:        100000us|         1000000us|
      */
-    fhss_common_stub.fhss_struct.ws->fhss_configuration.ws_channel_function = WS_TR51CF;
+    neighbor_info.uc_timing_info.unicast_channel_function = WS_TR51CF;
     if ((fhss_common_stub.fhss_struct.fhss_api->tx_handle(api, DEFAULT_IS_BC_DEST, dest_address, DEFAULT_FRAME_TYPE, DEFAULT_FRAME_LENGTH, DEFAULT_PHY_HEAD_LENGTH, DEFAULT_PHY_TAIL_LENGTH, DEFAULT_TX_TIME) != 0)
             || (channel_functions_stub.uint8_value != 7)) {
         return false;
@@ -236,7 +237,7 @@ bool test_fhss_ws_tx_handle_callback()
      * timestamps:    4294867000us|           900000us|
      */
     neighbor_info.uc_timing_info.utt_rx_timestamp = 4294867000;
-    fhss_common_stub.fhss_struct.ws->fhss_configuration.ws_channel_function = WS_TR51CF;
+    neighbor_info.uc_timing_info.unicast_channel_function = WS_TR51CF;
     if ((fhss_common_stub.fhss_struct.fhss_api->tx_handle(api, DEFAULT_IS_BC_DEST, dest_address, DEFAULT_FRAME_TYPE, DEFAULT_FRAME_LENGTH, DEFAULT_PHY_HEAD_LENGTH, DEFAULT_PHY_TAIL_LENGTH, 900000) != 0)
             || (channel_functions_stub.uint8_value != 7)) {
         return false;
@@ -248,20 +249,20 @@ bool test_fhss_ws_tx_handle_callback()
      */
     neighbor_info.uc_timing_info.utt_rx_timestamp = 100000;
     uint32_t tx_time = neighbor_info.uc_timing_info.utt_rx_timestamp + (fhss_common_stub.fhss_struct.number_of_channels * neighbor_info.uc_timing_info.unicast_dwell_interval * 1000);
-    fhss_common_stub.fhss_struct.ws->fhss_configuration.ws_channel_function = WS_TR51CF;
+    neighbor_info.uc_timing_info.unicast_channel_function = WS_TR51CF;
     if ((fhss_common_stub.fhss_struct.fhss_api->tx_handle(api, DEFAULT_IS_BC_DEST, dest_address, DEFAULT_FRAME_TYPE, DEFAULT_FRAME_LENGTH, DEFAULT_PHY_HEAD_LENGTH, DEFAULT_PHY_TAIL_LENGTH, tx_time) != 0)
             || (channel_functions_stub.uint8_value != 2)) {
         return false;
     }
     // For more coverage, set neighbor info NULL
     memset(&neighbor_info, 0, sizeof(fhss_ws_neighbor_timing_info_t));
     // Test direct hash channel function
-    fhss_common_stub.fhss_struct.ws->fhss_configuration.ws_channel_function = WS_DH1CF;
+    neighbor_info.uc_timing_info.unicast_channel_function = WS_DH1CF;
     if (fhss_common_stub.fhss_struct.fhss_api->tx_handle(api, DEFAULT_IS_BC_DEST, dest_address, DEFAULT_FRAME_TYPE, DEFAULT_FRAME_LENGTH, DEFAULT_PHY_HEAD_LENGTH, DEFAULT_PHY_TAIL_LENGTH, DEFAULT_TX_TIME) != 0) {
         return false;
     }
     // Test vendor defined channel function without application callback
-    fhss_common_stub.fhss_struct.ws->fhss_configuration.ws_channel_function = WS_VENDOR_DEF_CF;
+    neighbor_info.uc_timing_info.unicast_channel_function = WS_VENDOR_DEF_CF;
     if (fhss_common_stub.fhss_struct.fhss_api->tx_handle(api, DEFAULT_IS_BC_DEST, dest_address, DEFAULT_FRAME_TYPE, DEFAULT_FRAME_LENGTH, DEFAULT_PHY_HEAD_LENGTH, DEFAULT_PHY_TAIL_LENGTH, DEFAULT_TX_TIME) != -1) {
         return false;
     }