/* Disable interrupts * */ void ADC_Module::disableInterrupts() { var_enableInterrupts = 0; *ADC_SC1A_aien = 0; #if defined(__MK20DX128__) NVIC_DISABLE_IRQ(IRQ_ADC0); #elif defined(__MK20DX256__) if(ADC_num==1) { // enable correct interrupt NVIC_DISABLE_IRQ(IRQ_ADC1); } else { NVIC_DISABLE_IRQ(IRQ_ADC0); } #endif // defined }
/* Disable interrupts * */ void ADC_Module::disableInterrupts() { var_enableInterrupts = 0; // *ADC_SC1A_aien = 0; clearBit(ADC_SC1A, ADC_SC1A_AIEN_BIT); NVIC_DISABLE_IRQ(IRQ_ADC); }
void Servo::detach() { if (servoIndex >= MAX_SERVOS) return; servo_active_mask &= ~(1<<servoIndex); servo_allocated_mask &= ~(1<<servoIndex); if (servo_active_mask == 0) { NVIC_DISABLE_IRQ(IRQ_PDB); } }
void AudioPlaySdAac::stop(void) { NVIC_DISABLE_IRQ(IRQ_AUDIOCODEC); playing = codec_stopped; if (buf[1]) {free(buf[1]);buf[1] = NULL;} if (buf[0]) {free(buf[0]);buf[0] = NULL;} freeBuffer(); if (hAACDecoder) {AACFreeDecoder(hAACDecoder);hAACDecoder=NULL;}; fclose(); }
// ------------------------------------------------------------ // stops an active PIT by disabling its interrupt, writing to // its control register, and freeing up its state for future use. // also, if no PITs remain in use, disables the core PIT clock // ------------------------------------------------------------ void IntervalTimer::stop_PIT() { // disable interrupt and PIT *PIT_TCTRL = 0; #if defined(KINETISK) NVIC_DISABLE_IRQ(IRQ_PIT_CH); #elif defined(KINETISL) NVIC_DISABLE_IRQ(IRQ_PIT); #endif // free PIT for future use PIT_used[PIT_id] = false; // check if we're still using any PIT for (uint8_t id = 0; id < NUM_PIT; id++) { if (PIT_used[id]) return; } // none used, disable PIT clock disable_PIT(); }
void TwoWire::end() { if (!(hardware.clock_gate_register & hardware.clock_gate_mask)) return; NVIC_DISABLE_IRQ(hardware.irq); // TODO: should this try to create a stop condition?? port().C1 = 0; volatile uint32_t *reg; reg = portConfigRegister(hardware.scl_pin[scl_pin_index]); *reg = 0; reg = portConfigRegister(hardware.sda_pin[sda_pin_index]); *reg = 0; hardware.clock_gate_register &= ~hardware.clock_gate_mask; }
void TwoWire::end() { if (!(SIM_SCGC4 & SIM_SCGC4_I2C0)) return; NVIC_DISABLE_IRQ(IRQ_I2C0); I2C0_C1 = 0; if (sda_pin_num == 18) { CORE_PIN18_CONFIG = 0; } else if (sda_pin_num == 17) { CORE_PIN17_CONFIG = 0; } if (scl_pin_num == 19) { CORE_PIN19_CONFIG = 0; } else if (scl_pin_num == 16) { CORE_PIN16_CONFIG = 0; } SIM_SCGC4 &= ~SIM_SCGC4_I2C0; // TODO: use bitband }
/** * wakeupISR - handle LLWU interrupts after wakeup. */ void SnoozeClass::wakeupISR( void ) { NVIC_DISABLE_IRQ( IRQ_LLWU ); // disable wakeup isr if ( sleep_mode == LLS ) { __disable_irq( ); llwuFlag = llwu_clear_flags( );// clear flags lptmrISR( ); cmp0ISR( ); #ifdef KINETISK rtcISR( ); #endif tsiISR( ); /************************************ * back to PEE if in PBE, else it is * in either BLPI/BLPE, if so nothing * to do. ************************************/ pbe_pee( ); __enable_irq( ); } }
/******************************************************************************* * Enable digital interrupt and configure the pin *******************************************************************************/ void SnoozeDigital::enableDriver( void ) { if ( mode == RUN_LP ) { return; } #if defined(KINETISK) uint64_t _pin = pin; isr_pin = pin; if ( mode == VLPW || mode == VLPS ) { return_isr_a_enabled = NVIC_IS_ENABLED( IRQ_PORTA ); return_isr_b_enabled = NVIC_IS_ENABLED( IRQ_PORTB ); return_isr_c_enabled = NVIC_IS_ENABLED( IRQ_PORTC ); return_isr_d_enabled = NVIC_IS_ENABLED( IRQ_PORTD ); return_isr_e_enabled = NVIC_IS_ENABLED( IRQ_PORTE ); NVIC_DISABLE_IRQ(IRQ_PORTA); NVIC_DISABLE_IRQ(IRQ_PORTB); NVIC_DISABLE_IRQ(IRQ_PORTC); NVIC_DISABLE_IRQ(IRQ_PORTD); NVIC_DISABLE_IRQ(IRQ_PORTE); NVIC_CLEAR_PENDING(IRQ_PORTA); NVIC_CLEAR_PENDING(IRQ_PORTB); NVIC_CLEAR_PENDING(IRQ_PORTC); NVIC_CLEAR_PENDING(IRQ_PORTD); NVIC_CLEAR_PENDING(IRQ_PORTE); int priority = nvic_execution_priority( );// get current priority // if running from interrupt set priority higher than current interrupt priority = ( priority < 256 ) && ( ( priority - 16 ) > 0 ) ? priority - 16 : 128; return_priority_a = NVIC_GET_PRIORITY( IRQ_PORTA );//get current priority return_priority_b = NVIC_GET_PRIORITY( IRQ_PORTB );//get current priority return_priority_c = NVIC_GET_PRIORITY( IRQ_PORTC );//get current priority return_priority_d = NVIC_GET_PRIORITY( IRQ_PORTD );//get current priority return_priority_e = NVIC_GET_PRIORITY( IRQ_PORTE );//get current priority NVIC_SET_PRIORITY( IRQ_PORTA, priority );//set priority to new level NVIC_SET_PRIORITY( IRQ_PORTB, priority );//set priority to new level NVIC_SET_PRIORITY( IRQ_PORTC, priority );//set priority to new level NVIC_SET_PRIORITY( IRQ_PORTD, priority );//set priority to new level NVIC_SET_PRIORITY( IRQ_PORTE, priority );//set priority to new level __disable_irq( ); return_porta_irq = _VectorsRam[IRQ_PORTA+16];// save prev isr handler return_portb_irq = _VectorsRam[IRQ_PORTB+16];// save prev isr handler return_portc_irq = _VectorsRam[IRQ_PORTC+16];// save prev isr handler return_portd_irq = _VectorsRam[IRQ_PORTD+16];// save prev isr handler return_porte_irq = _VectorsRam[IRQ_PORTE+16];// save prev isr handler attachInterruptVector( IRQ_PORTA, isr );// set snooze digA isr attachInterruptVector( IRQ_PORTB, isr );// set snooze digB isr attachInterruptVector( IRQ_PORTC, isr );// set snooze digC isr attachInterruptVector( IRQ_PORTD, isr );// set snooze digD isr attachInterruptVector( IRQ_PORTE, isr );// set snooze digE isr __enable_irq( ); NVIC_ENABLE_IRQ( IRQ_PORTA ); NVIC_ENABLE_IRQ( IRQ_PORTB ); NVIC_ENABLE_IRQ( IRQ_PORTC ); NVIC_ENABLE_IRQ( IRQ_PORTD ); NVIC_ENABLE_IRQ( IRQ_PORTE ); } _pin = pin; while ( __builtin_popcountll( _pin ) ) { uint32_t pinNumber = 63 - __builtin_clzll( _pin );// get pin if ( pinNumber > 33 ) break; uint32_t pin_mode = irqType[pinNumber] >> 4;// get type uint32_t pin_type = irqType[pinNumber] & 0x0F;// get mode volatile uint32_t *config; config = portConfigRegister( pinNumber ); return_core_pin_config[pinNumber] = *config; if ( pin_mode == INPUT || pin_mode == INPUT_PULLUP ) {// setup pin mode/type/interrupt *portModeRegister( pinNumber ) = 0; if ( pin_mode == INPUT ) *config = PORT_PCR_MUX( 1 ); else *config = PORT_PCR_MUX( 1 ) | PORT_PCR_PE | PORT_PCR_PS;// pullup if ( mode == VLPW || mode == VLPS ) { attachDigitalInterrupt( pinNumber, pin_type );// set pin interrupt } else { llwu_configure_pin_mask( pinNumber, mode ); } } else { //pinMode( pinNumber, pin_mode ); //digitalWriteFast( pinNumber, pin_type ); } _pin &= ~( ( uint64_t )1 << pinNumber );// remove pin from list } #elif defined(KINETISL) uint32_t _pin = pin; isr_pin = pin; if ( mode == VLPW || mode == VLPS ) {// if using sleep must setup pin interrupt to wake return_isr_a_enabled = NVIC_IS_ENABLED( IRQ_PORTA ); return_isr_cd_enabled = NVIC_IS_ENABLED( IRQ_PORTCD ); NVIC_DISABLE_IRQ(IRQ_PORTA); NVIC_DISABLE_IRQ(IRQ_PORTCD); NVIC_CLEAR_PENDING(IRQ_PORTA); NVIC_CLEAR_PENDING(IRQ_PORTCD); int priority = nvic_execution_priority( );// get current priority // if running from interrupt set priority higher than current interrupt priority = ( priority < 256 ) && ( ( priority - 16 ) > 0 ) ? priority - 16 : 128; return_priority_a = NVIC_GET_PRIORITY( IRQ_PORTA );//get current priority return_priority_cd = NVIC_GET_PRIORITY( IRQ_PORTCD );//get current priority NVIC_SET_PRIORITY( IRQ_PORTA, priority );//set priority to new level NVIC_SET_PRIORITY( IRQ_PORTCD, priority );//set priority to new level __disable_irq( ); return_porta_irq = _VectorsRam[IRQ_PORTA+16];// save prev isr handler return_portcd_irq = _VectorsRam[IRQ_PORTCD+16];// save prev isr handler attachInterruptVector( IRQ_PORTA, isr );// set snooze isr attachInterruptVector( IRQ_PORTCD, isr );// set snooze isr __enable_irq( ); NVIC_ENABLE_IRQ( IRQ_PORTA ); NVIC_ENABLE_IRQ( IRQ_PORTCD ); } _pin = pin; while ( __builtin_popcount( _pin ) ) { uint32_t pinNumber = 31 - __builtin_clz( _pin );// get pin if ( pinNumber > 33 ) break; uint32_t pin_mode = irqType[pinNumber] >> 4;// get type uint32_t pin_type = irqType[pinNumber] & 0x0F;// get mode volatile uint32_t *config; config = portConfigRegister( pinNumber ); return_core_pin_config[pinNumber] = *config; if ( pin_mode == INPUT || pin_mode == INPUT_PULLUP ) {// setup pin mode/type/interrupt *portModeRegister( pinNumber ) &= ~digitalPinToBitMask( pinNumber ); // TODO: atomic if ( pin_mode == INPUT ) *config = PORT_PCR_MUX( 1 ); else *config = PORT_PCR_MUX( 1 ) | PORT_PCR_PE | PORT_PCR_PS;// pullup if ( pin_mode == VLPW || pin_mode == VLPS ) { attachDigitalInterrupt( pinNumber, pin_type );// set pin interrupt } else { llwu_configure_pin_mask( pinNumber, pin_mode ); } } else { //pinMode( pinNumber, pin_mode ); //digitalWriteFast( pinNumber, pin_type ); } _pin &= ~( ( uint32_t )1 << pinNumber );// remove pin from list } #endif }
/******************************************************************************* * Disable interrupt and configure pin to orignal state. *******************************************************************************/ void SnoozeDigital::disableDriver( void ) { if ( mode == RUN_LP ) { return; } #if defined(KINETISK) uint64_t _pin = pin; while ( __builtin_popcountll( _pin ) ) { uint32_t pinNumber = 63 - __builtin_clzll( _pin ); if ( pinNumber > 33 ) break; *portModeRegister( pinNumber ) = 0; volatile uint32_t *config; config = portConfigRegister( pinNumber ); *config = return_core_pin_config[pinNumber]; _pin &= ~( ( uint64_t )1 << pinNumber );// remove pin from list } #elif defined(KINETISL) uint32_t _pin = pin; while ( __builtin_popcount( _pin ) ) { uint32_t pinNumber = 31 - __builtin_clz( _pin ); if ( pinNumber > 33 ) break; *portModeRegister( pinNumber ) &= ~digitalPinToBitMask( pinNumber ); volatile uint32_t *config; config = portConfigRegister( pinNumber ); *config = return_core_pin_config[pinNumber]; _pin &= ~( ( uint32_t )1 << pinNumber );// remove pin from list } #endif if ( mode == VLPW || mode == VLPS ) { #if defined(KINETISK) NVIC_SET_PRIORITY( IRQ_PORTA, return_priority_a );//set priority to new level NVIC_SET_PRIORITY( IRQ_PORTB, return_priority_b );//set priority to new level NVIC_SET_PRIORITY( IRQ_PORTC, return_priority_c );//set priority to new level NVIC_SET_PRIORITY( IRQ_PORTD, return_priority_d );//set priority to new level NVIC_SET_PRIORITY( IRQ_PORTE, return_priority_e );//set priority to new level __disable_irq( ); attachInterruptVector( IRQ_PORTA, return_porta_irq );// set snooze isr attachInterruptVector( IRQ_PORTB, return_portb_irq );// set snooze isr attachInterruptVector( IRQ_PORTC, return_portc_irq );// set snooze isr attachInterruptVector( IRQ_PORTD, return_portd_irq );// set snooze isr attachInterruptVector( IRQ_PORTE, return_porte_irq );// set snooze isr __enable_irq( ); if ( return_isr_a_enabled == 0 ) NVIC_DISABLE_IRQ( IRQ_PORTA ); if ( return_isr_b_enabled == 0 ) NVIC_DISABLE_IRQ( IRQ_PORTB ); if ( return_isr_c_enabled == 0 ) NVIC_DISABLE_IRQ( IRQ_PORTC ); if ( return_isr_d_enabled == 0 ) NVIC_DISABLE_IRQ( IRQ_PORTD ); if ( return_isr_e_enabled == 0 ) NVIC_DISABLE_IRQ( IRQ_PORTE ); #elif defined(KINETISL) NVIC_SET_PRIORITY( IRQ_PORTA, return_priority_a );//set priority to new level NVIC_SET_PRIORITY( IRQ_PORTCD, return_priority_cd );//set priority to new level __disable_irq( ); attachInterruptVector( IRQ_PORTA, return_porta_irq );// set snooze isr attachInterruptVector( IRQ_PORTCD, return_portcd_irq );// set snooze isr __enable_irq( ); if ( return_isr_a_enabled == 0 ) NVIC_DISABLE_IRQ( IRQ_PORTA ); if ( return_isr_cd_enabled == 0 ) NVIC_DISABLE_IRQ( IRQ_PORTCD ); #endif } }
// ------------------------------------------------------------ // stops the timer and disables its interrupts // ------------------------------------------------------------ void PITimer::stop() { isRunning = false; NVIC_DISABLE_IRQ(IRQ_PIT_CH); *PIT_TCTRL = 0; }
/******************************************************************************* * Disable Driver *******************************************************************************/ void SnoozeCompare::disableDriver( void ) { if ( mode == RUN_LP ) { return; } if ( mode == VLPW || mode == VLPS ) { IRQ_NUMBER_t IRQ_CMP; switch (pin) { case 11: IRQ_CMP = IRQ_CMP0; break; #if defined(KINETISK) case 9: IRQ_CMP = IRQ_CMP1; break; case 4: IRQ_CMP = IRQ_CMP2; break; #endif default: IRQ_CMP = IRQ_CMP; return; } if ( return_isr_enabled == 0 ) NVIC_DISABLE_IRQ( IRQ_CMP ); NVIC_SET_PRIORITY( IRQ_CMP, return_priority ); __disable_irq( ); attachInterruptVector( IRQ_CMP, return_cmp_irq );// return prev interrupt __enable_irq( ); } if ( pin == 11 ) { CORE_PIN11_CONFIG = return_core_pin_config[0]; } else if ( pin == 4 ) { #if defined(KINETISK) CORE_PIN4_CONFIG = return_core_pin_config[1]; #else return; #endif } else if ( pin == 9 ) { #if defined(KINETISK) CORE_PIN9_CONFIG = return_core_pin_config[2]; #else return; #endif } #if defined(__MKL26Z64__) || defined(__MK66FX1M0__) LPTMR0_PSR = PSR; LPTMR0_CMR = CMR; LPTMR0_CSR = CSR; if ( !SIM_SCGC5_clock_active ) SIM_SCGC5 &= ~SIM_SCGC5_LPTIMER; #endif *cmpx_cr0 = CR0; *cmpx_cr1 = CR1; *cmpx_scr = SCR; *cmpx_fpr = FPR; *cmpx_muxcr = MUXCR; *cmpx_daccr = DACCR; if ( !SIM_SCGC4_clock_active ) SIM_SCGC4 &= ~SIM_SCGC4_CMP; }
/* Disable interrupts * */ void ADC::disableInterrupts() { var_enableInterrupts = 0; NVIC_DISABLE_IRQ(IRQ_ADC0); }