Grupo 1 Programación Distribuida - ASTROINGENIERIA/ASTROUFRO GitHub Wiki

Integrantes

  • Eduardo Queupumil
  • Sebastian Diez

Imagen Yocto para el Raspberry Pi

Se realizo la instalación de un sistema básico para una raspberrypi3 con la rama de poky-sumo(ultima versión disponible) a través del sistema operativo Debían.

Requerimientos de la maquina host

  • Debian 9.0 Stretch.
  • Equipo que soporte en.US-UTF8.
  • Paquetes necesarios: git 1.7.8(mínimo), gawk, tar1.24 ,python 2.7.3(mínimo, pero no 3.x por que no es soportado), sudo.
  • 50 Gb de espacio disponible en el disco.

Procedimiento

Creación de Directorios

  • Ejecutamos el siguiente comando, el cual descarga los paquetes de Yocto Project con el que trabajaremos para la creación de la imagen que quemaremos.
 $ sudo apt-get install gawk wget git-core diffstat unzip texinfo gcc-multilib \
     build-essential chrpath socat libsdl1.2-dev xterm
  • Clonamos los repositorios con los que trabajaremos para la creación de la imagen

~# git clone -b sumo git://git.yoctoproject.org/poky.git poky-sumo

  • Y agregamos las dependencias que ocuparemos
~$ cd poky-sumo
~/poky-sumo$ git clone -b sumo git://git.openembedded.org/meta-openembedded
~/poky-sumo$ git clone -b sumo https://github.com/meta-qt5/meta-qt5
~/poky-sumo$ git clone -b sumo git://git.yoctoproject.org/meta-security
~/poky-sumo$ git clone -b sumo git://git.yoctoproject.org/meta-raspberrypi
~/poky-sumo$ git clone –b master git://github.com/zeroc-ice/meta-zeroc.git
  • Creamos un repositorio para almacenar y compilar la imagen
~$ mkdir ~/rpi
~$ cd ~/rpi

Y ejecutamos una clonacion para descargar los metas ya preestablecidos para raspberrypi3.

~/rpi$ git clone -b sumo git://github.com/jumpnow/meta-rpi

E inicializamos el script oe-init-build-env para inicializar los directorios de compilación.

~/rpi$ cd ~
~$ source poky-sumo/oe-init-build-env ~/rpi/build

Customizamos los ficheros de configuracion

Copiamos desde meta-rpi/conf a build/conf

~$ cd rpi
~/rpi$ cp meta-rpi/conf/local.conf.sample build/conf/local.conf
~/rpi$ cp meta-rpi/conf/bblayers.conf.sample build/conf/bblayers.conf
  • Editamos los ficheros de configuracion BBlayers.conf Añadimos los metas correspondientes a los archivos de configuración, bibliotecas de python, perl, conexión de red, entre otros mas.
# POKY_BBLAYERS_CONF_VERSION is increased each time build/conf/bblayers.conf
# changes incompatibly
POKY_BBLAYERS_CONF_VERSION = "2"

BBPATH = "${TOPDIR}"
BBFILES ?= ""

BBLAYERS ?= " \
    ${HOME}/poky-sumo/meta \
    ${HOME}/poky-sumo/meta-poky \
    ${HOME}/poky-sumo/meta-openembedded/meta-oe \
    ${HOME}/poky-sumo/meta-openembedded/meta-multimedia \
    ${HOME}/poky-sumo/meta-openembedded/meta-networking \
    ${HOME}/poky-sumo/meta-openembedded/meta-perl \
    ${HOME}/poky-sumo/meta-openembedded/meta-python \
    ${HOME}/poky-sumo/meta-qt5 \
    ${HOME}/poky-sumo/meta-raspberrypi \
    ${HOME}/poky-sumo/meta-security \
    ${HOME}/rpi/meta-rpi \
    ${HOME}/poky-sumo/meta-zeroc \
"

local.conf En la opción del tipo de sistema embebido que ocuparemos, seleccionamos raspberrypi3

# Choose the board you are building for
#MACHINE="raspberrypi"
#MACHINE="raspberrypi0"
#MACHINE="raspberrypi0-wifi"
#MACHINE="raspberrypi2"
MACHINE = "raspberrypi3"
#MACHINE="raspberrypi-cm"
#MACHINE="raspberrypi-cm3"

Añadimos al final del fichero, los layers de zeroc-ice.

IMAGE_INSTALL_append = " zeroc-ice zeroc-ice-python"
Preferred_Version_zeroc-ice="3.7.1"

NO modificaremos las configuracion TMPDIR, DL_DIR, SSTATE_DIR y los dejaremos con las propiedades por DEFAULT.

Lo que si podemos modificar es

INHERIT += "extrausers"
EXTRA_USERS_PARAMS = "usermod -P jumpnowtek root; "

donde creamos un usuario preferente, "root" con la contraseña "jumpowtek". podemos comentar estas dos lineas y escribir EXTRA_IMAGE_FEATURES = "debug-tweaks" para dejar a los usuarios sin contraseñas, quedando de la siguiente forma:

EXTRA_IMAGE_FEATURES = "debug-tweaks"
#INHERIT += "extrausers"
#EXTRA_USERS_PARAMS = "usermod -P jumpnowtek root; "

Ejecución de la compilación

Desde el directorio home ejecutamos el comando

~$ source poky-sumo/oe-init-build-env ~/rpi/build

el cual nos desplegara el siguiente menu de opciones:

### Shell environment set up for builds. ###

You can now run 'bitbake '

Common targets are:
    core-image-minimal
    core-image-sato
    meta-toolchain
    meta-toolchain-sdk
    adt-installer
    meta-ide-support

You can also run generated qemu images with a command like 'runqemu qemux86'
~/rpi/build$

En el cual podremos seleccionar el tipo de imagen que queremos compilar, nosotros compilaremos con comando distinto a todos los indicados en Common Targets are:, ejecutaremos:

~/rpi/build$ bitbake console-image

El cual es una imagen sin ambiente de escritorio, pero mas completa a la core-image-minimal.

-Si en el caso de que sucedan errores al momento de compilar la imagen, tanto por errores de bibliotecas o descargs fallidas, ejecutamos los comandos:

~/rpi/build$ bitbake -c cleansstate zip
~/rpi/build$ bitbake zip

y repetimos la compilacion de la imagen:

~/rpi/build$ bitbake console-image

Si los pasos anteriores se realizaron correctamente y no se modifico la configuración de TMPDIR, la imagen habrá sido almacenada en:

~/rpi/buil/temp

Reconociendo y preparando la tarjeta SD.

Ejecutamos el siguiente comando desde la terminal, para identificar la SD ademas de las particiones que posee:

lsblk

y nos mostrara los discos y particiones de cada uno, hay que tener presente, que si la tarjeta a sido introducida por el lector para tarjetas integrado del computador nos mostrara algo parecido a :

NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda           8:0    0 931.5G  0 disk 
├─sda1        8:1    0   450M  0 part 
├─sda2        8:2    0   100M  0 part /boot/efi
├─sda3        8:3    0    16M  0 part 
├─sda4        8:4    0 688.5G  0 part 
├─sda5        8:5    0   931M  0 part 
├─sda6        8:6    0 233.6G  0 part /
└─sda7        8:7    0   7.9G  0 part [SWAP]
mmcblk0     179:0    0  29.1G  0 disk 
├─mmcblk0p1 179:1    0  43.2M  0 part 
└─mmcblk0p2 179:2    0  14.4G  0 part

siendo mmcblk0 nuestra tarjeta SD, y si se lee con un adaptador MicroSD-USB nos mostrara algo semejante a:

NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda      8:0    0 931.5G  0 disk 
├─sda1   8:1    0   450M  0 part 
├─sda2   8:2    0   100M  0 part /boot/efi
├─sda3   8:3    0    16M  0 part 
├─sda4   8:4    0 688.5G  0 part 
├─sda5   8:5    0   931M  0 part 
├─sda6   8:6    0 233.6G  0 part /
└─sda7   8:7    0   7.9G  0 part [SWAP]
sdb      8:16   1  29.1G  0 disk 
├─sdb1   8:17   1  43.2M  0 part
└─sdb2   8:18   1  14.4G  0 part

Teniendo en cuenta que ahora nuestra tarjeta SD se monta como sdb, se recomienda montar la SD de la ultima forma indicada(MicroSD-USB) ya que sera mas fácil copiar los archivos y montar las particiones.

Nos dirigiremos al directorio ~/rpi/meta-rpi/scripts para ejecutar los scripts necesarios para quemar la imagen.

Ejecutaremos el script mk2part.sh {SD} para formatear la tarjeta SD y crear 2 particiones, que son las necesarias para que sea reconocida por una tarjeta SD.

~$ cd ~/rpi/meta-rpi/scripts
~/rpi/meta-rpi/scripts$ sudo ./mk2parts.sh sdb

Creando un punto de montaje

Creamos un punto de montaje donde podremos montar la tarjeta

Por default tenemos:

~$ sudo mkdir /media/card

copy_boot.sh

Este script copia los firmware de la GPU, krnel de linux config.txt y cmdline.txt a la partición boot de la tarjeta, creada con el script mk2part.

Antes de ejecutarlo debemos exportar las variables OETMP y MACHINE que nos almacenaran la ubicación de la imagen y el sistema embebido para el que lo compilaremos.

~/rpi/meta-rpi/scripts$ export OETMP=~/rpi/build/tmp
~/rpi/meta-rpi/scripts$ export MACHINE=raspberrypi3

Luego podremos ejecutar el script copy_boot de la siguiente forma:

~/rpi/meta-rpi/scripts$ ./copy_boot.sh sdb

copy_rootfs.sh

Este script copia los archivos a la raíz de la segunda partición de la SD card, ademas acepta un argumento para el tipo de imagen dentro de la liena de comando, como console o qt5, pero por defecto trae la opción de console

El comando es:

~/rpi/meta-rpi/scripts$ ./copy_rootfs.sh sdb console

La duracion del script copy_rootfs.sh puede tomar un largo rato, dependiendo de la calidad de la SD, Con una Clase 10 tomara aproximadamente 30 segundos.

En caso de que no se pueda copiar los datos, por que la partición se encuentre montada, se debe desmontar las particiones y luego volver a ejecutar los scripts:

~$ sudo umount /dev/sdb1
~$ sudo umount /dev/sdb2
~$ export OETMP=/oe4/rpi/tmp-sumo
~$ export MACHINE=raspberrypi2
~$ cd rpi/meta-rpi/scripts
~/rpi/meta-rpi/scripts$ ./copy_boot.sh sdb
~/rpi/meta-rpi/scripts$ ./copy_rootfs.sh sdb console