Getting Started with Simplicity Studio

Created by Colton Parks, last modified on Aug 12, 2016


This page will show you how to use Simplicity Studio with the EFM32 Giant Gecko Starter Kit. Rather than copy the Giant Gecko article written here, I will show you how to setup Simplicity, and some of the quirks that come with the software. This will also work with the Wonder Gecko Starter Kit. Both boards are identical in functionality. The Wonder Gecko has less memory, uses a Cortex-M4F, and has a Floating Point Unit. The Giant Gecko uses the Cortex-M3. Be warned there are tons of hyperlinks in this article. You don’t need to follow them all.

Quick Links:

Purchase Link - This will bring you to Digi-Key’s selection of Silicon Labs’ 32-bit starter kits.

EFM32WG-STK3700 schematic BRD2200A_A03_schematic.pdf (506.7 KB) – This should be available under kit documentation.

EFM32WG Reference Manual EFM32GG-RefMan.pdf (11.1 MB) – If you enjoy direct register access, this manual is your bible. I would recommend reading the sections you plan to use anyway. It is very useful in understanding how the chip works.

EFM32GG990F1024 datasheet EFM32GG990_Datasheet.pdf (1.7 MB) – This will tell you which pins the peripherals are located under, among other things.

SDK documentation – This should be available on Simplicity Studio under software documentation.

Silab’s Forum – Home of the experts, ask a question and these guys can help you solve your problems. Or, just do a key-word search of your problem.

The Maker’s Guide to the IoT – I am a personal fan of this guy. His tutorials are extremely descriptive and very helpful. 10/10 would highly recommend.

Getting Started with the EFM32 Giant Gecko Starter Kit - This is another tutorial on how to setup the basic peripherals of this board. This article is also the reason why I won’t be going into the setup of peripherals.

Opening Simplicity:

I would highly recommend starting with a starter kit. The starter kits have a j-link debugger built in, which is incredibly useful for debugging custom boards.
Go through the setup tasks before anything. Once you install the necessary drivers, plug in your starter kit. Simplicity will add a ton of tools! To do a life test on your board, run some of the Demos available.
Here is a brief description of each link

Simplicity IDE: This is your programming environment, where you will spend most of your time.
Energy Profiler: This takes a program and shows how much energy your chip consumes running the program. It also shows how much energy each program uses. Very useful for low-energy applications.
Configurator: This guy is your friend. It will show you which peripherals are available for your device. You can use this when you start a new project and it will greatly simplify your setup.
Demos: You can use these demos to see what your board is capable of, or to perform a life test. For the code that runs these demos, look under software examples.
Flash Programmer: This tool programs your code into the chip.
Kit Manager: You need to have something connected to Simplicity to view this page. This page shows you some information about your chip. It is also where you select the debug mode. If you select Debug Mode, you will see four options:
Available Debug Modes:

  • In: External debugger connected to kit
  • MCU: Debug MCU on kit, debug connector disabled
  • Off: Disable kit debugging
  • Out: Kit debugger used to debug out
    Select the last option to debug a custom board.

SWO Terminal: I have mixed feelings about this tool. It doesn’t work like you might expect. When you first open it, it will tell you how to set up. Here is a discussion on the forum that talks about it. This is another more lengthy post that discusses it as well. If neither helped you out, you could use ITM_SendChar in place of USART_Tx in this code from the Maker’s Guide. My little test on it made it work, but it wouldn’t print until it entered the while(1) loop. It was easier for me to setup a UART on unused pins and use the aforementioned code. (Then you can throw an XBee on it and communicate wirelessly.)
If you end up using print or printf code, know that Simplicity doesn’t include floating point print by default. To enable floating point print compatibility, you need to:

Click: Project → Properties

Click: C/C++ Build → Settings

Under Tool Settings, expand GNU C Linker.

Click Miscellaneous

At the linker flags line, add this flag: -u_printf_float

Click Apply

My little test code for SWO print. Once you program the code to the chip, click on the SWO terminal from the home screen. Press the play button near the top to see the output. You can reset the board to verify that it starts from the beginning.

My test code for the SWO

 * @file
 * @brief Simple LED Blink Demo for EFM32GG_STK3700
 * @version 4.3.0
 * @section License
 * <b>Copyright 2015 Silicon Labs, Inc.</b>
 * This file is licensed under the Silabs License Agreement. See the file
 * "Silabs_License_Agreement.txt" for details. Before using this software for
 * any purpose, you must agree to the terms of that agreement.
#include <stdint.h>
#include <stdbool.h>
#include "em_device.h"
#include "em_chip.h"
#include "em_cmu.h"
#include "em_emu.h"
#include <stdio.h>
#include <stdarg.h>
//This isn't my code, I grabbed it from the Silabs community
void send_string(char * string)
      while (*string != 0)
            ITM_SendChar(*string++);            //Get rid of the exception and just send the character over the SWO terminal.
//This code will substitute printf, so most printf functions will work. Note the largest message you can send is 130 characters
void print(const char* format, ...)
    char       msg[130];
    va_list    args;
    va_start(args, format);
    vsnprintf(msg, sizeof(msg), format, args); // do check return value
//Include this code to be able to use Serial Wire Output
void SWO_SetupForPrint(void) {
    /* Enable GPIO clock. */
    /* Enable Serial wire output pin */GPIO ->ROUTE |= GPIO_ROUTE_SWOPEN;
#if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_LEOPARD_FAMILY) || defined(_EFM32_WONDER_FAMILY)
    /* Set location 0 */GPIO ->ROUTE = (GPIO ->ROUTE
    /* Enable output on pin - GPIO Port F, Pin 2 */GPIO ->P[5].MODEL &=
    /* Set location 1 */
    /* Enable output on pin */
    /* Wait until clock is ready */
    /* Enable trace in core debug */CoreDebug ->DEMCR |=
    ITM ->LAR = 0xC5ACCE55;
    ITM ->TER = 0x0;
    ITM ->TCR = 0x0;
    TPI ->SPPR = 2;
    TPI ->ACPR = 0xf;
    ITM ->TPR = 0x0;
    DWT ->CTRL = 0x400003FE;
    ITM ->TCR = 0x0001000D;
    TPI ->FFCR = 0x00000100;
    ITM ->TER = 0x1;
main() {
    CHIP_Init();                                            //Call this at the beginning of every project
    SWO_SetupForPrint();                                    //Call this to setup SWO. Use ITM_SendChar(char c)
    uint16_t j = 0;                                         //Initialize j
    volatile uint32_t i;                                    //Call i volatile so the compiler doesn't optimize it away
    while(1) {                                              //Forever loop
        print("\nHi %d", j++);                              //Print Hi and the value of j. Increment j
        for(i = 0; i < 100000; i++);                     //This is a very crude delay function. Useful in a hurry

EnergyAware Battery: I haven’t used this tool myself, but it looks like it will estimate the life of your battery based on the state of the chip.
Software Documentation: This page was linked above. It provides the documentation for all the libraries included in Simplicity.
Software Examples: This example code is the code that runs the demos from above. It is useful to see how to do certain things, and to use it as a skeleton for a new project.
Application Notes: This is a guide for turning your dreams into reality. It covers everything from PCB design considerations to USB implementations. Just select the app note you want and open the folder.
Kit Documentation: This is the documentation for the schematic, PCB design, Bill of Materials, and reference manual specific to your kit. It is very useful for designing your own board: you can see the specifications of each part used in the kit.
Data Sheet: Brings up the datasheet for your chip. This is useful for seeing which pins peripherals route to.
Reference Manual: This is the guidebook for direct register access. I use this to setup simple peripherals like timers and gpio interrupts.
Other Documents: Pretty self-explanatory. Chip errata and the Cortex M guide can be found here.
Resources: The last line of links are the various services offers. The Silicon Labs Community is probably the most helpful link here.

Starting a project in Simplicity V3:

Using Simplicity has its perks. It has many tools that work well with their parts. It also takes care of much of the setup for a new project. Here is how you set up a project in Simplicity Studio:
Starting a project:
Starting a project without Configurator:
Start at the Simplicity IDE. Click on Project->New->Silicon Labs MCU Project.
Select your kit. Simplicity will fill in the blanks when you do. If you are using a custom board, select “none” for the kit. You will need to set your part. The SDK should be the same as the kit.

I usually start an empty c program. If an example lines up with what you have in mind, you could choose that instead.

Name your project and hit finish! I didn’t experiment with the other settings, I would suggest leaving it as the default “link libraries and copy sources.” I will describe how to import libraries and tricks to using Simplicity Studio later on.

Starting a project with Configurator:
Start at the Simplicity home page. Click on the Configurator button. If this button doesn’t show up, ensure your board is connected to Simplicity Studio.

Select your kit and hit next.

Name your project and press finish.

It may take some time for Configurator to setup. When it does, ensure that the Port I/O tab is selected under “Outline”. Select Peripheral mapping. If you don’t see either, you can add them with this button image near the bottom.

Select the peripherals you plan to use. When you click on a peripheral, you can set the location and the individual pins. The bottom will show some problems and hint at what still needs to be done. If you are going to use SPIDRV or UARTDRV, you don’t need to set it up here.

When you are happy with your selection, you need to set the GPIO pin modes. Double click the errors under “Problems” to bring up the properties of a specific pin. Click the image button to change the pin mode. In this case, I needed to set the pin to Push Pull. The error will go away on the next mouse click.

If Configurator doesn’t throw an error, you probably don’t need to set a pin mode.
After all your I/O pins have been set up, it is time to set up the peripherals. Click on DefaultMode Peripherals. Here you will select your peripherals (again), but this time you can modify the properties of peripheral.

In my case, I received new errors when i set up my timer. This is because the compare/capture channels are disabled by default in the timer properties. To fix it, i set the CC mode property value.

If you don’t understand what Configurator is saying about a peripheral, you can read about it in the reference manual for a comprehensive understanding.

Go back to Simplicity IDE.

Under the project explorer, expand src and double click main.

In your main file, be sure to include “InitDevice.h” and the second line of code should be enter_DefaultMode_from_RESET();

This is a similar walkthrough of setting up a project in Configurator. It is a very useful tool. I will describe how to import libraries and tricks to using Simplicity later on.

Starting with Simplicity Studio V4:

If you upgraded to the latest version of Simplicity (not officially released at the time of me writing this), this tutorial will look more familiar.
Starting a project in Simplicity Studio V4:

Plug in your starter kit. Again, I would highly recommend starting with a starter kit. It is an easy way to test out different hardware. More importantly, the kits come with a debugger, which can be used to debug custom boards.
Start by clicking on tools near the top of the page. Click Add/Remove tools. Select your kit and press next, then finish.
If you take the tour, It’ll run you through the basics of setting up kits and parts.

Starting a project without Configurator
Select your kit located under “device” and press “new project.”

Your board should appear. If you are programming a custom board, cancel the currently selected board and select the right part. If this is your fist time starting a project, you will need to download configurator data. Click Next.

Now select your starting option. I usually go with an empty c program, but working from an example isn’t a bad idea.

Give your project a name that describes its purpose.

Click Finish and your project will build. I will describe how to import libraries and tricks to using Simplicity later on

Starting a project in Configurator:
To start, ensure your device is selected under the Device tab. Select Compatible Tools and Hardware Configurator.

Hit Next, then name your project.

This is what you will see when your project opens.

Start by selecting your peripherals under the peripheral mapping tab. That way, you can resolve pin conflicts right away by choosing different locations. Start with the most crucial peripherals first. Make sure to click on the “Port I/O” selection under the “Outline” tab to get that nice peripheral mapping selection.

In this setup, I think I will use the Timer3 compare/capture pins on location 1 to control the LEDs. I also selected the HXFO. You can see that I already have two errors near the bottom. These are very helpful errors. Double click the error to change the pin mode.

Click this button image to change the pin output. Select the proper pin mode and the error will go away on the next mouse click.

Once you are satisfied with your selection (and no errors appear), click on the “DefaultMode Peripherals” tab. Before, we set up the pins necessary to run your peripherals. Now, we will set up the peripherals themselves.

Click the checkbox on each peripheral you chose earlier. When you select a peripheral, you can modify the properties on the right hand side. This is pretty handy, because you don’t have to set it up later on in your code. If you don’t understand what a setting does, you can read about it in the reference manual.

Once you are done setting up your peripherals, click File->Save. Configurator will take some time to set up the code. Once it is done, go back to your main code by double clicking src->main.

To use the Configurator in your code, add #define “InitDevice.h” to your define list. Then, add enter_DefaultMode_from_RESET(); directly under CHIP_Init();

That should be it! You are ready to start designing a smart sensor, or a ping pong ball cannon that simulates each shot!

Importing Libraries in Simplicity:

One of the most annoying problems I faced early on was finding the proper libraries in Simplicity. Here is a rundown of what I learned:

Emlib Libraries:

  • Emlib C files are all found under C:\SiliconLabs\SimplicityStudio\v3\developer\sdks\efm32\v2\emlib\src

Different ways to import emlib files:

  • Method 1: copy from the file system.
    Go to
    and copy/paste the necessary libraries over to your project.
  • Method 2: use the import function.
    Under the project explorer tab in the IDE, right click emlib and select Import → Import…

Select General → File System

If you don’t have any selections under the arrow, you will need to browse your file system to the path C:\SiliconLabs\SimplicityStudio\v3\developer\sdks\efm32\v2\emlib\src
The next time you open this page, you can select it from the drop-down arrow.

Select the libraries you wish to copy to your project, and hit “Finish”

  • Method 3: Use Configurator.
    Use Configurator to setup the peripherals. Configurator will automatically copy the emlib .c files to your project (preferred method).

EMDRV Libraries

  • UARTDRV, SPIDRV, RTCDRV, and DMADRV are really useful drivers.
    Before you attempt these drivers, I would recommend trying a basic UART or SPI example. Here are two good sources that have example code for this part.
    Getting started with the EFM32 Giant Gecko
    Maker’s Guide to the IoT
    These drivers are pretty handy for any application. To learn more about them, read the software documentation found here. It will take some playing around to set it up. These functions are constantly changing, so double check the implementation in the example code.
    You will need to copy header and source files to your src folder. The easiest way to do this is to let the errors point out which files are missing when you compile the project. You should only have to add a few includes to the top of your code.
    You might receive semantic errors. If these errors won’t go away, try to delete the errors from the problems tab and rebuild. If they don’t reappear after your build, they probably won’t affect your project.

Files needed for UARTDRV:
include “uartdrv.h”

Include “uartdrv_config.h”

Add these files to the emlib folder:

  • em_cmu.c
  • em_dma.c
  • em_emu.c
  • em_gpio.c
  • em_int.c
  • em_usart.c

Copy these files to your “src” folder:












Example code for UARTDRV:

#include "em_device.h"
#include "em_chip.h"
#include "InitDevice.h"
#include "uartdrv.h"
#include "uartdrv_config.h"
UARTDRV_HandleData_t uarthandleData;
UARTDRV_Handle_t uartHandle = &uarthandleData;
void setup_uartdrv(void) {                                      //Setup uartdrv
      //Configuration for USART1, Location 1
      UARTDRV_Init_t uartInitData;
      uartInitData.port                     = USART1;                           //Port selection
      uartInitData.baudRate                 = 9600;                             //If this is off, check your HFCLK
      uartInitData.portLocation             = _USART_ROUTE_LOCATION_LOC1;       //Check your part datasheet
      uartInitData.stopBits                 = USART_FRAME_STOPBITS_ONE;         //Stopbits
      uartInitData.parity                   = USART_FRAME_PARITY_NONE;          //Parity
      uartInitData.oversampling             = USART_CTRL_OVS_X16;               //Oversampling mode. Check ref manual
      uartInitData.mvdis                    = false;                            //Majority vote
      uartInitData.fcType                   = uartdrvFlowControlNone;           //Flow control
      uartInitData.ctsPort                  = 1;                                //Port B in this case
      uartInitData.ctsPin                   = 7;                                //Pin 7
      uartInitData.rtsPort                  = 1;                                //Although it is disabled, i connected them
      uartInitData.rtsPin                   = 8;                                //on the board anyway just in case
      uartInitData.rxQueue                  = &rxBufferQueueI0;                 //Receive operation queue
      uartInitData.txQueue                  = &txBufferQueueI0;                 //Transmit operation queue
      UARTDRV_Init(uartHandle, &uartInitData);
int main(void)
  while (1) {}

Files needed for SPIDRV:
Include “spidrv.h”

Include “spidrv_config.h”

If you choose to keep the define EMDRV_SPIDRV_INCLUDE_SLAVE in the spidrv_config file, you will need to add these RTCDRV files:





Add these C emlib files to the emlib folder

  • em_cmu.c
  • em_dma.c
  • em_gpio.c
  • em_int.c
  • em_usart.c

Copy these files to your “src” folder:









Example code for SPIDRV:

#include "em_device.h"
#include "em_chip.h"
#include "em_cmu.h"
#include "spidrv.h"
#include "spidrv_config.h"
volatile bool spidrv_active;
SPIDRV_HandleData_t handleData;
SPIDRV_Handle_t handle = &handleData;
void TransferComplete( SPIDRV_Handle_t handle, Ecode_t transferStatus, int itemsTransferred) {
 if (transferStatus == ECODE_EMDRV_SPIDRV_OK) {
 // Success !
 spidrv_active = false;
void ReceiveComplete( SPIDRV_Handle_t handle, Ecode_t transferStatus, int itemsTransferred) {
 if (transferStatus == ECODE_EMDRV_SPIDRV_OK) {
 // Success !
 spidrv_active = false;
void setup_spidrv(void)
 //Check your settings. Click SPIDRV_MASTER_USART1 and press F3 to see the default settings
 //Click SPIDRV_Init_t and press F3 to see the initData declaration.
//Setup for Usart1, Location 1
initData.clockMode = spidrvClockMode3; //CLKPHA = 1, CLKPOL = 1, Check USART in ref manual.
 //initData.csControl = spidrvCsControlApplication; //This will let the application control Chip Select
 // //You will need to manually clear and set the CS pins
SPIDRV_Init(handle, &initData);
int main(void)
 /* Chip errata */
uint8_t message[6] = "\nHello"; //Normally you would send register addresses and stuff.
 uint8_t response[6];
//set the flag
 spidrv_active = true;
 SPIDRV_MTransfer(handle, &message, &response , 6, TransferComplete);
 //Now you can do other things while your message is sending.
 //Just poll it
 SPIDRV_MTransmitB(handle, &message, 6);
 /* Infinite loop */
 while (1) {

DSP Libraries:

  • Some pretty cool DSP functions can be found under C:\SiliconLabs\SimplicityStudio\v3\developer\sdks\efm32\v2\CMSIS\DSP_Lib
    You will need to define the core used, which I’ll show below.
    Here is a post on how to use the FPU.
    To use the math functions, add
    #include “arm_math.h”

How to define the core used:
Click Project-> Properties
Select C/C++ Build-> Settings
Select GNU ARM C Compiler-> Symbols
Click this symbol image to add a symbol

Add this line if you have a Cortex-M3.

If you have a Cortex-M4, you need to add MATH_CORE_CM4=1 instead.

Math Library:

  • For basic math operations (sin, tan, abs), you will need to include math.h, which seems to have a special kind of setup.
    Here is a post on how to add math.h to the libraries.
    To use basic mathematical functions, add
    #include “math.h”

Then, follow these steps to add the library to the project:

  • Click Project-> Properties
    Select C/C++ Build-> Settings
    Select CNU ARM C Linker-> Libraries
    Press this button to add a library. It will expect “lib” and “.m”, so to add the library “libm.m” you only need to type “m”

Tips for using Simplicity Studio:

Text editor:

  1. The IDE has an autocomplete feature. Press Ctrl+Space to enable it.
  2. F2 will show the declaration of functions.
  3. F3 will open the file where that function is located.
  4. Ctrl+Tab will switch between header and source files.
  5. Isolate problems during building by closing unrelated projects.
  6. Double click tabs to get a fullscreen view. Double click again to go back.


  1. F5 will step into a function. Useful for seeing the innards of library functions.
  2. F6 will step over a function. This will let you skip over the innards of functions.
  3. F7 will step return from a function. Useful to return from the innards of functions.
  4. F8 will resume the script.


Any questions or comments please go to Digi-Key’s TechForum