Before we start building anything, let’s talk about the sensors — because honestly, this is what makes this kit special. The ELECFREAKS Nezha Pro AI Mechanical Power Kit comes with 8 PlanetX sensors, all designed to be plug-and-play using RJ11 connectors. No soldering, no complex wiring — just connect them to the correct port, and you’re ready to go.

🤚 Gesture Sensor

This sensor can recognize 9 different hand gestures — up, down, left, right, forward, backward, clockwise, counterclockwise, and wave. It works using infrared light. The sensor continuously emits IR signals, and as your hand moves in front of it, the reflected light pattern changes. An onboard processor analyzes these changes and converts them into gesture data. For best results, keep your hand about 5–15 cm away. Too close can overwhelm the sensor, and too far reduces accuracy.

🎙️ Speech Recognition Sensor

This is one of the most impressive modules in the kit. It performs offline voice recognition, meaning everything runs directly on the sensor — no internet required. It comes preloaded with 21 English commands such as “full speed ahead,” “turn left,” and “avoid object.” The sensor analyzes your voice, converts it into frequency patterns, and matches it with stored templates.

For best performance:

1. Speak clearly
2. Stay within ~50 cm
3. Avoid noisy environments

📡 Ultrasonic Sensor

This sensor measures distance using sound waves, similar to how bats navigate. It emits a 40 kHz ultrasonic pulse and measures how long it takes for the echo to return. From this, it calculates distance using:

Distance = (Echo Time × Speed of Sound) ÷ 2

It can detect objects from about 2 cm to 4 meters, making it perfect for obstacle avoidance.

⬛ Line Tracking Sensor

This sensor uses infrared light to detect surface contrast.

1. White surfaces reflect more IR → high signal
2. Black surfaces absorb IR → low signal

By comparing left and right readings, the robot can detect its position relative to a line and continuously adjust its movement. This process happens rapidly, allowing smooth and accurate line following.

💥 Crash Sensor

A simple but practical sensor — essentially a mechanical switch. When the robot physically bumps into something, the sensor is triggered and sends a signal. It works well as a backup safety system or as a trigger for specific actions.

🌈 LED Rainbow

An RGB LED ring that can display multiple colors and animations.

You can use it to:

1. Indicate sensor states
2. Create visual effects
3. Build interactive lighting systems

🖥️ OLED Display

A small screen used to display real-time data such as:

1. Sensor readings
2. Commands
3. Debug information

While not used in the default builds, it’s extremely useful for understanding and debugging your system.

💨 Motor Fan

A simple actuator used to demonstrate output control. It responds to commands (like voice input) and is a great example of how sensors can control real-world devices — similar to smart home systems.

Now that you understand how each sensor works, we’re ready to move on to the fun part — building. We’ll start with a simple gesture-controlled robot, then move into voice control, and finally combine multiple sensors into a fully interactive system.

Now that you understand the sensors, there’s one more important piece before we start building — the board that connects everything together. Meet the Nezha Pro Expansion Board. Think of it like this that the micro:bit is the brain — it runs your code and makes decisions & the Nezha Pro board is the control center — it powers motors, connects sensors, and manages everything safely

The micro:bit alone can’t drive motors or handle multiple sensors efficiently. This board sits in between and makes the entire system work smoothly. Every build in this project depends on it — so understanding it now will save you a lot of confusion later. At first glance, the board might look confusing — lots of ports, lots of labels. But once you break it down, it’s actually very simple.

Motor Ports (M1, M2, M3, M4)

These ports are used to connect motors. Whenever your code says something like “run motor M1 at 50% speed”, this is where that command is sent. The connectors are RJ11 type, so they snap in easily and can’t be inserted incorrectly.

IIC Port (I2C Communication)

This is used for smart sensors like: Gesture sensor, Voice recognition modul, etc. IIC allows multiple devices to share the same communication line, so you don’t need separate ports for each advanced sensor. In this project, whenever you see “connect to IIC” — this is the port.

J1 & J2 Ports

These are for simpler sensors that use basic signals.

1. J1 → Line tracking sensor
2. J2 → Ultrasonic sensor

A simple way to remember:

1. Smart sensors → IIC
2. Basic sensors → J1 / J2

Type-C Port

Used for charging the onboard battery. The LED indicators show battery level while charging or in use.

1. Full charge: ~50 minutes
2. Runtime: ~4 hour

Color-Coded System (Super Helpful for Beginners)

One feature I really like is the color-matching system. Each port on the board has a specific color, and every cable matches that color. So instead of guessing, you just match colors and plug in. It might seem like a small detail — but when you’re building with multiple wires, it makes a huge difference.

Now that the hardware is ready, it’s time to make everything work — and that’s where coding comes in. Don’t worry if you’ve never programmed before. We’ll be using MakeCode, which is super beginner-friendly. It’s all drag-and-drop blocks, so you don’t have to write complicated code. MakeCode is a free online platform made for the micro:bit. You just open it in your browser, drag blocks together, and your program is ready. It even has a simulator on the screen, so you can test your code before uploading it.

Getting Started

1. Go to makecode.microbit.org
2. Click New Project
3. Give it a name like GestureCar or VoiceTruck
4. Click Create

Add Extensions

To use this kit, we need to add two extensions.

1. Click Extensions (bottom of blocks list)
2. Search Nezha Pro → install it
3. Go back and search PlanetX → install it

Now you’ll see new blocks for motors and sensors. Without this step, you won’t find the right controls.

Let’s finally build something. This is the first robot in this guide — and honestly, the most fun one to show people. The moment you wave your hand and the car responds, everyone around you wants to try it.

It’s also the simplest build, which makes it perfect to start with. Just two motors, one sensor, and a compact racing chassis. If you’re new to this kit, this build will help you understand how everything fits together before we move on to more advanced robots. So let’s begin with the most important part — the structure.

Building the Structure

Before we connect any sensors or write any code, we need to build the chassis. This is the base of your robot — it holds the motors, wheels, board, and sensor. If this part is done right, everything else becomes much easier.

I’ve attached the official step-by-step PDF with images. Follow it alongside these notes — the images will show you what to do, and these tips will help you avoid common mistakes.

Now it’s time to connect everything to the board and turn your build into a working robot. This step is simple — only three connections.

Connect the left motor to M1 and the right motor to M2. The connectors fit only one way, so don’t force them. After plugging in, make sure both cables are properly seated.

Next, connect the gesture sensor to the IIC port. It’s color-coded, so just match it and plug it in. Also check that the sensor is facing slightly upward and forward for better detection.

Take a moment to keep the wires neat and away from the wheels. Loose cables can cause problems while the robot is moving. Once everything is connected and secure, your hardware setup is complete.

The build is ready, everything is connected — now let’s load the code. I’ve already prepared the complete program, so you don’t need to write anything from scratch. Just open it, understand the logic, and upload it to your micro:bit.

Open the Program

Open the ready-made code in MakeCode: https://makecode.microbit.org/_2EuYKHF23aDX This will open directly in your browser. You’ll see all the blocks already arranged — each gesture linked to a specific movement. Take a moment to look through it before uploading. Even a quick understanding makes a big difference later.

Connect the Micro:bit

Connect your micro:bit to your computer using a USB cable. It will appear as a drive named MICROBIT, just like a USB device.

Upload the Code

In MakeCode, click Download, then choose Connect Device. Select BBC micro:bit CMSIS-DAP and click connect. Now click download again — the code will transfer directly. You’ll see the LED blinking during upload. Once it stops, the code is running.

Now comes the best part — testing your robot. Everything is ready: structure, wiring, and code. Let’s see it in action.

Insert the Micro:bit

Slide the micro:bit into the slot on the Nezha Pro board. Make sure it sits properly and the LED display faces outward.

Power It On

Flip the power switch to ON. The board LEDs will light up, and the micro:bit will start running. Give it a couple of seconds to initialize.

Try the Gestures

Place the car on a flat surface and hold your hand about 8–10 cm above the sensor. Now test different gestures:

1. Forward: Moves forward
2. Backward: Moves backward
3. Left: Turns left
4. Right: Turns right
5. No gesture: Stops

If everything responds correctly — your robot is working perfectly 🎉

Quick Fixes

If something feels off, don’t worry — it’s usually a small fix.

1. No response → check power and replug the gesture sensor
2. Wrong direction → swap M1 and M2
3. One motor not working → reconnect that cable
4. Gesture not detected → slow down your hand and keep proper distance

That First Reaction

Once it starts working, try handing it to someone nearby. Watching them control a robot just by moving their hand — no remote, no buttons — is honestly the most satisfying part of this build.

This time, the robot doesn’t just move — it carries things. You’re building a small transport vehicle with a lifting cargo bed that responds to voice commands. Drive it forward, turn it, load something on it, and with a simple command, watch it lift.

Building the Structure

This structure is a bit more advanced than the previous one. You still have the main drive chassis, but now there’s an extra mechanism on top — the cargo bed — which is controlled by a third motor. The alignment here matters more, because the lifting mechanism needs to move smoothly.

Follow the assembly PDF step by step, and keep these points in mind. Give it a quick check — wheels should rotate freely, and the structure should feel solid.

Now that the structure is complete, it’s time to connect everything to the board. This step is very similar to the previous build — the only difference is the extra motor for the cargo lift.

1. Left motor: M1
2. Right motor: M2
3. Lift motor: M3
4. Voice sensor: IIC

Start by connecting the two drive motors. Plug the left motor into M1 and the right motor into M2. Make sure both connectors are fully inserted. If a motor doesn’t respond later, this is usually the reason. Next, connect the lift motor to M3. Since this motor moves the cargo bed, leave a little extra cable length so the arm can move freely without pulling the wire.

Now connect the voice sensor to the IIC port. The connector is color-coded, so just match it and plug it in. After connecting, check that the sensor is facing outward and not blocked, so it can clearly detect your voice.

The build is ready, everything is connected — now let’s load the code. I’ve already prepared the complete program, so you don’t need to write anything from scratch. Just open it, understand the logic, and upload it to your micro:bit

Open the Program

Open the ready-made code in MakeCode: https://makecode.microbit.org/_dzvgAz4R5MJJ Take a moment to look through the blocks. Each voice command is mapped to a specific action, so it’s easy to understand how the robot responds.

Connect the Micro:bit

Connect your micro:bit to your computer using a USB cable. It will appear as a drive named MICROBIT.

Upload the Code

In MakeCode, click Download, then select Connect Device. Choose BBC micro:bit CMSIS-DAP, connect it, and click download again. The LED will blink during upload. Once it stops, the code is ready.