FHSS: superframe handlers separated

Author: Jarkko Paso

source/Service_Libs/fhss/fhss.c

@@ -43,6 +43,7 @@ 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);
 
 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)
 {
@@ -371,20 +372,20 @@ static int fhss_sync_with_beacon(fhss_structure_t *fhss_structure,
             fhss_structure->own_hop = payload->hop_count + 1;
         }
         fhss_stats_update(fhss_structure, STATS_FHSS_HOP_COUNT, fhss_structure->own_hop);
-        fhss_structure->channel_list_counter = payload->channel_list_counter;
+        fhss_structure->bs->channel_list_counter = payload->channel_list_counter;
         fhss_structure->current_channel_index = payload->channel_index;
         uint8_t mac_address[8];
         fhss_structure->callbacks.read_mac_address(fhss_structure->fhss_api, mac_address);
 
-        fhss_structure->uc_channel_index = fhss_calculate_uc_index(fhss_structure->current_channel_index, fhss_structure->number_of_channels,
+        fhss_structure->bs->uc_channel_index = fhss_calculate_uc_index(fhss_structure->current_channel_index, fhss_structure->number_of_channels,
                 payload->number_of_broadcast_channels) + fhss_get_offset(fhss_structure, mac_address);
 
         // If current channel is not broadcast, fhss_update_channel will increase UC channel index, otherwise do it here
         if (fhss_is_current_channel_broadcast(fhss_structure) == true || (fhss_structure->fhss_state == FHSS_SYNCHRONIZED)) {
-            fhss_structure->uc_channel_index += 1;
+            fhss_structure->bs->uc_channel_index += 1;
         }
-        if (fhss_structure->uc_channel_index >= (fhss_structure->number_of_channels - payload->number_of_broadcast_channels)) {
-            fhss_structure->uc_channel_index -= (fhss_structure->number_of_channels - payload->number_of_broadcast_channels);
+        if (fhss_structure->bs->uc_channel_index >= (fhss_structure->number_of_channels - payload->number_of_broadcast_channels)) {
+            fhss_structure->bs->uc_channel_index -= (fhss_structure->number_of_channels - payload->number_of_broadcast_channels);
         }
 
         fhss_structure->platform_functions.fhss_timer_stop(fhss_superframe_handler, fhss_structure->fhss_api);
@@ -646,7 +647,7 @@ static int fhss_reset(fhss_structure_t *fhss_structure)
     fhss_beacon_periodic_stop(fhss_structure);
     fhss_structure->current_superframe = 0;
     fhss_structure->current_channel_index = 0;
-    fhss_structure->channel_list_counter = 0;
+    fhss_structure->bs->channel_list_counter = 0;
     if (fhss_is_synch_root(fhss_structure) == false) {
         fhss_structure->own_hop = 0xff;
     }
@@ -773,7 +774,7 @@ static void fhss_handle_state_set(const fhss_api_t *api, fhss_states fhss_state,
         fhss_set_datarate(fhss_structure, datarate);
         uint8_t mac_address[8];
         fhss_structure->callbacks.read_mac_address(fhss_structure->fhss_api, mac_address);
-        fhss_structure->uc_channel_index = fhss_get_offset(fhss_structure, mac_address);
+        fhss_structure->bs->uc_channel_index = fhss_get_offset(fhss_structure, mac_address);
         // Get Beacon info from storage
         fhss_beacon_info_t *beacon_info = fhss_get_beacon_info(fhss_structure, pan_id);
         if (beacon_info) {
@@ -928,8 +929,8 @@ static void fhss_update_channel_callback(fhss_structure_t *fhss_structure)
 {
     if (fhss_structure->current_channel_index == 0) {
         fhss_structure->synch_infos_sent_counter = 0;
-        if (++fhss_structure->channel_list_counter >= ((uint16_t) fhss_structure->number_of_channels * MAX_SCRAMBLE_TABLE_INDEXES)) {
-            fhss_structure->channel_list_counter = 0;
+        if (++fhss_structure->bs->channel_list_counter >= ((uint16_t) fhss_structure->number_of_channels * MAX_SCRAMBLE_TABLE_INDEXES)) {
+            fhss_structure->bs->channel_list_counter = 0;
         }
         if (fhss_is_synch_root(fhss_structure) == false) {
             fhss_trig_event(fhss_structure, FHSS_COMPARE_SYNCH_PARENT);
@@ -1089,6 +1090,43 @@ static uint16_t fhss_get_retry_period_callback(const fhss_api_t *api, uint8_t *d
     return retry_period;
 }
 
+static void fhss_superframe_handler(const fhss_api_t *fhss_api, uint16_t delay)
+{
+    uint32_t timeout = 0;
+    fhss_structure_t *fhss_structure = fhss_get_object_with_api(fhss_api);
+    if (!fhss_structure) {
+        return;
+    }
+
+    timeout = fhss_get_sf_timeout_callback(fhss_structure);
+
+    fhss_start_timer(fhss_structure, timeout - (delay * fhss_structure->platform_functions.fhss_resolution_divider), fhss_superframe_handler);
+
+    if (fhss_structure->current_superframe++ >= (fhss_structure->synch_configuration.fhss_number_of_superframes - 1)) {
+        fhss_structure->current_superframe = 0;
+        if (++fhss_structure->current_channel_index >= fhss_structure->number_of_channels) {
+            fhss_structure->current_channel_index = 0;
+        }
+        fhss_update_channel_callback(fhss_structure);
+    }
+    fhss_superframe_callback(fhss_structure);
+
+    if (fhss_structure->fhss_timeout) {
+        fhss_structure->fhss_timer += fhss_structure->synch_configuration.fhss_superframe_length;
+        if (fhss_structure->fhss_timer >= fhss_structure->fhss_timeout) {
+            fhss_trig_event(fhss_structure, FHSS_TIMER_EVENT);
+            fhss_structure->fhss_timeout = 0;
+            fhss_structure->fhss_timer = 0;
+        }
+    }
+}
+
+uint32_t fhss_get_remaining_time_to_next_superframe(const fhss_structure_t *fhss_structure)
+{
+    const uint32_t slots = fhss_structure->platform_functions.fhss_get_remaining_slots(fhss_superframe_handler, fhss_structure->fhss_api);
+    return (slots * fhss_structure->platform_functions.fhss_resolution_divider);
+}
+
 int fhss_set_callbacks(fhss_structure_t *fhss_structure)
 {
     // Set external API
@@ -1104,9 +1142,6 @@ int fhss_set_callbacks(fhss_structure_t *fhss_structure)
     fhss_structure->fhss_api->get_retry_period = &fhss_get_retry_period_callback;
     fhss_structure->fhss_api->write_synch_info = &fhss_write_synch_info_callback;
     fhss_structure->fhss_api->init_callbacks = &fhss_init_callbacks_cb;
-    // Set internal API
-    fhss_structure->update_channel = fhss_update_channel_callback;
-    fhss_structure->update_superframe = fhss_superframe_callback;
-    fhss_structure->read_superframe_timeout = fhss_get_sf_timeout_callback;
+
     return 0;
 }

source/Service_Libs/fhss/fhss.h

@@ -60,13 +60,22 @@ struct fhss_failed_tx
 
 struct fhss_bs
 {
+    uint8_t uc_channel_index;
+    uint16_t channel_list_counter;
     fhss_configuration_t fhss_configuration;
 };
 
 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);
 bool fhss_is_synch_root(fhss_structure_t *fhss_structure);
 void fhss_update_beacon_info_lifetimes(fhss_structure_t *fhss_structure, uint32_t timestamp);
 uint32_t fhss_get_tx_time(fhss_structure_t *fhss_structure, uint16_t bytes_to_send, uint8_t phy_header_length, uint8_t phy_tail_length);
+/**
+ * Calculate time in microseconds to start of next superframe.
+ *
+ * @param fhss_struct FHSS structure
+ * @return microseconds left to start of next superframe
+ */
+uint32_t fhss_get_remaining_time_to_next_superframe(const fhss_structure_t *fhss_struct);
 int fhss_set_callbacks(fhss_structure_t *fhss_structure);
 
 #endif /* FHSS_H_ */

source/Service_Libs/fhss/fhss_beacon.c

@@ -50,7 +50,7 @@ int fhss_beacon_update_payload(fhss_structure_t *fhss_structure,
     // This assumes that the time is always in the range of 0..2**16, which
     // should be the case as the superframe length field is also in that range.
     payload->remaining_slots = (uint16_t) fhss_get_remaining_time_to_next_superframe(fhss_structure);
-    payload->channel_list_counter = fhss_structure->channel_list_counter;
+    payload->channel_list_counter = fhss_structure->bs->channel_list_counter;
 
     payload->hop_count = fhss_structure->own_hop;
     payload->number_of_broadcast_channels = config->fhss_number_of_bc_channels;

source/Service_Libs/fhss/fhss_channel.c

@@ -114,7 +114,7 @@ bool fhss_change_to_next_channel(fhss_structure_t *fhss_structure)
 
     uint16_t number_of_channels = fhss_structure->number_of_channels;
     uint8_t number_of_broadcast_channels = fhss_structure->synch_configuration.fhss_number_of_bc_channels;
-    uint8_t unicast_channel_index = fhss_structure->uc_channel_index;
+    uint8_t unicast_channel_index = fhss_structure->bs->uc_channel_index;
     uint8_t channel_index_tmp;
 
     /* Get the channel number using channel index. Latter (number_of_broadcast_channels) indexes in channel table are broadcast channels and
@@ -129,14 +129,13 @@ bool fhss_change_to_next_channel(fhss_structure_t *fhss_structure)
         broadcast_channel = true;
     } else { /* Get unicast channel */
         channel_index_tmp = fhss_calc_channel_shuffle(unicast_channel_index, fhss_structure->number_of_channels, fhss_structure->synch_configuration.fhss_number_of_bc_channels);
-        fhss_structure->uc_channel_index++;
-        if (fhss_structure->uc_channel_index >= number_of_channels - number_of_broadcast_channels) {
-            fhss_structure->uc_channel_index = 0;
+        if (++fhss_structure->bs->uc_channel_index >= number_of_channels - number_of_broadcast_channels) {
+            fhss_structure->bs->uc_channel_index = 0;
         }
     }
     // Reset Beacon received flag when channel has changed
     fhss_structure->beacon_received_on_this_bc_channel = false;
-    channel_index_tmp = fhss_add_channel_list_counter(channel_index_tmp, fhss_structure->number_of_channels, fhss_structure->channel_list_counter, fhss_structure->fhss_scramble_table);
+    channel_index_tmp = fhss_add_channel_list_counter(channel_index_tmp, fhss_structure->number_of_channels, fhss_structure->bs->channel_list_counter, fhss_structure->fhss_scramble_table);
     next_channel = channel_list_get_channel(fhss_structure->bs->fhss_configuration.channel_mask, channel_index_tmp);
 
     fhss_structure->rx_channel = next_channel;
@@ -219,7 +218,7 @@ static uint8_t fhss_get_destination_channel(fhss_structure_t *fhss_structure, ui
             }
 
             uc_index = fhss_calc_channel_shuffle(uc_index, fhss_structure->number_of_channels, fhss_structure->synch_configuration.fhss_number_of_bc_channels);
-            uc_index = fhss_add_channel_list_counter(uc_index, fhss_structure->number_of_channels, fhss_structure->channel_list_counter, fhss_structure->fhss_scramble_table);
+            uc_index = fhss_add_channel_list_counter(uc_index, fhss_structure->number_of_channels, fhss_structure->bs->channel_list_counter, fhss_structure->fhss_scramble_table);
             return channel_list_get_channel(fhss_structure->bs->fhss_configuration.channel_mask, uc_index);
         }
         return fhss_structure->rx_channel;
@@ -261,7 +260,7 @@ int fhss_change_to_parent_channel(fhss_structure_t *fhss_structure)
                 uc_index -= (fhss_structure->number_of_channels - fhss_structure->synch_configuration.fhss_number_of_bc_channels);
             }
             uc_index = fhss_calc_channel_shuffle(uc_index, fhss_structure->number_of_channels, fhss_structure->synch_configuration.fhss_number_of_bc_channels);
-            uc_index = fhss_add_channel_list_counter(uc_index, fhss_structure->number_of_channels, fhss_structure->channel_list_counter, fhss_structure->fhss_scramble_table);
+            uc_index = fhss_add_channel_list_counter(uc_index, fhss_structure->number_of_channels, fhss_structure->bs->channel_list_counter, fhss_structure->fhss_scramble_table);
             destination_channel = channel_list_get_channel(fhss_structure->bs->fhss_configuration.channel_mask, uc_index);
             fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, destination_channel);
 #ifdef FHSS_CHANNEL_DEBUG

source/Service_Libs/fhss/fhss_common.c

@@ -255,45 +255,3 @@ int fhss_compare_with_synch_parent_address(fhss_structure_t *fhss_structure, con
     }
     return ret_val;
 }
-
-void fhss_superframe_handler(const fhss_api_t *fhss_api, uint16_t delay)
-{
-    uint32_t timeout = 0;
-    fhss_structure_t *fhss_structure = fhss_get_object_with_api(fhss_api);
-    if (!fhss_structure) {
-        return;
-    }
-
-    if (fhss_structure->read_superframe_timeout) {
-        timeout = fhss_structure->read_superframe_timeout(fhss_structure);
-    }
-
-    fhss_start_timer(fhss_structure, timeout - (delay * fhss_structure->platform_functions.fhss_resolution_divider), fhss_superframe_handler);
-
-    if (fhss_structure->current_superframe++ >= (fhss_structure->synch_configuration.fhss_number_of_superframes - 1)) {
-        fhss_structure->current_superframe = 0;
-        if (++fhss_structure->current_channel_index >= fhss_structure->number_of_channels) {
-            fhss_structure->current_channel_index = 0;
-        }
-        if (fhss_structure->update_channel) {
-            fhss_structure->update_channel(fhss_structure);
-        }
-    }
-    if (fhss_structure->update_superframe) {
-        fhss_structure->update_superframe(fhss_structure);
-    }
-    if (fhss_structure->fhss_timeout) {
-        fhss_structure->fhss_timer += fhss_structure->synch_configuration.fhss_superframe_length;
-        if (fhss_structure->fhss_timer >= fhss_structure->fhss_timeout) {
-            fhss_trig_event(fhss_structure, FHSS_TIMER_EVENT);
-            fhss_structure->fhss_timeout = 0;
-            fhss_structure->fhss_timer = 0;
-        }
-    }
-}
-
-uint32_t fhss_get_remaining_time_to_next_superframe(const fhss_structure_t *fhss_structure)
-{
-    const uint32_t slots = fhss_structure->platform_functions.fhss_get_remaining_slots(fhss_superframe_handler, fhss_structure->fhss_api);
-    return (slots * fhss_structure->platform_functions.fhss_resolution_divider);
-}

source/Service_Libs/fhss/fhss_common.h

@@ -24,25 +24,6 @@
 
 typedef NS_LIST_HEAD(fhss_failed_tx_t, link) fhss_failed_tx_list_t;
 
-/**
- * @brief Update listening channel.
- * @param fhss_structure FHSS structure.
- */
-typedef void fhss_update_channel_cb(fhss_structure_t *fhss_structure);
-
-/**
- * @brief Update superframe.
- * @param fhss_structure FHSS structure.
- */
-typedef void fhss_update_superframe_cb(fhss_structure_t *fhss_structure);
-
-/**
- * @brief Read next FHSS superframe timeout length.
- * @param fhss_structure FHSS structure.
- * @return timeout (us)
- */
-typedef uint32_t fhss_read_superframe_timeout_cb(fhss_structure_t *fhss_structure);
-
 struct fhss_structure
 {
     fhss_api_t *fhss_api;
@@ -52,18 +33,12 @@ struct fhss_structure
     fhss_synch_configuration_t synch_configuration;
 
     uint8_t fhss_resolution_divider;
-    /** Unicast channel index, [0..(number_of_channels-number_of_beacon_channels-1)] */
-    uint8_t uc_channel_index;
     /** Current superframe number, [0..(fhss_number_of_superframes-1)] */
     uint8_t current_superframe;
     /** Current channel index, [0..(number_of channels-1)] */
     uint8_t current_channel_index;
-    /** Current broadcast index, [0..(number_of_bc_channels-1)] */
-    uint8_t broadcast_index;
     /** Number of channels (unicast and broadcast) */
     uint16_t number_of_channels;
-    /** Channel list counter is increased every time channel list is gone through*/
-    uint16_t channel_list_counter;
     /** This is used to store current RX channel*/
     uint8_t rx_channel;
     /** Own hop count*/
@@ -104,9 +79,6 @@ struct fhss_structure
 
     struct fhss_bs *bs;
     struct fhss_ws *ws;
-    fhss_update_channel_cb *update_channel;    /**< Update listening channel */
-    fhss_update_superframe_cb *update_superframe;    /**< Update superframe */
-    fhss_read_superframe_timeout_cb *read_superframe_timeout;    /**< Read next FHSS superframe timeout length */
 };
 
 fhss_structure_t *fhss_allocate_instance(fhss_api_t *fhss_api, const fhss_timer_t *fhss_timer);
@@ -122,12 +94,4 @@ 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);
-void fhss_superframe_handler(const fhss_api_t *fhss_api, uint16_t delay);
-/**
- * Calculate time in microseconds to start of next superframe.
- *
- * @param fhss_struct FHSS structure
- * @return microseconds left to start of next superframe
- */
-uint32_t fhss_get_remaining_time_to_next_superframe(const fhss_structure_t *fhss_struct);
 #endif /*FHSS_COMMON_H_*/

source/Service_Libs/fhss/fhss_ws.c

@@ -36,6 +36,7 @@
 #define DEF_2E16 16777216
 
 static void fhss_ws_update_uc_channel_callback(fhss_structure_t *fhss_structure);
+static void fhss_unicast_handler(const fhss_api_t *fhss_api, uint16_t delay);
 
 fhss_structure_t *fhss_ws_enable(fhss_api_t *fhss_api, const fhss_ws_configuration_t *fhss_configuration, const fhss_timer_t *fhss_timer)
 {
@@ -133,7 +134,7 @@ static uint32_t fhss_ws_calculate_ufsi(fhss_structure_t *fhss_structure, uint32_
         cur_slot = fhss_structure->number_of_channels;
     }
     cur_slot--;
-    uint32_t remaining_time = (fhss_structure->platform_functions.fhss_get_remaining_slots(fhss_superframe_handler, fhss_structure->fhss_api) / 1000);
+    uint32_t remaining_time = (fhss_structure->platform_functions.fhss_get_remaining_slots(fhss_unicast_handler, fhss_structure->fhss_api) / 1000);
     uint32_t time_to_tx = (tx_time - fhss_structure->fhss_api->read_timestamp(fhss_structure->fhss_api)) / 1000;
     uint32_t ms_since_seq_start = (cur_slot * dwell_time) + (dwell_time-remaining_time) + time_to_tx;
     ms_since_seq_start %= (dwell_time*fhss_structure->number_of_channels);
@@ -176,18 +177,13 @@ static void fhss_ws_handle_state_set(const fhss_api_t *api, fhss_states fhss_sta
         }
         // Start unicast schedule
         fhss_ws_update_uc_channel_callback(fhss_structure);
-        fhss_start_timer(fhss_structure, fhss_structure->ws->fhss_configuration.fhss_uc_dwell_interval*1000, fhss_superframe_handler);
+        fhss_start_timer(fhss_structure, fhss_structure->ws->fhss_configuration.fhss_uc_dwell_interval*1000, fhss_unicast_handler);
     }
 
     fhss_structure->fhss_state = fhss_state;
     return;
 }
 
-static void fhss_ws_superframe_callback(fhss_structure_t *fhss_structure)
-{
-    (void) fhss_structure;
-}
-
 static void fhss_ws_update_uc_channel_callback(fhss_structure_t *fhss_structure)
 {
     uint8_t mac_address[8];
@@ -304,6 +300,18 @@ static void fhss_ws_receive_frame_callback(const fhss_api_t *api, uint16_t pan_i
     (void) frame_type;
 }
 
+static void fhss_unicast_handler(const fhss_api_t *fhss_api, uint16_t delay)
+{
+    uint32_t timeout = 0;
+    fhss_structure_t *fhss_structure = fhss_get_object_with_api(fhss_api);
+    if (!fhss_structure) {
+        return;
+    }
+    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);
+}
+
 int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure)
 {
     // Set external API
@@ -319,9 +327,5 @@ int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure)
     fhss_structure->fhss_api->get_retry_period = NULL;
     fhss_structure->fhss_api->write_synch_info = &fhss_ws_write_synch_info_callback;
     fhss_structure->fhss_api->init_callbacks = &fhss_init_callbacks_cb;
-    // Set internal API
-    fhss_structure->update_channel = fhss_ws_update_uc_channel_callback;
-    fhss_structure->update_superframe = fhss_ws_superframe_callback;
-    fhss_structure->read_superframe_timeout = fhss_ws_get_sf_timeout_callback;
     return 0;
 }

test/nanostack/unittest/service_libs/fhss/fhsstest.cpp

@@ -44,11 +44,6 @@ TEST(fhss, test_fhss_event_timer_cb)
     CHECK(test_fhss_event_timer_cb());
 }
 
-TEST(fhss, test_fhss_superframe_handler)
-{
-    CHECK(test_fhss_superframe_handler());
-}
-
 TEST(fhss, test_fhss_update_synch_parent_address)
 {
     CHECK(test_fhss_update_synch_parent_address());