芯科ADC采集使用tailgating实现周期扫描与随机单次采样而不影响周期扫描采样时序的方法

我们在使用adc采样的时候有时候会遇到这样的场景，只用一个ADC，有一个需要周期采样的数据，并且时序要求比较高，比如心电数据这种时序要求高的采样对象，并且想多采样多个其他数据比如板子上的其他温度，气压，电压数据等这类对时序无要求的数据，正常我们的解决方案有两种：

1)将这类数据放到adc扫描列表中，而当产品对功耗非常敏感时，将这类较长时间才采样一次的数据放置到扫描列表里每次都参加扫描，将会导致功耗浪费在许多不需要的采集中，这是功耗敏感型应用所无法接受的

2)判断下扫描周期时间，避开adc周期采样时间，避免影响到adc周期扫描采样，但是这样也会导致功耗上升并且实现方法较为复杂

而在芯科的adc参考手册中，你可以看到这样一种方法，它可以实现不影响周期采样的时序的情况下，随机穿插一个单次采样，并且相对只有周期扫描的功耗上升微乎其微，这种方法叫tailgating，意思就是在adc采集时增加一个队列，将采集的命令都放在队列中，在随机来的采样命令中放置队列尾部，在每次周期采样时间实现队列中的命令，以下为原理：

实现的方法很简单，只需要将scan和single的adc采样方式，一起进行初始化，将scan ADC的命令放在定时器的周期中断中实现周期scan采样，然后在任意时候使用单次采样都会在下一次scan命令采集完进行单次采样命令。

下面是以定时中断扫描，按键触发单次采样并以串口输出结果为例的代码示例：

1、初始化ADC

void initIADC(void)

{

 app_log("Init adc_tailgating\r\n");

 // Declare initialization structures

 IADC_Init_t init = IADC_INIT_DEFAULT;

 IADC_AllConfigs_t initAllConfigs = IADC_ALLCONFIGS_DEFAULT;

 IADC_InitScan_t initScan = IADC_INITSCAN_DEFAULT;

 /*******************************************************************/

 IADC_InitSingle_t initSingle = IADC_INITSINGLE_DEFAULT;

 IADC_SingleInput_t initSingleInput = IADC_SINGLEINPUT_DEFAULT;

 /*******************************************************************/

 // Scan table structure

 IADC_ScanTable_t scanTable = IADC_SCANTABLE_DEFAULT;

 CMU_ClockEnable(cmuClock_IADC0, true);

 /*******************************************************************/

 app_log("ready to IADC_reset\r\n");

 IADC_reset(IADC0);

 app_log("IADC_reset done \r\n");

 /*******************************************************************/

 // Use the FSRC0 as the IADC clock so it can run in EM2

 CMU_ClockSelectSet(cmuClock_IADCCLK, cmuSelect_FSRCO);

 // Set the prescaler needed for the intended IADC clock frequency

 init.srcClkPrescale = IADC_calcSrcClkPrescale(IADC0, CLK_SRC_ADC_FREQ, 0);

 // Shutdown between conversions to reduce current

 init.warmup = iadcWarmupNormal;

 initSingle.singleTailgate = tailgating_switch;

 /*

  * Configuration 0 is used by both scan and single conversions by

  * default.  Use internal bandgap as the reference and specify the

  * reference voltage in mV.

  *

  * Resolution is not configurable directly but is based on the

  * selected oversampling ratio (osrHighSpeed), which defaults to

  * 2x and generates 12-bit results.

  */

 initAllConfigs.configs[0].reference = iadcCfgReferenceInt1V2;

 initAllConfigs.configs[0].vRef = 1210;

 initAllConfigs.configs[0].osrHighSpeed = iadcCfgOsrHighSpeed2x;

 initAllConfigs.configs[0].analogGain = iadcCfgAnalogGain0P5x;

 /*

  * CLK_SRC_ADC is prescaled to derive the intended CLK_ADC frequency.

  *

  * Based on the default 2x oversampling rate (OSRHS)...

  *

  * conversion time = ((4 * OSRHS) + 2) / fCLK_ADC

  *

  * ...which, results in a maximum sampling rate of 833 ksps with the

  * 2-clock input multiplexer switching time is included.

  */

 initAllConfigs.configs[0].adcClkPrescale = IADC_calcAdcClkPrescale(IADC0,

                                                                    CLK_ADC_FREQ,

                                                                    0,

                                                                    iadcCfgModeNormal,

                                                                    init.srcClkPrescale);

 /*

  * Set the SCANFIFODVL flag when there are 4 entries in the scan

  * FIFO.

  *

  * Tag FIFO entries with scan table entry IDs.

  *

  * Allow a scan conversion sequence to start as soon as there is a

  * trigger event.

  */

 initScan.dataValidLevel = iadcFifoCfgDvl4;

 initScan.showId = true;

 initScan.start = true;

 /*

  * Configure entries in scan table.  CH0 is single-ended from

  * input 0; CH1 is single-ended from input 1.

  */

 scanTable.entries[0].posInput = IADC_INPUT_0_PORT_PIN;

 scanTable.entries[0].negInput = iadcNegInputGnd;

 scanTable.entries[0].includeInScan = true;

 scanTable.entries[1].posInput = IADC_INPUT_1_PORT_PIN;

 scanTable.entries[1].negInput = iadcNegInputGnd;

 scanTable.entries[1].includeInScan = true;

 scanTable.entries[2].posInput = iadcPosInputAvdd;      // Add AVDD to scan for demonstration purposes

 scanTable.entries[2].negInput = iadcNegInputGnd | 1;   // When measuring a supply, PINNEG must be odd (1, 3, 5,...)

 scanTable.entries[2].includeInScan = true;

 scanTable.entries[3].posInput = iadcPosInputVddio;     // Add VDDIO to scan for demonstration purposes

 scanTable.entries[3].negInput = iadcNegInputGnd | 1;   // When measuring a supply, PINNEG must be odd (1, 3, 5,...)

 scanTable.entries[3].includeInScan = true;

 scanTable.entries[4].posInput = iadcPosInputVss;       // Add VSS to scan for demonstration purposes

 scanTable.entries[4].negInput = iadcNegInputGnd | 1;   // When measuring a supply, PINNEG must be odd (1, 3, 5,...)

 scanTable.entries[4].includeInScan = false;            // FIFO is only 4 entries deep

 scanTable.entries[5].posInput = iadcPosInputVssaux;    // Add VSSAUX (same as VSS) to scan for demonstration purposes

 scanTable.entries[5].negInput = iadcNegInputGnd | 1;   // When measuring a supply, PINNEG must be odd (1, 3, 5,...)

 scanTable.entries[5].includeInScan = false;

 scanTable.entries[6].posInput = iadcPosInputDvdd;      // Add DVDD to scan for demonstration purposes

 scanTable.entries[6].negInput = iadcNegInputGnd | 1;   // When measuring a supply, PINNEG must be odd (1, 3, 5,...)

 scanTable.entries[6].includeInScan = false;

 scanTable.entries[7].posInput = iadcPosInputDecouple;  // Add DECOUPLE to scan for demonstration purposes

 scanTable.entries[7].negInput = iadcNegInputGnd | 1;   // When measuring a supply, PINNEG must be odd (1, 3, 5,...)

 scanTable.entries[7].includeInScan = false;

 // Initialize IADC

 IADC_init(IADC0, &init, &initAllConfigs);

 // Initialize scan

 IADC_initScan(IADC0, &initScan, &scanTable);

 /*******************************************************************/

 // Initialize Single

 IADC_initSingle(IADC0, &initSingle, &initSingleInput);

 /*******************************************************************/

 // Allocate the analog bus for IADC0 inputs

 GPIO->IADC_INPUT_0_BUS |= IADC_INPUT_0_BUSALLOC;

 GPIO->IADC_INPUT_1_BUS |= IADC_INPUT_1_BUSALLOC;

 // Clear any previous interrupt flags

 IADC_clearInt(IADC0, _IADC_IF_MASK);

 // Enable scan interrupts

 IADC_enableInt(IADC0, IADC_IEN_SCANTABLEDONE);

 // Enable single done interrupts

  IADC_enableInt(IADC0, IADC_IEN_SINGLEDONE);

 // Enable IADC interrupts

 NVIC_ClearPendingIRQ(IADC_IRQn);

 NVIC_EnableIRQ(IADC_IRQn);

}

2、初始化定时器，1秒定时

/**************************************************************************//**

* @brief LETIMER initialization

*****************************************************************************/

void initLETIMER(void)

{

 CMU_LFXOInit_TypeDef lfxoInit = CMU_LFXOINIT_DEFAULT;

 LETIMER_Init_TypeDef letimerInit = LETIMER_INIT_DEFAULT;

 // Initialize the LFXO and use it as the EM23GRPACLK source

 CMU_LFXOInit(&lfxoInit);

 CMU_ClockSelectSet(cmuClock_EM23GRPACLK, cmuSelect_LFXO);

 CMU_ClockEnable(cmuClock_LETIMER0, true);

 // Calculate the top value (frequency) based on clock source

 uint32_t topValue = CMU_ClockFreqGet(cmuClock_LETIMER0) / LETIMER_FREQ;

 // Reload top on underflow, pulse output, and run in free mode

 letimerInit.comp0Top = true;

 letimerInit.topValue = topValue;

 letimerInit.ufoa0 = letimerUFOAPulse;

 letimerInit.repMode = letimerRepeatFree;

 // Initialize LETIMER

 LETIMER_Init(LETIMER0, &letimerInit);

 // Clear any previous interrupt flags

 LETIMER_IntClear(LETIMER0, _LETIMER_IF_MASK);

 // Enable underflow interrupts

 LETIMER_IntEnable(LETIMER0, LETIMER_IEN_UF);

 // Enable LETIMER interrupts

 NVIC_ClearPendingIRQ(LETIMER0_IRQn);

 NVIC_EnableIRQ(LETIMER0_IRQn);

 app_log("LETIMER0 init done\r\n");

}

3、定时器中断

/**************************************************************************//**

* @brief  LETIMER IRQ Handler

*****************************************************************************/

void LETIMER0_IRQHandler(void)

{

 uint32_t flags = LETIMER_IntGet(LETIMER0);

 // Trigger an IADC scan conversion

 IADC_command(IADC0, iadcCmdStartScan);

 app_log("LETIMER0 timeout\r\n");

 // Clear LETIMER interrupt flags

 LETIMER_IntClear(LETIMER0, flags);

}

4、采样中断

/**************************************************************************//**

* @brief  IADC interrupt handler

*****************************************************************************/

void IADC_IRQHandler(void)

{

 IADC_Result_t result = {0, 0};

 // While the FIFO count is non-zero...

 while (IADC_getScanFifoCnt(IADC0))

 {

   // Pull a scan result from the FIFO

   result = IADC_pullScanFifoResult(IADC0);

   /*

    * Calculate the voltage converted as follows:

    *

    * For single-ended conversions, the result can range from 0 to

    * +Vref, i.e., for Vref = VBGR = 1.21V, and with analog gain = 0.5,

    * 0xFFF represents the full scale value of 2.42V.

    */

   scanResult[result.id] = result.data * 2.42 / 0xFFF;

   /*

    * Scan results 2 - 6 are for external supply voltages, which are

    * presented to the IADC divided by 4 for conversion.  Back this

    * out to get the correct result in volts.  Note that DECOUPLE,

    * scan table entry 7 in this example, is an internal supply (the

    * output of the core supply regulator) and is connected directly

    * to the IADC without a divide-by-4 stage.

    */

   if ((result.id > 1) && (result.id < 7)) {

     scanResult[result.id] *= 4;

   }

   app_log("scanResult[%d] : %lf\r\n",result.id,scanResult[result.id]);

 }

   while (IADC_getSingleFifoCnt(IADC0))

   {

     sample = IADC_pullSingleFifoResult(IADC0);

     singleResult = sample.data * 2.42 / 0xFFF;

     app_log("singleResult : %lf\r\n",singleResult);

   }

 // Alternate between the first and second set of scan table entries.

 if (result.id == 3) {

   IADC_setScanMask(IADC0, 0x0070);

 }

 else {

   IADC_setScanMask(IADC0, 0x000F);

 }

 /*

  * Clear the scan table complete interrupt.  Reading FIFO results

  * does not do this automatically.

  */

 IADC_clearInt(IADC0, IADC_IF_SCANTABLEDONE);

 IADC_clearInt(IADC0, IADC_IF_SINGLEDONE);

}

5、按键中断

void sl_button_on_change(const sl_button_t *handle)

{

 (void)handle;

 IADC_command(IADC0, iadcCmdStartSingle);

}