What Is a Robot?

When people think of robots, they think of a physical device performing “programmed actions.” Programmed actions can include motion, sound, or blinking parts.

The motion of mechanical devices can evoke very human-like expressions, as demonstrated by the Sony dancing robots. In addition to novel actions like dancing, robots can also serve some “useful” function, such as feeding your cat when you are not at home or industrial uses such as building an automotive part.

From a computer science perspective, robots are based on several abstractions, as illustrated in Figure 12-1.

Figure 12-1. Robot abstractions

At the lowest levels, robots are made of actuators and sensors.

An actuator is a part that converts energy into motion. There are different types of actuators. For example, the motors that turn the wheels on a remote control car are rotational actuators. Your bicep muscle is a linear actuator.

A sensor is an input to the system in the form of data about the environment. For example, your phone knows which direction is down by reading which axis of its accelerometer most closely matches Earth’s gravitational pull.

From a hardware perspective, building a robot is about putting together a system of inputs (sensors) and outputs (actuators). These parts communicate over a data bus, such as I2C or SPI. Robots can perform actions depending on the inputs and their plans and heuristics (decision-making processes).

Why Build Robots in Node.js?

Depending on your background, there are different reasons Node.js is a good choice for creating robots.

The Tessel Project

To build robots, you need hardware. If you are new to hardware, the activation energy might be too high to get started.

You might be able to buy a sensor or a component, but it can feel like starting from scratch every time: get the component, read the datasheet, and figure out what its power requirements are and how to turn it on.

Arduino libraries challenge this notion, but the Arduino programming language is still relatively low level. Moreover, there is no single system for the community to contribute libraries or organize a project with, such as a manifest file like the package.json from a project in Node.js.

However, Node.js libraries for hardware components is an increasing phenomenon. The open source Tessel Project in particular creates modular components (such as a climate sensor) that easily plug into microcontroller boards and come with npm installable libraries. The project also explicitly promotes community-created modules: npm libraries for commodity hardware parts, such as breakout boards from Adafruit and SparkFun, along with community-member instructions on how to wire the component. You can see Tessel modules and community modules at http://tessel.io/modules. Tessel modules let you quickly experiment with motors, sensors, and other components without having to think too much about underlying mechanics or electronics (see Figure 12-2).

Figure 12-2. Tessel 2 with servo module and a community-contributed motion sensor

When you want to start building a robot with Tessel, take a look at the following modules:

Servo module

The servo module is based on a PCA9685 PWM controller. This module also provides a power plug to drive motors from an external power supply. Managing power is important when working with motors, as forces and voltages from a motor can potentially harm a micrcontroller.

Relay module

The relay module can help you to power on/off devices from a standard 220V power plug. This means you can take existing electronic devices like a floor lamp, a toaster, or an industrial machine and make them part of your robot’s output. The relay connects these things to your JavaScript code.

Distance sensors

For driving robots, it is often important to detect obstacles. The community-contributed modules SEN10737p and HCSR04 are nice plug-and-play distance-sensing solutions.

Potentiometer

To simulate values from sensors, potentiometers can often be helpful. Currently there are no Tessel modules with potentiometers and ADC, but you can easily build one yourself.

These are helpful for a traditional robot that might move and react to the environment. But you can also push the boundaries: what about a robot that moves in response to something else? Maybe it reacts to sound or warmth, like animals do. What if it reacts to information from the Internet, like a Twitter feed? Or what about a simple data-collecting robot that provides input to a system’s online code, like a motion detector that emails you when something moves? Internet access provides powerful input and output tools to any robotic system.

Some examples of this are:

• Hot enough text sends you a text through Twilio when the water on your stove is boiling

• Flinching robot runs away from loud noises

• RFID webapp authorization provides security by only letting you view a site if an authorized card is present

• Website down alarm brings the digital world into the physical space by turning on an alarm if your website doesn’t return a 200 OK response when it is pinged

If you’d like to get involved in the Nodebots community, check out this map of Nodebots meetup groups.

Robot Kits

In addition to a microcontroller and electronics to control actuators, you will often need some motors to get started with robots. In “Actuators”, you saw different motors you can use. In the language of electronics, motors are “actuators,” as they convert energy into motion.

Sumobot Jr.

There are a number of projects for robotic vehicles available today. One popular open source option is Pawel Szymczykowski’s Sumobot Jr. (see Figure 12-3).

The Sumobot Jr. provides a great laser-cuttable design that you can adapt to do just about whatever you want.

Although you might not have a laser cutter of your own, most maker spacers offer courses on how to laser cut parts. Another place to get your parts is Ponoko, or you can even buy a small laser cutter for home usage such as Mr. Beam. If you’re interested in learning more, check out Pawel’s Sumobot Jr. assembly video.

Figure 12-3. An assembled Sumobot Jr.

Hackarobot

The Hackarobot design was funded via a Kickstarter campaign in 2014. This robot is based on an Arduino Nano together with DC motors, sensors for proximity (HC-SR04), and an MPU6050 with an accelerometer.

You can buy the Hackarobot (Figure 12-4) from its creator Thomas Lee via Tindie.

Figure 12-4. The Hackarobot comes with sensors and a Bluetooth module

Example Project: The Robot Claw

As you can see in Figure 12-5, the simple robot claw built for this example consists of a mechanical frame combined with servo motors.

Figure 12-5. A simple robot claw with servo motors

The following provides direct control of servo motors:

// direct_arm.js
var five = require("johnny-five");

var board = new five.Board({
});

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

    // arm servo on pin 9
    var arm = new five.Servo(9);

    // hand servo on pin 10
    var hand = new five.Servo(10);

    this.repl.inject({
      hand: hand,
      arm: arm
    });
});

You can then add “actions” to combine control of multiple servo motors:

// add_actions.js
var five = require("johnny-five");
var util = require('util');

var board = new five.Board({
});

// create a new Arm class
var Arm = function() {

    five.Servo.apply(this, arguments);

    this.up = function() {
      this.max();
    }

    this.moveTo = function(pos) {
      this.to(pos);
    }

    this.down = function() {
      this.min();
    }
};
util.inherits(Arm, five.Servo);

// create a new Hand class
var Hand = function() {
  five.Servo.apply(this, arguments);

    this.open = function() {
      this.min();
    }

    this.moveTo = function(pos) {
      this.to(pos);
    }

    this.close = function() {
      this.max();
    }
};
util.inherits(Hand, five.Servo);

board.on("ready", function() {
  // arm servo on pin 9
  var arm = new Arm(9);

  // hand servo on pin 10
  var hand = new Hand(10);

  this.repl.inject({
    hand: hand,
    arm: arm
  });
});

Let’s try the movements in the Node.js read-eval-print loop:

$ node hello_action.js
1453555335508 Device(s) /dev/cu.usbmodem14131
 1453555335518 Connected /dev/cu.usbmodem14131

 1453555339060 Repl Initialized
 >> hand.open()
 >> hand.close()
 >> arm.up()
 >> hand.open()

To make more complex movements, you can combine multiple actions into “goals”:

// add_goals.js
var five = require("johnny-five");
var util = require('util');

var board = new five.Board({
});

// create a new Arm class
var Arm = function() {

    five.Servo.apply(this, arguments);

    this.up = function() {
      this.max();
    }

    this.moveTo = function(pos) {
      this.to(pos);
    }

    this.down = function() {
      this.min();
    }
};
util.inherits(Arm, five.Servo);

// create a new Hand class
var Hand = function() {

    five.Servo.apply(this, arguments);

    this.open = function() {
      this.min();
    }

    this.moveTo = function(pos) {
      this.to(pos);
    }

    this.close = function() {
      this.max();
    }
};
util.inherits(Hand, five.Servo);

var Goal = function(arm, hand) {
  this.arm = arm;
  this.hand = hand;

    this.prepare = function() {
      this.arm.down();
      this.hand.open();
      console.log('prepared');
    }

    this.grabObject = function() {
      console.log('hand will close');
      this.hand.close();
    }

    this.moveObject = function() {
      this.arm.up();
    }

    this.releaseObject = function() {
      this.hand.open();
    }
}

// connect to Arm object
board.on("ready", function() {

    // arm servo on pin 9
    var arm = new Arm(9);

    // hand servo on pin 10
    var hand = new Hand(10);

    // add goal
    var goal = new Goal(arm, hand);

    this.repl.inject({
      hand: hand,
      arm: arm,
      goal: goal
    });
});

Try it out:

>> goal.prepare()
>> goal.grabObject()
>> goal.moveObject()
>> goal.releaseObject()
>> goal.grabObject()
>> goal.prepare()

This robot claw provides provides two axes of freedom. With three axes of freedom, kinematics starts getting interesting—it provides a way to calculate movements on the basis of predefined coordinates. If you’d like to learn more about complex robotics, check out the tharp package.

Example Project: Move a Vehicle

In addition to actuators, it’s important to enable your robot to capture sensor data.

There is a Node/Tessel library to control a robot of a vehicle built around two continuous servo motors: servo-car for general use and RC-Sumobot for controlling it over a websocket.

var tessel = require('tessel');
var servolib = require('servo-pca9685');

var servo = servolib.use(tessel.port['D']);

var servo1 = 1;

servo.on('ready', function() {

    var position = 0;
    var dir = 0.05;

    servo.configure(servo1, 0.05, 0.11, function() {

        setInterval(function() {

            servo.move(servo1, position);

              if (position > 1 || position < 0) {
                dir = -dir;
              }
              position += dir;

        }, 100);

    });

});

MD25 Motor Shield

For real-world usage, you need larger DC motors to drive a vehicle. The Veter robot is a nice example of a moving vehicle. The robot controls different motors via I2C signals. You can build your own robot as shown in Figure 12-6 with the instructions at http://veterobot.com/buildyourself.html.

Figure 12-6. A robot using an MD25 motor shield and Intel Edison (based on the design of http://veterobot.com)