FHSS: Continued fhss_structure cleaning

Author: Jarkko Paso

source/Service_Libs/fhss/fhss.c

@@ -57,12 +57,31 @@ struct fhss_failed_tx
     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;
+    uint8_t current_superframe;
+    uint8_t current_channel_index;
+    uint8_t own_hop;
+    uint8_t beacons_received_timer;
+    uint8_t broadcast_start_superframe;
+    uint8_t synch_infos_sent_counter;
+    bool tx_allowed;
+    bool send_synch_info_on_next_broadcast_channel;
+    bool beacon_received_on_this_bc_channel;
     uint16_t channel_list_counter;
-    fhss_configuration_t fhss_configuration;
+    uint16_t synch_panid;
+    uint32_t synch_interval;
+    struct fhss_statistics *fhss_stats_ptr;
+    struct fhss_beacon_info *fhss_beacon_info_store;
+    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];
 };
 
 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);
@@ -76,6 +95,7 @@ uint32_t fhss_get_tx_time(fhss_structure_t *fhss_structure, uint16_t bytes_to_se
  * @return microseconds left to start of next superframe
  */
 uint32_t fhss_get_remaining_time_to_next_superframe(const fhss_structure_t *fhss_struct);
+int8_t fhss_set_synch_configuration(fhss_structure_t *fhss_structure, const fhss_synch_configuration_t *fhss_synch_configuration);
 int fhss_set_callbacks(fhss_structure_t *fhss_structure);
 
 #endif /* FHSS_H_ */

source/Service_Libs/fhss/fhss.h

@@ -39,20 +39,20 @@ int fhss_beacon_update_payload(fhss_structure_t *fhss_structure,
         return -1;
     }
 
-    const fhss_synch_configuration_t *config = &fhss_structure->synch_configuration;
+    const fhss_synch_configuration_t *config = &fhss_structure->bs->synch_configuration;
 
-    payload->channel_index = fhss_structure->current_channel_index;
+    payload->channel_index = fhss_structure->bs->current_channel_index;
 
     payload->sender_unicast_channel = 0;
 
-    payload->current_superframe = fhss_structure->current_superframe;
+    payload->current_superframe = fhss_structure->bs->current_superframe;
 
     // 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->bs->channel_list_counter;
 
-    payload->hop_count = fhss_structure->own_hop;
+    payload->hop_count = fhss_structure->bs->own_hop;
     payload->number_of_broadcast_channels = config->fhss_number_of_bc_channels;
     payload->number_of_tx_slots = config->fhss_number_of_tx_slots;
     payload->time_since_last_beacon = 0; // XXX not available yet

source/Service_Libs/fhss/fhss_beacon.c

@@ -74,21 +74,21 @@ static void fhss_beacon_tasklet_func(arm_event_s* event)
     // skip the init event as there will be a timer event after
     if (event->event_type == FHSS_TIMER_EVENT) {
         // Stop network when lost number of FHSS_SYNCHRONIZATION_LOST synchronization beacons from parent in a row.
-        if (fhss_structure->beacons_received_timer >= FHSS_SYNCHRONIZATION_LOST) {
+        if (fhss_structure->bs->beacons_received_timer >= FHSS_SYNCHRONIZATION_LOST) {
             fhss_structure->callbacks.synch_lost_notification(fhss_structure->fhss_api);
             fhss_stats_update(fhss_structure, STATS_FHSS_SYNCH_LOST, 1);
             tr_err("FHSS synchronization lost");
         } else {
-            uint16_t bc_density = (fhss_structure->number_of_channels / fhss_structure->synch_configuration.fhss_number_of_bc_channels);
-            uint16_t channel_dwell_time = ((uint32_t)fhss_structure->synch_configuration.fhss_superframe_length * fhss_structure->synch_configuration.fhss_number_of_superframes) / 1000;
+            uint16_t bc_density = (fhss_structure->number_of_channels / fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
+            uint16_t channel_dwell_time = ((uint32_t)fhss_structure->bs->synch_configuration.fhss_superframe_length * fhss_structure->bs->synch_configuration.fhss_number_of_superframes) / 1000;
 
             fhss_beacon_periodic_start(fhss_structure, (bc_density * channel_dwell_time) * 2);
             // Send synchronization request
             fhss_structure->callbacks.send_fhss_frame(fhss_structure->fhss_api, FHSS_SYNCH_REQUEST_FRAME);
-            fhss_structure->beacons_received_timer++;
+            fhss_structure->bs->beacons_received_timer++;
 #ifdef FEA_TRACE_SUPPORT
             if (!fhss_get_parent_address(fhss_structure, parent_address)) {
-                tr_debug("Update synch, attempt: %u, %s", fhss_structure->beacons_received_timer, trace_array(parent_address, 8));
+                tr_debug("Update synch, attempt: %u, %s", fhss_structure->bs->beacons_received_timer, trace_array(parent_address, 8));
             } else {
                 tr_err("No synch parent found");
             }
@@ -99,9 +99,9 @@ static void fhss_beacon_tasklet_func(arm_event_s* event)
     else if(event->event_type == FHSS_COMPARE_SYNCH_PARENT)
     {
         if (fhss_compare_with_synch_parent_address(fhss_structure, fhss_structure->synch_parent)) {
-            fhss_structure->synch_monitor.avg_synch_fix = 0;
-            if(fhss_structure->synch_monitor.avg_synch_fix_counter > 0) {
-                fhss_structure->synch_monitor.avg_synch_fix_counter = 0;
+            fhss_structure->bs->synch_monitor.avg_synch_fix = 0;
+            if(fhss_structure->bs->synch_monitor.avg_synch_fix_counter > 0) {
+                fhss_structure->bs->synch_monitor.avg_synch_fix_counter = 0;
             }
             // Send synchronization request
             fhss_structure->callbacks.send_fhss_frame(fhss_structure->fhss_api, FHSS_SYNCH_REQUEST_FRAME);
@@ -116,8 +116,8 @@ static void fhss_beacon_tasklet_func(arm_event_s* event)
     }
     else if(event->event_type == FHSS_BROADCAST_CHANNEL)
     {
-        uint16_t superframe_length = fhss_structure->synch_configuration.fhss_superframe_length;
-        uint8_t number_of_superframes = fhss_structure->synch_configuration.fhss_number_of_superframes;
+        uint16_t superframe_length = fhss_structure->bs->synch_configuration.fhss_superframe_length;
+        uint8_t number_of_superframes = fhss_structure->bs->synch_configuration.fhss_number_of_superframes;
         // Given broadcast time is channel length minus 1 superframe
         fhss_structure->callbacks.broadcast_notify(fhss_structure->fhss_api, (uint32_t)superframe_length * (number_of_superframes - 1));
     }

source/Service_Libs/fhss/fhss_beacon_tasklet.c

@@ -91,10 +91,10 @@ uint8_t fhss_add_channel_list_counter(uint8_t index, uint16_t number_of_channels
 static void fhss_generate_broadcast_start_superframe(fhss_structure_t *fhss_structure)
 {
     // If the number of superframes is low, allow broadcast on any superframe
-    if (fhss_structure->synch_configuration.fhss_number_of_superframes < 8) {
-        fhss_structure->broadcast_start_superframe = 0;
+    if (fhss_structure->bs->synch_configuration.fhss_number_of_superframes < 8) {
+        fhss_structure->bs->broadcast_start_superframe = 0;
     } else {
-        fhss_structure->broadcast_start_superframe = randLIB_get_random_in_range(0, NUMBER_OF_BC_START_SUPERFRAMES - 1);
+        fhss_structure->bs->broadcast_start_superframe = randLIB_get_random_in_range(0, NUMBER_OF_BC_START_SUPERFRAMES - 1);
     }
 }
 
@@ -113,7 +113,7 @@ bool fhss_change_to_next_channel(fhss_structure_t *fhss_structure)
     bool broadcast_channel = false;
 
     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 number_of_broadcast_channels = fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels;
     uint8_t unicast_channel_index = fhss_structure->bs->uc_channel_index;
     uint8_t channel_index_tmp;
 
@@ -124,18 +124,18 @@ bool fhss_change_to_next_channel(fhss_structure_t *fhss_structure)
      */
     /* Get broadcast channel */
     if (fhss_is_current_channel_broadcast(fhss_structure) == true) {
-        channel_index_tmp = fhss_calc_channel_shuffle((number_of_channels - number_of_broadcast_channels) + fhss_get_bc_index(fhss_structure), fhss_structure->number_of_channels, fhss_structure->synch_configuration.fhss_number_of_bc_channels);
+        channel_index_tmp = fhss_calc_channel_shuffle((number_of_channels - number_of_broadcast_channels) + fhss_get_bc_index(fhss_structure), fhss_structure->number_of_channels, fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
         fhss_generate_broadcast_start_superframe(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);
+        channel_index_tmp = fhss_calc_channel_shuffle(unicast_channel_index, fhss_structure->number_of_channels, fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
         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->bs->channel_list_counter, fhss_structure->fhss_scramble_table);
+    fhss_structure->bs->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->bs->channel_list_counter, fhss_structure->bs->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;
@@ -153,8 +153,8 @@ bool fhss_change_to_next_channel(fhss_structure_t *fhss_structure)
 static uint8_t fhss_get_bc_index(const fhss_structure_t *fhss_structure)
 {
     uint16_t number_of_channels = fhss_structure->number_of_channels;
-    uint8_t number_of_bc_channels = fhss_structure->synch_configuration.fhss_number_of_bc_channels;
-    uint8_t cur_channel_index = fhss_structure->current_channel_index;
+    uint8_t number_of_bc_channels = fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels;
+    uint8_t cur_channel_index = fhss_structure->bs->current_channel_index;
 
     return cur_channel_index / (number_of_channels/number_of_bc_channels);
 }
@@ -164,7 +164,7 @@ uint8_t fhss_get_offset(fhss_structure_t *fhss_structure, const uint8_t *ptr)
     uint8_t i;
     uint8_t index = *ptr++;
 
-    if (fhss_structure->number_of_channels == fhss_structure->synch_configuration.fhss_number_of_bc_channels) {
+    if (fhss_structure->number_of_channels == fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels) {
         // If all channels are defined as broadcast channels then return 0 to avoid division by 0.
         // This could happen e.g. in OTA case when fast download is needed.
         return 0;
@@ -176,7 +176,7 @@ uint8_t fhss_get_offset(fhss_structure_t *fhss_structure, const uint8_t *ptr)
         index ^= *ptr++;
     }
     // Offset must be < number of unicast channels
-    index %= (fhss_structure->number_of_channels - fhss_structure->synch_configuration.fhss_number_of_bc_channels);
+    index %= (fhss_structure->number_of_channels - fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
 
     return index;
 }
@@ -189,13 +189,13 @@ bool fhss_is_current_channel_broadcast(fhss_structure_t *fhss_structure)
     }
 
     // Should always have broadcast channels with FHSS
-    if (!fhss_structure->synch_configuration.fhss_number_of_bc_channels) {
+    if (!fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels) {
         return true;
     }
 
-    uint8_t channel_index = fhss_structure->current_channel_index;
+    uint8_t channel_index = fhss_structure->bs->current_channel_index;
     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 number_of_broadcast_channels = fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels;
 
     if (!(channel_index % (number_of_channels / number_of_broadcast_channels))) {
         return true;
@@ -211,14 +211,14 @@ static uint8_t fhss_get_destination_channel(fhss_structure_t *fhss_structure, ui
     if (fhss_structure) {
         if (fhss_is_current_channel_broadcast(fhss_structure) == false) {
             destination_offset = fhss_get_offset(fhss_structure, destination_address);
-            uc_index = fhss_calculate_uc_index(fhss_structure->current_channel_index, fhss_structure->number_of_channels,
-                    fhss_structure->synch_configuration.fhss_number_of_bc_channels) + destination_offset;
-            if (uc_index >= (fhss_structure->number_of_channels - fhss_structure->synch_configuration.fhss_number_of_bc_channels)) {
-                uc_index -= (fhss_structure->number_of_channels - fhss_structure->synch_configuration.fhss_number_of_bc_channels);
+            uc_index = fhss_calculate_uc_index(fhss_structure->bs->current_channel_index, fhss_structure->number_of_channels,
+                    fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels) + destination_offset;
+            if (uc_index >= (fhss_structure->number_of_channels - fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels)) {
+                uc_index -= (fhss_structure->number_of_channels - fhss_structure->bs->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->bs->channel_list_counter, fhss_structure->fhss_scramble_table);
+            uc_index = fhss_calc_channel_shuffle(uc_index, fhss_structure->number_of_channels, fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
+            uc_index = fhss_add_channel_list_counter(uc_index, fhss_structure->number_of_channels, fhss_structure->bs->channel_list_counter, fhss_structure->bs->fhss_scramble_table);
             return channel_list_get_channel(fhss_structure->bs->fhss_configuration.channel_mask, uc_index);
         }
         return fhss_structure->rx_channel;
@@ -246,21 +246,21 @@ int fhss_change_to_parent_channel(fhss_structure_t *fhss_structure)
     uint8_t destination_channel;
     uint8_t destination_offset;
     if (fhss_structure) {
-        if (fhss_structure->number_of_channels != fhss_structure->synch_configuration.fhss_number_of_bc_channels) {
+        if (fhss_structure->number_of_channels != fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels) {
             uint8_t parent_address[8];
             if (fhss_get_parent_address(fhss_structure, parent_address)) {
                 return -1;
             }
 
             destination_offset = fhss_get_offset(fhss_structure, parent_address);
 
-            uc_index = fhss_calculate_uc_index(fhss_structure->current_channel_index, fhss_structure->number_of_channels,
-                    fhss_structure->synch_configuration.fhss_number_of_bc_channels) + destination_offset;
-            if (uc_index >= (fhss_structure->number_of_channels - fhss_structure->synch_configuration.fhss_number_of_bc_channels)) {
-                uc_index -= (fhss_structure->number_of_channels - fhss_structure->synch_configuration.fhss_number_of_bc_channels);
+            uc_index = fhss_calculate_uc_index(fhss_structure->bs->current_channel_index, fhss_structure->number_of_channels,
+                    fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels) + destination_offset;
+            if (uc_index >= (fhss_structure->number_of_channels - fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels)) {
+                uc_index -= (fhss_structure->number_of_channels - fhss_structure->bs->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->bs->channel_list_counter, fhss_structure->fhss_scramble_table);
+            uc_index = fhss_calc_channel_shuffle(uc_index, fhss_structure->number_of_channels, fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
+            uc_index = fhss_add_channel_list_counter(uc_index, fhss_structure->number_of_channels, fhss_structure->bs->channel_list_counter, fhss_structure->bs->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_channel.c

@@ -93,31 +93,6 @@ int8_t fhss_set_datarate(fhss_structure_t *fhss_structure, uint32_t datarate)
     return 0;
 }
 
-int8_t fhss_set_synch_configuration(fhss_structure_t *fhss_structure, const fhss_synch_configuration_t *fhss_synch_configuration)
-{
-    if (!fhss_structure) {
-        return -1;
-    }
-    if (!fhss_synch_configuration) {
-        return -2;
-    }
-    // None of the configurations can be set zero
-    if( fhss_synch_configuration->fhss_number_of_bc_channels == 0 || fhss_synch_configuration->fhss_number_of_tx_slots == 0
-            || fhss_synch_configuration->fhss_number_of_superframes == 0 || fhss_synch_configuration->fhss_superframe_length == 0) {
-        return -3;
-    }
-    // Number of channels must be divisible with the number of broadcast channels.
-    // Number of superframes must be divisible with the number of TX slots
-    if (((fhss_structure->number_of_channels % fhss_synch_configuration->fhss_number_of_bc_channels) != 0) ||
-            ((fhss_synch_configuration->fhss_number_of_superframes % fhss_synch_configuration->fhss_number_of_tx_slots) != 0) ||
-            (fhss_synch_configuration->fhss_number_of_superframes <= fhss_synch_configuration->fhss_number_of_tx_slots)) {
-        return -4;
-    }
-    fhss_structure->synch_configuration = *fhss_synch_configuration;
-    fhss_structure->own_hop = 0;
-    return 0;
-}
-
 fhss_structure_t *fhss_get_object_with_api(const fhss_api_t *fhss_api)
 {
     if (!fhss_api || !fhss_struct) {