Smart.IO: Affordable Remote Control for Embedded Designs!

Providing an App for your embedded products or even prototypes will soon be a requirement, not just a "checkbox on your wish list". You can either spend $20,000+ and 3 months to develop the hardware and software and find app developers who are skilled in wireless programming, OR you can spend $16 for a Smart.IO toolkit which gives you the capabilities you need with no wireless or app coding!

Smart.IO (patent pending) was funded successfully on KickStarter (project link here). We will add more information to this page shortly. A few quick notes:

  • We will be setting up a forum at for Smart.IO users.
  • As we reached our stretch goal for the KickStarter, we will soon start work on the Android version of the programmable app as well.
  • If you missed the KickStarter, you can still pre-order Smart.IO here.

Thank you for your support!



Simple use case example of Smart.IO

Let's say you are designing a basic controller to adjust the speed of a fan. The smartphone app user interface is a slider, which lets you control the fan speed by changing the slider position.

  1. Design a controller circuit to control the fan motor speed and to turn the fan on and off. You can use any microcontroller you like.
  2. Add the Smart.IO chip module to your design. This chip  interfaces with your microcontroller via SPI and a couple of interrupt pins. (This should just require a small amount of work to fit it into your prototyping system or production circuit design.)
  3. Write the firmware to control the fan speed.
  4. To use the Smart.IO API, you add the API interface layer source code provided by ImageCraft, which should compile to just about 4K of code in your target microcontroller code.
  5. To create the user interface on the Smart.IO App, you will write something like the following:
#include <smartio_api.h>

tHandle slider;
void connect_callback(void);
void disconnect_callback(void);
void slider_changed(int);

int main(void)
    SmartIO_Initialize(0, connect_callback, disconnect_callback);

void connect_callback(void)
    slider = SmartIO_MakeSlider(50, 100, 0, 280, slider_changed);
    // get the current fan speed from the hardware
    int fan_speed = ...;
    SmartIO_UpdateSlider(slider, fan_speed / MAX_FAN_SPEED);

void slider_changed(int value)
    // adjust fan speed based on "value"

(NOTE: This code fragment is a completely bare-bones implementation of the user interface. In a "real" version, you would add labels, maybe different colors for different settings, etc.)

Deconstructing the code fragment above:

A major concept in Smart.IO API is the use of callback functions, which are just functions in your firmware. For example, when you create an input element such as a slider, you provide the name (actually the address) of the callback function which Smart.IO will call when the App user adjusts the slider.

SmartIO_Initialize() is the first call into the Smart.IO system, and should be called somewhere in your main routine. You supply it with two callback functions: one for when the Smart.IO chip connects to the App, and one for when it disconnects.

When the Smart.IO chip connects to the App, the connect_callback function is called. The first thing it does is create a slider using the SmartIO_MakeSlider call, specifying the slider's screen location, the length of the slider, and the callback function to call when the slider value is changed. Then, it reads the current fan speed from the hardware, and sets the initial value of the slider to the current fan speed setting.

When the user adjusts the slider, the slider_changed function is called. The new slider value (a percentage) is passed to the function, and the firmware uses this value to adjust the fan speed.


Your firmware does not need to deal with the mechanics of the wireless communication (in this case, Bluetooth Low Energy), or even pairing with the App. Smart.IO does it all for you. You don't even have to write the App, just configure the programmable Smart.IO App to your preferences.

The user runs the Smart.IO App, connects to the fan controller system, and the firmware's user interface will take over.

We can customize an App for you so that the App can automatically pair with your firmware, with your own logo and branding. Your users then simply invoke the customized App, and interact with your user interface immediately.

A bit more advanced:

For a commercial product, you likely would want to also add "smart control" behavior. For example, by adding a temperature sensor, you can write the user interface so as to turn on the fan automatically if the ambient room temperature rises above a selected degree. That user interface code fragment may look something like this:

SmartIO_MakeCheckBox(80, 150, auto_on_cb_callback, "Set fan to auto-on when temperature is higher than");
t1 = SmartIO_MakeNumberSelector(80, 200, 60, 100, auto_on_ns_callback);

A checkbox controls whether the auto-on feature is enabled or not. When the user changes the checkbox state, the callback function auto_on_cb_callback is called. (There is a way to restore the previous state of certain user interface elements, but for brevity, we will not explain it here.)

A "number selector" allows the user to select a number between the low and high bound (60 and 100 in this case). Changing the number selector calls the callback function auto_on_ns_callback.

If the checkbox is ON, your firmware should turn on the fan when the ambient temperature becomes higher than the selected temperature.

Note that without a smartphone app, even a simple user interface like this becomes much more difficult to create: you will need an LCD display or LED segments and buttons, which provide a clumsier and less straight-forward way to set desired temperatures, and you will also need suitable labeling that takes up valuable physical space. Smart.IO solves these issues.