NRF52 saadc: Not getting Interrupt handlerin in saadc example

[Pawan Kumar]

Hi I am using NRF52 board to interface analog sensor and this board further transmit the data ro sink node. I am using saadc example but unable to get callback or my interrupt handler is not working.Kindly suggest

#include "api.h"
#include "node_configuration.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "nrf_drv_saadc.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "hardware_config.h"
#include "nrf_delay.h"

#include "power.h"
#include "app_scheduler.h"

#define SAMPLES_IN_BUFFER 5
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;
 uint16_t data_adc;
uint8_t count=0;


void timer_handler(nrf_timer_event_t event_type, void * p_context)
{
     count++;
    
     _send_data((uint8_t*)&count, 1, APP_ADDR_ANYSINK, 28, 28);


}


void saadc_sampling_event_init(void)
{
    uint32_t err_code;

 
    nrf_drv_ppi_init();
   

    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);
    _send_data((uint8_t*)&err_code, 4, APP_ADDR_ANYSINK, 10, 13);

    
    // setup m_timer for compare event every 400ms
    uint32_t ticks = nrf_drv_timer_ms_to_ticks(&m_timer, 400);
    
    _send_data((uint8_t*)&ticks, 4, APP_ADDR_ANYSINK, 10, 14);
    
    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);
   _send_data((uint8_t*)&err_code, 4, APP_ADDR_ANYSINK, 10, 15);

    err_code =     nrf_drv_ppi_channel_assign(m_ppi_channel,
                                          timer_compare_event_addr,
                                          saadc_sample_task_addr);
   _send_data((uint8_t*)&err_code, 4, APP_ADDR_ANYSINK, 10, 16);
   
}


void saadc_sampling_event_enable(void)
{
    uint32_t err_code;
    err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
    _send_data((uint8_t*)&err_code, 4, APP_ADDR_ANYSINK, 11, 11);


}


void saadc_callback(nrf_drv_saadc_evt_t const * p_event)
{
    if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
    {
           
        uint32_t err_code;

        err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, SAMPLES_IN_BUFFER);
       _send_data((uint8_t*)&err_code, 4, APP_ADDR_ANYSINK, 13, 11);

        int i;
    

        for (i = 0; i < SAMPLES_IN_BUFFER; i++)
        {
          //  NRF_LOG_INFO("%d", p_event->data.done.p_buffer[i]);
              data_adc=p_event->data.done.p_buffer[i];
          _send_data((uint8_t*)&data_adc, 2, APP_ADDR_ANYSINK, 13, 10);
           
        }
        m_adc_evt_counter++;
    }
}


void saadc_init(void)
{
    uint32_t err_code;
    
    nrfx_saadc_uninit();
    
    nrf_saadc_channel_config_t channel_config =
        NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN0);

    err_code =  nrf_drv_saadc_init(NULL, saadc_callback);
     _send_data((uint8_t*)&err_code, 4, APP_ADDR_ANYSINK, 14, 13);



    err_code = nrf_drv_saadc_channel_init(0, &channel_config);
    _send_data((uint8_t*)&err_code, 4, APP_ADDR_ANYSINK, 14, 14);
 


    err_code=nrf_drv_saadc_buffer_convert(m_buffer_pool[0], SAMPLES_IN_BUFFER);
    _send_data((uint8_t*)&err_code, 4, APP_ADDR_ANYSINK, 14, 15);
  

    err_code =     nrf_drv_saadc_buffer_convert(m_buffer_pool[1], SAMPLES_IN_BUFFER);
    _send_data((uint8_t*)&err_code, 4, APP_ADDR_ANYSINK, 14, 16);


}


void App_init(const app_global_functions_t * functions)
{
    Power_enableDCDC();
    // Open public API
    API_Open(functions);

 
    if (configureNode(getUniqueAddress(),
                      NETWORK_ADDRESS,
                      NETWORK_CHANNEL) != APP_RES_OK)
    {

        return;
    }
 
     
      saadc_init();
     saadc_sampling_event_init();
     saadc_sampling_event_enable();


    lib_state->startStack();
}

[Jørgen Holmefjord]

Hi,

I'm not sure what the _send_data() function does, but do you check that all function calls return NRF_SUCCESS?

You are not using the softdevice in your application? The softdevice uses TIMER0 and blocks access to this instance from the application.

Best regards,
Jørgen

[Pawan Kumar]

hi jorgen,

_send_data() function send data to sink node.Yes I have check all function returns NRF_SUCCESS. Please tell me how softdevice will help me and how to use it.

[Jørgen Holmefjord]

The softdevice will not help you with your issue, it is the BLE stack and is used for BLE stuff. I was asking, since it occupies TIMER0, and you are using TIMER0 to do the SAADC sampling in your application.

Is there some kind of loop in your program that prevents the CPU from executing random instructions after you initialize the SAADC? What happens in lib_state->startStack()? Where is App_init() called from?

[Pawan Kumar]

The app_init() function uses application libirary and this lib_state->startStack() starts stack protocol and I am sure both these things don't use timer.

[Jørgen Holmefjord]

Ok, but does lib_state->startStack() return, or is there some loop inside it that prevents the application from terminating?