JSON คืออะไร และทำไมถึงสำคัญใน IoT
JSON (JavaScript Object Notation) คือรูปแบบการเก็บและแลกเปลี่ยนข้อมูลที่อ่านง่าย คล้ายกับ dictionary หรือ object โดยใช้โครงสร้าง key : value
ตัวอย่าง JSON:
{
"temperature": 28.5,
"humidity": 65,
"status": "OK"
}
ข้อดีของ JSON คือ
- ขนาดเล็ก ส่งเร็ว
- อ่านง่ายทั้งคนและโปรแกรม
- รองรับหลายภาษา (Python, C++, Java, JS)
- เหมาะมากกับงาน IoT ที่ต้องส่งข้อมูลระหว่าง ESP32 ↔ แอปมือถือ ↔ Server
ทำไม ESP32/Arduino ถึงนิยมใช้ ArduinoJson
เพราะ ESP32/Arduino มีข้อจำกัดด้านหน่วยความจำและความเร็ว การ parse หรือสร้าง JSON ด้วยโค้ดดิบ ๆ จะซับซ้อนและเปลืองทรัพยากร แต่ ArduinoJson ถูกออกแบบมาให้:
- ใช้งานง่าย แค่ไม่กี่บรรทัดก็อ่าน/เขียน JSON ได้
- ประหยัดหน่วยความจำ จัดการ StaticJsonDocument และ DynamicJsonDocument ให้
- รองรับการทำงานทั้ง serialize (สร้าง JSON) และ deserialize (แปลง JSON กลับมาเป็นตัวแปร)
- เป็นไลบรารียอดนิยม คนใช้เยอะ มีคู่มือและตัวอย่างเพียบ
ตัวอย่างการใช้งานจริง เช่น รับส่งข้อมูลกับแอป หรือ Web API
- Smart Farm → ESP32 อ่านค่าเซนเซอร์ DHT22 แล้วสร้าง JSON ส่งไปยังแอปมือถือ:
{
"temp": 27.3,
"humi": 60
}
- MQTT หรือ WebSocket → ใช้ JSON เป็นรูปแบบกลางในการส่งข้อมูล เช่น:
{
"device": "pump1",
"action": "on"
}
รายละเอียดพื้นฐานของ ESP32 คืออะไร พร้อมจุดเด่นและวิธีเริ่มต้นใช้งาน

การติดตั้ง ArduinoJson
วิธีติดตั้งผ่าน Library Manager ใน Arduino IDE
- เปิด Arduino IDE
- ไปที่เมนู Tools > Manage Libraries…
- พิมพ์ค้นหา ArduinoJson
- กดปุ่ม Install (แนะนำเลือกเวอร์ชันล่าสุด v6)
- รอจนขึ้นว่า Installed → พร้อมใช้งานทันที
📌 วิธีนี้ง่ายที่สุด มือใหม่ทำตามได้เลย ไม่ต้องโหลดไฟล์เอง
วิธีติดตั้งแบบ Manual จาก GitHub
บางครั้งเวอร์ชันใน Library Manager อาจยังไม่อัปเดตล่าสุด เราสามารถโหลดไฟล์โดยตรงจาก GitHub ได้
- เข้าไปที่ ArduinoJson GitHub
- กด Code > Download ZIP
- เปิด Arduino IDE → ไปที่ Sketch > Include Library > Add .ZIP Library…
- เลือกไฟล์ .zip ที่โหลดมา → Arduino IDE จะติดตั้งให้อัตโนมัติ
วิธีเช็คเวอร์ชัน (v6 คือเวอร์ชันล่าสุดที่นิยม)
- ไปที่ Sketch > Include Library > Manage Libraries… แล้วหาคำว่า ArduinoJson จะเห็นหมายเลขเวอร์ชันที่ติดตั้ง
- หรือเปิดไฟล์ library.properties ในโฟลเดอร์ ArduinoJson (อยู่ใน Documents/Arduino/libraries/) จะมีบรรทัด version=6.x.x
- ปัจจุบัน (ปี 2025) ArduinoJson v6 คือเวอร์ชันที่เสถียรและคนใช้เยอะที่สุด → มีฟังก์ชัน serializeJson() และ deserializeJson() ที่ใช้งานง่ายกว่า v5
ดาวน์โหลด Arduino IDE และติดตั้งได้ง่าย ๆ ที่ Arduino IDE Download & Install
การใช้งานพื้นฐาน
การสร้าง JSON Object
เวลาเราต้องการสร้าง JSON ขึ้นมาเพื่อส่งออก เช่น ค่าเซนเซอร์ → แอปมือถือ
#include <ArduinoJson.h>
void setup() {
Serial.begin(115200);
// สร้างพื้นที่เก็บ JSON
StaticJsonDocument<200> doc;
// เพิ่ม key-value ลงไป
doc["temperature"] = 27.5;
doc["humidity"] = 65;
doc["status"] = "OK";
// แปลงเป็นข้อความ JSON แล้วส่งไปที่ Serial Monitor
serializeJson(doc, Serial);
}
void loop() {}
การเข้าถึงค่า (Parse JSON String → อ่านค่า key/value)
สมมติ ESP32 ได้รับข้อมูล JSON จากเว็บ API หรือแอป
#include <ArduinoJson.h>
void setup() {
Serial.begin(115200);
// ตัวอย่างข้อความ JSON
const char* json = "{\"temp\":30.2,\"humi\":70}";
StaticJsonDocument<200> doc;
DeserializationError error = deserializeJson(doc, json);
if (!error) {
float t = doc["temp"];
int h = doc["humi"];
Serial.print("Temp: ");
Serial.println(t);
Serial.print("Humi: ");
Serial.println(h);
} else {
Serial.println("Parse JSON Error!");
}
}
void loop() {}
การจัดการหน่วยความจำด้วย StaticJsonDocument และ DynamicJsonDocument
StaticJsonDocument<N>
- ใช้หน่วยความจำแบบคงที่ (stack)
- เร็วและประหยัด
- เหมาะกับ JSON ขนาดเล็กและโครงสร้างคงที่
DynamicJsonDocument
- ใช้หน่วยความจำแบบ dynamic (heap)
- เหมาะกับ JSON ขนาดใหญ่ที่ไม่รู้ขนาดแน่นอน
- แต่ถ้าใช้ผิด อาจทำให้ หน่วยความจำหมด (heap overflow) ได้
📌 ทิป: ถ้าเป็น โครงงาน Smart Farm เล็ก ๆ แนะนำให้ใช้ StaticJsonDocument จะเสถียรกว่า
ตัวอย่าง:
StaticJsonDocument<200> doc1; // JSON คงที่ DynamicJsonDocument doc2(1024); // JSON ใหญ่/เปลี่ยนขนาดได้

ตัวอย่างโค้ด ArduinoJson กับ ESP32
ตัวอย่าง 1: แปลง String → JSON (Deserialize)
รับสตริง JSON แล้วอ่านค่า key/value ออกมา
#include <ArduinoJson.h>
void setup() {
Serial.begin(115200);
// สตริงที่ได้รับมาจาก API/แอป
const char* json = "{\"device\":\"pump1\",\"action\":\"on\",\"duration\":10}";
StaticJsonDocument<128> doc;
DeserializationError err = deserializeJson(doc, json);
if (err) {
Serial.print("Parse error: "); Serial.println(err.f_str());
return;
}
const char* device = doc["device"]; // "pump1"
const char* action = doc["action"]; // "on"
int duration = doc["duration"]; // 10
Serial.printf("device=%s, action=%s, duration=%d\n", device, action, duration);
}
void loop() {}
ตัวอย่าง 2: สร้าง JSON → ส่งผ่าน Serial Monitor (Serialize)
ประกอบ JSON จากตัวแปร แล้วส่งออกเป็นข้อความ JSON
#include <ArduinoJson.h>
void setup() {
Serial.begin(115200);
float temp = 27.8;
int humi = 62;
int soil = 480;
StaticJsonDocument<128> doc;
doc["temp"] = temp;
doc["humi"] = humi;
doc["soil"] = soil;
doc["status"] = "OK";
// ส่งแบบย่อ (minified)
serializeJson(doc, Serial);
Serial.println();
// ส่งแบบอ่านง่าย (pretty)
serializeJsonPretty(doc, Serial);
Serial.println();
}
void loop() {}
ตัวอย่าง 3: ใช้ ArduinoJson + WiFi + WebSocket ส่ง/รับข้อมูลกับแอป (ESPAsyncWebServer)
ESP32 เปิด WebSocket ที่พาธ /ws
- รับข้อความ JSON จากแอป (เช่น {“device”:”pump1″,”action”:”on”})
- ส่งสถานะ/เซนเซอร์กลับเป็น JSON ทุก ๆ 2 วินาที
- ต้องติดตั้งไลบรารี: ESPAsyncWebServer, AsyncTCP, ArduinoJson
ทำความรู้จักฟังก์ชันต่าง ๆ ในไลบรารี WiFi บน ESP32 และวิธีใช้งานอย่างมืออาชีพได้ที่ ESP32 WiFi Library Functions
#include <WiFi.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <ArduinoJson.h>
const char* ssid = "YOUR_WIFI";
const char* pass = "YOUR_PASSWORD";
AsyncWebServer server(80);
AsyncWebSocket ws("/ws");
const int RELAY_PUMP = 5; // ต่อรีเลย์ที่ GPIO5
bool pumpOn = false;
unsigned long lastSend = 0;
void broadcastSensor() {
// mock sensor
float temp = 28.5;
int humi = 60;
int soil = 430;
StaticJsonDocument<160> doc;
doc["temp"] = temp;
doc["humi"] = humi;
doc["soil"] = soil;
doc["pump"] = pumpOn;
String out;
serializeJson(doc, out);
ws.textAll(out);
}
void handleIncomingJson(void *arg, uint8_t *data, size_t len) {
// data เป็นสตริง JSON จากแอป
StaticJsonDocument<160> doc;
DeserializationError err = deserializeJson(doc, data, len);
if (err) return;
const char* device = doc["device"]; // "pump1"
const char* action = doc["action"]; // "on"/"off"
if (device && strcmp(device, "pump1") == 0 && action) {
pumpOn = (strcmp(action, "on") == 0);
digitalWrite(RELAY_PUMP, pumpOn ? LOW : HIGH); // Active LOW
}
}
void onWsEvent(AsyncWebSocket *server,
AsyncWebSocketClient *client,
AwsEventType type,
void *arg,
uint8_t *data,
size_t len) {
if (type == WS_EVT_CONNECT) {
Serial.printf("WS connect: %u\n", client->id());
} else if (type == WS_EVT_DATA) {
AwsFrameInfo * info = (AwsFrameInfo*)arg;
if (info->final && info->index == 0 && info->len == len && info->opcode == WS_TEXT) {
handleIncomingJson(arg, data, len);
}
} else if (type == WS_EVT_DISCONNECT) {
Serial.printf("WS disconnect: %u\n", client->id());
}
}
void setup() {
Serial.begin(115200);
pinMode(RELAY_PUMP, OUTPUT);
digitalWrite(RELAY_PUMP, HIGH); // ปิดไว้ก่อน (Active LOW)
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, pass);
Serial.print("WiFi connecting");
while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); }
Serial.println("\nWiFi connected: " + WiFi.localIP().toString());
ws.onEvent(onWsEvent);
server.addHandler(&ws);
// หน้า root แบบง่าย ๆ
server.on("/", HTTP_GET, [](AsyncWebServerRequest *req){
req->send(200, "text/plain", "ESP32 WebSocket ready: ws://<ip>/ws");
});
server.begin();
}
void loop() {
// ส่งสถานะ/เซนเซอร์ทุก 2 วินาที
if (millis() - lastSend > 2000) {
lastSend = millis();
broadcastSensor();
}
}
ตัวอย่าง 4: ใช้ ArduinoJson กับเซนเซอร์จริง (DHT22)
- อ่าน DHT22: อุณหภูมิ/ความชื้น
- รวมเป็น JSON แล้วส่งออก Serial / ต่อกับตัวอย่างที่ 3 เพื่อส่งผ่าน WebSocket ก็ได้
ต้องติดตั้งไลบรารี: DHT sensor library by Adafruit, ArduinoJson

#include <Arduino.h>
#include <DHT.h>
#include <ArduinoJson.h>
#define DHTPIN 4
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);
void setup() {
Serial.begin(115200);
dht.begin();
}
void loop() {
float t = dht.readTemperature(); // °C
float h = dht.readHumidity(); // %
// ตรวจ error ของ DHT
bool ok = !isnan(t) && !isnan(h);
StaticJsonDocument<160> doc;
doc["temp"] = ok ? t : -1000; // ใส่ sentinel เมื่ออ่านพลาด
doc["humi"] = ok ? h : -1;
doc["status"] = ok ? "OK" : "DHT_ERROR";
serializeJson(doc, Serial);
Serial.println();
delay(2000);
}

หมายเหตุเรื่องหน่วยความจำ (สำคัญ)
- ถ้าโครงสร้าง JSON คงที่/ขนาดเล็ก → ใช้ StaticJsonDocument<N> เร็วและเสถียรกว่า
- ถ้า JSON อาจเปลี่ยนแปลงใหญ่/ไม่แน่นอน → ใช้ DynamicJsonDocument size แต่ระวัง heap ใช้หมด
- กะขนาด N ให้เผื่อ key/value + string บ้าง (ถ้าไม่ชัวร์ เริ่ม 128/256 แล้วไล่ปรับจาก DeserializationError::NoMemory)

ข้อควรระวังในการใช้งาน
ขนาดของ JsonDocument ต้องเพียงพอ
เวลาสร้าง StaticJsonDocument<N> หรือ DynamicJsonDocument(N) ต้องกำหนดขนาด N ให้เหมาะสม
- ถ้าเล็กเกินไป → deserializeJson() จะ error: NoMemory
- ถ้าใหญ่เกินไป → เปลือง RAM โดยใช่เหตุ
👉 วิธีแก้: เริ่มจาก 128, 256 แล้วปรับเพิ่มตามจำนวน key/value ที่ใช้
การใช้ DynamicJsonDocument อาจทำให้หน่วยความจำหมด
DynamicJsonDocument ใช้หน่วยความจำแบบ heap ซึ่ง ESP32 มีจำกัด
- ใช้บ่อยเกินไป (โดยเฉพาะใน loop) อาจทำให้ heap fragment จน หน่วยความจำไม่พอ
👉 วิธีแก้: - ใช้ StaticJsonDocument ถ้า JSON มีโครงสร้างคงที่
- หรือ recycle DynamicJsonDocument ตัวเดิม แทนการสร้างใหม่ในทุก loop
ควรใช้ StaticJsonDocument ในงานที่ขนาด JSON คงที่
- StaticJsonDocument ใช้ stack memory → เสถียรกว่า, เร็วกว่า
- เหมาะกับงาน Smart Farm ที่มีโครงสร้าง JSON คงที่ เช่น ค่าเซนเซอร์ temp/humi/soil
👉 คำแนะนำ: ใช้ StaticJsonDocument<256> ก็เพียงพอสำหรับ JSON เล็ก ๆ ส่วนใหญ่
ปัญหาที่พบบ่อย และแนวทางแก้ไข
- Parse JSON แล้ว error → มักเกิดจากขนาด document ไม่พอ หรือ JSON ไม่ถูกต้อง
- Serial output ไม่ขึ้น → ลืม serializeJson(doc, Serial);
- ค่าที่ได้เป็น null → key ไม่ตรง หรือ type ไม่ตรง (int vs float)
- JSON ใหญ่เกินไป → ลด precision ของค่า sensor หรือส่งเฉพาะข้อมูลจำเป็น
- โปรเจกต์ใหญ่ lag → แนะนำแยก JSON เป็น packet เล็ก ๆ แทนส่งก้อนใหญ่
สรุป
- ArduinoJson เป็นไลบรารีสำคัญที่ช่วยให้ ESP32/Arduino สามารถรับ–ส่งข้อมูลในรูปแบบ JSON ได้สะดวก ไม่ว่าจะคุยกับ แอปมือถือ, Web API, MQTT หรือ WebSocket
- ใช้งานได้ทั้งโครงการเล็ก เช่น Smart Farm DIY ที่ส่งค่าเซนเซอร์ไปยังแอป และโครงการใหญ่ที่เชื่อมต่อกับ IoT Cloud
- มือใหม่ควรเริ่มจาก โค้ดสั้น ๆ เช่น สร้าง JSON ง่าย ๆ หรือ Parse ข้อความเล็ก ๆ ก่อน แล้วค่อยต่อยอดไปทำระบบที่ซับซ้อน เช่น ควบคุมอุปกรณ์ผ่าน WebSocket หรือเชื่อม API ภายนอก
FAQ คำถามที่พบบ่อย
1. ArduinoJson รองรับ ESP8266 ไหม?
ได้ครับ ✅ ArduinoJson ใช้งานได้ทั้ง Arduino ทั่วไป, ESP8266, ESP32 รวมถึงบอร์ดอื่น ๆ ที่ใช้ C++11 ขึ้นไป
2. ใช้กับ ESP32 ได้ทุกบอร์ดหรือไม่?
รองรับทุกบอร์ดตระกูล ESP32 ไม่ว่าจะเป็น DevKit v1, NodeMCU-32S, ESP32-WROOM, ESP32-S2, ESP32-C3 หรือแม้แต่ ESP32-CAM
3. ทำไม JSON Document ต้องกำหนดขนาด?
เพราะ ArduinoJson ใช้พื้นที่หน่วยความจำ (RAM) ในการเก็บโครงสร้าง JSON
- ถ้า document เล็กเกินไป → เกิด error NoMemory
- ถ้าใหญ่เกินไป → RAM เสียไปโดยใช่เหตุ
4. ต่างกันอย่างไรระหว่าง StaticJsonDocument กับ DynamicJsonDocument?
- StaticJsonDocument → หน่วยความจำคงที่ (stack), เร็ว, เหมาะกับ JSON ขนาดเล็กและคงที่
- DynamicJsonDocument → หน่วยความจำ dynamic (heap), ยืดหยุ่น, เหมาะกับ JSON ขนาดใหญ่ แต่เสี่ยง heap แตก
5. ถ้า JSON มีข้อมูลจำนวนมากทำอย่างไร?
- แบ่ง JSON ออกเป็นหลายก้อนเล็ก ๆ (chunk)
- เลือกส่งเฉพาะข้อมูลสำคัญ
- ใช้ DynamicJsonDocument แต่ต้องกำหนดขนาดเผื่อให้พอ
6. ใช้ ArduinoJson ในการสื่อสาร MQTT ได้ไหม?
ได้ครับ 👍 โดยใช้ ArduinoJson สร้าง payload JSON แล้วส่งผ่าน MQTT เช่น
{"device":"pump1","status":"on"}และใช้ deserializeJson() ตอนรับข้อความกลับมา
7. เวอร์ชัน 5 กับเวอร์ชัน 6 ต่างกันอย่างไร?
- v5: syntax เก่า, ฟังก์ชันไม่ค่อยยืดหยุ่น
- v6: syntax ใหม่ ใช้งานง่ายขึ้น (serializeJson, deserializeJson)
👉 แนะนำให้ใช้ v6 เพราะเสถียรและมีตัวอย่างเยอะ
8. ถ้า parse JSON แล้ว error เกิดจากอะไร?
สาเหตุหลัก:
- JSON ไม่ถูกต้อง (ขาด {}, ” ไม่ครบ)
- ขนาด document ไม่พอ → NoMemory
- type ไม่ตรง เช่น อ่าน int จากค่า float
9. ใช้ ArduinoJson กับ Firebase ได้หรือไม่?
ได้ครับ สามารถใช้ ArduinoJson ช่วย จัดการข้อมูลก่อนส่งไป Firebase หรือ parse ข้อมูล JSON ที่ Firebase ส่งกลับมา ได้
10. มีวิธี debug ค่า JSON ยังไง?
- ใช้ serializeJsonPretty(doc, Serial); เพื่อพิมพ์ JSON ให้อ่านง่าย
- เช็ค DeserializationError ตอน parse
- ใช้ Serial Monitor ดูค่าแบบเรียลไทม์






