Merge pull request ARMmbed#1545 from ARMmbed/IOTTHD-2097

Iotthd 2097

Author: Jarkko Paso

source/Service_Libs/fhss/fhss.c

@@ -25,6 +25,7 @@
 #include "nsdynmemLIB.h"
 #include "fhss_beacon.h"
 #include "fhss_statistics.h"
+#include "fhss_mac_interface.h"
 #include "ns_trace.h"
 #include "eventOS_event.h"
 #include "eventOS_callback_timer.h"
@@ -759,6 +760,57 @@ static void fhss_superframe_callback(fhss_structure_t *fhss_structure)
     }
 }
 
+static int fhss_tx_handle_callback(const fhss_api_t *api, bool is_broadcast_addr, uint8_t *destination_address, int frame_type, uint16_t frame_length, uint8_t phy_header_length, uint8_t phy_tail_length)
+{
+    fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
+    if (!fhss_structure) {
+        return -2;
+    }
+    // TODO: needs some more logic to push buffer back to queue
+    if (frame_type == FHSS_DATA_FRAME) {
+        if (is_broadcast_addr == true) {
+            if (fhss_is_current_channel_broadcast(fhss_structure) == false) {
+                tr_info("Broadcast on UC channel -> Back to queue");
+                return -3;
+            }
+        }
+    }
+    if (fhss_check_tx_allowed(fhss_structure, is_broadcast_addr, frame_length, frame_type, phy_header_length, phy_tail_length) == false) {
+        return -1;
+    }
+    // If sending Beacon request on parents Unicast channel
+    if (frame_type == FHSS_SYNCH_REQUEST_FRAME && fhss_structure->fhss_state == FHSS_SYNCHRONIZED) {
+        fhss_change_to_parent_channel(fhss_structure);
+    } else if (frame_type == FHSS_DATA_FRAME) {
+        fhss_change_to_tx_channel(fhss_structure, destination_address);
+    }
+    return 0;
+}
+
+static bool fhss_check_tx_conditions_callback(const fhss_api_t *api, bool is_broadcast_addr, uint8_t handle, int frame_type, uint16_t frame_length, uint8_t phy_header_length, uint8_t phy_tail_length)
+{
+    fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
+    if (!fhss_structure) {
+        return false;
+    }
+    // This condition will check that message is not sent on bad channel
+    if (fhss_check_bad_channel(fhss_structure, handle) == false) {
+        return false;
+    }
+
+    // This condition will check that broadcast messages are sent only broadcast channels
+    if (fhss_check_channel_type(fhss_structure, is_broadcast_addr, frame_type) == false) {
+        return false;
+    }
+
+    // This condition will check that FHSS is on TX slot and there is enough time to transmit before channel or slot change
+    if (fhss_check_tx_allowed(fhss_structure, is_broadcast_addr, frame_length, frame_type, phy_header_length, phy_tail_length) == false) {
+        return false;
+    }
+
+    return true;
+}
+
 static void fhss_update_channel_callback(fhss_structure_t *fhss_structure)
 {
     if (fhss_structure->current_channel_index == 0) {
@@ -780,8 +832,22 @@ static void fhss_update_channel_callback(fhss_structure_t *fhss_structure)
     }
 }
 
-int fhss_set_internal_callbacks(fhss_structure_t *fhss_structure)
+int fhss_set_callbacks(fhss_structure_t *fhss_structure)
 {
+    // Set external API
+    fhss_structure->fhss_api->is_broadcast_channel = &fhss_is_broadcast_channel_cb;
+    fhss_structure->fhss_api->use_broadcast_queue = &fhss_use_broadcast_queue_cb;
+    fhss_structure->fhss_api->tx_handle = &fhss_tx_handle_callback;
+    fhss_structure->fhss_api->check_tx_conditions = &fhss_check_tx_conditions_callback;
+    fhss_structure->fhss_api->receive_frame = &fhss_receive_frame_cb;
+    fhss_structure->fhss_api->data_tx_done = &fhss_data_tx_done_cb;
+    fhss_structure->fhss_api->data_tx_fail = &fhss_data_tx_fail_cb;
+    fhss_structure->fhss_api->synch_state_set = &fhss_synch_state_set_cb;
+    fhss_structure->fhss_api->read_timestamp = &fhss_read_timestamp_cb;
+    fhss_structure->fhss_api->get_retry_period = &fhss_get_retry_period_cb;
+    fhss_structure->fhss_api->write_synch_info = &fhss_write_synch_info_cb;
+    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_compensation = fhss_get_compensation;

source/Service_Libs/fhss/fhss.h

@@ -71,7 +71,7 @@ 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_set_internal_callbacks(fhss_structure_t *fhss_structure);
+int fhss_set_callbacks(fhss_structure_t *fhss_structure);
 
 /**
  * Calculate time in microseconds to start of next superframe.

source/Service_Libs/fhss/fhss_configuration_interface.c

@@ -29,22 +29,6 @@
 
 #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)
 {
     fhss_api_t *this = ns_dyn_mem_alloc(sizeof(fhss_api_t));
@@ -58,8 +42,7 @@ fhss_api_t *ns_fhss_create(const fhss_configuration_t *fhss_configuration, const
         ns_dyn_mem_free(this);
         return NULL;
     }
-    fhss_set_api_callbacks(this);
-    fhss_set_internal_callbacks(fhss_struct);
+    fhss_set_callbacks(fhss_struct);
     return this;
 }
 
@@ -76,8 +59,7 @@ fhss_api_t *ns_fhss_ws_create(const fhss_configuration_t *fhss_configuration, co
         ns_dyn_mem_free(this);
         return NULL;
     }
-    fhss_set_api_callbacks(this);
-    fhss_ws_set_internal_callbacks(fhss_struct);
+    fhss_ws_set_callbacks(fhss_struct);
     return this;
 }
 

source/Service_Libs/fhss/fhss_mac_interface.c

@@ -58,57 +58,6 @@ bool fhss_use_broadcast_queue_cb(const fhss_api_t *api, bool is_broadcast_addr,
     return is_broadcast_addr;
 }
 
-int fhss_tx_handle_cb(const fhss_api_t *api, bool is_broadcast_addr, uint8_t *destination_address, int frame_type, uint16_t frame_length, uint8_t phy_header_length, uint8_t phy_tail_length)
-{
-    fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
-    if (!fhss_structure) {
-        return -2;
-    }
-    // TODO: needs some more logic to push buffer back to queue
-    if (frame_type == FHSS_DATA_FRAME) {
-        if (is_broadcast_addr == true) {
-            if (fhss_is_current_channel_broadcast(fhss_structure) == false) {
-                tr_info("Broadcast on UC channel -> Back to queue");
-                return -3;
-            }
-        }
-    }
-    if (fhss_check_tx_allowed(fhss_structure, is_broadcast_addr, frame_length, frame_type, phy_header_length, phy_tail_length) == false) {
-        return -1;
-    }
-    // If sending Beacon request on parents Unicast channel
-    if (frame_type == FHSS_SYNCH_REQUEST_FRAME && fhss_structure->fhss_state == FHSS_SYNCHRONIZED) {
-        fhss_change_to_parent_channel(fhss_structure);
-    } else if (frame_type == FHSS_DATA_FRAME) {
-        fhss_change_to_tx_channel(fhss_structure, destination_address);
-    }
-    return 0;
-}
-
-bool fhss_check_tx_conditions_cb(const fhss_api_t *api, bool is_broadcast_addr, uint8_t handle, int frame_type, uint16_t frame_length, uint8_t phy_header_length, uint8_t phy_tail_length)
-{
-    fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
-    if (!fhss_structure) {
-        return false;
-    }
-    // This condition will check that message is not sent on bad channel
-    if (fhss_check_bad_channel(fhss_structure, handle) == false) {
-        return false;
-    }
-
-    // This condition will check that broadcast messages are sent only broadcast channels
-    if (fhss_check_channel_type(fhss_structure, is_broadcast_addr, frame_type) == false) {
-        return false;
-    }
-
-    // This condition will check that FHSS is on TX slot and there is enough time to transmit before channel or slot change
-    if (fhss_check_tx_allowed(fhss_structure, is_broadcast_addr, frame_length, frame_type, phy_header_length, phy_tail_length) == false) {
-        return false;
-    }
-
-    return true;
-}
-
 void fhss_receive_frame_cb(const fhss_api_t *api, uint16_t pan_id, uint8_t *source_address, uint32_t timestamp, uint8_t *synch_info, int frame_type)
 {
     fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);

source/Service_Libs/fhss/fhss_mac_interface.h

@@ -20,8 +20,6 @@
 
 bool fhss_is_broadcast_channel_cb(const fhss_api_t *api);
 bool fhss_use_broadcast_queue_cb(const fhss_api_t *api, bool is_broadcast_addr, int frame_type);
-int fhss_tx_handle_cb(const fhss_api_t *api, bool is_broadcast_addr, uint8_t *destination_address, int frame_type, uint16_t frame_length, uint8_t phy_header_length, uint8_t phy_tail_length);
-bool fhss_check_tx_conditions_cb(const fhss_api_t *api, bool is_broadcast_addr, uint8_t handle, int frame_type, uint16_t frame_length, uint8_t phy_header_length, uint8_t phy_tail_length);
 void fhss_receive_frame_cb(const fhss_api_t *api, uint16_t pan_id, uint8_t *source_address, uint32_t timestamp, uint8_t *synch_info, int frame_type);
 void fhss_data_tx_done_cb(const fhss_api_t *api, bool waiting_ack, bool tx_completed, uint8_t handle);
 bool fhss_data_tx_fail_cb(const fhss_api_t *api, uint8_t handle, int frame_type);

source/Service_Libs/fhss/fhss_ws.c

@@ -22,6 +22,7 @@
 #include "fhss_common.h"
 #include "channel_functions.h"
 #include "fhss_ws.h"
+#include "fhss_mac_interface.h"
 #include "nsdynmemLIB.h"
 #include "ns_trace.h"
 #include <string.h>
@@ -33,14 +34,17 @@
 
 static int fhss_ws_handle_state_set(fhss_structure_t *fhss_structure, fhss_states fhss_state, uint16_t pan_id)
 {
+    (void) fhss_state;
     (void) pan_id;
+    //TODO: Remove hard coded channel function
+    fhss_structure->ws->channel_function = WS_TR51CF;
     fhss_start_timer(fhss_structure, fhss_structure->synch_configuration.fhss_superframe_length, fhss_superframe_handler);
     return 0;
 }
 
 static void fhss_ws_superframe_callback(fhss_structure_t *fhss_structure)
 {
-
+    (void) fhss_structure;
 }
 
 static void fhss_ws_update_channel_callback(fhss_structure_t *fhss_structure)
@@ -62,13 +66,69 @@ static void fhss_ws_update_channel_callback(fhss_structure_t *fhss_structure)
         //TODO: Callback to get channel schedule from application
     }
 #ifdef FHSS_CHANNEL_DEBUG
-    tr_info("%"PRIu32" UC %u", fhss_structure->platform_functions.fhss_get_timestamp(fhss_structure->fhss_api), next_channel);
+    tr_info("%"PRIu32" UC %u %u", fhss_structure->platform_functions.fhss_get_timestamp(fhss_structure->fhss_api), next_channel, fhss_structure->ws->slot);
 #endif /*FHSS_CHANNEL_DEBUG*/
     fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, next_channel);
 }
 
-int fhss_ws_set_internal_callbacks(fhss_structure_t *fhss_structure)
+static int fhss_ws_tx_handle_callback(const fhss_api_t *api, bool is_broadcast_addr, uint8_t *destination_address, int frame_type, uint16_t frame_length, uint8_t phy_header_length, uint8_t phy_tail_length)
+{
+    (void) is_broadcast_addr;
+    (void) frame_type;
+    (void) frame_length;
+    (void) phy_header_length;
+    (void) phy_tail_length;
+    fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
+    if (!fhss_structure) {
+        return -1;
+    }
+    if (fhss_structure->fhss_state == FHSS_SYNCHRONIZED) {
+        int32_t tx_channel;
+        //TODO: Compute destination slot using neighbour table
+        uint16_t destination_slot = fhss_structure->ws->slot;
+        if (fhss_structure->ws->channel_function == WS_TR51CF) {
+            tx_channel = tr51_get_uc_channel_index(destination_slot, destination_address, fhss_structure->number_of_channels);
+        } else if(fhss_structure->ws->channel_function == WS_DH1CF) {
+            tx_channel = dh1cf_get_uc_channel_index(destination_slot, destination_address, fhss_structure->number_of_channels);
+        } else if (fhss_structure->ws->channel_function == WS_VENDOR_DEF_CF) {
+
+        }
+#ifdef FHSS_CHANNEL_DEBUG
+        tr_debug("TX channel: %u %u", tx_channel, destination_slot+1);
+#endif /*FHSS_CHANNEL_DEBUG*/
+        fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, tx_channel);
+    }
+    return 0;
+}
+
+static bool fhss_ws_check_tx_conditions_callback(const fhss_api_t *api, bool is_broadcast_addr, uint8_t handle, int frame_type, uint16_t frame_length, uint8_t phy_header_length, uint8_t phy_tail_length)
+{
+    (void) api;
+    (void) is_broadcast_addr;
+    (void) handle;
+    (void) frame_type;
+    (void) frame_length;
+    (void) phy_header_length;
+    (void) phy_tail_length;
+    return true;
+}
+
+int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure)
 {
+    // Set external API
+    fhss_structure->fhss_api->is_broadcast_channel = &fhss_is_broadcast_channel_cb;
+    fhss_structure->fhss_api->use_broadcast_queue = &fhss_use_broadcast_queue_cb;
+    fhss_structure->fhss_api->tx_handle = &fhss_ws_tx_handle_callback;
+    fhss_structure->fhss_api->check_tx_conditions = &fhss_ws_check_tx_conditions_callback;
+    fhss_structure->fhss_api->receive_frame = &fhss_receive_frame_cb;
+    fhss_structure->fhss_api->data_tx_done = &fhss_data_tx_done_cb;
+    fhss_structure->fhss_api->data_tx_fail = &fhss_data_tx_fail_cb;
+    fhss_structure->fhss_api->synch_state_set = &fhss_synch_state_set_cb;
+    fhss_structure->fhss_api->read_timestamp = &fhss_read_timestamp_cb;
+    fhss_structure->fhss_api->get_retry_period = &fhss_get_retry_period_cb;
+    fhss_structure->fhss_api->write_synch_info = &fhss_write_synch_info_cb;
+    fhss_structure->fhss_api->init_callbacks = &fhss_init_callbacks_cb;
+    // Set internal API
     fhss_structure->update_channel = fhss_ws_update_channel_callback;
     fhss_structure->update_superframe = fhss_ws_superframe_callback;
     fhss_structure->read_compensation = NULL;

source/Service_Libs/fhss/fhss_ws.h

@@ -29,6 +29,6 @@ struct fhss_ws
     uint16_t slot;
 };
 
-int fhss_ws_set_internal_callbacks(fhss_structure_t *fhss_structure);
+int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure);
 
 #endif /*FHSS_WS_H_*/