Wi-sun ETX update

ETX is returning 0 untill all configured values are readed

ETX min sample count for calculate ETX is updated. Only full TX feilure may accelerate ETX calculation.

Added possibility drop bad etx init sample's 1-2 by given limit > 2.

Removed dBM link update from wi-sun side.

Author: Juha Heiskanen

source/6LoWPAN/ws/ws_bootstrap.c

@@ -1563,7 +1563,6 @@ static void ws_bootstrap_pan_config_analyse(struct protocol_interface_info_entry
     }
 
     if (neighbour_pointer_valid) {
-        etx_lqi_dbm_update(cur->id, data->mpduLinkQuality, data->signal_dbm, neighbor_info.neighbor->index, neighbor_info.neighbor->mac64);
         //Update Neighbor Broadcast and Unicast Parameters
         ws_neighbor_class_neighbor_unicast_time_info_update(neighbor_info.ws_neighbor, ws_utt, data->timestamp, (uint8_t *) data->SrcAddr);
         ws_neighbor_class_neighbor_unicast_schedule_set(neighbor_info.ws_neighbor, ws_us, &cur->ws_info->hopping_schdule);
@@ -1652,7 +1651,6 @@ static void ws_bootstrap_pan_config_solicit_analyse(struct protocol_interface_in
 
     llc_neighbour_req_t neighbor_info;
     if (ws_bootstrap_neighbor_info_request(cur, data->SrcAddr, &neighbor_info, false)) {
-        etx_lqi_dbm_update(cur->id, data->mpduLinkQuality, data->signal_dbm, neighbor_info.neighbor->index, neighbor_info.neighbor->mac64);
         ws_neighbor_class_neighbor_unicast_time_info_update(neighbor_info.ws_neighbor, ws_utt, data->timestamp, (uint8_t *) data->SrcAddr);
         ws_neighbor_class_neighbor_unicast_schedule_set(neighbor_info.ws_neighbor, ws_us, &cur->ws_info->hopping_schdule);
     }
@@ -1961,6 +1959,15 @@ static void ws_neighbor_entry_remove_notify(mac_neighbor_table_entry_t *entry_pt
     ws_bootstrap_neighbor_delete(cur, entry_ptr);
 }
 
+static uint32_t ws_probe_init_time_get(protocol_interface_info_entry_t *cur)
+{
+    if (cur->ws_info->cfg->gen.network_size <= NETWORK_SIZE_SMALL) {
+        return WS_SMALL_PROBE_INIT_BASE_SECONDS;
+    }
+
+    return WS_NORMAL_PROBE_INIT_BASE_SECONDS;
+}
+
 static bool ws_neighbor_entry_nud_notify(mac_neighbor_table_entry_t *entry_ptr, void *user_data)
 {
     uint32_t time_from_start = entry_ptr->link_lifetime - entry_ptr->lifetime;
@@ -2013,17 +2020,23 @@ static bool ws_neighbor_entry_nud_notify(mac_neighbor_table_entry_t *entry_ptr,
         nud_proces = activate_nud;
     } else if (etx_entry->etx_samples < WS_NEIGHBOR_ETX_SAMPLE_MAX) {
         //Take Random number for trig a prope.
+        //Small network
+        //ETX Sample 0: random 1-4
+        //ETX Sample 1: random 2-8
+        //ETX Sample 2: random 4-16
+        //Medium and large
         //ETX Sample 0: random 1-8
         //ETX Sample 1: random 2-16
         //ETX Sample 2: random 4-32
+
         ws_bootsrap_create_ll_address(ll_address, entry_ptr->mac64);
         if (!rpl_control_probe_parent_candidate(cur, ll_address)) {
             return false;
         }
 
-
-        uint32_t probe_period = WS_PROBE_INIT_BASE_SECONDS << etx_entry->etx_samples;
+        uint32_t probe_period = ws_probe_init_time_get(cur) << etx_entry->etx_samples;
         uint32_t time_block = 1 << etx_entry->etx_samples;
+
         if (time_from_start >= probe_period) {
             //tr_debug("Link Probe test %u Sample trig", etx_entry->etx_samples);
             activate_nud = true;
@@ -2086,6 +2099,11 @@ int ws_bootstrap_init(int8_t interface_id, net_6lowpan_mode_e bootstrap_mode)
         return -1;
     }
 
+    if (!etx_allow_drop_for_poor_measurements(WS_ETX_BAD_INIT_LINK_LEVEL, WS_ETX_MAX_BAD_LINK_DROP)) {
+        etx_storage_list_allocate(cur->id, 0);
+        return -1;
+    }
+
     etx_max_update_set(WS_ETX_MAX_UPDATE);
     etx_max_set(WS_ETX_MAX);
 
@@ -2655,8 +2673,6 @@ static bool ws_rpl_new_parent_callback(uint8_t *ll_parent_address, void *handle,
         ws_bootstrap_neighbor_set_stable(cur, entry->mac64);
         //Copy fhss temporary data
         *ws_neigh = entry->neigh_info_list;
-        //ETX Create here
-        etx_lqi_dbm_update(cur->id, entry->mpduLinkQuality, entry->signal_dbm, neigh_buffer.neighbor->index, neigh_buffer.neighbor->mac64);
         mac_neighbor_table_trusted_neighbor(mac_neighbor_info(cur), neigh_buffer.neighbor, true);
     }
     ws_llc_free_multicast_temp_entry(cur, entry);

source/6LoWPAN/ws/ws_common_defines.h

@@ -255,7 +255,8 @@ typedef struct ws_bs_ie {
 #define WS_NEIGHBOR_ETX_SAMPLE_MAX 3
 #define WS_NEIGHBOR_FIRST_ETX_SAMPLE_MIN_COUNT 3 //This can't be bigger than WS_NEIGHBOR_ETX_SAMPLE_MAX
 
-#define WS_PROBE_INIT_BASE_SECONDS 8
+#define WS_SMALL_PROBE_INIT_BASE_SECONDS 4
+#define WS_NORMAL_PROBE_INIT_BASE_SECONDS 8
 
 #define WS_NUD_RAND_PROBABILITY 1
 
@@ -270,6 +271,10 @@ typedef struct ws_bs_ie {
 
 #define WS_ETX_MIN_WAIT_TIME 60
 
+#define WS_ETX_BAD_INIT_LINK_LEVEL 3 //3 or higher attempt count will be dropped
+#define WS_ETX_MAX_BAD_LINK_DROP 2 //Drop 2 bad link from init 3
+
+
 #define WS_RPL_PARENT_CANDIDATE_MAX 5
 #define WS_RPL_SELECTED_PARENT_MAX 2
 

source/6LoWPAN/ws/ws_llc_data_service.c

@@ -729,8 +729,6 @@ static void ws_llc_data_indication_cb(const mac_api_t *api, const mcps_data_ind_
     ws_neighbor_class_rsl_in_calculate(neighbor_info.ws_neighbor, data->signal_dbm);
 
     if (neighbor_info.neighbor) {
-        //Refresh ETX dbm
-        etx_lqi_dbm_update(interface->id, data->mpduLinkQuality, data->signal_dbm, neighbor_info.neighbor->index, neighbor_info.neighbor->mac64);
         if (data->Key.SecurityLevel) {
             //SET trusted state
             mac_neighbor_table_trusted_neighbor(mac_neighbor_info(interface), neighbor_info.neighbor, true);

source/Service_Libs/etx/etx.c

@@ -74,6 +74,8 @@ typedef struct {
     uint8_t etx_min_sampling_time;
     uint8_t ext_storage_list_size;
     uint8_t min_attempts_count;
+    uint8_t drop_bad_max;
+    uint8_t bad_link_level;
     bool cache_sample_requested;
     int8_t interface_id;
 } ext_info_t;
@@ -87,6 +89,8 @@ static ext_info_t etx_info = {
     .etx_cache_storage_list = NULL,
     .ext_storage_list_size = 0,
     .min_attempts_count = 0,
+    .drop_bad_max = 0,
+    .bad_link_level = 0,
     .max_etx_update = 0,
     .max_etx = 0xffff,
     .init_etx_sample_count = 1,
@@ -133,6 +137,8 @@ static void etx_calculation(etx_storage_t *entry, uint16_t attempts, uint8_t ack
     entry->tmp_etx = false;
 
     entry->etx = etx;
+    //Clear Drop count
+    entry->drop_bad_count = 0;
 
     if (entry->etx_samples >= etx_info.init_etx_sample_count) {
         etx_cache_entry_init(etx_neigh_info->attribute_index);
@@ -149,6 +155,7 @@ static void etx_cache_entry_init(uint8_t attribute_index)
 
     etx_sample_storage_t *storage = etx_info.etx_cache_storage_list + attribute_index;
     storage->attempts_count = 0;
+    storage->transition_count = 0;
     storage->etx_timer = etx_info.etx_min_sampling_time;
     storage->received_acks = 0;
 }
@@ -162,21 +169,22 @@ static bool etx_update_possible(etx_sample_storage_t *storage, etx_storage_t *en
             storage->etx_timer -= time_update;
         }
     }
+    if (entry->etx_samples == etx_info.init_etx_sample_count && time_update == 0) {
+        return true;
+    }
 
     if (entry->etx_samples > etx_info.init_etx_sample_count) {
         //Slower ETX update phase
-        if (storage->attempts_count >= etx_info.min_attempts_count) {
-
-            if (storage->etx_timer == 0 || storage->attempts_count == 0xffff || storage->received_acks == 0xff) {
+        if (storage->etx_timer == 0 || storage->attempts_count == 0xffff || storage->received_acks == 0xff) {
+            //When time is going zero or too much sample data
+            if (storage->transition_count >= etx_info.min_attempts_count) {
                 //Got least min sample in requested time or max possible sample
                 return true;
+            } else if (storage->transition_count != storage->received_acks) {
+                //Missing ack now ETX can be accelerated
+                return true;
             }
         }
-        return false;
-    }
-
-    if (time_update == 0) {
-        return true;
     }
 
     return false;
@@ -188,6 +196,7 @@ static etx_sample_storage_t *etx_cache_sample_update(uint8_t attribute_index, ui
 {
     etx_sample_storage_t *storage = etx_info.etx_cache_storage_list + attribute_index;
     storage->attempts_count += attempts;
+    storage->transition_count++;
     if (ack_rx) {
         storage->received_acks++;
     }
@@ -196,6 +205,26 @@ static etx_sample_storage_t *etx_cache_sample_update(uint8_t attribute_index, ui
 }
 
 
+static bool etx_drop_bad_sample(etx_storage_t *entry, uint8_t attempts, bool success)
+{
+    if (etx_info.bad_link_level == 0 || !success) {
+        //Not enabled or Failure
+        return false;
+    }
+
+    if (attempts < etx_info.bad_link_level) {
+        //under configured value is accepted
+        return false;
+    }
+
+    if (entry->drop_bad_count < etx_info.drop_bad_max) {
+        //Accepted only configured max value 1-2
+        entry->drop_bad_count++;
+        return true;
+    }
+
+    return false;
+}
 
 /**
  * \brief A function to update ETX value based on transmission attempts
@@ -222,6 +251,11 @@ void etx_transm_attempts_update(int8_t interface_id, uint8_t attempts, bool succ
     etx_neigh_info.mac64 = mac64_addr_ptr;
 
     if (entry->etx_samples < 7) {
+
+        if (etx_drop_bad_sample(entry, attempts, success)) {
+            tr_debug("Drop bad etx init %u", attempts);
+            return;
+        }
         entry->etx_samples++;
     }
 
@@ -409,9 +443,8 @@ uint16_t etx_local_etx_read(int8_t interface_id, uint8_t attribute_index)
     }
 
     if (etx_info.cache_sample_requested && entry->etx_samples < etx_info.init_etx_sample_count) {
-        if (!entry->etx_samples) {
-            return 0;
-        }
+        //Not ready yet
+        return 0;
     }
 
     return etx_current_calc(entry->etx, entry->accumulated_failures) >> 4;
@@ -668,6 +701,36 @@ bool etx_cached_etx_parameter_set(uint8_t min_wait_time, uint8_t etx_min_attempt
     return true;
 }
 
+bool etx_allow_drop_for_poor_measurements(uint8_t bad_link_level, uint8_t max_allowed_drops)
+{
+    //No ini ETX allocation done yet
+    if (etx_info.ext_storage_list_size == 0) {
+        return false;
+    }
+
+    if (bad_link_level == 0) {
+        //Disable feature
+        etx_info.bad_link_level = 0;
+        etx_info.drop_bad_max = 0;
+        return true;
+    }
+
+    if (bad_link_level < 2) {
+        // 2 attepts is min value
+        return false;
+    }
+
+    if (max_allowed_drops == 0 || max_allowed_drops > 3) {
+        //Accepted values is 1-3
+        return false;
+    }
+
+
+    etx_info.bad_link_level = bad_link_level;
+    etx_info.drop_bad_max = max_allowed_drops;
+    return true;
+}
+
 void etx_max_update_set(uint16_t etx_max_update)
 {
     if (etx_max_update) {

source/Service_Libs/etx/etx.h

@@ -58,12 +58,14 @@ typedef struct etx_storage_s {
     unsigned        tmp_etx: 1;
     unsigned        linkIdr: 4;
     unsigned        etx_samples: 3;
+    unsigned        drop_bad_count: 2;
 } etx_storage_t;
 
 typedef struct etx_sample_storage_s {
     uint16_t           attempts_count;         /*!< TX attempt count */
     uint8_t            etx_timer;              /*!< Count down from configured value 0 means that ETX Update is possible done again*/
     uint8_t            received_acks;          /*!< Received ACK's */
+    uint8_t            transition_count;
 } etx_sample_storage_t;
 
 /**
@@ -279,6 +281,15 @@ bool etx_cached_etx_parameter_set(uint8_t min_wait_time, uint8_t etx_min_attempt
  */
 void etx_max_update_set(uint16_t etx_max_update);
 
+/**
+ * \brief A function for configure limit for detect bad init ETX sample
+ *
+ * \param bad_link_level 0 No limit and >=2 Level
+ * \param max_allowed_drops How many init probe is accepted to drop 1-2 are possible values
+ *
+ */
+bool etx_allow_drop_for_poor_measurements(uint8_t bad_link_level, uint8_t max_allowed_drops);
+
 /**
  * \brief A function for set Maxium ETX value
  *