Mechanisms & micro:bit Intro
First contact with the micro:bit, first working mechanism, first taste of a take-home deadline. ~2.5–3 hours.
- 6× micro:bit
- 6× servo motors
- Cardboard templates — pre-cut and pre-glued
- 1–2 phones/tablets (needed later in the week for Teachable Machine)
- Charging cables + spare batteries
| Time | Activity |
|---|---|
| 0:00 | Welcome, cardboard/servo safety briefing, hand out pre-cut Mechanisms in Your Car templates |
| 0:05 | micro:bit Intro interactive lesson (narrated, live Bluetooth demo) |
| 0:50 | MakeCode editor orientation — blocks, downloading code to the board |
| 1:05 | Assemble the pre-cut/pre-glued Mechanisms in Your Car piece |
| 1:45 | Wire the servo to P0; code Button A / B to control position |
| 2:30 | Assign the take-home sprint; wrap-up |
Students are required to
- Bring their assembled mechanism home
- Try one stretch tweak — e.g. adjust the servo's turning range, or add a second mechanism
- Post one photo + one-line update before Day 2 (a phone/parent message is fine for now — Slack account is set up on Day 2)
What they learn — and why it matters
- Servo wiring & button events — the exact skill reused in every later build
- Code changes a number → a real object moves — the core idea behind every robot this week
- Cardboard assembly discipline — precision now saves rebuild time later
Notes on Mechanisms
Start simple and physical — you're building toward today's hands-on build, the wiper-style mechanism.
"A mechanism is just a part that turns one kind of movement into another. Your arm has mechanisms — your elbow turns a push into a swing. A car's windshield wiper has one too: a motor spins round and round, but the wiper blade doesn't spin — it swings back and forth. Something inside the wiper mechanism takes that spinning motion and *converts* it into a side-to-side sweep. Today, you're going to build that same idea out of cardboard, and control it with code."
Keep this concrete — if a student asks "why not just make the motor swing back and forth directly," that's a great moment to point out: motors are usually built to spin, not swing, so engineers design a *mechanism* to get the motion they actually want out of the motion the motor actually gives them. That's the whole idea behind today's build.
micro:bit Features — walk through each with the class
A 5×5 grid — 25 LEDs total. It can show text, animations, and pre-programmed pictures. Hold up a board (or the on-screen simulator) and have the class count the grid with you.
Two built-in buttons with no fixed function — their behavior is entirely defined by code. Point to where the buttons are on the board with the class. Then open it up:
"What could these two buttons be used for?" — let them brainstorm: turning something on/off (like mute/unmute), a doorbell, controlling a robot.
Key teaching point: the *same* two buttons, unchanged in hardware, can become a lamp switch, then a doorbell, then a game controller — purely through code. It's the programmer who decides what a button does, not the button itself.
An electromechanical sensor that measures physical acceleration — dynamic force like movement or vibration, or static force like gravity. It measures across X, Y, and Z axes to work out orientation and movement in 3D space.
Real-world uses: screen auto-rotation and step-counting on phones/wearables · industrial vibration monitoring for predictive maintenance · airbag triggering and vehicle stability in cars · motion data for drone and aircraft navigation and stabilization.
It can detect tilt (inclination via gravity), vibration, and impact. Classroom framing: rotating a phone screen, checking if something's level, detecting a jump or a bump.
Measures the strength, direction, and change of a magnetic field, and can detect the board's rotation angle relative to Earth's magnetic pole. Uses: determining geographic direction, detecting magnetic field changes.
"To calibrate the compass: open the calibrate screen in the app, then rotate the board slowly until every LED on the grid lights up."
Measures the ambient temperature around the board.
Allow connecting external sensors and modules — motors, LEDs, speakers, and more. They can also function as extra buttons. This is the pin family today's servo plugs into (P0).
bluetooth.onBluetoothConnected(function () {
basic.showIcon(IconNames.Yes)
})
bluetooth.onBluetoothDisconnected(function () {
basic.showIcon(IconNames.No)
})
basic.showIcon(IconNames.SmallDiamond)
bluetooth.startAccelerometerService()
bluetooth.startButtonService()
bluetooth.startLEDService()
bluetooth.startTemperatureService()
bluetooth.startMagnetometerService()
bluetooth.startIOPinService()
basic.forever(function () {
})let x = 90
pins.servoWritePin(AnalogPin.P0, x)
led.plotBarGraph(x, 180)
input.onButtonPressed(Button.A, function () {
if (x < 180) {
x += 10
pins.servoWritePin(AnalogPin.P0, x)
led.plotBarGraph(x, 180)
}
})
input.onButtonPressed(Button.B, function () {
if (x > 0) {
x -= 10
pins.servoWritePin(AnalogPin.P0, x)
led.plotBarGraph(x, 180)
}
})
input.onButtonPressed(Button.AB, function () {
x = 90
pins.servoWritePin(AnalogPin.P0, x)
led.plotBarGraph(x, 180)
})
basic.forever(function () {
})Vibe Coding & App Control
Sensing & Setup — first standup ritual, first automation logic, and Slack + Trello are introduced ahead of Hiring Day. ~2.5–3 hours.
- Register each account under a parent/guardian's email with their consent (best — mirrors a real HR-issued login)
- One adult holds all accounts, using one email alias per student from a single inbox (e.g.
yourname+asha@gmail.com)
| Time | Activity |
|---|---|
| 0:00 | Standup: each student shares what they tried at home (everyone speaks, kept short) |
| 0:15 | Build + code Edu Smart Home mini-lesson 1: Automatic Lights (NeoPixel) |
| 1:15 | Second mini-lesson if pace allows; otherwise becomes optional home content |
| 2:00 | Set up Slack + Trello accounts together; walk through channels/board |
| 2:30 | Tease Friday's goal: "Tomorrow, you get hired." Assign pre-work: think of a company name, and which station you'd want to build |
Students are required to
- Complete Slack + Trello account setup (parent email/consent — see tip above)
- Speak during standup — the shortest, lowest-stakes version of a real skill
- Come to Day 3 with a station preference in mind
What they learn — and why it matters
- Sensing-and-reacting logic — the conceptual bridge to AI-driven sorting later
- Giving a short status update — the single most repeated soft skill in real tech work
- Comfort with the tools before they carry real stakes on Day 3
What today's app needs to do
The control app the class builds today needs to support:
- Opening and closing a door via open/close buttons on a phone app
- Turning lights on/off, and switching between Red, Blue, and Green
- Changing light brightness via a slider
- A "connect to micro:bit" button in the app
- Door open/close control and NeoPixel on/off control
- A key-lock interface — one flow where a code is entered and it "unlocks"/opens
Main lesson — Vibe Coding
- Explain "vibe coding" in simple terms: coding by describing what you want to an AI, then iterating on what it gives you back — rather than writing every line by hand yourself.
- Kids use ChatGPT to vibe-code the HTML control app that connects to the micro:bit over Bluetooth UART and drives the functions listed above.
- Hand out (or demo live with) the starter prompts below — they're concrete enough to paste straight into ChatGPT and reliably get back usable HTML/JS using the Web Bluetooth UART pattern that matches the code below.
Starter prompts — hand these to kids, or use as a live demo
Note for the teacher's script — call this out explicitly, it's a fun reveal moment for the kids: the code "1397" triggers an unlock "celebration" sequence (music + a green/white flash), and "0000" is the lock/reset code.
let data = ""
let strip: neopixel.Strip = null
bluetooth.onBluetoothConnected(function () {
basic.showIcon(IconNames.Happy)
})
bluetooth.onBluetoothDisconnected(function () {
basic.showIcon(IconNames.No)
})
bluetooth.onUartDataReceived(serial.delimiters(Delimiters.NewLine), function () {
data = bluetooth.uartReadUntil(serial.delimiters(Delimiters.NewLine))
if (data == "C") {
pins.servoWritePin(AnalogPin.P0, 70)
}
if (data == "D") {
pins.servoWritePin(AnalogPin.P0, 175)
}
if (data == "R") {
strip.showColor(neopixel.colors(NeoPixelColors.Red))
strip.show()
}
if (data == "G") {
strip.showColor(neopixel.colors(NeoPixelColors.Green))
strip.show()
}
if (data == "B") {
strip.showColor(neopixel.colors(NeoPixelColors.Blue))
strip.show()
}
if (data == "W") {
strip.showColor(neopixel.colors(NeoPixelColors.White))
strip.show()
}
if (data == "OFF") {
strip.showColor(neopixel.colors(NeoPixelColors.Black))
strip.show()
}
if (data == "1397") {
pins.servoWritePin(AnalogPin.P0, 70)
music._playDefaultBackground(
music.builtInPlayableMelody(Melodies.Entertainer),
music.PlaybackMode.InBackground
)
for (let index = 0; index < 3; index++) {
strip.showColor(neopixel.colors(NeoPixelColors.Green))
strip.show()
basic.pause(200)
strip.showColor(neopixel.colors(NeoPixelColors.White))
strip.show()
basic.pause(200)
}
}
if (data == "0000") {
pins.servoWritePin(AnalogPin.P0, 175)
strip.showColor(neopixel.colors(NeoPixelColors.Black))
strip.show()
}
})
bluetooth.startUartService()
strip = neopixel.create(DigitalPin.P1, 8, NeoPixelMode.RGB)
strip.showRainbow(1, 360)
strip.show()
basic.forever(function () {
bluetooth.uartWriteValue("x", input.lightLevel())
basic.pause(50)
bluetooth.uartWriteValue("y", input.temperature())
basic.pause(50)
})Color Sorter — "The Sorting Line" Station
The flagship team build. Each student builds and codes one Color Sorter unit — a machine that uses a Teachable Machine AI model to recognize a ball's color and rolls it left or right via a servo. Individually a Beginner-level build; together, six stations become one connected factory line, each doing one filtering job before passing balls to the next station.
1. Introduce Teachable Machine
Teachable Machine is a tool that lets you train a simple AI model without writing any machine-learning code. You show it examples — pictures, sounds, or poses — sort them into labeled groups, and it learns to tell the groups apart on its own.
2. What's behind the AI, in plain terms
"When we 'train' a model, we're not writing rules like 'if it's red, it's a stop sign.' Instead, we show the computer lots of examples — 'this is red,' 'this is blue,' 'this is green' — over and over, and it slowly learns the *pattern* that makes red look like red. That's what a model is: something that's learned patterns from examples, instead of being told the rules directly."
Keep this accessible — the point isn't the math, it's the idea that a model *learns* rather than being *programmed with rules*.
3. Optional illustrative video
If it fits the flow, this video is a good visual companion to the explanation above:
4. Warm-up: training a model to recognize hand gestures
Before jumping into the color-sorting build, walk the class through training a model on hand gestures — this is the entry point that makes the AI concept concrete before it's applied to sorting balls.
- Open Teachable Machine, choose an Image Project, then a Standard image model.
- Create 2–3 classes — e.g. "Thumbs up," "Open hand," "Fist."
- For each class, hold the webcam button and show that gesture for a few seconds from a few angles — repeat for each class.
- Click Train Model, then test it live — hold up each gesture and watch the confidence bars respond.
- Bridge to the real build: "That's exactly what you'll do next — except instead of a hand gesture, you'll train it to recognize a ball's color."
Day 3 is the hinge of the whole week — the moment the bootcamp shifts from "learning" to "working." Run it as a small, sincere onboarding ritual, not just a costume change.
The ritual costs almost nothing in time (15–20 minutes) but is what makes every subsequent hour of the week land differently. Kids consistently take a "job" more seriously than a "craft project" — even when the underlying activity is identical.
| Time | Activity |
|---|---|
| 0:00 | Cold open, company mission announced |
| 0:10 | Employee Application Cards filled and submitted |
| 0:20 | "Hired" — badges/IDs issued, station assignments given |
| 0:30 | Ownership + sprint-goal briefing; Trello board walkthrough with real starter cards |
| 0:45 | Sprint 1: build station chassis, wire servo, begin training the color-recognition model |
| 2:30 | Close-out: move Trello cards, post a status line in Slack before leaving |
Students are required to
- Complete and submit an Employee Application Card
- Reach the stated sprint goal: station sorts one ball correctly by end of day
- Move their own Trello cards — not have it done for them
What they learn — and why it matters
- AI model training via Teachable Machine — their first hands-on AI concept
- Owning a deliverable — the difference between "a craft" and "my job today"
- Working from a written sprint goal — real sprint-planning, at kid scale
Employee Application
Kept deliberately lightweight — two tools, not a full engineering stack — so class time goes to building, not app-switching.
Slack channels
Trello board columns
Sample Day 3 starter cards: "Build chassis," "Wire servo," "Train color model," "Connect via Bluetooth."
The realism payoff: individual stations become one physically connected factory line. ~2.5–3 hours.
| Time | Activity |
|---|---|
| 0:00 | Standup: status of each station, blockers named out loud |
| 0:15 | Finish individual station wiring/coding; build cardboard connector chutes between stations |
| 1:15 | Arrange stations on a stepped surface so balls flow by gravity from one station to the next |
| 1:45 | Integration testing: rotate a "QA" role — a student tests a teammate's station and files bugs as Trello cards in #qa |
| 2:30 | Fix critical bugs found; assign final touch-ups for tomorrow's demo |
Students are required to
- QA-test a teammate's station and file at least one clear bug report
- Fix any bug filed against their own station
- Help physically connect their station to its neighbor's chute
What they learn — and why it matters
- Integration testing — a ball only reaches the right bin if every upstream station worked
- Writing a clear bug report — a real, transferable engineering skill
- Debugging someone else's work respectfully — a genuine team soft skill
Presentation — "Ship It"
Final polish, then the company presents. ~2.5–3 hours (may extend slightly for the parent demo slot).
| Time | Activity |
|---|---|
| 0:00 | Final polish window; full line rehearsal run without parents present |
| 1:00 | Pitch deck prep — each student prepares 2–3 spoken lines about their own station |
| 1:30 | Parents arrive; company briefing recap for the audience |
| 1:40 | Live demo: full Sorting Line runs, ball travels the whole line |
| 2:00 | Each "department" (student) gives a short pitch: what I built, what broke, how I fixed it |
| 2:20 | Certificates / employee recognition; stations packed up to take home |
Students are required to
- Speak for at least 30–60 seconds about their own station, unscripted or lightly scripted
- Have their station demo-ready and disconnected/packed to take home
What they learn — and why it matters
- Presenting your own work — arguably the most useful single soft skill in the whole week
- Talking about failure calmly — "what broke, how I fixed it" normalizes debugging as part of the job, not a shameful mistake
- A finished, owned artifact — the take-home robot as proof of a week's real work
Kids build a small presentation framework today — a simple structure for what to say and show when presenting their project: what they built, what it does, what they learned. Hand out or project the fill-in-the-blank template below rather than writing a long script — let each student's own voice fill it in.
"You don't need to memorize anything. Just fill in these blanks in your own words, and when it's your turn, read them like you're telling a friend about something you're proud of."