uart code

unsigned char uart1_transmit_buffer[UART1_XMIT_BUFFER_SIZE];    /* transmit buffer */
unsigned char uart1_receive_buffer[UART1_RECV_BUFFER_SIZE];     /* receive buffer */
unsigned char uart1_xmit_index;             /* xmit data input index */
unsigned char uart1_xmit_outdex;            /* xmit data output index */
unsigned char uart1_recv_index;             /* rcv data input index */
unsigned char uart1_recv_outdex;            /* rcv data output index */
/*
    When a data is comming in the port, it is passed through to the output.
    During that time, the transmit port is "locked".
*/
unsigned char uart1_xmit_lock = UNLOCK;

/** public functions **/

/** private functions **/

void __attribute__((interrupt, __auto_psv__)) _U1TXInterrupt(void)
{
/* Note: this ISR takes about 13.6uS to complete at 7.3728Mhz */

    unsigned char TempOutdex, TempIndex, data_byte;
    signed short junk;

    IFS0bits.U1TXIF = 0;                    /* clear the ISR flag */
    TempOutdex = uart1_xmit_outdex;
    TempIndex  = uart1_xmit_index;

/* Calculate number of full bytes in the buffer. */
    junk = (signed short) ((signed short) TempIndex - (unsigned short) TempOutdex);
    if (junk < 0)
    {
        junk += UART1_XMIT_BUFFER_SIZE;
    }
/* 'junk' now contains the number of full bytes in the transmit buffer */
    if (junk > 0)
    {
/* there is data available to send */
        data_byte = uart1_transmit_buffer[TempOutdex++];
        U1TXREG = data_byte;                            /* send byte */
        if (TempOutdex == UART1_XMIT_BUFFER_SIZE)
        {
            TempOutdex = 0;                             /* roll over */
        }
        junk--;                                         /* decrement byte count */
/* If 'junk' is 0, transmission is complete. */
        if (junk == 0)
        {
/* No more bytes to transfer here, disable the interrupt. */
            IEC0bits.U1TXIE = 0;                        /* disable transmit interrupt */
        }
    }
    uart1_xmit_outdex = TempOutdex;
}

void __attribute__((interrupt, __auto_psv__)) _U1RXInterrupt(void)
{
    unsigned char TempOutdex, TempIndex, data_byte;
    signed short junk;

    data_byte = (unsigned char) U1RXREG;    /* get the byte */
    IFS0bits.U1RXIF = 0;                    /* clear the ISR flag */

    TempOutdex = uart1_recv_outdex;         /* get the indices */
    TempIndex  = uart1_recv_index;

    junk = (signed short) ((signed short) TempOutdex - \
                        (signed short) TempIndex);
    if (junk <= 0)
    {
        junk += UART1_RECV_BUFFER_SIZE;
    }
    if (junk > 1)
    {
/* There's room in the buffer */
        uart1_receive_buffer[TempIndex] = data_byte;    /* save data */
        TempIndex++;                                    /* update index */
        if (TempIndex == UART1_RECV_BUFFER_SIZE)
        {
            TempIndex = 0;                              /* roll over */
        }
        uart1_recv_index = TempIndex;                   /* save new index */
    }
}

void uart1_receive_interrupt_enable(void)
{
    IFS0bits.U1RXIF = 0;    /* clear the ISR flag */
    IEC0bits.U1RXIE = 1;    /* enable the interrupt */
}

void uart1_receive_interrupt_disable(void)
{
    IEC0bits.U1RXIE = 0;    /* disable the interrupt */
}

/*
 **  void uart1_init(void)
 *
 *  FILENAME: uart1_drivers.c
 *
 *  PARAMETERS: None
 *
 *  DESCRIPTION: Initialize UART1
 *
 *  RETURNS: None
 *
 *  RD12 is CTS to module
 *  RD13 is RTS from module
 *
*/
void uart1_init(void)
{
    uart1_xmit_index  = 0;      /* initialize buffer indices */
    uart1_xmit_outdex = 0;
    uart1_recv_index  = 0;
    uart1_recv_outdex = 0;
/*
    The desired baud rate is 115.2K baud.
    The system frequency is 7.3728Mhz x 4 = 29.4912Mhz with the PLL running.
    Fcy = 29.4912Mhz / 2 = 14.7456Mhz
    U1BRG with BRGH = 0 is (14,745,600 / (16 x 230,400) } - 1 = 3
*/
    {
        // changed to 9600, can change it back to higher baud once we finished testing.
        uint32_t val = (uint32_t)((uint32_t)14745600 / ((uint32_t)16 * (uint32_t)9600))  - (uint32_t)1;
        U1BRG = val;                    /* baud rate divider */
        //U1BRG = 3;                    /* baud rate divider */
    }
    U1STA = 0x0000;             /* initialize uart */
    U1MODE = 0x8000;            /* enable uart */
    U1STA = 0x0400;             /* turn on transmitter */
    IFS0bits.U1RXIF = 0;        /* clear the ISR flag */
    IEC0bits.U1RXIE = 1;        /* enable the interrupt */
}

/*
 ** signed short uart1_xmit_buffer_space(void)
 *
 *  FILENAME: uart1_drivers.c
 *
 *  PARAMETERS: None
 *
 *  DESCRIPTION: Returns number of empty bytes in
 *              transmit buffer.
 *
 *  RETURNS: number of empty bytes in transmit buffer
 *
 */
signed short uart1_xmit_buffer_space(void)
{
    signed short ReturnValue, junk;
    unsigned char TempOutdex, TempIndex;

    TempOutdex = uart1_xmit_outdex;
    TempIndex  = uart1_xmit_index;

    junk = (signed short) ((signed short) TempOutdex - \
                        (signed short) TempIndex);
    if (junk <= 0)
    {
        ReturnValue = junk + UART1_XMIT_BUFFER_SIZE;
        if (ReturnValue == 1)
        {
/* full buffer indication */
            ReturnValue = 0;
        }
    }
    else
    {
        if (junk == 1)
        {
            ReturnValue = 0;            /* full buffer */
        }
        else
        {
            ReturnValue = junk;
        }
    }
    return ReturnValue;
}

/*
 ** signed short uart1_xmit_buffer_data(void)
 *
 *  FILENAME: uart1_drivers.c
 *
 *  PARAMETERS: None
 *
 *  DESCRIPTION: Returns number of full bytes in
 *              transmit buffer.
 *
 *  RETURNS: number of full bytes in transmit buffer
 *
 */
signed short uart1_xmit_buffer_data(void)
{
    signed short ReturnValue, junk;
    unsigned char TempOutdex, TempIndex;

    TempOutdex = uart1_xmit_outdex;
    TempIndex  = uart1_xmit_index;

    junk = (signed short) ((signed short) TempIndex - \
                        (signed short) TempOutdex);
    if (junk < 0)
    {
        ReturnValue = junk + UART1_XMIT_BUFFER_SIZE;
        if (ReturnValue == 63)
        {
            ReturnValue++;
        }
    }
    else
    {
        ReturnValue = junk;
    }
    return ReturnValue; /* checked */
}

/*
 ** signed short uart1_recv_data(void)
 *
 *  FILENAME: uart1_drivers.c
 *
 *  PARAMETERS: None
 *
 *  DESCRIPTION: Returns number of full bytes
 *              in receive buffer.
 *
 *  RETURNS: Number of full bytes in receive buffer
 *
 */
signed short uart1_recv_buffer_data(void)
{
    signed short ReturnValue, junk;
    unsigned char TempOutdex, TempIndex;

    TempOutdex = uart1_recv_outdex;
    TempIndex  = uart1_recv_index;

    junk = (signed short) ((signed short) TempIndex - \
                        (signed short) TempOutdex);
    if (junk < 0)
    {
        ReturnValue = junk + UART1_RECV_BUFFER_SIZE;
    }
    else
    {
        ReturnValue = junk;
    }
//  if (ReturnValue == 63)
//  {
/* buffer is full here */
//      ReturnValue++;
//  }
    return ReturnValue; /* checked */
}

/*
 ** signed short uart1_recv_buffer_space(void)
 *
 *  FILENAME: uart1_drivers.c
 *
 *  PARAMETERS: None
 *
 *  DESCRIPTION: Returns number of empty bytes in
 *              receive buffer.
 *
 *  RETURNS: number of empty bytes in receive buffer
 *
 */
signed short uart1_recv_buffer_space(void)
{
    signed short ReturnValue, junk;
    unsigned char TempOutdex, TempIndex;

    TempOutdex = uart1_recv_outdex;
    TempIndex  = uart1_recv_index;

    junk = (signed short) ((signed short) TempOutdex - \
                        (signed short) TempIndex);
    if (junk <= 0)
    {
        ReturnValue = junk + UART1_XMIT_BUFFER_SIZE;
        if (ReturnValue == 1)
        {
/* full buffer indication */
            ReturnValue = 0;
        }
    }
    else
    {
        if (junk == 1)
        {
/* full buffer indication */
            ReturnValue = 0;
        }
        else
        {
            ReturnValue = junk;
        }
    }
    return ReturnValue;
}

/*
 **
 *
 *  FILENAME: signed short uart1_put_byte(unsigned char data_byte)
 *
 *  PARAMETERS: data_byte to put into the xmit buffer.
 *
 *  DESCRIPTION: Put a byte of data into the xmit buffer.
 *
 *  RETURNS: Returns the number of empty bytes in the buffer.
 *          If the buffer was full when this function was called,
 *          return a negative value.
 *
 */
signed short uart1_put_byte(unsigned char data_byte)
{
    return uart1_put_data(&data_byte, 1);
#if(0)
    signed short ReturnValue;
    unsigned char TempOutdex, TempIndex;

    TempOutdex = uart1_xmit_outdex;
    TempIndex  = uart1_xmit_index;

/* See if there is there space in the buffer */
    ReturnValue = (signed short) ((signed short) TempOutdex - \
                        (signed short) TempIndex);
#endif
#if 0
    if (ReturnValue <= 0)
    {
        ReturnValue += UART1_XMIT_BUFFER_SIZE;
        if (ReturnValue < 0)
        {
/* space has become available here */
            ReturnValue += UART1_XMIT_BUFFER_SIZE;
            TempIndex -= UART1_XMIT_BUFFER_SIZE;
        }
    }
/* ReturnValue now contains the number of empty bytes in the transmit buffer */
    if (ReturnValue > 0)
    {
/* There's room */
        uart1_transmit_buffer[TempIndex++] = data_byte; /* save data */
        ReturnValue--;
        if (TempIndex == UART1_XMIT_BUFFER_SIZE)
        {
/* roll over here */
            TempIndex = 0;
        }
        if (TempIndex == TempOutdex)
        {
/* the buffer is full here */
            TempIndex += UART1_XMIT_BUFFER_SIZE;
        }
        uart1_xmit_index = TempIndex;
        IEC0bits.U1TXIE = 1;                        /* enable transmit interrupt */
    }
    else
    {
/* buffer was full, ignore request */
        ReturnValue = -1;
    }
    return ReturnValue; /*checked */
#endif
}


/*
 ** unsigned char uart1_get_byte(void)
 *
 *  FILENAME: uart1_drivers.c
 *
 *  PARAMETERS: None
 *
 *  DESCRIPTION: Return byte from receive buffer
 *
 *  RETURNS: Next byte in receive buffer. If there
 *          were no bytes in the buffer, return the
 *          last byte again.
 *
 */
unsigned char uart1_get_byte(void)
{
    signed short junk;
    unsigned char TempOutdex, TempIndex, ReturnValue;

    TempOutdex = uart1_recv_outdex;
    TempIndex  = uart1_recv_index;

/* get return data */
    ReturnValue = uart1_receive_buffer[TempOutdex];

    junk = (signed short) ((signed short) TempIndex - \
                        (signed short) TempOutdex);
    if (junk < 0)
    {
        junk += UART1_RECV_BUFFER_SIZE;
/* roll over condition here */
    }
/* junk has the "full" byte count */
    if (junk > 0)
    {
/* There's data in the buffer here */
        TempOutdex++;           /* increment the index */
        if (TempOutdex == UART1_RECV_BUFFER_SIZE)
        {
/* roll over here */
            TempOutdex = 0;
        }
    }
    uart1_recv_outdex = TempOutdex;
    return ReturnValue;
}

/*
 ** signed short uart1_put_data(unsigned char *in_buffer, signed short byte_count)
 *
 *  FILENAME: uart1_drivers.c
 *
 *  PARAMETERS: 'buffer' points to the block of data to put into the transmit
 *              buffer. 'byte_count' is the number of bytes to transfer.
 *
 *  DESCRIPTION: Move 'byte_count' bytes of data from a buffer pointed to by
 *              'buffer' into the transmit buffer if there's room.
 *
 *  RETURNS: If transfer is successful, return the number of empty bytes left
 *          in the buffer. If there is not enough room to make the transfer,
 *          skip this request and return a negative value.
 *
 */
signed short uart1_put_data(unsigned char *buffer, signed short byte_count)
{
    signed short ReturnValue;
    unsigned char TempOutdex, TempIndex;

    TempOutdex = uart1_xmit_outdex;                     /* don't let this change during this routine */
    TempIndex  = uart1_xmit_index;                      /* don't change this till the routine is done */

    ReturnValue = (signed short) ((signed short) TempOutdex - \
                                (signed short) TempIndex);
    if (ReturnValue <= 0)
    {
        ReturnValue += UART1_XMIT_BUFFER_SIZE;
        if (ReturnValue == 1)
        {
/* full buffer indication */
            ReturnValue = 0;
        }
    }
    else
    {
        if (ReturnValue == 1)
        {
            ReturnValue = 0;            /* full buffer */
        }
    }
/* 'ReturnValue' now contains the number of empty bytes in the buffer */
    if (ReturnValue < byte_count)
    {
/* there isn't enough room in the buffer here. */
        ReturnValue = -1;
    }
    else
    {
/* Complete the transfer here. */
        do
        {
            uart1_transmit_buffer[TempIndex++] = *buffer++;     /* save data */
            if (TempIndex == UART1_XMIT_BUFFER_SIZE)
            {
                TempIndex = 0;                                  /*  Roll over here */
            }
            ReturnValue--;                                      /* keep track of buffer status */
            byte_count--;                                       /* count the byte */
        } while (byte_count > 0);
        uart1_xmit_index = TempIndex;                           /* update index */
        IEC0bits.U1TXIE = 1;                                    /* enable transmit interrupt */
    }
    return ReturnValue; /* checked */
}

/*
 ** signed short uart1_get_data(unsigned char *buffer, signed short byte_count)
 *
 *  FILENAME: uart1_drivers.c
 *
 *  PARAMETERS: 'buffer' points to where the data will be placed. 'byte_count'
 *              is the number of bytes to transfer.
 *
 *  DESCRIPTION: Move 'byte_count' bytes of data from the receive buffer to the
 *              location pointed to by 'buffer' if there's that much data in the
 *              receive buffer. If the receive buffer doesn't have enough bytes,
 *              transfer all of the bytes in the receive buffer.
 *
 *  RETURNS: If transfer is successful, return the number of full bytes left
 *          in the receive buffer. If there weren't enough bytes in the receive
 *          buffer to complete the request, return a negative value of the count
 *          of the number of bytes not transferred.
 *
 */
signed short uart1_get_data(unsigned char *buffer, signed short byte_count)
{
    signed short ReturnValue;
    unsigned char TempOutdex, TempIndex;

    TempOutdex = uart1_recv_outdex;                     /* don't let this change during this routine */
    TempIndex  = uart1_recv_index;                      /* don't change this till the routine is done */

    ReturnValue = (signed short) ((signed short) TempIndex - \
                                (signed short) TempOutdex);
    if (ReturnValue < 0)
    {
        ReturnValue += UART1_RECV_BUFFER_SIZE;
    }
/* ReturnValue now contains the number of full bytes in the receive buffer. */
    if (ReturnValue < byte_count)
    {
/* There isn't enough bytes in the buffer here. */
/* Transfer all of the ReceiveBuffer bytes here. */
        do
        {
            *buffer++ = uart1_receive_buffer[TempOutdex++];     /* save data */
            if (TempOutdex == UART1_RECV_BUFFER_SIZE)
            {
                TempOutdex = 0;                                 /*  Roll over here */
            }
            ReturnValue--;                                      /* keep track of buffer status */
            byte_count--;                                       /* count the byte */
        } while (ReturnValue > 0);
        ReturnValue = -byte_count;
    }
    else
    {
/* Complete the transfer here. */
        do
        {
            *buffer++ = uart1_receive_buffer[TempOutdex++];     /* save data */
            if (TempOutdex == UART1_RECV_BUFFER_SIZE)
            {
                TempOutdex = 0;                                 /*  Roll over here */
            }
            ReturnValue--;                                      /* keep track of buffer status */
            byte_count--;                                       /* count the byte */
        } while (byte_count > 0);
    }
    uart1_recv_outdex = TempOutdex;
    return ReturnValue; /* checked */
}