SAADC samples the same as ground value for LM35 sensor.

[TrebleStick]

Hi, I'm running the saddc_pca10056 peripheral example given in SDK v15.2.0. 

The analogue pin A0 is connected to the signal line of an LM35 temperature sensor. When I measure the voltage of the pin it increases from 300mV to 320mV when touched. The noise on the input of the ADC seems to be too much to detect this. I need the sensors to be very accurate as they will be detecting skin temperature during rodent testing for safety. I get a steady stream of values through and the input definitely works as it changes value when connected to the 5V line. Any ideas on what might need changing? 

[haakonsh]

You should do three things:

1. Run offset calibration on start-up, and every second degree Celsius change in temperature.
   
   
2. Ensure that you've configured the SAADC to sample in the correct operating range of your signal. I suggest you try a gain of 1, and use the internal 0.6V reference. 
   
   
3. Enable oversampling of your measurement, at least 10X.  

[TrebleStick]

Hi, thank you for the suggestions:

1. I added the offset calibration to start up, the values coming through average at about 80 for the first reading and then return to the usual values around 1900. For calibrating every second degree Celsius change in temperature: Firstly if the ADC can't detect the temperature change because of the noise how would you be able to trigger such an event? Secondly would this mean uninitialising and reinitialising the ADC? Running calibration will not work unless the ADC is idle

2. This was already implemented before, forgot to mention.

3. I tried 16x oversampling onwards along side a resolution of 14-bits (as is suggested in the documentation) and there was no difference in results apart from the expected slow down as oversampling increased. 

Thanks in advance :) 

*EDIT* - code followed by debug prints below 

/**
 * Copyright (c) 2014 - 2018, 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.
 *
 */
/** @file
 * @defgroup nrf_adc_example main.c
 * @{
 * @ingroup nrf_adc_example
 * @brief ADC Example Application main file.
 *
 * This file contains the source code for a sample application using ADC.
 *
 * @image html example_board_setup_a.jpg "Use board setup A for this example."
 */

#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 "boards.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "app_util_platform.h"
#include "nrf_pwr_mgmt.h"

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.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;


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 400ms */
    uint32_t ticks = nrf_drv_timer_ms_to_ticks(&m_timer, 400);
    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)
{
    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;
        uint32_t data_average = 0;
        NRF_LOG_INFO("ADC event number: %d", (int)m_adc_evt_counter);
        SEGGER_RTT_printf(0, "ADC event: %d -> ", (int)m_adc_evt_counter); //swap for debug print

        for (i = 0; i < SAMPLES_IN_BUFFER; i++)
        {
            NRF_LOG_INFO("%d", p_event->data.done.p_buffer[i]);
            SEGGER_RTT_printf(0,"%d:", p_event->data.done.p_buffer[i]); //swap for debug print
            data_average += p_event->data.done.p_buffer[i];
        }
        //Produce average of the buffered data
        data_average = data_average/i+1;
        SEGGER_RTT_printf(0, " AVERAGE : %u\n", data_average);
        
        m_adc_evt_counter++;
        
    }
}


void saadc_init(void)
{
    ret_code_t err_code;
    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);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_channel_init(0, &channel_config);
    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);

}


/**
 * @brief Function for main application entry.
 */
int main(void)
{
    uint32_t err_code = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(err_code);

    NRF_LOG_DEFAULT_BACKENDS_INIT();

    ret_code_t ret_code = nrf_pwr_mgmt_init();
    APP_ERROR_CHECK(ret_code);

    //calibrate on start up
    err_code = nrfx_saadc_calibrate_offset();
    SEGGER_RTT_printf(0, "Calibration Error Code %x\n", err_code);
    APP_ERROR_CHECK(err_code);

    saadc_init();
    saadc_sampling_event_init();
    saadc_sampling_event_enable();
    NRF_LOG_INFO("SAADC HAL simple example started.");
    
    while (1)
    {
        nrf_pwr_mgmt_run();
        NRF_LOG_FLUSH();
    }
}


/** @} */







//----------debug print out from above main----------------//
Calibration Error Code 0
ADC event: 0 -> -69:319:130:33:-8: AVERAGE : 82
ADC event: 1 -> 16:1849:1847:1845:1848: AVERAGE : 1482
ADC event: 2 -> 1836:1858:1851:1852:1858: AVERAGE : 1852
ADC event: 3 -> 1852:1842:1843:1840:1841: AVERAGE : 1844
ADC event: 4 -> 1853:1849:1852:1841:1843: AVERAGE : 1848
ADC event: 5 -> 1846:1852:1837:1845:1845: AVERAGE : 1846
ADC event: 6 -> 1838:1845:1842:1847:1845: AVERAGE : 1844
ADC event: 7 -> 1853:1839:1836:1848:1850: AVERAGE : 1846
ADC event: 8 -> 1846:1838:1844:1852:1857: AVERAGE : 1848
ADC event: 9 -> 1856:1850:1859:1855:1854: AVERAGE : 1855
ADC event: 10 -> 1867:1860:1858:1854:1857: AVERAGE : 1860
ADC event: 11 -> 1849:1858:1861:1845:1842: AVERAGE : 1852

[haakonsh]

I suggest you use the SAADC to measure a proper voltage source first. This will tell you if there's noise in the SAADC or if it's in the temperature sensor's signal. 

You should also check your power supply and make sure that you adhere to the reference design of the nRF52 and the temperature sensor's. 

[TrebleStick]

Measuring a proper bench voltage source varying it from 0-5V produced some strange results. Regardless of the configuration of the SAADC channel, reading only changed when input voltage exceeded 3.65V. This either maxed out the reading or put it within a range (depending on the gain and reference voltage) that is usable to detect voltage change from 3.7V+. Any ideas why this might be the case? It sounds like a hardware issue to me.

I am using the development board so power is supplied by USB and taking the 0-5V rails to power the temperature sensor, it's a very simple sensor and the measured signal from that on both volt meter and oscilloscope comes out as expected. 

[haakonsh]

What voltage is VDD at?

You've probably exceeded the maximum rated voltage for the gpio, and consequently blown an ESD fuse. 
See I/O pin voltage in Absolute maximum ratings. 

[TrebleStick]

It's 3V 

[haakonsh]

Then you've most likely blown the ESD diode on that pin since you've applied a voltage higher than VDD + 0.3V. 

I suggest you try another analog input, this time you need to make sure that you're applying a voltage that's within the specification of the device.