nrf52805: ADC polling mode issue

RE: nrf52805: ADC polling mode issue

Gokulnath — Wed, 18 Sep 2024 13:31:45 GMT

Hello,
yes we did it indeed. the first value even before processing itself is moving a lot. either way we abandoned proceeding with this process.

feel free to make this ticket unresolved.

Thanks for your supports.

RE: nrf52805: ADC polling mode issue

helsing — Tue, 03 Sep 2024 08:12:04 GMT

Hi Gokulnath, sorry for not replying in a long time.

Going forward, it might be an idea to take a step back and look at the raw samples from SAADC. Could you try to take away all calculations in the code, in order to see what the raw samples from SAADC look like. Could you try a bench supply directly to the input, without a voltage divider in between? If the values look OK you can start adding one step at the time and see where the problem occurs.

RE: nrf52805: ADC polling mode issue

hmolesworth — Wed, 05 Jun 2024 11:38:42 GMT

I corrected the hex float print and changed the % calculation to use mV and correct min & max for my test setup with 2032 coin cell

float volttopercent(float vadc)
{
  float Vmax = 3400; // mV was 4.2;
  float Vmin = 2700; // mV was3.63;
  float percentage;
  percentage = ((vadc -Vmin)/(Vmax - Vmin))*100;
  return percentage;
}

Results look more sensible:

-Raw SAADC-   ------Scaled------   ------Percent1----   -----Percent2------
 Dec   Hex    Decimal   Hex        Decimal   Hex        Decimal      Hex
==== ======   ======= ==========   ======= ==========   =======  ==========
2979 0x0BA3   2979.00 0x453A3000     39.86 0x421F6DB7     39.86  0x421F6DB7

RE: nrf52805: ADC polling mode issue

hmolesworth — Tue, 04 Jun 2024 16:32:25 GMT

Using the code posted with the floating-point percentage calculation: This data comes from your code using a 2.996 volt input (slightly different resistors, but that is not the point here):

-Raw SAADC-   --------Scaled-------   --------Percent1-----    -------Percent2-----
 Dec   Hex     Decimal     Hex         Decimal      Hex         Decimal      Hex
==== ======   ========== ==========   ========== ==========    ========== ==========
2979 0x0BA3    2979.00   0x453A3000      39.86  0x421F6DB7       39.86 0x421F6DB7
2972 0x0B9C    2972.00   0x4539C000      38.86  0x421B6DB7       38.86 0x421B6DB7
2965 0x0B95    2965.00   0x45395000      37.86  0x42176DB7       37.86 0x42176DB7
2964 0x0B94    2964.00   0x45394000      37.71  0x4216DB6D       37.71 0x4216DB6D
2966 0x0B96    2966.00   0x45396000      38.00  0x42180000       38.00 0x42180000
2966 0x0B96    2966.00   0x45396000      38.00  0x42180000       38.00 0x42180000
with Burst 4 enabled
2981 0x0BA5    2981.00   0x453A5000      40.14  0x42209249       40.14 0x42209249
2970 0x0B9A    2970.00   0x4539A000      38.57  0x421A4925       38.57 0x421A4925
2972 0x0B9C    2972.00   0x4539C000      38.86  0x421B6DB7       38.86 0x421B6DB7
2965 0x0B95    2965.00   0x45395000      37.86  0x42176DB7       37.86 0x42176DB7
2966 0x0B96    2966.00   0x45396000      38.00  0x42180000       38.00 0x42180000
2966 0x0B96    2966.00   0x45396000      38.00  0x42180000       38.00 0x42180000

ints truncate floats; also as an aside floats (on the nRF52 hardware) are only 32-bit inclusive of sign and exponent, so have less precision than 32-bit ints. Compiler implicit conversion is compiler-dependent.

The data above is generated by adding these lines to the code :

// Input range = (0.6 V)/(1)   = 0.6V -> 3.393 V with 931k/200K dividers
// 3.0 volts -> 14486 ADC counts with 14-bit sampling: 4828.8 counts per volt
#define ADC12_COUNTS_PER_VOLT 4829

    // Disable command & turn off the Power to ADC Bridge to reduce power consumption
    nrf_gpio_pin_write(ADC_SWITCH, 0); //Turning off the voltage divider transistor
    nrf_saadc_disable();
    nrf_saadc_task_trigger(NRF_SAADC_TASK_STOP);
    nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
    nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
    float f_result = (float)((buffer[0] * 1000L) * 1.667 * 16384);
    f_result = result; ///0.140625;
    int32_t i_result = result; ///0.140625;
    float percent_result1 = volttopercent(i_result);
    float percent_result2 = volttopercent(f_result);
    char InfoPacket[180] = "";
    // -Raw SAADC-   -------Scaled-----   ------Percent1----   ------Percent2----
    //  Dec   Hex    Decimal   Hex        Decimal     Hex      Decimal    Hex
    // ==== ======   ======= ==========   ======= ==========   ======= ==========
    // 2968 0x0B98   2968.00 0x45398000     38.29 0x42192492     38.29 0x42192492
    snprintf(InfoPacket, sizeof(InfoPacket), "-Raw SAADC-   -------Scaled-----   ------Percent1----   ------Percent2----\r\n");  uartSend(InfoPacket, strlen(InfoPacket));
    snprintf(InfoPacket, sizeof(InfoPacket), " Dec   Hex    Decimal   Hex        Decimal     Hex      Decimal    Hex\r\n");     uartSend(InfoPacket, strlen(InfoPacket));
    snprintf(InfoPacket, sizeof(InfoPacket), "==== ======   ======= ==========   ======= ==========   ======= ==========\r\n"); uartSend(InfoPacket, strlen(InfoPacket));
    snprintf(InfoPacket, sizeof(InfoPacket), "%4d 0x%04X  %8.2f 0x%08X    %6.2f 0x%08X    %6.2f 0x%08X\r\n", result, result, f_result, *(uint32_t *)&f_result, percent_result1, *(uint32_t *)&percent_result1, percent_result2, *(uint32_t *)&percent_result2);
    uartSend(InfoPacket, strlen(InfoPacket));

My post here is to show how to check the algorithm is doing the required actions ..

Edit: I commented out the peculiar 0.140625 divider, correctd the hex float print and changed the % calc to use mV and correct min & max for my test setup

RE: nrf52805: ADC polling mode issue

Gokulnath — Tue, 04 Jun 2024 12:22:32 GMT

Hey helsing ,
Thanks for the suggestion I've also added the calibration too..

my new code below along with my New Hardware. But i have a few questions so asked them below (next thread)

// Input range of internal Vdd measurement = (0.6 V)/(1) = 0.6 V MAX in External Resistor Divider Output.
// 16384 ADC counts with 14-bit sampling:  0.1v = 2730.6 ADC Counts
// Resistor Divider 2.2M & 360K
// 4.2V  => 0.591 volts -> Assuming 100% Battery SoC
// 3.63V => 0.51 Volts -> Assuming 0% Battery SoC
//  Vadc= Vbat * ((360K)/(360K+2M2)) => Vadc = Vbat * 0.140625

void Adc12bitPolledInitialise(void)
{
    uint32_t timeout = 10;
    nrf_saadc_channel_config_t myConfig =
    {
        .resistor_p = NRF_SAADC_RESISTOR_DISABLED,
        .resistor_n = NRF_SAADC_RESISTOR_DISABLED,
        .gain       = NRF_SAADC_GAIN1,              //  1 Gain
        .reference  = NRF_SAADC_REFERENCE_INTERNAL, // 0.6V internal Ref Voltage
        .acq_time   = NRF_SAADC_ACQTIME_40US,       // See max source resistancetable
        .mode       = NRF_SAADC_MODE_SINGLE_ENDED,
        .burst      = NRF_SAADC_BURST_DISABLED,
        .pin_p      = NRF_SAADC_INPUT_AIN3,         // AIN3 for input Pin
        .pin_n      = NRF_SAADC_INPUT_DISABLED
    };

    nrf_saadc_resolution_set((nrf_saadc_resolution_t) 3);   // 2 is 12-bit , 3 for 14-bit 
    //nrf_saadc_oversample_set((nrf_saadc_oversample_t) 2);   // 2 is 4x, about 150uSecs total
    nrf_saadc_int_disable(NRF_SAADC_INT_ALL);
    nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
    nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
    nrf_saadc_enable();

    NRF_SAADC->CH[1].CONFIG =
              ((myConfig.resistor_p << SAADC_CH_CONFIG_RESP_Pos)   & SAADC_CH_CONFIG_RESP_Msk)
            | ((myConfig.resistor_n << SAADC_CH_CONFIG_RESN_Pos)   & SAADC_CH_CONFIG_RESN_Msk)
            | ((myConfig.gain       << SAADC_CH_CONFIG_GAIN_Pos)   & SAADC_CH_CONFIG_GAIN_Msk)
            | ((myConfig.reference  << SAADC_CH_CONFIG_REFSEL_Pos) & SAADC_CH_CONFIG_REFSEL_Msk)
            | ((myConfig.acq_time   << SAADC_CH_CONFIG_TACQ_Pos)   & SAADC_CH_CONFIG_TACQ_Msk)
            | ((myConfig.mode       << SAADC_CH_CONFIG_MODE_Pos)   & SAADC_CH_CONFIG_MODE_Msk)
            | ((myConfig.burst      << SAADC_CH_CONFIG_BURST_Pos)  & SAADC_CH_CONFIG_BURST_Msk);

    NRF_SAADC->CH[1].PSELN = myConfig.pin_n;
    NRF_SAADC->CH[1].PSELP = myConfig.pin_p;
}

void ble_Update_BatteryVoltage(void)
{
    nrf_saadc_enable();

    nrf_delay_ms(100); // add a delay to make the capacitor charge 

    volatile float result = 0;              // Some recognisable dummy value
    uint32_t timeout = 1000000;       // Trial and error
    volatile int32_t buffer[10];

    NRF_SAADC->RESULT.PTR = (uint32_t)buffer;
    NRF_SAADC->RESULT.MAXCNT = 1;

    nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
    nrf_saadc_task_trigger(NRF_SAADC_TASK_START);   // Start the SAADC to prepare for sampling

    // Wait until the SAADC is ready (EVENT_STARTED is set)
    while (!nrf_saadc_event_check(NRF_SAADC_EVENT_STARTED) && !nrf_saadc_event_check(NRF_SAADC_EVENT_CALIBRATEDONE)) 
    {
        // Optionally, you could add a timeout mechanism here to avoid waiting indefinitely
    }

    nrf_saadc_task_trigger(NRF_SAADC_TASK_SAMPLE);  // Trigger the SAADC to take a sample now that it is ready

    while (0 == nrf_saadc_event_check(NRF_SAADC_EVENT_END) && timeout > 0)
    {
        timeout--;
    }

    if (timeout != 0)
    {
        //result = ((buffer[0] * 1000L)+(ADC12_COUNTS_PER_VOLT/2)) / ADC12_COUNTS_PER_VOLT;
        result = (float)((buffer[0] * 1000L) * 1.667 * 16384);
        result = result/0.140625;
        result = volttopercent(result);
    }

    nrf_saadc_disable();

    nrf_saadc_task_trigger(NRF_SAADC_TASK_STOP);
    nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);  // Clear the STARTED event to enable detection next time
    nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
    
    /*
    while(result>100 && result >0)
    {
    result = result%100;
    }
    */
         
    if(Old_Bat != result && result >=1 && result !=0)
    {

    if(result<=5)
    {
    //result = 5;
    nrf_gpio_pin_write(BLUE_LED, 0); //Turning on the LOW BAttery Flash LED
    nrf_delay_ms(1000); // add a delay to make the capacitor charge 
    nrf_gpio_pin_write(BLUE_LED, 1); //Turning off the LOW BAttery Flash LED   
    }
    
    Old_Bat = result;
    ble_bas_battery_level_update(&m_bas, result, m_conn_handle);
    }
    nrf_saadc_task_trigger(NRF_SAADC_TASK_CALIBRATEOFFSET);
}

float volttopercent(float vadc)
{
  float Vmax = 4.2;
  float Vmin = 3.63;
  
  float percentage;

  percentage = ((vadc -Vmin)/(Vmax - Vmin))*100;

  return percentage;
}

I'm still testing it so dont know the results 100% yet.
Thanks

RE: nrf52805: ADC polling mode issue

Gokulnath — Tue, 04 Jun 2024 09:41:37 GMT

Hey hmolesworth
Could you precise your ADC Config? more precisely the ADC reference Voltage?

also, question on this:
from Datasheet of nrf52805:

My implemented formula: (for gain 1.5 & 0.6V REF Voltage for the above voltage divider of 220K & 36K? on a 4.2V Battery)
result = ((buffer[0] * 1000L)+(ADC12_COUNTS_PER_VOLT/2)) / ADC12_COUNTS_PER_VOLT;

is the above correct? I think my gain might be incorrect! where My Desired Battery voltage range is this: 4.2V 100% => 3.63V 0%

or should it be like this? (for gain 1 & 0.6V REF Voltage for the above voltage divider of 220K & 36K? on a 4.2V Battery )
result = ((buffer[0] * 1000L) * 1.667 * 16384);

Vadc= Vbat * ((360K)/(360K+2M2)) => Vadc = Vbat * 0.140625

// Input range of internal Vdd measurement = (0.6 V)/(1) = 0.6 V MAX in External Resistor Divider Output.
// 16384 ADC counts with 14-bit sampling:  0.1v = 2730.6 ADC Counts
// Resistor Divider 2.2M & 360K
// 4.2V  => 0.591 volts -> Assuming 100% Battery SoC
// 3.63V => 0.51 Volts -> Assuming 0% Battery SoC
// 


if (timeout != 0)
    {
        //result = ((buffer[0] * 1000L)+(ADC12_COUNTS_PER_VOLT/2)) / ADC12_COUNTS_PER_VOLT;
        result = (float)((buffer[0] * 1000L) * 1.667 * 16384);
        result = result/0.140625;
        result = volttopercent(result);
    }
    
    float volttopercent(float vadc)
{
  float Vmax = 4.2;
  float Vmin = 3.63;
  
  float percentage;

  percentage = ((vadc -Vmin)/(Vmax - Vmin))*100;

  return percentage;
}

// NOW RESULT SHOULD send VBat in terms of custom % ?

I'm using the internal chip 0.6V. I shall do the test on my side with this added info & shall post the results here.

*******************************************************************************************************************************
See the below thread too for my reply to Helsing

Thanks.
Gokulnath A R

RE: nrf52805: ADC polling mode issue

hmolesworth — Tue, 04 Jun 2024 02:23:23 GMT

By making a tiny change and masking out some of your code the raw SAADC results look ok to me without using bust mode or averaging or filtering (using 931k and 200k, so similar):

Battery 2984
Battery 2982
Battery 2966
Battery 2969
Battery 2973
Battery 2964
Battery 2965
Battery 2970
Battery 2968
Battery 2960
Battery 2960
Battery 2958
Battery 2966
Battery 2961
Battery 2960
Battery 2965
Battery 2970

I made these simple changes:

    .gain       = NRF_SAADC_GAIN1, // Gain (was 1.5)

    volatile int16_t buffer[20]; // 16-bit signed, not 32-bit signed

I commented out the maths and added a print:

    nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
    // Add a printout to test raw data
    char InfoPacket[120] = "";
    snprintf(InfoPacket, sizeof(InfoPacket), "Battery %4d\r\n", result);
    uartSend(InfoPacket, strlen(InfoPacket));
    // Remove the odd maths stuff, that's a non-SAADC issue
//  while(result>100 && result >0)
//  {
//  result = result%100;
//  }
//  if(Old_Bat != result && result >=1 && result !=0)
//  {
//  if(result<=17)
//  {
//  result = 5;
//  nrf_gpio_pin_write(BLUE_LED, 0); //Turning on the LOW BAttery Flash LED
//  nrf_delay_ms(1000); // add a delay to make the capacitor charge
//  nrf_gpio_pin_write(BLUE_LED, 1); //Turning off the LOW BAttery Flash LED
//  }
//  Old_Bat = result;
//  ble_bas_battery_level_update(&m_bas, result, m_conn_handle);
//  }
}

RE: nrf52805: ADC polling mode issue

helsing — Mon, 03 Jun 2024 12:41:06 GMT

Hi Gokulnath, sorry for the long delay.

What are the reslults from your lateste updated code?

Anyways, looking over this thread, somthing that seems to be missing is the wait for the SAADC to be ready, by checking for the NRF_SAADC_EVENT_STARTED event. By adding a check for the NRF_SAADC_EVENT_STARTED event before initiating sampling, you can ensure that the ADC has fully powered up and stabilized:

// Start the SAADC to prepare for sampling
nrf_saadc_task_trigger(NRF_SAADC_TASK_START);

// Wait until the SAADC is ready (EVENT_STARTED is set)
while (!nrf_saadc_event_check(NRF_SAADC_EVENT_STARTED)) {
    // Optionally, you could add a timeout mechanism here to avoid waiting indefinitely
}

// Clear the STARTED event to enable detection next time
nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);

// Trigger the SAADC to take a sample now that it is ready
nrf_saadc_task_trigger(NRF_SAADC_TASK_SAMPLE);

RE: nrf52805: ADC polling mode issue

Gokulnath — Fri, 12 Apr 2024 14:52:00 GMT

Hey,

Sorry for my delay in updating this thread with my hardware changes.

Just an update I've updated the custom PCB to this & This would be my current most updated hardware setting.

I haven't implemented your filter on the software yet.

With this current configuration (2 versions of Custom PCB), I have an oscillation delta of +-8% in both versions PCB from the true battery charge %.

(Just incase I've shunted the Transistor too(For Testing purposes) to see if it makes any change in output BUT the result remains the same)

In Both Versions of PCB the ADC Voltage Divider Ratio is the same.

Version 1 with ADC Switch PCB Below:

Version 2 without Transistor Switch PCB Below:

In Both Versions of the PCB I've added Ferrite Beads for EMC stability like shown below (Ofc Version 2 PCB doesn't have ADC switch input like shown below.)

My current ADC input is AIN3.

My Desired Battery voltage range is this: 4.2V 100% => 3.63V 0%

I explicitly add a software delay to make the capacitor charge too to avoid any inconsistencies in the hardware voltage level.

my latest adc code is below:

void Adc12bitPolledInitialise(void)
{
    uint32_t timeout = 10;
    nrf_saadc_channel_config_t myConfig =
    {
        .resistor_p = NRF_SAADC_RESISTOR_DISABLED,
        .resistor_n = NRF_SAADC_RESISTOR_DISABLED,
        .gain       = NRF_SAADC_GAIN1_5,            // (1/5) Gain
        .reference  = NRF_SAADC_REFERENCE_INTERNAL, // 0.6V internal Ref Voltage
        .acq_time   = NRF_SAADC_ACQTIME_40US,       // See max source resistancetable
        .mode       = NRF_SAADC_MODE_SINGLE_ENDED,
        .burst      = NRF_SAADC_BURST_DISABLED,
        .pin_p      = NRF_SAADC_INPUT_AIN3,         // AIN3 for input Pin
        .pin_n      = NRF_SAADC_INPUT_DISABLED
    };

    nrf_saadc_resolution_set((nrf_saadc_resolution_t) 3);   // 2 is 12-bit , 3 for 14-bit 
    //nrf_saadc_oversample_set((nrf_saadc_oversample_t) 2);   // 2 is 4x, about 150uSecs total
    nrf_saadc_int_disable(NRF_SAADC_INT_ALL);
    nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
    nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
    nrf_saadc_enable();

    NRF_SAADC->CH[1].CONFIG =
              ((myConfig.resistor_p << SAADC_CH_CONFIG_RESP_Pos)   & SAADC_CH_CONFIG_RESP_Msk)
            | ((myConfig.resistor_n << SAADC_CH_CONFIG_RESN_Pos)   & SAADC_CH_CONFIG_RESN_Msk)
            | ((myConfig.gain       << SAADC_CH_CONFIG_GAIN_Pos)   & SAADC_CH_CONFIG_GAIN_Msk)
            | ((myConfig.reference  << SAADC_CH_CONFIG_REFSEL_Pos) & SAADC_CH_CONFIG_REFSEL_Msk)
            | ((myConfig.acq_time   << SAADC_CH_CONFIG_TACQ_Pos)   & SAADC_CH_CONFIG_TACQ_Msk)
            | ((myConfig.mode       << SAADC_CH_CONFIG_MODE_Pos)   & SAADC_CH_CONFIG_MODE_Msk)
            | ((myConfig.burst      << SAADC_CH_CONFIG_BURST_Pos)  & SAADC_CH_CONFIG_BURST_Msk);

    NRF_SAADC->CH[1].PSELN = myConfig.pin_n;
    NRF_SAADC->CH[1].PSELP = myConfig.pin_p;
    nrf_gpio_pin_write(ADC_SWITCH, 1); //Turning on  the voltage divider with a transistor
}

void ble_Update_BatteryVoltage(void)
{
    // Enable command & Turn on the Power
    nrf_gpio_pin_write(ADC_SWITCH, 1); //Turning on  the voltage divider with a transistor
    nrf_saadc_enable();

    nrf_delay_ms(100); // add a delay to make the capacitor charge 

    uint16_t result = 0;              // Some recognisable dummy value
    uint32_t timeout = 1000000;       // Trial and error
    volatile int32_t buffer[20];

    NRF_SAADC->RESULT.PTR = (uint32_t)buffer;
    NRF_SAADC->RESULT.MAXCNT = 1;

    nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
    nrf_saadc_task_trigger(NRF_SAADC_TASK_START);
    nrf_saadc_task_trigger(NRF_SAADC_TASK_SAMPLE);

    while (0 == nrf_saadc_event_check(NRF_SAADC_EVENT_END) && timeout > 0)
    {
        timeout--;
    }

    if (timeout != 0)
    {
        result = ((buffer[0] * 1000L)+(ADC12_COUNTS_PER_VOLT/2)) / ADC12_COUNTS_PER_VOLT;
        result += 5;
    }

    // Disable command & turn off the Power to ADC Bridge to reduce power consumption
    nrf_gpio_pin_write(ADC_SWITCH, 0); //Turning off the voltage divider transistor
    nrf_saadc_disable();

    nrf_saadc_task_trigger(NRF_SAADC_TASK_STOP);
    nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
    nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
    
    while(result>100 && result >0)
    {
    result = result%100;
    }
    
    if(Old_Bat != result && result >=1 && result !=0)
    {

    if(result<=17)
    {
    result = 5;
    nrf_gpio_pin_write(BLUE_LED, 0); //Turning on the LOW BAttery Flash LED
    nrf_delay_ms(1000); // add a delay to make the capacitor charge 
    nrf_gpio_pin_write(BLUE_LED, 1); //Turning off the LOW BAttery Flash LED   
    }
    
    Old_Bat = result;
    ble_bas_battery_level_update(&m_bas, result, m_conn_handle);
    }
    
}

Since I thought there was a fundamental problem with my code/hardware configuration I didn't add the software filter yet.

if there seems to be no fundamental error on this config I shall proceed to add the software filter which you guys suggested.

In this above code, I've just added some phantom code to round off the results + some offset so that the result always comes between 0-100% on BLE.

especially here below:

while(result>100 && result >0)
    {
    result = result%100;
    }
    
    if(Old_Bat != result && result >=1 && result !=0)
    {

    if(result<=17)
    {
    result = 5;

P.S. If you need a log for this setup I can provide you with one. (the previous log in this forum thread is not from this latest setup)

Thanks in advance,
Gokulnath A R

RE: nrf52805: ADC polling mode issue

hmolesworth — Thu, 11 Apr 2024 13:41:21 GMT

There is a typo in this line, which was correct in your earlier post. Also note that this is not averaging, it is rounding; this means the averaging is presumably performed in ble_bas_battery_level_update()

// This line rounds the reading
Change
    result = ((buffer[0] * 1000L)+(ADC12_COUNTS_PER_VOLT/5)) / ADC12_COUNTS_PER_VOLT;
To
    result = ((buffer[0] * 1000L)+(ADC12_COUNTS_PER_VOLT/2)) / ADC12_COUNTS_PER_VOLT;

You can add the averaging I posted earlier, something like this:

void LowPassFilter(uint16_t *FilteredValue, result);

// Measured battery voltage - filtered value
static uint16_t MeasuredBatteryVoltage = 0;

    if (timeout != 0)
    {
        result = ((buffer[0] * 1000L)+(ADC12_COUNTS_PER_VOLT/2)) / ADC12_COUNTS_PER_VOLT;
        LowPassFilter(&MeasuredBatteryVoltage, result);
        // Use filtered value instead of raw sample
        result = MeasuredBatteryVoltage;
    }
.. snip ..
    ble_bas_battery_level_update(&m_bas, result, m_conn_handle); 

    return result;

Edit: If using the circuit first posted, the numbers in the log don't look correct:

Vadc = Vbat*300/(120+300) = (Vbat*300)/420
Vadc411 = 2936 mV
Vadc368 = 2629 mV

// Input range of internal Vdd measurement = (0.6 V)/(1/5) = 3 V
// 3.0 volts ->  16383 ADC counts with 14-bit sampling:  5461 counts per volt
// 3.0 volts ->   4095 ADC counts with 14-bit sampling:  1365 counts per volt
Vadc411 = 2936 mV = 16033 counts with 14-bit sampling
Vadc411 = 2936 mV =  4007 counts with 12-bit sampling

result = ((buffer[0] * 1000L)+(ADC12_COUNTS_PER_VOLT/2)) / ADC12_COUNTS_PER_VOLT;
result411 = ((16033 * 1000)+(5461/2))/5461 = 2936 with 14-bit sampling
result411 = (( 4007 * 1000)+(1365/2))/1365 = 2936 with 12-bit sampling
Vbat = 2936 * (120+300)/300 = 4110 mV = 4.11 V

From the log:
Voltage on BLE // 4.11V on voltage divider input from a Bench Power supply.
I      0BLEParserBase.CopyToRawData:Data:0x76  <<== 118, should be 0x678 for 14-bit, 0x555 for 12-bit

Maybe explicitly cast to uint32_t to ensure 32-bit processing:

// Ensure 32-bit processing:
result = (uint16_t)(((uint32_t)buffer[0] * 1000UL)+((uint32_t)ADC12_COUNTS_PER_VOLT/2)) / (uint32_t)ADC12_COUNTS_PER_VOLT);

Helsing's suggestion of printing out intermediate steps is the best way to verify the code is doing what you expect.

RE: nrf52805: ADC polling mode issue

helsing — Thu, 11 Apr 2024 12:41:19 GMT

Hi Gokulnath, sorry for the delay.

Some context is missing. However, it looks like you are performing many steps in only a few lines. Why not break up the calculations and print out the intermediate values? That way you could confirm that you are performing the intended calculations.

RE: nrf52805: ADC polling mode issue

Gokulnath — Wed, 27 Mar 2024 15:22:15 GMT

Hi hmolesworth helsing

I've noticed in debugging that my averaging might not be correct due to that I suspect it's moving a lot.

can you please verify it,

    if (timeout != 0)
    {
        result = ((buffer[0] * 1000L)+(ADC12_COUNTS_PER_VOLT/
        5)) / ADC12_COUNTS_PER_VOLT;
    }

especially this line?

EDIT:
sorry there was my typo during copy pasting the code in this thread. my correct code is still this.

result = ((buffer[0] * 1000L)+(ADC12_COUNTS_PER_VOLT/2)) / ADC12_COUNTS_PER_VOLT;

Thanks,
Gokulnath A R

RE: nrf52805: ADC polling mode issue

hmolesworth — Mon, 27 Nov 2023 17:06:50 GMT

I wrote this filter for a similar application; try it to see if it gives you what you are looking for

// Limit excursions such as noise spikes; for a step change this enforces a
// linear ramp or descent
// For 250 mVolts, 3300mV FSD and 12-bit ADC => ((250*4096)/3300) = 310
#define NOISE_SPIKE_CLIP_VALUE  310

// Equaliser single-pole low-pass filter value (0 is off). Increasing this value
// might require checking not overranging variables which FILTER_VALUE is assigned to.
#define FILTER_VALUE  16

#define FILTER_HOLDOFF_TRIP_LEVEL 16

// ADC Filter initial hold-off counter
uint16_t FilterHoldoffCounter = 0;
// Measured battery voltage - filtered value
uint16_t MeasuredBatteryVoltage;

void LowPassFilter(uint16_t *FilteredValue, uint16_t NewValue)
/*
 * This function implements a slew-rate limiting noise spike filter
 * followed by a single pole low-pass filter.
 *
 * Noise Spike Filter:
 *
 * Clip any signals to remain within 0.x volts of current filtered value
 *
 * Single-pole low-pass filter:
 *
 *    FV = ((1-n)*FV + n*V)/n where n=1/FILTER_VALUE
 *
 * The filter kicks in after 5 time constants which allows the filter to
 * settle to 12-bit resolution before taking over
 *
 * If FILTER_VALUE is constrained to lie between 0 (off) and 32 then 16-bit
 * unsigned arithmetic may be used since with a full-scale input reading
 * of 0x07FF (32-1)*0x7FF + 0x7FF + (32/2) = 65520 which fits in 16-bits
 * Otherwise 32-bit calculation is required. For ARM use 32-bit always
 */
{
    uint16_t LocalFilteredValue = *FilteredValue;
    uint16_t SpikeClippedValue;

    // Set initial value to be spike-clipped (slew-rate limited)
    SpikeClippedValue = NewValue;

    // Check if new value is above or below above current filtered value
    if (NewValue >= LocalFilteredValue)    // +ve signal excursion
    {
        // Clip input if more than 0.5 volts above current filtered value
        if (NewValue > LocalFilteredValue + NOISE_SPIKE_CLIP_VALUE)
        {
            SpikeClippedValue = LocalFilteredValue + NOISE_SPIKE_CLIP_VALUE;
        }
    }
    else  // -ve signal excursion
    {
        // Clip input if more than 0.5 volts below current filtered value
        if ((LocalFilteredValue - NewValue) > NOISE_SPIKE_CLIP_VALUE)
        {
            SpikeClippedValue = LocalFilteredValue - NOISE_SPIKE_CLIP_VALUE;
        }
    }

    // Either no filter or no processing required for speed, just return value
    #if (!FILTER_VALUE) //|| defined(USE_ADC12B_MULTIPLE_SAMPLES)
    {
        *FilteredValue = SpikeClippedValue;  // Filter disabled
        return;
    }
    #else //if (!FILTER_VALUE)

    LocalFilteredValue = (LocalFilteredValue*(FILTER_VALUE-1))
                       + SpikeClippedValue + (FILTER_VALUE/2);
    LocalFilteredValue /= FILTER_VALUE;

    // Filter settles to final 12-bit value within 5 time-constants, check ready
    // This is only used on exit hibernate and initial power-on cold start where
    // all channels are continually read to condition the filters. Prior to that
    // FilterHoldoffCounter must be initialized to 0.
    if ( FilterHoldoffCounter > FILTER_HOLDOFF_TRIP_LEVEL )
    {
        *FilteredValue = LocalFilteredValue;
    }
    else
    {
        FilterHoldoffCounter++;          // Waiting for initial stable reading
        *FilteredValue = NewValue;
    }
    #endif //if (!FILTER_VALUE)
}

RE: nrf52805: ADC polling mode issue

hmolesworth — Mon, 27 Nov 2023 16:54:59 GMT

BLE transmissions require current bursts, and even small such current bursts load the battery and are observable as voltage dips due to internal battery impedance which show up as disturbances in the measured voltage readings. Several options to reduce these voltage measurement dips: 1) sample the SAADC prior to a BLE burst (see Radio events); 2) add a filter capacitor between ADC IN 2 (AIN) and GND eg 100nF or more. Time constant of 100nF with 120k to battery is 12mSec, but for battery measurement probably an even slower value would be acceptable. The bigger the capacitor, the more even the voltage readings. 3) Use averaging; averaging is always better and for battery capacity response time is not significant.

Often two battery indications are required; battery voltage for capacity and lowest voltage dip for pending reset or brownout problems. Use averaging for the former and single values for the latter. Maybe even use 2 SAADC inputs, one with filter capacitor and one not to allow both fast sampling via comparator or SAADC and one for slower voltage measurement for capacity, probably overkill.

RE: nrf52805: ADC polling mode issue

Gokulnath — Mon, 27 Nov 2023 09:05:41 GMT

Hey,

I've made these suggested changes.hmolesworth

Ofc the value oscillation is better than before but still, it moves a lot.

->My voltage bridge is always on for this particular test & I verified it on the Circuit level during operation

My new code below:

// Input range of internal Vdd measurement = (0.6 V)/(1/5) = 3 V
// 3.0 volts ->  16383 ADC counts with 14-bit sampling:  5461 counts per volt
// 3.0 volts ->  4095 ADC counts with 14-bit sampling:  1365 counts per volt

#define ADC12_COUNTS_PER_VOLT 5461

void Adc12bitPolledInitialise(void)
{
    uint32_t timeout = 10;
    nrf_saadc_channel_config_t myConfig =
    {
        .resistor_p = NRF_SAADC_RESISTOR_DISABLED,
        .resistor_n = NRF_SAADC_RESISTOR_DISABLED,
        .gain       = NRF_SAADC_GAIN1_5,            // (1/5) Gain
        .reference  = NRF_SAADC_REFERENCE_INTERNAL, // 0.6V internal Ref Voltage
        .acq_time   = NRF_SAADC_ACQTIME_40US,       // See max source resistancetable
        .mode       = NRF_SAADC_MODE_SINGLE_ENDED,
        .burst      = NRF_SAADC_BURST_DISABLED,
        .pin_p      = NRF_SAADC_INPUT_AIN2,         // AIN2 for input Pin
        .pin_n      = NRF_SAADC_INPUT_DISABLED
    };

    nrf_saadc_resolution_set((nrf_saadc_resolution_t) 3);   // 2 is 12-bit , 3 for 14-bit 
    //nrf_saadc_oversample_set((nrf_saadc_oversample_t) 2);   // 2 is 4x, about 150uSecs total
    nrf_saadc_int_disable(NRF_SAADC_INT_ALL);
    nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
    nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
    nrf_saadc_enable();

    NRF_SAADC->CH[1].CONFIG =
              ((myConfig.resistor_p << SAADC_CH_CONFIG_RESP_Pos)   & SAADC_CH_CONFIG_RESP_Msk)
            | ((myConfig.resistor_n << SAADC_CH_CONFIG_RESN_Pos)   & SAADC_CH_CONFIG_RESN_Msk)
            | ((myConfig.gain       << SAADC_CH_CONFIG_GAIN_Pos)   & SAADC_CH_CONFIG_GAIN_Msk)
            | ((myConfig.reference  << SAADC_CH_CONFIG_REFSEL_Pos) & SAADC_CH_CONFIG_REFSEL_Msk)
            | ((myConfig.acq_time   << SAADC_CH_CONFIG_TACQ_Pos)   & SAADC_CH_CONFIG_TACQ_Msk)
            | ((myConfig.mode       << SAADC_CH_CONFIG_MODE_Pos)   & SAADC_CH_CONFIG_MODE_Msk)
            | ((myConfig.burst      << SAADC_CH_CONFIG_BURST_Pos)  & SAADC_CH_CONFIG_BURST_Msk);

    NRF_SAADC->CH[1].PSELN = myConfig.pin_n;
    NRF_SAADC->CH[1].PSELP = myConfig.pin_p;
    nrf_gpio_pin_write(ADC_SWITCH, 1); //Turning on  the voltage divider with a transistor
}

void ble_Update_BatteryVoltage(void)
{
    // Enable command & Turn on the Power
    //nrf_gpio_pin_write(ADC_SWITCH, 1); //Turning on  the voltage divider with a transistor
    nrf_saadc_enable();

    uint16_t result = 9999;         // Some recognisable dummy value
    uint32_t timeout = 100000;       // Trial and error
    volatile int16_t buffer[100];

    NRF_SAADC->RESULT.PTR = (uint32_t)buffer;
    NRF_SAADC->RESULT.MAXCNT = 1;

    nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
    nrf_saadc_task_trigger(NRF_SAADC_TASK_START);
    nrf_saadc_task_trigger(NRF_SAADC_TASK_SAMPLE);

    while (0 == nrf_saadc_event_check(NRF_SAADC_EVENT_END) && timeout > 0)
    {
        timeout--;
    }

    if (timeout != 0)
    {
        result = ((buffer[0] * 1000L)+(ADC12_COUNTS_PER_VOLT/2)) / ADC12_COUNTS_PER_VOLT;
    }

    nrf_saadc_task_trigger(NRF_SAADC_TASK_STOP);
    nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
    nrf_saadc_event_clear(NRF_SAADC_EVENT_END);

    // Disable command & turn off the Power to ADC Bridge to reduce power consumption
    nrf_saadc_disable();
    
    //nrf_gpio_pin_write(ADC_SWITCH, 0); //Turning off the voltage divider transistor
    ble_bas_battery_level_update(&m_bas, result, m_conn_handle); 
}

Regarding the example output which you asked helsing

I've just parsed the output of the Battery for each button press on the BLE terminal into the txt file for simpler understanding. (All the numbers are in hex format)

[quote userid="90815" url="~/f/nordic-q-a/105973/nrf52805-adc-polling-mode-issue/457197"]What does this look like? Would you be able to provide an example? Does the this change if you change the voltage?[/quote]

Voltage on BLE // 4.11V on voltage divider input from a Bench Power supply.
I      0BLEParserBase.CopyToRawData:Data:0x76
I      0BLEParserBase.CopyToRawData:Data:0x79
I      0BLEParserBase.CopyToRawData:Data:0x89
I      0BLEParserBase.CopyToRawData:Data:0x73
I      0BLEParserBase.CopyToRawData:Data:0x75
I      0BLEParserBase.CopyToRawData:Data:0x75
I      0BLEParserBase.CopyToRawData:Data:0x7A
I      0BLEParserBase.CopyToRawData:Data:0x6B
I      0BLEParserBase.CopyToRawData:Data:0x75
I      0BLEParserBase.CopyToRawData:Data:0x7B
I      0BLEParserBase.CopyToRawData:Data:0x7E
I      0BLEParserBase.CopyToRawData:Data:0x78

Voltage on BLE // 3.68V on voltage divider input from  a Bench Power supply.

I      0BLEParserBase.CopyToRawData:Data:0x4C
I      0BLEParserBase.CopyToRawData:Data:0x40
I      0BLEParserBase.CopyToRawData:Data:0x4B
I      0BLEParserBase.CopyToRawData:Data:0x4B
I      0BLEParserBase.CopyToRawData:Data:0x4A
I      0BLEParserBase.CopyToRawData:Data:0x4B
I      0BLEParserBase.CopyToRawData:Data:0x48
I      0BLEParserBase.CopyToRawData:Data:0x46
I      0BLEParserBase.CopyToRawData:Data:0x4A
I      0BLEParserBase.CopyToRawData:Data:0x40
I      0BLEParserBase.CopyToRawData:Data:0x45
I      0BLEParserBase.CopyToRawData:Data:0x4B
I      0BLEParserBase.CopyToRawData:Data:0x4D

My Observations:
I could see the Voltage on BLE clearly moves to the changes in input, My question is why it's not as stable as the bare-metal saadc example when I access it on the above polling method when the input voltage is constant?

My other trials:
I've tried the default saadc peripheral example from the SDK 17.0.2 /17.1
It outputs the value stable on the 52DK via uart. it also responds to the changes to the input voltage accurately.

But when I add the same code with the BLE stack the output has the same oscillation issue as mentioned in the above output text.

Thanks for your inputs.

RE: nrf52805: ADC polling mode issue

hmolesworth — Thu, 23 Nov 2023 16:20:03 GMT

There is a bug here, the result is read before the SAADC sample has completed:

    if (timeout != 0)
    {
        result = ((buffer[0] * 1000L)+(ADC12_COUNTS_PER_VOLT/
        5)) / ADC12_COUNTS_PER_VOLT;
    }

    while (0 == nrf_saadc_event_check(NRF_SAADC_EVENT_END) && timeout > 0)
    {
        timeout--;
    }

Change to:

    while (0 == nrf_saadc_event_check(NRF_SAADC_EVENT_END) && timeout > 0)
    {
        timeout--;
    }
    if (timeout != 0)
    {
        result = ((buffer[0] * 1000L)+(ADC12_COUNTS_PER_VOLT/
        5)) / ADC12_COUNTS_PER_VOLT;
    }

RE: nrf52805: ADC polling mode issue

helsing — Thu, 23 Nov 2023 14:25:16 GMT

Hi Gokulnath,

[quote user=""]

My Objective:

measure the Li-ion battery voltage(4.2V -100% till 3.6V-0%) through an external resistive divider & internal 0.6v ref voltage. (I'm not worried about the current consumption as of this moment. would like to make this concept work & all the other optimisations shall see later

[/quote]

You could try the peripheral/saadc sample in nRF5 SDK.

[quote user=""]But the ADC is just measuring some garbage value (random) which is clearly not correct.[/quote]

What does this look like? Would you be able to provide an example? Does the this change if you change the voltage?

[quote user=""]Thanks, for any valuable input I'm new to NRF. [/quote]

nRF Connect SDK is recommended for new designs. Please see the nRF Connect SDK and nRF5 SDK statement as well as the nRF Connect SDK Fundamentals course at Nordic Developer Academy.

https://www.nordicsemi.com/Products/Development-software/nrf-connect-sdk

Here are some samples for nRF Connect SDK. You could start with simple_blocking or simple_nonblocking: hal_nordic/nrfx/samples/src/nrfx_saadc at master · zephyrproject-rtos/hal_nordic · GitHub

RE: nrf52805: ADC polling mode issue

Gokulnath — Thu, 23 Nov 2023 09:40:11 GMT

Hey,

Yes I've verified this on the nrf52805_bitfields.h file (under modules/nrfx/mdk)

its mentioned as this : " #define SAADC_CH_PSELP_PSELP_AnalogInput2 (3UL) /*!< AIN2 */"

I've verified my PCB connections too it's under P0.04.

Voltages to the voltage divider are coming in crisp & voltage drop is similar to theoretical expectations with some milli volt differences.

Should I continue to debug this? or shall I go back to some tried & tested method example code on Saadc? (is it available if so please let me know where can i find them. ) may be interrupt on button press is preferred.

RE: nrf52805: ADC polling mode issue

hmolesworth — Wed, 22 Nov 2023 16:34:19 GMT

Small tip, the SAADC pin numbering can be confusing leading to using the wrong pin; AIN2 is P0.4

// Analog positive and negative input channels have strange numbering:
//  PSELP_NC           0UL  Not connected
//  PSELP_AnalogInput0 1UL  AIN0 P0.02
//  PSELP_AnalogInput1 2UL  AIN1 P0.03
//  PSELP_AnalogInput2 3UL  AIN2 P0.04
//  PSELP_AnalogInput3 4UL  AIN3
//  PSELP_AnalogInput4 5UL  AIN4
//  PSELP_AnalogInput5 6UL  AIN5
//  PSELP_AnalogInput6 7UL  AIN6
//  PSELP_AnalogInput7 8UL  AIN7
//  PSELP_VDD          9UL  VDD