How much power does the Particle Electron consume? When designing a solar-powered IoT project, it is always important to have a good real-world sense for how much power your devices are going to use. I hadn’t been able to find good data on the Particle Electron’s power consumption across its different sleep (and transmitting) modes, so I decided to go ahead and gather some data myself. I’ll summarize high level findings below, but read on for more information about how these tests were done and for access to the raw power data (sampled every 1s). The solar weather powered weather logger from a previous blog post was used as a test bed for this project (pictured below).

TL;DR Results

Please also see discussion and detailed results sections below to get a better idea of power use and tradeoffs.

Note that when using System.sleep and SLEEP_MODE_DEEP, significant (several kB) of data needs to be used to reconnect to the network on wake.

Note that there are 2 second stabilization delays in each of the transmits measured in the table above.

Methods

For these tests, I used a Drok USB power gauge to measure power consumption by a Particle Electron without its sidekick LiPo battery attached. A video of the setup was taken, and the voltage and current information was extracted from the seven segment display in the video using an image processing library I wrote. The raw data (sampled once a second) was then fed into Matlab along with time intervals during which the device was actually awake (manually extracted by watching the videos). A Matlab script was then used to gather various statistics from the data. The analysis scripts, raw sampled data, and analysis output can be found on Github here.

Three trials were performed:

1. Sleep_NetworkSTBY_Particle (use the SLEEP_NETWORK_STANDBY sleep mode and use particle.publish)
2. Sleep_Network_STBY_ThingSpeak (use the SLEEP_NETWORK_STANDBY sleep mode and send data to ThingSpeak)
3. Sleep_ThingSpeak (use the basic System.Sleep mode and send data to ThingSpeak)

All trials first waited 1 second, took and transmitted temperature and humidity measurements, waited another second, and then entered their respective sleep modes. The exact code can be found here.

Analysis Results

Detailed analysis results with mean power use (and standard deviation) for each awake and asleep interval can be found in the analysis text files here.

Discussion

Clearly SLEEP_MODE_DEEP saves the most power on the Electron, but it comes at the cost of being unable to save much data while in sleep (when it wakes up, it wakes up as if from reset) and at the cost of spending several kB of data every time it wakes up to reconnect to the network. This is probably the best mode if you transmit infrequently and don’t have to hold anything in memory (say, you just wake up to take and transmit a measurement before going back to sleep).

Next is the typical System.sleep() call, which shuts down the modem and puts the processor into a halt mode. This uses less power than leaving the modem on and holds information in memory but still must spend data reconnecting to the network when it wakes up. This is a good middle ground up from the deep sleep mode.

Finally we have the sleep mode with SLEEP_NETWORK_STANDBY enabled. Sleep mode halts the processor but does not turn off the modem and leaves the connection live. This mode uses much less power than when fully operating (up to ~0.35W less) but does not have to use data reconnecting to the network on wake. This mode is ideal if you need power conservation, transmit often, and/or have a tight data budget. Something else worth discussing is the trade-offs between Particle.publish and sending HTTP POST data to a service like thingspeak. In these tests, publishing to particle used less power (avg 0.53 W) but it took much longer to transmit (up to 71 seconds vs. ~15 seconds), though this could be because of modem re-connection times (future tests without re-connection could confirm this). It is also reported that Particle.publishes use less data than HTTP POST requests likely because they use streams.

Getting Started: Weather Logger Tutorial

This weather logger is going to sample data from a DHT22 humidity/temperature sensor and log it to a cloud platform (ThingSpeak) using HTTP POST every 20 minutes. Between transmits, we’ll put the device into sleep mode to conserve power. In my testing, this configuration uses only an average of 0.1021 W. This means our configuration uses only 2.5 Wh of energy a day (0.1021 W * 24 h)–so we can comfortably power our device using a Voltaic 6W or 3.5W panel. After the tutorial, I’ll discuss other power saving modes of the Electron and additional Solar considerations. For this tutorial we’re going to be using:

• Particle Electron + included 3.7V 2000 mAh LiPo battery
• DHT22 Temperature/Humidity Sensor
• 6W Voltaic Solar Panel or 3.5W Voltaic Solar Panel
• Voltaic MicroUSB Adapter

Hardware Setup

First, place the Electron in the middle of the included mini breadboard, and place the DHT22 so that pins 1-4 connect to pins D1-D4 on the Electron as shown below. We’ll be powering the DHT22 from digital pins so that we can turn power off to the sensor when we enter sleep mode. Ensure that the included LiPo battery is connected to the Electron and the U.FL antenna is attached.  

Solar Setup

To keep our device running, ideally we’d like to generate 2.5 Wh of energy a day to replace what’s used in 24 hours. With a 6W panel that gets 3 hours of good sun a day we can safely estimate generating 0.5*6W*3=9Wh a day, more than enough to keep us going and charge up LiPo battery reserves to get the device (and any sensors/LEDs) through weeks with bad weather or no sun. We multiply the panel Wattage by 0.5 to get a safe estimate of actual power generated and delivered to the Electron given various sources of loss from power regulation. This calculation also means you can get by with a 3.5 W panel if you’re in an area with good sun and don’t mind losing some power margin of error (you’d be generating at least 5.25 Wh a day). Since there’s already a LiPo battery charge controller (and intelligent power switching between battery and USB) built into the Particle Electron, all you need to do is directly connect the panel to the Electron’s MicroUSB connector as shown below. The battery charging draws between 0.65W and 1.8W in my testing.

Solar Setup 2

If you’re in need to store larger amounts of power or store it faster (e.g. you’re in an area with only a few hours of good sun a day), I’d recommend using a Voltaic V15 or V44 battery to store power from the panel and then pass it to the Electron. This is because the Voltaic batteries can pull down upto 4W of power from the panel at peak generation, whereas the Particle Electron’s charge controller doesn’t typically allow for power storage at such fast levels.

Basically, just connect the Voltaic battery to the panel and then connect the battery to the Electron with standard microusb. Picture is below.

Basic Software Setup

Thingspeak

ThingSpeak will receive data from the Particle Electron and display/store it for us. Go to ThingSpeak and set up an account. Click on “my channels” from the top tool bar and then “New Channel” Add a name for the channel and add two fields (one for temperature and one for humidity) and save the channel.   Once that’s done, click on the API Keys tab on your channel and note down your channel ID and write API key for later (we’ll need these to push data to this channel).

Firmware

Go to the Particle Build IDE, hit the code item in the lefthand menu, and create a new app. Next, we need to add and include the ThingSpeak and Adafruit_DHT libraries in our app. Do this by hitting the libraries tab item on the left and searching first for “ThingSpeak” and then for “Adafruit_DHT” and selecting “Include in App” and select your current app. Then you can go ahead and insert the code below into the editor, which can also be found here: https://gist.github.com/suyashkumar/fb1f09df4e475bda9cf0ba33cf009bf8. Comments are included on almost every line as explanation for what is going on. If you have a question, post in the comments below! Make sure you replace myChannelID and myWriteAPIKey with the values for your ThingSpeak channel. If you used different pin mappings for the DHT22, change them in lines 7-10. 

Wrap-Up

Now you should be good to go! You’ll want to find a way to water/weather proof this device if you’re going to deploy it in the wild. A quick power discussion is below.  

Power Discussion

As mentioned earlier, posting to ThingSpeak 3 times an hour is going to consume 2.5 Wh a day (24 hours). The Particle Electron has two main sleep modes, though–Deep Sleep and SLEEP_NETWORK_STANDBY with summaries and comparisons below. To use deep sleep mode, comment out the current sleep line in the code above (line 44) and uncomment the one on line 45. In sum:

• Sleep Network Standby (Higher Power, Low Data): Uses approx 0.1W of power max, keeps network connection alive (which saves a lot of data). Best if you transmit 1 or more times an hour. 
• Deep Sleep (Ultra-Low Power, High Data): Uses approx 0.0005W of power in sleep, but uses 6-10kB of data every time it wakes from sleep. Best if you transmit infrequently (say 1 a day) and need low power. Every time the device wakes up, it wakes up as if from “reset,” and runs the code from the setup() function.

Check out a more detailed power analysis and actual recorded data in a future post. Note also that using Particle.publish() to send data to the particle cloud will save you data and power, but requires you to pull your data from the particle services with your own software. More on that in a future post as well.