adc.c File Reference

ADC functionality for reading the (battery) voltage, internal temperature and CH4/5/6/7 voltages. More...

#include <stdint.h>
#include <stdbool.h>
#include "em_device.h"
#include "em_cmu.h"
#include "em_adc.h"
#include "adc.h"
#include "debug_dbprint.h"
#include "util.h"

Go to the source code of this file.

Macros
#define	DBPRINT_TIMEOUT   0
#define	TIMEOUT_CONVERSION   70

Functions
static float32_t	convertToCelsius (int32_t adcSample)
	Method to convert an ADC value to a temperature value. More...
void	initADC (ADC_Measurement_t peripheral)
	Method to initialize the ADC to later check the battery voltage or internal temperature. More...
int32_t	readADC (ADC_Measurement_t peripheral)
	Method to read the battery voltage or internal temperature. More...
void	ADC0_IRQHandler (void)
	Interrupt Service Routine for ADC0. More...

Variables
volatile bool	adcConversionComplete = false
ADC_Init_TypeDef	init = ADC_INIT_DEFAULT
ADC_InitSingle_TypeDef	initSingle = ADC_INITSINGLE_DEFAULT

Detailed Description

ADC functionality for reading the (battery) voltage, internal temperature and CH4/5/6/7 voltages.

Version

3.0

Author

Brecht Van Eeckhoudt

---

Versions

• v1.0: Moved ADC functionality from other.c to this file.
• v1.1: Removed re-initialization dbprint messages.
• v1.2: Started using custom enum type and cleaned up some unnecessary statements after testing.
• v1.3: Changed error numbering.
• v1.4: Added timeout to while loop and changed types to int32_t.
• v1.5: Refined timout functionality.
• v2.0: Disabled peripheral clock before entering an error function, added functionality to exit methods after error call and updated version number.
• v2.1: Removed static before the local variables (not necessary).
• v3.0: Added CH4/5/6/7 measurement capabilities.

---

License

Copyright (C) 2020 - Brecht Van Eeckhoudt

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

A copy of the GNU General Public License can be found in the LICENSE file along with this source code.

Some methods use code obtained from examples from Silicon Labs' GitHub. These sections are licensed under the Silabs License Agreement. See the file "Silabs_License_Agreement.txt" for details. Before using this software for any purpose, you must agree to the terms of that agreement.

Definition in file adc.c.

Macro Definition Documentation

DBPRINT_TIMEOUT

#define DBPRINT_TIMEOUT   0

Enable (1) or disable (0) printing the timeout counter value using DBPRINT

Definition at line 64 of file adc.c.

TIMEOUT_CONVERSION

#define TIMEOUT_CONVERSION   70

Maximum value for the counter before exiting a while loop

Definition at line 67 of file adc.c.

Function Documentation

ADC0_IRQHandler()

void ADC0_IRQHandler

(

void

)

Interrupt Service Routine for ADC0.

Definition at line 376 of file adc.c.

{
    /* Read interrupt flags */
     uint32_t flags = ADC_IntGet(ADC0);

    /* Clear the ADC0 interrupt flags */
    ADC_IntClear(ADC0, flags);

    /* Indicate that an ADC conversion has been completed */
    adcConversionComplete = true;
}

convertToCelsius()

static float32_t convertToCelsius ( int32_t  adcSample )

static

Method to convert an ADC value to a temperature value.

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Parameters

[in]

adcSample

The ADC sample to convert to a temperature value.

Returns

The converted temperature value.

Definition at line 351 of file adc.c.

{
    float32_t temp;

    /* Factory calibration temperature from device information page. */
    int32_t cal_temp_0 = ((DEVINFO->CAL & _DEVINFO_CAL_TEMP_MASK)
                        >> _DEVINFO_CAL_TEMP_SHIFT);

    /* Factory calibration value from device information page. */
    int32_t cal_value_0 = ((DEVINFO->ADC0CAL2 & _DEVINFO_ADC0CAL2_TEMP1V25_MASK)
                         >> _DEVINFO_ADC0CAL2_TEMP1V25_SHIFT);

    /* Temperature gradient (from datasheet) */
    float32_t t_grad = -6.27;

    temp = (cal_temp_0 - ((cal_value_0 - adcSample) / t_grad));

    return (temp);
}

initADC()

void initADC

(

ADC_Measurement_t

peripheral

)

Method to initialize the ADC to later check the battery voltage or internal temperature.

Parameters

[in]

peripheral

Select the ADC peripheral to initialize.

Definition at line 87 of file adc.c.

{
    /* Enable necessary clocks (just in case) */
    CMU_ClockEnable(cmuClock_HFPER, true); /* ADC0 is a High Frequency Peripheral */
    CMU_ClockEnable(cmuClock_ADC0, true);

    /* Set a timebase providing at least 1 us.
     * If the argument is "0" the currently defined HFPER clock setting is used. */
    init.timebase = ADC_TimebaseCalc(0);

    /* Set a prescale value according to the ADC frequency (400 000 Hz) wanted.
     * If the last argument is "0" the currently defined HFPER clock setting is for the calculation used. */
    init.prescale = ADC_PrescaleCalc(400000, 0);

    /* Initialize ADC peripheral */
    ADC_Init(ADC0, &init);

    /* Setup single conversions */

    /* initSingle.acqTime = adcAcqTime16;
     * The statement above was found in a SiLabs example but DRAMCO disabled it.
     * After testing this seemed to have no real effect so it was disabled.
     * This is probably not necessary since a prescale value other than 0 (default) has been defined. */
    if (peripheral == INTERNAL_TEMPERATURE) initSingle.input = adcSingleInpTemp; /* Internal temperature */
    else if (peripheral == BATTERY_VOLTAGE) initSingle.input = adcSingleInpVDDDiv3; /* Internal VDD/3 */
    else if (peripheral == CH1)
    {
        initSingle.input = adcSingleInputCh4; /* Channel 4 */
        initSingle.reference = adcRef2V5; /* Internal 2V5 reference (1V25 default) */
    }
    else if (peripheral == CH2)
    {
        initSingle.input = adcSingleInputCh5; /* Channel 5 */
        initSingle.reference = adcRef2V5; /* Internal 2V5 reference (1V25 default) */
    }
    else if (peripheral == CH3)
    {
        initSingle.input = adcSingleInputCh6; /* Channel 6 */
        initSingle.reference = adcRef2V5; /* Internal 2V5 reference (1V25 default) */
    }
    else if (peripheral == CH4)
    {
        initSingle.input = adcSingleInputCh7; /* Channel 7 */
        initSingle.reference = adcRef2V5; /* Internal 2V5 reference (1V25 default) */
    }
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Unknown ADC peripheral selected!");
#endif /* DEBUG_DBPRINT */

        /* Disable used clock */
        CMU_ClockEnable(cmuClock_ADC0, false);

        error(11);

        /* Exit function */
        return;
    }

    ADC_InitSingle(ADC0, &initSingle);

    /* Manually set some calibration values
     * ADC0->CAL = (0x7C << _ADC_CAL_SINGLEOFFSET_SHIFT) | (0x1F << _ADC_CAL_SINGLEGAIN_SHIFT);
     * The statement above was found in a SiLabs example but DRAMCO disabled it.
     * After testing this seemed to throw off the first measurement so it was disabled. */

    /* Enable interrupt on completed conversion */
    ADC_IntEnable(ADC0, ADC_IEN_SINGLE);
    NVIC_ClearPendingIRQ(ADC0_IRQn);
    NVIC_EnableIRQ(ADC0_IRQn);

    /* Disable used clock */
    CMU_ClockEnable(cmuClock_ADC0, false);

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
    if (peripheral == INTERNAL_TEMPERATURE) dbinfo("ADC0 initialized for internal temperature");
    else if (peripheral == BATTERY_VOLTAGE) dbinfo("ADC0 initialized for VBAT");
    else if (peripheral == CH1) dbinfo("ADC0 initialized for CH1");
    else if (peripheral == CH2) dbinfo("ADC0 initialized for CH2");
    else if (peripheral == CH3) dbinfo("ADC0 initialized for CH3");
    else if (peripheral == CH4) dbinfo("ADC0 initialized for CH4");
#endif /* DEBUG_DBPRINT */

}

readADC()

int32_t readADC

(

ADC_Measurement_t

peripheral

)

Method to read the battery voltage or internal temperature.

This method re-initializes the ADC settings if necessary.
Negative internal temperatures work fine.

Parameters

[in]

peripheral

Select the ADC peripheral to read from.

Returns

The measured battery voltage or internal temperature.

Definition at line 189 of file adc.c.

{
    uint16_t counter = 0; /* Timeout counter */
    int32_t value = 0; /* Value to eventually return */

    /* Enable necessary clock */
    CMU_ClockEnable(cmuClock_ADC0, true);

    /* Change ADC settings if necessary */
    if (peripheral == INTERNAL_TEMPERATURE)
    {
        if (initSingle.input != adcSingleInpTemp)
        {
            initSingle.input = adcSingleInpTemp; /* Internal temperature */
            initSingle.reference = adcRef1V25; /* Internal 1V25 reference (default) */
            ADC_InitSingle(ADC0, &initSingle);
        }
    }
    else if (peripheral == BATTERY_VOLTAGE)
    {
        if (initSingle.input != adcSingleInpVDDDiv3)
        {
            initSingle.input = adcSingleInpVDDDiv3; /* Internal VDD/3 */
            initSingle.reference = adcRef1V25; /* Internal 1V25 reference (default) */
            ADC_InitSingle(ADC0, &initSingle);
        }
    }
    else if (peripheral == CH1)
    {
        if (initSingle.input != adcSingleInputCh4)
        {
            initSingle.input = adcSingleInputCh4; /* Channel 4 */
            initSingle.reference = adcRef2V5; /* Internal 2V5 reference (1V25 default) */
            ADC_InitSingle(ADC0, &initSingle);
        }
    }
    else if (peripheral == CH2)
    {
        if (initSingle.input != adcSingleInputCh5)
        {
            initSingle.input = adcSingleInputCh5; /* Channel 5 */
            initSingle.reference = adcRef2V5; /* Internal 2V5 reference (1V25 default) */
            ADC_InitSingle(ADC0, &initSingle);
        }
    }
    else if (peripheral == CH3)
    {
        if (initSingle.input != adcSingleInputCh6)
        {
            initSingle.input = adcSingleInputCh6; /* Channel 6 */
            initSingle.reference = adcRef2V5; /* Internal 2V5 reference (1V25 default) */
            ADC_InitSingle(ADC0, &initSingle);
        }
    }
    else if (peripheral == CH4)
    {
        if (initSingle.input != adcSingleInputCh7)
        {
            initSingle.input = adcSingleInputCh7; /* Channel 7 */
            initSingle.reference = adcRef2V5; /* Internal 2V5 reference (1V25 default) */
            ADC_InitSingle(ADC0, &initSingle);
        }
    }
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Unknown ADC peripheral selected!");
#endif /* DEBUG_DBPRINT */

        /* Disable used clock */
        CMU_ClockEnable(cmuClock_ADC0, false);

        error(12);

        /* Exit function */
        return (0);
    }

    /* Set variable false just in case */
    adcConversionComplete = false;

    /* Start single ADC conversion */
    ADC_Start(ADC0, adcStartSingle);

    /* Wait until the conversion is completed */
    while ((counter < TIMEOUT_CONVERSION) && !adcConversionComplete) counter++;

    /* Exit the function if the maximum waiting time was reached */
    if (counter == TIMEOUT_CONVERSION)
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Waiting time for ADC conversion reached!");
#endif /* DEBUG_DBPRINT */

        /* Disable used clock */
        CMU_ClockEnable(cmuClock_ADC0, false);

        error(13);

        /* Exit function */
        return (0);
    }
#if DBPRINT_TIMEOUT == 1 /* DBPRINT_TIMEOUT */
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbwarnInt("ADC conversion (", counter, ")");
#endif /* DEBUG_DBPRINT */

    }
#endif /* DBPRINT_TIMEOUT */

    /* Get the ADC value */
    value = ADC_DataSingleGet(ADC0);

    dbwarnInt("ADC value = ", value, ""); // Debugging

    /* Disable used clock */
    CMU_ClockEnable(cmuClock_ADC0, false);

    /* Calculate final value according to parameter */
    if (peripheral == INTERNAL_TEMPERATURE)
    {
        float32_t ft = convertToCelsius(value)*1000;
        value = (int32_t) ft;
    }
    else if (peripheral == BATTERY_VOLTAGE)
    {
        /* 12 bit: 2^12 = 4096 */
        float32_t fv = (value * 3.75) / 4.096;
        value = (int32_t) fv;
    }
    else if (peripheral == CH1 || peripheral == CH2 || peripheral == CH3 || peripheral == CH4)
    {
        /* 2.5 = reference voltage
         * 12 bit: 2^12 = 4096 (comma placement is for int32_t conversion...) */
        dbprintln("Here!");
        float32_t fv = (value * 2.5) / 409.6;
        value = (int32_t) fv;
    }

    return (value);
}

Variable Documentation

adcConversionComplete

volatile bool adcConversionComplete = false

Definition at line 71 of file adc.c.

init

ADC_Init_TypeDef init = ADC_INIT_DEFAULT

Definition at line 72 of file adc.c.

initSingle

ADC_InitSingle_TypeDef initSingle = ADC_INITSINGLE_DEFAULT

Definition at line 73 of file adc.c.