UART1.c

Go to the documentation of this file.

#include "UART1.h"



//*****************************************************************************
//
// Globale variables (flags)
//
//*****************************************************************************

tBoolean ge_tbUART1RXITFLAG = 0;

tBoolean ge_tbUART1TXITFLAG = 0;

//*****************************************************************************
//
// Globale variables 
//
//*****************************************************************************


tpfUART1AppendResponseCallbackFunction g_pfOnCallbackGPSAppendResponse;

//*****************************************************************************
//
// Globale variables for input buffer
//
//*****************************************************************************


unsigned char g_pcUart1RxBuffer[UART1_RX_BUFFER_SIZE] = {'\0'};

unsigned int  g_uiUart1RxWriteIndex = 0;

unsigned int  g_uiUart1RxReadIndex = 0;

//*****************************************************************************
//
// Globale variables for output buffer
//
//*****************************************************************************

unsigned char g_pcUart1TxBuffer[UART1_RX_BUFFER_SIZE] = {'\0'};

unsigned int  g_uiUart1TxWriteIndex = 0;

unsigned int  g_uiUart1TxReadIndex = 0;


//*****************************************************************************
//
// UART1 interrupt handler rutines
//
//*****************************************************************************


void UART1_rxHandler(void)
{
    // set the flag to indicate that interrupts just occurred
    ge_tbUART1RXITFLAG = 1;
    // wake up the cpu
    _bis_SR_register(LPM0_bits);
    // disable receive interrupts..
    CLEAR_BIT(UC1IE,0);
    if(!UART1_RX_BUFFER_FULL){
        // get the last received byte from the UCA1RXBUF buffer and take into the g_pcUartRxBuffer
        g_pcUart1RxBuffer[g_uiUart1RxWriteIndex] = UCA1RXBUF;
        // increase the the RX buffer write pointer
        UART1_ADVANCE_RX_BUFFER_INDEX(g_uiUart1RxWriteIndex);
    }
    else{
        // TODO if the RX buffer is full
    }
    // enable receive interrupts
    SET_BIT(UC1IE,1);
}


// UART_uart1TxHandler

void UART1_txHandler(void)
{
    // wake up the cpu
    _bis_SR_register(LPM0_bits);
    // set the flag to indicate that interrupts just occurred
    ge_tbUART1TXITFLAG = 1;
}



//*****************************************************************************
//
// UART functions
//
//*****************************************************************************


void UART1_initUART1(void)
{
    P3OUT &= ~(BIT6+BIT7);
    // P3.6,7 = USCI_A1 TXD/RXD
    P3SEL = 0xC0;
    // CLK = ACLK
    UCA1CTL1 |= UCSSEL_1; 
    // 9600
    UCA1BR0 = 0x03;      // 32kHz/9600 = 3.41  
    // 9600                       
    UCA1BR1 = 0x00;
    // Modulation UCBRSx = 5
    UCA1MCTL = UCBRS1 + UCBRS0; // 
    // **Initialize USCI state machine**              
    UCA1CTL1 &= ~UCSWRST; 
    // Enable USCI_A1 RX interrupt                    
    UC1IE |= UCA1RXIE;
    // Enable USCI_A1 TX interrupt     
    UC1IE |= UCA1TXIE;  
    // Enable global interrupt
    _bis_SR_register(LPM3_bits + GIE);
    // set RX ISR callback function
    Interrupts_setUSCI1RX_ISRCallbackFunction(&UART1_rxHandler);
    // set TX ISR callback function;    
    Interrupts_setUSCI1TX_ISRCallbackFunction(&UART1_txHandler);              
}


void UART1_primeTransmit(void)
{
    // Do we have any data to transmit?   
    if ( !UART1_TX_BUFFER_EMPTY ){
        // Disable the UARTA1 interrupt. If we don't do this there is a race
        // condition which can cause the read index to be corrupted.
        CLEAR_BIT(UC1IE,1);
        // if is there space avaiable in the UCA1TXBUF in other words is the first bit of
        // the UC1IFG set and the tx buffer is still not empty ?
        while((TEST_BIT(UC1IFG,1)) && !UART1_TX_BUFFER_EMPTY){
            UCA1TXBUF = g_pcUart1TxBuffer[g_uiUart1TxReadIndex];
            UART1_ADVANCE_TX_BUFFER_INDEX(g_uiUart1TxReadIndex);
        }
        // reenable UARTA1 interrupt, set the third bit of the UC1IE vector
        SET_BIT(UC1IE,1);
    }
}


void UART1_setAppendResponseCallbackFunction(tpfUART1AppendResponseCallbackFunction pfCallbackAppendResponse)
{
    g_pfOnCallbackGPSAppendResponse = pfCallbackAppendResponse;
}


int UART1_read(void)
{
    char* pcTmpBuffer = (char*)calloc('\0',sizeof(char) * (UART1_RX_BUFFER_USED + 1));
    unsigned int uiUsage = UART1_RX_BUFFER_USED;  
    unsigned int uiAvail;
 
    if(!UART1_RX_BUFFER_EMPTY){
        
        for(uiAvail = 0; uiAvail < uiUsage; uiAvail++ ){
            
            pcTmpBuffer[uiAvail] = g_pcUart1RxBuffer[g_uiUart1RxReadIndex];
            UART1_ADVANCE_RX_BUFFER_INDEX(g_uiUart1RxReadIndex);
        }
        
        pcTmpBuffer[uiAvail] = '\0';
        // if callback is set
        if(g_pfOnCallbackGPSAppendResponse){
            
            g_pfOnCallbackGPSAppendResponse((const char*)pcTmpBuffer);
        }
    }   
    free(pcTmpBuffer);
    // return the number of the character read  
    return uiUsage;
}


int UART1_write(char* pcBuffer, unsigned int uiLength)
{
    unsigned int uiIdx;
    for( uiIdx = 0; uiIdx < uiLength; uiIdx++ ){
        if(!UART1_TX_BUFFER_FULL){
            g_pcUart1TxBuffer[g_uiUart1TxWriteIndex] = pcBuffer[uiIdx];
            UART1_ADVANCE_TX_BUFFER_INDEX(g_uiUart1TxWriteIndex);
        }
        else{
            // TODO if the tx buffer is full
        }
    }
    if(!UART1_TX_BUFFER_EMPTY){
        // send as many characters to the uart buffer as many can
        UART1_primeTransmit();
    }
    // return the number of the character written into the buffer
    return uiIdx;
}


void UART1_sendChar(void)
{
    // do we have anything to send in the buffer ?
    if(!UART1_TX_BUFFER_EMPTY){
        // Move as many bytes as we can into the tx buffer 
        UART1_primeTransmit();
    }  
    // If the output buffer is empty, turn off the transmit interrupt flag.
    else{
        // clear transmit interrupt flag (the first in the UC1IFG vector)
        CLEAR_BIT(UC1IFG,1);
    }
}


tBoolean UART1_isWritingDone(void)
{
    return ((UART1_TX_BUFFER_EMPTY) ? 1 : 0);
}


void UART1_flushRx(void)
{
    tBoolean tbIsInterruptEnabled = 0;
    // get the content of the sr register   
    unsigned int uiStatus = _get_SR_register();
    // is global interrupts enabled ?
    if(TEST_BIT(uiStatus,3)){
        tbIsInterruptEnabled = 1;
         // temporarily turn off interrupts.
        _disable_interrupts();
    }
    // flush the receive buffer.
    g_uiUart1RxWriteIndex = 0;
    g_uiUart1RxReadIndex = 0;
    // switch back interrupts
    if(tbIsInterruptEnabled){
        _enable_interrupts();
    }
}


void UART1_flushTx(void)
{
    tBoolean tbIsInterruptEnabled = 0;
    // get the content of the sr register   
    unsigned int uiStatus = _get_SR_register();
    // is global interrupts enabled ?
    if(TEST_BIT(uiStatus,3)){
        tbIsInterruptEnabled = 1;
         // temporarily turn off interrupts.
        _disable_interrupts();
    }
    // flusch the transmit buffer
    g_uiUart1TxWriteIndex = 0;
    g_uiUart1TxReadIndex = 0;
    // switch back interrupts
    if(tbIsInterruptEnabled){
        _enable_interrupts();
    }
}