UART2.c

Go to the documentation of this file.

#include "UART2.h"



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

tBoolean ge_tbUART2RXITFLAG = 0;

tBoolean ge_tbUART2TXITFLAG = 0;

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

tpfUART2AppendResponseCallbackFunction g_pfOnCallbackGPRSAppendResponse;

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

unsigned char g_pcUart2RxBuffer[UART2_RX_BUFFER_SIZE] = {'\0'};

unsigned int  g_uiUart2RxWriteIndex = 0;

unsigned int  g_uiUart2RxReadIndex = 0;

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


unsigned char g_pcUart2TxBuffer[UART2_RX_BUFFER_SIZE] = {'\0'};

unsigned int  g_uiUart2TxWriteIndex = 0;

unsigned int  g_uiUart2TxReadIndex = 0;


//*****************************************************************************
//
// UART2 interrupt handler rutines
//
//*****************************************************************************


void UART2_rxHandler(void)
{
    // set the flag to indicate that interrupts just occurred
    ge_tbUART2RXITFLAG = 1;
    // wake up the cpu
    _bis_SR_register(LPM0_bits);
    // disable receive interrupts..
    CLEAR_BIT(IE2,0);
    if(!UART2_RX_BUFFER_FULL){
        // get the last received byte from the UCA0RXBUF buffer and take into the g_pcUartRxBuffer
        g_pcUart2RxBuffer[g_uiUart2RxWriteIndex] = UCA0RXBUF;
        // increase the the RX buffer write pointer
        UART2_ADVANCE_RX_BUFFER_INDEX(g_uiUart2RxWriteIndex);
    }
    else{
        // TODO if the RX buffer is full
    }
    // enable receive interrupts
    SET_BIT(IE2,1);
}


// UART_uart1TxHandler

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



//*****************************************************************************
//
// UART2 functions
//
//*****************************************************************************


void UART2_initUART2(void)
{
    P3OUT &= ~(BIT4+BIT5);
    // P3.4,5 = USCI_A0 TXD/RXD
    P3SEL = 0x30;
    // CLK = ACLK
    UCA0CTL1 |= UCSSEL_0; 
    // 9600
    UCA0BR0 = 0x03;      // 32kHz/9600 = 3.41  
    // 9600                       
    UCA0BR1 = 0x00;
    // Modulation UCBRSx = 5
    UCA0MCTL = UCBRS1 + UCBRS0; // 
    // **Initialize USCI state machine**              
    UCA0CTL1 &= ~UCSWRST; 
    // Enable USCI_A1 RX interrupt                    
    IE2 |= UCA0RXIE;
    // Enable USCI_A1 TX interrupt     
    IE2 |= UCA0TXIE;  
    // Enable global interrupt
    _bis_SR_register(LPM3_bits + GIE);
    // set RX ISR callback function
    Interrupts_setUSCI0RX_ISRCallbackFunction(&UART2_rxHandler);
    // set TX ISR callback function;
    Interrupts_setUSCI0TX_ISRCallbackFunction(&UART2_txHandler);           
}


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


int UART2_read(void)
{
    char* pcTmpBuffer = (char*)calloc('\0',sizeof(char) * (UART2_RX_BUFFER_USED + 1));
    unsigned int uiUsage = UART2_RX_BUFFER_USED;  
    unsigned int uiAvail;
 
    if(!UART2_RX_BUFFER_EMPTY){
        
        for(uiAvail = 0; uiAvail < uiUsage; uiAvail++ ){
            
            pcTmpBuffer[uiAvail] = g_pcUart2RxBuffer[g_uiUart2RxReadIndex];
            UART2_ADVANCE_RX_BUFFER_INDEX(g_uiUart2RxReadIndex);
        }
        
        pcTmpBuffer[uiAvail] = '\0';
        // if callback is set
        if(g_pfOnCallbackGPRSAppendResponse){
            
            g_pfOnCallbackGPRSAppendResponse((const char*)pcTmpBuffer);
        }
    
    }   
    free(pcTmpBuffer);
    // return the number of the character read  
    return uiUsage;
}


int UART2_write(char* pcBuffer, unsigned int uiLength)
{
    unsigned int uiIdx;
    for( uiIdx = 0; uiIdx < uiLength; uiIdx++ ){
        if(!UART2_TX_BUFFER_FULL){
            g_pcUart2TxBuffer[g_uiUart2TxWriteIndex] = pcBuffer[uiIdx];
            UART2_ADVANCE_TX_BUFFER_INDEX(g_uiUart2TxWriteIndex);
        }
        else{
            // TODO if the tx buffer is full
        }
    }
    if(!UART2_TX_BUFFER_EMPTY){
        // send as many characters to the uart buffer as many can
        UART2_primeTransmit();
    }
    // return the number of the character written into the buffer
    return uiIdx;
}


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


tBoolean UART2_isWritingDone(void)
{
    return ((UART2_TX_BUFFER_EMPTY) ? 1 : 0);
}


void UART2_setAppendResponseCallbackFunction(tpfUART2AppendResponseCallbackFunction pfCallbackAppendResponse)
{
    g_pfOnCallbackGPRSAppendResponse = pfCallbackAppendResponse;
}


void UART2_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_uiUart2RxWriteIndex = 0;
    g_uiUart2RxReadIndex = 0;
    // switch back interrupts
    if(tbIsInterruptEnabled){
        _enable_interrupts();
    }
}


void UART2_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_uiUart2TxWriteIndex = 0;
    g_uiUart2TxReadIndex = 0;
    // switch back interrupts
    if(tbIsInterruptEnabled){
        _enable_interrupts();
    }
}