How to build Pogobot (swarm robot): the whole process
209 steps to build Pogobot (swarm robot), from buying parts, printing and assembly to software, calibration and training, with the bill of materials, shop links and the …
Not sold and no kit. The creators' paper (arXiv 2504.08686 v2, 2025‑11) estimates about €250 per assembled robot, not itemised and without saying whether tax is included; the head board has to be made by an electronics manufacturing service
Buy parts
- Prepare parts for one robot
Prepare a belly and head, a 3v CR2 rechargeable Li-FePO4 battery, 3 motors, and all the different 3d printed parts.
- Buy compatible robot motors
Buy the compatible motors linked in the document; 3 motors are required for one robot.
- Source USB UART programming board parts
Prepare a UMFT234XF board, an 8-pin 0.5 mm SMD/SMT right-angle dual-contact FFC/FPC connector, an 8-pin 0.5 mm FFC/FPC cable, and a USB micro-to-USB cable.
Print and make
- Print all 3D parts
Obtain and print all parts from the “3d-addons” folder, then assemble them using its assembly instructions.
- Fabricate the USB UART programming board
Use the KiCad files in the “Hardware/usb-uart-progboard” folder to produce the small board used to program the robot by cable.
- Print the IR remote 3D structure
Print pogoremote_down.stl and pogoremote_up.stl to form the 3D structure of the small IR remote.
- Fabricate the IR wall LED strip on flexible PCB
Not finding a suitable LED strip, the authors designed remote_leds_wall_strip and produced it on a flexible PCB.
- Print the pogobject 3D structure
The pogobject is a large PCB holding all the electronics and is placed inside a 3D printed structure.
- Print the skirt, capsule, and hat
Print the skirt, capsule, and hat for your belly version in PLA on an Ultimaker2+ at a 0.2mm layer height, without support or brim. Turn the hat over before printing it.
- Release the capsule tabs
After printing the capsule, gently cut underneath to release the tabs.
Assemble
- Review the hardware schematic
First review the global hardware diagram to understand the robot's hardware layout.
- Connect the cable programmer
Connect the USB-to-UART device between the computer and the FFC/FPC connector on the head to program the robot by cable.
- Choose a charging method
Charge the robot through the programming cable or through the plus and minus pads on the head; the multi-robot charger uses pogopins to contact those pads.
- Assemble the multi-robot charger
Fabricate the charger from the PCB CAD files in the folder, then install the listed pogopin, one 5.1 mm panel-mount power jack, and the M3-screw-mounted 3D-printed feet and contact cones.
- Assemble the small IR remote
Combine a pogobot head, a usb-uart-progboard and the printed 3D structure, fixing them with 2 M3x10mm screws.
- Assemble the big IR remote with LED strip
Combine a pogobot head, remote, remote_Leds_strip and the 3D structure into the big remote; its LEDs are TSAL6200.
- Assemble the IR wall
To build an IR wall you need a pogobot head, remote, remote_leds_wall_ctrl and remote_leds_wall_strip; the LEDs are VSM3940x01.
- Fit casters and the weight
The structure sits on 4 casters with metal ball (pololu item 953) so it can be pushed by the robot, and an aluminum weight holds it in place.
- Place the motors in three holes
First, place the motors inside the three holes.
- Place the robot inside the capsule
Then, place the robot inside the capsule.
- Place robot and capsule in skirt
Finally, place the robot together with the capsule inside the skirt.
- Connect robot and programming board
Connect the robot to the programming board using the ribbon cable.
- Connect the board to the computer
Connect the programming board to the computer with USB.
Software
- Write C and select an uploader
Pogobot programs are written in C. Upload a single robot through a USB cable, or multiple robots through a remote infrared uploader (“shower” / walls).
- Install the SDK and toolchain
Install the Pogobot SDK and toolchain before compiling programs.
- Open the helloworld example
After installing the SDK, navigate to the `helloworld` example under `pogobot-sdk/examples/helloworld`.
- Create the program directory
Create a `my_program` directory containing `main.c` and a `Makefile`.
- Copy the example Makefile
The Makefile is essentially the same in every program, so it can be copied from the examples.
- Add the standard program skeleton
In `main.c`, include `pogobot.h`, call `pogobot_init()`, and use comment placeholders for reading sensors, communicating, moving, and blinking LEDs inside `while (1)`. End the loop with `msleep(10)`.
- Initialize and report readiness
Call `pogobot_init()` to initialize the robot, then print `init ok`.
- Set blue LED and left motion
Set the LED color to blue `(0, 0, 255)`, run the left motor at full speed, and stop the right motor.
- Wait and print the greeting
Wait for `500` milliseconds, then print `HELLO WORLD !!!` to the serial terminal.
- Set red LED and right motion
Set the LED color to red `(255, 0, 0)`, stop the left motor, and run the right motor at full speed.
- Wait and repeat continuously
Wait another `500` milliseconds, then continuously repeat the blue-LED left-motion and red-LED right-motion sequence inside `while (1)`.
- Compile and upload the program
Compile the program after installing the SDK and toolchain. Upload a single robot through a USB cable, or multiple robots through a remote infrared uploader.
- Initialize the Program
Every program must call pogobot_init() first. Without initialization, most hardware features will not work.
- Set the Head LED Color
Call pogobot_led_setColor(r, g, b) to set the head LED color, with each value ranging from 0 → 255. The example sets the LED to red.
- Wait for a Set Time
Use msleep(milliseconds) to wait for the specified number of milliseconds. The example waits 500 ms.
- Set Vibration Motor Power
Pogobot has three vibration motors: motorR, motorL, and motorB. Power levels are motorStop = 0, motorQuarter = 256, motorHalf ≈ 512, motorThreeQuarter ≈ 716, and motorFull = 1023.
- Print Debug Messages
Use the standard C printf function to print messages. Messages appear in the serial terminal and are extremely useful for debugging.
- Read Ambient Light Sensors
Call pogobot_photosensors_read(0) to read an integer value from an ambient light sensor. Sensor IDs 0, 1, and 2 correspond to back, front-left, and front-right.
- Read Battery Voltage
Call pogobot_battery_voltage_read() to read the battery voltage. The returned value is in millivolts.
- Reset and Read a Stopwatch
Declare a time_reference_t timer and reset it, then perform the computation. Read the elapsed time in microseconds and print it with printf.
- Initialize a one-second periodic timer
Declare a time_reference_t timer and set its period to 1000000 microseconds. When it expires, print "1 second elapsed" and offset the timer origin by 1000000 microseconds.
- Follow the infrared message workflow
Send a message, periodically update the infrared system, check whether messages arrived, and read the messages.
- Broadcast a short message in all directions
Create a character message containing "hello" and send it with pogobot_infrared_sendShortMessage_omni. This broadcasts in all directions.
- Update infrared and receive a message
Call pogobot_infrared_update to update the infrared system and check whether a message is available. Read the next message with pogobot_infrared_recoverNextMessage, then print "Message received".
- Use the distributed genetic algorithm program
Use the distributed genetic algorithm demo program at examples/demo_d2_9BIS in the SDK. It demonstrates infrared swarm communication, distributed decision-making, mutation and selection, LEDs, motors, and random genome generation.
- Generate a random binary genome
Each robot generates a random binary genome.
- Compute a fitness score
Each robot computes a fitness score for its genome.
- Broadcast the genome
Each robot broadcasts its genome to its neighbors.
- Copy a stronger genome from a neighbor
When a received genome has higher fitness than the current fitness, copy that stronger genome into the robot's data.
- Occasionally mutate the genome
Each robot occasionally mutates its genome.
- Represent genome and fitness as data
Define a my_data_t structure with genome stored as uint16_t and fitness also stored as uint16_t.
- Broadcast genome data
Send the my_data structure with pogobot_infrared_sendLongMessage_omniGen, using sizeof( my_data ) to specify its size.
- Receive and compare genomes
Compare the received fitness with my_data.fitness. If the received fitness is higher, copy the received genome into my_data.genome.
- Mutate one genome bit
Use an XOR operation to flip the genome bit specified by n.
- Compile the firmware
Run make inside the project folder. A successful compilation produces build/firmware.bin and build/firmware.elf.
- Confirm compilation output
Confirm that build/firmware.bin and build/firmware.elf were obtained.
- Connect through USB
Run make connect TTY=/dev/ttyUSB0 to connect to the robot. Replace /dev/ttyUSB0 with the correct serial device on your machine.
- Enter the terminal workflow
After running make connect, press ENTER.
- Wait for the prompt
Wait for the prompt to appear.
- Use terminal commands directly
Use terminal commands directly in the terminal.
Calibrate and test
- Enter configuration mode
Connect D9 to VCC, then restart the Pogobject to configure the Wi-Fi SSID and password.
- Connect to configuration Wi-Fi
Connect to the Wi-Fi named PogobjectConfig using the password pogobotconfig.
- Enter network information
Open http://192.168.4.1 in a browser and enter the network information.
- Exit configuration mode
Reconnect D9 to GND, then restart the Pogobject.
- Confirm network connection
Confirm that the Pogobject is connected to your network.
- Check startup LEDs
When correctly powered, LEDs usually blink several colors during startup.
- Confirm successful upload
When upload succeeds, robots typically turn green.
- Observe robot behavior
Observe LEDs, movement, and debug prints.
- Accept the default Singularity configuration
During installation, use the default option if asked about a custom configuration or init file. The default action keeps the currently installed versions of /etc/singularity/init and /etc/singularity/singularity.conf.
- Check Singularity version
Run singularity version to check the installed Singularity version.
- Check charger polarity before power-up
Before plugging in a robot, use a voltmeter to verify that the inner contact of the power plug is +5v and the outer contact is ground.
- Select LED power source with the jumper
This version can use USB power or an external supply (up to 12v) to extend the remote range; the jumper near the power jack sets the LED power source.
- Test the SDK compilation
Run the container's test_install app to check whether the SDK compiled successfully.
- Quickly Calibrate the Motors
Call pogobot_quick_calibrate() with a power between 0 and 1023, and obtain integer motor values through leftMotorVal and rightMotorVal. Lower power makes calibration less precise, so 524 to 716 is recommended.
- Use the Configurable Calibration
Call pogobot_calibrate() with power, startup duration, sampling duration, number of tries, and correction; each try starts the motors for startup_duration ms before collecting IMU data for try_duration ms. Quick calibration uses 500 ms startup duration, 750 ms sampling duration, 15 tries, and a correction of 50.0f.
- Use Negative Correction for Backward Mounting
If the Pogobot is mounted backward, correction may need to be assigned a negative value. The correction is applied to one of the motors during each calibration try.
- Keep the other parameters unchanged
Initialize the other parameters once, then do not change them.
- Display filtered IMU values
Print IMU values with and without the Kalman filter to the console; i is the current time in milliseconds.
Data and training
- Gradually converge toward an optimal genome
By comparing and copying stronger genomes and occasionally mutating, the robots gradually converge toward an optimal genome.
Use it
- Experiment with swarm intelligence applications
Use this type of program to experiment with swarm intelligence, collective optimization, decentralized coordination, and emergent behavior.
- Run the uploaded program
Run run in the terminal to start the uploaded program.
- Start all robots
Run rc_start to start all robots.
- Change the object message over WiFi
The pogobject is composed of a dfrobot firebeatle, pogobot head and pogo_object PCB, with TSAL6200 LEDs; over WiFi you can send commands to the head to change the message sent by the object.
- Follow the web page instructions
Open the web app and follow the instructions provided on its web page.
- Play an animation
Call anim_same to display an animation.
- Blink all LEDs
Make all LEDs blink number_of_blinks times.
Parts
- Head board: a Lattice iCE40UP5K FPGA (main README and paper; the SDK README says iCE40LP8K) running a VexRiscv 32-bit RISC‑V softcore through LiteX; 4 IR transceivers (TS4231), 3 light sensors, a 6-axis IMU, 1 LED, an FFC programming port and charging pads
- Belly board: power and charge management, 3 motor drivers, 4 RGB LEDs
- 3 vibration motors (one on each side, one at the back); a CR2-size LiFePO4 rechargeable cell (3 V in the README, 3.3 V in the paper)
- PLA prints: capsule, skirt (holding brushes, TPU legs, toothbrush heads or two wheels) and hat; Pogobot 2026 adds tracking rings, red filters and an arrow
- Programming: a USB‑UART board (UMFT234XF with an 8-pin 0.5 mm FFC connector and cable); optional Pogocharger pogo-pin charging board, Pogoremote/PogoShower IR controllers and Pogowall IR wall
Tools
- 3D printer (the docs used an Ultimaker 2+ with PLA, 0.2 mm layers, no supports)
- An electronics manufacturing service for the head board; soldering for the other boards
- Multimeter (to check the supply polarity before plugging in the charger)
- A computer running Ubuntu (the SDK supports only Ubuntu, tested on 20.04; other distributions use a Singularity container)
Skills
- C programming, the Linux command line with make, and a serial terminal
- Expert mode: the LiteX, Yosys, nextpnr, IceStorm and RISC‑V GCC toolchain, for changing the FPGA gateware
- KiCad 6 for the boards and 3D modelling for the shell and locomotion parts
Software
- pogobot-sdk: a C API (LEDs, motors, light sensors, IMU, IR messaging, timers) with examples, including a distributed genetic-algorithm demo
- pogobios and pogolib: the on-board BIOS and low-level library; prebuilt firmware up to API v2.6
- Pogosim simulator (C++20/C17, SDL2, Box2D; v0.10.10, 2026‑06‑22): runs the robot C code unchanged, with batch experiments
- pogotrack video tracking, the pogo-utils add-on library and the PogoWallApp web control for the IR wall