51单片机关于LCD1602A显示和按键控制 附单片机程序

单片机源程序如下:

1. /********************************************************************************
   
2. 通过按键控制3个继电器开关，并在1602A液晶显示屏上显示        
   
3. *******************************************************************************/
   
4. #include<reg52.h>
   
5. #define uchar unsigned char
   
6. #define uint unsigned int
   
7. sbit E=P3^4;  //1602使能引脚
   
8. sbit RW=P3^6; //1602读写引脚        
   
9. sbit RS=P3^5; //1602数据/命令选择引脚
   
10. sbit key_s2 = P3^0;//独立按键S2
    
11. sbit key_s3 = P3^1;//独立按键S3
    
12. sbit key_s4 = P3^2;//独立按键S4
    
13. sbit key_s5 = P3^3;//独立按键S5
    
14. sbit M1= P1^0;
    
15. sbit M2= P1^1;
    
16. sbit M3= P1^2;
    
17. sbit beep= P2^3;
    
18. uchar j;
    
19. uchar flag;//定义标志位
    
20. uchar code tab1[]="welcome to you  ";  //要显示什么就在这儿改
    
21. uchar code tab2[]="enter       exit";  //要显示什么就在这儿改
    
22. uchar code tabhang1[]="motor: M1 M2 M3 "; //要显示什么就在这儿改
    
23. uchar code tab00[]="enter 000   exit";  
    
24. uchar code tab01[]="enter 001   exit";  
    
25. uchar code tab02[]="enter 010   exit";  
    
26. uchar code tab03[]="enter 011   exit";  
    
27. uchar code tab04[]="enter 100   exit";  
    
28. uchar code tab05[]="enter 101   exit";  
    
29. uchar code tab06[]="enter 110   exit";  
    
30. uchar code tab07[]="enter 111   exit";   
    
31. void delay(uint del)   //延时1ms
    
32. {
    
33. uint i,j;
    
34. for(i=0;i<del;i++)
    
35.    for(j=0;j<=168;j++);
    
36. }
    
37. void writecmd(uchar com)  //写指令
    
38. {
    
39. E=0;
    
40. RS=0;
    
41. RW=0;
    
42. P0=com;
    
43. delay(2);
    
44. E=1;  
    
45. delay(2);
    
46. E=0;
    
47. }
    
48. void writedata(uchar dat)//写数据
    
49. {  
    
50.   E=0;
    
51.   RS=1;
    
52.   RW=0;
    
53.   P0=dat;
    
54.   delay(2);
    
55.   E=1;  
    
56.   delay(2);
    
57.   E=0;
    
58. 
    
59. }
    
60. void kaiji()                //开机主页
    
61. {                                    
    
62. 
    
63.                         writecmd(0x80);    //告诉液晶在哪个地方显示 （设置地址指针）//80H+00
    
64.                                   for(j=0;j<16;j++)  //有16个字符，要循环16次
    
65.                                   {
    
66.                                            writedata(tab1[j]);
    
67.                                              delay(2);
    
68.                                    }
    
69.                                    writecmd(0x80+0x40); //再设置第二行的起始位置80H+40H
    
70. 
    
71.                                                                  for(j=0;j<16;j++)   //有16个字符，要循环16次
    
72.                                                                  { writedata(tab2[j]);
    
73.                                                                     delay(2);
    
74.                                                                  }
    
75. }
    
76. void delay1(uint z)        //延时子函数
    
77. {
    
78.         uint x,y;
    
79.         for(x = z; x > 0; x--)
    
80.                 for(y = 114; y > 0 ; y--);                 
    
81. }
    
82. void init(void)               //初始化
    
83. {
    
84. delay(15);
    
85. writecmd(0x38);
    
86. delay(5);
    
87. writecmd(0x38);
    
88. delay(5);
    
89. writecmd(0x38);
    
90. writecmd(0x38);
    
91. writecmd(0x08);
    
92. writecmd(0x01);
    
93. writecmd(0x06);
    
94. writecmd(0x0c);
    
95. M1=0;
    
96. M2=0;
    
97. M3=0;
    
98. kaiji();
    
99. }
    
100. void moshi0()
     
101. {
     
102.         writecmd(0x80);    //告诉液晶在哪个地方显示 （设置地址指针）//80H+00
     
103.          for(j=0;j<16;j++)  //有16个字符，要循环16次
     
104.         {
     
105.                    writedata(tabhang1[j]);
     
106.                      delay(2);
     
107.          }
     
108.          writecmd(0x80+0x40); //再设置第二行的起始位置80H+40H
     
109.          for(j=0;j<16;j++)   //有16个字符，要循环16次
     
110.                  {
     
111.                 writedata(tab00[j]);
     
112.                                 delay(2);
     
113.                   }
     
114.         if(key_s2==0)
     
115.         {        delay1(10);
     
116.                 if(key_s2 == 0)
     
117.                         {
     
118.                                 M1=0;
     
119.                                 M2=0;
     
120.                                 M3=0;
     
121.                                 while(!key_s2);//松手检测               
     
122.                         }        
     
123.         }
     
124.                
     
125.                                 
     
126. }
     
127. void moshi1()
     
128. {                       
     
129.         writecmd(0x80);    //告诉液晶在哪个地方显示 （设置地址指针）//80H+00
     
130.           for(j=0;j<16;j++)  //有16个字符，要循环16次
     
131.          {
     
132.                    writedata(tabhang1[j]);
     
133.                      delay(2);
     
134.           }
     
135.         writecmd(0x80+0x40); //再设置第二行的起始位置80H+40H
     
136.          for(j=0;j<16;j++)   //有16个字符，要循环16次
     
137.                   {
     
138.                 writedata(tab01[j]);
     
139.                                 delay(2);
     
140.                    }
     
141.         if(key_s2==0)
     
142.         {        delay1(10);
     
143.                 if(key_s2 == 0)
     
144.                         {
     
145.                                 M1=0;
     
146.                                 M2=0;
     
147.                                 M3=1;
     
148.                                 while(!key_s2);//松手检测               
     
149.                         }        
     
150.         }
     
151.                                 
     
152. if(key_s5==0)
     
153.         {        delay1(10);
     
154.                 if(key_s5== 0)
     
155.                         {
     
156.                                 M1=0;
     
157.                                 M2=0;
     
158.                                 M3=0;
     
159.                                 while(!key_s5);//松手检测               
     
160.                         }        
     
161.         }                                
     
162. 
     
163. }
     
164. void moshi2()
     
165. {
     
166.                                                                   writecmd(0x80);    //告诉液晶在哪个地方显示 （设置地址指针）//80H+00
     
167.                                   for(j=0;j<16;j++)  //有16个字符，要循环16次
     
168.                                   {
     
169.                                            writedata(tabhang1[j]);
     
170.                                              delay(2);
     
171.                                    }
     
172.                                    writecmd(0x80+0x40); //再设置第二行的起始位置80H+40H
     
173. 
     
174.                                                                  for(j=0;j<16;j++)   //有16个字符，要循环16次
     
175.                                                                  { writedata(tab02[j]);
     
176.                                                                     delay(2);
     
177.                                                                   }
     
178. if(key_s2==0)
     
179.         {        delay1(10);
     
180.                 if(key_s2 == 0)
     
181.                         {
     
182.                                 M1=0;
     
183.                                 M2=1;
     
184.                                 M3=0;
     
185.                                 while(!key_s2);//松手检测               
     
186.                         }        
     
187.         }
     
188.                                 
     
189. if(key_s5==0)
     
190.         {        delay1(10);
     
191.                 if(key_s5== 0)
     
192.                         {
     
193.                                 M1=0;
     
194.                                 M2=0;
     
195.                                 M3=0;
     
196.                                 while(!key_s5);//松手检测               
     
197.                         }        
     
198.         }                                                               
     
199. }
     
200. void moshi3()
     
201. {
     
202.                  writecmd(0x80);    //告诉液晶在哪个地方显示 （设置地址指针）//80H+00
     
203.           for(j=0;j<16;j++)  //有16个字符，要循环16次
     
204.         {
     
205.                    writedata(tabhang1[j]);
     
206.                      delay(2);
     
207.           }
     
208.         writecmd(0x80+0x40); //再设置第二行的起始位置80H+40H
     
209.          for(j=0;j<16;j++)   //有16个字符，要循环16次
     
210.                   {
     
211.                 writedata(tab03[j]);
     
212.                                 delay(2);
     
213.                   }
     
214.         if(key_s2==0)
     
215.         {        
     
216.                 delay1(10);
     
217.                 if(key_s2 == 0)
     
218.                         {
     
219.                                 M1=0;
     
220.                                 M2=1;
     
221.                                 M3=1;
     
222.                                 while(!key_s2);//松手检测               
     
223.                         }        
     
224.         }
     
225.                                 
     
226.         if(key_s5==0)
     
227.         {        delay1(10);
     
228.                 if(key_s5== 0)
     
229.                         {
     
230.                                 M1=0;
     
231.                                 M2=0;
     
232.                                 M3=0;
     
233.                                 while(!key_s5);//松手检测               
     
234.                         }        
     
235.         }                                                               
     
236. }
     
237. void moshi4()
     
238. {
     
239.                 writecmd(0x80);    //告诉液晶在哪个地方显示 （设置地址指针）//80H+00
     
240.          for(j=0;j<16;j++)  //有16个字符，要循环16次
     
241.          {
     
242.                    writedata(tabhang1[j]);
     
243.                      delay(2);
     
244.          }
     
245.         writecmd(0x80+0x40); //再设置第二行的起始位置80H+40H
     
246.          for(j=0;j<16;j++)   //有16个字符，要循环16次
     
247.                   {
     
248.                 writedata(tab04[j]);
     
249.                                 delay(2);
     
250. 
     
251.         }
     
252.         if(key_s2==0)
     
253.         {        delay1(10);
     
254.                 if(key_s2 == 0)
     
255.                         {
     
256.                                 M1=1;
     
257.                                 M2=0;
     
258.                                 M3=0;
     
259.                                 while(!key_s2);//松手检测               
     
260.                         }        
     
261.         }
     
262.                                 
     
263.         if(key_s5==0)
     
264.         {        delay1(10);
     
265.                 if(key_s5== 0)
     
266.                         {
     
267.                                 M1=0;
     
268.                                 M2=0;
     
269.                                 M3=0;
     
270.                                 while(!key_s5);//松手检测               
     
271.                         }        
     
272.         }                                                               
     
273. }
     
274. void moshi5()
     
275. {
     
276.      writecmd(0x80);    //告诉液晶在哪个地方显示 （设置地址指针）//80H+00
     
277.           for(j=0;j<16;j++)  //有16个字符，要循环16次
     
278.         {
     
279.                    writedata(tabhang1[j]);
     
280.                      delay(2);
     
281.          }
     
282.         writecmd(0x80+0x40); //再设置第二行的起始位置80H+40H
     
283.         for(j=0;j<16;j++)   //有16个字符，要循环16次
     
284.                  {
     
285.                 writedata(tab05[j]);
     
286.                                 delay(2);
     
287. 
     
288.          }
     
289.                                 
     
290.         if(key_s2==0)
     
291.         {        delay1(10);
     
292.                 if(key_s2 == 0)
     
293.                         {
     
294.                                 M1=1;
     
295.                                 M2=0;
     
296.                                 M3=1;
     
297.                                 while(!key_s2);//松手检测               
     
298.                         }        
     
299.         }
     
300.         if(key_s5==0)
     
301.         {        delay1(10);
     
302.                 if(key_s5== 0)
     
303.                         {
     
304.                                 M1=0;
     
305.                                 M2=0;
     
306.                                 M3=0;
     
307.                                 while(!key_s5);//松手检测               
     
308.                         }        
     
309.         }                                
     
310. }
     
311. void moshi6()
     
312. {
     
313.                 writecmd(0x80);    //告诉液晶在哪个地方显示 （设置地址指针）//80H+00
     
314.          for(j=0;j<16;j++)  //有16个字符，要循环16次
     
315.          {
     
316.                    writedata(tabhang1[j]);
     
317.                      delay(2);
     
318.          }
     
319.                 writecmd(0x80+0x40); //再设置第二行的起始位置80H+40H
     
320.         for(j=0;j<16;j++)   //有16个字符，要循环16次
     
321.                   {
     
322.                 writedata(tab06[j]);
     
323.                                 delay(2);
     
324.                    }
     
325.         if(key_s2==0)
     
326.         {        
     
327.                 delay1(10);
     
328.                 if(key_s2 == 0)
     
329.                         {
     
330.                                 M1=1;
     
331.                                 M2=1;
     
332.                                 M3=0;
     
333.                                 while(!key_s2);//松手检测               
     
334.                         }        
     
335.         }
     
336.         if(key_s5==0)
     
337.         {        delay1(10);
     
338.                 if(key_s5== 0)
     
339.                         {
     
340.                                 M1=0;
     
341.                                 M2=0;
     
342.                                 M3=0;
     
343.                                 while(!key_s5);//松手检测               
     
344.                         }        
     
345.         }                                                               
     
346. }
     
347. void moshi7()
     
348. {
     
349.                 writecmd(0x80);    //告诉液晶在哪个地方显示 （设置地址指针）//80H+00
     
350.          for(j=0;j<16;j++)  //有16个字符，要循环16次
     
351.          {
     
352.                    writedata(tabhang1[j]);
     
353.                      delay(2);
     
354.           }
     
355.          writecmd(0x80+0x40); //再设置第二行的起始位置80H+40H
     
356.         for(j=0;j<16;j++)   //有16个字符，要循环16次
     
357.                  {
     
358.                 writedata(tab07[j]);
     
359.                                 delay(2);
     
360.                                                                   }
     
361.         if(key_s2==0)
     
362.         {        
     
363.                 delay1(10);
     
364.                 if(key_s2 == 0)
     
365.                         {
     
366.                                 M1=1;
     
367.                                 M2=1;
     
368.                                 M3=1;
     
369.                                 while(!key_s2);//松手检测               
     
370.                         }        
     
371.         }
     
372.                                 
     
373.         if(key_s5==0)
     
374.         {        delay1(10);
     
375.                 if(key_s5== 0)
     
376.                         {
     
377.                                 M1=0;
     
378.                                 M2=0;
     
379.                                 M3=0;
     
380.                                 while(!key_s5);//松手检测               
     
381.                         }        
     
382.         }                                                               
     
383. }
     
384. void keyscan()
     
385. {
     
386.         if(key_s2==0)
     
387.         {        delay1(10);
     
388.                 if(key_s2 == 0)
     
389.                         {
     
390.                                  moshi0();
     
391.                                 while(!key_s2);//松手检测               
     
392.                         }        
     
393.         }
     
394.         if(key_s4==0)
     
395.         {        delay1(10);
     
396.                 if(key_s4 == 0)
     
397.                         {
     
398.                                 flag++;
     
399.                                 if(flag==9)
     
400.                                 flag=1;
     
401.                                 while(!key_s4);//松手检测               
     
402.                         }        
     
403.         }
     
404.         if(key_s3==0)
     
405.         {        delay1(10);
     
406.                 if(key_s3 == 0)
     
407.                         {
     
408.                                 flag--;
     
409.                                 if(flag==0)
     
410.                                 flag=8;
     
411.                                 while(!key_s3);//松手检测               
     
412.                         }        
     
413.         }
     
414.         
     
415. }
     
416. void main()
     
417. {  
     
418.         init();
     
419.         while(1)
     
420.         {
     
421.                
     
422.                 keyscan();
     
423.                 delay(20);
     
424.                 switch(flag)
     
425.                         {
     
426.                                      case 1: moshi0(); break;
     
427.                                      case 2: moshi1(); break;
     
428.                                      case 3: moshi2(); break;
     
429.                                      case 4: moshi3(); break;
     
430.                                      case 5: moshi4(); break;
     
431.                                     case 6: moshi5(); break;
     
432.                                       case 7: moshi6(); break;
     
433.                                case 8: moshi7(); break;
     
434.                                       default:break;
     
435.                 }
     
436.         }        
     
437. 
     
438. 
     
439. }

复制代码

【必读】版权免责声明

1、本主题所有言论和内容纯属会员个人意见，与本论坛立场无关。2、本站对所发内容真实性、客观性、可用性不做任何保证也不负任何责任，网友之间仅出于学习目的进行交流。3、对提供的数字内容不拥有任何权利，其版权归原著者拥有。请勿将该数字内容进行商业交易、转载等行为，该内容只为学习所提供，使用后发生的一切问题与本站无关。 4、本网站不保证本站提供的下载资源的准确性、安全性和完整性;同时本网站也不承担用户因使用这些下载资源对自己和他人造成任何形式的损失或伤害。 5、本网站所有软件和资料均为网友推荐收集整理而来，仅供学习用途使用，请务必下载后两小时内删除，禁止商用。6、如有侵犯你版权的，请及时联系我们（电子邮箱1370723259@qq.com）指出，本站将立即改正。