rt-thread/bsp/Vango/v85xxp/Libraries/VangoV85xxP_standard_peripheral/Source/lib_uart.c

/**
  ******************************************************************************
  * @file    lib_uart.c 
  * @author  Application Team
  * @version V1.1.0
  * @date    2019-10-28
  * @brief   UART library.
  ******************************************************************************
  * @attention
  *
  ******************************************************************************
  */
#include "lib_uart.h"
#include "lib_clk.h"

#define UART_STATE_RCMsk       (0xBCUL)
#define UART_INTSTS_RCMsk      (0x3FUL)
#define UART_BAUDDIV_RSTValue  (0UL)
#define UART_CTRL_RSTValue     (0UL)
#define UART_CTRL2_RSTValue    (0UL)

/**
  * @brief  Iinitializes the UARTx peripheral registers to their default reset 
            values.
  * @param  UARTx: UART0~UART5
  * @retval None
  */
void UART_DeInit(UART_Type *UARTx)
{ 
  __IO uint32_t dummy_data = 0UL;

  /* Check parameters */
  assert_parameters(IS_UART_ALL_INSTANCE(UARTx));

  /* read data, clear RXFULL flag */
  dummy_data = UARTx->DATA;
  dummy_data += 1;

  UARTx->INTSTS = UART_INTSTS_RCMsk;
  UARTx->STATE = UART_STATE_RCMsk;
  UARTx->BAUDDIV = UART_BAUDDIV_RSTValue;
  UARTx->CTRL2 = UART_CTRL2_RSTValue;
  UARTx->CTRL = UART_CTRL_RSTValue;
}

/**
  * @brief  Iinitializes UART.
  * @param  UARTx: UART0~UART5
            InitStruct:UART configuration.
                Mode: (between UART_MODE_RX and UART_MODE_TX, can use the '|' operator)
                    UART_MODE_RX
                    UART_MODE_TX
                    UART_MODE_OFF
                Parity:
                    UART_PARITY_EVEN 
                    UART_PARITY_ODD
                    UART_PARITY_0
                    UART_PARITY_1
                    UART_PARITY_NONE
                FirstBit:
                    UART_FIRSTBIT_LSB
                    UART_FIRSTBIT_MSB
                Baudrate: Baudrate value, 300UL ~ 819200UL
  * @retval None
  */
void UART_Init(UART_Type *UARTx, UART_InitType *InitStruct)
{
  uint32_t pclk;
  uint32_t div;
  uint32_t tmp_reg1, tmp_reg2;

  /* Check parameters */
  assert_parameters(IS_UART_ALL_INSTANCE(UARTx));
  assert_parameters(IS_UART_MODE(InitStruct->Mode));
  assert_parameters(IS_UART_PARITY(InitStruct->Parity));
  assert_parameters(IS_UART_FIRSTBIT(InitStruct->FirstBit));
  assert_parameters(IS_UART_BAUDRATE(InitStruct->Baudrate));

  tmp_reg1 = UARTx->CTRL;
  tmp_reg1 &= ~(UART_CTRL_RXEN_Msk\
               |UART_CTRL_TXEN_Msk);
  tmp_reg1 |= (InitStruct->Mode);
    
  tmp_reg2 = UARTx->CTRL2;
  tmp_reg2 &= ~(UART_CTRL2_MSB_Msk \
               |UART_CTRL2_PMODE_Msk);
  tmp_reg2 |= (InitStruct->Parity\
              |InitStruct->FirstBit);
  UARTx->CTRL2 = tmp_reg2;

  pclk = CLK_GetPCLKFreq();
  div = pclk/InitStruct->Baudrate;
    
  if ((pclk%InitStruct->Baudrate) > (InitStruct->Baudrate/2))
  {
    div++;
  }

  UARTx->BAUDDIV = div; 
  UARTx->CTRL = tmp_reg1;
}

/**
  * @brief  Fills each UART_InitType member with its default value.
  * @param  InitStruct: pointer to an UART_InitType structure which will be initialized.
  * @retval None
  */
void UART_StructInit(UART_InitType *InitStruct)
{
  /*-------------- Reset UART init structure parameters values ---------------*/
  /* Initialize the Baudrate member */
  InitStruct->Baudrate = 9600;
  /* Initialize the FirstBit member */
  InitStruct->FirstBit = UART_FIRSTBIT_LSB; 
  /* Initialize the Mode member */
  InitStruct->Mode = UART_MODE_OFF; 
  /* Initialize the Parity member */
  InitStruct->Parity = UART_PARITY_NONE;  
}

/**
  * @brief  Gets peripheral flag.
  * @param  UARTx: UART0~UART5
            FlagMask: flag to get.
            --UART_FLAG_DMATXDONE
            --UART_FLAG_RXPARITY
            --UART_FLAG_TXDONE  
            --UART_FLAG_RXPE    
            --UART_FLAG_RXOV    
            --UART_FLAG_TXOV    
            --UART_FLAG_RXFULL  
  * @retval 1:flag set
            0:flag reset
  */
uint8_t UART_GetFlag(UART_Type *UARTx, uint32_t FlagMask)
{
  /* Check parameters */
  assert_parameters(IS_UART_ALL_INSTANCE(UARTx));
  assert_parameters(IS_UART_FLAGR(FlagMask));

  if (UARTx->STATE&FlagMask)
  {
    return 1;
  }
  else
  {
    return 0;
  }
}

/**
  * @brief  Clears peripheral flag.
  * @param  UARTx: UART0~UART5
            FlagMask: status to clear, can use the '|' operator.
            --UART_FLAG_DMATXDONE
            --UART_FLAG_TXDONE 
            --UART_FLAG_RXPE     
            --UART_FLAG_RXOV     
            --UART_FLAG_TXOV     
  * @retval None
  */
void UART_ClearFlag(UART_Type *UARTx, uint32_t FlagMask)
{
  /* Check parameters */
  assert_parameters(IS_UART_ALL_INSTANCE(UARTx));
  assert_parameters(IS_UART_FLAGC(FlagMask));
  
  UARTx->STATE = FlagMask;
}

/**
  * @brief  Enables or disables the specified UART interrupts.
  * @param  UARTx: UART0~UART5
            INTMask: can use the '|' operator.
            --UART_INT_TXDONE
            --UART_INT_RXPE   
            --UART_INT_RXOV   
            --UART_INT_TXOV   
            --UART_INT_RX        
            NewState:New status of interrupt mask.
  * @retval None
  */
void UART_INTConfig(UART_Type *UARTx, uint32_t INTMask, uint8_t NewState)
{
  /* Check parameters */
  assert_parameters(IS_UART_ALL_INSTANCE(UARTx));
  assert_parameters(IS_UART_INT(INTMask));
  assert_parameters(IS_FUNCTIONAL_STATE(NewState));
  
  if (NewState == ENABLE)
  {
    UARTx->CTRL |= INTMask;
  }
  else
  {
    UARTx->CTRL &= ~INTMask;
  }
}

/**
  * @brief  Gets interrupt status.
  * @param  UARTx: UART0~UART5
            INTMask: status to get.
            --UART_INTSTS_TXDONE
            --UART_INTSTS_RXPE    
            --UART_INTSTS_RXOV    
            --UART_INTSTS_TXOV    
            --UART_INTSTS_RX      
  * @retval 1:status set
            0:status reset
  */
uint8_t UART_GetINTStatus(UART_Type *UARTx, uint32_t INTMask)
{
  /* Check parameters */
  assert_parameters(IS_UART_ALL_INSTANCE(UARTx));
  assert_parameters(IS_UART_INTFLAGR(INTMask));
  
  if (UARTx->INTSTS&INTMask)
  {
    return 1;
  }
  else
  {
    return 0;
  }
}

/**
  * @brief  Clears interrupt status.
  * @param  UARTx: UART0~UART5
            INTMask: status to clear, can use the '|' operator.
            --UART_INTSTS_TXDONE
            --UART_INTSTS_RXPE  
            --UART_INTSTS_RXOV  
            --UART_INTSTS_TXOV  
            --UART_INTSTS_RX      
  * @retval None
  */
void UART_ClearINTStatus(UART_Type *UARTx, uint32_t INTMask)
{
  /* Check parameters */
  assert_parameters(IS_UART_ALL_INSTANCE(UARTx));
  assert_parameters(IS_UART_INTFLAGC(INTMask));
  
  UARTx->INTSTS = INTMask;
}

/**
  * @brief  Loads send data register.
  * @param  UARTx: UART0~USART5
            ch: data to send.
  * @retval None
  */
void UART_SendData(UART_Type *UARTx, uint8_t ch)
{
  /* Check parameters */
  assert_parameters(IS_UART_ALL_INSTANCE(UARTx));  
  
  UARTx->DATA = ch;
}

/**
  * @brief  Reads receive data register.
  * @param  UARTx: UART0~UART5
  * @retval The received data.
  */
uint8_t UART_ReceiveData(UART_Type *UARTx)
{
  /* Check parameters */
  assert_parameters(IS_UART_ALL_INSTANCE(UARTx));
  
  return UARTx->DATA;
}

/**
  * @brief  Configures UART baudrate.
  * @param  UARTx: UART0~UART5
            BaudRate: Baudrate value
  * @retval None
  */
void UART_BaudrateConfig(UART_Type *UARTx, uint32_t BaudRate)
{
  uint32_t pclk;
  uint32_t div;
  
  /* Check parameters */
  assert_parameters(IS_UART_ALL_INSTANCE(UARTx));
  assert_parameters(IS_UART_BAUDRATE(BaudRate));
    
  pclk = CLK_GetPCLKFreq();
  div = pclk/BaudRate;
  if ((pclk%BaudRate) > (BaudRate/2))
  {
    div++;
  }
    
  UARTx->BAUDDIV = div;
}

/**
  * @brief  Enables or disables UART Transmitter/Receiver.
  * @param  UARTx: UART0~UART5
            Mode:
                UART_MODE_RX
                UART_MODE_TX
            NewState:
                ENABLE
                DISABLE
  * @retval None
  */
void UART_Cmd(UART_Type *UARTx, uint32_t Mode, uint32_t NewState)
{
  /* Check parameters */
  assert_parameters(IS_UART_ALL_INSTANCE(UARTx));
  assert_parameters(IS_UART_MODE(Mode));
  assert_parameters(IS_FUNCTIONAL_STATE(NewState));
  
  if (NewState == ENABLE)
  {
    UARTx->CTRL |= Mode;
  }
  else
  {
    UARTx->CTRL &= ~Mode;
  }
}

/**
  * @brief  Gets UART configure information.
  * @param[in]  UARTx: UART0~UART5
  * @param[out] ConfigInfo: The pointer of UART configuration.
  * @retval None
  */
void UART_GetConfigINFO(UART_Type *UARTx, UART_ConfigINFOType *ConfigInfo)
{
  uint32_t tmp1, tmp2, tmp3;
  uint32_t pclk;
  
  /* Check parameters */
  assert_parameters(IS_UART_ALL_INSTANCE(UARTx));
    
  tmp1 = UARTx->CTRL;
  tmp2 = UARTx->BAUDDIV;
  pclk = CLK_GetPCLKFreq();
  tmp3 = UARTx->CTRL2;
    
  /* Mode_Transmit */
  if (tmp1 & UART_CTRL_TXEN_Msk)
    ConfigInfo->Mode_Transmit = 1;
  else
    ConfigInfo->Mode_Transmit = 0;
  
  /* Mode_Receive */
  if (tmp1 & UART_CTRL_RXEN_Msk)
    ConfigInfo->Mode_Receive = 1;
  else
    ConfigInfo->Mode_Receive = 0;
  
  /* Baudrate */
  ConfigInfo->Baudrate = pclk / tmp2; 
  
  /* LSB/MSB */
  if (tmp3 & UART_CTRL2_MSB_Msk)
    ConfigInfo->FirstBit = 1;
  else
    ConfigInfo->FirstBit = 0;
    
  /* Parity */
  ConfigInfo->Parity = (tmp3 & UART_CTRL2_PMODE) >> UART_CTRL2_PMODE_Pos;
}

/*********************************** END OF FILE ******************************/