FHSS: Separate FHSS and WS parameters

- Configuration structs moved

Author: Jarkko Paso

source/Service_Libs/fhss/fhss.c

@@ -59,16 +59,23 @@ fhss_structure_t *fhss_enable(fhss_api_t *fhss_api, const fhss_configuration_t *
     if (!fhss_struct) {
         return NULL;
     }
-    fhss_struct->fhss_conf.fhss_configuration = *fhss_configuration;
+    fhss_struct->bs = ns_dyn_mem_alloc(sizeof(fhss_bs_t));
+    if (!fhss_struct->bs) {
+        ns_dyn_mem_free(fhss_struct);
+        return NULL;
+    }
+    memset(fhss_struct->bs, 0, sizeof(fhss_bs_t));
+
+    fhss_struct->bs->fhss_configuration = *fhss_configuration;
     fhss_struct->fhss_stats_ptr = fhss_statistics;
     fhss_struct->number_of_channels = channel_count;
 
     // set a invalid id to tasklet_id, so we know that one is not started yet
     fhss_struct->beacon_tasklet_id = -1;
 
     // Default synch interval is 240 seconds
-    if (!fhss_struct->fhss_conf.fhss_configuration.fhss_max_synch_interval) {
-        fhss_struct->fhss_conf.fhss_configuration.fhss_max_synch_interval = 240;
+    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->fhss_failed_tx_list);
     fhss_struct->own_hop = 0xff;
@@ -262,7 +269,7 @@ static int fhss_update_drift_compensation(fhss_structure_t *fhss_structure)
     bc_density = (fhss_structure->number_of_channels / fhss_structure->synch_configuration.fhss_number_of_bc_channels);
     channel_dwell_time = ((uint32_t)fhss_structure->synch_configuration.fhss_superframe_length * fhss_structure->synch_configuration.fhss_number_of_superframes) / 1000;
     // Calculate last synchronisation period
-    if (fhss_structure->synch_interval != ((uint32_t)fhss_structure->fhss_conf.fhss_configuration.fhss_max_synch_interval * 1000)) {
+    if (fhss_structure->synch_interval != ((uint32_t)fhss_structure->bs->fhss_configuration.fhss_max_synch_interval * 1000)) {
         // Last period was half of the current started period and max random period is shorter
         synch_period = (fhss_structure->synch_interval / 2) + (bc_density * channel_dwell_time) * (fhss_structure->synch_configuration.fhss_number_of_bc_channels / 2);
     } else {
@@ -401,14 +408,14 @@ static int fhss_sync_with_beacon(fhss_structure_t *fhss_structure,
 
             if (fhss_structure->fhss_state == FHSS_SYNCHRONIZED) {
                 if (fhss_update_synch_monitor(fhss_structure, payload, superframe_own, remaining_time_own, time_to_next_superframe)) {
-                    fhss_structure->synch_interval = (uint32_t) (fhss_structure->fhss_conf.fhss_configuration.fhss_max_synch_interval/BEACON_INTERVAL_INIT_DIVIDER) * 1000;
+                    fhss_structure->synch_interval = (uint32_t) (fhss_structure->bs->fhss_configuration.fhss_max_synch_interval/BEACON_INTERVAL_INIT_DIVIDER) * 1000;
                 }
             }
 
-            if (fhss_structure->synch_interval != ((uint32_t)fhss_structure->fhss_conf.fhss_configuration.fhss_max_synch_interval * 1000)) {
+            if (fhss_structure->synch_interval != ((uint32_t)fhss_structure->bs->fhss_configuration.fhss_max_synch_interval * 1000)) {
                 fhss_structure->synch_interval *= 2;
-                if (fhss_structure->synch_interval > ((uint32_t)fhss_structure->fhss_conf.fhss_configuration.fhss_max_synch_interval * 1000)) {
-                    fhss_structure->synch_interval = ((uint32_t)fhss_structure->fhss_conf.fhss_configuration.fhss_max_synch_interval * 1000);
+                if (fhss_structure->synch_interval > ((uint32_t)fhss_structure->bs->fhss_configuration.fhss_max_synch_interval * 1000)) {
+                    fhss_structure->synch_interval = ((uint32_t)fhss_structure->bs->fhss_configuration.fhss_max_synch_interval * 1000);
                 }
                 beacon_interval_random = (bc_density * channel_dwell_time) * randLIB_get_random_in_range(0, fhss_number_of_bc_channels/2);
             } else {
@@ -491,8 +498,8 @@ static bool fhss_check_remaining_tx_time(fhss_structure_t *fhss_structure, uint1
     if (fhss_structure->fhss_state == FHSS_UNSYNCHRONIZED) {
         retval = true;
     } else {
-        tx_processing_delay = fhss_structure->fhss_conf.fhss_configuration.fhss_tuning_parameters.tx_processing_delay;
-        ack_processing_delay = fhss_structure->fhss_conf.fhss_configuration.fhss_tuning_parameters.ack_processing_delay;
+        tx_processing_delay = fhss_structure->bs->fhss_configuration.fhss_tuning_parameters.tx_processing_delay;
+        ack_processing_delay = fhss_structure->bs->fhss_configuration.fhss_tuning_parameters.ack_processing_delay;
         // Calculate needed TX time (us): CCA static period + TX processing delays + transmission time + Ack processing delays + Ack transmission time
         needed_tx_time = CCA_FHSS_PERIOD + tx_processing_delay + fhss_get_tx_time(fhss_structure, tx_length, phy_header_length, phy_tail_length)
                         + ack_processing_delay + fhss_get_tx_time(fhss_structure, ACK_LENGTH, phy_header_length, phy_tail_length);
@@ -644,7 +651,7 @@ static int fhss_reset(fhss_structure_t *fhss_structure)
         fhss_structure->own_hop = 0xff;
     }
     fhss_structure->tx_allowed = false;
-    fhss_structure->synch_interval = (uint32_t) (fhss_structure->fhss_conf.fhss_configuration.fhss_max_synch_interval/BEACON_INTERVAL_INIT_DIVIDER) * 1000;
+    fhss_structure->synch_interval = (uint32_t) (fhss_structure->bs->fhss_configuration.fhss_max_synch_interval/BEACON_INTERVAL_INIT_DIVIDER) * 1000;
     fhss_structure->rx_channel = 0;
     fhss_structure->beacons_received_timer = 0;
     memset(fhss_structure->synch_parent, 0xff, 8);
@@ -807,7 +814,7 @@ static void fhss_beacon_received(fhss_structure_t *fhss_structure, const uint8_t
 
         if (synch_info) {
             fhss_synchronization_beacon_payload_s temp_payload;
-            temp_payload.processing_delay = fhss_structure->fhss_conf.fhss_configuration.fhss_tuning_parameters.rx_processing_delay;
+            temp_payload.processing_delay = fhss_structure->bs->fhss_configuration.fhss_tuning_parameters.rx_processing_delay;
             fhss_beacon_decode(&temp_payload, synch_info, elapsed_time, fhss_structure->number_of_channels);
 
             // use the received information
@@ -985,7 +992,7 @@ static bool fhss_data_tx_fail_callback(const fhss_api_t *api, uint8_t handle, in
         return false;
     }
     // Channel retries are disabled -> return
-    if (fhss_structure->fhss_conf.fhss_configuration.fhss_number_of_channel_retries == 0) {
+    if (fhss_structure->bs->fhss_configuration.fhss_number_of_channel_retries == 0) {
         return false;
     }
     // Use channel retries only for data frames
@@ -996,7 +1003,7 @@ static bool fhss_data_tx_fail_callback(const fhss_api_t *api, uint8_t handle, in
     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 >= fhss_structure->fhss_conf.fhss_configuration.fhss_number_of_channel_retries) {
+        if (fhss_failed_tx->retries_done >= fhss_structure->bs->fhss_configuration.fhss_number_of_channel_retries) {
             // No more retries. Return false to stop retransmitting.
             fhss_failed_handle_remove(fhss_structure, handle);
             return false;

source/Service_Libs/fhss/fhss.h

@@ -31,6 +31,7 @@ typedef struct fhss_structure fhss_structure_t;
 typedef struct fhss_beacon_info fhss_beacon_info_t;
 typedef struct fhss_synch_monitor fhss_synch_monitor_s;
 typedef struct fhss_failed_tx fhss_failed_tx_t;
+typedef struct fhss_bs fhss_bs_t;
 
 struct fhss_beacon_info
 {
@@ -57,6 +58,11 @@ struct fhss_failed_tx
     ns_list_link_t link;
 };
 
+struct fhss_bs
+{
+    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);

source/Service_Libs/fhss/fhss_beacon.c

@@ -58,7 +58,7 @@ int fhss_beacon_update_payload(fhss_structure_t *fhss_structure,
     payload->time_since_last_beacon = 0; // XXX not available yet
     // TODO: Get Beacon length from MAC
     uint32_t tx_time = fhss_get_tx_time(fhss_structure, 71, 0, 0);
-    payload->processing_delay = fhss_structure->fhss_conf.fhss_configuration.fhss_tuning_parameters.tx_processing_delay + tx_time;
+    payload->processing_delay = fhss_structure->bs->fhss_configuration.fhss_tuning_parameters.tx_processing_delay + tx_time;
 
     payload->superframe_length = config->fhss_superframe_length;
 

source/Service_Libs/fhss/fhss_channel.c

@@ -137,7 +137,7 @@ bool fhss_change_to_next_channel(fhss_structure_t *fhss_structure)
     // 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);
-    next_channel = channel_list_get_channel(fhss_structure->fhss_conf.fhss_configuration.channel_mask, channel_index_tmp);
+    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
@@ -220,7 +220,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);
-            return channel_list_get_channel(fhss_structure->fhss_conf.fhss_configuration.channel_mask, uc_index);
+            return channel_list_get_channel(fhss_structure->bs->fhss_configuration.channel_mask, uc_index);
         }
         return fhss_structure->rx_channel;
     }
@@ -262,7 +262,7 @@ int fhss_change_to_parent_channel(fhss_structure_t *fhss_structure)
             }
             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);
-            destination_channel = channel_list_get_channel(fhss_structure->fhss_conf.fhss_configuration.channel_mask, uc_index);
+            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
             tr_info("Parent channel: %u", destination_channel);

source/Service_Libs/fhss/fhss_common.c

@@ -153,6 +153,7 @@ int8_t fhss_disable(fhss_structure_t *fhss_structure)
         return -1;
     }
     fhss_structure->fhss_api->synch_state_set(fhss_structure->fhss_api, FHSS_UNSYNCHRONIZED, 0);
+    ns_dyn_mem_free(fhss_structure->bs);
     ns_dyn_mem_free(fhss_structure->ws);
     ns_dyn_mem_free(fhss_structure);
     fhss_structure = 0;

source/Service_Libs/fhss/fhss_common.h

@@ -43,18 +43,12 @@ typedef void fhss_update_superframe_cb(fhss_structure_t *fhss_structure);
  */
 typedef uint32_t fhss_read_superframe_timeout_cb(fhss_structure_t *fhss_structure);
 
-union fhss_conf {
-    fhss_configuration_t fhss_configuration;
-    fhss_ws_configuration_t fhss_ws_configuration;
-};
-
 struct fhss_structure
 {
     fhss_api_t *fhss_api;
     uint32_t datarate;
     fhss_states fhss_state;
     fhss_timer_t platform_functions;
-    union fhss_conf fhss_conf;
     fhss_synch_configuration_t synch_configuration;
 
     uint8_t fhss_resolution_divider;
@@ -108,6 +102,7 @@ struct fhss_structure
     fhss_failed_tx_list_t fhss_failed_tx_list;
     fhss_statistics_t *fhss_stats_ptr;
 
+    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 */