RGB LED (H01R0x)


SKU: H01R00 Category:


Stage: Production

In stock (can be backordered)


H01R0x is a smart RGB LED module based on Cree CLVBA-FKA RGB LED and STM32F0 MCU. It is our first and most beloved module as it was used to test and develop most of Hexabitz backend!

  • Use this module as a stand-alone smart RGB LED and easily control it via a Command Line Interface (CLI).
  • Firmware has embedded on / off / toggle, PWM, dimming and color sweep functionality.
  • Program advanced C code with our easy-to-use APIs.
  • Connect many H01R00 modules together and build interesting flat and curved boards with any configuration you imagine!
  • Send commands to a single LED, a group of LEDs or broadcast to all of them at the same time.
  • Connect to external hardware or combine with other Hexabitz modules!

A step-by-step guide to build blinky Hexabitz modules!
Blinky 101

Build your very own disco ball with some ninja soldering skills and a little help from the 3D printer.
Sphere of Light

Build and control an array of RGB LEDs using your hand gestures and magic (i.e., IR sensor craft)!
Magic Array!

Control Hexabitz modules from a smartphone app using Bluetooth.



  • Cree CLVBA-FKA-CC1F1L1BB7R3R3 Tri-color (RGB) SMD LED, 4-Pin PLCC:
    • Dominant Wavelength: Red (619 – 624nm) Green (520 – 540nm) Blue (460 – 480nm).
    • Luminous Intensity (mcd) @IF=20mA: Red (224 – 560) Green (280 – 900) Blue (90 – 355).


  • STM32F091CBU6 32-bit ARM Cortex-M0 MCU.
  • 8MHz external oscillator.
  • Six array ports and six power ports (+3.3V and GND).
  • Access to 6xUART, 2xI2C, SWD, BOOT0, RESET.

Physical Properties

  • Shape: Hexagon
  • Size: 30 mm short diagonal, 17.32 mm side
  • Area: 7.8 cm^2
  • Weight: 1.3 g
  • Soldermask Color: Dark green
  • Surface Finish: ENIG (gold) or HASL-LF (tin)

Hardware Release Notes


  • Initial hardware release.


  • Mounting holes were moved a little bit to be on the diagonal line exactly 5mm from module corner.

Bill of Materials

H01R00 BOM

Quickstart Guide


  1. Power your module from the 3V3 and GND pads. If you are using the FTDI 3.3V USB-UART cable, then the red wire should be connected to 3V3 (top) and the black one to GND (bottom).
  2. Connect the USB-UART cable to any of the module array ports (i.e., communication ports P1 to P6) using the wired Kelvin clamp or by soldering header connectors. The top pad is MCU TXD and the bottom one is MCU RXD. Thus, you should connect the top pad to the cable RXD (yellow in the FTDI cable) and the bottom pad to cable TXD (orange).
  3. If your module already has firmware on it (it showed one or multiple red indicator LED blinks when you powered it on), then you are ready to connect to the CLI in the next section. If your module doesn’t have a firmware yet, follow the firmware update guide here.

Try out some CLI commands

Follow the instructions to setup and connect to module CLI and try the following commands (Note all CLI commands are case-insensitive):
  • Type ping (and press enter), you will see a single indicator LED blink and a response message.
  • Type help to get a list of available module commands.
  • Type color red 30 to turn on the RGB LED with color red and 30% intensity. You can use the following set of predefined colors: black, white, red, blue, yellow, cyan, magenta and green.
  • Type off to turn off the LED.
  • Type dim green updownwait 1000 500 inf the RGB LED starts dimming up and down, repeatedly. The up and down cycle lasts for 1000 ms and is followed by 500 ms wait time where the LED keeps its current brightness before repeating the cycle.
  • Type run-time-stats to view current tasks (threads) and their run times. The messaging tasks are responsible about communication, the front-end task runs user code and other tasks perform various background activities including CLI communication.
  • Type status to view module status report including firmware version and compile date, module ports status and DMA streams status.
  • Connect a push button switch to port P1 and type in the CLI add-button momentary-no p1 to define a momentary button at port P1. You can reference this button in the CLI as B1.
  • Now, type the following commands each on a separate line followed by pressing ENTER:
    if b1.clicked
    end if
    If you click the push button, you should see indicator LED blink each time.
  • Type the following commands each on a separate line followed by pressing ENTER:if b1.pressed for 3
    color magenta 50
    end if
    Now, press the push button for three seconds and you should see a solid magenta color on the RGB LED.
  • Type the following commands each on a separate line followed by pressing ENTER:if b1.clicked
    end if
    Now click the push button and you will see an indicator LED blink and the RGB LED will turn off. The module will repeat same behavior until you power cycle.
  • Check module factsheet for more commands and their documentation!

Feeling victory? Let’s build a small array!

  • Solder few H01R00 modules together in your preferred shape and configuration. Just remember to orient all modules in the same direction (up or down) to avoid shorting power pins. The 3V3 pads should connect with each other and GND pads with each other. In this example, we want to program modules locally (i.e., update each module firmware by connecting to the module itself). To achieve this using ST factory bootloader, make sure you leave the programming port (P2 in this module) free. It’s marked with *. In other cases, you may use remote bootloader update or the SWD pads to update firmware so you can use P2 to connect modules together.
  • Once you power up the array, you will see all modules making a short single blink from their small red indicator LED. This means these modules have native firmware, i.e., the general firmware that you download to all modules of the same type, and they are not connected to each other yet. If you connect to any of these modules via the CLI, you will see they all have ID 0.
  • Let’s ask the modules to explore the array and connect to each other to do something useful together! Connect to any module via any port (this module will get ID 1) and run the following CLI command: exploreThe modules start exploring their neighbors and building the array topology making a pattern of blinks along the way. Check this article for details about the exploration process. Once the process is done, the explored topology is displayed on the CLI terminal. It’s also saved in MCU Flash. So if you power cycle, the topology will be preserved. When you reboot, the modules make three indicator LED blinks signaling that they have unique IDs and stored topology.
  • Now, you can have some fun with the array by repeating some of the previous CLI commands. If you are connected to module 1, type #2.ping and module 2 will blink its indicator LED and send back a response message to your terminal. You can disable the CLI response from a remote module using set BOS.response none
  • Type all.ping and this will broadcast the ping message to all modules. Broadcast commands currently do not return a response.
  • Type #3.color blue 30 to turn on module 3 with blue color and 30% intensity. If you type all.sweep fine 3000 infall modules start sweeping colors indefinitely! Since there is no synchronization signal between the modules, their timing cycles start to diverge from each other randomly creating awesome patterns. If you want to keep tight synchronization between the modules, then you can write a C program with a for loop that cycles through colors and requests displaying them from remote modules. Check other Quickstart Guides or our Hackaday projects and documentation for examples on writing C programs.


Frequently Asked Questions

A: Yes! But all Hexabitz modules -whether it’s a complex Ethernet or IMU or a simple LED- share same backend hardware and software. This what gives the platform its unmatched modularity and scalability. Cortex-M0 MCUs are small, cheap, power-efficient, yet capable of really wonderful things. Having an embedded MCU provides a cheaper and more compact alternative to connecting an LED breakout with an external controller.

A: Hexabitz are designed for the absolute soldering beginners! The edge pads are large and easy to reach and anyone with basic knowledge of soldering can assemble a flat array. Curved and spherical arrays require more training but can be made easier with 3d-printed fixtures.

Load More

Have more questions? Please check our main FAQ page and feel free to contact us for any unanswered questions.


  • Schematics (PDF)
  • Hardware Design Files (Circuit Maker)
  • Source Code (GitHub). Download a pre-compiled firmware HEX file here.
  • Documentation / Factsheet (PDF)
  • Projects & Examples: Please check our account on Hackster.io for demo projects and examples.