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.

ANDROID 2.1 en el Mini2440

En un post anterior les mostré los pasos para instalar Android 1.5 Cupcake en el Mini2440 y ademas los pasos para modificar el kernel para adaptar los controladores para una pantalla  tipo W35. Ahora teniendo estos conocimientos previos     el presente post lo hago con el fin de de mostrarles como como seria la instalación y correspondiente modificación del kernel  para una versión superior de Android: Eclair. Ademas de como poder mejorar la velocidad de la interactividad con el sistema operativo ya que Cupcake era para ser sincero y en mi opinión personal menos atractivo, muy limitado en cuanto a sus prestaciones y el desarrollo de aplicaciones estaría muy limitada.

¿Que necesitaremos?

• Una PC con el SO Ubuntu, si es otra distribución Linux  les recomiendo adaptar los comandos para su SO. Si disponen de Windows les recomiendo usen una maquina virtual. 
• Descargar Putty que esta disponible tanto para Linux como para Windows. Este software nos permitirá iniciar una sesión para acceder remotamente al dispositivo después de la instalación.
• Y por supuesto descargar los archivos correspondientes que están disponibles en estos links: Link1 y Link2.
• Para poder continuar sin contratiempos les recomiendo para los que todavía no lo han hecho revisar este post. De aquí en adelante asumiré que ya revisaron el post. 
• Tener instalado el IDE Geany.
• Disponer del API Ncurses.
• Configurar el compilador cruzado del ARM.
• Disponer del sistema YAFFS

¿Cual es el primer paso?

• Creamos una carpeta donde descomprimiremos el Kernel_Android_2_1 y accedemos a esta carpeta descomprimida.
• En el terminal (como root y al haber accedido a la carpeta correspondiente) escribimos esto:

$geany arch/arm/mach-s3c2440/mach-smdk2440.c 

• Nos trasladamos a la linea 156-167 y modificamos el archivo de esta manera:

Antes

Después

• Todavía queda modificar otro archivo para ello en el terminal ingresamos esto:  $geany drivers/input/touchscreen/s3c2410_ts.c  y de la misma manera también modificamos el archivo en las lineas 99-100 .

Antes

Después

• Ahora solo ingresamos los siguientes comandos:

                  $cp config_mini2440 .config

                  $make menuconfig

• Salimos de la interfaz que se nos presenta eligiendo 'EXIT'.
• Después escribimos: $make zImage
• La construcción de la imagen tardara de 10 a 15 minutos.
• Una vez compilado, el núcleo kernel estará en /arch/arm/boot/ con el nombre zImage.

¿Cual es el segundo paso?

• Creamos una carpeta donde descomprimiremos el otro archivo descargado: Fs_Android_2_1.tgz
• En esta carpeta esta un archivo llamado 'default.prop', el cual lo abriremos y haremos los siguientes cambios.

Antes

Después

• Por ultimo creamos la imagen con la herramienta YAFFS2 para ello descomprimimos el archivo  descargado anteriormente y elijemos el correspondiente a nuestro Mini2440 (en mi caso de 128Mb). El archivo final estará en la carpeta misma. 
$./mkyaffs2image-128M fs/ mini2440W35_android.img


• Una vez hecho esto solo instalamos el SO en el ARM y nos disponemos a configurar el sistema para hacerlo un poco mas rápido. Cabe mencionar que cuando iniciamos por primera vez el SO tardara un tiempo considerable. 
• Para acceder al dispositivo necesitaremos hacerlo por medio de comunicación serial entra la PC y el Mini2440 a una velocidad de 115200bps tal como lo muestra la siguiente imagen atravez de Putty. 

Una vez hecho esto ingresamos los comandos como si estuviéramos trabajando en Linux.

                  $cd /system/app

Luego borramos todos las aplicaciones presentes aqui, pero solo dejamos las siguientes:

-LatinIME.apk

-Launcher.apk

-PackageInstaller.apk

-Settings.apk

-SettingsProvider.apk

-UserDictionaryProvider.apk

De esta manera borramos los archivos:

                   $rm -rf nombreaplicacion.apk 

Nuestro SO esta listo, ahora solo lo reiniciamos y tendremos nuestra Android 2.1 mas funcional.

Mini2440: SO WINDOWS CE

Ahora solo nos falta un ultimo SO montar en el Mini2440 y aquí les mostrare como hacerlo con WINCE. Como sabemos Microsoft abarca casi todas las PC y como no imaginarse que no tendría su pequeño aporte a los sistemas móviles. Para ello desarrollo  Windows Embedded Compact lanzado por allá en el año de 1996 para sistemas embebidos con arquitecturas Intel x86 y compatibles, procesadores MIPS (RISC) y ARM. La ultima versión disponible es la WinCE 7.

La versión que dispondremos sera la 6, esta versión es la que vamos a instalar en el Mini2440, para ello como ya lo había mencionado en otros momentos sera necesario usar una PC que disponga XP para no tener problemas con los controladores.
El ejecutable DNW también sera de ayuda.
Los archivos de configuración del sistema serán necesarios obviamente.
El clable USB-SERIAL y el USB entran nuevamente como ayuda.
El método de instalación es casi similar a lo que usamos con Linux, por lo tanto seria bueno que revisen ese post antes de comenzar con este solo para recordar y avanzar mas rápido.


-Primeramente ejecutamos el DNW y configuramos la comunicación Serial  en CONFIGURATION>>OPTIONS. Ahí escojemos el puerto correspondiente al cable USB-SERIAL , la velocidad de 115200bps y la dirección del USB DOWNLOAD 0x30000000. Después conectamos el USB SERIAL de esta manera: SERIAL PORT>>CONNECT.

-Después configuramos el switch de boot al estado NOR, y encendemos el Mini2440. Si todo se hizo correctamente una imagen similar a esta deberá aparecer (darse cuenta de la barra de superior del programa).

-Lo primero a realizar sera formatear las espacios de memoria en las que se va a montar WinCE. Para ello presionamos f . Deberá salirnos una ventana como la siguiente.

-Ahora es necesario configurar el archivo Supervivi de 64MB 0 128MB, según cual corresponda a nuestro ARM. Elegimos  v y después USB-PORT>>TRANSMIT/RESTORE, abrimos el supervivi y tendrá que salir una ventana similar a esta.

-Ahora necesitaremos el archivo booteable para WinCE, presionamos n y así mismo vamos a USB-POR>>TRANSMIT/RESTORE y elijemos el correspondiente a nuestra LCD, en mi caso la W35.

-Ahora viene una una parte interesante: configurar un logo de inicio de pantalla de tipo de  extensión 'bmp' . Podemos elegir el que nos agrade siempre y cuando cumpla con las dimensiones de la pantalla LCD, en mi caso vamos a utilizar el por default. Presionamos l y transferimos el archivo por el puerto USB.

-Por ultimo el archivo .bin "nk_XX.bin" correspondiente a nuestra pantalla LCD, presionamos w y transferimos el archivo.

-Va tardar un poco para instalar el SO, una vez listo el sistema automáticamente de inicializara en el Mini2440, pero para no tener problemas lo apagamos y ponemos el switch de boot al modo NAND y de nuevo lo encendemos y ahora si estaremos listos para usar WinCE en el Mini2440. 

Es posible que la pantalla no responda del todo bien lo que recomiendo es usar un Mouse USB y con el recalibrar la pantalla (el SO dispone de una herramienta instalada por default para ello), en el Mini2440 estando el entorno del escritorio vamos al icono de Inicio :"Start>>Settings>>Control Panel>>Stylus" se nos abre una ventana y elegimos la pestaña Calibration, dentro de aqui hacemos clic en "Recalibrate" y seguimos los pasos que se nos mostrara.

Ahora como ya estamos en la posibilidad de montar los 3 sistemas operativos en el Mini2440, faltara como diseñar programas para ejecutarlos en esa plataforma. Como adelanto para Linux disponemos del QT CREATOR, para Android del IDE ECLIPSE y para WinCE de Visual Studio.

Es posible que realice un vídeo con los diferentes SO trabajando en el MINI2440 para tener un poco mas de referencia sobre este asombroso ARM. En la próxima entrega tratare de hacer un pequeño programa para probarlo en Mini2440.

Mini2440:SO Android, Jugando con el Kernel.

Uno de las sistemas operativos que soporta el Mini2440 en los cuales  se puede gestionar los recursos de hardware y proveernos servicios de programas de aplicación es Android que esta basando en el kernel de Linux y diseñado especialmente para dispositivos que posean una pantalla táctil.

Uno de los primeros problemas que me encontré al querer instalar Android en el Mini2440 fue que los distribuidores del dispositivo no habían compilado el kernel para soportar mi LCD (dispongo de una LCD W35 240x320),  por lo que no tuve otra opción que googlear un par de noches que estaba libre para poder solucionar mi inconveniente. Por suerte la ayuda no me fue esquiva y encontré la solución, aunque no de un modo muy especifico (me toco unir varias experiencias de otros usuarios). Toda esta ayuda la encontré en los foros de soporte técnico de FriendlyArm (Clic Aqui). Si quieres saber algo mas o tienes una duda, no lo dudes pide apoyo a la comunidad de desarrolladores.

Ahora si tu también tienes un problema similar o quieres simplemente probar suerte con el kernel de Android a lo Chuck Norris te voy a tratar de resumir lo que yo hice en especifico (no me considero un experto en Linux así que cualquier error por favor pido disculpas). Como ya se pueden imaginar sera necesario una PC con Linux y que tenga instalada alguna distribución  en mi caso particular yo tengo Ubuntu 12.04 LTS.

Los pasos a realizar son lo siguientes:

 
                   1.- Descargar el kernel, archivos de sistemas y el compilador cruzado.
                   2.- Instalar las Herramientas necesarias.
                   3.- Instalar el compilador cruzado.
                   4.- Modificando y compilando el kernel.
                   5.- Preparando el sistema de Archivos de Android.
                   6.- Instalación del SO en el Mini2440.

Abrimos una terminal por que todo lo haremos en modo comandos, te recomiendo que si eres novato en Linux leas un poco sobre comandos básicos para que lo que voy a hacer sea un poco mas entendible.

En cuanto a los permisos para ejecutar los comandos les recomiendo hacerlo como root, pero si no tienen permisos para root el comando sudo seria mas que suficiente.

1.- Descargar el kernel, archivos de sistemas y el compilador cruzado. 

-Para descargar el kernel Clic Aqui
-Para descargar el Sistema de Archivos Clic Aqui
-Para el compilador cruzado Clic Aqui

2.- Instalar las herramientas necesarias.

Vamos a necesitar un editor de texto llamado 'Geany', mi elección en este editor se basa en que nos proporciona un interfaz perfecta para crear código en diferentes lenguajes. Para la instalación lo realizamos desde terminal:

                    $sudo apt-get install geany

Debemos tener disponible también la librería Ncurses que es una biblioteca de programación que provee una API que nos permite escribir interfaces basadas en texto (comandos) para la compilación del kernel.  

                   $sudo apt-get install libncurses5-dev

Necesitaremos la herramienta YAFFS que es un sistema de archivos creado para memorias tipo NAND. Para descargarlo Clic Aquí.

3.- Instalar el compilador cruzado.

Antes que nada ¿Para que me va a servir un compilador cruzado? Para poder responder ampliamente a esta pregunta que muchas personas quizás se hayan hecho debemos entender lo que es un cross-compiler.

Un cross-compiler es un compilador capaz de crear código ejecutable para otra plataforma distinta a aquella en la que se ejecuta. Por lo tanto nos servirá de maravilla para crear código para el Mini2440 (la arquitectura del Mini2440 es ARM920T y la de una PC en general es muy diferente), como seria muy difícil crear código dentro del Mini2440 es mejor usar un cross-compiler para hacerlo en una PC común y corriente y después solo ejecutar ese código en la plataforma del ARM.

Nos ubicamos en la carpeta donde se descargo el paquete. En mi caso en la Carpeta Downloads

                     $cd /home/eddie/Downloads/
                     $ls -la 

Debería salirnos una ventana similar:

Ahora descomprimimos los archivos

                     $tar -zxvf arm-linux-gcc-4.3.2.tgz

Tardara un tiempo de descomprimir los archivos. Después de esto ingresamos los siguientes comandos: 

                     $cd usr/local/
                     $mv arm/ /usr/local/
                     $cd ../..
                     $rm -rf  usr/
                     $cd /usr/local/
                     $geany ~/.bashrc

En el ultimo comando lo que hicimos fue abrir con el editor 'Geany' el archivo 'bashrc'. Este archivo contiene toda la configuración de la terminal o bash como quieras llamarlo, que es donde podemos interactuar por medio de texto con la computadora.

El cross-compiler tiene unos comandos adicionales por lo que hay que hacerle saber al terminal donde se encuentran estos comandos para cuando los llamemos sepa ejecutarlos sin problemas, de ahí la necesidad de editar este archivo.

Al final del documento pegamos lo siguiente: "export PATH=$PATH:/usr/local/arm/4.3.2/bin" y después guardamos el archivo.

Para que los cambios se apliquen cerramos el terminal y nuevamente lo abrimos y ponemos lo siguiente:

                     
                     $arm-linux-gcc -v

Si todo esta bien debera salir algo similar a esto: 

4.- Modificando y compilando el Kernel.
                     

Como ya les mencione antes la distribución de Android que proporcionaba la empresa para instalarla en  el Mini2440 no estaba configurada con mi tipo de Pantalla (W35) es decir no estaba el kernel compilado para esta pantalla. Ahora para compilar el kernel para que trabaje con este tipo de pantalla solo hay que realizar los siguientes pasos (El kernel de Android debe estar descargado) :

                    $cd /home/eddie/Downloads/

                    $tar -zxvf android-kernel_20090825.tgz

                    $cd kernel/

                    $geany arch/arm/mach-s3c2440/mach-mini2440.c

Este archivo contiene los tipos de pantalla y sus configuraciones por lo que sera necesario modificar para adaptarlo a la resolución de nuestra pantalla.  En la linea 169 del documento veremos que hay unas resoluciones correspondientes a la pantalla T35 la cual es de 320x240.

Todo esto lo cambiaremos por la siguiente configuración y guardamos los cambios.

Es de esperar que como cambiamos la orientación de la pantalla LCD en el kernel la manera en como responderá la pantalla táctil a las pulsaciones no sera la misma por ello faltaría modificar un archivo mas, ingresamos el siguiente comando:

                   $geany drivers/input/touchscreen/s3c2410_ts.c

En las lineas 99 y 100 del documento haremos los siguientes cambios:

Cambiar esto

Por esto.

Ya hemos hechos los cambios necesarios en el kernel lo que nos toca hacer por ahora es compilar dicho kernel modificado.

                   $cp config_mini2440 .config

                   $make menuconfig

Se nos mostrara el API de Ncurses.

Como ya modificamos el kernel solo salimos de esta interfaz eligiendo <Exit>. Después ingresamos en la terminal:

                    $make zImage

Nota: Es posible que en el ultimo paso les salga un error como "arm-linux-gcc command not found", esto lo arreglamos solo agregando el PATH del cross-compiler al archivo bashrc. Hacer esto solo si no compila el kernel.

Tardara aproximadamente 10 minutos compilar por completo el kernel, una vez listo saldrá esto en la terminal. 

La zImage estara en arch/arm/boot/zImage.

4.- Preparando el Sistema de Archivos de Android. 

En la terminal nos movemos a la carpeta donde descargamos el sistema de archivos y descomprimimos el paquete.

                    $cd /home/eddie/Downloads/
                    $tar -zxvf android-fs_20090825.tgz

La carpeta descomprimida contiene los archivos root del sistema de Android, con un editor de texto abrimos el archivo default:

                    $geany fs/default.prop

Vamos a cambiar estos parámetros:

Por estos:

Ahora descomprimimos el paquete que contiene la YAFFS2

                     $tar -zxvf linux-mkyaffs2image.tgz 
                     $ cp usr/sbin/mkyaffs2image-128M /home/eddie/Downloads/

El comando ultimo copia la YAFFS2 para memorias NAND de 128MB (el Mini2440 que tengo tiene una memoria de ese tamaño, recomiendo verificar la tuya para que puedas copiar el archivo correcto) a la carpeta donde se descomprimió el sistema de archivos fs.

                     $./mkyaffs2image-128M fs/ mini2440W35i_android.img


Deberá salir lo siguiente:

El archivo estara de la carpeta donde descargaste los demás archivos con el nombre: mini2440W35i_android.img

6.- Instalar el SO Android en el Mini2440.

La instalación es similar a la de Linux, recomiendo ver este post para refrescar la memoria.

1. Poner el switch boot en NOR del Mini2440 mienstras este esta en OFF.
2. Conectar el cable USB y USB-SERIAL del Mini2440 a una PC que tenga XP.
3. Abrir el DNW y elegimos CONFIGURATION>>OPTIONS y elegimos el puerto serial correspondiente, un Baud Rate =115200 y Address USB=0X30000000.
4. Despues Serial Port>>Connect.
5. Ponemos en ON el switch del Mini2440.
6. Presionamos x para formatear la memoria.
7. Presionamos v para transmitir el Supervivi.
8. Presionamos k para la zImage (kernel).
9. Presionamos y para el sistema de archivos: mini2440W35i_android.img.
10. Apagamos el Mini2440 y el swithc de boot lo ponemos en NAND.

Mini2440: SO Linux Instalación

Como ya les había mencionado antes este ARM soporta tres SO diferentes: LINUX, ANDROID y WINDOWS. Por ello en este espacio les mostrare como instalar específicamente Linux con todos los pasos  que yo seguí y los problemas que pueden surgir y como los solucione.

LINUX:

Linux es un SO operativo potente, seguro y gratuito que vio la luz por allá en los inicios de la década de los 90. El kernel que soporta el Mini2440 y que  vamos a utilizar es el 2.6.32.2. Como se sabe el kernel es considerado el corazón del SO que esta encargado de que el software y hardware trabajen juntos de manera armoniosa. 

Ahora la distribución de Linux que usaremos en el Mini2440 sera QTOPIA  2.2.0  (ahora llamado QT EXTENDED). Este SO es una plataforma de aplicaciones para dispositivos como móviles, PDA's, Pockets PC , etc. Desarrollada por TROLLTECH bajo licencia tipo GPL (libre).

Vista del menú de Linux Qtopia.

Ahora si teniendo una idea de con que vamos a tratar estamos listos para portar el SO Qtopia en el Mini2440. Necesitaremos:

        -Un cable serial (en este caso un USB-SERIAL).
        -Una extensión de cable serial de conector tipo  Hembra-Hembra.

        -Un cable USB.

        -Y lógicamente el Mini2440 conectado a  su respectiva fuente de Voltaje.

Lo que si les recomiendo y esto basado en mi propia experiencia es que utilicemos una PC que tenga WINDOWS XP, pues el controlador del cable USB para el Mini2440  solo es compatible para XP, es verdad que es posible utilizar una maquina virtual pero a mi me surgió el siguiente problema: Estaba utilizando VMware pero tenia problemas con la utilización de los puertos USB cuando estaba corriendo XP (tengo una portátil con WINDOWS 7 ), en ocasiones los puertos los reconocía XP y en otras WINDOWS 7 y todo era una caos completo, trate con todas las soluciones posibles que encontraba en Internet pero ninguna dio resultado por lo que opte usar una PC con XP.

Para los controladores del cable USB-SERIAL para XP: Descargar AQUI.

Para los controladores del USB para el Mini2440 para XP Descargar AQUI. También se lo puede descargar de la pagina oficial http://www.friendlyarm.net en la sección de Descargas.

Instalamos los controladores y ahora necesitaremos estos archivos:

         -DNW for XP: Programa para la transferencia de ficheros del PC  al Mini2440.

        -Hay un archivo especial que no es el mismo para todo los Mini2440, hablo del Supervivi. Para identificar cual tenemos solo damos un vistazo al  chip de la memoria NAND que esta cerca de la tarjeta SD y según su serie identificamos el Supervivi correspondiente:

K9F1208 > 64 MB NAND Flash

K9F1G08 > 128 MB NAND Flash

K9F2G08 > 256 MB NAND Flash

K9F8G08 > 1024 MB NAND Flash

El supervivi-64M es para 64MB NAND y el supervivi-128M es para 128MB / 256MB / 1GB NAND. El link descarga para estos archivos esta AQUI.

        -Ahora el kernel de Linux: Con este archivo hay que tener cuidado pues este depende enormemente del tipo de pantalla LCD que disponemos (ya explicare por que, mas tarde en este mismo blog) en mi caso yo dispongo de un LCD W35, recomiendo investigar cual disponen ustedes. En mi caso fue fácil pues la descripción estaba presente en la misma LCD ojala que con uds. sea lo mismo. Igualmente aquí les dejo los archivos para los varios tipos de pantalla LCD en los que esta disponible el Mini2440 (Descargar AQUI).

        -La imagen del SO QTOPIA Descargar AQUI.

Conectamos los cables SERIAL y USB de la PC al Mini2440, para el cable serial se recomienda la extensión para que los conectores se correspondan sin problemas.Una vez conseguido estos archivos ejecutamos el DNW (recomiendo extraerlo del zip).

Nos vamos a CONFIGURATION>OPTIONS y elegimos el puerto serial correspondiente, un Baud Rate=115200 y un Address del USB=0x30000000.

Elegimos SERIAL PORT>CONNECT si todo esta bien aparecerá en la barra de la ventana lo siguiente :[COM3,115200] .

 Seteamos en NOR el switch para el modo del boot, esto mientras esta en OFF el switch de energía (para encontrar el switch por favor revisar la imagen siguiente).

Encendemos el Mini2440 poniendo en ON el switch de energia. En el modo NOR el LCD esta apagado, pero en la barra de estado del DNW si todo esta bien aparecerá [USB:OK].Ademas se desplegara un menú con opciones, en algunas ocasiones este menú no se despliega pero no hay problema mientras la barra de estado muestre lo dicho anteriormente todo estará bien.

Ahora nos tocara formatear la memoria  NAND FLASH donde esta el boot inicial para ello presionamos x. Deberá aparecer los siguiente:

Después presionamos v para subir al Mini2440 el archivo Supervivi. Después de esto nos vamos a USB Port>Transmit y elegimos el supevivi correspondiente en este caso para mi dispositivo supervivi-128M. En algunas ocasiones en el cuadro de dialogo no aparece el archivo que necesitamos, para solucionarlo solo seleccionamos ALL FILES en donde dice TYPE.

Ahora le toca el turno al kernel, presionamos k , inmediatamente USB Port>Transmit y elegimos el archivo imagen correspondiente a la pantalla que tenemos, en mi caso personal el zImageW35. 

¿Que pasa si eligo una que no corresponde a mi LCD? La respuesta es simple: El DNW no te dará ningún error (al menos eso es lo que se sucedió en mi ARM) y parecería que todo estuviera bien, pero cuando finalicemos y encendamos el Mini2440 la pantalla presentara errores en mi caso me presento solo hasta la mitad la interfaz gráfica esto por que el kernel esta compilado con otra tipo de resolución para la pantalla LCD.

En la ultima parte cargamos la imagen del SO QTOPIA, presionamos y. De la misma manera USB Port>Transmit y elejimos la imagen.

Hasta que finalice tardara un considerable tiempo. Después apagamos el Mini2440 y regresamos el switch de BOOT a NAND para que arranque desde ese sector de memoria, y encendemos nuevamente el Mini2440 con nuestro sistema operativo QTOPIA.

Para las configuraciones iniciales (nos pedirá calibrar la pantalla táctil, configurar la Zona Horaria, fecha, etc.) y en general para utilizar la pantalla LCD de manera efectiva sugiero utilizar un lápiz óptico. El Idioma esta en Chino, pero no nos preocupemos solo hay que abrir una aplicación de diccionario que es visible por que el icono son dos banderas: China y Británica, y elegir el idioma Ingles y listo.

Bueno hemos finalizado esta nueva entrega de como portar Linux en el Mini2440, espero que le sea de ayuda y en el siguiente blog tratare de hablar sobre como portar ANDROID, durante toda  la realización de este blog he estado en la tarea de portar ANDROID pero el problema que se me ha presentado es la pantalla que tengo (LCD W35)  que no encuentro el zImage correspondiente para ANDROID, cuando lo solucione estaré listo para la hacerles saber como lo hice.