mx21_uart2.c

MX21_InitCodeLib.rar freescale mx21系列ARM芯片9328的WINCE5.0下初始化代码

/**********************************************************************
*
*         (C) COPYRIGHT 2004 FREESCALE, INC.
*         ALL RIGHTS RESERVED
*
*
*     Group/Division:  WMSG/MMDO
*
*     Description:
*
*     Related Specifications:
*
*     Errata:
*
*     File Name:        MX21_UART2.h
*     Revision Number:  0.1
*     Author(s):        Ryan Johnson
*     Date created:     12 June 2004
*     Revision History:
*        Date      Rev     Description
*        ----      ---     -----------
*        12June04  0.1     First draft
*
**********************************************************************/

#include "MX21_UART2.h"
#include "MX21_CRM.h"


#define STR_LEN 49
static uint8_t uart2_Demo_message[STR_LEN]="The UART is transmitting this string to itself.\0";
static p_uint8_t uart2_p_Demo_message=uart2_Demo_message;


#if DEMO
void
uart2_Demo(void){

uint8_t i;
uint32_t c[50];

 printf("\n");
 
 // soft reset the UART and wait till
 // the reset state is over
 uart2_SoftReset();
 while(Disable != uart2_SoftResetStatus());

 // enable TX->RX loop
 UART2_UTS.bits.LOOP = Enable;
 
 // enable UART, Transmitter, Receiver
 uart2_EN(Enable);  
 uart2_Tx(Enable);
 uart2_Rx(Enable);
 
 // ignore the RTS pin
 uart2_RTS_Ignore(Enable);
 
 // CTS pin pin is controlled
 // by the receiver and not using
 // the CTS bit
 uart2_CTS_Automatic(Enable);
 
 // stop bits = 1
 uart2_ExtraStopBit(Disable);
 
 // disable parity checking
 uart2_Parity(Disable);
 
 // set character width=8
 uart2_CharacterWidth(_8bitUART);
 
 uart2_RxSetMux();
 
 // set TX, RX FIFO levels
 uart2_RxFIFO_TriggerLevel(1);
 uart2_TxFIFO_TriggerLevel(1);
 
 // sets up the RFDIV, UBIR and UBRM registers 
 uart2_AutoBRMFast(56000);
 
 // debug statements
 PRINTF (" The value of UART2_UCR1 is 0x%x\n", UART2_UCR1.all);
 PRINTF (" The value of UART2_UCR2 is 0x%x\n", UART2_UCR2.all);
 PRINTF (" The value of UART2_UCR3 is 0x%x\n", UART2_UCR3.all);
 PRINTF (" The value of UART2_UCR4 is 0x%x\n", UART2_UCR4.all);
 PRINTF (" The value of UART2_UFCR is 0x%x\n", UART2_UFCR.all);
 PRINTF (" The value of UART2_UTS is 0x%x\n", UART2_UTS.all);
 PRINTF (" The value of UART2_UBIR is 0x%x\n", UART2_UBIR.all);
 PRINTF (" The value of UART2_UBMR is 0x%x\n", UART2_UBMR.all);

 // transmit the user string, one 
 // character at a time   
 for(i=0;i< STR_LEN;i++){
  	if(uart2_TxFIFO_Ready()) 
 	{
 		uart2_TxCharacter(*uart2_p_Demo_message);
 		uart2_p_Demo_message+=1;  			
 	} 	
 	while (1 != uart2_RxFIFO_Ready()) ;
 		c[i] = uart2_RxCharacter() & 0xFF ;
 }
 
 for (i=0; i < STR_LEN; i++) 
 {
 	//if ((uint8_t)(c[i]) == uart2_p_Demo_message[i]) 
 	//{
 		printf("%c", c[i]);	
 	//}
 	//else 
 	//{
 	//	printf("UART2 test fails\n");
 	//	return;
 	//}
 }
 printf("\n UART2 test case passes\n");
 return;
} 

#endif


void
uart2_DemoInterruptHandler(void){
 uint8_t i;
 
 //TxFIFO ready for data
 if(uart2_TxFIFO_Ready() && UART2_UCR1.bits.TRDYEN){
  for(i=0;i<16;i+=1){
   if(*uart2_p_Demo_message == 0){
    i=16;
    uart2_TxFIFO_ReadyInterrupt(Disable);
   }
   uart2_TxCharacter(*uart2_p_Demo_message);
   uart2_p_Demo_message+=1;
  } 
  uart2_TxFIFO_EmptyInterrupt(Enable);
 } else
 
 //RxFIFO ready for read
 if(uart2_RxFIFO_TriggerReady() && UART2_UCR1.bits.RRDYEN){
  while(uart2_RxFIFO_Ready()){
   i=uart2_RxCharacter();
   if(i){
    printf("%c",i);
   } else {
    printf("\n");
    uart2_RxFIFO_TriggerReadyInterrupt(Disable);
    uart2_Rx(Disable);
    break;
   }
  } 
 } else
 
 //TxFIFO empty
 if(uart2_TxFIFO_EmptyFlag() && UART2_UCR1.bits.TXMPTYEN){
  uart2_TxFIFO_EmptyInterrupt(Disable);
  uart2_Tx(Disable);
 }

 return;
}

//AutoBRMFast
uint32_t
uart2_AutoBRMFast(uint32_t FREQ){
// ufloat32_t _RATIO;
 float _RATIO;
 uint32_t _RFDIV, _NUM, _PERCLK1 = pllclk_PERCLK1_Frequency();
 
 if(16*FREQ > _PERCLK1){
  return 0;
 }

 _RFDIV = _PERCLK1/(16*FREQ); 
 if(_RFDIV>7){
  _RFDIV=7;
 }
 _RATIO=16.0*FREQ*_RFDIV/_PERCLK1;;
 _NUM=65536*_RATIO;
 
 if(abs(FREQ - _PERCLK1/(16.0*_RFDIV)*_NUM/65536) > 
    abs(_PERCLK1/(16.0*_RFDIV)*(_NUM + 1)/65536 - FREQ)){
  _NUM+=1;
 }
 
 uart2_ReferenceFrequencyDivider(_RFDIV);
 uart2_BRMNumerator(_NUM-1);
 uart2_BRMDenominator(65535);
 _NUM=_PERCLK1/(16.0*_RFDIV)*_NUM/65536;
 return _NUM;
}

//AutoBRMPrecise
// FIX ME
// particularly, write me
uint32_t
uart2_AutoBRMPrecise(uint32_t FREQ){
 return 0;
}

//RxCharacterReady
 uint32_t
uart2_RxCharacterReady(void)
{
 return UART2_URXD.bits.CHARRDY;
}


//RxCharacterClean
 uint32_t
uart2_RxCharacterClean(void)
{
 return UART2_URXD.bits.ERR;
}


//RxFIFO_OverrunError
 uint32_t
uart2_RxFIFO_OverrunError(void)
{
 return UART2_URXD.bits.OVRRUN;
}


//RxFrameError
 uint32_t
uart2_RxFrameError(void)
{
 return UART2_URXD.bits.FRMERR;
}


//RxBreakDetect
 uint32_t
uart2_RxBreakDetect(void)
{
 return UART2_URXD.bits.BRK;
}


//RxParityError
 uint32_t
uart2_RxParityError(void)
{
 return UART2_URXD.bits.PRERR;
}


//RxCharacter
 uint32_t
uart2_RxCharacter(void)
{
 return UART2_URXD.all;
}


//TxCharacter
 void
uart2_TxCharacter(uint32_t TX_DATA)
{
 //UART2_UTXD.bits.TX_DATA= (uint8_t)TX_DATA;
 UART2_UTXD.all=TX_DATA;
}


//AutoBaudInterrupt
 void
uart2_AutoBaudInterrupt(uint32_t EN)
{
 uart2_AutoBaudCompleteFlag();
 UART2_UCR1.bits.ADEN=EN;
}


//AutoBaud
 void
uart2_AutoBaud(uint32_t EN)
{
 UART2_UCR1.bits.ADBR=EN;
 uart2_AutoBaudCompleteFlag();
}


//TxFIFO_ReadyInterrupt
 void
uart2_TxFIFO_ReadyInterrupt(uint32_t EN)
{
 UART2_UCR1.bits.TRDYEN=EN;
}


//RxIdleDetectInterrupt
 void
uart2_RxIdleDetectInterrupt(uint32_t EN)
{
 UART2_UCR1.bits.IDEN=EN;
}


//RxIdleLength
 void
uart2_RxIdleLength(uint32_t LENGTH)
{
 UART2_UCR1.bits.ICD=LENGTH;
}


//RxFIFO_TriggerReadyInterrupt
 void
uart2_RxFIFO_TriggerReadyInterrupt(uint32_t EN)
{
 UART2_UCR1.bits.RRDYEN=EN;
}


//RxFIFO_TriggerReadyDMA
 void
uart2_RxFIFO_TriggerReadyDMA(uint32_t EN)
{
 UART2_UCR1.bits.RXDMAEN=EN;
}


//IR
 void
uart2_IR(uint32_t EN)
{
 UART2_UCR1.bits.IREN=EN;
}


//TxFIFO_EmptyInterrupt
 void
uart2_TxFIFO_EmptyInterrupt(uint32_t EN)
{
 UART2_UCR1.bits.TXMPTYEN=EN;
}


//RTS_DeltaInterrupt
 void
uart2_RTS_DeltaInterrupt(uint32_t EN)
{
 UART2_UCR1.bits.RTSDEN=EN;
}


//TxBreak
 void
uart2_TxBreak(uint32_t EN)
{
 UART2_UCR1.bits.SNDBRK=EN;
}


//TxFIFO_ReadyDMA
 void
uart2_TxFIFO_ReadyDMA(uint32_t EN)
{
 UART2_UCR1.bits.TXDMAEN=EN;
}


//EN
 void
uart2_EN(uint32_t EN)
{
 UART2_UCR1.bits.UARTEN=EN;
}


//RxEscapeInterrupt
 void
uart2_RxEscapeInterrupt(uint32_t EN)
{
 UART2_UCR2.bits.ESCI=EN;
}


//RTS_Ignore
 void
uart2_RTS_Ignore(uint32_t EN)
{
 UART2_UCR2.bits.IRTS=EN;
}


//CTS_Automatic
 void
uart2_CTS_Automatic(uint32_t EN)
{
 UART2_UCR2.bits.CTSC=EN;
}


//CTS_Deassert
 void
uart2_CTS_Deassert(void)
{
 UART2_UCR2.bits.CTS=0;
}


//CTS_Assert
 void
uart2_CTS_Assert(void)
{
 UART2_UCR2.bits.CTS=1;
}


//RxEscapeDetect
 void
uart2_RxEscapeDetect(uint32_t EN)
{
 UART2_UCR2.bits.ESCEN=EN;
}


//RTS_EdgeControl
 void
uart2_RTS_EdgeControl(uint32_t EDGE)
{
 // FIX ME
 UART2_UCR2.bits.RTEC=EDGE;
}


//Parity
 void
uart2_Parity(uint32_t EN)
{
 UART2_UCR2.bits.PREN=EN;
}


//ParityType
 void
uart2_ParityType(uint32_t PARITY)
{
 UART2_UCR2.bits.PROE=PARITY;
}


//ExtraStopBit
 void
uart2_ExtraStopBit(uint32_t EN)
{
 UART2_UCR2.bits.STPB=EN;
}


//CharacterWidth
 void
uart2_CharacterWidth(uint32_t WIDTH)
{
 UART2_UCR2.bits.WS=WIDTH;
}


//RTS_EdgeInterrupt
 void
uart2_RTS_EdgeInterrupt(uint32_t EN)
{
 UART2_UCR2.bits.RTSEN=EN;
}


//AgingCharacterDetectInterrupt
 void
uart2_AgingCharacterDetectInterrupt(uint32_t EN)
{
 UART2_UCR2.bits.ATEN=EN;
}


//Tx
 void
uart2_Tx(uint32_t EN)
{
 UART2_UCR2.bits.TXEN=EN;
}


//Rx
 void
uart2_Rx(uint32_t EN)
{
 UART2_UCR2.bits.RXEN=EN;
}


//SoftReset
 void
uart2_SoftReset(void)
{
 UART2_UCR2.bits.SRST=0;
}


//RxParityErrorInterrupt
 void
uart2_RxParityErrorInterrupt(uint32_t EN)
{
 UART2_UCR3.bits.PARERREN=EN;
}


//RxFrameErrorInterrupt
 void
uart2_RxFrameErrorInterrupt(uint32_t EN)
{
 UART2_UCR3.bits.FRAERREN=EN;
}


//RxIdleStatusInterrupt
 void
uart2_RxIdleStatusInterrupt(uint32_t EN)
{
 UART2_UCR3.bits.RXDSEN=EN;
}


//IR_AsyncWakeInterrupt
 void
uart2_IR_AsyncWakeInterrupt(uint32_t EN)
{
 UART2_UCR3.bits.AIRINTEN=EN;
}


//AsyncWakeInterrupt
 void
uart2_AsyncWakeInterrupt(uint32_t EN)
{
 UART2_UCR3.bits.AWAKEN=EN;
}


//RxSetMux
 void
uart2_RxSetMux(void)
{
 UART2_UCR3.bits.RXDMUXSEL=1;
}

//IR_TxInvert
 void
uart2_IR_TxInvert(uint32_t EN)
{
 UART2_UCR3.bits.INVT=EN;
}


//AutoBaudCounterStoppedInterrupt
 void
uart2_AutoBaudCounterStoppedInterrupt(uint32_t EN)
{
 UART2_UCR3.bits.ACIEN=EN;
}

//CTS_TriggerLevel
 void
uart2_CTS_TriggerLevel(uint32_t CTSTL)
{
 UART2_UCR4.bits.CTSTL=CTSTL;
 return;
}


//IR_RxInvert
 void
uart2_IR_RxInvert(uint32_t EN)
{
 UART2_UCR4.bits.INVR=EN;
}


//IR_Interrupt
 void
uart2_IR_Interrupt(uint32_t EN)
{
 UART2_UCR4.bits.ENIRI=EN;
}


//WakeInterrupt
 void
uart2_WakeInterrupt(uint32_t EN)
{
 UART2_UCR4.bits.WKEN=EN;
}


//IR_SamplingClock
 void
uart2_IR_SamplingClock(uint32_t SCLOCK)
{
 UART2_UCR4.bits.IRSC=SCLOCK;
}


//TxCompleteInterrupt
 void
uart2_TxCompleteInterrupt(uint32_t EN)
{
 UART2_UCR4.bits.TCEN=EN;
}


//RxBreakDetectInterrupt
 void
uart2_RxBreakDetectInterrupt(uint32_t EN)
{
 UART2_UCR4.bits.BKEN=EN;
}


//RxFIFO_OverrunErrorInterrupt
 void
uart2_RxFIFO_OverrunErrorInterrupt(uint32_t EN)
{
 UART2_UCR4.bits.OREN=EN;
}


//TxFIFO_TriggerLevel
 void
uart2_TxFIFO_TriggerLevel(uint32_t TXTL)
{
 UART2_UFCR.bits.TXTL=TXTL;
 return;
}


//ReferenceFrequencyDivider
 void
uart2_ReferenceFrequencyDivider(uint32_t RFDIV)
{
 RFDIV&=7;
 if(RFDIV==7)
 {
  RFDIV=6;
 } else {
  RFDIV=6-RFDIV;
 }
 UART2_UFCR.bits.RFDIV=RFDIV;
}



//RxFIFO_TriggerLevel
 void
uart2_RxFIFO_TriggerLevel(uint32_t RXTL)
{
 UART2_UFCR.bits.RXTL=RXTL;
 return;
}


//RxParityErrorFlag
 uint32_t
uart2_RxParityErrorFlag(void)
{
 uint32_t _flag=UART2_USR1.bits.PARITYERR;
 if (_flag){
  UART2_USR1.bits.PARITYERR=1;
 }
 return _flag;
}


//RTS_Status
 uint32_t
uart2_RTS_Status(void)
{
 return UART2_USR1.bits.RTSS;
}


//TxFIFO_Ready
 uint32_t
uart2_TxFIFO_Ready(void)
{
 return UART2_USR1.bits.TRDY;
}


//RTS_DeltaFlag
 uint32_t
uart2_RTS_DeltaFlag(void)
{
 uint32_t _flag=UART2_USR1.bits.RTSD;
 if (_flag){
  UART2_USR1.bits.RTSD=1;
 }
 return _flag;
}


//RxEscapeFlag
 uint32_t
uart2_RxEscapeFlag(void)
{
 uint32_t _flag=UART2_USR1.bits.ESCF;
 if (_flag){
  UART2_USR1.bits.ESCF=1;
 }
 return _flag;
}


//RxFrameErrorFlag
 uint32_t
uart2_RxFrameErrorFlag(void)
{
 uint32_t _flag=UART2_USR1.bits.FRAMERR;
 if (_flag){
  UART2_USR1.bits.FRAMERR=1;
 }
 return _flag;
}


//RxFIFO_TriggerReady
 uint32_t
uart2_RxFIFO_TriggerReady(void)
{
 return UART2_USR1.bits.RRDY;
}


//AgingCharacterDetectFlag
 uint32_t
uart2_AgingCharacterDetectFlag(void)
{
 uint32_t _flag=UART2_USR1.bits.AGTIM;
 if (_flag){
  UART2_USR1.bits.AGTIM=1;
 }
 return _flag;
}


//RxIdleStatus
 uint32_t
uart2_RxIdleStatus(void)
{
 return UART2_USR1.bits.RXDS;
}


//IR_AsyncWakeFlag
 uint32_t
uart2_IR_AsyncWakeFlag(void)
{
 uint32_t _flag=UART2_USR1.bits.AIRINT;
 if (_flag){
  UART2_USR1.bits.AIRINT=1;
 }
 return _flag;
}


//AsyncWakeFlag
 uint32_t
uart2_AsyncWakeFlag(void)
{
 uint32_t _flag=UART2_USR1.bits.AWAKE;
 if (_flag){
  UART2_USR1.bits.AWAKE=1;
 }
 return _flag;
}


//AutoBaudCompleteFlag
 uint32_t
uart2_AutoBaudCompleteFlag(void)
{
 uint32_t _flag=UART2_USR2.bits.ADET;
 if (_flag){
  UART2_USR2.bits.ADET=1;
 }
 return _flag;
}


//TxFIFO_EmptyFlag
 uint32_t
uart2_TxFIFO_EmptyFlag(void)
{
 return UART2_USR2.bits.TXFE;
}


//RxIdleDetectFlag
 uint32_t
uart2_RxIdleDetectFlag(void)
{
 uint32_t _flag=UART2_USR2.bits.IDLE;
 if (_flag){
  UART2_USR2.bits.IDLE=1;
 }
 return _flag;
}


//AutoBaudCounterStoppedFlag
 uint32_t
uart2_AutoBaudCounterStoppedFlag(void)
{
 uint32_t _flag=UART2_USR2.bits.ACST;
 if (_flag){
  UART2_USR2.bits.ACST=1;
 }
 return _flag;
}


//IR_Flag
 uint32_t
uart2_IR_Flag(void)
{
 uint32_t _flag=UART2_USR2.bits.IRINT;
 if (_flag){
  UART2_USR2.bits.IRINT=1;
 }
 return _flag;
}


//WakeFlag
 uint32_t
uart2_WakeFlag(void)
{
 uint32_t _flag=UART2_USR2.bits.WAKE;
 if (_flag){
  UART2_USR2.bits.WAKE=1;
 }
 return _flag;
}


//RTS_EdgeFlag
 uint32_t
uart2_RTS_EdgeFlag(void)
{
 uint32_t _flag=UART2_USR2.bits.RTSF;
 if (_flag){
  UART2_USR2.bits.RTSF=1;
 }
 return _flag;
}


//TxComplete
 uint32_t
uart2_TxComplete(void)
{
 return UART2_USR2.bits.TXDC;
}


//RxBreakDetectFlag
 uint32_t
uart2_RxBreakDetectFlag(void)
{
 uint32_t _flag=UART2_USR2.bits.BRCD;
 if (_flag){
  UART2_USR2.bits.BRCD=1;
 }
 return _flag;
}


//RxFIFO_OverrunErrorFlag
 uint32_t
uart2_RxFIFO_OverrunErrorFlag(void)
{
 uint32_t _flag=UART2_USR2.bits.ORE;
 if (_flag){
  UART2_USR2.bits.ORE=1;
 }
 return _flag;
}


//RxFIFO_Ready
 uint32_t
uart2_RxFIFO_Ready(void)
{
 return UART2_USR2.bits.RDR;
}


//RxEscapeCharacter
 void
uart2_RxEscapeCharacter(uint32_t ESC_CHAR)
{
 UART2_UESC.bits.ESC_CHAR=ESC_CHAR;
}


//RxEscapeTimer
 void
uart2_RxEscapeTimer(uint32_t TIM)
{
 UART2_UTIM.bits.TIM=TIM;
}


//BRMNumerator
 void
uart2_BRMNumerator(uint32_t INC)
{
 // FIX ME
 UART2_UBIR.bits.INC=INC;
}


//BRMDenominator
 void
uart2_BRMDenominator(uint32_t MOD)
{
 // FIX ME
 UART2_UBMR.bits.MOD=MOD;
}


//AutoBaudCounter
 uint32_t
uart2_AutoBaudCounter(void)
{
 return UART2_UBRC.bits.BCNT;
}


//InternalKHz
 void
uart2_InternalKHz(uint32_t ONEMS)
{
 UART2_ONEMS.bits.ONEMS=ONEMS;
}


//TxFIFO_Empty
 uint32_t
uart2_TxFIFO_Empty(void)
{
 return UART2_UTS.bits.TXEMPTY;
}


//RxFIFO_Empty
 uint32_t
uart2_RxFIFO_Empty(void)
{
 return UART2_UTS.bits.RXEMPTY;
}


//TxFIFO_Full
 uint32_t
uart2_TxFIFO_Full(void)
{
 return UART2_UTS.bits.TXFULL;
}


//RxFIFO_Full
 uint32_t
uart2_RxFIFO_Full(void)
{
 return UART2_UTS.bits.RXFULL;
}


//SoftResetStatus
 uint32_t
uart2_SoftResetStatus(void)
{
 return UART2_UTS.bits.SOFTRST;
}