Of BLE, apps and ARMduino: A Simblee hands-on review

Article By : Michael Dunn

RF Digital's Simblee is a shortcut, and in short order, you can work up an embedded system that talks to an iOS or Android app of your own design.

BLE (Bluetooth Low Energy), app development and IoT design have pretty steep learning curves when you're approaching them from scratch. What are those of us in small companies (or hobbyists/makers) supposed to do? We look for shortcuts, and if we're lucky, we find them.

RF Digital's Simblee is very definitely a shortcut, and in short order, you can work up an embedded system that talks to an iOS or Android app of your own design.

The Simblee hardware comprises a small module that contains a 16MHz ARM Cortex-M0 processor, a BLE radio and firmware that pulls it all together to make a Superduino, or ARMduino, or… xxduino… Whatever you want to call it.

The Simblee's innards are left a mystery, but I'd wager a fancy dinner (with wine) that the key ingredient is a Nordic Semi nRF51822, a BLE SoC that integrates the ARM Cortex, 128k of flash, 32k of RAM, 10-bit ADC, 31 GPIOs, SPI, I2C, temperature sensor, UART, encryption HW, timers, RTC and a noise-based random number generator (RNG). Phew. Also under Simblee's hood are 32.768kHz & 16MHz crystals, a handful of discretes and a BLE antenna. Like other Bluetooth modules, it's pre-certified.

Simblee's big differentiator though is how it interacts with iOS/Android apps. You don't have to learn anything about either platform's development environment. Instead, as part of your Simblee code, you define your app's GUI in one function and the GUI's interaction with your embedded code in another function, all using just the Arduino environment (I won't call it an IDE). The Simblee iOS/Android app is totally generic; a blank slate whose behaviour is fully defined by your GUI code. When it starts up, you're presented with a list of any Simblees within comms range. The GUI definition from the Simblee you select is sent to your device, and away you go. Simblees can also network amongst themselves, with or without app intervention.

[Simblee 01 (cr)]
__Figure 1:__ *The Simblee app’s home page*

To ease development, RF Digital offers a range of stackable boards, such as Simblee breakouts, a USB programmer (unlike an Arduino, a separate board is needed), an RGB/button board and battery, relay, SD card, servo controller and prototyping boards. The regrettable "shield" moniker has been retained, even though the boards are not Arduino-compatible. Only seven GPIOs are brought to the stacking pins, but the larger Simblee breakout board has 29 GPIOs that are accessible by using a breadboard, wire leads or your own stacking board.

Once a Simblee is embedded in a device, it can be programmed OTA (over the air)—no USB programmer needed. I haven’t tried this yet, as it requires a deeper dive into the software. My own interest in Simblees was stoked by colleague/chum Max Maxfield (of the Hawaiian shirt), and my desire to build some lighting control projects.

Regular readers will know I have no qualms about bashing a product I feel is not up to snuff. Well, the Simblee does have some issues, but I'm going to try to be kind. It's a very interesting and potentially useful product made by a small company, and I'd like to see it succeed. That said, I must report my honest impressions.

My first project idea was utterly simple: A remote-controlled light switch so I wouldn't have to stumble to bed in the dark. Yeah…first-world problem. Implementation would require some care, as the board would need a simple capacitive-drop AC-line supply, and need to fit in an electrical box.
Then I installed RGB strip lighting over my bathtub and in the adjoining linen closet (why RGB? why not). The LED controller, though a slick touch-sensitive remote, is not to my liking, so using a Simblee to make a new and better one struck me as a simpler—and more interesting—first project. All I'd need would be a 3.3V regulator and a few MOSFETs.

One of the example "sketches" (Arduino programs are called "sketches") in the Simblee folder is, sure enough, a colour-wheel/slider controller for an RGB LED. Perfect—I can at least test with that—then rewrite it to my liking.

[Simblee 02 (cr)]
__Figure 2:__ *Simblee GUI*

As you can see, it's not a great GUI. The wheel is pretty ugly, and I'd rather have HLS (hue, lightness, saturation) controls, but worst of all, it's buggy. Compare the slider positions to the numeric values. They don't match. More often than not, moving a slider does not update the value. Sometimes it even causes other sliders to move. Whether this is bad luck due to a problem with my set-up, or more widespread, I haven't yet been able to determine.

The biggest problem with Simblee may well be the documentation. I'll get to that momentarily. First, here's a very simple sketch I wrote (basically a stripped-down version of the colorwheel example) to test slider functionality. BTW, it uses 23% of the 128kB code space—obviously mostly taken up with Simblee library code.

//Very simple test using a slider to control blink rate

#include <SimbleeForMobile.h>

const int blue_led = 4; //GPIO4 that is
uint8_t blinkyfreq;

//The standard Arduino initialisation block
void setup() {
SimbleeForMobile.deviceName = "Blinky";
SimbleeForMobile.advertisementData = "the LED";
pinMode(blue_led, OUTPUT);

//The standard Arduino main loop
void loop() {
digitalWrite(blue_led, HIGH);
digitalWrite(blue_led, LOW);
SimbleeForMobile.process(); //This enables Simblee functionality

//The GUI is defined here
void ui() {
uint8_t slider = SimbleeForMobile.drawSlider(55, 110, 175, 0, 255);
SimbleeForMobile.setEvents(slider,EVENT_DRAG); //Simblee support added this line

//Called on any GUI event
void ui_event(event_t &event) {
blinkyfreq = event.value;

Sure enough, the original code behaved identically to the colour wheel program—badly. Simblee support looked at the code and added one line in the GUI definition function. Now, a stream of values is emitted as I move the slider (as seen on the "serial terminal"). Okay… I can work with that.

Some scope captures of the LED pin follow:

[Simblee 03 (cr)]
__Figure 3:__ *The high levels are the 3ms on-times. Low times are a combination of delay(0) and the internal Simblee processing. Using infinite persistence, you can see the jitter.*

[Simblee 04 (cr)]
__Figure 4:__ *Close-up of the LED-off time*

[Simblee 05 (cr)]
__Figure 5:__ *Now with a LED-off time of 10ms. The stats show the range of on/off times.*

Next: The bad and the ugly: Hands-on review of Simblee »

Leave a comment