基于51单片机的智能窗帘程序+原理图PDF格式

[复制链接]
查看13 | 回复0 | 2021-6-15 21:18:42 | 显示全部楼层 |阅读模式
搜集资料做的一个智能窗帘,之前下的别人的 有很多问题,自己全改过来了。实现功能:实时显示、定时开关、光控、温控、手动控制
修改好的源程序+原理图
1.png
单片机部分源程序如下:完整程序如下
  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^0;                         // 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. sbit ds=P3^1;
  21. bit closeflag,openflag;
  22. uchar gMode=1;                                                                // 1是手动模式,2是时间自动模式,3是亮度自动模式
  23. uchar OpenHour    = 18;                                // 开启窗帘的小时
  24. uchar OpenMinute  = 20;                                // 开启窗帘的分钟
  25. uchar CloseHour   = 10;                                // 关闭窗帘的小时
  26. uchar CloseMinute = 30;                                // 关闭窗帘的分钟
  27. uchar gLight      = 40;                                // 窗帘开关的阈值

  28. uchar wDu=35;
  29. uint wd=13,t;
  30. uchar xsflag;

  31. uchar code Clock[]={0x8f,0x4f,0x2f,0x1f};                         // 步进电机顺时针旋转数组
  32. uchar code AntiClock[]={0x1f,0x2f,0x4f,0x8f};                // 步进电机逆时针旋转数组

  33. uchar TimeBuff[7]={17,9,1,6,18,30,40};                                        // 时间数组,默认2017年9月1日,星期五,18:30:40


  34. /*********************************************************/
  35. // 毫秒级的延时函数,time是要延时的毫秒数
  36. /*********************************************************/
  37. void DelayMs(uint time)
  38. {
  39.         uint i,j;
  40.         for(i=0;i<time;i++)
  41.                 for(j=0;j<112;j++);
  42. }
  43. void delay(uint z)                                                  //延时函数
  44. {
  45.         uint x,y;
  46.         for(x=z;x>0;x--)
  47.                 for(y=110;y>0;y--);
  48. }

  49. /*********************************************************/
  50. // 1602液晶写命令函数,cmd就是要写入的命令
  51. /*********************************************************/
  52. void LcdWriteCmd(uchar cmd)
  53. {
  54.         LcdRs_P = 0;
  55.         LcdRw_P = 0;
  56.         LcdEn_P = 0;
  57.         P0=cmd;
  58.         DelayMs(2);
  59.         LcdEn_P = 1;   
  60.         DelayMs(2);
  61.         LcdEn_P = 0;      
  62. }


  63. /*********************************************************/
  64. // 1602液晶写数据函数,dat就是要写入的数据
  65. /*********************************************************/
  66. void LcdWriteData(uchar dat)
  67. {
  68.         LcdRs_P = 1;
  69.         LcdRw_P = 0;
  70.         LcdEn_P = 0;
  71.         P0=dat;
  72.         DelayMs(2);
  73.         LcdEn_P = 1;   
  74.         DelayMs(2);
  75.         LcdEn_P = 0;
  76. }


  77. /*********************************************************/
  78. // 1602液晶初始化函数
  79. /*********************************************************/
  80. void LcdInit()
  81. {
  82.         LcdWriteCmd(0x38);        // 16*2显示,5*7点阵,8位数据口
  83.         LcdWriteCmd(0x0C);        // 开显示,不显示光标
  84.         LcdWriteCmd(0x06);        // 地址加1,当写入数据后光标右移
  85.         LcdWriteCmd(0x01);        // 清屏
  86. }


  87. /*********************************************************/
  88. // 液晶光标定位函数
  89. /*********************************************************/
  90. void LcdGotoXY(uchar line,uchar column)
  91. {
  92.         // 第一行
  93.         if(line==0)        
  94.                 LcdWriteCmd(0x80+column);
  95.         // 第二行
  96.         if(line==1)        
  97.                 LcdWriteCmd(0x80+0x40+column);
  98. }


  99. /*********************************************************/
  100. // 液晶输出字符串函数
  101. /*********************************************************/
  102. void LcdPrintStr(uchar *str)
  103. {
  104.         while(*str!='\0')
  105.                         LcdWriteData(*str++);
  106. }


  107. /*********************************************************/
  108. // 液晶输出数字(0-99)
  109. /*********************************************************/
  110. void LcdPrintNum(uchar num)
  111. {
  112.       
  113.         LcdWriteData(num/10+0x30);                // 十位
  114.         LcdWriteData(num%10+0x30);                 // 个位
  115.       
  116.         //LcdWriteData(num%10+'0');                 // 个位
  117. }

  118. void LcdPrintNum2(uchar num2)
  119. {
  120.       
  121.         LcdWriteData(num2/100+0x30);                // 百位
  122.         LcdWriteData(num2%100/10+0x30);                // 十位
  123.         LcdWriteData(num2%100%10+0x30);                 // 个位

  124. }
  125. /*********************************************************/
  126. // 显示模式
  127. /*********************************************************/
  128. void LcdPrintMode(uchar num)
  129. {
  130.         switch(num)                       
  131.         {
  132.                 case 1: LcdPrintStr("Manual");        break;
  133.                 case 2: LcdPrintStr(" TIME ");        break;
  134.                 case 3: LcdPrintStr("LIGHT ");        break;
  135.                 case 4: LcdPrintStr(" TEMP ");        break;
  136.                 default:                                                                                                break;
  137.         }
  138. }


  139. /*********************************************************/
  140. // 液晶显示内容的初始化
  141. /*********************************************************/
  142. void LcdShowInit()
  143. {
  144.         LcdGotoXY(0,0);
  145.         LcdPrintStr("20'C   -     :  ");
  146.         LcdGotoXY(1,0);
  147.         LcdPrintStr("         gz:    ");
  148.         LcdGotoXY(1,0);
  149.         LcdPrintMode(gMode);
  150. }



  151. /*********************************************************/
  152. // 刷新时间显示
  153. /*********************************************************/
  154. void FlashTime()
  155. {
  156.         LcdGotoXY(0,0);                                                                                // 年份
  157.         LcdPrintNum(wd);
  158.         LcdGotoXY(0,5);                                                                                // 月份
  159.         LcdPrintNum(TimeBuff[1]);
  160.         LcdGotoXY(0,8);                                                                                // 日期
  161.         LcdPrintNum(TimeBuff[2]);
  162.         LcdGotoXY(0,11);                                                                        // 小时
  163.         LcdPrintNum(TimeBuff[4]);
  164.         LcdGotoXY(0,14);                                                                        // 分钟
  165.         LcdPrintNum(TimeBuff[5]);
  166.         LcdGotoXY(0,13);                                                                        // 秒钟
  167.         if(TimeBuff[6]%2==0)                                                        // 秒钟是偶数显示冒号
  168.                 LcdWriteData(':');
  169.         else                                                                                                                        // 秒钟是奇数显示空格
  170.                 LcdWriteData(' ');
  171. }


  172. /*********************************************************/
  173. // 初始化DS1302
  174. /*********************************************************/
  175. void DS1302_Init(void)
  176. {
  177.         RST_P=0;                        // RST脚置低
  178.         SCK_P=0;                        // SCK脚置低
  179.         SDA_P=0;                        // SDA脚置低                              
  180. }


  181. /*********************************************************/
  182. // 从DS1302读出一字节数据
  183. /*********************************************************/
  184. uchar DS1302_Read_Byte(uchar addr)
  185. {
  186.         uchar i;
  187.         uchar temp;
  188.       
  189.         RST_P=1;                                                               
  190.       
  191.         /* 写入目标地址:addr*/
  192.         for(i=0;i<8;i++)
  193.         {     
  194.                 if(addr&0x01)
  195.                         SDA_P=1;
  196.                 else
  197.                         SDA_P=0;
  198.                
  199.                 SCK_P=1;
  200.                 _nop_();
  201.                 SCK_P=0;
  202.                 _nop_();
  203.                
  204.                 addr=addr>> 1;
  205.         }
  206.       
  207.         /* 读出该地址的数据 */
  208.         for(i=0;i<8;i++)
  209.         {
  210.                 temp=temp>>1;
  211.                
  212.                 if(SDA_P)
  213.                         temp|= 0x80;
  214.                 else
  215.                         temp&=0x7F;
  216.                
  217.                 SCK_P=1;
  218.                 _nop_();
  219.                 SCK_P=0;
  220.                 _nop_();
  221.         }
  222.       
  223.         RST_P=0;
  224.       
  225.         return temp;
  226. }


  227. /*********************************************************/
  228. // 向DS1302写入一字节数据
  229. /*********************************************************/
  230. void DS1302_Write_Byte(uchar addr, uchar dat)
  231. {
  232.         uchar i;
  233.       
  234.         RST_P = 1;
  235.       
  236.         /* 写入目标地址:addr*/
  237.         for(i=0;i<8;i++)
  238.         {
  239.                 if(addr&0x01)
  240.                         SDA_P=1;
  241.                 else
  242.                         SDA_P=0;

  243.                 SCK_P=1;
  244.                 _nop_();
  245.                 SCK_P=0;
  246.                 _nop_();
  247.                
  248.                 addr=addr>>1;
  249.         }
  250.       
  251.         /* 写入数据:dat*/
  252.         for(i=0;i<8;i++)
  253.         {
  254.                 if(dat&0x01)
  255.                         SDA_P=1;
  256.                 else
  257.                         SDA_P=0;
  258.       
  259.                 SCK_P=1;
  260.                 _nop_();
  261.                 SCK_P=0;
  262.                 _nop_();
  263.                
  264.                 dat=dat>>1;
  265.         }
  266.       
  267.         RST_P=0;                                       
  268. }


  269. /*********************************************************/
  270. // 向DS1302写入时间数据
  271. /*********************************************************/
  272. void DS1302_Write_Time()
  273. {
  274.   uchar i;
  275.         uchar temp1;
  276.         uchar temp2;
  277.       
  278.         for(i=0;i<7;i++)                        // 十进制转BCD码
  279.         {
  280.                 temp2=TimeBuff[i]%10;
  281.                 TimeBuff[i]=temp1+temp2;
  282.         }
  283.       
  284.         DS1302_Write_Byte(0x8E,0x00);                                                                // 关闭写保护
  285.         DS1302_Write_Byte(0x80,0x80);                                                                // 暂停时钟
  286.         DS1302_Write_Byte(0x8C,TimeBuff[0]);                                // 年
  287.         DS1302_Write_Byte(0x88,TimeBuff[1]);                                // 月
  288.         DS1302_Write_Byte(0x86,TimeBuff[2]);                                // 日
  289.         DS1302_Write_Byte(0x8A,TimeBuff[3]);                                // 星期
  290.         DS1302_Write_Byte(0x84,TimeBuff[4]);                                // 时
  291.         DS1302_Write_Byte(0x82,TimeBuff[5]);                                // 分
  292.         DS1302_Write_Byte(0x80,TimeBuff[6]);                                // 秒
  293.         DS1302_Write_Byte(0x80,TimeBuff[6]&0x7F);                // 运行时钟
  294.         DS1302_Write_Byte(0x8E,0x80);                                                                // 打开写保护  
  295. }



  296. /*********************************************************/
  297. // 从DS1302读出时间数据
  298. /*********************************************************/
  299. void DS1302_Read_Time()  
  300. {
  301.         uchar i;

  302.         TimeBuff[0]=DS1302_Read_Byte(0x8D);                                                // 年
  303.         TimeBuff[1]=DS1302_Read_Byte(0x89);                                                // 月
  304.         TimeBuff[2]=DS1302_Read_Byte(0x87);                                                // 日
  305.         TimeBuff[3]=DS1302_Read_Byte(0x8B);                                                // 星期
  306.         TimeBuff[4]=DS1302_Read_Byte(0x85);                                                // 时
  307.         TimeBuff[5]=DS1302_Read_Byte(0x83);                                                // 分
  308.         TimeBuff[6]=(DS1302_Read_Byte(0x81))&0x7F;                // 秒

  309.         for(i=0;i<7;i++)                // BCD转十进制
  310.         {           
  311.                 TimeBuff[i]=(TimeBuff[i]/16)*10+TimeBuff[i]%16;
  312.         }
  313. }


  314. /*********************************************************/
  315. // ADC0832的时钟脉冲
  316. /*********************************************************/
  317. void WavePlus()
  318. {
  319.         _nop_();
  320.         ADC_CLK = 1;
  321.         _nop_();
  322.         ADC_CLK = 0;
  323. }


  324. /*********************************************************/
  325. // 获取指定通道的A/D转换结果
  326. /*********************************************************/
  327. uchar Get_ADC0832(unsigned char num1 )
  328. {
  329.                
  330.         uchar i,dat1=0,dat2=0;
  331.         ADC_CS  = 0; ADC_CLK = 0;ADC_DAT = 1; _nop_(); _nop_();
  332.         ADC_CLK = 1; _nop_(); _nop_(); ADC_CLK = 0;                         //准备

  333.         ADC_CLK = 1; _nop_(); _nop_();ADC_CLK = 0;                 //开始          核实准备工作
  334.         ADC_DAT = num1; _nop_(); _nop_();ADC_CLK = 1;              //上升沿传地地址的低位
  335.         ADC_DAT = num1; _nop_(); _nop_();ADC_CLK = 0;                    //下降沿传地地址的高位
  336.         ADC_DAT = 1; _nop_(); _nop_();                                   //准备传输数据
  337.         for(i=0;i<8;i++)
  338.         {   
  339.             dat1 = dat1 | ADC_DAT;
  340.                  ADC_CLK = 1; _nop_(); _nop_();
  341.                 ADC_CLK = 0; _nop_(); _nop_();
  342.                
  343.                 dat1 = dat1 << 1 ;
  344.             
  345.         }
  346.         ADC_CS = 1;
  347.         return dat1;
  348.       
  349. }


  350. /*********************************************************/
  351. // 按键扫描(设置当前时间)
  352. /*********************************************************/
  353. void KeyScanf1()
  354. {
  355.         if(KeySet_P==0)
  356.         {
  357.                 LcdGotoXY(0,13);                                // 显示秒钟的冒号
  358.                 LcdWriteData(':');
  359.                
  360.                
  361.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  362.                 while(!KeySet_P);                                // 等待按键释放
  363.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  364.                

  365.                
  366.                 LcdGotoXY(0,6);                                        // 定位光标到月份闪烁
  367.                 LcdWriteCmd(0x0f);                        // 启动光标闪烁
  368.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  369.                 while(!KeySet_P);                                // 等待按键释放
  370.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  371.                        
  372.                 /* 调整月份 */
  373.                 while(1)
  374.                 {
  375.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  376.                         {
  377.                                 if(TimeBuff[1]>1)                                                // 判断月份是否大于1               
  378.                                         TimeBuff[1]--;                                                // 是的话就减去1
  379.                                 LcdGotoXY(0,5);                                                        // 光标定位到月份的位置
  380.                                 LcdPrintNum(TimeBuff[1]);                // 刷新显示改变后的月份
  381.                                 LcdGotoXY(0,6);                                                        // 定位光标到月份闪烁
  382.                                 DelayMs(300);                                                                // 延时0.3秒左右
  383.                         }
  384.                        
  385.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  386.                         {
  387.                                 if(TimeBuff[1]<12)                                        // 判断月份是否小于12
  388.                                         TimeBuff[1]++;                                                // 是的话就加上1
  389.                                 LcdGotoXY(0,5);                                                        // 光标定位到月份的位置
  390.                                 LcdPrintNum(TimeBuff[1]);                // 刷新显示改变后的月份
  391.                                 LcdGotoXY(0,6);                                                        // 定位光标到月份闪烁
  392.                                 DelayMs(300);                                                                // 延时0.3秒左右
  393.                         }
  394.                        
  395.                         if(KeySet_P==0)
  396.                         {
  397.                                 break;
  398.                         }
  399.                 }
  400.                
  401.                 LcdGotoXY(0,9);                                        // 定位光标到日期闪烁
  402.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  403.                 while(!KeySet_P);                                // 等待按键释放
  404.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  405.                
  406.                 /* 调整日期 */
  407.                 while(1)
  408.                 {
  409.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  410.                         {
  411.                                 if(TimeBuff[2]>1)                                                // 判断日期是否大于1               
  412.                                         TimeBuff[2]--;                                                // 是的话就减去1
  413.                                 LcdGotoXY(0,8);                                                        // 光标定位到日期的位置
  414.                                 LcdPrintNum(TimeBuff[2]);                // 刷新显示改变后的日期
  415.                                 LcdGotoXY(0,9);                                                        // 定位光标到日期闪烁
  416.                                 DelayMs(300);                                                                // 延时0.3秒左右
  417.                         }
  418.                        
  419.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  420.                         {
  421.                                 if(TimeBuff[2]<31)                                        // 判断日期是否小于31
  422.                                         TimeBuff[2]++;                                                // 是的话就加上1
  423.                                 LcdGotoXY(0,8);                                                        // 光标定位到日期的位置
  424.                                 LcdPrintNum(TimeBuff[2]);                // 刷新显示改变后的日期
  425.                                 LcdGotoXY(0,9);                                                        // 定位光标到日期闪烁
  426.                                 DelayMs(300);                                                                // 延时0.3秒左右
  427.                         }
  428.                        
  429.                         if(KeySet_P==0)
  430.                         {
  431.                                 break;
  432.                         }
  433.                 }
  434.                
  435.                 LcdGotoXY(0,12);                                // 定位光标到小时闪烁
  436.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  437.                 while(!KeySet_P);                                // 等待按键释放
  438.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  439.                
  440.                
  441.                 /* 调整小时 */
  442.                 while(1)
  443.                 {
  444.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  445.                         {
  446.                                 if(TimeBuff[4]>0)                                                // 判断小时是否大于0
  447.                                         TimeBuff[4]--;                                                // 是的话就减去1
  448.                                 LcdGotoXY(0,11);                                                // 光标定位到小时的位置
  449.                                 LcdPrintNum(TimeBuff[4]);                // 刷新显示改变后的小时
  450.                                 LcdGotoXY(0,12);                                                // 定位光标到小时闪烁
  451.                                 DelayMs(300);                                                                // 延时0.3秒左右
  452.                         }
  453.                        
  454.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  455.                         {
  456.                                 if(TimeBuff[4]<23)                                        // 判断小时是否小于23
  457.                                         TimeBuff[4]++;                                                // 是的话就加上1
  458.                                 LcdGotoXY(0,11);                                                // 光标定位到小时的位置
  459.                                 LcdPrintNum(TimeBuff[4]);                // 刷新显示改变后的小时
  460.                                 LcdGotoXY(0,12);                                                // 定位光标到小时闪烁
  461.                                 DelayMs(300);                                                                // 延时0.3秒左右
  462.                         }
  463.                        
  464.                         if(KeySet_P==0)
  465.                         {
  466.                                 break;
  467.                         }
  468.                 }
  469.                
  470.                 LcdGotoXY(0,15);                                // 定位光标到分钟闪烁
  471.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  472.                 while(!KeySet_P);                                // 等待按键释放
  473.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  474.                
  475.                 /* 调整分钟 */
  476.                 while(1)
  477.                 {
  478.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  479.                         {
  480.                                 if(TimeBuff[5]>0)                                                // 判断分钟是否大于0
  481.                                         TimeBuff[5]--;                                                // 是的话就减去1
  482.                                 LcdGotoXY(0,14);                                                // 光标定位到分钟的位置
  483.                                 LcdPrintNum(TimeBuff[5]);                // 刷新显示改变后的分钟
  484.                                 LcdGotoXY(0,15);                                                // 定位光标到分钟闪烁
  485.                                 DelayMs(300);                                                                // 延时0.3秒左右
  486.                         }
  487.                        
  488.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  489.                         {
  490.                                 if(TimeBuff[5]<59)                                        // 判断分钟是否小于59
  491.                                         TimeBuff[5]++;                                                // 是的话就加上1
  492.                                 LcdGotoXY(0,14);                                                // 光标定位到分钟的位置
  493.                                 LcdPrintNum(TimeBuff[5]);                // 刷新显示改变后的分钟
  494.                                 LcdGotoXY(0,15);                                                // 定位光标到分钟闪烁
  495.                                 DelayMs(300);                                                                // 延时0.3秒左右
  496.                         }
  497.                        
  498.                         if(KeySet_P==0)
  499.                         {
  500.                                 break;
  501.                         }
  502.                 }
  503.                
  504.                 /* 退出前的设置 */
  505.                 LcdWriteCmd(0x0C);                        // 关闭光标闪烁
  506.                 DS1302_Write_Time();                // 把新设置的时间值存入DS1302芯片
  507.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  508.                 while(!KeySet_P);                                // 等待按键释放
  509.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  510.         }
  511. }
  512. uint temp,mm;uchar i;float f_temp;
  513. /*******************************************************
  514. 温度函数
  515. *******************************************************/
  516. void dsreset(void)                                           //下边是温度获取子程衼E
  517. {
  518.         uint i;
  519.         ds=0;
  520.         i=103;
  521.         while(i>0)i--;
  522.         ds=1;
  523.         i=4;
  524.         while(i>0)i--;
  525. }
  526. bit tempreadbit(void)                                   //读一位
  527. {
  528.         uint i;
  529.         bit dat;
  530.         ds=0;i++;
  531.         ds=1;i++;i++;
  532.         dat=ds;
  533.         i=8;while(i>0)i--;
  534.         return(dat);
  535. }
  536. uchar tempread(void)                                         //获取温度
  537. {
  538.         uchar i,j,dat;
  539.         dat=0;
  540.         for(i=1;i<=8;i++)
  541.         {
  542.                 j=tempreadbit();
  543.                 dat=(j<<7)|(dat>>1);
  544.         }
  545.         return(dat);
  546. }
  547. void tempwritebyte(uchar dat)                           //写一个字节
  548. {
  549.         uint i;
  550.         uchar j;
  551.         bit testb;
  552.         for(j=1;j<=8;j++)
  553.         {
  554.                 testb=dat&0x01;
  555.                 dat=dat>>1;
  556.                 if(testb)
  557.                 {
  558.                         ds=0;
  559.                         i++;i++;
  560.                         ds=1;
  561.                         i=8;while(i>0)i--;
  562.                 }
  563.                 else
  564.                 {
  565.                         ds=0;
  566.                         i=8;while(i>0)i--;
  567.                         ds=1;
  568.                         i++;i++;
  569.                 }
  570.         }
  571. }
  572. void tempchange(void)                                           //温度转换
  573. {
  574.         dsreset();
  575.         delay(1);
  576.         tempwritebyte(0xcc);
  577.         tempwritebyte(0x44);
  578. }
  579. uint get_temp()                                                        //获取温度
  580. {
  581.         uchar a,b;
  582.         dsreset();
  583.         delay(1);
  584.         tempwritebyte(0xcc);
  585.         tempwritebyte(0xbe);
  586.         a=tempread();
  587.         b=tempread();
  588.         temp=b;
  589.         temp<<=8;
  590.         temp=temp|a;
  591.         f_temp=temp*0.0625;
  592.         temp=f_temp*10+0.5;
  593.         f_temp=f_temp+0.05;
  594.         return temp;
  595. }
  596. /***********************************/

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

  792.                 DelayMs(10);                                                                                // 延时等待,消除按键按下的抖动
  793.                 while(!KeySet2_P);                                                        // 等待按键释放
  794.                 DelayMs(10);                                                                                // 延时等待,消除按键松开的抖动

  795.         //                 设置温度
  796.                 LcdWriteCmd(0x0C);                                                                // 关闭光眮E了?
  797.                 LcdGotoXY(0,0);                                                                                // 光眮Eㄎ?
  798.                 LcdPrintStr("   TEMP  Set    ");        // 显示第1行内容
  799.                 LcdGotoXY(1,0);                                                                                // 光眮Eㄎ?
  800.                 LcdPrintStr("                ");        // 显示第2行内容
  801.                 LcdGotoXY(1,7);                                                                                // 光眮Eㄎ?
  802.                 LcdPrintNum(wDu);                                                        // 显示窗帘的光线控制强度阈值      
  803.                 while(1){
  804.                          LcdGotoXY(1,7);                                                                                // 光眮Eㄎ?
  805.                         LcdPrintNum(wDu);                                                        // 显示窗帘的光线控制强度阈值
  806.                         if(KeyDown_P==0)                                                        // 如果减按紒E幌氯?
  807.                         {
  808.                                 if(wDu>0)                                                                // 判断光线阈值是否大于0
  809.                                         wDu--;                                                                        // 是的话就减去1
  810.                                 DelayMs(300);                                                                // 延时0.3脕E笥?
  811.                         }
  812.                        
  813.                         if(KeyUp_P==0)                                                                // 如果加按紒E幌氯?
  814.                         {
  815.                                 if(wDu<99)                                                                // 判断光线阈值是否小于59
  816.                                         wDu++;                                                                        // 是的话就加上1
  817.                                 DelayMs(300);                                                                // 延时0.3脕E笥?
  818.                         }
  819.                         if(KeySet2_P==0)
  820.                         {
  821.                                 break;
  822.                         }
  823.                 }

  824.                
  825.                 /* 退出前的设置 */
  826.                 LcdShowInit();                                        // 液晶显示内容初始化
  827.                 DelayMs(10);                                                // 延时等待,消除按键按下的抖动
  828.                 while(!KeySet2_P);                        // 等待按键释放
  829.                 DelayMs(10);                                                // 延时等待,消除按键松开的抖动
  830.         }
  831. }


  832. /*********************************************************/
  833. // 按键扫描(模式切换)
  834. /*********************************************************/
  835. void KeyScanf3()
  836. {
  837.         if(KeyMode_P==0)
  838.         {
  839.                 gMode++;                                                        // 切换到下一模式
  840.                 if(gMode==5)                                        // 如果到尽头了
  841.                         gMode=1;                                                // 回到第一种模式
  842.                 LcdGotoXY(1,0);                                // 光标定位
  843.                 LcdPrintMode(gMode);        // 显示模式
  844.                 DelayMs(10);                                        // 去除按键按下的抖动
  845.                 while(!KeyMode_P);                // 等待按键是否
  846.                 DelayMs(10);                                        // 去除按键松开的抖动
  847.         }
  848. }


  849. /*********************************************************/
  850. // 开窗
  851. /*********************************************************/
  852. void Open()
  853. {
  854.         uint i,j;
  855.         for(j=0;j<255;j++)                // 控制步进电机正转
  856.         {
  857.                 for(i=0;i<4;i++)
  858.                 {
  859.                         P2=Clock[i];
  860.                         DelayMs(3);
  861.                 }
  862.         }
  863.         Led_P=0;
  864. }



  865. /*********************************************************/
  866. // 关窗
  867. /*********************************************************/
  868. void Close()
  869. {
  870.         uint i,j;
  871.         for(j=0;j<255;j++)                // 控制步进电机反转
  872.         {
  873.                 for(i=0;i<4;i++)
  874.                 {
  875.                         P2=AntiClock[i];
  876.                         DelayMs(3);
  877.                 }
  878.         }
  879.         Led_P=1;
  880. }



  881. /*********************************************************/
  882. // 主函数
  883. /*********************************************************/
  884. void main()
  885. {
  886.         uchar light;
  887.       
  888.         LcdInit();                        // 执行液晶初始化      
  889.         DS1302_Init();        // 时钟芯片的初始化
  890.         LcdShowInit();        // 液晶显示内容的初始化
  891.         if(DS1302_Read_Byte(0x81)>=128)                        // 判断时钟芯片是否正在运行
  892.         {
  893.                 DS1302_Write_Time();                                                        // 如果没有,则初始化一个时间
  894.         }
  895.       
  896.         while(1)
  897.         {
  898.                 tempchange();
  899.                 t=get_temp();
  900.                 if(t>=0&&t<=1250)  //温度合法范围,不在这个范围就是没有获取到合适的值
  901.                 {
  902.                         wd=t/10;
  903.                 }
  904.                        
  905. //                if(yudi==0 && gMode > 1){  //检测到有雨,并且不在手动模式(雨天想开窗必须是手动模式下才能开)
  906. //                        delay(5);
  907. //                        if(yudi==0){
  908. //                           gMode=5;//立即切换到手动模式,防止雨停自动开启窗帘
  909. //                           LcdGotoXY(1,0);                                // 光标定位
  910. //                                LcdPrintMode(gMode);        // 显示模式
  911. //                                DelayMs(10);                                        // 去除按键按下的抖动
  912. //                                 if(Led_P==0)                        // 如果窗帘当前是打开的
  913. //                                {
  914. //                                        Close();                                // 则关闭窗帘
  915. //                                }
  916. //                        }
  917. //                }

  918.                 DS1302_Read_Time();                                // 获取当前时钟芯片的时间,存在数组time_buf中
  919.                 FlashTime();                                                        // 刷新时间显示

  920.                 light=Get_ADC0832(1);                        // 读取光照强度
  921.                 //light=light/2;                                        // 缩小光照检测结果(在0-99)
  922.                 LcdGotoXY(1,13);                                        // 光标定位
  923.           LcdPrintNum2(light);
  924. ……………………

  925. …………限于本文篇幅 余下代码请下载附件…………
复制代码
电路原理图.pdf (65.8 KB)
回复

使用道具 举报

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

本版积分规则