Sending actual TWI sensor values through BLE

RE: Sending actual TWI sensor values through BLE

Einar Thorsrud — Wed, 06 Nov 2019 13:17:01 GMT

Hi,

You can use this method. How you obtain data via WTI is independent from how you use it later (such as transferring over BLE).

RE: Sending actual TWI sensor values through BLE

KCY — Tue, 05 Nov 2019 15:41:51 GMT

Thank you for sending this link. I will go through it to debug. Meanwhile, I have a quick question.

In the twi sensor example, the twi transaction "read_sensor_data()" is called in the main function, instead of in the data_handler, and I believe that the interrupt is controlled by the state of m_xfer_done. Is that an approach I can try too? Or does it not work in my case because I have to send the data through BLE?

Thanks!

RE: Sending actual TWI sensor values through BLE

Einar Thorsrud — Tue, 05 Nov 2019 07:54:58 GMT

Hi,

It could be a timing issue or could be something else. The key is that you need to debug to understand what the connection is dropped. Without proper debugging you will just have to guess, and that is not a good way of approaching this. We have already seen from the screenshot of your call stack in a previous post that the nRF is in an error handler. So you need to debug to see what error occurred. Have you done that? You may find An introduction to error handling in nRF5 projects interesting, though it is not fully up to date.

RE: Sending actual TWI sensor values through BLE

KCY — Mon, 04 Nov 2019 14:34:14 GMT

Hi,

Does the debugging mode shows error during the BLE transaction? I don't seem to be getting any error in the debugging mode. When I give dummy heart rate values in the code, the BLE transactions works fine, but once I make it read from the sensor, the BLE connection crashes. Could that be an issue with the timing? But shouldn't the timing issue be handled automatically, since it is in non-blocking mode?

RE: Sending actual TWI sensor values through BLE

Einar Thorsrud — Fri, 01 Nov 2019 14:03:36 GMT

Hi,

If you are using Segger Embedded Studio, you simply select the debug build configuration (usually by a drop-down in the upper left corner of the screen). If you are using another toolchain, just make sure you have a global define "DEBUG" and build without optimization.

Then enable debug logging in sdk_config.h if it is not already enabled (UART logging is enabled by default in most examples). If you are using an example without logging, you could just use the debugger to inspect the info struct in the error handler to see the same information, but it is a bit more hassle.

Unfortunately, there is no unified list of error codes in the SDK, but there is a hierarchy with error bases etc. If you use logging the error code will most of the time be spelled out with the name of the define, so you won't have to piece it together.

RE: Sending actual TWI sensor values through BLE

KCY — Fri, 01 Nov 2019 12:59:26 GMT

Does that mean to click on the “build and debug”? Also, Is there a link to the list of error codes? I don’t seem to be able to find it. Thanks.

RE: Sending actual TWI sensor values through BLE

Einar Thorsrud — Fri, 01 Nov 2019 07:36:29 GMT

Hi,

Looking at the call stack, you can see that it is in an error handler. So the first thing you should do is build with DEBUG enabled, and then either just enable logging or inspect the info struct in the error handler. This will tell you in which file and at which line you get which error code. As mentioned in my previous post, this is the by far best starting point when you see errors like this.

RE: Sending actual TWI sensor values through BLE

KCY — Thu, 31 Oct 2019 15:22:02 GMT

Hi, Sorry for the delay. To clear things up. I decided to restart the project again and now I am back here at this position.

I configured the TWI driver to be non-blocking and use DMA - passed an event handler when initializing the driver.

void twi_handler(nrf_drv_twi_evt_t const * p_event, void * p_context)
{
    ret_code_t err_code;
    uint16_t heart_rate;
    static sample_t m_sample;
    switch (p_event->type)
    {
        case NRF_DRV_TWI_EVT_DONE:
            if (p_event->xfer_desc.type == NRF_DRV_TWI_XFER_RX)
            {
                
                // call ble_hrs_heart_rate_measurement_send in twi_handler
                err_code = ble_hrs_heart_rate_measurement_send(&m_hrs, heart_rate);
                if ((err_code != NRF_SUCCESS) &&
                    (err_code != NRF_ERROR_INVALID_STATE) &&
                    (err_code != NRF_ERROR_RESOURCES) &&
                    (err_code != NRF_ERROR_BUSY) &&
                    (err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
                   )
                {
                    APP_ERROR_HANDLER(err_code);
                }
            }
            m_xfer_done = true;
            break;
        default:
            break;
    }
}


void twi_init (void)
{
    ret_code_t err_code;
    
    const nrf_drv_twi_config_t twi_nrf52_config = {
       .scl                = ARDUINO_SCL_PIN,
       .sda                = ARDUINO_SDA_PIN,
       .frequency          = NRF_DRV_TWI_FREQ_100K,
       .interrupt_priority = APP_IRQ_PRIORITY_HIGH,
       .clear_bus_init     = false
    };
    
    // Non-blocking, passing twi_handler when initializing driver
    err_code = nrf_drv_twi_init(&m_twi_nrf52, &twi_nrf52_config, twi_handler, NULL);
    APP_ERROR_CHECK(err_code);

    nrf_drv_twi_enable(&m_twi_nrf52);
}

Initiate the TWI transaction in heart_rate_meas_timeout_handler()
Call ble_hrs_heart_rate_measurement_send() from the TWI event handler to send the new heard rate measurement data. (shown above)

static void heart_rate_meas_timeout_handler(TimerHandle_t xTimer)
{
    static uint32_t cnt = 0;
    ret_code_t      err_code;
    uint8_t        heart_rate;

    UNUSED_PARAMETER(xTimer);

    // Initiate TWI transaction here
    heart_rate = readHRS();
    
    cnt++;

}


void readHRS(uint8_t * read_long_data){
    ret_code_t err_code;
    
    err_code = nrf_drv_twi_tx(&m_twi_nrf52, HRS_ADDR, (uint8_t *) HRS_FIFO_DATA, sizeof(HRS_FIFO_DATA), true);

    if (NRF_SUCCESS == err_code){
	    err_code = nrf_drv_twi_rx(&m_twi_nrf52, HRS_ADDR, (uint8_t *) read_long_data, 6);
    }
    APP_ERROR_CHECK(err_code);

}

The BLE can be connected, but automatically disconnects after one second.

I get these error codes when I run debug.

Please advise on what I have done wrong here.

Thank you.

RE: Sending actual TWI sensor values through BLE

Einar Thorsrud — Fri, 30 Aug 2019 09:07:50 GMT

Hi,

If you do as awneil suggests, you will see that 8 is NRF_ERROR_INVALID_STATE. And that will be returned from nrf_drv_twi_init() if it is already initialized. Looking at your code that will be the case, since you initialize it every time heart_rate_meas_timeout_handler() is run, without uninitializing it in between. This is not legal. Either just initialize it once, or uninitialized it once you are done, and initialize it again before the next time. Also, you do not actually do a transaction in this code snippet, (only initialize the driver), so you will not get any sensor data with this code.

This is a good example of why this kind of debugging is very useful. By looking at the error code and API documentation (sometimes together with a small peak into the function returned the error) you can most of the time pinpoint the problem or at least narrow it down significantly.

RE: Sending actual TWI sensor values through BLE

awneil — Thu, 29 Aug 2019 16:05:26 GMT

[quote userid="71618" url="~/f/nordic-q-a/51476/sending-actual-twi-sensor-values-through-ble/206924"]It seems like it is an error code 8 in this line[/quote]

Indeed.

So look up what error code 8 actually means.

The documentation for nrf_drv_twi_init will list the possible error codes it can return ...

RE: Sending actual TWI sensor values through BLE

KCY — Thu, 29 Aug 2019 14:33:56 GMT

Hi Einar,

Thank you for your response. I called the twi_init() function in heart_rate_meas_timeout_handler(). And then in twi_init(), the TWI event handler is used to ensure non-blocking mode. Then the readHRS() and ble_hrs_heart_rate_measurement_send() functions are called from the TWI event handler as shown in the code below. With these fixes, I am able to connect the device to the app through BLE, but it disconnects automatically after a second.

Did I misunderstand anything from your suggestion?

void twi_handler(nrf_drv_twi_evt_t const * p_event, void * p_context)
{
    ret_code_t err_code;
    uint16_t heart_rate;
    static sample_t m_sample;
    switch (p_event->type)
    {
        case NRF_DRV_TWI_EVT_DONE:
            if (p_event->xfer_desc.type == NRF_DRV_TWI_XFER_RX)
            {
                heart_rate = readHRS();
                
                err_code = ble_hrs_heart_rate_measurement_send(&m_hrs, heart_rate);
                if ((err_code != NRF_SUCCESS) &&
                    (err_code != NRF_ERROR_INVALID_STATE) &&
                    (err_code != NRF_ERROR_RESOURCES) &&
                    (err_code != NRF_ERROR_BUSY) &&
                    (err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
                   )
                {
                    APP_ERROR_HANDLER(err_code);
                }
            }
            m_xfer_done = true;
            break;
        default:
            break;
    }
}


void twi_init (void)
{
    ret_code_t err_code;
    
    const nrf_drv_twi_config_t twi_nrf52_config = {
       .scl                = ARDUINO_SCL_PIN,
       .sda                = ARDUINO_SDA_PIN,
       .frequency          = NRF_DRV_TWI_FREQ_100K,
       .interrupt_priority = APP_IRQ_PRIORITY_HIGH,
       .clear_bus_init     = false
    };
    
    err_code = nrf_drv_twi_init(&m_twi_nrf52, &twi_nrf52_config, twi_handler, NULL);
    APP_ERROR_CHECK(err_code);

    nrf_drv_twi_enable(&m_twi_nrf52);
}


void heart_rate_meas_timeout_handler(TimerHandle_t xTimer)
{
    static uint32_t cnt = 0;
    ret_code_t      err_code;
    uint16_t        heart_rate;

    UNUSED_PARAMETER(xTimer);
    
    twi_init();
      
    cnt++;
}

With the debugging tool, I received these errors.

It seems like it is an error code 8 in this line in the twi_init() function.

err_code = nrf_drv_twi_init(&m_twi_nrf52, &twi_nrf52_config, twi_handler, NULL);

What might be causing this issue?

Thank you!

RE: Sending actual TWI sensor values through BLE

Einar Thorsrud — Thu, 29 Aug 2019 12:06:17 GMT

Hi,

[quote user="chkan"]Yes, so I tried commenting out lines of code that are used in the readHRS() function and I was only able to connect to the device through BLE when I commented out nrf_drv_twi_tx() and nrf_drv_twi_rx().So I thought that was the issue.[/quote]

I see. What I meant by "debugging" in this context was more like using a debugging tool to see what is actually going on. What prevents BLE from working when you use TWI to communicate with the sensor? Is an error returned somewhere? Something along these lines. That said, the combination of your code and that TWI transactions seem to cause the problem gives us a good clue, as described in the previous post.

[quote user="chkan"]Can you elaborate more on how I can do this? Right now I am calling the ble_hrs_heart_rate_measurement_send() in the heart_rate_meas_timeout_handler() and using the heart_rate_meas_timeout_handler() in timer_init()[/quote]

Yes. I will repeat the suggestion in my previous post in more detail:

The idea is that you should use asynchronous (non-blocking) TWI transactions. To do so:
Make sure you configure the TWI driver to be non-blocking and use DMA. That means that you have to pass an event handler when you initialize the driver.
Initiate the TWI transaction in heart_rate_meas_timeout_handler(). Since this is now a non-blocking call, it will not cause problems for BLE or anything else.
The TWI transaction is now handled by HW, so the CPU can do whatever it needs, including BLE stuff.
When the TWI transaction is finished, your TWI event handler will be called.
Call ble_hrs_heart_rate_measurement_send() from the TWI event handler to send the new heard rate measurement data.

The important difference here compared to your implementation is that instead of spending a lot of time just busy waiting in heart_rate_meas_timeout_handler(), the CPU will be idle, available for handling other events. I do not know if this is a solution since you have not tracked down why your calls to nrf_drv_twi_tx() and nrf_drv_twi_rx(), but it seems very likely.

RE: Sending actual TWI sensor values through BLE

KCY — Wed, 28 Aug 2019 15:40:46 GMT

What do you mean by "when I do this, I am not able to the device anymore."?

Sorry, I meant that I wasn't able to connect to the device anymore when tried to modify the heart_rate_meas_timeout_handler function of the code to take value from the sensor instead of sensorsim_measure().

Have you done any debugging to find out what actually happens?

Yes, so I tried commenting out lines of code that are used in the readHRS() function and I was only able to connect to the device through BLE when I commented out nrf_drv_twi_tx() and nrf_drv_twi_rx().So I thought that was the issue.

Then you can call ble_hrs_heart_rate_measurement_send() from the TWI event handler.

Can you elaborate more on how I can do this? Right now I am calling the ble_hrs_heart_rate_measurement_send() in the heart_rate_meas_timeout_handler() and using the heart_rate_meas_timeout_handler() in timer_init()

static void timers_init(void)
{
    // Initialize timer module.
    ret_code_t err_code = app_timer_init();
    APP_ERROR_CHECK(err_code);

    // Create timers.
    m_battery_timer = xTimerCreate("BATT",
                                   BATTERY_LEVEL_MEAS_INTERVAL,
                                   pdTRUE,
                                   NULL,
                                   battery_level_meas_timeout_handler);
    m_heart_rate_timer = xTimerCreate("HRT",
                                      HEART_RATE_MEAS_INTERVAL,
                                      pdTRUE,
                                      NULL,
                                      heart_rate_meas_timeout_handler);
    m_rr_interval_timer = xTimerCreate("RRT",
                                       RR_INTERVAL_INTERVAL,
                                       pdTRUE,
                                       NULL,
                                       rr_interval_timeout_handler);
    m_sensor_contact_timer = xTimerCreate("SCT",
                                          SENSOR_CONTACT_DETECTED_INTERVAL,
                                          pdTRUE,
                                          NULL,
                                          sensor_contact_detected_timeout_handler);

    /* Error checking */
    if ( (NULL == m_battery_timer)
         || (NULL == m_heart_rate_timer)
         || (NULL == m_rr_interval_timer)
         || (NULL == m_sensor_contact_timer) )
    {
        APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
    }
}


static void heart_rate_meas_timeout_handler(TimerHandle_t xTimer)
{
    static uint32_t cnt = 0;
    ret_code_t      err_code;
    uint8_t        heart_rate;

    UNUSED_PARAMETER(xTimer);

    //heart_rate = (uint16_t)sensorsim_measure(&m_heart_rate_sim_state, &m_heart_rate_sim_cfg);
    heart_rate = readHRS();
    
    cnt++;
    err_code = ble_hrs_heart_rate_measurement_send(&m_hrs, heart_rate);
    if ((err_code != NRF_SUCCESS) &&
        (err_code != NRF_ERROR_INVALID_STATE) &&
        (err_code != NRF_ERROR_RESOURCES) &&
        (err_code != NRF_ERROR_BUSY) &&
        (err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
       )
    {
        APP_ERROR_HANDLER(err_code);
    }

    // Disable RR Interval recording every third heart rate measurement.
    // NOTE: An application will normally not do this. It is done here just for testing generation
    // of messages without RR Interval measurements.
    //m_rr_interval_enabled = ((cnt % 3) != 0);
}


void readHRS(uint8_t * read_long_data){
    ret_code_t err_code;
    
    err_code = nrf_drv_twi_tx(&m_twi_nrf52, HRS_ADDR, (uint8_t *) HRS_FIFO_DATA, sizeof(HRS_FIFO_DATA), true);

    if (NRF_SUCCESS == err_code){
	    err_code = nrf_drv_twi_rx(&m_twi_nrf52, HRS_ADDR, (uint8_t *) read_long_data, 6);
    }
    APP_ERROR_CHECK(err_code);

}

RE: Sending actual TWI sensor values through BLE

Einar Thorsrud — Wed, 28 Aug 2019 14:05:34 GMT

Hi,

The heart_rate_meas_timeout_handler() is just an app_timer timeout handler function, so it should not be any problems starting a TWI transaction here.

What do you mean by "when I do this, I am not able to the device anymore."? Have you done any debugging to find out what actually happens?

Without knowing more, the one thing that stands out is your call to nrf_delay_ms(). Note that this is in an RTC interrupt routine (app_timer), so any same or lower interrupt priorities will be blocked. You should not use nrf_delay_ms or other forms of bussy waiting. Instead, it would make sense to start the TWI transfer and then wait for an event when the TWI transfer has completed. Then you can call ble_hrs_heart_rate_measurement_send() from the TWI event handler.