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

Integrantes

  • Felipe Quezada
  • Jorge Silva
  • Patricio Gutierrez

Imagen Yocto para el Raspberry Pi

Requisitos:

  • Máquina con Ubuntu MATE 18.04, instalación LITE
  • Al menos 55GB de almacenamiento disponible
  • Tarjeta sd de al menos 8GB, preferentemente clase 10
  • Instalar las siguientes librerías:
    ~$ sudo apt-get install build-essential chrpath diffstat gawk libncurses5-dev libmcpp-dev texinfo git
  • Cambiar Ubuntu shell por defecto a bash:
    ~$ sudo dpkg-reconfigure dash 

    Elegir la opción NO

Procedimiento

Clonando repositorios

  • Clonamos el repositorio de yocto, para esto utilizar la rama sumo:
    ~$ git clone -b sumo git://git.yoctoproject.org/poky.git poky-sumo
  • Luego clonamos los distintos layers dentro de la carpeta poky-sumo. Como usaremos zeroc-ice, clonamos también su repositorio de la rama master:
    ~$ 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 directorio fuera de poky-sumo para el repositorio meta-rpi, junto con un subdirectorio para la carpeta de configuraciones:
    ~$ mkdir ~/rpi
    ~$ cd ~/rpi
    ~/rpi$ git clone -b sumo git://github.com/jumpnow/meta-rpi
    ~/rpi$ mkdir –p build/conf
  • Copiamos los archivos de configuración desde la carpeta meta-rpi/conf a la carpeta build/conf, eliminando la extensión ".sample":
    ~/rpi$ cp meta-rpi/conf/local.conf.sample build/conf/local.conf
    ~/rpi$ cp meta-rpi/conf/bblayers.conf.sample build/conf/bblayers.conf

 

Editando local.conf:

  • Cambiamos el valor de la variable MACHINE a la raspberry objetivo, ejemplo:
        MACHINE=raspberrypi2
  • Agregamos al final del archivo el paquete de zeroc ice junto con la versión a instalar:
        IMAGE_INSTALL_append = “zeroc-ice zeroc-ice-python”
        PREFERRED_VERSION_zeroc-ice = “3.7.1”
  • Asignamos una contraseña para usuario root, cambiando el valor de jumpnowtek:
        EXTRA_USERS_PARAMS = "usermod -P jumpnowtek root; "

Editando bblayers.conf:

  • Dentro de la variable BBLAYERS, agregar la ruta hacia meta-zeroc:
        BBLAYERS ¿= “ \
	        ${HOME}/poky-sumo/meta \
	        . . .
	        ${HOME}/poky-sumo/meta-zeroc \
	        . . .

Iniciar compilación

  • Corremos el siguiente script:
        ~$ source ~/poky-sumo/oe-init-build-env ~/rpi/build
  • Luego iniciamos la compilación y creamos la imagen que queremos, en esta caso console-image:
        ~/rpi/build$ bitbake console-image

Copiando imagen a tarjeta SD

  • Para comenzar a usar los siguientes scripts, se debe desmontar todas las particiones de la tarjeta sd objetivo. Para esto ejecutamos el siguiente comando para listar las unidades de almacenamiento y saber el nombre de nuestra tarjeta que, en este caso es nuestra sd de 7.4G llamada sdb:
        ~/rpi/meta-rpi$ lsblk
        NAME    MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
        sda       8:0    0 931.5G  0 disk
        |-sda1    8:1    0  93.1G  0 part /
        |-sda2    8:2    0  93.1G  0 part /home
        |-sda3    8:3    0  29.8G  0 part [SWAP]
        |-sda4    8:4    0     1K  0 part
        |-sda5    8:5    0   100G  0 part /oe5
        |-sda6    8:6    0   100G  0 part /oe6
        |-sda7    8:7    0   100G  0 part /oe7
        |-sda8    8:8    0   100G  0 part /oe8
        |-sda9    8:9    0   100G  0 part /oe9
        `-sda10   8:10   0 215.5G  0 part /oe10
        sdb       8:16   1   7.4G  0 disk
        |-sdb1    8:17   1    64M  0 part
        `-sdb2    8:18   1   7.3G  0 part

  • Luego desmontamos las particiones si es que así se requiere.

  • Ya identificada nuestra tarjeta, nos vamos a la carpeta dentro de rpi con los scripts y ejecutamos mk2parts para particionar nuestra tarjeta:

        ~$ cd ~/rpi/meta-rpi/scripts
        ~/rpi/meta-rpi/scripts$ sudo ./mk2parts.sh sdb
  • Necesitamos un punto de montaje para poder copiar los archivos de la imagen. Para ello creamos el siguiente directorio:
        ~$/rpi/meta-rpi/scripts$ sudo mkdir /media/card
  • Para copiar los archivos del arranque del sistema, primero debemos exportar las siguientes variables:
    • OETMP, la cuál se encuentra en el archivo local.conf y por defecto su ruta es ~/rpi/build/tmp
    • MACHINE, la cuál también se definió en el archivo local.conf
    • Observación: Cada vez que cerremos la consola, se deben exportar estas variables para correr los scripts copy-boot y, más adelante, copy-rootfs
        ~/rpi/meta-rpi/scripts export OETMP=~/rpi/build/tmp
        ~/rpi/meta-rpi/scripts export MACHINE=raspberrypi2
  • Luego corremos el script copy-boot, indicando el nombre de nuestra tarjeta:
~/rpi/meta-rpi/scripts ./copy_boot.sh sdb

copy-root.sh

  • Luego ejecutamos el siguiente script para escribir la imagen en nuestra tarjeta indicando el nombre de la tarjeta, la imagen creada sin “-image”, y luego el nombre de la máquina (ejemplo, raspi2):
~/rpi/meta-rpi/scripts ./copy_rootfs.sh sdb console raspi2

Node.js como cliente de servidor ice

Requisitos:

  • Es necesario el mismo .ice del servidor (Ejemplo: Example.ice)
  • Instalar slice2js (npm install --save-dev slice2js)
  • Dependencia a utilizar ICE (npm install ice)

Lo primero que hay que hacer es compilar el .ice para JavaScript Si slice2js esta instalado globalmente

slice2js Example.ice

O en su defecto, crear un .js con lo siguiente (dando por hecho que el .ice esta en la misma carpeta)

var slice2js = require('slice2js');
slice2js.compile(["Example.ice"]);

Luego, la base del programa es el siguiente:

const Ice = require("ice").Ice;
const Demo = require("./generated/Example").Demo; //Donde ./generated es la carpeta donde esta el compilado del .ice y que se llama Example.js y donde Demo es el nombre del modulo

(async function()
{
    let communicator;
    try
    {
        communicator = Ice.initialize();
        const base = communicator.stringToProxy("SimplePrinter:tcp -h IP -p 10000"); //SimplePrinter se llama en el servidor la implementación, IP es la ip del servidor y 10000 es el puerto por defecto
        const printer = await Demo.PrinterPrx.checkedCast(base); //PrinterPrx es el nombre de una clase generada en (Example.js)
        if(printer)
        {
            await printer.printString("Hello World!"); // printString es el metodo a realizar
        } 
        else
        {
            console.log("Invalid proxy");
        }
    }
    catch(ex)
    {
        console.log(ex.toString());
        process.exitCode = 1;
    }
    finally
    {
        if(communicator)
        {
            await communicator.destroy();
        }
    }
}());

Con este código funcionando, ya se puede utilizar la lógica para crear un servicio el cual se conecte a un servidor dinámicamente (dependiendo el ip que se utilice) y hacer peticiones http el cual este cliente gestione con el servidor.