Google Coral Dev Board

1, Feactures

•     Edge TPU Module (SOM)

o     NXP i.MX 8M SOC (Quad-core Cortex-A53, plus Cortex-M4F)

o     Google Edge TPU ML accelerator coprocessor

o     Cryptographic coprocessor

o     Wi-Fi 2x2 MIMO (802.11b/g/n/ac 2.4/5GHz)

o     Bluetooth 4.1

o     8GB eMMC

o     1GB LPDDR4

•     USB connections

o     USB Type-C power port (5V DC)

o     USB 3.0 Type-C OTG port

o     USB 3.0 Type-A host port

o     USB 2.0 Micro-B serial console port

•     Audio connections

o     3.5mm audio jack (CTIA compliant)

o     Digital PDM microphone (x2)

o     2.54mm 4-pin terminal for stereo speakers

•     Video connections

o     HDMI 2.0a (full size)

o     39-pin FFC connector for MIPI-DSI display (4-lane)

o     24-pin FFC connector for MIPI-CSI2 camera (4-lane)

•     MicroSD card slot

•     Gigabit Ethernet port

•     40-pin GPIO expansion header

•     Supports Mendel Linux (derivative of Debian)

(1), 4-pin stereo terminal

We recommend using a 4 Ohm, 3 watt speaker. A higher Ohmage results in a much quieter output.

The stereo terminal is a 4-pin 2.54mm-pitch terminal connector for stereo speakers.

(2), SOM hardware details

The SOM is based on NXP's iMX8M system-on-chip (SOC) and contains all the essential hardware systems, including the Edge TPU and Wi-Fi/Bluetooth radios. It is attached to the Dev Board baseboard with three 100-pin board-to-board connectors.

(3), Board to board connectors

The Edge TPU SOM connects to the host baseboard with three 100-pin connectors, as shown in figure 11.

 

These are Hirose Electric 100-position connector plugs (DF40C-100DP-0.4V(51)). They connect to the corresponding 100-position connector receptacles (DF40HC(3.0)-100DS-0.4V(51)) on the baseboard.

(4), Pinout schematic

 

2, Get started guide

The Coral Dev Board is a single-board-computer that contains an Edge TPU coprocessor. It's ideal for prototyping new projects that demand fast on-device inferencing for machine learning models.

Features

This page is your guide to get started. The setup requires flashing a Mendel system image to the board and then accessing the board's terminal. Once you have terminal access, you can begin running TensorFlow Lite models.

If you want to learn more about the Dev Board hardware, see the datasheet.

Requirements

Note: Do not power the board or connect any cables until instructed to do so.

Before you begin, collect the following:

• A Linux computer
• A USB-A to USB-microB cable (to connect your PC to the board's serial port)
• A USB-A to USB-C cable (to connect your PC to the board's data port)
• A 2 - 3A (5V) USB Type-C power supply (such as a phone charger)
• An Ethernet cable or Wi-Fi connection

You also need a serial console program such as screen, picocom, or PuTTY (among many others). Our instructions use screen, so if you don't already prefer a different program, then we suggest you install screen on your Linux computer as follows:

sudo apt-get install screen

Although you can connect a keyboard and monitor to the board, we do not recommend it because the system is not designed to operate as a desktop environment and doing so can affect the system performance. So our documentation emphasizes use of a terminal when interacting with the Dev Board (either with the serial console or SSH).

Flash the board

The factory settings do not include a system image, only the u-boot boot loader.

Before you begin the flashing procedure, verify the following:

• The board is completely unplugged (not powered and not connected to your computer).
• The boot mode switches are set to eMMC mode (see figure 1):

Table 1

Boot mode	Switch 1	Switch 2	Switch 3	Switch 4
eMMC	ON	OFF	OFF	OFF

Figure 1. Boot switches set to eMMC mode

Note: If you have already flashed the device once before (or it's bricked), instead read Reflash the Coral Dev Board.

Now flash the board as follows:

1. Add the udev rule.

Run the following commands on your Linux computer so it can recognize the Dev Board:

sudo sh -c "echo 'SUBSYSTEM=="usb", ATTR{idVendor}=="0525", MODE="0664",

GROUP="plugdev", TAG+="uaccess"' >> /etc/udev/rules.d/65-edgetpu-board.rules"

 

sudo udevadm control --reload-rules && udevadm trigger

1. Connect to the serial console.

Use your USB-microB cable to connect your Linux computer to the serial console port on the board (see figure 2). The orange and green LEDs on the board will illuminate.

Note: The board should not be powered on yet.

Figure 2. A USB-microB cable connected to the serial console port

Now determine the device filename for the serial connection by running this command on your Linux computer:

dmesg | grep ttyUSB

You should see two results such as this:

[ 6437.706335] usb 2-13.1: cp210x converter now attached to ttyUSB0

[ 6437.708049] usb 2-13.1: cp210x converter now attached to ttyUSB1

Then use the name of the first filename listed as a cp210x converter to open the serial console connection (this example uses ttyUSB0 as shown from above):

screen /dev/ttyUSB0 115200

The prompt should disappear and your terminal should become completely blank. That's expected, because you've established a connection but the board is not turned on yet.

Help! If you instead see a message from screen such as [screen is terminating], then something is wrong—try quiting the screen program and unplugging the USB cable, then try again.

1. Power the board.

Plug in your 2 - 3A power cable to the USB-C port labeled "PWR" (see figure 3).

Caution: Do not attempt to power the board by connecting it to your computer.

Figure 3. A USB-C power cable connected to the board (in addition to the serial cable)

The board's red LED will illuminate and the fan might turn on.

Your serial console (the screen terminal) should print some messages and arrive at the u-bootprompt.

Help! If you still don't see anything in the serial console screen, press Enter.

You should see a message that tells you to visit g.co/coral/setup, which takes you to this page. So you're all good; you can continue.

Note: If you instead see a long stream of messages, followed by a login prompt, then your board is already flashed with a system image. You can either skip to step 7 and log in, or if you still want to reflash the board, then instead read Reflash the Coral Dev Board.

1. Start fastboot.

In your serial console's u-boot prompt, execute the following:

fastboot 0

The cursor should simply move to the next line. Fastboot is now waiting for the host to begin flashing a system image.

1. Connect to the USB data port.

Use your USB-C cable to connect your Linux computer to the USB-C data port labeled "OTG" on the Dev Board. (This is the connection used by fastboot.)

Figure 4. A USB-C data cable connected to the board (in addition to the serial and power cables)

1. Verify the device is connected.

Switch to a new terminal on your Linux computer (do not use the screen terminal) and execute the following:

fastboot devices

It should print a line with a device ID followed by "fastboot".

Help! If the command fails because fastboot is not recognized, then install fastboot as follows:

sudo apt-get install fastboot

Then run the command again.

If fastboot prints nothing, verify that the Dev Board is connected to your computer via USB as shown in figure 4 and you executed the fastboot 0 command from step 4. If so, try installing a more recent version of fastboot from the Android SDK Platform-tools. (Be sure to add the new fastboot to your PATHvariable.)

1. Download and flash the system image.

From the same terminal (where you ran fastboot), execute the following:

cd $HOME/Downloads

 

wget https://dl.google.com/aiyprojects/mendel/enterprise/mendel-enterprise-beaker-18.zip

 

unzip mendel-enterprise-beaker-18.zip

&& cd mendel-enterprise-beaker-18

 

bash flash.sh

This starts the flashing process and you'll see various output.

1. Log in.

Switch back to the serial console to observe the flashing progress. It takes about 5 minutes to complete. When it's done, the system reboots and the console prompts you to login.

Login is mendel
Password is mendel

You should now be in the board's terminal.

Note: Your board's hostname is randomly generated the first time it boots from a new flashing. We do this to ensure that each device within a local fleet is likely to have a unique name. Of course, you can change this name using standard Linux hostname tooling (such as hostname).

Connect to the internet

You need the board online to download some of our models and samples.

Either connect an Ethernet cable to the board or select a Wi-Fi network with the following command:

nmtui

Then select Activate a connection and be sure to select a network from the WLAN0 list of networks.

Alternatively, use the following command to connect to a known network name:

nmcli dev wifi connect <NETWORK_NAME> password <PASSWORD> ifname wlan0

Verify your connection with this command:

nmcli connection show

You should see your selected network listed in the output. For example:

NAME                UUID                             TYPE             DEVICE

MyNetworkName       e5702f60-d74f-422b-fake-example  802-11-wireless  wlan0

Connect to the board via SSH

At this point, you've accessed a command line with the serial console. But you might prefer using SSH to access the board's terminal instead of the serial console, because the serial console may include extra logging that obscures your prompt. And using SSH allows for simpler file transfers with scp.

To use SSH, you just need to know the dev board's IP address. If you've connected your board to the same network as your desktop computer (and this network supports SSH connections), you should be able to query the board's IP address by entering ip addr in the board's serial console.

Alternatively, you can create an SSH connection over USB as follows:

1. Connect a USB data cable from your Linux computer to the USB-C data port on the dev board (labeled "OTG"). (This is probably already connected from the flashing steps above.)
2. Open a new terminal window on your Linux computer and use the board's static USB IP address, 192.168.100.2, to open an SSH session:
3. ssh mendel@192.168.100.2

The password is "mendel" (unless you already changed it).

Once you reach the board's terminal with SSH, you can remove the serial console cable from the microB-USB port.

Help! If you can't SSH or ping 192.168.100.2 from your Linux computer, try running this on your Linux computer to reconfigure the detected networks (and then try to SSH again):

sudo dhclient

Copy files with SSH

Now with an SSH connection, you can transfer files using scp.

For example, here's how to transfer two files to the Dev Board's home directory:

# Executed from your Linux computer:

scp cat.jpg dog.jpg mendel@192.168.100.2:~/

And here's how to transfer two files from the Dev Board's home directory into the host computer's home directory:

# Executed from your Linux computer:

scp mendel@192.168.100.2:~/{cat_result.jpg,dog_result.jpg} ~/

 

# Or transfer just one file:

scp mendel@192.168.100.2:~/cat_result.jpg ~/

Run a model on the Edge TPU

Now you're ready to run a TensorFlow Lite model on the Edge TPU!

For a video demo of the Edge TPU performance, run the following command from the Dev Board terminal:

edgetpu_demo --stream

Then on your desktop (that's connected to the Dev Board)—if you're connected to the board using ssh over USB—open 192.168.100.2:4664 in a browser. If you're instead connected to the board's terminal by other means (such as SSH over LAN or with an Ethernet cable), type the appropriate IP address into your browser with port 4664.

You should then see a video your browser being streamed from the Dev Board.

Or if you have a monitor attached to the Dev Board, you can instead display the demo on that screen:

edgetpu_demo --device

Try the Edge TPU Python API

The edgetpu_demo shown above performs an inference on each frame of the video using the Edge TPU Python library (the edgetpu Python module). This library includes APIs that make it easy to perform an image classification or object detection inference. So we've created some other sample code to show how you can use these APIs.

Note: The edgetpu_demo above actually uses a higher-level API called edgetpuvision that simplifies the code required to perform inferences with a camera or a video. Although you can inspect that code, it's not stable in our beta release. But rest assured, it will be ready soon. Until then, we suggest you use the edgetpu API as shown in the following sample.

First, navigate to the directory where we've shared the sample scripts:

cd /usr/lib/python3/dist-packages/edgetpu/

Then try this script to run image classification with the parrot image in figure 5:

python3 demo/classify_image.py

--model test_data/mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite

--label test_data/inat_bird_labels.txt

--image test_data/parrot.jpg

Figure 5. parrot.jpg

You should some results like this:

---------------------------

Ara macao (Scarlet Macaw)

Score :  0.613281

---------------------------

Platycercus elegans (Crimson Rosella)

Score :  0.152344

To learn more about the Python API, see the Edge TPU API overview & demos.

For details about how to create compatible TensorFlow Lite models, read TensorFlow Models on the Edge TPU.