• 1
    Step 1

    Introduction

    When I evaluate any robotics kit aimed at newcomers, the first thing I look for is the learning curve. Will it scare a beginner off in the first hour, or will it pull them in and keep them building for weeks? The ELECFREAKS TPBot micro:bit robot car sits comfortably in the second category.

    It is small, quick to set up, and built around the BBC micro:bit. In this project write-up I will walk through what the TPBot actually is, the hardware that ships in the box, and how you can turn it into a working autonomous robot in an afternoon.

    A Compact Platform Aimed at New Builders

    The reason the TPBot works so well as a starter kit is that it gets out of your way. The chassis arrives almost fully assembled, so there is no fiddling with screws, motor mounts, or wiring harnesses before you can write your first line of code. You drop in your micro:bit, snap in some batteries, and you are ready to roll.

    Because the micro:bit is the brain, you can program everything in Microsoft MakeCode using simple drag-and-drop blocks. Anyone who has touched a micro:bit before will feel right at home, and even total newcomers can get the robot moving in their first session.

    Hardware Breakdown: What You Get in the Box

    The kit arrives with everything you need to build a working robot car, with one exception. You still need to bring your own micro:bit board.

    Inside the box you will find:

    • The TPBot chassis with motors pre-installed
    • Two 130-size DC motors driving the rear wheels
    • An HC-SR04 ultrasonic distance sensor (range up to roughly 400 cm)
    • A line-following sensor module
    • Three programmable RGB headlights
    • Battery holder for 4 × AAA cells
    • Expansion ports broken out: P1, P2, P8, P12, plus I2C
    • LEGO-compatible mounting holes across the body

    The micro:bit board itself slots into a connector on top of the chassis and acts as the main controller for everything on board.

    A Closer Look at the Chassis

    The first thing that struck me when I unboxed the TPBot was just how friendly it looks. The design is simple but well thought out. It is a two-wheel drive robot powered by small DC motors at the back, with a tiny omni wheel up front that keeps the robot balanced when it turns. The rear wheels are large enough to grip most flat surfaces without slipping, even on smoother classroom floors.

    One nice detail is the LEGO compatibility. The mounting points across the chassis let you bolt on bricks, build extra structures, or even mount sensors and props of your own. For school projects this is a huge plus, because students can express their creativity rather than being stuck with a fixed look.

    Body: The TPBot measures roughly 128 × 113 × 90 mm without packaging. It is light but solid, which makes it well suited for classroom kits where things get knocked around.

    Drivetrain: Two 130 DC motors connect to the rear wheels (62 mm diameter), giving the robot enough torque to handle slight inclines and rougher surfaces. The 14 mm omni wheel up front handles balance during turns.

    Sensors: The HC-SR04 ultrasonic sensor reads obstacle distance up to about four meters with reasonable accuracy. The downward-facing line sensor lets the robot follow a black line on a white background, which is the classic first project for any autonomous robot.

    RGB Headlights: Three programmable LEDs sit on the front of the chassis. You can set the colour and brightness of each one independently from your code.

    Power: Four AAA batteries supply 4.5 V to 6 V to the system. Expect around 1.5 hours of continuous run time on a fresh set.

    What Makes This Kit Stand Out

    Easy entry point: The micro:bit handles all the heavy lifting on the software side, and MakeCode means you can write your first program without ever typing a semicolon. Even someone who has never coded can have the robot moving in minutes.

    Obstacle detection out of the box: The ultrasonic sensor lets the robot sense what is in front of it. With a few blocks of code you can have it stop, reverse, or change direction when something gets too close. It is a great way to introduce the concept of sensor-driven decisions.

    Line following ready to go: The line sensor opens the door to autonomous track following, which is one of the most popular projects in school robotics competitions. Lay down some black tape on white paper and you have an instant racing track.

    Programmable lighting: The three RGB LEDs are easy to control from code. They are a small touch, but they let kids add personality to their projects, like turning red when stopping or flashing green when starting.

    LEGO mounting: Because the chassis accepts LEGO bricks, you can build claws, towers, decorations, or whatever else students can imagine. It turns a robot kit into an open-ended construction toy.

    Wireless control via Bluetooth: With a second micro:bit acting as a remote, you can drive the robot wirelessly. This is a fun way to introduce radio communication between two boards, and it is one of my favourite first projects to assign.

    Programming the Robot

    Setting the TPBot up is honestly easier than most beginners expect. You snap the micro:bit into the slot on top of the robot, plug the board into your computer over USB, and open MakeCode in your browser. From there it is just dragging blocks together to make the wheels turn.

    Within the first ten minutes you can write programs that:

    • Move forward and reverse for a set time
    • Turn left or right
    • Read distance from the ultrasonic sensor
    • Follow a line on the floor
    • Trigger different LED colours on demand

    Connecting the Hardware and Uploading Your First Program

    Getting the TPBot running is a quick five-step process.

    First, slide the BBC micro:bit board into the slot on top of the TPBot chassis. The micro:bit is the controller for the whole robot, so every program you write runs from this board.

    Next, plug the micro:bit into your computer using a USB cable. Your operating system should detect it as a small USB drive, similar to a flash drive.

    Open the Microsoft MakeCode website in your browser. This is where you will write the program that runs on the robot. Start a new project and use the block-based editor to build your code visually.

    For your first program, try something simple. A good starter is making the robot drive forward for two seconds, stop, then rotate ninety degrees to one side. This kind of program teaches you how the motor blocks behave and how timing affects movement.

    Once your code is ready, hit the download button in MakeCode. The browser gives you a hex file, which you drag onto the micro:bit drive. As soon as the file finishes copying, the program starts running.

    Now unplug the USB cable, switch on the battery pack, and watch the robot do its thing. Once you have the basics working you can branch out into more advanced behaviour. Try writing a sketch that uses the ultrasonic sensor to avoid walls, or one that follows a black line drawn on white paper, or even a program that changes the LED colour based on what the sensors are reading.

    The MakeCode block interface is great for understanding how all the pieces fit together. Once you are comfortable, you can switch to Python in the same editor and start writing more complex routines.

    Project Ideas to Try

    After spending some time with the TPBot I came up with a handful of project ideas that work well as learning exercises. The classic obstacle avoidance program is the most rewarding first project, because you can immediately see the robot reacting to the world around it. Line following is the next logical step, and it teaches a lot about how to write loops that react to continuous sensor readings.

    A more advanced experiment is what I call distance keeping, where the robot maintains a fixed distance from a moving object in front of it. This one is great for teaching the basics of feedback control without needing to write any maths-heavy code. With three projects like these you cover sensors, motor control, conditionals, and loops, which together are most of what you need to start building your own robotic projects from scratch.

    Why It Works So Well in Classrooms

    The reason the TPBot does so well in school settings is that it removes the parts of robotics that intimidate beginners. Students don't need to wire breadboards, solder anything, or read motor driver datasheets. Instead they can spend their time understanding how sensors feed data into code and how that code drives the motors.

    Real concepts in a simple package

    The TPBot teaches the core building blocks of robotics: motors, sensors, and program flow. Instead of reading about these ideas in a textbook, students see them working in a physical robot they can hold. A two-line MakeCode program to drive forward for two seconds is the same fundamental idea that controls warehouse robots and autonomous cars. The scale is different, but the concept is identical.

    Step-by-step thinking

    Programming a robot forces students to think in steps. If the robot keeps bumping into the wall, they have to work out why. Maybe they need to add a check: if the distance sensor reads less than 20 cm, stop and turn. That is debugging in its purest form, and it is the same skill professional engineers use every day.

    Sensor based behaviour

    A robot that just runs the same loop is boring. A robot that reacts to its environment feels alive. The ultrasonic and line sensors let students write programs that respond to the world rather than blindly executing commands. This is the gateway to actual robotics, where machines make decisions based on real-time data.

    Bridging hardware and software

    When you write a "turn left" block in MakeCode, the micro:bit fires a signal to the motor driver, which then powers the wheels at different speeds. Watching that chain happen in real life is one of the clearest ways I have seen to teach students that code controls physical devices.

    Practical STEM activity

    Reading about robots only goes so far. Building one and watching your code take effect on the wheels in front of you is a completely different experience. A classroom exercise where students draw their own track on paper and program the robot to follow it covers programming, electronics, and a bit of mechanical engineering all at once.

    Pricing

    Now for the part everyone wants to know. The ELECFREAKS micro:bit TPBot Car Kit is reasonably priced for what you get. The base TPBot kit without a micro:bit comes in at around $79.90 USD. The TPBot Edu version, which includes a micro:bit board, is priced at roughly $102.99 USD. For a full classroom-ready robot with sensors, motors, and lights, that is a fair deal.

    Final Thoughts

    The ELECFREAKS TPBot is a solid example of a beginner robotics platform that respects the learner's time. It pairs a friendly chassis design with useful sensors, programmable lighting, and the very approachable MakeCode environment. For students, hobbyists, or teachers shopping for an entry-level kit, it covers a lot of ground without overwhelming anyone.

    If you have been curious about getting into robotics but didn't know where to start, the TPBot is one of the easier first steps you can take. Drop in a micro:bit, snap in some batteries, and start writing code that affects the real world.