/////////////////////////////////////////////////////////////////////////////// /// @brief TIMER1 interrupt handler sub-routine /// @param[in] None /// @return None /////////////////////////////////////////////////////////////////////////////// void TIMER1_IRQHandler1(void) { // if (TIM_GetIntCaptureStatus(LPC_TIM1,0)) // { // TIM_ClearIntCapturePending(LPC_TIM1,0); if(TIM_GetIntStatus(LPC_TIM1, TIM_CR0_INT)) { TIM_ClearIntPending(LPC_TIM1, TIM_CR0_INT); uint32_t capt = TIM_GetCaptureValue(LPC_TIM1,0); uint32_t diff = capt - Timer1Capture0Value; if(diff > 5000) { if(Recv.index != 12) { GPIO_SetValue(TRIG_PORT, TRIG_PIN); tim_cr0_int_error++; GPIO_ClearValue(TRIG_PORT, TRIG_PIN); } Recv.index = 0; } else { if(Recv.index < MAX_CHANNELS && diff > 500 && diff < 2500) { Recv.channel[Recv.index] = diff; } Recv.index++; } Timer1Capture0Value = capt; } }
int Timer_delay_ms(int count) { // Initialize timer 0, prescale count time of 100uS TIM_ConfigStruct.PrescaleOption = TIM_PRESCALE_USVAL; TIM_ConfigStruct.PrescaleValue = 1000; // use channel 0, MR0 TIM_MatchConfigStruct.MatchChannel = 0; // Disable interrupt when MR0 matches the value in TC register TIM_MatchConfigStruct.IntOnMatch = TRUE; //Enable reset on MR0: TIMER will reset if MR0 matches it TIM_MatchConfigStruct.ResetOnMatch = TRUE; //Stop on MR0 if MR0 matches it TIM_MatchConfigStruct.StopOnMatch = FALSE; //Toggle MR0.0 pin if MR0 matches it TIM_MatchConfigStruct.ExtMatchOutputType =TIM_EXTMATCH_TOGGLE; // Set Match value, count value of 1000 (1000 * 100uS = 100mS --> 10Hz) TIM_MatchConfigStruct.MatchValue = count; // Set configuration for Tim_config and Tim_MatchConfig TIM_Init(LPC_TIM0, TIM_TIMER_MODE,&TIM_ConfigStruct); TIM_ConfigMatch(LPC_TIM0,&TIM_MatchConfigStruct); TIM_Cmd(LPC_TIM0,ENABLE); // Wait for 1000 millisecond while(!(TIM_GetIntStatus(LPC_TIM0,TIM_MR0_INT))); TIM_ClearIntPending(LPC_TIM0,TIM_MR0_INT); return 0; }
/*********************************************************************//** * @brief Timer 0 interrupt handler. This sub-routine will set/clear * two Phase A-B output pin to their phase state * @param[in] None * @return None **********************************************************************/ void TIMER0_IRQHandler(void) { if (TIM_GetIntStatus(LPC_TIM0,TIM_MR0_INT)) { // Set/Clear phase A/B pin corresponding to their state switch (PhaseCnt) { case 0: GPIO_SetValue(0,PHASE_A_PIN); GPIO_ClearValue(0,PHASE_B_PIN); break; case 1: GPIO_SetValue(0, PHASE_A_PIN | PHASE_B_PIN); break; case 2: GPIO_SetValue(0, PHASE_B_PIN); GPIO_ClearValue(0, PHASE_A_PIN); break; case 3: GPIO_ClearValue(0, PHASE_A_PIN | PHASE_B_PIN); break; default: break; } // update PhaseCnt PhaseCnt = (PhaseCnt + 1) & 0x03; // Clear Timer 0 match interrupt pending TIM_ClearIntPending(LPC_TIM0,TIM_MR0_INT); } }
/*********************************************************************//** * @brief Delay millisecond * @param[in] time (ms) * @return None **********************************************************************/ void Timer_Wait(uint32_t time) { // Initialize timer 0, prescale count time of 1ms TIM_ConfigStruct.PrescaleOption = TIM_PRESCALE_USVAL; TIM_ConfigStruct.PrescaleValue = 1000; // use channel 0, MR0 TIM_MatchConfigStruct.MatchChannel = 0; // Enable interrupt when MR0 matches the value in TC register TIM_MatchConfigStruct.IntOnMatch = TRUE; //Enable reset on MR0: TIMER will not reset if MR0 matches it TIM_MatchConfigStruct.ResetOnMatch = FALSE; //Stop on MR0 if MR0 matches it TIM_MatchConfigStruct.StopOnMatch = TRUE; //do no thing for external output TIM_MatchConfigStruct.ExtMatchOutputType =TIM_EXTMATCH_NOTHING; // Set Match value, count value is time (timer * 1000uS =timer mS ) TIM_MatchConfigStruct.MatchValue = time; // Set configuration for Tim_config and Tim_MatchConfig TIM_Init(LPC_TIM0, TIM_TIMER_MODE,&TIM_ConfigStruct); TIM_ConfigMatch(LPC_TIM0,&TIM_MatchConfigStruct); // To start timer 0 TIM_Cmd(LPC_TIM0,ENABLE); while ( !(TIM_GetIntStatus(LPC_TIM0,0))); TIM_ClearIntPending(LPC_TIM0,0); }
void TIMER1_IRQHandler(void){ // xprintf("TIMER1_IRQ"); if (TIM_GetIntStatus(LPC_TIM1,TIM_MR0_INT)){ TIM_ClearIntPending(LPC_TIM1, TIM_MR0_INT); LatchIn(); } }
void TIMER2_IRQHandler(void){ // xprintf("TIMER2_IRQ\r\n"); if (TIM_GetIntStatus(LPC_TIM2,TIM_MR0_INT)){ TIM_ClearIntPending(LPC_TIM2, TIM_MR0_INT); LED_INT_OCCURED = 1; } }
/*********************************************************************//** * @brief TIMER3 interrupt handler * @param None * @return None ***********************************************************************/ void TIMER3_IRQHandler(void) { //duty cycle = 50% TIM_Cmd(LPC_TIM3,DISABLE); TIM_ClearIntPending(LPC_TIM3, TIM_MR0_INT); TIM_ResetCounter(LPC_TIM3); TIM_Cmd(LPC_TIM3,ENABLE); }
int c_entry(void) { // Init LED port LED_Init(); /* * Initialize debug via UART */ debug_frmwrk_init(); // print welcome screen print_menu(); // Read back TimeOut flag to determine previous timeout reset if (WDT_ReadTimeOutFlag()){ _DBG_(info1); // Clear WDT TimeOut WDT_ClrTimeOutFlag(); } else{ _DBG_(info2); } // Initialize WDT, IRC OSC, interrupt mode, timeout = 2000000 microsecond WDT_Init(WDT_CLKSRC_IRC, WDT_MODE_RESET); // Start watchdog with timeout given WDT_Start(WDT_TIMEOUT); // set timer 100 ms Timer_Wait(100); while (1){ // Wait for 100 millisecond while ( !(TIM_GetIntStatus(LPC_TIM0,0))); TIM_ClearIntPending(LPC_TIM0,0); //turn on led FIO_ByteSetValue(2, 0, LED_PIN); // Wait for 100 millisecond while ( !(TIM_GetIntStatus(LPC_TIM0,0))); TIM_ClearIntPending(LPC_TIM0,0); //turn off led FIO_ByteClearValue(2, 0, LED_PIN); } return 0; }
void TIMER0_IRQHandler(void) { if (TIM_GetIntStatus(LPC_TIM0, TIM_MR0_INT) != RESET) { TIM_ClearIntPending(LPC_TIM0, TIM_MR0_INT); rt_device_hwtimer_isr(&_timer0); } }
void TIMER32_0_IRQHandler() { static unsigned int duty_counter_r = 0; static unsigned int duty_counter_g = 0; static unsigned int duty_counter_b = 0; static unsigned int bl_duty_counter = 0; static unsigned int period_counter = 0; static int activity_counter = 0; CoEnterISR(); TIM_ClearIntPending(LPC_TMR32B0, TIM_MR0_INT); // 39.0625us activity indicator (for calibration) GPIO_ToggleBits(TIMER_ACTIVITY_PORT, TIMER_ACTIVITY_PIN); if( period_counter -- > 0 ) { if( duty_counter_r -- == 0 ) GPIO_ResetBits(RED_PORT, RED_PIN); if( duty_counter_g -- == 0 ) GPIO_ResetBits(GREEN_PORT, GREEN_PIN); if( duty_counter_b -- == 0 ) GPIO_ResetBits(BLUE_PORT, BLUE_PIN); if (bl_duty_counter-- == 0) GPIO_ResetBits(LCD_BACKLITE_PORT, LCD_BACKLITE_PIN); } else { if( activity_counter ++ >= TICKS_PER_SECOND ) { activity_counter = 0; GPIO_ToggleBits(TIMER_ACTIVITY_PORT, TIMER_ACTIVITY_PIN); //if( device_mode == AMBIENT_TEMPERATURE ) // PLUGIN_Temperature_Update(); } SEQ_Tick(); duty_counter_r = SEQ_CurrentRed(); duty_counter_r == 0 ? GPIO_ResetBits(RED_PORT, RED_PIN) : GPIO_SetBits(RED_PORT, RED_PIN); duty_counter_g = SEQ_CurrentGreen(); duty_counter_g == 0 ? GPIO_ResetBits(GREEN_PORT, GREEN_PIN ) : GPIO_SetBits(GREEN_PORT, GREEN_PIN ); duty_counter_b = SEQ_CurrentBlue(); duty_counter_b == 0 ? GPIO_ResetBits(BLUE_PORT, BLUE_PIN ) : GPIO_SetBits(BLUE_PORT, BLUE_PIN ); bl_duty_counter = backlite_power; bl_duty_counter == 0 ? GPIO_ResetBits(LCD_BACKLITE_PORT, LCD_BACKLITE_PIN) : GPIO_SetBits(LCD_BACKLITE_PORT, LCD_BACKLITE_PIN); period_counter = 255; } CoExitISR(); }
void TIMER0_IRQHandler(void){ char msg[BUFFLENGTH] = ""; char* strPtr = &msg; if (TIM_GetIntStatus(LPC_TIM0, TIM_MR0_INT)== SET){ TIM_Cmd(LPC_TIM0,DISABLE); TIM_ResetCounter(LPC_TIM0); tim0_flag = 1; TIM_Cmd(LPC_TIM0,ENABLE); } TIM_ClearIntPending(LPC_TIM0, TIM_MR0_INT); }
// stop the timer and disable interrupts void disableHwTimer (uint16_t timerNum) { /* Stop timer*/ TIM_Cmd(pTimerRegs[timerNum], DISABLE); /* Clear timer pending interrupt */ TIM_ClearIntPending(pTimerRegs[timerNum], TIM_MR0_INT); /* Disable interrupt for timer*/ NVIC_DisableIRQ(TimerConfig[timerNum].TimerIrq); }
void TIMER1_IRQHandler(void) { PWM_MATCHCFG_Type PWMMatchCfgDat; if (TIM_GetIntStatus(LPC_TIM1, TIM_MR1_INT)== SET) { amp += 0.5; freq += 100; } TIM_ClearIntPending(LPC_TIM1, TIM_MR1_INT); }
/*********************************************************************//** * @brief TIMER1 interrupt handler * @param None * @return None ***********************************************************************/ void TIMER1_IRQHandler(void) { //duty cycle = 25% TIM_Cmd(LPC_TIM1,DISABLE); TIM_ClearIntPending(LPC_TIM1, TIM_MR0_INT); TIM_ResetCounter(LPC_TIM1); if((PWM1_State == ENABLE)) { TIM_UpdateMatchValue(LPC_TIM1,0, 200); PWM1_State = DISABLE; } else { TIM_UpdateMatchValue(LPC_TIM1,0, 600); PWM1_State = ENABLE; } TIM_Cmd(LPC_TIM1,ENABLE); }
/*********************************************************************//** * @brief TIMER0 interrupt handler * @param None * @return None ***********************************************************************/ void TIMER0_IRQHandler(void) { //duty cycle = 12.5% TIM_Cmd(LPC_TIM0,DISABLE); TIM_ClearIntPending(LPC_TIM0, TIM_MR0_INT); TIM_ResetCounter(LPC_TIM0); if((PWM0_State == ENABLE)) { TIM_UpdateMatchValue(LPC_TIM0, 0, 100); PWM0_State = DISABLE; } else { TIM_UpdateMatchValue(LPC_TIM0, 0, 700); PWM0_State = ENABLE; } TIM_Cmd(LPC_TIM0,ENABLE); }
/*********************************************************************//** * @brief TIMER2 interrupt handler * @param None * @return None ***********************************************************************/ void TIMER2_IRQHandler(void) { //duty cycle = 37,5% TIM_Cmd(LPC_TIM2,DISABLE); TIM_ClearIntPending(LPC_TIM2, TIM_MR0_INT); TIM_ResetCounter(LPC_TIM2); if((PWM2_State == ENABLE)) { TIM_UpdateMatchValue(LPC_TIM2,0, 300); PWM2_State = DISABLE; } else { TIM_UpdateMatchValue(LPC_TIM2,0, 500); PWM2_State = ENABLE; } TIM_Cmd(LPC_TIM2,ENABLE); }
/*********************************************************************//** * @brief TIM3 interrupt handler sub-routine * @param None * @return None **********************************************************************/ void TIMER3_IRQHandler(void) { if (TIM_GetIntStatus(LPC_TIM3, TIM_MR0_INT)== SET) { TIM_Cmd(LPC_TIM3,DISABLE); // Disable Timer TIM_ResetCounter(LPC_TIM3); if(toggle_tim3 == TRUE) { TIM_UpdateMatchValue(LPC_TIM3,0,T1*10);//MAT3.0 toggle_tim3=FALSE; } else { TIM_UpdateMatchValue(LPC_TIM3,0,T2*10); toggle_tim3=TRUE; } TIM_Cmd(LPC_TIM3,ENABLE); // Start Timer } TIM_ClearIntPending(LPC_TIM3, TIM_MR0_INT); // clear Interrupt }
void TIMER32_1_IRQHandler(void) { /* Clear the pending interrupt */ frequency = LPC_TMR32B0->TC; TIM_Cmd(LPC_TMR32B0, DISABLE); TIM_ClearIntPending(LPC_TMR32B1, TIM_MR0_INT); TIM_Cmd(LPC_TMR32B1, DISABLE); if(blink) { GPIO_SetBits(PORT0, GPIO_Pin_7); } else { GPIO_ResetBits(PORT0, GPIO_Pin_7); } blink ^= 1; lcd_string("F = ", 2); lcdwriteint(frequency, 5); //SSP_SendData(LPC_SSP1, (uint16_t)frequency); LPC_TMR32B0->TC = 0; GPIO_PortIntCmd(PORT3, ENABLE); }
void TIMER0_IRQHandler () { if (TIM_GetIntStatus(LPC_TIM0, TIM_MR0_INT) == SET) { NVIC_DisableIRQ(TIMER0_IRQn); //disable interrupt, to prevent it from overlapping if it takes too long to process TIM_ClearIntPending(LPC_TIM0,TIM_MR0_INT); TIM_ResetCounter(LPC_TIM0); #if DEBUG==1 && TRACE==1 tty_writeln("Timer trigger"); #endif if (scramble_mode) { scramble_timer_handler(); } else { filter_loop(); } cycle++; //used for sine wave generation if(cycle > frequency) cycle = 0; NVIC_EnableIRQ(TIMER0_IRQn); } }
void TIMER2_IRQHandler( ) { GPIO_SetValue(0, 0x01<<9); TIM_ClearIntPending(LPC_TIM2, TIM_MR0_INT); // TIM_Cmd(LPC_TIM2, DISABLE); }
/*********************************************************************//** * @brief TIM2 interrupt handler sub-routine * @param None * @return None **********************************************************************/ void TIMER2_IRQHandler(void) { TIM_ClearIntPending(LPC_TIM2, TIM_MR0_INT); // clear Interrupt }
void TIMER0_IRQHandler(void){ // xprintf("TIMER0_IRQ"); if (TIM_GetIntStatus(LPC_TIM0,TIM_MR0_INT)){ TIM_ClearIntPending(LPC_TIM0, TIM_MR0_INT); #if 0 if(TOG[0]) // FIO_SetValue(LED_LE_PORT, LED_LE_BIT); GPIO_SetValue(LED_4_PORT, LED_4_BIT); else // FIO_ClearValue(LED_LE_PORT, LED_LE_BIT); GPIO_ClearValue(LED_4_PORT, LED_4_BIT); TOG[0]=!TOG[0]; // TIM_ClearIntPending(LPC_TIM0, TIM_MR0_INT); // return; #endif // xprintf(INFO "RIT N=%d B=%x NXT_T=%d TX=%x\n",SENDSEQ,SEND_BIT,DELAY_TIME,LED_PRECALC[0][SEND_BIT]); //Setup new timing for next Timer DELAY_TIME=SEQ_TIME[SENDSEQ]; SEND_BIT=SEQ_BIT[SENDSEQ]; //Retart sequence if required SENDSEQ++; SENDSEQ>=no_SEQ_BITS ? SENDSEQ=0 : 0; #ifdef DMA // xprintf("SEND_BIT:%d\n",SEND_BIT); // xprintf("DELAY_TIME:%d\n",DELAY_TIME); GPDMACfg.DMALLI = (uint32_t) &LinkerList[0][SEND_BIT][BufferNo]; GPDMA_Setup(&GPDMACfg); GPDMA_ChannelCmd(0, ENABLE); #endif TIM_UpdateMatchValue(LPC_TIM0,0,DELAY_TIME); FIO_SetValue(LED_OE_PORT, LED_OE_BIT); #ifdef RxDMA GPDMA_ChannelCmd(1, ENABLE); uint8_t reg; for(reg=6; 0<reg;reg--){ xprintf("%d ",reg-1); #if 0 if(BUFFER==1) SSP_SendData(LED_SPI_CHN, LED_PRECALC1[reg][SEND_BIT]); else SSP_SendData(LED_SPI_CHN, LED_PRECALC2[reg][SEND_BIT]); #endif //WaitForSend();//Wait if TX buffer full //while(LED_SPI_CHN->SR & SSP_STAT_BUSY); while(SSP_GetStatus(LED_SPI_CHN, SSP_STAT_BUSY)){ }; SSP_SendData(LED_SPI_CHN, LED_PRECALC[reg-1][SEND_BIT]); xprintf("%4x ",(LED_PRECALC[reg-1][SEND_BIT])); } for(reg=12; reg>6;reg--){ xprintf("%d ",reg-1); #if 0 if(BUFFER==1) SSP_SendData(LED_SPI_CHN, LED_PRECALC1[reg][SEND_BIT]); else SSP_SendData(LED_SPI_CHN, LED_PRECALC2[reg][SEND_BIT]); #endif //WaitForSend();//Wait if TX buffer full while(SSP_GetStatus(LED_SPI_CHN, SSP_STAT_BUSY)){ } SSP_SendData(LED_SPI_CHN, LED_PRECALC[reg-1][SEND_BIT]); // if (reg==7){ xprintf("%4x ",(LED_PRECALC[reg-1][SEND_BIT])); // } } LatchIn(); #endif /* UPDATE_COUNT+=1; ATE_COUNT=0; LED_UPDATE_REQUIRED=1; }*/ } }
void TIMER3_IRQHandler(void) { TIM_ClearIntPending(LPC_TIM3, TIM_MR0_INT); diskTick100Hz(); joulesUpdateTotals100Hz(); }
void tim_clearint(int dev) { TIM_ClearIntPending(tim_devs[dev], TIM_MR0_INT); }
int c_entry(void) { // DeInit NVIC and SCBNVIC NVIC_DeInit(); NVIC_SCBDeInit(); /* Configure the NVIC Preemption Priority Bits: * two (2) bits of preemption priority, six (6) bits of sub-priority. * Since the Number of Bits used for Priority Levels is five (5), so the * actual bit number of sub-priority is three (3) */ NVIC_SetPriorityGrouping(0x05); // Set Vector table offset value #if (__RAM_MODE__==1) NVIC_SetVTOR(0x10000000); #else NVIC_SetVTOR(0x00000000); #endif // Init LED port LED_Init(); /* Init debug */ debug_frmwrk_init(); // print welcome screen print_menu(); // Initialize timer 0, prescale count time of 100uS TIM_ConfigStruct.PrescaleOption = TIM_PRESCALE_USVAL; TIM_ConfigStruct.PrescaleValue = 100; // use channel 0, MR0 TIM_MatchConfigStruct.MatchChannel = 0; // Disable interrupt when MR0 matches the value in TC register TIM_MatchConfigStruct.IntOnMatch = TRUE; //Enable reset on MR0: TIMER will reset if MR0 matches it TIM_MatchConfigStruct.ResetOnMatch = TRUE; //Stop on MR0 if MR0 matches it TIM_MatchConfigStruct.StopOnMatch = FALSE; //Toggle MR0.0 pin if MR0 matches it TIM_MatchConfigStruct.ExtMatchOutputType =TIM_EXTMATCH_TOGGLE; // Set Match value, count value of 10000 (10000 * 100uS = 1S --> 1Hz) TIM_MatchConfigStruct.MatchValue = 10000; // Set configuration for Tim_config and Tim_MatchConfig TIM_Init(LPC_TIM0, TIM_TIMER_MODE,&TIM_ConfigStruct); TIM_ConfigMatch(LPC_TIM0,&TIM_MatchConfigStruct); TIM_Cmd(LPC_TIM0,ENABLE); while (1) { // Wait for 1000 millisecond while ( !(TIM_GetIntStatus(LPC_TIM0,0))); { TIM_ClearIntPending(LPC_TIM0,0); //turn on led LPC_GPIO2->FIOSET = LED0_PIN; UART_Send(LPC_UART0, info1, sizeof(info1), BLOCKING); } // Wait for 1000 millisecond while ( !(TIM_GetIntStatus(LPC_TIM0,0))); { TIM_ClearIntPending(LPC_TIM0,0); //turn off led LPC_GPIO2->FIOCLR = LED0_PIN; UART_Send(LPC_UART0, info2, sizeof(info2), BLOCKING); } } TIM_DeInit(LPC_TIM0); return (1); }
void TIMER0_IRQHandler(void){ TIM_ClearIntPending((LPC_TIM_TypeDef *) LPC_TIM0, TIM_MR0_INT); (*tick_handler)(); }
void Timer0_Stop(void) { TIM_ClearIntPending(TIMER0,TIM_MR0_INT); TIM_Cmd(TIMER0,DISABLE); }
void Timer1_Stop(void) { TIM_ClearIntPending(TIMER1,TIM_MR1_INT); TIM_Cmd(TIMER1,DISABLE); }