Robot - Wireless Communication: Receiver

In this post, I'll go over how to make the robot respond to commands sent by the transmitter. You'll need the parts outlined in a previous post. These parts include a motor driver, 433 MHz receiver, and some Arduino-compatible device. The robot chassis has limited space, so I used an Arduino nano clone.

The Receiver

The Arduino needs to respond to wireless commands by sending commands to the motor driver, which will ultimately drive the robot. Hook the 433 MHz receiver up to the Arduino as follows:

VCC --> Arduino 5V
GND --> Arduino GND
DATA --> pin 11

Power

At first, we had the Arduino and the motor driver running on 5 AA batteries. However, the Arduino exhibited odd behavior, like not responding to wireless commands after one had already been sent. With the motors running at half speed, they draw ~0.5 A, which was likely causing the Arduino to malfunction due to power loss. To fix this, a 9 V battery is used to power the Arduino and wireless receiver independent of the motors.

To run the Arduino off of a 9 V battery, connect:

9 V + --> Arduino VIN
9 V - --> Arduino GND

To recap, the motors are powered by 5 AA batteries, independent of any logic functions. The 433 MHz receiver, Arduino, and motor driver logic (VCC pin) are all powered from the 9 V battery.

Show Code

// Sketch used to respond to commands sent by transmitter.ino. 
// Uses VirtualWire and SparkFun dual motor driver
// Author: Zac DeMeo

#include <VirtualWire.h>

// Transmission rate 
int const RXRATE = 2000;
int const SERIALBAUD = 9600;

// Standby pin
byte const STANDBY = 3;

// Motor A pins
byte const PWMA = 5; // VirtualWire uses Timer1, so pins 5 and 6 MUST be used for PWM
byte const AIN1 = 7;
byte const AIN2 = 8;

// Motor B pins
byte const PWMB = 6;
byte const BIN1 = 12;
byte const BIN2 = 4;

// Commands
const char STOP = '0';
const char FORWARD = '1';
const char BACKWARD = '2';
const char CLOCKWISE = '3';
const char CCLOCKWISE = '4';

void setup() {   
  Serial.begin(SERIALBAUD);

  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(STANDBY, OUTPUT);
  pinMode(PWMA, OUTPUT);
  pinMode(AIN1, OUTPUT);
  pinMode(AIN2, OUTPUT);
  pinMode(PWMB, OUTPUT);
  pinMode(BIN1, OUTPUT);
  pinMode(BIN2, OUTPUT);

  vw_setup(RXRATE);
  vw_rx_start();         
}

void loop() {
  uint8_t buf[VW_MAX_MESSAGE_LEN];
  uint8_t buflen = VW_MAX_MESSAGE_LEN;

  if (vw_get_message(buf, &buflen)) {    
    digitalWrite(LED_BUILTIN, true);
    char message[20];    

    // Copy buffer into string
    for (int i = 0; i < buflen; i++) {
      message[i] = buf[i];      
    }

    // Null terminate string
    message[buflen] = '';

    Serial.println("Got " + String(message));  // Print command received

    char command = message[0];
    if (command == STOP) { // Stop
      halt();
    } else if (command == FORWARD) { // Move forward
      set(0, 1, 160);
      set(1, 1, 160);
      go();
    } else if (command == BACKWARD) { // Move backward
      set(0, 0, 160);
      set(1, 0, 160);
      go();
    } else if (command == CLOCKWISE) { // Turn clockwise
      set(0, 1, 150);
      set(1, 0, 150);
      go();
    } else if (command == CCLOCKWISE) { // Turn counterclockwise
      set(0, 0, 150);
      set(1, 1, 150);
      go();
    } 

  digitalWrite(LED_BUILTIN, false);
  }
}

/*
motor: 0 for motor A, 1 for motor B
direction: 1 for forward, 0 for reverse
speed: value from 0 to 255, inclusive
*/
void set(byte motor, byte direction, byte speed) {
  byte pwm;
  byte pin1;
  byte pin2;

  if (motor == 0) {
    pwm = PWMA;
    pin1 = AIN1;
    pin2 = AIN2;
  } else {
    pwm = PWMB;
    pin1 = BIN1;
    pin2 = BIN2;
  }

  if (direction == 1) {
    digitalWrite(pin1, HIGH);
    digitalWrite(pin2, LOW); 
  } else {
    digitalWrite(pin1, LOW);
    digitalWrite(pin2, HIGH);
  }

  analogWrite(pwm, speed);
}

void go() {
 digitalWrite(STANDBY, HIGH);
}

void halt() {
  digitalWrite(STANDBY, LOW);
}

How It Works

The loop() function is similar to my previous weatherstation posts. VirtualWire handles any incoming transmissions, storing them in a string, buf. Only the first character is of interest, and if it's one of the commands (i.e., STOP, FORWARD, BACKWARD, CLOCKWISE, CCLOCKWISE), the command is passed to the set() function.

set() specifies the direction and speed of one motor. It simply pulls the appropriate direction pins (e.g., AIN1 and AIN2) to HIGH or LOW depending on the desired direction. Then, it sets the speed by sending a PWM signal to the appropriate pin. Finally, go() is called, which sets STBY to HIGH, causing the robot to move.

Turning involves setting one motor to move forward and the other to move backward.

Conclusion

While the robot will respond to wireless commands, the control is rudimentary. The speed is manually defined in the robot's code, and sending commands through the Serial Monitor is clunky at best. The next step will be to use joysticks to control the robot, allowing precise control of both speed and direction.

Here's a short video of the robot in action. This was before I had my Arduino nano. As you can see in the above picture, the chassis is much less crowded now. I think one motor is not properly aligned, but that will be fixed soon.