Skip navigation
> RoadTest Reviews

Silicon Labs Bluetooth Design Kit - Review

Scoring

Product Performed to Expectations: 9
Specifications were sufficient to design with: 7
Demo Software was of good quality: 9
Product was easy to use: 9
Support materials were available: 9
The price to performance ratio was good: 8
TotalScore: 51 / 60
  • RoadTest: Silicon Labs Bluetooth Design Kit
  • Buy Now
  • Evaluation Type: Development Boards & Tools
  • Was everything in the box required?: Yes
  • Comparable Products/Other parts you considered: Bluetooth low energy market is pretty competitive. Here are few mentions:- Nordic's nRF52 series, ST Microelectronics Blue NRG-2 and, TI's SimpleLink products, Cypress EZ-BLE WICED modules etc are comparable with Silicon Labs offering. All the 8 bit micro controllers from Atmel/MIcrochip, TI etc are comparable with the silicon labs 8 bit MCU offerings.
  • What were the biggest problems encountered?: Installing eclipse plugins some times gives a headache. I got it right after couple of iterations.

  • Detailed Review:

    Introduction:

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    The BGX13P creates a Bluetooth 5 compliant BLE cable replacement interface, facilitating a BLE link to a second embedded device ora mobile device.

    An embedded MCU controls the device and communicates across the BLE link through a serial interface and controlsignals. Parameters stored in non-volatile

    memory and configurable through the serial interface adjust performance characteristics of the device.

     

    BGX13P Module featuring:

     

    • Bluetooth 5 radio with +8 programmable output power.
    • 1M, 2M and Coded PHY
    • UART and I2C interfaces.
    • 8 additional pins configurable as I/Os
    • Maximum baud rate : 2Mbaud
    • Maximum throughput : 1000 kbps
    • Integrated Antenna
    • Encrypted bonding and connectivity
    • Integrated DC-DC Converter
    • Onboard Bluetooth stack
    • Centralized OTA through mobile app library

    Dimensions:

     

    Overall dimension of the module: 2.9 ×15.0 × 2.0 mm (W × L × H)

    package dimension : 6.5 mm x 6.5 mm x 1.4 mm

    Pinout:

     

    BGX13P module is a 31 pin packaging. Out of the 31, 12 pins are no connection and 5 pins are power pins (including 4 GND pins).

    BGX13P requires only a single power rail for operation. Which is Pin 29 VDD.

     

    Typical application diagram:

     

    For a typical application one can follow the below mentioned diagram

    In this case the Host CPU can be any micro-controller. MCU communicates to BGX using 8N1 UART bus (8 data bits, No parity bits and 1 stop bit) with flow control(CTS - Clear to Send and RTS - Requests To Send).

    If your solution has pin constraints then you can turn off the flow control. But its always preferred to have flow control on.

    As mentioned above VDD is the only main power required for the whole module. The ratings are given below.

     

    BOOT is an optional pin. It's an active low pin. If you tie the pin to low then it will force the module to boot into the DFU boot loader mode after reset. Boot can left not connected.

    Internally this pin is pulled high.

    Reset pin can be driven from a MCU GPIO. Reset is an active low pin.

     

    Module can be reset in 3 different ways:

     

    * By pulling the reset pin low (reset button provided in the BGX board does this )

    * Using Internal Watchdog timer ( Expiring the watch dog timer can trigger reset)

    * Using Serial command (This option we will cover later this article )

    BGX13P Breakout board offering:

    • BGX13P module
    • 2x LEDs
    • 2x Buttons
    • Reset button
    • 20Pin expansion connection header
    • 16 solderable through holes for almost all the module functional pins. 
    • CP2102N USB to Serial Bridge
    • microUSB port

     

     

    GPIO0 and GPIO1 used for LED0 and LED1 respectively.

    GPIO2 and GPIO3 used for Switch0 and switch1 respectively.

     

    Operation:

     

    BGX13P hosts the Complete Bluetooth5 compatible stack inside the module ( Bluetooth5 is backward compatible with Bluetooth4.2. I will call it as Blueetooth Low Energy or BLE). The BLE ( Bluetooth Low Energy) connection parameters can be written to the internal non volatile memory through a set of commands.

    These commands can be sent either through the Serial bus or from a remote mobile app using the BLE connection.

     

    Since the whole Bluetooth5 compatible stack is hosted inside the module the host MCU doesn't need to worry much about the heavy lifting of the BLE stack. MCUs or Any Serially connected device can communicate to the

    BGX13P module using a set of commands.

     

    BGX13P has 3 main mode of operations.

     

     

    • Local COMMAND mode - Bluetooth Xpress commands are issued via the serial UART interface
    • STREAM mode - data is transferred directly between the serial UART interface and the wireless BLE interface
    • remote COMMAND mode - Bluetooth Xpress module commands are issued via the wireless BLE interface (the local COMMAND interface is disabled).

     

    Lets take a look at these in detail

    Local COMMAND mode:

        As I mentioned earlier the BGX13P hosts the Bluetooth5 compatible stack inside. So any update to the BLE parameters should happen through a set of commands. Silicon labs has defined a set of commands to communicates to the BGX Module.

    Example:

    "adv" for advertise in peripheral mode.

    "get" and "set" for getting and setting the internal variables respectively.

    "scan" for scanning the nearby peripherals ( In Central Mode)

    "con" for connecting to a peripheral (In Central Mode)

     

    Full list of commands will be found here: https://docs.silabs.com/bgx/latest/cmd/commands

     

    When the Local COMMAND mode is selected, commands can be passed from the host MCU though UART. This will be parsed and executed by BGX13P module. Each command should be followed by a CR ( "\n") character.

    Local COMMAND mode can be enabled by sending a breakout command ("$$$" or "-breakout $$$") from streaming mode. (Note: If you care in streaming mode breakout command should be send without CR "\n") or

    by setting up the str_select variable. "str_select" variable will help users to select GPIO functions to enter and exit from these modes.

     

    STREAM mode:

       In stream mode there is no connection to BGX13 command parser. Whatever character you send from the host device will straight away goes to air.

    Send a breakout command ( a special command compared to other commands) to exit from this mode to command mode.

     

    Remote COMMAND mode:

      Remote COMMAND mode is similar to Local COMMAND modes. All the commands are valid here. But the commands are send from a BLE connected device which utilizes the BGX  Xpress Streaming Service.

    Mode Selection:

    The above mentioned modes can be selected using two methods.

    • Automatic Mode selection ( By Default )
    • Manual Mode selection

     

    In Automatic Mode selection:

    Upon boot module goes to Local COMMAND mode. Enter streaming mode by sending command "str". Issue Breakout command to jump to COMMAND mode again.

    If a BLE device is connected and mode characteristic is changed then modes can be changed from STREAM mode to COMMAND mode and back.

     

     

    In Manual Mode selection:

    • boot the module with the bu i (bus mode initialization) variable set to command ( For boot with COMMAND mode )
    • boot the module with the bu i (bus mode initialization) variable set to stream ( For boot with STREAM mode )
    • assert/toggle the mode_sel GPIO

     

     

    Variables in BGX13P modules:

       I was mentioning about setting and getting variables in the previous sections. Lets look at what are the variables available in BGX13P.

    To control somewhat complicated BLE stack, few commands are not enough. Commands covers most part of the operation, But each operation needs more information to perform.

    For example lets take Bluetooth Advertising: Bluetooth stack provides options to manage advertising like what is the interval of advertising and what are the parameters passed while advertising. Is it a connectable advertise etc.

    To set all these parameters BGX13P uses variables.

     

    There are 45 variables available for you to tweak. They are categorized into:

     

    • All variables ( for listing all the variables)
    • BLE Peripheral Variables ( for tweaking BLE related parameters)
    • BUS ( For controlling and maintaining bus modes)https://docs.silabs.com/bgx/latest/cmd/variables#sy-i-s
    • BLE Central ( for tweaking parameters when module is set as BLE Central)
    • GPIO  (For managing GPIOs)
    • SYSTEM ( System specific variables)
    • TEST ( test specific variables)
    • UART ( For tweaking the UART parameters such as BAUD and Flow Control)

     

    Full list and details of variables are found here: https://docs.silabs.com/bgx/latest/cmd/variables#sy-i-s

     

    Two variations of BLE communication possible ( BLE peripheral and BLE central modes ):

     

    The BGX13P family facilitates two types of BLE communication links:

    • BGX-to-mobile
    • BGX-to-BGX

     

    In the BGX-to-mobile communication use case, the BGX13P operates as a peripheral that is discoverable and connectable when con-figured to that state through either

    the command API or the pin states driven by the embedded MCU.  Using the Xpress mobile library,mobile applications can scan for BGX13P devices, connect,

    and communicate with the device in both streaming and remote command modes, where the mobile app can execute command API functions remotely.

     

    In the BGX-to-BGX communication use case, one BGX13P must be configured as the central and one or more other BGX devices should be configured as a peripheral.

    Devices can be configured at runtime through the command API, or those settings  can be savedto non-volatile memory so that each device wakes from power-on or

    low power states as either a peripheral or central.

    Enough of theory Lets get into some hands-on:

     

    BGX13P breakout board standalone use case:

     

    Requirements:

    • 1x BGX13P Breakout board.
    • 1 micro USB cable.
    • XpressConfigurator from Simplicity studio ( IDE for development )
    • BGXCommander Mobile App

     

    Installing Simplicity Studio:

        As the first step of the development and testing lets install the recommended IDE for any silicon labs products. It's called Simplicity Studio. ( Note: I am using Ubuntu 18.04 Linux as my development PC, So all the steps described here are for Linux setup. MAC users will have almost similar steps. Windows users may have to refer to the manual)

     

    Simplicity studio is the Integrated development Environment for Silicon Labs products. Simplicity Studio simplifies the IoT development process with one-click access to everything developers need to

    complete their projects using an integrated  development environment (IDE) based on Eclipse 4.5. Simplicity Studio includes  a powerful suite of tools for energy profiling, configuration and wireless

    network analysis, as well as demos, software examples, complete documentation, technical support and community forums.

     

    Step 1 :

    Get the latest version of Simplicity Studio from here : https://www.silabs.com/products/development-tools/software/simplicity-studio

      Select the appropriate one for your working environment.

     

    Step 2:

    Download and extract the file.

    tar xvf Downloads/SimplicityStudio-v4.tgz
    

    Step 3:

    Read the Readme.txt file before you proceed with anything. Okay it recommends you to update and upgrade the packages

     sudo apt-get update
     sudo apt-get upgrade
    

    Execute the setup shell script

    sudo ./setup.sh
    

    Note: Use sudo ( super user do )

    Wait for few minutes until the installation gets done.

            

    Step 4:

      Before you proceed with running the studio. I would  recommend you to make sure that you have wine (windows environment for Linux systems) installed in your system. For those who don't have wine in your system please follow the lines.

     

    sudo dpkg --add-architecture i386 
    wget -qO - https://dl.winehq.org/wine-builds/winehq.key | sudo apt-key add -
    sudo apt-add-repository 'deb https://dl.winehq.org/wine-builds/ubuntu/ bionic main' 
    sudo add-apt-repository ppa:cybermax-dexter/sdl2-backport
    sudo apt update
    sudo apt install --install-recommends winehq-stable
    

     

    Step 5:

       Run run_studio.sh script to start the studio.

       An eclipse based IDE will open up. Bingo!.

       But you are only half way done. We need to install additional packages to use it for any development.

     

    Step6:

       Install all the additional software packages required.

       This RoadTest kit has came with EFM8 evaluation board. So we need to install supporting SDK for that as well.

       For that select install by product group.

     

    Select EFM8 and related software packages.

     

     

    This is roughly around 4.5GB of download and 12GB of install. So take a break and have a coffee!

     

    Once everything is done the IDE will ask for a restart.

    We are almost there!

     

    After the reboot install the Xpress Configurator for communicating with BGX13P breakout board though usb cable.

     

    Connect your BGX13P board to the computer using a microUSB cable (The cable provided in the package or any).

    The device will be automatically get detected by Simplicity studio. Confirm it by going to Debug Adapters option.

    Click on that and go to the Launcher widnow. You will see Xpress Configurator listed there.

    Click on that and install it.

    Okay now we are all set from the simplicity studio IDE point.

     

    Installing BGXCommander Mobile App:

     

        Now install the BGXCommander in your mobile app. (I am using an android phone. So I have to go to App store and install it)

     

    If your BGX13P module is powered it will start advertising in the BLE peripheral mode and It will be visible in the Commander landing page. Connect to the device and go ahead with a firmware upgrade. ( The firmware inside your BGX13P will be obsolete and It should be upgraded to the latest one)

     

    Now we are all set for testing some functionalities.

    setup:

      Connect the BGX13P Board to your computer using the micro USB cable.

    Open Simplicity Studio and make sure that the board is detected in Debug Adapters section. 

    Open XpressConfigurator and press the connect button in the bottom and select the BGX13P module.


    Testing the COMMAND Mode:

        The board automatically goes into the COMMAND mode by default. Now we can test the commands here.

    Lets start with "ver", This the command to get the version of the firmware inside the module.

     

    Lets look at some of the GPIO commands.

    GFU stands for GPIO function.

    • Controlling the operational state of the BGX by configuring the GPIO(BTN0/1) pin as input:

              • For GPIO 2’s BTN0: gfu 2 str_select

              • For GPIO 3’s BTN1: gfu 3 str_select

    • Displaying BLE connection status by configuring the GPIO(LED0/1) pin as output:

              •For GPIO 0’s LED0: gfu 0 con_status_led

              • For GPIO 1’s LED1: gfu 1 con_status_led

    • Indicating BLE Activity by configuring the GPIO(LED0/1) pin as output with:

              • For GPIO 0’s LED0: gfu 0 str_activity_led

              • For GPIO 1’s LED1: gfu 1 str_activity_led


     

    You will see the orange LED0 blinks.

     

    To access the GPIOs first you need to set the GPIO of interest to stdio mode.

     

    For example:

    SWITCH1 is connected to GPIO2 to control this you need to send command

     

    gfu 2 stdio

     

    Configure the pin as input.

     

    gdi 2 in

     

    Now press the switch and read the value in the GPIO2

    while switch not pressed

    Similarly you can do for all the GPIOs. Lets look at the LED0 example

    To toggle LED0. First deinitialize the GPIO from other modes. by assigning none. Then select it as a stdio pin, then set the direction as ouput with active high. Then control the GPIO values.

     

    gfu 0 none
    gfu 0 stdio
    gdi 0 ohi
    gse 0 0
    gse 0 1
    

     

    Now lets get the BGX13P module to advertise mode (So that other BLE central apps can see them)

    send adv command.

     

    Now open the BGXCommander app in your smart phone and press can button.

    You will see the BGX13P module getting discovered by your smart phone. Click on that and it will take you to the dashboard with two radio buttons and a terminal.

     

     

    Testing the STREAM Mode:

        Make sure that your BGX13P module is connected to the BGXCommander app.

    Now there are two ways of entering into streaming mode.

    1. By selecting the radio button in the app ( This changes the mode characteristics thereby entering into STREAM mode)
    2. By sending the command str

    Once you are in streaming mode then you can send messages back and forth from the module to connected app and vise versa.

     

     

     

    To exit from the STREAM mode to COMMAND mode, you need to send a breakout command.

    This is by sending $$$ or -breakout $$$

    Note: The way BGX Configurator sends the strings is with "\n" character. So even if you send $$$ or -breakout $$$ module is not going to exit from the STREAM mode.

    To solve this issue BGX Configurator gives an additional option for sending a breakout string ( without trailing "\n" character)

    Testing the remote COMMAND Mode:

        remote COMMAND mode is selected from the connected BGXCommander app.

    You can execute pretty much everything we tried on the serial command option.

    BGX13P breakout board communication with an MCU:

         For this RoadTest I have provided with an EFM8 universal bee board to test the BGX13P module. Things get more handy when the host MCU and Module are from the same vendors.

    We already discussed how to setup the Simplicity studio and installed all the required SDKs for EFM8 development mode.

     

    EFM8 is an 8051 based 8 bit micro controller from Silicon Labs.

    Featuring:

    • Pipelined 8-bit C8051 core with 48 MHz maximum operating frequency
    • 5 V tolerant I/O pins
    • Low Energy USB with full- and low-speed support saves 60% of the USB power consumption

     

    • USB charger detect circuit (USB-BCS 1.2 compliant)
    • 12-bit ADC
    • Two analog comparators with internal voltage DAC for reference

     

    • 16-bit timers
    • UARTs, SPI, SMBus/I²C master/slave and I²C slave
    • Priority crossbar for flexible pin mapping

     

    BGX13P module easily connects to the EFM8 Universal Bee board via 20 pin expansion connector.

     

     

    Power-up the board using micro USB cable and use USB mini for connecting the onboard segger debugger to your computer.

    Open the Simplicity Studio and check your EFM8 Universal bee got detected in the Debug Adapters menu.

    Once you click on the debug adapter, It will load all the demos, example projects and documentation required for the particular board (In this case for EFM8 universal Bee)

     

     

    For testing BGX13P we need to select BGX option from the demos.

     

    Load the sample project.

    This project uses the onboard LCD and switches for selecting BLE modes from peripheral to central. Since I don't have another BGX board I cant really try the Central mode. So I will test the peripheral mode example.

    Again in peripheral mode we will test both streaming back and forth from the app and device.

    Lets look at the code briefly.

     

    main function

    void main(void)
    {
      // Initialize the device
      enter_DefaultMode_from_RESET();
      // Board controller disconnected from EFM8 UART pins
      BSP_BC_EN = BSP_BC_DISCONNECTED;
      // Initializes the UART1 peripheral
      STK_DEMO_UART1_init();
      // Resets the BGX board and initializes it's baud rates and GPIOs
      BGX_init();
      // Initialize the commands and stream text used for TX
      STK_TX_init();
      // Initializes demo mode 1) CENTRAL 2) PERIPHERAL
      STK_DEMO_initMode();
      // Initialize LCD Screen
      STK_DISPLAY_init();
      // Clears and resets the buffers and targets Buffer A
      STK_RX_init();
      // Enable all interrupts
      IE_EA = 1;
    
      // Mainloop
      while (true)
      {
        STK_RX_handleRx();
        STK_TX_handleTx();
        PWR_enterIdle();
      }
    }
    

     

    After the board initialization. BGX init starts.

    void BGX_init()
    {
      BGX_reset();
      BGX_setModePin();
      BGX_setConnectionPin();
      BGX_save();
      STK_RX_init();
      BGX_getDeviceName();
      BGX_disableAdvertising();
    }
    

    The board gets reset and GPIO6 is set as the MODE select Pin by sending the following commands.

    void BGX_setModePin()
    {
      Wait(1000);
      BGX_sendCommand("gfu 6 none");
      Wait(500);
      BGX_sendCommand("gfu 6 str_active_n");
    }
    

    save the new configuration by sending save command.

     

    set the Device Name and disable the BGX from advertising.

     

    All BGX Commands are sent with the trailing "\r\0"

    void BGX_sendCommand(char* command)
    {
      DECL_PAGE;
    
      strcpy(commandBuffer, command);
      strcat(commandBuffer, "\r\0");
    
      SET_PAGE(UART1_SFR_PAGE);
      IE_EA = 0;
      UART1_writeBuffer(commandBuffer, strlen(commandBuffer));
      IE_EA = 1;
    
      RESTORE_PAGE;
    }
    

     

    There are two modes for the demo either in Peripheral or in Central mode, This you can select using PB0 or PB1 ( PB : Push button) Respectively.

    Once you enter into say peripheral mode. You can press the switched to send predefined string to a connected device.

    Debug the code and run it on the EFM8 universal bee platform.

     

    Once the device starts executing, You get options for choosing between central and peripheral mode in the LCD.

    Press PB0 to proceed with peripheral mode.

    Now your BGX will start advertising. Open the BGXCommander app and connect to the BGX board.

    press the push button on the EFM8 board to send some strings to the app.

     

    BGX13P Xpress Streaming Service Characteristics:

     


    For those who develop mobile application should have a good understanding of how the BGX BLE profile works. To understand the BLE profile I am using Nordic Connect app and connect the BGX to it while module is advertising.

     

     

    Apart from the mandatory GATT and GAP services

    It has got

    • Device information service
    • 2 unknown services

    Device information service is a standard SIG defined service to hold device specific information.

     

    Unknown service 1 331a36f5-2459-45ea-9d95-6142f0c4b307 is used for sending RX and TX information as well as

    changing the mode from streaming to remote command.

    More information will be found here: https://docs.silabs.com/gecko-os/1/bgx/latest/ble-services#xpress-streaming-service

     

    I couldn't find much information about Unknown service 2.

    BGX13P Power Consumption:

    Note: This should be one of the interesting part of the testing. But unfortunately due to COVID19 pandemic I don't have access to any good measurement tools. So mostly I will be doing datasheet analysis with onboard AEM ( Advanced Energy Meter )

     

     

    Power consumption in the BLE IOT market is a hot topic. Different chipset/SOC vendors are putting their great effort to reach the lowest possible energy consumption.

    I would say SiliconLab's BGX13P may not be the lowest power consuming device out in the market. But they got the values neck to neck with the competitors.

    Active supply supply current of ~3uAmps with a baud rate of 9600 is really impressive. At 20milli seconds advertising interval the chip is drawing 2mA and 4.7 mA if the baud rate is greater than 9600.

     

    BGX13P is a single supply device and when you connect it to the EXP header of EFM8 it will be powered using EFM8's VMCU. There is an energy meter available on board of EFM8. Any peripheral which drains current from VMCU can be monitored using

    Energy Profiler available in Simplicity Studio.

     

    Connect the USB mini debugging chord to the computer. And run simplicity studio. Open Energy perspective in simplicity studio.

     

    Toggle the switch to AEM position.

     

    Now select peripheral mode from the example program.

     

    Run energy profiler by selecting the JLink debug adapter and start a new energy capture.

     

    The whole example project is consuming 6.90mA of current while in advertising mode ( This includes all the peripherals connected to EFM Board (LCD mainly).

    But if you look at delta from 6.18mAmps base line( 550mseconds) to roughly around 29 mAmps (for burst of 3.6mSeconds) when the radio active. The average comes around 6.32mAmps which is ~140uAmps while advertising around 550msec interval. That's actually an impressive number.

     

    The below image is captured while receiving 50characters ( 51 with "\n") from the app to device.

    Conclusion:

     

    BGX13P is an easy to integrate, low power, out of the box Blueetooth5 solution for those who are looking for adding BLE wireless feature to their embedded solution.

    The tools that that Silicon Labs provided are really good and everything is very well documented.

     

    Some cons are:

    • BGX13P is not a fully configurable from Bluetooth solution. You can't create custom profile for your application. It will only play the serial bridge role.
    • Simplicity studio installation sometimes gets a little tricky and the eclipse platform crashes many times in the middle of the use.
    • BGXCommander app is good for the but I think the UI/UX could have been better than what it has now.
    • It would have been good if Silicon Labs can provide a jumper option to measure the current consumption .

     

    Useful Documents and links:

     

    Datasheet for BGX13p : https://www.silabs.com/documents/public/data-sheets/bgx13p-datasheet.pdf

    Wireless Xpress BGX13P user guide : https://www.silabs.com/documents/public/user-guides/ug369-slexp8027a-bgx13p-user-guide.pdf

    BGX13 Command Reference : https://docs.silabs.com/bgx/latest/cmd/commands#gfu

    BGX13 Variable Reference : https://docs.silabs.com/bgx/latest/cmd/variables#sy-i-s

    BLE Service overview : https://docs.silabs.com/gecko-os/1/bgx/latest/ble-services#xpress-streaming-service

    USBXpress Device configuration and programming guide: https://www.silabs.com/documents/public/application-notes/AN721.pdf

    Wireless Xpress BGX13P home page :https://www.silabs.com/products/development-tools/wireless/bluetooth/bgx13p-bluetooth-xpress-starter-kit


Comments

Also Enrolling

Enrollment Closes: Jun 4 
Enroll
Enrollment Closes: Jun 26 
Enroll
Enrollment Closes: Jun 19 
Enroll
Enrollment Closes: Jun 19 
Enroll
Enrollment Closes: Jun 22 
Enroll
Enrollment Closes: Jun 5 
Enroll
Enrollment Closes: Jun 5 
Enroll