52 #include "lptmr_hw_access.h"
60 #define LPTMR_MAX_CMR_NTICKS (LPTMR_CMR_COMPARE_MASK + 1u)
61 #define LPTMR_MAX_PRESCALER (1u << LPTMR_PSR_PRESCALE_WIDTH)
75 static inline uint8_t lptmr_cfg2p(
80 static inline uint64_t lptmr_us2nn(
81 const uint32_t clkfreq,
85 static inline uint64_t lptmr_compute_nticks(
90 static inline bool nticks2compare_ticks(
95 static uint32_t lptmr_GetClkFreq(
97 const uint32_t instance
100 static bool lptmr_Ticks2Us(
101 const uint32_t clkfreq,
104 const uint16_t ticks,
108 static bool lptmr_Us2Ticks(
109 const uint32_t clkfreq,
113 uint16_t*
const ticks
116 static bool lptmr_ChooseClkConfig(
117 const uint32_t clkfreq,
121 uint16_t*
const ticks
174 static inline uint8_t lptmr_cfg2p(
183 p = (uint8_t)(((uint8_t)prescval) + 1u);
196 static inline uint64_t lptmr_us2nn(
197 const uint32_t clkfreq,
216 uint64_t nn = (uint64_t)( (uint64_t)us * (uint64_t)clkfreq );
217 nn = (nn + 500000u) / 1000000u;
228 static inline uint64_t lptmr_compute_nticks(
233 uint64_t npresc = (uint64_t) 1u << p;
237 uint64_t nticks = ((nn + (npresc >> 1u)) / npresc);
253 static inline bool nticks2compare_ticks(
272 *ticks = (uint16_t)(nticks - 1u);
294 const uint32_t instance)
315 inputClockName = lptmrPccClockName[instance];
352 static bool lptmr_Ticks2Us(
353 const uint32_t clkfreq,
356 const uint16_t ticks,
361 uint8_t p = lptmr_cfg2p(pval, bypass);
362 uint64_t nn = ( (uint64_t)ticks + 1u ) << p;
363 uint64_t us_real = (nn * 1000000u) / (clkfreq);
366 if ( us_real <= (0xFFFFFFFFu) )
368 us_local = (uint32_t)us_real;
372 us_local = 0xFFFFFFFFu;
390 static bool lptmr_Us2Ticks(
391 const uint32_t clkfreq,
395 uint16_t*
const ticks
400 uint8_t p = lptmr_cfg2p(prescval, bypass);
403 uint64_t nn = lptmr_us2nn(clkfreq, us);
405 uint64_t nticks = lptmr_compute_nticks(nn, p);
407 success = nticks2compare_ticks(nticks, ticks);
423 static bool lptmr_ChooseClkConfig(
424 const uint32_t clkfreq,
428 uint16_t*
const ticks
435 uint64_t nn = lptmr_us2nn(clkfreq, us);
440 nticks = lptmr_compute_nticks(nn, p);
449 success = nticks2compare_ticks(nticks, ticks);
530 const bool startCounter)
535 LPTMR_Type*
const base = g_lptmrBase[instance];
578 LPTMR_Type*
const base = g_lptmrBase[instance];
581 uint16_t cmpValueTicks = 0U;
590 clkFreq = lptmr_GetClkFreq(config->
clockSelect, instance);
595 bool chooseClkConfigStatus;
601 chooseClkConfigStatus = lptmr_ChooseClkConfig(clkFreq, configCmpValue, &prescVal, &prescBypass, &cmpValueTicks);
603 (void) chooseClkConfigStatus;
633 LPTMR_SetDmaRequest (base, config->
dmaRequest);
635 LPTMR_SetFreeRunning (base, config->
freeRun);
636 LPTMR_SetWorkMode (base, configWorkMode);
637 LPTMR_SetPrescaler (base, prescVal);
638 LPTMR_SetBypass (base, prescBypass);
640 LPTMR_SetCompareValue (base, cmpValueTicks);
641 LPTMR_SetPinSelect (base, config->
pinSelect);
659 const LPTMR_Type*
const base = g_lptmrBase[instance];
662 config->
dmaRequest = LPTMR_GetDmaRequest(base);
664 config->
freeRun = LPTMR_GetFreeRunning(base);
665 config->
workMode = LPTMR_GetWorkMode(base);
666 config->
prescaler = LPTMR_GetPrescaler(base);
671 config->
pinSelect = LPTMR_GetPinSelect(base);
687 LPTMR_Type*
const base = g_lptmrBase[instance];
706 const uint16_t compareValueByCount)
710 LPTMR_Type*
const base = g_lptmrBase[instance];
713 bool timerEnabled = LPTMR_GetEnable(base);
714 bool compareFlag = LPTMR_GetCompareFlag(base);
719 #if (defined (DEV_ERROR_DETECT) || defined (CUSTOM_DEVASSERT))
720 bool bypass = LPTMR_GetBypass(base);
725 DEV_ASSERT((lptmr_GetClkFreq(LPTMR_GetClockSelect(base), instance) != 0u) || \
730 if (timerEnabled && !compareFlag)
737 LPTMR_SetCompareValue(base, compareValueByCount);
738 counterVal = LPTMR_GetCounterValue(base);
739 if (counterVal >= compareValueByCount)
757 uint16_t *
const compareValueByCount)
761 const LPTMR_Type*
const base = g_lptmrBase[instance];
763 *compareValueByCount = LPTMR_GetCompareValue(base);
781 const uint32_t compareValueUs)
786 LPTMR_Type*
const base = g_lptmrBase[instance];
787 bool timerEnabled, compareFlag;
791 uint16_t cmpValTicks, currentCounterVal;
793 bool prescBypass, conversionStatus;
798 timerEnabled = LPTMR_GetEnable(base);
799 compareFlag = LPTMR_GetCompareFlag(base);
801 if (timerEnabled && !compareFlag)
807 clkSrc = LPTMR_GetClockSelect(base);
808 clkFreq = lptmr_GetClkFreq(clkSrc, instance);
812 prescVal = LPTMR_GetPrescaler(base);
813 prescBypass = LPTMR_GetBypass(base);
815 conversionStatus = lptmr_Us2Ticks(clkFreq, prescVal, prescBypass, compareValueUs, &cmpValTicks);
817 (void) conversionStatus;
820 LPTMR_SetCompareValue(base, cmpValTicks);
821 currentCounterVal = LPTMR_GetCounterValue(base);
823 if (currentCounterVal >= cmpValTicks)
841 uint32_t *
const compareValueUs)
846 const LPTMR_Type*
const base = g_lptmrBase[instance];
849 uint16_t cmpValTicks;
851 bool prescBypass, conversionStatus;
856 clkSrc = LPTMR_GetClockSelect(base);
857 clkFreq = lptmr_GetClkFreq(clkSrc, instance);
862 prescVal = LPTMR_GetPrescaler(base);
863 prescBypass = LPTMR_GetBypass(base);
864 cmpValTicks = LPTMR_GetCompareValue(base);
867 conversionStatus = lptmr_Ticks2Us(clkFreq, prescVal, prescBypass, cmpValTicks, compareValueUs);
869 (void) conversionStatus;
884 const LPTMR_Type*
const base = g_lptmrBase[instance];
885 bool compareFlag = LPTMR_GetCompareFlag(base);
902 LPTMR_Type*
const base = g_lptmrBase[instance];
904 LPTMR_ClearCompareFlag(base);
922 const LPTMR_Type*
const base = g_lptmrBase[instance];
924 bool runningState = LPTMR_GetEnable(base);
938 const bool enableInterrupt)
942 LPTMR_Type*
const base = g_lptmrBase[instance];
944 LPTMR_SetInterrupt(base, enableInterrupt);
961 LPTMR_Type*
const base = g_lptmrBase[instance];
963 uint16_t counterVal = LPTMR_GetCounterValue(base);
980 LPTMR_Type*
const base = g_lptmrBase[instance];
983 #if (defined (DEV_ERROR_DETECT) || defined (CUSTOM_DEVASSERT))
984 bool bypass = LPTMR_GetBypass(base);
989 DEV_ASSERT((lptmr_GetClkFreq(LPTMR_GetClockSelect(base), instance) != 0u) || \
1007 LPTMR_Type*
const base = g_lptmrBase[instance];
1009 LPTMR_Disable(base);
1026 LPTMR_Type*
const base = g_lptmrBase[instance];
1028 LPTMR_SetPinSelect(base, pinSelect);
1029 LPTMR_SetPinPolarity(base, pinPolarity);
void LPTMR_DRV_InitConfigStruct(lptmr_config_t *const config)
Initialize a configuration structure with default values.
lptmr_workmode_t workMode
void LPTMR_DRV_Init(const uint32_t instance, const lptmr_config_t *const config, const bool startCounter)
Initialize a LPTMR instance with values from an input configuration structure.
void LPTMR_DRV_SetInterrupt(const uint32_t instance, const bool enableInterrupt)
Enable/disable the LPTMR interrupt.
lptmr_pinpolarity_t pinPolarity
void LPTMR_DRV_StopCounter(const uint32_t instance)
Disable the LPTMR / Stop the counter.
#define LPTMR_MAX_CMR_NTICKS
lptmr_clocksource_t clockSelect
Defines the configuration structure for LPTMR.
void LPTMR_DRV_ClearCompareFlag(const uint32_t instance)
Clear the Compare Flag of a LPTMR instance.
lptmr_prescaler_t prescaler
lptmr_clocksource_t
Clock Source selection Implements : lptmr_clocksource_t_Class.
bool LPTMR_DRV_IsRunning(const uint32_t instance)
Get the run state of a LPTMR instance.
lptmr_workmode_t
Work Mode Implements : lptmr_workmode_t_Class.
#define LPTMR_CMR_COMPARE_MASK
lptmr_counter_units_t counterUnits
void LPTMR_DRV_GetCompareValueByUs(const uint32_t instance, uint32_t *const compareValueUs)
Get the compare value in microseconds, of a LPTMR instance.
lptmr_counter_units_t
Defines the LPTMR counter units available for configuring or reading the timer compare value...
lptmr_pinselect_t pinSelect
#define LPTMR_INSTANCE_COUNT
lptmr_prescaler_t
Prescaler Selection Implements : lptmr_prescaler_t_Class.
void LPTMR_DRV_GetCompareValueByCount(const uint32_t instance, uint16_t *const compareValueByCount)
Get the compare value in counter tick units, of a LPTMR instance.
lptmr_pinpolarity_t
Pulse Counter input polarity Implements : lptmr_pinpolarity_t_Class.
status_t CLOCK_SYS_GetFreq(clock_names_t clockName, uint32_t *frequency)
Gets the clock frequency for a specific clock name.
void LPTMR_DRV_Deinit(const uint32_t instance)
De-initialize a LPTMR instance.
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
uint16_t LPTMR_DRV_GetCounterValueByCount(const uint32_t instance)
Get the current counter value in counter tick units.
void LPTMR_DRV_StartCounter(const uint32_t instance)
Enable the LPTMR / Start the counter.
void LPTMR_DRV_SetConfig(const uint32_t instance, const lptmr_config_t *const config)
Configure a LPTMR instance.
void LPTMR_DRV_GetConfig(const uint32_t instance, lptmr_config_t *const config)
Get the current configuration of a LPTMR instance.
#define LPTMR_MAX_PRESCALER
lptmr_pinselect_t
Pulse Counter Input selection Implements : lptmr_pinselect_t_Class.
clock_names_t
Clock names.
void LPTMR_DRV_SetPinConfiguration(const uint32_t instance, const lptmr_pinselect_t pinSelect, const lptmr_pinpolarity_t pinPolarity)
Set the Input Pin configuration for Pulse Counter mode.
status_t LPTMR_DRV_SetCompareValueByCount(const uint32_t instance, const uint16_t compareValueByCount)
Set the compare value in counter tick units, for a LPTMR instance.
status_t LPTMR_DRV_SetCompareValueByUs(const uint32_t instance, const uint32_t compareValueUs)
Set the compare value for Timer Mode in microseconds, for a LPTMR instance.
bool LPTMR_DRV_GetCompareFlag(const uint32_t instance)
Get the current state of the Compare Flag of a LPTMR instance.