// IMPORTANT: if interrupts are not enabled, the processor will never wake
// from sleep
void sleep_proc() {
enable_pcint();
// Turn off timer0
disable_pwm();
disp_off();
// probably want power save mode
// everything off but Timer2 interrupts
set_sleep_mode(SLEEP_MODE_PWR_SAVE);
sleep_mode();
// Continue here on wake
disable_pcint();
return;
}
/// @details
/// Wait for completion of the preceding rf12_sendStart() call, using the
/// specified low-power mode.
/// @note rf12_sendWait() should only be called right after rf12_sendStart().
/// @param mode Power-down mode during wait: 0 = NORMAL, 1 = IDLE, 2 = STANDBY,
/// 3 = PWR_DOWN. Values 2 and 3 can cause the millisecond time to
/// lose a few interrupts. Value 3 can only be used if the ATmega
/// fuses have been set for fast startup, i.e. 258 CK - the default
/// Arduino fuse settings are not suitable for full power down.
void rf12_sendWait (uint8_t mode) {
// wait for packet to actually finish sending
// go into low power mode, as interrupts are going to come in very soon
while (rxstate != TXIDLE)
if (mode) {
// power down mode is only possible if the fuses are set to start
// up in 258 clock cycles, i.e. approx 4 us - else must use standby!
// modes 2 and higher may lose a few clock timer ticks
set_sleep_mode(mode == 3 ? SLEEP_MODE_PWR_DOWN :
#ifdef SLEEP_MODE_STANDBY
mode == 2 ? SLEEP_MODE_STANDBY :
#endif
SLEEP_MODE_IDLE);
sleep_mode();
}
}
void go_sleep()
{
cbi(ADCSRA,ADEN); // switch Analog to Digitalconverter OFF
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
cli();
sleep_enable();
sleep_bod_disable();
sei();
sleep_cpu();
//sleep_mode();
/* wake up here */
sleep_disable();
sbi(ADCSRA,ADEN); // switch Analog to Digitalconverter ON
initvars();
setup();
}
obj fn_wait_for_event (obj args)
{
(void) args;
sleep_enable ();
set_sleep_mode (SLEEP_MODE_IDLE);
for (;;)
{
noInterrupts ();
if (isReady ())
break;
interrupts ();
sleep_cpu ();
}
interrupts ();
return (obj_NIL);
}
int main(void)
{
cli();
ir.enableIRIn();
TIMER_DISABLE_INTR; //start up the IR thing, then turn off the interrupt
DDRB &= ~((1 << IR_PIN) | (1 << SCL)); //Configure clock and IR pin as input
SETUP_PIN_CHANGE;
ENABLE_PIN_INTR;
sei();
set_sleep_mode(2);
sleep_enable();
while (1)
{
sleep_cpu();
}
}
int main(void) {
WDT_off(); //watchdog erstmal abschalten
wdt_disable();
LED_DDR = (1<<LED_PIN); //register setzen
LED(0); //LED auf LOW ziehen --> AN
delayms(20); //Delayzeit stellt die Impulsdauer und damit den Helligkeitseindruck ein
LED(1); //LED auf HIGH setzen --> AUS
wdt_enable(WDTO_2S); //setze den Watchdogtimer auf 2s
set_sleep_mode(SLEEP_MODE_PWR_DOWN); //PWR_DOWN --> quasi nur wdt kann chip wecken
sleep_mode(); //in den Tiefschlaf wechseln
while(1);
return 0;
}
static int acx565akm_panel_power_on(struct omap_dss_device *dssdev)
{
struct panel_drv_data *ddata = to_panel_data(dssdev);
struct omap_dss_device *in = ddata->in;
int r;
dev_dbg(&ddata->spi->dev, "%s\n", __func__);
in->ops.sdi->set_timings(in, &ddata->vm);
r = in->ops.sdi->enable(in);
if (r) {
pr_err("%s sdi enable failed\n", __func__);
return r;
}
/*FIXME tweak me */
msleep(50);
if (gpio_is_valid(ddata->reset_gpio))
gpio_set_value(ddata->reset_gpio, 1);
if (ddata->enabled) {
dev_dbg(&ddata->spi->dev, "panel already enabled\n");
return 0;
}
/*
* We have to meet all the following delay requirements:
* 1. tRW: reset pulse width 10usec (7.12.1)
* 2. tRT: reset cancel time 5msec (7.12.1)
* 3. Providing PCLK,HS,VS signals for 2 frames = ~50msec worst
* case (7.6.2)
* 4. 120msec before the sleep out command (7.12.1)
*/
msleep(120);
set_sleep_mode(ddata, 0);
ddata->enabled = 1;
/* 5msec between sleep out and the next command. (8.2.16) */
usleep_range(5000, 10000);
set_display_state(ddata, 1);
set_cabc_mode(ddata, ddata->cabc_mode);
return acx565akm_bl_update_status(ddata->bl_dev);
}
void initialise(void)
{
/* Disable interrupts during initialisation
*/
cli();
/* Setup i/o pins
* PORTB - all output except input MISO on PB4
* PORTC - all input except outputs PC0(?), PC4 (?) and PC5 (Led)
* PORTD - all output except inputs PD0 (RX), PD2 (signal) and
* PD3(int1)
*/
DDRB = ~(1 << DDB4);
DDRC = (1 << ACTIVITY_LED) | (1 << DDC4) | (1 << DDC0);
DDRD = ~((1 << DDD3) | (1 << DDD2) | (1 << DDD0));
/* Enable external interrupt on INT0 (PD2) - falling edge trigger
*/
EICRA = (1 << ISC01);
EIMSK = (1 << INT0);
/* Setup a 16 bit timer to generate 1s interrupts for display updates
*/
TCCR1B |= (1 << CS12) | (1 << WGM12);
OCR1A = (F_CPU / 256) - 1;
TIMSK1 |= (1 << OCIE1A);
/* Setup UART0
*/
UCSR0B |= (GEIGER_XFER);
UCSR0C |= (GEIGER_XFER_CFG);
UBRR0H = UBRRH_VALUE;
UBRR0L = UBRRL_VALUE;
#if USE_2X
UCSR0A |= (1 << U2X0);
#else
UCSR0A &= ~(1 << U2X0);
#endif
PORTC |= LED_OFF_MASK;
/* Allow the CPU to sleep and be woken on timer and external
* interrupts
*/
set_sleep_mode(SLEEP_MODE_IDLE);
sei();
}
/*-----------------------------------------------------------------------*/
static
uint8_t sleep(void)
{
/* 1/32 Clock */
cli();
CLKPR = _BV(CLKPCE);
CLKPR = 0b0101;
sei();
PRR = _BV(PRTWI) | _BV(PRTIM2) | _BV(PRTIM0) | _BV(PRTIM1) | _BV(PRSPI)
| _BV(PRUSART0) | _BV(PRADC);
/* CA2's dp on */
PORTB |= 0b00101000;
PORTD = 0b00000010;
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
/* PCINT enable */
PCMSK1 = _BV(PCINT9) | _BV(PCINT11) | _BV(PCINT13);
do {
cli();
wdt_reset();
WDTCSR = _BV(WDCE) | _BV(WDE);
WDTCSR = _BV(WDIE) | 0b110; /* 1s */
sei();
sleep_mode();
if ( !(PCMSK1 & _BV(PCINT9)) ) break;
xorshift();
/* blink dot per 0.5ms */
PIND = 0b00000010;
} while (1);
cli();
wdt_reset();
WDTCSR = _BV(WDCE) | _BV(WDE);
WDTCSR = 0;
sei();
/* if s1 pushed exit idle loop, else continue idle */
return (PINC & _BV(5));
}
void su_sleep(int16_t seconds)
{
s_toSleep = seconds;
ADCSRA |= (0<<ADEN); // Switch Analog to Digital converter OFF
while ( true )
{
set_sleep_mode( SLEEP_MODE_PWR_DOWN);
sleep_mode();
s_toSleep -= 10;
if ( s_toSleep < 0 ) break;
}
ADCSRA |= (1<<ADEN); // Switch Analog to Digital converter ON
}
// go to sleep until the MCU is reset
void sleepNow(void)
{
// configure sleep mode and enable it
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_enable();
sleep_bod_disable();
// disable interupts
cli();
// set ports to inputs and disabled pullups
DDRB = 0;
PORTB = 0;
// sleep
sleep_mode();
}
int main()
{
cli();
state = 0;
/*
* Setup LED display.
*
* Fortunately, LED pins are the exactly the DDRB pins (8-13),
* so setting it all of them to input output mode is as simple as
* setting all bits of DDRB to 1.
*/
DDRB = ~((uint8_t)0);
/*
* Setup button controls.
*
* We treat all DDRD pins (except for RX and TX ones) as our input
* controls. Therefore, we just clear the whole mask leaving only
* original RX (pin 0) and TX (pin 1) values.
*/
DDRD = (DDRD & _BV(0)) | (DDRD & _BV(1));
/*
* Setup interrupts.
*
* The clear button is connected to the pin 3 (interrupt 1) and we want
* it to trigger on the falling signal (when use raises his finger).
*
* Signal of the value keys is combined with diodes and connected to the
* pin 2 (interrupt 1). We want interrupt to trigger on the rising signal
* to be able to determine which button is being pressed.
*/
sei();
EICRA = (EICRA & ~(_BV(ISC01) | _BV(ISC00))) | _BV(ISC01) | _BV(ISC00);
EICRA = (EICRA & ~(_BV(ISC11) | _BV(ISC10))) | _BV(ISC11);
EIMSK = _BV(INT0) | _BV(INT1);
set_sleep_mode(SLEEP_MODE_IDLE);
sleep_enable();
for (;;) {
sleep_mode();
}
}
void tileSetup(void){
//Initialization routines
initIO();
setPort(&PORTB);
sendColor(LEDCLK,LEDDAT,dark);
sei();
initAD();
initTimer();
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_enable();
//Set up timing ring buffers
uint8_t i;
for(i = 0; i<6; i++){
timeBuf[i]=0;
}
mode = running;
}
int main(void)
{
set_sleep_mode(SLEEP_MODE_IDLE);
PORTF.DIRSET |= 0x01;
initialize_console();
initialize_games();
start_vga();
while(1)
{
sleep_mode();
if(vsync_backporch) {
vsync_backporch = 0x00;
update_state();
}
}
}
/// @see http://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html
void Sleepy::powerDown() {
byte adcsraSave = ADCSRA;
ADCSRA &= ~bit(ADEN); // disable the ADC
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
ATOMIC_BLOCK(ATOMIC_FORCEON) {
sleep_enable();
// sleep_bod_disable(); // can't use this - not in my avr-libc version!
#ifdef BODSE
MCUCR = MCUCR | bit(BODSE) | bit(BODS); // timed sequence
MCUCR = (MCUCR & ~bit(BODSE)) | bit(BODS);
#endif
}
sleep_cpu();
sleep_disable();
// re-enable what we disabled
ADCSRA = adcsraSave;
}
int main(void)
{
uint8_t i,
led; /* port D LEDs */
DDRD = 0xFF; /* set port D as output */
DDRE &= ~(_BV(PORTE4)); /* set PE4 as input */
PORTE |= _BV(PORTE4); /* enable PE4 pull up resistor */
cli(); /* global interrupt disable */
EIMSK = 0x00; /* disable all external interrupts */
EICRB = 0x00; /* 0 0 The low level of INT4 generates an interrupt request. */
EIFR = 0x00; /* clear all interrupt flags */
EIMSK = _BV(INT4); /* enable external interrupts */
sei(); /* global interrupt enable */
/*
* SLEEP_MODE_IDLE ... Idle
* SLEEP_MODE_ADC ... ADC Noise Reduction
* SLEEP_MODE_PWR_DOWN ... Power-down
* SLEEP_MODE_PWR_SAVE ... Power-save
* SLEEP_MODE_STANDBY ... Standby
* SLEEP_MODE_EXT_STANDBY ... Extended Standby
*/
set_sleep_mode(SLEEP_MODE_IDLE); /* set sleep mode */
while(1)
{
led = 1; /* indicate we are ready */
PORTD = ~led;
sleep_enable(); /* set Sleep Enable bit */
sleep_cpu(); /* sleep - waiting for INT4 */
sleep_disable(); /* clear Sleep Enable bit */
while (led) /* action after wake-up */
{
led <<= 1; /* walking LED */
PORTD = ~led;
for (i = 0; i < 100; i++) /* delay 1s */
_delay_ms(10);
}
}
}
//---------------------------------------------------------------------------
static void IdleMain( void *unused )
{
while(1)
{
#if 1
// LPM code;
set_sleep_mode(SLEEP_MODE_IDLE);
cli();
sleep_enable();
sei();
sleep_cpu();
sleep_disable();
sei();
#endif
}
return 0;
}
void sleepWithWDT(uint8_t wdt_period) {
wdt_enable(wdt_period);
wdt_reset();
#if defined(__AVR_ATtiny85__)
WDTCR |= _BV(WDIE); //wake up interrupt when time is up
#else //ATTiny84, ATMega328
WDTCSR |= _BV(WDIE); //wake up interrupt when time is up
#endif
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
wdt_disable();
#if defined(__AVR_ATtiny85__)
WDTCR &= ~_BV(WDIE);
#else //ATTiny84, ATMega328
WDTCSR &= ~_BV(WDIE);
#endif
}
int main(void)
{
_delay_ms(1000); //power_on_delay
RFM73_Initialize();
RED_LED_OUT();
RED_LED_OFF();
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sei(); // enable interrupts globally
sleep_mode(); // go to sleep
while(1)
{
Receive_Packet();
sleep_mode();
}
}
// Start program
int main(void)
{
// Timer initialize
InitTimer1();
InitTimer0();
// Set LED pin to output
LED_DDR = (1 << LED_OUT);
// Enable interrupts
sei();
while(1)
{
// Sleep Mode
set_sleep_mode(SLEEP_MODE_IDLE);
sleep_mode();
// If command exists ... compare
if (CmdDone == 1)
{
// If matches required command
if (RC5_cmd_val == RC5_CMD)
{
// Sleep disablen
//sleep_disable();
// Set output to 1
LED_PORT |= (1 << LED_OUT);
// Set CmdMatch to 1 ... no new command will be sampled
CmdMatch = 1;
// Set TimerValue to zero
TimerValue = 0;
// Start counting
StartTimer0();
}
// Reset all values
RC5_cmd_val = 0x00;
CmdBitNumber = 7;
StartBit = 0;
CmdDone = 0;
}
}
}
int main(void) {
// Configure PORTB-pins
DDRD = 0x07;
rtc_init(); //initialise the timer
sei();
set_sleep_mode(SLEEP_MODE_PWR_SAVE);
unsigned int lastsecond = 0;
// Loop forever
while(1) {
if ( seconds != lastsecond )
{
PORTD ^= 0b00000100;
lastsecond = seconds;
}
if ( seconds == 0 )
{
// If one minute passed, pulse 2ms signal
// We must also alternate polarity of the
// pulse sent to the clock, so every other
// time we pulse the other way of the H-bridge.
//
// 0bxxxxxx10 -> 0bxxxxxx01 -> 0bxxxxxx10 -> ...(contd.)
//
if ( direction == 0 ){
PORTD |= 0x02;
_delay_ms( MOTOR_PULSE_DURATION_MS );
PORTD &= 0xFD;
// Increment direction to alternate next time
direction = 1;
} else {
PORTD |= 0x01;
_delay_ms( MOTOR_PULSE_DURATION_MS );
PORTD &= 0xFE;
// Increment direction to alternate next time
direction = 0;
}
}
gnight();
}
}
static void ioinit() {
DDRD = (uint8_t) 0xff & ~(_BV(3)); // PORTD 3 is input (INT1, RECVINT)
DDRC = 0xff; // LCD lines
DDRB = 0x0f; // SS_RECV, LCD_BACKLIGHT, SS/SNDRST, MOSI (see spi.c)
PORTD = _BV(4);
PORTC = 0x0;
PORTB = 0x0;
set_sleep_mode(SLEEP_MODE_IDLE);
// set INT0 and INT1 on rising edge
MCUCR |= _BV(ISC11) | _BV(ISC10) | _BV(ISC01) | _BV(ISC00);
GICR |= _BV(INT1); // enable INT1
// Enable GIE
sei();
}
/********************************************************************
*
* sleepNow
*
********************************************************************/
void Sleep::sleepInterrupt(int interrupt,int mode) {
if(mode == FALLING || mode == LOW)
{
int pin = interrupt + 2; //will fail on the mega
pinMode (pin, INPUT);
digitalWrite (pin, HIGH);
}
set_sleep_mode(sleepMode_);
sleep_enable();
attachInterrupt(interrupt,sleepHandler,mode);
sei(); //make sure interrupts are on!
sleep_mode();
//----------------------------- ZZZZZZ sleeping here----------------------
sleep_disable(); //disable sleep, awake now
detachInterrupt(interrupt);
}
void osx_tlsche_execute( TiOsxTimeLineScheduler * sche )
{
rtc_setinterval( sche->timer, 0, 2, 0x01); //定时周期为一秒
hal_enable_interrupts();
rtc_start( sche->timer );
while (1)
{
osx_tlsche_evolve( sche, NULL );
set_sleep_mode(SLEEP_MODE_IDLE);
sleep_enable();
sleep_cpu();
sleep_disable();
}
// rtc_stop( sche->rtc );
}
void sleepNow()
{
PORTA = 0;
DDRA = 0;
PORTB = 0;
DDRB = 0;
TCCR1B = 0;
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_enable();
GIMSK |= _BV(INT0);
asm("sleep");
GIMSK &=~_BV(INT0);
sleep_disable();
currDemo ++;
if(currDemo > DEMOCOUNT) {
currDemo = 0;
}
}
int main(void)
{
DDRB = (1 << PB0);
// Watchdog signal will be active low
//PORTB |= (1 << PB0);
// Setup the power reduction register
PRR = (1 << PRTIM1) | (1 << PRTIM0) | (1 << PRUSI) | (1 << PRADC);
sei();
while (1)
{
// Disable the watchdog
WDTCR |= (1 << WDCE) | (1 << WDE);
WDTCR &= ~(1 << WDE);
// Enable the watchdog. It will fire every 4 seconds.
WDTCR = (1 << WDIE) | (1 << WDE) | (1 << WDP3);
// Sleep in power down mode. We will be woken up by the watchdog interrupt
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_enable();
sleep_cpu();
// When we wake up the watchdog interrupt has fired, chck if we have done enough
// iterations for an hour. If so, pulse PB0 low.
if (counter >= (60 / 60))
{
counter = 0;
PINB |= (1 << PB0);
_delay_us(4);
PINB &= ~(1 << PB0);
}
}
return 0;
}
//Main body in fact, an inifinite loop
void ReadTemp(){
set_sleep_mode(SLEEP_MODE_PWR_SAVE);
while(1)
{
uint32_t v = ReadADCx16();
//convert to centigrad and *10 (because we are working with INT and want to display 1 decimal)
//v = (v * 5 * 100 * 10) / 1024; <=> v * 5 * 1000 / 1024 <=> v *5 but we loose a bit of precision
//v = v * 5;
v = (v * 5 * 100 * 10) >> 10; //>> 10 <=> /1024
//ad'hoc calibration
//apparently my system reads a bit too high temp, about 5% too high
//I don't have the will to make extensive test, calculate formula etc...
//v = v - v/20; //finally readings are ok like that after comparison, just keep the code for memory
//average the temp with latest readings
mTempBufferAverage[mTempBufferHead] = v;
mTempBufferHead = (mTempBufferHead +1) % AVGBUFFER_LEN;
//calculate an average with a circle buffer
v= 0;
for (uint16_t j = 0; j < AVGBUFFER_LEN; j++){
v += mTempBufferAverage[j];
}
v = v / AVGBUFFER_LEN;
//just some silly temporisation
for (uint16_t j = 0; j < 10000; j++){
showDigit(v);
//_delay_us(1000);
//_delay_ms(1); // save about 0.5mA per ms of sleep. 1 does not change the brightness, after it does but saves more power... depends if you want to read the temperature by daylight too.
}
//and now the sleep n time 8 sec
for (int i =0; i < 2; i++){
wdt_reset();
myWatchdogEnable();
sleep_mode();
}
}
}
int __attribute__((noreturn)) main(void)
{
uint8_t i;
/* disable watchdog */
i = MCUSR;
MCUSR = 0;
wdt_disable();
/* power down unused peripherals */
PRR = ( (1 << PRTWI) | /* TWI */
(0 << PRTIM0) | /* Timer 0 */
(0 << PRTIM1) | /* Timer 1 */
(1 << PRTIM2) | /* Timer 2 */
(1 << PRSPI) | /* SPI */
(1 << PRUSART0) | /* USART0 */
(0 << PRADC) ); /* ADC */
/* clock */
led_init();
clock_init();
hello();
/* USB */
usbInit();
usbDeviceDisconnect();
i = 0;
while (--i) {
_delay_ms(1);
}
usbDeviceConnect();
sei();
for (;;) {
usbPoll();
clock_poll();
set_sleep_mode(SLEEP_MODE_IDLE);
sleep_mode();
}
}
int main(void)
{
init_avr();
uart_init();
TCCR1B=(0<<ICNC1) | (0<<ICES1) | (0<<WGM13) | (0<<WGM12) | (1<<CS12) | (0<<CS11) | (0<<CS10);
// Timer/Counter 1 Interrupt(s) initialization
TIMSK1=(0<<ICIE1) | (0<<OCIE1B) | (0<<OCIE1A) | (1<<TOIE1);
sei();
Task[0] = 0;
while(1)
{
if(BytesRead != 0)
{
TCCR1B = 0x00; // stop timer1
memcpy(data_buffer, uart_buffer, BytesRead);
uart_flush();
for(int i = 0; i < 16; i++)
Task[i] = data_buffer[i];
run_task(Task);
for(int i = 0; i < 16; i++)
Task[i] = 0;
TCCR1B = 0x04; // run timer1
TimerEvent = false;
}
if(TimerEvent)
{
TimerEvent = false;
run_task(Task);
for(int i = 0; i < 16; i++)
Task[i] = 0;
}
set_sleep_mode(SLEEP_MODE_IDLE);
sleep_mode();
}
}
//------------------------------------End of Setup-------------------------------------------------//
//Main Loop//
void loop ()
{
flash (); //HeartBeat Flash//
AwakeTimer(); //Awake Timer//
if ( ATimer == SleepTime)
{
BattRead();
DataTX();
} // End of Main loop if timer was reached
//----------------------------------- End of Actual executing code---------------------------//
//Preparing to go to sleep//
digitalWrite(DataRadioSwitch,LOW); //Switch Data Radio off
byte old_ADCSRA = ADCSRA; // disable ADC //
ADCSRA = 0; // disable ADC //
byte old_PRR = PRR; // disable Internal modules//
PRR = 0xFF; // disable Internal modules//
MCUSR = 0; // clear various "reset" flags//
// Watchdog Timer Parameters//
WDTCSR = bit (WDCE) | bit (WDE); // allow changes, disable reset
WDTCSR = bit (WDIE) | bit (WDP3) | bit (WDP0); // set WDIE, and 8 seconds delay
wdt_reset(); // pat the dog once program has executed.
// Sleep Activation //
set_sleep_mode (SLEEP_MODE_PWR_DOWN); //Sleep mode Selection//
sleep_enable(); //Sleep Now//
// turn off brown-out enable in software//
MCUCR = bit (BODS) | bit (BODSE); //Brown out settings
MCUCR = bit (BODS); //Brown out set.
sleep_cpu (); //CPU is now sleeping
//--------------------------------------End of sleep Preperation-------------------------------//
// Once awake code executes from this point//
// Once CPU wakes up do the follwoing to restore full operations//
sleep_disable();
PRR = old_PRR;
ADCSRA = old_ADCSRA;
}
