TWI Bluetooth transmittion problem.

RE: TWI Bluetooth transmittion problem.

Simonr — Tue, 23 Jul 2024 06:23:39 GMT

I've taken over this case while Edvin is out of office and will try to help you out.

First off, the error code 0xC corresponds to NRF_ERROR_BUSY, which means that the function sd_ble_gatts_hvx is unable to complete because the SoftDevice is busy with another operation. So you likely have to wait for the SoftDevice to be ready before calling the characteristics update function in your application.

The device doesn't show an error code regarding what's going wrong on the connection side, but I'm guessing it's related as well. I think you're trying to do "everything" at once without waiting for the SoftDevice to be ready for it. Please check out our other samples (ble_app_uart for example) to see how it's done there, with breaks, wait loops, and return codes, etc. and implement that on your end as well.

Best regards,

Simon

RE: TWI Bluetooth transmittion problem.

Joseph — Mon, 22 Jul 2024 17:13:54 GMT

Hi AHaug,

Would I be able to get a help faster? I need this code to work soon:(

If there's any possible way that I can get help, please let me know.

Thank you!

RE: TWI Bluetooth transmittion problem.

AHaug — Wed, 17 Jul 2024 11:50:20 GMT

Hi,

Edvin is out on vacation for a few more weeks, so this is just a heads up to let you know that it might take some time before we can follow up on this. We'll let you know more about a status/ETA next week.

Thank you for your patience.

Kind regards,
Andreas

RE: TWI Bluetooth transmittion problem.

Joseph — Sun, 14 Jul 2024 21:51:49 GMT

Hi Edvin,

I made changes to my code. I followed your idea and I'm using GATT to update the data that I want to send out when the Bluetooth connection is made. I'm still not sure what you mean by the defined latency.

This is my current code but it seems like I'm not able to read the data that's being updated through Wireshark. Also, I'm not able to connect to the advertising ble device with nRF Connect on my phone. It's keep saying that it's connecting. After few seconds, I get an error in the terminal saying this:

This is my current code:

#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf.h"
#include "app_error.h"
#include "ble.h"
#include "ble_hci.h"
#include "ble_srv_common.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "app_timer.h"
#include "nrf_pwr_mgmt.h"
#include "app_util_platform.h"
#include "nrf_drv_twi.h"
#include "nrf_delay.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "mpu6050.h"
#include <math.h>

#define DEVICE_NAME                     "MPU"
#define APP_ADV_INTERVAL                300
#define APP_ADV_DURATION                0
#define APP_BLE_CONN_CFG_TAG            1
#define APP_BLE_OBSERVER_PRIO           3

#define TWI_SCL_PIN                     25
#define TWI_SDA_PIN                     24

#define gyroSENSITIVITY                 131.0f
#define G_CONSTANT                      9.8f
#define accSENSITIVITY                  16384.0f

#define BLE_UUID_OUR_BASE_UUID          {0x23, 0xD1, 0xBC, 0xEA, 0x5F, 0x4A, 0xC3, 0x93, \
                                         0xE0, 0xA9, 0xE5, 0x0E, 0x24, 0xE7, 0xB5, 0x00} // 128-bit base UUID
#define BLE_UUID_OUR_SERVICE            0x1400
#define BLE_UUID_OUR_CHARACTERISTIC     0x1401

BLE_ADVERTISING_DEF(m_advertising);
NRF_BLE_GATT_DEF(m_gatt);
NRF_BLE_QWR_DEF(m_qwr);

static uint8_t m_adv_data[24];
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;
static ble_gatts_char_handles_t m_char_handles;
static uint16_t m_service_handle;

static void advertising_start(void);
void update_characteristic_value(void);
void mpu6050_data_update(void);

void twi_init(void) {
    ret_code_t err_code;

    const nrf_drv_twi_config_t twi_config = {
        .scl                = TWI_SCL_PIN,
        .sda                = TWI_SDA_PIN,
        .frequency          = NRF_TWI_FREQ_400K,
        .interrupt_priority = APP_IRQ_PRIORITY_HIGH,
        .clear_bus_init     = false
    };

    err_code = nrf_drv_twi_init(&m_twi, &twi_config, NULL, NULL);
    APP_ERROR_CHECK(err_code);

    nrf_drv_twi_enable(&m_twi);
}

static void on_adv_evt(ble_adv_evt_t ble_adv_evt) {
    switch (ble_adv_evt) {
        case BLE_ADV_EVT_FAST:
            NRF_LOG_INFO("Fast advertising.");
            break;
        case BLE_ADV_EVT_IDLE:
            advertising_start();
            break;
        default:
            break;
    }
}

static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context) {
    ret_code_t err_code;

    switch (p_ble_evt->header.evt_id) {
        case BLE_GAP_EVT_DISCONNECTED:
            NRF_LOG_INFO("Disconnected.");
            m_conn_handle = BLE_CONN_HANDLE_INVALID;
            advertising_start();
            break;
        case BLE_GAP_EVT_CONNECTED:
            NRF_LOG_INFO("Connected.");
            m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
            break;
        default:
            break;
    }
}

static void gap_params_init(void) {
    ret_code_t err_code;
    ble_gap_conn_params_t gap_conn_params;
    ble_gap_conn_sec_mode_t sec_mode;

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);

    err_code = sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *)DEVICE_NAME, strlen(DEVICE_NAME));
    APP_ERROR_CHECK(err_code);

    memset(&gap_conn_params, 0, sizeof(gap_conn_params));

    gap_conn_params.min_conn_interval = MSEC_TO_UNITS(100, UNIT_1_25_MS);
    gap_conn_params.max_conn_interval = MSEC_TO_UNITS(200, UNIT_1_25_MS);
    gap_conn_params.slave_latency     = 0;
    gap_conn_params.conn_sup_timeout  = MSEC_TO_UNITS(4000, UNIT_10_MS);

    err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
    APP_ERROR_CHECK(err_code);
}

static void advertising_init(void) {
    ret_code_t err_code;
    ble_advdata_t advdata;

    memset(&advdata, 0, sizeof(advdata));

    advdata.name_type               = BLE_ADVDATA_FULL_NAME;
    advdata.include_appearance      = false;
    advdata.flags                   = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;

    ble_advertising_init_t init;
    memset(&init, 0, sizeof(init));

    init.advdata = advdata;
    init.config.ble_adv_fast_enabled  = true;
    init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
    init.config.ble_adv_fast_timeout  = APP_ADV_DURATION;
    init.evt_handler = on_adv_evt;

    err_code = ble_advertising_init(&m_advertising, &init);
    APP_ERROR_CHECK(err_code);

    ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
}

static void services_init(void) {
    ret_code_t err_code;
    ble_uuid_t service_uuid;
    ble_uuid128_t base_uuid = BLE_UUID_OUR_BASE_UUID;
    service_uuid.uuid = BLE_UUID_OUR_SERVICE;

    err_code = sd_ble_uuid_vs_add(&base_uuid, &service_uuid.type);
    APP_ERROR_CHECK(err_code);

    err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &service_uuid, &m_service_handle);
    APP_ERROR_CHECK(err_code);

    // Add a characteristic to the service
    ble_gatts_char_md_t char_md;
    memset(&char_md, 0, sizeof(char_md));
    char_md.char_props.read = 1;
    char_md.char_props.write = 1;
    char_md.char_props.notify = 1;

    ble_uuid_t char_uuid;
    char_uuid.uuid = BLE_UUID_OUR_CHARACTERISTIC;
    char_uuid.type = service_uuid.type;

    ble_gatts_attr_md_t attr_md;
    memset(&attr_md, 0, sizeof(attr_md));
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.write_perm);
    attr_md.vloc = BLE_GATTS_VLOC_STACK;

    ble_gatts_attr_t attr_char_value;
    memset(&attr_char_value, 0, sizeof(attr_char_value));
    attr_char_value.p_uuid = &char_uuid;
    attr_char_value.p_attr_md = &attr_md;
    attr_char_value.init_len = sizeof(uint8_t) * 20;
    attr_char_value.init_offs = 0;
    attr_char_value.max_len = sizeof(uint8_t) * 20;

    err_code = sd_ble_gatts_characteristic_add(m_service_handle, &char_md, &attr_char_value, &m_char_handles);
    APP_ERROR_CHECK(err_code);
}

static void ble_stack_init(void) {
    ret_code_t err_code = nrf_sdh_enable_request();
    APP_ERROR_CHECK(err_code);

    uint32_t ram_start = 0x20001800;
    err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(err_code);

    NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
}

static void power_management_init(void) {
    ret_code_t err_code = nrf_pwr_mgmt_init();
    APP_ERROR_CHECK(err_code);
}

static void idle_state_handle(void) {
    if (NRF_LOG_PROCESS() == false) {
        nrf_pwr_mgmt_run();
    }
}

static void advertising_start(void) {
    ret_code_t err_code;
    err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
    APP_ERROR_CHECK(err_code);
}

void mpu6050_data_update(void) {
    int16_t accel_data[3], gyro_data[3];
    float ax, ay, az, gx, gy, gz;

    read_mpu6050_data(accel_data, gyro_data);

    ax = ((float)accel_data[0] / accSENSITIVITY) * G_CONSTANT;
    ay = ((float)accel_data[1] / accSENSITIVITY) * G_CONSTANT;
    az = ((float)accel_data[2] / accSENSITIVITY) * G_CONSTANT;
    gx = ((float)gyro_data[0] / gyroSENSITIVITY) * (M_PI / 180);
    gy = ((float)gyro_data[1] / gyroSENSITIVITY) * (M_PI / 180);
    gz = ((float)gyro_data[2] / gyroSENSITIVITY) * (M_PI / 180);

    memcpy(&m_adv_data[0],  &ax, 4);
    memcpy(&m_adv_data[4],  &ay, 4);
    memcpy(&m_adv_data[8],  &az, 4);
    memcpy(&m_adv_data[12], &gx, 4);
    memcpy(&m_adv_data[16], &gy, 4);
    memcpy(&m_adv_data[20], &gz, 4);

    NRF_LOG_RAW_INFO("m_adv_data[] = ");
    for (int i = 0; i < sizeof(m_adv_data); i++) {
        NRF_LOG_RAW_INFO("%02x:", m_adv_data[i]);
    }
    NRF_LOG_RAW_INFO("\r\n");

    update_characteristic_value();
}

void update_characteristic_value(void) {
    if (m_conn_handle != BLE_CONN_HANDLE_INVALID) {
        uint16_t len = sizeof(m_adv_data);
        ble_gatts_hvx_params_t hvx_params;
        memset(&hvx_params, 0, sizeof(hvx_params));

        hvx_params.handle = m_char_handles.value_handle;
        hvx_params.type = BLE_GATT_HVX_NOTIFICATION;
        hvx_params.offset = 0;
        hvx_params.p_len = &len;
        hvx_params.p_data = m_adv_data;

        ret_code_t err_code = sd_ble_gatts_hvx(m_conn_handle, &hvx_params);
        if (err_code != NRF_SUCCESS) {
            NRF_LOG_ERROR("sd_ble_gatts_hvx failed: 0x%x", err_code);
        }
    }
}

int main(void) {
    APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
    NRF_LOG_DEFAULT_BACKENDS_INIT();

    NRF_LOG_INFO("MPU6050 BLE example started.");
    NRF_LOG_FLUSH();

    twi_init();
    mpu6050_init();

    power_management_init();
    ble_stack_init();
    gap_params_init();
    advertising_init();
    services_init();

    advertising_start();

    while (true) {
        mpu6050_data_update();

        nrf_delay_ms(1000);
        idle_state_handle();
    }
}

RE: TWI Bluetooth transmittion problem.

Edvin — Mon, 01 Jul 2024 21:32:48 GMT

Hello,

I see. Yes. Using a connection instead of advertising allows you to get more data through. I suggest that you check out the ble_app_uart and ble_app_uart_c examples from the SDK. Instead of sending the data through your advertisements, you can just create an array uint8_t my_data[24], and update this array, and send it using ble_nus_data_send().

You should be able to get a decent throughput using this method, so you can send the data many times per second. You will however have a defined latency. Something called "the connection interval". The connection interval is the amount of times that pass between every time the devices communicate. So if you queue up a packet, it will be sent the next connection interval. So if you are lucky, the queued packet will be sent less than 1ms after it is queued up, and if you are unlucky, you queue it up directly after the devices has communicated, meaning it is almost an entire connection interval until the next time it will be able to send the packet.

I think the default values should be quite sufficient, but let me know if you need it to be shorter, and you struggle to do so. By default you should see a connection interval of around 30ms. I don't know how frequent you intend to send the data?

Best regards,

Edvin

RE: TWI Bluetooth transmittion problem.

Joseph — Sun, 30 Jun 2024 02:24:16 GMT

Hi Edvin,

Thank you so much for your help:)

What I'm trying to do with the acceleration and gyro is to use that data to predict some linear motion.

Therefore, I can't receive acceleration and gyro values at different time. I also want to able to receive those data as soon as possible so that I have more accurate linear motion prediction.

I'm able to use the code you modified and get the updated ACC and gyro values through BLE but the interval of those data is pretty long.

I'm using other dongle(NRF52840) to fetch the BLE transmitted from NRF52. I'm using Wireshark to get the data.

I think I might be better of modifying the code so that I can connect to the dongle by Bluetooth and transmit data with no restrictions. However, I'm not sure how to code this..

Would you be able to guide me please? Thank you so much for your help!!!

RE: TWI Bluetooth transmittion problem.

Edvin — Fri, 28 Jun 2024 22:11:56 GMT

Oh, I forgot to add the main.c file that I ended up with, where I split up the advertisement packet into advdata and srdata. Both in advertising_init() and in update_advertising_data().

devzone.nordicsemi.com/.../68108.main.c

RE: TWI Bluetooth transmittion problem.

Edvin — Fri, 28 Jun 2024 22:10:04 GMT

[quote user="Sangwoo Suk"] I'm planning to gather those data through BLE. [/quote]

What do you plan to use to gather those data? Another nRF board? A mobile phone? A computer? What will be the scanner?

[quote user="Sangwoo Suk"]How can I store them so that I can transmit 3 gyro and 3 acceleration values all together with no ram problem?[/quote]

The issue starts when you try to copy ax, ay, az, gx, gy, gz into the "scaled_value" parameter. I suggest you just copy the values of ax, ay, az, gx, gy, gz into your m_adv_data[] buffer:

Now, I don't have the gyroscope that you are using, so I will only change the main() function. For general c-functions, I usually google the name of it, and "c", and click the first hit. So googling "memcpy c" lead me here.

So I ended up with something like this:

void process_logs(void)
{
    while (NRF_LOG_PROCESS())
    {
        // do nothing.
    }
}

int main(void) {
    int16_t accel_data[3], gyro_data[3];
    float ax, ay, az, gx, gy, gz;

    APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
    NRF_LOG_DEFAULT_BACKENDS_INIT();

    NRF_LOG_INFO("MPU6050 BLE example started.");
    NRF_LOG_FLUSH();

    twi_init();
    mpu6050_init();

    power_management_init();
    ble_stack_init();
    gap_params_init();
    advertising_init();

    advertising_start();

    while (true) {
        //read_mpu6050_data(accel_data, gyro_data);

        // Log raw data for debugging
        NRF_LOG_INFO("Raw ACC: X=%d, Y=%d, Z=%d; Raw GYRO: X=%d, Y=%d, Z=%d",
                     accel_data[0], accel_data[1], accel_data[2],
                     gyro_data[0], gyro_data[1], gyro_data[2]);

        ax = ((float)accel_data[0] / accSENSITIVITY) * G_CONSTANT;
        ay = ((float)accel_data[1] / accSENSITIVITY) * G_CONSTANT;
        az = ((float)accel_data[2] / accSENSITIVITY) * G_CONSTANT;
        gx = ((float)gyro_data[0] / gyroSENSITIVITY) * (M_PI / 180);
        gy = ((float)gyro_data[1] / gyroSENSITIVITY) * (M_PI / 180);
        gz = ((float)gyro_data[2] / gyroSENSITIVITY) * (M_PI / 180);

        memcpy(&m_adv_data[0],  &ax, 4); // since the size of a float is 4 bytes.
        memcpy(&m_adv_data[4],  &ay, 4);
        memcpy(&m_adv_data[8],  &az, 4);
        memcpy(&m_adv_data[12], &gx, 4);
        memcpy(&m_adv_data[16], &gy, 4);
        memcpy(&m_adv_data[20], &gz, 4);

        NRF_LOG_RAW_INFO("m_adv_data[] = ");
        for (int i=0; i<sizeof(m_adv_data); i++)
        {
          NRF_LOG_RAW_INFO("%02x:", m_adv_data[i]);
        }
        NRF_LOG_RAW_INFO("\r\n");

        update_advertising_data();

        process_logs();

        nrf_delay_ms(1000);
        idle_state_handle();
    }
}

And actually testing this I realized that there was not room in the advertising packet for the entire 24 bytes of gyro data, in addition to the 3 bytes for the name ("MPU"), the 1 byte for the flags and the advertising element description byte and advertising element length byte for each of your 3 elements in the advertising packet. In addition, manufacturer specific data requires the company identifier (2 bytes) as the first two bytes of the manufacturer specific data. So in total we were looking at:

[1B]flags_element, [1B] length of flag element, [1B] actual flags, [1B] name_element, [1B] name length, [3B] actual name, [1B] manufacturer specific data element, [1B] manufacturer specific data length, [2B] manufacturer identifier, [24B] gyro/accel data

which adds up to 36 bytes, which is slightly higher than the 31 bytes that are the max length of an advertising packet. Luckily, it is quite easy to add scan response data, which is a whole second advertising packet that you can use. So I stripped away the manufacturer specific data, and added it to the scan response data. The manufacturer specific data now consists of 28 bytes, and your main advertising packet is 8 bytes, including flags and name.

Depending on your scanner, this may be a little extra work, because now the name and the actual sensor data are no longer on the same advertising packet. So when you are scanning, depending on what you use to scan, you may need to first take note of the device that has the correct name, and then check the next advertising packet from that device (coming from the same address as the device with the correct name).

Another option than splitting up the advertising packet in an advertising packet and a scan response packet is to slim down the amount of data in the original advertising packet. Perhaps you can send the accellerometer data and the gyro data every other second, and add a byte at the start saying whether this is the accellerometer data or the gyroscope data.

A 3rd option is to actually enter a connection with the scanner. This way you can send a lot longer packets (up to 247 bytes), so the size should not be a limit there. In addition this will have ACKing, so that you know that the connected device actually received the packet.

But back to the example where the advertisements are split into two packets, the advertising packet and the scan response packet. When you scan you will not immediately see nice float numbers in the advertisement packet, because that is not how embedded programming works. You can only send bytes, and each float number consists of 4 bytes. Then it is up to the receiver to determine how to interpret these 4 bytes. If you write the program for the receiver as well, you would know that this packet contains 6*4 bytes, which makes up 6 floating point numbers. So in case you want to do the reversal operation in C, it would look something like this:

float az;
memcpy(&az, &m_scan_data[8], 4); // not necessarily m_scan_data[8], but whereever the start of that float ends up in the scanned advertising packet). 8 bytes after the manufacturer ID.
NRF_LOG_INFO("az: " NRF_LOG_FLOAT_MARKER, NRF_LOG_FLOAT(az));

Best regards,

Edvin

RE: TWI Bluetooth transmittion problem.

Joseph — Fri, 28 Jun 2024 19:01:23 GMT

I don't understand how to use the debug function. Also, I don't think I understand how you store the acceleration and gyro values too..

What I'm trying to do is to send out advertising data packet with gyro and acceleration values. I'm planning to gather those data through BLE.

How can I store them so that I can transmit 3 gyro and 3 acceleration values all together with no ram problem?

RE: TWI Bluetooth transmittion problem.

Edvin — Thu, 27 Jun 2024 10:18:06 GMT

Thank you for sharing the projects.

Some few hints while developing:

1: Open your project settings. For all project settings, select the "Common" option in the drop down menu. Then select the preprocessor definitions, and add "DEBUG" to the list:

2: Then I also added a small function that will print out the log. call this directly before nrf_delay_ms(1000) in your main loop. Do not call it from anywhere else, as it may lead to weird behavior.

void process_logs(void)
{
    while (NRF_LOG_PROCESS())
    {
        // Do nothing.
    }
}

int main(void)
{
    ...
    while (true)
    {
        ...
        process_logs();
        nrf_delay_ms(1000);
        idle_state_handle();
    }
}

3: Then, you can also debug your application. You can set breakpoints, and add variables to watch, to monitor their value. Note that when you are using the softdevice, and set a breakpoint that is hit, then you can't continue to step. You need to reset the application.

Using these three steps, I see that the casting that you are doing is not working as you expect it to. The scaled_value parameter doesn't get the value of ax*100. It is 0.

I don't know what you intend to do with these numbers. If you only plan to send them out and process it somewhere else, then you can just copy the values into your m_adv_data (memcpy()). If you need to find out what format you want them to be.

Best regards,

Edvin

RE: TWI Bluetooth transmittion problem.

Joseph — Tue, 25 Jun 2024 19:02:41 GMT

I just tried printing the m_adv_data.

But I'm getting this issue:

Also, I have attached zip file here. My project is under example file and the folder name is called "ble_app_template_twi(use this). go into pca10040 afterwards.devzone.nordicsemi.com/.../3515.nRF5_5F00_SDK_5F00_17.1.0_5F00_ddde560.zip

RE: TWI Bluetooth transmittion problem.

Edvin — Mon, 24 Jun 2024 07:52:01 GMT

If you want me to test any parts of your code, then you need to zip and upload the entire application folder that you are using (the folder containing the example and configuration files, such as the SDK\examples\ble_peripheral\<your application project>

So what do you expect the values to look like? Have you tried printing the hexadecimal values that you are feeding into your advertising data?

NRF_LOG_RAW_INFO("m_adv_data[] = ");
for (int i=0; i<sizeof(m_adv_data); i++)
{
    NRF_LOG_RAW_INFO("%02x:", m_adv_data[i]);
}
NRF_LOG_RAW_INFO("\r\n");

BR,
Edvin

RE: TWI Bluetooth transmittion problem.

Joseph — Fri, 21 Jun 2024 23:33:03 GMT

Thank you so much for your help!

I currently having a problem with sending ax,ay,az,gx,gy,gz values through BLE.

This is what acceleration and gyro values that should be sent out by BLE:

However, this is a snapshot of data that's sent through BLE. I used Wireshark to get this data:

Frame 723682: 63 bytes on wire (504 bits), 63 bytes captured (504 bits) on interface COM8-4.2, id 0
    Section number: 1
    Interface id: 0 (COM8-4.2)
    Encapsulation type: nRF Sniffer for Bluetooth LE (186)
    Arrival Time: Jun 21, 2024 18:27:41.048745000 중부 일광 절약 시간
    UTC Arrival Time: Jun 21, 2024 23:27:41.048745000 UTC
    Epoch Arrival Time: 1719012461.048745000
    [Time shift for this packet: 0.000000000 seconds]
    [Time delta from previous captured frame: 0.000755000 seconds]
    [Time delta from previous displayed frame: 0.000755000 seconds]
    [Time since reference or first frame: 3786.864048000 seconds]
    Frame Number: 723682
    Frame Length: 63 bytes (504 bits)
    Capture Length: 63 bytes (504 bits)
    [Frame is marked: False]
    [Frame is ignored: False]
    [Protocols in frame: nordic_ble:btle:btcommon]
nRF Sniffer for Bluetooth LE
    Board: 8
    Header Version: 3, Packet counter: 6013
        Length of payload: 56
        Protocol version: 3
        Packet counter: 6013
        Packet ID: 2
    Length of packet: 10
    Flags: 0x01
        .... ...1 = CRC: Ok
        .... ..0. = Reserved: 0
        .... .0.. = Reserved: 0
        .... 0... = Address Resolved: No
        .000 .... = PHY: LE 1M (0)
        0... .... = Reserved: 0
    Channel Index: 39
    RSSI: -51 dBm
    Event counter: 0
    Timestamp: 76326918µs
    [Packet time (start to end): 376µs]
    [Delta time (end to start): 579µs]
    [Delta time (start to start): 755µs]
Bluetooth Low Energy Link Layer
    Access Address: 0x8e89bed6
    Packet Header: 0x2560 (PDU Type: ADV_IND, ChSel: #2, TxAdd: Random)
    Advertising Address: cc:69:fe:c9:06:21 (cc:69:fe:c9:06:21)
    Advertising Data
        Flags
            Length: 2
            Type: Flags (0x01)
            000. .... = Reserved: 0x0
            ...0 .... = Simultaneous LE and BR/EDR to Same Device Capable (Host): false (0x0)
            .... 0... = Simultaneous LE and BR/EDR to Same Device Capable (Controller): false (0x0)
            .... .1.. = BR/EDR Not Supported: true (0x1)
            .... ..1. = LE General Discoverable Mode: true (0x1)
            .... ...0 = LE Limited Discoverable Mode: false (0x0)
        Manufacturer Specific
            Length: 23
            Type: Manufacturer Specific (0xff)
            Company ID: Nordic Semiconductor ASA (0x0059)
            Data: 0024ffbd03760000000000000000000000000000
                [Expert Info (Note/Undecoded): Undecoded]
        Device Name (shortened): MP
            Length: 3
            Type: Device Name (shortened) (0x08)
            Device Name: MP
    CRC: 0xca4899

I don't think I'm sending correct acceleration and gyro values through BLE.

This is my current code:

#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf.h"
#include "app_error.h"
#include "ble.h"
#include "ble_hci.h"
#include "ble_srv_common.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "app_timer.h"
#include "nrf_pwr_mgmt.h"
#include "app_util_platform.h"
#include "nrf_drv_twi.h"
#include "nrf_delay.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "mpu6050.h"
#include <math.h>  // Include this for M_PI(pi)

#define DEVICE_NAME                     "MPU"                          
#define APP_ADV_INTERVAL                300                             
#define APP_ADV_DURATION                0                               
#define APP_BLE_CONN_CFG_TAG            1                               

#define TWI_SCL_PIN                     25                              
#define TWI_SDA_PIN                     24                              

#define gyroSENSITIVITY                 131.0f
#define G_CONSTANT                      9.8f
#define accSENSITIVITY                  16384.0f

BLE_ADVERTISING_DEF(m_advertising);                                      

static uint8_t m_adv_data[20];                                            
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;                  
static char log_buffer[256];

static void advertising_start(void);

void twi_init(void) {
    ret_code_t err_code;

    const nrf_drv_twi_config_t twi_config = {
       .scl                = TWI_SCL_PIN,
       .sda                = TWI_SDA_PIN,
       .frequency          = NRF_TWI_FREQ_400K,
       .interrupt_priority = APP_IRQ_PRIORITY_HIGH,
       .clear_bus_init     = false
    };

    err_code = nrf_drv_twi_init(&m_twi, &twi_config, NULL, NULL);
    APP_ERROR_CHECK(err_code);

    nrf_drv_twi_enable(&m_twi);
}

static void on_adv_evt(ble_adv_evt_t ble_adv_evt) {
    switch (ble_adv_evt) {
        case BLE_ADV_EVT_FAST:
            NRF_LOG_INFO("Fast advertising.");
            break;
        case BLE_ADV_EVT_IDLE:
            advertising_start();
            break;
        default:
            break;
    }
}

static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context) {
    switch (p_ble_evt->header.evt_id) {
        case BLE_GAP_EVT_DISCONNECTED:
            NRF_LOG_INFO("Disconnected.");
            break;
        case BLE_GAP_EVT_CONNECTED:
            NRF_LOG_INFO("Connected.");
            m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
            break;
        default:
            break;
    }
}

static void gap_params_init(void) {
    ret_code_t err_code;
    ble_gap_conn_params_t gap_conn_params;
    ble_gap_conn_sec_mode_t sec_mode;

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);

    err_code = sd_ble_gap_device_name_set(&sec_mode,
                                          (const uint8_t *)DEVICE_NAME,
                                          strlen(DEVICE_NAME));
    APP_ERROR_CHECK(err_code);

    memset(&gap_conn_params, 0, sizeof(gap_conn_params));

    gap_conn_params.min_conn_interval = MSEC_TO_UNITS(100, UNIT_1_25_MS);
    gap_conn_params.max_conn_interval = MSEC_TO_UNITS(200, UNIT_1_25_MS);
    gap_conn_params.slave_latency     = 0;
    gap_conn_params.conn_sup_timeout  = MSEC_TO_UNITS(4000, UNIT_10_MS);

    err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
    APP_ERROR_CHECK(err_code);
}

static void advertising_init(void) {
    ret_code_t err_code;
    ble_advdata_t advdata;

    memset(&advdata, 0, sizeof(advdata));

    advdata.name_type               = BLE_ADVDATA_FULL_NAME;
    advdata.include_appearance      = false;
    advdata.flags                   = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;

    ble_advdata_manuf_data_t manuf_data;
    manuf_data.company_identifier = 0x0059; // Nordic Semiconductor company ID
    manuf_data.data.p_data = m_adv_data;
    manuf_data.data.size = sizeof(m_adv_data);

    advdata.p_manuf_specific_data = &manuf_data;

    ble_advertising_init_t init;
    memset(&init, 0, sizeof(init));

    init.advdata = advdata;
    init.config.ble_adv_fast_enabled  = true;
    init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
    init.config.ble_adv_fast_timeout  = APP_ADV_DURATION;
    init.evt_handler = on_adv_evt;

    err_code = ble_advertising_init(&m_advertising, &init);
    APP_ERROR_CHECK(err_code);

    ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
}

static void ble_stack_init(void) {
    ret_code_t err_code = nrf_sdh_enable_request();
    APP_ERROR_CHECK(err_code);

    uint32_t ram_start = 0x20001800;  // Adjusted RAM start
    err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(err_code);
}

static void power_management_init(void) {
    ret_code_t err_code = nrf_pwr_mgmt_init();
    APP_ERROR_CHECK(err_code);
}

static void idle_state_handle(void) {
    if (NRF_LOG_PROCESS() == false) {
        nrf_pwr_mgmt_run();
    }
}

static void advertising_start(void) {
    ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
    APP_ERROR_CHECK(err_code);
}

void update_advertising_data(void) {
    ret_code_t err_code;
    ble_advdata_t advdata;

    ble_advdata_manuf_data_t manuf_data;
    manuf_data.company_identifier = 0x0059;
    manuf_data.data.p_data = m_adv_data;
    manuf_data.data.size = sizeof(m_adv_data);

    memset(&advdata, 0, sizeof(advdata));
    advdata.name_type               = BLE_ADVDATA_FULL_NAME;
    advdata.include_appearance      = false;
    advdata.flags                   = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
    advdata.p_manuf_specific_data   = &manuf_data;

    err_code = ble_advertising_advdata_update(&m_advertising, &advdata, NULL);
    APP_ERROR_CHECK(err_code);
}

int main(void) {
    int16_t accel_data[3], gyro_data[3];
    float ax, ay, az, gx, gy, gz;

    APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
    NRF_LOG_DEFAULT_BACKENDS_INIT();

    NRF_LOG_INFO("MPU6050 BLE example started.");
    NRF_LOG_FLUSH();

    twi_init();
    mpu6050_init();

    power_management_init();
    ble_stack_init();
    gap_params_init();
    advertising_init();

    advertising_start();

    while (true) {
        read_mpu6050_data(accel_data, gyro_data);

        // Log raw data for debugging
        NRF_LOG_INFO("Raw ACC: X=%d, Y=%d, Z=%d; Raw GYRO: X=%d, Y=%d, Z=%d",
                     accel_data[0], accel_data[1], accel_data[2],
                     gyro_data[0], gyro_data[1], gyro_data[2]);

        ax = ((float)accel_data[0] / accSENSITIVITY) * G_CONSTANT;
        ay = ((float)accel_data[1] / accSENSITIVITY) * G_CONSTANT;
        az = ((float)accel_data[2] / accSENSITIVITY) * G_CONSTANT;
        gx = ((float)gyro_data[0] / gyroSENSITIVITY) * (M_PI / 180);
        gy = ((float)gyro_data[1] / gyroSENSITIVITY) * (M_PI / 180);
        gz = ((float)gyro_data[2] / gyroSENSITIVITY) * (M_PI / 180);


        uint8_t offset = 0;
        // Directly update m_adv_data array with scaled values
        int16_t scaled_value;

        scaled_value = (int16_t)(ax*100);
        m_adv_data[offset++] = (scaled_value >> 8) & 0xFF;
        m_adv_data[offset++] = scaled_value & 0xFF;

        scaled_value = (int16_t)(ay*100);
        m_adv_data[offset++] = (scaled_value >> 8) & 0xFF;
        m_adv_data[offset++] = scaled_value & 0xFF;

        scaled_value = (int16_t)(az*100);
        m_adv_data[offset++] = (scaled_value >> 8) & 0xFF;
        m_adv_data[offset++] = scaled_value & 0xFF;

        scaled_value = (int16_t)(gx*100);
        m_adv_data[offset++] = (scaled_value >> 8) & 0xFF;
        m_adv_data[offset++] = scaled_value & 0xFF;

        scaled_value = (int16_t)(gy*100);
        m_adv_data[offset++] = (scaled_value >> 8) & 0xFF;
        m_adv_data[offset++] = scaled_value & 0xFF;

        scaled_value = (int16_t)(gz*100);
        m_adv_data[offset++] = (scaled_value >> 8) & 0xFF;
        m_adv_data[offset++] = scaled_value & 0xFF;

        update_advertising_data();

        nrf_delay_ms(1000);
        idle_state_handle();
    }
}

Thank you for helping me!

RE: TWI Bluetooth transmittion problem.

Edvin — Thu, 20 Jun 2024 11:58:54 GMT

Unless you actually intend to do any calculations on the floating numbers, you probably don't need to print them in the log. If the goal is to just send them over bluetooth either way. However, if you want to log them, please try to split up your problem. Try to strip out the accellerometer, and just try to print a floating number in the log. I got it working using:

#define ACCSENSITIVITY 16384.0f
#define GCONSTANT 9.81f

int main(void)
{
    ...
    
    float my_float = 32768.14;
    float ax = ((float)my_float / ACCSENSITIVITY * GCONSTANT);
    NRF_LOG_INFO("floating number:" NRF_LOG_FLOAT_MARKER "\r\n", NRF_LOG_FLOAT(ax));
    // Enter main loop.
    for (;;)
    {
        idle_state_handle();
    }

Perhaps your log message is too long. Try printing only one at the time.

Best regards,

Edvin

RE: TWI Bluetooth transmittion problem.

Joseph — Wed, 19 Jun 2024 21:01:47 GMT

I made a change and I get an error.

This is the error:

This is my current code:

#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf.h"
#include "app_error.h"
#include "ble.h"
#include "ble_hci.h"
#include "ble_srv_common.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "app_timer.h"
#include "nrf_pwr_mgmt.h"
#include "app_util_platform.h"
#include "nrf_drv_twi.h"
#include "nrf_delay.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "mpu6050.h"
#include <math.h>  // Include this for M_PI(pi)

#define DEVICE_NAME                     "MPU"                          
#define APP_ADV_INTERVAL                300                             
#define APP_ADV_DURATION                0                               
#define APP_BLE_CONN_CFG_TAG            1                               

#define TWI_SCL_PIN                     25                              
#define TWI_SDA_PIN                     24                              

#define gyroSENSITIVITY                 131.0f
#define G_CONSTANT                      9.81f
#define accSENSITIVITY                  16384.0f

BLE_ADVERTISING_DEF(m_advertising);                                      

static uint8_t m_adv_data[20];                                            
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;                  
static char log_buffer[256];

static void advertising_start(void);

void twi_init(void) {
    ret_code_t err_code;

    const nrf_drv_twi_config_t twi_config = {
       .scl                = TWI_SCL_PIN,
       .sda                = TWI_SDA_PIN,
       .frequency          = NRF_TWI_FREQ_400K,
       .interrupt_priority = APP_IRQ_PRIORITY_HIGH,
       .clear_bus_init     = false
    };

    err_code = nrf_drv_twi_init(&m_twi, &twi_config, NULL, NULL);
    APP_ERROR_CHECK(err_code);

    nrf_drv_twi_enable(&m_twi);
}

static void on_adv_evt(ble_adv_evt_t ble_adv_evt) {
    switch (ble_adv_evt) {
        case BLE_ADV_EVT_FAST:
            NRF_LOG_INFO("Fast advertising.");
            break;
        case BLE_ADV_EVT_IDLE:
            advertising_start();
            break;
        default:
            break;
    }
}

static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context) {
    switch (p_ble_evt->header.evt_id) {
        case BLE_GAP_EVT_DISCONNECTED:
            NRF_LOG_INFO("Disconnected.");
            break;
        case BLE_GAP_EVT_CONNECTED:
            NRF_LOG_INFO("Connected.");
            m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
            break;
        default:
            break;
    }
}

static void gap_params_init(void) {
    ret_code_t err_code;
    ble_gap_conn_params_t gap_conn_params;
    ble_gap_conn_sec_mode_t sec_mode;

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);

    err_code = sd_ble_gap_device_name_set(&sec_mode,
                                          (const uint8_t *)DEVICE_NAME,
                                          strlen(DEVICE_NAME));
    APP_ERROR_CHECK(err_code);

    memset(&gap_conn_params, 0, sizeof(gap_conn_params));

    gap_conn_params.min_conn_interval = MSEC_TO_UNITS(100, UNIT_1_25_MS);
    gap_conn_params.max_conn_interval = MSEC_TO_UNITS(200, UNIT_1_25_MS);
    gap_conn_params.slave_latency     = 0;
    gap_conn_params.conn_sup_timeout  = MSEC_TO_UNITS(4000, UNIT_10_MS);

    err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
    APP_ERROR_CHECK(err_code);
}

static void advertising_init(void) {
    ret_code_t err_code;
    ble_advdata_t advdata;

    memset(&advdata, 0, sizeof(advdata));

    advdata.name_type               = BLE_ADVDATA_FULL_NAME;
    advdata.include_appearance      = false;
    advdata.flags                   = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;

    ble_advdata_manuf_data_t manuf_data;
    manuf_data.company_identifier = 0x0059; // Nordic Semiconductor company ID
    manuf_data.data.p_data = m_adv_data;
    manuf_data.data.size = sizeof(m_adv_data);

    advdata.p_manuf_specific_data = &manuf_data;

    ble_advertising_init_t init;
    memset(&init, 0, sizeof(init));

    init.advdata = advdata;
    init.config.ble_adv_fast_enabled  = true;
    init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
    init.config.ble_adv_fast_timeout  = APP_ADV_DURATION;
    init.evt_handler = on_adv_evt;

    err_code = ble_advertising_init(&m_advertising, &init);
    APP_ERROR_CHECK(err_code);

    ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
}

static void ble_stack_init(void) {
    ret_code_t err_code = nrf_sdh_enable_request();
    APP_ERROR_CHECK(err_code);

    uint32_t ram_start = 0x20001800;  // Adjusted RAM start
    err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(err_code);
}

static void power_management_init(void) {
    ret_code_t err_code = nrf_pwr_mgmt_init();
    APP_ERROR_CHECK(err_code);
}

static void idle_state_handle(void) {
    if (NRF_LOG_PROCESS() == false) {
        nrf_pwr_mgmt_run();
    }
}

static void advertising_start(void) {
    ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
    APP_ERROR_CHECK(err_code);
}

// Function to pack scaled float data into an array as int16_t
void pack_scaled_data(uint8_t *buffer, float value, uint8_t *offset) {
    int16_t scaled_value = (int16_t)(value * 10);  // Scale to 1 decimal place
    buffer[*offset] = (scaled_value >> 8) & 0xFF;
    buffer[*offset + 1] = scaled_value & 0xFF;
    *offset += 2;
}

void update_advertising_data(void) {
    ret_code_t err_code;
    ble_advdata_t advdata;

    ble_advdata_manuf_data_t manuf_data;
    manuf_data.company_identifier = 0x0059;
    manuf_data.data.p_data = m_adv_data;
    manuf_data.data.size = sizeof(m_adv_data);

    memset(&advdata, 0, sizeof(advdata));
    advdata.name_type               = BLE_ADVDATA_FULL_NAME;
    advdata.include_appearance      = false;
    advdata.flags                   = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
    advdata.p_manuf_specific_data   = &manuf_data;

    err_code = ble_advertising_advdata_update(&m_advertising, &advdata, NULL);
    APP_ERROR_CHECK(err_code);
}

int main(void) {
    int16_t accel_data[3], gyro_data[3];
    float ax, ay, az, gx, gy, gz;

    APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
    NRF_LOG_DEFAULT_BACKENDS_INIT();

    NRF_LOG_INFO("MPU6050 BLE example started.");
    NRF_LOG_FLUSH();

    twi_init();
    mpu6050_init();

    power_management_init();
    ble_stack_init();
    gap_params_init();
    advertising_init();

    advertising_start();

    while (true) {
        read_mpu6050_data(accel_data, gyro_data);

        // Log raw data for debugging
        NRF_LOG_INFO("Raw ACC: X=%d, Y=%d, Z=%d; Raw GYRO: X=%d, Y=%d, Z=%d",
                     accel_data[0], accel_data[1], accel_data[2],
                     gyro_data[0], gyro_data[1], gyro_data[2]);

        ax = ((float)accel_data[0] / accSENSITIVITY) * G_CONSTANT;
        ay = ((float)accel_data[1] / accSENSITIVITY) * G_CONSTANT;
        az = ((float)accel_data[2] / accSENSITIVITY) * G_CONSTANT;
        gx = ((float)gyro_data[0] / gyroSENSITIVITY) * (M_PI / 180);
        gy = ((float)gyro_data[1] / gyroSENSITIVITY) * (M_PI / 180);
        gz = ((float)gyro_data[2] / gyroSENSITIVITY) * (M_PI / 180);

        // Log calculated values using NRF_LOG_FLOAT_MARKER and NRF_LOG_FLOAT
        NRF_LOG_INFO("Calculated ACC: X=" NRF_LOG_FLOAT_MARKER ", Y=" NRF_LOG_FLOAT_MARKER ", Z=" NRF_LOG_FLOAT_MARKER, NRF_LOG_FLOAT(ax), NRF_LOG_FLOAT(ay), NRF_LOG_FLOAT(az));
        NRF_LOG_INFO("Calculated GYRO: X=" NRF_LOG_FLOAT_MARKER ", Y=" NRF_LOG_FLOAT_MARKER ", Z=" NRF_LOG_FLOAT_MARKER, NRF_LOG_FLOAT(gx), NRF_LOG_FLOAT(gy), NRF_LOG_FLOAT(gz));


        uint8_t offset = 0;
        // Pack acceleration data
        pack_scaled_data(m_adv_data, ax, &offset);
        pack_scaled_data(m_adv_data, ay, &offset);
        pack_scaled_data(m_adv_data, az, &offset);
        // Pack gyroscope data
        pack_scaled_data(m_adv_data, gx, &offset);
        pack_scaled_data(m_adv_data, gy, &offset);
        pack_scaled_data(m_adv_data, gz, &offset);

        update_advertising_data();

        nrf_delay_ms(1000);
        idle_state_handle();
    }
}

RE: TWI Bluetooth transmittion problem.

Edvin — Wed, 19 Jun 2024 13:23:18 GMT

The way float numbers are handled on embedded devices is often a little different. And also in the NRF_LOG module.

Try printing them using this:

NRF_LOG_INFO("My float number: " NRF_LOG_FLOAT_MARKER "\r\n", NRF_LOG_FLOAT(ax));

Does that work?

BR,
Edvin

RE: TWI Bluetooth transmittion problem.

Joseph — Tue, 18 Jun 2024 19:31:54 GMT

I made m_adv_data as 20 byte array. It seems like I'm not getting the data issue.

However, I'm getting another issue. I'm not able to output ACC and gyro values through LOG. I know that my sensor is working properly. I think there's something wrong with the code. This is the error:

This is my current code:

#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf.h"
#include "app_error.h"
#include "ble.h"
#include "ble_hci.h"
#include "ble_srv_common.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "app_timer.h"
#include "nrf_pwr_mgmt.h"
#include "app_util_platform.h"
#include "nrf_drv_twi.h"
#include "nrf_delay.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "mpu6050.h"
#include <math.h>  // Include this for M_PI(pi)

#define DEVICE_NAME                     "MPU"                          
#define APP_ADV_INTERVAL                300                             
#define APP_ADV_DURATION                0                               
#define APP_BLE_CONN_CFG_TAG            1                               

#define TWI_SCL_PIN                     25                              
#define TWI_SDA_PIN                     24                              

#define gyroSENSITIVITY                 131.0f
#define G_CONSTANT                      9.81f
#define accSENSITIVITY                  16384.0f

BLE_ADVERTISING_DEF(m_advertising);                                      

static uint8_t m_adv_data[20];                                            
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;                  
static char log_buffer[256];

static void advertising_start(void);

void twi_init(void) {
    ret_code_t err_code;

    const nrf_drv_twi_config_t twi_config = {
       .scl                = TWI_SCL_PIN,
       .sda                = TWI_SDA_PIN,
       .frequency          = NRF_TWI_FREQ_400K,
       .interrupt_priority = APP_IRQ_PRIORITY_HIGH,
       .clear_bus_init     = false
    };

    err_code = nrf_drv_twi_init(&m_twi, &twi_config, NULL, NULL);
    APP_ERROR_CHECK(err_code);

    nrf_drv_twi_enable(&m_twi);
}

static void on_adv_evt(ble_adv_evt_t ble_adv_evt) {
    switch (ble_adv_evt) {
        case BLE_ADV_EVT_FAST:
            NRF_LOG_INFO("Fast advertising.");
            break;
        case BLE_ADV_EVT_IDLE:
            advertising_start();
            break;
        default:
            break;
    }
}

static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context) {
    switch (p_ble_evt->header.evt_id) {
        case BLE_GAP_EVT_DISCONNECTED:
            NRF_LOG_INFO("Disconnected.");
            break;
        case BLE_GAP_EVT_CONNECTED:
            NRF_LOG_INFO("Connected.");
            m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
            break;
        default:
            break;
    }
}

static void gap_params_init(void) {
    ret_code_t err_code;
    ble_gap_conn_params_t gap_conn_params;
    ble_gap_conn_sec_mode_t sec_mode;

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);

    err_code = sd_ble_gap_device_name_set(&sec_mode,
                                          (const uint8_t *)DEVICE_NAME,
                                          strlen(DEVICE_NAME));
    APP_ERROR_CHECK(err_code);

    memset(&gap_conn_params, 0, sizeof(gap_conn_params));

    gap_conn_params.min_conn_interval = MSEC_TO_UNITS(100, UNIT_1_25_MS);
    gap_conn_params.max_conn_interval = MSEC_TO_UNITS(200, UNIT_1_25_MS);
    gap_conn_params.slave_latency     = 0;
    gap_conn_params.conn_sup_timeout  = MSEC_TO_UNITS(4000, UNIT_10_MS);

    err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
    APP_ERROR_CHECK(err_code);
}

static void advertising_init(void) {
    ret_code_t err_code;
    ble_advdata_t advdata;

    memset(&advdata, 0, sizeof(advdata));

    advdata.name_type               = BLE_ADVDATA_FULL_NAME;
    advdata.include_appearance      = false;
    advdata.flags                   = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;

    ble_advdata_manuf_data_t manuf_data;
    manuf_data.company_identifier = 0x0059; // Nordic Semiconductor company ID
    manuf_data.data.p_data = m_adv_data;
    manuf_data.data.size = sizeof(m_adv_data);

    advdata.p_manuf_specific_data = &manuf_data;

    ble_advertising_init_t init;
    memset(&init, 0, sizeof(init));

    init.advdata = advdata;
    init.config.ble_adv_fast_enabled  = true;
    init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
    init.config.ble_adv_fast_timeout  = APP_ADV_DURATION;
    init.evt_handler = on_adv_evt;

    err_code = ble_advertising_init(&m_advertising, &init);
    APP_ERROR_CHECK(err_code);

    ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
}

static void ble_stack_init(void) {
    ret_code_t err_code = nrf_sdh_enable_request();
    APP_ERROR_CHECK(err_code);

    uint32_t ram_start = 0x20001800;  // Adjusted RAM start
    err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(err_code);
}

static void power_management_init(void) {
    ret_code_t err_code = nrf_pwr_mgmt_init();
    APP_ERROR_CHECK(err_code);
}

static void idle_state_handle(void) {
    if (NRF_LOG_PROCESS() == false) {
        nrf_pwr_mgmt_run();
    }
}

static void advertising_start(void) {
    ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
    APP_ERROR_CHECK(err_code);
}

// Function to pack scaled float data into an array as int16_t
void pack_scaled_data(uint8_t *buffer, float value, uint8_t *offset) {
    int16_t scaled_value = (int16_t)(value * 10);  // Scale to 1 decimal place
    buffer[*offset] = (scaled_value >> 8) & 0xFF;
    buffer[*offset + 1] = scaled_value & 0xFF;
    *offset += 2;
}

void update_advertising_data(void) {
    ret_code_t err_code;
    ble_advdata_t advdata;

    ble_advdata_manuf_data_t manuf_data;
    manuf_data.company_identifier = 0x0059;
    manuf_data.data.p_data = m_adv_data;
    manuf_data.data.size = sizeof(m_adv_data);

    memset(&advdata, 0, sizeof(advdata));
    advdata.name_type               = BLE_ADVDATA_FULL_NAME;
    advdata.include_appearance      = false;
    advdata.flags                   = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
    advdata.p_manuf_specific_data   = &manuf_data;

    err_code = ble_advertising_advdata_update(&m_advertising, &advdata, NULL);
    APP_ERROR_CHECK(err_code);
}

int main(void) {
    int16_t accel_data[3], gyro_data[3];

    APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
    NRF_LOG_DEFAULT_BACKENDS_INIT();

    NRF_LOG_INFO("MPU6050 BLE example started.");
    NRF_LOG_FLUSH();

    twi_init();
    mpu6050_init();

    power_management_init();
    ble_stack_init();
    gap_params_init();
    advertising_init();

    advertising_start();

    while (true) {
        read_mpu6050_data(accel_data, gyro_data);

        float ax = ((float)accel_data[0] / accSENSITIVITY) * G_CONSTANT;
        float ay = ((float)accel_data[1] / accSENSITIVITY) * G_CONSTANT;
        float az = ((float)accel_data[2] / accSENSITIVITY) * G_CONSTANT;
        float gx = ((float)gyro_data[0] / gyroSENSITIVITY) * (M_PI / 180);
        float gy = ((float)gyro_data[1] / gyroSENSITIVITY) * (M_PI / 180);
        float gz = ((float)gyro_data[2] / gyroSENSITIVITY) * (M_PI / 180);

        snprintf(log_buffer, sizeof(log_buffer), "ACC: X=%0.1f, Y=%0.1f, Z=%0.1f; GYRO: X=%0.1f, Y=%0.1f, Z=%0.1f",
                 ax, ay, az, gx, gy, gz);
        NRF_LOG_INFO("%s", NRF_LOG_PUSH(log_buffer));

        uint8_t offset = 0;
        // Pack acceleration data
        pack_scaled_data(m_adv_data, ax, &offset);
        pack_scaled_data(m_adv_data, ay, &offset);
        pack_scaled_data(m_adv_data, az, &offset);
        // Pack gyroscope data
        pack_scaled_data(m_adv_data, gx, &offset);
        pack_scaled_data(m_adv_data, gy, &offset);
        pack_scaled_data(m_adv_data, gz, &offset);

        update_advertising_data();

        nrf_delay_ms(1000);
        idle_state_handle();
    }
}

RE: TWI Bluetooth transmittion problem.

Edvin — Mon, 17 Jun 2024 13:37:12 GMT

Hello,

It is difficult to say exactly what the issue is caused by based on the file that you sent. Does the log say anything about where this error was coming from?

I do see, however, that you are setting your:

    ble_advdata_manuf_data_t manuf_data;
    manuf_data.company_identifier = 0x0059; // Nordic Semiconductor company ID
    manuf_data.data.p_data = m_adv_data;
    manuf_data.data.size = sizeof(m_adv_data);

and the m_adv_data is a 31 byte array.

It is correct that you have 31 bytes at your disposal, but two of these bytes will be the company identifier, one byte will be the manufacturer_specific data length.

I believe the scan response packet will look like: <type><length><company_identifier><payload>

So 1 byte for type, 1 byte for length, 2 bytes for company_identifier, this leaves you with 31-1-1-2 = 27 bytes for manufacturer data payload. Try to reduce the m_adv_data array to this size, and keep reducing it if you still get the same error. Or even better, reduce it to the amount of bytes you actually read from your sensor. A float takes 4 bytes. So if you try to push 6 float numbers, that is 24 bytes.

Best regards,

Edvin