Week 12 · Mechanical Design & Machine Design

A.k.a. we took apart a hoverboard and somehow ended up with a little green robot 🛹➡️🤖


🪛 Overview

This was a group week. The brief was to design a machine that includes mechanism + actuation + automation + application, build the mechanical parts and operate it manually, then actuate and automate it.

We started out planning to rebuild a hoverboard, and ended up with DispatchR, a wireless, remote-controlled drive robot: four geared DC motors, an L298N motor driver and an ESP32 on an acrylic chassis, driven over ESP-NOW from a handheld controller.

DispatchR poster: the green acrylic robot with prototype, coding and assembling photos
Meet DispatchR 🤖
BriefOur machine
MechanismFour-wheel chassis with motor mounts and shaft couplings
ActuationGeared DC motors driven by an L298N motor driver
AutomationESP32 receiving commands and switching the motor driver
ApplicationRemote-controlled robot for point-to-point delivery indoors

👥 Group Assignment

The full build is documented on the group page and on my teammates' pages:

🔗 Group Assignment: Machine Design
🔗 Vignesh Shetty: Week 12

🙋 My Contribution

AreaWhat I did
⚡ PCBDesigned the controller PCB in EasyEDA and milled it
🗺️ PlanningHelped plan the build: teardown, redesign, and how the parts fit together
🔧 AssemblyHelped assemble the frame, motors and electronics

The rest of the team worked across the teardown, frame, wiring and programming. Tasks were rotated rather than fixed, so everyone touched most of the build.

🗺️ How the Project Evolved

 PART 1: Hoverboard          PART 2: Own drive system      FINAL: RC robot
 ┌──────────────────┐        ┌──────────────────────┐      ┌──────────────────────┐
 │ Tear down        │        │ DC motor (too weak)  │      │ 4 geared DC motors   │
 │ hoverboard       │  ───▶  │ → geared DC motors   │ ───▶ │ L298N + ESP32        │
 │ Reuse hub motor  │        │ L298N + ESP32        │      │ Acrylic chassis      │
 │ Wood + aluminium │        │ Wiring + mounts      │      │ ESP-NOW controller   │
 │ frame            │        │                      │      │ (my PCB)             │
 └──────────────────┘        └──────────────────────┘      └──────────────────────┘
ProblemWhat we changed
The hoverboard's motors and sensors were tied to its own master control board, so we couldn't drive them on their ownBuilt our own drive system with a separate motor driver and microcontroller
A plain DC motor didn't have enough torque to carry the weightSwitched to geared DC motors
The heavy wooden base restricted the wheelsReplaced it with a lighter acrylic sheet

🛹 Part 1: Taking Apart the Hoverboard

The plan was to reuse a hoverboard's hub motor (a motor built into the wheel), since sourcing one separately was hard. We opened it up to see what we were working with.

Hoverboard opened up with tools around it
Opening the hoverboard

Inside the hoverboard: control board, wiring and battery
The internal electronics: control board, wiring and sensors

Hub motor wheel removed from the hoverboard, held in hand
Extracting the hub motor

Fully disassembled hoverboard parts laid out on the floor
Complete disassembly

🔹 Planning

With the parts laid out, we sat down to plan how to turn them into a new machine: what to keep, how to mount the motor, and what size the frame should be. I worked on this planning stage with the team.

Team planning at a table with laptops and a tablet
Research and planning

Hand sketch of the frame and wheel with dimensions
Sketching and dimensioning the frame

🔹 Testing and the first frame

We bench-tested the hub motor on a DC power supply, then built a first frame out of aluminium extrusion and wood and test-fitted the motor.

Bench DC power supply used to test the hub motor
Testing the motor on a DC power supply

Aluminium extrusion frame with wooden plates
The structural frame: aluminium extrusion and wood

Fitting the hub motor wheel onto the wooden frame
Initial assembly and fit check

This is where we hit the wall: the hub motor couldn't be driven without the hoverboard's own control board. So we changed direction.

⚙️ Part 2: Our Own Drive System

Instead of fighting the hoverboard electronics, we built a simple drive system we fully controlled:

 Controller (ESP32 + my PCB)
        │  ESP-NOW (wireless)
        ▼
 ESP32 on the robot ──GPIO──▶ L298N motor driver ──▶ geared DC motors ──▶ wheels
                                   ▲
                             12 V supply
Geared DC motor, L298N motor driver and ESP32 laid out on a table
Motor + driver + ESP32

Close-up of the L298N motor driver board
The L298N motor driver
ComponentJob
ESP32 (robot)Receives commands over ESP-NOW and sets the driver's inputs
L298NDual H-bridge: switches the motor current and direction (IN1–IN4)
Geared DC motorsEnough torque to move the robot's weight
ESP32 (controller)Reads the buttons and sends commands to the robot

The L298N's IN1–IN4 pins set the direction of each motor. We didn't use the ENA/ENB enable pins, because we weren't doing PWM speed control at this stage: the motors are either on or off in each direction.

⚡ The Controller PCB (My Part)

My main job was the controller board: the handheld side that sends commands to the robot. I designed it in EasyEDA and then milled it on the lab's PCB mill.

🔹 Version 1: first schematic

The first version put an ESP32 DevKit V1 between two 15-pin headers, with four push buttons, an LED and an 18650 Li-ion battery holder drawn straight onto the board so the controller could run on its own battery.

Version 1 schematic: ESP32 between two 15-pin headers, four buttons, LED and 18650 battery holder
Version 1 schematic

Close-up of the schematic: push button U1 to GND, R1 and LED U5
Close-up: each button pulls an ESP32 pin to GND; R1 + U5 is the status LED

EasyEDA library search window for finding component footprints
Finding footprints in the EasyEDA library

First PCB layout in EasyEDA with the ESP32 outline and unrouted parts
Starting the PCB layout

🔹 Version 2: final board

For the final version I moved the battery off the board (it plugs into a 2-pin connector instead), switched to 8-pin female headers so the ESP32 can be pulled out and reused, and added a header for a joystick.

Version 2 schematic: ESP32 on four 8-pin headers, four buttons, LED, power connector and joystick header
Version 2 schematic

Version 2 PCB routing in EasyEDA
Routing the final board

EasyEDA Gerber export preview: 70 x 70 mm board with ESP32 DevKit V1, buttons, LED, CN1 and joystick header
Gerber export preview: 70 × 70 mm
RefPartPurpose
P1–P48-pin female headers (2.54 mm)Socket for the ESP32 DevKit V1
U1–U4SMD push buttonsFour control inputs, each switching an ESP32 pin to GND
U5 + R1SMD LED + 220 Ω resistorStatus indicator
CN1XH 2.54 mm 2-pin connectorBattery / power input
Joystick header5 pins: SW, VRY, VRX, +5V, GNDJoystick module (two analog axes + push switch)
Version 1Version 2
ESP32 mounting15-pin headers4 × 8-pin female headers
Power18650 holder on the boardExternal battery via CN1
Inputs4 buttons4 buttons + joystick header
LED resistor0 Ω placeholder220 Ω

The buttons are wired between an ESP32 pin and ground, so the code can use the internal pull-up resistors. That means fewer parts on the board, and a button reads LOW when it's pressed.

🔹 Milling

I exported the Gerbers from EasyEDA and milled the board on the lab's monoFab, using the same workflow as in Week 8: Electronics Production.

Milling the controller board

The milled controller PCB held up to the light
The milled controller PCB

🔹 The controller

The board went into a 3D-printed handheld enclosure, with four red buttons and an opening for the joystick.

CAD render of the controller enclosure with four red buttons
Controller enclosure in CAD

The printed white controller with red buttons held in hand
The printed controller

Controller parts: battery holder, battery, ESP32 and switch
Controller parts: battery, holder, switch and ESP32

🔧 Assembly

We first tested the drive system on a wooden base, coding and testing directions while it was still on the bench. The wooden base turned out to be too heavy and got in the way of the wheels, so it was replaced with a green acrylic sheet. The four motors and wheels were mounted underneath, with the electronics on top.

Wooden prototype base with four wheels, wiring and battery pack
The wooden prototype

Wooden prototype next to a laptop running the code
Coding and testing on the prototype

Hands assembling motors and electronics onto the green acrylic chassis
Assembling onto the acrylic chassis

Wiring the motors on the acrylic chassis at the workbench
Wiring everything up

Acrylic chassis with four wheels and the battery pack mounted on top
Acrylic chassis with motors, wheels and power

🔹 Assembly order

  • • Solder wires onto the motor terminals, add heat shrink and crimp ferrules
  • • Mount the motors and wheels on the chassis
  • • Wire the motors to the L298N outputs
  • • Connect the L298N's IN1–IN4 to the ESP32 and share the ground
  • • Power up, test each direction, then pair the controller over ESP-NOW

🤖 Final Machine

The finished DispatchR drives in all directions from the wireless controller. As a bonus, we attached a marker to it and let it draw on paper as it drove around 🖍️.

The finished robot: green acrylic chassis on four black wheels
DispatchR, finished

The finished robot from another angle
Another angle

The finished robot from a third angle
And one more

The robot driving over paper and drawing a line with a marker
"Our friend also likes to draw.."

🎬 The DispatchR film

Our group video: from waiting on prints to a robot that draws

✨ What I Learned

  • • Reusing consumer hardware sounds easy, but its parts are often locked to its own control board
  • • Torque matters more than speed when a motor has to move real weight, which is why we used geared motors
  • • Socketing the dev board on headers makes a PCB much easier to debug and reuse
  • • Using internal pull-ups for buttons keeps the board simpler
  • • A second PCB version is normal: moving the battery off the board and adding a joystick header made it far more flexible
  • • Changing direction early (hoverboard → own drive system) saved us more time than forcing the first plan
  • • In a group build, planning and clear interfaces (which board sends what, which pins go where) keep everyone in sync

📁 Design Files

Controller schematic, EasyEDA (.json)
Controller PCB layout, EasyEDA (.json)
Controller PCB Gerbers (.zip)