精华内容
下载资源
问答
  • 自动产生的串口中断接收程序,支持缓冲区,比较经典的
                   
    你的mega128的串口接收程序写的有问题,和什么模块都无关。串口中断是每收到一个字符就会产生一次的,所以你不要看到中断了
    就急着处理,收的东西还没全呢,怎么处理啊,要想办法收全了再处理。建议你看看别人的串口接收中断处理代码。
    最最最简单的办法,做个延时,等所有的字符都收齐了,再处理。或者开缓冲区,根据缓冲区的长度来判断是否都接收完毕。

    下面是用CVAVR自动产生的串口中断接收程序,支持缓冲区,比较经典的:
    #include <mega128.h>

    #define RXB8 1
    #define TXB8 0
    #define UPE 2
    #define OVR 3
    #define FE 4
    #define UDRE 5
    #define RXC 7

    #define FRAMING_ERROR (1<<FE)
    #define PARITY_ERROR (1<<UPE)
    #define DATA_OVERRUN (1<<OVR)
    #define DATA_REGISTER_EMPTY (1<<UDRE)
    #define RX_COMPLETE (1<<RXC)

    // USART0 Receiver buffer
    #define RX_BUFFER_SIZE0 255
    char rx_buffer0[RX_BUFFER_SIZE0];

    #if RX_BUFFER_SIZE0<256
    unsigned char rx_wr_index0,rx_rd_index0,rx_counter0;
    #else
    unsigned int rx_wr_index0,rx_rd_index0,rx_counter0;
    #endif

    // This flag is set on USART0 Receiver buffer overflow
    bit rx_buffer_overflow0;

    // USART0 Receiver interrupt service routine
    interrupt [USART0_RXC] void usart0_rx_isr(void)
    {
    char status,data;
    status=UCSR0A;
    data=UDR0;
    if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
    {
    rx_buffer0[rx_wr_index0]=data;
    if (++rx_wr_index0 == RX_BUFFER_SIZE0) rx_wr_index0=0;
    if (++rx_counter0 == RX_BUFFER_SIZE0)
    {
    rx_counter0=0;
    rx_buffer_overflow0=1;
    };
    };
    }

    #ifndef _DEBUG_TERMINAL_IO_
    // Get a character from the USART0 Receiver buffer
    #define _ALTERNATE_GETCHAR_
    #pragma used+
    char getchar(void)
    {
    char data;
    while (rx_counter0==0);
    data=rx_buffer0[rx_rd_index0];
    if (++rx_rd_index0 == RX_BUFFER_SIZE0) rx_rd_index0=0;
    #asm("cli")
    --rx_counter0;
    #asm("sei")
    return data;
    }
    #pragma used-
    #endif

    // USART0 Transmitter buffer
    #define TX_BUFFER_SIZE0 8
    char tx_buffer0[TX_BUFFER_SIZE0];

    #if TX_BUFFER_SIZE0<256
    unsigned char tx_wr_index0,tx_rd_index0,tx_counter0;
    #else
    unsigned int tx_wr_index0,tx_rd_index0,tx_counter0;
    #endif

    // USART0 Transmitter interrupt service routine
    interrupt [USART0_TXC] void usart0_tx_isr(void)
    {
    if (tx_counter0)
    {
    --tx_counter0;
    UDR0=tx_buffer0[tx_rd_index0];
    if (++tx_rd_index0 == TX_BUFFER_SIZE0) tx_rd_index0=0;
    };
    }

    #ifndef _DEBUG_TERMINAL_IO_
    // Write a character to the USART0 Transmitter buffer
    #define _ALTERNATE_PUTCHAR_
    #pragma used+
    void putchar(char c)
    {
    while (tx_counter0 == TX_BUFFER_SIZE0);
    #asm("cli")
    if (tx_counter0 || ((UCSR0A & DATA_REGISTER_EMPTY)==0))
    {
    tx_buffer0[tx_wr_index0]=c;
    if (++tx_wr_index0 == TX_BUFFER_SIZE0) tx_wr_index0=0;
    ++tx_counter0;
    }
    else
    UDR0=c;
    #asm("sei")
    }
    #pragma used-
    #endif
     
     
      
    lwking412当前离线
    注册时间
    2008-4-15
    最后登录
    2012-3-20
    在线时间
    0 小时
    阅读权限
    1
    积分
    349
    帖子
    241
    精华
    0
    UID
    28812
    查看详细资料

    54

    主题

    0

    好友

    349

    积分

    游客

    莫元
    349
    4
    发表于 2008-9-2 19:27:55 |只看该作者
    好复杂,头都大了,一定要开辟缓冲区么,我直接接收就不可以么?
    1做个延时,等所有的字符都收齐了,再处理。 问题是怎么延时呢?可否简单介绍一下
    2或者开缓冲区,根据缓冲区的长度来判断是否都接收完毕。 开辟缓冲区我有点思路,可以参考马老师书上的,但是根据缓冲区的长度我还不是很明白这句话,如果我能判断接收完毕后就好了,手机发送的是那么一大串字符!

    本身就不是学习编程出身的,老师非让我做这个不做完不行啊!
     
     
      
    lwking412当前离线
    注册时间
    2008-4-15
    最后登录
    2012-3-20
    在线时间
    0 小时
    阅读权限
    1
    积分
    349
    帖子
    241
    精华
    0
    UID
    28812
    查看详细资料

    54

    主题

    0

    好友

    349

    积分

    游客

    莫元
    349
    5
    发表于 2008-9-2 19:41:23 |只看该作者
    Appcat
    你好,可以邮件联系你么,我想知道如何做延时,实在没这方面的经验
    希望可以发邮件和你请教!
     
     
      
    Appcat当前在线
    注册时间
    2006-6-25
    最后登录
    2012-5-31
    在线时间
    271 小时
    阅读权限
    90
    积分
    3844
    帖子
    3458
    精华
    5
    UID
    165346
    查看详细资料

    68

    主题

    0

    好友

    3844

    积分

    论坛元老

    苹果猫

    Rank: 8Rank: 8

    莫元
    3844
    6
    发表于 2008-9-2 19:44:08 |只看该作者
    手机发送的东西,总要有个上限吧,不可能是无限的吧,所以把你系统需要处理的最长长度+1做为缓冲区长度总可以吧。其实
    英文短信才几个字符啊?上面我贴的程序里边开了255个字符,绝对够用了。

    仔细看看上面的程序,里边有一个变量rx_counter0,这个就是关键所在。你在主程序里边判断rx_counter0是否不为零,如果
    不为零,说明串口已经有东西进来了,计算一下你的波特率和最大长度,做一个延时,保证串口缓冲区能够收到所有字符,然后
    取出整个缓冲区,你的完整短信已经在里边了,该怎么处理就怎么处理了。

    #define MAX_BUF_LENS 255
    unsigned char buf[MAX_BUF_LENS], i

    //初始化,首先清空串口缓冲区,防止残留的字符干扰
    while (rx_counter0) getchar();
    memset(buf, 0, MAX_BUF_LENS);
    ......................

    //自己做循环,检测rx_counter0是否不为零
    while (!rx_counter0);
    //延时100毫秒,具体多少需要自己算,这个时间宜长不宜短
    delay_ms(100);
    i = 0;
    while (rx_counter0)
    {
    buf = getchar();
    i++;
    }
    //到这里,串口过来的短信已经完整的存放在buf中了,你可以对buf进行需要的操作了
               
    展开全文
  • STC12C5A60S2 串口中断接收程序

    万次阅读 2012-01-28 08:47:12
    #define UART0_BUF_LEN 32int UART1_Recv_count; //接收计数bit UART1_Overflow_Flag; //缓冲区满标志idata uchar UART1_Recv_... //串口接收缓冲区 //串口初始化void Init_Uart(){ UART1_Overflow_Flag=0; UART
     

    #define UART0_BUF_LEN 32


    int UART1_Recv_count;  //接收计数

    bit UART1_Overflow_Flag;   //缓冲区满标志

    idata uchar UART1_Recv_BUF[UART0_BUF_LEN];  //串口接收缓冲区

     

    //串口初始化
    void Init_Uart()
    {
        UART1_Overflow_Flag=0;
        UART1_Recv_count=0;
         //22.1184M 晶振   115200波特率
        PCON &= 0x7f;  //波特率不倍速
        SCON = 0x50;  //8位数据,可变波特率
        BRT = 0xFA;  //设定独立波特率发生器重装值
        AUXR |= 0x04;  //独立波特率发生器时钟为Fosc,即1T
        AUXR |= 0x01;  //串口1选择独立波特率发生器为波特率发生器
        AUXR |= 0x10;  //启动独立波特率发生器   
         ES = 1;             //充许串口1中断

      }

     

    //串口中断接收程序

    /*

       说明:

          (1)如果缓冲区接收满了,则中断接收程序不在接收数据。UART1_Recv_count=32

          (2)如果接收到“回车符”、“换行符”,则中断不在接收数据。UART1_Recv_count={实际接收到的数据个数}

           以上2种情况触发后 UART1_Overflow_Flag标志位置为1,等待MAIN函数(主程序处理)

    */
    void UART1_Int(void) interrupt 4 

        if (RI == 1) 
        { 
          RI = 0; 
       if(UART1_Overflow_Flag==0)
       {          
         if(UART1_Recv_count<UART0_BUF_LEN)
             { 
           UART1_Recv_BUF[UART1_Recv_count++] = SBUF;  
           if(SBUF=='\r' || SBUF=='\n')
           {
                   UART1_Overflow_Flag=1;
        }
         }
         else
         {
                  UART1_Overflow_Flag=1; // 关闭串口中断,停止接收
         }
        }
        LED2=~LED2; 
        }    

     

     

    int main()
    {
       char i; 
       TMOD=0x00;
       AUXR=0x00;

       LED1=0;
       LED2=1;

       Init_Uart();
       EA=1;  //开总中断
       
       printf("System is start...\r\n");

       while(1)
       {
          if (UART1_Overflow_Flag==1)     //串口中断数据接收完毕,开始处理
          {  
                  for(i=0;i<UART1_Recv_count;i++)
                       printf("%c",UART1_Recv_BUF[i]);                       
                            Appcall(UART1_Recv_BUF,UART1_Recv_count);    
                       printf("\r\n");
                  UART1_Recv_count = 0;            //缓存清零
                  UART1_Overflow_Flag=0;        //允许串口继续接收数据
          } 
       }
    }

    小知识:

         [1]换行符、回车符的定义

             

     ASICC语言编程描述
    回车符0a(13)\r
    换行符0d\n

        换行符、回车符的来历:

        在计算机还没有出现之前,有一种叫做电传打字机(Teletype Model 33)的玩意,每秒钟可以打10个字符。但是它有一个问题,就是打完一行换行的时候,要用去0.2秒,正好可以打两个字符。要是在这0.2秒里面,又有新的字符传过来,那么这个字符将丢失。于是,研制人员想了个办法解决这个问题,就是在每行后面加两个表示结束的字符。一个叫做“回车”,告诉打字机把打印头定位在左边界;另一个叫做“换行”,告诉打字机把纸向下移一行。这就是“换行”和“回车”的来历,从它们的英语名字上也可以看出一二。

        后来,计算机发明了,这两个概念也就被般到了计算机上。那时,存储器很贵,一些科学家认为在每行结尾加两个字符太浪费了,加一个就可以。于是,就出现了分歧。

        Unix系统里,每行结尾只有“<换行>”,即“\n”;

        Windows系统里面,每行结尾是“<换行><回车>”,即“\n\r”;Mac系统里,每行结尾是“<回车>”。

        在ascii中,回车和换行是不同的字符。0x0A是回车,即光标移动到本行的最左面; 0x0D是换行,即光标移动到下一行。

      [2]常见的串口工具如何发生“换行符”

       

         在用串口工具发送数据时,如果勾选了发送新行,串口工具就会在数据尾部添加“换行符”

     

         [2] STC单片机波特率计算

             STC单片机官网上有一个比较好用的波特率计算工具,大家都可以自己下载了使用。

           

         选择好晶振,波特率发生器、定时器时钟后, 该程序就可以自动生成代码了。非常方便。

         STC官网地址:http://www.stcmcu.com/

        

       [3]关于STC单片机独立波特率发生器的理解

             a. STC单片机有1个独立的波特率发生器,虽然用独立的波特率发生器就不需要用定时器了。但是要注意的时,独立波特率发生器和“晶振”频率还是有关的。

             b. 如果要串口的数据收发误码率较低,还是要选用 11.0592 、22.1184  这些晶振。

           

             注意看上图,误码率为 0.00%

             c. 6M、  12M 、24M 这些晶振如果在串口通信里,是不建议用的

             d. 在STC单片机上,用 11.0592 晶振,是可以非常方便的上 115200 波特率高速传输的,这是普通的AT89S51单片机很难实现的。

           

          只要让单片机工作在1T的工作模式下,11.0592的晶振,也可以轻松跑到115200波特率。

    展开全文
  • TI DSP 28335 串口FIFO中断接收程序 打开后在工程添加文件中的comm_2int_fifo.c文件即可。 该文件已经本人调试成功可用。
  • TI DSP 28335 串口 非FIFO 中断接收程序 打开后在工程添加文件中的comm_2int_bytes.c文件即可。 该文件已经本人调试成功可用。
  • C51串口中断接收和发送程序

    千次阅读 2010-12-12 21:13:00
    //这是一个单片机C51串口接收(中断)和发送例程,可以用来测试51单片机的中断接收  //和查询发送,另外我觉得发送没有必要用中断 <br />#include <reg51.h><br />#include <string.h><br /> #...
    //这是一个单片机C51串口接收(中断)和发送例程,可以用来测试51单片机的中断接收 
    //和查询发送,另外我觉得发送没有必要用中断

    #include <reg51.h>
    #include <string.h>

    #define INBUF_LEN 4   //数据长度

    unsigned char inbuf1[INBUF_LEN];
    unsigned char checksum,count3;
    bit read_flag=0;

    void init_serialcomm(void)
    {
        SCON  = 0x50;       //SCON: serail mode 1, 8-bit UART, enable ucvr 
        TMOD |= 0x20;       //TMOD: timer 1, mode 2, 8-bit reload 
        PCON |= 0x80;       //SMOD=1; 
        TH1 = 0xF4;       //Baud:4800  fosc=11.0592MHz 
        IE |= 0x90;       //Enable Serial Interrupt 
        TR1 = 1;          // timer 1 run 
       // TI=1; 
    }

    //向串口发送一个字符 
    void send_char_com(unsigned char ch)
    {
        SBUF=ch;
        while(TI==0);
        TI=0;
    }

    //向串口发送一个字符串,strlen为该字符串长度 
    void send_string_com(unsigned char *str,unsigned int strlen)
    {
        unsigned int k=0;
        do 
        {
            send_char_com(*(str + k));
            k++;
        } while(k < strlen);
    }

    //串口接收中断函数 
    void serial () interrupt 4 using 3 
    {
        if(RI)
        {
            unsigned char ch;
            RI = 0;
            ch=SBUF;
            if(ch>127)
            {             count3=0;
                 inbuf1[count3]=ch;
                 checksum= ch-128;
            }
            else 
            {
                 count3++;
                 inbuf1[count3]=ch;
                 checksum ^= ch;
                 if( (count3==(INBUF_LEN-1)) && (!checksum) )
                 {
                     read_flag=1;  //如果串口接收的数据达到INBUF_LEN个,且校验没错, 
                                   //就置位取数标志 
                 }
            }
        }
    }

    main()
    {
        init_serialcomm();  //初始化串口 
        while(1)
        {
              if(read_flag)  //如果取数标志已置位,就将读到的数从串口发出 
              {
                   read_flag=0; //取数标志清0 
                   send_string_com(inbuf1,INBUF_LEN);
              }     }
    }
    展开全文
  • 这是一个单片机C51串口接收(中断)和发送例程,可以用来测试51单片机的中断接收 ,和查询发送,另外我觉得发送没有必要用中断,因为程序的开销是一样的 。
  • 程序编写了STM32F103三个串口初始化程序,可快速调用,同时支持接收和发送单个字符和多个字符,并存储数据,方便接收数据后的通信协议校验,支持自定义接收数据最大长度,重写printf函数。
  • 用中断来实现串口通信//这是一个单片机C51串口接收(中断)和发送例程,可以用来测试51单片机的中断接收 //和查询发送,另外我觉得发送没有必要用中断,因为程序的开销是一样
  • 最近做一个innovation项目时碰到串口接收中断的问题困扰了好久,终于找到知道原因了。项目用到的芯片是NXPMPC5607B,与一个指纹模块通过串口进行数据传输。在已有的Autosar架构的项目的代码中加入指纹模块代码,另外...

          最近做一个innovation项目时碰到串口接收中断的问题困扰了好久,终于找到知道原因了。项目用到的芯片是NXPMPC5607B,与一个指纹模块通过串口进行数据传输。在已有的Autosar架构的项目的代码中加入指纹模块代码,另外需要对串口进行正确的配置,才能完成最终的功能。串口接收中断

          根据解读芯片手册,配置串口需要先配置SUI端口,PCTL寄存器,然后配置Linflex相关寄存器。因为这款芯片,串口UART和LIN是结合在一起的,因此配置时需要设置UART模式,然后配置波特率等。直接附上串口配置代码:

    void LINFlex1_init(uint16_t baudrate)
    {
    	ME.PCTL[49].R = 0x00;
    
    	//Configure the input/output TX RX
    	SIU.PCR[38].R = 0x0600;    // Setting PC[6] as LINFlex_1.TxDA
          SIU.PCR[39].R = 0x0101;    // Setting PC[7] as LINFlex_1.RxDA, pull up
          SIU.PSMI[55].B.PADSEL = 0x00; // set PADSEL PC[7] to RXD
    
    	//Configure LINFlex1
    	LINFLEX_1.LINCR1.B.INIT   = 1;   // request initlization
    	LINFLEX_1.LINCR1.B.SLEEP  = 0;  // disable the sleep mode
    	LINFLEX_1.LINCR1.B.BF     = 1;  // if Identifier is not comparison with any filter,  generate interrupt
    
    	LINFLEX_1.UARTCR.B.UART   = 1;        // enter UART mode
    	LINFLEX_1.UARTCR.B.WL     = 1;        // 8 bit data
    	//LINFLEX_1.UARTCR.B.OP     = 1;      // even parity
    	LINFLEX_1.UARTCR.B.PCE    = 0;  // disable odd and even parity
    	LINFLEX_1.UARTCR.B.TDFL   = 0;        // send buffer is only 1 byte
    	LINFLEX_1.UARTCR.B.RDFL   = 0;        // receive buffer is only 1 byte
    	
    	LINFLEX_1.UARTCR.B.RXEN   = 1;   // enable receive
    	LINFLEX_1.UARTCR.B.TXEN   = 1;   // enable transmit
    	//WKUP.WISR.R = 0x00001000;  // setting the wake up event for LINRX1
    	//WKUP.WRE.R = 0x00000000;  //disable the LINRX1 wakeup request
    
    	switch (baudrate)
    	{
    		case 9600:
    		{
    			//baudrate 9600
    		  LINFLEX_1.LINIBRR.B.DIV_M = 833;      // Baud Rate = 9600, In Case fipg_clock_lin = 64 MHz
    		  LINFLEX_1.LINFBRR.B.DIV_F = 5;       // Baud Rate = 9600, In Case fipg_clock_lin = 64 MHz
    		}
    		break;
    		case 19200:
    		{
    			//baudrate 19200
    		  LINFLEX_1.LINIBRR.B.DIV_M = 416;     // Baud Rate = 19200, In Case fipg_clock_lin = 64 MHz
    		  LINFLEX_1.LINFBRR.B.DIV_F = 11;       // Baud Rate = 19200, In Case fipg_clock_lin = 64 MHz
    		}
    		break;
    		case 38400:
    		{
    			//baundrate 38400
    		  LINFLEX_1.LINIBRR.B.DIV_M = 208;     // Baud Rate = 38400, In Case fipg_clock_lin = 64 MHz
    		  LINFLEX_1.LINFBRR.B.DIV_F = 5;       // Baud Rate = 38400, In Case fipg_clock_lin = 64 MHz
    		}
    		break;
    		case 57600:
    		{
    			//baundrate 57600
    		  LINFLEX_1.LINIBRR.B.DIV_M = 138;      // Baud Rate = 57600, In Case fipg_clock_lin = 64 MHz
    		  LINFLEX_1.LINFBRR.B.DIV_F = 14;       // Baud Rate = 57600, In Case fipg_clock_lin = 64 MHz
    		}
    		break;
    		case 115200:
    		{
    			//baundrate 115200
    		  LINFLEX_1.LINIBRR.B.DIV_M = 69;       // Baud Rate = 19200, In Case fipg_clock_lin = 64 MHz
    		  LINFLEX_1.LINFBRR.B.DIV_F = 7;       // Baud Rate = 19200, In Case fipg_clock_lin = 64 MHz
    		}
    		break;
    		default:
    		{
    			//baundrate 57600
    		  LINFLEX_1.LINIBRR.B.DIV_M = 138;       // Baud Rate = 57600, In Case fipg_clock_lin = 64 MHz
    		  LINFLEX_1.LINFBRR.B.DIV_F = 14;       // Baud Rate = 57600, In Case fipg_clock_lin = 64 MHz
    		}
    		break;
    	}
    
    	LINFLEX_1.LINIER.B.DRIE   = 1;   // enable the receive interrupt
    
    	LINFLEX_1.UARTSR.B.DRF    = 1;        // clear the receive data complete flag
    	LINFLEX_1.UARTSR.B.DTF    = 1;        // clear the transmit data complete flag
    	//INTC.PSR[99].R = 0x01;                // set the interrupt priority as 1
    	LINFLEX_1.LINCR1.B.INIT   = 0;  // change to normal mode
    }

    串口初始化结束后,接着是编写中断函数,中断函数非常简单,就是从寄存器中读取接受的数据存到一个数据缓存arrar_uart[]中,接收完需要清除接收完成标志位DRF。

    void UART1_ISRfunc(void) 
    {
    	arrar_uart[length_uart++] = (uint8_t)LINFLEX_1.BDRM.R;
    	LINFLEX_1.UARTSR.B.DRF = 1;
    }

    中断函数编写完后,需要配置串口函数在中断向量表中的入口地址。设置如下:

    __asm("    e_lis  r0,%hi( UART1_ISR_cat2c)");
    __asm("    e_or2i       r0,%lo( UART1_ISR_cat2c)");

    设置中断函数的入口地址,由于中断函数在osek任务调度同一管理,下面的UART1_ISR_cat2c即是osek中的中断函数,此处可以直接替换成中断函数UART1_ISRfunc。

    尤其要注意的是设置中断优先级的这段

       __asm("   e_add16i   r31, r31, 26");     /* prio 1 for UART1_ISR */
       __asm("   e_add16i   r30, r30, 0");
       __asm("   e_stb    r30, 0(r31)");

    否则中断会被其他的中断抢占,而导致进不了中断函数,在调试过程中,之前代码没有设置优先级,从而导致中断函数一直进不去。

    展开全文
  • 网上大多数说的都是轮询的方式来读写串口数据...请问各位大侠怎样在linux下获取串口中断的标志,并跳转到相关的中断服务程序执行相关指令。(使用C语言) 网上使用的 signal handler是否就是用中断方式来读取串口数据?
  • 代码包含单片机串口初始化配置,轮训方式发送和接收数据,以及串口接收中断函数,并包含invector.c汇编代码的配置,以及oesk任务相关函数。
  • STM32的HAL库将底层包装的很完备了, 在使用过程中几乎不需要去修改HAL库本身代码, 直接使用现有HAL库接口就可以快速方便的开发应用程序, 配合CubMx对开发人员来说实在是太友好了, 今天介绍个自用的串口中断接收的...
  • 这是一个单片机C51串口接收(中断)和发送例程,可以用来测试51单片机的中断接收和查询发送,另外我觉得发送没有必要用中断,因为程序的开销是一样的
  • 完整配置代码1.1 IO以及串口时钟配置1.2 串口中断配置1.3 使能串口接收中断1.4 实现串口中断处理程序1.5 实现串口轮询发送(打印printf调试功能实现)2.主函数测试函数 本文只描述串口0中断接收和轮询发送相关配置...
  • 不定长度的中断方式串口接收程序段 void USART2_IRQHandler(void) //串口中断服务程序 { unsigned char i; if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) //接收到一个字节 { ...
  • [STM32系列]一、HAL库的串口中断接收

    千次阅读 2019-09-09 14:41:50
    [STM32系列]一、HAL库的串口中断接收1、前言2、回调函数3、HAL库中断接收函数使用 1、前言 HAL即硬件抽象层(英语:Hardware Abstraction Layer),实现了不同硬件的统一接口操作。这就极大的简化了程序员的移植工作...
  • 使用UCOSII最新版本2.92,程序中一共创建了三个任务,包括LED闪烁,串口收发,SPI收发,开发环境keil4,CPU是STM32L151C8T6
  • 串口接收超时中断程序思路

    千次阅读 2019-05-07 00:07:18
    //通过判断接收连续2个字符之间的时间差不大于10ms来决定是不是一次连续的数据. //如果2个字符接收间隔超过10ms,则认为不是1次连续数据.也就是超过10ms没有接收到 //任何数据,则表示此次接收完毕. //接收到的数据...
  • 用STM32 HAL库,串口使用中断模式,发现程序有时候会进去死锁状态,原因应该是串口在发送过程中,这时候数据又被发送过去了,然后就很容易会死锁了。上网找了相关的资料,见链接:...
  • 串口中断服务程序代码集

    千次阅读 2008-01-09 12:46:00
    //主页地址http://www.mcu51.com//串口中断服务程序,仅需做简单调用即可完成串口输入输出的处理//出入均设有缓冲区,大小可任意设置。//可供使用的函数名://char getbyte(void);从接收缓冲区取一个byte,如不想等待...
  • STM32F103单片机串口DMA+空闲中断接收DEMO源程序。 。
  • 前一段做了个串口通信小软件,就是现实利用上位机软件通过串口通信对下位机(单片机)通信,校时LED点阵万年历,省去按键调节的麻烦,
  • 串口通信原程序,利用中断方式接收数据. 串口通信原程序,利用中断方式接收数据
  • 用STM32 HAL库串口的DMA发送和空闲中断接收处理数据,单片机发送AT指令给ESP8266 wifi模组问题:单片机连续几次给wifi模组发送AT指令,wifi模块总是少一次的应答,在无线通信过程中是不方便和不允许的,因为在通信...
  • STM32F103串口使用空闲IDLE中断接收不定长数据程序

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 797
精华内容 318
关键字:

串口中断接收程序