- Project Overview
- Features & Operation
- Hardware Requirements
- Software Requirements
- Installation
- Project Structure
- Acknowledgments
- License
The Hexapolo Bot is a six-legged robot that can find and follow a person by listening to their voice and looking at them. It starts by saying “Marco” and waits for someone to reply “Polo.” When it hears the reply, the robot uses four microphones to figure out which direction the sound came from. Then, it turns to face that direction and checks with its camera if a person is there. If it sees someone, it walks toward them and stops when it is about one meter away. After that, the robot will follow the person as they move.
The project’s goal was to combine sound detection, camera vision, and motor control so the robot can interact with people.
| Front View | Back View |
|---|---|
 |
 |
| Below View | Inside View |
|---|---|
 |
 |
| Live Video Feed from the Esp32Cam |
|---|
 |
Video clip of hexapolo having its first steps :
video_2025-05-19_22-23-03.mp4
Video clip of hexapolo tracking a person :
video_2025-05-28_01-32-11.mp4
The Legs and mechanical links to control the legs :
T-bar, gears and motors to rotate heads and control the movement of the legs :
Please note that the following diagram does not include the USB connections between the
FTDI board and the Raspberry Pi as well as that between the microphone array (also not
included) and the Raspberry Pi. Furthermore, note that the speaker amplifier will also be wired
to a 3.5mm headphone jack, which will plug into the microphone array, through its A+ and A-
ports.
- Keyword Detection: The robot will listen for the word “Polo” and react when it hears it.
- Sound Direction Estimation: It will use four microphones and a time difference of arrival (TDoA) method to figure out which direction the sound came from.
- Turning Toward the Sound: After detecting the direction of the sound, the robot will rotate to face that direction.
- Visual Detection: The robot will use its camera to check if there is a person in front of it.
- Walking Toward the Person: The robot will move toward the person and stop when it is about 50 cm away.
The following is an overview of the decision tree outlining Hexapolo's main algorithm :
-
Raspberry Pi 1
Note : none of our scripts were tested on any Raspberry Pi other than RPi1. However, because of good backward compatibility, all scripts tested on RPi1 should work on any next iteration of the board. Furthermore, you might encounter a few difficulties linked to the limited computing capabilities of the RP1. Using a more recent iteration of the Raspberry Pi, such as the RPi4, will make the reproducibility process significantly easier.
- 2S 7.4V LiPo battery (e.g. 2S 7.4V lipo 1100mAh 15C with xt60 connector)
- DC-DC buck converter (e.g. WaveShare 6-36V to 5V/3.3V 4A DC-DC buck step down converter)
- Mic Array (e.g. ReSpeaker Mic Array v2.0)
- esp32 Camera (e.g. AI thinker esp 32-cam)
- FTDI USB-to-serial (e.g. FTDI FT232RL USB To TTL Serial Adapter Module)
- Buzzer (e.g. Purecrea Piezo buzzer active)
- Speaker
For our implementation, we stripped out both the speaker and the amplifier from an unbranded speaker. In the same way, you could use whatever speaker with a jack plug you want. Note that the whole build is quite heavy proportionally to the motors, choose your speaker carefully, the lighter the better. We chose this component to save weight, and you might find this approach useful as well.
- 2x 300rpm 6V n20 motor (200rpm motors would also work)
- 1.2A DC Motor Driver (e.g. DFRobot Fermion TB6612FNG 2x1.2A DC Motor Driver)
- Battery Protection Board (e.g. 8.4V 2S 20A Lithium Battery Protection BMS Protection Board)
- 10x 8x4x3 Ball Bearing
- Electrical Switch
- USB-A to Micro-USB cable
- USB-A to Mini-USB cable
The combined weight of all the cables and wires might be too heavy for the motors to move effectively with the rest of the build. We suggest that you cut them short and solder the wires inside.
- Linux (Debian) running on the RPi1
Due to the multiple features of our project, the use of computer vision and audio processing, a large, yet lightweight, set of dependencies need to be installed. They are all listed in the following file below :
Among the list of software requirements, you'll find program that are crucial to make this project work. More specifically :
On Linux :
- Minicom : serial communication program used to run program in the Raspberry Pi from remote shell. This solution is heavily used and eliminates the need to connect additional peripherals to the RPi1 for control. Minicom GitLab repository
On Windows :
- PuTTY : SSH and telnet client for Windows plateform. PuTTY website
On the RPi1, download the libraries as a .tar.gz file :
pip download --no-binary :all: -r requirements.txt
Then, copy the downloaded libraries to a usb flash drive and transfer them to the RPi1.
On your laptop :
pip install -r requirements.txt
The repository is organized as follows, important files have been highlighted:
CAD/
├── Electrical Components # 3D files for a few electrical components we use
│ ├── ...
│ └── ...
├── Electronic plate
├── Internal Mechanics # 3D files for each mechanical piece of the gearbox
│ └── ...
├── Moving Parts # 3D files for each piece of the body
│ └── ...
└── New head with larger base plate # 3D files for each piece of the head
└── ...
docs/
software/
├── control # Basic scripts to control hexapolo
│ └── __pycache__
├── esp # Scripts handling the communication between the laptop and hexapolo
├── laptop # Scripts processing the video feed from the esp32 cam and communicating with it via Wifi
├── machine_learning # Scripts used to train the ML model
└── pi # Scripts running on the RPi 1
├── model
│ ├── ...
│ └── ...
└── usb_4_mic_array # Scripts related to audio processing with the mic array
├── single_frequency_sound_recognizance # Scripts to recognize a single frequency sound in the case where the voice recognition model couldn't work
└── test # Unit tests
We drew inspiration for Pilotgeek's project (YouTube video) that demonstrated a similar concept of a six-legged robot. His work provided valuable insights and helped us build Hexapolo.
This project is licensed under the MIT License.
You are free to use, modify, and distribute this software, provided that proper attribution is given to the original authors. For more details, please refer to the LICENSE file included in this repository.