/*
|
* 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 <host/ble_gap.h>
|
#include <console/console.h>
|
#include <host/util/util.h>
|
#include <host/ble_l2cap.h>
|
#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);
|
}
|
