ESP32 Forum

Posted: **Sat Jul 06, 2024 1:05 am**

Hello all.
I'm a bit new to BLE/real-world RTOS functionality and would really appreciate your help.

MY PROBLEM: nimble_port_run(), which enables BLE functionality and makes my ESP BLE server accessible, blocks until nimble_port_stop() is called elsewhere. I need to be able to constantly advertise using my S3 as a BLE server, while also updating the value that a client will read in their scanner app through other functionality. If the value my custom functionality computes is above a given threshold, I need to update the value advertised by the BLE server. Here, I have simulated this with a basic "random number generator task".

Below is a basic starting point, reproducible example of my current code for an S3. Menuconfig->BLE in the bluetooth menu, flash at 4MB are necessary. I have the CPU freq set to 240MHz.

If you scroll near the bottom, you'll see the app_main and the two tasks.
I do not know if it is good practice to just turn it on and off constantly, or whether there is a good way to multithread it or something. I have:
- Tried using semaphores (doesn't solve the blocking problem)
- Tried changing task priorities by digging into the task created by nimble_port_freertos_init()
- Tried switching the nimble port on and off (not init/deinit; just stop/run). But this really is not viable for my project; I need my other sensor peripherals working constantly, and this also ticking away constantly.

Is there something I'm missing about how BLE or RTOS works (I'm sure there is!). Thanks for patience and any time at all spent reading.

Code: [Select all] [Expand/Collapse]

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_event.h"
#include "nvs_flash.h"
#include "esp_log.h"
#include "esp_nimble_hci.h"
#include "nimble/nimble_port.h"
#include "nimble/nimble_port_freertos.h"
#include "host/ble_hs.h"
#include "services/gap/ble_svc_gap.h"
#include "services/gatt/ble_svc_gatt.h"
#include "sdkconfig.h"
 
#include "esp_random.h"
 
 
int NUM_FOR_BLE = 0;
 
char *TAG = "BLE-Server";
uint8_t ble_addr_type;
void ble_app_advertise(void);
 
 
// Read data from ESP32 defined as server
static int device_read(uint16_t con_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg)
{   
    char data_str[10];
    sprintf(data_str, "val: %d", NUM_FOR_BLE);
    os_mbuf_append(ctxt->om, data_str, strlen(data_str));
    return 0;
}
 
// Array of pointers to other service definitions
// UUID - Universal Unique Identifier
static const struct ble_gatt_svc_def gatt_svcs[] = {
    {.type = BLE_GATT_SVC_TYPE_PRIMARY,
     .uuid = BLE_UUID16_DECLARE(0x180),                 // Define UUID for device type
     .characteristics = (struct ble_gatt_chr_def[]) {
            {
                .uuid = BLE_UUID16_DECLARE(0xFEF4),           // Define UUID for reading
                .flags = BLE_GATT_CHR_F_READ,
                .access_cb = device_read
            },
            {0}
        }
    },
    {0}
};
 
// BLE event handling
static int ble_gap_event(struct ble_gap_event *event, void *arg)
{
    switch (event->type)
    {
    // Advertise if connected
    case BLE_GAP_EVENT_CONNECT:
        ESP_LOGI("GAP", "BLE GAP EVENT CONNECT %s", event->connect.status == 0 ? "OK!" : "FAILED!");
        if (event->connect.status != 0)
        {
            ble_app_advertise();
        }
        break;
    // Advertise again after completion of the event
    case BLE_GAP_EVENT_DISCONNECT:
        ESP_LOGI("GAP", "BLE GAP EVENT DISCONNECTED");
        break;
    case BLE_GAP_EVENT_ADV_COMPLETE:
        ESP_LOGI("GAP", "BLE GAP EVENT");
        ble_app_advertise();
        break;
    default:
        break;
    }
    return 0;
}
 
// Define the BLE connection
void ble_app_advertise(void)
{
    // GAP - device name definition
    struct ble_hs_adv_fields fields;
    const char *device_name;
    memset(&fields, 0, sizeof(fields));
    device_name = ble_svc_gap_device_name(); // Read the BLE device name
    fields.name = (uint8_t *)device_name;
    fields.name_len = strlen(device_name);
    fields.name_is_complete = 1;
    ble_gap_adv_set_fields(&fields);
 
    // GAP - device connectivity definition
    struct ble_gap_adv_params adv_params;
    memset(&adv_params, 0, sizeof(adv_params));
    adv_params.conn_mode = BLE_GAP_CONN_MODE_UND; // connectable or non-connectable
    adv_params.disc_mode = BLE_GAP_DISC_MODE_GEN; // discoverable or non-discoverable
    ble_gap_adv_start(ble_addr_type, NULL, BLE_HS_FOREVER, &adv_params, ble_gap_event, NULL);
}
 
// The application
void ble_app_on_sync(void)
{
    ble_hs_id_infer_auto(0, &ble_addr_type); // Determines the best address type automatically
    ble_app_advertise();                     // Define the BLE connection
}
 
// The infinite task
void host_task(void *param)
{
    nimble_port_run(); // This function will return only when nimble_port_stop() is executed
}
 
 
TaskHandle_t numGenHandler = NULL;
void numberGenerator(void* params);
 
void numberGenerator(void* params) 
{   
    while (true) {
        vTaskDelay(portTICK_PERIOD_MS * 2000);
        uint32_t rNum = esp_random();
        NUM_FOR_BLE = (rNum % 10) + 1;
        fprintf(stdout, "num: %d\n", NUM_FOR_BLE);
    }
}
 
 
void app_main()
{
    nvs_flash_init();                          // Initialize NVS flash using
    nimble_port_init();                        // Initialize the host stack
    ble_svc_gap_device_name_set("BLETest");    // Initialize NimBLE configuration - server name
    ble_svc_gap_init();                        // Initialize NimBLE configuration - gap service
    ble_svc_gatt_init();                       // Initialize NimBLE configuration - gatt service
    ble_gatts_count_cfg(gatt_svcs);            // Initialize NimBLE configuration - config gatt services
    ble_gatts_add_svcs(gatt_svcs);             // Initialize NimBLE configuration - queues gatt services.
    ble_hs_cfg.sync_cb = ble_app_on_sync;      // Initialize application
    nimble_port_freertos_init(host_task);      // Run the thread
 
    xTaskCreate(&numberGenerator, "main Task", 4096, NULL, 2, &numGenHandler);
}

GeSHi © Codebox Plus Extension

Posted: **Sat Jul 06, 2024 5:04 pm**

CascadingStatic wrote: ↑
Sat Jul 06, 2024 1:05 am
MY PROBLEM: nimble_port_run(), which enables BLE functionality and makes my ESP BLE server accessible, blocks until nimble_port_stop() is called elsewhere.

I'm not sure I get what your problem actually is.
Yes, nimble_port_run() loops processing BLE events until NimBLE is stopped. That's why nimble_port_freertos_init(...) internally creates a new task dedicated to running this loop.
When started, advertising also runs "in the background", concurrently to your application's other tasks, until it times out or is stopped.
If you want to change the contents of the advertisement message, you'll have to stop advertising, reconfigure the advertisement, and start advertising again.
When a BLE client is connected and tries to read an attribute you delared, the callback function you defined (device_read() in your case) is called by the BLE stack to provide the data to return to the client.
If the server wishes to notify a client, e.g. because an attribute's value has changed, it can proactively send a notification or indication to the client, provided the client has previously 'subscribed' to/enabled the notification by writing to the corresponding CCCD attribute.

To share data between tasks, e.g. the numberGenerator and the BLE host task, there are a couple of possible ways. For single values of 32 bits or less, declaring a volatile variable can be sufficient (like 'volatile int NUM_FOR_BLE;').

Posted: **Sat Jul 06, 2024 6:09 pm**

MicroController wrote: ↑
Sat Jul 06, 2024 5:04 pm
I'm not sure I get what your problem actually is.
Yes, nimble_port_run() loops processing BLE events until NimBLE is stopped. That's why nimble_port_freertos_init(...) internally creates a new task dedicated to running this loop.
When started, advertising also runs "in the background", concurrently to your application's other tasks, until it times out or is stopped.
If you want to change the contents of the advertisement message, you'll have to stop advertising, reconfigure the advertisement, and start advertising again.
When a BLE client is connected and tries to read an attribute you delared, the callback function you defined (device_read() in your case) is called by the BLE stack to provide the data to return to the client.
If the server wishes to notify a client, e.g. because an attribute's value has changed, it can proactively send a notification or indication to the client, provided the client has previously 'subscribed' to/enabled the notification by writing to the corresponding CCCD attribute.

To share data between tasks, e.g. the numberGenerator and the BLE host task, there are a couple of possible ways. For single values of 32 bits or less, declaring a volatile variable can be sufficient (like 'volatile int NUM_FOR_BLE;').

Hi, I'm really sorry -- I wrote that at ~0300 and thought I had included: currently, the BLE task seems to be completely blocking my own generator task; that fprintf only outputs to the serial console, and likewise the NUM_FOR_BLE is only changed, if I call a read or a write service from my client (I cut this out from the example code to keep it smaller -- it follows the same standard GATT/callback format -- code included below *** should it be relevant). The number generator task doesn't actually run at all.

This is program-breaking for me as I need to continually update the global integer with the value returned from an environmental monitoring peripheral -- the device_read() pulls on that when writing to the mbuf. My understanding is/was thatif the client is connected to and requests a read service several times, that global NUM_FOR_BLE's value and its changed should be passed over to the BLE client app, no?

Your suggesiton to use the 'notify' service with a volatile attribute, and let it continually message out without needing to an acknowledgement back from client, and without need of me repeatedly making requests to the 'read' service, like you say, seems like the better choice either way!

Here's the code *** if relevant/helpful for context

Code: Select all

// Array of pointers to other service definitions
// UUID - Universal Unique Identifier
static const struct ble_gatt_svc_def gatt_svcs[] = {
    {.type = BLE_GATT_SVC_TYPE_PRIMARY,
     .uuid = BLE_UUID16_DECLARE(0x180),                 // Define UUID for device type
     .characteristics = (struct ble_gatt_chr_def[]) {
            {
                .uuid = BLE_UUID16_DECLARE(0xFEF4),           // Define UUID for reading
                .flags = BLE_GATT_CHR_F_READ,
                .access_cb = device_read
            },
            {
                .uuid = BLE_UUID16_DECLARE(0xDEAD),           // Define UUID for writing
                .flags = BLE_GATT_CHR_F_WRITE,
                .access_cb = device_write
            },
            {
                0
            }
        }
    },
    {0}
};

static int device_write(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg)
{
    char * data = (char *)ctxt->om->om_data;
    printf("Data from the client: %.*s\n", ctxt->om->om_len, ctxt->om->om_data);   
    return 0;
}

Posted: **Sat Jul 06, 2024 7:57 pm**

I think I see the issue now:

Code: Select all

vTaskDelay(portTICK_PERIOD_MS * 2000);

in numberGenerator() should be

Code: Select all

vTaskDelay(2000 / portTICK_PERIOD_MS);

to get the 2000ms delay I believe you want..

ESP32 Forum

RTOS & BLE: nimble_port_run() is blocking; how to advertise constantly with own concurrent functionality?

RTOS & BLE: nimble_port_run() is blocking; how to advertise constantly with own concurrent functionality?

Re: RTOS & BLE: nimble_port_run() is blocking; how to advertise constantly with own concurrent functionality?

Re: RTOS & BLE: nimble_port_run() is blocking; how to advertise constantly with own concurrent functionality?

Re: RTOS & BLE: nimble_port_run() is blocking; how to advertise constantly with own concurrent functionality?