ข้อจำกัดของ Web Server บน ESP32

ข้อจำกัดของ Web Server (ระบบภายในบ้าน/วิทยาลัย)

• Local Access Only เราจะเข้าถึงได้เฉพาะอุปกรณ์ที่ต่อ Wi-Fi หรืออินเทอร์เน็ตเดียวเดียวกัน
• IP Address ที่เราเห็นบนจอ OLED เป็นแค่เลขที่จำลองภายในวิทยาลัยเท่านั้น คนภายนอกไม่สามารถใช้งานได้
• The Security Wall เรามีสิ่งที่เรียกว่า Router คอยทำหน้าที่เป็น รปภ. ซึ่งจะยอมให้คนข้างในออกไปข้างนอกได้ แต่ห้ามคนข้างนอกแปลกหน้าแอบเข้ามาข้างในเด็ดขาด นี่คือเหตุผลว่าทำไมเวลาที่เราอยู่บ้านถึงกดเข้าหน้าเว็บ ESP32 ที่วิทยาลัยไม่ได้

ความเทพของ Blynk.Console (ระบบ Cloud)

• Blynk ทำหน้าที่เป็นคนกลาง (Meeting Point) ที่ตั้งอยู่บนอินเทอร์เน็ต
• ESP32 จะไม่ได้รอให้คนกดเข้ามาหา แต่มันจะเป็นฝ่ายออกไปรายงานตัวกับ Blynk Server เอง
• Anywhere, Anytime: เมื่อทั้ง “มือถือ” และ “ESP32” ต่างวิ่งไปเจอกันที่ Blynk Server เราจึงสามารถสั่งงานบอร์ดได้จากทุกที่ที่มีอินเทอร์เน็ต ไม่ว่าจะอยู่คนละจังหวัด หรือคนละประเทศครับ

ตารางสรุปเปรียบเทียบ

อธิบายด้วยเรื่องสั้น

ลองนึกภาพว่า ESP32 ของเราคือ เด็กที่ติดอยู่ในบ้าน (Web Server) ถ้าแม่ไม่อยู่บ้าน แม่จะบอกให้ทำสิ่งต่างๆไม่ได้เลย แต่ถ้าเราพาเด็กคนนี้ไปฝากไว้ที่ศูนย์รับฝากเด็ก (Blynk Server) ไม่ว่าแม่จะอยู่ที่ไหน ก็สามารถโทรไปบอกที่ศูนย์ฯ ให้เด็กทำสิ่งต่างๆได้ตลอดเวลา

สิ่งที่ต้องมีก่อนเริ่มใช้งาน Blynk

หลังจากที่เราได้ลองควบคุมไฟจราจรผ่านหน้าเว็บ (Web Server) กันไปแล้ว นักศึกษาคงเห็นข้อจำกัดสำคัญหนึ่งอย่าง “ถ้าเราเดินออกจากวิทยาลัย เราจะสั่งงานบอร์ดไม่ได้เลย” เพราะระบบนั้นทำงานอยู่แค่ในวง Wi-Fi เดียวกันเท่านั้น

แต่ในโลกของการทำ Smart Farm ของจริง เกษตรกรต้องสามารถเปิดปั๊มน้ำหรือดูความชื้นดินได้จากทุกที่บนโลก 🌍

ดังนั้น เราจะอัปเกรดทักษะกันด้วยการใช้ Blynk IoT (Cloud Platform) ซึ่งทำหน้าที่เหมือนเป็นคนกลางบนอินเทอร์เน็ต ให้บอร์ด ESP32 และมือถือของเรามาคุยกันได้ตลอดเวลา ไม่ว่าจะอยู่ห่างกันแค่ไหนก็ตาม

✉️ 1. อีเมลส่วนตัว

Blynk เป็นระบบคลาวด์ที่มีความปลอดภัยสูง การจะเข้าไปสร้าง Dashboard ได้ เราต้องมีบัญชีนักพัฒนาก่อน

• สิ่งที่ต้องทำ ให้เข้าไปที่เว็บไซต์ blynk.cloud แล้วทำการสมัครสมาชิก
• ข้อควรระวัง ใช้อีเมลที่ตัวเองสามารถล็อกอินเข้าไปกดปุ่มยืนยัน (Verify) ได้เท่านั้น หลายคนชอบลืมรหัสผ่านอีเมลตัวเอง เช็คให้ชัวร์ก่อนนะ

📱 2. สมาร์ทโฟนพร้อมแอปพลิเคชัน Blynk IoT

ไฮไลต์ของ Blynk คือเราไม่ต้องมานั่งเขียนแอปพลิเคชันมือถือเองตั้งแต่ศูนย์ เขามีแอปสำเร็จรูปให้เราลากปุ่ม ลากกราฟ มาวางได้เลยง่ายๆ

• สิ่งที่ต้องทำ หยิบสมาร์ทโฟนขึ้นมา เข้าไปที่ App Store (iOS) หรือ Google Play Store (Android)
• ค้นหาคำว่า “Blynk IoT” (สังเกตไอคอน B สีเหลือง)
• โหลดเสร็จแล้ว ให้ล็อกอินด้วยอีเมลเดียวกับที่สมัครในเว็บไซต์ให้เรียบร้อย

บทที่ 1 การเริ่มต้นใช้งานแพลตฟอร์ม Blynk สำหรับระบบ Smart Farm

ก่อนที่จะเริ่มเขียนโปรแกรมควบคุม ESP32 และต่อวงจรปั๊มน้ำ นักศึกษาจำเป็นต้องตั้งค่าระบบบนเว็บไซต์ Blynk.Console เพื่อสร้างโครงสร้างโปรเจกต์และรับรหัสยืนยันตัวตน (Auth Token) สำหรับเชื่อมต่ออุปกรณ์ โดยมีขั้นตอนปฏิบัติดังนี้

ส่วนที่ 1 การสร้าง Template (โครงสร้างโปรเจกต์)

Template คือ โครงสร้างพื้นฐานของโปรเจกต์ที่ใช้กำหนดรูปแบบการทำงาน หากมีชุดสมาร์ทฟาร์มหลายชุดในห้องเรียน สามารถใช้ Template นี้ร่วมกันได้

ขั้นตอนการปฏิบัติ

1. เข้าสู่ระบบ blynk.cloud ผ่านเว็บเบราว์เซอร์
2. สังเกตแถบเมนูด้านซ้าย เลือกเมนู Developer Zone > My Templates
3. คลิกปุ่ม + New Template (มุมขวาบน)
4. กรอกข้อมูลเบื้องต้นดังนี้:
   • Name: Smart Farm System
   • Hardware: เลือก ESP32
   • Connection Type: เลือก WiFi
5. คลิกปุ่ม Done เพื่อยืนยันการสร้าง

ส่วนที่ 2 การสร้าง Datastreams ช่องทางส่งข้อมูล

Datastream หรือ Virtual Pin (V-Pin) คือ ช่องทางการสื่อสารข้อมูลแบบเสมือนจริง ในโปรเจกต์นี้เราต้องการ 2 ช่องทาง คือ ส่งค่าความชื้นดินไปแสดงผลและรับคำสั่งเปิด-ปิดรีเลย์ปั๊มน้ำ

ขั้นตอนการปฏิบัติ

1. ในหน้า Template ที่สร้างไว้ ให้คลิกที่แท็บ Datastreams
2. คลิกปุ่ม + New Datastream แล้วเลือก Virtual Pin
3. ตั้งค่า V-Pin ที่ 1 (สำหรับอ่านค่าความชื้นดิน – สัมพันธ์กับ GPIO 34)
   • Name: Soil Moisture
   • PIN: V0
   • Data Type: Integer (เลขจำนวนเต็ม)
   • MIN / MAX: 0 / 100 (คิดเป็นเปอร์เซ็นต์ความชื้น 0-100%)
   • คลิก Create
4. ตั้งค่า V-Pin ที่ 2 (สำหรับปุ่มกดปั๊มน้ำ – สัมพันธ์กับ GPIO 13)
   • คลิก + New Datastream > Virtual Pin อีกครั้ง
   • Name: Pump Control
   • PIN: V1
   • Data Type: Integer
   • MIN / MAX: 0 / 1 (0 = ปิดปั๊ม, 1 = เปิดปั๊ม)
   • คลิก Create
5. ข้อควรระวัง เมื่อสร้างครบ 2 ขาแล้ว ต้องคลิกปุ่ม Save ที่มุมขวาบนของหน้าจอเสมอเพื่อบันทึกการตั้งค่า

ส่วนที่ 3 การเพิ่มอุปกรณ์ (Add Device)

เมื่อกำหนดโครงสร้างผ่าน Template เรียบร้อยแล้ว ขั้นตอนต่อไปคือการสร้างอุปกรณ์ (Device) ขึ้นมาในระบบ เพื่อนำไปผูกกับบอร์ด ESP32 จริง

ขั้นตอนการปฏิบัติ

1. ไปที่แถบเมนูด้านซ้าย เลือกเมนู Devices
2. คลิกปุ่ม + New Device
3. เลือกตัวเลือก From template ในช่อง Template ให้เลือก “Smart Farm System”
4. ในช่อง Device Name ให้ตั้งชื่ออุปกรณ์ตามต้องการ เช่น Node_01
5. คลิก Create

ส่วนที่ 4 การคัดลอกรหัส Auth Token

Auth Token คือ รหัสรักษาความปลอดภัยเฉพาะของอุปกรณ์ (Unique Identifier) ซึ่งจำเป็นอย่างยิ่งในการนำไปใช้เขียนโค้ด เพื่อให้บอร์ด ESP32 สามารถเชื่อมต่อกับเซิร์ฟเวอร์ได้

ขั้นตอนการปฏิบัติ

1. ทันทีที่คลิก Create ในขั้นตอนที่ 3 หน้าต่างข้อมูลอุปกรณ์ “New Device Created!” จะปรากฏขึ้น
2. สังเกตบล็อกข้อความทางขวามือ จะมีโค้ดที่แสดงผลในลักษณะนี้: #define BLYNK_AUTH_TOKEN "รหัสตัวอักษรและตัวเลข..."
3. ให้คลิกปุ่ม Copy to clipboard เพื่อคัดลอกข้อความชุดนี้
4. นำรหัสที่คัดลอกไปวางบันทึกไว้ใน Notepad หรือส่งเข้าแชทส่วนตัว เพื่อเตรียมนำไปแทรกในโค้ด Arduino IDE ในบทเรียนต่อไป (เปิดดูอีกครั้งที่ Developer tools รูปเครื่องมือช่าง > Firmware info)

รายการตรวจสอบความพร้อม (Checklist)

• [ ] สร้าง Template และกำหนด Hardware ESP32 สำเร็จ
• [ ] สร้าง Datastreams (V0 สำหรับความชื้น , V1 สำหรับปั๊ม) พร้อมกดบันทึกแล้ว
• [ ] สร้าง Device จาก Template สำเร็จ
• [ ] บันทึกรหัส Auth Token เรียบร้อยแล้ว

บทที่ 2 การเขียนโปรแกรมควบคุม Smart Farm และเชื่อมต่อ Blynk Cloud

หลังจากเตรียม Template และ Datastreams เรียบร้อยแล้ว ขั้นตอนต่อไปคือการเขียนโปรแกรมลงบนบอร์ด ESP32 เพื่อให้อ่านค่าความชื้นจากดิน (GPIO 34) ส่งขึ้นไปบนคลาวด์ และรับคำสั่งจากคลาวด์มาเปิด-ปิดปั๊มน้ำ (GPIO 13)

ส่วนที่ 1 การติดตั้งไลบรารีที่จำเป็น

ก่อนเริ่มเขียนโปรแกรม จำเป็นต้องติดตั้งชุดคำสั่ง (Library) สำหรับการสื่อสารกับ Blynk

1. เปิดโปรแกรม Arduino IDE
2. ไปที่เมนู Sketch > Include Library > Manage Libraries…
3. ในช่องค้นหา พิมพ์คำว่า Blynk
4. มองหาไลบรารีชื่อ Blynk by Volodymyr Shymanskyy (บลิงก์ บาย โวโลดีเมียร์ ชีมานสกี ผู้ก่อตั้ง Blynk) แล้วคลิก Install

ส่วนที่ 2 โครงสร้างคำสั่งหลักของระบบ Smart Farm

ในการทำงานร่วมกับเซนเซอร์และ Blynk มีหลักการทำงานที่สำคัญดังนี้

1. การใช้ BlynkTimer เพื่อส่งข้อมูล เพื่อป้องกันไม่ให้บอร์ดส่งข้อมูลขึ้นคลาวด์ถี่เกินไปจนระบบรวน (Flood Error) เราจะไม่เขียนคำสั่งส่งข้อมูลไว้ใน loop() โดยตรง แต่จะใช้ฟังก์ชัน BlynkTimer เพื่อตั้งเวลาให้ส่งค่าความชื้นดินทุกๆ 1 วินาที หรือตามที่กำหนด

2. การแปลงค่าอนาล็อก (Calibration) เซนเซอร์วัดความชื้นดินที่ต่อกับขา A0 (GPIO 34) จะอ่านค่าดิบได้ในช่วง 0 ถึง 4095 (บิต) เราจำเป็นต้องใช้ฟังก์ชัน map() เพื่อแปลงค่าเหล่านี้ให้กลายเป็นเปอร์เซ็นต์ (0-100%) เพื่อให้ดูง่ายบนหน้าจอแอปพลิเคชัน

3. การรับคำสั่งควบคุม Relay เมื่อผู้ใช้กดปุ่มเปิดปั๊มบนแอปพลิเคชัน (V1) ระบบจะเรียกใช้ฟังก์ชัน BLYNK_WRITE(V1) อัตโนมัติ เพื่อสั่งเปิด-ปิดกระแสไฟที่ขา GPIO 13

ส่วนที่ 3 ตัวอย่างโค้ดโปรแกรม (Smart Farm System)

ให้นักศึกษาคัดลอกโค้ดด้านล่างไปใช้งาน โดยต้อง แก้ไขบรรทัดที่ 1-3 และ ข้อมูล Wi-Fi ให้เป็นของตนเอง

// 1. ใส่ข้อมูล Blynk (คัดลอกมาจากหน้าเว็บ ต้องอยู่บนสุดเสมอ)
#define BLYNK_TEMPLATE_ID "TMPLxxxxxx"
#define BLYNK_TEMPLATE_NAME "Smart Farm System"
#define BLYNK_AUTH_TOKEN "YourAuthTokenHere"

#include <WiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleEsp32.h>

// 2. ตั้งค่าเครือข่าย Wi-Fi
char ssid[] = "YOUR_WIFI_NAME";
char pass[] = "YOUR_WIFI_PASSWORD";

// 3. กำหนดขาอุปกรณ์ตามวงจรจริง
const int SOIL_PIN = 34;   // ขาสัญญาณเซนเซอร์วัดความชื้นดิน
const int RELAY_PIN = 13;  // ขาควบคุม Relay สำหรับปั๊มน้ำ

// สร้างออบเจกต์ตั้งเวลา
BlynkTimer timer;

// --- ฟังก์ชันรับคำสั่งจากปุ่มบนแอป (V1) เพื่อควบคุมปั๊ม ---
BLYNK_WRITE(V1) {
  int pinValue = param.asInt(); // รับค่าจากปุ่ม (0 หรือ 1)
  
  if (pinValue == 1) {
    digitalWrite(RELAY_PIN, HIGH); // สั่ง Relay ทำงาน (เปิดปั๊ม)
    Serial.println("Pump: ON");
  } else {
    digitalWrite(RELAY_PIN, LOW);  // สั่ง Relay หยุดทำงาน (ปิดปั๊ม)
    Serial.println("Pump: OFF");
  }
}

// --- ฟังก์ชันอ่านค่าความชื้นและส่งขึ้น Blynk (V0) ---
void sendSensor() {
  int soilValue = analogRead(SOIL_PIN); // อ่านค่าดิบจากเซนเซอร์ (0 - 4095)
  
  // แปลงค่าดิบให้เป็นเปอร์เซ็นต์ (0 - 100%)
  // หมายเหตุ: อาจต้องปรับตัวเลข 4095 (แห้งสุด) และ 1000 (เปียกสุด) ตามการทดสอบจริง
  int moisturePercent = map(soilValue, 4095, 1000, 0, 100);
  
  // ป้องกันไม่ให้ค่าเกิน 100% หรือติดลบ
  moisturePercent = constrain(moisturePercent, 0, 100);

  // ส่งค่าไปแสดงผลที่ขา V0 บนแอปพลิเคชัน
  Blynk.virtualWrite(V0, moisturePercent);
  
  // แสดงผลทาง Serial Monitor เพื่อใช้ตรวจสอบ
  Serial.print("Soil Moisture: ");
  Serial.print(moisturePercent);
  Serial.println("%");
}

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

void setup() {
  Serial.begin(115200);
  
  // ตั้งค่าโหมดของขาอุปกรณ์
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW); // ปิดปั๊มน้ำไว้ก่อนเป็นค่าเริ่มต้น
  
  Serial.println("Connecting to Blynk...");
  // เริ่มต้นการเชื่อมต่อ
  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);

  // ตั้งเวลาให้ฟังก์ชัน sendSensor ทำงานทุกๆ 1000 มิลลิวินาที (1 วินาที)
  timer.setInterval(1000L, sendSensor);
}

void loop() {
  // สั่งให้ระบบ Blynk และ Timer ทำงานอย่างต่อเนื่อง
  Blynk.run();
  timer.run();
}

รายการตรวจสอบความพร้อม (Checklist)

• [ ] เปลี่ยน Template ID, Name และ Auth Token เรียบร้อยแล้ว
• [ ] เปลี่ยนชื่อและรหัสผ่าน Wi-Fi เป็นของตนเอง (รองรับ 2.4GHz เท่านั้น)
• [ ] อัปโหลดโค้ดผ่าน Arduino IDE โดยไม่เกิดข้อผิดพลาด
• [ ] เปิด Serial Monitor (Baud Rate 115200) เพื่อตรวจสอบการเชื่อมต่อและการอ่านค่าเปอร์เซ็นต์ความชื้นดิน

บทที่ 3 การสร้างหน้าปัดควบคุม (Dashboard) บนแอปพลิเคชัน Blynk

เมื่อนักศึกษาดำเนินการเขียนโปรแกรมและอัปโหลดโค้ดลงบอร์ด ESP32 เรียบร้อยแล้ว ขั้นตอนต่อไปคือการออกแบบหน้าจอควบคุมบนแอปพลิเคชัน Blynk IoT เพื่อใช้ในการติดตามค่าความชื้นและสั่งการปั๊มน้ำจากระยะไกล

ส่วนที่ 1 การเตรียมความพร้อมบนสมาร์ทโฟน

1. เปิดแอปพลิเคชัน Blynk IoT บนสมาร์ทโฟน
2. ล็อกอินด้วยบัญชีอีเมลเดียวกับที่ใช้ในคอมพิวเตอร์
3. ในหน้าแรก (Devices) นักศึกษาจะพบชื่ออุปกรณ์ที่สร้างไว้ในบทที่ 1 เช่น Node_01 ให้คลิกเข้าไปที่อุปกรณ์นั้น
4. คลิกไอคอน รูปกุญแจ หรือ สัญลักษณ์แก้ไข (Setup Dashboard) เพื่อเข้าสู่โหมดการจัดวาง Widget

ส่วนที่ 2 การสร้าง Widget แสดงผลความชื้นดิน (V0)

เราจะใช้ Gauge (มาตรวัด) เพื่อแสดงเปอร์เซ็นต์ความชื้นดินที่ส่งมาจากเซนเซอร์ (GPIO 34)

ขั้นตอนการปฏิบัติ

1. คลิกปุ่ม + (Add Widget) และเลือก Gauge
2. คลิกที่ตัว Gauge ที่ปรากฏขึ้นเพื่อตั้งค่า (Settings)
   • Title : Soil Moisture
   • DataStream : เลือก Soil Moisture (V0)
   • Design : สามารถเลือกสีของมาตรวัดได้ตามต้องการ เช่น สีฟ้า สีเขียว
3. กดปุ่มย้อนกลับเพื่อบันทึก

ส่วนที่ 3 การสร้าง Widget สั่งการปั๊มน้ำ (V1)

เราจะใช้ Button (ปุ่มกด) เพื่อส่งคำสั่งเปิด-ปิด Relay (GPIO 13)

ขั้นตอนการปฏิบัติ

1. คลิกปุ่ม + (Add Widget) และเลือก Button
2. คลิกที่ตัว Button เพื่อตั้งค่า (Settings)
   • Title : Pump Control
   • DataStream : เลือก Pump Control (V1)
   • Mode : เปลี่ยนจาก Push เป็น Switch เพื่อให้กดหนึ่งครั้งคือเปิดและกดอีกครั้งคือปิด
   • Labels : ตั้งค่าความหมายของสถานะ เช่น Off = ปิดปั๊ม , On = เปิดปั๊ม
3. กดปุ่มย้อนกลับเพื่อบันทึก

ส่วนที่ 4 การทดสอบระบบรวม (System Integration Test)

เมื่อจัดวาง Widget เรียบร้อยแล้ว ให้กดปุ่ม Exit (ปุ่ม Play) เพื่อเริ่มการทำงาน และทำการทดสอบตามหัวข้อดังนี้

1. การตรวจสอบการเชื่อมต่อ สังเกตที่หน้าจอแอปพลิเคชัน หากจุดสถานะเป็นสีเขียว แสดงว่าบอร์ด ESP32 เชื่อมต่ออินเทอร์เน็ตสำเร็จ
2. การทดสอบเซนเซอร์ (V0) นำเซนเซอร์วัดความชื้นดินจุ่มลงในแก้วนหรือดินที่เปียก สังเกตค่า Gauge บนมือถือว่ามีการเปลี่ยนแปลงเพิ่มขึ้นหรือไม่ แล้วนำเซนเซอร์ขึ้นมาเช็ดให้แห้ง สังเกตว่าค่าเปอร์เซ็นต์ลดลงหรือไม่
3. การทดสอบการสั่งงาน (V1) กดปุ่มบนมือถือเพื่อสั่งเปิดปั๊ม สังเกตการทำงานของโมดูล Relay จะมีไฟสถานะติดขึ้นและได้ยินเสียงคลิก สังเกตว่าปั๊มน้ำขนาดเล็กทำงานหรือไม่ แล้วกดปุ่มอีกครั้งเพื่อสั่งปิดปั๊มและตรวจสอบว่าระบบหยุดทำงานตามคำสั่งหรือไม่

สรุปสิ่งที่นักศึกษาได้รับจากโปรเจกต์นี้

• เข้าใจการทำงานของระบบคลาวด์ (Blynk Cloud) และการสื่อสารผ่าน Virtual Pin
• สามารถแปลงค่าสัญญาณอนาล็อกเป็นเปอร์เซ็นต์ที่นำไปใช้งานได้จริง
• สามารถควบคุมอุปกรณ์ไฟฟ้าแรงสูงผ่าน Relay ด้วยแรงดันไฟฟ้าต่ำจากไมโครคอนโทรลเลอร์

บทที่ 4 อัปเกรดระบบตรวจวัดสภาพอากาศด้วยเซนเซอร์ DHT22

ในบทนี้ เราจะทำการติดตั้งเซนเซอร์ DHT22 เพื่อวัดอุณหภูมิและความชื้นในอากาศ จากนั้นส่งข้อมูลขึ้นไปแสดงผลบนแอปพลิเคชัน Blynk ร่วมกับค่าความชื้นดินและปุ่มควบคุมปั๊มน้ำเดิมที่มีอยู่แล้ว

ส่วนที่ 1 การต่อวงจรเซนเซอร์ DHT22

เซนเซอร์ DHT22 โดยทั่วไปจะมี 3 ขา (VCC , DATA , GND) ให้นักศึกษาเชื่อมต่อเข้ากับบอร์ด ESP32 ดังนี้

ส่วนที่ 2 การสร้างช่องทางส่งข้อมูล (Datastreams) เพิ่มเติม

เราต้องสร้างท่อข้อมูลเพิ่มอีก 2 ท่อ เพื่อรองรับตัวเลขความชื้นและอุณหภูมิที่จะส่งมาจากเซนเซอร์ตัวใหม่

ขั้นตอนการปฏิบัติ

1. เข้าสู่ระบบ blynk.cloud และไปที่ Template “Smart Farm System” ของเรา
2. คลิกแท็บ Datastreams และสร้าง Virtual Pin เพิ่มดังนี้
   • สำหรับอุณหภูมิ
     • Name : Temperature
     • PIN : V2
     • Data Type : Double (เพราะอุณหภูมิมีทศนิยม และ Blynk ไม่มีตัวเลือก float แต่ทำงานเข้ากันได้)
     • MIN / MAX : -40 / 80
     • Units : Celsius
   • สำหรับความชื้นในอากาศ
     • Name : Humidity
     • PIN : V3
     • Data Type : Double
     • MIN / MAX : 0 / 100
     • Units : %
3. อย่าลืมกดปุ่ม Save ที่มุมขวาบนสุด

ส่วนที่ 3 การติดตั้งไลบรารีและการเขียนโปรแกรม

เซนเซอร์ DHT22 จำเป็นต้องมีไลบรารีเฉพาะในการถอดรหัสสัญญาณ

การติดตั้งไลบรารี

1. ใน Arduino IDE ไปที่เมนู Sketch > Include Library > Manage Libraries…
2. ค้นหาคำว่า DHT sensor library โดยผู้สร้าง Adafruit แล้วคลิก Install
3. หากระบบถามว่าต้องการติดตั้งไลบรารีที่เกี่ยวข้อง (Dependencies) เช่น Adafruit Unified Sensor ด้วยหรือไม่ ให้ตอบ Install All

โค้ดโปรแกรมฉบับอัปเกรด

// 1. ข้อมูล Blynk (ต้องอยู่บนสุด)
#define BLYNK_TEMPLATE_ID "TMPLxxxxxx"
#define BLYNK_TEMPLATE_NAME "Smart Farm System"
#define BLYNK_AUTH_TOKEN "YourAuthTokenHere"

#include <WiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleEsp32.h>
#include <DHT.h> // 🌟 นำเข้าไลบรารี DHT

// 2. ตั้งค่าเครือข่าย Wi-Fi
char ssid[] = "YOUR_WIFI_NAME";
char pass[] = "YOUR_WIFI_PASSWORD";

// 3. กำหนดขาอุปกรณ์
const int SOIL_PIN = 34;   
const int RELAY_PIN = 13;  
const int DHT_PIN = 4;     // 🌟 ขาสัญญาณเซนเซอร์ DHT22

// 🌟 ตั้งค่าชนิดของเซนเซอร์ (ใช้ DHT22)
#define DHTTYPE DHT22   
DHT dht(DHT_PIN, DHTTYPE);

BlynkTimer timer;

// --- ฟังก์ชันรับคำสั่งควบคุมปั๊มน้ำ (V1) ---
BLYNK_WRITE(V1) {
  int pinValue = param.asInt(); 
  if (pinValue == 1) {
    digitalWrite(RELAY_PIN, HIGH); 
    Serial.println("Pump: ON");
  } else {
    digitalWrite(RELAY_PIN, LOW);  
    Serial.println("Pump: OFF");
  }
}

// --- ฟังก์ชันอ่านค่าเซนเซอร์ทั้งหมดและส่งขึ้น Blynk ---
void sendSensors() {
  // 1. อ่านค่าความชื้นดิน
  int soilValue = analogRead(SOIL_PIN); 
  int moisturePercent = map(soilValue, 4095, 1000, 0, 100);
  moisturePercent = constrain(moisturePercent, 0, 100);
  Blynk.virtualWrite(V0, moisturePercent);
  
  // 2. 🌟 อ่านค่าจาก DHT22
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  // ตรวจสอบว่าเซนเซอร์ทำงานปกติหรือไม่
  if (isnan(h) || isnan(t)) {
    Serial.println("Failed to read from DHT sensor!");
    return;
  }

  // ส่งค่าขึ้น Blynk (V2 และ V3)
  Blynk.virtualWrite(V2, t);
  Blynk.virtualWrite(V3, h);
  
  // แสดงผลทางหน้าจอคอมพิวเตอร์
  Serial.print("Soil: "); Serial.print(moisturePercent); Serial.print("% | ");
  Serial.print("Air Temp: "); Serial.print(t); Serial.print("°C | ");
  Serial.print("Air Humidity: "); Serial.print(h); Serial.println("%");
}

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

void setup() {
  Serial.begin(115200);
  
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW); 
  
  dht.begin(); // 🌟 สั่งให้เซนเซอร์ DHT เริ่มทำงาน

  Serial.println("Connecting to Blynk...");
  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);

  // 🌟 เปลี่ยนเวลาเป็น 2 วินาที (2000L) เพราะ DHT22 ควรอ่านค่าทุกๆ 2 วินาทีเพื่อความแม่นยำ
  timer.setInterval(2000L, sendSensors); 
}

void loop() {
  Blynk.run();
  timer.run();
}

ส่วนที่ 4 การอัปเดตหน้าปัด (Dashboard) บนมือถือ

1. เปิดแอปพลิเคชัน Blynk IoT บนสมาร์ทโฟน
2. เข้าสู่โหมดตั้งค่า (Setup Dashboard)
3. เพิ่ม Widget แบบ Gauge (มาตรวัด) หรือ Labeled Value (กล่องข้อความ) จำนวน 2 ตัว
4. ตั้งค่า Widget ตัวแรกให้ผูกกับ V2 (Temperature)
5. ตั้งค่า Widget ตัวที่สองให้ผูกกับ V3 (Humidity)
6. ปรับแต่งสีสันให้สวยงาม เช่น อุณหภูมิสีแดง ความชื้นสีฟ้า
7. กดเริ่มระบบ (Play) และใช้มืออังหรือเป่าลมหายใจใส่เซนเซอร์ DHT22 เพื่อทดสอบดูว่าตัวเลขมีการเปลี่ยนแปลงหรือไม่

💡 ข้อควรระวัง (Teaching Point) นักศึกษาจะสังเกตเห็นว่าในบรรทัด timer.setInterval(2000L, sendSensors); มีการเปลี่ยนเวลาจาก 1000L เป็น 2000L (2 วินาที) สาเหตุเพราะธรรมชาติของฮาร์ดแวร์ DHT22 จะประมวลผลข้อมูลค่อนข้างช้า หากเราสั่งให้อ่านค่าถี่กว่า 2 วินาที เซนเซอร์อาจจะรวนและแสดงผลเป็นค่าแปลกๆ ได้

บทที่ 5 การติดตั้งเซนเซอร์วัดแสง (LDR) เพื่อติดตามความสว่าง

ในระบบสมาร์ทฟาร์ม แสงสว่างเป็นปัจจัยหลักในการสังเคราะห์แสงของพืช ในบทนี้เราจะเพิ่มเซนเซอร์วัดความสว่างของแสง (LDR Module) เข้าไปในระบบ เพื่อให้สามารถตรวจสอบปริมาณแสงผ่านแอปพลิเคชัน Blynk ได้ตลอดเวลา

ส่วนที่ 1 การต่อวงจรเซนเซอร์วัดแสง (LDR Module)

โมดูล LDR แบบมาตรฐานมักจะมี 3 หรือ 4 ขา (หากมี 4 ขา เราจะใช้เฉพาะขาสัญญาณอนาล็อก หรือ A0) ให้นักศึกษาเชื่อมต่อเข้ากับบอร์ด ESP32 ดังนี้

สำหรับการต่อ LDR แบบ 2 ขา เปล่าๆ เข้ากับ ESP32 นั้น ไม่สามารถต่อตรงได้เหมือนรูปแบบโมดูล แต่ต้องอาศัยการต่อ วงจรแบ่งแรงดัน (Voltage Divider) โดยใช้ตัวต้านทานคงที่ขนาด 10kΩ มาช่วยครับ วิธีการคือให้ต่อขาหนึ่งของ LDR เข้ากับไฟ 3.3V และอีกขาหนึ่งต่อเข้ากับขา GPIO 35 พร้อมกับเชื่อมตัวต้านทาน 10kΩ จากจุดนั้นลงไปยัง GND เพื่อเปลี่ยนค่าความต้านทานที่แปรผันตามแสงให้กลายเป็นแรงดันไฟฟ้าที่บอร์ดสามารถอ่านค่าอนาล็อกได้นั่นเอง

ส่วนที่ 2 การสร้างช่องทางส่งข้อมูล (Datastreams) เพิ่มเติม

เราจำเป็นต้องสร้าง Datastream ใหม่ในแม่พิมพ์ (Template) เพื่อเป็นท่อรับข้อมูลตัวเลขความสว่าง

ขั้นตอนการปฏิบัติ

1. เข้าสู่ระบบ blynk.cloud และเปิด Template “Smart Farm System”
2. คลิกแท็บ Datastreams และสร้าง Virtual Pin เพิ่มดังนี้
   • สำหรับแสงสว่าง
     • Name : Light Intensity (ไลท์-อินเทนซิตี)
     • PIN : V4
     • Data Type : Integer (เลขจำนวนเต็ม)
     • MIN / MAX : 0 / 100
     • Units : %
3. คลิกปุ่ม Save เพื่อบันทึกโครงสร้างใหม่

ส่วนที่ 3 การเขียนโปรแกรมรวมทุกเซนเซอร์

โค้ดในเวอร์ชันนี้ จะทำการประมวลผลข้อมูลทั้งเซนเซอร์ความชื้นดิน (A0) อุณหภูมิ/ความชื้นอากาศ (DHT22) และเซนเซอร์แสง (LDR) ไปพร้อมๆกัน

// 1. ข้อมูล Blynk (ต้องอยู่บนสุด)
#define BLYNK_TEMPLATE_ID "TMPLxxxxxx"
#define BLYNK_TEMPLATE_NAME "Smart Farm System"
#define BLYNK_AUTH_TOKEN "YourAuthTokenHere"

#include <WiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleEsp32.h>
#include <DHT.h> 

// 2. ตั้งค่าเครือข่าย Wi-Fi
char ssid[] = "YOUR_WIFI_NAME";
char pass[] = "YOUR_WIFI_PASSWORD";

// 3. กำหนดขาอุปกรณ์ทั้งหมด
const int SOIL_PIN = 34;   // เซนเซอร์ความชื้นดิน
const int RELAY_PIN = 13;  // ปั๊มน้ำ
const int DHT_PIN = 4;     // เซนเซอร์ DHT22
const int LDR_PIN = 35;    // 🌟 เซนเซอร์วัดแสง (LDR)

#define DHTTYPE DHT22   
DHT dht(DHT_PIN, DHTTYPE);

BlynkTimer timer;

// --- ฟังก์ชันรับคำสั่งควบคุมปั๊มน้ำ (V1) ---
BLYNK_WRITE(V1) {
  int pinValue = param.asInt(); 
  if (pinValue == 1) {
    digitalWrite(RELAY_PIN, HIGH); 
  } else {
    digitalWrite(RELAY_PIN, LOW);  
  }
}

// --- ฟังก์ชันอ่านค่าเซนเซอร์ทั้งหมดและส่งขึ้น Blynk ---
void sendSensors() {
  // 1. อ่านค่าความชื้นดิน (V0)
  int soilValue = analogRead(SOIL_PIN); 
  int moisturePercent = map(soilValue, 4095, 1000, 0, 100);
  moisturePercent = constrain(moisturePercent, 0, 100);
  Blynk.virtualWrite(V0, moisturePercent);
  
  // 2. อ่านค่าอากาศจาก DHT22 (V2, V3)
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  if (!isnan(h) && !isnan(t)) {
    Blynk.virtualWrite(V2, t);
    Blynk.virtualWrite(V3, h);
  }

  // 3. 🌟 อ่านค่าความสว่างจาก LDR (V4)
  int lightValue = analogRead(LDR_PIN);
  
  // แปลงค่าดิบให้เป็นเปอร์เซ็นต์ (0 - 100%)
  // *ข้อควรระวัง: หากโมดูล LDR ของนักศึกษาแสดงค่าย้อนกลับ (สว่าง=0, มืด=100) 
  // ให้สลับตัวเลขในฟังก์ชัน map() เป็น map(lightValue, 0, 4095, 0, 100);
  int lightPercent = map(lightValue, 4095, 0, 0, 100);
  lightPercent = constrain(lightPercent, 0, 100);
  
  // ส่งค่าขึ้นไปที่ V4
  Blynk.virtualWrite(V4, lightPercent);
  
  // แสดงผลสถานะทั้งหมดผ่านทางหน้าจอคอมพิวเตอร์ (Serial Monitor)
  Serial.print("Soil: "); Serial.print(moisturePercent); Serial.print("% | ");
  Serial.print("Temp: "); Serial.print(t); Serial.print("°C | ");
  Serial.print("Hum: "); Serial.print(h); Serial.print("% | ");
  Serial.print("Light: "); Serial.print(lightPercent); Serial.println("%");
}

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

void setup() {
  Serial.begin(115200);
  
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW); 
  
  dht.begin(); 

  Serial.println("Connecting to Blynk...");
  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);

  // ตั้งเวลาส่งข้อมูลทุกๆ 2 วินาที
  timer.setInterval(2000L, sendSensors); 
}

void loop() {
  Blynk.run();
  timer.run();
}

ส่วนที่ 4 การอัปเดตหน้าปัด (Dashboard) บนมือถือ

1. เปิดแอปพลิเคชัน Blynk IoT บนสมาร์ทโฟน
2. เข้าสู่โหมดตั้งค่า (Setup Dashboard)
3. เพิ่ม Widget แบบ Gauge (มาตรวัด) อีก 1 ตัว
4. ตั้งค่า Widget ตัวใหม่ให้ผูกกับ V4 (Light Intensity)
5. ปรับเปลี่ยนสีตามความเหมาะสม เช่น ใช้สีเหลืองหรือส้มแทนแสงอาทิตย์
6. กดเริ่มระบบ (Play)

วิธีทดสอบเซนเซอร์ LDR

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

รายการตรวจสอบความพร้อม (Checklist)

• [ ] ต่อสายสัญญาณ LDR เข้ากับขา GPIO 35 ถูกต้อง
• [ ] สร้าง Datastream V4 สำหรับแสงสว่างในระบบคลาวด์แล้ว
• [ ] ตัวเลขความสว่างบนแอปพลิเคชันมีการเปลี่ยนแปลงเมื่อสภาพแสงเปลี่ยนไป

บทที่ 6 การสร้างกราฟบันทึกข้อมูลย้อนหลังเพื่อการวิเคราะห์ (Data Logging & Chart)

ในระบบ Smart Farm การดูข้อมูลแบบตามเวลาจริง (Real-time) อาจไม่เพียงพอต่อการตัดสินใจ การบันทึกข้อมูลย้อนหลัง (Historical Data) และนำมาแสดงผลเป็นกราฟ จะช่วยให้เรามองเห็นแนวโน้มและความสัมพันธ์ของสภาพแวดล้อมต่างๆภายในฟาร์มได้อย่างชัดเจน

ในบทนี้ เราจะทำการสร้างกราฟบนหน้าจอควบคุมผ่านเว็บเบราว์เซอร์ (Web Dashboard) ซึ่งเหมาะสำหรับการดูข้อมูลเชิงลึกและหน้าจอที่มีขนาดใหญ่

ส่วนที่ 1 การเตรียมหน้าแผงควบคุมบนเว็บไซต์ (Web Dashboard)

1. เข้าสู่ระบบ blynk.cloud ผ่านคอมพิวเตอร์
2. ไปที่เมนู Templates และเลือกแม่พิมพ์ “Smart Farm System” ที่เราใช้งานอยู่
3. คลิกที่แท็บ Web Dashboard > Edit เพื่อเข้าสู่โหมดการออกแบบหน้าจอสำหรับคอมพิวเตอร์
4. ลาก Widget ที่ชื่อว่า Chart จากแถบเครื่องมือด้านซ้ายมือ มาวางบนพื้นที่ว่าง (สามารถปรับขนาดความกว้างของกราฟให้เต็มหน้าจอได้เพื่อความชัดเจน)

ส่วนที่ 2 การตั้งค่าเส้นกราฟ (Configuring Data Lines)

เราจะนำข้อมูลจากเซนเซอร์ทั้ง 4 ตัว (V0 , V2 , V3 , V4) มาพล็อตรวมกันในกราฟเดียว เพื่อดูความสัมพันธ์ของเหตุการณ์

ขั้นตอนการปฏิบัติ

1. วางเมาส์เหนือ Widget กราฟที่ลากมาวาง แล้วคลิกสัญลักษณ์ รูปเฟือง (Settings)
2. ตั้งชื่อกราฟในช่อง Title เช่น สถิติสภาพแวดล้อมฟาร์ม
3. ในส่วนของ Datastreams ให้คลิกปุ่ม + Add Datastream เพื่อเพิ่มเส้นกราฟ
4. เลือก Datastream และตั้งค่าสีของเส้นให้แยกแยะได้ง่าย:
   • เส้นที่ 1: เลือก V0 (Soil Moisture) – แนะนำสีน้ำตาลหรือสีเขียวเข้ม
   • เส้นที่ 2: เลือก V2 (Temperature) – แนะนำสีแดงหรือส้ม
   • เส้นที่ 3: เลือก V3 (Humidity) – แนะนำสีฟ้าหรือน้ำเงิน
   • เส้นที่ 4: เลือก V4 (Light Intensity) – แนะนำสีเหลือง
5. รูปแบบของเส้น (Line Type) แนะนำให้เลือกแบบ Spline (เส้นโค้งมน) เพื่อให้กราฟดูเป็นธรรมชาติและสบายตา
6. คลิก Save ที่หน้าต่างตั้งค่า และคลิก Save ที่มุมขวาบนของหน้า Template อีกครั้งเพื่อยืนยันระบบ

ส่วนที่ 3 การดูข้อมูลและส่งออกรายงาน (Data Export)

เมื่อบอร์ด ESP32 เริ่มทำงานและส่งข้อมูลขึ้นระบบอย่างต่อเนื่อง ข้อมูลจะเริ่มปรากฏบนกราฟ

ขั้นตอนการปฏิบัติ

1. ไปที่เมนู Devices เลือกระบบฟาร์มของเรา เช่น Node_01
2. คลิกที่แท็บ Dashboard เพื่อดูกราฟที่กำลังบันทึกข้อมูลจริง
3. ทดลองปรับช่วงเวลาการแสดงผล (Time Range) ที่มุมของกราฟ เช่น ดูข้อมูลย้อนหลัง 1 ชั่วโมง , 6 ชั่วโมง หรือ 1 วัน
4. การส่งออกข้อมูล หากคลิกที่สัญลักษณ์รูปแผ่นกระดาษ มุมขวาบนของกราฟ จะมีคำสั่ง Export data (CSV) ซึ่งสามารถโหลดข้อมูลตัวเลขไปวิเคราะห์ต่อในโปรแกรม Microsoft Excel ได้

ส่วนที่ 4 หลักการวิเคราะห์ความสัมพันธ์ของกราฟ (Data Interpretation)

เมื่อมีข้อมูลในกราฟแล้ว ให้นักศึกษาสังเกตและวิเคราะห์ความสัมพันธ์ดังต่อไปนี้

• ช่วงกลางวัน (แดดจัด) เส้นความเข้มแสง (V4) และอุณหภูมิ (V2) จะสูงขึ้น ในขณะเดียวกัน เส้นความชื้นในอากาศ (V3) มักจะลดต่ำลง และเส้นความชื้นดิน (V0) จะค่อยๆลาดลงเร็วกว่าปกติเนื่องจากการระเหย
• ประสิทธิภาพของการรดน้ำ เมื่อกดปุ่มสั่งเปิดปั๊มน้ำ (V1) ให้สังเกตกราฟความชื้นดิน (V0) ว่าใช้เวลานานเท่าใดกราฟจึงจะพุ่งสูงขึ้น (ระยะเวลาที่น้ำซึมลงดินถึงระดับเซนเซอร์)
• การตั้งค่าระบบอัตโนมัติ การดูกราฟจะช่วยให้เรากำหนด “ค่าวิกฤต” ได้แม่นยำขึ้น เช่น หากกราฟความชื้นดินตกลงถึง 30% แล้วพืชเริ่มมีอาการเหี่ยว เราจะรู้ได้ทันทีว่าควรตั้งค่าให้ระบบรดน้ำอัตโนมัติทำงานเมื่อความชื้นต่ำกว่า 35% เป็นต้น

รายการตรวจสอบความพร้อม (Checklist)

• [ ] สร้าง Widget Chart บน Web Dashboard สำเร็จ
• [ ] เพิ่มเส้น Datastream ครบทั้ง 4 เส้นและกำหนดสีแยกชัดเจน
• [ ] กราฟแสดงเส้นแนวโน้มของข้อมูลเมื่อระบบทำงานอย่างต่อเนื่อง
• [ ] ทราบตำแหน่งและวิธีการดาวน์โหลดข้อมูล (Export to CSV) เพื่อทำรายงาน

บทที่ 7 การสร้างระบบควบคุมอัตโนมัติ (Automations)

เป้าหมายสูงสุดของ Smart Farm ไม่ใช่เพียงแค่การดูค่าผ่านมือถือ แต่คือการทำให้ระบบสามารถตัดสินใจได้เอง บทนี้เราจะเขียนโปรแกรมให้ ESP32 ตรวจสอบค่าความชื้นดินอย่างต่อเนื่อง และสั่งเปิดปั๊มน้ำทันทีเมื่อดินแห้งเกินไป รวมถึงปิดน้ำเองเมื่อความชื้นถึงระดับที่เหมาะสม

ส่วนที่ 1 ตรรกะการควบคุม (Control Logic)

ในการทำระบบอัตโนมัติ เราจะใช้หลักการเปรียบเทียบค่าวิกฤต โดยตั้งเงื่อนไข หากค่าความชื้นดิน < ค่าที่กำหนดไว้ ให้เปิดปั๊มน้ำ และหากค่าความชื้นดิน > ค่าที่พอเหมาะ ให้ปิดปั๊มน้ำ

ส่วนที่ 2 การปรับปรุงโค้ด (Smart Automation Code)

เราจะเพิ่มตัวแปรสำหรับเก็บค่า Threshold (เทรช-โฮลด์ = ค่าวิกฤต) และสร้างฟังก์ชันตรวจสอบเงื่อนไขอัตโนมัติ โดยนักศึกษาสามารถปรับเปลี่ยนค่า soilThreshold ได้ตามความเหมาะสมของพืชแต่ละชนิด

โค้ดส่วนที่เพิ่มและแก้ไข

// เพิ่มตัวแปรสำหรับตั้งค่าความชื้นที่ต้องการ (หน่วย %)
int soilThreshold = 40; // ตัวอย่าง: ถ้าน้อยกว่า 40% ให้รดน้ำ

// --- ฟังก์ชันควบคุมอัตโนมัติ ---
void checkAutomation() {
  int soilValue = analogRead(SOIL_PIN);
  int moisturePercent = map(soilValue, 4095, 1000, 0, 100);
  moisturePercent = constrain(moisturePercent, 0, 100);

  // ตรรกะตัดสินใจอัตโนมัติ
  if (moisturePercent < soilThreshold) {
    digitalWrite(RELAY_PIN, HIGH); // เปิดปั๊ม
    Blynk.virtualWrite(V1, 1);     // อัปเดตสถานะปุ่มบนแอปให้เป็น ON
    Serial.println("Automation: Low moisture! Pump ON");
  } 
  else if (moisturePercent > (soilThreshold + 10)) { 
    // บวก 10 เพื่อป้องกันปั๊มตัดต่อบ่อยเกินไป (Hysteresis)
    digitalWrite(RELAY_PIN, LOW);  // ปิดปั๊ม
    Blynk.virtualWrite(V1, 0);     // อัปเดตสถานะปุ่มบนแอปให้เป็น OFF
    Serial.println("Automation: Ideal moisture. Pump OFF");
  }
}

void setup() {
  // ... โค้ดเดิม ...
  // เพิ่มการเรียกฟังก์ชันตรวจสอบอัตโนมัติทุกๆ 5 วินาที
  timer.setInterval(5000L, checkAutomation); 
}

บทที่ 8 ระบบแจ้งเตือนอัจฉริยะ (Smart Alerts) และตรรกะซ้อนทับ (Advanced Logic)

ในบทนี้ เราจะใช้งานฟีเจอร์ Events ของ Blynk เพื่อให้ ESP32 สามารถส่ง Push Notification แจ้งเตือนเด้งขึ้นมาบนหน้าจอมือถือของเราได้ทันทีที่เกิดความผิดปกติ และเราจะยกระดับการเขียนโค้ดให้ฉลาดขึ้นด้วยการใช้เงื่อนไขซ้อนทับ (AND / OR)

ส่วนที่ 1 การสร้างเหตุการณ์ (Events) บนเว็บ Blynk

ก่อนที่บอร์ดจะส่งการแจ้งเตือนได้ เราต้องไปสร้างชื่อเหตุการณ์เตรียมไว้บนคลาวด์ก่อน

ขั้นตอนการปฏิบัติ

1. เข้าไปที่ blynk.cloud ไปที่เมนู Templates และเลือก “Smart Farm System”
2. คลิกที่แท็บ Events & Notifications
3. คลิกปุ่ม Edit > Create Even > Custom
4. ตั้งค่าเหตุการณ์เตือนภัยร้อนจัด
   • Event Name : High Temperature
   • Event Code : high_temp (จำโค้ดนี้ไว้ให้ดี ต้องพิมพ์ใน Arduino เป็นตัวเล็กแบบนี้)
   • Type : Warning (จะขึ้นไอคอนตกใจสีส้ม)
   • Description : อุณหภูมิในฟาร์มสูงเกินค่าที่กำหนด
   • กดเปิดสวิตช์ Enable notifications ให้ทำงาน ตรงช่อง To (ผู้รับ) ให้เลือกเป็น Device Owner แล้วให้คลิกไปที่แท็บ Settings หัวข้อ Event Limit (การจำกัดจำนวนครั้ง) ช่วงที่เรากำลังทดสอบ ให้ตั้งค่าจำกัดเวลาน้อยๆไว้ก่อน เช่น 1 minute จะได้เอาไดร์เป่าผมเป่าเทสได้รัวๆ
5. กด Save ที่หน้า Event และกด Save ที่มุมขวาบนสุดของ Template

ส่วนที่ 2 การอัปเกรดโค้ด (Advanced Logic & Alerts)

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

นำโค้ดชุดนี้ไปวางทับฟังก์ชัน checkAutomation() เดิม

// เพิ่มตัวแปรสำหรับตั้งค่าวิกฤต
int soilThreshold = 40; 
float tempThreshold = 35.0; // อุณหภูมิวิกฤต (35 องศาเซลเซียส)

// ตัวแปรป้องกันการส่งแจ้งเตือนซ้ำรัวๆ (Spam protection)
bool isTempAlertSent = false; 

// --- ฟังก์ชันควบคุมอัตโนมัติ & แจ้งเตือน ---
void checkAutomation() {
  int soilValue = analogRead(SOIL_PIN);
  int moisturePercent = map(soilValue, 4095, 1000, 0, 100);
  moisturePercent = constrain(moisturePercent, 0, 100);
  
  float t = dht.readTemperature();

  // 🌟 ตรรกะที่ 1: ตรวจสอบอุณหภูมิเพื่อแจ้งเตือน (Smart Alert)
  if (!isnan(t)) {
    if (t > tempThreshold && !isTempAlertSent) {
      // อุณหภูมิสูงกว่า 35 องศา และยังไม่เคยแจ้งเตือนมาก่อน
      Blynk.logEvent("high_temp", String("⚠️ ระวัง! อุณหภูมิฟาร์มสูงถึง ") + t + " °C");
      Serial.println("Alert: High Temp Warning Sent!");
      isTempAlertSent = true; // ล็อกไว้ จะได้ไม่ส่งซ้ำทุกๆ 5 วินาที
    } 
    else if (t < (tempThreshold - 2)) {
      // ถ้าอุณหภูมิลดลงกลับมาปกติ (ต่ำกว่า 33 องศา) ให้ปลดล็อกการแจ้งเตือน
      isTempAlertSent = false; 
    }
  }

  // 🌟 ตรรกะที่ 2: ระบบรดน้ำแบบหลายเงื่อนไข (Advanced Logic)
  // สมมติว่า: ถ้าดินแห้ง (<40%) หรือ อากาศร้อนจัด (>35 องศาและดินชื้นน้อยกว่า 60%) ให้เปิดน้ำ
  if (moisturePercent < soilThreshold || (t > tempThreshold && moisturePercent < 60)) {
    digitalWrite(RELAY_PIN, HIGH); 
    Blynk.virtualWrite(V1, 1);     
    Serial.println("Pump: ON (Condition Met)");
  } 
  else if (moisturePercent > (soilThreshold + 10)) { 
    digitalWrite(RELAY_PIN, LOW);  
    Blynk.virtualWrite(V1, 0);     
    Serial.println("Pump: OFF (Soil is wet)");
  }
}

💡 จุดที่ควรเน้นย้ำ

1. คำสั่ง Blynk.logEvent("event_code", "Message"); คือการสั่งให้บอร์ดบอกเซิร์ฟเวอร์ว่า “เกิดเหตุการณ์นี้ขึ้นแล้ว ส่งข้อความเข้ามือถือเจ้านายเดี๋ยวนี้”
2. ทำไมต้องมีตัวแปร isTempAlertSent ถ้านักศึกษาไม่ใส่ตัวแปรนี้บล็อกไว้ บอร์ดจะเช็คเจอว่าอากาศร้อนทุกๆ 5 วินาที แล้วมันก็จะยิงแจ้งเตือนเข้ามือถือเรารัวๆ ทุก 5 วินาทีจนมือถือค้างไปเลย Blynk จะบล็อกการเชื่อมต่อทันทีถ้าส่งรัวเกินไป เรียกว่า Flood Error การเขียนลอจิกปลดล็อกเมื่ออุณหภูมิกลับมาปกติจึงเป็นทักษะการเขียนโปรแกรมที่สำคัญมาก

บทที่ 9 ระบบฟาร์มไร้รอยต่อ (Offline Mode & System Reliability)

ในบทที่ผ่านๆ มา เราใช้คำสั่ง Blynk.begin(AUTH, ssid, pass); ซึ่งมีจุดอ่อนที่อันตรายมากสำหรับฟาร์มจริง คือ ถ้าระบบ Wi-Fi ล่ม หรือเน็ตถูกตัด บอร์ด ESP32 จะค้าง (Freeze) อยู่ตรงนั้นทันที มันจะพยายามต่อเน็ตจนกว่าจะได้ ส่งผลให้ฟังก์ชัน checkAutomation() ที่คอยเช็คความชื้นเพื่อเปิดปั๊มน้ำหยุดทำงานไปด้วย ต้นไม้ตายแน่นอน

ในบทนี้ เราจะสอนนักศึกษาปรับโครงสร้างโค้ดใหม่ เรียกว่า Non-blocking Connection เพื่อให้สมองกล (Logic) ยังคงทำงานเปิด-ปิดปั๊มน้ำได้ตามปกติ แม้ในวันที่ฟาร์มไม่มีอินเทอร์เน็ต

ส่วนที่ 1 เปลี่ยนวิธีการเชื่อมต่อ (Non-blocking Network)

เราจะแยกหน้าที่กันชัดเจน ปล่อยให้ ESP32 เชื่อมต่อ Wi-Fi ด้วยตัวเอง และใช้คำสั่ง Blynk.config() แทน Blynk.begin() เพื่อบอกบอร์ดว่า “ถ้าเน็ตมี ค่อยคุยกับ Blynk แต่ถ้าไม่มี ก็ทำงานอย่างอื่นต่อไปนะ”

การปรับปรุงโค้ดในฟังก์ชัน setup()

// 🌟 ลบคำสั่ง Blynk.begin(...) เดิมทิ้งไป แล้วใช้โค้ดชุดนี้แทน

void setup() {
  Serial.begin(115200);
  
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW); 
  dht.begin(); 

  // 1. สั่งให้ ESP32 ต่อ Wi-Fi แบบไม่รอค้าง
  Serial.print("Connecting to Wi-Fi");
  WiFi.begin(ssid, pass);
  
  // รอแค่ 10 วินาที ถ้าต่อไม่ได้ให้ข้ามไปเลย
  int timeout = 0;
  while (WiFi.status() != WL_CONNECTED && timeout < 20) {
    delay(500);
    Serial.print(".");
    timeout++;
  }
  Serial.println();

  // 2. ตั้งค่า Auth Token ให้ Blynk รับทราบ (แต่ยังไม่บังคับเชื่อมต่อ)
  Blynk.config(BLYNK_AUTH_TOKEN);

  // 3. เริ่มการทำงานของ Timer (สำคัญมาก ต้องให้ทำงานเสมอ)
  timer.setInterval(2000L, sendSensors); 
  timer.setInterval(5000L, checkAutomation); 
}

ส่วนที่ 2 อัปเกรดฟังก์ชัน Loop เพื่อการเชื่อมต่ออัตโนมัติ (Auto-Reconnect)

ใน loop() เราต้องเพิ่มการตรวจสอบสถานะอินเทอร์เน็ต ถ้าหลุดไปแล้วกลับมาใหม่ บอร์ดต้องต่อกลับเองได้โดยไม่ต้องให้คนไปเดินถอดปลั๊กเสียบใหม่

การปรับปรุงโค้ดในฟังก์ชัน loop()

void loop() {
  // ตรวจสอบว่าต่อ Wi-Fi อยู่หรือไม่
  if (WiFi.status() == WL_CONNECTED) {
    // ถ้าต่อ Wi-Fi ได้ ให้รัน Blynk
    Blynk.run();
  } else {
    // 🌟 ถอดปลั๊กเน็ต! แต่ฟาร์มยังต้องรอด
    // เราสามารถเพิ่มโค้ดพยายามต่อ Wi-Fi ใหม่เบื้องหลังตรงนี้ได้
    // โดยไม่ทำให้บอร์ดค้าง
  }

  // Timer ต้องอยู่นอกเงื่อนไข Wi-Fi เพื่อให้ระบบอัตโนมัติทำงานแบบ Offline ได้!
  timer.run();
}

ส่วนที่ 3 บททดสอบสภาวะวิกฤต (Stress Test)

เพื่อให้เห็นภาพความสำคัญของโค้ดชุดนี้ ให้นักศึกษาทดสอบตามขั้นตอนดังนี้

1. อัปโหลดโค้ดชุดใหม่ลงบอร์ด ESP32
2. ปล่อยให้บอร์ดเชื่อมต่อ Wi-Fi และแสดงค่าบนแอปพลิเคชัน Blynk ตามปกติ
3. จำลองเหตุการณ์เน็ตล่ม ปิด Internet
4. ทดสอบ Offline Logic ใช้มือจับเซนเซอร์ความชื้นดินให้หลุดออกจากดิน (จำลองว่าดินแห้ง)
5. สังเกตที่บอร์ด ESP32 ปั๊มน้ำ (Relay) จะต้องทำงานได้ทันที แม้จุดแสดงสถานะในแอป Blynk จะขึ้นว่า Offline ก็ตาม
6. จำลองเหตุการณ์เน็ตกลับมา เปิด Internet แล้วรอดูว่า ESP32 สามารถกลับไปรายงานตัวบนคลาวด์ได้เองหรือไม่

สรุปคุณค่าของบทนี้ (Engineering Mindset) การทำ IoT ที่ดี ไม่ใช่แค่สั่งงานผ่านแอปได้ แต่ระบบต้องมีความ “ยืดหยุ่นและทนทานต่อความล้มเหลว” (Fault Tolerance) การทำให้ระบบทำงานแบบ Offline ได้ คือเส้นแบ่งระหว่างโปรเจกต์นักเรียนกับโปรเจกต์ที่นำไปติดตั้งให้เกษตรกรใช้งานได้จริง

บทที่ 10 การอัปเดตโปรแกรมไร้สาย (Over-The-Air : OTA) สู่มาตรฐานอุตสาหกรรม

บทสรุปของระบบ Smart Farm Mini Sandbox คือการทำให้ระบบสามารถบำรุงรักษาได้ง่ายที่สุด (Maintenance Friendly) ฟีเจอร์ OTA (Over-The-Air) จะช่วยให้เราสามารถอัปโหลดเฟิร์มแวร์ใหม่ๆ จากคอมพิวเตอร์ไปยังบอร์ด ESP32 ผ่านระบบ Wi-Fi ได้โดยไม่ต้องใช้สาย USB อีกต่อไป

ส่วนที่ 1 การเตรียมไลบรารีสำหรับ OTA

ข้อดีของ ESP32 คือมีชุดคำสั่งสำหรับทำ OTA มาให้พร้อมในตัวโปรแกรม Arduino IDE แล้ว เราเพียงแค่ต้องเรียกใช้งานให้ถูกต้อง

ขั้นตอนการปฏิบัติ ในส่วนหัวของโปรแกรม (ต่อจากไลบรารี Blynk และ DHT) ให้เพิ่มไลบรารีเหล่านี้เข้าไป

#include <ESPmDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h> // 🌟 นำเข้าไลบรารีสำหรับอัปเดตไร้สาย

ส่วนที่ 2 การอัปเกรดโค้ด (ฝังระบบ OTA ลงในบอร์ด)

เราจะทำการเพิ่มการตั้งค่าชื่อบอร์ดและรหัสผ่าน เพื่อป้องกันไม่ให้คนอื่นแอบส่งโค้ดมากวนบอร์ดของเรา ลงในฟังก์ชัน setup() และสั่งให้ระบบคอยดักจับการอัปเดตในฟังก์ชัน loop()

การปรับปรุงฟังก์ชัน setup()

void setup() {
  // ... โค้ดตั้งค่าเดิมทั้งหมด (Serial, pinMode, Wi-Fi, Blynk) ...

  // 🌟 1. ตั้งชื่อบอร์ดให้จำง่ายเวลาค้นหาในเครือข่าย
  ArduinoOTA.setHostname("SmartFarm_Node_01");
  
  // 🌟 2. ตั้งรหัสผ่านสำหรับอัปเดตโค้ด (ความปลอดภัยระดับเบื้องต้น)
  ArduinoOTA.setPassword("farm1234");

  // 🌟 3. เริ่มการทำงานของระบบ OTA
  ArduinoOTA.begin();
  
  Serial.println("OTA Ready!");
}

การปรับปรุงฟังก์ชัน loop()

void loop() {
  if (WiFi.status() == WL_CONNECTED) {
    Blynk.run();
    // 🌟 4. สั่งให้บอร์ดคอยเงี่ยหูฟังว่ามีโค้ดใหม่ส่งมาทาง Wi-Fi หรือไม่
    ArduinoOTA.handle(); 
  }
  
  timer.run();
}

ส่วนที่ 3 วิธีการอัปโหลดโค้ดผ่านอากาศ (Wireless Upload)

เมื่อเราอัปโหลดโค้ดชุดด้านบนผ่านสาย USB เป็นครั้งแรกเรียบร้อยแล้ว บอร์ด ESP32 ของเราก็พร้อมที่จะโบยบินเป็นอิสระ

ขั้นตอนการอัปโหลดแบบไร้สายในครั้งต่อไป

1. ถอดสาย USB ออกจากคอมพิวเตอร์ ให้นำบอร์ด ESP32 ไปต่อกับอะแดปเตอร์ 9V หรือพาวเวอร์แบงก์แทน
2. ตรวจสอบให้แน่ใจว่า คอมพิวเตอร์ของคุณ และ บอร์ด ESP32 เชื่อมต่ออยู่กับ Wi-Fi วงเดียวกัน
3. ในโปรแกรม Arduino IDE ไปที่เมนู Tools > Port
4. สังเกตที่หัวข้อ Network Ports (แทนที่จะเป็น Serial Ports แบบเดิม) คุณจะพบชื่อบอร์ดที่คุณตั้งไว้ปรากฏขึ้นมา เช่น SmartFarm_Node_01 at 192.168.x.x
5. คลิกเลือก Port นั้น
6. ลองแก้ไขโค้ดเล็กน้อย เช่น เปลี่ยนเวลา Timer หรือ เปลี่ยนข้อความ Serial.print
7. กดปุ่ม Upload ตามปกติ
8. โปรแกรมจะเด้งหน้าต่างขึ้นมาถามรหัสผ่าน ให้กรอก farm1234 แล้วกด Enter
9. รอจนแถบอัปโหลดเสร็จสิ้น บอร์ดจะรีสตาร์ทตัวเองและรันโค้ดชุดใหม่ทันที

💡 บทสรุปทางวิศวกรรม (Engineering Insights)

นักศึกษาจะได้เห็นความเปลี่ยนแปลงอย่างชัดเจน จากบทที่ 1 ที่บอร์ดต้องมีสายระโยงระยางติดกับคอมพิวเตอร์ มาสู่บทที่ 10 ที่ตัวบอร์ดถูกนำไปติดตั้งในสวนแล้ว แต่เรายังสามารถนั่งจิบกาแฟอยู่ในห้องแอร์ และอัปเดตเงื่อนไข Threshold ของความชื้นดินให้ฉลาดขึ้นได้ผ่านระบบเครือข่าย

นี่คือรูปแบบการทำงานของวิศวกร IoT ในอุตสาหกรรมขนาดใหญ่ของจริง

สอนโดย อาจารย์นุ/ครูนุ (ภานุพงศ์ สะและหมัด)

ติดต่อ Line ID : salae44476