85 #include "oc_pal_cfg.h"
88 #if (defined(OC_PAL_OVER_ETIMER))
90 #include "etimer_hw_access.h"
107 uint8_t nNumChannels;
108 uint8_t channelConfigArray[OC_PAL_NUM_OF_CHANNEL_MAX];
110 void * channelCallbackParams[OC_PAL_NUM_OF_CHANNEL_MAX];
112 bool enableNotification[OC_PAL_NUM_OF_CHANNEL_MAX];
128 #if (defined(OC_PAL_OVER_FTM))
130 static ftm_state_t g_ocFtmState[NUMBER_OF_OC_PAL_INSTANCES];
144 uint32_t * instanceMapping,
146 uint8_t numberOfInstances)
151 for (i = 0;i < numberOfInstances;i++)
153 if (isAllocated[i] ==
false)
155 instanceMapping[i] = instance;
156 isAllocated[i] =
true;
171 uint32_t * instanceMapping,
173 uint8_t numberOfInstances)
178 for (i = 0;i < numberOfInstances;i++)
180 if (instanceMapping[i] == instance)
182 isAllocated[i] =
false;
198 for (i = 0U;i < NUMBER_OF_OC_PAL_INSTANCES;i++)
209 #if (defined(OC_PAL_OVER_FTM))
215 static status_t OC_InitFtm(uint32_t instance,
220 uint8_t indexInstance = 0U;
222 uint8_t channel = 0U;
226 ocState = &g_ocPalStatePtr[indexInstance];
231 for (index = 0U; index < OC_PAL_NUM_OF_CHANNEL_MAX; index++)
233 ocState->channelConfigArray[index] = 0U;
235 ocState->enableNotification[index] =
false;
236 ocState->channelCallbackParams[index] = NULL;
237 ocState->channelCallbacks[index] = NULL;
242 ftm_state_t * ftmState = &g_ocFtmState[indexInstance];
280 for (index = 0U; index < configPtr->
nNumChannels; index++)
293 ocState->enableNotification[channel] =
true;
306 for (index = 0U; index < configPtr->
nNumChannels; index++)
314 s_ocOverFtmIsr[instance][channel], (
isr_t*)0);
323 #if (defined(OC_PAL_OVER_EMIOS))
329 static status_t OC_InitEMIOS(uint32_t instance,
334 uint8_t indexInstance = 0U;
336 uint8_t channel = 0U;
338 emios_common_param_t commonParam;
339 emios_mc_mode_param_t mcParam;
340 emios_oc_param_t ocParam;
341 emios_bus_select_t timeBaseSelection = EMIOS_BUS_SEL_BCDE;
342 const IRQn_Type emiosIrq[eMIOS_INSTANCE_COUNT][(eMIOS_UC_COUNT / 2U)] = eMIOS_IRQS;
346 ocState = &g_ocPalStatePtr[indexInstance];
351 for (index = 0U; index < OC_PAL_NUM_OF_CHANNEL_MAX; index++)
353 ocState->channelConfigArray[index] = 0U;
355 ocState->enableNotification[index] =
false;
356 ocState->channelCallbackParams[index] = NULL;
357 ocState->channelCallbacks[index] = NULL;
361 commonParam.allowDebugMode =
false;
362 commonParam.lowPowerMode =
false;
363 commonParam.clkDivVal = ((extension_emios_for_oc_t *)(configPtr->
extension))->clkDivVal;
364 commonParam.enableGlobalPrescaler = ((extension_emios_for_oc_t *)(configPtr->
extension))->enableGlobalPrescaler;
365 commonParam.enableGlobalTimeBase = ((extension_emios_for_oc_t *)(configPtr->
extension))->enableGlobalTimeBase;
368 EMIOS_DRV_InitGlobal((uint8_t)instance,
372 mcParam.mode = EMIOS_MODE_MCB_UP_COUNTER_INT_CLK;
373 mcParam.filterInput = EMIOS_INPUT_FILTER_BYPASS;
374 mcParam.filterEn =
false;
375 mcParam.triggerMode = EMIOS_TRIGGER_EDGE_ANY;
377 for (index = 0U; index < configPtr->
nNumChannels; index++)
381 mcParam.internalPrescalerEn =
true;
388 timeBaseSelection = EMIOS_BUS_SEL_A;
393 timeBaseSelection = EMIOS_BUS_SEL_BCDE;
398 timeBaseSelection = EMIOS_BUS_SEL_BCDE;
403 timeBaseSelection = EMIOS_BUS_SEL_BCDE;
408 timeBaseSelection = EMIOS_BUS_SEL_BCDE;
413 timeBaseSelection = EMIOS_BUS_SEL_F;
415 case OC_BUS_SEL_INTERNAL:
418 timeBaseSelection = EMIOS_BUS_SEL_INTERNAL;
426 status = EMIOS_DRV_MC_InitCounterMode((uint8_t)instance,
433 ocParam.mode = EMIOS_MODE_SAOC;
434 ocParam.timebase = timeBaseSelection;
436 ocParam.matchTrailingEdgeValue = 0U;
441 ocParam.outputActiveMode = EMIOS_OUTPUT_ACTIVE_LOW;
445 ocParam.outputActiveMode = EMIOS_OUTPUT_ACTIVE_HIGH;
449 ocParam.outputActiveMode = EMIOS_OUTPUT_ACTIVE_TOGGLE;
457 status = EMIOS_DRV_OC_InitOutputCompareMode((uint8_t)instance,
462 EMIOS_DRV_ChannelEnableInterruptRequest((uint8_t)instance, channel);
466 ocState->channelConfigArray[index] = channel;
468 ocState->enableNotification[channel] =
true;
474 EMIOS_DRV_EnableGlobalEmios((uint8_t)instance);
480 #if (defined(OC_PAL_OVER_ETIMER))
487 static status_t OC_EtimerInit(uint32_t etimerInstance,
492 uint16_t channel = 0U;
493 uint16_t maskChannel = 0U;
498 ocState = &g_ocPalStatePtr[index];
503 for (index = 0U; index < OC_PAL_NUM_OF_CHANNEL_MAX; index++)
505 ocState->channelConfigArray[index] = 0U;
507 ocState->enableNotification[index] =
false;
508 ocState->channelCallbackParams[index] = NULL;
509 ocState->channelCallbacks[index] = NULL;
513 ETIMER_DRV_Init(etimerInstance);
516 etimer_user_channel_config_t userChannelConfig = {
517 .timerMode = ETIMER_MODE_OUTPUT_COMPARE,
518 .coreSettings = ETIMER_COUNTER_NORMAL,
521 .samples = ETIMER_FILT_CNT_3,
526 .source = ETIMER_IN_SRC_CLK_DIV_128,
527 .polarity = ETIMER_POLARITY_POSITIVE,
531 .source = ETIMER_IN_SRC_CNT0_IN,
532 .polarity = ETIMER_POLARITY_POSITIVE,
537 .polarity = ETIMER_POLARITY_POSITIVE,
539 .countDirection = ETIMER_COUNT_UP,
547 ETIMER_CLC_FROM_CMPLD1_WHEN_COMP1,
550 .compareOutputControl = ETIMER_OUTMODE_SOFTWARE,
551 .compareMode = ETIMER_CMPMODE_COMP1_UP_COMP2_DOWN,
554 ETIMER_CPTMODE_DISABLED,
555 ETIMER_CPTMODE_DISABLED,
558 .interruptEnableMask = (ETIMER_CH_IRQ_SOURCE_TCF1IE|0U),
562 for (index = 0U; index < configPtr->
nNumChannels; index++)
565 maskChannel |= (uint16_t)(1U << channel);
568 userChannelConfig.primaryInput.source = ((channel_extension_etimer_for_oc_t *)configPtr->
outputChConfig[index].
channelExtension)->primaryInput.source;
569 userChannelConfig.primaryInput.polarity = ((channel_extension_etimer_for_oc_t *)configPtr->
outputChConfig[index].
channelExtension)->primaryInput.polarity;
572 userChannelConfig.outputPin.polarity = ((channel_extension_etimer_for_oc_t *)configPtr->
outputChConfig[index].
channelExtension)->outputPin.polarity;
581 userChannelConfig.compareOutputControl = ETIMER_OUTMODE_COMPARE_CLEAR;
582 ETIMER_DRV_ReloadOnCompare(etimerInstance, channel, 0,
false);
586 userChannelConfig.compareOutputControl = ETIMER_OUTMODE_COMPARE_SET;
587 ETIMER_DRV_ReloadOnCompare(etimerInstance, channel, 0,
false);
591 userChannelConfig.compareOutputControl = ETIMER_OUTMODE_COMPARE_TOGGLE;
592 ETIMER_DRV_ReloadOnCompare(etimerInstance, channel, 0,
true);
597 userChannelConfig.compareOutputControl = ETIMER_OUTMODE_SOFTWARE;
598 maskChannel &= ~((uint16_t)(1U << channel));
602 ETIMER_DRV_InitChannel((uint16_t)etimerInstance, channel, &userChannelConfig);
606 ETIMER_DRV_ReloadOnCompare((uint16_t)etimerInstance, channel, 0,
true);
610 IRQn_Type etimer_ch_irq_id = ETIMER_DRV_GetInterruptNumber((uint16_t)etimerInstance,(etimer_irq_vector_t)channel);
614 ocState->channelConfigArray[index] = channel;
616 ocState->enableNotification[channel] =
true;
622 ETIMER_DRV_StartTimerChannels((uint16_t)etimerInstance, maskChannel);
633 static status_t OC_ETIMER_SetOutputMode(uint32_t instance,
640 ETIMER_DRV_SetOutputFunction(instance, channel, ETIMER_OUTMODE_COMPARE_TOGGLE);
641 ETIMER_DRV_OutputPinEnable(instance, channel);
644 ETIMER_DRV_SetOutputFunction(instance, channel, ETIMER_OUTMODE_COMPARE_CLEAR);
645 ETIMER_DRV_OutputPinEnable(instance, channel);
648 ETIMER_DRV_SetOutputFunction(instance, channel, ETIMER_OUTMODE_COMPARE_SET);
649 ETIMER_DRV_OutputPinEnable(instance, channel);
653 ETIMER_DRV_OutputPinDisable(instance, channel);
666 static status_t OC_ETIMER_ForceOutput(uint32_t instance,
671 ETIMER_DRV_ForceOutputLogicLevel((uint16_t) instance, (uint16_t) channel,outputValue);
697 #if (defined(OC_PAL_OVER_FTM))
702 status = OC_InitFtm(instance->
instIdx, configPtr);
707 #if (defined(OC_PAL_OVER_EMIOS))
708 if(instance->
instType == OC_INST_TYPE_EMIOS)
712 status = OC_InitEMIOS(instance->
instIdx, configPtr);
717 #if (defined(OC_PAL_OVER_ETIMER))
718 if(instance->
instType == OC_INST_TYPE_ETIMER)
721 status = OC_EtimerInit(instance->
instIdx, configPtr);
752 ocState = &g_ocPalStatePtr[index];
754 #if (defined(OC_PAL_OVER_FTM))
763 #if (defined(OC_PAL_OVER_EMIOS))
765 if(instance-> instType == OC_INST_TYPE_EMIOS)
767 for (index = 0U; index < ocState->nNumChannels; index++)
769 channel = ocState->channelConfigArray[index];
771 EMIOS_DRV_DeInitChannel((uint8_t)instance->
instIdx, channel);
778 #if (defined(OC_PAL_OVER_ETIMER))
779 if(instance->
instType == OC_INST_TYPE_ETIMER)
782 ETIMER_DRV_Deinit((uint16_t)instance->
instIdx);
793 ocState->nNumChannels = 0U;
794 for (index = 0U; index < OC_PAL_NUM_OF_CHANNEL_MAX; index++)
796 ocState->channelConfigArray[index] = 0U;
798 ocState->enableNotification[index] =
false;
818 const uint8_t channel)
823 DEV_ASSERT(channel < OC_PAL_NUM_OF_CHANNEL_MAX);
825 #if (defined(OC_PAL_OVER_FTM))
831 ocState = &g_ocPalStatePtr[index];
837 (uint8_t)channelMode);
843 #if (defined(OC_PAL_OVER_EMIOS))
844 if(instance->
instType == OC_INST_TYPE_EMIOS)
847 EMIOS_DRV_ChannelEnableClk((uint8_t)instance->
instIdx, channel);
852 #if (defined(OC_PAL_OVER_ETIMER))
853 if(instance->
instType == OC_INST_TYPE_ETIMER)
855 ETIMER_DRV_StartTimerChannels((uint16_t)(instance->
instIdx),
856 (uint16_t)(1U << channel));
875 const uint8_t channel)
880 DEV_ASSERT(channel < OC_PAL_NUM_OF_CHANNEL_MAX);
882 #if (defined(OC_PAL_OVER_FTM))
892 #if (defined(OC_PAL_OVER_EMIOS))
893 if(instance->
instType == OC_INST_TYPE_EMIOS)
896 EMIOS_DRV_ChannelDisableClk((uint8_t)instance->
instIdx, channel);
901 #if (defined(OC_PAL_OVER_ETIMER))
902 if(instance->
instType == OC_INST_TYPE_ETIMER)
904 ETIMER_DRV_StopTimerChannels((uint16_t)(instance->
instIdx),
905 (uint16_t)(1U << channel));
926 const uint8_t channel,
bool outputValue)
930 DEV_ASSERT(channel < OC_PAL_NUM_OF_CHANNEL_MAX);
933 #if (defined(OC_PAL_OVER_FTM))
936 uint8_t channelMask = (uint8_t)(1U << channel);
945 #if (defined(OC_PAL_OVER_EMIOS))
946 if(instance->
instType == OC_INST_TYPE_EMIOS)
949 EMIOS_DRV_SetOutputLevel((uint8_t)instance->
instIdx, channel,
false, outputValue);
951 EMIOS_DRV_OC_ForceSingleActOutputCmpMatch((uint8_t)instance->
instIdx, channel);
957 #if (defined(OC_PAL_OVER_ETIMER))
958 if(instance->
instType == OC_INST_TYPE_ETIMER)
961 status = OC_ETIMER_ForceOutput(instance->
instIdx,
983 const uint8_t channel,
988 DEV_ASSERT(channel < OC_PAL_NUM_OF_CHANNEL_MAX);
995 ocState = &g_ocPalStatePtr[index];
997 #if (defined(OC_PAL_OVER_FTM))
1003 (uint8_t)channelMode);
1008 #if (defined(OC_PAL_OVER_EMIOS))
1009 if(instance->
instType == OC_INST_TYPE_EMIOS)
1012 EMIOS_DRV_SetOutputLevel((uint8_t)instance->
instIdx, channel,
1013 ((((uint8_t)channelMode & 0x02U) == 0U) ?
true :
false),
1014 ((((uint8_t)channelMode & 0x01U) == 0U) ?
false :
true));
1020 #if (defined(OC_PAL_OVER_ETIMER))
1021 if(instance->
instType == OC_INST_TYPE_ETIMER)
1023 status = OC_ETIMER_SetOutputMode(instance->
instIdx,
1034 ocState->ocChannelMode[channel] = channelMode;
1048 const uint8_t channel,
1049 uint32_t nextCompareMatchValue,
1054 DEV_ASSERT(channel < OC_PAL_NUM_OF_CHANNEL_MAX);
1057 #if (defined(OC_PAL_OVER_FTM))
1062 (uint16_t)nextCompareMatchValue,
1069 #if (defined(OC_PAL_OVER_EMIOS))
1070 if(instance->
instType == OC_INST_TYPE_EMIOS)
1072 uint32_t compareValue = 0U;
1073 uint32_t maxCounterValue = 0U;
1074 uint32_t counterValue = EMIOS_DRV_MC_CounterRead((uint8_t)instance->
instIdx, channel);
1078 maxCounterValue = EMIOS_DRV_MC_GetCounterPeriod((uint8_t)instance->
instIdx, channel);
1080 if (nextCompareMatchValue > (maxCounterValue - counterValue))
1082 compareValue = (nextCompareMatchValue - (maxCounterValue - counterValue));
1086 compareValue = (counterValue + nextCompareMatchValue);
1091 compareValue = nextCompareMatchValue;
1095 EMIOS_DRV_OC_SetSingleActOutputCmpMatch((uint8_t)instance->
instIdx,
1096 channel, compareValue);
1102 #if (defined(OC_PAL_OVER_ETIMER))
1103 if(instance->
instType == OC_INST_TYPE_ETIMER)
1105 uint16_t compareValue = 0U;
1106 uint16_t counterValue = ETIMER_DRV_GetTimerTicks((uint16_t)instance->
instIdx, (uint16_t)channel);
1111 if ((uint16_t)nextCompareMatchValue > (ETIMER_CH_MAX_TIMER_COUNT - counterValue))
1113 compareValue = ((uint16_t)nextCompareMatchValue - (ETIMER_CH_MAX_TIMER_COUNT - counterValue));
1117 compareValue = (counterValue + (uint16_t)nextCompareMatchValue);
1122 compareValue = (uint16_t)nextCompareMatchValue;
1126 ETIMER_DRV_Set_CMPLD1((uint16_t)instance->
instIdx,
1147 const uint8_t channel)
1151 DEV_ASSERT(channel < OC_PAL_NUM_OF_CHANNEL_MAX);
1157 ocState = &g_ocPalStatePtr[index];
1160 ocState->enableNotification[channel] =
true;
1171 const uint8_t channel)
1175 DEV_ASSERT(channel < OC_PAL_NUM_OF_CHANNEL_MAX);
1181 ocState = &g_ocPalStatePtr[index];
1184 ocState->enableNotification[channel] =
false;
1197 DEV_ASSERT(channel < OC_PAL_NUM_OF_CHANNEL_MAX);
1200 #if (defined (OC_PAL_OVER_FTM))
1206 ocState = &g_ocPalStatePtr[index];
1208 if ((ocState->channelCallbacks[channel] != NULL) && (ocState->enableNotification[channel] ==
true))
1214 #if (defined (OC_PAL_OVER_FTM))
1219 #if (defined(OC_PAL_OVER_EMIOS))
1221 EMIOS_DRV_ClrFlagState(instance, channel);
1224 #if (defined(OC_PAL_OVER_ETIMER))
1226 ETIMER_DRV_ClearInterruptStatus((uint16_t)instance,
1227 (ETIMER_CH_IRQ_FLAGS_TCF | ETIMER_CH_IRQ_FLAGS_TCF1 | ETIMER_CH_IRQ_FLAGS_TCF2),
status_t OC_SetCompareValue(const oc_instance_t *const instance, const uint8_t channel, uint32_t nextCompareMatchValue, oc_option_update_t typeOfupdate)
Update the match value on the channel.
ftm_reg_update_t initCounterSync
status_t FTM_DRV_SetSoftwareOutputChannelControl(uint32_t instance, uint8_t channelsMask, bool softwareTrigger)
This function will configure which output channel can be software controlled.
ftm_pwm_sync_t syncMethod
FlexTimer state structure of the driver.
#define FTM_CONTROLS_COUNT
FlexTimer driver PWM parameters.
#define FEATURE_FTM_CHANNEL_COUNT
Configuration structure that the user needs to set.
void OC_IrqHandler(uint32_t instance, uint8_t channel)
ftm_output_cmp_ch_param_t * outputChannelConfig
static oc_pal_state_t g_ocPalStatePtr[NUMBER_OF_OC_PAL_INSTANCES]
The internal context structure.
oc_callback_t channelCallbacks
FlexTimer Registers sync parameters Please don't use software and hardware trigger simultaneously Imp...
ftm_output_compare_mode_t chMode
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_output_compare_mode_t
FlexTimer Mode configuration for output compare mode.
void OC_StartChannel(const oc_instance_t *const instance, const uint8_t channel)
Start the counter.
status_t FTM_DRV_InitOutputCompare(uint32_t instance, const ftm_output_cmp_param_t *param)
Configures the FTM to generate timed pulses(Output compare mode).
const oc_output_ch_param_t * outputChConfig
void * channelCallbackParams
ftm_output_compare_update_t
FlexTimer input capture type of the next output compare value.
status_t OC_SetOutputState(const oc_instance_t *const instance, const uint8_t channel, bool outputValue)
Control the channel output by software.
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.
status_t OC_SetOutputAction(const oc_instance_t *const instance, const uint8_t channel, oc_option_mode_t channelMode)
Set the operation mode of channel output.
status_t OC_Deinit(const oc_instance_t *const instance)
De-initialize the output compare instance.
void OC_StopChannel(const oc_instance_t *const instance, const uint8_t channel)
Stop the counter.
#define FTM_INSTANCE_COUNT
oc_option_mode_t
The type of comparison for output compare mode Implements : oc_option_mode_t_Class.
bool enableInitializationTrigger
static uint32_t ocStateInstanceMapping[NUMBER_OF_OC_PAL_INSTANCES]
ftm_reg_update_t inverterSync
void OC_EnableNotification(const oc_instance_t *const instance, const uint8_t channel)
Enable channel notifications.
status_t FTM_DRV_EnableInterrupts(uint32_t instance, uint32_t interruptMask)
This function will enable the generation a list of interrupts. It includes the FTM overflow interrupt...
ftm_config_mode_t ftmMode
void(* oc_callback_t)(oc_event_t event, void *userData)
FlexTimer driver PWM parameters.
bool enableExternalTrigger
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
uint8_t nNumOutputChannels
static void FTM_DRV_ClearChnEventStatus(FTM_Type *const ftmBase, uint8_t channel)
Clears the FTM peripheral timer all channel event status.
static bool ocStateIsAllocated[NUMBER_OF_OC_PAL_INSTANCES]
status_t FTM_DRV_Init(uint32_t instance, const ftm_user_config_t *info, ftm_state_t *state)
Initializes the FTM driver.
status_t FTM_DRV_SetSoftOutChnValue(uint32_t instance, uint8_t channelsValues, bool softwareTrigger)
This function will force the output value of a channel to a specific value. Before using this functio...
status_t OC_Init(const oc_instance_t *const instance, const oc_config_t *const configPtr)
Initializes the output compare mode.
void(* isr_t)(void)
Interrupt handler type.
void OC_DisableNotification(const oc_instance_t *const instance, const uint8_t channel)
Disable channel notifications.
status_t FTM_DRV_UpdateOutputCompareChannel(uint32_t instance, uint8_t channel, uint16_t nextComparematchValue, ftm_output_compare_update_t update, bool softwareTrigger)
Sets the next compare match value based on the current counter value.
static uint8_t FindOcState(uint32_t instance)
static uint8_t ocAllocateState(bool *isAllocated, uint32_t *instanceMapping, uint32_t instance, uint8_t numberOfInstances)
ftm_clock_source_t ftmClockSource
oc_option_update_t
The type of update on the channel match Implements : oc_option_mode_t_Class.
ftm_reg_update_t outRegSync
Defines the configuration structures are used in the output compare mode.
static void ocFreeState(bool *isAllocated, uint32_t *instanceMapping, uint32_t instance, uint8_t numberOfInstances)
ftm_clock_ps_t ftmPrescaler
FTM_Type *const g_ftmBase[(2u)]
Table of base addresses for FTM instances.
void INT_SYS_InstallHandler(IRQn_Type irqNumber, const isr_t newHandler, isr_t *const oldHandler)
Installs an interrupt handler routine for a given IRQ number.
Structure storing PAL instance information.