How to Install OpenCV 4.5 on NVIDIA Jetson Nano

In this tutorial, we will install OpenCV 4.5 on the NVIDIA Jetson Nano. The reason I will install OpenCV 4.5 is because the OpenCV that comes pre-installed on the Jetson Nano does not have CUDA support. CUDA support will enable us to use the GPU to run deep learning applications.

The terminal command to check which OpenCV version you have on your computer is:

python -c 'import cv2; print(cv2.__version__)'

Prerequisites

You have already set up your NVIDIA Jetson Nano (4GB, B01).
If you didn’t follow my setup guide in the bullet point above, make sure you create a Swap file. See the “Create a Swap File” section of this tutorial on how to do that.

Install Dependencies

Type the following command.

sudo sh -c "echo '/usr/local/cuda/lib64' >> /etc/ld.so.conf.d/nvidia-tegra.conf"

Create the links and caching to the shared libraries

sudo ldconfig

Install the relevant third party libraries. Play close attention to the line wrapping below. Each command begins with “sudo apt-get install”.

sudo apt-get install build-essential cmake git unzip pkg-config
sudo apt-get install libjpeg-dev libpng-dev libtiff-dev
sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev
sudo apt-get install libgtk2.0-dev libcanberra-gtk*
sudo apt-get install python3-dev python3-numpy python3-pip
sudo apt-get install libxvidcore-dev libx264-dev libgtk-3-dev
sudo apt-get install libtbb2 libtbb-dev libdc1394-22-dev
sudo apt-get install libv4l-dev v4l-utils
sudo apt-get install libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev
sudo apt-get install libavresample-dev libvorbis-dev libxine2-dev
sudo apt-get install libfaac-dev libmp3lame-dev libtheora-dev
sudo apt-get install libopencore-amrnb-dev libopencore-amrwb-dev
sudo apt-get install libopenblas-dev libatlas-base-dev libblas-dev
sudo apt-get install liblapack-dev libeigen3-dev gfortran
sudo apt-get install libhdf5-dev protobuf-compiler
sudo apt-get install libprotobuf-dev libgoogle-glog-dev libgflags-dev

Download OpenCV

Now that we’ve installed the third-party libraries, let’s install OpenCV itself. The latest release is listed here. Again, pay attention to the line wrapping. The https://github… was too long to fit on one line.

cd ~
wget -O opencv.zip https://github.com/opencv/opencv/archive/4.5.1.zip
wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/4.5.1.zip
unzip opencv.zip
unzip opencv_contrib.zip

Now rename the directories. Type each command below, one after the other.

mv opencv-4.5.1 opencv
mv opencv_contrib-4.5.1 opencv_contrib
rm opencv.zip
rm opencv_contrib.zip

Build OpenCV

Let’s build the OpenCV files.

Create a directory.

cd ~/opencv
mkdir build
cd build

Set the compilation directives. You can copy and paste this entire block of commands below into your terminal.

cmake -D CMAKE_BUILD_TYPE=RELEASE \
-D CMAKE_INSTALL_PREFIX=/usr \
-D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib/modules \
-D EIGEN_INCLUDE_PATH=/usr/include/eigen3 \
-D WITH_OPENCL=OFF \
-D WITH_CUDA=ON \
-D CUDA_ARCH_BIN=5.3 \
-D CUDA_ARCH_PTX="" \
-D WITH_CUDNN=ON \
-D WITH_CUBLAS=ON \
-D ENABLE_FAST_MATH=ON \
-D CUDA_FAST_MATH=ON \
-D OPENCV_DNN_CUDA=ON \
-D ENABLE_NEON=ON \
-D WITH_QT=OFF \
-D WITH_OPENMP=ON \
-D WITH_OPENGL=ON \
-D BUILD_TIFF=ON \
-D WITH_FFMPEG=ON \
-D WITH_GSTREAMER=ON \
-D WITH_TBB=ON \
-D BUILD_TBB=ON \
-D BUILD_TESTS=OFF \
-D WITH_EIGEN=ON \
-D WITH_V4L=ON \
-D WITH_LIBV4L=ON \
-D OPENCV_ENABLE_NONFREE=ON \
-D INSTALL_C_EXAMPLES=OFF \
-D INSTALL_PYTHON_EXAMPLES=OFF \
-D BUILD_NEW_PYTHON_SUPPORT=ON \
-D BUILD_opencv_python3=TRUE \
-D OPENCV_GENERATE_PKGCONFIG=ON \
-D BUILD_EXAMPLES=OFF ..

I got this message when everything was done building.

Build OpenCV. This command below will take a long time (1-2 hours), so you can go do something else and come back later.

make -j4

If the building process stops before it reaches 100%, repeat the cmake command I showed earlier, and run the ‘make -j4’ command again.

One other thing. A lot of times I had the installation stall. To avoid that happening, I moved the mouse cursor every few minutes so that the screen saver for the Jetson Nano didn’t turn on.

Finish the install.

cd ~

sudo rm -r /usr/include/opencv4/opencv2

cd ~/opencv/build

sudo make install

sudo ldconfig

make clean

sudo apt-get update

Verify Your OpenCV Installation

Let’s verify that everything is working correctly.

python3

import cv2
cv2.__version__
exit()

Final Housekeeping

Delete the original OpenCV and OpenCV_Contrib folders.

sudo rm -rf ~/opencv

sudo rm -rf ~/opencv_contrib

Install jtop, a system monitoring software for Jetson Nano.

cd ~

sudo -H pip3 install -U jetson-stats

Reboot your machine.

sudo reboot

jtop

Press q to quit.

Verify the installation of OpenCV one last time.

python3

import cv2
cv2.__version__
exit()

That’s it. Keep building!

References

This article over at Q-engineering was really helpful.

How to Blink an LED Using NVIDIA Jetson Nano

In this tutorial, we will blink an LED using NVIDIA Jetson Nano. I will show you how to use Python to blink an LED, and I will show you how to use C++ to blink an LED. Here is what you will build:

Prerequisites

You have already set up your NVIDIA Jetson Nano (4GB, B01).

You Will Need

This section is the complete list of components you will need for this project (#ad).

Disclosure (#ad): As an Amazon Associate I earn from qualifying purchases.

Set Up the Hardware

The first thing we need to do is to set up the hardware.

Gather all of the items from the “You Will Need” section and lay them out on a table.

The NVIDIA Jetson Nano board has 40 general-purpose input/output pins (GPIO). Each pin can either be an input (e.g. connecting the Jetson Nano to a sensor) or an output (e.g. an LED). GPIO pins on the Jetson Nano use 3.3V by default.

In order to get the LED to blink, we need to connect it to one of the 40 GPIO pins. Make sure you set everything up exactly like this image below:

Connect the 220 Ohm resistor to the positive pin of the LED (i.e. the long leg).
Connect the other end of this resistor to GPIO pin 7 on the Jetson Nano.
Connect the negative pin of the LED (i.e. the short leg) to the GND pin on the Jetson Nano.

The connections are made using Male-Female jumper wires.

Blink an LED Using Python

Set Up the NVIDIA GPIO Library for Python

Let’s set up NVIDIA Jetson Nano GPIO.

Open a terminal, and type the following command.

sudo pip3 install Jetson.GPIO

If that command above doesn’t work, type the following command:

sudo pip install Jetson.GPIO

When I typed these commands, I got a message which a bunch of warning signs, but at the end of all that the following text was printed to the console:

“Requirement already satisfied…”

This message means that the GPIO library for Python is already installed on my Jetson Nano.

Reconfigure security permissions. Instead of your_user_name, I used automaticaddison, which is my username.

sudo groupadd -f -r gpio

sudo usermod -a -G gpio your_user_name

Reboot the computer.

sudo reboot

Let’s check to see if the library is fully setup.

python3

>>> import Jetson.GPIO as GPIO
>>> GPIO.JETSON_INFO
>>> GPIO.VERSION

Here is what I see:

Write the Code

Create a new folder. Open up a new terminal, and type:

cd Documents

mkdir led_blink

cd led_blink

Let’s create a program to blink the LED.

Create a file named gpiodemo.py.

gedit gpiodemo.py

# GPIO library
import Jetson.GPIO as GPIO

# Handles time
import time 

# Pin Definition
led_pin = 7

# Set up the GPIO channel
GPIO.setmode(GPIO.BOARD) 
GPIO.setup(led_pin, GPIO.OUT, initial=GPIO.HIGH) 

print("Press CTRL+C when you want the LED to stop blinking") 

# Blink the LED
while True: 
  time.sleep(2) 
  GPIO.output(led_pin, GPIO.HIGH) 
  print("LED is ON")
  time.sleep(2) 
  GPIO.output(led_pin, GPIO.LOW)
  print("LED is OFF")

Run the Code

You can run your program, gpiodemo.py, in the Terminal. Type this command:

python3 gpiodemo.py

If you get any errors due to security issues, you can run the gpiodemo.py file with the sudo command.

sudo python3 gpiodemo.py

You should see the LED blinking.

You should also see output in the terminal.

Press CTRL+C when you’re ready to stop the program.

To shutdown your Jetson Nano, you can type:

sudo shutdown -h now

Blink an LED Using C++

Set Up the NVIDIA GPIO Library for C++

Let’s install the C++ Jetson GPIO library, so we can see how to blink an LED using C++.

Make sure you’re connected to the Internet, and open a new terminal window.

git clone https://github.com/pjueon/JetsonGPIO

cd JetsonGPIO/build

make all

sudo make install

Reboot your machine.

sudo reboot

See if the header file for the C++ GPIO Library for Jetson Nano is on your machine. The command below will show the path to the header file.

find /home -name JetsonGPIO.h

Write the Code

Go to the led_blink directory.

cd Documents/led_blink

Open a new C++ program.

gedit led_blink.cpp

Write the following code. We want to blink an LED every 0.5 seconds:

// Handles input and output
#include <iostream>

// For delay function
#include <chrono> 

// Handles threads of program execution
#include <thread>

// Signal handling
#include <signal.h>

#include <JetsonGPIO.h>

// Pin Definitions
int led_pin = 7;

// Flag to determine when user wants to end program
bool done = false;

// Function called by Interrupt
void signalHandler (int s){
  done = true;
}

int main() {

  // When CTRL+C pressed, signalHandler will be called
  // to interrupt the programs execution
  signal(SIGINT, signalHandler);

  // Pin Definitions 
  GPIO::setmode(GPIO::BOARD);

  // LED pin gets set to high initially
  GPIO::setup(led_pin, GPIO::OUT, GPIO::HIGH);

  std::cout << "Press CTRL+C to stop the LED" << std::endl;

  int curr_value = GPIO::HIGH;

  // Blink LED every 0.5 seconds
  while(!done) {

    std::this_thread::sleep_for(std::chrono::milliseconds(500));

    curr_value = GPIO::HIGH;

    GPIO::output(led_pin, curr_value);

    std::cout << "LED is ON" << std::endl;

    std::this_thread::sleep_for(std::chrono::milliseconds(500));

    curr_value = GPIO::LOW;

    GPIO::output(led_pin, curr_value);

    std::cout << "LED is OFF" << std::endl;
  }

  GPIO::cleanup();

  return 0;
}

Save the file, and close it.

See if your file is in there.

ls

Run the Code

Compile the program.

g++ -o led_blink led_blink.cpp -lJetsonGPIO

(That is a lowercase L in front of Jetson above)

See if the executable is in the current directory.

ls

You should see a new file named led_blink.

If you see an error, check your program to see if it is exactly like I wrote it.

Run the program.

./led_blink

You should see the LED blinking every 0.5 seconds (i.e. 500 milliseconds).

Press CTRL + C when you’re finished.

That’s it. Keep building!

How to Write a C/C++ Program for NVIDIA Jetson Nano

In this tutorial, we will write a basic C++ program for NVIDIA Jetson Nano.

Prerequisites

You have already set up your NVIDIA Jetson Nano.
This tutorial will be similar to my C++ fundamentals for robotics tutorial.

Check Your GCC Version

Open a terminal window, and run the following command to see the version of the GCC C/C++ compiler you have.

gcc --version

If gcc is not installed, follow the instructions in the next section.

Install the GCC/G++ Compilers

Open a new terminal window, and type:

sudo apt-get update

Now use this command to install a bunch of packages, including GCC, G++, and GNU Make:

sudo apt install build-essential

You might see some sort of error about things being locked if you try the following command. If you do, kill all processes that are using the APT package management tool using this command:

sudo killall apt apt-get

Remove the lock files:

sudo rm /var/lib/apt/lists/lock

sudo rm /var/cache/apt/archives/lock

sudo rm /var/lib/dpkg/lock*

Reconfigure the packages and update:

sudo dpkg --configure -a

sudo apt update

Now use this command to install numerous packages, including GCC, G++, and GNU Make:

sudo apt install build-essential

Press Y to continue.

Wait while the whole thing downloads.

Now, install the manual pages about using GNU/Linux for development (note: it might already be installed):

sudo apt-get install manpages-dev

Check to see if both GCC and G++ are installed.

whereis gcc

whereis g++

Check what version you have.

gcc --version

g++ --version

Install the C/C++ Debugger

In this section, we will install the C/C++ debugger. It is called GNU Debugger (GDB) and enables us to detect problems or bugs in the code that we write.

In the terminal window, type the following command:

sudo apt-get install gdb

You will be asked to type your password, and then click Enter.

Type the following command to verify that it is installed:

gdb

Type this command to quit.

quit

Press Enter.

Exit the terminal.

exit

Install Gedit

Install gedit, a text editor that will enable us to write code in C/C++.

Open a terminal window, and type:

sudo apt-get install gedit

Write a Hello World Program in C

Let’s write a program that does nothing but print “Hello Automatic Addison” (i.e. my version of a “Hello World” program) to the screen.

Open a new terminal window, and create a new folder.

mkdir cpp_basics

Move to that folder.

cd cpp_basics

Open a new C program.

gedit hello_automaticaddison_c.c

#include<stdio.h>
int main()
{
printf("Hello Automatic Addison\n");
return 0;
}

Save the file, and close it.

See if your file is in there.

ls

Compile the program.

gcc hello_automaticaddison_c.c -o hello_automaticaddison_c

Run the program.

./hello_automaticaddison_c

Here is what I see.

Write a Hello World Program in C++

Open a new C++ program.

gedit hello_automaticaddison_cpp.cpp

Write the following code.

// Simple C++ program to display "Hello Automatic Addison"
  
// Header file for input output functions
#include<iostream> 
  
using namespace std;
  
// main function
// where the execution of program begins
int main()
{
    // prints hello world
    cout<<"Hello Automatic Addison";
      
    return 0;
}

Save the file, and close it.

See if your file is in there.

ls

Compile the program. All of this is just a single command.

g++ -o hello_automaticaddison_cpp hello_automaticaddison_cpp.cpp

If you see an error, check your program to see if it is exactly like I wrote it.

Run the program.

./hello_automaticaddison_cpp

Here is what I see.

That’s it. Keep building!