Google+ Room Technology: qt
Mostrando entradas con la etiqueta qt. Mostrar todas las entradas
Mostrando entradas con la etiqueta qt. Mostrar todas las entradas

martes, 25 de junio de 2013

Mini2440: Aplicación de comunicación Serial usando QtCretor.

Unas de las principales razones por las que los sistemas embebidos son usados con mayor frecuencia es la posibilidad de usar interfaces de comunicación que les permitan interactuar con diferentes dispositivos. La interfaz mas usada en el mundo de la electrónica es la famosa comunicación serial. En el Mini2440 tenemos a nuestra disposición 4 puertos seriales: 1 RS-232 y 3 TTL. 

Ubicación de los puertos en el Mini2440. 

Durante mucho tiempo trate de usar el puerto serial en el Mini2440. En Windows CE usar el Serial Port   no es muy problemático pero es todo lo contrario en Linux QTopia. Después de varios intentos, la mayoría largos y fallidos, pude realizar una aplicación de Tx y Rx de datos entre el Mini2440 y la PC.  No me considero en lo mas mínimo experto en programación así que cualquier metida de pata de antemano disculpas.

¿De que va la aplicación?

La aplicación es simple: Transmisión/Recepción de datos (específicamente cadenas de texto) entre el Mini2440 y una computadora. Aquí una imagen de la aplicación:

Windows Form de la Aplicación del Mini2440. 

Tendremos tres botones: Para abrir el Puerto Serial, para cerrar el Puerto Serial y para escribir una cadena de caracteres en el Puerto Serial hacia la computadora
Un TextEdit multilínea donde se imprimirá los datos recibidos desde la computadora en el Mini2440. 

¿Que Necesito?
  • El Mini2440 debe estar ya preparado para correr aplicaciones hechas en Qt Creator, si no es así te recomiendo que leas este post.
  • Tener Qt Creator configurado con el compilador cruzado del Mini2440, si no es así te recomiendo leer este post.
  • Un cable USB-SERIAL para la computadora.
  • Los pines de los puertos seriales de ambos dispositivos deben de estar de la siguiente manera: TX con RX, RX con TX y ambas GND juntas. 
Consideraciones Generales importantes
  1. Tienes que tener un cierto grado de conocimiento de C++, no te pido que seas un máster en programación, solo los conocimientos suficientes.
  2. El uso del Puerto Serial no debe ser nada nuevo para ti, es decir debes saber que es el BaudRate, Bit de paridad, Bit de parada, RS-232, etc. 
  3. Haber hecho por lo menos una aplicación para el Mini2440 y comprobar su funcionamiento en el Mini2440. 
  4. Este post no lo considero una Guía paso a paso, por favor como mencione anteriormente debes manejarte fluidamente en Qt Creator. 

Descargar Librerías. 

En C++ las librerías son colecciones de clases y funciones escritas en un lenguaje que el núcleo del SO pueda entender.  Para realizar la comunicación serial para el Mini2440 se hace el uso de librerías que me permitan usar de manera eficiente el puerto físico. En el Internet hay muchas librerías para tal fin, yo use una en particular que para mi aplicación en especifico me ayudo de manera satisfactoria. 
Tomar en cuenta que esta no es la mejor librería que pueda haber, pero en esta aplicación trabaja perfectamente.  Descargar: Link

Creando la Aplicación: Incluyendo librerías en el Proyecto. 

Una vez descargadas las librerías descomprimimos los archivos y los copiamos a todos dentro de la carpeta raíz donde esta el proyecto creado en Qt Creator. Los archivos .h son los headers (encabezados) y los archivos .cpp son los sources (fuentes).

Estas librerías las tendremos que agregar al proyecto para ello vamos hacer lo siguiente: Hacemos clic derecho sobre la carpeta del proyecto y elijemos "Agregar archivos existentes".

Hacemos Clic derecho y elijemos "Agregar Archivos existentes.  


Los archivos en total son 8: PortListener.cpp, PortListener.h, posix_qextserialport.cpp, qextserialenumerator.h, qextserialenumerator_unix.cpp, qextserialport.cpp, qextserialport.h y qextserialport_global.h. Todos ellos los añadimos al proyecto.  

Una vez hecho esto darse cuenta como los archivos se agruparon.   

El archivo .pro también tiene que tener las siguientes modificaciones.   

Le damos al proyecto un Rebuild All y después un "Ejecutar" (por el momento no cambiamos al compilador del Mini2440). No tendría que haber problemas en este punto. 


Creando la Aplicación: Slots, variables, controles, etc. 

Le damos las siguientes dimensiones al mainwindow.iu (Height>>249;Width>>392).
Añadimos los tres botones y el EditText. Hay que declarar los slots privados correspondiente a cada uno de los botones.

En el mainwindow.cpp añadimos lo siguiente:

private:
    Ui::MainWindow *ui;
    QextSerialPort *port; //esta añadiremos, asignación de un nombre para hacer uso de las características del puerto serial. 


Ademas debemos incluir las librerías del Serial Port  de la siguiente manera:

#include "qextserialport.h" //esto va en el mainwindow.h
#include <qextserialenumerator.h>//esto va en el mainwindow.cpp
#include "qextserialport.h"            //esto va en el mainwindow.cpp

En el mainwindow.cpp debemos declarar el nombre del Serial Port que sera usado:

#define port_name "/dev/ttySAC0" //nombre del puerto del Mini2440 (COM1)

El código del botón para abrir el Puerto Serial se vería así:

void MainWindow::clic_open_port()
{
    this->port = new QextSerialPort(port_name, QextSerialPort::EventDriven);
    port->flush();
    port->setBaudRate(BAUD115200);//115200 de BAUDRATE
    port->setFlowControl(FLOW_OFF);//Sin Control de Flujo
    port->setParity(PAR_NONE);//Sin Paridad
    port->setDataBits(DATA_8);//8 bits de datos
    port->setStopBits(STOP_1);//1 bit de parada

    if (port->open(QIODevice::ReadWrite) == true)
    {
        connect(port,SIGNAL(readyRead()),this,SLOT(onReadyRead()));
        ui->button_close_port->setEnabled(true);
        ui->button_write_data->setEnabled(true);
        ui->button_open_port->setEnabled(false);
    }
    else
    {
        QMessageBox::information(this, "ERROR DE SISTEMA", "Se intenta abrir un puerto inexistente");
    }
}

El código del botón para cerrar el Puerto Serial:

void MainWindow::clic_close_port()
{
    port->close();//cerramos el puerto
    ui->button_close_port->setEnabled(false);
    ui->button_write_data->setEnabled(false);
    ui->button_open_port->setEnabled(true);
}

El código del botón para escribir en el Serial Port una cadena de caracteres ya definida seria este:

void MainWindow::clic_write_port()/
{
    port->write("Hola Mini2440. ");
}

En el caso de la recepción de los datos debemos enlazar el Signal correspondiente con un Slot, primero declaramos un Slot privado en el mainwindow.h.

private slots:
    void clic_open_port();//slot correspondiente al boton open_port
    void clic_close_port();//slot correspondiente al boton close_port
    void clic_write_port();//slot correspondiente al boton write_port
    void onReadyRead();//slot correspondiente al evento de RX de bits del puerto

Seguido desarrollamos el código correspondiente al slot:

void MainWindow::onReadyRead()
{
    SleeperThread::msleep(20);
    QByteArray bytes=port->readAll();
    ui->textEdit->append(bytes);
}

Algo adicional es poder deshabilitar los botones "CLOSE PORT" y "WRITE DATA" si primero no se abrió el Serial Port de manera correcta. El código estaría dentro del método de inicialización del formulario:

    ui->button_close_port->setEnabled(false);
    ui->button_write_data->setEnabled(false);

Esto es todo lo necesario para poder ejecutar la aplicación, si tienen algún error durante la compilación o ejecución traten de revisar de nuevo el post.  Una vez compilada la aplicación en la PC es hora de hacer lo mismo pero con el compilador del Mini2440, recuerda que debe devolverte el famoso 255 para asegurarnos que todo esta bien. Copiamos al ejecutable a una SD o memoria USB , la pasamos al Mini2440 (a través de comandos, recomiendo usar el programa PUTTY) y ejecutamos la aplicación.  

Si el código les da problemas les dejare dos links con los proyectos de Qt Creator. En ellos estará la aplicación desarrollada tanto para PC como para el Mini2440, estas aplicaciones están trabajando perfectamente y no he tenido problemas.
Descargar: Link1 Link2

Para finalizar en la PC tienen que tener un programa que les permita usar en Puerto Serial para enviar cadena de caracteres y poder recibir de la misma manera caracteres. 

Espero que esta nuevo post les sirva (a mi este aplicación me saco de grandes apuros). No es una aplicación que lo tiene de todo y no solucionara todos los problemas que tengan, pero las librerías están disponibles, solo hay que tener la suficiente visión para aprovecharla al 100%.  Traten de experimentar es mi única recomendación. Modifiquen el código, añadan mas código, eliminen código tal vez que este inservible y  de esta manera estaran aprendiendo a usar el Serial Port. 
¡Suerte en sus proyectos!



lunes, 27 de mayo de 2013

Primeros pasos con QT Creator para el Mini2440.

Hola a todos!!!!! Después de casi un mes completo por fin me he buscado un espacio de mi tiempo y  con ello poder hacer este nuevo post en el que tratare de intentar dar una guía de como preparar el IDE QT Creator con el compilador para el Mini2440 y así poder preparar una aplicación que se debería ejecutar sin problemas en el sistema embebido. 

Empezando, lógicamente deberíamos tener alguna distribución de Linux, en mi caso tengo Ubuntu 12.04 LTS y no he tenido hasta el momento ningún problema.
Ademas deberiamos leer antes el post sobre como instalar el entorno del compilador. 

Nota: Antes que nada si estas interesado en desarrollar aplicaciones para el Mini2440 con el IDE QT Creator, tienes que saber al menos lo básico sobre programación en lenguaje C++ y saber desenvolverte de manera fluida en el QT Creator. Esto no es dificil si le pones tiempo y sobre todo paciencia.

  • Descargamos el IDE QT Creator: El IDE esta disponible en el Centro de Software de Ubuntu y se lo puede descargar libremente. ¡Pero espera un momento! Te menciono que en mi caso particular la versión del IDE que esta en disponible aquí no me funciono cuando intente configurar el compilador cruzado del Mini2440. Espero que sea solo un problema mio y a los que intente seguir los pasos en este post no tengan ningun problema. Pero si tienes inconvenientes descarga el "qt-sdk-linux-x86-opensource-2009.05.bin" del siguiente enlace (FTP). Este FTP tiene varios archivos selecciona el que te mencione y espera que lo descargue por completo. Espero poder en un tiempo mas adelante subir el archivo que tengo y ponerlo a disposición de la comunidad. 
  • Instalación del IDE QT Creator: "ESTE PASO SEGUIR SOLO SI USAS EL ARCHIVO DEL SERVIDOR FTP". Una vez descargado el archivo le damos todos los permisos desde el terminal con:

$chmod 777 qt-sdk-linux-x86-opensource-2009.05.bin

Le damos ejecución al archivo de instalación con:

$./qt-sdk-linux-x86-opensource-2009.05.bin 

Seguimos los siguientes pasos:



*Aquí cambiamos el directorio por defecto.

*Lo instalamos en el directorio /usr/local. 


*La instalación comenzara de manera progresiva. Tardara un tiempo considerable. 

  • Configuración del Compilador cruzado: Una vez abierto el IDE nos vamos a Herramientas>>Opciones. Una vez ahí en la pestaña de (+)  hacemos clic y ponemos el nombre de la versión en este caso Mini2440 y en la parte del directorio ubicamos este archivo: /usr/local/QT/bin/Qmake. En el botón Reconstruir hacemos clic y después de algún tiempo deberá aparecer un tick de visto en verde. Ponemos Aplicar y Aceptar.






  • Creación de un Proyecto: Seguimos estos pasos Archivo>>New File or Project. Las imágenes muestran que hacer después. 
* Elegimos "Aplicación Qt4 con GUI"  

* Nombre de la aplicación y directorio respectivo. 





  • Compilando el código: Como es una aplicación sencilla solo intentaremos solo compilar el GUI tal como nos da el IDE por defecto. Hacemos lo siguiente:
Construir>>Construir Todo
Construir>>Ejecutar

La aplicación se debería ejecutar y mostrarse una ventana vacía. En la salida de la aplicación debería haber algo similar a esto: "App_Mini2440 finalizo retornando 0"


*Salida de la aplicación. 


La linea que expresa que se esta retornando 0 nos es mas que un identificativo de que le aplicación se acaba de cerrar. Para poder compilar para el Mini2440 debemos elegir dentro del proyecto el compilador correspondiente:

*En la pestaña llamada Proyecto hay una opción llamada "Ajustes de Construcción".  En la parte de "General" elegimos "Show Details"

*En "Version de QT" seleccionamos Mini2440. 

*Le damos un "Rebuid All" al proyecto y después seleccionamos "Importar adjuste existente".

*Tener en cuenta como ha cambiado el "QMake" en la parte "Etapas de la construcción"

*Si todo esta bien cuando ejecutemos la aplicacion, se retornara un 255. 


Como ahora se cambio el compilador, al momento de ejecutar la aplicación no se muestra nada, esto por que cambiamos el compilador a otra diferente arquitectura que no corresponde a la PC. Pero en la salida de la aplicación debería salir: Retornando 255, lo que significa que todo esta bien. 

El archivo ejecutable final esta en la carpeta que configuramos inicialmente esto lo pasamos en una SD Card y desde un terminal conectado al Mini2440 lo ejecutamos asi: 

$./App_Mini2440 -qws

La aplicación deberá correr sin problemas en el Mini2440. Una de las razones principales por las que me decidí a investigar dentro del campo Linux y de QT Creator fue poder usar el Serial Port. Después de tanto tiempo he podido desarrollar una aplicación que para mis fines es mas que suficiente. Espero poder tener algo de tiempo en un futuro y poder hablarles sobre ello de manera mas especifica. 

viernes, 26 de abril de 2013

Mini2440: Compilando el entorno de Qt 4.6.2 para QT CREATOR.





Ya que hemos tenido la oportunidad de poder instalar en el Mini2440 tres SO diferentes podremos por fin desarrollar las aplicaciones que mas nos interesen. En este blog tratare de explicar la instalación de las diferentes herramientas que debería tener el entorno de Ubuntu, en mi caso particular 12.04 LTS, para que compile programas que puedan ejecutarte en Qtopia dentro del Mini2440.

Como es lo mas lógico deberán de disponer de una PC con Ubuntu (yo tengo 12.04 LTS y lo comandos funcionan a la perfección), y saber manejarse con fluidez en la shell de Linux por que todo sera hecho por comandos.

Descargar el Qt Opensource 4.6.2 Aqui

-Instalando las librerías necesarias.
Es necesario disponer de algunas herramientas para realizar la correcta instalación del entorno del compilador. Por favor instalar esto por medio de la terminal:

                  $apt-get install git
                  $apt-get install libtool
                  $apt-get install autoconf
                  $apt-get install g++
                  $apt-get install zlib-bin
                  $apt-get install zlib1g-dev
                  $apt-get install zlib1g


*Git: Software de control de revisiones de código abierto, descarga de repositorios.

*Libtool: Compartir bibliotecas entre diferentes compiladores. 
*autoconf: Es una herramienta para crear scripts de configuración para la construcción, instalación y empaquetado de software en los sistemas informáticos.
*g++: GNU Compiler Collection (GCC) es un sistema compilador producido por el proyecto GNU  de apoyo a varios lenguajes de programación entre ellos c++=g++.
*zlib: Biblioteca de software que se utiliza para la compresión de datos

-Instalando y Compilacion de Tslib.
Tslib es una capa de abstracción para los eventos en el panel de la pantalla táctil , así como una pila de filtros para la manipulación de esos eventos. Se utiliza generalmente en dispositivos embebidos para proporcionar una interfaz de usuario. Ingresar lo siguiente por terminal

                    $cd /usr/local/
                    $git clone http://github.com/kergoth/tslib.git
                    $export PATH=/usr/local/arm/4.3.2/bin/:$PATH  
                    $export CROSS_COMPILE=arm-none-linux-gnueabi-
                    $export CC=${CROSS_COMPILE}gcc
                    $export CFLAGS=-march=armv4t
                    $export CXX=${CROSS_COMPILE}"g++"   
                    $export AR=${CROSS_COMPILE}"ar" 
                    $export AS=${CROSS_COMPILE}"as"
                    $export RANLIB=${CROSS_COMPILE}"ranlib"
                    $export LD=${CROSS_COMPILE}"ld"
                    $export STRIP=${CROSS_COMPILE}"strip"
                    $cd /usr/local/tslib      
                    $./autogen-clean.sh
                    $./autocgen.sh
                    $./configure --host=arm-linux --prefix=/home/tslib --enable-shared=yes --enable-static=yes
                    $make
                    $make install

Tener en cuenta que la variable $PATH hace referencia al compilador cruzado que deberias tener instalado, si no es asi te recomieno revisar este post.
Si todo salio bien deberias tener algo similar a esto en el directorio /home/tslib


-Compilacion de Qt 4.6.2 
Nos dirigimos a la carpeta donde descargamos el compilador Qt y procedemos a realizar los siguientes pasos:


                   $cp /home/ediie/Downloads/qt-everywhere-opensource-src-4.6.2.tar.gz /usr/local/ 
                   $cd /usr/local/
                   $tar -zxvf qt-everywhere-opensource-src-4.6.2.tar.gz
                   $cd qt-everywhere-opensource-src-4.6.2
                   $cd mkspecs/common/
                   $geany g++.conf


Se nos abrirá un documento (Geany es editor de texto) dentro de este realizar los siguientes cambios y salvar los mismos.

 Texto Original:+= -O2

Texto Modificado: -O0


Guardado los cambios y cerrado el documento seguimos en la terminal.

                   $cd /usr/local/qt-everywhere-opensource-src-4.6.2/mkspecs/qws/linux-arm-g++/
                   $geany qmake.conf

Se nos abrirá un documento (Geany es editor de texto) dentro de este realizar los siguientes cambios y salvar los mismos (borramos todo dentro del documento). Código a pegar dentro del documento:

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

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


include(../../common/g++.conf)
include(../../common/linux.conf)
include(../../common/qws.conf)


# modifications to g++.conf
QMAKE_CC                = /usr/local/arm/4.3.2/bin/arm-none-linux-gnueabi-gcc -msoft-float -D__GCC_FLOAT_NOT_NEEDED -march=armv4t -mtune=arm920t -O0 -lts
QMAKE_CXX               = /usr/local/arm/4.3.2/bin/arm-none-linux-gnueabi-g++ -msoft-float -D__GCC_FLOAT_NOT_NEEDED -march=armv4t -mtune=arm920t -O0 -lts
QMAKE_LINK              = /usr/local/arm/4.3.2/bin/arm-none-linux-gnueabi-g++ -msoft-float -D__GCC_FLOAT_NOT_NEEDED -march=armv4t -mtune=arm920t -O0 -lts
QMAKE_LINK_SHLIB        = /usr/local/arm/4.3.2/bin/arm-none-linux-gnueabi-g++ -msoft-float -D__GCC_FLOAT_NOT_NEEDED -march=armv4t -mtune=arm920t -O0 -lts


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


QMAKE_INCDIR     += /home/tslib/include/
QMAKE_LIBDIR  += /home/tslib/lib/


QMAKE_CFLAGS_RELEASE   += -march=armv4 -mtune=arm920t
QMAKE_CFLAGS_DEBUG   += -march=armv4t -mtune=arm920t
QMAKE_CFLAGS_MT   += -march=armv4t -mtune=arm920t
QMAKE_CFLAGS_MT_DBG   += -march=armv4t -mtune=arm920t
QMAKE_CFLAGS_MT_DLL   += -march=armv4t -mtune=arm920t
QMAKE_CFLAGS_MT_DLLDBG   += -march=armv4t -mtune=arm920t
QMAKE_CFLAGS_SHLIB   += -march=armv4t -mtune=arm920t
QMAKE_CFLAGS_THREAD   += -march=armv4t -mtune=arm920t
QMAKE_CFLAGS_WARN_OFF   += -march=armv4t -mtune=arm920t
QMAKE_CFLAGS_WARN_ON   += -march=armv4t -mtune=arm920t


QMAKE_CXXFLAGS_DEBUG   += -march=armv4t -mtune=arm920t
QMAKE_CXXFLAGS_MT   += -march=armv4t -mtune=arm920t
QMAKE_CXXFLAGS_MT_DBG   += -march=armv4t -mtune=arm920t
QMAKE_CXXFLAGS_MT_DLL   += -march=armv4t -mtune=arm920t
QMAKE_CXXFLAGS_MT_DLLDBG  += -march=armv4t -mtune=arm920t
QMAKE_CXXFLAGS_RELEASE   += -march=armv4t -mtune=arm920t
QMAKE_CXXFLAGS_SHLIB   += -march=armv4t -mtune=arm920t
QMAKE_CXXFLAGS_THREAD   += -march=armv4t -mtune=arm920t
QMAKE_CXXFLAGS_WARN_OFF  += -march=armv4t -mtune=arm920t
QMAKE_CXXFLAGS_WARN_ON   += -march=armv4t -mtune=arm920t


load(qt_config)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Texto original.

Texto modificado.

Guardado los cambios y cerrado el documento seguimos en la terminal.

                $mkdir /usr/local/Qt
                $cd /usr/local/qt-everywhere-opensource-src-4.6.2
                $./configure -embedded arm -xplatform qws/linux-arm-g++ -prefix /usr/local/Qt -qt-mouse-tslib -little-endian -no-webkit -no-qt3support -no-cups -no-largefile -optimized-qmake -no-openssl -nomake tools -qt-sql-sqlite -no-3dnow -system-zlib -qt-gif -qt-libtiff -qt-libpng -qt-libmng -qt-libjpeg -no-opengl -gtkstyle -no-openvg -no-xshape -no-xsync -no-xrandr -qt-freetype -qt-gfx-linuxfb -qt-kbd-tty -qt-kbd-linuxinput -qt-mouse-tslib -qt-mouse-linuxinput

En la primera pregunta respondemos con 'o' para elegir la version open source y en la segunda con 'yes'.




Esperamos por que tardara aproximadamente 5 minutos. Después seguimos en la terminal.

                  $make

Una vez puesto el 'make' tendremos que sacar toda esa paciencia escondida, con solo comentarles que mi portátil una DELL con procesador Intel i7 a 2.2GHz y 6GB de RAM tardo 18 minutos exactos. Después solo falta la instalación del compilador.

                  $make install

 Si todo salio bien tendremos los resultados en el directorio '/usr/local/Qt'.

-Instalación de TSLIB en el Mini2440.

Para esto necesitaremos una SDCARD y programa de terminal para la comunicación serial entre la PC y el Mini2440. En resumen las librerías las copiaremos en una carpeta en la PC (una carpeta en el escritorio en mi caso), de ahí las comprimimos en un fichero "tar". Una vez hecho esto las pasamos a la SDCARD y descomprimimos esto dentro del Mini2440.

¿Por que la razon de la compresion en un fichero .tar? Tendremos librerias que seran de tipo simbolicas (enlaces, accesos directos de otras librerias) que no se pueden almacenar en un dispositivos de almacenamiento tipo FAT si no en las famosas EXT2. Claro que hay como cambiar de FAT a EXT2 y no tendria ningun problema, el unico incoveniente que me encontre fue que el Mini2440 no me reconocia la SDCAR con EXT2 por lo que decidi realizarlo de la siguiente manera, Ingresamos esta por la terminal

                    $mkdir /home/edison/Escritorio/Sd_Card
                    $cd /usr/local/Qt/lib
                    $cp *4.6.2 /home/edison/Escritorio/Sd_Card/
                    $cp -r fonts/ /home/edison/Escritorio/Sd_Card/
                    $cd /usr/local/Qt/
                    $cp -r demos/ /home/edison/Escritorio/Sd_Card/
                    $mkdir /home/edison/Escritorio/Sd_Card/tslib
                    $mkdir /home/edison/Escritorio/Sd_Card/tslib/lib
                    $cd /home/tslib/lib/
                    $cp -r * /home/edison/Escritorio/Sd_Card/tslib/lib/
                    $cp * /home/edison/Escritorio/Sd_Card/tslib/lib/
                    $cd /home/edison/Escritorio/
                    $tar -cvf sd_card.tar Sd_Card/
                    $cp sd_card.tar /media/SD_CARD/

Una vez copiados los archivos a la SDCARD solo necesitamos configurarlos dentro del Mini2440, para ello haremos uso del programa Putty para la comunicación serial e ingresar los comandos de linux. Ingresamos la SDCARD en el Mini2440





Ingresamos lo siguientes comandos dentro del terminal Putty.

                     $cd /home
                     $tar -zxvf /sdcard/sd_card.tar 



                     $mkdir /usr/local/Qt
                     $mkdir /usr/local/Qt/lib
                     $cp /home/Sd_Card/*4.6.2 /usr/local/Qt/lib/
                     $cd /usr/local/Qt/lib/

Llegados a este punto en esta carpeta tendremos todos los archivos nombrados con la siguiente extensión ".so.4.6.2" lo que haremos sera cambiar esta extensión a todos los archivos por esta otra ".so.4"

                    $mv libQtCore.so.4.6.2 libQtCore.so.4





                   $cp -r /home/Sd_Card/fonts/ /usr/local/Qt/lib/
                   $cp -r /home/Sd_Card/demos/ /mnt/
                   $rm -rf /home/Sd_Card/demos/
                   $rm -rf /home/Sd_Card/fonts/
                   $cp -r /home/Sd_Card/tslib/ /usr/local/
                   $rm -rf /home/Sd_Card/

-Modificar los archivos de Linux

Ahora tendremos que modificar los archivos de configuración de linux:

                    $cd /etc/init.d/
                    $vi rcS

Cambiamos esto:

                     bin/qtopia&
                     echo"                                 "> /dev/tty1
                     ehco"Starting Qtopia, please waiting..." > /dev/tty1

Por esto (comentar las lineas):


                    #bin/qtopia&
                    #echo"                                 "> /dev/tty1
                    #ehco"Starting Qtopia, please waiting..." > /dev/tty1




Nos tocara hacer algo similar en otro archivo la diferencia esta en que ahora no tendremos que que modificar algo si no añadir mas lineas:

                   $cd /etc/
                   $vi profile

Añadimos estas lineas: 

                 export LD_LIBRARY_PATH=/usr/local/tslib/lib
                 export QTDIR=/usr/local/Qt                 
                 export QWS_MOUSE_PROTO=tslib:/dev/input/event0
                 export TSLIB_CALIBFILE=/etc/pointercal        
                 export TSLIB_CONFFILE=/usr/local/etc/ts.conf  
                 export TSLIB_CONSOLEDEVICE=none               
                 export TSLIB_FBDEVICE=/dev/fb0              
                 #export TSLIB_PLUGINDIR=/usr/local/tslib/lib/ts
                 export TSLIB_TSDEVICE=/usr/local/tslib/lib/ts 
                 export TSLIB_TSEVENTTYPE=INPUT                
                 export QWS_DISPLAY=LinuxFB:mmWidth=105:mmHeight=140


Creamos un enlace simbolico para las librerias recientemente agregadas:

ln -s /usr/local/lib/libts-0.0.so.0 /usr/local/Qt/lib/libts-0.0.so.0

-Correr programas

Para poder ejecutar el demo ingresamos los siguientes comandos (antes lo mejor ser darle RESET al Mini2440) :

                 $cd /mnt/demos/embedded/fluidlauncher/
                 $./fluidlauncher -qws


Si todo lo anterior esta hecho paso a paso y de manera correcta no habría problemas a la hora de ejecutar los programas que compilemos en Qt Creator. Espero tener algo de tiempo de aqui en adelante para explicarles como usar el IDE QT CREATOR para realizar las aplicaciones para nuestro MINI2440.