drivers/serial/uart0.c

Go to the documentation of this file.

/*********************************************************
* Project: Bootloader using gnu gcc 2.95.3
* Function: Uart0 driver
*
* File: uart0.c
* Author: Book Chen
* Date 20080822
***********************************************************
*/
#include "includes.h"

void F_Uart0Initial(void){
    // UART0 sfr initialize
    //******
    //rULCON0=0x00;   // uart line control register
    //rUCON0=0x00;    // uart control register
    //rUFCON0=0x00;   // uart FIFO control register
    //rUMCON0=0x00;   // uart cF_IsrTimer4hannel 0 moden control register
    //Data=UTRSTAT0;  // uart transmit receive status register
    //Data=rUERSTAT0; // uart error status register
    //Data=rUFSTAT0;  // uart fifo status
    //Data=rUMSTAT0;  // uart moden status register

    HandleUART0=(INT32U)F_IsrUart0;
    Uart0Ctrl.pUart0Register=(UART0_REGISTER *)0x50000000;
    Uart0Ctrl.pUart0Register->ULCON=0x00000003; // n.8.1
    Uart0Ctrl.pUart0Register->UCON=0x00000045;  // enable tx,rx 
    Uart0Ctrl.pUart0Register->UFCON=0x00000000;
    Uart0Ctrl.pUart0Register->UMCON=0x00000000;
    Uart0Ctrl.pUart0Register->UTRSTAT=0x00000006;
    Uart0Ctrl.pUart0Register->UBRDIV=((int)(50000000/(16.*19200)+0.5)-1); //set baudrae to 19200
    //Uart0Ctrl.pUart0Register->UERSTAT=0x00000000; // read only
    //Uart0Ctrl.pUart0Register->UFSTAT=0x00000000;  // read only
    //Uart0Ctrl.pUart0Register->UMSTAT=0x00000000;  // read only
    //Uart0Ctrl.pUart0Register->UTXH=0x00000000;    // write only
    //Uart0Ctrl.pUart0Register->URXH=0x00000000;    // read only
    //Uart0Ctrl.pUart0Register->UBRDIV=0x00000000;
    Uart0Ctrl.TxBuffer.Get=0;
    Uart0Ctrl.TxBuffer.Put=0;
    Uart0Ctrl.RxBuffer.Get=0;
    Uart0Ctrl.RxBuffer.Put=0;
    Uart0Ctrl.UartTxTransmit=0;
    //Uart0Ctrl.TxState=Uart0TxIdleState;
    //Uart0Ctrl.RxState=Uart0RxIdleState;
}
void F_Uart0BufferReset(void){
    Uart0Ctrl.TxBuffer.Get=0;
    Uart0Ctrl.TxBuffer.Put=0;
    Uart0Ctrl.RxBuffer.Get=0;
    Uart0Ctrl.RxBuffer.Put=0;
}
INT8U F_Uart0RxBufferCheck(void){
    if(Uart0Ctrl.RxBuffer.Put!=Uart0Ctrl.RxBuffer.Get){
        if(Uart0Ctrl.RxBuffer.Put==(UART0_MAX_BUFFER_SIZE-1)){
            if(Uart0Ctrl.RxBuffer.Get==0) return UART0_BUFFER_FULL;
            else return UART0_BUFFER_NOT_EMPTY;
        }
        else{
            if((Uart0Ctrl.RxBuffer.Put+1)==Uart0Ctrl.RxBuffer.Get) return UART0_BUFFER_FULL;
            else return UART0_BUFFER_NOT_EMPTY;
        }
    }
    else return UART0_BUFFER_EMPTY;
}
INT8U F_Uart0RxBufferCheckIsr(void){
    if(Uart0Ctrl.RxBuffer.Put!=Uart0Ctrl.RxBuffer.Get){
        if(Uart0Ctrl.RxBuffer.Put==(UART0_MAX_BUFFER_SIZE-1)){
            if(Uart0Ctrl.RxBuffer.Get==0) return UART0_BUFFER_FULL;
            else return UART0_BUFFER_NOT_EMPTY;
        }
        else{
            if((Uart0Ctrl.RxBuffer.Put+1)==Uart0Ctrl.RxBuffer.Get) return UART0_BUFFER_FULL;
            else return UART0_BUFFER_NOT_EMPTY;
        }
    }
    else return UART0_BUFFER_EMPTY;
}
void F_Uart0RxBufferPut(INT8U Data){
    if(F_Uart0RxBufferCheck()==UART0_BUFFER_FULL) return;
    if(Uart0Ctrl.RxBuffer.Put==(UART0_MAX_BUFFER_SIZE-1)){
        Uart0Ctrl.RxBuffer.Data[Uart0Ctrl.RxBuffer.Put]=Data;
        Uart0Ctrl.RxBuffer.Put=0;
    }
    else{
        Uart0Ctrl.RxBuffer.Data[Uart0Ctrl.RxBuffer.Put]=Data;
        Uart0Ctrl.RxBuffer.Put++;
    }
}
void F_Uart0RxBufferPutIsr(INT8U Data){
    if(F_Uart0RxBufferCheckIsr()==UART0_BUFFER_FULL) return;
    if(Uart0Ctrl.RxBuffer.Put==(UART0_MAX_BUFFER_SIZE-1)){
        Uart0Ctrl.RxBuffer.Data[Uart0Ctrl.RxBuffer.Put]=Data;
        Uart0Ctrl.RxBuffer.Put=0;
    }
    else{
        Uart0Ctrl.RxBuffer.Data[Uart0Ctrl.RxBuffer.Put]=Data;
        Uart0Ctrl.RxBuffer.Put++;
    }
}
INT8U F_Uart0RxBufferGet(void){
    INT8U Data;

    if(F_Uart0RxBufferCheck()==UART0_BUFFER_EMPTY) return 0;
    if(Uart0Ctrl.RxBuffer.Get==(UART0_MAX_BUFFER_SIZE-1)){
        Data=Uart0Ctrl.RxBuffer.Data[Uart0Ctrl.RxBuffer.Get];
        Uart0Ctrl.RxBuffer.Get=0;
    }
    else{
        Data=Uart0Ctrl.RxBuffer.Data[Uart0Ctrl.RxBuffer.Get];
        Uart0Ctrl.RxBuffer.Get++;
    }
    return Data;
}
INT8U F_Uart0TxBufferCheckIsr(void){
    if(Uart0Ctrl.TxBuffer.Put!=Uart0Ctrl.TxBuffer.Get){
        if(Uart0Ctrl.TxBuffer.Put==(UART0_MAX_BUFFER_SIZE-1)){
            if(Uart0Ctrl.TxBuffer.Get==0) return UART0_BUFFER_FULL;
            else return UART0_BUFFER_NOT_EMPTY;
        }
        else{
            if((Uart0Ctrl.TxBuffer.Put+1)==Uart0Ctrl.TxBuffer.Get) return UART0_BUFFER_FULL;
            else return UART0_BUFFER_NOT_EMPTY;
        }
    }
    else return UART0_BUFFER_EMPTY;
}
INT8U F_Uart0TxBufferCheck(void){
    if(Uart0Ctrl.TxBuffer.Put!=Uart0Ctrl.TxBuffer.Get){
        if(Uart0Ctrl.TxBuffer.Put==(UART0_MAX_BUFFER_SIZE-1)){
            if(Uart0Ctrl.TxBuffer.Get==0) return UART0_BUFFER_FULL;
            else return UART0_BUFFER_NOT_EMPTY;
        }
        else{
            if((Uart0Ctrl.TxBuffer.Put+1)==Uart0Ctrl.TxBuffer.Get) return UART0_BUFFER_FULL;
            else return UART0_BUFFER_NOT_EMPTY;
        }
    }
    else return UART0_BUFFER_EMPTY;
}
void F_Uart0TxBufferPut(INT8U Data){
    if(F_Uart0TxBufferCheck()==UART0_BUFFER_FULL) return; 
    if(Uart0Ctrl.TxBuffer.Put==(UART0_MAX_BUFFER_SIZE-1)){
        Uart0Ctrl.TxBuffer.Data[Uart0Ctrl.TxBuffer.Put]=Data;
        Uart0Ctrl.TxBuffer.Put=0;
    }
    else{
        Uart0Ctrl.TxBuffer.Data[Uart0Ctrl.TxBuffer.Put]=Data;
        Uart0Ctrl.TxBuffer.Put++;
    }
}
INT8U F_Uart0TxBufferGet(void){
    INT8U Data;

    if(F_Uart0TxBufferCheck()==UART0_BUFFER_EMPTY) return 0; 
    if(Uart0Ctrl.TxBuffer.Get==(UART0_MAX_BUFFER_SIZE-1)){
        Data=Uart0Ctrl.TxBuffer.Data[Uart0Ctrl.TxBuffer.Get];
        Uart0Ctrl.TxBuffer.Get=0;
    }
    else{
        Data=Uart0Ctrl.TxBuffer.Data[Uart0Ctrl.TxBuffer.Get];
        Uart0Ctrl.TxBuffer.Get++;
    }
    return Data;
}
INT8U F_Uart0TxBufferGetIsr(void){
    INT8U Data;

    if(F_Uart0TxBufferCheckIsr()==UART0_BUFFER_EMPTY) return 0; 
    if(Uart0Ctrl.TxBuffer.Get==(UART0_MAX_BUFFER_SIZE-1)){
        Data=Uart0Ctrl.TxBuffer.Data[Uart0Ctrl.TxBuffer.Get];
        Uart0Ctrl.TxBuffer.Get=0;
    }
    else{
        Data=Uart0Ctrl.TxBuffer.Data[Uart0Ctrl.TxBuffer.Get];
        Uart0Ctrl.TxBuffer.Get++;
    }
    return Data;
}
void F_Uart0BaudrateSet(INT32U Baudrate){
    Uart0Ctrl.pUart0Register->UBRDIV =50000000/(16*Baudrate); // gcc no support floating calculate
    //Uart0Ctrl.pUart0Register->UBRDIV =(INT32U)(((50000000/(16.0*Baudrate))+0.5)-1);
}
void F_Uart0IsrHook(void){
    INT8U Data;

    ClearSubPending(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
    ClearPending(BIT_UART0);
    if(rUTRSTAT0&UART0_UTRSTAT0_TX){  // tx int
        /*if(F_Uart0TxBufferCheckIsr()==UART0_BUFFER_EMPTY){
            Uart0Ctrl.UartTxTransmit=0;
        }
        else{
            Data=F_Uart0TxBufferGetIsr();
            SERIAL_WRITE_CHAR(Data);
        }*/
        Uart0Ctrl.UartTxTransmit=0;
    }
    if(rUTRSTAT0&UART0_UTRSTAT0_RX){  // rx int
        Data=SERIAL_READ_CHAR();
        F_Uart0RxBufferPutIsr(Data);
    }
    if(rUERSTAT0&0x0f){
        //F_Uart0RxError();           // error int
    }
}

void F_Uart0CharTx(INT8 Data){
    //while(F_Uart0RxBufferCheck()==UART0_BUFFER_FULL); // wait if beffer full
    F_Uart0TxBufferPut((INT8U)Data);
}
INT8 F_Uart0RxCheck(void){
    if(F_Uart0RxBufferCheck()!=UART0_BUFFER_EMPTY) return TRUE;
    else return FALSE;
}
INT8 F_Uart0CharRx(void){
    INT8U Data;

    if(F_Uart0RxBufferCheck()!=UART0_BUFFER_EMPTY){
        Data=F_Uart0RxBufferGet();
        return (INT8)Data;
    }
    return 0;
}
void F_Uart0StringTx(INT8 *pString){
    while(*pString!=0) F_Uart0CharTx(*pString++);
}

INT8 kbhit(void){
    if(F_Uart0RxCheck()==TRUE) return 1;
    else return 0;
}
INT8 getkey(void){
    INT8 Data;

    Data=F_Uart0CharRx(); // Data==0...key not exist
    return Data;
}
INT8 getc(void){
    INT8 key;

    while(1){
        key=getkey();
        if(key!=0) return key;
        F_Uart0Svc();     // receive uart data using polling mode
    }
}
void putc(INT8 Data){
    F_Uart0CharTx(Data);
}
char putch(INT8 Data){
    F_Uart0CharTx(Data);
    return Data;
}
void puts(INT8 *pString){
    F_Uart0StringTx(pString);
}
INT8 getch(void){
    INT8 key;

    while(1){
        key=getkey();
        if(key!=0) return key;
        F_Uart0Svc();     // receive uart data using polling mode
    }
}
INT32 strlen(const char *String){
    INT32U Length;

    Length=0;
    for(;*String!=0;String++) Length++;
    return Length;
}

void F_StringPut(const char *String){
    //putnstr(String, strlen(String));
}

void F_Uart0Svc2(void){
    INT8U Data;
    INT32U Status;

    if(SERIAL_READ_READY()){
        Data=SERIAL_READ_CHAR();
        Status=SERIAL_READ_STATUS();
        F_Uart0RxBufferPut(Data);
    }
    if(F_Uart0TxBufferCheck()!=UART0_BUFFER_EMPTY){
        if(SERIAL_WRITE_READY()==0) return;
        Data=F_Uart0TxBufferGet();
        SERIAL_WRITE_CHAR(Data);
    }
}

void F_Uart0Svc(void){
    INT8U Data;

    if(Uart0Ctrl.UartTxTransmit==1) return;
    if(F_Uart0TxBufferCheck()==UART0_BUFFER_EMPTY) return;;
    Data=F_Uart0TxBufferGet();
    Uart0Ctrl.UartTxTransmit=1;
    SERIAL_WRITE_CHAR(Data);
}

---