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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › 基于STM32的智能路灯控制系统
返回列表 发新帖
查看: 18566|回复: 6
打印 上一主题 下一主题
收起左侧

基于STM32的智能路灯控制系统

  [复制链接]
跳转到指定楼层
楼主
ID:365203 发表于 2018-7-5 22:01 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
本帖主要介绍一个基于STM32的智能路灯控制系统
摘    要
本设计根据题目要求制作一套智能路灯控制系统，并且本着低成本高性能、结构简单、控制方便、直观显示等的设计思想。我们通过对硬件系统和软件程序的设计，以此实现通过光线强弱状态来控制路灯的亮灭功能。其中硬件电路部分主要包括：单片机最小系统、路灯控制电路部分、红外检测和执行电路部分、数码管显示电路部分；软件部分主要包括：相应软件和路灯控制、光电检测和执行、时间显示等程序模块。为了能够精确控制智能灯的开关状态，本参赛队队员决定采用集成度高、处理能力强、可靠性高的单片机STM32F103RCT6设计相应程序，通过红外检测模块来检测是否有物体通过。当物体通过时，下降沿触发产生中断，随后单片机执行中断函数里的命令。通过CH340g串口通信用电脑将采集到的有用数据发送给单片机，以此通过引脚高低电平和驱动电路控制路灯亮灭。再经处理后将物体通过的时间和对应速度显示在数码管上。
1．系统方案论证与比较
1.1整体设计思路流程
1.2单片机模块部分
方案一：选择STC89C52作为主控芯片，STC89C52周期比较慢，系统反应比较慢。
方案二：选择STM32F103RB作为主控芯片，这款单片机的虽然周期是比STC89C52快，但是CPU兼容性不强，存储空间不够大。
方案三：选择STM32F103RCT6作为主控芯片，这块芯片CPU兼容性更强，同时存储空间很强大，一个16位普通IC/OC/PWM)，2个16位基本(IC/OC/PWM)，1个STI，2个USART，同时具有低功率、记忆、定时器等功能完全可以满足系统智能控制的要求。
综合以上三种方案，选择方案三。
2．电路与程序设计
2.1电路的设计
2.1.1红外感应检测模块部分
采用红外感应技术而不采用其他人体感应技术，是因为目前基于红外线的人体感应技术已经发展成熟，各种类型的红外感应器也已经十分多见，而且价格便宜，目前成为最流行的人体感应技术。
红外感应部分由红外线自动检测电路、逻辑运算、延迟电路、驱动电路等组成。利用红外传感器，可以检测到人体的接近、移动等运动状态。即当有人体进入到感应区域内时，红外发射电路发出的红外线被人体反射回一部分，红外接收电路接收后通过逻辑运算电路控制路灯的亮灭，从而实现自动控制。
红外自动检测系统如图1-3所示。
图1-3红外线自动检测系统框图
2.1.2 LED驱动电路部分
本部分通过LED驱动电路根据环境亮度的敏感程度做出反应。当环境亮度较低时（夜晚时分），电路将自动启动，给红外感应器模块供电，这时可以根据有没有人经过而自动控制路灯的亮灭。当环境亮度较高时（白天或者周围有更高亮度的路灯点亮时），电路将自动切断并进入省电模式，这是无论有没有人经过，路灯都不会点亮。如下1-4为LED驱动电路的仿真图。
图1-4LED驱动电路设计图
其中每只LED灯控制逻辑关系如图1-5所示，即在规定的时间条件成立的条件下，当明暗条件成立的情况下开灯。

图1-5 LED灯控制逻辑图

2.1.3 串口通信部分
该部分采用的是通过CH340g进行串口通信，即进行软件设置以后，将编程器与目标板连接，然后对单片机烧录程序。
2.1.4 系统总体框图
智能路灯控制系统主要采用单片机进行控制，根据环境的明暗程度以及时间条件来决定路灯的开与关，其控制流程如下


2.2程序的设计
1、程序功能
根据题目要求软件部分主要实现运算与显示。
2、程序设计
利用单片机STM32F103RCT6的外部中断以及计时器功能，通过红外检测模块来检测是否有物体通过。当物体通过时，下降沿触发产生中断，随后单片机执行中断函数里的命令。以此通过引脚高低电平和驱动电路控制路灯亮灭，再经处理后将物体通过的时间和对应速度显示在数码管上。
3.测试方案与测试结果
3.1测试方案
1、硬件测试
首先分模块搭建硬件电路并分别测试成功，然后将分立的模块搭建在一起测试整体功能。经测试，我们的电源模块、功耗模块、单片机控制模块以及信号检测放大模块均工作正常。
2、软件仿真测试
利用Proteus软件画出电路仿真图，进行电路的各项性能测试，结果正常。
3、硬件软件联调

软件仿真结果与实测值进行比较，分析差异原因，找出改进方案。

3.2 测试结果及分析
    经过测试，系统各部分均工作正常，智能路灯照明系统可以控制LED灯的开关状态。同时可以根据数码管显示相应物体运动速度等，测试结果也比较准确，因此本设计可以满足相应功能。

单片机源程序如下:
  1. #include "stm32f10x.h"
  2. #include"LCD1602.h"
  3. #include"time_i.h"
  4. #include"clock.h"
  5. #include "delay.h"
  6. #include "sys.h"
  7. #include "usart.h"
  8. #include"strcmp.h"
  9. #include"Fixed_time.h"
  10. #include"led.h"
  11. #include"Digital_LED.h"
  12. #include"Alarm.h"
  13. #include"Speed_Cal.h"
  14. #include"IR_EXTI.h"
  15. #include"EXTI_PC10.h"
  16. #include"EXTI_PC11.h"
  17. #include"exti_PC13.h"
  18. #include"EXTI_PC14.h"
  19. #include"EXTI_PC15.h"
  20. #include"Judge_LED.h"
  21. int main(void)
  22. {   u8 t;
  23.               u8 len;            
  24.               u8 Time_Set[]="Set";
  25.               u8 Time_Set_Flag=0;
  26.               u8 Fix_Flag=0;
  27.               u8 *P_Fix_Flag;
  28.               P_Fix_Flag=&Fix_Flag;
  29.               order=Pass_order=0;
  30.               //LED1_Flag=LED2_Flag=0;
  31.               //LED_1=LED_2=L=M=R=1;
  32.               Time_Record_Flag=0;
  33.               Action_Record=0;
  34. /****************************************************************************/              /*配置GPIO*/
  35.               LCD_Data_GPIO_Config();
  36.               LCD_Com_GPIO_Config();
  37. /*配置数码管的GPIO*/
  38.               Digital_LED_GPIO_Init();
  39.               /*LED GPIO配置*/
  40.               LED_GPIO_Config();
  41.               /*LCD初始化*/
  42.   LCD1602_Init();
  43.               /*延时函数初始化*/
  44.               delay_init();                              
  45.               /*设置中断优先级分组*/
  46.               NVIC_Configuration_sys();
  47.               /*警报初始化*/
  48.               Alarm_Config();
  49.               /*外部中断初始化*/
  50.               //EXTI_PC_Config();
  51.   EXTI_PC10_Config();
  52.               EXTI_PC11_Config();
  53.               EXTI_PC13_Config();
  54.   EXTI_PC14_Config();
  55.               EXTI_PC15_Config();
  56.               /*串口初始化为9600*/
  57.               uart_init(9600);            
  58.               /*配置TIM3   默认开启时钟*/
  59.               Timer_Init();
  60.               /*给时钟赋初始时间*/
  61.               Clock_Init();
  62. /*****************************************************************/            
  63. LED1(OFF);
  64. LED2(OFF);
  65.               while(1)
  66.               {Judge();            
  67.               {if(USART_RX_STA&0x8000)
  68.                             { len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
  69.                                           printf("%s_%s_%s_%s\r\nThe message you have sent:\r\n\n",Fixed_Buf1,Fixed_Buf3,Fixed_Buf2,Fixed_Buf4);
  70.                                           for(t=0;t<len;t++)
  71.                                           {USART1->DR=USART_RX_BUF[t];
  72.                                           while((USART1->SR&0X40)==0);//等待发送结束}
  73.                                           printf("\r\n\r\n");//插入换行
  74.                                           USART_RX_STA=0;
  75.                                           Time_Set_Flag=1;
  76.                                           Fix_Flag=1;
  77.                                           Control_Flag1=1;
  78.                                           Control_Flag2=1;}
  79.                                           if(Strcmp(USART_RX_BUF,Time_Set) > 0&&(USART_RX_BUF[0] == 'S'))
  80.                                                         if(Time_Set_Flag)
  81.                                                         {hour=(USART_RX_BUF[3]-48)*10+(USART_RX_BUF[4]-48);
  82.                                                                       min=(USART_RX_BUF[6]-48)*10+(USART_RX_BUF[7]-48);
  83.                                                                       sec=(USART_RX_BUF[9]-48)*10+(USART_RX_BUF[10]-48)-1;
  84.                                                                       Time_Set_Flag=0; }  }
  85.                             Control();
  86.                             Fix(P_Fix_Flag);
  87.                             Dis_time();
  88.                             Fixed_Show();} }
  89. LCD显示
  90. LCD1602.c
  91. #include"LCD1602.h"
  92. // 单片机系统时钟在72MHZ下的延时
  93. /*****************************延时函数*********** *******/
  94. void delay_nus(u32 n)//微秒级延时
  95. {   u8 i;
  96.     while(n--)
  97.     {   i=7;
  98.         while(i--);  }  }   
  99. void delay_nms(u32 n) //毫秒级延时，通常情况此函数可以不用更改
  100. {   while(n--)
  101.     {    delay_nus(1100);  } }
  102. //LCD1602液晶读忙状态
  103. // void LCD_FBUF(void)
  104. // {   // LCD1602_RS0;                    //RS信号拉低
  105.               // LCD1602_RW1;    //RW信号拉高
  106.               // LCD1602_EN1;//EN信号拉高
  107.               // DATA_OUT = 0xFF;    //数据端口 11111111全高电平
  108.               // while((DATA_OUT & 0x80) == 0x80);    //判断数据端口PB7 是否一直高
  109.               // LCD1602_RW1;//RW信号拉高
  110.               // LCD1602_EN0;    //EN信号拉低  // }
  111. //LCD1602写指令子函数
  112. void Write_LCD1602_Instruction_Com(uint8_t Com)
  113. {   //LCD_FBUF();                                     //读忙状态
  114.               LCD1602_EN0;                    //EN信号拉低
  115.               LCD1602_RS0;                    //RS信号拉低写指令
  116.               LCD1602_RW0;                    //RW信号拉低
  117.               DATA_OUT = Com;                    //数据端口指令输入
  118.               delay_nms(1);                   //延时1ms
  119.               delay_nms(1);
  120.               LCD1602_EN1;                       //EN信号一个高脉冲
  121.               delay_nms(1);                   //延时1ms
  122.               delay_nms(1);
  123.               LCD1602_EN0;}
  124. //LCD1602写数据子函数
  125. void Write_LCD1602_Instruction_Data(uint8_t Date)
  126. {//LCD_FBUF();                                     //读忙状态
  127.               LCD1602_EN0;                    //EN信号拉低
  128.               LCD1602_RS1;                    //RS信号拉低写指令
  129.               LCD1602_RW0;                    //RW信号拉低
  130.               DATA_OUT = Date;               //数据端口数据输入
  131.               delay_nms(1);                   //延时1ms
  132.               delay_nms(1);
  133.               LCD1602_EN1;                        //EN信号一个高脉冲
  134.               delay_nms(1);                   //延时1ms
  135.               delay_nms(1);
  136.               LCD1602_EN0;}
  137. //LCD1602写指令和写数据子函数
  138. // void Write_LCD1602_Instruction_Com_Data(uint8_t CountLiey, uint8_t Date)
  139. // {              // if(CountLiey == 0)                              //CountLiey == 0 写指令
  140.               // {  // Write_LCD1602_Instruction_Com(Date);              // 写指令
  141.               // }              // else                                 //CountLiey !=0 写数据  
  142.               // {  // Write_LCD1602_Instruction_Data(Date);  //不等于0写数据  // }   // }
  143. //LCD1602初始化子函数
  144. void LCD1602_Init(void)
  145. {  delay_nms(15);
  146.               Write_LCD1602_Instruction_Com(0x38);   //设置16×2显示，5×7点阵，8位数据接口
  147.               delay_nms(5);
  148.               Write_LCD1602_Instruction_Com(0x0C);               //设置打开显示
  149.               delay_nms(5);
  150.               Write_LCD1602_Instruction_Com(0x06);             //读或写一个字符后地址指针加1
  151.               delay_nms(5);
  152.               Write_LCD1602_Instruction_Com(0x01);           //显示清屏
  153.               delay_nms(5);
  154.               Write_LCD1602_Instruction_Com(0x80);           //设置数据指针起点
  155.               delay_nms(5);   }
  156. void LCD_Data_GPIO_Config(void)
  157. {    GPIO_InitTypeDef GPIO_InitStructure;
  158.               RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE);
  159.               GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 |GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3| GPIO_Pin_4| GPIO_Pin_5| GPIO_Pin_6| GPIO_Pin_7;
  160.               GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  161.               GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  162.               GPIO_Init(GPIOA, &GPIO_InitStructure);   }
  163. void LCD_Com_GPIO_Config(void)
  164. {   GPIO_InitTypeDef GPIO_InitStructure;
  165.               RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE);
  166.               GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 |GPIO_Pin_7 | GPIO_Pin_5 ;
  167.               GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  168.               GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  169.               GPIO_Init(GPIOB, &GPIO_InitStructure);   }
  170. LCD1602.h
  171. #ifndef                _LCD1602_H_
  172. #define                _LCD1602_H_
  173. /**************************************************************************/
  174. #include "stm32f10x.h"
  175. //======端口位清除寄存器
  176. #define      LCD1602_RS0           GPIO_ResetBits(GPIOB, GPIO_Pin_5)//低电平  PB5
  177. #define      LCD1602_RW0           GPIO_ResetBits(GPIOB, GPIO_Pin_7) //低电平  PB7
  178. #define      LCD1602_EN0           GPIO_ResetBits(GPIOB, GPIO_Pin_6)//低电平  PB6
  179. //========端口位设置/清除寄存器
  180. #define      LCD1602_RS1           GPIO_SetBits(GPIOB, GPIO_Pin_5) //高电平 PB5
  181. #define      LCD1602_RW1           GPIO_SetBits(GPIOB, GPIO_Pin_7) //高电平  PB7
  182. #define      LCD1602_EN1           GPIO_SetBits(GPIOB, GPIO_Pin_6) //高电平  PB6
  183. #define      DATA_OUT              GPIOA->ODR//数据端口 PA0-PA7
  184. void Delay_us(uint32_t CountLing);
  185. void LCD_FBUF(void);
  186. void Write_LCD1602_Instruction_Com(uint8_t Com);
  187. void Write_LCD1602_Instruction_Data(uint8_t Date);
  188. void Write_LCD1602_Instruction_Com_Data(uint8_t CountLiey, uint8_t Date);
  189. void LCD1602_Init(void);
  190. void LCD_Data_GPIO_Config(void);
  191. void LCD_Com_GPIO_Config(void);
  192. /****************************************************************************/
  193. #endif
  194. 数码管显示
  195. Digital_LED.c
  196. #include "stm32f10x.h"
  197. #include"Digital_LED.h"
  198. #include"Speed_Cal.h"
  199. #include "delay.h"
  200. #include"led.h"
  201. u32 Digital_LED_Table[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};//共阳极数码管显示编码
  202. u32 Dig_LED_time;
  203. void Digital_LED_GPIO_Init(void)
  204. {  GPIO_InitTypeDef GPIO_InitStructure;
  205.               RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB |RCC_APB2Periph_GPIOC, ENABLE);
  206.               /*配置数据输出GPIO*/
  207.               GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5| GPIO_Pin_6| GPIO_Pin_7;
  208.               GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  209.               GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  210.               GPIO_Init(GPIOC, &GPIO_InitStructure);
  211.               GPIO_ResetBits(GPIOC, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5| GPIO_Pin_6| GPIO_Pin_7);
  212.               /*配置位选GPIO*/
  213.               GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_12 ;
  214.               GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  215.               GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  216.               GPIO_Init(GPIOA, &GPIO_InitStructure);
  217.               GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 |  GPIO_Pin_14 | GPIO_Pin_15 ;
  218.               GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  219.               GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  220.               GPIO_Init(GPIOB, &GPIO_InitStructure);
  221. /****************************************************************************/
  222.               GPIO_ResetBits(GPIOA,  GPIO_Pin_12 );
  223.               GPIO_ResetBits(GPIOB, GPIO_Pin_8 |  GPIO_Pin_14 | GPIO_Pin_15 );   }
  224. void Digital_LED_Write(u32 Speed)   //Speed 以mm为单位
  225. {   if(Speed <= 9999)   //数码管最多显示999.9cm
  226.               {   if(Speed/1000)
  227.                             {    Dig_1_On;
  228.                                           DATA_OUT_DIG = Digital_LED_Table[Speed / 1000];
  229.                                           Delay(0x000fef);
  230.                                           Dig_1_Off;
  231.                                           Dig_2_On;
  232.                                           DATA_OUT_DIG = Digital_LED_Table[(Speed-(Speed/1000)*1000)/ 100];
  233.                                           Delay(0x000fef);
  234.                                           Dig_2_Off;
  235.                                           Dig_3_On;
  236.                                           DATA_OUT_DIG = Digital_LED_Table[(Speed-(Speed/100)*100)/ 10];
  237.                                           Delay(0x000fef);
  238.                                           DATA_OUT_DIG = 0x7f;//点亮小数点
  239.                                           Delay(0x000fef);
  240.                                           Dig_3_Off;
  241.                                           Dig_4_On;
  242.                                           DATA_OUT_DIG = Digital_LED_Table[Speed-(Speed/10)*10];
  243.                                           Delay(0x000fef);
  244.                                           Dig_4_Off;   }
  245.                             else if(Speed/100)
  246.                                           {   Dig_1_Off;
  247.                                                         Dig_2_On;
  248.                                                         DATA_OUT_DIG = Digital_LED_Table[Speed/100];
  249.                                                         Delay(0x000fef);
  250.                                                         Dig_2_Off;
  251.                                                         Dig_3_On;
  252.                                                         DATA_OUT_DIG = Digital_LED_Table[(Speed-(Speed/100)*100)/10];
  253.                                                         Delay(0x000fef);
  254.                                                         DATA_OUT_DIG = 0x7f;//点亮小数点
  255.                                                         Delay(0x000fef);
  256.                                                         Dig_3_Off;
  257.                                                         Dig_4_On;
  258.                                                         DATA_OUT_DIG = Digital_LED_Table[Speed-(Speed/10)*10];
  259.                                                         Delay(0x000fef);
  260.                                                         Dig_4_Off;   }
  261.                                           else if(Speed/10)
  262.                                                         {   Dig_1_Off;
  263.                                                                       Dig_2_Off;
  264.                                                                       Dig_3_On;
  265.                                                                       DATA_OUT_DIG = Digital_LED_Table[Speed/10];
  266.                                                                       Delay(0x000fef);
  267.                                                                       DATA_OUT_DIG = 0x7f;//点亮小数点
  268.                                                                       Delay(0x000fef);
  269.                                                                       Dig_3_Off;
  270.                                                                       Dig_4_On;
  271.                                                                       DATA_OUT_DIG = Digital_LED_Table[Speed-(Speed/10)*10];
  272.                                                                       Delay(0x000fef);
  273.                                                                       Dig_4_Off;  }
  274.                                                         else if(Speed/10 == 0)
  275.                                                                       {              Dig_1_Off;
  276.                                                                                     Dig_2_Off;
  277.                                                                                     Dig_3_On;
  278.                                                                                     DATA_OUT_DIG = Digital_LED_Table[0];
  279.                                                                                     Delay(0x000fef);
  280.                                                                                     DATA_OUT_DIG = 0x7f;//点亮小数点
  281.                                                                                     Delay(0x000fef);
  282.                                                                                     Dig_3_Off;
  283.                                                                                     Dig_4_On;
  284.                                                                                     DATA_OUT_DIG = Digital_LED_Table[Speed];
  285.                                                                                     Delay(0x000fef);
  286.                                                                                     Dig_4_Off;              }       }                                                                      }
  287. void Delay(u32 nCount)
  288. {   for(;nCount != 0; nCount--);  }
  289. void Run_Digital_LED(void)
  290. {   //Speed_();
  291.               Dig_LED_time=0x000fff;//延时3~4s
  292.               while(Dig_LED_time--)
  293.               Digital_LED_Write(Speed);
  294.               // LED1(OFF);
  295.               // LED2(OFF);  }
  296. Digital_LED.h
  297. #ifndef _Digital_LED_H
  298. #define _Digital_LED_H
  299. /**************************************************/
  300. #include "stm32f10x.h"
  301. #define      DATA_OUT_DIG              GPIOC->ODR//数据端口 PC0-PC7
  302. /*定义位选*/
  303. #define      Dig_1_On                                                        GPIO_SetBits(GPIOB, GPIO_Pin_14 );
  304. #define      Dig_2_On                                                        GPIO_SetBits(GPIOB, GPIO_Pin_15 );
  305. #define      Dig_3_On                                                        GPIO_SetBits(GPIOB, GPIO_Pin_8);
  306. #define      Dig_4_On                                                        GPIO_SetBits(GPIOA, GPIO_Pin_12 );
  307. #define      Dig_1_Off                                                        GPIO_ResetBits(GPIOB, GPIO_Pin_14 );
  308. #define      Dig_2_Off                                                        GPIO_ResetBits(GPIOB, GPIO_Pin_15 );
  309. #define      Dig_3_Off                                                        GPIO_ResetBits(GPIOB, GPIO_Pin_8);
  310. #define      Dig_4_Off                                                        GPIO_ResetBits(GPIOA, GPIO_Pin_12 );
  311. /*定义位选*/
  312. extern u32 Digital_LED_Table[];
  313. extern u32 Dig_LED_time;
  314. void Digital_LED_GPIO_Init(void);
  315. void Digital_LED_Write(u32 Speed);
  316. void Delay(u32 nCount);
  317. void Run_Digital_LED(void);
  318. /**************************************************/
  319. #endif
  320. 定时器3用于显示时间
  321. time_i.c
  322. #include"time_i.h"
  323. void Timer_Init(void)
  324. {  TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
  325.               /*给TIM模块使能， TIM3挂载在APB1上*/
  326.               RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
  327.               NVIC_Configuration();
  328.               /*配置TIM3*/
  329.               TIM_DeInit(TIM3);
  330.               TIM_TimeBaseStructure.TIM_Period=1999;//自动重装载寄存器的值
  331.               TIM_TimeBaseStructure.TIM_Prescaler=35999;//时钟预分频数
  332.               TIM_TimeBaseStructure.TIM_ClockDivision=TIM_CKD_DIV1;//采样分频
  333.               TIM_TimeBaseStructure.TIM_CounterMode=TIM_CounterMode_Up;//计数方式
  334.               TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
  335.               TIM_ClearFlag(TIM3,TIM_FLAG_Update);//清除溢出中断标志
  336.               TIM_ITConfig(TIM3, TIM_IT_Update, ENABLE);
  337.               TIM_Cmd(TIM3,ENABLE);//开启时钟  }
  338. /*配置NVIC*/
  339. static void NVIC_Configuration(void)
  340. {   NVIC_InitTypeDef NVIC_InitStructure;
  341.               /*配置中断源*/
  342.               NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
  343.               NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; //抢占优先级1
  344.               NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;       //响应优先级1
  345.               NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  346.               NVIC_Init(&NVIC_InitStructure); }
  347. time_i.h
  348. #ifndef _TIME_I_
  349. #define _TIME_I_
  350. /**********************************************/
  351. #include "stm32f10x.h"
  352. void Timer_Init(void);
  353. static void NVIC_Configuration(void);
  354. /*********************************************/
  355. #endif
  356. TIM3中断函数
  357. void TIM3_IRQHandler(void)
  358. {   if (TIM_GetITStatus(TIM3,TIM_IT_Update)==SET)
  359.               {   TIM_ClearITPendingBit(TIM3,TIM_FLAG_Update);
  360.                             sec++;
  361.                             Clock();
  362.                             //Dis_time();   }   }
  363. 串口控制LED
  364. Fixed_time.c
  365. #include "stm32f10x_it.h"
  366. #include"Fixed_time.h"
  367. #include"clock.h"
  368. #include "usart.h"
  369. #include"LCD1602.h"
  370. #include"strcmp.h"
  371. #include"led.h"
  372. u8 Fixed_1_On[] = "N1";
  373. u8 Fixed_1_Off[] = "F1";
  374. u8 Fixed_2_On[] = "N2";
  375. u8 Fixed_2_Off[] = "F2";
  376. // u8 N_Now_1[] = "nowN1";
  377. // u8 F_Now_1[] = "nowF1";
  378. // u8 N_Now_2[] = "nowN2";
  379. // u8 F_Now_2[] = "nowF2";
  380. u8 Led1[]="L1";
  381. u8 Led2[]="L2";
  382. u8 Fixed_Buf1[]="  :  :  ";
  383. u8 Fixed_Buf2[]="  :  :  ";
  384. u8 Fixed_Buf3[]="  :  :  ";
  385. u8 Fixed_Buf4[]="  :  :  ";
  386. u8 State_Flag1=0;
  387. u8 State_Flag2=0;
  388. u8 Control_Flag1=0;
  389. u8 Control_Flag2=0;
  390. void Fix(u8 *Fix_Flag)
  391. {  /*定时开启1号灯*/
  392.               if(Strcmp(USART_RX_BUF,Fixed_1_On) > 0)
  393.                             if((*Fix_Flag)&& (USART_RX_BUF[0]=='N')&& (USART_RX_BUF[1]=='1'))
  394.                                                         {    State_Flag1=1;
  395.                                                                       *Fix_Flag=0;
  396.                                                                       Fixed_Buf1[0]=USART_RX_BUF[2];
  397.                                                                       Fixed_Buf1[1]=USART_RX_BUF[3];
  398.                                                                       Fixed_Buf1[3]=USART_RX_BUF[5];
  399.                                                                       Fixed_Buf1[4]=USART_RX_BUF[6];
  400.                                                                       Fixed_Buf1[6]=USART_RX_BUF[8];
  401.                                                                       Fixed_Buf1[7]=USART_RX_BUF[9];
  402.                                                                       // if(GPIO_ReadOutputDataBit(GPIOB,GPIO_Pin_10)==0)
  403.                                                                       // {  // Write_LCD1602_Instruction_Com(0x80);
  404.                                                                                     // Write_LCD1602_Instruction_Data('N');
  405.                                                                                     // Write_LCD1602_Instruction_Com(0xC0);
  406.                                                                                     // for(m=0;m<8;m++)
  407.                                                                                     // {  // Write_LCD1602_Instruction_Com(0xC0+m);
  408.                                                           // Write_LCD1602_Instruction_Data(Fixed_Buf1[m]               // }   // }                }
  409.               // if(Strcmp(USART_RX_BUF,N_Now_1) == 0)
  410.               // {                // LED1(ON);
  411.                             // if( GPIO_ReadOutputDataBit (GPIOB, GPIO_Pin_1)==0)              // LED2(OFF);   // }
  412.               /*定时关闭1号灯*/
  413.               if(Strcmp(USART_RX_BUF,Fixed_1_Off) > 0)
  414.                             if((*Fix_Flag)&& (USART_RX_BUF[0]=='F')&& (USART_RX_BUF[1]=='1'))
  415.                                                         {    State_Flag1=1;
  416.                                                                       *Fix_Flag=0;
  417.                                                                       Fixed_Buf3[0]=USART_RX_BUF[2];
  418.                                                                       Fixed_Buf3[1]=USART_RX_BUF[3];
  419.                                                                       Fixed_Buf3[3]=USART_RX_BUF[5];
  420.                                                                       Fixed_Buf3[4]=USART_RX_BUF[6];
  421.                                                                       Fixed_Buf3[6]=USART_RX_BUF[8];
  422.                                                                       Fixed_Buf3[7]=USART_RX_BUF[9];
  423.                                                                       // if(GPIO_ReadOutputDataBit(GPIOB,GPIO_Pin_10)==1)
  424.                                                                       // {  // Write_LCD1602_Instruction_Com(0x80);
  425.                                                                                     // Write_LCD1602_Instruction_Data('F');
  426.                                                                                     // for(m=0;m<8;m++)
  427.                                                                                     // {              // Write_LCD1602_Instruction_Com(0xC0+m);
  428.                             // Write_LCD1602_Instruction_Data(Fixed_Buf3[m]);                            // }   // }              }
  429.               // if(Strcmp(USART_RX_BUF,F_Now_1) == 0)
  430.               // {              // LED1(OFF);
  431.                             // if( GPIO_ReadOutputDataBit (GPIOB, GPIO_Pin_1)==1)               // LED2(ON);  // }
  432.               /*定时开启2号灯*/                                         
  433.               if(Strcmp(USART_RX_BUF,Fixed_2_On) > 0)
  434.                             if((*Fix_Flag)&& (USART_RX_BUF[0]=='N')&& (USART_RX_BUF[1]=='2'))
  435.                                                         {   State_Flag2=1;
  436.                                                                       *Fix_Flag=0;
  437.                                                                       Fixed_Buf2[0]=USART_RX_BUF[2];
  438.                                                                       Fixed_Buf2[1]=USART_RX_BUF[3];
  439.                                                                       Fixed_Buf2[3]=USART_RX_BUF[5];
  440.                                                                       Fixed_Buf2[4]=USART_RX_BUF[6];
  441.                                                                       Fixed_Buf2[6]=USART_RX_BUF[8];
  442.                                                                       Fixed_Buf2[7]=USART_RX_BUF[9];
  443.                                                                       // if(GPIO_ReadOutputDataBit(GPIOB,GPIO_Pin_10)==0)
  444.                                                                       // {  // Write_LCD1602_Instruction_Com(0x8f);
  445.                                                                                     // Write_LCD1602_Instruction_Data('N');
  446.                                                                                     // for(m=0;m<8;m++)
  447.                                                                                     // {   // Write_LCD1602_Instruction_Com(0xC8+m);
  448.                                                                                     //Write_LCD1602_Instruction_Data(Fixed_Buf2[m]);//    // }   }
  449.               // if(Strcmp(USART_RX_BUF,N_Now_2) == 0)
  450.               // {   // LED2(ON);
  451.                             // if( GPIO_ReadOutputDataBit (GPIOB, GPIO_Pin_0)==0)               // LED1(OFF);   // }
  452.               /*定时关闭2号灯*/                                         
  453.               if(Strcmp(USART_RX_BUF,Fixed_2_Off) > 0)
  454.                             if((*Fix_Flag) && (USART_RX_BUF[0]=='F')&& (USART_RX_BUF[1]=='2'))
  455.                                                         {   State_Flag2=1;
  456.                                                                       *Fix_Flag=0;
  457.                                                                       Fixed_Buf4[0]=USART_RX_BUF[2];
  458.                                                                       Fixed_Buf4[1]=USART_RX_BUF[3];
  459.                                                                       Fixed_Buf4[3]=USART_RX_BUF[5];
  460.                                                                       Fixed_Buf4[4]=USART_RX_BUF[6];
  461.                                                                       Fixed_Buf4[6]=USART_RX_BUF[8];
  462.                                                                       Fixed_Buf4[7]=USART_RX_BUF[9];
  463.                                                                       // if(GPIO_ReadOutputDataBit(GPIOB,GPIO_Pin_10)==1)
  464.                                                                       // {  // Write_LCD1602_Instruction_Com(0x8f);
  465.                                                                                     // Write_LCD1602_Instruction_Data('F');
  466.                                                                                     // for(m=0;m<8;m++)
  467.                                                                                     // {   // Write_LCD1602_Instruction_Com(0xC8+m);
  468.                                                         // Write_LCD1602_Instruction_Data(Fixed_Buf4[m]);  // }                // }              // }                                                        // if(Strcmp(USART_RX_BUF,F_Now_2) == 0)
  469.               // {                // LED2(OFF);
  470.                   // if( GPIO_ReadOutputDataBit (GPIOB, GPIO_Pin_0)==1)  // LED1(ON);   }   }
  471.               void Control(void)
  472. {    if(State_Flag1==1)
  473.                             if(Strcmp(Fixed_Buf1,Time) == 0)
  474.                                           {    LED1(ON);              //State_Flag1=0;   }
  475.               if(State_Flag1==1)
  476.                             if(Strcmp(Fixed_Buf3,Time) == 0)
  477.                                           { LED1(OFF);              //State_Flag1=0; }                                                                                   
  478.               if(State_Flag2==1)
  479.                             if(Strcmp(Fixed_Buf2,Time) == 0)
  480.                                           {              LED2(ON);              //State_Flag2=0;              }
  481. if(State_Flag2==1)
  482.                             if(Strcmp(Fixed_Buf4,Time) == 0)
  483.                                           {   LED2(OFF);              //State_Flag2=0;                            }                                          }
  484. void Control_Now(void)
  485. {    /*实时开启关闭1号LED*/
  486.               if(((Strcmp(USART_RX_BUF,Led1) == 0)||(Strcmp(USART_RX_BUF,Led1) > 0))&& (Control_Flag1)&&(USART_RX_BUF[0]=='L')&&(USART_RX_BUF[1]=='1'))
  487.               {              Control_Flag1=0;
  488.                             Control_Flag2=0;
  489. GPIO_WriteBit(GPIOC,GPIO_Pin_6,(BitAction)((1-GPIO_ReadOutputDataBit(GPIOC,GPIO_Pin_6))));   }
  490.               // /*实时关闭1号LED*/
  491.               // else if(Strcmp(USART_RX_BUF,F_Now_1) == 0)
  492.               // {                // LED1(OFF);       // }
  493.               // /*实时开启2号LED*/
  494.               // else if(Strcmp(USART_RX_BUF,N_Now_2) == 0)
  495.               // {              // LED2(ON);   // }
  496.               /*实时开启关闭2号LED*/
  497.               else if(((Strcmp(USART_RX_BUF,Led2) == 0)||(Strcmp(USART_RX_BUF,Led2) > 0))&& (Control_Flag2)&&(USART_RX_BUF[0]=='L')&&(USART_RX_BUF[1]=='2'))
  498.               {              Control_Flag1=0;                Control_Flag2=0;
  499.               GPIO_WriteBit(GPIOC,GPIO_Pin_7,(BitAction)((1-GPIO_ReadOutputDataBit(GPIOC,GPIO_Pin_7))));  }  }
  500. ……………………

  502. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
基于STM32的智能路灯控制系统.docx (182.59 KB, 下载次数: 239)

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

使用道具 举报

沙发
ID:623630 发表于 2019-10-14 09:09 | 只看该作者
我也用过stm32的单片机，这个芯片是厂家做的，各功能引脚，芯片已经定义好了，怎么画电路图仿真啊？
回复

使用道具 举报

板凳
ID:628371 发表于 2020-5-10 18:04 | 只看该作者
我用51做过，这个挺好的
回复

使用道具 举报

地板
ID:780937 发表于 2020-6-22 13:42 | 只看该作者
有仿真吗
回复

使用道具 举报

5#
ID:961446 发表于 2021-8-20 09:20 | 只看该作者
你好，你这个STM32的智能路灯这个有没有仿真图啊
回复

使用道具 举报

6#
ID:757488 发表于 2022-1-24 09:40 | 只看该作者
有没有仿真图
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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