/********************************************************************* * * UART Library definitions * ********************************************************************* * FileName: uart.h * Dependencies: * Processor: PIC32 * * Compiler: MPLAB XC32 * MPLAB IDE * Company: Microchip Technology Inc. * * Software License Agreement * * The software supplied herewith by Microchip Technology Incorporated * (the “Company”) for its PIC32 Microcontroller is intended * and supplied to you, the Company’s customer, for use solely and * exclusively on Microchip PIC32 Microcontroller products. * The software is owned by the Company and/or its supplier, and is * protected under applicable copyright laws. All rights are reserved. * Any use in violation of the foregoing restrictions may subject the * user to criminal sanctions under applicable laws, as well as to * civil liability for the breach of the terms and conditions of this * license. * * THIS SOFTWARE IS PROVIDED IN AN “AS IS” CONDITION. NO WARRANTIES, * WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT, * IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. * * * $Id: uart.h,v 1.2 2006/10/24 18:42:33 C10737 Exp $ * $Name: 1.6 $ * ********************************************************************/ #ifndef _UART_H #define _UART_H /* * WARNING: All the Peripheral Library (PLIB) functions, including those in this file, * will be removed from future releases of MPLAB XC32 C/C++ Compiler. * Please refer to the MPLAB Harmony Libraries for new projects. For legacy support, * these PLIB Libraries will be available for download from: www.microchip.com/pic32_peripheral_lib */ #ifndef _SUPPRESS_PLIB_WARNING #warning The PLIB functions and macros in this file will be removed from the MPLAB XC32 C/C++ Compiler in future releases #endif #ifdef PIC24 #define _UART1 #define _UART2 #include #else #include #include #endif // PIC24 #define UART2 UART3A #define UART3 UART2A #define UART4 UART1B #define UART5 UART3B #define UART6 UART2B /* This file supports following types and instances of UART peripheral. #define _UART1 #define _UART2 */ /************************************************************** * config1 Parameter Values to be used with OpenUARTx() *************************************************************/ #define UART_EN (1<<15) /* Module enable */ #define UART_DIS (0) /* Module disable */ #define UART_IDLE_STOP (1<<13) /* Stop all functions in IDLE mode */ #define UART_IDLE_CON (0) /* Work in IDLE mode */ #define UART_ALTRX_ALTTX (1<<10) /* Communication through ALT pins */ #define UART_RX_TX (0) /* Communication through the normal pins */ #define UART_EN_WAKE (1<<7) /* Enable Wake-up on START bit Detect during SLEEP Mode bit */ #define UART_DIS_WAKE (0) /* Disable Wake-up on START bit Detect during SLEEP Mode bit */ #define UART_EN_LOOPBACK (1<<6) /* Loop back enabled */ #define UART_DIS_LOOPBACK (0) /* Loop back disabled */ #define UART_EN_ABAUD (1<<5) /* Input to Capture module from UxRX pin */ #define UART_DIS_ABAUD (0) /* Input to Capture module from ICx pin */ #define UART_NO_PAR_9BIT (3<<1) /* No parity 9 bit */ #define UART_ODD_PAR_8BIT (2<<1) /* odd parity 8 bit */ #define UART_EVEN_PAR_8BIT (1<<1) /* even parity 8 bit */ #define UART_NO_PAR_8BIT (0) /* no parity 8 bit */ #define UART_2STOPBITS (1) /* 2 stop bits */ #define UART_1STOPBIT (0) /* 1 stop bit */ #define UART_IRDA_EN (1<<12) /* IRDA encoder and decoder enable */ #define UART_IRDA_DIS (0) /* IRDA encoder and decoder disable */ #define UART_MODE_SIMPLEX (1<<11) /* UxRTS pin in Simplex mode */ #define UART_MODE_FLOWCTRL (0) /* UxRTS pin in Flow Control mode */ #define UART_EN_BCLK (3<<8) /* BCLKx pin is enabled. */ #define UART_EN_CTS_RTS (2<<8) /* CTS and RTS pins are enabled */ #define UART_EN_RTS (1<<8) /* RTS pin is enabled. */ #define UART_DIS_BCLK_CTS_RTS (0) /* Disable BCLKx, CTS, and RTS pins */ #define UART_INVERT_RX (1<<4) /* UxRX idle state is '0' */ #define UART_NORMAL_RX (0) /* UxRX idle state is '1' */ #define UART_BRGH_FOUR (1<<3) /* 4x baud clock - High speed */ #define UART_BRGH_SIXTEEN (0) /* 16x baud clock - Normal speed */ /************************************************************** * config2 Parameter Values to be used with OpenUARTx() *************************************************************/ #define UART_TX_PIN_NORMAL (1<<13) /* IrDA encoded UxTX idle state is '1' */ #define UART_TX_PIN_LOW (0) /* IrDA encoded UxTX idle state is '0' */ #define UART_RX_ENABLE (1<<12) /* Enable UxRX pin */ #define UART_RX_DISABLE (0) #define UART_TX_ENABLE (1<<10) /* Enable UxTX pin */ #define UART_TX_DISABLE (0) /* Disable UxTX pin */ #define UART_INT_TX_BUF_EMPTY (2<<14) /* Interrupt on TXBUF becoming empty */ #define UART_INT_TX_LAST_CH (1<<14) /* Interrupt when last character shifted out*/ #define UART_INT_TX (0) /* Interrupt on transfer of every character to TSR */ #define UART_INT_RX_BUF_FUL (3<<6) /* Interrupt on RXBUF full */ #define UART_INT_RX_3_4_FUL (2<<6) /* Interrupt on RXBUF 3/4 full */ #define UART_INT_RX_CHAR (0) /* Interrupt on every char received */\ #define UART_ADR_DETECT_EN (1<<5) /* Enable 9-bit address detect*/ #define UART_ADR_DETECT_DIS (0) #define UART_RX_OVERRUN_CLEAR (0) /* Rx buffer Over run status bit clear */ /****************************************************************************** * * * Function: void OpenUARTx(unsigned int config1, * unsigned int config2, * unsigned int ubrg) * * Description: Configures UARTx * * PreCondition: None * * Inputs: config1: Bit-wise OR value of config1 parameters as defined * above. Must use only one from each group. * config2: Bit-wise OR value of config2 parameters as defined * above. Must use only one from each group. * * An absent symbol is automatically taken as off or default value. * * Output: None * * Example: OpenUART1(UART_EN | UART_BRGH_FOUR, * UART_TX_PIN_NORMAL | UART_RX_EN | UART_TX_ENABLE, * 123) * *****************************************************************************/ #if defined(_UART1) #define OpenUART1(config1, config2, ubrg) (U1BRG = (ubrg), U1MODE = (config1), U1STA = (config2)) #endif #if defined(_UART2) #define OpenUART2(config1, config2, ubrg) (U2BRG = (ubrg), U2MODE = (config1), U2STA = (config2)) #endif /****************************************************************************** * Function: int mUARTBRG(int pb_clk, int baud_rate) * * Description: Calculates the BRG values needed for the UART configuration * * PreCondition: None * * Inputs: pb_clk: - the PB clock frequency, HZ * baud_rate: - the derired baud rate * * Output: The proper BRG value * * Example: OpenUART1(UART_EN | UART_BRGH_FOUR, UART_TX_PIN_NORMAL | UART_RX_EN | UART_TX_ENABLE, mUARTBRG(72000000, 38400)); * *****************************************************************************/ #define mUARTBRG(pb_clk, baud_rate) (((pb_clk)/16/(baud_rate)-1)) /****************************************************************************** * * * Function: void EnableIntUxRX(void) * * Description: Enables UARTx Receive Interrupt * * PreCondition: None * * Inputs: None * * Output: None * * Example: EnableIntU1RX; * *****************************************************************************/ #if defined(_UART1) #define EnableIntU1RX mU1RXIntEnable(1) #endif #if defined(_UART2) #define EnableIntU2RX mU2RXIntEnable(1) #endif /****************************************************************************** * * * Function: void DisableIntUxRX(void) * * Description: Enables UARTx Receive Interrupt * * PreCondition: None * * Inputs: None * * Output: None * * Example: DisableIntU1RX; * *****************************************************************************/ #if defined(_UART1) #define DisableIntU1RX mU1RXIntEnable(0) #endif #if defined(_UART2) #define DisableIntU2RX mU2RXIntEnable(0) #endif /****************************************************************************** * * * Function: void EnableIntUxTX(void) * * Description: Enables UARTx Transmit Interrupt * * PreCondition: None * * Inputs: None * * Output: None * * Example: EnableIntU1TX; * *****************************************************************************/ #if defined(_UART1) #define EnableIntU1TX mU1TXIntEnable(1) #endif #if defined(_UART2) #define EnableIntU2TX mU2TXIntEnable(1) #endif /****************************************************************************** * * * Function: void DisableIntUxTX(void) * * Description: Disables UARTx Transmit Interrupt * * PreCondition: None * * Inputs: None * * Output: None * * Example: DisableIntU1TX; * *****************************************************************************/ #if defined(_UART1) #define DisableIntU1TX mU1TXIntEnable(0) #endif #if defined(_UART2) #define DisableIntU2TX mU2TXIntEnable(0) #endif /************************************************************** * Parameter values to be used with SetPriorityIntUx() and * ConfigIntUARTx() *************************************************************/ #define UART_INT_PR0 (0) #define UART_INT_PR1 (1) #define UART_INT_PR2 (2) #define UART_INT_PR3 (3) #define UART_INT_PR4 (4) #define UART_INT_PR5 (5) #define UART_INT_PR6 (6) #define UART_INT_PR7 (7) /************************************************************** * Parameter values to be used with SetSubPriorityIntUx() *************************************************************/ #define UART_INT_SUB_PR0 (0 << 4) #define UART_INT_SUB_PR1 (1 << 4) #define UART_INT_SUB_PR2 (2 << 4) #define UART_INT_SUB_PR3 (3 << 4) /************************************************************** * Parameter values to be used with ConfigIntUARTx() only *************************************************************/ #define UART_ERR_INT_EN (1 << 6) /* Error interrupt enabled */ #define UART_ERR_INT_DIS (0) /* Error interrupt disabled */ #define UART_RX_INT_EN (1 << 7) /* Receive interrupt enabled */ #define UART_RX_INT_DIS (0) /* Receive interrupt disabled */ #define UART_TX_INT_EN (1 << 8) /* Transmit interrupt enabled */ #define UART_TX_INT_DIS (0) /* Transmit interrupt disabled */ /****************************************************************************** * * * Function: void ConfigIntUART1(int config) * * Description: Configures interrupt settings for UART x * * PreCondition: None * * Inputs: Bit-wise OR value of UART_RX_INT_XX, UART_TX_INT_XX, * UART_ERR_INT_XXX, UART_INT_PRx, UART_INT_SUB_PRx * * Output: None * * Example: ConfigIntUART1(UART_RX_INT_EN | UART_ERR_INT_EN | * | UART_INT_PR0 | UART_INT_SUB_PR2); * *****************************************************************************/ #if defined(_UART1) #define ConfigIntUART1(config) ( mU1ClearAllIntFlags(), SetPriorityIntU1(config), \ SetSubPriorityIntU1(config), mU1SetIntEnable((((config)>> 6) & 7)) ) #endif #if defined(_UART2) #define ConfigIntUART2(config) ( mU2ClearAllIntFlags(), SetPriorityIntU2(config), \ SetSubPriorityIntU2(config), mU2SetIntEnable((((config)>> 6) & 7)) ) #endif /****************************************************************************** * * * Function: void SetPriorityIntUx(int pri) * * Description: Sets priority for UARTx * * PreCondition: None * * Inputs: pri: A value from UART_INT_PRx * * * Output: None * * Example: SetPriorityIntUx(UART_INT_PR3) * *****************************************************************************/ #if defined(_UART1) #define SetPriorityIntU1(pri) mU1SetIntPriority(((pri) & 0x7)) #endif #if defined(_UART2) #define SetPriorityIntU2(pri) mU2SetIntPriority(((pri) & 0x7)) #endif /****************************************************************************** * * * Function: void SetSubPriorityIntUx(int sub) * * Description: Sets subpriority for UARTx * * PreCondition: None * * Inputs: sub: A value from UART_INT_SUB_PRx * * * Output: None * * Example: SetPriorityIntUx(UART_INT_SUB_PR3) * *****************************************************************************/ #if defined(_UART1) #define SetSubPriorityIntU1(sub) mU1SetIntSubPriority((((sub)>> 4) & 3)) #endif #if defined(_UART2) #define SetSubPriorityIntU2(sub) mU2SetIntSubPriority((((sub)>> 4) & 3)) #endif /****************************************************************************** * * * Function: int UARTxGetErrors(void) * void UARTxClearErrors(void) * * Description: UARTxGetErrrors() retrives bitmap of various error values * UARTxClearAllErrors() clears all error flags. * UART1ClearError(error) clear specific error flag. * * PreCondition: None * * Inputs: * * Output: Overflow Error - _UxSTA_OERR_MASK * Frame error - _UxSTA_FERR_MASK * Parity error - _UxSTA_PERR_MASK * * Example: // hande an overflow error on UART 1 * if(UART1GetErrors() & _U1STA_FERR_MASK) * { * // handle error... * UARTClearError(_U1STA_FERR_MASK); * } * * NOTES: See device header file for output defines * *****************************************************************************/ #if defined(_UART1) #define UART1GetErrors() (U1STA & (_U1STA_OERR_MASK | _U1STA_FERR_MASK | _U1STA_PERR_MASK)) #define UART1ClearAllErrors() (U1STACLR = (_U1STA_OERR_MASK | _U1STA_FERR_MASK | _U1STA_PERR_MASK)) #define UART1ClearError(error) (U1STACLR = (error)) #endif #if defined(_UART2) #define UART2GetErrors() (U2STA & (_U2STA_OERR_MASK | _U2STA_FERR_MASK | _U2STA_PERR_MASK)) #define UART2ClearAllErrors() (U2STACLR = (_U2STA_OERR_MASK | _U2STA_FERR_MASK | _U2STA_PERR_MASK)) #define UART2ClearError(error) (U2STACLR = (error)) #endif /****************************************************************************** * * * Function: void getcUARTx(void) * * Description: Reads one character from UART x receive buffer * * PreCondition: None * * Inputs: None * * Output: None * * Example: getcUART1; * *****************************************************************************/ #if defined(_UART1) #define getcUART1 (char)ReadUART1 #endif #if defined(_UART2) #define getcUART2 (char)ReadUART2 #endif /****************************************************************************** * * * Function: void putcUARTx(char c) * * Description: Writes one character to UART x transmit buffer * * PreCondition: None * * Inputs: None * * Output: None * * Example: putcUART1('m'); * *****************************************************************************/ #if defined(_UART1) #define putcUART1(c) do{while(!U1STAbits.TRMT); WriteUART1((int)(c));}while(0) #endif #if defined(_UART2) #define putcUART2(c) do{while(!U2STAbits.TRMT); WriteUART2((int)(c));}while(0) #endif /****************************************************************************** * * * Function: void putsUARTx(const char *buffer) * * Description: Transmit a NULL transmitted string via UARTx * * PreCondition: None * * Inputs: buffer: NULL terminated string to be transmitted * * Output: None * * Example: putsUART1(myString); * putsUART1("Hello World!"); * *****************************************************************************/ #if defined(_UART1) void putsUART1(const char* buffer); #endif #if defined(_UART2) void putsUART2(const char* buffer); #endif /****************************************************************************** * * * Function: void WriteUART1(unsigned int data) * * Description: Transmit a character via UARTx * * PreCondition: None * * Inputs: data: A character to be transmitted * * Output: None * * Example: WriteUART1('a'); * WriteUART1(myChar); * *****************************************************************************/ #if defined(_UART1) #define WriteUART1(data) U1TXREG = (data) #endif #if defined(_UART2) #define WriteUART2(data) U2TXREG = (data) #endif /****************************************************************************** * * * Function: char ReadUART1(void) * * Description: Read a character from UARTx receive buffer * * PreCondition: None * * Inputs: None * * Output: Data from UARTx receive buffer * * Example: myData = ReadUART1(); * *****************************************************************************/ #if defined(_UART1) #define ReadUART1() (U1RXREG) #endif #if defined(_UART2) #define ReadUART2() (U2RXREG) #endif /****************************************************************************** * * * Function: void CloseUARTx(void) * * Description: Disables UART interrupt and closes UART x * * PreCondition: None * * Inputs: None * * Output: None * * Example: CloseUART1(); * *****************************************************************************/ #if defined(_UART1) #define CloseUART1() U1MODECLR = (1<<_U1MODE_UARTEN_POSITION) #endif #if defined(_UART2) #define CloseUART2() U2MODECLR = (1<<_U2MODE_UARTEN_POSITION); #endif /****************************************************************************** * * * Function: int DataRdyUARTx(void) * * Description: Checks to see if a data is ready is in UARTx * * PreCondition: None * * Inputs: None * * Output: If ‘0’ is returned, it indicates that receive buffer does * not have any new data to be read. * If Non-Zero value is returned, it indicates that the receive * buffer has a data to be read. * * Example: DataRdyUART1(); * *****************************************************************************/ #if defined(_UART1) #define DataRdyUART1() (U1STAbits.URXDA) #endif #if defined(_UART2) #define DataRdyUART2() (U2STAbits.URXDA) #endif /****************************************************************************** * * * Function: int BusyUARTx(void) * * Description: Checks to see if a UARTx transmitter is empty * * PreCondition: None * * Inputs: None * * Output: '0' if UART1 transmitter is not busy * Non-zero if UART1 transmitter is busy * * Example: if ( BusyUART1() == 0) // Is it not busy? * *****************************************************************************/ #if defined(_UART1) #define BusyUART1() (!U1STAbits.TRMT) #endif #if defined(_UART2) #define BusyUART2() (!U2STAbits.TRMT) #endif /****************************************************************************** * * * Function: unsigned int getsUART1(unsigned int length, * char* buffer, * unsigned int uart_data_wait); * * Description: Checks to see if a data is ready is in UARTx * * PreCondition: None * * Inputs: length: This is the length of the string to be received * buffer: This is the pointer to the location where the data * received have to be stored. * uart_data_wait: This is the time-out count for which the module * has to wait before return. If the time-out count is ‘N’, * the actual time out would be about (19 * N – 1) instruction cycles. * Output: None * * Example: getsUART1(12, myBuffer, 123); * *****************************************************************************/ #if defined(_UART1) unsigned int getsUART1(unsigned int length, char* buffer, unsigned int uart_data_wait); #endif #if defined(_UART2) unsigned int getsUART2(unsigned int length, char* buffer, unsigned int uart_data_wait); #endif /****************************************************************************** * * * Function: void UARTxEnableAutoAddr(int address) * * Description: Enables the automatic address matching mode of UARTx * * PreCondition: None * * Inputs: address: The 9-bit address for this UART * * Output: None * * Example: UART1EnableAutoAddr(0x18); * *****************************************************************************/ #if defined(_UART1) #define UART1EnableAutoAddr(address) (U1STA |= ((1 << _U1STA_ADM_EN_POSITION) | (address << _U1STA_ADDR_POSITION) | (1 << _U1STA_ADDEN_POSITION))) #endif #if defined(_UART2) #define UART2EnableAutoAddr(address) ((U2STA |= (1 << _U2STA_ADM_EN_POSITION) | (address << _U2STA_ADDR_POSITION) | (1 << _U2STA_ADDEN_POSITION))) #endif /****************************************************************************** * * * Function: void UARTxSendBreak(void); * * Description: Initiates Break sequence on UARTx * * PreCondition: None * * Inputs: None * * Output: None * * Example: UART1SendBreak(); * *****************************************************************************/ #if defined(_UART1) #define UART1SendBreak() (U1STASET = (1<<_U1STA_UTXBRK_POSITION), WriteUART1(0)) #endif #if defined(_UART2) #define UART2SendBreak() (U2STASET = (1<<_U2STA_UTXBRK_POSITION), WriteUART2(0)) #endif /****************************************************************************** * Following defines are provided for PIC24/dsPIC backward compatibility only. * Do not use these defines for PIC32MX native applications. *****************************************************************************/ #define UART_RX_INT_PR0 UART_INT_PR0 #define UART_RX_INT_PR1 UART_INT_PR1 #define UART_RX_INT_PR2 UART_INT_PR2 #define UART_RX_INT_PR3 UART_INT_PR3 #define UART_RX_INT_PR4 UART_INT_PR4 #define UART_RX_INT_PR5 UART_INT_PR5 #define UART_RX_INT_PR6 UART_INT_PR6 #define UART_RX_INT_PR7 UART_INT_PR7 #define UART_TX_INT_PR0 UART_INT_PR0 #define UART_TX_INT_PR1 UART_INT_PR1 #define UART_TX_INT_PR2 UART_INT_PR2 #define UART_TX_INT_PR3 UART_INT_PR3 #define UART_TX_INT_PR4 UART_INT_PR4 #define UART_TX_INT_PR5 UART_INT_PR5 #define UART_TX_INT_PR6 UART_INT_PR6 #define UART_TX_INT_PR7 UART_INT_PR7 // On PIC32MX, there are no separate priorities for RX and TX interrupt // Each UART has its own priority and all interrupts (TX, RX and Error) // for that UART have the same priority #define SetPriorityIntU1RX SetPriorityIntU1 #define SetPriorityIntU2RX SetPriorityIntU2 #define SetPriorityIntU1TX SetPriorityIntU1 #define SetPriorityIntU2TX SetPriorityIntU2 #endif /*_UART_H */