单片机串口收发数据_直接用串口线接收单片机串口引脚的数据出现乱码 - CSDN
  • 单片机串口接收多字节数据

    万次阅读 2017-07-14 19:18:00
    各位大侠看一下,我下面的程序为什么不能接收两个字节的数据呢? #include #define uchar unsigned char #define uint unsigned int void rs232_init(); uchar flag,i,g,d; uchar code table

    http://bbs.elecfans.com/jishu_409918_1_1.html

    各位大侠看一下,我下面的程序为什么不能接收两个字节的数据呢?
    #include<reg51.h>
    #define uchar unsigned char
    #define uint unsigned int
    void rs232_init();
    uchar flag,i,g,d;
    uchar code table[]="I get ";
    //sbit led=P1^0;
    main()
    {
            rs232_init();
            while(1)
            {
                    if(flag==1)
                    {
                            ES=0;
                            for(i=0;i<6;i++)
                            {
                                    SBUF=table[i];
                                    while(!TI);
                                    TI=0;
                            }
                            SBUF=g;
                            while(!TI);
                            TI=0;
                            SBUF=d;
                            while(!TI);
                            TI=0;
                            ES=1;
                            flag=0;
                    }                
            }
    }
    void rs232_init()
    {
            TMOD=0x20;
            TH1=0xfd;
            TL1=0xfd;
            TR1=1;
            REN=1;
            SM0=0;
            SM1=1;
            EA=1;
            ES=1;        
    }
    void ser()interrupt 4
    {
            RI=0;
            g=SBUF;
            d=SBUF;
            flag=1;
    }

    我用串口调试助手调试时,上位机给单片机发送两个字节的数据,例如发送ck两个字母时,只接收到cc两个字母呢?


    //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    首先数据发送是一位一位发送的,串口接收也是一位一位接收的,当接收8位数据后,申请中断。

    你的程序中,程序进入中断后,你用了g=SBUF,d=SBUF,程序之所以进入中断是因为串口接收到了八位数据,是八位数据,不是十六位数据,也就是你发送的字母ck中的c,k还没有发送完呢,所以g和d都被赋值了c,打印结果当然是cc了。

    你要了解串口是接收八位数据后申请中断,你必须在下一个八位数据接收完(下一次中断到来前)以前取走这个数据,不然这个数据将会丢失。

    我给你改 的程序如下,我定义一个宏N,N就是你每次发送的数据个数,然后一个数组,数组有N个元素,用于存储串口接受的数据。

    当串口有中断时,我立即把这个数据存储到数组中,同时将数组指针指向下一位,然后当下一个中断来时重复上面步骤,直到接收数据个数到达N。

    这里中断中程序不能太长,如果程序很长,我本次数据还没存储好,下一个数据已经到了,会丢失数据。

    1. #include<reg51.h>
    2. #define uchar unsigned char
    3. #define uint unsigned int
    4. #define N 2                                                        //可一次接收数据量
    5. void rs232_init();
    6. uchar flag,i;                                                       //删除无用变量                           
    7. uchar code table[]="I get ";
    8. uchar table1[N];                                              //接收缓存数组
    9. uchar j=0;                                                             //接收计数器
    10. //sbit led=P1^0;
    11. main()
    12. {
    13.          rs232_init();
    14.          while(1)
    15.          {
    16.                  if(flag==1)
    17.                  {
    18.                          ES=0;
    19.                          for(i=0;i<6;i++)
    20.                          {
    21.                                  SBUF=table[i];
    22.                                  while(!TI);
    23.                                  TI=0;
    24.                          }
    25.                          for(j=0;j<N;j++)                        //发送接收数组
    26.                                                  {
    27.                                                          SBUF=table1[j];
    28.                                  while(!TI);
    29.                                  TI=0;
    30.                                                 }
    31.                          j=0;                                           //清零接收计数器
    32.                          ES=1;
    33.                          flag=0;
    34.                  }                
    35.          }
    36. }
    37. void rs232_init()
    38. {
    39.          TMOD=0x20;
    40.          TH1=0xfd;
    41.          TL1=0xfd;
    42.          TR1=1;
    43.          SM0=0;
    44.          SM1=1;
    45.                  REN=1;                                                        //先设定号工作方式,在打开允许接收
    46.          EA=1;
    47.          ES=1;        
    48. }
    49. void ser()interrupt 4
    50. {                 
    51.                 RI=0;
    52.                 table1[j++]=SBUF;                                //存数据到接收缓存
    53.                 if(j==N)                                                //数组满时,允许发送
    54.                 flag=1;
    55. }
    复制代码


    受此贴启发,Starsky项目中,串口中断接收更改如下成功接收多字节:

    /*    串口接收数据中断服务函数    */
    #pragma vector = 0x14              //设置串口接收中断向量号 = 0X14 = 20
    __interrupt void UART1_RX_RXNE(void)
    {          
      static int cnt=0;


      UART1_SR_RXNE = 1;    //清除中断标志
      
      if(cnt == (COMBUFNUM-1))  //receive data done
      {    
        bufRec[cnt]= UART1_DR;  //last byte
        recCmd = bufRec[1];
        dutyPwm = (int) bufRec[2];
        cnt =0;
      }
      else{
        bufRec[cnt]= UART1_DR;
        cnt++;
      }
    }

    其中bufRec为接收buffer;

    UART1_DR为STM8S003F6 UART接收数据寄存器。



    展开全文
  • 基于51 单片机串口收发数据

    万次阅读 热门讨论 2018-10-23 20:43:00
    在进行串口的收发数据过程中一定要注意波特率的问题。 大多数51单片机用的都是11m晶振而只有少部分用的是奇葩的12m(楼主的就是),在12m晶振进行串口通信时切忌要将波特率...在用串口助手进行串口收发数据时都会触...

    在进行串口的收发数据过程中一定要注意波特率的问题。

    大多数51单片机用的都是11m晶振而只有少部分用的是奇葩的12m(楼主的就是),在12m晶振进行串口通信时切忌要将波特率设置为4800以下,应为12m晶振的波特率在9600以上误差很大容易丢失数据,动手能力强的可以折腾一下用定时器输出9600波特率。

    至于,串口中断以及波特率的设置可以参考网上例子忒多。

    在用串口助手进行串口收发数据时都会触发串口中断并且在发送数据时只能够一位一位的发送,也就是SBUF=10是不行的智能一位一位发送也就是每次只能发送(0-9或者一个字符)并且串口调试助手接收到的数据是asii码要进行下转换,发送也要进行一下转换。这只是针对串口调试助手

    话不多说直接上代码:

     

    由于代码不方便公布所以只能上图片需要的可以私聊博主

     

     转载请标明原贴出处:https://blog.csdn.net/zj490044512

    展开全文
  • 51系列单片机 单片机串口通信接收发送数据程序
  • 单片机串口收发字符数据的类型

    千次阅读 2018-06-09 17:50:38
    今天在用51单片机进行串口收发数据的时候遇到了这样一个问题,上位机给单片机的字符数据是什么类型的,单片机又是怎样存储的?串口中断如下/* UART中断服务函数 */ void InterruptUART() interrupt 4 { if (RI) //...

      今天在用51单片机进行串口收发数据的时候遇到了这样一个问题,上位机给单片机的字符数据是什么类型的,单片机又是怎样存储的?

    串口中断如下

    /* UART中断服务函数 */
    void InterruptUART() interrupt 4
    {
    	if (RI)  //接收到字节
    	{
      	   RI = 0;  //手动清零接收中断标志位
      	   table1[j] = SBUF;  //接收到的数据保存到接收字节变量中
    	   if(table1[0] == 0x0D)
      	       f = 1;
           else 
    		   f =0;
           table1[j] = table1[j]&0x0f;
    	   j++;
    	   flag1 = 1;	
    								
        }
        else  //字节发送完毕
        {
           TI = 0;  //手动清零发送中断标志位
           FS_Bit = 0;
        }
    } 

    问题1:

    单片机将接收到的数据放到SBUF中存储,但这个SBUF只能存储8位数据(1个字节),那么就有了第一个问题:如何接收多位数据?

    答:我是定义了一个table1[]数组,将每个接收到的8位数据放到数组里,然后指针自加1,在另一个中断里判断一共接收到了几个数据(j起自加和计数作用),然后延时1s后,将接收到的每个元素输出(1s足够接收到几个字节的数据了)。

    问题2

    那么table1[]里的数据是什么类型的呢?

    答:它是一个二进制数据,是接收到字节的二进制ascii码,如果再用SBUF发送出去,也是发送的二进制数据,不过上位机接收的时候自动转换成字节了。

    问题三

    如何将接收到的二进制ascii码进行十进制运算呢?

    答:其实二进制与十进制计算方法、过程、结果都一样。但是用字符类型传给单片机的数字的二进制与对应十进制的二进制是不一样的,比如说上位机字符格式发送过来一个数据2,单片机接收到的二进制ascii码0011 0010,而十进制的2对应的二进制是 0000 0010,所以不能直接对字符格式的数字进行运算,所以我用了

    table1[j] = table1[j]&0x0f;
    将高四位都清0,与十进制的2对应起来,然后就可以进行运算了。(但是上位机发送一个大写字母R与字符2是一样的,因为R的ascii码是 0000 0010)


    展开全文
  • 之前写了篇关于ESP8266使用AT指令进行互相通讯的实验,在写STM32串口接发数据的程序中,觉得有必要将之前学的有关于串口方面的使用经历加以总结。 串口发送数据: 1. 串口发送数据最直接的方式就是标准调用...

    之前写了篇关于ESP8266使用AT指令进行互相通讯的实验,在写STM32串口接发数据的程序中,觉得有必要将之前学的有关于串口方面的使用经历加以总结。

     

    串口发送数据:

           1. 串口发送数据最直接的方式就是标准调用库函数 。 void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);
    第一个参数是发送的串口号,第二个参数是要发送的数据了。但是用过的朋友应该觉得不好用,一次只能发送单个字符,所以我们有必要根据这个函数加以扩展。

    void Send_data(u8 *s)
    {
        while(*s!='\0')
        { 
            while(USART_GetFlagStatus(USART1,USART_FLAG_TC )==RESET);    
            USART_SendData(USART1,*s);
            s++;
        }
    }
            以上程序的形参就是我们调用该函数时要发送的字符串,这里通过循环调用USART_SendData来一 一发送我们的字符串。

    while(USART_GetFlagStatus(USART1,USART_FLAG_TC )==RESET);
    <span style="color:#333333">        这句话有必要加,他是用于检查串口是否发送完成的标志,如果不加这句话会发生数据丢失的情况。
            这个函数只能用于串口1发送。有些时候根据需要,要用到多个串口发送那么就还需要改进这个程序。如下:</span>
    void Send_data(USART_TypeDef * USARTx,u8 *s)
    {
        while(*s!='\0')
        { 
            while(USART_GetFlagStatus(USARTx,USART_FLAG_TC )==RESET);    
            USART_SendData(USARTx,*s);
            s++;
        }
    }
            这样就可实现任意的串口发送。但有一点,我在使用实时操作系统的时候(如UCOS,Freertos等),需考虑函数重入的问题。当然也可以简单的实现把该函数复制一下,然后修改串口号也可以避免该问题。然而这个函数不能像printf那样传递多个参数,所以还可以在改进,最终程序如下

    void USART_printf ( USART_TypeDef * USARTx, char * Data, ... )
    {
        const char *s;
        int d;   
        char buf[16];
        
        va_list ap;
        va_start(ap, Data);
     
        while ( * Data != 0 )     // 判断是否到达字符串结束符
        {                                          
            if ( * Data == 0x5c )  //'\'
            {                                      
                switch ( *++Data )
                {
                    case 'r':                                      //回车符
                    USART_SendData(USARTx, 0x0d);
                    Data ++;
                    break;
     
                    case 'n':                                      //换行符
                    USART_SendData(USARTx, 0x0a);    
                    Data ++;
                    break;
     
                    default:
                    Data ++;
                    break;
                }             
            }
            
            else if ( * Data == '%')
            {                                      //
                switch ( *++Data )
                {                
                    case 's':                                          //字符串
                    s = va_arg(ap, const char *);
                    
                    for ( ; *s; s++) 
                    {
                        USART_SendData(USARTx,*s);
                        while( USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET );
                    }
                    
                    Data++;
                    
                    break;
     
                    case 'd':            
                        //十进制
                    d = va_arg(ap, int);
                    
                    itoa(d, buf, 10);
                    
                    for (s = buf; *s; s++) 
                    {
                        USART_SendData(USARTx,*s);
                        while( USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET );
                    }
                    
                    Data++;
                    
                    break;
                    
                    default:
                    Data++;
                    
                    break;
                    
                }         
            }
            
            else USART_SendData(USARTx, *Data++);
            
            while ( USART_GetFlagStatus ( USARTx, USART_FLAG_TXE ) == RESET );
            
        }
    }
            该函数就可以像printf使用可变参数,方便很多。通过观察函数但这个函数只支持了%d,%s的参数,想要支持更多,可以仿照printf的函数写法加以补充。
            2. 直接使用printf函数。        很多朋友都知道想要STM32要直接使用printf不行的。需要加上以下的说明

            最后记得还要修改一下选中Code Generation——选中Use MicroLI

     

    串口接收数据:       

            串口接收最后应有一定的协议,如发送一帧数据应该有头标志或尾标志,也可两个标志都有。这样在处理数据时既能能保证数据的正确接收,也有利于接收完后我们处理数据。串口的配置在这里就不在赘述,这里我以串口2接收中断服务程序函数且接收的数据包含头尾标识为例,先来看我经常使用的接收程序格式。

    #define Max_BUFF_Len 18
    unsigned char Uart2_Buffer[Max_BUFF_Len];
    unsigned int Uart2_Rx=0;
    void USART2_IRQHandler() 
    {
        if(USART_GetITStatus(USART2,USART_IT_RXNE) != RESET) //中断产生 
        {
            USART_ClearITPendingBit(USART2,USART_IT_RXNE); //清除中断标志
                 
            Uart2_Buffer[Uart2_Rx] = USART_ReceiveData(USART2);     //接收串口1数据到buff缓冲区
            Uart2_Rx++; 
                  
            if(Uart2_Buffer[Uart2_Rx-1] == 0x0a || Uart2_Rx == Max_BUFF_Len)    //如果接收到尾标识是换行符(或者等于最大接受数就清空重新接收)
            {
                if(Uart2_Buffer[0] == '+')                      //检测到头标识是我们需要的 
                {
                    printf("%s\r\n",Uart2_Buffer);        //这里我做打印数据处理
                    Uart2_Rx=0;                                   
                } 
                else
                {
                    Uart2_Rx=0;                                   //不是我们需要的数据或者达到最大接收数则开始重新接收
                }
            }
        }
    }
     


            数据的头标识为“\n”既换行符,尾标识为“+”。该函数将串口接收的数据存放在USART_Buffer数组中,然后先判断当前字符是不是尾标识,如果是说明接收完毕,然后再来判断头标识是不是“+”号,如果还是那么就是我们想要的数据,接下来就可以进行相应数据的处理了。但如果不是那么就让Usart2_Rx=0重新接收数据。这样做的有以下好处:

            1.可以接受不定长度的数据,最大接收长度可以通过Max_BUFF_Len来更改

            2.可以接受指定的数据

            3.防止接收的数据使数组越界
            这里我的把接受正确数据直接打印出来,也可以通过设置标识位,然后在主函数里面轮询再操作。

            

            以上的接收形式,是中断一次就接收一个字符,这在UCOS等实时内核系统中频繁的中断,非常消耗CPU资源,在有些时候我们需要接收大量数据时且波特率很高的情况下,长时间中断会带来一些额外的问题。所以以DMA形式配合串口的IDLE(空闲中断)来接受数据将会大大的提高CPU的利用率,减少系统资源的消耗。首先还是先看代码。

    #define DMA_USART1_RECEIVE_LEN 18
    void USART1_IRQHandler(void)                                 
    {     
        u32 temp = 0;  
        uint16_t i = 0;  
          
        if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)  
        {  
            USART1->SR;  
            USART1->DR; //这里我们通过先读SR(状态寄存器)和DR(数据寄存器)来清USART_IT_IDLE标志             
            DMA_Cmd(DMA1_Channel5,DISABLE);  
            temp = DMA_USART1_RECEIVE_LEN - DMA_GetCurrDataCounter(DMA1_Channel5); //接收的字符串长度=设置的接收长度-剩余DMA缓存大小 
            for (i = 0;i < temp;i++)  
            {  
                Uart2_Buffer[i] = USART1_RECEIVE_DMABuffer[i];  
                    
            }  
            //设置传输数据长度  
            DMA_SetCurrDataCounter(DMA1_Channel5,DMA_USART1_RECEIVE_LEN);  
            //打开DMA  
            DMA_Cmd(DMA1_Channel5,ENABLE);  
        }        

            之前的串口中断是一个一个字符的接收,现在改为串口空闲中断,就是一帧数据过来才中断进入一次。而且接收的数据时候是DMA来搬运到我们指定的缓冲区(程序中是USART1_RECEIVE_DMABuffer数组),是不占用CPU时间的。具体什么是IDLE中断和DMA需要朋友们先行了解。

        参考链接:

        https://blog.csdn.net/jdh99/article/details/8444474

        https://blog.csdn.net/phker/article/details/51925668   

       最后在讲下DMA的发送

    #define DMA_USART1_SEND_LEN 64
    void DMA_SEND_EN(void)
    {
        DMA_Cmd(DMA1_Channel4, DISABLE);      
        DMA_SetCurrDataCounter(DMA1_Channel4,DMA_USART1_SEND_LEN);   
        DMA_Cmd(DMA1_Channel4, ENABLE);
    }
            这里需要注意下DMA_Cmd(DMA1_Channel4,DISABLE)函数需要在设置传输大小之前调用一下,否则不会重新启动DMA发送。

        有了以上的接收方式,对一般的串口数据处理是没有问题的了。下面再讲一下,在ucosiii中我使用信号量+消息队列+储存管理的形式来处理我们的串口数据。先来说一下这种方式对比其他方式的一些优缺点。一般对串口的处理形式是"生产者"和"消费者"的模式,即本次接收的数据要马上处理,否则当数据大量涌进的时候,就来不及"消费"掉生产者(串口接收中断)的数据,那么就会丢失本次的数据处理。所以使用队列就能够很方便的解决这个问题。

        在下面的程序中,对数据的处理是先接受,在处理,如果在处理的过程中,有串口中断接受数据,那么就把它依次放在队列中,队列的特征是先进先出,在串口中就是先处理先接受的数据,所以根据生产和消费的速度,定义不同大小的消息队列缓冲区就可以了。缺点就是太占用系统资源,一般51单片机是没可能了。下面是从我做的项目中截取过来的程序

    OS_MSG_SIZE  Usart1_Rx_cnt;          //字节大小计数值
    unsigned char Usart1_data;           //每次中断接收的数据
    unsigned char* Usart1_Rx_Ptr;        //储存管理分配内存的首地址的指针
    unsigned char* Usart1_Rx_Ptr1;       //储存首地址的指针
    void USART1_IRQHandler() 
    {
        OS_ERR err;
        OSIntEnter();
        
      if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) != RESET) //中断产生 
      {      
        USART_ClearFlag(USART1, USART_FLAG_RXNE);     //清除中断标志
            
        Usart1_data = USART_ReceiveData(USART1);     //接收串口1数据到buff缓冲区
            
            if(Usart1_data =='+')                     //接收到数据头标识
            {
    //            OSSemPend((OS_SEM*        )&SEM_IAR_UART,  //这里请求信号量是为了保证分配的存储区,但一般来说不允许
    //            (OS_TICK        )0,                   //在终端服务函数中调用信号量请求但因为
    //            (OS_OPT            )OS_OPT_PEND_NON_BLOCKING,//我OPT参数设置为非阻塞,所以可以这么写
    //            (CPU_TS*        )0,
    //            (OS_ERR*        )&err); 
    //            if(err==OS_ERR_PEND_WOULD_BLOCK)        //检测到当前信号量不可用
    //            {
    //                 printf("error");
    //            }                
                Usart1_Rx_Ptr=(unsigned char*) OSMemGet((OS_MEM*)&UART1_MemPool,&err);//分配存储区
                Usart1_Rx_Ptr1=Usart1_Rx_Ptr;                //储存存储区的首地址
            }
            if(Usart1_data == 0x0a )                   //接收到尾标志
            {                    
                *Usart1_Rx_Ptr++=Usart1_data;
                Usart1_Rx_cnt++;                            //字节大小增加
                OSTaskQPost((OS_TCB    *  )&Task1_TaskTCB,
                                       (void      *  )Usart1_Rx_Ptr1,    //发送存储区首地址到消息队列
                                       (OS_MSG_SIZE  )Usart1_Rx_cnt,
                                       (OS_OPT       )OS_OPT_POST_FIFO,  //先进先出,也可设置为后进先出,再有地方很有用
                                       (OS_ERR    *  )&err);
                                        
                Usart1_Rx_Ptr=NULL;          //将指针指向为空,防止修改
                Usart1_Rx_cnt=0;         //字节大小计数清零
            }
            else
            {
                *Usart1_Rx_Ptr=Usart1_data; //储存接收到的数据
                Usart1_Rx_Ptr++;
                Usart1_Rx_cnt++;
            }    
        }             
        OSIntExit();
    }
           上面被注释掉的代码为我是为了防止当分区中没有空闲的存储块时加入信号量,打印出报警信息。当然我们也可以将存储块直接设置大一点,但是还是无法避免当没有可有存储块时会程序会崩溃现象。希望懂的朋友能告知下~。

            下面是串口数据处理任务,这里删去了其他代码,只把他打印出来了而已。

    void task1_task(void *p_arg)
    {
        OS_ERR err;
        OS_MSG_SIZE Usart1_Data_size;
        u8 *p;
        
        while(1)
        {
            p=(u8*)OSTaskQPend((OS_TICK        )0, //请求消息队列,获得储存区首地址
                (OS_OPT                )OS_OPT_PEND_BLOCKING,
                (OS_MSG_SIZE*    )&Usart1_Data_size,
                (CPU_TS*            )0,
                (OS_ERR*            )&err);
     
            printf("%s\r\n",p);        //打印数据
     
            delay_ms(100);
            OSMemPut((OS_MEM*    )&UART1_MemPool,    //释放储存区
            (void*            )p,
            (OS_ERR*        )&err);
                             
            OSSemPost((OS_SEM*    )&SEM_IAR_UART,    //释放信号量
            (OS_OPT     )OS_OPT_POST_NO_SCHED,
            (OS_ERR*    )&err);
                             
            OSTimeDlyHMSM(0,0,1,500,OS_OPT_TIME_PERIODIC,&err);                 
        }
    }
     
    --------------------- 
    作者:可以吃的鱼 
    来源:CSDN 
    原文:https://blog.csdn.net/qq_35281599/article/details/80299770 
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • 单片机串口接收的几种常用的数据处理方法 一、为什么串口接收数据需要处理 我们在做项目的时候经常会用到串口,当我们用串口和别的设备通讯的时候就需要严格遵循通讯协议,然而,仅仅是遵循通讯协议是不够的,因为...
  • 单片机串口收发数据

    千次阅读 2015-06-29 14:11:49
    在中断函数中,如果接收数据则RI由硬件置1,这时候把SBUF缓冲区的数据赋值给Buffer,并将RI置0,等待下次接收。同时,将接收到的数据再放入缓冲区,发送给PC机。当发送完毕的时候TI会被硬件置1,这时候需要将TI置0...
  • 一个简易的51单片机串口接收和发送程序

    万次阅读 多人点赞 2017-08-17 08:56:24
    程序功能:接收上位机发过来的一个字符串,然后把该字符串发送给上位机, 字符串必须以!结尾 **********************/ #include #define uchar unsigned char #define uint unsigned int sbit LED = P2^7; uchar ...
  • 两个单片机串口收发数据

    千次阅读 2019-07-11 08:57:33
    使用两个单片机开发版,串口3.0与3.1交叉互接,两个开发版分别烧写串口接收串口发送的单片机程序观察P0端口输出值的变化 ============接收串口单片机程序=========== #include <reg52.h> #define uchar...
  • STC单片机串口收发学习总结

    千次阅读 2018-11-19 17:16:23
    STC单片机串口收发学习总结1字符串输出到串口2LED闪烁3LED流水灯4定时器5中断6定时与中断应用示例7数码管8串口9RS232接口 1字符串输出到串口 //////////////////////////////////////////////////////// //单片机...
  • 51单片机串口通信的帧数据接收

    千次阅读 2015-12-13 10:25:29
    首先定义一个数据帧格式,Header :{ 0xAA 0x55} type:{ 0x01 | 0x02 | 0x03 } length:{ N } body :{____n个字节的数据___ } 数据的格式就是上面的定义 Header 为帧头 标记一个数据帧的开始,type 为类型 用来...
  • STC单片机串口接收发送程序

    热门讨论 2020-07-29 14:18:53
    基于STC单片机串口接收发送程序/**************************************************************************** * 程序名称:STC89C52RC单片机串口发送接收程序 * 实验条件:11.0592的晶振频率
  • 通过数码管将51单片机从电脑上接收来的数据进行转换并显示出来!
  • 单片机串口发送和接受程序

    万次阅读 2018-11-03 18:44:51
    /******************************串口1的波特率********************************/ //T1作波特率发生器 //在波特率加倍情况下  #define BAUD_57600 256 - (OSC_FREQ/192L)/57600L // 254 FF #define BAUD_28800 256...
  • 用汇编语言编写的51单片机串口和模拟串口收发多个数据程序。单片机自带串口作为串口1,与上位机通讯。用外部中断模拟串口作为串口2,与现场仪表通讯。从单片机初始化到各个单元子程序均有。方便开发者使用。改程序...
  • 自己新学,弄了2天,才成功,可以收发字符或字符串,并且能够判断输入的数据,方便做下一步的操作!可以上位机发送字符串,测试连接(其他的我还没改),也可以自己改一下就可以,主要为了测试上位机labview和单片机...
  • 51单片机串口通信的发送与接收(转)

    万次阅读 多人点赞 2013-02-20 15:01:56
    51单片机串口,是个全双工的串口,发送数据的同时,还可以接收数据。 当串行发送完毕后,将在标志位 TI 置 1,同样,当收到了数据后,也会在 RI 置 1。 无论 RI 或 TI 出现了 1,只要串口中断处于开放状态,...
  • /*******************************************************************************...ReData[]: 里是一个字节类型的数组,这里一次只接收8个字节数据. *********************************************************...
  • 上位机给串口发送数据单片机通过串口接收到的数据以什么结尾@TOC 串口接收数据后对数据最后几位进行判断,总是进不去判断函数是什么原因,串口接收数据后会不会自动加什么标志,求大佬指导? 串口通过中断...
  • 51单片机串口多字节接收
1 2 3 4 5 ... 20
收藏数 13,013
精华内容 5,205
关键字:

单片机串口收发数据