Merge pull request ARMmbed#1666 from ARMmbed/fhss_is_bc_flag_fix

Fhss is bc flag fix

Author: Jarkko Paso

source/MAC/IEEE802_15_4/mac_mcps_sap.c

@@ -1657,7 +1657,7 @@ void mcps_sap_pd_req_queue_write(protocol_interface_rf_mac_setup_s *rf_mac_setup
     bool use_bc_queue = false;
 
     // When FHSS is enabled, broadcast buffers are pushed to own queue
-    if (rf_mac_setup->fhss_api) {
+    if (rf_mac_setup->fhss_api && (buffer->asynch_request == false)) {
         if (rf_mac_setup->fhss_api->use_broadcast_queue(rf_mac_setup->fhss_api, !mac_is_ack_request_set(buffer),
                 mac_convert_frame_type_to_fhss(buffer->fcf_dsn.frametype)) == true) {
             cur = rf_mac_setup->pd_data_request_bc_queue_to_go;

source/Service_Libs/fhss/fhss.c

@@ -1200,6 +1200,20 @@ static bool fhss_is_broadcast_channel_callback(const fhss_api_t *api)
     return fhss_is_current_channel_broadcast(fhss_structure);
 }
 
+static bool fhss_use_broadcast_queue_cb(const fhss_api_t *api, bool is_broadcast_addr, int frame_type)
+{
+    fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
+    if (!fhss_structure) {
+        return false;
+    }
+    // Synch requests are always stored in unicast queue
+    if (frame_type == FHSS_SYNCH_REQUEST_FRAME) {
+        return false;
+    }
+    // Broadcast packets are stored in broadcast queue
+    return is_broadcast_addr;
+}
+
 static void fhss_superframe_handler(const fhss_api_t *fhss_api, uint16_t delay)
 {
     uint32_t timeout = 0;

source/Service_Libs/fhss/fhss_common.c

@@ -239,20 +239,6 @@ int fhss_compare_with_synch_parent_address(fhss_structure_t *fhss_structure, con
     return ret_val;
 }
 
-bool fhss_use_broadcast_queue_cb(const fhss_api_t *api, bool is_broadcast_addr, int frame_type)
-{
-    fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
-    if (!fhss_structure) {
-        return false;
-    }
-    // Synch requests are always stored in unicast queue
-    if (frame_type == FHSS_SYNCH_REQUEST_FRAME) {
-        return false;
-    }
-    // Broadcast packets are stored in broadcast queue
-    return is_broadcast_addr;
-}
-
 uint32_t fhss_read_timestamp_cb(const fhss_api_t *api)
 {
     fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);

source/Service_Libs/fhss/fhss_common.h

@@ -67,7 +67,6 @@ int fhss_update_synch_parent_address(fhss_structure_t *fhss_structure);
 void fhss_trig_event(fhss_structure_t *fhss_structure, uint8_t event_type);
 int fhss_get_parent_address(fhss_structure_t *fhss_structure, uint8_t *p_addr);
 int fhss_compare_with_synch_parent_address(fhss_structure_t *fhss_structure, const uint8_t *source_addr);
-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);

source/Service_Libs/fhss/fhss_ws.c

@@ -205,6 +205,7 @@ static void fhss_ws_synch_state_set_callback(const fhss_api_t *api, fhss_states
     if ((fhss_state == FHSS_SYNCHRONIZED) && (fhss_structure->ws->fhss_configuration.ws_channel_function != WS_FIXED_CHANNEL)) {
         uint32_t fhss_broadcast_interval = fhss_structure->ws->fhss_configuration.fhss_broadcast_interval;
         uint8_t fhss_bc_dwell_interval = fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval;
+
         // Start broadcast schedule when BC intervals are known
         if (fhss_broadcast_interval && fhss_bc_dwell_interval) {
             fhss_broadcast_handler(fhss_structure->fhss_api, 0);
@@ -393,6 +394,13 @@ static void fhss_ws_data_tx_done_callback(const fhss_api_t *api, bool waiting_ac
             fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, fhss_structure->rx_channel);
         }
     }
+    // Buffer was successfully transmitted. Remove stored failure handle if exists.
+    if (tx_completed == true) {
+        fhss_failed_tx_t *fhss_failed_tx = fhss_failed_handle_find(fhss_structure, handle);
+        if (fhss_failed_tx) {
+            fhss_failed_handle_remove(fhss_structure, handle);
+        }
+    }
 }
 
 static bool fhss_ws_data_tx_fail_callback(const fhss_api_t *api, uint8_t handle, int frame_type)
@@ -446,6 +454,21 @@ static bool fhss_ws_is_broadcast_channel_callback(const fhss_api_t *api)
     return fhss_structure->ws->is_on_bc_channel;
 }
 
+static bool fhss_ws_use_broadcast_queue_cb(const fhss_api_t *api, bool is_broadcast_addr, int frame_type)
+{
+    (void) frame_type;
+    fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
+    if (!fhss_structure) {
+        return false;
+    }
+    // Do not use broadcast queue when fixed channel
+    if (fhss_structure->ws->fhss_configuration.ws_channel_function == WS_FIXED_CHANNEL) {
+        return false;
+    }
+    // Broadcast packets are stored in broadcast queue
+    return is_broadcast_addr;
+}
+
 static void fhss_unicast_handler(const fhss_api_t *fhss_api, uint16_t delay)
 {
     uint32_t timeout = 0;
@@ -480,7 +503,7 @@ int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure)
 {
     // Set external API
     fhss_structure->fhss_api->is_broadcast_channel = &fhss_ws_is_broadcast_channel_callback;
-    fhss_structure->fhss_api->use_broadcast_queue = &fhss_use_broadcast_queue_cb;
+    fhss_structure->fhss_api->use_broadcast_queue = &fhss_ws_use_broadcast_queue_cb;
     fhss_structure->fhss_api->tx_handle = &fhss_ws_tx_handle_callback;
     fhss_structure->fhss_api->check_tx_conditions = &fhss_ws_check_tx_conditions_callback;
     fhss_structure->fhss_api->receive_frame = &fhss_ws_receive_frame_callback;

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

@@ -71,11 +71,6 @@ TEST(fhss_common, test_fhss_compare_with_synch_parent_address)
     CHECK(test_fhss_compare_with_synch_parent_address());
 }
 
-TEST(fhss_common, test_fhss_use_broadcast_queue_cb)
-{
-    CHECK(test_fhss_use_broadcast_queue_cb());
-}
-
 TEST(fhss_common, test_fhss_read_timestamp_cb)
 {
     CHECK(test_fhss_read_timestamp_cb());

test/nanostack/unittest/service_libs/fhss_common/test_fhss_common.c

@@ -245,28 +245,6 @@ bool test_fhss_compare_with_synch_parent_address()
     return true;
 }
 
-bool test_fhss_use_broadcast_queue_cb()
-{
-    nsdynmemlib_stub.returnCounter = 1;
-    // Allocate instance
-    fhss_structure_t *fhss_ptr = fhss_allocate_instance(&fhss_api, &fhss_timer);
-    // Test without API
-    if (false != fhss_use_broadcast_queue_cb(NULL, true, FHSS_DATA_FRAME)) {
-        return false;
-    }
-    // Test synch request frame
-    if (false != fhss_use_broadcast_queue_cb(&fhss_api, true, FHSS_SYNCH_REQUEST_FRAME)) {
-        return false;
-    }
-    // Test data frame frame with broadcast address
-    if (true != fhss_use_broadcast_queue_cb(&fhss_api, true, FHSS_DATA_FRAME)) {
-        return false;
-    }
-    // Free allocated instance
-    fhss_free_instance(&fhss_api);
-    return true;
-}
-
 bool test_fhss_read_timestamp_cb()
 {
     fhss_platform_stub.timestamp_value = 100000;

test/nanostack/unittest/service_libs/fhss_common/test_fhss_common.h

@@ -21,7 +21,6 @@ bool test_fhss_timeout_stop();
 bool test_fhss_update_synch_parent_address();
 bool test_fhss_trig_event();
 bool test_fhss_compare_with_synch_parent_address();
-bool test_fhss_use_broadcast_queue_cb();
 bool test_fhss_read_timestamp_cb();
 bool test_fhss_init_callbacks_cb();
 bool test_fhss_clear_active_event();