uart.c

最新版IAR FOR ARM（EWARM）5.11中的代码例子

    pUart0RxFifo = (pUartFifo_t)malloc(sizeof(UartFifo_t));
    if(pUart0RxFifo == NULL)
    {
      return(FALSE);
    }
    pUart0TxFifo = (pUartFifo_t)malloc(sizeof(UartFifo_t));
    if(pUart0TxFifo == NULL)
    {
      free(pUart0RxFifo);
      return(FALSE);
    }
    // Init receive and transmit FIFOs
    pUart0RxFifo->PopIndx = pUart0RxFifo->PushIndx = \
    pUart0TxFifo->PopIndx = pUart0TxFifo->PushIndx = 0;

    // Release reset and enable clock
    UART_DeInit(UART0);
    MRCC_PeripheralClockConfig(MRCC_Peripheral_UART0, ENABLE);

    // Assign GPIO 0.11 to UART0 (Tx)
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Pin = 1UL<<11;
    GPIO_Init(GPIO0, &GPIO_InitStructure);
    // Assign GPIO 0.10 to UART0 (Rx)
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_InitStructure.GPIO_Pin = 1UL<<10;
    GPIO_Init(GPIO0, &GPIO_InitStructure);

    // Init UART0
    UART_Init(UART0,&UART_InitStructure);

    // Enable and configure the priority of the UART0 Update IRQ Channel
    EIC_IRQInitStructure.EIC_IRQChannel = UART0_IRQChannel;
    EIC_IRQInitStructure.EIC_IRQChannelPriority = IrqSlot;
    EIC_IRQInitStructure.EIC_IRQChannelCmd = ENABLE;
    EIC_IRQInit(&EIC_IRQInitStructure);

    // Enable UART0 interrupts
    UART_ITConfig(UART0, UART_IT_OverrunError   |
                         UART_IT_BreakError     |
                         UART_IT_ParityError    |
                         UART_IT_FrameError     |
                         UART_IT_ReceiveTimeOut |
                         UART_IT_Transmit       |
                         UART_IT_Receive        , ENABLE);

    // Enable the UART0
    UART_Cmd(UART0, ENABLE);
    break;
  case UART_1:
    pUart1RxFifo = (pUartFifo_t)malloc(sizeof(UartFifo_t));
    if(pUart1RxFifo == NULL)
    {
      return(FALSE);
    }
    pUart1TxFifo = (pUartFifo_t)malloc(sizeof(UartFifo_t));
    if(pUart1TxFifo == NULL)
    {
      free(pUart1RxFifo);
      return(FALSE);
    }
    // Init receive and transmit FIFOs
    pUart1RxFifo->PopIndx = pUart1RxFifo->PushIndx = \
    pUart1TxFifo->PopIndx = pUart1TxFifo->PushIndx = 0;

    // Release reset and enable clock
    UART_DeInit(UART1);
    MRCC_PeripheralClockConfig(MRCC_Peripheral_UART1, ENABLE);

    // Assign GPIO 0.21 to UART1 (Tx)
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Pin = 1UL<<21;
    GPIO_Init(GPIO0, &GPIO_InitStructure);
    // Assign GPIO 0.20 to UART1 (Rx)
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_InitStructure.GPIO_Pin = 1UL<<20;
    GPIO_Init(GPIO0, &GPIO_InitStructure);

    // Init UART1
    UART_Init(UART1,&UART_InitStructure);

    // Enable and configure the priority of the UART1 Update IRQ Channel
    EIC_IRQInitStructure.EIC_IRQChannel = UART1_IRQChannel;
    EIC_IRQInitStructure.EIC_IRQChannelPriority = IrqSlot;
    EIC_IRQInitStructure.EIC_IRQChannelCmd = ENABLE;
    EIC_IRQInit(&EIC_IRQInitStructure);

    // Enable UART1 interrupts
    UART_ITConfig(UART1, UART_IT_OverrunError   |
                         UART_IT_BreakError     |
                         UART_IT_ParityError    |
                         UART_IT_FrameError     |
                         UART_IT_ReceiveTimeOut |
                         UART_IT_Transmit       |
                         UART_IT_Receive        , ENABLE);

    // Enable the UART1
    UART_Cmd(UART1, ENABLE);
    break;
  case UART_2:
    pUart2RxFifo = (pUartFifo_t)malloc(sizeof(UartFifo_t));
    if(pUart2RxFifo == NULL)
    {
      return(FALSE);
    }
    pUart2TxFifo = (pUartFifo_t)malloc(sizeof(UartFifo_t));
    if(pUart2TxFifo == NULL)
    {
      free(pUart2RxFifo);
      return(FALSE);
    }
    // Init receive and transmit FIFOs
    pUart2RxFifo->PopIndx = pUart2RxFifo->PushIndx = \
    pUart2TxFifo->PopIndx = pUart2TxFifo->PushIndx = 0;

    // Release reset and enable clock
    UART_DeInit(UART2);
    MRCC_PeripheralClockConfig(MRCC_Peripheral_UART2, ENABLE);

    // Assign GPIO 0.25 to UART2 (Tx)
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Pin = 1UL<<25;
    GPIO_Init(GPIO0, &GPIO_InitStructure);
    // Assign GPIO 0.24 to UART2 (Rx)
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_InitStructure.GPIO_Pin = 1UL<<24;
    GPIO_Init(GPIO0, &GPIO_InitStructure);

    // Init UART2
    UART_Init(UART2,&UART_InitStructure);

    // Enable and configure the priority of the UART2 Update IRQ Channel
    EIC_IRQInitStructure.EIC_IRQChannel = UART2_IRQChannel;
    EIC_IRQInitStructure.EIC_IRQChannelPriority = IrqSlot;
    EIC_IRQInitStructure.EIC_IRQChannelCmd = ENABLE;
    EIC_IRQInit(&EIC_IRQInitStructure);

    // Enable UART2 interrupts
    UART_ITConfig(UART2, UART_IT_OverrunError   |
                         UART_IT_BreakError     |
                         UART_IT_ParityError    |
                         UART_IT_FrameError     |
                         UART_IT_ReceiveTimeOut |
                         UART_IT_Transmit       |
                         UART_IT_Receive        , ENABLE);

    // Enable the UART2/
    UART_Cmd(UART2, ENABLE);
  default:
    return(FALSE);
  }
  return(TRUE);
}

/*************************************************************************
 * Function Name: UartSetLineCoding
 * Parameters:  UartNum_t Uart,UART_InitTypeDef pUartCoding
 *
 * Return: None
 *
 * Description: Init UART Baud rate, Word width, Stop bits, Parity type
 *
 *************************************************************************/
void UartSetLineCoding(UartNum_t Uart,UART_InitTypeDef UartCoding)
{
UART_InitTypeDef  UART_InitStructure;
UART_TypeDef * pUart;

  UART_StructInit(&UART_InitStructure);

  switch(Uart)
  {
  case UART_0:
    pUart = UART0;
    break;
  case UART_1:
    pUart = UART1;
    break;
  case UART_2:
    pUart = UART2;
    break;
  default:
    return;
  }

  UART_InitStructure.UART_WordLength = UartCoding.UART_WordLength;
  UART_InitStructure.UART_StopBits   = UartCoding.UART_StopBits;
  UART_InitStructure.UART_Parity     = UartCoding.UART_Parity;
  UART_InitStructure.UART_BaudRate   = UartCoding.UART_BaudRate;

  UART_Init(pUart,&UART_InitStructure);

}

/*************************************************************************
 * Function Name: UartRead
 * Parameters:  UartNum_t Uart, pInt8U pBuffer, Int32U BufferSize
 *
 * Return: Int32U
 *
 * Description: Read received data from UART.
 *              Return number of readied characters
 *
 *************************************************************************/
Int32U UartRead(UartNum_t Uart, pInt8U pBuffer, Int32U BufferSize)
{
Int32U Count;
pUartFifo_t pUartFifo;

  switch(Uart)
  {
  case UART_0:
    pUartFifo = pUart0RxFifo;
    break;
  case UART_1:
    pUartFifo = pUart1RxFifo;
    break;
  case UART_2:
    pUartFifo = pUart2RxFifo;
    break;
  default:
    return(0);
  }

  for (Count = 0; Count < BufferSize; ++Count)
  {
    if(!FifoPop(pUartFifo,pBuffer+Count))
    {
      break;
    }
  }
  return(Count);
}

/*************************************************************************
 * Function Name: UartWrite
 * Parameters:  UartNum_t Uart, pInt8U pBuffer, Int32U BufferSize
 *
 * Return: Int32U
 *
 * Description: Write a data to UART. Return number of successful
 *  transmitted bytes
 *
 *************************************************************************/
Int32U UartWrite(UartNum_t Uart, pInt8U pBuffer, Int32U BufferSize)
{
Int32U Count = 0;
Int8U Data;
pUartFifo_t pUartFifo;
UART_TypeDef * pUart;
FunctionalState cpu_sr;

  switch(Uart)
  {
  case UART_0:
    pUart = UART0;
    pUartFifo = pUart0TxFifo;
    break;
  case UART_1:
    pUart = UART1;
    pUartFifo = pUart1TxFifo;
    break;
  case UART_2:
    pUart = UART2;
    pUartFifo = pUart2TxFifo;
    break;
  default:
    return(0);
  }

  if(BufferSize != 0)
  {
    for ( ; Count < BufferSize; ++Count)
    {
      if(!FifoPush(pUartFifo,*(pBuffer+Count)))
      {
        break;
      }
    }

    if(UART_GetFlagStatus(pUart,UART_FLAG_TxFIFOFull) != SET)
    {
      do
      {
        EIC_IRQDisCmd(cpu_sr);
        if(!FifoPop(pUartFifo,&Data))
        {
          EIC_IRQRestoreCmd(cpu_sr);
          // The tx software FIFO is empty
          break;
        }
        UART_SendData(pUart,Data);
        EIC_IRQRestoreCmd(cpu_sr);
      }
      while(UART_GetFlagStatus(pUart,UART_FLAG_TxFIFOFull) != SET);
    }

  }
  return(Count);
}

/*************************************************************************
 * Function Name: UartGetUartEvents
 * Parameters:  UartNum_t Uart
 *
 * Return: UartLineEvents_t
 *
 * Description: Get Uart Line events (PE,OE, FE, BI)
 *
 *************************************************************************/
UartLineEvents_t UartGetUartLineEvents (UartNum_t Uart)

{
UartLineEvents_t  LineEvents;
  LineEvents.Data = 0;
  switch(Uart)
  {
  case UART_0:
    LineEvents.Data = AtomicExchange(LineEvents.Data,
                                     &Uart0LineEvents.Data);
    break;
  case UART_1:
    LineEvents.Data = AtomicExchange(LineEvents.Data,
                                     &Uart1LineEvents.Data);
    break;
  case UART_2:
    LineEvents.Data = AtomicExchange(LineEvents.Data,
                                     &Uart2LineEvents.Data);
    break;
  }
  return(LineEvents);
}

/*************************************************************************
 * Function Name: UartSetUartLineState
 * Parameters:  UartNum_t Uart UartNum_t Uart, Boolean Break
 *
 * Return: none
 *
 * Description: Set Uart Break Event
 *
 *************************************************************************/
void UartSetUartLineState (UartNum_t Uart, Boolean Break)
{
UART_TypeDef * pUart;

  if(Break == FALSE)
  {
    return;
  }

  switch(Uart)
  {
  case UART_0:
    pUart = UART0;
    break;
  case UART_1:
    pUart = UART1;
    break;
  case UART_2:
    pUart = UART2;
    break;
  default:
    return;
  }
  UART_SendBreak(pUart);
}