5.1 ADC Guide

The example first brings up the ADC on a divided clock, then triggers one channel at a time from the main loop.

Data path: RCC_Configuration enables the GPIO and ADC clocks → GPIO_Configuration writes the PA0 and PA1 modes → ADC_Initial calls ADC_Init and ADC_Enable → the main loop triggers through ADC_Config_And_Get_Data → ADC_GetDat returns the result into ADCConvertedValue

1. Enable the GPIO and ADC clocks, then set the ADC clock divider. The ADC sits on AHB and takes its operating clock from ADC_ClockModeConfig, here one quarter of 64 MHz.

void RCC_Configuration(void)
{
    /* Enable peripheral clocks ------------------------------------------------*/

    /* Enable GPIO clocks */
    RCC_EnableAPBPeriphClk(RCC_APB_PERIPH_GPIO, ENABLE);
    /* Enable ADC clocks */
    RCC_EnableAHBPeriphClk(RCC_AHB_PERIPH_ADC, ENABLE);
    
    /* RCC_ADCHCLK_DIV4*/
    ADC_ClockModeConfig(RCC_ADCHCLK_DIV4);
}

When you move the code to another system frequency, check this divider so that the ADC clock stays within the limit stated in the manual.

2. Configure the measured pins as analog inputs. Analog mode detaches the pin from the digital input path, and both channels share one configuration call.

    GPIO_InitStruct(&GPIO_InitStructure);
    /* Configure PA0 PA1 as analog input -----------------------*/
    GPIO_InitStructure.Pin       = GPIO_PIN_0 | GPIO_PIN_1;
    GPIO_InitStructure.GPIO_Mode = GPIO_MODE_ANALOG;
    GPIO_InitPeripheral(GPIOA, &GPIO_InitStructure);

If you switch to other channels, change the pins here and the channel numbers passed to ADC_Config_And_Get_Data in the same step.

3. Initialize the ADC and wait for power-up before converting. The structure members select the trigger source, the data alignment, and the phase mode; this example disables continuous conversion, selects the software trigger, and gives each of the four phases one channel.

    ADC_InitStruct(&ADC_InitStructure);
    /* ADC configuration ------------------------------------------------------*/
    ADC_InitStructure.ContinueConvEn = DISABLE;
    /* Initialize the ExtTrigSelect1 member */
    ADC_InitStructure.ExtTrigSelect1 = ADC_EXT_TRIGCONV_SWSTRRCH;
    /* Initialize the DatAlign member */
    ADC_InitStructure.DatAlign       = ADC_DAT_ALIGN_R;
    /* Initialize the phase mode member */
    ADC_InitStructure.PhsMode        = ADC_PHS_TRG_MODE_SINGLE ;
    /* Initialize the phase 1 channel number member */
    ADC_InitStructure.Phs1ChNumber   = 1U;
    /* Initialize the phase 2 channel number member */
    ADC_InitStructure.Phs2ChNumber   = 1U;
    /* Initialize the phase 3 channel number member */
    ADC_InitStructure.Phs3ChNumber   = 1U;
    /* Initialize the phase 4 channel number member */
    ADC_InitStructure.Phs4ChNumber   = 1U;
    ADC_Init(&ADC_InitStructure);

    /* Enable ADC */
    ADC_Enable(ENABLE);
    /*Check ADC Ready*/
    while(ADC_GetFlagStatus(ADC_FLAG_RDY) == RESET)
        ;

The while loop waits on ADC_FLAG_RDY, which reports power-up completion; removing this poll lets a conversion start before the ADC is ready.

4. Reconfigure the channel on every read, then trigger and fetch. The function queues the requested channel, waits for the phase to finish, clears the flags, and reads the data register, so one phase can serve different channels in turn.

    uint16_t dat;
    
    ADC_ConfigRegularChannel(ADC_Channel, 1, ADC_SAMP_TIME_72CYCLES);
    /* Start ADC Software Conversion */
    ADC_EnableChannelStartConv(ADC_SWSTRRCH_PHS1_START);
    while(ADC_GetFlagStatus(ADC_FLAG_ENDC)==0){
    }
    ADC_ClearFlag(ADC_FLAG_ENDC);
    ADC_ClearFlag(ADC_FLAG_STR);
    dat=ADC_GetDat();
    
    return dat;

Adjust the sample time to the source impedance, and when you change the trigger, check that ADC_InitStructure.ExtTrigSelect1 and the start macro here still match.

Corresponding source files: src/main.c, firmware/n32g033_std_periph_driver/inc/n32g033_adc.h

The example enables the temperature sensor channel and converts the raw code to a temperature with the on-chip calibration value before printing it.

Data path: ADC_EnableTempSensor enables the channel → ADC_Config_And_Get_Data triggers and reads the raw code → TempCal reads the on-chip calibration value and computes the temperature → TempValue → printf through the UART1 configured by log_init

1. The file header carries the reference voltage and the slope used by the conversion. The reference voltage follows the actual supply, as the comment notes, and the slope comes from the datasheet.

/*xx mv per degree Celsius  by datasheet define*/
#define AVG_SLOPE  0.00407f


//#define VDDA_5V
#ifdef  VDDA_5V
#define  VREF_VALUE      (5.0)      //this value need be configured by the actual voltage reference. 
#define  VTS_CODE_ADDR   (0x1FFFF048U)
#else
#define  VREF_VALUE      (3.3)
#define  VTS_CODE_ADDR   (0x1FFFF048U)
#endif

With a 5 V supply, enable VDDA_5V and check both VREF_VALUE and the bit field used to extract the calibration value.

2. Enable the temperature sensor channel before enabling the ADC. Channel 16 belongs to the internal temperature sensor, and only an enabled channel can be selected by the regular sequence; both enables sit in the same function.

    ADC_EnableTempSensor(ENABLE);
    /* Enable ADC */
    ADC_Enable(ENABLE);
    /*Check ADC Ready*/
    while(ADC_GetFlagStatus(ADC_FLAG_RDY) == RESET)
        ;

Do not swap the channel enable and the ADC enable; to use another internal signal source, replace the enable call here.

3. Every read waits on the end flag and uses a longer sample time. The internal sensor has a high output impedance, so the sample time is 400 cycles; even in continuous mode each read waits for the end flag.

    ADC_ConfigRegularChannel(ADC_Channel, 1, ADC_SAMP_TIME_400CYCLES);
    /* Start ADC Software Conversion */
    ADC_EnableChannelStartConv(ADC_SWSTRRCH_PHS1_START);
    while(ADC_GetFlagStatus(ADC_FLAG_ENDCA)==0){
    }
    ADC_ClearFlag(ADC_FLAG_ENDCA);
    ADC_ClearFlag(ADC_FLAG_STR);
    dat=ADC_GetDat();

The wait is on ADC_FLAG_ENDCA here rather than the ADC_FLAG_ENDC used by the single-read example; when you change the sample time, check it against the source impedance.

4. The conversion function reads the on-chip calibration value and applies the slope. The calibration value lives at a fixed address, and VDDA_5V selects whether the high or the low 16 bits are used.

    float Temperate,tempValue,VTS;
    uint32_t TSValue;
    /* Voltage value of temperature sensor */
    tempValue=TempAdVal*(VREF_VALUE/4095);

The next fragment sits below a VDDA_5V conditional block, which decides the bit field of the selected value.

    /* Get the temperature inside the chip */
    Temperate= (VTS-tempValue)/AVG_SLOPE + 30;
    return Temperate;

When the reference voltage or the chip revision changes, recheck the calibration address and the slope, otherwise the computed temperature carries no meaning.

Corresponding source files: src/main.c, firmware/n32g033_std_periph_driver/inc/n32g033_adc.h

The example wires the watchdog thresholds, the monitored register, and the interrupt together in one configuration, then counts events on the flag in the handler.

Data path: ADC_ConfigAnalogWatchdogThresholds writes the high and low thresholds → ADC_ConfigAnalogWatchdogModeChannel selects DAT0 → ADC_ConfigInt enables ADC_INT_AWD → a result outside the range sets ADC_INT_FLAG_AWDG → ADC_IRQHandler clears the flag and increments gCntAwdg

1. Open the ADC interrupt in the NVIC first. Enabling the vector and enabling the interrupt source are two separate switches, and this fragment handles the former.

    NVIC_InitStructure.NVIC_IRQChannel                   = ADC_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPriority           = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

In a real project, fit NVIC_IRQChannelPriority into the system priority plan and keep the vector name consistent with the startup file.

2. Configure the thresholds and the monitored register, then enable the interrupt. The thresholds are given as 12-bit codes and the monitored object is the conversion data register DAT0.

    ADC_ConfigRegularChannel(ADC_Channel_03_PA3, 1, ADC_SAMP_TIME_72CYCLES);
    
    /*Enable anolog watchdog*/
    ADC_ConfigInt(ADC_INT_AWD, ENABLE);
    ADC_ConfigAnalogWatchdogThresholds(HIGH_THRESHOLD, LOW_THRESHOLD);
    /*Enable DAT0 watchdog*/
    ADC_ConfigAnalogWatchdogModeChannel(ADC_ANALOG_WTDG_DAT0);
    /* Anolog watchdog monitor DAT0 enable */
    ADC_Enable(ENABLE);

Rewrite the thresholds for the allowed range of the signal under test, and if you monitor another data register, change the ADC_ANALOG_WTDG_DATx value here.

3. The handler branches on the flag. Only when the watchdog flag is set does it clear the flag and count.

void ADC_IRQHandler(void)
{
   if(ADC_GetIntStatus(ADC_INT_FLAG_AWDG) != RESET)
   {
       ADC_ClearIntPendingBit(ADC_INT_FLAG_AWDG);
       gCntAwdg++;
   }
}

gCntAwdg is a file-static variable, so watch it according to its declaration in the source; when you add other interrupt sources, keep the flag clear inside the branch.

Corresponding source files: src/main.c, src/n32g033_it.c, firmware/n32g033_std_periph_driver/inc/n32g033_adc.h

The example routes an EXTI line event to the ADC trigger and converts two channels in sequence within one trigger.

Data path: GPIO_Configuration sets PA0 and PA1 as analog inputs and PA4 as a pull-up input → EXTI_Configuration connects PA4 to an EXTI line → AFIO_ConfigADCExternalTrigRemap selects the trigger line → ADC_ConfigRegularChannel orders the two channels → the main loop waits for ADC_FLAG_ENDC → ADC_GetGroupConvDat returns both results

1. Switch the trigger source to the EXTI line and remap it to a specific line number. The structure member selects the trigger source, and the AFIO remap function decides which EXTI line feeds it.

    ADC_InitStruct(&ADC_InitStructure);
    /* ADC configuration ------------------------------------------------------*/
    ADC_InitStructure.ContinueConvEn = DISABLE;
    /* Initialize the ExtTrigSelect1 member */
    ADC_InitStructure.ExtTrigSelect1 = ADC_EXT_TRIGCONV_EXT_LINE;
    /* Initialize the DatAlign member */
    ADC_InitStructure.DatAlign       = ADC_DAT_ALIGN_R;
    /* Initialize the phase mode member */
    ADC_InitStructure.PhsMode        = ADC_PHS_TRG_MODE_SINGLE ;
    /* Initialize the phase 1 channel number member */
    ADC_InitStructure.Phs1ChNumber   = 2U;

    //select EXTI1 as adc triagger source
    AFIO_ConfigADCExternalTrigRemap(AFIO_ADC_TRIG_EXTI_1);

To use another trigger line, change both the AFIO_ADC_TRIG_EXTI_x value and the EXTI line number of the external pin so that the two match.

2. Two channels are ranked inside one phase, and the readout follows the register order. Phase 1 carries two channels and the results land in data registers 0 and 1.

    //ExtTrigSelect1 exti
    ADC_ConfigRegularChannel(ADC_Channel_00_PA0, 1, ADC_SAMP_TIME_72CYCLES);
    ADC_ConfigRegularChannel(ADC_Channel_01_PA1, 2, ADC_SAMP_TIME_72CYCLES);

        while(ADC_GetFlagStatus(ADC_FLAG_ENDC)==0){
        }
        ADC_ClearFlag(ADC_FLAG_ENDC);
        ADC_ClearFlag(ADC_FLAG_STR);
        ADCConvertedValue[0] =ADC_GetGroupConvDat(0);
        ADCConvertedValue[1] =ADC_GetGroupConvDat(1);

The rank maps one-to-one onto the register index, so adding or removing a channel means changing both Phs1ChNumber and the readout indices.

3. Keep the EXTI pin source and line number consistent with the ADC side. The source configuration connects PA4 to pin source 4 while the structure configures EXTI line 1, and the comment above it reads “EXTI line10 configuration”.

    GPIO_ConfigEXTILine(GPIOA_PORT_SOURCE,GPIO_PIN_SOURCE4);
    /* EXTI line10 configuration -----------------------------------------------*/
    EXTI_InitStructure.EXTI_Mode    = EXTI_Mode_Event;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
    EXTI_InitStructure.EXTI_Line    = EXTI_LINE1;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_InitPeripheral(&EXTI_InitStructure);

As the source stands, the line that takes effect is EXTI_LINE1; to use the line belonging to PA4 instead, set the pin source and the line number to the same index.

Corresponding source files: src/main.c, firmware/n32g033_std_periph_driver/inc/n32g033_adc.h

The example turns the four compare outputs of TIM1 into trigger sources, samples five channels through four phases, and lets the interrupt move the results out.

Data path: TIM_Configuration sets up the four PWM channels → the four compare events trigger phases 1 to 4 → the five channels ordered by ADC_ConfigRegularChannel convert in turn → phase 4 sets ADC_INT_FLAG_PHS4 → ADC_IRQHandler moves five results into ADCConvertedValue with ADC_GetGroupConvDat

1. Four-phase mode gives each phase its own trigger source and channel count. Phase 1 triggers two channels and the other three one each, with the trigger sources coming from the four compare channels of TIM1.

    /* Initialize the ExtTrigSelect1 member */
    ADC_InitStructure.ExtTrigSelect1 = ADC_EXT_TRIGCONV_T1_CC1;
    /* Initialize the ExtTrigSelect2 member */
    ADC_InitStructure.ExtTrigSelect2 = ADC_EXT_TRIGCONV_T1_CC2;
    /* Initialize the ExtTrigSelect3 member */
    ADC_InitStructure.ExtTrigSelect3 = ADC_EXT_TRIGCONV_T1_CC3;
    /* Initialize the ExtTrigSelect4 member */
    ADC_InitStructure.ExtTrigSelect4 = ADC_EXT_TRIGCONV_T1_CC4;
    /* Initialize the DatAlign member */
    ADC_InitStructure.DatAlign       = ADC_DAT_ALIGN_R;
    /* Initialize the phase mode member */
    ADC_InitStructure.PhsMode        = ADC_PHS_TRG_MODE_FOUR ;
    /* Initialize the phase 1 channel number member */
    ADC_InitStructure.Phs1ChNumber   = 2U;

    //PH1
    ADC_ConfigRegularChannel(ADC_Channel_01_PA1,1,ADC_SAMP_TIME_4CYCLES);
    ADC_ConfigRegularChannel(ADC_Channel_04_PA4,2,ADC_SAMP_TIME_4CYCLES);
    //PH2
    ADC_ConfigRegularChannel(ADC_Channel_00_PA0,3,ADC_SAMP_TIME_4CYCLES);
    //PH3
    ADC_ConfigRegularChannel(ADC_Channel_08_PB0,4,ADC_SAMP_TIME_4CYCLES);
    //PH4
    ADC_ConfigRegularChannel(ADC_Channel_09_PB1,5,ADC_SAMP_TIME_4CYCLES);

The channel count of each phase must match Phs1ChNumber to Phs4ChNumber above, so change both places together.

2. The five sampling pins and the four PWM pins take separate configurations. The sampling pins use analog mode, while the PWM pins use alternate-function push-pull, each with its own alternate-function index.

    /* Configure PB3-CH1 as alternate function push-pull mode ----*/
    GPIO_InitStructure.Pin       = GPIO_PIN_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_MODE_AF_PP;
    GPIO_InitStructure.GPIO_Alternate =GPIO_AF1;
    GPIO_InitPeripheral(GPIOB, &GPIO_InitStructure);
    
    /* Configure PB4-CH2 as alternate function push-pull mode ----*/
    GPIO_InitStructure.Pin       = GPIO_PIN_4;
    GPIO_InitStructure.GPIO_Mode = GPIO_MODE_AF_PP;
    GPIO_InitStructure.GPIO_Alternate =GPIO_AF7;
    GPIO_InitPeripheral(GPIOB, &GPIO_InitStructure);

The alternate-function index and the pin are tied together, so consult the alternate-function mapping table in the user manual when you move a channel to another pin.

3. The TIM1 time base sets the trigger rate and the four pulses set the trigger instants. In center-aligned mode the counter runs up and down, and the four compare values trigger the four phases in turn.

    PrescalerValue = (uint32_t)(SystemCoreClock / 160000) - 1;
    /* Time base configuration */
    TIM_InitTimBaseStruct(&TIM_TimeBaseStructure);
    TIM_TimeBaseStructure.Period    = 1600;
    TIM_TimeBaseStructure.Prescaler = PrescalerValue;
    TIM_TimeBaseStructure.ClkDiv    = TIM_CLK_DIV1;
    TIM_TimeBaseStructure.CounterMode   = TIM_CNT_MODE_CENTER_ALIGN3;
    TIM_InitTimeBase(TIM1, &TIM_TimeBaseStructure);

    /* PWM1 Mode configuration: Channel1 */
    TIM_InitOcStruct(&TIM_OCInitStructure);
    TIM_OCInitStructure.OCMode      = TIM_OCMODE_PWM1;
    TIM_OCInitStructure.OutputState = TIM_OUTPUT_STATE_ENABLE;
    TIM_OCInitStructure.Pulse       = Pluse1_Val;
    TIM_OCInitStructure.OCPolarity  = TIM_OC_POLARITY_HIGH;
    TIM_InitOc1(TIM1, &TIM_OCInitStructure);
    TIM_ConfigOc1Preload(TIM1, TIM_OC_PRE_LOAD_ENABLE);

PrescalerValue and Period together set the phase group duration, and the order of the four pulse values sets the order of the phases.

4. The handler moves the five results in order and toggles one pin. It runs only when the phase-4 flag is set, and rewinds the index after 28 buffer entries.

void ADC_IRQHandler(void)
{
    if(ADC_GetIntStatus(ADC_INT_FLAG_PHS4) != RESET)
    {
       ADC_ClearIntPendingBit(ADC_INT_FLAG_PHS4);
       GPIOB->PBSC = GPIO_PIN_7;
       //Get PA1, PA4, PA0, PB0, PB1 conversion value
       ADCConvertedValue[index++] = ADC_GetGroupConvDat(0);
       ADCConvertedValue[index++] = ADC_GetGroupConvDat(1);
       ADCConvertedValue[index++] = ADC_GetGroupConvDat(2);
       ADCConvertedValue[index++] = ADC_GetGroupConvDat(3);
       ADCConvertedValue[index++] = ADC_GetGroupConvDat(4);
       if(index >= 28)
       {
          index = 0;
       }
       GPIOB->PBC = GPIO_PIN_7;
    }

}

Change the buffer size, the rewind threshold, and the number of registers read together; the handler writes the registers directly to keep it short.

Corresponding source files: src/main.c, src/n32g033_it.c, firmware/n32g033_std_periph_driver/inc/n32g033_adc.h