Para aquellos curiosos de los sistemas empotrados, he encontrado un HOWTO sobre OpenEmbedded mucho más actualizado que el que yo escribí y donde, además, se aportan muchas más cosas.

Podéis entrar a echar un vistazo en el OpemEmbedded HowTo de Werner Schulte.

También os podéis pasar por el wiki de OpenZaurus, que siempre hay cosas interesantes.

A mi me gusta bastante. ¿Y a vosotros?

PD: Sí, ya sé que es del 18 de Mayo la noticia. ¿No dije que hacía mucho tiempo que no me pasaba por allí?

1-. Introducción:

Durante algún tiempo he estado trabajando con Bitbake/OpenEmbedded, entre otras cosas porque la distribución para mi PDA (una Sharp Zaurus SL-5500 Collie) no se actualiza normalmente, así que decidí utilizar OpenEmbedded para compilar mi propia versión de OpenZaurus.

Bitbake es la herramienta para construir los paquetes. Es algo parecido a “emerge” para aquellos que hayáis utilizado Gentoo.

OpenEmbedded son los ficheros que indican cómo deben construirse los paquetes, es decir, los metadatos.

Por tanto, para poder conseguir una versión actualizada, necesitamos instalar ambas herramientas.

2-. Preparando el sistema:

Lo primero que tenemos que hacer es instalar Bitbake. Para ello tenemos que descargarlo desde los servidores de subversion donde se aloja.

Por tanto tendremos que instalar subversion:

[code] $ sudo apt-get install subversion [/code]

NOTA: Subversion es un sistema de control de versiones utilizado en muchísimos proyectos de software libre.

Una vez instalado ya podremos descargar Bitbake, pero eso lo veremos más adelante.

Por otro lado para poder trabajar con OpenEmbedded hay que conectar a los repositorios donde se encuentra. Para ello debemos instalar Monotone, que es el sistema de versiones con el que trabajan.

Para descargar Monotone accedemos a [1], donde podremos descargar la última versión.

En mi caso utilizo Ubuntu, y en el sitio de Monotone hay paquetes .deb para instalar la última versión. En el momento de escribir este documento se encuentra en la versión 0.22.

¡Vamos a instalar Monotone!

Primero crearemos un directorio para descargar los paquetes .deb:

[code]
$ sudo mkdir /root/monotone/
[/code]

Ahora lo descargamos:

[code]
$ sudo wget http://venge.net/monotone/downloads/ubuntu-0.22/libboost-date-time1.32.0_1.32.0-6_i386.deb /root/monotone/

$ sudo wget http://venge.net/monotone/downloads/ubuntu-0.22/libboost-filesystem1.32.0_1.32.0-6_i386.deb /root/monotone/

$ sudo wget http://venge.net/monotone/downloads/ubuntu0.22/libboost-regex1.32.0_1.32.0-6_i386.deb /root/monotone/

$ sudo wget http://venge.net/monotone/downloads/ubuntu-0.22/monotone_0.22-0.1_i386.deb /root/monotone/
[/code]

NOTA: Si os fijáis, aparte de Monotone hay 3 ficheros de libboost. Esta es una librería de ayuda para programar en C++ que utilizan los chicos de Monotone y que nos sirven ya precompilada. Todo un detalle, ya que si no tendríamos que compilarla nosotros a mano.

Una vez hayamos descargado los archivos podemos proceder a instalarlos:

[code]
$ sudo dpkg -i /root/monotone/*.deb
[/code]

Con esto instalaremos tanto las tres partes de la librería libboost como Monotone.

NOTA: Sí, es una lata tener que instalar tanto Subversion como Monotone

3-. Instalando las dependencias de OpenEmbedded

Antes de descargar el repositorio de OpenEmbedded nos vamos a asegurar que disponemos de todas las dependencias.

Para ello ejecutamos el siguiente comando:

[code]
$ sudo apt-get install python python-dev python-psyco ccache patch m4 sed \
bison make wget bzip2 cvs gawk libc6-dev g++ subversion sharutils coreutils \
docbook openjade quilt libmpfr-dev libpcre3-dev unzip
[/code]

Tened en cuenta que muchas de las dependencias ya las tendremos instaladas. De todas formas, esto puede tardar un rato en terminar, así que es momento de ir a tomar un café =)

4-. Preparando los directorios

Vamos a crear un directorio que nos sirva como base para instalar cada una de las cosas.

En mi caso lo he llamado OpenEmbedded y está ubicado en mi directorio home:

[code]
$ mkdir OpenEmbedded
$ cd OpenEmbedded
[/code]

NOTA: En este directorio instalaremos tanto OpenEmbedded como Bitbake, aunque por comodidad le haya llamado sólo OpenEmbedded.

5-. Instalando Bitbake

Como ya hemos dicho antes, Bitbake es la herramienta encargada de construir los paquetes, así que tenemos que instalarla.

Nos vamos a crear un directorio donde instalarla

[code]
$ mkdir bitbake
[/code]

Y luego lo vamos a descargar

[code]
$ svn co svn://svn.berlios.de/bitbake/trunk/bitbake
[/code]

NOTA: No es necesario compilar nada, ya que son todo scripts en Python.
NOTA: No es necesario estar dentro del directorio bitbake, ya que se descarga dentro de él los ficheros y no en el directorio actual.

Finalmente, para poder ejecutar Bitbake es necesario añadir los binarios al PATH

[code]
$ export PATH=${PATH}:~/OpenEmbedded/bitbake/bin/
[/code]

4-. Obteniendo el árbol desde el repositorio

El siguiente paso es obtener OpenEmbedded en sí, tanto Bitbake (que se encarga de construir paquetes) como los ficheros de metadatos (que se encargan de decir cómo deben construirse los paquetes).

Lo primero que haremos serác crear un directorio donde guardar la base de datos de Monotone y el árbol de OpenEmbedded:

[code]
$ mkdir OpenEmbedded
$ cd OpenEmbedded
[/code]

Para obtener la base de datos completa lo mejor es descargar un snapshot reciente. Para ello ejecutaremos el siguiente comando:

[code]
$ wget http://ewi546.ewi.utwente.nl/OE/OE.db.bz2
[/code]

El sitio desde donde lo descargamos es el sitio que indican en el wiki. El fichero descargado contiene la base de datos de Monotone.

Una vez lo hayamos descargado lo descomprimiremos con bunzip2:

[code]
$ bunzip2 OE.db.bz2
[/code]

Y renombraremos el fichero a oe.db, ya que está en mayúsculas el que nos pasan:

[code]
$ mv OE.db oe.db
[/code]

Finalmente, tenemos que obtener las últimas modificaciones al repositorio, ya que desde que subieron el fichero que nos descargamos hasta que nos lo descargamos nosotros hayan actualizado algunas cosas.

Para ello ejecutamos la siguiente linea (puede tardar un poco!):

[code]
$ monotone --db=oe.db pull monotone.vanille.de org.openembedded.{dev,dreambox,oz354fam083}
monotone: doing anonymous pull; use -kKEYNAME if you need authentication
monotone: connecting to monotone.vanille.de
monotone: finding items to synchronize:
monotone: certs | keys | revisions
monotone: 8934 | 32 | 2317
monotone: bytes in | bytes out | certs in | revs in | revs written
monotone: 523.0k | 119.5k | 608 | 121 | 1
monotone: verifying new revisions (this may take a while)
monotone: bytes in | bytes out | certs in | revs in | revs written
monotone: 1.8M | 126.3k | 608 | 121 | 121
monotone: successful exchange with monotone.vanille.de
[/code]

¡Bien! ¡Ahora ya tenemos la base de datos de Monotone sincronizada!

Aún tenemos que descargar el árbol de ficheros. Para ello utilizamos el comando siguiente:

[code]
$ monotone --db=oe.db checkout --branch=org.openembedded.oz354fam083
[/code]

Se nos creará un directorio para cada versión como véis a continuación:

[code]
$ ls -l
total 176168
-rw-r--r-- 1 kraptor kraptor 180204544 2005-09-28 01:55 oe.db
drwxr-xr-x 9 kraptor kraptor 304 2005-09-28 02:05 org.openembedded.oz354fam083
[/code]

NOTA: En este caso, como vamos a trabajar con la versión 3.5.4 de OpenZaurus solo vamos a descargar una rama. Si queréis, podéis trastear con la versión en desarrollo.

Ok, ya tenemos el repositorio de OpenEmbedded “casi” listo para trabajar.

5. Instalando ZGCC 2.95.3

Algunos os preguntaréis: “¿Para qué? ¿No es posible utilizar el gcc que ya tengo instalado?”

La respuesta es sí y no.

Sí, realmente se utiliza el GCC que viene instalado en el sistema (realmente lo que se hace es usar este GCC para compilar un ZGCC 3.x que es con el que se compilarán los paquetes para la Zaurus).

No, no se compila todo con el ZGCC que compila automáticamente OpenEmbedded. Necesitamos la versión 2.95.3 porque el kernel que utiliza la Zaurus (los modelos SL-5000 y SL-5500) es el 2.4.18 y sólo compila con esta versión de GCC.

Así que ya sabéis, se compilará todo con la versión 3.x excepto el kernel y es por ello que voy a instalar este cross-compiler en mi sistema.

Si tenéis la una Zaurus más nueva seguramente no necesitaréis esto, ya que las nuevas versiones compilan un kernel 2.6. Se está haciendo trabajo, de todas formas para conseguir un kernel 2.6 para las versiones 5000 y 5500, pero todavía están desarrollándolo. Más información sobre el kernel 2.6 para Poodle y Collie aquí: http://www.cs.wisc.edu/~lenz/zaurus/

¡Esperemos que dentro de poco podamos disfrutar del kernel 2.6!

Bien, para instalar el kernel lo primero que vamos a hacer es descargar uno ya precompilado por los chicos de OpenEmbedded.

Para ello tendremos que instalarlo como super-usuario:

[code]
$ sudo su -
Password:
[/code]

Lo descargamos:

[code]
$ wget http://handhelds.org/download/projects/toolchain/archive/cross-2.95.3.tar.bz2
--02:34:07-- http://handhelds.org/download/projects/toolchain/archive/cross-2.95.3.tar.bz2
=> `cross-2.95.3.tar.bz2'
Resolviendo handhelds.org... 192.58.209.90
Conectando con handhelds.org[192.58.209.90]:80... conectado.
Petición HTTP enviada, esperando respuesta... 200 OK
Longitud: 36,273,634 [application/x-bzip2]

100%[====================================>] 36,273,634 103.12K/s ETA 00:00

02:39:52 (102.78 KB/s) - `cross-2.95.3.tar.bz2' saved [36,273,634/36,273,634]
[/code]

Y lo descomprimimos en /usr/local/arm:

[code]
$ mkdir /usr/local/arm/
$ tar xjvf cross-2.95.3.tar.bz2 --directory=/usr/local/arm/
[/code]

NOTA IMPORTANTE: Tiene que ser /usr/local/arm/ y no otro, ya que este zgcc busca las librerías en ese directorio y sólo en ese directorio, ya que es el directorio donde el autor original lo compiló. Si no se instala aquí, olvidáos de poder compilar con él.

Bien, ya tenemos instalado el compilador necesario para poder compilar los kernel 2.4.18. Más adelante ya configuraremos OpenEmbedded para indicarle que haga uso de este compilador para el kernel.

Una última modificación. Los binarios del compilador se llaman arm-linux-gcc y arm-linux-ld. Para que OpenEmbedded sea capaz de encontrarlos tenemos que añadir la versión como apéndice al nombre. Para ello:

[code]
$ mv /usr/local/arm/2.95.3/bin/arm-linux-gcc /usr/local/arm/2.95.3/bin/arm-linux-gcc-2.95
$ mv /usr/local/arm/2.95.3/bin/arm-linux-ld /usr/local/arm/2.95.3/bin/arm-linux-ld-2.11.2
[/code]

Después de esto, ya podemos abandonar la cuenta de superusuario y volver al directorio de trabajo de OpenEmbedded:

[code]
$ exit
logout
$
[/code]

6. Configurando OpenEmbedded

Lo primero que tenemos que hacer es asegurarnos que estamos en el directorio base de OpenEmbedded:

[code]
$ cd ~/OpenEmbedded/
[/code]

Vamos a crear un directorio donde se realizarán todas las compilaciones:

[code]
$ mkdir build-oz354
[/code]

Antes de continuar, vamos a crear el directorio donde Bitbake (la herramienta de OpenEmbedded encargada de construir los programas) debe descargar los ficheros fuente de los programas:

[code]
$ mkdir sources
[/code]

Después vamos a crear el directorio de configuración:

[code]
$ mkdir build-oz354/conf
[/code]

Vamos a hacer un pequeño inciso de cómo deben quedar los directorios. La estructura, tal y como hemos ido creándola es la siguiente:

[code]
${HOME}
|
+- OpenEmbbedded
|
+- build-oz354
| |
| +- conf
|
+- org.openembedded.org
|
+- org.openembedded.oz354fam083
|
+- sources
[/code]

Lo primero que tenemos que hacer es crear la configuración local. Para ello vamos a utilizar un esqueleto de ejemplo que está dentro de la versión que queremos obtener.

En mi caso, como es la versión en 3.5.4 lo copiaremos dentro de /build-354/conf:

[code]
$ cp org.openembedded.dev/conf/local.conf.sample build-oz354/conf/local.conf
[/code]

NOTA: Fijáos que el original se “apellida” .sample porque es un ejemplo. En cambio el fichero de configuración debe llamarse “local.conf”

Ahora es momento de editar el fichero para configurarlo a nuestro gusto:

[code]
$ vim build-oz354/conf/local.conf
[/code]

Es importante leer todas las anotaciones, aunque aquí vamos a comentar cómo configurarlo para la Zaurus SL-5500 (Collie).

Primero editaremos la variable DL_DIR, que se encarga de decir dónde se van a descargar nuestros ficheros fuente. Para ello vamos a utilizar el directorio que hemos creado para ello:

[code]
DL_DIR = "${HOME}/OpenEmbedded/sources/"
[/code]

Luego cambiaremos BBFILES para que apunte a los metadatos de los paquetes. Éstos se encuentran dentro de los directorios “org.openembedded.*/packages/*/*.bb”. Para ello, como estoy con la versión desarrollo:

[code]
BBFILES := "${HOME}/OpenEmbedded/org.openembedded.dev/packages/*/*.bb"
[/code]

NOTA: Sí, es un “:=”. Esto indica a python que la línea es única.

Como tengo una SL-5500 y voy a crear un kernel 2.4.18 entonces debo descomentar la linea ASSUME_PROVIDED y dejarla así:

[code]
ASSUME_PROVIDED = "virtual/arm-linux-gcc-2.95"
[/code]

Esto indica a Bitbake que busque el compilador que hemos instalado antes para crear los kernels 2.4.

¿Ya os he dicho que tengo una SL-5500? Seguro que sí, pero lo tenemos que indicar en el fichero de configuración:

[code]
MACHINE = "collie"
[/code]

Para compilar una OpenZaurus lo indicamos en DISTRO. También tenemos que poner TARGET_OS a “linux”

[code]
TARGET_OS = "linux"
DISTRO = "openzaurus-3.5.4"
[/code]

Finalmente, hay que comentar (o borrar) la última línea. Está puesta porque lo autores de OpenEmbedded quieren que nos leamos bien el fichero =) Yo he optado por comentarla como muestro a continuación:

[code]
#REMOVE_THIS_LINE:="${@oe.fatal('Read the comments in your conf/local.conf')}"
[/code]

Con esto (y un bizcocho) ya tenemos preparado OpenEmbedded.

7. Estableciendo las variables de entorno

Finalmente tenemos que establecer las variables de entorno para poder trabajar con OpenEmbedded. Esto es necesario para que nuestro shell sea capaz de encontrar los binarios de Bitbake.

Para ello necesitamos:

a) Añadir al PATH el compilador que instalamos:

[code]
export PATH="${PATH}:/usr/local/arm/2.95.3/bin/"
[/code]

b) Exportar BBPATH con la información correcta

[code]
export BBPATH="~/OpenEmbedded/build-dev/:~/OpenEmbedded/org.openembedded.dev/"
[/code]

c) Exportar los binarios de Bitbake al path

[code]
export PATH="${PATH}:~/OpenEmbedded/bitbake/bin/"
[/code]

8. Compilando paquetes y creando imágenes

Para empezar vamos a compilar un paquete. El primero que compilemos tardará bastante. Esto es porque la primera vez se compilan el cross-compiler (vamos, el gcc que compilará lo demás) y para ello también se tiene que compilar glibc y todas las dependencias de paquetes. Es por ello que no nos tenemos que desanimar cuando nos pongamos a compilar el primer paquete.

NOTA: Es muy importante estar siempre dentro del directorio build-* que hayamos creado para la rama para la que vamos a compilar los paquetes. En este caso, como vamos a compilar paquetes para OpenZaurus 3.5.4 trabajaremos dentro del directorio /oz354/

Empecemos por algo sencillo:

[code]
bitbake nano
[/code]

Con esto construiremos el paquete IPK con el editor nano así como todas sus dependencias.

Ahora probemos algo más complicado:

[code]
bitbake gpe-image
[/code]

¡Wow! ¡¡Con esto creamos una imagen completa basada en GPE!! Pero le cuesta un buen rato =) Tened en cuenta que crea todas las dependencias así como la imagen, y GPE (al igual que Opie) es un paquete complejo con muchísimas dependencias.

La lista de programas que podéis compilar están en org.openembedded.dev/packages/*/*.bb

¡Ale! A compilar que son dos días (nunca mejor dicho).

A-. Apéndice de enlaces:

[1] http://venge.net/monotone/

B-. Licencia



This work is licensed under a Creative Commons Attribution-NoDerivs2.5 License.

Gracias a un comentario de Mimecar descubro InnerZaurus.com. Aunque está empezando es muy interesante y está en castellano. Poco a poco va llenándose de contenidos.

¡Un saludo desde aquí a sus webmasters! Seguid así.

Con dos días de retraso debido al fin de semana y gracias a un comentario de mozz me entero de la salida de OpenZaurus 3.5.4RC1. Ya podéis descargarla desde aquí.

A ver si la pruebo durante esta semana. Mientras tanto podéis leer un pequeño análisis aquí.

Como ya comenté en otro post, estoy preparando un documento en el que explico cómo configurar, actualizar y generar distribuciones (en este caso OpenZaurus 3.5.4) con OpenEmbedded (realmente habría que decir BitBake). Si puedo, también aprovecharé para explicar cómo compilar nuestras propias aplicaciones para la Zaurus y daré una visión general de cómo funciona el sistema de paquetes IPK.

La razón del retraso es que actualmente hay muchos paquetes rotos en OpenEmbedded y, hasta que no consiga compilar una imagen con GPE y otra con OPIE preinstalados (y con un poco de suerte con E17), no daré el tutorial por finalizado.

Tendréis que esperar un poco más. Perdonad las molestias.