自学教程：C++ Assert_Param函数代码示例

/*********************************************************************************************************//** * @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;}