Archivo de la etiqueta: Wemos D1 mini

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

Configuración del Gauge:

  • Temperatura pin virtual V0
  • Humedad pin virtual V1
  • Modo push
  • Label: C para temperatura y % para Humedad

Configuración del Botón. poner en modo switch:

Aspecto final de la APP:

Ejecutar el programa

 

Preparar IDE Arduino

Instalar el IDE de Arduino:

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 Puerta Abierta” 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.

Identificación Horizontales Demo

Las horizontales o Building Blocks usados en IoT:

Para la demo:

  • Devices: Wemos D1 mini + sensor temperatura + pulsador + led + relé
  • Infraestructura de comunicación: Wifi
  • Gateway: Punto de Acceso Wifi
  • Protocolo: API HTTP y MQTT (transparente al usar las librerías de Blynk y Thingspeak)
  • Plataforma: Thingspeak y Blynk
  • Servicios: Almacenamiento de datos, gráficas, disparo de eventos y análisis de datos por Thingspeak, monitorización móvil por Blynk, notificaciones por IFTTT o plataforma propia.

Limitaciones de la solución utilizada:

  • Máximo número de envíos a plataforma: 15 segundos
  • Datos almacenados solo hasta un año o 3 millones de registros
  • Límite en el cálculo de datos
  • Gráficas simples
  • Depender de terceros para las notificaciones

Prácticas: Funciones Definidas por Usuario

Montaje Arduino UNO:

Montaje Wemos:

Ejercicio15 – Funciones

Hacer un menú interactivo con Arduino. Con todo lo visto anteriormente, hacer un ejemplo de un menú interactivo donde se dan 4 opciones y pulsando cada una de ellas se ejecuta una acción concreta. Si el valor pulsado no es ninguna de las opciones avisar y volver a mostrar el menú hasta que se pulse una opción correcta. Usar funciones para cada una de las opciones.

Opciones:

  • 1 – Encender led siguiente (paso por referencia la posición del led)
  • 2 – Sacar por pantalla el LCD que está encendido
  • 3 – Sonar el buzzer 5 segundos
  • 4 – Fin (entra en un bucle infinito y no sale)

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

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

Ejercicio16 – Función Detecta flanco

Señales digitales:

Hacer una función que detecte flancos ascendentes y otras flancos descendentes, para ser reutilizada en otros proyectos.

Unificar estas dos funciones en una única función llamada detectaFlanco() donde le paso el pin y devuelve 1 si es flanco ascendente, -1 si es flanco descendente y 0 si no hay cambio de estado.

Ponerla en un ejemplo con alguno de los botones, usando este loop:

 
void loop() {
  int flanco = detectaFlanco(PIN_BOTON_A);
  if (flanco == 1)
    Serial.println("flanco ascendente");
  if (flanco == -1)
    Serial.println("flanco descendente");
}

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

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

Ejercicio17 – Función Detecta flanco dos pines

Para ejercicio detecta flanco, probar la función con los dos botones en los pines 2 y 3. La función detecta flanco solo funciona con un pulsador, pero cuando se intenta usar con dos pulsadores ya no funciona. Comprobar porqué.

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

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

La función para detectar flanco es la base para luego entender las clases y objetos y luego las librerías.

La solución es crear un objeto detecta flanco, para ello crear una clase y se puede distribuir mediante una librería como https://github.com/jecrespo/Detecta_Flanco_Libreria que se puede descargar desde https://github.com/jecrespo/Detecta_Flanco_Libreria/releases/tag/Version_1.0:

#include <DetectaFlanco.h>
#define PIN_BOTON_A 2
#define PIN_BOTON_B 3

DetectaFlanco df1(PIN_BOTON_A);
DetectaFlanco df2(PIN_BOTON_B);

void setup() {
  Serial.begin(9600);
  df1.inicio(INPUT_PULLUP);
  df2.inicio(INPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
  int flanco1 = df1.comprueba();
  int flanco2 = df2.comprueba();

  if (flanco1 == 1)
    Serial.println("Flanco asc A");

  if (flanco1 == -1)
    Serial.println("Flanco desc A");

  if (flanco2 == 1)
    Serial.println("Flanco asc B");

  if (flanco2 == -1)
    Serial.println("Flanco asc B");

  delay(50); //Evitar rebotes
}

Ejercicio18 – Dado Digital

Usando las funciones de números aleatorios hacer un dado digital que genere un número aleatorio entre 1 y 6 y encienda un led aleatorio cada vez que se pulse el botón A. Usar el montaje del Wemos D1 mini

Usar la función de detección de flanco hecha en el anterior ejercicio.

Random Numbers

  • randomSeed() – Inicializa el generador de número pseudo-aleatorios
  • random() – Genera números pseudo-aleatorios

Paso 1 – Generar un valor aleatorio entre 1 y 6 al pulsar el botón

Paso 2 – Hacer girar el anillo led haciendo el efecto y que baje la velocidad

Paso 2 – Dejar fijo el nuevo número aleatorio

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

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

Prácticas: Variables y Tipos de Datos en Arduino

Montaje Arduino UNO:

Montaje Wemos:

Ejercicio07 – Ámbito Variables

Ámbito de las variables en C++

Ejercicio07: Mover el servo mediante el botón A. Para ello cada vez que se pulse mover 10 grados y cuando llegue a 170 grados volver a la posición inicial de 10 grados.

Usar una una variable llamada “grados” que aumente su valor cada vez que se detecte un flanco ascendente. Hacerlo como variable local y global.

Hacer una función “detectaFlanco” que use una variable local para detectar flanco.

Sacar por el puerto serie el ángulo que está, por la pantalla LCD y por el Serial Plotter

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

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

Ejercicio08 – Puntuaciones

Hacer un programa,de forma que muestre por la pantalla LCD el valor del LDR y un contador de puntos. Al pulsar un botón A, acumule el valor del LDR multiplicado por 10 hasta un máximo de 8 pulsaciones y luego empiece en cero. Ver quién consigue más puntos. ¿Quién llegará a 80000 puntos?

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

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

Ejercicio09 – Puntuaciones Wemos

Adaptar el código del Ejercicio09-Puntuaciones_Wemos para el Wemos D1 Mini con la pantalla oled.

Comprobar cómo adaptar un código de una placa a otra y con componentes diferentes

NOTA: conectar el LDR al pin A0 del Wemos D1 Mini

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

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

Prácticas: Ejemplos Sencillos Programación Arduino

Hacer unos ejemplos sencillos de programación para evaluar el conocimiento de cada alumno con el montaje de prácticas.

Todos los ejercicios se subirán al repositorio llamado “Curso Programacion Arduino 2019” de cada alumno haciendo un commit y un Pull.

Luego todos los alumnos podrán ver las soluciones propuestas por cada uno y comprobaremos que para un mismo problema hay muchas soluciones diferentes. También el profesor pondrá su solución (no tiene porque ser la mejor) y hacer correcciones a los códigos propuestos por los alumnos.

Montaje Arduino UNO:

Montaje Wemos:

Ejercicio03 – Leer LDR y mostrar Gráfica

Ejercicio03. Leer el valor del LDR cada 500ms y mostrarlo por el Serial Monitor y Serial Plotter. Usar delay para grabar cada 500ms.

También calcular el máximo y mínimo, mostrándolo por la pantalla LCD. Usar las funciones:

Esto nos puede servir para calibrar un elemento y conocer su máximo y mínimo para luego en función de esos valores regular otro elemento como la intensidad de un LED.

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

Hacer commit y pull del código en el repositorio de cada alumno “Curso Programacion Arduino 2019” que esté en una carpeta llamada Ejercicio03-LDR

Ejercicio04 – Contar pulsos

Ejercicio04. Contar las veces que se pulsa (flanco ascendente) del botón A y B y mostrar por el monitor serie el total de pulsaciones de ambos botones cada vez que cambia el valor de alguno de los contadores.

Mostrar también los datos por la pantalla LCD.

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

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

Ejercicio05 – Mover Servo

Ejercicio05. Mover el servo entre las posiciones de 10º a 170º en función del valor leído en el potenciómetro.

Imprimir por la pantalla LCD la posición del servo.

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

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

Ejercicio06 – Contar Pulsos Wemos D1 Mini

Ejercicio06. Contar las veces que se pulsa el pulsador y mostrar por la pantalla oled el número de pulsaciones y el tiempo entre pulsaciones.

También crear un servidor web que muestre los datos de pulsaciones. 

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

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

Montaje Prácticas

Para el curso vamos a usar un entorno de trabajo fijo con diversas entradas y salidas analógicas y digitales, que una vez montado se usará en diferentes prácticas.

Para hacer el montaje se usará una protoboard por separado y no la protoboard que viene con el kit de Arduino. Este montaje no se desmontará durante todo el curso.

Esquemas fritzing disponibles en: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino_2019/tree/master/Esquemas%20Montajes%20Pr%C3%A1cticas%20Fritzing

Montaje Arduino UNO

Elementos:

  • PIN 2: Botón A. Resistencia pullup interna
  • PIN 3: Botón B. Resistencia pulldown externa
  • PIN 4: LED 1
  • PIN 5: LED 2 (PWM)
  • PIN 6: LED 3 (PWM)
  • PIN 7: LED 4
  • PIN 8: Buzzer
  • PIN 9: Servo
  • PIN 11: Sonda DHT11
  • PIN A0: Potenciómetro (Usar potenciómetro grande)
  • PIN A1: LDR
  • I2C (Pines SDA – A4 y SCL – A5): Pantalla LCD I2C

Montaje Wemos D1 Mini

Pines Wemos D1 Mini: https://steve.fi/Hardware/d1-pins/

Elementos:

Botones/Pulsadores

Botón A con resistencia pull-up interna.

Botón B con resistencia de pull-down externa de 10 Kohms

NOTA: Muy buen tutorial para entender las resistencias de pullup y pulldown http://www.instructables.com/id/Understanding-the-Pull-up-Resistor-With-Arduino/ 

LEDs

Un LED al ser un diodo tiene una caída de tensión que depende del tipo y del color del LED. Para usar un LED es imprescindible poner una resistencia adecuada a cada led. Según la ley de ohm: V = I * R, si el voltaje es de 5 V y queremos que al LED sólo le lleguen entre 5 mA (0.005 A) y 20 mA (0.02 A), entonces usar una resistencia entre 250 y 1000 ohms.

Circuito LED: https://es.wikipedia.org/wiki/Circuito_de_LED 

La fórmula a usar para calcular el valor correcto de la resistencia del circuito es:

Donde:

  • Voltaje de la fuente de alimentación, es el voltaje aplicado al circuito (5 voltios en el caso de Arduino)
  • Caída de voltaje del LED, es el voltaje necesario para el funcionamiento del LED, generalmente está entre 1.7 y 3.3 voltios, depende del color del diodo y de la composición de metales.
  • Rango de corriente del LED, es determinado por el fabricante, usualmente está en el rango de unos pocos miliamperios. A más corriente más iluminación. Para Arduino el valor máximo será de 20 mA.

Buzzer

Zumbador, buzzer en inglés, es un transductor electroacústico que produce un sonido o zumbido continuo o intermitente

El zumbador usado es: https://www.arduino.cc/documents/datasheets/PIEZO-PKM22EPPH4001-BO.pdf

Para usar el buzzer usaremos la función Tone() de Arduino. Tone() genera una onda cuadrada de una frecuencia específica y con un 50% de duty cycle en el pin especificado. La duración del tono puede ser especificado o en caso contrario continúa hasta llamar a la función noTone().

Para más información: Función tone(): https://www.arduino.cc/en/Reference/Tone

Servomotor

Servomotor (o también llamado servo) es similar a un motor de corriente continua pero con la capacidad de posicionarse en una posición determinada y permanecer fija en esta. Normalmente el ángulo es de 0 a 180 grados y se alimentan a 5 voltios mínimo.

Para controlar un servo, se usa el PWM. La mayoría de los servos trabaja en una frecuencia de 50 Hz (20ms). Cuando se manda un pulso, la anchura de este determina la posición angular del servo. La anchura varía según el servomotor pero normalmente es entre 0,5ms a 2,5ms.

En Arduino se utiliza la librería <Servo.h> para controlar los servos y generar las señales adecuadas para manejarlos. Dispone entre otras de las siguientes funciones:

Potenciómetro

Un potenciómetro es una resistencia cuyo valor de resistencia es variable. De esta manera, indirectamente, se puede controlar la intensidad de corriente que fluye por un circuito si se conecta en paralelo, o la diferencia de potencial al conectarlo en serie.

LDR

Se trata de un sensor que actúa como una resistencia variable en función de la luz que capta. A mayor intensidad de luz, menor resistencia: el sensor ofrece una resistencia de 1M ohm en la oscuridad, alrededor de 10k ohm en exposición de luz ambiente, hasta menos de 1k ohm expuesto a la luz del sol.

El LDR actúa como una resistencia variable. Para conocer la cantidad de luz que el sensor capta en cierto ambiente, necesitamos medir la tensión de salida del mismo. Para ello utilizaremos un divisor de tensión, colocando el punto de lectura para Vout entre ambas resistencias. De esta forma:

Donde Vout es el voltaje leído por el PIN analógico del Arduino y será convertido a un valor digital, Vin es el voltaje de entrada (5v), R2 será el valor de la resistencia fija colocada (10k ohm generalmente) y R1 es el valor resistivo del sensor LDR. A medida que el valor del sensor LDR varía, obtendremos una fracción mayor o menor del voltaje de entrada Vin.

El LDR que usamos: Photoresistor [VT90N2 LDR]

Sensor DHT11

Sensor de humedad y temperatura DHT11. Es lo suficientemente exacta para la mayoría de los proyectos que necesitan hacer un seguimiento de las lecturas de humedad y temperatura. Es unas de las sondas más populares.

Parámetros del producto:

  • Humedad relativa:
    • Resolución: 16 bits
    • Repetibilidad: ±1% H.R.
    • Precisión: 25 ° C ± 5% hr
    • Histéresis: < ± 0.3% RH
    • Estabilidad a largo plazo: < ± 0.5% hr / año
  • Temperatura:
    • Resolución: 16 bits
    • Repetibilidad: ±0. 2 ° C
    • Precisión: 25 ° C ± 2° c
  • Características eléctricas
    • Fuente de alimentación: DC 3.5 ~5.5V
    • Corriente: medición 0.3mA
    • Espera 60μA
    • Periodo de muestreo: más de 2 segundos
  • Descripción pines:
    • VDD alimentación 3,5~5.5V DC
    • serie de datos, un solo bus
    • NC, pin vacío
    • GND tierra, la energía negativa

Datasheet y protocolo sonda DHT11: https://akizukidenshi.com/download/ds/aosong/DHT11.pdf

Librerías:

Pantalla LCD I2C

Pantalla LCD I2C. La pantalla tiene una retroiluminación de LED y puede mostrar dos filas con hasta 16 caracteres en cada fila.

El controlador de LCD I2C es un dispositivo que nos permite controlar una pantalla a través del bus I2C, usando únicamente dos cables.

Librería LiquidCrystal_I2C del gestor de librerías: https://github.com/marcoschwartz/LiquidCrystal_I2C

La dirección I2C por defecto del módulo puede ser 0x3F o en otros casos 0x27. Es muy importante identificar correctamente la dirección I2C de nuestro módulo, pues de otra forma nuestro programa no funcionará correctamente. Para identificar la dirección específica de nuestro módulo podemos utilizar un pequeño sketch de prueba llamado: I2C Scanner, el cual nos permite identificar la dirección I2C del dispositivo conectado al Arduino.

Más información: https://www.naylampmechatronics.com/blog/35_Tutorial–LCD-con-I2C-controla-un-LCD-con-so.html

Wemos D1 Mini

Wemos son una serie de placas de prototipado con chip ESP8266 integrado para conexión WiFi. Hay varios modelos y la página web oficial es https://www.wemos.cc/

Vamos a usar la Wemos D1 Mini: https://wiki.wemos.cc/products:d1:d1_mini 

Shields Wemos D1 Mini

Fritzing parts: https://github.com/mcauser/Fritzing-Part-WeMos-D1-mini-Shields

Relay Shield

Web: https://wiki.wemos.cc/products:d1_mini_shields:relay_shield

Por defecto usa el pin D1, pero es configurable.

Wemos RGB LED Shield

Web: https://wiki.wemos.cc/products:d1_mini_shields:rgb_led_shield

Por defecto usa el pin D4, pero es configurable.

NOTA: La shield led RGB de un pin va al pin D2: https://wiki.wemos.cc/products:d1_mini_shields:ws2812b_rgb_shield

Wemos mini Oled Shield

Web: https://wiki.wemos.cc/products:d1_mini_shields:oled_shield

Pantalla I2C – Pines SDA – D2 y SCL – A1

Librería Pantalla: https://github.com/mcauser/Adafruit_SSD1306/tree/esp8266-64×48

Librería Botones: https://github.com/wemos/LOLIN_OLED_I2C_Button_Library (En la versión disponible para prácticas no dispone de los botones)

Características

  • Screen Size: 64×48 pixels (0.66” Across)
  • Operating Voltage: 3.3V
  • Driver IC: SSD1306 (I2C Address: 0x3C or 0x3D)
  • 2x I2C Button (customizable I2C Address, default:0x31)

Ejercicio01 – Testeo del Circuito Arduino

Para comprobar que todo funciona ejecutar el programa de testeo. Para ello coger el código de https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino_2019/blob/master/Ejercicio01-Comprueba_Entorno_Arduino/Ejercicio01-Comprueba_Entorno_Arduino.ino.

Todo el código que haga cada alumno lo guardará en su repositorio de github llamado: “Curso Programacion Arduino 2019”. Cada ejercicio se guardará en un directorio con el nombre EjercicioXX y dentro el código.

Pasos a seguir:

Ejecutar todos los test del Ejercicio01 y comprobar que funciona todo correctamente.

En caso que algo no funcione a lo largo del curso, usar este sketch para comprobar que la parte hardware funciona correctamente.

Tests:

  • 1 – Muestra Texto Pantalla
  • 2 – Prueba Botones (comprobar pulsaciones correctas)
  • 3 – Prueba LEDs (Iluminación LEDs)
  • 4 – Prueba PWM LEDs (No todos los LEDs son PWM)
  • 5 – Prueba Potenciómetro (comprobar que va de 0 a 1023)
  • 6 – Prueba LDR (ver valores máximo y mínimo. Anotarlos)
  • 7 – Sonda temperatura (comprueba valores) DHT11
  • 8 – Test Servo (comprobar el movimiento completo)
  • 9 – Test Buzzer (comprobar sonido)

IMPORTANTE: después de ejecutar los test o mientras se ejecutan, leer el código, entenderlo y preguntar todo aquello que no se entienda.

NOTA:  Las funciones de testeo de cada componente se pueden usar como plantilla para los ejercicios propuestos a lo largo del curso.

Ejercicio02 – Testeo del Circuito Wemos D1 Mini

Pasos a seguir:

Ejecutar todos los test del Ejercicio02 y comprobar que funciona todo correctamente.

Código: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino_2019/blob/master/Ejercicio02-Comprueba_Entorno_ESP8266/Ejercicio02-Comprueba_Entorno_ESP8266.ino

En caso que algo no funcione a lo largo del curso, usar este sketch para comprobar que la parte hardware funciona correctamente.

Tests:

  • 1 – Muestra IP Arduino
  • 2 – Test Cliente Web (comprobar respuesta del servidor)
  • 3 – Test Servidor Web (comprobar servidor embebido en Arduino)
  • 4 – Prueba Pulsador (comprobar pulsaciones correctas)
  • 5 – Prueba Relé Shield
  • 6 – Prueba Neopixel Shield
  • 7 – Prueba Pantalla Oled Shield