la PCB se ha optimizado para reducir el ruido electromagnético en un entorno de maquinaria compacta. Se han integrado etapas de filtrado por hardware para las señales de los sensores ópticos y se ha priorizado una topología de alimentación con conversores DC-DC de alta eficiencia, minimizando la disipación térmica dentro de la carcasa. El resultado es un sistema embebido que no solo cumple con la velocidad de la mecánica, sino que extiende la vida útil del equipo al operar con márgenes de seguridad sobredimensionados.

Lista de materiales

El objetivo aquí es demostrar que no compras «lo más barato», sino lo que garantiza calidad industrial.

1. MCU: Módulo Espressif ESP32-WROOM-32E (Versión industrial con rango de temperatura extendido -40°C a +85°C).
2. Sensores Ópticos: Barreras fotoeléctricas Omron EE-SX671 (Conmutación de alta velocidad, 1kHz min) con conectores de bloqueo para evitar desconexiones por vibración.
3. Gestión de Energía: Convertidor Buck Texas Instruments serie LM2596 (Original) o módulo Traco Power, sustituyendo reguladores lineales LDO para una eficiencia >90% y cero calentamiento.
4. Conectividad: Borneras de conexión Phoenix Contact serie MKDS (contactos de aleación de cobre, no latón) para asegurar la integridad de la señal de los sensores externos.
5. Protección: Fusible rearmable (PTC) y diodo TVS en la entrada de alimentación para protección contra transitorios y polaridad inversa.

Ejemplo de programación

/*
 * FIRMWARE: Máquina Contadora de Tarjetas
 * PLATAFORMA: ESP32
 * AUTOR: [Tu Nombre/Firma]
 * DESCRIPCION: Sistema de conteo por interrupciones con filtrado digital
 * para entornos industriales ruidosos.
 */

#include <Arduino.h>

// --- PIN DEFINITIONS & CONSTANTS ---
const uint8_t PIN_SENSOR_IRQ = 18;  // Pin compatible con interrupciones
const uint8_t PIN_STATUS_LED = 2;   // LED Integrado para heartbeat
const uint32_t DEBOUNCE_US   = 500; // Tiempo muerto en microsegundos (ajustable según velocidad máquina)

// --- VOLATILE VARIABLES (ISR Context) ---
// 'volatile' es crucial para variables modificadas dentro de una interrupción
volatile uint32_t totalCardCount = 0;
volatile uint32_t lastInterruptTime = 0;
volatile bool newCardDetected = false;

// --- INTERRUPT SERVICE ROUTINE (ISR) ---
// IRAM_ATTR coloca la función en la RAM para máxima velocidad de ejecución
void IRAM_ATTR isr_CardSensor() {
    uint32_t currentTime = micros();
    
    // Filtrado de rebotes (Debounce) simple pero efectivo basado en tiempo
    if ((currentTime - lastInterruptTime) > DEBOUNCE_US) {
        totalCardCount++;
        lastInterruptTime = currentTime;
        newCardDetected = true; // Flag para que el loop principal procese la UI/Log
    }
}

// --- SETUP ---
void setup() {
    Serial.begin(115200);
    
    // Configuración de pines
    pinMode(PIN_STATUS_LED, OUTPUT);
    // INPUT_PULLUP asegura un estado lógico estable si el sensor es Open Collector
    pinMode(PIN_SENSOR_IRQ, INPUT_PULLUP);

    // Adjuntar interrupción al flanco de caída (FALLING) o subida (RISING) según el sensor
    attachInterrupt(digitalPinToInterrupt(PIN_SENSOR_IRQ), isr_CardSensor, FALLING);

    Serial.println("--- SISTEMA INICIADO: MODO ALTA VELOCIDAD ---");
}

// --- MAIN LOOP ---
void loop() {
    // 1. GESTIÓN DE EVENTOS CRÍTICOS (Sin bloquear el procesador)
    if (newCardDetected) {
        // Sección crítica: deshabilitar interrupciones momentáneamente para leer variables compartidas
        portENTER_CRITICAL_ISR(&mux); 
        uint32_t safeCount = totalCardCount;
        newCardDetected = false;
        portEXIT_CRITICAL_ISR(&mux);

        // Procesamiento de datos (Log, Display, Serial) fuera de la ISR
        Serial.printf("TARJETA DETECTADA | Total: %u | Tiempo: %lu us\n", safeCount, micros());
    }

    // 2. TAREAS SECUNDARIAS (Heartbeat, chequeo de errores, WiFi, etc.)
    static uint32_t lastBlink = 0;
    if (millis() - lastBlink > 1000) {
        lastBlink = millis();
        digitalWrite(PIN_STATUS_LED, !digitalRead(PIN_STATUS_LED)); // Heartbeat visual
    }
}

The post Circuito: Programación de PCB de serie de máquinas Máquina Contadora de Tarjetas fabricadas en España appeared first on HUE CAT INGENIERÍA ESPAÑA.

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:

1. 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.
2. 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?

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.

The post Sistema de gestión de batería avanzado Analogico + SBS appeared first on HUE CAT INGENIERÍA ESPAÑA.

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.

The post Proyecto de Reproducción de MP3 con ESP32 y DFPlayer Mini appeared first on HUE CAT INGENIERÍA ESPAÑA.

Muy últil en muchos proyectos con ESP32, por su simplicidad respecto al BLE.

https://github.com/huecat/Conectar-ESP32-por-Wifi-Sin-Router

Servidor:

#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);
}

The post Conectar dos ESP32 por Wi-Fi (Sin router de por medio) appeared first on HUE CAT INGENIERÍA ESPAÑA.

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.

1. 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.
2. Manejar la Conexión y Desconexión:
   • Implementar lógica para gestionar la conexión y desconexión con el dispositivo Bluetooth.
3. 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):

1. Preparar todo para poder configurar el ESP32 con Arduino IDE.
   • Si aún no has configurado el Arduino IDE para tu ESP32, puedes seguir estos pasos: Configurar el ESP32 con Arduino IDE
2. Programar la Lógica del Arduino Controlar 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).

The post Controlar un ESP32 (o esp8266) con Android utilizando AppInventor2 appeared first on HUE CAT INGENIERÍA ESPAÑA.

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.);
• Crear eventos activados por tiempo;
• Almacenar y recuperar datos de una base de datos.

Instalando Node RED en Raspberry Pi

bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)

Link Oficial: Running on Raspberry Pi : Node-RED (nodered.org)

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:

http://Your_RPi_IP_address:1880/ui

For example, in my case:

http://192.168.1.106:1880/ui

The post Node-RED en Raspberry Pi appeared first on HUE CAT INGENIERÍA ESPAÑA.

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.

Se programará el ESP32 usando Arduino IDE

Requisitos:

Primeros pasos con NodeRed y Raspberry Pi

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.

1. 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.
2. 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.
3. 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.
4. 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.
5. 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.
6. 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.
7. Prueba y Depuración.

The post ESP32 y Node-RED + MQTT (Publicar/Subscribir o Susbribir) appeared first on HUE CAT INGENIERÍA ESPAÑA.

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.

The post Utilizar ambos núcleos de un ESP32 appeared first on HUE CAT INGENIERÍA ESPAÑA.

Preparación: Conectar el módulo SIM900 al microcontrolador y comprobar que se puedan enviar comandos AT.

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.

The post Conectar placa SIM900 y Arduino Uno, Nano, ESP8266, ESP32, (…etc) appeared first on HUE CAT INGENIERÍA ESPAÑA.

En el procedimiento, cada ciclo fue programado como una «Máquina de Estados Finitos»

La lista de Hardware de este proyecto es:

-ESP32

-Sensores digitales/fotocélulas

-LCD 1602 con módulo I2C

-Botonera de 4 salidas simple

-Salidas con relay

The post Circuito, Programación, Fabricación de PCB de Máquina Contadora de Tarjetas. appeared first on HUE CAT INGENIERÍA ESPAÑA.