FHSS: FHSS configuration to union

Author: Jarkko Paso

source/Service_Libs/fhss/fhss.c

@@ -56,16 +56,16 @@ fhss_structure_t *fhss_enable(fhss_api_t *fhss_api, const fhss_configuration_t *
     if (!fhss_struct) {
         return NULL;
     }
-    fhss_struct->fhss_configuration = *fhss_configuration;
+    fhss_struct->fhss_conf.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_configuration.fhss_max_synch_interval) {
-        fhss_struct->fhss_configuration.fhss_max_synch_interval = 240;
+    if (!fhss_struct->fhss_conf.fhss_configuration.fhss_max_synch_interval) {
+        fhss_struct->fhss_conf.fhss_configuration.fhss_max_synch_interval = 240;
     }
     ns_list_init(&fhss_struct->fhss_failed_tx_list);
     fhss_struct->own_hop = 0xff;
@@ -259,7 +259,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_configuration.fhss_max_synch_interval * 1000)) {
+    if (fhss_structure->synch_interval != ((uint32_t)fhss_structure->fhss_conf.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 {
@@ -398,14 +398,14 @@ 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_configuration.fhss_max_synch_interval/BEACON_INTERVAL_INIT_DIVIDER) * 1000;
+                    fhss_structure->synch_interval = (uint32_t) (fhss_structure->fhss_conf.fhss_configuration.fhss_max_synch_interval/BEACON_INTERVAL_INIT_DIVIDER) * 1000;
                 }
             }
 
-            if (fhss_structure->synch_interval != ((uint32_t)fhss_structure->fhss_configuration.fhss_max_synch_interval * 1000)) {
+            if (fhss_structure->synch_interval != ((uint32_t)fhss_structure->fhss_conf.fhss_configuration.fhss_max_synch_interval * 1000)) {
                 fhss_structure->synch_interval *= 2;
-                if (fhss_structure->synch_interval > ((uint32_t)fhss_structure->fhss_configuration.fhss_max_synch_interval * 1000)) {
-                    fhss_structure->synch_interval = ((uint32_t)fhss_structure->fhss_configuration.fhss_max_synch_interval * 1000);
+                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);
                 }
                 beacon_interval_random = (bc_density * channel_dwell_time) * randLIB_get_random_in_range(0, fhss_number_of_bc_channels/2);
             } else {
@@ -488,8 +488,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_configuration.fhss_tuning_parameters.tx_processing_delay;
-        ack_processing_delay = fhss_structure->fhss_configuration.fhss_tuning_parameters.ack_processing_delay;
+        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;
         // 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);
@@ -627,31 +627,31 @@ static int fhss_flush_beacon_info_storage(fhss_structure_t *fhss_structure)
 
 static int fhss_reset(fhss_structure_t *fhss_structure)
 {
-    if (fhss_structure) {
-        fhss_destroy_scramble_table(fhss_structure);
-        fhss_structure->platform_functions.fhss_timer_stop(fhss_superframe_handler, fhss_structure->fhss_api);
-        fhss_structure->synch_panid = 0xffff;
-        fhss_beacon_periodic_stop(fhss_structure);
-        fhss_structure->current_superframe = 0;
-        fhss_structure->current_channel_index = 0;
-        fhss_structure->channel_list_counter = 0;
-        if (fhss_is_synch_root(fhss_structure) == false) {
-            fhss_structure->own_hop = 0xff;
-        }
-        fhss_structure->tx_allowed = false;
-        fhss_structure->synch_interval = (uint32_t) (fhss_structure->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);
-        fhss_structure->send_synch_info_on_next_broadcast_channel = false;
-        memset(&fhss_structure->synch_configuration, 0, sizeof(fhss_synch_configuration_t));
-        fhss_structure->synch_infos_sent_counter = 0;
-        fhss_structure->broadcast_start_superframe = 0;
-        fhss_failed_list_free(fhss_structure);
-        fhss_structure->fhss_state = FHSS_UNSYNCHRONIZED;
-        return 0;
+    if (!fhss_structure) {
+        return -1;
     }
-    return -1;
+    fhss_destroy_scramble_table(fhss_structure);
+    fhss_structure->platform_functions.fhss_timer_stop(fhss_superframe_handler, fhss_structure->fhss_api);
+    fhss_structure->synch_panid = 0xffff;
+    fhss_beacon_periodic_stop(fhss_structure);
+    fhss_structure->current_superframe = 0;
+    fhss_structure->current_channel_index = 0;
+    fhss_structure->channel_list_counter = 0;
+    if (fhss_is_synch_root(fhss_structure) == false) {
+        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->rx_channel = 0;
+    fhss_structure->beacons_received_timer = 0;
+    memset(fhss_structure->synch_parent, 0xff, 8);
+    fhss_structure->send_synch_info_on_next_broadcast_channel = false;
+    memset(&fhss_structure->synch_configuration, 0, sizeof(fhss_synch_configuration_t));
+    fhss_structure->synch_infos_sent_counter = 0;
+    fhss_structure->broadcast_start_superframe = 0;
+    fhss_failed_list_free(fhss_structure);
+    fhss_structure->fhss_state = FHSS_UNSYNCHRONIZED;
+    return 0;
 }
 
 int fhss_add_beacon_info(fhss_structure_t *fhss_structure, uint16_t pan_id, uint8_t *source_address, uint32_t timestamp, uint8_t *synch_info)

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_configuration.fhss_tuning_parameters.tx_processing_delay + tx_time;
+    payload->processing_delay = fhss_structure->fhss_conf.fhss_configuration.fhss_tuning_parameters.tx_processing_delay + tx_time;
 
     payload->superframe_length = config->fhss_superframe_length;
 

source/Service_Libs/fhss/fhss_beacon_tasklet.c

@@ -144,7 +144,7 @@ void fhss_beacon_received(fhss_structure_t *fhss_structure, const uint8_t *synch
 
         if (synch_info) {
             fhss_synchronization_beacon_payload_s temp_payload;
-            temp_payload.processing_delay = fhss_structure->fhss_configuration.fhss_tuning_parameters.rx_processing_delay;
+            temp_payload.processing_delay = fhss_structure->fhss_conf.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

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_configuration.channel_mask, channel_index_tmp);
+    next_channel = channel_list_get_channel(fhss_structure->fhss_conf.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_configuration.channel_mask, uc_index);
+            return channel_list_get_channel(fhss_structure->fhss_conf.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_configuration.channel_mask, uc_index);
+            destination_channel = channel_list_get_channel(fhss_structure->fhss_conf.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.h

@@ -52,13 +52,18 @@ typedef uint32_t fhss_read_compensation_cb(fhss_structure_t *fhss_structure);
  */
 typedef int fhss_handle_state_set_cb(fhss_structure_t *fhss_structure, fhss_states fhss_state, uint16_t pan_id);
 
+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;
-    fhss_configuration_t fhss_configuration;
+    union fhss_conf fhss_conf;
     fhss_synch_configuration_t synch_configuration;
 
     uint8_t fhss_resolution_divider;

source/Service_Libs/fhss/fhss_mac_interface.c

@@ -118,7 +118,7 @@ bool fhss_data_tx_fail_cb(const fhss_api_t *api, uint8_t handle, int frame_type)
         return false;
     }
     // Channel retries are disabled -> return
-    if (fhss_structure->fhss_configuration.fhss_number_of_channel_retries == 0) {
+    if (fhss_structure->fhss_conf.fhss_configuration.fhss_number_of_channel_retries == 0) {
         return false;
     }
     // Use channel retries only for data frames
@@ -129,7 +129,7 @@ bool fhss_data_tx_fail_cb(const fhss_api_t *api, uint8_t handle, int frame_type)
     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_configuration.fhss_number_of_channel_retries) {
+        if (fhss_failed_tx->retries_done >= fhss_structure->fhss_conf.fhss_configuration.fhss_number_of_channel_retries) {
             // No more retries. Return false to stop retransmitting.
             fhss_failed_handle_remove(fhss_structure, handle);
             return false;

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

@@ -301,7 +301,7 @@ bool test_fhss_sync_with_beacon()
     fhss_struct->platform_functions.fhss_timer_start = &fhss_timer_start;
     fhss_struct->platform_functions.fhss_get_remaining_slots = &fhss_get_remaining_slots_stub;
     fhss_struct->platform_functions.fhss_resolution_divider = 1;
-    fhss_struct->fhss_configuration.fhss_max_synch_interval = 240;
+    fhss_struct->fhss_conf.fhss_configuration.fhss_max_synch_interval = 240;
     fhss_struct->synch_interval = 150000;
 
     // Test that synchronization is skipped if Beacon is already received on this channel

test/nanostack/unittest/service_libs/fhss_beacon/test_fhss_beacon.c

@@ -77,7 +77,7 @@ bool test_fhss_beacon_update_payload()
     fhss_struct->own_hop = test_value;
     fhss_struct->synch_configuration.fhss_number_of_bc_channels = test_value;
     fhss_struct->synch_configuration.fhss_number_of_tx_slots = test_value;
-    fhss_struct->fhss_configuration.fhss_tuning_parameters.tx_processing_delay = test_value;
+    fhss_struct->fhss_conf.fhss_configuration.fhss_tuning_parameters.tx_processing_delay = test_value;
     fhss_struct->synch_configuration.fhss_superframe_length = test_value;
     fhss_struct->synch_configuration.fhss_number_of_superframes = test_value;
 

test/nanostack/unittest/service_libs/fhss_mac_interface/test_fhss_mac_interface.c

@@ -150,13 +150,13 @@ bool test_fhss_data_tx_fail_cb()
     fhss_stub.bool_value = true;
 
     // No channel retries should return false
-    fhss_stub.fhss_struct.fhss_configuration.fhss_number_of_channel_retries = 0;
+    fhss_stub.fhss_struct.fhss_conf.fhss_configuration.fhss_number_of_channel_retries = 0;
     if (fhss_data_tx_fail_cb(&fhss_api, handle, FHSS_DATA_FRAME) != false) {
     	return false;
     }
     // In this test 255 means no handle added
     fhss_stub.fhss_failed_tx.handle = 255;
-    fhss_stub.fhss_struct.fhss_configuration.fhss_number_of_channel_retries = 2;
+    fhss_stub.fhss_struct.fhss_conf.fhss_configuration.fhss_number_of_channel_retries = 2;
     // This call should add new failed handle
     if (fhss_data_tx_fail_cb(&fhss_api, handle, FHSS_DATA_FRAME) != true) {
     	return false;