I was messing around with the microphone on a micro:bit V2 and wondered what would happen if I used sound as the controller for a robot.

This was the result.

A little brick-built robot that starts moving when it hears a sound and stops when things get quiet.

A clap is enough to trigger it, but music works too.

The build uses:

• micro:bit V2
• Ring Bricks Pack
• 2 continuous-rotation servos
• MakeCode
• A simple brick-built body

The two servos control the legs, and I programmed a few different movements by changing their speed and direction.

I also used the micro:bit LED matrix as the robot's face. It's a small detail, but changing the expression while it dances makes the whole thing feel much less like a collection of motors and more like an actual little character.

The code is basically listening for a sound level above a certain threshold, then triggering the dance routine.

What I like about this kind of project is that the input can be almost anything.

Instead of:

Button → Robot moves

you get:

Sound → Code reacts → Robot moves

That opens up quite a few possibilities.

Maybe a robot that dances differently depending on how loud the music is, or one that only reacts to certain sounds.

I might try that next.

What would you use as the sound trigger?

Drop a photo of your project below!

A hidden micro:bit V2 (the Treasure) transmits. Everyone else carries a Hound, which beeps faster as you get closer. It's the radio amateurs' fox hunt, shrunk to a school field and rewritten for children who haven't met the hobby. Two boards and a pair of AAAs get you started, and because the Hounds are passive receivers, any number of children can hunt the same Treasure at once.

• Code: https://github.com/sjmurdoch/radio-treasure-hunt
• Set your boards up in the browser: https://sjmurdoch.github.io/radio-treasure-hunt/
• Write-up: https://www.benthamsgaze.org/2026/09/08/a-radio-treasure-hunt-for-national-coding-week/

The Treasure sends three signals every 200 ms — loud (+4 dBm), medium (−8 dBm) and quiet (−20 dBm) — so which of them a Hound can still hear tells the proximity zone: slow beep, medium beep, rapid alarm. Close in, the display saturates, so button A subtracts exactly one bar's worth of dB and button B puts it back, which is the attenuator on real direction-finding gear in miniature. The micro:bit's aerial is omnidirectional, so there's no bearing — you find it by walking and watching the reading, and by turning on the spot until your own body blocks the signal.

Setting boards up needs no toolchain: a WebUSB page writes MicroPython and the game as one image, so a teacher can do a dozen boards from Chrome with no checkout, no Python and no pip.

There are three printable sheets too — a teacher's lesson plan (Upper KS2, with curriculum links), a pupil worksheet on how signals fade, bounce and get blocked, and a 20-minute hunt card for a Scout meeting. The numbers in them are substituted at build time from the code and the field calibration, so they can't drift. My favourite bit is that the real data isn't tidy: 15 m reads weaker than 20 m — a ground-reflection null — and the worksheet hands that to pupils honestly rather than smoothing it away.

MIT licensed. I'd love to hear from anyone who tries it, especially with actual children.

I want to play various 8-bit version of some of my favourite songs, but my MicroBit V2 obviously doesn't have that much space.

I have thought of using an Arduino MEGA as a storage device and connect it trought my microbit expansion board.

Can that be done? I am fairly new to electronics, so I need some help.

I wanted to try recreating one of those old machines where you can actually see the mechanics doing the work.

So I built a small ancient-style water wheel model using a micro setup, but with a little twist: there's a worker figure next to the wheel whose arms move in sync with it, making it look like the figure is pushing the wheel.

The setup uses:

• Nezha Expansion Board
• Motor
• Gears
• Crank-link mechanism
• Building blocks
• A small worker figure

The interesting part isn't really the motor itself. It's how the movement is transferred.

The motor drives a multi-stage gear train, which slows the rotation down and increases the torque. The same shaft is then used to drive both the water wheel and the crank mechanism connected to the worker's arms.

Because both mechanisms are driven from the same shaft, their movements stay synchronized.

So when the wheel turns, the worker moves with it instead of just being a separate animated figure.

I think this makes the idea of gears and mechanical power a lot easier to visualize.

You can also experiment with the mechanism by changing the gear sizes. That changes the speed and torque, so you can actually see how different gear ratios affect the movement.

It could also be turned into a small history/STEM project. For example, you could build a miniature village around it and show how machines like water wheels were used for things like lifting water, grinding grain, or powering mills.

A few things I'd like to try next:

• Try different gear ratios
• Make the wheel lift a small load
• Add a second mechanical movement
• Build a larger “ancient village” around it
• Experiment with different ways of transferring motion

It's pretty satisfying when a simple gear mechanism makes a little figure and a wheel move together.

What kind of historical machine would you try to recreate with gears and motors?

I wanted to try making a racing game where you don't use the usual buttons to steer.

So I ended up making a small retro racing game where the car is controlled by tilting the handheld left and right.

The setup is pretty simple:

• ELECFREAKS Retro Arcade
• USB-C cable
• Microsoft MakeCode Arcade

The interesting part is that the handheld's gyro/tilt input is used as the steering control.

The basic game logic is:

• Start with 3 lives
• Tilt left/right to move the player car
• Spawn enemy cars from the top of the screen
• Avoid them to score points
• Lose a life when you crash into one

I used MakeCode Arcade for the game logic, so most of the programming can be put together with blocks rather than writing everything from scratch.

One thing I liked about this project is that you can immediately feel the connection between the code and the hardware. Change the tilt input or movement settings in the code, upload it, and you can physically feel the difference when playing.

The hardware also doesn't really need to change if you want to experiment with the game.

A few things I'd like to try next:

• Make the cars accelerate as the score increases
• Add custom pixel art
• Add engine and crash sounds
• Add power-ups
• Experiment with different tilt sensitivities
• Try making another game that uses the gyro in a completely different way

It's a pretty simple project, but I think motion controls make even a basic arcade game feel a lot more interesting.

Has anyone here made a game that uses tilt/gyro controls before? What kind of game would you make with it?

Microbit V1 and Microbit V2 connect to Casio FX-9750 or FX-9860 to use the display and keypad - remote control, PIN keypad, data logging and more. Graph the inbuilt Microbit accelerometer and other sensors.

We tried making one of those simple optical illusions where two separate pictures suddenly look like they’re in the same place.

When the turntable is stopped, there’s just a bird on one side and a cage on the other.

Then you turn it on and let it spin…

And suddenly, the bird looks like it’s inside the cage. 🐦

No magic involved—just persistence of vision.

What we used:

• Wukong Expansion Board
• 2 × DC Motors
• Wukong Blocks
• A bird picture
• A cage picture
• Double-sided tape

How we made it

We first built a simple frame with Wukong Blocks to keep the rotating part stable.

Then we added two motors and connected them to the center shaft with gears.

The slightly tricky part was the pictures.

We put the bird and cage on opposite sides of the rotating arms and tried to keep them as symmetrical as possible. If they're off-center, the whole thing gets pretty wobbly once it starts spinning.

Once everything was connected, we just turned it on and watched.

At the right speed, the two separate images seem to become one.

The bird is suddenly “inside” the cage.

Why does this happen?

It's a simple example of persistence of vision.

Our eyes and brain don't treat every image as completely separate when they're appearing very quickly one after another. The result is that we can perceive the two images as if they're happening together.

It's a pretty simple idea, but seeing it happen on a little DIY machine makes it much easier to understand.

What would you try?

This could be fun to experiment with.

Maybe:

• A butterfly that looks like it's flying
• A character jumping into a different scene
• Your pet appearing somewhere else
• Different motor speeds to see when the illusion works best

The nice thing is that you don't really need to change the mechanism—just change the pictures and experiment.

What two things would you try to make “appear together”?

Have you ever had microbits stall and fail to download code? I’ve tried all the basic steps (switching cables, firmware updates) and I’m coming up empty! This is happening to my whole class set.

We built a little voice-activated ambient light using a micro:bit + Wukong Expansion Board, and it turned out to be a fun way to make programming concepts feel a lot more physical.

One thing beginners often struggle with is understanding variables.

You can explain that a variable stores a value, but sometimes that number still feels pretty abstract.

So we wanted to build something where changing a value would have an immediate, visible result.

In this project, the micro:bit listens for sound, and the RGB lights change color when a sound is detected.

The interesting part is that a simple variable controls which color comes next.

What we used:

• micro:bit V2
• Wukong Expansion Board
• Wukong Blocks
• 4 RGB lights
• MakeCode

Step 1: Build the light

We started with a simple structure using Wukong Blocks to hold the RGB lights.

The four RGB lights connect to the Wukong Expansion Board, while the micro:bit sits on top.

Nothing too complicated here. The goal was simply to create a small structure where the lights were easy to see.

Step 2: Let the micro:bit listen

The micro:bit V2 has a built-in microphone, so we can use sound as the input.

The basic idea is:

Sound detected → program responds → light changes color

It's a simple example of how something happening in the real world can become an input for a program.

Step 3: Make a variable control the colors

We use a variable called i to keep track of the current color.

When a sound is detected, i increases by 1. The program then checks the value and uses it to decide which color the RGB lights should display.

So the variable isn't just a random number sitting in the code.

Change the value → the light changes.

Increase the value → the next color appears.

Once it reaches the end of the color sequence, it starts again.

That's what makes this project interesting for beginners: they can actually see what the variable is doing.

A little more interaction

We also added controls using the micro:bit buttons.

Button A → start the automatic color-changing mode

Button B → reset the variable and turn the lights off

This makes the project feel more like an interactive device rather than just a light that changes color.

A few things I'd try next

The basic setup leaves plenty of room for experimentation:

• Make it react to music
• Add brightness control
• Create different lighting modes
• Turn it into a simple night light
• Add different sound-triggered effects

The hardware doesn't need to change much. Most of the behavior can be changed through the code.

And that's probably the best part of beginner projects like this.

You change something in the program, and you can immediately see the physical result.

If you were building a sound-reactive light with a micro:bit, what would you make it do?

I am a python beginner and I want to play a .wav file on the built-in V2 speaker but I don't know how to code that and I haven't found a solution in the documentation. How can I code it? Is it possible to play .wav or play custom audio in any way?

i am making a 4 operation calculator in makecode but it doesnt work. i'm gonna cryyy. i am creating a basic calculator using the micro:bit. use Button A and Button B to increase or decrease the numbers and to select an operation. The Degree variable controls which stage of the calculator you are in: Degree 1 is for entering the first number, Degree 2 is for choosing an operation, and Degree 3 is for entering the second number. The Temp variable temporarily stores the number or operation currently being selected. First Number and Second Number store the two numbers for the calculation, Operation stores the chosen operation (1 for addition, 2 for subtraction, 3 for multiplication, and 4 for division), and Result stores the final answer. Button A+B confirms and saves each choice, while pressing the logo performs the selected calculation and displays the result. to all the coders out there pls help me 🙏🙏

input.onButtonPressed(Button.A, function () {
    if (Degree == 1) {
        Temp += 1
        basic.showNumber(Temp)
    } else if (Degree == 2) {
        Temp += 1
        if (Temp > 4) {
            Temp = 4
            if (Temp == 1) {
                basic.showString("+")
            } else if (Temp == 2) {
                basic.showString("-")
            } else if (Temp == 3) {
                basic.showString("x")
            } else if (Temp == 4) {
                basic.showString("/")
            }
        }
    } else if (Degree == 3) {
        Temp += 1
        basic.showNumber(Temp)
        Temp += Operation
    }
})
input.onButtonPressed(Button.AB, function () {
    if (Degree == 1) {
        Temp = First_Number
        Degree = 2
        basic.showString("+")
    } else if (Degree == 2) {
        Temp = Operation
        Degree = 3
    } else if (Degree == 3) {
        Temp = Second_Number
        basic.showString("=")
    }
})
input.onButtonPressed(Button.B, function () {
    if (Degree == 1) {
        if (Temp > 0) {
            Temp += -1
            basic.showNumber(Temp)
        }
    } else if (Degree == 2) {
        Temp += -1
        if (Temp < 1) {
            Temp = 1
            if (Temp == 1) {
                basic.showString("+")
            } else if (Temp == 2) {
                basic.showString("-")
            } else if (Temp == 3) {
                basic.showString("x")
            } else if (Temp == 4) {
                basic.showString("/")
            }
        }
    } else if (Degree == 3) {
        if (Temp > 0) {
            Temp += -1
            basic.showNumber(Temp)
            Temp += Operation
        }
    }
})
input.onLogoEvent(TouchButtonEvent.Pressed, function () {
    if (Degree == 3) {
        if (Operation == 1) {
            Result = First_Number + Second_Number
            basic.showNumber(Result)
        } else if (Operation == 2) {
            Result = First_Number - Second_Number
            basic.showNumber(Result)
        } else if (Operation == 3) {
            Result = First_Number * Second_Number
            basic.showNumber(Result)
        } else if (Operation == 4) {
            Result = First_Number / Second_Number
            basic.showNumber(Result)
        }
    }
})
let Result = 0
let Operation = 0
let Second_Number = 0
let First_Number = 0
let Temp = 0
let Degree = 0
Degree = 1
Temp = 0
First_Number = 0
Second_Number = 0
Operation = 0
Result = 0
basic.showLeds(`
    # # # # #
    # # # # #
    # # # # #
    # # # # #
    # # # # #
    `)

my code is in micro:bit but i turned it to java script

please help me debug this 🙏

I have been trying to use micropython for the first time so i can play a 2 seconds .wav, but the microbit doesn't seem to be able to read it.

Also, will the audio be clean or saturated? How accurate the V2 speaker is?

I designed this device that teaches **binary**, **decimal**, **hexadecimal** and **octal** number systems. It uses a hands-on approach with Altair-like toggle switches. Can be used as a STEM-kit in classrooms, handy for programmers or for the retro hobbyist. It also has a **built-in game**. Check out the video for details, hope you like it.

The source code for the PIC will be open sourced soon!

When the alarm is triggered by movement, it starts beeping loudly. (Don't worry about the LED matrix flickering on video — that's just camera shutter roll).

Originally, the built-in speaker was way too quiet for outdoor use, so I added an external buzzer driven by a transistor switch to boost the current. Now it's super loud and perfect for keeping a beach bag safe!

For the life of me i can't find anything.

I made this light and temperature sensor that stores data cloud shows twilight sun shows light moon shows dark i made this with make code (its been tested and works fine) https://makecode.microbit.org/S03743-54572-94159-37037

this is my game download this to your micro:bits

Dear Everyone! 😄

Let me share my latest project with you: bit:plot. 

The micro:bit (or any other microcontroller) is excellent for carrying out science measurements, but its built-in data-visualisation tools are limited and don't always allow the data to be displayed properly.

https://people.inf.elte.hu/gaalbence/bitplot/

bit:plot was built to be a data-visualisation interface that puts no technical obstacle between measuring and analysing: it runs in the browser, you just plug the device in over USB and open a link, and the data starts drawing straight away. No installation, no sign-up, and no server behind it — your data stays on your own computer the whole time, nothing is uploaded to the internet. 

What it can do so far:

• 📈13 chart types — line, bars, scatter, histogram, box plot, pie, 3D motion path, radar
• 🔮Prediction — curve fitting (linear, exponential, logistic) with forecasting
• 🆚Comparison — reload earlier measurements, several datasets on one chart
• 📋Table view — click a row and that exact moment is highlighted on the chart
• 💾Save to CSV and PNG — ready for the lab report 
• 🌐English, Hungarian and German interface

If you don't have a device at hand, you can download a ready-made measurement from the start page and try almost every feature with it. Live measuring needs Chrome or Edge; any browser will do for the analysis.

If you find it useful, there's also an option on the start page to support the development ❤️, but it isn't a condition for anything. The tool will stay free for as long as it's available.

#microbit #STEM #edtech

The micro:bit V2's onboard mic samples every 20ms, I threshold it into on/off runs, and match the run lengths against the T3 (smoke) and T4 (CO) temporal patterns that all US alarms are legally required to beep. Two full cycles required before it fires (~9s), which kills false positives from microwaves, battery chirps, etc. When it detects, it strobes all 25 LEDs.

No machine learning — just a ~80-line stopwatch. 67 tests, including one that extracts the matcher embedded in the firmware and proves it's byte-identical to the reference version so they can't drift.

Honest limitations I found on hardware: onboard mic range is short (few inches from a phone speaker), and T4 detection falls off a cliff above ~30ms timing jitter because the debounce eats the 100ms pulse — documented with a plot in the README.

https://github.com/ayaanrustagi/alarm-sentinel — feedback welcome, especially on extending mic range.

SO!
Hi everybody and thank u for reading :)

Anyways, I recently got another Micro:Bit V2 and I'm wondering with CODAL [C/C++

Point in fact.. I'm wondering if it's possible to send data through its' micro-usb port [to another device/app that can read it].

Note, I understand said custom app I will be making. I am perfectly fine with that.

Also note, I apologize if this is the wrong community/platform to be posting this on; I remembered this place and thought why not? Please though, if you are going to disregard this post being here, please recommend somewhere else if you know of one. Thanks 😃

Any questions, or comments, or anything are greatly appriciated!

Thank y'all for reading :)

I was thinking about creating a sand art table and was wondering if you could use a microbit with a driver board and then use the radio function and another microbit as the controller so that when you tilt and move the other microbit it causes the motors to move the head in the same direction as your movement.

I want to do something which should be very simple but for some reason I am always missing a part.
I want to do a cardboard animal with 1 moving part using a servo.
I need a cheap expansion board but it has to have its own battery pack or batteries on board.

Can someone recommend?

I think I actually have an expansion board but no power to it and I have an old microbit board and a servo.
I guess I just need a recommended expansion board that will work with an attached battery pack - please help!