/** * SnoozeClass Constructor */ SnoozeClass::SnoozeClass( void ) { SIM_SOPT1CFG |= SIM_SOPT1CFG_USSWE_MASK; SIM_SOPT1 &= ~SIM_SOPT1_USBSSTBY_MASK; attachInterruptVector( IRQ_LLWU, wakeupISR ); NVIC_SET_PRIORITY( IRQ_LLWU, 32 ); clock_mode = mcg_mode( ); }
void attachInterrupt(uint8_t pin, void (* function)(void), int mode) { volatile uint32_t* config; uint32_t cfg, mask; if (pin >= CORE_NUM_DIGITAL) {return; } switch (mode) { case CHANGE: mask = 0x0B; break; case RISING: mask = 0x09; break; case FALLING: mask = 0x0A; break; case LOW: mask = 0x08; break; case HIGH: mask = 0x0C; break; default: return; } mask = (mask << 16) | 0x01000000; config = portConfigRegister(pin); #if defined(KINETISK) attachInterruptVector(IRQ_PORTA, porta_interrupt); attachInterruptVector(IRQ_PORTB, portb_interrupt); attachInterruptVector(IRQ_PORTC, portc_interrupt); attachInterruptVector(IRQ_PORTD, portd_interrupt); attachInterruptVector(IRQ_PORTE, porte_interrupt); #elif defined(KINETISL) attachInterruptVector(IRQ_PORTA, porta_interrupt); attachInterruptVector(IRQ_PORTCD, portcd_interrupt); #endif __disable_irq(); cfg = *config; cfg &= ~0x000F0000; // disable any previous interrupt *config = cfg; intFunc[pin] = function; // set the function pointer cfg |= mask; *config = cfg; // enable the new interrupt __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 } }
/******************************************************************************* * 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; }
/******************************************************************************* * Enable Driver *******************************************************************************/ void SnoozeCompare::enableDriver( 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; } return_priority = NVIC_GET_PRIORITY( IRQ_CMP );//get current priority int priority = nvic_execution_priority( );// get current priority // if running from handler mode set priority higher than current handler priority = ( priority < 256 ) && ( ( priority - 16 ) > 0 ) ? priority - 16 : 128; NVIC_SET_PRIORITY( IRQ_CMP, priority );//set priority to new level __disable_irq( ); return_cmp_irq = _VectorsRam[IRQ_CMP+16];// save prev isr attachInterruptVector( IRQ_CMP, wakeupIsr ); __enable_irq( ); } if ( SIM_SCGC4 & SIM_SCGC4_CMP ) SIM_SCGC4_clock_active = true; else SIM_SCGC4 |= SIM_SCGC4_CMP; CR0 = *cmpx_cr0; CR1 = *cmpx_cr1; SCR = *cmpx_scr; FPR = *cmpx_fpr; MUXCR = *cmpx_muxcr; DACCR = *cmpx_daccr; uint8_t _pin = 0; *cmpx_cr0 = 0; *cmpx_cr1 = 0; *cmpx_scr = 0; #if defined(__MKL26Z64__) || defined(__MK66FX1M0__) if ( SIM_SCGC5 & SIM_SCGC5_LPTIMER ) SIM_SCGC5_clock_active = true; else SIM_SCGC5 |= SIM_SCGC5_LPTIMER; PSR = LPTMR0_PSR; CMR = LPTMR0_CMR; CSR = LPTMR0_CSR; #endif if ( pin == 11 ) { if ( mode >= LLS ) llwu_configure_modules_mask( LLWU_CMP0_MOD ); return_core_pin_config[0] = CORE_PIN11_CONFIG; CORE_PIN11_CONFIG = PORT_PCR_MUX( 0 ); _pin = 0x00; } else if ( pin == 4 ) { #if defined(KINETISK) if ( mode >= LLS ) llwu_configure_modules_mask( LLWU_CMP2_MOD ); return_core_pin_config[1] = CORE_PIN4_CONFIG; CORE_PIN4_CONFIG = PORT_PCR_MUX( 0 ); _pin = 0x01; #else return; #endif } else if ( pin == 9 ) { #if defined(KINETISK) if ( mode >= LLS ) llwu_configure_modules_mask( LLWU_CMP1_MOD ); return_core_pin_config[2] = CORE_PIN9_CONFIG; CORE_PIN9_CONFIG = PORT_PCR_MUX( 0 ); _pin = 0x01; #else return; #endif } // save if isr is already enabled and enable isr if not 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; } return_isr_enabled = NVIC_IS_ENABLED( IRQ_CMP ); if ( return_isr_enabled == 0 ) NVIC_ENABLE_IRQ( IRQ_CMP ); } // setup compare *cmpx_cr0 = CMP_CR0_FILTER_CNT( 0x07 ); if ( type == CHANGE ) *cmpx_scr = CMP_SCR_CFF | CMP_SCR_CFR | CMP_SCR_IEF | CMP_SCR_IER; else if ( type == RISING || type == HIGH ) *cmpx_scr = CMP_SCR_CFF | CMP_SCR_CFR | CMP_SCR_IER; else if ( type == FALLING || type == LOW ) *cmpx_scr = CMP_SCR_CFF | CMP_SCR_CFR | CMP_SCR_IEF; else return; uint8_t tap = ( threshold_crossing/0.0515625 ) - 1; *cmpx_fpr = 0x00; *cmpx_muxcr = CMP_MUXCR_MSEL( 0x07 ) | CMP_MUXCR_PSEL( _pin ); *cmpx_daccr = CMP_DACCR_DACEN | CMP_DACCR_VRSEL | CMP_DACCR_VOSEL( tap ); #if defined(__MKL26Z64__) || defined(__MK66FX1M0__) // compare needs lptmr to operate in low power with LC, 3.6 *cmpx_cr1 = CMP_CR1_EN | CMP_CR1_TRIGM; SIM_SCGC5 |= SIM_SCGC5_LPTIMER; LPTMR0_CSR = 0; LPTMR0_PSR = LPTMR_PSR_PBYP | LPTMR_PSR_PCS( LPTMR_LPO );//LPO Clock LPTMR0_CMR = 1; LPTMR0_CSR = LPTMR_CSR_TEN | LPTMR_CSR_TCF; #else *cmpx_cr1 = CMP_CR1_EN; #endif }