PC机通过RS232控制单片机(Proteus仿真+代码)

单片机与PC机通过RS232相连，编写一个异步串行口通信程序，实现单片机与PC机上的串口助手之间的通信。

功能实现：

1、当PC机向单片机发送字符‘1’~‘8’，打开对应的8个灯；

2、当PC机再次向单片机发送字符‘1’~‘8’时，关闭对应的灯；

3、当PC机向单片机发送字符‘d’时，会在液晶屏上删除一个字符；

4、当PC机向单片机发送字符‘n’时，会在液晶屏上换行显示；

5、当PC机向单片机发送字符‘c’时，会清屏显示；

6、当PC机向单片机发送字符‘m’时，会打开音乐播放，结束后可继续操作；

7、当PC机向单片机发送其它字符时，会显示在1602液晶屏上；

8、当矩阵按键有按键按下时，单片机会把键值发送到PC机上。

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）

单片机源程序如下:

1. #include<reg52.h>
   
2. #include<string.h>
   
3. #include<intrins.h>
   
4. #define uchar unsigned char
   
5. #define        uint unsigned int
   
6. uchar str[17];
   
7. uchar ch;
   
8. uchar m,n;
   
9. sbit K1=P3^7;
   
10. bit play=0;
    
11. sbit LEN=P3^4;
    
12. sbit LCDEN=P3^6;
    
13. sbit RS=P3^3;
    
14. sbit RW=P3^5;
    
15. sbit BF=P2^7;
    
16. sbit LED=P0;
    
17. sbit BEEP=P3^2;
    
18. uint I=0,J,K;
    
19. uchar code keyval[]="123456789*0#"; //按键对应的符号
    
20. char s[ ]="MCS-51 Microcomputer";
    
21. uchar OpenLight[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
    
22. uchar CloseLight[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
    
23. uchar code T[49][2]={{0,0},
    
24. {0xF8,0x8B},{0xF8,0xF2},{0xF9,0x5B},{0xF9,0xB7},{0xFA,0x14},{0xFA,0x66},{0xFA,0xB9},{0xFB,0x03},{0xFB,0x4A},{0xFB,0x8F},{0xFB,0xCF},{0xFC,0x0B},
    
25. {0xFC,0x43},{0xFC,0x78},{0xFC,0xAB},{0xFC,0xDB},{0xFD,0x08},{0xFD,0x33},{0xFD,0x5B},{0xFD,0x81},{0xFD,0xA5},{0xFD,0xC7},{0xFD,0xE7},{0xFE,0x05},
    
26. {0xFE,0x21},{0xFE,0x3C},{0xFE,0x55},{0xFE,0x6D},{0xFE,0x84},{0xFE,0x99},{0xFE,0xAD},{0xFE,0xC0},{0xFE,0x02},{0xFE,0xE3},{0xFE,0xF3},{0xFF,0x02},
    
27. {0xFF,0x10},{0xFF,0x1D},{0xFF,0x2A},{0xFF,0x36},{0xFF,0x42},{0xFF,0x4C},{0xFF,0x56},{0xFF,0x60},{0xFF,0x69},{0xFF,0x71},{0xFF,0x79},{0xFF,0x81}
    
28. };
    
29. uchar code music[][2]={
    
30. {0,4},{20,8},{25,4},{22,4},{20,8},
    
31. {20,8},{17,4},{20,4},{22,4},{25,4},
    
32. {20,8},{20,8},{22,8},{20,4},{17,4},
    
33. {15,8},{15,8},{17,8},{20,4},{17,4},
    
34. {15,4},{17,4},{13,8},{22,8},{20,8},
    
35. {22,8},{20,8},{17,8},{22,8},{20,16},
    
36. {20,4},{20,4},{17,4},{15,4},{13,16},
    
37. {13,4},{13,4},{15,4},{17,4},{13,16},
    
38. {0xFF,0xFF}};
    
39. //生日快乐歌的音符频率表，不同频率由不同的延时来决定
    
40. uchar code SONG_TONE[]={212,212,190,212,159,169,212,212,190,212,142,159,
    
41.                                                 212,212,106,126,159,169,190,119,119,126,159,142,159,0};
    
42. //生日快乐歌节拍表，节拍决定每个音符的演奏长短
    
43. uchar code SONG_LONG[]={9,3,12,12,12,24,9,3,12,12,12,24,
    
44. 9,3,12,12,12,12,12,9,3,12,12,12,24,0};
    
45. void delay(uchar p)
    
46. {
    
47.     uchar i,j;
    
48.     for(;p>0;p--)
    
49.     for(i=181;i>0;i--)
    
50.     for(j=181;j>0;j--);
    
51. }
    
52. void DelayMS(uint x)
    
53. {
    
54.         uchar t;
    
55.         while(x--) for(t=0;t<120;t++);
    
56. }
    
57. //2￥·?oˉêy
    
58. void PlayMusic2()
    
59. {
    
60. //        uint i=0,j,k;
    
61.         if(SONG_LONG[I]!=0||SONG_TONE[I]!=0)
    
62.         {        
    
63.                 for(J=0;J<SONG_LONG[I]*20;J++)
    
64.                 {
    
65.                         BEEP=~BEEP;
    
66.                         
    
67.                         for(K=0;K<SONG_TONE[I]/3;K++);
    
68.                 }
    
69.                 DelayMS(10);
    
70.                 I++;               
    
71.         }
    
72.         else
    
73.                 I=0;
    
74. }
    
75. void delay_us(uchar t) //微秒延时
    
76. {uchar i;
    
77. for(i=0;i<=t;i++);
    
78. }
    
79. void Alarm(uchar t) //报警
    
80. {
    
81. uchar i,j,k;         
    
82. for(j=0;j<t;j++)
    
83. { for(i=0;i<200;i++)
    
84.       {BEEP=0;delay_us(50);BEEP=1;delay_us(50);}
    
85.    for(k=0;k<100;k++)
    
86.       {BEEP=0;delay_us(110);BEEP=1;delay_us(110);}
    
87. }
    
88. }
    
89. void pause()
    
90. {
    
91.     uchar i,j;
    
92.     for(i=150;i>0;i--)
    
93.     for(j=150;j>0;j--);
    
94. }
    
95. void delay_ms(unsigned int xms)
    
96. {
    
97.         int i,j;
    
98.         for(i=xms;i>0;i--)
    
99.                 for(j=110;j>0;j--);
    
100. }
     
101. void PlayMusic()
     
102. {
     
103.         uchar i=0;
     
104.         
     
105.         while(1)
     
106.         {         if(i==40){ ET0=0;
     
107.                         break;         }
     
108.                 m=music[i][0];
     
109.                 n=music[i][1];
     
110.                    if(m==0x00)
     
111.             {
     
112.                         TR0=0;
     
113.                         delay(n);
     
114.                         i++;
     
115.                 }
     
116.             else if(m==0xFF)
     
117.            {
     
118.                    TR0=0;
     
119.                    delay(30);
     
120.                    i=0;
     
121.            }
     
122.            else if(m==music[i+1][0])
     
123.            {
     
124.                    TR0=1;
     
125.                    delay(n);
     
126.                    TR0=0;
     
127.                    pause();
     
128.                    i++;
     
129.            }
     
130.            else
     
131.            {
     
132.                    TR0=1;
     
133.                    delay(n);
     
134.                    i++;
     
135.            }
     
136.         }
     
137. }
     
138. uchar keypad4_3()//按键扫描函数:要去抖，若有按键按下，返回对应的按键值(0-11),没有按键按下返回12
     
139. {
     
140.         uchar i,row,temp;
     
141.         uchar key=12;//按键号，初值设置为12，目的是：没有按键按下时返回12；
     
142.                   //若不设初值(默认值为0)，没有按键按下时，将返回0，会误认为0被按下  
     
143.         row=0xef; //从第一行开始      
     
144.         for(i=0;i<4;i++)
     
145.         {
     
146.                 P1=0xff;  
     
147.                 P1=row;        //第i行信号，对应行为低，其他全为高
     
148.                 row=_crol_(row,1);           //生成下一行信号
     
149.                 temp=P1; //读入扫描信号
     
150.                 temp=temp&0x07; //屏蔽高5位信号，只保留低3位列信号
     
151.                 if(temp!=0x07)//有按键被按下，因为第i行某列有按键按下，则低3位中有一位为低  
     
152.                  {  
     
153.                         delay_ms(20);  //延时去抖
     
154.                         temp=P1;  
     
155.                         temp=temp&0x07;  
     
156.                         if(temp!=0x07)   //再次确认有按键被按下
     
157.                           {  
     
158.                         switch(temp)  //根据低3位列信号，判断哪个按键被按下
     
159.                     {  
     
160.                             case 0x06:key=0+3*i;break; //第i行第1列按键被按下
     
161.                         case 0x05:key=1+3*i;break; //第i行第2列按键被按下  
     
162.                         case 0x03:key=2+3*i;break; //第i行第3列按键被按下                                    
     
163.                     }
     
164.                                 
     
165.                                 do
     
166.                                 {
     
167.                                         temp=P1;              //再次扫描按键
     
168.                                           temp=temp&0x07;  
     
169.                                   }while(temp!=0x07); //等待按键释放   
     
170.                           }  
     
171.              }
     
172.         }  
     
173.         return(key);//扫面结束，返回按键值
     
174. }        
     
175. uchar RdACAdr()//读当前光标地址
     
176. {   
     
177.         uchar result;
     
178.         P2 = 0xff;        //读地址前先置高电平，防止误判
     
179.         RS = 0;
     
180.         delay_ms(5);
     
181.     RW = 1;
     
182.         LCDEN = 1;
     
183.         delay_ms(5);
     
184.         result=P2&0x7f; //去掉最高位忙闲标记，只保留低7位地址值
     
185.         LCDEN = 0;
     
186.         return result;                     
     
187. }
     
188. 
     
189. uchar DectectBusyBit(void)//状态判断函数(忙/闲?)
     
190. {   
     
191.         bit result;
     
192.         P2 = 0xff;        //读状态前先置高电平，防止误判
     
193.         RS = 0;
     
194.         delay_ms(5);
     
195.     RW = 1;
     
196.         LCDEN = 1;
     
197.         delay_ms(5);
     
198.         result=BF; //若LCM忙,则反复测试,在此处原地踏步；当LCM闲时，才往下继续
     
199.         LCDEN = 0;
     
200.         return result;                     
     
201. }
     
202. 
     
203. void WrComLCD(unsigned char ComVal)//写命令函数
     
204. {
     
205.         while(DectectBusyBit()==1);         //先检测LCM是否空闲
     
206.         RS = 0;
     
207.         delay_ms(1);
     
208.     RW = 0;
     
209.         LCDEN = 1;
     
210.         P2 = ComVal;
     
211.         delay_ms(1);
     
212.         LCDEN = 0;        
     
213. }
     
214. 
     
215. void WrDatLCD(uchar DatVal)//写数据函数
     
216. {
     
217.         while(DectectBusyBit()==1);
     
218.         RS = 1;
     
219.         delay_ms(1);
     
220.     RW = 0;
     
221.         LCDEN = 1;
     
222.         P2 = DatVal;
     
223.         delay_ms(1);
     
224.         LCDEN = 0;        
     
225. }
     
226. void WrStrDat(uchar *p)//显示英文字符串（长度不超过32）
     
227. {        
     
228.         uchar i=0,t;
     
229.    
     
230.         while(p[i]!='\0')
     
231.         {  
     
232.                   WrDatLCD(p[i]);
     
233.                 i++;
     
234.                 delay_ms(5);
     
235.         
     
236.                 t=RdACAdr();
     
237.         if(t==0x10) WrComLCD(0xc0);//读当前坐标，如果第1行写完换行到第2行        
     
238.                 if(t==0x50) WrComLCD(0x80);//读当前坐标，如果第2行写完换行到第1行        
     
239.         }        
     
240. }
     
241. 
     
242. void LCD_Init(void)//1602初始化函数
     
243. {
     
244.         //delay(15);
     
245.         WrComLCD(0x38);
     
246.         //delay(5);     // 功能设定:16*2行、5*7点阵、8位数据接口
     
247.         WrComLCD(0x38);
     
248.         //delay(5);
     
249.         WrComLCD(0x38);   
     
250. //多次重复设定功能指令,因为LCD启动后并不知道使用的是4位数据接口还是8位的，所以开始时总是默认为4位，这样刚开始写入功能设定指令时，低4位被忽略,为了可靠，最好多写几遍该指令
     
251.         WrComLCD(0x01);    // 清屏
     
252.         WrComLCD(0x06);    // 光标自增、屏幕不动  
     
253.         delay_ms(1);              // 延时，等待上面的指令生效，下面再显示，防止出现乱码
     
254.         WrComLCD(0x0C);    // 开显示、关光标
     
255. }
     
256. 
     
257. void uart_init(unsigned int bps)
     
258. { unsigned char t;
     
259.   SCON=0x50;    //工作方式一：8位异步收发，波特率可变，允许接收数据
     
260.   PCON=0x00;    //SMOD=0
     
261.   TI=0;    //软件清零，表示未发送完成
     
262.   EA=1;   //开总中断
     
263.   ET1=1;
     
264.   ET0=1;   //开T0
     
265.   ES=1;   //开串口中断
     
266.   TMOD=0x21;   //设置T1定时器8位自动装载模式
     
267.   switch(bps)
     
268.   { case 1200:t=0xe8;break;
     
269.     case 2400:t=0xf4;break;
     
270.     case 4800:t=0xfa;break;
     
271.     case 9600:t=0xfd;break;
     
272.   }
     
273.   TH1=t;
     
274.   TL1=t;
     
275.   TR1=1;   //开启T1
     
276. }
     
277. void uart_send(unsigned char ch)
     
278. {
     
279.   ES=0;   //关串口中断
     
280.   SBUF=ch;
     
281.   while(TI==0);  //等待发送完成
     
282.   TI=0;  //清除中断标记
     
283.   ES=1;   //开中断
     
284. }
     
285. unsigned char receive(void)
     
286. {        unsigned char dat;
     
287.         while(RI==0);   //等待接收完毕
     
288.         RI=0;          //将接收中断标志RI清0，为接收下一帧数据做准备
     
289.      dat=SBUF;         //将接收缓冲器中的数据存入dat
     
290.      return dat;        //将接收到的数据返回
     
291. }
     
292. 
     
293. void main (void)
     
294. {         uchar temp=0xff;
     
295.         uchar tt=0xff;
     
296.         uchar a,b=0;
     
297.         uchar  keypadVal=12;
     
298.         //TMOD=0x21;  EA=1; ET0=1;
     
299.          //ET1=0;  
     
300.         //LEN=1;
     
301.         PT0=1;
     
302.         //PS=1;
     
303.         P0=0xff;
     
304.         //LEN=0;
     
305.           uart_init(9600);//串口初始化
     
306.           LCD_Init();//1602液晶屏初始化
     
307.           delay_ms(5);   //延时，等待初始化完成
     
308.         WrComLCD(0x80);           //设置显示地址第一行第一位：0X00（0x80+0x00）   
     
309.         
     
310.           while(1)
     
311.     {
     
312.                  
     
313.                  keypadVal=keypad4_3();
     
314.                 if(keypadVal<12)
     
315.                 {
     
316.                         uart_send(keyval[keypadVal]);
     
317.                 }
     
318.                 /*if(K1==0)//如按键按下,就发送"MCS-51 Microcomputer"
     
319.         {
     
320.                         b=0;//计数器清0
     
321.                   a=strlen(s);//取数组长度
     
322.                   for(;b<a;b++)//循环取数据发送,从0到a
     
323.               { SBUF=s[b];//发送"MCS-51 Microcomputer"
     
324.                 while(!TI);//没有发送完,就等待.
     
325.                 TI=0;//清发送结束标志
     
326.                }
     
327.            while(!K1);//如果按键没有松开,等待
     
328.          }*/
     
329.       if(RI||a=='m')//如果接收到数据,就把接收到的数回发给PC
     
330.          { uchar pos;
     
331.                  
     
332.                          RI=0;//清接收标志
     
333.                
     
334.                         //if(a!='m')
     
335.            //{
     
336.                                    a=SBUF ;//读串行口数据
     
337.                            SBUF=a;//把从PC机发送过来的数据返回给PC机
     
338.                         //        if(a=='m')
     
339.                         //        play=~play;
     
340.                   // }
     
341.                            
     
342.                         
     
343.            while(!TI);//没有发送完等待
     
344.            TI=0;//清发送完中断标志
     
345.                    if(a>'0'&&a<='8')
     
346.                    {
     
347.                            if(temp==a)
     
348.                                    tt=tt^(_crol_(0x01,a-'0'-1));
     
349.                         //P0=0x00;
     
350.                         else
     
351.                                 tt=tt&(~OpenLight[a-'0'-1]);
     
352.                         temp=a;
     
353.                         P0=tt;
     
354.                    }
     
355.                         else
     
356.                         {
     
357.                                 if(a=='n')
     
358.                                 {
     
359.                                 //换行
     
360.                                          pos=RdACAdr();
     
361.                                 if(pos>=0x00&&pos<0x10){ WrComLCD(0xc0);WrStrDat("                ");WrComLCD(0xc0);}//读当前坐标，如果第1行写完换行到第2行        
     
362.                                         else if(pos>=0x40&&pos<0x50) { WrComLCD(0x80);WrStrDat("                ");WrComLCD(0x80);}//读当前坐标，如果第2行写完换行到第1行        
     
363.                                 }
     
364.                                 else if(a=='c')
     
365.                                 {
     
366.                                 WrComLCD(0x01);
     
367.                                 WrComLCD(0x80);
     
368.                                 }
     
369.                                 else if(a=='d')
     
370.                                 {
     
371.                                         //删除
     
372.                                         WrComLCD(0x10);
     
373.                                         WrDatLCD(' ');
     
374.                                         WrComLCD(0x10);
     
375.                                 }
     
376.                                 else if(a=='m')
     
377.                                 {        //ET0=1;
     
378.                                         PlayMusic2();
     
379.                                        
     
380.                                         //if(play)
     
381.                                         //Alarm(5);
     
382.                                 }                  
     
383.                                 else
     
384.                                 {
     
385.                                     WrDatLCD(a);
     
386.                                            //WrComLCD(0x80);
     
387.                                            pos=RdACAdr();
     
388.                                 if(pos==0x10) WrComLCD(0xc0);//读当前坐标，如果第1行写完换行到第2行        
     
389.                                         if(pos==0x50) WrComLCD(0x80);//读当前坐标，如果第2行写完换行到第1行        
     
390.                                 }
     
391.                                 
     
392.                         }
     
393.        }
     
394.          
     
395.   }
     
396. }
     
397. void T0_int() interrupt 1
     
398. {
     
399. BEEP=!BEEP;
     
400. TH0=T[m][0]; TL0=T[m][1];
     
401. }  
     

复制代码

所有资料51hei提供下载:
PC机控制单片机.zip (259.53 KB, 下载次数: 341)

2019-2-3 00:04 上传

点击文件名下载附件

下载下来试试。

谢谢分享   学习一下

功能挺强的，下载试试，

感觉还不错

下载看看

下个参考学习下

功能挺强的，下载参考学习

很好的   

必须好评，认真学习一下

不错，必须认真学习一下

看起来不错，好好学习学习

不错，值得借鉴

talant 发表于 2019-2-4 23:45
下载看看

下载看看

感谢！

请问这个是可以发送命令给单片机吗

正好需要rs232的程序，先下载下来看看。谢谢分享。

功能强大的，下载参考学习一下

感谢，值得参考

学习一下

能否介绍详细一些，让大家愉快学习，学有所获。

谢谢！学习一下

谢谢分享

学习学习。

功能挺强的，谢谢！学习一下

谢谢分享♥

谢谢分享   学习一下

不错 挺好

可以下载
试一下

这真的是非常优秀的资料

正好需要这种资料，谢谢分享

下选择了学习一下

学习一下

下载试试

正好需要这种资料，谢谢分享

正好需要rs232的程序，先下载下来看看。谢谢分享

不错，值得借鉴

请问这个是可以发送命令给单片机吗
正好需要rs232的程序，先下载下来看看。谢谢分享

谢谢分享，想下载学习学习

Great job, thanks for your sharing.