This is the second post about powering an arduino from a capacitor. The basic setup is described in the introduction. It’s an ATmega328P in a standalone setup with use of the internal clock source. The power comes from the two capacitors on the picture. The microcontroller measures it’s own supply voltage repeatedly in intervals and writes data to the onboard EEPROM. After starting the measurement the power supply is plugged out and the ATmega runs off of the capacitors until the voltage is too low.

In this post I will describe how long the setup can run with different power-reducing techniques.

The first test

For a first test the arduino was programmed in standard configuration. This means that no power-reducing steps were made. The intervals between the measurements are made with the delay() command. So the controller is fully operating the whole time. This is the code:

#include <EEPROM.h>

// the measured voltage
unsigned int voltage;

// The analog input where the voltage is measured:
int voltagepin = 0;

int addr = 0; // EEPROM address to write to

void setup() {
  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++;
    delay(50);
  }
}

The diagram shows what is happening. V_CC was measured every 50ms. You see some noise on the curve. This is probably due to the ‘quick and dirty’ voltage divider with some resistors I had lying around. The controller was connected to the power supply at start. After 1.7 seconds power was plugged out. Then the ATmega ran on the capacitors for a little more than 3 seconds until the internal Brown-Out Detection shutted it off at 2.7V. The uptime of 3 seconds is what I expected and really isn’t a lot 😉

In the next steps I will add different power-saving methods like sleep and some other things to look how long we can go:

Step 1: First sleep mode test

In the first step the measurement interval is set to 1 second and the timing is done by the internal timer. So the controller can do the measuring and then sleep until the next measurement. To load the sleep library and to activate the timer the following lines are added at the beginning of the sketch:

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

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

The delay() command is replaced by:

  // 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

  set_sleep_mode (SLEEP_MODE_PWR_DOWN);  
  sleep_enable();

  sleep_cpu ();

  // cancel sleep as a precaution
  sleep_disable();

This code is copied directly from Nick Gammon’s page. The timer is set to 1s and then SLEEP_MODE_PWR_DOWN is activated. The controller stops after the sleep_cpu() command. When the timer finishes his interval the sketch continues at the same place. We see that the standalone uptime has increased to 88s which is a lot compared to running the controller continuously. As in the first test the controller stops at 2.7V by the brown-out detection.

The sleep library makes putting the controller to the different sleep modes comfortable.  Here you can find the documentation of the sleep library:  http://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html.

Step 2: How low can we go

Disabling Brown-out detection lets the ATmega run with much lower voltage than before. This will give us an increase in uptime because the capacitors can be discharged deeper and so give more energy into the system. Brown-out detection is often disabled in software. I tried the same but failed. The datasheet of the ATmega328P told me why in chapter 9.2 page 40: “Upon wake-up from sleep, BOD is automatically enabled again.” This is the reason why the controller doesn’t start after wake-up. Brown-out detection can also be disabled permanently by setting the appropriate fuse:

avrdude -P /dev/ttyACM0 -b 19200 -c avrisp -p m328p -U efuse:w:0x07:m

This is the command-line for my Linux computer. For more info about using a Uno board for setting fuses look here.
After setting the fuse the controller also works at lower voltage. The image shows the result. The ATmega works down to a voltage of 1.7V. Now we reach a uptime of 147s. This is an increase of 67% compared to step 1. Reading the datasheet 1.7V is lower than the minimum voltage the ATmega is able to run with. One reason for this could be that measuring of V_CC isn’t correct at this voltage level or that the controller can work at lower voltage than specified.

These first tests show that the total uptime of the system can be much longer than expected at a first glance. With some further tweaking it is possible to get even further. The next post shows the possibilities of power reduction both in the controller’s run mode and sleep mode.

Enjoy

heliosoph