The first time you watch a robot make its own decision feels like magic.

Most DIY robots respond to simple voice commands like “forward” or “turn left.” But real rovers — the ones exploring Mars — don’t follow one-step instructions. They execute missions: sequences of actions like “move forward, if there’s a rock, bypass it, then continue.”

This project recreates that idea at a classroom scale. Using VoxControl v2 and CrowBot, we turn short phrases into autonomous scenarios. Your robot learns to bypass obstacles, perform patrols, and replay recorded paths — all from a voice command.

It’s simple, visual, and reproducible. Perfect for schools, STEM labs, and anyone curious about how autonomy really begins.

Why it’s Awesome

• Mission-based thinking. Students move from single commands to real behavior logic.
• Visible autonomy. The robot senses, decides, and acts — no joystick, no remote.
• Ready for lessons. Uses only one distance sensor and 90° turns — easy to explain and modify.
• Community-driven. Add your own voice commands and share new “missions” with others.

Use Cases

• STEM Lessons: Teach loops, states, and algorithms through robot motion.
• Workshops and Hackathons: Let students prototype new missions and compete.
• College Labs: Explore path learning, replay, and voice-triggered autonomy.
• DIY Robotics: Experiment with intent-to-command logic on any small rover.

Turn your classroom into a Mars rover lab.Let students give the robot real “missions” instead of single moves — watch them learn planning, logic, and teamwork through play.

Download the code, try the demo, and then challenge your class to invent the next “Do it…” command.

How it Works

We prepared three sample commands that launch full “missions”:

1. “Pass on the right” — the rover drives around the obstacle on the right and returns to the line.

2. “Pass on the left” — same logic, mirrored.

Each command activates a macro on the CrowBot: the robot moves forward until the front sensor detects an obstacle, backs up slightly, turns 90°, skirts around the object, and resumes the route.

3. “Go Turning” — to replay the last learned trajectory.

Voice Interface

In this setup, VoxControl v2 handles the speech recognition (ASR) and sends a ready-made text command (e.g., “PASS ON THE RIGHT”, “GO TURNING”) to the rover over Bluetooth (BLE serial connection).

The CrowBot (MarsRover) itself does not recognize speech — it simply receives these commands and executes the corresponding behavior: learning, obstacle bypass, or replay.

Open Challenge

We invite educators and makers to join the experiment:

1. Download the code from GitHub.
2. Build your own rover or use CrowBot.
3. Try the three sample missions.
4. Extend the project — create a new command and its algorithm (for example, “Do a square around the obstacle” or “Do an exploration to the right”).
5. Share your video and code on Hackster.

Let’s build a shared gallery of rover behaviors, powered by simple voice commands.

What You’ll Need

• VoxControl v2— speech recognition module
• CrowBot or any two-wheel platform with a front-facing distance sensor
• Distance sensor (HC-SR04, VL53L0X, or similar)
• USB adapter and power supply
• Arduino IDE or ESP-IDF

Try it Yourself

1. Connect VoxControl v2 to your CrowBot.
2. Add three voice commands in the VoxControl app.
3. Upload the sample firmware.
4. Place an obstacle in front of the robot and say, “PASS ON THE RIGHT.”
5. Watch your rover act like it’s on Mars — bypassing, turning, and returning on its own.

What’s Next

• Save and share missions: SPIFFS/SD storage, export to CSV, and mission import/export.
• Teach-by-teleop: record a trajectory while manually driving and replay it later.
• On-the-fly obstacle avoidance: allow the rover to bypass small obstacles during normal navigation without writing them into the main mission.
• Visualization: plot trajectories from CSV (e.g., Python + matplotlib) and analyze repeatability.
• Turn it into a class challenge: whose rover completes its mission fastest?

Share Your Feedback

Tried our rover prototype? Share your video or code!Invented a new “Do it…” command? Post it in the comments — we’ll feature the most creative ones.Let’s make this the world’s smallest Mars rover challenge — powered by curiosity, not budgets.

⚙️ Technical Appendix — For Advanced Users

This section condenses all core technical material from the Mars Rover project, so educators and advanced makers can reproduce and extend it.

Overview

The VoxControl module converts your speech into text commands, which the rover interprets as autonomous learning and replay tasks.

Once triggered, the rover “trains” itself to bypass an obstacle, records the sequence of moves, and later replays it.

Mission Flow

1. Receive command.

2. Enter learning mode.

3. Approach the obstacle and align parallel.

4. Move stepwise, detect corners, record FORWARD + TURN actions.

5. After four sides — mark trajectory as ready for replay.

Guide: Understanding the Rover Firmware

1. Where to Find the Logic

Open MarsRover.ino and search for these functions:

• learn_bypass_right_task
• learn_bypass_left_task
• replay_learned_right_task
• replay_learned_left_task

These are the heart of the “missions” described in the article.

2. How Obstacle Bypass Works

Each learning function drives forward until the front distance sensor detects an obstacle. Then the rover backs up, turns, moves along the obstacle, and turns again to return to its path.

Example (simplified from learn_bypass_right_task):

while (!obstacle) moveForward();

stop(); backOff();

turnRight90();

while (sides < 4) {

stepForward();

turnLeft90(); measure();

if (side_cleared) { recordForward(); recordTurn(); sides++; }

else { revertTurn(); }

}

saveTrajectory();

• obstacleDetected() checks the ultrasonic sensor.
• turnRight90() and turnLeft90() use timed turns (number of milliseconds = how long motors spin).
• The loop records each forward and turn movement into a small list — this is the “learning” step.

The left bypass works the same way but mirrors the turns.

3. How the Rover “Remembers” and “Replays”

During learning, every action is stored in memory:

• addLearnedForwardRight(ms);
• addLearnedTurnRight(deg);

Later, when the student says “GO TURNING”, the rover executes the replay task:

for (int i = 0; i < learned_right_cnt; i++) {

  if (a.type == ACT_FORWARD) driveForward(a.duration_ms);

  else turnBy(a.deg, a.dir);

}

stop();

This reuses the exact steps and durations learned earlier — just like “replaying a recording.”

4. Easy Parameters to Experiment With

You can easily adapt the rover’s behavior by changing a few numeric constants in the code.These values control how far and how sharply the robot moves. All of them are defined near the top of the file or marked inside the learning functions.

• TURN_DEG — sets how many degrees the rover turns. The default value is around 46.If the robot rotates too much on a slippery surface, reduce this number;if it doesn’t complete the turn on a rough floor, increase it slightly.
• FORWARD_STEP_MS — defines how long the motors run forward in one learning step (usually 400–800 ms).Larger values make each segment of the path longer.
• BASE_TURN_POWER — controls motor power during turns (typical range 80–100).Raise it if turns feel too weak or uneven.
• FORWARD_POWER — sets the drive speed when moving forward (usually 100–120).Adjust it for smoother or slower motion depending on the floor type.

5. Where the Voice Commands Come From

The rover itself doesn’t recognize speech — that’s done by VoxControl v2.It sends text commands such as "PASS ON THE RIGHT" or "GO TURNING" over Bluetooth (BLE serial connection).The firmware receives them and calls the matching task:

if (value == "PASS ON THE RIGHT")  xTaskCreate(learn_bypass_right_task, ...);

if (value == "PASS ON THE LEFT")   xTaskCreate(learn_bypass_left_task, ...);

if (value == "GO TURNING")         xTaskCreate(replay_learned_right_task, ...);

6. Teaching Tips

• Let students observe how the robot behaves before and after changing TURN_DEG — it clearly shows how calibration works.
• Demonstrate saving and replaying a route; explain that this is a primitive form of machine learning — storing and repeating behavior.
• Encourage them to invent new missions by combining forward, turn, and delay blocks.

Surface Calibration

Different surfaces affect how your rover turns and moves.If the floor is smooth or slippery, reduce the turn angle or shorten timed rotations — otherwise, the rover may over-rotate.If it’s rough or high-friction, increase the turn angle slightly to compensate for wheel slip.We recommend testing each mission with a small obstacle and fine-tuning the constants TURN_DEG and FORWARD_STEP_MS for stable and repeatable movement.

GitHub Repository

https://github.com/Grovety/CrowBot_GRC_program/blob/main/MarsRover.ino