Dispositivo Móvil de Acceso - DMA

Compilación de una máquina virtual de java para el i.MXL

Tutorial

Ing Juan Felipe Botero Vega

Ing Mónica Ayde Vallejo

Informe Técnico : COL-1T-2006

Desarrollado por : Grupo de Microelectrónica y Control y Grupo Sicosis

Institución : Universidad de Antioquia

Fecha : Febrero 2006

www: microe.udea.edu.co/proyectos/DMA
email: infodma@microe.udea.edu.co
tel: +574 2105567
fax: +574 211 9028
 TABLA DE CONTENIDO

1. INTRODUCCIÓN ........................................................................................ 3

2. PLATAFORMA PARA LA PROGRAMACIÓN DE APLICACIONES EN

SISTEMAS MÓVILES DIGITALES..................................................................... 3
2.1 Lenguaje De Programación Python ..................................................... 3
2.1.1 Características .............................................................................. 4
2.1.2 Soporte ......................................................................................... 4
2.1.3 Ventajas de Pytohn....................................................................... 5
2.1.4 Desventajas de Python ................................................................. 5
2.1.5 Otro software relacionado con Python .......................................... 5
2.2 Lenguaje De Programación Java ......................................................... 6
2.2.1 Ventajas de J2ME......................................................................... 7
2.2.2 Desventajas de J2ME ................................................................... 7
2.3 Máquina virtual JAVA.................................................................... 7
2.4 Compilar kaffe para un sistema embebido:.......................................... 8

3. CROSS-COMPILACION E INSTALACION DE KAFFE EN EL SISTEMA

DE DESARROLLO I.MXL................................................................................. 10
3.1 cross-compilación .............................................................................. 10
3.2 Herramientas y dispositivos: .............................................................. 11
3.3 Descripción de la Interfaz Gráfica a Utilizar ....................................... 11
3.4 Cross-compilación de la máquina virtual de java: kaffe ..................... 11
3.5 Pasos para ejecutar un archivo .java en la tarjeta imxl ...................... 14

4. AGRADECIMIENTOS ............................................................................... 15

5. REFERENCIAS......................................................................................... 16

2
 Compilación de una máquina virtual
de java para el I.MXL LiteKit
Juan Felipe Botero Vega
Mónica Ayde Vallejo V

1. INTRODUCCIÓN

Los dispositivos móviles son implementaciones con un hardware muy reducido

con respecto a un computador personal, por lo que las aplicaciones que se
desarrollan para un dispositivo embebido (dispositivo móvil), debe ser estables,
confiables, eficientes y no pueden consumir muchos recursos del sistema. Por
estas razones, se hace necesario elegir una plataforma de programación muy
completa y que cumpla con los requerimientos de hardware y software que
tienen los sistemas embebidos.

En la sección 2 de este documento se describen algunas plataformas de

software usadas en dispositivos móviles. En la sección 3 se describe el proceso
de instalación de la plataforma de software en el i.MXL LiteKit. En la última
sección se presentarán algunos ejemplos de aplicaciones corriendo en el
dispositivo embebido.

2. PLATAFORMA PARA LA PROGRAMACIÓN DE APLICACIONES

EN SISTEMAS MÓVILES DIGITALES

Esta sección trata de los lenguajes de programación Python y JAVA, indicando

las diferentes características que ellos poseen.

2.1 Lenguaje De Programación Python

Python es un lenguaje de programación fácil de aprender y potente. Dispone de

eficaces estructuras de datos de alto nivel y una solución de programación
orientada a objetos simple pero eficaz. La elegante sintaxis de Python, su
gestión de tipos dinámica y su naturaleza interpretada hacen de él el lenguaje
ideal para guiones (scripts) y desarrollo rápido de aplicaciones en muchas
áreas y en la mayoría de las plataformas.

El intérprete de Python y su extensa biblioteca estándar están disponibles

libremente, en forma de fuentes o ejecutables, para las plataformas más
importantes, en la sede web de Python [1], y se pueden distribuir libremente.

3
2.1.1 Características

Python es simple, pero es un lenguaje de programación real. Ofrece más apoyo

e infraestructura para programas grandes que el intérprete de órdenes. Por otra
parte, también ofrece mucha más comprobación de errores que C y, al ser un
lenguaje de muy alto nivel, tiene incluidos tipos de datos de alto nivel, como
matrices flexibles y diccionarios, que llevarían días de programación en C.
Dados sus tipos de datos más generales, se puede aplicar a un rango de
problemas más amplio que Awk o incluso Perl, pero muchas cosas son, al
menos, igual de fáciles en Python que en esos lenguajes.

Python permite dividir su programa en módulos reutilizables desde otros

programas en Python. Viene con una gran colección de módulos estándar que
puedes utilizar como base de tus programas (o como ejemplos para empezar a
aprender Python). También hay módulos incluidos que proporcionan E/S de
ficheros, llamadas al sistema, “sockets” y hasta interfaces gráficas con el
usuario, como Tk.

Python es un lenguaje interpretado, lo que ahorra un tiempo considerable en el

desarrollo del programa, pues no es necesario compilar ni enlazar. El intérprete
se puede utilizar de modo interactivo, lo que facilita experimentar con
características del lenguaje, escribir programas desechables o probar funciones
durante el desarrollo del programa de la base hacia arriba. También es una
calculadora muy útil.

Python permite escribir programas muy compactos y legibles. Los programas

escritos en Python son normalmente mucho más cortos que sus equivalentes
en C o C++, por varios motivos:

• Los tipos de datos de alto nivel permiten expresar operaciones

complejas en una sola sentencia.
• El agrupamiento de sentencias se realiza mediante sangrado
(indentación) en lugar de begin/end o llaves.
• No es necesario declarar los argumentos ni las variables.

Python es ampliable: es fácil añadir una nueva función o módulo al intérprete,

para realizar operaciones críticas a la máxima velocidad o para enlazar
programas en Python con bibliotecas que sólo están disponibles en forma
binaria (como bibliotecas de gráficos específicas del fabricante). Una vez
enganchado, puedes enlazar el intérprete de Python a una aplicación escrita en
C y utilizarlo como lenguaje de macros para dicha aplicación.

2.1.2 Soporte

El lenguaje de programación Python es soportado por The Python Software

Foundation (PSF), además por muchos programadores a nivel mundial. En
PSF son fieles al software libre o código abierto. La lista de miembros de este
grupo es bastante alta además de contar con el auspicio de empresas como
O’Reilly, Google, Open Source Application Foundation, Merlin LLC, entre otros.

4
2.1.3 Ventajas de Pytohn

• Python es interpretado. Esto quiere decir que es independiente de la

plataforma.
• Python fue escrito para ser usado en educación, en otras palabras,
Python te obliga a escribir software bonito.
• Puede usarse para programar tanto de manera estructurada como
orientada a objetos
• Los tipos de datos de alto nivel permiten expresar operaciones
complejas en una sola sentencia.
• Programación rápida debido a la sintaxis empleada y al modo de probar
los códigos realizados.
• Python es ampliable: es fácil añadir una nueva función o módulo al
intérprete, para realizar operaciones críticas a la máxima velocidad o
para enlazar programas en Python con bibliotecas que sólo están
disponibles en forma binaria
• Acceso al hardware a través del sistema operativo haciendo uso de
funciones en C
• Gran cantidad de librerías puestas en Internet para su disposición
(Administración de archivos, llamadas al sistema, sockets, XML,
gráficos, GUI, Protocolos de Internet, entre otros).
• Código 100% libre

2.1.4 Desventajas de Python

• Carece de una distribución orientada a los sistemas embebidos. Sin

embargo, algunos fabricantes han portado este lenguaje a sus sistemas
como iPOD [6], Python for Series 60 de Nokia, Python sobre Palm OS,
Python para Windows CE
• No es fácil la Migración de código por la sencillez del lenguaje.
• Aun no se encuentran módulos Python para manejo de MPEG-4.
• Python es interpretado, lo que lleva a una reducción en el desempeño
comparado con aplicaciones desarrolladas en C.

2.1.5 Otro software relacionado con Python

JPython - Es una nueva implementación del lenguaje de programación Python,

el cual está diseñado para correr en la plataforma de Java. Consiste de:

• Un compilador que compila el código hecho en Python, generando byte

codes de Java que pueden correr directamente en la JVM.
• Conjunto de librerías las cuales son usadas por el código compilado en
Java Byte Codes.
• Soporte para hacer uso de los paquetes de Java dentro de JPython

Jython - Sucesor de JPython. Es una implementación del lenguaje Python de

alto nivel, dinámico y orientado a objetos estrechamente integrado con la
plataforma Java. Jython está libremente disponible para uso comercial y no

5
comercial y es distribuido con su código fuente. Jython es complementario a
Java y está diseñado para las siguientes tareas:

• Script embebidos: Los programadores de Java pueden adicionar las

librerías Jython a su sistema para permitir la adición de funcionalidad en
la escritura de scripts fáciles o complejos.
• Experimentación interactiva: Jython provee un intérprete interactivo que
puede ser usado para interactuar con paquetes de Java o con la
ejecución de aplicaciones Java. Esto permite a los programadores
experimentar y depurar cualquier sistema Java usando Python.
• Desarrollo rápido de aplicaciones: Los programas escritos en Python son
típicamente más pequeños que el equivalente programa en Java.

2.2 Lenguaje De Programación Java

La empresa Sun Microsystems [7] (desarrolladora de Java) ha propuesto una

plataforma Java orientada al desarrollo en sistemas de poca capacidad en
cuanto a recursos, es la plataforma más común para desarrollo de aplicaciones
en dispositivo móviles como celulares, PDA, etc.

El nombre de la plataforma es J2ME (Java 2 Micro Edition) [8]. Esta plataforma

incluye una máquina virtual (llamada KVM) y un conjunto de APIs estándar
definidas por los desarrolladores oficiales de Java. El J2ME le entrega a los
dispositivos embebidos los beneficios de la tecnología Java. Incluye flexibles
interfaces de usuario, un nivel de seguridad robusto, y un soporte grande de la
mayoría de los protocolos de red.

La documentación acerca de esta herramienta es bastante amplia, dado que es

una de las herramientas más conocidas para el desarrollo de dispositivos
móviles.

J2ME representa una versión simplificada de J2SE. J2ME tiene la

característica de tener una parte de su API fija, es decir, aplicable a todos los
dispositivos inalámbricos y una parte que es específica para ciertos
dispositivos; como ejemplo claro se puede ver el API especifica de Palm y la de
móviles, que evidentemente son distintas. J2ME es una tecnología que permite
la creación de aplicaciones que por ejemplo, reciban y envíen datos a través de
redes inalámbricas.

Una configuración es un conjunto mínimo de APIs que son útiles para

desarrollar aplicaciones para un conjunto definido de dispositivos. Son muy
importantes porque describen la funcionalidad requerida para unos dispositivos
determinados. Hay una configuración estándar para dispositivos inalámbricos
que se conoce como Connected Limited Device Configuration o CLDC. Este
estándar describe la funcionalidad mínima de los dispositivos inalámbricos, de
acuerdo a su potencia y a sus características. CLDC es, en resumen, el
conjunto de APIs básicas para construir aplicaciones para dispositivos móviles.
Finalmente, CLDC establece los mínimos de hardware requeridos para J2ME.
Estos son los siguientes:

6

160kb de memoria disponible para Java

Procesador de 16-bit

Bajo consumo energético

Conexión a una red (a menudo de 96000 bps pero puede ser menor el
ancho de banda)

2.2.1 Ventajas de J2ME

• Permite que el código que se desarrolle sea completamente portable a

otros ambientes y viceversa, código de otros ambientes deberá correr
sin problemas.
• Cuenta con una librería especial para flujos multimedia Java Media
Framework API.
• El java es un lenguaje open source, lo que permite que se pueda
intervenir su código libremente.
• J2ME está pensado para sistemas embebidos.
• J2ME cuenta con el API: Mobile Media API (MMAPI) que permite un
rápido y fácil desarrollo de aplicaciones multimedia para sistemas
embebidos.

2.2.2 Desventajas de J2ME

• El java como tal puede ser muy grande y pesado. Solución: J2ME Java 2
Platform, Micro Edition (J2ME).
• El Java y/o el J2ME no está disponible en binario en todas las
plataformas. Solución: Compilar el código fuente, usar alternativas a la
implementación Java de Sun como lo es el proyecto GNU Kaffe.

2.3 Máquina virtual JAVA

El lenguaje de programación JAVA consta de una máquina virtual que se

instala en la máquina que ejecuta los programas. El procesador del i.MXL
LiteKit tiene una arquitectura ARM y corre un Linux con kernel 2.6.11.4 como
sistema operativo, entonces se buscaron las máquinas virtuales de JAVA mas
apropiadas.

La primera máquina virtual que se tuvo en cuenta fue la que distribuye la

empresa Sun Microsystems, dado que esta empresa desarrolla oficialmente
JAVA. Esta máquina virtual se llama la KVM [8], y es desarrollada para J2ME.
El J2ME (JAVA 2 MICRO EDITION) es una colección de tecnologías y
especificaciones que los desarrolladores pueden elegir y combinar para
construir un completo ambiente JAVA que se acomoda a los requisitos de una
gama de dispositivos en particular. J2ME posee poca información y soporte
para realizar la cross-compilación de la máquina virtual KVM (la máquina virtual
J2ME de Sun Microsystems) en la arquitectura ARM.

Kaffe es un open source “Java runtime enviroment” que puede ser descargado
de http://www.kaffe.org. La máquina virtual, el recolector de basura y los
métodos nativos que trae fueron escritos en C y assembler. Por lo que, aunque

7
kaffe no fue escrito pensando en sistemas embebidos, es posible llevar kaffe a
cualquier plataforma en la que exista un compilador de C. La lista de
procesadores soportados por kaffe es amplia, está conformada por:
386/486/Pentium, SPARC, Alpha, PowerPC, 68k, ARM y MIPS. Esta familia de
procesadores está soportada también por el compilador GNU C Compiler
(GCC). Para la memoria, una combinación del intérprete, recolector de basura
y los métodos nativos requiere menos de 100-kbytes de espacio. Kaffe puede
ser usado con o sin un sistema operativo, esta es una característica única entre
las máquinas virtuales de Java. Esto es posible porque Kaffe contiene sus
propias implementaciones internas de hilos.

2.4 Compilar kaffe para un sistema embebido:

Más adelante se detallará el proceso exacto que se siguió para cross-compilar

kaffe y su instalación en la tarjeta IMXL de arquitectura arm. En esta sección se
tratará el proceso general que se debe seguir para portar el kaffe a un sistema
embebido. Después de descargar el kaffe de su sitio en Internet, se
descomprime el archivo que de allí se descarga y se puede ver que el código
fuente del kaffe queda organizado de la siguiente manera:

• Kaffe – Partes del intérprete independientes de la plataforma, código del

recolector de basura y algunas otras piezas del “Java runtime
enviroment”.
• Config – Partes del intérprete dependientes de la plataforma. Esta
organizada en una serie de subdirectorios con las arquitecturas
soportadas, y dentro de estos los sistemas operativos soportados.

• Packages – Contiene las librerías de clases Java, así como otros

métodos de los que ellas dependen.

• Incluye - Contiene las definiciones de los métodos nativos que se

encuentran en el directorio packages.

La división del código fuente de kaffe en subdirectorios dependiente e

independientes de la plataforma se hace con el fin de simplificar el proceso de
portar el kaffe a nuevas plataformas. En la mayoría de los casos, sólo los
archivos en el directorio config requieren modificaciones.

Pasos para realizar la migración del kaffe a un sistema embebido

Paso1: Intérprete del código de Bytes.

El intérprete el códigos de byte (Bytecode) de Java está implementado para

convertir cada Bytecode en código ejecutable de C. Como resultado, ni una
simple línea del código fuente del intérprete es específica de una arquitectura
particular. Esto permite que la máquina virtual sea portable: sólo hay que cross-
compilar el kaffe y los archivos resulantes quedarán en el directorio
kaffe/kaffevm.

8
Paso 2: Hilos Internos

Como ya se sabe, kaffe tiene su propio paquete de hilos. En otras palabras,

kaffe mantiene sus propias estructuras de datos de hilos. Todos los cambios
que hay que realizar en este paso (si hay que realizarlos) se hacen en el
directorio config (los cambios se hacen en caso de que en el directorio config
no exista una carpeta con el nombre de la arquitectura a la que se le va a
instalar kaffe).

Paso 3: Software de soporte

Como en la mayoría de software escrito en C, Kaffe depende de rutinas de la

librería estándar de C. La mayoría de las dependencias son compatibles con
los sistemas embebidos. Aunque, algunas de las librerías de que kaffe
depende pueden no ser soportadas por todos los compiladores de C, o pueden
no funcionar en un ambiente embebido. La siguiente es una lista de
herramientas de software que se deben tener para que el kaffe pueda
funcionar:

 Alojamiento de memoria dinámica. Aunque Java no llame

directamente a la función de C malloc(), la máquina virtual de kaffe
requiere una función alojamiento de memoria para solicitar grandes
cantidades de memoria para el software subyacente.
 Señales. Kaffe necesita señales para realizar las interrupciones
convenientes en la ejecución de algun aplicación.
 Una interfaz no bloqueada de I/O.

Paso 4: Cargador dinámico de clases

Una parte del código fuente dependiente de la plataforma que debe ser
modificada para usarla en cualquier sistema embebido es el cargador dinámico
de clases. Éste es una parte del “Java runtime enviroment” que es responsable
de cargar los métodos cuando son llamados. En un ambiente de escritorio, los
Bytecodes asociados con cada método son almacenados en un archivo .class.
El cargador dinámico de clases busca los directorios y archivos en la ruta de
clases del Java (classpath) para un método de acuerdo al nombre que éste
tenga. Pero hay muy pocos sistemas embebidos con un sistema de archivos,
por los que el cargador de clases debe ser modificado para que busque las
clases en la memoria (puede se RAM ó ROM).

Paso 5. Compilador en tiempo real (JIT: Just-in.time compiler) (opcional)

Si el JIT de kaffe soporta la arquitectura que se necesita (arm para el proyecto),

es una buena opción usarlo. Para utilizarlo, hay que recompilar los contenidos
de kaffe/kaffevm, pero esta vez usando los archivos de /kaffevm/jit en vez de
los de kaffevm/intr.. Estos archivos dependen de los que se encuentran en la
carpeta config/<arquitectura>, que debe ser compilada primero. Si la
arquitectura usada no soporta JIT es mejor no tratar de usarlo.

9
Paso 6: Hilos Nativos (opcional)

Por defecto, kaffe tiene sus propios mecanismos internos de hilos para
inicializar y programar cada uno de los hilos en una aplicación Java. Kaffe logra
esto creando estructuras de datos de hilos que son separadas e invisibles al
sistema operativo. En otras palabras, la máquina virtual del Kaffe es por si
misma una herramienta que subdivide su tiempo de ejecución y lo distribuye en
cada uno de sus hilos. En la figura 4 podemos ver la relación entre los hilos de
Kaffe y el sistema operativo.

Figura 1. Relación de los hilos del kaffe con el sistema operativo

Paso 7: Inicio de la máquina virtual

Se espera que Kaffe sea compilado para un sistema operativo basado en UNIX
o en DOS y que sea invocado desde la línea de comandos, usualmente con un
parámetro que dice cual clase JAVA ejecutar primero. Pero como se quiere
usar el kaffe en un sistema embebido, se necesitará una manera menos
dinámica de iniciar la máquina virtual y algún mecanismo para pasar la clase
JAVA inicial. La inicialización se puede lograr con una llamada a la rutina
initializeKaffe().

Una vez que el “Kaffe runtime enviroment” ha sido inicializado, el sistema está
listo para ejecutar archivos JAVA.

3. CROSS-COMPILACION E INSTALACION DE KAFFE EN EL

SISTEMA DE DESARROLLO I.MXL

3.1 cross-compilación

La idea básica de la cross-compilación es usar algún procesador, comúnmente

llamado HOST, para compilar software que va a ejecutarse en otro procesador,
comúnmente llamado TARGET que usa una arquitectura diferente a la que usa
HOST. Esto significa que el software no puede ejecutarse en la máquina en
que se compila. El software es compilado para otro procesador. Ésta es la
principal característica de la cross-compilación.

10
3.2 Herramientas y dispositivos:
Generalmente se usa la cross-compilación cuando se quiere compilar
programas para dispositivos móviles como PDA o alguna otra máquina
pequeña que tiene un lento procesador principal.

Scratchbox: El Scratchbox es un ambiente en el que el usuario ingresa cuando

se encuentra en una máquina corriendo el sistema operativo Linux. Aunque, las
herramientas del Scratchbox pueden ser usadas dentro o fuera del ambiente
Scratchbox. Usando las herramientas fuera es lo mismo que usar cualquier
herramienta que el computador tenga. Es la forma normal de cross-compilar, la
nueva forma de cross-compilar es dentro del ambiente Scratchbox.

Instalación del Scratchbox: Para instalar el Scratchbox se debe descargar el

paquete de su página oficial [13], después descomprimirlo en el directorio que
se desee, y ejecutar el comando ./run_me_first.sh. En la página
http://www.scratchbox.org/documentation/user/scratchbox-1.0/html/tutorial.html,
se encuentran las instrucciones necesarias para la instalación del Scratchbox.

3.3 Descripción de la Interfaz Gráfica a Utilizar

Nano-X (Microwindows) - El sistema gráfico Nano-X es un proyecto de código

abierto que va dirigido a brindar las características principales de los sistemas
gráficos modernos para los dispositivos pequeños o de pocos recursos. Nano-X
permite que las aplicaciones sean construidas y probadas en un PC con
sistema operativo Linux, también permite la cross-compilación para un
dispositivo embebido. El sistema gráfico Nano-X era previamente llamado
Microwindows, pero tuvo que ser renombrado debido a problemas con
Microsoft. El Nano-X tiene implementadas dos APIs, una API Win32 y otra API
de Xlib.

Instalación de Nano-X - La descarga del Nano-X es muy sencilla, el paquete

se puede descargar de su página principal [14], como archivos fuentes o como
archivos binarios, Como para el proyecto, el Nano-X debía ser cross-compilado
para su posterior uso en la tarjeta IMXL, se descargaron los archivos fuentes.
El proceso de cross-compilación e instalación del Nano-X no abarca el alcance
de este informe.

3.4 Cross-compilación de la máquina virtual de java: kaffe

El Kaffe se cross-compiló en una máquina con el sistema operativo Linux de la

distribución Mandrake y con un Kernel 2.6.11. El paquete que se compiló fue el
Kaffe-1.1.5 que se puede descargar de la página principal de Kaffe [10]. La
cross-compilación se realizó en el Scratchbox con el sistema gráfico Nano-X.

El directorio root de la compilación, es decir, el directorio dónde se

descomprimió el Kaffe fue: /scratchbox/users/monica/home/monica/kaffe-1.1.5.

11
Los pasos que se siguieron para cross-compilar el Kaffe se dividen en 2 partes;
compilar las librerías por fuera del Scratchbox y cross-compilar el Kaffe dentro
del scratchbox.

La razón por la que las librerías se compilan fuera del scratchbox, es que no
existe un compilador JAVA para la arquitectura ARM, si existiera, la cross-
compilación no se tendría que realizar en dos pasos. Pero las librerías
necesitan ser compiladas con un compilador JAVA, y el compilador JAVA que
se tiene trabaja en la arquitectura del computador personal y no el una
arquitectura ARM.

Los pasos para compilar las librerías por fuera del scratchbox son los
siguientes:

Paso 1:
Situarse en el directorio /scratchbox/users/monica/home/monica/kaffe-1.1.5 y
generar el Makefile con la siguiente instrucción:

./configure --disable-debug --disable-xprofiling --disable-xdebugging --disable-feedback

--without-profiling --without-stats --disable-gcj --enable-pure-java-math --without-esd --
without-alsa --without-kaffe-x-awt --with-kaffe-nanox-awt --without-classpath-gtk-awt --
with-engine=intrp --with-threads=unix-jthreads

Se le deshabilitan algunas opciones en la configuración, para poder hacer la

máquina virtual más liviana, que es uno de los objetivos, puesto que la tarjeta
IMXL no tiene una gran capacidad de memoria.

Paso 2:
Quitar el comentario de la línea 393 al Makefile ubicado en el directorio
/libraries/javalib.

MAYBE_PEERLESS_KAFFE_AWT = awt-implementations

Esto se hace para permitir que la librería awt incluya algunas

implementaciones, como en nuestro caso el Nano-X.

Paso 3:
Exportar las banderas del javac, así:

export JAVAC_FLAGS=

Esta opción sirve para habilitar la variable de banderas del JAVAC.

Paso 4:
Agregar en el archivo Makefile ubicado en la carpeta /libraries/javalib/awt-
implementation/kaffe, lo siguiente:

12
En la línea de las banderas de Java

JAVAC_FLAGS=-g:none -bootclasspath /scratchbox/users/monica/home/monica/kaffe-

1.1.5/libraries/javalib/lib/

Esta línea permite que el compilador encuentre la dirección en que están las
librerías que debe compilar.

Paso 5:
Ingresar al directorio /libraries/javalib y compilar las librerías, mediante los
comandos:

make clean
make

Si vamos bien hasta acá, quiere decir que las librerias compilaron bien, es
decir, el primer gran paso está realizado

Ahora entramos al scratchbox:

Para ingresar al scratchbox, como root: /scratchbox/run_me_first.sh

Luego nos logueamos como usuarios (este usuario debe ser el mismo usuario
que configuramos en el scratchbox):

su monica

/scratchbox/login

Ahora se verán los pasos que hay que dar dentro del scratchbox (cross-
compilación):

Paso 6:
Ingresar al directorio root de kaffe y realizar la siguiente configuración.

./configure --disable-debug --disable-xprofiling --disable-xdebugging --disable-feedback

--without-profiling --without-stats --disable-gcj --enable-pure-java-math --without-esd --
without-alsa --without-kaffe-x-awt --with-kaffe-nanox-awt --without-classpath-gtk-awt --
with-engine=intrp --with-nanox-include=/home/monica/microwindows-0.91/src/include --
with-nanox-library=/home/monica/microwindows-0.91/src/lib --with-rt-
jar=/home/monica/kaffe/libraries/javalib/rt.jar --with-threads=unix-jthreads

Las opciones son las mismas que en el primer configure, con la differencia que
se dan las rutas en las cuales están las librerías del Nano-X (microwindows) y
se le da la ruta del rt.jar, que es un archivo que se genera al compilar las
librerías. Las rutas se dan suponiendo que el microwindows está en el mismo
directorio que el kaffe, es decir en:
/scratchbox/users/monica/home/monica/microwindows-0.91.

13
Paso 7:
Borrar del Makefile principal, es decir, ubicado en
/scratchbox/users/monica/home/monica/kaffe-1.1.5, la línea 405 que dice:

libraries/javalib

Este paso sirve para que el scratchbox no compile las librerías, puesto que
éstas ya fueron compiladas en los pasos anteriores.

Paso 8:
Compilar el paquete, en el mismo directorio /kaffe-1.1.5

make clean
make
make install

Si todos estos pasos no presentan problema, la máquina virtual quedó bien

compilada y se puede empezar a ejecutar aplicaciones en la tarjeta IMXL.

3.5 Pasos para ejecutar un archivo .java en la tarjeta imxl

Cuando ya se haya compilado la máquina virtual de Java para una arquitectura

ARM, se deben seguir los siguientes pasos para ejecutar un archivo en la
tarjeta IMXL (recordemos que la única librería gráfica que puede usar el Kaffe
compilado es AWT):

1. Compilar el archivo .java, en un equipo que tenga la máquina virtual de

JAVA instalada (en un equipo normal, no nos referimos todavía a la
tarjeta IMXL).

2. El archivo .class que se genera en el paso anterior, se incluirá en una de

los directorios de la carpeta kaffe, pues la carpeta kaffe que se generó al
realizar la compilación en el scratchbox, y está ubicada en
/scratchbox/users/monica/targets/mxl/usr/local/, se compartirá mediante
el servicio NFS, con el sistema de archivos de la tarjeta IMXL.

3. Para compartir la carpeta tendremos que entrar primero al Linux en la

tarjeta IMXL y montar mediante NFS la carpeta kaffe1, esto se realiza
mediante el siguiente comando: mount – t nfs
192.168.0.111:/scratchbox/users/monica /mnt/nfs, con lo que en la
carpeta /mnt/nfs del sistema de archivos de la tarjeta IMXL, quedará
compartida la tarjeta que contiene al kaffe en la máquina host, el
directorio se comparte desde más atrás pues también se necesita
compartir el microwindows, para poder ejecutar aplicaciones gráficas,
recoredemos que el microwindows está ubicado en:
/scratchbox/users/monica/home/monica/microwindows-0.91

1
Recuérdese que para que se puedan compartir archivos mediante NFS, se debe levantar éste
servicio, y se debe incluir en el archivo /etc/exports el directorio que se va a compartir.

14
 4. También hay que compartir la carpeta de las librerías del microwindows.
Este proceso se realiza de la misma manera que el descrito en el paso
anterior, se utilizan los siguientes comandos:

nfs –t 192.168.0.111:/scratchbox/users/monica/home/monica/lib /lib

5. Cuando se hayan realizado estos pasos, hay que exportar unas

variables de entorno que especificarán dónde se encuentran las librerías
necesarias para ejecutar un programa JAVA. Los comandos para
exportar las variables son:

export
BOOTCLASSPATH=/mnt/nfs/targets/mxl/usr/local/kaffe/jre/lib/arm/kaffeawt.jar:/
mnt/nfs/targets/mxl/usr/local/kaffe/jre/lib/arm/rt.jar
y
export
BOOTCLASSPATH=/mnt/nfs/targets/mxl/usr/local/kaffe/jre/lib/arm/kaffeawt.jar:/
mnt/nfs/kaffe/jre/lib/arm/rt.jar

6. Después corremos el programa desde la carpeta en que se encuentre

con el ejecutable kaffe-bin ubicado en
/mnt/nfs/targets/mxl/usr/localkaffe/jre/bin. Por ejemplo para ejecutar un
programa llamado HolaMundo que está ubicado en la carpeta
/mnt/nfs/kaffe/bin:

/mnt/nfs/targets/mxl/usr/localkaffe/bin$
/mnt/nfs/targets/mxl/usr/localkaffe/jre/bin/kaffe-bin HolaMundo

Esto en caso de que no sea una aplicación gráfica, si la aplicación es

gráfica pasemos al paso 7.

7. Para ejecutar una aplicación gráfica hay, en primer lugar, que iniciar el
Nano-X y el nanowm, esto se realiza ubicados en el directorio
/mnt/nfs/home/monica/microwindows-0.91/src/bin mediante los
comandos:

$ nano-X
$ nanowm

8. Después de que estos servicios estén iniciados se procede a ejecutar la

aplicación mediante el siguiente comando:

/mnt/nfs/targets/mxl/usr/localkaffe/bin$
/mnt/nfs/targets/mxl/usr/localkaffe/jre/bin/kaffe-bin -
Dkaffe.awt.nativelib=nanoxawt example

4. AGRADECIMIENTOS

Agradecemos la asesoría y la gran colaboración proporcionada por Guillaume

Boutillier del grupo REDS (Reconfigurable & Embedded Digital System) de
HEIG-VD, Haute Ecole d'Ingénierie et de Gestion du Canton de Vaud- Suiza.

15
5. REFERENCIAS

[1] Página principal de pitón.URL: http://www.python.org

[2] Python/XML Home. URL: http://pyxml.sourceforge.net/topics/

[3] Python for Mobile Devices. URL: http://www.awaretek.com/pymo.html

[4] Módulos Phyton para el manejo Multimedia.

URL: http://www.pymedia.org/tut/index.html

[5] Versión Jython. URL: http://jython.sourceforge.net/

[6] Phyton en sistemas embebidos. URL:

http://ciberjacobo.com/en/linux_on_ipod.html

[7] Sun Microsystems. URL: http://www.sun.com

[8] Java 2 Micro Edition. URL: http://java.sun.com/javame/index.jsp

[9] How to Implement a Java Virtual Machine.

URL: http://www.netrino.com/Articles/KaffeAnyone/

[10] Sitio oficial de Kaffe. URL: http://www.kaffe.org

[11] Freedom for Media in Java. URL: http://fmj.sourceforge.net/

[12] Tutorial scratchbox.

URL: http://www.scratchbox.org/documentation/user/scratchbox-
1.0/html/tutorial.html

[13] Página oficial Scratchbox. URL: http://www.scratchbox.org

[14] Página oficial nano-X. URL: http://www.microwindows.org/

16