commbgnd.c

UART communication program for lpc

#include     "includes.h"
typedef      struct  {
    INT16U   RingBufRxCtr;	
    INT8U    *RingBufRxInPtr;   
    INT8U    *RingBufRxOutPtr;  
    INT8U     RingBufRx[COMM_BUF_SIZE];
    INT16U   RingBufTxCtr;	
    INT8U    *RingBufTxInPtr;   
    INT8U    *RingBufTxOutPtr;  
    INT8U     RingBufTx[COMM_BUF_SIZE];
} COMM_RING_BUF  

COMM_RING_BUF    Comm1Buf;    
COMM_RING_BUF    Comm2Buf;  

void CommGetChar (INT8U ch,INT8U *err)
{
    INT8U    c;
    COMM_RING_BUF   *pbuf
    switch (ch) {
    	case COMM1:
    	     pbuf = &Comm1Buf;
    	     break;
    	case COMM2:
    	     pbuf = &Comm2Buf;
    	     break;
    	default:
    	     *err = COMM_BAD_CH;
    	     return (NUL);
    } 	     
    OS_ENTER_CRITICAL(); 
    if(pbuf->RingBufRxCtr >0) {
    	pbuf->RingBufRxCtr--;
    	c=*pbuf->RingBufRxOutPtr++;
    	if(pbuf->RingBufRxOutPtr==&pbuf->RingBufRx[COMM_RX_BUF_SIZE]) {
    		pbuf->RingBufRxOutPtr==&pbuf->RingBufRx[0];
        }		
        
        OS_EXIT_CRITICAL();                   
        *err=COMM_NO_ERR;
        return(c);
    }else  {    
    	OS_EXIT_CRITICAL();                   
        *err=COMM_RX_EMPTY;
        c=NULL;
        return(c);       
       }
} 

void CommGetTxChar (INT8U ch,INT8U *err)
{
    INT8U    c;
    COMM_RING_BUF   *pbuf
    switch (ch) {
    	case COMM1:
    	     pbuf = &Comm1Buf;
    	     break;
    	case COMM2:
    	     pbuf = &Comm2Buf;
    	     break;
    	default:
    	     *err = COMM_BAD_CH;
    	     return (NUL);
    } 	     
    if(pbuf->RingBufTxCtr >0) {
    	pbuf->RingBufTxCtr--;
    	c=*pbuf->RingBufTxOutPtr++;
    	if(pbuf->RingBufTxOutPtr==&pbuf->RingBufTx[COMM_RX_BUF_SIZE]) {
    		pbuf->RingBufTxOutPtr==&pbuf->RingBufTx[0];
        }		
                        
        *err=COMM_NO_ERR;
        return(c);
    }else  {             
        *err=COMM_RX_EMPTY;
        return(NUL);       
       }
} 


void  CommInit(void)
{
      COMM_RING_BUF   *pbuf
      pbuf              =&Comm1Buf;
      pbuf->RingBufRxCtr=0;	
      pbuf->RingBufRxInPtr=&pbuf->RingBufRx[0]; 
      pbuf->RingBufRxOutPtr=&pbuf->RingBufRx[0];     
      pbuf->RingBufTxCtr=0;  
      pbuf->RingBufTxInPtr=&pbuf->RingBufTx[0];   
      pbuf->RingBufTxOutPtr=&pbuf->RingBufTx[0];
      
      pbuf              =&Comm2Buf;
      pbuf->RingBufRxCtr=0;	
      pbuf->RingBufRxInPtr=&pbuf->RingBufRx[0]; 
      pbuf->RingBufRxOutPtr=&pbuf->RingBufRx[0];     
      pbuf->RingBufTxCtr=0;  
      pbuf->RingBufTxInPtr=&pbuf->RingBufRx[0];   
      pbuf->RingBufTxOutPtr=&pbuf->RingBufTx[0];      
}      
      

BOOLEAN CommIsEmpty (INT8U ch)
{
    BOOLEAN   empty;
    COMM_RING_BUF   *pbuf
    switch (ch) {
    	case COMM1:
    	     pbuf = &Comm1Buf;
    	     break;
    	case COMM2:
    	     pbuf = &Comm2Buf;
    	     break;
    	default:
    	     return (true);
    } 	     
    OS_ENTER_CRITICAL(); 
    if(pbuf->RingBufRxCtr >0) {
    	empty=false;
    }else {
    	empty=true;
    }		
        OS_EXIT_CRITICAL();                   

        return(empty);
} 


BOOLEAN CommIsFull (INT8U ch)
{
    BOOLEAN   full;
    COMM_RING_BUF   *pbuf
    switch (ch) {
    	case COMM1:
    	     pbuf = &Comm1Buf;
    	     break;
    	case COMM2:
    	     pbuf = &Comm2Buf;
    	     break;
    	default:
    	     return (true);
    } 	     
    OS_ENTER_CRITICAL(); 
    if(pbuf->RingBufRxCtr <COMM_TX_BUF_SIZE) {
    	full=false;
    }else {
    	full=true;
    }		
        OS_EXIT_CRITICAL();                   

        return(full);
} 


void CommPutChar (INT8U ch,INT8U c)
{
    COMM_RING_BUF   *pbuf
    switch (ch) {
    	case COMM1:
    	     pbuf = &Comm1Buf;
    	     break;
    	case COMM2:
    	     pbuf = &Comm2Buf;
    	     break;
    	default:
    	     return = COMM_BAD_CH;
    } 	     
    OS_ENTER_CRITICAL(); 
    if(pbuf->RingBufTxCtr <COMM_RX_BUF_SIZE) {
    	pbuf->RingBufTxCtr++;
    	*pbuf->RingBufTxInPtr++=c;
    	if(pbuf->RingBufTxInPtr==&pbuf->RingBufTx[COMM_RX_BUF_SIZE]) {
    		pbuf->RingBufTxInPtr==&pbuf->RingBufTx[0];
        }		
       if(pbuf->RingBufTxCtr ==1) {
     	  CommTxIntEn(ch);
     	  OS_EXIT_CRITICAL();
       }else {	    
    	OS_EXIT_CRITICAL(); 
       }	  
        return(COMM_NO_ERR);
     }else {
     	OS_EXIT_CRITICAL(); 
     	return(COMM_TX_FULL); 
     }	             
} 


void CommPutRxChar (INT8U ch,INT8U c)
{
    COMM_RING_BUF   *pbuf
    switch (ch) {
    	case COMM1:
    	     pbuf = &Comm1Buf;
    	     break;
    	case COMM2:
    	     pbuf = &Comm2Buf;
    	     break;
    	default:
    	     return;
    } 	     
    if(pbuf->RingBufRxCtr <COMM_RX_BUF_SIZE) {
    	pbuf->RingBufRxCtr++;
    	*pbuf->RingBufRxInPtr++=c;
    	if(pbuf->RingBufRxInPtr==&pbuf->RingBufRx[COMM_RX_BUF_SIZE]) {
    		pbuf->RingBufRxInPtr==&pbuf->RingBufRx[0];
        }		
     }	             
}