Compilando LineageOS Android: Una guía paso a paso
November 1, 2017By Justin LeeAndroid, Tutoriales
Esta guía te enseñará como descargar y compilar el kernel de Android para ODROID-XU3/XU4. Si todavía no has compilado Android en tu ordenador de escritorio, echa un vistazo a la guía oficial de Google sobre cómo configurar un entorno de desarrollo para Android en http://bit.ly/1Hd3Z3P. Revísala cuidadosamente antes de continuar, de lo contrario puede que te encuetes con errores inesperados y necesites recurrir a los extensos y complejos registros log para localizar el problema.
Nosotros hemos utilizado Ubuntu 14.04 de 64 bits con 8 GB de RAM, las versiones más recientes de Ubuntu han dado algunos problemas a la hora de compilar el sistema operativo Android. http://bit.ly/2yGT5Tw. Si quieres compilar todo el código fuente de Android, no descargue y compiles código fuente del kernel por separado. Una compilación independiente de Kernel podría interrumpir el proceso global de compilación de Android.
Instalar openjdk-8-jdk
Si tu entorno de desarrollo es Ubuntu 14.04 o 12.40, introduce lo siguiente:
Ten en cuenta que distribuimos el kernel de Linux en diferentes sub-ramas para Android y otras distribuciones Linux.
Plataforma Android y Kernel
El repositorio para la descarga está disponible en http://bit.ly/1Syr1sf. El tamaño de todo el código fuente de Android es de alrededor de unos 70GB, así que asegúrese de preparar suficiente espacio antes de empezar a desarrollar la plataforma Android:
Antes de compilar, debes configurar el ODROID-XU3 con los siguientes comandos.
$ ./build.sh odroidxu3
Una vez completado el largo proceso de compilación, puedes localizar los archivos img en el directorio "/tmp/odroidxu3/". Para usar ADB a través de una conexión TCP/IP, consulta http://bit.ly/2gtWzAo.
Instalación para ODROID-XU3/XU3-Lite
Las instrucciones para instalar una imagen del kernel Linux para Android y Linux son diferentes. Como Android carga desde una partición del kernel, tenemos que usar fastboot para instalarlo en la partición dedicada. Antes de empezar, consulta la tabla de particiones en http://bit.ly/2irbjnC. En cambio, Linux arranca teniendo en cuenta los parámetros incluidos en boot.ini en la primera partición FAT.
En primer lugar, instala la imagen kernel zImage-dtb, en la tabla de arranque:
Puedes evitar el tema de usar fastboot en un ODROID-XU4, ya que éste no dispone de ningún puerto USB OTG. Primero, configura una conexión ADB o copia una imagen a la partición FAT:
$ adb push xxxx.img /sdcard/
$ adb reboot
Echa un vistazo a los registros log del U-Boot conectándote al ODROID-XU4 con un kit USB-UART:
U-Boot 2017.05-12209-g43745f3 (Aug 17 2017 - 09:37:39 +0900) for ODROID-XU4
CPU: Exynos5422 @ 800 MHz
Model: Odroid XU4 based on EXYNOS5422
Board: Odroid XU4 based on EXYNOS5422
Type: xu3
DRAM: 2 GiB
MMC: EXYNOS DWMMC: 0, EXYNOS DWMMC: 1
MMC Device 0 (eMMC): 14.7 GiB
Info eMMC rst_n_func status = enabled
MMC Device 1 ( SD ): 7.4 GiB
*** Warning - bad CRC, using default environment
In: serial
Out: serial
Err: serial
Net: No ethernet found.
Press quickly 'Enter' twice to stop autoboot: 0
Escribe los siguientes comandos tras presionar "Intro" dos veces para pausar el proceso de arranque:
Puedes actualizar desde Android Kitkat 4.4.4 estándar a Android 7.1 utilizando la versión 5.6 o superior de ODROID Updater (http://bit.ly/2yFz9lf). Siempre marca la opción "Format userdata" al actualizar desde otra versión de Android, tal y como se muestra en la Figura 1.
Abre "Internal storage", tal y como se muestra en la Figura 2, luego copia update.zip y update.zip.md5sum como se muestra en la Figura 3. Activa el botón "Validate file" como muestra la Figura 4.
Figura 2 – Abriendo el almacenamiento interno en LineageOS
Figura 3 - Seleccionando los archivos update.zip y update.zip.md5sum
Figura 4 - Validando los archivos de actualización en
ODROID Updater
Información del Almacenamiento
/storage/sdcard0 partición FAT del almacenamiento interno eMMC o microSD
/storage/sdcard1 ranura microSD para Tarjeta SD
/storage/usb2host Almacenamiento USB puerto USB 2.0 host
/storage/usb3host Almacenamiento USB puerto USB 3.0 host
/storage/usb3device Almacenamiento USB puerto USB 3.0 Dispositivo
Para comentarios, preguntas y sugerencias, visita el artículo original en http://bit.ly/2yUeqvm.
LIDAR asistido por ODROID: Detección y medición lumínica con el ODROID-XU4
November 1, 2017By Tom JacobsODROID-XU4, Mecaniqueo
Hace poco encargué un ODROID-XU4 para poner en marcha mi último proyecto, un Earth Rover, un robot explorador de 6 ruedas que puede desplazarse tanto por áreas internas como externas de forma autónoma. Estoy utilizando un sistema LIDAR extraído de una vieja aspiradora robotizada, la Neato XV-11 LIDAR. Este proyecto cubre la interconexión de ODROID con el LIDAR, la recepción de las mediciones de lectura y su integración en un sistema SLAM, localización y mapeo simultáneo con la finalidad de crear un mapa del área explorada. Elegí ODROID porque era la única placa lo suficientemente potente como para procesar las mediciones sobre un mapa en tiempo real.
Tiene ocho núcleos, cuatro se ejecutan a 2Ghz y los cuatro a 1.6Ghz. ¿Recuerdas tu famoso Pentium 133Mhz? Esta placa es quince veces más rápida y lo hace cuatro veces al mismo tiempo. Además, cuenta con otros cuatro núcleos simplemente por pura diversión y se puede introducir dentro de una taza de café. ¿Cuánto cuesta? 59$.
Conéctale el cable HDMI, la fuente de alimentación, el teclado y el ratón USB, el adaptador wifi USB y enciéndelo. En primer lugar, ejecuta los siguientes comandos para actualizar completamente tu sistema:
Gracias al conjunto de instrucciones de multiprocesamiento NEON, el rendimiento es bastante bueno, http://bit.ly/2zG12Ix, para tareas específicas como SLAM, incluso comparandolo con la potente Raspberry Pi, tal y como se muestra en la Figura 1.
Figura 1 – Comparando las lecturas por segundo de varios dispositivos SBC
Primero, clona el sistema de instalación e inícialo:
Ahora que tenemos muchas y muy buenas aplicaciones, como Python, PIP, OpenCV, FFMPEG y Alsa, vamos a instalar BreezySLAM:
$ git clone https://github.com/simondlevy/BreezySLAM
$ cd BreezySLAM/python
$ sudo python setup.py install
$ cd ../examples
$ make pytest
Figura 2 - Una imagen preliminar de una habitación SLAM usando LIDAR
Tal y como se muestra en la Figura 2, ¡Estamos viendo una sala mapeada con SLAM! desde el propio archivo de datos del sistema, de modo que aún no disponemos de ningún LIDAR físico externo. Vamos intentar ver los objetos en vivo, lo cual requiere matplotlib:
$ sudo apt-get install python-matplotlib
$ make movie
Figura 3 - Película en vivo de una habitación SLAM usando LIDAR
Tal y como muestra la Figura 3, podemos ver cómo se ejecuta y se va generando el mapa. El siguiente paso es probar LIDAR, que requiere xvlidar, pip y pyrserial:
Puesto que está intentando acceder al puerto serie, podemos verificar el dispositivo:
$ ls /dev/tty*
$ /dev/ttyACM99
Resulta que el dispositivo está realmente en otro puerto:
$ /dev/ttySAC0
Para saber dónde conectar el LIDAR, podríamos consultar el manual de ODROID-XU4 en http://bit.ly/2xYZhco, pero el caso es que no se menciona. La información que necesitamos está en http://bit.ly/2hYj8NQ, la Figura 4 muestra los pines que estamos buscando.
Figura 4 - Configuración GPIO para un proyecto LIDAR en el ODROID-XU4
Los pines de recepción y transmisión son UART_0.RXD (#6) y UART_0.TXD (#8). Tenemos también la puesta a tierra (#2) y la alimentación de 5v (#1). La mayoría de los sensores Lidars XV son a 5v, tal y como se menciona en http://bit.ly/2gBSiPc. Utilice el pin de 1.8v para alimentar el motor LIDAR, que como era de esperar proporciona suficiente amperaje. Tras ejecutar lidarplot.py nuevamente, se obtiene un LIDAR giratorio y un gráfico en blanco con un único punto, suele aparecer "Checksum fail" alguna vez que otra cuando se agitan las clavijas. De modo que se consigue algo, pero nada útil todavía, tal y como muestra la Figura 5.
Figura 5 – Resultado inicial de la configuración LIDAR en el ODROID-XU4
Después de añadir algunas impresiones, observo que el puerto serie generaba muchos 82 a lo largo de la matriz de 360 grados. Supongo que eso significa "Not spinning fast enough", porque utilicé una Raspberry Pi 2 para generar el voltaje correcto a 3.3v, y fui capaz de conseguir lecturas LIDAR. También se actualiza muy rápido, ya que cuando colocaba mi mano en frente, el cambio quedaba reflejado en un segundo más o menos.
Figura 6 – Resultado adaptado usando un motor 3.3v de la configuración LIDAR en el ODROID-XU4
Ahora estamos listos para ejecutar la aplicación SLAM:
$ cd BreezySLAM/examples
$ python xvslam.py
Figure 7 - SLAM sobre el ODROID-XU4
Para comentarios, preguntas y sugerencias, visita el artículo original en: http://bit.ly/2xX6ObL.
Servidor Web LEMP: Linux, NGINX, MariaDB y PHP en el ODROID-HC1
November 1, 2017By Justin LeeLinux, ODROID-HC1, ODROID-HC2
Esta guía te permitirá montar un servidor web económico pero potente usando un ODROID-HC1 (familia XU4, incluido el ODROID-HC2) equipado con un SSD SATA.
Preparar el soporte de arranque
Antes de continuar, graba la última imagen oficial de Hardkernel Ubuntu Minimal en tu soporte de arranque: tarjeta microSD de 8GB + Clase 10. También puedes utilizar un módulo eMMC de Hardkernel, junto con un lector de tarjetas microSD USB3.
Visita al enlace http://bit.ly/2xaucO8 y descárgate la última imagen de Ubuntu Minimal. Además, accede al enlace https://etcher.io/ y descarga la versión de Etcher correspondiente a tu sistema operativo. Inserta la tarjeta microSD en tu ordenador y ejecuta Etcher, luego graba la imagen en tu microSD.
Configurar tu ODROID
Instala el SSD usando el puerto SATA en su ODROID-HC1. Asegúrate de utilizar la fuente de alimentación oficial 5V 4A+ de Hardkernel para garantizar que el SSD disponga de suficiente potencia. Una vez hecho esto, inserta el soporte de arranque ya preparado en tu ODROID y enciende el ODROID-HC1.
El primer arranque suele tardar unos 5 minutos en iniciar el sistema operativo. Si no se enciende tras aproximadamente 5 minutos, puedes probar a reiniciarlo, desconectando/conectando de nuevo el cable de alimentación y volviéndolo a encender.
Ten en cuenta que si utilizas un ODROID-XU4, puedes llegar a montar un NAS de alto rendimiento usando un hub USB con alimentación, un SSD/eMMC para el sistema operativo y uno o más discos duros para el NAS. Los hubs alimentados por bus pueden que no funcionen correctamente debido a una alimentación insuficiente.
Acceso SSH y actualización del sistema
Conéctate a tu ODROID-HC1 a través de SSH y empieza a darle forma a tu servidor web. Se recomienda encarecidamente actualizar la imagen de la tarjeta microSD. Eso te permitirá beneficiarte de las últimas correcciones y del posible soporte para funciones adicionales. Tras acceder por SSH, actualiza Ubuntu y el kernel con los siguientes comandos:
Los soportes de arranque, como las tarjetas microSD, constituyen un sistema ineficiente porque las tarjetas microSD son lenta (para el sistema operativo y las aplicaciones que se ejecuten en ellas, como un servidor web) y están sujeta a fallos tras sucesivas escrituras. Aunque un módulo eMMC es una opción viable para un ODROID-XU4, éste no está disponible para el ODROID-HC1. Por todo ello, la instalación y uso de un SSD es muy recomendable para alojar sitios web que utilicen bases de datos. Para utilizar eficientemente un SSD para el arranque y las aplicaciones, sigue la guía paso a paso que se presenta a continuación, la cual te ayudará a preparar tu SSD con una partición root. Puedes consultar el post del foro en http://bit.ly/2gpT9OR para más detalles.
Re-particionar tu SSD
En primer lugar, debes particionar tu SSD para poder usarlo con dos particiones: una como partición root para el sistema operativo y la otra para los datos. Puedes obtener información sobre tu SSD usando la herramienta fdisk:
Para particionar el SSD, utiliza la herramienta fdisk con el nombre correcto del dispositivo (/dev/sda tal y como aparece en el resultado del comando anterior):
$ sudo fdisk /dev/sda
Las opciones fdisk más útiles se detallan a continuación:
p : Mostrar la tabla de particiones
n : Añadir una nueva partición
d : Eliminar una partición
w : Escribir la tabla en el disco y salir
q : Salir sin guardar los cambios
g : Crear una nueva tabla de particiones GPT vacía
m : Ayuda (menú)
Al mismo tiempo que consultas el menú anterior, elimina las particiones actuales, si las hay, y crea una nueva tabla de particiones GPT. Después crea una nueva partición para la partición root y otra para los datos. En nuestro caso, la partición root tendrá una capacidad de 16G y el resto de espacio irá para la partición de datos. Puedes especificar un tamaño de la partición especifico escribiendo una capacidad, por ejemplo, "+16G".
Revisa el resultado de tus acciones obteniendo información de las particiones con el parámetro "p". Si esta información coincide con tus preferencias, presiona "w" para guardar y salir.
# In fdisk
Command (m for help): p
Disk /dev/sda: 111.8 GiB, 120034123776 bytes, 234441648 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 33553920 bytes
Disklabel type: gpt
Disk identifier: 0412F7EC-4E8C-4610-ABFF-D6293387ADB6
Device Start End Sectors Size Type
/dev/sda1 2048 33556479 33554432 16G Linux filesystem
/dev/sda2 33556480 234441614 200885135 95.8G Linux filesystem
Formatear y montar una partición EXT4
Los modernos sistemas Linux generalmente utilizan el sistema de archivos EXT4, de modo que es muy aconsejable crear particiones de tipo ext4:
Toma nota del UUID para /media/systemdrive, luego cambia el UUID del sistema de archivos root en boot.ini para que tu gestor de arranque reconozca la partición del SSD como partición root:
$ sudo cp /media/boot/boot.ini /media/boot/boot.ini.bak
$ sudo vi /media/boot/boot.ini
Busca la expresión "Basic Ubuntu Setup" en el archivo:
...
# Basic Ubuntu Setup. Don't touch unless you know what you are doing.
# --------------------------------
setenv bootrootfs "console=tty1 console=ttySAC2,115200n8 root=UUID=e139ce78-9841-40fe-8823-96a304a09859 rootwait ro fsck.repair=yes net.ifnames=0"
…
Cambia el UUID de root para que coincida con el valor anterior. Ten en cuenta que tus valores UUID pueden ser diferentes a los que se aparecen aquí.
Actualizando fstab
Para montar tus particiones automáticamente, añade las entradas necesarias en el archivo /etc/fstab.
Tal y como aparece arriba, el MOUNTPOINT del sda1 es "/", lo que significa que el sistema arrancó correctamente desde el SSD.
Servidor LEMP (Linux, NGINX, MariaDB, PHP)
Hemos optado por utilizar nginx como servidor web. Éste utiliza una técnica asincrónica y orientada a eventos para manejar las conexiones, es rápido y tiene capacidad para atender solicitudes de muchos usuarios, además de ofrecer un rendimiento bastante fiable. Ha sido diseñado para ser un software liviano, el cual ofrece muchas características. Si deseas contar con la ventaja de poder usar funciones como es la instalación de módulos adicionales, decantarse por Apache sería una mejor opción.
PHP
Para instalar PHP, debes añadir un repositorio para PHP de antemano. Puedes instalar el último PHP para ARM, versión 7.1 o superior.
Una vez finalizada la instalación, debes cambiar la zona horaria especificada en un archivo de configuración de PHP.
$ sudo vi /etc/php/7.1/fpm/php.ini
Busca "date.timezone" y cámbiala de acuerdo a tu ubicación, inicialmente puede estar comentada por defecto.
MariaDB
No hay disponible un PPA oficial para MariaDB (http://bit.ly/2zktcMs) basado en la arquitectura ARM. Simplemente debes instalarlo desde el repositorio que se proporciona en Ubuntu. Además, debes instalar el paquete php-mysql para enlazar MariaDB con PHP. La instalación de los paquetes necesarios podría demorarse un poco.
Deberías configurar el conjunto de idiomas que MariaDB usa para UTF-8.
$ sudo vi /etc/mysql/conf.d/mysql.cnf
Elimina todo el contenido existente y copia-pega el nuevo contenido que aparece a continuación.
# MariaDB-specific config file.
# Read by /etc/mysql/my.cnf
[client]
# Default is Latin1, if you need UTF-8 set this
# (also in server section)
default-character-set = utf8mb4
[mysqld]
#
# * Character sets
#
# Default is Latin1, if you need UTF-8 set all this
# (also in client section)
#
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
character_set_server = utf8mb4
collation_server = utf8mb4_unicode_ci
Finalmente, reinicia el servicio MariaDB.
$ sudo service mysql restart
Instalar nginx
Para instalar nginx, debes añadir un repositorio para nginx de antemano. Puedes instalar la última versión para ARM (versión 1.12+):
Ten en cuenta que las pruebas del módulo eMMC se ejecutaron sobre un ODROID-XU4 y el resto de las de llevaron a cabo en el ODROID-HC1.
Todos los resultados tienen sus propios márgenes de error
Puesto que WordPress se ejecuta con PHP, MariaDB (MySQL) y Nginx (Apache), instalamos WordPress en cada sistema para crear unas condiciones de prueba nativas. Las pruebas de JMeter se ejecutaron accediendo a la página principal de WordPress por defecto.
Observamos fallos en la respuesta si teníamos más de 140 usuarios accediendo de forma simultánea a la simple página web de WordPress.
TPS es la abreviatura de Transacción por segundo, así que ésta es la prueba más cercana a un posible entorno de usuario.
HDD 2TB
SSD 120G
eMMC 64G
eMMC 16G
MicroSD
8G
Apache JMeter
TPS medio con 100 usuarios simultáneos
51.1
53.1
54.5
53.4
52.3
Tiempo de Respuesta medio con 100 usuarios simultáneos
Velocidad de transferencia media E/S Ficheros (Mbps)
1.9359
17.982
24.593
16.738
0.094831
IOzone (Kbps)
Velocidad de lectura aleatoria (4K)
1580
20937
15466
15203
9139
Velocidad de escritura aleatoria (4K)
1275
21078
15803
17939
827
Velocidad de lectura secuencial (16M)
115209
363269
142535
147790
42885
Velocidad de escritura secuencial (16M)
108979
278223
88529
33709
13022
Como puedes ver en la tabla anterior, un HDD es ligeramente más rápido que una tarjeta MicroSD en cuanto a la velocidad de acceso aleatorio. El resultado del TPS OLTP y la velocidad de acceso secuencial son bastante buenos, pero la velocidad de acceso aleatorio no es aceptable. El TPS medio que se muestra arriba es simplemente un valor promedio, necesitas saber que la velocidad de acceso aleatorio es uno de los valores más importantes a la hora medir la velocidad global del sistema. Los resultados OLTP del HDD ODROID variaron bastante entre las pruebas. Sin embargo, en lo que respecta a la velocidad de acceso secuencial, éste es casi tan rápido como un PC escritorio. Por lo tanto, usar una unidad de disco duro en el ODROID-HC1 para un NAS puede ser una muy buena opción.
Respecto a las pruebas TPS con los 100 usuarios simultáneos, no hay mucha diferencia. Sin embargo, en las otras pruebas, como la TPS OLTP y IOzone, el SSD o el eMMC 64G parecen más rápido que el resto. En la prueba E/S de ficheros, el SSD es la más rápido en las estadísticas por solicitud.
En base a los resultados anteriores, no se recomienda utilizar un HDD o tarjeta MicroSD para un sistema LEMP o LAMP. Recomendamos utilizar un módulo eMMC o SSD para lograr el mejor rendimiento con un ODROID-XU4/HC1/HC2 a la hora de alojar un sitio web y/o utilizarlo como un NAS. Para más detalles, puedes visitar el artículo original en http://bit.ly/2l5aUs1.
Linux Kernel 4.14: Soporte para ODROID-XU3/4/MC1/HC1
November 1, 2017By Marian MihailescuLinux
Exynos 5422 es un System-on-a-Chip (SoC) Samsung que ha sido la base de los productos de Hardkernel durante varios años. Empezando con el ODROID-XU3 de alta gama, más tarde se lanzó una variante más asequible, el ODROID-XU3 Lite; pasó por un completo rediseño con el ODROID-XU4 y XU4Q, y recientemente lo podemos encontrar en el nuevo ODROID-HC1 y MC1, orientados para el uso de NAS y clusters, respectivamente.
Lanzado inicialmente con la versión 3.10 del kernel Linux, han sido muchos los intentos para actualizar los productos ODROID basados en Exynos 5422 a un kernel más reciente, con kernels experimentales lanzados para las versiones 4.0, 4.2, 4.4 y 4.8 por la comunidad, hasta que Hardkernel ayudó a desarrollar y liberar una versión estable del kernel 4.9.
Durante cada ciclo de desarrollo del kernel, el SoC conseguía más actualizaciones para el kernel estándar gracias a los esfuerzos de Samsung y de la comunidad. De este modo, cada vez resultaba más fácil actualizar a la última versión del kernel. De hecho, durante un tiempo, los ODROID basados en Exynos 5422 podían usar el kernel estándar sin modificaciones. Sin embargo, el problema radicaba en que la versión estándar no cuenta con todos los controladores y algunos sistemas no funcionaban.
El siguiente kernel con soporte de larga duración (LTS) es la versión 4.14, que se lanzará en noviembre. Casualmente, hace poco se ha revelado que el soporte para kernels LTS se extenderá hasta los 6 años. Esto significa que la versión 4.14 recibirá soporte hasta finales de 2022. Esta es una gran noticia para los dueños de esas pequeñas, extensibles, potentes y económicas placas, como son los ODROID.
Esta versión del kernel pasa por ser particularmente atractiva para los ODROID Exynos 5422, especialmente porque incluye importantes correcciones para la decodificación y codificación de video por hardware (MFC), el escalador de hardware y convertidor de espacios de color (GScaler) y un nuevo driver para HDMI CEC, que permite controlar el dispositivo a través de un mando a distancia por infrarrojos.
Además, incluye in sinfín de parches desde la versión 4.9 mantenidos por Hardkernel que pueden beneficiar a los usuarios de ODROIDs, como son las mejoras en los sistemas de archivos EXT4 y BTRFS, las mejoras en la máquina virtual basada en kernel (KVM), drivers WiFi nuevos y actualizados, y mejoras en los drivers para sistemas multimedia (por ejemplo, mejor soporte para sintonizadores de TV).
La comunidad intervino y empezó a solucionar el resto de problemas incluso antes de que se liberara el kernel 4.14:
Los Drivers Mali fueron actualizados a la versión r20p0
Se ha añadido soporte para el programador automático de tareas Multiprocesamiento Heterogéneo (HMP) de CPU
Parches para los puertos USB3 en ODROID
Parche para la interfaz Gigabit Ethernet
Soporte adicional para varias interfaces, tales como el botón de encendido, SPI, ADC, GPIOs
Controlador de sonido HDMI para el ODROID-XU4
Mejoras para tarjetas sd/módulos eMMC que incluye soporte para velocidades superiores
Soporte mejorado para el hipervisor de máquina virtual
Soporte habilitado para el hardware watchdog
Soporte para los contadores de rendimiento de hardware de la CPU (PMU)
Incluido soporte oficial para ODROID-HC1 (programado para la versión de kernel 4.15)
Soporte adicional para frecuencias extra de CPU y características térmicas mejoradas
Soporte añadido para las tablas ASV de la CPU de Samsung que permite mejorar la selección del voltaje de la CPU y el nivel térmico.
Con la mayoría de correcciones y parches desarrollados o importados desde el kernel 4.9, la versión 4.14 del kernel ya está lista para someterla a las pruebas de los usuarios. Los interesados pueden descargar, compilar e instalar el kernel en la distribución oficial Ubuntu de Hardkernel usando estas instrucciones:
$ git clone --depth 1 --single-branch -b odroidxu4-4.14.y https://github.com/mihailescu2m/linux
$ cd linux
$ wget https://gist.github.com/mihailescu2m/115c9e2135f9b12f3d05669e18137c3d -O .config
$ make -j 8 zImage dtbs modules
$ sudo cp arch/arm/boot/zImage arch/arm/boot/dts/*.dtb /media/boot
$ sudo cp .config /media/boot/config
$ sudo make modules_install
$ kver=`make kernelrelease`
$ sudo cp .config /boot/config-${kver}
$ cd /boot
$ sudo update-initramfs -c -k ${kver}
$ sudo mkimage -A arm -O linux -T ramdisk -a 0x0 -e 0x0 -n initrd.img-${kver} -d initrd.img-${kver} uInitrd-${kver}
$ sudo cp uInitrd-${kver} /media/boot/uInitrd
Los comentarios y resultados de las pruebas son bienvenidos en el foro "Kernel 4.14 debugging party" en http://bit.ly/2ltTPbD.
ODROID-C2: Apaga y enciende el sistema usando un simple botón GPIO
November 1, 2017By Justin LeeODROID-C2, Mecaniqueo
Este artículo describe cómo configurar un botón GPIO con vistas a apagar y encender el sistema. Los breves pasos de configuración incluyen:
Conectar un botón en forma de tabulador al puerto pin que quieras utilizar
Configurar el número GPIO usando boot.ini
Compilar y grabar el kernel DTS modificado, que sólo es necesario para Android
Configuración del Hardware
En primer lugar, debes preparar un interruptor que se conectará a dos líneas GPIO. El cable rojo será para la alimentación y el cable gris para la línea activa (puesta a tierra o potencia de 3.3V).
Figura 1 - Material para el proyecto de botón de encendido ODROID-C2
El diagrama de la disposición de los pines ODROID-C2 http://bit.ly/2aXAlmt nos será muy útil para este proyecto. En nuestro caso, utilizaremos el pin #29 del conector de expansión de 40 pines. El pin es asignado a GPIOX.BIT0 y su número GPIO será 228. Conecta la línea roja al pin #29. Su estado por defecto será high y el interruptor activado será low. Por lo tanto, debe conectar la línea gris del interruptor a la puesta a tierra (GND), pin #30.
Núemro de Pin
(Linea Roja)
Número GPIO
Nivel Activo
(Linea Gris)
29
GPIO# 228
Active Low (Pin 30)
Teclas disponibles
Aquí tienes ejemplos de teclas disponibles para el conector de 40 pines y el conector de 7 pines. Puede localizar los ejemplos de asignación de pin para Línea roja y Línea gris.
(1) J2 - 2×20 pins
Nivel Activo
(Linea Gris)
GPIO #
Pin #
(Linea Roja)
Pin #
(Linea Roja)
GPIO #
Nivel Activo
(Linea Gris)
-
3.3V Power
1
2
-
-
-
-
3
4
-
-
-
-
5
6
Ground
-
Active Low (Pin 9)
GPIO# 249
7
8
-
-
-
Ground
9
10
-
-
Active Low (Pin 14)
GPIO# 247
11
12
GPIO#238
Active Low (Pin 14)
Active Low (Pin 14)
GPIO# 239
13
14
Ground
-
Active Low (Pin 14)
GPIO# 237
15
16
GPIO#236
Active Low (Pin 14)
-
3.3V Power
17
18
GPIO#233
Active Low (Pin 20)
Active Low (Pin 20)
GPIO# 235
19
20
Ground
-
Active Low (Pin 20)
GPIO# 232
21
22
GPIO#231
Active Low (Pin 20)
Active Low (Pin 25)
GPIO# 230
23
24
GPIO#229
Active Low (Pin 25)
-
Ground
25
26
GPIO# 225
Active High (Pin 17)
-
-
27
28
-
-
Active Low (Pin 30)
GPIO# 228
29
30
Ground
-
Active Low (Pin 30)
GPIO# 219
31
32
GPIO# 224
Active Low (Pin 34)
Active High (Pin 17)
GPIO# 234
33
34
Ground
Active Low (Pin 34)
GPIO# 214
35
36
GPIO# 218
Active Low (Pin 34)
-
-
37
38
-
-
-
Ground
39
40
-
-
(2) J7 - 1×7 pins
Pin #
(Linea Roja)
GPIO #
Nivel Activo
(Linea Gris)
1
Ground
-
2
GPIO# 128
Active Low (Pin 1)
3
5.0V Power
-
4
GPIO# 130
Active Low (Pin 1)
5
GPIO# 132
Active Low (Pin 1)
6
GPIO# 131
Active Low (Pin 1)
7
GPIO# 133
Active Low (Pin 1)
Puedes encontrar información detallada sobre conectores de expansión de 40 y 7 pines http://bit.ly/2gzCA7c.
Configurar el Software Ubuntu
La versión liberada debe ser la 3.14.79-107 (26 de febrero de 2017) o superior. Puedes asignar un número GPIO con env gpiopower en boot.ini:
Si tienes la intención de apagar la placa con el botón de encendido, necesitas cambiar el patrón de acción de la tecla. Para hacer posible esto, primero abre el cuadro de diálogo de Preferencias de la gestión de energía ([System] → [Preferences] → [Hardware] → [Power Management]) y selecciona la festaña [General].
Figura 2: Preferencias de gestión de energía
Acción de encendido
Para reactivar el sistema después de apagarlo, es necesario presionar el botón durante un tiempo (2-3 segundos).
Configurar el software Android
En Android, necesitas modificar el archivo DTS en Android Marshmallow (v2.4) y versiones superiores para usar esta funcionalidad.
Tienes que modificar el archivo DTS para activar la funcionalidad de la tecla GPIO:
/arch/arm64/boot/dts/meson64_odroidc2.dts
...
gpio_keypad{
.
status = "okay";
.
};
…
Tras compilar el archivo DTS, puedes grabar el archivo DTB en la placa:
$ make odroidc2_defconfig
$ make dtbs
$ fastboot flash dtb arch/arm64/boot/dts/meson64_odroidc2.dtb
$ fastboot reboot
Debes grabar el archivo DTBS cuando la placa esté en modo fastboot de u-boot:
$ reboot fastboot
Configurar boot.ini
En Android boot.ini, puedes descomentar la entrada "gpipower" y modificar el número existente por el número aplicable en tu caso:
Tarjeta MicroSD clase 10 de 8gb o más para el sistema operativo
Cable LAN
Figura 1 - Requisitos de hardware para el proyecto Google Assistant
IConecta el dongle Bluetooth al puerto USB del ODROID-HC1, luego enciende el ODROID-HC1 y el altavoz Bluetooth para empezar.
Ajustes de Sonido
Para acceder a la consola del ODROID-HC1, consigue la dirección IP de la placa tal y como se describe en http://bit.ly/2yXFLwp. Esta guía está basada en el último sistema operativo Ubuntu 16.04 Minimal. Puedes descargar la imagen del sistema operativo desde http://bit.ly/2yXYs3h. Antes de empezar con la configuración del sistema, añade la nueva cuenta de usuario ODROID como un usuario sudo, porque Ubuntu Minimal no tiene ninguna cuenta de usuario:
Añade permisos pulseaudio a la cuenta de usuario. Agrega la línea "load-module module-switch-on-connect" al archivo de configuración de pulseaudio. Esta configuración cambia la salida de audio al altavoz Bluetooth automáticamente:
.ifexists module-bluetooth-discover.so
load-module module-bluetooth-discover
load-module module-switch-on-connect # this is new!
.endif
Inicia pulseaudio:
$ pulseaudio --start
Configuración de Bluetooth
Instala el paquete relacionado con el Bluetooth. En este caso, usa el paquete bluez para bluetooth:
$ sudo apt install bluez
$ bluetoothctl
Si el comando bluetoothctl no funciona con la cuenta de usuario, modifica el archivo de configuración de dbus añadiendo las siguientes configuraciones al archivo:
Introduce los siguientes comandos en la consola bluetoothctl. Ten en cuenta que la dirección MAC del altavoz Bluetooth debe cambiarse de 00:11:67:AE:25:C6 a tu propia dirección MAC. Esta dirección es diferente para cada dispositivo Bluetooth, así que asegúrate de reemplazar la dirección MAC por la suya:
[bluetooth]# agent on
[bluetooth]# default-agent
[bluetooth]# scan on
[bluetooth]# pair 00:11:67:AE:25:C6
[bluetooth]# trust 00:11:67:AE:25:C6
[bluetooth]# connect 00:11:67:AE:25:C6
[bluetooth]# quit
El altavoz Bluetooth debería tener una configuración por defecto. Para ajustar el A2DP (Advanced Audio Distribution Profile) como predeterminado, cambia el perfil a HSP (Head Set Profile) porque A2DP no puede usar el micrófono.
$ pacmd ls
Consulta el fichero del altavoz Bluetooth, suponemos que el index es 1:
$ pacmd set-card-profile 1 headset_head_unit
Para verificar que hay sonido y que la configuración de Bluetooth se ha realizado correctamente, reproduce un sonido de prueba:
$ speaker-test -t wav
Graba y reproduzca algo de audio utilizando las herramientas de línea de comandos ALSA:
Para habilitar la API de Google Assistant, consulta la página de Guías de Google Assistant SDK en http://bit.ly/2pXwqfC. Usa una cuenta de Google para iniciar sesión. Si todavía no dispones de una cuenta de Google, cree una. Probar la API de Google Assistant es gratis para uso personal.
Configurar un Proyecto Desarrollador Google
Un Proyecto desarrollador Google permite que cualquier dispositivo ODROID tenga acceso a la API de Google Assistant. El proyecto rastrea el uso de cuota y proporciona valiosas métricas de las peticiones realizadas desde dispositivos ODROID en la red.
Para habilitar el acceso a la API de Google Assistant, primero dirígete a la página de Proyectos dentro de Cloud Platform Console y selecciona un proyecto existente o cree un nuevo proyecto. Ve a la página de Proyectos en http://bit.ly/2gY7pSV. A continuación, activa la API de Google Assistant en el proyecto que has seleccionado y haz clic en Habilitar. Puedes obtener más información sobre cómo activar la API en http://bit.ly/2A1ewic.
Después, crea un ID de Cliente OAuth creando primero la ID del cliente, tal y como se describe en http://bit.ly/2xBjII6. Puede que necesites definir un nombre de producto en la pantalla de aprobación de producto. En la pestaña aprobación de OAuth, asigna un nombre al producto y haga clic en Guardar, luego haz clic en Otro y asigna un nombre al ID del cliente y haz clic en Crear. Aparecerá un cuadro de diálogo que te mostrará el ID de cliente y un secret. No hay necesidad de recordar o guardar esto, simplemente cierra el cuadro de diálogo. A continuación, haz clic en el extremo derecho de la pantalla para que la ID del cliente descargue el archivo JSON del cliente (client_secret_.json). El archivo client_secret_.json debe estar ubicado en el dispositivo para autorizar a que la muestra de Google Assistant SDK pueda realizar consultas a Google Assistant, y no debe cambiarse de nombre. Finalmente, copia client_secret_.json en el ODROID-HC1:
Definir los controles de actividad para tu cuenta de Google
Para poder usar Google Assistant, hay determinados datos de actividad que tienen que ser compartidos con Google. Google Assistant necesita que estos datos funcionen correctamente, no son específicos del SDK. Para hacer esto, abre la página de Controles de actividad de la cuenta de Google que se usará con el Asistente en http://bit.ly/2ig4QIB. Cualquier cuenta de Google tiene esta opción y no necesita ser tu cuenta de desarrollador. Asegúrate de que las siguientes opciones estén activadas (azul):
Web & App Activity
Device Information
Voice & Audio Activity
Descargar y ejecutar la muestra de la API de Google Assistant
Utiliza un entorno virtual Python para aislar el SDK y sus dependencias de los paquetes Python del sistema:
Si tienes problemas con la configuración regional tal y como se muestra a continuación, configura la variable de entorno LC_ALL:
Complete output from command /home/odroid/env/bin/python2 - setuptools pkg_resources pip wheel:
Traceback (most recent call last):
File "", line 24, in
File "/usr/share/python-wheels/pip-8.1.1-py2.py3-none-any.whl/pip/__init__.py", line 215, in main
File "/home/odroid/env/lib/python2.7/locale.py", line 581, in setlocale
return _setlocale(category, locale)
locale.Error: unsupported locale setting
$ export LC_ALL=C
$ virtualenv env --no-site-packages
Activate Python virtual environment.
$ env/bin/python -m pip install --upgrade pip setuptools
$ source env/bin/activate
Tras activar el entorno virtual de Python, aparecerá la cadena "(env)" delante del prompt.
Autoriza que la muestra de SDK de Google Assistant pueda realizar consultas a Google Assistant para la cuenta de Google especificada. Haz referencia al archivo JSON que ha sido copiado en el dispositivo en un paso anterior e instala la herramienta de autorización:
Ejecute la herramienta, asegurándote de quitar el parámetro –headless si estás ejecutando esto desde una terminal en el dispositivo (no usas una sesión SSH):
Debería ver una URL que se muestra en el terminal:
Please go to this URL: https://
Copia la URL y pégala en un navegador. Esto se puede hacer en la máquina de desarrollo o en cualquier otra máquina. Una vez aceptada, aparecerá un código en el navegador, algo así como "4/XXXX". Copia y pega este código en el terminal:
Enter the authorization code:
Si la autorización ha tenido exito, las credenciales de OAuth se activarán en la terminal. Si en su lugar aparece InvalidGrantError, entonces es que se ha introducido un código no valido. Si esto ocurre, inténtalo de nuevo, teniendo cuidado de copiar y pegar todo el código. Si se introduce el código de autorización correcto, se genera el archivo credentials.json:
Ejecuta y prueba la muestra pushtotalk. Si el programa de ejemplo funciona bien, está hecho casi todo trabajo:
(env) $ python pushtotalk.py
INFO:root:Connecting to embeddedassistant.googleapis.com
Press Enter to send a new request...
Copia la muestra en el directorio de trabajo. Desactiva el entorno virtual de Python. Hay que realizar una serie de pasos adicionales para dar forma a un interlocutor IA de provecho. Para eso, dirígete al directorio $ (HOME)/ai_speaker:
(env) $ cd ..
(env) $ cp -r grpc ~/ai_speaker
(env) $ cd ~/ai_speaker
(env) $ cp pushtotalk.py ai_speaker.py
(env) $ deactivate
$ cd
Wake-Up-Word
La muestra Wake-Up-Word parece que interactúa con el asistente de inteligencia artificial. Sin embargo, antes de comunicarse con el asistente IA, primero hay que presionar la tecla Intro. Para detectar un Wake-Up-Word como "Okay, Google", "Alexa" o "Jarvis", usa CMUSphinx de https://cmusphinx.github.io , que es el kit de herramientas de reconocimiento de voz local de código abierto. Lo mejor es compilar e instalar SphinxBase, ya que éste proporciona una funcionalidad común para todos los proyectos CMUSphinx:
$ sudo apt install libtool bison swig python-dev autoconf libtool automake
$ git clone --depth 1 https://github.com/cmusphinx/sphinxbase.git
$ cd sphinxbase
$ ./autogen.sh
$ make -j8
$ sudo make install
$ cd
Sphinxbase se instalará en el directorio "/usr/local/" por defecto. No todos los sistemas cargan las librerías automáticamente desde esta carpeta. Para cargarlas, configura la ruta para localizar las librerías compartidas. Esto se puede hacer en el archivo "/etc/ld.so.conf" o exportando las variables de entorno:
Compila e instala PocketSphinx. PocketSphinx es un liviano motor de reconocimiento de voz específialmente diseñado para dispositivos portátiles y dispositivos móviles, aunque funciona igual de bien en los PC de escritorio:
$ git clone --depth 1 https://github.com/cmusphinx/pocketsphinx.git
$ cd pocketsphinx
$ make -j8
$ sudo make install
$ cd
Para probar la instalación, ejecuta pocketsphinx_continuous y comprueba que se reconoce tus palabras a través del micrófono:
$ pocketsphinx_continuous -inmic yes
Para obtener más información sobre el desarrollo de PocketSphinx, consulte la página "Building an application with PocketSphinx " en http://bit.ly/2gZhHT5.
Añade el programa pocketsphinx_continuous como un subproceso del programa del Altavoz IA. El programa pocketsphinx_continuous es una buena herramienta para detectar palabras clave ya que reconoce el habla de forma asincrónica. Procede a eliminar las líneas relacionadas wait_for_user_trigger puesto que las propias palabras clave son el activador:
$(HOME)/ai_speaker/ai_speaker.py
"""Sample that implements gRPC client for Google Assistant API."""
# Add subprocess module
import subprocess
import json
import logging
import os.path
(......)
# Add below's routines in the 'While True:' loop
while True:
p = subprocess.Popen(args = ['pocketsphinx_continuous','-inmic', 'yes', '-kws_threshold', '1e-16', '-keyphrase', 'hey dude'],
stdin = subprocess.PIPE,
stdout = subprocess.PIPE,
universal_newlines=True)
while p.poll() is None:
data = p.stdout.readline()
if data.find("hey dude") is not -1:
print "Detected Hotwords"
p.stdout.flush()
break
p.terminate()
El Wake-Up-Word es "hey dude". Ejecuta el programa, pronuncia "hey dude" y luego dile todo lo que quieras al asistente IA:
(env) $ cd ai_speaker
(env) $ python ai_speaker.py
Sonido de detección
Existe un problema tras añadir inicialmente los Wake-Up-Words, porque no hay ningún mecanismo en situ para darnos cuenta si el altavoz IA está detectando o no las palabras clave. Se debe conocer la sincronización para poder controlar el asistente IA por voz. Esto puede solucionarse añadiendo un sonido de detección al programa. Descarga el sonido de detección de muestra en http://bit.ly/2zkSV3b, luego copia el archivo detect.wav al ODROID-HC1:
$ scp ~/Downloads/detect.wav odroid@:~/
Utiliza el módulo wave y pyaudio para reproducir el archivo .wav en el código fuente de Python:
(env) $ pip install --upgrade pyaudio wave
Agrega la rutina para reproducir el sonido de detección al programa. Todas las posibles variedades, incluidas las rutinas Wake-Up-Words son las siguientes:
(env) $ nano ai_speaker.py
Archivo diff entre el código de muestra original pushtotalk.py y el programa modificado ai_speaker.py
--- pushtotalk.py 2017-10-19 15:42:12.164741800 +0000
+++ ai_speaker.py 2017-10-19 15:41:49.644811151 +0000
@@ -14,6 +14,9 @@
"""Sample that implements gRPC client for Google Assistant API."""
+import pyaudio
+import wave
+import subprocess
import json
import logging
import os.path
@@ -310,14 +313,38 @@
# keep recording voice requests using the microphone
# and playing back assistant response using the speaker.
# When the once flag is set, don't wait for a trigger. Otherwise, wait.
- wait_for_user_trigger = not once
+ chunk = 1024
+ pa = pyaudio.PyAudio()
+ while True:
- if wait_for_user_trigger:
- click.pause(info='Press Enter to send a new request...')
+ p = subprocess.Popen(args = ['pocketsphinx_continuous','-inmic', 'yes', '-kws_threshold', '1e-16', '-keyphrase', 'hey dude'],
+ stdin = subprocess.PIPE,
+ stdout = subprocess.PIPE,
+ universal_newlines=True)
+ while p.poll() is None:
+ data = p.stdout.readline()
+ if data.find("hey dude") is not -1:
+ print "Detected Hotwords"
+ p.stdout.flush()
+ break
+ p.terminate()
+
+ # Play the detection sound
+ f = wave.open(r"/home/odroid/detect.wav","rb")
+ stream = pa.open(format = pa.get_format_from_width(f.getsampwidth()),
+ channels = f.getnchannels(),
+ rate = f.getframerate(),
+ output = True)
+ wav_data = f.readframes(chunk)
+
+ while wav_data:
+ stream.write(wav_data)
+ wav_data = f.readframes(chunk)
+ stream.stop_stream()
+ stream.close()
+ f.close()
+
continue_conversation = assistant.converse()
- # wait for user trigger if there is no follow-up turn in
- # the conversation.
- wait_for_user_trigger = not continue_conversation
# If we only want one conversation, break.
if once and (not continue_conversation):
# Run the AI speaker program.
(env) $ python ai_speaker.py
La tasa de detección de Wake-Up-Words es algo inferior a la ideal. Tanto si usa Pocketsphinx como cualquier otra solución, la rutina Wake-Up-Words necesita mejoras, así que añadir comandos personalizados va a resultar muy útil en este proyecto en concreto. Por ejemplo, es fácil controlar los dispositivos IoT por voz mediante el Google Assistant SDK. Se pueden localizar diferentes soluciones recurrirendo a la búsqueda "action on google " para obtener más información sobre la extensión de Google Assistant.
Para ahorrar tiempo, se puede utilizar una sencilla solución de comando personalizado simplemente añadiendo el comando al programa ai_speaker.py. En la muestra pushtotalk, busca el texto de solicitud que ya está reconocido por voz:
--- pushtotalk.py 2017-10-19 16:07:46.753689882 +0000
+++ pushtotalk_new.py 2017-10-19 16:09:58.165799271 +0000
@@ -119,6 +119,15 @@
logging.info('Transcript of user request: "%s".',
resp.result.spoken_request_text)
logging.info('Playing assistant response.')
+ #Add your custom voice commands here
+ #Ex>
+ #import os
+ #r_text = resp.resut.spoken_request_text
+ #if r_text.find("play music") is not -1:
+ # os.system("mplayer ~/Music/*&")
+ #if r_text.find("turn on light") is not -1:
+ # os.system("echo 1 > /sys/class/gpio/gpio1/value")
+
if len(resp.audio_out.audio_data) > 0:
self.conversation_stream.write(resp.audio_out.audio_data)
if resp.result.spoken_response_text:
Después de guardar esta modificación, puede empezar a experimentar con el control de dispositivos electrónicos domésticos utilizando el controlador IOT con comandos de voz. Para comentarios, preguntas y sugerencias, visita el artículo original en http://bit.ly/2iQ629K.
Analizando el almacenamiento definido por software con GlusterFS en el ODROID-HC1: Parte 1 - Configuración del servidor
November 1, 2017By Andy YuenODROID-HC1
Según Whatis.com "El almacenamiento definido por software (SDS) es un programa informático que gestiona la funcionalidad y los recursos del almacenamiento de datos sin tener que depender del hardware de almacenamiento físico subyacente"
Según Red Hat "Gluster File System (GlusterFS) es una plataforma SDS diseñada para gestionar los requisitos del almacenamiento tradicional de archivos: tareas de alta capacidad como backup y almacenamiento de archivo, así como tareas de alto rendimiento de análisis y virtualización".
Aunque GlusterFS es claramente una tecnología destinada a empresas, ello no significa que no se pueda usar en casa. Al contrario, considero que es más flexible y escalable que los sistemas de almacenamiento conectados en red (NAS) comerciales. Los servidores NAS para usuarios domésticos normalmente vienen con 2 o 4 bahías. Cuando llega el momento de expandir tu sistema, no son tan flexibles. Necesitas cambiar a un sistema más grande con más bahías, o tienes que reemplazar todos tus discos por otros de mayor capacidad. GlusterFS se escala horizontalmente, lo que significa que puede añadir más servidores para expandir tu capacidad de almacenamiento. Para los usuarios domésticos, añadir más servidores no tiene sentido, ya que los servidores son bastante caros. Esto es cierto hasta que vino a la mente el ODROID-HC1, que se vende por solo 49$. Cuatro ODROID-HC1 se pueden equiparar a un único NAS de 4 bahías con un coste aproximado del 50%. Además, el procesador ODROID-XU4, que cuenta con cuatro núcleos A15 y cuatro núcleos A7 en cada HC1, ya es más potente que el NAS medio dirigido al mercado doméstico, que generalmente viene con un procesador A15 dual-core
En este artículo, voy a utilizar cuatro ODROID-HC1 para crear un volumen GlusterFS replicado, distribuido, altamente escalable y sumamente disponible, similar a una configuración RAID 1+0. No se preocupes si solo tienes dos HC1 a mano. Describiré cómo puedes crear un volumen GlusterFS replicado que sea equivalente a un RAID 1. Pero antes de eso, vamos a analizar un poco los diferentes tipos de volúmenes de GlusterFS que existen.
Tipos de volumenes GlusterFS
GlusterFS es un sistema de archivos distribuidos compatible con POSIX. Utiliza el Elastic Hash Algorithm para realizar hash de forma inteligente en ubicaciones basadas en rutas y nombres del archivo, en lugar de valerse de un servidor de metadatos como ocurre con algunos otros sistemas de archivos distribuidos. En consecuencia, este sistema permite evitar cuello de botella de rendimiento de metadatos y puede ejecutarse en hardware muy heterogéneo.
Un volumen viene a ser un conjunto de “ladrillos”. Un ladrillo es cualquier directorio en un sistema de archivos de disco subyacente. La mayoría de las operaciones de GlusterFS suceden en el volumen. GlusterFS admite diferentes tipos de volúmenes que están optimizados para escalar la capacidad de almacenamiento, mejorar el rendimiento o ambos. Es posible que desees consultar Gluster Docs en http://bit.ly/2zhI51S para obtener más información. En este artículo, analizare dos tipos en concreto, el volumen replicado y el volumen replicado distribuido que requieren dos y cuatro servidores (o HC1), respectivamente. En mi opinión, estas son las configuraciones más adecuadas para el uso doméstico.
El volumen replicado implica que los archivos siempre se escriben en los ladrillos de dos servidores. Esto es el equivalente al RAID 1. En un volumen replicado distribuido, los archivos se escriben en un servidor o en otro dentro de un conjunto fiable de nodos GlusterFS. Discutiremos estos conjuntos fiables más adelante. Los ladrillos de los dos servidores se replican en los otros dos servidores dentro del conjunto. Esto es similar al RAID 1 + 0, pero con una diferencia importante: RAID 1 + 0 usa striping, lo que significa que diferentes bloques de un archivo se escriben en diferentes servidores. En la distribución, un archivo está escrito por completo en un servidor u otro y los contenidos de los dos servidores se replican en otros dos servidores, tal y como describe el siguiente diagrama.
Figura 1 - Replicado distribuido
Utilizar un volumen replicado distribuido evita la pérdida de datos cuando falla uno servidor. También mejora el rendimiento cuando accedes simultáneamente a archivos que han sido distribuido en dos servidores independientes. En lugar de tener un servidor que sirve archivos, cuentas con dos proporcionado archivos. Ahora que ya hemos abordado la teoría, vamos a meternos de lleno en el desarrollo de estos volúmenes.
Montar un volumen GlusterFS replicado distribuido
La Figura 2 muestra una foto de mi configuración. A la izquierda están los cuatro ODROID-HC1 apilados y a la derecha, el clúster ODROID-MC1. Ambos descansan sobre un switch Gigabit de 16 puertos al cual están conectados.
Figura 2 - Entorno de laboratorio
Configurar los ODROID-HC1s
Necesitarás copiar la imagen del sistema operativo en tu tarjeta SD para iniciar tus HC1. Después, define una dirección IP estática y un nombre de host único para cada HC1. Puede que quieras recurrir a las instrucciones de cómo configurar el sistema operativo en cada nodo del clúster de mi artículo sobre el MC1 en http://bit.ly/2lrzVhb. Cambia los nombres de host a xu4-gluster0, xu-4-gluster1, xu-4-gluster2, y así sucesivamente.
Instalar y formatear el disco duro
Inserta los discos duros en los conectores SATA de tus HC1. Escribe "sudo -as" para acceder a los privilegios de root y crear una partición de Linux usando fdisk, luego crea un sistema de archivos ext4, tal y como se muestra en la Figura 3.
Figura 3 - fdisk
Crea un directorio llamado /gds/brick1, añade una entrada a /etc/fstab y monta el sistema de archivos. Puedes ver el resultado en la Figura 4.
Añade la siguiente línea a tu /etc/fstab (sin las comillas): “/dev/sda1/gfs/brick1 ext4 defaults 0 1”. A continuación, escribe los siguientes comandos:
$ mount -a
$ mount
Instalar y configurar el volumen y el servidor Gluster
Instalar el servidor GlusterFS
Crear un grupo fiable de nodos GlusterFS. Un grupo de almacenamiento es una red fiable de servidores de almacenamiento. Antes de que uno pueda configurar un volumen GlusterFS, se debe crear un conjunto fiable (de almacenamiento) consistente en servidores de almacenamiento que proporcionen ladrillos a un volumen.
Crear un directorio para el volumen
Crear un volumen replicado distribuido llamado gvolume0
Iniciar el volumen y mostrar su estado
Los comandos utilizados se resumen a continuación (se ejecutan como root):
Ejecuta en todos los servidores HC1 los siguientes comandos:
Desde xu4-gluster0 (u otro servidor GlusterFS), introduce los comandos para crear un grupo fiable de nodos GlusterFS que está compuesto por nuestros 4 HC1:
En un volumen replicado distribuido, los archivos se distribuyen a través de conjuntos de ladrillos replicados. El número de ladrillos debe ser un múltiplo de la cantidad de réplicas, que en nuestro caso es dos. El orden en que se especifican los ladrillos es importante. En el comando "gluster volume create", los ladrillos adyacentes se convierten en réplicas entre sí. Este tipo de volumen proporciona alta disponibilidad a través de la réplica y el escalado a través de la distribución. En nuestro comando, usamos cuatro ladrillos y replicamos dos, lo cual hace que los dos primeros ladrillos se conviertan en réplicas de los otros. Este volumen suele denominarse 2 x 2. La Figura 5 muestra el resultado de algunos de los comandos.
Figura 5 - Crear el volumen
Para aquellos que solo tengan dos HC1 y quieran crear un volumen replicado, simplemente tienen que usar el comando "gluster peer probe" en el otro servidor y reemplazar el comando "gluster volume create" por el siguiente comando:
Ten en cuenta que, si deseas que el montaje sea permanente, debes añadir una entrada en el archivo /etc/fstab.
Una simple prueba
Esta es una simple prueba que muestra la distribución de archivos en un volumen GlusterFS replicado distribuido.
Crea 100 archivos usando el comando:
$ cd /mnt/gfs
$ mkdir testdir
$ cd testdir
$ for i in `seq 1 100`
$ do
$ echo message$i > file$i
$ done
$ ls
El resultado de estos comandos se muestra en la Figura 6.
Figura 6 - Archivos del clientes
Inicie sesión en xu4-gluster0 e introduce los siguientes comandos:
$ cd /gfs/brick1/gvolume0/testdir
$ ls
$ ls | wc -l
Observarás en la Figura 7 que 46 de los 100 archivos están guardados en este servidor, dado que estamos utilizando un volumen replicado distribuido.
Figura 7 - Archivos GlusterO
Inicia sesión en xu4-gluster1 e introduce los mismos comandos:
$ cd /gfs/brick1/gvolume0/testdir
$ ls
$ ls | wc -l
Verás en la captura de pantalla que hay 54 archivos en este servidor. El total en ambos servidores suma los 100 archivos que creamos anteriormente. En nuestro volumen replicado distribuido, los 100 archivos se distribuyen entre los dos servidores, aunque no exactamente en una proporción de 50/50. Encontrarás el mismo resultado si inicias sesión en los otros dos servidores (xu4-gluster2 y xu4-gluster3). Para aquellos que crearon un volumen replicado usando dos ODROID-HC1, verán los 100 archivos en ambos servidores ya que el suyo es un volumen replicado y no un volumen distribuido.
¿Qué será lo proximo?
He descrito cómo montar volúmenes GlusterFS replicados y distribuidos replicados usando dos y cuatros ODROID-HC1 respectivamente. También he mostrado cómo acceder al volumen GlusterFS usando un cliente GlusterFS. En la Parte 2 de este artículo, describiré cómo instalar y utilizar otros clientes, incluidos NFS y Samba (para Windows), para acceder al volumen GlusterFS y comparar el rendimiento de estos clientes.
Regular el contraluz en ODROID-VU7+: Cómo controlar la iluminación de fondo en las plataformas Android ODROID-C1 y ODROID-C2
November 1, 2017By Jörg WolffODROID-C1+, ODROID-C2, Mecaniqueo
Recientemente, he desarrollado un driver para controlar la luz de fondo para ODROID-C1 y ODROID-C2 usando PWM (pin 33). Para poder usarlo, debes copiarlo a la carpeta system/lib/hw/. Tras reiniciar, el driver debería funcionar correctamente.
El driver carga automáticamente los módulos del kernel para PWM, de modo que pwm-meson.ko y pwm-ctrl.ko deben estar presentes, como suelen estarlo normalmente. Ten en cuenta que, si utilizas este driver, sólo podrá usar el PWM y el pin 33 para la luz de fondo. El driver está disponible en http://bit.ly/2ysMPAS.
Para copiar el driver al ODROID-C1, introduce el siguiente comando desde un equipo host que ejecute Android Debug Bridge (ADB) conectado al ODROID-C1 a través de un cable USB:
$ adb push lights.odroidc.so /system/lib/hw/
Para que soporte ODROID-VU8, se debe añadir a boot.ini el argumento de arranque “backlight_pwm=yes|no|invert”:
Para controlar la luz de fondo del VU7+, tendrás que hacer una pequeña modificación. En el pin 4 del controlador de luz de fondo PT4103, deberás soldar una resistencia. Yo utilicé una resistencia de 330 Ohm. No obstante, también debería funcionar sin ella. Independientemente de las especificaciones técnicas del 4103, el pin EN del 4103 en el VU7 + tiene una resistencia de 10k pull-up. Por lo tanto, la luz de fondo del VU7 siempre aparece activada. Medí la corriente con el pin EN conectado a GND. El resultado fue de unos 0.5mA, que proceden de la resistencia pull-up: 5V dividido por 10k. Cogí una resistencia y la pegué a la placa, soldándola con cuidado al pin 4. Esta se puede conectar al pin 33 del ODROID.
Figura 1 - Diagrama esquemático
Figura 2 – Primer plano de la conexión soldada
Figura 3 – Vista panorámica de la conexión soldada
November 1, 2017By Laurent Caneiro (@tipoto)Conociendo un ODROIDian
Por favor, háblanos un poco sobre ti.
Tengo 40 años y nací en Burdeos, Francia. Actualmente vivo en Los Ángeles, California, con mi maravillosa esposa Nathalie y mi hija Hanaé, que es mayor. Trabajo para los estudios de animación de DreamWorks como animador. He trabajado en la industria de la animación desde el 2000. He trabajado en películas como "Cómo entrenar a tu dragón 1 y 2", "Gato con botas", "Kung Fu Panda 3", "Trolls" y algunas más. Actualmente estoy trabajando en "Cómo entrenar a tu Dragon 3" que se lanzará en marzo de 2019. Antes de DreamWorks, trabajé para varios estudios de animación en Luxemburgo, Francia, Bélgica y España, lo cual me permitió descubrir diferentes países al mismo tiempo que enriquecía a mi experiencia.
Figura 1 - Laurent en su estación de trabajo en DreamWorks Animation
¿Cuál es tu formación académica?
No era muy buen estudiante de joven, lo cual me puso en una situación delicada al final de la escuela secundaria. Básicamente no pude elegir la rama que quería, y mi única opción era elegir entre estudios de secretaría o contabilidad. Opté por la contabilidad, a pesar de que ni siquiera sabía de qué se trataba. No obstante, estudié 4 años contabilidad de todas formas y finalmente obtuve mi diploma. Afortunadamente, nunca dejé de dibujar y pintar durante mi tiempo libre, y tras mis estudios de contabilidad, decidí probar con el examen de ingreso en una escuela de animación de Luxemburgo (L.T.A.M.) y ¡lo pasé! Fue entonces cuando me enamoré de la animación.
¿Cómo empezaste con los ordenadores?
Empecé con los ordenadores cuando tenía 8 o 9 años. Por aquel entonces, tenía un ordenador llamado Thompson TO7-70, que creo que sólo se lanzó en Francia. Principalmente jugaba a juegos con él, aunque mi iniciación en la programación también empezó en ese momento. El ordenador usaba el lenguaje BASIC, y como mis padres estaban suscritos a una revista BASIC mensual, pude aprender algunas cosas y empezar a juguetear con el lenguaje.
Figura 2 – El primer ordenador de Laurent, una Thompson T07-70
No soy programador y mis conocimientos son bastante limitados en esta área, pero me fascina este mundo. Soy autodidacta y me gusta escribir pequeñas herramientas útiles que me faciliten mi día a día en el trabajo. Principalmente uso el lenguaje script Shell, aunque también uso en ocasiones Python, Squirrel, C/C ++ y otros lenguajes.
¿Qué te atraje a la plataforma ODROID?
ITenía en mente un proyecto que realmente quería hacer realidad. Primero compré una Raspberry Pi 2, que es un excelente microcontrolador, pero no era lo suficientemente potente para cubrir a mis necesidades, así que decidí investigar otras placas con el fin de reemplazarla. Encontré el sitio web de Hardkernel y descubrí el XU4. Me impresionaron sus especificaciones técnicas, pero también quería saber si la comunidad era lo suficientemente grande, así que consulté los foros de ODROID e hice bastantes lecturas. Tras unas horas llegue a la conclusión de que se trataba de un foro muy activo y que sus miembros parecían siempre estaban dispuestos a ayudar, además de ser técnicamente excelentes. Decidí comprar un XU4 y migrar mi proyecto actual a esta placa.
¿Cómo utilizas tu ODROID?
Uso mi ODROID como consola de juegos retro. He estado trabajando en este proyecto desde 2015, soy bastante lento. Mi proyecto está dividido en dos piezas de hardware, una es la consola en sí y la otra es un joystick arcade para 2 jugadores. Para la consola, uso una pequeña carcasa de PC que modifiqué ligeramente, diseñé una placa de acrílico en la que conecté todos mis componentes (XU4, Hub USB, regulador de voltaje, HDD).
Figura 3: Laurent ha estado desarrollando una consola de juegos personalizada desde 2015
Figura 4 – Interior de la consola de juegos hecha a medida por Laurent
En el caso de los joysticks, los diseñé por completo desde el principio, y también utilicé láminas acrílicas. Utiliza un Arduino combinado con una placa módulo RGB para controlar todos los leds RGB de los botones. Usa un IPAC2 para la comunicación entre los botones y el XU4. La parte del hardware está totalmente finalizada y es completamente funcional, ahora estoy trabajando en el tema del software. Empecé con la imagen OGST de @meveric, pero estoy personalizándolo todo añadiendo un monto de características con el fin de darle un aspecto único y atractivo.
Figura 5 - ¡Los joysticks que Laurent diseñó para su consola de juegos son una autentica obra de arte!!
¿Cuál es tu ODROID favorito y por qué?
Resulta difícil contestar, ya que solo poseo el ODROID-XU4, aunque realmente adoro esta placa.
¿Qué innovaciones te gustaría ver en futuros productos de hardkernel?
Me gustaría ver una placa con un módulo Wifi integrado, un sistema de refrigeración eficiente que evitase cualquier obstrucción cuando las CPU funcionase al 100% y un excelente soporte GPU en Linux.
¿Qué pasatiempos e intereses tienes a parte de los ordenadores?
Disfruto con la fotografía y suelo tocar la guitarra y el piano.
¿Qué consejo le darías a alguien que quieres aprender más sobre programación?
Empezar con un lenguaje amigable que tenga un excelente soporte en Internet, para que siempre puedas encontrar soluciones a tus problemas. Ponte a prueba con pequeños proyectos con los que te diviertas. No intentes ir demasiado rápido, necesitas retarte a ti mismo paso a paso, de este modo podrás aprender y mantenerte al mismo tiempo motivado. No querrás sentirte abrumado con algo que sea demasiado complicado como proyecto inicial. Si planificas tus progresos lentamente, siempre estarás listo para resolver el siguiente problema al que te enfrentes.
Yo lo que hago personalmente es lo que denomino “un estampado” antes de empezar a “elaborar” código, que no es otra cosa que crear una vista esquemática de lo que quiero hacer en papel, de modo que tenga una visión global de todo mi código antes de iniciarlo. También recomiendo usar Internet tanto como puedas como recurso educativo.
Figura 4 - Validando los archivos de actualización en
