martes, 17 de noviembre de 2015

Compilar Qt5 en Windows y Linux para usar en Beaglebone Black (Machinekit).

Para poder usar QT con un dispositivo que tenga una arquitectura diferente a la del PC que se este usando, se necesita compilar los archivos con un compilador cruzado con el objetivo de poder crear códido ejecutable que corra en la otra plataforma.

En este tutorial se indicará como compilar QT5 para usarlo en la plataforma Beaglebone Black. Se puede instalar QT tanto en windows como en linux, por lo que primero se mostrará como realizar los pasos necesarios en Windows y luego se indicará en Linux.

Compilación de QT5 en Windows.

Primero hay que descargar los archivos necesarios para instalar en windows, en el siguiente link BBB-Compilador-Cruzado-Windows se puede descargar el programa que instalará el compilador y los archivos que permitirán crear las librerías de QT. En este otro link MINGW32 está el programa que se encargará de ejecutar un entorno de linux en windows para usar el compilador cruzado y las librerías de linux que se encuentran en la carpeta "C:\SysGCC\BeagleDebian\arm-linux-gnueabihf\sysroot".




Ahora hay que descargar e instalar Python 2.7 para Windows.

Una vez descargados e instalados los archivos, que por defecto se instalán en la carpeta C:\SysGCC, se debe ejecutar el archivo msys.bat que se encuentra en la ruta "C:\SysGCC\MinGW32\msys\1.0". Saldrá una ventana en la cuál ya podemos comenzar a  configurar el entorno de windows con mingw32. 



 Primero se debe crear una carpeta donde se descargará el código de QT5.5.1, una forma es pegar el archivo descargado a la carpeta que se creará. Esto se hace copiando el link sin la palabra wget y pegar en el navegador web. 

Para poder usar mingw con el comando wget, se debe instalar el ejecutable descargando el programa mingw-get-setup.exe y realizando lo siguiente:

 - Ejecutar el archivo mingw-get-setup.exe y en Installation Directory colocar la ruta de directorio del  programa MinGW32.

  
- Seleccionar y aceptar Run Now.


 - Buscar el ejecutable (bin) o librería que se quiera instalar y marcarla para luego aplicar los cambios.







- Para terminar solo que aceptar y cerrar cuando acabe el proceso.

Listo, ahora hay que descargar el código de QT5.5.1, en este link se puede descargar la versión que se requiera de QT -> QT versiones.

Nota: Para pegar texto hay que ir a la parte superior izquierda de la ventana de mingw32, dar click-derecho, ir a editar y pegar.


mkdir -p /c/download
cd /c/download
wget http://download.qt.io/archive/qt/5.5/5.5.1/single/qt-everywhere-opensource-src-5.5.1.tar.xz 
#si se quiere ver el proceso usar tar -xvf 
tar xf qt-everywhere-opensource-src-5.5.1.tar.xz

una vez que se termine de descargar y descomprimir, se debe verificar los programas que deben estar instalados y si no encuentra o esta mal asignada la ruta se debe exportar la correcta de la siguiente manera.
 
export PATH=/c/SysGCC/MinGW32/bin/:$PATH




 Ahora hay que realizar un paso muy importante, y es que el programa descargado de tool-chain BeagleDebian no incluye un archivo que es necesario para que mingw32 sepa donde estan las librerías necesarias de la carpeta sysroot para compilar QT .

cd /c/SysGCC/BeagleDebian/arm-linux-gnueabihf/sysroot/
mkdir -p etc/
cd etc/
touch ld.so.conf

En windows ir a la ruta del archivo ld.so.conf "C:\SysGCC\BeagleDebian\arm-linux-gnueabihf\sysroot\etc" y abrir con cualquier editor (recomiendo tener notepad++), pegar lo siguiente y guardar.
En el caso de querer usar nano con mingw32 hay que copiar los archivos de la carpeta bin del siguiente link MinGW editor nano y  pegarlos en "C:\SysGCC\MinGW32\msys\1.0\bin".

# Multiarch support
/lib/arm-linux-gnueabihf
/usr/lib/arm-linux-gnueabihf
# libc default configuration
/usr/local/lib

Ahora hay que modificar el archivo qmake.conf de la siguiente ruta "C:\download\qt-everywhere-opensource-src-5.5.1\qtbase\mkspecs\devices\linux-beagleboard-g++". Esto se hace para poder construir QT con la opción de habiltar X11 para ejecutar las aplicaciones con GUI, cambiar la variable QT_QPA_DEFAULT_PLATFORM a xcb y en COMPILER_FLAGS comentar "-mfloat-abi=softfp".


 Lo siguiente es configurar el archivo qmake.conf de la ruta "C:\download\qt-everywhere-opensource-src-5.5.1\qtbase\mkspecs\win32-g++". Esto se realiza por un bug que existe al generar el archivo qmake para windows usando win32-g++. Se debe añadir -U__STRICT_ANSI__ a la variable CXXFLAGS.


Para construir QT5 sin modificar la carpeta extraida se debe crear una carpeta a la que se le llamará qt-build, esto se hace para no tener que eliminar la carpeta extraida y volver a extraer si la compilación sale mal. Si esto ocurre solo hay que eliminar la carpeta qt-build de ser necesario o sino volver a ejecutar la compilación habiendo corregido el problema.

cd /c/download/
mkdir -p qt-build
cd qt-build
../qt-everywhere-opensource-src-5.5.1/configure -platform win32-g++ -xplatform linux-arm-gnueabi-g++ -release -device linux-beagleboard-g++ -sysroot C:/SysGCC/BeagleDebian/arm-linux-gnueabihf/sysroot -prefix /usr/local/qt5 -opensource -confirm-license

Después de crear el ejecutable qmake.exe en la carpeta qtbase se escribe "qtbase/bin/qmake -v" para comprobar la versión.


Voy dar una breve explicación de lo que hace cada opción en la configuración de QT:

Al poner "../qt-everywhere-opensource-src-5.5.1/configure" regresa de la carpeta qt-build a la carpeta download donde esta la carpeta extraida de "qt-everywhere-opensource-src-5.5.1",  he ingresa a esta y ejecuta el archivo de configure. A partir de esto se pone las opciones con las que se quiere construir QT.

-platform win32-g++ -> indica que sa va usar la configuración realizada en "C:\download\qt-everywhere-opensource-src-5.5.1\qtbase\mkspecs\win32-g++/qmake.conf". Este se usa para crear archivos para windows. 

-xplatform linux-arm-gnueabi-g++ -> indica que se va usar la configuración ARM con el compilador cruzado que se ha instalado. Esta permite crear los archivos para Raspberry Pi, Beaglebone Black, etc.

-release -> Con esta opción se crean archivos de forma optima sin necesidad de incluir información de depuración que hace que pese mucho más el archivo. 

-device linux-beagleboard-g++ -> le dice que tipo de configuración se debe usar de acuerdo al dispositivo con el que se quiera trabajar, generalmente en la configuració de beaglebone black se cambia las opciones del archivo qmake.conf dentro de la carpeta linux-beagleboard-g++ y se lo adapta para una optima configuración en la beaglebone black. 

-sysroot C:/SysGCC/BeagleDebian/arm-linux-gnueabihf/sysroot -> En sysroot se determina la ruta donde están los archivos con las librerías necesarias para poder compilar y crear las librerías de QT. Según las opciones que se quieran habilitar en QT se debe tener instalada en la partición rootfs que es la que contiene toda la información.

-prefix /usr/local/qt5 ->  La ruta que este colocada en prefix es la que se va a usar para instalar los archivos de QT, en este ejemplo los archivo de QT se instalarán en sysroot más la ruta prefix
"C:/SysGCC/BeagleDebian/arm-linux-gnueabihf/sysroot/usr/local/qt5".

-opensource -> Indica que se acepta la configuración de QT como de código abierto y no la otra opcíon que es la Comercial.

 -confirm-license -> Con esta opción se acepta la configuración escogida de código abierto.

Esas fueron algunas de las opciones con las que trabaja QT, para saber más ver el siguiente link Configuración QT o Opciones Configuración QT.

Ahora se debe configurar el archivo "configure" de la ruta "C:\download\qt-everywhere-opensource-src-5.5.1\qtbase" y modificar con esto "if [ '!' -f "$outpath/bin/qmake.exe" ]; then".


 
../qt-everywhere-opensource-src-5.5.1/configure -platform win32-g++ -xplatform linux-arm-gnueabi-g++ -release -device linux-beagleboard-g++ -sysroot C:/SysGCC/BeagleDebian/arm-linux-gnueabihf/sysroot -prefix /usr/local/qt5 -device-option CROSS_COMPILE=C:/SysGCC/BeagleDebian/bin/arm-linux-gnueabihf- -qt-xcb -opensource -confirm-license 

-device-option CROSS_COMPILE=C:/SysGCC/BeagleDebian/bin/arm-linux-gnueabihf- -> Con esta configuración se determina la ruta donde se encuentra el compilador cruzado que se va a usar.

-qt-xcb -> Es una configuración muy importante en QT5 si se quiere ejecutar aplicaciones con GUI. ya que si no se lo pone faltaría la librería "libqxcb.so" que se encuentra en la ruta donde se instalo QT5/plugins/platforms "C:\SysGCC\BeagleDebian\arm-linux-gnueabihf\sysroot\usr\local\qt5\plugins\platforms" y si no esta, el programa de QT pedirá una reinstalación si se quiere utilizar.

Al terminar de configurar QT con las anteriores opciones se debe ejecutar make y cuando haya terminado de compilar ejecutar make install.

Por último copiar la carpeta qt5 creada en  "C:\SysGCC\BeagleDebian\arm-linux-gnueabihf\sysroot\usr\local" a la Beaglebone Black a "~/" y luego mover a "/usr/local". En windows se puede usar pscp y en linux scp, más información de como copiar archivos o carpeta en este link http://bbb-machinekit-lcd7.blogspot.com/2015/07/primeros-pasos-machinekit-beaglebone.html.

sudo mv ~/qt5 /usr/local

Si Qt lanza un error  de que la variable QT_XKB_CONFIG_ROOT se  puede solucionar con el siguinete comando.

export QT_XKB_CONFIG_ROOT=/usr/share/X11/xkb

Nota: En mi caso no me funciono poner el número de núcleos que tiene mi procesador ya que se quedaba colgado en un proceso, asi que recomiendo ejecutar solo como make y no como make -j# (#-> número de procesadores) .
Otro punto importante con mingw32-make me funciono ejecutar con 4 núcleos en mi equipo pero falló al compilar un archivo el cúal se encuentra en la ruta "C:\download\qt-build\qtwebchannel\examples\webchannel\standalone\", el archivo main.cpp se arreglo abriendo con notepad++ y convirtiendo el archivo en utf-8, para luego compilar con un make en la carpeta mencionada y volviendo a hacer un mingw32-make en la carpeta principal qt-build siguió normalmente el proceso. Para finalizar se corre un make install o un mingw32-make install.
La compilación con mingw32 es demasiada lenta, en mi caso fue de 5 horas de compilación y 3 horas de instalación (copia de los archivos de qt-build a la carpeta de qt5 en sysroot).

Referencia: http://visualgdb.com/tutorials/beaglebone/qt5/cross-compile/
                   https://sysprogs.com/w/fixing-rpath-link-issues-with-cross-compilers/.

Compilación de QT5 en Linux

Para compilar QT5 en Linux se va usar la Imagén de Machinekit o la carpeta de sysroot obtenida al instalar GNU Toolchain de Beaglebone en windows. 

Si se tiene instalado Linux para equipos de 64 bits, se recomienda instalar esto:

sudo apt-get update
sudo apt-get install ia32-libs-i386
sudo apt-get install lsb

Si se va ha compilar QT en una máquina virtual como vmware, se recomienda revisar el siguiente link Primeros Pasos BBB en la parte de "Copiar Imagen Machinekit usando Linux", se explica como detectar las memorias microSDCard como un disco duro. Ya configurada la microSDCard en VMWARE se debe montar y luego generar un respaldo asi que a partir de aquí comienza el tutorial.

Primera Opción -> Usar la Imagen Machinekit

La Imagen Machinekit utiliza dos particiones, la primera es la de "boot" donde están todos los archivos necesarios para que inicie y los drivers para instalar en Windows, Linux y MacOSX. La segunda que es la más importante para instalar QT5, contiene los Headers y Librerías necesarias para construir QT5.

Con los comandos lsblk y fdisk se puede obtener la información de los discos y memorías externas conectadas. En mi caso la partición de "boot" o "BEAGLEBONE" es la sbd1 y la partición "rootfs" es la sbd2. Se va a realizar unos pasos para indicar que lo que se explica es correcto.

#Usar lsblk o fdisk para detectar donde se encuentra la microSDcard
sudo fdisk -l
lsblk
#Primero se va a crear las carpetas donde vamos a montar las particiones
#para poder visualizar los archivos que contienen.
sudo mkdir /mnt/boot
sudo mkdir /mnt/rootfs
#Luego de crear los archivos se debe montar las particiones sdb1 y sdb2
sudo mount /dev/sdb1 /mnt/boot
sudo mount /dev/sdb2 /mnt/rootfs
#Ir a las carpeta y visualizar los archivos como se explico una partición contiene los 
#Drivers y archivos para bootear, y la otra contiene todas las carpetas que se encuntran
#en el "root" de un Sistema Linux.
ls /mnt/boot
ls /mnt/rootfs
#Al terminar desmontar la partición de boot y rootfs, luego se montará de nuevo la
#partición de rootfs para construir QT5 con las librerías alojadas en esta.
cd
sudo umount /mnt/boot
sudo umount /mnt/rootfs

En la siguiente Imagen se puede visualizar el recuadro de color rojo que indica el número de particiones de la SDCard y también el tamano que en este caso es de "8gb", el azul indica los archivos de la carpeta "boot" o "BEAGLEBONE" y el amarrillo indica los archivos de la carpeta "rootfs".



Explicado lo anterior ya se puede crear el archivo comprimido de rootfs para usarlo en QT5, pero primero hay que instalar unas librerías necesarías si se quiere usar las siguientes componentes de QT5. Para esto se va a poner la microSDCard en la Beaglebone Black y comenzar a descargar las siguientes librerías.

sudo apt-get update

Instalar librerías necesarias para libxcb (necesaria para ejecutar GUI´s):
 
sudo apt-get install -y "^libxcb.*" libx11-xcb-dev libglu1-mesa-dev libxrender-dev libxi-dev

Instalar librerías necesarias para QtMultimedia:

sudo apt-get install -y libasound2-dev libgstreamer0.10-dev libgstreamer-plugins-base0.10-dev

Instalar librerías necesarias para QtWebEngine:

sudo apt-get install -y libcap-dev libbz2-dev libgcrypt11-dev libpci-dev libnss3-dev build-essential libxcursor-dev libxcomposite-dev libxdamage-dev libxrandr-dev libdrm-dev libfontconfig1-dev libxtst-dev libasound2-dev gperf libcups2-dev libpulse-dev libudev-dev libssl-dev flex bison ruby

Instalar librerías necesarias para QtConnectivity:

sudo apt-get install -y bluez libbluetooth-dev bluetooth bluez-tools

Instalar librerías necesarias para libi2c-dev (necesaria si se quiere comunicar por I2C):

sudo apt-get install -y i2c-tools libi2c-dev


Una vez que se hayan instalado todas las librerías, se puede limpiar los paquetes descargados.

sudo apt-get clean
sudo shutdown -h now

Ahora apagamos la Beaglebone Black e insertamos la microSDCard en la PC para continuar con la construcción de QT5.

Primero hay que crear una carpeta donde se quiera realizar el proceso de compilar QT5. De preferencia se crea en /opt/ que es donde se instalán varios programas por defecto.

#Creación de carpeta qt-beaglebone-black en /opt
sudo mkdir /opt/qt-beaglebone-black/
#Con chown se da permisos para poder trabjar en dicha carpeta como root y $USER detecta
#el usuario que actualmente esta activo
sudo chown $USER /opt/qt-beaglebone-black/

Antes de continuar con los siguientes pasos se puede usar la segunda opción que evitará que se realice los pasos anteriores de instalar las librerías y poder usar las que vienen por defecto, en la carpeta sysroot de la instalación de windows que se encuentra en C:\SysGCC\BeagleDebian\arm-linux-gnueabihf\sysroot.

Segunda Opción -> Usar la carpeta de sysroot.

Lo único que se tiene que hacer es copiar la carpeta sysroot de windows a VMWARE o PC Linux, se puede usar conexión remota (pscp en windows, scp linux)  o Pendrive o arrastrar y pegar en una carpeta de VMWARE.

En el método de copiar la carpeta sysroot. Se debe montar en una carpeta de linux para poder continnuar con el proceso.

#Buscar donde está la carpeta sysroot copiada
#En VMWARE la copie con pscp de windows en ~/
sudo mkdir /mnt/rootfs
sudo mount ~/sysroot /mnt/rootfs
#En mi PC con linux use un Pendrive y lo monte
sudo mkdir /mnt/rootfs
sudo mount /media/nombre-de-pendrive /mnt/rootfs

Continuación...

Realizado lo anterior ya se puede realizar un respaldo de la carpeta rootfs a /opt/qt-beaglebone-black

#No realizar este paso si se va a usar la Segunda opción
#Como se explicó en la primera opción hay que montar la partición de rootfs para hacer
un respaldo del mismo.
sudo mkdir -p /mnt/rootfs
sudo mount /dev/sdb2 /mnt/rootfs 

Crear Respaldo.

Se crea un respaldo para no dañar los archivos y se los comprime para copiar a la carpeta /opt/qt-beaglebone-black creada.

#Ir a la carpeta donde se monto la partición rootfs o la carpeta sysroot
cd /mnt/rootfs
#Comprimir los archivos y enviar a la carpeta qt-beaglebone-black
sudo tar cpjfv /opt/qt-beaglebone-black/rootfs.tar.bz2 ./
#Dar permisos para poder ejecutar el archivo rootfs.tar.bz2 cuando se use el script que
#se va a publicar al final del tutorial.
sudo chown $USER /opt/qt-beaglebone-black/rootfs.tar.bz2

Explicación de script publicado al final.En esta parte se va a tratar de explicar lo más claro posible, ya que realizando bien este proceso se podrá obtener una compilación de QT exitosa. No realizar si se va a usar el script, todos estos pasos se deben realizar en la carpeta /opt/qt-beaglebone-black.

Para descargar la última versión de QT5 ir a QT RepositorioBBB-Machinekit .

#Primero hay que descargar el código de QT5.5.1 que es el último por ahora.
wget http://download.qt.io/archive/qt/5.5/5.5.1/single/qt-everywhere-opensource-src-5.5.1.tar.xz
#Con md5sum se comprueba que la versión descargada no haya sido alterada.
md5sum qt-everywhere-opensource-src-5.5.1.tar.xz c2a249e8795d45200d997d96860d0353
#Ahora usar "tar" para descomprimir el archivo descargado.
tar -xvf qt-everywhere-opensource-src-5.5.1.tar.xz

Con esto ya se tiene el código QT, lo siguiente es descargar el compilador cruzado. Esto se realiza por que la última versión del compilador-cruzado que instalé tiene algunos problemas para compilar con QT. La versión que se descargará a continuación es más vieja pero funciona perfectamente.

#Descargar de compilador
wget http://releases.linaro.org/14.04/components/toolchain/binaries/gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux.tar.xz
#Descomprimir compilador
tar -xvf gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux.tar.xz

Para extraer el archivo comprimido de rootfs es recomendable crear una carpeta para que todos los archivos del sistema raíz se guarden en ella.

#Carpeta rootfs creada en la ruta /opt/qt-beaglebone-black anteriormente creada
mkdir /opt/qt-beaglebone-black/rootfs
#Se descomprime el archivo rootfs comprimido en el archivo rootfs.tar.bz2
sudo tar xf /opt/qt-beaglebone-black/rootfs.tar.bz2 -C /opt/qt-beaglebone-black/rootfs

El siguiente script que se descargará es importante para comprobar si la Imagen de linux Debian para Beaglebone Black, tiene correctamente instaladas las librerías en la ruta /opt/qt-beaglebone-black/rootfs/usr/lib y se comprueba compatibilidad con el compilador cruzado descargado.

#Descarga de script
wget http://guh.guru/downloads/scripts/fixQualifiedLibraryPaths
#Se da permisos de ejecución al script
chmod +x fixQualifiedLibraryPaths
#La siguiente orden ejecuta el script dando la ruta donde se instaló rootfs y comprueba
#las librerías con el compilador cruzado qe se tenga en el PC
sudo ./fixQualifiedLibraryPaths /opt/qt-beaglebone-black/rootfs /opt/qt-beaglebone-black/gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux/bin/arm-linux-gnueabihf-g++

Ahora hay que realizar modificaciones en los archivos que configuran QT, al igual que se realizó con la configuración de windows hay que reemplazar algunas variables.

#Al ingresar al directorio de devices solo existe la configuración para beagleboard
cd /opt/qt-beaglebone-black/qt-everywhere-opensource-src-5.5.1/qtbase/mkspecs/devices/
#Para eso se realiza una copia 
cp -rv linux-beagleboard-g++ linux-beaglebone-g++
#Luego se modifica la variable -mfloat-abi=softfp por -mfloat-abi=hard que se guardará en
#la nueva copia "linux-beaglebone-g++/qmake.conf"
sed 's/softfp/hard/' <linux-beagleboard-g++/qmake.conf >linux-beaglebone-g++/qmake.conf

En la carpeta de mkspecs donde esta la configuración del compilador que se va a usar, tambien se realiazan cambios para decirle la ruta del compilador que se va a usar.

#Entra al directorio mkspecs
cd /opt/qt-beaglebone-black/qt-everywhere-opensource-src-5.5.1/qtbase/mkspecs
#Realiza una copia de la configuración "linux-arm-gnueabi-g++"
cp -r linux-arm-gnueabi-g++/ linux-linaro-gnueabihf-g++/
#Variable que se usa para reemplazar con el directorio donde se encuentra el compilador cruzado
TO_REPLACE="arm-linux-gnueabi-"
#Se sutituye la variable "arm-linux-gnueabi-" con la ruta del compilador+los ejecutables
#arm-linux-gnueabi- que con la opción de g se repite para todas las variales "arm-linux-gnueabi-"#
#que encuentre y las copia al nuevo archivo "linux-linaro-gnueabihf-g++/qmake.conf" 
sed "s|${TO_REPLACE}|/opt/qt-beaglebone-black/gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux/bin/arm-linux-gnueabihf-|g" <linux-arm-gnueabi-g++/qmake.conf >linux-linaro-gnueabihf-g++/qmake.conf

Cuando se compila un programa pesado es recomendable crear una carpeta de build, para en caso de haber un error de compilación no tener que borrar el directorio y tener que volver a extraer la carpeta original. Al crear la carpeta qt-build si algo sale mal la podemos borrar y volver a compilar todo sin que se tenga que borrar la carpeta original de qt-everywhere-opensource-src-5.5.1.

cd /opt/qt-beaglebone-black
mkdir -p qt-build
cd qt-build

La configuración que se le va a dar a QT es la siguiente:
 
../qt-everywhere-opensource-src-5.5.1/configure \
         -prefix /usr/local/Qt-5.5.1 \
         -sysroot /opt/qt-beaglebone-black/rootfs \
         -device linux-beaglebone-g++ \
  -xplatform linux-linaro-gnueabihf-g++ \
         -device-option CROSS_COMPILE=/opt/qt-beaglebone-black/gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux/bin/arm-linux-gnueabihf- \
  -release \
         -silent \
                -qt-xcb \
         -opensource \
         -confirm-license \
         -continue \
         -v \
  -nomake examples \
  -nomake tests \
 

Regresa una carpeta y busca la carpeta original de qt para ejecutar el archivo configure y establecer las siguientes opciones.

-prefix /usr/local/Qt-5.5.1 ->  La ruta que este colocada en prefix es la que se va a usar para instalar los archivos de QT, en este ejemplo los archivo de QT se instalarán en rootfs más la ruta prefix
"/opt/qt-beaglebone-black/rootfs/usr/local/Qt-5.5.1".

-sysroot  /opt/qt-beaglebone-black/rootfs-> En sysroot se determina la ruta donde están los archivos con las librerías necesarias para poder compilar y crear las librerías de QT. Según las opciones que se quieran habilitar en QT se debe tener instalada en la partición rootfs que es la que contiene toda la información.

-device linux-beaglebone-g++ -> le dice que tipo de configuración se debe usar de acuerdo al dispositivo con el que se quiera trabajar, generalmente en la configuració de beaglebone black se cambia las opciones del archivo qmake.conf dentro de la carpeta linux-beagleboard-g++ y se lo adapta para una optima configuración en la beaglebone black. Como se explico anteriormente. 

-xplatform linux-linaro-gnueabihf-g++ -> indica que se va usar la configuración ARM con el compilador cruzado que se ha instalado o con la ruta que se ha establecido para usar un compilador cruzado. Esta permite crear los archivos para Raspberry Pi, Beaglebone Black, etc. Como se explico anteriormente.

-device-option CROSS_COMPILE=/opt/qt-beaglebone-black/gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux/bin/arm-linux-gnueabihf-  -> Con esta configuración se determina la ruta donde se encuentra el compilador cruzado que se va a usar.


-release -> Con esta opción se crean archivos de forma optima sin necesidad de incluir información de depuración que hace que pese mucho más el archivo. 

-silent -> Sirve para no lanzar los errore de forma detallada si no de una forma general.

-qt-xcb -> Es una configuración muy importante en QT5 si se quiere ejecutar aplicaciones con GUI. ya que si no se lo pone faltaría la librería "libqxcb.so" que se encuentra en la ruta donde se instalo QT5/plugins/platforms "/opt/qt-beaglebone-black/rootfs/usr/local/Qt-5.5.1/plugins/platforms" y si no esta, el programa de QT pedirá una reinstalación si se quiere utilizar.

-opensource -> Indica que se acepta la configuración de QT como de código abierto y no la otra opcíon que es la Comercial.

 -confirm-license -> Con esta opción se acepta la configuración escogida de código abierto.


 -continue -> Continua si hay un error, siempre y cuando no se relevante.

-v -> Imprime la información de detallada del proceso de configuración. Esta info sirve para poder determinar con que opciones se va a configurar QT y en el script se va a guardar en un archivo para poder instalar las librerías que sean necesarias para activar todas las opciones que se requieran. Las librerías se deben instalar usando la Beaglebone Black y repetir nuevamente el proceso.

-nomake examples -> no compila los ejemplos que se encuentran en las carpetas.

-nomake tests -> no realiza pruebas, no ejecuta y cuemprueba los archivo .pro.

Ahora viene la parte de como usar un archivo para depurar la configuración de QT.

#se crea una carpeta donde se guardará todos los archivos con la info de depuración
mkdir /opt/qt-beaglebone-black/logfiles
#Con "2>&1" se esta diciendo que tomo los errores generados y con tee que los almacene
# en un archivo
2>&1 | tee -a /opt/qt-beaglebone-black/logfiles/qtbase-configure-log.txt \

Lo mismo se hace para la compilación.

#nproc devuelve el número de núcleos que tiene el PC
export NPROC=`nproc`
make -j$NPROC 2>&1 | tee -a /opt/qt-beaglebone-black/logfiles/qtbase-build-log.txt

Cuando todo se haya configurado y compilado se creará el ejecutable qmake. Se usa para verificar el funcionamiento de los archivos creados cuando se va instalar en un directorio.

#Esta variable se crea solo para confirmar que qmake se ha instalado el el directorio
#asignado en la configuración.
export QMAKE_CROSS="/opt/qt-beaglebone-black/rootfs/usr/local/Qt-5.5.1/bin/qmake"
#Entramos a la carpeta donde se compilo toda la info 
cd /opt/qt-beaglebone-black/qt-build

Este es el último paso para instalar los componentes que queramos de QT. Entra de una en una a las carpetas asignadas, comprueba que qmake exista y realiza una compilcación de cada carpeta antes de instalar en la carpeta "/opt/qt-beaglebone-black/rootfs/usr/local/Qt-5.5.1".

###############################################################
# build qtgraphicaleffects
cd qtgraphicaleffects
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtgraphicaleffects-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtgraphicaleffects-make-log.txt
sudo make install
cd ..

###############################################################
# build qttools
cd qttools
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qttools-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qttools-make-log.txt
sudo make install
cd ..


 Scrip para realizar los pasos anteriores de forma automática.

Los pasos de copiar los datos de la microSDCard, comprimir y copiar a la carpeta "/opt/qt-beaglebone-black", hay que hacerlos de forma manual ya que la partición rootfs de la microSDCard puede estar asiganada a una entrada diferente a sdb como ejemplo puede ser sdc u otra.

En el script se asignan varias variables para obtener la ruta de los archivos o carpetas que se va a usar. A continuación dejo las variables con la ruta completa, y en el script ya estará con las variables sintetizadas.

#Directorio que se va usar, com "pwd" retorna el directorio donde se este.
CURRENT_DIR="/opt/qt-beaglebone-black"
#Directorio que indica donde está la código de QT
QT_SRCDIR="/opt/qt-beaglebone-black/qt-everywhere-opensource-src-5.5.1"
#indica donde se encuentra el archivo descargado de los repositorios de QT
QT_SRCFILE="${QT_SRCDIR}.tar.xz"
#URL para descargar QT
QT_URL="http://download.qt.io/archive/qt/5.5/5.5.1/single/qt-everywhere-opensource-src-5.5.1.tar.xz"
#Directorio donde se encuentra el compilador cruzado
CC_DIR="/opt/qt-beaglebone-black/gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux"
#URL para descargar el compilador cruzado
CC_URL="http://releases.linaro.org/14.04/components/toolchain/binaries/gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux.tar.xz"
#Dirección donde se encuentra el archivo descargado del compilador cruzado
CC_FILE="${CC_DIR}.tar.xz"
#Directorio donde se encuentran los binarios del compilador cruzado
CC="/opt/qt-beaglebone-black/gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux/bin/arm-linux-gnueabihf-"
#Directorio que se usará para instalar QT5
PREFIX="/usr/local/Qt-5.5.1"
#Directorio Principal de donde se obtendrán los librerías necesarías para instalar 
ROOTFS_DIR="/opt/qt-beaglebone-black/rootfs"
#Directorio que se usará para extraer todos los errores reportados
LOG_DIR="/opt/qt-beaglebone-black/logfiles"
#variable que se usará para determinar el número de núcleos del PC.
NPROC=`nproc`
 
Crear un un archivo de texto en el directorio y pegar todo el contenido del script.

cd /opt/qt-beaglebone-black
touch crosscompile-Qt_5.5.1-beaglebone-black.sh
nano  crosscompile-Qt_5.5.1-beaglebone-black.sh

El siguiente script lo he modificado para realizar la instalación de una forma un poco diferente, el original se lo encuentra en el siguiente link http://guh.guru/downloads/scripts/crosscompile-Qt_5.2.1-beaglebone-black.sh.

#!/bin/sh -ex

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#                                                                         #
#  Copyright (C) 2015 Simon Stürz <simon.stuerz@guh.guru>                 #
#                                                                         #                                              #
#                                                                         #
#  This script is free software: you can redistribute it and/or modify    #
#  it under the terms of the GNU General Public License as published by   #
#  the Free Software Foundation, version 2 of the License.                #
#                                                                         #
#  This script is distributed in the hope that it will be useful,         #
#  but WITHOUT ANY WARRANTY; without even the implied warranty of         #
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the           #
#  GNU General Public License for more details.                           #
#                                                                         #
#  You should have received a copy of the GNU General Public License      #
#  along with this script. If not, see <http://www.gnu.org/licenses/>.    #
#                                                                         #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 

# the tutorial for this script can be found here: https://blog.guh.guru/tech/crosscompile-qt-5-2-1-for-bbb/

CURRENT_DIR=`pwd`
QT_SRCDIR="${CURRENT_DIR}/qt-everywhere-opensource-src-5.5.1"
QT_SRCFILE="${QT_SRCDIR}.tar.xz"
QT_URL="http://download.qt.io/archive/qt/5.5/5.5.1/single/qt-everywhere-opensource-src-5.5.1.tar.xz"
CC_DIR="${CURRENT_DIR}/gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux"
CC_URL="http://releases.linaro.org/14.04/components/toolchain/binaries/gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux.tar.xz"
CC_FILE="${CC_DIR}.tar.xz"
CC="${CC_DIR}/bin/arm-linux-gnueabihf-"
PREFIX="/usr/local/Qt-5.5.1"
ROOTFS_DIR="${CURRENT_DIR}/rootfs"
LOG_DIR="${CURRENT_DIR}/logfiles"
NPROC=`nproc`

###############################################################
#clean up
# delete old log files
if [ -d ${LOG_DIR} ]; then
        sudo rm -rf ${LOG_DIR}
        mkdir ${LOG_DIR}
fi

# create the logfiles folder
if [ ! -d ${LOG_DIR} ]; then
        mkdir ${LOG_DIR}
fi

# delete qt-build folder (old build stuff in it)
#if [ -d ${CURRENT_DIR}/qt-build ]; then
#        sudo rm -rf ${QT_SRCDIR}
#fi

# download qt source
if [ ! -f ${QT_SRCFILE} ]; then
 wget ${QT_URL}
fi

# extract qt source
if [ ! -d ${QT_SRCDIR} ]; then
 tar xf ${QT_SRCFILE}
fi

###############################################################
# download linaro cross compiler toolchain
if [ ! -f ${CC_FILE} ]; then
 wget -c ${CC_URL}
fi

# extract linaro cross compiler toolchain
if [ ! -d ${CC_DIR} ]; then
 tar xf ${CC_FILE}
fi

###############################################################
# extract the rootfs if it's missing
if [ ! -d ${ROOTFS_DIR} ]; then
        mkdir ${ROOTFS_DIR}
        sudo tar xf ${CURRENT_DIR}/rootfs.tar.bz2 -C ${ROOTFS_DIR}
fi

###############################################################
# download script to create relative symlinks of the libs with absolute symlinks in the rootfs...
# Thx to https://gitorious.org/cross-compile-tools/cross-compile-tools.git (I offer the download because gitorious.org will be off soon)
if [ ! -f ${CURRENT_DIR}/fixQualifiedLibraryPaths ]; then
        wget http://guh.guru/downloads/scripts/fixQualifiedLibraryPaths
 chmod +x fixQualifiedLibraryPaths
fi

# ...fix the symlinks
sudo ./fixQualifiedLibraryPaths ${ROOTFS_DIR} ${CC}g++

###############################################################
# create device...
cd ${QT_SRCDIR}/qtbase/mkspecs/devices/
cp -rv linux-beagleboard-g++ linux-beaglebone-g++
sed 's/softfp/hard/' <linux-beagleboard-g++/qmake.conf >linux-beaglebone-g++/qmake.conf

# ...and mkspec
cd ${QT_SRCDIR}/qtbase/mkspecs
cp -r linux-arm-gnueabi-g++/ linux-linaro-gnueabihf-g++/
TO_REPLACE="arm-linux-gnueabi-"
sed "s|${TO_REPLACE}|${CC}|g" <linux-arm-gnueabi-g++/qmake.conf >linux-linaro-gnueabihf-g++/qmake.conf


cd ${CURRENT_DIR}
mkdir -p qt-build
cd qt-build

###############################################################
# configure qtbase
if [ ! -d ${PREFIX} ]; then
 ../qt-everywhere-opensource-src-5.5.1/configure \
         -prefix ${PREFIX} \
         -sysroot ${ROOTFS_DIR} \
         -device linux-beaglebone-g++ \
  -xplatform linux-linaro-gnueabihf-g++ \
         -device-option CROSS_COMPILE=${CC} \
  -release \
         -silent \
                -qt-xcb \
         -opensource \
         -confirm-license \
         -continue \
         -v \
  -nomake examples \
  -nomake tests \
         2>&1 | tee -a ${LOG_DIR}/qtbase-configure-log.txt \


 ###############################################################
 # build qtbase
 make -j$NPROC 2>&1 | tee -a ${LOG_DIR}/qtbase-build-log.txt
 sudo make install
 cd ..
fi

# user our fresh compiled cross-qmake
QMAKE_CROSS="${ROOTFS_DIR}/${PREFIX}/bin/qmake"
cd ${CURRENT_DIR}/qt-build

###############################################################
# build qtgraphicaleffects
cd qtgraphicaleffects
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtgraphicaleffects-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtgraphicaleffects-make-log.txt
sudo make install
cd ..

###############################################################
# build qttools
cd qttools
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qttools-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qttools-make-log.txt
sudo make install
cd ..

###############################################################
# build qtscript
cd qtscript
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtscript-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtscript-make-log.txt
sudo make install
cd ..

###############################################################
# build qtserialport
cd qtserialport
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtserialport-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtserialport-make-log.txt
sudo make install
cd ..

###############################################################
# build qtsensors
cd qtsensors
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtsensors-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtsensors-make-log.txt
sudo make install
cd ..

###############################################################
# build qtimageformats
cd qtimageformats
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtimageformats-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtimageformats-make-log.txt
sudo make install
cd ..

###############################################################
# build qtsvg
cd qtsvg
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtsvg-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtsvg-make-log.txt
sudo make install
cd ..

###############################################################
# build qtactiveqt
cd qtactiveqt
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtactiveqt-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtactiveqt-make-log.txt
sudo make install
cd ..

###############################################################
# build qtxmlpatterns
cd qtxmlpatterns
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtxmlpatterns-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtxmlpatterns-make-log.txt
sudo make install
cd ..

###############################################################
# build qtdeclarative
cd qtdeclarative
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtdeclarative-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtdeclarative-make-log.txt
sudo make install
cd ..

###############################################################
# build qtquick1
cd qtquick1
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtquick1-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtquick1-make-log.txt
sudo make install
cd ..

###############################################################
# build qtquickcontrols
cd qtquickcontrols
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtquickcontrols-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtquickcontrols-make-log.txt
sudo make install
cd ..

###############################################################
# build qtmultimedia
cd qtmultimedia
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtmultimedia-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtmultimedia-make-log.txt
sudo make install
cd ..

###############################################################
# build qtconnectivity
cd qtconnectivity
${QMAKE_CROSS} 2>&1 | tee -a ${LOG_DIR}/qtconnectivity-qmake-log.txt
sudo make -j${NPROC} 2>&1 | tee -a ${LOG_DIR}/qtconnectivity-make-log.txt
sudo make install
cd ..

Luego de agregar el script guardamos con ctrl+o y salimos con ctrl+x.

Ahora le damos permisos de ejecución y lo corremos, tomar en cuenta que en algunos procesos hay que poner la contresaña para poder continuar.

chmod +x crosscompile-Qt_5.5.1-beaglebone-black.sh
./crosscompile-Qt_5.5.1-beaglebone-black.sh

Por último copiar la carpeta Qt-5.5.1 creada en  "/opt/qt-beaglebone-black/rootfs/usr/local/Qt-5.5.1" a la Beaglebone Black a "~/" y luego mover a "/usr/local". En windows se puede usar pscp y en linux scp, más información de como copiar archivos o carpeta en este link http://bbb-machinekit-lcd7.blogspot.com/2015/07/primeros-pasos-machinekit-beaglebone.html.

Opción 1: Indicar donde están las librerías de Qt_5.5.1 en el archivo "/etc/environment"

sudo mv ~/Qt_5.5.1 /usr/local
sudo nano /etc/environment
#Añadir lo siguiente
# QT libs configuration
LD_LIBRARY_PATH="/usr/local/Qt-5.5.1/lib"
#ctrl+o para guardar y ctrl+x para salir
sudo reboot
  
Opción 2: Indicar donde están las librerías de Qt_5.5.1 en el archivo "/etc/ld.so.conf.d/libc.conf"

sudo mv ~/Qt_5.5.1 /usr/local
sudo nano /etc/ld.so.conf.d/libc.conf
#Añadir lo siguiente
# QT libs configuration

/usr/local/Qt-5.5.1/lib
#ctrl+o para guardar y ctrl+x para salir
sudo ldconfig
 
Referencia: https://blog.guh.guru/tech/crosscompile-qt-5-2-1-for-bbb/#Set_up_the_cross_compile_environment_on_host.

Para ver los errores ir a la carpeta /opt/qt-beaglebone-black/logfiles.

Nota: Utilizando VMWARE con una configuración de 4 núcleos (CPU AMD A10-4600M), se demoro 1 hora y 20 minutos en compilar e instalar. Con mi PC con linux  (CPU Core I7) configuración de 8 núcleos se demoró 35 minutos en realizar todo el proceso.

En mi caso la primera opción me generó los siguientes errores:
info-errores-Machinekit
La segunda opción generó estos errores:
sysroot windows


2 comentarios:

  1. Hola, hice el procedimiento completo, pero a la hora de poner run al ejemplo de este tutorial me aparece este error

    make: *** [ui_prueba1.h] Error -1073741515
    21:48:37: The process "C:\SysGCC\Beaglebone\bin\make.exe" exited with code 2.
    Error while building/deploying project prueba (kit: BBB-QT5)
    When executing step 'Make'

    sabes a que se debe?

    saludos

    ResponderEliminar
  2. Hola, eso ocurre porque no esta detectando las librerías. No está bien hecho el paso donde se enlazan las librerías.
    En mi caso la dirección es cd /c/SysGCC/BeagleDebian/arm-linux-gnueabihf/sysroot/. Este parece ser lo que está mal ya que si se usó este comando mi carpeta se llama "BeagleDebian" la suya es Beaglebone.

    ResponderEliminar