บทความ: ESP32 Energy Harvesting พร้อม Supercapacitor - สร้าง IoT Device แบบไม่ต้องใช้แบตเตอรี่

เรียนรู้วิธีสร้างอุปกรณ์ IoT ที่ทำงานได้โดยไม่ต้องใช้แบตเตอรี่ ด้วยการรวมเทคนิค Deep Sleep ของ ESP32 กับพลังงานจากแสงอาทิตย์และ Supercapacitor สำหรับการจัดเก็บพลังงานที่ยั่งยืนและประหยัดค่าใช้จ่าย

📅 24 มีนาคม 2026⏱️ 15 นาที🎯 ระดับกลาง

ภาพรวม

การสร้างอุปกรณ์ IoT ที่ทำงานต่อเนื่องหลายวันหรือหลายเดือนโดยไม่ต้องใช้แบตเตอรี่ เป็นความท้าทายที่น่าสนใจและมีประโยชน์อย่างมาก บทความนี้จะแนะนำวิธีการใช้ประโยชน์จากพลังงานแสงอาทิตย์ร่วมกับ Supercapacitor และเทคนิค Deep Sleep ของ ESP32 เพื่อสร้างระบบ IoT ที่ยั่งยืนและประหยัดค่าใช้จ่าย

แนวคิดคือการใช้ Solar Panel เพื่อเก็บพลังงานไปยัง Supercapacitor แทนแบตเตอรี่ Li-ion แบบดั้งเดิม และใช้ ESP32 ในโหมด Deep Sleep เพื่อลดการใช้พลังงานให้เหลือน้อยที่สุด เมื่อมีพลังงานเพียงพอ ESP32 จะตื่นขึ้นมาทำงาน ส่งข้อมูล และกลับเข้าสู่โหมด Sleep อีกครั้ง

ข้อกำหนดเบื้องต้น

Hardware

  • ESP32 Board แนะนำ ESP32-WROOM-32 หรือ ESP32-S2 ที่มีโหมด Deep Sleep
  • Solar Panel 5V-6V ขนาด 1W-3W (แนะนำแบบมี USB output)
  • Supercapacitor 1F-10F ที่ 5.5V (แนะนำ 5.5V 1F ขึ้นไป)
  • Diode 1N5819 (Schottky Diode) สำหรับป้องกันกระแสย้อนกลับ
  • Resistor 100Ω-1kΩ สำหรับจำกัดกระแสชาร์จ
  • Breadboard และ Jumper wires สำหรับต่อวงจร

Software

  • Arduino IDE พร้อม ESP32 Board Support
  • Library: Deep Sleep, WiFi, MQTT (ถ้าต้องการส่งข้อมูล)
  • CynoIoT Account สำหรับเก็บข้อมูล (ฟรี)

ความรู้พื้นฐาน

  • การเขียนโปรแกรม ESP32 ขั้นพื้นฐาน
  • ความเข้าใจเรื่องวงจรไฟฟ้าเบื้องต้น
  • ความรู้เรื่อง Deep Sleep Mode

Energy Harvesting คืออะไร?

Energy Harvesting คือกระบวนการเก็บเกี่ยวพลังงานจากแหล่งพลังงานรอบตัว เช่น แสงอาทิตย์ ความร้อน การสั่นสะเทือน หรือคลื่นวิทยุ แล้วนำมาใช้เป็นพลังงานไฟฟ้าสำหรับขับเคลื่อนอุปกรณ์อิเล็กทรอนิกส์ ในบทความนี้เราจะเน้นที่พลังงานจากแสงอาทิตย์เพราะเป็นแหล่งพลังงานที่เข้าถึงง่ายและใช้งานได้จริง

💡 ข้อดีของ Energy Harvesting

  • ไม่ต้องเปลี่ยนแบตเตอรี่ ประหยัดค่าใช้จ่ายระยะยาว
  • เป็นมิตรกับสิ่งแวดล้อม ลดขยะจากแบตเตอรี่
  • ติดตั้งง่าย ไม่ต้องดูแลรักษาบ่อย
  • เหมาะกับสถานที่ที่เข้าถึงยาก

Supercapacitor คืออะไร?

Supercapacitor (หรือ Ultracapacitor) เป็นอุปกรณ์เก็บประจุไฟฟ้าที่มีความจุสูงกว่าแบตเตอรี่ปกติหลายพันเท่า แต่มีแรงดันไฟฟ้าต่ำกว่า ข้อดีคือชาร์จได้เร็วมาก ทนทานต่อการชาร์จ-ปล่อยซ้ำๆ ได้หลายแสนครั้ง และมีอายุการใช้งานยาวนานกว่าแบตเตอรี่ Li-ion

เปรียบเทียบ Supercapacitor vs Battery

คุณสมบัติSupercapacitorLi-ion Battery
ความจุต่ำสูง
เวลาชาร์จวินาทีชั่วโมง
จำนวนรอบชาร์จ-ปล่อย100,000+ รอบ500-1,000 รอบ
อายุการใช้งาน10-20 ปี2-5 ปี

การต่อวงจร Hardware

วงจรพื้นฐาน

การต่อวงจร Energy Harvesting อย่างง่ายประกอบด้วย:

  1. Solar Panel ส่งกระแสไฟฟ้าเข้ามา
  2. Schottky Diode ป้องกันกระแสย้อนกลับ
  3. Resistor จำกัดกระแสชาร์จ Supercapacitor
  4. Supercapacitor เก็บพลังงาน
  5. ESP32 ใช้พลังงานจาก Supercapacitor

ตัวอย่างการต่อวงจร

// การต่อสายไฟ
// Solar Panel (+) → Diode (A→K) → Resistor (100Ω) → Supercapacitor (+)
// Supercapacitor (-) → Solar Panel (-)

// Supercapacitor (+) → ESP32 VIN หรือ 3.3V
// Supercapacitor (-) → ESP32 GND

// หมายเหตุ:
// - Diode 1N5819: แถบบน A (Anode), แถบล่าง K (Cathode)
// - ใช้ Resistor 100Ω สำหรับ Supercapacitor 1F
// - ใช้ Resistor 1kΩ สำหรับ Supercapacitor 10F เพื่อลดกระแสชาร์จ

⚠️ ข้อควรระวัง

  • อย่าใช้ Solar Panel ที่มีแรงดันเกิน 6V เพราะอาจทำลาย ESP32
  • ตรวจสอบขั้วของ Diode ให้ถูกต้องก่อนต่อวงจร
  • Supercapacitor มีขั้วบวก/ลบชัดเจน ต่อผิดอาจทำให้ระเบิดได้
  • ควรใส่กันชน (Protection Circuit) สำหรับการใช้งานจริง

การเขียนโปรแกรม

ตัวอย่างโค้ดพื้นฐาน - Deep Sleep พร้อม Measurement

#include <WiFi.h>
#include <HTTPClient.h>

// ตั้งค่า WiFi
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";

// ตั้งค่า CynoIoT API
const char* serverUrl = "https://api.cynoiot.com/v1/sensor/data";
const char* apiKey = "YOUR_API_KEY";

// ตั้งค่า Deep Sleep (microseconds)
// 5 นาที = 300,000,000 microseconds
#define SLEEP_TIME 300e6

// ขา Analog สำหรับวัดแรงดัน Supercapacitor
#define VOLTAGE_PIN 35

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

  Serial.println("=== ESP32 Energy Harvesting System ===");
  Serial.println("ตื่นจาก Deep Sleep");

  // วัดแรงดัน Supercapacitor
  float voltage = readVoltage();
  Serial.printf("แรงดัน Supercapacitor: %.2fV\n", voltage);

  // เช็คว่าแรงดันเพียงพอหรือไม่
  if (voltage < 2.5) {
    Serial.println("แรงดันต่ำเกินไป กลับเข้า Sleep");
    goToSleep();
    return;
  }

  // เชื่อมต่อ WiFi และส่งข้อมูล
  if (connectWiFi()) {
    sendData(voltage);
  }

  // เข้าสู่โหมด Deep Sleep
  goToSleep();
}

void loop() {
  // ไม่ต้องใช้ loop() เพราะใช้ Deep Sleep
}

// ฟังก์ชันวัดแรงดัน Supercapacitor
float readVoltage() {
  int adcValue = analogRead(VOLTAGE_PIN);
  // แปลงค่า ADC เป็นแรงดัน (ESP32 ADC 12-bit = 0-4095)
  // ใช้ Voltage Divider ถ้าจำเป็น
  float voltage = (adcValue / 4095.0) * 3.3 * 2.0; // คูณ 2 สำหรับ Voltage Divider
  return voltage;
}

// ฟังก์ชันเชื่อมต่อ WiFi
bool connectWiFi() {
  Serial.print("เชื่อมต่อ WiFi");
  WiFi.begin(ssid, password);

  int attempts = 0;
  while (WiFi.status() != WL_CONNECTED && attempts < 20) {
    delay(500);
    Serial.print(".");
    attempts++;
  }

  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\nเชื่อมต่อ WiFi สำเร็จ!");
    Serial.printf("IP: %s\n", WiFi.localIP().toString().c_str());
    return true;
  } else {
    Serial.println("\nเชื่อมต่อ WiFi ล้มเหลว");
    return false;
  }
}

// ฟังก์ชันส่งข้อมูลไป CynoIoT
void sendData(float voltage) {
  HTTPClient http;
  http.begin(serverUrl);
  http.addHeader("Content-Type", "application/json");
  http.addHeader("Authorization", apiKey);

  // สร้าง JSON payload
  String payload = "{\"device\":\"esp32_energy_harvester\",\"voltage\":";
  payload += String(voltage, 2);
  payload += ",\"battery_level\":";
  payload += String((voltage / 5.0) * 100); // เปอร์เซ็นต์แบตเตอรี่โดยประมาณ
  payload += "}";

  Serial.printf("ส่งข้อมูล: %s\n", payload.c_str());

  int httpResponseCode = http.POST(payload);

  if (httpResponseCode > 0) {
    Serial.printf("HTTP Response: %d\n", httpResponseCode);
    String response = http.getString();
    Serial.println(response);
  } else {
    Serial.printf("Error: %s\n", http.errorToString(httpResponseCode).c_str());
  }

  http.end();
}

// ฟังก์ชันเข้าสู่โหมด Deep Sleep
void goToSleep() {
  Serial.println("เข้าสู่โหมด Deep Sleep");
  Serial.printf("จะตื่นใน %.1f นาที\n", SLEEP_TIME / 60e6);

  // ตั้งเวลาตื่นด้วย Timer
  esp_sleep_enable_timer_wakeup(SLEEP_TIME);

  // เข้าสู่โหมด Deep Sleep
  esp_deep_sleep_start();
}

คำอธิบายโค้ด

  • readVoltage() - วัดแรงดัน Supercapacitor เพื่อเช็คว่ามีพลังงานเพียงพอหรือไม่
  • connectWiFi() - เชื่อมต่อ WiFi พร้อม timeout 20 วินาที
  • sendData() - ส่งข้อมูลไปยัง CynoIoT Platform
  • goToSleep() - เข้าสู่โหมด Deep Sleep เพื่อประหยัดพลังงาน

การปรับแต่งประสิทธิภาพ

เทคนิคการประหยัดพลังงาน

1. ปิด WiFi เมื่อไม่ใช้

// ปิด WiFi เพื่อประหยัดพลังงาน
WiFi.mode(WIFI_OFF);
btStop(); // ปิด Bluetooth ถ้าไม่ใช้

// เปิด WiFi เมื่อต้องการ
WiFi.mode(WIFI_STA);

2. ลดความเร็ว CPU

#include "esp_wifi.h"

// ลดความเร็ว CPU จาก 240MHz เป็น 80MHz
setCpuFrequencyMhz(80);

// หรือ 160MHz สำหรับงานที่ต้องการประสิทธิภาพมากกว่า
setCpuFrequencyMhz(160);

3. ใช้ External Wake Up

// ตื่นด้วย Timer หรือ External Interrupt
esp_sleep_enable_timer_wakeup(SLEEP_TIME);
esp_sleep_enable_ext0_wakeup(GPIO_NUM_4, 1); // ตื่นเมื่อ GPIO 4 เป็น HIGH

การคำนวณระยะเวลาทำงาน

เพื่อคาดการณ์ว่าระบบจะทำงานได้นานเท่าไรในเงื่อนไขแสงน้อย สามารถคำนวณได้จาก:

  • ปริมาณพลังงานที่เก็บได้ = 0.5 × C × V²
  • พลังงานที่ใช้ต่อรอบ = กระแสเฉลี่ย × เวลาทำงาน
  • จำนวนรอบที่ทำได้ = พลังงานที่เก็บได้ ÷ พลังงานที่ใช้ต่อรอบ

✅ ตัวอย่างคำนวณ

ถ้ามี Supercapacitor 5.5V 1F และ ESP32 ใช้ 100mA เมื่อตื่น 10 วินาที: พลังงานที่เก็บได้ = 0.5 × 1 × 5.5² = 15.125 Joules
พลังงานที่ใช้ต่อรอบ = 0.1A × 10s = 1 Joule
จำนวนรอบ ≈ 15 รอบ → ทำงานได้ 15 รอบ = 75 นาที (โดยไม่มีแสง)

ปัญหาที่พบบ่อยและวิธีแก้ไข

❌ ปัญหา: ESP32 ตื่นแล้วรีเซ็ตทันที

สาเหตุ: แรงดันต่ำเกินไป

วิธีแก้: เพิ่มขนาด Supercapacitor หรือเพิ่มขนาด Solar Panel

❌ ปัญหา: ไม่สามารถเชื่อมต่อ WiFi ได้

สาเหตุ: พลังงานไม่เพียงพอสำหรับ WiFi

วิธีแก้: เพิ่มเวลา Sleep ให้นานขึ้น (10-15 นาที)

❌ ปัญหา: ข้อมูลไม่ถูกส่งไป CynoIoT

สาเหตุ: Network timeout หรือ API Key ผิด

วิธีแก้: ตรวจสอบ API Key และเพิ่ม timeout

สรุป

ในบทความนี้เราได้เรียนรู้วิธีสร้างระบบ IoT ที่ทำงานได้โดยไม่ต้องใช้แบตเตอรี่ ด้วยการใช้ประโยชน์จากพลังงานแสงอาทิตย์และ Supercapacitor ร่วมกับเทคนิค Deep Sleep ของ ESP32 ระบบนี้เหมาะสำหรับการติดตั้งในสถานที่ที่เข้าถึงยาก หรือที่ต้องการระบบที่ไม่ต้องดูแลรักษาบ่อย

แนวคิดนี้สามารถนำไปประยุกต์ใช้กับโปรเจกต์อื่นๆ ได้ เช่น ระบบวัดอุณหภูมิและความชื้น ระบบตรวจจับการรั่วไหลของน้ำ หรือระบบเซ็นเซอร์อัจฉริยะอื่นๆ ที่ต้องการทำงานต่อเนื่องและประหยัดพลังงาน

ถัดไป