How to Build a RoboSumo Robot for Robotics Competitions — Complete Step-by-Step Guide

OLL × TechFest 2026-27 is a national robotics championship for school students in Grades 4–12. It gives young makers a stage to build, compete and innovate — and its Grand Finale is held at IIT Bombay from 16–18 December 2026.

The championship runs three parallel tracks:

• RoboSumo — 1 v 1 robot battle (this guide).
• RoboRacer — high-speed autonomous / manual robot racing.
• Robotics Innovation Challenge — build an original robotic or automated solution to a real-world problem.

Participation is FREE, with a ₹1.5 lakh prize pool and qualification rounds you can join from anywhere in India:

National Online Qualifier → Regional Qualifier → Grand Finale @ IIT Bombay

See full championship details, dates and tracks

RoboSumo is a robot-versus-robot pushing contest — your bot must shove its opponent out of a circular arena. Sounds simple, but a winning RoboSumo demands the right balance of torque, traction, weight, ground clearance, wedge geometry and control. Raw motor power alone loses matches. Winning bots blend mechanical design, electronics and firmware.

• Motor torque & RPM
• Wheel traction & ground clearance
• Chassis weight distribution
• Wedge angle (getting under the opponent)
• Power delivery & PWM control
• Overall stability under impact

Every part in this build is available off-the-shelf in India, or bundled together in the official RoboSumo kit (see below).

Sourcing 15+ compatible components can eat weeks. The OLL × TechFest RoboSumo Kit ships every essential — motor drivers, ESP32, LiPo, wheels, XT60s, LM2596 — pre-selected for the current ruleset so you can spend your time building, not shopping.

Prefer to source parts individually? All build resources — STL files, motor-driver bracket CAD and the full ESP32 code — are in the RoboSumo Resources folder .

The chassis is the mechanical backbone. In this reference build it’s made from plywood (light, cheap, easy to cut) with the stainless-steel wedge bolted to the front. Two circular cutouts host the wheels; the sloped front lets the bot slide under the opponent.

Approximate dimensions used here:

• Length: 24 cm
• Width: 19.6 cm
• Height: 9.6 cm
• Wheel opening radius: ~5 cm
• Front slope: ~45°

The wedge is arguably the single most important mechanical part. Angled at roughly 25° (measured 15.7° effective in this build) and cut from stainless steel, it lets the robot get beneath the opponent — killing their traction and letting yours do the pushing.

Ensure your final wedge complies with the official rules on edges, dimensions and materials. A wedge that’s too sharp or overhangs beyond limits can disqualify an otherwise legal bot.

RoboSumo motors pull massive current in short bursts. A 3S LiPo (11.1 V) is the classic choice — high discharge C-rating, generous capacity for a short match and small enough to fit inside a 3 kg bot.

Two 300 RPM Johnson gear motors drive the two rubber wheels. 300 RPM is the sweet spot between torque and speed for a 3 kg sumo. Mount each motor with U-clamps into the chassis cutouts.

Each Johnson motor is driven by a BTS7960 43 A H-bridge module. One driver per motor gives you full independent PWM control, which is what differential-drive steering needs.

Motor terminal convention used throughout this build:

• Black wire → M-
• Red wire → M+

A pair of small 3D-printed brackets (designed in Autodesk Fusion) holds each BTS7960 securely to the chassis. Using two narrow clamps rather than one wide one keeps the driver’s screw terminals accessible after mounting.

With the mechanical build done, we can move to power. Steps 7-10 all belong to the same subsystem — the goal is to feed 11.1 V from the LiPo to both BTS7960s directly, and a clean 5 V rail to the ESP32 through an LM2596.

1. Solder the motor wires onto each motor and into the corresponding M+/M- terminal on the BTS7960.
2. Add the XT60 pigtail to the LiPo lead — this becomes the master power connector for the whole robot. Confirm polarity twice.
3. Split the battery feed into two branches: one to the BTS7960 B+/B- pair, the other into the LM2596 input.
4. Set the LM2596 to 5.0 V using a multimeter before connecting the ESP32. A 100 µF electrolytic cap across the output (with an optional 0.1 µF ceramic in parallel) will crush the ripple.

The BTS7960 exposes six logic pins: RPWM, LPWM, R_EN, L_EN, VCC, GND. Wire them to the following ESP32 GPIOs — this mapping matches the firmware in the next section:

// LEFT BTS7960
#define L_RPWM 4
#define L_LPWM 5
#define L_R_EN 6
#define L_L_EN 7

// RIGHT BTS7960
#define R_RPWM 15
#define R_LPWM 16
#define R_R_EN 17
#define R_L_EN 18

// FlySky FS-CT6B receiver (optional RC control)
#define RC_CH1 8   // Steering
#define RC_CH2 9   // Throttle

Use short jumper wires while prototyping so you can rewire fast during testing. Solder them once you’re confident the mapping is stable.

A single Arduino sketch handles everything: motor PWM, the Wi-Fi joystick web-app, optional FlySky RC input and a hard failsafe that stops the motors if either controller drops.

1. Wi-Fi access-point setup

The ESP32 hosts its own Wi-Fi so no router is needed at the venue. Connect any phone to the SSID SumoBot and open 192.168.4.1.

#include <WiFi.h>
#include <WebServer.h>

const char* AP_SSID     = "SumoBot";
const char* AP_PASSWORD = "sumo12345";

const int RC_FAILSAFE_MS   = 300;   // stop motors if no RC pulse in 300ms
const int WIFI_FAILSAFE_MS = 500;   // stop motors if no phone cmd in 500ms
const int PWM_FREQ         = 20000; // 20 kHz — inaudible to humans
const int PWM_RES_BITS     = 8;     // 0..255
const int MOTOR_MAX        = 255;

2. Differential-drive mixing

Throttle drives both wheels forward/back; steering biases the left/right speed to make the bot turn. Constrain to keep PWM inside legal bounds.

int left  = throttle + steering;
int right = throttle - steering;

left  = constrain(left,  -MOTOR_MAX, MOTOR_MAX);
right = constrain(right, -MOTOR_MAX, MOTOR_MAX);

driveMotor(L_RPWM, L_LPWM, left);
driveMotor(R_RPWM, R_LPWM, right);

3. Phone joystick endpoint

The on-board web page (also served by the ESP32) sends joystick values over a single HTTP endpoint. Format: /cmd?t=<throttle>&s=<steering>.

server.on("/cmd", HTTP_GET, []() {
  lastPhoneMs = millis();                 // reset failsafe timer
  phoneThrottle = server.arg("t").toInt();
  phoneSteering = server.arg("s").toInt();
  server.send(200, "text/plain", "OK");
});

4. Failsafe priority

RC control always wins if it’s live — the moment the sticks move off centre by more than the deadband, phone commands are ignored. If both inputs go silent, the motors are cut hard.

bool rcLive    = (millis() - lastRcMs)    < RC_FAILSAFE_MS;
bool phoneLive = (millis() - lastPhoneMs) < WIFI_FAILSAFE_MS;

if (rcLive) {
  applyMix(rcThrottle, rcSteering);
} else if (phoneLive) {
  applyMix(phoneThrottle, phoneSteering);
} else {
  stopMotors();     // final safety state
}

Before the first powered test, walk this list top-to-bottom:

• All solder joints solid and heat-shrunk.
• Battery polarity confirmed with a multimeter.
• LM2596 measured at 5.0 V — no more, no less.
• No stray strands bridging BTS7960 terminals.
• Wheels mount square; nothing rubs.
• Common ground between LiPo, LM2596, ESP32 and both BTS7960s.

Now power up and test each motion in isolation — forward, reverse, left, right, stop. Both motors should spin in the direction you expect at each throttle/steering input.

Finally — put the bot on a kitchen scale. The target for this reference build is ≤ 3 kg. Always confirm against the current rulebook — a bot over-weight by 20 g on match day is a lost season.