欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 1661|回復: 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就行了。
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表