Johnny-Five Robotics and Hardware Programming Framework

The Navigator class is a custom abstraction designed for the BOE Bot (or similar differential drive robots) using johnny-five continuous servos. It handles the inverse relationship between left and right servos (since they are mounted oppositely) and provides high-level movement commands.

Initialization

To create a Navigator instance, pass an options object specifying the pins for the right and left servos.

Note: BOE Bot continuous servos are calibrated to stop at 90°. You can specify a custom center value in the options.

Movement API

• forward(speed): Moves the bot forward. speed is a value from 0 (stopped) to 5 (fastest).
• reverse(speed): Moves the bot in reverse. speed is a value from 0 to 5.
• stop(): Stops all movement.
• left(): Performs a turn to the left.
• right(): Performs a turn to the right.
• pivot(which, time): Performs a pivot turn. which accepts strings like forward-right, forward-left, reverse-right, or reverse-left. time is the duration of the pivot in milliseconds.
• move(right, left): Low-level method to set specific servo positions directly.

var five = require("johnny-five");

// Assuming a Board is ready...
var bot = new Navigator({
  right: 10,
  left: 11,
  center: 90
});

bot.forward(3);
bot.pivot("forward-left", 500);
bot.stop();

This guide demonstrates how to build a line-following robot using a reflectance array (like the Pololu QTR-8A) and continuous servos for wheels.

Core Logic

1. Reflectance Array: Use five.IR.Reflect.Collection to read sensor data. The sensors detect light/dark transitions to determine the line's position.
2. Calibration: Use eyes.calibrateUntil() to capture ambient light and dark values. This data can be persisted to a file (e.g., .calibration) using eyes.calibration and reloaded via eyes.loadCalibration() to avoid repeated manual calibration.
3. Driving Rules: Map the sensor's line value (emitted via the line event) to specific motor speeds and directions.
4. Continuous Servos: Control the wheels using five.Servo.Continuous. Use methods like .stop(), .cw(speed), or .ccw(speed) to adjust movement.

Implementation Example

var five = require("johnny-five");
var board = new five.Board();

board.on("ready", function() {
  var eyes = new five.IR.Reflect.Collection({
    emitter: 13,
    pins: ["A0", "A1", "A2", "A3", "A4", "A5"],
    freq: 20
  });

  var wheels = {
    left: new five.Servo.Continuous(10),
    right: new five.Servo.Continuous(9)
  };

  // Calibration logic
  eyes.calibrateUntil(function() {
    // Return true when calibration is finished
    return false; 
  });

  // Driving logic
  eyes.on("line", function(err, line) {
    // 'line' value is used to determine movement rules
    if (line < 1000) {
      wheels.left.cw(0.01);
      wheels.right.ccw(0.07);
    }
    // ... additional rules
  });
});

// This is an example of a line following robot.  It uses a
// Pololu QTR-8A reflectance array to read a line on my
// counter drawn with electrical tape.  You can see the
// bot in action here: https://www.youtube.com/watch?v=i6n4CwqQer0

var fs = require("fs");
var five = require("johnny-five");
var board = new five.Board();

// Setup Standard input.  We use this to let the bot know that we"ve finished
// calibrating
var stdin = process.stdin;
stdin.setRawMode(true);
stdin.resume();

var calibrationFile = ".calibration";

// VERY simple driving rules.  It uses a mapping from the line value that comes
// from the Reflectance Array to the left and right wheel of the bot.n// This can be made much better, it is a good start.
var drivingRules = {
  0: {
    left: {
      dir: "cw",
      speed: 0.01
    },
    right: {
      dir: "ccw",
      speed: 0.07
    }
  },

  1000: {
    left: {
      dir: "cw",
      speed: 0.02
    },
    right: {
      dir: "ccw",
      speed: 0.05
    }
  },

  2000: {
    left: {
      dir: "cw",
      speed: 0.04
    },
    right: {
      dir: "ccw",
      speed: 0.05
    }
  },

  2500: {
    left: {
      dir: "cw",
      speed: 0.05
    },
    right: {
      dir: "ccw",
      speed: 0.05
    }
  },

  3000: {
    left: {
      dir: "cw",
      speed: 0.05
    },
    right: {
      dir: "ccw",
      speed: 0.04
    }
  },

  4000: {
    left: {
      dir: "cw",
      speed: 0.05
    },
    right: {
      dir: "ccw",
      speed: 0.02
    }
  },

  5001: {
    left: {
      dir: "cw",
      speed: 0.07
    },
    right: {
      dir: "ccw",
      speed: 0.01
    }
  }
};

board.on("ready", function() {

  // Create an instance of the reflectance array.
  var eyes = new five.IR.Reflect.Collection({
    emitter: 13,
    pins: ["A0", "A1", "A2", "A3", "A4", "A5"],
    freq: 20
  });

  // These are the continuous servos that control the wheels
  var wheels = {
    left: new five.Servo.Continuous(10),
    right: new five.Servo.Continuous(9)
  };

  // Make the eyes and wheels available in the REPL UI
  this.repl.inject({
    eyes: eyes,
    wheels: wheels
  });

  // When the bot starts up, enable the IR emitters and tell the wheels
  // to stop.  Calibrate the device.  When complete, drive.
  function init() {
    eyes.enable();
    wheels.left.stop();
    wheels.right.stop();

    calibrate(drive);
  }

  // Calibrate the bot.  If the calibration has been persisted, use it.
  // If not, calibrate the bot until the user presses a key.  Move the sensor
  // over light and dark regions several times.  Persist the calibration data
  // to a file so it doesn"t need to do it again next time.
  function calibrate(whenComplete) {
    var savedCalibration, calibrating = true;

    if (fs.existsSync(calibrationFile)) {
      eyes.loadCalibration(JSON.parse(fs.readFileSync(calibrationFile)));
      whenComplete();
      return;
    }

    console.log("Calibrating.  Press a key...");

    eyes.calibrateUntil(function() {
      return !calibrating;
    });

    stdin.once("keypress", function() {
      calibrating = false;
      console.log("Done:", eyes.calibration);
      fs.writeFile(calibrationFile, JSON.stringify(eyes.calibration));
      whenComplete();
    });
  }

  // Drive the bot.  Every time a line value event comes in, figure out which
  // rule to follow from the rules mapping.  Tell the left and right wheels
  // which direction and how fast to spin.
  function drive() {
    eyes.on("line", function(err, line) {
      var rule;
      var threshold = Object.keys(drivingRules).find(function(r) {
        return line <= parseInt(r);
      });

      if (!threshold) {
        console.log("Could not find threshold for " + line);
      }

      rule = drivingRules[threshold];

      wheels.left[rule.left.dir](rule.left.speed);
      wheels.right[rule.right.dir](rule.right.speed);
    });
  }

  // Start the bot
  init();

});