• 国民技术N32G031系列单片机的AD采样

    用过一段时间国民技术N32G031系列单片机，编程模式几乎类同STM32系列（另外一个国产32位单片机品牌兆易创新好像也是仿STM32的编程模式，看来STM32的确是一款极其优秀的产品），但是价格实惠，功能也很齐全，软件支持包在官网都可以下载，所以总体感觉还是可以的，只是稳定性还有待验证。

    最近在用N32G031做一款电源产品软件时发现了一个情况，这种情况以前几乎都是不关注的，就是AD转换的时间。我有10个通道要进行AD转换，每个通道采样64次，我的AD初始化函数和采样函数如下：

    初始化函数：

    1. /**
    2. *@name: ADC_Initial
    3. *@description: ADC initialization
    4. *@params: none
    5. *@return: none
    6. */
    7. void ADC_Initial(void)
    8. {
    9.     ADC_InitType ADC_InitStructure;
    10.  
    11.     ADC_GPIO_Configuration();
    12.  
    13.     /* ADC configuration ------------------------------------------------------*/
    14.     ADC_InitStructure.MultiChEn      = DISABLE;
    15.     ADC_InitStructure.ContinueConvEn = DISABLE;
    16.     ADC_InitStructure.ExtTrigSelect  = ADC_EXT_TRIGCONV_NONE;
    17.     ADC_InitStructure.DatAlign       = ADC_DAT_ALIGN_R;
    18.     ADC_InitStructure.ChsNumber      = 1;
    19.     ADC_Init(ADC, &ADC_InitStructure);
    20.     //ADC1 regular channel13 configuration
    21.     //ADC_ConfigRegularChannel(ADC, ADC_CH_13_PC2, 1, ADC_SAMP_TIME_55CYCLES5);
    22.     //Enable ADC DMA
    23.     //ADC_EnableDMA(ADC, ENABLE);
    24.  
    25.     //Enable ADC
    26.     ADC_Enable(ADC, ENABLE);
    27.  
    28.     // Check ADC Ready
    29.     while (ADC_GetFlagStatusNew(ADC, ADC_FLAG_RDY) == RESET);
    30.     while (ADC_GetFlagStatusNew(ADC, ADC_FLAG_PD_RDY));
    31.  
    32.     channel = IS1;
    33. }

    获取每次AD转换值函数：这里设置每次采样的时钟周期是56

    1. /**
    2. *@name: ADC_GetData
    3. *@description: get the converted AD value
    4. *@params: ADC_Channel: channel to be converted
    5. *@return: AD value we need
    6. */
    7. uint16_t ADC_GetData(uint8_t ADC_Channel)
    8. {
    9.     uint16_t data;
    10.  
    11.     ADC_ConfigRegularChannel(ADC, ADC_Channel, 1, ADC_SAMP_TIME_56CYCLES5);
    12.     // Start ADC Software Conversion
    13.     ADC_EnableSoftwareStartConv(ADC, ENABLE); //start software conversion
    14.     while (ADC_GetFlagStatus(ADC, ADC_FLAG_ENDC) == 0) //wait for the conversion to be finished
    15.     {
    16.  
    17.     }
    18.     ADC_ClearFlag(ADC, ADC_FLAG_ENDC); //clear the end conversion flag
    19.     ADC_ClearFlag(ADC, ADC_FLAG_STR);
    20.     data = ADC_GetDat(ADC);
    21.  
    22.     return (data);
    23. }

    应用程序采样所有通道AD值的函数（共10个通道，每个通道采样64次）：

    1. /**
    2. *@name: ADC_Sample
    3. *@description: sample all the channels
    4. 			   According to the ADC sampling clock(1 MHz) and the cycles(56 cycles) one sampling operation needs,
    5.                here we need to sample 10 channels, and each channel has to be sampled 64 times. If the ADC sampling
    6.                clock is 1 MHz, the total time it takes to sample all the 10 channels is 64*10*56/1M = 0.03584(S)
    7. 			   about 36 milli-seconds.
    8. *@params: none
    9. *@return: none
    10. */
    11. void ADC_Sample(void)
    12. {
    13.     uint16_t ad_data = 0;
    14.  
    15.     if (!sample_flag)
    16.     {
    17.         if (sample_cnt == 0) //the first value should be discarded when switching channel
    18.         {
    19.             sample_cnt = 1;
    20.             return;
    21.         }
    22.         switch (channel)
    23.         {
    24.             case IS1:
    25.             {
    26.                 ad_data = ADC_GetData(IS1);
    27.                 is1_sample_sum += ad_data;
    28.                 if (++sample_cnt > SAMPLE_COUNT)
    29.                 {
    30.                     sample_cnt = 0;
    31.                     is1_sample_value_filt = is1_sample_sum >> 6; //get the average AD value
    32.                     is1_sample_sum = 0;
    33.                     channel = IS2;              //next channel
    34.                 }
    35.                 break;
    36.             }
    37.             case IS2:
    38.             {
    39.                 ad_data = ADC_GetData(IS2);
    40.                 is2_sample_sum += ad_data;
    41.                 if (++sample_cnt > SAMPLE_COUNT)
    42.                 {
    43.                     sample_cnt = 0;
    44.                     is2_sample_value_filt = is2_sample_sum >> 6;
    45.                     is2_sample_sum = 0;
    46.                     channel = IS3;
    47.                 }
    48.                 break;
    49.             }
    50.             case IS3:
    51.             {
    52.                 ad_data = ADC_GetData(IS3);
    53.                 is3_sample_sum += ad_data;
    54.                 if (++sample_cnt > SAMPLE_COUNT)
    55.                 {
    56.                     sample_cnt = 0;
    57.                     is3_sample_value_filt = is3_sample_sum >> 6;
    58.                     is3_sample_sum = 0;
    59.                     channel = IS4;
    60.                 }
    61.                 break;
    62.             }
    63.             case IS4:
    64.             {
    65.                 ad_data = ADC_GetData(IS4);
    66.                 is4_sample_sum += ad_data;
    67.                 if (++sample_cnt > SAMPLE_COUNT)
    68.                 {
    69.                     sample_cnt = 0;
    70.                     is4_sample_value_filt = is4_sample_sum >> 6;
    71.                     is4_sample_sum = 0;
    72.                     channel = IS5;
    73.                 }
    74.                 break;
    75.             }
    76.             case IS5:
    77.             {
    78.                 ad_data = ADC_GetData(IS5);
    79.                 is5_sample_sum += ad_data;
    80.                 if (++sample_cnt > SAMPLE_COUNT)
    81.                 {
    82.                     sample_cnt = 0;
    83.                     is5_sample_value_filt = is5_sample_sum >> 6;
    84.                     is5_sample_sum = 0;
    85.                     channel = IS6;
    86.                 }
    87.                 break;
    88.             }
    89.             case IS6:
    90.             {
    91.                 ad_data = ADC_GetData(IS6);
    92.                 is6_sample_sum += ad_data;
    93.                 if (++sample_cnt > SAMPLE_COUNT)
    94.                 {
    95.                     sample_cnt = 0;
    96.                     is6_sample_value_filt = is6_sample_sum >> 6;
    97.                     is6_sample_sum = 0;
    98.                     channel = IS7;
    99.                 }
    100.                 break;
    101.             }
    102.             case IS7:
    103.             {
    104.                 ad_data = ADC_GetData(IS7);
    105.                 is7_sample_sum += ad_data;
    106.                 if (++sample_cnt > SAMPLE_COUNT)
    107.                 {
    108.                     sample_cnt = 0;
    109.                     is7_sample_value_filt = is7_sample_sum >> 6;
    110.                     is7_sample_sum = 0;
    111.                     channel = IS8;
    112.                 }
    113.                 break;
    114.             }
    115.             case IS8:
    116.             {
    117.                 ad_data = ADC_GetData(IS8);
    118.                 is8_sample_sum += ad_data;
    119.                 if (++sample_cnt > SAMPLE_COUNT)
    120.                 {
    121.                     sample_cnt = 0;
    122.                     is8_sample_value_filt = is8_sample_sum >> 6;
    123.                     is8_sample_sum = 0;
    124.                     channel = TEMP;
    125.                 }
    126.                 break;
    127.             }
    128.             case TEMP:
    129.             {
    130.                 ad_data = ADC_GetData(TEMP);
    131.                 otp_sample_sum += ad_data;
    132.                 if (++sample_cnt > SAMPLE_COUNT)
    133.                 {
    134.                     sample_cnt = 0;
    135.                     otp_ad_value = otp_sample_sum >> 6;
    136.                     otp_sample_sum = 0;
    137.                     channel = VOS;
    138.                 }
    139.                 break;
    140.             }
    141.             case VOS:
    142.             {
    143.                 ad_data = ADC_GetData(VOS);
    144.                 vos_sample_sum += ad_data;
    145.                 if (++sample_cnt > SAMPLE_COUNT)
    146.                 {
    147.                     sample_cnt = 0;
    148.                     vdc_ad_value = vos_sample_sum >> 6;
    149.                     vos_sample_sum = 0;
    150.                     sample_flag = 1;//sampleing finished flag
    151.                     channel = IS1;
    152.                 }
    153.                 break;
    154.             }
    155.             default:
    156.             {
    157.                 channel = IS1;
    158.                 sample_cnt = 0;
    159.                 is1_sample_sum = 0;
    160.                 is2_sample_sum = 0;
    161.                 is3_sample_sum = 0;
    162.                 is4_sample_sum = 0;
    163.                 is5_sample_sum = 0;
    164.                 is6_sample_sum = 0;
    165.                 is7_sample_sum = 0;
    166.                 is8_sample_sum = 0;
    167.                 vos_sample_sum = 0;
    168.                 otp_sample_sum = 0;
    169.                 break;
    170.             }
    171.         }
    172.     }
    173. }

    系统时钟及ADC模块的时钟配置函数（其中配置AD模块的1 MHz时钟是必须的）：

    1. /**
    2.  * @brief  Configures the different system clocks.
    3.  */
    4. static void RCC_Configuration(void)
    5. {
    6.     // PCLK1 = HCLK/4, configure the clock of APB1 and times uses the prescaled APB1
    7.     RCC_ConfigPclk1(RCC_HCLK_DIV4);
    8.  
    9.     // Enable peripheral clocks ------------------------------------------------
    10.     // Enable TIM1 clocks
    11.     //RCC_EnableAPB2PeriphClk(RCC_APB2_PERIPH_TIM1, ENABLE);
    12.     //Enable DMA clocks
    13.     //RCC_EnableAHBPeriphClk(RCC_AHB_PERIPH_DMA, ENABLE);
    14.  
    15.     //Enable GPIO clocks
    16.     RCC_EnableAPB2PeriphClk(RCC_APB2_PERIPH_GPIOA | RCC_APB2_PERIPH_GPIOB | RCC_APB2_PERIPH_GPIOC | RCC_APB2_PERIPH_GPIOF, ENABLE);
    17.     //Enable ADC clocks
    18.     RCC_EnableAHBPeriphClk(RCC_AHB_PERIPH_ADC, ENABLE);
    19.  
    20.     //RCC_ADCHCLK_DIV16
    21.     ADC_ConfigClk(ADC_CTRL3_CKMOD_AHB, RCC_ADCHCLK_DIV16);
    22.  
    23.     //enable ADC1M clock
    24.     //RCC_EnableHsi(ENABLE);
    25.     RCC_ConfigAdc1mClk(RCC_ADC1MCLK_SRC_HSE, RCC_ADC1MCLK_DIV8);
    26.  
    27.     //enable USART1 clock
    28.     RCC_EnableAPB2PeriphClk(USARTy_GPIO_CLK, ENABLE);
    29.     RCC_EnableAPB2PeriphClk(USARTy_CLK, ENABLE);
    30.  
    31.     //TIM3 and TIM clock enable
    32.     RCC_EnableAPB1PeriphClk(RCC_APB1_PERIPH_TIM3, ENABLE);
    33.     //RCC_EnableAPB1PeriphClk(RCC_APB1_PERIPH_TIM6, ENABLE);
    34. }

    AD检测滤波函数（每20毫秒设置相关警告位，主要是输入电压是否欠压或者过压）：

    1. /**
    2. *@name: ADC_Status_Check
    3. *@description: ADC filter, the input voltage and OTP check
    4. *@params: none
    5. *@return: none
    6. */
    7. static void ADC_Status_Check(void)
    8. {
    9.     if (vdc_ad_value <= VDC_UV_OFF_AD) //DC under and over voltage filter
    10.         vdc_uvp_off++;
    11.     if (vdc_ad_value >= VDC_UV_ON_AD)
    12.         vdc_uvp_recovered++;
    13.     if (vdc_ad_value >= VDC_OV_OFF_AD)
    14.         vdc_ovp_off++;
    15.     if (vdc_ad_value <= VDC_OV_ON_AD)
    16.         vdc_ovp_recovered++;
    17.  
    18.     if (otp_ad_value >= OTP_OFF_AD) //OTP
    19.         otp_off++;
    20.     if (otp_ad_value <= OTP_RECOVER_AD)
    21.         otp_recovered++;
    22.  
    23.     if (adc_filter_cnt >= IO_FILTER_CNT)
    24.     {
    25.         if (vdc_uvp_off >= IO_FILTER_VALID_CNT && AlarmStatus.alarm.VDC_UVP == 0) //VDC
    26.             AlarmStatus.alarm.VDC_UVP = 1;
    27.         if (vdc_uvp_recovered >= IO_FILTER_VALID_CNT && AlarmStatus.alarm.VDC_UVP == 1)
    28.             AlarmStatus.alarm.VDC_UVP = 0;
    29.  
    30.         if (vdc_ovp_off >= IO_FILTER_VALID_CNT && AlarmStatus.alarm.VDC_OVP == 0)
    31.             AlarmStatus.alarm.VDC_OVP = 1;
    32.         if (vdc_ovp_recovered >= IO_FILTER_VALID_CNT && AlarmStatus.alarm.VDC_OVP == 1)
    33.             AlarmStatus.alarm.VDC_OVP = 0;
    34.  
    35.         if (otp_off >= IO_FILTER_VALID_CNT && AlarmStatus.alarm.OTP == 0) //OTP
    36.             AlarmStatus.alarm.OTP = 1;
    37.         if (otp_recovered >= IO_FILTER_VALID_CNT && AlarmStatus.alarm.OTP == 1)
    38.             AlarmStatus.alarm.OTP = 0;
    39.  
    40.         if (AlarmStatus.alarm.VDC_OVP == 0 && AlarmStatus.alarm.VDC_UVP == 0)
    41.         {
    42.             AlarmStatus.alarm.VIN_STATUS_ERR = 0;
    43.         }
    44.         else
    45.         {
    46.             AlarmStatus.alarm.VIN_STATUS_ERR = 1;
    47.         }
    48.  
    49.         adc_filter_cnt = 0;
    50.         vdc_uvp_off = 0;
    51.         vdc_uvp_recovered = 0;
    52.         vdc_ovp_off = 0;
    53.         vdc_ovp_recovered = 0;
    54.         otp_off = 0;
    55.         otp_recovered = 0;
    56.     }
    57.     else
    58.     {
    59.         adc_filter_cnt++;
    60.     }
    61. }

    根据手册说明及咨询芯片厂的相关技术人员，ADC模块的采样时钟频率固定是1MHz，每次采样的时间软件设置为56个时钟周期（这个可以修改），另外每次AD转换还额外需要12.5个时钟周期，所以完成10个通道采样（每个通道采样64次）所需要的总时间是：(56+12.5)*10*64/1000000 = 0.04384秒，差不多就是44毫秒。

    我的程序在做AD检测滤波（非AD转换，对AD转换完成后的平均值再次进行一段时间的滤波处理，避免电源输出产生误动作）时只有20毫秒，并且初始时所有警告标志位都是清零的，尤其是输入电压欠压和过压标志，所以在电源开机时会有一个20毫秒输出正常打开，然后又有一个40毫秒左右的关闭，最后又是完全正常的现象。结合这个现象和AD转换10个通道所需的总时间，那20毫秒就是AD滤波的时间，在此期间由于所有标志位都清零，电源输出正常打开，20毫秒滤波过后，由于此时AD转换还未完成（需要40毫秒左右），所以输入电压欠压警告位被置位（AD检测未完成，AD平均值为0），结果输出关闭，只有等到一轮AD检测完全完成且AD滤波也检测到完整的AD值后警告标志位才会清除，之后输出就一直正常了。

    如果要解决这个问题，可以把AD滤波的时间加长，至少要大于AD转换一轮所需要的时间，或者如果对AD转换精度要求不高的话，可以把采样次数减少或者把每次采样所需要的时钟数设置得小一些。最为直接的做法就是初始将所有警告标志位置1。这样开机时是异常的，只有AD检测结果正常后电源才打开输出。

    在这里我也只是记录下出现问题后要根据现象找出原因，积极思考，再找解决办法就是比较容易些的事情了。

  • 相关阅读:
    GitHub详细教程
    【动手学深度学习PyTorch版】23 深度学习硬件CPU 和 GPU
    数智随行 | 机器学习与图像技术：库存管理的下一个前沿
    Node.js安装记录
    Spring 注入静态@Value值
    基于MATLAB的混沌数字图像加密技术研究与仿真实现
    JavaScript设计模式——命令模式
    Java版Word开发工具Aspose.Words功能解析：在Word（DOCX / DOC）中插入或删除注释
    线程的执行顺序
    Django实战项目-学习任务系统-自定义URL拦截器
  • 原文地址：https://blog.csdn.net/jmmx/article/details/133162417