// Timer 17 update and capture compare interrupt void TIM1_TRG_COM_TIM17_IRQHandler(void) { if(__HAL_TIM_GET_FLAG(&TimHandle[0], TIM_FLAG_CC1) != RESET) { if(__HAL_TIM_GET_ITSTATUS(&TimHandle[0], TIM_IT_CC1) !=RESET) { { __HAL_TIM_CLEAR_IT(&TimHandle[0], TIM_IT_CC1); encoderSpeed[0] = HAL_TIM_ReadCapturedValue(&TimHandle[0], TIM_CHANNEL_1); TIM17->CNT = 0; } } } if(__HAL_TIM_GET_FLAG(&TimHandle[0], TIM_FLAG_UPDATE) != RESET) { if(__HAL_TIM_GET_ITSTATUS(&TimHandle[0], TIM_IT_UPDATE) !=RESET) { __HAL_TIM_CLEAR_IT(&TimHandle[0], TIM_IT_UPDATE); encoderSpeed[0] = PERIOD; // If timer expires we have got no pulse during measurment period, set max time } } }
void timer_irq_handler(void) { // Channel 1 for mbed timeout if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_CC1) == SET) { if (__HAL_TIM_GET_IT_SOURCE(&TimMasterHandle, TIM_IT_CC1) == SET) { __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_CC1); us_ticker_irq_handler(); } } // Channel 2 for HAL tick if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_CC2) == SET) { if (__HAL_TIM_GET_IT_SOURCE(&TimMasterHandle, TIM_IT_CC2) == SET) { __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_CC2); uint32_t val = __HAL_TIM_GetCounter(&TimMasterHandle); if ((val - PreviousVal) >= HAL_TICK_DELAY) { // Increment HAL variable HAL_IncTick(); // Prepare next interrupt __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_2, val + HAL_TICK_DELAY); PreviousVal = val; #if 0 // For DEBUG only HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_6); #endif } } } }
/** * @brief This function handles TIM5 interrupt request. * @param None * @retval None */ void TIM5_IRQHandler(void) { /* clear interrupt pending flag */ __HAL_TIM_CLEAR_IT(&htim5, TIM_IT_UPDATE); rtimer_clock++; }
void timer_irq_handler(void) { uint16_t cnt_val = TIM_MST->CNT; TimMasterHandle.Instance = TIM_MST; // Clear Update interrupt flag if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_UPDATE) == SET) { if (__HAL_TIM_GET_IT_SOURCE(&TimMasterHandle, TIM_IT_UPDATE) == SET) { __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_UPDATE); SlaveCounter++; } } // Channel 1 for mbed timeout if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_CC1) == SET) { if (__HAL_TIM_GET_IT_SOURCE(&TimMasterHandle, TIM_IT_CC1) == SET) { __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_CC1); if (oc_rem_part > 0) { set_compare(oc_rem_part); // Finish the remaining time left oc_rem_part = 0; } else { if (oc_int_part > 0) { set_compare(0xFFFF); oc_rem_part = cnt_val; // To finish the counter loop the next time oc_int_part--; } else { us_ticker_irq_handler(); } } } } // Channel 2 for HAL tick if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_CC2) == SET) { if (__HAL_TIM_GET_IT_SOURCE(&TimMasterHandle, TIM_IT_CC2) == SET) { __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_CC2); uint32_t val = __HAL_TIM_GetCounter(&TimMasterHandle); if ((val - PreviousVal) >= HAL_TICK_DELAY) { // Increment HAL variable HAL_IncTick(); // Prepare next interrupt __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_2, val + HAL_TICK_DELAY); PreviousVal = val; } } } }
// ----- TIM_IRQHandler() ---------------------------------------------------- extern "C" void TIM3_IRQHandler(void) { if (__HAL_TIM_GET_ITSTATUS(&imu10DOF.TimHandle, TIM_IT_UPDATE ) != RESET) { semaphore_timerInterrupt = 1; imu10DOF.timerAction(); semaphore_timerInterrupt = 0; __HAL_TIM_CLEAR_IT(&imu10DOF.TimHandle, TIM_IT_UPDATE); } }
void TIM8_TRG_COM_TIM14_IRQHandler(void) { { auto& h = Private::get_timer_cube_handle<14>(); if(__HAL_TIM_GET_ITSTATUS(&h, TIM_IT_UPDATE) == SET) { if(Private::get_timer_irq_handler<14>()) Private::get_timer_irq_handler<14>()(); __HAL_TIM_CLEAR_IT(&h, TIM_IT_UPDATE); } } }
void vMBPortTimersDisable( ) { /* Disable any pending timers. */ __HAL_TIM_DISABLE(&htim6); __HAL_TIM_SetCounter(&htim6,0); __HAL_TIM_DISABLE_IT(&htim6,TIM_IT_UPDATE); __HAL_TIM_CLEAR_IT(&htim6,TIM_IT_UPDATE); }
void TIM6_DAC_IRQHandler(void) { if (__HAL_TIM_GET_FLAG(&handleTIM6forTimer, TIM_FLAG_UPDATE) == SET && __HAL_TIM_GET_ITSTATUS(&handleTIM6forTimer, TIM_IT_UPDATE)) { Timer_Update1ms(); __HAL_TIM_CLEAR_FLAG(&handleTIM6forTimer, TIM_FLAG_UPDATE); __HAL_TIM_CLEAR_IT(&handleTIM6forTimer, TIM_IT_UPDATE); } }
//void WWDG_IRQHandler( void ) //void PVD_IRQHandler( void ) //void TAMP_STAMP_IRQHandler( void ) //void RTC_WKUP_IRQHandler( void ) //void FLASH_IRQHandler( void ) //void RCC_IRQHandler( void ) //void EXTI0_IRQHandler( void ) //void EXTI1_IRQHandler( void ) //void EXTI2_IRQHandler( void ) //void EXTI3_IRQHandler( void ) //void EXTI4_IRQHandler( void ) //void DMA1_Stream0_IRQHandler( void ) //void DMA1_Stream1_IRQHandler( void ) //void DMA1_Stream2_IRQHandler( void ) //void DMA1_Stream3_IRQHandler( void ) //void DMA1_Stream4_IRQHandler( void ) //void DMA1_Stream5_IRQHandler( void ) //void DMA1_Stream6_IRQHandler( void ) //void ADC_IRQHandler( void ) //void EXTI9_5_IRQHandler( void ) //void TIM1_BRK_TIM9_IRQHandler( void ) //void TIM1_UP_TIM10_IRQHandler( void ) //void TIM1_TRG_COM_TIM11_IRQHandler( void ) //void TIM1_CC_IRQHandler( void ) //void TIM2_IRQHandler( void ) void TIM3_IRQHandler( void ) { if (__HAL_TIM_GET_FLAG(hTimAhrs.handle, TIM_FLAG_UPDATE) != RESET) { if (__HAL_TIM_GET_IT_SOURCE(hTimAhrs.handle, TIM_IT_UPDATE) != RESET) { __HAL_TIM_CLEAR_IT(hTimAhrs.handle, TIM_IT_UPDATE); hTimAhrs.EventCallback(); } } }
void vMBPortTimersEnable( ) { /* Enable the timer with the timeout passed to xMBPortTimersInit( ) */ /* Enable the timer with the timeout passed to xMBPortTimersInit( ) */ __HAL_TIM_CLEAR_IT(&htim6,TIM_IT_UPDATE); __HAL_TIM_ENABLE_IT(&htim6,TIM_IT_UPDATE); __HAL_TIM_SetCounter(&htim6,0); __HAL_TIM_ENABLE(&htim6); }
void TIM6_IRQHandler(void) { if(__HAL_TIM_GET_FLAG(&TIM_ADC_HandleStruct, TIM_FLAG_UPDATE) != RESET){ if(__HAL_TIM_GET_IT_SOURCE(&TIM_ADC_HandleStruct, TIM_IT_UPDATE) !=RESET){ __HAL_TIM_CLEAR_IT(&TIM_ADC_HandleStruct, TIM_IT_UPDATE); ///时基中断 drv_StartMeasureTemperatureRaw(); } } }
// Timer 1 Update interrupt void TIM1_UP_TIM16_IRQHandler(void) { if(__HAL_TIM_GET_FLAG(&TimHandle[1], TIM_FLAG_UPDATE) != RESET) { if(__HAL_TIM_GET_ITSTATUS(&TimHandle[1], TIM_IT_UPDATE) !=RESET) { __HAL_TIM_CLEAR_IT(&TimHandle[1], TIM_IT_UPDATE); encoderSpeed[1] = PERIOD; // If timer expires we have got no pulse during measurment period, set max time } } }
void TCX_IRQHANDLER( void ) { //HAL_UART_Transmit(&huart1, "T", 1, 0xFFFF); __HAL_TIM_DISABLE(&htim1); __HAL_TIM_CLEAR_IT(&htim1, TIM_IT_UPDATE); #if MB_TIMER_DEBUG == 1 PIO_Clear( &xTimerDebugPins[0] ); #endif ( void )pxMBPortCBTimerExpired( ); }
// Timer 1 capture compare interrupt void TIM1_CC_IRQHandler(void) { if(__HAL_TIM_GET_FLAG(&TimHandle[1], TIM_FLAG_CC2) != RESET) { if(__HAL_TIM_GET_ITSTATUS(&TimHandle[1], TIM_IT_CC2) !=RESET) { { __HAL_TIM_CLEAR_IT(&TimHandle[1], TIM_IT_CC2); encoderSpeed[1] = HAL_TIM_ReadCapturedValue(&TimHandle[1], TIM_CHANNEL_2); TIM1->CNT = 0; } } } }
static void tim_irq_handler(void) { TIM_HandleTypeDef *htim; for (hacs_timer_t index = 0; index < HACS_NUM_TIMER_PERIPH; index++) { htim = &tim_handles[index]; // Only care about update event. Code copied from stm32f4xx_tim.c if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_UPDATE) != RESET) { if(__HAL_TIM_GET_ITSTATUS(htim, TIM_IT_UPDATE) !=RESET) { __HAL_TIM_CLEAR_IT(htim, TIM_IT_UPDATE); if (tim_overflow_cb[index] != NULL) tim_overflow_cb[index](); } } } }
/* ----------------------- Start implementation -----------------------------*/ BOOL xMBPortTimersInit( USHORT usTim1Timerout50us ) { HAL_UART_Transmit(&huart1, "_TI_" , 4, 0xFFFF); #if MB_TIMER_DEBUG == 1 PIO_Configure( xTimerDebugPins, PIO_LISTSIZE( xTimerDebugPins ) ); #endif __HAL_TIM_DISABLE_IT(&htim1, TIM_IT_UPDATE); htim1.Init.Period = ( 50 * usTim1Timerout50us ); //htim1.Init.Period = ( 50 * 1000 ); HAL_TIM_Base_Init(&htim1); HAL_NVIC_ClearPendingIRQ(TIM1_UP_IRQn); __HAL_TIM_CLEAR_IT(&htim1, TIM_IT_UPDATE); return TRUE; }
void TIM_IRQH(void){ #if MEAS_ENABLED static volatile uint32_t PerformaceTimer = MEAS_PERIOD; #endif //If update interrupt is pending and update interrupt is enabled, clear update int flag, increment tick variable and if needed calculate cpu usage if( ( __HAL_TIM_GET_FLAG(&Tmr, TIM_FLAG_UPDATE) != RESET ) && ( __HAL_TIM_GET_ITSTATUS(&Tmr, TIM_IT_UPDATE) !=RESET ) ){ __HAL_TIM_CLEAR_IT(&Tmr, TIM_IT_UPDATE); Tick++; #if MEAS_ENABLED if( PerformaceTimer-- <= 0 ){ PerformaceTimer = MEAS_PERIOD; Perf.CpuLoadVal = PerformanceCounter; Perf.CPULoad = 1 - (float)PerformanceCounter/(float)NOLOAD_PERF; PerformanceCounter = 0; } #endif } }
/*General Interrupt handler which handles interrupts for Laser trasnmit and writing angles to pan and tilt. The interrupt is set to occur every half manchester bit period for the purposes of transmitting manchester using GPIO*/ void s4353096_general_irqhandler(void) { TIM_Init.Instance = PANTILT_IR_TIM; __HAL_TIM_CLEAR_IT(&TIM_Init, TIM_IT_UPDATE); vars->count++; if (mode == S4353096_LASER_TRANSMIT) { if (vars->bit_count == 0 || vars->bit_count == 1 || vars->bit_count == 11 || vars->bit_count == 12) { s4353096_laser_transmit_bit(1); } else if (vars->bit_count == 10 || vars->bit_count == 21) { s4353096_laser_transmit_bit(0); } else if ((vars->bit_count == 22) && (vars->bit_half == 1)) { //Stop transmitting and reset values HAL_GPIO_WritePin(LASER_WAVE_GEN_1_GPIO_PORT, LASER_WAVE_GEN_1_PIN, 0); vars->bit_count = 0; vars->encoded_bit_count = -1; mode = S4353096_TERMINAL; } else { if (vars->bit_half == 1) { vars->encoded_bit_count++; vars->encoded_bit = !!((vars->encoded_char >> vars->encoded_bit_count) & 0x1); } s4353096_laser_transmit_bit(vars->encoded_bit); } }
void us_ticker_clear_interrupt(void) { __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_CC1); }
static void lp_handler(void) { __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_CC1); overflows++; }