void TIM4_IRQHandler(void)
{
TIM_ClearITPendingBit(TIM4, TIM_IT_CC2); //Zeruj flagê przerwania
cnt = TIM_GetCapture2(TIM4); //odczytaj wartoæ z rejestru CCR kana³u nr 2
if (cnt != 0)
{
my_wyp = (TIM_GetCapture1(TIM4) * 100) / cnt; // wype³nienie
my_frq = 72000000 / cnt;
}
else
{
my_wyp = 0;
my_frq = 0;
}
}
/*******************************************************************************
* Function Name : TIM2_IRQHandler
* Description : This function handles TIM2 global interrupt request.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void TIM2_IRQHandler(void)
{
u16 capture;
if(TIM_GetITStatus(TIM2,TIM_IT_Update) != RESET)
{
GPIOD->ODR ^= ((u32)1<<7);
TIM_ClearITPendingBit(TIM2,TIM_IT_Update);
}
if(TIM_GetITStatus(TIM2,TIM_IT_CC2) != RESET)
{
//GPIOD->ODR ^= ((u32)1<<7);
TIM_ClearITPendingBit(TIM2,TIM_IT_CC2);
capture = TIM_GetCapture2(TIM2);
TIM_SetCounter(TIM2,0);
}
}
/**
* @brief This function handles TIM1 Break and TIM9 interrupts request.
* @param None
* @retval None
*/
void TIM1_BRK_TIM9_IRQHandler(void)
{
/* TIM9_CH1 toggling with frequency = 366.2 Hz */
if (TIM_GetITStatus(TIM9, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM9, TIM_IT_CC1 );
capture = TIM_GetCapture1(TIM9);
TIM_SetCompare1(TIM9, capture + CCR1Val );
}
/* TIM9_CH2 toggling with frequency = 732.4 Hz */
if (TIM_GetITStatus(TIM9, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM9, TIM_IT_CC2);
capture = TIM_GetCapture2(TIM9);
TIM_SetCompare2(TIM9, capture + CCR2Val);
}
}
void TIM2_IRQHandler(void)
{
u8 j=0;
colcnt++;
if (TIM_GetITStatus(TIM2, TIM_IT_Update) == SET)
{
TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
}
// IC2Value = TIM_GetCapture2(TIM2);
// IC1Value = TIM_GetCapture1(TIM2) ; //读取IC2捕获寄存器的值，即为PWM周期的计数值
else if (TIM_GetITStatus(TIM2,TIM_IT_CC2) == SET)
{
//计算PWM频率。
// if(Capflag==0)
// {
IC2Value = TIM_GetCapture2(TIM2);
// Capflag=1;
// }
// else if(Capflag==1)
// {
IC1Value = TIM_GetCapture1(TIM2) ; //读取IC2捕获寄存器的值，即为PWM周期的计数值
// Capflag=0;
// }
DutyCycle = 2000*(IC1Value)/(IC2Value) ;
if(DutyCycle!=0)
CO2sum[99] = DutyCycle;
for(j=0;j<99;j++)
{
CO2sum[j] = CO2sum[j+1];
}
TIM_ClearITPendingBit(TIM2, TIM_IT_CC2);
}
Tim2SP() ;
}
void TIM2_IRQHandler(void)
{
uint16_t val =0,i=0;
for(i=0;i<2;i++){
if (Channels[i].tim == TIM2 && (TIM_GetITStatus(TIM2, Channels[i].cc) == SET)){
TIM_ClearITPendingBit(TIM2, Channels[i].cc);
switch (Channels[i].channel)
{
case TIM_Channel_1:
val = TIM_GetCapture1(TIM2);
break;
case TIM_Channel_2:
val = TIM_GetCapture2(TIM2);
break;
}
if (Inputs[i].state == 0)
Inputs[i].rise = val;
else
Inputs[i].fall = val;
if (Inputs[i].state == 0) {
Inputs[i].state = 1;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling;
TIM_ICInitStructure.TIM_Channel = Channels[i].channel;
TIM_ICInit(TIM2, &TIM_ICInitStructure);
}else{
if(Inputs[i].fall > Inputs[i].rise ){
val = (Inputs[i].fall - Inputs[i].rise);
if(val < 2100 && val>900)
Inputs[i].capture = val;
}else{
val = ((0xffff - Inputs[i].rise) + Inputs[i].fall);
if(val < 2100 && val>900)
Inputs[i].capture = val;
}
Inputs[i].state = 0;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
TIM_ICInitStructure.TIM_Channel = Channels[i].channel;
TIM_ICInit(TIM2, &TIM_ICInitStructure);
}
}
}
}
void TIM3_IRQHandler(void)
{
if (TIM_GetITStatus(PULSE_TIMER, TIM_IT_CC2) != RESET)
{
int capture = TIM_GetCapture2(PULSE_TIMER);
TIM_SetCompare3(PULSE_TIMER, (uint16_t) (capture - 1));
TIM_ClearITPendingBit(PULSE_TIMER, TIM_IT_CC2);
if (CaptureService != NULL)
{
CaptureService(capture);
}
}
if (TIM_GetITStatus(PULSE_TIMER, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(PULSE_TIMER, TIM_IT_CC3);
if (CaptureOverflowService != NULL)
{
CaptureOverflowService();
}
}
}
void TIM4_Tone_Interrupt_Handler(void)
{
uint16_t capture;
if (TIM_GetITStatus(TIM4, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM4, TIM_IT_CC1 );
capture = TIM_GetCapture1(TIM4);
TIM_SetCompare1(TIM4, capture + PIN_MAP[1].timer_ccr);
if(PIN_MAP[1].user_property != -1)
{
if (PIN_MAP[1].user_property > 0)
{
PIN_MAP[1].user_property -= 1;
}
else
{
noTone(1);
}
}
}
if (TIM_GetITStatus(TIM4, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM4, TIM_IT_CC2);
capture = TIM_GetCapture2(TIM4);
TIM_SetCompare2(TIM4, capture + PIN_MAP[0].timer_ccr);
if(PIN_MAP[0].user_property != -1)
{
if (PIN_MAP[0].user_property > 0)
{
PIN_MAP[0].user_property -= 1;
}
else
{
noTone(0);
}
}
}
}
/**
* @brief This function handles TIM2 global interrupt request.
* @param None
* @retval None
*/
void TIM2_IRQHandler(void)
{
if (TIM_GetITStatus(TIM2, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC1);
/* Pin PC.00 toggling with frequency = 390 Hz */
GPIO_WriteBit(GPIOC, GPIO_Pin_0, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_0)));
capture = TIM_GetCapture1(TIM2);
TIM_SetCompare1(TIM2, capture + CCR1_Val);
}
else if (TIM_GetITStatus(TIM2, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC2);
/* Pin PC.01 toggling with frequency = 585 Hz */
GPIO_WriteBit(GPIOC, GPIO_Pin_1, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_1)));
capture = TIM_GetCapture2(TIM2);
TIM_SetCompare2(TIM2, capture + CCR2_Val);
}
else if (TIM_GetITStatus(TIM2, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC3);
/* Pin PC.02 toggling with frequency = 1.17 KHz */
GPIO_WriteBit(GPIOC, GPIO_Pin_2, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_2)));
capture = TIM_GetCapture3(TIM2);
TIM_SetCompare3(TIM2, capture + CCR3_Val);
}
else
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC4);
/* Pin PC.03 toggling with frequency = 2.34 KHz */
GPIO_WriteBit(GPIOC, GPIO_Pin_3, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_3)));
capture = TIM_GetCapture4(TIM2);
TIM_SetCompare4(TIM2, capture + CCR4_Val);
}
}
/**
* @brief This function handles TIM3 global interrupt request.
* @param None
* @retval None
*/
void TIM3_IRQHandler(void)
{
if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1);
/* LED1 toggling with frequency = 73.24 Hz */
STM_EVAL_LEDToggle(LED1);
capture = TIM_GetCapture1(TIM3);
TIM_SetCompare1(TIM3, capture + CCR1_Val);
}
else if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
/* LED2 toggling with frequency = 109.8 Hz */
STM_EVAL_LEDToggle(LED2);
capture = TIM_GetCapture2(TIM3);
TIM_SetCompare2(TIM3, capture + CCR2_Val);
}
else if (TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
/* LED3 toggling with frequency = 219.7 Hz */
STM_EVAL_LEDToggle(LED3);
capture = TIM_GetCapture3(TIM3);
TIM_SetCompare3(TIM3, capture + CCR3_Val);
}
else
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);
/* LED4 toggling with frequency = 439.4 Hz */
STM_EVAL_LEDToggle(LED4);
capture = TIM_GetCapture4(TIM3);
TIM_SetCompare4(TIM3, capture + CCR4_Val);
}
}
// PWM input handler
void TIM3_IRQHandler(void)
{
// TIM2 in STM32F3 is a 32 bit timer, to use 16 bit timer, we should change the data type to uint16_t
timer_val_t diff;
static timer_val_t now;
static timer_val_t last = 0;
static uint32_t chan = 0;
if (TIM_GetITStatus(TIM3, TIM_IT_CC2) == SET){
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
last = now;
now = TIM_GetCapture2(TIM2);
diff = now - last; // auto overflow
if(diff > MAX_PULSE*PRESCALER/SYSFREQ_MHz ){
chn_count = chan;
chan = 0;
}else{
pwm_intputs[chan % MAX_CHN_CNT] = (uint16_t)(diff*PRESCALER/SYSFREQ_MHz);
if(chan < MAX_CHN_CNT)
chan++;
}
}
}
//LHL
void LHL_2_execute(uint16_t time) // time = time*0.1 (ms)
{
static uint16_t ticker = 0;
if ((uint16_t)(ticker+time)==GetTicker())
{
ticker = GetTicker();
CCR_now=TIM_GetCapture2(TIM2);
if (phi_LHL_2>CCR_now)
{
CCR_now++;
if ((SysTicker % k_LHL_2) ==0)
TIM_SetCompare2(TIM2, CCR_now);
}
else if (phi_LHL_2<CCR_now)
{
CCR_now--;
if ((SysTicker % k_LHL_2) ==0)
TIM_SetCompare2(TIM2, CCR_now);
}
}
}
/*******************************************************************************
* Function Name : TIM2_IRQHandler
* Description : This function handles TIM2 global interrupt request.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void TIM2_IRQHandler(void)
{
/* Clear TIM2 Capture compare interrupt pending bit */
TIM_ClearITPendingBit(TIM2, TIM_IT_CC2);
/* Get the Input Capture value */
IC2Value = TIM_GetCapture2(TIM2);
if (IC2Value != 0)
{
/* Duty cycle computation */
DutyCycle = (TIM_GetCapture1(TIM2) * 100) / IC2Value;
/* Frequency computation */
Frequency = 72000000 / IC2Value;
}
else
{
DutyCycle = 0;
Frequency = 0;
}
}
void RHL_1_execute(uint16_t time) // time = time*0.1 (ms)
{
static uint16_t ticker = 0;
if ((uint16_t)(ticker+time)==GetTicker())
{
ticker = GetTicker();
CCR_now=TIM_GetCapture2(TIM4);
if (phi_RHL_1>CCR_now)
{
CCR_now++;
if ((SysTicker % k_RHL_1) ==0)
TIM_SetCompare2(TIM4, CCR_now);
}
else if (phi_RHL_1<CCR_now)
{
CCR_now--;
if ((SysTicker % k_RHL_1) ==0)
TIM_SetCompare2(TIM4, CCR_now);
}
}
}
static void timCCxHandler(TIM_TypeDef *tim)
{
uint16_t capture;
timerConfig_t *timerConfig;
uint8_t channelIndex = 0;
for (channelIndex = 0; channelIndex < CC_CHANNELS_PER_TIMER; channelIndex++) {
uint8_t channel = channels[channelIndex];
if (channel == TIM_Channel_1 && TIM_GetITStatus(tim, TIM_IT_CC1) == SET) {
TIM_ClearITPendingBit(tim, TIM_IT_CC1);
timerConfig = findTimerConfig(tim, TIM_Channel_1);
capture = TIM_GetCapture1(tim);
} else if (channel == TIM_Channel_2 && TIM_GetITStatus(tim, TIM_IT_CC2) == SET) {
TIM_ClearITPendingBit(tim, TIM_IT_CC2);
timerConfig = findTimerConfig(tim, TIM_Channel_2);
capture = TIM_GetCapture2(tim);
} else if (channel == TIM_Channel_3 && TIM_GetITStatus(tim, TIM_IT_CC3) == SET) {
TIM_ClearITPendingBit(tim, TIM_IT_CC3);
timerConfig = findTimerConfig(tim, TIM_Channel_3);
capture = TIM_GetCapture3(tim);
} else if (channel == TIM_Channel_4 && TIM_GetITStatus(tim, TIM_IT_CC4) == SET) {
TIM_ClearITPendingBit(tim, TIM_IT_CC4);
timerConfig = findTimerConfig(tim, TIM_Channel_4);
capture = TIM_GetCapture4(tim);
} else {
continue; // avoid uninitialised variable dereference
}
if (!timerConfig->callback) {
continue;
}
timerConfig->callback(timerConfig->reference, capture);
}
}
/**
* @brief This function handles TIM2 global interrupt request.
* @param None
* @retval None
*/
void TIM2_IRQHandler(void)
{
if (TIM_GetITStatus(TIM2, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC1);
/* Pin PC.06 toggling with frequency = 73.24 Hz */
GPIO_WriteBit(GPIOC, GPIO_Pin_6, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_6)));
capture = TIM_GetCapture1(TIM2);
TIM_SetCompare1(TIM2, capture + CCR1_Val);
}
else if (TIM_GetITStatus(TIM2, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC2);
/* Pin PC.07 toggling with frequency = 109.8 Hz */
GPIO_WriteBit(GPIOC, GPIO_Pin_7, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_7)));
capture = TIM_GetCapture2(TIM2);
TIM_SetCompare2(TIM2, capture + CCR2_Val);
}
else if (TIM_GetITStatus(TIM2, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC3);
/* Pin PC.08 toggling with frequency = 219.7 Hz */
GPIO_WriteBit(GPIOC, GPIO_Pin_8, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_8)));
capture = TIM_GetCapture3(TIM2);
TIM_SetCompare3(TIM2, capture + CCR3_Val);
}
else
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC4);
/* Pin PC.09 toggling with frequency = 439.4 Hz */
GPIO_WriteBit(GPIOC, GPIO_Pin_9, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_9)));
capture = TIM_GetCapture4(TIM2);
TIM_SetCompare4(TIM2, capture + CCR4_Val);
}
}
/**
* @brief This function handles TIM3 global interrupt request.
* @param None
* @retval None
*/
void TIM3_IRQHandler(void)
{
if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1);
/* LED4 toggling with frequency = 4.57 Hz */
STM_EVAL_LEDToggle(LED4);
capture = TIM_GetCapture1(TIM3);
TIM_SetCompare1(TIM3, capture + CCR1_Val);
}
else if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
/* LED3 toggling with frequency = 9.15 Hz */
STM_EVAL_LEDToggle(LED3);
capture = TIM_GetCapture2(TIM3);
TIM_SetCompare2(TIM3, capture + CCR2_Val);
}
else if (TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
/* LED5 toggling with frequency = 18.31 Hz */
STM_EVAL_LEDToggle(LED5);
capture = TIM_GetCapture3(TIM3);
TIM_SetCompare3(TIM3, capture + CCR3_Val);
}
else
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);
/* LED6 toggling with frequency = 36.62 Hz */
STM_EVAL_LEDToggle(LED6);
capture = TIM_GetCapture4(TIM3);
TIM_SetCompare4(TIM3, capture + CCR4_Val);
}
}
static void pwmTIMxHandler(TIM_TypeDef *tim, uint8_t portBase)
{
int8_t port;
// Generic CC handler for TIM2,3,4
if (TIM_GetITStatus(tim, TIM_IT_CC1) == SET) {
port = portBase + 0;
TIM_ClearITPendingBit(tim, TIM_IT_CC1);
pwmPorts[port].callback(port, TIM_GetCapture1(tim));
} else if (TIM_GetITStatus(tim, TIM_IT_CC2) == SET) {
port = portBase + 1;
TIM_ClearITPendingBit(tim, TIM_IT_CC2);
pwmPorts[port].callback(port, TIM_GetCapture2(tim));
} else if (TIM_GetITStatus(tim, TIM_IT_CC3) == SET) {
port = portBase + 2;
TIM_ClearITPendingBit(tim, TIM_IT_CC3);
pwmPorts[port].callback(port, TIM_GetCapture3(tim));
} else if (TIM_GetITStatus(tim, TIM_IT_CC4) == SET) {
port = portBase + 3;
TIM_ClearITPendingBit(tim, TIM_IT_CC4);
pwmPorts[port].callback(port, TIM_GetCapture4(tim));
}
}
uint16_t HAL_Servo_Read_Pulse_Width(uint16_t pin)
{
uint16_t SERVO_TIM_CCR = 0x0000;
if(PIN_MAP[pin].timer_ch == TIM_Channel_1)
{
SERVO_TIM_CCR = TIM_GetCapture1(PIN_MAP[pin].timer_peripheral);
}
else if(PIN_MAP[pin].timer_ch == TIM_Channel_2)
{
SERVO_TIM_CCR = TIM_GetCapture2(PIN_MAP[pin].timer_peripheral);
}
else if(PIN_MAP[pin].timer_ch == TIM_Channel_3)
{
SERVO_TIM_CCR = TIM_GetCapture3(PIN_MAP[pin].timer_peripheral);
}
else if(PIN_MAP[pin].timer_ch == TIM_Channel_4)
{
SERVO_TIM_CCR = TIM_GetCapture4(PIN_MAP[pin].timer_peripheral);
}
//pulseWidth = (SERVO_TIM_CCR * 1000000) / ((SERVO_TIM_ARR + 1) * SERVO_TIM_PWM_FREQ);
return SERVO_TIM_CCR;
}
void TIM8_CC_IRQHandler()
{
TIM_ICInitTypeDef TIM_ICInitStructure;
TIM_ICStructInit(&TIM_ICInitStructure); //Initialize the structure with default setting
if(TIM_GetITStatus(TIM8, TIM_IT_CC1) == SET) {
TIM_ClearITPendingBit(TIM8, TIM_IT_CC1);
TIM_ICInitStructure.TIM_Channel = TIM_Channel_1;
if(capture_state[THROTTLE_CHANNEL] == RISE) {
//Rised edge capture
rise_value[THROTTLE_CHANNEL] = TIM_GetCapture1(TIM8);
//Change to measure the falled edge
capture_state[THROTTLE_CHANNEL] = FALL;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling;
} else {
//Falled edge capture
fall_value[THROTTLE_CHANNEL] = TIM_GetCapture1(TIM8);
/* Calculate the RC high pulse value */
if(fall_value[THROTTLE_CHANNEL] > rise_value[THROTTLE_CHANNEL])
rc_value[THROTTLE_CHANNEL] = fall_value[THROTTLE_CHANNEL] - rise_value[THROTTLE_CHANNEL];
else if(fall_value[THROTTLE_CHANNEL] == 0 && rise_value[THROTTLE_CHANNEL] == 0)
rc_value[THROTTLE_CHANNEL] = 0; //No signal
else /* falled edge measured value is overflow */
rc_value[THROTTLE_CHANNEL] = (fall_value[THROTTLE_CHANNEL] + 10000) - rise_value[THROTTLE_CHANNEL];
//Change to measure the rised edge
capture_state[THROTTLE_CHANNEL] = RISE;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
}
TIM_ICInit(TIM8, &TIM_ICInitStructure);
}
if(TIM_GetITStatus(TIM8, TIM_IT_CC2) == SET) {
TIM_ClearITPendingBit(TIM8, TIM_IT_CC2);
TIM_ICInitStructure.TIM_Channel = TIM_Channel_2;
if(capture_state[YAW_CHANNEL] == RISE) {
//Rised edge capture
rise_value[YAW_CHANNEL] = TIM_GetCapture2(TIM8);
//Change to measure the falled edge
capture_state[YAW_CHANNEL] = FALL;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling;
} else {
//Falled edge capture
fall_value[YAW_CHANNEL] = TIM_GetCapture2(TIM8);
/* Calculate the RC high pulse value */
if(fall_value[YAW_CHANNEL] > rise_value[YAW_CHANNEL])
rc_value[YAW_CHANNEL] = fall_value[YAW_CHANNEL] - rise_value[YAW_CHANNEL];
else if(fall_value[YAW_CHANNEL] == 0 && rise_value[YAW_CHANNEL] == 0)
rc_value[YAW_CHANNEL] = 0; //No signal
else /* falled edge measured value is overflow */
rc_value[YAW_CHANNEL] = (fall_value[YAW_CHANNEL] + 10000) - rise_value[YAW_CHANNEL];
//Change to measure the rised edge
capture_state[YAW_CHANNEL] = RISE;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
}
TIM_ICInit(TIM8, &TIM_ICInitStructure);
}
}
static inline void pwmIRQHandler(TIM_TypeDef *tim)
{
pwm_in_counter++;
uint8_t i;
uint16_t val = 0;
uint16_t time_on = 0;
uint16_t time_off = 0;
for (i = 0; i < PWMIN_CHANNEL_NUM; i++) {
struct TIM_Channel channel = Channels[i];
struct PWM_State *input = &Inputs[i];
if (channel.tim == tim && (TIM_GetITStatus(tim, channel.tim_cc) == SET)) {
TIM_ClearITPendingBit(channel.tim, channel.tim_cc);
switch (channel.tim_channel) {
case TIM_Channel_1:
val = TIM_GetCapture1(channel.tim);
break;
case TIM_Channel_2:
val = TIM_GetCapture2(channel.tim);
break;
case TIM_Channel_3:
val = TIM_GetCapture3(channel.tim);
break;
case TIM_Channel_4:
val = TIM_GetCapture4(channel.tim);
break;
}
if (input->state == 0) {
input->rise = val;
if(input->rise > input->fall)
time_off = input->rise - input->fall;
else
time_off = ((0xFFFF - input->fall) + input->rise);
// switch states
if ((time_off >= MINOFFWIDTH) && (time_off <= MAXOFFWIDTH)){
input->state = 1;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling;
TIM_ICInitStructure.TIM_Channel = channel.tim_channel;
TIM_ICInit(channel.tim, &TIM_ICInitStructure);
}
} else {
input->fall = val;
if (input->fall > input->rise)
time_on = (input->fall - input->rise);
else
time_on = ((0xFFFF - input->rise) + input->fall);
if ((time_on >= MINONWIDTH) && (time_on <= MAXONWIDTH))
{
// compute capture
input->capture = time_on;
// switch state
input->state = 0;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
TIM_ICInitStructure.TIM_Channel = channel.tim_channel;
TIM_ICInit(channel.tim, &TIM_ICInitStructure);
}
}
}
}
}
void TIM2_IRQHandler(void)
{
uint32_t current[4];
TIM_ICInitTypeDef TIM_ICInitStructure;
TIM_ICStructInit(&TIM_ICInitStructure);
if (TIM_GetITStatus(TIM2, TIM_IT_CC1) == SET) {
/* Clear TIM1 Capture compare interrupt pending bit */
TIM_ClearITPendingBit(TIM2, TIM_IT_CC1);
if ( inc[INC6].status == RISING ) {
TIM_ICInitStructure.TIM_Channel = TIM_Channel_1;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling;
/* Get the Input Capture value */
inc[INC6].prev_value = TIM_GetCapture1(TIM2);
inc[INC6].status = FALLING;
} else {
TIM_ICInitStructure.TIM_Channel = TIM_Channel_1;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
//Get the Input Capture value
current[0] = TIM_GetCapture1(TIM2);
if (current[0] > inc[INC6].prev_value)
inc[INC6].curr_value = current[0] - inc[INC6].prev_value ;
else if (current[0] < inc[INC6].prev_value)
inc[INC6].curr_value = 0xFFFF - inc[INC6].prev_value + current[0] ;
inc[INC6].status = RISING;
}
TIM_ICInit(TIM2, &TIM_ICInitStructure);
}
if (TIM_GetITStatus(TIM2, TIM_IT_CC2) == SET) {
/* Clear TIM1 Capture compare interrupt pending bit */
TIM_ClearITPendingBit(TIM2, TIM_IT_CC2);
if (inc[INC5].status == RISING) {
TIM_ICInitStructure.TIM_Channel = TIM_Channel_2;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling;
/* Get the Input Capture value */
inc[INC5].prev_value = TIM_GetCapture2(TIM2);
inc[INC5].status = FALLING;
} else {
TIM_ICInitStructure.TIM_Channel = TIM_Channel_2;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
/* Get the Input Capture value */
current[1] = TIM_GetCapture2(TIM2);
if (current[1] > inc[INC5].prev_value)
inc[INC5].curr_value = current[1] - inc[INC5].prev_value ;
else if (current[1] < inc[INC5].prev_value)
inc[INC5].curr_value = 0xFFFF - inc[INC5].prev_value + current[1] ;
inc[INC5].status = RISING;
}
TIM_ICInit(TIM2, &TIM_ICInitStructure);
}
if (TIM_GetITStatus(TIM2, TIM_IT_CC3) == SET) {
/* Clear TIM1 Capture compare interrupt pending bit */
TIM_ClearITPendingBit(TIM2, TIM_IT_CC3);
if (inc[INC2].status == RISING) {
TIM_ICInitStructure.TIM_Channel = TIM_Channel_3;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling;
/* Get the Input Capture value */
inc[INC2].prev_value = TIM_GetCapture3(TIM2);
inc[INC2].status = FALLING;
} else {
TIM_ICInitStructure.TIM_Channel = TIM_Channel_3;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
/* Get the Input Capture value */
current[2] = TIM_GetCapture3(TIM2);
if (current[2] > inc[INC2].prev_value)
inc[INC2].curr_value= current[2] - inc[INC2].prev_value;
else if (current[2] < inc[INC2].prev_value)
inc[INC2].curr_value = 0xFFFF - inc[INC2].prev_value + current[2] ;
inc[INC2].status = RISING;
}
TIM_ICInit(TIM2, &TIM_ICInitStructure);
}
if (TIM_GetITStatus(TIM2, TIM_IT_CC4) == SET) {
/* Clear TIM1 Capture compare interrupt pending bit */
TIM_ClearITPendingBit(TIM2, TIM_IT_CC4);
if (inc[INC1].status == RISING) {
TIM_ICInitStructure.TIM_Channel = TIM_Channel_4;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling;
/* Get the Input Capture value */
inc[INC1].prev_value = TIM_GetCapture4(TIM2);
inc[INC1].status = FALLING;
} else {
TIM_ICInitStructure.TIM_Channel = TIM_Channel_4;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
/* Get the Input Capture value */
current[3] = TIM_GetCapture4(TIM2);
if (current[3] > inc[INC1].prev_value)
inc[INC1].curr_value = current[3] - inc[INC1].prev_value;
else if (current[3] < inc[INC1].prev_value)
inc[INC1].curr_value = 0xFFFF - inc[INC1].prev_value+ current[3] ;
inc[INC1].status = RISING;
}
TIM_ICInit(TIM2, &TIM_ICInitStructure);
}
}
//定时器3中断服务程序
void TIM3_IRQHandler(void)
{
if((TIM3CH1_CAPTURE_STA&0X80)==0)//CH1 还未成功捕获
{
if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)//捕获1发生捕获事件
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1);
if(TIM3CH1_CAPTURE_STA&0X40) //捕获到一个下降沿为真 发生上升沿中断后再次发生中断为下降沿
{
TIM3CH1_CAPTURE_DOWNVAL=TIM_GetCapture1(TIM3); //获取当前的捕获值
if(TIM3CH1_CAPTURE_DOWNVAL<TIM3CH1_CAPTURE_UPVAL)
{
tim3_T=65535;
}
else tim3_T=0;
tempup1=TIM3CH1_CAPTURE_DOWNVAL-TIM3CH1_CAPTURE_UPVAL+tim3_T;//得到总的高电平时间
pwmout1=tempup1;
TIM3CH1_CAPTURE_STA=0;
TIM_OC1PolarityConfig(TIM3,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
}
else //发生捕获事件但不是下降沿，第一次捕获上升沿，清零，定时器开始计数
{
TIM3CH1_CAPTURE_UPVAL=TIM_GetCapture1(TIM3); //获取上升沿的数据
TIM3CH1_CAPTURE_STA|=0X40; //标记以捕获到了上升沿
TIM_OC1PolarityConfig(TIM3,TIM_ICPolarity_Falling); //CC1P=1 设置为下降沿捕获
}
}
}
if((TIM3CH2_CAPTURE_STA&0X80)==0)//CH1 还未成功捕获
{
if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)//捕获1发生捕获事件
{
TIM_ClearITPendingBit(TIM3,TIM_IT_CC2);
if(TIM3CH2_CAPTURE_STA&0X40) //捕获到一个下降沿为真 发生上升沿中断后再次发生中断为下降沿
{
TIM3CH2_CAPTURE_DOWNVAL=TIM_GetCapture2(TIM3);
if(TIM3CH2_CAPTURE_DOWNVAL<TIM3CH2_CAPTURE_UPVAL)
{
tim3_T=65535;
}
else tim3_T=0;
tempup2=TIM3CH2_CAPTURE_DOWNVAL-TIM3CH2_CAPTURE_UPVAL+tim3_T;//得到总的高电平时间
pwmout2=tempup2;
TIM3CH2_CAPTURE_STA=0;
TIM_OC2PolarityConfig(TIM3,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
}
else //发生捕获事件但不是下降沿，第一次捕获上升沿，清零，定时器开始计数
{
TIM3CH2_CAPTURE_UPVAL=TIM_GetCapture2(TIM3); //获取上升沿的数据
TIM3CH2_CAPTURE_STA|=0X40; //标记以捕获到了上升沿
TIM_OC2PolarityConfig(TIM3,TIM_ICPolarity_Falling); //CC1P=1 设置为下降沿捕获
}
}
}
if((TIM3CH3_CAPTURE_STA&0X80)==0)//CH3 还未成功捕获
{
if (TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET)//捕获3发生捕获事件
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
if(TIM3CH3_CAPTURE_STA&0X40) //捕获到一个下降沿为真 发生上升沿中断后再次发生中断为下降沿
{
TIM3CH3_CAPTURE_DOWNVAL=TIM_GetCapture3(TIM3);
if(TIM3CH3_CAPTURE_DOWNVAL<TIM3CH3_CAPTURE_UPVAL)
{
tim3_T=65535;
}
else tim3_T=0;
tempup3=TIM3CH3_CAPTURE_DOWNVAL-TIM3CH3_CAPTURE_UPVAL+tim3_T;//得到总的高电平时间
pwmout3=tempup3;
TIM3CH3_CAPTURE_STA=0;
TIM_OC3PolarityConfig(TIM3,TIM_ICPolarity_Rising); //CC3P=0 设置为上升沿捕获
}
else //发生捕获事件但不是下降沿，第一次捕获上升沿，清零，定时器开始计数
{
TIM3CH3_CAPTURE_UPVAL=TIM_GetCapture3(TIM3); //获取上升沿的数据
TIM3CH3_CAPTURE_STA|=0X40; //标记以捕获到了上升沿
TIM_OC3PolarityConfig(TIM3,TIM_ICPolarity_Falling); //CC1P=1 设置为下降沿捕获
}
}
}
if((TIM3CH4_CAPTURE_STA&0X80)==0)//CH4 还未成功捕获
{
if (TIM_GetITStatus(TIM3, TIM_IT_CC4) != RESET)//捕获1发生捕获事件
{
TIM_ClearITPendingBit(TIM3,TIM_IT_CC4);
if(TIM3CH4_CAPTURE_STA&0X40) //捕获到一个下降沿为真 发生上升沿中断后再次发生中断为下降沿
{
TIM3CH4_CAPTURE_DOWNVAL=TIM_GetCapture4(TIM3);
if(TIM3CH4_CAPTURE_DOWNVAL<TIM3CH4_CAPTURE_UPVAL)
{
tim3_T=65535;
}
else tim3_T=0;
tempup4=TIM3CH4_CAPTURE_DOWNVAL-TIM3CH4_CAPTURE_UPVAL+tim3_T;//得到总的高电平时间
pwmout4=tempup4;
TIM3CH4_CAPTURE_STA=0;
TIM_OC4PolarityConfig(TIM3,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
}
else //发生捕获事件但不是下降沿，第一次捕获上升沿，清零，定时器开始计数
{
TIM3CH4_CAPTURE_UPVAL=TIM_GetCapture4(TIM3); //获取上升沿的数据
TIM3CH4_CAPTURE_STA|=0X40; //标记以捕获到了上升沿
TIM_OC4PolarityConfig(TIM3,TIM_ICPolarity_Falling); //CC4P=1 设置为下降沿捕获
}
}
}
}
/**
* @brief Handler for TIM4 global interrupt
* @details TIM4 handler
*/
void TIM4_IRQHandler(void) {
if (TIM_GetITStatus(TIM4, TIM_IT_CC1) != RESET) {
TIM_ClearITPendingBit(TIM4, TIM_IT_CC1);
_ge_ic_chan_captures_last[IC_CHAN1] = _ge_ic_chan_captures[IC_CHAN1];
_ge_ic_chan_captures[IC_CHAN1] = TIM_GetCapture1(TIM4);
// set updated available flag
_ge_ic_chan_freq_avail[IC_CHAN1] = true;
//calculate actual counts based on timer overflow count
if (_ge_ic_chan_captures_last[IC_CHAN1] > _ge_ic_chan_captures[IC_CHAN1]) {
_ge_ic_chan_period[IC_CHAN1] = (uint32_t) _ge_ic_chan_captures[IC_CHAN1]
+ 65536 * (_ge_ic_chan_ovf[IC_CHAN1] - 1)
- _ge_ic_chan_captures_last[IC_CHAN1];
} else {
_ge_ic_chan_period[IC_CHAN1] = (uint32_t) _ge_ic_chan_captures[IC_CHAN1]
+ 65536 * (_ge_ic_chan_ovf[IC_CHAN1])
- _ge_ic_chan_captures_last[IC_CHAN1];
}
_ge_ic_chan_ovf[IC_CHAN1] = 0;
//reenable chan 1 IC
TIM_ICInitTypeDef ic_init_struct;
TIM_ICStructInit(&ic_init_struct);
ic_init_struct.TIM_Channel = TIM_Channel_1;
ic_init_struct.TIM_ICPolarity = TIM_ICPolarity_Rising;
ic_init_struct.TIM_ICSelection = TIM_ICSelection_DirectTI;
ic_init_struct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
ic_init_struct.TIM_ICFilter = GE_IC_IFILTER;
TIM_ICInit(TIM4, &ic_init_struct);
// _ge_ic_chan_captures[IC_CHAN1] = 3000;
}
if (TIM_GetITStatus(TIM4, TIM_IT_CC2) != RESET) {
TIM_ClearITPendingBit(TIM4, TIM_IT_CC2);
_ge_ic_chan_captures_last[IC_CHAN2] = _ge_ic_chan_captures[IC_CHAN2];
_ge_ic_chan_captures[IC_CHAN2] = TIM_GetCapture2(TIM4);
// set updated available flag
_ge_ic_chan_freq_avail[IC_CHAN2] = true;
//calculate actual counts based on timer overflow count
if (_ge_ic_chan_captures_last[IC_CHAN2] > _ge_ic_chan_captures[IC_CHAN2]) {
_ge_ic_chan_period[IC_CHAN2] = (uint32_t) _ge_ic_chan_captures[IC_CHAN2]
+ 65536 * (_ge_ic_chan_ovf[IC_CHAN2] - 1)
- _ge_ic_chan_captures_last[IC_CHAN2];
} else {
_ge_ic_chan_period[IC_CHAN2] = (uint32_t) _ge_ic_chan_captures[IC_CHAN2]
+ 65536 * (_ge_ic_chan_ovf[IC_CHAN2])
- _ge_ic_chan_captures_last[IC_CHAN2];
}
_ge_ic_chan_ovf[IC_CHAN2] = 0;
//reenable chan 2 IC
TIM_ICInitTypeDef ic_init_struct;
TIM_ICStructInit(&ic_init_struct);
ic_init_struct.TIM_Channel = TIM_Channel_2;
ic_init_struct.TIM_ICPolarity = TIM_ICPolarity_Rising;
ic_init_struct.TIM_ICSelection = TIM_ICSelection_DirectTI;
ic_init_struct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
ic_init_struct.TIM_ICFilter = GE_IC_IFILTER;
TIM_ICInit(TIM4, &ic_init_struct);
}
if (TIM_GetITStatus(TIM4, TIM_IT_CC3) != RESET) {
TIM_ClearITPendingBit(TIM4, TIM_IT_CC3);
_ge_ic_chan_captures_last[IC_CHAN3] = _ge_ic_chan_captures[IC_CHAN3];
_ge_ic_chan_captures[IC_CHAN3] = TIM_GetCapture3(TIM4);
// set updated available flag
_ge_ic_chan_freq_avail[IC_CHAN3] = true;
//calculate actual counts based on timer overflow count
if (_ge_ic_chan_captures_last[IC_CHAN3] > _ge_ic_chan_captures[IC_CHAN3]) {
_ge_ic_chan_period[IC_CHAN3] = (uint32_t) _ge_ic_chan_captures[IC_CHAN3]
+ 65536 * (_ge_ic_chan_ovf[IC_CHAN3] - 1)
- _ge_ic_chan_captures_last[IC_CHAN3];
} else {
_ge_ic_chan_period[IC_CHAN3] = (uint32_t) _ge_ic_chan_captures[IC_CHAN3]
+ 65536 * (_ge_ic_chan_ovf[IC_CHAN3])
- _ge_ic_chan_captures_last[IC_CHAN3];
}
_ge_ic_chan_ovf[IC_CHAN3] = 0;
//reenable chan 3 IC
TIM_ICInitTypeDef ic_init_struct;
TIM_ICStructInit(&ic_init_struct);
ic_init_struct.TIM_Channel = TIM_Channel_3;
ic_init_struct.TIM_ICPolarity = TIM_ICPolarity_Rising;
ic_init_struct.TIM_ICSelection = TIM_ICSelection_DirectTI;
ic_init_struct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
ic_init_struct.TIM_ICFilter = GE_IC_IFILTER;
TIM_ICInit(TIM4, &ic_init_struct);
}
if (TIM_GetITStatus(TIM4, TIM_IT_CC4) != RESET) {
TIM_ClearITPendingBit(TIM4, TIM_IT_CC4);
_ge_ic_chan_captures_last[IC_CHAN4] = _ge_ic_chan_captures[IC_CHAN4];
_ge_ic_chan_captures[IC_CHAN4] = TIM_GetCapture4(TIM4);
// set updated available flag
_ge_ic_chan_freq_avail[IC_CHAN4] = true;
//calculate actual counts based on timer overflow count
if (_ge_ic_chan_captures_last[IC_CHAN4] > _ge_ic_chan_captures[IC_CHAN4]) {
_ge_ic_chan_period[IC_CHAN4] = (uint32_t) _ge_ic_chan_captures[IC_CHAN4]
+ 65536 * (_ge_ic_chan_ovf[IC_CHAN4] - 1)
- _ge_ic_chan_captures_last[IC_CHAN4];
} else {
_ge_ic_chan_period[IC_CHAN4] = (uint32_t) _ge_ic_chan_captures[IC_CHAN4]
+ 65536 * (_ge_ic_chan_ovf[IC_CHAN4])
- _ge_ic_chan_captures_last[IC_CHAN4];
}
_ge_ic_chan_ovf[IC_CHAN4] = 0;
//reenable chan 4 IC
TIM_ICInitTypeDef ic_init_struct;
TIM_ICStructInit(&ic_init_struct);
ic_init_struct.TIM_Channel = TIM_Channel_4;
ic_init_struct.TIM_ICPolarity = TIM_ICPolarity_Rising;
ic_init_struct.TIM_ICSelection = TIM_ICSelection_DirectTI;
ic_init_struct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
ic_init_struct.TIM_ICFilter = GE_IC_IFILTER;
TIM_ICInit(TIM4, &ic_init_struct);
}
if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET) {
TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
for (int i = 0; i < 4; i++) {
_ge_ic_chan_ovf[i]++;
}
}
}
/*********************************************************************************
*Function : void TIM2_Tone_Interrupt_Handler(void)
*Description : set duty cycle
*Input : none
*Output : none
*Return : none
*author : lz
*date : 6-December-2013
*Others :
**********************************************************************************/
void TIM2_Tone_Interrupt_Handler(void)
{
uint16_t capture;
if (TIM_GetITStatus(TIM2, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC1 );
capture = TIM_GetCapture1(TIM2);
TIM_SetCompare1(TIM2, capture + PIN_MAP[30].timer_ccr);
if(PIN_MAP[30].user_property != -1)
{
if (PIN_MAP[30].user_property > 0)
{
PIN_MAP[30].user_property -= 1;
}
else
{
noTone(30);
}
}
}
if (TIM_GetITStatus(TIM2, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC2);
capture = TIM_GetCapture2(TIM2);
TIM_SetCompare2(TIM2, capture + PIN_MAP[31].timer_ccr);
if(PIN_MAP[31].user_property != -1)
{
if (PIN_MAP[31].user_property > 0)
{
PIN_MAP[31].user_property -= 1;
}
else
{
noTone(31);
}
}
}
if (TIM_GetITStatus(TIM2, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC3);
capture = TIM_GetCapture3(TIM2);
TIM_SetCompare3(TIM2, capture + PIN_MAP[33].timer_ccr);
if(PIN_MAP[33].user_property != -1)
{
if (PIN_MAP[33].user_property > 0)
{
PIN_MAP[33].user_property -= 1;
}
else
{
noTone(33);
}
}
}
if (TIM_GetITStatus(TIM2, TIM_IT_CC4) != RESET)
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC4);
capture = TIM_GetCapture4(TIM2);
TIM_SetCompare4(TIM2, capture + PIN_MAP[32].timer_ccr);
if(PIN_MAP[32].user_property != -1)
{
if (PIN_MAP[32].user_property > 0)
{
PIN_MAP[32].user_property -= 1;
}
else
{
noTone(32);
}
}
}
}
/*********************************************************************************
*Function : void TIM3_Tone_Interrupt_Handler(void)
*Description : set duty cycle
*Input : none
*Output : none
*Return : none
*author : lz
*date : 6-December-2013
*Others :
**********************************************************************************/
void TIM3_Tone_Interrupt_Handler(void)
{
uint16_t capture;
if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1 );
capture = TIM_GetCapture1(TIM3);
TIM_SetCompare1(TIM3, capture + PIN_MAP[36].timer_ccr);
if(PIN_MAP[36].user_property != -1)
{
if (PIN_MAP[36].user_property > 0)
{
PIN_MAP[36].user_property -= 1;
}
else
{
noTone(36);
}
}
}
if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
capture = TIM_GetCapture2(TIM3);
TIM_SetCompare2(TIM3, capture + PIN_MAP[37].timer_ccr);
if(PIN_MAP[37].user_property != -1)
{
if (PIN_MAP[37].user_property > 0)
{
PIN_MAP[37].user_property -= 1;
}
else
{
noTone(37);
}
}
}
if (TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
capture = TIM_GetCapture3(TIM3);
TIM_SetCompare3(TIM3, capture + PIN_MAP[38].timer_ccr);
if(PIN_MAP[38].user_property != -1)
{
if (PIN_MAP[38].user_property > 0)
{
PIN_MAP[38].user_property -= 1;
}
else
{
noTone(38);
}
}
}
if (TIM_GetITStatus(TIM3, TIM_IT_CC4) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);
capture = TIM_GetCapture4(TIM3);
TIM_SetCompare4(TIM3, capture + PIN_MAP[39].timer_ccr);
if(PIN_MAP[39].user_property != -1)
{
if (PIN_MAP[39].user_property > 0)
{
PIN_MAP[39].user_property -= 1;
}
else
{
noTone(39);
}
}
}
}
void TIM4_IRQHandler(void){
if(function == FREQUENCY_METER)
{
RCC_ClocksTypeDef RCC_Clocks;
RCC_GetClocksFreq(&RCC_Clocks);
/* Get the Input Capture value */
IC2Value = TIM_GetCapture2(TIM4);
if (IC2Value != 0)
{
/* Duty cycle computation */
DutyCycle = (TIM_GetCapture1(TIM4) * 100) / IC2Value;
/* Frequency computation TIM4 counter clock = (RCC_Clocks.HCLK_Frequency)/2 */
if(freqRange == LESS_THAN_1) {
low_Frequency = (((RCC_Clocks.HCLK_Frequency)/2 / (double)IC2Value) / (61440 - 1)); /* 0.06 - 1 hz */
}
else if(freqRange == ONE_TO_100) {
Frequency = (((RCC_Clocks.HCLK_Frequency)/2 / IC2Value) / (3840 - 1)); /* 1 - 100 hz */
}
else if(freqRange == HUNDRED_TO_10K) {
Frequency = (((RCC_Clocks.HCLK_Frequency)/2 / IC2Value) / (15 - 1)); /* 100 - 10000 hz */
}
else if(freqRange == MORE_THAN_10K) {
Frequency = (((RCC_Clocks.HCLK_Frequency)/2 / IC2Value) / 1); /* 10000 - ~10M hz */
}
else {
Frequency = ((RCC_Clocks.HCLK_Frequency)/2 / IC2Value); /* DEFAULT - 1.28k - 1M hz */
}
}
else
{
DutyCycle = 0;
Frequency = 0;
}
}
else if (function == FREQUENCY_KEY_SHIFT)
{
NVIC_InitTypeDef NVIC_InitStructure;
// Set the FSK_Chnage flag to true to signal DDS frequencies need updating
FSK_Change = true;
// Based on the current toggleBit value, change the DDS frequency
if (toggleBit == 1)
{
FSK_Freq = HIGH;
toggleBit = 0;
}
else
{
FSK_Freq = LOW;
toggleBit = 1;
}
// Problems encounter with the timers global interrupt flag, so re-enable
// the interrupt which appears to fix the problem for some reason.
NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
/* Clear TIM4 Capture compare interrupt pending bit */
TIM_ClearITPendingBit(TIM4, TIM_IT_CC2);
}
//定时器4中断服务程序,用CH1作为超声波转换的通道 即PB6端口
void TIM4_IRQHandler(void)
{
if ((TIM4CH1_CAPTURE_STA & 0X80) == 0) //还未成功捕获
{
if (TIM_GetITStatus(TIM4, TIM_IT_CC1) != RESET) //捕获1发生捕获事件
{
TIM_ClearITPendingBit(TIM4, TIM_IT_CC1); //清除中断标志位
if (TIM4CH1_CAPTURE_STA & 0X40) //捕获到一个下降沿
{
TIM4CH1_CAPTURE_DOWNVAL = TIM_GetCapture1(TIM4);//记录下此时的定时器计数值
if (TIM4CH1_CAPTURE_DOWNVAL < TIM4CH1_CAPTURE_UPVAL)
{/* 如果计数器初始值大于末尾值，说明计数器有溢出 */
tim4_T1 = 65535;
}
else
tim4_T1 = 0;
tempup1 = TIM4CH1_CAPTURE_DOWNVAL - TIM4CH1_CAPTURE_UPVAL
+ tim4_T1; //得到总的高电平的时间
//pwmout1 = tempup1; //总的高电平的时间
tempup1 =tempup1 *17/1000;//计算距离&&UltrasonicWave_Distance<85
TIM4CH1_CAPTURE_STA = 0; //捕获标志位清零，这一步很重要！
TIM_OC1PolarityConfig(TIM4, TIM_ICPolarity_Rising); //设置为上升沿捕获
}
else //发生捕获时间但不是下降沿，第一次捕获到上升沿，记录此时的定时器计数值
{
TIM4CH1_CAPTURE_UPVAL = TIM_GetCapture1(TIM4); //获取上升沿数据
TIM4CH1_CAPTURE_STA |= 0X40; //标记已捕获到上升沿
TIM_OC1PolarityConfig(TIM4, TIM_ICPolarity_Falling);//设置为下降沿捕获
}
}
}
if ((TIM4CH2_CAPTURE_STA & 0X80) == 0) //还未成功捕获
{
if (TIM_GetITStatus(TIM4, TIM_IT_CC2) != RESET) //捕获2发生捕获事件
{
TIM_ClearITPendingBit(TIM4, TIM_IT_CC2); //清除中断标志位
if (TIM4CH2_CAPTURE_STA & 0X40) //捕获到一个下降沿
{
TIM4CH2_CAPTURE_DOWNVAL = TIM_GetCapture2(TIM4);//记录下此时的定时器计数值
if (TIM4CH2_CAPTURE_DOWNVAL < TIM4CH2_CAPTURE_UPVAL)
{
tim4_T2 = 65535;
}
else
tim4_T2 = 0;
tempup2 = TIM4CH2_CAPTURE_DOWNVAL - TIM4CH2_CAPTURE_UPVAL
+ tim4_T2; //得到总的高电平的时间
pwmout2 = tempup2; //总的高电平的时间
TIM4CH2_CAPTURE_STA = 0; //捕获标志位清零
TIM_OC2PolarityConfig(TIM4, TIM_ICPolarity_Rising); //设置为上升沿捕获
}
else //发生捕获时间但不是下降沿，第一次捕获到上升沿，记录此时的定时器计数值
{
TIM4CH2_CAPTURE_UPVAL = TIM_GetCapture2(TIM4); //获取上升沿数据
TIM4CH2_CAPTURE_STA |= 0X40; //标记已捕获到上升沿
TIM_OC2PolarityConfig(TIM4, TIM_ICPolarity_Falling);//设置为下降沿捕获
}
}
}
if ((TIM4CH3_CAPTURE_STA & 0X80) == 0) //还未成功捕获
{
if (TIM_GetITStatus(TIM4, TIM_IT_CC3) != RESET) //捕获3发生捕获事件
{
TIM_ClearITPendingBit(TIM4, TIM_IT_CC3); //清除中断标志位
if (TIM4CH3_CAPTURE_STA & 0X40) //捕获到一个下降沿
{
TIM4CH3_CAPTURE_DOWNVAL = TIM_GetCapture3(TIM4);//记录下此时的定时器计数值
if (TIM4CH3_CAPTURE_DOWNVAL < TIM4CH3_CAPTURE_UPVAL)
{
tim4_T3 = 65535;
}
else
tim4_T3 = 0;
tempup3 = TIM4CH3_CAPTURE_DOWNVAL - TIM4CH3_CAPTURE_UPVAL
+ tim4_T3; //得到总的高电平的时间
pwmout3 = tempup3; //总的高电平的时间
TIM4CH3_CAPTURE_STA = 0; //捕获标志位清零
TIM_OC3PolarityConfig(TIM4, TIM_ICPolarity_Rising); //设置为上升沿捕获
}
else //发生捕获时间但不是下降沿，第一次捕获到上升沿，记录此时的定时器计数值
{
TIM4CH3_CAPTURE_UPVAL = TIM_GetCapture3(TIM4); //获取上升沿数据
TIM4CH3_CAPTURE_STA |= 0X40; //标记已捕获到上升沿
TIM_OC3PolarityConfig(TIM4, TIM_ICPolarity_Falling);//设置为下降沿捕获
}
}
}
if ((TIM4CH4_CAPTURE_STA & 0X80) == 0) //还未成功捕获
{
if (TIM_GetITStatus(TIM4, TIM_IT_CC4) != RESET) //捕获4发生捕获事件
{
TIM_ClearITPendingBit(TIM4, TIM_IT_CC4); //清除中断标志位
if (TIM4CH4_CAPTURE_STA & 0X40) //捕获到一个下降沿
{
TIM4CH4_CAPTURE_DOWNVAL = TIM_GetCapture4(TIM4);//记录下此时的定时器计数值
if (TIM4CH4_CAPTURE_DOWNVAL < TIM4CH4_CAPTURE_UPVAL)
{
tim4_T4 = 65535;
}
else
tim4_T4 = 0;
tempup4 = TIM4CH4_CAPTURE_DOWNVAL - TIM4CH4_CAPTURE_UPVAL
+ tim4_T4; //得到总的高电平的时间
pwmout4 = tempup4; //总的高电平的时间
TIM4CH4_CAPTURE_STA = 0; //捕获标志位清零
TIM_OC4PolarityConfig(TIM4, TIM_ICPolarity_Rising); //设置为上升沿捕获
}
else //发生捕获时间但不是下降沿，第一次捕获到上升沿，记录此时的定时器计数值
{
TIM4CH4_CAPTURE_UPVAL = TIM_GetCapture4(TIM4); //获取上升沿数据
TIM4CH4_CAPTURE_STA |= 0X40; //标记已捕获到上升沿
TIM_OC4PolarityConfig(TIM4, TIM_ICPolarity_Falling);//设置为下降沿捕获
}
}
}
}
void TIMER_INTERRUPT_FCN(void)
{
#if TIMEBASE_TIMER == 6 || TIMEBASE_TIMER == 7 || TIMEBASE_TIMER == 18
if (TIM_GetITStatus(MAKENAME(TIM,TIMEBASE_TIMER), TIM_IT_Update) != RESET)
{
TIM_ClearITPendingBit(MAKENAME(TIM,TIMEBASE_TIMER), TIM_IT_Update);
timerCallback1();
}
#endif //TIMEBASE_TIMER == 6 || TIMEBASE_TIMER == 7 || TIMEBASE_TIMER == 18
#if TIMEBASE_TIMER != 6 && TIMEBASE_TIMER != 7 && TIMEBASE_TIMER != 18
#ifdef TIMEBASE_SIZE
TIMEBASE_SIZE capture_val = 0;
TIMEBASE_SIZE next_capture_val = 0;
TIMEBASE_SIZE clock_val = 0;
TIMEBASE_SIZE gap_val = 0;
#endif
if (TIM_GetITStatus(MAKENAME(TIM,TIMEBASE_TIMER), TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(MAKENAME(TIM,TIMEBASE_TIMER), TIM_IT_CC1);
timerCallback1();
capture_val = TIM_GetCapture1(MAKENAME(TIM,TIMEBASE_TIMER));
clock_val = TIM_GetCounter(MAKENAME(TIM,TIMEBASE_TIMER));
gap_val = (TIMEBASE_SIZE) (SystemCoreClock/TIMEBASE_CLOCK_PSC / TIMEBASE_INT1_FREQ - 1);
next_capture_val = capture_val + gap_val;
while( (((clock_val > next_capture_val) || (clock_val < capture_val)) && (capture_val < next_capture_val)) || ((clock_val > next_capture_val) && (clock_val < capture_val)) )
{
//increment capture and next_capture by gap_val
capture_val += gap_val;
next_capture_val = capture_val + gap_val;
clock_val = TIM_GetCounter(MAKENAME(TIM,TIMEBASE_TIMER));
}
TIM_SetCompare1(MAKENAME(TIM,TIMEBASE_TIMER), next_capture_val);
}
#if defined(TIMEBASE_INT2_FREQ) && TIMEBASE_TIMER != 13 && TIMEBASE_TIMER != 14 && TIMEBASE_TIMER != 16 && TIMEBASE_TIMER != 17
if (TIM_GetITStatus(MAKENAME(TIM,TIMEBASE_TIMER), TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(MAKENAME(TIM,TIMEBASE_TIMER), TIM_IT_CC2);
timerCallback2();
capture_val = TIM_GetCapture2(MAKENAME(TIM,TIMEBASE_TIMER));
clock_val = TIM_GetCounter(MAKENAME(TIM,TIMEBASE_TIMER));
gap_val = (TIMEBASE_SIZE) (SystemCoreClock/TIMEBASE_CLOCK_PSC / TIMEBASE_INT2_FREQ - 1);
next_capture_val = capture_val + gap_val;
while( (((clock_val > next_capture_val) || (clock_val < capture_val)) && (capture_val < next_capture_val)) || ((clock_val > next_capture_val) && (clock_val < capture_val)) )
{
//increment capture and next_capture by gap_val
capture_val += gap_val;
next_capture_val = capture_val + gap_val;
clock_val = TIM_GetCounter(MAKENAME(TIM,TIMEBASE_TIMER));
}
TIM_SetCompare2(MAKENAME(TIM,TIMEBASE_TIMER), next_capture_val);
}
#if defined(TIMEBASE_INT3_FREQ) && TIMEBASE_TIMER != 12 && TIMEBASE_TIMER != 15
if (TIM_GetITStatus(MAKENAME(TIM,TIMEBASE_TIMER), TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(MAKENAME(TIM,TIMEBASE_TIMER), TIM_IT_CC3);
timerCallback3();
capture_val = TIM_GetCapture3(MAKENAME(TIM,TIMEBASE_TIMER));
clock_val = TIM_GetCounter(MAKENAME(TIM,TIMEBASE_TIMER));
gap_val = (TIMEBASE_SIZE) (SystemCoreClock/TIMEBASE_CLOCK_PSC / TIMEBASE_INT3_FREQ - 1);
next_capture_val = capture_val + gap_val;
while( (((clock_val > next_capture_val) || (clock_val < capture_val)) && (capture_val < next_capture_val)) || ((clock_val > next_capture_val) && (clock_val < capture_val)) )
{
//increment capture and next_capture by gap_val
capture_val += gap_val;
next_capture_val = capture_val + gap_val;
clock_val = TIM_GetCounter(MAKENAME(TIM,TIMEBASE_TIMER));
}
TIM_SetCompare3(MAKENAME(TIM,TIMEBASE_TIMER), next_capture_val);
}
#ifdef TIMEBASE_INT4_FREQ
if (TIM_GetITStatus(MAKENAME(TIM,TIMEBASE_TIMER), TIM_IT_CC4) != RESET)
{
TIM_ClearITPendingBit(MAKENAME(TIM,TIMEBASE_TIMER), TIM_IT_CC4);
timerCallback4();
capture_val = TIM_GetCapture4(MAKENAME(TIM,TIMEBASE_TIMER));
clock_val = TIM_GetCounter(MAKENAME(TIM,TIMEBASE_TIMER));
gap_val = (TIMEBASE_SIZE) (SystemCoreClock/TIMEBASE_CLOCK_PSC / TIMEBASE_INT4_FREQ - 1);
next_capture_val = capture_val + gap_val;
while( (((clock_val > next_capture_val) || (clock_val < capture_val)) && (capture_val < next_capture_val)) || ((clock_val > next_capture_val) && (clock_val < capture_val)) )
{
//increment capture and next_capture by gap_val
capture_val += gap_val;
next_capture_val = capture_val + gap_val;
clock_val = TIM_GetCounter(MAKENAME(TIM,TIMEBASE_TIMER));
}
TIM_SetCompare4(MAKENAME(TIM,TIMEBASE_TIMER), next_capture_val);
}
#endif //TIMEBASE_INT4_FREQ
#endif //defined(TIMEBASE_INT3_FREQ) && TIMEBASE_TIMER != 12 && TIMEBASE_TIMER != 15
#endif //defined(TIMEBASE_INT2_FREQ) && TIMEBASE_TIMER != 13 && TIMEBASE_TIMER != 14 && TIMEBASE_TIMER != 16 && TIMEBASE_TIMER != 17
#endif //TIMEBASE_TIMER != 6 || TIMEBASE_TIMER != 7 || TIMEBASE_TIMER != 18
}
void TIM3_IRQHandler()
{
// int i;
// i++;
// TIM_ClearITPendingBit(TIM3, TIM3_IRQn);
// TIM_ClearITPendingBit(TIM3, TIM_IT_CC1);
// TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
// TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
// TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);
// if ( TIM_GetFlagStatus(TIM3, TIM_FLAG_CC1))
// {i++;}
// if ( TIM_GetFlagStatus(TIM3, TIM_FLAG_CC2))
// {i++;}
// if ( TIM_GetFlagStatus(TIM3, TIM_FLAG_CC3))
// {i++;}
// if ( TIM_GetFlagStatus(TIM3, TIM_FLAG_CC4))
// {i++;}
if (TIM_GetFlagStatus(TIM3, TIM_FLAG_CC1))//проверяем что прерывание вызвал канал 1
{
if ( TIM3->CCER & TIM_CCER_CC1P)
{
/*проверка что бы проходили циклически по записям массива фронтов*/
if (modCounter_FallCounter[CH_1]== MEASURE_BUFFER - 1)
modCounter_FallCounter[CH_1]=0;
else
modCounter_FallCounter[CH_1]++;
modCounter_Falls[CH_1][modCounter_FallCounter[CH_1]] = TIM_GetCapture1(TIM3);//записываем значение захвата
modCounter_WritePending |= CH_1_DOWN;//указываем что произошел новый спад
TIM3->CCER &= ~(TIM_CCER_CC1P);// перенастройка канала на захват по нарастающему фронту
}
else
{
/*проверка что бы проходили циклически по записям массива фронтов*/
if (modCounter_RiseCounter[CH_1]== MEASURE_BUFFER -1)
modCounter_RiseCounter[CH_1]=0;
else
modCounter_RiseCounter[CH_1]++;
modCounter_Rises[CH_1][modCounter_RiseCounter[CH_1]] = TIM_GetCapture1(TIM3);//записываем значение захвата
modCounter_WritePending |= CH_1_UP;//указываем что произошел подьем
TIM3->CCER |= TIM_CCER_CC1P;//перенастройка канала на захват по спадающему фронту
}
TIM_ClearITPendingBit(TIM3, TIM_Channel_1);
}
if ( TIM_GetFlagStatus(TIM3, TIM_FLAG_CC2))//проверяем что прерывание вызвал канал 2
{
if ( TIM3->CCER & TIM_CCER_CC2P)
{
/*проверка что бы проходили циклически по записям массива фронтов*/
if (modCounter_FallCounter[CH_2]== MEASURE_BUFFER - 1)
modCounter_FallCounter[CH_2]=0;
else
modCounter_FallCounter[CH_2]++;
modCounter_Falls[CH_2][modCounter_FallCounter[CH_2]] = TIM_GetCapture2(TIM3);//записываем значение захвата
modCounter_WritePending |= CH_2_DOWN;//указываем что произошел новый спад
TIM3->CCER &= ~(TIM_CCER_CC2P);// перенастройка канала на захват по нарастающему фронту
}
else
{
/*проверка что бы проходили циклически по записям массива фронтов*/
if (modCounter_RiseCounter[CH_2] == MEASURE_BUFFER -1)
modCounter_RiseCounter[CH_2]=0;
else
modCounter_RiseCounter[CH_2]++;
modCounter_Rises[CH_2][modCounter_RiseCounter[CH_2]] = TIM_GetCapture2(TIM3);//записываем значение захвата
modCounter_WritePending |= CH_2_UP;//указываем что произошел подьем
TIM3->CCER |= TIM_CCER_CC2P;//перенастройка канала на захват по спадающему фронту
}
TIM_ClearITPendingBit(TIM3, TIM_Channel_2);
}
if ( TIM_GetFlagStatus(TIM3, TIM_FLAG_CC3))//проверяем что прерывание вызвал канал 3
{
if ( TIM3->CCER & TIM_CCER_CC3P) //если канал 3 настроен на захват спадающего фронта
{
/*проверка что бы проходили циклически по записям массива фронтов*/
if (modCounter_FallCounter[CH_3]== MEASURE_BUFFER - 1)
modCounter_FallCounter[CH_3]=0;
else
modCounter_FallCounter[CH_3]++;
modCounter_Falls[CH_3][modCounter_FallCounter[CH_3]] = TIM_GetCapture3(TIM3);//записываем значение захвата
modCounter_WritePending |= CH_3_DOWN;//указываем что произошел новый спад
TIM3->CCER &= ~(TIM_CCER_CC3P);// перенастройка канала на захват по нарастающему фронту
}
else
{
/*проверка что бы проходили циклически по записям массива фронтов*/
if (modCounter_RiseCounter[CH_3]== MEASURE_BUFFER -1)
modCounter_RiseCounter[CH_3]=0;
else
modCounter_RiseCounter[CH_3]++;
modCounter_Rises[CH_3][modCounter_RiseCounter[CH_3]] = TIM_GetCapture3(TIM3);//записываем значение захвата
modCounter_WritePending |= CH_3_UP;//указываем что произошел подьем
TIM3->CCER |= TIM_CCER_CC3P;//перенастройка канала на захват по спадающему фронту
}
TIM_ClearITPendingBit(TIM3, TIM_Channel_3);//сброс бита прерывания
}
if ( TIM_GetFlagStatus(TIM3, TIM_FLAG_CC4))//проверяем что прерывание вызвал канал 3
{
if ( TIM3->CCER & TIM_CCER_CC4P) //если канал 3 настроен на захват спадающего фронта
{
/*проверка что бы проходили циклически по записям массива фронтов*/
if (modCounter_FallCounter[CH_4]== MEASURE_BUFFER - 1)
modCounter_FallCounter[CH_4]=0;
else
modCounter_FallCounter[CH_4]++;
modCounter_Falls[CH_4][modCounter_FallCounter[CH_4]] = TIM_GetCapture4(TIM3);//записываем значение захвата
modCounter_WritePending |= CH_4_DOWN;//указываем что произошел новый спад
TIM3->CCER &= ~(TIM_CCER_CC4P);// перенастройка канала на захват по нарастающему фронту
}
else
{
/*проверка что бы проходили циклически по записям массива фронтов*/
if (modCounter_RiseCounter[CH_4]== MEASURE_BUFFER -1)
modCounter_RiseCounter[CH_4]=0;
else
modCounter_RiseCounter[CH_4]++;
modCounter_Rises[CH_4][modCounter_RiseCounter[CH_4]] = TIM_GetCapture4(TIM3);//записываем значение захвата
modCounter_WritePending |= CH_4_UP;//указываем что произошел подьемs
TIM3->CCER |= TIM_CCER_CC4P;//перенастройка канала на захват по спадающему фронту
}
TIM_ClearITPendingBit(TIM3, TIM_Channel_4);//сброс бита прерывания
}
}
static void PIOS_TIM_generic_irq_handler(TIM_TypeDef * timer)
{
/* Iterate over all registered clients of the TIM layer to find channels on this timer */
for (uint8_t i = 0; i < pios_tim_num_devs; i++) {
const struct pios_tim_dev * tim_dev = &pios_tim_devs[i];
if (!tim_dev->channels || tim_dev->num_channels == 0) {
/* No channels to process on this client */
continue;
}
/* Check for an overflow event on this timer */
bool overflow_event;
uint16_t overflow_count;
if (TIM_GetITStatus(timer, TIM_IT_Update) == SET) {
TIM_ClearITPendingBit(timer, TIM_IT_Update);
overflow_count = timer->ARR;
overflow_event = true;
} else {
overflow_count = 0;
overflow_event = false;
}
for (uint8_t j = 0; j < tim_dev->num_channels; j++) {
const struct pios_tim_channel * chan = &tim_dev->channels[j];
if (chan->timer != timer) {
/* channel is not on this timer */
continue;
}
/* Figure out which interrupt bit we should be looking at */
uint16_t timer_it;
switch (chan->timer_chan) {
case TIM_Channel_1:
timer_it = TIM_IT_CC1;
break;
case TIM_Channel_2:
timer_it = TIM_IT_CC2;
break;
case TIM_Channel_3:
timer_it = TIM_IT_CC3;
break;
case TIM_Channel_4:
timer_it = TIM_IT_CC4;
break;
default:
PIOS_Assert(0);
break;
}
bool edge_event;
uint16_t edge_count;
if (TIM_GetITStatus(chan->timer, timer_it) == SET) {
TIM_ClearITPendingBit(chan->timer, timer_it);
/* Read the current counter */
switch(chan->timer_chan) {
case TIM_Channel_1:
edge_count = TIM_GetCapture1(chan->timer);
break;
case TIM_Channel_2:
edge_count = TIM_GetCapture2(chan->timer);
break;
case TIM_Channel_3:
edge_count = TIM_GetCapture3(chan->timer);
break;
case TIM_Channel_4:
edge_count = TIM_GetCapture4(chan->timer);
break;
default:
PIOS_Assert(0);
break;
}
edge_event = true;
} else {
edge_event = false;
edge_count = 0;
}
if (!tim_dev->callbacks) {
/* No callbacks registered, we're done with this channel */
continue;
}
/* Generate the appropriate callbacks */
if (overflow_event & edge_event) {
/*
* When both edge and overflow happen in the same interrupt, we
* need a heuristic to determine the order of the edge and overflow
* events so that the callbacks happen in the right order. If we
* get the order wrong, our pulse width calculations could be off by up
* to ARR ticks. That could be bad.
*
* Heuristic: If the edge_count is < 16 ticks above zero then we assume the
* edge happened just after the overflow.
*/
if (edge_count < 16) {
/* Call the overflow callback first */
if (tim_dev->callbacks->overflow) {
(*tim_dev->callbacks->overflow)((uintptr_t)tim_dev,
tim_dev->context,
j,
overflow_count);
}
/* Call the edge callback second */
if (tim_dev->callbacks->edge) {
(*tim_dev->callbacks->edge)((uintptr_t)tim_dev,
tim_dev->context,
j,
edge_count);
}
} else {
/* Call the edge callback first */
if (tim_dev->callbacks->edge) {
(*tim_dev->callbacks->edge)((uintptr_t)tim_dev,
tim_dev->context,
j,
edge_count);
}
/* Call the overflow callback second */
if (tim_dev->callbacks->overflow) {
(*tim_dev->callbacks->overflow)((uintptr_t)tim_dev,
tim_dev->context,
j,
overflow_count);
}
}
} else if (overflow_event && tim_dev->callbacks->overflow) {
(*tim_dev->callbacks->overflow)((uintptr_t)tim_dev,
tim_dev->context,
j,
overflow_count);
} else if (edge_event && tim_dev->callbacks->edge) {
(*tim_dev->callbacks->edge)((uintptr_t)tim_dev,
tim_dev->context,
j,
edge_count);
}
}
}
}
