一个非常好的串口程序.txt

一个非常好的串口程序

      贴一个非常好的串口程序！
        #include <iom128v.h>
        #include <macros.h>
        #include "uart.h"

        /* USART Buffer Defines */
        #define USART_RX_BUFFER_SIZE 16 /* 1,2,4,8,16,32,64,128 or 256 bytes */
        #define USART_RX_BUFFER_MASK ( USART_RX_BUFFER_SIZE - 1 )
        #define USART_TX_BUFFER_SIZE 16 /* 1,2,4,8,16,32,64,128 or 256 bytes */
        #define USART_TX_BUFFER_MASK ( USART_TX_BUFFER_SIZE - 1 )

        #if ( USART_RX_BUFFER_SIZE & USART_RX_BUFFER_MASK )
        #error RX buffer size is not a power of 2
        #endif

        /* Static Variables */
        static unsigned char USART_RxBuf[USART_RX_BUFFER_SIZE];
        static volatile unsigned char USART_RxHead;
        static volatile unsigned char USART_RxTail;
        static unsigned char USART_TxBuf[USART_TX_BUFFER_SIZE];
        static volatile unsigned char USART_TxHead;
        static volatile unsigned char USART_TxTail;

        /* 串口初始化 */
        void InitUSART(INT8U  baudrate)
        {
        INT8U x;
        UBRR0L = baudrate;
        UCSR0B = ( (1<<RXCIE0) | (1<<RXEN0) | (1<<TXEN0) );/*RX Complete 
        Interrupt Enable, Receiver Enable and Transmitter Enable*/
        x = 0; /* flush receive buffer */
        USART_RxTail = x;
        USART_RxHead = x;
        USART_TxTail = x;
        USART_TxHead = x;
        }

        /* 接收中断 */
        void USART_RX_interrupt( void )
        {
        unsigned char data;
        unsigned char tmphead;
        data = UDR0; /* read the received data */
        tmphead = ( USART_RxHead + 1 ) & USART_RX_BUFFER_MASK;/* calculate 
        buffer index */
        USART_RxHead = tmphead; /* store new index */
        if ( tmphead == USART_RxTail )
        {
        return;/* ERROR! Receive buffer overflow, you can use 
        flux cortorl */
        }
        USART_RxBuf[tmphead] = data; /* store received data in buffer */
        }

        /* 发送中断 */
        void USART_TX_interrupt( void )
        {
        unsigned char tmptail;

        if ( USART_TxHead != USART_TxTail )/* check if all data is 
        transmitted */
        {
        tmptail = ( USART_TxTail + 1 ) & USART_TX_BUFFER_MASK;/* 
        calculate buffer index */
        USART_TxTail = tmptail; /* store new index */
        UDR0 = USART_TxBuf[tmptail]; /* start transmition */
        }
        else
        {
        UCSR0B &= ~(1<<UDRIE0); /* disable UDRE interrupt */
        }
        }

        /* 读取数据函数 */
        unsigned char ReceiveByte( void )
        {
        unsigned char tmptail;

        while ( USART_RxHead == USART_RxTail ) /* wait for incomming data */
        ;
        tmptail = ( USART_RxTail + 1 ) & USART_RX_BUFFER_MASK;/* calculate 
        buffer index */
        USART_RxTail = tmptail; /* store new index */
        return USART_RxBuf[tmptail]; /* return data */
        }

        /* 发送数据函数 */
        void TransmitByte( unsigned char data )
        {
        unsigned char tmphead;

        tmphead = ( USART_TxHead + 1 ) & USART_TX_BUFFER_MASK; /* calculate 
        buffer index */

        while ( tmphead == USART_TxTail )/* wait for free space in buffer */
        ;
        USART_TxBuf[tmphead] = data; /* store data in buffer */
        USART_TxHead = tmphead; /* store new index */
        UCSR0B |= (1<<UDRIE0); /* enable UDRE interrupt */
        }

        /* 查询是否有数据 */
        unsigned char DataInReceiveBuffer( void )
        {
        return ( USART_RxHead != USART_RxTail ); /* return 0 (FALSE) if the 
        receive buffer is empty */
        }

        /* 中断中只做很少的事情，通常我是在接收中断中post一个信号量，触发别的任务读数据
        */