/**
* @brief This function handles TIM14 global interrupt request.
* @param None
* @retval None
*/
void TIM14_IRQHandler(void)
{
if (TIM_GetITStatus(TIM14, TIM_IT_CC1) != RESET)
{
/* Clear TIM14 Capture Compare 1 interrupt pending bit */
TIM_ClearITPendingBit(TIM14, TIM_IT_CC1);
if(CaptureNumber == 0)
{
/* Get the Input Capture value */
IC1ReadValue1 = TIM_GetCapture1(TIM14);
CaptureNumber = 1;
}
else if(CaptureNumber == 1)
{
/* Get the Input Capture value */
IC1ReadValue2 = TIM_GetCapture1(TIM14);
TIM_ITConfig(TIM14, TIM_IT_CC1, DISABLE);
/* Capture computation */
if (IC1ReadValue2 > IC1ReadValue1)
{
PeriodValue = (IC1ReadValue2 - IC1ReadValue1);
}
else
{
PeriodValue = ((0xFFFF - IC1ReadValue1) + IC1ReadValue2);
}
/* capture of two values is done */
CaptureNumber = 2;
}
}
}
/*TIM5_CH1*/
void TIM5_IRQHandler( void )
{
RCC_ClocksTypeDef RCC_Clocks;
RCC_GetClocksFreq( &RCC_Clocks );
TIM_ClearITPendingBit( TIM5, TIM_IT_CC2 );
/* Get the Input Capture value */
IC2Value = TIM_GetCapture2( TIM5 );
if( IC2Value != 0 )
{
/* Duty cycle computation */
//DutyCycle = ( TIM_GetCapture1( TIM5 ) * 100 ) / IC2Value;
/* Frequency computation TIM4 counter clock = (RCC_Clocks.HCLK_Frequency)/2 */
//Frequency = (RCC_Clocks.HCLK_Frequency)/2 / IC2Value;
/*是不是反向电路?*/
DutyCycle = ( IC2Value * 100 ) / TIM_GetCapture1( TIM5 );
Frequency = ( RCC_Clocks.HCLK_Frequency ) / 2 / TIM_GetCapture1( TIM5 );
}else
{
DutyCycle = 0;
Frequency = 0;
}
}
/**
* @brief This function handles TIM14 global interrupt request.
* @param None
* @retval None
*/
void TIM14_IRQHandler(void)
{
if (TIM_GetITStatus(TIM14, TIM_IT_CC1) != RESET)
{
if(CaptureNumber == 0)
{
/* Get the Input Capture value */
IC1ReadValue1 = TIM_GetCapture1(TIM14);
}
else if(CaptureNumber == 1)
{
/* Get the Input Capture value */
IC1ReadValue2 = TIM_GetCapture1(TIM14);
/* Capture computation */
if (IC1ReadValue2 > IC1ReadValue1)
{
Capture = (IC1ReadValue2 - IC1ReadValue1);
}
else
{
Capture = ((0xFFFF - IC1ReadValue1) + IC1ReadValue2);
}
/* Frequency computation */
LsiFreq = (uint32_t) SystemCoreClock / Capture;
LsiFreq *= 8;
}
CaptureNumber++;
/* Clear TIM14 Capture compare interrupt pending bit */
TIM_ClearITPendingBit(TIM14, TIM_IT_CC1);
}
}
void TIM4_IRQHandler(void)
{
static u16 Drop_Capture = 0;
static u16 Rise_Capture = 0;
static u16 Rise1 = 0;
static u16 Rise2 = 0;
static u16 Distance1 = 0;
static u16 Distance2 = 0;
static u16 Delta_Distance = 0;
static u8 i = 0;
static u8 j = 0;
if (TIM_GetITStatus(TIM4, TIM_IT_CC1) != RESET) //捕获1发生捕获事件
{
TIM_ClearITPendingBit(TIM4, TIM_IT_CC1); //清除中断标志位
if(GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_6) == 1)
{
TIM_OC1PolarityConfig(TIM4,TIM_ICPolarity_Falling); //CC1P=1 设置为下降沿捕获
Rise_Capture=TIM_GetCapture1(TIM4);
if(i == 0)
{
Rise1 = Rise_Capture;
i = 1;
}
else
{
Rise2 = Rise_Capture;
i = 0;
}
pulse.period = (Rise1>Rise2)?(Rise1-Rise2):(Rise2-Rise1);//us
//Delta.dis =
//Speed = Delta.dis/pulse.period
Speed = Delta_Distance*1000/5069;// um*1000/us == m/s*1000 == mm/s
}
else
{
TIM_OC1PolarityConfig(TIM4,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
Drop_Capture=TIM_GetCapture1(TIM4);
if(Rise_Capture>Drop_Capture) pulse.width = 65535-Rise_Capture + Drop_Capture;
else pulse.width = Drop_Capture - Rise_Capture;
if(j == 0)
{
Distance1 = pulse.width;
j = 1;
}
else
{
Distance2 = pulse.width;
j = 0;
}
Delta_Distance = ((Distance1>Distance2)?(Distance1-Distance2):(Distance2-Distance1))*170;//um
}
}
}
uint16_t Servo::readMicroseconds() const {
if (!this->attached()) {
return 0;
}
uint16_t SERVO_TIM_CCR = 0x0000;
if(PIN_MAP[this->pin].timer_ch == TIM_Channel_1)
{
SERVO_TIM_CCR = TIM_GetCapture1(PIN_MAP[this->pin].timer_peripheral);
}
else if(PIN_MAP[this->pin].timer_ch == TIM_Channel_2)
{
SERVO_TIM_CCR = TIM_GetCapture2(PIN_MAP[this->pin].timer_peripheral);
}
else if(PIN_MAP[this->pin].timer_ch == TIM_Channel_3)
{
SERVO_TIM_CCR = TIM_GetCapture3(PIN_MAP[this->pin].timer_peripheral);
}
else if(PIN_MAP[this->pin].timer_ch == TIM_Channel_4)
{
SERVO_TIM_CCR = TIM_GetCapture4(PIN_MAP[this->pin].timer_peripheral);
}
//pulseWidth = (SERVO_TIM_CCR * 1000000) / ((SERVO_TIM_ARR + 1) * SERVO_TIM_PWM_FREQ);
return SERVO_TIM_CCR;
}
void __attribute__((used)) TIM8_TRG_COM_TIM14_IRQHandler()
{
uint16_t capureVal;
uint16_t capureValDiff;
portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
if (TIM_GetITStatus(CPPM_TIMER, TIM_IT_CC1) != RESET)
{
if (TIM_GetFlagStatus(CPPM_TIMER, TIM_FLAG_CC1OF) != RESET)
{
//TODO: Handle overflow error
}
capureVal = TIM_GetCapture1(CPPM_TIMER);
capureValDiff = capureVal - prevCapureVal;
prevCapureVal = capureVal;
xQueueSendFromISR(captureQueue, &capureValDiff, &xHigherPriorityTaskWoken);
captureFlag = true;
TIM_ClearITPendingBit(CPPM_TIMER, TIM_IT_CC1);
}
if (TIM_GetITStatus(CPPM_TIMER, TIM_IT_Update) != RESET)
{
// Update input status
isAvailible = (captureFlag == true);
captureFlag = false;
TIM_ClearITPendingBit(CPPM_TIMER, TIM_IT_Update);
}
}
/**
* @brief This function handles timer 8 capture/compare interrupt request.
* @retval None
*/
void TIM8_CC_IRQHandler(void) {
if (TIM_GetITStatus(TIM8, TIM_IT_CC1) != RESET) {
TIM_ClearITPendingBit(TIM8, TIM_IT_CC1);
if(TIM_Handler[TIM8CH1] != NULL) {
TIM_Handler[TIM8CH1]();
}
TIM_SetCompare1(TIM8, TIM_GetCapture1(TIM8) + TIM_IRQ_period[TIM8CH1]);
}
else if (TIM_GetITStatus(TIM8, TIM_IT_CC2) != RESET) {
TIM_ClearITPendingBit(TIM8, TIM_IT_CC2);
if(TIM_Handler[TIM8CH2] != NULL) {
TIM_Handler[TIM8CH2]();
}
TIM_SetCompare2(TIM8, TIM_GetCapture2(TIM8) + TIM_IRQ_period[TIM8CH2]);
}
else if (TIM_GetITStatus(TIM8, TIM_IT_CC3) != RESET) {
TIM_ClearITPendingBit(TIM8, TIM_IT_CC3);
if(TIM_Handler[TIM8CH3] != NULL) {
TIM_Handler[TIM8CH3]();
}
TIM_SetCompare3(TIM8, TIM_GetCapture3(TIM8) + TIM_IRQ_period[TIM8CH3]);
}
else if (TIM_GetITStatus(TIM8, TIM_IT_CC4) != RESET) {
TIM_ClearITPendingBit(TIM8, TIM_IT_CC4);
if(TIM_Handler[TIM8CH4] != NULL) {
TIM_Handler[TIM8CH4]();
}
TIM_SetCompare4(TIM8, TIM_GetCapture4(TIM8) + TIM_IRQ_period[TIM8CH4]);
}
}
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));
}
}
void TIM4_IRQHandler(void) {
#ifdef PWM_IRQ_TIM4_CH1
if (TIM_GetITStatus(TIM4, TIM_IT_CC1) == SET) {
int8_t pwmPort = PWM_IRQ_TIM4_CH1;
TIM_ClearITPendingBit(TIM4, TIM_IT_CC1);
pwmData[pwmPort].callback(TIM_GetCapture1(TIM4), GPIO_ReadInputDataBit((GPIO_TypeDef *)pwmPorts[pwmPort], (uint16_t)pwmPins[pwmPort]));
}
#endif
#ifdef PWM_IRQ_TIM4_CH2
if (TIM_GetITStatus(TIM4, TIM_IT_CC2) == SET) {
int8_t pwmPort = PWM_IRQ_TIM4_CH2;
TIM_ClearITPendingBit(TIM4, TIM_IT_CC2);
pwmData[pwmPort].callback(TIM_GetCapture2(TIM4), GPIO_ReadInputDataBit((GPIO_TypeDef *)pwmPorts[pwmPort], (uint16_t)pwmPins[pwmPort]));
}
else
#endif
#ifdef PWM_IRQ_TIM4_CH3
if (TIM_GetITStatus(TIM4, TIM_IT_CC3) == SET) {
int8_t pwmPort = PWM_IRQ_TIM4_CH3;
TIM_ClearITPendingBit(TIM4, TIM_IT_CC3);
pwmData[pwmPort].callback(TIM_GetCapture3(TIM4), GPIO_ReadInputDataBit((GPIO_TypeDef *)pwmPorts[pwmPort], (uint16_t)pwmPins[pwmPort]));
}
#endif
#ifdef PWM_IRQ_TIM4_CH4
if (TIM_GetITStatus(TIM4, TIM_IT_CC4) == SET) {
int8_t pwmPort = PWM_IRQ_TIM4_CH4;
TIM_ClearITPendingBit(TIM4, TIM_IT_CC4);
pwmData[pwmPort].callback(TIM_GetCapture4(TIM4), GPIO_ReadInputDataBit((GPIO_TypeDef *)pwmPorts[pwmPort], (uint16_t)pwmPins[pwmPort]));
}
#endif
}
void TIM2_IRQHandler()
{
if (TIM_GetITStatus(TIM2, TIM_IT_CC1) == SET) {
/* Clear TIM2 Capture compare interrupt pending bit */
TIM_ClearITPendingBit(TIM2, TIM_IT_CC1);
/* Get the Input Capture value */
timebaseCapture_prev = timebaseCapture_current;
timebaseCapture_current = TIM_GetCapture1(TIM2);
if(TIM_ICInitStructure.TIM_ICPolarity == TIM_ICPolarity_Rising){
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling;
TIM_ICInit(TIM2, &TIM_ICInitStructure);
}
else if(TIM_ICInitStructure.TIM_ICPolarity == TIM_ICPolarity_Falling){
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
TIM_ICInit(TIM2, &TIM_ICInitStructure);
if(timebaseCapture_current > timebaseCapture_prev){
timebaseCapture_output = (timebaseCapture_current - timebaseCapture_prev);//*5/18;
}
else{
timebaseCapture_output = (20000 - timebaseCapture_prev + timebaseCapture_current);//*5/18;
}
}
}
}
void timerISR(uint8_t timer) {
TIM_TypeDef *TIMx = TIMER_MAP[timer].TIMx;
TimerInfo *cfg = &TIMER_MAP[timer];
// Update for rollover
if (TIM_GetITStatus(TIMx, TIM_IT_Update) != RESET) {
TIM_ClearITPendingBit(TIMx, TIM_IT_Update);
cfg->numRollovers++;
}
// CCx for pwmIn
if (TIM_GetITStatus(TIMx, TIM_IT_CC1) != RESET) {
TIM_ClearITPendingBit(TIMx, TIM_IT_CC1);
timerCCxISR(TIMx, &cfg->channelData[0], TIM_GetCapture1(TIMx), cfg->numRollovers);
}
if (TIM_GetITStatus(TIMx, TIM_IT_CC2) != RESET) {
TIM_ClearITPendingBit(TIMx, TIM_IT_CC2);
timerCCxISR(TIMx, &cfg->channelData[1], TIM_GetCapture2(TIMx), cfg->numRollovers);
}
if (TIM_GetITStatus(TIMx, TIM_IT_CC3) != RESET) {
TIM_ClearITPendingBit(TIMx, TIM_IT_CC3);
timerCCxISR(TIMx, &cfg->channelData[2], TIM_GetCapture3(TIMx), cfg->numRollovers);
}
if (TIM_GetITStatus(TIMx, TIM_IT_CC4) != RESET) {
TIM_ClearITPendingBit(TIMx, TIM_IT_CC4);
timerCCxISR(TIMx, &cfg->channelData[3], TIM_GetCapture4(TIMx), cfg->numRollovers);
}
}
/**
* @brief This function handles TIM2 global interrupt request.
* @param None
* @retval None
*/
void TIM2_IRQHandler(void)
{
RCC_ClocksTypeDef RCC_Clocks;
RCC_GetClocksFreq(&RCC_Clocks);
/* 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
TIM2 counter clock = (RCC_Clocks.HCLK_Frequency)/2 */
Frequency = RCC_Clocks.HCLK_Frequency / IC2Value;
}
else
{
DutyCycle = 0;
Frequency = 0;
}
}
/**
* @brief This function handles TIM3 global interrupt request.
* @param None
* @retval None
*/
void TIM3_IRQHandler(void)
{
/* TIM3_CH1 toggling with frequency = 256.35 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1 );
uhCapture = TIM_GetCapture1(TIM3);
TIM_SetCompare1(TIM3, uhCapture + uhCCR1_Val );
}
/* TIM3_CH2 toggling with frequency = 512.7 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
uhCapture = TIM_GetCapture2(TIM3);
TIM_SetCompare2(TIM3, uhCapture + uhCCR2_Val);
}
/* TIM3_CH3 toggling with frequency = 1025.4 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
uhCapture = TIM_GetCapture3(TIM3);
TIM_SetCompare3(TIM3, uhCapture + uhCCR3_Val);
}
/* TIM3_CH4 toggling with frequency = 2050.78 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC4) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);
uhCapture = TIM_GetCapture4(TIM3);
TIM_SetCompare4(TIM3, uhCapture + uhCCR4_Val);
}
}
/**
* @brief This function handles TIM3 global interrupt request.
* @param None
* @retval None
*/
void TIM3_IRQHandler(void)
{
/* TIM3_CH1 toggling with frequency = 585.9 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1 );
capture = TIM_GetCapture1(TIM3);
TIM_SetCompare1(TIM3, capture + CCR1_Val );
}
/* TIM3_CH2 toggling with frequency = 1171.8 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
capture = TIM_GetCapture2(TIM3);
TIM_SetCompare2(TIM3, capture + CCR2_Val);
}
/* TIM3_CH3 toggling with frequency = 2343.75 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
capture = TIM_GetCapture3(TIM3);
TIM_SetCompare3(TIM3, capture + CCR3_Val);
}
/* TIM3_CH4 toggling with frequency = 4687.5 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC4) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);
capture = TIM_GetCapture4(TIM3);
TIM_SetCompare4(TIM3, capture + CCR4_Val);
}
}
void TIM2_IRQHandler(void)
{
vu16 vu16_IC2Value = 0;
/* Get the Input Capture value */
vu16_IC2Value = TIM_GetCapture2(TIM2);
if(vu16_IC2Value != 0)
{
/* Duty cycle computation */
vu16_DutyCycle = (TIM_GetCapture1(TIM2) * 100) / vu16_IC2Value;
/* Frequency computation */
f32_Frequency = ((float)u32_TimerFrequency) / ((float)vu16_IC2Value);
/* TIM counter disable */
TIM_Cmd(TIM2, DISABLE);
/* Disable the CC2 Interrupt Request */
TIM_ITConfig(TIM2, TIM_IT_CC2, DISABLE);
TIM_ClearITPendingBit(TIM2, TIM_IT_CC2);
}
else
{
vu16_DutyCycle = 0;
f32_Frequency = 0;
}
}
static void ppmIRQHandler(TIM_TypeDef *tim)
{
uint16_t diff;
static uint16_t now;
static uint16_t last = 0;
static uint8_t chan = 0;
if (TIM_GetITStatus(tim, TIM_IT_CC1) == SET) {
last = now;
now = TIM_GetCapture1(tim);
rcActive = true;
}
TIM_ClearITPendingBit(tim, TIM_IT_CC1);
if (now > last) {
diff = (now - last);
} else {
diff = ((0xFFFF - last) + now);
}
if (diff > 4000) {
chan = 0;
} else {
if (diff > 750 && diff < 2250 && chan < 8) { // 750 to 2250 ms is our 'valid' channel range
Inputs[chan].capture = diff;
}
chan++;
failsafeCnt = 0;
}
}
/**
* @brief This function handles TIM3 global interrupt request.
* @param None
* @retval None
*/
void TIM3_IRQHandler(void)
{
/* TIM3_CH1 toggling with frequency = 183.1 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1 );
capture = TIM_GetCapture1(TIM3);
TIM_SetCompare1(TIM3, capture + CCR1_Val );
}
/* TIM3_CH2 toggling with frequency = 366.2 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
capture = TIM_GetCapture2(TIM3);
TIM_SetCompare2(TIM3, capture + CCR2_Val);
}
/* TIM3_CH3 toggling with frequency = 732.4 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
capture = TIM_GetCapture3(TIM3);
TIM_SetCompare3(TIM3, capture + CCR3_Val);
}
/* TIM3_CH4 toggling with frequency = 1464.8 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC4) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);
capture = TIM_GetCapture4(TIM3);
TIM_SetCompare4(TIM3, capture + CCR4_Val);
}
}
void TIM4_IRQHandler(void)
{
RCC_ClocksTypeDef RCC_Clocks;
RCC_GetClocksFreq(&RCC_Clocks);
/* Clear TIM4 Capture compare interrupt pending bit */
TIM_ClearITPendingBit(TIM4, TIM_IT_CC2);
/* Get the Input Capture value */
IC2Value = TIM_GetCapture2(TIM4);
IC1Value = TIM_GetCapture1(TIM4);
if (IC2Value != 0)
{
/* Duty cycle computation */
DutyCycle = (IC1Value* 100+1 ) / IC2Value;//
/* Frequency computation
TIM4 counter clock = (RCC_Clocks.HCLK_Frequency)/2 */
Frequency = (1780000)/2 / IC2Value;//RCC_Clocks.HCLK_Frequency
GUI_DispDecAt(Frequency,0,0,6);
GUI_DispDecAt(DutyCycle,40,0,3);
}
else
{
DutyCycle = 0;
Frequency = 0;
}
// Stop_Tim4IT();
}
void TIM1_CC_IRQHandler(void)
{
uint16_t diff;
static uint16_t now;
static uint16_t last = 0;
static uint8_t chan = 0;
if (TIM_GetITStatus(TIM1, TIM_IT_CC1) == SET)
{
last = now;
now = TIM_GetCapture1(TIM1);
rcActive = true;
}
TIM_ClearITPendingBit(TIM1, TIM_IT_CC1);
diff = now - last;
if (diff > 2700 * 2) // Per http://www.rcgroups.com/forums/showpost.php?p=21996147&postcount=3960
{ // "So, if you use 2.5ms or higher as being the reset for the PPM stream start,
chan = 0; // you will be fine. I use 2.7ms just to be safe."
}
else
{
if (diff > 1500 && diff < 4500 && chan < 8) // 750 to 2250 ms is our 'valid' channel range
{
pulseWidth[chan] = diff;
}
chan++;
}
}
static void timCCxHandler(TIM_TypeDef *tim)
{
uint16_t capture;
timerConfig_t *timerConfig;
if (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 (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 (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 (TIM_GetITStatus(tim, TIM_IT_CC4) == SET) {
TIM_ClearITPendingBit(tim, TIM_IT_CC4);
timerConfig = findTimerConfig(tim, TIM_Channel_4);
capture = TIM_GetCapture4(tim);
} else {
return; // avoid uninitialised variable dereference
}
if (!timerConfig->callback) {
return;
}
timerConfig->callback(timerConfig->reference, capture);
}
/*******************************************************************************
* Function Name : TIM3_IRQHandler
* Description : This function handles TIM3 global interrupt request.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void TIM3_IRQHandler(void)
{
vu16 capture = 0; /* 当前捕获计数值局部变量 */
printf("SR = %x\r\n", TIM3->SR);
/*
* TIM2 时钟 = 72 MHz, 分频数 = 7299 + 1, TIM2 counter clock = 10KHz
* CC1 更新率 = TIM2 counter clock / CCRx_Val
*/
if(TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
{
//GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_4)));
PA_PIN_NOT(4);
/* 读出当前计数值 */
capture = TIM_GetCapture1(TIM3);
//printf("capture1 = %d\r\n", capture);
/* 根据当前计数值更新输出捕获寄存器 */
TIM_SetCompare1(TIM3, capture + 40000);
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1);
}
else if(TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
{
//GPIO_WriteBit(GPIOA, GPIO_Pin_5, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_5)));
PA_PIN_NOT(5);
capture = TIM_GetCapture2(TIM3);
//printf("capture2 = %d\r\n", capture);
TIM_SetCompare2(TIM3, capture + 20000);
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
}
else if(TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET)
{
//GPIO_WriteBit(GPIOA, GPIO_Pin_6, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_6)));
PA_PIN_NOT(6);
capture = TIM_GetCapture3(TIM3);
//printf("capture3 = %d\r\n", capture);
TIM_SetCompare3(TIM3, capture + 10000);
TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
}
else if(TIM_GetITStatus(TIM3, TIM_IT_CC4) != RESET)
{
//GPIO_WriteBit(GPIOA, GPIO_Pin_7, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_7)));
PA_PIN_NOT(7);
capture = TIM_GetCapture4(TIM3);
//printf("capture4 = %d\r\n", capture);
TIM_SetCompare4(TIM3, capture + 5000);
TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);
}
else if(TIM3->SR & 0x0001)
{
//capture = TIM_GetCapture4(TIM3);
//printf("capture5 = %d\r\n", capture);
//printf("SR = %x\r\n", TIM3->SR);
TIM3->SR &= ~(1 << 0); // 清除中断标志位
}
}
void TIM1_UP_TIM16_IRQHandler(void)
{
uint32_t inputCaptureValue = 0;
uint16_t tmpccer = 0;
if (TIM_GetITStatus(TIM16, TIM_IT_CC1) == SET)
{
inputCaptureValue = (uint16_t)TIM_GetCapture1(TIM16);
TIM_ClearITPendingBit(TIM16, TIM_IT_CC1);
if (aglState == 0)
{
// inputCaptureValue has rising edge timer value
aglRiseTime = inputCaptureValue;
// Switch states
aglState = 1;
// Disable CC Channel 1, Reset the CC1E Bit
TIM16->CCER &= (uint16_t)~TIM_CCER_CC1E;
tmpccer = TIM16->CCER;
// Select the Polarity and set the CC1E Bit
tmpccer &= (uint16_t)~(TIM_CCER_CC1P | TIM_CCER_CC1NP);
tmpccer |= (uint16_t) ((TIM_ICPolarity_Falling) | TIM_CCER_CC1E);
// Write to TIM1 CCER registers
TIM16->CCER = tmpccer;
}
else
{
// inputCaptureValue has falling edge timer value
// Compute capture
if (inputCaptureValue > aglRiseTime)
aglPulseWidth = (inputCaptureValue - aglRiseTime);
else
aglPulseWidth = ((0xFFFF - aglRiseTime) + inputCaptureValue);
// Switch state
aglState = 0;
// Disable CC Channel 1, Reset the CC1E Bit
TIM16->CCER &= (uint16_t)~TIM_CCER_CC1E;
tmpccer = TIM16->CCER;
// Select the Polarity and set the CC1E Bit
tmpccer &= (uint16_t)~(TIM_CCER_CC1P | TIM_CCER_CC1NP);
tmpccer |= (uint16_t) ((TIM_ICPolarity_Rising) | TIM_CCER_CC1E);
// Write to TIM16 CCER registers
TIM16->CCER = tmpccer;
}
}
}
void SONAR_MAXBOTIX12_IRQ_HANDLER(void)
{
if (TIM_GetITStatus(SONAR_MAXBOTIX12_TIM, TIM_IT_CC1) == SET)
{
TIM_ClearITPendingBit(SONAR_MAXBOTIX12_TIM, TIM_IT_CC1);
int32_t sonar_meas = TIM_GetCapture1(SONAR_MAXBOTIX12_TIM);
/* pulse_cnts to actual pulse width in us:
* pulse width = pulse_cnts * (prescaler+1)/(actual clock)
* with 58us per centimeter, the alt in cm is:
*/
//int32_t alt_mm = pulse_cnts * 10 * (69/72) / 58;
//sonar_alt
//if ((sonar_meas > (sonar_filter_val + 1500) || sonar_meas < (sonar_filter_val - 1500))
if ((sonar_meas > (sonar_filter_val + 3000) || sonar_meas < (sonar_filter_val - 3000))
&& (sonar_spike_cnt < 5)) {
sonar_spike_cnt++;
sonar_meas = sonar_filter_val;
}
else {
sonar_spike_cnt = 0;
}
//@TODO: check for angle > 10 deg ==> don't use value
sonar_filter_val = SONAR_MAXBOTIX12_BUTTER_NUM_1*sonar_meas
+ SONAR_MAXBOTIX12_BUTTER_NUM_2*sonar_meas_prev
// + SONAR_MAXBOTIX12_BUTTER_NUM_3*sonar_meas_prev_prev
- SONAR_MAXBOTIX12_BUTTER_DEN_2*sonar_filter_val_prev;
// - SONAR_MAXBOTIX12_BUTTER_DEN_3*sonar_filter_val_prev_prev;
sonar_meas_prev_prev = sonar_meas_prev;
sonar_meas_prev = sonar_meas;
sonar_filter_val_prev_prev = sonar_filter_val_prev;
sonar_filter_val_prev = sonar_filter_val;
/** using float
float factor_cm = 0.0165229885;
float alt_cm_flt = sonar_meas * factor_cm * (1<<8);
sonar_meas_real = alt_cm_flt;*/
//((69 / 72) / 58) * (2^16) = 1082.85057
//uint16_t conv_factor_cm = 1083;
//sonar_alt_cm_bfp = conv_factor_cm*sonar_filter_val;
//sonar_filtered = conv_factor_cm*sonar_filter_val;
//((69 / 72) / 58) / 100 * (2^8) = 0.0422988506
float conv_factor_m = 0.0422988506;
float alt_m_bfp_fl = conv_factor_m*sonar_filter_val;
sonar_filtered = alt_m_bfp_fl;
//ins_sonar_initialised = TRUE;
ins_update_sonar();
//sonar_filtered = conv_factor_cm*sonar_filter_val;
//DOWNLINK_SEND_VFF(DefaultChannel, &alt_mm_flt,0,0,0,0,0,0);
DOWNLINK_SEND_INS_Z(DefaultChannel, &sonar_filtered,&sonar_spike_cnt,0, 0);
}
}
void TIM1_TRG_COM_TIM11_IRQHandler(void) {
int8_t pwmPort;
if (TIM_GetITStatus(TIM11, TIM_IT_CC1) == SET) {
pwmPort = PWM_IRQ_TIM11_CH1;
TIM_ClearITPendingBit(TIM11, TIM_IT_CC1);
pwmData[pwmPort].callback(TIM_GetCapture1(TIM11), GPIO_ReadInputDataBit((GPIO_TypeDef *)pwmPorts[pwmPort], (uint16_t)pwmPins[pwmPort]));
}
}
/*
* @brief Capacitor VFC Counter
*/
void TIM8_BRK_TIM12_IRQHandler(void)
{
if(TIM_GetITStatus(TIM12, TIM_IT_CC1) == SET)
{
//Voltage Capacitor
CapVoltage = TIM_GetCapture1(TIM12);
CapVoltage /= 100;
TIM_ClearITPendingBit(TIM12, TIM_IT_CC1);
}
}
/**
* @brief Return the angle value related to the specified servo.
* @param servo: pointer to a ausbeeServo structure that contains the
* configuration information for the specified servo.
* @retval angle: the servo angle
*/
uint8_t ausbeeGetAngleServo(ausbeeServo* servo)
{
if(servo->CHANx == TIM_Channel_1)
return (uint8_t)( (TIM_GetCapture1(servo->TIMx)-servo->minValue)*100/(servo->maxValue-servo->minValue));
else if(servo->CHANx == TIM_Channel_2)
return (uint8_t)( (TIM_GetCapture2(servo->TIMx)-servo->minValue)*100/(servo->maxValue-servo->minValue));
else if(servo->CHANx == TIM_Channel_3)
return (uint8_t)( (TIM_GetCapture3(servo->TIMx)-servo->minValue)*100/(servo->maxValue-servo->minValue));
else
return (uint8_t)( (TIM_GetCapture4(servo->TIMx)-servo->minValue)*100/(servo->maxValue-servo->minValue));
}
void TIM3_IRQHandler(void)
{
/* "Read" all sensors sequence and execute the BLDC coils commutation */
commutate ();
/* Save current time between each hall sensor signal change */
hall_sensors_time = TIM_GetCapture1(TIM3);
// clear interrupt flag
TIM_ClearITPendingBit (TIM3, TIM_IT_Trigger);
}
void TIM4_IRQHandler(void)
{
if (TIM_GetITStatus(TIM4, TIM_IT_CC2) != RESET)//??1??????
{
duty_TIM4 = TIM_GetCapture1(TIM4); //?????
if (TIM_GetCapture2(TIM4)>600) period_TIM4 = TIM_GetCapture2(TIM4);//?????
CollectFlag_TIM4 = 0;
}
TIM_ClearITPendingBit(TIM4, TIM_IT_CC2|TIM_IT_Update); //???????
}
void TIM3_IRQHandler(void)
{
uint16_t val =0,i=0;
for(i=0;i<4;i++){
if (Channels[i+2].tim == TIM3 && (TIM_GetITStatus(TIM3, Channels[i+2].cc) == SET)){
TIM_ClearITPendingBit(TIM3, Channels[i+2].cc);
switch (Channels[i+2].channel)
{
case TIM_Channel_1:
val = TIM_GetCapture1(TIM3);
break;
case TIM_Channel_2:
val = TIM_GetCapture2(TIM3);
break;
case TIM_Channel_3:
val = TIM_GetCapture3(TIM3);
break;
case TIM_Channel_4:
val = TIM_GetCapture4(TIM3);
break;
}
if (Inputs[i+2].state == 0)
Inputs[i+2].rise = val;
else
Inputs[i+2].fall = val;
if (Inputs[i+2].state == 0) {
Inputs[i+2].state = 1;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling;
TIM_ICInitStructure.TIM_Channel = Channels[i+2].channel;
TIM_ICInit(TIM3, &TIM_ICInitStructure);
}else{
if(Inputs[i+2].fall > Inputs[i+2].rise ){
val = (Inputs[i+2].fall - Inputs[i+2].rise);
if(val < 2100 && val>900)
Inputs[i+2].capture = val;
}else{
val = ((0xffff - Inputs[i+2].rise) + Inputs[i+2].fall);
if(val < 2100 && val>900)
Inputs[i+2].capture = val;
}
Inputs[i+2].state = 0;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
TIM_ICInitStructure.TIM_Channel = Channels[i+2].channel;
TIM_ICInit(TIM3, &TIM_ICInitStructure);
}
}
}
rc_in.thr=Inputs[0].capture;
rc_in.roll=Inputs[1].capture;
rc_in.pitch=Inputs[2].capture;
rc_in.yaw=Inputs[3].capture;
rc_in.mode=Inputs[4].capture;
rc_in.serve=Inputs[5].capture;
}
/*
* @brief Battery VFC Counter
*/
void TIM1_BRK_TIM9_IRQHandler(void)
{
if(TIM_GetITStatus(TIM9, TIM_IT_CC1) == SET)
{
//Voltage Battery
BattVoltage = TIM_GetCapture1(TIM9);
BattVoltage /= 100;
TIM_ClearITPendingBit(TIM9, TIM_IT_CC1);
}
}
