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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机智能窗帘控制系统源程序与Proteus仿真图
返回列表 发新帖
查看: 4671|回复: 0
收起左侧

51单片机智能窗帘控制系统源程序与Proteus仿真图

[复制链接]
ID:651755 发表于 2021-5-23 13:18 | 显示全部楼层 |阅读模式
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）
51hei.gif
51hei.png 51hei.png

元件清单:
10UF电解电容    C2
47UF电解电容    C6
光敏电阻    R10
限位开关    K1, K2
微动开关    KEY1, KEY2, KEY3, KEY4, KEY5
步进电机    P1
DC-002电源插座    P2
LCD1602液晶    Q1
红外一体接头    Q5
10K色环电阻    R1, R4, R5, R6, R8, R9
10K电位器    R2
10k排阻    R3
双掷开关    SW1
2Pi插针    U2
STC89C52单片机    U3
ADC0832模数转换芯片    U4
ULN2003电机驱动芯片    U5
DS1302时钟芯片    U6
12MHZ晶振    Y1
32.768KHZ晶振    Y2

单片机源程序如下:
  1. #include<reg52.h>                   //头文件
  2. #include<LCD1602.h>
  3. #include<DS1302.h>
  4. #include<28BYJ48.h>
  5. #include<EEPROM.h>
  6. #include<ADC0832.h>
  7. #include<HW.h>

  9. #define uchar unsigned char//宏定义
  10. #define uint unsigned int

  12. /*******************引脚定义*********************/
  13. sbit key_mode = P1^0;         //设置键
  14. sbit key_jia  = P1^1;         //加值键
  15. sbit key_jian = P1^2;         //减值键
  16. sbit key_ok   = P1^3;         //确定键

  18. sbit sw1=P3^7;           //全开 限位开关
  19. sbit sw2=P3^6;           //全关 限位开关
  20. /*******************变量定义*********************/
  21. uchar light_up,light_down;//存储光强上、下限值
  22. uchar set_f=0;                //设置选择标记，=0非设置，=1设置年，=2设置月，=3设置日，=4设置时，=5设置分，=6设置秒
  23.                                         //              =7设置定时-时，=8设置定时-分，=9设置定时-开关，=10设置窗帘打开/关闭
  24.                                         //                                =11设置光强上限，=12设置光强下限，=13设置校准窗帘位置

  26. uchar num;                        //计数变量
  27. uchar ds[4];            //定时控制开时、分、控制关时、分

  29. uchar mode=0;                //模式标记。=0手动，=1定时，=2光控
  30. uchar light;        //存储光强

  32. uint moto_num=0;  //记录窗帘位置
  33. uchar moto_state=0;//窗帘状态，=0已经关闭，=1处于运转过程中，=2已经打开
  34. bit moto_f=0;           //标记当前控制状态，=0控制关，=1控制开
  35. uchar code display_mode[3][3]={"SD\0","DS\0","GK\0"};//显示模式
  36. /********************************************************
  37. 函数名称:void delayms(uint ms)
  38. 函数作用:毫秒延时函数
  39. 参数说明:
  40. ********************************************************/
  41. void delayms(uint ms)
  42. {
  43.         unsigned char i=100,j;
  44.         for(;ms;ms--)
  45.         {
  46.                 while(--i)
  47.                 {
  48.                         j=10;
  49.                         while(--j);
  50.                 }
  51.         }
  52. }

  54. /********************************************************
  55. 函数名称:void display(void)
  56. 函数作用:正常显示日期、时间、光强等函数
  57. 参数说明:
  58. ********************************************************/
  59. void display(void)
  60. {
  61.         uint t[3];        

  63.         //显示时间
  64.         LCD_disp_char(0,2,ASCII[time[2]/10]);//显示时【0：表示第1列，2：表示第2行，所有关于显示都一样】
  65.         LCD_disp_char(1,2,ASCII[time[2]%10]);
  66.         LCD_disp_char(2,2,':');
  67.         LCD_disp_char(3,2,ASCII[time[1]/10]);//显示分【3：表示第4列，2：表示第2行，所有关于显示都一样】
  68.         LCD_disp_char(4,2,ASCII[time[1]%10]);
  69.         LCD_disp_char(5,2,':');
  70.         LCD_disp_char(6,2,ASCII[time[0]/10]);//显示秒
  71.         LCD_disp_char(7,2,ASCII[time[0]%10]);

  73.         //显示日期
  74.         LCD_disp_char(0,1,ASCII[time[6]/10]);//显示年
  75.         LCD_disp_char(1,1,ASCII[time[6]%10]);
  76.         LCD_disp_char(2,1,'/');
  77.         LCD_disp_char(3,1,ASCII[time[4]/10]);//显示月
  78.         LCD_disp_char(4,1,ASCII[time[4]%10]);
  79.         LCD_disp_char(5,1,'/');
  80.         LCD_disp_char(6,1,ASCII[time[3]/10]);//显示日
  81.         LCD_disp_char(7,1,ASCII[time[3]%10]);

  83.         //显示模式
  84.         lcd1602_write_character(9,1,display_mode[mode]);
  85.        
  86.         //显示光强
  87.         if(light>99)
  88.                 LCD_disp_char(12,1,ASCII[light/100]);
  89.         else
  90.                 LCD_disp_char(12,1,' ');
  91.         LCD_disp_char(13,1,ASCII[light%100/10]);
  92.         LCD_disp_char(14,1,ASCII[light%10]);
  93.         LCD_disp_char(15,1,'%');

  95.         //光强控制
  96.         if(mode==2)//光控模式
  97.         {         
  98.                 if((light>=light_up||light<light_down))//判断实际光强是否【大于等于上限 或 小于下限值】、当前处于打开状态
  99.                 {       
  100.                         moto_f=0;         //标记当前控制窗帘关闭  
  101.                         moto_state=1;//标记窗帘处于运转过程中
  102.                 }
  103.                 else
  104.                         if((light<light_up&&light>=light_down))//判断实际光强是否【大于等于下限值 并且 小于上限】、当前处于关闭状态
  105.                         {
  106.                                 moto_f=1;         //标记当前控制窗帘打开  
  107.                                 moto_state=1;//标记窗帘处于运转过程中
  108.                         }
  109.         }
  110.         else
  111.                 if(mode==1)//定时模式
  112.                 {
  113.                         t[0]=time[2]*60+time[1];//当前时间
  114.                         t[1]=ds[0]*60+ds[1];        //窗帘开启时间点
  115.                         t[2]=ds[2]*60+ds[3];        //窗帘关闭时间点
  116.                        
  117.                         if(t[1]<t[2])                         //0时 --> t[1] --> t[2] --> 24时
  118.                         {
  119.                                 if(t[0]>=t[1]&&t[0]<=t[2])
  120.                                         moto_f=1;            //标记当前需要打开窗帘
  121.                                 else
  122.                                         moto_f=0;                //标记当前需要关闭窗帘
  123.                         }
  124.                         else                                        //0时 --> t[2] --> t[1] --> 24时
  125.                         {
  126.                                 if(t[0]>=t[1]||t[0]<=t[2])
  127.                                         moto_f=1;                //标记当前需要打开窗帘
  128.                                 else
  129.                                         moto_f=0;                //标记当前需要关闭窗帘
  130.                         }
  131.                         moto_state=1;          //标记窗帘处于运转过程中
  132.                 }
  133.         if(moto_f==0&&moto_state!=0&&sw2!=0)//控制关闭窗帘
  134.         {
  135.                 if(moto_num==0)                          //控制次数减到0时，表示窗户已经关闭完成
  136.                 {
  137.                         BYJ48=P2&0xf0;                  //关闭步进电机
  138.                         moto_state=0;                  //标记窗帘处于关闭状态
  139.                         lcd1602_write_character(10,2,"ZT:OFF");
  140.                 }
  141.                 else
  142.                 {
  143.                         motor_z();                                  //步进电机正转
  144.                         moto_num--;                                  //控制次数-1
  145.                         lcd1602_write_character(10,2,"-->OFF");
  146.                 }               
  147.         }
  148.         else                  
  149.                 if(moto_f==1&&moto_state!=2&&sw1!=0)//控制打开窗帘
  150.                 {
  151.                         if(moto_num>=192)          //控制次数加到128时，表示窗户已经打开完成
  152.                         {
  153.                                 BYJ48=P2&0xf0;                  //关闭步进电机
  154.                                 moto_state=2;          //标记窗帘处于打开状态
  155.                                 lcd1602_write_character(10,2,"ZT:ON ");
  156.                         }
  157.                         else
  158.                         {
  159.                                 motor_f();                          //步进电机反转
  160.                                 moto_num++;                          //控制次数+1
  161.                                 lcd1602_write_character(10,2,"-->ON ");
  162.                         }               
  163.                 }
  164.                 else                                          //窗户处于停止状态
  165.                 {
  166.                         BYJ48=P2&0xf0;                  //关闭步进电机
  167.                         if(moto_state==0||sw2==0)
  168.                                 lcd1602_write_character(10,2,"ZT:OFF");
  169.                         else
  170.                                 if(moto_state==2||sw1==0)
  171.                                         lcd1602_write_character(10,2,"ZT:ON ");       
  172.                 }         
  173. }
  174. /********************************************************
  175. 函数名称:void display2(void)
  176. 函数作用:显示调整日期、时间函数
  177. 参数说明:
  178. ********************************************************/
  179. void display2()
  180. {
  181.         num++;

  183.         lcd1602_write_character(1,1,"Date:");
  184.         lcd1602_write_character(1,2,"Time:");
  185.        
  186.         if(num%2==0)        //偶数次显示，奇数次不显示。这样就会有闪烁效果，可以清楚看到当前设置的是哪个值
  187.         {
  188.                 LCD_disp_char(6,1,ASCII[time[6]/10]); //显示年
  189.                 LCD_disp_char(7,1,ASCII[time[6]%10]);
  190.                 LCD_disp_char(8,1,'/');  
  191.                 LCD_disp_char(9,1,ASCII[time[4]/10]); //显示月
  192.                 LCD_disp_char(10,1,ASCII[time[4]%10]);          
  193.                 LCD_disp_char(11,1,'/');
  194.                 LCD_disp_char(12,1,ASCII[time[3]/10]);//显示日
  195.                 LCD_disp_char(13,1,ASCII[time[3]%10]);
  196.        
  197.                 LCD_disp_char(6,2,ASCII[time[2]/10]); //显示时
  198.                 LCD_disp_char(7,2,ASCII[time[2]%10]);
  199.                 LCD_disp_char(8,2,':');  
  200.                 LCD_disp_char(9,2,ASCII[time[1]/10]); //显示分
  201.                 LCD_disp_char(10,2,ASCII[time[1]%10]);          
  202.                 LCD_disp_char(11,2,':');
  203.                 LCD_disp_char(12,2,ASCII[time[0]/10]);//显示秒
  204.                 LCD_disp_char(13,2,ASCII[time[0]%10]);
  205.         }       
  206.         else                        //奇数次不显示
  207.         {
  208.                 switch(set_f)//根据当前设置的内容，对应位置闪烁
  209.                 {
  210.                         case 1: lcd1602_write_character(6,1,"  "); break;
  211.                         case 2: lcd1602_write_character(9,1,"  "); break;
  212.                         case 3: lcd1602_write_character(12,1,"  "); break;
  213.                         case 4: lcd1602_write_character(6,2,"  "); break;
  214.                         case 5: lcd1602_write_character(9,2,"  "); break;
  215.                         case 6: lcd1602_write_character(12,2,"  "); break;
  216.                         default: break;
  217.                 }
  218.         }       
  219. }
  220. /********************************************************
  221. 函数名称:void display3(void)
  222. 函数作用:显示调整定时时间函数
  223. 参数说明:
  224. ********************************************************/
  225. void display3()
  226. {
  227.         num++;
  228.         lcd1602_write_character(0, 1, "Sets timer time:");
  229.         lcd1602_write_character(7, 2, "--");
  230.         if(num%2==0)        //偶数次显示，奇数次不显示。这样就会有闪烁效果，可以清楚看到当前设置的是哪个值
  231.         {            
  232.                 LCD_disp_char(1, 2, ASCII[ds[0]/10]);  //显示定时开-时
  233.                 LCD_disp_char(2, 2, ASCII[ds[0]%10]);   
  234.                 LCD_disp_char(3, 2, ':');
  235.                 LCD_disp_char(4, 2, ASCII[ds[1]/10]);  //显示定时开-分
  236.                 LCD_disp_char(5, 2, ASCII[ds[1]%10]);

  238.                 LCD_disp_char(10, 2, ASCII[ds[2]/10]); //显示定时关-时
  239.                 LCD_disp_char(11, 2, ASCII[ds[2]%10]);   
  240.                 LCD_disp_char(12, 2, ':');
  241.                 LCD_disp_char(13, 2, ASCII[ds[3]/10]); //显示定时关-分
  242.                 LCD_disp_char(14, 2, ASCII[ds[3]%10]);
  243.         }
  244.         else                         //奇数次不显示
  245.         {
  246.                 switch(set_f)//根据当前设置的内容，对应位置闪烁
  247.                 {
  248.                         case 7: lcd1602_write_character(1,2,"  "); break;
  249.                         case 8: lcd1602_write_character(4,2,"  "); break;
  250.                         case 9: lcd1602_write_character(10,2,"  "); break;
  251.                         case 10: lcd1602_write_character(13,2,"  "); break;
  252.                         default: break;
  253.                 }
  254.         }
  255. }
  256. /********************************************************
  257. 函数名称:void display4(void)
  258. 函数作用:显示调整光强控制函数
  259. 参数说明:
  260. ********************************************************/
  261. void display4(void)
  262. {
  263.         num++;

  265.         lcd1602_write_character(0, 1, "Light_Up  :");
  266.         lcd1602_write_character(0, 2, "Light_Down:");
  267.         LCD_disp_char(15,1,'%');
  268.         LCD_disp_char(15,2,'%');
  269.         if(num%2==0)        //偶数次显示，奇数次不显示。这样就会有闪烁效果，可以清楚看到当前设置的是哪个值
  270.         {
  271.                 LCD_disp_char(12, 1, ASCII[light_up/100]);           //显示光强上限值
  272.                 LCD_disp_char(13, 1, ASCII[light_up%100/10]);
  273.                 LCD_disp_char(14, 1, ASCII[light_up%10]);   
  274.        
  275.                 LCD_disp_char(12, 2, ASCII[light_down/100]);   //显示光强下限值
  276.                 LCD_disp_char(13, 2, ASCII[light_down%100/10]);       
  277.                 LCD_disp_char(14, 2, ASCII[light_down%10]);
  278.         }
  279.         else                           //奇数次不显示
  280.         {
  281.                 switch(set_f)//根据当前设置的内容，对应位置闪烁
  282.                 {
  283.                         case 11: lcd1602_write_character(12,1,"   "); break;
  284.                         case 12: lcd1602_write_character(12,2,"   "); break;
  285.                         default: break;
  286.                 }
  287.         }
  288. }
  289. /********************************************************
  290. 函数名称:void scan(void)
  291. 函数作用:按键查询处理函数
  292. 参数说明:
  293. ********************************************************/
  294. void scan(void)
  295. {
  296.         //设置键
  297.         if(hw_data=='B'||key_mode==0)      //按键按下
  298.         {  
  299.                 delayms(7);                                            //延时消抖
  300.                 if(hw_data=='B'||key_mode==0)  //再次确认按键按下       
  301.                 {
  302.                         BYJ48=P2&0xf0;                            //关闭步进电机
  303.                         if(set_f==6)                                //日期、时间校准完
  304.                         {
  305.                                 LCD_write_command(0x01);//清除屏幕显示
  306.                                 delay_n40us(100);                //延时等待全部清除完毕
  307.                                 set_f=13;                                //跳到校准窗帘状态
  308.                         }
  309.                         else
  310.                                 if(set_f==0)            //进入设置先清除屏幕，显示设置部分
  311.                                 {
  312.                                         Writeds1302 (WRITE_PROTECT,0X00);//禁止DS1302写保护
  313.                                         LCD_write_command(0x01);         //清除屏幕显示
  314.                                         delay_n40us(100);                         //延时等待全部清除完毕
  315.                                         switch(mode)//根据对应的模式，设置对应的参数
  316.                                         {
  317.                                                 case 0: set_f=1; break;                 //手动模式
  318.                                                 case 1: set_f=7; break;                 //定时模式
  319.                                                 case 2: set_f=11; break;         //光控模式
  320.                                                 default: break;
  321.                                         }       
  322.                                 }
  323.                                 else
  324.                                         if(set_f==10||set_f==12)//进入设置日期时间
  325.                                         {
  326.                                                 LCD_write_command(0x01);     //清除屏幕显示
  327.                                                 delay_n40us(100);                     //延时等待全部清除完毕
  328.                                                 set_f=1;                                         //进入校准时间
  329.                                         }
  330.                                          else
  331.                                                 set_f++;                                         //设置变量+1
  332.                         if(set_f>12)
  333.                         {
  334.                                 set_f=0;                                                         //重置设置变量

  336.                                 Writeds1302 (WRITE_MINUTE,(time[1]/10)*16+time[1]%10);//将设置好的时间写入DS1302
  337.                                 Writeds1302 (WRITE_SECOND,(time[0]/10)*16+time[0]%10);

  339.                                 EEPROM_delete(0x2200);                                  //擦除扇区
  340.                                 EEPROM_write(0x2200,ds[0]);     //写入【定时时间】数据保存
  341.                                 EEPROM_write(0x2210,ds[1]);     //写入【定时时间】数据保存存
  342.                                 EEPROM_write(0x2220,ds[2]);     //写入【定时时间】数据保存存
  343.                                 EEPROM_write(0x2230,ds[3]);     //写入【定时时间】数据保存存
  344.                                 EEPROM_write(0x2240,light_up);  //写入【光强上限值】数据保存
  345.                                 EEPROM_write(0x2250,light_down);//写入【光强下限值】数据保存

  347.                                 LCD_write_command(0x01);             //清除屏幕显示
  348.                                 delay_n40us(100);                             //延时等待全部清除完毕
  349.                         }                        
  350.                 }
  351.                 while(!key_mode);                            //等待按键松开       
  352.         }
  353.         //确定
  354.         if(hw_data=='Q'||key_ok==0)                                //按键按下
  355.         {
  356.                 delayms(7);                                                                //延时消抖
  357.                 if((hw_data=='Q'||key_ok==0)&&set_f!=0)//再次确认按键按下
  358.                 {
  359.                         if(set_f<7)
  360.                         {
  361.                                 Writeds1302 (WRITE_MINUTE,(time[1]/10)*16+time[1]%10);//将设置好的时间写入DS1302
  362.                                 Writeds1302 (WRITE_SECOND,(time[0]/10)*16+time[0]%10);
  363.                         }
  364.                         set_f=0;                                                        //重置设置变量
  365.        
  366.                         EEPROM_delete(0x2200);                                  //擦除扇区
  367.                         EEPROM_write(0x2200,ds[0]);     //写入【定时时间】数据保存
  368.                         EEPROM_write(0x2210,ds[1]);     //写入【定时时间】数据保存存
  369.                         EEPROM_write(0x2220,ds[2]);     //写入【定时时间】数据保存存
  370.                         EEPROM_write(0x2230,ds[3]);     //写入【定时时间】数据保存存
  371.                         EEPROM_write(0x2240,light_up);  //写入【光强上限值】数据保存
  372.                         EEPROM_write(0x2250,light_down);//写入【光强下限值】数据保存

  374.                         LCD_write_command(0x01);            //清除屏幕显示
  375.                         delay_n40us(100);                            //延时等待全部清除完毕
  376.                 }
  377.                 else
  378.                         if(key_ok==0&&set_f==0)                            //切换模式
  379.                         {
  380.                                 mode++;                                                        //模式变量+1
  381.                                 if(mode>=3)                                                //最大3个模式
  382.                                         mode=0;                                                //重新回到第1个模式
  383.                                 if(moto_state==1)                                //如果处于运转过程中
  384.                                 {
  385.                                         if(moto_f==0)                                //控制步进电机关闭
  386.                                                 moto_state=0;
  387.                                         else                                                //控制步进电机打开
  388.                                                 moto_state=2;               
  389.                                 }
  390.                                 EEPROM_delete(0x2400);                    //擦除扇区
  391.                                 EEPROM_write(0x2400,mode);      //写入【模式】数据保存               
  392.                         }
  393.                 while(!key_ok);                                //等待按键松开
  394.         }
  395.         //加键        ，下面减键内容一样       
  396.         if(hw_data=='+'||key_jia==0)
  397.         {
  398.                 delayms(7);
  399.                 if((hw_data=='+'||key_jia==0)&&set_f!=0)
  400.                 {
  401.                         if(set_f==1)           //设置年
  402.                         {
  403.                                 time[6]++;                                                        //年份+1
  404.                                 time[6]=(time[6]/10)*16+time[6]%10;        //将年份转换成16进制，例如：16年-->0x16
  405.                                 if(time[6]>0x79)                                        //判断是否达到最大年份79年
  406.                                         time[6]=0x00;                                        //重新回到00年
  407.                                 Writeds1302 (WRITE_YEA,time[6]);        //将设置好的年份写入到DS1302存储起来
  408.                         }
  409.                
  410.                         if(set_f==2)           //设置月
  411.                         {
  412.                                 time[4]++;                                                        //月份+1
  413.                                 time[4]=(time[4]/10)*16+time[4]%10;        //将月份转换成16进制，例如：08月-->0x08
  414.                                 if(time[4]>0x12)                                        //判断是否达到最大月份12月
  415.                                         time[4]=0x01;                                        //重新回到01月
  416.                                 Writeds1302 (WRITE_MONTH,time[4]);        //将设置好的月份写入到DS1302存储起来
  417.                         }
  418.                
  419.                         if(set_f==3)         //设置日
  420.                         {
  421.                                 time[3]++;                                                        //日份+1
  422.                                 time[3]=(time[3]/10)*16+time[3]%10;        //将日份转换成16进制，例如：15日-->0x15
  423.                                 if(time[4]==1||time[4]==3||time[4]==5||time[4]==7||time[4]==8||time[4]==10||time[4]==12)//1,3,5,7,8,10,12为大月，每月31天
  424.                                 {
  425.                                         if(time[3]>0x31)                                //判断是否达到最大日份31日
  426.                                                 time[3]=0x01;                                //重新回到01日
  427.                                 }
  428.                                 else                                                                //否者2,4,6,9,11为小月
  429.                                 {
  430.                                         if(time[4]==0x02)                                //如果是2月，需要区分闰、平年
  431.                                         {
  432.                                                 if(((!(time[6]%4) && (time[6]%100)) || !(time[6]%400))==0)//如果闰年
  433.                                                 {
  434.                                                         if(time[3]>0x28)                //判断是否达到最大日份28日
  435.                                                                 time[3]=0x01;                //重新回到01日
  436.                                                 }
  437.                                                 else                                                //否者平年
  438.                                                 {
  439.                                                         if(time[3]>0x29)                //判断是否达到最大日份29日
  440.                                                                 time[3]=0x01;                //重新回到01日
  441.                                                 }
  442.                                         }
  443.                                         else                                                        //否者为剩下的月份
  444.                                         {
  445.                                                 if(time[3]>0x30)                        //判断是否达到最大日份30日
  446.                                                         time[3]=0x01;                        //重新回到01日
  447.                                         }
  448.                                 }       
  449.                                 Writeds1302 (WRITE_DAY,time[3]);        //将设置好的日份写入到DS1302存储起来
  450.                         }
  451.                
  452.                         if(set_f==4)          //设置时，同上
  453.                         {                       
  454.                                 time[2]++;
  455.                                 time[2]=(time[2]/10)*16+time[2]%10;
  456.                                 if(time[2]>0x23)
  457.                                         time[2]=0x00;
  458.                                 Writeds1302 (WRITE_HOUR,time[2]);       
  459.                         }
  460.                
  461.                         if(set_f==5)          //设置分，同上
  462.                         {
  463.                                 time[1]++;
  464.                                 time[1]=(time[1]/10)*16+time[1]%10;
  465.                                 if(time[1]>0x59)
  466.                                         time[1]=0x00;
  467.                                 Writeds1302 (WRITE_MINUTE,time[1]);       
  468.                         }
  469.                
  470.                         if(set_f==6)         //设置秒，同上
  471.                         {
  472.                                 time[0]++;
  473.                                 time[0]=(time[0]/10)*16+time[0]%10;
  474.                                 if(time[0]>0x59)
  475.                                         time[0]=0x00;
  476.                                 Writeds1302 (WRITE_SECOND,time[0]);       
  477.                         }
  478.                        
  479.                         if(set_f==7)     //设置定时起始时间——时      
  480.                         {
  481.                                 if(ds[0]<23)
  482.                                         ds[0]++;  
  483.                                 else
  484.                                         ds[0]=0;                       
  485.                         }
  486.        
  487.                         if(set_f==8)    //设置定时起始时间——分        
  488.                         {
  489.                                 if(ds[1]<59)
  490.                                         ds[1]++;  
  491.                                 else
  492.                                         ds[1]=0;                 
  493.                         }

  495.                         if(set_f==9)     //设置定时结束时间——时      
  496.                         {
  497.                                 if(ds[2]<23)
  498.                                         ds[2]++;  
  499.                                 else
  500.                                         ds[2]=0;                       
  501.                         }
  502.        
  503.                         if(set_f==10)    //设置定时结束时间——分        
  504.                         {
  505.                                 if(ds[3]<59)
  506.                                         ds[3]++;  
  507.                                 else
  508.                                         ds[3]=0;                 
  509.                         }
  510.                         if(set_f==11)    //设置 光强上限值
  511.                         {
  512.                                 if(light_up<99)//最大值可设置99%
  513.                                         light_up++;//光强上限值+1%
  514.                         }
  515.        
  516.                         if(set_f==12)    //设置 光强下限值
  517.                         {
  518.                                 if(light_down<99&&light_down+1<light_up)//最大值可设置99%，并且下限不能超过上限
  519.                                         light_down++;//光强下限值+1%
  520.                         }
  521.                 }
  522.                 else
  523.                         if((hw_data=='+'||key_jia==0)&&set_f==0&&mode==0)//手动控制窗帘打开
  524.                         {         
  525.                                 if(moto_state==1&&moto_f==1)//已经在控制状态。并且控制打开
  526.                                         moto_state=2;    //停止运作
  527.                                 else
  528.                                 {
  529.                                         if(moto_num<192)//判断是否不处于打开状态
  530.                                         {
  531.                                                 moto_f=1;         //控制开闭窗
  532.                                                 moto_state=1;    //开启运作
  533.                                         }
  534.                                 }
  535.                                 while(!key_jia);     //等待按键松开
  536.                         }       
  537.         }
  538.         //减键
  539.         if(hw_data=='-'||key_jian==0)
  540.         {
  541.                 delayms(7);
  542.                 if((hw_data=='-'||key_jian==0)&&set_f!=0)
  543.                 {
  544.                         if(set_f==1)         //设置年
  545.                         {
  546.                                 if(time[6]==0)                                           //判断当前是否为00年
  547.                                         time[6]=79;                                           //如果是回到最大年份：79年
  548.                                 else
  549.                                         time[6]--;                                           //否者，年份-1
  550.                                 time[6]=(time[6]/10)*16+time[6]%10;//将年份转换成16进制，例如：16年-->0x16                       
  551.                                 Writeds1302 (WRITE_YEA,time[6]);   //将设置好的年份写入到DS1302存储起来
  552.                         }
  553.        
  554.                         if(set_f==2)         //设置月，同上
  555.                         {
  556.                                 if(time[4]==1)
  557.                                         time[4]=12;
  558.                                 else
  559.                                         time[4]--;
  560.                                 time[4]=(time[4]/10)*16+time[4]%10;
  561.                                 Writeds1302 (WRITE_MONTH,time[4]);               
  562.                         }
  563.        
  564.                         if(set_f==3)        //设置日，同上
  565.                         {
  566.                                 time[3]--;
  567.                                 time[3]=(time[3]/10)*16+time[3]%10;
  568.                                 if(time[4]==1||time[4]==3||time[4]==5||time[4]==7||time[4]==8||time[4]==10||time[4]==12)
  569.                                 {
  570.                                         if(time[3]<0x01)
  571.                                                 time[3]=0x31;
  572.                                 }
  573.                                 else
  574.                                 {
  575.                                         if(time[4]==0x02)
  576.                                         {
  577.                                                 if(((!(time[6]%4) && (time[6]%100)) || !(time[6]%400))==0)
  578.                                                 {
  579.                                                         if(time[3]<0x01)
  580.                                                                 time[3]=0x28;
  581.                                                 }
  582.                                                 else
  583.                                                 {
  584.                                                         if(time[3]<0x01)
  585.                                                                 time[3]=0x29;
  586.                                                 }
  587.                                         }
  588.                                         else
  589.                                         {
  590.                                                 if(time[3]<0x01)
  591.                                                         time[3]=0x30;
  592.                                         }
  593.                                 }       
  594.                                 Writeds1302 (WRITE_DAY,time[3]);               
  595.                         }
  596.        
  597.                         if(set_f==4)        //设置时，同上
  598.                         {                       
  599.                                 if(time[2]==0)
  600.                                         time[2]=23;
  601.                                 else
  602.                                         time[2]--;
  603.                                 time[2]=(time[2]/10)*16+time[2]%10;
  604.                                 Writeds1302 (WRITE_HOUR,time[2]);               
  605.                         }
  606.        
  607.                         if(set_f==5)        //设置分，同上
  608.                         {
  609.                                 if(time[1]==0)
  610.                                         time[1]=59;
  611.                                 else
  612.                                         time[1]--;
  613.                                 time[1]=(time[1]/10)*16+time[1]%10;
  614.                                 Writeds1302 (WRITE_MINUTE,time[1]);               
  615.                         }
  616.        
  617.                         if(set_f==6)        //设置秒，同上
  618.                         {
  619.                                 if(time[0]==0)
  620.                                         time[0]=59;
  621.                                 else
  622.                                         time[0]--;
  623.                                 time[0]=(time[0]/10)*16+time[0]%10;
  624.                                 Writeds1302 (WRITE_SECOND,time[0]);                       
  625.                         }
  626.                         if(set_f==7)     //设置定时起始时间——时      
  627.                         {
  628.                                 if(ds[0]>0)
  629.                                         ds[0]--;  
  630.                                 else
  631.                                         ds[0]=23;                       
  632.                         }
  633.        
  634.                         if(set_f==8)    //设置定时起始时间——分        
  635.                         {
  636.                                 if(ds[1]>0)
  637.                                         ds[1]--;  
  638.                                 else
  639.                                         ds[1]=59;                 
  640.                         }

  642.                         if(set_f==9)     //设置定时结束时间——时      
  643.                         {
  644.                                 if(ds[2]>0)
  645.                                         ds[2]--;  
  646.                                 else
  647.                                         ds[2]=23;                       
  648.                         }
  649.        
  650.                         if(set_f==10)    //设置定时结束时间——分        
  651.                         {
  652.                                 if(ds[3]>0)
  653.                                         ds[3]--;  
  654.                                 else
  655.                                         ds[3]=59;                 
  656.                         }

  658.                         if(set_f==11)    //设置 光强上限值
  659.                         {
  660.                                 if(light_up!=0&&light_up>light_down+1)//最小值可设置成0，并且上限值要大于下限值
  661.                                         light_up--;  //光强上限值-1%
  662.                         }
  663.        
  664.                         if(set_f==12)    //设置 光强下限值
  665.                         {
  666.                                 if(light_down!=0)//最小值可设置成0
  667.                                         light_down--;//光强下限值-1%
  668.                         }
  669.                 }
  670.                 else
  671.                         if((hw_data=='-'||key_jian==0)&&set_f==0&&mode==0)//手动控制窗户关闭
  672.                         {
  673.                                 if(moto_state==1&&moto_f==0)//已经在控制状态。并且控制打开
  674.                                         moto_state=0;    //停止运作
  675.                                 else
  676.                                 {
  677.                                         if(moto_num>0)//判断是否不处于打开状态
  678.                                         {
  679.                                                 moto_f=0;         //控制开闭窗
  680.                                                 moto_state=1;    //开启运作
  681.                                         }
  682.                                 }
  683.                                 while(!key_jian);    //等待按键松开       
  684.                         }
  685.         }
  686.         //红外遥控切换模式
  687.         if(hw_data=='|'&&set_f==0)
  688.         {
  689.                 mode++;                                                        //模式变量+1
  690.                 if(mode>=3)                                                //最大3个模式
  691.                         mode=0;                                                //重新回到第1个模式
  692.                 if(moto_state==1)                                //如果处于运转过程中
  693.                 {
  694.                         if(moto_f==0)                                //控制步进电机关闭
  695.                                 moto_state=0;
  696.                         else                                                //控制步进电机打开
  697.                                 moto_state=2;               
  698.                 }
  699.                 EEPROM_delete(0x2400);                    //擦除扇区
  700.                 EEPROM_write(0x2400,mode);      //写入【模式】数据保存
  701.         }

  703.         //红外遥控切换设置上一个参数
  704.         if(hw_data=='<'&&set_f!=0)
  705.         {
  706.                 if(set_f==7||set_f==11)
  707.                 {
  708.                         LCD_write_command(0x01);    //清除屏幕显示
  709.                         delay_n40us(100);                    //延时等待全部清除完毕
  710.                         set_f=6;
  711.                 }
  712.                 else
  713.                         if(set_f==1)
  714.                         {
  715.                                 LCD_write_command(0x01);//清除屏幕显示
  716.                                 delay_n40us(100);                //延时等待全部清除完毕
  717.                                 switch(mode)//根据对应的模式，设置对应的参数
  718.                                 {
  719.                                         case 0: set_f=6; break;        //手动模式
  720.                                         case 1: set_f=10; break;//定时模式
  721.                                         case 2: set_f=12; break;//光控模式
  722.                                         default: break;
  723.                                 }
  724.                         }
  725.                         else
  726.                                 set_f--;
  727.         }

  729.         //红外遥控切换设置下一个参数
  730.         if(hw_data=='>'&&set_f!=0)
  731.         {
  732.                 if(set_f==6)                                //日期、时间校准完
  733.                 {
  734.                         LCD_write_command(0x01);//清除屏幕显示
  735.                         delay_n40us(100);                //延时等待全部清除完毕
  736.                         set_f=13;                                //跳到校准窗帘状态
  737.                 }
  738.                 else
  739.                         if(set_f==10||set_f==12)
  740.                         {
  741.                                 LCD_write_command(0x01);     //清除屏幕显示
  742.                                 delay_n40us(100);                     //延时等待全部清除完毕
  743.                                 set_f=1;                                         //进入校准时间
  744.                         }
  745.                          else
  746.                                 set_f++;                                         //设置变量+1
  747.                 if(set_f>12)
  748.                 {
  749.                         Writeds1302 (WRITE_PROTECT,0X00);//禁止DS1302写保护
  750.                         LCD_write_command(0x01);         //清除屏幕显示
  751. ……………………

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

所有资料51hei提供下载:
基于单片机的智能窗帘.7z (8.65 MB, 下载次数: 181)
压缩包, 资料, 源程序, 源代码, 程序设计

评分

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

查看全部评分

相关帖子
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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