Now let’s put this all together. First we take the old setup from the first tests and set all digital I/Os to output and low and connect the analog inputs to GND. Surprisingly this doesn’t make a longer uptime. So obviously most of the electricity is consumed while sleeping. Let’s do some calculation:

Reading the analog signal and writing to EEPROM once takes 3.85ms (measured). Current is about 7mA. We consume 27µAs (time x current). During sleep as in our last configuration (ADC on, BOD off) we have a sleep current of 122µA and 1s of time for one period. So consumption during sleep is 122µAs! So most of the electricity is wasted during sleep according to the relatively high current and the much longer time.

Time for minimizing sleep current: Shut down ADC!

This is what we get 🙂 Analog-Digital-Converter and Brown-out Detection shut down whilst asleep gives us a total uptime of 450 seconds! This is around 150x longer than at the beginning (without sleep).

Brown-out Detection is enabled during run-mode. This stops the system at 1.8V. Without BOD we could get even lower but operation isn’t safe anymore.

The voltage divider that is used to measure V_CC is connected to a digital output. During the measurement this output is set to HIGH. Before sleep it is set to LOW. When you draw only very little current from a digital output set to HIGH the voltage equals V_CC. So now we don’t have any current through the divider while sleeping.

Here is a code example:

#include <avr/sleep.h>
#include <avr/wdt.h>
#include <EEPROM.h>

// Variables declarations:
// EEPROM address
int addr = 0;
// the measured voltage as integer
unsigned int voltage;
// keep the state of register ADCSRA
byte keep_ADCSRA;

// Pin declarations:
// The pin that supplies the voltage divider:
int dividerpin = 8;
// The analog input where the voltage is measured:
int voltagepin = 0;

// watchdog interrupt
ISR (WDT_vect) {
  wdt_disable();  // disable watchdog
}  // end of WDT_vect

void setup() {
  // set digital pins for low power consumption
  for (int i = 0; i < 14; i++) {
    pinMode(i, OUTPUT);
    digitalWrite(i, LOW);
  }
  // set analog reference voltage
  analogReference(INTERNAL);
}

void loop() {
  while(addr < 1024) {
    voltage = analogRead(voltagepin);
    // write data to EEPROM
    // Lowbyte first
    EEPROM.write(addr, voltage % 256);
    addr++;
    EEPROM.write(addr, voltage / 256);
    addr++;
    // shut down ADC
    keep_ADCSRA = ADCSRA;
    ADCSRA = 0;

    // Go to sleep for 1 second (with code from Nick Gammon)
    // clear various "reset" flags
    MCUSR = 0;     
    // allow changes, disable reset
    WDTCSR = _BV (WDCE) | _BV (WDE);
    // set interrupt mode and an interval 
    WDTCSR = _BV (WDIE) | _BV (WDP2) | _BV (WDP1);    // set WDIE, and 1 second delay
    wdt_reset();  // pat the dog
    digitalWrite(dividerpin, LOW);

    set_sleep_mode (SLEEP_MODE_PWR_DOWN);  
    sleep_enable();

    // turn off brown-out enable in software
    MCUCR = _BV (BODS) | _BV (BODSE);  // turn on brown-out enable select
    MCUCR = _BV (BODS);        // this must be done within 4 clock cycles of above
    sleep_cpu();

    // continues here after wakeup
    // cancel sleep as a precaution
    sleep_disable();
    ADCSRA = keep_ADCSRA;
    digitalWrite(dividerpin, HIGH);
  }
}

The while-loop prevents overwriting the first bytes of the EEPROM when more than 512 measurements can be done until power is down. The variable keep_ADCSRA saves the state of the ADC status register during sleep. After wakeup the variable is written back to the register to have the ADC in the same state as before. The voltage divider is connected to dividerpin and turned off during sleep.

Let’s have a look at what is still powered during sleep: The watchdog timer is needed in this setup to wake up the controller. Supply current is 6µA with the watchdog enabled. If we want to get rid of it wakeup has to be done via external interrupt by e. g. a RTC like the DS1337. This is what is done in the next post.

Another topic to talk about is how long can we go with the capacitors:

Self-discharge of the capacitors

Regarding the capacitors, self-discharge can have an impact on the maximum possible uptime. As I couldn’t find anything in the datasheet I decided to measure it. After charging one of the capacitors to 5V I disconnected it. Then I measured the voltage once an hour. Therefore I connected the capacitor to the voltmeter only for the duration of the measurement and then disconnected it again to prevent additional discharge due to the resistance of the voltmeter. The result was better than I expected: The capacitor lost 0.7V in 24 hours.

So this will give us enough time 🙂

In the next post we will add a RTC to have a more exact and more flexible system timing and to bring

Enjoy

heliosoph