void TIMER1_IRQHandler(void) { if ((US_TICKER_TIMER->EVENTS_COMPARE[1] != 0) && ((US_TICKER_TIMER->INTENSET & TIMER_INTENSET_COMPARE1_Msk) != 0)) { US_TICKER_TIMER->EVENTS_COMPARE[1] = 0; overflow++; US_TICKER_TIMER->CC[1] = 0xFFFF; if (timeStamp>0) { timeStamp--; if (timeStamp==0) { us_ticker_clear_interrupt(); us_ticker_disable_interrupt(); us_ticker_irq_handler(); return; } } } if ((US_TICKER_TIMER->EVENTS_COMPARE[0] != 0) && ((US_TICKER_TIMER->INTENSET & TIMER_INTENSET_COMPARE0_Msk) != 0)) { us_ticker_clear_interrupt(); us_ticker_disable_interrupt(); if (timeStamp==0) { us_ticker_irq_handler(); } } }
//****************************************************************************** static void tmr_handler(void) { uint32_t term_cnt32 = US_TIMER->term_cnt32; US_TIMER->term_cnt32 = 0xFFFFFFFF; // reset to max value to prevent further interrupts US_TIMER->intfl = (MXC_F_TMR_INTFL_TIMER0 | MXC_F_TMR_INTFL_TIMER1); // clear interrupt NVIC_ClearPendingIRQ(US_TIMER_IRQn); inc_current_cnt(term_cnt32); if (event_passed(current_cnt + US_TIMER->count32, event_cnt )) { // the timestamp has expired event_cnt = 0xFFFFFFFFFFFFFFFFULL; // reset to max value us_ticker_irq_handler(); } else { uint64_t diff = event_diff(current_cnt, event_cnt); if (diff < (uint64_t)0xFFFFFFFF) { // the event occurs before the next overflow US_TIMER->term_cnt32 = diff; // Since the timer keeps counting after the terminal value is reached, it is possible that the new // terminal value is in the past. if (US_TIMER->term_cnt32 < US_TIMER->count32) { // the timestamp has expired US_TIMER->term_cnt32 = 0xFFFFFFFF; // reset to max value to prevent further interrupts US_TIMER->intfl = (MXC_F_TMR_INTFL_TIMER0 | MXC_F_TMR_INTFL_TIMER1); // clear interrupt NVIC_ClearPendingIRQ(US_TIMER_IRQn); event_cnt = 0xFFFFFFFFFFFFFFFFULL; // reset to max value us_ticker_irq_handler(); } } } }
void TMR0_IRQHandler(void) { us_ticker_clear_interrupt(); // NOTE: us_ticker_set_interrupt() may get called in us_ticker_irq_handler(); us_ticker_irq_handler(); }
static void tim_irq_handler(void) { uint16_t cval = TIM_MST->CNT; if (TIM_GetITStatus(TIM_MST, TIM_IT_Update) == SET) { TIM_ClearITPendingBit(TIM_MST, TIM_IT_Update); SlaveCounter++; } if (TIM_GetITStatus(TIM_MST, TIM_IT_CC1) == SET) { TIM_ClearITPendingBit(TIM_MST, 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 = cval; // To finish the counter loop the next time oc_int_part--; } else { us_ticker_irq_handler(); } } } }
static void tmr0_vec(void) { TIMER_ClearIntFlag((TIMER_T *) NU_MODBASE(TIMER_MODINIT.modname)); // NOTE: us_ticker_set_interrupt() may get called in us_ticker_irq_handler(); us_ticker_irq_handler(); }
static void tmr0_vec(void) { us_ticker_clear_interrupt(); // NOTE: us_ticker_set_interrupt() may get called in us_ticker_irq_handler(); us_ticker_irq_handler(); }
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 } } } }
void DUALTIMER0_Handler(void) { if(DUALTIMER_GetIntStatus(DUALTIMER0_0)) { DUALTIMER_IntClear(DUALTIMER0_0); us_ticker_irq_handler(); } }
/****************************************************************************** * INTERRUPTS HANDLING ******************************************************************************/ void vAHI_IntHandlerTimer1(void) { // Make use of hardware masked interrupt status register uint32_t u32Isr = u32REG_TimerRead(US_TICKER_TIMER, REG_TMR_MINT); vREG_TimerWrite(US_TICKER_TIMER, REG_TMR_MINT, u32Isr); // clear interrupts immediately if(u32Isr == REG_TMR_INT_P_EN_MASK) { us_ticker_irq_handler(); } }
static void pit_isr(void) { PIT_ClearStatusFlags(PIT, kPIT_Chnl_3, PIT_TFLG_TIF_MASK); PIT_ClearStatusFlags(PIT, kPIT_Chnl_2, PIT_TFLG_TIF_MASK); PIT_StopTimer(PIT, kPIT_Chnl_2); PIT_StopTimer(PIT, kPIT_Chnl_3); us_ticker_irq_handler(); }
void us_ticker_irq_handler_internal(struct tc_module* us_tc_module) { uint32_t status_flags; /* Clear TC capture overflow and TC count overflow */ status_flags = TC_STATUS_CAPTURE_OVERFLOW | TC_STATUS_COUNT_OVERFLOW; tc_clear_status(&us_ticker_module, status_flags); us_ticker_irq_handler(); }
static void tmr1_vec(void) { TIMER_ClearIntFlag((TIMER_T *) NU_MODBASE(timer1hires_modinit.modname)); cd_major_minor_us = (cd_major_minor_us > cd_minor_us) ? (cd_major_minor_us - cd_minor_us) : 0; if (cd_major_minor_us == 0) { // NOTE: us_ticker_set_interrupt() may get called in us_ticker_irq_handler(); us_ticker_irq_handler(); } else { us_ticker_arm_cd(); } }
static void ticker_isr(void) { // Clear IRQ flag PIT_TICKER.TFLG = 1; if (us_ticker_int_counter > 0) { ticker_set(0xFFFFFFFF); us_ticker_int_counter--; } else { // This function is going to disable the interrupts if there are // no other events in the queue us_ticker_irq_handler(); } }
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; } } } }
void us_ticker_set_interrupt(timestamp_t timestamp) { int delta = (int)((uint32_t)timestamp - us_ticker_read()); uint16_t cval = TIM_MST->CNT; if (delta <= 0) { // This event was in the past us_ticker_irq_handler(); } else { oc_int_part = (uint32_t)(delta >> 16); oc_rem_part = (uint16_t)(delta & 0xFFFF); if (oc_rem_part <= (0xFFFF - cval)) { set_compare(cval + oc_rem_part); oc_rem_part = 0; } else { set_compare(0xFFFF); oc_rem_part = oc_rem_part - (0xFFFF - cval); } } }
void us_ticker_set_interrupt(timestamp_t timestamp) { uint32_t timer_value = 0; int delta = 0; if (!us_ticker_inited) us_ticker_init(); delta = (int)(timestamp - us_ticker_read()); if (delta <= 0) { // This event was in the past: us_ticker_irq_handler(); return; } timer_value = (delta)*25; // enable interrupt US_TICKER_TIMER1->TimerControl = 0x0; // disable timer US_TICKER_TIMER1->TimerControl = 0x62; // enable interrupt and set to 32 bit counter and set to periodic mode US_TICKER_TIMER1->TimerLoad = (delta)*25; //initialise the timer value US_TICKER_TIMER1->TimerControl |= 0x80; //enable timer }
void us_ticker_set_interrupt(timestamp_t timestamp) { uint32_t cur_time; int32_t delta; cur_time = us_ticker_read(); delta = (int32_t)((uint32_t)timestamp - cur_time); if (delta < 0) { /* Event already occurred in past */ us_ticker_irq_handler(); return; } NVIC_DisableIRQ(TICKER_COUNTER_IRQn); NVIC_SetVector(TICKER_COUNTER_IRQn, (uint32_t)TICKER_COUNTER_Handlr); /* Enable the callback */ tc_enable_callback(&us_ticker_module, TC_CALLBACK_CC_CHANNEL0); tc_set_compare_value(&us_ticker_module, TC_COMPARE_CAPTURE_CHANNEL_0, (uint32_t)timestamp); NVIC_EnableIRQ(TICKER_COUNTER_IRQn); }
static void tpm_isr(void) { // Clear the TPM timer overflow flag TPM_ClearStatusFlags(TPM2, kTPM_TimeOverflowFlag); TPM_StopTimer(TPM2); if (us_ticker_int_counter > 0) { TPM2->MOD = 0xFFFF; TPM_StartTimer(TPM2, kTPM_SystemClock); us_ticker_int_counter--; } else { if (us_ticker_int_remainder > 0) { TPM2->MOD = us_ticker_int_remainder; TPM_StartTimer(TPM2, kTPM_SystemClock); us_ticker_int_remainder = 0; } else { // This function is going to disable the interrupts if there are // no other events in the queue us_ticker_irq_handler(); } } }
// Used by interrupt system static void tim_oc_irq_handler(void) { uint16_t cval = TIM_MST->CNT; TimMasterHandle.Instance = TIM_MST; // Clear CC1 interrupt flag if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_CC1) == SET) { __HAL_TIM_CLEAR_FLAG(&TimMasterHandle, TIM_FLAG_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 = cval; // To finish the counter loop the next time oc_int_part--; } else { us_ticker_irq_handler(); } } }
void us_ticker_set_interrupt(timestamp_t timestamp) { int delta = (int)((uint32_t)timestamp - us_ticker_read()); if (delta <= 0) { // This event was in the past: us_ticker_irq_handler(); return; } //Calculate how much falls outside the 32-bit after multiplying with clk_mhz //We shift twice 16-bit to keep everything within the 32-bit variable us_ticker_int_counter = (uint32_t)(delta >> 16); us_ticker_int_counter *= clk_mhz; us_ticker_int_counter >>= 16; uint32_t us_ticker_int_remainder = (uint32_t)delta * clk_mhz; if (us_ticker_int_remainder == 0) { ticker_set(0xFFFFFFFF); us_ticker_int_counter--; } else { ticker_set(us_ticker_int_remainder); } }
void us_ticker_set_interrupt(timestamp_t timestamp) { int32_t dev = 0; if (!us_ticker_inited) { us_ticker_init(); } dev = (int32_t)(timestamp - us_ticker_read()); dev = dev * ((GetSystemClock() / 1000000) / 16); if(dev <= 0) { us_ticker_irq_handler(); return; } DUALTIMER_ClockEnable(TIMER_0); DUALTIMER_Stop(TIMER_0); TimerHandler.TimerControl_Mode = DUALTIMER_TimerControl_Periodic; TimerHandler.TimerControl_OneShot = DUALTIMER_TimerControl_OneShot; TimerHandler.TimerControl_Pre = DUALTIMER_TimerControl_Pre_16; TimerHandler.TimerControl_Size = DUALTIMER_TimerControl_Size_32; TimerHandler.TimerLoad = (uint32_t)dev; DUALTIMER_Init(TIMER_0, &TimerHandler); DUALTIMER_IntConfig(TIMER_0, ENABLE); NVIC_EnableIRQ(TIMER_IRQn); DUALTIMER_Start(TIMER_0); }
// Used for mbed timeout (channel 1) and HAL tick (channel 2) void timer_oc_irq_handler(void) { uint16_t cval = TIM_MST->CNT; TimMasterHandle.Instance = TIM_MST; // Channel 1 for mbed timeout if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_CC1) == SET) { __HAL_TIM_CLEAR_FLAG(&TimMasterHandle, TIM_FLAG_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 = cval; // 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) { __HAL_TIM_CLEAR_FLAG(&TimMasterHandle, TIM_FLAG_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 } } }
void COMMON_RTC_IRQ_HANDLER(void) #endif { if (nrf_rtc_event_pending(COMMON_RTC_INSTANCE, US_TICKER_EVENT)) { us_ticker_irq_handler(); } #if DEVICE_LOWPOWERTIMER if (nrf_rtc_event_pending(COMMON_RTC_INSTANCE, LP_TICKER_EVENT)) { lp_ticker_irq_handler(); } #endif if (nrf_rtc_event_pending(COMMON_RTC_INSTANCE, NRF_RTC_EVENT_OVERFLOW)) { nrf_rtc_event_clear(COMMON_RTC_INSTANCE, NRF_RTC_EVENT_OVERFLOW); // Don't disable this event. It shall occur periodically. ++m_common_rtc_overflows; } }
void us_ticker_interrupt(void) { us_ticker_irq_handler(); }
/* An adaptor to interface us_ticker_irq_handler with the app_timer callback. * Needed because the irq_handler() doesn't take any parameter.*/ static void us_ticker_app_timer_callback(void *context) { us_ticker_appTimerRunning = false; us_ticker_irq_handler(); }
static inline void invokeCallback(void) { us_ticker_callbackPending = false; //tmr1_disableCompareInterrupt(); us_ticker_irq_handler(); }
VOID _us_ticker_irq_handler(IN VOID *Data) { us_ticker_irq_handler(); }