ESP32 Mengirim Data Sensor ke Server Menggunakan HTTP

Setelah ESP32 dapat membaca sensor, langkah berikutnya dalam project IoT biasanya adalah mengirim data tersebut ke server. Dengan begitu, data sensor tidak hanya tersedia pada ESP32, tetapi dapat disimpan, dianalisis, dan ditampilkan melalui aplikasi web.

Salah satu metode yang paling mudah digunakan adalah HTTP. ESP32 dapat terhubung ke WiFi, membaca sensor, kemudian mengirim data ke server menggunakan HTTP POST dalam format JSON.

Pada artikel ini kita akan membangun alur sederhana:

Sensor
   |
   v
ESP32
   |
   | WiFi
   |
   | HTTP POST + JSON
   v
Server / REST API
   |
   v
Database

Contoh implementasi akan menggunakan ESP32 sebagai IoT device dan server sebagai REST API. Pada bagian akhir, kita juga akan melihat contoh endpoint menggunakan Laravel agar ESP32 dapat mengirim data langsung ke aplikasi web.

Konsep ESP32 Mengirim Data ke Server

ESP32 bertindak sebagai HTTP client, sedangkan server bertindak sebagai HTTP server.

Berbeda dengan artikel sebelumnya tentang ESP32 Web Server, kali ini ESP32 bukan menerima request dari browser. ESP32 justru membuat request menuju server.

                    HTTP Request
ESP32 ---------------------------------> Server
  |                                       |
  | { temperature: 28.5 }                 |
  |                                       |
  | <---------------------------------    |
              HTTP Response

ESP32 dapat mengirim data seperti:

• Suhu.
• Kelembapan.
• Tekanan udara.
• Intensitas cahaya.
• Nilai analog.
• Status relay.
• Tegangan baterai.
• Data energi listrik.

Mengapa Menggunakan HTTP?

HTTP merupakan pilihan yang praktis untuk project IoT sederhana karena ekosistemnya sangat luas.

Keuntungannya antara lain:

• Mudah dipahami.
• Didukung hampir semua bahasa pemrograman.
• Mudah diintegrasikan dengan REST API.
• Mudah diuji menggunakan browser, curl, Postman, atau tools lainnya.
• Cocok untuk komunikasi device ke backend pada banyak project sederhana.

Namun, HTTP bukan selalu pilihan terbaik untuk semua skenario IoT. Jika jumlah device sangat besar atau membutuhkan komunikasi real-time dan hemat bandwidth, protokol seperti MQTT dapat menjadi pilihan yang lebih sesuai.

Arsitektur Sederhana

Contoh arsitektur yang akan dibuat:

+-------------+
|   Sensor    |
+------+------+
       |
       | GPIO / I2C
       v
+-------------+
|    ESP32    |
+------+------+
       |
       | WiFi
       |
       | POST /api/sensor
       v
+-------------+
| REST API    |
|   Server    |
+------+------+
       |
       v
+-------------+
|  Database   |
+-------------+

ESP32 membaca sensor secara berkala, kemudian mengirim data ke endpoint API.

Data Sensor dalam Format JSON

JSON merupakan format yang praktis untuk pertukaran data antara ESP32 dan server.

Contoh payload:

{
    "device_id": "ESP32-001",
    "temperature": 28.5,
    "humidity": 72.4
}

Server kemudian dapat membaca setiap field tersebut dan menyimpannya ke database.

Persiapan ESP32

Untuk contoh dasar, kita membutuhkan:

• ESP32 development board.
• Kabel USB.
• Arduino IDE.
• Jaringan WiFi.
• Sensor, atau nilai dummy untuk pengujian awal.
• Server yang menyediakan endpoint HTTP.

Sebelum menghubungkan sensor sebenarnya, sebaiknya uji komunikasi HTTP menggunakan data dummy terlebih dahulu. Dengan demikian kita dapat memastikan koneksi ESP32 ke server sudah benar.

Menghubungkan ESP32 ke WiFi

Gunakan library WiFi.h untuk menghubungkan ESP32 ke jaringan.

#include <WiFi.h>

const char* ssid = "NAMA_WIFI";
const char* password = "PASSWORD_WIFI";

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

    WiFi.begin(ssid, password);

    Serial.print("Menghubungkan ke WiFi");

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

    Serial.println();
    Serial.println("WiFi terhubung");
    Serial.println(WiFi.localIP());
}

void loop() {
}

Jika berhasil, Serial Monitor akan menampilkan IP address ESP32.

Mengirim HTTP POST dari ESP32

Untuk mengirim data ke server, kita dapat menggunakan library HTTPClient.h.

Contoh dasar:

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

const char* serverUrl = "http://192.168.1.100/api/sensor";

void sendData() {
    HTTPClient http;

    http.begin(serverUrl);
    http.addHeader("Content-Type", "application/json");

    String payload = "{\"temperature\":28.5}";

    int httpResponseCode = http.POST(payload);

    Serial.print("HTTP Response: ");
    Serial.println(httpResponseCode);

    http.end();
}

Method POST() digunakan untuk mengirim payload ke server.

Memahami HTTP Response Code

Server akan mengembalikan HTTP status code.

Beberapa status yang umum:

Status	Arti
200	Request berhasil.
201	Resource berhasil dibuat.
400	Request tidak valid.
401	Authentication diperlukan atau gagal.
403	Request ditolak.
404	Endpoint tidak ditemukan.
500	Error pada server.

Jika fungsi POST() menghasilkan nilai negatif, biasanya masalah terjadi pada sisi koneksi atau proses HTTP sebelum server memberikan response.

Membaca Response dari Server

Selain status code, ESP32 dapat membaca response body.

int httpResponseCode = http.POST(payload);

if (httpResponseCode > 0) {
    String response = http.getString();

    Serial.println(response);
} else {
    Serial.print("HTTP Error: ");
    Serial.println(httpResponseCode);
}

Misalnya server mengembalikan:

{
    "success": true,
    "message": "Data berhasil disimpan"
}

ESP32 dapat membaca response tersebut untuk mengetahui hasil request.

Membuat JSON Payload

Untuk payload sederhana, kita dapat membuat JSON menggunakan String.

float temperature = 28.5;
float humidity = 72.4;

String payload = "{";
payload += "\"device_id\":\"ESP32-001\",";
payload += "\"temperature\":";
payload += String(temperature, 2);
payload += ",";
payload += "\"humidity\":";
payload += String(humidity, 2);
payload += "}";

Serial.println(payload);

Output:

{
    "device_id": "ESP32-001",
    "temperature": 28.50,
    "humidity": 72.40
}

Menggunakan ArduinoJson

Untuk payload yang lebih kompleks, library ArduinoJson dapat membuat proses serialisasi JSON lebih rapi.

Contoh:

#include <ArduinoJson.h>

JsonDocument doc;

doc["device_id"] = "ESP32-001";
doc["temperature"] = 28.5;
doc["humidity"] = 72.4;

String payload;

serializeJson(doc, payload);

Serial.println(payload);

Untuk project dengan banyak field atau nested JSON, pendekatan ini biasanya lebih mudah dipelihara dibandingkan menyusun string JSON secara manual.

Contoh Data Sensor Dummy

Sebelum menggunakan sensor sebenarnya, kita dapat membuat nilai simulasi.

float temperature = 25.0 + random(0, 100) / 10.0;
float humidity = 60.0 + random(0, 300) / 10.0;

Dengan data dummy tersebut, komunikasi ESP32 dengan server dapat diuji tanpa memasang sensor terlebih dahulu.

Mengirim Data Setiap Beberapa Detik

Cara sederhana adalah menggunakan delay().

void loop() {
    sendData();

    delay(10000);
}

Artinya ESP32 akan mengirim data setiap 10 detik.

Namun, untuk project yang lebih kompleks, penggunaan delay() sebaiknya dihindari karena dapat membuat program menjadi blocking.

Menggunakan millis()

Pendekatan yang lebih fleksibel adalah menggunakan millis().

unsigned long lastSend = 0;
const unsigned long interval = 10000;

void loop() {
    unsigned long currentMillis = millis();

    if (currentMillis - lastSend >= interval) {
        lastSend = currentMillis;

        sendData();
    }
}

Dengan cara ini, ESP32 masih dapat menjalankan pekerjaan lain selama menunggu interval pengiriman data.

Membaca Sensor DHT

Sebagai contoh, kita dapat menggunakan sensor keluarga DHT untuk membaca suhu dan kelembapan. Implementasi detail pin dan tipe sensor harus disesuaikan dengan hardware yang digunakan.

Contoh:

#include <DHT.h>

#define DHTPIN 4
#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);

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

    dht.begin();
}

Membaca nilai sensor:

float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

if (isnan(temperature) || isnan(humidity)) {
    Serial.println("Gagal membaca sensor");
    return;
}

Menggabungkan Sensor dan HTTP

Sekarang nilai sensor dapat dimasukkan ke JSON payload.

float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

if (isnan(temperature) || isnan(humidity)) {
    return;
}

String payload = "{";
payload += "\"device_id\":\"ESP32-001\",";
payload += "\"temperature\":";
payload += String(temperature, 2);
payload += ",";
payload += "\"humidity\":";
payload += String(humidity, 2);
payload += "}";

Payload tersebut kemudian dikirim menggunakan HTTP POST.

Program ESP32 Lengkap

Berikut contoh lengkap menggunakan WiFi, DHT, HTTP POST, dan JSON sederhana.

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

#define DHTPIN 4
#define DHTTYPE DHT22

const char* ssid = "NAMA_WIFI";
const char* password = "PASSWORD_WIFI";

const char* serverUrl =
    "http://192.168.1.100/api/sensor";

DHT dht(DHTPIN, DHTTYPE);

unsigned long lastSend = 0;
const unsigned long interval = 10000;

void connectWiFi() {
    WiFi.begin(ssid, password);

    Serial.print("Menghubungkan ke WiFi");

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

    Serial.println();
    Serial.println("WiFi terhubung");
    Serial.print("IP: ");
    Serial.println(WiFi.localIP());
}

void sendSensorData() {
    if (WiFi.status() != WL_CONNECTED) {
        Serial.println("WiFi tidak terhubung");
        return;
    }

    float temperature = dht.readTemperature();
    float humidity = dht.readHumidity();

    if (isnan(temperature) || isnan(humidity)) {
        Serial.println("Gagal membaca sensor");
        return;
    }

    String payload = "{";
    payload += "\"device_id\":\"ESP32-001\",";
    payload += "\"temperature\":";
    payload += String(temperature, 2);
    payload += ",";
    payload += "\"humidity\":";
    payload += String(humidity, 2);
    payload += "}";

    HTTPClient http;

    http.begin(serverUrl);
    http.addHeader(
        "Content-Type",
        "application/json"
    );

    int responseCode = http.POST(payload);

    Serial.print("Payload: ");
    Serial.println(payload);

    Serial.print("HTTP Response: ");
    Serial.println(responseCode);

    if (responseCode > 0) {
        String response = http.getString();

        Serial.print("Server Response: ");
        Serial.println(response);
    }

    http.end();
}

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

    dht.begin();

    connectWiFi();
}

void loop() {
    unsigned long currentMillis = millis();

    if (currentMillis - lastSend >= interval) {
        lastSend = currentMillis;

        sendSensorData();
    }
}

Membuat REST API di Laravel

Sekarang kita dapat membuat server menggunakan Laravel sebagai backend.

Misalnya ESP32 akan mengirim request:

POST /api/sensor
Content-Type: application/json

Dengan payload:

{
    "device_id": "ESP32-001",
    "temperature": 28.5,
    "humidity": 72.4
}

Membuat Route API Laravel

Tambahkan route pada file API aplikasi Laravel sesuai struktur versi Laravel yang digunakan.

use App\Http\Controllers\SensorController;
use Illuminate\Support\Facades\Route;

Route::post('/sensor', [
    SensorController::class,
    'store'
]);

Endpoint kemudian menjadi:

POST /api/sensor

Membuat SensorController

Buat controller:

php artisan make:controller SensorController

Kemudian buat method store().

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class SensorController extends Controller
{
    public function store(Request $request)
    {
        $data = $request->validate([
            'device_id' => ['required', 'string'],
            'temperature' => ['required', 'numeric'],
            'humidity' => ['required', 'numeric'],
        ]);

        return response()->json([
            'success' => true,
            'data' => $data,
        ]);
    }
}

Untuk tahap awal, endpoint tersebut hanya mengembalikan data yang diterima.

Menguji API dengan curl

Sebelum menggunakan ESP32, sebaiknya API diuji terlebih dahulu dari komputer.

curl -X POST http://localhost:8000/api/sensor \
  -H "Content-Type: application/json" \
  -d '{
    "device_id": "ESP32-001",
    "temperature": 28.5,
    "humidity": 72.4
  }'

Jika API menghasilkan response yang benar, barulah ESP32 diarahkan ke endpoint tersebut.

Menyimpan Data Sensor ke Database

Jika data sensor ingin disimpan, buat migration.

php artisan make:model SensorReading -m

Contoh migration:

Schema::create('sensor_readings', function (Blueprint $table) {
    $table->id();
    $table->string('device_id');
    $table->decimal('temperature', 8, 2);
    $table->decimal('humidity', 8, 2);
    $table->timestamps();
});

Setelah migration selesai:

php artisan migrate

Menyimpan Data dari Controller

Model dapat digunakan untuk menyimpan data.

use App\Models\SensorReading;

public function store(Request $request)
{
    $data = $request->validate([
        'device_id' => ['required', 'string'],
        'temperature' => ['required', 'numeric'],
        'humidity' => ['required', 'numeric'],
    ]);

    $reading = SensorReading::create($data);

    return response()->json([
        'success' => true,
        'data' => $reading,
    ], 201);
}

Jangan lupa mengatur fillable pada model jika menggunakan mass assignment.

class SensorReading extends Model
{
    protected $fillable = [
        'device_id',
        'temperature',
        'humidity',
    ];
}

Alur Lengkap ESP32 ke Laravel

+----------------+
| DHT22 / Sensor |
+-------+--------+
        |
        | Temperature
        | Humidity
        v
+----------------+
|     ESP32      |
+-------+--------+
        |
        | WiFi
        |
        | POST JSON
        v
+----------------+
| Laravel API    |
| /api/sensor    |
+-------+--------+
        |
        | Validation
        v
+----------------+
| SensorReading  |
+-------+--------+
        |
        v
+----------------+
|    Database    |
+----------------+

Authentication API

Jangan membuat endpoint IoT production terbuka tanpa mempertimbangkan authentication.

Tanpa authentication, siapa pun yang dapat mencapai endpoint mungkin dapat mencoba mengirim data palsu.

Salah satu pendekatan sederhana adalah menggunakan API key.

ESP32 dapat mengirim header:

http.addHeader(
    "X-API-Key",
    "SECRET_API_KEY"
);

Server kemudian memvalidasi API key tersebut.

Contoh sederhana di Laravel:

if ($request->header('X-API-Key') !== config('services.iot.api_key')) {
    return response()->json([
        'message' => 'Unauthorized'
    ], 401);
}

Untuk production, sebaiknya gunakan mekanisme credential dan secret management yang lebih matang daripada menaruh secret secara langsung di source code.

HTTPS untuk ESP32

HTTP biasa mengirim data tanpa enkripsi transport. Untuk jaringan yang tidak sepenuhnya terpercaya, gunakan HTTPS.

Secara konseptual:

Tidak aman:

ESP32
  |
  | HTTP
  v
Server


Lebih aman:

ESP32
  |
  | HTTPS / TLS
  v
Server

Dengan HTTPS, data dan credential dapat dilindungi selama transmisi menggunakan TLS.

Implementasi TLS pada ESP32 perlu menggunakan client HTTPS dan konfigurasi certificate atau trust model yang sesuai dengan kebutuhan perangkat.

Contoh HTTPS pada ESP32

Pada ESP32, koneksi HTTPS dapat menggunakan WiFiClientSecure.

#include <WiFiClientSecure.h>
#include <HTTPClient.h>

WiFiClientSecure client;

client.setInsecure();

HTTPClient http;

http.begin(
    client,
    "https://example.com/api/sensor"
);

Catatan:setInsecure() menonaktifkan verifikasi sertifikat server. Ini dapat berguna untuk testing tertentu, tetapi tidak disarankan untuk production karena menghilangkan perlindungan verifikasi sertifikat.

Untuk production, gunakan verifikasi certificate yang sesuai.

Retry Ketika Server Tidak Bisa Dihubungi

Perangkat IoT harus menganggap koneksi jaringan dapat gagal kapan saja.

Contoh:

ESP32
  |
  | POST
  v
Server
  |
  X Connection failed
  |
  v
ESP32 menyimpan / retry

Jangan langsung melakukan retry tanpa batas dalam loop karena dapat membuat device terus-menerus membebani jaringan dan server.

Gunakan jumlah retry dan interval yang wajar.

Exponential Backoff

Untuk sistem yang lebih besar, retry dapat menggunakan exponential backoff.

Attempt 1 -> tunggu 1 detik
Attempt 2 -> tunggu 2 detik
Attempt 3 -> tunggu 4 detik
Attempt 4 -> tunggu 8 detik
...

Pendekatan ini membantu mencegah banyak device melakukan retry bersamaan ketika server mengalami gangguan.

Bagaimana Jika WiFi Terputus?

ESP32 sebaiknya dapat mencoba melakukan reconnect.

if (WiFi.status() != WL_CONNECTED) {
    Serial.println("WiFi terputus");

    WiFi.reconnect();
}

Untuk production, mekanisme reconnect sebaiknya memiliki timeout dan strategi retry yang tidak menyebabkan loop blocking terlalu lama.

Jangan Mengirim Data Terlalu Sering

Misalnya ada 1.000 perangkat yang mengirim data setiap detik.

1.000 device
     |
     | 1 request / second
     v
1.000 request / second
     |
     v
Server + Database

Jumlah request tersebut dapat menjadi beban besar.

Interval pengiriman harus disesuaikan dengan kebutuhan bisnis dan karakteristik data sensor.

Untuk sensor suhu ruangan, misalnya, mengirim setiap beberapa detik mungkin tidak selalu diperlukan.

Batching Data

Jika data tidak harus dikirim secara real-time, ESP32 dapat mengumpulkan beberapa reading terlebih dahulu lalu mengirimnya sekaligus.

{
    "device_id": "ESP32-001",
    "readings": [
        {
            "temperature": 28.1,
            "humidity": 70.2
        },
        {
            "temperature": 28.3,
            "humidity": 71.0
        },
        {
            "temperature": 28.5,
            "humidity": 72.4
        }
    ]
}

Batching dapat mengurangi jumlah HTTP request jika kebutuhan real-time tidak terlalu tinggi.

Timestamp Data Sensor

Server sebaiknya mengetahui kapan sebuah reading dibuat.

ESP32 dapat mengirim timestamp:

{
    "device_id": "ESP32-001",
    "temperature": 28.5,
    "humidity": 72.4,
    "timestamp": "2026-09-04T10:15:30Z"
}

Namun, pastikan clock ESP32 sudah disinkronkan jika timestamp berasal dari device. Alternatifnya, server dapat menetapkan timestamp saat request diterima.

Device ID

Ketika hanya memiliki satu ESP32, device ID mungkin terlihat tidak penting.

Namun ketika jumlah device bertambah, server perlu membedakan setiap perangkat.

ESP32-001
ESP32-002
ESP32-003
ESP32-004
...

Contoh payload:

{
    "device_id": "ESP32-003",
    "temperature": 29.1
}

Server kemudian dapat mengelompokkan data berdasarkan device.

Idempotency dan Duplicate Data

Dalam sistem IoT, request dapat terkirim ulang karena timeout atau retry.

Akibatnya, server mungkin menerima data yang sama lebih dari satu kali.

Untuk proses tertentu, gunakan identifier unik atau sequence number.

{
    "device_id": "ESP32-001",
    "sequence": 1025,
    "temperature": 28.5
}

Server dapat menggunakan sequence tersebut untuk mendeteksi duplicate data sesuai kebutuhan.

Validasi Data di Server

Jangan percaya data hanya karena berasal dari ESP32.

Server tetap harus melakukan validation.

$data = $request->validate([
    'device_id' => [
        'required',
        'string',
        'max:100'
    ],
    'temperature' => [
        'required',
        'numeric',
        'between:-50,100'
    ],
    'humidity' => [
        'required',
        'numeric',
        'between:0,100'
    ],
]);

Range tersebut hanya contoh dan harus disesuaikan dengan sensor serta kebutuhan aplikasi.

Rate Limiting pada API IoT

Endpoint IoT juga sebaiknya memiliki rate limiting.

Contoh Laravel:

Route::post('/sensor', [
    SensorController::class,
    'store'
])->middleware('throttle:120,1');

Aturan tersebut harus disesuaikan dengan jumlah device dan frekuensi pengiriman yang direncanakan.

Untuk sistem dengan banyak device, rate limit berdasarkan device ID atau API credential sering lebih masuk akal daripada hanya berdasarkan IP.

Monitoring Request IoT

Server sebaiknya mencatat informasi penting seperti:

• Device ID.
• Waktu request.
• HTTP status.
• Response time.
• Nilai sensor.
• Jumlah request gagal.

Dengan monitoring tersebut, kita dapat mengetahui apakah ada device yang sering gagal mengirim data.

Debugging ESP32 HTTP

Serial Monitor merupakan alat debugging paling sederhana.

Contoh informasi yang dapat dicetak:

Serial.println("Mengirim data...");

Serial.print("URL: ");
Serial.println(serverUrl);

Serial.print("Payload: ");
Serial.println(payload);

Serial.print("Response Code: ");
Serial.println(responseCode);

Serial.print("Response: ");
Serial.println(response);

Dengan informasi tersebut, proses troubleshooting menjadi jauh lebih mudah.

Checklist Troubleshooting

ESP32 Tidak Terhubung WiFi

• Periksa SSID.
• Periksa password.
• Periksa kekuatan sinyal.
• Pastikan konfigurasi jaringan kompatibel dengan board.

HTTP Request Gagal

• Periksa URL server.
• Periksa IP address server.
• Periksa port.
• Pastikan server dapat dijangkau dari jaringan ESP32.
• Periksa firewall.

Server Mengembalikan 404

Pastikan route API benar.

POST /api/sensor

Pastikan juga HTTP method yang digunakan ESP32 sama dengan method yang didefinisikan server.

Server Mengembalikan 400

Periksa JSON payload dan validation.

Server Mengembalikan 401

Periksa API key atau authentication credential.

Server Mengembalikan 500

Periksa application log pada server. Masalah kemungkinan terjadi pada backend atau database.

HTTP vs MQTT untuk IoT

HTTP mudah digunakan, tetapi MQTT sering menjadi pilihan populer untuk sistem IoT yang membutuhkan komunikasi lebih efisien.

Aspek	HTTP	MQTT
Model	Request/Response	Publish/Subscribe
Implementasi awal	Relatif sederhana	Memerlukan broker
REST API	Sangat cocok	Tidak berbasis REST
Real-time	Bisa, tetapi tidak selalu ideal	Cocok
Skala IoT besar	Tergantung arsitektur	Sering lebih sesuai

Untuk project belajar dan integrasi sederhana dengan Laravel REST API, HTTP merupakan titik awal yang sangat baik.

Arsitektur Production yang Lebih Kompleks

Ketika jumlah device bertambah, arsitektur dapat berkembang menjadi:

+------------------+
|      ESP32       |
| Device 001       |
+--------+---------+
         |
         | HTTPS
         v
+------------------+
|   API Gateway    |
+--------+---------+
         |
         v
+------------------+
|   Laravel API    |
+--------+---------+
         |
    +----+----+
    |         |
    v         v
 Database    Queue
               |
               v
            Worker

Queue dapat digunakan untuk pekerjaan yang tidak harus diselesaikan secara langsung dalam HTTP request.

Menyimpan Data Offline pada ESP32

Bagaimana jika internet atau server tidak tersedia?

Dalam sistem IoT yang membutuhkan reliability tinggi, ESP32 dapat menyimpan data sementara dan mengirimkannya kembali ketika koneksi tersedia.

Sensor
  |
  v
ESP32
  |
  +---- Server OK ----> Kirim data
  |
  +---- Server gagal -> Simpan sementara
                         |
                         v
                    Koneksi kembali
                         |
                         v
                     Kirim ulang

Media penyimpanan dapat berupa flash, filesystem, atau storage lain yang sesuai dengan kebutuhan dan keterbatasan hardware.

Jangan Mengirim Data Mentah Tanpa Pertimbangan

Data sensor perlu diproses sesuai kebutuhan.

Misalnya sensor dibaca setiap 100 ms, tetapi aplikasi hanya membutuhkan rata-rata suhu setiap 10 detik.

Daripada mengirim seluruh reading:

10 reading / second
600 reading / minute

ESP32 dapat melakukan agregasi terlebih dahulu:

ESP32
  |
  | 600 reading
  v
Average
  |
  | 1 value
  v
Server

Pendekatan ini dapat mengurangi bandwidth dan beban server.

Best Practice ESP32 Mengirim Data ke Server

• Gunakan HTTP POST untuk mengirim data.
• Gunakan JSON sebagai format payload jika sesuai dengan API.
• Gunakan HTTPS untuk komunikasi production yang membutuhkan confidentiality dan integrity.
• Gunakan authentication atau API credential.
• Validasi seluruh data di server.
• Gunakan device ID yang unik.
• Jangan mengirim data terlalu sering tanpa alasan.
• Gunakan millis() untuk scheduler sederhana yang tidak blocking.
• Tangani WiFi disconnect.
• Tangani server timeout dan error.
• Gunakan retry dengan backoff jika diperlukan.
• Pertimbangkan duplicate data ketika menggunakan retry.
• Gunakan database index yang sesuai untuk data sensor.
• Monitor request dan error pada server.

Checklist Sebelum Project IoT Production

• ESP32 dapat reconnect ketika WiFi terputus.
• API memiliki authentication.
• API menggunakan HTTPS jika dibutuhkan.
• Payload divalidasi di server.
• Device ID dapat diidentifikasi.
• HTTP error ditangani ESP32.
• Server memiliki rate limiting.
• Data duplicate dapat ditangani.
• Interval pengiriman sudah diperhitungkan.
• Data sensor memiliki timestamp yang dapat dipercaya.
• Ada monitoring dan logging.
• Ada strategi ketika server tidak tersedia.

Ringkasan

Komponen	Fungsi
WiFi.h	Menghubungkan ESP32 ke jaringan WiFi.
HTTPClient.h	Mengirim HTTP request dari ESP32.
HTTP POST	Mengirim data sensor ke endpoint server.
application/json	Content type untuk payload JSON.
WiFiClientSecure	Mendukung koneksi HTTPS/TLS.
Device ID	Membedakan satu device dengan device lainnya.
REST API	Interface antara ESP32 dan backend.

Kesimpulan

ESP32 mengirim data sensor ke server menggunakan HTTP merupakan salah satu pola dasar yang penting dalam pengembangan IoT. ESP32 dapat membaca sensor, terhubung ke WiFi, membuat HTTP POST request, mengirim payload JSON, kemudian menerima response dari server.

Dengan REST API, data tersebut dapat diteruskan ke backend seperti Laravel untuk divalidasi dan disimpan ke database. Dari sini, sistem dapat dikembangkan menjadi dashboard monitoring, histori sensor, alert, analitik, dan kontrol perangkat.

Untuk prototype, kombinasi ESP32 + HTTP + JSON + REST API sudah cukup untuk memahami dasar komunikasi device dengan server. Ketika jumlah perangkat dan kebutuhan reliability meningkat, sistem dapat dikembangkan dengan HTTPS, authentication, retry dengan backoff, queue, caching, offline storage, batching, monitoring, atau bahkan berpindah ke protokol seperti MQTT.

Prinsip terpentingnya adalah jangan hanya memastikan ESP32 dapat mengirim data. Pastikan juga server mampu memvalidasi, mengautentikasi, menyimpan, memonitor, dan menangani kegagalan komunikasi dengan baik.