Sistema de detección de fuga de gas y cerrado de valvula de paso usando comunicación espnow con dos esp32 y mq-2

Aquí tienes un esquema básico para tu práctica utilizando dos ESP32, uno maestro y otro esclavo, con un sensor de gas MQ2, un buzzer, LEDs, y control de una válvula con un servo motor, usando ESP-NOW para la comunicación entre los dos ESP32:

ESP32 Maestro (Detección de fuga de gas)

Componentes:

• Sensor MQ2 (Gas)
• LED de medición (indica cuando está midiendo)
• LED de alerta (indica fuga de gas)
• Buzzer
• ESP32 (Maestro)

Conexiones:

1. Sensor MQ2:
   • VCC: 3.3V del ESP32
   • GND: GND del ESP32
   • AO (Salida analógica de gas): Pin analógico del ESP32 (ejemplo: A0)
2. LED de medición:
   • Anodo (positivo): Pin GPIO del ESP32 (ejemplo: GPIO 12)
   • Cátodo (negativo): GND a través de una resistencia de 220Ω
3. LED de alerta:
   • Anodo: Pin GPIO del ESP32 (ejemplo: GPIO 13)
   • Cátodo: GND a través de una resistencia de 220Ω
4. Buzzer:
   • Pin de control del buzzer: GPIO (ejemplo: GPIO 14)
   • GND: Conectado a GND del ESP32

Código para ESP32 Maestro:

#include <esp_now.h>
#include <WiFi.h>

// Pines de los LEDs y buzzer
#define LED_MEDICION 12
#define LED_ALERTA 13
#define BUZZER 14
#define MQ2_PIN A0  // Pin analógico del MQ2

// Estructura de datos para enviar al esclavo
typedef struct struct_message {
    bool fuga_gas;
} struct_message;

struct_message mensaje;

// Dirección MAC del ESP32 esclavo
uint8_t broadcastAddress[] = {0x24, 0x6F, 0x28, 0xAB, 0xCD, 0xEF}; // Reemplazar con la dirección MAC del ESP32 esclavo

void setup() {
  Serial.begin(115200);
  pinMode(LED_MEDICION, OUTPUT);
  pinMode(LED_ALERTA, OUTPUT);
  pinMode(BUZZER, OUTPUT);

  WiFi.mode(WIFI_STA);
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error al inicializar ESP-NOW");
    return;
  }

  esp_now_peer_info_t peerInfo;
  memcpy(peerInfo.peer_addr, broadcastAddress, 6);
  peerInfo.channel = 0;  
  peerInfo.encrypt = false;

  if (esp_now_add_peer(&peerInfo) != ESP_OK) {
    Serial.println("Error al agregar el peer");
    return;
  }
}

void loop() {
  int gasValue = analogRead(MQ2_PIN);  // Leer el sensor MQ2

  digitalWrite(LED_MEDICION, HIGH);  // Indica que se está midiendo

  if (gasValue > 600) {  // Umbral para detección de gas
    digitalWrite(LED_ALERTA, HIGH);
    digitalWrite(BUZZER, HIGH);
    mensaje.fuga_gas = true;
  } else {
    digitalWrite(LED_ALERTA, LOW);
    digitalWrite(BUZZER, LOW);
    mensaje.fuga_gas = false;
  }

  // Enviar el mensaje al ESP32 esclavo
  esp_now_send(broadcastAddress, (uint8_t *) &mensaje, sizeof(mensaje));
  
  delay(1000);  // Medir cada segundo
  digitalWrite(LED_MEDICION, LOW);  // Apaga el LED de medición entre lecturas
}

ESP32 Esclavo (Control de válvula de gas)

Componentes:

• Servo motor para cerrar la válvula de gas
• Botón para control manual
• ESP32 (Esclavo)
• Servomotor

Conexiones:

1. Servo motor:
   • VCC: 5V del ESP32 (o fuente externa)
   • GND: GND del ESP32
   • Control: GPIO del ESP32 (ejemplo: GPIO 15)
2. Botón manual:
   • Un pin a GND
   • Otro pin a un GPIO del ESP32 (ejemplo: GPIO 16) con una resistencia de pull-up

Código para ESP32 Esclavo:

#include <esp_now.h>

#include <WiFi.h>

#include <ESP32Servo.h>

// Pines

#define SERVO_PIN 15

#define BOTON_PIN 16

#define LED_IN 2

Servo servoMotor;

bool valvulaCerrada = false;

typedef struct struct_message {

    bool fuga_gas;

} struct_message;

struct_message mensaje;

// Función de recepción de ESP-NOW

void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {

  memcpy(&mensaje, incomingData, sizeof(mensaje));

  if (mensaje.fuga_gas) {

    cerrarValvula();

  }

}

void setup() {

  Serial.begin(115200);

  pinMode(BOTON_PIN, INPUT_PULLUP);

  pinMode(LED_IN, OUTPUT);

  servoMotor.attach(SERVO_PIN);

  abrirValvula();  // Inicialmente, la válvula está abierta

  WiFi.mode(WIFI_STA);

  if (esp_now_init() != ESP_OK) {

    Serial.println("Error al inicializar ESP-NOW");

    return;

  }

  //esp_now_register_recv_cb(OnDataRecv);

    esp_now_register_recv_cb(esp_now_recv_cb_t(OnDataRecv));

}

void loop() {

  // Control manual con el botón

  if (digitalRead(BOTON_PIN) == LOW) {

    if (valvulaCerrada) {

      abrirValvula();

      digitalWrite(LED_IN,LOW);

    } else {

      cerrarValvula();

      digitalWrite(LED_IN,HIGH);

    }

    delay(500);  // Pequeño retraso para evitar rebotes del botón

  }

}

void cerrarValvula() {

  servoMotor.write(0);  // Ajusta el ángulo para cerrar la válvula

  valvulaCerrada = true;

  Serial.println("Válvula cerrada");

}

void abrirValvula() {

  servoMotor.write(90);  // Ajusta el ángulo para abrir la válvula

  valvulaCerrada = false;

  Serial.println("Válvula abierta");

}

Explicación:

• El ESP32 maestro está leyendo los valores del sensor MQ2. Si detecta una fuga de gas (por encima de un umbral), enciende el buzzer, el LED de alerta y envía un mensaje al ESP32 esclavo mediante ESP-NOW.
• El ESP32 esclavo recibe la señal y mueve el servo para cerrar la válvula de gas. También tiene un botón que permite abrir o cerrar la válvula manualmente.

Esto debería darte una base para comenzar tu proyecto. Puedes ajustar el código según tus necesidades y el hardware disponible.