From 07d408943ed12d29344a1b439125540c7389158c Mon Sep 17 00:00:00 2001 From: Jarkko Paso Date: Thu, 15 Feb 2018 13:30:04 +0200 Subject: [PATCH] FHSS: Cleaning. Static functions. Separated tx fail and retry callbacks --- source/MAC/IEEE802_15_4/mac_pd_sap.c | 2 +- source/Service_Libs/fhss/fhss.c | 147 +++++++++++- source/Service_Libs/fhss/fhss.h | 14 -- source/Service_Libs/fhss/fhss_beacon.h | 18 -- .../Service_Libs/fhss/fhss_beacon_tasklet.c | 18 -- source/Service_Libs/fhss/fhss_common.h | 8 +- source/Service_Libs/fhss/fhss_mac_interface.c | 109 --------- source/Service_Libs/fhss/fhss_mac_interface.h | 3 - source/Service_Libs/fhss/fhss_ws.c | 24 +- .../unittest/service_libs/fhss/fhsstest.cpp | 15 -- .../unittest/service_libs/fhss/test_fhss.c | 223 +----------------- .../unittest/service_libs/fhss/test_fhss.h | 6 - .../fhssbeacontasklettest.cpp | 5 - .../test_fhss_beacon_tasklet.c | 13 - .../test_fhss_beacon_tasklet.h | 1 - .../fhss_mac_interface/fhssmaciftest.cpp | 15 -- .../test_fhss_mac_interface.c | 104 +------- .../test_fhss_mac_interface.h | 8 - 18 files changed, 168 insertions(+), 565 deletions(-) diff --git a/source/MAC/IEEE802_15_4/mac_pd_sap.c b/source/MAC/IEEE802_15_4/mac_pd_sap.c index b81c92c66a6..bde1b69cbdd 100644 --- a/source/MAC/IEEE802_15_4/mac_pd_sap.c +++ b/source/MAC/IEEE802_15_4/mac_pd_sap.c @@ -265,7 +265,7 @@ static void mac_sap_cca_fail_cb(protocol_interface_rf_mac_setup_s *rf_ptr) { static uint16_t mac_get_retry_period(protocol_interface_rf_mac_setup_s *rf_ptr) { - if (rf_ptr->fhss_api) { + if (rf_ptr->fhss_api && rf_ptr->fhss_api->get_retry_period) { return rf_ptr->fhss_api->get_retry_period(rf_ptr->fhss_api, rf_ptr->active_pd_data_request->DstAddr, rf_ptr->dev_driver->phy_driver->phy_MTU); } uint8_t backoff_length = mac_csma_random_backoff_get(rf_ptr); diff --git a/source/Service_Libs/fhss/fhss.c b/source/Service_Libs/fhss/fhss.c index 4626d3f24fc..5033660456a 100644 --- a/source/Service_Libs/fhss/fhss.c +++ b/source/Service_Libs/fhss/fhss.c @@ -40,6 +40,9 @@ static void fhss_destroy_scramble_table(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); static bool fhss_is_there_common_divisor(uint16_t i, uint8_t j); +static fhss_failed_tx_t *fhss_failed_handle_find(fhss_structure_t *fhss_structure, uint8_t handle); +static void fhss_failed_list_free(fhss_structure_t *fhss_structure); +static void fhss_beacon_received(fhss_structure_t *fhss_structure, const uint8_t *synch_info, const uint32_t elapsed_time); fhss_structure_t *fhss_enable(fhss_api_t *fhss_api, const fhss_configuration_t *fhss_configuration, const fhss_timer_t *fhss_timer, fhss_statistics_t *fhss_statistics) { @@ -195,7 +198,7 @@ static bool fhss_check_tx_allowed(fhss_structure_t *fhss_structure, bool is_bc, return true; } -int fhss_reset_synch_monitor(fhss_synch_monitor_s *synch_monitor) +static int fhss_reset_synch_monitor(fhss_synch_monitor_s *synch_monitor) { if (synch_monitor) { synch_monitor->avg_synch_fix = 0; @@ -326,7 +329,7 @@ static int fhss_update_synch_monitor(fhss_structure_t *fhss_structure, const fhs return retval; } -int fhss_sync_with_beacon(fhss_structure_t *fhss_structure, +static int fhss_sync_with_beacon(fhss_structure_t *fhss_structure, const fhss_synchronization_beacon_payload_s *payload) { int ret_val = -1; @@ -654,7 +657,7 @@ static int fhss_reset(fhss_structure_t *fhss_structure) return 0; } -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) +static 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) { if (!fhss_structure || !source_address || !synch_info) { return -1; @@ -687,7 +690,7 @@ void fhss_update_beacon_info_lifetimes(fhss_structure_t *fhss_structure, uint32_ } } -fhss_failed_tx_t *fhss_failed_handle_find(fhss_structure_t *fhss_structure, uint8_t handle) +static fhss_failed_tx_t *fhss_failed_handle_find(fhss_structure_t *fhss_structure, uint8_t handle) { ns_list_foreach(fhss_failed_tx_t, cur, &fhss_structure->fhss_failed_tx_list) { if (cur->handle == handle) { @@ -697,7 +700,7 @@ fhss_failed_tx_t *fhss_failed_handle_find(fhss_structure_t *fhss_structure, uint return NULL; } -int fhss_failed_handle_add(fhss_structure_t *fhss_structure, uint8_t handle) +static int fhss_failed_handle_add(fhss_structure_t *fhss_structure, uint8_t handle) { fhss_failed_tx_t *failed_tx = ns_dyn_mem_alloc(sizeof(fhss_failed_tx_t)); if (!failed_tx) { @@ -710,7 +713,7 @@ int fhss_failed_handle_add(fhss_structure_t *fhss_structure, uint8_t handle) return 0; } -int fhss_failed_handle_remove(fhss_structure_t *fhss_structure, uint8_t handle) +static int fhss_failed_handle_remove(fhss_structure_t *fhss_structure, uint8_t handle) { fhss_failed_tx_t *failed_tx = fhss_failed_handle_find(fhss_structure, handle); if (!failed_tx) { @@ -721,7 +724,7 @@ int fhss_failed_handle_remove(fhss_structure_t *fhss_structure, uint8_t handle) return 0; } -void fhss_failed_list_free(fhss_structure_t *fhss_structure) +static void fhss_failed_list_free(fhss_structure_t *fhss_structure) { for (uint16_t i = 0; i<256; i++) { fhss_failed_handle_remove(fhss_structure, i); @@ -797,6 +800,22 @@ static void fhss_destroy_scramble_table(fhss_structure_t *fhss_structure) } } +static void fhss_beacon_received(fhss_structure_t *fhss_structure, const uint8_t *synch_info, const uint32_t elapsed_time) +{ + + if (fhss_structure) { + + if (synch_info) { + fhss_synchronization_beacon_payload_s temp_payload; + temp_payload.processing_delay = fhss_structure->fhss_conf.fhss_configuration.fhss_tuning_parameters.rx_processing_delay; + fhss_beacon_decode(&temp_payload, synch_info, elapsed_time, fhss_structure->number_of_channels); + + // use the received information + fhss_sync_with_beacon(fhss_structure, &temp_payload); + } + } +} + static uint32_t fhss_get_sf_timeout_callback(fhss_structure_t *fhss_structure) { uint32_t compensation = 0; @@ -955,6 +974,114 @@ static void fhss_data_tx_done_callback(const fhss_api_t *api, bool waiting_ack, } } +static bool fhss_data_tx_fail_callback(const fhss_api_t *api, uint8_t handle, int frame_type) +{ + fhss_structure_t *fhss_structure = fhss_get_object_with_api(api); + if (!fhss_structure) { + return false; + } + // Only use channel retries when device is synchronized + if (fhss_structure->fhss_state == FHSS_UNSYNCHRONIZED) { + return false; + } + // Channel retries are disabled -> return + if (fhss_structure->fhss_conf.fhss_configuration.fhss_number_of_channel_retries == 0) { + return false; + } + // Use channel retries only for data frames + if (FHSS_DATA_FRAME != frame_type) { + return false; + } + + fhss_failed_tx_t *fhss_failed_tx = fhss_failed_handle_find(fhss_structure, handle); + if (fhss_failed_tx) { + fhss_failed_tx->retries_done++; + if (fhss_failed_tx->retries_done >= fhss_structure->fhss_conf.fhss_configuration.fhss_number_of_channel_retries) { + // No more retries. Return false to stop retransmitting. + fhss_failed_handle_remove(fhss_structure, handle); + return false; + } + } else { + // Create new failure handle and return true to retransmit + fhss_failed_handle_add(fhss_structure, handle); + } + return true; +} + +static void fhss_receive_frame_callback(const fhss_api_t *api, uint16_t pan_id, uint8_t *source_address, uint32_t timestamp, uint8_t *synch_info, int frame_type) +{ + fhss_structure_t *fhss_structure = fhss_get_object_with_api(api); + if (!fhss_structure) { + return; + } + if (FHSS_SYNCH_FRAME == frame_type) { + if ((fhss_structure->fhss_state == FHSS_UNSYNCHRONIZED) || fhss_structure->synch_panid != pan_id) { + fhss_add_beacon_info(fhss_structure, pan_id, source_address, timestamp, synch_info); + } else { + if (!fhss_compare_with_synch_parent_address(fhss_structure, source_address)) { + // Synch parent address needs to be updated in case parent has changed + fhss_update_synch_parent_address(fhss_structure); + platform_enter_critical(); + // Calculate time since the Beacon was received + uint32_t elapsed_time = api->read_timestamp(api) - timestamp; + // Synchronize to given PAN + fhss_beacon_received(fhss_structure, synch_info, elapsed_time); + platform_exit_critical(); + } + } + } else if (FHSS_SYNCH_REQUEST_FRAME == frame_type) { + // If current channel is broadcast, we don't need to send another synch info on next broadcast channel. + // Only send number of MAX_SYNCH_INFOS_PER_CHANNEL_LIST synch infos per one channel list cycle + if ((fhss_structure->fhss_state == FHSS_SYNCHRONIZED) && (fhss_is_current_channel_broadcast(fhss_structure) == false) + && (fhss_structure->synch_infos_sent_counter < MAX_SYNCH_INFOS_PER_CHANNEL_LIST)) { + fhss_structure->send_synch_info_on_next_broadcast_channel = true; + } + } +} + +static uint16_t fhss_get_retry_period_callback(const fhss_api_t *api, uint8_t *destination_address, uint16_t phy_mtu) +{ + uint16_t retry_period = 0; + uint16_t random_number = randLIB_get_16bit(); + uint16_t rnd_mask; + + /* Generate retry back-off period. FHSS is using the known synchronization parent info to delay retransmissions upstream. + * + */ + if (phy_mtu < 128) { + // Max. random when PHY MTU below 128 is 6.4ms + rnd_mask = 0x7f; + } else if (phy_mtu < 256) { + // Max. random when PHY MTU below 256 is 12.8ms + rnd_mask = 0xff; + } else { + // Max. random when PHY MTU above 255 is 25.6ms + rnd_mask = 0x1ff; + } + + fhss_structure_t *fhss_structure = fhss_get_object_with_api(api); + if (fhss_structure) { + uint32_t datarate = fhss_structure->datarate; + uint16_t max_tx_length; + + if (datarate && phy_mtu) { + if (fhss_compare_with_synch_parent_address(fhss_structure, destination_address) == 0) { + // E.g. (1000000 / (250000bit/s / 8 bits)) * 255 bytes = 8160us + max_tx_length = ((1000000 / (datarate / 8)) * phy_mtu); + /* Retrying upstream: delay the transmission until assumed hidden node has retried downstream: + * Static period: max random + max tx length + * 50 comes from MAC timer resolution (50us) + */ + retry_period = (rnd_mask + (max_tx_length / 50)); + } + } + } + + // Add 1 to not to ever return zero value. + retry_period += ((random_number & rnd_mask) + 1); + return retry_period; +} + int fhss_set_callbacks(fhss_structure_t *fhss_structure) { // Set external API @@ -962,12 +1089,12 @@ int fhss_set_callbacks(fhss_structure_t *fhss_structure) fhss_structure->fhss_api->use_broadcast_queue = &fhss_use_broadcast_queue_cb; fhss_structure->fhss_api->tx_handle = &fhss_tx_handle_callback; fhss_structure->fhss_api->check_tx_conditions = &fhss_check_tx_conditions_callback; - fhss_structure->fhss_api->receive_frame = &fhss_receive_frame_cb; + fhss_structure->fhss_api->receive_frame = &fhss_receive_frame_callback; fhss_structure->fhss_api->data_tx_done = &fhss_data_tx_done_callback; - fhss_structure->fhss_api->data_tx_fail = &fhss_data_tx_fail_cb; + fhss_structure->fhss_api->data_tx_fail = &fhss_data_tx_fail_callback; fhss_structure->fhss_api->synch_state_set = &fhss_handle_state_set; fhss_structure->fhss_api->read_timestamp = &fhss_read_timestamp_cb; - fhss_structure->fhss_api->get_retry_period = &fhss_get_retry_period_cb; + fhss_structure->fhss_api->get_retry_period = &fhss_get_retry_period_callback; fhss_structure->fhss_api->write_synch_info = &fhss_write_synch_info_callback; fhss_structure->fhss_api->init_callbacks = &fhss_init_callbacks_cb; // Set internal API diff --git a/source/Service_Libs/fhss/fhss.h b/source/Service_Libs/fhss/fhss.h index 93df31f0337..d72f2c7a7c1 100644 --- a/source/Service_Libs/fhss/fhss.h +++ b/source/Service_Libs/fhss/fhss.h @@ -59,22 +59,8 @@ struct fhss_failed_tx fhss_structure_t *fhss_enable(fhss_api_t *fhss_api, const fhss_configuration_t *fhss_configuration, const fhss_timer_t *fhss_timer, fhss_statistics_t *fhss_statistics); bool fhss_is_synch_root(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); -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); -void fhss_failed_list_free(fhss_structure_t *fhss_structure); -int fhss_reset_synch_monitor(fhss_synch_monitor_s *synch_monitor); int fhss_set_callbacks(fhss_structure_t *fhss_structure); -/** - * Calculate time in microseconds to start of next superframe. - * - * @param fhss_struct FHSS state - * @return microseconds left to start of next superframe - */ -uint32_t fhss_get_remaining_time_to_next_superframe(const fhss_structure_t *fhss_struct); - #endif /* FHSS_H_ */ diff --git a/source/Service_Libs/fhss/fhss_beacon.h b/source/Service_Libs/fhss/fhss_beacon.h index 7684b1c168a..2513499942d 100644 --- a/source/Service_Libs/fhss/fhss_beacon.h +++ b/source/Service_Libs/fhss/fhss_beacon.h @@ -149,24 +149,6 @@ void fhss_beacon_decode_raw(fhss_synchronization_beacon_payload_s* dest, const u int fhss_beacon_update_payload(fhss_structure_t *fhss_structure, fhss_synchronization_beacon_payload_s *payload); -void fhss_beacon_received(fhss_structure_t *fhss_structure, const uint8_t *synch_info, const uint32_t elapsed_time); - -/** - * This function is called whenever a node receives a beacon in the "proper state". - * The implmentation of it stores the data received and eventually synchronizes - * itself. - * - * Note: this is in completely illogical header file, but we have a - * circular dependency with net_fhss.h and protocol.h. - * - * @param cur the network interface which received beacon - * @param payload decoded beacon payload information - * - * @return 0 on success - */ -int fhss_sync_with_beacon(fhss_structure_t *fhss_structure, - const fhss_synchronization_beacon_payload_s *payload); - uint8_t fhss_calculate_uc_index(uint8_t channel_index, uint16_t number_of_channels, uint8_t number_of_broadcast_channels); int8_t fhss_beacon_create_tasklet(fhss_structure_t *fhss_structure); diff --git a/source/Service_Libs/fhss/fhss_beacon_tasklet.c b/source/Service_Libs/fhss/fhss_beacon_tasklet.c index 8a0914929ae..76011af7f5a 100644 --- a/source/Service_Libs/fhss/fhss_beacon_tasklet.c +++ b/source/Service_Libs/fhss/fhss_beacon_tasklet.c @@ -136,21 +136,3 @@ void fhss_beacon_build(fhss_structure_t *fhss_structure, uint8_t* dest) platform_exit_critical(); fhss_beacon_encode_raw(dest, &temp_payload); } - -// this assumes that the buffer's data pointer is seeked to the beacon payload -void fhss_beacon_received(fhss_structure_t *fhss_structure, const uint8_t *synch_info, const uint32_t elapsed_time) { - - if (fhss_structure) { - - if (synch_info) { - fhss_synchronization_beacon_payload_s temp_payload; - temp_payload.processing_delay = fhss_structure->fhss_conf.fhss_configuration.fhss_tuning_parameters.rx_processing_delay; - fhss_beacon_decode(&temp_payload, synch_info, elapsed_time, fhss_structure->number_of_channels); - - // use the received information - fhss_sync_with_beacon(fhss_structure, &temp_payload); - } - } -} - - diff --git a/source/Service_Libs/fhss/fhss_common.h b/source/Service_Libs/fhss/fhss_common.h index 89f85e3918e..6ae08ace9fb 100644 --- a/source/Service_Libs/fhss/fhss_common.h +++ b/source/Service_Libs/fhss/fhss_common.h @@ -127,6 +127,12 @@ int fhss_update_synch_parent_address(fhss_structure_t *fhss_structure); void fhss_trig_event(fhss_structure_t *fhss_structure, uint8_t event_type); int fhss_get_parent_address(fhss_structure_t *fhss_structure, uint8_t *p_addr); int fhss_compare_with_synch_parent_address(fhss_structure_t *fhss_structure, const uint8_t *source_addr); - void fhss_superframe_handler(const fhss_api_t *fhss_api, uint16_t delay); +/** + * Calculate time in microseconds to start of next superframe. + * + * @param fhss_struct FHSS structure + * @return microseconds left to start of next superframe + */ +uint32_t fhss_get_remaining_time_to_next_superframe(const fhss_structure_t *fhss_struct); #endif /*FHSS_COMMON_H_*/ diff --git a/source/Service_Libs/fhss/fhss_mac_interface.c b/source/Service_Libs/fhss/fhss_mac_interface.c index 5af65895c3b..17e652ab680 100644 --- a/source/Service_Libs/fhss/fhss_mac_interface.c +++ b/source/Service_Libs/fhss/fhss_mac_interface.c @@ -58,71 +58,6 @@ bool fhss_use_broadcast_queue_cb(const fhss_api_t *api, bool is_broadcast_addr, return is_broadcast_addr; } -void fhss_receive_frame_cb(const fhss_api_t *api, uint16_t pan_id, uint8_t *source_address, uint32_t timestamp, uint8_t *synch_info, int frame_type) -{ - fhss_structure_t *fhss_structure = fhss_get_object_with_api(api); - if (!fhss_structure) { - return; - } - if (FHSS_SYNCH_FRAME == frame_type) { - if ((fhss_structure->fhss_state == FHSS_UNSYNCHRONIZED) || fhss_structure->synch_panid != pan_id) { - fhss_add_beacon_info(fhss_structure, pan_id, source_address, timestamp, synch_info); - } else { - if (!fhss_compare_with_synch_parent_address(fhss_structure, source_address)) { - // Synch parent address needs to be updated in case parent has changed - fhss_update_synch_parent_address(fhss_structure); - platform_enter_critical(); - // Calculate time since the Beacon was received - uint32_t elapsed_time = api->read_timestamp(api) - timestamp; - // Synchronize to given PAN - fhss_beacon_received(fhss_structure, synch_info, elapsed_time); - platform_exit_critical(); - } - } - } else if (FHSS_SYNCH_REQUEST_FRAME == frame_type) { - // If current channel is broadcast, we don't need to send another synch info on next broadcast channel. - // Only send number of MAX_SYNCH_INFOS_PER_CHANNEL_LIST synch infos per one channel list cycle - if ((fhss_structure->fhss_state == FHSS_SYNCHRONIZED) && (fhss_is_current_channel_broadcast(fhss_structure) == false) - && (fhss_structure->synch_infos_sent_counter < MAX_SYNCH_INFOS_PER_CHANNEL_LIST)) { - fhss_structure->send_synch_info_on_next_broadcast_channel = true; - } - } -} - -bool fhss_data_tx_fail_cb(const fhss_api_t *api, uint8_t handle, int frame_type) -{ - fhss_structure_t *fhss_structure = fhss_get_object_with_api(api); - if (!fhss_structure) { - return false; - } - // Only use channel retries when device is synchronized - if (fhss_structure->fhss_state == FHSS_UNSYNCHRONIZED) { - return false; - } - // Channel retries are disabled -> return - if (fhss_structure->fhss_conf.fhss_configuration.fhss_number_of_channel_retries == 0) { - return false; - } - // Use channel retries only for data frames - if (FHSS_DATA_FRAME != frame_type) { - return false; - } - - fhss_failed_tx_t *fhss_failed_tx = fhss_failed_handle_find(fhss_structure, handle); - if (fhss_failed_tx) { - fhss_failed_tx->retries_done++; - if (fhss_failed_tx->retries_done >= fhss_structure->fhss_conf.fhss_configuration.fhss_number_of_channel_retries) { - // No more retries. Return false to stop retransmitting. - fhss_failed_handle_remove(fhss_structure, handle); - return false; - } - } else { - // Create new failure handle and return true to retransmit - fhss_failed_handle_add(fhss_structure, handle); - } - return true; -} - uint32_t fhss_read_timestamp_cb(const fhss_api_t *api) { fhss_structure_t *fhss_structure = fhss_get_object_with_api(api); @@ -132,50 +67,6 @@ uint32_t fhss_read_timestamp_cb(const fhss_api_t *api) return (fhss_structure->platform_functions.fhss_get_timestamp(api) * fhss_structure->platform_functions.fhss_resolution_divider); } -uint16_t fhss_get_retry_period_cb(const fhss_api_t *api, uint8_t *destination_address, uint16_t phy_mtu) -{ - uint16_t retry_period = 0; - uint16_t random_number = randLIB_get_16bit(); - uint16_t rnd_mask; - - /* Generate retry back-off period. FHSS is using the known synchronization parent info to delay retransmissions upstream. - * - */ - if (phy_mtu < 128) { - // Max. random when PHY MTU below 128 is 6.4ms - rnd_mask = 0x7f; - } else if (phy_mtu < 256) { - // Max. random when PHY MTU below 256 is 12.8ms - rnd_mask = 0xff; - } else { - // Max. random when PHY MTU above 255 is 25.6ms - rnd_mask = 0x1ff; - } - - fhss_structure_t *fhss_structure = fhss_get_object_with_api(api); - if (fhss_structure) { - uint32_t datarate = fhss_structure->datarate; - uint16_t max_tx_length; - - if (datarate && phy_mtu) { - if (fhss_compare_with_synch_parent_address(fhss_structure, destination_address) == 0) { - // E.g. (1000000 / (250000bit/s / 8 bits)) * 255 bytes = 8160us - max_tx_length = ((1000000 / (datarate / 8)) * phy_mtu); - /* Retrying upstream: delay the transmission until assumed hidden node has retried downstream: - * Static period: max random + max tx length - * 50 comes from MAC timer resolution (50us) - */ - retry_period = (rnd_mask + (max_tx_length / 50)); - } - } - } - - // Add 1 to not to ever return zero value. - retry_period += ((random_number & rnd_mask) + 1); - return retry_period; -} - - int fhss_init_callbacks_cb(const fhss_api_t *api, fhss_callback_t *callbacks) { fhss_structure_t *fhss_structure = fhss_get_object_with_api(api); diff --git a/source/Service_Libs/fhss/fhss_mac_interface.h b/source/Service_Libs/fhss/fhss_mac_interface.h index 691cdb7a1b1..9c758d3a0a7 100644 --- a/source/Service_Libs/fhss/fhss_mac_interface.h +++ b/source/Service_Libs/fhss/fhss_mac_interface.h @@ -20,10 +20,7 @@ bool fhss_is_broadcast_channel_cb(const fhss_api_t *api); bool fhss_use_broadcast_queue_cb(const fhss_api_t *api, bool is_broadcast_addr, int frame_type); -void fhss_receive_frame_cb(const fhss_api_t *api, uint16_t pan_id, uint8_t *source_address, uint32_t timestamp, uint8_t *synch_info, int frame_type); -bool fhss_data_tx_fail_cb(const fhss_api_t *api, uint8_t handle, int frame_type); uint32_t fhss_read_timestamp_cb(const fhss_api_t *api); -uint16_t fhss_get_retry_period_cb(const fhss_api_t *api, uint8_t *destination_address, uint16_t phy_mtu); int fhss_init_callbacks_cb(const fhss_api_t *api, fhss_callback_t *callbacks); #endif /* FHSS_MAC_INTERFACE_H_ */ diff --git a/source/Service_Libs/fhss/fhss_ws.c b/source/Service_Libs/fhss/fhss_ws.c index fbfba173547..94f7e962c36 100644 --- a/source/Service_Libs/fhss/fhss_ws.c +++ b/source/Service_Libs/fhss/fhss_ws.c @@ -279,6 +279,24 @@ static void fhss_ws_data_tx_done_callback(const fhss_api_t *api, bool waiting_ac } } +static bool fhss_ws_data_tx_fail_callback(const fhss_api_t *api, uint8_t handle, int frame_type) +{ + (void) api; + (void) handle; + (void) frame_type; + return false; +} + +static void fhss_ws_receive_frame_callback(const fhss_api_t *api, uint16_t pan_id, uint8_t *source_address, uint32_t timestamp, uint8_t *synch_info, int frame_type) +{ + (void) api; + (void) pan_id; + (void) source_address; + (void) timestamp; + (void) synch_info; + (void) frame_type; +} + int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure) { // Set external API @@ -286,12 +304,12 @@ int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure) fhss_structure->fhss_api->use_broadcast_queue = &fhss_use_broadcast_queue_cb; fhss_structure->fhss_api->tx_handle = &fhss_ws_tx_handle_callback; fhss_structure->fhss_api->check_tx_conditions = &fhss_ws_check_tx_conditions_callback; - fhss_structure->fhss_api->receive_frame = &fhss_receive_frame_cb; + fhss_structure->fhss_api->receive_frame = &fhss_ws_receive_frame_callback; fhss_structure->fhss_api->data_tx_done = &fhss_ws_data_tx_done_callback; - fhss_structure->fhss_api->data_tx_fail = &fhss_data_tx_fail_cb; + fhss_structure->fhss_api->data_tx_fail = &fhss_ws_data_tx_fail_callback; fhss_structure->fhss_api->synch_state_set = &fhss_ws_handle_state_set; fhss_structure->fhss_api->read_timestamp = &fhss_read_timestamp_cb; - fhss_structure->fhss_api->get_retry_period = &fhss_get_retry_period_cb; + fhss_structure->fhss_api->get_retry_period = NULL; fhss_structure->fhss_api->write_synch_info = &fhss_ws_write_synch_info_callback; fhss_structure->fhss_api->init_callbacks = &fhss_init_callbacks_cb; // Set internal API diff --git a/test/nanostack/unittest/service_libs/fhss/fhsstest.cpp b/test/nanostack/unittest/service_libs/fhss/fhsstest.cpp index f897cd9c35f..89b405a3cea 100644 --- a/test/nanostack/unittest/service_libs/fhss/fhsstest.cpp +++ b/test/nanostack/unittest/service_libs/fhss/fhsstest.cpp @@ -64,21 +64,11 @@ TEST(fhss, test_fhss_get_parent_address) CHECK(test_fhss_get_parent_address()); } -TEST(fhss, test_fhss_sync_with_beacon) -{ - CHECK(test_fhss_sync_with_beacon()); -} - TEST(fhss, test_fhss_set_datarate) { CHECK(test_fhss_set_datarate()); } -TEST(fhss, test_fhss_add_beacon_info) -{ - CHECK(test_fhss_add_beacon_info()); -} - TEST(fhss, test_fhss_set_synch_configuration) { CHECK(test_fhss_set_synch_configuration()); @@ -104,11 +94,6 @@ TEST(fhss, test_fhss_update_beacon_info_lifetimes) CHECK(test_fhss_update_beacon_info_lifetimes()); } -TEST(fhss, test_fhss_failed_handle) -{ - CHECK(test_fhss_failed_handle()); -} - TEST(fhss, test_fhss_is_synch_root) { CHECK(test_fhss_is_synch_root()); diff --git a/test/nanostack/unittest/service_libs/fhss/test_fhss.c b/test/nanostack/unittest/service_libs/fhss/test_fhss.c index 358ae4c3b1d..3938083255d 100644 --- a/test/nanostack/unittest/service_libs/fhss/test_fhss.c +++ b/test/nanostack/unittest/service_libs/fhss/test_fhss.c @@ -169,94 +169,6 @@ bool test_fhss_set_synch_configuration() return true; } -bool test_fhss_add_beacon_info() -{ - uint8_t compare_array[20]; - uint8_t mac_address[8]; - uint8_t synch_info[20]; - uint16_t panid = 0x1234; - - fhss_struct = malloc(sizeof(fhss_structure_t)); - - memset(mac_address, 0, 8); - - fhss_struct->fhss_beacon_info_store = 0; - // Test without FHSS structure - if (fhss_add_beacon_info(NULL, panid, mac_address, 0, synch_info) != -1) { - return false; - } - // Test without source address - if (fhss_add_beacon_info(fhss_struct, panid, NULL, 0, synch_info) != -1) { - return false; - } - // Test without synchronization info - if (fhss_add_beacon_info(fhss_struct, panid, mac_address, 0, NULL) != -1) { - return false; - } - // Test without memory - if (fhss_add_beacon_info(fhss_struct, panid, mac_address, 0, synch_info) != -2) { - return false; - } - // Test adding first Beacon info - nsdynmemlib_stub.returnCounter = 1; - if (fhss_add_beacon_info(fhss_struct, panid, mac_address, 0, synch_info) != 0) { - return false; - } - memset(compare_array, 0, 8); - // Verify storage by comparing pan id and source address - if ((fhss_struct->fhss_beacon_info_store->pan_id != panid) || memcmp(fhss_struct->fhss_beacon_info_store->source_address, compare_array, 8)) { - return false; - } - nsdynmemlib_stub.returnCounter = 1; - // Test adding another Beacon info (pan id is not same as first Beacon info) - if (fhss_add_beacon_info(fhss_struct, panid + 1, mac_address, 0, synch_info) != 0) { - return false; - } - memset(compare_array, 0, 8); - // Verify storage by comparing pan id - if ((fhss_struct->fhss_beacon_info_store->next->pan_id != panid + 1) || memcmp(fhss_struct->fhss_beacon_info_store->next->source_address, compare_array, 8)) { - return false; - } - nsdynmemlib_stub.returnCounter = 1; - // Test adding third Beacon info (pan id is not same as other Beacon infos) - if (fhss_add_beacon_info(fhss_struct, panid + 2, mac_address, 0, synch_info) != 0) { - return false; - } - memset(compare_array, 0, 8); - // Verify storage by comparing pan id - if ((fhss_struct->fhss_beacon_info_store->next->next->pan_id != panid + 2) || memcmp(fhss_struct->fhss_beacon_info_store->next->next->source_address, compare_array, 8)) { - return false; - } - // Test replacing first Beacon info (source address has changed) - memset(mac_address, 1, 8); - nsdynmemlib_stub.returnCounter = 1; - if (fhss_add_beacon_info(fhss_struct, panid, mac_address, 0, synch_info) != 0) { - return false; - } - memset(compare_array, 1, 8); - // Verify storage by comparing pan id and source address - if ((fhss_struct->fhss_beacon_info_store->pan_id != panid) || memcmp(fhss_struct->fhss_beacon_info_store->source_address, compare_array, 8)) { - return false; - } - // Test replacing second Beacon info (source address has changed) - memset(mac_address, 1, 8); - nsdynmemlib_stub.returnCounter = 1; - if (fhss_add_beacon_info(fhss_struct, panid + 1, mac_address, 0, synch_info) != 0) { - return false; - } - memset(compare_array, 1, 8); - // Verify storage by comparing pan id and source address - if ((fhss_struct->fhss_beacon_info_store->next->pan_id != panid + 1) || memcmp(fhss_struct->fhss_beacon_info_store->next->source_address, compare_array, 8)) { - return false; - } - free(fhss_struct->fhss_beacon_info_store->next->next); - free(fhss_struct->fhss_beacon_info_store->next); - free(fhss_struct->fhss_beacon_info_store); - free(fhss_struct); - fhss_struct = 0; - return true; -} - bool test_fhss_set_datarate() { fhss_struct = malloc(sizeof(fhss_structure_t)); @@ -283,99 +195,6 @@ bool test_fhss_set_datarate() return true; } -bool test_fhss_sync_with_beacon() -{ - fhss_struct = malloc(sizeof(fhss_structure_t)); - memset(fhss_struct, 0, sizeof(fhss_structure_t)); - fhss_synchronization_beacon_payload_s payload; - - fhss_struct->number_of_channels = 50; - payload.number_of_broadcast_channels = 10; - payload.superframe_length = 50000; - payload.number_of_superframes_per_channel = 8; - fhss_struct->fhss_state = FHSS_SYNCHRONIZED; - - fhss_struct->callbacks.read_mac_address = &mac_read_64bit_mac_address; - fhss_struct->callbacks.read_coord_mac_address = &mac_get_coordinator_mac_address; - fhss_struct->platform_functions.fhss_timer_stop = &fhss_timer_stop_stub; - fhss_struct->platform_functions.fhss_timer_start = &fhss_timer_start; - fhss_struct->platform_functions.fhss_get_remaining_slots = &fhss_get_remaining_slots_stub; - fhss_struct->platform_functions.fhss_resolution_divider = 1; - fhss_struct->fhss_conf.fhss_configuration.fhss_max_synch_interval = 240; - fhss_struct->synch_interval = 150000; - - // Test that synchronization is skipped if Beacon is already received on this channel - fhss_struct->beacon_received_on_this_bc_channel = false; - fhss_channel_stub.channel_bool_value = false; - if (fhss_sync_with_beacon(fhss_struct, &payload)) { - return false; - } - fhss_struct->beacon_received_on_this_bc_channel = true; - fhss_channel_stub.channel_bool_value = true; - if (fhss_sync_with_beacon(fhss_struct, &payload)) { - return false; - } - // Test fixing synchronization - fhss_struct->beacon_received_on_this_bc_channel = false; - fhss_channel_stub.channel_bool_value = true; - if (fhss_sync_with_beacon(fhss_struct, &payload)) { - return false; - } - // Test synchronizing unsynchronized device - fhss_struct->fhss_state = FHSS_UNSYNCHRONIZED; - if (fhss_sync_with_beacon(fhss_struct, &payload)) { - return false; - } - - fhss_struct->fhss_state = FHSS_UNSYNCHRONIZED; - fhss_struct->synch_interval = 240000; - if (fhss_sync_with_beacon(fhss_struct, &payload)) { - return false; - } - - fhss_struct->fhss_state = FHSS_SYNCHRONIZED; - fhss_struct->beacon_received_on_this_bc_channel = false; - // Test superframe changed loops - fhss_struct->current_superframe = 0; - payload.current_superframe = 7; - if (fhss_sync_with_beacon(fhss_struct, &payload)) { - return false; - } - // Test synch drift compensation - fhss_struct->fhss_state = FHSS_SYNCHRONIZED; - fhss_struct->own_hop = 1; - fhss_struct->beacon_received_on_this_bc_channel = false; - fhss_struct->synch_monitor.avg_synch_fix_counter = 4; - fhss_struct->synch_monitor.avg_synch_fix = 100; - fhss_struct->platform_functions.fhss_resolution_divider = 1; - payload.remaining_slots = fhss_platform_stub.uint32_value; - if (fhss_sync_with_beacon(fhss_struct, &payload)) { - return false; - } - // Should use maximum interval - if (fhss_struct->synch_interval != 240000) { - return false; - } - - fhss_struct->fhss_state = FHSS_SYNCHRONIZED; - fhss_struct->own_hop = 1; - fhss_struct->beacon_received_on_this_bc_channel = false; - fhss_struct->synch_monitor.avg_synch_fix_counter = 4; - fhss_struct->synch_monitor.avg_synch_fix = 51000; - fhss_struct->synch_interval = 120000; - payload.remaining_slots = fhss_platform_stub.uint32_value + 1000000000; - if (fhss_sync_with_beacon(fhss_struct, &payload)) { - return false; - } - if (fhss_struct->synch_interval != 4000) { - return false; - } - - free(fhss_struct); - fhss_struct = NULL; - return true; -} - bool test_fhss_get_parent_address() { uint8_t mac_address[8]; @@ -433,8 +252,8 @@ bool test_fhss_compare_with_synch_parent_address() return false; } fhss_struct = malloc(sizeof(fhss_structure_t)); + fhss_struct->own_hop = 1; //Test when mac address is synch address - fhss_struct->callbacks.read_coord_mac_address = &mac_get_coordinator_mac_address; memcpy(fhss_struct->synch_parent, synch_parent, 8); @@ -674,34 +493,6 @@ bool test_fhss_update_beacon_info_lifetimes() return true; } -bool test_fhss_failed_handle() -{ - uint8_t handle = 99; - fhss_struct = malloc(sizeof(fhss_structure_t)); - ns_list_init(&fhss_struct->fhss_failed_tx_list); - // Test without memory - nsdynmemlib_stub.returnCounter = 0; - if (fhss_failed_handle_add(fhss_struct, handle) != -2) { - return false; - } - // Test with memory - nsdynmemlib_stub.returnCounter = 1; - if (fhss_failed_handle_add(fhss_struct, handle) != 0) { - return false; - } - // Remove invalid handle - if (fhss_failed_handle_remove(fhss_struct, handle-1) != -1) { - return false; - } - // Remove valid handle - if (fhss_failed_handle_remove(fhss_struct, handle) != 0) { - return false; - } - free(fhss_struct); - fhss_struct = NULL; - return true; -} - bool test_fhss_is_synch_root() { fhss_struct = malloc(sizeof(fhss_structure_t)); @@ -770,19 +561,7 @@ bool test_fhss_check_tx_conditions_callback() ns_list_init(&fhss_struct->fhss_failed_tx_list); nsdynmemlib_stub.returnCounter = 1; - if (fhss_failed_handle_add(fhss_struct, handle) != 0) { - return false; - } - - // Test failing bad channel check - if (fhss_struct->fhss_api->check_tx_conditions(&fhss_api, true, handle, FHSS_DATA_FRAME, 100, 0, 0) == true) { - return false; - } - if (fhss_failed_handle_remove(fhss_struct, handle) != 0) { - return false; - } // Test failing channel type check - fhss_struct->fhss_state = FHSS_SYNCHRONIZED; if (fhss_struct->fhss_api->check_tx_conditions(&fhss_api, true, 1, FHSS_DATA_FRAME, 100, 0, 0) == true) { return false; diff --git a/test/nanostack/unittest/service_libs/fhss/test_fhss.h b/test/nanostack/unittest/service_libs/fhss/test_fhss.h index 2a4698bb874..fa32db3b049 100644 --- a/test/nanostack/unittest/service_libs/fhss/test_fhss.h +++ b/test/nanostack/unittest/service_libs/fhss/test_fhss.h @@ -29,12 +29,8 @@ bool test_fhss_enable(); bool test_fhss_disable(); // Test synchronization time configuration bool test_fhss_set_synch_configuration(); -// Test storing Beacon info -bool test_fhss_add_beacon_info(); // Test setting datarate bool test_fhss_set_datarate(); -// Test synchronization to Beacon -bool test_fhss_sync_with_beacon(); // Test requesting parent MAC address bool test_fhss_get_parent_address(); // Test comparing synch parent address @@ -53,8 +49,6 @@ bool test_fhss_timeout_stop(); bool test_fhss_clear_active_event(); // Test updating lifetimes bool test_fhss_update_beacon_info_lifetimes(); -// Test finding failed TX handle -bool test_fhss_failed_handle(); // Test synch root check bool test_fhss_is_synch_root(); // Test TX handle callback diff --git a/test/nanostack/unittest/service_libs/fhss_beacon_tasklet/fhssbeacontasklettest.cpp b/test/nanostack/unittest/service_libs/fhss_beacon_tasklet/fhssbeacontasklettest.cpp index cc2f0f71868..badac5e50f4 100644 --- a/test/nanostack/unittest/service_libs/fhss_beacon_tasklet/fhssbeacontasklettest.cpp +++ b/test/nanostack/unittest/service_libs/fhss_beacon_tasklet/fhssbeacontasklettest.cpp @@ -38,8 +38,3 @@ TEST(fhss_beacon_tasklet, test_fhss_beacon_build) { CHECK(test_fhss_beacon_build()); } - -TEST(fhss_beacon_tasklet, test_fhss_beacon_received) -{ - CHECK(test_fhss_beacon_received()); -} diff --git a/test/nanostack/unittest/service_libs/fhss_beacon_tasklet/test_fhss_beacon_tasklet.c b/test/nanostack/unittest/service_libs/fhss_beacon_tasklet/test_fhss_beacon_tasklet.c index 3c9efc8b341..a0a03a6fa22 100644 --- a/test/nanostack/unittest/service_libs/fhss_beacon_tasklet/test_fhss_beacon_tasklet.c +++ b/test/nanostack/unittest/service_libs/fhss_beacon_tasklet/test_fhss_beacon_tasklet.c @@ -92,16 +92,3 @@ bool test_fhss_beacon_build() fhss_beacon_build(NULL, NULL); return true; } - -bool test_fhss_beacon_received() -{ - fhss_structure_t fhss_structure; - uint8_t synch_info[21]; - // Test NULL parameters; - fhss_beacon_received(NULL, NULL, 0); - // Test NULL synch info - fhss_beacon_received(&fhss_structure, NULL, 0); - // Test with "proper" parameters - fhss_beacon_received(&fhss_structure, synch_info, 0); - return true; -} diff --git a/test/nanostack/unittest/service_libs/fhss_beacon_tasklet/test_fhss_beacon_tasklet.h b/test/nanostack/unittest/service_libs/fhss_beacon_tasklet/test_fhss_beacon_tasklet.h index bc40417914a..a99390cf1f7 100644 --- a/test/nanostack/unittest/service_libs/fhss_beacon_tasklet/test_fhss_beacon_tasklet.h +++ b/test/nanostack/unittest/service_libs/fhss_beacon_tasklet/test_fhss_beacon_tasklet.h @@ -25,7 +25,6 @@ extern "C" { bool test_fhss_beacon_tasklet_func(); bool test_fhss_beacon_build(); -bool test_fhss_beacon_received(); #ifdef __cplusplus } diff --git a/test/nanostack/unittest/service_libs/fhss_mac_interface/fhssmaciftest.cpp b/test/nanostack/unittest/service_libs/fhss_mac_interface/fhssmaciftest.cpp index 8fe488b5cee..d59b7f14c43 100644 --- a/test/nanostack/unittest/service_libs/fhss_mac_interface/fhssmaciftest.cpp +++ b/test/nanostack/unittest/service_libs/fhss_mac_interface/fhssmaciftest.cpp @@ -39,16 +39,6 @@ TEST(fhss_mac_if, test_fhss_use_broadcast_queue_cb) CHECK(test_fhss_use_broadcast_queue_cb()); } -TEST(fhss_mac_if, test_fhss_receive_frame_cb) -{ - CHECK(test_fhss_receive_frame_cb()); -} - -TEST(fhss_mac_if, test_fhss_data_tx_fail_cb) -{ - CHECK(test_fhss_data_tx_fail_cb()); -} - TEST(fhss_mac_if, test_fhss_read_timestamp_cb) { CHECK(test_fhss_read_timestamp_cb()); @@ -58,8 +48,3 @@ TEST(fhss_mac_if, test_fhss_init_callbacks_cb) { CHECK(test_fhss_init_callbacks_cb()); } - -TEST(fhss_mac_if, test_fhss_get_retry_period_cb) -{ - CHECK(test_fhss_get_retry_period_cb()); -} diff --git a/test/nanostack/unittest/service_libs/fhss_mac_interface/test_fhss_mac_interface.c b/test/nanostack/unittest/service_libs/fhss_mac_interface/test_fhss_mac_interface.c index b410372f176..47e7d9febdb 100644 --- a/test/nanostack/unittest/service_libs/fhss_mac_interface/test_fhss_mac_interface.c +++ b/test/nanostack/unittest/service_libs/fhss_mac_interface/test_fhss_mac_interface.c @@ -47,6 +47,7 @@ bool test_fhss_is_broadcast_channel_cb() } // Should return false fhss_channel_stub.channel_bool_value = false; + fhss_stub.fhss_struct.fhss_state = FHSS_SYNCHRONIZED; if (fhss_is_broadcast_channel_cb(&fhss_api) == true) { return false; } @@ -79,86 +80,6 @@ bool test_fhss_use_broadcast_queue_cb() return true; } -bool test_fhss_receive_frame_cb() -{ - fhss_api_t fhss_api; - fhss_timer_t platform_functions; - uint8_t source_address[8] = {0, 1, 2, 3, 4, 5, 6, 7}; - - platform_functions.fhss_get_timestamp = fhss_get_timestamp_stub; - fhss_stub.fhss_struct.platform_functions = platform_functions; - fhss_api.read_timestamp = fhss_read_timestamp_cb; - - // By setting bool value false, fhss_struct can not be found - fhss_stub.bool_value = false; - fhss_receive_frame_cb(&fhss_api, 0, NULL, 0, NULL, FHSS_SYNCH_FRAME); - // By setting bool value true, fhss_struct can be found - fhss_stub.bool_value = true; - // Test adding Beacon info when not synchronized - fhss_stub.fhss_struct.fhss_state = FHSS_UNSYNCHRONIZED; - fhss_receive_frame_cb(&fhss_api, 0, NULL, 0, NULL, FHSS_SYNCH_FRAME); - // Beacon received when synchronized - fhss_stub.fhss_struct.fhss_state = FHSS_SYNCHRONIZED; - fhss_receive_frame_cb(&fhss_api, 0, source_address, 0, NULL, FHSS_SYNCH_FRAME); - // Beacon request received - fhss_channel_stub.channel_bool_value = false; - fhss_stub.fhss_struct.fhss_state = FHSS_SYNCHRONIZED; - - fhss_stub.fhss_struct.send_synch_info_on_next_broadcast_channel = false; - fhss_receive_frame_cb(&fhss_api, 0, NULL, 0, NULL, FHSS_SYNCH_REQUEST_FRAME); - if (fhss_stub.fhss_struct.send_synch_info_on_next_broadcast_channel != true) { - return false; - } - // Test Synch info limitation - fhss_stub.fhss_struct.send_synch_info_on_next_broadcast_channel = false; - fhss_stub.fhss_struct.synch_infos_sent_counter = MAX_SYNCH_INFOS_PER_CHANNEL_LIST; - fhss_receive_frame_cb(&fhss_api, 0, NULL, 0, NULL, FHSS_SYNCH_REQUEST_FRAME); - if (fhss_stub.fhss_struct.send_synch_info_on_next_broadcast_channel != false) { - return false; - } - - return true; -} - -bool test_fhss_data_tx_fail_cb() -{ - fhss_api_t fhss_api; - uint8_t handle = 1; - fhss_stub.fhss_struct.fhss_state = FHSS_SYNCHRONIZED; - - // By setting bool value false, fhss_struct can not be found - fhss_stub.bool_value = false; - fhss_data_tx_fail_cb(&fhss_api, handle, FHSS_DATA_FRAME); - // By setting bool value true, fhss_struct can be found - fhss_stub.bool_value = true; - - // No channel retries should return false - fhss_stub.fhss_struct.fhss_conf.fhss_configuration.fhss_number_of_channel_retries = 0; - if (fhss_data_tx_fail_cb(&fhss_api, handle, FHSS_DATA_FRAME) != false) { - return false; - } - // In this test 255 means no handle added - fhss_stub.fhss_failed_tx.handle = 255; - fhss_stub.fhss_struct.fhss_conf.fhss_configuration.fhss_number_of_channel_retries = 2; - // This call should add new failed handle - if (fhss_data_tx_fail_cb(&fhss_api, handle, FHSS_DATA_FRAME) != true) { - return false; - } - // Verify added handle - if (fhss_stub.fhss_failed_tx.handle != handle) { - return false; - } - // After first retransmission should return true because one more retry left - if (fhss_data_tx_fail_cb(&fhss_api, handle, FHSS_DATA_FRAME) != true) { - return false; - } - // After last retransmission should return false - if (fhss_data_tx_fail_cb(&fhss_api, handle, FHSS_DATA_FRAME) != false) { - return false; - } - - return true; -} bool test_fhss_read_timestamp_cb() { fhss_api_t fhss_api; @@ -185,26 +106,3 @@ bool test_fhss_init_callbacks_cb() fhss_init_callbacks_cb(&fhss_api, &callbacks); return true; } -bool test_fhss_get_retry_period_cb() -{ - fhss_api_t fhss_api; - if (fhss_get_retry_period_cb(NULL, NULL, 1) != 1) { - return false; - } - if (fhss_get_retry_period_cb(NULL, NULL, 128) != 1) { - return false; - } - if (fhss_get_retry_period_cb(NULL, NULL, 256) != 1) { - return false; - } - // By setting bool value true, fhss_struct can be found - fhss_stub.bool_value = true; - - // With the given datarate and MTU, callback should return 896 - fhss_stub.fhss_struct.datarate = 250000; - fhss_stub.int8_value = 0; - if (fhss_get_retry_period_cb(&fhss_api, NULL, 600) != 896) { - return false; - } - return true; -} diff --git a/test/nanostack/unittest/service_libs/fhss_mac_interface/test_fhss_mac_interface.h b/test/nanostack/unittest/service_libs/fhss_mac_interface/test_fhss_mac_interface.h index 7b2ba5259fa..5cab8e94263 100644 --- a/test/nanostack/unittest/service_libs/fhss_mac_interface/test_fhss_mac_interface.h +++ b/test/nanostack/unittest/service_libs/fhss_mac_interface/test_fhss_mac_interface.h @@ -26,18 +26,10 @@ extern "C" { bool test_fhss_is_broadcast_channel_cb(); // Test broadcast queue check callback bool test_fhss_use_broadcast_queue_cb(); -// Test frame receive callback -bool test_fhss_receive_frame_cb(); -// Test TX fail callback -bool test_fhss_data_tx_fail_cb(); -// Test state set callback -bool test_fhss_synch_state_set_cb(); // Test timestamp callback bool test_fhss_read_timestamp_cb(); // Test callback init callback bool test_fhss_init_callbacks_cb(); -// Test getting retransmission period callback -bool test_fhss_get_retry_period_cb(); #ifdef __cplusplus }