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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › 单片机程序 固定的时间内温度控制窗帘开关 求帮助
返回列表 发新帖
查看: 1249|回复: 1
打印 上一主题 下一主题
收起左侧

单片机程序 固定的时间内温度控制窗帘开关 求帮助

[复制链接]
跳转到指定楼层
楼主
ID:630692 发表于 2019-10-26 22:12 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
每天在一定时候打开窗户，关上窗户，然后在这个时间内温度控制窗帘关和开,用51单片机


这个用不了

  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^0;                         // 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;                                // 指示灯
  23. sbit ds=P3^1;
  24. bit closeflag,openflag;
  25. uchar gMode=1;                                                                // 1是手动模式，2是时间自动模式，3是亮度自动模式
  26. uchar gLight      = 40;                                // 窗帘开关的阈值
  27. uchar wDu=35;
  28. uint wd=13,t;
  29. uchar xsflag;

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

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



  45. /*********************************************************/
  46. // 毫秒级的延时函数，time是要延时的毫秒数
  47. /*********************************************************/
  48. void DelayMs(uint time)
  49. {
  50.         uint i,j;
  51.         for(i=0;i<time;i++)
  52.                 for(j=0;j<112;j++);
  53. }
  54. void delay(uint z)                                                  //延时函数
  55. {
  56.         uint x,y;
  57.         for(x=z;x>0;x--)
  58.                 for(y=110;y>0;y--);
  59. }

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


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


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


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


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


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


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


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



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


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


  204. /*********************************************************/
  205. // 从DS1302读出一字节数据
  206. /*********************************************************/
  207. uchar DS1302_Read_Byte(uchar addr)
  208. {
  209.         uchar i;
  210.         uchar temp;

  212.         RST_P=1;                                                               

  214.         /* 写入目标地址：addr*/
  215.         for(i=0;i<8;i++)
  216.         {     
  217.                 if(addr&0x01)
  218.                         SDA_P=1;
  219.                 else
  220.                         SDA_P=0;
  221.                 _nop_();

  223.                 addr=addr>> 1;
  224.         }

  226.         /* 读出该地址的数据 */
  227.         for(i=0;i<8;i++)
  228.         {
  229.                 temp=temp>>1;

  231.                 if(SDA_P)
  232.                         temp|= 0x80;
  233.                 else
  234.                         temp&=0x7F;

  236.                 SCK_P=1;
  237.                 _nop_();
  238.                 SCK_P=0;
  239.                 _nop_();
  240.         }

  242.         RST_P=0;

  244.         return temp;
  245. }


  248. /*********************************************************/
  249. // 向DS1302写入一字节数据
  250. /*********************************************************/
  251. void DS1302_Write_Byte(uchar addr, uchar dat)
  252. {
  253.         uchar i;

  255.         RST_P = 1;

  257.         /* 写入目标地址：addr*/
  258.         for(i=0;i<8;i++)
  259.         {
  260.                 if(addr&0x01)
  261.                         SDA_P=1;
  262.                 else
  263.                         SDA_P=0;

  265.                 SCK_P=1;
  266.                 _nop_();
  267.                 SCK_P=0;
  268.                 _nop_();

  270.                 addr=addr>>1;
  271.         }

  273.         /* 写入数据：dat*/
  274.         for(i=0;i<8;i++)
  275.         {
  276.                 if(dat&0x01)
  277.                         SDA_P=1;
  278.                 else
  279.                         SDA_P=0;

  281.                 SCK_P=1;
  282.                 _nop_();
  283.                 SCK_P=0;
  284.                 _nop_();

  286.                 dat=dat>>1;
  287.         }

  289.         RST_P=0;                                       
  290. }


  293. /*********************************************************/
  294. // 向DS1302写入时间数据
  295. /*********************************************************/
  296. void DS1302_Write_Time()
  297. {
  298.   uchar i;
  299.         uchar temp1;
  300.         uchar temp2;

  302.         for(i=0;i<7;i++)                        // 十进制转BCD码
  303.         {
  304.                 temp1=(TimeBuff[i]/10)<<4;
  305.                 temp2=TimeBuff[i]%10;
  306.                 TimeBuff[i]=temp1+temp2;
  307.         }

  309.         DS1302_Write_Byte(0x8E,0x00);                                                                // 关闭写保护
  310.         DS1302_Write_Byte(0x80,0x80);                                                                // 暂停时钟
  311.         DS1302_Write_Byte(0x8C,TimeBuff[0]);                                // 年
  312.         DS1302_Write_Byte(0x88,TimeBuff[1]);                                // 月
  313.         DS1302_Write_Byte(0x86,TimeBuff[2]);                                // 日
  314.         DS1302_Write_Byte(0x8A,TimeBuff[3]);                                // 星期
  315.         DS1302_Write_Byte(0x84,TimeBuff[4]);                                // 时
  316.         DS1302_Write_Byte(0x82,TimeBuff[5]);                                // 分
  317.         DS1302_Write_Byte(0x80,TimeBuff[6]);                                // 秒
  318.         DS1302_Write_Byte(0x80,TimeBuff[6]&0x7F);                // 运行时钟
  319.         DS1302_Write_Byte(0x8E,0x80);                                                                // 打开写保护  
  320. }



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

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

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


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


  358. /*********************************************************/
  359. // 获取指定通道的A/D转换结果
  360. /*********************************************************/
  361. uchar Get_ADC0832()
  362. {
  363.         uchar i;
  364.         uchar dat1=0;
  365.         uchar dat2=0;

  367.         ADC_CLK = 0;                                // 电平初始化
  368.         ADC_DAT = 1;
  369.         _nop_();
  370.         ADC_CS = 0;
  371.         WavePlus();                                        // 起始信号
  372.         ADC_DAT = 1;
  373.         WavePlus();                                        // 通道选择的第一位
  374.         ADC_DAT = 0;      
  375.         WavePlus();                                        // 通道选择的第二位
  376.         ADC_DAT = 1;

  378.         for(i=0;i<8;i++)                // 第一次读取
  379.         {
  380.                 dat1<<=1;
  381.                 WavePlus();
  382.                 if(ADC_DAT)
  383.                         dat1=dat1|0x01;
  384.                 else
  385.                         dat1=dat1|0x00;
  386.         }

  388.         for(i=0;i<8;i++)                // 第二次读取
  389.         {
  390.                 dat2>>= 1;
  391.                 if(ADC_DAT)
  392.                         dat2=dat2|0x80;
  393.                 else
  394.                         dat2=dat2|0x00;
  395.                 WavePlus();
  396.         }

  398.         _nop_();                                                // 结束此次传输
  399.         ADC_CS  = 1;   

  401.         if(dat1==dat2)                        // 返回采集结果
  402.                 return dat1;
  403.         else
  404.                 return 0;
  405. }


  408. /*********************************************************/
  409. // 按键扫描(设置当前时间)
  410. /*********************************************************/
  411. void KeyScanf1()
  412. {
  413.         if(KeySet_P==0)
  414.         {
  415.                 LcdGotoXY(0,13);                                // 显示秒钟的冒号
  416.                 LcdWriteData(':');
  417.                 LcdWriteCmd(0x0f);                        // 启动光标闪烁
  418.                 LcdGotoXY(0,6);                                        // 定位光标到年份闪烁
  419.                 DelayMs(10);                                                // 延时等待，消除按键按下的抖动
  420.                 while(!KeySet_P);                                // 等待按键释放
  421.                 DelayMs(10);                                                // 延时等待，消除按键松开的抖动

  423. //                 /* 调整年份 */
  424. //                 while(1)
  425. //                 {
  426. //                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  427. //                         {
  428. //                                 if(TimeBuff[0]>0)                                                // 判断年份是否大于0               
  429. //                                         TimeBuff[0]--;                                                // 是的话就减去1
  430. //                                 LcdGotoXY(0,2);                                                        // 光标定位到年份的位置
  431. //                                 LcdPrintNum(TimeBuff[0]);                // 刷新显示改变后的年份
  432. //                                 LcdGotoXY(0,3);                                                        // 定位光标到年份闪烁
  433. //                                 DelayMs(300);                                                                // 延时0.3秒左右
  434. //                         }
  435. //                        
  436. //                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  437. //                         {
  438. //                                 if(TimeBuff[0]<99)                                        // 判断年份是否小于99
  439. //                                         TimeBuff[0]++;                                                // 是的话就加上1
  440. //                                 LcdGotoXY(0,2);                                                        // 光标定位到年份的位置
  441. //                                 LcdPrintNum(TimeBuff[0]);                // 刷新显示改变后的年份
  442. //                                 LcdGotoXY(0,3);                                                        // 定位光标到年份闪烁
  443. //                                 DelayMs(300);                                                                // 延时0.3秒左右
  444. //                         }
  445. //                        
  446. //                         if(KeySet_P==0)
  447. //                         {
  448. //                                 break;
  449. //                         }
  450. //                 }

  452.                 LcdGotoXY(0,6);                                        // 定位光标到月份闪烁
  453.                 DelayMs(10);                                                // 延时等待，消除按键按下的抖动
  454.                 while(!KeySet_P);                                // 等待按键释放
  455.                 DelayMs(10);                                                // 延时等待，消除按键松开的抖动

  457.                 /* 调整月份 */
  458.                 while(1)
  459.                 {
  460.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  461.                         {
  462.                                 if(TimeBuff[1]>1)                                                // 判断月份是否大于1               
  463.                                         TimeBuff[1]--;                                                // 是的话就减去1
  464.                                 LcdGotoXY(0,5);                                                        // 光标定位到月份的位置
  465.                                 LcdPrintNum(TimeBuff[1]);                // 刷新显示改变后的月份
  466.                                 LcdGotoXY(0,6);                                                        // 定位光标到月份闪烁
  467.                                 DelayMs(300);                                                                // 延时0.3秒左右
  468.                         }

  470.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  471.                         {
  472.                                 if(TimeBuff[1]<12)                                        // 判断月份是否小于12
  473.                                         TimeBuff[1]++;                                                // 是的话就加上1
  474.                                 LcdGotoXY(0,5);                                                        // 光标定位到月份的位置
  475.                                 LcdPrintNum(TimeBuff[1]);                // 刷新显示改变后的月份
  476.                                 LcdGotoXY(0,6);                                                        // 定位光标到月份闪烁
  477.                                 DelayMs(300);                                                                // 延时0.3秒左右
  478.                         }

  480.                         if(KeySet_P==0)
  481.                         {
  482.                                 break;
  483.                         }
  484.                 }

  486.                 LcdGotoXY(0,9);                                        // 定位光标到日期闪烁
  487.                 DelayMs(10);                                                // 延时等待，消除按键按下的抖动
  488.                 while(!KeySet_P);                                // 等待按键释放
  489.                 DelayMs(10);                                                // 延时等待，消除按键松开的抖动

  491.                 /* 调整日期 */
  492.                 while(1)
  493.                 {
  494.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  495.                         {
  496.                                 if(TimeBuff[2]>1)                                                // 判断日期是否大于1               
  497.                                         TimeBuff[2]--;                                                // 是的话就减去1
  498.                                 LcdGotoXY(0,8);                                                        // 光标定位到日期的位置
  499.                                 LcdPrintNum(TimeBuff[2]);                // 刷新显示改变后的日期
  500.                                 LcdGotoXY(0,9);                                                        // 定位光标到日期闪烁
  501.                                 DelayMs(300);                                                                // 延时0.3秒左右
  502.                         }

  504.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  505.                         {
  506.                                 if(TimeBuff[2]<31)                                        // 判断日期是否小于31
  507.                                         TimeBuff[2]++;                                                // 是的话就加上1
  508.                                 LcdGotoXY(0,8);                                                        // 光标定位到日期的位置
  509.                                 LcdPrintNum(TimeBuff[2]);                // 刷新显示改变后的日期
  510.                                 LcdGotoXY(0,9);                                                        // 定位光标到日期闪烁
  511.                                 DelayMs(300);                                                                // 延时0.3秒左右
  512.                         }

  514.                         if(KeySet_P==0)
  515.                         {
  516.                                 break;
  517.                         }
  518.                 }

  520.                 LcdGotoXY(0,12);                                // 定位光标到小时闪烁
  521.                 DelayMs(10);                                                // 延时等待，消除按键按下的抖动
  522.                 while(!KeySet_P);                                // 等待按键释放
  523.                 DelayMs(10);                                                // 延时等待，消除按键松开的抖动


  526.                 /* 调整小时 */
  527.                 while(1)
  528.                 {
  529.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  530.                         {
  531.                                 if(TimeBuff[4]>0)                                                // 判断小时是否大于0
  532.                                         TimeBuff[4]--;                                                // 是的话就减去1
  533.                                 LcdGotoXY(0,11);                                                // 光标定位到小时的位置
  534.                                 LcdPrintNum(TimeBuff[4]);                // 刷新显示改变后的小时
  535.                                 LcdGotoXY(0,12);                                                // 定位光标到小时闪烁
  536.                                 DelayMs(300);                                                                // 延时0.3秒左右
  537.                         }

  539.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  540.                         {
  541.                                 if(TimeBuff[4]<23)                                        // 判断小时是否小于23
  542.                                         TimeBuff[4]++;                                                // 是的话就加上1
  543.                                 LcdGotoXY(0,11);                                                // 光标定位到小时的位置
  544.                                 LcdPrintNum(TimeBuff[4]);                // 刷新显示改变后的小时
  545.                                 LcdGotoXY(0,12);                                                // 定位光标到小时闪烁
  546.                                 DelayMs(300);                                                                // 延时0.3秒左右
  547.                         }

  549.                         if(KeySet_P==0)
  550.                         {
  551.                                 break;
  552.                         }
  553.                 }

  555.                 LcdGotoXY(0,15);                                // 定位光标到分钟闪烁
  556.                 DelayMs(10);                                                // 延时等待，消除按键按下的抖动
  557.                 while(!KeySet_P);                                // 等待按键释放
  558.                 DelayMs(10);                                                // 延时等待，消除按键松开的抖动

  560.                 /* 调整分钟 */
  561.                 while(1)
  562.                 {
  563.                         if(KeyDown_P==0)                                                        // 如果减按键被下去
  564.                         {
  565.                                 if(TimeBuff[5]>0)                                                // 判断分钟是否大于0
  566.                                         TimeBuff[5]--;                                                // 是的话就减去1
  567.                                 LcdGotoXY(0,14);                                                // 光标定位到分钟的位置
  568.                                 LcdPrintNum(TimeBuff[5]);                // 刷新显示改变后的分钟
  569.                                 LcdGotoXY(0,15);                                                // 定位光标到分钟闪烁
  570.                                 DelayMs(300);                                                                // 延时0.3秒左右
  571.                         }

  573.                         if(KeyUp_P==0)                                                                // 如果加按键被下去
  574.                         {
  575.                                 if(TimeBuff[5]<59)                                        // 判断分钟是否小于59
  576.                                         TimeBuff[5]++;                                                // 是的话就加上1
  577.                                 LcdGotoXY(0,14);                                                // 光标定位到分钟的位置
  578.                                 LcdPrintNum(TimeBuff[5]);                // 刷新显示改变后的分钟
  579.                                 LcdGotoXY(0,15);                                                // 定位光标到分钟闪烁
  580.                                 DelayMs(300);                                                                // 延时0.3秒左右
  581.                         }

  583.                         if(KeySet_P==0)
  584.                         {
  585.                                 break;
  586.                         }
  587.                 }

  589.                 /* 退出前的设置 */
  590.                 LcdWriteCmd(0x0C);                        // 关闭光标闪烁
  591.                 DS1302_Write_Time();                // 把新设置的时间值存入DS1302芯片
  592.                 DelayMs(10);                                                // 延时等待，消除按键按下的抖动
  593.                 while(!KeySet_P);                                // 等待按键释放
  594.                 DelayMs(10);                                                // 延时等待，消除按键松开的抖动
  595.         }
  596. }
  597. uint temp,mm;uchar i;float f_temp;
  598. /*******************************************************
  599. 温度函数
  600. *******************************************************/
  601. void dsreset(void)                                           //下边是温度获取子程衼E
  602. {
  603.         uint i;
  604.         ds=0;
  605.         i=103;
  606.         while(i>0)i--;
  607.         ds=1;
  608.         i=4;
  609.         while(i>0)i--;
  610. }
  611. bit tempreadbit(void)                                   //读一位
  612. {
  613.         uint i;
  614.         bit dat;
  615.         ds=0;i++;
  616.         ds=1;i++;i++;
  617.         dat=ds;
  618.         i=8;while(i>0)i--;
  619.         return(dat);
  620. }
  621. uchar tempread(void)                                         //获取温度
  622. {
  623.         uchar i,j,dat;
  624.         dat=0;
  625.         for(i=1;i<=8;i++)
  626.         {
  627.                 j=tempreadbit();
  628.                 dat=(j<<7)|(dat>>1);
  629.         }
  630.         return(dat);
  631. }
  632. void tempwritebyte(uchar dat)                           //写一个字节
  633. {
  634.         uint i;
  635.         uchar j;
  636.         bit testb;
  637.         for(j=1;j<=8;j++)
  638.         {
  639.                 testb=dat&0x01;
  640.                 dat=dat>>1;
  641.                 if(testb)
  642.                 {
  643.                         ds=0;
  644.                         i++;i++;
  645.                         ds=1;
  646.                         i=8;while(i>0)i--;
  647.                 }
  648.                 else
  649.                 {
  650.                         ds=0;
  651.                         i=8;while(i>0)i--;
  652.                         ds=1;
  653.                         i++;i++;
  654.                 }
  655.         }
  656. }
  657. void tempchange(void)                                           //温度转换
  658. {
  659.         dsreset();
  660.         delay(1);
  661.         tempwritebyte(0xcc);
  662.         tempwritebyte(0x44);
  663. }
  664. uint get_temp()                                                        //获取温度
  665. {
  666.         uchar a,b;
  667.         dsreset();
  668.         delay(1);
  669.         tempwritebyte(0xcc);
  670.         tempwritebyte(0xbe);
  671.         a=tempread();
  672.         b=tempread();
  673.         temp=b;
  674.         temp<<=8;
  675.         temp=temp|a;
  676.         f_temp=temp*0.0625;
  677.         temp=f_temp*10+0.5;
  678.         f_temp=f_temp+0.05;
  679.         return temp;
  680. }
  681. /***********************************/

  683. /*********************************************************/
  684. // 按键扫描(设置窗帘的动作)
  685. /*********************************************************/
  686. void KeyScanf2()
  687. {
  688.         if(KeySet2_P==0)
  689.         {
  690.                 xsflag++;
  691.                 if(xsflag>=2)
  692.                         xsflag=0;
  693.                 while(!KeySet2_P);
  694.         }
  695.         if(xsflag==1)
  696.         {
  697.                 //                 /* 光照强度的设置 */
  698.                 LcdWriteCmd(0x0C);                                                                // 关闭光眮E了?
  699.                 LcdGotoXY(0,0);                                                                                // 光眮Eㄎ?
  700.                 LcdPrintStr("   Light Set    ");        // 显示第1行内容
  701.                 LcdGotoXY(1,0);                                                                                // 光眮Eㄎ?
  702.                 LcdPrintStr("                ");        // 显示第2行内容
  703.                 LcdGotoXY(1,7);                                                                                // 光眮Eㄎ?
  704.                 LcdPrintNum(gLight);                                                        // 显示窗帘的光线控制强度阈值

  706.                 while(1)
  707.                 {
  708.                         if(KeySet2_P==0)
  709.                         {
  710.                                 xsflag++;
  711.                                 if(xsflag>=3)
  712.                                         xsflag=0;
  713.                                 while(!KeySet2_P);
  714.                         }
  715.                         if(xsflag==1)
  716.                         {
  717.                                 if(KeyDown_P==0)                                                        // 如果减按紒E幌氯?
  718.                                 {
  719.                                         if(gLight>0)                                                                // 判断光线阈值是否大于0
  720.                                                 gLight--;                                                                        // 是的话就减去1
  721.                                         LcdGotoXY(1,7);                                                        // 光眮Eㄎ?
  722.                                         LcdPrintNum(gLight);                                // 刷新显示改变后的光线阈值
  723.                                         DelayMs(300);                                                                // 延时0.3脕E笥?
  724.                                 }

  726.                                 if(KeyUp_P==0)                                                                // 如果加按紒E幌氯?
  727.                                 {
  728.                                         if(gLight<99)                                                                // 判断光线阈值是否小于59
  729.                                                 gLight++;                                                                        // 是的话就加上1
  730.                                         LcdGotoXY(1,7);                                                        // 光眮Eㄎ?
  731.                                         LcdPrintNum(gLight);                                // 刷新显示改变后的光线阈值
  732.                                         DelayMs(300);                                                                // 延时0.3脕E笥?
  733.                                 }
  734.                         }
  735.                         if(xsflag==2)
  736.                         {
  737.                                 //                 设置温度
  738.                                 LcdWriteCmd(0x0C);                                                                // 关闭光眮E了?
  739.                                 LcdGotoXY(0,0);                                                                                // 光眮Eㄎ?
  740.                                 LcdPrintStr("   Wendu Set    ");        // 显示第1行内容
  741.                                 LcdGotoXY(1,0);                                                                                // 光眮Eㄎ?
  742.                                 LcdPrintStr("                ");        // 显示第2行内容
  743.                                 LcdGotoXY(1,7);                                                                                // 光眮Eㄎ?
  744.                                 LcdPrintNum(wDu);                                                        // 显示窗帘的光线控制强度阈值        
  745.                                 while(!KeySet2_P);
  746.                                 while(1)
  747.                                 {
  748.                                         LcdGotoXY(1,7);                                                                                // 光眮Eㄎ?
  749.                                         LcdPrintNum(wDu);                                                        // 显示窗帘的光线控制强度阈值
  750.                                         if(KeyDown_P==0)                                                        // 如果减按紒E幌氯?
  751.                                         {
  752.                                                 if(wDu>0)                                                                // 判断光线阈值是否大于0
  753.                                                         wDu--;                                                                        // 是的话就减去1
  754.                                                 DelayMs(300);                                                                // 延时0.3脕E笥?
  755.                                         }

  757.                                         if(KeyUp_P==0)                                                                // 如果加按紒E幌氯?
  758.                                         {
  759.                                                 if(wDu<99)                                                                // 判断光线阈值是否小于59
  760.                                                         wDu++;                                                                        // 是的话就加上1
  761.                                                 DelayMs(300);                                                                // 延时0.3脕E笥?
  762.                                         }
  763.                                         if(KeySet2_P==0)
  764.                                         {
  765.                                                 break;
  766.                                         }
  767.                                 }
  768.                         }
  769.                         if(xsflag==0)
  770.                         {
  771.                                 break;
  772.                         }
  773.                 }
  774.                         //                 /* 退出前的设置 */
  775.                 LcdShowInit();                                        // 液晶显示内容初始化
  776.                 DelayMs(10);                                                // 延时等待，消除按紒E聪碌亩抖?
  777.                 while(!KeySet2_P);                        // 等待按紒E头?
  778.                 DelayMs(10);
  779.         }
  780. }


  783. /*********************************************************/
  784. // 按键扫描(模式切换)
  785. /*********************************************************/
  786. void KeyScanf3()
  787. {
  788.         if(KeyMode_P==0)
  789.         {
  790.                 DelayMs(10);
  791.                 if(KeyMode_P==0)
  792.                 {
  793.                 gMode++;                                                        // 切换到下一模式
  794.                 if(gMode==4)                                        // 如果到尽头了
  795.                         gMode=1;                                                // 回到第一种模式
  796.                 LcdGotoXY(1,0);                                // 光标定位
  797.                 LcdPrintMode(gMode);        // 显示模式

  799.                 while(!KeyMode_P);                // 等待按键是否
  800.                 }
  801.         }
  802. }


  805. /*********************************************************/
  806. // 开窗
  807. /*********************************************************/
  808. void Open()
  809. {
  810.         uint i,j;
  811.         for(j=0;j<255;j++)                // 控制步进电机正转
  812.         {
  813.                 for(i=0;i<4;i++)
  814.                 {
  815.                         P2=Clock[i];
  816.                         DelayMs(3);
  817.                 }
  818.         }
  819.         Led_P=0;
  820. }



  824. /*********************************************************/
  825. // 关窗
  826. /*********************************************************/
  827. void Close()
  828. {
  829.         uint i,j;
  830.         for(j=0;j<255;j++)                // 控制步进电机反转
  831.         {
  832.                 for(i=0;i<4;i++)
  833.                 {
  834.                         P2=AntiClock[i];
  835.                         DelayMs(3);
  836.                 }
  837.         }
  838.         Led_P=1;
  839. }



  843. /*********************************************************/
  844. // 主函数
  845. /*********************************************************/
  846. void main()
  847. {
  848.         uchar light;

  850.         LcdInit();                        // 执行液晶初始化        
  851.         DS1302_Init();        // 时钟芯片的初始化
  852.         LcdShowInit();        // 液晶显示内容的初始化
  853.         if(DS1302_Read_Byte(0x81)>=128)                        // 判断时钟芯片是否正在运行
  854.         {
  855.                 DS1302_Write_Time();                                                        // 如果没有，则初始化一个时间
  856.         }
  857.         while(1)
  858.         {
  859.                 tempchange();
  860.                 t=get_temp();
  861.                 if(t>=0&&t<=1250)  //温度合法范围，不在这个范围就是没有获取到合适的值
  862.                 {
  863.                         wd=t/10;
  864.                 }
  865.                 DS1302_Read_Time();                                // 获取当前时钟芯片的时间，存在数组time_buf中
  866.                 FlashTime();                                                        // 刷新时间显示

  868.                 light=Get_ADC0832();                        // 读取光照强度
  869.                 light=light/2.5;                                        // 缩小光照检测结果(在0-99)
  870.                 if(light>99)                                                        // 如果大于99
  871.                         light=99;                                                                // 则依然保持99
  872.                 LcdGotoXY(1,14);                                        // 光标定位
  873.                 LcdPrintNum(light);                                // 显示光照强度

  875.                 KeyScanf1();                                                        // 按键扫描(时间的设置)
  876.                 KeyScanf2();                                                        // 按键扫描(阈值的设置)
  877.                 KeyScanf3();                                                        // 按键扫描(模式切换)

  879.                 /*手动控制模式*/
  880.                 if(gMode==1)
  881.                 {
  882.                         if(closeflag==1)
  883.                         {
  884.                                 if(Led_P==0)                        // 如果窗帘当前是打开的
  885.                                 {
  886.                                         closeflag=0;
  887.                                         Close();                                // 则光标窗帘
  888.                                 }else
  889.                                 closeflag=0;
  890.                         }
  891.                         if(KeyDown_P==0)                // 如果关窗帘键按下了        
  892.                         {
  893.                                 if(Led_P==0)                        // 如果窗帘当前是打开的
  894.                                 {
  895.                                         Close();                                // 则光标窗帘
  896.                                 }
  897.                         }
  898.                         if(openflag==1)
  899.                         {
  900.                                 if(Led_P==1)                        // 如果窗帘当前是关闭的
  901.                                 {
  902.                                         openflag=0;
  903.                                         Open();                                        // 则打开窗帘
  904.                                 }else{
  905.                                         openflag=0;
  906.                                 }

  908.                         }
  909.                         if(KeyUp_P==0)                        // 如果开窗帘键按下了
  910.                         {
  911.                                 if(Led_P==1)                        // 如果窗帘当前是关闭的
  912.                                 {
  913.                                         Open();                                        // 则打开窗帘
  914.                                 }
  915.                         }        
  916.                 }



  920.                 /*光线控制模式*/
  921.                 if(gMode==2)
  922.                 {
  923.                         if(light<gLight)                // 当前光线小于设置的阈值
  924.                         {
  925.                                 if(Led_P==0)                        // 如果窗帘当前是打开的
  926.                                 {
  927.                                         Close();                                // 则光标窗帘
  928.                                 }
  929.                         }
  930.                         else                                                                // 当前光线大于或等于设置的阈值
  931.                         {
  932.                                 if(Led_P==1)                        // 如果窗帘当前是关闭的
  933.                                 {
  934.                                         Open();                                        // 则打开窗帘
  935.                                 }
  936.                         }        
  937.                 }

  939.                 if(gMode==3)
  940.                 {
  941.                         if(wd<wDu)                // 当前温度小于设置的阈值
  942.                         {
  943.                                 if(Led_P==0)                        // 如果窗帘当前是打开的
  944.                                 {
  945.                                         Close();                                // 则关闭窗帘
  946.                                 }
  947.                         }
  948.                         else                                                                // 当前温度大于或等于设置的阈值
  949.                         {
  950.                                 if(Led_P==1)                        // 如果窗帘当前是关闭的
  951.                                 {
  952.                                         Open();                                        // 则打开窗帘
  953.                                 }
  954.                         }        
  955.                 }

  957.                 DelayMs(100);                                                        // 延时0.1秒
  958.         }
  959. }  
复制代码


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

使用道具 举报

沙发
ID:630692 发表于 2019-10-31 13:49 | 只看该作者
可以了，只需要把s改成*s就行了。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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