標(biāo)題: 基于51單片機(jī)的智能窗簾程序Proteus仿真設(shè)計 光敏電阻控制步進(jìn)電機(jī) [打印本頁]
作者: 51hei圓圓    時間: 2024-1-23 00:04
標(biāo)題: 基于51單片機(jī)的智能窗簾程序Proteus仿真設(shè)計 光敏電阻控制步進(jìn)電機(jī)
   系統(tǒng)簡介:
      1.控制芯片使用51單片機(jī)+1602液晶+步進(jìn)電機(jī)；
      2.屏幕顯示當(dāng)前日期和時間、當(dāng)前控制模式、當(dāng)前光照強(qiáng)度；
      3.共支持3種模式，通過按鍵切換：手動模式、定時模式、光控模式；
      4.在手動模式下，通過開窗簾和關(guān)窗簾鍵對窗簾進(jìn)行控制；
      5.在定時模式下，通過按鍵設(shè)置開窗簾和關(guān)窗簾的時間；
      6.在光控模式下，光照強(qiáng)度大于設(shè)置值時開啟窗簾，否則關(guān)閉，模擬的是白天開窗，晚上關(guān)窗；
      7.步進(jìn)電機(jī)正轉(zhuǎn)半圈，模擬開窗，紅色LED燈點(diǎn)亮；相反的電機(jī)反轉(zhuǎn)半圈，模擬關(guān)窗，紅色LED燈熄滅。
      8.可佩戴下載接口(4個排針)，用于連接下載器下載程序, 方便進(jìn)行升級調(diào)試
•        
操作說明:
按鍵1：切換模式（在手動模式、定時模式、光控模式循環(huán)切換）。
按鍵2：進(jìn)入當(dāng)前時間的設(shè)置（年、月、日、時、分的設(shè)置）。
按鍵3：進(jìn)入定時時間和光控閾值大小的設(shè)置。
按鍵4：減（手動關(guān)閉窗簾）。
按鍵5：加（手動開啟窗簾）。

制作出來的實(shí)物圖如下：


(1) 可實(shí)時顯示年月日、時分秒、光照強(qiáng)度和控制模式；
(2) 可通過手動控制窗簾的開啟和關(guān)閉；
(3) 可通過設(shè)置開啟和關(guān)閉時間來控制窗簾；
(4) 可通過檢測光照強(qiáng)度的亮暗來控制窗簾；
(5) 使用步進(jìn)電機(jī)的正傳和反轉(zhuǎn)來模擬窗簾的開啟和關(guān)閉；

電路原理圖如下：

元件清單:
編號    "注釋
Comment"    "描述
Description"    "數(shù)量
Quantity"
1    CR2032    電池座    1
2    紐扣電池    CR2032   
3    10uf    直插電解電容    1
4    30P    直插瓷片電容    2
5    LED3mm    3mm發(fā)紅光二極管    1
6    POWER    DC電源插座    1
7    步進(jìn)電機(jī)        1
8    Header 5    排針5-Pin    1
9    LCD1602    LCD1602液晶顯示器    1
10    LCD1602插座    16P排母    1
11    LCD1602引出腳    16P排針    1
12    10K    9腳排阻    1
13    10K    藍(lán)白可調(diào)電阻    1
14    10K    色環(huán)電阻    5
15    1K    色環(huán)電阻    1
16    GL5506    光敏電阻5506 5mm    1
17    SW-PB    按鍵6X6X5MM    5
18    SWITCH    自鎖開關(guān)    1
19    MCU    51單片機(jī)    1
20    DS1302    時鐘芯片    1
21    IC插座    8腳IC座    1
22    ULN2003    達(dá)林頓晶體管    1
23    IC插座    16腳IC座    1
24    ADC0832    模數(shù)轉(zhuǎn)換芯片    1
25    IC插座    8腳IC座    1
26    32.768K    晶振    1
27    12M    晶振    1
必備配套器材            
1    導(dǎo)線    XXcm    1
2    焊錫    XXcm    1
3    USB轉(zhuǎn)DC3.5mm電源線    系統(tǒng)供電    1
4.2    9*15萬用板        1
5    單片機(jī)插座    40腳IC座    1

仿真原理圖如下（proteus仿真工程文件可到本帖附件中下載）用可調(diào)電阻帶代替光敏電阻


單片機(jī)源程序如下:
  1. #include <reg52.h>
  2. #include <intrins.h>

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


  8. sbit ADC_CS     = P1^6;                         // ADC0832的CS引腳
  9. sbit ADC_CLK    = P1^7;                         // ADC0832的CLK引腳
  10. sbit ADC_DAT    = P3^2;                         // ADC0832的DI/DO引腳
  11. sbit SCK_P      = P1^0;                                // 時鐘芯片DS1302的SCK管腳
  12. sbit SDA_P      = P1^1;                                // 時鐘芯片DS1302的SDA管腳
  13. sbit RST_P      = P1^2;                                // 時鐘芯片DS1302的RST管腳
  14. sbit LcdRs_P    = P1^3;       // 1602液晶的RS管腳      
  15. sbit LcdRw_P    = P1^4;       // 1602液晶的RW管腳
  16. sbit LcdEn_P    = P1^5;       // 1602液晶的EN管腳
  17. sbit KeyMode_P  = P3^3;                                // 模式切換
  18. sbit KeySet_P   = P3^4;                                // 設(shè)置時間按鍵
  19. sbit KeySet2_P  = P3^5;                                // 設(shè)置時間模式的開關(guān)時間和光照控制強(qiáng)度
  20. sbit KeyDown_P  = P3^6;                                // 減按鍵
  21. sbit KeyUp_P    = P3^7;                                // 加按鍵
  22. sbit Led_P      = P2^0;                                // 指示燈

  24. uchar gMode=1;                                                                // 1是手動模式，2是時間自動模式，3是亮度自動模式
  25. uchar OpenHour    = 18;                                // 開啟窗簾的小時
  26. uchar OpenMinute  = 20;                                // 開啟窗簾的分鐘
  27. uchar CloseHour   = 10;                                // 關(guān)閉窗簾的小時
  28. uchar CloseMinute = 30;                                // 關(guān)閉窗簾的分鐘
  29. uchar gLight      = 40;                                // 窗簾開關(guān)的閾值

  31. uchar code Clock[]={0x10,0x20,0x40,0x80};                         // 步進(jìn)電機(jī)順時針旋轉(zhuǎn)數(shù)組
  32. uchar code AntiClock[]={0x80,0x40,0x20,0x10};                // 步進(jìn)電機(jī)逆時針旋轉(zhuǎn)數(shù)組

  34. uchar TimeBuff[7]={17,9,1,6,18,30,40};                                        // 時間數(shù)組，默認(rèn)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. // 毫秒級的延時函數(shù)，time是要延時的毫秒數(shù)
  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. }


  56. /*********************************************************/
  57. // 1602液晶寫命令函數(shù)，cmd就是要寫入的命令
  58. /*********************************************************/
  59. void LcdWriteCmd(uchar cmd)
  60. {
  61.         LcdRs_P = 0;
  62.         LcdRw_P = 0;
  63.         LcdEn_P = 0;
  64.         P0=cmd;
  65.         DelayMs(2);
  66.         LcdEn_P = 1;   
  67.         DelayMs(2);
  68.         LcdEn_P = 0;        
  69. }


  72. /*********************************************************/
  73. // 1602液晶寫數(shù)據(jù)函數(shù)，dat就是要寫入的數(shù)據(jù)
  74. /*********************************************************/
  75. void LcdWriteData(uchar dat)
  76. {
  77.         LcdRs_P = 1;
  78.         LcdRw_P = 0;
  79.         LcdEn_P = 0;
  80.         P0=dat;
  81.         DelayMs(2);
  82.         LcdEn_P = 1;   
  83.         DelayMs(2);
  84.         LcdEn_P = 0;
  85. }


  88. /*********************************************************/
  89. // 1602液晶初始化函數(shù)
  90. /*********************************************************/
  91. void LcdInit()
  92. {
  93.         LcdWriteCmd(0x38);        // 16*2顯示，5*7點(diǎn)陣，8位數(shù)據(jù)口
  94.         LcdWriteCmd(0x0C);        // 開顯示，不顯示光標(biāo)
  95.         LcdWriteCmd(0x06);        // 地址加1，當(dāng)寫入數(shù)據(jù)后光標(biāo)右移
  96.         LcdWriteCmd(0x01);        // 清屏
  97. }


  100. /*********************************************************/
  101. // 液晶光標(biāo)定位函數(shù)
  102. /*********************************************************/
  103. void LcdGotoXY(uchar line,uchar column)
  104. {
  105.         // 第一行
  106.         if(line==0)        
  107.                 LcdWriteCmd(0x80+column);
  108.         // 第二行
  109.         if(line==1)        
  110.                 LcdWriteCmd(0x80+0x40+column);
  111. }


  114. /*********************************************************/
  115. // 液晶輸出字符串函數(shù)
  116. /*********************************************************/
  117. void LcdPrintStr(uchar *str)
  118. {
  119.         while(*str!='\0')
  120.                         LcdWriteData(*str++);
  121. }


  124. /*********************************************************/
  125. // 液晶輸出數(shù)字(0-99)
  126. /*********************************************************/
  127. void LcdPrintNum(uchar num)
  128. {
  129.         LcdWriteData(num/10+48);                // 十位
  130.         LcdWriteData(num%10+48);                 // 個位
  131. }


  134. /*********************************************************/
  135. // 顯示模式
  136. /*********************************************************/
  137. void LcdPrintMode(uchar num)
  138. {
  139.         switch(num)                        
  140.         {
  141.                 case 1: LcdPrintStr("Manual");        break;
  142.                 case 2: LcdPrintStr("Timing");        break;
  143.                 case 3: LcdPrintStr("Liging");        break;
  144.                 default:                                                                                                break;
  145.         }
  146. }


  149. /*********************************************************/
  150. // 液晶顯示內(nèi)容的初始化
  151. /*********************************************************/
  152. void LcdShowInit()
  153. {
  154.         LcdGotoXY(0,0);
  155.         LcdPrintStr("20  -  -     :  ");
  156.         LcdGotoXY(1,0);
  157.         LcdPrintStr("           gz:  ");
  158.         LcdGotoXY(1,0);
  159.         LcdPrintMode(gMode);
  160. }



  164. /*********************************************************/
  165. // 刷新時間顯示
  166. /*********************************************************/
  167. void FlashTime()
  168. {
  169.         LcdGotoXY(0,2);                                                                                // 年份
  170.         LcdPrintNum(TimeBuff[0]);
  171.         LcdGotoXY(0,5);                                                                                // 月份
  172.         LcdPrintNum(TimeBuff[1]);
  173.         LcdGotoXY(0,8);                                                                                // 日期
  174.         LcdPrintNum(TimeBuff[2]);
  175.         LcdGotoXY(0,11);                                                                        // 小時
  176.         LcdPrintNum(TimeBuff[4]);
  177.         LcdGotoXY(0,14);                                                                        // 分鐘
  178.         LcdPrintNum(TimeBuff[5]);
  179.         LcdGotoXY(0,13);                                                                        // 秒鐘
  180.         if(TimeBuff[6]%2==0)                                                        // 秒鐘是偶數(shù)顯示冒號
  181.                 LcdWriteData(':');
  182.         else                                                                                                                        // 秒鐘是奇數(shù)顯示空格
  183.                 LcdWriteData(' ');
  184. }


  187. /*********************************************************/
  188. // 初始化DS1302
  189. /*********************************************************/
  190. void DS1302_Init(void)
  191. {
  192.         RST_P=0;                        // RST腳置低
  193.         SCK_P=0;                        // SCK腳置低
  194.         SDA_P=0;                        // SDA腳置低                                
  195. }


  198. /*********************************************************/
  199. // 從DS1302讀出一字節(jié)數(shù)據(jù)
  200. /*********************************************************/
  201. uchar DS1302_Read_Byte(uchar addr)
  202. {
  203.         uchar i;
  204.         uchar temp;
  205.         
  206.         RST_P=1;                                                               
  207.         
  208.         /* 寫入目標(biāo)地址：addr*/
  209.         for(i=0;i<8;i++)
  210.         {     
  211.                 if(addr&0x01)
  212.                         SDA_P=1;
  213.                 else
  214.                         SDA_P=0;
  215.                
  216.                 SCK_P=1;
  217.                 _nop_();
  218.                 SCK_P=0;
  219.                 _nop_();
  220.                
  221.                 addr=addr>> 1;
  222.         }
  223.         
  224.         /* 讀出該地址的數(shù)據(jù) */
  225.         for(i=0;i<8;i++)
  226.         {
  227.                 temp=temp>>1;
  228.                
  229.                 if(SDA_P)
  230.                         temp|= 0x80;
  231.                 else
  232.                         temp&=0x7F;
  233.                
  234.                 SCK_P=1;
  235.                 _nop_();
  236.                 SCK_P=0;
  237.                 _nop_();
  238.         }
  239.         
  240.         RST_P=0;
  241.         
  242.         return temp;
  243. }


  246. /*********************************************************/
  247. // 向DS1302寫入一字節(jié)數(shù)據(jù)
  248. /*********************************************************/
  249. void DS1302_Write_Byte(uchar addr, uchar dat)
  250. {
  251.         uchar i;
  252.         
  253.         RST_P = 1;
  254.         
  255.         /* 寫入目標(biāo)地址：addr*/
  256.         for(i=0;i<8;i++)
  257.         {
  258.                 if(addr&0x01)
  259.                         SDA_P=1;
  260.                 else
  261.                         SDA_P=0;

  263.                 SCK_P=1;
  264.                 _nop_();
  265.                 SCK_P=0;
  266.                 _nop_();
  267.                
  268.                 addr=addr>>1;
  269.         }
  270.         
  271.         /* 寫入數(shù)據(jù)：dat*/
  272.         for(i=0;i<8;i++)
  273.         {
  274.                 if(dat&0x01)
  275.                         SDA_P=1;
  276.                 else
  277.                         SDA_P=0;
  278.         
  279.                 SCK_P=1;
  280.                 _nop_();
  281.                 SCK_P=0;
  282.                 _nop_();
  283.                
  284.                 dat=dat>>1;
  285.         }
  286.         
  287.         RST_P=0;                                       
  288. }


  291. /*********************************************************/
  292. // 向DS1302寫入時間數(shù)據(jù)
  293. /*********************************************************/
  294. void DS1302_Write_Time()
  295. {
  296.   uchar i;
  297.         uchar temp1;
  298.         uchar temp2;
  299.         
  300.         for(i=0;i<7;i++)                        // 十進(jìn)制轉(zhuǎn)BCD碼
  301.         {
  302.                 temp1=(TimeBuff[i]/10)<<4;
  303.                 temp2=TimeBuff[i]%10;
  304.                 TimeBuff[i]=temp1+temp2;
  305.         }
  306.         
  307.         DS1302_Write_Byte(0x8E,0x00);                                                                // 關(guān)閉寫保護(hù)
  308.         DS1302_Write_Byte(0x80,0x80);                                                                // 暫停時鐘
  309.         DS1302_Write_Byte(0x8C,TimeBuff[0]);                                // 年
  310.         DS1302_Write_Byte(0x88,TimeBuff[1]);                                // 月
  311.         DS1302_Write_Byte(0x86,TimeBuff[2]);                                // 日
  312.         DS1302_Write_Byte(0x8A,TimeBuff[3]);                                // 星期
  313.         DS1302_Write_Byte(0x84,TimeBuff[4]);                                // 時
  314.         DS1302_Write_Byte(0x82,TimeBuff[5]);                                // 分
  315.         DS1302_Write_Byte(0x80,TimeBuff[6]);                                // 秒
  316.         DS1302_Write_Byte(0x80,TimeBuff[6]&0x7F);                // 運(yùn)行時鐘
  317.         DS1302_Write_Byte(0x8E,0x80);                                                                // 打開寫保護(hù)  
  318. }



  322. /*********************************************************/
  323. // 從DS1302讀出時間數(shù)據(jù)
  324. /*********************************************************/
  325. void DS1302_Read_Time()  
  326. {
  327.         uchar i;

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

  337.         for(i=0;i<7;i++)                // BCD轉(zhuǎn)十進(jìn)制
  338.         {           
  339.                 TimeBuff[i]=(TimeBuff[i]/16)*10+TimeBuff[i]%16;
  340.         }
  341. }


  344. /*********************************************************/
  345. // ADC0832的時鐘脈沖
  346. /*********************************************************/
  347. void WavePlus()
  348. {
  349.         _nop_();
  350.         ADC_CLK = 1;
  351.         _nop_();
  352.         ADC_CLK = 0;
  353. }


  356. /*********************************************************/
  357. // 獲取指定通道的A/D轉(zhuǎn)換結(jié)果
  358. /*********************************************************/
  359. uchar Get_ADC0832()
  360. {
  361.         uchar i;
  362.         uchar dat1=0;
  363.         uchar dat2=0;
  364.         
  365.         ADC_CLK = 0;                                // 電平初始化
  366.         ADC_DAT = 1;
  367.         _nop_();
  368.         ADC_CS = 0;
  369.         WavePlus();                                        // 起始信號
  370.         ADC_DAT = 1;
  371.         WavePlus();                                        // 通道選擇的第一位
  372.         ADC_DAT = 0;      
  373.         WavePlus();                                        // 通道選擇的第二位
  374.         ADC_DAT = 1;
  375.         
  376.         for(i=0;i<8;i++)                // 第一次讀取
  377.         {
  378.                 dat1<<=1;
  379.                 WavePlus();
  380.                 if(ADC_DAT)
  381.                         dat1=dat1|0x01;
  382.                 else
  383.                         dat1=dat1|0x00;
  384.         }
  385.         
  386.         for(i=0;i<8;i++)                // 第二次讀取
  387.         {
  388.                 dat2>>= 1;
  389.                 if(ADC_DAT)
  390.                         dat2=dat2|0x80;
  391.                 else
  392.                         dat2=dat2|0x00;
  393.                 WavePlus();
  394.         }
  395.         
  396.         _nop_();                                                // 結(jié)束此次傳輸
  397.         ADC_DAT = 1;
  398.         ADC_CLK = 1;
  399.         ADC_CS  = 1;   

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


  408. /*********************************************************/
  409. // 按鍵掃描(設(shè)置當(dāng)前時間)
  410. /*********************************************************/
  411. void KeyScanf1()
  412. {
  413.         if(KeySet_P==0)
  414.         {
  415.                 LcdGotoXY(0,13);                                // 顯示秒鐘的冒號
  416.                 LcdWriteData(':');
  417.                 LcdWriteCmd(0x0f);                        // 啟動光標(biāo)閃爍
  418.                 LcdGotoXY(0,3);                                        // 定位光標(biāo)到年份閃爍
  419.                 DelayMs(10);                                                // 延時等待，消除按鍵按下的抖動
  420.                 while(!KeySet_P);                                // 等待按鍵釋放
  421.                 DelayMs(10);                                                // 延時等待，消除按鍵松開的抖動
  422.                
  423.                 /* 調(diào)整年份 */
  424.                 while(1)
  425.                 {
  426.                         if(KeyDown_P==0)                                                        // 如果減按鍵被下去
  427.                         {
  428.                                 if(TimeBuff[0]>0)                                                // 判斷年份是否大于0               
  429.                                         TimeBuff[0]--;                                                // 是的話就減去1
  430.                                 LcdGotoXY(0,2);                                                        // 光標(biāo)定位到年份的位置
  431.                                 LcdPrintNum(TimeBuff[0]);                // 刷新顯示改變后的年份
  432.                                 LcdGotoXY(0,3);                                                        // 定位光標(biāo)到年份閃爍
  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);                                                        // 光標(biāo)定位到年份的位置
  441.                                 LcdPrintNum(TimeBuff[0]);                // 刷新顯示改變后的年份
  442.                                 LcdGotoXY(0,3);                                                        // 定位光標(biāo)到年份閃爍
  443.                                 DelayMs(300);                                                                // 延時0.3秒左右
  444.                         }
  445.                         
  446.                         if(KeySet_P==0)
  447.                         {
  448.                                 break;
  449.                         }
  450.                 }
  451.                
  452.                 LcdGotoXY(0,6);                                        // 定位光標(biāo)到月份閃爍
  453.                 DelayMs(10);                                                // 延時等待，消除按鍵按下的抖動
  454.                 while(!KeySet_P);                                // 等待按鍵釋放
  455.                 DelayMs(10);                                                // 延時等待，消除按鍵松開的抖動
  456.                         
  457.                 /* 調(diào)整月份 */
  458.                 while(1)
  459.                 {
  460.                         if(KeyDown_P==0)                                                        // 如果減按鍵被下去
  461.                         {
  462.                                 if(TimeBuff[1]>1)                                                // 判斷月份是否大于1               
  463.                                         TimeBuff[1]--;                                                // 是的話就減去1
  464.                                 LcdGotoXY(0,5);                                                        // 光標(biāo)定位到月份的位置
  465.                                 LcdPrintNum(TimeBuff[1]);                // 刷新顯示改變后的月份
  466.                                 LcdGotoXY(0,6);                                                        // 定位光標(biāo)到月份閃爍
  467.                                 DelayMs(300);                                                                // 延時0.3秒左右
  468.                         }
  469.                         
  470.                         if(KeyUp_P==0)                                                                // 如果加按鍵被下去
  471.                         {
  472.                                 if(TimeBuff[1]<12)                                        // 判斷月份是否小于12
  473.                                         TimeBuff[1]++;                                                // 是的話就加上1
  474.                                 LcdGotoXY(0,5);                                                        // 光標(biāo)定位到月份的位置
  475.                                 LcdPrintNum(TimeBuff[1]);                // 刷新顯示改變后的月份
  476.                                 LcdGotoXY(0,6);                                                        // 定位光標(biāo)到月份閃爍
  477.                                 DelayMs(300);                                                                // 延時0.3秒左右
  478.                         }
  479.                         
  480.                         if(KeySet_P==0)
  481.                         {
  482.                                 break;
  483.                         }
  484.                 }
  485.                
  486.                 LcdGotoXY(0,9);                                        // 定位光標(biāo)到日期閃爍
  487.                 DelayMs(10);                                                // 延時等待，消除按鍵按下的抖動
  488.                 while(!KeySet_P);                                // 等待按鍵釋放
  489.                 DelayMs(10);                                                // 延時等待，消除按鍵松開的抖動
  490.                
  491.                 /* 調(diào)整日期 */
  492.                 while(1)
  493.                 {
  494.                         if(KeyDown_P==0)                                                        // 如果減按鍵被下去
  495.                         {
  496.                                 if(TimeBuff[2]>1)                                                // 判斷日期是否大于1               
  497.                                         TimeBuff[2]--;                                                // 是的話就減去1
  498.                                 LcdGotoXY(0,8);                                                        // 光標(biāo)定位到日期的位置
  499.                                 LcdPrintNum(TimeBuff[2]);                // 刷新顯示改變后的日期
  500.                                 LcdGotoXY(0,9);                                                        // 定位光標(biāo)到日期閃爍
  501.                                 DelayMs(300);                                                                // 延時0.3秒左右
  502.                         }
  503.                         
  504.                         if(KeyUp_P==0)                                                                // 如果加按鍵被下去
  505.                         {
  506.                                 if(TimeBuff[2]<31)                                        // 判斷日期是否小于31
  507.                                         TimeBuff[2]++;                                                // 是的話就加上1
  508.                                 LcdGotoXY(0,8);                                                        // 光標(biāo)定位到日期的位置
  509.                                 LcdPrintNum(TimeBuff[2]);                // 刷新顯示改變后的日期
  510.                                 LcdGotoXY(0,9);                                                        // 定位光標(biāo)到日期閃爍
  511.                                 DelayMs(300);                                                                // 延時0.3秒左右
  512.                         }
  513.                         
  514.                         if(KeySet_P==0)
  515.                         {
  516.                                 break;
  517.                         }
  518.                 }
  519.                
  520.                 LcdGotoXY(0,12);                                // 定位光標(biāo)到小時閃爍
  521.                 DelayMs(10);                                                // 延時等待，消除按鍵按下的抖動
  522.                 while(!KeySet_P);                                // 等待按鍵釋放
  523.                 DelayMs(10);                                                // 延時等待，消除按鍵松開的抖動
  524.                
  525.                
  526.                 /* 調(diào)整小時 */
  527.                 while(1)
  528.                 {
  529.                         if(KeyDown_P==0)                                                        // 如果減按鍵被下去
  530.                         {
  531.                                 if(TimeBuff[4]>0)                                                // 判斷小時是否大于0
  532.                                         TimeBuff[4]--;                                                // 是的話就減去1
  533.                                 LcdGotoXY(0,11);                                                // 光標(biāo)定位到小時的位置
  534.                                 LcdPrintNum(TimeBuff[4]);                // 刷新顯示改變后的小時
  535.                                 LcdGotoXY(0,12);                                                // 定位光標(biāo)到小時閃爍
  536.                                 DelayMs(300);                                                                // 延時0.3秒左右
  537.                         }
  538.                         
  539.                         if(KeyUp_P==0)                                                                // 如果加按鍵被下去
  540.                         {
  541.                                 if(TimeBuff[4]<23)                                        // 判斷小時是否小于23
  542.                                         TimeBuff[4]++;                                                // 是的話就加上1
  543.                                 LcdGotoXY(0,11);                                                // 光標(biāo)定位到小時的位置
  544.                                 LcdPrintNum(TimeBuff[4]);                // 刷新顯示改變后的小時
  545.                                 LcdGotoXY(0,12);                                                // 定位光標(biāo)到小時閃爍
  546.                                 DelayMs(300);                                                                // 延時0.3秒左右
  547.                         }
  548.                         
  549.                         if(KeySet_P==0)
  550.                         {
  551.                                 break;
  552.                         }
  553.                 }
  554.                
  555.                 LcdGotoXY(0,15);                                // 定位光標(biāo)到分鐘閃爍
  556.                 DelayMs(10);                                                // 延時等待，消除按鍵按下的抖動
  557.                 while(!KeySet_P);                                // 等待按鍵釋放
  558.                 DelayMs(10);                                                // 延時等待，消除按鍵松開的抖動
  559.                
  560.                 /* 調(diào)整分鐘 */
  561.                 while(1)
  562.                 {
  563.                         if(KeyDown_P==0)                                                        // 如果減按鍵被下去
  564.                         {
  565.                                 if(TimeBuff[5]>0)                                                // 判斷分鐘是否大于0
  566.                                         TimeBuff[5]--;                                                // 是的話就減去1
  567.                                 LcdGotoXY(0,14);                                                // 光標(biāo)定位到分鐘的位置
  568.                                 LcdPrintNum(TimeBuff[5]);                // 刷新顯示改變后的分鐘
  569.                                 LcdGotoXY(0,15);                                                // 定位光標(biāo)到分鐘閃爍
  570.                                 DelayMs(300);                                                                // 延時0.3秒左右
  571.                         }
  572.                         
  573.                         if(KeyUp_P==0)                                                                // 如果加按鍵被下去
  574.                         {
  575.                                 if(TimeBuff[5]<59)                                        // 判斷分鐘是否小于59
  576.                                         TimeBuff[5]++;                                                // 是的話就加上1
  577.                                 LcdGotoXY(0,14);                                                // 光標(biāo)定位到分鐘的位置
  578.                                 LcdPrintNum(TimeBuff[5]);                // 刷新顯示改變后的分鐘
  579.                                 LcdGotoXY(0,15);                                                // 定位光標(biāo)到分鐘閃爍
  580.                                 DelayMs(300);                                                                // 延時0.3秒左右
  581.                         }
  582.                         
  583.                         if(KeySet_P==0)
  584.                         {
  585.                                 break;
  586.                         }
  587.                 }
  588.                
  589.                 /* 退出前的設(shè)置 */
  590.                 LcdWriteCmd(0x0C);                        // 關(guān)閉光標(biāo)閃爍
  591.                 DS1302_Write_Time();                // 把新設(shè)置的時間值存入DS1302芯片
  592.                 DelayMs(10);                                                // 延時等待，消除按鍵按下的抖動
  593.                 while(!KeySet_P);                                // 等待按鍵釋放
  594.                 DelayMs(10);                                                // 延時等待，消除按鍵松開的抖動
  595.         }
  596. }


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


  804. /*********************************************************/
  805. // 按鍵掃描(模式切換)
  806. /*********************************************************/
  807. void KeyScanf3()
  808. {
  809.         if(KeyMode_P==0)
  810.         {
  811.                 gMode++;                                                        // 切換到下一模式
  812.                 if(gMode==4)                                        // 如果到盡頭了
  813.                         gMode=1;                                                // 回到第一種模式
  814.                 LcdGotoXY(1,0);                                // 光標(biāo)定位
  815.                 LcdPrintMode(gMode);        // 顯示模式
  816.                 DelayMs(10);                                        // 去除按鍵按下的抖動
  817.                 while(!KeyMode_P);                // 等待按鍵是否
  818.                 DelayMs(10);                                        // 去除按鍵松開的抖動
  819.         }
  820. }


  823. /*********************************************************/
  824. // 開窗
  825. /*********************************************************/
  826. void Open()
  827. {
  828.         uint i,j;
  829.         for(j=0;j<255;j++)                // 控制步進(jìn)電機(jī)正轉(zhuǎn)
  830.         {
  831.                 for(i=0;i<4;i++)
  832.                 {
  833.                         P2=Clock[i];
  834.                         DelayMs(3);
  835.                 }
  836.         }
  837.         Led_P=0;
  838. }



  842. /*********************************************************/
  843. // 關(guān)窗
  844. /*********************************************************/
  845. void Close()
  846. {
  847.         uint i,j;
  848.         for(j=0;j<255;j++)                // 控制步進(jìn)電機(jī)反轉(zhuǎn)
  849.         {
  850.                 for(i=0;i<4;i++)
  851.                 {
  852.                         P2=AntiClock[i];
  853.                         DelayMs(3);
  854.                 }
  855.         }
  856.         Led_P=1;
  857. }



  861. /*********************************************************/
  862. // 主函數(shù)
  863. /*********************************************************/
  864. void main()
  865. {
  866.         uchar light;
  867.         
  868.         LcdInit();                        // 執(zhí)行液晶初始化        
  869.         DS1302_Init();        // 時鐘芯片的初始化
  870.         LcdShowInit();        // 液晶顯示內(nèi)容的初始化
  871.         
  872.         if(DS1302_Read_Byte(0x81)>=128)                        // 判斷時鐘芯片是否正在運(yùn)行
  873.         {
  874.                 DS1302_Write_Time();                                                        // 如果沒有，則初始化一個時間
  875.         }
  876.         
  877.         while(1)
  878.         {
  879.                 DS1302_Read_Time();                                // 獲取當(dāng)前時鐘芯片的時間，存在數(shù)組time_buf中
  880.                 FlashTime();                                                        // 刷新時間顯示

  882.                 light=Get_ADC0832();                        // 讀取光照強(qiáng)度
  883.                 light=light/2.5;                                        // 縮小光照檢測結(jié)果(在0-99)
  884.                 if(light>99)                                                        // 如果大于99
  885.                         light=99;                                                                // 則依然保持99
  886.                 LcdGotoXY(1,14);                                        // 光標(biāo)定位
  887.                 LcdPrintNum(light);                                // 顯示光照強(qiáng)度
  888.                
  889.                 KeyScanf1();                                                        // 按鍵掃描(時間的設(shè)置)
  890.                 KeyScanf2();                                                        // 按鍵掃描(閾值的設(shè)置)
  891.                 KeyScanf3();                                                        // 按鍵掃描(模式切換)
  892.         
  893.                 /*手動控制模式*/
  894.                 if(gMode==1)
  895.                 {
  896.                         if(KeyDown_P==0)                // 如果關(guān)窗簾鍵按下了        
  897.                         {
  898.                                 if(Led_P==0)                        // 如果窗簾當(dāng)前是打開的
  899.                                 {
  900.                                         Close();                                // 則關(guān)閉窗簾
  901.                                 }
  902.                         }
  903.                         if(KeyUp_P==0)                        // 如果開窗簾鍵按下了
  904.                         {
  905.                                 if(Led_P==1)                        // 如果窗簾當(dāng)前是關(guān)閉的
  906.                                 {
  907.                                         Open();                                        // 則打開窗簾
  908.                                 }
  909.                         }        
  910.                 }
  911.                
  912.                 /*時間控制模式*/
  913.                 if(gMode==2)
  914.                 {
  915.                         if((TimeBuff[4]==CloseHour)&&(TimeBuff[5]==CloseMinute)&&(TimeBuff[6]==0))        // 如果到了關(guān)窗簾的時間        
  916.                         {
  917.                                 if(Led_P==0)                        // 如果窗簾當(dāng)前是打開的
  918.                                 {
  919.                                         Close();                                // 則關(guān)閉窗簾
  920.                                 }
  921.                         }
  922.                         if((TimeBuff[4]==OpenHour)&&(TimeBuff[5]==OpenMinute)&&(TimeBuff[6]==0))                // 如果到了開窗簾的時間        
  923.                         {
  924.                                 if(Led_P==1)                        // 如果窗簾當(dāng)前是關(guān)閉的
  925.                                 {
  926.                                         Open();                                        // 則打開窗簾
  927.                                 }
  928.                         }        
  929.                 }
  930.                
  931.                 /*光線控制模式*/
  932.                 if(gMode==3)
  933.                 {
  934.                         if(light<gLight)                // 當(dāng)前光線小于設(shè)置的閾值
  935.                         {
  936.                                 if(Led_P==0)                        // 如果窗簾當(dāng)前是打開的
  937.                                 {
  938.                                         Close();                                // 則關(guān)閉窗簾
  939.                                 }
  940.                         }
  941.                         else                                                                // 當(dāng)前光線大于或等于設(shè)置的閾值
  942.                         {
  943.                                 if(Led_P==1)                        // 如果窗簾當(dāng)前是關(guān)閉的
  944.                                 {
復(fù)制代碼

仿真和程序51hei附件下載:
基于51單片機(jī)的智能窗設(shè)計.7z (2.3 MB, 下載次數(shù): 99)




歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1