#define assert_param(expr) ((void)0U)
CodeScope will show references to assert_param from the following samples and libraries:
Symbols ![]()
loading...
Files ![]()
loading...
assert_param macro
Syntax
Arguments
expr
Examples
assert_param is referenced by 1146 libraries and example projects.References
| Location | Text |
|---|---|
assert_param(IS_TICKFREQ(Freq)); | |
assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance)); | |
assert_param(IS_ADC_CLOCKPRESCALER(hadc->Init.ClockPrescaler)); | |
assert_param(IS_ADC_RESOLUTION(hadc->Init.Resolution)); | |
assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ScanConvMode)); | |
assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode)); | |
assert_param(IS_ADC_EXT_TRIG(hadc->Init.ExternalTrigConv)); | |
assert_param(IS_ADC_DATA_ALIGN(hadc->Init.DataAlign)); | |
assert_param(IS_ADC_REGULAR_LENGTH(hadc->Init.NbrOfConversion)); | |
assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DMAContinuousRequests)); | |
assert_param(IS_ADC_EOCSelection(hadc->Init.EOCSelection)); | |
assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DiscontinuousConvMode)); | |
assert_param(IS_ADC_EXT_TRIG_EDGE(hadc->Init.ExternalTrigConvEdge)); | |
assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance)); | |
assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode)); | |
assert_param(IS_ADC_EXT_TRIG_EDGE(hadc->Init.ExternalTrigConvEdge)); | |
assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance)); | |
assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance)); | |
assert_param(IS_ADC_EVENT_TYPE(EventType)); | |
assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode)); | |
assert_param(IS_ADC_EXT_TRIG_EDGE(hadc->Init.ExternalTrigConvEdge)); | |
assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance)); | |
assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode)); | |
assert_param(IS_ADC_REGULAR_LENGTH(hadc->Init.NbrOfConversion)); | |
assert_param(IS_ADC_EOCSelection(hadc->Init.EOCSelection)); | |
assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode)); | |
assert_param(IS_ADC_EXT_TRIG_EDGE(hadc->Init.ExternalTrigConvEdge)); | |
assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance)); | |
assert_param(IS_ADC_CHANNEL(sConfig->Channel)); | |
assert_param(IS_ADC_REGULAR_RANK(sConfig->Rank)); | |
assert_param(IS_ADC_SAMPLE_TIME(sConfig->SamplingTime)); | |
assert_param(IS_ADC_ANALOG_WATCHDOG(AnalogWDGConfig->WatchdogMode)); | |
assert_param(IS_ADC_CHANNEL(AnalogWDGConfig->Channel)); | |
assert_param(IS_FUNCTIONAL_STATE(AnalogWDGConfig->ITMode)); | |
assert_param(IS_ADC_RANGE(tmp, AnalogWDGConfig->HighThreshold)); | |
assert_param(IS_ADC_RANGE(tmp, AnalogWDGConfig->LowThreshold)); | |
assert_param(IS_ADC_REGULAR_DISC_NUMBER(hadc->Init.NbrOfDiscConversion)); | |
assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance)); | |
assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance)); | |
assert_param(IS_ADC_INJECTED_RANK(InjectedRank)); | |
assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode)); | |
assert_param(IS_ADC_EXT_TRIG_EDGE(hadc->Init.ExternalTrigConvEdge)); | |
assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DMAContinuousRequests)); | |
assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance)); | |
assert_param(IS_ADC_CHANNEL(sConfigInjected->InjectedChannel)); | |
assert_param(IS_ADC_INJECTED_RANK(sConfigInjected->InjectedRank)); | |
assert_param(IS_ADC_SAMPLE_TIME(sConfigInjected->InjectedSamplingTime)); | |
assert_param(IS_ADC_EXT_INJEC_TRIG(sConfigInjected->ExternalTrigInjecConv)); | |
assert_param(IS_ADC_INJECTED_LENGTH(sConfigInjected->InjectedNbrOfConversion)); | |
assert_param(IS_FUNCTIONAL_STATE(sConfigInjected->AutoInjectedConv)); | |
assert_param(IS_FUNCTIONAL_STATE(sConfigInjected->InjectedDiscontinuousConvMode)); | |
assert_param(IS_ADC_RANGE(tmp, sConfigInjected->InjectedOffset)); | |
assert_param(IS_ADC_EXT_INJEC_TRIG_EDGE(sConfigInjected->ExternalTrigInjecConvEdge)); | |
assert_param(IS_ADC_MODE(multimode->Mode)); | |
assert_param(IS_ADC_DMA_ACCESS_MODE(multimode->DMAAccessMode)); | |
assert_param(IS_ADC_SAMPLING_DELAY(multimode->TwoSamplingDelay)); | |
assert_param(IS_CAN_ALL_INSTANCE(hcan->Instance)); | |
assert_param(IS_FUNCTIONAL_STATE(hcan->Init.TimeTriggeredMode)); | |
assert_param(IS_FUNCTIONAL_STATE(hcan->Init.AutoBusOff)); | |
assert_param(IS_FUNCTIONAL_STATE(hcan->Init.AutoWakeUp)); | |
assert_param(IS_FUNCTIONAL_STATE(hcan->Init.AutoRetransmission)); | |
assert_param(IS_FUNCTIONAL_STATE(hcan->Init.ReceiveFifoLocked)); | |
assert_param(IS_FUNCTIONAL_STATE(hcan->Init.TransmitFifoPriority)); | |
assert_param(IS_CAN_MODE(hcan->Init.Mode)); | |
assert_param(IS_CAN_SJW(hcan->Init.SyncJumpWidth)); | |
assert_param(IS_CAN_BS1(hcan->Init.TimeSeg1)); | |
assert_param(IS_CAN_BS2(hcan->Init.TimeSeg2)); | |
assert_param(IS_CAN_PRESCALER(hcan->Init.Prescaler)); | |
assert_param(IS_CAN_ALL_INSTANCE(hcan->Instance)); | |
assert_param(IS_CAN_FILTER_ID_HALFWORD(sFilterConfig->FilterIdHigh)); | |
assert_param(IS_CAN_FILTER_ID_HALFWORD(sFilterConfig->FilterIdLow)); | |
assert_param(IS_CAN_FILTER_ID_HALFWORD(sFilterConfig->FilterMaskIdHigh)); | |
assert_param(IS_CAN_FILTER_ID_HALFWORD(sFilterConfig->FilterMaskIdLow)); | |
assert_param(IS_CAN_FILTER_MODE(sFilterConfig->FilterMode)); | |
assert_param(IS_CAN_FILTER_SCALE(sFilterConfig->FilterScale)); | |
assert_param(IS_CAN_FILTER_FIFO(sFilterConfig->FilterFIFOAssignment)); | |
assert_param(IS_CAN_FILTER_ACTIVATION(sFilterConfig->FilterActivation)); | |
assert_param(IS_CAN_FILTER_BANK_SINGLE(sFilterConfig->FilterBank)); | |
assert_param(IS_CAN_FILTER_BANK_DUAL(sFilterConfig->FilterBank)); | |
assert_param(IS_CAN_FILTER_BANK_DUAL(sFilterConfig->SlaveStartFilterBank)); | |
assert_param(IS_CAN_FILTER_BANK_DUAL(sFilterConfig->FilterBank)); | |
assert_param(IS_CAN_FILTER_BANK_DUAL(sFilterConfig->SlaveStartFilterBank)); | |
assert_param(IS_CAN_IDTYPE(pHeader->IDE)); | |
assert_param(IS_CAN_RTR(pHeader->RTR)); | |
assert_param(IS_CAN_DLC(pHeader->DLC)); | |
assert_param(IS_CAN_STDID(pHeader->StdId)); | |
assert_param(IS_CAN_EXTID(pHeader->ExtId)); | |
assert_param(IS_FUNCTIONAL_STATE(pHeader->TransmitGlobalTime)); | |
assert_param(IS_CAN_TX_MAILBOX_LIST(TxMailboxes)); | |
assert_param(IS_CAN_TX_MAILBOX_LIST(TxMailboxes)); | |
assert_param(IS_CAN_TX_MAILBOX(TxMailbox)); | |
assert_param(IS_CAN_RX_FIFO(RxFifo)); | |
assert_param(IS_CAN_RX_FIFO(RxFifo)); | |
assert_param(IS_CAN_IT(ActiveITs)); | |
assert_param(IS_CAN_IT(InactiveITs)); | |
assert_param(IS_CEC_ALL_INSTANCE(hcec->Instance)); | |
assert_param(IS_CEC_SIGNALFREETIME(hcec->Init.SignalFreeTime)); | |
assert_param(IS_CEC_TOLERANCE(hcec->Init.Tolerance)); | |
assert_param(IS_CEC_BRERXSTOP(hcec->Init.BRERxStop)); | |
assert_param(IS_CEC_BREERRORBITGEN(hcec->Init.BREErrorBitGen)); | |
assert_param(IS_CEC_LBPEERRORBITGEN(hcec->Init.LBPEErrorBitGen)); | |
assert_param(IS_CEC_BROADCASTERROR_NO_ERRORBIT_GENERATION(hcec->Init.BroadcastMsgNoErrorBitGen)); | |
assert_param(IS_CEC_SFTOP(hcec->Init.SignalFreeTimeOption)); | |
assert_param(IS_CEC_LISTENING_MODE(hcec->Init.ListenMode)); | |
assert_param(IS_CEC_OWN_ADDRESS(hcec->Init.OwnAddress)); | |
assert_param(IS_CEC_ALL_INSTANCE(hcec->Instance)); | |
assert_param(IS_CEC_OWN_ADDRESS(CEC_OwnAddress)); | |
assert_param(IS_CEC_ADDRESS(DestinationAddress)); | |
assert_param(IS_CEC_ADDRESS(InitiatorAddress)); | |
assert_param(IS_CEC_MSGSIZE(Size)); | |
assert_param(IS_NVIC_PRIORITY_GROUP(PriorityGroup)); | |
assert_param(IS_NVIC_SUB_PRIORITY(SubPriority)); | |
assert_param(IS_NVIC_PREEMPTION_PRIORITY(PreemptPriority)); | |
assert_param(IS_NVIC_DEVICE_IRQ(IRQn)); | |
assert_param(IS_NVIC_DEVICE_IRQ(IRQn)); | |
assert_param(IS_MPU_REGION_NUMBER(MPU_Init->Number)); | |
assert_param(IS_MPU_REGION_ENABLE(MPU_Init->Enable)); | |
assert_param(IS_MPU_INSTRUCTION_ACCESS(MPU_Init->DisableExec)); | |
assert_param(IS_MPU_REGION_PERMISSION_ATTRIBUTE(MPU_Init->AccessPermission)); | |
assert_param(IS_MPU_TEX_LEVEL(MPU_Init->TypeExtField)); | |
assert_param(IS_MPU_ACCESS_SHAREABLE(MPU_Init->IsShareable)); | |
assert_param(IS_MPU_ACCESS_CACHEABLE(MPU_Init->IsCacheable)); | |
assert_param(IS_MPU_ACCESS_BUFFERABLE(MPU_Init->IsBufferable)); | |
assert_param(IS_MPU_SUB_REGION_DISABLE(MPU_Init->SubRegionDisable)); | |
assert_param(IS_MPU_REGION_SIZE(MPU_Init->Size)); | |
assert_param(IS_NVIC_PRIORITY_GROUP(PriorityGroup)); | |
assert_param(IS_NVIC_DEVICE_IRQ(IRQn)); | |
assert_param(IS_NVIC_DEVICE_IRQ(IRQn)); | |
assert_param(IS_NVIC_DEVICE_IRQ(IRQn)); | |
assert_param(IS_NVIC_DEVICE_IRQ(IRQn)); | |
assert_param(IS_SYSTICK_CLK_SOURCE(CLKSource)); | |
assert_param(IS_CRC_ALL_INSTANCE(hcrc->Instance)); | |
assert_param(IS_CRC_ALL_INSTANCE(hcrc->Instance)); | |
assert_param(IS_CRYP_KEYSIZE(hcryp->Init.KeySize)); | |
assert_param(IS_CRYP_DATATYPE(hcryp->Init.DataType)); | |
assert_param(IS_CRYP_ALGORITHM(hcryp->Init.Algorithm)); | |
assert_param(IS_CRYP_INIT(hcryp->Init.KeyIVConfigSkip)); | |
assert_param(IS_CRYP_KEYSIZE(pConf->KeySize)); | |
assert_param(IS_CRYP_DATATYPE(pConf->DataType)); | |
assert_param(IS_CRYP_ALGORITHM(pConf->Algorithm)); | |
assert_param(IS_DAC_ALL_INSTANCE(hdac->Instance)); | |
assert_param(IS_DAC_ALL_INSTANCE(hdac->Instance)); | |
assert_param(IS_DAC_CHANNEL(Channel)); | |
assert_param(IS_DAC_CHANNEL(Channel)); | |
assert_param(IS_DAC_CHANNEL(Channel)); | |
assert_param(IS_DAC_ALIGN(Alignment)); | |
assert_param(IS_DAC_CHANNEL(Channel)); | |
assert_param(IS_DAC_CHANNEL(Channel)); | |
assert_param(IS_DAC_ALIGN(Alignment)); | |
assert_param(IS_DAC_DATA(Data)); | |
assert_param(hdac != NULL); | |
assert_param(IS_DAC_CHANNEL(Channel)); | |
assert_param(IS_DAC_TRIGGER(sConfig->DAC_Trigger)); | |
assert_param(IS_DAC_OUTPUT_BUFFER_STATE(sConfig->DAC_OutputBuffer)); | |
assert_param(IS_DAC_CHANNEL(Channel)); | |
assert_param(IS_DAC_CHANNEL(Channel)); | |
assert_param(IS_DAC_LFSR_UNMASK_TRIANGLE_AMPLITUDE(Amplitude)); | |
assert_param(IS_DAC_CHANNEL(Channel)); | |
assert_param(IS_DAC_LFSR_UNMASK_TRIANGLE_AMPLITUDE(Amplitude)); | |
assert_param(IS_DAC_ALIGN(Alignment)); | |
assert_param(IS_DAC_DATA(Data1)); | |
assert_param(IS_DAC_DATA(Data2)); | |
assert_param(IS_DCMI_ALL_INSTANCE(hdcmi->Instance)); | |
assert_param(IS_DCMI_PCKPOLARITY(hdcmi->Init.PCKPolarity)); | |
assert_param(IS_DCMI_VSPOLARITY(hdcmi->Init.VSPolarity)); | |
assert_param(IS_DCMI_HSPOLARITY(hdcmi->Init.HSPolarity)); | |
assert_param(IS_DCMI_SYNCHRO(hdcmi->Init.SynchroMode)); | |
assert_param(IS_DCMI_CAPTURE_RATE(hdcmi->Init.CaptureRate)); | |
assert_param(IS_DCMI_EXTENDED_DATA(hdcmi->Init.ExtendedDataMode)); | |
assert_param(IS_DCMI_MODE_JPEG(hdcmi->Init.JPEGMode)); | |
assert_param(IS_DCMI_CAPTURE_MODE(DCMI_Mode)); | |
assert_param(IS_DCMI_WINDOW_COORDINATE(X0)); | |
assert_param(IS_DCMI_WINDOW_COORDINATE(YSize)); | |
assert_param(IS_DCMI_WINDOW_COORDINATE(XSize)); | |
assert_param(IS_DCMI_WINDOW_HEIGHT(Y0)); | |
assert_param(IS_DCMI_ALL_INSTANCE(hdcmi->Instance)); | |
assert_param(IS_DCMI_PCKPOLARITY(hdcmi->Init.PCKPolarity)); | |
assert_param(IS_DCMI_VSPOLARITY(hdcmi->Init.VSPolarity)); | |
assert_param(IS_DCMI_HSPOLARITY(hdcmi->Init.HSPolarity)); | |
assert_param(IS_DCMI_SYNCHRO(hdcmi->Init.SynchroMode)); | |
assert_param(IS_DCMI_CAPTURE_RATE(hdcmi->Init.CaptureRate)); | |
assert_param(IS_DCMI_EXTENDED_DATA(hdcmi->Init.ExtendedDataMode)); | |
assert_param(IS_DCMI_MODE_JPEG(hdcmi->Init.JPEGMode)); | |
assert_param(IS_DCMI_BYTE_SELECT_MODE(hdcmi->Init.ByteSelectMode)); | |
assert_param(IS_DCMI_BYTE_SELECT_START(hdcmi->Init.ByteSelectStart)); | |
assert_param(IS_DCMI_LINE_SELECT_MODE(hdcmi->Init.LineSelectMode)); | |
assert_param(IS_DCMI_LINE_SELECT_START(hdcmi->Init.LineSelectStart)); | |
assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance)); | |
assert_param(IS_FUNCTIONAL_STATE(hdfsdm_channel->Init.OutputClock.Activation)); | |
assert_param(IS_DFSDM_CHANNEL_INPUT(hdfsdm_channel->Init.Input.Multiplexer)); | |
assert_param(IS_DFSDM_CHANNEL_DATA_PACKING(hdfsdm_channel->Init.Input.DataPacking)); | |
assert_param(IS_DFSDM_CHANNEL_INPUT_PINS(hdfsdm_channel->Init.Input.Pins)); | |
assert_param(IS_DFSDM_CHANNEL_SERIAL_INTERFACE_TYPE(hdfsdm_channel->Init.SerialInterface.Type)); | |
assert_param(IS_DFSDM_CHANNEL_SPI_CLOCK(hdfsdm_channel->Init.SerialInterface.SpiClock)); | |
assert_param(IS_DFSDM_CHANNEL_FILTER_ORDER(hdfsdm_channel->Init.Awd.FilterOrder)); | |
assert_param(IS_DFSDM_CHANNEL_FILTER_OVS_RATIO(hdfsdm_channel->Init.Awd.Oversampling)); | |
assert_param(IS_DFSDM_CHANNEL_OFFSET(hdfsdm_channel->Init.Offset)); | |
assert_param(IS_DFSDM_CHANNEL_RIGHT_BIT_SHIFT(hdfsdm_channel->Init.RightBitShift)); | |
assert_param(IS_DFSDM_CHANNEL_OUTPUT_CLOCK(hdfsdm_channel->Init.OutputClock.Selection)); | |
assert_param(IS_DFSDM_CHANNEL_OUTPUT_CLOCK_DIVIDER(hdfsdm_channel->Init.OutputClock.Divider)); | |
assert_param(IS_DFSDM_CHANNEL_OUTPUT_CLOCK(hdfsdm_channel->Init.OutputClock.Selection)); | |
assert_param(IS_DFSDM_CHANNEL_OUTPUT_CLOCK_DIVIDER(hdfsdm_channel->Init.OutputClock.Divider)); | |
assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance)); | |
assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance)); | |
assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance)); | |
assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance)); | |
assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance)); | |
assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance)); | |
assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance)); | |
assert_param(IS_DFSDM_CHANNEL_SCD_THRESHOLD(Threshold)); | |
assert_param(IS_DFSDM_BREAK_SIGNALS(BreakSignal)); | |
assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance)); | |
assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance)); | |
assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance)); | |
assert_param(IS_DFSDM_CHANNEL_SCD_THRESHOLD(Threshold)); | |
assert_param(IS_DFSDM_BREAK_SIGNALS(BreakSignal)); | |
assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance)); | |
assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance)); | |
assert_param(IS_DFSDM_CHANNEL_OFFSET(Offset)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_REG_TRIGGER(hdfsdm_filter->Init.RegularParam.Trigger)); | |
assert_param(IS_FUNCTIONAL_STATE(hdfsdm_filter->Init.RegularParam.FastMode)); | |
assert_param(IS_FUNCTIONAL_STATE(hdfsdm_filter->Init.RegularParam.DmaMode)); | |
assert_param(IS_DFSDM_FILTER_INJ_TRIGGER(hdfsdm_filter->Init.InjectedParam.Trigger)); | |
assert_param(IS_FUNCTIONAL_STATE(hdfsdm_filter->Init.InjectedParam.ScanMode)); | |
assert_param(IS_FUNCTIONAL_STATE(hdfsdm_filter->Init.InjectedParam.DmaMode)); | |
assert_param(IS_DFSDM_FILTER_SINC_ORDER(hdfsdm_filter->Init.FilterParam.SincOrder)); | |
assert_param(IS_DFSDM_FILTER_OVS_RATIO(hdfsdm_filter->Init.FilterParam.Oversampling)); | |
assert_param(IS_DFSDM_FILTER_INTEGRATOR_OVS_RATIO(hdfsdm_filter->Init.FilterParam.IntOversampling)); | |
assert_param(IS_DFSDM_FILTER_EXT_TRIG(hdfsdm_filter->Init.InjectedParam.ExtTrigger)); | |
assert_param(IS_DFSDM_FILTER_EXT_TRIG_EDGE(hdfsdm_filter->Init.InjectedParam.ExtTriggerEdge)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_REGULAR_CHANNEL(Channel)); | |
assert_param(IS_DFSDM_CONTINUOUS_MODE(ContinuousMode)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_INJECTED_CHANNEL(Channel)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(Channel != NULL); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(Channel != NULL); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_AWD_DATA_SOURCE(awdParam->DataSource)); | |
assert_param(IS_DFSDM_INJECTED_CHANNEL(awdParam->Channel)); | |
assert_param(IS_DFSDM_FILTER_AWD_THRESHOLD(awdParam->HighThreshold)); | |
assert_param(IS_DFSDM_FILTER_AWD_THRESHOLD(awdParam->LowThreshold)); | |
assert_param(IS_DFSDM_BREAK_SIGNALS(awdParam->HighBreakSignal)); | |
assert_param(IS_DFSDM_BREAK_SIGNALS(awdParam->LowBreakSignal)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_INJECTED_CHANNEL(Channel)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(Channel != NULL); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(Channel != NULL); | |
assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance)); | |
assert_param(IS_DFSDM_DELAY_CLOCK(MCHDLY)); | |
assert_param(IS_DFSDM_DELAY_CLOCK(MCHDLY)); | |
assert_param(IS_DFSDM_CLOCKIN_SELECTION(source)); | |
assert_param(IS_DFSDM_CLOCKOUT_SELECTION(source)); | |
assert_param(IS_DFSDM_DATAIN0_SRC_SELECTION(source)); | |
assert_param(IS_DFSDM_DATAIN2_SRC_SELECTION(source)); | |
assert_param(IS_DFSDM_DATAIN4_SRC_SELECTION(source)); | |
assert_param(IS_DFSDM_DATAIN6_SRC_SELECTION(source)); | |
assert_param(IS_DFSDM_BITSTREM_CLK_DISTRIBUTION(source)); | |
assert_param(IS_DFSDM_DFSDM1_CLKOUT(mchdlystruct->DFSDM1ClockOut)); | |
assert_param(IS_DFSDM_DFSDM2_CLKOUT(mchdlystruct->DFSDM2ClockOut)); | |
assert_param(IS_DFSDM_DFSDM1_CLKIN(mchdlystruct->DFSDM1ClockIn)); | |
assert_param(IS_DFSDM_DFSDM2_CLKIN(mchdlystruct->DFSDM2ClockIn)); | |
assert_param(IS_DFSDM_DFSDM1_BIT_CLK((mchdlystruct->DFSDM1BitClkDistribution))); | |
assert_param(IS_DFSDM_DFSDM2_BIT_CLK(mchdlystruct->DFSDM2BitClkDistribution)); | |
assert_param(IS_DFSDM_DFSDM1_DATA_DISTRIBUTION(mchdlystruct->DFSDM1DataDistribution)); | |
assert_param(IS_DFSDM_DFSDM2_DATA_DISTRIBUTION(mchdlystruct->DFSDM2DataDistribution)); | |
assert_param(IS_DMA_STREAM_ALL_INSTANCE(hdma->Instance)); | |
assert_param(IS_DMA_CHANNEL(hdma->Init.Channel)); | |
assert_param(IS_DMA_DIRECTION(hdma->Init.Direction)); | |
assert_param(IS_DMA_PERIPHERAL_INC_STATE(hdma->Init.PeriphInc)); | |
assert_param(IS_DMA_MEMORY_INC_STATE(hdma->Init.MemInc)); | |
assert_param(IS_DMA_PERIPHERAL_DATA_SIZE(hdma->Init.PeriphDataAlignment)); | |
assert_param(IS_DMA_MEMORY_DATA_SIZE(hdma->Init.MemDataAlignment)); | |
assert_param(IS_DMA_MODE(hdma->Init.Mode)); | |
assert_param(IS_DMA_PRIORITY(hdma->Init.Priority)); | |
assert_param(IS_DMA_FIFO_MODE_STATE(hdma->Init.FIFOMode)); | |
assert_param(IS_DMA_FIFO_THRESHOLD(hdma->Init.FIFOThreshold)); | |
assert_param(IS_DMA_MEMORY_BURST(hdma->Init.MemBurst)); | |
assert_param(IS_DMA_PERIPHERAL_BURST(hdma->Init.PeriphBurst)); | |
assert_param(IS_DMA_STREAM_ALL_INSTANCE(hdma->Instance)); | |
assert_param(IS_DMA_BUFFER_SIZE(DataLength)); | |
assert_param(IS_DMA_BUFFER_SIZE(DataLength)); | |
assert_param(IS_DMA2D_ALL_INSTANCE(hdma2d->Instance)); | |
assert_param(IS_DMA2D_MODE(hdma2d->Init.Mode)); | |
assert_param(IS_DMA2D_CMODE(hdma2d->Init.ColorMode)); | |
assert_param(IS_DMA2D_OFFSET(hdma2d->Init.OutputOffset)); | |
assert_param(IS_DMA2D_LINE(Height)); | |
assert_param(IS_DMA2D_PIXEL(Width)); | |
assert_param(IS_DMA2D_LINE(Height)); | |
assert_param(IS_DMA2D_PIXEL(Width)); | |
assert_param(IS_DMA2D_LINE(Height)); | |
assert_param(IS_DMA2D_PIXEL(Width)); | |
assert_param(IS_DMA2D_LINE(Height)); | |
assert_param(IS_DMA2D_PIXEL(Width)); | |
assert_param(IS_DMA2D_LAYER(LayerIdx)); | |
assert_param(IS_DMA2D_LAYER(LayerIdx)); | |
assert_param(IS_DMA2D_CLUT_CM(CLUTCfg->CLUTColorMode)); | |
assert_param(IS_DMA2D_CLUT_SIZE(CLUTCfg->Size)); | |
assert_param(IS_DMA2D_LAYER(LayerIdx)); | |
assert_param(IS_DMA2D_CLUT_CM(CLUTCfg->CLUTColorMode)); | |
assert_param(IS_DMA2D_CLUT_SIZE(CLUTCfg->Size)); | |
assert_param(IS_DMA2D_LAYER(LayerIdx)); | |
assert_param(IS_DMA2D_CLUT_CM(CLUTCfg.CLUTColorMode)); | |
assert_param(IS_DMA2D_CLUT_SIZE(CLUTCfg.Size)); | |
assert_param(IS_DMA2D_LAYER(LayerIdx)); | |
assert_param(IS_DMA2D_CLUT_CM(CLUTCfg.CLUTColorMode)); | |
assert_param(IS_DMA2D_CLUT_SIZE(CLUTCfg.Size)); | |
assert_param(IS_DMA2D_LAYER(LayerIdx)); | |
assert_param(IS_DMA2D_OFFSET(hdma2d->LayerCfg[LayerIdx].InputOffset)); | |
assert_param(IS_DMA2D_INPUT_COLOR_MODE(hdma2d->LayerCfg[LayerIdx].InputColorMode)); | |
assert_param(IS_DMA2D_ALPHA_MODE(hdma2d->LayerCfg[LayerIdx].AlphaMode)); | |
assert_param(IS_DMA2D_LAYER(LayerIdx)); | |
assert_param(IS_DMA2D_CLUT_CM(CLUTCfg.CLUTColorMode)); | |
assert_param(IS_DMA2D_CLUT_SIZE(CLUTCfg.Size)); | |
assert_param(IS_DMA_BUFFER_SIZE(DataLength)); | |
assert_param(IS_DMA_BUFFER_SIZE(DataLength)); | |
assert_param(IS_DSI_PLL_NDIV(PLLInit->PLLNDIV)); | |
assert_param(IS_DSI_PLL_IDF(PLLInit->PLLIDF)); | |
assert_param(IS_DSI_PLL_ODF(PLLInit->PLLODF)); | |
assert_param(IS_DSI_AUTO_CLKLANE_CONTROL(hdsi->Init.AutomaticClockLaneControl)); | |
assert_param(IS_DSI_NUMBER_OF_LANES(hdsi->Init.NumberOfLanes)); | |
assert_param(IS_DSI_COLOR_CODING(VidCfg->ColorCoding)); | |
assert_param(IS_DSI_VIDEO_MODE_TYPE(VidCfg->Mode)); | |
assert_param(IS_DSI_LP_COMMAND(VidCfg->LPCommandEnable)); | |
assert_param(IS_DSI_LP_HFP(VidCfg->LPHorizontalFrontPorchEnable)); | |
assert_param(IS_DSI_LP_HBP(VidCfg->LPHorizontalBackPorchEnable)); | |
assert_param(IS_DSI_LP_VACTIVE(VidCfg->LPVerticalActiveEnable)); | |
assert_param(IS_DSI_LP_VFP(VidCfg->LPVerticalFrontPorchEnable)); | |
assert_param(IS_DSI_LP_VBP(VidCfg->LPVerticalBackPorchEnable)); | |
assert_param(IS_DSI_LP_VSYNC(VidCfg->LPVerticalSyncActiveEnable)); | |
assert_param(IS_DSI_FBTAA(VidCfg->FrameBTAAcknowledgeEnable)); | |
assert_param(IS_DSI_DE_POLARITY(VidCfg->DEPolarity)); | |
assert_param(IS_DSI_VSYNC_POLARITY(VidCfg->VSPolarity)); | |
assert_param(IS_DSI_HSYNC_POLARITY(VidCfg->HSPolarity)); | |
assert_param(IS_DSI_LOOSELY_PACKED(VidCfg->LooselyPacked)); | |
assert_param(IS_DSI_COLOR_CODING(CmdCfg->ColorCoding)); | |
assert_param(IS_DSI_TE_SOURCE(CmdCfg->TearingEffectSource)); | |
assert_param(IS_DSI_TE_POLARITY(CmdCfg->TearingEffectPolarity)); | |
assert_param(IS_DSI_AUTOMATIC_REFRESH(CmdCfg->AutomaticRefresh)); | |
assert_param(IS_DSI_VS_POLARITY(CmdCfg->VSyncPol)); | |
assert_param(IS_DSI_TE_ACK_REQUEST(CmdCfg->TEAcknowledgeRequest)); | |
assert_param(IS_DSI_DE_POLARITY(CmdCfg->DEPolarity)); | |
assert_param(IS_DSI_VSYNC_POLARITY(CmdCfg->VSPolarity)); | |
assert_param(IS_DSI_HSYNC_POLARITY(CmdCfg->HSPolarity)); | |
assert_param(IS_DSI_LP_GSW0P(LPCmd->LPGenShortWriteNoP)); | |
assert_param(IS_DSI_LP_GSW1P(LPCmd->LPGenShortWriteOneP)); | |
assert_param(IS_DSI_LP_GSW2P(LPCmd->LPGenShortWriteTwoP)); | |
assert_param(IS_DSI_LP_GSR0P(LPCmd->LPGenShortReadNoP)); | |
assert_param(IS_DSI_LP_GSR1P(LPCmd->LPGenShortReadOneP)); | |
assert_param(IS_DSI_LP_GSR2P(LPCmd->LPGenShortReadTwoP)); | |
assert_param(IS_DSI_LP_GLW(LPCmd->LPGenLongWrite)); | |
assert_param(IS_DSI_LP_DSW0P(LPCmd->LPDcsShortWriteNoP)); | |
assert_param(IS_DSI_LP_DSW1P(LPCmd->LPDcsShortWriteOneP)); | |
assert_param(IS_DSI_LP_DSR0P(LPCmd->LPDcsShortReadNoP)); | |
assert_param(IS_DSI_LP_DLW(LPCmd->LPDcsLongWrite)); | |
assert_param(IS_DSI_LP_MRDP(LPCmd->LPMaxReadPacket)); | |
assert_param(IS_DSI_ACK_REQUEST(LPCmd->AcknowledgeRequest)); | |
assert_param(IS_DSI_FLOW_CONTROL(FlowControl)); | |
assert_param(IS_DSI_COLOR_MODE(ColorMode)); | |
assert_param(IS_DSI_SHUT_DOWN(Shutdown)); | |
assert_param(IS_DSI_SHORT_WRITE_PACKET_TYPE(Mode)); | |
assert_param(IS_DSI_LONG_WRITE_PACKET_TYPE(Mode)); | |
assert_param(IS_DSI_READ_PACKET_TYPE(Mode)); | |
assert_param(IS_DSI_COMMUNICATION_DELAY(CommDelay)); | |
assert_param(IS_DSI_LANE_GROUP(Lane)); | |
assert_param(IS_FUNCTIONAL_STATE(State)); | |
assert_param(IS_DSI_CUSTOM_LANE(CustomLane)); | |
assert_param(IS_DSI_LANE(Lane)); | |
assert_param(IS_FUNCTIONAL_STATE(State)); | |
assert_param(IS_DSI_PHY_TIMING(Timing)); | |
assert_param(IS_FUNCTIONAL_STATE(State)); | |
assert_param(IS_DSI_LANE_GROUP(Lane)); | |
assert_param(IS_FUNCTIONAL_STATE(State)); | |
assert_param(IS_FUNCTIONAL_STATE(State)); | |
assert_param(IS_FUNCTIONAL_STATE(State)); | |
assert_param(IS_FUNCTIONAL_STATE(State)); | |
assert_param(IS_FUNCTIONAL_STATE(State)); | |
assert_param(IS_ETH_AUTONEGOTIATION(heth->Init.AutoNegotiation)); | |
assert_param(IS_ETH_RX_MODE(heth->Init.RxMode)); | |
assert_param(IS_ETH_CHECKSUM_MODE(heth->Init.ChecksumMode)); | |
assert_param(IS_ETH_MEDIA_INTERFACE(heth->Init.MediaInterface)); | |
assert_param(IS_ETH_SPEED(heth->Init.Speed)); | |
assert_param(IS_ETH_DUPLEX_MODE(heth->Init.DuplexMode)); | |
assert_param(IS_ETH_PHY_ADDRESS(heth->Init.PhyAddress)); | |
assert_param(IS_ETH_PHY_ADDRESS(heth->Init.PhyAddress)); | |
assert_param(IS_ETH_SPEED(heth->Init.Speed)); | |
assert_param(IS_ETH_DUPLEX_MODE(heth->Init.DuplexMode)); | |
assert_param(IS_ETH_WATCHDOG(macconf->Watchdog)); | |
assert_param(IS_ETH_JABBER(macconf->Jabber)); | |
assert_param(IS_ETH_INTER_FRAME_GAP(macconf->InterFrameGap)); | |
assert_param(IS_ETH_CARRIER_SENSE(macconf->CarrierSense)); | |
assert_param(IS_ETH_RECEIVE_OWN(macconf->ReceiveOwn)); | |
assert_param(IS_ETH_LOOPBACK_MODE(macconf->LoopbackMode)); | |
assert_param(IS_ETH_CHECKSUM_OFFLOAD(macconf->ChecksumOffload)); | |
assert_param(IS_ETH_RETRY_TRANSMISSION(macconf->RetryTransmission)); | |
assert_param(IS_ETH_AUTOMATIC_PADCRC_STRIP(macconf->AutomaticPadCRCStrip)); | |
assert_param(IS_ETH_BACKOFF_LIMIT(macconf->BackOffLimit)); | |
assert_param(IS_ETH_DEFERRAL_CHECK(macconf->DeferralCheck)); | |
assert_param(IS_ETH_RECEIVE_ALL(macconf->ReceiveAll)); | |
assert_param(IS_ETH_SOURCE_ADDR_FILTER(macconf->SourceAddrFilter)); | |
assert_param(IS_ETH_CONTROL_FRAMES(macconf->PassControlFrames)); | |
assert_param(IS_ETH_BROADCAST_FRAMES_RECEPTION(macconf->BroadcastFramesReception)); | |
assert_param(IS_ETH_DESTINATION_ADDR_FILTER(macconf->DestinationAddrFilter)); | |
assert_param(IS_ETH_PROMISCUOUS_MODE(macconf->PromiscuousMode)); | |
assert_param(IS_ETH_MULTICAST_FRAMES_FILTER(macconf->MulticastFramesFilter)); | |
assert_param(IS_ETH_UNICAST_FRAMES_FILTER(macconf->UnicastFramesFilter)); | |
assert_param(IS_ETH_PAUSE_TIME(macconf->PauseTime)); | |
assert_param(IS_ETH_ZEROQUANTA_PAUSE(macconf->ZeroQuantaPause)); | |
assert_param(IS_ETH_PAUSE_LOW_THRESHOLD(macconf->PauseLowThreshold)); | |
assert_param(IS_ETH_UNICAST_PAUSE_FRAME_DETECT(macconf->UnicastPauseFrameDetect)); | |
assert_param(IS_ETH_RECEIVE_FLOWCONTROL(macconf->ReceiveFlowControl)); | |
assert_param(IS_ETH_TRANSMIT_FLOWCONTROL(macconf->TransmitFlowControl)); | |
assert_param(IS_ETH_VLAN_TAG_COMPARISON(macconf->VLANTagComparison)); | |
assert_param(IS_ETH_VLAN_TAG_IDENTIFIER(macconf->VLANTagIdentifier)); | |
assert_param(IS_ETH_DROP_TCPIP_CHECKSUM_FRAME(dmaconf->DropTCPIPChecksumErrorFrame)); | |
assert_param(IS_ETH_RECEIVE_STORE_FORWARD(dmaconf->ReceiveStoreForward)); | |
assert_param(IS_ETH_FLUSH_RECEIVE_FRAME(dmaconf->FlushReceivedFrame)); | |
assert_param(IS_ETH_TRANSMIT_STORE_FORWARD(dmaconf->TransmitStoreForward)); | |
assert_param(IS_ETH_TRANSMIT_THRESHOLD_CONTROL(dmaconf->TransmitThresholdControl)); | |
assert_param(IS_ETH_FORWARD_ERROR_FRAMES(dmaconf->ForwardErrorFrames)); | |
assert_param(IS_ETH_FORWARD_UNDERSIZED_GOOD_FRAMES(dmaconf->ForwardUndersizedGoodFrames)); | |
assert_param(IS_ETH_RECEIVE_THRESHOLD_CONTROL(dmaconf->ReceiveThresholdControl)); | |
assert_param(IS_ETH_SECOND_FRAME_OPERATE(dmaconf->SecondFrameOperate)); | |
assert_param(IS_ETH_ADDRESS_ALIGNED_BEATS(dmaconf->AddressAlignedBeats)); | |
assert_param(IS_ETH_FIXED_BURST(dmaconf->FixedBurst)); | |
assert_param(IS_ETH_RXDMA_BURST_LENGTH(dmaconf->RxDMABurstLength)); | |
assert_param(IS_ETH_TXDMA_BURST_LENGTH(dmaconf->TxDMABurstLength)); | |
assert_param(IS_ETH_ENHANCED_DESCRIPTOR_FORMAT(dmaconf->EnhancedDescriptorFormat)); | |
assert_param(IS_ETH_DMA_DESC_SKIP_LENGTH(dmaconf->DescriptorSkipLength)); | |
assert_param(IS_ETH_DMA_ARBITRATION_ROUNDROBIN_RXTX(dmaconf->DMAArbitration)); | |
assert_param(IS_ETH_MAC_ADDRESS0123(MacAddr)); | |
assert_param(IS_EXTI_LINE(pExtiConfig->Line)); | |
assert_param(IS_EXTI_MODE(pExtiConfig->Mode)); | |
assert_param(IS_EXTI_TRIGGER(pExtiConfig->Trigger)); | |
assert_param(IS_EXTI_GPIO_PORT(pExtiConfig->GPIOSel)); | |
assert_param(IS_EXTI_GPIO_PIN(linepos)); | |
assert_param(IS_EXTI_LINE(hexti->Line)); | |
assert_param(IS_EXTI_GPIO_PIN(linepos)); | |
assert_param(IS_EXTI_LINE(hexti->Line)); | |
assert_param(IS_EXTI_GPIO_PIN(linepos)); | |
assert_param(IS_EXTI_LINE(ExtiLine)); | |
assert_param(IS_EXTI_LINE(hexti->Line)); | |
assert_param(IS_EXTI_CONFIG_LINE(hexti->Line)); | |
assert_param(IS_EXTI_PENDING_EDGE(Edge)); | |
assert_param(IS_EXTI_LINE(hexti->Line)); | |
assert_param(IS_EXTI_CONFIG_LINE(hexti->Line)); | |
assert_param(IS_EXTI_PENDING_EDGE(Edge)); | |
assert_param(IS_EXTI_LINE(hexti->Line)); | |
assert_param(IS_EXTI_CONFIG_LINE(hexti->Line)); | |
assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram)); | |
assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram)); | |
assert_param(IS_FLASH_ADDRESS(Address)); | |
assert_param(IS_FLASH_ADDRESS(Address)); | |
assert_param(IS_FLASH_ADDRESS(Address)); | |
assert_param(IS_FLASH_ADDRESS(Address)); | |
assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase)); | |
assert_param(IS_FLASH_NBSECTORS(pEraseInit->NbSectors + pEraseInit->Sector)); | |
assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase)); | |
assert_param(IS_FLASH_NBSECTORS(pEraseInit->NbSectors + pEraseInit->Sector)); | |
assert_param(IS_OPTIONBYTE(pOBInit->OptionType)); | |
assert_param(IS_WRPSTATE(pOBInit->WRPState)); | |
assert_param(IS_OBEX(pAdvOBInit->OptionType)); | |
assert_param(IS_PCROPSTATE(pAdvOBInit->PCROPState)); | |
assert_param(IS_VOLTAGERANGE(VoltageRange)); | |
assert_param(IS_FLASH_BANK(Banks)); | |
assert_param(IS_FLASH_SECTOR(Sector)); | |
assert_param(IS_VOLTAGERANGE(VoltageRange)); | |
assert_param(IS_OB_WRP_SECTOR(WRPSector)); | |
assert_param(IS_FLASH_BANK(Banks)); | |
assert_param(IS_OB_WRP_SECTOR(WRPSector)); | |
assert_param(IS_FLASH_BANK(Banks)); | |
assert_param(IS_OB_BOOT(BootConfig)); | |
assert_param(IS_FLASH_BANK(Banks)); | |
assert_param(IS_OB_PCROP(SectorBank1)); | |
assert_param(IS_OB_PCROP(SectorBank2)); | |
assert_param(IS_OB_PCROP(SectorBank2)); | |
assert_param(IS_FLASH_BANK(Banks)); | |
assert_param(IS_OB_PCROP(SectorBank1)); | |
assert_param(IS_OB_PCROP(SectorBank2)); | |
assert_param(IS_OB_PCROP(SectorBank2)); | |
assert_param(IS_VOLTAGERANGE(VoltageRange)); | |
assert_param(IS_FLASH_BANK(Banks)); | |
assert_param(IS_FLASH_SECTOR(Sector)); | |
assert_param(IS_VOLTAGERANGE(VoltageRange)); | |
assert_param(IS_OB_WRP_SECTOR(WRPSector)); | |
assert_param(IS_FLASH_BANK(Banks)); | |
assert_param(IS_OB_WRP_SECTOR(WRPSector)); | |
assert_param(IS_FLASH_BANK(Banks)); | |
assert_param(IS_OB_PCROP(Sector)); | |
assert_param(IS_OB_PCROP(Sector)); | |
assert_param(IS_OB_RDP_LEVEL(Level)); | |
assert_param(IS_OB_IWDG_SOURCE(Iwdg)); | |
assert_param(IS_OB_STOP_SOURCE(Stop)); | |
assert_param(IS_OB_STDBY_SOURCE(Stdby)); | |
assert_param(IS_OB_BOR_LEVEL(Level)); | |
assert_param(IS_FMPI2C_ALL_INSTANCE(hfmpi2c->Instance)); | |
assert_param(IS_FMPI2C_OWN_ADDRESS1(hfmpi2c->Init.OwnAddress1)); | |
assert_param(IS_FMPI2C_ADDRESSING_MODE(hfmpi2c->Init.AddressingMode)); | |
assert_param(IS_FMPI2C_DUAL_ADDRESS(hfmpi2c->Init.DualAddressMode)); | |
assert_param(IS_FMPI2C_OWN_ADDRESS2(hfmpi2c->Init.OwnAddress2)); | |
assert_param(IS_FMPI2C_OWN_ADDRESS2_MASK(hfmpi2c->Init.OwnAddress2Masks)); | |
assert_param(IS_FMPI2C_GENERAL_CALL(hfmpi2c->Init.GeneralCallMode)); | |
assert_param(IS_FMPI2C_NO_STRETCH(hfmpi2c->Init.NoStretchMode)); | |
assert_param(IS_FMPI2C_ALL_INSTANCE(hfmpi2c->Instance)); | |
assert_param(IS_FMPI2C_MEMADD_SIZE(MemAddSize)); | |
assert_param(IS_FMPI2C_MEMADD_SIZE(MemAddSize)); | |
assert_param(IS_FMPI2C_MEMADD_SIZE(MemAddSize)); | |
assert_param(IS_FMPI2C_MEMADD_SIZE(MemAddSize)); | |
assert_param(IS_FMPI2C_MEMADD_SIZE(MemAddSize)); | |
assert_param(IS_FMPI2C_MEMADD_SIZE(MemAddSize)); | |
assert_param(IS_FMPI2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_FMPI2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_FMPI2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_FMPI2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_FMPI2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_FMPI2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_FMPI2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_FMPI2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_FMPI2C_ALL_INSTANCE(hfmpi2c->Instance)); | |
assert_param(IS_TRANSFER_MODE(Mode)); | |
assert_param(IS_TRANSFER_REQUEST(Request)); | |
assert_param(IS_FMPI2C_ALL_INSTANCE(hfmpi2c->Instance)); | |
assert_param(IS_FMPI2C_ANALOG_FILTER(AnalogFilter)); | |
assert_param(IS_FMPI2C_ALL_INSTANCE(hfmpi2c->Instance)); | |
assert_param(IS_FMPI2C_DIGITAL_FILTER(DigitalFilter)); | |
assert_param(IS_FMPI2C_FASTMODEPLUS(ConfigFastModePlus)); | |
assert_param(IS_FMPI2C_FASTMODEPLUS(ConfigFastModePlus)); | |
assert_param(IS_GPIO_ALL_INSTANCE(GPIOx)); | |
assert_param(IS_GPIO_PIN(GPIO_Init->Pin)); | |
assert_param(IS_GPIO_MODE(GPIO_Init->Mode)); | |
assert_param(IS_GPIO_SPEED(GPIO_Init->Speed)); | |
assert_param(IS_GPIO_PULL(GPIO_Init->Pull)); | |
assert_param(IS_GPIO_AF(GPIO_Init->Alternate)); | |
assert_param(IS_GPIO_ALL_INSTANCE(GPIOx)); | |
assert_param(IS_GPIO_PIN(GPIO_Pin)); | |
assert_param(IS_GPIO_PIN(GPIO_Pin)); | |
assert_param(IS_GPIO_PIN_ACTION(PinState)); | |
assert_param(IS_GPIO_PIN(GPIO_Pin)); | |
assert_param(IS_GPIO_PIN(GPIO_Pin)); | |
assert_param(IS_HASH_DATATYPE(hhash->Init.DataType)); | |
assert_param(IS_HASH_DMA_MULTIBUFFER_SIZE(Size)); | |
assert_param(IS_HMAC_DMA_MULTIBUFFER_SIZE(hhash, Size)); | |
assert_param(IS_HCD_ALL_INSTANCE(hhcd->Instance)); | |
assert_param(IS_I2C_ALL_INSTANCE(hi2c->Instance)); | |
assert_param(IS_I2C_CLOCK_SPEED(hi2c->Init.ClockSpeed)); | |
assert_param(IS_I2C_DUTY_CYCLE(hi2c->Init.DutyCycle)); | |
assert_param(IS_I2C_OWN_ADDRESS1(hi2c->Init.OwnAddress1)); | |
assert_param(IS_I2C_ADDRESSING_MODE(hi2c->Init.AddressingMode)); | |
assert_param(IS_I2C_DUAL_ADDRESS(hi2c->Init.DualAddressMode)); | |
assert_param(IS_I2C_OWN_ADDRESS2(hi2c->Init.OwnAddress2)); | |
assert_param(IS_I2C_GENERAL_CALL(hi2c->Init.GeneralCallMode)); | |
assert_param(IS_I2C_NO_STRETCH(hi2c->Init.NoStretchMode)); | |
assert_param(IS_I2C_ALL_INSTANCE(hi2c->Instance)); | |
assert_param(IS_I2C_MEMADD_SIZE(MemAddSize)); | |
assert_param(IS_I2C_MEMADD_SIZE(MemAddSize)); | |
assert_param(IS_I2C_MEMADD_SIZE(MemAddSize)); | |
assert_param(IS_I2C_MEMADD_SIZE(MemAddSize)); | |
assert_param(IS_I2C_MEMADD_SIZE(MemAddSize)); | |
assert_param(IS_I2C_MEMADD_SIZE(MemAddSize)); | |
assert_param(IS_I2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_I2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_I2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_I2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_I2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_I2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_I2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_I2C_TRANSFER_OPTIONS_REQUEST(XferOptions)); | |
assert_param(IS_I2C_ALL_INSTANCE(hi2c->Instance)); | |
assert_param(IS_I2C_ANALOG_FILTER(AnalogFilter)); | |
assert_param(IS_I2C_ALL_INSTANCE(hi2c->Instance)); | |
assert_param(IS_I2C_DIGITAL_FILTER(DigitalFilter)); | |
assert_param(IS_I2S_ALL_INSTANCE(hi2s->Instance)); | |
assert_param(IS_I2S_MODE(hi2s->Init.Mode)); | |
assert_param(IS_I2S_STANDARD(hi2s->Init.Standard)); | |
assert_param(IS_I2S_DATA_FORMAT(hi2s->Init.DataFormat)); | |
assert_param(IS_I2S_MCLK_OUTPUT(hi2s->Init.MCLKOutput)); | |
assert_param(IS_I2S_AUDIO_FREQ(hi2s->Init.AudioFreq)); | |
assert_param(IS_I2S_CPOL(hi2s->Init.CPOL)); | |
assert_param(IS_I2S_CLOCKSOURCE(hi2s->Init.ClockSource)); | |
assert_param(IS_I2S_FULLDUPLEX_MODE(hi2s->Init.FullDuplexMode)); | |
assert_param(IS_I2S_ALL_INSTANCE(hi2s->Instance)); | |
assert_param(IS_IRDA_INSTANCE(hirda->Instance)); | |
assert_param(IS_IRDA_POWERMODE(hirda->Init.IrDAMode)); | |
assert_param(IS_IRDA_INSTANCE(hirda->Instance)); | |
assert_param(IS_IRDA_INSTANCE(hirda->Instance)); | |
assert_param(IS_IRDA_BAUDRATE(hirda->Init.BaudRate)); | |
assert_param(IS_IRDA_WORD_LENGTH(hirda->Init.WordLength)); | |
assert_param(IS_IRDA_PARITY(hirda->Init.Parity)); | |
assert_param(IS_IRDA_MODE(hirda->Init.Mode)); | |
assert_param(IS_IRDA_POWERMODE(hirda->Init.IrDAMode)); | |
assert_param(IS_IWDG_ALL_INSTANCE(hiwdg->Instance)); | |
assert_param(IS_IWDG_PRESCALER(hiwdg->Init.Prescaler)); | |
assert_param(IS_IWDG_RELOAD(hiwdg->Init.Reload)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_CLOCK_SOURCE(hlptim->Init.Clock.Source)); | |
assert_param(IS_LPTIM_CLOCK_PRESCALER(hlptim->Init.Clock.Prescaler)); | |
assert_param(IS_LPTIM_CLOCK_POLARITY(hlptim->Init.UltraLowPowerClock.Polarity)); | |
assert_param(IS_LPTIM_CLOCK_SAMPLE_TIME(hlptim->Init.UltraLowPowerClock.SampleTime)); | |
assert_param(IS_LPTIM_TRG_SOURCE(hlptim->Init.Trigger.Source)); | |
assert_param(IS_LPTIM_EXT_TRG_POLARITY(hlptim->Init.Trigger.ActiveEdge)); | |
assert_param(IS_LPTIM_TRIG_SAMPLE_TIME(hlptim->Init.Trigger.SampleTime)); | |
assert_param(IS_LPTIM_OUTPUT_POLARITY(hlptim->Init.OutputPolarity)); | |
assert_param(IS_LPTIM_UPDATE_MODE(hlptim->Init.UpdateMode)); | |
assert_param(IS_LPTIM_COUNTER_SOURCE(hlptim->Init.CounterSource)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_PERIOD(Period)); | |
assert_param(IS_LPTIM_PULSE(Pulse)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_PERIOD(Period)); | |
assert_param(IS_LPTIM_PULSE(Pulse)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_PERIOD(Period)); | |
assert_param(IS_LPTIM_PULSE(Pulse)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_PERIOD(Period)); | |
assert_param(IS_LPTIM_PULSE(Pulse)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_PERIOD(Period)); | |
assert_param(IS_LPTIM_PULSE(Pulse)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_PERIOD(Period)); | |
assert_param(IS_LPTIM_PULSE(Pulse)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_PERIOD(Period)); | |
assert_param(hlptim->Init.Clock.Source == LPTIM_CLOCKSOURCE_APBCLOCK_LPOSC); | |
assert_param(hlptim->Init.Clock.Prescaler == LPTIM_PRESCALER_DIV1); | |
assert_param(IS_LPTIM_CLOCK_POLARITY(hlptim->Init.UltraLowPowerClock.Polarity)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_PERIOD(Period)); | |
assert_param(hlptim->Init.Clock.Source == LPTIM_CLOCKSOURCE_APBCLOCK_LPOSC); | |
assert_param(hlptim->Init.Clock.Prescaler == LPTIM_PRESCALER_DIV1); | |
assert_param(IS_LPTIM_CLOCK_POLARITY(hlptim->Init.UltraLowPowerClock.Polarity)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_PERIOD(Period)); | |
assert_param(IS_LPTIM_PULSE(Timeout)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_PERIOD(Period)); | |
assert_param(IS_LPTIM_PULSE(Timeout)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_PERIOD(Period)); | |
assert_param(IS_LPTIM_CLOCK_PRESCALERDIV1(hlptim->Init.Clock.Prescaler)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_PERIOD(Period)); | |
assert_param(IS_LPTIM_CLOCK_PRESCALERDIV1(hlptim->Init.Clock.Prescaler)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LPTIM_INSTANCE(hlptim->Instance)); | |
assert_param(IS_LTDC_ALL_INSTANCE(hltdc->Instance)); | |
assert_param(IS_LTDC_HSYNC(hltdc->Init.HorizontalSync)); | |
assert_param(IS_LTDC_VSYNC(hltdc->Init.VerticalSync)); | |
assert_param(IS_LTDC_AHBP(hltdc->Init.AccumulatedHBP)); | |
assert_param(IS_LTDC_AVBP(hltdc->Init.AccumulatedVBP)); | |
assert_param(IS_LTDC_AAH(hltdc->Init.AccumulatedActiveH)); | |
assert_param(IS_LTDC_AAW(hltdc->Init.AccumulatedActiveW)); | |
assert_param(IS_LTDC_TOTALH(hltdc->Init.TotalHeigh)); | |
assert_param(IS_LTDC_TOTALW(hltdc->Init.TotalWidth)); | |
assert_param(IS_LTDC_HSPOL(hltdc->Init.HSPolarity)); | |
assert_param(IS_LTDC_VSPOL(hltdc->Init.VSPolarity)); | |
assert_param(IS_LTDC_DEPOL(hltdc->Init.DEPolarity)); | |
assert_param(IS_LTDC_PCPOL(hltdc->Init.PCPolarity)); | |
assert_param(IS_LTDC_ALL_INSTANCE(hltdc->Instance)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0)); | |
assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1)); | |
assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0)); | |
assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1)); | |
assert_param(IS_LTDC_PIXEL_FORMAT(pLayerCfg->PixelFormat)); | |
assert_param(IS_LTDC_ALPHA(pLayerCfg->Alpha)); | |
assert_param(IS_LTDC_ALPHA(pLayerCfg->Alpha0)); | |
assert_param(IS_LTDC_BLENDING_FACTOR1(pLayerCfg->BlendingFactor1)); | |
assert_param(IS_LTDC_BLENDING_FACTOR2(pLayerCfg->BlendingFactor2)); | |
assert_param(IS_LTDC_CFBLL(pLayerCfg->ImageWidth)); | |
assert_param(IS_LTDC_CFBLNBR(pLayerCfg->ImageHeight)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_CFBLL(XSize)); | |
assert_param(IS_LTDC_CFBLNBR(YSize)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_CFBLL(X0)); | |
assert_param(IS_LTDC_CFBLNBR(Y0)); | |
assert_param(IS_LTDC_PIXEL_FORMAT(Pixelformat)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_ALPHA(Alpha)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LIPOS(Line)); | |
assert_param(IS_LTDC_RELOAD(ReloadType)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0)); | |
assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1)); | |
assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0)); | |
assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1)); | |
assert_param(IS_LTDC_PIXEL_FORMAT(pLayerCfg->PixelFormat)); | |
assert_param(IS_LTDC_ALPHA(pLayerCfg->Alpha)); | |
assert_param(IS_LTDC_ALPHA(pLayerCfg->Alpha0)); | |
assert_param(IS_LTDC_BLENDING_FACTOR1(pLayerCfg->BlendingFactor1)); | |
assert_param(IS_LTDC_BLENDING_FACTOR2(pLayerCfg->BlendingFactor2)); | |
assert_param(IS_LTDC_CFBLL(pLayerCfg->ImageWidth)); | |
assert_param(IS_LTDC_CFBLNBR(pLayerCfg->ImageHeight)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_CFBLL(XSize)); | |
assert_param(IS_LTDC_CFBLNBR(YSize)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_CFBLL(X0)); | |
assert_param(IS_LTDC_CFBLNBR(Y0)); | |
assert_param(IS_LTDC_PIXEL_FORMAT(Pixelformat)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_ALPHA(Alpha)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_LTDC_LAYER(LayerIdx)); | |
assert_param(IS_SDIO_ALL_INSTANCE(hmmc->Instance)); | |
assert_param(IS_SDIO_CLOCK_EDGE(hmmc->Init.ClockEdge)); | |
assert_param(IS_SDIO_CLOCK_BYPASS(hmmc->Init.ClockBypass)); | |
assert_param(IS_SDIO_CLOCK_POWER_SAVE(hmmc->Init.ClockPowerSave)); | |
assert_param(IS_SDIO_BUS_WIDE(hmmc->Init.BusWide)); | |
assert_param(IS_SDIO_HARDWARE_FLOW_CONTROL(hmmc->Init.HardwareFlowControl)); | |
assert_param(IS_SDIO_CLKDIV(hmmc->Init.ClockDiv)); | |
assert_param(IS_SDIO_ALL_INSTANCE(hmmc->Instance)); | |
assert_param(IS_SDIO_BUS_WIDE(WideMode)); | |
assert_param(IS_PCD_ALL_INSTANCE(hpcd->Instance)); | |
assert_param(IS_PWR_PVD_LEVEL(sConfigPVD->PVDLevel)); | |
assert_param(IS_PWR_PVD_MODE(sConfigPVD->Mode)); | |
assert_param(IS_PWR_WAKEUP_PIN(WakeUpPinx)); | |
assert_param(IS_PWR_WAKEUP_PIN(WakeUpPinx)); | |
assert_param(IS_PWR_REGULATOR(Regulator)); | |
assert_param(IS_PWR_SLEEP_ENTRY(SLEEPEntry)); | |
assert_param(IS_PWR_REGULATOR(Regulator)); | |
assert_param(IS_PWR_STOP_ENTRY(STOPEntry)); | |
assert_param(IS_PWR_VOLTAGE_SCALING_RANGE(VoltageScaling)); | |
assert_param(IS_PWR_VOLTAGE_SCALING_RANGE(VoltageScaling)); | |
assert_param(IS_PWR_REGULATOR_UNDERDRIVE(Regulator)); | |
assert_param(IS_PWR_STOP_ENTRY(STOPEntry)); | |
assert_param(IS_QSPI_ALL_INSTANCE(hqspi->Instance)); | |
assert_param(IS_QSPI_CLOCK_PRESCALER(hqspi->Init.ClockPrescaler)); | |
assert_param(IS_QSPI_FIFO_THRESHOLD(hqspi->Init.FifoThreshold)); | |
assert_param(IS_QSPI_SSHIFT(hqspi->Init.SampleShifting)); | |
assert_param(IS_QSPI_FLASH_SIZE(hqspi->Init.FlashSize)); | |
assert_param(IS_QSPI_CS_HIGH_TIME(hqspi->Init.ChipSelectHighTime)); | |
assert_param(IS_QSPI_CLOCK_MODE(hqspi->Init.ClockMode)); | |
assert_param(IS_QSPI_DUAL_FLASH_MODE(hqspi->Init.DualFlash)); | |
assert_param(IS_QSPI_FLASH_ID(hqspi->Init.FlashID)); | |
assert_param(IS_QSPI_INSTRUCTION_MODE(cmd->InstructionMode)); | |
assert_param(IS_QSPI_INSTRUCTION(cmd->Instruction)); | |
assert_param(IS_QSPI_ADDRESS_MODE(cmd->AddressMode)); | |
assert_param(IS_QSPI_ADDRESS_SIZE(cmd->AddressSize)); | |
assert_param(IS_QSPI_ALTERNATE_BYTES_MODE(cmd->AlternateByteMode)); | |
assert_param(IS_QSPI_ALTERNATE_BYTES_SIZE(cmd->AlternateBytesSize)); | |
assert_param(IS_QSPI_DUMMY_CYCLES(cmd->DummyCycles)); | |
assert_param(IS_QSPI_DATA_MODE(cmd->DataMode)); | |
assert_param(IS_QSPI_DDR_MODE(cmd->DdrMode)); | |
assert_param(IS_QSPI_DDR_HHC(cmd->DdrHoldHalfCycle)); | |
assert_param(IS_QSPI_SIOO_MODE(cmd->SIOOMode)); | |
assert_param(IS_QSPI_INSTRUCTION_MODE(cmd->InstructionMode)); | |
assert_param(IS_QSPI_INSTRUCTION(cmd->Instruction)); | |
assert_param(IS_QSPI_ADDRESS_MODE(cmd->AddressMode)); | |
assert_param(IS_QSPI_ADDRESS_SIZE(cmd->AddressSize)); | |
assert_param(IS_QSPI_ALTERNATE_BYTES_MODE(cmd->AlternateByteMode)); | |
assert_param(IS_QSPI_ALTERNATE_BYTES_SIZE(cmd->AlternateBytesSize)); | |
assert_param(IS_QSPI_DUMMY_CYCLES(cmd->DummyCycles)); | |
assert_param(IS_QSPI_DATA_MODE(cmd->DataMode)); | |
assert_param(IS_QSPI_DDR_MODE(cmd->DdrMode)); | |
assert_param(IS_QSPI_DDR_HHC(cmd->DdrHoldHalfCycle)); | |
assert_param(IS_QSPI_SIOO_MODE(cmd->SIOOMode)); | |
assert_param(IS_QSPI_INSTRUCTION_MODE(cmd->InstructionMode)); | |
assert_param(IS_QSPI_INSTRUCTION(cmd->Instruction)); | |
assert_param(IS_QSPI_ADDRESS_MODE(cmd->AddressMode)); | |
assert_param(IS_QSPI_ADDRESS_SIZE(cmd->AddressSize)); | |
assert_param(IS_QSPI_ALTERNATE_BYTES_MODE(cmd->AlternateByteMode)); | |
assert_param(IS_QSPI_ALTERNATE_BYTES_SIZE(cmd->AlternateBytesSize)); | |
assert_param(IS_QSPI_DUMMY_CYCLES(cmd->DummyCycles)); | |
assert_param(IS_QSPI_DATA_MODE(cmd->DataMode)); | |
assert_param(IS_QSPI_DDR_MODE(cmd->DdrMode)); | |
assert_param(IS_QSPI_DDR_HHC(cmd->DdrHoldHalfCycle)); | |
assert_param(IS_QSPI_SIOO_MODE(cmd->SIOOMode)); | |
assert_param(IS_QSPI_INTERVAL(cfg->Interval)); | |
assert_param(IS_QSPI_STATUS_BYTES_SIZE(cfg->StatusBytesSize)); | |
assert_param(IS_QSPI_MATCH_MODE(cfg->MatchMode)); | |
assert_param(IS_QSPI_INSTRUCTION_MODE(cmd->InstructionMode)); | |
assert_param(IS_QSPI_INSTRUCTION(cmd->Instruction)); | |
assert_param(IS_QSPI_ADDRESS_MODE(cmd->AddressMode)); | |
assert_param(IS_QSPI_ADDRESS_SIZE(cmd->AddressSize)); | |
assert_param(IS_QSPI_ALTERNATE_BYTES_MODE(cmd->AlternateByteMode)); | |
assert_param(IS_QSPI_ALTERNATE_BYTES_SIZE(cmd->AlternateBytesSize)); | |
assert_param(IS_QSPI_DUMMY_CYCLES(cmd->DummyCycles)); | |
assert_param(IS_QSPI_DATA_MODE(cmd->DataMode)); | |
assert_param(IS_QSPI_DDR_MODE(cmd->DdrMode)); | |
assert_param(IS_QSPI_DDR_HHC(cmd->DdrHoldHalfCycle)); | |
assert_param(IS_QSPI_SIOO_MODE(cmd->SIOOMode)); | |
assert_param(IS_QSPI_INTERVAL(cfg->Interval)); | |
assert_param(IS_QSPI_STATUS_BYTES_SIZE(cfg->StatusBytesSize)); | |
assert_param(IS_QSPI_MATCH_MODE(cfg->MatchMode)); | |
assert_param(IS_QSPI_AUTOMATIC_STOP(cfg->AutomaticStop)); | |
assert_param(IS_QSPI_INSTRUCTION_MODE(cmd->InstructionMode)); | |
assert_param(IS_QSPI_INSTRUCTION(cmd->Instruction)); | |
assert_param(IS_QSPI_ADDRESS_MODE(cmd->AddressMode)); | |
assert_param(IS_QSPI_ADDRESS_SIZE(cmd->AddressSize)); | |
assert_param(IS_QSPI_ALTERNATE_BYTES_MODE(cmd->AlternateByteMode)); | |
assert_param(IS_QSPI_ALTERNATE_BYTES_SIZE(cmd->AlternateBytesSize)); | |
assert_param(IS_QSPI_DUMMY_CYCLES(cmd->DummyCycles)); | |
assert_param(IS_QSPI_DATA_MODE(cmd->DataMode)); | |
assert_param(IS_QSPI_DDR_MODE(cmd->DdrMode)); | |
assert_param(IS_QSPI_DDR_HHC(cmd->DdrHoldHalfCycle)); | |
assert_param(IS_QSPI_SIOO_MODE(cmd->SIOOMode)); | |
assert_param(IS_QSPI_TIMEOUT_ACTIVATION(cfg->TimeOutActivation)); | |
assert_param(IS_QSPI_TIMEOUT_PERIOD(cfg->TimeOutPeriod)); | |
assert_param(IS_QSPI_FLASH_ID(FlashID)); | |
assert_param(IS_QSPI_FUNCTIONAL_MODE(FunctionalMode)); | |
assert_param(IS_RCC_OSCILLATORTYPE(RCC_OscInitStruct->OscillatorType)); | |
assert_param(IS_RCC_HSE(RCC_OscInitStruct->HSEState)); | |
assert_param(IS_RCC_HSI(RCC_OscInitStruct->HSIState)); | |
assert_param(IS_RCC_CALIBRATION_VALUE(RCC_OscInitStruct->HSICalibrationValue)); | |
assert_param(IS_RCC_LSI(RCC_OscInitStruct->LSIState)); | |
assert_param(IS_RCC_LSE(RCC_OscInitStruct->LSEState)); | |
assert_param(IS_RCC_PLL(RCC_OscInitStruct->PLL.PLLState)); | |
assert_param(IS_RCC_PLLSOURCE(RCC_OscInitStruct->PLL.PLLSource)); | |
assert_param(IS_RCC_PLLM_VALUE(RCC_OscInitStruct->PLL.PLLM)); | |
assert_param(IS_RCC_PLLN_VALUE(RCC_OscInitStruct->PLL.PLLN)); | |
assert_param(IS_RCC_PLLP_VALUE(RCC_OscInitStruct->PLL.PLLP)); | |
assert_param(IS_RCC_PLLQ_VALUE(RCC_OscInitStruct->PLL.PLLQ)); | |
assert_param(IS_RCC_CLOCKTYPE(RCC_ClkInitStruct->ClockType)); | |
assert_param(IS_FLASH_LATENCY(FLatency)); | |
assert_param(IS_RCC_HCLK(RCC_ClkInitStruct->AHBCLKDivider)); | |
assert_param(IS_RCC_SYSCLKSOURCE(RCC_ClkInitStruct->SYSCLKSource)); | |
assert_param(IS_RCC_PCLK(RCC_ClkInitStruct->APB1CLKDivider)); | |
assert_param(IS_RCC_PCLK(RCC_ClkInitStruct->APB2CLKDivider)); | |
assert_param(IS_RCC_MCO(RCC_MCOx)); | |
assert_param(IS_RCC_MCODIV(RCC_MCODiv)); | |
assert_param(IS_RCC_MCO1SOURCE(RCC_MCOSource)); | |
assert_param(IS_RCC_MCO2SOURCE(RCC_MCOSource)); | |
assert_param(IS_RCC_PERIPHCLOCK(PeriphClkInit->PeriphClockSelection)); | |
assert_param(IS_RCC_I2SAPB1CLKSOURCE(PeriphClkInit->I2sApb1ClockSelection)); | |
assert_param(IS_RCC_I2SAPB2CLKSOURCE(PeriphClkInit->I2sApb2ClockSelection)); | |
assert_param(IS_RCC_SAI1CLKSOURCE(PeriphClkInit->Sai1ClockSelection)); | |
assert_param(IS_RCC_SAI2CLKSOURCE(PeriphClkInit->Sai2ClockSelection)); | |
assert_param(IS_RCC_RTCCLKSOURCE(PeriphClkInit->RTCClockSelection)); | |
assert_param(IS_RCC_FMPI2C1CLKSOURCE(PeriphClkInit->Fmpi2c1ClockSelection)); | |
assert_param(IS_RCC_CECCLKSOURCE(PeriphClkInit->CecClockSelection)); | |
assert_param(IS_RCC_CLK48CLKSOURCE(PeriphClkInit->Clk48ClockSelection)); | |
assert_param(IS_RCC_SDIOCLKSOURCE(PeriphClkInit->SdioClockSelection)); | |
assert_param(IS_RCC_SPDIFRXCLKSOURCE(PeriphClkInit->SpdifClockSelection)); | |
assert_param(IS_RCC_PLLI2SM_VALUE(PeriphClkInit->PLLI2S.PLLI2SM)); | |
assert_param(IS_RCC_PLLI2SN_VALUE(PeriphClkInit->PLLI2S.PLLI2SN)); | |
assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR)); | |
assert_param(IS_RCC_PLLI2SQ_VALUE(PeriphClkInit->PLLI2S.PLLI2SQ)); | |
assert_param(IS_RCC_PLLI2S_DIVQ_VALUE(PeriphClkInit->PLLI2SDivQ)); | |
assert_param(IS_RCC_PLLI2SP_VALUE(PeriphClkInit->PLLI2S.PLLI2SP)); | |
assert_param(IS_RCC_PLLI2SP_VALUE(PeriphClkInit->PLLI2S.PLLI2SP)); | |
assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR)); | |
assert_param(IS_RCC_PLLI2SQ_VALUE(PeriphClkInit->PLLI2S.PLLI2SQ)); | |
assert_param(IS_RCC_PLLSAIM_VALUE(PeriphClkInit->PLLSAI.PLLSAIM)); | |
assert_param(IS_RCC_PLLSAIN_VALUE(PeriphClkInit->PLLSAI.PLLSAIN)); | |
assert_param(IS_RCC_PLLSAIQ_VALUE(PeriphClkInit->PLLSAI.PLLSAIQ)); | |
assert_param(IS_RCC_PLLSAI_DIVQ_VALUE(PeriphClkInit->PLLSAIDivQ)); | |
assert_param(IS_RCC_PLLSAIP_VALUE(PeriphClkInit->PLLSAI.PLLSAIP)); | |
assert_param(IS_RCC_PERIPHCLOCK(PeriphClkInit->PeriphClockSelection)); | |
assert_param(IS_RCC_CLK48CLKSOURCE(PeriphClkInit->Clk48ClockSelection)); | |
assert_param(IS_RCC_SDIOCLKSOURCE(PeriphClkInit->SdioClockSelection)); | |
assert_param(IS_RCC_PLLI2SN_VALUE(PeriphClkInit->PLLI2S.PLLI2SN)); | |
assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR)); | |
assert_param(IS_RCC_PLLI2SQ_VALUE(PeriphClkInit->PLLI2S.PLLI2SQ)); | |
assert_param(IS_RCC_PLLI2S_DIVQ_VALUE(PeriphClkInit->PLLI2SDivQ)); | |
assert_param(IS_RCC_PLLI2SQ_VALUE(PeriphClkInit->PLLI2S.PLLI2SQ)); | |
assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR)); | |
assert_param(IS_RCC_PLLSAIN_VALUE(PeriphClkInit->PLLSAI.PLLSAIN)); | |
assert_param(IS_RCC_PLLSAIQ_VALUE(PeriphClkInit->PLLSAI.PLLSAIQ)); | |
assert_param(IS_RCC_PLLSAI_DIVQ_VALUE(PeriphClkInit->PLLSAIDivQ)); | |
assert_param(IS_RCC_PLLSAIR_VALUE(PeriphClkInit->PLLSAI.PLLSAIR)); | |
assert_param(IS_RCC_PLLSAI_DIVR_VALUE(PeriphClkInit->PLLSAIDivR)); | |
assert_param(IS_RCC_PLLSAIP_VALUE(PeriphClkInit->PLLSAI.PLLSAIP)); | |
assert_param(IS_RCC_RTCCLKSOURCE(PeriphClkInit->RTCClockSelection)); | |
assert_param(IS_RCC_PERIPHCLOCK(PeriphClkInit->PeriphClockSelection)); | |
assert_param(IS_RCC_I2SAPB1CLKSOURCE(PeriphClkInit->I2sApb1ClockSelection)); | |
assert_param(IS_RCC_I2SAPB2CLKSOURCE(PeriphClkInit->I2sApb2ClockSelection)); | |
assert_param(IS_RCC_SAIACLKSOURCE(PeriphClkInit->SaiAClockSelection)); | |
assert_param(IS_RCC_PLL_DIVR_VALUE(PeriphClkInit->PLLDivR)); | |
assert_param(IS_RCC_SAIBCLKSOURCE(PeriphClkInit->SaiBClockSelection)); | |
assert_param(IS_RCC_PLL_DIVR_VALUE(PeriphClkInit->PLLDivR)); | |
assert_param(IS_RCC_RTCCLKSOURCE(PeriphClkInit->RTCClockSelection)); | |
assert_param(IS_RCC_FMPI2C1CLKSOURCE(PeriphClkInit->Fmpi2c1ClockSelection)); | |
assert_param(IS_RCC_CLK48CLKSOURCE(PeriphClkInit->Clk48ClockSelection)); | |
assert_param(IS_RCC_SDIOCLKSOURCE(PeriphClkInit->SdioClockSelection)); | |
assert_param(IS_RCC_PLLI2SCLKSOURCE(PeriphClkInit->PLLI2SSelection)); | |
assert_param(IS_RCC_PLLI2SM_VALUE(PeriphClkInit->PLLI2S.PLLI2SM)); | |
assert_param(IS_RCC_PLLI2SN_VALUE(PeriphClkInit->PLLI2S.PLLI2SN)); | |
assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR)); | |
assert_param(IS_RCC_PLLI2SQ_VALUE(PeriphClkInit->PLLI2S.PLLI2SQ)); | |
assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR)); | |
assert_param(IS_RCC_PLLI2S_DIVR_VALUE(PeriphClkInit->PLLI2SDivR)); | |
assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR)); | |
assert_param(IS_RCC_PLLI2SQ_VALUE(PeriphClkInit->PLLI2S.PLLI2SQ)); | |
assert_param(IS_RCC_DFSDM1CLKSOURCE(PeriphClkInit->Dfsdm1ClockSelection)); | |
assert_param(IS_RCC_DFSDM1AUDIOCLKSOURCE(PeriphClkInit->Dfsdm1AudioClockSelection)); | |
assert_param(IS_RCC_DFSDM2CLKSOURCE(PeriphClkInit->Dfsdm2ClockSelection)); | |
assert_param(IS_RCC_DFSDM2AUDIOCLKSOURCE(PeriphClkInit->Dfsdm2AudioClockSelection)); | |
assert_param(IS_RCC_LPTIM1CLKSOURCE(PeriphClkInit->Lptim1ClockSelection)); | |
assert_param(IS_RCC_PERIPHCLOCK(PeriphClkInit->PeriphClockSelection)); | |
assert_param(IS_RCC_RTCCLKSOURCE(PeriphClkInit->RTCClockSelection)); | |
assert_param(IS_RCC_FMPI2C1CLKSOURCE(PeriphClkInit->Fmpi2c1ClockSelection)); | |
assert_param(IS_RCC_LPTIM1CLKSOURCE(PeriphClkInit->Lptim1ClockSelection)); | |
assert_param(IS_RCC_I2SAPBCLKSOURCE(PeriphClkInit->I2SClockSelection)); | |
assert_param(IS_RCC_PERIPHCLOCK(PeriphClkInit->PeriphClockSelection)); | |
assert_param(IS_RCC_PLLI2SN_VALUE(PeriphClkInit->PLLI2S.PLLI2SN)); | |
assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR)); | |
assert_param(IS_RCC_PLLI2SQ_VALUE(PeriphClkInit->PLLI2S.PLLI2SQ)); | |
assert_param(IS_RCC_PLLI2S_DIVQ_VALUE(PeriphClkInit->PLLI2SDivQ)); | |
assert_param(IS_RCC_PLLI2SQ_VALUE(PeriphClkInit->PLLI2S.PLLI2SQ)); | |
assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR)); | |
assert_param(IS_RCC_PLLSAIN_VALUE(PeriphClkInit->PLLSAI.PLLSAIN)); | |
assert_param(IS_RCC_PLLSAIQ_VALUE(PeriphClkInit->PLLSAI.PLLSAIQ)); | |
assert_param(IS_RCC_PLLSAI_DIVQ_VALUE(PeriphClkInit->PLLSAIDivQ)); | |
assert_param(IS_RCC_PLLSAIR_VALUE(PeriphClkInit->PLLSAI.PLLSAIR)); | |
assert_param(IS_RCC_PLLSAI_DIVR_VALUE(PeriphClkInit->PLLSAIDivR)); | |
assert_param(IS_RCC_RTCCLKSOURCE(PeriphClkInit->RTCClockSelection)); | |
assert_param(IS_RCC_PERIPHCLOCK(PeriphClkInit->PeriphClockSelection)); | |
assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR)); | |
assert_param(IS_RCC_PLLI2SN_VALUE(PeriphClkInit->PLLI2S.PLLI2SN)); | |
assert_param(IS_RCC_PLLI2SM_VALUE(PeriphClkInit->PLLI2S.PLLI2SM)); | |
assert_param(IS_RCC_RTCCLKSOURCE(PeriphClkInit->RTCClockSelection)); | |
assert_param(IS_RCC_LSE_MODE(Mode)); | |
assert_param(IS_RCC_PLLI2SN_VALUE(PLLI2SInit->PLLI2SN)); | |
assert_param(IS_RCC_PLLI2SR_VALUE(PLLI2SInit->PLLI2SR)); | |
assert_param(IS_RCC_PLLI2SM_VALUE(PLLI2SInit->PLLI2SM)); | |
assert_param(IS_RCC_PLLI2SP_VALUE(PLLI2SInit->PLLI2SP)); | |
assert_param(IS_RCC_PLLI2SQ_VALUE(PLLI2SInit->PLLI2SQ)); | |
assert_param(IS_RCC_PLLSAIN_VALUE(PLLSAIInit->PLLSAIN)); | |
assert_param(IS_RCC_PLLSAIQ_VALUE(PLLSAIInit->PLLSAIQ)); | |
assert_param(IS_RCC_PLLSAIM_VALUE(PLLSAIInit->PLLSAIM)); | |
assert_param(IS_RCC_PLLSAIP_VALUE(PLLSAIInit->PLLSAIP)); | |
assert_param(IS_RCC_PLLSAIR_VALUE(PLLSAIInit->PLLSAIR)); | |
assert_param(IS_RCC_OSCILLATORTYPE(RCC_OscInitStruct->OscillatorType)); | |
assert_param(IS_RCC_HSE(RCC_OscInitStruct->HSEState)); | |
assert_param(IS_RCC_HSI(RCC_OscInitStruct->HSIState)); | |
assert_param(IS_RCC_CALIBRATION_VALUE(RCC_OscInitStruct->HSICalibrationValue)); | |
assert_param(IS_RCC_LSI(RCC_OscInitStruct->LSIState)); | |
assert_param(IS_RCC_LSE(RCC_OscInitStruct->LSEState)); | |
assert_param(IS_RCC_PLL(RCC_OscInitStruct->PLL.PLLState)); | |
assert_param(IS_RCC_PLLSOURCE(RCC_OscInitStruct->PLL.PLLSource)); | |
assert_param(IS_RCC_PLLM_VALUE(RCC_OscInitStruct->PLL.PLLM)); | |
assert_param(IS_RCC_PLLN_VALUE(RCC_OscInitStruct->PLL.PLLN)); | |
assert_param(IS_RCC_PLLP_VALUE(RCC_OscInitStruct->PLL.PLLP)); | |
assert_param(IS_RCC_PLLQ_VALUE(RCC_OscInitStruct->PLL.PLLQ)); | |
assert_param(IS_RCC_PLLR_VALUE(RCC_OscInitStruct->PLL.PLLR)); | |
assert_param(IS_RNG_ALL_INSTANCE(hrng->Instance)); | |
assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance)); | |
assert_param(IS_RTC_HOUR_FORMAT(hrtc->Init.HourFormat)); | |
assert_param(IS_RTC_ASYNCH_PREDIV(hrtc->Init.AsynchPrediv)); | |
assert_param(IS_RTC_SYNCH_PREDIV(hrtc->Init.SynchPrediv)); | |
assert_param(IS_RTC_OUTPUT(hrtc->Init.OutPut)); | |
assert_param(IS_RTC_OUTPUT_POL(hrtc->Init.OutPutPolarity)); | |
assert_param(IS_RTC_OUTPUT_TYPE(hrtc->Init.OutPutType)); | |
assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance)); | |
assert_param(IS_RTC_FORMAT(Format)); | |
assert_param(IS_RTC_DAYLIGHT_SAVING(sTime->DayLightSaving)); | |
assert_param(IS_RTC_STORE_OPERATION(sTime->StoreOperation)); | |
assert_param(IS_RTC_HOUR12(sTime->Hours)); | |
assert_param(IS_RTC_HOURFORMAT12(sTime->TimeFormat)); | |
assert_param(IS_RTC_HOUR24(sTime->Hours)); | |
assert_param(IS_RTC_MINUTES(sTime->Minutes)); | |
assert_param(IS_RTC_SECONDS(sTime->Seconds)); | |
assert_param(IS_RTC_HOUR12(RTC_Bcd2ToByte(sTime->Hours))); | |
assert_param(IS_RTC_HOURFORMAT12(sTime->TimeFormat)); | |
assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sTime->Hours))); | |
assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sTime->Minutes))); | |
assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sTime->Seconds))); | |
assert_param(IS_RTC_FORMAT(Format)); | |
assert_param(IS_RTC_FORMAT(Format)); | |
assert_param(IS_RTC_WEEKDAY(sDate->WeekDay)); | |
assert_param(IS_RTC_YEAR(sDate->Year)); | |
assert_param(IS_RTC_MONTH(sDate->Month)); | |
assert_param(IS_RTC_DATE(sDate->Date)); | |
assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(sDate->Year))); | |
assert_param(IS_RTC_MONTH(RTC_Bcd2ToByte(sDate->Month))); | |
assert_param(IS_RTC_DATE(RTC_Bcd2ToByte(sDate->Date))); | |
assert_param(IS_RTC_FORMAT(Format)); | |
assert_param(IS_RTC_FORMAT(Format)); | |
assert_param(IS_RTC_ALARM(sAlarm->Alarm)); | |
assert_param(IS_RTC_ALARM_MASK(sAlarm->AlarmMask)); | |
assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(sAlarm->AlarmDateWeekDaySel)); | |
assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(sAlarm->AlarmTime.SubSeconds)); | |
assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(sAlarm->AlarmSubSecondMask)); | |
assert_param(IS_RTC_HOUR12(sAlarm->AlarmTime.Hours)); | |
assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat)); | |
assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours)); | |
assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes)); | |
assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds)); | |
assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(sAlarm->AlarmDateWeekDay)); | |
assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(sAlarm->AlarmDateWeekDay)); | |
assert_param(IS_RTC_HOUR12(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours))); | |
assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat)); | |
assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours))); | |
assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes))); | |
assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds))); | |
assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay))); | |
assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay))); | |
assert_param(IS_RTC_FORMAT(Format)); | |
assert_param(IS_RTC_ALARM(sAlarm->Alarm)); | |
assert_param(IS_RTC_ALARM_MASK(sAlarm->AlarmMask)); | |
assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(sAlarm->AlarmDateWeekDaySel)); | |
assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(sAlarm->AlarmTime.SubSeconds)); | |
assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(sAlarm->AlarmSubSecondMask)); | |
assert_param(IS_RTC_HOUR12(sAlarm->AlarmTime.Hours)); | |
assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat)); | |
assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours)); | |
assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes)); | |
assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds)); | |
assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(sAlarm->AlarmDateWeekDay)); | |
assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(sAlarm->AlarmDateWeekDay)); | |
assert_param(IS_RTC_HOUR12(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours))); | |
assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat)); | |
assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours))); | |
assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes))); | |
assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds))); | |
assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay))); | |
assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay))); | |
assert_param(IS_RTC_ALARM(Alarm)); | |
assert_param(IS_RTC_FORMAT(Format)); | |
assert_param(IS_RTC_ALARM(Alarm)); | |
assert_param(IS_TIMESTAMP_EDGE(RTC_TimeStampEdge)); | |
assert_param(IS_RTC_TIMESTAMP_PIN(RTC_TimeStampPin)); | |
assert_param(IS_TIMESTAMP_EDGE(RTC_TimeStampEdge)); | |
assert_param(IS_RTC_TIMESTAMP_PIN(RTC_TimeStampPin)); | |
assert_param(IS_RTC_FORMAT(Format)); | |
assert_param(IS_RTC_TAMPER(sTamper->Tamper)); | |
assert_param(IS_RTC_TAMPER_PIN(sTamper->PinSelection)); | |
assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger)); | |
assert_param(IS_RTC_TAMPER_FILTER(sTamper->Filter)); | |
assert_param(IS_RTC_TAMPER_FILTER_CONFIG_CORRECT(sTamper->Filter, sTamper->Trigger)); | |
assert_param(IS_RTC_TAMPER_SAMPLING_FREQ(sTamper->SamplingFrequency)); | |
assert_param(IS_RTC_TAMPER_PRECHARGE_DURATION(sTamper->PrechargeDuration)); | |
assert_param(IS_RTC_TAMPER_PULLUP_STATE(sTamper->TamperPullUp)); | |
assert_param(IS_RTC_TAMPER_TIMESTAMPONTAMPER_DETECTION(sTamper->TimeStampOnTamperDetection)); | |
assert_param(IS_RTC_TAMPER(sTamper->Tamper)); | |
assert_param(IS_RTC_TAMPER_PIN(sTamper->PinSelection)); | |
assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger)); | |
assert_param(IS_RTC_TAMPER_FILTER(sTamper->Filter)); | |
assert_param(IS_RTC_TAMPER_FILTER_CONFIG_CORRECT(sTamper->Filter, sTamper->Trigger)); | |
assert_param(IS_RTC_TAMPER_SAMPLING_FREQ(sTamper->SamplingFrequency)); | |
assert_param(IS_RTC_TAMPER_PRECHARGE_DURATION(sTamper->PrechargeDuration)); | |
assert_param(IS_RTC_TAMPER_PULLUP_STATE(sTamper->TamperPullUp)); | |
assert_param(IS_RTC_TAMPER_TIMESTAMPONTAMPER_DETECTION(sTamper->TimeStampOnTamperDetection)); | |
assert_param(IS_RTC_TAMPER(Tamper)); | |
assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock)); | |
assert_param(IS_RTC_WAKEUP_COUNTER(WakeUpCounter)); | |
assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock)); | |
assert_param(IS_RTC_WAKEUP_COUNTER(WakeUpCounter)); | |
assert_param(IS_RTC_BKP(BackupRegister)); | |
assert_param(IS_RTC_BKP(BackupRegister)); | |
assert_param(IS_RTC_CALIB_SIGN(CalibSign)); | |
assert_param(IS_RTC_CALIB_VALUE(Value)); | |
assert_param(IS_RTC_SMOOTH_CALIB_PERIOD(SmoothCalibPeriod)); | |
assert_param(IS_RTC_SMOOTH_CALIB_PLUS(SmoothCalibPlusPulses)); | |
assert_param(IS_RTC_SMOOTH_CALIB_MINUS(SmoothCalibMinusPulsesValue)); | |
assert_param(IS_RTC_SHIFT_ADD1S(ShiftAdd1S)); | |
assert_param(IS_RTC_SHIFT_SUBFS(ShiftSubFS)); | |
assert_param(IS_RTC_CALIB_OUTPUT(CalibOutput)); | |
assert_param(IS_SAI_SUPPORTED_PROTOCOL(protocol)); | |
assert_param(IS_SAI_PROTOCOL_DATASIZE(datasize)); | |
assert_param(IS_SAI_ALL_INSTANCE(hsai->Instance)); | |
assert_param(IS_SAI_AUDIO_FREQUENCY(hsai->Init.AudioFrequency)); | |
assert_param(IS_SAI_BLOCK_PROTOCOL(hsai->Init.Protocol)); | |
assert_param(IS_SAI_BLOCK_MODE(hsai->Init.AudioMode)); | |
assert_param(IS_SAI_BLOCK_SYNCEXT(hsai->Init.SynchroExt)); | |
assert_param(IS_SAI_BLOCK_DATASIZE(hsai->Init.DataSize)); | |
assert_param(IS_SAI_BLOCK_FIRST_BIT(hsai->Init.FirstBit)); | |
assert_param(IS_SAI_BLOCK_CLOCK_STROBING(hsai->Init.ClockStrobing)); | |
assert_param(IS_SAI_BLOCK_SYNCHRO(hsai->Init.Synchro)); | |
assert_param(IS_SAI_BLOCK_OUTPUT_DRIVE(hsai->Init.OutputDrive)); | |
assert_param(IS_SAI_BLOCK_NODIVIDER(hsai->Init.NoDivider)); | |
assert_param(IS_SAI_BLOCK_FIFO_THRESHOLD(hsai->Init.FIFOThreshold)); | |
assert_param(IS_SAI_MONO_STEREO_MODE(hsai->Init.MonoStereoMode)); | |
assert_param(IS_SAI_BLOCK_COMPANDING_MODE(hsai->Init.CompandingMode)); | |
assert_param(IS_SAI_BLOCK_TRISTATE_MANAGEMENT(hsai->Init.TriState)); | |
assert_param(IS_SAI_BLOCK_FRAME_LENGTH(hsai->FrameInit.FrameLength)); | |
assert_param(IS_SAI_BLOCK_ACTIVE_FRAME(hsai->FrameInit.ActiveFrameLength)); | |
assert_param(IS_SAI_BLOCK_FS_DEFINITION(hsai->FrameInit.FSDefinition)); | |
assert_param(IS_SAI_BLOCK_FS_POLARITY(hsai->FrameInit.FSPolarity)); | |
assert_param(IS_SAI_BLOCK_FS_OFFSET(hsai->FrameInit.FSOffset)); | |
assert_param(IS_SAI_BLOCK_FIRSTBIT_OFFSET(hsai->SlotInit.FirstBitOffset)); | |
assert_param(IS_SAI_BLOCK_SLOT_SIZE(hsai->SlotInit.SlotSize)); | |
assert_param(IS_SAI_BLOCK_SLOT_NUMBER(hsai->SlotInit.SlotNumber)); | |
assert_param(IS_SAI_SLOT_ACTIVE(hsai->SlotInit.SlotActive)); | |
assert_param(IS_SAI_BLOCK_MASTER_DIVIDER(hsai->Init.Mckdiv)); | |
assert_param(IS_SAI_BLOCK_MUTE_VALUE(val)); | |
assert_param(IS_SAI_BLOCK_MUTE_COUNTER(counter)); | |
assert_param(IS_SAI_CLK_SOURCE(hsai->Init.ClockSource)); | |
assert_param(IS_SDIO_ALL_INSTANCE(hsd->Instance)); | |
assert_param(IS_SDIO_CLOCK_EDGE(hsd->Init.ClockEdge)); | |
assert_param(IS_SDIO_CLOCK_BYPASS(hsd->Init.ClockBypass)); | |
assert_param(IS_SDIO_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave)); | |
assert_param(IS_SDIO_BUS_WIDE(hsd->Init.BusWide)); | |
assert_param(IS_SDIO_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl)); | |
assert_param(IS_SDIO_CLKDIV(hsd->Init.ClockDiv)); | |
assert_param(IS_SDIO_ALL_INSTANCE(hsd->Instance)); | |
assert_param(IS_SDIO_BUS_WIDE(WideMode)); | |
assert_param(IS_SMARTCARD_INSTANCE(hsc->Instance)); | |
assert_param(IS_SMARTCARD_NACK_STATE(hsc->Init.NACKState)); | |
assert_param(IS_SMARTCARD_INSTANCE(hsc->Instance)); | |
assert_param(IS_SMARTCARD_INSTANCE(hsc->Instance)); | |
assert_param(IS_SMARTCARD_POLARITY(hsc->Init.CLKPolarity)); | |
assert_param(IS_SMARTCARD_PHASE(hsc->Init.CLKPhase)); | |
assert_param(IS_SMARTCARD_LASTBIT(hsc->Init.CLKLastBit)); | |
assert_param(IS_SMARTCARD_BAUDRATE(hsc->Init.BaudRate)); | |
assert_param(IS_SMARTCARD_WORD_LENGTH(hsc->Init.WordLength)); | |
assert_param(IS_SMARTCARD_STOPBITS(hsc->Init.StopBits)); | |
assert_param(IS_SMARTCARD_PARITY(hsc->Init.Parity)); | |
assert_param(IS_SMARTCARD_MODE(hsc->Init.Mode)); | |
assert_param(IS_SMARTCARD_NACK_STATE(hsc->Init.NACKState)); | |
assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance)); | |
assert_param(IS_SPI_MODE(hspi->Init.Mode)); | |
assert_param(IS_SPI_DIRECTION(hspi->Init.Direction)); | |
assert_param(IS_SPI_DATASIZE(hspi->Init.DataSize)); | |
assert_param(IS_SPI_NSS(hspi->Init.NSS)); | |
assert_param(IS_SPI_BAUDRATE_PRESCALER(hspi->Init.BaudRatePrescaler)); | |
assert_param(IS_SPI_FIRST_BIT(hspi->Init.FirstBit)); | |
assert_param(IS_SPI_TIMODE(hspi->Init.TIMode)); | |
assert_param(IS_SPI_CPOL(hspi->Init.CLKPolarity)); | |
assert_param(IS_SPI_CPHA(hspi->Init.CLKPhase)); | |
assert_param(IS_SPI_BAUDRATE_PRESCALER(hspi->Init.BaudRatePrescaler)); | |
assert_param(IS_SPI_BAUDRATE_PRESCALER(hspi->Init.BaudRatePrescaler)); | |
assert_param(IS_SPI_CRC_CALCULATION(hspi->Init.CRCCalculation)); | |
assert_param(IS_SPI_CRC_POLYNOMIAL(hspi->Init.CRCPolynomial)); | |
assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance)); | |
assert_param(IS_SPI_DIRECTION_2LINES_OR_1LINE(hspi->Init.Direction)); | |
assert_param(IS_SPI_DIRECTION_2LINES(hspi->Init.Direction)); | |
assert_param(IS_SPI_DIRECTION_2LINES_OR_1LINE(hspi->Init.Direction)); | |
assert_param(IS_SPI_DIRECTION_2LINES(hspi->Init.Direction)); | |
assert_param(IS_SPI_DMA_HANDLE(hspi->hdmatx)); | |
assert_param(IS_SPI_DIRECTION_2LINES_OR_1LINE(hspi->Init.Direction)); | |
assert_param(IS_SPI_DMA_HANDLE(hspi->hdmarx)); | |
assert_param(IS_SPI_DMA_HANDLE(hspi->hdmatx)); | |
assert_param(IS_SPI_DMA_HANDLE(hspi->hdmarx)); | |
assert_param(IS_SPI_DMA_HANDLE(hspi->hdmatx)); | |
assert_param(IS_SPI_DIRECTION_2LINES(hspi->Init.Direction)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode)); | |
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision)); | |
assert_param(IS_TIM_PERIOD(htim, htim->Init.Period)); | |
assert_param(IS_TIM_AUTORELOAD_PRELOAD(htim->Init.AutoReloadPreload)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_DMA_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_DMA_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode)); | |
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision)); | |
assert_param(IS_TIM_PERIOD(htim, htim->Init.Period)); | |
assert_param(IS_TIM_AUTORELOAD_PRELOAD(htim->Init.AutoReloadPreload)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode)); | |
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision)); | |
assert_param(IS_TIM_PERIOD(htim, htim->Init.Period)); | |
assert_param(IS_TIM_AUTORELOAD_PRELOAD(htim->Init.AutoReloadPreload)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode)); | |
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision)); | |
assert_param(IS_TIM_PERIOD(htim, htim->Init.Period)); | |
assert_param(IS_TIM_AUTORELOAD_PRELOAD(htim->Init.AutoReloadPreload)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_DMA_CC_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_DMA_CC_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode)); | |
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision)); | |
assert_param(IS_TIM_OPM_MODE(OnePulseMode)); | |
assert_param(IS_TIM_PERIOD(htim, htim->Init.Period)); | |
assert_param(IS_TIM_AUTORELOAD_PRELOAD(htim->Init.AutoReloadPreload)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_ENCODER_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode)); | |
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision)); | |
assert_param(IS_TIM_AUTORELOAD_PRELOAD(htim->Init.AutoReloadPreload)); | |
assert_param(IS_TIM_ENCODER_MODE(sConfig->EncoderMode)); | |
assert_param(IS_TIM_IC_SELECTION(sConfig->IC1Selection)); | |
assert_param(IS_TIM_IC_SELECTION(sConfig->IC2Selection)); | |
assert_param(IS_TIM_ENCODERINPUT_POLARITY(sConfig->IC1Polarity)); | |
assert_param(IS_TIM_ENCODERINPUT_POLARITY(sConfig->IC2Polarity)); | |
assert_param(IS_TIM_IC_PRESCALER(sConfig->IC1Prescaler)); | |
assert_param(IS_TIM_IC_PRESCALER(sConfig->IC2Prescaler)); | |
assert_param(IS_TIM_IC_FILTER(sConfig->IC1Filter)); | |
assert_param(IS_TIM_IC_FILTER(sConfig->IC2Filter)); | |
assert_param(IS_TIM_PERIOD(htim, htim->Init.Period)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_ENCODER_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_ENCODER_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_ENCODER_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_ENCODER_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_ENCODER_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_ENCODER_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CHANNELS(Channel)); | |
assert_param(IS_TIM_OC_MODE(sConfig->OCMode)); | |
assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity)); | |
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC2_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC3_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC4_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_IC_POLARITY(sConfig->ICPolarity)); | |
assert_param(IS_TIM_IC_SELECTION(sConfig->ICSelection)); | |
assert_param(IS_TIM_IC_PRESCALER(sConfig->ICPrescaler)); | |
assert_param(IS_TIM_IC_FILTER(sConfig->ICFilter)); | |
assert_param(IS_TIM_CC2_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC3_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC4_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CHANNELS(Channel)); | |
assert_param(IS_TIM_PWM_MODE(sConfig->OCMode)); | |
assert_param(IS_TIM_OC_POLARITY(sConfig->OCPolarity)); | |
assert_param(IS_TIM_FAST_STATE(sConfig->OCFastMode)); | |
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC2_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC3_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC4_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_OPM_CHANNELS(OutputChannel)); | |
assert_param(IS_TIM_OPM_CHANNELS(InputChannel)); | |
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC2_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC2_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_DMABURST_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_DMA_BASE(BurstBaseAddress)); | |
assert_param(IS_TIM_DMA_SOURCE(BurstRequestSrc)); | |
assert_param(IS_TIM_DMA_LENGTH(BurstLength)); | |
assert_param(IS_TIM_DMA_DATA_LENGTH(DataLength)); | |
assert_param(IS_TIM_DMA_SOURCE(BurstRequestSrc)); | |
assert_param(IS_TIM_DMABURST_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_DMA_BASE(BurstBaseAddress)); | |
assert_param(IS_TIM_DMA_SOURCE(BurstRequestSrc)); | |
assert_param(IS_TIM_DMA_LENGTH(BurstLength)); | |
assert_param(IS_TIM_DMA_DATA_LENGTH(DataLength)); | |
assert_param(IS_TIM_DMA_SOURCE(BurstRequestSrc)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_EVENT_SOURCE(EventSource)); | |
assert_param(IS_TIM_OCXREF_CLEAR_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CLEARINPUT_SOURCE(sClearInputConfig->ClearInputSource)); | |
assert_param(IS_TIM_CLEARINPUT_POLARITY(sClearInputConfig->ClearInputPolarity)); | |
assert_param(IS_TIM_CLEARINPUT_PRESCALER(sClearInputConfig->ClearInputPrescaler)); | |
assert_param(IS_TIM_CLEARINPUT_FILTER(sClearInputConfig->ClearInputFilter)); | |
assert_param(IS_TIM_CLOCKSOURCE(sClockSourceConfig->ClockSource)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CLOCKSOURCE_ETRMODE1_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CLOCKPRESCALER(sClockSourceConfig->ClockPrescaler)); | |
assert_param(IS_TIM_CLOCKPOLARITY(sClockSourceConfig->ClockPolarity)); | |
assert_param(IS_TIM_CLOCKFILTER(sClockSourceConfig->ClockFilter)); | |
assert_param(IS_TIM_CLOCKSOURCE_ETRMODE2_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CLOCKPRESCALER(sClockSourceConfig->ClockPrescaler)); | |
assert_param(IS_TIM_CLOCKPOLARITY(sClockSourceConfig->ClockPolarity)); | |
assert_param(IS_TIM_CLOCKFILTER(sClockSourceConfig->ClockFilter)); | |
assert_param(IS_TIM_CLOCKSOURCE_TIX_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CLOCKPOLARITY(sClockSourceConfig->ClockPolarity)); | |
assert_param(IS_TIM_CLOCKFILTER(sClockSourceConfig->ClockFilter)); | |
assert_param(IS_TIM_CLOCKSOURCE_TIX_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CLOCKPOLARITY(sClockSourceConfig->ClockPolarity)); | |
assert_param(IS_TIM_CLOCKFILTER(sClockSourceConfig->ClockFilter)); | |
assert_param(IS_TIM_CLOCKSOURCE_TIX_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CLOCKPOLARITY(sClockSourceConfig->ClockPolarity)); | |
assert_param(IS_TIM_CLOCKFILTER(sClockSourceConfig->ClockFilter)); | |
assert_param(IS_TIM_CLOCKSOURCE_ITRX_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_XOR_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_TI1SELECTION(TI1_Selection)); | |
assert_param(IS_TIM_SLAVE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_SLAVE_MODE(sSlaveConfig->SlaveMode)); | |
assert_param(IS_TIM_TRIGGER_SELECTION(sSlaveConfig->InputTrigger)); | |
assert_param(IS_TIM_SLAVE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_SLAVE_MODE(sSlaveConfig->SlaveMode)); | |
assert_param(IS_TIM_TRIGGER_SELECTION(sSlaveConfig->InputTrigger)); | |
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC2_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC3_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC4_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_DMABURST_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_OCN_POLARITY(OC_Config->OCNPolarity)); | |
assert_param(IS_TIM_OCNIDLE_STATE(OC_Config->OCNIdleState)); | |
assert_param(IS_TIM_OCIDLE_STATE(OC_Config->OCIdleState)); | |
assert_param(IS_TIM_OCN_POLARITY(OC_Config->OCNPolarity)); | |
assert_param(IS_TIM_OCNIDLE_STATE(OC_Config->OCNIdleState)); | |
assert_param(IS_TIM_OCIDLE_STATE(OC_Config->OCIdleState)); | |
assert_param(IS_TIM_OCN_POLARITY(OC_Config->OCNPolarity)); | |
assert_param(IS_TIM_OCNIDLE_STATE(OC_Config->OCNIdleState)); | |
assert_param(IS_TIM_OCIDLE_STATE(OC_Config->OCIdleState)); | |
assert_param(IS_TIM_OCIDLE_STATE(OC_Config->OCIdleState)); | |
assert_param(IS_TIM_CLOCKSOURCE_ETRMODE1_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_TRIGGERPRESCALER(sSlaveConfig->TriggerPrescaler)); | |
assert_param(IS_TIM_TRIGGERPOLARITY(sSlaveConfig->TriggerPolarity)); | |
assert_param(IS_TIM_TRIGGERFILTER(sSlaveConfig->TriggerFilter)); | |
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_TRIGGERFILTER(sSlaveConfig->TriggerFilter)); | |
assert_param(IS_TIM_CC1_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_TRIGGERPOLARITY(sSlaveConfig->TriggerPolarity)); | |
assert_param(IS_TIM_TRIGGERFILTER(sSlaveConfig->TriggerFilter)); | |
assert_param(IS_TIM_CC2_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_TRIGGERPOLARITY(sSlaveConfig->TriggerPolarity)); | |
assert_param(IS_TIM_TRIGGERFILTER(sSlaveConfig->TriggerFilter)); | |
assert_param(IS_TIM_CC2_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CC1_INSTANCE(TIMx)); | |
assert_param(IS_TIM_CHANNELS(Channel)); | |
assert_param(IS_TIM_HALL_SENSOR_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode)); | |
assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision)); | |
assert_param(IS_TIM_AUTORELOAD_PRELOAD(htim->Init.AutoReloadPreload)); | |
assert_param(IS_TIM_IC_POLARITY(sConfig->IC1Polarity)); | |
assert_param(IS_TIM_PERIOD(htim, htim->Init.Period)); | |
assert_param(IS_TIM_IC_PRESCALER(sConfig->IC1Prescaler)); | |
assert_param(IS_TIM_IC_FILTER(sConfig->IC1Filter)); | |
assert_param(IS_TIM_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_HALL_SENSOR_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_HALL_SENSOR_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_HALL_SENSOR_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_HALL_SENSOR_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_HALL_SENSOR_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_HALL_SENSOR_INTERFACE_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, Channel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, OutputChannel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, OutputChannel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, OutputChannel)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, OutputChannel)); | |
assert_param(IS_TIM_COMMUTATION_EVENT_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_INTERNAL_TRIGGEREVENT_SELECTION(InputTrigger)); | |
assert_param(IS_TIM_COMMUTATION_EVENT_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_INTERNAL_TRIGGEREVENT_SELECTION(InputTrigger)); | |
assert_param(IS_TIM_COMMUTATION_EVENT_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_INTERNAL_TRIGGEREVENT_SELECTION(InputTrigger)); | |
assert_param(IS_TIM_MASTER_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_TRGO_SOURCE(sMasterConfig->MasterOutputTrigger)); | |
assert_param(IS_TIM_MSM_STATE(sMasterConfig->MasterSlaveMode)); | |
assert_param(IS_TIM_BREAK_INSTANCE(htim->Instance)); | |
assert_param(IS_TIM_OSSR_STATE(sBreakDeadTimeConfig->OffStateRunMode)); | |
assert_param(IS_TIM_OSSI_STATE(sBreakDeadTimeConfig->OffStateIDLEMode)); | |
assert_param(IS_TIM_LOCK_LEVEL(sBreakDeadTimeConfig->LockLevel)); | |
assert_param(IS_TIM_DEADTIME(sBreakDeadTimeConfig->DeadTime)); | |
assert_param(IS_TIM_BREAK_STATE(sBreakDeadTimeConfig->BreakState)); | |
assert_param(IS_TIM_BREAK_POLARITY(sBreakDeadTimeConfig->BreakPolarity)); | |
assert_param(IS_TIM_AUTOMATIC_OUTPUT_STATE(sBreakDeadTimeConfig->AutomaticOutput)); | |
assert_param(IS_TIM_REMAP(htim->Instance, Remap)); | |
assert_param(IS_TIM_CCXN_INSTANCE(htim->Instance, ChannelN)); | |
assert_param(IS_UART_HWFLOW_INSTANCE(huart->Instance)); | |
assert_param(IS_UART_HARDWARE_FLOW_CONTROL(huart->Init.HwFlowCtl)); | |
assert_param(IS_UART_INSTANCE(huart->Instance)); | |
assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength)); | |
assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling)); | |
assert_param(IS_UART_HALFDUPLEX_INSTANCE(huart->Instance)); | |
assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength)); | |
assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling)); | |
assert_param(IS_UART_LIN_INSTANCE(huart->Instance)); | |
assert_param(IS_UART_LIN_BREAK_DETECT_LENGTH(BreakDetectLength)); | |
assert_param(IS_UART_LIN_WORD_LENGTH(huart->Init.WordLength)); | |
assert_param(IS_UART_LIN_OVERSAMPLING(huart->Init.OverSampling)); | |
assert_param(IS_UART_INSTANCE(huart->Instance)); | |
assert_param(IS_UART_WAKEUPMETHOD(WakeUpMethod)); | |
assert_param(IS_UART_ADDRESS(Address)); | |
assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength)); | |
assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling)); | |
assert_param(IS_UART_INSTANCE(huart->Instance)); | |
assert_param(IS_UART_INSTANCE(huart->Instance)); | |
assert_param(IS_UART_INSTANCE(huart->Instance)); | |
assert_param(IS_UART_INSTANCE(huart->Instance)); | |
assert_param(IS_UART_BAUDRATE(huart->Init.BaudRate)); | |
assert_param(IS_UART_STOPBITS(huart->Init.StopBits)); | |
assert_param(IS_UART_PARITY(huart->Init.Parity)); | |
assert_param(IS_UART_MODE(huart->Init.Mode)); | |
assert_param(IS_USART_INSTANCE(husart->Instance)); | |
assert_param(IS_USART_INSTANCE(husart->Instance)); | |
assert_param(IS_USART_INSTANCE(husart->Instance)); | |
assert_param(IS_USART_POLARITY(husart->Init.CLKPolarity)); | |
assert_param(IS_USART_PHASE(husart->Init.CLKPhase)); | |
assert_param(IS_USART_LASTBIT(husart->Init.CLKLastBit)); | |
assert_param(IS_USART_BAUDRATE(husart->Init.BaudRate)); | |
assert_param(IS_USART_WORD_LENGTH(husart->Init.WordLength)); | |
assert_param(IS_USART_STOPBITS(husart->Init.StopBits)); | |
assert_param(IS_USART_PARITY(husart->Init.Parity)); | |
assert_param(IS_USART_MODE(husart->Init.Mode)); | |
assert_param(IS_WWDG_ALL_INSTANCE(hwwdg->Instance)); | |
assert_param(IS_WWDG_PRESCALER(hwwdg->Init.Prescaler)); | |
assert_param(IS_WWDG_WINDOW(hwwdg->Init.Window)); | |
assert_param(IS_WWDG_COUNTER(hwwdg->Init.Counter)); | |
assert_param(IS_WWDG_EWI_MODE(hwwdg->Init.EWIMode)); | |
assert_param(IS_ADC_COMMON_INSTANCE(ADCxy_COMMON)); | |
assert_param(IS_ADC_COMMON_INSTANCE(ADCxy_COMMON)); | |
assert_param(IS_LL_ADC_COMMON_CLOCK(ADC_CommonInitStruct->CommonClock)); | |
assert_param(IS_ADC_ALL_INSTANCE(ADCx)); | |
assert_param(IS_ADC_ALL_INSTANCE(ADCx)); | |
assert_param(IS_LL_ADC_RESOLUTION(ADC_InitStruct->Resolution)); | |
assert_param(IS_LL_ADC_DATA_ALIGN(ADC_InitStruct->DataAlignment)); | |
assert_param(IS_LL_ADC_SCAN_SELECTION(ADC_InitStruct->SequencersScanMode)); | |
assert_param(IS_ADC_ALL_INSTANCE(ADCx)); | |
assert_param(IS_LL_ADC_REG_TRIG_SOURCE(ADC_REG_InitStruct->TriggerSource)); | |
assert_param(IS_LL_ADC_REG_SEQ_SCAN_LENGTH(ADC_REG_InitStruct->SequencerLength)); | |
assert_param(IS_LL_ADC_REG_SEQ_SCAN_DISCONT_MODE(ADC_REG_InitStruct->SequencerDiscont)); | |
assert_param(IS_LL_ADC_REG_CONTINUOUS_MODE(ADC_REG_InitStruct->ContinuousMode)); | |
assert_param(IS_LL_ADC_REG_DMA_TRANSFER(ADC_REG_InitStruct->DMATransfer)); | |
assert_param((ADC_REG_InitStruct->ContinuousMode == LL_ADC_REG_CONV_SINGLE) | |
assert_param(IS_ADC_ALL_INSTANCE(ADCx)); | |
assert_param(IS_LL_ADC_INJ_TRIG_SOURCE(ADC_INJ_InitStruct->TriggerSource)); | |
assert_param(IS_LL_ADC_INJ_SEQ_SCAN_LENGTH(ADC_INJ_InitStruct->SequencerLength)); | |
assert_param(IS_LL_ADC_INJ_SEQ_SCAN_DISCONT_MODE(ADC_INJ_InitStruct->SequencerDiscont)); | |
assert_param(IS_LL_ADC_INJ_TRIG_AUTO(ADC_INJ_InitStruct->TrigAuto)); | |
assert_param(IS_DAC_ALL_INSTANCE(DACx)); | |
assert_param(IS_DAC_ALL_INSTANCE(DACx)); | |
assert_param(IS_LL_DAC_CHANNEL(DACx, DAC_Channel)); | |
assert_param(IS_LL_DAC_TRIGGER_SOURCE(DAC_InitStruct->TriggerSource)); | |
assert_param(IS_LL_DAC_OUTPUT_BUFFER(DAC_InitStruct->OutputBuffer)); | |
assert_param(IS_LL_DAC_WAVE_AUTO_GENER_MODE(DAC_InitStruct->WaveAutoGeneration)); | |
assert_param(IS_LL_DAC_WAVE_AUTO_GENER_CONFIG(DAC_InitStruct->WaveAutoGeneration, | |
assert_param(IS_LL_DMA_ALL_STREAM_INSTANCE(DMAx, Stream)); | |
assert_param(IS_LL_DMA_ALL_STREAM_INSTANCE(DMAx, Stream)); | |
assert_param(IS_LL_DMA_DIRECTION(DMA_InitStruct->Direction)); | |
assert_param(IS_LL_DMA_MODE(DMA_InitStruct->Mode)); | |
assert_param(IS_LL_DMA_PERIPHINCMODE(DMA_InitStruct->PeriphOrM2MSrcIncMode)); | |
assert_param(IS_LL_DMA_MEMORYINCMODE(DMA_InitStruct->MemoryOrM2MDstIncMode)); | |
assert_param(IS_LL_DMA_PERIPHDATASIZE(DMA_InitStruct->PeriphOrM2MSrcDataSize)); | |
assert_param(IS_LL_DMA_MEMORYDATASIZE(DMA_InitStruct->MemoryOrM2MDstDataSize)); | |
assert_param(IS_LL_DMA_NBDATA(DMA_InitStruct->NbData)); | |
assert_param(IS_LL_DMA_CHANNEL(DMA_InitStruct->Channel)); | |
assert_param(IS_LL_DMA_PRIORITY(DMA_InitStruct->Priority)); | |
assert_param(IS_LL_DMA_FIFO_MODE_STATE(DMA_InitStruct->FIFOMode)); | |
assert_param(IS_LL_DMA_FIFO_THRESHOLD(DMA_InitStruct->FIFOThreshold)); | |
assert_param(IS_LL_DMA_MEMORY_BURST(DMA_InitStruct->MemBurst)); | |
assert_param(IS_LL_DMA_PERIPHERAL_BURST(DMA_InitStruct->PeriphBurst)); | |
assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); | |
assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); | |
assert_param(IS_LL_DMA2D_MODE(DMA2D_InitStruct->Mode)); | |
assert_param(IS_LL_DMA2D_OCMODE(DMA2D_InitStruct->ColorMode)); | |
assert_param(IS_LL_DMA2D_LINE(DMA2D_InitStruct->NbrOfLines)); | |
assert_param(IS_LL_DMA2D_PIXEL(DMA2D_InitStruct->NbrOfPixelsPerLines)); | |
assert_param(IS_LL_DMA2D_GREEN(DMA2D_InitStruct->OutputGreen)); | |
assert_param(IS_LL_DMA2D_RED(DMA2D_InitStruct->OutputRed)); | |
assert_param(IS_LL_DMA2D_BLUE(DMA2D_InitStruct->OutputBlue)); | |
assert_param(IS_LL_DMA2D_ALPHA(DMA2D_InitStruct->OutputAlpha)); | |
assert_param(IS_LL_DMA2D_OFFSET(DMA2D_InitStruct->LineOffset)); | |
assert_param(IS_LL_DMA2D_OFFSET(DMA2D_LayerCfg->LineOffset)); | |
assert_param(IS_LL_DMA2D_LCMODE(DMA2D_LayerCfg->ColorMode)); | |
assert_param(IS_LL_DMA2D_CLUTCMODE(DMA2D_LayerCfg->CLUTColorMode)); | |
assert_param(IS_LL_DMA2D_CLUTSIZE(DMA2D_LayerCfg->CLUTSize)); | |
assert_param(IS_LL_DMA2D_ALPHAMODE(DMA2D_LayerCfg->AlphaMode)); | |
assert_param(IS_LL_DMA2D_GREEN(DMA2D_LayerCfg->Green)); | |
assert_param(IS_LL_DMA2D_RED(DMA2D_LayerCfg->Red)); | |
assert_param(IS_LL_DMA2D_BLUE(DMA2D_LayerCfg->Blue)); | |
assert_param(IS_LL_DMA2D_ALPHA(DMA2D_LayerCfg->Alpha)); | |
assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); | |
assert_param(IS_LL_DMA2D_OCMODE(DMA2D_ColorStruct->ColorMode)); | |
assert_param(IS_LL_DMA2D_GREEN(DMA2D_ColorStruct->OutputGreen)); | |
assert_param(IS_LL_DMA2D_RED(DMA2D_ColorStruct->OutputRed)); | |
assert_param(IS_LL_DMA2D_BLUE(DMA2D_ColorStruct->OutputBlue)); | |
assert_param(IS_LL_DMA2D_ALPHA(DMA2D_ColorStruct->OutputAlpha)); | |
assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); | |
assert_param(IS_LL_DMA2D_OCMODE(ColorMode)); | |
assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); | |
assert_param(IS_LL_DMA2D_OCMODE(ColorMode)); | |
assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); | |
assert_param(IS_LL_DMA2D_OCMODE(ColorMode)); | |
assert_param(IS_DMA2D_ALL_INSTANCE(DMA2Dx)); | |
assert_param(IS_LL_DMA2D_OCMODE(ColorMode)); | |
assert_param(IS_LL_EXTI_LINE_0_31(EXTI_InitStruct->Line_0_31)); | |
assert_param(IS_FUNCTIONAL_STATE(EXTI_InitStruct->LineCommand)); | |
assert_param(IS_LL_EXTI_MODE(EXTI_InitStruct->Mode)); | |
assert_param(IS_LL_EXTI_TRIGGER(EXTI_InitStruct->Trigger)); | |
assert_param(IS_FMC_NORSRAM_DEVICE(Device)); | |
assert_param(IS_FMC_NORSRAM_BANK(Init->NSBank)); | |
assert_param(IS_FMC_MUX(Init->DataAddressMux)); | |
assert_param(IS_FMC_MEMORY(Init->MemoryType)); | |
assert_param(IS_FMC_NORSRAM_MEMORY_WIDTH(Init->MemoryDataWidth)); | |
assert_param(IS_FMC_BURSTMODE(Init->BurstAccessMode)); | |
assert_param(IS_FMC_WAIT_POLARITY(Init->WaitSignalPolarity)); | |
assert_param(IS_FMC_WRAP_MODE(Init->WrapMode)); | |
assert_param(IS_FMC_WAIT_SIGNAL_ACTIVE(Init->WaitSignalActive)); | |
assert_param(IS_FMC_WRITE_OPERATION(Init->WriteOperation)); | |
assert_param(IS_FMC_WAITE_SIGNAL(Init->WaitSignal)); | |
assert_param(IS_FMC_EXTENDED_MODE(Init->ExtendedMode)); | |
assert_param(IS_FMC_ASYNWAIT(Init->AsynchronousWait)); | |
assert_param(IS_FMC_WRITE_BURST(Init->WriteBurst)); | |
assert_param(IS_FMC_CONTINOUS_CLOCK(Init->ContinuousClock)); | |
assert_param(IS_FMC_WRITE_FIFO(Init->WriteFifo)); | |
assert_param(IS_FMC_PAGESIZE(Init->PageSize)); | |
assert_param(IS_FMC_NORSRAM_DEVICE(Device)); | |
assert_param(IS_FMC_NORSRAM_EXTENDED_DEVICE(ExDevice)); | |
assert_param(IS_FMC_NORSRAM_BANK(Bank)); | |
assert_param(IS_FMC_NORSRAM_DEVICE(Device)); | |
assert_param(IS_FMC_ADDRESS_SETUP_TIME(Timing->AddressSetupTime)); | |
assert_param(IS_FMC_ADDRESS_HOLD_TIME(Timing->AddressHoldTime)); | |
assert_param(IS_FMC_DATASETUP_TIME(Timing->DataSetupTime)); | |
assert_param(IS_FMC_TURNAROUND_TIME(Timing->BusTurnAroundDuration)); | |
assert_param(IS_FMC_CLK_DIV(Timing->CLKDivision)); | |
assert_param(IS_FMC_DATA_LATENCY(Timing->DataLatency)); | |
assert_param(IS_FMC_ACCESS_MODE(Timing->AccessMode)); | |
assert_param(IS_FMC_NORSRAM_BANK(Bank)); | |
assert_param(IS_FMC_EXTENDED_MODE(ExtendedMode)); | |
assert_param(IS_FMC_NORSRAM_EXTENDED_DEVICE(Device)); | |
assert_param(IS_FMC_ADDRESS_SETUP_TIME(Timing->AddressSetupTime)); | |
assert_param(IS_FMC_ADDRESS_HOLD_TIME(Timing->AddressHoldTime)); | |
assert_param(IS_FMC_DATASETUP_TIME(Timing->DataSetupTime)); | |
assert_param(IS_FMC_TURNAROUND_TIME(Timing->BusTurnAroundDuration)); | |
assert_param(IS_FMC_ACCESS_MODE(Timing->AccessMode)); | |
assert_param(IS_FMC_NORSRAM_BANK(Bank)); | |
assert_param(IS_FMC_NORSRAM_DEVICE(Device)); | |
assert_param(IS_FMC_NORSRAM_BANK(Bank)); | |
assert_param(IS_FMC_NORSRAM_DEVICE(Device)); | |
assert_param(IS_FMC_NORSRAM_BANK(Bank)); | |
assert_param(IS_FMC_NAND_DEVICE(Device)); | |
assert_param(IS_FMC_NAND_BANK(Init->NandBank)); | |
assert_param(IS_FMC_WAIT_FEATURE(Init->Waitfeature)); | |
assert_param(IS_FMC_NAND_MEMORY_WIDTH(Init->MemoryDataWidth)); | |
assert_param(IS_FMC_ECC_STATE(Init->EccComputation)); | |
assert_param(IS_FMC_ECCPAGE_SIZE(Init->ECCPageSize)); | |
assert_param(IS_FMC_TCLR_TIME(Init->TCLRSetupTime)); | |
assert_param(IS_FMC_TAR_TIME(Init->TARSetupTime)); | |
assert_param(IS_FMC_NAND_DEVICE(Device)); | |
assert_param(IS_FMC_SETUP_TIME(Timing->SetupTime)); | |
assert_param(IS_FMC_WAIT_TIME(Timing->WaitSetupTime)); | |
assert_param(IS_FMC_HOLD_TIME(Timing->HoldSetupTime)); | |
assert_param(IS_FMC_HIZ_TIME(Timing->HiZSetupTime)); | |
assert_param(IS_FMC_NAND_BANK(Bank)); | |
assert_param(IS_FMC_NAND_DEVICE(Device)); | |
assert_param(IS_FMC_SETUP_TIME(Timing->SetupTime)); | |
assert_param(IS_FMC_WAIT_TIME(Timing->WaitSetupTime)); | |
assert_param(IS_FMC_HOLD_TIME(Timing->HoldSetupTime)); | |
assert_param(IS_FMC_HIZ_TIME(Timing->HiZSetupTime)); | |
assert_param(IS_FMC_NAND_BANK(Bank)); | |
assert_param(IS_FMC_NAND_DEVICE(Device)); | |
assert_param(IS_FMC_NAND_BANK(Bank)); | |
assert_param(IS_FMC_NAND_DEVICE(Device)); | |
assert_param(IS_FMC_NAND_BANK(Bank)); | |
assert_param(IS_FMC_NAND_DEVICE(Device)); | |
assert_param(IS_FMC_NAND_BANK(Bank)); | |
assert_param(IS_FMC_NAND_DEVICE(Device)); | |
assert_param(IS_FMC_NAND_BANK(Bank)); | |
assert_param(IS_FMC_PCCARD_DEVICE(Device)); | |
assert_param(IS_FMC_WAIT_FEATURE(Init->Waitfeature)); | |
assert_param(IS_FMC_TCLR_TIME(Init->TCLRSetupTime)); | |
assert_param(IS_FMC_TAR_TIME(Init->TARSetupTime)); | |
assert_param(IS_FMC_PCCARD_DEVICE(Device)); | |
assert_param(IS_FMC_SETUP_TIME(Timing->SetupTime)); | |
assert_param(IS_FMC_WAIT_TIME(Timing->WaitSetupTime)); | |
assert_param(IS_FMC_HOLD_TIME(Timing->HoldSetupTime)); | |
assert_param(IS_FMC_HIZ_TIME(Timing->HiZSetupTime)); | |
assert_param(IS_FMC_PCCARD_DEVICE(Device)); | |
assert_param(IS_FMC_SETUP_TIME(Timing->SetupTime)); | |
assert_param(IS_FMC_WAIT_TIME(Timing->WaitSetupTime)); | |
assert_param(IS_FMC_HOLD_TIME(Timing->HoldSetupTime)); | |
assert_param(IS_FMC_HIZ_TIME(Timing->HiZSetupTime)); | |
assert_param(IS_FMC_PCCARD_DEVICE(Device)); | |
assert_param(IS_FMC_SETUP_TIME(Timing->SetupTime)); | |
assert_param(IS_FMC_WAIT_TIME(Timing->WaitSetupTime)); | |
assert_param(IS_FMC_HOLD_TIME(Timing->HoldSetupTime)); | |
assert_param(IS_FMC_HIZ_TIME(Timing->HiZSetupTime)); | |
assert_param(IS_FMC_PCCARD_DEVICE(Device)); | |
assert_param(IS_FMC_SDRAM_DEVICE(Device)); | |
assert_param(IS_FMC_SDRAM_BANK(Init->SDBank)); | |
assert_param(IS_FMC_COLUMNBITS_NUMBER(Init->ColumnBitsNumber)); | |
assert_param(IS_FMC_ROWBITS_NUMBER(Init->RowBitsNumber)); | |
assert_param(IS_FMC_SDMEMORY_WIDTH(Init->MemoryDataWidth)); | |
assert_param(IS_FMC_INTERNALBANK_NUMBER(Init->InternalBankNumber)); | |
assert_param(IS_FMC_CAS_LATENCY(Init->CASLatency)); | |
assert_param(IS_FMC_WRITE_PROTECTION(Init->WriteProtection)); | |
assert_param(IS_FMC_SDCLOCK_PERIOD(Init->SDClockPeriod)); | |
assert_param(IS_FMC_READ_BURST(Init->ReadBurst)); | |
assert_param(IS_FMC_READPIPE_DELAY(Init->ReadPipeDelay)); | |
assert_param(IS_FMC_SDRAM_DEVICE(Device)); | |
assert_param(IS_FMC_LOADTOACTIVE_DELAY(Timing->LoadToActiveDelay)); | |
assert_param(IS_FMC_EXITSELFREFRESH_DELAY(Timing->ExitSelfRefreshDelay)); | |
assert_param(IS_FMC_SELFREFRESH_TIME(Timing->SelfRefreshTime)); | |
assert_param(IS_FMC_ROWCYCLE_DELAY(Timing->RowCycleDelay)); | |
assert_param(IS_FMC_WRITE_RECOVERY_TIME(Timing->WriteRecoveryTime)); | |
assert_param(IS_FMC_RP_DELAY(Timing->RPDelay)); | |
assert_param(IS_FMC_RCD_DELAY(Timing->RCDDelay)); | |
assert_param(IS_FMC_SDRAM_BANK(Bank)); | |
assert_param(IS_FMC_SDRAM_DEVICE(Device)); | |
assert_param(IS_FMC_SDRAM_BANK(Bank)); | |
assert_param(IS_FMC_SDRAM_DEVICE(Device)); | |
assert_param(IS_FMC_SDRAM_BANK(Bank)); | |
assert_param(IS_FMC_SDRAM_DEVICE(Device)); | |
assert_param(IS_FMC_SDRAM_BANK(Bank)); | |
assert_param(IS_FMC_SDRAM_DEVICE(Device)); | |
assert_param(IS_FMC_COMMAND_MODE(Command->CommandMode)); | |
assert_param(IS_FMC_COMMAND_TARGET(Command->CommandTarget)); | |
assert_param(IS_FMC_AUTOREFRESH_NUMBER(Command->AutoRefreshNumber)); | |
assert_param(IS_FMC_MODE_REGISTER(Command->ModeRegisterDefinition)); | |
assert_param(IS_FMC_SDRAM_DEVICE(Device)); | |
assert_param(IS_FMC_REFRESH_RATE(RefreshRate)); | |
assert_param(IS_FMC_SDRAM_DEVICE(Device)); | |
assert_param(IS_FMC_AUTOREFRESH_NUMBER(AutoRefreshNumber)); | |
assert_param(IS_FMC_SDRAM_DEVICE(Device)); | |
assert_param(IS_FMC_SDRAM_BANK(Bank)); | |
assert_param(IS_FSMC_NORSRAM_DEVICE(Device)); | |
assert_param(IS_FSMC_NORSRAM_BANK(Init->NSBank)); | |
assert_param(IS_FSMC_MUX(Init->DataAddressMux)); | |
assert_param(IS_FSMC_MEMORY(Init->MemoryType)); | |
assert_param(IS_FSMC_NORSRAM_MEMORY_WIDTH(Init->MemoryDataWidth)); | |
assert_param(IS_FSMC_BURSTMODE(Init->BurstAccessMode)); | |
assert_param(IS_FSMC_WAIT_POLARITY(Init->WaitSignalPolarity)); | |
assert_param(IS_FSMC_WRAP_MODE(Init->WrapMode)); | |
assert_param(IS_FSMC_WAIT_SIGNAL_ACTIVE(Init->WaitSignalActive)); | |
assert_param(IS_FSMC_WRITE_OPERATION(Init->WriteOperation)); | |
assert_param(IS_FSMC_WAITE_SIGNAL(Init->WaitSignal)); | |
assert_param(IS_FSMC_EXTENDED_MODE(Init->ExtendedMode)); | |
assert_param(IS_FSMC_ASYNWAIT(Init->AsynchronousWait)); | |
assert_param(IS_FSMC_WRITE_BURST(Init->WriteBurst)); | |
assert_param(IS_FSMC_CONTINOUS_CLOCK(Init->ContinuousClock)); | |
assert_param(IS_FSMC_WRITE_FIFO(Init->WriteFifo)); | |
assert_param(IS_FSMC_PAGESIZE(Init->PageSize)); | |
assert_param(IS_FSMC_NORSRAM_DEVICE(Device)); | |
assert_param(IS_FSMC_NORSRAM_EXTENDED_DEVICE(ExDevice)); | |
assert_param(IS_FSMC_NORSRAM_BANK(Bank)); | |
assert_param(IS_FSMC_NORSRAM_DEVICE(Device)); | |
assert_param(IS_FSMC_ADDRESS_SETUP_TIME(Timing->AddressSetupTime)); | |
assert_param(IS_FSMC_ADDRESS_HOLD_TIME(Timing->AddressHoldTime)); | |
assert_param(IS_FSMC_DATASETUP_TIME(Timing->DataSetupTime)); | |
assert_param(IS_FSMC_TURNAROUND_TIME(Timing->BusTurnAroundDuration)); | |
assert_param(IS_FSMC_CLK_DIV(Timing->CLKDivision)); | |
assert_param(IS_FSMC_DATA_LATENCY(Timing->DataLatency)); | |
assert_param(IS_FSMC_ACCESS_MODE(Timing->AccessMode)); | |
assert_param(IS_FSMC_NORSRAM_BANK(Bank)); | |
assert_param(IS_FSMC_EXTENDED_MODE(ExtendedMode)); | |
assert_param(IS_FSMC_NORSRAM_EXTENDED_DEVICE(Device)); | |
assert_param(IS_FSMC_ADDRESS_SETUP_TIME(Timing->AddressSetupTime)); | |
assert_param(IS_FSMC_ADDRESS_HOLD_TIME(Timing->AddressHoldTime)); | |
assert_param(IS_FSMC_DATASETUP_TIME(Timing->DataSetupTime)); | |
assert_param(IS_FSMC_TURNAROUND_TIME(Timing->BusTurnAroundDuration)); | |
assert_param(IS_FSMC_ACCESS_MODE(Timing->AccessMode)); | |
assert_param(IS_FSMC_NORSRAM_BANK(Bank)); | |
assert_param(IS_FSMC_NORSRAM_DEVICE(Device)); | |
assert_param(IS_FSMC_NORSRAM_BANK(Bank)); | |
assert_param(IS_FSMC_NORSRAM_DEVICE(Device)); | |
assert_param(IS_FSMC_NORSRAM_BANK(Bank)); | |
assert_param(IS_FSMC_NAND_DEVICE(Device)); | |
assert_param(IS_FSMC_NAND_BANK(Init->NandBank)); | |
assert_param(IS_FSMC_WAIT_FEATURE(Init->Waitfeature)); | |
assert_param(IS_FSMC_NAND_MEMORY_WIDTH(Init->MemoryDataWidth)); | |
assert_param(IS_FSMC_ECC_STATE(Init->EccComputation)); | |
assert_param(IS_FSMC_ECCPAGE_SIZE(Init->ECCPageSize)); | |
assert_param(IS_FSMC_TCLR_TIME(Init->TCLRSetupTime)); | |
assert_param(IS_FSMC_TAR_TIME(Init->TARSetupTime)); | |
assert_param(IS_FSMC_NAND_DEVICE(Device)); | |
assert_param(IS_FSMC_SETUP_TIME(Timing->SetupTime)); | |
assert_param(IS_FSMC_WAIT_TIME(Timing->WaitSetupTime)); | |
assert_param(IS_FSMC_HOLD_TIME(Timing->HoldSetupTime)); | |
assert_param(IS_FSMC_HIZ_TIME(Timing->HiZSetupTime)); | |
assert_param(IS_FSMC_NAND_BANK(Bank)); | |
assert_param(IS_FSMC_NAND_DEVICE(Device)); | |
assert_param(IS_FSMC_SETUP_TIME(Timing->SetupTime)); | |
assert_param(IS_FSMC_WAIT_TIME(Timing->WaitSetupTime)); | |
assert_param(IS_FSMC_HOLD_TIME(Timing->HoldSetupTime)); | |
assert_param(IS_FSMC_HIZ_TIME(Timing->HiZSetupTime)); | |
assert_param(IS_FSMC_NAND_BANK(Bank)); | |
assert_param(IS_FSMC_NAND_DEVICE(Device)); | |
assert_param(IS_FSMC_NAND_BANK(Bank)); | |
assert_param(IS_FSMC_NAND_DEVICE(Device)); | |
assert_param(IS_FSMC_NAND_BANK(Bank)); | |
assert_param(IS_FSMC_NAND_DEVICE(Device)); | |
assert_param(IS_FSMC_NAND_BANK(Bank)); | |
assert_param(IS_FSMC_NAND_DEVICE(Device)); | |
assert_param(IS_FSMC_NAND_BANK(Bank)); | |
assert_param(IS_FSMC_PCCARD_DEVICE(Device)); | |
assert_param(IS_FSMC_WAIT_FEATURE(Init->Waitfeature)); | |
assert_param(IS_FSMC_TCLR_TIME(Init->TCLRSetupTime)); | |
assert_param(IS_FSMC_TAR_TIME(Init->TARSetupTime)); | |
assert_param(IS_FSMC_PCCARD_DEVICE(Device)); | |
assert_param(IS_FSMC_SETUP_TIME(Timing->SetupTime)); | |
assert_param(IS_FSMC_WAIT_TIME(Timing->WaitSetupTime)); | |
assert_param(IS_FSMC_HOLD_TIME(Timing->HoldSetupTime)); | |
assert_param(IS_FSMC_HIZ_TIME(Timing->HiZSetupTime)); | |
assert_param(IS_FSMC_PCCARD_DEVICE(Device)); | |
assert_param(IS_FSMC_SETUP_TIME(Timing->SetupTime)); | |
assert_param(IS_FSMC_WAIT_TIME(Timing->WaitSetupTime)); | |
assert_param(IS_FSMC_HOLD_TIME(Timing->HoldSetupTime)); | |
assert_param(IS_FSMC_HIZ_TIME(Timing->HiZSetupTime)); | |
assert_param(IS_FSMC_PCCARD_DEVICE(Device)); | |
assert_param(IS_FSMC_SETUP_TIME(Timing->SetupTime)); | |
assert_param(IS_FSMC_WAIT_TIME(Timing->WaitSetupTime)); | |
assert_param(IS_FSMC_HOLD_TIME(Timing->HoldSetupTime)); | |
assert_param(IS_FSMC_HIZ_TIME(Timing->HiZSetupTime)); | |
assert_param(IS_FSMC_PCCARD_DEVICE(Device)); | |
assert_param(IS_GPIO_ALL_INSTANCE(GPIOx)); | |
assert_param(IS_GPIO_ALL_INSTANCE(GPIOx)); | |
assert_param(IS_LL_GPIO_PIN(GPIO_InitStruct->Pin)); | |
assert_param(IS_LL_GPIO_MODE(GPIO_InitStruct->Mode)); | |
assert_param(IS_LL_GPIO_PULL(GPIO_InitStruct->Pull)); | |
assert_param(IS_LL_GPIO_SPEED(GPIO_InitStruct->Speed)); | |
assert_param(IS_LL_GPIO_OUTPUT_TYPE(GPIO_InitStruct->OutputType)); | |
assert_param(IS_LL_GPIO_ALTERNATE(GPIO_InitStruct->Alternate)); | |
assert_param(IS_I2C_ALL_INSTANCE(I2Cx)); | |
assert_param(IS_I2C_ALL_INSTANCE(I2Cx)); | |
assert_param(IS_LL_I2C_PERIPHERAL_MODE(I2C_InitStruct->PeripheralMode)); | |
assert_param(IS_LL_I2C_CLOCK_SPEED(I2C_InitStruct->ClockSpeed)); | |
assert_param(IS_LL_I2C_DUTY_CYCLE(I2C_InitStruct->DutyCycle)); | |
assert_param(IS_LL_I2C_ANALOG_FILTER(I2C_InitStruct->AnalogFilter)); | |
assert_param(IS_LL_I2C_DIGITAL_FILTER(I2C_InitStruct->DigitalFilter)); | |
assert_param(IS_LL_I2C_OWN_ADDRESS1(I2C_InitStruct->OwnAddress1)); | |
assert_param(IS_LL_I2C_TYPE_ACKNOWLEDGE(I2C_InitStruct->TypeAcknowledge)); | |
assert_param(IS_LL_I2C_OWN_ADDRSIZE(I2C_InitStruct->OwnAddrSize)); | |
assert_param(IS_LPTIM_INSTANCE(LPTIMx)); | |
assert_param(IS_LPTIM_INSTANCE(LPTIMx)); | |
assert_param(IS_LL_LPTIM_CLOCK_SOURCE(LPTIM_InitStruct->ClockSource)); | |
assert_param(IS_LL_LPTIM_CLOCK_PRESCALER(LPTIM_InitStruct->Prescaler)); | |
assert_param(IS_LL_LPTIM_WAVEFORM(LPTIM_InitStruct->Waveform)); | |
assert_param(IS_LL_LPTIM_OUTPUT_POLARITY(LPTIM_InitStruct->Polarity)); | |
assert_param(IS_LPTIM_INSTANCE(LPTIMx)); | |
assert_param(IS_LL_RCC_FMPI2C_CLKSOURCE(FMPI2CxSource)); | |
assert_param(IS_LL_RCC_I2S_CLKSOURCE(I2SxSource)); | |
assert_param(IS_LL_RCC_LPTIM_CLKSOURCE(LPTIMxSource)); | |
assert_param(IS_LL_RCC_SDIO_CLKSOURCE(SDIOxSource)); | |
assert_param(IS_LL_RCC_RNG_CLKSOURCE(RNGxSource)); | |
assert_param(IS_LL_RCC_USB_CLKSOURCE(USBxSource)); | |
assert_param(IS_RTC_ALL_INSTANCE(RTCx)); | |
assert_param(IS_RTC_ALL_INSTANCE(RTCx)); | |
assert_param(IS_LL_RTC_HOURFORMAT(RTC_InitStruct->HourFormat)); | |
assert_param(IS_LL_RTC_ASYNCH_PREDIV(RTC_InitStruct->AsynchPrescaler)); | |
assert_param(IS_LL_RTC_SYNCH_PREDIV(RTC_InitStruct->SynchPrescaler)); | |
assert_param(IS_RTC_ALL_INSTANCE(RTCx)); | |
assert_param(IS_LL_RTC_FORMAT(RTC_Format)); | |
assert_param(IS_LL_RTC_HOUR12(RTC_TimeStruct->Hours)); | |
assert_param(IS_LL_RTC_TIME_FORMAT(RTC_TimeStruct->TimeFormat)); | |
assert_param(IS_LL_RTC_HOUR24(RTC_TimeStruct->Hours)); | |
assert_param(IS_LL_RTC_MINUTES(RTC_TimeStruct->Minutes)); | |
assert_param(IS_LL_RTC_SECONDS(RTC_TimeStruct->Seconds)); | |
assert_param(IS_LL_RTC_HOUR12(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Hours))); | |
assert_param(IS_LL_RTC_TIME_FORMAT(RTC_TimeStruct->TimeFormat)); | |
assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Hours))); | |
assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Minutes))); | |
assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Seconds))); | |
assert_param(IS_RTC_ALL_INSTANCE(RTCx)); | |
assert_param(IS_LL_RTC_FORMAT(RTC_Format)); | |
assert_param(IS_LL_RTC_YEAR(RTC_DateStruct->Year)); | |
assert_param(IS_LL_RTC_MONTH(RTC_DateStruct->Month)); | |
assert_param(IS_LL_RTC_DAY(RTC_DateStruct->Day)); | |
assert_param(IS_LL_RTC_YEAR(__LL_RTC_CONVERT_BCD2BIN(RTC_DateStruct->Year))); | |
assert_param(IS_LL_RTC_MONTH(__LL_RTC_CONVERT_BCD2BIN(RTC_DateStruct->Month))); | |
assert_param(IS_LL_RTC_DAY(__LL_RTC_CONVERT_BCD2BIN(RTC_DateStruct->Day))); | |
assert_param(IS_LL_RTC_WEEKDAY(RTC_DateStruct->WeekDay)); | |
assert_param(IS_RTC_ALL_INSTANCE(RTCx)); | |
assert_param(IS_LL_RTC_FORMAT(RTC_Format)); | |
assert_param(IS_LL_RTC_ALMA_MASK(RTC_AlarmStruct->AlarmMask)); | |
assert_param(IS_LL_RTC_ALMA_DATE_WEEKDAY_SEL(RTC_AlarmStruct->AlarmDateWeekDaySel)); | |
assert_param(IS_LL_RTC_HOUR12(RTC_AlarmStruct->AlarmTime.Hours)); | |
assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat)); | |
assert_param(IS_LL_RTC_HOUR24(RTC_AlarmStruct->AlarmTime.Hours)); | |
assert_param(IS_LL_RTC_MINUTES(RTC_AlarmStruct->AlarmTime.Minutes)); | |
assert_param(IS_LL_RTC_SECONDS(RTC_AlarmStruct->AlarmTime.Seconds)); | |
assert_param(IS_LL_RTC_DAY(RTC_AlarmStruct->AlarmDateWeekDay)); | |
assert_param(IS_LL_RTC_WEEKDAY(RTC_AlarmStruct->AlarmDateWeekDay)); | |
assert_param(IS_LL_RTC_HOUR12(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours))); | |
assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat)); | |
assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours))); | |
assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Minutes))); | |
assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Seconds))); | |
assert_param(IS_LL_RTC_DAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay))); | |
assert_param(IS_LL_RTC_WEEKDAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay))); | |
assert_param(IS_RTC_ALL_INSTANCE(RTCx)); | |
assert_param(IS_LL_RTC_FORMAT(RTC_Format)); | |
assert_param(IS_LL_RTC_ALMB_MASK(RTC_AlarmStruct->AlarmMask)); | |
assert_param(IS_LL_RTC_ALMB_DATE_WEEKDAY_SEL(RTC_AlarmStruct->AlarmDateWeekDaySel)); | |
assert_param(IS_LL_RTC_HOUR12(RTC_AlarmStruct->AlarmTime.Hours)); | |
assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat)); | |
assert_param(IS_LL_RTC_HOUR24(RTC_AlarmStruct->AlarmTime.Hours)); | |
assert_param(IS_LL_RTC_MINUTES(RTC_AlarmStruct->AlarmTime.Minutes)); | |
assert_param(IS_LL_RTC_SECONDS(RTC_AlarmStruct->AlarmTime.Seconds)); | |
assert_param(IS_LL_RTC_DAY(RTC_AlarmStruct->AlarmDateWeekDay)); | |
assert_param(IS_LL_RTC_WEEKDAY(RTC_AlarmStruct->AlarmDateWeekDay)); | |
assert_param(IS_LL_RTC_HOUR12(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours))); | |
assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat)); | |
assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours))); | |
assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Minutes))); | |
assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Seconds))); | |
assert_param(IS_LL_RTC_DAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay))); | |
assert_param(IS_LL_RTC_WEEKDAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay))); | |
assert_param(IS_RTC_ALL_INSTANCE(RTCx)); | |
assert_param(IS_RTC_ALL_INSTANCE(RTCx)); | |
assert_param(IS_RTC_ALL_INSTANCE(RTCx)); | |
assert_param(IS_SDIO_ALL_INSTANCE(SDIOx)); | |
assert_param(IS_SDIO_CLOCK_EDGE(Init.ClockEdge)); | |
assert_param(IS_SDIO_CLOCK_BYPASS(Init.ClockBypass)); | |
assert_param(IS_SDIO_CLOCK_POWER_SAVE(Init.ClockPowerSave)); | |
assert_param(IS_SDIO_BUS_WIDE(Init.BusWide)); | |
assert_param(IS_SDIO_HARDWARE_FLOW_CONTROL(Init.HardwareFlowControl)); | |
assert_param(IS_SDIO_CLKDIV(Init.ClockDiv)); | |
assert_param(IS_SDIO_CMD_INDEX(Command->CmdIndex)); | |
assert_param(IS_SDIO_RESPONSE(Command->Response)); | |
assert_param(IS_SDIO_WAIT(Command->WaitForInterrupt)); | |
assert_param(IS_SDIO_CPSM(Command->CPSM)); | |
assert_param(IS_SDIO_RESP(Response)); | |
assert_param(IS_SDIO_DATA_LENGTH(Data->DataLength)); | |
assert_param(IS_SDIO_BLOCK_SIZE(Data->DataBlockSize)); | |
assert_param(IS_SDIO_TRANSFER_DIR(Data->TransferDir)); | |
assert_param(IS_SDIO_TRANSFER_MODE(Data->TransferMode)); | |
assert_param(IS_SDIO_DPSM(Data->DPSM)); | |
assert_param(IS_SDIO_READWAIT_MODE(SDIO_ReadWaitMode)); | |
assert_param(IS_SPI_ALL_INSTANCE(SPIx)); | |
assert_param(IS_SPI_ALL_INSTANCE(SPIx)); | |
assert_param(IS_LL_SPI_TRANSFER_DIRECTION(SPI_InitStruct->TransferDirection)); | |
assert_param(IS_LL_SPI_MODE(SPI_InitStruct->Mode)); | |
assert_param(IS_LL_SPI_DATAWIDTH(SPI_InitStruct->DataWidth)); | |
assert_param(IS_LL_SPI_POLARITY(SPI_InitStruct->ClockPolarity)); | |
assert_param(IS_LL_SPI_PHASE(SPI_InitStruct->ClockPhase)); | |
assert_param(IS_LL_SPI_NSS(SPI_InitStruct->NSS)); | |
assert_param(IS_LL_SPI_BAUDRATE(SPI_InitStruct->BaudRate)); | |
assert_param(IS_LL_SPI_BITORDER(SPI_InitStruct->BitOrder)); | |
assert_param(IS_LL_SPI_CRCCALCULATION(SPI_InitStruct->CRCCalculation)); | |
assert_param(IS_LL_SPI_CRC_POLYNOMIAL(SPI_InitStruct->CRCPoly)); | |
assert_param(IS_I2S_ALL_INSTANCE(SPIx)); | |
assert_param(IS_LL_I2S_MODE(I2S_InitStruct->Mode)); | |
assert_param(IS_LL_I2S_STANDARD(I2S_InitStruct->Standard)); | |
assert_param(IS_LL_I2S_DATAFORMAT(I2S_InitStruct->DataFormat)); | |
assert_param(IS_LL_I2S_MCLK_OUTPUT(I2S_InitStruct->MCLKOutput)); | |
assert_param(IS_LL_I2S_AUDIO_FREQ(I2S_InitStruct->AudioFreq)); | |
assert_param(IS_LL_I2S_CPOL(I2S_InitStruct->ClockPolarity)); | |
assert_param(IS_I2S_ALL_INSTANCE(SPIx)); | |
assert_param(IS_LL_I2S_PRESCALER_LINEAR(PrescalerLinear)); | |
assert_param(IS_LL_I2S_PRESCALER_PARITY(PrescalerParity)); | |
assert_param(IS_I2S_EXT_ALL_INSTANCE(I2Sxext)); | |
assert_param(IS_LL_I2S_MODE(I2S_InitStruct->Mode)); | |
assert_param(IS_LL_I2S_STANDARD(I2S_InitStruct->Standard)); | |
assert_param(IS_LL_I2S_DATAFORMAT(I2S_InitStruct->DataFormat)); | |
assert_param(IS_LL_I2S_CPOL(I2S_InitStruct->ClockPolarity)); | |
assert_param(IS_TIM_INSTANCE(TIMx)); | |
assert_param(IS_TIM_INSTANCE(TIMx)); | |
assert_param(IS_LL_TIM_COUNTERMODE(TIM_InitStruct->CounterMode)); | |
assert_param(IS_LL_TIM_CLOCKDIVISION(TIM_InitStruct->ClockDivision)); | |
assert_param(IS_TIM_ENCODER_INTERFACE_INSTANCE(TIMx)); | |
assert_param(IS_LL_TIM_ENCODERMODE(TIM_EncoderInitStruct->EncoderMode)); | |
assert_param(IS_LL_TIM_IC_POLARITY_ENCODER(TIM_EncoderInitStruct->IC1Polarity)); | |
assert_param(IS_LL_TIM_ACTIVEINPUT(TIM_EncoderInitStruct->IC1ActiveInput)); | |
assert_param(IS_LL_TIM_ICPSC(TIM_EncoderInitStruct->IC1Prescaler)); | |
assert_param(IS_LL_TIM_IC_FILTER(TIM_EncoderInitStruct->IC1Filter)); | |
assert_param(IS_LL_TIM_IC_POLARITY_ENCODER(TIM_EncoderInitStruct->IC2Polarity)); | |
assert_param(IS_LL_TIM_ACTIVEINPUT(TIM_EncoderInitStruct->IC2ActiveInput)); | |
assert_param(IS_LL_TIM_ICPSC(TIM_EncoderInitStruct->IC2Prescaler)); | |
assert_param(IS_LL_TIM_IC_FILTER(TIM_EncoderInitStruct->IC2Filter)); | |
assert_param(IS_TIM_HALL_SENSOR_INTERFACE_INSTANCE(TIMx)); | |
assert_param(IS_LL_TIM_IC_POLARITY_ENCODER(TIM_HallSensorInitStruct->IC1Polarity)); | |
assert_param(IS_LL_TIM_ICPSC(TIM_HallSensorInitStruct->IC1Prescaler)); | |
assert_param(IS_LL_TIM_IC_FILTER(TIM_HallSensorInitStruct->IC1Filter)); | |
assert_param(IS_TIM_BREAK_INSTANCE(TIMx)); | |
assert_param(IS_LL_TIM_OSSR_STATE(TIM_BDTRInitStruct->OSSRState)); | |
assert_param(IS_LL_TIM_OSSI_STATE(TIM_BDTRInitStruct->OSSIState)); | |
assert_param(IS_LL_TIM_LOCK_LEVEL(TIM_BDTRInitStruct->LockLevel)); | |
assert_param(IS_LL_TIM_BREAK_STATE(TIM_BDTRInitStruct->BreakState)); | |
assert_param(IS_LL_TIM_BREAK_POLARITY(TIM_BDTRInitStruct->BreakPolarity)); | |
assert_param(IS_LL_TIM_AUTOMATIC_OUTPUT_STATE(TIM_BDTRInitStruct->AutomaticOutput)); | |
assert_param(IS_TIM_CC1_INSTANCE(TIMx)); | |
assert_param(IS_LL_TIM_OCMODE(TIM_OCInitStruct->OCMode)); | |
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCState)); | |
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCPolarity)); | |
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCIdleState)); | |
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCNState)); | |
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCNPolarity)); | |
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCNIdleState)); | |
assert_param(IS_TIM_CC2_INSTANCE(TIMx)); | |
assert_param(IS_LL_TIM_OCMODE(TIM_OCInitStruct->OCMode)); | |
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCState)); | |
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCPolarity)); | |
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCIdleState)); | |
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCNState)); | |
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCNPolarity)); | |
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCNIdleState)); | |
assert_param(IS_TIM_CC3_INSTANCE(TIMx)); | |
assert_param(IS_LL_TIM_OCMODE(TIM_OCInitStruct->OCMode)); | |
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCState)); | |
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCPolarity)); | |
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCIdleState)); | |
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCNState)); | |
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCNPolarity)); | |
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCNIdleState)); | |
assert_param(IS_TIM_CC4_INSTANCE(TIMx)); | |
assert_param(IS_LL_TIM_OCMODE(TIM_OCInitStruct->OCMode)); | |
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCState)); | |
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCPolarity)); | |
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCIdleState)); | |
assert_param(IS_TIM_CC1_INSTANCE(TIMx)); | |
assert_param(IS_LL_TIM_IC_POLARITY(TIM_ICInitStruct->ICPolarity)); | |
assert_param(IS_LL_TIM_ACTIVEINPUT(TIM_ICInitStruct->ICActiveInput)); | |
assert_param(IS_LL_TIM_ICPSC(TIM_ICInitStruct->ICPrescaler)); | |
assert_param(IS_LL_TIM_IC_FILTER(TIM_ICInitStruct->ICFilter)); | |
assert_param(IS_TIM_CC2_INSTANCE(TIMx)); | |
assert_param(IS_LL_TIM_IC_POLARITY(TIM_ICInitStruct->ICPolarity)); | |
assert_param(IS_LL_TIM_ACTIVEINPUT(TIM_ICInitStruct->ICActiveInput)); | |
assert_param(IS_LL_TIM_ICPSC(TIM_ICInitStruct->ICPrescaler)); | |
assert_param(IS_LL_TIM_IC_FILTER(TIM_ICInitStruct->ICFilter)); | |
assert_param(IS_TIM_CC3_INSTANCE(TIMx)); | |
assert_param(IS_LL_TIM_IC_POLARITY(TIM_ICInitStruct->ICPolarity)); | |
assert_param(IS_LL_TIM_ACTIVEINPUT(TIM_ICInitStruct->ICActiveInput)); | |
assert_param(IS_LL_TIM_ICPSC(TIM_ICInitStruct->ICPrescaler)); | |
assert_param(IS_LL_TIM_IC_FILTER(TIM_ICInitStruct->ICFilter)); | |
assert_param(IS_TIM_CC4_INSTANCE(TIMx)); | |
assert_param(IS_LL_TIM_IC_POLARITY(TIM_ICInitStruct->ICPolarity)); | |
assert_param(IS_LL_TIM_ACTIVEINPUT(TIM_ICInitStruct->ICActiveInput)); | |
assert_param(IS_LL_TIM_ICPSC(TIM_ICInitStruct->ICPrescaler)); | |
assert_param(IS_LL_TIM_IC_FILTER(TIM_ICInitStruct->ICFilter)); | |
assert_param(IS_UART_INSTANCE(USARTx)); | |
assert_param(IS_UART_INSTANCE(USARTx)); | |
assert_param(IS_LL_USART_BAUDRATE(USART_InitStruct->BaudRate)); | |
assert_param(IS_LL_USART_DATAWIDTH(USART_InitStruct->DataWidth)); | |
assert_param(IS_LL_USART_STOPBITS(USART_InitStruct->StopBits)); | |
assert_param(IS_LL_USART_PARITY(USART_InitStruct->Parity)); | |
assert_param(IS_LL_USART_DIRECTION(USART_InitStruct->TransferDirection)); | |
assert_param(IS_LL_USART_HWCONTROL(USART_InitStruct->HardwareFlowControl)); | |
assert_param(IS_LL_USART_OVERSAMPLING(USART_InitStruct->OverSampling)); | |
assert_param(IS_LL_USART_BRR_MIN(USARTx->BRR)); | |
assert_param(IS_UART_INSTANCE(USARTx)); | |
assert_param(IS_LL_USART_CLOCKOUTPUT(USART_ClockInitStruct->ClockOutput)); | |
assert_param(IS_USART_INSTANCE(USARTx)); | |
assert_param(IS_LL_USART_CLOCKPOLARITY(USART_ClockInitStruct->ClockPolarity)); | |
assert_param(IS_LL_USART_CLOCKPHASE(USART_ClockInitStruct->ClockPhase)); | |
assert_param(IS_LL_USART_LASTBITCLKOUTPUT(USART_ClockInitStruct->LastBitClockPulse)); | |
assert_param(IS_LL_UTILS_HSE_FREQUENCY(HSEFrequency)); | |
assert_param(IS_LL_UTILS_HSE_BYPASS(HSEBypass)); | |
assert_param(IS_LL_UTILS_PLLM_VALUE(UTILS_PLLInitStruct->PLLM)); | |
assert_param(IS_LL_UTILS_PLLN_VALUE(UTILS_PLLInitStruct->PLLN)); | |
assert_param(IS_LL_UTILS_PLLP_VALUE(UTILS_PLLInitStruct->PLLP)); | |
assert_param(IS_LL_UTILS_PLLVCO_INPUT(pllfreq)); | |
assert_param(IS_LL_UTILS_PLLVCO_OUTPUT(pllfreq)); | |
assert_param(IS_LL_UTILS_PLL_FREQUENCY(pllfreq)); | |
assert_param(IS_LL_UTILS_SYSCLK_DIV(UTILS_ClkInitStruct->AHBCLKDivider)); | |
assert_param(IS_LL_UTILS_APB1_DIV(UTILS_ClkInitStruct->APB1CLKDivider)); | |
assert_param(IS_LL_UTILS_APB2_DIV(UTILS_ClkInitStruct->APB2CLKDivider)); |