RE: How to read two analog inputs using SAADC?

paul_tanner — Mon, 19 Aug 2019 06:39:47 GMT

I'm using sdk 12.3 on nrf52832. I have a single channel working fine and am extending it to two channels.

The initialisation looks simple enough. However, instead of one array of samples p_event->data.done.p_buffer[i] the callback would need to return 2 arrays. How would those values be accessed?

RE: How to read two analog inputs using SAADC?

Noah — Wed, 22 May 2019 20:34:02 GMT

Figured it out earlier this morning! After the first reading, I unitialize SAADC and then instantly reinitialize it with my second analog pin as input, put both readings into a packet, transmit, then restart the whole process!

RE: How to read two analog inputs using SAADC?

Jørgen Holmefjord — Wed, 22 May 2019 08:32:15 GMT

Hi,

The SAADC peripheral will by default store samples directly in a buffer in RAM. I would recommend that you use scan mode (enabled automatically when more than one channel is enabled) with a buffer size of 2, and trigger a single sample to sample both channels. This will sample the channels successively with minimal delay, and you will get a done event once both channels have been samples. The callback will give a pointer to the buffer where the samples are stored.

You can easily add more channels to the SAADC example in the SDK by adding these lines in saadc_init():

nrf_saadc_channel_config_t channel_config2 =
        NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN1);

err_code = nrf_drv_saadc_channel_init(1, &channel_config);
APP_ERROR_CHECK(err_code);

Best regards,
Jørgen

RE: How to read two analog inputs using SAADC?

paul — Wed, 22 May 2019 03:39:30 GMT

Hi,

there are no doubt many ways to do this. In the following I am reading battery voltage and the presence of metal with a hall effect sensor.

#define HALL_PIN NRF_SAADC_INPUT_AIN0               /// analog pin 0
#define VOLT_PIN NRF_SAADC_INPUT_AIN2               /// analog pin 2
#define VOLT_CHANNEL 0                              /// SAADC channel no
#define HALL_CHANNEL 1                              /// SAADC channel no

static nrf_saadc_channel_config_t ch_config_volts =  
              NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(VOLT_PIN);
static nrf_saadc_channel_config_t ch_config_hall =  
              NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(HALL_PIN);
static nrf_saadc_value_t adc_buf[2];        //!< Buffer used for storing ADC value.
static nrf_saadc_value_t volts_raw, hall_raw;

void saadc_init(void)
{    
    uint32_t err_code;
    nrfx_saadc_config_t saadc_config = NRFX_SAADC_DEFAULT_CONFIG;
   
    // Fine tune saadc params
    ch_config_volts.gain = NRF_SAADC_GAIN1_4;
    /// gain of a half produced range of ~0x75 compared to ~0x35 for quarter
    ch_config_hall.gain = NRF_SAADC_GAIN1_2;

    // init the adc
    err_code  = nrfx_saadc_init(&saadc_config, saadc_event_handler);
    // no point testing error.it is either success or complaining that it has been initialised

    // do a calibrate
    while (nrfx_saadc_calibrate_offset() != NRFX_SUCCESS)
        nrf_delay_ms(10);
    while (nrfx_saadc_is_busy())
        nrf_delay_ms(10);
    
    // config the adc channel to read cpu internal volts   
    err_code = nrfx_saadc_channel_init(VOLT_CHANNEL, &ch_config_volts);        
    APP_ERROR_CHECK(err_code);

    // config the adc channel to read hall sensor   
    err_code = nrf_drv_saadc_channel_init(HALL_CHANNEL, &ch_config_hall);        
    APP_ERROR_CHECK(err_code);

    err_code = nrfx_saadc_buffer_convert(adc_buf, sizeof(adc_buf)/sizeof(nrf_saadc_value_t));
    APP_ERROR_CHECK(err_code);

    nrfx_saadc_sample();
}

/** @brief Function handling events from 'nrf_drv_saadc.c'.
 *
 * @param[in] p_evt SAADC event.
 */
static void saadc_event_handler(nrf_drv_saadc_evt_t const * p_evt)
{
    if (p_evt->type == NRFX_SAADC_EVT_DONE)
    {
        // just need to copy values now because could be overwritten at any time
        volts_raw = p_evt->data.done.p_buffer[VOLT_CHANNEL];
        hall_raw = p_evt->data.done.p_buffer[HALL_CHANNEL];
    } else if (p_evt->type == NRFX_SAADC_EVT_CALIBRATEDONE) {
        // don't do anything - we call calibrate every now and then and this comes back
    } else if (p_evt->type ==  NRFX_SAADC_EVT_LIMIT) {
        // not setting any limits with nrfx_saadc_limits_set so should never fire
    }
}

/**
** @brief wrapper for saadc_get that returns the last voltage reading
** @param[out] p_vbatt returns the last voltage reading
**
*/
void saadc_get_volts(uint16_t * p_vbatt) {
    
    // convert and return the current volts
    *p_vbatt = ADC_RESULT_IN_MILLI_VOLTS(volts_raw);

    // schedule another go
    saadc_get();
}

/**
** @brief wrapper for saadc_get that returns the last hall effect reading
** @param[out] p_lvl_hall returns the last voltage reading
**
*/
void saadc_get_hall(uint16_t * p_lvl_hall) {
     
    // convert and return the hall value
    *p_lvl_hall = hall_raw;

    // schedule another go
    saadc_get();
}

/**
** @brief kick off the adc. value comes back in evt handler
** 
*/
static void saadc_get(void)
{
   ret_code_t err_code;

    // does the read which takes time 
    // value returned through the event handler
    if (!nrfx_saadc_is_busy())
    {
        err_code = nrfx_saadc_buffer_convert(adc_buf, sizeof(adc_buf)/sizeof(nrf_saadc_value_t));
        APP_ERROR_CHECK(err_code);

        nrfx_saadc_sample();
    }
}

I have no idea why I used two different calls to do the channel init - guess I was having a bad day at the time. They should probably both be the nrfx versions since they are the latest and greatest.

Cheers Paul