EFM32™ Zero Gecko Starter Kit w/ Sensor Card - Review

Table of contents

RoadTest: EFM32™ Zero Gecko Starter Kit w/ Sensor Card

Author: Jan Cumps

Creation date:

Evaluation Type: Evaluation Boards

Did you receive all parts the manufacturer stated would be included in the package?: True

What other parts do you consider comparable to this product?: Texas Instruments Ultra Low Power processors, Microchip PIC low power family, Atmel picoPower, ST STM32L, NPX LPC800 What were the biggest problems encountered?: measuring the controller current consumption without interference from other devices on the board

What were the biggest problems encountered?: I didn't encounter any problems with the product during the RoadTest

Detailed Review:



I'm testing the Zero Gecko kit with EFM32 controller, and a extension pack with environment related sensors.

The microcontroller designed to be very conservative with power consumption. It's claiming to run in several low energy modes, and to be able to wake up fast.

The development tools from Energy come with a variety of utilities to evaluate, profile and optimize power use.





Software installation


The download and installation of Simplicity Studio is straightforward. I did this on Windows 8.1 64 bit.

The process worked fine, no issues during the whole cycle. It took approximately two hours to complete on my brand new but modest PC and ADSL internet connection.


unboxing and checking the demo applications, first debug cycle




Road Test 1a: Unboxing


There was not that much to do at package opening time. The box contains two boards in plastic shields bag and a usb cable.

At the bottom of the box was this tiniest Quick Start Guide that I've ever seen - the size of a business card.

Everything was safely packed and secured. The only thing you 'll have to add yourself is a CR2032 battery.

The two break-out connectors on the long sides of the board are not populated. I haven't checked yet what processor pins are routed to there.





microcontroller: the processor is positioned more for low energy use than for highest processing speed

ARM Cortex-M0+

24 MHz

32 kB Flash

4 kB Ram



evaluation board:

debug via USB

power via USB or battery

graphical lcd screen

capacitive buttons

breakout positions


sensor board:

humidity and temperature

proximity and gesture

UV and light


Getting Started


Road Test 1b: testing the quick start and demo, how easy is it to get them working


Running the pre-loaded example: This worked right out of the box. It's the Space Invaders classic of the 80's. This demo showcases the lcd and the two capacitive touch buttons.


Loading and running a demo: Simplicity Studio recognized the zero gecko starter kit and pre-loaded content related to that board. I was able to load the weather station demo from Simplicity Studio in one go. I selected to run it with the power monitor enabled. This demo focuses on the sensor board's capabilities.


Building and running the first project: I opened the source of the 'blink' example in the IDE. I used the 'Software Examples' wizard to get the project set up in the Simplicity IDE. The wizard sets up the project properties. It also guides you through your first compile and Debug cycle.


I was able to complete all three exercises without reading any documentation. I know the Eclipse environment well, but still the start pages and wizards are a great help to get you going without frustrations. All focus could be spent on learning and experimenting.

All these activities in Road Test 1 worked without errors or issues. The board behaved well. I didn't have a single setup, compile or run-time error.


Checking the different energy modes

I've checked the different energy modes.



Road Test 2: measure power consumption during various modes


The starter kit comes with several energy mode examples. I've tested two of them.


The energy example: this project switches between clock frequencies (7, 11, 14 and 21 MHz) every few seconds. It displays the voltage and currency stats of the USB supply on the LCD. The power monitor works exclusively when the PWR selection switch is in DEBUG position.


The emode example: this one prompt for the desired energy mode and keeps running in that mode once selected. This exercise is handy when you want to do measurements in a stable state. These options are available:

EM0 24MHz (primes calc): the processor goes into a loop to calculate prime numbers in energy mode 0 - a good mode to learn how the profiler displays energy use per function

EM1 24MHz: runs in energy mode 1 at full speed

EM2 32kHz: energy mode at low speed

EM3 and EM4: go to sleep modes 3 and 4 respectively

EM2+RTC: run in energy mode 2, activate on pulse counter interrupt

EM2 and EM3+RTC+LCD: wake up on pulse counter interrupt, update display and go back to sleep

User: full speed standard mode running in an endless for(;;) loop.


I monitor the current with the Energy Profiler and with a µCurrent. To be able to measure current, I desoldered R704 and populated P701 with male print headers.

When not measuring, I bridge pin 1 and 2. When measuring, I put a current meter between pin 1 and 2.





The tutorials



Road Test 3: the EMF32 tutorial


The tutorials are integrated in Simplicity Studio. When you select a lesson, you can open the pdf with instructions, and you can generate the template project in the IDE.

The template project has indicators in the source that hint where you should place your code.

The lessons explain how to interprete the Reference Manual, how to use the registers - and how the API works.

The first lessons go into setting and clearing single bits and a range of bits within the registers. This may be common knowledge for lots of us, but it is a nice way to introduce the API's constants, masks and macros that make the code readable.


void initTimer() {
  /* Enable clock for TIMER0 */
  /* set prescaler to slow down clock by factor 1024, multiple bits so mask needed */


The first lessons cover timers and GPIO, the second set handles interrupts and energy modes.

The third lesson iterates over two of the existing application note examples, and drives you through further refinement of their energy profile.


Wake Up from sleep


Road Test 4: wake up from various sleep modes via GPIO async interrupt




I altered the tutorial's GPIO Interrupt example a little bit so that I could profile the controller's power consumption after an interrupt wake-up.

The original exercise toggles a led. The current used by the led influences the measurement. So I changed what happens during wake up time:

When running in idle mode, the firmware is in EM3.

When Button 0 is pressed, an interrupt fires and wakes up the controller.

I keep on reading the button's status (so a simple GPIO read in stead of afeeding an LED).

Once the putton is released, the controller returns to sleep mode EM3.






#define PB0_PORT gpioPortC
#define PB0_PIN 8

void GPIO_EVEN_IRQHandler(void)
  /* Get interrupts flags */
  uint32_t flags = GPIO_IntGet();

  /* Clear flags */

  /* Keep looping as long as the button is pressed.
  * This has two purposes:
  * - keep the controller in  wake mode, so that it shows in the profile
  * - perform a reasonable action: read a GPIO port, so that the power consumption
  *  is mainly that what the the controller uses. So no leds or anything
  * */
  if ( flags & (1 << PB0_PIN) ) {
  while(!GPIO_PinInGet(PB0_PORT, PB0_PIN));

int main(void)
  /* Initialize chip */

  /* Enable clock for GPIO */
  CMU_ClockEnable(cmuClock_GPIO, true);

  /* Configure button pin as input */
  GPIO_PinModeSet(PB0_PORT,        /* Port */
                  PB0_PIN,          /* Pin */
                  gpioModeInput,    /* Mode */
                  0 );              /* No filter */

  /* Enable IRQ event for push button GPIO pin  */
  GPIO_IntConfig(PB0_PORT, PB0_PIN, false, true, true);

  /* Enable interrupt for GPIO_ODD IRQ event */

  /* Stay in this loop forever */
  while (1) {


When I do a profiler spot current measurement in wake-up mode gives 1.76 mA.

I did a range check on the low power mode, because the consumption is volatile in that mode. The profiler gives an average current of 514.93 nA for a time span of 750.99 ms.




I've done more investigations and exercises on the starter kit:





Final notes

The sensors and display are nice and useful, but that's not what makes this combination special.

The biggest value of this product is the ability to monitor and measure power consumption.

That's where Silicon Labs manages to proove how low energy their processor is. It is out there for you to measure and validate.


For me, the big difference is not made by providing a demo that reacts on hand waves. It's when they manage to explain you in a nice way where energy is used.

And they manage to teach you how to save on energy in an understandable way - an exercise that some other companies hide deep in the datasheets.

In that sense, the Zero Gecko is more than a proove of concept for the microcontroller. It's an eye opener for embedded engineers on how low power you can make an application.


Additional info:

For some tests not captured here, I used the element14/TI FuelTank boosterpack as power source.


This power source with a Lithium Polymer battery is not very conservative on power itself, consuming 26 mA when idle in my case.

See here to reduce its power consumption:




I build a test gig to monitor power consumption, using an Arduino Uno to poll the FuelTank's battery gauge via i2c.

Prep for road testing the EFM32™ Zero Gecko Starter Kit

source code: https://gist.github.com/jancumps/c68bdb9a714e4faf18e3


I used the µCurrent to measure low power sleep power consumption. This device saves me from buying a current meter with low Burden voltage.