Qt + opencv + v4l cross compiling Raspberry Pi / Beagle bone

It’s easier than it looks! Everyone can do it with this tutorial!

System information:

– Ubuntu 13.10 64 bit

– Raspberry Pi with raspbian

Before we start

Open a terminal and c/p:

 sudo apt-get install g++

1. Download and install the cross compile toolchain

Download the toolchain at: (64bit) http://www.angstrom-distribution.org/toolchains/angstrom-2011.03-x86_64-linux-armv7a-linux-gnueabi-toolchain-qte-4.6.3.tar.bz2 or (32bit) http://www.angstrom-distribution.org/toolchains/angstrom-2011.03-i686-linux-armv7a-linux-gnueabi-toolchain-qte-4.6.3.tar.bz2 (or a later version at http://www.angstrom-distribution.org/toolchains/
since the site is offline right now you can download the 64 bit here: https://mega.co.nz/#!lMUTjQTa!fhGu4yvT3y-VyfdNLWuJpVeeZAY8Sy-xybZpb2v4sdk

Also available on here : http://web.archive.org/web/20130921065357/http://www.angstrom-distribution.org/toolchains/archive/ (thanks to Anisul)

• go to download directory and run

sudo tar -C / -xjf angstrom-2011.03-i686-linux-armv7a-linux-gnueabi-toolchain-qte-4.6.3.tar.bz2

2. Dowload and install QT

• open terminal and run the following commands

cd ~/Downloads

wget http://download.qt-project.org/official_releases/qt/4.8/4.8.5/qt-everywhere-opensource-src-4.8.5.tar.gz

tar -xzf qt-everywhere-opensource-src-4.8.5.tar.gz

mv qt-everywhere-opensource-src-4.8.5 ~/qt-4.8.5-beagle
cd ~/qt-4.8.5-beagle
mkdir ./mkspecs/qws/linux-am335x-g++
cp ./mkspecs/qws/linux-arm-g++/qplatformdefs.h ./mkspecs/qws/linux-am335x-g++
touch ./mkspecs/qws/linux-am335x-g++/qmake.conf

• edit the qmake.conf (with gedit: sudo gedit ./mkspecs/qws/linux-am335x-g++/qmake.conf ) file with a text editor and change it to

#
# qmake configuration for building with arm-linux-g++
#

include(../../common/linux.conf)
include(../../common/gcc-base-unix.conf)
include(../../common/g++-unix.conf)
include(../../common/qws.conf)

# modifications to g++.conf
#Toolchain

#Compiler Flags to take advantage of the ARM architecture
QMAKE_CFLAGS_RELEASE = -O3 -march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp
QMAKE_CXXFLAGS_RELEASE = -O3 -march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp

QMAKE_CC = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/gcc
QMAKE_CXX = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/g++
QMAKE_LINK = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/g++
QMAKE_LINK_SHLIB = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/g++

# modifications to linux.conf
QMAKE_AR = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/ar cqs
QMAKE_OBJCOPY = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/objcopy
QMAKE_STRIP = /usr/local/angstrom/arm/arm-angstrom-linux-gnueabi/bin/strip

load(qt_config)

• configure QT embedded

./configure -v -opensource -confirm-license -prefix /opt/qt -embedded arm -platform qws/linux-x86-g++ -xplatform qws/linux-am335x-g++ -depths 16,24,32 -no-mmx -no-3dnow -no-sse -no-sse2 -no-glib -no-cups -no-largefile -no-accessibility -no-openssl -no-gtkstyle -qt-mouse-pc -qt-mouse-linuxtp -qt-mouse-linuxinput -plugin-mouse-linuxtp -plugin-mouse-pc -fast -little-endian -host-big-endian -no-pch -no-sql-ibase -no-sql-mysql -no-sql-odbc -no-sql-psql -no-sql-sqlite -no-sql-sqlite2 -no-webkit -no-qt3support -nomake examples -nomake demos -nomake docs -nomake translations

• build and install

make -j 4
sudo make install

3. Prepare your Raspberry Pi or beagle bone for Qt

• connect your controller to your network

ssh to your controller ssh accountname@ip => example: ssh pi@192.168.0.100

• create a dir structure on your controller

sudo mkdir /opt
sudo mkdir /opt/qt

• copy lib folder from host to controller

scp -r /opt/qt/lib accountname@ip:”/opt/qt”

• add lib directory to your path

PATH=$PATH:/opt/qt/lib

4. Dowload and install QT creator

• Download qt-creator-linux-x86-opensource-2.8.0.run for x86 or qt-creator-linux-x86_64-opensource-2.8.0.run for 64bit

chmod +x qt-creator-linux-x86_64-opensource-2.8.0.run
./qt-creator-linux-x86_64-opensource-2.8.0.run

• Installation wizard
• Run angstrom setup script

. /usr/local/angstrom/arm/environment-setup

• Open Qt Creator and Configure Qt version
• Go to Tools->Options->Build & Run->Qt Versions and click Add
• Select qmake.conf from /opt/qt/bin
• Click Ok
• Configure target device connection
• Go to Tools->Options->Devices
• Click Add and select Generic Linux Device
• Add IP 192.168.7.2, User: root
• Set name to “Beaglebone”
• Click Ok
• Configure Compiler
• Go to Tools->Options->Build & Run->Compilers and click Add->GCC
• Select compiler path: /usr/local/angstrom/arm/bin/arm-angstrom-linux-gnueabi-g++
• Click Ok
• Configure Kit
• Go to Tools->Options->Build & Run->Kits and click Add
• Call new kit Beaglebone
• Select device type: “Generic Linux Device”
• Select the device you previously created
• Select compiler you created
• Select Qt version you created
• Select GDK path as /usr/local/angstrom/arm/bin/arm-angstrom-linux-gnueabi-gdk
• Click Ok

5. Build an easy Qt program

• Create new project (File->New project->Qt Project->Qt Console application)
• Edit your project (.pro) file
• Add the following after “TARGET=…” line:

target.files = <YOUR EXECUTABLE NAME>
target.path = /home/root
INSTALLS = target

• Go to Projects -> Run, you should see on “Files to deploy” table your “target” settings
• Now you are ready to build and deploy you project on your target board
• The following example application should print Hello world inside your console:

#include <QCoreApplication>
#include <iostream>

int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);

std::cout << “hello world” << std::endl;

return a.exec();
}

6. Adding OpenCV2.4 and v4l

• install opencv on your computer (I use 2.4.1, it also works with all the newer versions)

sudo apt-get update && sudo apt-get upgrade && sudo apt-get install build-essential libgtk2.0-dev libjpeg-dev libtiff4-dev libjasper-dev libopenexr-dev cmake python-dev python-numpy python-tk libtbb-dev libeigen2-dev yasm libfaac-dev libopencore-amrnb-dev libopencore-amrwb-dev libtheora-dev libvorbis-dev libxvidcore-dev libx264-dev libqt4-dev libqt4-opengl-dev sphinx-common texlive-latex-extra libv4l-dev libdc1394-22-dev libavcodec-dev libavformat-dev libswscale-dev
cd ~
wget http://downloads.sourceforge.net/project/opencvlibrary/opencv-unix/2.4.1/OpenCV-2.4.1.tar.bz2 && tar -xvf OpenCV-2.4.1.tar.bz2
cd OpenCV-2.4.1
mkdir build
cd build

cmake -D WITH_TBB=ON -D BUILD_NEW_PYTHON_SUPPORT=ON -D WITH_V4L=ON -D INSTALL_C_EXAMPLES=ON -D INSTALL_PYTHON_EXAMPLES=ON -D BUILD_EXAMPLES=ON -D WITH_QT=ON -D WITH_OPENGL=ON ..
make -j4

sudo make install

• add to “/etc/ld.so.conf.d/opencv.conf” (file can be empty) the line /usr/local/lib

sudo gedit /etc/ld.so.conf.d/opencv.conf

sudo ldconfig

• add the following lines to /etc/bash.bashrc

PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig
export PKG_CONFIG_PATH

• get the opencv arm library files
• install cmake

sudo apt-get install cmake cmake-curses-gui

• add angstrom compiler to path

PATH=$PATH:/usr/local/angstrom/arm/bin/

• download opencv2.4.1

cd ~
mkdir OpenCV-2.4.1ARM
cd OpenCV-2.4.1ARM
wget http://downloads.sourceforge.net/project/opencvlibrary/opencv-unix/2.4.1/OpenCV-2.4.1.tar.bz2
tar -xvf OpenCV-2.4.1.tar.bz2
cd OpenCV-2.4.1ARM
mkdir /build

cd build

• create toolchain file to tell the cross compiler how to compile

nano toolchain.cmake

• add to the toolchain.cmake file

set( CMAKE_SYSTEM_NAME Linux )
set( CMAKE_SYSTEM_PROCESSOR arm )
set( CMAKE_C_COMPILER arm-angstrom-linux-gnueabi-gcc )
set( CMAKE_CXX_COMPILER arm-angstrom-linux-gnueabi-g++ )
set( CMAKE_FIND_ROOT_PATH ~/targetfs )

• run cmake to generate the makefile

cmake -DCMAKE_TOOLCHAIN_FILE=toolchain.cmake ../OpenCV-2.4.1ARM/

• since this gives errors, we are going to use the gui to disable some settings

sudo apt-get install cmake-qt-gui

• now run the cmake-qt-quit with “cmake-gui .”
• disable the following things (do not forget to chose “Advanced”)

BUILD_NEW_PYTHON_SUPPORT
BUILD_TESTS
WITH_1394
WITH_CUDA
WITH_EIGEN2 (and WITH_EIGEN)
WITH_FFMPEG
WITH_GSTREAMER
WITH_GTK
WITH_JASPER
WITH_JPEG
WITH_OPENEXR
WITH_PNG
WITH_PVAPI
WITH_QT
WITH_QT_OPENGL
WITH_TBB
WITH_TIFF
WITH_UNICAP
WITH_V4L
WITH_XINE

• do a search on python and disable all of those too
• first click on “Configure” , then “Generate”
• close it
• make opencv with the make command (ex: make -j4)
• now we have the arm library’s we can start including them into our Qt project (example later in the tutorial)

Important:

I do not know that you need to install opencv on your beaglebone / raspberry Pi to be able to use it with cross compiling.
If anyone followed my tutorial, can you please tell me you need it or not?
If you do need it, you can find instructions here: (change the version to 2.4.1!)
http://mitchtech.net/raspberry-pi-opencv/

7. Install v4l on the raspberry PI

• Since all the essential information is on the site below, I will just redirect you to it.

http://www.linux-projects.org/modules/sections/index.php?op=viewarticle&artid=14

• to always enable the v4l driver with the camera add “uv4l –driver raspicam –auto-video_nr –width 640 –height 480 –encoding jpeg” to the “~/.bashrc ” file

8. Easy example program with Qt, opencv and v4l

• first create main.cpp

#include <QCoreApplication>
#include <video.h>
#include <QDebug>
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Video vid;
vid.Record();
qDebug() << “Recording ended.\n”;
return a.exec();
}

• add a video.cpp file

#include “video.h”
#include <opencv/cv.h>
#include <opencv2/opencv.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv/highgui.h>

#include “QString”
#include “QDebug”

using namespace cv;

Video::Video(QObject *parent) :
QObject(parent)
{
cam = new VideoCapture(0);
if(!cam->isOpened()) qDebug() << “Cannot open Camera”;
else qDebug() << “Camera open.”;
}

void Video::Record()
{

qDebug() << “Record\n”;
double dWidth = cam->get(CV_CAP_PROP_FRAME_WIDTH); //get the width of frames of the video
double dHeight = cam->get(CV_CAP_PROP_FRAME_HEIGHT); //get the height of frames of the video
Size frameSize(static_cast<int>(dWidth), static_cast<int>(dHeight));
qDebug() << “Frame Size = ” << dWidth << “x” << dHeight << “\n”;

qDebug() << “Recording.\n”;
Mat frame;
qDebug() << “Made frame.\n”;
cam->read(frame); // get a new frame from camera
if(frame.data)
{
qDebug(“Image has data!”);
QString Path = “/EmbeddedOS0.jpg”;
QByteArray ba = Path.toLocal8Bit();
const char *PathChar = ba.data();
imwrite(PathChar,frame);
}
}

• add header file video.h

#ifndef VIDEO_H
#define VIDEO_H

#include <QString>
#include <QObject>
#include “vector”

#include <opencv/cv.h>
#include <opencv2/opencv.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv/highgui.h>

using namespace cv;

class Video: public QObject
{
private:
VideoCapture *cam;
public:
explicit Video(QObject *parent = 0);
void Record();
};

#endif // VIDEO_H

• add to your .pro file the following lines

INCLUDEPATH += /usr/local/include

• right click in your .pro file
• add library
• External library
• library file

OpenCV-2.4.1ARM/build/lib/

• select libopencv_calib3d.so (if files are not found, look for them in the file manager and change .so.2.4 to .so)
• click away the windows and mac options
• next , finish
• directly after the -lopencv_calib3d add the following:  -lopencv_contrib -lopencv_core -lopencv_features2d -lopencv_flann -lopencv_highgui -lopencv_imgproc -lopencv_legacy -lopencv_ml -lopencv_objdetect -lopencv_ts -lopencv_video
• it will be something like (files can be found in ~/OpenCV-2.4.1ARM/build/lib/ )

unix:!macx: LIBS += -L$$PWD/../../build/lib/ -lopencv_calib3d -lopencv_contrib -lopencv_core -lopencv_features2d -lopencv_flann -lopencv_highgui -lopencv_imgproc -lopencv_legacy -lopencv_ml -lopencv_objdetect -lopencv_ts -lopencv_video

• go to projects (on the left side bar)
• you’ll see on the top the compilers you chose for this project, every compiler has a build and ruin button
• click on the run button (from the Cross Compiler)
• if you scroll down you’ll see “Alternate executable on device” , check the box next to it and fill in:

LD_PRELOAD=/usr/lib/uv4l/uv4lext/armv6l/libuv4lext.so <YOUREXECUTABLEFILENAME>

HINT: <YOUREXECUTABLEFILENAME> can be found above the box next to “Executable on device”

• go back to edit and press the run button

• you should now see this output (close the program with ctrl + c)

Camera open.
Record

Frame Size = 480 x 480

Recording.

Made frame.

Image has data!
Recording ended.

• If you do ls -l in your root ( / ) folder, you will see an EmbeddedOS0.jpg file
• If you have any problems, first check the links below, there is a lot of information about it
• If you can’t find a solution, feel free to comment bellow!

Sources:

Most credits go to the people who made those tutorials. I used their work to make one bigger project.

http://www.cloud-rocket.com/2013/07/building-qt-for-beaglebone/

Installing OpenCV 2.4.1 in Ubuntu 12.04 LTS

http://processors.wiki.ti.com/index.php/Building_OpenCV_for_ARM_Cortex-A8