1- Utiles necesarios:Smartty: programa para comunicar por SSH con la RPI/BBB, también instala X11 para poder ejecutar aplicaciones gráficas:
http://smartty.sysprogs.com/download/SmarTTY-1.0.msiToolchain para Raspberry, incluye compilador cruzado C++:
http://gnutoolchains.com/raspberry/raspberry-gcc4.6.3.exeToolchain para Beaglebone, incluye compilador cruzado C++:
http://gnutoolchains.com/beaglebone/beaglebone-gcc4.7.3.exeQtCrossTool: utilidad para sincronizar todas las librerías y cabeceras entre RPI/BBB y el PC.
http://visualgdb.com/tools/QtCrossTool/QtCrossTool.zipQt Creator para Windows, incluye IDE y QtDesigner para formularios;
http://download.qt-project.org/official_releases/qtcreator/2.8/2.8.1/qt-creator-windows-opensource-2.8.1.exeQt Librerias 4.8.5 para PC: http://download.qt-project.org/official_releases/qt/4.8/4.8.5/qt-win-opensource-4.8.5-mingw.exeCompilador C++ MinGW v4.4.0 para PC; https://docs.google.com/uc?export=download&confirm=6Wf6&id=0B4D8x6CJEmtuczdiQklwMEs4RUUBasicQtProject.zip 3 KB: Proyecto básico de pruebas para QT
https://mega.co.nz/#!5EMyAZzY!SpvrbBS9-kFeOLKsx8j4_X-Al7NDuFmKcFVY0b6iJC42- Instalación programas PCInstalar
Smartty, Qt Creator, MinGW y librerias Qt 4.8.5, por ese orden, con todos los valores por omisión.
La RPI o BBB, debe de estar conectada al PC por Ethernet, con un cable RJ45 y con acceso a internet.
3- Configuración de SmarTTYArrancar Smartty, pulsar "
Setup a new connection":
Nos saldrá está pantalla, que tenemos que rellenar con los datos de IP, usuario y contraseña de nuestra placa RPI o BBB:
Estos son los datos para la Raspberry, yo he puesto como usuario root porque lo tengo creado, o podeis usar el usuario
pi y contraseña
raspberry que vienen cargados en la placa:
Y estos son los datos para la Beaglebone black, el usuario
root viene con la contraseña en blanco:
Al pulsar
Connect, se creará la cuenta, para poder utilizarla posteriormente sin tener que introducir de nuevo los datos, y se conectará a la placa, saldrá una pantalla pidiendo el password del usuario que hayamos puesto, en mi caso ambas con el usuario "root".
Si todo va bien, se abrirá la pantalla de sesion de Smartty, con la linea de comandos de sistema de la RPI o la BBB, es como si estuviésemos en la RPI o BBB, pero desde el PC. Como Smartty instalá también un servidor X11, podemos arrancar un entorno gráfico, en el caso de la RPI con startx o startlxde y en el caso de la BBB con nautilus. Podemos cerrar Smartty, de momento no lo necesitamos, solo hemos configurado las cuentas para acceder por SSH a las placas cuando haga falta.
4- Instalación librerías QT4 en RPI/BBB.Ahora vamos a instalar en la Raspberry o la Beaglebone las librerías QT4, podemos hacerlo desde la ventana que hemos abierto con Smartty o desde la propia placa, por comodidad es mejor hacerlo todo desde el PC con Smartty.
Para instalar Qt4 en la Raspberry, teclearemos los siguiente comandos:
sudo apt-get update
sudo apt-get install libqt4-dev
Y estos para la Beaglebone:
opkg update
opkg install qt4-embedded --force-depends
opkg install libqtcoree-dev libqtguie-dev
5- Instalación Toolchain RPI/BBB.El siguiente paso es instalar el Toolchain para RPI o BBB, en el PC. El Toolchain incluye el compilador C++ para poder hacer compilación cruzada, en este caso desde Windows/X86 a Linux/ARM. Arrancamos el instalador de los toolchain que hemos descargado previamente e instalamos para RPI y/o BBB:
6- Sincronización librerías/cabeceras RPI/BBB - PC.Arrancamos QtCrossTool para sincronizar librerias y cabeceras entre RPI/BBB y el PC. Nos saldrá esta pantalla, que tenemos que rellenar con los datos correspondientes, según sea para RPI o BBB:
Para RPI
Para BBBB:
Pulsamos "
Select" y seleccionamos la cuenta que hemos creado antes en Smartty para la tarjeta, lo normal será la IP 192.168.1.3 para RPI y la 192.168.1.4 para la BBB:
Una vez se haya conectado, empezará a descargar desde RPI o BBB al PC, todas las librerías y cabeceras, para sincronizar ambos con las mismas versiones, imprescindible para que la compilación cruzada funcione bien:
7- Configuración QT-Creator.Arrancamos QT-Creator en el PC, y seleccionamos
Tools > Options.
Seleccionamos
Devices > Add > Generic Linux Device, y pulsamos Start Wizard.
Rellenamos los datos para nuestra tarjeta RPI o BBB, pulsamos Next y en la siguiente pantalla Finish:
Qt-Creator se intentará conectar con la tarjeta, para verificar la conexión, si todo va bien, saldrá esta pantalla. Pulsamos close y repetimos la operación si es necesario para añadir otra tarjeta, en mi caso tengo la Raspberry y también la Beaglebone black:
Ahora seleccionamos
Build & Run > Compilers, para añadir el compilador cruzado C++, y pulsamos
Add > GCC.
Rellenamos los datos, estos son para Raspberry:
Y estos para Beaglebone:
Seleccionamos
QT Versions, y pulsamos Add (para cada tarjeta RPI o BBB), se abrirá un ventana para que seleccionemos la ubicación de
qmake.exe, para Raspberry lo tendremos en
C:\SysGCC\Raspberry\bin y para Beaglebone lo tendremos en
C:\SysGCC\beaglebone\bin.
Ahora vamos a Kits y pulsamos
Add. Rellenamos los datos, los de está imagen son para RPI:
Y estos para Beaglebone:
Pulsamos
Apply y OK, para que se guarde todo.
8- Pruebas primer proyecto, configuración.Llegó el momento de probar, crear un proyecto de pruebas, compilarlo, subirlo a la placa y ejecutarlo.
Para hacer la prueba, podeis bajaros este pequeño ejemplo, saca una pantalla principal con un botón que al pulsarlo abre otra ventana con el "Hello World".
BasicQtProject.zip 3 KB: https://mega.co.nz/#!5EMyAZzY!SpvrbBS9-kFeOLKsx8j4_X-Al7NDuFmKcFVY0b6iJC4Descomprimimos y pulsamos sobre el archivo
BasicQtProject.pro, el proyecto se abrirá en Qt-Creator.
Pulsamos
Projects, veremos que tenemos un
qmake y un
make creados automáticamente por Qt, como vemos en esta imagen, no hace falta tocar nada si previamente configuramos correctamente el Kit. En la parte superior podemos ver el Kit seleccionado, en esta imagen el kit Qt 4.8.5 Raspberry para las Raspberry, si estais trabajando con la Beaglebone, podeis cambiar el kit pulsando sobre
Add kit y seleccionando el correcto, el otro se puede quitar pasando el ratón por encima y seleccionando
Remove kit. Aquí ya no hay que hacer nada, solo comprobar que los datos son correctos (qmake, make y kit).
Ahora vamos a incluir unos parámetros en el proyecto, para que tras compilar, simplemente pulsando sobre un icono (
triángulo verde en la esquina inferior izquierda de Qt), podamos subir el objeto compilado, automáticamente a la tarjeta, además el programa se ejecutará en la RPI o la BBB, mostrando la salida gráfica en la pantalla conectada a la RPI/BBB. Hay otro icono con un triángulo verde y un círculo gris, que sirve para lanzar el Debug, en este segundo caso, Qt sube el programa, lo ejecuta y abre la ventana de Debug.
Los parámetros que hay que añadir, los tenemos que poner en el fichero .pro, en este ejemplo el archivo del proyecto se llama
BasicQtProject.pro, lo editamos y ponemos:
target.path = /usr/PRUEBAS
INSTALLS = targetEn este ejemplo, el binario ejecutable que compilemos, Qt lo subirá al directorio
/usr/PRUEBAS de la RPI/BBB, el directorio
PRUEBAS lo creé previamente en la Raspberry, colgando del directorio /usr. Vosotros poner el directorio que querais en
target.path para que Qt suba el binario una vez compilado, pulsando Run (Ctrl+R) para subir y ejecutar o Star Debuging (F5) para subir y ejecutar con Debug. También podeis
pulsar directamente los iconos Ya estamos en disposición de compilar, para ello pulsaremos sobre el
icono en forma de martillo que hay en la esquina inferior izquierda, si seleccionamos
Compile Output (opción 4 al pie de Qt Creator), veremos todos los mensajes que va lanzando Qt sobre el proceso de la compilación y lincado, si todo va bien, nos mostrará un mensaje, de lo contrario nos indicará los errores para corregirlos.
Si la compilación terminó con éxito, ya tendremos el ejecutable (binario) listo para subirlo a la tarjeta RPI o BBB.
Ahora podeis subir y ejecutar el programa a la RPI o BBB, pulsando
Run (Ctrl+R) para subir y ejecutar o
Star Debuging (F5) para subir y ejecutar con Debug. También podeis pulsar directamente los iconos que indico en esta imagen. El programa subirá a la placa, se ejecutará y sacará la salida gráfica por la pantalla conectada a la RPI o BBB, si hemos arrancado el Debug, Qt pasará a la pantalla correspondiente, donde podemos marcar Breakpoints, ver registros, valores de campos, ejecutar paso a paso, etc... ¡¡¡ una maravilla ¡¡¡.
Pantalla de una sesión de Debug.
En esta imagen, el monitor de la derecha con Qt-Creator rodando en un PC con Windows XP SP3, el monitor pequeño de la izquierda conectado a la Raspberry por HDMI. Tras compilar en Qt y pulsar el icono de Ejecución o ejecución con Debug, el programa se traspasa automáticamente y se ejecuta en la RPI, con la salida gráfica en el monitor de la RPI. Me ha resultado curioso, porque con VisualGBD y Visual Studio en el PC, o ejecutando el programa desde Smartty en el PC, aunque el programa también se ejecuta en la RPI, la salida gráfica es por la pantalla del PC.
Si quereis subir el ejecutable a mano por algún motivo (
poco recomendable e incómodo), podeis hacer uso de Smartty, util que además nos permitirá también lanzar la ejecución del programa desde el PC (pero rodando en la RPI/BBB), también podríamos ejecutarlo directamente desde la RPI o la BBB en la administración de archivos o en la linea de comandos, pero en este caso por comodidad usaremos Smartty. Arrancamos Smartty, y seleccionamos la cuenta de la tarjeta, que ya creamos anteriormente:
En mi caso he creado un directorio llamado
PRUEBAS, que cuelga del directorio
/usr en la Raspberry. Podeis ir al directorio /usr tecleando
cd /usr, y para crear un subdirectorio podeis usar el comando
mkdir, en este caso una vez en /usr tecleamos
mkdir PRUEBAS para crear el nuevo directorio. Desde /usr para entrar en el nuevo directorio PRUEBAS, tecleamos
cd PRUEBAS. Una vez dentro de nuestro directorio de pruebas, vamos a subir el ejecutable que acabamos de compilar, para eso Smartty tiene una opción que permite subir y bajar tanto ficheros como directorios completos, asi que pulsamos la opción
SCP > Upload a file:
Nos saldrá una ventana que nos pide el archivo a subir, y la ubicación de destino, pulsamos sobre el icono de
local file name y seleccionamos el binario que acabamos de compilar, y en el directorio de destino seleccionamos el que queramos, en mi caso
/usr/PRUEBAS, que es el directorio que hemos creado en el paso anterior para subir este ejemplo. Pulsamos
Upload y el fichero subira desde el PC a la tarjeta RPI o BBB.
Ahora que ya tenenos el ejecutable en la tarjeta, en este ejemplo en una Raspberry, vamos a ejecutar el programa para ver que funciona. Antes de ejecutarlo tenemos que cambiar los permisos del archivo para que sea ejecutable. Para eso desde la ventana de Smartty teclearemos
chmod a+x ./BasicQtProject. Ya podemos ejecutar el programa tecleando
./BasicQtProjectY en esta otra foto, ejecutando el programa directamente desde la RPI, como monitor uso un pequeño TV LED de 13 pulgadas, por lo que tengo que configurar la resolución de la Raspberry a VGA para que se vea con cierta comodidad, al final el resultado es el mismo, pero usando Smartty desde el PC, resulta más cómodo:
9- GlosarioRPI = Raspberry pi
BBB = Beaglebone Black
10- Enlaces de interésSysprogs:
http://visualgdb.com/tools/QtCrossTool/Binutils:
http://www.gnu.org/software/binutils/GNU GCC ARM:
https://launchpad.net/gcc-arm-embedded Linaro Toolchain for ARM:
https://launchpad.net/linaro-toolchain-binariesMake:
http://gnuwin32.sourceforge.net/packages/make.htmQmake:
http://qt-project.org/doc/qt-4.8/qmake-manual.htmlQtProject:
http://qt-project.org/Raspberry:
http://www.raspberrypi.org/Beaglebone:
http://beagleboard.org/products/beaglebone%20blackRevista Magpi:
http://www.themagpi.com/11- Temas pendientesLa configuración para la Beaglebone requiere unos pequeños arreglos en la configuración, para que no de error la compilación, si tengo un rato los documento, aunque también se pueden ver en este enlace de Sysprogs (pasos 10 a 16):
http://visualgdb.com/tutorials/beaglebone/qt-embedded/Y con esto y un bizcocho, se acabó.