Merge pull request ARMmbed#1653 from ARMmbed/IOTTHD-2366

Iotthd 2366

Author: Jarkko Paso

source/Service_Libs/fhss/fhss.c

@@ -38,8 +38,6 @@ static int fhss_reset(fhss_structure_t *fhss_structure);
 static bool fhss_is_bc_sending_superframe(fhss_structure_t *fhss_structure);
 static bool fhss_check_remaining_tx_time(fhss_structure_t *fhss_structure, uint16_t tx_length, uint8_t phy_header_length, uint8_t phy_tail_length);
 static bool fhss_is_there_common_divisor(uint16_t i, uint8_t j);
-static fhss_failed_tx_t *fhss_failed_handle_find(fhss_structure_t *fhss_structure, uint8_t handle);
-static void fhss_failed_list_free(fhss_structure_t *fhss_structure);
 static void fhss_beacon_received(fhss_structure_t *fhss_structure, const uint8_t *synch_info, const uint32_t elapsed_time);
 static void fhss_superframe_handler(const fhss_api_t *fhss_api, uint16_t delay);
 static int8_t fhss_beacon_create_tasklet(fhss_structure_t *fhss_structure);
@@ -80,7 +78,7 @@ fhss_structure_t *fhss_enable(fhss_api_t *fhss_api, const fhss_configuration_t *
     if (!fhss_struct->bs->fhss_configuration.fhss_max_synch_interval) {
         fhss_struct->bs->fhss_configuration.fhss_max_synch_interval = 240;
     }
-    ns_list_init(&fhss_struct->bs->fhss_failed_tx_list);
+    ns_list_init(&fhss_struct->fhss_failed_tx_list);
     fhss_struct->bs->own_hop = 0xff;
     fhss_reset(fhss_struct);
 
@@ -696,47 +694,6 @@ static void fhss_update_beacon_info_lifetimes(fhss_structure_t *fhss_structure,
     }
 }
 
-static fhss_failed_tx_t *fhss_failed_handle_find(fhss_structure_t *fhss_structure, uint8_t handle)
-{
-    ns_list_foreach(fhss_failed_tx_t, cur, &fhss_structure->bs->fhss_failed_tx_list) {
-        if (cur->handle == handle) {
-            return cur;
-        }
-    }
-    return NULL;
-}
-
-static int fhss_failed_handle_add(fhss_structure_t *fhss_structure, uint8_t handle)
-{
-    fhss_failed_tx_t *failed_tx = ns_dyn_mem_alloc(sizeof(fhss_failed_tx_t));
-    if (!failed_tx) {
-        return -2;
-    }
-    failed_tx->bad_channel = fhss_structure->rx_channel;
-    failed_tx->retries_done = 0;
-    failed_tx->handle = handle;
-    ns_list_add_to_end(&fhss_structure->bs->fhss_failed_tx_list, failed_tx);
-    return 0;
-}
-
-static int fhss_failed_handle_remove(fhss_structure_t *fhss_structure, uint8_t handle)
-{
-    fhss_failed_tx_t *failed_tx = fhss_failed_handle_find(fhss_structure, handle);
-    if (!failed_tx) {
-        return -1;
-    }
-    ns_list_remove(&fhss_structure->bs->fhss_failed_tx_list, failed_tx);
-    ns_dyn_mem_free(failed_tx); // Free entry
-    return 0;
-}
-
-static void fhss_failed_list_free(fhss_structure_t *fhss_structure)
-{
-    for (uint16_t i = 0; i<256; i++) {
-        fhss_failed_handle_remove(fhss_structure, i);
-    }
-}
-
 static void fhss_synch_state_set_callback(const fhss_api_t *api, fhss_states fhss_state, uint16_t pan_id)
 {
     fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
@@ -1151,7 +1108,7 @@ static bool fhss_data_tx_fail_callback(const fhss_api_t *api, uint8_t handle, in
         }
     } else {
         // Create new failure handle and return true to retransmit
-        fhss_failed_handle_add(fhss_structure, handle);
+        fhss_failed_handle_add(fhss_structure, handle, fhss_structure->rx_channel);
     }
     return true;
 }

source/Service_Libs/fhss/fhss.h

@@ -16,7 +16,6 @@
  */
 #ifndef FHSS_H_
 #define FHSS_H_
-#include "ns_list.h"
 #define MAX_SCRAMBLE_TABLE_INDEXES  20
 // Lifetime is given as seconds
 #define BEACON_INFO_LIFETIME        600
@@ -87,16 +86,6 @@ struct fhss_synch_monitor
     int channel_counter;
 };
 
-struct fhss_failed_tx
-{
-    uint8_t handle;
-    uint8_t bad_channel;
-    uint8_t retries_done;
-    ns_list_link_t link;
-};
-typedef NS_LIST_HEAD(fhss_failed_tx_t, link) fhss_failed_tx_list_t;
-
-
 struct fhss_bs
 {
     uint8_t uc_channel_index;
@@ -117,7 +106,6 @@ struct fhss_bs
     struct fhss_configuration fhss_configuration;
     struct fhss_synch_configuration synch_configuration;
     struct fhss_synch_monitor synch_monitor;
-    fhss_failed_tx_list_t fhss_failed_tx_list;
     uint8_t fhss_scramble_table[MAX_SCRAMBLE_TABLE_INDEXES];
 };
 

source/Service_Libs/fhss/fhss_common.c

@@ -271,3 +271,45 @@ int fhss_init_callbacks_cb(const fhss_api_t *api, fhss_callback_t *callbacks)
     fhss_structure->callbacks = *callbacks;
     return 0;
 }
+
+
+fhss_failed_tx_t *fhss_failed_handle_find(fhss_structure_t *fhss_structure, uint8_t handle)
+{
+    ns_list_foreach(fhss_failed_tx_t, cur, &fhss_structure->fhss_failed_tx_list) {
+        if (cur->handle == handle) {
+            return cur;
+        }
+    }
+    return NULL;
+}
+
+int fhss_failed_handle_add(fhss_structure_t *fhss_structure, uint8_t handle, uint8_t bad_channel)
+{
+    fhss_failed_tx_t *failed_tx = ns_dyn_mem_alloc(sizeof(fhss_failed_tx_t));
+    if (!failed_tx) {
+        return -1;
+    }
+    failed_tx->bad_channel = bad_channel;
+    failed_tx->retries_done = 0;
+    failed_tx->handle = handle;
+    ns_list_add_to_end(&fhss_structure->fhss_failed_tx_list, failed_tx);
+    return 0;
+}
+
+int fhss_failed_handle_remove(fhss_structure_t *fhss_structure, uint8_t handle)
+{
+    fhss_failed_tx_t *failed_tx = fhss_failed_handle_find(fhss_structure, handle);
+    if (!failed_tx) {
+        return -1;
+    }
+    ns_list_remove(&fhss_structure->fhss_failed_tx_list, failed_tx);
+    ns_dyn_mem_free(failed_tx); // Free entry
+    return 0;
+}
+
+void fhss_failed_list_free(fhss_structure_t *fhss_structure)
+{
+    for (uint16_t i = 0; i<256; i++) {
+        fhss_failed_handle_remove(fhss_structure, i);
+    }
+}

source/Service_Libs/fhss/fhss_common.h

@@ -16,12 +16,23 @@
  */
 #ifndef FHSS_COMMON_H_
 #define FHSS_COMMON_H_
+#include "ns_list.h"
+
 #define FHSS_TASKLET_INIT_EVENT             0
 #define FHSS_TIMER_EVENT                    1
 #define FHSS_COMPARE_SYNCH_PARENT           2
 #define FHSS_BROADCAST_CHANNEL              3
 #define FHSS_UPDATE_SYNCH_INFO_STORAGE      4
 
+struct fhss_failed_tx
+{
+    uint8_t handle;
+    uint8_t bad_channel;
+    uint8_t retries_done;
+    ns_list_link_t link;
+};
+typedef NS_LIST_HEAD(fhss_failed_tx_t, link) fhss_failed_tx_list_t;
+
 struct fhss_structure
 {
     uint8_t fhss_resolution_divider;
@@ -39,6 +50,7 @@ struct fhss_structure
     struct fhss_ws *ws;
     struct fhss_timer platform_functions;
     struct fhss_callback callbacks;
+    fhss_failed_tx_list_t fhss_failed_tx_list;
     uint8_t synch_parent[8];
 };
 
@@ -58,4 +70,8 @@ int fhss_compare_with_synch_parent_address(fhss_structure_t *fhss_structure, con
 bool fhss_use_broadcast_queue_cb(const fhss_api_t *api, bool is_broadcast_addr, int frame_type);
 uint32_t fhss_read_timestamp_cb(const fhss_api_t *api);
 int fhss_init_callbacks_cb(const fhss_api_t *api, fhss_callback_t *callbacks);
+int fhss_failed_handle_remove(fhss_structure_t *fhss_structure, uint8_t handle);
+int fhss_failed_handle_add(fhss_structure_t *fhss_structure, uint8_t handle, uint8_t bad_channel);
+fhss_failed_tx_t *fhss_failed_handle_find(fhss_structure_t *fhss_structure, uint8_t handle);
+void fhss_failed_list_free(fhss_structure_t *fhss_structure);
 #endif /*FHSS_COMMON_H_*/

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,18 @@ 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)
+{
+    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 +318,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 +395,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 +454,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/test_fhss.c

@@ -129,7 +129,6 @@ static fhss_api_t *test_generate_fhss_api(void)
     memset(&fhss_channel_stub, 0, sizeof(fhss_channel_stub_def));
     FHSS.fhss_api = &fhss_api;
     FHSS.bs = &bs;
-    ns_list_init(&FHSS.bs->fhss_failed_tx_list);
     FHSS.callbacks.change_channel = &mac_set_channel;
     FHSS.callbacks.read_mac_address = &mac_read_64bit_mac_address;
     FHSS.callbacks.read_datarate = &mac_read_phy_datarate;
@@ -138,7 +137,6 @@ static fhss_api_t *test_generate_fhss_api(void)
     FHSS.callbacks.synch_lost_notification = &mac_synch_lost;
     FHSS.callbacks.broadcast_notify = &mac_broadcast_notification;
     test_set_fhss_default_configs();
-    ns_list_init(&FHSS.bs->fhss_failed_tx_list);
     test_set_platform_api(&FHSS.platform_functions);
     fhss_set_callbacks(&FHSS);
     return &fhss_api;
@@ -409,15 +407,6 @@ bool test_fhss_data_tx_fail_callback()
     if (FHSS.fhss_api->data_tx_fail(api, DEFAULT_HANDLE, FHSS_SYNCH_FRAME) != false) {
         return false;
     }
-    // Test adding failed handle
-    nsdynmemlib_stub.returnCounter = 1;
-    if (FHSS.fhss_api->data_tx_fail(api, DEFAULT_HANDLE, DEFAULT_FRAME_TYPE) != true) {
-        return false;
-    }
-    // Test removing failed handle
-    if (FHSS.fhss_api->data_tx_fail(api, DEFAULT_HANDLE, DEFAULT_FRAME_TYPE) != false) {
-        return false;
-    }
 
     return true;
 }

test/nanostack/unittest/service_libs/fhss_common/Makefile

@@ -13,6 +13,7 @@ TEST_SRC_FILES = \
         test_fhss_common.c \
         ../../stub/mbed_trace_stub.c \
         ../../stub/nsdynmemLIB_stub.c \
+        ../../stub/ns_list_stub.c \
         ../../stub/event_stub.c \
         ../../stub/ns_timer_stub.c \
         ../../stub/fhss_stub.c \

test/nanostack/unittest/service_libs/fhss_common/fhsscommontest.cpp

@@ -90,3 +90,13 @@ TEST(fhss_common, test_fhss_clear_active_event)
 {
     CHECK(test_fhss_clear_active_event());
 }
+
+TEST(fhss_common, test_fhss_failed_handle_add)
+{
+    CHECK(test_fhss_failed_handle_add());
+}
+
+TEST(fhss_common, test_fhss_failed_list_free)
+{
+    CHECK(test_fhss_failed_list_free());
+}