Monitoring Suhu & Kelembaban dengan Sensor DHT11/DHT22 + ESP32

// Library utama untuk sensor DHT
#include "DHT.h"

// Definisi pin dan tipe sensor
#define DHT_PIN 4        // GPIO4 terhubung ke pin DATA sensor
#define DHT_TYPE DHT11   // Ganti ke DHT22 jika pakai DHT22

// Inisialisasi objek sensor
DHT sensorSuhu(DHT_PIN, DHT_TYPE);

// =============================================
// Program Membaca Suhu & Kelembaban DHT11/DHT22
// BeebaneLabs - https://beebanelabs.pages.dev
// =============================================

#include "DHT.h"

// === Konfigurasi Sensor ===
#define DHT_PIN   4         // GPIO4 terhubung ke pin DATA
#define DHT_TYPE  DHT11     // Ganti ke DHT22 jika diperlukan
#define LED_PIN   2         // LED internal ESP32 (GPIO2)

// === Interval Pembacaan ===
const unsigned long INTERVAL_BACA = 5000;  // Baca setiap 5 detik

// === Objek Sensor ===
DHT sensorDHT(DHT_PIN, DHT_TYPE);

// === Variabel Penyimpanan ===
float suhuTerkini      = 0.0;
float kelembabanTerkini = 0.0;
float heatIndex         = 0.0;
unsigned long totalPembacaan = 0;
unsigned long totalError     = 0;

// === Fungsi Pembacaan dengan Validasi ===
bool bacaSensor() {
  float s = sensorDHT.readTemperature();      // Celsius
  float h = sensorDHT.readHumidity();         // Persen
  float f = sensorDHT.readTemperature(true);  // Fahrenheit

  // Validasi: cek apakah pembacaan valid
  if (isnan(s) || isnan(h)) {
    totalError++;
    Serial.println("[ERROR] Gagal membaca sensor DHT!");
    Serial.println("  Penyebab: koneksi longgar, resistor belum dipasang, atau sensor rusak.");
    return false;
  }

  suhuTerkini      = s;
  kelembabanTerkini = h;
  heatIndex         = sensorDHT.computeHeatIndex(s, h, false);
  totalPembacaan++;
  return true;
}

// === Fungsi Tampilkan Data ke Serial ===
void tampilkanData() {
  Serial.println("┌────────────────────────────────┐");
  Serial.println("│      Pembacaan Sensor DHT      │");
  Serial.println("├────────────────────────────────┤");
  Serial.print("│ Suhu        : ");
  Serial.print(suhuTerkini, 1);
  Serial.println(" °C        │");
  Serial.print("│ Kelembaban  : ");
  Serial.print(kelembabanTerkini, 1);
  Serial.println(" %          │");
  Serial.print("│ Heat Index  : ");
  Serial.print(heatIndex, 1);
  Serial.println(" °C        │");
  Serial.print("│ Pembacaan # : ");
  Serial.print(totalPembacaan);
  Serial.println("              │");
  Serial.println("└────────────────────────────────┘");
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);

  Serial.println("╔══════════════════════════════════════╗");
  Serial.println("║  Sensor DHT11/DHT22 + ESP32         ║");
  Serial.println("║  BeebaneLabs - https://beebanelabs.pages.dev          ║");
  Serial.println("╚══════════════════════════════════════╝");

  // Mulai sensor
  sensorDHT.begin();
  delay(2000);  // Waktu stabilisasi sensor

  Serial.println("Sensor dimulai. Menunggu pembacaan pertama...");
}

void loop() {
  static unsigned long lastBaca = 0;
  unsigned long sekarang = millis();

  if (sekarang - lastBaca >= INTERVAL_BACA) {
    lastBaca = sekarang;

    if (bacaSensor()) {
      tampilkanData();

      // Kedipkan LED saat pembacaan berhasil
      digitalWrite(LED_PIN, HIGH);
      delay(100);
      digitalWrite(LED_PIN, LOW);
    }
  }
}

// =============================================
// Kalibrasi & Error Handling Sensor DHT
// BeebaneLabs - https://beebanelabs.pages.dev
// =============================================

#include "DHT.h"

#define DHT_PIN   4
#define DHT_TYPE  DHT11

DHT sensorDHT(DHT_PIN, DHT_TYPE);

// === Faktor Kalibrasi ===
// Nilai ini didapatkan dari perbandingan dengan sensor referensi
// Contoh: jika DHT11 membaca 30.5°C tapi referensi menunjuk 29.8°C
//          maka offset_suhu = 29.8 - 30.5 = -0.7
const float OFFSET_SUHU         = -0.7;   // Koreksi suhu (°C)
const float OFFSET_KELEMBABAN   = 2.0;    // Koreksi kelembaban (%)
const float BATAS_SUHU_MIN      = -10.0;  // Batas bawah suhu valid
const float BATAS_SUHU_MAX      = 60.0;   // Batas atas suhu valid
const float BATAS_RH_MIN        = 0.0;    // Batas bawah kelembaban
const float BATAS_RH_MAX        = 100.0;  // Batas atas kelembaban
const int   MAX_ERROR_BERUNTUN  = 5;      // Max error berturut sebelum reset

// === Counter Error ===
int errorBeruntun = 0;

// === Fungsi Kalibrasi ===
float kalibrasiSuhu(float raw) {
  return raw + OFFSET_SUHU;
}

float kalibrasiKelembaban(float raw) {
  float calibrated = raw + OFFSET_KELEMBABAN;
  // Clamp ke rentang valid
  if (calibrated < BATAS_RH_MIN) calibrated = BATAS_RH_MIN;
  if (calibrated > BATAS_RH_MAX) calibrated = BATAS_RH_MAX;
  return calibrated;
}

// === Fungsi Pembacaan dengan Error Handling Lanjut ===
bool bacaSensorLanjut(float* suhu, float* kelembaban) {
  float rawSuhu = sensorDHT.readTemperature();
  float rawRH   = sensorDHT.readHumidity();

  // Error 1: Pembacaan NaN
  if (isnan(rawSuhu) || isnan(rawRH)) {
    errorBeruntun++;
    Serial.printf("[ERROR #%d/%d] NaN diterima dari sensor!\n",
                  errorBeruntun, MAX_ERROR_BERUNTUN);

    if (errorBeruntun >= MAX_ERROR_BERUNTUN) {
      Serial.println("[CRITICAL] Terlalu banyak error berturut. Mencoba reset...");
      sensorDHT.begin();
      delay(3000);
      errorBeruntun = 0;
    }
    return false;
  }

  // Error 2: Nilai di luar rentang fisik
  float calibratedSuhu = kalibrasiSuhu(rawSuhu);
  float calibratedRH   = kalibrasiKelembaban(rawRH);

  if (calibratedSuhu < BATAS_SUHU_MIN || calibratedSuhu > BATAS_SUHU_MAX) {
    errorBeruntun++;
    Serial.printf("[WARN] Suhu %.1f°C di luar rentang valid (%.0f–%.0f°C)\n",
                  calibratedSuhu, BATAS_SUHU_MIN, BATAS_SUHU_MAX);
    return false;
  }

  // Error 3: Kelembaban di luar rentang
  if (calibratedRH < BATAS_RH_MIN || calibratedRH > BATAS_RH_MAX) {
    errorBeruntun++;
    Serial.printf("[WARN] Kelembaban %.1f%% di luar rentang valid\n", calibratedRH);
    return false;
  }

  // Error 4: Perubahan mendadak (sensor terlepas?)
  static float lastSuhu = 0;
  if (lastSuhu != 0 && abs(calibratedSuhu - lastSuhu) > 10.0) {
    Serial.printf("[WARN] Lompatan suhu ekstrem: %.1f → %.1f°C\n",
                  lastSuhu, calibratedSuhu);
    // Tidak return false, tapi catat warning
  }
  lastSuhu = calibratedSuhu;

  // Semua valid
  *suhu       = calibratedSuhu;
  *kelembaban = calibratedRH;
  errorBeruntun = 0;
  return true;
}

void setup() {
  Serial.begin(115200);
  Serial.println("=== Sistem Kalibrasi DHT ===");
  sensorDHT.begin();
  delay(2000);

  Serial.printf("Offset Suhu       : %.1f°C\n", OFFSET_SUHU);
  Serial.printf("Offset Kelembaban : %.1f%%\n", OFFSET_KELEMBABAN);
  Serial.printf("Rentang Suhu      : %.0f ~ %.0f°C\n", BATAS_SUHU_MIN, BATAS_SUHU_MAX);
}

void loop() {
  static unsigned long lastBaca = 0;
  if (millis() - lastBaca > 5000) {
    lastBaca = millis();

    float suhu, kelembaban;
    if (bacaSensorLanjut(&suhu, &kelembaban)) {
      Serial.printf("[OK] Suhu: %.1f°C | RH: %.1f%%\n", suhu, kelembaban);
    }
  }
}

// =============================================
// Menyimpan Data Sensor ke EEPROM ESP32
// BeebaneLabs - https://beebanelabs.pages.dev
// =============================================

#include "DHT.h"
#include <EEPROM.h>

#define DHT_PIN   4
#define DHT_TYPE  DHT11

DHT sensorDHT(DHT_PIN, DHT_TYPE);

// === Struktur Data untuk Disimpan ===
struct DataSensor {
  float suhu;
  float kelembaban;
  unsigned long timestamp;  // millis() sebagai timestamp
  bool valid;               // Flag validitas data
};

// === Konfigurasi Penyimpanan ===
const int EEPROM_SIZE    = 4096;
const int ALAMAT_AWAL    = 0;    // Alamat awal penyimpanan
const int MAX_RECORDS    = 40;   // Max record (4096 / sizeof(DataSensor))
const int ALAMAT_COUNTER = 4000; // Alamat counter record

int jumlahRecord = 0;

void setup() {
  Serial.begin(115200);
  EEPROM.begin(EEPROM_SIZE);

  Serial.println("=== Data Logging ke EEPROM ===");
  sensorDHT.begin();
  delay(2000);

  // Baca jumlah record yang tersimpan
  jumlahRecord = EEPROM.read(ALAMAT_COUNTER);
  if (jumlahRecord > MAX_RECORDS) {
    Serial.println("[INFO] EEPROM penuh. Menimpa dari awal.");
    jumlahRecord = 0;
  }
  Serial.printf("Record tersimpan: %d / %d\n", jumlahRecord, MAX_RECORDS);
}

// === Simpan Data ke EEPROM ===
void simpanData(float suhu, float kelembaban) {
  if (jumlahRecord >= MAX_RECORDS) {
    Serial.println("[WARN] EEPROM penuh! Data baru tidak disimpan.");
    return;
  }

  DataSensor data;
  data.suhu       = suhu;
  data.kelembaban = kelembaban;
  data.timestamp  = millis();
  data.valid      = true;

  // Hitung alamat penyimpanan
  int alamat = ALAMAT_AWAL + (jumlahRecord * sizeof(DataSensor));

  // Tulis data ke EEPROM
  EEPROM.put(alamat, data);
  EEPROM.write(ALAMAT_COUNTER, jumlahRecord + 1);
  EEPROM.commit();  // Wajib untuk ESP32!

  jumlahRecord++;
  Serial.printf("[EEPROM] Data #%d disimpan di alamat %d\n", jumlahRecord, alamat);
}

// === Baca Data dari EEPROM ===
void bacaSemuaData() {
  Serial.printf("\n=== Total %d Record di EEPROM ===\n", jumlahRecord);
  for (int i = 0; i < jumlahRecord; i++) {
    DataSensor data;
    int alamat = ALAMAT_AWAL + (i * sizeof(DataSensor));
    EEPROM.get(alamat, data);

    if (data.valid) {
      Serial.printf("#%d | %.1f°C | %.1f%% | %lu ms\n",
                    i + 1, data.suhu, data.kelembaban, data.timestamp);
    }
  }
}

void loop() {
  static unsigned long lastSimpan = 0;

  if (millis() - lastSimpan > 10000) {  // Simpan setiap 10 detik
    lastSimpan = millis();

    float suhu = sensorDHT.readTemperature();
    float kelembaban = sensorDHT.readHumidity();

    if (!isnan(suhu) && !isnan(kelembaban)) {
      simpanData(suhu, kelembaban);

      // Setiap 5 record, tampilkan semua data
      if (jumlahRecord % 5 == 0) {
        bacaSemuaData();
      }
    }
  }
}

// =============================================
// Menyimpan Data Sensor ke SD Card sebagai CSV
// BeebaneLabs - https://beebanelabs.pages.dev
// =============================================

#include "DHT.h"
#include <SPI.h>
#include <SD.h>

#define DHT_PIN   4
#define DHT_TYPE  DHT11
#define SD_CS_PIN 5   // GPIO5 sebagai Chip Select

DHT sensorDHT(DHT_PIN, DHT_TYPE);
const char* NAMA_FILE = "/sensor_log.csv";

// === Inisialisasi SD Card ===
bool mulaiSDCard() {
  if (!SD.begin(SD_CS_PIN)) {
    Serial.println("[ERROR] SD Card gagal dimulai!");
    return false;
  }
  Serial.printf("SD Card: Tipe=%d, Kapasitas=%llu bytes\n",
                SD.cardType(), SD.cardSize());
  return true;
}

// === Tulis Header CSV ===
void tulisHeader() {
  File file = SD.open(NAMA_FILE, FILE_APPEND);
  if (file) {
    // Tulis header hanya jika file baru
    if (file.size() == 0) {
      file.println("nomor,suhu_c,kelembaban_persen,heat_index,millis,uptime_detik");
      Serial.println("[SD] Header CSV ditulis.");
    }
    file.close();
  }
}

// === Tulis Data Baru ===
void tulisDataCSV(float suhu, float kelembaban, float heatIndex) {
  File file = SD.open(NAMA_FILE, FILE_APPEND);
  if (file) {
    // Hitung nomor baris berdasarkan ukuran file
    int nomorBaris = file.size() / 50;  // Estimasi kasar

    // Format CSV: nomor,suhu,kelembaban,heat_index,millis,uptime
    file.printf("%d,%.2f,%.2f,%.2f,%lu,%lu\n",
                nomorBaris + 1, suhu, kelembaban, heatIndex,
                millis(), millis() / 1000);
    file.close();

    Serial.printf("[SD] Baris #%d ditulis: %.1f°C, %.1f%%\n",
                  nomorBaris + 1, suhu, kelembaban);
  } else {
    Serial.println("[ERROR] Gagal menulis ke SD Card!");
  }
}

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

  Serial.println("=== Data Logging ke SD Card ===");
  delay(2000);

  if (mulaiSDCard()) {
    tulisHeader();
    Serial.println("[OK] SD Card siap untuk logging.");
  }
}

void loop() {
  static unsigned long lastTulis = 0;

  if (millis() - lastTulis > 15000) {  // Tulis setiap 15 detik
    lastTulis = millis();

    float suhu = sensorDHT.readTemperature();
    float kelembaban = sensorDHT.readHumidity();

    if (!isnan(suhu) && !isnan(kelembaban)) {
      float heatIndex = sensorDHT.computeHeatIndex(suhu, kelembaban, false);
      tulisDataCSV(suhu, kelembaban, heatIndex);
    }
  }
}

// =============================================
// Proyek: DHT Sensor + MQTT + Web Dashboard
// BeebaneLabs - https://beebanelabs.pages.dev
// =============================================

#include "WiFi.h"
#include "PubSubClient.h"
#include "DHT.h"

// === Konfigurasi WiFi ===
const char* WIFI_SSID = "NamaWiFiAnda";
const char* WIFI_PASS = "PasswordWiFi";

// === Konfigurasi MQTT ===
const char* MQTT_SERVER   = "test.mosquitto.org";
const int   MQTT_PORT     = 1883;
const char* TOPIC_DATA    = "iothub/project/dht/data";
const char* TOPIC_STATUS  = "iothub/project/dht/status";
const char* CLIENT_ID     = "esp32_dht_dashboard_01";

// === Konfigurasi Sensor ===
#define DHT_PIN  4
#define DHT_TYPE DHT11
#define LED_PIN  2

// === Objek ===
DHT sensorDHT(DHT_PIN, DHT_TYPE);
WiFiClient espClient;
PubSubClient mqtt(espClient);

// === Interval ===
const unsigned long INTERVAL_KIRIM = 10000;  // 10 detik
unsigned long lastKirim = 0;
int msgCount = 0;

// === Koneksi WiFi ===
void setupWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  Serial.print("WiFi: Menghubungkan");
  int attempt = 0;

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    if (++attempt > 40) {
      Serial.println(" GAGAL! Restart...");
      ESP.restart();
    }
  }

  Serial.printf(" OK! IP: %s\n", WiFi.localIP().toString().c_str());
}

// === Koneksi MQTT ===
void hubungkanMQTT() {
  while (!mqtt.connected()) {
    Serial.print("MQTT: Menghubungkan...");
    if (mqtt.connect(CLIENT_ID)) {
      Serial.println(" OK!");
      mqtt.publish(TOPIC_STATUS, "{\"status\":\"online\"}", true);
    } else {
      Serial.printf(" GAGAL (rc=%d). Coba lagi 3s...\n", mqtt.state());
      delay(3000);
    }
  }
}

// === Kirim Data sebagai JSON ===
void kirimData() {
  float suhu       = sensorDHT.readTemperature();
  float kelembaban = sensorDHT.readHumidity();

  if (isnan(suhu) || isnan(kelembaban)) {
    Serial.println("[ERROR] Sensor gagal membaca!");
    return;
  }

  float heatIndex = sensorDHT.computeHeatIndex(suhu, kelembaban, false);

  // Format JSON
  char payload[256];
  snprintf(payload, sizeof(payload),
    "{"
    "\"suhu\":%.1f,"
    "\"kelembaban\":%.1f,"
    "\"heat_index\":%.1f,"
    "\"rssi\":%d,"
    "\"uptime\":%lu,"
    "\"msg_count\":%d,"
    "\"timestamp\":%lu"
    "}",
    suhu, kelembaban, heatIndex,
    WiFi.RSSI(),
    millis() / 1000,
    msgCount + 1,
    millis()
  );

  if (mqtt.publish(TOPIC_DATA, payload)) {
    msgCount++;
    Serial.printf("[%d] Suhu: %.1f°C | RH: %.1f%% | HI: %.1f°C\n",
                  msgCount, suhu, kelembaban, heatIndex);
    digitalWrite(LED_PIN, HIGH);
    delay(50);
    digitalWrite(LED_PIN, LOW);
  } else {
    Serial.println("[ERROR] Gagal publish ke MQTT!");
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);

  Serial.println("╔═══════════════════════════════════╗");
  Serial.println("║  DHT + MQTT + Dashboard v1.0      ║");
  Serial.println("║  BeebaneLabs - https://beebanelabs.pages.dev        ║");
  Serial.println("╚═══════════════════════════════════╝");

  sensorDHT.begin();
  delay(2000);

  setupWiFi();
  mqtt.setServer(MQTT_SERVER, MQTT_PORT);
  mqtt.setBufferSize(512);
  hubungkanMQTT();
}

void loop() {
  if (!mqtt.connected()) {
    hubungkanMQTT();
  }
  mqtt.loop();

  if (millis() - lastKirim >= INTERVAL_KIRIM) {
    lastKirim = millis();
    kirimData();
  }
}

<!DOCTYPE html>
<html lang="id">
<head>
  <meta charset="UTF-8">
  <title>IoT Dashboard - Monitoring Suhu</title>
  <script src="https://unpkg.com/mqtt/dist/mqtt.min.js"></script>
  <style>
    * { margin: 0; padding: 0; box-sizing: border-box; }
    body { font-family: 'Segoe UI', sans-serif; background: #0f172a; color: #e2e8f0; padding: 20px; }
    h1 { text-align: center; margin-bottom: 20px; color: #38bdf8; }
    .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 16px; max-width: 800px; margin: 0 auto; }
    .card { background: #1e293b; border-radius: 12px; padding: 24px; text-align: center; border: 1px solid #334155; }
    .card .label { font-size: 0.85rem; color: #94a3b8; margin-bottom: 8px; }
    .card .value { font-size: 2.5rem; font-weight: 700; }
    .card .unit { font-size: 0.9rem; color: #64748b; }
    .card.suhu .value { color: #f97316; }
    .card.rh .value { color: #38bdf8; }
    .card.hi .value { color: #ef4444; }
    .card.rssi .value { color: #22c55e; font-size: 1.5rem; }
    #status { text-align: center; margin: 16px 0; font-size: 0.9rem; }
    #status.connected { color: #22c55e; }
    #status.disconnected { color: #ef4444; }
    #log { max-width: 800px; margin: 20px auto; background: #1e293b; border-radius: 8px; padding: 16px; font-family: monospace; font-size: 0.8rem; max-height: 200px; overflow-y: auto; }
  </style>
</head>
<body>
  <h1>🌡️ IoT Dashboard - Real-time Monitoring</h1>
  <p id="status" class="disconnected">🔴 Menunggu koneksi MQTT...</p>

  <div class="grid">
    <div class="card suhu">
      <div class="label">Suhu</div>
      <div class="value" id="suhu">--</div>
      <div class="unit">°C</div>
    </div>
    <div class="card rh">
      <div class="label">Kelembaban</div>
      <div class="value" id="rh">--</div>
      <div class="unit">%</div>
    </div>
    <div class="card hi">
      <div class="label">Heat Index</div>
      <div class="value" id="hi">--</div>
      <div class="unit">°C</div>
    </div>
    <div class="card rssi">
      <div class="label">WiFi Signal</div>
      <div class="value" id="rssi">--</div>
      <div class="unit">dBm</div>
    </div>
  </div>

  <div id="log"><div>⏳ Menunggu data...</div></div>

  <script>
    const broker = "wss://test.mosquitto.org:8081/mqtt";
    const topic  = "iothub/project/dht/data";

    const client = mqtt.connect(broker);
    const logEl  = document.getElementById("log");

    client.on("connect", () => {
      document.getElementById("status").textContent = "🟢 Terhubung ke MQTT Broker";
      document.getElementById("status").className = "connected";
      client.subscribe(topic);
    });

    client.on("message", (t, msg) => {
      const data = JSON.parse(msg.toString());
      document.getElementById("suhu").textContent = data.suhu.toFixed(1);
      document.getElementById("rh").textContent   = data.kelembaban.toFixed(1);
      document.getElementById("hi").textContent    = data.heat_index.toFixed(1);
      document.getElementById("rssi").textContent  = data.rssi;

      const line = document.createElement("div");
      line.textContent = `[${new Date().toLocaleTimeString()}] Suhu: ${data.suhu}°C | RH: ${data.kelembaban}%`;
      logEl.appendChild(line);
      logEl.scrollTop = logEl.scrollHeight;
    });

    client.on("error", (err) => {
      document.getElementById("status").textContent = "🔴 Error: " + err.message;
      document.getElementById("status").className = "disconnected";
    });
  </script>
</body>
</html>