FHSS: Broadcast handler implemented

Author: Jarkko Paso

source/Service_Libs/fhss/channel_functions.c

@@ -193,3 +193,19 @@ int32_t tr51_get_uc_channel_index(uint16_t slot_number, uint8_t *mac, int16_t nu
     tr51_calculate_hopping_sequence(channel_table, nearest_prime, first_element, step_size, output_table, NULL, 0);
     return output_table[slot_number];
 }
+
+int32_t tr51_get_bc_channel_index(uint16_t slot_number, uint16_t bsi, int16_t number_of_channels)
+{
+    uint16_t nearest_prime = tr51_calc_nearest_prime_number(number_of_channels);
+    int32_t channel_table[nearest_prime];
+    int32_t output_table[number_of_channels];
+    uint8_t mac[8] = {0, 0, 0, 0, 0, 0, (uint8_t)(bsi >> 8), (uint8_t)bsi};
+    uint8_t first_element;
+    uint8_t step_size;
+    tr51_calculate_channel_table(number_of_channels, nearest_prime, channel_table);
+    tr51_compute_cfd(mac, &first_element, &step_size, nearest_prime);
+// Not sure yet which one is the correct second parameter
+//    tr51_calculate_hopping_sequence(channel_table, number_of_channels, first_element, step_size, output_table, NULL, 0);
+    tr51_calculate_hopping_sequence(channel_table, nearest_prime, first_element, step_size, output_table, NULL, 0);
+    return output_table[slot_number];
+}

source/Service_Libs/fhss/channel_functions.h

@@ -46,6 +46,15 @@ uint16_t tr51_calculate_hopping_sequence(int32_t *channel_table, uint16_t channe
  */
 int32_t tr51_get_uc_channel_index(uint16_t slot_number, uint8_t *mac, int16_t number_of_channels);
 
+/**
+ * @brief Compute the broadcast schedule channel index using tr51 channel function.
+ * @param slot_number Current slot number.
+ * @param bsi Broadcast schedule identifier of the node for which the index is calculated.
+ * @param number_of_channels Number of channels.
+ * @return Channel index.
+ */
+int32_t tr51_get_bc_channel_index(uint16_t slot_number, uint16_t bsi, int16_t number_of_channels);
+
 /**
  * @brief Compute the unicast schedule channel index using direct hash channel function.
  * @param slot_number Current slot number.

source/Service_Libs/fhss/fhss_ws.c

@@ -50,22 +50,66 @@ fhss_structure_t *fhss_ws_enable(fhss_api_t *fhss_api, const fhss_ws_configurati
     }
     fhss_struct->fhss_conf.fhss_ws_configuration = *fhss_configuration;
     fhss_struct->number_of_channels = channel_count;
-
     return fhss_struct;
 }
 
+static void fhss_ws_update_bc_channel(fhss_structure_t *fhss_structure)
+{
+    uint8_t mac_address[8];
+    int32_t next_channel;
+    fhss_structure->callbacks.read_mac_address(fhss_structure->fhss_api, mac_address);
+    if (fhss_structure->ws->channel_function == WS_FIXED_CHANNEL) {
+
+    } else if (fhss_structure->ws->channel_function == WS_TR51CF) {
+        // TODO: Second parameter is BSI which needs to be implemented in FHSS configurations
+        next_channel = tr51_get_bc_channel_index(fhss_structure->ws->bc_slot, 0xffff, fhss_structure->number_of_channels);
+        if (++fhss_structure->ws->bc_slot == fhss_structure->number_of_channels) {
+            fhss_structure->ws->bc_slot = 0;
+        }
+    } else if (fhss_structure->ws->channel_function == WS_DH1CF) {
+        // TODO: Second parameter is BSI which needs to be implemented in FHSS configurations
+        next_channel = dh1cf_get_bc_channel_index(fhss_structure->ws->bc_slot, 0xffff, fhss_structure->number_of_channels);
+        fhss_structure->ws->bc_slot++;
+    } else if (fhss_structure->ws->channel_function == WS_VENDOR_DEF_CF) {
+        //TODO: Callback to get channel schedule from application
+    }
+#ifdef FHSS_CHANNEL_DEBUG
+    tr_info("%"PRIu32" BC %u %u", fhss_structure->platform_functions.fhss_get_timestamp(fhss_structure->fhss_api), next_channel, fhss_structure->ws->bc_slot);
+#endif /*FHSS_CHANNEL_DEBUG*/
+    fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, next_channel);
+}
+
+static void fhss_broadcast_handler(const fhss_api_t *fhss_api, uint16_t delay)
+{
+    (void) delay;
+    fhss_structure_t *fhss_structure = fhss_get_object_with_api(fhss_api);
+    if (!fhss_structure) {
+        return;
+    }
+    if (fhss_structure->ws->is_on_bc_channel == false) {
+        fhss_start_timer(fhss_structure, fhss_structure->fhss_conf.fhss_ws_configuration.fhss_bc_dwell_interval*1000, fhss_broadcast_handler);
+        fhss_structure->ws->is_on_bc_channel = true;
+        fhss_ws_update_bc_channel(fhss_structure);
+    } else {
+        uint32_t timeout = (fhss_structure->fhss_conf.fhss_ws_configuration.fhss_broadcast_interval - fhss_structure->fhss_conf.fhss_ws_configuration.fhss_bc_dwell_interval) * 1000;
+        fhss_start_timer(fhss_structure, timeout, fhss_broadcast_handler);
+        fhss_structure->ws->is_on_bc_channel = false;
+    }
+}
+
 static uint32_t fhss_ws_get_sf_timeout_callback(fhss_structure_t *fhss_structure)
 {
     return fhss_structure->fhss_conf.fhss_ws_configuration.fhss_uc_dwell_interval * 1000;
 }
 
 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->fhss_conf.fhss_ws_configuration.fhss_uc_dwell_interval*1000, fhss_superframe_handler);
+    if (fhss_state == FHSS_SYNCHRONIZED) {
+        fhss_start_timer(fhss_structure, fhss_structure->fhss_conf.fhss_ws_configuration.fhss_uc_dwell_interval*1000, fhss_superframe_handler);
+    }
+
+    fhss_structure->fhss_state = fhss_state;
     return 0;
 }
 
@@ -74,26 +118,26 @@ 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)
+static void fhss_ws_update_uc_channel_callback(fhss_structure_t *fhss_structure)
 {
     uint8_t mac_address[8];
     int32_t next_channel;
     fhss_structure->callbacks.read_mac_address(fhss_structure->fhss_api, mac_address);
     if (fhss_structure->ws->channel_function == WS_FIXED_CHANNEL) {
 
     } else if (fhss_structure->ws->channel_function == WS_TR51CF) {
-        next_channel = fhss_structure->rx_channel = tr51_get_uc_channel_index(fhss_structure->ws->slot, mac_address, fhss_structure->number_of_channels);
-        if (++fhss_structure->ws->slot == fhss_structure->number_of_channels) {
-            fhss_structure->ws->slot = 0;
+        next_channel = fhss_structure->rx_channel = tr51_get_uc_channel_index(fhss_structure->ws->uc_slot, mac_address, fhss_structure->number_of_channels);
+        if (++fhss_structure->ws->uc_slot == fhss_structure->number_of_channels) {
+            fhss_structure->ws->uc_slot = 0;
         }
     } else if (fhss_structure->ws->channel_function == WS_DH1CF) {
-        next_channel = fhss_structure->rx_channel = dh1cf_get_uc_channel_index(fhss_structure->ws->slot, mac_address, fhss_structure->number_of_channels);
-        fhss_structure->ws->slot++;
+        next_channel = fhss_structure->rx_channel = dh1cf_get_uc_channel_index(fhss_structure->ws->uc_slot, mac_address, fhss_structure->number_of_channels);
+        fhss_structure->ws->uc_slot++;
     } else if (fhss_structure->ws->channel_function == WS_VENDOR_DEF_CF) {
         //TODO: Callback to get channel schedule from application
     }
 #ifdef FHSS_CHANNEL_DEBUG
-    tr_info("%"PRIu32" UC %u %u", fhss_structure->platform_functions.fhss_get_timestamp(fhss_structure->fhss_api), next_channel, fhss_structure->ws->slot);
+    tr_info("%"PRIu32" UC %u %u", fhss_structure->platform_functions.fhss_get_timestamp(fhss_structure->fhss_api), next_channel, fhss_structure->ws->uc_slot);
 #endif /*FHSS_CHANNEL_DEBUG*/
     fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, next_channel);
 }
@@ -112,7 +156,7 @@ static int fhss_ws_tx_handle_callback(const fhss_api_t *api, bool is_broadcast_a
     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;
+        uint16_t destination_slot = fhss_structure->ws->uc_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) {
@@ -156,7 +200,7 @@ int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure)
     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_channel = fhss_ws_update_uc_channel_callback;
     fhss_structure->update_superframe = fhss_ws_superframe_callback;
     fhss_structure->read_superframe_timeout = fhss_ws_get_sf_timeout_callback;
     fhss_structure->handle_state_set = fhss_ws_handle_state_set;
@@ -165,5 +209,6 @@ int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure)
         return -1;
     }
     memset(fhss_structure->ws, 0, sizeof(fhss_ws_t));
+    fhss_structure->ws->channel_function = fhss_structure->fhss_conf.fhss_ws_configuration.ws_channel_function;
     return 0;
 }

source/Service_Libs/fhss/fhss_ws.h

@@ -21,7 +21,9 @@ typedef struct fhss_ws fhss_ws_t;
 struct fhss_ws
 {
     fhss_ws_channel_functions channel_function;
-    uint16_t slot;
+    uint16_t uc_slot;
+    uint16_t bc_slot;
+    bool is_on_bc_channel;
 };
 
 fhss_structure_t *fhss_ws_enable(fhss_api_t *fhss_api, const fhss_ws_configuration_t *fhss_configuration, const fhss_timer_t *fhss_timer);