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;
593 clkFreq = lptmr_GetClkFreq(config->
clockSelect, instance);
598 bool chooseClkConfigStatus;
604 chooseClkConfigStatus = lptmr_ChooseClkConfig(clkFreq, configCmpValue, &prescVal, &prescBypass, &cmpValueTicks);
606 (void) chooseClkConfigStatus;
636 LPTMR_SetDmaRequest (base, config->
dmaRequest);
638 LPTMR_SetFreeRunning (base, config->
freeRun);
639 LPTMR_SetWorkMode (base, configWorkMode);
640 LPTMR_SetPrescaler (base, prescVal);
641 LPTMR_SetBypass (base, prescBypass);
643 LPTMR_SetCompareValue (base, cmpValueTicks);
644 LPTMR_SetPinSelect (base, config->
pinSelect);
662 const LPTMR_Type*
const base = g_lptmrBase[instance];
665 config->
dmaRequest = LPTMR_GetDmaRequest(base);
667 config->
freeRun = LPTMR_GetFreeRunning(base);
668 config->
workMode = LPTMR_GetWorkMode(base);
669 config->
prescaler = LPTMR_GetPrescaler(base);
674 config->
pinSelect = LPTMR_GetPinSelect(base);
690 LPTMR_Type*
const base = g_lptmrBase[instance];
709 const uint16_t compareValueByCount)
713 LPTMR_Type*
const base = g_lptmrBase[instance];
716 bool timerEnabled = LPTMR_GetEnable(base);
717 bool compareFlag = LPTMR_GetCompareFlag(base);
722 #if (defined (DEV_ERROR_DETECT) || defined (CUSTOM_DEVASSERT))
723 bool bypass = LPTMR_GetBypass(base);
728 DEV_ASSERT((lptmr_GetClkFreq(LPTMR_GetClockSelect(base), instance) != 0u) || \
733 if (timerEnabled && !compareFlag)
740 LPTMR_SetCompareValue(base, compareValueByCount);
741 counterVal = LPTMR_GetCounterValue(base);
742 if (counterVal >= compareValueByCount)
760 uint16_t *
const compareValueByCount)
764 const LPTMR_Type*
const base = g_lptmrBase[instance];
766 *compareValueByCount = LPTMR_GetCompareValue(base);
784 const uint32_t compareValueUs)
789 LPTMR_Type*
const base = g_lptmrBase[instance];
790 bool timerEnabled, compareFlag;
794 uint16_t cmpValTicks, currentCounterVal;
796 bool prescBypass, conversionStatus;
801 timerEnabled = LPTMR_GetEnable(base);
802 compareFlag = LPTMR_GetCompareFlag(base);
804 if (timerEnabled && !compareFlag)
810 clkSrc = LPTMR_GetClockSelect(base);
811 clkFreq = lptmr_GetClkFreq(clkSrc, instance);
815 prescVal = LPTMR_GetPrescaler(base);
816 prescBypass = LPTMR_GetBypass(base);
818 conversionStatus = lptmr_Us2Ticks(clkFreq, prescVal, prescBypass, compareValueUs, &cmpValTicks);
820 (void) conversionStatus;
823 LPTMR_SetCompareValue(base, cmpValTicks);
824 currentCounterVal = LPTMR_GetCounterValue(base);
826 if (currentCounterVal >= cmpValTicks)
844 uint32_t *
const compareValueUs)
849 const LPTMR_Type*
const base = g_lptmrBase[instance];
852 uint16_t cmpValTicks;
854 bool prescBypass, conversionStatus;
859 clkSrc = LPTMR_GetClockSelect(base);
860 clkFreq = lptmr_GetClkFreq(clkSrc, instance);
865 prescVal = LPTMR_GetPrescaler(base);
866 prescBypass = LPTMR_GetBypass(base);
867 cmpValTicks = LPTMR_GetCompareValue(base);
870 conversionStatus = lptmr_Ticks2Us(clkFreq, prescVal, prescBypass, cmpValTicks, compareValueUs);
872 (void) conversionStatus;
887 const LPTMR_Type*
const base = g_lptmrBase[instance];
888 bool compareFlag = LPTMR_GetCompareFlag(base);
905 LPTMR_Type*
const base = g_lptmrBase[instance];
907 LPTMR_ClearCompareFlag(base);
925 const LPTMR_Type*
const base = g_lptmrBase[instance];
927 bool runningState = LPTMR_GetEnable(base);
941 const bool enableInterrupt)
945 LPTMR_Type*
const base = g_lptmrBase[instance];
950 LPTMR_SetInterrupt(base, enableInterrupt);
967 LPTMR_Type*
const base = g_lptmrBase[instance];
969 uint16_t counterVal = LPTMR_GetCounterValue(base);
986 LPTMR_Type*
const base = g_lptmrBase[instance];
989 #if (defined (DEV_ERROR_DETECT) || defined (CUSTOM_DEVASSERT))
990 bool bypass = LPTMR_GetBypass(base);
995 DEV_ASSERT((lptmr_GetClkFreq(LPTMR_GetClockSelect(base), instance) != 0u) || \
1013 LPTMR_Type*
const base = g_lptmrBase[instance];
1015 LPTMR_Disable(base);
1032 LPTMR_Type*
const base = g_lptmrBase[instance];
1034 LPTMR_SetPinSelect(base, pinSelect);
1035 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.
clock_names_t
Clock names.
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.
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.