Subversion Repositories Code-Repo

#include "maindefs.h"
#include "uart.h"
#include <string.h>

static UART_DATA uart_1_data;

void UART1_Init() {
    // Configure the hardware USART device
    // UART1 TX RC6
    // UART1 RX RC7

    TRISCbits.TRISC6 = 0;   // Tx pin set to output
    TRISCbits.TRISC7 = 1;   // Rx pin set to input

    BAUDCON1bits.BRG16 = 0; // 8-bit baud rate generator
    SPBRG1 = 25;            // Set UART speed to 115200 baud
    TXSTA1bits.BRGH = 1;    // High speed mode
    TXSTA1bits.SYNC = 0;    // Async mode
    RCSTA1bits.SPEN = 1;    // Serial port enable
    TXSTA1bits.TX9 = 0;     // 8 bit transmission
    RCSTA1bits.RX9 = 0;     // 8 bit reception
    TXSTA1bits.TXEN = 0;    // Enable transmission
    RCSTA1bits.CREN = 1;    // Continuous receive mode
    
    PIE1bits.TX1IE = 1;     // Enable TX interrupt
    PIE1bits.RC1IE = 1;     // Enable RX interrupt

    // Initialize the buffer that holds UART messages
    uart_1_data.buffer_in_read_ind = 0;
    uart_1_data.buffer_in_write_ind = 0;
    uart_1_data.buffer_in_len = 0;
}

//void uart_2_init() {
//    // Configure the PPS USART ports
//
//    // UART2 RX Pin RP5
//    RPINR16 = 5;    // 5 is PPS RP5
//    // UART2 TX Pin RP6
//    RPOR6 = 6;  // 6 is TX2/CK2 (EUSART2 Asynchronous Transmit/Asynchronous Clock Output)
//
//    Open2USART(USART_TX_INT_OFF &   // Interrupt on TX off
//            USART_RX_INT_ON &      // Interrupt on RX on
//            USART_ASYNCH_MODE &     // Operate in async mode
//            USART_EIGHT_BIT &       // Operate in 8-bit mode
//            USART_CONT_RX &         // Continuously recieve messages
//            USART_BRGH_HIGH, 25);  // Set UART speed to 115200 baud
//}

void UART1_Recv_Interrupt_Handler() {
    unsigned char c;
    if (PIR1bits.RC1IF) {   // Check if data receive flag is set
        if (uart_1_data.buffer_in_len == MAXUARTBUF-1) {
            TXSTA1bits.TXEN = 0;    // Kill anything currently sending
            DBG_PRINT_UART("UART1 Buffer Overflow!\r\n");
            c = RCREG1; // Read RCREG to clear it
        } else {
            // Save received data into buffer
            uart_1_data.buffer_in[uart_1_data.buffer_in_write_ind] = RCREG1;
            if (uart_1_data.buffer_in_write_ind == MAXUARTBUF-1) {
                uart_1_data.buffer_in_write_ind = 0;
            } else {
                uart_1_data.buffer_in_write_ind++;
            }
            uart_1_data.buffer_in_len++;
        }
    }
    
    if (RCSTAbits.OERR == 1) {
        // We've overrun the USART and must reset
        RCSTA1bits.CREN = 0;    // Reset UART1
        RCSTA1bits.CREN = 1;
        TXSTA1bits.TXEN = 0;    // Kill anything currently sending
        DBG_PRINT_UART("UART1 Overrun!\r\n");
    }
}

//void uart_2_recv_interrupt_handler() {
//    if (DataRdy2USART()) {
////        xbee_read_serial(Read2USART());
//    }
//
//    if (USART2_Status.OVERRUN_ERROR == 1) {
//        // We've overrun the USART and must reset
//        RCSTA2bits.CREN = 0;    // Reset UART2
//        RCSTA2bits.CREN = 1;
//    }
//}

void UART1_Send_Interrupt_Handler() {
    // Put remaining data in TSR for transmit
    if (uart_1_data.buffer_out_ind != uart_1_data.buffer_out_len) {
        TXREG1 = uart_1_data.buffer_out[uart_1_data.buffer_out_ind];
        uart_1_data.buffer_out_ind++;
    } else {
        while (!TXSTA1bits.TRMT);   // Wait for last byte to finish sending
        TXSTA1bits.TXEN = 0;    // End transmission and disable TX interrupt
        uart_1_data.buffer_out_ind = 0;
        uart_1_data.buffer_out_len = 0;
    }
}

void UART1_WriteS(const rom char *fmt, ...) {
    va_list args;
    while (TXSTA1bits.TXEN);    // Wait for previous message to finish sending
    va_start(args, fmt);
    vsprintf((char *)uart_1_data.buffer_out, fmt, args);
    va_end(args);
    uart_1_data.buffer_out_len = strlen((char *)uart_1_data.buffer_out);
    uart_1_data.buffer_out_ind = 1;
    TXREG1 = uart_1_data.buffer_out[0]; // Put first byte in TSR
    TXSTA1bits.TXEN = 1;    // Begin transmission
}

void UART1_WriteB(const char *msg, unsigned char length) {
    unsigned char i;
    while (TXSTA1bits.TXEN);    // Wait for previous message to finish sending
    uart_1_data.buffer_out_len = length;
    uart_1_data.buffer_out_ind = 1;
    for (i = 0; i <  length; i++) {
        uart_1_data.buffer_out[i] = msg[i];
    }
    TXREG1 = uart_1_data.buffer_out[0]; // Put first byte in TSR
    TXSTA1bits.TXEN = 1;    // Begin transmission
}

/* Reader interface to the UART buffer, returns the number of bytes read */
unsigned char UART1_Read(char *buffer) {
    unsigned char i = 0;
    while (uart_1_data.buffer_in_len != 0) {
        buffer[i] = uart_1_data.buffer_in[uart_1_data.buffer_in_read_ind];
        i++;
        if (uart_1_data.buffer_in_read_ind == MAXUARTBUF-1) {
            uart_1_data.buffer_in_read_ind = 0;
        } else {
            uart_1_data.buffer_in_read_ind++;
        }
        uart_1_data.buffer_in_len--;
    }
    return i;
}