Official Blog of Silicon Labs

      • Hello World Part 1: The C code structure and locating a test LED

        lynchtron | 04/119/2015 | 12:01 PM


        In this lesson, you will learn how to write your first embedded program. When software programmers learn a new language, the first program usually written is to simply output the words “Hello World” to the display screen. Since embedded systems don’t always have a display, the best we can usually do is blink an LED. In addition, you will learn all about the process of creating an embedded executable and transferring that executable to the Wonder Gecko Starter Kit.


        The C Code File Structure

        For those of you who have coded in C-like languages before, you can feel free to skip this section. For this course, I assume that most readers may have had some exposure to higher-level computer languages, but not necessarily the C programming language. I will therefore explain things very clearly and exhaustively in this section so that you can get a feel for the lingo of a C program.


        The emptyProject.c file was created by Simplicity Studio automatically and written in a computer language known as C. This file contains C source code that will be parsed by a computer program called a compiler, which is then linked with other supporting source code by a linker and then translated into an executable program. That executable program is then transferred to your MCU where the program is executed. The process by which a computer program is parsed, compiled, linked and turned into an executable is called a build process. 


        The software that you develop for an embedded project through this process is known as firmware. It is called this because embedded software was traditionally written once and then it could not be updated ever again. Today, we have upgradeable firmware in many of our devices, so the distinction between software and firmware is less apparent.



        Contents of emptyProject.c


        The first section of our emptlyProject.c file is a comment block header.  The comment block is optional and contains the purpose of the file with a copyright notice and usually contains lengthy license clauses for protecting corporations. The comment section is usually specified by a starting block comment marker /* and an end comment marker */. Everything between those markers is ignored by the program and you are free to modify the contents. They can occur anywhere within the code, even within a single line of code. These are C style comments.  You can also use C++ style comments, which are two forward slashes “//” which comments everything out on the rest of a single line. These are the comments that I prefer to use because there are only two keystrokes and no shift key required.


        You may notice some curious looking @ symbols in the comment header, and that is part of a docstring. The docstring shown uses special keywords such as @file and @brief because they are used to automatically generate documentation from the source code with a third-party tool called Doxygen that is not a part of Simplicity Studio.  If it were not for this documentation mechanism there would be a lot of source code out there without ANY documentation!


        The comment block is usually followed by an area where we specify instructions to the compiler about which files we want to include in the compile process by using the #include statements. The # sign indicates a compiler directive (also known as a preprocessor directive) and Simplicity Studio is nice enough to color the instruction differently to let you know that it is special. This #include tells the compiler where to look for any external functions that will be used in the code and also pulls in constants and #defines that have been set up for your particular MCU model. A #define is utilized later by other preprocessor directives: #if, #ifdef, #ifndef, and #endif.  None of these statements that begin with the # sign will make it into your executable program. They don’t get executed on your MCU but they have a great deal of control over which blocks of code will make it into your executable. Simplicity Studio will automatically shade blocks of code that will not be executed on your MCU due to #if/#ifdef/#ifndef statements.


        The emptyProject.c file has two #include statements. The first is #include “em_device.h” which sets up your program as one that can operate on an EFM32 MCU. It gives your code the ability to read registers on the MCU and access to all of the constants that the Silicon Labs team have already thoughtfully set up for your program to access. Without it, you would have to look up the gory details of every MCU setting or other value in the reference manual every time you wanted to use an MCU-specific feature. The second is #include “em_chip.h” bringing in the function CHIP_Init()referenced later in the program.


        One of the niceties of working in Simplicity Studio is the ability to find out more information about an identifier in the source code just by hovering your mouse pointer over it, or selecting it and right-clicking to see all kinds of things you can do with it. For example, when we hover on the include statement, nothing happens. But if we highlight the name of the file and right click, we see lots of options. Follow the “Open Declaration” menu choice, or press the F3 button and Simplicity will open a new tab showing you the file that is being referenced. If you scroll down, you will see the implementation for the CHIP_Init() function:


        __STATIC_INLINE void CHIP_Init(void)
        #if defined(_EFM32_GECKO_FAMILY)
          uint32_t                    rev;
          SYSTEM_ChipRevision_TypeDef chipRev;
          volatile uint32_t           *reg;


        Don’t worry about what all of that stuff in the function means for now.  Just marvel for now at how easy it is to find the source for any source file.


        Navigate back to the emptyProject.c tab in Simplicity Studio.


        After the compiler directive section, there is a docstring that describes the purpose for the main function definition. The main function is special, since it is the entry point to your program. A function definition is created by specifying a return type, the function name, followed by optional input parameters within parentheses. 


        In the case of the main function, you must specify an int return type, and no parameters.   Note that unlike desktop programming, there is no way to pass in command line parameters to the main function of an embedded program, because there is no command line.


        When we are done with the function definition, the implementation of the function immediately follows, encapsulated in curly brackets { }.


        The first line inside the main function is a code comment /* Chip errata */, which is trying to convey the idea of what the following function call on the next line will accomplish. Comments are a GOOD thing to see in your code, but you can find out even more about what a function does, thanks to Simplicity Studio. Hover your mouse over the CHIP_Init() function call to see a popup that shows you the same information in your browser:


        If you highlight the CHIP_Init word and then right-click and choose “Open Declaration”, it will open the referenced em_chip.h file and put as right at the declaration of the function, which also shows us the purpose of the function in the docstring above the function definition:


         * @brief
         *   Chip initialization routine for revision errata workarounds
         * This init function will configure the EFM32 device to a state where it is
         * as similar as later revisions as possible, to improve software compatibility
         * with newer parts. See the device specific errata for details.



        So, now you know what the CHIP_Init() function does, and I didn’t even have to tell you!  Hopefully you will do this on any function where you need to understand what it does.


        Finally, the firmware enters a while loop which will keep the MCU busy into eternity, or until you reset it as you load it with a new executable.


        Find an Onboard LED

        Since we already compiled and built a simple emptyProject.c file in the first lesson, we will skip that step here. Next we will modify the file to enable a General Purpose Input/Output (GPIO) pin that is connected to an on-board LED on the Starter Kit. The objective of this next step is to simply put voltage on the GPIO pin that is connected to the Starter Kit test LED. To do that, we have to figure out which GPIO pin the test LED is connected to on the EFM32 MCU. We can do that right from Simplicity Studio.

        Go back to the Simplicity Studio home screen by click on the “Simplicity perspective” icon in the upper right hand corner of the IDE:



        Then, click the “Kit Documentation” tile:



        This will bring up all of the available documentation for your kit.   



        When you open up the User Manual for this kit, you will find text on page seven: “The LEDs are connected to pins PE2 and PE3 in an active high configuration.” That tells us everything we need to know to turn on the LED.


        In the part two of this lesson, I will show you how to create and load the firmware to blink those LEDs on your Starter Kit.



      • Low-Power 32-bit MCU Enables Thin Watch Design

        Siliconlabs | 04/118/2015 | 08:26 AM

        Creating a simple, sleek design is harder than it looks!

        Situation: A top fitness watch manufacturer wanted to bring a smart watch to market with complex fitness algorithms, including heart rate monitoring, packaged inside a sleek design. To provide the ultimate user experience with a long lasting battery, the designers needed a high-performance processor with an energy-friendly power profile; and Silicon Labs’ MCU family offered the most advanced and flexible energy-friendly MCUs on the market.




        Solution: Not only are they energy efficient across active and sleep modes, but they also have ultra-fast wake-up times. These MCUs feature best-in-class architectural innovations to achieve power reduction within every block of the MCU, resulting in longer battery life. The EFM32 Wonder Gecko has an ARM® Cortex®-M4F core, with a digital signal processor (DSP) hardware floating-point unit (FPU) for faster computation performance. 

        The energy-efficient EFM32 MCU in a small package, allowed the product managers to reached their goal of an ultra-thin, lightweight product. Not only was the product design sleeker, but it also delivered a 2x longer battery life than the other MCUs they considered.




        Benefit: The EFM32 family also offers MCU fundamentals that make energy management simple. 


        • Autonomous Peripherals: Circuits outside of the microcontroller which can perform complex operations on their own while the main processor core remains in sleep mode. Learn more
        • Energy-Aware Profiler: An energy debugging tool that uses energy monitoring data from advanced development tools for real-time profiling and debugging of firmware. Learn more
        •  Energy Mode: Operating condition that balances effective circuit operation with the lowest possible energy usage. EFM32 offers five energy modes: Run, Sleep, Deep Sleep, Stop and Shutoff. Learn more

        • Simplicity Studio™: A suite of software and documentation tools for automatic code creation, debugging and power profiling, enabling designers to easily capitalize on IoT and embedded design challenges. Learn more


        Figure: Wearable block diagram featuring EFM32


        Learn more about the energy-friendly EFM32 microcontrollers at

      • IoT World (CA)

        Nari | 04/117/2015 | 11:17 AM




        Booth #155

        Moscone Center - San Francisco, CA


        Date: May 12-13, 2015


        Keynote Session:

        Engineering the IoT

        05/12/15 (12:45 PM), Ecosystem Center Stage (3rd floor - Moscone West)

        James Stansberry, Senior Vice President and General Manager, Internet of Things (IoT) products


        Panel Session:

        Assessing developments in the Energy market and Smart Grid technology

        05/13/15 (12:10), BayShore West

        Speaker: Dave Egan, Senior Product Manager



      • IoT DevCon (CA)

        Siliconlabs | 04/117/2015 | 09:42 AM

        IoT DevCon.png


        Hyatt Regency – Santa Clara, CA  


        Date: May 6th – 7th, 2015 


        Speaking Session:

        05/07/15 (15:45-16:10), Cypress Room

        ME1328:  Network Performance, Reliability and Metrics for Embedded IP Mesh Networks

        Millions of devices have been deployed on IEEE 802.15.4 networks, which use a variety of protocols ranging from proprietary point-to-point to ZigBee and now IP-based mesh networking stacks (Thread). When developing connected device products for 802.15.4 networks, it is important to understand expected device and network behaviors. In wireless mesh networks, device efficiency impacts the behavior of all interacting devices.

        Learn more


        Panel Session:

        05/07/15 (13:45-14:10), BayShore West

        ME1429:  Meeting the Battery-Life Requirements for Your IoT Edge Node Product

        An edge node, the 'thing' of the IoT, can be described by four features: 1) the transducer; 2) the interfaces connecting the transducers and microcontroller; 3) the processing (e.g. encryption, compression, protocol stack, data analysis); and 4) communication mechanism used to send/receive information between the thing and the network. When designing your edge node device, battery-life might be one of the most important factors, but how do you reliably determine the combined energy consumption of the entire platform?

        Learn more



      • Building an Empty Project and Simplicity Studio IDE

        lynchtron | 04/114/2015 | 08:38 AM

        Maker's Guide Ch 2

        Welcome back to part two of Chapter Two. If you'd like to join in from the beginning, visit the Maker's Guide home page. In this lesson, we are going to get your Simplicity Studio Integrated Development Environment (IDE) setup. This lesson has a lot of background information but the real hands-on lessons will start in the next lesson.


        I think you're going to be pleasantly surprised how easy it is to work in the Simplicity Studio environment. The first thing you need to do is download the Simplicity Studio IDE from this link:


        Simplicity Studio Integrated Developer Environment (IDE)

        When you first launch Simplicity Studio, you are presented with a wealth of information.  Consider yourself very lucky that you have stumbled upon this tool.  Historically, this information was particularly hard to find for MCUs. 



        Simplicity Studio Launch View


        Let’s start exploring this tool at the top left.  The first thing to do is enter in a part number that you are using, or considering using.  It will give you suggestions as you type, so just start typing “EFM32” and then pick one.  Alternatively, if you already have a Starter Kit attached to your computer, you can click on “Detect Connected Device…”  All of the specifics for your particular part number are detailed, and there are even buttons there to Buy/Sample that exact device.


        You can open the Reference Manual or Data Sheet PDF files for that particular processor by clicking buttons under the Buy/Sample buttons.  This is very helpful to me because it is quicker than navigating my file system to find a PDF file. 


        The Reference Manual contains information that pertains to all EFM32 models within a particular family (i.e. the Leopard family is shown above.)  The Reference Manual details all of the features supported by that family, including hardware configuration registers.  Therefore, some features detailed in the reference manual may not exist in your exact specified part.  You will need to check the selection guide above or the Data Sheet, explained below.


        The Data Sheet contains information that only pertains to the specific part number entered in the Product field.  The Data Sheet details the exact features supported, the absolute and typical operating conditions, electrical and thermal specifications, pinout, and package dimensions.


        The Cortex M document is common to all of the models and contains information about the ARM core that resides inside the MCU.  This is where machine instructions are specified.


        During the duration of this course, you will use many of the “tiles” on this welcome screen.  They are incredibly useful and Silicon Labs releases updates and bug fixes often.  You can hover your mouse on each of these tiles to see what they do and then launch the tile if you would like to see it.


        For now, we are going to open the Simplicity IDE tile in the upper left. makersguidech2_2_2.png


        The IDE is the primary tool that you will use to write code for the MCU.  Once you have it open, let’s create a new project and take a look around.


        Select “File -> New -> Silicon Labs MCU Project” from the menu.  A window will pop up that asks for the type of Kit and/or Part that you will be using for the new project.  Select the “Wonder Gecko 3800 Starter Kit” and the Part will be selected automatically.

        Simplicity Studio


        Change the name of the Project to “2_getting_started.”



        Now, you should see a screen like the following:



        In the later lessons, I will explain the purpose for all of these buttons, menus and windows.  For now, let’s build an empty project so that you can see what happens.  In order to do that, you have to click on the code window for empty_project.c.  Just click anywhere in that window and the build icon (which looks like a little hammer) will become selectable.  Click that and then watch the Console window at the bottom.makersguidech2_2_6.png


        You will see a popup window as it builds:



        If all went well, your Console window should look like this:


        So, how did it go?  Did you get this “Build Finished” line?  I surely hope so, since all we are doing is building an empty project. 


        If the build went smoothly -- as I expect it will for most people -- congratulations!  You are ready to begin development with your Starter Kit!  Believe it or not, it wasn’t always this easy.  There are war stories form the “days of old” where getting a new “toolchain” to compile an empty project was quite an accomplishment.  But you just did it without editing a single “Makefile” or typing a single line on a command line.  Lucky you!


        If you are an established software programmer, or just like pain, you can of course build targets for the EFM32 family using a Makefile and the command line.  You can just use vim or emacs and bypass all of the Simplicity IDE programming functionality if you prefer.


        In the next lesson, we will start writing code and running our first program, which is usually the first program that embedded programmers write: Blinking an LED, the “Hello World” of embedded programming.



      • What Could You Make with a 2 X 2 mm Temperature and Humidity Sensor?

        lethawicker | 04/112/2015 | 02:45 PM

        With the Your IoT Contest continuing merrily along, we present the latest in our series on great products that can help you innovate and come up with the next big IoT idea. This time, we’re talking about the Si7034 Temperature and Relative Humidity Sensor, a tiny sensor component coming in at a minuscule 2 X 2 mm.

        This sensor combines fully factory-calibrated humidity and temperature sensor elements with an analog to digital converter, signal processing and an I2C host interface. The low-K polymer dielectrics provides both accuracy and long term stability, along with low drift and low hysteresis. The innovative CMOS design also offers the lowest power consumption in the industry for a relative humidity and temperature sensor.


        The Si7034 comes from the factory fully calibrated, meaning that you don’t need to do any calibration during PCB assembly. With full factory calibration, all Si70xx devices require no addition RH/temperature calibration during PCB assembly. The voltage is in the 1.67 V to 1.98 V range that’s become so popular among wearable and other consumer devices.


        So let’s see…tiny form factor, pre-calibrated, accurate and stable with the lowest power consumption in the industry. Any ideas yet? Get your hands on an evaluation kit and ideas are sure to follow.


        Why not get started today? You could win $10,000 in Silicon Labs components to bring your idea to reality.


        Previous Kit how-to’s:

      • It’s Your IoT—Dream Big and Win $10,000 in Components

        lethawicker | 04/111/2015 | 05:34 PM

        Everyone is talking about the Internet of Things; so much so that developers might be tempted to think that it’s a trend that’s already run its course. What we don’t see from inside our bubble is that the hype cycle is still in its infancy in the consumer world. Only a tiny fraction of homes have internet-connected thermostats or home automation technology. We’ve barely scratched the surface of “wrist-top” platform possibilities, and we've seen enough recently to realize that the IoT is really an endless concept.


        In short, this is the perfect time for you to jump on the IoT bandwagon, and we’re offering you the ideal opportunity—the Your IoT | Connected World Contest. All you need is an idea and a little time to put it all together, and you could win $10,000 worth of Silicon Labs components to kick start your product development. You need more incentive? We’re giving away three of these prizes.



        IoT Inspiration

        If you’re not sure where to start, never fear. Silicon Labs offers a wide array of starter and development kits that you can tinker with. We’ve summarized a couple of them here:


        You can also find starter kits for 32-bit MCUs, 8-bit MCUs, Wireless MCUs, and much more at our website.


        Check out the Competition

        Have you ever thought of IoT action figures? Propane tank gauges? Boat lifts? Our entrants did! Here are the projects that have been submitted so far:


         Project Name

        Short Description
        DEV Energy Meter DEV Energy Meter is an end-to-end IoT solution created to make the job of energy managers of buildings easier.
        Eco Action Sensors The project is to create an environmental “action figure” with sensors and microcontrollers that will encourage students to engage in scientific experiments, discovery, and quality of life investigations: to develop a product that can transform students into “citizen scientists.”
        Safire ZORE is developing Safire: a unique, universal add-on that will save lives by preventing unauthorised use of a weapon. Safire is a patented "smart cartridge case" that is inserted into a firearm. A gun owner can then lock and monitor his weapon using the secure Safire smartphone app.
        An endlessly customizable smart device to solve problems The device collects ambient energy from a multitude of sources. (radio may be a bit of a stretch!) It adjusts its energy intake to collect and analyze important information as efficiently as possible. Harvesting modules and sensors can be selected specifically for intended applications or projects.
        The ProReg The ProReg is a concept and prototype for a disruptive manner of monitoring consumption of pressurized fuel systems. The industry standard for measuring fuel levels today is to measure weight with a scale.
        WaveLift Wireless This is a boat / jetski lift controller operating from front panel controls, wireless remote (315, 418, 434MHz), and BlueTooth. It uses reluctance based limit switches and has a depth sensor as well as water temp, usage log, light control, time of day lockout, etc.


        These are some fantastic ideas, but we want to see more! And don’t forget, even if you’re not going to enter, you can go vote for your favorite project and propel it into the finalist category.


        The deadline is July 17, 2015, so you have time—with $10,000 in components as the prize, what are you waiting for?

      • MCUs vs Computers and Which EFM32 MCU Is Right for Your Project

        lynchtron | 04/110/2015 | 05:50 AM

        Maker's Guide Ch 2

        Welcome back to Chapter Two of the series that will teach you how to program an embedded MCU from the ground up!


        Microcontroller (MCU) Differences vs. Computers

        All computing devices have at their heart a little “calculator” that crunches numbers.  At the most fundamental level that is all it does.  A processor “core” as they are called is really nothing more than a machine that gobbles up numbers (interpreted as instructions) and spits out other numbers, which are the results of those instructions.  It doesn’t matter if we are discussing the world’s most powerful servers or the tiniest of gadgets.  All computers are the same in this regard.


        The key differences between the most powerful computer processors and small MCUs are generally:

        • the types of instructions that are supported,
        • the speed at which those instructions are processed, or the clocking rate,
        • the bit-width of the instructions that can be generally handled at one time,
        • the number of bundled processor cores (to work in parallel) and
        • the support circuitry around the core(s) that accelerates the rate at which instructions are processed.

         MCU vs Computer

        Computer versus Microcontroller


        Therefore, big servers that run the Internet are likely to be clocked up to several GHz, with lots of hardware-accelerated 64-bit wide instructions that run on at least four cores and surrounded by large caches, which are reservoirs of fast local memory and other hardware acceleration circuitry.  That takes a lot of energy, but these are servers that are connected with a power cord to an AC outlet, so they can afford to do all of that.  MCUs on the other hand often run on battery power and need to consume as little energy as possible, with as low a clocking rate as possible (since it saves power), running only a handful of instructions that can be as small as 8-bits wide on a single core.  The aim of an embedded MCU is to do as much as possible with as few resources as possible.  This also makes the MCU cheap enough to be placed into nearly disposable gadgets.


        A key point however, is that the MCU is no different at the most fundamental level from the standard desktop computer or web server that you may already have had some experience programming in the past.  They both have a very similar number cruncher at their heart, but with different set of peripherals surrounding them.  Therefore, any skills you might already have in programming regular old computers will help you learn how to program embedded devices.  Does that make you feel better?


        However, while all mobile/desktop/server computers a standard set of resources available to programmers like hard drives, displays, and network access, the MCU world is much different.  There are severe resource constraints in most situations, with lots of specialization between manufacturers and models.  You must choose your MCU carefully so as not to waste money or energy while trying to solve your particular embedded task.  And you must be very careful about how you use your available resources.  I’ll help you with that.


        In addition, all mobile/desktop/server computers ship with an Operating System (OS) that helps programmers write, store, and execute source code, as well as optimizing the vast resources of the machine.  If things go awry, the OS is there to save the day to inform the programmer that something has gone wrong.  An OS is great to have, but it consumes a lot of those precious resources in order to exist, and this is sometimes too much power to bring to your appropriate MCU solution.  While there are specialized “real time” OSes available for MCU’s called “RTOS” and a whole dedicate following for them, many embedded solutions don’t require that overhead or justify the expense to run them.


        About the EFM32 Family of MCUs

        The EFM32 family of MCUs that were chosen for this course are 32-bit cores. In general, this means that 32-bits of information can be processed at once.  There are MCUs that operate at 8- or 16-bits and as such, less data can be “gobbled up” by the MCU at one time.  Processing more bits at once can speed up the execution time of the program. 


        The type of processing core in the EFM32 family is an ARM Cortex M0+,  M3 or M4 (depending on the EFM32 model) licensed from a company called ARM.  These ARM cores are very popular in the mobile device market, and licensed by thousands of companies.  The ARM core accepts machine instructions that are in the Thumb format.  However, from a programmer’s perspective, the type of instruction format is usually not too important because software programming is usually written in a higher level language and the compiler takes care of translating the higher level language into machine instructions.  This process will be covered in the next lesson.


        MCU Bare Minimum

        MCU Bare Minimum Components


        But the MCU is much more than just an ARM core.  In order to use the core at a bare minimum, an MCU needs some non-volatile memory (memory that keeps its programming when the power is removed, typically flash memory) to store the software instructions, some Random Access Memory (RAM) to store the results of those instructions and some input/output pins to accept the program instructions and communicate the results of those instructions to the outside world.  While the ARM core itself is licensed from a single company, the rest of the blocks on the MCU can be sourced from other vendors or custom-built by the semiconductor company that produces the MCU.


        Once we have a bare minimum MCU, we could use it to embed our programs inside of electronic gadgets of all kinds.  The programmer would have to work within the limitations of this bare-bones MCU, but it would work perfectly fine for some applications.  Within the EFM32 family of MCUs however, the programmer has many more options.  In order to make a more powerful and energy-friendly MCU, Silicon Labs has included a number of onboard hardware accelerator blocks (called peripherals) that automatically perform many tasks that would otherwise be cumbersome or time consuming to program strictly in software. 


        Which EFM32 is Right for Your Project?

        The good news is that you don’t have to decide this right away.  The Wonder Gecko Starter Kit is nearly the fully-loaded model so you can learn about all of the features that the EFM32 family offers.  Once you learn how to use the MCU, you can choose a different model and port your software to that model easily.


        This will get you started in making the decision.  The EFM32 family has six basic models and each model has a variety of options regarding RAM, flash, and pin count.  The models are Zero Gecko, Tiny Gecko, Gecko, Leopard Gecko, Giant Gecko and Wonder Gecko.  A very detailed (and awesome!) breakdown of the different models can be found here:




      • Webinar Recap: What's New in Simplicity Studio

        Nari | 04/107/2015 | 09:26 AM

        Missed our latest Simplicity Studio webinar? Fret not! Here’s a recap for you.


        The webinar gives a quick introduction to Simplicity Studio for those who are new to the platform or just need a refresher. So what is Simplicity Studio? Fundamentally, it’s a window into Silicon Labs’ MCUs and Wireless solutions. It is a one-stop-shop development solution that allows you to get from idea to product faster using precompiled demos, application notes, and project examples.




        Meeting MCU and wireless development challenges can be extremely difficult, especially when dealing with tight development schedules. To start a new project, one normally has to select the right MCU or radio for the application, learn about the selected device by reading documentation, reviewing training material, or watching tutorial videos, find sample code and projects to jumpstart the development process, learn how to use the specific software tools, download the latest user guide and get technical support when stuck.


        Most of these are found on different platforms, websites, installers, and tools that make keeping track of everything difficult and inefficient. Simplicity Studio provides three major solutions for these problems as below:




        First, Simplicity Studio allows for concurrent development of MCU and wireless projects, fixing fractured tool chains. The Simplicity IDE is a fully integrated tool chain. It is an Eclipse-based IDE supporting Keil®, IAR®, and GCC build tools. The Eclipse-platform enables support for additional Eclipse plugins as well. To improve performance during debug, the Simplicity IDE uses the Eclipse Debugger for C/C++ (or EDC) instead of the GNU debugger (or GDB). It also includes integration with Keil µVision or IAR Embedded Workbench. For 8-bit MCU development, Silicon Labs provides the leading 8051 toolset, Keil PK51 development tools, for free.




        Second, unique and differentiated tools like Energy Profiler and Configurator  are examples of optimization tools that reduce risk and complexity and get you from idea to product faster. 


        The Energy Profiler makes energy debugging simple by analyzing current consumption in real-time. It quickly identify areas of code that draw the most current and maps graphical output to lines of code. Clicking on an area on the graph will highlight the specific line of code executed during that point in time. Another nice feature is the bar graph identifying the energy consumption of each function.


        Watch the Energy Profiler in action: 


        The Simplicity Configurator helps manage pin assignments easily & resolve pin conflicts automatically to save development time. It graphically configures Wireless, 32-bit and 8-bit MCUs, automatically generates C-code and creates a complete application using mode transitions. It has built-in intelligence for error checking and calculators to simplify settings. Also includes a Configurator project file for each code example.




        Finally, find what you need when you need it – it’s all in one place. No more searching for datasheet updates, code examples, and other time consuming development tasks. Simplicity Studio gives you instant access to the latest software, documentation, tools, support and resources in one place, all free of charge.




        In late February 2015, we released the newest version of Simplicity Studio. The latest release includes support for Silicon Labs IoT Products and several new design optimization tools, like the Network analyzer and the Appbuilder. So, what’s new in Simplicity Studio 3.0?


        Microcontrollers and Wireless & RF

        One of the newest products to be supported in Simplicity Studio is the new energy-friendly EFM8 MCUs based on the popular 8051 core. These devices are ideal for IoT systems processing data that comes from port I/O or sensor inputs. Simplicity Studio also gives you powerful choices when it comes to developing with EZR32 Wireless MCUs. The new EZR32 wireless MCUs deliver best-in-class power efficiency and sub-GHz RF performance which makes them ideal for any application requiring longer battery life, increased wireless range and small form factor. The Connect software stack within Simplicity Studio will provide a complete sub-GHz networking stack for building simple point-to-point and star networks. This can take care of all content, development, and optimization needs.


        Network Analyzer

        This is a packet tracer and network analysis tool that can examine live or previously captured network traffic in detail. It includes API tracing, a virtual UART and provides network-aware energy debugging to get the most robust networks and the smallest batteries. When used together with the Simplicity Energy Profiler, phenomenally energy-friendly designs can be created in a fraction of the time.


        Watch a video to learn more about the Network Analyzer: 



        The AppBuilder is a graphical tool with an embedded software framework and scenario templates for rapid development. New projects can be started based on an existing framework of best-practices developed and tested by Silicon Labs. The framework sits on top of the wireless networking stack to interface with the Hardware Abstraction Layer (HAL) and provide application layer functionality such as startup routines and high-level APIs for creating and handling message payloads. It is also the fastest way to create certified products using ZigBee standard public application profiles—a feature that’s coming soon!


        Watch a video about the AppBuilder: 


        Visit the Simplicity Studio Forum for questions and answers, training videos and development resources including sample project ideas.


        Install Simplicity Studio for free at! Available for Windows, Mac, and Linux with 5 installation options and a custom option.

      • Video review of the EFM8 8-bit MCU family by David Jones on EEVblog

        Nari | 04/105/2015 | 01:12 PM

        David Jones, an electronic design engineer and a video blogger hosting, opened his mailbag and found three EFM8 Bee family development kits: EFM8 Universal Bee starter kit (STK), EFM8 Sleepy Bee STK, and EFM8 Busy Bee STK.  


        (The review starts at 22m 40s mark)  


        EFM8 Universal Bee:

        David said that “Check out the resolution on the LCD. Very nice indeed. Driving graphics on the Sharp Memory LCD is pretty impressive.” while playing the Space Invader demo on the Universal Bee STK.




        EFM8 Sleepy Bee:

        The Sleepy Bee is ideal for low power and battery powered systems and include up to 14 high-quality capacitive sense channels.


        “If you’re developing ultra-low power applications with touch, you have to get this demo board. If you want something with a powerful USB Host interface, you probably need the Universal Bee chip,” said David.




        EFM8 Busy Bee:

        As David mentioned, the Busy Bee chip looks significantly different from other EFM8 Bee chips as it is designed to integrate advanced analog and communication peripherals into small packages, making them ideal for space constrained applications.




         “These things do compete in a crowd 8-bit microcontroller space but 150 μA/MHz power consumption is pretty good. If your system requirement is low power and if you don’t need a 32-bit, then they’re probably worth looking at. And these things are very nicely priced, 30 bucks a pop.” David concluded.