nimble: Add apps/blestress

App runs BLE Stress Tests.

apps/blestress/README.md

@@ -0,0 +1,201 @@
+BLE Stress Tests
+
+******************************************************************************
+    QUICK TIPS:
+    You need 2 controllers supported by MyNewt. One will become TX device,
+    the other will become RX device.
+
+    1. Set role (TX=0, RX=1) for current device in syscfg.yml
+        BLE_STRESS_TEST_ROLE: 1
+
+       The RX has LED2 turned on.
+
+    2. Set (in syscfg.yml) number of times to repeat each tested action
+       in use case, e.g. do 1000 times connect/disconnect to complete use case.
+        RX_STRESS_REPEAT: 1000
+
+    3. To perform only specific test, go to rx_stress.c,
+       find definition of rx_stress_main_task_fn(void *arg) and in place of
+       for-loop just paste function rx_stress_start(i), where i is id of test.
+
+******************************************************************************
+
+No | Use case
+-----------------------------------------------------------------------------
+ 1 | Stress Connect -> Connect Cancel - repeat 1000
+   | RX: Nothing
+   | TX: Connect/Connect cancel
+   |
+ 2 | Stress Connect/Disconnect legacy - repeat 1000
+   | RX: Advertise legacy
+   | TX: Connect/Disconnect
+   |
+ 3 | Stress Connect/Disconnect ext adv - repeat 1000
+   | RX: Advertise Ext
+   | TX: Connect/Disconnect
+   |
+ 4 | Stress connection params update (TX) - (1000)
+   | RX: Advertise
+   | TX: Connect/Connect param update
+   |
+ 5 | Stress connection params update (RX) - (1000)
+   | RX: Advertise/Connect param update
+   | TX: Connect
+   |
+ 6 | Stress Scan
+   | RX: Advertise a known data pattern
+   | TX: Scan and check received data with pattern
+   |
+ 7 | Stress PHY Update (TX) - (1000)
+   | RX: Advertise
+   | TX: Connect/Phy update
+   |
+ 8 | Stress PHY update (RX) - (1000)
+   | RX: Advertise/Phy update
+   | TX: Connect
+   |
+ 9 | Stress multi connection
+   | RX: Advertise Ext
+   | TX: Establish and maintain as many instances as possible
+   |
+10 | Stress L2CAP send
+   | RX: Send 64kB of data with L2CAP
+   | TX: Measure bit rate and max received data MTU
+   |
+11 | Stress Advertise/Connect/Continue Adv/Disconnect
+   | RX: Advertise Ext/Continue same advertise after connect
+   | TX: Connect
+   |
+12 | Stress GATT indicating
+   | RX: Indicate
+   | TX: Receive indication. Measure average time of indicating.
+   |
+13 | Stress GATT notification
+   | RX: Notify. Measure average time of notifying.
+   | TX: Count the number of received notification.
+   |
+14 | Stress GATT Subscribe/Notify/Unsubscribe
+   | RX: Notify on subscribe
+   | TX: Measure the average time from sending a subscription request
+   |     to receiving a notification.
+   |
+15 | Stress Connect/Send/Disconnect
+   | RX: Advertise/Send via ATT/Disconnect
+   | TX: Receive notification. Measure time of notifying.
+
+******************************************************************************
+   Concept:
+   The RX device advertises data containing a UUID128 of test use case that
+   should be performed. The TX device scan for known UUIDs, when it finds,
+   adapts to the advertised use case and runs a test.
+
+   Stress Task vs Semaphore:
+   The rx_stress_start_auto function starts main stress test task that runs
+   all stress tests one by one. The tests are based on event handling, so to
+   synchronize main task with events, a semaphore is used. On use case start
+   there is 0 tokens for semaphore. After main task starts one of use cases,
+   it comes across a semaphore and has to wait. When use case is completed,
+   1 token is released, so main task can use it to pass through semaphore.
+   The tx_stress_start_auto function works analogically.
+
+
+   Newt target set example:
+    rymek@rymek:~/projects/bletiny_proj$ newt target show bletest_tx
+    targets/bletest_tx
+        app=@apache-mynewt-nimble/apps/blestress
+        bsp=@apache-mynewt-core/hw/bsp/nordic_pca10056
+        build_profile=debug
+        syscfg=BLE_STRESS_TEST_ROLE=0
+    rymek@rymek:~/projects/bletiny_proj$ newt target show bletest_rx
+     targets/bletest_rx
+        app=@apache-mynewt-nimble/apps/blestress
+        bsp=@apache-mynewt-core/hw/bsp/nordic_pca10056
+        build_profile=debug
+        syscfg=BLE_STRESS_TEST_ROLE=1
+
+
+   Example of expected logs on TX side(LOG_LEVEL > 1):
+     Start test num 1
+     >>>>>>>>>>>>>>>>>>>> Stress test 1 completed
+     Start scan for test
+     Start test num 2
+     >>>>>>>>>>>>>>>>>>>> Stress test 2 completed
+     Start scan for test
+     Start test num 3
+     >>>>>>>>>>>>>>>>>>>> Stress test 3 completed
+     Start scan for test
+     Start test num 4
+     >>>>>>>>>>>>>>>>>>>> Stress test 4 completed
+     Start scan for test
+     Start test num 5
+     >>>>>>>>>>>>>>>>>>>> Stress test 5 completed
+     Start scan for test
+     Start test num 6
+     >>>>>>>>>>>>>>>>>>>> Stress test 6 completed
+     Start scan for test
+     Start test num 7
+     >>>>>>>>>>>>>>>>>>>> Stress test 7 completed
+     Start scan for test
+     Start test num 8
+     >>>>>>>>>>>>>>>>>>>> Stress test 8 completed
+     All tests completed
+     Tests results:
+     Use case 1 - Stress Connect -> Connect Cancel:
+     Con attempts = 20
+     Con success = 0
+     Use case 2 - Stress Connect/Disconnect legacy:
+     Con attempts = 20
+     Con success = 20
+     Use case 3 - Stress Connect/Disconnect ext adv:
+     Con attempts = 20
+     Con success = 20
+     Use case 4 - Stress connection params update (TX):
+     Params updates = 20
+     Use case 5 - Stress connection params update (RX):
+     Params updates = 20
+     Use case 6 - Stress Scan:
+     Received first packets = 20
+     Received all packets = 20
+     Use case 7 - Stress PHY Update (TX):
+     PHY updates = 20
+     Use case 8 - Stress Connect -> Connect Cancel:
+     PHY updates = 20
+
+
+   Example of expected logs on RX side(LOG_LEVEL > 1):
+     Start test num 2
+     >>>>>>>>>>>>>>>>>>>> Stress test 2 completed
+     Start test num 3
+     >>>>>>>>>>>>>>>>>>>> Stress test 3 completed
+     Start test num 4
+     >>>>>>>>>>>>>>>>>>>> Stress test 4 completed
+     Start test num 5
+     >>>>>>>>>>>>>>>>>>>> Stress test 5 completed
+     Start test num 6
+     Received signal to switch test
+     Start test num 7
+     >>>>>>>>>>>>>>>>>>>> Stress test 7 completed
+     Start test num 8
+     >>>>>>>>>>>>>>>>>>>> Stress test 8 completed
+     All tests completed
+     Tests results:
+     Use case 1 - Stress Connect -> Connect Cancel:
+     Con attempts = 0
+     Con success = 0
+     Use case 2 - Stress Connect/Disconnect legacy:
+     Con attempts = 20
+     Con success = 20
+     Use case 3 - Stress Connect/Disconnect ext adv:
+     Con attempts = 20
+     Con success = 20
+     Use case 4 - Stress connection params update (TX):
+     Params updates = 20
+     Use case 5 - Stress connection params update (RX):
+     Params updates = 20
+     Use case 6 - Stress Scan:
+     Received first packets = 0
+     Received all packets = 0
+     Use case 7 - Stress PHY Update (TX):
+     PHY updates = 20
+     Use case 8 - Stress Connect -> Connect Cancel:
+     PHY updates = 20

apps/blestress/pkg.yml

@@ -0,0 +1,39 @@
+#
+# 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.
+#
+
+pkg.name: "apps/blestress"
+pkg.type: app
+pkg.description: "Stress tests sample application."
+pkg.keywords:
+
+pkg.deps:
+    - "@mcuboot/boot/bootutil"
+    - "@apache-mynewt-core/sys/log/modlog"
+    - "@apache-mynewt-core/kernel/os"
+    - "@apache-mynewt-core/sys/console/full"
+    - "@apache-mynewt-core/sys/log/full"
+    - "@apache-mynewt-core/sys/stats/full"
+    - "@apache-mynewt-core/sys/id"
+    - "@apache-mynewt-nimble/nimble/controller"
+    - "@apache-mynewt-nimble/nimble/host"
+    - "@apache-mynewt-nimble/nimble/host/util"
+    - "@apache-mynewt-nimble/nimble/host/services/gap"
+    - "@apache-mynewt-nimble/nimble/host/services/gatt"
+    - "@apache-mynewt-nimble/nimble/host/store/ram"
+    - "@apache-mynewt-nimble/nimble/transport/ram"

apps/blestress/src/main.c

@@ -0,0 +1,99 @@
+/*
+ * 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 <assert.h>
+#include <stdio.h>
+#include "os/mynewt.h"
+#include "config/config.h"
+#include "bsp.h"
+#include "hal/hal_gpio.h"
+
+/* BLE */
+#include "nimble/ble.h"
+#include "host/ble_hs.h"
+#include "host/util/util.h"
+#include "services/gap/ble_svc_gap.h"
+
+/* Application-specified header. */
+#include "rx_stress.h"
+#include "tx_stress.h"
+#include "stress_gatt.h"
+
+static void
+stress_test_on_reset(int reason)
+{
+    MODLOG_DFLT(ERROR, "Resetting state; reason=%d\n", reason);
+}
+
+static void
+stress_test_on_sync(void)
+{
+    int rc;
+
+    /* Make sure we have proper identity address set (public preferred) */
+    rc = ble_hs_util_ensure_addr(1);
+    assert(rc == 0);
+
+#if MYNEWT_VAL(BLE_STRESS_TEST_ROLE)
+    rx_stress_start_auto();
+#else
+    tx_stress_start_auto();
+#endif
+}
+
+/**
+ * main
+ *
+ * The main task for the project. This function initializes the packages,
+ * then starts serving events from default event queue.
+ *
+ * @return int NOTE: this function should never return!
+ */
+int
+main(void)
+{
+    int rc;
+
+    sysinit();
+
+    ble_hs_cfg.reset_cb = stress_test_on_reset;
+    ble_hs_cfg.sync_cb = stress_test_on_sync;
+    ble_hs_cfg.store_status_cb = ble_store_util_status_rr;
+
+    /* Please do not change name. Otherwise some tests could fail. */
+    rc = ble_svc_gap_device_name_set("STRESS");
+    assert(rc == 0);
+
+    conf_load();
+
+    rc = gatt_svr_init();
+    assert(rc == 0);
+
+#if MYNEWT_VAL(BLE_STRESS_TEST_ROLE)
+    /* RX device */
+    ble_hs_cfg.gatts_register_cb = gatt_svr_register_cb;
+    hal_gpio_init_out(LED_2, 1);
+    hal_gpio_toggle(LED_2);
+#endif
+
+    while (1) {
+        os_eventq_run(os_eventq_dflt_get());
+    }
+    return 0;
+}

apps/blestress/src/misc.c

@@ -0,0 +1,224 @@
+/*
+ * 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 "misc.h"
+
+void
+rand_bytes(uint8_t *data, int len) {
+    int i;
+
+    for (i = 0; i < len; ++i) {
+        data[i] = (uint8_t) rand() % UINT8_MAX;
+    }
+}
+
+/**
+ * Utility function to log an array of bytes.
+ */
+void
+print_bytes(const uint8_t *bytes, int len)
+{
+    int i;
+
+    for (i = 0; i < len; i++) {
+        MODLOG_DFLT(DEBUG, "%s0x%02x", i != 0 ? ":" : "", bytes[i]);
+    }
+}
+
+void
+print_addr(const void *addr)
+{
+    const uint8_t *u8p;
+
+    u8p = addr;
+    MODLOG_DFLT(DEBUG, "%02x:%02x:%02x:%02x:%02x:%02x",
+                u8p[5], u8p[4], u8p[3], u8p[2], u8p[1], u8p[0]);
+}
+
+void
+print_mbuf(const struct os_mbuf *om)
+{
+    while (om != NULL) {
+        print_bytes(om->om_data, om->om_len);
+        om = SLIST_NEXT(om, om_next);
+
+        if(om == NULL) {
+            return;
+        }
+
+        /* Separate buf fields with colon to maintain continuity */
+        MODLOG_DFLT(DEBUG, ":");
+    }
+}
+
+char *
+addr_str(const void *addr)
+{
+    /* 6 bytes of MAC address * 2 signs for each byte in string + 5 colons to
+     * separate bytes + 1 byte for null-character appended by sprintf
+     */
+    static char buf[6 * 2 + 5 + 1];
+    const uint8_t *u8p;
+
+    u8p = addr;
+    sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x",
+            u8p[5], u8p[4], u8p[3], u8p[2], u8p[1], u8p[0]);
+
+    return buf;
+}
+
+void
+print_uuid(const ble_uuid_t *uuid)
+{
+    char buf[BLE_UUID_STR_LEN];
+
+    MODLOG_DFLT(DEBUG, "%s", ble_uuid_to_str(uuid, buf));
+}
+
+/**
+ * Logs information about a connection to the console.
+ */
+void
+print_conn_desc(const struct ble_gap_conn_desc *desc)
+{
+    MODLOG_DFLT(DEBUG, "handle=%d our_ota_addr_type=%d our_ota_addr=%s ",
+                desc->conn_handle, desc->our_ota_addr.type,
+                addr_str(desc->our_ota_addr.val));
+    MODLOG_DFLT(DEBUG, "our_id_addr_type=%d our_id_addr=%s ",
+                desc->our_id_addr.type, addr_str(desc->our_id_addr.val));
+    MODLOG_DFLT(DEBUG, "peer_ota_addr_type=%d peer_ota_addr=%s ",
+                desc->peer_ota_addr.type, addr_str(desc->peer_ota_addr.val));
+    MODLOG_DFLT(DEBUG, "peer_id_addr_type=%d peer_id_addr=%s ",
+                desc->peer_id_addr.type, addr_str(desc->peer_id_addr.val));
+    MODLOG_DFLT(DEBUG, "conn_itvl=%d conn_latency=%d supervision_timeout=%d "
+                       "encrypted=%d authenticated=%d bonded=%d",
+                desc->conn_itvl, desc->conn_latency,
+                desc->supervision_timeout,
+                desc->sec_state.encrypted,
+                desc->sec_state.authenticated,
+                desc->sec_state.bonded);
+}
+
+void
+print_adv_fields(const struct ble_hs_adv_fields *fields)
+{
+    char s[BLE_HS_ADV_MAX_SZ];
+    const uint8_t *u8p;
+    int i;
+
+    if (fields->flags != 0) {
+        MODLOG_DFLT(DEBUG, "    flags=0x%02x\n", fields->flags);
+    }
+
+    if (fields->uuids16 != NULL) {
+        MODLOG_DFLT(DEBUG, "    uuids16(%scomplete)=",
+                    fields->uuids16_is_complete ? "" : "in");
+        for (i = 0; i < fields->num_uuids16; i++) {
+            print_uuid(&fields->uuids16[i].u);
+            MODLOG_DFLT(DEBUG, " ");
+        }
+        MODLOG_DFLT(DEBUG, "\n");
+    }
+
+    if (fields->uuids32 != NULL) {
+        MODLOG_DFLT(DEBUG, "    uuids32(%scomplete)=",
+                    fields->uuids32_is_complete ? "" : "in");
+        for (i = 0; i < fields->num_uuids32; i++) {
+            print_uuid(&fields->uuids32[i].u);
+            MODLOG_DFLT(DEBUG, " ");
+        }
+        MODLOG_DFLT(DEBUG, "\n");
+    }
+
+    if (fields->uuids128 != NULL) {
+        MODLOG_DFLT(DEBUG, "    uuids128(%scomplete)=",
+                    fields->uuids128_is_complete ? "" : "in");
+        for (i = 0; i < fields->num_uuids128; i++) {
+            print_uuid(&fields->uuids128[i].u);
+            MODLOG_DFLT(DEBUG, " ");
+        }
+        MODLOG_DFLT(DEBUG, "\n");
+    }
+
+    if (fields->name != NULL) {
+        assert(fields->name_len < sizeof s - 1);
+        memcpy(s, fields->name, fields->name_len);
+        s[fields->name_len] = '\0';
+        MODLOG_DFLT(DEBUG, "    name(%scomplete)=%s\n",
+                    fields->name_is_complete ? "" : "in", s);
+    }
+
+    if (fields->tx_pwr_lvl_is_present) {
+        MODLOG_DFLT(DEBUG, "    tx_pwr_lvl=%d\n", fields->tx_pwr_lvl);
+    }
+
+    if (fields->slave_itvl_range != NULL) {
+        MODLOG_DFLT(DEBUG, "    slave_itvl_range=");
+        print_bytes(fields->slave_itvl_range, BLE_HS_ADV_SLAVE_ITVL_RANGE_LEN);
+        MODLOG_DFLT(DEBUG, "\n");
+    }
+
+    if (fields->svc_data_uuid16 != NULL) {
+        MODLOG_DFLT(DEBUG, "    svc_data_uuid16=");
+        print_bytes(fields->svc_data_uuid16, fields->svc_data_uuid16_len);
+        MODLOG_DFLT(DEBUG, "\n");
+    }
+
+    if (fields->public_tgt_addr != NULL) {
+        MODLOG_DFLT(DEBUG, "    public_tgt_addr=");
+        u8p = fields->public_tgt_addr;
+        for (i = 0; i < fields->num_public_tgt_addrs; i++) {
+            MODLOG_DFLT(DEBUG, "public_tgt_addr=%s ", addr_str(u8p));
+            u8p += BLE_HS_ADV_PUBLIC_TGT_ADDR_ENTRY_LEN;
+        }
+        MODLOG_DFLT(DEBUG, "\n");
+    }
+
+    if (fields->appearance_is_present) {
+        MODLOG_DFLT(DEBUG, "    appearance=0x%04x\n", fields->appearance);
+    }
+
+    if (fields->adv_itvl_is_present) {
+        MODLOG_DFLT(DEBUG, "    adv_itvl=0x%04x\n", fields->adv_itvl);
+    }
+
+    if (fields->svc_data_uuid32 != NULL) {
+        MODLOG_DFLT(DEBUG, "    svc_data_uuid32=");
+        print_bytes(fields->svc_data_uuid32, fields->svc_data_uuid32_len);
+        MODLOG_DFLT(DEBUG, "\n");
+    }
+
+    if (fields->svc_data_uuid128 != NULL) {
+        MODLOG_DFLT(DEBUG, "    svc_data_uuid128=");
+        print_bytes(fields->svc_data_uuid128, fields->svc_data_uuid128_len);
+        MODLOG_DFLT(DEBUG, "\n");
+    }
+
+    if (fields->uri != NULL) {
+        MODLOG_DFLT(DEBUG, "    uri=");
+        print_bytes(fields->uri, fields->uri_len);
+        MODLOG_DFLT(DEBUG, "\n");
+    }
+
+    if (fields->mfg_data != NULL) {
+        MODLOG_DFLT(DEBUG, "    mfg_data=");
+        print_bytes(fields->mfg_data, fields->mfg_data_len);
+        MODLOG_DFLT(DEBUG, "\n");
+    }
+}

apps/blestress/src/misc.h

@@ -0,0 +1,54 @@
+/*
+ * 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.
+ */
+
+#ifndef BLE_TGT_MISC_H
+#define BLE_TGT_MISC_H
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include "host/ble_hs.h"
+#include "host/ble_uuid.h"
+#include "host/ble_hs_adv.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void rand_bytes(uint8_t *data, int len);
+
+void print_bytes(const uint8_t *bytes, int len);
+
+void print_addr(const void *addr);
+
+void print_mbuf(const struct os_mbuf *om);
+
+char *addr_str(const void *addr);
+
+void print_uuid(const ble_uuid_t *uuid);
+
+void print_conn_desc(const struct ble_gap_conn_desc *desc);
+
+void print_adv_fields(const struct ble_hs_adv_fields *fields);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //BLE_TGT_MISC_H

apps/blestress/src/rx_stress.h

@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+
+#ifndef _BLE_STRESS_RX_H
+#define _BLE_STRESS_RX_H
+
+#include <assert.h>
+#include <string.h>
+#include <console/console.h>
+#include <errno.h>
+#include <nrfx/hal/nrf_aar.h>
+
+/* BLE */
+#include "nimble/ble.h"
+#include "host/ble_hs.h"
+#include "services/gap/ble_svc_gap.h"
+#include "host/ble_gap.h"
+#include <host/ble_l2cap.h>
+
+#include "misc.h"
+#include "stress.h"
+#include "stress_gatt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Executes stress tests one by one.
+ */
+void rx_stress_start_auto();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_BLE_STRESS_RX_H

apps/blestress/src/stress.c

@@ -0,0 +1,389 @@
+/*
+ * 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 "stress.h"
+
+void
+com_stress_print_report(const struct com_stress_test_ctx *test_ctxs)
+{
+    console_printf("\033[0;32mAll tests completed\033[0m\n");
+    console_printf("Tests results:\n");
+
+    console_printf(
+        "\033[0;33mUse case 1 - Stress Connect -> Connect Cancel: \n\033[0m");
+    console_printf("Con attempts = %d\n", test_ctxs->con_stat[1].attempts_num);
+    console_printf("Con success = %d\n", test_ctxs->con_stat[1].num);
+
+    console_printf(
+        "\033[0;33mUse case 2 - Stress Connect/Disconnect legacy: \n\033[0m");
+    console_printf("Con attempts = %d\n", test_ctxs->con_stat[2].attempts_num);
+    console_printf("Con success = %d\n", test_ctxs->con_stat[2].num);
+
+    console_printf(
+        "\033[0;33mUse case 3 - Stress Connect/Disconnect ext adv: \n\033[0m");
+    console_printf("Con attempts = %d\n", test_ctxs->con_stat[3].attempts_num);
+    console_printf("Con success = %d\n", test_ctxs->con_stat[3].num);
+
+    console_printf(
+        "\033[0;33mUse case 4 - Stress connection params update (TX): \n\033[0m");
+    console_printf("Params updates = %d\n",
+                   test_ctxs->con_stat[4].prms_upd_num);
+
+    console_printf(
+        "\033[0;33mUse case 5 - Stress connection params update (RX): \n\033[0m");
+    console_printf("Params updates = %d\n",
+                   test_ctxs->con_stat[5].prms_upd_num);
+
+    console_printf("\033[0;33mUse case 6 - Stress Scan: \n\033[0m");
+    console_printf("Received first packets = %d\n",
+                   test_ctxs->s6_rcv_adv_first);
+    console_printf("Received all packets = %d\n", test_ctxs->s6_rcv_adv_suc);
+
+    console_printf("\033[0;33mUse case 7 - Stress PHY Update (TX): \n\033[0m");
+    console_printf("PHY updates = %d\n", test_ctxs->con_stat[7].phy_upd_num);
+
+    console_printf("\033[0;33mUse case 8 - Stress PHY Update (RX): \n\033[0m");
+    console_printf("PHY updates = %d\n", test_ctxs->con_stat[8].phy_upd_num);
+
+    console_printf(
+        "\033[0;33mUse case 9 - Stress multi connection: \n\033[0m");
+    console_printf("Max reached num of connections = %d\n",
+                   test_ctxs->con_stat[9].max_num);
+
+    console_printf("\033[0;33mUse case 10 - Stress L2CAP send: \n\033[0m");
+    console_printf("Average bit rate = %d\n", test_ctxs->s10_bit_rate);
+    console_printf("Max received MTU = %lld\n", test_ctxs->s10_max_mtu);
+
+    console_printf("\033[0;33mUse case 11 - "
+                   "Stress Advertise/Connect/Continue adv \n\033[0m");
+//    console_printf(" = %d\n",);
+
+    console_printf("\033[0;33mUse case 12 - "
+                   "Stress GATT indication: \n\033[0m");
+    console_printf("Average bit rate = %d\n", test_ctxs->s12_notif_time);
+
+    console_printf("\033[0;33mUse case 13 - "
+                   "Stress GATT notification: \n\033[0m");
+    console_printf("Average time = %d\n", test_ctxs->s13_notif_time);
+
+    console_printf("\033[0;33mUse case 14 - "
+                   "Stress GATT Subscribe/Notify/Unsubscribe: \n\033[0m");
+    console_printf("Average time = %d\n", test_ctxs->s14_notif_time);
+
+    console_printf("\033[0;33mUse case 15 - "
+                   "Stress Connect/Send/Disconnect: \n\033[0m");
+    console_printf("Con num = %d\n", test_ctxs->con_stat[15].num);
+}
+
+void
+stress_clear_ctx_reusable_var(struct com_stress_test_ctx *ctx)
+{
+    ctx->cur_test_id = 0;
+    ctx->dev_addr.type = 0;
+    ctx->dev_addr.type = 0;
+    ctx->conn_handle = 0;
+    ctx->chan = 0;
+    ctx->rcv_data_bytes = 0;
+    ctx->rcv_num = 0;
+    ctx->send_num = 0;
+    ctx->begin_us = 0;
+    ctx->end_us = 0;
+    ctx->time_sum = 0;
+    ctx->bytes_sum = 0;
+    ctx->timeout_flag = 0;
+    ctx->rcv_data_flag = 0;
+}
+
+int
+stress_fill_mbuf_with_pattern(struct os_mbuf *om, uint16_t len)
+{
+    int rc, i, mul, rest;
+
+    mul = len / STRESS_PAT_LEN;
+    rest = len % STRESS_PAT_LEN;
+
+    for (i = 0; i < mul; ++i) {
+        rc = os_mbuf_append(om, &test_6_pattern[29], STRESS_PAT_LEN);
+
+        if (rc) {
+            os_mbuf_free_chain(om);
+            assert(0);
+        }
+    }
+
+    rc = os_mbuf_append(om, &test_6_pattern[29], rest);
+
+    if (rc) {
+        os_mbuf_free_chain(om);
+        assert(0);
+    }
+
+    return rc;
+}
+
+void
+stress_l2cap_coc_recv(struct ble_l2cap_chan *chan, struct os_mbuf *sdu)
+{
+    int rc;
+    console_printf("LE CoC SDU received, chan: 0x%08lx, data len %d\n",
+                   (uint32_t) chan, OS_MBUF_PKTLEN(sdu));
+
+    rc = os_mbuf_free_chain(sdu);
+    assert(rc == 0);
+
+    /* Get buffer for data chain */
+    sdu = os_msys_get_pkthdr(STRESS_COC_MTU, 0);
+    assert(sdu != NULL);
+
+    /* Receive data chain */
+    rc = ble_l2cap_recv_ready(chan, sdu);
+    assert(rc == 0);
+}
+
+void
+stress_l2cap_coc_accept(uint16_t peer_mtu, struct ble_l2cap_chan *chan)
+{
+    struct os_mbuf *sdu_rx;
+    int rc;
+
+    console_printf("LE CoC accepting, chan: 0x%08lx, peer_mtu %d\n",
+                   (uint32_t) chan, peer_mtu);
+
+    sdu_rx = os_msys_get_pkthdr(STRESS_COC_MTU, 0);
+    assert(sdu_rx != NULL);
+
+    rc = ble_l2cap_recv_ready(chan, sdu_rx);
+    assert(rc == 0);
+}
+
+void
+stress_start_timer(uint32_t timeout_ms, os_event_fn *ev_cb)
+{
+    int rc;
+    os_callout_stop(&stress_timer_callout);
+
+    os_callout_init(&stress_timer_callout, os_eventq_dflt_get(), ev_cb, NULL);
+
+    rc = os_callout_reset(&stress_timer_callout,
+                          os_time_ms_to_ticks32(timeout_ms));
+
+    assert(rc == 0);
+}
+
+int64_t
+stress_calc_bit_rate(int64_t us, int64_t bytes_num)
+{
+    int bit_rate;
+
+    /* Multiply by 1000000 so you don't lose accuracy */
+    bit_rate = 1000000 * bytes_num / us;
+
+    return bit_rate;
+}
+
+static int
+stress_disc_dsc_fn(uint16_t conn_handle,
+                   const struct ble_gatt_error *error,
+                   uint16_t chr_val_handle,
+                   const struct ble_gatt_dsc *dsc,
+                   void *arg)
+{
+    struct stress_gatt_search_ctx *search_ctx;
+    static bool found = false;
+
+    search_ctx = (struct stress_gatt_search_ctx *) arg;
+
+    if (error->status == 0) {
+        if (!ble_uuid_cmp(&dsc->uuid.u, &search_ctx->dsc_uuid.u) && !found) {
+            MODLOG_DFLT(INFO, "Found chr descriptor\n");
+            search_ctx->dsc_handle = dsc->handle;
+            MODLOG_DFLT(INFO, "uuid=%#06x; handle=%#06x", dsc->uuid.u16.value,
+                        dsc->handle);
+            found = true;
+        }
+        return 0;
+    }
+
+    if (error->status == BLE_HS_EDONE) {
+        MODLOG_DFLT(INFO, "Done descriptor discovery\n");
+
+        if (found) {
+            found = false;
+            search_ctx->disc_end_fn(search_ctx);
+            return 0;
+        }
+
+        MODLOG_DFLT(ERROR, "\033[0;31mDid not find particular descriptor"
+                           "\033[0m\n");
+        return 0;
+    }
+
+    MODLOG_DFLT(ERROR, "\033[0;31mError during descriptor discovery"
+                       "\033[0m\n");
+    assert(0);
+    return 0;
+}
+
+static int
+stress_disc_chr_fn(uint16_t conn_handle,
+                   const struct ble_gatt_error *error,
+                   const struct ble_gatt_chr *chr, void *arg)
+{
+    int rc;
+    struct stress_gatt_search_ctx *search_ctx;
+    static bool found = false;
+
+    search_ctx = (struct stress_gatt_search_ctx *) arg;
+
+    if (error->status == 0) {
+        MODLOG_DFLT(INFO, "Found characteristic\n");
+        search_ctx->chr_start_handle = chr->val_handle;
+        found = true;
+        return 0;
+    }
+
+    if (error->status == BLE_HS_EDONE) {
+        MODLOG_DFLT(INFO, "Done characteristic discovery\n");
+
+        if (found) {
+            found = false;
+
+            if (search_ctx->search_goal == STRESS_FIND_CHR) {
+                search_ctx->disc_end_fn(search_ctx);
+                return 0;
+            }
+
+            rc = ble_gattc_disc_all_dscs(conn_handle,
+                                         search_ctx->chr_start_handle,
+                                         search_ctx->srv_end_handle,
+                                         &stress_disc_dsc_fn, search_ctx);
+            assert(rc == 0);
+            return 0;
+        }
+
+        MODLOG_DFLT(ERROR, "\033[0;31mDid not find particular "
+                           "characteristic\033[0m\n");
+        return 0;
+    }
+
+    MODLOG_DFLT(ERROR,
+                "\033[0;31mError during characteristic discovery\033[0m\n");
+    assert(0);
+    return 0;
+}
+
+static int
+stress_disc_svc_fn(uint16_t conn_handle, const struct ble_gatt_error *error,
+                   const struct ble_gatt_svc *service, void *arg)
+{
+    int rc;
+    struct stress_gatt_search_ctx *search_ctx = NULL;
+    static bool found = false;
+
+    search_ctx = (struct stress_gatt_search_ctx *) arg;
+
+    if (error->status == 0) {
+        MODLOG_DFLT(INFO, "Found service\n");
+        search_ctx->srv_start_handle = service->start_handle;
+        search_ctx->srv_end_handle = service->end_handle;
+        found = true;
+        return 0;
+    }
+
+    if (error->status == BLE_HS_EDONE) {
+        MODLOG_DFLT(INFO, "Done service discovery\n");
+
+        if (found) {
+            found = false;
+            if (search_ctx->search_goal == STRESS_FIND_SRV) {
+                search_ctx->disc_end_fn(search_ctx);
+                return 0;
+            }
+
+            rc = ble_gattc_disc_chrs_by_uuid(conn_handle,
+                                             search_ctx->srv_start_handle,
+                                             search_ctx->srv_end_handle,
+                                             &search_ctx->chr_uuid.u,
+                                             &stress_disc_chr_fn,
+                                             search_ctx);
+            MODLOG_DFLT(INFO, "rc=%d\n", rc);
+            assert(rc == 0);
+            return 0;
+        }
+
+        MODLOG_DFLT(ERROR,
+                    "\033[0;31mDid not find particular service\033[0m\n");
+        return 0;
+    }
+
+    MODLOG_DFLT(ERROR, "\033[0;31mError during service discovery\033[0m\n");
+    assert(0);
+    return 0;
+}
+
+static void
+stress_gatt_find_handle(uint16_t conn_handle, const ble_uuid_t *srv_uuid,
+                        const ble_uuid_t *chr_uuid, const ble_uuid_t *dsc_uuid,
+                        stress_gatt_disc_end_fn *disc_end_fn,
+                        uint8_t search_goal)
+{
+    static struct stress_gatt_search_ctx search_ctx;
+    int rc;
+
+    search_ctx.conn_handle = conn_handle;
+    ble_uuid_copy((ble_uuid_any_t *) &search_ctx.srv_uuid, srv_uuid);
+    ble_uuid_copy((ble_uuid_any_t *) &search_ctx.chr_uuid, chr_uuid);
+    ble_uuid_copy((ble_uuid_any_t *) &search_ctx.dsc_uuid, dsc_uuid);
+    search_ctx.disc_end_fn = disc_end_fn;
+    search_ctx.search_goal = search_goal;
+    search_ctx.srv_start_handle = 0;
+    search_ctx.srv_end_handle = 0;
+    search_ctx.chr_start_handle = 0;
+    search_ctx.dsc_handle = 0;
+
+    rc = ble_gattc_disc_svc_by_uuid(conn_handle, srv_uuid, &stress_disc_svc_fn,
+                                    &search_ctx);
+    assert(rc == 0);
+}
+
+void
+stress_find_svc_handle(uint16_t conn_handle, const ble_uuid_t *srv_uuid,
+                       stress_gatt_disc_end_fn *disc_end_fn)
+{
+    stress_gatt_find_handle(conn_handle, srv_uuid, NULL, NULL, disc_end_fn,
+                            STRESS_FIND_SRV);
+}
+
+void
+stress_find_chr_handle(uint16_t conn_handle, const ble_uuid_t *srv_uuid,
+                       const ble_uuid_t *chr_uuid,
+                       stress_gatt_disc_end_fn *disc_end_fn)
+{
+    stress_gatt_find_handle(conn_handle, srv_uuid, chr_uuid, NULL, disc_end_fn,
+                            STRESS_FIND_CHR);
+}
+
+void
+stress_find_dsc_handle(uint16_t conn_handle, const ble_uuid_t *srv_uuid,
+                       const ble_uuid_t *chr_uuid, const ble_uuid_t *dsc_uuid,
+                       stress_gatt_disc_end_fn *disc_end_fn)
+{
+    stress_gatt_find_handle(conn_handle, srv_uuid, chr_uuid, dsc_uuid,
+                            disc_end_fn, STRESS_FIND_DSC);
+}

apps/blestress/src/stress.h

@@ -0,0 +1,375 @@
+/*
+ * 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.
+ */
+
+#ifndef BLE_TGT_STRESS_H
+#define BLE_TGT_STRESS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <nimble/ble.h>
+#include <modlog/modlog.h>
+#include <os/mynewt.h>
+#include <console/console.h>
+#include <host/ble_l2cap.h>
+#include <host/ble_gatt.h>
+#include <host/ble_gap.h>
+#include <assert.h>
+
+#define STRESS_UUIDS_NUM    (16)
+
+/* No preferred PHY */
+#define TX_PHY_MASK 0
+#define RX_PHY_MASK 0
+/* L2CAP SDU */
+#define STRESS_COC_MTU (64000)
+
+#define STRESS_FIND_SRV 1
+#define STRESS_FIND_CHR 2
+#define STRESS_FIND_DSC 3
+
+struct os_callout stress_timer_callout;
+struct stress_gatt_search_ctx;
+typedef void stress_gatt_disc_end_fn(struct stress_gatt_search_ctx *search_ctx);
+
+struct stress_gatt_search_ctx {
+    /* Connection handle */
+    uint16_t conn_handle;
+
+    /* Wanted service uuid */
+    ble_uuid16_t srv_uuid;
+
+    /* Wanted characteristic uuid */
+    ble_uuid16_t chr_uuid;
+
+    /* Wanted descriptor uuid */
+    ble_uuid16_t dsc_uuid;
+
+    /* Search goal: 1 - service, 2 - characteristic, 3 - descriptor */
+    uint8_t search_goal;
+
+    /* Callback after reaching the goal */
+    stress_gatt_disc_end_fn *disc_end_fn;
+
+    /* Service start handle */
+    uint16_t srv_start_handle;
+
+    /* Service end handle */
+    uint16_t srv_end_handle;
+
+    /* Characteristic start handle */
+    uint16_t chr_start_handle;
+
+    /* Descriptor handle */
+    uint16_t dsc_handle;
+};
+
+struct stress_con_stat {
+    /* Number of successful connection attempts */
+    int num;
+
+    /* Max number of established connections */
+    int max_num;
+
+    /* Number connection attempts */
+    int attempts_num;
+
+    /* Number of params updates */
+    int prms_upd_num;
+
+    /* Number of PHY updates */
+    int phy_upd_num;
+};
+
+/* Common stress test context.
+ * (Reusable) - auxiliary variable
+ * (Stress x) - variable contains result of x stress test */
+struct com_stress_test_ctx {
+    /* Which of tests are completed already. Each element for different
+     * stress test.  */
+    bool completed[STRESS_UUIDS_NUM];
+
+    /* Connection stats. Each element for different stress test. */
+    struct stress_con_stat con_stat[STRESS_UUIDS_NUM];
+
+/* Reusable variables */
+
+    /* Stress test number */
+    int cur_test_id;
+
+    /* Instance address */
+    ble_addr_t dev_addr;
+
+    /* Connection handler */
+    uint16_t conn_handle;
+
+    /* L2CAP channel (Reusable) */
+    struct ble_l2cap_chan * chan;
+
+    /* Size of received data */
+    int64_t rcv_data_bytes;
+
+    /* Number of received packages */
+    int rcv_num;
+
+    /* Number of send actions */
+    int send_num;
+
+    /* Variables for bit rate measurement */
+    int64_t begin_us;
+    int64_t end_us;
+    int64_t time_sum;
+    int64_t bytes_sum;
+
+    /* Timeout flag */
+    bool timeout_flag;
+
+    /* Data received flag */
+    bool rcv_data_flag;
+
+    uint16_t start_handle;
+    uint16_t end_handle;
+    uint16_t dsc_handle;
+
+/* Variables for test results */
+    /* Reached timeout of scanning for test */
+    bool scan_timeout;
+
+    /* Number of received first packets of adverts */
+    int s6_rcv_adv_first;
+
+    /* Number of full received adverts */
+    int s6_rcv_adv_suc;
+
+    /* L2CAP Send Bit Rate */
+    int s10_bit_rate;
+
+    /* Average indication time */
+    int s12_notif_time;
+
+    /* Average notification time */
+    int s13_notif_time;
+
+    /* Average notification time */
+    int s14_notif_time;
+
+    /* Max size of received MTU */
+    int64_t s10_max_mtu;
+};
+
+#define STRESS_PAT_LEN 1650
+
+static const uint8_t test_6_pattern[STRESS_PAT_LEN] = {
+    /* Random data */
+    0x00, 0x02, 0x00, 0x04, 0x00, 0x06, 0x00, 0x08, 0x00, 0x0a,
+    0x00, 0x0c, 0x00, 0x0e, 0x00, 0x10, 0x00, 0x12, 0x00, 0x14,
+    0x00, 0x16, 0x00, 0x18, 0x00, 0x1a, 0x00, 0x1c, 0x00, 0x1e,
+    0x00, 0x20, 0x00, 0x22, 0x00, 0x24, 0x00, 0x26, 0x00, 0x28,
+    0x00, 0x2a, 0x00, 0x2c, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x32,
+    0x00, 0x34, 0x00, 0x36, 0x00, 0x38, 0x00, 0x3a, 0x00, 0x3c,
+    0x00, 0x3e, 0x00, 0x40, 0x00, 0x42, 0x00, 0x44, 0x00, 0x46,
+    0x00, 0x48, 0x00, 0x4a, 0x00, 0x4c, 0x00, 0x4e, 0x00, 0x50,
+    0x00, 0x52, 0x00, 0x54, 0x00, 0x56, 0x00, 0x58, 0x00, 0x5a,
+    0x00, 0x5c, 0x00, 0x5e, 0x00, 0x60, 0x00, 0x62, 0x00, 0x64,
+    0x00, 0x66, 0x00, 0x68, 0x00, 0x6a, 0x00, 0x6c, 0x00, 0x6e,
+    0x00, 0x70, 0x00, 0x72, 0x00, 0x74, 0x00, 0x76, 0x00, 0x78,
+    0x00, 0x7a, 0x00, 0x7c, 0x00, 0x7e, 0x00, 0x80, 0x00, 0x82,
+    0x00, 0x84, 0x00, 0x86, 0x00, 0x88, 0x00, 0x8a, 0x00, 0x8c,
+    0x00, 0x8e, 0x00, 0x90, 0x00, 0x92, 0x00, 0x94, 0x00, 0x96,
+    0x00, 0x98, 0x00, 0x9a, 0x00, 0x9c, 0x00, 0x9e, 0x00, 0xa0,
+    0x00, 0xa2, 0x00, 0xa4, 0x00, 0xa6, 0x00, 0xa8, 0x00, 0xaa,
+    0x00, 0xac, 0x00, 0xae, 0x00, 0xb0, 0x00, 0xb2, 0x00, 0xb4,
+    0x00, 0xb6, 0x00, 0xb8, 0x00, 0xba, 0x00, 0xbc, 0x00, 0xbe,
+    0x00, 0xc0, 0x00, 0xc2, 0x00, 0xc4, 0x00, 0xc6, 0x00, 0xc8,
+    0x00, 0xca, 0x00, 0xcc, 0x00, 0xce, 0x00, 0xd0, 0x00, 0xd2,
+    0x00, 0xd4, 0x00, 0xd6, 0x00, 0xd8, 0x00, 0xda, 0x00, 0xdc,
+    0x00, 0xde, 0x00, 0xe0, 0x00, 0xe2, 0x00, 0xe4, 0x00, 0xe6,
+    0x00, 0xe8, 0x00, 0xea, 0x00, 0xec, 0x00, 0xee, 0x00, 0xf0,
+    0x00, 0xf2, 0x00, 0xf4, 0x00, 0xf6, 0x00, 0xf8, 0x00, 0xfa,
+    0x00, 0xfc, 0x00, 0xfe, 0x01, 0x01, 0x01, 0x03, 0x01, 0x05,
+    0x01, 0x07, 0x01, 0x09, 0x01, 0x0b, 0x01, 0x0d, 0x01, 0x0f,
+    0x01, 0x11, 0x01, 0x13, 0x01, 0x15, 0x01, 0x17, 0x01, 0x19,
+    0x01, 0x1b, 0x01, 0x1d, 0x01, 0x1f, 0x01, 0x21, 0x01, 0x23,
+    0x01, 0x25, 0x01, 0x27, 0x01, 0x29, 0x01, 0x2b, 0x01, 0x2d,
+    0x01, 0x2f, 0x01, 0x31, 0x01, 0x33, 0x01, 0x35, 0x01, 0x37,
+    0x01, 0x39, 0x01, 0x3b, 0x01, 0x3d, 0x01, 0x3f, 0x01, 0x41,
+    0x01, 0x43, 0x01, 0x45, 0x01, 0x47, 0x01, 0x49, 0x01, 0x4b,
+    0x01, 0x4d, 0x01, 0x4f, 0x01, 0x51, 0x01, 0x53, 0x01, 0x55,
+    0x01, 0x57, 0x01, 0x59, 0x01, 0x5b, 0x01, 0x5d, 0x01, 0x5f,
+    0x01, 0x61, 0x01, 0x63, 0x01, 0x65, 0x01, 0x67, 0x01, 0x69,
+    0x01, 0x6b, 0x01, 0x6d, 0x01, 0x6f, 0x01, 0x71, 0x01, 0x73,
+    0x01, 0x75, 0x01, 0x77, 0x01, 0x79, 0x01, 0x7b, 0x01, 0x7d,
+    0x01, 0x7f, 0x01, 0x81, 0x01, 0x83, 0x01, 0x85, 0x01, 0x87,
+    0x01, 0x89, 0x01, 0x8b, 0x01, 0x8d, 0x01, 0x8f, 0x01, 0x91,
+    0x01, 0x93, 0x01, 0x95, 0x01, 0x97, 0x01, 0x99, 0x01, 0x9b,
+    0x01, 0x9d, 0x01, 0x9f, 0x01, 0xa1, 0x01, 0xa3, 0x01, 0xa5,
+    0x01, 0xa7, 0x01, 0xa9, 0x01, 0xab, 0x01, 0xad, 0x01, 0xaf,
+    0x01, 0xb1, 0x01, 0xb3, 0x01, 0xb5, 0x01, 0xb7, 0x01, 0xb9,
+    0x01, 0xbb, 0x01, 0xbd, 0x01, 0xbf, 0x01, 0xc1, 0x01, 0xc3,
+    0x01, 0xc5, 0x01, 0xc7, 0x01, 0xc9, 0x01, 0xcb, 0x01, 0xcd,
+    0x01, 0xcf, 0x01, 0xd1, 0x01, 0xd3, 0x01, 0xd5, 0x01, 0xd7,
+    0x01, 0xd9, 0x01, 0xdb, 0x01, 0xdd, 0x01, 0xdf, 0x01, 0xe1,
+    0x01, 0xe3, 0x01, 0xe5, 0x01, 0xe7, 0x01, 0xe9, 0x01, 0xeb,
+    0x01, 0xed, 0x01, 0xef, 0x01, 0xf1, 0x01, 0xf3, 0x01, 0xf5,
+    0x01, 0xf7, 0x01, 0xf9, 0x01, 0xfb, 0x01, 0xfd, 0x02, 0x00,
+    0x02, 0x02, 0x02, 0x04, 0x02, 0x06, 0x02, 0x08, 0x02, 0x0a,
+    0x02, 0x0c, 0x02, 0x0e, 0x02, 0x10, 0x02, 0x12, 0x02, 0x14,
+    0x02, 0x16, 0x02, 0x18, 0x02, 0x1a, 0x02, 0x1c, 0x02, 0x1e,
+    0x02, 0x20, 0x02, 0x22, 0x02, 0x24, 0x02, 0x26, 0x02, 0x28,
+    0x02, 0x2a, 0x02, 0x2c, 0x02, 0x2e, 0x02, 0x30, 0x02, 0x32,
+    0x02, 0x34, 0x02, 0x36, 0x02, 0x38, 0x02, 0x3a, 0x02, 0x3c,
+    0x02, 0x3e, 0x02, 0x40, 0x02, 0x42, 0x02, 0x44, 0x02, 0x46,
+    0x02, 0x48, 0x02, 0x4a, 0x02, 0x4c, 0x02, 0x4e, 0x02, 0x50,
+    0x02, 0x52, 0x02, 0x54, 0x02, 0x56, 0x02, 0x58, 0x02, 0x5a,
+    0x02, 0x5c, 0x02, 0x5e, 0x02, 0x60, 0x02, 0x62, 0x02, 0x64,
+    0x02, 0x66, 0x02, 0x68, 0x02, 0x6a, 0x02, 0x6c, 0x02, 0x6e,
+    0x02, 0x70, 0x02, 0x72, 0x02, 0x74, 0x02, 0x76, 0x02, 0x78,
+    0x02, 0x7a, 0x02, 0x7c, 0x02, 0x7e, 0x02, 0x80, 0x02, 0x82,
+    0x02, 0x84, 0x02, 0x86, 0x02, 0x88, 0x02, 0x8a, 0x02, 0x8c,
+    0x02, 0x8e, 0x02, 0x90, 0x02, 0x92, 0x02, 0x94, 0x02, 0x96,
+    0x02, 0x98, 0x02, 0x9a, 0x02, 0x9c, 0x02, 0x9e, 0x02, 0xa0,
+    0x02, 0xa2, 0x02, 0xa4, 0x02, 0xa6, 0x02, 0xa8, 0x02, 0xaa,
+    0x02, 0xac, 0x02, 0xae, 0x02, 0xb0, 0x02, 0xb2, 0x02, 0xb4,
+    0x02, 0xb6, 0x02, 0xb8, 0x02, 0xba, 0x02, 0xbc, 0x02, 0xbe,
+    0x02, 0xc0, 0x02, 0xc2, 0x02, 0xc4, 0x02, 0xc6, 0x02, 0xc8,
+    0x02, 0xca, 0x02, 0xcc, 0x02, 0xce, 0x02, 0xd0, 0x02, 0xd2,
+    0x02, 0xd4, 0x02, 0xd6, 0x02, 0xd8, 0x02, 0xda, 0x02, 0xdc,
+    0x02, 0xde, 0x02, 0xe0, 0x02, 0xe2, 0x02, 0xe4, 0x02, 0xe6,
+    0x02, 0xe8, 0x02, 0xea, 0x02, 0xec, 0x02, 0xee, 0x02, 0xf0,
+    0x02, 0xf2, 0x02, 0xf4, 0x02, 0xf6, 0x02, 0xf8, 0x02, 0xfa,
+    0x02, 0xfc, 0x02, 0xfe, 0x03, 0x01, 0x03, 0x03, 0x03, 0x05,
+    0x03, 0x07, 0x03, 0x09, 0x03, 0x0b, 0x03, 0x0d, 0x03, 0x0f,
+    0x03, 0x11, 0x03, 0x13, 0x03, 0x15, 0x03, 0x17, 0x03, 0x19,
+    0x03, 0x1b, 0x03, 0x1d, 0x03, 0x1f, 0x03, 0x21, 0x03, 0x23,
+    0x03, 0x25, 0x03, 0x27, 0x03, 0x29, 0x03, 0x2b, 0x03, 0x2d,
+    0x03, 0x2f, 0x03, 0x31, 0x03, 0x33, 0x03, 0x35, 0x03, 0x37,
+    0x03, 0x39, 0x03, 0x3b, 0x03, 0x3d, 0x03, 0x3f, 0x03, 0x41,
+    0x03, 0x43, 0x03, 0x45, 0x03, 0x47, 0x03, 0x49, 0x03, 0x4b,
+    0x03, 0x4d, 0x03, 0x4f, 0x03, 0x51, 0x03, 0x53, 0x03, 0x55,
+    0x03, 0x57, 0x03, 0x59, 0x03, 0x5b, 0x03, 0x5d, 0x03, 0x5f,
+    0x03, 0x61, 0x03, 0x63, 0x03, 0x65, 0x03, 0x67, 0x03, 0x69,
+    0x03, 0x6b, 0x03, 0x6d, 0x03, 0x6f, 0x03, 0x71, 0x03, 0x73,
+    0x03, 0x75, 0x03, 0x77, 0x03, 0x79, 0x03, 0x7b, 0x03, 0x7d,
+    0x03, 0x7f, 0x03, 0x81, 0x03, 0x83, 0x03, 0x85, 0x03, 0x87,
+    0x03, 0x89, 0x03, 0x8b, 0x03, 0x8d, 0x03, 0x8f, 0x03, 0x91,
+    0x03, 0x93, 0x03, 0x95, 0x03, 0x97, 0x03, 0x99, 0x03, 0x9b,
+    0x03, 0x9d, 0x03, 0x9f, 0x03, 0xa1, 0x03, 0xa3, 0x03, 0xa5,
+    0x03, 0xa7, 0x03, 0xa9, 0x03, 0xab, 0x03, 0xad, 0x03, 0xaf,
+    0x03, 0xb1, 0x03, 0xb3, 0x03, 0xb5, 0x03, 0xb7, 0x03, 0xb9,
+    0x03, 0xbb, 0x03, 0xbd, 0x03, 0xbf, 0x03, 0xc1, 0x03, 0xc3,
+    0x03, 0xc5, 0x03, 0xc7, 0x03, 0xc9, 0x03, 0xcb, 0x03, 0xcd,
+    0x03, 0xcf, 0x03, 0xd1, 0x03, 0xd3, 0x03, 0xd5, 0x03, 0xd7,
+    0x03, 0xd9, 0x03, 0xdb, 0x03, 0xdd, 0x03, 0xdf, 0x03, 0xe1,
+    0x03, 0xe3, 0x03, 0xe5, 0x03, 0xe7, 0x03, 0xe9, 0x03, 0xeb,
+    0x03, 0xed, 0x03, 0xef, 0x03, 0xf1, 0x03, 0xf3, 0x03, 0xf5,
+    0x03, 0xf7, 0x03, 0xf9, 0x03, 0xfb, 0x03, 0xfd, 0x04, 0x00,
+    0x04, 0x02, 0x04, 0x04, 0x04, 0x06, 0x04, 0x08, 0x04, 0x0a,
+    0x04, 0x0c, 0x04, 0x0e, 0x04, 0x10, 0x04, 0x12, 0x04, 0x14,
+    0x04, 0x16, 0x04, 0x18, 0x04, 0x1a, 0x04, 0x1c, 0x04, 0x1e,
+    0x04, 0x20, 0x04, 0x22, 0x04, 0x24, 0x04, 0x26, 0x04, 0x28,
+    0x04, 0x2a, 0x04, 0x2c, 0x04, 0x2e, 0x04, 0x30, 0x04, 0x32,
+    0x04, 0x34, 0x04, 0x36, 0x04, 0x38, 0x04, 0x3a, 0x04, 0x3c,
+    0x04, 0x3e, 0x04, 0x40, 0x04, 0x42, 0x04, 0x44, 0x04, 0x46,
+    0x04, 0x48, 0x04, 0x4a, 0x04, 0x4c, 0x04, 0x4e, 0x04, 0x50,
+    0x04, 0x52, 0x04, 0x54, 0x04, 0x56, 0x04, 0x58, 0x04, 0x5a,
+    0x04, 0x5c, 0x04, 0x5e, 0x04, 0x60, 0x04, 0x62, 0x04, 0x64,
+    0x04, 0x66, 0x04, 0x68, 0x04, 0x6a, 0x04, 0x6c, 0x04, 0x6e,
+    0x04, 0x70, 0x04, 0x72, 0x04, 0x74, 0x04, 0x76, 0x04, 0x78,
+    0x04, 0x7a, 0x04, 0x7c, 0x04, 0x7e, 0x04, 0x80, 0x04, 0x82,
+    0x04, 0x84, 0x04, 0x86, 0x04, 0x88, 0x04, 0x8a, 0x04, 0x8c,
+    0x04, 0x8e, 0x04, 0x90, 0x04, 0x92, 0x04, 0x94, 0x04, 0x96,
+    0x04, 0x98, 0x04, 0x9a, 0x04, 0x9c, 0x04, 0x9e, 0x04, 0xa0,
+    0x04, 0xa2, 0x04, 0xa4, 0x04, 0xa6, 0x04, 0xa8, 0x04, 0xaa,
+    0x04, 0xac, 0x04, 0xae, 0x04, 0xb0, 0x04, 0xb2, 0x04, 0xb4,
+    0x04, 0xb6, 0x04, 0xb8, 0x04, 0xba, 0x04, 0xbc, 0x04, 0xbe,
+    0x04, 0xc0, 0x04, 0xc2, 0x04, 0xc4, 0x04, 0xc6, 0x04, 0xc8,
+    0x04, 0xca, 0x04, 0xcc, 0x04, 0xce, 0x04, 0xd0, 0x04, 0xd2,
+    0x04, 0xd4, 0x04, 0xd6, 0x04, 0xd8, 0x04, 0xda, 0x04, 0xdc,
+    0x04, 0xde, 0x04, 0xe0, 0x04, 0xe2, 0x04, 0xe4, 0x04, 0xe6,
+    0x04, 0xe8, 0x04, 0xea, 0x04, 0xec, 0x04, 0xee, 0x04, 0xf0,
+    0x04, 0xf2, 0x04, 0xf4, 0x04, 0xf6, 0x04, 0xf8, 0x04, 0xfa,
+    0x04, 0xfc, 0x04, 0xfe, 0x05, 0x01, 0x05, 0x03, 0x05, 0x05,
+    0x05, 0x07, 0x05, 0x09, 0x05, 0x0b, 0x05, 0x0d, 0x05, 0x0f,
+    0x05, 0x11, 0x05, 0x13, 0x05, 0x15, 0x05, 0x17, 0x05, 0x19,
+    0x05, 0x1b, 0x05, 0x1d, 0x05, 0x1f, 0x05, 0x21, 0x05, 0x23,
+    0x05, 0x25, 0x05, 0x27, 0x05, 0x29, 0x05, 0x2b, 0x05, 0x2d,
+    0x05, 0x2f, 0x05, 0x31, 0x05, 0x33, 0x05, 0x35, 0x05, 0x37,
+    0x05, 0x39, 0x05, 0x3b, 0x05, 0x3d, 0x05, 0x3f, 0x05, 0x41,
+    0x05, 0x43, 0x05, 0x45, 0x05, 0x47, 0x05, 0x49, 0x05, 0x4b,
+    0x05, 0x4d, 0x05, 0x4f, 0x05, 0x51, 0x05, 0x53, 0x05, 0x55,
+    0x05, 0x57, 0x05, 0x59, 0x05, 0x5b, 0x05, 0x5d, 0x05, 0x5f,
+    0x05, 0x61, 0x05, 0x63, 0x05, 0x65, 0x05, 0x67, 0x05, 0x69,
+    0x05, 0x6b, 0x05, 0x6d, 0x05, 0x6f, 0x05, 0x71, 0x05, 0x73,
+    0x05, 0x75, 0x05, 0x77, 0x05, 0x79, 0x05, 0x7b, 0x05, 0x7d,
+    0x05, 0x7f, 0x05, 0x81, 0x05, 0x83, 0x05, 0x85, 0x05, 0x87,
+    0x05, 0x89, 0x05, 0x8b, 0x05, 0x8d, 0x05, 0x8f, 0x05, 0x91,
+    0x05, 0x93, 0x05, 0x95, 0x05, 0x97, 0x05, 0x99, 0x05, 0x9b,
+    0x05, 0x9d, 0x05, 0x9f, 0x05, 0xa1, 0x05, 0xa3, 0x05, 0xa5,
+    0x05, 0xa7, 0x05, 0xa9, 0x05, 0xab, 0x05, 0xad, 0x05, 0xaf,
+    0x05, 0xb1, 0x05, 0xb3, 0x05, 0xb5, 0x05, 0xb7, 0x05, 0xb9,
+    0x05, 0xbb, 0x05, 0xbd, 0x05, 0xbf, 0x05, 0xc1, 0x05, 0xc3,
+    0x05, 0xc5, 0x05, 0xc7, 0x05, 0xc9, 0x05, 0xcb, 0x05, 0xcd,
+    0x05, 0xcf, 0x05, 0xd1, 0x05, 0xd3, 0x05, 0xd5, 0x05, 0xd7,
+    0x05, 0xd9, 0x05, 0xdb, 0x05, 0xdd, 0x05, 0xdf, 0x05, 0xe1,
+    0x05, 0xe3, 0x05, 0xe5, 0x05, 0xe7, 0x05, 0xe9, 0x05, 0xeb,
+    0x05, 0xed, 0x05, 0xef, 0x05, 0xf1, 0x05, 0xf3, 0x05, 0xf5,
+    0x05, 0xf7, 0x05, 0xf9, 0x05, 0xfb, 0x05, 0xfd, 0x06, 0x00,
+    0x06, 0x02, 0x06, 0x04, 0x06, 0x06, 0x06, 0x08, 0x06, 0x0a,
+    0x06, 0x0c, 0x06, 0x0e, 0x06, 0x10, 0x06, 0x12, 0x06, 0x14,
+    0x06, 0x16, 0x06, 0x18, 0x06, 0x1a, 0x06, 0x1c, 0x06, 0x1e,
+    0x06, 0x20, 0x06, 0x22, 0x06, 0x24, 0x06, 0x26, 0x06, 0x28,
+    0x06, 0x2a, 0x06, 0x2c, 0x06, 0x2e, 0x06, 0x30, 0x06, 0x32,
+    0x06, 0x34, 0x06, 0x36, 0x06, 0x38, 0x06, 0x3a, 0x06, 0x3c,
+    0x06, 0x3e, 0x06, 0x40, 0x06, 0x42, 0x06, 0x44, 0x06, 0x46,
+    0x06, 0x48, 0x06, 0x4a, 0x06, 0x4c, 0x06, 0x4e, 0x06, 0x50,
+    0x06, 0x52, 0x06, 0x54, 0x06, 0x56, 0x06, 0x58, 0x06, 0x5a,
+    0x06, 0x5c, 0x06, 0x5e, 0x06, 0x60, 0x06, 0x62, 0x06, 0x64,
+    0x06, 0x66, 0x06, 0x68, 0x06, 0x6a, 0x06, 0x6c, 0x06, 0x6e,
+    0x06, 0x70, 0x06, 0x72, 0x06, 0x74, 0x06, 0x76, 0x06, 0x78,
+};
+
+void stress_clear_ctx_reusable_var(struct com_stress_test_ctx *ctx);
+
+void com_stress_print_report(const struct com_stress_test_ctx test_ctxs[]);
+
+int stress_fill_mbuf_with_pattern(struct os_mbuf *om, uint16_t len);
+
+void stress_l2cap_coc_recv(struct ble_l2cap_chan *chan, struct os_mbuf *sdu);
+
+void stress_l2cap_coc_accept(uint16_t peer_mtu, struct ble_l2cap_chan *chan);
+
+void stress_start_timer(uint32_t timeout_ms, os_event_fn *ev_cb);
+
+int64_t stress_calc_bit_rate(int64_t us, int64_t bytes_num);
+
+void stress_find_svc_handle(uint16_t conn_handle, const ble_uuid_t *srv_uuid,
+                            stress_gatt_disc_end_fn *disc_end_fn);
+void stress_find_chr_handle(uint16_t conn_handle, const ble_uuid_t *srv_uuid,
+                            const ble_uuid_t *chr_uuid,
+                            stress_gatt_disc_end_fn *disc_end_fn);
+
+void stress_find_dsc_handle(uint16_t conn_handle, const ble_uuid_t *srv_uuid,
+                            const ble_uuid_t *chr_uuid, const ble_uuid_t *dsc_uuid,
+                            stress_gatt_disc_end_fn *disc_end_fn);
+#ifdef __cplusplus
+}
+#endif
+
+#endif //BLE_TGT_STRESS_H

apps/blestress/src/stress_gatt.c

@@ -0,0 +1,155 @@
+/*
+ * 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 "stress_gatt.h"
+
+uint16_t hrs_hrm_handle = 0xffff;
+
+static int
+stress_gatt_access_cb(uint16_t conn_handle, uint16_t attr_handle,
+                      struct ble_gatt_access_ctxt *ctxt, void *arg);
+
+static const struct ble_gatt_svc_def gatt_svr_svcs[] = {
+    {
+        /* Service: Heart-rate */
+        .type = BLE_GATT_SVC_TYPE_PRIMARY,
+        .uuid = BLE_UUID16_DECLARE(STRESS_GATT_UUID),
+        .characteristics = (struct ble_gatt_chr_def[]) {
+            {
+                /* Characteristic: read test */
+                .uuid = BLE_UUID16_DECLARE(STRESS_GATT_READ_UUID),
+                .access_cb = stress_gatt_access_cb,
+                .val_handle = &hrs_hrm_handle,
+                .flags = BLE_GATT_CHR_F_READ,
+            },
+            {
+                /* Characteristic: write test */
+                .uuid = BLE_UUID16_DECLARE(STRESS_GATT_WRITE_UUID),
+                .access_cb = stress_gatt_access_cb,
+                .val_handle = &hrs_hrm_handle,
+                .flags = BLE_GATT_CHR_F_WRITE,
+            },
+            {
+                /* Characteristic: notify test */
+                .uuid = BLE_UUID16_DECLARE(STRESS_GATT_NOTIFY_UUID),
+                .access_cb = stress_gatt_access_cb,
+                .val_handle = &hrs_hrm_handle,
+                .flags = BLE_GATT_CHR_F_NOTIFY,
+            },
+            {
+                /* Characteristic: indicate test */
+                .uuid = BLE_UUID16_DECLARE(STRESS_GATT_INDICATE_UUID),
+                .access_cb = stress_gatt_access_cb,
+                .val_handle = &hrs_hrm_handle,
+                .flags = BLE_GATT_CHR_F_INDICATE,
+            },
+            {
+                0, /* No more characteristics in this service */
+            },}
+    },
+    {
+        0, /* No more services */
+    },
+};
+
+static int
+stress_gatt_access_cb(uint16_t conn_handle, uint16_t attr_handle,
+                      struct ble_gatt_access_ctxt *ctxt, void *arg)
+{
+    /* Sensor location, set to "Chest" */
+    static uint8_t chr_value[] = "Hello";
+    uint16_t uuid;
+    int rc;
+
+    //chr_value = (uint8_t)rand() % 256;
+    uuid = ble_uuid_u16(ctxt->chr->uuid);
+
+    switch(uuid){
+    case STRESS_GATT_READ_UUID:
+        MODLOG_DFLT(INFO, "GATT Read event\n");
+        rc = os_mbuf_append(ctxt->om, &chr_value, sizeof(chr_value));
+        assert(rc == 0);
+        //return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
+        return 0;
+    case STRESS_GATT_WRITE_UUID:
+        MODLOG_DFLT(INFO, "GATT Write event\n");
+        print_mbuf(ctxt->om);
+        return 0;
+    case STRESS_GATT_NOTIFY_UUID:
+        MODLOG_DFLT(INFO, "GATT Notify event\n");
+        return 0;
+    case STRESS_GATT_INDICATE_UUID:
+        MODLOG_DFLT(INFO, "GATT Indicate event\n");
+        return 0;
+    default:
+        MODLOG_DFLT(ERROR, "GATT UUID does not exist\n");
+        assert(0);
+        return BLE_ATT_ERR_UNLIKELY;
+    }
+}
+
+void
+gatt_svr_register_cb(struct ble_gatt_register_ctxt *ctxt, void *arg)
+{
+    char buf[BLE_UUID_STR_LEN];
+
+    switch (ctxt->op) {
+    case BLE_GATT_REGISTER_OP_SVC:
+    MODLOG_DFLT(DEBUG, "registered service %s with handle=%d\n",
+                ble_uuid_to_str(ctxt->svc.svc_def->uuid, buf),
+                ctxt->svc.handle);
+        break;
+
+    case BLE_GATT_REGISTER_OP_CHR:
+    MODLOG_DFLT(DEBUG, "registering characteristic %s with "
+                       "def_handle=%d val_handle=%d\n",
+                ble_uuid_to_str(ctxt->chr.chr_def->uuid, buf),
+                ctxt->chr.def_handle,
+                ctxt->chr.val_handle);
+        break;
+
+    case BLE_GATT_REGISTER_OP_DSC:
+    MODLOG_DFLT(DEBUG, "registering descriptor %s with handle=%d\n",
+                ble_uuid_to_str(ctxt->dsc.dsc_def->uuid, buf),
+                ctxt->dsc.handle);
+        break;
+
+    default:
+        assert(0);
+        break;
+    }
+}
+
+int
+gatt_svr_init(void)
+{
+    int rc;
+
+    rc = ble_gatts_count_cfg(gatt_svr_svcs);
+    if (rc != 0) {
+        return rc;
+    }
+
+    rc = ble_gatts_add_svcs(gatt_svr_svcs);
+    if (rc != 0) {
+        return rc;
+    }
+
+    return 0;
+}

apps/blestress/src/stress_gatt.h

@@ -0,0 +1,54 @@
+/*
+ * 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.
+ */
+
+#ifndef BLE_TGT_STRESS_GATT_H
+#define BLE_TGT_STRESS_GATT_H
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include "host/ble_hs.h"
+#include "host/ble_uuid.h"
+#include "nimble/ble.h"
+#include "modlog/modlog.h"
+#include "misc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern uint16_t hrs_hrm_handle;
+
+/* Heart-rate configuration */
+#define STRESS_GATT_UUID                     0xC0DE
+#define STRESS_GATT_READ_UUID                0xC1DE
+#define STRESS_GATT_WRITE_UUID               0xC2DE
+#define STRESS_GATT_INDICATE_UUID            0xC3DE
+#define STRESS_GATT_NOTIFY_UUID              0xC4DE
+
+int gatt_svr_init(void);
+
+void gatt_svr_register_cb(struct ble_gatt_register_ctxt *ctxt, void *arg);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif //BLE_TGT_STRESS_GATT_H

apps/blestress/src/tx_stress.h

@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+#ifndef _BLE_STRESS_TX_H
+#define _BLE_STRESS_TX_H
+
+#include <assert.h>
+#include <string.h>
+#include <host/ble_gap.h>
+#include <stdlib.h>
+
+/* BLE */
+#include "nimble/ble.h"
+#include "host/ble_hs.h"
+
+#include "misc.h"
+#include "stress.h"
+#include "stress_gatt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Scan and execute tests one by one.
+ */
+void tx_stress_start_auto();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_BLE_STRESS_TX_H

apps/blestress/syscfg.yml

@@ -0,0 +1,74 @@
+#
+# 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.
+#
+
+# Settings this app defines.
+syscfg.defs:
+    BLE_STRESS_TEST_ROLE:
+        description: 0 - TX device, 1 - RX device
+        value: 0
+
+    BLE_STRESS_REPEAT:
+        description: Number of times to repeat each stress test use case
+        value: 50
+
+    BLE_STRESS_UUID_BASE:
+        description: Part of the test UUID that is specific to the current
+                     device couple.
+        value: ((uint8_t[13]){0xA5, 0x4A, 0xB4, 0x44, 0xC3, 0xBF, 0xB5,
+                              0xF8, 0xF9, 0x42, 0x83, 0xA1, 0xDA})
+
+# Settings this app overrides.
+syscfg.vals:
+    # Change these settings:
+
+    # Set 0 to print all debug logs, but keep in mind that plenty of
+    # adv packets will be lost during scan tests.
+    LOG_LEVEL: 1
+
+    # The maximum number of concurrent connections. For some devices, this
+    # value will need to be reduced due to the RAM capacity.
+    BLE_MAX_CONNECTIONS: 50
+
+    # Should not change these settings:
+
+    # Enable Extended Advertising
+    BLE_EXT_ADV: 1
+
+    # Max advertising data size
+    BLE_EXT_ADV_MAX_SIZE: 1650
+
+    # Number of multi-advertising instances. Note that due
+    # to historical reasons total number of advertising
+    # instances is BLE_MULTI_ADV_INSTANCES + 1 as instance
+    # 0 is always available
+    BLE_MULTI_ADV_INSTANCES: 2
+
+    # Controller uses msys pool for storing advertising data and scan responses.
+    # Since we advertise a lot of data (~4k in total) at the same time we need
+    # to increase block count.
+    MSYS_1_BLOCK_COUNT: 50
+
+    #
+    BLE_L2CAP_COC_MAX_NUM: 2
+
+    # Enable 2M PHY
+    BLE_LL_CFG_FEAT_LE_2M_PHY: 1
+
+    # Enable CODED PHY
+    BLE_LL_CFG_FEAT_LE_CODED_PHY: 1