Published September 27, 2020 © GPL3+

Mirroring Robot Movements with Packet Radios

Use a couple of packet radio boards to mirror one robot's movements in the other one from up to 500m away.

IntermediateFull instructions provided4 hours1,158

Things used in this project

Hardware components

Adafruit Feather M0 RFM69HCW Packet Radio

SparkFun Full-Bridge Motor Driver Breakout - L298N

DC motor (generic)

Software apps and online services

Microsoft VS Code

Arduino IDE

Hand tools and fabrication machines

Soldering iron (generic)

Story

Swarm Robots

The idea of having a large number of robots doing tasks in unison is nothing new, as there have been quadcopters drawing designs with LEDs at events like the Sochi Olympics, and convoys of trucks all moving together. What I wanted to do with this project was explore how this could be accomplished using cheap hardware and at greater distances apart, since Bluetooth can only reach about 45m away before the signal becomes too weak.

Packet Radio Principles of Operation

The Adafruit Feather M0 used for this project contains an onboard RFM69 radio module, and it can operate in one of two modes. The first one is a continuous stream of data from one point to the other, much like how a pair of walkie-talkie radios would function. This can lead to a lot of data being missed or corrupted, and it's more difficult to build an application layer on top of it.

The other way to operate the radio module is packet mode, which collects a buffer of data and sends it in a packet, akin to how the UDP protocol works. This way, information can be encrypted and checked for errors, making information transfer more reliable. Once the packet is sent, the receiver sends an acknowledgement to the sender that indicates a successful transference.

The Chassis

Designing a robot chassis from scratch and gathering the necessary components takes a long time and can become very costly. Rather, using a kit is a much faster and cheaper option. I went with one of Elegoo's Smart Car V3 Kits, which contain everything needed for a robotic car, including motors, a motor controller, rechargeable batteries, and a servo mount. The kit is solidly constructed from laser-cut acrylic panels and milled aluminum pieces. If you're curious about how to assemble it, you can view one of my other projects here.

Hardware and PCB Design

As alluded to before, this project uses a pair of Adafruit Feather M0 with RFM69 Packet Radio boards. One is set up to send movement data, and the other receives it. In addition, each robot has four DC motors with gearboxes, a custom L298N motor driver, and a battery pack. One of my previous projects used several Particle Xenon boards to control the same robot, and those boards also have the same pinouts (both feathers), so I was able to quickly solder together a few more PCBs and plug in the packet radio feathers instead.

Assembly

Because I had already assembled the two chassis, I was able to skip that part and move straight to soldering the boards together. First, I soldered the headers for the feather and L298N, along with two connectors for power. Next, I added a single WS2812B LED to each PCB for future use. Finally, I wired up the 5v regulator. All of this then got placed onto the chassis and attached with a single 3mm machine screw.

Programming

This portion of the project was probably the most difficult, since several things need to happen at the same time to get any communication and/or movement between the two cars. The program is essentially two separate programs which are defined by either defining "LEADER" or "FOLLOWER" as a preprocessor directive. Movements are stored as Movement struct objects, which each contain a left and right motor value, along with the duration of the movement. If a robot has been designated as a leader, it has an address, destination address, and a series of pre-planned movements. If it's a follower, it simply has an address (same as destination of leader) and a queue to store its movement history (to be used later). Both devices then initialize their radio modules and motor pins.

Inside of the main loop, the leader goes through each movement and sends it to the receiver in the form of a serialized data packet. If it gets a success message back, the leader proceeds with its move. Meanwhile, the follower waits for a new movement to come in, and once one arrives, it parses the packet into a Movement object and then runs the motors.

Taking It All for a Test Run

The video below shows the process of building the robot, programming it, and then taking the two cars out for a test run.

As you can see, they worked very well. The sender was able to transmit its movements to the receiver, which then got decoded and translated into the identical movement. In the future, I would like to make the sender robot move autonomously, and then have the receiver move just behind it in a sort of convoy.

Code

#include "pinDefs.h"
#include <queue>
#include <Adafruit_NeoPixel.h>
#include <RHReliableDatagram.h>
#include <RH_RF69.h>

#define MOVEMENT_DELAY 100
const uint8_t motorPins[4] = {MOTOR_IN1, MOTOR_IN2, MOTOR_IN3, MOTOR_IN4};

// only uncomment ONE based on its role!
//#define LEADER
#define FOLLOWER

struct Movement
{
    int16_t leftMotor, rightMotor, movementTime;
};

#ifdef LEADER
#define ADDRESS 1
#define DEST_ADDRESS 2
const Movement movements[] = 
    {{200, 200, 1000}, {50, -50, 2500}, {-100, -100, 750}, 
    {-50, 50, 480}, {200, 200, 1000}, {-150, 200, 600}, {200, -150, 600}, 
    {-100, -100, 1000}, {0, 0, 4000}, {100, 200, 2000}};

#endif
#ifdef FOLLOWER
#define ADDRESS 2
std::queue<Movement> movementHistory;

#endif

Adafruit_NeoPixel pixel(1, RGB_LED_PIN, NEO_GRB + NEO_KHZ800);
RH_RF69 rf69(RFM69_CS, RFM69_INT);
RHReliableDatagram rf69_manager(rf69, ADDRESS);

void setup()
{
    Serial.println(115200);
    radioInit();
    pixel.begin();
    for(uint8_t i = 0; i < 4; i++)
    {
        pinMode(motorPins[i], OUTPUT);
    }
}

uint8_t buf[RH_RF69_MAX_MESSAGE_LEN];
uint8_t data[] = "OK";

void loop()
{
    
    #ifdef LEADER
    uint8_t radioPacket[6];
    Movement movement;
    for(uint8_t movementNum = 0; movementNum < sizeof(movements) / sizeof(Movement); movementNum++)
    {
        movement = movements[movementNum];
        bool success = false;
        while(!success) {
            radioPacket[0] = movement.leftMotor >> 8;
            radioPacket[1] = movement.leftMotor & 0xFF;
            radioPacket[2] = movement.rightMotor >> 8;
            radioPacket[3] = movement.rightMotor & 0xFF;
            radioPacket[4] = movement.movementTime >> 8;
            radioPacket[5] = movement.movementTime & 0xFF;
            Serial.printf("Sending leftMotor=0x%04x\n", (radioPacket[0] << 8) + radioPacket[1]);
            if(rf69_manager.sendtoWait((uint8_t *)radioPacket, 6, DEST_ADDRESS)) {
                uint8_t len = sizeof(buf);
                uint8_t from;
                if(rf69_manager.recvfromAckTimeout(buf, &len, 2000, &from)) {
                    Serial.println(F("received by client"));
                    success = true;
                } else Serial.println("Failed to receive");
            } else Serial.println(F("Failed to send"));
            if(success) {
                runMotors(movement);
            }
        }
    }
    #endif
    #ifdef FOLLOWER
    if(rf69_manager.available()) {
        uint8_t len = sizeof(buf);
        uint8_t from;
        Movement movement;
        if(rf69_manager.recvfromAck(buf, &len, &from)) {
            movement.leftMotor = (buf[0] << 8) + buf[1];
            movement.rightMotor = (buf[2] << 8) + buf[3];
            movement.movementTime = (buf[4] << 8) + buf[5];
            Serial.printf("Packet contents= %d, %d, %d\n", movement.leftMotor, movement.rightMotor, movement.movementTime);
            movementHistory.push(movement);
            if(rf69_manager.sendtoWait(data, sizeof(data), from)) {
                runMotors(movement);
            } else Serial.println(F("Send failed"));
        }
    }
    #endif
}

void radioInit()
{
    pinMode(RFM69_RST, OUTPUT);
    digitalWrite(RFM69_RST, LOW);

    // manual reset
    digitalWrite(RFM69_RST, HIGH);
    delay(10);
    digitalWrite(RFM69_RST, LOW);
    delay(10);

    if (!rf69_manager.init()) {
        Serial.println("RFM69 radio init failed");
        while (1);
    }
    Serial.println("RFM69 radio init OK!");
    if (!rf69.setFrequency(RF69_FREQ)) {
        Serial.println("setFrequency failed");
    }
    rf69.setTxPower(20, true);
}

void runMotors(Movement & toMove)
{
    int16_t m1 = (toMove.rightMotor > 0) ? toMove.rightMotor : 0,
            m2 = (toMove.rightMotor > 0) ? 0 : -toMove.rightMotor,
            m3 = (toMove.leftMotor > 0) ? toMove.leftMotor : 0,
            m4 = (toMove.leftMotor > 0) ? 0 : -toMove.leftMotor;
    int16_t motorVals[4] = {m1, m2, m3, m4};

    for(uint8_t i = 0; i < 4; i++)
        analogWrite(motorPins[i], motorVals[i]);

    delay(toMove.movementTime);

    for(uint8_t i = 0; i < 4; i++)
        analogWrite(motorPins[i], 0);
}