请教串口程序问题

nishiyitouniu

请教串口程序问题 [复制链接]

1. #include
   
2. #define uchar unsigned char
   
3. #define uint unsigned int
   
4. unsigned char flag,a,i;
   
5. uchar code table[]="I get ";
   
6. void init()
   
7. {
   
8.         TMOD=0x20;     //确定T1的工作方式
   
9.         TH1=0xfd;                //计算T1的初值，装载TH1，TL1
   
10.         TL1=0xfd;
    
11.         TR1=1;                        //启动T1
    
12.         REN=1;                        //确定串行口的工作方式
    
13.         SM0=0;
    
14.         SM1=1;
    
15.         EA=1;
    
16.         ES=1;
    
17. }
    
18. 
    
19. void main()
    
20. {
    
21.         init();
    
22.         while(1)
    
23.         {
    
24.                 if(flag==1)
    
25.                 {
    
26.                         ES=0;                        //关闭串口中断，否则发送数据时同样申请中断，程序进入死循环
    
27.                         for(i=0;i<6;i++)
    
28.                         {
    
29.                                 SBUF=table[i];
    
30.                                 while(!TI);
    
31.                                 TI=0;
    
32.                         }
    
33.                         SBUF=a;
    
34.                         while(!TI);                //发送完毕后，TI会被硬件置1，跳出循环，说明数据发送完毕
    
35.                         TI=0;                        //
    
36.                         ES=1;
    
37.                         flag=0;
    
38.                 }
    
39.         }
    
40. }
    
41. 
    
42. void ser() interrupt 4
    
43. {
    
44.         RI=0;                                //接受数据完成后，内部硬件置1，进入串口中断函数后
    
45.         a=SBUF;                                //必须有软件清0
    
46.         flag=1;                                //将flag置1，方便在主程序中检测
    
47. }

复制代码

这个程序的功能是在上位机上用串口调试助手发送一个字符X,单片机收到后返回给上位机"I get X"
请问如何修改可以在上位机上用串口调试助手发送两个个字符X,单片机收到后返回给上位机"I get XX"

我弄了很久也没有弄出来了，麻烦各位了

懒骨头

我觉得这个你的定义好通信协议，比如上位机发送一个X给单片机，不能是单独的一个X，而是一个完整的命令桢，打个比方，你以：#作为起始符 %作为结束符号，那么命令桢就是：#X% 不过单片机通信你的把它们转换为ASC码：23 58 25；单片机再收到了这个命令桢后，就可以分析出的出X，从而返回给上位机：I Get X

同样的道理，当上位机发送：#XX%给单片机，单片机分析得出：XX，返回给上位机：I Get XX

manbuzhe

问题的关键在于：介于通信起始符和结束符之间的内容！
通信协议对于串口通信很重要。

hanxm

这就是普通51单片机的串口通信

ronc

for(i=0;i<6;i++) 改成i<7发两个X就行了

aiwenwen

引用 4 楼 qzf368 的回复:

for(i=0;i<6;i++) 改成i<7发两个X就行了

不可以的

mary1127

先定义一个数组，然后在中断程序里每接收一个字符就赋给这个数组。发送的时候循环取出发给上位机就行了。

qiuling

粗略的看了下发送接收的代码，应该没问题的，初始化串口和配置方式代码就不知道了，因为很久没搞51了，

想问一下，具体的现象是什么？单片机什么都没接收到？还是单片机接收到了X，反馈给PC的时候，PC没收到？或者收到错误信息？

我觉得会不会是你PC串口配置和51的串口配置不对应，比如波特率，停止位，校验位等，，，，，，

1291257128

试试看。
...//你原来的程序

uchar a[2]; //定义变量中把a去了，加一个数组a[2]。如果是更长的字符，数组长度要相应改变

...//你原来的程序

void main()
{
    init();
    while(1)
    {
        if(flag==1)
        {
            ES=0;            //关闭串口中断，否则发送数据时同样申请中断，程序进入死循环
            for(i=0;i<6;i++)
            {
                SBUF=table;
                while(!TI);
                TI=0;
            }
          for(i=0;i<2;i++) //发送数组内容
            {
                SBUF=a;
                while(!TI);
                TI=0;
            }
            ES=1;
            flag=0;
        }
    }
}

void ser() interrupt 4
{                    
     uchar j;
     for(j=0; j<2; i++) //接收两个字符
       {
         while(!RI);
         RI=0;
         a=SBUF;
        }
    flag=1;                //将flag置1，方便在主程序中检测
}

duibuqi

1. 
   
2. char revbuff[1000000]
   
3. void ser() interrupt 4
   
4. {
   
5.     static int len=0;
   
6.     RI=0;                //接受数据完成后，内部硬件置1，进入串口中断函数后
   
7.      unsigned char a=SBUFF;
   
8.     if(a=='\r'||a=='\n')
   
9.     {flag=1;revbuff[len]=0;}
   
10.     else
    
11.         revbuff[len++]=a;                           
    
12. }
    
13. 
    
14. 在main内部
    
15. void main()
    
16. {
    
17.   ...
    
18.   if(flag)
    
19.   {
    
20.     flag=0;
    
21.     strcpy(buff+6,revbuff);
    
22.     uartouts(buff);
    
23.   }
    
24. 
    
25.   ...
    
26. }
    

复制代码

力量

引用 8 楼 xmjulytiger 的回复:

试试看。
...//你原来的程序

uchar a[2]; //定义变量中把a去了，加一个数组a[2]。如果是更长的字符，数组长度要相应改变

...//你原来的程序

void main()
{
    init();
    while(1)
    {
        if(flag==1)
        {
            ES=0;        ……

我之前试的和你的差不多，就是中断函数里少了一句：while(!RI);

现在接受字符的个数是可以达到了，但是有BUG
比如，设置发送4个字符
                发送1234，接受到的是4123（数据大小已设置好）
                发送12345，接收到的是4512（当然越界了，也许没什么课研究性，仅供参考）
      设置发送5个字符
                 发送12345，收到51234
                 发送123456，收到56123

qinxuewei101

我之前试的和你的差不多，就……
[/quote]

如果要发送多个数，试着加一个包头标识，比如0xFF（以十六进制数为例）。 要发12345，发送时就是FF 1 2 3 4 5。中断程序做小小改动，主程序中发送数组从a[1]开始发。
[code]
void ser() interrupt 4
{   
    uchar j;
    for(j=0; j<6; i++) //接收6个字符
    {  
        while(!RI);
        RI=0;
        a[j]=SBUF;
    }
    if(a[0]==0xff)
    {
        flag=1;
    }                //将flag置1，方便在主程序中检测
}

自下而上

楼主用个数组不就可以了么？随便你收几个字符。

shc217

回LS的，我用的就是数组

1. #include
   
2. #include
   
3. #define uchar unsigned char
   
4. #define uint unsigned int
   
5. unsigned char flag,a,i;
   
6. uchar b[4];
   
7. uchar code table[]="I get ";
   
8. void init()
   
9. {
   
10.         TMOD=0x20;     //确定T1的工作方式
    
11.         TH1=0xfd;                //计算T1的初值，装载TH1，TL1
    
12.         TL1=0xfd;
    
13.         TR1=1;                        //启动T1
    
14.         REN=1;                        //确定串行口的工作方式
    
15.         SM0=0;
    
16.         SM1=1;
    
17.         EA=1;
    
18.         ES=1;
    
19. }
    
20. 
    
21. void main()
    
22. {
    
23.         init();
    
24.         while(1)
    
25.         {
    
26.                 if(flag==1)
    
27.                 {
    
28.                         ES=0;                        //关闭串口中断，否则发送数据时同样申请中断，程序进入死循环
    
29. //                        for(i=0;i<6;i++)
    
30. //                        {
    
31. ///                                SBUF=table[i];
    
32. //                                while(!TI);
    
33. //                                TI=0;
    
34. //                        }
    
35.                         for(i=0;i<4;i++)
    
36.                         {
    
37.                         SBUF=b[i];
    
38.                         while(!TI);                //发送完毕后，TI会被硬件置1，跳出循环，说明数据发送完毕
    
39.                         TI=0;
    
40.                         }//
    
41.                         ES=1;
    
42.                         flag=0;
    
43.                 }
    
44.         }
    
45. }
    
46. 
    
47. void ser() interrupt 4
    
48. {
    
49.         uchar j;
    
50.         for(j=0;j<4;j++)
    
51.         {
    
52.                 while(!RI);
    
53.                 RI=0;
    
54.                 b[j]=SBUF;
    
55.                                                 //接受数据完成后，内部硬件置1，进入串口中断函数后
    
56.                
    
57.         }                                //必须有软件清0
    
58.         flag=1;                                //将flag置1，方便在主程序中检测
    
59. }

复制代码

qazwsx123

void Com_Int(void) interrupt 4
{

         if(RI)
         {  
       RI = 0;
           stringaz[iaz++]=SBUF;
            if(SBUF == '*')
              {
               stringaz[iaz]='\0';
               iaz=0;
               record=1;
           }
          
     }

一个字符好解决,多个字符就是字符串了,字符串接受最好带个结束标志,不然就有问题,这是我的一个中断函数,参考下!

sanny777

1. #ifndef _SERIAL_CONFIG_H_
   
2. #define _SERIAL_CONFIG_H_
   
3. #include "const.h"
   
4. #include "oscfrequencydef.h"
   
5. 
   
6. #ifndef OSC_FREQUENCY
   
7. #error undefined OSC_FREQUENCY
   
8. #endif
   
9. /***********************************************************************
   
10. 仅限于串口方式1的工作模式，即1位起始位，8位数据位和1位停止位，无校验位
    
11. 波特率不倍增
    
12. ************************************************************************/
    
13. 
    
14. typedef enum tagBAUD
    
15. {
    
16.         b_1200 = 1200,
    
17.         b_2400 = 2400,
    
18.         b_4800 = 4800,
    
19.         b_9600 = 9600,
    
20.         b_14400 = 14400,
    
21.         b_19200 = 19200,
    
22.         b_28800 = 28800,
    
23.         b_38400 = 38400,
    
24.         b_56000 = 56000,
    
25.         b_57600 = 57600,
    
26.        
    
27.         //注意：115200已经超过两个字节的范围
    
28. 
    
29.         INVALID_BAUD,
    
30. 
    
31. }BAUD;
    
32. 
    
33. 
    
34. typedef void (*RECVPROC)(BYTE byte);
    
35. 
    
36. BOOL OpenSerial(BAUD Baud, RECVPROC pRecvFunc);
    
37. void SendData(const BYTE* pData, BYTE nSize);
    
38. void CloseSerial();
    
39. 
    
40. 
    
41. #endif

复制代码

shizibaihe

1. 
   
2. #include "serialconfig.h"
   
3. #include
   
4. #include
   
5. 
   
6. idata RECVPROC g_pfnRecvFunc = NULL;
   
7. 
   
8. 
   
9. BOOL OpenSerial(BAUD Baud, RECVPROC pRecvFunc)
   
10. {
    
11. 
    
12.         idata BYTE LoadValue = 0;
    
13. 
    
14.         if(pRecvFunc == NULL)
    
15.                 return FALSE;
    
16.                
    
17.         g_pfnRecvFunc = pRecvFunc;
    
18. 
    
19.         switch(Baud) //确保输入的波特率是正确的
    
20.         {
    
21. //                case b_1200:
    
22. //                case b_2400:
    
23.                 case b_4800:
    
24.                 case b_9600:
    
25.                 case b_14400:
    
26.                 case b_28800:
    
27.                 case b_19200:
    
28.                 case b_38400:
    
29.                 case b_57600:
    
30.                         break;
    
31. 
    
32.                 default:
    
33.                         return FALSE;
    
34.                         break;
    
35.         }       
    
36. 
    
37. 
    
38. 
    
39.         /*****************************************************************************
    
40.         LoadValue = 256 -        OSC_FREQUENCY * 10^6 / (384 * Baud)
    
41.         因每次运算的结果上限限制，故做了变换
    
42.         ******************************************************************************/       
    
43.         LoadValue = 256 - (BYTE)(1000 * 1.0f * (float)OSC_FREQUENCY / 384 * 1000 * 1.0f / Baud);
    
44. 
    
45.           
    
46. 
    
47. 
    
48.         TMOD |= T1_M1_;        //定时器T1工作方式2
    
49.         TH1 = LoadValue;               
    
50.         TL1 = LoadValue;   //不可TL1 = TH1赋值
    
51.         PCON = 0x00;        //波特率不倍增   
    
52.         SCON = 0x50;        //串行通信方式1,允许接收                  
    
53.         TR1 = 1;                //启动定时器1
    
54. 
    
55. 
    
56. 
    
57.         ES = 1;                        //开串行中断  
    
58.         EA = 1;         //开总中断
    
59. 
    
60.         return TRUE;
    
61. }
    
62. 
    
63. 
    
64. void CloseSerial()
    
65. {
    
66.         TR1 = 0;                //关定时器1
    
67.         ES = 0;                        //关串行中断  
    
68. }
    
69. 
    
70. 
    
71. 
    
72. void SendData(const BYTE* pData, BYTE nSize)
    
73. {
    
74.         BYTE i = 0;
    
75.         ///////////////////////////////////////////////
    
76. 
    
77.         //发送与接收中断不能同时工作，发送时必须关闭接收中断
    
78.         ES = 0;
    
79. //        if(pData == NULL || nSize == 0)         出于效率，不做检查
    
80. //                return FALSE;
    
81. 
    
82.         for(i = 0; i < nSize; i++)
    
83.         {
    
84.                 SBUF = pData[i];
    
85.                 while(!TI);
    
86.                 TI = 0;
    
87.         }
    
88.        
    
89.         ES = 1;       
    
90. 
    
91. 
    
92. }       
    
93. 
    
94. void SerialISR() interrupt SIO_VECTOR
    
95. {
    
96.         RI = 0;
    
97.         (*g_pfnRecvFunc)(SBUF);
    
98. }

复制代码

lincc

谢谢楼上大师级的回复