#define sizeBufTx 16
#define sizeBufRx 16

unsigned char bufRx[sizeBufRx];
unsigned char bufTx[sizeBufTx];

typedef struct CharBuffer
{
    unsigned char* Data;            
    int NData;                        
    int cData;                        
    int pWrite;                        
    int pRead;                        
}
CharBuffer;
void BufferReset(CharBuffer* pBuffer)
{
    pBuffer->pWrite = 0;
    pBuffer->pRead = 0;
    pBuffer->cData = 0;
}
int    BufferWrite(CharBuffer* pBuffer,unsigned char Byte)
{
    if(pBuffer->cData == pBuffer->NData - 1)
        return 1;                    
    pBuffer->Data[pBuffer->pWrite] = Byte;
    if(pBuffer->pWrite == pBuffer->NData - 1)
        pBuffer->pWrite = 0;
    else
        pBuffer->pWrite++;
    pBuffer->cData++;
    return 0;
}
int BufferRead(CharBuffer* pBuffer, unsigned char* Byte)
{
    if(pBuffer->cData == 0)
       return 1;                    
    *Byte = pBuffer->Data[pBuffer->pRead];
    if(pBuffer->pRead == pBuffer->NData - 1)
        pBuffer->pRead = 0;
    else
        pBuffer->pRead++;
    pBuffer->cData--;
    return 0;
}

struct CharBuffer UARTTxBuf, UARTRxBuf;
void WriteTxbuf(int* data, char size)
{
    unsigned char a, j;
    if ((IE1 & UTXIE0) == 0)        
    {
        BufferWrite(&UARTTxBuf, 0xC0);
        for(j = 0; j < size; j++)
        {
          
            a = data[j] & 0xFF;
            switch (a)
            {
                case 0xC0:
                {
                    BufferWrite(&UARTTxBuf, 0xDB);
                    BufferWrite(&UARTTxBuf, 0xDC);
                    break;
                }
                case 0xDB:
                {
                    BufferWrite(&UARTTxBuf, 0xDB);
                    BufferWrite(&UARTTxBuf, 0xDD);
                    break;
                }
                default:
                    BufferWrite(&UARTTxBuf, a);
            }
            
            a = data[j] >> 8;
            switch (a)
            {
                case 0xC0:
                {
                    BufferWrite(&UARTTxBuf, 0xDB);
                    BufferWrite(&UARTTxBuf, 0xDC);
                    break;
                }
                case 0xDB:
                {
                    BufferWrite(&UARTTxBuf, 0xDB);
                    BufferWrite(&UARTTxBuf, 0xDD);
                    break;
                }
                default:
                    BufferWrite(&UARTTxBuf, a);
            }
            BufferWrite(&UARTTxBuf, 0xC0);
        }
        
        IE1 |= UTXIE0;                    
        IFG1 |= UTXIFG0;            
    }
}


void ReadRxbuf(unsigned char *data)
{
    IE1 &= ~URXIE0;
    BufferRead(&UARTRxBuf, data);
    
    IE1 |= URXIE0;
}

char i, txsize;
    unsigned char rxdata;
    int txdata[sizeBufTx];
BufferReset(&UARTRxBuf);
    UARTRxBuf.NData = sizeBufRx;
    UARTRxBuf.Data = bufRx;
    BufferReset(&UARTTxBuf);
    UARTTxBuf.NData = sizeBufTx;
    UARTTxBuf.Data = bufTx;

IE1 |= URXIE0;
_BIS_SR(GIE);    
for(;;)
    {
        rxdata = 0;
        txsize = 0;
        ReadRxbuf(&rxdata);
        if (rxdata)
        {
            txdata[txsize++] = rxdata;

            WriteTxbuf(txdata, txsize);
            
        }
    }
}

#pragma vector = UART0RX_VECTOR
__interrupt void usart0_rx (void)
{
    BufferWrite(&UARTRxBuf, U0RXBUF);
}


#pragma vector = USART0TX_VECTOR
__interrupt void usart0_tx (void)
{
    unsigned char data;
    if (!BufferRead(&UARTTxBuf, &data))        
        U0TXBUF = data;
    else
        IE1 &= ~UTXIE0;                        
}