1. Perspectivas IoT con ARDUINO
M.Sc. Aldo Ramiro Valdez Alvarado
Marzo de 2017

2. Introducción al IoT
Capas del IoT
IoT con ARDUINO
Un ejemplo sencillo
Conclusiones
Índice
1
2
3
4
5

3. Introducción al IoT1

4. Ley de Moore. El número de transistores
de un chip se duplica cada 2 años
Ley de Metcalfe. El valor de una red de
comunicaciones aumenta
proporcionalmente al cuadrado del
número de usuarios del sistema
Las etiquetas RFID (Radio Frequency
IDentification)
El modelo de Computación Ubicua
IoT implica que todo objeto puede
constituir una fuente de datos.
Antes del…

5. En 1999 Kevin Ashton cofundador y director del
Auto-ID Center del MIT inventa “Internet of Things”
El IoT es el mundo en el que cada objeto tiene una
identidad virtual propia y capacidad potencial para
integrarse e interactuar de manera independiente en
la Red con cualquier otro individuo, ya sea una
máquina (M2M) o un humano.
Qué significa?

6. Nuestro mundo esta cambiando

8. Popularización de Placas de Hardware
Libre.
Abaratamiento de Sensores.
Mejora en las Comunicaciones.
Varias Plataformas IoT
Por qué ahora

9. Algunos ejemplos

10. Baby check
Recordatorio de Pastillas
Domótica
Smart Buildings
Smart City
Smart Banking

11. Capas del IoT2

12. Las tres capas que se consideran son: la
miniaturización del hardware, las necesidades de
infraestructura y el desarrollo de software innovador,
estas son fundamentales para entender la expansión
del Internet de las Cosas en el terreno de la
tecnologías de la información y la comunicación.

13. Capas del IoT

14. IoT con ARDUINO3

15. De los creadores de…

16. Manifiesto IoT
We believe that the best way to grow this environment is to develop
open source platforms and protocols to propose as an alternative to
the myriad of proprietary hardware and software platforms each one
of the big players are developing.
We believe in creating tools that make these technologies
understandable to the most diverse set of people as possible, this is
the only way to make sure innovation benefits most of humanity.
We propose that connected devices should be: Open, Sustainable
and Fair.
https://create.arduino.cc/iot/manifesto/

17. Creemos que la mejor manera de hacer crecer este entorno es desarrollar
plataformas y protocolos de código abierto, para proponerlos como una
alternativa a la miríada de plataformas propietarias de hardware y software
que cada uno de los grandes jugadores en la industria están
desarrollando.
Creemos en la creación de herramientas que hagan estas tecnologías
comprensibles para el más diverso grupo de personas como sea posible,
esta es la única manera de asegurar que la innovación beneficie a la
mayoría de la humanidad.
Proponemos que los dispositivos conectados sean: Abierto, Sostenible y
Justo.

18. Abierto, lo Open Source es mejor para la Innovación.
Sostenible, contra el diseño desechable de los bienes
electrónicos del consumidor de movimiento rápido.
Justo contra el espionaje.

19. Elementos…

20. Dispositivos Hardware
Conectividad
Protocolos de Comunicación
Plataformas Software
Servicios

21. Hardware
El MCU como ARDUINO.
Los sensores toman información en bruto
que lee el dispositivo. Pueden medir
temperatura, presencia, viento, campos
magnéticos, flujos de líquidos, calidad del
aire, propiedades de los líquidos, vibraciones,
posiciones geográficas, altitud, presión y un
largo entre otros.
Los actuadores permiten la interacción con el
mundo físico. Pueden abrir puertas, mostrar
mensajes, encender luces, enviar señales,
controlar un flujo de líquidos, controlar el aire
acondicionado, encender y apagar motores,
entre otros.
ESLOV IoT Invention Kit

22. Conectividad
En los proyectos de IoT los dispositivos
se conectan a Internet para interactuar.
• Conectividad autónoma
(Standalone). Modems 3G / GPRS
embebidos en el dispositivo
• Dispositivo + Pasarela.
Comunicación dispositivo-pasarela
serie (ej. RS232 or RS485) o radio (ej.
868MHz)
• Red de sensores + Pasarela.
Comunicación local por WiFi o
Ethernet entre dispositivos y pasarela.

23. Protocolos de Comunicación
Los dispositivos
interactúan con la
Plataforma a través de
un protocolo estándar
HTTP / HTTPS en la
capa de Internet y JSON
o XML en la capa de
aplicación (REST API)

24. Plataformas de Software
Las Plataformas de Software sirven para tratar los datos
recogidos por nuestros sensores y almacenarlos. Pueden ser
plataformas de terceros o plataformas propias desarrolladas
por nosotros o simplemente guardar en BD propias. Además
todas estas Plataformas de Software que están en la nube,
deben estar soportadas por un hardware de servidores, unas
BD de gran capacidad y una infraestructura segura que los
hospede.

25. https://create.arduino.cc/iot/products/cloud/

26. Plataformas con Versiones Gratuitas
https://artik.cloud/

27. Plataformas con Versiones Gratuitas
https://arest.io/

28. Plataformas con Versiones Gratuitas
https://thinger.io/

29. Plataformas de Integración (IoT)
https://thethings.io/

30. Plataformas de Integración (IoT)
https://ifttt.com/maker_webhooks

31. Plataformas de Integración (IoT)
https://firebase.google.com/

32. Otras Plataformas
https://www.carriots.com/
https://www.aylanetworks.com/
http://autodeskfusionconnect.com/
https://aws.amazon.com/es/iot/
https://cloud.google.com/solutions/iot/
https://www.ibm.com/internet-of-things/
https://www.microsoft.com/en-us/internet-of-things/azure-iot-suite
https://www.thingworx.com/
https://www.xively.com/
http://www.zatar.com/

33. Servicios
Son los servicios que
ofrecen las
plataformas como
mostrar los datos
recogidos, mandar
avisos cuando se
detecte un evento o la
interconexión con
otras plataformas o
simplemente.

34. Un ejemplo sencillo4

35. Sistema de Alarma
(https://www.carriots.com/tutorials/arduino_carriots/alert_system)
Utilizamos un Arduino capaz de detectar la luz y Carriots Engine para
enviar alertas por correo electrónico. Vamos a ver como:
• Conectar un Arduino a Carriots para enviar flujos de datos utilizando
Carriots HTTP REST API
• Construir una aplicación de alerta en Carriots mediante la
programación de un Listener para enviar un correo electrónico con el
SDK
Materiales
• Arduino UNO
• Una Placa Ethernet, o WiFi, o GPRS
• Protoboard
• Resistencia entre 200KΩ y 10KΩ
• Sensor Óptico o Sensor de Movimiento

36. Esquema

37. Conexión ARDUINO

38. Proyecto Carriots
Dispositivo
defaultDevice@myusername
Apikey
98346673a6377ef1fde2357ebdcb0da582b150b00cabcd5a0d83045425
407ab4

39. Datos desde ARDUINO a
CarriotsHTTP request
POST /streams HTTP/1.1
Host: api.carriots.com
Accept: application/json
User-Agent: Arduino-Carriots
Content-Type: application/json
carriots.apikey: YOUR APIKEY HERE
Content-Length: YOUR CONTENT LENGTH HERE
Connection: close
Data
{
"protocol":"v2",
"device":"YOUR DEVICEs ID_DEVELOPER HERE",
"at":1356390000,
"data":{"light":"YOUR DATA HERE"}
}

40. Código en ARDUINO
#include <SPI.h>
#include <Ethernet.h>
const int ON = 1; // Constant to indicate that lights are on
const int OFF = 2; // Constant to indicate that lights are off
const String APIKEY = "YOUR APIKEY HERE"; // Replace with your Carriots apikey
const String DEVICE = "YOUR DEVICEs ID_DEVELOPER HERE"; // Replace with the id_developer of your device
// Enter a MAC address for your controller below.
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1,27); // Your IP Address
IPAddress server(82,223,244,60); // api.carriots.com IP Address
EthernetClient client; // Initialize the library instance
int ledPin = 7; // Led pin number
int LDRPin = 3; // LDR sensor pin number
int lights = OFF; // Current status
int newLights = OFF; // New status

41. Código en ARDUINO
// The setup routine runs once when you press reset
void setup() {
pinMode(ledPin, OUTPUT); // Initialize the digital pin as an output
Serial.begin(9600); // Start serial port
Serial.println(F("Starting"));
Ethernet.begin(mac,ip); // Start the Ethernet connection
delay(1000); // Give the Ethernet shield a second to initialize
}
// The loop routine runs over and over again forever
void loop() {
int val = analogRead(LDRPin); // Read the value from the sensor
Serial.println(val);
if (val > 990) { // This is the value limit between day or night with our LDR sensor. Maybe you need adjust this value.
newLights = OFF; // Now its night. We have to turn on the LED
digitalWrite(ledPin, HIGH); // Turn the LED on (HIGH is the voltage level)
}
else {
newLights = ON; // Now its day. We have to turn off the LED
digitalWrite(ledPin, LOW); // Turn the LED off by making the voltage LOW
}

42. Código en ARDUINO
if (lights != newLights) { // Check if we have a change in status
Serial.println(F("Send Stream"));
lights = newLights; // Status update and send stream
sendStream();
}
delay(500);
// If theres incoming data from the net connection, send it out the serial port
// This is for debugging purposes only
while (client.available()) {
char c = client.read();
Serial.print(c);
}
if (!client.connected()) {
client.stop();
}
}

43. Código en ARDUINO
// Send stream to Carriots
void sendStream()
{
String txt = ""; // Text to send
if ( lights == OFF ) { // Alarm OFF
txt = "OFF";
} else { // Alarm ON
txt = "ON";
}
Serial.println(txt); // For debugging purpose only
if (client.connect(server, 80)) { // If theres a successful connection
Serial.println(F("connected"));
// Build the data field
String json = "{"protocol":"v2","device":""+DEVICE+"","at":1356390000,"data":{"light":""+txt+""}}";
// Make a HTTP request
client.println("POST /streams HTTP/1.1");
client.println("Host: api.carriots.com");
client.println("Accept: application/json");
client.println("User-Agent: Arduino-Carriots");

44. Código en ARDUINO
client.println("Content-Type: application/json");
client.print("carriots.apikey: ");
client.println(APIKEY);
client.print("Content-Length: ");
int thisLength = json.length();
client.println(thisLength);
client.println("Connection: close");
client.println();
client.println(json);
}
else {
// If you didnt get a connection to the server:
Serial.println(F("connection failed"));
}
}

45. Datos en Carriots

46. Crear la Alerta en Carriots
Name: The name that you prefer
Description: The description that you prefer
Entity type: Device
Entity id: Your id device
Event to listen: data_persisted
If expression:
context.data.light=="ON"
Then expression:
import com.carriots.sdk.utils.Email;
def email = new Email ();
email.to="YOUR EMAIL HERE";
email.message="Alarm ON";
email.send();

47. Crear la Alerta en Carriots
Then rule: leave empty
Else expression:
import com.carriots.sdk.utils.Email;
def email = new Email ();
email.to="YOUR EMAIL HERE";
email.message="Alarm OFF";
email.send();
Else rule: leave empty
Be sure to have your listener enabled if you want it to be executed

48. Conclusiones5

49. Hoy en día, se tienen diferentes
plataformas de IoT, multitud de
proyectos de IoT, todos enfocados
en el petróleo del siglo XX, los
Datos, y hacia la gestión de estos
con el el Big Data.
En la presentación de hoy solo se
mostro un poco de lo que se
puede hacer con un ARDUINO una
plataforma de IoT y un poco de
IMAGINACIÓN.
EL FUTURO ES DE USTEDES!!!

50. Aldo Ramiro Valdez Alvarado
Licenciado en Informática
Master en Dirección Estrategica en Tecnologías de la Información
Docente Titular de Pregrado en la UMSA
Docente de Postgrado en la UMSA y otras Universidades
Coordinador del Postgrado en Informática UMSA
Conferencista Nacional e Internacional
http://aldovaldezalvarado.blogspot.com/
https://www.linkedin.com/in/msc-aldo-valdez-alvarado-17464820
aldo_valdez@hotmail.com