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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机自动窗帘电机控制程序与Proteus仿真图
返回列表 发新帖
查看: 3062|回复: 0
打印 上一主题 下一主题
收起左侧

51单片机自动窗帘电机控制程序与Proteus仿真图

[复制链接]
跳转到指定楼层
楼主
ID:926113 发表于 2021-5-23 22:17 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
单片机控制电机转速运用PWM
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


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

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


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

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

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


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


  38. uchar TimeBuff[7]={17,9,1,6,18,30,40};                    // 时间数组，默认2017年9月1日，星期五，18:30:40
  39. // TimeBuff[0] 代表年份，范围00-99
  40. // TimeBuff[1] 代表月份，范围1-12
  41. // TimeBuff[2] 代表日期，范围1-31
  42. // TimeBuff[3] 代表星期，范围1-7
  43. // TimeBuff[4] 代表小时，范围00-23
  44. // TimeBuff[5] 代表分钟，范围00-59
  45. // TimeBuff[6] 代表秒钟，范围00-59



  49. /*********************************************************/
  50. // 毫秒级的延时函数，time是要延时的毫秒数
  51. /*********************************************************/
  52. void DelayMs(uint time)
  53. {
  54.     uint i,j;
  55.     for(i=0;i<time;i++)
  56.         for(j=0;j<112;j++);
  57. }


  60. /*********************************************************/
  61. // 1602液晶写命令函数，cmd就是要写入的命令
  62. /*********************************************************/
  63. void LcdWriteCmd(uchar cmd)
  64. {
  65.     LcdRs_P = 0;
  66.     LcdRw_P = 0;
  67.     LcdEn_P = 0;
  68.     P0=cmd;
  69.     DelayMs(2);
  70.     LcdEn_P = 1;   
  71.     DelayMs(2);
  72.     LcdEn_P = 0;   
  73. }


  76. /*********************************************************/
  77. // 1602液晶写数据函数，dat就是要写入的数据
  78. /*********************************************************/
  79. void LcdWriteData(uchar dat)
  80. {
  81.     LcdRs_P = 1;
  82.     LcdRw_P = 0;
  83.     LcdEn_P = 0;
  84.     P0=dat;
  85.     DelayMs(2);
  86.     LcdEn_P = 1;   
  87.     DelayMs(2);
  88.     LcdEn_P = 0;
  89. }


  92. /*********************************************************/
  93. // 1602液晶初始化函数
  94. /*********************************************************/
  95. void LcdInit()
  96. {
  97.     LcdWriteCmd(0x38);        // 16*2显示，5*7点阵，8位数据口
  98.     LcdWriteCmd(0x0C);        // 开显示，不显示光标
  99.     LcdWriteCmd(0x06);        // 地址加1，当写入数据后光标右移
  100.     LcdWriteCmd(0x01);        // 清屏
  101. }


  104. /*********************************************************/
  105. // 液晶光标定位函数
  106. /*********************************************************/
  107. void LcdGotoXY(uchar line,uchar column)
  108. {
  109.     // 第一行
  110.     if(line==0)        
  111.         LcdWriteCmd(0x80+column);
  112.     // 第二行
  113.     if(line==1)        
  114.         LcdWriteCmd(0x80+0x40+column);
  115. }


  118. /*********************************************************/
  119. // 液晶输出字符串函数
  120. /*********************************************************/
  121. void LcdPrintStr(uchar *str)
  122. {
  123.     while(*str!='\0')
  124.             LcdWriteData(*str++);
  125. }


  128. /*********************************************************/
  129. // 液晶输出数字(0-99)
  130. /*********************************************************/
  131. void LcdPrintNum(uchar num)
  132. {
  133.     LcdWriteData(num/10+48);        // 十位
  134.     LcdWriteData(num%10+48);         // 个位
  135. }


  138. /*********************************************************/
  139. // 显示模式
  140. /*********************************************************/
  141. void LcdPrintMode(uchar num)
  142. {
  143.     switch(num)            
  144.     {
  145.         case 1: LcdPrintStr("Manual");    break;
  146.         case 2: LcdPrintStr("Timing");    break;
  147.         case 3: LcdPrintStr("Liging");    break;
  148.         default:                                                break;
  149.     }
  150. }


  153. /*********************************************************/
  154. // 液晶显示内容的初始化
  155. /*********************************************************/
  156. void LcdShowInit()
  157. {
  158.     LcdGotoXY(0,0);
  159.     LcdPrintStr("20  -  -     :  ");
  160.     LcdGotoXY(1,0);
  161.     LcdPrintStr("           gz:  ");
  162.     LcdGotoXY(1,0);
  163.     LcdPrintMode(gMode);
  164. }


  167. /*********************************************************/
  168. // 刷新时间显示
  169. /*********************************************************/
  170. void FlashTime()
  171. {
  172.     LcdGotoXY(0,2);                                        // 年份
  173.     LcdPrintNum(TimeBuff[0]);
  174.     LcdGotoXY(0,5);                                        // 月份
  175.     LcdPrintNum(TimeBuff[1]);
  176.     LcdGotoXY(0,8);                                        // 日期
  177.     LcdPrintNum(TimeBuff[2]);
  178.     LcdGotoXY(0,11);                                    // 小时
  179.     LcdPrintNum(TimeBuff[4]);
  180.     LcdGotoXY(0,14);                                    // 分钟
  181.     LcdPrintNum(TimeBuff[5]);
  182.     LcdGotoXY(0,13);                                    // 秒钟
  183.     if(TimeBuff[6]%2==0)                            // 秒钟是偶数显示冒号
  184.         LcdWriteData(':');
  185.     else                                                            // 秒钟是奇数显示空格
  186.         LcdWriteData(' ');
  187. }


  190. /*********************************************************/
  191. // 初始化DS1302
  192. /*********************************************************/
  193. void DS1302_Init(void)
  194. {
  195.     RST_P=0;            // RST脚置低
  196.     SCK_P=0;            // SCK脚置低
  197.     SDA_P=0;            // SDA脚置低               
  198. }


  201. /*********************************************************/
  202. // 从DS1302读出一字节数据
  203. /*********************************************************/
  204. uchar DS1302_Read_Byte(uchar addr)
  205. {
  206.     uchar i;
  207.     uchar temp;
  208.    
  209.     RST_P=1;                                
  210.    
  211.     /* 写入目标地址：addr*/
  212.     for(i=0;i<8;i++)
  213.     {     
  214.         if(addr&0x01)
  215.             SDA_P=1;
  216.         else
  217.             SDA_P=0;
  218.         
  219.         SCK_P=1;
  220.         _nop_();
  221.         SCK_P=0;
  222.         _nop_();
  223.         
  224.         addr=addr>> 1;
  225.     }
  226.    
  227.     /* 读出该地址的数据 */
  228.     for(i=0;i<8;i++)
  229.     {
  230.         temp=temp>>1;
  231.         
  232.         if(SDA_P)
  233.             temp|= 0x80;
  234.         else
  235.             temp&=0x7F;
  236.         
  237.         SCK_P=1;
  238.         _nop_();
  239.         SCK_P=0;
  240.         _nop_();
  241.     }
  242.    
  243.     RST_P=0;
  244.    
  245.     return temp;
  246. }


  249. /*********************************************************/
  250. // 向DS1302写入一字节数据
  251. /*********************************************************/
  252. void DS1302_Write_Byte(uchar addr, uchar dat)
  253. {
  254.     uchar i;
  255.    
  256.     RST_P = 1;
  257.    
  258.     /* 写入目标地址：addr*/
  259.     for(i=0;i<8;i++)
  260.     {
  261.         if(addr&0x01)
  262.             SDA_P=1;
  263.         else
  264.             SDA_P=0;

  266.         SCK_P=1;
  267.         _nop_();
  268.         SCK_P=0;
  269.         _nop_();
  270.         
  271.         addr=addr>>1;
  272.     }
  273.    
  274.     /* 写入数据：dat*/
  275.     for(i=0;i<8;i++)
  276.     {
  277.         if(dat&0x01)
  278.             SDA_P=1;
  279.         else
  280.             SDA_P=0;
  281.    
  282.         SCK_P=1;
  283.         _nop_();
  284.         SCK_P=0;
  285.         _nop_();
  286.         
  287.         dat=dat>>1;
  288.     }
  289.    
  290.     RST_P=0;                    
  291. }


  294. /*********************************************************/
  295. // 向DS1302写入时间数据
  296. /*********************************************************/
  297. void DS1302_Write_Time()
  298. {
  299.   uchar i;
  300.     uchar temp1;
  301.     uchar temp2;
  302.    
  303.     for(i=0;i<7;i++)            // 十进制转BCD码
  304.     {
  305.         temp1=(TimeBuff[i]/10)<<4;
  306.         temp2=TimeBuff[i]%10;
  307.         TimeBuff[i]=temp1+temp2;
  308.     }
  309.    
  310.     DS1302_Write_Byte(0x8E,0x00);                                // 关闭写保护
  311.     DS1302_Write_Byte(0x80,0x80);                                // 暂停时钟
  312.     DS1302_Write_Byte(0x8C,TimeBuff[0]);                // 年
  313.     DS1302_Write_Byte(0x88,TimeBuff[1]);                // 月
  314.     DS1302_Write_Byte(0x86,TimeBuff[2]);                // 日
  315.     DS1302_Write_Byte(0x8A,TimeBuff[3]);                // 星期
  316.     DS1302_Write_Byte(0x84,TimeBuff[4]);                // 时
  317.     DS1302_Write_Byte(0x82,TimeBuff[5]);                // 分
  318.     DS1302_Write_Byte(0x80,TimeBuff[6]);                // 秒
  319.     DS1302_Write_Byte(0x80,TimeBuff[6]&0x7F);        // 运行时钟
  320.     DS1302_Write_Byte(0x8E,0x80);                                // 打开写保护  
  321. }



  325. /*********************************************************/
  326. // 从DS1302读出时间数据
  327. /*********************************************************/
  328. void DS1302_Read_Time()  
  329. {
  330.     uchar i;

  332.     TimeBuff[0]=DS1302_Read_Byte(0x8D);                        // 年
  333.     TimeBuff[1]=DS1302_Read_Byte(0x89);                        // 月
  334.     TimeBuff[2]=DS1302_Read_Byte(0x87);                        // 日
  335.     TimeBuff[3]=DS1302_Read_Byte(0x8B);                        // 星期
  336.     TimeBuff[4]=DS1302_Read_Byte(0x85);                        // 时
  337.     TimeBuff[5]=DS1302_Read_Byte(0x83);                        // 分
  338.     TimeBuff[6]=(DS1302_Read_Byte(0x81))&0x7F;        // 秒

  340.     for(i=0;i<7;i++)        // BCD转十进制
  341.     {           
  342.         TimeBuff[i]=(TimeBuff[i]/16)*10+TimeBuff[i]%16;
  343.     }
  344. }


  347. /*********************************************************/
  348. // ADC0832的时钟脉冲
  349. /*********************************************************/
  350. void WavePlus()
  351. {
  352.     _nop_();
  353.     ADC_CLK = 1;
  354.     _nop_();
  355.     ADC_CLK = 0;
  356. }


  359. /*********************************************************/
  360. // 获取指定通道的A/D转换结果
  361. /*********************************************************/
  362. uchar Get_ADC0832()
  363. {
  364.     uchar i;
  365.     uchar dat1=0;
  366.     uchar dat2=0;
  367.    
  368.     ADC_CLK = 0;                // 电平初始化
  369.     ADC_DAT = 1;
  370.     _nop_();
  371.     ADC_CS = 0;
  372.     WavePlus();                    // 起始信号
  373.     ADC_DAT = 1;
  374.     WavePlus();                    // 通道选择的第一位
  375.     ADC_DAT = 0;      
  376.     WavePlus();                    // 通道选择的第二位
  377.     ADC_DAT = 1;
  378.    
  379.     for(i=0;i<8;i++)        // 第一次读取
  380.     {
  381.         dat1<<=1;
  382.         WavePlus();
  383.         if(ADC_DAT)
  384.             dat1=dat1|0x01;
  385.         else
  386.             dat1=dat1|0x00;
  387.     }
  388.    
  389.     for(i=0;i<8;i++)        // 第二次读取
  390.     {
  391.         dat2>>= 1;
  392.         if(ADC_DAT)
  393.             dat2=dat2|0x80;
  394.         else
  395.             dat2=dat2|0x00;
  396.         WavePlus();
  397.     }
  398.    
  399.     _nop_();                        // 结束此次传输
  400.     ADC_DAT = 1;
  401.     ADC_CLK = 1;
  402.     ADC_CS  = 1;   

  404.     if(dat1==dat2)            // 返回采集结果
  405.         return dat1;
  406.     else
  407.         return 0;
  408. }


  411. /*********************************************************/
  412. // 按键扫描(设置当前时间)
  413. /*********************************************************/
  414. void KeyScanf1()
  415. {
  416.     if(KeySet_P==0)
  417.     {
  418.         LcdGotoXY(0,13);                // 显示秒钟的冒号
  419.         LcdWriteData(':');
  420.         LcdWriteCmd(0x0f);            // 启动光标闪烁
  421.         LcdGotoXY(0,3);                    // 定位光标到年份闪烁
  422.         DelayMs(10);                        // 延时等待，消除按键按下的抖动
  423.         while(!KeySet_P);                // 等待按键释放
  424.         DelayMs(10);                        // 延时等待，消除按键松开的抖动
  425.         
  426.         /* 调整年份 */
  427.         while(1)
  428.         {
  429.             if(KeyDown_P==0)                            // 如果减按键被下去
  430.             {
  431.                 if(TimeBuff[0]>0)                        // 判断年份是否大于0        
  432.                     TimeBuff[0]--;                        // 是的话就减去1
  433.                 LcdGotoXY(0,2);                            // 光标定位到年份的位置
  434.                 LcdPrintNum(TimeBuff[0]);        // 刷新显示改变后的年份
  435.                 LcdGotoXY(0,3);                            // 定位光标到年份闪烁
  436.                 DelayMs(300);                                // 延时0.3秒左右
  437.             }
  438.             
  439.             if(KeyUp_P==0)                                // 如果加按键被下去
  440.             {
  441.                 if(TimeBuff[0]<99)                    // 判断年份是否小于99
  442.                     TimeBuff[0]++;                        // 是的话就加上1
  443.                 LcdGotoXY(0,2);                            // 光标定位到年份的位置
  444.                 LcdPrintNum(TimeBuff[0]);        // 刷新显示改变后的年份
  445.                 LcdGotoXY(0,3);                            // 定位光标到年份闪烁
  446.                 DelayMs(300);                                // 延时0.3秒左右
  447.             }
  448.             
  449.             if(KeySet_P==0)
  450.             {
  451.                 break;
  452.             }
  453.         }
  454.         
  455.         LcdGotoXY(0,6);                    // 定位光标到月份闪烁
  456.         DelayMs(10);                        // 延时等待，消除按键按下的抖动
  457.         while(!KeySet_P);                // 等待按键释放
  458.         DelayMs(10);                        // 延时等待，消除按键松开的抖动
  459.             
  460.         /* 调整月份 */
  461.         while(1)
  462.         {
  463.             if(KeyDown_P==0)                            // 如果减按键被下去
  464.             {
  465.                 if(TimeBuff[1]>1)                        // 判断月份是否大于1        
  466.                     TimeBuff[1]--;                        // 是的话就减去1
  467.                 LcdGotoXY(0,5);                            // 光标定位到月份的位置
  468.                 LcdPrintNum(TimeBuff[1]);        // 刷新显示改变后的月份
  469.                 LcdGotoXY(0,6);                            // 定位光标到月份闪烁
  470.                 DelayMs(300);                                // 延时0.3秒左右
  471.             }
  472.             
  473.             if(KeyUp_P==0)                                // 如果加按键被下去
  474.             {
  475.                 if(TimeBuff[1]<12)                    // 判断月份是否小于12
  476.                     TimeBuff[1]++;                        // 是的话就加上1
  477.                 LcdGotoXY(0,5);                            // 光标定位到月份的位置
  478.                 LcdPrintNum(TimeBuff[1]);        // 刷新显示改变后的月份
  479.                 LcdGotoXY(0,6);                            // 定位光标到月份闪烁
  480.                 DelayMs(300);                                // 延时0.3秒左右
  481.             }
  482.             
  483.             if(KeySet_P==0)
  484.             {
  485.                 break;
  486.             }
  487.         }
  488.         
  489.         LcdGotoXY(0,9);                    // 定位光标到日期闪烁
  490.         DelayMs(10);                        // 延时等待，消除按键按下的抖动
  491.         while(!KeySet_P);                // 等待按键释放
  492.         DelayMs(10);                        // 延时等待，消除按键松开的抖动
  493.         
  494.         /* 调整日期 */
  495.         while(1)
  496.         {
  497.             if(KeyDown_P==0)                            // 如果减按键被下去
  498.             {
  499.                 if(TimeBuff[2]>1)                        // 判断日期是否大于1        
  500.                     TimeBuff[2]--;                        // 是的话就减去1
  501.                 LcdGotoXY(0,8);                            // 光标定位到日期的位置
  502.                 LcdPrintNum(TimeBuff[2]);        // 刷新显示改变后的日期
  503.                 LcdGotoXY(0,9);                            // 定位光标到日期闪烁
  504.                 DelayMs(300);                                // 延时0.3秒左右
  505.             }
  506.             
  507.             if(KeyUp_P==0)                                // 如果加按键被下去
  508.             {
  509.                 if(TimeBuff[2]<31)                    // 判断日期是否小于31
  510.                     TimeBuff[2]++;                        // 是的话就加上1
  511.                 LcdGotoXY(0,8);                            // 光标定位到日期的位置
  512.                 LcdPrintNum(TimeBuff[2]);        // 刷新显示改变后的日期
  513.                 LcdGotoXY(0,9);                            // 定位光标到日期闪烁
  514.                 DelayMs(300);                                // 延时0.3秒左右
  515.             }
  516.             
  517.             if(KeySet_P==0)
  518.             {
  519.                 break;
  520.             }
  521.         }
  522.         
  523.         LcdGotoXY(0,12);                // 定位光标到小时闪烁
  524.         DelayMs(10);                        // 延时等待，消除按键按下的抖动
  525.         while(!KeySet_P);                // 等待按键释放
  526.         DelayMs(10);                        // 延时等待，消除按键松开的抖动
  527.         
  528.         
  529.         /* 调整小时 */
  530.         while(1)
  531.         {
  532.             if(KeyDown_P==0)                            // 如果减按键被下去
  533.             {
  534.                 if(TimeBuff[4]>0)                        // 判断小时是否大于0
  535.                     TimeBuff[4]--;                        // 是的话就减去1
  536.                 LcdGotoXY(0,11);                        // 光标定位到小时的位置
  537.                 LcdPrintNum(TimeBuff[4]);        // 刷新显示改变后的小时
  538.                 LcdGotoXY(0,12);                        // 定位光标到小时闪烁
  539.                 DelayMs(300);                                // 延时0.3秒左右
  540.             }
  541.             
  542.             if(KeyUp_P==0)                                // 如果加按键被下去
  543.             {
  544.                 if(TimeBuff[4]<23)                    // 判断小时是否小于23
  545.                     TimeBuff[4]++;                        // 是的话就加上1
  546.                 LcdGotoXY(0,11);                        // 光标定位到小时的位置
  547.                 LcdPrintNum(TimeBuff[4]);        // 刷新显示改变后的小时
  548.                 LcdGotoXY(0,12);                        // 定位光标到小时闪烁
  549.                 DelayMs(300);                                // 延时0.3秒左右
  550.             }
  551.             
  552.             if(KeySet_P==0)
  553.             {
  554.                 break;
  555.             }
  556.         }
  557.         
  558.         LcdGotoXY(0,15);                // 定位光标到分钟闪烁
  559.         DelayMs(10);                        // 延时等待，消除按键按下的抖动
  560.         while(!KeySet_P);                // 等待按键释放
  561.         DelayMs(10);                        // 延时等待，消除按键松开的抖动
  562.         
  563.         /* 调整分钟 */
  564.         while(1)
  565.         {
  566.             if(KeyDown_P==0)                            // 如果减按键被下去
  567.             {
  568.                 if(TimeBuff[5]>0)                        // 判断分钟是否大于0
  569.                     TimeBuff[5]--;                        // 是的话就减去1
  570.                 LcdGotoXY(0,14);                        // 光标定位到分钟的位置
  571.                 LcdPrintNum(TimeBuff[5]);        // 刷新显示改变后的分钟
  572.                 LcdGotoXY(0,15);                        // 定位光标到分钟闪烁
  573.                 DelayMs(300);                                // 延时0.3秒左右
  574.             }
  575.             
  576.             if(KeyUp_P==0)                                // 如果加按键被下去
  577.             {
  578.                 if(TimeBuff[5]<59)                    // 判断分钟是否小于59
  579.                     TimeBuff[5]++;                        // 是的话就加上1
  580.                 LcdGotoXY(0,14);                        // 光标定位到分钟的位置
  581.                 LcdPrintNum(TimeBuff[5]);        // 刷新显示改变后的分钟
  582.                 LcdGotoXY(0,15);                        // 定位光标到分钟闪烁
  583.                 DelayMs(300);                                // 延时0.3秒左右
  584.             }
  585.             
  586.             if(KeySet_P==0)
  587.             {
  588.                 break;
  589.             }
  590.         }
  591.         
  592.         /* 退出前的设置 */
  593.         LcdWriteCmd(0x0C);            // 关闭光标闪烁
  594.         DS1302_Write_Time();        // 把新设置的时间值存入DS1302芯片
  595.         DelayMs(10);                        // 延时等待，消除按键按下的抖动
  596.         while(!KeySet_P);                // 等待按键释放
  597.         DelayMs(10);                        // 延时等待，消除按键松开的抖动
  598.     }
  599. }


  602. /*********************************************************/
  603. // 按键扫描(设置窗帘的动作)
  604. /*********************************************************/
  605. void KeyScanf2()
  606. {
  607.     if(KeySet2_P==0)
  608.     {
  609.         LcdGotoXY(0,0);                                        // 光标定位
  610.         LcdPrintStr(" OpenTime   :   ");    // 显示第1行内容
  611.         LcdGotoXY(1,0);                                        // 光标定位
  612.         LcdPrintStr("CloseTime   :   ");    // 显示第2行内容
  613.         LcdGotoXY(0,10);                                    // 光标定位
  614.         LcdPrintNum(OpenHour);                        // 显示开启窗帘的小时
  615.         LcdGotoXY(0,13);                                    // 光标定位
  616.         LcdPrintNum(OpenMinute);                    // 显示开启窗帘的分钟
  617.         LcdGotoXY(1,10);                                    // 光标定位
  618.         LcdPrintNum(CloseHour);                        // 显示关闭窗帘的小时
  619.         LcdGotoXY(1,13);                                    // 光标定位
  620.         LcdPrintNum(CloseMinute);                    // 显示关闭窗帘的分钟        
  621.         
  622.         LcdWriteCmd(0x0f);                            // 启动光标闪烁
  623.         LcdGotoXY(0,11);                                // 定位光标
  624.         DelayMs(10);                                        // 延时等待，消除按键按下的抖动
  625.         while(!KeySet2_P);                            // 等待按键释放
  626.         DelayMs(10);                                        // 延时等待，消除按键松开的抖动
  627.         
  628.         /* 调整开启的小时 */
  629.         while(1)
  630.         {
  631.             if(KeyDown_P==0)                            // 如果减按键被下去
  632.             {
  633.                 if(OpenHour>0)                            // 判断小时是否大于0        
  634.                     OpenHour--;                                // 是的话就减去1
  635.                 LcdGotoXY(0,10);                        // 光标定位
  636.                 LcdPrintNum(OpenHour);            // 刷新显示改变后的小时
  637.                 LcdGotoXY(0,11);                        // 定位光标
  638.                 DelayMs(300);                                // 延时0.3秒左右
  639.             }
  640.             
  641.             if(KeyUp_P==0)                                // 如果加按键被下去
  642.             {
  643.                 if(OpenHour<23)                            // 判断小时是否小于23
  644.                     OpenHour++;                                // 是的话就加上1
  645.                 LcdGotoXY(0,10);                        // 光标定位
  646.                 LcdPrintNum(OpenHour);            // 刷新显示改变后的小时
  647.                 LcdGotoXY(0,11);                        // 定位光标
  648.                 DelayMs(300);                                // 延时0.3秒左右
  649.             }
  650.             
  651.             if(KeySet2_P==0)
  652.             {
  653.                 break;
  654.             }
  655.         }
  656.         
  657.         LcdGotoXY(0,14);                                // 定位光标
  658.         DelayMs(10);                                        // 延时等待，消除按键按下的抖动
  659.         while(!KeySet2_P);                            // 等待按键释放
  660.         DelayMs(10);                                        // 延时等待，消除按键松开的抖动
  661.         
  662.         /* 调整开启的分钟 */
  663.         while(1)
  664.         {
  665.             if(KeyDown_P==0)                            // 如果减按键被下去
  666.             {
  667.                 if(OpenMinute>0)                        // 判断分钟是否大于0
  668.                     OpenMinute--;                            // 是的话就减去1
  669.                 LcdGotoXY(0,13);                        // 光标定位
  670.                 LcdPrintNum(OpenMinute);        // 刷新显示改变后的分钟
  671.                 LcdGotoXY(0,14);                        // 定位光标
  672.                 DelayMs(300);                                // 延时0.3秒左右
  673.             }
  674.             
  675.             if(KeyUp_P==0)                                // 如果加按键被下去
  676.             {
  677.                 if(OpenMinute<59)                        // 判断分钟是否小于59
  678.                     OpenMinute++;                            // 是的话就加上1
  679.                 LcdGotoXY(0,13);                        // 光标定位
  680.                 LcdPrintNum(OpenMinute);        // 刷新显示改变后的分钟
  681.                 LcdGotoXY(0,14);                        // 定位光标
  682.                 DelayMs(300);                                // 延时0.3秒左右
  683.             }
  684.             
  685.             if(KeySet2_P==0)
  686.             {
  687.                 break;
  688.             }
  689.         }
  690.         
  691.         LcdGotoXY(1,11);                                // 定位光标
  692.         DelayMs(10);                                        // 延时等待，消除按键按下的抖动
  693.         while(!KeySet2_P);                            // 等待按键释放
  694.         DelayMs(10);                                        // 延时等待，消除按键松开的抖动
  695.         
  696.         /* 调整关闭的小时 */
  697.         while(1)
  698.         {
  699.             if(KeyDown_P==0)                            // 如果减按键被下去
  700.             {
  701.                 if(CloseHour>0)                            // 判断小时是否大于0        
  702.                     CloseHour--;                            // 是的话就减去1
  703.                 LcdGotoXY(1,10);                        // 光标定位
  704.                 LcdPrintNum(CloseHour);            // 刷新显示改变后的小时
  705.                 LcdGotoXY(1,11);                        // 定位光标
  706.                 DelayMs(300);                                // 延时0.3秒左右
  707.             }
  708.             
  709.             if(KeyUp_P==0)                                // 如果加按键被下去
  710.             {
  711.                 if(CloseHour<23)                        // 判断小时是否小于23
  712.                     CloseHour++;                            // 是的话就加上1
  713.                 LcdGotoXY(1,10);                        // 光标定位
  714.                 LcdPrintNum(CloseHour);            // 刷新显示改变后的小时
  715.                 LcdGotoXY(1,11);                        // 定位光标
  716.                 DelayMs(300);                                // 延时0.3秒左右
  717.             }
  718.             
  719.             if(KeySet2_P==0)
  720.             {
  721.                 break;
  722.             }
  723.         }
  724.         
  725.         LcdGotoXY(1,14);                                // 定位光标
  726.         DelayMs(10);                                        // 延时等待，消除按键按下的抖动
  727.         while(!KeySet2_P);                            // 等待按键释放
  728.         DelayMs(10);                                        // 延时等待，消除按键松开的抖动
  729.         
  730.         /* 调整关闭的分钟 */
  731.         while(1)
  732.         {
  733.             if(KeyDown_P==0)                            // 如果减按键被下去
  734.             {
  735.                 if(CloseMinute>0)                        // 判断分钟是否大于0
  736.                     CloseMinute--;                        // 是的话就减去1
  737.                 LcdGotoXY(1,13);                        // 光标定位
  738.                 LcdPrintNum(CloseMinute);        // 刷新显示改变后的分钟
  739.                 LcdGotoXY(1,14);                        // 定位光标
  740.                 DelayMs(300);                                // 延时0.3秒左右
  741.             }
  742.             
  743.             if(KeyUp_P==0)                                // 如果加按键被下去
  744.             {
  745.                 if(CloseMinute<59)                    // 判断分钟是否小于59
  746.                     CloseMinute++;                        // 是的话就加上1
  747.                 LcdGotoXY(1,13);                        // 光标定位
  748.                 LcdPrintNum(CloseMinute);        // 刷新显示改变后的分钟
  749.                 LcdGotoXY(1,14);                        // 定位光标
  750.                 DelayMs(300);                                // 延时0.3秒左右
  751.             }
  752.             
  753.             if(KeySet2_P==0)
  754.             {
  755.                 break;
  756.             }
  757.         }
  758.         
  759.         DelayMs(10);                                        // 延时等待，消除按键按下的抖动
  760.         while(!KeySet2_P);                            // 等待按键释放
  761.         DelayMs(10);                                        // 延时等待，消除按键松开的抖动
  762.         
  763.         /* 光照强度的设置 */
  764.         LcdWriteCmd(0x0C);                                // 关闭光标闪烁
  765.         LcdGotoXY(0,0);                                        // 光标定位
  766.         LcdPrintStr("   Light Set    ");    // 显示第1行内容
  767.         LcdGotoXY(1,0);                                        // 光标定位
  768.         LcdPrintStr("                ");    // 显示第2行内容
  769.         LcdGotoXY(1,7);                                        // 光标定位
  770.         LcdPrintNum(gLight);                            // 显示窗帘的光线控制强度阈值
  771.         
  772.         while(1)
  773.         {
  774.             if(KeyDown_P==0)                            // 如果减按键被下去
  775.             {
  776.                 if(gLight>0)                                // 判断光线阈值是否大于0
  777.                     gLight--;                                    // 是的话就减去1
  778.                 LcdGotoXY(1,7);                            // 光标定位
  779.                 LcdPrintNum(gLight);                // 刷新显示改变后的光线阈值
  780.                 DelayMs(300);                                // 延时0.3秒左右
  781.             }
  782.             
  783.             if(KeyUp_P==0)                                // 如果加按键被下去
  784.             {
  785.                 if(gLight<99)                                // 判断光线阈值是否小于59
  786.                     gLight++;                                    // 是的话就加上1
  787.                 LcdGotoXY(1,7);                            // 光标定位
  788.                 LcdPrintNum(gLight);                // 刷新显示改变后的光线阈值
  789.                 DelayMs(300);                                // 延时0.3秒左右
  790.             }
  791.             
  792.             if(KeySet2_P==0)
  793.             {
  794.                 break;
  795.             }
  796.         }
  797.         
  798.         /* 退出前的设置 */
  799.         LcdShowInit();                    // 液晶显示内容初始化
  800.         DelayMs(10);                        // 延时等待，消除按键按下的抖动
  801.         while(!KeySet2_P);            // 等待按键释放
  802.         DelayMs(10);                        // 延时等待，消除按键松开的抖动
  803.     }
  804. }


  807. /*********************************************************/
  808. // 按键扫描(模式切换)
  809. /*********************************************************/
  810. void KeyScanf3()
  811. {
  812.     if(KeyMode_P==0)
  813.     {
  814.         gMode++;                            // 切换到下一模式
  815.         if(gMode==4)                    // 如果到尽头了
  816.             gMode=1;                        // 回到第一种模式
  817.         LcdGotoXY(1,0);                // 光标定位
  818.         LcdPrintMode(gMode);    // 显示模式
  819.         DelayMs(10);                    // 去除按键按下的抖动
  820.         while(!KeyMode_P);        // 等待按键是否
  821.         DelayMs(10);                    // 去除按键松开的抖动
  822.     }
  823. }


  826. /*********************************************************/
  827. // 开窗
  828. /*********************************************************/
  829. void Open()
  830. {
  831.     uint i;
  832.     for(i=0;i<4;i++)
  833.     {
  834.         P2=Clock[i];
  835.         DelayMs(250);
  836.     }
  837.     Led_P=0;
  838. }



  842. /*********************************************************/
  843. // 关窗
  844. /*********************************************************/
  845. void Close()
  846. {
  847.     uint i;
  848.     for(i=0;i<4;i++)
  849.     {
  850.         P2=AntiClock[i];
  851.         DelayMs(250);
  852.     }
  853.     Led_P=1;
  854. }



  858. /*********************************************************/
  859. // 主函数
  860. /*********************************************************/
  861. void main()
  862. {
  863.     uchar light;
  864.    
  865.     LcdInit();            // 执行液晶初始化   
  866.     DS1302_Init();    // 时钟芯片的初始化
  867.     LcdShowInit();    // 液晶显示内容的初始化
  868.    
  869.     if(DS1302_Read_Byte(0x81)>=128)            // 判断时钟芯片是否正在运行
  870.     {
  871.         DS1302_Write_Time();                            // 如果没有，则初始化一个时间
  872.     }
  873.    
  874.     while(1)
  875.     {
  876.         DS1302_Read_Time();                // 获取当前时钟芯片的时间，存在数组time_buf中
  877.         FlashTime();                            // 刷新时间显示

  879.         light=Get_ADC0832();            // 读取光照强度
  880.         light=light/2.5;                    // 缩小光照检测结果(在0-99)
  881.         if(light>99)                            // 如果大于99
  882.             light=99;                                // 则依然保持99
  883.         LcdGotoXY(1,14);                    // 光标定位
  884.         LcdPrintNum(light);                // 显示光照强度
  885.         
  886.         KeyScanf1();                            // 按键扫描(时间的设置)
  887.         KeyScanf2();                            // 按键扫描(阈值的设置)
  888.         KeyScanf3();                            // 按键扫描(模式切换)
  889.    
  890.         /*手动控制模式*/
  891.         if(gMode==1)
  892.         {
  893.             if(KeyDown_P==0)        // 如果关窗帘键按下了   
  894.             {
  895.                 if(Led_P==0)            // 如果窗帘当前是打开的
  896.                 {
  897.                     Close();                // 则关闭窗帘
  898.                 }
  899.             }
  900.             if(KeyUp_P==0)            // 如果开窗帘键按下了
  901.             {
  902.                 if(Led_P==1)            // 如果窗帘当前是关闭的
  903.                 {
  904.                     Open();                    // 则打开窗帘
  905.                 }
  906.             }   
  907.         }
  908.         
  909.         /*时间控制模式*/
  910.         if(gMode==2)
  911.         {
  912.             if((TimeBuff[4]==CloseHour)&&(TimeBuff[5]==CloseMinute)&&(TimeBuff[6]==0))    // 如果到了关窗帘的时间   
  913.             {
  914.                 if(Led_P==0)            // 如果窗帘当前是打开的
  915.                 {
  916.                     Close();                // 则关闭窗帘
  917.                 }
  918.             }
  919.             if((TimeBuff[4]==OpenHour)&&(TimeBuff[5]==OpenMinute)&&(TimeBuff[6]==0))        // 如果到了开窗帘的时间   
  920.             {
  921.                 if(Led_P==1)            // 如果窗帘当前是关闭的
  922.                 {
  923.                     Open();                    // 则打开窗帘
  924.                 }
  925.             }   
  926.         }
  927.         
  928.         /*光线控制模式*/
  929.         if(gMode==3)
  930.         {
  931.             if(light<gLight)        // 当前光线小于设置的阈值
  932.             {
  933.                 if(Led_P==0)            // 如果窗帘当前是打开的
  934.                 {
  935.                     Close();                // 则关闭窗帘
  936.                 }
  937.             }
  938.             else                                // 当前光线大于或等于设置的阈值
  939.             {
  940.                 if(Led_P==1)            // 如果窗帘当前是关闭的
  941.                 {
  942.                     Open();                    // 则打开窗帘
复制代码

所有资料51hei提供下载:
28__proteus仿真 (1).zip (131.83 KB, 下载次数: 74)

评分

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

查看全部评分

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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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