Principios 

de Internet de las cosas  2015  Principios de Internet de las cosas  2015 

   
 

PRINCIPIOS DE INTERNET DE LAS COSAS (IoT)  INSTALAR DRIVERS 
INTRODUCCIÓN A LA PLATAFORMA INTEL GALILEO   Debido  a  que  Windows  no  detecta  la  tarjeta  cuando  se  conecta,  se  debe  a  proceder  a  la 
PONTIFICIA  UNIVERSIDAD  JAVERIANA  instalación  de  los  drivers  manualmente.  Para  esto  se  debe  ingresar  a  Panel  de  control­
>Administrador de dispositivos.  
OCTUBRE DE  2015, B OGOTÁ  COLOMBIA  

I NGENIERÍA  E LECTRÓNICA   En esta ventana aparecerá lo siguiente: 

 
 
ACTUALIZACIÓN DEL FIRMWARE 
Figura 2. Windows no reconoce el driver de la tarjeta 
Antes de empezar a programar se debe actualizar la versión del firmware de la tarjeta. Para esto 
se  debe  ingresar  a  la  siguiente  página  WEB:  http://www.intel.com/support/galileo/sb/CS­ Luego en Gadget Serial v2.4 se  entra a la pestaña Controlador­> Actualizar controlador­> Buscar 
035101.htm.  Se  debe  descargar  el  programa  en  el  vínculo  Intel Galileo  Firmware  Updater  Tool  software  de  controlado  en  el  equipo.  Con  el  botón  Examinar  se  debe  buscar  la  ruta  donde  se 
1.0.4  ­>  IntelGalileoFirmwareUpdater­1.0.4­Windows.zip  ­>  I  accept  the  terms  in  the  license  encuentra  la  carpeta  que  se  descomprimió  llamada “IntelGalileoFirmwareUpdater­1.0.4­
agreemen.  Windows” y seleccionar Galileo Driver. Luego dar clic  en  siguiente  y  se  espera  unos  minutos 
mientras se instala el driver correspondiente. 
Una vez descargado el programa se descomprime y se procede a realizar la conexión de la Galileo: 
Ahora  se  procede  a  la  actualización  del  firmware  mediante  el  programa llamado “firmware­
NOTA:  Antes  de  iniciar,  es  importante  conectar  la  fuente  de  alimentación  antes  de  conectar  el  updater­1.0.4”, el cual se encuentra en la carpeta “IntelGalileoFirmwareUpdater­1.0.4­Windows”. 
cable  micro  USB  entre  la  tarjeta  y  la  PC.  Conectar  el  cable  micro  USB  sin  alimentación  puede 
resultar en un daño a tu tarjeta Galileo. Una vez que la fuente de alimentación ha sido conectada, 
un LED verde marcado con la etiqueta "ON" (localizado en la parte izquierda inferior de la tarjeta) 
se encenderá. Después de uno segundos, un segundo LED marcado como "USB Client" (encima del 
conector USB) se encenderá, indicando que la placa de desarrollo está lista para utilizarse. 

 
Figura 3. Programa para actualizar el Firmware de la tarjeta 

Ya en el programa se escoge el puerto donde se encuentra la tarjeta conectada y se verifica que la 
tarjeta tenga la versión 1.0.4, de no ser así se procede a la instalación de dicha versión mediante el 
botón Update Firmware. 

 
 
 
Figura 1. Manera correcta de conectar la tarjeta 
 
1  Octubre de 2015  2  Octubre de 2015 
   
 Principios de Internet de las cosas  2015  Principios de Internet de las cosas  2015 
   
PROGRAMACIÓN EN ARDUINO IDE  La estructura básica del lenguaje de programación de Arduino es bastante simple y se compone de 
al menos dos partes: 
Ya  con  la  versión  del  firmware  actualizada,  se  procede  a  descargar  la  versión  de  Arduino  IDE  e 
Intel. Para esto se debe ingresar a la siguiente página WEB:  void setup() { // rutina de inicialización
estamentos;
}
http://www.intel.com/support/galileo/sb/CS­035101.htm 

En  la  sección  Arduino  Software  1.6.0  ­  Intel  1.0.4  escoger  el  sistema  operativo  el  cual  posea  e 
instantáneamente  se  empezará  la  descarga.  Al  terminar  la  descarga  se  descomprime  y  se  void loop() { // loop infinito de procesamiento
estamentos;
ejecutará el archivo llamado arduino.exe.  }

En el programa de Arduino se asigna la tarjeta y el puerto que se utilizarán. Para ello se remite a la   
pestaña  Herramientas­>Placa­>Intel  Galileo  y  Herramientas­>Puerto­>  (Seleccionar  el  puerto  En  donde  setup()  es  la  parte  encargada  de  inicializar  todos  los  periféricos  y  módulos  de  la 
asignado para la tarjeta).   plataforma  y  loop()  es  la  que  contienen el  programa  que  se  ejecutará  cíclicamente  (de  ahí  el 
termino loop –bucle­). Ambas funciones son necesarias para que el programa trabaje. 

La función de inicialización debe contener la declaración de las variables. Es la primera función a 
ejecutar en el programa, se ejecuta sólo una vez, y se utiliza para configurar o inicializar entradas y 
salidas (modo de trabajo de las E/S), configuración de la UART, entre otras. 

La función bucle (loop) contiene el código que se ejecutará continuamente (lectura de entradas, 
procesamiento y toma de decisiones, y control de salidas). Esta función es el núcleo de todos los 
programas de Arduino y la que realiza la mayor parte del trabajo. 

   

 
Figura 4. Selección de la tarjeta en el IDE de arduino 

ESTRUCTURA DE UN PROGRAMA 

3  Octubre de 2015  4  Octubre de 2015 
   
 Principios de Internet de las cosas  2015  Principios de Internet de las cosas  2015 
   
 
ENTRADAS ANÁLOGAS 
ENTRADAS Y SALIDAS DIGITALES 
Las entradas análogas leen el valor de pin análogo con una resolución de 10 bits. Por lo tanto los 
En  la  función  void  setup()  se  configuran  los  pines  específicos  para  que  se  comporten  como  una  valores  devueltos  por la respectiva función  están dentro del  rango 0 a 1023.  Los pines  análogos 
entrada  (INPUT)  o  como  una  salida  (OUTPUT).  La  tarjeta  tiene  12  pines  digitales  (E/S)  y  que  se  están referenciados en el rango de 0 a 5. 
indexan de 2 a 13. 
value = analogRead (pin); //Se asigna a values lo que se lee en el “pin”
pinMode(pin,OUTPUT); //se ajusta “pin” como salida
NOTA:  Los  pines  análogos  al  contrario  de  los  digitales,  no  necesitan  ser  declarados  al  principio 
Si el pin se configura como salida, la forma en que se asigna un 1 lógico es mediante el comando  como OUTPUT o INPUT.  
HIGH,  mientras  que  para  asignar  un  0  lógico  es  con  LOW.  El  siguiente  ejemplo  representa  la 
asignación de la salida lógica: 
digitalWrite(pin,HIGH);

Ahora, cuando el pin se asigna como entrada, la forma de leer el puerto es la siguiente: 
digitalRead(pin);

Así como en muchas plataformas Arduino, los pines digitales 3, 5, 6, 9, 10 y 11 tienen salidas PWM 
(valor DC análogo @490Hz), con una resolución de 8bits para el ciclo útil.  
analogWrite(pin,value)

 
Figura 6. Conexión ejemplo 2 

EJEMPLO 2: [1 POTENCIÓMETRO, BUS LEDS (8)] 
int leds[]={2,3,4,5,6,7,8,9}; // Arreglo con los pines que se utilizarán.
  int pot; // Sensor (potenciómetro)
int n=0; // Variable auxiliar.
Figura 5. Conexión ejemplo 1 
void setup(){
EJEMPLO 1: [1 LED, 1, PULSADOR]  for(n=0;n<8;n++)
{
int led = 9; // conecta “led” al pin 9 pinMode(leds[n],OUTPUT);//Se asignan los pines como salidas
int pin = 2; // conecta “pushbutton” al pin 2 }
int value = 0; // variable para almacenar el valor leído }

void loop(){
void setup () {
pot = analogRead(0);// Se define pot (potenciómetro)como el valor leído del
pinMode(led, OUTPUT); // Se ajusta el pin 9 como salida // puerto Análogo 0
pinMode(pin, INPUT); // Se ajusta el pin 2 como entrada
} if(pot >= 0 && pot <= 128){ //Definimos el rango para el cual se
//encenderá un LED
void loop () { for(n=0;n<1;n++){ //solo se enciende un LED, de ahí el número 1
value = digitalRead(pin); // Se ajusta value al valor leído del pin 7 DigitalWrite(leds[n],HIGH); // Se encienden n LEDs, aquí n = 1
digitalWrite(led, value); // Se ajusta el valor del led dependiendo del pin }
for(n=1;n<7;n++){ //Los demás LEDs están apagados
// leido
digitalWrite(leds[n],LOW);
} }
}

5  Octubre de 2015  6  Octubre de 2015 
   
 Principios de Internet de las cosas  2015  Principios de Internet de las cosas  2015 
   
if(pot >= 128 && pot <= 256){ //Definimos el rango para el cual se
//encenderá dos LED
for(n=0;n<2;n++){ //solo se enciende dos LEDs
digitalWrite(leds[n],HIGH); // Se encienden n LEDs, aquí n = 2
}
for(n=2;n<8;n++){ //Los demás LEDs están apagados
digitalWrite(leds[n],LOW);
}
}

//Este proceso se repite para cada intervalo

if(pot >= 256 && pot <= 348){
for(n=0;n<3;n++) {  
digitalWrite(leds[n],HIGH);
} Figura 7. Montaje del ejemplo 3 
for(n=3;n<8;n++){
digitalWrite(leds[n],LOW); EJEMPLO 3: [1 POTENCIÓMETRO, 1 LED (PWM)] 
}
} const int pinSensor = 0; // pin del potenciometro
if(pot >= 348 && pot <= 512){ const int pinLed = 9; // pin con el led, tiene pwm
for(n=0;n<4;n++) {
digitalWrite(leds[n],HIGH); // Declaramos las variables que vamos a usar
}
int brilloLed = 0; // variable para guardar el valor con el que se iluminara el
for(n=4;n<8;n++){
digitalWrite(leds[n],LOW); //led
} int valorPotenciometro = 0; // variable para guardar el valor leído del
} // potenciómetro
if(pot >= 512 && pot <= 640){
for(n=0;n<5;n++) { void setup() {
digitalWrite(leds[n],HIGH); pinMode(pinSensor, INPUT); // Inicializa el pin como entrada
} pinMode(pinLed, OUTPUT); // Inicializa el pin del led como salida
for(n=5;n<8;n++){
}
digitalWrite(leds[n],LOW);
}
} void loop(){
if(pot >= 640 && pot <= 768){ valorPotenciometro = analogRead(pinSensor); // Lee el valor del
for(n=0;n<6;n++) { // Potenciómetro
digitalWrite(leds[n],HIGH); brilloLed = 0.25 * valorPotenciometro; //Transformamos el valor del
} //potenciómetro el cual está en una
for(n=6;n<8;n++){ //resolución de 10 bits a una
digitalWrite(leds[n],LOW);
//resolución de 8 bits para el PWM
}
} //(0.25 = 255/1023)
if(pot >= 768 && pot <= 896){
for(n=0;n<7;n++) { analogWrite(pinLed, brilloLed); //Escribimos la intensidad del led (valor
digitalWrite(leds[n],HIGH); //entre 0-255)
} }  
for(n=7;n<8;n++){
digitalWrite(leds[n],LOW);
   
}
}
if(pot >= 896){
for(n=0;n<8;n++){
digitalWrite(leds[n],HIGH);
}

}
}
 

7  Octubre de 2015  8  Octubre de 2015 
   
 Principios de Internet de las cosas  2015  Principios de Internet de las cosas  2015 
   
  void loop() {

COMUNICACIÓN SERIAL  valor=Serial.read(); //Se almacena el valor leído mediante el puerto Serial

Entre la tarjeta y el computador se puede establecer una comunicación de transmisión de datos en  switch (valor) {

serie. El valor típico de velocidad para comunicarse con el ordenador es de 9600. Para enviar y ver  case 67: //Código ASCII de la letra C
lo que se recibe se debe entrar a la pestaña Herramientas­>monitor serie  for (int i =0;i<8;i++){
digitalWrite(ledPin[i],LOW); //Se apagan los 8 LEDs
void setup(){ }
Serial.begin(9600); //Abre el puerto y configura la velocidad de Serial.print("Código ASCCI del carácter 'C' es: ");
//transmisión Serial.println(valor);
} conteo=0; //Conteo=0 debido a que ningún LED se encuentra
//encendido
break;
Los siguientes comandos son los utilizados para la comunicación serial: 
case 83: //Código ASCII de la letra S
 Serial.printIn(value);   // Envia “value” al puerto  for (int i =0;i<8;i++){
 Serial.read();     // Lee lo que se recibe mediante el puerto de comunicación.  digitalWrite(ledPin[i],HIGH); //Se encienden los 8 LEDs
 Serial.available();   // Devuelve un numero entero con el número de bytes disponibles   }
Serial.print("Código ASCCI del carácter 'S' es: ");
// Para leer desde el buffer serie, o 0 si no hay ninguno.   Serial.println(valor);
conteo=7; //Conteo=0 debido a que todos los LEDs se encuentra
//encendidos
break;

case 85: //Código ASCII de la letra U

if(conteo <= 7){//Condición límite para que conteo no se salga del
//rango
digitalWrite(ledPin[conteo],HIGH); //Se enciende el LED
//dependiendo el valor de conteo
conteo=conteo+1; //Se incrementa conteo
Serial.print("Código ASCCI del carácter 'U' es: ");
Serial.println(valor);
}
break;

  case 68: //Código ASCII de la letra D

if(conteo >= 0){ //Condición límite para que conteo no se salga del
  //rango
digitalWrite(ledPin[conteo],LOW); //Se apaga el LED
Figura 8. Montaje del ejemplo 4  //dependiendo el valor de conteo
conteo=conteo-1; //Se decrementa conteo
  Serial.print("Código ASCCI del carácter 'D' es: ");
Serial.println(valor);
EJEMPLO 4: [UART, BUS DE LEDS(8)]  }
break;
int ledPin[] = {2,3,4,5,6,7,8,9}; //Puertos a utilizar para el BUS de LEDs }
int valor=0, conteo=0; //Inicialización de las variables a utilizar }   
void setup() {
Serial.begin(9600); //Inicialización del puerto serial
for (int i =0;i<8;i++){
pinMode(ledPin[i], OUTPUT); //Asignación de los puertos como
//salidas
}
}

9  Octubre de 2015  10  Octubre de 2015 

   
 Principios de Internet de las cosas  2015  Principios de Internet de las cosas  2015 
   
 
Serial.print("Humidity: ");
SENSOR DE TEMPERATURA DIGITAL Y DISPLAY LCD   Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperature: ");
 
Serial.print(t);
Serial.print(" *C ");

lcd.clear(); //Se limpia la pantalla

lcd.print("Hum: "); //Se imprime en la pantalla
lcd.print(h);
lcd.print(" %");
lcd.setCursor(0, 1); //Se cambia el cursor la segunda fila
lcd.print("Tem: ");
lcd.print(t);
lcd.print(" *C ");

if(t > 30.0){ //Condición de sobre paso de la //temperatura

tone(speakerPin, 261, 2000); //Se enciende el buzzer
}else{
   digitalWrite(speakerPin, LOW); //Se apaga el buzzer
delay(2000);
Figura 9. Montaje del ejemplo 5 
}
}
EJEMPLO 5: [SENSOR DE TEMPERATURA CON ALARMA Y PANTALLA LCD] 
#include "DHT.h" //Se agrega la librería del sensor
#define DHTIN 2 //Pin DATA
#define DHTOUT 3 //Pin DATA2
#include <Wire.h> //Librería de I2C
#include "rgb_lcd.h" //Librería de la pantalla
rgb_lcd lcd;

#define DHTTYPE DHT11 //Se escoge el Sensor

DHT dht(DHTIN,DHTOUT, DHTTYPE);

int speakerPin = 4; //Se asigna el Pin para el buzzer

void setup() {
lcd.begin(16, 2); //Se inicializa la comunicación
//con la pantalla
lcd.print("hello, world!");
Serial.begin(9600); //Se inicia el puerto serial
pinMode(speakerPin, OUTPUT); //Define el buzzer como salida
dht.begin(); //Se inicia el sensor
}

void loop() {
//delay(2000); //Espera dos segundos para la
//siguiente medición

float h = dht.readHumidity(); //Lee humedad relativa

float t = dht.readTemperature(); //Lee temperatura en °C

if (isnan(h) || isnan(t)){ //Se chequea de algún ERROR

Serial.println("Failed to read from DHT sensor!");
return;
}

11  Octubre de 2015  12  Octubre de 2015