Building the Zhurong Mars Rover

When the Zhurong rover touched down on the Martian surface, I took it as an invitation. An invitation to understand, to touch, and in my own way, to replicate that marvel of engineering. For me, this was a journey into the heart of what makes a rover work: the interaction of mechanics, electronics, and code. I didn’t just want to watch the mission, I wanted to be able to physically "interact" and understand it too.

With my desk as my launchpad and way too many photos (solar wings, panoramic camera masts, six-wheel rocker-bogie suspensions, you name it) as my guide, I delved into research about how these individual mechanisms functioned and interacted. Then, I put theory into practice, which ultimately resulted in my very own rover replica, the MRL2.0. Now, with this guide, you can make one too!

Your Mars rover "mission pack" includes the following key components:

Core Control Unit

1. NEW micro:bit Main Board (for rover): The upgraded brain with built-in speaker and microphone.
2. Original micro:bit Main Board (for remote): The classic version responsible for sending commands.
3. MRL2.0 Dedicated Expansion Board: The hub connecting all sensors, providing motor, servo, and sensor interfaces.

Power & Mobility System

1. Mars Rover Chassis: Pre-assembled with six-wheel suspension system and high-torque DC motors.
2. 7.4V 5200mAh Li-ion Battery & Charger: Provides energy for long "Martian missions."
3. 4 Servos: 2 for front-wheel steering, 1 for robotic arm lift, 1 for gripper open/close.

Perception System (The Rover's Senses)

1. HUSKYLENS AI Vision Sensor: An intelligent "eye" that can recognize faces, colors, and object labels.
2. RGB Ultrasonic Sensor: Measures distance and emits colored light while detecting.
3. DHT11 Temperature & Humidity Sensor: Monitors environmental data.
4. LCD1602 Display (I2C): Displays status, data, and feedback.

Interaction & Input System

1. Custom Remote Controller: Features dual joysticks, multiple function buttons, and vibration feedback for an immersive experience.
2. Various Input Modules: Rotary potentiometer (analog knob), traffic light module, onboard RGB LED strip.

Software & Connectivity

1. USB Cable: For programming and power.
2. Mind+ Programming Software: Our primary development environment.

After waiting far too long for the components to arrive, unboxing everything felt like a mission unpacking. The components were laid out on the desk: the white chassis, six wheels, bundles of wires, the servo motors, the camera eye (a HUSKYLENS AI sensor), and the tiny but mighty micro:bit controllers.

The first step is mechanical. Screw the wheels onto the motor shafts, mount the main expansion board onto the chassis and thereby create the foundations of this project. Then came the servos: two for steering the front wheels, one for the arm’s elbow-like joint, and a final one for the claw. Connect them, and you get your first look at the rover.

Then, install the "senses". Plugging the HUSKYLENS camera into its I2C port gives it sight. The LCD screen gives it the ability to communicate. The ultrasonic sensor with its glowing RGB ring gives it proximity senses. Each step adds another layer of complexity and with it, ability.

Finally, add the "brain" —the micro:bit—and connect the battery. Flipping the power switch for the first time is, and always will be, a moment of truth. Hopefully, a red LED on the board jumps to life, because then, congratulations! Your rover has a heartbeat.

I used Mind+, a visual programming software, to avoid getting bogged down in syntax and instead to focus on logic and behaviour.

The first program to test was simple : "Move Forward." In Mind+, I dragged blocks together: set steering servos to 90° (to straighten the wheels), then set all six motors to speed 200. Upload it via USB, press the remote button, and watch it come to life. This is the first time you are able to actually control your creation.

(I might have then spent an hour just driving it in squares and figure-eights out of sheer happiness that everything finally worked, but that's optional.)

Next, I gave it "eyes" and a reaction. I taught the HUSKYLENS camera my face (ID1). Then, I wrote a program: If HUSKYLENS sees face ID1, then raise the robotic arm and display "Welcome Back!" on the LCD. The first time I walked in front of it and it recognized me, lifting its arm in greeting, was a breakthrough. It was no longer just a remote-controlled car; it was interacting.

The remote control system becomes your mission control. I programmed one micro:bit in the handheld remote to read the joysticks and send data via radio. The micro:bit on the rover received it, translating joystick tilts into steering angles and throttle. Fine-tuning this loop and making the controls feel responsive and intuitive will be a game of patience and precision, but when you finally get it right, you will feel as if you are no longer just pushing buttons; you're driving a rover.

With basic functions working, I crafted my own "Mars Exploration Scenario." This was the ultimate test and the reason for it all.

Mission Profile: The rover must leave its base, navigate to a colored marker (a red piece of paper), use its arm to collect a "rock sample" (a foam cube), and return home, all while avoiding obstacles.

Here’s how I did it:

1. The Manual Pilot Phase: I took remote control, and deftly (mostly clumsily) navigated around books and chair legs in lieu of the Martian terrain.
2. The Autonomous Search: I then switched it to my auto-program. The HUSKYLENS, set to colour recognition mode, scanned the room. When its feed locked onto the red marker, the code took over, making tiny adjustments to center the target. Here, you should see the rover doing a little wiggle as it adjusts and locks onto the target.
3. The Sample Collection: With a single button press, the "collection sequence" (that I’d painstakingly coded) triggered : Arm down, claw open, arm lower slightly, claw close, arm lift.
4. The Return Home: For the final leg, I activated a simple autonomous return routine. It used the ultrasonic sensor to ping for obstacles. My code essentially said, "Go forward. If something is closer than 10cm, turn 30 degrees and try again." Simple as it might be, it worked, and watching it bump, sense, correct, and slowly find its way back to my feet was the perfect, imperfect conclusion.

This project was never about building the perfect replica. It was about the process. It was about the frustration of a servo that wouldn't center, the triumph of fixing a bug in my logic chain, and the quiet awe of seeing a collection of parts exhibit purposeful behavior.

It demystified the sheer complexity of missions like Zhurong. Now, when I see news from Mars, I don't just see a robot, but also the thousands of lines of code, the torque calculations for the wheels, the sensor fusion algorithms, and the human ingenuity that brought it all together. With this project, I’ve replicated an iota of that challenge.

My rover sits on my desk now, a constant companion, and I’m already planning its upgrades: maybe a Raspberry Pi for real video streaming, or solar panels to charge its battery. The project isn't over; it’s evolving, just like our exploration of space.

If you have that same spark of wonder—about space, robots, or how things work—I urge you to start your own build. Don't just watch the future unfold. Grab a screwdriver, fire up a code editor, and build a piece of it for yourself. The view from your own mission control is unforgettable.

Build fearlessly. Explore endlessly.