设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › 蓝桥杯嵌入式第七届省赛:模拟液位检测告警系统 STM32程 ...
返回列表 发新帖
查看: 1763|回复: 0
打印 上一主题 下一主题
收起左侧

蓝桥杯嵌入式第七届省赛:模拟液位检测告警系统 STM32程序

[复制链接]
跳转到指定楼层
楼主
ID:440075 发表于 2020-3-4 17:34 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
```c
/*赛题：第七届:模拟液位检测告警系统”
**作者：*wj  
**时间：2021-2-13
**注意：设备通过串口发送给PC，思路和LCD动态显示一样（记得添加"stdio.h"）
*/
**第一部分：逻辑功能实现**
  1. #include "stm32f10x.h"
  2. #include "lcd.h"
  3. #include "led.h"
  4. #include "key.h"
  5. #include "i2c.h"
  6. #include "stdio.h"
  7. #include "usart.h"
  8. #include "adc.h"
  9. u32 TimingDelay = 0;
  10. u8 text1[20];           //字符串数组1
  11. u8 text2[20];           //字符串数组2
  12. u8 RXBUF[20];           //串口接收数组
  13. u8 TXBUF[20];           //串口发送数组
  14. u8 RXOVER = 0;          //串口接收标志0：没有接收     1：接收
  15. u8 RXCOUNT = 0;         //串口数组计数变量      
  16. u8 ADC_Flag =1;         //ADC以1s间隔采集变量  1：采集（初始化为1，是让上电之后就进行一次电压采集）
  17. u8 K1_FLAG = 0;         //B1 按键： “设置”按键   0：液位检测界面    1：//阈值设置界面
  18. u8 K2_FLAG = 0;         //B2 按键：切换选择 3 个待修改的阈值，被选中的阈值应突出显示
  19. u8 LED1_on = 0;         //控制LED1开变量
  20. u8 LED1_off = 0;        //控制LED1关变量
  21. u8 Threshold_1 = 30;    //液位范围1
  22. u8 Threshold_2 = 50;    //液位范围2
  23. u8 Threshold_3 = 70;    //液位范围3
  24. u8 Level_old = 0;       //上一次的水平值
  25. u8 Level_now= 0;        //新的水平值
  26. u8 Height = 0;          //液面高度变量
  27. float ADC_Value;        //ADC采集的值（浮点型）
  28. u8 i = 0;               //循环变量
  29. u8 j = 0;               //循环变量
  30. u8 k = 0;               //循环变量


  33. /************************函数引用**************************************/
  34. void Delay_Ms(u32 nTime);
  35. void RCC_Configuration(void);
  36. void LCD_Init(void);
  37. void KEY_Scan(void);
  38. void _24c02_Write(u16 addr, u16 data);
  39. u16 _24c02_Read(u16 addr);
  40. void LCD_Display(void);
  41. void Deal_Data(void);
  42. void LED_Blink(void);
  43. /************************Main Body函数**************************************/
  44. int main(void)
  45. {
  46.         i2c_init();             //IIC初始化
  47.     LCD_Init();             //LCD初始化
  48.         RCC_Configuration();    //所有外设时钟配置
  49.         LED_Configuration();    //LED配置
  50.         KEY_Configuration();    //KEY配置
  51.         USART2_Configuration(); //串口通信2配置
  52.         ADC_Configuration();    //ADC配置
  53.         while(1)
  54.         {
  55.             KEY_Scan();           //按键扫描函数
  56.                 Deal_Data();          //数据处理比较函数
  57.                 LCD_Display();        //LCD显示函数
  58.             LED_Blink();          //LED闪烁配置函数
  59.         }
  60. }
  61. /************************LCD_Init初始化函数**************************************/
  62. void LCD_Init(void)
  63. {
  64.         STM3210B_LCD_Init();
  65.         LCD_Clear(Blue);
  66.         LCD_SetBackColor(Blue);
  67.         LCD_SetTextColor(White);        
  68.         SysTick_Config(SystemCoreClock/1000);        
  69. //第一次给EEPROM写入数据
  70. //                _24c02_Write(0x01,30);
  71. //                Delay_Ms(10);
  72. //                _24c02_Write(0x02,50);
  73. //                Delay_Ms(10);
  74. //                _24c02_Write(0x03,70);
  75. //                Delay_Ms(10);               
  76. //上电之后读取之前存储的数据
  77.         Threshold_1 = _24c02_Read(0x01);
  78.         Delay_Ms(10);
  79.         Threshold_2 = _24c02_Read(0x02);
  80.         Delay_Ms(10);
  81.         Threshold_3 = _24c02_Read(0x03);
  82. }
  83. /************************LCD_Display显示函数**************************************/        
  84. void LCD_Display(void)
  85. {
  86.         if(K1_FLAG == 0)    // 液位检测界面
  87.         {
  88.                 LCD_DisplayStringLine(Line2 ,"    Liquid Level    ");
  89.                 sprintf((char*)text1,"  Height: %dcm ",Height);
  90.           LCD_DisplayStringLine(Line4,text1);               
  91.                 if(ADC_Flag == 1)
  92.                 {
  93.                         ADC_Flag =0;
  94.                         ADC_Value = Get_ADC(8) * 3.3 /0xfff;
  95.                         sprintf((char*)text2,"  ADC_VAL: %.2fV ",ADC_Value);  //保留俩位小数：.2f
  96.                         LCD_DisplayStringLine(Line6,text2);
  97.                 }                        
  98.                 sprintf((char*)text1,"  Level: %d ",Level_now);
  99.             LCD_DisplayStringLine(Line8,text1);        
  100.                 _24c02_Write(0x01,Threshold_1);
  101.                 Delay_Ms(10);
  102.                 _24c02_Write(0x02,Threshold_2);
  103.                 Delay_Ms(10);
  104.                 _24c02_Write(0x03,Threshold_3);
  105.                 Delay_Ms(10);                                       
  106.         }
  107.         else if(K1_FLAG == 1)  //阈值设置界面
  108.         {
  109.                 LCD_SetBackColor(Blue);      //第一行一直显示蓝色
  110.                 LCD_DisplayStringLine(Line2 ,"  Parameter Setup    ");        
  111.                 if(K2_FLAG == 1)
  112.                 {
  113.                   LCD_SetBackColor(Red);    //选中高亮显示
  114.                   sprintf((char*)text1,"  Threshold 1: %dcm   ",Threshold_1);               
  115.           LCD_DisplayStringLine(Line4,text1);                        
  116.                 }
  117.                 else
  118.                 {
  119.                   LCD_SetBackColor(Blue);
  120.                   sprintf((char*)text1,"  Threshold 1: %dcm   ",Threshold_1);               
  121.           LCD_DisplayStringLine(Line4,text1);        
  122.                 }
  123.                 if(K2_FLAG == 2)
  124.                 {
  125.                   LCD_SetBackColor(Red);
  126.                   sprintf((char*)text1,"  Threshold 2: %dcm   ",Threshold_2);               
  127.           LCD_DisplayStringLine(Line5,text1);                        
  128.                 }
  129.                 else
  130.                 {
  131.                   LCD_SetBackColor(Blue);
  132.                   sprintf((char*)text1,"  Threshold 2: %dcm   ",Threshold_2);               
  133.           LCD_DisplayStringLine(Line5,text1);        
  134.                 }               
  135.                 if(K2_FLAG == 3)
  136.                 {
  137.                   LCD_SetBackColor(Red);
  138.                   sprintf((char*)text1,"  Threshold 3: %dcm   ",Threshold_3);               
  139.           LCD_DisplayStringLine(Line6,text1);                        
  140.                 }
  141.                 else
  142.                 {
  143.                   LCD_SetBackColor(Blue);
  144.                   sprintf((char*)text1,"  Threshold 3: %dcm   ",Threshold_3);               
  145.           ![在这里插入图片描述]([img]https://img-blog.csdnimg.cn/20200225154220972.png[/img]?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDIzNjMwMg==,size_16,color_FFFFFF,t_70)LCD_DisplayStringLine(Line6,text1);        
  146.                 }
  147. //设置不要的行的颜色为背景颜色
  148.                 LCD_SetBackColor(Blue);
  149.                 LCD_DisplayStringLine(Line0 ,"                     ");   
  150.                 LCD_DisplayStringLine(Line1 ,"                     ");
  151.                 LCD_DisplayStringLine(Line3 ,"                     ");
  152.                 LCD_DisplayStringLine(Line7 ,"                     ");
  153.                 LCD_DisplayStringLine(Line8 ,"                     ");
  154.                 LCD_DisplayStringLine(Line9 ,"                     ");
  155.         }
  156. //串口部分               
  157.         if(RXOVER)
  158.         {               
  159.                 RXOVER = 0;
  160.                 if(RXBUF[0] == 'C')
  161.                 {
  162.             sprintf((char*)TXBUF,"C:H%d+L%d\r\n",Height,Level_now);     
  163.                         Send_String(TXBUF);                        
  164.                 }
  165.                 else if(RXBUF[0] == 'S')
  166.                 {
  167.             sprintf((char*)TXBUF,"S:TL%d+TM%d+TH%d\r\n",Threshold_1,Threshold_2,Threshold_3);     
  168.                         Send_String(TXBUF);                        
  169.                 }
  170.                 for(k=0;k<5;k++)
  171.                 {
  172.                         LED_Control(LED1,1);
  173.                         LED_Control(LED3,0);                                                        
  174.                         Delay_Ms(200);
  175.                         LED_Control(LED3,1);                                
  176.                         Delay_Ms(200);
  177.                 }
  178.                 for(i=0;i<20;i++)
  179.                 {
  180.                         RXBUF[i] = 0;                [/i][i]
  181.                 }
  182.           USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
  183.         }        
  184. }
  185. /************************液位水平比较函数**************************************/        
  186. void Deal_Data(void)
  187. {
  188.         Height = ADC_Value * 100 / 3.3;   //根据题目要求的关系
  189.         if(Height <= Threshold_1)
  190.         {
  191.                 Level_now = 0;        
  192.         }
  193.         else if((Threshold_1 < Height ) && (Height <=  Threshold_2))
  194.         {
  195.                 Level_now = 1;        
  196.         }
  197.         else if((Threshold_2 < Height ) && (Height <=  Threshold_3))
  198.         {
  199.                 Level_now = 2;        
  200.         }
  201.         else if(Threshold_3 < Height )
  202.         {
  203.                 Level_now = 3;        
  204.         }        
  205. }


  208. /************************LED闪烁函数**************************************/        
  209. void LED_Blink(void)
  210. {
  211. //LED1_配置
  212.         if(K1_FLAG == 0)        //运行状态下
  213.         {
  214.                 if(LED1_on == 1)
  215.                 {
  216.                         LED1_on =0;
  217.                   LED_Control(LED1,0);               
  218.                 }


  221.                 if(LED1_off == 1)
  222.                 {
  223.                         LED1_off=0;
  224.             LED_Control(LED1,1);               
  225.                 }        
  226.         }
  227.         else
  228.   {
  229.           LED_Control(LED1,1);
  230.         }
  231. //LED2_配置
  232.         if(Level_old != Level_now)
  233.         {
  234.                 if(Level_now > Level_old)
  235.                         {
  236.                                 sprintf((char*)TXBUF,"A:H%d+L%d+U\r\n",Height,Level_now);     
  237.                                 Send_String(TXBUF);                                                        
  238.                         }
  239.                 if(Level_now < Level_old)
  240.                         {
  241.                                 sprintf((char*)TXBUF,"A:H%d+L%d+D\r\n",Height,Level_now);     
  242.                                 Send_String(TXBUF);                                
  243.                         }
  244.                 for(j=0;j<5;j++)
  245.                 {
  246.                         LED_Control(LED1,1);
  247.                     LED_Control(LED2,0);                                                        
  248.             Delay_Ms(200);
  249.                     LED_Control(LED2,1);                                
  250.             Delay_Ms(200);               
  251.                 }  
  252.         }
  253.         Level_old = Level_now;       //加载上一次的液位等级
  254. }
  255. /************************外设时钟函数**************************************/        
  256. void RCC_Configuration(void)
  257. {
  258.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);
  259.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE);
  260.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC , ENABLE);
  261.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD , ENABLE);
  262.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);
  263.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1,ENABLE);
  264. }
  265. /************************外设时钟函数**************************************/        
  266. void KEY_Scan(void)
  267. {
  268.         if(K1 == 0)
  269.         {
  270.           Delay_Ms(10);
  271.                 if(K1 == 0)
  272.                 {
  273.                   if(K1_FLAG == 0)
  274.                         {
  275.                           K1_FLAG = 1;                        
  276.                         }
  277.                         else
  278.                         {
  279.                           K1_FLAG = 0;
  280.                         }        
  281.                 }
  282.                 while(K1 == 0)
  283.                 LCD_ClearLine(Line0);
  284.                 LCD_ClearLine(Line1);
  285.                 LCD_ClearLine(Line2);
  286.                 LCD_ClearLine(Line3);
  287.                 LCD_ClearLine(Line4);
  288.                 LCD_ClearLine(Line5);
  289.                 LCD_ClearLine(Line6);
  290.                 LCD_ClearLine(Line7);
  291.                 LCD_ClearLine(Line8);
  292.                 LCD_ClearLine(Line9);               
  293.         }


  296.         if(K2 == 0 && K1_FLAG == 1)
  297.         {
  298.           Delay_Ms(10);
  299.                 if(K2 == 0 && K1_FLAG == 1)
  300.                 {        
  301.                         if(K2_FLAG < 3)
  302.                         K2_FLAG++;               
  303.       else
  304.       K2_FLAG=1;                                
  305.                 }
  306.                 while(K2 == 0);
  307.         }        


  310.         if(K3 == 0)
  311.         {
  312.           Delay_Ms(10);
  313.                 if(K3 == 0)
  314.                 {
  315.                   if(K2_FLAG == 1)
  316.                         {
  317.                                 if(Threshold_1 < Threshold_2)
  318.                                 Threshold_1 +=5;
  319.               else
  320.                                 Threshold_1 = Threshold_2;
  321.                         }
  322.                   else if(K2_FLAG == 2)
  323.                         {
  324.                                 if(Threshold_2<Threshold_3)
  325.                                 Threshold_2 +=5;
  326.               else
  327.                                 Threshold_2 = Threshold_3;
  328.                         }
  329.                         else if(K2_FLAG == 3)
  330.                         {
  331.                                 if(Threshold_3<90)
  332.                                 Threshold_3 +=5;
  333.               else
  334.                                 Threshold_3 = 95;
  335.                         }        
  336.                 }
  337.                 while(K3 == 0);
  338.         }        


  341.         if(K4 == 0)
  342.         {
  343.           Delay_Ms(10);
  344.                 if(K4 == 0)
  345.                 {
  346.                   if(K2_FLAG == 1)
  347.                         {
  348.                                 if(Threshold_1>5)
  349.                                 Threshold_1 -=5;
  350.               else
  351.                                 Threshold_1 = 5;
  352.                         }
  353.                   else if(K2_FLAG == 2)
  354.                         {
  355.                                 if(Threshold_2 >Threshold_1)
  356.                                 Threshold_2 -=5;
  357.               else
  358.                                 Threshold_2 = Threshold_1;
  359.                         }
  360.                         else if(K2_FLAG == 3)
  361.                         {
  362.                                 if(Threshold_3>Threshold_2)
  363.                                 Threshold_3 -=5;
  364.               else
  365.                                 Threshold_3 = Threshold_2;
  366.                         }        
  367.                 }
  368.                 while(K4 == 0);
  369.         }        
  370. }




  375. void _24c02_Write(u16 addr, u16 data)
  376. {


  379.         I2CStart();
  380.         I2CSendByte(0xa0);
  381.         I2CSendAck();
  382.         I2CSendByte(addr);
  383.         I2CSendAck();
  384.         I2CSendByte(data);
  385.     I2CSendAck();
  386.         I2CStop();
  387. }




  392. u16 _24c02_Read(u16 addr)
  393. {
  394.     u16 temp;
  395.         I2CStart();
  396.         I2CSendByte(0xa0);
  397.         I2CSendAck();
  398.         I2CSendByte(addr);
  399.         I2CSendAck();
  400.         
  401.         I2CStart();
  402.         I2CSendByte(0xa1);
  403.         I2CSendAck();
  404.         temp = I2CReceiveByte();
  405.         I2CSendAck();
  406.         I2CStop();
  407.         return temp;
  408.         
  409. }


  412. void Delay_Ms(u32 nTime)
  413. {
  414.         TimingDelay = nTime;
  415.         while(TimingDelay != 0);        
  416. }
  417. ```
  418. **第二部分:初始化配置**


  421. ```bash
  422. #define LED1 GPIO_Pin_8
  423. #define LED2 GPIO_Pin_9
  424. #define LED3 GPIO_Pin_10
  425. #define LED4 GPIO_Pin_11
  426. #define LED5 GPIO_Pin_12
  427. #define LED6 GPIO_Pin_13
  428. #define LED7 GPIO_Pin_14
  429. #define LED8 GPIO_Pin_15
  430. #define LEDALL GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15


  433. ```


  436. ```c
  437. #include "led.h"


  440. /**
  441. 功能：初始化LED管脚
  442. 注意：为了防止LCD LED显示的冲突对LCD写函数进行了寄存器的操作
  443. **/        
  444. void LED_Configuration(void)
  445. {
  446.   GPIO_InitTypeDef GPIO_InitStructure;


  449.   GPIO_InitStructure.GPIO_Pin = LEDALL;
  450.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  451.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  452.   GPIO_Init(GPIOC, &GPIO_InitStructure);


  455.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
  456.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  457.   GPIO_Init(GPIOD, &GPIO_InitStructure);


  460.         GPIO_SetBits(GPIOD,GPIO_Pin_2);
  461.         GPIO_SetBits(GPIOC,LEDALL);
  462.         GPIO_ResetBits(GPIOD,GPIO_Pin_2);
  463.         
  464. }
  465. /**
  466. 功能：控制LED亮灭
  467. 入口参数ledx：LED1-LED8
  468. 入口参数led_sta：低电平点亮（根据原理图配置）
  469. **/        
  470. void LED_Control(u16 ledx,u16 led_sta)
  471. {
  472.         if(led_sta == 0)
  473.         {
  474.                 GPIO_SetBits(GPIOD,GPIO_Pin_2);
  475.                 GPIO_ResetBits(GPIOC,ledx);
  476.                 GPIO_ResetBits(GPIOD,GPIO_Pin_2);
  477.         }
  478.         else
  479.         {
  480.                 GPIO_SetBits(GPIOD,GPIO_Pin_2);
  481.                 GPIO_SetBits(GPIOC,ledx);
  482.                 GPIO_ResetBits(GPIOD,GPIO_Pin_2);        
  483.         }
  484. }
  485. ```






  492. ```bash
  493. #define K1 GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0)
  494. #define K2 GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_8)
  495. #define K3 GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_1)
  496. #define K4 GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_2)
  497. ```


  500. ```c
  501. #include "key.h"
  502. void KEY_Configuration(void)
  503. {
  504.   GPIO_InitTypeDef GPIO_InitStructure;


  507.   /* Configure TIM1_CH1 (PA8) as alternate function push-pull */
  508.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_8;
  509.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  510.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  511.   GPIO_Init(GPIOA, &GPIO_InitStructure);


  514.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
  515.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  516.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  517.   GPIO_Init(GPIOB, &GPIO_InitStructure);
  518. }
  519. ```


  522. ```c
  523. #include "usart.h"
  524. void USART2_Configuration(void)
  525. {
  526.   USART_InitTypeDef USART_InitStructure;
  527.   GPIO_InitTypeDef GPIO_InitStructure;
  528.   NVIC_InitTypeDef NVIC_InitStructure;
  529.         
  530.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 ;
  531.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  532.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  533.   GPIO_Init(GPIOA, &GPIO_InitStructure);


  536.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
  537.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  538.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  539.   GPIO_Init(GPIOA, &GPIO_InitStructure);
  540.         
  541.   USART_InitStructure.USART_BaudRate = 9600;
  542.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  543.   USART_InitStructure.USART_StopBits = USART_StopBits_1;
  544.   USART_InitStructure.USART_Parity = USART_Parity_No;
  545.   USART_InitStructure.USART_HardwareFlowControl =    USART_HardwareFlowControl_None;
  546.   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        


  549.   NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
  550.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  551.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  552.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  553.   NVIC_Init(&NVIC_InitStructure);


  556.   USART_Init(USART2, &USART_InitStructure);
  557.   USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
  558.   /* Enable the USART2 */
  559.   USART_Cmd(USART2, ENABLE);
  560. }


  563. /**
  564. 功能：发送字符串
  565. 入口参数：发送内容
  566. **/        
  567. void Send_String(u8 *str)
  568. {
  569.         u8 index = 0;
  570.         do
  571.         {
  572.                 USART_SendData(USART2, str[index]);
  573.                 while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);
  574.                 index++;
  575.         }
  576.         while(str[index] != 0);
  577. }
  578. ```


  581. ```c
  582. #include "adc.h"
  583. void ADC_Configuration(void)
  584. {
  585.         GPIO_InitTypeDef GPIO_InitStructure;
  586.   ADC_InitTypeDef  ADC_InitStructure;
  587.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
  588.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  589.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;   //模拟输入
  590.   GPIO_Init(GPIOB, &GPIO_InitStructure);


  593.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);   //ADC时钟分频，不能超过14M，所以72/6=12M
  594.   /* ADC1 configuration ------------------------------------------------------*/
  595.   ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
  596.   ADC_InitStructure.ADC_ScanConvMode = DISABLE;
  597.   ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
  598.   ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
  599.   ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  600.   ADC_InitStructure.ADC_NbrOfChannel = 1;
  601.   ADC_Init(ADC1, &ADC_InitStructure);
  602.   ADC_Cmd(ADC1, ENABLE);
  603.         
  604.   /* Enable ADC1 reset calibration register */   
  605.   ADC_ResetCalibration(ADC1);
  606.   /* Check the end of ADC1 reset calibration register */
  607.   while(ADC_GetResetCalibrationStatus(ADC1));


  610.   /* Start ADC1 calibration */
  611.   ADC_StartCalibration(ADC1);
  612.   /* Check the end of ADC1 calibration */
  613.   while(ADC_GetCalibrationStatus(ADC1));
  614.         
  615. }
  616. /**
  617. 功能：获取模拟输入变量
  618. 入口参数：ADC的通道（因为板上配置ADC_Channel_8）
  619. 局部变量：u16 temp保存读取的模拟量
  620. 返回值：temp保存读取的模拟量
  621. **/        
  622. u16 Get_ADC(u8 channel)
  623. {
  624.         u16 temp;
  625.   /* ADC1 regular channel14 configuration */
  626.   ADC_RegularChannelConfig(ADC1, channel, 1, ADC_SampleTime_239Cycles5);        
  627.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);
  628.         while(ADC_GetFlagStatus(ADC1,ADC_FLAG_EOC) == 0);  //转换结束标志ADC_FLAG_EOC
  629.         temp = ADC_GetConversionValue(ADC1);
  630.         ADC_SoftwareStartConvCmd(ADC1,DISABLE);
  631.   return temp;
  632. }
  633. ```
  634. **第三部分：中断处理**


  637. ```bash
  638. extern u32 TimingDelay;
  639. extern u8 RXBUF[20];
  640. extern u8 RXOVER;
  641. extern u8 RXCOUNT;
  642. extern u8 LED1_on;
  643. extern u8 LED1_off;
  644. extern u8 ADC_Flag;
  645. ```


  648. ```c
  649. void SysTick_Handler(void)
  650. {
  651.         static u16 count1 = 0 ,count2 =0;
  652.         TimingDelay--;
  653.         if(++count1 == 1000)
  654.         {
  655.                 count1 = 0;
  656.           LED1_on        = 1;
  657.                 ADC_Flag = 1;
  658.         }
  659.   if(++count2 == 2000)
  660.         {
  661.                 count2 = 0;
  662.           LED1_off = 1;
  663.         }
  664. }




  669. void USART2_IRQHandler(void)
  670. {
  671.         u8 temp;
  672.   if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
  673.   {
  674.           USART_ClearITPendingBit(USART2,USART_IT_RXNE);
  675.                 temp = USART_ReceiveData(USART2);
  676.                 if(temp == '\n' || RXCOUNT ==20)
  677.                 {
  678. //                        RXBUF[RXCOUNT - 1] = 0;         //防止最后出现乱码\r
  679.                         RXOVER = 1;                        
  680.                   RXCOUNT=0;
  681.                         USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);
  682.                 }
  683.                 else
  684.                 {
  685.                         RXBUF[RXCOUNT] = temp;
  686.                   RXCOUNT++;
  687.                 }               
  688.         }
  689. }
复制代码


分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏2 分享淘帖 顶顶 踩踩
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表