Intel galileo gen1

Práctica Profesional Supervisada - Ingeniería en Computación
Intel Galileo GEN1
Milton Alberto Meroni
Contacto: miltonmeroni@gmail.com
III-LIDI - Facultad de Informática UNLP, 50 y 120, La Plata

Intel Galileo GEN1
Contenido
Introducción..................................................................................................................................... 1
Características principales............................................................................................................... 1
Detalles de arquitectura ................................................................................................................... 4
Fuente de alimentación.................................................................................................................... 4
Comunicación.................................................................................................................................. 4
Kit de desarrollo Intel IoT ............................................................................................................... 5
Node.JS............................................................................................................................................ 5
Puesta en marcha de la placa y el Entorno Intel XDK .................................................................... 6
Programación sobre Intel® XDK IoT Edition .............................................................................. 14
Entrada-Salida en Intel Galileo...................................................................................................... 19
Librería “mraa”.......................................................................................................................... 19
Conexión de Shield en la placa Intel Galileo ............................................................................ 29
Pruebas realizadas con distintos sensores y actuadores utilizando “mraa”............................... 29
GPIO - Encendiendo un led externo...................................................................................... 30
Aio – Prueba de entrada analógica con potenciómetro ......................................................... 31
PWM - Control de intensidad de un led mediante PWM variando el ciclo de trabajo con un
potenciómetro........................................................................................................................ 33
I2C - Utilización de un Display LCD.................................................................................... 35
Librería “upm”........................................................................................................................... 37
Pruebas realizadas con distintos sensores y actuadores utilizando “upm”................................ 38
Utilización de un Display LCD ............................................................................................. 38
Utilización de sensor TOUCH............................................................................................... 39
Utilización de un Buzzer ....................................................................................................... 40
Utilización de un Micrófono.................................................................................................. 41

Intel Galileo GEN1
Utilización del sensor de alcohol MQ3 ................................................................................. 43
Utilización de Joystick .......................................................................................................... 44
Ejemplos adicionales utilizando “mraa” y “upm”..................................................................... 46
Sensor de Temperatura.......................................................................................................... 46
Muestra de temperatura en Display LCD.............................................................................. 47
Sensor táctil con buzzer......................................................................................................... 49
Entrada/Salida con “galileo-io”..................................................................................................... 50
Blinking Led con Galileo-IO..................................................................................................... 50
Servo – Entrada analógica......................................................................................................... 51
Johnny-Five ................................................................................................................................... 52
Ejemplos con Johnny-Five utilizando Galileo-IO......................................................................... 53
Blinking led ............................................................................................................................... 53
Display LCD.............................................................................................................................. 53
Touch con LED ......................................................................................................................... 54
Servo con potenciómetro........................................................................................................... 55
Display LCD con sensor de temperatura................................................................................... 55
Entrada/Salida a través de Linux................................................................................................... 56
Mapeo de puertos GPIO ............................................................................................................ 56
Puertos GPIO............................................................................................................................. 58
Exportar un puerto GPIO........................................................................................................... 58
Blinking led en Bash ................................................................................................................. 60
Puertos Analógicos.................................................................................................................... 60
Lectura de muestras analógicas................................................................................................. 61
Tomando muestras analógicas en Bash................................................................................. 62
PWM.......................................................................................................................................... 63

Intel Galileo GEN1
Configuración de PWM............................................................................................................. 63
PWM en Bash............................................................................................................................ 64
Conclusiones.................................................................................................................................. 65
Links opcionales - MEGA............................................................. ¡Error! Marcador no definido.

Intel Galileo GEN1
1
Introducción
Galileo es un microcontrolador basado en el procesador Intel® Quark SoC X1000 con una
arquitectura de 32-bit. Es la primera placa basada en la arquitectura Intel® diseñada para ser pin-
compatible tanto en hardware como software con los shields Arduino UNO. Posee 12 pines
digitales de entrada/salida (numerados del 2 al 13), los pines digitales AREF y GND; 6 entradas
analógicas, una tira de pins hembra para tomar tensión (5V – 3.3V – GND), pines ICSP, y los pines
0 y 1 del puerto UART. Todos los pines se encuentran ubicados de la misma manera que el Arduino
UNO R3.
Galileo está diseñada para soportar shields que operan tanto con 3.3V o 5V. La tensión principal
en la que opera Galileo es 3.3V. Sin embargo, un jumper en la placa habilita la tensión 5V en los
pines de entrada/salida. Esto provee soporte para los 5V utilizados por los shields UNO.
Galileo contiene sobre su placa: un slot mini-PCI Express, un puerto Ethernet de 100Mb, un slot
para tarjeta Micro-SD, un puerto serie RS232, un puerto Host USB, un puerto Cliente USB, y una
memoria flash NOR de 8Mbyte.
La placa Intel Galileo, es también software compatible con el IDE de Arduino.
Características principales
- 14 pines entrada/salidas digitales
o Posee 6 pines que pueden ser utilizados como salidas PWM (Modulación de ancho
de pulso).
o Operan con 3.3V o 5V.
o Cada pin provee una corriente máxima de 10 mA y puede recibir hasta 25mA.
o Resistencia interna de pull-up (desconectada por defecto) de 5.6K a 10kOhms.
- A0 – A5: Son 6 entradas analógicas, conectadas a un conversor analógico-digital (AD7298)
o Resolución de 12 bits (4096 valores diferentes).
o Rango entre 0 y 5V.
- Bus I2C, TWI:
o TWI (Two Wire Interface): Utiliza los Pines A4 o SDA y A5 o SCL.
Para esta comunicación, la transmisión de datos en serie se realiza en modo
asíncrono. Este protocolo utiliza sólo dos cables para la comunicación entre dos o

Intel Galileo GEN1
2
más circuitos integrados. Posee dos líneas de comunicación bidireccionales
llamadas SDA (Serial Data) y SCL (Serial Clock) con resistencias de pull-up, las
cuales se utilizan para la transferencia de datos entre dispositivos. Uno de los dos
dispositivos, que controla todo el proceso, se conoce como Maestro y la otra que
responde a las consultas de maestro se conoce como dispositivo esclavo. La placa
de desarrollo Intel Galileo solo puede funcionar como Maestro.
- SPI
o Rango de 4Mhz – 25Mhz
Este tipo de comunicación, tiene sólo tres líneas (MISO, MOSI y SCK) para la
transmisión de datos, así como para handshake. En la comunicación SPI sólo hay un
controlador maestro y un controlador esclavo, y por lo tanto el esclavo no requiere
direccionamiento. Es un proceso de comunicación de datos en serie "full duplex".
Aunque Intel Galileo posea un controlador nativo para SPI, actuara solamente como
maestro y no como esclavo.
- UART (Puerto serie)
o Velocidad configurable
o Pines: 0 (Rx) y 1 (Tx)
- ICSP (SPI):
o Son 6 pines para programación serie que permiten la conexión de shields externos.
Estos pines permiten la comunicación SPI utilizando la librería adecuada.
- VIN
o Se permite alimentar la placa mediante este pin de entrada utilizando una fuente
externa (deberá ser de 5V).
- Pin 5V salida:
o Este pin provee una salida de 5v con una corriente máxima de 800mA.
- Pin 3.3V salida:
o Este pin provee una salida de 3.3v con una corriente máxima de 800mA.
- GND
o Pines de masa general.
- IOREF

Intel Galileo GEN1
3
o Este pin permite a un shield conectado y configurado apropiadamente adaptarse al
voltaje provisto por la placa.
o Este pin está controlado por un jumper en la placa el cual permite el uso de 3.3V o
5V.
- RESET botón/pin:
o Este pin mediante una entrada en bajo, permite resetear la placa.
- AREF
o Este pin no es utilizado.
La Figura 1 muestra un esquema completo de la placa:
Figura 1. Esquema de la placa Intel Galileo GEN1

Intel Galileo GEN1
4
Detalles de arquitectura
 Procesador Intel Quark SoC X1000
o 400Mhz 32-bits.
o ISA (Set de instrucciones) compatible con Intel® Pentium.
o 16 KBytes memoria cache L1.
 512 KBytes SRAM.
 Programación simple: Un hilo, un núcleo, velocidad constante de clock.
 CPU compatible con ACPI, con estados de sleep.
 RTC (Real Time Clock – Reloj de tiempo real).
 Conector Ethernet 10/100.
 Slot de tipo PCI Express 2.0 mini-sd slot.
 Puerto USB 2.0 Host.
 Puerto USB 2.0 Cliente.
 Boton Reboot para reiniciar el procesador.
 Boton Reset para reiniciar el sketch.
 Opciones de almacenamiento:
o Memoria 8MB flash para firmware y el ultimo sketch.
o Entre 256 y 512 KB son dedicados al almacenamiento del sketch.
o 512KB SRAM embebida, habilitada por defecto por el firmware.
o 256MB DRAM, habilitada por defecto por el firmware.
o Micro SD hasta 32gb de almacenamiento. (Preferentemente clase 10).
o 11 KB memoria EEPROM programable a través de librería EEPROM.
Fuente de alimentación
La placa Intel galileo utiliza un transformador AC-DC, y es conectada por un conector tipo plug
de 2.1mm cuyo rango de funcionamiento es de 5V y 3Amp.
Comunicación
Galileo provee una comunicación serie UART TLL (5V/3.3V), que está disponible en los pines
digitales 0 (RX) y 1 (TX). Además, soporta una segunda UART (RS-232) que es conectada vía un
conector Jack 3.5mm.

Intel Galileo GEN1
5
Los puertos USB permiten comunicaciones serie (CDC) a través de USB. Esto provee una
conexión serial al “Serial Monitor” u otra aplicación. El puerto USB Host permite que Galileo
actúe como un host USB para periféricos conectados, tales como mouse, teclados y teléfonos
inteligentes.
Galileo es la primera placa Arduino que provee un slot mini PCI Express (mPCIe). Este slot permite
conectar módulos mPCIe en tamaño completo o en mitad de tamaño (con un adaptador) para que
puedan ser conectados a la placa y, también, proveer un puerto USB Host adicional. Cualquier
módulo estándar mPCIe puede ser conectado y usado para proveer aplicaciones como WiFi,
Bluetooth o conectividad celular. Inicialmente, el slot mPCIe provee soporte para la librería WiFi.
Un conector Ethernet RJ45 permite conectar a Galileo con redes cableadas. Cuando se conecta a
una red, se debe asignar una dirección IP y una dirección MAC. La interfaz Ethernet es totalmente
compatible y no requiere el uso de la interfaz SPI como Arduino.
El lector de tarjetas SD es accesible a través de las librerías SD. La comunicación entre Galileo y
la tarjeta SD es provisto por un controlador SD integrado y no requiere el uso de la interfaz SPI
como otras placas Arduino.
Kit de desarrollo Intel IoT
El kit de desarrollo Intel IoT es una completa solución para crear y probar aplicaciones sobre
plataformas Intel IoT. Este kit provee un conjunto de componentes hardware y software que les
permite a los desarrolladores crear proyectos innovadores usando la placa Intel y el kit de
accesorios (sensores y actuadores – Grove Starter Kit). El kit Intel IoT proporciona software para
programar en JavaScript utilizando el framework Node.JS. Este software cuenta de tres partes
principales: Intel XDK IoT Editión, el sistema Linux Yocto, y un conjunto de librerías. Estas
librerías fueron creadas para proporcionar a los desarrolladores una manera fácil de controlar los
componentes de hardware integrados en las plataformas Intel IoT, así como la manipulación en
alto nivel de sensores y actuadores.
Node.JS
Node.js es un framework asíncrono con una arquitectura orientada a eventos. Funciona con un
único hilo de ejecución, usando entradas y salidas asíncronas las cuales pueden ejecutarse
concurrentemente en un número de hasta cientos de miles sin incurrir en costos asociados al cambio

Intel Galileo GEN1
6
de contexto. Este diseño de compartir un único hilo de ejecución entre todas las solicitudes atiende
a necesidades de aplicaciones altamente concurrentes, en el que toda operación que realice entradas
y salidas debe tener una función callback.
Node.js incorpora varios "módulos básicos" compilados en el propio binario, como por ejemplo el
módulo de red, que proporciona una capa para programación de red asíncrona y otros módulos
fundamentales, como por ejemplo Path, FileSystem, Buffer, Timers y Stream.
Pese a que los módulos pueden instalarse como archivos simples, normalmente se instalan
utilizando el Node Package Manager (npm) que nos facilitará la compilación, instalación y
actualización de módulos así como la gestión de las dependencias.
Este framework es el utilizado para programar la placa de desarrollo utilizando el entorno Intel
XDK IoT Editión.
Puesta en marcha de la placa y el Entorno Intel XDK
Paso 1: Actualización del firmware
En este apartado se explicará cómo actualizar el firmware de la placa Intel Galileo Gen 1.
Paso 1.1: Descargar el software
Primero hay que descargar la herramienta Intel® Galileo Firmware Updater1
, y como se está
trabajando con Windows, se descargará además en el mismo .zip el archivo linux-cdc-acm.inf. A
continuación coloque los dos archivos en una carpeta de su preferencia. Además, en caso de ser
necesario, instalar Java Runtime Enviroment (JRE) v6, Java Enterprise Edition 6 SDK o alguna
versión más reciente.
Paso 1.2: Preparar placa Intel Galileo
Antes de empezar, se debe realizar lo siguiente:
 Remover la fuente de alimentación.
 Remover cualquier cable USB conectado a la placa.
 Remover la tarjeta SD, en caso de estar colocada en la ranura.
1
http://downloadcenter.intel.com/download/24748

Intel Galileo GEN1
7
Nota: Es necesario remover la tarjeta SD ya que no es posible actualizar el firmware cuando la
placa bootea desde una imagen guardada en la tarjeta SD o si hay algún programa corriendo.
Paso 1.3: Conectar la placa Intel Galileo
Conectar la placa Intel Galileo a la computadora con el siguiente procedimiento:
 Siempre conectar a la fuente de alimentación (1) antes del cable USB en el puerto de USB
Client (2) como se muestra en la Figura 2 para prevenir daños en el hardware. El puerto
USB Client es un conector micro USB cerca del puerto Ethernet. Se debe conectar el micro
USB una vez que el led de USB (3) esté encendido.
 Siempre mantener la fuente de alimentación conectada a la placa Intel Galileo cuando se
transfieren programas o se está actualizando el firmware de la placa.
Figura 2. Conectar la fuente de alimentación antes del cable USB
Paso 1.4: Instalar los drivers.
Antes de poder usar la herramienta Intel® Galileo Firmware Updater, hay que asegurarse de que
la computadora contenga los drivers del puerto serie para poder establecer la comunicación con la
placa.

Intel Galileo GEN1
8
Para instalar los drivers en Windows, haga lo siguiente:
1. Conectar la fuente de alimentación y los cables USB, esperar 10 segundos, y abrir el
Administrador de dispositivos (desde el Menú de Inicio, abrir el Panel de Control y
seleccionar Sistema y seguridad en Windows).
2. En Puertos (COM & LPT), se debe ver un puerto llamado Gadget Serial V2.4, si la placa
contiene una vieja versión, como V0.7.5, o simplemente Galileo.
3. Click derecho sobre puerto Gadget Serial V2.4 o Galileo y elegir la opción Actualizar
software de controlador.
4. Seleccionar la opción Buscar software de controlador en el equipo.
5. Navegar hacia la locación donde se descargó el archivo linux-cdc-acm.inf y seleccionarlo.
6. Una vez que el driver es satisfactoriamente instalado, el Administrador de dispositivos
mostrará un dispositivo Galileo (COMx) en Puertos (COM & LPT), como se muestra en la
Figura 3.
Figura 3. Puerto serie de la placa Intel Galileo
Paso 1.5: Actualizar el firmware
Abrir la herramienta Intel® Galileo Firmware Updater descargada en la sección 1.1 y seleccionar
el puerto serie al que está conectada la placa Intel Galileo usando el menú desplegable llamado
Port (Figura 4). Si el puerto seleccionado es el correcto, Current Board Firmware mostrará la
versión actual que la placa tiene instalada.

Intel Galileo GEN1
9
Figura 4. Ventana de Intel Galileo Firmware Updater.
Un mensaje de dialogo (Figura 5) preguntando si “desea confirmar que la fuente de alimentación
está conectada a la placa Intel Galileo”. Si es así, click en OK.
Figura 5. Diálogo para confirmar si la fuente de alimentación está conectada.
Un segundo mensaje muestra cual es la versión actual del firmware de la placa y cuál es la nueva
versión a instalar (Figura 6). Si se está de acuerdo, click en YES.
Figura 6. Diálogo preguntando si la actualización debe proceder.
Precaución: En este punto, el proceso de actualización de firmware comenzará. Durante este
proceso, NO remueva el cable USB o la fuente de alimentación. La actualización tardará
aproximadamente unos 5 minutos.
Si la actualización es satisfactoria, el mensaje que se despliega es el de la Figura 7:

Intel Galileo GEN1
10
Figura 7. Actualización de Firmware satisfactoria.
Paso 2: Preparar tarjeta microSD (Opcional)
La preparación de la tarjeta microSD permite cargar un sistema operativo en la placa de desarrollo,
en este caso será el SO Linux Yocto provisto por Intel. Esto da mayor flexibilidad (herramientas
como SSH y drivers para shields WIFI) que utilizar únicamente el firmware de la placa.
Requisitos
 Tarjeta microSD desde 2GB - 32GB.
 Lector de tarjeta microSD para la computadora.
En Windows
 Descargar y descomprimir la última versión de la imagen2
.
 Una vez descomprimida la imagen, se mostrará el archivo iot-devkit-version-
mmcblkp0.direct.
 Escribir imagen en la tarjeta microSD
1. Descargar la última versión del programa win32diskimager3
.
2. Insertar tarjeta microSD en la computadora.
3. Abrir el archivo Win32DiskImager.exe con permisos de administrador.
4. Hacer click en el icono de carpeta mostrado en la siguiente imagen:
Figura 8. Win32DiskImager
2
http://iotdk.intel.com/images/iot-devkit-latest-mmcblkp0.direct.bz2
3
http://sourceforge.net/projects/win32diskimager

Intel Galileo GEN1
11
5. Buscar en el directorio donde fue extraído el archivo iot-devkit-version-
mmcblkp0.direct. Seleccionar la opción *.* para visualizar cualquier archivo sin
importar la extensión.
6. Seleccionar el archivo iot-devkit-version-mmcblkp0.direct y hacer click en open.
7. Seleccionar de la lista mostrada a continuación, el punto de montaje de la tarjeta
microSD.
8. Clickear en el botón write y esperar que termine la escritura de la imagen.
9. Luego de completarse, realizar click en exit y luego opcionalmente verificar el
contenido de la tarjeta microSD la cual debe tener lo siguiente:
Figura 11. MicroSD con SO Linux Yocto
Nota: Si todos los pasos se realizaron de manera satisfactoria, la tarjeta estará lista para su uso.
Ahora, podrá insertar la tarjeta microSD en la placa de desarrollo Intel Galileo.
Paso 3: Encienda la placa Intel Galileo
1. Verifique que no se encuentre conectado el cable microUSB.

Intel Galileo GEN1
12
2. Conectar el cable de corriente.
3. Si se utiliza el cable USB (En general con Arduino)
a. Esperar que se encienda la luz verde de USB
b. Conectar el cable USB
4. En este caso no se utilizó el cable USB sino que se conecta el cable serie UART
Paso 4: Instalación de controladores
Para la placa Intel Galileo GEN1, no se necesita la instalación de controladores adicionales.
En caso de que no se pueda reconocer el puerto de comunicaciones serie, se deben seguir los
siguientes pasos:
1. Descargar el driver FTDI4
para Windows.
2. Click derecho sobre el archivo descargado, el cual tiene como nombre “CDM…” y
selecciona Ejecutar como administrador.
Figura 12. Driver FTDI Windows
a. Click en Extract
b. Click en Next
c. Click en Finish
d. Ahora debería aparecer una nueva entrada USB Serial Port en “Ports
(COM&LPT)” en la sección de Administrador de dispositivos.
Paso 5: Comunicación
Windows
1. Descargar e instalar el software PuTTy5
.
2. Realizar las siguientes configuraciones
a. Tipo de conexión Serial
4
https://mega.nz/#!ddphEQJZ!yNLQjt_RnTOpR0M7d4qDNBxR-acrT3E6F-6w_aUhEEw
5
http://the.earth.li/~sgtatham/putty/latest/x86/putty.exe

Intel Galileo GEN1
13
b. En el campo Serial Line, escribir el puerto COM# correspondiente al conector
UART de la placa.
c. En el campo Speed colocar el valor 115200.
Figura 13. A la izquierda, el puerto COM# de la placa. A la derecha, configuración de PuTTy.
3. Hacer click en open del PuTTy, luego se abrirá una nueva ventana en la cual se mostrará el
inicio del firmware o sistema operativo en caso de que el mismo este iniciando.
Si el sistema operativo se ya se ejecutando, iniciar sesión con el usuario root y sin
contraseña (En caso de mostrarse una pantalla en toda blanco o toda negra, apretar Enter
dos veces).
Paso 8: Instalación de entorno de desarrollo Intel® XDK IoT Edition.
1. Ingresar y descargar el instalador6
del software correspondiente al sistema operativo.
2. Para Windows
a. Abrir el instalador con permisos de administrador, si aparece un mensaje de
confirmación hacer click en yes.
b. Instalar Bonjour Print Services (Solo Windows).
i. Este programa habilita al XDK IoT Edition a detectar automáticamente los
dispositivos instalados en la red.
1. Descargar Bounjour7
.
2. Click en Download.
6
https://software.intel.com/en-us/iot/software/ide
7
http://support.apple.com/kb/DL999

Intel Galileo GEN1
14
3. Click derecho sobre BounjourPSSetup.exe y luego seleccionar
Ejecutar como administrador. Si un mensaje de configuración
aparece, hacer click en YES para continuar.
4. Seguir las instrucciones del asistente de instalación para instalar
Bonjour.
Figura 14. Instalador de Bonjour Print Services
Programación sobre Intel® XDK IoT Edition
Destello de un led
Dentro de la pestaña Start a new project se selecciona el item Templates como muestra la siguiente
figura:
Figura 15. Intel XDK IoT Edition

Intel Galileo GEN1
15
Luego se elige la opción Onboard led blink y se hace click click en Continue.
Elegir el nombre del proyecto y la ruta donde queremos guardarlo.
Luego se mostrará el entorno listo para programar:

Intel Galileo GEN1
16
En esta etapa se conecta la placa por puerto serie y ethernet.
Conexión Serial:
Luego de conectar el cable serie a la placa se elige en el menú contenedor Port en la esquina inferior
izquierda de la pantalla, el dispositivo serie que representa la placa, además, se deberá configurar
el Baud Rate en 115200, Data Bits en 8, Stop Bits en 1 y Parity en 0.
Finalmente se presiona el botón Connect (si no se conecta, se recomienda presionar el botón Reboot
de la placa para que inicie el sistema operativo).
Figura 16. Conexión serial
En la terminal se verá el booteo del sistema operativo, en caso de que este iniciando, y la posibilidad
de iniciar sesión con el usuario root.
Conexión Ethernet
Para este paso simplemente se conecta un cable Ethernet (Rj-45) a la placa y el otro extremo a un
access point disponible sin la necesidad de una configuración adicional.
Una vez conectado el cable, para ver la dirección IP asignada a la placa deberá ingresar el comando
de ifconfig para luego realizar la conexión IoT posteriormente explicada.
Figura 17. IP a través de ifconfig
Configuración Intel XDK IoT
Para cargar los programas que deba ejecutar necesitará establecer una conexión con la placa a
través de Ethernet.

Intel Galileo GEN1
17
Para ello en el menú contenedor IoT Device se elige la opción Add manual connection que
desplegará una nueva ventana como indica la siguiente figura (Figura 18):
Figura 18. Conexión ethernet
Dentro del campo Address se coloca la IP previamente obtenida a través del comando ifconfig,
luego en los campos User y Password se deberá ingresar el usuario y contraseña siendo el usuario
default root y sin contraseña.
Al botón Connect aparecerá un cartel indicando que la conexión fue establecida:
Figura 19. Conexión establecida
Compilación, carga y ejecución del programa
Para esta etapa se deberán seguir los siguientes pasos:
En botón Manage your daemon/IoT device se deberá hacer click sobre la opción Sync PC time
w/clock on target device y esperar unos segundos.
Figura 20. Manage your daemon/IoT device

Intel Galileo GEN1
18
Luego dentro de la terminal serie ejecutar los siguientes comandos para la instalación de las
librerías MRAA & UPM que luego se utilizarán.
1. echo "src maa-upm http://iotdk.intel.com/repos/1.1/intelgalactic" > /etc/opkg/intel-iotdk.conf
2. opkg update
3. opkg upgrade
Para el funcionamiento del led onboard deberá comentar la línea de código 22 y descomentar la
línea de código 23, resultando de la siguiente manera:
Figura 21. Código a modificar
El código está listo para ser compilado y cargado en la placa.
Para compilar se debe presionar el botón install/Build y esperar unos instantes hasta que se muestre
el resultado en consola.
Figura 22. Resultado al finalizar compilación
Una vez realizado esto, se presiona el botón Upload para cargar el programa en la placa y
finalmente se presiona el botón Run para la ejecutar.

Intel Galileo GEN1
19
Entrada-Salida en Intel Galileo
Librería “mraa”
El manejo de los pines de entrada/salida de la placa Intel Galileo GEN1 se realiza a través de la
librería “mraa8
”. Esta es una librería escrita en C/C++ con una traducción a python, javascript y
java para interactuar con la entrada/salida de Galileo, Edison & otras plataformas. Además, cuenta
con una API estructurada donde los nombres y la numeración de los puertos coinciden con los de
la placa. Esto hace independiente del hardware al programador cuando utiliza esta librería.
La API cuenta con la siguientes interfaces:
 gpio
 i2c
 aio
 pwm
 spi
 uart
 common
A continuación, se detallarán las funciones que posee cada una de las interfaces antes mencionadas:
Interfaz “gpio”: Esta interfaz permite manipular los puertos GPIO de la placa.
 Constructor
o gpio ( pin, owner, raw )
 Instancia un objeto GPIO para luego realizar operaciones sobre él
 pin: número de pin a utilizar
 Funciones: cada una de las siguientes funciones deben ser aplicadas a la variable
instanciada por el constructor.
o isr ( mode, func)
 mode: El modo del flanco a establecer
 Edge_both (Ambos flancos): flanco ascendente y descendente. Es el
único modo que funciona en Intel Galileo GEN 1.
 func: Función que va a ser llamada cuando la interrupción es disparada.
o isrExit()
8
http://iotdk.intel.com/docs/master/mraa/node/modules/mraa.html

Intel Galileo GEN1
20
 Esta llamada, no matará la hilo “isr” inmediatamente, solo cuando este
mismo salga de su sección critica.
o dir (Dir dir)
 Configura el pin como entrada o salida
 dir
 mraa.DIR_IN: Entrada
 mraa.DIR_OUT: Saluda
 mraa.DIR_OUT_HIGH: Salida en alto
 mraa.DIR_OUT_LOW: Salida en bajo
o read ()
 Lee el valor del puerto
o write ( value )
 Escribe un valor en el puerto
 value: valor que se asignara al puerto
o getPin ( raw )
 Retorna el número del pin GPIO.
 raw (opcional): Si el parámetro es establecido como verdadero, retorna el
número real usado dentro del filesystem (Sysfs).
o mode ( mode )
 Cambia el modo del puerto GPIO
 mode:
 mraa.MODE_STRONG: valor por defecto. Modo “strong” alto o
bajo.
 mraa.MODE_PULLUP: interrumpir en flanco ascendente o
descendente.
 mraa.MODE_PULLDOWN: interrumpir solo en flanco ascendente.
 mraa.MODE_HIZ: interrumpir solo en flanco descendente.
Interfaz “aio”: Esta interfaz permite manipular los puertos analógicos de la placa.
 Constructor:
o Aio ( pin)

Intel Galileo GEN1
21
 Instancia un objeto como analógico para luego poder realizar operaciones
sobre él.
 Ej: var analogPin = mraa.Aio(3);
 pin: número del pin.
 Funciones: estas funciones deben aplicarse sobre la variable instanciada por el constructor.
o read()
 Permite leer el valor del pin configurado como analógico. El valor que
devuelve es de 10 bits.
o readFloat ()
 Permite leer el valor del pin configurado como analógico retornando un
valor float normalizado.
o setBit ( bits )
 Establece en cuantos bits será representada la conversión. Ej. 10 bits.
o getBit ( )
 Devuelve la cantidad de bits en que realizará las conversiones.
Interfaz “pwm”: Esta interfaz permite manipular señales pwm.
 Constructor
o pwm ( pin, owner, chipid)
 Permite instanciar un objeto PWM para luego poder realizar operaciones
sobre él.
 pin: número del pin PWM.
o write ( porcentaje )
 Ingresa el ciclo de trabajo en porcentaje.
 El valor debe estar entre 0.0f (que representa el 0%) y 1.0f, por encima o por
debajo de este rango se establecerá en 0.0f o 1.0f.
o read ()
 Retorna el ciclo de trabajo en porcentaje.
o period ( segundos )
 Establece el periodo de la señal PWM en segundos
o period_ms ( milisegundos )

Intel Galileo GEN1
22
 Establece el periodo de la señal PWM en milisegundos.
o period_us ( microsegundos )
 Establece el periodo de la señal PWM en microsegundos.
o pulsewidth ( second )
 Establece el ancho del pulso en segundos
o pulsewidth_ms ( milisecond )
 Establece el ancho del pulso en milisegundos
o pulsewidth_us ( microsecond )
 Establece el ancho del pulso en microsegundos
o enable ( enable )
 Habilita el puerto PWM
 enable
 true
 false
o config_ms ( period, duty )
 Configura el periodo y ciclo de trabajo (duty) en milisegundos.
o config_percent ( period, duty )
 Configura el periodo en milisegundos y ciclo de trabajo (duty) en porcentaje.
Interfaz “i2c”: Esta interfaz permite manipular dispositivos I2C.
 Constructor
o I2c ( bus, raw )
 Instancia un objeto I2C. Pueden existir varias instancias para el mismo bus
y el mismo no garantiza estar en la dirección correcta antes de leer o escribir.
o frecuency ( mode )
 Establece la frecuencia para la comunicación I2C. La placa puede no
soportar un conjunto de frecuencias. Cualquiera puede cambiar esto en
cualquier momento y tendrá efecto en todos los esclavos del bus.
 mode
 mraa.I2C_STD: más de 100Khz
 mraa.I2C_FAST: más de 400Khz

Intel Galileo GEN1
23
 mraa.I2C_HIGH: más de 3.4Mhz
o addrees ( addrees )
 Establece un esclavo para poder hablarle. Típicamente es llamado antes de
cada operación de lectura y escritura.
o readByte ()
 Lee exactamente un byte del bus.
o read ( length )
 Lee una longitud de “length” bytes del bus.
o readReg ( reg )
 Lee un byte desde un registro I2C.
o readWordReg ( reg )
 Lee una palabra desde un registro I2C.
o writeByte ( data )
 Escribe un byte en el Bus
 data: byte a escribir en el bus
o write ( length )
 Escribe “length” bytes en el bus, el primer byte en el buffer es el
comando/registro a escribir.
 length: tamaño del buffer a enviar.
o writeReg ( reg, data )
 Escribe un byte en un registro I2C.
 reg: registro a escribir
 data: valor a escribir en el registro
o writeWordReg ( reg, data )
 Escribe una palabra en un registro I2C.
 reg: registro a escribir
 data: valor a escribir en el registro
Interfaz “UART”
 Constructor
o Uart ( uart )

Intel Galileo GEN1
24
 Toma el número de un pin el cual será mapeado directamente al número
“uart” de linux, esto habilita el “uart” solamente.
 uart: número del uart a utilizar.
o Uart ( path )
 Toma un string como ruta para la interfaz serie.
 uart: string que representa a la ruta.
o getDevicePath ()
 Retorna un string con la ruta del dispositivo tty de linux.
 Ej: “"/dev/ttyS0”
o read ( length )
 Lee “length” bytes del dispositivo.
 length: tamaño de los datos a leer.
o write ( length )
 Escribe “length” bytes en el dispositivo.
 length: tamaño de los datos a enviar.
o readStr ( length )
 Lee “length” bytes desde el dispositivo en un objeto String.
o writeStr ( data )
 Escribe bytes de un objeto String en el dispositivo.
o dataAvailable ( millis )
 Verifica si los datos están disponibles para lectura en el dispositivo.
 millis: número de milisegundos a esperar. Si es cero, retorna
inmediatamente.
o flush ()
 Envia efectivamente los datos que estan en el buffer.
o setBaudRate ( baud )
 Establece el baud-rate.
 baud: valor del baud rate.
o setMode ( byteSize, parity, stopbits )
 Establece el modo de transferencia. Ej. 8N1.

Intel Galileo GEN1
25
 byteSize: bits de datos
 parity: establece la paridad
 stopbits: bit de parada.
o setFlowControl ( xonxoff, rtscts )
 Establece el control de flujo.
 xonxoff: XON/XOFF Control de flujo por software.
 rtscts: RTS/CTS Control de flujo por hardware.
o setTimeout ( read, write, interchar )
 Establece el timeout para leer y escribir operaciones. Menor o igual que cero,
deshabilita el timeout.
 read: establece el timeout para lectura.
 write: establece el timeout para escritura.
 interchar: tiempo de espera entre caracteres.
Interfaz “spi”
 Constructor
o Spi ( bus )
 Inicializa el objeto SPI usando el mapeo de pines de la placa.
 bus: define el bus, normalmente inicializado en 0.
o mode ( mode )
 establece el modo del dispositivo SPI.
 Mode
 SPI_MODE0
o CPOL = 0, CPHA = 0, Reloj ocioso en bajo, los datos son
registrados en el flanco ascendente, datos de salida (o
cambios) en el flanco de bajada.
 SPI_MODE1
registrados en el flanco descendente, datos de salida (o
cambios) en el flanco de subida.
 SPI_MODE2

Intel Galileo GEN1
26
registrados en el flanco descendente, datos de salida (o
 SPI_MODE3
registrados en el flanco ascendente, datos de salida (o
o frequency ( hz )
 Establece la frecuencia del reloj del dispositivo SPI.
 hz: la frecuencia en unidades de hz.
o writeByte ( data )
 Escribe un solo byte al dispositivo SPI.
 data: el byte a enviar.
o write_word ( data )
 Escribe un byte en el dispositivo SPI.
 data: el byte a enviar.
o lsbmode ( lsb )
 Cambia el modo lsb (bit menos significativo) del SPI.
 lsb: variable booleana. Para usar el bit de transmisión menos significativo,
0.
o bitPerWord ( bits )
 Establece los bits por modo de transacción, por defecto son 8.
 bits: cantidad de bits por palabra.
Interfaz “common”: clases comunes.
 Funciones
o Init ()
 Inicializa MRAA.
 Detecta la plataforma donde se está corriendo e intenta usar el mapa de pines
incluidos, esto es ejecutar en los módulos/librerías “init/load”.
MRAA_SUCCESS indica la correcta inicialización (por primera vez),

Intel Galileo GEN1
27
mientras que MRAA_ERROR_PLATFORM_ALREADY_INITIALISED
indica que la placa ya está correctamente inicializada.
o getVersion ()
 obtiene la versión de la librería mraa. Por ejemplo, v0.4.0-20-gb408207.
o setPriority ( priority )
 Esta función intenta establecer una prioridad al proceso mraa y establece el
planificador en SCHED_RR (Round-Robin). La prioridad mayor es,
típicamente, 99 y la mínima es 0. Esta función, establecerá la máxima
prioridad en caso de que el parámetro sea mayor a 99. Si falla al establecer,
retorna -1.
o getPlatformType ()
 Obtiene el tipo de plataforma, la placa debe estar inicializada.
o printError ( result )
 imprime una representación textal de los mraa::result
o pinModeTest ( pin mode )
 Chequea si el pin es apto para ser usado en un modo
 pin: número del pin físico.
 mode: modo para ser testeado.
 PIN_VALID: si el pin es válido.
 PIN_GPIO: si el pin es de entrada salida de propósito general.
 PIN_PWM: si el pin soporta ancho de pulso modulado.
 PIN_FAST_GPIO: si el pin soporta entrada salida de propósito
general más rápido.
 PIN_SPI: si el pin soporta el protocolo SPI.
 PIN_I2C: si el pin soporta el protocolo I2C
 PIN_AIO: si el pin es de entrada analógica.
 PIN_UART: si el pin soporta el protocolo UART.
 adcRawBits ()
 Chequea el tamaño del bit de la placa cuando lee el valor.
 Lo bits puros que se leen del módulo del kernel. Cero si no hay
conversión.

Intel Galileo GEN1
28
 adcSupportedBits()
 Retorna la cantidad de bits que soporta el ADC.
 getPlatformName ()
 Retorna el nombre de la plataforma. Retorna NULL si no hay
plataforma inicializada.
 getPinCount()
 Retorna la cantidad de pines físicos que están en funcionamiento en
la placa.
 getI2cBusCount()
 Obtiene la cantidad de buses utilizables para el protocolo I2C. La
placa debe estar inicializada.
 getI2cBusId ( i2c_bus )
 Obtiene el número de adaptador I2C en el file system.
 i2c_bus: el número del bus lógico.
 getPinName ( pin )
 Obtiene el nombre del pin. La placa debe estar inicializada.
 pin: número del pin.
 setLogLevel ( level )
 Establece el nivel de registro desde 0-7, siendo 7 el registro más
detallado.
 level: número de nivel de registro.
 hasSubPlatform ()
 Detecta la presencia de una sub plataforma
 Retorna verdadero si hay una sub plataforma presente y está
inicializada. Falso en el otro caso.
 isSubPlatformId ( pin_or_bus_id )
 Verifica si un pin o un bus está incluida en la máscara de la sub
plataforma.
 getSubPlatformId ( pin_or_bus_index )
 Convierte el índice de un pin o un bus a la identificación
correspondiente en la sub plataforma.

Intel Galileo GEN1
29
 getSubPlatformIndex ( pin_or_bus_id )
 Convierte la identificación de un pin o un bus al índice.
Conexión de Shield en la placa Intel Galileo
El Shield UNO (Figura 23) es un adaptador, o “poncho” que se utiliza para expandir los puertos
de una placa Arduino. Teniendo en cuenta que la disposición de los pines de Galileo es compatible
con Arduino, será utilizado para realizar distintas pruebas.
Figura 23. Shield UNO
La conexión es simple, pero para una mejor comprensión, se mostrará en la Figura 23 como queda
finalmente colocado.
Figura 24. Shield UNO sobre Galileo
Pruebas realizadas con distintos sensores y actuadores utilizando “mraa”.
En las pruebas que se detallan a continuación, se utilizaron varias interfaces de la librería mraa y
en alguno de estos casos el “shield” antes mencionado.

Intel Galileo GEN1
30
La placa deberá estar conectada al entorno Intel XDK, tal como se explicó en los apartados
anteriores (puerto serie - plug 3.5 a USB - y Ethernet).
Después de haber creado cada proyecto, se deberá compilar, cargar y ejecutar para que el mismo
comience a correr.
GPIO - Encendiendo un led externo.
Con la finalidad de probar los puertos GPIO de la placa, se conectó un LED externo. A
continuación, en la Figura 25, se detalla el esquema de conexión.
Figura 25. Esquema de conexión
Para este ejemplo, se utilizó el témplate “Onboard Led Blink” provisto por el entorno Intel XDK.
El código que mostrara es el siguiente:
Figura 26. Código “Onboard Led Blink”

Intel Galileo GEN1
31
Como primera medida, se debe importar la librería “mraa”. El paso siguiente, es determinar qué
pin GPIO se utilizará para encender el led. En este caso, se utilizó el pin 13. Tal como se puede ver
en este paso, se instancio un nuevo objeto GPIO y se le asignó un pin.
Luego, se determinó a través de la función “dir” si el pin es de entrada o salida. La variable ledState,
permitirá alternar el valor del pin entre alto y bajo. El led se encenderá a través de la función
“write”, la cual escribirá un “1” para encenderlo y un “0” para apagarlo. El estado del led cambiará
cada un cierto tiempo, y esto está determinado a través de la función “periodicActivity” la cual se
llamará cada 1000 milisegundos (un segundo).
Aio – Prueba de entrada analógica con potenciómetro
El potenciómetro fue conectado a la entrada analógica A0.
Para este ejemplo, se creó un nuevo proyecto utilizando el témplate “Blank Template”. A
continuación se detalla paso a paso para poder realizar este procedimiento.
Paso 1. Elección de témplate “Blank Template”

Intel Galileo GEN1
32
Paso 2. Elegir un directorio donde guardarlo y asignar un nombre al proyecto
Paso 3. Luego de crear el proyecto, se verá esta imagen donde podremos escribir el código.
El ejemplo realizado consta de leer los valores que aporta un potenciómetro en la entrada analógica
A0. Para ello, se ejecutó el siguiente código (Figura 28):
Figura 28. Código ejemplo
Nuevamente, como en el ejemplo anterior, se importó la librería “mraa”. Seguido a esto, se creó
un nuevo objeto “analógico” y se le asignó un pin, en este caso, el pin “A0”. La función
“periodicActivity” se llamará a si misma cada 1000 milisegundos (un segundo) y tiene como

Intel Galileo GEN1
33
objetivo tomar una muestra del pin analógico e imprimir el resultado en la terminal. Cada muestra
es tomada a través de la función “read”.
El resultado que se mostrará es el siguiente:
Figura 29. Lecturas analógicas realizadas
PWM - Control de intensidad de un led mediante PWM variando el ciclo de trabajo con un
potenciómetro.
El potenciómetro se conectó a la entrada analógica “A0”, ésta será leída y de acuerdo a su valor
modificará el ciclo de trabajo de una onda PWM generada como salida en el “pin GPIO 3” al cual
está conectado el LED. Se debe tener en cuenta que el “pin GPIO 3” es uno de los posibles pines
configurables como salida PWM. El esquema de conexión se muestra en la siguiente figura (Figura
30):

Intel Galileo GEN1
34
El código fue generado en un proyecto “Blank Template”, el cual se debe crear de la misma manera
que se explicó en el ejemplo anterior. A continuación, se detalla el código creado (Figura 31), y
seguido a esto la correspondiente explicación.
Figura 31. Código ejemplo
El primer paso, de la misma manera que lo realizado en los demás ejemplos, es importar la librería
“mraa”. Luego, se debe crear un objeto PWM y asignarle un pin, en este caso el “pin GPIO 3”.
Cuando se crea una señal PWM, son necesarias dos configuraciones: habilitar el puerto PWM a
través de la función “enable” y establecer el periodo de la señal, en este caso se ingresó en
microsegundos a través de la función “period_us (valor)”.
Para utilizar el potenciómetro, se deben realizar las mismas configuraciones que en el ejemplo
anterior. Los valores analógicos que se tomarán tendrán un rango de 0 a 1023. Teniendo en cuenta
que el ciclo de trabajo de la señal PWM, el cual es ingresado a través de la función “write”, varía
entre 0 y 1, solo se tomaron los valores analógicos que van desde 0 a 1000. Esto permite que, luego
de dividirlo por 1000, el resultado sea acorde para ser enviado como ciclo de trabajo.
Para los valores analógicos mayores a 1000, queda el valor de la última muestra hasta el siguiente
llamado.
En este ejemplo además, se incorporó la función setInterval, la cual recibe dos parámetros:
 Función a ejecutar.
 Intervalo de tiempo para la ejecución de la función (milisegundos).
Dentro del primer argumento se encuentra el algoritmo descrito:
 Lectura del valor del potenciómetro.
 Acotación del rango.
o Escritura del pin 3.

Intel Galileo GEN1
35
I2C - Utilización de un Display LCD
En este ejemplo, se utilizará el témplate “(I2C) LCD with backlight driver and demostrator” el cual
se tomó de la lista de templetes que ofrece el entorno XDK. El objetivo es mostrar a través del
display LCD los diferentes colores con que puede iluminar su fondo, además de escribir en pantalla
cuál es la composición de cada tono (rojo, azul o verde) con el que se construyó el color.
La comunicación con el LCD debe realizarse a través de un puerto I2C de la placa. Para facilitar la
conexión se utilizó el shield mencionado en el apartado anterior.
Para lograr su propósito, el témplate utiliza una librería “externa” llamada “i2c.js” la cual es
utilizada para administrar el display LCD. Ésta librería se encuentra incluida dentro del proyecto,
y la misma puede ser accedida desde el margen izquierdo del entorno. A continuación, la siguiente
figura (Figura 32) muestra donde se encuentra ubicada:
Figura 32. Ubicación de librería “i2c.js”
El ejemplo consiste de dos funciones:
 rotateColors(display): se encarga de ir variando los colores del fondo del display LCD. El
color será compuesto por los colores rojo, verde y azul (RGB). Una vez generado el nuevo
color, se establece en el LCD, luego, se posiciona en la primera línea y escribe las
tonalidades de color rojo y verde; y finalmente, se posiciona en la segunda línea y escribe
la tonalidad del azul. Esta función está dentro de un “setInterval”, es decir, se repetirá cada
un cierto tiempo, en este caso, cada un segundo.

Intel Galileo GEN1
36
Figura 33. Función “rotateColors”
 useLcd(): esta función tiene como objetivo manipular el display LCD a través de la librería
“i2c.js” que se mencionó anteriormente. Como primera medida, se importa la librería e
instancia un objeto que represente la conexión I2C con el LCD enviando como parámetro
el “bus” por el cual se conectará. Luego, realiza la inicialización del display estableciendo
el color inicial y escribiendo en las dos líneas disponibles. Además, se utiliza la función
“waitForQuiescent”, la cual se encuentra dentro de la librería importada, que devolverá
cualquier error o el éxito cuando se completen las operaciones en cola; y la función
"clearError" despejará cualquier error para que pueda seguir utilizando la pantalla LCD.
Figura 34. Función “useLcd”

Intel Galileo GEN1
37
En la figura siguiente (Figura 35) se muestra como se conectó el display LCD, y además, lo que
éste mostrará cuando el proyecto esté corriendo.
Figura 35. Conexión y resultado
Nota: este ejemplo puede no funcionar para las versiones menores a la 0.6.1 de la librería “mraa”.
Librería “upm”
La API UPM9
es una librería en alto nivel de sensores para dispositivos IoT, que utiliza “mraa”.
Cada sensor contiene un encabezado que permite interactuar con el mismo. Típicamente un sensor
está representado como una clase y es instanciado. El constructor inicializa el sensor y los
parámetros pueden ser usados, por ejemplo, para proveer el número de pin en la placa.
Esta librería provee soporte a sensores que pueden conectarse a través de los pines analógicos,
puertos gpio, i2c, pwm, spi y uart.
Existen un gran número de dispositivos que están comprendidos dentro de esta librería. Para poder
utilizarlos, es necesario instalar el módulo correspondiente, lo cual se realiza de la siguiente
manera:
 Abrir la terminal de comandos a la cual se encuentra conectada la placa
 Escribir el siguiente comando
o npm install jsupm_<module-name>
9
http://iotdk.intel.com/docs/master/upm/node/

Intel Galileo GEN1
38
Por ejemplo, si se desea utilizar el display LCD, es necesario instalar el módulo como se indica a
continuación:
npm install jsupm_i2clcd
Es posible tomar conocimiento de los métodos que posee cada módulo de esta librería accediendo
a la página que se muestra al pie.
Pruebas realizadas con distintos sensores y actuadores utilizando “upm”
Para llevar a cabo estas pruebas, será necesario la utilización del shield UNO.
Nota: luego de haber creado un proyecto y escrito el código, será necesario compilar, cargar y
ejecutar, para que el mismo comience a correr.
Utilización de un Display LCD
Este ejemplo tiene como objetivo lograr lo mismo que se propuso en lo realizado con la librería
“mraa”, pero en este caso utilizando “upm”, mostrando así la facilidad que ésta ofrece para la
manipulación de dispositivos.
Se comenzará con la creación de un “Blank Template”. Una vez creado éste, se llamará a la función
“useUpm()”, la cual se explicará a continuación.
En este caso, al igual que en el ejemplo anterior, existen dos funciones:
 rotateColors(display): realiza la misma tarea que antes.
 useUpm(): esta función importará el modulo “jsupm_i2clcd”. Luego, instanciará un objeto
“lcd” el cual depende el modelo utilizado, en este caso “Jhd1313m1”, y lo inicializará. Los
parámetros que recibe son: bus, lcdAddress, rgbAddress. Siguiendo, se posiciona en las
distintas líneas del display y escribe en ellas. Finalmente, realiza el llamado a la función
“rotateColors” enviando el display instanciado como parámetro.
Figura 36. Función “useUpm”
Nota: este ejemplo puede no funcionar para las versiones menores a la 0.6.1 de la librería ‘mraa’.

Intel Galileo GEN1
39
Utilización de sensor TOUCH
El dispositivo utilizado es un sensor TOUCH, como el mostrado en la siguiente figura (Figura 37).
Figura 37. Sensor TOUCH
Para utilizarlo es necesario instalar, tal como se mencionó anteriormente para el Display LCD, el
modulo “upm” correspondiente. En este caso, el sensor corresponde con el modelo TTP223 que
ofrece “upm”. El comando para realizar la instalación es el siguiente:
npm install jsupm_ttp223
El objetivo de este ejemplo es chequear si el sensor está siendo presionado e imprimir en consola
el resultado. Para llevarlo a cabo, se deberá crear un nuevo “Blank template”. El código en cuestión
se muestra a continuación (Figura 38):
Figura 38. Código “Utilización de sensor touch”
Como primera medida, se importó el módulo antes instalado y se instanció un objeto TTP223
enviando como parámetro el “pin GPIO” al cual está conectado, en este caso “pin 3 - D3 Shield
UNO”. Luego, se creó una función, que será llamada cada 1000 milisegundos, la cual tiene como
objetivo chequear si el sensor está siendo presionado y dependiendo de esto, imprimir el resultado
en la terminal.

Intel Galileo GEN1
40
Utilización de un Buzzer
El “buzzer” utilizado es el que se muestra en la Figura 39.
Figura 39. Buzzer
Es necesario instalar el módulo correspondiente al mismo. Tal como se realizó antes:
npm install jsupm_buzzer
El objetivo es reproducir una melodía y, para llevarlo a cabo, se debe crear un nuevo “Blank
Template”.
Figura 40. Código “Utilización de un Buzzer”

Intel Galileo GEN1
41
Al igual que lo realizado en todos los ejemplos, se deberá importar el módulo correspondiente.
Luego, es necesario instanciar el objeto “buzzer” y enviar como parámetro el “pin GPIO” al cual
está conectado, en este caso “pin 3 - D3 Shield UNO”.
Siguiendo, se creó un arreglo el cual posee una combinación de notas, las cuales son provistas por
“upm”. También, se estableció el volumen con el cual se desea que se escuche cada nota. Este
volumen varía en un rango 0.0 a 1.0.
La función “melody()” será llamada cada 100 milisegundos, y tendrá como objetivo realizar el
recorrido por cada una de las posiciones del arreglo, y utilizando la función “playSound”, enviará
cada nota y el tiempo (microsegundos) que la misma estará “activa”, para que sea escuchada.
Utilización de un Micrófono
El micrófono utilizado es el que se muestra en la Figura 41.
Figura 41. Micrófono
Para poder utilizarlo, se instaló el módulo correspondiente:
npm install jsupm_mic
El objetivo es mostrar en la terminal un “grafico” el cual dependerá de la intensidad de la entrada
que este capturando el micrófono. Además, mostrará el valor “umbral” cuando el mismo sea mayor
que 30.

Intel Galileo GEN1
42
Figura 42. Código “Utilización de un micrófono”
Para este ejemplo, fue necesario crear un nuevo “Blank Template”. Se importó el módulo
“jsupm_mic”, y se instanció el objeto correspondiente al micrófono, enviando como parámetro a
su constructor el “pin ANALOGICO” al cual está conectado, en este caso “pin 0 - A0 Shield UNO”.
El loop principal toma una muestra cada 2 microsegundos, calcula el promedio de 128 muestras, e
imprime el valor del umbral junto a un gráfico de los promedios obtenidos.
La función “getSampledWindow”, tiene como tarea tomar un conjunto de muestras. Recibe tres
parámetros, el primero corresponde al tiempo entre cada muestra, el segundo es la cantidad de
muestras y el tercero el buffer en el cual éstas se almacenan. Devuelve como resultado la longitud
del buffer.
La función “findThreshold” devuelve TRUE/FALSE si el buffer de muestras alcanza el umbral.
Recibe los siguientes parámetros: “threshContext”, valor umbral, buffer de muestras y longitud del
buffer.
La función “printGraph” será la que imprima el promedio en consola.
El resultado se muestra en la Figura 43, donde la línea punteada hace referencia al gráfico de
promedios impreso por la función “printGraph”. La “longitud” de la línea depende del valor del
promedio. Además, se imprime el valor del umbral, siempre que éste sea superado.

Intel Galileo GEN1
43
Figura 43. Gráfico resultado
Utilización del sensor de alcohol MQ3
El sensor MQ3 es el que se muestra en la Figura 44.
Figura 44. Sensor MQ3
Instalación del módulo correspondiente:
npm install jsupm_gas
Este ejemplo, si bien opera con un sensor de alcohol, es similar al anterior. El objetivo es realizar
un “grafico” que dependa de los valores de entrada aportados por el sensor.
Figura 45. Código “Utilización del sensor de alcohol MQ3”

Intel Galileo GEN1
44
Se creó un proyecto “Blank Template”, se importó el módulo “jsupm_gas” y, se instanció un nuevo
objeto MQ3 enviando como parámetro el “pin ANALOGICO” al cual se conecta, en este caso “pin
0 - A0 Shield UNO”. El loop principal toma una muestra cada 2 microsegundos, calcula el
promedio de 128 muestras, e imprime un gráfico con los promedios obtenidos.
El resultado se muestra a continuación:
Figura 46. Gráfico resultante
Utilización de Joystick
Para la utilización del Joystick, el módulo que nos provee “upm” es el “jsupm_joystick12”. El
modelo correspondiente a este módulo es el que se muestra en la Figura 47. Como no se dispone
del mismo, se realizó una prueba con otro joystick, distinto al modelo recomendado, pero
esperando poder detectar el movimiento de la “palanca”. El joystick utilizado se muestra en la
Figura 48.
Figura 47. Joystick recomendado

Intel Galileo GEN1
45
Figura 48. Joystick utilizado
Tal como lo realizado en los ejemplos anteriores, será necesaria la instalación del módulo:
npm install jsupm_joystick12
El objetivo del ejemplo es detectar el movimiento del Joystick, tanto en el “eje x” como en el “eje
y”.
Figura 49. Código “Utilización de Joystick”
Para lograrlo, se creó un “Blank Template” y se importó el módulo instalado. Luego, se instanció
un nuevo objeto Joystick12, enviando al constructor, en el primer parámetro el “pin
ANALOGICO” al cual está conectado el “eje x”, y en el segundo, el “eje y”.
Se creó una función “setInterval” que se ejecutará cada un segundo, y se encargará de tomar los
datos que aporta el Joystick sobre los ejes “x” e “y”, a través de las funciones “getXInput” y
“getYInput”. Además, imprimirá un valor “redondeado y acotado” de los datos obtenidos.
La función “roundNum”, es recomendada por “upm”, y se encarga de redondear el valor analógico
que aporta el Joystick. Recibe dos parámetros: el primero corresponde al número que debe
redondear y el segundo a la cantidad de decimales que se quiere acotar.

Intel Galileo GEN1
46
Tal como se mencionó antes, el Joystick utilizado no es el recomendado a usar con el modelo
“Joystick12”, por lo que los valores que mostró como resultado no son amigables, pero aun así, se
pudo detectar el movimiento de la “palanca”.
Cuando el Joystick está en el centro:
 X: -0.786093
 Y: -0.735696
Cuando varía el Joystick hacia un lado del eje:
 X: -1
 Y: -1
Cuando varía el Joystick hacia el lado contrario:
 X: -0.388742
 Y: -0.36505
La Figura 50 muestra lo antes mencionado:
Figura 50. Resultado obtenido
Ejemplos adicionales utilizando “mraa” y “upm”
Sensor de Temperatura
El objetivo de este ejemplo es tomar los datos del sensor de temperatura, convertir estos datos a
grados celsius (ºC) e imprimir el resultado en la terminal.
Se utilizó un nuevo “Blank Template”. El sensor se encuentra conectado al “pin ANALOGICO 0
- A0 Shield UNO”.

Intel Galileo GEN1
47
Figura 51. Código “Sensor de temperatura”
Luego de configurar el pin analógico, se toma el valor proporcionado por sensor, se calcula la
resistencia del mismo y finalmente se obtiene al valor de temperatura. Esto se realizará cada 1000
milisegundos. Los cálculos realizados para obtener la resistencia y la temperatura fueron provistos
por el datasheet.
Muestra de temperatura en Display LCD
Para este ejemplo, nuevamente se creó un “Blank Template”. Será necesario utilizar el sensor de
temperatura, el cual se conectó en la entrada “A0 Shield UNO - pin ANALOGICO 0”, y el Display
LCD, conectado a la entrada “I2C”.
Para la primer parte del ejemplo (Figura 52), se crearon las variables correspondientes para el
cálculo de la temperatura (en este caso la variable B necesaria para la conversión). Luego, se
verifica la versión de la librería “mraa” para corroborar que el display LCD funcione
correctamente, se crea la variable que permitirá tomar los datos desde la entrada A0 y se hace el
llamado a la función useUpm().
Figura 52. Primera parte del ejemplo

Intel Galileo GEN1
48
Tal como se explicó en el apartado anterior, la función “useUpm” (Figura 53) se encargará de
importar y configurar al display LCD. En este caso particular, se llamará a una función denominada
“temperatura” que será la que calcule y visualice los valores de temperatura en el display LCD.
Figura 53. Función “useUpm”
La función temperatura (Figura 54) se encarga de obtener la muestra desde el pin A0, cada un
segundo, y, a partir de cálculos provisto en el datasheet del sensor, se obtiene la temperatura en
grados Celsius. Con dicha muestra, se posiciona en la primera línea y escribe el mensaje
“Temperatura=xx.x”, mientras que en la segunda línea se escriben guiones para completar los
caracteres del display LCD.
Figura 54. Función “temperatura”
El resultado final es el siguiente:

Intel Galileo GEN1
49
Sensor táctil con buzzer
Se creó un nuevo proyecto “Blank Template”. En el mismo se realizó un programa simple en el
cual se emite un sonido cada vez que se toca el sensor táctil.
El sensor táctil está conectado a la entrada “D2 Shield UNO - pin GPIO 2”, mientras que el buzzer
está conectado a la entrada “D6 Shield UNO- pin GPIO 6”.
A continuación, en la Figura 57, se detalla el código en cuestión:
Figura 57. Código “Sensor táctil con buzzer”

Intel Galileo GEN1
50
Lo primero a realizar es configurar los puertos, el D2 como entrada y D6 como salida. Siguiendo
a esto, se llamará a la función “startSensorWatch”, la cual inicializa el puerto D6 en bajo, es decir,
escribe un “0” en el mismo. Luego, entrará en un loop que se ejecutara cada 10ms, donde realizará
el chequeo de lo que recibe del sensor, y a partir de esto, emitirá o no un sonido. Dependiendo de
qué tan rápido se ejecuta el loop, será el retardo que tenga en sensar si se está presionando o no.
Como resultado, en la terminal se deberá ver lo siguiente:
Entrada/Salida con “galileo-io”
Galileo-IO es una clase para escribir programas Node.js, compatible con Firmata.js, que se ejecutan
en el procesador Intel Galileo o el Intel Edison. Es posible instalar esta clase a través de comando:
npm install galileo-io
Los métodos que posee son los siguientes:
 digitalWrite (pin, 1|0)
o Establece el pin en “1” o “0”.
 analogWrite(pin, value)
o Establece el valor del pin entre 0 y 255.
 digitalRead(pin, handler)
o Lee el valor digital del pin.
 analogRead(pin, handler)
o Lee el valor del pin, el cual es un valor entre 0 y 4095.
 servoWrite(pin, value)
o Establece el pin con un valor entre 0 y 180°.
Blinking Led con Galileo-IO
El código que se muestra a continuación, muestra cómo realizar un blinking led.

Intel Galileo GEN1
51
Figura 59. Código “Blinking led con galileo-io”
Tal como se puede ver, lo primero que se debe realizar es importar la librería “galileo-io”, y luego
instanciar un objeto “board”, la cual representará la placa Intel Galileo.
La función que recibe como parámetro el método “board.on”, tendrá la lógica del ejemplo. Dentro
de ésta, se configurará el “pin 8” como salida a través de “pinMode (8 , this.MODES.OUTPUT)”.
El led deberá estar conectado al pin antes configurado.
Luego, la función “digitalWrite” escribirá valores alternados entre “0” y “1” para encender/apagar
el led. Esto lo realiza dentro de un “setInterval” el cual repetirá dicha instrucción cada 500
milisegundos.
Servo – Entrada analógica
A continuación, se muestra un ejemplo, donde se realizaron tres actividades: En el “pin 6” se hizo
parpadear un led; en el “pin 3” se colocó un servo, el cual varía su ángulo de movimiento desde
“0” a “180”; y a través del “pin A0”, se leyeron los valores aportados por un sensor (este puede ser
un potenciómetro).

Intel Galileo GEN1
52
Figura 60. Código “servo-entrada analógica”
Johnny-Five
La clase Galileo-IO, mencionada anteriormente, es el “layer IO” por defecto para los programas de
"Johnny-Five" que se ejecutan en una placa Galileo o Edison.
Johnny-Five permite utilizar los puertos de una manera simple y en alto nivel.
Para instalar “johnny-five” y “galileo-io” (en caso de no haberla instalado antes):
npm install galileo-io johnny-five
En cuanto a Intel Galileo GEN1, da soporte a:
 Lecturas analógicas
 Lecturas digitales
 Escrituras digitales
 PWM
 Servo
 I2C

Intel Galileo GEN1
53
Ejemplos con Johnny-Five utilizando Galileo-IO
Blinking led
En este caso, antes de importar “galileo-io”, habrá que importar “johnny-five”. Luego, habrá que
instanciar una “five.Board”, la cual se asociará a la placa “Intel Galileo”.
A través de la función que se envía como parámetro a “board.on”, se configurará el LED 13 para
realizar el parpadeo. Johnny-Five provee una función llamada “blink”, que recibe como parámetro
el delay de parpadeo. Esta función se encarga de realizar la operación de encendido y apagado del
led.
Figura 61. Código “Blinking led”
Cuando el proyecto comienza a correr, en la terminal se mostrará lo siguiente:
Figura 62. Resultado en la terminal
Display LCD
En este ejemplo, se comenzara realizando la importación de “johnny-five” y “galileo-io”, como en
el punto anterior. Siguiendo a esto, en la función que recibe el método “board.on”, se creó un nuevo
objeto LCD, el cual permite seleccionar el dispositivo utilizado, en este caso “JHD1313M1”.

Intel Galileo GEN1
54
Para escribir en la primer línea del display, se utiliza la función “lcd.cursor(0,0).print(“ Linea 1 ”)”,
y para escribir en la segunda, “lcd.cursor.(1,0).print (“ Linea 2 “)”.
La función “lcd.blink” realiza el parpadeo del cursor luego de terminar de escribir en la línea. En
este caso, al finalizar la escritura en la segunda línea, quedará el “cursor” parpadeando.
Nota: el Display LCD fue conectado a una entrada “I2C” del Shield UNO.
Figura 63. Código “Display LCD”
Touch con LED
El objetivo de este ejemplo es utilizar el sensor touch como interruptor para encender un led. Una
vez realizada la importación de las librerías, en la función que recibe como parámetro el método
“board.on”, se realizará la configuración del puerto utilizado para el sensor touch, en este caso el
“pin 4 – D4”, y el utilizado para el led, “pin 6 – D6”.
A través del objeto “touch”, podremos saber cuándo está siendo presionado, para así, encender el
led. Tal como se puede ver, el led se encenderá utilizando la función “led.on()”, y se apagará con
“led.off()”.

Intel Galileo GEN1
55
Figura 64. Código “Touch con led”
Servo con potenciómetro
Para este ejemplo, se conectó el potenciómetro a la entrada “A0 - pin ANALÓGICO 0” y el servo
a la entrada “D5 – pin 5”. El objetivo es tomar los valores del potenciómetro para establecer el
ángulo de movimiento del servo.
Teniendo en cuenta que el potenciómetro arrojará valores desde 0 a 1023, los mismos deberán ser
“escalados” entre “0” y “180”. Esto es realizado a través de la función “scale”. El valor escalado,
será el utilizado para establecer el movimiento del servo con la función “servo.to”.
Figura 65. Código “Servo con potenciómetro”
Display LCD con sensor de temperatura
El objetivo de este ejemplo será calcular el valor aportado por el sensor de temperatura y mostrar
el resultado en el Display LCD. La utilización de este último se realiza de la misma manera que en

Intel Galileo GEN1
56
el ejemplo anterior (Display LCD), en cuanto al sensor de temperatura, será necesario instanciarlo
e inicializarlo. El parámetro “pin”, indica a que pin se conectó, en este caso “A0”, y el parámetro
“controller”, indica al controlador correspondiente al sensor. Una vez instanciado este último, se
tomará una muestra a través de la función “temperature.on”, se aplicará al valor una función de
redondeo (para acotar decimales), y se escribirá en la pantalla del display LCD.
Figura 66. Código “Display LCD con sensor de temperatura”
Entrada/Salida a través de Linux
La mayor parte de las capacidades GPIO de la placa Intel Galileo están expuestas a través de la
interfaz "Sysfs" de Linux, y pueden ser controladas usando archivos. Es posible utilizar algunas de
estas capacidades mediante comandos Shell utilizando una terminal. Además, es posible programar
un script con comandos que configuren la placa para realizar una determinada tarea.
Mapeo de puertos GPIO
El mapeo de los puertos GPIO se encuentra ilustrado en la Figura 67. Las etiquetas de la izquierda
indican los nombres de los puertos en “Sysfs” de las interfaces GPIO y PWM (donde corresponda).
En cuanto a las conexiones del Intel Quark X1000: ttyS0 para las señales del puerto serie; SPI1
para señales de interfaz SPI y I2C para señales I2C.
Las entradas ADC se nombran desde vin0 a vin7 y corresponden a:

Intel Galileo GEN1
57
 /sys/bus/iio/devices/iio:Device0/in_voltageX_raw ; siendo “X” el número del puerto.
Las etiquetas de la derecha indican el nombre de los puertos en el Shield UNO.
Los trapezoides son multiplexores bidireccionales (o interruptores). Son controlados por la señal
que viene en la parte superior (entrada selectora). Cuando el valor del selector es “0” se conecta la
entrada que corresponde al “puerto 0” en la parte izquierda del multiplexor con la salida en el lado
derecho del mismo; cuando el valor del selector es “1” se conecta la entrada que corresponde al
“puerto 1” en la parte izquierda con la salida en la parte derecha. Por ejemplo, si desea conectar el
pin “A1” del shield a Vin1 del ADC, se deberá configurar la “gpio36” a "0".
Figura 67. Mapeo de puertos GPIO

Intel Galileo GEN1
58
Puertos GPIO
El siguiente comando aporta información sobre los puertos GPIO en el sistema y muestra si un
puerto I/O fue asignado a un módulo o Sysfs (usuario).
 cat /sys/kernel/debug/gpio
El resultado es el siguiente:
Figura 68. Comando “cat /sys/kernel/debug/gpio”
Exportar un puerto GPIO
Para hacer el puerto GPIO controlable desde “Sysfs” se necesita exportarlo. Esto se hace
escribiendo el número de puerto GPIO a /sys/class/GPIO/export. En este caso, se utilizara el puerto
GPIO27 en “Sysfs” el cual corresponde con el D7 en el Shield UNO.
El puerto se exporto de la siguiente manera:
El siguiente paso será establecer si el puerto será de “entrada” o “salida”. Para esto, se escribirá
“in” o “out” en el archivo “/sys/class/gpio/gpioXX/direction” (XX – número de puerto), en este
caso se estableció como salida:
Cuando se está utilizando como SALIDA a uno de los puertos GPIO que están conectados a
CY8C9520A, se debe configurar uno de los siguientes modos de funcionamiento:

Intel Galileo GEN1
59
 Drive = pullup
o Este es el modo por defecto, pero no es conveniente para dispositivos que manejan
una cantidad significante de corriente. Por ejemplo, para el manejo de un LED
conectado entre el GPIO y GND.
 Drive = pulldown
 Drive = strong. Alto y bajo
o El modo más apropiado para la mayoría de las aplicaciones
 Drive = hiz. (alta impedancia)
 (CY8C9520A tambien soporta modos de manejo “open drain” y “open source”, pero no se
lo puede configurar a traves del File System (SysFS).
El modo de funcionamiento se establece escribiendo “pullup”, “pulldown”, “strong” o “hiz” en el
archivo /sys/class/gpio/gpioXX/drive:
Una vez realizado lo anterior, será posible poner en alto o en bajo el puerto. Esto se realiza
escribiendo un “1” o “0” en el archivo “/sys/class/gpio/gpioXX/value”.
De la misma manera que se configuro el puerto como salida, es posible configurarlo como entrada.
En ese caso, el valor de entrada se toma desde el mismo archivo, a través del comando “cat”. A
continuación se muestra un ejemplo:
Cuando la operación de configuración se completa con éxito, un directorio que corresponde al
número de puerto GPIO aparecerá en “Sysfs”. Luego de que finalice la utilización del puerto, es
posible revertir la operación de exportación escribiendo el número de puerto GPIO a
“/sys/class/GPIO/unexport”.

Intel Galileo GEN1
60
Blinking led en Bash
Es posible crear scripts que permitan configurar la placa para que realice una tarea en particular.
En el script creado, se configura el puerto siguiendo cada paso explicado en el apartado anterior, y
se realizó un loop, con un retardo de un segundo, que “enciende” y “apaga” el led. El código es el
siguiente (Figura 69):
Figura 69. Script “blink.sh”
Puertos Analógicos
Las entradas analógicas en Galileo fueron implementadas utilizando el ADC AD7298. Este ADC
tiene 8 canales, pero sólo 6 canales están conectados en Galileo. La resolución de cada canal es 12
bits, así que los valores resultantes serán en el rango “0” – “4095”.
 “0” - entrada de tensión de 0 V (tierra)
 “4095” - entrada igual a 5 V (fuente de alimentación).
En "Sysfs" las entradas analógicas se pueden leer desde el archivo:
 "/sys/bus/iio/devices/iio:Device0/in_voltageX_raw"
Dado que las entradas analógicas son multiplexadas con GPIO y I2C (en caso de A4 y A5) es
necesario utilizar los multiplexores para habilitarlas. Estos se controlan mediante los puertos GPIO.
En la tabla siguiente (Tabla 1), se muestra el valor que debe tomar cada puerto para configurar los
multiplexores.

Intel Galileo GEN1
61
Tabla 1. Configuración de multiplexores para señales analógicas
AD7298 SYSFS SEÑAL
ANALÓGICA
CONFIGURACIÓN
VIN0 in_voltage0_raw A0 Seleccionado por A0_MUX
(gpio37=0)
(gpio36=0)
(gpio23=0)
(gpio22=0)
(gpio21=0) y I2C_MUX
(gpio29=1)
(gpio20=0) y I2C_MUX
(gpio29=1)
VIN6 in_voltage6_raw No conectado
VIN7 in_voltage7_raw No conectado
Lectura de muestras analógicas
Lo primero a realizar será elegir uno de los cinco puertos analógicos disponibles. En este caso, se
utilizará el puerto A0.
Tal como se mencionó en el apartado anterior, debemos configurar el multiplexor correspondiente.
Como se utilizará el puerto A0, será necesario, según la Tabla 1., establecer el valor del puerto
GPIO37 a cero. Para realizar esto, debemos hacer lo siguiente:
 Exportar el puerto GPIO37
 Establecer la “dirección” del puerto como “salida”
 Escribir un “0”

Intel Galileo GEN1
62
Una vez que el puerto analógico está configurado, su valor se puede leer desde “sysfs” a través del
comando:
Un punto a considerar del comando anterior, es el nombre del archivo del cual se lee la muestra,
“in_voltage0_raw”. Este archivo, es el correspondiente al puerto A0 en “sysfs”, tal como lo indica
la (Tabla 1).
Tomando muestras analógicas en Bash
Para realizar este ejemplo, se conectó a la entrada A0 un potenciómetro. El script realizará la
configuración del puerto, tal como se mencionó anteriormente, y además, ejecutara un loop que
mostrará el valor que aporta el potenciómetro en la terminal con una frecuencia de un segundo.
En la siguiente figura se muestra el código creado:
Figura 70. Script “potenciometro.sh”
El resultado muestra los valores leídos a medida que fue variando el potenciómetro:

Intel Galileo GEN1
63
PWM
Es posible chequear, primeramente, cuantos canales PWM posee Galileo. Esto se realiza mediante:
En Galileo todas las salidas PWM se implementan utilizando Cypress CY8C9540A. Éste da
soporte a 8 canales PWM, pero sólo 6 se utilizan en Galileo. La Tabla 2, indica cómo se mapean
los canales PWM.
Tabla 2. Mapeo de canales PWM
NUMERO DE PIN -
GALILEO
N° DE CANAL
PWM
3 3
5 5
6 6
9 1
10 7
11 4
Los datos indicados en la Tabla 2 es posible identificarlos en la Figura 67, ya que los pines de las
señales PWM están indicados con la etiqueta “(pwmX)”.
Configuración de PWM
Para configurar un canal PWM, primeramente, debemos seleccionar cual se pretende utilizar. Para
este caso, se utilizara el canal 3. Tal como se muestra en la Tabla 2, el canal 3 está relacionado
como el pin 3 de la placa. Los pasos para realizar la configuración son los siguientes:
 Exportar el canal PWM 3
De la misma manera que en los puertos GPIO, el canal PWM, después de ser utilizado debe ser
“des-exportado”. Esto puede realizarse escribiendo el número del canal en el archivo
“/sys/class/pwmchip0/unexport”

Intel Galileo GEN1
64
 Habilitar el canal: la habilitación se realiza escribiendo un “1” en el archivo de habilitación
correspondiente. Tener en cuenta que en el siguiente comando, se seleccionó el canal
“pwm3”.
 Establecer el periodo: el periodo se escribe en “nanosegundos”.
 Establecer el ciclo de trabajo: se establece en “nanosegundos”.
Ej: si el periodo establecido es de 1000000 nanosegundos (1 milisegundo) y se quiere un
ciclo de trabajo del 50%, se debe realizar:
(50 * 1000000 / 100) = 500000; ciclo de trabajo (nanosegundos)
Una vez realizado los pasos anteriores, se tendrá configurado el canal PWM.
PWM en Bash
Se realizó la configuración antes mencionada, y además, se generó un loop que aumenta el ciclo
de trabajo en un 10% cada un segundo, hasta llegar al valor máximo, reiniciándolo nuevamente.
A continuación, se detalla el código en cuestión:
Figura 72. Script “pwm.sh”

Intel Galileo GEN1
65
Conclusiones
En el presente informe, se ha desarrollado un amplio contenido sobre la placa Intel Galileo GEN1
con el propósito de realizar un aporte a la comunidad que la utiliza. Se abordaron las características
de entrada/salida de la placa, con la finalidad de desarrollar las distintas posibilidades que existen
para programar los puertos de la misma utilizando el framework Node.JS.
La librería “mraa”, es importante ya que es la base de programación de los puertos. Es el “lenguaje
de bajo nivel” de la placa con Node.JS. Las librerías “upm”, “Johnny-Five” y “galileo-io” utilizan
“mraa” para poder realizar las operaciones. Estas solo nos dan la posibilidad de programar en “alto
nivel”.
En cuanto a la programación de los puertos a través de comandos LINUX mediante la utilización
de archivos, es un tema muy interesante y rico, ya que es posible programar los puertos no solo en
Bash, sino a través de cualquier lenguaje que admita la lectura/escritura de archivos. Esto amplía
la cantidad de lenguajes con los que podemos programar la placa. Sin embargo, este tipo de
programación puede resultar engorrosa.

Intel galileo gen1

Recomendados

Recomendados

Más contenido relacionado

Similar a Intel galileo gen1

Similar a Intel galileo gen1 (20)

Último

Último (8)

Intel galileo gen1