It is not only how often the application works that matters but also how quickly it does it. The clock frequency can be dynamically changed between 156, 32 or 8 MHz.

Note that there are some limitations when limiting the clock frequency. For example:

However, since the frequency can be set dynamically you can increase it temporarily only when needed and run at a lower speed the rest of the time. This is especially useful if your app is just idling while waiting for some external event, such as receiving updated positioning data from GNSS.

Setting clock frequency from the Arduino library is done by calling the clockMode() function in the LowPower class. For more details about clock frequency control please see the SDK Power Saving Control documentation.

Accessing data storage will affect power consumption, especially if it is frequently accessed for reading or writing.

EEPROM is a memory type that is traditionally used for small amounts of non-volatile data. In Spresense there is an API for accessing EEPROM, but this implementation is just an emulation that actually uses flash storage, so from a power consumption point of view there is no difference.

Having the extension board connected will cause a slight increase in power consumption of approximately 700 μA. Also, having uart RX and TX on the expansion board, e.g. for debugging Spresense without USB connected, will cause it to draw approximately 3.5 mA extra. This is good to know when doing any power measurements.

Any kind of peripherals connected to the board and the type of battery selected will of course also affect the power consumption and battery life of an application, but the vast number of possible combinations makes this discussion out of scope for this short tutorial.

Here is a simple demo showing how GNSS updates might be handled in e.g. a goods tracking use case where low frequency position updates are enough. A more realistic application would probably process the collected data and then transmit it to some host, but to keep this demo simple and avoid external modules it just prints the data on the uart. For an introduction to the GNSS related concepts please see the How to read GPS information using the Arduino IDE tutorial. For this tutorial, we're using a standard LiPo battery with 3.7v.

Application outline

Here is a basic outline of the demo application (download the Arduino sketch here):

This is what the main loop looks like in the demo Arduino sketch:

void loop() {
  tries++;
  if (getGnssUpdate() ||
      (tries >= GNSS_UPDATE_MAX_TRIES && isRtcValid())) {

    /* Position aquired, go to sleep */
    Serial.print("Sleep for ");
    Serial.println(GNSS_SLEEP_PERIOD_S);
 
    Gnss.saveEphemeris();

    /* Note: "tries" is reset when the application is reloaded on wake up */
    LowPower.deepSleep(GNSS_SLEEP_PERIOD_S);
  }
}

Sample measurements

One wake cycle (wake up -> read GNSS -> write SD card -> sleep) consumes approximately 7 mA while during sleep it uses about 300 μA. The application tries to update GNSS data a number of times until it gets a valid update (i.e. not cached data), and assuming it takes on average five attempts to achieve this the board will be awake for approximately 10 seconds. Using this we can calculate an approximate number for how much current the board draws per hour for different wake-up frequencies:

There are 3600 seconds in an hour so hourly consumption is calculated as:

Cawake × (Tawake / 3600) + Csleep × ((3600-Tawake) / 3600)

So in theory, if we wake up and check the position every 10th minute, i.e. run for 60 s per hour, it will last for 4858 hours or about 200 days on a 2000 mAh battery. In reality however, the battery life will also depend quite a lot on battery discharge characteristic and environmental factors such as temperature.

Below are graphs showing examples of measurements calculating the numbers above:

Average consumption during sleep for the shaded area between the white lines (AVG = 303 μA).

Average consumption when awake and working for gray area between the white lines (AVG = 6.81 mA).

As a side note it's worth mentioning that by selecting clock frequency 32 MHZ instead of 156 MHz it only consumes about half the power, especially while waiting for GNSS to respond. This is illustrated in the graph below where the purple line shows power consumption when running in 32 MHz and the blue line when running in 156 MHz. The averages (AVG) are calculated for the GNSS wait period, i.e. the shaded area between the white lines in the graph.