Official Blog of Silicon Labs

      • Employee Spotlight - Randy Ferguson

        Anna Hogan | 06/166/2018 | 12:27 PM

        Randy Ferguson joined the Silicon Labs IT team in November 2015 as a desktop support analyst. In his current role as IT service delivery manager, Randy is able to engage with members in all departments, because he and his team are often the first point of contact for company-wide IT support. His responsibilities range from maintaining equipment and infrastructure for day-to-day internal operations, to providing web platform updates affecting external customers. Because of this, Randy said his team has a “unique point of view on the operations of the whole company.” He continued, “we all know that every department is integral to the overall success of Silicon Labs, but working in IT, you really experience it first-hand."




        Working in IT also gives Randy the opportunity to see the value of a strong team culture. “Every member of the team is treated like an equal contributor to what we do,” he said. “I’ve always felt that I have the freedom to tackle any task I'm confronted with in the way that suites me best. Being able to trust and rely on your peers’ and leaders’ strengths and cover each other’s weaknesses is something that's hard to come by in my experience.”


        “If you haven't met us in person, you might be surprised to find out just how sociable and likeable we can be! That said, we do fly our nerd flags high and proud.” He continued, “We do have a pretty rockin' team in IT, if I say so myself.”


        We’re glad to have a rockin’ guy like you on the team, Randy Ferguson. Fly your nerd flag high and keep up the great work!


      • New Sub-GHz and BLE Solution Simplifies Industrial IoT

        Lance Looper | 06/164/2018 | 01:32 PM

        This week, we’ve introduced a Wireless Gecko software solution created to simplify industrial and commercial IoT applications using sub-GHz wireless connections by adding Bluetooth connectivity. The new hardware and software solution enables simultaneous sub-GHz and 2.4 GHz Bluetooth low energy connectivity for commercial and industrial IoT applications, such as smart metering, home and building automation, and commercial lighting.

        This is important for the industrial and commercial sectors for several reasons – for one, it’ll make it much easier for people working in these environments to set-up, control, and monitor sub-GHz IoT devices using Bluetooth low energy mobile apps.

        Sub-GHz wireless protocols are used extensively in industrial and commercial settings because many of them require a combination of energy efficiency, long battery life, and extended range for remote sensor nodes. Proprietary sub-GHz protocols allow developers to optimize their wireless solution to their specific needs instead of conforming to a standard that might put additional constraints on network implementation. With our new software solution, sub-GHz protocols can still be utilized for their benefits, but users can also easily manage the system using Bluetooth mobile apps on a variety of devices, such as tablets or smart phones.

        Sub-GHz environments are typically low-data-rate systems, such as simple point-to-point connections to large mesh networks and low-power wide area networks (LPWAN). By adding Bluetooth with low energy connectivity to wireless networks in the sub-GHz band, developers can deliver new capabilities such as faster over-the-air (OTA) updates and deploy scalable, location-based service infrastructure with Bluetooth beacons.


        Single Chip Reduces Cost by 40 Percent

        IoT developers stand to gain tremendous development benefits by avoiding the complexity of two-chip wireless architectures. By using a single chip with both sub-GHz and BLE connectivity, developers can simplify hardware and software development, which can speed time-to-market and reduce bill-of-materials (BOM) cost and size by up to 40 percent.

        Accenture estimates industrial IoT could add $14.2 trillion to the global economy by 2030, making the deployment potential of this solution especially massive. Any new technology developments such as this one that helps developers control and monitor industrial and commercial devices and data more easily leads to efficiency and economic gains for both businesses and the users.

        Mobile control applications are often a crucial piece of industrial and commercial automation, giving system operators a quick and easy way to control equipment. For instance, commercial lighting depends heavily on mobile devices, which control lighting on/off schedules, energy efficient modes and rules, and dimming based on occupancy using ambient light sensors. Often times, the mobile app may be the only control interface installers, designers and site managers have for project commissioning and configuration.

        Bluetooth connectivity allows the device apps and interface to be simple, which can make a difference in user adoption, as many lighting and commercial controls can be complex and difficult to manage.

        Our new solution will clearly yield impressive benefits for both developers and the users of the industrial applications. Fortunately, the new multiprotocol software is now available using Silicon Labs’ EFR32MG and EFR32BG Wireless Gecko SoCs. Check out more details here if you’re working on a product that could benefit from the solution.


      • Adding Micrium OS on a Flex Gecko

        Janos Magasrevy | 06/159/2018 | 06:05 PM

        This blog should serve as a guide to adding Micrium OS on a Flex Gecko and get at least one task running on the device.

        I will now share with you my experience while going through this exercise.

        Getting Started

        I decided to perform a clean installation of Simplicity Studio in order to avoid conflicts inflicted by software updates over time. After installing the tool, before even attempting to add anything, I first had to make sure that I had the necessary SDKs. Here's what I installed:

        • 32-bit MCU SDK -
        • Micrium OS - 5.4.0
        • Flex SDK -

        I then mounted a Flex Gecko, EFR32FG12 in my case, onto a Wireless Started Kit Mainboard (BRD4001A). After that, I connected it to the PC using the provided USB cable.

        Simplicity Studio recognized a Flex Gecko connected to a WSTK and displayed the link to examples from the Flex SDK (see Figure 1).

        Figure 1 - Initial Setup Validation


        Loading a Basic Flex SDK Example

        As a starting point, I decided to go with the "RAIL: Simple RAIL without HAL" example from the Flex SDK.

        You can find this by expanding the list of projects under the "Silicon Labs Flex SDK Examples" link:

        Figure 2 - Flex SDK Examples Link


        Then find and click the example shown in Figure 3 to add it to your workspace:

        Figure 3 - RAIL: Simple RAIL without HAL Example


        After the example loads on your workspace, you might get a notice as shown in Figure 4. Just click "OK".

        Figure 4 - Auto upgrade notice


        You will then be presented with simple_rail_without_hal.isc opened where you can configure RAIL. In my case, I left everything in its default values and simply clicked on "Generate" as shown in Figure 5.

        Figure 5 - RAIL Project Configuration


        At this point, you should now be set with a basic Flex Gecko example that builds and runs. However, I did find that the default project settings have compiler optimization set to "Optimize for size (-Os)" which will eventually make debugging the project rather difficult. Therefore, I switched optimizations to "None (-O0)".

        Figure 6 - Compiler Optimizations


        Adding Micrium OS to the Workspace

        Now that you have a basic Flex Gecko example that builds and runs, let's go ahead and start adding the Micrium OS source files into the workspace.

        First, locate the Micrium OS directory, it should be in:



        Now drag and drop the "micrium_os" folder into your project (simple_rail_without_hal) in Simplicity Studio. When doing this, make sure that you have "Copy files and folders" selected before clicking "OK" as shown in Figure 7.

        Figure 7 - Adding Micrium OS Folder to Project


        You will then have to remove all the unnecessary files that get added with Micrium OS (this was tedious).

        Here's how your "micrium_os" folder should end up looking:

        Figure 8 - Micrium OS Necessary Files


        Finally, the compiler needs to know where to look for the header files so we have to add two compiler include paths to the project settings:

        Figure 9 - Micrium OS Compiler Include Paths


        Configuring Micrium OS

        Now that you have Micrium OS as part of your project, let's go ahead and make some minor adjustments to the default Micrium OS configuration.

        1. Open rtos_description.h located in your project under "micrium_os/cfg/"
        2. Replace the contents of the file with one below:
        *                                             EXAMPLE CODE
        * Licensing:
        *   The licensor of this EXAMPLE CODE is Silicon Laboratories Inc.
        *   Silicon Laboratories Inc. grants you a personal, worldwide, royalty-free, fully paid-up license to
        *   use, copy, modify and distribute the EXAMPLE CODE software, or portions thereof, in any of your
        *   products.
        *   Your use of this EXAMPLE CODE is at your own risk. This EXAMPLE CODE does not come with any
        *   warranties, and the licensor disclaims all implied warranties concerning performance, accuracy,
        *   non-infringement, merchantability and fitness for your application.
        *   The EXAMPLE CODE is provided "AS IS" and does not come with any support.
        *   You can find user manuals, API references, release notes and more at:
        *   You can contact us at:
        *                                           RTOS DESCRIPTION
        *                                      CONFIGURATION TEMPLATE FILE
        * File : rtos_description.h
        *                                               MODULE
        #ifndef  _RTOS_DESCRIPTION_H_
        #define  _RTOS_DESCRIPTION_H_
        *                                             INCLUDE FILES
        #include  <common/include/rtos_opt_def.h>
        *                                       ENVIRONMENT DESCRIPTION
        #define  RTOS_CPU_SEL                                       RTOS_CPU_SEL_ARM_V7_M
        #define  RTOS_TOOLCHAIN_SEL                                 RTOS_TOOLCHAIN_GNU
        #define  RTOS_INT_CONTROLLER_SEL                            RTOS_INT_CONTROLLER_ARMV7_M
        *                                       RTOS MODULES DESCRIPTION
                                                                        /* ---------------------- KERNEL ---------------------- */
        *                                             MODULE END
        #endif                                                          /* End of rtos_description.h module include.            */


        Modifying main.c

        We'll be making modifications to the default main.c generated by the "RAIL: Simple RAIL without HAL" example.

        Micrium OS requires the following include paths in main.c so go ahead and add them as shown below:

        #include  <cpu/include/cpu.h>
        #include  <kernel/include/os.h>
        #include  <common/include/common.h>
        #include  <common/include/rtos_utils.h>
        #include  <common/source/kal/kal_priv.h>  /* Private file, use should be limited */


        We'll be modifying main.c to initialize Micrium OS and create a start task. For that, you'll need to specify a task stack size and a priority. We typically do this by defining them as constants and passing those in the call to OSTaskCreate().

        The start task also requires its own Stack and Task Control Block (OS_TCB) as well as its function prototype. Therefore, add the following to main.c:

        #define  START_TASK_PRIO              21u
        #define  START_TASK_STK_SIZE         512u
        static  CPU_STK  StartTaskStk[START_TASK_STK_SIZE];  /* Start Task Stack. */
        static  OS_TCB   StartTaskTCB;                       /* Start Task TCB.   */
        static  void  StartTask (void  *p_arg);


        Here's the body of the StartTask function where the kernel tick gets initialize and as well as the Common module. Note that the function includes an infinite loop at the end with a time delay of 1 second. This is done to yield CPU time to other tasks that are or will eventually run on your system. You can copy and paste the following in your main.c:

        static  void  StartTask (void  *p_arg)
          RTOS_ERR    err;
          CPU_INT32U  cpu_freq;
          CPU_INT32U  cnts;
          /* Prevent compiler warning. */
          /* Determine SysTick reference freq. */
          cpu_freq =  SystemCoreClockGet();
          /* Cal. SysTick counts between two OS tick interrupts. */
          cnts     = (cpu_freq / (CPU_INT32U)KAL_TickRateGet());
          /* Init uC/OS periodic time src (SysTick). */
          /* Initialize CPU Usage. */
          /* Check error code. */
        #ifdef CPU_CFG_INT_DIS_MEAS_EN
          /* Initialize interrupts disabled measurement. */
          /* Call common module initialization example. */
          while (DEF_ON) {
        	  /* Delay Start Task execution for 1000 OS Ticks from now. */
              OSTimeDly(1000, OS_OPT_TIME_DLY, &err);
              /* Check error code. */


        Finally, let's modify main() to initialize the CPU, re-assign interrupt handlers as kernel-aware, initialize the kernel, create the Start Task, and start the OS. Here's how main() should end up looking:

        int main(void)
          uint32_t vtorAddress = SCB->VTOR;
          CPU_FNCT_VOID * vtor = (CPU_FNCT_VOID *)vtorAddress;
          RTOS_ERR  err;
          /* Re-assign previous interrupt handlers as kernel-aware */
          for (uint32_t i = CPU_INT_EXT0; i < CPU_INT_EXT0 + EXT_IRQ_COUNT; i++) {
            CPU_IntSrcHandlerSetKA(i, vtor[i]);
          /* Initialize the Kernel. */
          /* Check error code. */
          /* Create the Start Task. */
                       "Start Task",
                       (START_TASK_STK_SIZE / 10u),
          /* Check error code. */
          /* Start the kernel. */
          /* Check error code. */
          return (1);


        You are now set to build and run the project. You can put a breakpoint on the Start Task inside the while loop and notice that you'll be hitting that every second (or as specified by the delay you configure in OSTimeDly()).

        Please do understand that this is a very basic guide that resembles more a hack rather than an official solution from Silicon Labs. Hopefully, Micrium OS can be part of the Flex SDK in the future, but in the meantime, this is a start.

        I hope this was useful to you. Feel free to post any comments or questions regarding this blog post.

      • Webinar: Develop Secure, Interoperable Smart Home Devices with Z-Wave

        LeighPankonien | 06/157/2018 | 05:21 PM

        Title: Develop Secure, Interoperable Smart Home Devices with Z-Wave

        Date: July 11 & 12, 2018

        Duration: 1 hour

        Speaker: Johan Pedersen, Product Marketing Manager of Z-Wave

        Topic:  Z-Wave is a popular wireless technology for smart home applications with a large ecosystem of interoperable devices, such as smart lighting, energy monitoring, and home security systems. Consumers benefit from Z-Wave’s ease of use and secure interoperability thanks to mandatory product certification and features including SmartStart plug-and-play installation, Security 2 (S2), and backwards compatibility. Adding Z-Wave connectivity to your product is straightforward due to clearly defined software stacks, published device profiles, pre-certified modules, a finished product certification program and development tools that ensure high-quality products get to market fast.

        In this webinar, we explore how Z-Wave wireless technology enables easy-to-use, secure, and interoperable products for the smart home market.