Power saving techniques for the Attiny84 powered TinySensor

I have been working hard to cut power consumption on the TinySensors so that they can run on the CR2032 battery that is on the back of the PCB. I have one of the sensors is sending room temperature for two months now, powered by the CR2032 only and few more with AA two batteries. The problem with the CR203 battery is its low capacity, only 220mAh typically, compared to up to 2*2500 for two AA sized batteries. Still the CR2032 is appealing because of the small size, the sensor powered this way fits in a small neat box.

So my effort to save power started with picking the appropriate ATtiny84 version. The V version of the Attiny84 will work down to 1.8V at 4Mhz, check page 175 in the datasheet. This is good because 4Mhz is the lowest speed at which the RFM12b will operate as well. The RFM12b can work down to 2.2V when you initialize it appropriately:

  // Adjust low battery voltage to 2.2V
  rf12_control(0xC040);

The BOD schematic does consume precious power so worth disabling it wither thru fuses or in the software:

#define BODS 7 //BOD Sleep bit in MCUCR
#define BODSE 2 //BOD Sleep enable bit in MCUCR
MCUCR |= _BV(BODS) | _BV(BODSE); //turn off the brown-out detector

There is also a relationship between power consumption and the speed at which the ATTiny runs. The 4Mhz is the minimum for the SPI to operate, but that doesn’t mean we can’t run on less when we are not using the RFM12b module. With the ATTiny running off its internal oscillator and not an external crystal, we can change the speed on the fly with some simple code that sets the prescaler value:

static void setPrescaler (uint8_t mode) {
    cli();
    CLKPR = bit(CLKPCE);
    CLKPR = mode;
sei();
}

So that means while checking temperature sensors and doing non-RFM12B stuff we can run at 1Mhz (or less) and speedup for RF transmissions.

The next trick that I used is to power off the unused ATTiny hardware.

I don’t need timer 1 so I power it down:

PRR = bit(PRTIM1); // only keep timer 0 going

I enable the ADC only when I need it:

 bitClear(PRR, PRADC); // power up the ADC
 ADCSRA |= bit(ADEN); // enable the ADC

..and disable it right after:

ADCSRA &= ~ bit(ADEN); // disable the ADC
bitSet(PRR, PRADC); // power down the ADC

Power the USI only when we need the RFM12b:

bitClear(PRR, PRUSI); // enable USI h/w

..and disable it when I’m done:

bitSet(PRR, PRUSI); // disable USI h/w

I also use one of the pins of the Attiny to provide power to the attached sensor (DS18B20 or TMP36), thus ensuring I can power it up in the software by setting the pin to high and later to low when I am done. These two sensors are not ideal for low-voltage operations though as they operate at a higher voltage and will start failing at around 2.8V (although DS18b20’s datasheet states 3V low voltage). Thus you may consider different sensor, for example the MCP9700A that works down to 2.3V

I have found many sources stating that most power saving is achieved if you put pins to input and internal pull-ups enabled while sleeping, so I do that.

Also, consider the minimal data structure you want to send. A float value takes a lot of bytes to send (thus eats more battery), while a simple trick may allow you to use an int (2 bytes). For humidity and temperature readings, I multiply the reading by 100 so 23.15 (float) degrees becomes 2315 (int). The receiving end needs to multiply by 0.01 to get the original value.

Another thing is to plan how frequently you need to send. The RF module is a power hog, so you may want to plan the minimum possible send frequency. I send room temperatures every 15 minutes. You may also wake up only to read and average temperatures more frequently, but send out the averaged reading only once every 15 mins.

Here is a sample sketch that I run on one of my room sensors that utilizes the above tricks.

Comments are welcome