Found it randomly on friend house and decided to have fun with it. It has 5*5 grid led metrix, using its internal accelerometer, i created a sand simulator. It's bit slow and refresh is visible.

A while ago, I recreated the entirety of FNAF 1 within the Makecode editor, so now I want to do something more complex and original, a metroidvania-ish platformer game! I have no idea how this project is going to turn out but I'll explain the technical details in the engine showcase within the video:

• First, the entire game is set up. An array contains coordinates and level data for the renderer and player logic to gather info from

• Player logic is calculated. Since this doesn't depend on the renderer, it can be done before the screen deletes itself

• The micro:bit then deletes and redraws the level chunk every tick. Solid tiles plot with brightness 10. It also plots the player at max brightness

• Yes the way the level between screens is strange but it's worth it. I have attempted to make a scrolling platformer and trust me I can't do it for my life. I'll add a fade-in and out transition to give the player some time to react

My main goal is to make a fully fledged video game entirely compatible within one micro:bit v2. No accessories, no fancy arduino stuff. If you got any suggestions, please drop them in the comments. Thanks for reading! :)

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?

Students should get to experience a machine learning model first-hand. Such as shown here, use an AI-enabled lens, supported with LEGO Education modules and powered by micro: bit. Such a system can be trained to recognise a specific object, with real-time audio feedback giving a direct window into the model's current confidence level. This process culminates in a physical action, such as launching a paper aeroplane.

These hands-on experiences offer a tangible way to move beyond abstract concepts and into the core principles of artificial intelligence. By giving students the chance to interact with these systems, they gain a clearer understanding of machine perception and inference.

Tried to integrate Micro:bit on my web app. Just have problem on making the rotation smooth because the readings from the sensors accelerometer isn't smooth.

The school ran a hands-on STEM session where students built simple launch platforms using micro:bit, AI camera, sensors, and modular parts. They folded their own paper planes, attached them to the launcher, and used basic code. By learning the recognition system functions of AI cameras, they created a fascinating tutorial study.

I wanted to see if I could make a little humanoid robot move around without using wheels, so I built this two-legged bot with a Ring Bricks Pack, two micro:bit, and a joystick gamepad.

The fun part is that the robot is controlled wirelessly by a second micro:bit. No phone, Wi-Fi, or custom motor driver needed.

Here’s how the controls work:

• Push the joystick forward or backward → the robot waddles in that direction.

• Push it left or right → the robot spins to turn.

• Release the joystick → it stops moving.

The robot uses two continuous-rotation servos as its hip joints. By changing the direction and speed of each servo, the legs move in different patterns to create forward and backward movement or a turn.

The wireless side is pretty simple, too. The remote reads the joystick position and sends a number over the micro:bit radio. The robot receives that number and calls the corresponding movement function. When the joystick returns to the center, it receives a stop command.

I like this build because it brings together a few different ideas in one project: walking mechanisms, wireless communication, and real-time control. And since both programs are made with MakeCode blocks, it’s easy to experiment with the movement logic.

Next, I’d like to try adding an ultrasonic sensor so it can react to obstacles, or maybe give it different walking speeds.

What would you add to a tiny joystick-controlled robot like this?

Music: Plok - House

I just made a demo featuring the ELECFREAKS Nezha control board paired with their AI camera, and it’s a pretty solid setup for anyone interested in beginner-to-intermediate AI vision projects.

In the video, the AI camera handles on-device vision tasks (like recognition and tracking), while the Nezha control board takes care of motion control and logic. The two communicate smoothly, making it easy to turn visual input into real-world actions. This kind of separation—AI processing on the camera, control on the board—feels very practical for robotics and smart-device projects.

Overall, it could be especially useful for STEM education or rapid prototyping.

CPU

nRF52833 @ 64MHz vs ESP32 @ 240 MHz

RAM

128kb vs 520kb (SRAM) + 8Mb (PSRAM)

FLASH

512kb vs 16Mb

LED

5x5 red vs 5x5 RGB

Wireless

BT 5.0 vs WiFi 2.4Ghz + BT 4.2

Hi all, I made a micro:bit based escape room activity for a scout camp, which I’ve made a video about (see link above!)

It uses 8 micro:bits, with a few extra accessories (including a giant red button!), some laser cut boxes and a few DIY cardboard constructions. The idea was to show the kids how versatile the micro:bit can be, and to hopefully inspire them to have a go at using it to build their own puzzles.

All the source code and designs are up on GitHub, if you'd like to dig into the details or have a go at reproducing the activity: https://github.com/brggs/Fix-The-SpaceShip-Escape-Room

Look at this little beast! 🌃🕹️

Coded a quick side-scrolling defender game in MakeCode Arcade on my laptop (blocks for now, but Python mode is tempting), flashed it straight to the ELECFREAKS Retro Arcade handheld, and boom — my tiny pixel hero is blasting baddies while the city skyline chills in the background.

The victory screen popped up with "We are safe!" and I genuinely felt like I'd saved the day lol. The screen is surprisingly crisp for its size, the d-pad + A/B buttons feel solid, and being able to iterate code → play in under a minute is addicting.

It's marketed for kids/STEM, but honestly this thing scratches such a perfect retro + maker itch for adults too. Nostalgia hits different when *you* wrote the game.

Questions for anyone who's played with MakeCode Arcade hardware (this, micro:bit shields, or others):

- What's the coolest/most ridiculous game you've actually finished and loaded onto one of these?

- How far have you pushed the Retro Arcade's sensors/tilt/whatever in a game? Any hidden gems?

- Block coding vs. JavaScript/Python — which do you prefer for quick prototypes like this?

- Worth the price for hobbyists, or better as a pure edu tool?

Would love to see what other people are creating — drop screenshots, share projects, roast my simple city-saver, whatever 😂

#MakeCode #MakeCodeArcade #RetroGaming #STEM #microbit #gamedev

If the ultrasonic sensor detects a distance in the range of 9~10, it plays the tone Middle C;

If the distance is in 11~12, it plays Middle D;

If the distance is in 13~14, it plays Middle E;

If the distance is in 15~16, it plays Middle F;

If the distance is in 17~18, it plays Middle G;

If the distance is in 19~20, it plays Middle A;

If the distance is in 20~21, it plays Middle B.

I was thinking about one of those small problems that happens all the time when kids are studying: they slowly move closer and closer to the book or screen without even noticing.

Instead of reminding them every few minutes, I thought it would be more interesting to build a little device that could detect the distance automatically.

So I made this simple distance warning system with a micro:bit.

The setup uses:

• micro:bit

• Nezha Innovation Kit

• Ultrasonic distance sensor

• Red and green LEDs

• MakeCode

The idea is pretty straightforward.

The ultrasonic sensor continuously measures the distance in front of the device.

If the distance gets below the threshold I set:

Too close → red light

Move back far enough:

Safe distance → green light

There's no complicated interface or screen. Just a simple visual signal that tells you when you've moved too close.

I think this is a nice example of how a sensor can turn something that's normally difficult to notice into an input that a program can react to.

The coding is also pretty simple in MakeCode:

1. Read the distance from the ultrasonic sensor

2. Compare it with a preset value

3. Turn on the appropriate LED

4. Keep checking the distance

What I like about projects like this is that the final result isn't just something that moves or lights up for the sake of it. It solves a small everyday problem while also introducing concepts like sensors, conditions, and real-time feedback.

There are quite a few ways to extend it too:

• Add a buzzer when you're too close

• Use different warning levels

• Display the distance on the micro:bit

• Track how often the warning is triggered

• Add a timer for study breaks

• Make the warning gradually more noticeable if you stay too close

It's a simple project, but it made me wonder how many other everyday annoyances could be turned into small sensor-based projects.

What everyday problem would you try to solve with a micro:bit?

Hey r/microbit community! 👋

I just wrapped up Case 12: Voice-Controlled Fan from the Elecfreaks Nezha Pro AI Mechanical Power Kit. The kids were absolutely hooked — it's the perfect blend of mechanical building, sensor integration, programming logic, and real-world "smart home" tech. Voice commands controlling a fan? Instant engagement!

I wanted to share a complete, ready-to-use lesson plan with detailed learning steps so other teachers (or parents/hobbyists) can run this exact project. Everything below is pulled straight from the official Elecfreaks wiki Case 12 page, adapted for classroom pacing (2–3 class periods of 45–60 minutes each). I'll include objectives, materials, assembly notes, hardware connections, programming walkthrough, testing/debugging, discussion prompts, and extensions.

🛠️ Project Overview & Story Hook

Students build a voice-controlled fan that responds to spoken commands for on/off, speed adjustment (levels 1–? ), and oscillation (left-right swing).

Story intro for kids (great for engagement):

"It’s a scorching day on an alien planet. The 'Fengyu Fan' only works by voice commands — but the wiring is loose! Fix it before everyone overheats!"

🎯 Teaching Objectives (what students will master)

1. Assemble the fan module, oscillation mechanism, and voice recognition sensor.

2. Understand how the voice sensor receives → parses → triggers actions.

3. Program the micro:bit to map specific voice commands to fan behaviors.

4. Debug voice recognition accuracy and fan performance.

5. Discuss real-world voice tech (smart speakers, noise reduction, etc.).

📦 Materials (per group)

- Nezha Pro AI Mechanical Power Kit (includes fan module, smart motor, oscillation parts, voice recognition sensor, Nezha Pro expansion board, micro:bit V2)

- USB cable for programming

- Computer with internet (for MakeCode)

Step-by-Step Learning Sequence

Day 1 – Exploration & Assembly (45–60 min)

1. Introduce the challenge (10 min): Read the story hook aloud. Ask: "What would make a fan 'smart'?" Show the wiki demo video if you have it.

2. Hardware connections (15 min):

   - Voice recognition sensor → IIC interface on the Nezha Pro expansion board

   - Smart motor → M2 interface

   - Fan module → J1 interface

   (Super simple plug-and-play — no soldering!)

3. Build the mechanical fan (20–30 min):

   - Use the Nezha Pro kit’s modular building blocks to construct the fan base, blades, and oscillation (swing) mechanism.

   - Tip: Follow the kit’s visual instructions for the fan/oscillation sub-assemblies first, then mount the voice sensor at the front so it can “hear” clearly.

Day 2 – Programming & Coding Logic (45–60 min)

1. Set up MakeCode (5 min):

   - Go to makecode.microbit.org → New Project

   - Add Extensions: Search and add “nezha pro” + “PlanetX” (both required for the voice sensor and motor/fan blocks).

2. Core programming steps (detailed block-by-block logic):

   - On start: Initialize the voice recognition sensor (set to command-list mode) and set default fan state (off, speed = 1).

   - Use voice command event blocks (from the PlanetX or Nezha Pro library) to listen continuously.

   - Map each command to actions:

- “Start device” / “Turn on the fan” → Fan on at speed 1

- “Turn off device” / “Turn off the fan” → Fan off

- “Raise a level” → Increase speed by 1

- “Lower a level” → Decrease speed by 1

- “Keep going” → Start oscillation (swing mode)

- “Pause” → Stop oscillation

- Add a forever loop to keep checking the voice sensor and update motor/fan states in real time.

- (Pro tip: The sample program is here if you want the exact blocks: https://makecode.microbit.org/_Uhz0mRDaV1Cy — download and tweak it with your class!)

3. Download & flash (10 min): Connect micro:bit, select BBC micro:bit CMSIS-DAP, and download.

Day 3 – Testing, Debugging & Reflection (45 min)

1. Power on and test all six voice commands in a quiet room first.

2. Debugging challenges (hands-on!):

   - Voice not recognized? → Check wiring, speak louder/clearer, shorten commands, or adjust sensor sensitivity in code.

   - Fan speed too fast/slow? → Tweak the speed parameter blocks.

   - Oscillation jittery? → Check mechanical alignment.

3. Learning Exploration Discussion (15–20 min):

   - In what environments does voice recognition work best? How can you improve it in noisy classrooms

   -How does the sensor “distinguish” similar commands?

   -Compare voice control vs. buttons/remote — when is voice better?

   -Extended knowledge: Explain how real smart speakers use noise-reduction algorithms and internet connectivity.

✅ Assessment & Differentiation

Beginner: Use the sample program as-is and just test commands.

Advanced: Add new custom commands (e.g., “fan speed 3”) or integrate a temperature sensor to auto-turn on when it’s hot.

Rubric ideas: Successful assembly (20%), working code for all commands (40%), debugging log (20%), reflection paragraph (20%).

One student yelled, “Turn on the fan!” so loud that the whole room cheered when it worked. It really drove home how voice AI is already in our homes.

Has anyone else run this case or similar voice projects? Any tips for noisy classrooms or ways to extend it further? I’d love feedback or your own student photos/videos!

Happy coding!

Also this is a music production software. It functions surprisingly well for a prototype, all of this code is somehow being actually worth it. I am having REALLY ambitious goals with this thing and so far it's all going great so it might not be that difficult to do the stuff I want

Finally finished my first game in Space Invaders. Coded it whole in Python.

Github repo: https://github.com/AdamBures/MICROBIT-PYTHON/tree/master/Space%20Invaders

Game: https://makecode.microbit.org/_FDUXPYLpF0U3

I wanted to try turning a simple smart-home idea into a small physical model, so I built this miniature garage with a micro:bit and Nezha Innovation Kit.

Instead of using a button to control it, I added an ultrasonic sensor at the entrance. When a little toy car gets close enough, the system detects the distance and changes the garage from “closed” to “open.”

The logic is pretty simple:

🚗 Car approaches → ultrasonic sensor detects it
🟢 Green light → garage is “open”
⏱️ Wait a few seconds
🔴 Red light → garage is “closed” again

The micro:bit handles the logic in MakeCode, while the sensor provides the input and the LEDs give a quick visual indication of what the system is doing.

What I like about this kind of project is that the code is actually connected to something physical. You can change the trigger distance, timing, add a manual override, or even add another sensor and make the model behave more like a real automated system.

It started as a tiny garage model, but it got me thinking about how many everyday objects could be turned into little sensor-controlled systems.

What everyday automation would you try to build as a miniature model?

Built a small rover using a robotics kit and decided to test how well it could detect edges. The video shows it rolling right up to the countertop drop-off while its sensors and makeshift stabilizers try to keep it from committing accidental robot self-destruction.

It’s a messy bundle of gears, wires, and optimism, but watching it inch toward the edge was oddly suspenseful. Still tuning the sensors and wheel alignment, but I’m impressed it didn’t immediately dive off the table.

Any tips for improving cliff detection or stabilizing lightweight bots like this?

Hey there! I’ve created a lot of micro:bit based projects for educational purposes through the company I work at. These all use the micro:bit + Bit Board that we launched at the end of 2020, but there are other ways of connecting things as well. (We always like to say that you don’t have to buy things from us, but if you do, we can keep making and sharing projects, curriculum, and code.)

(Oh, the Bit Board is a LEGO compatible breakout board for the micro:bit, and part of the “Crazy Circuits” system for education.)

Each project will have a link to MakeCode so you can use the code however you want, as well as connection diagrams and occasionally some deeper dives into certain concepts. We make this stuff for educators but of course anyone can use it. :)

https://browndoggadgets.dozuki.com/c/MicroBit_Projects