找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 1540|回复: 1
打印 上一主题 下一主题
收起左侧

单片机智能窗户程序与Proteus仿真设计 光敏电阻自动控制与时间控制

[复制链接]
跳转到指定楼层
楼主
整个系统以AT89C52单片机为核心器件,配合电阻电容晶振等器件,构成单片机的最小系统。其它个模块围绕着单片机最小系统展开。其中包括,显示设备使用1602液晶,可以同时显示年、月、日、时、分、控制模式、光照强度等基本信息;时钟模块采用DS1302芯片,初始化之后,就会开始运行计算时间,单片机只需进行时间信息的读取即可;光照检测电路采用光敏电阻和模数转换芯片ADC0832,将模拟量数字化并显示出来;窗帘使用步进电机进行代替模拟,同时配有一个LED灯用来指示窗帘当前的开关状态;本设计还有5个按键作为操作输入设备,可以对当前时间进行调整设置和设置窗帘开关时间和光控阈值等;最后是供电采用常用的USB 5V进行供电。智能窗帘控制系统具有以下几个基本功能:  
(1)手动控制:该功能是根据用户的需求通过按键进行窗帘的开关,此功能可以使窗帘的开闭处于任何一种状态;  
(2)光照自动控制:系统可以根据用户设定的光照强度值通过感光器采集光照自动开光窗帘;  
(3)时间控制:此功能是根据用户设定的时间一次性开关窗帘。   
(4)可以通过按键是上面三种控制模式循环切换。

仿真原理图如下(proteus仿真工程文件可到本帖附件中下载)


单片机源程序如下:
  1. #include <reg52.h>
  2. #include <intrins.h>

  3. #define uchar unsigned char                // 以后unsigned char就可以用uchar代替
  4. #define uint  unsigned int                // 以后unsigned int 就可以用uint 代替


  5. sbit ADC_CS     = P1^6;                         // ADC0832的CS引脚
  6. sbit ADC_CLK    = P1^7;                         // ADC0832的CLK引脚
  7. sbit ADC_DAT    = P3^2;                         // ADC0832的DI/DO引脚
  8. sbit SCK_P      = P1^0;                                // 时钟芯片DS1302的SCK管脚
  9. sbit SDA_P      = P1^1;                                // 时钟芯片DS1302的SDA管脚
  10. sbit RST_P      = P1^2;                                // 时钟芯片DS1302的RST管脚
  11. sbit LcdRs_P    = P1^3;       // 1602液晶的RS管脚      
  12. sbit LcdRw_P    = P1^4;       // 1602液晶的RW管脚
  13. sbit LcdEn_P    = P1^5;       // 1602液晶的EN管脚
  14. sbit KeyMode_P  = P3^3;                                // 模式切换
  15. sbit KeySet_P   = P3^4;                                // 设置时间按键
  16. sbit KeySet2_P  = P3^5;                                // 设置时间模式的开关时间和光照控制强度
  17. sbit KeyDown_P  = P3^6;                                // 减按键
  18. sbit KeyUp_P    = P3^7;                                // 加按键
  19. sbit Led_P      = P2^0;                                // 指示灯

  20. uchar gMode=1;                                                                // 1是手动模式,2是时间自动模式,3是亮度自动模式
  21. uchar OpenHour    = 18;                                // 开启窗帘的小时
  22. uchar OpenMinute  = 20;                                // 开启窗帘的分钟
  23. uchar CloseHour   = 10;                                // 关闭窗帘的小时
  24. uchar CloseMinute = 30;                                // 关闭窗帘的分钟
  25. uchar gLight      = 40;                                // 窗帘开关的阈值

  26. uchar code Clock[]={0x10,0x90,0x80,0xc0};                         // 步进电机顺时针旋转数组
  27. uchar code AntiClock[]={0x80,0x90,0x10,0x30};                // 步进电机逆时针旋转数组


  28. uchar code Clock1[]={0x10,0x90,0x80,0xc0};


  29. uchar TimeBuff[7]={17,9,1,6,18,30,40};                                        // 时间数组,默认2017年9月1日,星期五,18:30:40
  30. // TimeBuff[0] 代表年份,范围00-99
  31. // TimeBuff[1] 代表月份,范围1-12
  32. // TimeBuff[2] 代表日期,范围1-31
  33. // TimeBuff[3] 代表星期,范围1-7
  34. // TimeBuff[4] 代表小时,范围00-23
  35. // TimeBuff[5] 代表分钟,范围00-59
  36. // TimeBuff[6] 代表秒钟,范围00-59




  37. /*********************************************************/
  38. // 按键扫描(设置当前时间)
  39. /*********************************************************/
  40. void KeyScanf1()
  41. {
  42.         if(KeySet_P==0)
  43.         {
  44.                 LcdGotoXY(0,13);                                // 显示秒钟的冒号
  45.                 LcdWriteData(':');
  46.                 LcdWriteCmd(0x0f);                        // 启动光标闪烁
  47.                 LcdGotoXY(0,3);                                        // 定位光标到年份闪烁
  48.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  49.                 while(!KeySet_P);                                // 等待按键释放
  50.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  51.                
  52.                 /* 调整年份 */
  53.                 while(1)
  54.                 {
  55.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  56.                         {
  57.                                 if(TimeBuff[0]>0)                                                // 判断年份是否大于0               
  58.                                         TimeBuff[0]--;                                                // 是的话就减去1
  59.                                 LcdGotoXY(0,2);                                                        // 光标定位到年份的位置
  60.                                 LcdPrintNum(TimeBuff[0]);                // 刷新显示改变后的年份
  61.                                 LcdGotoXY(0,3);                                                        // 定位光标到年份闪烁
  62.                                 DelayMs(300);                                                                // 延时0.3秒左右
  63.                         }
  64.                         
  65.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  66.                         {
  67.                                 if(TimeBuff[0]<99)                                        // 判断年份是否小于99
  68.                                         TimeBuff[0]++;                                                // 是的话就加上1
  69.                                 LcdGotoXY(0,2);                                                        // 光标定位到年份的位置
  70.                                 LcdPrintNum(TimeBuff[0]);                // 刷新显示改变后的年份
  71.                                 LcdGotoXY(0,3);                                                        // 定位光标到年份闪烁
  72.                                 DelayMs(300);                                                                // 延时0.3秒左右
  73.                         }
  74.                         
  75.                         if(KeySet_P==0)
  76.                         {
  77.                                 break;
  78.                         }
  79.                 }
  80.                
  81.                 LcdGotoXY(0,6);                                        // 定位光标到月份闪烁
  82.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  83.                 while(!KeySet_P);                                // 等待按键释放
  84.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  85.                         
  86.                 /* 调整月份 */
  87.                 while(1)
  88.                 {
  89.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  90.                         {
  91.                                 if(TimeBuff[1]>1)                                                // 判断月份是否大于1               
  92.                                         TimeBuff[1]--;                                                // 是的话就减去1
  93.                                 LcdGotoXY(0,5);                                                        // 光标定位到月份的位置
  94.                                 LcdPrintNum(TimeBuff[1]);                // 刷新显示改变后的月份
  95.                                 LcdGotoXY(0,6);                                                        // 定位光标到月份闪烁
  96.                                 DelayMs(300);                                                                // 延时0.3秒左右
  97.                         }
  98.                         
  99.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  100.                         {
  101.                                 if(TimeBuff[1]<12)                                        // 判断月份是否小于12
  102.                                         TimeBuff[1]++;                                                // 是的话就加上1
  103.                                 LcdGotoXY(0,5);                                                        // 光标定位到月份的位置
  104.                                 LcdPrintNum(TimeBuff[1]);                // 刷新显示改变后的月份
  105.                                 LcdGotoXY(0,6);                                                        // 定位光标到月份闪烁
  106.                                 DelayMs(300);                                                                // 延时0.3秒左右
  107.                         }
  108.                         
  109.                         if(KeySet_P==0)
  110.                         {
  111.                                 break;
  112.                         }
  113.                 }
  114.                
  115.                 LcdGotoXY(0,9);                                        // 定位光标到日期闪烁
  116.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  117.                 while(!KeySet_P);                                // 等待按键释放
  118.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  119.                
  120.                 /* 调整日期 */
  121.                 while(1)
  122.                 {
  123.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  124.                         {
  125.                                 if(TimeBuff[2]>1)                                                // 判断日期是否大于1               
  126.                                         TimeBuff[2]--;                                                // 是的话就减去1
  127.                                 LcdGotoXY(0,8);                                                        // 光标定位到日期的位置
  128.                                 LcdPrintNum(TimeBuff[2]);                // 刷新显示改变后的日期
  129.                                 LcdGotoXY(0,9);                                                        // 定位光标到日期闪烁
  130.                                 DelayMs(300);                                                                // 延时0.3秒左右
  131.                         }
  132.                         
  133.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  134.                         {
  135.                                 if(TimeBuff[2]<31)                                        // 判断日期是否小于31
  136.                                         TimeBuff[2]++;                                                // 是的话就加上1
  137.                                 LcdGotoXY(0,8);                                                        // 光标定位到日期的位置
  138.                                 LcdPrintNum(TimeBuff[2]);                // 刷新显示改变后的日期
  139.                                 LcdGotoXY(0,9);                                                        // 定位光标到日期闪烁
  140.                                 DelayMs(300);                                                                // 延时0.3秒左右
  141.                         }
  142.                         
  143.                         if(KeySet_P==0)
  144.                         {
  145.                                 break;
  146.                         }
  147.                 }
  148.                
  149.                 LcdGotoXY(0,12);                                // 定位光标到小时闪烁
  150.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  151.                 while(!KeySet_P);                                // 等待按键释放
  152.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  153.                
  154.                
  155.                 /* 调整小时 */
  156.                 while(1)
  157.                 {
  158.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  159.                         {
  160.                                 if(TimeBuff[4]>0)                                                // 判断小时是否大于0
  161.                                         TimeBuff[4]--;                                                // 是的话就减去1
  162.                                 LcdGotoXY(0,11);                                                // 光标定位到小时的位置
  163.                                 LcdPrintNum(TimeBuff[4]);                // 刷新显示改变后的小时
  164.                                 LcdGotoXY(0,12);                                                // 定位光标到小时闪烁
  165.                                 DelayMs(300);                                                                // 延时0.3秒左右
  166.                         }
  167.                         
  168.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  169.                         {
  170.                                 if(TimeBuff[4]<23)                                        // 判断小时是否小于23
  171.                                         TimeBuff[4]++;                                                // 是的话就加上1
  172.                                 LcdGotoXY(0,11);                                                // 光标定位到小时的位置
  173.                                 LcdPrintNum(TimeBuff[4]);                // 刷新显示改变后的小时
  174.                                 LcdGotoXY(0,12);                                                // 定位光标到小时闪烁
  175.                                 DelayMs(300);                                                                // 延时0.3秒左右
  176.                         }
  177.                         
  178.                         if(KeySet_P==0)
  179.                         {
  180.                                 break;
  181.                         }
  182.                 }
  183.                
  184.                 LcdGotoXY(0,15);                                // 定位光标到分钟闪烁
  185.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  186.                 while(!KeySet_P);                                // 等待按键释放
  187.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  188.                
  189.                 /* 调整分钟 */
  190.                 while(1)
  191.                 {
  192.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  193.                         {
  194.                                 if(TimeBuff[5]>0)                                                // 判断分钟是否大于0
  195.                                         TimeBuff[5]--;                                                // 是的话就减去1
  196.                                 LcdGotoXY(0,14);                                                // 光标定位到分钟的位置
  197.                                 LcdPrintNum(TimeBuff[5]);                // 刷新显示改变后的分钟
  198.                                 LcdGotoXY(0,15);                                                // 定位光标到分钟闪烁
  199.                                 DelayMs(300);                                                                // 延时0.3秒左右
  200.                         }
  201.                         
  202.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  203.                         {
  204.                                 if(TimeBuff[5]<59)                                        // 判断分钟是否小于59
  205.                                         TimeBuff[5]++;                                                // 是的话就加上1
  206.                                 LcdGotoXY(0,14);                                                // 光标定位到分钟的位置
  207.                                 LcdPrintNum(TimeBuff[5]);                // 刷新显示改变后的分钟
  208.                                 LcdGotoXY(0,15);                                                // 定位光标到分钟闪烁
  209.                                 DelayMs(300);                                                                // 延时0.3秒左右
  210.                         }
  211.                         
  212.                         if(KeySet_P==0)
  213.                         {
  214.                                 break;
  215.                         }
  216.                 }
  217.                
  218.                 /* 退出前的设置 */
  219.                 LcdWriteCmd(0x0C);                        // 关闭光标闪烁
  220.                 DS1302_Write_Time();                // 把新设置的时间值存入DS1302芯片
  221.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  222.                 while(!KeySet_P);                                // 等待按键释放
  223.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  224.         }
  225. }


  226. /*********************************************************/
  227. // 按键扫描(设置窗帘的动作)
  228. /*********************************************************/
  229. void KeyScanf2()
  230. {
  231.         if(KeySet2_P==0)
  232.         {
  233.                 LcdGotoXY(0,0);                                                                                // 光标定位
  234.                 LcdPrintStr(" OpenTime   :   ");        // 显示第1行内容
  235.                 LcdGotoXY(1,0);                                                                                // 光标定位
  236.                 LcdPrintStr("CloseTime   :   ");        // 显示第2行内容
  237.                 LcdGotoXY(0,10);                                                                        // 光标定位
  238.                 LcdPrintNum(OpenHour);                                                // 显示开启窗帘的小时
  239.                 LcdGotoXY(0,13);                                                                        // 光标定位
  240.                 LcdPrintNum(OpenMinute);                                        // 显示开启窗帘的分钟
  241.                 LcdGotoXY(1,10);                                                                        // 光标定位
  242.                 LcdPrintNum(CloseHour);                                                // 显示关闭窗帘的小时
  243.                 LcdGotoXY(1,13);                                                                        // 光标定位
  244.                 LcdPrintNum(CloseMinute);                                        // 显示关闭窗帘的分钟               
  245.                
  246.                 LcdWriteCmd(0x0f);                                                        // 启动光标闪烁
  247.                 LcdGotoXY(0,11);                                                                // 定位光标
  248.                 DelayMs(10);                                                                                // 延时等待,消除按键按下的抖动
  249.                 while(!KeySet2_P);                                                        // 等待按键释放
  250.                 DelayMs(10);                                                                                // 延时等待,消除按键松开的抖动
  251.                
  252.                 /* 调整开启的小时 */
  253.                 while(1)
  254.                 {
  255.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  256.                         {
  257.                                 if(OpenHour>0)                                                        // 判断小时是否大于0               
  258.                                         OpenHour--;                                                                // 是的话就减去1
  259.                                 LcdGotoXY(0,10);                                                // 光标定位
  260.                                 LcdPrintNum(OpenHour);                        // 刷新显示改变后的小时
  261.                                 LcdGotoXY(0,11);                                                // 定位光标
  262.                                 DelayMs(300);                                                                // 延时0.3秒左右
  263.                         }
  264.                         
  265.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  266.                         {
  267.                                 if(OpenHour<23)                                                        // 判断小时是否小于23
  268.                                         OpenHour++;                                                                // 是的话就加上1
  269.                                 LcdGotoXY(0,10);                                                // 光标定位
  270.                                 LcdPrintNum(OpenHour);                        // 刷新显示改变后的小时
  271.                                 LcdGotoXY(0,11);                                                // 定位光标
  272.                                 DelayMs(300);                                                                // 延时0.3秒左右
  273.                         }
  274.                         
  275.                         if(KeySet2_P==0)
  276.                         {
  277.                                 break;
  278.                         }
  279.                 }
  280.                
  281.                 LcdGotoXY(0,14);                                                                // 定位光标
  282.                 DelayMs(10);                                                                                // 延时等待,消除按键按下的抖动
  283.                 while(!KeySet2_P);                                                        // 等待按键释放
  284.                 DelayMs(10);                                                                                // 延时等待,消除按键松开的抖动
  285.                
  286.                 /* 调整开启的分钟 */
  287.                 while(1)
  288.                 {
  289.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  290.                         {
  291.                                 if(OpenMinute>0)                                                // 判断分钟是否大于0
  292.                                         OpenMinute--;                                                        // 是的话就减去1
  293.                                 LcdGotoXY(0,13);                                                // 光标定位
  294.                                 LcdPrintNum(OpenMinute);                // 刷新显示改变后的分钟
  295.                                 LcdGotoXY(0,14);                                                // 定位光标
  296.                                 DelayMs(300);                                                                // 延时0.3秒左右
  297.                         }
  298.                         
  299.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  300.                         {
  301.                                 if(OpenMinute<59)                                                // 判断分钟是否小于59
  302.                                         OpenMinute++;                                                        // 是的话就加上1
  303.                                 LcdGotoXY(0,13);                                                // 光标定位
  304.                                 LcdPrintNum(OpenMinute);                // 刷新显示改变后的分钟
  305.                                 LcdGotoXY(0,14);                                                // 定位光标
  306.                                 DelayMs(300);                                                                // 延时0.3秒左右
  307.                         }
  308.                         
  309.                         if(KeySet2_P==0)
  310.                         {
  311.                                 break;
  312.                         }
  313.                 }
  314.                
  315.                 LcdGotoXY(1,11);                                                                // 定位光标
  316.                 DelayMs(10);                                                                                // 延时等待,消除按键按下的抖动
  317.                 while(!KeySet2_P);                                                        // 等待按键释放
  318.                 DelayMs(10);                                                                                // 延时等待,消除按键松开的抖动
  319.                
  320.                 /* 调整关闭的小时 */
  321.                 while(1)
  322.                 {
  323.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  324.                         {
  325.                                 if(CloseHour>0)                                                        // 判断小时是否大于0               
  326.                                         CloseHour--;                                                        // 是的话就减去1
  327.                                 LcdGotoXY(1,10);                                                // 光标定位
  328.                                 LcdPrintNum(CloseHour);                        // 刷新显示改变后的小时
  329.                                 LcdGotoXY(1,11);                                                // 定位光标
  330.                                 DelayMs(300);                                                                // 延时0.3秒左右
  331.                         }
  332.                         
  333.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  334.                         {
  335.                                 if(CloseHour<23)                                                // 判断小时是否小于23
  336.                                         CloseHour++;                                                        // 是的话就加上1
  337.                                 LcdGotoXY(1,10);                                                // 光标定位
  338.                                 LcdPrintNum(CloseHour);                        // 刷新显示改变后的小时
  339.                                 LcdGotoXY(1,11);                                                // 定位光标
  340.                                 DelayMs(300);                                                                // 延时0.3秒左右
  341.                         }
  342.                         
  343.                         if(KeySet2_P==0)
  344.                         {
  345.                                 break;
  346.                         }
  347.                 }
  348.                
  349.                 LcdGotoXY(1,14);                                                                // 定位光标
  350.                 DelayMs(10);                                                                                // 延时等待,消除按键按下的抖动
  351.                 while(!KeySet2_P);                                                        // 等待按键释放
  352.                 DelayMs(10);                                                                                // 延时等待,消除按键松开的抖动
  353.                
  354.                 /* 调整关闭的分钟 */
  355.                 while(1)
  356.                 {
  357.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  358.                         {
  359.                                 if(CloseMinute>0)                                                // 判断分钟是否大于0
  360.                                         CloseMinute--;                                                // 是的话就减去1
  361.                                 LcdGotoXY(1,13);                                                // 光标定位
  362.                                 LcdPrintNum(CloseMinute);                // 刷新显示改变后的分钟
  363.                                 LcdGotoXY(1,14);                                                // 定位光标
  364.                                 DelayMs(300);                                                                // 延时0.3秒左右
  365.                         }
  366.                         
  367.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  368.                         {
  369.                                 if(CloseMinute<59)                                        // 判断分钟是否小于59
  370.                                         CloseMinute++;                                                // 是的话就加上1
  371.                                 LcdGotoXY(1,13);                                                // 光标定位
  372.                                 LcdPrintNum(CloseMinute);                // 刷新显示改变后的分钟
  373.                                 LcdGotoXY(1,14);                                                // 定位光标
  374.                                 DelayMs(300);                                                                // 延时0.3秒左右
  375.                         }
  376.                         
  377.                         if(KeySet2_P==0)
  378.                         {
  379.                                 break;
  380.                         }
  381.                 }
  382.                
  383.                 DelayMs(10);                                                                                // 延时等待,消除按键按下的抖动
  384.                 while(!KeySet2_P);                                                        // 等待按键释放
  385.                 DelayMs(10);                                                                                // 延时等待,消除按键松开的抖动
  386.                
  387.                 /* 光照强度的设置 */
  388.                 LcdWriteCmd(0x0C);                                                                // 关闭光标闪烁
  389.                 LcdGotoXY(0,0);                                                                                // 光标定位
  390.                 LcdPrintStr("   Light Set    ");        // 显示第1行内容
  391.                 LcdGotoXY(1,0);                                                                                // 光标定位
  392.                 LcdPrintStr("                ");        // 显示第2行内容
  393.                 LcdGotoXY(1,7);                                                                                // 光标定位
  394.                 LcdPrintNum(gLight);                                                        // 显示窗帘的光线控制强度阈值
  395.                
  396.                 while(1)
  397.                 {
  398.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  399.                         {
  400.                                 if(gLight>0)                                                                // 判断光线阈值是否大于0
  401.                                         gLight--;                                                                        // 是的话就减去1
  402.                                 LcdGotoXY(1,7);                                                        // 光标定位
  403.                                 LcdPrintNum(gLight);                                // 刷新显示改变后的光线阈值
  404.                                 DelayMs(300);                                                                // 延时0.3秒左右
  405.                         }
  406.                         
  407.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  408.                         {
  409.                                 if(gLight<99)                                                                // 判断光线阈值是否小于59
  410.                                         gLight++;                                                                        // 是的话就加上1
  411.                                 LcdGotoXY(1,7);                                                        // 光标定位
  412.                                 LcdPrintNum(gLight);                                // 刷新显示改变后的光线阈值
  413.                                 DelayMs(300);                                                                // 延时0.3秒左右
  414.                         }
  415.                         
  416.                         if(KeySet2_P==0)
  417.                         {
  418.                                 break;
  419.                         }
  420.                 }
  421.                
  422.                 /* 退出前的设置 */
  423.                 LcdShowInit();                                        // 液晶显示内容初始化
  424.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  425.                 while(!KeySet2_P);                        // 等待按键释放
  426.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  427.         }
  428. }


  429. /*********************************************************/
  430. // 按键扫描(模式切换)
  431. /*********************************************************/
  432. void KeyScanf3()
  433. {
  434.         if(KeyMode_P==0)
  435.         {
  436.                 gMode++;                                                        // 切换到下一模式
  437.                 if(gMode==4)                                        // 如果到尽头了
  438.                         gMode=1;                                                // 回到第一种模式
  439.                 LcdGotoXY(1,0);                                // 光标定位
  440.                 LcdPrintMode(gMode);        // 显示模式
  441.                 DelayMs(10);                                        // 去除按键按下的抖动
  442.                 while(!KeyMode_P);                // 等待按键是否
  443.                 DelayMs(10);                                        // 去除按键松开的抖动
  444.         }
  445. }


  446. /*********************************************************/
  447. // 开窗
  448. /*********************************************************/
  449. void Open()
  450. {
  451.         uint i;
  452.         for(i=0;i<4;i++)
  453.         {
  454.                 P2=Clock[i];
  455.                 DelayMs(250);
  456.         }
  457.         Led_P=0;
  458. }



  459. /*********************************************************/
  460. // 关窗
  461. /*********************************************************/
  462. void Close()
  463. {
  464.         uint i;
  465.         for(i=0;i<4;i++)
  466.         {
  467.                 P2=AntiClock[i];
  468.                 DelayMs(250);
  469.         }
  470.         Led_P=1;
  471. }



  472. /*********************************************************/
  473. // 主函数
  474. /*********************************************************/
  475. void main()
  476. {
  477.         uchar light;
  478.         
  479.         LcdInit();                        // 执行液晶初始化        
  480.         DS1302_Init();        // 时钟芯片的初始化
  481.         LcdShowInit();        // 液晶显示内容的初始化
  482.         
  483.         if(DS1302_Read_Byte(0x81)>=128)                        // 判断时钟芯片是否正在运行
  484.         {
  485.                 DS1302_Write_Time();                                                        // 如果没有,则初始化一个时间
  486.         }
  487.         
  488.         while(1)
  489.         {
  490.                 DS1302_Read_Time();                                // 获取当前时钟芯片的时间,存在数组time_buf中
  491.                 FlashTime();                                                        // 刷新时间显示

  492.                 light=Get_ADC0832();                        // 读取光照强度
  493.                 light=light/2.5;                                        // 缩小光照检测结果(在0-99)
  494.                 if(light>99)                                                        // 如果大于99
  495.                         light=99;                                                                // 则依然保持99
  496.                 LcdGotoXY(1,14);                                        // 光标定位
  497.                 LcdPrintNum(light);                                // 显示光照强度
  498.                
  499.                 KeyScanf1();                                                        // 按键扫描(时间的设置)
  500.                 KeyScanf2();                                                        // 按键扫描(阈值的设置)
  501.                 KeyScanf3();                                                        // 按键扫描(模式切换)
  502.         
  503.                 /*手动控制模式*/
  504.                 if(gMode==1)
  505.                 {
  506.                         if(KeyDown_P==0)                // 如果关窗帘键按下了        
  507.                         {
  508.                                 if(Led_P==0)                        // 如果窗帘当前是打开的
  509.                                 {
  510.                                         Close();                                // 则关闭窗帘
  511.                                 }
  512.                         }
  513.                         if(KeyUp_P==0)                        // 如果开窗帘键按下了
  514.                         {
  515.                                 if(Led_P==1)                        // 如果窗帘当前是关闭的
  516.                                 {
  517.                                         Open();                                        // 则打开窗帘
  518.                                 }
  519.                         }        
  520.                 }
  521.                
  522.                 /*时间控制模式*/
  523.                 if(gMode==2)
  524.                 {
  525.                         if((TimeBuff[4]==CloseHour)&&(TimeBuff[5]==CloseMinute)&&(TimeBuff[6]==0))        // 如果到了关窗帘的时间        
  526.                         {
  527.                                 if(Led_P==0)                        // 如果窗帘当前是打开的
  528.                                 {
  529.                                         Close();                                // 则关闭窗帘
  530.                                 }
  531.                         }
  532.                         if((TimeBuff[4]==OpenHour)&&(TimeBuff[5]==OpenMinute)&&(TimeBuff[6]==0))                // 如果到了开窗帘的时间        
  533.                         {
  534.                                 if(Led_P==1)                        // 如果窗帘当前是关闭的
  535.                                 {
  536.                                         Open();                                        // 则打开窗帘
  537.                                 }
  538.                         }        
  539.                 }
  540.                
  541.                 /*光线控制模式*/
  542.                 if(gMode==3)
  543.                 {
  544.                         if(light<gLight)                // 当前光线小于设置的阈值
  545.                         {
  546.                                 if(Led_P==0)                        // 如果窗帘当前是打开的
  547.                                 {
  548.                                         Close();                                // 则关闭窗帘
  549.                                 }
  550.                         }
  551.                         else                                                                // 当前光线大于或等于设置的阈值
  552.                         {
  553.                                 if(Led_P==1)                        // 如果窗帘当前是关闭的
  554.                                 {
  555.                                         Open();                                        // 则打开窗帘
  556.                                 }
  557.                         }        
  558.                 }
  559.                
  560.                 DelayMs(100);                                                        // 延时0.1秒
  561.         }
  562. }
复制代码

所有资料51hei附件下载:
仿真程序.7z (89.02 KB, 下载次数: 57)

评分

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

查看全部评分

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

使用道具 举报

沙发
ID:262 发表于 2022-12-12 03:42 | 只看该作者
好资料,51黑有你更精彩!!!
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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