Merge pull request ARMmbed#1803 from ARMmbed/IOTTHD-2736

Iotthd 2736

source/Service_Libs/fhss/fhss.c

@@ -34,6 +34,7 @@
 
 #define TRACE_GROUP "fhss"
 
+static void fhss_event_timer_cb(int8_t timer_id, uint16_t slots);
 static int fhss_reset(fhss_structure_t *fhss_structure);
 static bool fhss_is_bc_sending_superframe(fhss_structure_t *fhss_structure);
 static bool fhss_check_remaining_tx_time(fhss_structure_t *fhss_structure, uint16_t tx_length, uint8_t phy_header_length, uint8_t phy_tail_length);
@@ -67,6 +68,7 @@ fhss_structure_t *fhss_enable(fhss_api_t *fhss_api, const fhss_configuration_t *
  }
  memset(fhss_struct->bs, 0, sizeof(fhss_bs_t));
 
+ fhss_struct->fhss_event_timer = eventOS_callback_timer_register(fhss_event_timer_cb);
  fhss_struct->bs->fhss_configuration = *fhss_configuration;
  fhss_struct->bs->fhss_stats_ptr = fhss_statistics;
  fhss_struct->number_of_channels = channel_count;
@@ -99,6 +101,15 @@ bool fhss_is_synch_root(fhss_structure_t *fhss_structure)
  return true;
 }
 
+static void fhss_event_timer_cb(int8_t timer_id, uint16_t slots)
+{
+ (void) slots;
+ fhss_structure_t *fhss_structure = fhss_get_object_with_timer_id(timer_id);
+ if (fhss_structure) {
+ fhss_structure->callbacks.tx_poll(fhss_structure->fhss_api);
+ }
+}
+
 static bool fhss_is_bc_sending_superframe(fhss_structure_t *fhss_structure)
 {
  if (fhss_structure->bs->current_superframe >= fhss_structure->bs->broadcast_start_superframe) {

source/Service_Libs/fhss/fhss_common.c

@@ -34,8 +34,6 @@
 
 static fhss_structure_t *fhss_struct = NULL;
 
-static void fhss_event_timer_cb(int8_t timer_id, uint16_t slots);
-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);
 
@@ -52,7 +50,6 @@ fhss_structure_t *fhss_allocate_instance(fhss_api_t *fhss_api, const fhss_timer_
  memset(fhss_struct, 0, sizeof(fhss_structure_t));
  fhss_struct->fhss_api = fhss_api;
  fhss_struct->platform_functions = *fhss_timer;
- fhss_struct->fhss_event_timer = eventOS_callback_timer_register(fhss_event_timer_cb);
  if (!fhss_struct->platform_functions.fhss_resolution_divider) {
  fhss_struct->platform_functions.fhss_resolution_divider = 1;
  }
@@ -69,16 +66,7 @@ int8_t fhss_free_instance(fhss_api_t *fhss_api)
  return 0;
 }
 
-static void fhss_event_timer_cb(int8_t timer_id, uint16_t slots)
-{
- (void) slots;
- fhss_structure_t *fhss_structure = fhss_get_object_with_timer_id(timer_id);
- if (fhss_structure) {
- fhss_structure->callbacks.tx_poll(fhss_structure->fhss_api);
- }
-}
-
-static fhss_structure_t *fhss_get_object_with_timer_id(const int8_t timer_id)
+fhss_structure_t *fhss_get_object_with_timer_id(const int8_t timer_id)
 {
  if (timer_id < 0 || !fhss_struct) {
  return NULL;

source/Service_Libs/fhss/fhss_common.h

@@ -54,6 +54,7 @@ struct fhss_structure
  uint8_t synch_parent[8];
 };
 
+fhss_structure_t *fhss_get_object_with_timer_id(const int8_t timer_id);
 fhss_structure_t *fhss_allocate_instance(fhss_api_t *fhss_api, const fhss_timer_t *fhss_timer);
 int8_t fhss_free_instance(fhss_api_t *fhss_api);
 int8_t fhss_set_datarate(fhss_structure_t *fhss_structure, uint32_t datarate);

source/Service_Libs/fhss/fhss_ws.c

@@ -57,9 +57,11 @@ struct ws_ie_t {
  uint8_t id;
 };
 
+static void fhss_event_timer_cb(int8_t timer_id, uint16_t slots);
 static void fhss_ws_update_uc_channel_callback(fhss_structure_t *fhss_structure);
 static void fhss_unicast_handler(const fhss_api_t *fhss_api, uint16_t delay);
-static void fhss_ws_start_tx_poll_timer(fhss_structure_t *fhss_structure, uint16_t queue_size, uint8_t channel_dwell_interval);
+static bool fhss_ws_check_tx_allowed(fhss_structure_t *fhss_structure);
+static uint8_t fhss_set_txrx_slot_length(fhss_structure_t *fhss_structure);
 
 fhss_structure_t *fhss_ws_enable(fhss_api_t *fhss_api, const fhss_ws_configuration_t *fhss_configuration, const fhss_timer_t *fhss_timer)
 {
@@ -83,13 +85,25 @@ fhss_structure_t *fhss_ws_enable(fhss_api_t *fhss_api, const fhss_ws_configurati
  }
  memset(fhss_struct->ws, 0, sizeof(fhss_ws_t));
 
+ fhss_struct->fhss_event_timer = eventOS_callback_timer_register(fhss_event_timer_cb);
  fhss_struct->ws->fhss_configuration = *fhss_configuration;
  fhss_struct->number_of_channels = channel_count;
  fhss_struct->own_hop = 0xff;
+ fhss_set_txrx_slot_length(fhss_struct);
  ns_list_init(&fhss_struct->fhss_failed_tx_list);
  return fhss_struct;
 }
 
+static uint8_t fhss_set_txrx_slot_length(fhss_structure_t *fhss_structure)
+{
+ uint8_t number_of_tx_slots = ((fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) / WS_MAX_TXRX_SLOT_LEN_MS) / 2;
+ if (!number_of_tx_slots) {
+ return 0;
+ }
+ fhss_structure->ws->txrx_slot_length_ms = (fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) / (number_of_tx_slots * 2);
+ return number_of_tx_slots;
+}
+
 static int32_t fhss_ws_calc_bc_channel(fhss_structure_t *fhss_structure)
 {
  int32_t next_channel = fhss_structure->rx_channel;
@@ -130,12 +144,37 @@ static void fhss_broadcast_handler(const fhss_api_t *fhss_api, uint16_t delay)
  fhss_start_timer(fhss_structure, fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval*1000 - (delay * fhss_structure->platform_functions.fhss_resolution_divider), fhss_broadcast_handler);
  fhss_structure->ws->is_on_bc_channel = true;
  next_channel = fhss_structure->ws->bc_channel = fhss_ws_calc_bc_channel(fhss_structure);
+
+ /* Start timer with random timeout to trigger broadcast TX queue poll event.
+ * Min random is 1/50 of the channel dwell interval.
+ * Max random is 1/10 of the channel dwell interval.
+ * Event timer resolution is 50us.
+ */
+ uint32_t bc_dwell_us = fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval*1000;
+ uint16_t bc_min_random = (bc_dwell_us / 50) / 50;
+ uint16_t bc_max_random = (bc_dwell_us / 10) / 50;
+ eventOS_callback_timer_start(fhss_structure->fhss_event_timer, randLIB_get_random_in_range(bc_min_random, bc_max_random));
  } else {
  uint32_t timeout = (fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) * 1000;
  fhss_start_timer(fhss_structure, timeout - (delay * fhss_structure->platform_functions.fhss_resolution_divider), fhss_broadcast_handler);
  fhss_structure->ws->is_on_bc_channel = false;
  // Should return to own (unicast) listening channel after broadcast channel
  next_channel = fhss_structure->rx_channel;
+ /* Start timer with random timeout to trigger unicast TX queue poll event.
+ * Min random is 50us.
+ * Max random is 1/10 of the TX slot length.
+ * Event timer resolution is 50us.
+ */
+ uint32_t txrx_slot_length_us = fhss_structure->ws->txrx_slot_length_ms * 1000;
+ uint16_t uc_min_random = 1;
+ uint16_t uc_max_random = (txrx_slot_length_us / 10) / 50;
+ bool tx_allowed = fhss_ws_check_tx_allowed(fhss_structure);
+ if (!tx_allowed) {
+ uc_min_random += (txrx_slot_length_us)/50;
+ uc_max_random += (txrx_slot_length_us)/50;
+ }
+ eventOS_callback_timer_start(fhss_structure->fhss_event_timer, randLIB_get_random_in_range(uc_min_random, uc_max_random));
+
 #ifdef FHSS_CHANNEL_DEBUG
  tr_info("%"PRIu32" UC %u", fhss_structure->platform_functions.fhss_get_timestamp(fhss_structure->fhss_api), fhss_structure->rx_channel);
 #endif /*FHSS_CHANNEL_DEBUG*/
@@ -146,8 +185,6 @@ static void fhss_broadcast_handler(const fhss_api_t *fhss_api, uint16_t delay)
  fhss_bc_switch();
  }
 #endif /*FHSS_CHANNEL_DEBUG_CBS*/
- fhss_ws_start_tx_poll_timer(fhss_structure, fhss_structure->callbacks.read_tx_queue_size(fhss_structure->fhss_api, true),
- fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval);
 }
 
 static int own_floor(float value)
@@ -164,6 +201,28 @@ static int own_ceil(float value)
  return ivalue + 1;
 }
 
+static void fhss_event_timer_cb(int8_t timer_id, uint16_t slots)
+{
+ (void) slots;
+ uint16_t queue_size = 0;
+ fhss_structure_t *fhss_structure = fhss_get_object_with_timer_id(timer_id);
+
+
+ if (fhss_structure->ws->is_on_bc_channel == true) {
+ queue_size = fhss_structure->callbacks.read_tx_queue_size(fhss_structure->fhss_api, true);
+ } else {
+ // On unicast, start timer to trigger polling event on next TX slot
+ uint32_t delay_between_tx_slots_us = fhss_structure->ws->txrx_slot_length_ms*1000*2;
+ if (delay_between_tx_slots_us < fhss_structure->platform_functions.fhss_get_remaining_slots(fhss_broadcast_handler, fhss_structure->fhss_api)) {
+ eventOS_callback_timer_start(fhss_structure->fhss_event_timer, delay_between_tx_slots_us/50);
+ }
+ queue_size = fhss_structure->callbacks.read_tx_queue_size(fhss_structure->fhss_api, false);
+ }
+ if (queue_size) {
+ fhss_structure->callbacks.tx_poll(fhss_structure->fhss_api);
+ }
+}
+
 static uint32_t fhss_ws_calculate_ufsi(fhss_structure_t *fhss_structure, uint32_t tx_time)
 {
  uint8_t dwell_time = fhss_structure->ws->fhss_configuration.fhss_uc_dwell_interval;
@@ -348,23 +407,22 @@ static bool fhss_ws_check_tx_allowed(fhss_structure_t *fhss_structure)
  if (fhss_structure->ws->is_on_bc_channel == true) {
  return true;
  }
- uint8_t number_of_tx_slots = ((fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) / WS_MAX_TXRX_SLOT_LEN_MS) / 2;
+ uint8_t number_of_tx_slots = fhss_set_txrx_slot_length(fhss_structure);
  // Allow transmission when broadcast interval is very short comparing to MAX slot length
  if (!number_of_tx_slots) {
  return true;
  }
- uint32_t slot_len_ms = (fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) / (number_of_tx_slots * 2);
  uint32_t remaining_time_ms = fhss_structure->platform_functions.fhss_get_remaining_slots(fhss_broadcast_handler, fhss_structure->fhss_api) / 1000;
- uint32_t tx_slot_begin = (fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) - (slot_len_ms * (fhss_structure->own_hop & 1));
- uint32_t rx_slot_begin = tx_slot_begin - slot_len_ms;
+ uint32_t tx_slot_begin = (fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) - (fhss_structure->ws->txrx_slot_length_ms * (fhss_structure->own_hop & 1));
+ uint32_t rx_slot_begin = tx_slot_begin - fhss_structure->ws->txrx_slot_length_ms;
  uint8_t n_o_tx_slots = number_of_tx_slots;
 
  while (n_o_tx_slots--) {
  if ((remaining_time_ms <= tx_slot_begin) && (remaining_time_ms > rx_slot_begin)) {
  return true;
  }
- tx_slot_begin -= (2*slot_len_ms);
- rx_slot_begin = tx_slot_begin - slot_len_ms;
+ tx_slot_begin -= (2*fhss_structure->ws->txrx_slot_length_ms);
+ rx_slot_begin = tx_slot_begin - fhss_structure->ws->txrx_slot_length_ms;
  }
 
  return false;
@@ -564,24 +622,12 @@ static void fhss_unicast_handler(const fhss_api_t *fhss_api, uint16_t delay)
  timeout = fhss_ws_get_sf_timeout_callback(fhss_structure);
  fhss_start_timer(fhss_structure, timeout - (delay * fhss_structure->platform_functions.fhss_resolution_divider), fhss_unicast_handler);
  fhss_ws_update_uc_channel_callback(fhss_structure);
- fhss_ws_start_tx_poll_timer(fhss_structure, fhss_structure->callbacks.read_tx_queue_size(fhss_structure->fhss_api, false),
- fhss_structure->ws->fhss_configuration.fhss_uc_dwell_interval);
-}
-
-static void fhss_ws_start_tx_poll_timer(fhss_structure_t *fhss_structure, uint16_t queue_size, uint8_t channel_dwell_interval)
-{
- if (!queue_size) {
- return;
+ // Unless we have broadcast schedule, we have to poll unicast queue when changing channel. This is randomized by the unicast schedule.
+ if (!fhss_structure->ws->fhss_configuration.fhss_broadcast_interval || !fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) {
+ if (fhss_structure->callbacks.read_tx_queue_size(fhss_structure->fhss_api, false)) {
+ fhss_structure->callbacks.tx_poll(fhss_structure->fhss_api);
+ }
  }
- /* Start timer with random timeout to trigger TX queue poll event.
- * Min random is 1/50 of the channel dwell interval.
- * Max random is 1/10 of the channel dwell interval.
- * Event timer resolution is 50us.
- * Divide random with TX queue size to transmit faster when TX queue is growing
- */
- uint16_t min_random = ((((uint32_t)channel_dwell_interval * 1000) / 50) / 50) / queue_size;
- uint16_t max_random = ((((uint32_t)channel_dwell_interval * 1000) / 10) / 50) / queue_size;
- eventOS_callback_timer_start(fhss_structure->fhss_event_timer, randLIB_get_random_in_range(min_random, max_random));
 }
 
 int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure)
@@ -623,6 +669,7 @@ int fhss_ws_set_parent(fhss_structure_t *fhss_structure, const uint8_t eui64[8],
  // TODO: Calculate drift error
  fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval = bc_timing_info->broadcast_dwell_interval;
  fhss_structure->ws->fhss_configuration.fhss_broadcast_interval = bc_timing_info->broadcast_interval;
+ fhss_set_txrx_slot_length(fhss_structure);
  fhss_structure->ws->bc_slot = bc_timing_info->broadcast_slot + slots_since_reception;
 
  //TODO: support multiple parents

source/Service_Libs/fhss/fhss_ws.h

@@ -30,6 +30,7 @@ struct fhss_ws
  uint8_t bc_channel;
  uint16_t uc_slot;
  uint16_t bc_slot;
+ uint32_t txrx_slot_length_ms;
  bool is_on_bc_channel;
  struct fhss_ws_configuration fhss_configuration;
  const struct broadcast_timing_info *parent_bc_info;

test/nanostack/unittest/service_libs/fhss_common/test_fhss_common.c

@@ -84,13 +84,6 @@ bool test_fhss_allocate_instance()
  if (NULL == fhss_ptr) {
  return false;
  }
- // Test event timer cb with invalid timer id
- fhss_ptr->callbacks.tx_poll = &mac_poll_tx_queue;
- ns_timer_stub.cb(-1, 10);
- // Test event timer cb with random timer id
- ns_timer_stub.cb(1, 10);
- // Test event timer cb with valid timer id
- ns_timer_stub.cb(0, 10);
  // Free allocated instance
  fhss_free_instance(&fhss_api);
 

test/nanostack/unittest/stub/fhss_common_stub.c

@@ -55,6 +55,15 @@ fhss_structure_t *fhss_get_object_with_api(const fhss_api_t *fhss_api)
  return &fhss_common_stub.fhss_struct;
 }
 
+fhss_structure_t *fhss_get_object_with_timer_id(const int8_t timer_id)
+{
+ if (fhss_common_stub.bool_value == false) {
+ return NULL;
+ }
+ fhss_common_stub.fhss_struct.fhss_event_timer = timer_id;
+ return &fhss_common_stub.fhss_struct;
+}
+
 void fhss_clear_active_event(fhss_structure_t *fhss_structure, uint8_t event_type)
 {