FHSS: function to check if remaining slots is negative

Author: Jarkko Paso

source/Service_Libs/fhss/fhss_ws.c

@@ -71,6 +71,16 @@ static uint32_t divide_integer(uint32_t dividend, uint32_t divisor)
     return (dividend + divisor/2) / divisor;
 }
 
+static uint32_t get_remaining_slots_us(fhss_structure_t *fhss_structure, void (*callback)(const fhss_api_t *api, uint16_t), uint32_t max_timeout_us)
+{
+    uint32_t remaining_time_us = fhss_structure->platform_functions.fhss_get_remaining_slots(callback, fhss_structure->fhss_api);
+    // When remaining time goes negative, use 0.
+    if (remaining_time_us > max_timeout_us) {
+        remaining_time_us = 0;
+    }
+    return remaining_time_us;
+}
+
 fhss_structure_t *fhss_ws_enable(fhss_api_t *fhss_api, const fhss_ws_configuration_t *fhss_configuration, const fhss_timer_t *fhss_timer)
 {
     if (!fhss_api || !fhss_configuration || !fhss_timer) {
@@ -247,7 +257,7 @@ static void fhss_event_timer_cb(int8_t timer_id, uint16_t slots)
     } 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)) {
+        if (delay_between_tx_slots_us < get_remaining_slots_us(fhss_structure, fhss_broadcast_handler, fhss_structure->ws->fhss_configuration.fhss_broadcast_interval*1000)) {
             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);
@@ -265,16 +275,13 @@ static uint32_t fhss_ws_calculate_ufsi(fhss_structure_t *fhss_structure, uint32_
         cur_slot = fhss_structure->number_of_channels;
     }
     cur_slot--;
-    uint32_t remaining_time = (fhss_structure->platform_functions.fhss_get_remaining_slots(fhss_unicast_handler, fhss_structure->fhss_api) / 1000);
-    if (remaining_time > dwell_time) {
-        remaining_time = 0;
-    }
+    uint32_t remaining_time_ms = get_remaining_slots_us(fhss_structure, fhss_unicast_handler, fhss_structure->ws->fhss_configuration.fhss_uc_dwell_interval*1000) / 1000;
     uint32_t time_to_tx = 0;
     uint32_t cur_time = fhss_structure->callbacks.read_timestamp(fhss_structure->fhss_api);
     if (cur_time < tx_time) {
         time_to_tx = (tx_time - cur_time) / 1000;
     }
-    uint64_t ms_since_seq_start = (cur_slot * dwell_time) + (dwell_time-remaining_time) + time_to_tx;
+    uint64_t ms_since_seq_start = (cur_slot * dwell_time) + (dwell_time-remaining_time_ms) + time_to_tx;
     uint32_t seq_length = 0x10000;
     if (fhss_structure->ws->fhss_configuration.ws_uc_channel_function == WS_TR51CF) {
         ms_since_seq_start %= (dwell_time*fhss_structure->number_of_channels);
@@ -287,17 +294,16 @@ static uint32_t fhss_ws_calculate_broadcast_interval_offset(fhss_structure_t *fh
 {
     uint8_t dwell_time = fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval;
     uint32_t broadcast_interval = fhss_structure->ws->fhss_configuration.fhss_broadcast_interval;
-
-    uint32_t remaining_time = divide_integer(fhss_structure->platform_functions.fhss_get_remaining_slots(fhss_broadcast_handler, fhss_structure->fhss_api), 1000);
+    uint32_t remaining_time_ms = divide_integer(get_remaining_slots_us(fhss_structure, fhss_broadcast_handler, fhss_structure->ws->fhss_configuration.fhss_broadcast_interval*1000), 1000);
     if (fhss_structure->ws->is_on_bc_channel == true) {
-        remaining_time += (broadcast_interval - dwell_time);
+        remaining_time_ms += (broadcast_interval - dwell_time);
     }
     uint32_t time_to_tx = 0;
     uint32_t cur_time = fhss_structure->callbacks.read_timestamp(fhss_structure->fhss_api);
     if (cur_time < tx_time) {
         time_to_tx = divide_integer(tx_time - cur_time, 1000);
     }
-    return (broadcast_interval-remaining_time) + time_to_tx;
+    return (broadcast_interval-remaining_time_ms) + time_to_tx;
 }
 
 static uint16_t fhss_ws_calculate_destination_slot(fhss_ws_neighbor_timing_info_t *neighbor_timing_info, uint32_t tx_time)
@@ -466,7 +472,8 @@ static bool fhss_ws_check_tx_allowed(fhss_structure_t *fhss_structure)
     if (!number_of_tx_slots) {
         return true;
     }
-    uint32_t remaining_time_ms = fhss_structure->platform_functions.fhss_get_remaining_slots(fhss_broadcast_handler, fhss_structure->fhss_api) / 1000;
+
+    uint32_t remaining_time_ms = get_remaining_slots_us(fhss_structure, fhss_broadcast_handler, fhss_structure->ws->fhss_configuration.fhss_broadcast_interval*1000) / 1000;
     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;
@@ -488,8 +495,8 @@ static bool fhss_ws_check_tx_time(fhss_structure_t *fhss_structure, uint16_t tx_
         return true;
     }
     uint32_t tx_time = fhss_get_tx_time(fhss_structure, tx_length, phy_header_length, phy_tail_length);
-    uint32_t time_to_bc_channel = fhss_structure->platform_functions.fhss_get_remaining_slots(fhss_broadcast_handler, fhss_structure->fhss_api);
-    if (tx_time > time_to_bc_channel) {
+    uint32_t time_to_bc_channel_us = get_remaining_slots_us(fhss_structure, fhss_broadcast_handler, fhss_structure->ws->fhss_configuration.fhss_broadcast_interval);
+    if (tx_time > time_to_bc_channel_us) {
         return false;
     }
     return true;