RE: ESB_PTX loses 1 packet of every two packets when I enable 4 channels of SAADC

Karl Ylvisaker — Tue, 09 Mar 2021 12:10:14 GMT

Hello again,

[quote user="Masoumeh"]I mean I have 20 samples of adc in 16 bits which every one has 4 bits of zero because that the resolution is 4 bit. to send data in a optimized way I put this 20 samples in a 32 bytes packet which the first and last byte are not filled with data. so I have 20 sample in 12 bits resolution which means 240 bits in 30 bytes. [/quote]

I could not understand what you mean here until I saw you code, but I see now that you are truncating the samples so you may fit more samples into the buffer, as long as the receiver is aware of this, this should be just fine - it is a good optimization to avoid sending redundant empty bytes.

[quote user="Masoumeh"]here is my code: [/quote]

This makes things clearer, thank you for sharing.
I notice that you are not actually checking the error code of the call to nrf_esb_write_payload - you only check whether it was a success or not. This is likely where you are 'loosing' you data. For example, if it returns with the error code NRF_ERROR_NO_MEM the tx fifo queue is full. This means that you data is discarded, since you move on with only incrementing the fail counter.

[quote user="Masoumeh"]if the packet is lost, I increase a buffer. so yes the data is not transferred successfully and never acknowledged by the receiver. [/quote]

If it is important that data is not discarded / lost, you will need to implement a proper error handling here, instead of just moving on if it fails. It is not the esb protocol that is loosing the data, it is the application that is discarding it, currently.

[quote user="Masoumeh"]this problem happlens when I increase the channels of the adc from 2 to 4. [/quote]

This could be due to the fact that enabling the double amount of channels will double the data to be transmitted. If the transmitting is supposed to happen at the same pace, this likely causes your buffer to fill, and thus the application starts discarding data more regularly.

[quote user="Masoumeh"]I am using keil for my work, can you say me how to check there? [/quote]

In keil, you can change this in the C/C++ tab of the 'options' when right clicking the project in the file explorer. Please see attached image. You will have to pass the returned error code to an APP_ERROR_CHECK() in order for the returned error code to be checked. The default error handling is to reset the device.

Best regards,
Karl

RE: ESB_PTX loses 1 packet of every two packets when I enable 4 channels of SAADC

Masoumeh — Sat, 06 Mar 2021 11:41:03 GMT

[quote userid="87869" url="~/f/nordic-q-a/72290/esb_ptx-loses-1-packet-of-every-two-packets-when-i-enable-4-channels-of-saadc/297602#297602"]

Could you clarify what you mean when you say that you send 20 samples in a 32 packet?

[/quote]

I mean I have 20 samples of adc in 16 bits which every one has 4 bits of zero because that the resolution is 4 bit. to send data in a optimized way I put this 20 samples in a 32 bytes packet which the first and last byte are not filled with data. so I have 20 sample in 12 bits resolution which means 240 bits in 30 bytes.

[quote userid="87869" url="~/f/nordic-q-a/72290/esb_ptx-loses-1-packet-of-every-two-packets-when-i-enable-4-channels-of-saadc/297602#297602"]Could you detail how you are initiating your sampling (are you using a timer to trigger SAMPLE_START through PPI, like in the SAADC example?)?[/quote]

yes I am using the approach in the SAADC and use nrf_drv_timer_us_to_ticks(&m_timer, 50) which gives me 20ksps.

here is my code:

/**
 * Copyright (c) 2014 - 2020, Nordic Semiconductor ASA
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 *
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include "sdk_common.h"
#include "nrf.h"
#include "nrf_esb.h"
#include "nrf_error.h"
#include "nrf_esb_error_codes.h"
#include "nrf_delay.h"
#include "nrf_gpio.h"
#include "nrf_clock.h"
#include "boards.h"
#include "nrf_delay.h"
#include "app_util.h"

/** user's code begins 1. 
*/
#include <stdio.h>
#include "nrf_drv_saadc.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "app_error.h"
#include "app_util_platform.h"
#include "nrf_pwr_mgmt.h"
/** user's code ends 1. 
*/

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

/** user's code begins 2. 
*/

#define SAMPLES_IN_BUFFER 20
volatile uint8_t state = 1;

static const nrf_drv_timer_t m_timer = NRF_DRV_TIMER_INSTANCE(0);
static nrf_saadc_value_t     m_buffer_pool[2][SAMPLES_IN_BUFFER];
static nrf_ppi_channel_t     m_ppi_channel;
static uint32_t              m_adc_evt_counter;
static nrf_esb_payload_t     tx_payload = NRF_ESB_CREATE_PAYLOAD(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);


static nrf_esb_payload_t     rx_payload;
uint8_t flag=0;

static uint32_t              Sending_packet_passed;
static uint32_t              Sending_packet_failed;

bool buf_flag=false;

void timer_handler(nrf_timer_event_t event_type, void * p_context)
{

}

void saadc_sampling_event_init(void)
{
    ret_code_t err_code;

    err_code = nrf_drv_ppi_init();
    APP_ERROR_CHECK(err_code);

    nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;
    timer_cfg.bit_width = NRF_TIMER_BIT_WIDTH_32;
    err_code = nrf_drv_timer_init(&m_timer, &timer_cfg, timer_handler);
    APP_ERROR_CHECK(err_code);

    /* setup m_timer for compare event every 50us */
    uint32_t ticks = nrf_drv_timer_us_to_ticks(&m_timer, 50);
    nrf_drv_timer_extended_compare(&m_timer,
                                   NRF_TIMER_CC_CHANNEL0,
                                   ticks,
                                   NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK,
                                   false);
    nrf_drv_timer_enable(&m_timer);

    uint32_t timer_compare_event_addr = nrf_drv_timer_compare_event_address_get(&m_timer,
                                                                                NRF_TIMER_CC_CHANNEL0);
    uint32_t saadc_sample_task_addr   = nrf_drv_saadc_sample_task_get();

    /* setup ppi channel so that timer compare event is triggering sample task in SAADC */
    err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_ppi_channel_assign(m_ppi_channel,
                                          timer_compare_event_addr,
                                          saadc_sample_task_addr);
    APP_ERROR_CHECK(err_code);
}


void saadc_sampling_event_enable(void)
{
    ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);

    APP_ERROR_CHECK(err_code);
}


void saadc_callback(nrf_drv_saadc_evt_t const * p_event) //ok
{
    if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
    {
        ret_code_t err_code;
				err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, SAMPLES_IN_BUFFER);
			  APP_ERROR_CHECK(err_code);
				
        int i;
				int k=1;
				for (i = 0; i < SAMPLES_IN_BUFFER; i+=2)
			  {
					tx_payload.data[k] =   (uint8_t)(p_event->data.done.p_buffer[i]);
					tx_payload.data[k+1] = (uint8_t)(p_event->data.done.p_buffer[i] >> 8) | (uint8_t)(p_event->data.done.p_buffer[i+1] << 4);
					tx_payload.data[k+2] = (uint8_t)(p_event->data.done.p_buffer[i+1] >> 4);
					k+=3;
			  }
				tx_payload.data[0]=m_adc_evt_counter++;
				if (nrf_esb_write_payload(&tx_payload) == NRF_SUCCESS)
				{
					Sending_packet_passed++;
				}
				else
				{
					tx_payload.data[31]=Sending_packet_failed++;
				}
//				nrf_delay_us(50);
    }
}


void saadc_init(void) //ok
{
  ret_code_t err_code;

	nrf_saadc_channel_config_t channel_config0 =
        NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_DIFFERENTIAL(NRF_SAADC_INPUT_AIN4,NRF_SAADC_INPUT_AIN6);
	nrf_saadc_channel_config_t channel_config1 =
        NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_DIFFERENTIAL(NRF_SAADC_INPUT_AIN5,NRF_SAADC_INPUT_AIN6);
	
	nrf_saadc_channel_config_t channel_config2 =
        NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN6);
	nrf_saadc_channel_config_t channel_config3 =
        NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN7);

    err_code = nrf_drv_saadc_init(NULL, saadc_callback);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_channel_init(0, &channel_config0);
    APP_ERROR_CHECK(err_code);
		err_code = nrf_drv_saadc_channel_init(1, &channel_config1);
    APP_ERROR_CHECK(err_code);
		err_code = nrf_drv_saadc_channel_init(2, &channel_config2);
    APP_ERROR_CHECK(err_code);
		err_code = nrf_drv_saadc_channel_init(3, &channel_config3);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[0], SAMPLES_IN_BUFFER);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[1], SAMPLES_IN_BUFFER);
    APP_ERROR_CHECK(err_code);
		
//		nrf_saadc_continuous_mode_enable(800);

}

/** user's code ends 2. 
*/


void nrf_esb_event_handler(nrf_esb_evt_t const * p_event)
{
    switch (p_event->evt_id)
    {
        case NRF_ESB_EVENT_TX_SUCCESS:
            NRF_LOG_DEBUG("TX SUCCESS EVENT");
            break;
        case NRF_ESB_EVENT_TX_FAILED:
            NRF_LOG_DEBUG("TX FAILED EVENT");
            (void) nrf_esb_flush_tx();
            (void) nrf_esb_start_tx();
            break;
        case NRF_ESB_EVENT_RX_RECEIVED:
            NRF_LOG_DEBUG("RX RECEIVED EVENT");
            while (nrf_esb_read_rx_payload(&rx_payload) == NRF_SUCCESS)
            {
                if (rx_payload.length > 0)
                {
                    NRF_LOG_DEBUG("RX RECEIVED PAYLOAD");
                }
            }
            break;
    }
}


void clocks_start( void )
{
    NRF_CLOCK->EVENTS_HFCLKSTARTED = 0;
    NRF_CLOCK->TASKS_HFCLKSTART = 1;

    while (NRF_CLOCK->EVENTS_HFCLKSTARTED == 0);
}


void gpio_init( void )
{
    nrf_gpio_range_cfg_output(8, 15);
    bsp_board_init(BSP_INIT_LEDS);
}


uint32_t esb_init( void )
{
    uint32_t err_code;
    uint8_t base_addr_0[4] = {0xE7, 0xE7, 0xE7, 0xE7};
    uint8_t base_addr_1[4] = {0xC2, 0xC2, 0xC2, 0xC2};
    uint8_t addr_prefix[8] = {0xE7, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8 };

    nrf_esb_config_t nrf_esb_config         = NRF_ESB_DEFAULT_CONFIG;
    nrf_esb_config.protocol                 = NRF_ESB_PROTOCOL_ESB_DPL;
    nrf_esb_config.retransmit_delay         = 600;
    nrf_esb_config.bitrate                  = NRF_ESB_BITRATE_2MBPS_BLE;
    nrf_esb_config.event_handler            = nrf_esb_event_handler;
    nrf_esb_config.mode                     = NRF_ESB_MODE_PTX;
    nrf_esb_config.selective_auto_ack       = false;

    err_code = nrf_esb_init(&nrf_esb_config);

    VERIFY_SUCCESS(err_code);

    err_code = nrf_esb_set_base_address_0(base_addr_0);
    VERIFY_SUCCESS(err_code);

    err_code = nrf_esb_set_base_address_1(base_addr_1);
    VERIFY_SUCCESS(err_code);

    err_code = nrf_esb_set_prefixes(addr_prefix, NRF_ESB_PIPE_COUNT);
    VERIFY_SUCCESS(err_code);

    return err_code;
}


int main(void)
{
	
    ret_code_t err_code;
    gpio_init();
  	nrf_gpio_pin_clear(10);

    err_code = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(err_code);

    NRF_LOG_DEFAULT_BACKENDS_INIT();
	
  	nrf_gpio_cfg_output(27);
		nrf_gpio_pin_clear(27);
	
	
		clocks_start();
	
    err_code = esb_init();
    APP_ERROR_CHECK(err_code);
		
		/** user's code begins 3. 
		*/
		NRF_POWER->DCDCEN=1;
		
		ret_code_t ret_code = nrf_pwr_mgmt_init();
    APP_ERROR_CHECK(ret_code);
		
    saadc_init();
    saadc_sampling_event_init();
    saadc_sampling_event_enable();
		
		/** usr's code ends 3. 
		*/ 
    while (true)
    { 
				nrf_pwr_mgmt_run();
    }
		
}

[quote userid="87869" url="~/f/nordic-q-a/72290/esb_ptx-loses-1-packet-of-every-two-packets-when-i-enable-4-channels-of-saadc/297602#297602"]Could you clarify what you mean when you say that packets are lost - do you mean that they are never acknowledged by the receiver?
[/quote]

as you can see in saadc_callback() I send packets through nrf_esb_write_payload and if the packet is lost, I increase a buffer. so yes the data is not transferred successfully and never acknowledged by the receiver.

this is somehow the packets I received in matlab, as you can see the first byte of every packet is not the ++ of the last one and it is +2, which means that I did not get 1 packet. this problem happlens when I increase the channels of the adc from 2 to 4.

[quote userid="87869" url="~/f/nordic-q-a/72290/esb_ptx-loses-1-packet-of-every-two-packets-when-i-enable-4-channels-of-saadc/297602#297602"]Could you also confirm for me that you have DEBUG defined in your transmitter's preprocessor defines, like shown in the included image? [/quote]

I am using keil for my work, can you say me how to check there?

RE: ESB_PTX loses 1 packet of every two packets when I enable 4 channels of SAADC

Karl Ylvisaker — Wed, 03 Mar 2021 16:41:06 GMT

Hello,

[quote user=""]I send every 20 samples of adc in a 32 packet [/quote]

Could you clarify what you mean when you say that you send 20 samples in a 32 packet?

[quote user=""]When I configure just 2 channels everything work fine and the packets transmit without any loss. but when I configure 3 channels, 1 of every 3 packets of the esb is lost, and when I configure 4 channels, I lost 1 out of 2. I think the problem is somehow related to the priorities.[/quote]

Could you detail how you are initiating your sampling (are you using a timer to trigger SAMPLE_START through PPI, like in the SAADC example?)?
It would be great if you could show the code where you are configuring and enabling the channels.

[quote user=""]when I configure 3 channels, 1 of every 3 packets of the esb is lost, and when I configure 4 channels[/quote]

Could you clarify what you mean when you say that packets are lost - do you mean that they are never acknowledged by the receiver?

Could you also confirm for me that you have DEBUG defined in your transmitter's preprocessor defines, like shown in the included image? This will make a detailed error message print out if a non-NRF_SUCCESS error code is passed to an APP_ERROR_CHECK.

Looking forward to resolving this issue together!

Best regards,
Karl