/*********************************************************************************************************//**
* @brief USART SendData from Tx.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @param Data: the data to be transmitted.
* @retval None
************************************************************************************************************/
void USART_SendData(USART_TypeDef* USARTx, u16 Data)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_USART_DATA(Data));
USARTx->RBR = Data;
}
/*********************************************************************************************************//**
* @brief Clear both the write and read point in Tx FIFO or Rx FIFO.
* @param USARTx: where USARTx is the selected USART from the USART peripheral, x can be 0 or 1.
* @param USART_FIFODirection: Determine TX FIFO or Rx FIFO that is to be reset.
* This parameter can be any combination of the following values:
* @arg USART_FIFO_TX : Tx FIFO is to be reset
* @arg USART_FIFO_RX : Rx FIFO is to be reset
* @retval None
************************************************************************************************************/
void USART_FIFOReset(USART_TypeDef* USARTx, u32 USART_FIFODirection)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_USART_FIFO_DIRECTION(USART_FIFODirection));
USARTx->FCR |= USART_FIFODirection;
}
/*********************************************************************************************************//**
* @brief Set the vector table location and Offset.
* @param NVIC_VectTable: Specify if the vector table is in FLASH or RAM.
* This parameter can be one of the following values:
* @arg NVIC_VECTTABLE_RAM
* @arg NVIC_VECTTABLE_FLASH
* @param NVIC_Offset: Vector Table base offset field.
* This value must be a multiple of 0x100.
* @retval None
***********************************************************************************************************/
void NVIC_SetVectorTable(u32 NVIC_VectTable, u32 NVIC_Offset)
{
/* Check the parameters */
Assert_Param(IS_NVIC_VECTTABLE(NVIC_VectTable));
Assert_Param(IS_NVIC_OFFSET(NVIC_Offset));
SCB->VTOR = NVIC_VectTable | (NVIC_Offset & (u32)0x1FFFFF80);
}
/*********************************************************************************************************//**
* @brief Set the specified USART IrDA prescaler.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @param USART_IrDAPrescaler: Specify the USART IrDA prescaler.
* @retval None
************************************************************************************************************/
void USART_SetIrDAPrescaler(USART_TypeDef* USARTx, u32 USART_IrDAPrescaler)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_USART_IRDA_PRESCALER(USART_IrDAPrescaler));
/* Set the USART IrDA prescaler */
USARTx->ICR = (USARTx->ICR & RCR_ILPDVSR_Mask) | (USART_IrDAPrescaler << 0x08);
}
/*********************************************************************************************************//**
* @brief Set the specified USART guard time.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @param USART_GuardTime: Specify the guard time.
* @retval None
************************************************************************************************************/
void USART_SetGuardTime(USART_TypeDef* USARTx, u32 USART_GuardTime)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_USART_GUARD_TIME(USART_GuardTime));
/* Set the USART guard time */
USARTx->TPR = (USARTx->TPR & TPR_TG_Mask) | (USART_GuardTime << 0x08);
}
/*********************************************************************************************************//**
* @brief Set the value of USART FIFO Time Out.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @param USART_TimeOut: Specify the value of Time Out.
* @retval None
************************************************************************************************************/
void USART_SetTimeOutValue(USART_TypeDef* USARTx, u32 USART_TimeOut)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_USART_TIMEOUT(USART_TimeOut));
/* Set the USART time out */
USARTx->TPR = (USARTx->TPR & TPR_RTOIC_Mask) | USART_TimeOut;
}
/*********************************************************************************************************//**
* @brief Set the specified USART RS485 address match value.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @param USART_AddressMatchValue: specify the RS485 address match value.
* @retval None
************************************************************************************************************/
void USART_SetAddressMatchValue(USART_TypeDef* USARTx, u32 USART_AddressMatchValue)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_USART_ADDRESS_MATCH_VALUE(USART_AddressMatchValue));
/* Set the USART guard time */
USARTx->RCR = (USARTx->RCR & RS485CR_ADDM_Mask) | (u32)(USART_AddressMatchValue<<0x08);
}
/*********************************************************************************************************//**
* @brief Clear the specific PDMA channel interrupt flags
* @param PDMA_Ch: PDMA_CH0 ~ PDMACH7
* @param PDMA_Flag: PDMA_FLAG_GE, PDMA_FLAG_BE, PDMA_FLAG_HT, PDMA_FLAG_TC, PDMA_FLAG_TE
* @retval None
***********************************************************************************************************/
void PDMA_ClearFlag(u32 PDMA_Ch, u32 PDMA_Flag)
{
u32 *PdmaIntStatClrReg = (PDMA_Ch < 6) ? ((u32 *)(&HT_PDMA->ISCR0)) : ((u32 *)(&HT_PDMA->ISCR1));
u32 BitShift = (PDMA_Ch < 6) ? (PDMA_Ch * 5) : ((PDMA_Ch - 6) * 5);
/* Check the parameters */
Assert_Param(IS_PDMA_CH(PDMA_Ch));
Assert_Param(IS_PDMA_CLEAR_FLAG(PDMA_Flag));
*PdmaIntStatClrReg |= (PDMA_Flag << BitShift);
}
/*********************************************************************************************************//**
* @brief Configure the Tx FIFO Interrupt Trigger Level.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @param USART_TFITL: Specify the USART Tx FIFO interrupt trigger level.
* This parameter can be one of the following values:
* @arg USART_TFITL_00
* @arg USART_TFITL_02
* @arg USART_TFITL_04
* @arg USART_TFITL_08
* @retval None
************************************************************************************************************/
void USART_TFITLConfig(USART_TypeDef* USARTx, u32 USART_TFITL)
{
u32 tmpreg = 0x00;
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_USART_TFITL(USART_TFITL));
tmpreg = USARTx->FCR & FCR_TFITL_CLEAR_Mask;
/* Set the USART TFITL */
USARTx->FCR = tmpreg | USART_TFITL;
}
/*********************************************************************************************************//**
* @brief PDMA_TranSizeConfig
* @param PDMA_Ch: PDMA_CH0 ~ PDMACH7
* @param BlkCnt: Number of blocks for a transfer
* @param BlkLen: Number of data for a block
* @retval None
***********************************************************************************************************/
void PDMA_TranSizeConfig(u32 PDMA_Ch, u32 BlkCnt, u32 BlkLen)
{
HT_PDMACH_TypeDef *PDMACHx = (HT_PDMACH_TypeDef *)(HT_PDMA_BASE + PDMA_Ch * 6 * 4);
/* Check the parameters */
Assert_Param(IS_PDMA_CH(PDMA_Ch));
Assert_Param(IS_PDMA_BLK_CNT(BlkCnt));
Assert_Param(IS_PDMA_BLK_LEN(BlkLen));
/* transfer size configuration */
PDMACHx->TSR = ((BlkCnt << 16) | BlkLen);
}
/*********************************************************************************************************//**
* @brief Configure the USART IrDA interface.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @param USART_IrDAMode: Specify the USART IrDA mode.
* This parameter can be one of the following values:
* @arg USART_IRDA_LOWPOWER
* @arg USART_IRDA_NORMAL
* @retval None
************************************************************************************************************/
void USART_IrDAConfig(USART_TypeDef* USARTx, u32 USART_IrDAMode)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_USART_IRDA_MODE(USART_IrDAMode));
if (USART_IrDAMode != USART_IRDA_NORMAL)
{
USARTx->ICR |= USART_IRDA_LOWPOWER;
}
else
{
USARTx->ICR &= USART_IRDA_NORMAL;
}
}
/*********************************************************************************************************//**
* @brief Configure the polarity of RS485 transmitter enable signal.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @param USART_RS485Polarity: Specify the polarity of USART RS485 Tx enable signal.
* This parameter can be one of the following values:
* @arg USART_RS485POL_LOW
* @arg USART_RS485POL_HIGH
* @retval None
************************************************************************************************************/
void USART_RS485TxEnablePolarityConfig(USART_TypeDef* USARTx, u32 USART_RS485Polarity)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_USART_RS485_POLARITY(USART_RS485Polarity));
if (USART_RS485Polarity != USART_RS485POLARITY_HIGH)
{
USARTx->RCR |= USART_RS485POLARITY_LOW;
}
else
{
USARTx->RCR &= USART_RS485POLARITY_HIGH;
}
}
/*********************************************************************************************************//**
* @brief Select which low power mode to execute to the system.
* @param NVIC_LowPowerMode: Specify the new low power mode to execute to the system.
* This parameter can be one of the following values:
* @arg NVIC_LOWPOWER_SEVONPEND
* @arg NVIC_LOWPOWER_SLEEPDEEP
* @arg NVIC_LOWPOWER_SLEEPONEXIT
* @param NewState: new state of low power condition.
* This parameter can be: ENABLE or DISABLE.
* @retval None
***********************************************************************************************************/
void NVIC_LowPowerConfig(u8 NVIC_LowPowerMode, ControlStatus NewState)
{
/* Check the parameters */
Assert_Param(IS_NVIC_LOWPOWER(NVIC_LowPowerMode));
Assert_Param(IS_CONTROL_STATUS(NewState));
if (NewState != DISABLE)
{
SCB->SCR |= NVIC_LowPowerMode;
}
else
{
SCB->SCR &= (u32)(~(u32)NVIC_LowPowerMode);
}
}
/*********************************************************************************************************//**
* @brief Enable or Disable inverting serial input function of IrDA on the specified USART.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @param NewState: new state of the inverting serial input.
* This parameter can be: ENABLE or DISABLE.
* @retval None
************************************************************************************************************/
void USART_IrDAInvtInputCmd(USART_TypeDef* USARTx, ControlStatus NewState)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_CONTROL_STATUS(NewState));
if (NewState != DISABLE)
{
USARTx->ICR |= USART_RXINV_ON;
}
else
{
USARTx->ICR &= USART_RXINV_OFF;
}
}
/*********************************************************************************************************//**
* @brief Enable or Disable the USART stick parity function.
* @param USARTx: where USARTx is the selected USART from the USART peripheral, x can be 0 or 1.
* @param NewState: new state of the stick parity.
* This parameter can be: ENABLE or DISABLE
* @retval None
************************************************************************************************************/
void USART_StickParityCmd(USART_TypeDef* USARTx, ControlStatus NewState)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_CONTROL_STATUS(NewState));
if (NewState != DISABLE)
{
USARTx->LCR |= USART_SPE_ON;
}
else
{
USARTx->LCR &= USART_SPE_OFF;
}
}
/*********************************************************************************************************//**
* @brief Configure stick parity value of the USART.
* @param USARTx: where USARTx is the selected USART from the USART peripheral, x can be 0 or 1.
* @param USART_StickParity: Specify stick parity of the USART.
* This parameter can be one of the following values
* @arg USART_STICK_LOW
* @arg USART_STICK_HIGH
* @retval None
************************************************************************************************************/
void USART_StickParityConfig(USART_TypeDef * USARTx, u32 USART_StickParity)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_USART_STICK_PARITY(USART_StickParity));
if (USART_StickParity != USART_STICK_HIGH)
{
USARTx->LCR |= USART_STICK_LOW;
}
else
{
USARTx->LCR &= USART_STICK_HIGH;
}
}
/*********************************************************************************************************//**
* @brief Enable or Disable the USART interrupts.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @param USART_IER: Specify if the USART interrupt source to be enabled or disabled.
* This parameter can be one of the following values:
* @arg USART_IER_MSIE
* @arg USART_IER_RLSIE
* @arg USART_IER_THREIE
* @arg USART_IER_RDAIE
* @arg USART_IER_ENON
* @param NewState: new state of the USART interrupts.
* This parameter can be: ENABLE or DISABLE.
* @retval None
************************************************************************************************************/
void USART_IntConfig(USART_TypeDef* USARTx, u32 USART_IER, ControlStatus NewState)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_CONTROL_STATUS(NewState));
if (NewState != DISABLE)
{
USARTx->IER |= USART_IER;
}
else
{
USARTx->IER &= ~USART_IER;
}
}
/*********************************************************************************************************//**
* @brief Enable the IrDA transmitter or receiver.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @param USART_IrDADirection: Specify the USART IrDA direction select.
* This parameter can be one of the following values:
* @arg USART_IRDA_TX
* @arg USART_IRDA_RX
* @retval None
************************************************************************************************************/
void USART_IrDADirectionConfig(USART_TypeDef* USARTx, u32 USART_IrDADirection)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_USART_IRDA_DIRECTION(USART_IrDADirection));
if (USART_IrDADirection != USART_IRDA_RX)
{
USARTx->ICR |= USART_IRDA_TX;
}
else
{
USARTx->ICR &= USART_IRDA_RX;
}
}
/*********************************************************************************************************//**
* @brief Enable or Disable time out interrupt of the USART.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @param NewState: new state of the time out interrupt.
* This parameter can be: ENABLE or DISABLE.
* @retval None
************************************************************************************************************/
void USART_TimeOutIntConfig(USART_TypeDef* USARTx, ControlStatus NewState)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_CONTROL_STATUS(NewState));
if (NewState != DISABLE)
{
USARTx->TPR |= USART_TIMEOUT_ON;
}
else
{
USARTx->TPR &= USART_TIMEOUT_OFF;
}
}
/*********************************************************************************************************//**
* @brief Deinitialize registers of the USART peripheral by resetting USART.
* @param USARTx: where USARTx is USART to select the USART peripheral.
* @retval None
************************************************************************************************************/
void USART_DeInit(USART_TypeDef* USARTx)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
RSTCU_APBPerip0Reset(RSTCU_APBRST0_USART, ENABLE);
}
/*********************************************************************************************************//**
* @brief USART ReceiveData from Rx.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @return The received data.
************************************************************************************************************/
u16 USART_ReceiveData(USART_TypeDef* USARTx)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
return (u16)USARTx->RBR;
}
/*********************************************************************************************************//**
* @brief Get Interrupt ID value.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @retval The interrupt ID of USART.
* @arg USART_IID_RLS
* @arg USART_IID_RDA
* @arg USART_IID_CTI
* @arg USART_IID_THRE
* @arg USART_IID_MS
* @arg USART_IID_NON
************************************************************************************************************/
u8 USART_GetIntID(USART_TypeDef* USARTx)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
return (u8)USARTx->IIR;
}
/*********************************************************************************************************//**
* @brief Get Modem status.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @return The current status of Modem Status Register.
************************************************************************************************************/
u8 USART_GetModemStatus(USART_TypeDef* USARTx)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
return (u8)USARTx->MSR;
}
/*********************************************************************************************************//**
* @brief Set delta value of the WDT.
* @param WDT_WDTD : specify the WDT Delta value.
* This parameter must be a number between 0 and 0x0FFF.
* @retval None
************************************************************************************************************/
void WDT_SetDeltaValue(u16 WDT_WDTD)
{
/* Check the parameters */
Assert_Param(IS_WDT_DELTA(WDT_WDTD));
WDT->MR1 = (WDT_WDTD | (WDT->MR1 & 0x00007000));
}
/*********************************************************************************************************//**
* @brief Set Prescaler value of the WDT.
* @param WDT_PRESCALER: specify the WDT Prescaler value.
* This parameter can be one of the following values:
* @arg WDT_PRESCALER_1 : WDT prescaler set to 1
* @arg WDT_PRESCALER_2 : WDT prescaler set to 2
* @arg WDT_PRESCALER_4 : WDT prescaler set to 4
* @arg WDT_PRESCALER_8 : WDT prescaler set to 8
* @arg WDT_PRESCALER_16 : WDT prescaler set to 16
* @arg WDT_PRESCALER_32 : WDT prescaler set to 32
* @arg WDT_PRESCALER_64 : WDT prescaler set to 64
* @arg WDT_PRESCALER_128 : WDT prescaler set to 128
* @retval None
************************************************************************************************************/
void WDT_SetPrescaler(u16 WDT_PRESCALER)
{
/* Check the parameters */
Assert_Param(IS_WDT_PRESCALER(WDT_PRESCALER));
WDT->MR1 = (WDT_PRESCALER | (WDT->MR1 & 0x00000FFF));
}
/*********************************************************************************************************//**
* @brief Enters DEEP-SLEEP Mode 1.
* @param SleepEntry : Enters sleep mode instruction that is used to WFI or WFE.
* This parameter can be one of the following values:
* @arg PWRCU_SLEEP_ENTRY_WFE: Enters SLEEP mode via WFE instruction.
* @arg PWRCU_SLEEP_ENTRY_WFI: Enters SLEEP mode via WFI instruction.
* @retval None
************************************************************************************************************/
void PWRCU_DeepSleep1(PWRCU_SLEEP_ENTRY_Enum SleepEntry)
{
u32 uRTCStatus = 0;
u32 uADCStatus = 0;
Assert_Param(IS_PWRCU_SLEEP_ENTRY(SleepEntry));
uRTCStatus = BB_RTCEN;
uADCStatus = BB_ADCEN;
BB_RTCEN = 1;
BB_ADCEN = 0;
BB_DMOSON = 0x0;
BB_LDOOFF = 0x0;
BB_RTCEN = uRTCStatus;
/* Sets SLEEPDEEP bit of Cortex System Control Register */
SCB->SCR |= SLEEPDEEP_SET;
if (SleepEntry == PWRCU_SLEEP_ENTRY_WFE)
{
/* Wait for event */
__WFE();
}
else
{
/* Wait for interrupt */
__WFI();
}
BB_ADCEN = uADCStatus;
}
/*********************************************************************************************************//**
* @brief Force pin DTR/RTS to low or high state.
* @param USARTx: where USARTx is USART to select the USART peripheral, x can be 0 or 1.
* @param USART_ModemPin: Specify the USART modem pin to be forced.
* This parameter can be one of the following values:
* @arg USART_MODEM_DTR
* @arg USART_MODEM_RTS
* @param USART_ModemState: the USART modem pin state.
* This parameter can be one of the following values:
* @arg USART_MODEMSTATE_HIGH
* @arg USART_MODEMSTATE_LOW
* @return None
************************************************************************************************************/
void USART_ForceModemPinState(USART_TypeDef* USARTx, u32 USART_ModemPin, u32 USART_ModemState)
{
/* Check the parameters */
Assert_Param(IS_USART(USARTx));
Assert_Param(IS_USART_MODEM_PIN(USART_ModemPin));
Assert_Param(IS_USART_MODEM_STATE(USART_ModemState));
if (USART_ModemState != USART_MODEMSTATE_HIGH)
{
USARTx->MCR |= USART_MODEMSTATE_LOW << USART_ModemPin;
}
else
{
USARTx->MCR &= ~(USART_MODEMSTATE_HIGH << USART_ModemPin);
}
}
/*********************************************************************************************************//**
* @brief Set SysTick counter reload value.
* @param SysTick_Reload: SysTick reload new value.
* This parameter must be a number between 1 and 0xFFFFFF.
* @retval None
***********************************************************************************************************/
void SYSTICK_SetReloadValue(u32 SysTick_Reload)
{
/* Check the parameters */
Assert_Param(IS_SYSTICK_RELOAD(SysTick_Reload));
SysTick->LOAD = SysTick_Reload;
}
/*********************************************************************************************************//**
* @brief Set Reload value of the WDT.
* @param WDT_WDTV : specify the WDT Reload value.
* This parameter must be a number between 0 and 0x0FFF.
* @retval None
************************************************************************************************************/
void WDT_SetReloadValue(u16 WDT_WDTV)
{
/* Check the parameters */
Assert_Param(IS_WDT_RELOAD(WDT_WDTV));
WDT->MR0 = WDT_WDTV | (WDT->MR0 & 0x0000F000);
}
/*********************************************************************************************************//**
* @brief Set the pending bit for a system handler.
* @param SystemHandler: Specify the system handler pending bit to be set.
* This parameter can be one of the following values:
* @arg SYSTEMHANDLER_NMI
* @arg SYSTEMHANDLER_PSV
* @arg SYSTEMHANDLER_SYSTICK
* @retval None
***********************************************************************************************************/
void NVIC_SetPendingSystemHandler(u32 SystemHandler)
{
/* Check the parameters */
Assert_Param(IS_NVIC_SYSTEMHANDLER(SystemHandler));
/* Set the corresponding System Handler pending bit */
SCB->ICSR |= SystemHandler;
}
