FHSS: Created statistics for WS

nanostack/fhss_config.h

@@ -183,6 +183,12 @@ typedef struct fhss_statistics {
 
  /** FHSS synchronization lost counter. */
  uint32_t fhss_synch_lost;
+
+ /** FHSS TX to unknown neighbour counter. */
+ uint32_t fhss_unknown_neighbor;
+
+ /** FHSS channel retry counter. */
+ uint32_t fhss_channel_retry;
 } fhss_statistics_t;
 
 /**

nanostack/net_fhss.h

@@ -76,6 +76,14 @@ extern int ns_fhss_ws_configuration_set(const fhss_api_t *fhss_api, const fhss_w
  */
 extern int ns_fhss_delete(fhss_api_t *fhss_api);
 
+/**
+ * @brief Starts collecting FHSS statistics.
+ * @param fhss_api FHSS instance.
+ * @param fhss_statistics Pointer to stored statistics.
+ * @return 0 on success, -1 on fail.
+ */
+extern int ns_fhss_statistics_start(const fhss_api_t *fhss_api, fhss_statistics_t *fhss_statistics);
+
 
 #ifdef __cplusplus
 }

source/MAC/IEEE802_15_4/mac_pd_sap.c

@@ -487,7 +487,8 @@ static int8_t mac_data_interface_tx_done_cb(protocol_interface_rf_mac_setup_s *r
  return 0;
  } else {
  // Do not update CCA count when Ack is received, it was already updated with PHY_LINK_TX_SUCCESS event
- if ((status != PHY_LINK_TX_DONE) && (status != PHY_LINK_TX_DONE_PENDING)) {
+ // Do not update CCA count when CCA_OK is received, PHY_LINK_TX_SUCCESS will update it
+ if ((status != PHY_LINK_TX_DONE) && (status != PHY_LINK_TX_DONE_PENDING) && (status != PHY_LINK_CCA_OK)) {
  /* For PHY_LINK_TX_SUCCESS and PHY_LINK_CCA_FAIL cca_retry must always be > 0.
  * PHY_LINK_TX_FAIL either happened during transmission or when waiting Ack -> we must use the CCA count given by PHY.
  */

source/Service_Libs/fhss/fhss.c

@@ -71,7 +71,7 @@ fhss_structure_t *fhss_enable(fhss_api_t *fhss_api, const fhss_configuration_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->fhss_stats_ptr = fhss_statistics;
  fhss_struct->number_of_channels = channel_count;
 
  // set a invalid id to tasklet_id, so we know that one is not started yet

source/Service_Libs/fhss/fhss.h

@@ -97,7 +97,6 @@ struct fhss_bs {
  uint16_t channel_list_counter;
  uint16_t synch_panid;
  uint32_t synch_interval;
- struct fhss_statistics *fhss_stats_ptr;
  struct fhss_beacon_info *fhss_beacon_info_store;
  struct fhss_configuration fhss_configuration;
  struct fhss_synch_configuration synch_configuration;

source/Service_Libs/fhss/fhss_common.h

@@ -48,6 +48,7 @@ struct fhss_structure {
  struct fhss_ws *ws;
  struct fhss_timer platform_functions;
  struct fhss_callback callbacks;
+ struct fhss_statistics *fhss_stats_ptr;
  fhss_failed_tx_list_t fhss_failed_tx_list;
  uint8_t synch_parent[8];
 };

source/Service_Libs/fhss/fhss_configuration_interface.c

@@ -24,6 +24,7 @@
 #include "Service_Libs/fhss/fhss.h"
 #include "Service_Libs/fhss/fhss_common.h"
 #include "Service_Libs/fhss/fhss_ws.h"
+#include "Service_Libs/fhss/fhss_statistics.h"
 #include "ns_trace.h"
 
 #define TRACE_GROUP "fhss"
@@ -138,3 +139,12 @@ int ns_fhss_ws_set_hop_count(const fhss_api_t *fhss_api, const uint8_t hop_count
  }
  return fhss_ws_set_hop_count(fhss_structure, hop_count);
 }
+
+int ns_fhss_statistics_start(const fhss_api_t *fhss_api, fhss_statistics_t *fhss_statistics)
+{
+ fhss_structure_t *fhss_structure = fhss_get_object_with_api(fhss_api);
+ if (!fhss_structure) {
+ return -1;
+ }
+ return fhss_statistics_start(fhss_structure, fhss_statistics);
+}

source/Service_Libs/fhss/fhss_statistics.c

@@ -24,23 +24,35 @@
 
 void fhss_stats_update(fhss_structure_t *fhss_structure, fhss_stats_type_t type, uint32_t update_val)
 {
- if (fhss_structure->bs->fhss_stats_ptr) {
+ if (fhss_structure->fhss_stats_ptr) {
  switch (type) {
  case STATS_FHSS_DRIFT_COMP:
- fhss_structure->bs->fhss_stats_ptr->fhss_drift_compensation = update_val;
+ fhss_structure->fhss_stats_ptr->fhss_drift_compensation = update_val;
  break;
  case STATS_FHSS_HOP_COUNT:
- fhss_structure->bs->fhss_stats_ptr->fhss_hop_count = update_val;
+ fhss_structure->fhss_stats_ptr->fhss_hop_count = update_val;
  break;
  case STATS_FHSS_SYNCH_INTERVAL:
- fhss_structure->bs->fhss_stats_ptr->fhss_synch_interval = update_val;
+ fhss_structure->fhss_stats_ptr->fhss_synch_interval = update_val;
  break;
  case STATS_FHSS_AVG_SYNCH_FIX:
- fhss_structure->bs->fhss_stats_ptr->fhss_prev_avg_synch_fix = update_val;
+ fhss_structure->fhss_stats_ptr->fhss_prev_avg_synch_fix = update_val;
  break;
  case STATS_FHSS_SYNCH_LOST:
- fhss_structure->bs->fhss_stats_ptr->fhss_synch_lost += update_val;
+ fhss_structure->fhss_stats_ptr->fhss_synch_lost += update_val;
+ break;
+ case STATS_FHSS_UNKNOWN_NEIGHBOR:
+ fhss_structure->fhss_stats_ptr->fhss_unknown_neighbor += update_val;
+ break;
+ case STATS_FHSS_CHANNEL_RETRY:
+ fhss_structure->fhss_stats_ptr->fhss_channel_retry += update_val;
  break;
  }
  }
 }
+
+int fhss_statistics_start(fhss_structure_t *fhss_structure, fhss_statistics_t *fhss_statistics)
+{
+ fhss_structure->fhss_stats_ptr = fhss_statistics;
+ return 0;
+}

source/Service_Libs/fhss/fhss_statistics.h

@@ -23,8 +23,11 @@ typedef enum {
  STATS_FHSS_SYNCH_INTERVAL,
  STATS_FHSS_AVG_SYNCH_FIX,
  STATS_FHSS_SYNCH_LOST,
+ STATS_FHSS_UNKNOWN_NEIGHBOR,
+ STATS_FHSS_CHANNEL_RETRY
 } fhss_stats_type_t;
 
 void fhss_stats_update(fhss_structure_t *fhss_structure, fhss_stats_type_t type, uint32_t update_val);
+int fhss_statistics_start(fhss_structure_t *fhss_structure, fhss_statistics_t *fhss_statistics);
 
 #endif /* FHSS_STATISTICS_H_ */

source/Service_Libs/fhss/fhss_ws.c

@@ -20,6 +20,7 @@
 #include "fhss_config.h"
 #include "fhss.h"
 #include "fhss_common.h"
+#include "fhss_statistics.h"
 #include "channel_list.h"
 #include "channel_functions.h"
 #include "fhss_ws.h"
@@ -143,7 +144,7 @@ fhss_structure_t *fhss_ws_enable(fhss_api_t *fhss_api, const fhss_ws_configurati
  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_ws_set_hop_count(fhss_struct, 0xff);
  fhss_struct->rx_channel = fhss_configuration->unicast_fixed_channel;
  fhss_struct->ws->min_synch_interval = DEFAULT_MIN_SYNCH_INTERVAL;
  fhss_set_txrx_slot_length(fhss_struct);
@@ -472,6 +473,7 @@ static int fhss_ws_tx_handle_callback(const fhss_api_t *api, bool is_broadcast_a
  if (fhss_structure->fhss_state == FHSS_SYNCHRONIZED) {
  fhss_ws_neighbor_timing_info_t *neighbor_timing_info = fhss_structure->ws->get_neighbor_info(api, destination_address);
  if (!neighbor_timing_info) {
+ fhss_stats_update(fhss_structure, STATS_FHSS_UNKNOWN_NEIGHBOR, 1);
  return -2;
  }
  // TODO: WS bootstrap has to store neighbors number of channels
@@ -687,6 +689,7 @@ static bool fhss_ws_data_tx_fail_callback(const fhss_api_t *api, uint8_t handle,
  // Create new failure handle and return true to retransmit
  fhss_failed_handle_add(fhss_structure, handle, fhss_structure->rx_channel);
  }
+ fhss_stats_update(fhss_structure, STATS_FHSS_CHANNEL_RETRY, 1);
  return true;
 }
 
@@ -858,9 +861,11 @@ int fhss_ws_set_parent(fhss_structure_t *fhss_structure, const uint8_t eui64[8],
  drift_per_ms_tmp = -MAX_DRIFT_COMPENSATION_STEP;
  }
  fhss_structure->ws->drift_per_millisecond_ns += drift_per_ms_tmp;
+ fhss_stats_update(fhss_structure, STATS_FHSS_DRIFT_COMP, fhss_structure->ws->drift_per_millisecond_ns * bc_timing_info->broadcast_dwell_interval);
  }
  tr_debug("synch to parent: %s, drift: %"PRIi32"ms in %"PRIu32" seconds, compensation: %"PRIi32"ns per ms", trace_array(eui64, 8), true_bc_interval_offset - own_bc_interval_offset + ((int32_t)(fhss_structure->ws->bc_slot - own_bc_slot) * bc_timing_info->broadcast_interval), US_TO_S(time_since_last_synch_us), fhss_structure->ws->drift_per_millisecond_ns);
  }
+ fhss_stats_update(fhss_structure, STATS_FHSS_SYNCH_INTERVAL, US_TO_S(time_since_last_synch_us));
  return 0;
 }
 
@@ -915,6 +920,8 @@ int fhss_ws_configuration_set(fhss_structure_t *fhss_structure, const fhss_ws_co
 int fhss_ws_set_hop_count(fhss_structure_t *fhss_structure, const uint8_t hop_count)
 {
  fhss_structure->own_hop = hop_count;
+ fhss_stats_update(fhss_structure, STATS_FHSS_HOP_COUNT, fhss_structure->own_hop);
  return 0;
 }
+
 #endif // HAVE_WS

test/nanostack/unittest/service_libs/fhss_config/Makefile

@@ -16,6 +16,7 @@ TEST_SRC_FILES = \
  ../../stub/fhss_stub.c \
  ../../stub/fhss_common_stub.c \
  ../../stub/fhss_ws_stub.c \
+ ../../stub/fhss_statistics_stub.c \
 
 include ../../MakefileWorker.mk
 

test/nanostack/unittest/service_libs/fhss_statistics/test_fhss_statistics.c

@@ -24,43 +24,41 @@
 #include "Service_Libs/fhss/fhss_statistics.h"
 
 static fhss_structure_t fhss_struct;
-static fhss_bs_t bs;
 static fhss_statistics_t fhss_stats_ptr;
 
 static init_fhss_struct(void)
 {
  memset(&fhss_stats_ptr, 0, sizeof(fhss_statistics_t));
- bs.fhss_stats_ptr = &fhss_stats_ptr;
- fhss_struct.bs = &bs;
+ fhss_struct.fhss_stats_ptr = &fhss_stats_ptr;
 }
 
 bool test_fhss_stats_update()
 {
  init_fhss_struct();
  // Test drift compensation
  fhss_stats_update(&fhss_struct, STATS_FHSS_DRIFT_COMP, 10);
- if (fhss_struct.bs->fhss_stats_ptr->fhss_drift_compensation != 10) {
+ if (fhss_struct.fhss_stats_ptr->fhss_drift_compensation != 10) {
  return false;
  }
  // Test hop count
  fhss_stats_update(&fhss_struct, STATS_FHSS_HOP_COUNT, 1);
- if (fhss_struct.bs->fhss_stats_ptr->fhss_hop_count != 1) {
+ if (fhss_struct.fhss_stats_ptr->fhss_hop_count != 1) {
  return false;
  }
  // Test synch interval
  fhss_stats_update(&fhss_struct, STATS_FHSS_SYNCH_INTERVAL, 960);
- if (fhss_struct.bs->fhss_stats_ptr->fhss_synch_interval != 960) {
+ if (fhss_struct.fhss_stats_ptr->fhss_synch_interval != 960) {
  return false;
  }
  // Test average synch fix
  fhss_stats_update(&fhss_struct, STATS_FHSS_AVG_SYNCH_FIX, 1000);
- if (fhss_struct.bs->fhss_stats_ptr->fhss_prev_avg_synch_fix != 1000) {
+ if (fhss_struct.fhss_stats_ptr->fhss_prev_avg_synch_fix != 1000) {
  return false;
  }
  // Test synch lost count
- fhss_struct.bs->fhss_stats_ptr->fhss_synch_lost = 1;
+ fhss_struct.fhss_stats_ptr->fhss_synch_lost = 1;
  fhss_stats_update(&fhss_struct, STATS_FHSS_SYNCH_LOST, 1);
- if (fhss_struct.bs->fhss_stats_ptr->fhss_synch_lost != 2) {
+ if (fhss_struct.fhss_stats_ptr->fhss_synch_lost != 2) {
  return false;
  }
  return true;

test/nanostack/unittest/service_libs/fhss_ws/Makefile

@@ -23,6 +23,7 @@ TEST_SRC_FILES = \
  ../../stub/fhss_common_stub.c \
  ../../stub/fhss_callbacks_stub.c \
  ../../stub/fhss_platform_stub.c \
+ ../../stub/fhss_statistics_stub.c \
  ../../stub/platform_stub.c \
 
 include ../../MakefileWorker.mk

test/nanostack/unittest/stub/fhss_statistics_stub.c

@@ -27,3 +27,8 @@ void fhss_stats_update(fhss_structure_t *fhss_structure, fhss_stats_type_t type,
 {
 
 }
+
+int fhss_statistics_start(fhss_structure_t *fhss_structure, fhss_statistics_t *fhss_statistics)
+{
+ return 0;
+}