Merge pull request ARMmbed#1541 from ARMmbed/IOTTHD-2171

Iotthd 2171

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/channel_functions.c

@@ -41,6 +41,25 @@
 
 static uint32_t global_seed = 1;
 
+
+uint16_t tr51_calc_nearest_prime_number(uint16_t start_value)
+{
+    if (start_value < 2) {
+        return 0;
+    }
+    uint16_t divider = start_value - 1;
+    while (start_value) {
+        if (start_value % divider--) {
+            if (divider == 1) {
+                return start_value;
+            }
+        } else {
+            divider = ++start_value - 1;
+        }
+    }
+    return 0;
+}
+
 void tr51_seed_rand(uint32_t seed)
 {
     if (!seed) {
@@ -161,3 +180,16 @@ int32_t dh1cf_get_bc_channel_index(uint16_t slot_number, uint16_t bsi, int16_t n
     channel_number = dh1cf_hashword(key, 3, 0) % number_of_channels;
     return channel_number;
 }
+
+int32_t tr51_get_uc_channel_index(uint16_t slot_number, uint8_t *mac, 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 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);
+    tr51_calculate_hopping_sequence(channel_table, number_of_channels, first_element, step_size, output_table, NULL, 0);
+    return output_table[slot_number];
+}

source/Service_Libs/fhss/channel_functions.h

@@ -24,7 +24,7 @@
 void tr51_calculate_channel_table(uint16_t number_of_channels, uint16_t nearest_prime, int32_t *channel_table);
 
 /**
- * @brief Calculate hopping sequence for a specific peer.
+ * @brief Calculate hopping sequence for a specific peer using tr51 channel function.
  * @param channel_table Used channel table.
  * @param channel_table_length Length of the used channel table.
  * @param first_element Start generated by CFD function.
@@ -37,7 +37,16 @@ void tr51_calculate_channel_table(uint16_t number_of_channels, uint16_t nearest_
 uint16_t tr51_calculate_hopping_sequence(int32_t *channel_table, uint16_t channel_table_length, uint8_t first_element, uint8_t step_size, int32_t *output_table, uint16_t *excluded_channels, uint16_t number_of_excluded_channels);
 
 /**
- * @brief Compute the unicast schedule channel index.
+ * @brief Compute the unicast schedule channel index using tr51 channel function.
+ * @param slot_number Current slot number.
+ * @param mac MAC address of the node for which the index is calculated.
+ * @param number_of_channels Number of channels.
+ * @return Channel index.
+ */
+int32_t tr51_get_uc_channel_index(uint16_t slot_number, uint8_t *mac, int16_t number_of_channels);
+
+/**
+ * @brief Compute the unicast schedule channel index using direct hash channel function.
  * @param slot_number Current slot number.
  * @param mac MAC address of the node for which the index is calculated.
  * @param number_of_channels Number of channels.
@@ -46,7 +55,7 @@ uint16_t tr51_calculate_hopping_sequence(int32_t *channel_table, uint16_t channe
 int32_t dh1cf_get_uc_channel_index(uint16_t slot_number, uint8_t *mac, int16_t number_of_channels);
 
 /**
- * @brief Compute the broadcast schedule channel index.
+ * @brief Compute the broadcast schedule channel index using direct hash 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.

source/Service_Libs/fhss/fhss.c

@@ -28,6 +28,7 @@
 #include "ns_trace.h"
 #include "eventOS_event.h"
 #include "eventOS_callback_timer.h"
+#include "platform/arm_hal_interrupt.h"
 #include "randLIB.h"
 #include <string.h>
 
@@ -165,97 +166,7 @@ int fhss_reset_synch_monitor(fhss_synch_monitor_s *synch_monitor)
 	return -1;
 }
 
-uint32_t fhss_get_remaining_time_to_next_superframe(const fhss_structure_t *fhss_structure)
-{
-    const uint32_t slots = fhss_structure->platform_functions.fhss_get_remaining_slots(fhss_superframe_handler, fhss_structure->fhss_api);
-    const uint32_t time = slots * fhss_structure->platform_functions.fhss_resolution_divider;
-    return time;
-}
-
-void fhss_superframe_handler(const fhss_api_t *fhss_api, uint16_t delay)
-{
-    int compensation = 0;
-    fhss_structure_t *fhss_structure = fhss_get_object_with_api(fhss_api);
-    if (!fhss_structure) {
-        return;
-    }
-/* Drift compensation doesn't work with Linux platform */
-#ifndef __linux__
-    // Drift compensation on first superframe
-    if (fhss_structure->current_superframe == 0) {
-        /* Idea is to compensate number of drift_compensation (microseconds) on each channel.
-         * However, fhss_resolution_divider defines the minimum timer resolution.
-         * E.g. if fhss_resolution_divider = 64, compensate (drift_compensation * 64) on each 64th channel.
-         */
-        if (++fhss_structure->synch_monitor.channel_counter == fhss_structure->platform_functions.fhss_resolution_divider) {
-            compensation = fhss_structure->synch_monitor.drift_compensation;
-            fhss_structure->synch_monitor.channel_counter = 0;
-        }
-    }
-#endif //__linux__
-    // Restart timer asap to minimize the effect of dynamic execution time of
-    // the rest of function.
-    fhss_start_timer(fhss_structure, (fhss_structure->synch_configuration.fhss_superframe_length) - (delay * fhss_structure->platform_functions.fhss_resolution_divider) + (compensation * fhss_structure->platform_functions.fhss_resolution_divider), fhss_superframe_handler);
-
-    // check, if the current frame was the last one
-    if (fhss_structure->current_superframe >= (fhss_structure->synch_configuration.fhss_number_of_superframes - 1)) {
-
-        // last superframe has passed, change channel
-        fhss_structure->current_superframe = 0;
-        fhss_structure->current_channel_index++;
-        if (fhss_structure->current_channel_index >= fhss_structure->number_of_channels) {
-            fhss_structure->synch_infos_sent_counter = 0;
-            fhss_structure->current_channel_index = 0;
-            fhss_structure->channel_list_counter++;
-            // Repeated cycle is started from beginning, reset counter. Don't let the channel_list_counter overflow.
-            if (fhss_structure->channel_list_counter >= ((uint16_t) fhss_structure->number_of_channels * MAX_SCRAMBLE_TABLE_INDEXES)) {
-                fhss_structure->channel_list_counter = 0;
-            }
-            // Hop 0 don't have parent
-            if (fhss_is_synch_root(fhss_structure) == false) {
-                fhss_trig_event(fhss_structure, FHSS_COMPARE_SYNCH_PARENT);
-            }
-            fhss_trig_event(fhss_structure, FHSS_UPDATE_SYNCH_INFO_STORAGE);
-        }
-        fhss_update_channel(fhss_structure);
-    } else  {
-        // bump up the superframe counter
-        fhss_structure->current_superframe++;
-    }
-    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:
-         * on first superframe probability is 1/number of superframes
-         * on second superframe probability is 1/(number of superframes-1)
-         * on third superframe probability is 1/(number of superframes-2)
-         * on last superframe probability is 1/1
-         */
-        if (randLIB_get_random_in_range(1, fhss_structure->synch_configuration.fhss_number_of_superframes - fhss_structure->current_superframe) == 1) {
-            fhss_structure->send_synch_info_on_next_broadcast_channel = false;
-            fhss_structure->synch_infos_sent_counter++;
-            fhss_structure->callbacks.send_fhss_frame(fhss_structure->fhss_api, FHSS_SYNCH_FRAME);
-        }
-    }
-    fhss_update_txrx_slots(fhss_structure);
-    uint16_t queue_size = fhss_structure->callbacks.read_tx_queue_size(fhss_structure->fhss_api, false) + fhss_structure->callbacks.read_tx_queue_size(fhss_structure->fhss_api, true);
-    if ((fhss_structure->tx_allowed == true || fhss_is_current_channel_broadcast(fhss_structure) == true) && queue_size) {
-        /* Start timer with random timeout to trigger TX queue poll event.
-         * Max random is half of the superframe length. Event timer resolution is 50us.
-         * Divide Max random with TX queue size to transmit faster when TX queue is growing
-         */
-        uint16_t max_random = ((fhss_structure->synch_configuration.fhss_superframe_length / 2) / 50) / queue_size;
-        eventOS_callback_timer_start(fhss_structure->fhss_event_timer, randLIB_get_random_in_range(1, max_random));
-    }
-    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) {
-            fhss_trig_event(fhss_structure, FHSS_TIMER_EVENT);
-            fhss_structure->fhss_timeout = 0;
-            fhss_structure->fhss_timer = 0;
-        }
-    }
-}
-
-int fhss_update_txrx_slots(fhss_structure_t *fhss_structure)
+static int fhss_update_txrx_slots(fhss_structure_t *fhss_structure)
 {
     uint8_t cur_superframe = fhss_structure->current_superframe;
     uint8_t number_of_tx_slots = fhss_structure->synch_configuration.fhss_number_of_tx_slots;
@@ -438,7 +349,7 @@ int fhss_sync_with_beacon(fhss_structure_t *fhss_structure,
 
         if (fhss_structure->fhss_state == FHSS_UNSYNCHRONIZED) {
             fhss_structure->fhss_state = FHSS_SYNCHRONIZED;
-            fhss_update_channel(fhss_structure);
+            fhss_change_to_next_channel(fhss_structure);
         }
         if (fhss_is_synch_root(fhss_structure) == false) {
             // Initially synch drift might be massive. Request first few Beacons more frequently until compensation starts fixing the error.
@@ -563,7 +474,7 @@ static bool fhss_is_there_common_divisor(uint16_t i, uint8_t j)
 }
 
 
-int fhss_generate_scramble_table(fhss_structure_t *fhss_structure)
+static int fhss_generate_scramble_table(fhss_structure_t *fhss_structure)
 {
     uint8_t j = 2;
     fhss_structure->fhss_scramble_table = ns_dyn_mem_alloc(MAX_SCRAMBLE_TABLE_INDEXES);
@@ -746,3 +657,134 @@ void fhss_failed_list_free(fhss_structure_t *fhss_structure)
         fhss_failed_handle_remove(fhss_structure, i);
     }
 }
+
+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) {
+        tr_debug("Synch same state %u", fhss_state);
+        return -1;
+    }
+
+    if (fhss_state == FHSS_UNSYNCHRONIZED) {
+        tr_debug("FHSS down");
+        fhss_down(fhss_structure);
+    } else {
+        // Do not synchronize to current pan
+        if (fhss_structure->synch_panid == pan_id) {
+            tr_debug("Synch same panid %u", pan_id);
+            return -1;
+        }
+        if (fhss_structure->fhss_scramble_table == NULL) {
+            if (fhss_generate_scramble_table(fhss_structure)) {
+                tr_error("Failed to generate scramble table");
+                return -1;
+            }
+        }
+        uint32_t datarate = fhss_structure->callbacks.read_datarate(fhss_structure->fhss_api);
+        fhss_set_datarate(fhss_structure, datarate);
+        uint8_t mac_address[8];
+        fhss_structure->callbacks.read_mac_address(fhss_structure->fhss_api, mac_address);
+        fhss_structure->uc_channel_index = fhss_get_offset(fhss_structure, mac_address);
+        // Get Beacon info from storage
+        fhss_beacon_info_t *beacon_info = fhss_get_beacon_info(fhss_structure, pan_id);
+        if (beacon_info) {
+            memcpy(fhss_structure->synch_parent, beacon_info->source_address, 8);
+            platform_enter_critical();
+            // Calculate time since the Beacon was received
+            uint32_t elapsed_time = fhss_structure->fhss_api->read_timestamp(fhss_structure->fhss_api) - beacon_info->timestamp;
+            // Synchronize to given PAN
+            fhss_beacon_received(fhss_structure, beacon_info->synch_info, elapsed_time);
+            platform_exit_critical();
+            // Delete stored Beacon infos
+            fhss_flush_beacon_info_storage(fhss_structure);
+            fhss_structure->synch_panid = pan_id;
+        } else if (fhss_is_synch_root(fhss_structure) == true) {
+            // Synch root will start new network
+            fhss_start_timer(fhss_structure, fhss_structure->synch_configuration.fhss_superframe_length, fhss_superframe_handler);
+        } else {
+            tr_error("Synch info not found");
+            return -1;
+        }
+    }
+    return 0;
+}
+
+static uint32_t fhss_get_compensation(fhss_structure_t *fhss_structure)
+{
+    uint32_t compensation = 0;
+    /* Drift compensation doesn't work with Linux platform */
+#ifndef __linux__
+    // Drift compensation on first superframe
+    if (fhss_structure->current_superframe == 0) {
+        /* Idea is to compensate number of drift_compensation (microseconds) on each channel.
+         * However, fhss_resolution_divider defines the minimum timer resolution.
+         * E.g. if fhss_resolution_divider = 64, compensate (drift_compensation * 64) on each 64th channel.
+         */
+        if (++fhss_structure->synch_monitor.channel_counter == fhss_structure->platform_functions.fhss_resolution_divider) {
+            compensation = fhss_structure->synch_monitor.drift_compensation;
+            fhss_structure->synch_monitor.channel_counter = 0;
+        }
+    }
+#else
+    (void) fhss_structure;
+#endif //__linux__
+    return compensation;
+}
+
+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:
+         * on first superframe probability is 1/number of superframes
+         * on second superframe probability is 1/(number of superframes-1)
+         * on third superframe probability is 1/(number of superframes-2)
+         * on last superframe probability is 1/1
+         */
+        if (randLIB_get_random_in_range(1, fhss_structure->synch_configuration.fhss_number_of_superframes - fhss_structure->current_superframe) == 1) {
+            fhss_structure->send_synch_info_on_next_broadcast_channel = false;
+            fhss_structure->synch_infos_sent_counter++;
+            fhss_structure->callbacks.send_fhss_frame(fhss_structure->fhss_api, FHSS_SYNCH_FRAME);
+        }
+    }
+    fhss_update_txrx_slots(fhss_structure);
+    uint16_t queue_size = fhss_structure->callbacks.read_tx_queue_size(fhss_structure->fhss_api, false) + fhss_structure->callbacks.read_tx_queue_size(fhss_structure->fhss_api, true);
+    if ((fhss_structure->tx_allowed == true || fhss_is_current_channel_broadcast(fhss_structure) == true) && queue_size) {
+        /* Start timer with random timeout to trigger TX queue poll event.
+         * Max random is half of the superframe length. Event timer resolution is 50us.
+         * Divide Max random with TX queue size to transmit faster when TX queue is growing
+         */
+        uint16_t max_random = ((fhss_structure->synch_configuration.fhss_superframe_length / 2) / 50) / queue_size;
+        eventOS_callback_timer_start(fhss_structure->fhss_event_timer, randLIB_get_random_in_range(1, max_random));
+    }
+}
+
+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;
+        if (++fhss_structure->channel_list_counter >= ((uint16_t) fhss_structure->number_of_channels * MAX_SCRAMBLE_TABLE_INDEXES)) {
+            fhss_structure->channel_list_counter = 0;
+        }
+        if (fhss_is_synch_root(fhss_structure) == false) {
+            fhss_trig_event(fhss_structure, FHSS_COMPARE_SYNCH_PARENT);
+        }
+        fhss_trig_event(fhss_structure, FHSS_UPDATE_SYNCH_INFO_STORAGE);
+    }
+    // If channel is broadcast channel (true), send event
+    if (fhss_change_to_next_channel(fhss_structure) == true) {
+        // Only if device is border router
+        if (fhss_structure->own_hop == 0) {
+            fhss_trig_event(fhss_structure, FHSS_BROADCAST_CHANNEL);
+        }
+    }
+}
+
+int 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;
+    return 0;
+}

source/Service_Libs/fhss/fhss.h

@@ -36,26 +36,16 @@ 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);
-void fhss_superframe_handler(const fhss_api_t *fhss_api, uint16_t delay);
 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);
-int fhss_generate_scramble_table(fhss_structure_t *fhss_structure);
 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);
+
 #define MAX_FHSS_TIMER_DIVIDER  100
 #define SYNCH_MONITOR_AVG_SAMPLES   5
 
-/**
- * Update slots
- *
- * Every superframe handler interrupt calls this function to update the TX/RX slot status.
- *
- * @param fhss_structure Pointer to FHSS structure
- * @return 0 for success, -1 for fail
- */
-int fhss_update_txrx_slots(fhss_structure_t *fhss_structure);
-
 /**
  * Calculate time in microseconds to start of next superframe.
  *

source/Service_Libs/fhss/fhss_channel.c

@@ -29,7 +29,7 @@
 #define TRACE_GROUP "fhss"
 
 // Enable this flag to use channel traces
-//#define FHSS_CHANNEL_DEBUG
+// #define FHSS_CHANNEL_DEBUG
 
 static uint8_t fhss_get_bc_index(const fhss_structure_t *fhss_structure);