Merge pull request ARMmbed#1923 from ARMmbed/IOTTHD-3080

Iotthd 3080

Author: Jarkko Paso

source/MAC/IEEE802_15_4/mac_header_helper_functions.c

@@ -26,6 +26,7 @@
 #include "MAC/IEEE802_15_4/mac_defines.h"
 #include "MAC/IEEE802_15_4/mac_mcps_sap.h"
 #include "MAC/IEEE802_15_4/mac_header_helper_functions.h"
+#include "MAC/rf_driver_storage.h"
 
 static uint8_t *mcps_mac_security_aux_header_start_pointer_get(const mac_pre_parsed_frame_t *buffer);
 static uint8_t *mac_header_information_elements_write(const mac_pre_build_frame_t *buffer, uint8_t *ptr);
@@ -569,7 +570,13 @@ uint8_t *mac_generic_packet_write(struct protocol_interface_rf_mac_setup *rf_ptr
         ptr += buffer->mac_payload_length;
     }
     if (rf_ptr->fhss_api) {
-        rf_ptr->fhss_api->write_synch_info(rf_ptr->fhss_api, ie_start, buffer->headerIeLength, FHSS_DATA_FRAME, buffer->tx_time);
+        if (buffer->fcf_dsn.frametype == FC_BEACON_FRAME) {
+            dev_driver_tx_buffer_s *tx_buf = &rf_ptr->dev_driver_tx_buffer;
+            uint8_t *synch_info = tx_buf->buf + rf_ptr->dev_driver->phy_driver->phy_header_length + tx_buf->len - FHSS_SYNCH_INFO_LENGTH;
+            rf_ptr->fhss_api->write_synch_info(rf_ptr->fhss_api, synch_info, FHSS_SYNCH_INFO_LENGTH, FHSS_SYNCH_FRAME, buffer->tx_time);
+        } else {
+            rf_ptr->fhss_api->write_synch_info(rf_ptr->fhss_api, ie_start, buffer->headerIeLength, FHSS_DATA_FRAME, buffer->tx_time);
+        }
     }
     return ptr;
 }

source/MAC/IEEE802_15_4/mac_mlme.c

@@ -1710,8 +1710,6 @@ int8_t mac_mlme_beacon_tx(protocol_interface_rf_mac_setup_s *rf_ptr)
         }*/
     }
     buf->priority = MAC_PD_DATA_HIGH_PRIOTITY;
-
-    tr_debug("BEA tx");
     mcps_sap_pd_req_queue_write(rf_ptr, buf);
     sw_mac_stats_update(rf_ptr, STAT_MAC_BEA_TX_COUNT, 0);
     return 0;

source/MAC/IEEE802_15_4/mac_pd_sap.c

@@ -400,13 +400,6 @@ static int8_t mac_data_interface_tx_done_cb(protocol_interface_rf_mac_setup_s *r
                 return -1;
             }
 
-            if (active_buf->fcf_dsn.frametype == FC_BEACON_FRAME) {
-                // FHSS synchronization info is written in the end of transmitted (Beacon) buffer
-                dev_driver_tx_buffer_s *tx_buf = &rf_ptr->dev_driver_tx_buffer;
-                uint8_t *synch_info = tx_buf->buf + rf_ptr->dev_driver->phy_driver->phy_header_length + tx_buf->len - FHSS_SYNCH_INFO_LENGTH;
-                rf_ptr->fhss_api->write_synch_info(rf_ptr->fhss_api, synch_info, 0, FHSS_SYNCH_FRAME, 0);
-            }
-
             // Change to destination channel and write synchronization info to Beacon frames here
             int tx_handle_retval = rf_ptr->fhss_api->tx_handle(rf_ptr->fhss_api, !mac_is_ack_request_set(active_buf),
                                                                active_buf->DstAddr, mac_convert_frame_type_to_fhss(active_buf->fcf_dsn.frametype),

source/Service_Libs/fhss/fhss.c

@@ -45,6 +45,7 @@ static int8_t fhss_beacon_create_tasklet(fhss_structure_t *fhss_structure);
 static void fhss_beacon_tasklet_func(arm_event_s *event);
 static int fhss_beacon_periodic_start(fhss_structure_t *fhss_structure, uint32_t time_to_first_beacon);
 static void fhss_beacon_periodic_stop(fhss_structure_t *fhss_structure);
+static int fhss_reset_synch_monitor(fhss_synch_monitor_s *synch_monitor);
 
 fhss_structure_t *fhss_enable(fhss_api_t *fhss_api, const fhss_configuration_t *fhss_configuration, const fhss_timer_t *fhss_timer, fhss_statistics_t *fhss_statistics)
 {
@@ -80,6 +81,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;
     }
+    fhss_reset_synch_monitor(&fhss_struct->bs->synch_monitor);
     ns_list_init(&fhss_struct->fhss_failed_tx_list);
     fhss_struct->own_hop = 0xff;
     fhss_reset(fhss_struct);
@@ -263,6 +265,11 @@ static int fhss_update_txrx_slots(fhss_structure_t *fhss_structure)
             tx_slot_up_limit += (tx_slot_length * 2);
         }
     }
+#ifdef FHSS_CHANNEL_DEBUG_CBS
+    if (fhss_bc_switch && fhss_structure->bs->tx_allowed != tx_allowed) {
+        fhss_bc_switch();
+    }
+#endif /*FHSS_CHANNEL_DEBUG_CBS*/
     fhss_structure->bs->tx_allowed = tx_allowed;
     return 0;
 }
@@ -735,7 +742,7 @@ static int16_t fhss_synch_state_set_callback(const fhss_api_t *api, fhss_states
             memcpy(fhss_structure->synch_parent, beacon_info->source_address, 8);
             platform_enter_critical();
             // Calculate time since the Beacon was received
-            uint32_t elapsed_time = fhss_structure->fhss_api->read_timestamp(fhss_structure->fhss_api) - beacon_info->timestamp;
+            uint32_t elapsed_time = fhss_structure->callbacks.read_timestamp(fhss_structure->fhss_api) - beacon_info->timestamp;
             // Synchronize to given PAN
             fhss_beacon_received(fhss_structure, beacon_info->synch_info, elapsed_time);
             platform_exit_critical();
@@ -978,7 +985,6 @@ static int fhss_tx_handle_callback(const fhss_api_t *api, bool is_broadcast_addr
     if (frame_type == FHSS_DATA_FRAME) {
         if (is_broadcast_addr == true) {
             if (fhss_is_current_channel_broadcast(fhss_structure) == false) {
-                tr_info("Broadcast on UC channel -> Back to queue");
                 return -3;
             }
         }
@@ -1059,7 +1065,7 @@ static uint8_t *fhss_beacon_encode_raw(uint8_t *buffer, const fhss_synchronizati
     return buffer;
 }
 
-static void fhss_beacon_build(fhss_structure_t *fhss_structure, uint8_t *dest)
+static void fhss_beacon_build(fhss_structure_t *fhss_structure, uint8_t *dest, uint32_t tx_time)
 {
     fhss_synchronization_beacon_payload_s temp_payload;
     platform_enter_critical();
@@ -1075,8 +1081,12 @@ static void fhss_beacon_build(fhss_structure_t *fhss_structure, uint8_t *dest)
     temp_payload.number_of_broadcast_channels = config->fhss_number_of_bc_channels;
     temp_payload.number_of_tx_slots = config->fhss_number_of_tx_slots;
     temp_payload.time_since_last_beacon = 0; // XXX not available yet
-    uint32_t tx_time = fhss_get_tx_time(fhss_structure, 71, 0, 0);
-    temp_payload.processing_delay = fhss_structure->bs->fhss_configuration.fhss_tuning_parameters.tx_processing_delay + tx_time;
+    uint32_t time_to_tx = 0;
+    uint32_t cur_time = fhss_structure->callbacks.read_timestamp(fhss_structure->fhss_api);
+    if (cur_time < tx_time) {
+        time_to_tx = tx_time - cur_time;
+    }
+    temp_payload.processing_delay = fhss_structure->bs->fhss_configuration.fhss_tuning_parameters.tx_processing_delay + time_to_tx;
     temp_payload.superframe_length = config->fhss_superframe_length;
     temp_payload.number_of_superframes_per_channel = config->fhss_number_of_superframes;
     platform_exit_critical();
@@ -1091,7 +1101,7 @@ static int16_t fhss_write_synch_info_callback(const fhss_api_t *api, uint8_t *pt
     if (!fhss_structure || !ptr || (frame_type != FHSS_SYNCH_FRAME)) {
         return -1;
     }
-    fhss_beacon_build(fhss_structure, ptr);
+    fhss_beacon_build(fhss_structure, ptr, tx_time);
     return FHSS_SYNCH_INFO_LENGTH;
 }
 
@@ -1123,6 +1133,9 @@ static bool fhss_data_tx_fail_callback(const fhss_api_t *api, uint8_t handle, in
     if (fhss_structure->fhss_state == FHSS_UNSYNCHRONIZED) {
         return false;
     }
+#ifdef FHSS_CHANNEL_DEBUG
+    tr_info("TX failed on ch: %u", debug_destination_channel);
+#endif /*FHSS_CHANNEL_DEBUG*/
     // Channel retries are disabled -> return
     if (fhss_structure->bs->fhss_configuration.fhss_number_of_channel_retries == 0) {
         return false;
@@ -1162,7 +1175,7 @@ static void fhss_receive_frame_callback(const fhss_api_t *api, uint16_t pan_id,
                 fhss_update_synch_parent_address(fhss_structure);
                 platform_enter_critical();
                 // Calculate time since the Beacon was received
-                uint32_t elapsed_time = api->read_timestamp(api) - timestamp;
+                uint32_t elapsed_time = fhss_structure->callbacks.read_timestamp(api) - timestamp;
                 // Synchronize to given PAN
                 fhss_beacon_received(fhss_structure, synch_info, elapsed_time);
                 platform_exit_critical();
@@ -1422,6 +1435,6 @@ static void fhss_beacon_tasklet_func(arm_event_s *event)
     }
     // Update Beacon info lifetimes
     else if (event->event_type == FHSS_UPDATE_SYNCH_INFO_STORAGE) {
-        fhss_update_beacon_info_lifetimes(fhss_structure, fhss_read_timestamp_cb(fhss_structure->fhss_api));
+        fhss_update_beacon_info_lifetimes(fhss_structure, fhss_structure->callbacks.read_timestamp(fhss_structure->fhss_api));
     }
 }

source/Service_Libs/fhss/fhss_channel.c

@@ -27,8 +27,14 @@
 
 #define TRACE_GROUP "fhss"
 
-// Enable this flag to use channel traces
-// #define FHSS_CHANNEL_DEBUG
+#ifdef FHSS_CHANNEL_DEBUG_CBS
+void (*fhss_uc_switch)(void) = NULL;
+void (*fhss_bc_switch)(void) = NULL;
+#endif /*FHSS_CHANNEL_DEBUG_CBS*/
+
+#ifdef FHSS_CHANNEL_DEBUG
+uint8_t debug_destination_channel = 0;
+#endif /*FHSS_CHANNEL_DEBUG*/
 
 static uint8_t fhss_get_bc_index(const fhss_structure_t *fhss_structure);
 
@@ -138,13 +144,22 @@ bool fhss_change_to_next_channel(fhss_structure_t *fhss_structure)
     next_channel = channel_list_get_channel(fhss_structure->bs->fhss_configuration.channel_mask, channel_index_tmp);
 
     fhss_structure->rx_channel = next_channel;
-#ifdef FHSS_CHANNEL_DEBUG
+
     if (fhss_is_current_channel_broadcast(fhss_structure) == true) {
+#ifdef FHSS_CHANNEL_DEBUG
         tr_info("%"PRIu32" BC %u", fhss_structure->platform_functions.fhss_get_timestamp(fhss_structure->fhss_api), next_channel);
+#endif /*FHSS_CHANNEL_DEBUG*/
     } else {
+#ifdef FHSS_CHANNEL_DEBUG_CBS
+        if (fhss_uc_switch) {
+            fhss_uc_switch();
+        }
+#endif /*FHSS_CHANNEL_DEBUG_CBS*/
+#ifdef FHSS_CHANNEL_DEBUG
         tr_info("%"PRIu32" UC %u", fhss_structure->platform_functions.fhss_get_timestamp(fhss_structure->fhss_api), next_channel);
-    }
 #endif /*FHSS_CHANNEL_DEBUG*/
+    }
+
     fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, next_channel);
     return broadcast_channel;
 }
@@ -231,7 +246,7 @@ int fhss_change_to_tx_channel(fhss_structure_t *fhss_structure, uint8_t *destina
             uint8_t destination_channel = fhss_get_destination_channel(fhss_structure, destination_address);
             fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, destination_channel);
 #ifdef FHSS_CHANNEL_DEBUG
-            tr_info("TX channel: %u", destination_channel);
+            debug_destination_channel = destination_channel;
 #endif /*FHSS_CHANNEL_DEBUG*/
         }
     }

source/Service_Libs/fhss/fhss_channel.h

@@ -24,4 +24,18 @@ int fhss_change_to_tx_channel(fhss_structure_t *fhss_structure, uint8_t *destina
 int fhss_change_to_parent_channel(fhss_structure_t *fhss_structure);
 int fhss_change_to_rx_channel(fhss_structure_t *fhss_structure);
 
+
+// Enable this flag to use channel traces
+// #define FHSS_CHANNEL_DEBUG
+// Enable this flag to use debug callbacks
+// #define FHSS_CHANNEL_DEBUG_CBS
+
+#ifdef FHSS_CHANNEL_DEBUG
+extern uint8_t debug_destination_channel;
+#endif /*FHSS_CHANNEL_DEBUG*/
+#ifdef FHSS_CHANNEL_DEBUG_CBS
+extern void (*fhss_uc_switch)(void);
+extern void (*fhss_bc_switch)(void);
+#endif /*FHSS_CHANNEL_DEBUG_CBS*/
+
 #endif /*FHSS_CHANNEL_H_*/

test/nanostack/unittest/service_libs/fhss/test_fhss.c

@@ -135,6 +135,7 @@ static fhss_api_t *test_generate_fhss_api(void)
     FHSS.callbacks.read_tx_queue_size = &mac_read_tx_queue_sizes;
     FHSS.callbacks.synch_lost_notification = &mac_synch_lost;
     FHSS.callbacks.broadcast_notify = &mac_broadcast_notification;
+    FHSS.callbacks.read_timestamp = &mac_read_phy_timestamp;
     test_set_fhss_default_configs();
     test_set_platform_api(&FHSS.platform_functions);
     fhss_set_callbacks(&FHSS);
@@ -640,7 +641,7 @@ bool test_fhss_beacon_tasklet_func()
     uint8_t source_address[8] = {1, 2, 3, 4, 5, 6, 7, 8};
     uint8_t synch_info[FHSS_SYNCH_INFO_LENGTH] = {0, 0, 1, 0, 5, 0x86, 0xa0, 0x03, 0xe7, 1, 10, 2, 0, 0, 0, 0, 0, 0, 0xc3, 0x50, 8};
     nsdynmemlib_stub.returnCounter = 1;
-    fhss_common_stub.uint32_value = DEFAULT_TIMESTAMP + (BEACON_INFO_LIFETIME * 1000000);
+    fhss_callbacks_stub.uint32_value = DEFAULT_TIMESTAMP + (BEACON_INFO_LIFETIME * 1000000);
     FHSS.fhss_api->receive_frame(api, DEFAULT_PANID, source_address, DEFAULT_TIMESTAMP, synch_info, FHSS_SYNCH_FRAME);
     event.event_type = FHSS_UPDATE_SYNCH_INFO_STORAGE;
     event_stub.func_ptr(&event);