93 #if (defined(IC_PAL_OVER_FTM))
95 static ftm_state_t g_ftmState[NUMBER_OF_IC_PAL_INSTANCES];
108 uint32_t * instanceMapping,
114 for (i = 0U;i < NUMBER_OF_IC_PAL_INSTANCES;i++)
116 if (isAllocated[i] ==
false)
118 instanceMapping[i] = instance;
119 isAllocated[i] =
true;
134 const uint32_t * instanceMapping,
140 for (i = 0U;i < NUMBER_OF_IC_PAL_INSTANCES;i++)
142 if (instanceMapping[i] == instance)
144 isAllocated[i] =
false;
160 for (i = 0U;i < NUMBER_OF_IC_PAL_INSTANCES;i++)
171 #if (defined(IC_PAL_OVER_FTM))
178 static status_t IC_FtmInit(uint32_t instance,
187 icState = &g_icPalStatePtr[index];
189 uint8_t channel = 0U;
229 for (index = 0U; index < configPtr->
nNumChannels; index++)
290 icState->enableContinuousMode[channel] = channelConfig[index].
continuousModeEn;
291 icState->enableNotification[channel] =
true;
305 #if (defined(IC_PAL_OVER_EMIOS))
312 static status_t IC_EmiosInit(uint32_t instance,
318 const IRQn_Type emiosIrq[eMIOS_INSTANCE_COUNT][(eMIOS_UC_COUNT / 2U)] = eMIOS_IRQS;
322 icState = &g_icPalStatePtr[index];
324 emios_common_param_t commonParam;
325 uint8_t channel = 0U;
326 uint8_t optionMode = 0U;
327 emios_bus_select_t timeBase = EMIOS_BUS_SEL_A;
328 emios_mc_mode_param_t mcParam;
329 emios_input_capture_param_t icParam;
330 emios_gpio_mode_param_t gpioParam;
333 commonParam.allowDebugMode =
false;
334 commonParam.lowPowerMode =
false;
335 commonParam.clkDivVal = ((extension_emios_for_ic_t *)(configPtr->
extension))->clkDivVal;
336 commonParam.enableGlobalPrescaler = ((extension_emios_for_ic_t *)(configPtr->
extension))->enableGlobalPrescaler;
337 commonParam.enableGlobalTimeBase = ((extension_emios_for_ic_t *)(configPtr->
extension))->enableGlobalTimeBase;
340 EMIOS_DRV_InitGlobal((uint8_t)instance,
344 mcParam.mode = EMIOS_MODE_MCB_UP_COUNTER_INT_CLK;
345 mcParam.period = MAX_COUNTER_VALUE;
346 mcParam.filterInput = EMIOS_INPUT_FILTER_BYPASS;
347 mcParam.filterEn =
false;
348 mcParam.triggerMode = EMIOS_TRIGGER_EDGE_ANY;
351 for (index = 0U; index < configPtr->
nNumChannels; index++)
353 mcParam.internalPrescaler = (emios_clock_internal_ps_t)((channel_extension_emios_for_ic_t *)(configPtr->
inputChConfig[index].
channelExtension))->prescaler;
354 mcParam.internalPrescalerEn =
true;
361 timeBase = EMIOS_BUS_SEL_A;
366 timeBase = EMIOS_BUS_SEL_BCDE;
371 timeBase = EMIOS_BUS_SEL_BCDE;
376 timeBase = EMIOS_BUS_SEL_BCDE;
381 timeBase = EMIOS_BUS_SEL_BCDE;
386 timeBase = EMIOS_BUS_SEL_F;
388 case IC_BUS_SEL_INTERNAL:
391 timeBase = EMIOS_BUS_SEL_INTERNAL;
399 status = EMIOS_DRV_MC_InitCounterMode((uint8_t)instance,
404 icParam.mode = EMIOS_MODE_IC;
405 icParam.timebase = timeBase;
411 icParam.inputCaptureMode = EMIOS_CAPTURE_TRIGGER_EDGE_RISING;
415 icParam.inputCaptureMode = EMIOS_CAPTURE_TRIGGER_EDGE_FALLING;
420 gpioParam.mode = EMIOS_MODE_GPIO_INPUT;
421 gpioParam.filterEn =
false;
422 gpioParam.filterInput = EMIOS_INPUT_FILTER_BYPASS;
423 gpioParam.triggerMode = EMIOS_TRIGGER_EDGE_ANY;
426 EMIOS_DRV_InitGpioMode((uint8_t)instance,
433 icParam.inputCaptureMode = (emios_input_capture_mode_t)optionMode;
439 status = EMIOS_DRV_IC_InitInputCaptureMode((uint8_t)instance,
444 EMIOS_DRV_ChannelEnableInterruptRequest((uint8_t)instance, channel);
449 icState->channelConfigArray[index] = channel;
451 icState->timeBaseSelection[channel] = icParam.timebase;
452 icState->filterEn[channel] = icParam.filterEn;
453 icState->filterInput[channel] = icParam.filterInput;
454 icState->enableNotification[channel] =
true;
460 EMIOS_DRV_EnableGlobalEmios((uint8_t)instance);
466 #if (defined(IC_PAL_OVER_ETIMER))
473 static status_t IC_EtimerInit(uint32_t instance,
479 uint16_t channel = 0U;
480 uint16_t maskChannel = 0U;
481 etimer_cptmode_t capCtr[ETIMER_NUM_COMPARE_REGISTERS];
483 static const IRQn_Type etimerIrqId[ETIMER_INSTANCE_COUNT][ETIMER_CH_MAX_IRQS] = ETIMER_IRQS;
487 icState = &g_icPalStatePtr[index];
489 etimer_user_channel_config_t userChannelConfig;
492 ETIMER_DRV_Init((uint16_t)instance);
494 userChannelConfig.coreSettings = ETIMER_COUNTER_NORMAL;
495 userChannelConfig.outputPin.enable =
false;
496 userChannelConfig.outputPin.polarity = ETIMER_POLARITY_POSITIVE;
497 userChannelConfig.countDirection = ETIMER_COUNT_UP;
498 userChannelConfig.compareOutputControl = ETIMER_OUTMODE_SOFTWARE;
499 userChannelConfig.compareMode = ETIMER_CMPMODE_COMP1_UP_COMP2_UP;
500 userChannelConfig.primaryInput.polarity = ETIMER_POLARITY_POSITIVE;
501 userChannelConfig.secondaryInput.polarity = ETIMER_POLARITY_POSITIVE;
503 for (index = 0U; index < ETIMER_NUM_COMPARE_REGISTERS; index++)
505 userChannelConfig.compareValues[index] = 0U;
506 userChannelConfig.compareLoading[index] = ETIMER_CLC_NEVER;
507 capCtr[index] = ETIMER_CPTMODE_DISABLED;
511 for (index = 0U; index < configPtr->
nNumChannels; index++)
514 maskChannel |= (uint16_t)(1U << channel);
518 userChannelConfig.timerMode = ETIMER_MODE_INPUT_CAPTURE;
522 userChannelConfig.timerMode = ETIMER_MODE_INPUT_CAPTURE_ONESHOT;
531 userChannelConfig.primaryInput.source = (etimer_input_source_t)(((channel_extension_etimer_for_ic_t *)configPtr->
inputChConfig[index].
channelExtension)->prescaler);;
532 userChannelConfig.secondaryInput.source = (etimer_input_source_t)channel;
533 userChannelConfig.captureWords = 1U;
534 userChannelConfig.interruptEnableMask = ETIMER_CH_IRQ_SOURCE_ICF1IE;
539 capCtr[0] = ETIMER_CPTMODE_RISING;
543 capCtr[0] = ETIMER_CPTMODE_FALLING;
547 capCtr[0] = ETIMER_CPTMODE_BOTH;
551 capCtr[0] = ETIMER_CPTMODE_RISING;
552 userChannelConfig.captureWords = 2U;
556 capCtr[0] = ETIMER_CPTMODE_FALLING;
557 userChannelConfig.captureWords = 2U;
561 capCtr[0] = ETIMER_CPTMODE_RISING;
562 capCtr[1] = ETIMER_CPTMODE_FALLING;
563 userChannelConfig.interruptEnableMask = ETIMER_CH_IRQ_SOURCE_ICF2IE;
567 capCtr[0] = ETIMER_CPTMODE_FALLING;
568 capCtr[1] = ETIMER_CPTMODE_RISING;
569 userChannelConfig.interruptEnableMask = ETIMER_CH_IRQ_SOURCE_ICF2IE;
576 for (i = 0U; i < ETIMER_NUM_COMPARE_REGISTERS; i++)
578 userChannelConfig.captureControl[i] = capCtr[i];
582 ETIMER_DRV_InitChannel((uint16_t)instance, channel, &userChannelConfig);
584 ETIMER_DRV_StartCapture((uint16_t)instance, channel);
589 icState->channelConfigArray[index] = channel;
591 icState->enableNotification[channel] =
true;
597 ETIMER_DRV_StartTimerChannels((uint16_t)instance, maskChannel);
608 static void IC_Etimer_SetChannelMode(uint32_t instance,
615 static ETIMER_Type *
const s_etimerBase[ETIMER_INSTANCE_COUNT] = ETIMER_BASE_PTRS;
617 base = s_etimerBase[instance];
618 uint8_t captureWords = 1U;
619 etimer_cptmode_t captureControl[2] = { ETIMER_CPTMODE_DISABLED, ETIMER_CPTMODE_DISABLED };
620 base->CH[channel].INTDMA &= ~(ETIMER_CH_IRQ_FLAGS_ICF1 | ETIMER_CH_IRQ_FLAGS_ICF2);
625 captureControl[0] = ETIMER_CPTMODE_RISING;
626 base->CH[channel].INTDMA |= ETIMER_CH_IRQ_FLAGS_ICF1;
629 captureControl[0] = ETIMER_CPTMODE_FALLING;
630 base->CH[channel].INTDMA |= ETIMER_CH_IRQ_FLAGS_ICF1;
633 captureControl[0] = ETIMER_CPTMODE_BOTH;
634 base->CH[channel].INTDMA |= ETIMER_CH_IRQ_FLAGS_ICF1;
637 captureControl[0] = ETIMER_CPTMODE_RISING;
638 base->CH[channel].INTDMA |= ETIMER_CH_IRQ_FLAGS_ICF1;
642 captureControl[0] = ETIMER_CPTMODE_FALLING;
643 base->CH[channel].INTDMA |= ETIMER_CH_IRQ_FLAGS_ICF1;
647 captureControl[0] = ETIMER_CPTMODE_RISING;
648 captureControl[1] = ETIMER_CPTMODE_FALLING;
649 base->CH[channel].INTDMA |= ETIMER_CH_IRQ_FLAGS_ICF2;
652 captureControl[0] = ETIMER_CPTMODE_FALLING;
653 captureControl[1] = ETIMER_CPTMODE_RISING;
654 base->CH[channel].INTDMA |= ETIMER_CH_IRQ_FLAGS_ICF2;
662 base->CH[channel].CCCTRL &= ((~ETIMER_CCCTRL_CFWM_MASK) & (~ETIMER_CCCTRL_CPT1MODE_MASK) & (~ETIMER_CCCTRL_CPT2MODE_MASK));
663 base->CH[channel].CCCTRL |= ETIMER_CCCTRL_CFWM(captureWords) | ETIMER_CCCTRL_CPT1MODE(captureControl[0]) | ETIMER_CCCTRL_CPT2MODE(captureControl[1]);
689 icState = &g_icPalStatePtr[index];
694 for (index = 0U; index < IC_PAL_NUM_OF_CHANNEL_MAX; index++)
696 icState->channelConfigArray[index] = 0U;
698 icState->enableNotification[index] =
false;
699 icState->channelCallbackParams[index] = NULL;
700 icState->channelCallbacks[index] = NULL;
701 #if (defined(IC_PAL_OVER_FTM))
702 icState->enableContinuousMode[index] =
false;
704 #if (defined(IC_PAL_OVER_ETIMER))
705 icState->measurementResults[index] = 0U;
709 #if (defined(IC_PAL_OVER_FTM))
711 status = IC_FtmInit(instance->
instIdx, configPtr);
714 #if (defined(IC_PAL_OVER_EMIOS))
716 status = IC_EmiosInit(instance->
instIdx, configPtr);
719 #if (defined(IC_PAL_OVER_ETIMER))
721 status = IC_EtimerInit(instance->
instIdx, configPtr);
745 icState = &g_icPalStatePtr[index];
747 #if (defined(IC_PAL_OVER_FTM))
754 #if (defined(IC_PAL_OVER_EMIOS))
758 for (index = 0U; index < icState->nNumChannels; index++)
760 channel = icState->channelConfigArray[index];
762 EMIOS_DRV_DeInitChannel((uint8_t)instance->
instIdx,
767 EMIOS_DRV_DisableGlobalEmios((uint8_t)instance->
instIdx);
770 #if (defined(IC_PAL_OVER_ETIMER))
773 ETIMER_DRV_Deinit((uint16_t)instance->
instIdx);
777 icState->nNumChannels = 0U;
778 for (index = 0U; index < IC_PAL_NUM_OF_CHANNEL_MAX; index++)
780 icState->channelConfigArray[index] = 0U;
782 icState->enableNotification[index] =
false;
783 #if (defined(IC_PAL_OVER_FTM))
784 icState->enableContinuousMode[index] =
false;
787 #if (defined(IC_PAL_OVER_ETIMER))
788 icState->measurementResults[index] = 0U;
810 DEV_ASSERT(channel < IC_PAL_NUM_OF_CHANNEL_MAX);
812 #if (defined(IC_PAL_OVER_FTM))
819 icState = &g_icPalStatePtr[index];
824 icState->icChannelType[channel]);
828 #if (defined(IC_PAL_OVER_EMIOS))
830 EMIOS_DRV_ChannelEnableClk((uint8_t)instance->
instIdx,
834 #if (defined(IC_PAL_OVER_ETIMER))
835 ETIMER_DRV_StartCapture((uint16_t)instance->
instIdx,
837 ETIMER_DRV_StartTimerChannels((uint16_t)instance->
instIdx,
838 (uint16_t)(1U << channel));
854 DEV_ASSERT(channel < IC_PAL_NUM_OF_CHANNEL_MAX);
856 #if (defined(IC_PAL_OVER_FTM))
863 #if (defined(IC_PAL_OVER_EMIOS))
865 EMIOS_DRV_ChannelDisableClk((uint8_t)instance->
instIdx,
869 #if (defined(IC_PAL_OVER_ETIMER))
870 ETIMER_DRV_StopCapture((uint16_t)instance->
instIdx,
872 ETIMER_DRV_StopTimerChannels((uint16_t)instance->
instIdx,
873 (uint16_t)(1U << channel));
892 DEV_ASSERT(channel < IC_PAL_NUM_OF_CHANNEL_MAX);
899 icState = &g_icPalStatePtr[index];
901 #if (defined(IC_PAL_OVER_FTM))
903 index = (uint8_t)channelMode;
906 if (
true == icState->enableContinuousMode[channel])
908 contModeEnable =
true;
912 contModeEnable =
false;
922 #if (defined(IC_PAL_OVER_EMIOS))
923 emios_input_capture_param_t icParam;
924 emios_gpio_mode_param_t gpioParam;
925 uint8_t optionMode = 0U;
930 gpioParam.mode = EMIOS_MODE_GPIO_INPUT;
931 gpioParam.filterEn =
false;
932 gpioParam.filterInput = EMIOS_INPUT_FILTER_BYPASS;
933 gpioParam.triggerMode = EMIOS_TRIGGER_EDGE_ANY;
936 EMIOS_DRV_InitGpioMode((uint8_t)instance->
instIdx,
942 icParam.mode = EMIOS_MODE_IC;
943 icParam.timebase = icState->timeBaseSelection[channel];
944 icParam.filterInput = icState->filterInput[channel];
945 icParam.filterEn = icState->filterEn[channel];
949 icParam.inputCaptureMode = EMIOS_CAPTURE_TRIGGER_EDGE_RISING;
953 icParam.inputCaptureMode = EMIOS_CAPTURE_TRIGGER_EDGE_FALLING;
957 optionMode = (uint8_t)(channelMode) - 1U;
958 icParam.inputCaptureMode = (emios_input_capture_mode_t)optionMode;
962 status = EMIOS_DRV_IC_InitInputCaptureMode((uint8_t)instance->
instIdx,
968 #if (defined(IC_PAL_OVER_ETIMER))
969 IC_Etimer_SetChannelMode(instance->
instIdx,
975 icState->icChannelType[channel] = channelMode;
992 DEV_ASSERT(channel < IC_PAL_NUM_OF_CHANNEL_MAX);
995 #if (defined(IC_PAL_OVER_FTM))
1001 #if (defined(IC_PAL_OVER_EMIOS))
1003 uint32_t retValue = 0U;
1006 status = EMIOS_DRV_IC_GetLastMeasurement((uint8_t)instance->
instIdx,
1011 value = (uint16_t)retValue;
1014 #if (defined(IC_PAL_OVER_ETIMER))
1020 icState = &g_icPalStatePtr[index];
1022 value = icState->measurementResults[channel];
1040 DEV_ASSERT(channel < IC_PAL_NUM_OF_CHANNEL_MAX);
1046 icState = &g_icPalStatePtr[index];
1049 icState->enableNotification[channel] =
true;
1051 #if (defined(IC_PAL_OVER_FTM))
1069 DEV_ASSERT(channel < IC_PAL_NUM_OF_CHANNEL_MAX);
1075 icState = &g_icPalStatePtr[index];
1078 icState->enableNotification[channel] =
false;
1080 #if (defined(IC_PAL_OVER_FTM))
1096 DEV_ASSERT(channel < IC_PAL_NUM_OF_CHANNEL_MAX);
1098 #if (defined (IC_PAL_OVER_ETIMER))
1106 icState = &g_icPalStatePtr[index];
1108 #if (defined (IC_PAL_OVER_ETIMER))
1109 uint16_t value = 0U;
1110 uint16_t captureRegister = 0U;
1111 uint16_t captureResultBuffer1[2] = {0U, 0U};
1112 uint16_t captureResultBuffer2[2] = {0U, 0U};
1113 uint8_t captureWordsToRead = 1U;
1114 uint16_t returnCode = 0U;
1118 captureWordsToRead = 2U;
1121 returnCode = ETIMER_DRV_GetCaptureValue((uint16_t)instance,
1124 captureResultBuffer1,
1125 captureWordsToRead);
1127 if (returnCode == 0U)
1131 else if (returnCode == 1U)
1133 value = captureResultBuffer1[0];
1137 if (captureResultBuffer1[1] > captureResultBuffer1[0])
1139 value = captureResultBuffer1[1] - captureResultBuffer1[0];
1143 value = captureResultBuffer1[1] + (ETIMER_CH_MAX_TIMER_COUNT - captureResultBuffer1[0]);
1149 captureRegister = 1U;
1150 returnCode = ETIMER_DRV_GetCaptureValue((uint16_t)instance,
1153 captureResultBuffer2,
1154 captureWordsToRead);
1155 if (captureResultBuffer2[0] > captureResultBuffer1[0])
1157 value = captureResultBuffer2[0] - captureResultBuffer1[0];
1161 value = captureResultBuffer2[0] + (ETIMER_CH_MAX_TIMER_COUNT - captureResultBuffer1[0]);
1173 icState->measurementResults[channel] = value;
1176 if ((icState->channelCallbacks[channel] != NULL) && (icState->enableNotification[channel] ==
true))
1182 #if (defined (IC_PAL_OVER_EMIOS))
1184 EMIOS_DRV_ClrFlagState(instance, channel);
1187 #if (defined (IC_PAL_OVER_ETIMER))
1189 ETIMER_DRV_ClearInterruptStatus((uint16_t)instance,
1190 (ETIMER_CH_IRQ_FLAGS_ICF1 | ETIMER_CH_IRQ_FLAGS_ICF2),
ftm_reg_update_t initCounterSync
ftm_pwm_sync_t syncMethod
Structure storing PAL instance information.
FlexTimer state structure of the driver.
void IC_IrqHandler(uint32_t instance, uint8_t channel)
ftm_state_t * ftmStatePtr[(2u)]
Pointer to runtime state structure.
static ic_pal_state_t g_icPalStatePtr[NUMBER_OF_IC_PAL_INSTANCES]
status_t IC_Init(const ic_instance_t *const instance, const ic_config_t *configPtr)
Initializes the input capture mode.
#define FEATURE_FTM_CHANNEL_COUNT
Configuration structure that the user needs to set.
void IC_DisableNotification(const ic_instance_t *const instance, uint8_t channel)
Disable channel notifications.
static uint32_t icStateInstanceMapping[NUMBER_OF_IC_PAL_INSTANCES]
status_t FTM_IC_DRV_SetChannelMode(uint32_t instance, uint8_t channel, ftm_ic_op_mode_t inputMode, bool enableContinuousCapture)
Set mode operation for channel in the input captue mode.
FlexTimer Registers sync parameters Please don't use software and hardware trigger simultaneously Imp...
void IC_EnableNotification(const ic_instance_t *const instance, uint8_t channel)
Enable channel notifications.
status_t FTM_DRV_SetOutputlevel(uint32_t instance, uint8_t channel, uint8_t level)
This function will set the channel edge or level on the selection of the channel mode.
ftm_ic_op_mode_t
The measurement type for input capture mode Implements : ftm_ic_op_mode_t_Class.
bool enableNotification[(8U)]
static void icFreeState(bool *isAllocated, const uint32_t *instanceMapping, uint32_t instance)
void IC_StopChannel(const ic_instance_t *const instance, uint8_t channel)
Stop the counter.
status_t IC_Deinit(const ic_instance_t *const instance)
De-initialize a input capture instance.
Defines the configuration structures are used in the input capture mode.
status_t IC_SetChannelMode(const ic_instance_t *const instance, uint8_t channel, ic_option_mode_t channelMode)
Get the measured value.
status_t FTM_DRV_InitInputCapture(uint32_t instance, const ftm_input_param_t *param)
Configures Channel Input Capture for either getting time-stamps on edge detection or on signal measur...
ftm_pwm_sync_mode_t syncPoint
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
IRQn_Type
Defines the Interrupt Numbers definitions.
static bool icStateIsAllocated[NUMBER_OF_IC_PAL_INSTANCES]
static uint8_t FindIcState(uint32_t instance)
static uint8_t icAllocateState(bool *isAllocated, uint32_t *instanceMapping, uint32_t instance)
The internal context structure.
bool enableInitializationTrigger
ic_option_mode_t
The measurement type for input capture mode Implements : ic_option_mode_t_Class.
const ic_input_ch_param_t * inputChConfig
ftm_reg_update_t inverterSync
ftm_config_mode_t ftmMode
status_t FTM_DRV_Deinit(uint32_t instance)
Shuts down the FTM driver.
void INT_SYS_EnableIRQ(IRQn_Type irqNumber)
Enables an interrupt for a given IRQ number.
ftm_reg_update_t maskRegSync
status_t FTM_DRV_Init(uint32_t instance, const ftm_user_config_t *info, ftm_state_t *state)
Initializes the FTM driver.
void IC_StartChannel(const ic_instance_t *const instance, uint8_t channel)
Start the counter.
uint16_t IC_GetMeasurement(const ic_instance_t *const instance, uint8_t channel)
Get the measured value.
ftm_clock_source_t ftmClockSource
uint16_t FTM_DRV_GetInputCaptureMeasurement(uint32_t instance, uint8_t channel)
This function is used to calculate the measurement and/or time stamps values which are read from the ...
ftm_reg_update_t outRegSync
ftm_clock_ps_t ftmPrescaler