CC2538 ZigBee 芯片 两路UART串口同时使用

前言

• 众所周知，CC2538 zigbee芯片物理上支持UART0和UART1，但是在Z-Stack协议栈里面只提供了UART1的代码支持，并没有提供UART0的代码支持，但是具体如何同时使用UART0，能不能两路同时使用，网上找不到任何介绍的，包括deyisupport网站在内。

• 按照国外网站e2e.ti.com论坛提供的支持，TI技术人员说要自己修改hal_uart.c来实现支持两路UART，但是他自己也没有测试是否可行。

• 经过我自己的验证证实，两路UART是可以同时工作的，只是代码需要做修改。

方法步骤

• 首先定义宏UART_SIMULTANEOUS，来支持两路UART，修改C:\Texas Instruments\Z-Stack 3.0.0\Components\hal\target\CC2538目录下的hal_uart.c，内容如下：

/**************************************************************************************************  Filename:       _hal_uart.c  Revised:        $Date: 2013-05-17 11:25:11 -0700 (Fri, 17 May 2013) $  Revision:       $Revision: 34355 $  Description:    This file contains the interface to the UART.  Copyright 2012-2013 Texas Instruments Incorporated. All rights reserved.  IMPORTANT: Your use of this Software is limited to those specific rights  granted under the terms of a software license agreement between the user  who downloaded the software, his/her employer (which must be your employer)  and Texas Instruments Incorporated (the "License").  You may not use this  Software unless you agree to abide by the terms of the License. The License  limits your use, and you acknowledge, that the Software may not be modified,  copied or distributed unless embedded on a Texas Instruments microcontroller  or used solely and exclusively in conjunction with a Texas Instruments radio  frequency transceiver, which is integrated into your product.  Other than for  the foregoing purpose, you may not use, reproduce, copy, prepare derivative  works of, modify, distribute, perform, display or sell this Software and/or  its documentation for any purpose.  YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE  PROVIDED 揂S IS?WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,  INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE,  NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL  TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT,  NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER  LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES  INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE  OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT  OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES  (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.  Should you have any questions regarding your right to use this Software,  contact Texas Instruments Incorporated at www.TI.com.**************************************************************************************************//* ------------------------------------------------------------------------------------------------ *                                          Includes * ------------------------------------------------------------------------------------------------ */#if HAL_UART_USB#include "_hal_uart_usb.c"#else#include "_hal_uart_isr.c"#endif/* ------------------------------------------------------------------------------------------------ *                                           Global Functions * ------------------------------------------------------------------------------------------------ *//************************************************************************************************* * @fn      HalUARTInit() * * @brief   Initialize the UART * * @param   none * * @return  none *************************************************************************************************/void HalUARTInit(void){#if HAL_UART_USB  HalUARTInitUSB();#else#if defined (UART_SIMULTANEOUS)  HalUART0InitIsr();  HalUART1InitIsr();#else  HalUART1InitIsr();                    //only initialize UART1#endif /*UART_SIMULTANEOUS*/#endif}/************************************************************************************************* * @fn      HalUARTOpen() * * @brief   Open a port based on the configuration * * @param   port   - UART port *          config - contains configuration information *          cBack  - Call back function where events will be reported back * * @return  Status of the function call *************************************************************************************************/uint8 HalUARTOpen(uint8 port, halUARTCfg_t *config){#if HAL_UART_USB  (void)port;  HalUARTOpenUSB(config);  return HAL_UART_SUCCESS;#else#if defined (UART_SIMULTANEOUS)  switch(port)  {  case HAL_UART_PORT_0:    return(HalUART0OpenIsr(port, config));    break;  case HAL_UART_PORT_1:    return(HalUART1OpenIsr(port, config));    break;  }#else  return(HalUART1OpenIsr(port, config));        //only open UART1#endif /*UART_SIMULTANEOUS*/#endif}/************************************************************************************************* * @fn      Hal_UARTPoll * * @brief   This routine simulate polling and has to be called by the main loop * * @param   void * * @return  void *************************************************************************************************/void HalUARTPoll(void){#ifdef HAL_UART_USB  HalUARTPollUSB();#else#if defined (UART_SIMULTANEOUS)  HalUART0PollIsr();  HalUART1PollIsr();#else  HalUART1PollIsr();                            //only poll UART1#endif /*UART_SIMULTANEOUS*/#endif}/************************************************************************************************* * @fn      HalUARTClose() * * @brief   Close the UART * * @param   port - UART port (not used.) * * @return  none *************************************************************************************************/void HalUARTClose(uint8 port){#ifdef HAL_UART_USB#else#if defined (UART_SIMULTANEOUS)  switch(port)  {  case HAL_UART_PORT_0:    HalUART0CloseIsr(port);    break;  case HAL_UART_PORT_1:    HalUART1CloseIsr(port);    break;  }#else HalUART1CloseIsr(port);                        //only close UART1#endif /*UART_SIMULTANEOUS*/#endif}/************************************************************************************************* * @fn      HalUARTRead() * * @brief   Read a buffer from the UART * * @param   port - UART port (not used.) *          ppBuffer - pointer to a pointer that points to the data that will be read *          length - length of the requested buffer * * @return  length of buffer that was read *************************************************************************************************/uint16 HalUARTRead ( uint8 port, uint8 *pBuffer, uint16 length ){#if HAL_UART_USB  return HalUARTRx(pBuffer, length);#else#if defined (UART_SIMULTANEOUS)  switch(port)  {  case HAL_UART_PORT_0:    return (HalUART0ReadIsr( port, pBuffer, length ));    break;  case HAL_UART_PORT_1:    return (HalUART1ReadIsr( port, pBuffer, length ));    break;  }#else  return (HalUART1ReadIsr( port, pBuffer, length ));            //only read UART1#endif /*UART_SIMULTANEOUS*/#endif}/************************************************************************************************* * @fn      HalUARTWrite() * * @brief   Write a buffer to the UART * * @param   port    - UART port (not used.) *          pBuffer - pointer to the buffer that will be written *          length  - length of * * @return  length of the buffer that was sent *************************************************************************************************/uint16 HalUARTWrite(uint8 port, uint8 *pBuffer, uint16 length){#if HAL_UART_USB  return HalUARTTx(pBuffer, length);#else#if defined (UART_SIMULTANEOUS)  switch(port)  {  case HAL_UART_PORT_0:    return (HalUART0WriteIsr( port, pBuffer, length ));    break;  case HAL_UART_PORT_1:    return (HalUART1WriteIsr( port, pBuffer, length ));    break;  }#else  return (HalUART1WriteIsr( port, pBuffer, length ));           //only write UART1#endif /*UART_SIMULTANEOUS*/#endif}/************************************************************************************************* * @fn      Hal_UART_RxBufLen() * * @brief   Calculate Rx Buffer length of a port * * @param   port - UART port (not used.) * * @return  length of current Rx Buffer *************************************************************************************************/uint16 Hal_UART_RxBufLen (uint8 port){#if HAL_UART_USB  return HalUARTRxAvailUSB();#else#if defined (UART_SIMULTANEOUS)  switch(port)  {  case HAL_UART_PORT_0:    return (Hal_UART0_RxBufLenIsr(port));    break;  case HAL_UART_PORT_1:    return (Hal_UART1_RxBufLenIsr(port));    break;  }#else  return (Hal_UART1_RxBufLenIsr(port));                         //only get UART1 length#endif /*UART_SIMULTANEOUS*/#endif}/***************************************************************************************************/

• 其次继续修改C:\Texas Instruments\Z-Stack 3.0.0\Components\hal\target\CC2538\hal_uart_isr.c文件，内容如下：

/**************************************************************************************************  Filename:       _hal_uart_isr.c  Revised:        $Date: 2014-12-05 13:07:19 -0800 (Fri, 05 Dec 2014) $  Revision:       $Revision: 41365 $  Description:    This file contains the interface to the UART.  Copyright 2013-2014 Texas Instruments Incorporated. All rights reserved.  IMPORTANT: Your use of this Software is limited to those specific rights  granted under the terms of a software license agreement between the user  who downloaded the software, his/her employer (which must be your employer)  and Texas Instruments Incorporated (the "License"). You may not use this  Software unless you agree to abide by the terms of the License. The License  limits your use, and you acknowledge, that the Software may not be modified,  copied or distributed unless embedded on a Texas Instruments microcontroller  or used solely and exclusively in conjunction with a Texas Instruments radio  frequency transceiver, which is integrated into your product. Other than for  the foregoing purpose, you may not use, reproduce, copy, prepare derivative  works of, modify, distribute, perform, display or sell this Software and/or  its documentation for any purpose.  YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE  PROVIDED 揂S IS?WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,  INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE,  NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL  TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT,  NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER  LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES  INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE  OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT  OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES  (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.  Should you have any questions regarding your right to use this Software,  contact Texas Instruments Incorporated at www.TI.com.**************************************************************************************************//* ------------------------------------------------------------------------------------------------ *                                          Includes * ------------------------------------------------------------------------------------------------ */#include "hal_board.h"#include "hal_types.h"#include "hal_uart.h"#include "OSAL.h"#include "OSAL_Timers.h"#include "hw_ioc.h"#include "hw_uart.h"/* ------------------------------------------------------------------------------------------------ *                                           Constants * ------------------------------------------------------------------------------------------------ */#define HAL_UART0_PORT                      UART0_BASE#define HAL_UART0_SYS_CTRL                  SYS_CTRL_PERIPH_UART0#define HAL_UART0_INT_CTRL                  INT_UART0#define HalUart0ISR                         interrupt_uart0#define HAL_UART1_PORT                      UART1_BASE#define HAL_UART1_SYS_CTRL                  SYS_CTRL_PERIPH_UART1#define HAL_UART1_INT_CTRL                  INT_UART1#define HalUart1ISR                         interrupt_uart1/* ------------------------------------------------------------------------------------------------ *                                           Local Variables * ------------------------------------------------------------------------------------------------ */const uint32 UBRRTable[] = {  9600,  19200,  38400,  57600,  115200};static halUARTCfg_t uartRecord0;static bool txMT0;static halUARTCfg_t uartRecord1;static bool txMT1;/* ------------------------------------------------------------------------------------------------ *                                           Local Functions * ------------------------------------------------------------------------------------------------ */static void recRstUART0(void);static void procRxUART0(void);static void procTxUART0(void);/* ------------------------------------------------------------------------------------------------ *                                           Global Functions * ------------------------------------------------------------------------------------------------ */void HalUART0InitIsr(void);uint8 HalUART0OpenIsr(uint8 port, halUARTCfg_t *config);void HalUART0PollIsr(void);void HalUART0CloseIsr(uint8 port);uint16 HalUART0ReadIsr ( uint8 port, uint8 *pBuffer, uint16 length );uint16 HalUART0WriteIsr(uint8 port, uint8 *pBuffer, uint16 length);uint16 Hal_UART0_RxBufLenIsr(uint8 port);void HalUart0ISR(void);/* ------------------------------------------------------------------------------------------------ *                                           Local Functions * ------------------------------------------------------------------------------------------------ */static void recRstUART1(void);static void procRxUART1(void);static void procTxUART1(void);/* ------------------------------------------------------------------------------------------------ *                                           Global Functions * ------------------------------------------------------------------------------------------------ */void HalUART1InitIsr(void);uint8 HalUART1OpenIsr(uint8 port, halUARTCfg_t *config);void HalUART1PollIsr(void);void HalUART1CloseIsr(uint8 port);uint16 HalUART1ReadIsr ( uint8 port, uint8 *pBuffer, uint16 length );uint16 HalUART1WriteIsr(uint8 port, uint8 *pBuffer, uint16 length);uint16 Hal_UART1_RxBufLenIsr(uint8 port);void HalUart1ISR(void);/************************************************************************************************* * @fn      HalUART0InitIsr() * * @brief   Initialize the UART * * @param   none * * @return  none *************************************************************************************************/void HalUART0InitIsr(void){   SysCtrlPeripheralEnable(HAL_UART0_SYS_CTRL);  /*     * PA5 as UART_TX and PA4 as UART_RX   */   IOCPinConfigPeriphOutput(GPIO_A_BASE, GPIO_PIN_5, IOC_MUX_OUT_SEL_UART0_TXD);  IOCPinConfigPeriphInput(GPIO_A_BASE, GPIO_PIN_4, IOC_UARTRXD_UART0);  GPIOPinTypeUARTInput(GPIO_A_BASE, GPIO_PIN_4);  GPIOPinTypeUARTOutput(GPIO_A_BASE, GPIO_PIN_5);    recRstUART0();}/************************************************************************************************* * @fn      HalUART1InitIsr() * * @brief   Initialize the UART * * @param   none * * @return  none *************************************************************************************************/void HalUART1InitIsr(void){   SysCtrlPeripheralEnable(HAL_UART1_SYS_CTRL);  /* Setup PB0 as UART_CTS, PD3 as UART_RTS     * PA1 as UART_TX and PA0 as UART_RX   */   IOCPinConfigPeriphOutput(GPIO_A_BASE, GPIO_PIN_1, IOC_MUX_OUT_SEL_UART1_TXD);  IOCPinConfigPeriphInput(GPIO_A_BASE, GPIO_PIN_0, IOC_UARTRXD_UART1);  GPIOPinTypeUARTInput(GPIO_A_BASE, GPIO_PIN_0);  GPIOPinTypeUARTOutput(GPIO_A_BASE, GPIO_PIN_1);    recRstUART1();}/************************************************************************************************* * @fn      HalUART0OpenIsr() * * @brief   Open a port based on the configuration * * @param   port   - UART port *          config - contains configuration information *          cBack  - Call back function where events will be reported back * * @return  Status of the function call *************************************************************************************************/uint8 HalUART0OpenIsr(uint8 port, halUARTCfg_t *config){  if (uartRecord0.configured)  {    HalUARTClose(port);  }  if (config->baudRate > HAL_UART_BR_115200)  {    return HAL_UART_BAUDRATE_ERROR;  }  if (((uartRecord0.rx.pBuffer = osal_mem_alloc(config->rx.maxBufSize)) == NULL) ||      ((uartRecord0.tx.pBuffer = osal_mem_alloc(config->tx.maxBufSize)) == NULL))  {    if (uartRecord0.rx.pBuffer != NULL)    {      osal_mem_free(uartRecord0.rx.pBuffer);      uartRecord0.rx.pBuffer = NULL;    }    return HAL_UART_MEM_FAIL;  }#if 0  //UART0 don't support RTS/CTS flowcontrol  if(config->flowControl)  {    IOCPinConfigPeriphOutput(GPIO_D_BASE, GPIO_PIN_3, IOC_MUX_OUT_SEL_UART1_RTS);    GPIOPinTypeUARTOutput(GPIO_D_BASE, GPIO_PIN_3);    IOCPinConfigPeriphInput(GPIO_B_BASE, GPIO_PIN_0, IOC_UARTCTS_UART1);    GPIOPinTypeUARTInput(GPIO_B_BASE, GPIO_PIN_0);  }#endif    IntEnable(HAL_UART0_INT_CTRL);  uartRecord0.configured = TRUE;  uartRecord0.baudRate = config->baudRate;  uartRecord0.flowControl = config->flowControl;  uartRecord0.flowControlThreshold = (config->flowControlThreshold > config->rx.maxBufSize) ? 0 :                                     config->flowControlThreshold;  uartRecord0.idleTimeout = config->idleTimeout;  uartRecord0.rx.maxBufSize = config->rx.maxBufSize;  uartRecord0.tx.maxBufSize = config->tx.maxBufSize;  uartRecord0.intEnable = config->intEnable;  uartRecord0.callBackFunc = config->callBackFunc;  UARTConfigSetExpClk(HAL_UART0_PORT, SysCtrlClockGet(), UBRRTable[uartRecord0.baudRate],                         (UART_CONFIG_WLEN_8 | UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE));  /* FIFO level set to 1/8th for both RX and TX which is 2 bytes */  UARTFIFOLevelSet(HAL_UART0_PORT, UART_FIFO_TX1_8, UART_FIFO_RX1_8);  UARTFIFOEnable(HAL_UART0_PORT);  /* Clear and enable UART TX, RX, CTS and Recieve Timeout interrupt */  UARTIntClear(HAL_UART0_PORT, (UART_INT_RX | UART_INT_TX /*| UART_INT_CTS*/ | UART_INT_RT ));  UARTIntEnable(HAL_UART0_PORT, (UART_INT_RX | UART_INT_TX /*| UART_INT_CTS*/ | UART_INT_RT ));  //if(config->flowControl)  //{    /* Enable hardware flow control by enabling CTS and RTS */  //  HWREG(HAL_UART0_PORT + UART_O_CTL) |= (UART_CTL_CTSEN | UART_CTL_RTSEN );  //}  UARTEnable(HAL_UART0_PORT);  return HAL_UART_SUCCESS;}/************************************************************************************************* * @fn      HalUART1OpenIsr() * * @brief   Open a port based on the configuration * * @param   port   - UART port *          config - contains configuration information *          cBack  - Call back function where events will be reported back * * @return  Status of the function call *************************************************************************************************/uint8 HalUART1OpenIsr(uint8 port, halUARTCfg_t *config){  if (uartRecord1.configured)  {    HalUARTClose(port);  }  if (config->baudRate > HAL_UART_BR_115200)  {    return HAL_UART_BAUDRATE_ERROR;  }  if (((uartRecord1.rx.pBuffer = osal_mem_alloc(config->rx.maxBufSize)) == NULL) ||      ((uartRecord1.tx.pBuffer = osal_mem_alloc(config->tx.maxBufSize)) == NULL))  {    if (uartRecord1.rx.pBuffer != NULL)    {      osal_mem_free(uartRecord1.rx.pBuffer);      uartRecord1.rx.pBuffer = NULL;    }    return HAL_UART_MEM_FAIL;  }  //TODO: modify flowControl pins  if(config->flowControl)  {    IOCPinConfigPeriphOutput(GPIO_D_BASE, GPIO_PIN_3, IOC_MUX_OUT_SEL_UART1_RTS);    GPIOPinTypeUARTOutput(GPIO_D_BASE, GPIO_PIN_3);    IOCPinConfigPeriphInput(GPIO_B_BASE, GPIO_PIN_0, IOC_UARTCTS_UART1);    GPIOPinTypeUARTInput(GPIO_B_BASE, GPIO_PIN_0);  }  IntEnable(HAL_UART1_INT_CTRL);  uartRecord1.configured = TRUE;  uartRecord1.baudRate = config->baudRate;  uartRecord1.flowControl = config->flowControl;  uartRecord1.flowControlThreshold = (config->flowControlThreshold > config->rx.maxBufSize) ? 0 :                                     config->flowControlThreshold;  uartRecord1.idleTimeout = config->idleTimeout;  uartRecord1.rx.maxBufSize = config->rx.maxBufSize;  uartRecord1.tx.maxBufSize = config->tx.maxBufSize;  uartRecord1.intEnable = config->intEnable;  uartRecord1.callBackFunc = config->callBackFunc;  UARTConfigSetExpClk(HAL_UART1_PORT, SysCtrlClockGet(), UBRRTable[uartRecord1.baudRate],                         (UART_CONFIG_WLEN_8 | UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE));  /* FIFO level set to 1/8th for both RX and TX which is 2 bytes */  UARTFIFOLevelSet(HAL_UART1_PORT, UART_FIFO_TX1_8, UART_FIFO_RX1_8);  UARTFIFOEnable(HAL_UART1_PORT);  /* Clear and enable UART TX, RX, CTS and Recieve Timeout interrupt */  UARTIntClear(HAL_UART1_PORT, (UART_INT_RX | UART_INT_TX | UART_INT_CTS | UART_INT_RT ));  UARTIntEnable(HAL_UART1_PORT, (UART_INT_RX | UART_INT_TX | UART_INT_CTS | UART_INT_RT ));  if(config->flowControl)  {    /* Enable hardware flow control by enabling CTS and RTS */    HWREG(HAL_UART1_PORT + UART_O_CTL) |= (UART_CTL_CTSEN | UART_CTL_RTSEN );  }  UARTEnable(HAL_UART1_PORT);  return HAL_UART_SUCCESS;}/************************************************************************************************* * @fn      HalUART0PollIsr * * @brief   This routine simulate polling and has to be called by the main loop * * @param   void * * @return  void *************************************************************************************************/void HalUART0PollIsr(void){  uint16 head = uartRecord0.tx.bufferHead;  uint16 tail = uartRecord0.tx.bufferTail;  /* If port is not configured, no point to poll it. */  if (!uartRecord0.configured)    {    return;  }  halIntState_t intState;  HAL_ENTER_CRITICAL_SECTION(intState);  procRxUART0();  procTxUART0();  HAL_EXIT_CRITICAL_SECTION(intState);  uint8 evts = 0;  /* Report if Rx Buffer is full. */  if ((Hal_UART_RxBufLen(HAL_UART_PORT_0) + 1) >= uartRecord0.rx.maxBufSize)    {    evts = HAL_UART_RX_FULL;  }  /* Report if Rx Buffer is idled. */  if ((uartRecord0.rxChRvdTime != 0) &&       ((osal_GetSystemClock() - uartRecord0.rxChRvdTime) > uartRecord0.idleTimeout))  {    uartRecord0.rxChRvdTime = 0;    evts |= HAL_UART_RX_TIMEOUT;  }  if (Hal_UART_RxBufLen(HAL_UART_PORT_0) >= uartRecord0.rx.maxBufSize - uartRecord0.flowControlThreshold)  {    evts |= HAL_UART_RX_ABOUT_FULL;  }  if (!txMT0 && (head == tail))  {    txMT0 = true;    evts |= HAL_UART_TX_EMPTY;  }  if (evts && uartRecord0.callBackFunc)  {    (uartRecord0.callBackFunc)(HAL_UART_PORT_0, evts);  }}/************************************************************************************************* * @fn      HalUART1PollIsr * * @brief   This routine simulate polling and has to be called by the main loop * * @param   void * * @return  void *************************************************************************************************/void HalUART1PollIsr(void){  uint16 head = uartRecord1.tx.bufferHead;  uint16 tail = uartRecord1.tx.bufferTail;  /* If port is not configured, no point to poll it. */  if (!uartRecord1.configured)    {    return;  }  halIntState_t intState;  HAL_ENTER_CRITICAL_SECTION(intState);  procRxUART1();  procTxUART1();  HAL_EXIT_CRITICAL_SECTION(intState);  uint8 evts = 0;  /* Report if Rx Buffer is full. */  if ((Hal_UART_RxBufLen(HAL_UART_PORT_1) + 1) >= uartRecord1.rx.maxBufSize)    {    evts = HAL_UART_RX_FULL;  }  /* Report if Rx Buffer is idled. */  if ((uartRecord1.rxChRvdTime != 0) &&       ((osal_GetSystemClock() - uartRecord1.rxChRvdTime) > uartRecord1.idleTimeout))  {    uartRecord1.rxChRvdTime = 0;    evts |= HAL_UART_RX_TIMEOUT;  }  if (Hal_UART_RxBufLen(HAL_UART_PORT_1) >= uartRecord1.rx.maxBufSize - uartRecord1.flowControlThreshold)  {    evts |= HAL_UART_RX_ABOUT_FULL;  }  if (!txMT1 && (head == tail))  {    txMT1 = true;    evts |= HAL_UART_TX_EMPTY;  }  if (evts && uartRecord1.callBackFunc)  {    (uartRecord1.callBackFunc)(HAL_UART_PORT_1, evts);  }}/************************************************************************************************* * @fn      HalUART0CloseIsr() * * @brief   Close the UART * * @param   port - UART port (not used.) * * @return  none *************************************************************************************************/void HalUART0CloseIsr(uint8 port){  (void)port;  UARTDisable(HAL_UART0_PORT);  if (uartRecord0.configured)  {    (void)osal_mem_free(uartRecord0.rx.pBuffer);    (void)osal_mem_free(uartRecord0.tx.pBuffer);    recRstUART0();  }}/************************************************************************************************* * @fn      HalUART1CloseIsr() * * @brief   Close the UART * * @param   port - UART port (not used.) * * @return  none *************************************************************************************************/void HalUART1CloseIsr(uint8 port){  (void)port;  UARTDisable(HAL_UART1_PORT);  if (uartRecord1.configured)  {    (void)osal_mem_free(uartRecord1.rx.pBuffer);    (void)osal_mem_free(uartRecord1.tx.pBuffer);    recRstUART1();  }}/************************************************************************************************* * @fn      HalUART0ReadIsr() * * @brief   Read a buffer from the UART * * @param   port - UART port (not used.) *          ppBuffer - pointer to a pointer that points to the data that will be read *          length - length of the requested buffer * * @return  length of buffer that was read *************************************************************************************************/uint16 HalUART0ReadIsr ( uint8 port, uint8 *pBuffer, uint16 length ){  uint16 cnt, idx;  (void)port;  /* If port is not configured, no point to read it. */  if (!uartRecord0.configured)  {    return 0;  }  /* If requested length is bigger than what in    * buffer, re-adjust it to the buffer length.   */  cnt = Hal_UART_RxBufLen(port);  if (cnt < length)  {    length = cnt;  }  idx = uartRecord0.rx.bufferHead;  for (cnt = 0; cnt < length; cnt++)  {    pBuffer[cnt] = uartRecord0.rx.pBuffer[idx++];    if (idx >= uartRecord0.rx.maxBufSize)    {      idx = 0;    }  }  uartRecord0.rx.bufferHead = idx;  /* Return number of bytes read. */  return length;  }/************************************************************************************************* * @fn      HalUART1ReadIsr() * * @brief   Read a buffer from the UART * * @param   port - UART port (not used.) *          ppBuffer - pointer to a pointer that points to the data that will be read *          length - length of the requested buffer * * @return  length of buffer that was read *************************************************************************************************/uint16 HalUART1ReadIsr ( uint8 port, uint8 *pBuffer, uint16 length ){  uint16 cnt, idx;  (void)port;  /* If port is not configured, no point to read it. */  if (!uartRecord1.configured)  {    return 0;  }  /* If requested length is bigger than what in    * buffer, re-adjust it to the buffer length.   */  cnt = Hal_UART_RxBufLen(port);  if (cnt < length)  {    length = cnt;  }  idx = uartRecord1.rx.bufferHead;  for (cnt = 0; cnt < length; cnt++)  {    pBuffer[cnt] = uartRecord1.rx.pBuffer[idx++];    if (idx >= uartRecord1.rx.maxBufSize)    {      idx = 0;    }  }  uartRecord1.rx.bufferHead = idx;  /* Return number of bytes read. */  return length;  }/************************************************************************************************* * @fn      HalUART0WriteIsr() * * @brief   Write a buffer to the UART * * @param   port    - UART port (not used.) *          pBuffer - pointer to the buffer that will be written *          length  - length of * * @return  length of the buffer that was sent *************************************************************************************************/uint16 HalUART0WriteIsr(uint8 port, uint8 *pBuffer, uint16 length){  (void)port;  if (!uartRecord0.configured)  {    return 0;  }  uint16 idx = uartRecord0.tx.bufferHead;  uint16 cnt = uartRecord0.tx.bufferTail;  if (cnt == idx)  {    cnt = uartRecord0.tx.maxBufSize;  }  else if (cnt > idx)  {    cnt = uartRecord0.tx.maxBufSize - cnt + idx;  }  else /* (cnt < idx) */  {    cnt = idx - cnt;  }  /* Accept "all-or-none" on write request. */  if (cnt < length)  {    return 0;  }  txMT0 = false;  idx = uartRecord0.tx.bufferTail;  for (cnt = 0; cnt < length; cnt++)  {    uartRecord0.tx.pBuffer[idx++] = pBuffer[cnt];    if (idx >= uartRecord0.tx.maxBufSize)    {      idx = 0;    }  }  halIntState_t intState;  HAL_ENTER_CRITICAL_SECTION(intState);  uartRecord0.tx.bufferTail = idx;  procTxUART0();  HAL_EXIT_CRITICAL_SECTION(intState);  /* Return the number of bytes actually put into the buffer. */  return length;  }/************************************************************************************************* * @fn      HalUART1WriteIsr() * * @brief   Write a buffer to the UART * * @param   port    - UART port (not used.) *          pBuffer - pointer to the buffer that will be written *          length  - length of * * @return  length of the buffer that was sent *************************************************************************************************/uint16 HalUART1WriteIsr(uint8 port, uint8 *pBuffer, uint16 length){  (void)port;  if (!uartRecord1.configured)  {    return 0;  }  uint16 idx = uartRecord1.tx.bufferHead;  uint16 cnt = uartRecord1.tx.bufferTail;  if (cnt == idx)  {    cnt = uartRecord1.tx.maxBufSize;  }  else if (cnt > idx)  {    cnt = uartRecord1.tx.maxBufSize - cnt + idx;  }  else /* (cnt < idx) */  {    cnt = idx - cnt;  }  /* Accept "all-or-none" on write request. */  if (cnt < length)  {    return 0;  }  txMT1 = false;  idx = uartRecord1.tx.bufferTail;  for (cnt = 0; cnt < length; cnt++)  {    uartRecord1.tx.pBuffer[idx++] = pBuffer[cnt];    if (idx >= uartRecord1.tx.maxBufSize)    {      idx = 0;    }  }  halIntState_t intState;  HAL_ENTER_CRITICAL_SECTION(intState);  uartRecord1.tx.bufferTail = idx;  procTxUART1();  HAL_EXIT_CRITICAL_SECTION(intState);  /* Return the number of bytes actually put into the buffer. */  return length;  }/************************************************************************************************* * @fn      Hal_UART0_RxBufLenIsr() * * @brief   Calculate Rx Buffer length of a port * * @param   port - UART port (not used.) * * @return  length of current Rx Buffer *************************************************************************************************/uint16 Hal_UART0_RxBufLenIsr(uint8 port){  int16 length = uartRecord0.rx.bufferTail;  (void)port;  length -= uartRecord0.rx.bufferHead;  if  (length < 0)    length += uartRecord0.rx.maxBufSize;  return (uint16)length;}/************************************************************************************************* * @fn      Hal_UART1_RxBufLenIsr() * * @brief   Calculate Rx Buffer length of a port * * @param   port - UART port (not used.) * * @return  length of current Rx Buffer *************************************************************************************************/uint16 Hal_UART1_RxBufLenIsr(uint8 port){  int16 length = uartRecord1.rx.bufferTail;  (void)port;  length -= uartRecord1.rx.bufferHead;  if  (length < 0)    length += uartRecord1.rx.maxBufSize;  return (uint16)length;}/************************************************************************************************* * @fn      Hal_UART0_TxBufLen() * * @brief   Calculate Tx Buffer length of a port * * @param   port - UART port (not used.) * * @return  length of current Tx buffer *************************************************************************************************/uint16 Hal_UART0_TxBufLen( uint8 port ){  int16 length = uartRecord0.tx.bufferTail;  (void)port;  length -= uartRecord0.tx.bufferHead;  if  (length < 0)    length += uartRecord0.tx.maxBufSize;  return (uint16)length;}/************************************************************************************************* * @fn      Hal_UART1_TxBufLen() * * @brief   Calculate Tx Buffer length of a port * * @param   port - UART port (not used.) * * @return  length of current Tx buffer *************************************************************************************************/uint16 Hal_UART1_TxBufLen( uint8 port ){  int16 length = uartRecord1.tx.bufferTail;  (void)port;  length -= uartRecord1.tx.bufferHead;  if  (length < 0)    length += uartRecord1.tx.maxBufSize;  return (uint16)length;}/************************************************************************************************* * @fn      recRstUART0() * * @brief   Reset the UART record. * * @param   none * * @return  none *************************************************************************************************/static void recRstUART0(void){  uartRecord0.configured        = FALSE;  uartRecord0.rx.bufferHead     = 0;  uartRecord0.rx.bufferTail     = 0;  uartRecord0.rx.pBuffer        = (uint8 *)NULL;  uartRecord0.tx.bufferHead     = 0;  uartRecord0.tx.bufferTail     = 0;  uartRecord0.tx.pBuffer        = (uint8 *)NULL;  uartRecord0.rxChRvdTime       = 0;  uartRecord0.intEnable         = FALSE;}/************************************************************************************************* * @fn      recRstUART1() * * @brief   Reset the UART record. * * @param   none * * @return  none *************************************************************************************************/static void recRstUART1(void){  uartRecord1.configured        = FALSE;  uartRecord1.rx.bufferHead     = 0;  uartRecord1.rx.bufferTail     = 0;  uartRecord1.rx.pBuffer        = (uint8 *)NULL;  uartRecord1.tx.bufferHead     = 0;  uartRecord1.tx.bufferTail     = 0;  uartRecord1.tx.pBuffer        = (uint8 *)NULL;  uartRecord1.rxChRvdTime       = 0;  uartRecord1.intEnable         = FALSE;}/************************************************************************************************* * @fn      procRxUART0 * * @brief   Process Tx bytes. * * @param   void * * @return  void *************************************************************************************************/static void procRxUART0(void){  uint16 tail = uartRecord0.rx.bufferTail;  while (UARTCharsAvail(HAL_UART0_PORT))  {    uartRecord0.rx.pBuffer[tail++] = UARTCharGetNonBlocking(HAL_UART0_PORT);    if (tail >= uartRecord0.rx.maxBufSize)    {      tail = 0;    }  }  if (uartRecord0.rx.bufferTail != tail)  {    uartRecord0.rx.bufferTail = tail;    uartRecord0.rxChRvdTime = osal_GetSystemClock();  }}/************************************************************************************************* * @fn      procRxUART1 * * @brief   Process Tx bytes. * * @param   void * * @return  void *************************************************************************************************/static void procRxUART1(void){  uint16 tail = uartRecord1.rx.bufferTail;  while (UARTCharsAvail(HAL_UART1_PORT))  {    uartRecord1.rx.pBuffer[tail++] = UARTCharGetNonBlocking(HAL_UART1_PORT);    if (tail >= uartRecord1.rx.maxBufSize)    {      tail = 0;    }  }  if (uartRecord1.rx.bufferTail != tail)  {    uartRecord1.rx.bufferTail = tail;    uartRecord1.rxChRvdTime = osal_GetSystemClock();  }}/************************************************************************************************* * @fn      procTxUART0 * * @brief   Process Tx bytes. * * @param   void * * @return  void *************************************************************************************************/static void procTxUART0(void){  uint16 head = uartRecord0.tx.bufferHead;  uint16 tail = uartRecord0.tx.bufferTail;  while ((head != tail) && (UARTCharPutNonBlocking(HAL_UART0_PORT, uartRecord0.tx.pBuffer[head])))  {    if (++head >= uartRecord0.tx.maxBufSize)    {      head = 0;    }  }  uartRecord0.tx.bufferHead = head;}/************************************************************************************************* * @fn      procTxUART1 * * @brief   Process Tx bytes. * * @param   void * * @return  void *************************************************************************************************/static void procTxUART1(void){  uint16 head = uartRecord1.tx.bufferHead;  uint16 tail = uartRecord1.tx.bufferTail;  while ((head != tail) && (UARTCharPutNonBlocking(HAL_UART1_PORT, uartRecord1.tx.pBuffer[head])))  {    if (++head >= uartRecord1.tx.maxBufSize)    {      head = 0;    }  }  uartRecord1.tx.bufferHead = head;}/************************************************************************************************* * @fn      UART Rx/Tx ISR * * @brief   Called when a serial byte is ready to read and/or write. * NOTE:   Assumes that uartRecord0.configured is TRUE if this interrupt is enabled. * * @param   void * * @return  void**************************************************************************************************/void HalUart0ISR(void){  UARTIntClear(HAL_UART0_PORT, (UART_INT_RX/* |  UART_INT_RT*/));  procRxUART0();  UARTIntClear(HAL_UART0_PORT, (UART_INT_TX/* | UART_INT_CTS*/));  procTxUART0();}/************************************************************************************************* * @fn      UART Rx/Tx ISR * * @brief   Called when a serial byte is ready to read and/or write. * NOTE:   Assumes that uartRecord1.configured is TRUE if this interrupt is enabled. * * @param   void * * @return  void**************************************************************************************************/void HalUart1ISR(void){  UARTIntClear(HAL_UART1_PORT, (UART_INT_RX |  UART_INT_RT));  procRxUART1();  UARTIntClear(HAL_UART1_PORT, (UART_INT_TX | UART_INT_CTS));  procTxUART1();}/***************************************************************************************************/

• 修改完以上两个文件以后，很多人认为就可以使用两路UART了，其实不行，由于TI默认使用的是UART1，只有UART1的中断处理函数加入到了中断向量表中，UART0是没有加进去的，很多人可能就卡在这里，上去直接读写UART0总是莫名其妙导致OSAL死掉。解决方法就是我们必须修改中断向量表，打开文件C:\Texas Instruments\Z-Stack 3.0.0\Components\hal\target\CC2538\startup_ewarm.c，定位到221行，我们发现UART0中断被默认丢给了IntDefaultHandler函数处理，我们改为interrupt_uart0函数，同时在前面声明一下函数extern void interrupt_uart0(void);

    interrupt_uart0,                        // 21 UART0 Rx and Tx#ifdef HAL_UART_USB       IntDefaultHandler,                      // 22 UART1 Rx and Tx#else    interrupt_uart1,                        // 22 UART1 Rx and Tx#endif    IntDefaultHandler,                      // 23 SSI0 Rx and Tx

• 最后重新编译整个工程，测试，两个UART同时完美工作！