void main (void) {

    InitDevice ();

    while (1) {
        Delay_mSeconds(20);
        UARTTransmitByte(0x55);
    }
}

#include "global.h"
/*
********************************************************************************
*                             #DEFINE CONSTANTS
********************************************************************************
*/
#define UART_RX_BUFFER_SIZE 8
#define UART_RX_BUFFER_MASK ( UART_RX_BUFFER_SIZE - 1 )
#define UART_TX_BUFFER_SIZE 8
#define UART_TX_BUFFER_MASK ( UART_TX_BUFFER_SIZE - 1 )

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


/*
********************************************************************************
*                             GLOBAL FUNCTION
********************************************************************************
*/

INT08U UART_RxBuf[UART_RX_BUFFER_SIZE];
volatile INT08U UART_RxHead;
volatile INT08U UART_RxTail;

INT08U UART_TxBuf[UART_TX_BUFFER_SIZE];
volatile INT08U UART_TxHead;
volatile INT08U UART_TxTail;

INT08U UARTDataInReceiveBuffer (void) {    
   INT08U temp1 = UART_RxHead, temp2 = UART_RxTail;
   return (temp1 != temp2);    
}

INT08U UARTReceiveByte (void) {
    INT08U temp1=UART_RxHead, temp2=UART_RxTail;
    INT08U tmptail;


    while (temp1 == temp2) {
    };
    tmptail = ( UART_RxTail + 1 ) & UART_RX_BUFFER_MASK;
    UART_RxTail = tmptail;
    return UART_RxBuf[tmptail];
}

void UARTTransmitByte (INT08U data ) {
    INT08U tmphead;


    tmphead = ( UART_TxHead + 1 ) & UART_TX_BUFFER_MASK;
    while ( tmphead == UART_TxTail );
    UART_TxBuf[tmphead] = data;
    UART_TxHead = tmphead;
    UCSR1B |= (1<<UDRIE1);
}
/*
********************************************************************************
*                              LOCAL FUNCTION
********************************************************************************
*/


#pragma vector=USART1_RX_vect
__interrupt void USART_Rx_isr(void) {
    INT08U data;
    INT08U tmphead;

    data = UDR1;
    tmphead = ( UART_RxHead + 1 ) & UART_RX_BUFFER_MASK;
    UART_RxHead = tmphead;  
    if (tmphead == UART_RxTail) {        }
    UART_RxBuf[tmphead] = data;
}


#pragma vector=USART1_TX_vect
__interrupt void USART0_Tx_interrupt( void ) {
    INT08U temp1 = UART_TxHead, temp2 = UART_TxTail;
    INT08U tmptail;

    if (temp1 != temp2) {
        tmptail = ( UART_TxTail + 1 ) & UART_TX_BUFFER_MASK;
        UART_TxTail = tmptail;
        UDR1=UART_TxBuf[tmptail];
    }
    else {
        UCSR1B &= ~(1<<UDRIE1);
    }
}

/*
********************************************************************************
*                             GLOBAL VARIABLE
********************************************************************************
*/
extern INT08U UART_RxBuf[];
extern volatile INT08U UART_RxHead;
extern volatile INT08U UART_RxTail;

extern INT08U UART_TxBuf[];
extern volatile INT08U UART_TxHead;
extern volatile INT08U UART_TxTail;


/*
********************************************************************************
*                        GLOBAL FUNCTION PROTOTYPES
********************************************************************************
*/
INT08U UARTDataInReceiveBuffer (void);
INT08U UARTReceiveByte (void);
void UARTTransmitByte (INT08U);

...
void Init_UART (void) {
    UBRR1L = 0x0C;                                            
    UBRR1H = 0x00;                                          
    UCSR1B = (1<<RXEN1)|(1<<TXEN1)|(1<<TXCIE1)|(1<<RXCIE1)|(1<<UDRIE1);    
    UCSR1C = (1<<USBS1)|(3<<UCSZ10);                          
}
...