Archivo de la etiqueta: Arduino

Arduino en IoT

Arduino se ha convertido una figura destacada e incluso uno de los impulsores del IoT y no por casualidad, sino que  por sus características es un HW con gran capacidad para usar en proyectos de IoT.

Características de Arduino para IoT

  • Barato y rápido prototipado.
  • HW libre y por lo tanto es modificable para que consuma menos y para hacer un HW final de características industriales.
  • Disponibilidad de HW de comunicaciones de todo tipo para conectar con Arduino. Nuevas tecnologías de comunicación llegan antes que para elementos comerciales
  • Librerías y SW público para su reutilización o adaptación.
  • Flexibilidad en la programación.
  • Apoyo de la comunidad.

No en vano cuando se busca IoT (Internet de las cosas) enseguida aparece Arduino. Arduino sirve para recoger datos no solo del entorno sino de máquinas o elementos externos y comunicarnos con Internet, mediante su consumo eléctrico, contactos de alertas externas, su temperatura, su posición, etc…

Arduino nos permite de una forma sencilla y barata poder conectar entre sí elementos cotidianos para manejarlos y añadir sensores a cualquier elemento y en cualquier ubicación.

Qué es Arduino: https://aprendiendoarduino.wordpress.com/2018/04/02/que-es-arduino-7/ 

Hardware Arduino:

Hardware Arduino IoT

La familia de Arduino MKR son una serie de placas con un factor de forma diferente al de Arduino mucho más pequeño y basados todos en el microcontrolador de 32 bits de Atmel SAMD21. Estas placas están pensadas principalmente para IoT.

MKR Family: https://store.arduino.cc/arduino-genuino/arduino-genuino-mkr-family 

Arduino MKRZero

Producto: https://store.arduino.cc/arduino-mkrzero

Primero modelo de la familia MKR y heredero del Arduino Zero.

Arduino MKR1000 WIFI

Producto: https://store.arduino.cc/arduino-mkr1000 

Versión para IoT con procesador Atmel ARM Cortex M0+ de 32bits ATSAMW25 que es el mismo procesador que Genuino Zero pero con wifi integrado, chip de cifrado y antena integrada.

El ATSAMW25 está compuesto por tres principales bloques:

  • SAMD21 Cortex-M0+ 32bit low power ARM MCU
  • WINC1500 low power 2.4GHz IEEE® 802.11 b/g/n Wi-Fi (mismo que el wifi 101 shield)
  • ECC508 CryptoAuthentication

Arduino MKR WiFi 1010

Producto: https://store.arduino.cc/arduino-mkr-wifi-1010 

El MKR WIFI 1010 es una mejora significativa del MKR 1000 WIFI. Está equipado con un módulo ESP32 fabricado por U-BLOX. Esta placa tiene como objetivo acelerar y simplificar la creación de prototipos de aplicaciones de IO basadas en WiFi gracias a la flexibilidad del módulo ESP32 y su bajo consumo de energía.

La placa tienes estos 3 bloques principales:

  • SAMD21 Cortex-M0+ 32bit Low Power ARM MCU;
  • U-BLOX NINA-W10 Series Low Power 2.4GHz IEEE® 802.11 b/g/n Wi-Fi; and Bluetooth
  • ECC508 Crypto Authentication

Actualización firmware bluetooth para Arduino MKR WiFi 1010: http://forum.arduino.cc/index.php?topic=579306.0 

La librería para controlar el bluetooth es:

Arduino MKR FOX 1200

Producto: https://store.arduino.cc/arduino-mkrfox1200 

Arduino anunciado en abril de 2017. En una placa de desarrollo pensada para el IoT con conectividad Sigfox. Comparte muchas características con otras placas de la familia MKR como em microcontrolador SAM D21 32-bit Cortex-M0+.

Incluye un módulo ATA8520 con conectividad sigfox de amplia cobertura y bajo consumo capaz de funcionar durante 6 meses con dos pilas AA. También incluye una suscripción por dos años a la red Sigfox: http://www.sigfox.com/en 

Web: https://blog.arduino.cc/2017/04/18/introducing-the-arduino-mkrfox1200/ 

Más información sobre el Arduino MKRFOX1200 en el artículo: https://www.aprendiendoarduino.com/2018/03/05/arduino-mkrfox1200/ 

Arduino MKR WAN 1300

Producto: https://store.arduino.cc/mkr-wan-1300 

Presentado el 25 de septiembre de 2017 en la maker faire de NY: https://blog.arduino.cc/2017/09/25/introducing-the-arduino-mkr-wan-1300-and-mkr-gsm-1400/ 

Arduino + LoRa: 

Arduino MKR WAN1310

Nueva placa evolución de la MKRWAN 1300: https://store.arduino.cc/mkr-wan-1310

Esta placa mejora el consumo de la anterior y dispone de mayor memoria flash para poder hacer data logging y OTA

Esta tarjeta de código abierto se puede conectar a:

  • Arduino Create
  • Tu propia red LoRa usando el Arduino Pro Gateway para LoRa 
  • Infraestructura LoRaWAN existente como The Things Network 
  • O incluso otras tarjetas que utilizan el modo de conectividad directa

Presentación de la placa: https://blog.arduino.cc/2019/10/10/new-mkr-wan-1310-for-lora-connectivity-comes-with-2mbyte-flash-and-extended-battery-life/

Proyectos: https://create.arduino.cc/projecthub/products/arduino-mkr-wan-1310

Arduino MKR GSM 1400

Producto: https://store.arduino.cc/mkr-gsm-1400 

Presentado el 25 de septiembre de 2017 en la maker faire de NY: https://blog.arduino.cc/2017/09/25/introducing-the-arduino-mkr-wan-1300-and-mkr-gsm-1400/ 

Arduino + GSM:

Arduino MKR NB 1500

Producto: https://store.arduino.cc/arduino-mkr-nb-1500

El nuevo estándar Narrow Band IoT, con el ecosistema Arduino fácil de usar. Totalmente compatible con las clases Narrow Band IoT NB y las redes LTE CAT M1.

Arduino MKR Vidor 4000

Producto: https://store.arduino.cc/arduino-vidor-4000

El MKR VIDOR 4000 es altamente configurable y potente, y puede realizar procesamiento digital de audio y video de alta velocidad.

El MKR VIDOR 4000 puede configurarlo de la manera que desee; esencialmente puede crear su propia tarjeta controladora.

Viene cargado de hardware y potencial:

  • un SRAM de 8 MB
  • un chip Flash QSPI de 2 MB – 1 MB asignado para aplicaciones de usuario
  • un conector Micro HDMI
  • un conector para cámara MIPI
  • Wifi & BLE alimentado por U-BLOX NINA Serie W10.

También incluye la clásica interfaz MKR en la que todos los pines son accionados tanto por SAMD21 como por FPGA.

Además, tiene un conector Mini PCI Express con hasta 25 pines programables por el usuario. 

La FPGA contiene 16K Logic Elements, 504 KB de RAM embebida y 56 multiplicadores de 18×18 bit HW para DSP de alta velocidad. Cada pin puede conmutar a más de 150 MHz y puede ser configurado para funciones tales como UARTs, (Q)SPI, PWM de alta resolución/alta frecuencia, codificador de cuadratura, I2C, I2S, Sigma Delta DAC, etc.

La FPGA integrada también se puede utilizar para operaciones DSP de alta velocidad para el procesamiento de audio y vídeo. Esta tarjeta también incluye un Microchip SAMD21. La comunicación entre la FPGA y el SAMD21 es directa.

Accesorios para Arduinos MKR

Y los IoT Bundles:

Nuevos Arduino Nano

En la Maker Faire Bay Area del año 2019, supone un nuevo concepto de placas de pequeño tamaño, económicas y de bajo consumo.

Presentación de las placas: https://blog.arduino.cc/2019/05/17/whats-new-at-maker-faire-bay-area-2019/

Se trata de 4 modelos:

El nuevo microcontrolador ATmega4809 soliciona las limitaciones de las tarjetas antiguas basadas en ATmega328P, puede añadir un segundo puerto serie de hardware, más periféricos y memoria significa que puede abordar proyectos más ambiciosos. Utiliza un chip USB de calidad para que la gente no tenga problemas de conexión o de drivers. El procesador separado que maneja la interfaz USB también permite implementar diferentes clases de USB, como el Dispositivo de Interfaz Humana (HID), en lugar del clásico CDC/UART. 

La nueva arquitectura de fuente de alimentación basada en un convertidor DC-DC de alta eficiencia permite alimentar la tarjeta hasta 21V y accionar periféricos de salida hasta 950mA sin sobrecalentamiento.

Arduino Cloud

Arduino no solo se queda con el HW sino esta preparando un cloud para IoT que pueda usar cualquiera.

Web: https://www.arduino.cc/en/IoT/HomePage 

Arduino IoT Cloud permite conectar dispositivos a Internet y a otros dispositivos. Esta herramienta hace que la creación de objetos conectados sea rápida, sencilla y segura.

Aun es una versión beta y solo se puede usar con unos pocos modelos de Arduino, pero puede ser interesante en el futuro.

Actualmente, las tarjetas MKR1000, MKR WiFi 1010 y MKR GSM 1400 son compatibles. En el futuro, el MKR Vidor 4000 y Arduino Uno WiFi Rev2 también serán soportados.

Arduino IoT Cloud es una plataforma de aplicación de Internet of Things fácil de usar. Hace que sea muy sencillo para cualquiera desarrollar y gestionar aplicaciones de IoT, lo que les permite centrarse en la resolución de problemas reales en su negocio o en la vida cotidiana.

Web: https://create.arduino.cc/iot/things

Más información sobre Arduino IoT Cloud: https://www.arduino.cc/en/IoT/HomePage

Presentación del Arduino IoT Cloud:

Getting started con Arduino Cloud:

Proyectos con IoT cloud: https://create.arduino.cc/projecthub/products/arduino-cloud

Mejoras en Arduino IoT Cloud:

Librería Arduino IoT Cloud: https://github.com/arduino-libraries/ArduinoIoTCloud

FAQ: https://www.arduino.cc/en/Create/FAQ

Configuración Arduino

Puesta en marcha y comprobación del entorno de programación de Arduino para utilizar en el curso.

Instalación del IDE y blink para comprobar que funciona:

Programación Arduino

Librerías

Mandar Datos a un Servidor con Arduino

Vamos a conectar Arduino a un servidor para que mande datos y los muestre en una gráfica.

En este caso vamos a mandar cada 5000 ms el valor del potenciómetro, probar a mover el potenciómetro y ver cómo cambian los datos. 

También puede sustituirse el potenciómetro por un LDR que nos muestre los datos de luminosidad:

Los datos de mostrarán en esta web: https://www.aprendiendoarduino.com/servicios/datos/index.html

Las gráficas se pueden ver en esta dirección: https://www.aprendiendoarduino.com/servicios/datos/graficas.html

El código en el servidor para recoger datos y mostrar está en: https://github.com/jecrespo/aprendiendoarduino-servicios/tree/master/datos

Cargar este firmware en Arduino: https://github.com/jecrespo/Curso-IoT-Open-Source/blob/master/data_logger_temperatura_DHCP/data_logger_temperatura_DHCP.ino

En el código sustituir “X” por el número de Arduino usado y “YY” por el número de Arduino en formato con dos dígitos, es decir, 01, 03, 11, 16, etc…

Ver los datos en:

Anuncios

Dispositivos Hardware IoT

En este curso vamos a usar Arduino y otras placas compatibles como HW de sensorización y actuación en IoT y módulos de comunicación, pero existen otros microcontroladores, PLCs y otro hardware en general que haría la misma funcionalidad.

Podemos dividir el HW IoT en tres grandes conjuntos:

  • Placas controladoras con CPU/microcontrolador con cierta capacidad de cómputo.
  • Sensores y actuadores, conectados a los controladores para leer o actuar sobre el mundo físico
  • Módulos de comunicación, que permiten conectarse a distintos tipos de redes el HW IoT

Dispositivos Hardware para IoT, son los dispositivos que van a medir y los que van a interactuar con el exterior. El elemento HW programable capaz de interactuar con estos dispositivos es el microcontrolador o el microprocesador.

Hay tres clases de dispositivos controlades IoT: 

  • Los dispositivos más pequeños son los controladores embedded de 8/16/32 bits System-On-Chip (SOC). Un buen ejemplo de este Open Source hardware es Arduino. Por ejemplo: Arduino Uno platform, este tipo de HW no suelen llevar sistema operativo (SO). 
  • El siguiente nivel son los dispositivos con una arquitectura de 32/64 bits como los chips de Atheros y ARM. Normalmente estos dispositivos se basan en plataformas de Linux embedded, cómo OpenWRT u otros sistemas operativos embedded (Muchas veces incluyen pequeños routers domésticos y derivados de estos). En algunos casos, no corren ningún SO. Por ejemplo: Arduino Zero o Arduino Yun. 
  • Las plataformas IoT con más capacidad son los sistemas completos de 32 y 64 bits, también se les denomina Single-Board-Computer (SBC). Estos sistemas, como Raspberry Pi o BeagleBone, pueden correr varios SO como Linux o Android. En muchos casos, estos son Smartphone o algún tipo de dispositivo basado en tecnologías móviles. Estos dispositivos pueden comportarse como Gateways o puentes para dispositivos más pequeños. Por ejemplo: un wearable que se conecta vía Bluetooth a un Smartphone o a una Raspberry Pi, es típicamente un puente para conectarse a Internet.

Además a esta lista de dispositivos podemos añadir los Microcontroladores Industriales o PLCs, softPLCs o cualquier dispositivo que pueda conectar a internet y del que pueda obtener datos como un power meter como este http://circutor.com/en/products/metering o también una gran máquina enfriadora con interfaz de red como https://www.vertiv.com/en-asia/products-catalog/thermal-management/free-cooling-chillers/liebert-hpc-l-and-hpc-m-freecooling-chillers/.

Otro tipo de HW IoT son los Gateway. Un Gateway IoT es un dispositivo físico o un programa de software que sirve como punto de conexión entre la nube y los controladores, sensores y dispositivos inteligentes. Todos los datos que se mueven a la nube, o viceversa, pasan por el gateway, que puede ser un dispositivo de hardware dedicado o un programa de software. Un gateway IoT también puede denominarse pasarela inteligente o nivel de control.

A estos dispositivos o nos nodos sensores se les lama también motes (short for remote) https://en.wikipedia.org/wiki/Sensor_node 

Los cálculos que hacen estos dispositivos se denomina Edge Computing. Hasta ahora en la mayoría de los casos las grandes plataformas de Cloud Computing se encargaban de hacer ese “trabajo sucio” de analizar los datos recolectados por los sensores y dispositivos IoT.

La Edge Computing se refiere de forma específica a cómo los procesos computacionales se realizan en los “dispositivos edge”, los dispositivos IoT con capacidad de análisis y procesos como routers o gateways de red, por ejemplo.

La eficiencia de este paradigma no es óptima en muchos casos en los que los propios nodos de la red pueden analizar esos datos para evitar ese paso por la nube. Permite que los datos producidos por los dispositivos de la internet de las cosas se procesen más cerca de donde se crearon en lugar de enviarlos a través de largas recorridos para que lleguen a centros de datos y nubes de computación.

Si hay un campo en el que este tipo de filosofía tenga sentido, ese es el del coche autónomo. Estos “centros de datos sobre ruedas” no paran de recolectar información sobre sus sistemas y su entorno, y toda esa información debe ser procesada en tiempo real para que podamos disfrutar de una conducción autónoma óptima y segura. El coche autónomo no puede estar esperando a comunicarse con la nube y a esperar la respuesta: todo ese proceso y análisis de datos hay que hacerlo en tiempo real, y es ahí donde la Edge Computing entra en juego, confirmando el importante papel que el ordenador central del coche tiene para aglutinar, analizar y dar respuesta a las necesidades de la conducción autónoma en cada momento. Intel estima que un coche autónomo podría acabar generando 4 TB de datos al día que incluye: cámaras, lidar, GPS, radar, etc…

Más información:

Programación de los dispositivos IoT

Estadística de los lenguajes de programación usados en los dispositivos HW IoT:

Firmware es un programa informático que establece la lógica de más bajo nivel que controla los circuitos electrónicos de un dispositivo de cualquier tipo. Está fuertemente integrado con la electrónica del dispositivo, es el software que tiene directa interacción con el hardware, siendo así el encargado de controlarlo para ejecutar correctamente las instrucciones externas. Ver https://es.wikipedia.org/wiki/Firmware

Un sistema operativo IoT es un sistema operativo diseñado para funcionar dentro de las restricciones propias de los dispositivos de Internet of Things, incluidas las restricciones de memoria, tamaño, potencia y capacidad de procesamiento. Los sistemas operativos de IoT son un tipo de sistema operativo integrado, pero por definición están diseñados para permitir la transferencia de datos a través de Internet.

ARM Mbed es una plataforma y un sistema operativo para dispositivos conectados a Internet basado en microcontroladores ARM Cortex-M de 32 bits. Estos dispositivos también se conocen como dispositivos de Internet of Things. El proyecto es desarrollado en colaboración por Arm y sus socios tecnológicos.

RTOS sistemas operativos en Tiempo real para sistemas embebidos, generalmente basados en linux.

Buen resumen de lo necesario para saber sobre sistemas embebidos para IoT a nivel de HW http://so-unlam.com.ar/wiki/index.php/PUBLICO:Sistemas_embebidos_e_Internet_de_las_Cosas 

Guia para elegir el mejor HW IoT: https://www.ibm.com/developerworks/library/iot-lp101-best-hardware-devices-iot-project/index.html 

Hardware IoT

El HW libre por excelencia es Arduino como microcontrolador y Raspberry Pi como microprocesador, con menor potencia física pero mayor potencia de cálculo.

Dentro del HW libre no solo debemos quedarnos con Arduino, sino que existen otros dispositivos, incluso algunos son compatibles y se programan igual que Arduino:

Más HW IoT:

¿Conoces alguna más?

En el caso de HW libre, el siguiente paso es una personalización del HW mediante el diseño de HW como Eagle o Kicad.

HW IoT Industrial

En el mundo industrial se está incorporando el IoT con la denominación IIoT (Industrial Internet of Things) ya sea con dispositivos basados en HW libre o los fabricantes de Autómatas están incorporando comunicaciones más abiertas a sus dispositivos.

PLC basado en Arduino: https://www.industrialshields.com/

Artículo de Industrial Shields sobre Arduino como aplicación de PLC: http://blog.industrialshields.com/es/iot-in-industry-improves-reliability-equipment/

PLCs basados en Arduino: https://industruino.com/ 

PLC basado en Arduino: http://www.winkhel.com/

Carcasa para Arduino y Raspberry Pi en la industria: Arduibox: http://www.hwhardsoft.de/english/webshop/raspibox/#cc-m-product-10145780397 

SIMATIC IOT2020: gateway de Siemens basado en Arduino para futuras aplicaciones industriales: http://es.rs-online.com/web/p/kit-de-desarrollo-de-iot/1244037/ y aplicaciones https://www.rs-online.com/designspark/simatic-iot2020.

Simatic IoT 2040: https://w3.siemens.com/mcms/pc-based-automation/en/industrial-iot/Documents/simatic-ioc2040-flyer-en.pdf

Los otros PLCs SBC (Single Board Computer): http://www.infoplc.net/blogs-automatizacion/item/102505-plc-single-board-computer 

OpenPLC Project: http://www.openplcproject.com/

Autómatas con MQTT: http://www.unitronics.com/ y modelo nistream https://unitronicsplc.com/unistream-series-unistream5/ 

ABB PM556, automata de ABB abierto: http://new.abb.com/drives/es/noticias-y-casos-de-exito/impulsa-el-internet-de-las-cosas-los-servicios-y-las-personas

PLC basado en Raspberry Pi: https://revolution.kunbus.com/

Otro PLC basado en Raspberry Pi: https://www.unipi.technology/ 

Sensores y Actuadores

Este es el primer elemento, es que está más cerca de las “cosas” es el HW que se encarga de medir e interactuar con las “cosas” y procesar esos datos. Este dispositivo puede tener conectado otros hardware como:

Módulos de Comunicación

Los dispositivos IoT deben tener una comunicación mediante algún tipo de protocolo y este módulo puede estar integrado o ser una expansión.

Algunos de los módulos usados en IoT

  • Ethernet
  • Modbus
  • ZigBee
  • XBee
  • WiFi
  • Bluetooth
  • Thread
  • Red de telefonía móvil (2/3/4/5G)
  • 6LoWPAN
  • LoRaWAN
  • Z-Wave
  • NFC
  • nRF24
  • Wize
  • Sigfox

Otros Módulos

Otros módulos muy importantes que van asociados al HW IoT son:

  • Power management (lowpower)
  • Componentes de identificación y seguridad (ATSHA204A, ATECCX08A, 24AA02E64T,…)

IoT en 90 Minutos

Vamos a crear un sistema IoT sencillo utilizando una placa basada en ESP8266, la plataforma Thingspeak para registrar los datos y la APP Blynk para controlar y monitorizar desde el móvil.

El objetivo es:

  • Monitorizar la temperatura y humedad de una sala remotamente desde el móvil
  • Encender desde el móvil la iluminación de la sala
  • Registrar todos los datos históricos de temperatura y humedad
  • Registrar las veces que se abre una puerta
  • Mandar avisos por alta temperatura. 
  • Mandar avisos cuando el sensor de puerta se abra.

Los avisos o notificaciones pueden ser:

Material Necesario

Hardware:

  • Wemos D1 mini
  • Sensor DHT11
  • Led + resistencia 220 ohms (para simular la iluminación) o Relé para la iluminación
  • Pulsador + Resistencia 10 kohms  (para simular la apertura de la puerta) o sensor magnético/infrarrojos.

Coste aproximado: 5 – 20 € dependiendo del material usado.

Software:

Coste del software y licencias: 0 €

Conexión Hardware

Esquema de conexión:

Pines utilizados:

  • D4: Led y también es el led integrado de la placa
  • D3: pulsador/puerta, tiene una resistencia de pull up integrada: OJO, este pin va al GPIO0 que control el arranque, asegurarse de no estar a masa/pulsado al reiniciar o cargar un nuevo programa
  • D2: sonda DHT11

El pulsador simula la apertura de la puerta y el led simula la iluminación de la sala.

Blynk

Blynk es una plataforma que permite que cualquiera pueda controlar fácilmente su proyecto Arduino con un dispositivo con sistema iOS o Android. Los usuarios tendrán ahora la posibilidad de crear una interfaz gráfica de usuario de “arrastrar y soltar” para su proyecto en cuestión de minutos y sin ningún gasto extra.

Blynk vendría a ser como tener una protoboard en tu dispositivo móvil, tablet o teléfono, que cuenta con todo lo que necesites usar, desde deslizadores y pantallas a gráficos y otros widgets funcionales que se pueden organizar en la pantalla un Arduino. Además te da la opción de poder recopilar datos de los sensores que montes en un proyecto. Funciona nada más sacarlo de la caja y conectarlo a la placa por Internet.

Arquitectura de Blynk:

Thingspeak

ThingSpeak es un plataforma de Internet of Things (IoT) que permite recoger y almacenar datos de sensores en la nube y desarrollar aplicaciones IoT. Thinkspeak también ofrece aplicaciones que permiten analizar y visualizar tus datos en MATLAB y actuar sobre los datos. Los datos de los sensores pueden ser enviados desde Arduino, Raspberry Pi, BeagleBone Black y otro HW.

Web: https://thingspeak.com/

Precios: https://thingspeak.com/prices

Pasos a seguir

Crear una cuenta en Thingspeak y configurar

Web: https://thingspeak.com/users/sign_up

Tutoriales:

Crear cuenta:

Crear un Nuevo Canal llamado: “Curso IoT”

Crear 3 Fields:

  • Temperatura – Guarda los datos de temperatura
  • Humedad – Guarda los datos de humedad
  • Puerta – Guarda las aperturas de puerta

Guarda la API Key y el número de canal

Instalar Blynk 

Getting Started: https://blynk.io/en/getting-started

Docs: https://docs.blynk.cc/

Instalar Blynk en el móvil: https://blynk.io/

Crear una cuenta en Blynk

Crear un nuevo proyecto llamado “IoT en 90 minutos”

Elegir Hardware, en este caso “Wemos D1 Mini”

Guardar el Auth Token. Auth Token es un identificador único que se necesita para conectar su hardware a su smartphone. Cada nuevo proyecto que cree tendrá su propio Auth Token. Obtendrá Auth Token automáticamente en su correo electrónico después de la creación del proyecto. También se puede copiar manualmente.

Añadir 3 widgets:

  • Un botón (Conectado al Pin D4)
  • Dos Gauge en los pines Virtuales V0 y V1 para temperatura y humedad

Virtual Pin: http://help.blynk.cc/en/articles/512061-what-is-virtual-pins

Aspecto final de la APP:

Ejecutar el programa

 

Preparar IDE Arduino

Instalar el IDE de Arduino: https://www.arduino.cc/en/Main/Software

Instalar el soporte para las placas basadas en ESP8266 en el IDE de Arduino

Instalar librerías necesarias en IDE Arduino desde el gestor de librerías:

 Realizar montaje de Wemos D1 mini

Personalizar el Firmware y Ejecutarlo

Configurar la Vista Pública en Thingspeak

Crear una vista pública, para ello en el canal ir a “sharing” y seleccionar “Share channel view with everyone”

Configurar la vista pública de Thingspeak, es una especie de dashboard donde pondremos:

  • Gráfica de Temperatura (Tipo Spline)
  • Display numérico Temperatura
  • Gráfica de Humedad  (Tipo Spline)
  • Display numérico Humedad
  • Gráfica apertura de puerta (Tipo Step)
  • Lamp Indicator, para ver el estado de la puerta abierto/cerrado
  • Un histograma para ver la variación de la temperatura

La vista debe quedar como esta: https://thingspeak.com/channels/635134

Configurar las Notificaciones en Thingspeak

Configurar avisos en Thingspeak cuando la temperatura sea mayor de 24 grados y cuando se abra la puerta. Para ello usaremos estas utilidades de thingspeak.

Notificaciones posibles:

  • Mandar un mensaje al panel: https://www.aprendiendoarduino.com/servicios/mensajes/index.html, servicio de #aprendiendoarduino para hacer una demo.
  • Enviar un mensaje a Telegram mediante un bot al canal https://t.me/aprendiendoarduino. Para ello es necesario crear un bot, añadirlo al canal y usar su API KEY desde thingspeak con ThingHTTP
  • Enviar un mensaje al canal #arduino_iot de https://aprendiendoarduino.slack.com/
  • Mandar un tweet usando ThingTweet, para ello debemos enlazar nuestra cuenta de Twitter.
  • Mandar un email con mailgun https://www.mailgun.com/, para ello debemos darnos de alta en mailgun y usar la API Key para que dispare el webhook configurado en ThingHTTP y mande un email
  • Para cualquier otra interacción se puede usar IFTTT. Se crea un webhook que se usa desde ThingHTTP y desde IFTTT disparamos el servicio que queramos.
  • Y cualquier otra que disponga de un webhook o API

Primero debe configurarse ThingHTTP para que llame a una API o webhook que dispare la notificación que deseamos. Para ello deberemos darnos de alta en el servicio que deseemos.

Para mandar un mensaje al panel: https://www.aprendiendoarduino.com/servicios/mensajes/index.html debo llamar a esta API:

Crear un nuevo ThingHTTP llamado “Manda Mensaje Alta Temperatura” y poner:

Crear un nuevo ThingHTTP llamado “Manda Mensaje Alta Temperatura” y poner:

NOTA: si no funciona la llamada al servicio de mensajes, mandar un correo a aprendiendoarduino@gmail.com

Una vez creados los elementos ThingHTTP que dispara la notificación queda crear los react, que son las condiciones en la que se disparan las notificaciones, donde diremos en qué condiciones se mandan las notificaciones. En nuestro caso:

  • Temperatura > 24 grados solo la primera vez que pase (Run action only the first time the condition is met: Trigger the action if the condition was previously false and is currently true.)
  • El valor del canal es 1 (Puerta abierta) cada vez que pase.

Crear un nuevo react llamado “Alta Temperatura IoT 90 minutos” con los siguientes parámetros:

Crear un nuevo react llamado “Puerta Abierta IoT 90 minutos” con los siguientes parámetros:

Probar que se muestran los mensajes en el panel https://www.aprendiendoarduino.com/servicios/mensajes/index.html

Si quisiéramos mandar un tweet, simplemente seleccionar en Action “ThingTweet” y poner el texto del tweet.

Saber más de IoT 2019…

Slack: https://aprendiendoarduino.slack.com, enlace de invitación: link invitación


Día 1: “Presentación del Curso”

Nuevo Arduino MKR WAN 1300: https://blog.arduino.cc/2019/10/10/new-mkr-wan-1310-for-lora-connectivity-comes-with-2mbyte-flash-and-extended-battery-life/

Monitorizar temperatura de un refrigerador: https://blog.arduino.cc/2019/09/25/logging-refrigerator-temperature-with-arduino/

Sistema de monitorización de temperatura: https://blog.temboo.com/temperature-monitoring-system/

Capítulos vistos día 1:

Día 2: “Raspberry Pi en IoT”

 

Capítulos vistos día 2:

Día 3: ” “

 

Capítulos vistos día 3:

Día 4: ” “

 

Capítulos vistos día 4:

Día 5: ” “

 

Capítulos vistos día 5:

Día 6: ” “

Ejemplo de uso de mailgun conectando una máquina dispensadora de snacks:

Capítulos vistos día 6:

Día 7: ” “

Capítulos vistos día 7:

Día 8: ” “

 

Capítulos vistos día 8:

Prácticas: Clases y Objetos

Montaje Arduino UNO:

Montaje Wemos:

Ejercicio19 – Clase Contador

Hacer un programa que cuente las pulsaciones de los botones A y B usando la clase contador guardada en un fichero “Contador.h”

Solución: https://codeshare.io/5QYNeq

Hacer commit y pull del código en el repositorio “Curso Programacion Arduino 2019” que esté en una carpeta llamada Ejercicio19-Clase_Contador

Si solo usamos funciones como en el ejercicio 17, necesito dos funciones detecta flanco y no puedo usar solo una porque si llamo a una y a otra simultáneamente el valor static se mantiene entre la llamada de una y otra lo que hace que falle. Para resolver este problema, hacer una clase DetectaFlanco y entonces puedo reutilizar el código ya que cada vez que instancio una nueva clase es como una función nueva.

NOTA: la clase se puede definir en un fichero “Contador.h” o dentro del mismo fichero .ino, ver ejemplo en https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino_2019

Ejercicio20 – Clase Detecta Flanco

Hacer el programa anterior pero creando  una clase llamada DetectaFlanco en un fichero “DetectaFlanco.h”

Solución: https://codeshare.io/Gb6K0M

Hacer commit y pull del código en el repositorio “Curso Programacion Arduino 2019” que esté en una carpeta llamada Ejercicio20-Clase_Detecta_Flanco

NOTA: Esta clase se puede definir en un fichero “DetectaFlanco.h” y otro “DetectaFlanco.cpp” ver ejemplo en https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino_2019

Ejercicio21: Sensor DHT

Para entender mejor las clases y objetos y antes de entrar en el apartado de librerías y cómo crearlas, vemos un ejemplo de la librería DHT22 para las sondas de temperatura y humedad, de forma que entendamos que cuando la usamos para una sonda, lo que hacemos es instanciar un objeto de tipo sonda DHT22 y cuando llamamos al método readTemperature() estamos ejecutando la función que consulta la temperatura. También vamos a ver cómo se estructura la clase en el fichero de cabecera y en el de contenido.

El código de la librería lo tenemos en https://github.com/adafruit/DHT-sensor-library y vemos que tenemos dos ficheros:

En el fichero de cabecera tenemos la definición de la clase:

class DHT {
  public:
   DHT(uint8_t pin, uint8_t type, uint8_t count=6);
   void begin(void);
   float readTemperature(bool S=false, bool force=false);
   float convertCtoF(float);
   float convertFtoC(float);
   float computeHeatIndex(float temperature, float percentHumidity, bool isFahrenheit=true);
   float readHumidity(bool force=false);
   boolean read(bool force=false);

 private:
  uint8_t data[5];
  uint8_t _pin, _type;
  #ifdef __AVR
    // Use direct GPIO access on an 8-bit AVR so keep track of the port and bitmask
    // for the digital pin connected to the DHT.  Other platforms will use digitalRead.
    uint8_t _bit, _port;
  #endif
  uint32_t _lastreadtime, _maxcycles;
  bool _lastresult;

  uint32_t expectPulse(bool level);
};

Y en el fichero de definiciones DHT.cpp tenemos el código.

Constructor:

 
DHT::DHT(uint8_t pin, uint8_t type, uint8_t count) {
  _pin = pin;
  _type = type;
  #ifdef __AVR
    _bit = digitalPinToBitMask(pin);
    _port = digitalPinToPort(pin);
  #endif
  _maxcycles = microsecondsToClockCycles(1000);  // 1 millisecond timeout for
                                                 // reading pulses from DHT sensor.
  // Note that count is now ignored as the DHT reading algorithm adjusts itself
  // basd on the speed of the processor.
}

Método begin():

 
void DHT::begin(void) {
  // set up the pins!
  pinMode(_pin, INPUT_PULLUP);
  // Using this value makes sure that millis() - lastreadtime will be
  // >= MIN_INTERVAL right away. Note that this assignment wraps around,
  // but so will the subtraction.
  _lastreadtime = -MIN_INTERVAL;
  DEBUG_PRINT("Max clock cycles: "); DEBUG_PRINTLN(_maxcycles, DEC);
}

Método readTemperature(), que llama a la función read() que es la que hace toda la operación de consultar a la sonda y guarda en la propiedad privada data la información leída y readTemeprature() se encarga de darle formato en función del tipo de sonda y devolver el float con la temperatura:

 
float DHT::readTemperature(bool S, bool force) {
  float f = NAN;

  if (read(force)) {
    switch (_type) {
    case DHT11:
      f = data[2];
      if(S) {
        f = convertCtoF(f);
      }
      break;
    case DHT22:
    case DHT21:
      f = data[2] & 0x7F;
      f *= 256;
      f += data[3];
      f *= 0.1;
      if (data[2] & 0x80) {
        f *= -1;
      }
      if(S) {
        f = convertCtoF(f);
      }
      break;
    }
  }
  return f;
}

Este esquema explica como funciona este sensor y el protocolo de comunicación. La librería implementa el protocolo y facilita el uso de la sonda con Arduino.

En un ejemplo de uso de esta clase, primero hacemos un include del fichero, luego instanciamos un nuevo objeto sonda llamado dht. En el setup hacemos el begin() para iniciarlo y en el loop llamamos a los métodos de leer temperatura y humedad.

#include "DHT.h"
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  dht.begin();
}
void loop() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();
}

Partiendo del ejemplo de la librería llamado DHTtester, adaptarlo para el montaje de Arduino Uno pero usando dos sondas DHT11 en los pines 11 y 12

Solución: https://codeshare.io/arJ0nv

Hacer commit y pull del código en el repositorio “Curso Programacion Arduino 2019” que esté en una carpeta llamada Ejercicio21-DHT