/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ #include #include #include #include #include "tx_stress.h" /* Main test task priority. Set a high value so that the task does not * interfere with event handling */ #define TX_STRESS_MAIN_TASK_PRIO 0xf0 #define BASE_UUID_LEN 13 /* Contexts for stress tests. */ static struct com_stress_test_ctx tx_stress_ctxD = { .conn_handle = 0xffff, .cur_test_id = 0, }; static struct com_stress_test_ctx *tx_stress_ctx; /* Define stack, object and semaphore for test main task. */ #define TX_STRESS_MAIN_TASK_STACK_SIZE (500) static struct os_task tx_stress_main_task; static os_stack_t tx_stress_main_task_stack[TX_STRESS_MAIN_TASK_STACK_SIZE]; static struct os_sem tx_stress_main_sem; /* Test use case and address of test advertiser. */ static int tx_stress_use_case; static int completed_tests = 0; static void tx_stress_on_test_finish(int test_num) { console_printf("\033[0;32m\nStress test %d completed\033[0m\n", test_num); ++completed_tests; tx_stress_ctx->completed[test_num] = true; os_sem_release(&tx_stress_main_sem); } static void tx_stress_simple_scan(ble_gap_event_fn *cb, uint16_t duration) { uint8_t own_addr_type; struct ble_gap_ext_disc_params params = {0}; int rc; /* Figure out address to use while scanning. */ rc = ble_hs_id_infer_auto(0, &own_addr_type); if (rc != 0) { console_printf("\033[0;31mError determining own address type; " "rc=%d\033[0m\n", rc); assert(0); } params.itvl = BLE_GAP_SCAN_FAST_INTERVAL_MAX; params.passive = 1; params.window = BLE_GAP_SCAN_FAST_WINDOW; rc = ble_gap_ext_disc(own_addr_type, duration, 0, 1, 0, 0, ¶ms, NULL, cb, NULL); if (rc != 0) { console_printf("\033[0;31mError initiating GAP discovery procedure" "; rc=%d\033[0m\n", rc); } } static int tx_stress_simple_connect(ble_gap_event_fn *cb, int test_num) { uint8_t own_addr_type; int rc; /* Set so any PHY mask allowed. */ ble_gap_set_prefered_default_le_phy(TX_PHY_MASK, RX_PHY_MASK); /* Figure out address to use while connecting. */ rc = ble_hs_id_infer_auto(0, &own_addr_type); if (rc != 0) { MODLOG_DFLT(INFO, "\033[0;31mError determining own address type; " "rc=%d\033[0m\n", rc); return rc; } MODLOG_DFLT(INFO, "Connection attempt: %d\n", ++tx_stress_ctx->con_stat[test_num].attempts_num); rc = ble_gap_ext_connect(own_addr_type, &tx_stress_ctx->dev_addr, 10000, BLE_GAP_LE_PHY_1M_MASK | BLE_GAP_LE_PHY_2M_MASK, NULL, NULL, NULL, cb, NULL); if (rc != 0) { MODLOG_DFLT(INFO, "\033[0;31mError during connection; rc=%d\033[0m\n", rc); } return rc; } static int tx_stress_find_test(struct ble_gap_ext_disc_desc *ext_disc) { struct ble_hs_adv_fields fields; int data_len; int rc; /* Parser refuses greater length data than 31. But known UUID128 will be * in first 31 bytes of adv data first packet. */ if (ext_disc->length_data > 31) { data_len = 31; } else { data_len = ext_disc->length_data; } /* Parse part of adv data. */ ble_hs_adv_parse_fields(&fields, ext_disc->data, data_len); print_adv_fields(&fields); /* UUID128 service data of stress test advert includes only UUID128. */ if (fields.svc_data_uuid128_len != 16) { return -1; } /* Check if service data include known UUID128. */ rc = memcmp(fields.svc_data_uuid128, (uint8_t[]) {0xC0, 0xDE}, 2); if (rc) { return -1; } rc = memcmp(fields.svc_data_uuid128 + 3, MYNEWT_VAL(BLE_STRESS_UUID_BASE), BASE_UUID_LEN); if (rc != 0) { return -1; } /* This UUID 128 byte indicates the stress test ID to be executed. */ return fields.svc_data_uuid128[2]; } static int tx_stress_switcher_gap_event(struct ble_gap_event *event, void *arg) { int rc; switch (event->type) { case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { MODLOG_DFLT(INFO, "Success to connect to device\n"); return 0; } else if (event->connect.status == BLE_HS_ETIMEOUT_HCI) { MODLOG_DFLT(INFO, "Connection timeout\n"); } else { MODLOG_DFLT(INFO, "Error: connection attempt failed; status=%d\n", event->connect.status); } /* Connect to rx device just to give it a signal to switch test. */ tx_stress_simple_connect(tx_stress_switcher_gap_event, tx_stress_ctx->cur_test_id); return 0; case BLE_GAP_EVENT_DISCONNECT: os_sem_release(&tx_stress_main_sem); return 0; case BLE_GAP_EVENT_EXT_DISC: /* Check if caught advert contains known UUID128. The UUID128 * contains the ID of test use case to be executed. */ rc = tx_stress_find_test(&event->ext_disc); if (rc == 0) { tx_stress_ctx->dev_addr = event->ext_disc.addr; /* Stop scanning. */ ble_gap_disc_cancel(); /* Add token to semaphore. Main task will start the test. */ os_sem_release(&tx_stress_main_sem); } return 0; case BLE_GAP_EVENT_DISC_COMPLETE: MODLOG_DFLT(INFO, "Discovery complete; reason=%d\n", event->disc_complete.reason); return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static void tx_stress_switch_test() { tx_stress_simple_scan(tx_stress_switcher_gap_event, 0); os_sem_pend(&tx_stress_main_sem, OS_TIMEOUT_NEVER); tx_stress_simple_connect(tx_stress_switcher_gap_event, 0); } static int tx_stress_1_gap_event(struct ble_gap_event *event, void *arg) { switch (event->type) { case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ MODLOG_DFLT(INFO, "Connection %s; status=%d ", event->connect.status == 0 ? "established" : "failed", event->connect.status); if (event->connect.status == 0) { /* Connection successfully established. In this use case * it is error of 'Connect cancel'. Stress test failed. */ MODLOG_DFLT(INFO, "Success to connect to device\n"); ++tx_stress_ctx->con_stat[1].num; ble_gap_terminate(event->connect.conn_handle, BLE_ERR_NO_PAIRING); } return 0; case BLE_GAP_EVENT_DISCONNECT: MODLOG_DFLT(INFO, "Disconnect; reason=%d ", event->disconnect.reason); return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static void tx_stress_1_test() { int rc; uint8_t own_addr_type; ble_addr_t rnd_rx_addr; int delay_time; rc = ble_gap_disc_active(); assert(rc == 0); /* Figure out address to use while advertising. */ rc = ble_hs_id_infer_auto(0, &own_addr_type); if (rc != 0) { MODLOG_DFLT(INFO, "\033[0;31mError determining own address type; " "rc=%d\033[0m\n", rc); os_sem_release(&tx_stress_main_sem); return; } while (tx_stress_ctx->con_stat[1].attempts_num < MYNEWT_VAL(BLE_STRESS_REPEAT)) { /* Rand ble address to connect*/ rc = ble_hs_id_gen_rnd(1, &rnd_rx_addr); assert (rc == 0); MODLOG_DFLT(INFO, "Connection attempt; num=%d\n", ++tx_stress_ctx->con_stat[1].attempts_num); rc = ble_gap_connect(own_addr_type, &rnd_rx_addr, 10000, NULL, tx_stress_1_gap_event, NULL); if (rc != 0) { MODLOG_DFLT(INFO, "\033[0;31mConnection error; rc=%d\033[0m\n", rc); os_sem_release(&tx_stress_main_sem); return; } MODLOG_DFLT(INFO, "Connect cancel\n"); ble_gap_conn_cancel(); console_printf("\033[0;32m>\033[0m"); } console_printf( "\033[0;32m\nFirst part of test completed\nStart second part: " "Connect->random delay->cancel\n\033[0m"); while (tx_stress_ctx->con_stat[1].attempts_num < 2 * MYNEWT_VAL(BLE_STRESS_REPEAT)) { /* Rand ble address to connect*/ rc = ble_hs_id_gen_rnd(1, &rnd_rx_addr); assert (rc == 0); MODLOG_DFLT(INFO, "Connection attempt; num=%d\n", ++tx_stress_ctx->con_stat[1].attempts_num); delay_time = rand() % 1000; MODLOG_DFLT(INFO, "Time to delay=%d\n", delay_time); rc = ble_gap_connect(own_addr_type, &rnd_rx_addr, 10000, NULL, tx_stress_1_gap_event, NULL); if (rc != 0) { MODLOG_DFLT(INFO, "\033[0;31mConnection error; rc=%d\033[0m\n", rc); os_sem_release(&tx_stress_main_sem); return; } os_time_delay(os_time_ms_to_ticks32(delay_time)); MODLOG_DFLT(INFO, "Connect cancel\n"); ble_gap_conn_cancel(); console_printf("\033[0;32m>\033[0m"); } tx_stress_on_test_finish(1); } static int tx_stress_2_gap_event(struct ble_gap_event *event, void *arg) { struct ble_gap_conn_desc desc; int rc; switch (event->type) { case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { MODLOG_DFLT(INFO, "Success to connect to device\n"); ++tx_stress_ctx->con_stat[2].num; rc = ble_gap_conn_find(event->connect.conn_handle, &desc); assert(rc == 0); tx_stress_ctx->conn_handle = desc.conn_handle; ble_gap_terminate(event->connect.conn_handle, BLE_ERR_REM_USER_CONN_TERM); } else { MODLOG_DFLT(INFO, "\033[0;31mError: connection attempt failed; " "status=%d\033[0m\n", event->connect.status); os_sem_release(&tx_stress_main_sem); } return 0; case BLE_GAP_EVENT_DISCONNECT: MODLOG_DFLT(INFO, "Disconnect; reason=%d \n", event->disconnect.reason); console_printf("\033[0;32m>\033[0m"); if (tx_stress_ctx->con_stat[2].num >= MYNEWT_VAL(BLE_STRESS_REPEAT)) { tx_stress_on_test_finish(2); return 0; } tx_stress_simple_connect(tx_stress_2_gap_event, tx_stress_ctx->cur_test_id); return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static int tx_stress_3_gap_event(struct ble_gap_event *event, void *arg) { int rc; switch (event->type) { case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { ++tx_stress_ctx->con_stat[3].num; MODLOG_DFLT(INFO, "Success to connect to device\n"); rc = ble_gap_terminate(event->connect.conn_handle, BLE_ERR_REM_USER_CONN_TERM); MODLOG_DFLT(INFO, "rc=%d\n", rc); } else { MODLOG_DFLT(INFO, "\033[0;31mError: connection attempt failed; " "status=%d\033[0m\n", event->connect.status); os_sem_release(&tx_stress_main_sem); } return 0; case BLE_GAP_EVENT_DISCONNECT: MODLOG_DFLT(INFO, "Disconnect; reason=%d \n", event->disconnect.reason); console_printf("\033[0;32m>\033[0m"); if (tx_stress_ctx->con_stat[3].num >= MYNEWT_VAL(BLE_STRESS_REPEAT)) { tx_stress_on_test_finish(3); return 0; } tx_stress_simple_connect(tx_stress_3_gap_event, tx_stress_ctx->cur_test_id); return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static int tx_stress_4_con_update(void) { int rc; /* With every next update at least one param must change. Otherwise no * event occurs and test will not be continued */ struct ble_gap_upd_params params = { .itvl_min = BLE_GAP_INITIAL_CONN_ITVL_MIN, .itvl_max = BLE_GAP_INITIAL_CONN_ITVL_MAX, .latency = BLE_GAP_INITIAL_CONN_LATENCY, /* So let's change e.g. timeout value. Put ...% 2 ? 1 : 2 to make sure * that value won't grow significantly and will be different with every * iteration. */ .supervision_timeout = BLE_GAP_INITIAL_SUPERVISION_TIMEOUT + (tx_stress_ctx->con_stat[4].prms_upd_num % 2 ? 1 : 2), .min_ce_len = BLE_GAP_INITIAL_CONN_MIN_CE_LEN, .max_ce_len = BLE_GAP_INITIAL_CONN_MAX_CE_LEN, }; rc = ble_gap_update_params(tx_stress_ctx->conn_handle, ¶ms); if (rc == BLE_HS_ENOTCONN) { MODLOG_DFLT(INFO, "Device disconnected. Connection update failed\n"); assert(0); } if (rc != 0) { MODLOG_DFLT(ERROR, "\033[0;31mError during connection update; " "rc=%d\033[0m\n", rc); assert(0); } return rc; } static int tx_stress_4_gap_event(struct ble_gap_event *event, void *arg) { int rc; switch (event->type) { case BLE_GAP_EVENT_CONNECT: ++tx_stress_ctx->con_stat[4].attempts_num; /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { MODLOG_DFLT(INFO, "Success to connect to device\n"); ++tx_stress_ctx->con_stat[4].num; tx_stress_ctx->conn_handle = event->connect.conn_handle; tx_stress_4_con_update(); } else { MODLOG_DFLT(INFO, "\033[0;31mError: connection attempt failed; " "status=%d\033[0m\n", event->connect.status); os_sem_release(&tx_stress_main_sem); } return 0; case BLE_GAP_EVENT_DISCONNECT: MODLOG_DFLT(INFO, "Disconnect; reason=%d \n", event->disconnect.reason); tx_stress_on_test_finish(4); return 0; case BLE_GAP_EVENT_CONN_UPDATE: if (event->conn_update.status != 0) { MODLOG_DFLT(INFO, "Connection update failed\n"); } else { MODLOG_DFLT(INFO, "Connection updated; num=%d\n", ++tx_stress_ctx->con_stat[4].prms_upd_num); console_printf("\033[0;32m>\033[0m"); } if (tx_stress_ctx->con_stat[4].prms_upd_num >= MYNEWT_VAL(BLE_STRESS_REPEAT)) { ble_gap_terminate(tx_stress_ctx->conn_handle, BLE_ERR_REM_USER_CONN_TERM); } else { /* Update connection. */ rc = tx_stress_4_con_update(); if (rc != 0) { MODLOG_DFLT(INFO, "\033[0;31mError: update fail; " "rc=%d\033[0m\n", rc); os_sem_release(&tx_stress_main_sem); } } return 0; case BLE_GAP_EVENT_CONN_UPDATE_REQ: MODLOG_DFLT(INFO, "Connection update request\n"); return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static int tx_stress_5_gap_event(struct ble_gap_event *event, void *arg) { switch (event->type) { case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { MODLOG_DFLT(INFO, "Success to connect to device\n"); ++tx_stress_ctx->con_stat[5].num; tx_stress_ctx->conn_handle = event->connect.conn_handle; } else { console_printf("\033[0;31mError: Update fail; " "status=%d\033[0m\n", event->connect.status); os_sem_release(&tx_stress_main_sem); } return 0; case BLE_GAP_EVENT_DISCONNECT: MODLOG_DFLT(INFO, "Disconnect; reason=%d \n", event->disconnect.reason); tx_stress_on_test_finish(5); return 0; case BLE_GAP_EVENT_CONN_UPDATE: if (event->conn_update.status != 0) { MODLOG_DFLT(INFO, "Connection update failed\n"); } else { MODLOG_DFLT(INFO, "Connection updated; num=%d\n", ++tx_stress_ctx->con_stat[5].prms_upd_num); console_printf("\033[0;32m>\033[0m"); } if (tx_stress_ctx->con_stat[5].prms_upd_num >= MYNEWT_VAL(BLE_STRESS_REPEAT)) { ble_gap_terminate(tx_stress_ctx->conn_handle, BLE_ERR_REM_USER_CONN_TERM); } return 0; case BLE_GAP_EVENT_CONN_UPDATE_REQ: MODLOG_DFLT(INFO, "Connection update request\n"); return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static int tx_stress_6_gap_event(struct ble_gap_event *event, void *arg) { static int start_id = 0; int use_case = 0; int adv_pattern_len; const uint8_t *adv_pattern; switch (event->type) { case BLE_GAP_EVENT_EXT_DISC: /* Instance 0 reserved for SWITCH advert. */ if (event->ext_disc.sid == 0) { return 0; } /* Check if advertiser is known rx device. */ if (memcmp(tx_stress_ctx->dev_addr.val, event->ext_disc.addr.val, 6) != 0) { return 0; } /* Return -1 if not first package of advert. */ use_case = tx_stress_find_test(&event->ext_disc); if (use_case > 0) { /* If first package of advert */ ++tx_stress_ctx->s6_rcv_adv_first; start_id = 0; adv_pattern = &event->ext_disc.data[29]; adv_pattern_len = event->ext_disc.length_data - 29; } else { if (start_id == 0) { return 0; } /* If not first package of advert */ adv_pattern = event->ext_disc.data; adv_pattern_len = event->ext_disc.length_data; } /* Check data pattern */ if (memcmp(adv_pattern, test_6_pattern + start_id, adv_pattern_len) != 0) { /* Pattern does not match. May lost some data or package. * Reset data pattern index. */ start_id = 0; return 0; } /* At the next adv data package, start comparing from this index.*/ start_id += adv_pattern_len; /* Check if last packet of advert. */ if (event->ext_disc.data_status == BLE_GAP_EXT_ADV_DATA_STATUS_COMPLETE) { /* Got all packets of advert. */ ++tx_stress_ctx->s6_rcv_adv_suc; MODLOG_DFLT(INFO, "Got all packets of advert. num=%d\n", tx_stress_ctx->s6_rcv_adv_suc); console_printf("\033[0;32m>\033[0m"); start_id = 0; if (tx_stress_ctx->s6_rcv_adv_suc >= MYNEWT_VAL(BLE_STRESS_REPEAT)) { /* Stop scanning. */ ble_gap_disc_cancel(); tx_stress_on_test_finish(6); } } return 0; case BLE_GAP_EVENT_DISC_COMPLETE: MODLOG_DFLT(INFO, "Discovery complete; reason=%d\n", event->disc_complete.reason); return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static void tx_stress_6_perform(void) { tx_stress_simple_scan(tx_stress_6_gap_event, 0); os_sem_pend(&tx_stress_main_sem, OS_TIMEOUT_NEVER); tx_stress_switch_test(); } static int tx_stress_7_phy_update(void) { int rc; uint8_t tx_phys_mask; uint8_t rx_phys_mask; ble_gap_read_le_phy(tx_stress_ctx->conn_handle, &tx_phys_mask, &rx_phys_mask); /* With every next update at least one param must change */ switch (rx_phys_mask) { case BLE_GAP_LE_PHY_1M_MASK: rx_phys_mask = BLE_GAP_LE_PHY_2M_MASK; break; case BLE_GAP_LE_PHY_2M_MASK: #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CODED_PHY) rx_phys_mask = BLE_GAP_LE_PHY_CODED_MASK; break; case BLE_GAP_LE_PHY_CODED_MASK: #endif rx_phys_mask = BLE_GAP_LE_PHY_1M_MASK; break; default: rx_phys_mask = BLE_GAP_LE_PHY_1M_MASK; break; } switch (tx_phys_mask) { case BLE_GAP_LE_PHY_1M_MASK: tx_phys_mask = BLE_GAP_LE_PHY_2M_MASK; break; case BLE_GAP_LE_PHY_2M_MASK: #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CODED_PHY) tx_phys_mask = BLE_GAP_LE_PHY_CODED_MASK; break; case BLE_GAP_LE_PHY_CODED_MASK: #endif tx_phys_mask = BLE_GAP_LE_PHY_1M_MASK; break; default: tx_phys_mask = BLE_GAP_LE_PHY_1M_MASK; break; } rc = ble_gap_set_prefered_le_phy(tx_stress_ctx->conn_handle, tx_phys_mask, rx_phys_mask, 0); if (rc == BLE_HS_ENOTCONN) { MODLOG_DFLT(INFO, "Device disconnected. Connection update failed\n"); return rc; } if (rc != 0) { MODLOG_DFLT(ERROR, "\033[0;31mError during PHY update; " "rc=%d\033[0m\n", rc); } return rc; } static int tx_stress_7_gap_event(struct ble_gap_event *event, void *arg) { int rc; switch (event->type) { case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { MODLOG_DFLT(INFO, "Success to connect to device\n"); ++tx_stress_ctx->con_stat[7].num; tx_stress_ctx->conn_handle = event->connect.conn_handle; tx_stress_7_phy_update(); } else { console_printf("\033[0;31mError: Update fail; " "status=%d\033[0m\n", event->connect.status); os_sem_release(&tx_stress_main_sem); } return 0; case BLE_GAP_EVENT_DISCONNECT: MODLOG_DFLT(INFO, "Disconnect; reason=%d \n", event->disconnect.reason); tx_stress_on_test_finish(7); return 0; case BLE_GAP_EVENT_CONN_UPDATE: MODLOG_DFLT(INFO, "Connection updated\n"); return 0; case BLE_GAP_EVENT_CONN_UPDATE_REQ: MODLOG_DFLT(INFO, "Connection update request\n"); return 0; case BLE_GAP_EVENT_PHY_UPDATE_COMPLETE: if (event->phy_updated.status != 0) { MODLOG_DFLT(INFO, "PHY update failed\n"); } else { MODLOG_DFLT(INFO, "PHY updated; num=%d; rx:%d, tx:%d\n", ++tx_stress_ctx->con_stat[7].phy_upd_num, event->phy_updated.rx_phy, event->phy_updated.tx_phy); console_printf("\033[0;32m>\033[0m"); } if (tx_stress_ctx->con_stat[7].phy_upd_num >= MYNEWT_VAL(BLE_STRESS_REPEAT)) { ble_gap_terminate(tx_stress_ctx->conn_handle, BLE_ERR_REM_USER_CONN_TERM); } else { /* Update connection. */ rc = tx_stress_7_phy_update(); if (rc != 0) { console_printf("\033[0;31mError: PHPY update fail; " "rc=%d\033[0m\n", event->phy_updated.status); assert(0); } } return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static int tx_stress_8_gap_event(struct ble_gap_event *event, void *arg) { switch (event->type) { case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { MODLOG_DFLT(INFO, "Success to connect to device\n"); ++tx_stress_ctx->con_stat[8].num; tx_stress_ctx->conn_handle = event->connect.conn_handle; } else { MODLOG_DFLT(INFO, "\033[0;31mError: connection attempt failed; " "status=%d\033[0m\n", event->connect.status); os_sem_release(&tx_stress_main_sem); } return 0; case BLE_GAP_EVENT_DISCONNECT: MODLOG_DFLT(INFO, "Disconnect; reason=%d \n", event->disconnect.reason); tx_stress_on_test_finish(8); return 0; case BLE_GAP_EVENT_CONN_UPDATE: if (event->conn_update.status != 0) { MODLOG_DFLT(INFO, "Connection update failed\n"); } else { MODLOG_DFLT(INFO, "Connection updated; num=%d\n", ++tx_stress_ctx->con_stat[8].prms_upd_num); } return 0; case BLE_GAP_EVENT_CONN_UPDATE_REQ: MODLOG_DFLT(INFO, "Connection update request\n"); return 0; case BLE_GAP_EVENT_PHY_UPDATE_COMPLETE: if (event->phy_updated.status != 0) { MODLOG_DFLT(INFO, "PHY update failed\n"); } else { MODLOG_DFLT(INFO, "PHY updated; num=%d\n", ++tx_stress_ctx->con_stat[8].phy_upd_num); console_printf("\033[0;32m>\033[0m"); } if (tx_stress_ctx->con_stat[8].phy_upd_num >= MYNEWT_VAL(BLE_STRESS_REPEAT)) { ble_gap_terminate(tx_stress_ctx->conn_handle, BLE_ERR_REM_USER_CONN_TERM); } return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static int tx_stress_9_gap_event(struct ble_gap_event *event, void *arg) { ble_addr_t addr; int test; switch (event->type) { case BLE_GAP_EVENT_EXT_DISC: /* Looking for next instance of test 9 advert. */ test = tx_stress_find_test(&event->ext_disc); /* To avoid messing by rest of test 9 events in queue, check if handle * filled */ if (test == 9 && tx_stress_ctx->conn_handle == 0xffff) { tx_stress_ctx->conn_handle = 0; ble_gap_disc_cancel(); tx_stress_ctx->dev_addr = event->ext_disc.addr; tx_stress_simple_connect(tx_stress_9_gap_event, tx_stress_ctx->cur_test_id); } return 0; case BLE_GAP_EVENT_DISC_COMPLETE: if (event->disc_complete.reason == 0 && !tx_stress_ctx->completed[9]) { console_printf("\033[0;31mScanning timeout\033[0m"); tx_stress_ctx->completed[9] = true; os_sem_release(&tx_stress_main_sem); return 0; } break; case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { MODLOG_DFLT(INFO, "Success to connect to device\n"); MODLOG_DFLT(INFO, "Connections num: %d\n", ++tx_stress_ctx->con_stat[9].num); console_printf("\033[0;32m>\033[0m"); /* Remember max number of handled connections */ if (tx_stress_ctx->con_stat[9].num > tx_stress_ctx->con_stat[9].max_num) { tx_stress_ctx->con_stat[9].max_num = tx_stress_ctx->con_stat[9].num; } } else { MODLOG_DFLT(INFO, "\033[0;31mError: connection attempt failed; " "status=%d\033[0m\n", event->connect.status); } break; case BLE_GAP_EVENT_DISCONNECT: MODLOG_DFLT(INFO, "Disconnect; reason=%d ", event->disconnect.reason); console_printf("\033[0;31mX\033[0m"); MODLOG_DFLT(INFO, "Connections num: %d\n", --tx_stress_ctx->con_stat[9].num); if (tx_stress_ctx->con_stat[9].num == 0) { os_sem_release(&tx_stress_main_sem); return 0; } break; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } if (tx_stress_ctx->completed[9]) { return 0; } /* End use case after specified number of scan times or max config number * of connections */ if (tx_stress_ctx->con_stat[9].attempts_num < MYNEWT_VAL(BLE_STRESS_REPEAT) && tx_stress_ctx->con_stat[9].max_num < MYNEWT_VAL(BLE_MAX_CONNECTIONS)) { if (ble_gap_disc_active() == 0) { /* Generate and set new random address */ ble_hs_id_gen_rnd(0, &addr); ble_hs_id_set_rnd(addr.val); tx_stress_ctx->conn_handle = 0xffff; /* Scan for next instance of the test. */ tx_stress_simple_scan(tx_stress_9_gap_event, 2000); } } else { tx_stress_ctx->completed[9] = true; os_sem_release(&tx_stress_main_sem); } return 0; } static void tx_stress_9_perform() { int i, rc; /* Scan for next instance of the test. */ tx_stress_simple_scan(tx_stress_9_gap_event, 2000); os_sem_pend(&tx_stress_main_sem, OS_TIMEOUT_NEVER); /* On use case finishing terminate all handled connections */ for (i = 0; i <= MYNEWT_VAL(BLE_MAX_CONNECTIONS); ++i) { rc = ble_gap_conn_find(i, NULL); if (rc == 0) { MODLOG_DFLT(INFO, "Terminating...\n"); ble_gap_terminate(i, BLE_ERR_REM_USER_CONN_TERM); } } os_sem_pend(&tx_stress_main_sem, OS_TIMEOUT_NEVER); tx_stress_on_test_finish(9); } static int tx_stress_10_l2cap_send(struct ble_l2cap_chan *chan, uint8_t *data, int data_len) { struct os_mbuf *data_buf; int rc; /* Get mbuf for adv data */ data_buf = os_msys_get_pkthdr(data_len, 0); assert(data != NULL); /* Fill mbuf with pattern data */ rc = os_mbuf_append(data_buf, data, data_len); if (rc) { os_mbuf_free_chain(data_buf); assert(0); } /* Send data with L2CAP */ rc = ble_l2cap_send(chan, data_buf); return rc; } void tx_stress_10_timer_ev_cb(struct os_event *ev) { assert(ev != NULL); if (tx_stress_ctx->rcv_data_flag) { return; } tx_stress_ctx->timeout_flag = true; MODLOG_DFLT(INFO, "L2CAP receiving timeout\n"); ble_gap_terminate(tx_stress_ctx->conn_handle, BLE_ERR_REM_USER_CONN_TERM); } static void tx_stress_10_l2cap_send_req() { int rc; /* Send a request to the RX device */ MODLOG_DFLT(INFO, "L2CAP sending request\n"); tx_stress_ctx->timeout_flag = false; tx_stress_ctx->rcv_data_flag = false; stress_start_timer(7000, tx_stress_10_timer_ev_cb); /* Get the sending begin time */ tx_stress_ctx->begin_us = os_get_uptime_usec(); /* Send anything just to give a signal to start sending data * by RX device */ rc = tx_stress_10_l2cap_send(tx_stress_ctx->chan, (uint8_t *) "S", sizeof("S")); assert(rc == 0); } static int tx_stress_10_l2cap_event(struct ble_l2cap_event *event, void *arg) { static int i = 0; int64_t us = 0; struct ble_l2cap_chan_info chan_info; switch (event->type) { case BLE_L2CAP_EVENT_COC_CONNECTED: /* A new L2CAP connection was established. */ if (event->connect.status == 0) { MODLOG_DFLT(INFO, "Established L2CAP connection\n"); tx_stress_ctx->chan = event->connect.chan; ble_l2cap_get_chan_info(event->connect.chan, &chan_info); MODLOG_DFLT(INFO, "LE COC connected, conn: %d, chan: 0x%08lx, scid: 0x%04x, " "dcid: 0x%04x, our_mtu: 0x%04x, peer_mtu: 0x%04x\n", event->connect.conn_handle, (uint32_t) event->connect.chan, chan_info.scid, chan_info.dcid, chan_info.our_l2cap_mtu, chan_info.peer_l2cap_mtu); tx_stress_10_l2cap_send_req(); } return 0; case BLE_L2CAP_EVENT_COC_DISCONNECTED: MODLOG_DFLT(INFO, "Remote device disconnected from L2CAP server\n"); return 0; case BLE_L2CAP_EVENT_COC_ACCEPT: stress_l2cap_coc_accept(event->accept.peer_sdu_size, event->accept.chan); return 0; case BLE_L2CAP_EVENT_COC_DATA_RECEIVED: /* Get the time of data receive */ tx_stress_ctx->end_us = os_get_uptime_usec(); /* And test after timeout */ if (tx_stress_ctx->timeout_flag) { ble_gap_terminate(tx_stress_ctx->conn_handle, BLE_ERR_REM_USER_CONN_TERM); return 0; } tx_stress_ctx->rcv_data_flag = true; stress_l2cap_coc_recv(event->receive.chan, event->receive.sdu_rx); /* Time of data sending */ us = tx_stress_ctx->end_us - tx_stress_ctx->begin_us; MODLOG_DFLT(INFO, "Time of receiving L2CAP data: %ld \n", tx_stress_ctx->end_us); /* Remember size of entire mbuf chain */ tx_stress_ctx->rcv_data_bytes = OS_MBUF_PKTLEN( event->receive.sdu_rx); MODLOG_DFLT(INFO, "Num of received bytes: %lld\n", tx_stress_ctx->rcv_data_bytes); /* Calculate the bit rate of this send */ tx_stress_ctx->s10_bit_rate = stress_calc_bit_rate(us, tx_stress_ctx->rcv_data_bytes); MODLOG_DFLT(INFO, "Bit rate: %d B/s\n", tx_stress_ctx->s10_bit_rate); /* Remember the sum of bytes and the time to calculate the average * bit rate. */ tx_stress_ctx->bytes_sum += tx_stress_ctx->rcv_data_bytes; tx_stress_ctx->time_sum += us; /* Remember max received MTU */ if (tx_stress_ctx->s10_max_mtu < tx_stress_ctx->rcv_data_bytes) { tx_stress_ctx->s10_max_mtu = tx_stress_ctx->rcv_data_bytes; } console_printf("\033[0;32m>\033[0m"); MODLOG_DFLT(INFO, "Loop nr: %d\n", ++i); tx_stress_10_l2cap_send_req(); return 0; case BLE_L2CAP_EVENT_COC_TX_UNSTALLED: MODLOG_DFLT(INFO, "L2CAP event unstalled\n"); return 0; default: MODLOG_DFLT(INFO, "Other L2CAP event occurs; rc=%d\n", event->type); return 0; } } static int tx_stress_10_gap_event(struct ble_gap_event *event, void *arg) { int rc; struct os_mbuf *sdu_rx; switch (event->type) { case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { MODLOG_DFLT(INFO, "Success to connect to device; num: %d\n", ++tx_stress_ctx->con_stat[10].num); sdu_rx = os_msys_get_pkthdr(STRESS_COC_MTU, 0); assert(sdu_rx != NULL); tx_stress_ctx->conn_handle = event->connect.conn_handle; rc = ble_l2cap_connect(event->connect.conn_handle, TEST_PSM, STRESS_COC_MTU, sdu_rx, tx_stress_10_l2cap_event, NULL); assert(rc == 0); } else { MODLOG_DFLT(INFO, "\033[0;31mError: connection attempt failed; " "status=%d\033[0m\n", event->connect.status); } return 0; case BLE_GAP_EVENT_DISCONNECT: tx_stress_ctx->s10_bit_rate = 1000000 * tx_stress_ctx->bytes_sum / tx_stress_ctx->time_sum; MODLOG_DFLT(INFO, "Average bit rate: %d B/s\n", tx_stress_ctx->s10_bit_rate); tx_stress_on_test_finish(10); return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static int tx_stress_11_gap_event(struct ble_gap_event *event, void *arg) { int test; switch (event->type) { case BLE_GAP_EVENT_EXT_DISC: /* Looking for next instance of test 9 advert. */ test = tx_stress_find_test(&event->ext_disc); /* To avoid messing by rest of test 9 events in queue, check if handle * filled */ if (test == 11 && tx_stress_ctx->conn_handle == 0xffff) { tx_stress_ctx->conn_handle = 0; ble_gap_disc_cancel(); tx_stress_ctx->dev_addr = event->ext_disc.addr; tx_stress_simple_connect(tx_stress_11_gap_event, tx_stress_ctx->cur_test_id); } return 0; case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { ++tx_stress_ctx->con_stat[11].num; MODLOG_DFLT(INFO, "Success to connect to device\n"); } else { MODLOG_DFLT(INFO, "\033[0;31mError: connection attempt failed; " "status=%d\033[0m\n", event->connect.status); break; } return 0; case BLE_GAP_EVENT_DISCONNECT: MODLOG_DFLT(INFO, "Disconnect; reason=%d \n", event->disconnect.reason); console_printf("\033[0;32m>\033[0m"); if (tx_stress_ctx->con_stat[11].num >= MYNEWT_VAL(BLE_STRESS_REPEAT)) { tx_stress_on_test_finish(11); return 0; } break; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } tx_stress_ctx->conn_handle = 0xffff; /* Scan for next instance of the test. */ tx_stress_simple_scan(tx_stress_11_gap_event, 750); return 0; } static int tx_stress_12_gap_event(struct ble_gap_event *event, void *arg) { switch (event->type) { case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { ++tx_stress_ctx->con_stat[12].num; MODLOG_DFLT(INFO, "Success to connect to device\n"); tx_stress_ctx->conn_handle = event->connect.conn_handle; } else { MODLOG_DFLT(INFO, "\033[0;31mError: connection attempt failed; " "status=%d\033[0m\n", event->connect.status); } return 0; case BLE_GAP_EVENT_DISCONNECT: MODLOG_DFLT(INFO, "Disconnect; reason=%d \n", event->disconnect.reason); /* Finish test after first disconnection */ tx_stress_on_test_finish(12); return 0; case BLE_GAP_EVENT_NOTIFY_RX: /* Received indication */ MODLOG_DFLT(INFO, "Notify RX event\n"); console_printf("\033[0;32m>\033[0m"); return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static int tx_stress_13_gap_event(struct ble_gap_event *event, void *arg) { switch (event->type) { case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { ++tx_stress_ctx->con_stat[13].num; MODLOG_DFLT(INFO, "Success to connect to device\n"); tx_stress_ctx->conn_handle = event->connect.conn_handle; } else { MODLOG_DFLT(INFO, "\033[0;31mError: connection attempt failed; " "status=%d\033[0m\n", event->connect.status); assert(0); } return 0; case BLE_GAP_EVENT_DISCONNECT: MODLOG_DFLT(INFO, "Disconnect; reason=%d \n", event->disconnect.reason); /* Finish test after disconnection */ tx_stress_on_test_finish(13); return 0; case BLE_GAP_EVENT_NOTIFY_RX: MODLOG_DFLT(INFO, "Notify RX event\n"); console_printf("\033[0;32m>\033[0m"); ++tx_stress_ctx->rcv_num; return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static int tx_stress_14_subs_cb(uint16_t conn_handle, const struct ble_gatt_error *error, struct ble_gatt_attr *attr, void *arg) { struct os_mbuf *om; bool *sub; int rc; assert(error->status == 0); /* If the first subscription after finding cccd */ if (arg == NULL) { return 0; } sub = (bool *)arg; /* Enable notifications */ if (*sub == 0) { *sub = true; om = ble_hs_mbuf_from_flat((uint8_t[]) {0x01, 0x00}, 2); tx_stress_ctx->begin_us = tx_stress_ctx->end_us; rc = ble_gattc_write(tx_stress_ctx->conn_handle, tx_stress_ctx->dsc_handle, om, tx_stress_14_subs_cb, arg); assert(rc == 0); } return 0; } static void tx_stress_14_disc_cccd_fn(struct stress_gatt_search_ctx *search_ctx) { int rc; struct os_mbuf *om; MODLOG_DFLT(INFO, "CCCD found\n"); /* Enable notifications */ om = ble_hs_mbuf_from_flat((uint8_t[]) {0x01, 0x00}, 2); tx_stress_ctx->begin_us = os_get_uptime_usec(); tx_stress_ctx->dsc_handle = search_ctx->dsc_handle; rc = ble_gattc_write(tx_stress_ctx->conn_handle, tx_stress_ctx->dsc_handle, om, tx_stress_14_subs_cb, NULL); assert(rc == 0); } static int tx_stress_14_gap_event(struct ble_gap_event *event, void *arg) { int64_t us = 0; struct os_mbuf *om; int rc; static bool subscribed = true; switch (event->type) { case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { ++tx_stress_ctx->con_stat[14].num; MODLOG_DFLT(INFO, "Success to connect to device\n"); tx_stress_ctx->conn_handle = event->connect.conn_handle; /* Find CCCD handle (with default UUID16 = 0x2902) */ stress_find_dsc_handle(event->connect.conn_handle, BLE_UUID16_DECLARE(STRESS_GATT_UUID), BLE_UUID16_DECLARE(STRESS_GATT_NOTIFY_UUID), BLE_UUID16_DECLARE(0x2902), &tx_stress_14_disc_cccd_fn); } else { MODLOG_DFLT(INFO, "\033[0;31mError: connection attempt failed; " "status=%d\033[0m\n", event->connect.status); assert(0); } return 0; case BLE_GAP_EVENT_DISCONNECT: MODLOG_DFLT(INFO, "Disconnect; reason=%d \n", event->disconnect.reason); /* Calc average notifying time */ if (tx_stress_ctx->rcv_num > 0) { tx_stress_ctx->s14_notif_time = tx_stress_ctx->time_sum / tx_stress_ctx->rcv_num; } MODLOG_DFLT(INFO, "Average notification time: %d\n", tx_stress_ctx->s14_notif_time); /* Finish test after first disconnection */ tx_stress_on_test_finish(14); return 0; case BLE_GAP_EVENT_NOTIFY_RX: tx_stress_ctx->end_us = os_get_uptime_usec(); MODLOG_DFLT(INFO, "Notify RX event\n"); /* Time of data sending */ us = tx_stress_ctx->end_us - tx_stress_ctx->begin_us; MODLOG_DFLT(INFO, "Notification time: %lld\n us", us); tx_stress_ctx->time_sum += us; console_printf("\033[0;32m>\033[0m"); /* Perform use case specified number of times */ if (++tx_stress_ctx->rcv_num >= MYNEWT_VAL(BLE_STRESS_REPEAT)) { rc = ble_gap_terminate(event->notify_rx.conn_handle, BLE_ERR_REM_USER_CONN_TERM); MODLOG_DFLT(INFO, "rc=%d\n", rc); assert(rc == 0); return 0; } /* Disable notifications */ subscribed = false; om = ble_hs_mbuf_from_flat( (uint8_t[]) {0x00, 0x00}, 2); rc = ble_gattc_write(tx_stress_ctx->conn_handle, tx_stress_ctx->dsc_handle, om, tx_stress_14_subs_cb, &subscribed); assert(rc == 0); return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static int tx_stress_15_write_cb(uint16_t conn_handle, const struct ble_gatt_error *error, struct ble_gatt_attr *attr, void *arg) { /* Disconnect */ ble_gap_terminate(conn_handle, BLE_ERR_REM_USER_CONN_TERM); console_printf("\033[0;32m>\033[0m"); return 0; } static void tx_stress_15_disc_chr_fn(struct stress_gatt_search_ctx *search_ctx) { int rc; struct os_mbuf *om; /* Send some data */ MODLOG_DFLT(INFO, "Write to chr\n"); om = ble_hs_mbuf_from_flat(test_6_pattern, 20); rc = ble_gattc_write(tx_stress_ctx->conn_handle, search_ctx->chr_start_handle, om, tx_stress_15_write_cb, NULL); assert(rc == 0); } static int tx_stress_15_gap_event(struct ble_gap_event *event, void *arg) { switch (event->type) { case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ if (event->connect.status == 0) { MODLOG_DFLT(INFO, "Success to connect to device; num: %d\n", ++tx_stress_ctx->con_stat[15].num); tx_stress_ctx->conn_handle = event->connect.conn_handle; /* Find characteristic handle */ stress_find_chr_handle(event->connect.conn_handle, BLE_UUID16_DECLARE(STRESS_GATT_UUID), BLE_UUID16_DECLARE(STRESS_GATT_WRITE_UUID), &tx_stress_15_disc_chr_fn); } else { MODLOG_DFLT(INFO, "\033[0;31mError: connection attempt failed; " "status=%d\033[0m\n", event->connect.status); assert(0); } return 0; case BLE_GAP_EVENT_DISCONNECT: /* Perform use case specified number of times */ if (tx_stress_ctx->con_stat[15].num >= MYNEWT_VAL(BLE_STRESS_REPEAT)) { tx_stress_on_test_finish(15); return 0; } /* Reconnect */ tx_stress_simple_connect(tx_stress_15_gap_event, 15); return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static int scan_for_test_gap_event(struct ble_gap_event *event, void *arg) { int use_case; int rc; switch (event->type) { case BLE_GAP_EVENT_EXT_DISC: /* Check if caught advert contains known UUID128. The UUID128 * contains the ID of test use case to be executed. */ use_case = tx_stress_find_test(&event->ext_disc); if (use_case > 0) { rc = ble_gap_disc_cancel(); tx_stress_ctx->dev_addr = event->ext_disc.addr; /* After discovery cancel there are still some events in queue. */ if (rc == 0) { tx_stress_use_case = use_case; /* Add token to semaphore. Main task will start the test. */ os_sem_release(&tx_stress_main_sem); } } return 0; case BLE_GAP_EVENT_DISC_COMPLETE: /* On timeout */ tx_stress_ctx->scan_timeout = true; console_printf("\033[1;36mDiscover complete\033[0m\n"); os_sem_release(&tx_stress_main_sem); return 0; default: MODLOG_DFLT(INFO, "Other event occurs=%d\n", event->type); return 0; } } static void tx_stress_test_perform(int test_num) { /* Perform every test only once */ // if (test_num <= 0 || tx_stress_ctx->completed[test_num] == true) { // return; // } tx_stress_ctx->cur_test_id = test_num; tx_stress_ctx->completed[test_num] = false; tx_stress_ctx->conn_handle = 0xffff; console_printf("\033[1;36mStart test num %d - ", test_num); /* Start test */ switch (test_num) { case 0: return; case 1: console_printf("Stress Connect -> Connect Cancel\033[0m\n"); tx_stress_1_test(); break; case 2: console_printf("Stress Connect/Disconnect legacy\033[0m\n"); tx_stress_simple_connect(&tx_stress_2_gap_event, 2); break; case 3: console_printf("Stress Connect/Disconnect ext adv\033[0m\n"); tx_stress_simple_connect(&tx_stress_3_gap_event, 3); break; case 4: console_printf("Stress connection params update (TX)\033[0m\n"); tx_stress_simple_connect(&tx_stress_4_gap_event, 4); break; case 5: console_printf("Stress connection params update (RX)\033[0m\n"); tx_stress_simple_connect(&tx_stress_5_gap_event, 5); break; case 6: console_printf("Stress Scan\033[0m\n"); tx_stress_6_perform(); break; case 7: console_printf("Stress PHY Update (TX)\033[0m\n"); tx_stress_simple_connect(&tx_stress_7_gap_event, 7); break; case 8: console_printf("Stress PHY Update (RX)\033[0m\n"); tx_stress_simple_connect(&tx_stress_8_gap_event, 8); break; case 9: console_printf("Stress multi connection\033[0m\n"); tx_stress_9_perform(); break; case 10: console_printf("Stress L2CAP send\033[0m\n"); tx_stress_simple_connect(&tx_stress_10_gap_event, 10); break; case 11: console_printf("Stress Advertise/Connect/Disconnect\033[0m\n"); tx_stress_simple_connect(&tx_stress_11_gap_event, 11); break; case 12: console_printf("Stress GATT indication\033[0m\n"); tx_stress_simple_connect(&tx_stress_12_gap_event, 12); break; case 13: console_printf("Stress GATT notification\033[0m\n"); tx_stress_simple_connect(&tx_stress_13_gap_event, 13); break; case 14: console_printf("Stress GATT Subscribe/Notify/Unsubscribe\033[0m\n"); tx_stress_simple_connect(&tx_stress_14_gap_event, 14); break; case 15: console_printf("Stress Connect/Send/Disconnect\033[0m\n"); tx_stress_simple_connect(&tx_stress_15_gap_event, 15); break; default: console_printf("\033[0;31mFound test, but do not know how to perform." "\033[0m\n"); assert(0); } /* Wait for the test to finish. Then 1 token will be released * allowing to pass through semaphore. */ os_sem_pend(&tx_stress_main_sem, OS_TIMEOUT_NEVER); stress_clear_ctx_reusable_var(tx_stress_ctx); } static void tx_stress_read_command_cb(void) { console_printf("Start testing\n"); os_sem_release(&tx_stress_main_sem); } static void tx_stress_main_task_fn(void *arg) { int rc; tx_stress_ctx = &tx_stress_ctxD; console_printf("\033[1;36mTX device\033[0m\n"); console_printf("Press ENTER to start: \n"); console_init(&tx_stress_read_command_cb); /* Waite for pressing ENTER in console */ os_sem_pend(&tx_stress_main_sem, OS_TIMEOUT_NEVER); /* Init semaphore with 0 tokens. */ rc = os_sem_init(&tx_stress_main_sem, 0); assert(rc == 0); /* Start test 1 - Connect/Connect cancel */ //tx_stress_test_perform(1); while (1) { console_printf("\033[0;36mStart scan for test\033[0m\n"); /* Scan for known UUID128 of one of the stress tests. */ tx_stress_simple_scan(scan_for_test_gap_event, 2000); /* Wait for the scan to find the test. Then 1 token will be * released allowing to pass through semaphore. */ os_sem_pend(&tx_stress_main_sem, OS_TIMEOUT_NEVER); if (tx_stress_ctx->scan_timeout) { break; } /* Start test. */ tx_stress_test_perform(tx_stress_use_case); tx_stress_use_case = -1; } /* Print tests results */ com_stress_print_report(tx_stress_ctx); /* Task should never return */ while (1) { /* Delay used only to prevent watchdog to reset the device. */ os_time_delay(os_time_ms_to_ticks32(2000)); } } void tx_stress_start_auto() { /* Start task that will run all stress tests one by one. */ os_task_init(&tx_stress_main_task, "tx_stress_main_task", tx_stress_main_task_fn, NULL, TX_STRESS_MAIN_TASK_PRIO, OS_WAIT_FOREVER, tx_stress_main_task_stack, TX_STRESS_MAIN_TASK_STACK_SIZE); }