curso de iot de labotec

1. CAPÍTULO
1
Introducción
1.1. Internet
Se podría definir como una red global de redes de ordenadores cuya finalidad es permitir el intercambio de información
entre todos sus usuarios.
1.2. HTTP
Es el protocolo de comunicación que permite las transferencias de información en la World Wide Web.
1.3. WebSocket
Es una tecnología que proporciona un canal de comunicación bidireccional y full-duplex sobre un único socket TCP.
1

2. 1. INTRODUCCIÓN
1.4. Modelo MVC
Es un patrón de arquitectura de software por un lado define componentes para la representación de la información, y
por otro lado para la interacción del usuario.
1.5. Base de datos
Almacenamiento de información. Tenemos las bases de datos relacionales y las no relacionales
1.6. Internet de las cosas
Es un concepto que se refiere a la interconexión digital de objetos cotidianos con internet.
2

3. 1.7. HTTP: API-REST
1.6.1. Protocolos de internet de las cosas
Generales
HTTP
Dedicados
MQTT
WebSocket CoAP
1.7. HTTP: API-REST
REST, REpresentational State Transfer, es un tipo de arquitectura de desarrollo web que se apoya totalmente en
el estándar HTTP.
Las APIs son como bibliotecas para poder ordenarnos.
Para manipular los recursos, HTTP nos dota de los siguientes métodos con los cuales debemos operar:
GET : Para consultar y leer recursos
POST : Para crear recursos
PUT : Para editar recursos
DELETE : Para eliminar recursos
PATCH : Para editar partes concretas de un recurso.
1.8. CURL
Es un proyecto de software consistente en una biblioteca (libcurl) y un intérprete de comandos (curl) orientado a la
transferencia de archivos. Soporta los protocolos FTP, FTPS, HTTP, HTTPS, TFTP, SCP, SFTP, Telnet, DICT, FILE y
LDAP, entre otros.
1.9. MQTT
MQTT es un protocolo abierto, sencillo, ligero y fácil de implantar. Es ideal para responder a las siguientes necesida-
des:
Esta orientado exclusivamente a hardware de recursos limitados como microcontroladores.
3

4. 1. INTRODUCCIÓN
Está especialmente adaptado para utilizar un ancho de banda mínimo.
Es ideal para utilizar redes inalámbricas.
Consume muy poca energía.
Es muy rápido y posibilita un tiempo de respuesta superior al resto de protocolos web.
Permite una gran fiabilidad si es necesario.
Requiere pocos recursos procesadores y memorias.
El MQTT no es el único protocolo que intenta imponerse: otros como XMPP, REST API y CoAp también tienen
ciertas ventajas.
1.10. Mosquitto
Mosquitto es un broker OpenSource ampliamente utilizado debido a su ligereza lo que nos permite, fácilmente, em-
plearlo en gran número de ambientes, incluso si éstos son de pocos recursos.
1.11. Hardware
4

5. 1.12. Nodemcu
1.12. Nodemcu
√
Procesador interno de 32 bits a 80
MHz y se le puede subir hasta
160Mhz.
√
802.11 protocol y Wifi Direct
(P2P) Soft-AP.
√
80K de DRAM.
√
Regulador y unidad de
alimentación incluidos.
√
35K de IRAM , memoria rápida para
el procesador.
√
Consumo en reposo <10 mW.
√
1 Mb de memoria Flash para nuestros
programas.
√
Soporta antena externa para
mayor alcance.
√
Stack TCPIP WIFI a 2.4 Ghz.
√
Soporta el bus SPI.
√
30 Metros de alcance teórico.
√
Soporta I2C.
√
16 pines GPIO programables
disponibles.
√
1 entrada analógica (Muy mal
documentada).
√
Full TCPIP stack incluido.
√
Gestión completa del WIFI con
amplificador incluido.
Versiones DEL NODEMCU
Nodemcu 1.0
5

6. 1. INTRODUCCIÓN
Programación de NODEMCU
Example
6

7. CAPÍTULO
2
Conexión al Internet
2.1. Introducción
En esta clase aprenderemos a usar el NODEMCU con el sensor de temperatura y humedad DHT11 y permitir visualizar
la información en una pantalla LCD por i2c. Una vez conociendo como poder interactuar con el sensor y la pantalla,
pasaremos a usar los ticker como temporizadores del microcontrolador.
Esta será la base para poder usar algún software que permitirá subir la información proporcionado de la NODEMCU
al internet. En este caso usaremos FLASK para cumplir con el trabajo de realizar las web’s, luego para poder subir al
internet usaremos HEROKU, también veremos como subir bajo plataformas ya establecidas como THINGSPEAK.
2.2. Hardware
2.2.1. DTH11
Es un sensor de temperatura y humedad digital de bajo costo. Utiliza un sensor capacitivo de humedad y un termistor
para medir el aire circundante, y muestra los datos mediante una señal digital en el pin de datos. Es bastante simple
de usar, pero requiere sincronización cuidadosa para tomar datos. El único inconveniente de este sensor es que sólo se
puede obtener nuevos datos una vez cada 2 segundos, así que las lecturas que se pueden realizar serán mínimo cada 2
segundos.
Características
Alimentación: 3Vdc ≤ Vcc ≤ 5Vdc
Rango de medición de temperatura: 0 a 50 °C
Precisión de medición de temperatura: ±2.0 °C .
Resolución Temperatura: 0.1°C
Rango de medición de humedad: 20% a 90% RH.
Precisión de medición de humedad: 4% RH.
Resolución Humedad: 1% RH
Tiempo de sensado: 1 seg.
Presentaciones
Integración al NODEMCU
7

8. 2. CONEXIÓN AL INTERNET
Codificación del NODEMCU
Usaremos las librerías de Adafruit, podremos descargar de este link:
https://github.com/adafruit/DHT-sensor-library
https://github.com/adafruit/Adafruit_Sensor
Luego incluimos las librerías al IDE de Arduino. Ejemplo del test de DHT11:
#include"DHT.h"
#define DHTPIN 2
#define DHTTYPE DHT11
DHT dht(DHTPIN,DHTTYPE);
void setup(){
Serial.begin(9600);
Serial.println("DHTxx test!");
dht.begin();
}
void loop(){
delay(2000);
float h=dht.readHumidity();
float t=dht.readTemperature();
if(isnan(h) || isnan(t)){
Serial.println("error");
return;
}
Serial.print("Humidity: ");
Serial.print(h);
Serial.print("Temperature: ");
Serial.print(t);
Serial.print(" *C ");
}
8

9. 2.2. Hardware
OLED Pantalla mini que se controla por medio del protocolo I2C con tecnología OLED. La pantalla mide solo 0.96
pulgadas de tamaño. Ideal para sistemas donde el peso o tamaño son críticos. Características :
√
No necesita backlight.
√
Interfaz: I2C IIC TWI
√
Resolución: 128x64.
√
Driver: SSD1306
√
Voltaje: 3 a 5V.
√
Consumo: 0.08W
√
Temperatura de trabajo: -30ºC a 70ºC.
√
letras color blancas
√
Tamaño: 27 x 27 x 4.1 mm
Presentación
Integración al NODEMCU
Codificación del NODEMCU Podremos descargar la librería de Adafruit del siguiente link: https://github.com/klarsys/esp8266-
OLED
#include<Wire.h>
include"OLED.h"
OLED display(2,14);
void setup(){
Serial.begin(9600);
Serial.println("OLED test!");
display.print("Hello worl");
delay(3*1000);
9

10. 2. CONEXIÓN AL INTERNET
display.print("Lorem ipsum dolor sit amet");
delay(3*1000);
display.clear();
delay(3*1000);
display.print("TOP-LEFT");
display.print("4th row",4);
display.print("RIGHT-BOTTOM",7,4);
delay(3*1000);
display.off();
display.print("3rd row",3,8);
delay(3*1000);
display.on();
delay(3*1000);
}
2.3. Software
Thingspeak Ingresamos a la siguiente URL y creamos una cuenta: https://thingspeak.com/
Vamos a la parte de CANALES y agregamos otro, si recién creas uno por primera vez solo aprece un fondo blanco:
Completamos los campos como se indicarán en clase:
10

11. 2.3. Software
por la parte de thingspeak esta todo listo y presto a escuchar la data que sera enviada desde el NODEMCU:
Deberemos cargar el siguiente código en el NODEMCU:
#include<DHT.h>
#include<ESP8266WiFi.h>
#include<WiFiClient.h>
#include<ThingSpeak.h>
#define DHTPIN D5
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
const char* ssid="jicamarca";
const char* password="radioobservatory";
WiFiClient client;
11

12. 2. CONEXIÓN AL INTERNET
unsigned long myChannelNumber = 232438;
const char * myWriteAPIKey = "VC12X8U2379LQH1S";
uint8_t temperature, humidity;
void setup() {
Serial.begin(115200);
dht.begin();
delay(10);
// Connect to WiFi network
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status()!=WL_CONNECTED){
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
// Print the IP address
Serial.println(WiFi.localIP());
ThingSpeak.begin(client);
}
void loop() {
static boolean data_state = false;
temperature = dht.readTemperature();
humidity = dht.readHumidity();
Serial.print("Temperature Value is :");
Serial.print(temperature);
Serial.println("C");
Serial.print("Humidity Value is :");
Serial.print(humidity);
Serial.println("%");
// Write to ThingSpeak. There are up to 8 fields in a channel,
// allowing you to store up to 8 different
// pieces of information in a channel. Here, we write to field 1.
if(data_state){
ThingSpeak.writeField(myChannelNumber,1,temperature,myWriteAPIKey);
data_state = false;
}else{
ThingSpeak.writeField(myChannelNumber,2,humidity,myWriteAPIKey);
data_state = true;
}
delay(30000); // ThingSpeak will only accept updates every 15 seconds.
}
Esto nos permitirá subir datos al thingspeak.
12

13. CAPÍTULO
3
Nodemcu con Tuniot
3.1. Introducción
Esta web nos permite trabajar el código de arduino mediante bloques de una manera ordenada y rápida para la elabo-
ración de código de nuestro NODEMCU. Como sabemos la NODEMCU tiene un montón de aplicaciones de comu-
nicación con servidores remotos, conexión con REST externas, conexión con MQTT, etc. Pero al mismo ritmo que
el código de la aplicación crece, también se vuelve mayor la complejidad, incluso para elaborar códigos sencillos se
requiere muchas líneas de código, es por esto que TUNIOT nos permite generar una plantillas con la cual empezar y a
partir de esta poder elaborar nuestros propios código partiendo de un código base.
Figura 3.1: Área de trabajo de TUNIOT (área de programación)
Se puede acceder con la siguiente URL: http://easycoding.tn/tuniot/demos/code/
Una vez conociendo que es el TUNIOT veremos las partes que lo conforman:
13

14. 3. NODEMCU CON TUNIOT
Figura 3.2: Área de Bloques, donde podremos sacar todo tipo de bloques para realizar nuestra programación.
En TUNIOT tenemos varias pestañas de representar el código, una es mediante bloques cuyo objetivo es ir sacando
dichos bloques, arrastrarlo al área de programación e ir conectando hasta realizar el algoritmo deseado, mientras ocurre
esto a la par se está creando un respectivo código en la sintaxis de arduino y en la sintaxis de XML.
En el área de bloques tenemos bloques que se encargan de controlar el hardware como son INPUT, OUTPUT, PWM,
SERVO, SERIAL, PANTALLAS OLED, etc, asimismo gestiona la parte wifi como CLIENTE WEB, ACCESO DE
WEBSERVICE, ACCESO A THINGSPEAK, ACCESO A IFTTT, etc.
Es un IDE muy bueno para empezar y tener soltura programando ente microcontrolador, de esta manera poder realizar
aplicaciones rápidamente.
Figura 3.3: Mientras empezamos a conectar bloques automáticamente aparece el codigo equivalente en arduino, lo
podemos ver como va cambiando en la pestaña CODE.
3.2. Blink led con TUNIOT
El nodemcu cuenta con un led integrado en la misma placa que sirve de indicador de carga de código, el orden de este
led varía según las tarjetas, pero preferentemente en las tarjetas originales el led se encuentra en el pin D0 (GPIO16),
en las versiones clones algunos vienen en el pin D2.
Para controlar este led mediante TUNIOT hay que saber que este ya cuenta con un bloque que controla este led llamado
“integrated LED ”, mediante este bloque podremos ponerlo en su estado HIGH o LOW .
14

15. 3.2. Blink led con TUNIOT
Estos lo podemos sacar de la parte de IN/OUT - DIGITAL de la sección de bloques, para la parte del tiempo lo sacamos
de VARIOUS.
Figura 3.4: Acceso a los bloques correspondientes para el código del blink led
Figura 3.5: Código de BLink led, tener en cuenta que no se inicializa el modo del pin (IN, OUT)
Una vez tengamos la lógica establecida , vamos a ver su código en sintaxis de arduino y revisamos (accedemos a la
pestaña CODE ). Si todo está conforme entonces procedemos a copiar este código al ide de arduino, también podemos
descargar el código y simplemente subirlo.
Figura 3.6: Código en arduino, podemos copiarlo o descargarlo
15

16. 3. NODEMCU CON TUNIOT
Figura 3.7: El símbolo del triángulo con fondo rojo indica la descarga de nuestro codigo, así mismo podemos guardar
nuestro XML en la opción indicada (SAVE XML), como también podemos cargar uno ya guardado anteriormente
(LOAD XML).
Una vez tengamos el código de arduino subiremos a nuestra placa:
Figura 3.8: Procedemos a subirlo a la placa NODEMCU
3.3. Pantallas OLED I2C
Para trabajar con las pantallas OLEd i2c debemos de tener una librerias que nos da easycoding.tn . La ruta es:
https://easycoding.tn/index.php/resources/
Descargamos las librerías correspondientes a i2c, que son:
I2C scanner sketch.
esp8266-oled-ssd1306 library
Figura 3.9: Código base para la programación de la pantalla OLED.
16

17. 3.4. Conexión al internet
Verifiquemos el código en sintaxis arduino, tengamos en cuenta que si tenemos problemas con la dirección del i2c ,
entonces debemos usar el código base (I2C scanner sketch) que descargamos junto a la librería de la pantalla OLEd,
este código I2C scanner sketch nos permitirá saber la dirección i2c de nuestra pantalla OLED.
#include<Wire.h>
#include"SSD1306.h"
SSD1306 display(0x3C,4,5);
void setup(){
Serial.begin(9600);
display.init();
display.drawString(0,0,"Hola LaboTEC");
display.display();
}
void loop(){
}
Figura 3.10: Código generado en la sintaxis de arduino.
3.4. Conexión al internet
Para esto TUNIOT tiene una plantilla base donde poder empezar a trabajar, para esto nos dirigimos a la parte de
TEMPLATEs y elegir Client in an encrypted network.
Figura 3.11: Vamos a la opción de templates para elegir el código base de la conexión a internet.
Figura 3.12: Elegimos la opción MODEL 4 que es la cliente con una encriptación a al red.
17

18. 3. NODEMCU CON TUNIOT
Figura 3.13: Código generado del template, con esto podemos modificar la red y contraseña, así mismo podemos
colocarle una ip estática.
3.5. Modo Access Point
En este modo nuestro NODEMCU puede generar su propia red y de esta manera algún otro NODEMCU se puede
conectar a nuestra red y comunicarse, cabe resaltar que muchos NODEMCU se pueden conectar, recordar que por
DHCP es de 8 bits , en pocas palabras la IP máxima es el (192.168.1.1 - 192.168.1.255).
Figura 3.14: código base para generar una red, se muestra en pantalla si hay conexión.
18

19. 3.6. Modo WebServer
Figura 3.15: Cuando nos conectamos a la red creada nos aparece el número de la estación como 1.
3.6. Modo WebServer
En el modo WEBSERVER el nodemcu modo server dará el servicio de una página web, donde desde una web browser
podremos acceder y realizar peticiones GET desde su opción de ingreso de URL.
También desde una nodemcu cliente podemos acceder al contenido del web server de la nodemcu modo server.
Figura 3.16: Código para generar una web server desde una NODEMCU.
Código generado del TUNIOT para web server.
19

20. 3. NODEMCU CON TUNIOT
#include<ESP8266WiFi.h>
String ClientRequest;
WiFiServer server(80);
void setup(){
ClientRequest = "";
Serial.begin(9600);
WiFi.disconnect();
delay(3000);
Serial.println("START");
WiFi.begin("jicamarca", "radioobservatory");
while ((!(WiFi.status() == WL_CONNECTED))) {
delay(300);
Serial.print("..");
}
Serial.println("Connected");
Serial.println("Your IP is");
Serial.println((WiFi.localIP()));
server.begin();
}
void loop(){
WiFiClient client = server.available();
if (!client) {
return;
}
while (!client.available()) {
delay(1);
}
ClientRequest = (client.readStringUntil('r'));
Serial.println(ClientRequest);
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("");
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("Bienvenido");
client.println("</html>");
client.stop();
delay(1);
}
20

21. 3.6. Modo WebServer
Figura 3.17: Mediante un web browser podemos acceder al contenido de la web server del nodemcu.
Figura 3.18: Podemos realizar peticiones desde otra NODEMCU cliente.
Servir información de sensores Una vez visto cómo servir información por medio de una web, lo ideal seria servir
información de los sensores conectados.
Figura 3.19: Un cliente puede obtener la data mediante una consulta y luego la respuesta convertir a entero (debemos
quitar el formato de HTML).
21

22. 3. NODEMCU CON TUNIOT
Figura 3.20: Ejemplo de servir información del ADC.
Figura 3.21: Obtenemos solamente el valor que nos brindó el web server.
22

23. CAPÍTULO
4
Python en microcontroladores
4.1. Nodemcu
NodeMCU es una plataforma IoT de código abierto. Incluye firmware que se ejecuta en el ESP8266 Wi-Fi SoC de
Espressif Systems , y el hardware que se basa en el módulo ESP- 12. El término "NodeMCU" por defecto se refiere al
firmware en lugar de los kits de desarrollo. El firmware utiliza el lenguaje de secuencias de comandos Lua . Se basa
en el proyecto eLua , y se basa en el SDK Espressif OS para ESP8266 . Utiliza muchos proyectos de código abierto,
como lua-cjson, y spiffs.
Pasos
Borrar el firmware del NODEMCU:
$ sudo pip install esptool
$ esptool.py --port /dev/ttyUSB0 erase_flash
23

24. 4. PYTHON EN MICROCONTROLADORES
También se puede descargar aquí:
$ git clone https://github.com/themadinventor/esptool.git
$ cd esptool
$ python esptool.py -h
Instalar el firmware del micro-python: El firmware se encuentra en la siguiente dirección de internet: http://micropython.org
$ esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=detect 0
esp8266-2016-05-03-v1.8.bin
Instalar algún software de monitoreo de protocolo serial, como el cutecom:
$ sudo apt-get install cutecom
Abrir cutecom a la velocidad de 115200 y en el puerto correcto
Probar la sintaxis de python
>>> print('hello esp8266!')
>>> 1 + 2
3
>>> 1 / 2
0.5
>>> 12**34
4922235242952026704037113243122008064
Podemos usar sus pines como salida o entrada digital:
>>> import machine
>>> pin = machine.Pin(2, machine.Pin.OUT)
>>> pin.high()
>>> pin.low()
Más información de la sintaxis: http://docs.micropython.org/en/latest/esp8266/esp8266/quickref.html
Librerías de MicroPython: https://github.com/micropython/micropython-lib
Cargar script en la NODEMCU: Instalar ampy de adafruit:
$ git clone https://github.com/adafruit/ampy.git
$ sudo python setup.py install
$ ampy --help
Probar algún script: Se resalta que el script puede estar en cualquier parte de nuestra PC
$ ampy --port /serial/port run test.py
24

25. 4.1. Nodemcu
Probar script sin mensaje en terminal:
$ ampy --port /serial/port run --no-output test.py
Copiar, borrar y crear archivos a la tarjeta: Con “put” podemos copiar archivos a la nodemcu.
$ ampy --port /serial/port put test.py
También podemos copiar carpetas:
$ ampy --port /serial/port put miCarpetaEnNodeMcu
Podemos leer, borrar y crear archivos:
$ ampy --port /serial/port get boot.py #lee archivo boot.py
$ ampy --port /serial/port mkdir foo #crea una carpeta
$ ampy --port /serial/port mkdir /foo/bar #crea carpeta recursiva
$ ampy --port /serial/port ls #lista los archivos y directorios del micro
$ ampy --port /serial/port rm test.py #borrar un archivo
$ ampy --port /serial/port rmdir /foo/bar #borra un directorio
Grabar un archivo en la NODEMCU como archivo principal:
Secuencias de inicio
Hay dos archivos importantes que MicroPython busca en la raíz de su sistema de archivos. Estos archivos contienen
el código de MicroPython que se ejecutará cada vez que la placa se enciende o restablece (es decir, se inicia). Estos
archivos son:
/boot.py - Este archivo se ejecuta primero al encender / restablecer y debe contener código de bajo nivel que configura
la placa para finalizar el arranque. Por lo general, no necesita modificar boot.py a menos que esté personalizando o
modificando MicroPython. Sin embargo, es interesante ver el contenido del archivo para ver qué sucede cuando la
placa se inicia. Recuerde que puede usar el comando ampy get para leer esto y cualquier otro archivo!
/main.py - Si este archivo existe, se ejecuta después de boot.py y debe contener cualquier script principal que desee
ejecutar cuando la placa se encienda o restablezca.
$ ampy --port /serial/port put test.py /main.py
25