IQ2

Códigos ESP32


   
//Código abierto


#include "esp_camera.h"
#include <WiFi.h>

//  Cambia por el nombre y contraseña de tu red WiFi
const char* ssid = "------";
const char* password = "------";

// 🔧 Pines para la cámara OV2640 en ESP32-WROVER (Freenove)
#define PWDN_GPIO_NUM     -1
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM     21
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27

#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       19
#define Y4_GPIO_NUM       18
#define Y3_GPIO_NUM       5
#define Y2_GPIO_NUM       4
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22

WiFiServer server(80);

void startCameraServer() {
  server.begin();
  Serial.println("Servidor web iniciado");
}

void setup() {
  Serial.begin(115200);
  delay(1000);

  //  Configuración de cámara
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer   = LEDC_TIMER_0;
  config.pin_d0       = Y2_GPIO_NUM;
  config.pin_d1       = Y3_GPIO_NUM;
  config.pin_d2       = Y4_GPIO_NUM;
  config.pin_d3       = Y5_GPIO_NUM;
  config.pin_d4       = Y6_GPIO_NUM;
  config.pin_d5       = Y7_GPIO_NUM;
  config.pin_d6       = Y8_GPIO_NUM;
  config.pin_d7       = Y9_GPIO_NUM;
  config.pin_xclk     = XCLK_GPIO_NUM;
  config.pin_pclk     = PCLK_GPIO_NUM;
  config.pin_vsync    = VSYNC_GPIO_NUM;
  config.pin_href     = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn     = PWDN_GPIO_NUM;
  config.pin_reset    = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;

  // 🔍 Frame size
  config.frame_size = FRAMESIZE_QVGA; // Puedes usar FRAMESIZE_VGA, FRAMESIZE_SVGA, etc.
  config.jpeg_quality = 10;
  config.fb_count = 1;

  //  Inicializar cámara
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Error inicializando la cámara: 0x%x", err);
    return;
  }

  // 🌐 Conectar WiFi
  WiFi.begin(ssid, password);
  Serial.print("Conectando a WiFi...");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi conectado");
  Serial.print("Dirección IP local: ");
  Serial.println(WiFi.localIP());

  startCameraServer();
}

void loop() {
  WiFiClient client = server.available();
  if (!client) return;

  // Esperar petición
  while (!client.available()) delay(1);
  String req = client.readStringUntil('\r');
  client.readStringUntil('\n');

  if (req.indexOf("/stream") != -1) {
    Serial.println("Iniciando stream...");
    client.println("HTTP/1.1 200 OK");
    client.println("Content-Type: multipart/x-mixed-replace; boundary=frame");
    client.println();

    while (client.connected()) {
      camera_fb_t *fb = esp_camera_fb_get();
      if (!fb) {
        Serial.println("Error capturando imagen");
        break;
      }

      client.println("--frame");
      client.println("Content-Type: image/jpeg");
      client.printf("Content-Length: %u\n\n", fb->len);
      client.write(fb->buf, fb->len);
      client.println();
      esp_camera_fb_return(fb);
      delay(30);
    }

  } else {
    // Página HTML

    client.println("HTTP/1.1 200 OK");
    client.println("Content-Type: text/html\n");
    client.println("<!DOCTYPE html><html><head><meta charset='UTF-8'><meta name='viewport' content='width=device-width, initial-scale=1.0'>");
    client.println("<title>Webcam</title>");
    client.println("<style>");
    client.println("body{margin:0;background:#000;color:#f2f2f2;font-family:sans-serif;}header{text-align:center;padding:1rem;background:#111;}h1{margin:0;font-size:2rem;}main{display:flex;justify-content:center;gap:2rem;flex-wrap:wrap;padding:2rem;}.");
    client.println("camera-box{background:#1a1a1a;padding:1rem;border-radius:10px;flex:1 1 45%;}img{width:100%;max-width:1000px;border-radius:10px;border:2px solid #444;}.title{text-align:center;margin-bottom:1rem;font-weight:bold;font-size:1.2rem;}");
    client.println(".placeholder{width:100%;aspect-ratio:4/3;border:2px dashed #444;border-radius:10px;display:flex;align-items:center;justify-content:center;color:#777;font-style:italic;}");
    client.println("</style></head><body>");
    client.println("<header><h1>Webcam</h1></header><main>");
    client.println("<div class='camera-box'><div class='title'>Cámara 1</div><img src='/stream'></div>");
    client.println("<div class='camera-box'><div class='title'>Cámara 2</div><div class='placeholder'>Cámara aún no conectada</div></div>");
    client.println("</main></body></html>");
  }

  delay(1);
  client.stop();
  Serial.println("Cliente desconectado");
}

Sensor de temperatura (DS18B20)


   
//By: IQ2

#ifdef ESP32
#include <WiFi.h>  // Librería para manejar WiFi en ESP32
#include <HTTPClient.h>  // Librería para realizar peticiones HTTP en ESP32
#else
#include <WiFiClient.h>  // Librería para manejar clientes WiFi en otros dispositivos
#endif

#include <Wire.h>  // Librería para comunicación I2C
#include <Adafruit_Sensor.h>  // Librería para manejar sensores Adafruit

#include <OneWire.h>  // Librería para comunicación OneWire
#include <DallasTemperature.h>  // Librería para sensores de temperatura Dallas

OneWire ourWire1(4);  // Definir el pin 4 para el bus OneWire (Puerto de salida S1)
DallasTemperature sensors1(&ourWire1);  // Crear una instancia del sensor Dallas en el bus OneWire (S1)

void setup() {
  delay(1000);  // Espera de 1 segundo para estabilización
  Serial.begin(115200);  // Inicializar la comunicación serial a 115200 baudios
  sensors1.begin();  // Iniciar la comunicación con el sensor de temperatura
}

void loop() {
  sensors1.requestTemperatures();  // Enviar comando para leer las temperaturas de los sensores
  float temp = sensors1.getTempCByIndex(0);  // Obtener la temperatura en grados Celsius del primer sensor

  Serial.print("Temperatura= ");  // Imprimir el texto "Temperatura= " en el monitor serial
  Serial.print(temp);  // Imprimir el valor de la temperatura
  Serial.println(" C");  // Imprimir el texto " C" en el monitor serial y pasar a la siguiente línea
  delay(3000);  // Toma de lectura cada 3 segundos
}

Sensor de temperatura (DHT22 + SERVIDOR SQL)


   


// ===================== 1) DHT22 =====================

//DHT22

#include <DHT.h>  

#define DHTTYPE DHT22
#define DHTPIN 15

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(115200);
  dht.begin();
}

void loop() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  Serial.print("Temp: ");
  Serial.print(t);
  Serial.print(" C  ");

  Serial.print("Humedad: ");
  Serial.print(h);
  Serial.println(" %");

  delay(1000);
}


// ===================== 2) SQL =====================

CREATE TABLE SensorData (
    id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    t1 FLOAT NOT NULL,
    fecha DATE NOT NULL,
    hora TIME NOT NULL
);


// ===================== 3) esp-data.php =====================

<!DOCTYPE html>
<html><body>
<?php

$servername = "localhost";
$dbname = "-------------";
$username = "-------------";
$password = "-------------"; 

$conn = new mysqli($servername, $username, $password, $dbname);

if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
} 

$sql = "SELECT id,t1,fecha,hora FROM SensorData ORDER BY id DESC";

echo '<table cellspacing="5" cellpadding="5">

<tr> 
<td>ID</td> 
<td>Temperatura ambiente y humedad °C</td> 
<td>Fecha</td>
<td>Hora</td>
</tr>';

if ($result = $conn->query($sql)) {
    while ($row = $result->fetch_assoc()) {
        echo '<tr> 
                <td>' . $row["id"]. '</td> 
                <td>' . $row["t1"]. '</td> 
                <td>' . $row["fecha"] . '</td>
                <td>' . $row["hora"] . '</td> 
              </tr>';
    }
    $result->free();
}

$conn->close();
?> 
</table>
</body>
</html>


// ===================== 4) post-esp-data.php =====================

<?php

date_default_timezone_set('America/Mexico_City');

$fecha= date('Y-m-d H:i:s'); 

$horarioVerano = date('I');

if ($horarioVerano==1) {
    $NuevaFecha = strtotime ( '-1 hour' , strtotime ($fecha) ); 
    $NuevaFecha = date ( 'Y-m-d H:i:s' , $NuevaFecha); 

    $hora = date("H:i:s", strtotime($NuevaFecha));
    $fecha=date("Y-m-d", strtotime($NuevaFecha)); 
}
else{
    $fecha=date("Y/m/d");
    $hora=date("H:i:s");
}

$servername = "-------------";
$dbname = "-------------";
$username = "-------------";
$password = "-------------"; 

$api_key_value = "-------------";

if ($_SERVER["REQUEST_METHOD"] == "POST") {

    if($_POST["api_key"] == $api_key_value) {

        $t1 = $_POST["t1"];

        $conn = new mysqli($servername, $username, $password, $dbname);

        if ($conn->connect_error) {
            die("Connection failed: " . $conn->connect_error);
        } 

        $sql = "INSERT INTO SensorData (t1,fecha,hora)
        VALUES ('$t1','$fecha','$hora')";
        
        if ($conn->query($sql) === TRUE) {
            echo "New record created successfully";
        } 
        else {
            echo "Error: " . $conn->error;
        }

        $conn->close();
    }
    else {
        echo "Wrong API Key provided.";
    }
}
else {
    echo "No data posted.";
}
?>


// ===================== 5) ESP32 FINAL =====================

#ifdef ESP32
#include <WiFi.h>
#include <HTTPClient.h>
#else
#include <WiFiClient.h>
#endif

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <DHT.h>

#define DHTTYPE DHT22
#define DHTPIN 15

DHT dht(DHTPIN, DHTTYPE);

const char* ssid = "-------------"; 
const char* password = "-------------"; 

const char* serverName = "-------------"; 
String apiKeyValue = "-------------";

void setup() {
  Serial.begin(115200);
  dht.begin();

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("Conectado");
}

void loop() {

  if (WiFi.status() == WL_CONNECTED) {

    WiFiClient client;
    HTTPClient http;

    float t1 = dht.readTemperature();

    http.begin(client, serverName);
    http.addHeader("Content-Type", "application/x-www-form-urlencoded");

    String httpRequestData = "api_key=" + apiKeyValue + "&t1=" + String(t1);

    int httpResponseCode = http.POST(httpRequestData);

    http.end();
  }

  delay(30000);
}


// ===================== 6) Página donde se encuentran los datos =====================

https://experimentoirvin.x10.mx/codigoabierto/datos6/esp-data.php

Piranómetro + ESP32




// Código abierto

#include <Adafruit_ADS1X15.h>

Adafruit_ADS1115 ads;  // Usamos el ADS1115 de 16 bits
float cr = 108108.108;
float wm = 0;

void setup(void)
{
  Serial.begin(9600);
  Serial.println("Lectura de radiación iniciada");

  // Inicialización del ADS1115
  Serial.println("Obteniendo lecturas de radiación");
  ads.setGain(GAIN_SIXTEEN);    // Ganancia 16x, +/- 0.256V
  if (!ads.begin()) {
    Serial.println("No se pudo inicializar el ADS.");
    while (1);
  }
}

void loop(void)
{
  // Lectura del ADS1115
  int16_t adc0 = ads.readADC_SingleEnded(0);
  float volts0 = ads.computeVolts(adc0);
  wm = volts0 * cr;

  // Verificar si la lectura es negativa
  if (wm < 0) {
    wm = 0;
  }

  // Imprimir resultados
  Serial.println("-----------------------------------------------------------");
  Serial.print(wm); Serial.println(" Wm^2");

  delay(1000);  // Espera de 1 segundo
}

Sensor de humedad relativa y temperatura (DHT22)


 //BY: IQ2

        #include <DHT.h>           // Incluye la librería DHT para manejar sensores DHT
        #define DHTTYPE   DHT22   // Define el tipo de sensor DHT22
        #define DHTPIN    4     // Define el pin D4 del ESP32 para conectar el sensor DHT22
        DHT dht(DHTPIN, DHTTYPE, 22); // Crea una instancia del objeto DHT usando el pin definido y el tipo de sensor

        void setup()
        {
          Serial.begin(115200);   // Inicializa la comunicación serial a 115200 baudios
          dht.begin();  // Inicializa el sensor DHT22
        }

        void loop()
        {
          float h = dht.readHumidity(); // Lee el valor de humedad desde el sensor y lo asigna a la variable "h"
          float t = dht.readTemperature(); // Lee el valor de temperatura desde el sensor y lo asigna a la variable "t"
          
          // Imprime los valores leídos en el monitor serial
          Serial.println("Humedad: "); // Imprime el texto "Humedad: " en el monitor serial
          Serial.println(h);  // Imprime el valor de la humedad
          Serial.println("Temperatura: "); // Imprime el texto "Temperatura: " en el monitor serial
          Serial.println(t);  // Imprime el valor de la temperatura
          delay(2000);  // Espera 2 segundos antes de realizar la siguiente lectura
        }

Sensores termopar Tipo K




//BY: IQ2

#include <WiFi.h>
#include <WebServer.h>
#include <max6675.h> //Libreria especifica

// Pines SPI compartidos
int thermoCLK = 18;
int thermoDO  = 19;

// Pines Chip Select independientes
int thermoCS1 = 5;
int thermoCS2 = 4;

// Instancias de los termopares
MAX6675 termopar1(thermoCLK, thermoCS1, thermoDO);
MAX6675 termopar2(thermoCLK, thermoCS2, thermoDO);

// WiFi
const char* ssid = "------";  // Nombre de la Red
const char* password = "-----"; // Contraseña de la Red

WebServer server(80);

// Página web con diseño profesional y gráficas
const char htmlPage[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="UTF-8">
  <title>Monitor de Termopares</title>
  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
  <style>
    body {
      font-family: 'Segoe UI', sans-serif;
      background: #1e272e;
      color: #f5f6fa;
      margin: 0;
      padding: 20px;
      text-align: center;
    }
    h1 { color: #00cec9; }
    .grid {
      display: flex;
      justify-content: center;
      gap: 20px;
      margin-bottom: 30px;
      flex-wrap: wrap;
    }
    .card {
      background: #2f3542;
      border-radius: 12px;
      padding: 20px;
      box-shadow: 0 4px 10px rgba(0, 0, 0, 0.3);
      width: 200px;
    }
    .label {
      font-size: 1.2em;
      margin-bottom: 10px;
      color: #dfe6e9;
    }
    .value {
      font-size: 2em;
      font-weight: bold;
      color: #fdcb6e;
    }
    .log {
      max-height: 300px;
      overflow-y: auto;
      background: #2d3436;
      padding: 10px;
      border-radius: 8px;
      margin-top: 20px;
      text-align: left;
      font-size: 0.95em;
    }
    .log-entry {
      margin-bottom: 6px;
      border-bottom: 1px solid #636e72;
      padding-bottom: 4px;
    }
    #chartContainer {
      display: none;
      margin-top: 30px;
    }
    .btn {
      background: #00cec9;
      border: none;
      padding: 10px 20px;
      font-size: 1em;
      border-radius: 8px;
      cursor: pointer;
      margin-bottom: 20px;
      color: black;
    }
  </style>
</head>
<body>
  <h1>📈 Monitor de Temperatura - Termopares</h1>
  <button class="btn" onclick="toggleView()">🔁 Cambiar vista</button>

  <div id="dataContainer">
    <div class="grid">
      <div class="card">
        <div class="label">Termopar 1</div>
        <div class="value" id="temp1">-- °C</div>
      </div>
      <div class="card">
        <div class="label">Termopar 2</div>
        <div class="value" id="temp2">-- °C</div>
      </div>
    </div>
    <h2>🗂 Resultados obtenidos</h2>
    <div class="log" id="logContainer"></div>
  </div>

  <div id="chartContainer">
    <canvas id="chart1"></canvas>
    <canvas id="chart2" style="margin-top:30px;"></canvas>
  </div>

  <script>
    let chart1, chart2;
    let data1 = [];
    let data2 = [];
    let labels = [];

    function toggleView() {
      const dataDiv = document.getElementById("dataContainer");
      const chartDiv = document.getElementById("chartContainer");
      dataDiv.style.display = dataDiv.style.display === "none" ? "block" : "none";
      chartDiv.style.display = chartDiv.style.display === "none" ? "block" : "none";
    }

    function setupCharts() {
      const ctx1 = document.getElementById('chart1').getContext('2d');
      const ctx2 = document.getElementById('chart2').getContext('2d');

      chart1 = new Chart(ctx1, {
        type: 'line',
        data: {
          labels: labels,
          datasets: [{
            label: 'Temperatura Termopar 1 (°C)',
            data: data1,
            borderColor: '#00cec9',
            backgroundColor: 'rgba(0, 206, 201, 0.2)',
            fill: true,
            tension: 0.2
          }]
        },
        options: {
          scales: {
            x: { display: true },
            y: { suggestedMin: 0 }
          }
        }
      });

      chart2 = new Chart(ctx2, {
        type: 'line',
        data: {
          labels: labels,
          datasets: [{
            label: 'Temperatura Termopar 2 (°C)',
            data: data2,
            borderColor: '#fdcb6e',
            backgroundColor: 'rgba(253, 203, 110, 0.2)',
            fill: true,
            tension: 0.2
          }]
        },
        options: {
          scales: {
            x: { display: true },
            y: { suggestedMin: 0 }
          }
        }
      });
    }

    async function fetchTemperatures() {
      try {
        const res = await fetch("/temperatura");
        const data = await res.json();
        const now = new Date();
        const timestamp = now.toLocaleTimeString();

        // Actualizar texto
        document.getElementById("temp1").textContent = `${data.t1} °C`;
        document.getElementById("temp2").textContent = `${data.t2} °C`;

        // Actualizar log
        const logEntry = `
          <div class="log-entry">
            <strong>${now.toLocaleString()}</strong><br>
            Termopar 1: ${data.t1} °C<br>
            Termopar 2: ${data.t2} °C
          </div>
        `;
        const logContainer = document.getElementById("logContainer");
        logContainer.innerHTML = logEntry + logContainer.innerHTML;

        // Actualizar gráficas
        if (labels.length >= 30) {
          labels.shift();
          data1.shift();
          data2.shift();
        }

        labels.push(timestamp);
        data1.push(data.t1);
        data2.push(data.t2);

        chart1.update();
        chart2.update();

      } catch (error) {
        console.error("Error al obtener datos:", error);
      }
    }

    setupCharts();
    setInterval(fetchTemperatures, 1000);
    fetchTemperatures();
  </script>
</body>
</html>
)rawliteral";

// Función para enviar página web
void handleRoot() {
  server.send_P(200, "text/html", htmlPage);
}

// Función para enviar datos JSON
void handleTemperatura() {
  float t1 = termopar1.readCelsius();
  float t2 = termopar2.readCelsius();
  String json = "{\"t1\":" + String(t1, 2) + ",\"t2\":" + String(t2, 2) + "}";
  server.send(200, "application/json", json);
}

void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println("Conectando al WiFi...");
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConectado. Dirección IP:");
  Serial.println(WiFi.localIP());

  server.on("/", handleRoot);
  server.on("/temperatura", handleTemperatura);
  server.begin();
  Serial.println("Servidor HTTP iniciado");
}

void loop() {
  server.handleClient();
}


        
    
    
    
     
     

    
        Sensor de Temperatura y Humedad DHT22 + Servidor Local (Wifi) 🌐
    
    


    
    

    
    
// Codigo abierto 

// Importamos las librerias que necesitamos
#include "WiFi.h"
#include "ESPAsyncWebServer.h"
#include <Adafruit_Sensor.h>
#include <DHT.h>  

// Es necesario remplazar la informacion de tu internet
const char* ssid = "-------";
const char* password = "-----";

#define DHTPIN 27     // Pin digital de salida del sensor
#define DHTTYPE    DHT22     // Tipo de sensor

DHT dht(DHTPIN, DHTTYPE);

// Creación del puerto # 80 
AsyncWebServer server(80);

String readDHTTemperature() {
  float t = dht.readTemperature();
  if (isnan(t)) {    
    Serial.println("Failed to read from DHT sensor!");
    return "--";
  }
  else {
    Serial.println(t);
    return String(t);
  }
}

String readDHTHumidity() {
  float h = dht.readHumidity();
  if (isnan(h)) {
    Serial.println("Failed to read from DHT sensor!");
    return "--";
  }
  else {
    Serial.println(h);
    return String(h);
  }
}

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css" integrity="sha384-fnmOCqbTlWIlj8LyTjo7mOUStjsKC4pOpQbqyi7RrhN7udi9RwhKkMHpvLbHG9Sr" crossorigin="anonymous">
  <style>
    html {
     font-family: Arial;
     display: inline-block;
     margin: 0px auto;
     text-align: center;
    }
    h2 { font-size: 3.0rem; }
    p { font-size: 3.0rem; }
    .units { font-size: 1.2rem; }
    .dht-labels{
      font-size: 1.5rem;
      vertical-align:middle;
      padding-bottom: 15px;
    }
  </style>
</head>
<body>
  <h2>Codigo Abierto </h2>
  <p>
    <i class="fas fa-thermometer-half" style="color:#059e8a;"></i> 
    <span class="dht-labels">Temperature</span> 
    <span id="temperature">%TEMPERATURE%</span>
    <sup class="units">°C</sup>
  </p>
  <p>
    <i class="fas fa-tint" style="color:#00add6;"></i> 
    <span class="dht-labels">Humidity</span>
    <span id="humidity">%HUMIDITY%</span>
    <sup class="units">%</sup>
  </p>
</body>
<script>
setInterval(function ( ) {
  var xhttp = new XMLHttpRequest();
  xhttp.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
      document.getElementById("temperature").innerHTML = this.responseText;
    }
  };
  xhttp.open("GET", "/temperature", true);
  xhttp.send();
}, 10000 ) ;

setInterval(function ( ) {
  var xhttp = new XMLHttpRequest();
  xhttp.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
      document.getElementById("humidity").innerHTML = this.responseText;
    }
  };
  xhttp.open("GET", "/humidity", true);
  xhttp.send();
}, 10000 ) ;
</script>
</html>)rawliteral";

// Replaces placeholder with DHT values
String processor(const String& var){
  if(var == "TEMPERATURE"){
    return readDHTTemperature();
  }
  else if(var == "HUMIDITY"){
    return readDHTHumidity();
  }
  return String();
}

void setup(){
  Serial.begin(115200);
  dht.begin();
  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi..");
  }

  Serial.println(WiFi.localIP());

  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/html", index_html, processor);
  });
  server.on("/temperature", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/plain", readDHTTemperature().c_str());
  });
  server.on("/humidity", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/plain", readDHTHumidity().c_str());
  });

  server.begin();
}

void loop(){
  
}



        
            
        
        
    
    
    
     


    
        Estación meteorológica + Servidor Local (Wifi) 🌐
    
    


    
      

#include "WiFi.h"
#include "ESPAsyncWebServer.h"
#include <Adafruit_Sensor.h>
#include <DHT.h>
#include <Adafruit_ADS1X15.h>  // Librería para el ADS1115
#include <Wire.h>
#include <OneWire.h>  // Librería para comunicación OneWire
#include <DallasTemperature.h>  // Librería para sensores de temperatura Dallas

// Es necesario remplazar la información de tu internet
const char* ssid = "-------";  // Reemplaza con tu SSID
const char* password = "-----------";  // Reemplaza con tu contraseña

#define DHTPIN 27     // Pin digital de salida del sensor
#define DHTTYPE    DHT22     // Tipo de sensor
#define ONE_WIRE_BUS 4  // Pin del bus OneWire

DHT dht(DHTPIN, DHTTYPE);

// Inicialización del ADS1115
Adafruit_ADS1115 ads;
float cr = 108108.108;  // Factor de calibración
float wm = 0;

// Configuración del sensor Dallas
OneWire ourWire1(ONE_WIRE_BUS);  // Definir el pin 4 para el bus OneWire
DallasTemperature sensors1(&ourWire1);  // Crear una instancia del sensor Dallas

AsyncWebServer server(80);

String readDHTTemperature() {
  float t = dht.readTemperature();
  if (isnan(t)) {    
    Serial.println("Failed to read from DHT sensor!");
    return "--";
  }
  else {
    return String(t);
  }
}

String readDHTHumidity() {
  float h = dht.readHumidity();
  if (isnan(h)) {
    Serial.println("Failed to read from DHT sensor!");
    return "--";
  }
  else {
    return String(h);
  }
}

String readSolarRadiation() {
  // Lectura del ADS1115
  int16_t adc0 = ads.readADC_SingleEnded(0);  // Lee el canal 0
  float volts0 = ads.computeVolts(adc0);  // Convierte la lectura a voltaje
  wm = volts0 * cr;  // Calcula la radiación en W/m²

  // Verificar si la lectura es negativa
  if (wm < 0) {
    wm = 0;
  }

  return String(wm);
}

String readDallasTemperature() {
  sensors1.requestTemperatures();  // Solicitar las temperaturas
  float temp = sensors1.getTempCByIndex(0);  // Obtener la temperatura en °C
  return String(temp);
}

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css">
  <style>
    * { margin: 0; padding: 0; box-sizing: border-box; }
    body {
      font-family: 'Arial', sans-serif;
      background-color: #eef2f7;
      display: flex;
      justify-content: center;
      align-items: center;
      height: 100vh;
      flex-direction: column;
      background-image: url('https://www.transparenttextures.com/patterns/diagonal-stripes-light.png');
      background-repeat: repeat;
    }
    h1 {
      font-size: 3rem;
      color: #3c8dbc;
      margin-bottom: 30px;
      font-weight: bold;
      text-align: center;
    }
    .card {
      background-color: white;
      border-radius: 12px;
      padding: 20px;
      margin: 15px;
      box-shadow: 0 8px 16px rgba(0, 0, 0, 0.1);
      width: 280px;
      text-align: center;
      transition: transform 0.3s ease;
    }
    .card:hover {
      transform: translateY(-10px);
    }
    .card h2 {
      font-size: 2rem;
      margin: 10px 0;
      color: #333;
    }
    .card i {
      font-size: 4rem;
      color: #f39c12;
      margin-bottom: 15px;
    }
    .value {
      font-size: 2.5rem;
      color: #333;
      font-weight: bold;
    }
    .units {
      font-size: 1.4rem;
      color: #777;
    }
    .container {
      display: flex;
      flex-direction: row;
      justify-content: center;
      align-items: center;
      flex-wrap: wrap;
      gap: 20px;
      margin-top: 20px;
    }
    @media (max-width: 768px) {
      .container {
        flex-direction: column;
      }
    }
  </style>
</head>
<body>
  <h1>Estacion Meteorologica</h1>
  <div class="container">
    <div class="card">
      <i class="fas fa-thermometer-half"></i>
      <h2>Temperatura DHT</h2>
      <p class="value" id="temperature">%TEMPERATURE%</p>
      <span class="units">°C</span>
    </div>

    <div class="card">
      <i class="fas fa-tint"></i>
      <h2>Humedad</h2>
      <p class="value" id="humidity">%HUMIDITY%</p>
      <span class="units">%</span>
    </div>

    <div class="card">
      <i class="fas fa-sun"></i>
      <h2>Radiacion Solar</h2>
      <p class="value" id="radiation">%RADIATION%</p>
      <span class="units">W/m²</span>
    </div>

    <div class="card">
      <i class="fas fa-temperature-high"></i>
      <h2>Temperatura Dallas</h2>
      <p class="value" id="dallasTemp">%DALLASTEMPERATURE%</p>
      <span class="units">°C</span>
    </div>
  </div>

  <script>
    setInterval(function() {
      var xhttp = new XMLHttpRequest();
      xhttp.onreadystatechange = function() {
        if (this.readyState == 4 && this.status == 200) {
          document.getElementById("temperature").innerHTML = this.responseText;
        }
      };
      xhttp.open("GET", "/temperature", true);
      xhttp.send();
    }, 10000);

    setInterval(function() {
      var xhttp = new XMLHttpRequest();
      xhttp.onreadystatechange = function() {
        if (this.readyState == 4 && this.status == 200) {
          document.getElementById("humidity").innerHTML = this.responseText;
        }
      };
      xhttp.open("GET", "/humidity", true);
      xhttp.send();
    }, 10000);

    setInterval(function() {
      var xhttp = new XMLHttpRequest();
      xhttp.onreadystatechange = function() {
        if (this.readyState == 4 && this.status == 200) {
          document.getElementById("radiation").innerHTML = this.responseText;
        }
      };
      xhttp.open("GET", "/radiation", true);
      xhttp.send();
    }, 10000);

    setInterval(function() {
      var xhttp = new XMLHttpRequest();
      xhttp.onreadystatechange = function() {
        if (this.readyState == 4 && this.status == 200) {
          document.getElementById("dallasTemp").innerHTML = this.responseText;
        }
      };
      xhttp.open("GET", "/dallasTemperature", true);
      xhttp.send();
    }, 10000);
  </script>
</body>
</html>)rawliteral";

// Iniciar el servidor
void setup() {
  Serial.begin(115200); // Dato super importante

  // Conexión WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Conectando a WiFi...");
  }
  Serial.println("Conexión WiFi establecida");

  // Inicializar DHT
  dht.begin();

  // Inicializar ADS1115
  if (!ads.begin()) {
    Serial.println("Error al inicializar el ADS1115");
    while (1);
  }

  // Inicializar sensores Dallas
  sensors1.begin();

  // Configuración de las rutas del servidor web
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/html", index_html);
  });

  server.on("/temperature", HTTP_GET, [](AsyncWebServerRequest *request){
    String temperature = readDHTTemperature();
    request->send(200, "text/plain", temperature);
  });

  server.on("/humidity", HTTP_GET, [](AsyncWebServerRequest *request){
    String humidity = readDHTHumidity();
    request->send(200, "text/plain", humidity);
  });

  server.on("/radiation", HTTP_GET, [](AsyncWebServerRequest *request){
    String radiation = readSolarRadiation();
    request->send(200, "text/plain", radiation);
  });

  server.on("/dallasTemperature", HTTP_GET, [](AsyncWebServerRequest *request){
    String dallasTemperature = readDallasTemperature();
    request->send(200, "text/plain", dallasTemperature);
  });

  // Iniciar el servidor
  server.begin();
}

void loop() {
  // El loop puede estar vacío ya que las lecturas y respuestas web se manejan en el servidor
}



            
        
        
    

    
      


    
        Sensor de Humedad y Temperatura (DHT22) + LCD 2x16
    
    

   
    

 
// Incluye librería para LCD
#include <LiquidCrystal_I2C.h>  

// Definición de pines y configuración del LCD
int lcdColumns = 16;
int lcdRows = 2;
LiquidCrystal_I2C lcd(0x27, lcdColumns, lcdRows); 

// Incluye librería para el sensor
#include <DHT.h>  

#define DHTTYPE   DHT22   // Definición del tipo de sensor 
#define DHTPIN    4       // Definición del pin de conexión

// Instancia del sensor con valores protegidos
DHT dht(DHTPIN, DHTTYPE, 22);  

void setup() {
    lcd.init();                     
    lcd.backlight();
    
    Serial.begin(115200);  // Inicializa la comunicación serial 
    dht.begin();  // Inicializa el sensor
}

void loop() {
    float h = dht.readHumidity();  // Lee la humedad y la almacena en "h"
    float t = dht.readTemperature();  // Lee la temperatura y la almacena en "t"
    
    lcd.setCursor(0, 0);
    lcd.print(String("Temp: ") + h + " C");
    lcd.setCursor(0, 1);
    lcd.print(String("Humedad: ") + t + " %");

    delay(1000);  
}


            

        

        
    
    
        
        
  
        
      


    
        Moc 3031 y Triac BTA 224 (Interruptor eléctronico) 
    
    

   
    

        
        
            
            
        

        
    

    
        
        
        
    
      


    
        Sensor de Temperatura (DS18B20) + LCD 2x16 
    
    

   
    

 
// Incluye librería para LCD
#include <LiquidCrystal_I2C.h>  

// Definición de pines y configuración del LCD
int lcdColumns = 16;
int lcdRows = 2;
LiquidCrystal_I2C lcd(0x27, lcdColumns, lcdRows); 

// Librerías para comunicación OneWire y sensores Dallas
#include <OneWire.h>  
#include <DallasTemperature.h>  

OneWire ourWire1(4);  // Definir el pin 4 para el bus OneWire (Puerto de salida S1)
DallasTemperature sensors1(&ourWire1);  // Crear una instancia del sensor Dallas en el bus OneWire (S1)

void setup() {
    lcd.init();                     
    lcd.backlight();
    sensors1.begin();  // Iniciar la comunicación con el sensor de temperatura
    Serial.begin(115200);  // Inicializa la comunicación serial 
}

void loop() {
    sensors1.requestTemperatures();  // Enviar comando para leer las temperaturas de los sensores
    float temp = sensors1.getTempCByIndex(0);  // Obtener la temperatura en grados Celsius del primer sensor
    
    lcd.setCursor(0, 0);
    lcd.print("Temperatura:");
    lcd.setCursor(0, 1);
    lcd.print(String(temp) + "C");

    delay(1000);  
}


            

        

        
    

    


    
    


    
        Sensor de Temperatura (DS18B20) + control + lcd 2x16 
    
    

   
    
        
    
//Control de temperatura + lcd ---> by: IQ2

// Incluye librería para LCD
#include <LiquidCrystal_I2C.h>  

// Definición de pines y configuración del LCD
int lcdColumns = 16;
int lcdRows = 2;
LiquidCrystal_I2C lcd(0x27, lcdColumns, lcdRows); 

// Librerías para comunicación OneWire y sensores Dallas
#include <OneWire.h>  
#include <DallasTemperature.h>  

const int ledPin = 13;      // LED en el pin digital 13
const int btnUp = 25;       // Botón para aumentar la temperatura
const int btnDown = 26;     // Botón para disminuir la temperatura
const int btnManual = 27;   // Botón para encender/apagar el LED manualmente
float tempSet = 30.0;       // Temperatura inicial

OneWire ourWire1(4);  // Definir el pin 4 para el bus OneWire (Puerto de salida S1)
DallasTemperature sensors1(&ourWire1);  // Crear una instancia del sensor Dallas en el bus OneWire (S1)

bool ledManual = false;  // Estado manual del LED (encendido o apagado)
unsigned long lastButtonPress = 0;  // Para evitar rebotes y lecturas rápidas del botón manual

void setup() {
    lcd.init();                     
    lcd.backlight();
    sensors1.begin();  // Iniciar la comunicación con el sensor de temperatura
    pinMode(ledPin, OUTPUT);    // Configurar el LED como salida
    pinMode(btnUp, INPUT_PULLUP);   // Configurar botón de aumentar con resistencia interna
    pinMode(btnDown, INPUT_PULLUP); // Configurar botón de disminuir con resistencia interna
    pinMode(btnManual, INPUT_PULLUP); // Configurar botón manual con resistencia interna
    Serial.begin(115200);  // Inicializa la comunicación serial 
}

void loop() {
    // Leer temperatura
    sensors1.requestTemperatures();
    float temp = sensors1.getTempCByIndex(0);

    // Ajuste de temperatura con botones
    if (digitalRead(btnUp) == LOW) {
        tempSet += 1; // Aumenta temperatura en 1°C
        delay(200);  // Pequeño retraso para evitar rebotes
    }
    if (digitalRead(btnDown) == LOW) {
        tempSet -= 1; // Disminuye temperatura en 1°C
        delay(200);  // Pequeño retraso para evitar rebotes
    }

    // Control manual del LED sin delay
    if (digitalRead(btnManual) == LOW && (millis() - lastButtonPress) > 500) {
        ledManual = !ledManual;  // Cambia el estado del LED manual
        lastButtonPress = millis();  // Actualiza el tiempo de la última pulsación
    }

    // Mostrar información en LCD
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Temp:" + String(temp) + " C");
    
    lcd.setCursor(0, 1);
    lcd.print("Set:" + String(tempSet) + "");

    // Control del LED (automático por temperatura o manual)
    if (ledManual) {
        digitalWrite(ledPin, HIGH); // Enciende el LED manualmente
        lcd.setCursor(10, 1);  
        lcd.print("M1 MANUAL ON");
    } else {
        if (temp > tempSet) {
            digitalWrite(ledPin, HIGH); // Enciende el LED según la temperatura
            lcd.setCursor(10, 1);  
            lcd.print("M1-ON");
        } else {
            digitalWrite(ledPin, LOW); // Apaga el LED según la temperatura
            lcd.setCursor(10, 1);  
            lcd.print("M1-OFF");
        }
    }

    delay(200);  // Pausa para evitar que los botones se registren demasiado rápido
}


            

        

        
    

    
        
        
     


    
        Sensor de humedad relativa y temperatura (DHT22) + ESP32 
    
    


    
      
      
 //BY: IQ2

        #include <DHT.h>           // Incluye la librería DHT para manejar sensores DHT
        #define DHTTYPE   DHT22   // Define el tipo de sensor DHT22
        #define DHTPIN    4     // Define el pin D4 del ESP32 para conectar el sensor DHT22
        DHT dht(DHTPIN, DHTTYPE, 22); // Crea una instancia del objeto DHT usando el pin definido y el tipo de sensor

        void setup()
        {
          Serial.begin(115200);   // Inicializa la comunicación serial a 115200 baudios
          dht.begin();  // Inicializa el sensor DHT22
        }

        void loop()
        {
          float h = dht.readHumidity(); // Lee el valor de humedad desde el sensor y lo asigna a la variable "h"
          float t = dht.readTemperature(); // Lee el valor de temperatura desde el sensor y lo asigna a la variable "t"
          
          // Imprime los valores leídos en el monitor serial
          Serial.println("Humedad: "); // Imprime el texto "Humedad: " en el monitor serial
          Serial.println(h);  // Imprime el valor de la humedad
          Serial.println("Temperatura: "); // Imprime el texto "Temperatura: " en el monitor serial
          Serial.println(t);  // Imprime el valor de la temperatura
          delay(2000);  // Espera 2 segundos antes de realizar la siguiente lectura
        }
        
            

        

        
    

    
    
    
    
    
    

    


    
        Sensor de temperatura, presión y humedad. Módulo (GY-BMP280) + ESP32
    
    


    


#include <Wire.h>  // Incluye la librería Wire para la comunicación I2C
        #include <Adafruit_Sensor.h>  // Incluye la librería base para sensores Adafruit
        #include <Adafruit_BME280.h>  // Incluye la librería específica para el sensor BME280

        #define SEALEVELPRESSURE_HPA (1013.25)  // Define la presión a nivel del mar en hPa

        Adafruit_BME280 bme; // Crea una instancia para el sensor BME280 en modo I2C

        // Adafruit_BME280 bme(BME_CS); // Alternativa para SPI hardware (comentado)
        // Adafruit_BME280 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK); // Alternativa para SPI software (comentado)

        unsigned long delayTime;  // Variable para almacenar el tiempo de retardo

        void setup() {
          Serial.begin(9600);  // Inicia la comunicación serial a 9600 baudios
          Serial.println(F("BME280 test"));  // Imprime un mensaje de inicio en el monitor serial

          bool status;
          status = bme.begin(0x76);  // Inicializa el sensor BME280 en la dirección I2C 0x76
          
          if (!status) {
            Serial.println("Could not find a valid BME280 sensor, check wiring!");  // Si falla, imprime un error
            while (1);  // Se queda en un bucle infinito
          }

          Serial.println("-- Default Test --");  // Imprime un mensaje de prueba en el monitor serial
          delayTime = 3000;  // Establece el tiempo de retardo a 3000 ms

          Serial.println();  // Imprime una línea vacía
        }

        void loop() { 
          printValues();  // Llama a la función para imprimir los valores del sensor
          delay(delayTime);  // Espera el tiempo definido antes de la siguiente lectura
        }

        void printValues() {
          Serial.print("Temperature = ");  // Imprime "Temperature = " en el monitor serial
          Serial.print(bme.readTemperature());  // Lee e imprime la temperatura en °C
          Serial.println(" *C");  // Imprime el símbolo de grados Celsius y pasa a la siguiente línea

          Serial.print("Pressure = ");  // Imprime "Pressure = " en el monitor serial
          Serial.print(bme.readPressure() / 100.0F);  // Lee e imprime la presión en hPa
          Serial.println(" hPa");  // Imprime "hPa" y pasa a la siguiente línea

          Serial.print("Approx. Altitude = ");  // Imprime "Approx. Altitude = " en el monitor serial
          Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));  // Calcula e imprime la altitud aproximada en metros
          Serial.println(" m");  // Imprime "m" y pasa a la siguiente línea

          Serial.print("Humidity = ");  // Imprime "Humidity = " en el monitor serial
          Serial.print(bme.readHumidity());  // Lee e imprime la humedad en %
          Serial.println(" %");  // Imprime "%" y pasa a la siguiente línea

          Serial.println();  // Imprime una línea vacía para separar lecturas
        }

            

        

        
    
    

 


    
        Sensor ultrasónico + ESP32 
    
    


    
        
      
                
const int Trigger = 2;  // Pin de salida para el Trigger del sensor ultrasónico
const int Echo = 4;     // Pin de entrada para el Echo del sensor ultrasónico

void setup() {
  Serial.begin(115200);           // Inicia la comunicación serial a 115200 baudios
  pinMode(Trigger, OUTPUT);       // Configura el pin Trigger como salida
  pinMode(Echo, INPUT);           // Configura el pin Echo como entrada
  digitalWrite(Trigger, LOW);     // Asegura que el Trigger empiece en estado bajo
}

void loop() {
  long t;  // Variable para almacenar el tiempo de regreso del pulso
  long d;  // Variable para almacenar la distancia en centímetros
  
  digitalWrite(Trigger, HIGH);      // Activa el Trigger para enviar un pulso
  delayMicroseconds(10);            // Mantiene el pulso durante 10 microsegundos
  digitalWrite(Trigger, LOW);       // Desactiva el Trigger

  t = pulseIn(Echo, HIGH);          // Mide el tiempo que tarda el pulso en regresar
  d = t / 59;                       // Calcula la distancia en centímetros

  Serial.print("Distancia: ");      // Imprime "Distancia: " en el monitor serial
  Serial.print(d);                  // Imprime la distancia calculada
  Serial.println(" cm");            // Imprime "cm" y pasa a la siguiente línea

  delay(100);                       // Pausa de 100 ms antes de la próxima medición
}

            

        

        
    
    
    

 
        

    
        Sensor DHT 22 + HC-SR04 + HUMEDAD DE SUELO + ESP32
    
    


    

                
#include <Wire.h>  // Librería para comunicación I2C
#include <Adafruit_Sensor.h>  // Librería para manejar sensores Adafruit
#include <OneWire.h>  // Librería para comunicación OneWire
#include <DallasTemperature.h>  // Librería para sensores de temperatura Dallas
#include <DHT.h>           // Incluye la librería DHT para manejar sensores DHT

// Sensores:  (DHT 22 / HC-S04/sensor humedad de suelo)

// Declaración de variables:

const int Valor_Sensor_Aire = 2560; // Valor calculado con el programa de calibración con el sensor al aire
const int Valor_Sensor_Agua = 974; // Valor calculado con el programa de calibración con el sensor sumergido en agua

int valor_sensor = 0; // Variable que almacena el valor de salida del sensor de humedad capacitivo
int porcentaje = 0; // Variable que almacena el porcentaje de humedad relativa del terreno

const int Trigger = 2;  // Pin de salida para el Trigger del sensor ultrasónico
const int Echo = 5;     // Pin de entrada para el Echo del sensor ultrasónico

long s;  // Variable para almacenar el tiempo de regreso del pulso
long d;  // Variable para almacenar la distancia en centímetros

#define DHTTYPE   DHT22   // Define el tipo de sensor DHT22
#define DHTPIN    4      // Define el pin D4 del ESP32 para conectar el sensor DHT22
DHT dht(DHTPIN, DHTTYPE, 22); // Crea una instancia del objeto DHT usando el pin definido y el tipo de sensor

void setup()
{
  Serial.begin(115200);   // Inicializa la comunicación serial a 115200 baudios
  dht.begin();  // Inicializa el sensor DHT22

  // Sensor ultrasónico
  pinMode(Trigger, OUTPUT);       // Configura el pin Trigger como salida
  pinMode(Echo, INPUT);           // Configura el pin Echo como entrada
  digitalWrite(Trigger, LOW);     // Asegura que el Trigger empiece en estado bajo
}

void loop()
{
  // Lee el valor de la salida analógica del sensor capacitivo, conectado al pin analógico "A0"
  valor_sensor = analogRead(33);
  
  // Calcula el porcentaje de humedad relativa usando los valores de calibración
  porcentaje = map(valor_sensor, Valor_Sensor_Agua, Valor_Sensor_Aire, 100, 0);
  
 
  if (porcentaje < 0) porcentaje = 0; // Evita porcentajes negativos, asegurando que el porcentaje no sea menor que 0
  if (porcentaje > 100) porcentaje = 100; // Evita porcentajes mayores a 100, asegurando que el porcentaje no sea mayor que 100

  float h = dht.readHumidity(); // Lee el valor de humedad desde el sensor y lo asigna a la variable "h"
  float t = dht.readTemperature(); // Lee el valor de temperatura desde el sensor y lo asigna a la variable "t"
  digitalWrite(Trigger, HIGH);      // Activa el Trigger para enviar un pulso
  delayMicroseconds(10);            // Mantiene el pulso durante 10 microsegundos
  digitalWrite(Trigger, LOW);       // Desactiva el Trigger

  s = pulseIn(Echo, HIGH);          // Mide el tiempo que tarda el pulso en regresar
  d = s / 59;                       // Calcula la distancia en centímetros

  // Diseño visual profesional en el monitor serial
  Serial.println("══════════════════════════════════════════");
  Serial.println("              DATOS DEL SENSOR            ");
  Serial.println("══════════════════════════════════════════");

  Serial.print("HUMEDAD      : ");
  Serial.print(h);
  Serial.println(" %");

  Serial.print("TEMPERATURA  : ");
  Serial.print(t);
  Serial.println(" °C");

  Serial.print("DISTANCIA    : ");
  Serial.print(d);
  Serial.println(" cm");

  Serial.print("HUMEDAD RELATIVA: ");
  Serial.print(porcentaje);
  Serial.println(" % HR");

  Serial.print("ESTADO DEL SUELO: ");
  if (porcentaje <= 33) {
    Serial.println("Suelo seco !!!");
  } else if (porcentaje > 33 && porcentaje <= 66) {
    Serial.println("Suelo húmedo !!!");
  } else if (porcentaje > 66) {
    Serial.println("Exceso de humedad !!!");
  }

  Serial.println("══════════════════════════════════════════");
  Serial.println(); // Espacio para la próxima lectura

  delay(2000);  // Espera 2 segundos antes de realizar la siguiente lectura
}

            

        

        
    

    
    

 


    
        Sensor de flujo de agua YS-2011 1/2" 1-30 l/min caudalimetro + ESP32
    
    


    


// pin de dato: Caudal= 18

#ifdef ESP32
#include <WiFi.h>  // Librería para manejar WiFi en ESP32
#include <HTTPClient.h>  // Librería para realizar peticiones HTTP en ESP32
#else
//#include <ESP8266WiFi.h>  // Librería para manejar WiFi en ESP8266
//#include <ESP8266HTTPClient.h>  // Librería para realizar peticiones HTTP en ESP8266
#include <WiFiClient.h>  // Librería para manejar clientes WiFi en otros dispositivos
#endif

#include <Wire.h>  // Librería para comunicación I2C
#include <Adafruit_Sensor.h>  // Librería para manejar sensores Adafruit

// Sensor de caudal--------------
volatile int flow_frequency;
float vol = 0.0, l_minute;  // Esta es la variable que se debe configurar según el dato
unsigned char flowsensor = 18;  // Señal de entrada
unsigned long currentTime;
unsigned long cloopTime;

// Función para contar las pulsaciones del sensor de caudal
void flow() {
  flow_frequency++;
}

// Las variables que se tienen declaradas, son:
String c = "c";  // Sensor de caudal

void setup() {
  // Código para el sensor de caudal----------
  pinMode(flowsensor, INPUT);
  digitalWrite(flowsensor, HIGH); // Optional Internal Pull-Up
  attachInterrupt(digitalPinToInterrupt(flowsensor), flow, RISING); // Configurar la interrupción

  Serial.begin(115200);
  Serial.print("Water Flow Meter");
  Serial.print("Circuit Digest");

  currentTime = millis();
  cloopTime = currentTime;

  //--------------------------------------------

  bool status = c.begin(); // Inicialización del sensor de caudal
  if (!status) {
    Serial.println("¡No se pudo encontrar un sensor de HUMEDAD válido, verifique el cableado o cambie la dirección I2C!");
    while (1);
  }
}

// Este código de programación se queda como está:
void loop() {
  currentTime = millis();

  if (currentTime >= (cloopTime + 1000)) {
    cloopTime = currentTime;
    if (flow_frequency != 0) {
      l_minute = (flow_frequency / 60 * 10 - 0.26);
      l_minute = l_minute / 60;

      c = vol;
      vol = vol + l_minute;

      Serial.println(" Caudal:"); // Ls
      Serial.print(vol);  // Código a editar
      flow_frequency = 0; // Reset Counter
      Serial.println(" mililitros (mL)"); // Ls
    }
  }

  delay(1000); // cada 5 minutos 300000 la lectura de los sensores // para cada medio segundo 30000
}

            

        

        
    

    
    
        
    
    



    
        Sensor de humedad de suelo capacitivo + ESP32
    
    


    


const int Valor_Sensor_Aire = 2560; // Valor calculado con el programa de calibración con el sensor al aire
const int Valor_Sensor_Agua = 974; // Valor calculado con el programa de calibración con el sensor sumergido en agua

int valor_sensor = 0; // Variable que almacena el valor de salida del sensor de humedad capacitivo
int porcentaje = 0; // Variable que almacena el porcentaje de humedad relativa del terreno

void setup()
{
  Serial.begin(115200); // Inicia la comunicación serial a 115200 baudios para mostrar datos en el monitor serial
}

void loop()
{
  // Lee el valor de la salida analógica del sensor capacitivo, conectado al pin analógico "A0"
  valor_sensor = analogRead(33);

  // Calcula el porcentaje de humedad relativa usando los valores de calibración
  porcentaje = map(valor_sensor, Valor_Sensor_Agua, Valor_Sensor_Aire, 100, 0);

  if(porcentaje < 0) porcentaje = 0; // Evita porcentajes negativos, asegurando que el porcentaje no sea menor que 0

  if(porcentaje > 100) porcentaje = 100; // Evita porcentajes mayores a 100, asegurando que el porcentaje no sea mayor que 100

  // Muestra el porcentaje de humedad en el monitor serial
  Serial.print("HUMEDAD: ");
  Serial.print(porcentaje);
  Serial.println("% HR");

  // Muestra un mensaje dependiendo del rango del porcentaje de humedad
  if(porcentaje <= 33)
  {
    Serial.println("Suelo seco !!!");    
  }

  if(porcentaje > 33 && porcentaje <= 66)
  {
    Serial.println("Suelo húmedo !!!");
  }

  if(porcentaje > 66)
  {
    Serial.println("Suelo con exceso de humedad !!!");
  }

  Serial.println(" "); // Imprime una línea en blanco para separar las lecturas en el monitor serial

  delay(1000); // Espera un segundo antes de realizar la siguiente lectura del sensor
}

I Q 2

Inicio

Gestión de Actividades

Visión y Misión

Códigos ESP32

Correo 📫

Selecciona tu sistema 🚀 📡 ️