RoboticsFirst semester · November 2024

Maze Runner & Ball Shooter

Two robots for a first-semester university competition

Two Control Systems
Autonomous Arduino navigation and manual Makeblock control
Three Ultrasonic Sensors
Front, left, and right distance feedback for maze navigation
Gamepad Ball Handling
Joystick driving, a shooter motor, and grabber and claw servos

System Overview

For a first-semester competition in November 2024, our three-person Circuit Breakers team built two robots: one to carry a ball through a maze autonomously, and another to shoot balls under gamepad control.

The maze robot uses three ultrasonic sensors and Arduino C++; the Makeblock shooter uses Python to control its drive, shooter motor, and ball-handling servos.

How it actually works

Two robots, two control loops

Place the maze robot in a junction to see its real sensor rules decide the wheel speeds, then drive the shooter's real gamepad code.

Things to try

In Turn toward openings, pick T-junction and Dead end.
In Mix the joystick, push the stick to a corner and see the ±1 clamp.
In Shoot and release, press R2.

Built from the project's own code and documents.from code: A constant or rule copied from the project's repositoryfrom report: A value from the project's report or presentationsimulated: Computed in your browser by running the project's logic

Maze runner (Arduino C++): stages 1–4 · Ball shooter (Python): stages 5–6

Across+0.5 cm

Before the junction55 cm

Heading2°

sensors[0..2] → right, left, front13, 14, 206 cm

difference = 20 + |L − R| × 520 + 1 × 5 = 25

after centring (left, right)125, 175

open-space rulenone

constrain(0, 255) → analogWrite125, 175

Left wheel PWM (pin 6)

125

Right wheel PWM (pin 5)

175

The decision is the report's moveWithDifferentialAdjustment() run on the three readings from code: Report pp. 2-3, lines 31-75. The junction, body size, sensor rays and the dotted path (wheel speed taken as proportional to PWM) are simulated: Corridor 40 cm wide, round 18 cm body, single-ray sensors. Which wheel is motors[0] is inferred from the turning rules, not stated in the report.

Maze runner · Arduino C++View in report

#include <NewPing.h>
struct Motor {
int enPin;
int forwardPin;
int backwardPin;
};
int openSpaceThreshold = 15;
int openSpaceTurnBoost = 60;
Motor motors[2] = {{6, 12, 13}, {5, 9, 8}};
NewPing sensors[3] = { NewPing(7, 10, 500), NewPing(4, 11, 500), NewPing(2, 3, 500) };
int baseSpeed = 150;
void setupMotors() {
for (Motor* motor = motors; motor < motors + 2; motor++) {
pinMode(motor->enPin, OUTPUT);
pinMode(motor->forwardPin, OUTPUT);
pinMode(motor->backwardPin, OUTPUT);
}
}
void setup() {
Serial.begin(9600);
setupMotors();
}
void moveWithDifferentialAdjustment() {
int distances[3];
for (int i = 0; i < 3; i++) {
distances[i] = sensors[i].ping_cm();
}
int leftDistance = distances[1];
int rightDistance = distances[0];
int frontDistance = distances[2];
int motorSpeeds[2] = {baseSpeed, baseSpeed};
int difference = 20 + abs(leftDistance - rightDistance) * 5;
if (leftDistance > rightDistance) {
motorSpeeds[1] += difference;
motorSpeeds[0] -= difference;
} else if (rightDistance > leftDistance) {
motorSpeeds[0] += difference;
motorSpeeds[1] -= difference;
}
if (leftDistance > openSpaceThreshold && rightDistance > openSpaceThreshold && frontDistance < openSpaceThreshold) {
motorSpeeds[0] += openSpaceTurnBoost;
motorSpeeds[1] -= openSpaceTurnBoost;
} else if (leftDistance >= openSpaceThreshold && rightDistance < openSpaceThreshold) {
motorSpeeds[0] -= openSpaceTurnBoost;
motorSpeeds[1] += openSpaceTurnBoost;
} else if (rightDistance >= openSpaceThreshold && leftDistance < openSpaceThreshold) {
motorSpeeds[0] += openSpaceTurnBoost;
motorSpeeds[1] -= openSpaceTurnBoost;
} else if (rightDistance < openSpaceThreshold && leftDistance < openSpaceThreshold && frontDistance < 5) {
motorSpeeds[0] = 0;
motorSpeeds[1] = 0;
}
motorSpeeds[0] = constrain(motorSpeeds[0], 0, 255);
motorSpeeds[1] = constrain(motorSpeeds[1], 0, 255);
for (int i = 0; i < 2; i++) {
analogWrite(motors[i].enPin, motorSpeeds[i]);
digitalWrite(motors[i].forwardPin, HIGH);
digitalWrite(motors[i].backwardPin, LOW);
}
}
void loop() {
delay(50);
moveWithDifferentialAdjustment();
}

CAD of the maze robot: two wheels, front and side ultrasonic sensors, L298N driver, Arduino with sensor shield and a ball holder on top — Maze robot assembly: three ultrasonic sensors at the front.Report p. 11

Both programs are copied from the report (pp. 2–3 and 12–13) and run in your browser with their own constants. The maze scenes, robot size, single-ray sensors and the dotted path are simulated, and the report gives no speeds, maze sizes or run results, so none are shown. Line numbers follow the report: the maze listing is printed starting at 2; the Python listing is counted from 1.

How it works

Build two robots with different control requirements.

1
Read maze distances
NewPing reads the front, left, and right ultrasonic sensors to supply distances for the Arduino navigation loop.
2
Adjust maze wheel speeds
Correct the difference between side distances, turn toward detected openings, and stop when both sides and the front are too close.
3
Drive the shooter manually
Mix joystick inputs into left and right wheel speeds, and use gamepad buttons to start or stop the shooter motor.
4
Position and release the ball
Move the grabber and claw servos through bounded button inputs, or trigger the timed grabber-position and claw-release sequence.

Project Demo

The project's own demonstration footage.

Maze Runner & Ball Shooter video preview

Watch Maze Runner & Ball Shooter on YouTube

Engineering features

Maze navigation: three ultrasonic sensors measure the front and side walls so the Arduino can steer toward openings while carrying a ball.
Differential motor control: C++ and NewPing adjust left and right wheel speeds through an L298N driver, constrain PWM to 0–255, and stop when both sides are under 15 cm and the front is under 5 cm.
Manual shooting: Python on Makeblock mBot2 mixes joystick inputs for differential driving, with gamepad buttons starting and stopping the shooter motor.
Ball handling: separate grabber and claw servos use bounded 0–180° controls and a timed release sequence, supported by custom mechanical CAD assemblies.

Inside the build

The control logic, integration and design decisions, one note at a time.

Reactive differential maze control

The C++ program stores motors and ultrasonic sensors in arrays and computes a correction from the left-right distance difference. Side-opening rules add a turning boost; the blocked-path condition stops both motors. PWM commands are constrained to 0-255 and applied through the L298N driver in a repeated sensor-feedback loop.

Gamepad mixing and bounded ball handling

The Python program sums and subtracts normalized joystick axes to produce differential drive commands. Separate buttons operate the shooter motor and increment the two servo angles within 0-180 degrees. The release input sets the grabber position, waits briefly, and then opens the claw; the operator initiates this sequence.

Mechanical assemblies documented in CAD

The maze assembly places the ball holder above the controller, driver, wheels, and three ultrasonic sensors. The manual robot's CAD documents the shooter barrel, gear track, motor mounts, connecting arms, and claw assembly. These illustrations show component placement and mechanisms without substituting CAD for physical-build evidence.

Build artifacts

Figures taken from the project's own report or presentation.

Maze robot CAD assembly with ball holder, Arduino electronics, wheels, and ultrasonic sensors — Maze robot assembly extracted from report PDF page 11. This is a CAD rendering.

Manual ball shooter CAD assembly showing barrel, gear track, chassis, and extended claw — Manual ball shooter assembly extracted from report PDF page 27. This is a CAD rendering.

Evidence & limitations

What the project documents show, and where each claim comes from.

Code, flowcharts, and assembly illustrations

The 27-page Computer Programming for RAI report contains both programs, explanations, flowcharts, component CAD, and complete assemblies. Its cover names the three Circuit Breakers members and dates submission to 11 November 2024. A competition demonstration is linked in the supplied portfolio.

Computer Programming for RAI competition report
PDF page 1: team and date; 2-11: maze code and CAD; 12-15: manual shooter control; 15-27: shooter CAD. Individual contribution confirmed by Lucky.
Competition demonstration
Linked from the supplied portfolio.

Project Resources

The original documents behind this case study.

Final Project Report · 27 pages
PDF file
View Download

Next project3-Axis Cartesian Grasping Robot & Auto ParkingVision-Guided Cartesian Gripper and LiDAR-Based Auto Parking

Hiring for robotics or embedded work?

I'm looking for internships. The résumé has the short version.

Get in touch Résumé