SPI BLE receive wrong values via UART and BLE

RE: SPI BLE receive wrong values via UART and BLE

bjorn-spockeli — Fri, 10 Jan 2020 08:07:22 GMT

Hi Christoph,

If you have are using a modified ble_app_uart example then you're using notifications to send the sensor data to the phone. Notifications can be enabled or disabled by the central device(phone) writing to the CCCD of the characteristic on the slave device. When the CCCD is written to you will get enter the on_write handler in the NUS code. Here the is_notification_enabled flag set to true, see below.

static void on_write(ble_nus_t * p_nus, ble_evt_t const * p_ble_evt)
{
    ble_gatts_evt_write_t const * p_evt_write = &p_ble_evt->evt.gatts_evt.params.write;
    ble_nus_evt_t evt;
    evt.p_nus = p_nus;
    if (   (p_evt_write->handle == p_nus->tx_handles.cccd_handle)
        && (p_evt_write->len == 2))
    {
        if (ble_srv_is_notification_enabled(p_evt_write->data))
        {
            p_nus->is_notification_enabled = true;
            evt.type = BLE_NUS_EVT_COMM_STARTED;
        }
        else
        {
            p_nus->is_notification_enabled = false;
            evt.type = BLE_NUS_EVT_COMM_STOPPED;
        }
        p_nus->data_handler(&evt);
    }
    else if (   (p_evt_write->handle == p_nus->rx_handles.value_handle)
             && (p_nus->data_handler != NULL))
    {
        evt.params.rx_data.p_data = p_evt_write->data;
        evt.params.rx_data.length = p_evt_write->len;
        evt.type = BLE_NUS_EVT_RX_DATA;
        p_nus->data_handler(&evt);
    }
    else
    {
        // Do Nothing. This event is not relevant for this service.
    }
}

This flag is checked in ble_nus_string_send, which I assume that you use to send the sensor data.

uint32_t ble_nus_string_send(ble_nus_t * p_nus, uint8_t * p_string, uint16_t * p_length)
{
    ble_gatts_hvx_params_t hvx_params;

    VERIFY_PARAM_NOT_NULL(p_nus);

    if ((p_nus->conn_handle == BLE_CONN_HANDLE_INVALID) || (!p_nus->is_notification_enabled))
    {
        return NRF_ERROR_INVALID_STATE;
    }

    if (*p_length > BLE_NUS_MAX_DATA_LEN)
    {
        return NRF_ERROR_INVALID_PARAM;
    }

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

    hvx_params.handle = p_nus->tx_handles.value_handle;
    hvx_params.p_data = p_string;
    hvx_params.p_len  = p_length;
    hvx_params.type   = BLE_GATT_HVX_NOTIFICATION;

    return sd_ble_gatts_hvx(p_nus->conn_handle, &hvx_params);
}

As you can see ble_nus_string_send will return NRF_ERROR_INVALID_STATE if is_notification_enabled is false. So you could simply set is_notification_enabled to false when you receive the stop command from nRF Connect on your phone. Alternativly, you can use a timer to trigger the sensor data transmission and use the start/stop signals to start/stop this timer that will call ble_nus_string_send in its timeout handler.

Best regards

Bjørn

RE: SPI BLE receive wrong values via UART and BLE

Christoph_I — Thu, 09 Jan 2020 14:16:59 GMT

Hey bjorn-spockeli,

I want something similar to the uart example (../examples/peripheral/uart). Here we see that we close the connection when we send 'q' or 'Q' via uart. (code below)

while (true)
    {
        uint8_t cr;
        while (app_uart_get(&cr) != NRF_SUCCESS);
        while (app_uart_put(cr) != NRF_SUCCESS);

        if (cr == 'q' || cr == 'Q')
        {
            printf(" \r\nExit!\r\n");

            while (true)
            {
                // Do nothing.
            }
        }
    }

I want nearly the same for my modified ble_app_uart. But I don't want to send the quit command 'q' or 'Q' via UART, but via ble. When I press on my phone (nRF Connect) 's' (for start), the nRF sends the sensor data to my phone via ble. When I press 'q' the nRF should stop sending sensor data. And when I press 's' again the nRF send datas again. (pseudocode and photos below)

//initializing
....

uint8_t read_data[2];
uint16_t length = sizeof(read_data);
uint8_t start_stop_command;

start_stop_command = register_which_get_data_via_ble;   //which register I have to read? Or which variable?


while(1):
    switch(start_stop_command)
    {
        case('s' or 'S'):
            //read WHO_AM_I register from lis3dh (example)
            nrf_drv_spi_transfer(&spi, LIS3DH_WHO_AM_I_REG, sizeof(LIS3DH_WHO_AM_I_REG), read_data, sizeof(read_data));     
            while(!spi_xfer_done);
            
            //send WHO_AM_I value (data) via ble to my phone
            ble_nus_string_send(&m_nus, DecArrAxis, &length);
            
            //if pressed 'q' or 'Q': break
            if(register_which_get_data_via_ble == 'q' or register_which_get_data_via_ble == 'Q')
            {
                break;
            }
        
        case('q' or 'Q'):
            //do nothing
            if(register_which_get_data_via_ble == 's' or register_which_get_data_via_ble == 'S')
            {
                break;
            }
    }
}

start command: (app: nRF Connect on my phone)

RX Characteristics --> Value: s

stop command:(app: nRF Connect on my phone)

RX Characteristics --> Value: q

I hope I could explain clearly and precisely.

RE: SPI BLE receive wrong values via UART and BLE

bjorn-spockeli — Thu, 09 Jan 2020 12:58:43 GMT

Could you elaborate on this? Is it the phone that should not send any thing to the nRF before the nRF has sent the sensor data?

RE: SPI BLE receive wrong values via UART and BLE

Christoph_I — Wed, 08 Jan 2020 13:30:54 GMT

And I have another question: Is there a possibility to query the bluetooth RX buffer? Because I want to implement a send command for sending the sensor datas via ble to my phone. Before the send command it should be not allowed to send anything.

RE: SPI BLE receive wrong values via UART and BLE

Christoph_I — Wed, 08 Jan 2020 12:35:26 GMT

Thanks for your great input cbd, you know a lot! But I prefer not to change something in Nordic code so I programmed a function to convert decimal into ASCII. The code is below:

void AxisDec_to_ASCII(uint8_t dec)    
{
    static uint8_t DecArray[3];		
    uint8_t hundred = dec / 100;
    dec -= hundred*100;
    uint8_t ten = dec / 10;	
    dec -= ten * 10;
    uint8_t one = dec;	
	
    DecArray[0] = (hundred+48);	
    DecArray[1] = (ten+48);		
    DecArray[2] = (one+48);		

    uint16_t length = sizeof(DecArray);
    ble_nus_string_send(&m_nus, DecArray, &length);
}

And it works. It convert the datas from dec to hex. What do you think about my function? Any suggestions?

RE: SPI BLE receive wrong values via UART and BLE

cbd — Wed, 08 Jan 2020 10:46:14 GMT

You can send non-text (or ASCII) if you wish, as ultimately all data is binary anyway.

Points to bear in mind:

0x00 (or null) is a valid value and as it acts as a string terminator you will need to replace any string handling operators with array handling ones e.g. strlen to determine size of data to send will no longer work.

The Nordic NUS code should support it as :

err_code = ble_nus_data_send(&m_nus, data_array, &length, m_conn_handle);

treats the data as binary anyway.

The NUS code may require certain terminators such as '\n' or '\r' to determine end of text - so you'll need to check that.

nRF Connect will be expecting to handle the Nordic UART Service data as text. It probably wont handle the data correctly for display, particularly non-printable characters.

You could use the Nordic code as is, but change the service UUID (change the nus_base_uuid ) in this section

// Add a custom base UUID.
    err_code = sd_ble_uuid_vs_add(&nus_base_uuid, &p_nus->uuid_type);
    VERIFY_SUCCESS(err_code);

    ble_uuid.type = p_nus->uuid_type;
    ble_uuid.uuid = BLE_UUID_NUS_SERVICE;

    // Add the service.
    err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
                                        &ble_uuid,
                                        &p_nus->service_handle);

RE: SPI BLE receive wrong values via UART and BLE

Christoph_I — Wed, 08 Jan 2020 09:56:37 GMT

Hey cbd,

[quote userid="72220" url="~/f/nordic-q-a/56291/spi-ble-receive-wrong-values-via-uart-and-ble/227931"][/quote]

>>> I've not looked at your code yet, but points that spring to mind: 0x33 (hex) = 51 decimal = ASCII character '3'.

If your characteristic is defined as having a string type then nRF Connect will automatically convert it - displaying 3 for 0x33. <<<

You are right, thank you. I forgot such things like ASCII and exact displaying. Also the second printf format wasn't the right, thanks for your attention!

[quote userid="72220" url="~/f/nordic-q-a/56291/spi-ble-receive-wrong-values-via-uart-and-ble/227931"]occur before you try to read the spi first time?[/quote]

In my modified periphal example spim I have the first printf(...WHO_AM_I...) before lis_init() and this worked... Now I tried out the 1st printf(...WHO_AM_I...) after lis_init() because of your suggestion and now I get 0x33. I don't know where is difference between spim and ble_app_uart but thank you cbd!

I have a further question: to send datas via bluetooth to my phone/pc I need the function ble_nus_string_send() and this function send the data as string. Do you know if there are possibilities to send the datas as hex or decimal values? Or is there only the possibility for me to convert the values manually (by an own function, e.g. convert 0x33 in string/ASCII "33" and give "33" to ble_nus_string_send() )?

RE: SPI BLE receive wrong values via UART and BLE

cbd — Tue, 07 Jan 2020 14:31:55 GMT

I've not looked at your code yet, but points that spring to mind: 0x33 (hex) = 51 decimal = ASCII character '3'.

If your characteristic is defined as having a string type then nRF Connect will automatically convert it - displaying 3 for 0x33.

…

Looking at your code in main() your first printf statement formats the value as hex:

printf("WHOAMI: %x\r\n", read_data[1]);

whereas your second printf formats the value as decimal:

printf("WHOAMI: %d\r\n", read_data[1]);

...

I can't see why your first character out is 0x24 ('$'), perhaps you can tell dynamically e.g. in debug.

...

Ah shouldn't this line

 lis_init();

occur before you try to read the spi first time?