OSchip
/
arduino_core_ch32
mirror of https://github.com/openwch/arduino_core_ch32.git
13
0
Fork 5
Code Issues Packages Projects Releases Wiki Activity
arduino_core_ch32/cores/arduino/HardwareTimer.cpp

1781 lines
53 KiB
C++
Raw Blame History

/*
Copyright (c) 2017 Daniel Fekete
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Copyright (c) 2019 STMicroelectronics
Modified to support Arduino_Core_STM32
Modified by TempersLee to support Adruino_Core_CH32
*/
#include "Arduino.h"
#include "HardwareTimer.h"
#if defined(TIM_MODULE_ENABLED) && !defined(TIM_MODULE_ONLY)
/* Private Defines */
#define PIN_NOT_USED 0xFF
#define MAX_RELOAD ((1 << 16) - 1) // Currently even 32b timers are used as 16b to have generic behavior
/* Private Variables */
timerObj_t *HardwareTimer_Handle[TIMER_NUM] = {NULL};
/**
* @brief HardwareTimer constructor: make uninitialized timer
* Before calling any methods, call setup to select and setup
* the timer to be used.
* @retval None
*/
HardwareTimer::HardwareTimer()
{
_timerObj.handle.Instance = nullptr;
}
/**
* @brief HardwareTimer constructor: set default configuration values
* The timer will be usable directly, there is no need to call
* setup(). Using this constructor is not recommended for
* global variables that are automatically initialized at
* startup, since this will happen to early to report any
* errors. Better use the argumentless constructor and call the
* setup() method during initialization later.
* @param Timer instance ex: TIM1, ...
* @retval None
*/
HardwareTimer::HardwareTimer(TIM_TypeDef *instance)
{
_timerObj.handle.Instance = nullptr;
setup(instance);
#ifdef TIM1_BASE
NVIC_EnableIRQ(TIM1_UP_IRQn);
NVIC_EnableIRQ(TIM1_CC_IRQn);
#endif
#ifdef TIM2_BASE
NVIC_EnableIRQ(TIM2_IRQn);
#endif
#ifdef TIM3_BASE
NVIC_EnableIRQ(TIM3_IRQn);
#endif
#ifdef TIM4_BASE
NVIC_EnableIRQ(TIM4_IRQn);
#endif
#ifdef CH32V30x
#ifdef TIM5_BASE
NVIC_EnableIRQ(TIM5_IRQn);
#endif
#ifdef TIM6_BASE
NVIC_EnableIRQ(TIM6_IRQn);
#endif
#ifdef TIM7_BASE
NVIC_EnableIRQ(TIM7_IRQn);
#endif
#ifdef TIM8_BASE
NVIC_EnableIRQ(TIM8_UP_IRQn);
NVIC_EnableIRQ(TIM8_CC_IRQn);
#endif
#ifdef TIM9_BASE
NVIC_EnableIRQ(TIM9_UP_IRQn);
NVIC_EnableIRQ(TIM9_CC_IRQn);
#endif
#ifdef TIM10_BASE
NVIC_EnableIRQ(TIM10_UP_IRQn);
NVIC_EnableIRQ(TIM10_CC_IRQn);
#endif
#endif
}
/**
* @brief HardwareTimer setup: configuration values. Must be called
* exactly once before any other methods, except when an instance is
* passed to the constructor.
* @param Timer instance ex: TIM1, ...
* @retval None
*/
void HardwareTimer::setup(TIM_TypeDef *instance)
{
uint32_t index = get_timer_index(instance);
if (index == UNKNOWN_TIMER) {
Error_Handler();
}
// Already initialized?
if (_timerObj.handle.Instance) {
Error_Handler();
}
HardwareTimer_Handle[index] = &_timerObj;
_timerObj.handle.Instance = instance;
_timerObj.__this = (void *)this;
_timerObj.preemptPriority = TIM_IRQ_PRIO;
_timerObj.subPriority = TIM_IRQ_SUBPRIO;
_timerObj.handle.Init={0};
/* Enable timer clock. Even if it is also done in HAL_TIM_Base_MspInit(),
it is done there so that it is possible to write registers right now */
enableTimerClock(&(_timerObj.handle));
// Initialize NULL callbacks
for (int i = 0; i < TIMER_CHANNELS + 1 ; i++) {
callbacks[i] = NULL;
}
// Initialize channel mode and complementary
for (int i = 0; i < TIMER_CHANNELS; i++) {
#if defined(TIM_CC1NE)
isComplementaryChannel[i] = false; //如果有互补通道定义
#endif
_ChannelMode[i] = TIMER_DISABLED;
}
/* Configure timer with some default values */
_timerObj.handle.Init.TIM_Prescaler = 0;
_timerObj.handle.Init.TIM_Period = MAX_RELOAD;
_timerObj.handle.Init.TIM_CounterMode = TIM_CounterMode_Up;
_timerObj.handle.Init.TIM_ClockDivision = TIM_CKD_DIV1;
#if defined(TIM_RCR_REP)
_timerObj.handle.Init.TIM_RepetitionCounter = 0;
#endif
TIM_ARRPreloadConfig( _timerObj.handle.Instance, ENABLE );
TIM_TimeBaseInit( _timerObj.handle.Instance, &_timerObj.handle.Init);
}
/**
* @brief Pause HardwareTimer: stop timer
* @param None
* @retval None
*/
void HardwareTimer::pause()
{
// Disable all IT
TIM_ITConfig(_timerObj.handle.Instance, TIM_IT_Update|TIM_IT_CC1|TIM_IT_CC2|TIM_IT_CC3|TIM_IT_CC4, DISABLE);
// Stop timer. Required to restore HAL State: HAL_TIM_STATE_READY
TIM_Cmd(_timerObj.handle.Instance,DISABLE);
}
/**
* @brief Pause only one channel.
* Timer is still running but channel is disabled (output and interrupt)
* @param Arduino channel [1..4]
* @retval None
*/
void HardwareTimer::pauseChannel(uint32_t channel)
{
int timAssociatedInputChannel;
int LLChannel = getLLChannel(channel);
if (LLChannel == -1) {
Error_Handler();
}
int interrupt = getIT(channel);
if (interrupt == -1) {
Error_Handler();
}
// Disable channel and corresponding interrupt
TIM_ITConfig(_timerObj.handle.Instance, interrupt, DISABLE);
TIM_CCxCmd(_timerObj.handle.Instance,LLChannel,TIM_CCx_Disable);
#if defined(TIM_CHANNEL_STATE_SET)
/* Starting from G4, new Channel state implementation prevents to restart a channel,
if the channel has not been explicitly be stopped with HAL interface */
#if defined(TIM_CHANNEL_N_STATE_SET)
if (isComplementaryChannel[channel - 1])
{
// TIM_CHANNEL_N_STATE_SET(&(_timerObj.handle), getChannel(channel), HAL_TIM_CHANNEL_STATE_READY);
}
else
#endif
{
// TIM_CHANNEL_STATE_SET(&(_timerObj.handle), getChannel(channel), HAL_TIM_CHANNEL_STATE_READY);
}
#endif
// In case 2 channels are used, disable also the 2nd one
if (_ChannelMode[channel - 1] == TIMER_INPUT_FREQ_DUTY_MEASUREMENT)
{
// Identify and configure 2nd associated channel
timAssociatedInputChannel = getAssociatedChannel(channel);
TIM_ITConfig(_timerObj.handle.Instance, getIT(timAssociatedInputChannel), DISABLE);
TIM_CCxCmd(_timerObj.handle.Instance,getLLChannel(timAssociatedInputChannel),TIM_CCx_Disable);
}
}
/**
* @brief Start or resume HardwareTimer: all channels are resumed, interrupts are enabled if necessary
* @param None
* @retval None
*/
void HardwareTimer::resume(void)
{
// Clear flag and enable IT
if (callbacks[0]) // 0 for update
{
TIM_ClearFlag(_timerObj.handle.Instance,TIM_FLAG_Update );
TIM_ITConfig(_timerObj.handle.Instance, TIM_IT_Update, ENABLE);
// Start timer in Time base mode. Required when there is no channel used but only update interrupt.
TIM_Cmd(_timerObj.handle.Instance, ENABLE );
}
// Resume all channels
resumeChannel(1);
resumeChannel(2);
resumeChannel(3);
resumeChannel(4);
}
/**
* @brief Convert arduino channel into HAL channel
* @param Arduino channel [1..4]
* @retval HAL channel. return -1 if arduino channel is invalid
*/
//CHANNEL
int HardwareTimer::getChannel(uint32_t channel)
{
uint32_t return_value;
switch (channel) {
case 1:
return_value = TIM_Channel_1;
break;
case 2:
return_value = TIM_Channel_2;
break;
case 3:
return_value = TIM_Channel_3;
break;
case 4:
return_value = TIM_Channel_4;
break;
default:
return_value = -1;
}
return return_value;
}
/**
* @brief Convert arduino channel into LL channel
* @param Arduino channel [1..4]
* @retval LL channel. return -1 if arduino channel is invalid
*/
//CHANNEL P or N
int HardwareTimer::getLLChannel(uint32_t channel)
{
uint32_t return_value;
#if defined(TIM_CC1NE)
if (isComplementaryChannel[channel - 1]) {
// Complementary channel
switch (channel) {
case 1:
return_value = TIM_CHANNEL_CH1N;
break;
case 2:
return_value = TIM_CHANNEL_CH2N;
break;
case 3:
return_value = TIM_CHANNEL_CH3N;
break;
#if defined(TIM_CHANNEL_CH4N)
case 4:
return_value = TIM_CHANNEL_CH4N;
break;
#endif
default:
return_value = -1;
}
}
else
#endif
{
// Regular channel not complementary
switch (channel) {
case 1:
return_value = TIM_CHANNEL_CH1;
break;
case 2:
return_value = TIM_CHANNEL_CH2;
break;
case 3:
return_value = TIM_CHANNEL_CH3;
break;
case 4:
return_value = TIM_CHANNEL_CH4;
break;
default:
return_value = -1;
}
}
return return_value;
}
/**
* @brief Convert arduino channel into HAL Interrupt ID
* @param Arduino channel [1..4]
* @retval HAL channel. return -1 if arduino channel is invalid
*/
int HardwareTimer::getIT(uint32_t channel)
{
uint32_t return_value;
switch (channel) {
case 1:
return_value = TIM_IT_CC1;
break;
case 2:
return_value = TIM_IT_CC2;
break;
case 3:
return_value = TIM_IT_CC3;
break;
case 4:
return_value = TIM_IT_CC4;
break;
default:
return_value = -1;
}
return return_value;
}
/**
* @brief Get input associated channel
* Channel 1 and 2 are associated; channel 3 and 4 are associated
* @param Arduino channel [1..4]
* @retval HAL channel. return -1 if arduino channel is invalid
*/
int HardwareTimer::getAssociatedChannel(uint32_t channel)
{
int timAssociatedInputChannel = -1;
switch (channel) {
case 1:
timAssociatedInputChannel = 2;
break;
case 2:
timAssociatedInputChannel = 1;
break;
case 3:
timAssociatedInputChannel = 4;
break;
case 4:
timAssociatedInputChannel = 3;
break;
default:
break;
}
return timAssociatedInputChannel;
}
/**
* @brief Configure specified channel and resume/start timer
* @param Arduino channel [1..4]
* @retval None
*/
void HardwareTimer::resumeChannel(uint32_t channel)
{
int timChannel = getChannel(channel);
int timAssociatedInputChannel;
if (timChannel == -1) {
Error_Handler();
}
int interrupt = getIT(channel);
if (interrupt == -1) {
Error_Handler();
}
int LLChannel = getLLChannel(channel);
if (LLChannel == -1) {
Error_Handler();
}
// Clear flag and enable IT
if (callbacks[channel]) {
TIM_ClearFlag(_timerObj.handle.Instance,interrupt );
TIM_ITConfig(_timerObj.handle.Instance, interrupt, ENABLE);
}
switch (_ChannelMode[channel - 1])
{
case TIMER_OUTPUT_COMPARE_PWM1:
case TIMER_OUTPUT_COMPARE_PWM2:
{
#if defined(TIM_CC1NE)
if (isComplementaryChannel[channel - 1])
{
TIM_CCxNCmd( _timerObj.handle.Instance, timChannel, TIM_CCxN_Enable );
_timerObj.handle.Instance->BDTR |= TIM_MOE; //MOE ENABLE
TIM_Cmd( _timerObj.handle.Instance, ENABLE );
}
else
#endif
{
TIM_CCxCmd( _timerObj.handle.Instance, timChannel, TIM_CCx_Enable );
_timerObj.handle.Instance->BDTR |= TIM_MOE; //MOE ENABLE
TIM_Cmd( _timerObj.handle.Instance, ENABLE );
}
}
break;
case TIMER_OUTPUT_COMPARE_ACTIVE:
case TIMER_OUTPUT_COMPARE_INACTIVE:
case TIMER_OUTPUT_COMPARE_TOGGLE:
case TIMER_OUTPUT_COMPARE_FORCED_ACTIVE:
case TIMER_OUTPUT_COMPARE_FORCED_INACTIVE:
{
#if defined(TIM_CC1NE)
if (isComplementaryChannel[channel - 1])
{
// HAL_TIMEx_OCN_Start(&(_timerObj.handle), timChannel);
TIM_CCxNCmd( _timerObj.handle.Instance, timChannel, TIM_CCxN_Enable );
_timerObj.handle.Instance->BDTR |= TIM_MOE; //MOE ENABLE
TIM_Cmd( _timerObj.handle.Instance, ENABLE );
}
else
#endif
{
// HAL_TIM_OC_Start(&(_timerObj.handle), timChannel);
TIM_CCxCmd( _timerObj.handle.Instance, timChannel, TIM_CCx_Enable );
_timerObj.handle.Instance->BDTR |= TIM_MOE; //MOE ENABLE
TIM_Cmd( _timerObj.handle.Instance, ENABLE );
}
}
break;
case TIMER_INPUT_FREQ_DUTY_MEASUREMENT: {
TIM_CCxCmd( _timerObj.handle.Instance, timChannel, TIM_CCx_Enable );
// Enable 2nd associated channel
//两个关联通道，配置为捕获通道 1 & 2 / 3 & 4
timAssociatedInputChannel = getAssociatedChannel(channel);
TIM_CCxCmd( _timerObj.handle.Instance, getLLChannel(timAssociatedInputChannel), TIM_CCx_Enable );
_timerObj.handle.Instance->BDTR |= TIM_MOE; //MOE ENABLE
TIM_Cmd( _timerObj.handle.Instance, ENABLE );
if (callbacks[channel])
{
TIM_ClearFlag(_timerObj.handle.Instance,getIT(timAssociatedInputChannel));
TIM_ITConfig(_timerObj.handle.Instance,getIT(timAssociatedInputChannel),ENABLE);
}
}
break;
case TIMER_INPUT_CAPTURE_RISING:
case TIMER_INPUT_CAPTURE_FALLING:
case TIMER_INPUT_CAPTURE_BOTHEDGE: {
TIM_CCxCmd( _timerObj.handle.Instance, timChannel, TIM_CCx_Enable );
_timerObj.handle.Instance->BDTR |= TIM_MOE; //MOE ENABLE
TIM_Cmd( _timerObj.handle.Instance, ENABLE );
// HAL_TIM_IC_Start(&(_timerObj.handle), timChannel);
}
break;
case TIMER_OUTPUT_COMPARE:
case TIMER_DISABLED:
if (!(_timerObj.handle.Instance->CTLR1 & TIM_CEN) ) //if not enable
{
TIM_Cmd( _timerObj.handle.Instance, ENABLE ) ;
}
break;
case TIMER_NOT_USED:
default :
break;
}
}
/**
* @brief Configure comparison output channels
* @param timerX, TIM_OCInitTypeDef, Arduino channel [1..4]
* @retval None
*/
void HardwareTimer::TIM_OC_ConfigChannel_Static(TIM_TypeDef *tim, TIM_OCInitTypeDef *sConfig, uint32_t Channel)
{
switch (Channel)
{
case TIM_Channel_1:
{
/* Configure the TIM Channel 1 in Output Compare */
TIM_OC1Init(tim,sConfig);
break;
}
case TIM_Channel_2:
{
/* Configure the TIM Channel 2 in Output Compare */
TIM_OC2Init(tim,sConfig);
break;
}
case TIM_Channel_3:
{
/* Configure the TIM Channel 3 in Output Compare */
TIM_OC3Init(tim,sConfig);
break;
}
case TIM_Channel_4:
{
/* Configure the TIM Channel 4 in Output Compare */
TIM_OC4Init(tim,sConfig);
break;
}
default:
break;
}
}
/**
* @brief Configure input capture channels
* @param timerX, TIM_ICInitTypeDef, Arduino channel [1..4]
* @retval None
*/
void HardwareTimer::TIM_IC_ConfigChannel_Static(TIM_TypeDef *tim, TIM_ICInitTypeDef *sConfig, uint32_t Channel)
{
sConfig->TIM_Channel = Channel;
TIM_ICInit( tim, sConfig);
if(Channel == TIM_Channel_1)
{
TIM_SetIC1Prescaler(tim, sConfig->TIM_ICPrescaler);
}
else if(Channel == TIM_Channel_2)
{
TIM_SetIC2Prescaler(tim, sConfig->TIM_ICPrescaler);
}
else if(Channel == TIM_Channel_3)
{
TIM_SetIC3Prescaler(tim, sConfig->TIM_ICPrescaler);
}
else
{
TIM_SetIC4Prescaler(tim, sConfig->TIM_ICPrescaler);
}
}
/**
* @brief Retrieve prescaler from hardware register
* @param None
* @retval prescaler factor
*/
uint32_t HardwareTimer::getPrescaleFactor()
{
// Hardware register correspond to prescaler-1. Example PSC register value 0 means divided by 1
return (TIM_GetPrescaler( _timerObj.handle.Instance )+1);
}
/**
* @brief Configure hardwareTimer prescaler
* @param prescaler factor
* @retval None
*/
void HardwareTimer::setPrescaleFactor(uint32_t prescaler)
{
// Hardware register correspond to prescaler-1. Example PSC register value 0 means divided by 1
_timerObj.handle.Instance->PSC = prescaler - 1;
updateRegistersIfNotRunning(_timerObj.handle.Instance);
}
/**
* @brief Retrieve overflow (rollover) value from hardware register
* @param format of returned value. If omitted default format is Tick
* @retval overflow depending on format value:
* TICK_FORMAT: return number of tick for overflow
* MICROSEC_FORMAT: return number of microsecondes for overflow
* HERTZ_FORMAT: return frequency in hertz for overflow
*/
uint32_t HardwareTimer::getOverflow(TimerFormat_t format)
{
// Hardware register correspond to period count-1. Example ARR register value 9 means period of 10 timer cycle
uint32_t ARR_RegisterValue = _timerObj.handle.Instance->ATRLR;
uint32_t Prescalerfactor = TIM_GetPrescaler(_timerObj.handle.Instance) + 1;
uint32_t return_value;
switch (format) {
case MICROSEC_FORMAT:
return_value = (uint32_t)(((ARR_RegisterValue + 1) * Prescalerfactor * 1000000.0) / getTimerClkFreq());
break;
case HERTZ_FORMAT:
return_value = (uint32_t)(getTimerClkFreq() / ((ARR_RegisterValue + 1) * Prescalerfactor));
break;
case TICK_FORMAT:
default :
return_value = ARR_RegisterValue + 1;
break;
}
return return_value;
}
/**
* @brief Set overflow (rollover)
*
* Note that by default, the new value will not be applied
* immediately, but become effective at the next update event
* (usually the next timer overflow). See setPreloadEnable()
* for controlling this behaviour.
* @param overflow: depend on format parameter
* @param format of overflow parameter. If omitted default format is Tick
* TICK_FORMAT: overflow is the number of tick for overflow
* MICROSEC_FORMAT: overflow is the number of microsecondes for overflow
* HERTZ_FORMAT: overflow is the frequency in hertz for overflow
* @retval None
*/
void HardwareTimer::setOverflow(uint32_t overflow, TimerFormat_t format)
{
uint32_t ARR_RegisterValue;
uint32_t PeriodTicks;
uint32_t Prescalerfactor;
uint32_t period_cyc;
// Remark: Hardware register correspond to period count-1. Example ARR register value 9 means period of 10 timer cycle
switch (format) {
case MICROSEC_FORMAT:
period_cyc = overflow * (getTimerClkFreq() / 1000000);
Prescalerfactor = (period_cyc / 0x10000) + 1;
_timerObj.handle.Instance->PSC = Prescalerfactor - 1;
PeriodTicks = period_cyc / Prescalerfactor;
break;
case HERTZ_FORMAT:
period_cyc = getTimerClkFreq() / overflow;
Prescalerfactor = (period_cyc / 0x10000) + 1;
_timerObj.handle.Instance->PSC = Prescalerfactor - 1;
PeriodTicks = period_cyc / Prescalerfactor;
break;
case TICK_FORMAT:
default :
PeriodTicks = overflow;
break;
}
if (PeriodTicks > 0) {
// The register specifies the maximum value, so the period is really one tick longer
ARR_RegisterValue = PeriodTicks - 1;
} else {
// But do not underflow in case a zero period was given somehow.
ARR_RegisterValue = 0;
}
_timerObj.handle.Instance->ATRLR = ARR_RegisterValue;
updateRegistersIfNotRunning(_timerObj.handle.Instance);
}
/**
* @brief Retrieve timer counter value
* @param format of returned value. If omitted default format is Tick
* @retval overflow depending on format value:
* TICK_FORMAT: return number of tick for counter
* MICROSEC_FORMAT: return number of microsecondes for counter
* HERTZ_FORMAT: return frequency in hertz for counter
*/
uint32_t HardwareTimer::getCount(TimerFormat_t format)
{
uint32_t CNT_RegisterValue = TIM_GetCounter(_timerObj.handle.Instance);
uint32_t Prescalerfactor = TIM_GetPrescaler(_timerObj.handle.Instance) + 1;
uint32_t return_value;
switch (format) {
case MICROSEC_FORMAT:
return_value = (uint32_t)((CNT_RegisterValue * Prescalerfactor * 1000000.0) / getTimerClkFreq());
break;
case HERTZ_FORMAT:
return_value = (uint32_t)(getTimerClkFreq() / (CNT_RegisterValue * Prescalerfactor));
break;
case TICK_FORMAT:
default :
return_value = CNT_RegisterValue;
break;
}
return return_value;
}
/**
* @brief Set timer counter value
* @param counter: depend on format parameter
* @param format of overflow parameter. If omitted default format is Tick
* TICK_FORMAT: counter is the number of tick
* MICROSEC_FORMAT: counter is the number of microsecondes
* HERTZ_FORMAT: counter is the frequency in hertz
* @retval None
*/
void HardwareTimer::setCount(uint32_t counter, TimerFormat_t format)
{
uint32_t CNT_RegisterValue;
uint32_t Prescalerfactor = TIM_GetPrescaler(_timerObj.handle.Instance) + 1;
switch (format) {
case MICROSEC_FORMAT:
CNT_RegisterValue = ((counter * (getTimerClkFreq() / 1000000)) / Prescalerfactor);
break;
case HERTZ_FORMAT:
CNT_RegisterValue = (uint32_t)(getTimerClkFreq() / (counter * Prescalerfactor));
break;
case TICK_FORMAT:
default :
CNT_RegisterValue = counter;
break;
}
TIM_SetCounter(_timerObj.handle.Instance, CNT_RegisterValue);
}
/**
* @brief Set channel mode
* @param channel: Arduino channel [1..4]
* @param mode: mode configuration for the channel (see TimerModes_t)
* @param pin: Arduino pin number, ex: D1, 1 or PA1
* @retval None
*/
void HardwareTimer::setMode(uint32_t channel, TimerModes_t mode, uint32_t pin)
{
setMode(channel, mode, digitalPinToPinName(pin));
}
/**
* @brief Set channel mode
* @param channel: Arduino channel [1..4]
* @param mode: mode configuration for the channel (see TimerModes_t)
* @param pin: pin name, ex: PB_0
* @retval None
*/
void HardwareTimer::setMode(uint32_t channel, TimerModes_t mode, PinName pin)
{
int timChannel = getChannel(channel); //get arduino channel-->timer channel
int timAssociatedInputChannel;
TIM_OCInitTypeDef channelOC={0};
TIM_ICInitTypeDef channelIC={0};
if (timChannel == -1) {
Error_Handler();
}
/* Configure some default values. Maybe overwritten later */
channelOC.TIM_OCMode = TIMER_NOT_USED; //set default value 0xFFFF
// channelOC.Pulse = __HAL_TIM_GET_COMPARE(&(_timerObj.handle), timChannel); // keep same value already written in hardware register
channelOC.TIM_Pulse = (((timChannel) == TIM_Channel_1) ? (_timerObj.handle.Instance->CH1CVR) :\
((timChannel) == TIM_Channel_2) ? (_timerObj.handle.Instance->CH2CVR) :\
((timChannel) == TIM_Channel_3) ? (_timerObj.handle.Instance->CH3CVR) :\
(_timerObj.handle.Instance->CH4CVR));
channelOC.TIM_OCPolarity = TIM_OCPolarity_High;
#if defined(TIM_OIS1)
channelOC.TIM_OCIdleState = TIM_OSSIState_Disable;
#endif
#if defined(TIM_CC1NE)
channelOC.TIM_OCNPolarity = TIM_OCNPolarity_High;
#if defined(TIM_OIS1N)
channelOC.TIM_OCNIdleState = TIM_OCNIdleState_Reset;
#endif
#endif
channelIC.TIM_ICPolarity = TIM_ICPolarity_Rising;
channelIC.TIM_ICSelection = TIM_ICSelection_DirectTI;
channelIC.TIM_ICPrescaler = TIM_ICPSC_DIV1;
channelIC.TIM_ICFilter = 0;
switch (mode) {
case TIMER_DISABLED:
channelOC.TIM_OCMode = TIM_OCMode_Timing;
TIM_OC_ConfigChannel_Static(_timerObj.handle.Instance, &channelOC, timChannel);
break;
case TIMER_OUTPUT_COMPARE:
/* In case of TIMER_OUTPUT_COMPARE, there is no output and thus no pin to
* configure, and no channel. So nothing to do. For compatibility reason
* restore TIMER_DISABLED if necessary.
*/
if (_ChannelMode[channel - 1] != TIMER_DISABLED) {
_ChannelMode[channel - 1] = TIMER_DISABLED;
channelOC.TIM_OCMode = TIM_OCMode_Timing;
TIM_OC_ConfigChannel_Static(_timerObj.handle.Instance, &channelOC, timChannel);
}
return;
case TIMER_OUTPUT_COMPARE_ACTIVE:
channelOC.TIM_OCMode = TIM_OCMode_Active;
TIM_OC_ConfigChannel_Static(_timerObj.handle.Instance, &channelOC, timChannel);
break;
case TIMER_OUTPUT_COMPARE_INACTIVE:
channelOC.TIM_OCMode = TIM_OCMode_Inactive;
TIM_OC_ConfigChannel_Static(_timerObj.handle.Instance, &channelOC, timChannel);
break;
case TIMER_OUTPUT_COMPARE_TOGGLE:
channelOC.TIM_OCMode = TIM_OCMode_Toggle;
TIM_OC_ConfigChannel_Static(_timerObj.handle.Instance, &channelOC, timChannel);
break;
case TIMER_OUTPUT_COMPARE_PWM1:
channelOC.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OC_ConfigChannel_Static(_timerObj.handle.Instance, &channelOC, timChannel);
break;
case TIMER_OUTPUT_COMPARE_PWM2:
channelOC.TIM_OCMode = TIM_OCMode_PWM2;
TIM_OC_ConfigChannel_Static(_timerObj.handle.Instance, &channelOC, timChannel);
break;
case TIMER_OUTPUT_COMPARE_FORCED_ACTIVE:
channelOC.TIM_OCMode = 0x0050; //force high
TIM_OC_ConfigChannel_Static(_timerObj.handle.Instance, &channelOC, timChannel);
break;
case TIMER_OUTPUT_COMPARE_FORCED_INACTIVE:
channelOC.TIM_OCMode = 0x0040; //force low
TIM_OC_ConfigChannel_Static(_timerObj.handle.Instance, &channelOC, timChannel);
break;
case TIMER_INPUT_CAPTURE_RISING:
channelIC.TIM_ICPolarity = TIM_ICPolarity_Rising;
TIM_IC_ConfigChannel_Static(_timerObj.handle.Instance, &channelIC,timChannel);
break;
case TIMER_INPUT_CAPTURE_FALLING:
channelIC.TIM_ICPolarity = TIM_ICPolarity_Falling;
TIM_IC_ConfigChannel_Static(_timerObj.handle.Instance, &channelIC,timChannel);
break;
case TIMER_INPUT_CAPTURE_BOTHEDGE:
channelIC.TIM_ICPolarity = TIM_ICPolarity_BothEdge;
TIM_IC_ConfigChannel_Static(_timerObj.handle.Instance, &channelIC,timChannel);
break;
case TIMER_INPUT_FREQ_DUTY_MEASUREMENT:
// Configure 1st channel
channelIC.TIM_ICPolarity = TIM_ICPolarity_Rising;
channelIC.TIM_ICSelection = TIM_ICSelection_DirectTI;
TIM_IC_ConfigChannel_Static(_timerObj.handle.Instance, &channelIC, timChannel);
// // Identify and configure 2nd associated channel
timAssociatedInputChannel = getAssociatedChannel(channel);
_ChannelMode[timAssociatedInputChannel - 1] = mode;
channelIC.TIM_ICPolarity = TIM_ICPolarity_Falling;
channelIC.TIM_ICSelection = TIM_ICSelection_IndirectTI;
TIM_IC_ConfigChannel_Static(_timerObj.handle.Instance, &channelIC, timChannel);
break;
default:
break;
}
// Save channel selected mode to object attribute
_ChannelMode[channel - 1] = mode;
if (pin != NC)
{
if ((int)getTimerChannel(pin) == timChannel)
{
/* Configure PWM GPIO pins */
pinmap_pinout(pin, PinMap_TIM);
if ((mode == TIMER_INPUT_CAPTURE_RISING) || (mode == TIMER_INPUT_CAPTURE_FALLING) \
|| (mode == TIMER_INPUT_CAPTURE_BOTHEDGE) || (mode == TIMER_INPUT_FREQ_DUTY_MEASUREMENT))
{
//input alternate function must configure GPIO in input mode
pinMode(pinNametoDigitalPin(pin), INPUT); //set input
}
}
else
{
// Pin doesn't match with timer output channels
Error_Handler();
}
#if defined(TIM_CC1NE)
isComplementaryChannel[channel - 1] = CH_PIN_INVERTED(pinmap_function(pin, PinMap_TIM)); //(x>>20)&0x1
#endif
}
}
/**
* @brief Retrieves channel mode configured
* @param channel: Arduino channel [1..4]
* @retval returns configured mode
*/
TimerModes_t HardwareTimer::getMode(uint32_t channel)
{
if ((1 <= channel) && (channel <= TIMER_CHANNELS)) {
return _ChannelMode[channel - 1];
} else {
return TIMER_DISABLED;
}
}
/**
* @brief Enable or disable preloading for overflow value
* When disabled, changes to the overflow value take effect
* immediately. When enabled (the default), the value takes
* effect only at the next update event (typically the next
* overflow).
*
* Note that the capture/compare register has its own preload
* enable bit, which is independent and enabled in PWM modes
* and disabled otherwise. If you need more control of that
* bit, you can use the HAL functions directly.
* @param value: true to enable preloading, false to disable
* @retval None
*/
void HardwareTimer::setPreloadEnable(bool value)
{
if (value) {
TIM_ARRPreloadConfig( _timerObj.handle.Instance, ENABLE );
} else {
TIM_ARRPreloadConfig( _timerObj.handle.Instance, DISABLE );
}
}
/**
* @brief Set channel Capture/Compare register
* @param channel: Arduino channel [1..4]
* @param compare: compare value depending on format
* @param format of compare parameter. If omitted default format is Tick
* TICK_FORMAT: compare is the number of tick
* MICROSEC_FORMAT: compare is the number of microsecondes
* HERTZ_FORMAT: compare is the frequency in hertz
* @retval None
*/
void HardwareTimer::setCaptureCompare(uint32_t channel, uint32_t compare, TimerCompareFormat_t format)
{
int timChannel = getChannel(channel);
uint32_t Prescalerfactor = TIM_GetPrescaler(_timerObj.handle.Instance) + 1;
uint32_t CCR_RegisterValue;
if (timChannel == -1) {
Error_Handler();
}
switch (format) {
case MICROSEC_COMPARE_FORMAT:
CCR_RegisterValue = ((compare * (getTimerClkFreq() / 1000000)) / Prescalerfactor);
break;
case HERTZ_COMPARE_FORMAT:
CCR_RegisterValue = getTimerClkFreq() / (compare * Prescalerfactor);
break;
// As per Reference Manual PWM reach 100% with CCRx value strictly greater than ARR (So ARR+1 in our case)
case PERCENT_COMPARE_FORMAT:
CCR_RegisterValue = ((_timerObj.handle.Instance->ATRLR + 1) * compare) / 100;
break;
case RESOLUTION_1B_COMPARE_FORMAT:
case RESOLUTION_2B_COMPARE_FORMAT:
case RESOLUTION_3B_COMPARE_FORMAT:
case RESOLUTION_4B_COMPARE_FORMAT:
case RESOLUTION_5B_COMPARE_FORMAT:
case RESOLUTION_6B_COMPARE_FORMAT:
case RESOLUTION_7B_COMPARE_FORMAT:
case RESOLUTION_8B_COMPARE_FORMAT:
case RESOLUTION_9B_COMPARE_FORMAT:
case RESOLUTION_10B_COMPARE_FORMAT:
case RESOLUTION_11B_COMPARE_FORMAT:
case RESOLUTION_12B_COMPARE_FORMAT:
case RESOLUTION_13B_COMPARE_FORMAT:
case RESOLUTION_14B_COMPARE_FORMAT:
case RESOLUTION_15B_COMPARE_FORMAT:
case RESOLUTION_16B_COMPARE_FORMAT:
CCR_RegisterValue = (( _timerObj.handle.Instance->ATRLR + 1 ) * compare ) / ( (1 << format) -1 );
break;
case TICK_COMPARE_FORMAT:
default :
CCR_RegisterValue = compare;
break;
}
// Special case when ARR is set to the max value, it is not possible to set CCRx to ARR+1 to reach 100%
// Then set CCRx to max value. PWM is then 1/0xFFFF = 99.998..%
if( (( _timerObj.handle.Instance->ATRLR ) == MAX_RELOAD) && (CCR_RegisterValue == MAX_RELOAD + 1))
{
CCR_RegisterValue = MAX_RELOAD;
}
switch (timChannel)
{
case TIM_Channel_1:
TIM_SetCompare1( _timerObj.handle.Instance, CCR_RegisterValue );
break;
case TIM_Channel_2:
TIM_SetCompare2( _timerObj.handle.Instance, CCR_RegisterValue );
break;
case TIM_Channel_3:
TIM_SetCompare3( _timerObj.handle.Instance, CCR_RegisterValue );
break;
case TIM_Channel_4:
TIM_SetCompare4( _timerObj.handle.Instance, CCR_RegisterValue );
break;
default:
break;
}
updateRegistersIfNotRunning(_timerObj.handle.Instance);
}
/**
* @brief Retrieve Capture/Compare value
* @param channel: Arduino channel [1..4]
* @param format of return value. If omitted default format is Tick
* TICK_FORMAT: return value is the number of tick for Capture/Compare value
* MICROSEC_FORMAT: return value is the number of microsecondes for Capture/Compare value
* HERTZ_FORMAT: return value is the frequency in hertz for Capture/Compare value
* @retval Capture/Compare value
*/
uint32_t HardwareTimer::getCaptureCompare(uint32_t channel, TimerCompareFormat_t format)
{
int timChannel;
uint32_t return_value;
uint32_t CCR_RegisterValue;
uint32_t Prescalerfactor;
timChannel = getChannel(channel);
Prescalerfactor = TIM_GetPrescaler(_timerObj.handle.Instance) + 1;
if (timChannel == -1) {
Error_Handler();
}
switch(timChannel)
{
case TIM_Channel_1:
CCR_RegisterValue = (_timerObj.handle.Instance->CH1CVR);
break;
case TIM_Channel_2:
CCR_RegisterValue = (_timerObj.handle.Instance->CH2CVR);
break;
case TIM_Channel_3:
CCR_RegisterValue = (_timerObj.handle.Instance->CH3CVR);
break;
case TIM_Channel_4:
CCR_RegisterValue = (_timerObj.handle.Instance->CH4CVR);
break;
default:
break;
}
switch (format) {
case MICROSEC_COMPARE_FORMAT:
return_value = (uint32_t)((CCR_RegisterValue * Prescalerfactor * 1000000.0) / getTimerClkFreq());
break;
case HERTZ_COMPARE_FORMAT:
return_value = (uint32_t)(getTimerClkFreq() / (CCR_RegisterValue * Prescalerfactor));
break;
case PERCENT_COMPARE_FORMAT:
return_value = (CCR_RegisterValue * 100) / _timerObj.handle.Instance->ATRLR;
break;
case RESOLUTION_1B_COMPARE_FORMAT:
case RESOLUTION_2B_COMPARE_FORMAT:
case RESOLUTION_3B_COMPARE_FORMAT:
case RESOLUTION_4B_COMPARE_FORMAT:
case RESOLUTION_5B_COMPARE_FORMAT:
case RESOLUTION_6B_COMPARE_FORMAT:
case RESOLUTION_7B_COMPARE_FORMAT:
case RESOLUTION_8B_COMPARE_FORMAT:
case RESOLUTION_9B_COMPARE_FORMAT:
case RESOLUTION_10B_COMPARE_FORMAT:
case RESOLUTION_11B_COMPARE_FORMAT:
case RESOLUTION_12B_COMPARE_FORMAT:
case RESOLUTION_13B_COMPARE_FORMAT:
case RESOLUTION_14B_COMPARE_FORMAT:
case RESOLUTION_15B_COMPARE_FORMAT:
case RESOLUTION_16B_COMPARE_FORMAT:
return_value = (CCR_RegisterValue * ((1 << format) - 1)) / _timerObj.handle.Instance->ATRLR ;
break;
case TICK_COMPARE_FORMAT:
default :
return_value = CCR_RegisterValue;
break;
}
return return_value;
}
/**
* @param channel: Arduino channel [1..4]
* @param pin: Arduino pin number, ex D1, 1 or PA1
* @param frequency: PWM frequency expressed in hertz
* @param dutycycle: PWM dutycycle expressed in percentage
* @param PeriodCallback: timer period callback (timer rollover upon update event)
* @param CompareCallback: timer compare callback
* @retval None
*/
void HardwareTimer::setPWM(uint32_t channel, uint32_t pin, uint32_t frequency, uint32_t dutycycle, callback_function_t PeriodCallback, callback_function_t CompareCallback)
{
setPWM(channel, digitalPinToPinName(pin), frequency, dutycycle, PeriodCallback, CompareCallback);
}
/**
* @brief All in one function to configure PWM
* @param channel: Arduino channel [1..4]
* @param pin: pin name, ex PB_0
* @param frequency: PWM frequency expressed in hertz
* @param dutycycle: PWM dutycycle expressed in percentage
* @param PeriodCallback: timer period callback (timer rollover upon update event)
* @param CompareCallback: timer compare callback
* @retval None
*/
void HardwareTimer::setPWM(uint32_t channel, PinName pin, uint32_t frequency, uint32_t dutycycle, callback_function_t PeriodCallback, callback_function_t CompareCallback)
{
setMode(channel, TIMER_OUTPUT_COMPARE_PWM1, pin);
setOverflow(frequency, HERTZ_FORMAT);
setCaptureCompare(channel, dutycycle, PERCENT_COMPARE_FORMAT);
if (PeriodCallback) {
attachInterrupt(PeriodCallback);
}
if (CompareCallback) {
attachInterrupt(channel, CompareCallback);
}
resume();
}
/**
* @brief Set the priority of the interrupt
* @note Must be call before resume()
* @param preemptPriority: the pre-emption priority for the IRQn channel
* @param subPriority: the subpriority level for the IRQ channel.
* @retval None
*/
void HardwareTimer::setInterruptPriority(uint32_t preemptPriority, uint32_t subPriority)
{
// Set Update interrupt priority for immediate use
NVIC_SetPriority( getTimerUpIrq(_timerObj.handle.Instance), ((preemptPriority & 0x1) << 7 ) | subPriority );
// Set Capture/Compare interrupt priority if timer provides a unique IRQ
if (getTimerCCIrq(_timerObj.handle.Instance) != getTimerUpIrq(_timerObj.handle.Instance)) {
NVIC_SetPriority( getTimerCCIrq(_timerObj.handle.Instance), ((preemptPriority & 0x1) << 7 ) | subPriority );
}
// Store priority for use if timer is re-initialized
_timerObj.preemptPriority = preemptPriority;
_timerObj.subPriority = subPriority;
}
/**
* @brief Attach interrupt callback on update (rollover) event
* @param callback: interrupt callback
* @retval None
*/
void HardwareTimer::attachInterrupt(callback_function_t callback)
{
if (callbacks[0]) {
// Callback previously configured : do not clear neither enable IT, it is just a change of callback
callbacks[0] = callback;
} else {
callbacks[0] = callback;
if (callback) {
// Clear flag before enabling IT
TIM_ClearFlag(_timerObj.handle.Instance,TIM_FLAG_Update);
TIM_ITConfig(_timerObj.handle.Instance,TIM_IT_Update,ENABLE);
}
}
}
/**
* @brief Detach interrupt callback on update (rollover) event
* @retval None
*/
void HardwareTimer::detachInterrupt()
{
// Disable update interrupt and clear callback
TIM_ITConfig(_timerObj.handle.Instance,TIM_IT_Update,DISABLE);
callbacks[0] = NULL;
}
/**
* @brief Attach interrupt callback on Capture/Compare event
* @param channel: Arduino channel [1..4]
* @param callback: interrupt callback
* @retval None
*/
void HardwareTimer::attachInterrupt(uint32_t channel, callback_function_t callback)
{
int interrupt = getIT(channel);
if (interrupt == -1) {
Error_Handler();
}
if ((channel == 0) || (channel > (TIMER_CHANNELS + 1))) {
Error_Handler(); // only channel 1..4 have an interrupt
}
if (callbacks[channel]) {
// Callback previously configured : do not clear neither enable IT, it is just a change of callback
callbacks[channel] = callback;
} else {
callbacks[channel] = callback;
if (callback) {
// Clear flag before enabling IT
TIM_ClearFlag( _timerObj.handle.Instance, interrupt);
// Enable interrupt corresponding to channel, only if callback is valid
TIM_ITConfig(_timerObj.handle.Instance,interrupt,ENABLE);
}
}
}
/**
* @brief Detach interrupt callback on Capture/Compare event
* @param channel: Arduino channel [1..4]
* @retval None
*/
void HardwareTimer::detachInterrupt(uint32_t channel)
{
int interrupt = getIT(channel);
if (interrupt == -1) {
Error_Handler();
}
if ((channel == 0) || (channel > (TIMER_CHANNELS + 1))) {
Error_Handler(); // only channel 1..4 have an interrupt
}
// Disable interrupt corresponding to channel and clear callback
TIM_ITConfig(_timerObj.handle.Instance,interrupt,DISABLE);
callbacks[channel] = NULL;
}
/**
* @brief Checks if there's an interrupt callback attached on Rollover event
* @retval returns true if a timer rollover interrupt has already been set
*/
bool HardwareTimer::hasInterrupt()
{
return callbacks[0] != NULL;
}
/**
* @brief Checks if there's an interrupt callback attached on Capture/Compare event
* @param channel: Arduino channel [1..4]
* @retval returns true if a channel compare match interrupt has already been set
*/
bool HardwareTimer::hasInterrupt(uint32_t channel)
{
if ((channel == 0) || (channel > (TIMER_CHANNELS + 1))) {
Error_Handler(); // only channel 1..4 have an interrupt
}
return callbacks[channel] != NULL;
}
/**
* @brief Generate an update event to force all registers (Autoreload, prescaler, compare) to be taken into account
* @note @note Refresh() can only be called after timer has been initialized,
either by calling setup() function or thanks to constructor with TIM instance parameter.
* It is useful while timer is running after some registers update
* @retval None
*/
void HardwareTimer::refresh()
{
TIM_GenerateEvent( _timerObj.handle.Instance,TIM_EventSource_Update );
}
/**
* @brief Return the timer object handle object for more advanced setup
* @note Using this function and editing the Timer handle is at own risk! No support will
* be provided whatsoever if the HardwareTimer does not work as expected when editing
* the handle using the HAL functionality or other custom coding.
* @retval TIM_HandleTypeDef address
*/
TIM_HandleTypeDef *HardwareTimer::getHandle()
{
return &_timerObj.handle;
}
/**
* @brief Generic Update (rollover) callback which will call user callback
* @param htim: HAL timer handle
* @retval None
*/
void HardwareTimer::updateCallback(TIM_HandleTypeDef *htim)
{
if (!htim) {
Error_Handler();
}
if(TIM_GetITStatus(htim->Instance, TIM_IT_Update) && (htim->Instance->DMAINTENR & TIM_IT_Update))
{
timerObj_t *obj = get_timer_obj(htim);
HardwareTimer *HT = (HardwareTimer *)(obj->__this);
if (HT->callbacks[0]) {
HT->callbacks[0]();
}
TIM_ClearITPendingBit(htim->Instance, TIM_IT_Update);
}
}
/**
* @brief Generic Capture and Compare callback which will call user callback
* @param htim: HAL timer handle
* @retval None
*/
void HardwareTimer::captureCompareCallback(TIM_HandleTypeDef *htim)
{
if (!htim) {
Error_Handler();
}
uint32_t channel ;
if( (htim->Instance->DMAINTENR & TIM_IT_CC1) || (htim->Instance->DMAINTENR & TIM_IT_CC2) \
|| (htim->Instance->DMAINTENR & TIM_IT_CC3) || (htim->Instance->DMAINTENR & TIM_IT_CC4) )
{
if( TIM_GetITStatus(htim->Instance, TIM_IT_CC1) )
{
channel = 1;
TIM_ClearITPendingBit( htim->Instance, TIM_IT_CC1);
}
else if(TIM_GetITStatus(htim->Instance, TIM_IT_CC2) )
{
channel = 2;
TIM_ClearITPendingBit( htim->Instance, TIM_IT_CC2);
}
else if(TIM_GetITStatus(htim->Instance, TIM_IT_CC3) )
{
channel = 3;
TIM_ClearITPendingBit( htim->Instance, TIM_IT_CC3);
}
else if(TIM_GetITStatus(htim->Instance, TIM_IT_CC4) )
{
channel = 4;
TIM_ClearITPendingBit( htim->Instance, TIM_IT_CC4);
}
timerObj_t *obj = get_timer_obj(htim);
HardwareTimer *HT = (HardwareTimer *)(obj->__this);
if (HT->callbacks[channel]) {
HT->callbacks[channel]();
}
}
}
/**
* @brief Check whether HardwareTimer is running (paused or resumed).
* @retval return true if the HardwareTimer is running
*/
bool HardwareTimer::isRunning()
{
// return LL_TIM_IsEnabledCounter(_timerObj.handle.Instance);
return (((_timerObj.handle.Instance->CTLR1 & TIM_CEN) == TIM_CEN)? 1UL : 0UL) ;
}
/**
* @brief Check whether channel is running (paused or resumed).
* @param channel: Arduino channel [1..4]
* @retval return true if HardwareTimer is running and the channel is enabled
*/
bool HardwareTimer::isRunningChannel(uint32_t channel)
{
int LLChannel = getLLChannel(channel);
int interrupt = getIT(channel);
bool ret;
if (LLChannel == -1) {
Error_Handler();
}
if (interrupt == -1) {
Error_Handler();
}
// channel is running if: timer is running, and either output channel is
// enabled or interrupt is set
ret = ((_timerObj.handle.Instance->CCER & LLChannel) == LLChannel ? 1UL : 0UL) \
|| ((_timerObj.handle.Instance->DMAINTENR & interrupt) == interrupt ? 1UL : 0UL) ;
return (isRunning() && ret);
}
/**
* @brief Take into account registers update immediately if timer is not running,
* (independently from Preload setting)
* @param TIMx Timer instance
* @retval None
*/
void HardwareTimer::updateRegistersIfNotRunning(TIM_TypeDef *TIMx)
{
if (!isRunning()) {
if (_timerObj.handle.Instance->DMAINTENR & TIM_IT_Update)
{
// prevent Interrupt generation from refresh()
TIM_ITConfig(_timerObj.handle.Instance, TIM_IT_Update, DISABLE);
refresh( );
TIM_ClearFlag(_timerObj.handle.Instance, TIM_IT_Update);
TIM_ITConfig(_timerObj.handle.Instance, TIM_IT_Update, ENABLE);
} else {
refresh();
}
}
}
/**
* @brief HardwareTimer destructor
* @retval None
*/
HardwareTimer::~HardwareTimer()
{
uint32_t index = get_timer_index(_timerObj.handle.Instance);
disableTimerClock(&(_timerObj.handle));
HardwareTimer_Handle[index] = NULL;
_timerObj.__this = NULL;
}
/**
* @brief return timer index from timer handle
* @param htim : one of the defined timer
* @retval timer index
*/
timer_index_t get_timer_index(TIM_TypeDef *instance)
{
timer_index_t index = UNKNOWN_TIMER;
#if defined(TIM1_BASE)
if (instance == TIM1) {
index = TIMER1_INDEX;
}
#endif
#if defined(TIM2_BASE)
if (instance == TIM2) {
index = TIMER2_INDEX;
}
#endif
#if defined(TIM3_BASE)
if (instance == TIM3) {
index = TIMER3_INDEX;
}
#endif
#if defined(TIM4_BASE)
if (instance == TIM4) {
index = TIMER4_INDEX;
}
#endif
#if defined(TIM5_BASE)
if (instance == TIM5) {
index = TIMER5_INDEX;
}
#endif
#if defined(TIM6_BASE)
if (instance == TIM6) {
index = TIMER6_INDEX;
}
#endif
#if defined(TIM7_BASE)
if (instance == TIM7) {
index = TIMER7_INDEX;
}
#endif
#if defined(TIM8_BASE)
if (instance == TIM8) {
index = TIMER8_INDEX;
}
#endif
#if defined(TIM9_BASE)
if (instance == TIM9) {
index = TIMER9_INDEX;
}
#endif
#if defined(TIM10_BASE)
if (instance == TIM10) {
index = TIMER10_INDEX;
}
#endif
return index;
}
/**
* @brief This function return the timer clock frequency.
* @param None
* @retval frequency in Hz
*/
uint32_t HardwareTimer::getTimerClkFreq()
{
RCC_ClocksTypeDef RCC_ClocksStatus={};
uint32_t uwTimclock = 0U, uwAPBxPrescaler = 0U;
/* Get clock configuration */
RCC_GetClocksFreq(&RCC_ClocksStatus);
#if !defined(CH32V00x) && !defined(CH32X035)
switch (getTimerClkSrc(_timerObj.handle.Instance))
{
case 1:
uwAPBxPrescaler = (RCC->CFGR0 & RCC_PPRE1) >> 8;
uwTimclock = RCC_ClocksStatus.PCLK1_Frequency;
break;
case 2:
uwAPBxPrescaler = (RCC->CFGR0 & RCC_PPRE2) >> 11;
uwTimclock = RCC_ClocksStatus.PCLK2_Frequency;
break;
default:
case 0: // Unknown timer clock source
Error_Handler();
break;
}
switch(uwAPBxPrescaler & 0x7)
{
case 0x4:
uwAPBxPrescaler = 2;
break;
case 0x5:
uwAPBxPrescaler = 4;
break;
case 0x6:
uwAPBxPrescaler = 8;
break;
case 0x7:
uwAPBxPrescaler = 16;
break;
default:
uwAPBxPrescaler = 1;
break;
}
#else //CH32V003 and CH32X035 are equal to AHB CLOCK
uwAPBxPrescaler = 1;
uwTimclock = RCC_ClocksStatus.HCLK_Frequency;
#endif
switch (uwAPBxPrescaler)
{
default:
case 1:
uwTimclock*=1;
break;
case 2:
case 4:
case 8:
case 16:
uwTimclock *= 2;
break;
}
return uwTimclock;
}
/**
* @brief This function will reset the timer
* @param None
* @retval None
*/
void HardwareTimer::timerHandleDeinit()
{
TIM_Cmd(_timerObj.handle.Instance, DISABLE);
TIM_DeInit(_timerObj.handle.Instance);
}
/******************************************************************************/
/* TIMx IRQ HANDLER */
/******************************************************************************/
extern "C" {
#if defined(TIM1_BASE)
/**
* @brief TIM1 IRQHandler
* @param None
* @retval None
*/
void TIM1_UP_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM1_UP_IRQHandler(void)
{
if (HardwareTimer_Handle[TIMER1_INDEX]) {
HardwareTimer::updateCallback(&HardwareTimer_Handle[TIMER1_INDEX]->handle);
}
}
void TIM1_CC_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM1_CC_IRQHandler(void)
{
if (HardwareTimer_Handle[TIMER1_INDEX]) {
HardwareTimer::captureCompareCallback(&HardwareTimer_Handle[TIMER1_INDEX]->handle);
}
}
#endif //TIM1_BASE
#if defined(TIM2_BASE)
/**
* @brief TIM2 IRQHandler
* @param None
* @retval None
*/
void TIM2_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM2_IRQHandler(void)
{
if (HardwareTimer_Handle[TIMER2_INDEX])
{
// HAL_TIM_IRQHandler(&HardwareTimer_Handle[TIMER2_INDEX]->handle);
HardwareTimer::updateCallback(&HardwareTimer_Handle[TIMER2_INDEX]->handle);
HardwareTimer::captureCompareCallback(&HardwareTimer_Handle[TIMER2_INDEX]->handle);
}
}
#endif //TIM2_BASE
#if defined(TIM3_BASE)
/**
* @brief TIM3 IRQHandler
* @param None
* @retval None
*/
void TIM3_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM3_IRQHandler(void)
{
if (HardwareTimer_Handle[TIMER3_INDEX]) {
// HAL_TIM_IRQHandler(&HardwareTimer_Handle[TIMER3_INDEX]->handle);
HardwareTimer::updateCallback(&HardwareTimer_Handle[TIMER3_INDEX]->handle);
HardwareTimer::captureCompareCallback(&HardwareTimer_Handle[TIMER3_INDEX]->handle);
}
}
#endif //TIM3_BASE
#if defined(TIM4_BASE)
/**
* @brief TIM4 IRQHandler
* @param None
* @retval None
*/
void TIM4_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM4_IRQHandler(void)
{
if (HardwareTimer_Handle[TIMER4_INDEX]) {
// HAL_TIM_IRQHandler(&HardwareTimer_Handle[TIMER4_INDEX]->handle);
HardwareTimer::updateCallback(&HardwareTimer_Handle[TIMER4_INDEX]->handle);
HardwareTimer::captureCompareCallback(&HardwareTimer_Handle[TIMER4_INDEX]->handle);
}
}
#endif //TIM4_BASE
#if defined(TIM5_BASE)
/**
* @brief TIM5 IRQHandler
* @param None
* @retval None
*/
void TIM5_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM5_IRQHandler(void)
{
if (HardwareTimer_Handle[TIMER5_INDEX]) {
// HAL_TIM_IRQHandler(&HardwareTimer_Handle[TIMER5_INDEX]->handle);
HardwareTimer::updateCallback(&HardwareTimer_Handle[TIMER5_INDEX]->handle);
HardwareTimer::captureCompareCallback(&HardwareTimer_Handle[TIMER5_INDEX]->handle);
}
}
#endif //TIM5_BASE
#if defined(TIM6_BASE)
/**
* @brief TIM6 IRQHandler
* @param None
* @retval None
*/
void TIM6_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM6_IRQHandler(void)
{
if (HardwareTimer_Handle[TIMER6_INDEX]) {
HardwareTimer::updateCallback(&HardwareTimer_Handle[TIMER6_INDEX]->handle);
HardwareTimer::captureCompareCallback(&HardwareTimer_Handle[TIMER6_INDEX]->handle);
}
}
#endif //TIM6_BASE
#if defined(TIM7_BASE)
/**
* @brief TIM7 IRQHandler
* @param None
* @retval None
*/
void TIM7_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM7_IRQHandler(void)
{
if (HardwareTimer_Handle[TIMER7_INDEX]) {
// HAL_TIM_IRQHandler(&HardwareTimer_Handle[TIMER7_INDEX]->handle);
HardwareTimer::updateCallback(&HardwareTimer_Handle[TIMER7_INDEX]->handle);
HardwareTimer::captureCompareCallback(&HardwareTimer_Handle[TIMER7_INDEX]->handle);
}
}
#endif //TIM7_BASE
#if defined(TIM8_BASE)
/**
* @brief TIM8 IRQHandler
* @param None
* @retval None
*/
void TIM8_UP_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM8_UP_IRQHandler(void)
{
if (HardwareTimer_Handle[TIMER8_INDEX]) {
// HAL_TIM_IRQHandler(&HardwareTimer_Handle[TIMER8_INDEX]->handle);
HardwareTimer::updateCallback(&HardwareTimer_Handle[TIMER8_INDEX]->handle);
}
}
void TIM8_CC_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM8_CC_IRQHandler(void)
{
if (HardwareTimer_Handle[TIMER8_INDEX]) {
// HAL_TIM_IRQHandler(&HardwareTimer_Handle[TIMER8_INDEX]->handle);
HardwareTimer::captureCompareCallback(&HardwareTimer_Handle[TIMER8_INDEX]->handle);
}
}
#endif //TIM8_BASE
#if defined(TIM9_BASE)
/**
* @brief TIM9 IRQHandler
* @param None
* @retval None
*/
void TIM9_UP_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM9_UP_IRQHandler(void)
{
if (HardwareTimer_Handle[TIMER9_INDEX]) {
// HAL_TIM_IRQHandler(&HardwareTimer_Handle[TIMER9_INDEX]->handle);
HardwareTimer::updateCallback(&HardwareTimer_Handle[TIMER9_INDEX]->handle);
}
}
void TIM9_CC_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM9_CC_IRQHandler(void)
{
if(HardwareTimer_Handle[TIMER9_INDEX]){
HardwareTimer::captureCompareCallback(&HardwareTimer_Handle[TIMER9_INDEX]->handle);
}
}
#endif //TIM9_BASE
#if defined(TIM10_BASE)
/**
* @brief TIM10 IRQHandler
* @param None
* @retval None
*/
void TIM10_UP_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM10_UP_IRQHandler(void)
{
if (HardwareTimer_Handle[TIMER10_INDEX]) {
// HAL_TIM_IRQHandler(&HardwareTimer_Handle[TIMER10_INDEX]->handle);
HardwareTimer::updateCallback(&HardwareTimer_Handle[TIMER10_INDEX]->handle);
}
}
void TIM10_CC_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM10_CC_IRQHandler(void)
{
if (HardwareTimer_Handle[TIMER10_INDEX]){
HardwareTimer::captureCompareCallback(&HardwareTimer_Handle[TIMER10_INDEX]->handle);
}
}
#endif //TIM10_BASE
}
#endif // TIM_MODULE_ENABLED && !TIM_MODULE_ONLY
Reference in New Issue View Git Blame Copy Permalink