Select a lesson to load it into the ModuLab.
The browser dashboard is built for a desktop or tablet workspace. On a phone, install or open the ModuLab Android app for Bluetooth board control.
If the app is already installed, open it from here. If Android blocks that, use the Play button.
Use the full help when you need details; this card keeps the live dashboard close.
Loading ModuLab help…
Picture it: Think of this like the cockpit of your biscuit mission, where you choose speed, tools, and what to test next.
How it works: Workspace settings control how fast the dashboard updates and how quickly edits auto-send to the board, so your testing feels smooth and responsive.
Try this: Set a slower auto-send speed, draw on a display panel, then make it faster and compare how the board reacts.
Breadboard diagram
Picture it: This is your treasure map for wiring, showing exactly where each biscuit goes so everything can talk together.
How it works: The build panel shows the lesson wiring layout and links to the full breadboard workspace, helping you match the real circuit to the lesson setup.
Try this: Open the build view, place one module at a time to match the map, then return to Test and check if it connects.
Picture it: Like a tiny flashlight you can control with code.
How it works: Sends commands that turn the LED on, off, or blinking on the board.
Try this: Send LED On, then LED Off, and watch how fast the board responds.
Three distinct red, amber, and green LEDs on individual GPIO pins for beginner control logic.
Picture it: Like a mini road signal where your program controls each colour.
How it works: PB12 drives red, PB13 drives amber, and PB14 drives green while a shared cathode ties to ground.
Try this: Switch red, amber, and green one by one, then add timing with automation rules.
LED matrix driver used for displaying text and simple graphics.
Picture it: It works like a mini scoreboard where every square can light up.
How it works: The MAX7219 chip looks after the LEDs. The Bluepill sends rows of data and the driver refreshes the lights fast enough to look steady.
Try this: Send a word to the matrix, then change the bitmap rows to make your own 8 by 8 icon.
Addressable 8x8 colour LED matrix driven from PA8 with timer DMA.
Picture it: Imagine 64 tiny stage lights, and each one can pick its own colour.
How it works: The LEDs are chained together. The Bluepill sends a timed stream of colour numbers, and each LED keeps the colour meant for it.
Try this: Make one pixel red, then fill a row, then animate a rainbow travelling across the grid.
Browser-side game controls and game telemetry.
Picture it: Like a tiny arcade built into your dashboard.
How it works: Runs game logic in the browser, then streams frames to connected display modules.
Try this: Start Matrix Tetris, then watch score and lines update live.
Accelerometer and gyroscope breakout used for tilt and motion sensing.
Picture it: It feels movement a bit like your inner ear helps you know when you tilt.
How it works: The accelerometer senses pull and tilt, while the gyroscope senses turning. The Bluepill reads those numbers over I2C.
Try this: Tilt the board and watch pitch and roll change, then use the tilt to control lights or an animation.
Distance sensor with separate transmitter and receiver transducers on the front face.
Picture it: It measures distance like a bat using echoes.
How it works: One round transducer sends a tiny sound ping. The other listens for the echo, and the Bluepill times how long the trip took.
Try this: Move your hand closer and farther away, then use the distance number to change a light, tone, or display message.
Analog variable resistor used to dial values from 0 to 100%.
Picture it: Like a dimmer knob that smoothly changes a number.
How it works: The SIG pin feeds PA6 ADC input. Firmware converts voltage to raw and percent values.
Try this: Turn the knob slowly and watch raw and percent values rise and fall.
Picture it: Like a kitchen timer that keeps track of passing seconds.
How it works: Controls timing modes used by other panel features and board behaviors.
Try this: Start a timed mode and observe how other panels react over time.
Picture it: Like a message board where your code writes short notes.
How it works: Sends text commands so connected displays can show words or short status messages.
Try this: Send your name or a short phrase and check it appears correctly.
Live Dashboard shows real-time values from your board and app so you can drag variables into automation blocks, test ideas faster, and understand what your system is doing right now.
Picture it: Like a spaceship control window that shows speed, direction, and warnings while you fly.
How it works: This panel listens to live data such as distance, pitch, roll, mode, text, and time. Each chip can be dragged into automation expressions so your routines can react to what is happening right now.
Try this: Drag {distance_cm} into an If block and make it trigger a message or animation when distance is less than 20.
Picture it: Like setting up dominoes so one action triggers the next.
How it works: Lets you build trigger and action rules that run without manual button presses.
Try this: Create one simple trigger-action rule and test it with the board connected.
abs(pitch)
roll
distance_cm / 10
mode_name
pitch > rollDISPLAY_ANIMATION_FRAME {{ clamp(round(distance_cm / 10), 0, 7) }}
P {pitch} R {roll}
{mode_name}
HELLO {bluetooth_name}DRV8833 dual H-bridge motor driver (4 PWM input mode)
Picture it: Like a toy car trigger that can gently creep or race, PWM gives the motor tiny bursts of power to control speed.
How it works: A brushed DC motor driver switches power on and off very quickly using PWM. The duty cycle sets average power, so higher duty means faster spin, while direction pins choose forward or reverse through the H-bridge.
Try this: Start at 20% duty, then step to 40%, 60%, and 80% and watch the speed change. Next keep duty at 50% and flip direction to reverse the motor.
Picture it: Like a news ticker that turns updates into moving messages.
How it works: Fetches data from selected feeds, formats it into short text, and sends it to matrix display workflows.
Try this: Pick a preset feed, run Execute, and watch the Feed Text update before sending it to the device.
Direct command and debug panel for sending firmware commands and reading live board responses.
Picture it: Like a command desk where you type instructions and read replies from the board.
How it works: Contains direct command input, quick debug actions, and output logs for troubleshooting.
Try this: Use GET_STATUS, then compare the returned values in the output log.
Use ModuLab as the hub, then branch out to wiring diagrams, lessons, and play experiences that use the same board features.