The main idea of the project was to test how much power would we actually need to power up a wireless sensor network, and try to push the boundaries of conventional power supplies (batteries, coin cell, solar panels) and have fun while at it. Someone mentioned "hey, remember the clock-powered potatoes?" and that's how the IoT potato-powered mote was born! a Potato Mote (PO-Mote): a Zolertia RE-Mote powered by potatoes.
The first thing we did was to compare two devices: spark core and the RE-Mote platform, comparing the low power of each one and the time delay to send to Ubidots, then try to improve the current scenario.
Then we connected the RE-Mote to an array of potatoes and periodically send messages every minute, below is a sneak-peak vide showing a real-live footage of the demo.
Power stuff with potatoes... right? what other motivation we would need?
I was pretty bored of hearing the low-power sales pitch everywhere indistinctively of the type of devices and technology used, and explaining the differences between a WiFI device in power consumption terms, compared to devices with a 20mA footprint while transmitting and receiving, was becoming repetitive... so why don't show this with an easy to understand example?
First we did a hand to hand comparisson, we used a Spark core (now particle) externally powered with a power supply and a remote powered with a Li-ion Battery.
At the point when we made this test, we used the Spark Core powered over the USB connector, thus increasing power consumption due to the regulator, after reading this thread we repeated the test powering the Spark via
Vin with 3.6V and we got almost 500uA less, so really the lowest current draw in
DEEP_SLEEP was around 180uA, and the overall current draw (also taking this into account while running in active mode) was an average of 40mA. Using
DEEP_SLEEP causes the Spark Core to restart, so each time it has to create a new connection to Ubidots instead of keeping the connection open.
In the graph we can see the highest peak consumption at 191.43mA, probably when all the system needs to be started. In the active mode, we can see that the average consumption is reasonably stable at 150mA. The deep sleep mode of spark (all components disabled) the consumption results is aproximately 0.67mA, pretty cool result for a WiFi-based device :-)
The shutdown mode of the RE-Mote is similar to the the Spark Core
DEEP_SLEEP, shutting all hardware components (including the System on Chip CC2538 ARM Cortex-M3 based) and running only on the ATTiny MCU used as co-processor. When powered on the current consumption is aprox 3.9mA using a duty cycle protocol (ContikiMAC). When the radio needs to transmit, the peak consumption is 40mA aprox.
The result average consumption of remote over 6-7 minutes is 2.6mA aproximately.
In the graph above we see some transmission peaks, these correspond to the TCP handshake to Ubidots server, then sending a POST using Ubidots RESTFull API. In average the whole process takes 15-18 secs to complete, but this is a delay tolerant application, so no optimizations were done for the example. In average this active period draws 7.25mA aprox.
A closer look at the RE-Mote power consumption when in shutdown mode shows some peaks due mostly to the ATTiny in low power mode. A tick-less MCU or other would decrease the 4.5uA average current draw even further, but this is nevertheless a good result, considering the shutdown mode is not only reducing the power consumption of the RE-Mote's cc2538 core (typically as low as 1.5uA in tickless mode) but also of the other modules and components in the RE-Mote (cc1120 sub-1GHz RF transceiver, micro-SD, attached sensors and regulators), so an application with power-hungry sensors for example would directly benefit from this.
Below are some screenshoots showing the timmings and captures done of the POST requests sent to Ubidots, showing a fully capable IPv6 end-to-end communication between the RE-Mote and Ubidots.
The published values are shown in the Ubidots dashboard.
As shown in the graphs above the power consumption of the RE-Mote is at least 15 times less (2.6mA vs 40.5mA) compared to the most low-power WiFI application I could come up with, using the same posting interval and try to keep the same scenario for better comparisson (no tune-in or optimizations of any kind). Using a connection-less protocol based on UDP like CoAP surely would helped us decrease this figures (saving valuable byte transactions for example not having to do the TCP handshake, thus keeping the radio less time ON), but I wanted to be fair and keep results as close as possible.
We purchased a Potato clock kit from Amazon mostly to get the copper and zinc strips.
First we needed to assert how much current and voltage could we draw from a couple of potatoes, a pair gave us aprox. 1.8V and 90uA, so we hooked up 4 potatoes in a serie array to get the 3.3V required to power the RE-Mote. We measured the discharge time of the potatoes and got enough juice to ran the setup with a 1.2K Ohm resistor for 5 days.
Then we prepared our setup: using 2 x 4.7uF capacitors in parallel connected to the potatoes electrodes we save enough juice, to transmit the temperature sensor readings every minute to a receiver node forwarding the results to a python script listening on the serial port. The sender side connected to the Potatoes is something like this:
When the RE-Mote is done sensing and transmitting the data over the wireless interface, it signals the ATTiny MCU to enter shutdown mode, disabling everything by the ATTiny operating in sleep mode, then waking up at the next minute and enabling back the CC2538, rinse and repeat.
The receiver side has a python script showing a visual interface printing the received data with a timestamp (alternatively it could store the data in a log file or forward to any IoT platform).
Below are some numbers showing the average power consumption on a 7 minute period, compared to the Ubidots example we sport now an average of 0.19mA, 213 times less than the WiFI test. One caveat though, this is a test using RIME (non-IP stack) so fewer packets and complexity is needed, also it requires a receiver hooked to a host to forward data to internet, but our goal was to stretch the scenario focusing on a minimum power supply rather than maintaining an IP-based design.
The firmware used for the test was developed on Contiki OS, a tarball is available below.
It was a fun experiment and more fun to justify to the management :-) but we are very satisfied with the results, actually enabling a potato-powered system with an overal good performance unlocks new energy harvesting possibilities and lots of applications... someone suggested that lemons have more power than potatoes, maybe that will be our new objective!
We got an overal savings of:
- 15 times less power than WiFi using HTTP RESTFull based API posting to an IoT cloud platform over IPv6
- 213 times less power than WiFi using non-IP, powered by a potatoes array.
As people say in 9gag, sorry for the long post, have an IoT potato!