单片机计算器程序数码管显示及38k遥控cd1602显示遥控键值读取

38k遥控器

全部代码下载： 38k红外遥控器（用）.rar (14.75 KB, 下载次数: 12)

2016-4-13 20:36 上传

点击文件名下载附件
38k遥控器
下载积分: 黑币 -5

单片机计算器程序 数码管显示：

1. #include<reg51.h>
   
2. #include<math.h>
   
3. #define   uchar   unsigned  char
   
4. #define   uint    unsigned   int
   
5. #define   ulong   unsigned  long
   
6. uchar code tab[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x06,0xbf};//共阳极
   
7. ulong  num=0,qnum=0;
   
8. uchar  key0=0,ikey0=0,kkey=0;   //qnum为前一个键值，当为0时表示没有前一个键值，ikey0表示当存在前一个键值下进行加减乘除运算
   
9. //uchar  num1,num2,num3,num4,num5,num6;  //key0表示当为1时，是数字键，为0时，是清零键，为2时，是运算键，为3时，等号键
   
10. void  delay(uint d)                    
    
11. {
    
12.      while(d-->0);
    
13. }
    
14. 
    
15. void  error()    //当数值溢出的时候                       
    
16. {   
    
17.      P2 = 0x00;
    
18.      P2 = 0xff;
    
19.      P0 = tab[10];
    
20.      delay(100);
    
21.      P2 = 0x00;
    
22.      P0 = 0xff;
    
23. }
    
24. void  display(ulong num0)   //显示函数
    
25. {
    
26.      if(num0>999999&&num0<-99999)                      //当数值溢出时
    
27.           error();
    
28.      else if(num0>=0&&num0<=999999)                         //当数值为正数时
    
29.      {
    
30.           P2 = 0x00;
    
31.           dis1 = 1;     //显示最高位，第一位
    
32.           P0 = tab[num0/100000];
    
33.           delay(100);
    
34.           dis1 = 0;
    
35.           P0 = 0xff;
    
36.          
    
37.           P2 = 0x00;
    
38.           dis2 = 1;       //第二位
    
39.           P0 = tab[(num0/10000)%10];
    
40.           delay(100);
    
41.           dis2 = 0;
    
42.           P0 = 0xff;
    
43.          
    
44.          
    
45.           P2 = 0x00;
    
46.           dis3 = 1;       //第三位
    
47.           P0 = tab[(num0/1000)%10];
    
48.           delay(100);
    
49.           dis3 = 0;
    
50.           P0 = 0xff;
    
51.          
    
52.           P2 = 0x00;
    
53.           dis4 = 1;         //第四位
    
54.           P0 = tab[(num0/100)%10];
    
55.           delay(100);
    
56.           dis4 = 0;
    
57.           P0 = 0xff;
    
58.          
    
59.           P2 = 0x00;
    
60.           dis5 = 1;        //第五位
    
61.           P0 = tab[(num0/10)%10];
    
62.           delay(100);
    
63.           dis5 = 0;
    
64.           P0 = 0xff;
    
65.          
    
66.           P2 = 0x00;
    
67.           dis6 = 1;        //显示最低位，第六位
    
68.           P0 = tab[num0%10];
    
69.           delay(100);
    
70.           dis6 = 0;
    
71.           P0 = 0xff;
    
72.       }
    
73.       else                             //当数值为负数时
    
74.       {
    
75.           num0 = abs(num0);
    
76.           P2 = 0x00;
    
77.           dis1 = 1;     //显示最高位，第一位
    
78.           P0 = tab[11];
    
79.           delay(100);
    
80.           dis1 = 0;
    
81.           P0 = 0xff;
    
82.          
    
83.           P2 = 0x00;
    
84.           dis2 = 1;       //第二位
    
85.           P0 = tab[(num0/10000)%10];
    
86.           delay(100);
    
87.           dis2 = 0;
    
88.           P0 = 0xff;
    
89.          
    
90.          
    
91.           P2 = 0x00;
    
92.           dis3 = 1;       //第三位
    
93.           P0 = tab[(num0/1000)%10];
    
94.           delay(100);
    
95.           dis3 = 0;
    
96.           P0 = 0xff;
    
97.          
    
98.           P2 = 0x00;
    
99.           dis4 = 1;         //第四位
    
100.           P0 = tab[(num0/100)%10];
     
101.           delay(100);
     
102.           dis4 = 0;
     
103.           P0 = 0xff;
     
104.          
     
105.           P2 = 0x00;
     
106.           dis5 = 1;        //第五位
     
107.           P0 = tab[(num0/10)%10];
     
108.           delay(100);
     
109.           dis5 = 0;
     
110.           P0 = 0xff;
     
111.          
     
112.           P2 = 0x00;
     
113.           dis6 = 1;        //显示最低位，第六位
     
114.           P0 = tab[num0%10];
     
115.           delay(100);
     
116.           dis6 = 0;
     
117.           P0 = 0xff;         
     
118.       }
     
119. }
     
120. 
     
121. void  key()         //键盘扫描函数
     
122. {
     
123.      uchar  temp;
     
124.      P1 = 0xff;
     
125.      P1 = 0Xef;   //检测第一行
     
126.      temp = P1;
     
127.      temp = temp&0x0f;
     
128.      if(P1!=0X0f)
     
129.      {
     
130.           delay(5);
     
131.           temp = P1;
     
132.           temp = temp&0x0f;
     
133.           if(P1!=0X0f)
     
134.           {
     
135.                temp = P1;
     
136. 
     
137.                switch(temp)
     
138.                {
     
139.                     case 0xe7:  key0 = 0; break;                  //-----清屏键
     
140.                     case 0xeb:  key0 = 1; num = num*10+0; kkey = 1; break;  //-------'0'
     
141.                     case 0xed:  key0 = 3; break;                  //-----等号键=
     
142.                     case 0xee:  key0 = 2; ikey0 = 10; break;      //------加号键+
     
143.                }
     
144.          
     
145.           while(temp!=0x0f)
     
146.           {
     
147.                temp = P1;
     
148.                temp = temp&0x0f;
     
149.           }
     
150.           //P0 = tab[h];
     
151.          }
     
152.      }
     
153. 
     
154. 
     
155.      P1 = 0xff;
     
156.      P1 = 0Xdf;   //检测第二行
     
157.      temp = P1;
     
158.      temp = temp&0x0f;
     
159.      if(P1!=0X0f)
     
160.      {
     
161.           delay(5);
     
162.           temp = P1;
     
163.           temp = temp&0x0f;
     
164.           if(P1!=0X0f)
     
165.           {
     
166.                temp = P1;
     
167. 
     
168.                switch(temp)
     
169.                {
     
170.                     case 0xd7:  key0 = 1; num = num*10+1; kkey = 1; break;   //------'1'
     
171.                     case 0xdb:  key0 = 1; num = num*10+2; kkey = 1; break;   //------'2'
     
172.                     case 0xdd:  key0 = 1; num = num*10+3; kkey = 1; break;   //-------'3'
     
173.                     case 0xde:  key0 = 2; ikey0 = 11; break;       //-----减号键-
     
174.                }
     
175.          
     
176.           while(temp!=0x0f)
     
177.           {
     
178.                temp = P1;
     
179.                temp = temp&0x0f;
     
180.           }
     
181.           //P0 = tab[h];
     
182.          }
     
183.      }
     
184. 
     
185. 
     
186.      P1 = 0xff;
     
187.      P1 = 0Xbf;   //检测第三行
     
188.      temp = P1;
     
189.      temp = temp&0x0f;
     
190.      if(P1!=0X0f)
     
191.      {
     
192.           delay(5);
     
193.           temp = P1;
     
194.           temp = temp&0x0f;
     
195.           if(P1!=0X0f)
     
196.           {
     
197.                temp = P1;
     
198. 
     
199.                switch(temp)
     
200.                {
     
201.                     case 0xb7:  key0 = 1; num = num*10+4; kkey = 1; break;    //-------'4'
     
202.                     case 0xbb:  key0 = 1; num = num*10+5; kkey = 1; break;    //-------'5'
     
203.                     case 0xbd:  key0 = 1; num = num*10+6; kkey = 1; break;    //-------'6'
     
204.                     case 0xbe:  key0 = 2; ikey0 = 12; break;        //------乘号键*
     
205.                }
     
206.          
     
207.           while(temp!=0x0f)
     
208.           {
     
209.                temp = P1;
     
210.                temp = temp&0x0f;
     
211.           }
     
212.           //P0 = tab[h];
     
213.          }
     
214.      }
     
215. 
     
216. 
     
217.      P1 = 0xff;
     
218.      P1 = 0X7f;   //检测第四行
     
219.      temp = P1;
     
220.      temp = temp&0x0f;
     
221.      if(P1!=0X0f)
     
222.      {
     
223.           delay(5);
     
224.           temp = P1;
     
225.           temp = temp&0x0f;
     
226.           if(P1!=0X0f)
     
227.           {
     
228.                temp = P1;
     
229.                
     
230.                switch(temp)
     
231.                {
     
232.                     case 0x77:  key0 = 1; num = num*10+7; kkey = 1; break;     //-------'7'
     
233.                     case 0x7b:  key0 = 1; num = num*10+8; kkey = 1; break;     //--------'8'
     
234.                     case 0x7d:  key0 = 1; num = num*10+9; kkey = 1; break;     //--------'9'
     
235.                     case 0x7e:  key0 = 2; ikey0 = 13; break;         //-------除号键
     
236.                     
     
237.                }
     
238.          
     
239.           while(temp!=0x0f)
     
240.           {
     
241.                temp = P1;
     
242.                temp = temp&0x0f;
     
243.           }
     
244.          }
     
245.      }
     
246.               
     
247. }
     
248. 
     
249. void  count()
     
250. {
     
251.      key();
     
252.      if(key0 == 0)         //清零
     
253.      {
     
254.           num = 0;qnum = 0;
     
255.           display(num);
     
256.      }
     
257.      else  if(key0 == 1)       //数字键，显示数字
     
258.      {     
     
259.           display(num);
     
260.          
     
261.      }
     
262.      else if(key0 == 8)
     
263.      {
     
264.           display(qnum);
     
265.      }
     
266.      else if(key0 == 2)        //当为运算符号键时
     
267.      {
     
268.           qnum = num;
     
269.           num = 0;
     
270.           key0 = 8;
     
271.                
     
272.      }
     
273.      else if(key0 == 3)        //等号键
     
274.      {
     
275.           switch(ikey0)
     
276.                {
     
277.                     case 10:num = num + qnum;  key0 = 2; break;
     
278.                     case 11:num = qnum - num;  key0 = 2; break;
     
279.                     case 12:num = num * qnum;  key0 = 2; break;
     
280.                     case 13:num = qnum / num;  key0 = 2; break;
     
281.                     //default  break;
     
282.                }        
     
283.           //}
     
284.      }
     
285. 
     
286. }
     
287. 
     
288.          
     
289. void  main()
     
290. {    while(1)
     
291.      {   
     
292.           //display(num);
     
293.           count();
     
294.      }     
     
295. }
     
296. 
     

复制代码

1. /********************************************************************************
   
2. *                                                                              *
   
3. *         lcd1602显示遥控键值读取                                              *
   
4. *         lcd1602显示 红外接收头接p3.2                                         *
   
5. *         蜂鸣器接p3.7                                                         *
   
6. *                                                                              *
   
7. ********************************************************************************/
   
8. 
   
9. #include <reg51.h>
   
10. #include <intrins.h>
    
11. 
    
12. #define uchar unsigned char
    
13. #define uint  unsigned int
    
14. #define delayNOP(); {_nop_();_nop_();_nop_();_nop_();};
    
15. 
    
16. void delay(uchar x);  //x*0.14MS
    
17. void delay1(int ms);
    
18. void beep();
    
19. 
    
20. sbit IRIN = P3^2;         //红外接收器数据线
    
21. //sbit BEEP = P3^7;         //蜂鸣器驱动线
    
22. 
    
23. 
    
24. uchar IRCOM[7];
    
25. 
    
26. sbit LCD_RS = P2^1;            
    
27. sbit LCD_RW = P2^2;
    
28. sbit LCD_EN = P2^3;
    
29. 
    
30. uchar code  cdis1[ ] = {" Remote Control "};
    
31. uchar code  cdis2[ ] = {"  IR-CODE: --H  "};
    
32. 
    
33. /*******************************************************************/
    
34. /*                                                                 */
    
35. /*检查LCD忙状态                                                    */
    
36. /*lcd_busy为1时，忙，等待。lcd-busy为0时,闲，可写指令与数据。      */
    
37. /*                                                                 */
    
38. /*******************************************************************/
    
39. 
    
40. bit lcd_busy()
    
41. {                          
    
42.     bit result;
    
43.     LCD_RS = 0;
    
44.     LCD_RW = 1;
    
45.     LCD_EN = 1;
    
46.     delayNOP();
    
47.     result = (bit)(P0&0x80);
    
48.     LCD_EN = 0;
    
49.     return(result);
    
50. }
    
51. 
    
52. /*******************************************************************/
    
53. /*                                                                 */
    
54. /*写指令数据到LCD                                                  */
    
55. /*RS=L，RW=L，E=高脉冲，D0-D7=指令码。                             */
    
56. /*                                                                 */
    
57. /*******************************************************************/
    
58. 
    
59. void lcd_wcmd(uchar cmd)
    
60. 
    
61. {                          
    
62.    while(lcd_busy());
    
63.     LCD_RS = 0;
    
64.     LCD_RW = 0;
    
65.     LCD_EN = 0;
    
66.     _nop_();
    
67.     _nop_();
    
68.     P0 = cmd;
    
69.     delayNOP();
    
70.     LCD_EN = 1;
    
71.     delayNOP();
    
72.     LCD_EN = 0;  
    
73. }
    
74. 
    
75. /*******************************************************************/
    
76. /*                                                                 */
    
77. /*写显示数据到LCD                                                  */
    
78. /*RS=H，RW=L，E=高脉冲，D0-D7=数据。                               */
    
79. /*                                                                 */
    
80. /*******************************************************************/
    
81. 
    
82. void lcd_wdat(uchar dat)
    
83. {                          
    
84.    while(lcd_busy());
    
85.     LCD_RS = 1;
    
86.     LCD_RW = 0;
    
87.     LCD_EN = 0;
    
88.     P0 = dat;
    
89.     delayNOP();
    
90.     LCD_EN = 1;
    
91.     delayNOP();
    
92.     LCD_EN = 0;
    
93. }
    
94. 
    
95. /*******************************************************************/
    
96. /*                                                                 */
    
97. /*  LCD初始化设定                                                  */
    
98. /*                                                                 */
    
99. /*******************************************************************/
    
100. 
     
101. void lcd_init()
     
102. {
     
103.     delay1(15);                  
     
104.     lcd_wcmd(0x38);      //16*2显示，5*7点阵，8位数据
     
105.     delay1(5);
     
106.     lcd_wcmd(0x38);         
     
107.     delay1(5);
     
108.     lcd_wcmd(0x38);         
     
109.     delay1(5);
     
110. 
     
111.     lcd_wcmd(0x0c);      //显示开，关光标
     
112.     delay1(5);
     
113.     lcd_wcmd(0x06);      //移动光标
     
114.     delay1(5);
     
115.     lcd_wcmd(0x01);      //清除LCD的显示内容
     
116.     delay1(5);
     
117. }
     
118. 
     
119. /*******************************************************************/
     
120. /*                                                                 */
     
121. /*  设定显示位置                                                   */
     
122. /*                                                                 */
     
123. /*******************************************************************/
     
124. 
     
125. void lcd_pos(uchar pos)
     
126. {                          
     
127.   lcd_wcmd(pos | 0x80);  //数据指针=80+地址变量
     
128. }
     
129. 
     
130. /*******************************************************************/
     
131. main()
     
132. {
     
133.    uchar m;
     
134.    
     
135.     IRIN=1;                    //I/O口初始化
     
136.     //BEEP=1;
     
137.        
     
138.     delay1(10);                 //延时
     
139.     lcd_init();                //初始化LCD            
     
140.         
     
141.     lcd_pos(0);                //设置显示位置为第一行的第1个字符
     
142. 
     
143.      m = 0;
     
144.     while(cdis1[m] != '\0')
     
145.      {                         //显示字符
     
146.        lcd_wdat(cdis1[m]);
     
147.        m++;
     
148.      }
     
149. 
     
150.     lcd_pos(0x40);             //设置显示位置为第二行第1个字符
     
151.      m = 0;
     
152.     while(cdis2[m] != '\0')
     
153.      {
     
154.        lcd_wdat(cdis2[m]);      //显示字符
     
155.        m++;
     
156.      }
     
157. 
     
158. 
     
159.         IE = 0x81;                 //允许总中断中断,使能 INT0 外部中断
     
160.         TCON = 0x01;               //触发方式为脉冲负边沿触发
     
161. 
     
162.    while(1)        ;
     
163. 
     
164. } //end main
     
165. /**********************************************************/
     
166. void IR_IN() interrupt 0 using 0
     
167. {
     
168.   unsigned char j,k,N=0;
     
169.      EX0 = 0;   
     
170.          delay(15);
     
171.          if (IRIN==1)
     
172.      { EX0 =1;
     
173.            return;
     
174.           }
     
175.                            //确认IR信号出现
     
176.   while (!IRIN)            //等IR变为高电平，跳过9ms的前导低电平信号。
     
177.     {delay(1);}
     
178. 
     
179. for (j=0;j<4;j++)         //收集四组数据
     
180. {
     
181.        for (k=0;k<8;k++)        //每组数据有8位
     
182.        {
     
183.              while (IRIN)            //等 IR 变为低电平，跳过4.5ms的前导高电平信号。
     
184.                {delay(1);}
     
185.               while (!IRIN)          //等 IR 变为高电平
     
186.                {delay(1);}
     
187.                while (IRIN)           //计算IR高电平时长
     
188.                 {
     
189.                    delay(1);
     
190.                    N++;           
     
191.                    if (N>=30)
     
192.                         {
     
193.                           EX0=1;
     
194.                              return;
     
195.                      }                  //30*0.14ms=4.2ms计数过长自动离开。
     
196.                 }                        //高电平计数完毕               
     
197.                IRCOM[j]=IRCOM[j] >> 1;                  //数据最高位补“0”
     
198.                if (N>=8) {IRCOM[j] = IRCOM[j] | 0x80;}  //数据最高位补“1”
     
199.                N=0;
     
200.        }//end for k
     
201. }//end for j
     
202.    
     
203.    if (IRCOM[2]!=~IRCOM[3])
     
204.    {
     
205.      EX0=1;
     
206.      return;
     
207.    }
     
208. 
     
209.    IRCOM[5]=IRCOM[2] & 0x0F;     //取键码的低四位
     
210.    IRCOM[6]=IRCOM[2] >> 4;       //右移4次，高四位变为低四位
     
211. 
     
212.    if(IRCOM[5]>9)                  //将16进制数用ASCLL码中的字符表示
     
213.     { IRCOM[5]=IRCOM[5]+0x37;}
     
214.    else
     
215.           IRCOM[5]=IRCOM[5]+0x30;    //0x30是ASCLL码的’0‘
     
216. 
     
217.    if(IRCOM[6]>9)
     
218.     { IRCOM[6]=IRCOM[6]+0x37;}
     
219.    else
     
220.           IRCOM[6]=IRCOM[6]+0x30;
     
221. 
     
222.      lcd_pos(0x4b);            
     
223.      lcd_wdat(IRCOM[6]);        //第一位数显示
     
224.      lcd_pos(0x4c);            
     
225.      lcd_wdat(IRCOM[5]);        //第二位数显示
     
226. 
     
227.      //beep();
     
228.      EX0 = 1;
     
229. }
     
230. 
     
231. /**********************************************************/
     
232. /*void beep()
     
233. {
     
234.   unsigned char i;
     
235.   for (i=0;i<100;i++)
     
236.    {
     
237.    delay(4);
     
238.    BEEP=!BEEP;                 //BEEP取反
     
239.    }
     
240.   BEEP=1;                      //关闭蜂鸣器
     
241. }*/
     
242. /**********************************************************/
     
243. void delay(unsigned char x)    //x*0.14MS
     
244. {
     
245. unsigned char i;
     
246.   while(x--)
     
247. {
     
248.   for (i = 0; i<13; i++) {}
     
249. }
     
250. }
     
251. 
     
252. /**********************************************************/
     
253. void delay1(int ms)
     
254. {
     
255. unsigned char y;
     
256.   while(ms--)
     
257. {
     
258.   for(y = 0; y<250; y++)
     
259.   {
     
260.    _nop_();
     
261.    _nop_();
     
262.    _nop_();
     
263.    _nop_();
     
264.   }
     
265. }
     
266. }
     
267. 
     

复制代码

可以运行吗