Crea Proyectos IoT Simples con Arduino UNO, ESP-01, ThingSpeak y MIT App Inventor

Componentes y materiales

Componente	Cantidad	Precio aprox.
Arduino UNO	1	$10.00
ESP8266 ESP-01 (Módulo WiFi)	1	$3.50
Sensor DHT22 (Temperatura y humedad aire)	1	$9.00
DS18B20 (Sensor temperatura 1-Wire para suelo)	1	$6.00
YL-69 + LM393 (Sensor humedad suelo)	1	$2.00
LDR (Fotorresistencia - Sensor luminosidad)	1	$0.20
2 x LEDs (Rojo y Verde)	2	-
Módulo Relé 2 Canales 5V DC con Optoacoplador (Low Level Trigger)	1	$7.00
Bomba DC 5V	1	$3.00
Lámpara 220V	1	-
Resistencias: 2x330Ω, 2x10kΩ, 1x4.7kΩ	-	-
Protoboard, Jumpers, Fuente 5V DC externa para relés	-	-

Aplicaciones y servicios online

• Arduino IDE - Programación
• ThingSpeak API - Plataforma IoT en la nube
• MIT App Inventor - Desarrollo app Android

Sobre este proyecto

Nuestro objetivo será básicamente recopilar información de una unidad local y enviarla a internet. Un usuario en cualquier parte del planeta que consulte esta información tomará decisiones enviando comandos remotos a los actuadores, que también estarán en esta unidad local. Podría usarse cualquier sensor o actuador.

[Imagen del diagrama]

La gran mayoría de mi trabajo en IoT fue usando NodeMCU y más recientemente ESP32. Pero creo importante no olvidar mis primeros pasos, hace un par de años, donde empecé a aprender IoT usando un Arduino UNO y el viejo y bueno ESP8266-01.

Así que decido aquí volver a ese momento (con un poco más de experiencia ahora) y explorar nuevamente esos grandes dispositivos, conectándolos a la nube, usando el servicio web ThingSpeak.com. También exploraremos el control remoto usando una App Android desarrollada con MIT App Inventor.

[Imagen del diagrama]

El "Centro de nuestro proyecto IoT" será ThingSpeak.com. La unidad local (UNO/ESP-01) capturará datos de sensores y estado de actuadores, enviándolos a internet, "escribiendo" en un Canal de Estado ThingSpeak específico. La unidad local también recibirá datos de internet, "leyéndolos" de Canales de Actuadores ThingSpeak específicos.

Una App Android también leerá esos datos del Canal de Estado ThingSpeak y los mostrará al usuario. De la misma forma, el usuario, basándose en esa información de estado, puede enviar comandos a los actuadores, escribiéndolos en los Canales de Actuadores ThingSpeak (ver diagrama de bloques anterior para entender mejor el flujo de datos).

Paso 1: Introducción

[Imagen]

Usando sensores comunes, nuestro proyecto capturará varios datos, enviándolos a la nube, donde cualquiera puede verlos a través de internet. Para trabajar esos datos, usaremos el servicio de ThingSpeak.com, una plataforma IoT abierta que nos permitirá recopilar, analizar y actuar sobre esos datos.

Datos a recopilar por sensores:

• Temperatura del aire y humedad relativa
• Temperatura y humedad del suelo
• Luminosidad

Actuadores del proyecto (2):

• Bomba eléctrica
• Lámpara eléctrica

El estado de esos actuadores ("ON/OFF") también debe enviarse a la nube.

La idea es capturar esos datos de los sensores, por ejemplo, de una plantación, y enviarlos a la nube. Basándose en esos datos, un usuario debería tomar decisiones según estas reglas:

• Encender la Bomba si la humedad del suelo es muy baja
• Encender la Lámpara si la temperatura del suelo es muy baja

Para comandar remotamente nuestros actuadores, usaremos una App Android.

Paso 2: Lista de materiales (BoM)

Ver tabla de componentes arriba con precios orientativos.

Paso 3: El Hardware

[Imagen]

Ensamblemos el hardware del proyecto. Lo ideal es instalar y probar nuestro proyecto por partes. Como sugerencia, podemos seguir estos pasos:

1. Instalar y probar localmente todos los sensores
2. Instalar y configurar el ESP-01 (BareMinimum)
3. Cambiar la instalación del ESP-01 a su configuración final y probarlo
4. Configurar el Canal de Estado ThingSpeak
5. Instalar código ThingSpeak en Arduino y verificar estado de sensores en la nube
6. Desarrollar primera versión de App Android para mostrar estado y mensajes
7. Instalar actuadores (LEDs y Relés)
8. Configurar Canales de Actuadores ThingSpeak
9. Instalar y probar código Arduino con actuadores
10. Desarrollar versión final de App Android

Paso 4: Conectando Sensores

[Imagen]

Debemos tener algunas librerías instaladas en nuestro IDE para leer los sensores correctamente. Verifica si tienes todas instaladas. Su configuración inicial debería ser:

// DS18B20
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 5  // DS18B20 en pin D5
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);
int soilTemp = 0;

// DHT
#include "DHT.h"
#include <stdlib.h>
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht(pinoDHT, tipoDHT);
int airTemp = 0;
int airHum = 0;

// LDR (Luz)
#define ldrPIN 1
int light = 0;

// Humedad suelo
#define soilHumPIN 0
int soilHum = 0;

En Setup y loop, escribamos:

void setup() {
  Serial.begin(9600);
  DS18B20.begin();
  dht.begin();
}

void loop() {
  readSensors();
  displaySensors();
  delay(10000);
}

Y por último, escribamos dos funciones específicas, una para leer nuestros sensores y otra para mostrar sus valores en el Monitor Serie:

/********* Leer valores de sensores *************/
void readSensors(void) {
  airTemp = dht.readTemperature();
  airHum = dht.readHumidity();
  DS18B20.requestTemperatures();
  soilTemp = DS18B20.getTempCByIndex(0);  // Sensor 0 captura Temp Suelo en °C
  soilHum = map(analogRead(soilHumPIN), 1023, 0, 0, 100);
  light = map(analogRead(ldrPIN), 1023, 0, 0, 100);  // LDR Oscuro:0 => luz 100%
}

/********* Mostrar valores de sensores *************/
void displaySensors(void) {
  Serial.print("airTemp (°C): "); Serial.println(airTemp);
  Serial.print("airHum (%): "); Serial.println(airHum);
  Serial.print("soilTemp (°C): "); Serial.println(soilTemp);
  Serial.print("soilHum (%): "); Serial.println(soilHum);
  Serial.print("light (%): "); Serial.println(light);
  Serial.println("");
}

La imagen del Monitor Serie muestra los valores de los sensores.

[Imagen]

El código puede descargarse de mi GitHub: Sensors_Test.ino

Paso 5: Configuración Inicial ESP8266-01

[Imagen]

El ESP-01 se usará como Puente Serial (Serial Bridge), lo que significa que lo programaremos usando "comandos AT". Lo primero es asegurar que tu ESP-01 esté en la velocidad de comunicación (Baud Rate) correcta. En nuestro caso, 9,600 baudios. Generalmente, el ESP-01 viene programado de fábrica con 115,200 baudios y debemos cambiarlo a 9,600.

1. Conecta el ESP-01 como se muestra arriba.
2. Conecta Arduino a tu PC, abre el IDE y carga el ejemplo: Archivo > Ejemplos > 01.Basics > BareMinimum. Este código vacío asegura que no haya conflicto de comunicación serial entre Arduino y ESP.
3. Abre el Monitor Serie del IDE y cambia la velocidad a 115,200 baudios. Envía un comando "AT". El ESP-01 debería responder "OK".
4. Cambia la velocidad con el comando: AT+UART_DEF=9600,8,1,0,0 (9600 baud / 8 bits datos / 1 bit stop / sin paridad / sin control flujo).
5. En el Monitor Serie, cambia la velocidad a "9600 baud". Prueba: escribe AT y verifica respuesta OK.
6. Configura el módulo en Modo Estación (Station Mode) para actuar como Cliente de tu red WiFi: AT+CWMODE=1
7. Conecta el módulo a tu red WiFi: AT+CWJAP="nombre_red","contraseña"
8. Si ves: WIFI CONNECTED / WIFI GOT IP, la conexión es correcta.
9. Para ver la IP: AT+CIFSR (anota la IP para uso futuro).

Paso 6: Probando el ESP-01

[Imagen]

Una vez configurado el ESP-01, instálalo en su circuito final. Cambia el cableado y conecta el ESP-01 al UNO así:

• ESP-01 RX (Amarillo) → UNO Pin D7
• ESP-01 TX (Naranja) → UNO Pin D6
• ESP-01 Ch-Pd (Marrón) → Vcc (3.3V)
• ESP-01 Reset (Azul) → UNO Pin D8
• ESP-01 Vcc (Rojo) → 3.3V
• ESP-01 Gnd (Negro) → UNO GND

Hagamos una prueba simple para verificar que el ESP-01 está correctamente instalado:

#include <SoftwareSerial.h>
SoftwareSerial esp8266(6, 7);  // Rx => Pin 6; TX => Pin 7
#define speed8266 9600

void setup() {
  esp8266.begin(speed8266);
  Serial.begin(speed8266);
  Serial.println("ESP8266 Setup test - use AT commands");
}

void loop() {
  while(esp8266.available()) Serial.write(esp8266.read());
  while(Serial.available()) esp8266.write(Serial.read());
}

Ahora, prueba algunos comandos AT y ve el resultado en tu Monitor Serie:

* AT          =====> ESP8266 devuelve OK
* AT+RST      =====> ESP8266 reinicia y devuelve OK
* AT+GMR      =====> ESP8266 devuelve AT Version; SDK version; id; OK
* AT+CWMODE?  =====> ESP8266 devuelve tipo de modo
* AT+CWLAP    =====> ESP8266 devuelve puntos de acceso cercanos
* AT+CIFSR    =====> ESP8266 devuelve IP asignada

Código en GitHub: ESP_AT_Config.ino

Para conectar a la red WiFi automáticamente en cada reset, añade una llamada a connectWiFi() al final de setup():

void connectWiFi(void) {
  sendData("AT+RST\r\n", 2000, 0);  // reset
  sendData("AT+CWJAP=\"TU_USUARIO\",\"TU_PASSWORD\"\r\n", 2000, 0);
  delay(3000);
  sendData("AT+CWMODE=1\r\n", 1000, 0);
  sendData("AT+CIFSR\r\n", 1000, 0);  // Muestra IP
  Serial.println("8266 Conectado");
}

String sendData(String command, const int timeout, boolean debug) {
  String response = "";
  EspSerial.print(command);
  long int time = millis();
  while ((time + timeout) > millis()) {
    while (EspSerial.available()) {
      char c = EspSerial.read();
      response += c;
    }
  }
  if (debug) Serial.print(response);
  return response;
}

Paso 7: Conectando Sensores y ESP-01

[Imagen]

Una vez tenemos todos los sensores instalados y probados y también nuestro ESP-01 funcionando, veamos todo junto y listo para enviar datos a internet.

Paso 8: ThingSpeak

[Imagen]

Una de las partes más importantes es ThingSpeak, una plataforma IoT abierta para recopilar, analizar y actuar sobre datos. Si no tienes cuenta, ve a ThingSpeak y regístrate.

Crea un nuevo Canal con 2 actuadores, 5 sensores y un campo extra:

• Field 1: Actuador 1 (Bomba)
• Field 2: Actuador 2 (Lámpara)
• Field 3: Temperatura aire (°C)
• Field 4: Humedad aire (%)
• Field 5: Temperatura suelo (°C)
• Field 6: Humedad suelo (%)
• Field 7: Luminosidad (%)
• Field 8: Reserva (contador de errores de comunicación)

Al crear el canal (nuestro Canal de Estado), anota tus claves (Write Key, Read Key, Channel ID).

Paso 9: Enviando Estado a la Nube

[Imagen]

Enviamos datos a ThingSpeak mediante una petición GET en 3 partes:

1. Comando inicio: AT+CIPSTART="TCP","184.106.153.149",80
2. Longitud del comando: AT+CIPSEND=116
3. String GET: GET /update?api_key=TU_WRITE_KEY&field1=bomba&field2=lampara&field3=airTemp&field4=airHum&field5=soilTemp&field6=soilHum&field7=light&field8=spare

El código completo para envío de estado está en GitHub: SendingStatusTS_EXT.ino

Paso 10: App Android - Parte 1 (Monitoreo de Estado)

[Imagen]

Diseñamos la interfaz de usuario y los bloques de lógica. Cada 2 segundos (Clock1), llamamos al procedimiento readArduino que lee el Canal de Estado en ThingSpeak, procesa el JSON recibido y actualiza las etiquetas en pantalla. Convierte valores "0"/"1" a "OFF"/"ON". Incluye alarma visual (parpadeo) si temperatura suelo < 10°C o humedad < 60%.

Código App en GitHub: ArduFarmBot_Status_App_EXT.aia

Paso 11: Instalando Actuadores (LEDs y Relés)

[Imagen]

Completamos el hardware instalando actuadores. Usamos módulo relé con optoacoplador Low-Level Trigger, alimentado a 5V por pin separado. El GND del relé NO se conecta al GND del Arduino para evitar ruido.

Paso 12: Configurando Canales de Actuadores ThingSpeak

[Imagen]

Creamos 2 nuevos canales (uno por actuador), anotando Channel ID, Read/Write Keys. Escribimos solo en Field 1 de cada canal:

• Canal 375598 → LED Rojo (Bomba): Field1=0 OFF, Field1=1 ON
• Canal 375599 → LED Verde (Lámpara): Field1=0 OFF, Field1=1 ON

Paso 13: Instalando y Probando Código Arduino con Actuadores

[Imagen]

Ahora LEEMOS de canales ThingSpeak (descargar datos). Enviamos GET a /channels/ID/fields/1/last cada 10 segundos. La función clave es readThingSpeak(String channelID).

Código completo en GitHub: ReadingCommandTS_EXT.ino

Paso 14: Enviando Comandos a Actuadores (Prueba navegador)

Podemos probar desde navegador:

Encender Bomba:  https://api.thingspeak.com/update?api_key=ACT1_WRITE_KEY&field1=1
Apagar Bomba:    https://api.thingspeak.com/update?api_key=ACT1_WRITE_KEY&field1=0
Encender Lámpara: https://api.thingspeak.com/update?api_key=ACT2_WRITE_KEY&field1=1
Apagar Lámpara:   https://api.thingspeak.com/update?api_key=ACT2_WRITE_KEY&field1=0

Paso 15: Completando la App Android

[Imagen]

Añadimos botones ON/OFF para cada actuador. Al presionar, cambian color (ON=Azul, OFF=Rojo) y escriben en los canales de actuadores ThingSpeak.

App completa en GitHub: ArduFarmBot_V1_EXT.aia

Paso 16: Uniendo Todo

[Imagen]

Código final completo en GitHub: ArduFarmBot_Light_EXT.ino (incluye verificación de congelamiento ESP-01 y reset por software).

Paso 17: Conclusión

[Imagen]

Hay mucho por explorar en IoT con estos grandes dispositivos: Arduino Uno y ESP8266-01. ¡Volveré pronto con nuevos tutoriales! Sigue los tutoriales de MJRoBot.

Espero que este proyecto ayude a otros a encontrar su camino en el emocionante mundo de la electrónica, robótica e IoT.

Visita mi GitHub para archivos actualizados: ArduFarmBot_Light

Más proyectos en mi blog: MJRoBot.org

¡Saludos desde el sur del mundo! Nos vemos en el próximo tutorial. Gracias, Marcelo.

Código (Fragmentos principales)

Los fragmentos de código completos están disponibles en el repositorio GitHub. Aquí se muestran los más relevantes:

Configuración sensores

// DS18B20
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 5
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);
int soilTemp = 0;

// DHT22
#include "DHT.h"
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht(pinoDHT, tipoDHT);
int airTemp = 0; int airHum = 0;

// LDR
#define ldrPIN 1
int light = 0;

// Humedad suelo
#define soilHumPIN 0
int soilHum = 0;

Lectura y visualización sensores

void readSensors(void) {
  airTemp = dht.readTemperature();
  airHum = dht.readHumidity();
  DS18B20.requestTemperatures();
  soilTemp = DS18B20.getTempCByIndex(0);
  soilHum = map(analogRead(soilHumPIN), 1023, 0, 0, 100);
  light = map(analogRead(ldrPIN), 1023, 0, 0, 100);
}

void displaySensors(void) {
  Serial.print("airTemp (°C): "); Serial.println(airTemp);
  Serial.print("airHum (%): "); Serial.println(airHum);
  Serial.print("soilTemp (°C): "); Serial.println(soilTemp);
  Serial.print("soilHum (%): "); Serial.println(soilHum);
  Serial.print("light (%): "); Serial.println(light);
  Serial.println("");
}

Test ESP-01 con SoftwareSerial

#include <SoftwareSerial.h>
SoftwareSerial esp8266(6, 7);
#define speed8266 9600

void setup() {
  esp8266.begin(speed8266);
  Serial.begin(speed8266);
  Serial.println("ESP8266 Setup test - use AT commands");
}

void loop() {
  while(esp8266.available()) Serial.write(esp8266.read());
  while(Serial.available()) esp8266.write(Serial.read());
}

Envío estado a ThingSpeak

// Variables ThingSpeak
String statusChWriteKey = "TU_WRITE_KEY";
SoftwareSerial EspSerial(6, 7);
#define HARDWARE_RESET 8
// ... (variables sensores, timers, actuadores)

void writeThingSpeak(void) {
  startThingSpeakCmd();
  String getStr = "GET /update?api_key=";
  getStr += statusChWriteKey;
  getStr += "&field1=" + String(pump);
  getStr += "&field2=" + String(lamp);
  getStr += "&field3=" + String(airTemp);
  getStr += "&field4=" + String(airHum);
  getStr += "&field5=" + String(soilTemp);
  getStr += "&field6=" + String(soilHum);
  getStr += "&field7=" + String(light);
  getStr += "&field8=" + String(spare);
  getStr += "\r\n\r\n";
  sendThingSpeakGetCmd(getStr);
}

Lectura comandos actuadores desde ThingSpeak

int readThingSpeak(String channelID) {
  startThingSpeakCmd();
  String getStr = "GET /channels/" + channelID + "/fields/1/last\r\n";
  String messageDown = sendThingSpeakGetCmd(getStr);
  if (messageDown[5] == 49) {  // ASCII '1'
    return messageDown[7] - 48;  // Extrae valor 0 o 1
  }
  return 9;  // Error
}

Esquemáticos

Diagrama eléctrico completo: GitHub - ArduFarmBot Light.fzz