FHSS WS: Implemented fhss retry logic

Author: Jarkko Paso

nanostack/fhss_api.h

@@ -143,13 +143,13 @@ typedef int16_t fhss_synch_state_set(const fhss_api_t *api, fhss_states fhss_sta
 typedef uint32_t fhss_read_timestamp(const fhss_api_t *api);
 
 /**
- * @brief Get retransmission period. FHSS uses different retry periods for different destinations.
+ * @brief Get additional retransmission period. FHSS uses different retry periods depending on destination or channel availability.
  * @param api FHSS instance.
  * @param destination_address Destination MAC address.
  * @param phy_mtu PHY MTU size.
- * @return Retransmission period.
+ * @return Retransmission period in microsecond which should be added to normal backoff period.
  */
-typedef uint16_t fhss_get_retry_period(const fhss_api_t *api, uint8_t *destination_address, uint16_t phy_mtu);
+typedef uint32_t fhss_get_retry_period(const fhss_api_t *api, uint8_t *destination_address, uint16_t phy_mtu);
 
 /**
  * @brief Write synchronization info to given pointer.

source/MAC/IEEE802_15_4/mac_pd_sap.c

@@ -105,6 +105,9 @@ uint32_t mac_csma_backoff_get(protocol_interface_rf_mac_setup_s *rf_mac_setup)
         if (backoff_in_us < (uint32_t)(rf_mac_setup->multi_cca_interval * (rf_mac_setup->number_of_csma_ca_periods - 1))) {
             backoff_in_us += ((rf_mac_setup->multi_cca_interval * (rf_mac_setup->number_of_csma_ca_periods - 1)) - backoff_in_us);
         }
+        if (rf_mac_setup->mac_tx_retry) {
+            backoff_in_us += rf_mac_setup->fhss_api->get_retry_period(rf_mac_setup->fhss_api, rf_mac_setup->active_pd_data_request->DstAddr, rf_mac_setup->dev_driver->phy_driver->phy_MTU);
+        }
     }
     return backoff_in_us;
 }

source/Service_Libs/fhss/fhss.c

@@ -1191,7 +1191,7 @@ static void fhss_receive_frame_callback(const fhss_api_t *api, uint16_t pan_id,
     }
 }
 
-static uint16_t fhss_get_retry_period_callback(const fhss_api_t *api, uint8_t *destination_address, uint16_t phy_mtu)
+static uint32_t fhss_get_retry_period_callback(const fhss_api_t *api, uint8_t *destination_address, uint16_t phy_mtu)
 {
     uint16_t retry_period = 0;
     uint16_t random_number = randLIB_get_16bit();

source/Service_Libs/fhss/fhss_ws.c

@@ -242,6 +242,7 @@ static void fhss_broadcast_handler(const fhss_api_t *fhss_api, uint16_t delay)
         uint16_t bc_max_random = (bc_dwell_us / 10) / 50;
         eventOS_callback_timer_start(fhss_structure->fhss_event_timer, randLIB_get_random_in_range(bc_min_random, bc_max_random));
     } else {
+        fhss_structure->ws->unicast_start_time_us = fhss_structure->callbacks.read_timestamp(fhss_structure->fhss_api);
         uint32_t timeout = MS_TO_US(fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval);
         fhss_ws_start_timer(fhss_structure, timeout - (delay * fhss_structure->platform_functions.fhss_resolution_divider), fhss_broadcast_handler);
         fhss_structure->ws->is_on_bc_channel = false;
@@ -250,7 +251,7 @@ static void fhss_broadcast_handler(const fhss_api_t *fhss_api, uint16_t delay)
         /* Start timer with random timeout to trigger unicast TX queue poll event.
          * For hops 0,1,4,5,8,9,...
          * Min random is 1/100 of the TX slot length.
-         * Max random is 1/10 of the TX slot length.
+         * Max random is 1/5 of the TX slot length.
          *
          * For hops 2,3,6,7,10,11,...
          * Min random is 1/100 of the TX slot length plus 0.5*TX slot length.
@@ -261,7 +262,7 @@ static void fhss_broadcast_handler(const fhss_api_t *fhss_api, uint16_t delay)
         uint8_t own_tx_trig_slot = calc_own_tx_trig_slot(fhss_structure->own_hop);
         uint32_t txrx_slot_length_us = MS_TO_US(fhss_structure->ws->txrx_slot_length_ms);
         uint16_t uc_min_random = (((txrx_slot_length_us / 2) * own_tx_trig_slot) / 50) + ((txrx_slot_length_us / 100) / 50);
-        uint16_t uc_max_random = (((txrx_slot_length_us / 2) * own_tx_trig_slot) / 50) + ((txrx_slot_length_us / 10) / 50);
+        uint16_t uc_max_random = (((txrx_slot_length_us / 2) * own_tx_trig_slot) / 50) + ((txrx_slot_length_us / 5) / 50);
         bool tx_allowed = fhss_ws_check_tx_allowed(fhss_structure);
         if (!tx_allowed) {
             uc_min_random += (txrx_slot_length_us) / 50;
@@ -719,6 +720,45 @@ static bool fhss_ws_use_broadcast_queue_cb(const fhss_api_t *api, bool is_broadc
     return is_broadcast_addr;
 }
 
+static uint32_t fhss_ws_get_retry_period_callback(const fhss_api_t *api, uint8_t *destination_address, uint16_t phy_mtu)
+{
+    (void) destination_address;
+    (void) phy_mtu;
+    uint32_t return_value = 0;
+    fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
+    if (!fhss_structure) {
+        return return_value;
+    }
+    if (fhss_structure->own_hop == 0xff) {
+        return return_value;
+    }
+    if (fhss_structure->ws->is_on_bc_channel == true) {
+        return return_value;
+    }
+
+    uint32_t txrx_slot_length_us = MS_TO_US(fhss_structure->ws->txrx_slot_length_ms);
+    uint32_t unicast_start_us = fhss_structure->ws->unicast_start_time_us;
+    uint32_t cur_time_us = fhss_structure->callbacks.read_timestamp(fhss_structure->fhss_api);
+    uint32_t tx_trig_offset_us = (txrx_slot_length_us / 2) * calc_own_tx_trig_slot(fhss_structure->own_hop);
+
+    uint32_t next_tx_trig_slot_start_us = unicast_start_us + (txrx_slot_length_us * !fhss_ws_check_tx_allowed(fhss_structure)) + tx_trig_offset_us;
+    uint32_t next_tx_trig_slot_end_us = next_tx_trig_slot_start_us + (txrx_slot_length_us / 2);
+    while ((next_tx_trig_slot_start_us < cur_time_us) || ((next_tx_trig_slot_start_us - cur_time_us) > (uint32_t) MS_TO_US(fhss_structure->ws->fhss_configuration.fhss_broadcast_interval))) {
+        if (cur_time_us < next_tx_trig_slot_end_us) {
+            return 0;
+        }
+        next_tx_trig_slot_start_us += (txrx_slot_length_us * 2);
+        next_tx_trig_slot_end_us = next_tx_trig_slot_start_us + (txrx_slot_length_us / 2);
+    }
+    return_value = next_tx_trig_slot_start_us - cur_time_us;
+    uint32_t time_to_bc_channel = get_remaining_slots_us(fhss_structure, fhss_broadcast_handler, MS_TO_US(fhss_structure->ws->fhss_configuration.fhss_broadcast_interval));
+    if (time_to_bc_channel <= return_value) {
+        return_value += MS_TO_US(fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval);
+    }
+
+    return return_value;
+}
+
 static void fhss_unicast_handler(const fhss_api_t *fhss_api, uint16_t delay)
 {
     uint32_t timeout = 0;
@@ -755,7 +795,7 @@ int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure)
     fhss_structure->fhss_api->data_tx_fail = &fhss_ws_data_tx_fail_callback;
     fhss_structure->fhss_api->synch_state_set = &fhss_ws_synch_state_set_callback;
     fhss_structure->fhss_api->read_timestamp = NULL;
-    fhss_structure->fhss_api->get_retry_period = NULL;
+    fhss_structure->fhss_api->get_retry_period = &fhss_ws_get_retry_period_callback;
     fhss_structure->fhss_api->write_synch_info = &fhss_ws_write_synch_info_callback;
     fhss_structure->fhss_api->init_callbacks = &fhss_init_callbacks_cb;
     return 0;

source/Service_Libs/fhss/fhss_ws.h

@@ -36,6 +36,7 @@ struct fhss_ws {
     uint16_t min_synch_interval;
     uint32_t txrx_slot_length_ms;
     uint32_t synchronization_time;
+    uint32_t unicast_start_time_us;
     int32_t drift_per_millisecond_ns;
     int16_t *tr51_channel_table;
     uint8_t *tr51_output_table;

test/nanostack/unittest/service_libs/fhss_ws/fhsswstest.cpp

@@ -78,6 +78,11 @@ TEST(fhssws, test_fhss_broadcast_handler)
     CHECK(test_fhss_broadcast_handler());
 }
 
+TEST(fhssws, test_fhss_ws_get_retry_period_callback)
+{
+    CHECK(test_fhss_ws_get_retry_period_callback());
+}
+
 TEST(fhssws, test_fhss_ws_update_uc_channel_callback)
 {
     CHECK(test_fhss_ws_update_uc_channel_callback());

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

@@ -548,6 +548,106 @@ bool test_fhss_broadcast_handler()
     return true;
 }
 
+bool test_fhss_ws_get_retry_period_callback()
+{
+    fhss_api_t *api = test_generate_fhss_api();
+    enable_fhss_struct();
+    // Test when own hop not set
+    fhss_common_stub.fhss_struct.ws->is_on_bc_channel = false;
+    fhss_common_stub.fhss_struct.own_hop = 0xff;
+    if (fhss_common_stub.fhss_struct.fhss_api->get_retry_period(api, NULL, 0) != 0) {
+        return false;
+    }
+    // Test when on broadcast channel
+    fhss_common_stub.fhss_struct.ws->is_on_bc_channel = true;
+    fhss_common_stub.fhss_struct.own_hop = 1;
+    if (fhss_common_stub.fhss_struct.fhss_api->get_retry_period(api, NULL, 0) != 0) {
+        return false;
+    }
+    // Test when not on TX trig slot
+    fhss_common_stub.fhss_struct.ws->is_on_bc_channel = false;
+    fhss_common_stub.fhss_struct.own_hop = 0;
+    fhss_common_stub.fhss_struct.ws->txrx_slot_length_ms = 127;
+    fhss_common_stub.fhss_struct.ws->unicast_start_time_us = 1000000;
+    fhss_platform_stub.remaining_slots_value = 700000;
+    fhss_callbacks_stub.uint32_value = 1065000;
+    if (fhss_common_stub.fhss_struct.fhss_api->get_retry_period(api, NULL, 0) != 189000) {
+        return false;
+    }
+    // Test when not on TX trig slot
+    fhss_common_stub.fhss_struct.ws->is_on_bc_channel = false;
+    fhss_common_stub.fhss_struct.own_hop = 0;
+    fhss_common_stub.fhss_struct.ws->txrx_slot_length_ms = 127;
+    fhss_common_stub.fhss_struct.ws->unicast_start_time_us = 1000000;
+    fhss_platform_stub.remaining_slots_value = 436000;
+    fhss_callbacks_stub.uint32_value = 1329000;
+    if (fhss_common_stub.fhss_struct.fhss_api->get_retry_period(api, NULL, 0) != 179000) {
+        return false;
+    }
+    // Test when not on TX trig slot
+    fhss_common_stub.fhss_struct.ws->is_on_bc_channel = false;
+    fhss_common_stub.fhss_struct.own_hop = 0;
+    fhss_common_stub.fhss_struct.ws->txrx_slot_length_ms = 127;
+    fhss_common_stub.fhss_struct.ws->unicast_start_time_us = 1000000;
+    fhss_platform_stub.remaining_slots_value = 182000;
+    fhss_callbacks_stub.uint32_value = 1583000;
+    if (fhss_common_stub.fhss_struct.fhss_api->get_retry_period(api, NULL, 0) != 179000) {
+        return false;
+    }
+    // Test when on TX trig slot
+    fhss_common_stub.fhss_struct.ws->is_on_bc_channel = false;
+    fhss_common_stub.fhss_struct.own_hop = 2;
+    fhss_common_stub.fhss_struct.ws->txrx_slot_length_ms = 127;
+    fhss_common_stub.fhss_struct.ws->unicast_start_time_us = 1000000;
+    fhss_platform_stub.remaining_slots_value = 700000;
+    fhss_callbacks_stub.uint32_value = 1065000;
+    if (fhss_common_stub.fhss_struct.fhss_api->get_retry_period(api, NULL, 0) != 0) {
+        return false;
+    }
+    // Test when on TX trig slot
+    fhss_common_stub.fhss_struct.ws->is_on_bc_channel = false;
+    fhss_common_stub.fhss_struct.own_hop = 2;
+    fhss_common_stub.fhss_struct.ws->txrx_slot_length_ms = 127;
+    fhss_common_stub.fhss_struct.ws->unicast_start_time_us = 1000000;
+    fhss_platform_stub.remaining_slots_value = 486000;
+    fhss_callbacks_stub.uint32_value = 1279000;
+    if (fhss_common_stub.fhss_struct.fhss_api->get_retry_period(api, NULL, 0) != 38500) {
+        return false;
+    }
+    // Test when timestamp overflows
+    fhss_common_stub.fhss_struct.ws->is_on_bc_channel = false;
+    fhss_common_stub.fhss_struct.own_hop = 0;
+    fhss_common_stub.fhss_struct.ws->txrx_slot_length_ms = 127;
+    fhss_common_stub.fhss_struct.ws->unicast_start_time_us = 4294967285;
+    fhss_platform_stub.remaining_slots_value = 700000;
+    fhss_callbacks_stub.uint32_value = 64989;
+    if (fhss_common_stub.fhss_struct.fhss_api->get_retry_period(api, NULL, 0) != 189000) {
+        return false;
+    }
+    // Test when on RX slot
+    fhss_common_stub.fhss_struct.ws->is_on_bc_channel = false;
+    fhss_common_stub.fhss_struct.own_hop = 1;
+    fhss_common_stub.fhss_struct.ws->txrx_slot_length_ms = 127;
+    fhss_common_stub.fhss_struct.ws->unicast_start_time_us = 1000000;
+    fhss_platform_stub.remaining_slots_value = 700000;
+    fhss_callbacks_stub.uint32_value = 1065000;
+    if (fhss_common_stub.fhss_struct.fhss_api->get_retry_period(api, NULL, 0) != 62000) {
+        return false;
+    }
+    // Test when going to BC channel
+    fhss_common_stub.fhss_struct.ws->fhss_configuration.fhss_bc_dwell_interval = 255;
+    fhss_common_stub.fhss_struct.ws->is_on_bc_channel = false;
+    fhss_common_stub.fhss_struct.own_hop = 0;
+    fhss_common_stub.fhss_struct.ws->txrx_slot_length_ms = 100;
+    fhss_common_stub.fhss_struct.ws->unicast_start_time_us = 1000000;
+    fhss_platform_stub.remaining_slots_value = 130000;
+    fhss_callbacks_stub.uint32_value = 1670000;
+    if (fhss_common_stub.fhss_struct.fhss_api->get_retry_period(api, NULL, 0) != 385000) {
+        return false;
+    }
+    return true;
+}
+
 bool test_fhss_ws_update_uc_channel_callback()
 {
     fhss_api_t *api = test_generate_fhss_api();

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

@@ -34,6 +34,7 @@ bool test_fhss_ws_data_tx_fail_callback();
 bool test_fhss_ws_synch_state_set_callback();
 bool test_fhss_ws_write_synch_info_callback();
 bool test_fhss_broadcast_handler();
+bool test_fhss_ws_get_retry_period_callback();
 bool test_fhss_ws_update_uc_channel_callback();
 bool test_fhss_unicast_handler();
 bool test_fhss_ws_set_parent();