Bare Metal Qt 5.2 on BeagleBone Black Ubuntu - Part 2

Overview

For the impatient, I now have a precompiled tar of Qt 5.2.1 (for installation on a Beaglebone), see my blog post for more info...

Now that we have our development environment setup from Part 1, I will now guide you through the steps to compile Qt 5.2. This guide assumes the following:

• That Ubuntu host machine is up-to-date
• The host machine has the necessary utilities installed
• Contains a folder, in the home directory, with the Qt source
• The toolchain is installed under /usr/local/, which, for this guide, is in the linaro directory.

Downloads

Download these files, if you still need to flash Ubuntu onto the BeagleBone Black:

• BeagleBone Ubuntu Saucy: Direct Link, Others, Alternate Site

Create Device Configuration

Before we can call the Qt configuration script, we need to create a device configuration file so Qt knows how to generate the proper makefiles. Let's start by diving deeper into the Qt source folders.

> cd                                                             

> cd qt-everywhere-opensource-src-5.2.0/qtbase/mkspecs/devices   

> ls                                                             

The directory list will reveal 17 devices that we can target with Qt, of which, one of those is linux-beagleboard-g++. Let's make a copy of that device directory and then modify the qmake.conf file for our toolchain.

> cp -r linux-beagleboard-g++ linux-beaglebone-g++               

> nano linux-beaglebone-g++/qmake.conf                           

We'll start by modifying the comment (line 2) to reflect this new file's target hardware, because good comments are important :)

# qmake configuration for the BeagleBone and BeagleBone Black boards

 Next we need to change the compiler flags. The Linaro toolchain uses hardfloat so we need to change the "-mfloat-abi=softfp" option to "-mfloat-abi=hard" on line 29.

COMPILER_FLAGS = -march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=hard

Save your changes and exit nano: CTRL-O, Enter, CTRL-X.

Create Platform Configuration

We need to create one more configuration before we call the Qt configuration script. Similar to a device configuration, we need to point to our platform compiler. In this case, I use the same linaro toolchain compiler. (I tried running the make without a -xplatform defined, because I thought it was not necessary....wrong!) 

Let's start by making a copy of an existing configuration file:

> cd                                                             

> cd qt-everywhere-opensource-src-5.2.0/qtbase/mkspecs           

> cp -r linux-arm-gnueabi-g++ linux-linaro-gnueabihf-g++         

Now let's modify the qmake.conf file:

> nano linux-linaro-gnueabihf-g++/qmake.conf                     

Comments first (line 2):

# qmake configuration for building with Linaro hardfloat toolchain.

Next we need to modify all 8 lines of compiler paths to point to our Linaro toolchain. We can do this two ways:

• By using the -device-options CROSS_COMPILE tag
• By entering the full path

I chose the first option because I just copied the device configuration file, removed unused parts based on the linux-arm-gnueabi-g++ file (opengl, calls to device_config, etc), and modified the paths (changed ../../ to ../) to common headers. But I would recommend using the full path method because the configuration script may not enforce a "-device-option" tag for a "-xplatform" tag like it does for a "-device" tag.

So lets add the full path to qmake.conf. Change each line from this:

QMAKE_* = arm-linux-gnueabi-*

to

QMAKE_* = /usr/local/linaro/bin/arm-linux-gnueabihf-* 

In other words, leave the suffixes (gcc/g++/ar/objcopy/nm/strip) and options (cqs/-P) unchanged. As an example, the QMAKE_AR line (line 20) would become:

QMAKE_AR  = /usr/local/linaro/bin/arm-linux-gnueabihf-ar cqs

Once you have modified all 8 lines, save your changes and exit nano: CTRL-O, Enter, CTRL-X.

Configure Qt

Now we are ready to configure Qt. This is a relatively painless operation, but took me a while to discover which command line options were required. A lot of the options that were available in Qt 4 are no longer valid in Qt 5. We can ask the configuration script what options are available, but first we need to change our working directory to the build folder:

> cd                                                             
> cd qt-5.2-host                                                 
> ../qt-everywhere-opensource-src-5.2.0/configure --help         

This outputs several pages of information, which you can study later; while you are waiting for Qt to compile. But for now, let's run configure with these parameters:

> ../qt-everywhere-opensource-src-5.2.0/configure \              
   -v \                                                          
   -opensource \                                                 
   -confirm-license \                                            
   -prefix /usr/local/qt-5.2 \                                   
   -no-largefile \                                               
   -no-accessibility \                                           
   -qt-zlib \                                                    
   -no-gif \                                                     
   -qt-libpng \                                                  
   -qt-libjpeg \                                                 
   -no-nis \                                                     
   -no-cups \                                                    
   -xplatform linux-linaro-gnueabihf-g++ \                       
   -device linux-beaglebone-g++ \                                
   -device-option CROSS_COMPILE=/usr/local/linaro/bin/arm-linux-g
nueabihf-                                                        

Here is a brief description of each option

-v                         verbose output, which is helpful for problem solving
-opensource        build Qt as the opensource version
-confirm-license  automatically say "yes" to the LGPL license terms
-prefix                  the destination folder for binaries when a 'make' is performed
-no-largefile        no 4Gb file support
-no-accessibility  don't include accessibility, to save space?
-qt-zlib                 use the Qt version of zlib (instead of system)
-no-gif                 no GIF support
-qt-libpng            use the Qt version of libpng (instead of system)
-qt-libjpeg           use the Qt version of libjpeg (instead of system)
-no-nis                no Network Information Service support
-no-cups              no print support
-xplatform          defines which qmake.conf file to use for building libraries/plugins/examples
-device               defines which qmake.conf file, in the device folder, to use for building
-device-option    this is required, when -device is used, to point to the cross compiler binary

The reasoning behind why I chose these options is simple: these were the only options that worked from the  Building Qt for Embedded Linux web page., which is written for Qt 4.8.

Note: This is a work in progress, and as such the mouse, touchscreen, and GUI elements are not fully functional. Console applications seem to be working fine.

Building Qt

The configure script has compiled a host version of qmake, automatically detected what modules are available to build, determined what compiler optimizations are available,  and has created makefiles in the source folders. So now what? Well, that's easy, the configure script prints it out when it finishes:

> make -j3 

The -j3 option tells the compiler how many jobs (aka threads) to run simultaneously. Your number of CPU cores minus one is a good number for a virtual machine host. Number of cores plus one is a good number for native hosts.

My host PC has an Intel i7-3540M quad-core processor and 8 Gb of RAM. I created the VM with four cores and assigned 3 Gb of RAM. It finished the compile in about 20 to 30 minutes.

Tasks While Waiting

Since it is going to take a while, let's setup the BeagleBone Black with our embedded Ubuntu image. Follow the instructions on this site to create a card and update the BBB eMMC. It should only take a few minutes.

Once you have a working Ubuntu on the BBB, we need to remove an old version of Qt, 5.0.2

> sudo apt-get remove libqt5core5                                

This will clear up the /usr/lib/arm-linux-gnueabihf folder of the old Qt libraries.

We need a way to transfer files to the BeagleBone. This can be via SD or USB, but I prefer connecting it to my LAN and using 'scp'. You can find the IP address of the BeagleBone by issuing the following command:

> ifconfig                                                       

Under the eth0 adapter listing (or wlan0 if using WiFi) you will find the "inet addr" field. Write this down, or remember it, as this is what you use for the host name with the scp command:

> scp source_file username@host:remote_path

But that will have to wait until the build is done....

Post Build

When the build is done, Qt is ready to be installed. The following command will create the directory, specified by the -prefix target when you ran the configuration script, and fill it with binaries.

> make install                                                   

Now let's go explore the installation....

> cd /usr/local/qt-5.2                                           

Under this directory you will find eight more folders, of which a few are of interest:

• bin - host binary of qmake, and other utilities
• examples - target binaries for testing our build
• lib - .so libraries for our target
• plugins - our platform gui drivers

Copy Binaries to BeagleBone

My preferred method is to use 'scp' to copy the files over the LAN to the BeagleBone. The following commands will copy the entire Qt folder to your BeagleBone home folder:

> cd /usr/local                                                  
> scp -r qt-5.2 ubuntu@192.168.7.2:/home/ubuntu/qt-5.2           

Replace 'ubuntu' with the user account that you use on the BeagleBone. Replace '192.168.7.2' with the IP address of your BeagleBone. It will take a couple minutes, depending on your network speed. You can reduce the size, by about 1/3, if you only transfer the four folders: examples, lib, plugins, and qml.

The Qt libraries are now on the BeagleBone, but they are in the wrong directory. So, now we need to log into the BeagleBone, either via 'ssh' or through the console, and move them to the proper location:

bbb> sudo mv /home/ubuntu/qt-5.2 /usr/local                      

Test Installation

Everything should be good to go, so let's run a couple examples to verify it. First let's try a console application:

bbb> /usr/local/qt-5.2/examples/network/dnslookup www.google.com 

Now for a GUI application. I recommend calling this from a ssh session, because a local session will take over the screen and you will not be able to get it back until you reboot the BeagleBone.

bbb> /usr/local/qt-5.2/examples/gui/analogclock/analogclock      

Hmm, it doesn't work! Well, our device configuration, that we copied, sets the GUI to default to 'eglfs'. We don't have this plugin, because we didn't configure OpenGL support. So, to get around this, we need to explicitly define the platform. Add this to the previous command:

 -platform linuxfb                                               

Congratulations, you now have a working Qt 5.2 on your BeagleBone Black!

Conclusion

Part 3 shows how to configure Qt Creator for application development.

Sources

Here are some web pages that I used for inspiration.

• http://qt-project.org/doc/qt-5/configure-options.html
• http://qt-project.org/doc/qt-4.8/qt-embedded-crosscompiling.html
• http://www.cloud-rocket.com/2013/07/building-qt-for-beaglebone/
• http://qt-project.org/wiki/Building_Qt_for_Embedded_Linux
• https://groups.google.com/forum/#!topic/beagleboard/doI41xkIvks