Sunday, January 26, 2014

element14 BB-View and the Debian Beta

This is a post I made at the element14 Community pages:

I thought some other might like to know how to get the BB-View working under the latest Debian beta images.

Unfortunately, you are going to have to recompile the Kernel. The video works fine without a recompile (the red/blue swap is easy to fix), but the touchscreen control connections are not the same as the standard TI 4-wire interface. I tried to patch the ti_am335x_tsc.c file, so the changes would be limited to a dts recompile, but I haven't been able to get that working yet (I'm pretty sure it is a state machine / bit assignment issue). But anyway, here are the steps that you need to perform.....


1) Download the necessary files
     a) Robert Nelson's handy tools for compiling the Beaglebone kernel
     b) BB-View source for Angstrom
2) Build the default kernel
3) Patch the Kernel and perform a fast recompile
4) Copy the new kernel to the Beaglebone
5) Edit the xorg.conf file to correct the Red/Blue color swap
6) Revel in the 4 days you just saved 

Let's Get Started

I am using Ubuntu 12.04 LTS 64 bit running in a VirtualBox VM to compile the kernel:
Make a new folder called bb-view, this is where our build will happen.
> mkdir bb-view
> cd bb-view

Install git, if you haven't already:
> apt-get install git

Clone Robert Nelson's linux-dev project locally. Be prepared for a large download (~100 Mb for the cross-compiler and ~700 Mb for the kernel source).
> git clone

Change into the new linux-dev folder and select branch/tag that matches the Debian version.
> cd linux-dev
> git checkout 3.8.13-bone37 -b tmp

Now we need to build the base image, so our cape drivers folder gets populated. The script will tell you if you need to do or install anything else. 
> ./

Come back in an hour or so.....(You might want to download the Angstrom source from element14 now)

Patching the Kernel

Extract two files from the Angstrom source:
> unzip
> tar -zxf bb-black-kernel-3.8.13-bb-view.tar.bz2
> cp ./kernel/kernel/drivers/input/touchscreen/ti_am335x_tsc.c  ~/bb-view/linux-dev/KERNEL/drivers/input/touchscreen/
> cp ./kernel/kernel/firmware/capes/BB-VIEW-LCD7-01-00A0.dts  ~/bb-view/linux-dev/KERNEL/firmware/capes/

Now we need to let the compiler know that we want to add the firmware to the build:
> nano   ~/bb-view/linux-dev/KERNEL/firmware/Makefile

Add the following line somewhere near line 192 (CTRL-C will display current cursor position):
BB-VIEW-LCD7-01-00A0.dtbo \

Don't forget the trailing is important. Now save and exit by doing CTRL-O, Enter, CTRL-X.
Change back to the linux-dev root folder:
> cd   ~/bb-view/linux-dev

Now issue the kernel rebuild command, this won't take very long at all:
> ./tools/

Copy Kernel to BBB

The following instructions assume that you already have the Debian beta installed and booted up on the BBB.
The easiest way is to copy the files over the network, via the 'scp' command:
> scp   ~/bb-view/linux-dev/deploy/3.8.13-bone37.zImage   debian@
Replace debian (both instances) with the username you are running on the BBB and with the IP address of the BBB.

Now log into the BBB and copy the kernel image to the boot partition:
> ssh debian@
bbb>  sudo cp 3.8.13-bone37.zImage   /boot/uboot/zImage

We need to do one more thing before the LCD will work. Since the cape doesn't have an EEPROM, we need to black-list the HDMI drivers and force-load the BB-VIEW drivers in the boot command file:
bbb>  sudo  nano  /boot/uboot/uEnv.txt

Find the "optargs" line and edit it to be:
optargs=capemgr.disable_partno=BB-BONELT-HDMI,BB-BONELT-HDMIN  capemgr.enable_partno=BB-VIEW-LCD7-01
Notice that the preceding "#" has been removed. You don't want to disable BB-BONE-EMMC-2G, or you won't be able to boot from eMMC.
Now save and exit by doing CTRL-O, Enter, CTRL-X.

Reboot the BBB and the LCD should now work....except the blue and red are reversed.

Fixing Red/Blue Color Swap

This is due to errata in the TI AM335x processor when switching between 16 and 24 bit video modes. To fix this, we must first find the name of our screen:
> ssh debian@
bbb> cat  /var/log/Xorg.0.log  |  grep  screen
Mine was "Builtin Default fbdev Screen 0"

Now we edit our X configuration file:
bbb> sudo nano  /usr/share/X11/xorg.conf.d/10-evdev.conf

and add a "Screen" section at the end of the file:
Section "Screen"
        Identifier "Builtin Default fbdev Screen 0"
        Monitor "Configured Monitor"
        Device "Configured Video Device"
        DefaultDepth 24
Save and exit by doing CTRL-O, Enter, CTRL-X.
Reboot and enjoy!

Thursday, January 16, 2014

Bare Metal Qt 5.2 on BeagleBone Black Ubuntu - Part 3


With Qt 5.2 working on the BeagleBone Black, created in Part 1 and Part 2, now it is time to compile a "Hello World" application. Assumptions:
  • You are using an Ubuntu x64 host for creating Qt applications
  • You have a Linaro toolchain located under /usr/local/linaro
  • You have a BeagleBone connect to your host PC via a LAN


No need to compile our own Qt Creator, just download it:

Video Tutorials

Derek Molloy has three excellent videos about Qt on the BeagleBone. I suggest you start with these, as it will make following these instructions easier.

Setup Toolchain Environment

Open Qt Creator
Go to Tools -> Options

Add a new Device
Click on "Devices" from the list on the left
Click the "Add..." button on the upper right
Select Generic Linux Device
Click "Start Wizard" button
Enter "BBB - Ubuntu" for the name
Enter IP, and user information.
Click "Next" button
Click "Finish" button
Verify that the test connection was successful

Add a new Compiler
Click on the "Build & Run" item from the list on the left
Click on the "Compilers" tab
Click the "Add" drop down list button and select GCC
Change the name to "Linaro GCC"
Click the "Browse..." button next to the "Compiler path" field
Enter "/usr/local/linaro/bin/" into the filename field and click "Open"
Select "arm-linux-gnueabihf-g++" and click "Open" again
Click the "Apply" button

Add a new Debugger
Click on the "Debuggers" tab
Click the "Add" button
Enter "Linaro GDB" for the name
Click the "Browse..." button next to the Path field
Select "arm-linux-gnueabihf-gdb" and click "Open"
Click the "Apply" button

Add a new Qt Version
Click on the "Qt Versions" tab
Click the "Add..." button
Navigate to "/usr/local/qt-5.2/bin/qmake"
Click the "Open" button
Click the "Apply" button

Add a new Kit
Click on the "Kits" tab
Click the "Add" button
Change name to "BBB Kit"
Ensure that the device type is "Generic Linux Device"
Ensure that the device is "BBB - Ubuntu"
Select the "Linaro GCC" compiler from the Compiler drop down list button
Select the "Linaro GDB" debugger from the Debugger drop down list button
Select the "Qt 5.2.0 (qt-5.2)" version from the "Qt Version" drop down list button
Click the "Ok" button

Create a New Console Project

Under the Welcome page, Click the "New Project" button
Select "Applications" from the list on the left
Select "Qt Console Application"
Click the "Next" button
Enter "HelloWorld" in the name field
Change the target directory, if you like
Click on the "Next" button
Review the details and then click on the "Next" button
Click on the "Finish" button

Modify Auto-Generated Project

Edit main.cpp to look like this:

#include <QCoreApplication>
#include <iostream>
using namespace std;

int main(int argc, char *argv[])
   QCoreApplication a(argc, argv);
   cout << "Hello World!" << endl;
   return a.exec();

This will build locally, but we want it to auto deploy to the BeagleBone. That's coming up next...

Create Deploy Configuration

Add the following three lines to after the "TARGET=HelloWorld" line

   target.files = HelloWorld
   target.path = /home/ubuntu
INSTALLS += target

That's it, now Qt Creator will automatically deploy the files before a debug or run.

Install GDB Server

This is required in order to debug from Qt Creator running on our host PC. This only needs to be done once. Issue this command on the Beaglebone:

> sudo apt-get install gdbserver

Now you can press the Debug icon (looks like a play arrow) in Qt Creator and it will automatically scp the binary to the BeagleBone and start a remote GDB server session.

Create a GUI Project

Under the Welcome page, Click the "New Project" button
Select "Applications" from the list on the left
Select "Qt Gui Application"

Note: This option may not show up. If Qt Creator does not see the Qt 5.2 build as supporting GUI applications,  you can choose "Qt Widgets Application", but this may give different results. The other option is to install a distro version of Qt and make Qt Creator aware of it. This will make the Gui option visible in the project creation section. Nevermind, this is a difference between Qt Creator 2.8 and 3.0. The source generated, for either option, is identical.

Click the "Next" button
Enter "HelloWorldGUI" in the name field
Change the target directory, if you like
Click on the "Next" button
Review the details and then click on the "Next" button
Click on the "Finish" button

Modify Auto-Generated Project

Perform the same .pro file changes, as the console project, to deploy the project to the Beaglebone.

Friday, January 10, 2014

Bare Metal Qt 5.2 on BeagleBone Black Ubuntu - Part 2


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.


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

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-*
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

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@           

Replace 'ubuntu' with the user account that you use on the BeagleBone. Replace '' 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 

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!


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


Here are some web pages that I used for inspiration.

Thursday, January 9, 2014

Bare Metal Qt 5.2 on BeagleBone Black Ubuntu - Part 1


This part will guide you through the steps to create a working cross compile platform for the Beaglebone. I will try to keep it generic enough that you could use any toolchain and target distro, but this is my target:
  • BeagleBone Black Rev A6
  • Saucy Ubuntu 13.10 with Kernel 3.8.13-bone32 (12/13/2013) installed to eMMC
  • CircuitCo LCD7 Rev A3
See Part 2 for configuring and building Qt. 


Download these files while you read the instructions below...

Setup Generic Virtual Machine

Follow these instructions to create and setup a vanilla Ubuntu VM. If you already have a VM or are going to use your host Ubuntu install, proceed to the "Install Compiler Prerequisites" section.
  1. Install Virtual Box
  2. Create a new Virtual Machine
    1. Enter a name, such as "Ubuntu Qt Builder"
    2. Change Type to "Linux", if it hasn't automatically done so.
    3. Change Version to "Ubuntu (64 bit)"
    4. Specify memory size, at least 1.5 Gb for better compiling performance.
    5. Create a new virtual hard drive (ignore size recommendation for now)
    6. Select VDI
    7. Select Dynamically allocated
    8. Set size to at least 40 Gb (it's dynamic, so why limit yourself)
    9. Once the virtual machine is created, change the advanced settings
      1. Click the Settings button and then select "System" from the list on the left
      2. Click the "Processor" tab and change the Processors to something greater than 1
      3. Select "Display" from the list on the left
      4. Max out the video memory
      5. Select "Storage" from the list on the left
      6. Click on the empty CD drive under the Storage Tree
      7. Under the attributes section, click the CD symbol and select "Choose a Virtual CD/DVD disk file"
      8. Point it to your Ubuntu ISO.
      9. Adjust other virtual machine settings as desired.
  3. Start the virtual machine and perform the Ubuntu Install
  4. After the install completes, reboot the virtual machine. Don't forget to hit enter to "eject" the boot CD when it prompts.
  5. Let it install the 200+ updates
  6. After another reboot, install Guest Additions by clicking on the Devices menu of the running VM, and then selecting "Install Guest Additions..." (You may have to do this again after Ubuntu installs future updates)

Install Compiler Prerequisites

Since we are running a 64 bit host OS, we need to install the 32 bit libraries to run some of the build tools. We also need the Linaro headers. Follow these instructions to install both of these required packages
  1. Open a new Terminal or xterm window
  2. Type the following to install the Linaro headers and 32 bit compatibility libraries
> sudo apt-get install lsb                          
> sudo apt-get install ia32-libs                       

Extract Qt Source

Perform this step to expand the source tarball into your home directory. It will reside under the tarball directory of "qt-everywhere-opensource-src-5.2.0". This can be done in a new terminal window, while the prerequisites are being installed.

> cd                                                   
> tar -zxf qt-everywhere-opensource-src-5.2.0.tar.gz   

Now we create a couple of folders for our shadow builds. This helps keep the main source folder clean of configuration files and binaries.

> mkdir qt-5.2-host                                    
> mkdir qt-5.2-target                                  

Extract Linaro Toolchain

I chose to use the Linaro toolchain because it came highly recommended and the Ubuntu cross compile chain does not include a g++ binary, which will be required to compile Qt.

Issue these commands to extract the Linaro toolchain, change the directory name, and move it to a global location:

> tar -Jxf gcc-linaro-arm-linux-gnueabihf-4.8-2013.04-20130417_li nux.tar.xz                                                       
> mv gcc-linaro-arm-linux-gnueabihf-4.8-2013.04-20130417_linux \ 
> sudo mv linaro /usr/local                                      


You should now have a working Ubuntu virtual machine that is:

  • Up-to-date
  • Has necessary host utilities installed
  • Contains a folder, in the home directory, with the Qt source
  • Has the Linaro toolchain installed under /usr/local/linaro

Continue on to Part 2 for the configuration and building of Qt.