代碼:

1. #include"reg51.h"
   
2. #include"intrins.h"
   
3. #include"absacc.h"
   
4. 
   
5. #define busy 0x80
   
6. #define uchar unsigned char
   
7. #define unit unsigned int
   
8. 
   
9. sbit RS=P2^3;
   
10. sbit RW=P2^4;
    
11. sbit E=P2^5;
    
12. sbit KEY1=P2^0;
    
13. sbit KEY2=P2^1;
    
14. sbit KEY3=P2^2;
    
15. uchar code tab[8]={0x02,0x06,0x04,0x0C,0x08,0x09,0x01,0x03};
    
16. uchar temp;
    
17. void delay(uchar k)
    
18. {
    
19. unit i,j;
    
20. for(i=0;i<k;i++)
    
21. {
    
22. for(j=0;j<60;j++)
    
23. {;}
    
24. }
    
25. }
    
26. void test_1602busy()
    
27. {
    
28. P0=0xFF;
    
29. E=1;
    
30. RS=0;
    
31. RW=1;
    
32. _nop_();
    
33. _nop_();
    
34. while(P0&busy)
    
35. {
    
36. E=0;
    
37. _nop_();
    
38. E=1;
    
39. _nop_();
    
40. }
    
41. E=0;
    
42. }
    
43. 
    
44. void write_1602Command(uchar co)
    
45. {
    
46. test_1602busy();
    
47. RS=0;
    
48. RW=0;
    
49. E=0;
    
50. _nop_();
    
51. P0=co;
    
52. _nop_();
    
53. E=1;
    
54. _nop_();
    
55. E=0;
    
56. }
    
57. 
    
58. void write_1602Data(uchar Data)
    
59. {
    
60. test_1602busy();
    
61. P0=Data;
    
62. RS=1;
    
63. RW=0;
    
64. E=1;
    
65. _nop_();
    
66. E=0;
    
67. }
    
68. 
    
69. void init_1602(void)
    
70. {
    
71. write_1602Command(0x38);
    
72. delay(5);
    
73. write_1602Command(0x01);
    
74. delay(5);
    
75. write_1602Command(0x06);
    
76. delay(5);
    
77. write_1602Command(0x0F);
    
78. delay(5);
    
79. write_1602Command(0x0C);
    
80. }
    
81. void DisplayOneChar(uchar X, uchar Y, uchar DData)
    
82. {
    
83. Y&=1;
    
84. X&=15;
    
85. if(Y)X|=0x40;
    
86. X|=0x80;
    
87. write_1602Command(X);
    
88. write_1602Data(DData);
    
89. }
    
90. void display_1602(uchar *DData,X,Y)
    
91. {
    
92. uchar ListLength=0;
    
93. Y&=0x01;
    
94. X&=0x0F;
    
95. while(X<16)
    
96. {
    
97.   DisplayOneChar(X,Y,DData[ListLength]) ;
    
98. ListLength++;
    
99. X++;
    
100. }
     
101. 
     
102. }
     
103. 
     
104. void main()
     
105. {
     
106. uchar i=0;
     
107. uchar delay_v=100;
     
108. uchar flag=0;
     
109. P1=0xFF;
     
110. P2=0xFF;
     
111. init_1602();
     
112. display_1602("STA:  SPD:  ",0,0);
     
113. display_1602("RUN:      ",0,1);
     
114. while(1)
     
115. {
     
116.         if(KEY2==1)DisplayOneChar(4,0,'Z');
     
117.         else DisplayOneChar(4,0,'F');
     
118. if(KEY3==0)
     
119. {
     
120. i++;
     
121. i=i%3;
     
122. while(KEY3==0)
     
123. {;}
     
124. }
     
125. switch(i)
     
126. {
     
127. case 0:delay_v=100;DisplayOneChar(13,0,'1');break;
     
128. case 1:delay_v=75;DisplayOneChar(13,0,'2');break;
     
129. case 2:delay_v=100;DisplayOneChar(13,0,'3');break;
     
130. }
     
131. if(KEY1==0)
     
132. {
     
133. display_1602("      RUN:ON    ",0,1);
     
134. if(flag==0)
     
135. {
     
136. if(KEY2==1)
     
137. { temp=0;
     
138. P1=tab[temp];
     
139. flag=1;
     
140. delay(delay_v);
     
141. }
     
142. if(KEY2==0)
     
143. { temp=6;
     
144. P1=tab[temp];
     
145. flag=1;
     
146. delay(delay_v);
     
147. }
     
148. }
     
149. if(KEY2==1)
     
150. { temp++;
     
151. if(temp==8)
     
152. {temp=0;}
     
153. P1=tab[temp];
     
154. delay(delay_v);
     
155. }
     
156. if(KEY2==0)
     
157. { temp--;
     
158. if(temp==0xFF)
     
159. {temp=7;}
     
160. P1=tab[temp];
     
161. delay(delay_v);
     
162. }
     
163. }
     
164. else display_1602("    RUN:off      ",0,1);
     
165. }
     
166. }