【沁恒微CH32V307评估板试用体验】基于CH32V307的ADC实验 - RISC-V MCU技术社区 - 电子技术william hill官网 - 广受欢迎的专业电子william hill官网 - 威廉希尔官方网站
分享 收藏 返回

工程认知教育中心的硬件小屋 关注 私信
[文章]

【沁恒微CH32V307评估板试用体验】基于CH32V307的ADC实验

一实验概述
利用CH32V307的12bit ADC制作一个光照强度监测与报警系统，主要的元器件有光敏电阻传感器、OLED屏幕、继电器、蜂鸣器、CH32V307开发板。

二实验原理图

微信图片_20220521164032.jpg 微信图片_20220521164039.jpg
三CH32V307 ADC 外设介绍
    ADC包含两个12位ADC ，最高频率位14MHz(程序设计过程中经常采用8分频)，支持18个通道其中两个位内部信号源，可以实现单次转换、连续转换，通道间自动扫描模式、间断模式、外部触发模式、双重采样等功能。

   这里我们主要采用ADC1的通道1，实现外部光照强度大小的测量，并在OLED模块上显示，以及设计最大报警阈值，通过继电器控制蜂鸣器。四代码实现ADC.c
  1. #include "adc.h"

  3. s16 Calibrattion_Val = 0;//校准值
  4. void MX_ADC_Init(void)
  5. {
  6.     ADC_InitTypeDef hadc1;//ADC 句柄
  7.     GPIO_InitTypeDef GPIO_Initure;//GPIO 句柄

  9.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1|RCC_APB2Periph_GPIOA, ENABLE);
  10.     //开启ADC1 GPIOA的时钟
  11.     RCC_ADCCLKConfig(RCC_PCLK2_Div8);//ADC 频率设置

  13.     GPIO_Initure.GPIO_Pin=GPIO_Pin_0;
  14.     GPIO_Initure.GPIO_Mode=GPIO_Mode_AIN;//选择模拟输入
  15.     GPIO_Init(GPIOA, &GPIO_Initure);


  18.     hadc1.ADC_Mode=ADC_Mode_Independent;//配置ADC位独立模式
  19.     hadc1.ADC_ScanConvMode=DISABLE;//不选择扫描模式
  20.     hadc1.ADC_ContinuousConvMode=ENABLE;//使能连续转换模式
  21.     hadc1.ADC_DataAlign=ADC_DataAlign_Right;
  22.     hadc1.ADC_ExternalTrigConv=ADC_ExternalTrigConv_None;
  23.     hadc1.ADC_NbrOfChannel=1;
  24.     ADC_Init(ADC1, &hadc1);

  26.     ADC_Cmd(ADC1, ENABLE);

  28.     ADC_BufferCmd(ADC1, DISABLE);                               //disable buffer
  29.          //测量ADC校准数据，也可以不使用。
  30.          ADC_ResetCalibration(ADC1);
  31.          while(ADC_GetResetCalibrationStatus(ADC1));
  32.          ADC_StartCalibration(ADC1);
  33.          while(ADC_GetCalibrationStatus(ADC1));
  34.          Calibrattion_Val = Get_CalibrationValue(ADC1);

  36.          ADC_BufferCmd(ADC1, ENABLE);                                //enable buffer


  39. }




  44. u16 Get_ADC_Val(u8 ch)
  45. {
  46.    u16 val;

  48.    ADC_RegularChannelConfig(ADC1, ch, 1, ADC_SampleTime_239Cycles5 );
  49.    ADC_SoftwareStartConvCmd(ADC1, ENABLE);

  51.    while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC ));
  52.    val = ADC_GetConversionValue(ADC1);

  54.    return val;
  55. }

OLED.c 这里我们常采用软件SPI实现屏幕显示
  1. #include "oled.h"
  2. #include "oledfont.h"

  4. u8 OLED_GRAM[144][8];

  6. //反显函数
  7. void OLED_ColorTurn(u8 i)
  8. {
  9.     if(i==0)
  10.         {
  11.             OLED_WR_Byte(0xA6,OLED_CMD);//正常显示
  12.         }
  13.     if(i==1)
  14.         {
  15.             OLED_WR_Byte(0xA7,OLED_CMD);//反色显示
  16.         }
  17. }

  19. //屏幕旋转180度
  20. void OLED_DisplayTurn(u8 i)
  21. {
  22.     if(i==0)
  23.         {
  24.             OLED_WR_Byte(0xC8,OLED_CMD);//正常显示
  25.             OLED_WR_Byte(0xA1,OLED_CMD);
  26.         }
  27.     if(i==1)
  28.         {
  29.             OLED_WR_Byte(0xC0,OLED_CMD);//反转显示
  30.             OLED_WR_Byte(0xA0,OLED_CMD);
  31.         }
  32. }


  35. void OLED_WR_Byte(u8 dat,u8 cmd)
  36. {
  37.     u8 i;
  38.     if(cmd)
  39.       OLED_DC_Set();
  40.     else
  41.       OLED_DC_Clr();
  42.     OLED_CS_Clr();
  43.     for(i=0;i<8;i++)
  44.     {
  45.         OLED_SCLK_Clr();
  46.         if(dat&0x80)
  47.            OLED_SDIN_Set();
  48.         else
  49.            OLED_SDIN_Clr();
  50.         OLED_SCLK_Set();
  51.         dat<<=1;
  52.     }
  53.     OLED_CS_Set();
  54.     OLED_DC_Set();
  55. }

  57. //开启OLED显示
  58. void OLED_DisPlay_On(void)
  59. {
  60.     OLED_WR_Byte(0x8D,OLED_CMD);//电荷泵使能
  61.     OLED_WR_Byte(0x14,OLED_CMD);//开启电荷泵
  62.     OLED_WR_Byte(0xAF,OLED_CMD);//点亮屏幕
  63. }

  65. //关闭OLED显示
  66. void OLED_DisPlay_Off(void)
  67. {
  68.     OLED_WR_Byte(0x8D,OLED_CMD);//电荷泵使能
  69.     OLED_WR_Byte(0x10,OLED_CMD);//关闭电荷泵
  70.     OLED_WR_Byte(0xAF,OLED_CMD);//关闭屏幕
  71. }

  73. //更新显存到OLED
  74. void OLED_Refresh(void)
  75. {
  76.     u8 i,n;
  77.     for(i=0;i<8;i++)
  78.     {
  79.        OLED_WR_Byte(0xb0+i,OLED_CMD); //设置行起始地址
  80.        OLED_WR_Byte(0x00,OLED_CMD);   //设置低列起始地址
  81.        OLED_WR_Byte(0x10,OLED_CMD);   //设置高列起始地址
  82.        for(n=0;n<128;n++)
  83.          OLED_WR_Byte(OLED_GRAM[n][i],OLED_DATA);
  84.   }
  85. }
  86. //清屏函数
  87. void OLED_Clear(void)
  88. {
  89.     u8 i,n;
  90.     for(i=0;i<8;i++)
  91.     {
  92.        for(n=0;n<128;n++)
  93.             {
  94.              OLED_GRAM[n][i]=0;//清除所有数据
  95.             }
  96.   }
  97.     OLED_Refresh();//更新显示
  98. }

  100. //画点
  101. //x:0~127
  102. //y:0~63
  103. void OLED_DrawPoint(u8 x,u8 y)
  104. {
  105.     u8 i,m,n;
  106.     i=y/8;
  107.     m=y%8;
  108.     n=1<
  109.     OLED_GRAM[x][i]|=n;
  110. }

  112. //清除一个点
  113. //x:0~127
  114. //y:0~63
  115. void OLED_ClearPoint(u8 x,u8 y)
  116. {
  117.     u8 i,m,n;
  118.     i=y/8;
  119.     m=y%8;
  120.     n=1<
  121.     OLED_GRAM[x][i]=~OLED_GRAM[x][i];
  122.     OLED_GRAM[x][i]|=n;
  123.     OLED_GRAM[x][i]=~OLED_GRAM[x][i];
  124. }


  127. //画线
  128. //x:0~128
  129. //y:0~64
  130. void OLED_DrawLine(u8 x1,u8 y1,u8 x2,u8 y2)
  131. {
  132.     u8 i,k,k1,k2;
  133.     if((x1<0)||(x2>128)||(y1<0)||(y2>64)||(x1>x2)||(y1>y2))return;
  134.     if(x1==x2)    //画竖线
  135.     {
  136.             for(i=0;i<(y2-y1);i++)
  137.             {
  138.                 OLED_DrawPoint(x1,y1+i);
  139.             }
  140.   }
  141.     else if(y1==y2)   //画横线
  142.     {
  143.             for(i=0;i<(x2-x1);i++)
  144.             {
  145.                 OLED_DrawPoint(x1+i,y1);
  146.             }
  147.   }
  148.     else      //画斜线
  149.     {
  150.         k1=y2-y1;
  151.         k2=x2-x1;
  152.         k=k1*10/k2;
  153.         for(i=0;i<(x2-x1);i++)
  154.             {
  155.               OLED_DrawPoint(x1+i,y1+i*k/10);
  156.             }
  157.     }
  158. }
  159. //x,y:圆心坐标
  160. //r:圆的半径
  161. void OLED_DrawCircle(u8 x,u8 y,u8 r)
  162. {
  163.     int a, b,num;
  164.     a = 0;
  165.     b = r;
  166.     while(2 * b * b >= r * r)
  167.     {
  168.         OLED_DrawPoint(x + a, y - b);
  169.         OLED_DrawPoint(x - a, y - b);
  170.         OLED_DrawPoint(x - a, y + b);
  171.         OLED_DrawPoint(x + a, y + b);

  173.         OLED_DrawPoint(x + b, y + a);
  174.         OLED_DrawPoint(x + b, y - a);
  175.         OLED_DrawPoint(x - b, y - a);
  176.         OLED_DrawPoint(x - b, y + a);

  178.         a++;
  179.         num = (a * a + b * b) - r*r;//计算画的点离圆心的距离
  180.         if(num > 0)
  181.         {
  182.             b--;
  183.             a--;
  184.         }
  185.     }
  186. }



  190. //在指定位置显示一个字符,包括部分字符
  191. //x:0~127
  192. //y:0~63
  193. //size:选择字体 12/16/24
  194. //取模方式 逐列式
  195. void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size1)
  196. {
  197.     u8 i,m,temp,size2,chr1;
  198.     u8 y0=y;
  199.     size2=(size1/8+((size1%8)?1:0))*(size1/2);  //得到字体一个字符对应点阵集所占的字节数
  200.     chr1=chr-' ';  //计算偏移后的值
  201.     for(i=0;i
  202.     {
  203.         if(size1==12)
  204.         {temp=asc2_1206[chr1][i];} //调用1206字体
  205.         else if(size1==16)
  206.         {temp=asc2_1608[chr1][i];} //调用1608字体
  207.         else if(size1==24)
  208.         {temp=asc2_2412[chr1][i];} //调用2412字体
  209.         else return;
  210.                 for(m=0;m<8;m++)           //写入数据
  211.                 {
  212.                     if(temp&0x80)OLED_DrawPoint(x,y);
  213.                     else OLED_ClearPoint(x,y);
  214.                     temp<<=1;
  215.                     y++;
  216.                     if((y-y0)==size1)
  217.                     {
  218.                         y=y0;
  219.                         x++;
  220.                         break;
  221.           }
  222.                 }
  223.   }
  224. }


  227. //显示字符串
  228. //x,y:起点坐标
  229. //size1:字体大小
  230. //*chr:字符串起始地址
  231. void OLED_ShowString(u8 x,u8 y,u8 *chr,u8 size1)
  232. {
  233.     while((*chr>=' ')&&(*chr<='~'))//判断是不是非法字符!
  234.     {
  235.         OLED_ShowChar(x,y,*chr,size1);
  236.         x+=size1/2;
  237.         if(x>128-size1)  //换行
  238.         {
  239.             x=0;
  240.             y+=2;
  241.     }
  242.         chr++;
  243.   }
  244. }

  246. //m^n
  247. u32 OLED_Pow(u8 m,u8 n)
  248. {
  249.     u32 result=1;
  250.     while(n--)
  251.     {
  252.       result*=m;
  253.     }
  254.     return result;
  255. }

  257. ////显示2个数字
  258. ////x,y :起点坐标
  259. ////len :数字的位数
  260. ////size:字体大小
  261. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size1)
  262. {
  263.     u8 t,temp;
  264.     for(t=0;t
  265.     {
  266.         temp=(num/OLED_Pow(10,len-t-1))%10;
  267.             if(temp==0)
  268.             {
  269.                 OLED_ShowChar(x+(size1/2)*t,y,'0',size1);
  270.       }
  271.             else
  272.             {
  273.               OLED_ShowChar(x+(size1/2)*t,y,temp+'0',size1);
  274.             }
  275.   }
  276. }

  278. //显示汉字
  279. //x,y:起点坐标
  280. //num:汉字对应的序号
  281. //取模方式 列行式
  282. void OLED_ShowChinese(u8 x,u8 y,u8 num,u8 size1)
  283. {
  284.     u8 i,m,n=0,temp,chr1;
  285.     u8 x0=x,y0=y;
  286.     u8 size3=size1/8;
  287.     while(size3--)
  288.     {
  289.         chr1=num*size1/8+n;
  290.         n++;
  291.             for(i=0;i
  292.             {
  293.                 if(size1==16)
  294.                         {temp=Hzk1[chr1][i];}//调用16*16字体
  295.                 else if(size1==24)
  296.                         {temp=Hzk2[chr1][i];}//调用24*24字体
  297.                 else if(size1==32)
  298.                         {temp=Hzk3[chr1][i];}//调用32*32字体
  299.                 else if(size1==64)
  300.                         {temp=Hzk4[chr1][i];}//调用64*64字体
  301.                 else return;

  303.                         for(m=0;m<8;m++)
  304.                             {
  305.                                 if(temp&0x01)OLED_DrawPoint(x,y);
  306.                                 else OLED_ClearPoint(x,y);
  307.                                 temp>>=1;
  308.                                 y++;
  309.                             }
  310.                             x++;
  311.                             if((x-x0)==size1)
  312.                             {x=x0;y0=y0+8;}
  313.                             y=y0;
  314.              }
  315.     }
  316. }

  318. //num 显示汉字的个数
  319. //space 每一遍显示的间隔
  320. void OLED_ScrollDisplay(u8 num,u8 space)
  321. {
  322.     u8 i,n,t=0,m=0,r;
  323.     while(1)
  324.     {
  325.         if(m==0)
  326.         {
  327.         OLED_ShowChinese(128,24,t,16); //写入一个汉字保存在OLED_GRAM[][]数组中
  328.             t++;
  329.         }
  330.         if(t==num)
  331.             {
  332.                 for(r=0;r<16*space;r++)      //显示间隔
  333.                  {
  334.                     for(i=0;i<144;i++)
  335.                         {
  336.                             for(n=0;n<8;n++)
  337.                             {
  338.                                 OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
  339.                             }
  340.                         }
  341.            OLED_Refresh();
  342.                  }
  343.         t=0;
  344.       }
  345.         m++;
  346.         if(m==16){m=0;}
  347.         for(i=0;i<144;i++)   //实现左移
  348.         {
  349.             for(n=0;n<8;n++)
  350.             {
  351.                 OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
  352.             }
  353.         }
  354.         OLED_Refresh();
  355.     }
  356. }

  358. //配置写入数据的起始位置
  359. void OLED_WR_BP(u8 x,u8 y)
  360. {
  361.     OLED_WR_Byte(0xb0+y,OLED_CMD);//设置行起始地址
  362.     OLED_WR_Byte(((x&0xf0)>>4)|0x10,OLED_CMD);
  363.     OLED_WR_Byte((x&0x0f),OLED_CMD);
  364. }

  366. //x0,y0：起点坐标
  367. //x1,y1：终点坐标
  368. //BMP[]：要写入的图片数组
  369. void OLED_ShowPicture(u8 x0,u8 y0,u8 x1,u8 y1,u8 BMP[])
  370. {
  371.     u32 j=0;
  372.     u8 x=0,y=0;
  373.     if(y%8==0)y=0;
  374.     else y+=1;
  375.     for(y=y0;y
  376.      {
  377.          OLED_WR_BP(x0,y);
  378.          for(x=x0;x
  379.          {
  380.              OLED_WR_Byte(BMP[j],OLED_DATA);
  381.              j++;
  382.      }
  383.      }
  384. }
  385. //OLED的初始化
  386. void OLED_Init(void)
  387. {
  388.     GPIO_InitTypeDef  GPIO_InitStructure;

  390.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);    //使能A端口时钟
  391.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5;
  392.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;         //推挽输出
  393.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//速度50MHz
  394.     GPIO_Init(GPIOA, &GPIO_InitStructure);
  395.     GPIO_SetBits(GPIOA,GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5);

  397.     OLED_RST_Clr();//复位
  398.     Delay_Ms(20);
  399.     OLED_RST_Set();

  401.     OLED_WR_Byte(0xAE,OLED_CMD);//--turn off oled panel
  402.     OLED_WR_Byte(0x00,OLED_CMD);//---set low column address
  403.     OLED_WR_Byte(0x10,OLED_CMD);//---set high column address
  404.     OLED_WR_Byte(0x40,OLED_CMD);//--set start line address  Set Mapping RAM Display Start Line (0x00~0x3F)
  405.     OLED_WR_Byte(0x81,OLED_CMD);//--set contrast control register
  406.     OLED_WR_Byte(0xCF,OLED_CMD);// Set SEG Output Current Brightness
  407.     OLED_WR_Byte(0xA1,OLED_CMD);//--Set SEG/Column Mapping     0xa0左右反置 0xa1正常
  408.     OLED_WR_Byte(0xC8,OLED_CMD);//Set COM/Row Scan Direction   0xc0上下反置 0xc8正常
  409.     OLED_WR_Byte(0xA6,OLED_CMD);//--set normal display
  410.     OLED_WR_Byte(0xA8,OLED_CMD);//--set multiplex ratio(1 to 64)
  411.     OLED_WR_Byte(0x3f,OLED_CMD);//--1/64 duty
  412.     OLED_WR_Byte(0xD3,OLED_CMD);//-set display offset   Shift Mapping RAM Counter (0x00~0x3F)
  413.     OLED_WR_Byte(0x00,OLED_CMD);//-not offset
  414.     OLED_WR_Byte(0xd5,OLED_CMD);//--set display clock divide ratio/oscillator frequency
  415.     OLED_WR_Byte(0x80,OLED_CMD);//--set divide ratio, Set Clock as 100 Frames/Sec
  416.     OLED_WR_Byte(0xD9,OLED_CMD);//--set pre-charge period
  417.     OLED_WR_Byte(0xF1,OLED_CMD);//Set Pre-Charge as 15 Clocks & Discharge as 1 Clock
  418.     OLED_WR_Byte(0xDA,OLED_CMD);//--set com pins hardware configuration
  419.     OLED_WR_Byte(0x12,OLED_CMD);
  420.     OLED_WR_Byte(0xDB,OLED_CMD);//--set vcomh
  421.     OLED_WR_Byte(0x40,OLED_CMD);//Set VCOM Deselect Level
  422.     OLED_WR_Byte(0x20,OLED_CMD);//-Set Page Addressing Mode (0x00/0x01/0x02)
  423.     OLED_WR_Byte(0x02,OLED_CMD);//
  424.     OLED_WR_Byte(0x8D,OLED_CMD);//--set Charge Pump enable/disable
  425.     OLED_WR_Byte(0x14,OLED_CMD);//--set(0x10) disable
  426.     OLED_WR_Byte(0xA4,OLED_CMD);// Disable Entire Display On (0xa4/0xa5)
  427.     OLED_WR_Byte(0xA6,OLED_CMD);// Disable Inverse Display On (0xa6/a7)
  428.     OLED_WR_Byte(0xAF,OLED_CMD);
  429.     OLED_Clear();
  430. }

main.c
  1. #include "debug.h"
  2. #include "gpio.h"
  3. #include "oled.h"
  4. #include "adc.h"
  5. /* Global typedef */
  6. char tjcstr[80];
  7. uint16_t adc_value;
  8. /* Global define */

  10. /* Global Variable */


  13. /*********************************************************************
  14. * @fn      main
  15. *
  16. * [url=home.php?mod=space&uid=2666770]@Brief[/url]   Main program.
  17. *
  18. * [url=home.php?mod=space&uid=1141835]@Return[/url]  none
  19. */
  20. int main(void)
  21. {
  22.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  23.         Delay_Init();
  24.         USART_Printf_Init(115200);
  25.         printf("SystemClk:%drn",SystemCoreClock);
  26.         printf("This is printf examplern");
  27.         MX_GPIO_Init();
  28.     OLED_Init();
  29.     OLED_ColorTurn(0);//0正常显示，1 反色显示
  30.     OLED_DisplayTurn(0);//0正常显示 1 屏幕翻转显示
  31.     OLED_Refresh();
  32.     MX_ADC_Init();
  33.         while(1)
  34.     {

  36.             adc_value=4096-Get_ADC_Val(ADC_Channel_0);
  37.             sprintf(tjcstr,"%d",adc_value);
  38.             OLED_ShowString(12,8,(u8 *)"ADC",24);
  39.             OLED_ShowString(36,32,(u8 *)tjcstr,24);
  40.             Delay_Ms(200);
  41.             OLED_Refresh();
  42.             GPIO_SetBits(GPIOD, GPIO_Pin_10);
  43.             if(adc_value>=3000)
  44.             {
  45.                 GPIO_SetBits(GPIOD, GPIO_Pin_10);
  46.                 Delay_Ms(50);
  47.                 GPIO_ResetBits(GPIOD, GPIO_Pin_10);
  48.                 Delay_Ms(50);
  49.             }

  51.         }
  52. }
实现效果
[media]https://yingsheng.elecfans.com/share/user/video/1Oz7sDYGrioS1nLP3gA2nQ[/media]
[media]https://yingsheng.elecfans.com/share/user/video/eDUXcsSn5vzn3O%2FMn4OywA[/media]
源代码

更多回帖

我也要说两句 回帖

相关经验

×
发帖