智能窗簾設計：51單片機+A/D轉換+光敏電阻+LCD1602+步進電機

這是我做的仿真，如有不足，還請大家指出。謝謝各位。文件中包含protues仿真、程序。



單片機源程序如下:

1. #include <reg52.h>         
   
2. 
   
3. #define uchar unsigned char
   
4. #define uint unsigned int
   
5. #define yi 0x80       //LCD第一行的初始位置,因為LCD1602字符地址首位D7恒定為1（100000000=80）
   
6. #define er 0x80+0x40 //LCD第二行初始位置（因為第二行第一個字符位置地址是0x40）
   
7. 
   
8. uchar display_digit[]={0,0,0};
   
9. uchar yuzhi[]={0,0,0};
   
10. uchar phasecw[4] ={0x08,0x04,0x02,0x01};//正轉 電機導通相序 D-C-B-A
    
11. uchar phaseccw[4]={0x01,0x02,0x04,0x08};//反轉 電機導通相序 A-B-C-D
    
12. 
    
13. sbit R_D=P2^0;
    
14. sbit W_R=P2^1;        
    
15. sbit C_S=P2^2;        
    
16. 
    
17. sbit Up=P2^3;               
    
18. sbit Down=P2^4;               
    
19. 
    
20. sbit rw=P2^5;                 //液晶讀寫端
    
21. sbit rs=P2^6;                 //液晶指令/數據輸入控制
    
22. sbit en=P2^7;                 //液晶使能端
    
23. 
    
24. sbit AD_data=P1;        
    
25. 
    
26. sbit bianji=P3^4;
    
27. sbit jia=P3^7;
    
28. sbit jian=P3^6;
    
29. 
    
30. uint adval;
    
31. uint fazhi=180;
    
32. uchar state=1;//1為窗簾打開，0為窗簾關閉
    
33. uchar zhuangtai=1;//1為窗簾打開，0為窗簾關閉
    
34. 
    
35. void  Time_init()               
    
36. {
    
37.         EA=1;
    
38.         TMOD=0x11;
    
39.         TH0=0xf8;        
    
40.         TL0=0xcc;
    
41.         ET0=1;
    
42.         TR0=0;
    
43. }
    
44. 
    
45. void delay(uint time)         
    
46. {
    
47.         uint x,y;                        
    
48.         for(x=time;x>0;x--)
    
49.         for(y=110;y>0;y--);        
    
50. }
    
51. 
    
52. void qiangdushuzhi()               
    
53. {
    
54.         C_S=0;                                 
    
55.         W_R=0;                 //啟動AD轉換
    
56.         delay(1);
    
57.         W_R=1;
    
58.         C_S=1;
    
59.         delay(10);
    
60.         P1=0xff;                //讀取AD轉換值前,先把P1口置1               
    
61.         C_S=0;
    
62.         R_D=0;                         //AD讀使能
    
63.         delay(1);                  
    
64.         adval=P1;                  //把AD轉換好的值,賦給 adval
    
65.         R_D=1;
    
66.         C_S=1;                         //置1后,為下次AD轉換做準備
    
67.         delay(1);
    
68.         
    
69.         display_digit[0]=adval/100;
    
70.         display_digit[1]=adval%100/10;                   //取得十位數字
    
71.         display_digit[2]=adval%10;                   //取得個位數字
    
72. }               
    
73. 
    
74. void write_1602com(uchar com)
    
75. {
    
76.         rs=0;                //數據/指令選擇置為指令
    
77.         rw=0;                //讀寫選擇置為寫
    
78.         P0=com;              //送入數據
    
79.         delay(1);
    
80.         en=1;                //拉高使能端，為制造有效的下降沿做準備
    
81.         delay(1);
    
82.         en=0;                //en由高變低，產生下降沿，液晶執行命令
    
83. }
    
84. 
    
85. void write_1602dat(uchar dat)
    
86. {
    
87.         rs=1;               //數據/指令選擇置為數據
    
88.         rw=0;               //讀寫選擇置為寫
    
89.         P0=dat;             //送入數據
    
90.         delay(1);
    
91.         en=1;               //en置高電平，為制造下降沿做準備
    
92.         delay(1);
    
93.         en=0;               //en由高變低，產生下降沿，液晶執行命令
    
94. }
    
95. 
    
96. void write_1602str(uchar *s)  //寫字符串
    
97. {
    
98.         while(*s)
    
99.                 {
    
100.                         write_1602dat(*s++);
     
101.     }
     
102. }
     
103. 
     
104. void lcd_init()
     
105. {
     
106.         write_1602com(0x38);         //設置液晶工作模式，
     
107.         write_1602com(0x0c);         //開顯示不顯示光標
     
108.         write_1602com(0x06);         //整屏不移動，光標自動右移
     
109.         write_1602com(0x01);         //清顯示
     
110.   delay(5);
     
111.         write_1602com(yi+5);         //固定符號從第一行第1個位置之后開始顯示
     
112.         write_1602str("WELCOME");      
     
113.         delay(1000);
     
114.         write_1602com(0x01);
     
115. }
     
116. 
     
117. void display( )
     
118. {
     
119.         yuzhi[0]=fazhi/100;
     
120.         yuzhi[1]=fazhi%100/10;
     
121.         yuzhi[2]=fazhi%10;
     
122.         write_1602com(yi+0);
     
123.         write_1602str(" TARGET:");
     
124.   if(yuzhi[0]==0)
     
125.         {
     
126.                 write_1602dat(0x30+yuzhi[1]);
     
127.                 delay(5);
     
128.                 write_1602dat(0x30+yuzhi[2]);
     
129.                 delay(5);
     
130.         }
     
131.   if(yuzhi[0]!=0)
     
132.         {
     
133.                 write_1602dat(0x30+yuzhi[0]);
     
134.                 delay(5);
     
135.                 write_1602dat(0x30+yuzhi[1]);
     
136.                 delay(5);
     
137.                 write_1602dat(0x30+yuzhi[2]);
     
138.                 delay(5);
     
139.         }
     
140.         write_1602com(er+0);       //er是頭文件寫的值0x80+0x40
     
141.         delay(5);
     
142.         write_1602str("CURRENT:");   
     
143.         delay(5);
     
144.         if(display_digit[0]==0)
     
145.         {
     
146.                 write_1602dat(0x30+display_digit[1]);      //數字+30得到該數字的LCD1602顯示碼
     
147.           delay(5);
     
148.           write_1602dat(0x30+display_digit[2]);      //數字+30得到該數字的LCD1602顯示碼                        
     
149.     delay(5);        
     
150.                 write_1602str(" ");      //數字+30得到該數字的LCD1602顯示碼                        
     
151.     delay(5);        
     
152.         }
     
153.         if(display_digit[0]!=0)
     
154.         {
     
155.                 write_1602dat(0x30+display_digit[0]);
     
156.           delay(5);
     
157.           write_1602dat(0x30+display_digit[1]);      //數字+30得到該數字的LCD1602顯示碼
     
158.           delay(5);
     
159.           write_1602dat(0x30+display_digit[2]);      //數字+30得到該數字的LCD1602顯示碼                        
     
160.     delay(5);
     
161.         }
     
162.         if(zhuangtai==1)
     
163.         {
     
164.                 write_1602com(yi+12);
     
165.                 write_1602str("OPEN");
     
166.         }
     
167.         if(zhuangtai==0)
     
168.         {
     
169.                 write_1602com(er+11);
     
170.                 write_1602str("CLOSE");
     
171.         }
     
172. }
     
173. 
     
174. void zhengzhuan(uchar step)  //上升
     
175. {
     
176.         uchar i,j,k;
     
177.         if(zhuangtai==0)
     
178.         {
     
179.                 write_1602com(0x01);
     
180.                 write_1602com(yi+6);
     
181.                 write_1602str("UP");
     
182.                 k=20*step;
     
183.                 for(j=0;j<k;j++)
     
184.                 {
     
185.                         for(i=0;i<4;i++)
     
186.                         {
     
187.                                 P3=phasecw[i];
     
188.                                 delay(10);//轉速調節
     
189.                         }
     
190.                 }
     
191.     P3=0xf1;
     
192.                 zhuangtai=1;
     
193.         }
     
194. }
     
195.         
     
196. void fanzhuan(uchar step)  //下降
     
197. {
     
198.         uchar i,j,k;
     
199.         if(zhuangtai==1)
     
200.         {
     
201.                 write_1602com(0x01);
     
202.                 write_1602com(yi+6);
     
203.                 write_1602str("DOWN");
     
204.                 k=20*step;
     
205.                 for(j=0;j<k;j++)
     
206.                 {
     
207.                         for(i=0;i<4;i++)
     
208.                         {
     
209.                                 P3=phaseccw[i];
     
210.                                 delay(10);//轉速調節
     
211.                         }
     
212.                 }
     
213.                 P3=0xf8;
     
214.                 zhuangtai=0;
     
215.         }
     
216. }
     
217. 
     
218. void move(uchar level)
     
219. {
     
220.         switch(level)
     
221.                 {
     
222.                         case 0:switch(state)
     
223.                                 {
     
224.                                         case 0:break;
     
225.                             case 1:fanzhuan(10);break;
     
226.                     }
     
227.                         state=0;break;
     
228.                   case 1:switch(state)
     
229.                                 {
     
230.                                         case 0:zhengzhuan(10);break;
     
231.                             case 1:break;
     
232.                     }
     
233.                         state=1;break;
     
234.                 }
     
235. }
     
236. 
     
237. 
     
238. void bijiao()
     
239. {
     
240.         if(adval>=0&&adval<fazhi)
     
241.         move(0);
     
242.         if(adval>=fazhi&&adval<500)
     
243.         move(1);
     
244. }
     
245. 
     
246. void yunxing()
     
247. {
     
248.         if(Down==1)
     
249.                 {
     
250.                         if(Up==1)
     
251.                                 {
     
252.                                         bijiao();
     
253.                     }
     
254.                         else if(Up==0)
     
255.                     {
     
256.                             zhengzhuan(10);
     
257.                     }
     
258.           }
     
259.         else if(Down==0)
     
260.                 {
     
261.                   fanzhuan(10);
     
262.           }
     
263. }
     
264. 
     
265. void key()
     
266. {
     
267.         if(bianji==0)
     
268.         {
     
269.                 write_1602com(yi+0);
     
270.                 write_1602str("ORIGINAL:");
     
271.                 if(yuzhi[0]==0)
     
272.                 {
     
273.                         write_1602dat(0x30+yuzhi[1]);
     
274.                         delay(5);
     
275.                         write_1602dat(0x30+yuzhi[2]);
     
276.                         delay(5);
     
277.                 }
     
278.                 if(yuzhi[0]!=0)
     
279.                 {
     
280.                         write_1602dat(0x30+yuzhi[0]);
     
281.                         delay(5);
     
282.                         write_1602dat(0x30+yuzhi[1]);
     
283.                         delay(5);
     
284.                         write_1602dat(0x30+yuzhi[2]);
     
285.                         delay(5);
     
286.                 }
     
287.                 write_1602str("    ");
     
288.                 delay(5);
     
289.                 while(1)
     
290.                 {
     
291.                         yuzhi[0]=fazhi/100;
     
292.                         yuzhi[1]=fazhi%100/10;
     
293.                         yuzhi[2]=fazhi%10;
     
294.                         write_1602com(er+0);
     
295.                         write_1602str("SETTING:");
     
296.                         if(yuzhi[0]==0)
     
297.                         {
     
298.                                 write_1602dat(0x30+yuzhi[1]);
     
299.                                 delay(5);
     
300.                                 write_1602dat(0x30+yuzhi[2]);
     
301.                                 delay(5);
     
302.                         }
     
303.                         if(yuzhi[0]!=0)
     
304.                         {
     
305.                                 write_1602dat(0x30+yuzhi[0]);
     
306.                                 delay(5);
     
307.                                 write_1602dat(0x30+yuzhi[1]);
     
308.                                 delay(5);
     
309.                                 write_1602dat(0x30+yuzhi[2]);
     
310.                                 delay(5);
     
311.                         }
     
312.                         if(jia==0)
     
313.                         {
     
314.                                 delay(400);
     
315.                                 fazhi=fazhi+5;
     
316.                         }
     
317.                         if(jian==0)
     
318.                         {
     
319.                                 delay(400);
     
320.                                 fazhi=fazhi-5;
     
321.                         }
     
322.                         if(bianji==1)
     
323.                         {
     
324.                                 write_1602com(0x01);
     
325.         break;
     
326.                         }                                
     
327.                 }
     
328.         }
     
329. }
     
330. 
     
331. void main()                                
     
332. {
     
333.         Time_init();
     
334.         delay(50);
     
335.         lcd_init();      //調用液晶屏初始化子函數
     
336.         while(1)               
     
337.         {
     
338.                 key();
     
339.                 qiangdushuzhi();
     
340.                 display();
     
341.                 yunxing();
     
342.         }
     
343. }
     

復制代碼

所有資料51hei提供下載,用Proteus8.8才能打開:
智能窗簾設計.rar (88 KB, 下載次數: 645)

2019-6-26 13:03 上傳

點擊文件名下載附件
包含仿真圖和程序
下載積分: 黑幣 -5

正在學習中

哇這的不錯

為什么這個實物焊好液晶屏不顯示呢

絕對好帖子 感謝分享！！！

為什么仿真打不開，是打包缺什么文件嗎？樓主用的是哪一個版本的PROTEUS

hahahaha..... 發表于 2019-7-17 10:18
為什么這個實物焊好液晶屏不顯示呢

你調電位器了嗎

怎么沒有光敏電阻 電路圖里面？

793188403 發表于 2019-12-19 18:21
怎么沒有光敏電阻 電路圖里面？

用滑動變阻器代替了

這個只能實現光控嗎？

拿去試一下，再來

超級流氓兔 發表于 2020-3-7 13:49
拿去試一下，再來

實現了嗎？

樓主用的那個版本的軟件？我下載的工程文件打不開，提示錯誤

我想弄個溫控的

設計文檔有嗎?謝謝

不能手動自動切換吧？

仿真圖為什嗎打不開

為什么仿真打不開，是打包缺什么文件嗎？樓主用的是哪一個版本的PROTEUS

mqq一米八八 發表于 2020-5-11 09:47
仿真圖為什嗎打不開

打不開，

mqq一米八八 發表于 2020-5-13 19:02
打不開，

用ISISprotel

有設計文檔嗎

哪一個打開呀 為什么用proteus打開不了

cly5940220 發表于 2020-4-25 09:02
樓主用的那個版本的軟件？我下載的工程文件打不開，提示錯誤

我的也打不開

有沒有說明書

能在這基礎上再加一個轉機嗎？感覺都沒有引腳了

想問一下大哥們，就是最近小弟做了個類似的小玩意兒，然后仿真畫好了，程序也寫好了，步進電機跟光敏電阻+LCD1602顯示模塊都分別能用，但是不懂如何把它們寫到一起呀，求懂的大哥給小弟指點一二

想問一下這個2003驅動管腳在哪里設置的

有用STC15來做的嗎？

793188403 發表于 2019-12-19 18:21
怎么沒有光敏電阻 電路圖里面？

左下角RV1就是光敏電阻

單調的唯一的 發表于 2019-12-2 20:50
為什么仿真打不開，是打包缺什么文件嗎？樓主用的是哪一個版本的PROTEUS

需要8.11以上，你的版本低了吧

aktuan007 發表于 2020-4-25 22:50
不能手動自動切換吧？

能，只要重新設置按鍵即可

fx158 發表于 2020-2-21 19:36
這個只能實現光控嗎？

不只是光控，還能控制電機