A veces, en ingeniería, el reto no es solo crear algo nuevo, sino hacer que conviva con lo que ya existe. Hace poco estuve trabajando en un proyecto muy interesante que resume perfectamente esta idea: un sistema de gestión y registro de baterías (Datalogger) capaz de hablar dos “idiomas” distintos.
El problema: Lo viejo vs. Lo nuevo
En el mundo de las baterías hay, básicamente, dos grandes grupos conviviendo:
Las baterías “inteligentes” (SBS): Son las modernas. Ellas mismas te dicen “estoy al 80%”, “tengo esta temperatura” o “me quedan tantos ciclos de vida”. Se comunican digitalmente.
Las baterías “tradicionales” (Analógicas): Son las de toda la vida. No “hablan”, así que para saber cómo están tienes que medir físicamente su voltaje, la corriente que entra y sale, y usar sondas externas para vigilar que no se calienten.
El objetivo era crear un cerebro único que pudiera manejar ambas situaciones sin despeinarse.
La solución: Un sistema híbrido
Desarrollé un firmware capaz de trabajar en dos modos. Si el sistema detecta una batería moderna, se comporta como un “host” digital: lee directamente los datos internos (voltaje, amperaje, salud de la batería) a través de protocolos de comunicación estándar. Es limpio y preciso.
Pero, si conectamos una batería analógica, el sistema cambia el chip. Pasa a usar sensores físicos para leer la corriente y el voltaje, y gestiona sondas de temperatura externas para asegurarse de que todo opera dentro de los márgenes de seguridad.
¿Por qué es útil esto?
Lo bonito de este desarrollo es la versatilidad. El dispositivo no solo gestiona la carga, sino que actúa como una “caja negra”:
Registro de datos: Guarda un historial diario en una tarjeta SD con todo lo que pasa (ciclos de carga, temperaturas, potencias…).
Seguridad: Tiene alarmas programadas. Si una batería se calienta demasiado o baja de cierto nivel, el sistema avisa y corta para prevenir daños, da igual si la batería es digital o analógica.
Visualización: Toda la info se muestra sencilla en una pantalla OLED para que el usuario sepa qué pasa de un vistazo.
Al final, este proyecto ha sido un buen ejercicio de adaptación. La electrónica sirve para hacer de puente entre tecnologías distintas, alargando la vida útil de los equipos y mejorando la seguridad, sea cual sea la batería que se use.
Actualizado: 3/7/2025: Ahora es compatible con familia de uC Espressif ESP8266 y ESP32. Este proyecto detalla cómo utilizar un ESP32 y un módulo DFPlayer Mini para reproducir archivos MP3 de manera automática cada cierto tiempo. Se abordan los aspectos del módulo DFPlayer Mini, las conexiones necesarias y el código de programación, proporcionando una guía completa para la implementación de este sistema de reproducción de audio.
El DFPlayer Mini es un módulo de reproducción de audio compacto y de bajo costo que puede reproducir archivos MP3 y WAV almacenados en una tarjeta microSD. Es ampliamente utilizado en proyectos de electrónica debido a su facilidad de uso y a su capacidad para manejar archivos de audio de manera autónoma, sin necesidad de una fuente de control compleja. El módulo cuenta con varias funciones, incluyendo el ajuste de volumen, control de reproducción, y la capacidad de seleccionar pistas mediante comandos simples.
Conexiones del Proyecto
Para conectar el DFPlayer Mini con el ESP32, es importante seguir las siguientes indicaciones:
VCC: Conectar a una fuente de alimentación de 5V. El ESP32 puede proporcionar esta salida.
GND: Conectar al pin de tierra (GND) del ESP32.
TX del DFPlayer Mini: Conectar al pin GPIO 16 del ESP32.
RX del DFPlayer Mini: Conectar al pin GPIO 17 del ESP32.
SPK1 y SPK2: Conectar a un altavoz pasivo, si se desea una salida de audio. Alternativamente, se puede usar un conector de auriculares para salida de línea.
Es fundamental asegurarse de que las conexiones sean correctas para evitar daños en los componentes y garantizar un funcionamiento óptimo del sistema.
3. Código de Programación
El siguiente código muestra cómo configurar el ESP32 para comunicarse con el DFPlayer Mini y reproducir un archivo MP3 cada 10 segundos. Se utiliza el puerto Serial1 del ESP32/ESP8266 para la comunicación, aprovechando la capacidad del microcontrolador para manejar múltiples puertos UART de hardware.
#include <Arduino.h>
#include <DFPlayerMini_Fast.h>
#if defined(ESP32)
// En ESP32 podemos usar HardwareSerial en un segundo puerto
HardwareSerial playerSerial(2); // UART2: GPIO16=RX2, GPIO17=TX2 por defecto
const int DF_RX = 16; // al TX del DFPlayer
const int DF_TX = 17; // al RX del DFPlayer
#elif defined(ESP8266)
#include <SoftwareSerial.h>
const int DF_RX = D5; // ESP8266: conecta a TX del DFPlayer
const int DF_TX = D6; // ESP8266: conecta a RX del DFPlayer
SoftwareSerial playerSerial(DF_RX, DF_TX);
#else
#error "Este código sólo es para ESP32 o ESP8266"
#endif
DFPlayerMini_Fast myDFPlayer;
const unsigned long intervalReproduccion = 10000; // 10 s
unsigned long lastMillis = 0;
void setup() {
Serial.begin(115200);
Serial.println();
Serial.println("=== DFPlayer en ESP32/ESP8266 ===");
// Inicializar puerto al módulo
#if defined(ESP32)
playerSerial.begin(9600, SERIAL_8N1, DF_RX, DF_TX);
#elif defined(ESP8266)
playerSerial.begin(9600);
#endif
if (! myDFPlayer.begin(playerSerial)) {
Serial.println(F("ERROR: No se detectó DFPlayer Mini"));
while (true) delay(100);
}
myDFPlayer.volume(20); // 0–30
myDFPlayer.play(1); // empieza en pista 001
lastMillis = millis();
}
void loop() {
unsigned long now = millis();
// Cada 10 s, reproducir siguiente pista
if (now - lastMillis >= intervalReproduccion) {
lastMillis = now;
myDFPlayer.playNext();
}
// Procesar eventos del DFPlayer (fin de pista, errores…)
if (myDFPlayer.available()) {
DFPlayerEventType type = myDFPlayer.readType();
int state = myDFPlayer.readState();
Serial.print(F("Evento DFPlayer: "));
Serial.print(type);
Serial.print(F(" Estado interno: "));
Serial.println(state);
}
// Aquí puedes gestionar botones u otras tareas no bloqueantes
delay(20);
}
En este código, se utilizan las siguientes funciones y configuraciones:
mySerial.begin(9600, SERIAL_8N1, 16, 17); Esta línea configura el puerto Serial1 del ESP32 con una velocidad de comunicación de 9600 baudios y establece los pines GPIO 16 y 17 como RX y TX, respectivamente.
myDFPlayer.begin(mySerial); Esta función inicializa el DFPlayer Mini y lo prepara para recibir comandos.
myDFPlayer.volume(20); Se ajusta el volumen del reproductor a un nivel de 20 (en una escala de 0 a 30).
myDFPlayer.play(1); Este comando indica al DFPlayer Mini que reproduzca el archivo de audio numerado como 1 en la tarjeta microSD.
delay(10000); Introduce una pausa de 10 segundos antes de repetir el ciclo.
Este código permite la reproducción continua de un archivo MP3, con una espera de 10 segundos entre reproducciones. Es posible modificar el tiempo de espera o cambiar el archivo a reproducir ajustando los parámetros del código según las necesidades del proyecto.
#include <WiFi.h>
const char* ssid = "Nombre_Red_Servidor";
const char* password = "Contraseña_Servidor";
WiFiServer server(80);
int buttonPin = 5;
int buttonState = 0;
void setup() {
Serial.begin(115200);
pinMode(buttonPin, INPUT_PULLUP);
// Configurar el ESP32 como un punto de acceso
WiFi.softAP(ssid, password);
IPAddress IP = WiFi.softAPIP();
Serial.print("AP IP address: ");
Serial.println(IP);
server.begin();
Serial.println("Server started");
}
void loop() {
WiFiClient client = server.available();
if (client) {
//Serial.println("New client connected");
while (client.connected()) {
// Leer el estado del botón
buttonState = 99;
//String response = String(buttonState) + "," + String(analogRead(A0)) + "," + String(random(100));
//client.println(response);
if (client.available()) {
String request = client.readStringUntil('\r');
Serial.print("Client says: ");
Serial.print(request);
Serial.print(", ");
int b = request.length();
//Serial.print("b=");
//Serial.println(b);
if (b > 2) {
int value1 = request.substring(0, request.indexOf(',')).toInt();
request = request.substring(request.indexOf(',') + 1);
int value2 = request.toInt();
Serial.print("Received values from client: ");
Serial.print(value1);
Serial.print(", ");
Serial.println(value2);
}
}
//////// cada 3 segundos envia
static unsigned long a;
if (millis() > a + 5000) {
a = millis();
// Enviar dos variables simuladas al servidor
int value1 = 2; // Valor simulado 1
int value2 = 4; // Valor simulado 2
int value3 = 6; // Valor simulado 2
String response = String(value1) + "," + String(value2)+ "," + String(value3);
//String response = String(buttonState) + "," + String(analogRead(A0)) + "," + String(random(100));
Serial.print("Sending response: ");
Serial.println(response);
client.println(response);
client.stop();
}
}
//Serial.println("Client disconnected");
}
}
Cliente:
#include <WiFi.h>
const char* ssid = "Nombre_Red_Servidor"; // Reemplaza con el SSID de tu red
const char* password = "Contraseña_Servidor"; // Reemplaza con la contraseña de tu red
const char* serverIP = "192.168.4.1"; // Reemplaza con la dirección IP del servidor
const int serverPort = 80;
void setup() {
Serial.begin(115200);
Serial.println("Conectándose a la red WiFi...");
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Conectado a la red WiFi. Dirección IP: ");
Serial.println(WiFi.localIP());
}
void loop() {
// Simular dos valores enteros para enviar al servidor
int value1 = 1; // Valor simulado 1 (número aleatorio entre 0 y 9)
int value2 = 3; // Valor simulado 2 (número aleatorio entre 0 y 99)
// Construir la solicitud al servidor en el formato "value1,value2"
String request = String(value1) + "," + String(value2);
Serial.print("Enviando solicitud al servidor: ");
Serial.println(request);
// Establecer la conexión con el servidor
WiFiClient client;
if (client.connect(serverIP, serverPort)) {
// Enviar la solicitud al servidor
client.println(request);
// Esperar la respuesta del servidor
String response = client.readStringUntil('\r');
Serial.print("Respuesta del servidor: ");
Serial.println(response);
// Si necesitas utilizar los valores de la respuesta separados por comas, puedes hacerlo de la siguiente manera:
int serverValue1 = response.substring(0, response.indexOf(',')).toInt();
response = response.substring(response.indexOf(',') + 1);
int serverValue2 = response.substring(0, response.indexOf(',')).toInt();
//response = response.substring(response.indexOf(',') + 1);
//int serverValue3 = response.toInt();
Serial.print("Valores recibidos del servidor: ");
Serial.print(serverValue1);
Serial.print(", ");
Serial.print(serverValue2);
//Serial.print(", ");
//Serial.println(serverValue3);
}
// Esperar 5 segundos antes de enviar una nueva solicitud
delay(5000);
}
App Inventor 2 es una plataforma en línea de código abierto que permite crear aplicaciones para dispositivos Android sin necesidad de conocimientos avanzados de programación. F
App Inventor 2 fue desarrollado por Google y posteriormente transferido al MIT (Instituto Tecnológico de Massachusetts).
Para este proyecto se creará una aplicación en App Inventor que se conecte a un slider a través de Bluetooth y lo controle desde un dispositivo programado con Arduino IDE
Aplicación en App Inventor que se conecte a un slider a través de Bluetooth y se controle desde un dispositivo Arduino con un ESP32, puedes seguir estos pasos generales:
Lado de la Aplicación en App Inventor:
1. Crear la Interfaz Gráfica:
2. Comienza un nuevo proyecto
3. Componentes Bluetooth: Añadir el componente Bluetooth al diseño.
4. Configurar Bluetooth:
Configurar el componente Bluetooth para buscar dispositivos y establecer la conexión.
Programar la Interacción con el Slider:
Programar la lógica que enviará los datos del slider a través de Bluetooth al dispositivo Arduino cuando se modifique su valor.
Manejar la Conexión y Desconexión:
Implementar lógica para gestionar la conexión y desconexión con el dispositivo Bluetooth.
Diseñar la Interfaz de Usuario:
Diseñar la interfaz de usuario para mostrar el estado de la conexión y otra información relevante.
En la pantalla de diseño, agrega un componente Slider desde la paleta de componentes.
Manejo del Slider y envío de datos:
En el bloque "BluetoothClient1.SendText", el valor del slider se convierte a una cadena (Text), ya que el módulo Bluetooth envía datos como texto.
Asegúrate de configurar correctamente el BluetoothClient1.Address con la dirección Bluetooth de tu dispositivo.
Conecta tu dispositivo Android a tu Arduino mediante Bluetooth.
Lado del Dispositivo Arduino (ESP32):
Preparar todo para poder configurar el ESP32 con Arduino IDE.
Programar la Lógica del ArduinoControlar el Slider (recibir datos)
Escribe un programa para el ESP32 que escuche los datos enviados por la aplicación a través de Bluetooth.
Implementa la lógica que ajustará el valor del slider según los datos recibidos a través de Bluetooth.
Controlar un slider en App Inventor 2 y enviar los datos al ESP32 a través de Bluetooth
Asegurarse tener un módulo Bluetooth conectado al microcontrolador.
// Importar la librería para el módulo Bluetooth
#include <SoftwareSerial.h>
SoftwareSerial BTSerial(10, 11); // RX, TX
void setup() {
Serial.begin(9600);
BTSerial.begin(9600);
}
void loop() {
if (BTSerial.available()) {
int valor = BTSerial.parseInt();
if (valor >= 0 && valor <= 255) {
// Aquí puedes utilizar el valor recibido como desees
analogWrite(9, valor); // Por ejemplo, controlar un LED con el valor del slider
}
}
}
Este código utiliza la librería SoftwareSerial para comunicarse con el módulo Bluetooth en los pines 10 y 11. Luego, lee el valor entero enviado desde la aplicación y lo utiliza para controlar un LED conectado al pin 9 (se puede ajustar esto según tu configuración).
Node-RED es una herramienta de código abierto para la programación visual que permite crear aplicaciones de Internet de las cosas (IoT).
Node-RED se ejecuta en el navegador web y utiliza una programación visual que le permite conectar bloques de código, conocidos como nodos, para realizar una tarea. Los nodos cuando se conectan entre sí se denominan flujos.
Características:
Es accesible a una gama más amplia de usuarios.
Permite ahorrar tiempo, pues no se escribe código (… ¿Tu qué opinas?)
Es código abierto y desarrollado por IBM,
Raspberry Pi puede ejecutar Node-RED,
¿Qué se puede hacer con Node RED?
Node-RED permite:
Acceder a los GPIO;
Establecer una conexión MQTT con otros dispositivos (Usando Arduino IDE, ESP8266, ESP32, etc.);
Cree una interfaz gráfica de usuario receptiva para sus proyectos;
Comunicarse con servicios de terceros (IFTTT.com, Adafruit.io, ThingSpeak, Home Assistant, InfluxDB etc);
Recuperar datos de la web (pronóstico del clima, precios de acciones, correos electrónicos, etc.);
Preguntará si se quiere instalar Node Red, luego preguntará: “Would you like to install Pi-specific nodes?” Presionar Y, luego Enter.
Tomará unos minutos instalar Node-RED. Al final, debería recibir un mensaje similar en la ventana de Terminal:
Configurar Node-RED Settings
Después de la instalación, se recomienda configurar las opciones y configuraciones iniciales.
Ejecución del siguiente comando:
node-red admin init
Press Enter to create a Node-RED Settings file on /home/pi/.node-red/settings.js
Do you want to set up user security? Yes.
Enter a username -> Luego presionar Enter (admin).
Enter a password -> Luego presionar Enter (adminadmin).
Luego, debe definir los permisos de usuario. Configuraremos el acceso completo, nos aseguraremos de que la opción de acceso completo esté resaltada en azul y presione Enter.
Se pueden agregar otros usuarios con diferentes permisos. Solo se creará un usuario por ahora. Se puden agregar otros usuarios más luego.
Do you want to enable the Projects feature? No.
Enter a name for your flows file. (Presionar Enter para seleccionar el nombre por defecto flows.json).
Provide a passphrase to encrypt your credentials file. (huecat) Aprende más sobre qué es una passphrase.
Select a theme for the editor. Presionar Enter para seleccionar por default.
Press Enter again to select the default text editor.
Allow Function nodes to load external modules? Yes.
La configuración de Node-RED fue exitosa. Todos los ajustes se guardan en settings.js.
Iniciar Node-RED
Correr el siguiente comando para iniciar Node-RED:
node-red-start
Debería verse algo así en la Terminal:
Auto-Inicio / Autostart Node-RED
Para ejecutar Node-RED automáticamente cuando se inicia el Pi, debe ingresar el siguiente comando. Esto significa que mientras su Raspberry Pi esté encendida, Node-RED estará funcionando.
sudo systemctl enable nodered.service
Ahora, reinicie su Pi para que el inicio automático surta efecto. La próxima vez que se reinicie la Raspberry Pi, Node-RED ya se estará ejecutando.
sudo reboot
If, later on, you want to disable autostart on boot, you can run:
sudo systemctl disable nodered.service
Para obtener más información sobre el proceso de instalación, consulte la official documentation.
Access Node-RED
Node-RED se ejecuta en el puerto 1880. Para acceder a Node-RED, abra un navegador y escriba la dirección IP de Raspberry Pi seguida de: 1880. Por ejemplo:
192.168.1.102:1880
Para obtener su dirección IP de Raspberry Pi, puede ejecutar el siguiente comando:
hostname -I
Después de ingresar la dirección IP de Raspberry Pi seguida de: 1880 en el navegador web, obtendrá acceso a la página de inicio de sesión de Node-RED. Inicie sesión con el nombre de usuario y la contraseña que configuró anteriormente.
Ya se tiene el acceso a Node-RED. Ahora se puede comenzar a construir sus flujos.
Descripción General Node-RED
Echemos un vistazo a la interfaz visual de Node-RED.
Secciones principales de la interfaz Node-RED
La siguiente imagen muestra las secciones principales de Node-RED etiquetadas.
Nodes / Nodos
En la barra lateral izquierda, puede ver una lista con un montón de bloques. Estos bloques se denominan nodos y están separados por su funcionalidad. Si se selecciona un nodo, se puede ver cómo funciona en la pestaña de documentación de los nodos.
Los nodos tienen puertos de entrada y/o salida para recibir y enviar información a otros nodos. Por ejemplo, un nodo recibe una entrada de un nodo anterior, procesa esa información y envía un mensaje diferente a otro nodo que hará algo con esa información. La información que se pasa entre los nodos se denomina mensaje.
Flow
Los nodos son los componentes básicos de un flujo. Conecta los nodos para crear un flujo que realizará una determinada tarea. Un Flujo también es una pestaña en el espacio de trabajo donde coloca y organiza los nodos.
En el centro, tienes el Flujo y aquí es donde colocas los nodos.
Barra lateral derecha
La barra lateral a la derecha tiene varias herramientas.
Información: muestra información sobre los flujos;
Ayuda: muestra la documentación de los nodos;
Debug/Depurar: el icono de error abre una ventana de depuración que muestra los mensajes pasados a los nodos de depuración; es útil para fines de depuración;
Config nodes/Nodos de configuración: el icono de engranaje muestra información sobre los nodos de configuración. Los nodos de configuración no aparecen en el espacio de trabajo principal y son nodos especiales que contienen configuraciones reutilizables que pueden compartir varios nodos en un flujo.
Implementación
El botón de implementación guarda todos los cambios realizados en el flujo y comienza a ejecutar el flujo.
Creando un flujo simple
Para que se acostumbre a la interfaz de Node-RED, creemos un flujo simple. El flujo que crearemos, simplemente imprime un mensaje en la consola de depuración, cuando se activa.
Arrastre un nodo de inyección y un nodo de depuración a su flujo y conéctelos.
Ahora, editemos el nodo de inyección. Haga doble clic en el nodo. En la figura a continuación, puede ver las diferentes configuraciones que puede cambiar.
En el campo msg.payload , seleccione una cadena y escriba Hola. Luego, haz clic en Listo.
Messages (msg) in Node-RED are javascript objects that can have multiple properties. The payload is the default property most nodes work with. You can think of it as the main content of the message you want to send to the next node. In our case, we’re simply sending a text message.
We won’t edit the debug node, but you can double-click on it to check its properties.
////////////////////////////////////////////////////////// HASTA ACA
You can select the output of the debug node, which is msg.payload and where we want to send that output. In our case, we want to send it to the debug window.
To save your application, you need to click the Deploy button in the top right corner.
Your application is saved.
Testing the flow
Let’s test our simple flow. Open the debug window and click the inject node to trigger the flow.
As you can see, our message is printed in the debug window when you trigger the inject node. This is a very basic example and it doesn’t do anything useful. However, the purpose of this post is to get you familiar with the Node-RED interface. In no time, you’ll start creating your own flows.
Exporting and Importing Nodes
In this section, you’ll learn how to save your nodes. This is useful if you need to:
Backup your Node-RED flow
Move your flow to another Raspberry Pi (or machine)
Share your Node-RED project with others
Open the main menu, and select the Export option.
A new window opens. You can select if you want to save the selected nodes, the current flow, or all flows. You can also download the nodes as a JSON file or copy the JSON to the clipboard.
To show you how it works, click on Download for the selected nodes. It will download a JSON file called flows.json.
You can import those nodes later to another Raspberry Pi or another machine with Node-RED installed, by going to the main menu and selecting the Import option.
On the Import nodes window, you can upload a JSON file or paste raw JSON.
Installing Pallete Nodes
As we’ve seen previously, Node-RED comes with a bunch of pre-installed nodes on the Pallete (left sidebar). There are many more nodes available that you can install and use for your projects. You can find them in the Node-RED library. If you need some specific task for your project, there’s probably already a node for that.
For example, if you need to add the feature to send an email to your flow, you can google something like this: “send email node-red node”. One of the first search results is this page with the node-red-node-email. It comes with some nodes to send and receive emails.
If you want to install those nodes (or any other nodes) so that you can use them on your flow, go to the main menu and select the option Manage palette.
The following window will open. Select the install tab and search for the nodes you want to install, for example, node-red-node-email.
Node-RED Dashboard
Node-RED Dashboard is a module that provides a set of nodes in Node-RED to quickly create a live data dashboard. You can install those nodes using the Menu > Manage Palette. Then, search for node-red-dashboard and install it.
After installing, the dashboard nodes will show up on the palette.
Nodes from the dashboard section provide widgets that show up in your application user interface (UI). The user interface is accessible on the following URL:
Utilización de Node-RED para controlar las entradas/salidas del ESP8266/ESP32 y mostrar los datos de sensores en su interfaz.
El software Node-RED se ejecuta en una Raspberry Pi y la comunicación entre el ESP8266 y el software Node-RED se realiza a través del protocolo de comunicación MQTT.
La comunicación entre Arduino IDE y Node-RED a través del protocolo MQTT permite intercambiar datos y comandos entre un dispositivo basado en ESP8266 o ESP32 (programado con Arduino IDE) y un servidor Node-RED que se ejecuta en otra máquina, como una Raspberry Pi.
Preparación del entorno:
Asegurarse que Node-RED esté instalado y en funcionamiento en la máquina que actuará como servidor.
Configurar un servidor MQTT y verifica que esté en funcionamiento en la misma máquina que Node-RED.
Conecta tu ESP8266 o ESP32 a la red Wi-Fi para que pueda acceder al servidor MQTT.
Uso de la librería PubSubClient en Arduino IDE:
En Arduino IDE, instalar la librería PubSubClient para facilitar la comunicación MQTT.
Configura tu dispositivo ESP8266 o ESP32 para conectarse a la red Wi-Fi y establecer una conexión con el servidor MQTT utilizando la dirección IP y el puerto correspondientes.
Envío* de mensajes MQTT desde Arduino IDE:
Una vez establecida la conexión MQTT, utilizar la función client.publish() para enviar mensajes al servidor Node-RED.
Define un “topic” específico para cada tipo de mensaje que desees enviar. Esto permitirá que el servidor Node-RED identifique y procese la información adecuadamente.
Opcional: Recepción de mensajes MQTT en Arduino IDE*:
Para recibir mensajes del servidor Node-RED, puedes utilizar la función client.subscribe() para suscribirte a ciertos “topics” MQTT desde tu código de Arduino. De esta manera, tu dispositivo puede recibir comandos o información desde el servidor.
Configuración de Node-RED:
En Node-RED, configurar el nodo MQTT para que se conecte al servidor MQTT que está en funcionamiento en la Raspberry Pi u otra máquina.
Utiliza el nodo MQTT para escuchar los “topics” a los que tu ESP8266/ESP32 está publicando y/o suscrito.
Procesamiento de mensajes en Node-RED:
Una vez que Node-RED reciba los mensajes de un dispositivo ESP8266/ESP32, puedes procesarlos utilizando diferentes nodos para la lógica y la visualización. Esto te permitirá realizar acciones o presentar los datos recibidos según tus necesidades.
FreeRTOS (Free Real-Time Operating System) es un sistema operativo de tiempo real de código abierto diseñado para sistemas embebidos y aplicaciones en tiempo real. Un sistema operativo es un software que administra los recursos del hardware y proporciona una interfaz para que las aplicaciones se ejecuten en un dispositivo, como un microcontrolador o microprocesador.
En el contexto de los microcontroladores, como el ESP32, los sistemas operativos en tiempo real (RTOS) como FreeRTOS son útiles para administrar tareas concurrentes que deben ejecutarse de manera independiente y en un orden específico. Esto permite que las tareas se ejecuten en paralelo y que el sistema pueda responder rápidamente a eventos en tiempo real.
Las tareas son como pequeños programas que se ejecutan de forma independiente y tienen su propia parte de la memoria (pila) para almacenar datos locales y trabajar en una tarea específica. Un RTOS permite que las tareas compartan el tiempo de ejecución del procesador, lo que permite una mejor utilización de los recursos del sistema.
En FreeRTOS, xTaskCreatePinnedToCore es una función utilizada para crear tareas que se ejecutarán en un núcleo de procesador específico en sistemas multi-núcleo, como el ESP32.
Se utiliza FreeRTOS para crear dos tareas: parpadearLedNucleo0 y parpadearLedNucleo1. Cada tarea controla un LED y los hace parpadear con diferentes intervalos de tiempo. Al usar FreeRTOS, estas tareas se pueden ejecutar en núcleos diferentes del ESP32, lo que permite que las tareas de parpadeo se realicen en paralelo sin bloquear la ejecución del programa principal.
FreeRTOS también proporciona mecanismos para sincronización y comunicación entre tareas, lo que permite que las tareas se comuniquen y cooperen en la resolución de problemas complejos.
const int ledPinNucleo0 = 2;
const int ledPinNucleo1 = 4;
void parpadearLedNucleo0(void *parameter) {
(void)parameter; // Ignorar el parámetro, ya que no lo usamos en este ejemplo
while (true) {
digitalWrite(ledPinNucleo0, HIGH);
Serial.println("LED Núcleo 0 encendido");
delay(500);
digitalWrite(ledPinNucleo0, LOW);
Serial.println("LED Núcleo 0 apagado");
delay(500);
}
}
void parpadearLedNucleo1(void *parameter) {
(void)parameter; // Ignorar el parámetro, ya que no lo usamos en este ejemplo
while (true) {
digitalWrite(ledPinNucleo1, HIGH);
Serial.println("LED Núcleo 1 encendido");
delay(300);
digitalWrite(ledPinNucleo1, LOW);
Serial.println("LED Núcleo 1 apagado");
delay(300);
}
}
void setup() {
Serial.begin(115200);
pinMode(ledPinNucleo0, OUTPUT);
pinMode(ledPinNucleo1, OUTPUT);
xTaskCreatePinnedToCore(parpadearLedNucleo0, "Nucleo 0 LED", 10000, NULL, 1, NULL, 0);
xTaskCreatePinnedToCore(parpadearLedNucleo1, "Nucleo 1 LED", 10000, NULL, 1, NULL, 1);
}
void loop() {
// Nada que hacer en loop, ya que las tareas se encargan del parpadeo de los LEDs
}
Con estos cambios, se mostrarán mensajes en el monitor serie cada vez que los LEDs cambien de estado, lo que te permitirá verificar el funcionamiento correcto del código y seguir el comportamiento de los LEDs. Recuerda que necesitarás abrir el Monitor Serie en el IDE de Arduino para ver los mensajes que se imprimen.
Concepto: Se enviarán mensajes vía comandos AT desde el microcontrolador a programar hacia el SIM900. Mediante estos comandos se podrán solicitar y enviar SMS, llamados telefónicos y conectarse a Internet para obtener un proyecto IoT autónomo en cualquier parte del mundo.
Pines del sensor táctil capacitivo ESP32 con Arduino IDE
Cómo utilizar los pines TOUCH del ESP32 con Arduino IDE. Los pines táctiles ESP32 pueden detectar variaciones en cualquier objeto que contenga una carga eléctrica. Muchas veces se utilizan para despertar el ESP32 del “deep sleep” o sueño profundo.
El ESP32 tiene 10 GPIO táctiles capacitivos. Estos GPIO pueden detectar variaciones en cualquier cosa que contenga carga eléctrica, como la piel humana. Así pueden detectar variaciones inducidas al tocar los GPIO con un dedo.
Estos pines se pueden integrar fácilmente en almohadillas capacitivas y reemplazar botones mecánicos. Además, los pines táctiles también se pueden utilizar como fuente de activación cuando el ESP32 está en sueño profundo.
Eche un vistazo a la distribución de pines de su placa para ubicar los 10 sensores táctiles diferentes: los pines sensibles al tacto están resaltados en color rosa.
Tener en cuenta que no todas las placas de desarrollo permiten acceder a todos los pines del ESP32.
tocarLeer()
Leer el sensor táctil es sencillo. En el IDE de Arduino, se utiliza la función touchRead(), que acepta como argumento el GPIO que desea leer.
touchRead(GPIO);
Prueba de Touch con ESP32 y ARDUINO IDE o Platformio con librería arduino.h:
// ESP32 Touch Test
// Just test touch pin - Touch0 is T0 which is on GPIO 4.
void setup() {
Serial.begin(115200);
delay(1000); // give me time to bring up serial monitor
Serial.println("ESP32 Touch Test");
}
void loop() {
Serial.println(touchRead(4)); // get value of Touch 0 pin = GPIO 4
delay(1000);
}
