Connecting to sources…

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

Documents