Published December 23, 2019 © GPL3+

Building a Custom JetBot with Jetson Nano

Take Nvidia's JetBot platform to the next level by expanding the functionality of the Jetbot API by adding new sensors and drivers.

IntermediateFull instructions provided5 hours19,745

Building a Custom JetBot with Jetson Nano

Things used in this project

Hardware components

NVIDIA Jetson Nano Developer Kit

DC motor (generic)

Texas Instruments Dual H-Bridge motor drivers L293D

SparkFun Full-Bridge Motor Driver Breakout - L298N

ELEGOO EL-KIT-012 UNO Project Smart Robot Car Kit V 3.0

Pimoroni VL53L1X Time of Flight (ToF) Sensor Breakout

Software apps and online services

Python 3

Jupyter Notebook

Jetbot

Hand tools and fabrication machines

Multitool, Screwdriver

Soldering iron (generic)

Story

Nvidia’s JetBot Platform

After training your Jetson Nano to recognize how many fingers you’re holding up or whether you’re giving a thumb’s up or thumb’s down gesture, you might be wondering about the next possible project. Nvidia has developed a robotics platform that utilizes the Jetson Nano called the JetBot. It lets users control two motors via I2C and a PCA9685, along with viewing output on an OLED or via the web, and finally, it has support for a camera in order to perform computer vision tasks. On its own, the JetBot is a nice development platform to have fun with and experiment, but it lacks support for many important sensors and has limited capabilities for motor control.

Nvidia JetBot render

Possible Customizations

Since I was planning on creating several robotics projects that rely on sensors besides a sole camera, I needed a way to interface them with the JetBot API and GPIO.

For most of them, communication is handled over the I2C bus, so integrating a pre-existing library, such as an Adafruit one, would be an easy way to add another sensor. I also wanted to use four motors with an L298N motor driver, which requires direct PWM control, rather than over the I2C bus.

PCA8685

Different Motor Driver

As mentioned previously, the JetBot uses Adafruit’s PCA9685 16-channel PWM breakout board, but I wanted to use either the L298N or an L293d driver. They are simple H-bridges that take in a control signal to attenuate the power going to each motor via PWM. These drivers are considered “dumb”, since they have no onboard controller. Therefore, setting up four GPIO pins as PWM outputs and connecting them to the motor driver is all you have to do.

1 / 2 • L298N

In the Python code, there is a file in the JetBot library called robot.py, and it contains the functions to control the robot’s motors. In order to change it to support PWM and not the Adafruit Motor HAT, simply edit lines 23 and 24 to get rid of the first argument in the Motor constructor call. Then, go to motor.py and get rid of all calls to the Adafruit Motor HAT. They will need to be replaced by adjusting the PWM values according to the speed that each channel is set to. Additionally, if a channel’s value is negative, then the motor will need to turn the opposite direction by swapping which pin is high. Finally, once the motor is released, all motors will be set to low to prevent them from running.

Adding More Sensors

In order to add additional sensors, you first need to know what communication protocol they use. For this project, I wanted to add distance sensing via a VL53L1X, which uses a laser’s time of flight (ToF) to measure distances.

VL53L1X ToF Sensor

Since it interfaces with the I2C bus, adding it would be extremely simple. There is a library called vl53l1x-python by pimoroni on Github that allows for easy interfacing with the sensor, since it contains all of the necessary setup and configurations.

I began by installing smbus2 and vl53l1x with pip. Next, I created a new file called vl53l1x.py that would contain the necessary functions, namely retrieving a distance from the sensor. It begins by importing the library and then setting it up by assigning a new object to an instance of the VL53L1X class. The I2C bus and sensor address are passed in from the Robot class, along with the distance traitlet. Finally, calling get_distance(range) will read a distance at short, medium, or long range.

The underlying function, VL53L1X.get_distance() is a blocking function, which means the rest of the program will have to wait until a distance is returned. This can be mitigated by placing the wrapper function into a thread that can execute in the background while the rest of the program continues. A method decorator is used to call a function whenever the value has been updated, which is useful for applications involving self-driving or other time-sensitive tasks.

Integration with Jupyter Notebooks

Because the motor driver and distance sensor classes both rely on the use of traitlets, it is extremely simple to integrate them with a Jupyter notebook widget. All you have to do is create a new container from the ipython widgets module and pass in the traitlets you wish to have displayed. Finally, call the display() function to show the widget in your Jupyter notebook.

Future Plans and Ideas

With the ability to create custom robots using the JetBot API, the possibilities are nearly limitless. I plan on making several projects that integrate self-driving and autonomy into the a JetBot, which could let it deliver a package or pick up an item, all on its own.

A possible custom JetBot

Code

import time
import traitlets
from traitlets.config.configurable import SingletonConfigurable
from .motor import Motor
from .vl53l1x import Vl53l1x
import RPi.GPIO as GPIO

class Robot(SingletonConfigurable):
    
    left_motor = traitlets.Instance(Motor)
    right_motor = traitlets.Instance(Motor)
    tof_sensor = traitlets.Instance(Vl53l1x)

    distance = traitlets.Integer(default_value=1).tag(config=True)

    # config
    i2c_bus = traitlets.Integer(default_value=1).tag(config=True)
    left_motor_alpha = traitlets.Float(default_value=1.0).tag(config=True)
    right_motor_alpha = traitlets.Float(default_value=1.0).tag(config=True)

    GPIO.setmode(GPIO.BOARD)

    def __init__(self, *args, **kwargs):
        super(Robot, self).__init__(*args, **kwargs)
        self.left_motor = Motor(35, 36, freq=50, alpha=self.left_motor_alpha)
        self.right_motor = Motor(37, 38, freq=50, alpha=self.right_motor_alpha)
        self.tof_sensor = Vl53l1x(self, i2c_bus_num=self.i2c_bus, i2c_addr=0x29)

    @observe('distance')
    def _observe_distance(self, change):
        new_distance_value = change['new']
        
    def set_motors(self, left_speed, right_speed):
        self.left_motor.value = left_speed
        self.right_motor.value = right_speed
        
    def forward(self, speed=1.0, duration=None):
        self.left_motor.value = speed
        self.right_motor.value = speed

    def backward(self, speed=1.0):
        self.left_motor.value = -speed
        self.right_motor.value = -speed

    def left(self, speed=1.0):
        self.left_motor.value = -speed
        self.right_motor.value = speed

    def right(self, speed=1.0):
        self.left_motor.value = speed
        self.right_motor.value = -speed

    def stop(self):
        self.left_motor.value = 0
        self.right_motor.value = 0

import atexit
import traitlets
from traitlets.config.configurable import Configurable
import RPi.GPIO as GPIO

class Motor(Configurable):

    value = traitlets.Float()
    
    # config
    alpha = traitlets.Float(default_value=1.0).tag(config=True)
    beta = traitlets.Float(default_value=0.0).tag(config=True)

    def __init__(self, pin1, pin2, freq=50, *args, **kwargs):
        super(Motor, self).__init__(*args, **kwargs)  # initializes traitlets
        self.pins = {'out1' : pin1, 'out2' : pin2}
        self.PWMs = []
        atexit.register(self._release)
        for out, pin in self.pins.items():
            GPIO.setup(pin, GPIO.OUT, initial=GPIO.HIGH)
            self.PWMs.append(GPIO.PWM(pin, freq))
        self.PWMs[0].start(0)
        self.PWMs[1].start(0)
        
    @traitlets.observe('value')
    def _observe_value(self, change):
        self._write_value(change['new'])

    def _write_value(self, value):
        """Sets motor value between [-1, 1]"""
        mapped_value = int(100.0 * (self.alpha * value + self.beta))
        speed = min(max(abs(mapped_value), 0), 100)
        self.PWMs[0].changeDutyCycle(speed)
        self.PWMs[1].changeDutyCycle(speed)
        if mapped_value < 0:
            self.PWMs[0].changeDutyCycle(0)
        else:
            self.PWMs[1].changeDutyCycle(0)

    def _release(self):
        """Stops motor by releasing control"""
        self.PWMs[0].stop()
        self.PWMs[1].stop()

import atexit
import traitlets
from traitlets.config.configurable import Configurable
import concurrent.futures
import VL53L1X
import Robot

class Vl53l1x(Configurable):
    
    distance = traitlets.Integer()

    def __init__(self, robot_instance, i2c_bus_num=1, i2c_addr=0x29, *args, **kwargs):
        self.tof = VL53L1X.VL53L1X(i2c_bus=i2c_bus_num, i2c_address=i2c_addr)
        self.tof.open()
        self.SHORT = 1
        self.MEDIUM = 2
        self.LONG = 3
        self.robot = robot_instance

    def read_distance(self, mode=1):
        self.tof.start_ranging(mode)
        with concurrent.futures.ThreadPoolExecutor() as executor:
            future = executor.submit(_get_distance, self.tof)
            val = future.result()
            self.robot.distance = val

def _get_distance(tof_sensor):
    return tof_sensor.get_distance()