FHSS: Own create api for WS

- Defined some internal callbacks

Author: Jarkko Paso

nanostack/net_fhss.h

@@ -38,6 +38,15 @@ extern "C" {
  */
 extern fhss_api_t *ns_fhss_create(const fhss_configuration_t *fhss_configuration, const fhss_timer_t *fhss_timer, fhss_statistics_t *fhss_statistics);
 
+/**
+ * @brief TODO: description.
+ * @param fhss_configuration Basic FHSS configuration.
+ * @param fhss_timer FHSS platform timer interface and configuration.
+ * @param fhss_statistics FHSS statistics storage.
+ * @return New FHSS instance if successful, NULL otherwise.
+ */
+extern fhss_api_t *ns_fhss_ws_create(const fhss_configuration_t *fhss_configuration, const fhss_timer_t *fhss_timer, fhss_statistics_t *fhss_statistics);
+
 /**
  * @brief Set synchronization time configuration for FHSS network. Should be only called from Border router.
  * @param fhss_api FHSS instance.

source/Service_Libs/fhss/fhss.c

@@ -658,7 +658,7 @@ void fhss_failed_list_free(fhss_structure_t *fhss_structure)
     }
 }
 
-int fhss_handle_state_set(fhss_structure_t *fhss_structure, fhss_states fhss_state, uint16_t pan_id)
+static int fhss_handle_state_set(fhss_structure_t *fhss_structure, fhss_states fhss_state, uint16_t pan_id)
 {
     // State is already set
     if (fhss_structure->fhss_state == fhss_state) {
@@ -710,7 +710,7 @@ int fhss_handle_state_set(fhss_structure_t *fhss_structure, fhss_states fhss_sta
     return 0;
 }
 
-uint32_t fhss_get_compensation(fhss_structure_t *fhss_structure)
+static uint32_t fhss_get_compensation(fhss_structure_t *fhss_structure)
 {
     uint32_t compensation = 0;
     /* Drift compensation doesn't work with Linux platform */
@@ -732,7 +732,7 @@ uint32_t fhss_get_compensation(fhss_structure_t *fhss_structure)
     return compensation;
 }
 
-void fhss_superframe_callback(fhss_structure_t *fhss_structure)
+static void fhss_superframe_callback(fhss_structure_t *fhss_structure)
 {
     if ((fhss_structure->send_synch_info_on_next_broadcast_channel == true) && (fhss_is_current_channel_broadcast(fhss_structure) == true)) {
         /* Randomize sending superframe of synchronization frame:
@@ -759,7 +759,7 @@ void fhss_superframe_callback(fhss_structure_t *fhss_structure)
     }
 }
 
-void fhss_update_channel_callback(fhss_structure_t *fhss_structure)
+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;
@@ -779,3 +779,11 @@ void fhss_update_channel_callback(fhss_structure_t *fhss_structure)
         }
     }
 }
+
+void fhss_set_internal_callbacks(fhss_structure_t *fhss_structure)
+{
+    fhss_structure->update_channel = fhss_update_channel_callback;
+    fhss_structure->update_superframe = fhss_superframe_callback;
+    fhss_structure->read_compensation = fhss_get_compensation;
+    fhss_structure->handle_state_set = fhss_handle_state_set;
+}

source/Service_Libs/fhss/fhss.h

@@ -36,15 +36,13 @@ int fhss_flush_beacon_info_storage(fhss_structure_t *fhss_structure);
 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);
 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);
-uint32_t fhss_get_compensation(fhss_structure_t *fhss_structure);
-void fhss_superframe_callback(fhss_structure_t *fhss_structure);
-void fhss_update_channel_callback(fhss_structure_t *fhss_structure);
 fhss_failed_tx_t *fhss_failed_handle_find(fhss_structure_t *fhss_structure, uint8_t handle);
 int fhss_failed_handle_add(fhss_structure_t *fhss_structure, uint8_t handle);
 int fhss_failed_handle_remove(fhss_structure_t *fhss_structure, uint8_t handle);
 void fhss_failed_list_free(fhss_structure_t *fhss_structure);
 int fhss_reset_synch_monitor(fhss_synch_monitor_s *synch_monitor);
-int fhss_handle_state_set(fhss_structure_t *fhss_structure, fhss_states fhss_state, uint16_t pan_id);
+void fhss_set_internal_callbacks(fhss_structure_t *fhss_structure);
+
 #define MAX_FHSS_TIMER_DIVIDER  100
 #define SYNCH_MONITOR_AVG_SAMPLES   5
 

source/Service_Libs/fhss/fhss_common.c

@@ -41,20 +41,20 @@ static fhss_structure_t *fhss_get_object_with_timer_id(const int8_t timer_id);
 static void fhss_set_active_event(fhss_structure_t *fhss_structure, uint8_t event_type);
 static bool fhss_read_active_event(fhss_structure_t *fhss_structure, uint8_t event_type);
 
-int8_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)
+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)
 {
     if (!fhss_api || !fhss_configuration || !fhss_timer || fhss_struct) {
         tr_err("Invalid FHSS enable configuration");
-        return -1;
+        return NULL;
     }
     int channel_count = channel_list_count_channels(fhss_configuration->channel_mask);
     if (channel_count <= 0) {
         // There must be at least one configured channel in channel list
-        return -2;
+        return NULL;
     }
     fhss_struct = ns_dyn_mem_alloc(sizeof(fhss_structure_t));
     if (!fhss_struct) {
-        return -3;
+        return NULL;
     }
     memset(fhss_struct, 0, sizeof(fhss_structure_t));
     fhss_struct->fhss_api = fhss_api;
@@ -83,10 +83,10 @@ int8_t fhss_enable(fhss_api_t *fhss_api, const fhss_configuration_t *fhss_config
 
     if (fhss_beacon_create_tasklet(fhss_struct) < 0) {
         // XXX: should we free the fhss_structure here?
-        return -5;
+        return NULL;
     }
 
-    return 0;
+    return fhss_struct;
 }
 
 static void fhss_event_timer_cb(int8_t timer_id, uint16_t slots)
@@ -333,24 +333,6 @@ int fhss_compare_with_synch_parent_address(fhss_structure_t *fhss_structure, con
     return ret_val;
 }
 
-static void fhss_update_channel(fhss_structure_t *fhss_structure)
-{
-    if (fhss_structure->mode == MODE_FHSS) {
-        fhss_update_channel_callback(fhss_structure);
-    } else if (fhss_structure->mode == MODE_W_S) {
-        fhss_ws_update_channel_callback(fhss_structure);
-    }
-}
-
-static void fhss_update_superframe(fhss_structure_t *fhss_structure)
-{
-    if (fhss_structure->mode == MODE_FHSS) {
-        fhss_superframe_callback(fhss_structure);
-    } else if (fhss_structure->mode == MODE_W_S) {
-        fhss_ws_superframe_callback(fhss_structure);
-    }
-}
-
 void fhss_superframe_handler(const fhss_api_t *fhss_api, uint16_t delay)
 {
     uint32_t compensation = 0;
@@ -360,8 +342,8 @@ void fhss_superframe_handler(const fhss_api_t *fhss_api, uint16_t delay)
     }
 
     if (fhss_structure->current_superframe == 0) {
-        if (fhss_structure->mode == MODE_FHSS) {
-            compensation = fhss_get_compensation(fhss_structure);
+        if (fhss_structure->read_compensation) {
+            compensation = fhss_structure->read_compensation(fhss_structure);
         }
     }
 
@@ -372,9 +354,13 @@ void fhss_superframe_handler(const fhss_api_t *fhss_api, uint16_t delay)
         if (++fhss_structure->current_channel_index >= fhss_structure->number_of_channels) {
             fhss_structure->current_channel_index = 0;
         }
-        fhss_update_channel(fhss_structure);
+        if (fhss_structure->update_channel) {
+            fhss_structure->update_channel(fhss_structure);
+        }
+    }
+    if (fhss_structure->update_superframe) {
+        fhss_structure->update_superframe(fhss_structure);
     }
-    fhss_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) {

source/Service_Libs/fhss/fhss_common.h

@@ -21,6 +21,8 @@
 #define FHSS_BROADCAST_CHANNEL              3
 #define FHSS_UPDATE_SYNCH_INFO_STORAGE      4
 
+typedef struct fhss_structure fhss_structure_t;
+
 typedef struct fhss_beacon_info
 {
     uint16_t pan_id;
@@ -48,7 +50,35 @@ typedef struct
     int channel_counter;
 } fhss_synch_monitor_s;
 
-typedef struct fhss_structure_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 FHSS compensation.
+ * @param fhss_structure FHSS structure.
+ * @return Compensation to be added to started dwell time
+ */
+typedef uint32_t fhss_read_compensation_cb(fhss_structure_t *fhss_structure);
+
+/**
+ * @brief Set FHSS state.
+ * @param fhss_structure FHSS structure.
+ * @param fhss_state FHSS state to set.
+ * @param pan_id Network PAN id.
+ * @return 0 Success, -1 Failure.
+ */
+typedef int fhss_handle_state_set_cb(fhss_structure_t *fhss_structure, fhss_states fhss_state, uint16_t pan_id);
+
+struct fhss_structure
 {
     fhss_api_t *fhss_api;
     uint32_t datarate;
@@ -107,9 +137,14 @@ typedef struct fhss_structure_t
     fhss_beacon_info_t *fhss_beacon_info_store;
     fhss_failed_tx_list_t fhss_failed_tx_list;
     fhss_statistics_t *fhss_stats_ptr;
-} fhss_structure_t;
+    fhss_update_channel_cb *update_channel;    /**< Update listening channel */
+    fhss_update_superframe_cb *update_superframe;    /**< Update superframe */
+    fhss_read_compensation_cb *read_compensation;    /**< Read FHSS compensation */
+    fhss_handle_state_set_cb *handle_state_set;    /**< Set FHSS state */
+};
+
 
-int8_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);
+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);
 int fhss_down(fhss_structure_t *fhss_structure);
 int8_t fhss_set_datarate(fhss_structure_t *fhss_structure, uint32_t datarate);
 int8_t fhss_set_synch_configuration(fhss_structure_t *fhss_structure, const fhss_synch_configuration_t *fhss_synch_configuration);

source/Service_Libs/fhss/fhss_configuration_interface.c

@@ -23,11 +23,27 @@
 #include "nsdynmemLIB.h"
 #include "Service_Libs/fhss/fhss_common.h"
 #include "Service_Libs/fhss/fhss.h"
+#include "Service_Libs/fhss/fhss_ws.h"
 #include "Service_Libs/fhss/fhss_mac_interface.h"
 #include "ns_trace.h"
 
 #define TRACE_GROUP "fhss"
 
+static void fhss_set_api_callbacks(fhss_api_t *fhss_api)
+{
+    fhss_api->is_broadcast_channel = &fhss_is_broadcast_channel_cb;
+    fhss_api->use_broadcast_queue = &fhss_use_broadcast_queue_cb;
+    fhss_api->tx_handle = &fhss_tx_handle_cb;
+    fhss_api->check_tx_conditions = &fhss_check_tx_conditions_cb;
+    fhss_api->receive_frame = &fhss_receive_frame_cb;
+    fhss_api->data_tx_done = &fhss_data_tx_done_cb;
+    fhss_api->data_tx_fail = &fhss_data_tx_fail_cb;
+    fhss_api->synch_state_set = &fhss_synch_state_set_cb;
+    fhss_api->read_timestamp = &fhss_read_timestamp_cb;
+    fhss_api->get_retry_period = &fhss_get_retry_period_cb;
+    fhss_api->write_synch_info = &fhss_write_synch_info_cb;
+    fhss_api->init_callbacks = &fhss_init_callbacks_cb;
+}
 
 fhss_api_t *ns_fhss_create(const fhss_configuration_t *fhss_configuration, const fhss_timer_t *fhss_timer, fhss_statistics_t *fhss_statistics)
 {
@@ -36,24 +52,32 @@ fhss_api_t *ns_fhss_create(const fhss_configuration_t *fhss_configuration, const
         return NULL;
     }
     // Create FHSS object
-    int8_t retval = fhss_enable(this, fhss_configuration, fhss_timer, fhss_statistics);
-    if (retval) {
-        tr_err("Failed to enable FHSS, return code: %i", retval);
+    fhss_structure_t *fhss_struct = fhss_enable(this, fhss_configuration, fhss_timer, fhss_statistics);
+    if (!fhss_struct) {
+        tr_err("Failed to enable FHSS");
+        ns_dyn_mem_free(this);
+        return NULL;
+    }
+    fhss_set_api_callbacks(this);
+    fhss_set_internal_callbacks(fhss_struct);
+    return this;
+}
+
+fhss_api_t *ns_fhss_ws_create(const fhss_configuration_t *fhss_configuration, const fhss_timer_t *fhss_timer, fhss_statistics_t *fhss_statistics)
+{
+    fhss_api_t *this = ns_dyn_mem_alloc(sizeof(fhss_api_t));
+    if (!this) {
+        return NULL;
+    }
+    // Create FHSS object
+    fhss_structure_t *fhss_struct = fhss_enable(this, fhss_configuration, fhss_timer, fhss_statistics);
+    if (!fhss_struct) {
+        tr_err("Failed to enable FHSS");
         ns_dyn_mem_free(this);
         return NULL;
     }
-    this->is_broadcast_channel = &fhss_is_broadcast_channel_cb;
-    this->use_broadcast_queue = &fhss_use_broadcast_queue_cb;
-    this->tx_handle = &fhss_tx_handle_cb;
-    this->check_tx_conditions = &fhss_check_tx_conditions_cb;
-    this->receive_frame = &fhss_receive_frame_cb;
-    this->data_tx_done = &fhss_data_tx_done_cb;
-    this->data_tx_fail = &fhss_data_tx_fail_cb;
-    this->synch_state_set = &fhss_synch_state_set_cb;
-    this->read_timestamp = &fhss_read_timestamp_cb;
-    this->get_retry_period = &fhss_get_retry_period_cb;
-    this->write_synch_info = &fhss_write_synch_info_cb;
-    this->init_callbacks = &fhss_init_callbacks_cb;
+    fhss_set_api_callbacks(this);
+    fhss_ws_set_internal_callbacks(fhss_struct);
     return this;
 }
 

source/Service_Libs/fhss/fhss_mac_interface.c

@@ -198,10 +198,8 @@ void fhss_synch_state_set_cb(const fhss_api_t *api, fhss_states fhss_state, uint
     if (!fhss_structure) {
         return;
     }
-    if (fhss_structure->mode == MODE_FHSS) {
-        fhss_handle_state_set(fhss_structure, fhss_state, pan_id);
-    } else if (fhss_structure->mode == MODE_W_S) {
-        fhss_ws_handle_state_set(fhss_structure, fhss_state);
+    if (fhss_structure->handle_state_set) {
+        fhss_structure->handle_state_set(fhss_structure, fhss_state, pan_id);
     }
     fhss_structure->fhss_state = fhss_state;
 }

source/Service_Libs/fhss/fhss_ws.c

@@ -27,18 +27,19 @@
 // Enable this flag to use channel traces
 #define FHSS_CHANNEL_DEBUG
 
-int fhss_ws_handle_state_set(fhss_structure_t *fhss_structure, fhss_states fhss_state)
+static int fhss_ws_handle_state_set(fhss_structure_t *fhss_structure, fhss_states fhss_state, uint16_t pan_id)
 {
+    (void) pan_id;
     fhss_start_timer(fhss_structure, fhss_structure->synch_configuration.fhss_superframe_length, fhss_superframe_handler);
     return 0;
 }
 
-void fhss_ws_superframe_callback(fhss_structure_t *fhss_structure)
+static void fhss_ws_superframe_callback(fhss_structure_t *fhss_structure)
 {
 
 }
 
-void fhss_ws_update_channel_callback(fhss_structure_t *fhss_structure)
+static void fhss_ws_update_channel_callback(fhss_structure_t *fhss_structure)
 {
     uint8_t mac_address[8];
     fhss_structure->callbacks.read_mac_address(fhss_structure->fhss_api, mac_address);
@@ -49,3 +50,11 @@ void fhss_ws_update_channel_callback(fhss_structure_t *fhss_structure)
 #endif /*FHSS_CHANNEL_DEBUG*/
     fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, next_channel);
 }
+
+void fhss_ws_set_internal_callbacks(fhss_structure_t *fhss_structure)
+{
+    fhss_structure->update_channel = fhss_ws_update_channel_callback;
+    fhss_structure->update_superframe = fhss_ws_superframe_callback;
+    fhss_structure->read_compensation = NULL;
+    fhss_structure->handle_state_set = fhss_ws_handle_state_set;
+}

source/Service_Libs/fhss/fhss_ws.h

@@ -15,6 +15,4 @@
  * limitations under the License.
  */
 
-int fhss_ws_handle_state_set(fhss_structure_t *fhss_structure, fhss_states fhss_state);
-void fhss_ws_superframe_callback(fhss_structure_t *fhss_structure);
-void fhss_ws_update_channel_callback(fhss_structure_t *fhss_structure);
+void fhss_ws_set_internal_callbacks(fhss_structure_t *fhss_structure);