Creación del sistema embebido Linux optimizado para la Raspberry Pi

¿Por qué desarrollar un sistema embebido y no utilizar Raspbian o cualquier otro sistema operativo ya creado para la Raspberry?

La principal razón para ello es que cualquiera de estas distribuciones tienen instalados muchos paquetes que no nos serán necesarios, no disponen de las suficientes librerías cruzadas (que son las que nos permiten programar y compilar desde una maquina más potente, y luego ejecutar los programas en la propia placa, en este caso la RPI),  son más lentas a la hora de arrancar y consumen más recursos, entre ellos más memoria, bastante preciada en este tipo de sistemas. Por ello es más efectivo implementar un sistema embebido Linux, que optimice nuestra aplicación sobre la Raspberry.

Por tanto ahora, y antes de detallar los pasos a seguir para crear el sistema desde 0, ¿qué es un sistema embebido?

Un sistema embebido es un sistema informático y/o electrónico desarrollado para realizar una única función o pocas funciones específicas,  y generalmente con un uso en tiempo real. En el caso concreto de Linux, al ser de código abierto nos aporta una serie de ventajas o libertades:

  • Libertad de hacer funcionar el software para cualquier propósito.
  • Libertad de estudiarlo y modificarlo.
  • Libertad de distribuir tantas copias como se quiera, sin tener que pagar por ello.
  • Libertad de redistribuir copias de una versión modificada.

Por todas estas ventajas, los sistemas embebidos o empotrados están presentes en muchas de las cosas que nos rodean, como los televisores, los routers personales, o lectores de tarjetas, entre otras muchas cosas.

Partes de un sistema embebido:

  1. BSP (Board Support Package), que contiene el kernel de Linux, el bootloader, con los drivers de los dispositivos físicos de la placa a usar.
  2. Aplicaciones
  3. Sistema de integración: que une las dos anteriores, las librerías y las aplicaciones al entorno de trabajo del sistema.

Para el caso de crear un sistema empotrado Linux es altamente recomendable utilizar otra máquina con el mismo sistema operativo, pues nos evitaremos posibles problemas de incompatibilidad con las herramientas, y puesto que lo que sepamos del Linux de escritorio será fácilmente aplicable al dispositivo empotrado.

Para ello, y en caso de no tener un ordenador con Linux, creamos una máquina virtual con programas como VMWare, y le instalamos los siguientes paquetes:

paquetes

Buildroot:

Una vez instalados dichos paquetes utilizaremos una herramienta llamada Buildroot, pues es una buena alternativa para crear distribuciones Linux desde cero para dispositivos empotrados, ya que nos permite crear las distribuciones a partir  del código fuente de los paquetes a utilizar y que ofrece un gran número de posibilidades a la hora de crear distribuciones. Se basa en los comandos make y defconfig para su funcionamiento.

Permite configurar entre otros parámetros, la arquitectura a utilizar, el kernel, el bootloader (en nuestro caso uboot), permite elegir que toolchain va a usarse, si una externa o la suya previa, configurándola como paso previo a la creación de la imagen del kernel. Además nos permite elegir la ABI (Application Binary Interface), en este caso la EABI para ARM. La ABI es la que nos define como se pasan los parámetros a una función, que devuelve, y como se hacen las llamadas al sistema. Además nos permite elegir la versión de Busybox, que es un conjunto básico de programas necesarios para trabajar en cualquier sistema embebido, para manipular ficheros, para configurar el sistema, un programa de inicio, una shell. Busybox es una alternativa que nos permite integrar todo esto en un solo proyecto para que sea más fácil trabajar con ello.

Buildroot ofrece utilidades de configuración tipo Menuconfig, o Xconfig, y además todas las opciones de configuración se encuentran en un único archivo .config que puede utilizarse para recrear una distribución desde cero.

Además ofrece facilidades para añadir paquetes que no se encuentran en la distribución oficial, y genera tanto el sistema de ficheros, como las librerías cruzadas y herramientas necesarias para trabajar con la nueva distribución, evitando problemas de incompatibilidades.

Además nos permite añadir directorios y archivos al sistema de ficheros de la nueva distribución, así como ejecutar scripts de pre y post instalación.

Es totalmente libre, y lo actualizar aproximadamente cada 3 meses. Además está muy bien documentado y existen muchos ejemplos de los que ayudarnos.

Una vez que le hemos indicado al Buildroot nuestra configuración, escribiendo el comando make, esta herramienta prepara el entorno para la compilación, configura los paquetes, los descarga, compila e instala.

Configuración del Kernel de Linux:

En todas las aplicaciones de Linux embebidos, es necesario configurar el kernel con el fin de dar soporte a los diferentes dispositivos físicos y a las aplicaciones del espacio de usuario. Todas las fuentes del kernel proporcionan una configuración básica para plataformas de hardware específicas. Utilizando una plataforma de hardware comercial, probablemente encontraremos una configuración del kernel adecuada, y no tendremos que definirla.

Esta es una tarea difícil pero se puede encontrar cientos de ejemplos en Internet. El Kernel de Linux tiene un directorio con las configuraciones de hardware predefinidas. La ruta relativa es la siguiente: ” ./Documents/buildroot-2013.11/output/build/linux-1587f77/arch/arm/configs”.

Ejecutando make linux-menuconfig obtenemos una ventana de configuración como la siguiente:

kernel_config

Habilitamos las configuraciones de comunicación I2C, SPI, añadimos nuevos argumentos en el bootloader del kernel,  activamos el uso de tarjetas SD entre otros. Con ello guardamos de nuevo las configuraciones y volvemos a realizar un make, y ya deberíamos conseguir que la Raspberry bootease sin problemas.

Preparando la tarjeta SD:

Una vez realizado el make, se generarán en la carpeta buildtroot/output/image los archivos necesarios que hay que copiar en la tarjeta SD. Esta tarjeta debe estar formateada en  el sistema de archivos FAT.

tarSD

A continuación se listaran los archivos necesarios que hay que copiar a la tarjeta SD:

  • scr.uimg: Este archivo es un script para automatizar el proceso del booteado de la RPI. Este fichero no se encuentra en la carpeta image mencionada antes, sino que hay que generarlo. Después se explica este proceso.
  • bin: Es un fichero binario que utiliza la GPU al arrancar.
  • txt: Es un fichero de texto que contiene los parámetros de configuración del kernel de Linux.
  • txt: Es un fichero de texto que contiene los parámetros de configuración de la GPU.
  • dat, fixup_cd.dat y fixup_x.dat: Se utiliza para configurar la memoria RAM para que pueda ser utilizada por la GPU y la CPU. Hay variaciones de este fichero para utilizarlas en diferentes modos de arranque.
  • ext2, rootfs.ext2.gz y rootfs.tar: Estos los archivos del sistema Linux. Contiene todas las capetas y archivos del S.O. embebido que se está montando. El archivo con extensión .ext2 indica que los archivos están montados en el sistema de ficheros ext2, comúnmente utilizado en sistemas operativos basados en UNIX/LINUX. El fichero acabado en .gz es el mismo que el del extensión .ext2, solo que este está comprimido. El fichero .tar contiene los mismos ficheros del sistema operativo, pero estos están sin montar en ext2.
  • elf, start_cd.elf y start_x.elf: Es el binario que la GPU utiliza para arrancar la CPU. Existen variaciones de este fichero para poder arrancar en varios modos distintos.
  • u-boot.bin: Es el binario que utiliza la CPU para cargar la imagen del kernel de Linux.
  • uImage: Es el kernel de Linux.

Antes de copiar el fichero config.txt hay que modificar un parámetro, de modo que lo abrimos con un editor de texto plano y modificamos la línea del kernel=uImage, dejándolo como se indica en la siguiente imagen:

configtxt

Preparando script de booteo (boot.scr.uimg):

Ahora se va a preparar el script encargado del proceso del booteo de la RPI. Este script es necesario porque en el arranque hay que introducir una  serie de comandos, y de esta manera este proceso queda totalmente automatizado.

  1. En la carpeta de buildroot, hay que crear un fichero de texto llamado boot_mmc.txt. En su interior se introducen las líneas tal y como se muestran en la siguiente imagen.boot_mmc
  2. Una vez guardado el fichero boot_mmc.txt abrimos una consola de comandos y nos dirigimos a la carpeta de buildroot con el comando cd. Una vez hecho esto basta con escribir el siguiente comando:

mkimage -A arm -O linux -T script -C none -a 0 -e 0 -n “RaspBerry Pi” -d boot_mmc.txt boot.scr.uimg

Con ello se creara un fichero llamado boot.scr.uimg, que contiene el script  hecho antes…

  1. Ahora solo hay que coger el fichero boot.scr.uimg y copiarlo a la tarjeta SD con los demás archivos.

Los comandos introducidos en este script son los siguientes:

  • mmc rescan: comprueba que hay una tarjeta de memoria SD en la RPI.
  • mmc list: este comando lista los archivos que hay en la tarjeta SD.
  • setenv bootargs console=ttyAMA0,115200n8 root=/dev/ram rw ramdisk_size=16384 initrd=0x02000000,16M: En estas líneas se indica que la consola se comunicará por el puerto serie utilizando una velocidad de 115200 baudios/s y que los archivos del sistema estarán cargados en la memoria RAM de la RPI.
  • init=/sbin/init: se indica el primer proceso que se ejecuta cuando se inicia el sistema operativo.
  • fatload mmc 0 0x01000000 uImage: con este comando se carga la imagen del kernel de Linux en la memoria RAM.
  • fatload mmc 0 0x02000000 rootfs.ext2.gz: ahora se carga n los archivos del sistema operativo a la memoria RAM.
  • bootm 0x01000000: inicia el boot.

COMPILACIÓN CRUZADA:

Es la forma de compilar una aplicación en un hardware remoto. Este tipo de compilación es utilizado para dispositivos como la RPI, ya que permite utilizar las herramientas que ofrece un ordenador potente para la construcción de la aplicación que luego se ejecutará en un hardware distinto. En nuestro caso, utilizamos la máquina con el sistema operativo Ubuntu para realizar las aplicaciones, pero a la hora de compilar, los binarios se crean para el hardware de la RPI, de manera que no vamos a poder ejecutar la aplicación en el PC.

compilacion Cruzada

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s