ON Semi RSL10-SENSE-DB-GEVK Sensor Board - Review

Table of contents

RoadTest: ON Semi RSL10-SENSE-DB-GEVK Sensor Board

Author: shabaz

Creation date:

Evaluation Type: Development Boards & Tools

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

What other parts do you consider comparable to this product?: TI has chips with some overlap (CC26xx series) however there are differences, so there is no completely comparable product.

What were the biggest problems encountered?: A few broken links, and absence of a mobile app needed for running the in-built example. However, I worked around it and it won't affect engineers and developers working with the RSL10.

Detailed Review:

RSL10-SENSE-DB-GEVK Review

 

Introduction

I’ve been excited to explore this Bluetooth LE (BLE) sensor board for quite a while!

Here’s a 4-minute overview and video demo of the board:

 

The reason for being interested in this board, is that it contains an extraordinarily small compute and wireless system-in-package (SIP) device that is easy-to-use. It seems like a game-changer because anyone can create tiny wearable projects, smart wireless headphones, watches and toys with this device. Its footprint is three times smaller than a micro SD card, and that includes a built-in antenna.

 

The RSL10 SIPRSL10 SIP 8 x 6 x 1.5mm package internally contains a chip called the RSL10RSL10, along with antenna, inductors, capacitors and crystals so that apart from a few pull-up resistors, nothing extra is needed for operation.

 

The RSL10 kitRSL10 kit contains that RSL10 SIP device pre-soldered onto a main board. The board is the size of a large coin, and is populated with some sensors too. The underside of the board has a battery clip for a 3V CR2032 coin cell. A separate programmer/debugger board is supplied, and a cable with 10-way 1.27mm connectors for interfacing it to the main board. There’s also a small Near Field Communication (NFC) antenna that plugs in directly to the board.

 

 

The on-board sensors include a light sensor, temperature, humidity, pressure, air quality (it measures the amount of volatile organic compounds in the air – i.e. types of chemical fumes, rotting fish and garbage cans) an inertial measurement unit (IMU) and a compact digital-output microphone.

 

That’s a lot to explore! I may explore the sensors in a later blog post, but this review is going to focus on the core part, the tiny RSL10 SIP device, to get to the point of using it in custom designs.

 

The RSL10-SENSE-DB-GEVKRSL10-SENSE-DB-GEVK name is quite long, so in this review it will be more informally just called the RSL10 kit or RSL10 board for short. Incidentally there are other evaluation kits for the RSL10 SIP and the RSL10 available too, one of them Arduino Shield shapedArduino Shield shaped, but the RSL10-SENSE-DB-GEVK kit is the one I had for review. There is a slightly similar-named RSL10-SENSE-GEVKRSL10-SENSE-GEVK kit too, but that doesn’t include the programming header and separate programmer board, and for that you are expected to bring your own debugger and cable if you wish to put your own code on the device. Some of the larger RSL10 SIP and RSL10 evaluation boards have an on-board debugger and are lower cost, so there’s plenty of choice. The kit being reviewed here can be operated with a coin cell and is compact, so it would be handy when evaluating the RSL10 SIP for use in products where size and power consumption are important.

 

Bluetooth Low Energy (BLE) Crash Course

BLE operates at 2.4 GHz, and, as its name implies, is very useful for low-power communication! Devices using BLE can sometimes operate for a year or longer using a coin cell.

 

As far as the software interface to BLE is concerned, information can be read or written via handles known as characteristics. The underlying BLE software stack will perform the magic needed to get that information across using the radio interface. The communication is not generally symmetrical; each BLE device instead plays a ‘role’. The two main roles (there are actually four that are possible) are known as BLE Central Device, and BLE Peripheral Device. The peripheral device can advertise periodically to everyone that it exists. The advertisement may contain sufficient information for the recipient, but in many use-cases more information is needed, so the recipient of the advertisement will try to connect. The initiator of the connection plays the Central Device role, and in effect it is a master to the slave peripheral.

 

Board Features

The board is quite feature-packed. Plenty to keep one busy.

Once you insert the battery, the device starts advertising, ready to be connected to an app. Unfortunately the required app seemed to be temporarily removed from the Android app store : ( The app is important, because it shows you one way to transform the RSL10 board into an IoT wireless sensor node that communicates to the cloud using your mobile phone as the gateway. That’s a massively important type of workflow simply because it has so many uses.  In my case, it was of less concern since I wished to develop my own apps.

Since there are many RSL10 boards, there could be a desire to modify code intended for one board to another. These are the pin names that are used on this board; this information comes in handy when working with the code (see further below).

 

RSL10-SENSE-DB-GEVK I/O Numbering

FeatureI/O Pin NameNotes
Push Button 115Input
Push Button 212Input
RGB LED: Red2Output
RGB LED: Green1Output
RGB LED: Blue0Output
I/O Interface Pin 33-
Microphone Clock10Input
Microphone Dout6Output
I2C SDA and I/O Interface Pin 44I2C Master
I2C SCL and I/O Interface Pin 35I2C Master
IMU (BHI160) Interrupt9Input

 

RSL10 Overview

I have to repeat it again, I love the size of the RSL10. I get the feeling it could become my favourite substitute for other microcontroller chips for a while : ) Even if the BLE wireless capability were not needed for a project, it could still be a nice-to-have feature that could be used to eliminate other wired interfaces for configuration purposes, remote logging, and over-the-air software updates. The wireless capability incidentally doesn’t need to be BLE. The RSL10 exposes registers for direct access to the RF hardware, bypassing any BLE stack. So, you can implement proprietary protocols that could work around any BLE restrictions too. On Semi supply example code that does just that, for low-latency audio streaming.

 

The diagram here shows what is inside the RL10.

There are a total of 16 input/output pins exposed on the RSL10 SIP module, and they can be used as general purpose digital input/output or for any of the other purposes shown in the diagrams, including analog input. There is a lot of flexibility; any pin can be configured for any purpose, there doesn’t seem to be any specific pin multiplexing restriction.

 

Current Consumption

The RSL10 board was run using some example code (see further below to see what examples I ran with the RSL10), powered from an external power supply (I removed the on-board coin cell, and wired the supply to the 0.1” header on the board). I used a 2.8V power supply, and monitored the current with a Keithley DMM6500 meter.

 

The chart below shows the current consumption at power-up, for two minutes. For the first minute, the RSL10 board sent out BLE advertisements (this was what the programmed code was supposed to do) with current spikes of around 2-3 mA. I believe the subsequent spikes are related to the on-chip buck regulator (the RSL10 uses a low core voltage) but this is just a guess.

The software programmed into the RSL10 stops advertising after 60 seconds, until a button is pressed. The chart below shows what happens when the button is pressed, followed by a connection from a BLE Central Device, and characteristics written and read each second:

 

A zoomed-in view of a few seconds during the time the characteristics were being written and read is shown below. Each spike presumably corresponds to radio transmit or receive operations:

 

RSL10 Documentation

Another benefit of the RSL10 is the documentation. While some of the website stuff had issues (broken links), the actual PDF manuals for the hardware and software are well written. The library code for BLE and the on-chip peripherals such as the ADC and serial interfaces is documented in a single PDF – that’s nice and easy to navigate. Apart from the on-chip DSP, all the other features appeared to be well documented. The DSP uses third party tools, and requires discussion with On Semi to be able to use it.

 

Working with the Development Environment

From the RSL10 SIP product page On Semi supply a freely downloadable integrated development environment (IDE) and libraries for use with the device. In brief, everything I tested worked well, and there were no issues using the development environment. The IDE runs on Windows (I didn’t see a download for other operating systems) but in theory it would be feasible to use the GNU GCC compiler for ARM too.

 

I followed the RSL10 Eval Board user guide (PDF) as well as the RSL10 Getting Started guide (PDF) – they are written quite well. I did have some website issues - there didn’t seem to be any way to download a particular software pack. I eventually found it – if you too have the same issue, visit this other Bluetooth dev kit page and download the software pack from there).

 

The development environment is based on Eclipse, so it will be familiar to many embedded engineers. The key thing when using it with the RSL10 is that along with the usual Code and Debug perspectives that are seen in Eclipse, there is also a perspective called CMSIS Pack Manager. Click on that, and you can install additional packs of software. Various software packs are available from ARM and from On Semi, and the packs provide APIs, drivers and example source code into the development environment.

 

After the packs were added, the rich palettes of libraries, APIs and example code were visible. There are real-time operating systems (including FreeRTOS and RTX and RTX5), drivers for serial interfaces and all the sensors on the board, and the BLE stack too of course, and perhaps close to 100 example projects. Help is also fully integrated. Nearly all the APIs and drivers have clickable help. I found the best place to start was using an example app, and building from there. Note that because there are many RSL10 boards, you may need to change some I/O pin definitions if you choose an example app intended for a different board, but this is straightforward.

 

I followed the guide to import the blinky app. The example was intended for a different RSL10 board, so I changed the LED and button pin number definition in the app.h file for the code to function with my board, using the table listed above in the Board Features section. All of the sensors communicate using I2C.

 

Once the code was compiled it was a quick matter to upload the code onto the board and it worked. Great! This was a small step, but smooth so far, so I continued with exploring some of the other examples.

 

Implementing a BLE Beacon

Next, I took a look at an Eddystone Beacon code example called solarsens_env_beacon_v3. It was designed for a different board with different sensors, so this was a nice opportunity to explore how to use the libraries to add a sensor into the code. This was fairly straightforward – the trick is to click on the .rteconfig file in the project view, and then you’ll see a clickable list of things you can add to the project. I used that to switch off the non-existent sensors and add the sensor which I intended to use.

 

With some tweaks to the source code, it was fairly easy to get an Eddystone beacon functioning, advertising temperature to a mobile phone running an app that can scan for beacon data. I used an Android phone and Blue Gecko from Silicon Labs.

 

If you wish to try it, the tweaked source code bundle is attached to this review.

 

With this bit of confidence, I decided to examine a BLE Peripheral type of app. It is the most likely type of app I would want to create often with the RSL10.

 

Implementing a BLE Peripheral

Looking at the example apps, I noticed one called sense_ics_firmware_sleep which I believe is similar or identical to the default app that was on the device (since by now I’d deliberately overwritten the firmware that had arrived on the board, I could not confirm). In any case, this is a BLE example that is intended for use with a mobile app that I could not find on the Android App Store at the time of writing, at least for my mobile phone. In any case, I decided to reverse-engineer it a little bit to figure out how it worked, so that I could modify it in future to support my custom sensors, and to work with my own apps rather than the missing Android app.

 

It took a while to figure it out, but the protocol design and the implementation is quite interesting. The protocol relies on forward-slash separated values in a string. Once that is received by the RSL10 device, it will decode the string to pull out a transaction identifier (e.g. 0 for the first transaction), a subsystem identifier (e.g. AL for the Ambient Light sensor) and then the actual request (e.g. L for enabling the light sensor). So, a complete instruction would be:

0/AL/L//

There are two forward-slashes at the end because this instruction does not include any value to write.

 

Once the command has been executed, the remote device can send a request to read a BLE characteristic, and the response will contain the transaction identifier. An example from the AL subsystem would be:

0/f/155.00

which would indicate a light level of 155.00 lux.

 

Using the RSL10 as an Ambient Light Measurement Device

Once the protocol running on top of BLE was figured out, the next step was to communicate with it, to build a usable solution. The question was, how to do this? In the past, I’ve used several methods, such as using other BLE-enabled microcontrollers, or a Raspberry Pi. This time around, I figured it may be worth trying something new (to me). For about a year, the Web Bluetooth API has been evolving. This is an interesting API that runs in a web browser (Google Chrome supports it, other browsers do not support it currently). By using the API, web pages can interact with the BLE chip inside your PC. No application needs to be installed on the PC!

 

The Web Bluetooth API is convenient because no code needs to be installed on a PC. Provided the browser (for now, the API only works with Chrome until it is more broadly adopted) can access the web page, and the PC has Bluetooth capability, then the application can work. The web page contains the application in JavaScript. It is served up by the web server, and the PC’s Chrome browser will automatically talk to the Bluetooth chip inside the PC, to communicate to the BLE peripheral such as the RSL10. I used a Web API Bluetooth article to understand how to use the API.

 

The demo of it is shown in the earlier video.

 

Summary

The RSL10 is an extremely interesting device. It is tiny, and this could enable wearables projects. The fully integrated system-in-package is great for reduced time-to-market too.

 

Since the SIP simplifies BLE implementation in products immensely, this could be handy to encourage BLE use in products that ordinarily may not have it. Combined with a mobile phone app, or Web Bluetooth API-enabled Chrome browser app, it is very convenient for configuring and monitoring products without requiring physical connectors. The BLE feature may pay for itself once the cost saving from not requiring connectors is factored in. The RSL10-SIP costs about $6.50 in quantities of 1000 or $10 in single quantity. That seems pricey, but laying out a Cortex-M3 chip with BLE radio, plus the required crystal, capacitors, inductors and antenna could approach this cost.

 

It proved to be straightforward to work with the RSL10, and I was able to successfully work with the RSL10 demo code, and understand it sufficiently to adapt the examples to run on the particular RSL10 board I had, and to build my own browser-based application to communicate with the RSL10.

 

I hope the information in this review was useful. Thanks for reading!

Anonymous
  • Hi Luis,

     

    You've caught it at a good time, just migrating stuff from old PC, but luckily I still have that workspace. I've zipped up the entire workspace, so you have access to the code I've been using, in case I've downloaded it from a different location (I do recall going in circles on the On Semi website, due to site issue at the time, maybe it is resolved now).

    My On Semi workspace is downloadable here (78 Mbyte download): https://app.box.com/s/giiq4mlo8q0qnc6n088lvdluh6fvlvbx

    It ideally should be unzipped and placed such that the path is c:\c_root\electronics\onsemi-workspace and then that folder contains content as shown in the screenshot below. Maybe it can be placed in other locations too (I don't know if the IDE uses relative paths or fixed paths).

  • Hi Shabaz,

     

    This is a great review of this little board. Have you tried the Eddystone example included in the BDK Examples?

     

    According to the instructions it can be used with the RSL10-SENSE with some minor tweaks but I haven't had luck with it. It compiles and everything but for me it always gets stuck at "Starting target CPU...".

     

    Also, could you let me know where did you get your solarsens_env_beacon_v3 orignally from?

     

    Luis

  • Hi Sorry I completely missed your reply and just noticed it. I'll give it another try and measure again. It's a neat board to use as a reference design.

     

    Cheers

  • Hi!

    It's not documented as far as I'm aware... I just hunted around in the source code to decipher it enough for the review.

    I *think* (I can't recall for sure) the file to examine is sense_ics_firmware_sleep\src\ics\CS.c - I just briefly looked at it now, and in

    function CS_ProcessRequest I see strtok being executed (which splits up a command string), so it's there I'm 80% sure.

  • Hi

     

    I was wondering which file did you find the implementation of the BLE protocol. Like how did you figure out you the "AL" and "L" part in "0/AL/L//". Im trying to write my own app for the RSL10 but have difficulty figuring out their BLE protocol.

  • Hi Waleed,

     

    Thanks!

    I think the default supplied firmware on the board may not be using the lowest power options, because I noticed there was code for sense_ics, but also different code called sense_ics_firmware_sleep. I wiped the default firmware so I'm not sure which one it was. I measured with the sense_ics_firmware_sleep code. With that, I got the results shown in the graphs, i.e. under around 20 uA, with very brief spikes in the hundreds of uA, which may be the on-chip DC-DC converter.

    With sense_ics_firmware_sleep, as I understand, there is no BLE advertisement occurring, until the button is held down for a couple of seconds to wake up the device, and then it is discoverable for maybe a minute, to allow another device to connect to it (and then it stays powered up until the device disconnects).

  • Hi Shabaz

     

    Thanks a lot for sharing your findings, a great review of the board.

    I used a DMM6500 and for some reason even in deep sleep the average current was 700uA at @3V, I would assume that to run on a coin cell battery, a much lower current would be used. Or maybe instead of deep sleep consider stop or shutdown modes. Just a thought.

     

    Cheers

    Waleed

  • Hi! Not yet, but it looks interesting. I've not done any formal web development or studying, so my JavaScript stuff is pretty terrible.

    I'd like to get to the point that I know which JavaScript libraries to use for these sorts of tasks.. trouble is there's so many of them!

    I recall looking at one in the past, which seemingly produced beautiful charts.. but was doing bezier-style nonsense on the curves! : ) Not really good when you're trying to plot real data and want control over interpolation if used.

    So far, for data on the server, I've often got away with some native apps to do monitoring of data (and even just using graphics libraries when wanting to do really niche graph styles - I once needed to represent tens of thousands of pieces of information on-screen, so there was no choice but to do it in a custom way), but I do want to do it more and more using web technologies.

    With my limited knowledge I've sometimes resorted to a plain canvas, and self-draw stuff using any basic JavaScript library : (

  • Say, have you ever tried https://grafana.com/ 

     

    It's open source analytics & monitoring solution for producing fancy looking dashboards (the Arduino dashboard on that tweet looks remarkably similar).

  • Hi Steve,

     

    I've just tried to run it locally on my phone it works there too. I downloaded the zip file to the phone, clicked on it and it saved the contents to an Internal/Downloads/rsl10 folder, and then clicked on example.html, and then when given the option I chose to open it in Samsung Internet instead of Chrome.

    In the web page, when I clicked on the Select RSL10 device, after I selected the device, it failed and I don't know why. However I reloaded the page and reattempted, and it worked after a couple of tries.

    So, in summary, local files are ok, for both laptop and mobile.