void dbgInit(void)
{
power_usart0_enable(); // power to the USART
// USART Baud rate:
UBRR0H = UBRRH_VALUE;
UBRR0L = UBRRL_VALUE;
UCSR0B = _BV(TXEN0) /* | _BV(RXEN0) */ ;
stdout = &mystdout;
}
// enable usart while awake
void usart_wake(void) {
power_usart0_enable(); // enable usart
// set desired baudrate in terms of system clock
UBRR0 = F_CPU / (USART_BAUDRATE * 16UL) - 1;
// standard serial port settings: 8 bits, no parity, 1 stop
UCSR0C = _BV(UCSZ01) | _BV(UCSZ00);
// enable transmitter and receiver
UCSR0B = _BV(RXEN0) | _BV(TXEN0);
}
/*********************************************************************************************************
** Function name: wakeUp
** Descriptions: wakeUp
*********************************************************************************************************/
void xadow::wakeUp()
{
#if defined(__AVR_ATmega32U4__)
power_adc_enable();
power_usart0_enable();
power_spi_enable();
power_twi_enable();
power_timer1_enable();
power_timer2_enable();
power_timer3_enable();
power_usart1_enable();
power_usb_enable();
#endif
}
void Low_Power::idle(Period_t period, ADC_t adc, Timer5_t timer5,
Timer4_t timer4, Timer3_t timer3, Timer2_t timer2,
Timer1_t timer1, Timer0_t timer0, SPI_t spi,
USART3_t usart3, USART2_t usart2, USART1_t usart1,
USART0_t usart0, TWI_t twi)
{
// Temporary clock source variable
unsigned char clockSource = 0;
if (timer2 == TIMER2_OFF)
{
if (TCCR2B & CS22) clockSource |= (1 << CS22);
if (TCCR2B & CS21) clockSource |= (1 << CS21);
if (TCCR2B & CS20) clockSource |= (1 << CS20);
// Remove the clock source to shutdown Timer2
TCCR2B &= ~(1 << CS22);
TCCR2B &= ~(1 << CS21);
TCCR2B &= ~(1 << CS20);
power_timer2_disable();
}
if (adc == ADC_OFF)
{
ADCSRA &= ~(1 << ADEN);
power_adc_disable();
}
if (timer5 == TIMER5_OFF) power_timer5_disable();
if (timer4 == TIMER4_OFF) power_timer4_disable();
if (timer3 == TIMER3_OFF) power_timer3_disable();
if (timer1 == TIMER1_OFF) power_timer1_disable();
if (timer0 == TIMER0_OFF) power_timer0_disable();
if (spi == SPI_OFF) power_spi_disable();
if (usart3 == USART3_OFF) power_usart3_disable();
if (usart2 == USART2_OFF) power_usart2_disable();
if (usart1 == USART1_OFF) power_usart1_disable();
if (usart0 == USART0_OFF) power_usart0_disable();
if (twi == TWI_OFF) power_twi_disable();
if (period != SLEEP_FOREVER)
{
wdt_enable(period);
WDTCSR |= (1 << WDIE);
}
lowPowerBodOn(SLEEP_MODE_IDLE);
if (adc == ADC_OFF)
{
power_adc_enable();
ADCSRA |= (1 << ADEN);
}
if (timer2 == TIMER2_OFF)
{
if (clockSource & CS22) TCCR2B |= (1 << CS22);
if (clockSource & CS21) TCCR2B |= (1 << CS21);
if (clockSource & CS20) TCCR2B |= (1 << CS20);
power_timer2_enable();
}
if (timer5 == TIMER5_OFF) power_timer5_enable();
if (timer4 == TIMER4_OFF) power_timer4_enable();
if (timer3 == TIMER3_OFF) power_timer3_enable();
if (timer1 == TIMER1_OFF) power_timer1_enable();
if (timer0 == TIMER0_OFF) power_timer0_enable();
if (spi == SPI_OFF) power_spi_enable();
if (usart3 == USART3_OFF) power_usart3_enable();
if (usart2 == USART2_OFF) power_usart2_enable();
if (usart1 == USART1_OFF) power_usart1_enable();
if (usart0 == USART0_OFF) power_usart0_enable();
if (twi == TWI_OFF) power_twi_enable();
}
/*******************************************************************************
* Name: idle
* Description: Putting microcontroller into idle state. Please make sure you
* understand the implication and result of disabling module.
*
* Argument Description
* ========= ===========
* 1. period Duration of low power mode. Use SLEEP_FOREVER to use other wake
* up resource:
* (a) SLEEP_15MS - 15 ms sleep
* (b) SLEEP_30MS - 30 ms sleep
* (c) SLEEP_60MS - 60 ms sleep
* (d) SLEEP_120MS - 120 ms sleep
* (e) SLEEP_250MS - 250 ms sleep
* (f) SLEEP_500MS - 500 ms sleep
* (g) SLEEP_1S - 1 s sleep
* (h) SLEEP_2S - 2 s sleep
* (i) SLEEP_4S - 4 s sleep
* (j) SLEEP_8S - 8 s sleep
* (k) SLEEP_FOREVER - Sleep without waking up through WDT
*
* 2. adc ADC module disable control:
* (a) ADC_OFF - Turn off ADC module
* (b) ADC_ON - Leave ADC module in its default state
*
* 3. timer2 Timer 2 module disable control:
* (a) TIMER2_OFF - Turn off Timer 2 module
* (b) TIMER2_ON - Leave Timer 2 module in its default state
*
* 4. timer1 Timer 1 module disable control:
* (a) TIMER1_OFF - Turn off Timer 1 module
* (b) TIMER1_ON - Leave Timer 1 module in its default state
*
* 5. timer0 Timer 0 module disable control:
* (a) TIMER0_OFF - Turn off Timer 0 module
* (b) TIMER0_ON - Leave Timer 0 module in its default state
*
* 6. spi SPI module disable control:
* (a) ADC_OFF - Turn off ADC module
* (b) ADC_ON - Leave ADC module in its default state
*
* 7. usart0 USART0 module disable control:
* (a) USART0_OFF - Turn off USART0 module
* (b) USART0_ON - Leave USART0 module in its default state
*
* 8. twi TWI module disable control:
* (a) TWI_OFF - Turn off TWI module
* (b) TWI_ON - Leave TWI module in its default state
*
*******************************************************************************/
void LowPowerClass::idle(period_t period, adc_t adc, timer2_t timer2,
timer1_t timer1, timer0_t timer0,
spi_t spi, usart0_t usart0, twi_t twi)
{
// Temporary clock source variable
unsigned char clockSource = 0;
if (timer2 == TIMER2_OFF)
{
if (TCCR2B & CS22) clockSource |= (1 << CS22);
if (TCCR2B & CS21) clockSource |= (1 << CS21);
if (TCCR2B & CS20) clockSource |= (1 << CS20);
// Remove the clock source to shutdown Timer2
TCCR2B &= ~(1 << CS22);
TCCR2B &= ~(1 << CS21);
TCCR2B &= ~(1 << CS20);
power_timer2_disable();
}
if (adc == ADC_OFF)
{
ADCSRA &= ~(1 << ADEN);
power_adc_disable();
}
if (timer1 == TIMER1_OFF) power_timer1_disable();
if (timer0 == TIMER0_OFF) power_timer0_disable();
if (spi == SPI_OFF) power_spi_disable();
if (usart0 == USART0_OFF) power_usart0_disable();
if (twi == TWI_OFF) power_twi_disable();
if (period != SLEEP_FOREVER)
{
wdt_enable(period);
WDTCSR |= (1 << WDIE);
}
lowPowerBodOn(SLEEP_MODE_IDLE);
if (adc == ADC_OFF)
{
power_adc_enable();
ADCSRA |= (1 << ADEN);
}
if (timer2 == TIMER2_OFF)
{
if (clockSource & CS22) TCCR2B |= (1 << CS22);
if (clockSource & CS21) TCCR2B |= (1 << CS21);
if (clockSource & CS20) TCCR2B |= (1 << CS20);
power_timer2_enable();
}
if (timer1 == TIMER1_OFF) power_timer1_enable();
if (timer0 == TIMER0_OFF) power_timer0_enable();
if (spi == SPI_OFF) power_spi_enable();
if (usart0 == USART0_OFF) power_usart0_enable();
if (twi == TWI_OFF) power_twi_enable();
}
// Shutdown
void bg_pwr_down()
{
// execute sleep routine
if (bg_pwr_exec_sleep_routine_flag)
{
if (bg_pwr_on_sleep != NULL)
bg_pwr_on_sleep();
// the flag is needed because we want to execute sleep
// routine only when we go from pwr up to pwr down
bg_pwr_exec_sleep_routine_flag = 0;
}
//Shut off ADC, TWI, SPI, Timer0, Timer1, Timer2
ADCSRA &= ~(1<<ADEN); //Disable ADC
ACSR |= (1<<ACD); //Disable the analog comparator
DIDR0 = 0xFF; //Disable digital input buffers on all ADC0-ADC5 pins
DIDR1 = (1<<AIN1D)|(1<<AIN0D); //Disable digital input buffer on AIN1/0
power_twi_disable();
power_spi_disable();
power_usart0_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
#if defined(__AVR_ATmega1284P__)
power_timer3_disable();
#endif
//Power down various bits of hardware to lower power usage
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
/*********/
/* SLEEP */
/*********/
// The processor wakes up back here after interrupt
//Turn on ADC, TWI, SPI, Timer0, Timer1, Timer2
ADCSRA |= (1<<ADEN); // Enable ADC
ACSR &= ~(1<<ACD); // Enable the analog comparator
// this should be set to reflect real usage of analog pins
DIDR0 = 0x00; // Enable digital input buffers on all ADC0-ADC5 pins
DIDR1 &= ~(1<<AIN1D)|(1<<AIN0D); // Enable digital input buffer on AIN1/0
power_twi_enable();
power_spi_enable();
power_usart0_enable();
power_timer0_enable();
power_timer1_enable();
power_timer2_enable();
#if defined(__AVR_ATmega1284P__)
power_timer3_enable();
#endif
// check button press time and handle state
unsigned long start = millis();
while ( (ellapsed_millis(start) < BG_PWR_BUTTON_TIME) && (digitalRead(bg_pwr_switch_pin) == HIGH) );
// if the button is pressed continuously for 2 seconds, swap to on state
if (ellapsed_millis(start) >= BG_PWR_BUTTON_TIME)
bg_pwr_state = BG_STATE_PWR_UP;
// lower the button flag
bg_pwr_button_pressed_flag = 0;
// execute wake up routine only if we really woke up
if (bg_pwr_state == BG_STATE_PWR_UP || sd_reader_interrupted)
{
// execute wake up routine if any is defined
if (bg_pwr_on_wakeup != NULL)
bg_pwr_on_wakeup();
// next time we sleep execute sleep routine
bg_pwr_exec_sleep_routine_flag = 1;
}
}
/*this mode turns off everything not needed during the time in which only the main counter is running
The only things needed during simple sleep are the operation of basic pins and the timer1 interrupt
*/
void Radian_power_saver::EnterSimpleSleep(unsigned int IdlePWM ){
/*
//Disable ADC and internal Vref
POWER_OFF;
ADMUX &= ~( (1<<REFS1) | (1<<REFS0));
ADCSRA &= ~( (1<<ADEN) );
//Disable AnalogComparator
ACSR |= (1<<ACD);
SMCR = 1; //go into idle mode
sleep_mode();
POWER_ON;
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_enable();
interrupts();
// attachInterrupt(0,sleepHandler, FALLING);
sleep_mode(); //sleep now
//--------------- ZZZZZZ sleeping here
sleep_disable(); //fully awake now
POWER_ON; //turn the power back on
*/
if(DEBUG) Serial.println("Entering simple Sleep Mode");
if(IdlePWM == 0) SetIdlePins(PAN);
else SetIdlePins(TILT);
// power_all_disable(); //turn off all modules
//turn necessary idle ports back on
power_usart0_enable();
power_timer1_enable();
// power_timer4_enable(); //leave PWM module on, should make something smarter for future
set_sleep_mode(SLEEP_MODE_IDLE);
sleep_enable();
// interrupts();
// attachInterrupt(0,sleepHandler, FALLING);
sleep_mode(); //sleep now
//--------------- ZZZZZZ sleeping here
sleep_disable(); //fully awake now
// Serial.println("Woke up");
POWER_ON;
power_all_enable();
if(IdlePWM == 0) WakeUpPins(PAN);
else WakeUpPins(TILT);
/*power_adc_enable();
power_timer0_enable();
power_usart1_enable();
power_useart0_enable();
*/
}