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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 住宅小区汽车超速检测及报警系统设计(单片机源码+图+报 ...
返回列表 发新帖
查看: 4826|回复: 1
打印 上一主题 下一主题
收起左侧

住宅小区汽车超速检测及报警系统设计(单片机源码+图+报告)

[复制链接]
跳转到指定楼层
楼主
ID:334647 发表于 2018-5-21 09:38 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
“宏晶杯单片机大赛”设计报告—4、 住宅小区汽车超速检测及报警系统

一、参赛题目
住宅小区汽车超速检测及报警系统
（1）基本要求
速度检测与显示
速度报警值设定
环境气象参数的显示
（2）拓展功能自行考虑
二、方案比较及确定
依据题目基本要求:速度的检测与显示，速度报警值的设定以及环境气象参数的显示。团队以此作为基本要求展开设计，经过讨论以及程序的执行情况，确定以下功能，其中包括基本功能模块和拓展功能模块。

（1）基本功能
常用显示:温度、湿度以及通过薄膜键盘设定速度报警值。
测速及报警显示:测速时采用光电开关进行测量，通过测量汽车经过两个光电门之间的时间，运用基本的物理速度公式：V=s/t 进而获得汽车的速度。如果汽车超速则 12864 将显示时速并出现提醒超速标语，同时蜂鸣报警响起,LED灯亮起。
（2）拓展功能
初始化显示:在电源供电之后，12864 将出现第一个界面，界面上显示“欢迎使用小区车速检测系统，请输入限定时速：”的标语。
常用显示:在利用薄膜键盘输入限定时速按下确认键， 12864 将出现第二个界面，其中包括基本显示项目:万年历、日期、温度、湿度以及速度报警值。
测速及报警显示:在汽车超速之后不仅会显示超速和标语，同时报警蜂鸣响起，报警系统与小区监控摄像连接为一体，在显示超速的同时会利用
监控抓拍车牌号，并做及时的记录。

路灯控制:考虑到小区人们的出行， 在15 上增加了对路灯控制的模块，在每天的 19:30-00:30 路灯会自动亮起。同时兼顾每位居民的不同的作息时间，在路灯亮起的这段时间内如果检测到有超速的情况则蜂鸣警报声不会响起，
只会在显示屏上显示超速并且LED 灯闪烁来替代警报声，同时抓拍车牌号。深夜模式:在00:30 分之后，路灯熄灭，此时如果有人或者车经过时，声控开关会控制路灯再次点亮 10s,同时测速报警系统也会启动。在到达凌晨4 点 30 分之后，深夜模式关闭。既方便小区人们的出行又达到了节能减排的效果。
噪声检测:通过检测周围环境的噪声，如果检测到噪音，则通过点
亮LED 灯来显示噪声检测结果。

三、理论数据分析
此测速报警系统是通过测量汽车经过两个光电门之间的时间， 设定两个光电门之间的距离为  s 10cm .编写程序时将延时时间设定为1ms， 每经过 1ms则检测一次车头是否到达第二个光电门， 同时计时，如果到达则计时结束，得到车头经过两个光电门所用时间t ，之后运用基本的物理速度公式：
v=s/t 进而获得汽车的速度。

四、软件设计
根据STC15单片机的 O I / 端口的数目以及功能要求软件程
序如下：（具体程序详见附录）
1、薄膜键盘输入程序模块
2、12864程序模块
3、路灯控制程序模块
4、蜂鸣报警程序模块
5、深夜模式程序模块
6、噪音检测程序模块
五、流程图
1、测速功能流程图


2、路灯控制功能流程图


六、电路图及相关设计文件


所用软件：proteus 电路仿真软件
七、比赛器件
STC15 单片机、薄膜键盘、12864 液晶显示屏、温湿度传感器DHT11、时间显示 DS1302、噪音检测器、光电门等。

八、测试数据及结果分析
1、 此报警系统不仅能够测定速度，通过测定车头通过两个光电门所用时间 t,利用物理公式v=s/t 判断是否超速。
2、 通过温湿度传感器测量周围环境的环境参数， 并显示在12864显示屏的第三行。
3、通过噪音传感器测量噪音系数，根据系数大小判断是否点亮噪音显示灯。

九、总结
此次大赛我们选中了“小区测速报警系统”的题目，这个命题十分贴近我们的日常生活， 真正的将平时在课本上所学习的有关单片机的知识运用到实践中，在技术设计中更多地要考虑的是实用性，合理性。而且，平时我们大多数用的单片机都是 51 系列，此次大赛要求我们应用 15 系列，这又是一次锻炼我们的机会，掌握了更多型号的单片机的使用方法。在设计中，向 15 单片机上转化是一项很大的考验，通过几天的努力我们终于让程序在 15 上正常运行，这次比赛让我们的专业知识储备更加丰富， 也在实践中应用了所学， 受益匪浅。


附录：
15单片机设计程序及注释

单片机源程序如下:
  1. #include<reg52.h>
  2. #include<intrins.h>
  3. #define uchar unsigned char
  4. #define uint  unsigned int
  5. #define LCD_data  P0
  6. #define delayNOP(); {_nop_();_nop_();_nop_();_nop_();};
  7. #define MAIN_Fosc                11059200UL        //
  8. #define DS1302_W_ADDR 0x80  //
  9. #define DS1302_R_ADDR 0x81        //

  11. sbit buzzer = P2^3;//蜂鸣器报警
  12. sbit voice = P3^0; //鸣笛检测输出
  13. sbit led6 = P1^5; //        灯光报警
  14. sbit led5 = P1^4;//鸣笛检测灯光示意

  16. sbit TSCLK = P1^0;
  17. sbit TIO = P1^1;   
  18. sbit TRST = P1^2;
  19. sbit streetlight = P1^7;//路灯
  20. sbit LCD_RS  =  P3^5;//
  21. sbit LCD_RW  =  P3^6;//
  22. sbit LCD_EN  =  P3^4; //
  23. sbit LCD_PSB =  P3^7;
  24. sbit wela = P2^7;
  25. sbit dula = P2^6;

  27. sbit DQ=P2^2;    //DTH11
  28. uint vtest= 0;
  29. uint t = 0;
  30. uchar vlim = 0;
  31. v_test[3] = {0,0,0};
  32. v_lim[3] = {0,0,0};
  33. uchar flag,flag0,flag1,flag2,flag4,flag5,flag6= 0;
  34. uchar flag3 = 1;
  35. uchar flag7 = 1;
  36. uchar weed,x;
  37. uchar tem = 0;
  38. uchar hum = 0;
  39. display0[2]={0,0};
  40. display1[2]={0,0};        
  41. uchar code init1[] = {"  欢迎使用小区  "};
  42. uchar code init2[] = {"  车速检测系统  "};
  43. uchar code init3[] = {"请输入小区限速: "};
  44. uchar code init4[] = {"    km/h        "};
  45. uchar code warning1[] = {"车速: 020km/h   "};
  46. uchar code warning2[] = {"您已超速, 为了  "};
  47. uchar code warning3[] = {"您和他人的安全  "};
  48. uchar code warning4[] = {"请减速慢行      "};
  49. uchar code slogan1[] = {"    文明礼让    "};
  50. uchar code slogan2[] = {"    有序通行    "};
  51. uchar code slogan3[] = {"    互相体谅    "};
  52. uchar code slogan4[] = {"    请勿鸣笛    "};
  53. uchar code dis1[]= {"20  年  月  日 "};
  54. uchar code dis2[]= {"星期    :   :   "};
  55. uchar code dis3[] = {"温度26℃湿度30%"};
  56. uchar code dis4[] = {"限速:     km/h  "};



  60. void delay(uint ms)
  61. {
  62.     while(ms--)
  63.         {
  64.       uchar i;
  65.           for(i=0;i<250;i++)  
  66.            {
  67.             _nop_();                           
  68.                 _nop_();
  69.                 _nop_();
  70.                 _nop_();
  71.            }
  72.         }
  73. }               

  75. /*******************************************************************/
  76. /*                                                                 */
  77. /*检查LCD忙状态                                                    */
  78. /*lcd_busy为1时，忙，等待。lcd-busy为0时,闲，可写指令与数据。      */
  79. /*                                                                 */
  80. /*******************************************************************/
  81. bit lcd_busy()
  82. {                          
  83.     bit result;
  84.     LCD_RS = 0;
  85.     LCD_RW = 1;
  86.     LCD_EN = 1;
  87.     delayNOP();
  88.     result = (bit)(P0&0x80);
  89.     LCD_EN = 0;
  90.     return(result);
  91. }
  92. /*******************************************************************/
  93. /*                                                                 */
  94. /*写指令数据到LCD                                                  */
  95. /*RS=L，RW=L，E=高脉冲，D0-D7=指令码。                             */
  96. /*                                                                 */
  97. /*******************************************************************/
  98. void lcd_wcmd(uchar cmd)
  99. {                          
  100.    while(lcd_busy());
  101.     LCD_RS = 0;
  102.     LCD_RW = 0;
  103.     LCD_EN = 0;
  104.     _nop_();
  105.     _nop_();
  106.     P0 = cmd;
  107.     delayNOP();
  108.     LCD_EN = 1;
  109.     delayNOP();
  110.     LCD_EN = 0;  
  111. }
  112. /*******************************************************************/
  113. /*                                                                 */
  114. /*写显示数据到LCD                                                  */
  115. /*RS=H，RW=L，E=高脉冲，D0-D7=数据。                               */
  116. /*                                                                 */
  117. /*******************************************************************/
  118. void lcd_wdat(uchar dat)
  119. {                          
  120.    while(lcd_busy());
  121.     LCD_RS = 1;
  122.     LCD_RW = 0;
  123.     LCD_EN = 0;
  124.     P0 = dat;
  125.     delayNOP();
  126.     LCD_EN = 1;
  127.     delayNOP();
  128.     LCD_EN = 0;
  129. }
  130. /*******************************************************************/
  131. /*                                                                 */
  132. /*  LCD初始化设定                                                  */
  133. /*                                                                 */
  134. /*******************************************************************/
  135. void lcd_init()
  136. {

  138.    
  139.      LCD_PSB = 1;
  140.     lcd_wcmd(0x34);      //扩充指令操作
  141.     delay(5);
  142.     lcd_wcmd(0x30);      //基本指令操作
  143.     delay(5);
  144.     lcd_wcmd(0x0C);      //显示开，关光标
  145.     delay(5);
  146.     lcd_wcmd(0x01);      //清除LCD的显示内容
  147.     delay(5);
  148. }


  151. #define MAIN_Fosc                11059200UL        //宏定义主时钟HZ
  152. #define DS1302_W_ADDR 0x80  //写时钟日历寄存器起始地址
  153. #define DS1302_R_ADDR 0x81        //读时钟日历寄存器起始地址

  155. //时钟日历暂存数组，秒、分、时、日、月、周、年 初值为= 16年6月4日 周六 19:29:50
  156. uchar TimeData[7]={0, 29, 19, 4, 6, 6, 16};

  158. /*=================================================
  159. *函数名称：Delay_Ms
  160. *函数功能：12T 51单片机自适应主时钟毫秒级延时函数
  161. *说明：需定义MAIN_Fosc（晶振主频单位HZ）
  162. *输入：ms：要延时的毫秒
  163. =================================================*/
  164. void Delay_Ms(uint ms)
  165. {
  166.      uint i;
  167.          do{
  168.               i = MAIN_Fosc / 96000;
  169.                   while(--i);   //96T per loop
  170.      }while(--ms);
  171. }
  172. /*=================================================
  173. *函数名称：DS1302_W_Byte
  174. *函数功能：DS1302写一字节数据
  175. *输入：dat：要写入的数据
  176. =================================================*/
  177. void DS1302_W_Byte(uchar dat)
  178. {
  179.         uchar i;
  180.         for(i = 0; i < 8; i++) //每次写1bit，写8次
  181.         {
  182.                 TSCLK = 0;                   //拉低时钟总线
  183.                 TIO = dat & 0x01;  //从一字节最低位开始写
  184.                 TSCLK = 1;                   //拉高时钟总线，DS1302把数据读走
  185.                 dat >>= 1;                   //数据右移一位
  186.         }        
  187. }
  188. /*=================================================
  189. *函数名称：DS1302_R_Byte
  190. *函数功能：DS1302读一字节
  191. *输出：dat：读取的数据
  192. =================================================*/
  193. uchar DS1302_R_Byte()
  194. {
  195.         uchar i, dat;
  196.         for(i = 0; i < 8; i++)  //每次写1bit，写8次
  197.         {
  198.                 TSCLK = 0;                        //拉低时钟总线，DS1302把数据放到数据总线上
  199.                 dat >>= 1;                         //数据右移一位，数据从最低位开始读
  200.                 if(TIO)        dat |= 0x80;//读取数据
  201.                 TSCLK = 1;                        //拉高时钟总线
  202.         }
  203.         return dat;                                //返回读取的数据
  204. }
  205. /*=================================================
  206. *函数名称：DS1302_W_DAT
  207. *函数功能：写DS1302数据一次写2个字节
  208. *说明：先写命令后写数据
  209. *调用：DS1302_W_Byte()
  210. *输入：cmd：需要写的命令 ，dat：需要些的数据
  211. =================================================*/
  212. void DS1302_W_DAT(uchar cmd, uchar dat)
  213. {
  214.         TRST = 0;                         //拉低使能端
  215.         TSCLK = 0;                         //拉低数据总线
  216.         TRST = 1;                         //拉高使能端，开始写数据
  217.         DS1302_W_Byte(cmd);         //写命令
  218.         DS1302_W_Byte(dat);         //写数据
  219. }
  220. /*=================================================
  221. *函数名称：DS1302_R_DAT
  222. *函数功能：读DS1302数据
  223. *说明：先写入命令字节后读出对应数据
  224. *调用：        DS1302_W_Byte();DS1302_R_Byte();
  225. *输入：        cmd：需要写的命令
  226. *输出：        dat：读出的数据
  227. =================================================*/
  228. uchar DS1302_R_DAT(uchar cmd)
  229. {
  230.         uchar dat;
  231.         TRST = 0;                                 //拉低使能端
  232.         TSCLK = 0;                                //拉低数据总线
  233.         TRST = 1;                                //拉高使能端，开始写数据
  234.         DS1302_W_Byte(cmd);                //写命令
  235.         dat = DS1302_R_Byte();        //读出数据
  236.         return dat;                                //返回读出数据
  237. }

  239. /*=================================================
  240. *函数名称：DS1302_Clear_WP
  241. *函数功能：清除DS1302写保护
  242. *说明：先写入命令0x8e（写控制寄存器）接着向该寄存器写0
  243. *调用：DS1302_W_DAT()
  244. =================================================*/
  245. void DS1302_Clear_WP()
  246. {
  247.         DS1302_W_DAT(0x8e,0x00);  //把控制寄存器WP位置0
  248. }
  249. /*=================================================
  250. *函数名称：DS1302_Clear_WP
  251. *函数功能：设置DS1302写保护
  252. *说明：先写入命令0x8e（写控制寄存器）接着向该寄存器写0x80
  253. *调用：DS1302_W_DAT()
  254. =================================================*/
  255. void DS1302_Set_WP()
  256. {        
  257.         DS1302_W_DAT(0x8e,0x80); //把控制寄存器WP位置1
  258.         TRST = 0;                                 //拉低使能端
  259.         TSCLK = 0;                                 //拉低数据总线
  260. }
  261. /*=================================================
  262. *函数名称：Set_DS1302_Time
  263. *函数功能：设置DS1302时钟日历数据
  264. *说明：把时钟日历暂存数组TimeData数据转换为BCD码并
  265.            写入到DS1302时钟日历寄存器中
  266. *调用：DS1302_Clear_WP();DS1302_W_DAT();DS1302_Set_WP();
  267. *输入：addr:需要写入寄存器的地址 ，TimeData数组：时钟日历初始值
  268. =================================================*/
  269. void Set_DS1302_Time(uchar addr)
  270. {
  271.         uchar i, j;
  272.         DS1302_Clear_WP();                //清除写保护
  273.         for(i = 0; i < 7; i++)        //写入7个字节的时钟初始值
  274.         {
  275.                 j = TimeData[i]/10;         //BCD码转换
  276.                 TimeData[i] %= 10;         //BCD码转换
  277.                 TimeData[i] += j*16; //BCD码转换
  278.                 DS1302_W_DAT(addr, TimeData[i]); //先写DS1302时钟日历起始地址，再写数据
  279.                 addr += 2;         //时钟日历寄存器地址+2转向下一个寄存器
  280.         }
  281.         DS1302_Set_WP(); //开起写保护               
  282. }
  283. /*=================================================
  284. *函数名称：Read_DS1302_Time
  285. *函数功能：读取DS1302时钟数据
  286. *说明：        读取DS1302时钟数据 返回数据存入时钟日历暂存
  287.                 数组TimeData（数据格式BCD码）
  288. *调用：DS1302_Clear_WP();DS1302_R_DAT();DS1302_Set_WP();
  289. *输入：        addr：需要读取时钟日历寄存器的起始地址
  290. =================================================*/
  291. void Read_DS1302_Time(uchar addr)
  292. {
  293.         uchar i;
  294.         DS1302_Clear_WP();            //清楚些保护
  295.         for(i = 0; i < 7; i++)        //从DS1302读取7个字节的时钟日历数据
  296.         {
  297.                 TimeData[i] = DS1302_R_DAT(addr);//先写入要读取数据的寄存器起始地址，再读出数据存入TimeData数组
  298.                 addr += 2;                                                 //时钟日历寄存器地址+2转向下一个寄存器
  299.         }
  300.         DS1302_Set_WP();   //开起写保护
  301. }



  305. void init()
  306. {
  307.         
  308.         TMOD = 0x01;  //定时器16位计数工作模式
  309.         TH0 =0xfc;
  310.         TL0 =0x66; //1ms定时
  311.         EX0 = 1; //开外部中断0
  312.     IT0 = 1; //负跳变触发
  313.         EX1 = 1; //开外部中断1
  314.     IT1 = 1; //负跳变触发
  315.     EA = 1; //开总中断

  317. }



  321. uchar KeyScan()        //带返回值的子函数
  322. {
  323.         uchar cord_l = 0,cord_h = 0;//声明列线和行线的值的储存变量
  324.         P0 = 0xf0;//1111 0000
  325.         if( (P0 & 0xf0) != 0xf0)//判断是否有按键按下
  326.         {
  327.                 delay(20);//软件消抖
  328.                 if( (P0 & 0xf0) != 0xf0)//判断是否有按键按下
  329.                 {     flag0 = 1;
  330.                           cord_l = P0 & 0xf0;// 储存列线值
  331.                           P0 = cord_l | 0x0f;
  332.                           cord_h = P0 & 0x0f;// 储存行线值
  333.                           while( (P0 & 0x0f) != 0x0f );//松手检测
  334.                           return (cord_l + cord_h);//返回键值码
  335.                 }        
  336.         }
  337.                
  338. }

  340. void input_bai()
  341. {
  342.         switch( KeyScan() )
  343.         {
  344.                  case 0xd7: v_lim[0] = 0;            break;
  345.                 case 0xee: v_lim[0] = 1;                break;
  346.                 case 0xde: v_lim[0] = 2;                break;
  347.                 case 0xbe: v_lim[0] = 3;                break;
  348.                 case 0xed: v_lim[0] = 4;                break;
  349.                 case 0xdd: v_lim[0] = 5;                break;
  350.                 case 0xbd: v_lim[0] = 6;                break;
  351.             case 0xeb: v_lim[0] = 7;                break;
  352.                 case 0xdb: v_lim[0] = 8;                break;
  353.                 case 0xbb: v_lim[0] = 9;            break;
  354.                
  355.                
  356.         }        
  357. }
  358. void input_shi()
  359. {
  360.         switch( KeyScan() )
  361.         {
  362.                  case 0xd7: v_lim[1] = 0;            break;
  363.                 case 0xee: v_lim[1] = 1;                break;
  364.                 case 0xde: v_lim[1] = 2;                break;
  365.                 case 0xbe: v_lim[1] = 3;                break;
  366.                 case 0xed: v_lim[1] = 4;                break;
  367.                 case 0xdd: v_lim[1] = 5;                break;
  368.                 case 0xbd: v_lim[1] = 6;                break;
  369.             case 0xeb: v_lim[1] = 7;                break;
  370.                 case 0xdb: v_lim[1] = 8;                break;
  371.                 case 0xbb: v_lim[1] = 9;            break;
  372.                
  373.                
  374.         }        
  375. }
  376. void input_ge()
  377. {
  378.         switch( KeyScan() )
  379.         {
  380.                  case 0xd7: v_lim[2] = 0;            break;
  381.                 case 0xee: v_lim[2] = 1;                break;
  382.                 case 0xde: v_lim[2] = 2;                break;
  383.                 case 0xbe: v_lim[2] = 3;                break;
  384.                 case 0xed: v_lim[2] = 4;                break;
  385.                 case 0xdd: v_lim[2] = 5;                break;
  386.                 case 0xbd: v_lim[2] = 6;                break;
  387.             case 0xeb: v_lim[2] = 7;                break;
  388.                 case 0xdb: v_lim[2] = 8;                break;
  389.                 case 0xbb: v_lim[2] = 9;            break;
  390.                
  391.                
  392.         }        
  393. }


  396. bit Init_DTH11()
  397. {
  398. bit flag;
  399. uchar num;
  400. DQ=0;
  401. delay(19);   // >18ms
  402. DQ=1;
  403. for(num=0;num<10;num++);   //
  404. for(num=0;num<12;num++);
  405. flag=DQ;
  406. for(num=0;num<11;num++);
  407. for(num=0;num<24;num++);   
  408. return flag;
  409. }

  411. uchar DTH11_RD_CHAR()
  412. {
  413. uchar byte=0;
  414. uchar num;
  415. uchar num1;
  416. while(DQ==1);
  417. for(num1=0;num1<8;num1++)
  418. {
  419.   while(DQ==0);
  420.   byte<<=1;     //
  421.   for(num=0;DQ==1;num++);
  422.   if(num<10)
  423.    byte|=0x00;
  424.   else
  425.    byte|=0x01;
  426. }
  427. return byte;
  428. }

  430. void  DTH11_DUSHU()
  431. {
  432. uchar num;
  433. if(Init_DTH11()==0)
  434. {
  435.   hum=DTH11_RD_CHAR();   //
  436.   DTH11_RD_CHAR();
  437.   tem=DTH11_RD_CHAR();
  438.   DTH11_RD_CHAR();
  439.   DTH11_RD_CHAR();
  440.   for(num=0;num<17;num++);  //
  441.   DQ=1;
  442. }
  443. }
  444. void Display_DTH11()  
  445. {
  446. display0[0]=hum/10%10;
  447. display0[1]=hum%10;
  448. lcd_wcmd(0x8e);
  449. for(x=0;x<2;x++)
  450. lcd_wdat(display0[0+x]);//显示湿度
  451. display1[0]=tem/10%10;
  452. display1[1]=tem%10;
  453. lcd_wcmd(0x8a);
  454. for(x=0;x<2;x++)
  455. lcd_wdat(display1[0+x]);//显示温度
  456. }
  457. void main()
  458. {         wela = 0;
  459.            dula = 0;
  460.           Init_DTH11();                 
  461.           lcd_init();//12864初始化               
  462.             init();//定时器初始化
  463.                 Set_DS1302_Time(DS1302_W_ADDR);
  464.                 lcd_wcmd(0x80);                        
  465.         for(x=0;x<16;x++)
  466.                 lcd_wdat(init1[x]);
  467.         lcd_wcmd(0x90);                        
  468.         for(x=0;x<16;x++)
  469.                 lcd_wdat(init2[x]);
  470.         
  471.         lcd_wcmd(0x88);
  472.         for(x=0;x<16;x++)
  473.                 lcd_wdat(init3[x]);
  474.         lcd_wcmd(0x98);
  475.         for(x=0;x<16;x++)
  476.                 lcd_wdat(init4[x]);  //显示初始界面  
  477.         

  479.                     
  480.                
  481.                         
  482.            
  483.      
  484.         while(1)
  485.         {
  486.                 input_bai();
  487.                 if(flag0)
  488.                 {
  489.                         flag0 = 0;
  490.                         lcd_wcmd(0x98);
  491.                         for(x=0;x<1;x++)
  492.                         lcd_wdat(v_lim[0+x]+ '0');
  493.                         break;
  494.                 }
  495.         }
  496.         
  497.         while(1)
  498.         {
  499.                 input_shi();
  500.                 if(flag0)
  501.                 {
  502.                         flag0 = 0;
  503.                         lcd_wcmd(0x98);
  504.                         for(x=0;x<2;x++)
  505.                         lcd_wdat(v_lim[0+x]+ '0');
  506.                         break;
  507.                 }
  508.         }
  509.         
  510.         while(1)
  511.         {
  512.                 input_ge();
  513.                 if(flag0)
  514.                 {
  515.                         flag0 = 0;
  516.                         lcd_wcmd(0x99);
  517.                         
  518.                         lcd_wdat(v_lim[2]+ '0');
  519.                
  520.                         }
  521.          if (KeyScan() == 0x7e)
  522.                 {         
  523.                 vlim = v_lim[0]*100+v_lim[1]*10+v_lim[2];
  524.                
  525.                 break;
  526.                   }         
  527.                
  528.                
  529.         }
  530.      

  532. while(1)  
  533. {        delay(5);
  534.          lcd_wcmd(0x01);
  535.                   delay(5);
  536.                    lcd_wcmd(0x80);                        
  537.                 for(x=0;x<16;x++)
  538.                         lcd_wdat(dis1[x]);
  539.                 lcd_wcmd(0x90);                        
  540.                 for(x=0;x<16;x++)
  541.                         lcd_wdat(dis2[x]);
  542.                
  543.                 lcd_wcmd(0x88);
  544.                 for(x=0;x<16;x++)
  545.                         lcd_wdat(dis3[x]);
  546.                 lcd_wcmd(0x98);
  547.                 for(x=0;x<16;x++)
  548.                           lcd_wdat(dis4[x]);
  549.          while(flag3)
  550.         {        
  551.                   Read_DS1302_Time(DS1302_R_ADDR);//
  552.                  delay(5);
  553.                 lcd_wcmd(0x81);
  554.                 lcd_wdat(TimeData[6]/16 + '0');
  555.                 lcd_wdat(TimeData[6]%16 + '0');//year
  556.                 delay(5);
  557.                 lcd_wcmd(0x83);
  558.                 lcd_wdat(TimeData[4]/16 + '0');
  559.                 lcd_wdat(TimeData[4]%16 + '0');//month
  560.                 delay(5);
  561.                 lcd_wcmd(0x85);
  562.                 lcd_wdat(TimeData[3]/16 + '0');
  563.                 lcd_wdat(TimeData[3]%16 + '0');//day
  564.                 delay(5);
  565.                   lcd_wcmd(0x92);
  566.                 lcd_wdat(TimeData[5]%16 + '0');//weed
  567.                   delay(20);
  568.                 lcd_wcmd(0x93);
  569.                 lcd_wdat(TimeData[2]/16 + '0');
  570.                 lcd_wdat(TimeData[2]%16 + '0');//hour
  571.                 delay(5);
  572.                 lcd_wcmd(0x95);
  573.                 lcd_wdat(TimeData[1]/16 + '0');
  574.                 lcd_wdat(TimeData[1]%16 + '0');//minute
  575.                 delay(5);
  576.                 lcd_wcmd(0x97);
  577.                 lcd_wdat(TimeData[0]/16 + '0');
  578.                 lcd_wdat(TimeData[0]%16 + '0');//second

  580.                 if((TimeData[2] == 0x19)&&(TimeData[1] == 0x30))streetlight = 0;
  581.                 if((TimeData[2] == 0x00)&&(TimeData[1] == 0x30))streetlight = 1;
  582.                 if((TimeData[2] == 0x40)&&(TimeData[1] == 0x00)) flag7 = 0;
  583.                 Delay_Ms(600);
  584.                 DTH11_DUSHU();
  585.                  display0[0]=hum/10%10;
  586.                  display0[1]=hum%10;
  587.                  lcd_wcmd(0x8e);
  588.                  for(x=0;x<2;x++)
  589.                  lcd_wdat(display0[0+x]+'0');//显示湿度
  590.                  display1[0]=tem/10%10;
  591.                  display1[1]=tem%10;
  592.                  lcd_wcmd(0x8a);
  593.                  for(x=0;x<2;x++)
  594.                  lcd_wdat(display1[0+x]+'0');//显示温度
  595.                  lcd_wcmd(0x9b);
  596.                  for(x=0;x<3;x++)
  597.                  lcd_wdat(v_lim[0+x]+'0');
  598.                  while(flag)
  599.                 {   
  600.                          TR0 = 1;
  601.                         if(TF0 == 1)
  602.                         {
  603.                                 TF0 = 0;
  604.                                 TH0 = 0xfc;
  605.                                 TL0 = 0x66; // 定时1ms
  606.                                 t++;
  607.                         }
  608.                 }        
  609.                 if(t > 0)
  610.                 {
  611.                   vtest = 10000/t;//
  612.                         if (vtest > vlim)
  613.                         {
  614.                         
  615.                         v_test[0] = vtest/100;
  616.                         v_test[1] = (vtest/10)-(vtest/100)*10;
  617.                         v_test[2] = vtest%10;
  618.                         flag3 = 0;
  619.                         flag4 = 1;
  620.                         
  621.                         t = 0;
  622.                         vtest = 0;
  623.                         flag = 0;
  624.                         
  625.                 }
  626.                 }
  627.          if(!voice)
  628.          {
  629.            delay(5);
  630.            if(!voice)
  631.            {flag3 = 0;
  632.            flag5 = 1;
  633.           }
  634. }
  635.    
  636.         }        
  637.              if(flag4)
  638.                  {lcd_wcmd(0x01);
  639.                   delay(5);
  640.              lcd_wcmd(0x80);                        
  641.                 for(x=0;x<16;x++)
  642.                         lcd_wdat(warning1[x]);
  643.                 lcd_wcmd(0x90);                        
  644.                 for(x=0;x<16;x++)
  645.                         lcd_wdat(warning2[x]);
  646.                
  647.                 lcd_wcmd(0x88);
  648.                 for(x=0;x<16;x++)
  649.                         lcd_wdat(warning3[x]);
  650.                 lcd_wcmd(0x98);
  651.                 for(x=0;x<16;x++)
  652.                           lcd_wdat(warning4[x]);
  653.                 lcd_wcmd(0x83);
  654.                 for(x=0;x<3;x++)
  655.                 lcd_wdat(v_test[0+x]+'0');                 
  656.                      
  657.                 //Delay_Ms(2000);
  658.                  if(streetlight == 1)
  659.                         { buzzer = 0;
  660.                           Delay_Ms(2000);
  661.                           buzzer = 1;}
  662.                         else
  663.                         {
  664.                           led6 = 0;
  665.                           Delay_Ms(2000);
  666.                           led6=  1;
  667.                          }
  668.                 flag3 = 1;
  669.                   flag4 = 0;
  670.                   
  671.                   }
  672.                   
  673. ……………………

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


所有资料51hei提供下载:
最终工程(51).zip (62.8 KB, 下载次数: 38)
2016年“宏晶杯单片机大赛”设计报告.pdf (460.53 KB, 下载次数: 20)


评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

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

使用道具 举报

沙发
ID:489394 发表于 2023-4-7 10:19 | 只看该作者
附件没有仿真图和原理图呀
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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