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.

// Firmware Control Buck PID - v1.0 Release
#include <pwm.h>

const int PIN_SENSOR = A0;  // Entrada Divisor (Vout/2)
const int PIN_PWM = 9;      // Salida Gate Driver

// Constantes PID (L=100uH, C=33uF)
float Kp = 0.272253;
float Ti = 0.0015285;
float Ts = 20e-6;           // 50kHz Loop

// Variables PID
float u = 0.0, u_1 = 0.0;
float e = 0.0, e_1 = 0.0;
float q0, q1;
float Vref = 2.5;           // Target (2.5V leídos = 5.0V reales)

void setup() {
    // Coeficientes Tustin
    q0 = Kp * (1 + (Ts / (2 * Ti)));
    q1 = -Kp * (1 - (Ts / (2 * Ti)));
    
    // Configurar PWM Asíncrono
    InitTimersSafe();
    SetPinFrequencySafe(PIN_PWM, 50000); 
    pinMode(PIN_PWM, OUTPUT);
}

void loop() {
    // 1. Lectura ADC y Normalización
    float y_medida = analogRead(PIN_SENSOR) * (5.0 / 1023.0);
    
    // 2. PID Discreto
    e = Vref - y_medida;
    u = u_1 + q0 * e + q1 * e_1;
    
    // 3. Saturación y Anti-Windup (Crítico)
    if (u > 0.95) u = 0.95; 
    if (u < 0.00) u = 0.00;
    
    // 4. Actualización Estados
    u_1 = u;
    e_1 = e;
    
    // 5. Actuación
    pwmWrite(PIN_PWM, (int)(u * 255));
    
    // Estabilización de Ciclo
    delayMicroseconds(10);
}

The post Manual de Ingeniería: Buck Converter PID appeared first on HUE CAT INGENIERÍA ESPAÑA.

Sistema de luminarias UV (sanitización por Ultravioletas) y sistema automatizado para pulverización de producto ambientador para la Industria, controlado por IoT

Detalles: Conexión a base de datos MySQL, sensor de movimiento, sensor de nivel de líquido por ultrasonido (SR-04), conexión por WiFi, LCD1602

The post Electrónica para sistema de Sanitización controlado por ESP8266 y base de datos MySQL para gestión de consumibles 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.

Este proyecto implementa un sistema básico para medir la humedad del suelo mediante un microcontrolador, optimizando el consumo de energía de la sonda gracias a un pin de alimentación controlado por software. Está diseñado para facilitar la integración en entornos de bajo consumo o alimentados por baterías.

Ver repositorio en Github

Objetivo

Obtener lecturas confiables del nivel de humedad del suelo mientras se evita la corrosión y el consumo innecesario de corriente de la sonda, encendiéndola solo durante el tiempo mínimo necesario para la medición.

Estructura del proyecto

El código está organizado en tres partes principales:

1. Encabezado (moisture.h)

Define la interfaz de uso:

• moistureInit(): inicializa los pines para alimentar la sonda y leer la señal analógica.
• moistureSetWarmup(): permite configurar el tiempo de precalentamiento antes de la medición.
• moistureRead(): realiza la lectura del valor crudo del ADC.

2. Implementación (moisture.cpp)

Contiene la lógica de funcionamiento:

• Al inicializar, configura el pin de alimentación como salida y lo apaga por defecto.
• Durante la lectura, habilita la alimentación, espera el tiempo de calentamiento configurado (300 ms por defecto) y luego toma la muestra analógica.
• Apaga la alimentación inmediatamente después de la lectura para reducir la corrosión y el consumo.

3. Sketch principal (moisture1.ino)

Ejemplo de uso que inicializa el sensor con pines definidos, configura el precalentamiento si es necesario y lee los valores de humedad periódicamente, mostrando los resultados por el puerto serial.

Características destacadas

• Control programático de la alimentación de la sonda.
• Configuración flexible del tiempo de precalentamiento.
• Lectura directa del valor analógico en formato crudo (0–1023).
• Diseño modular para facilitar la reutilización en otros proyectos.

Aplicaciones

El sistema está pensado para proyectos de riego automático, monitoreo de jardines o cultivos, y cualquier implementación que requiera reducir el consumo y prolongar la vida útil de sondas de humedad

The post Sensor de humedad de suelo con control de alimentación (moisture-sensor-for-plants) appeared first on HUE CAT INGENIERÍA ESPAÑA.

El FINGERPRINT 071405 es un sensor óptico de huella digital compacto y fácil de integrar en proyectos de seguridad y acceso biométrico. Ofrece detección rápida y un alto nivel de precisión, lo que lo convierte en una opción recomendada para cerraduras inteligentes, control de asistencia y aplicaciones IoT.

Principio de funcionamiento

1. Captura óptica: Una pequeña cámara CMOS interna ilumina el dedo con un LED infrarrojo y toma una imagen de la huella.
2. Procesado interno: El propio módulo extrae los “minucias” (optimiza las crestas y valles) y genera un template digital.
3. Comparación: El microcontrolador puede enviar patrones de huella almacenados para comprobación o pedir al sensor que registre un nuevo usuario.

Especificaciones técnicas

• Resolución: 500 dpi
• Interface: UART TTL (3,3 V lógico)
• Voltaje de alimentación: 3,6 V – 6 V
• Corriente en reposo: ≈ 40 mA
• Corriente en captura: ≈ 60 mA
• Tiempo de verificación: < 1 s
• Plantillas almacenables: hasta 2 000
• Dimensiones: 35 × 20 × 16 mm

Conexión al microcontrolador

1. Alimentación: VIN a 5 V, GND a masa.
2. Datos:
   • TX del sensor → RX del microcontrolador
   • RX del sensor → TX del microcontrolador
3. Nivel lógico: Si se trabaja a 3,3 V, asegurar que VIN sea ≥ 3,6 V y usar un conversor de nivel para la señal RX.

[Sensor] [Microcontrolador]
VIN ──► 5 V
GND ──► GND
TX ──► RX (UART)
RX ──► TX (UART)*

• con conversor de nivel si MCU opera a 3,3 V

Uso con librería Adafruit

Se recomienda la biblioteca Adafruit Fingerprint para gestionar enrolamiento y verificación de forma sencilla:

#include <Adafruit_Fingerprint.h>
#include <HardwareSerial.h>

// Usar Serial1 para ESP32, Serial para otros microcontroladores
HardwareSerial uart(1);
Adafruit_Fingerprint sensor(&uart);

void setup() {
  uart.begin(57600, SERIAL_8N1, RX_PIN, TX_PIN);
  sensor.begin(57600);
  if (sensor.verifyPassword()) {
    Serial.println("Sensor listo");
  } else {
    Serial.println("Error de comunicación");
    while (1);
  }
}

uint8_t getFingerprintID() {
  if (sensor.getImage() != FINGERPRINT_OK) return FINGERPRINT_NOFINGER;
  sensor.image2Tz();
  return sensor.fingerFastSearch();
}

void loop() {
  uint8_t id = getFingerprintID();
  if (id == FINGERPRINT_NOFINGER) return;
  if (id == FINGERPRINT_OK) {
    Serial.print("Huella reconocida con ID: ");
    Serial.println(sensor.fingerID);
  } else {
    Serial.println("Huella no reconocida");
  }
  delay(1000);
}

Aplicaciones comunes

• Control de acceso en cerraduras electrónicas
• Registro de asistencia en oficinas o aulas
• Autenticación en dispositivos IoT
• Seguridad en proyectos de domótica y automatización

Ventajas de el modelo:

• Rápido y fiable: verificación en menos de 1 s.
• Alto almacenamiento: hasta 2 000 plantillas.
• Fácil integración: comunicación por puerto serie TTL.
• Robustez: carcasa de resina protege el sensor óptico.

Para maximizar la fiabilidad, se aconseja limpiar periódicamente la superficie y evitar la exposición directa a la luz solar intensa.

The post SENSOR FINGERPRINT 071405 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.

Estamos en busca de componentes que ofrezcan la mejor calidad y precisión para proyectos de electrónica y sistemas embebidos.

Características del SHT31

El sensor SHT31, desarrollado por Sensirion, es conocido por su alta precisión y fiabilidad en la medición de temperatura y humedad. Sus principales características incluyen:

• Alta Precisión: Con una precisión de ±2% RH para la humedad y ±0.3°C para la temperatura, garantiza datos exactos para aplicaciones críticas.
• Interfaz I2C: Facilita la integración con diversos microcontroladores y plataformas de desarrollo como Arduino y Raspberry Pi.
• Rápida Respuesta: Su diseño avanzado permite obtener lecturas en tiempo real, ideal para sistemas de monitoreo continuo.
• Compensación de Calor: Mejora la precisión en ambientes con fluctuaciones térmicas, asegurando mediciones consistentes.

Aplicaciones del SHT31

El SHT31 es versátil y se adapta a diversas aplicaciones, tales como:

• Sistemas HVAC: Optimiza el control de climatización en edificios inteligentes.
• Estaciones Meteorológicas: Proporciona datos precisos para el análisis del clima.
• Agricultura de Precisión: Monitoriza las condiciones ambientales en invernaderos y cultivos.
• Dispositivos IoT: Integra fácilmente en soluciones de hogar inteligente y monitoreo ambiental.

Integración Sencilla

Se valora la facilidad de uso y la versatilidad. El SHT31 se conecta mediante una interfaz I2C, simplificando su uso con cualquier microcontrolador compatible.

Código para compilar en IDE Platformio

#include <Wire.h>
#include <Adafruit_SHT31.h>
#include <FS.h>
#include <SD_MMC.h>

Adafruit_SHT31 sht31 = Adafruit_SHT31();

void setup() {
  Serial.begin(115200);
  while (!Serial) delay(10);  // wait for serial port to open
  
  if (!sht31.begin(0x44)) {   // Set to 0x45 for alternate i2c addr
    Serial.println("Couldn't find SHT31");
    while (1) delay(1);
  }

  if (!SD_MMC.begin("/sdcard", true)) {
    Serial.println("SD Card Mount Failed");
    return;
  }

  uint8_t cardType = SD_MMC.cardType();
  if (cardType == CARD_NONE) {
    Serial.println("No SD card attached");
    return;
  }

  Serial.println("SD Card initialized.");
}

void loop() {
  float t = sht31.readTemperature();
  float h = sht31.readHumidity();
  
  if (!isnan(t)) {  // check if 'is not a number'
    Serial.print("Temp *C = "); Serial.println(t);
  } else {
    Serial.println("Failed to read temperature");
  }

  if (!isnan(h)) {  // check if 'is not a number'
    Serial.print("Hum. % = "); Serial.println(h);
  } else {
    Serial.println("Failed to read humidity");
  }

  // Open the file in write mode
  File dataFile = SD_MMC.open("/sdcard/data.txt", FILE_APPEND);

  // If the file opened successfully, write the temperature and humidity
  if (dataFile) {
    dataFile.print("Millis: ");
    dataFile.print(millis());
    dataFile.print(", Temp: ");
    dataFile.print(t);
    dataFile.print(" *C, Humidity: ");
    dataFile.print(h);
    dataFile.println(" %");
    dataFile.close();
    Serial.println("Data written to file");
  } else {
    // If the file didn't open, print an error
    Serial.println("Error opening data.txt");
  }

  // Wait for 2 seconds before reading again
  delay(2000);
}

The post Sensor de Temperatura y Humedad SHT31: Precisión y Fiabilidad en tus Proyectos 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.