uart.c

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

  UART_InitStructure.UART_RxFIFOLevel = UART_FIFOLevel_1_8;
  UART_InitStructure.UART_TxFIFOLevel = UART_FIFOLevel_1_4;
  UART_InitStructure.UART_Parity = UART_Parity_No;
  SCU_BRCLKDivisorConfig(SCU_BRCLK_Div2);

  switch(Uart)
  {
  case UART_0:
    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);
    // Enable UART0 and PORTs clocks
    SCU_APBPeriphClockConfig(__UART0 | __GPIO3 | __GPIO5, ENABLE);
    // Release UART0 and PORTs reset
    SCU_APBPeriphReset(__UART0 | __GPIO3 | __GPIO5,DISABLE);

    // Assign GPIO 3.4 to UART0 (Tx)
    GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
    GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
    GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Enable;
    GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt3;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    GPIO_Init(GPIO3, &GPIO_InitStructure);

    // Assign GPIO 5.1 to UART0 (Rx)
    GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
    GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
    GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Enable;
    GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
    GPIO_Init (GPIO5, &GPIO_InitStructure);

    // Init UART0
    UART_Init(UART0,&UART_InitStructure);
    UART_DMACmd(UART0,UART_DMAReq_Tx | UART_DMAReq_Rx, DISABLE);

    // Enable and configure the priority of the UART0 Update IRQ Channel
    VIC_Config(UART0_ITLine, VIC_IRQ, IntrPriority);
    VIC_ITCmd(UART0_ITLine, ENABLE);

    // 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;

    // Enable UART1 and PORTs clocks
    SCU_APBPeriphClockConfig(__UART1 | __GPIO3, ENABLE);
    // Release UART1 and PORTs reset
    SCU_APBPeriphReset(__UART1 | __GPIO3,DISABLE);

    // Assign GPIO 3.3 to UART1 (Tx)
    GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
    GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
    GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Enable;
    GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt3;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    GPIO_Init(GPIO3, &GPIO_InitStructure);

    // Assign GPIO 3.2 to UART1 (Rx)
    GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
    GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Enable;
    GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_Init(GPIO3, &GPIO_InitStructure);

    // Init UART1
    UART_Init(UART1,&UART_InitStructure);
    UART_DMACmd(UART1,UART_DMAReq_Tx | UART_DMAReq_Rx, DISABLE);

    // Enable and configure the priority of the UART1 Update IRQ Channel
    VIC_Config(UART1_ITLine, VIC_IRQ, IntrPriority);
    VIC_ITCmd(UART1_ITLine, ENABLE);

    // 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;

    // Enable UART2 and PORTs clocks
    SCU_APBPeriphClockConfig(__UART2 | __GPIO3, ENABLE);
    // Release UART2 and PORTs reset
    SCU_APBPeriphReset(__UART2 | __GPIO3,DISABLE);

    // Assign GPIO 3.0 to UART2 (Tx)
    GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
    GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
    GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Enable;
    GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt3;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    GPIO_Init(GPIO3, &GPIO_InitStructure);

    // Assign GPIO 3.1 to UART2 (Rx)
    GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
    GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Enable;
    GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
    GPIO_Init(GPIO3, &GPIO_InitStructure);

    // Init UART2
    UART_Init(UART2,&UART_InitStructure);
    UART_DMACmd(UART2,UART_DMAReq_Tx | UART_DMAReq_Rx, DISABLE);

    // Enable and configure the priority of the UART2 Update IRQ Channel
    VIC_Config(UART2_ITLine, VIC_IRQ, IntrPriority);
    VIC_ITCmd(UART2_ITLine, ENABLE);

    // 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;
Int32U Save;

  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(UART0,UART_FLAG_TxFIFOFull) != SET)
    {
      do
      {
        Save = __get_interrupt_state();
        __disable_interrupt();
        if(!FifoPop(pUart0TxFifo,&Data))
        {
          __set_interrupt_state(Save);
          // The tx software FIFO is empty
          break;
        }
        UART_SendData(pUart,Data);
        __set_interrupt_state(Save);
      }
      while(UART_GetFlagStatus(UART0,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);
}