FHSS: Use channel retries with WS

Author: Jarkko Paso

source/Service_Libs/fhss/fhss_ws.c

@@ -73,6 +73,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;
+    ns_list_init(&fhss_struct->fhss_failed_tx_list);
     return fhss_struct;
 }
 
@@ -112,8 +113,6 @@ static void fhss_broadcast_handler(const fhss_api_t *fhss_api, uint16_t delay)
         fhss_start_timer(fhss_structure, fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval*1000, fhss_broadcast_handler);
         fhss_structure->ws->is_on_bc_channel = true;
         next_channel = fhss_ws_calc_bc_channel(fhss_structure);
-        // TODO: Randomize polling TX queue when on broadcast channel
-        fhss_structure->callbacks.tx_poll(fhss_structure->fhss_api);
     } else {
         uint32_t timeout = (fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) * 1000;
         fhss_start_timer(fhss_structure, timeout, fhss_broadcast_handler);
@@ -125,6 +124,10 @@ static void fhss_broadcast_handler(const fhss_api_t *fhss_api, uint16_t delay)
 #endif /*FHSS_CHANNEL_DEBUG*/
     }
     fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, next_channel);
+    if (fhss_structure->callbacks.read_tx_queue_size(fhss_structure->fhss_api, true)) {
+        // TODO: Randomize polling TX queue when on broadcast channel
+        fhss_structure->callbacks.tx_poll(fhss_structure->fhss_api);
+    }
 }
 
 static int own_floor(float value)
@@ -289,6 +292,21 @@ static int fhss_ws_tx_handle_callback(const fhss_api_t *api, bool is_broadcast_a
     return 0;
 }
 
+static bool fhss_check_bad_channel(fhss_structure_t *fhss_structure, uint8_t handle)
+{
+    if (!fhss_structure) {
+        return false;
+    }
+    fhss_failed_tx_t *failed_tx = fhss_failed_handle_find(fhss_structure, handle);
+    if (!failed_tx) {
+        return true;
+    }
+    if (failed_tx->bad_channel == fhss_structure->rx_channel) {
+        return false;
+    }
+    return true;
+}
+
 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;
@@ -303,10 +321,18 @@ static bool fhss_ws_check_tx_conditions_callback(const fhss_api_t *api, bool is_
     if (fhss_structure->ws->fhss_configuration.ws_channel_function == WS_FIXED_CHANNEL) {
         return true;
     }
+    // This condition will check that message is not sent on bad channel
+    if (fhss_check_bad_channel(fhss_structure, handle) == false) {
+        return false;
+    }
     // Do not allow broadcast destination on unicast channel
     if (is_broadcast_addr && (fhss_structure->ws->is_on_bc_channel == false)) {
         return false;
     }
+    // Do not allow unicast destination on broadcast channel
+    if (!is_broadcast_addr && (fhss_structure->ws->is_on_bc_channel == true)) {
+        return false;
+    }
     return true;
 }
 
@@ -372,10 +398,34 @@ static void fhss_ws_data_tx_done_callback(const fhss_api_t *api, bool waiting_ac
 
 static bool fhss_ws_data_tx_fail_callback(const fhss_api_t *api, uint8_t handle, int frame_type)
 {
-    (void) api;
-    (void) handle;
-    (void) frame_type;
-    return false;
+    fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
+    if (!fhss_structure) {
+        return false;
+    }
+    // Only use channel retries when device is synchronized
+    if (fhss_structure->fhss_state == FHSS_UNSYNCHRONIZED) {
+        return false;
+    }
+
+    // Use channel retries only for data frames
+    if (FHSS_DATA_FRAME != frame_type) {
+        return false;
+    }
+
+    fhss_failed_tx_t *fhss_failed_tx = fhss_failed_handle_find(fhss_structure, handle);
+    if (fhss_failed_tx) {
+        fhss_failed_tx->retries_done++;
+        if (fhss_failed_tx->retries_done >= WS_NUMBER_OF_CHANNEL_RETRIES) {
+            // No more retries. Return false to stop retransmitting.
+            fhss_failed_handle_remove(fhss_structure, handle);
+            return false;
+        }
+        fhss_failed_tx->bad_channel = fhss_structure->rx_channel;
+    } else {
+        // Create new failure handle and return true to retransmit
+        fhss_failed_handle_add(fhss_structure, handle, fhss_structure->rx_channel);
+    }
+    return true;
 }
 
 static void fhss_ws_receive_frame_callback(const fhss_api_t *api, uint16_t pan_id, uint8_t *source_address, uint32_t timestamp, uint8_t *synch_info, int frame_type)
@@ -407,6 +457,9 @@ static void fhss_unicast_handler(const fhss_api_t *fhss_api, uint16_t delay)
     timeout = fhss_ws_get_sf_timeout_callback(fhss_structure);
     fhss_start_timer(fhss_structure, timeout - (delay * fhss_structure->platform_functions.fhss_resolution_divider), fhss_unicast_handler);
     fhss_ws_update_uc_channel_callback(fhss_structure);
+    if (fhss_structure->callbacks.read_tx_queue_size(fhss_structure->fhss_api, false)) {
+        fhss_structure->callbacks.tx_poll(fhss_structure->fhss_api);
+    }
 }
 
 int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure)

source/Service_Libs/fhss/fhss_ws.h

@@ -16,6 +16,11 @@
  */
 #ifndef FHSS_WS_H_
 #define FHSS_WS_H_
+
+/* WS requires at least 19 MAC retransmissions (total 1+19=20 attempts). 802.15.4 macMaxFrameRetries is 3 (total 1+3=4 attempts).
+ * 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
 typedef struct fhss_ws fhss_ws_t;
 
 struct fhss_ws

test/nanostack/unittest/service_libs/fhss_ws/Makefile

@@ -13,6 +13,7 @@ TEST_SRC_FILES = \
         test_fhss_ws.c \
         ../../stub/mbed_trace_stub.c \
         ../../stub/nsdynmemLIB_stub.c \
+        ../../stub/ns_list_stub.c \
         ../../stub/channel_list_stub.c \
         ../../stub/channel_functions_stub.c \
         ../../stub/fhss_stub.c \