Panduan Konfigurasi PlatformIO untuk ESP32 dengan Sensor Ultrasonik HC-SR04

Pendahuluan

Dokumentasi ini menjelaskan implementasi sistem pengukur tinggi badan anak menggunakan ESP32 DevKitC v4 dan sensor ultrasonik HC-SR04. Sistem ini menggunakan filter moving average dan median untuk stabilisasi data, dilengkapi dengan validasi, kalibrasi, dan output JSON untuk integrasi sistem.

1. Persiapan Lingkungan Pengembangan

1.1 Membuat Virtual Environment Python

Virtual environment Python memastikan isolasi dependensi proyek untuk menghindari konflik versi package.

python3 -m venv venv

1.2 Mengaktifkan Virtual Environment

Aktifkan environment sebelum menjalankan perintah PlatformIO:

source venv/bin/activate

1.3 Instalasi PlatformIO

PlatformIO adalah framework cross-platform untuk pengembangan embedded systems dan IoT.

pip install platformio

2. Inisialisasi Proyek ESP32

2.1 Membuat Direktori Proyek

mkdir sok-anak-hw && cd sok-anak-hw

2.2 Inisialisasi PlatformIO untuk ESP32

pio init --board esp32dev

Perintah ini menghasilkan struktur proyek:

• platformio.ini - File konfigurasi utama
• src/ - Direktori source code
• lib/ - Library eksternal
• include/ - Header files (opsional)
• test/ - Unit tests (opsional)

3. Struktur Proyek PlatformIO

sok-anak-hw
├── include
│   └── README
├── lib
│   └── README
├── platformio.ini
├── src
│   └── main.cpp
└── test
    └── README

4. Spesifikasi Hardware

Komponen	Spesifikasi
Board	ESP32 DevKitC v4
MCU	ESP32-WROOM-32
Sensor	HC-SR04 Ultrasonic
Pin Trigger	GPIO23
Pin Echo	GPIO22
Tombol Kalibrasi	GPIO19
LED Status	GPIO2 (onboard)

5. Implementasi Kode Sensor Ultrasonik

5.1 Membuat File Source Utama

nano src/main.cpp

5.2 Kode Program Lengkap

#include <Arduino.h>
#include <NewPing.h>
#include <ArduinoJson.h>

/**
 * SISTEM PENGUKUR TINGGI BADAN ANAK
 * 
 * Fitur:
 * 1. Pengukuran tinggi badan anak (150cm - jarak)
 * 2. Moving average filter untuk pembacaan stabil
 * 3. Validasi data (outlier detection)
 * 4. Output JSON untuk pemrosesan data lanjutan
 * 5. Mode debugging dan kalibrasi
 */

// ==================== KONFIGURASI PIN ====================
#define TRIGGER_PIN      23
#define ECHO_PIN         22
#define CALIB_BUTTON     19
#define STATUS_LED       2      // LED onboard ESP32

// ==================== KONSTANTA SISTEM ====================
const float POLE_HEIGHT_CM = 150.0;      // Tinggi tiang penyangga sensor
const float MIN_VALID_HEIGHT = 50.0;     // Tinggi minimum valid (cm)
const float MAX_VALID_HEIGHT = 150.0;    // Tinggi maksimum valid (cm)
const float MAX_SENSOR_RANGE = 200.0;    // Maksimal jarak sensor (cm) - nama diubah

// Konfigurasi filter
const int NUM_READINGS = 15;             // Jumlah sampel untuk moving average
const int MEDIAN_WINDOW = 5;             // Ukuran window untuk median filter

// Threshold untuk deteksi outlier
const float DISTANCE_JUMP_THRESHOLD = 20.0;  // cm
const int STABLE_READING_COUNT = 3;          // Jumlah pembacaan stabil

// ==================== DEKLARASI OBJEK ====================
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_SENSOR_RANGE);

// ==================== VARIABEL SISTEM ====================
float readings[NUM_READINGS];
int readIndex = 0;
float total = 0;
float medianBuffer[MEDIAN_WINDOW];
int medianIndex = 0;

// State variables
float currentDistance = 0;
float currentHeight = 0;
float averageHeight = 0;
bool isStable = false;
int stableCount = 0;
unsigned long lastMeasurementTime = 0;
unsigned long measurementInterval = 250; // ms

// Kalibrasi
float calibrationOffset = 0.0;
bool debugMode = false;

// ==================== PROTOTIPE FUNGSI ====================
void initializeSystem();
void printSystemInfo();
float getFilteredDistance();
float getMedianDistance();
float calculateHeight(float distance);
bool validateHeight(float height);
void processMeasurement();
void printMeasurement();
void printJSONMeasurement();
void calibrationRoutine();
void printDebugInfo();
void blinkLED(int times, int delayTime);
void handleSerialCommands();

// ==================== SETUP SISTEM ====================
void setup() {
  Serial.begin(115200);
  delay(1000);  // Tunggu Serial ready
  
  // Inisialisasi pin
  pinMode(STATUS_LED, OUTPUT);
  pinMode(CALIB_BUTTON, INPUT_PULLUP);
  
  // Inisialisasi array
  for (int i = 0; i < NUM_READINGS; i++) {
    readings[i] = 0;
  }
  
  for (int i = 0; i < MEDIAN_WINDOW; i++) {
    medianBuffer[i] = 0;
  }
  
  initializeSystem();
  printSystemInfo();
  blinkLED(3, 200);  // Indikator startup
}

// ==================== LOOP UTAMA ====================
void loop() {
  // Handle serial commands
  handleSerialCommands();
  
  // Cek tombol kalibrasi
  if (digitalRead(CALIB_BUTTON) == LOW) {
    delay(50);  // Debounce
    if (digitalRead(CALIB_BUTTON) == LOW) {
      calibrationRoutine();
    }
  }
  
  // Pengukuran pada interval tertentu
  unsigned long currentTime = millis();
  if (currentTime - lastMeasurementTime >= measurementInterval) {
    processMeasurement();
    lastMeasurementTime = currentTime;
  }
  
  // Update LED status
  digitalWrite(STATUS_LED, isStable ? HIGH : LOW);
}

// ==================== IMPLEMENTASI FUNGSI ====================

/**
 * Inisialisasi sistem
 */
void initializeSystem() {
  Serial.println("\n" + String(80, '='));
  Serial.println("SISTEM PENGUKUR TINGGI BADAN ANAK");
  Serial.println(String(80, '='));
  Serial.println("Konfigurasi:");
  Serial.println("- Tinggi tiang: " + String(POLE_HEIGHT_CM) + " cm");
  Serial.println("- Rentang valid: " + String(MIN_VALID_HEIGHT) + " - " + 
                 String(MAX_VALID_HEIGHT) + " cm");
  Serial.println("- Filter: Moving Average (" + String(NUM_READINGS) + " samples)");
  Serial.println("- Filter: Median (" + String(MEDIAN_WINDOW) + " samples)");
  Serial.println(String(80, '-'));
  Serial.println("Perintah Serial:");
  Serial.println("  'd' - Toggle debug mode");
  Serial.println("  'c' - Kalibrasi");
  Serial.println("  'j' - Toggle JSON output");
  Serial.println("  'r' - Reset filter");
  Serial.println("  '?' - Tampilkan info sistem");
  Serial.println(String(80, '=') + "\n");
}

/**
 * Tampilkan info sistem
 */
void printSystemInfo() {
  Serial.println("\n=== INFO SISTEM ===");
  Serial.println("Status: " + String(isStable ? "STABIL" : "MENCARI"));
  Serial.println("Offset Kalibrasi: " + String(calibrationOffset, 1) + " cm");
  Serial.println("Interval Pengukuran: " + String(measurementInterval) + " ms");
  Serial.println("Mode Debug: " + String(debugMode ? "AKTIF" : "NON-AKTIF"));
  Serial.println("===================\n");
}

/**
 * Dapatkan jarak terfilter dengan moving average
 */
float getFilteredDistance() {
  // Kurangkan nilai lama dari total
  total -= readings[readIndex];
  
  // Baca jarak baru dari sensor
  delay(30);  // Waktu stabilisasi sensor
  unsigned int pingTime = sonar.ping();
  float newDistance = sonar.convert_cm(pingTime);
  
  // Validasi pembacaan
  if (newDistance <= 0 || newDistance > MAX_SENSOR_RANGE) {
    newDistance = 0;  // Invalid reading
  }
  
  // Update moving average
  readings[readIndex] = newDistance;
  total += newDistance;
  readIndex = (readIndex + 1) % NUM_READINGS;
  
  return total / NUM_READINGS;
}

/**
 * Dapatkan jarak dengan median filter
 */
float getMedianDistance() {
  float filteredDistance = getFilteredDistance();
  
  // Update median buffer
  medianBuffer[medianIndex] = filteredDistance;
  medianIndex = (medianIndex + 1) % MEDIAN_WINDOW;
  
  // Sort buffer untuk mencari median
  float tempBuffer[MEDIAN_WINDOW];
  memcpy(tempBuffer, medianBuffer, sizeof(tempBuffer));
  
  // Bubble sort sederhana
  for (int i = 0; i < MEDIAN_WINDOW - 1; i++) {
    for (int j = 0; j < MEDIAN_WINDOW - i - 1; j++) {
      if (tempBuffer[j] > tempBuffer[j + 1]) {
        float temp = tempBuffer[j];
        tempBuffer[j] = tempBuffer[j + 1];
        tempBuffer[j + 1] = temp;
      }
    }
  }
  
  // Return median (middle value)
  return tempBuffer[MEDIAN_WINDOW / 2];
}

/**
 * Hitung tinggi badan dari jarak
 */
float calculateHeight(float distance) {
  if (distance <= 0 || distance > POLE_HEIGHT_CM - MIN_VALID_HEIGHT) {
    return 0;  // Invalid
  }
  return POLE_HEIGHT_CM - distance + calibrationOffset;
}

/**
 * Validasi tinggi badan
 */
bool validateHeight(float height) {
  return (height >= MIN_VALID_HEIGHT && height <= MAX_VALID_HEIGHT);
}

/**
 * Proses pengukuran
 */
void processMeasurement() {
  // Dapatkan jarak terfilter
  float distance = getMedianDistance();
  currentDistance = distance;
  
  // Hitung tinggi badan
  float height = calculateHeight(distance);
  currentHeight = height;
  
  // Update average height jika valid
  if (validateHeight(height)) {
    // Deteksi perubahan mendadak (outlier)
    static float lastValidHeight = 0;
    if (abs(height - lastValidHeight) < DISTANCE_JUMP_THRESHOLD || lastValidHeight == 0) {
      stableCount++;
      lastValidHeight = height;
      
      if (stableCount >= STABLE_READING_COUNT) {
        isStable = true;
        averageHeight = (averageHeight * 0.7) + (height * 0.3);  // Exponential moving average
      }
    } else {
      stableCount = 0;
      isStable = false;
    }
  } else {
    stableCount = 0;
    isStable = false;
  }
  
  // Tampilkan hasil
  printMeasurement();
  
  if (debugMode) {
    printDebugInfo();
  }
}

/**
 * Tampilkan hasil pengukuran
 */
void printMeasurement() {
  static unsigned long lastPrint = 0;
  
  if (millis() - lastPrint < 500 && !isStable) {
    return;  // Batasi output untuk pembacaan tidak stabil
  }
  
  Serial.print("T: ");
  Serial.print(millis() / 1000.0, 1);
  Serial.print("s | ");
  
  if (isStable) {
    Serial.print("TINGGI: ");
    Serial.print(averageHeight, 1);
    Serial.print(" cm");
    
    // Tambahkan kategori berdasarkan tinggi
    if (averageHeight < 100) {
      Serial.print(" (Balita)");
    } else if (averageHeight < 120) {
      Serial.print(" (Anak Kecil)");
    } else if (averageHeight < 140) {
      Serial.print(" (Anak Besar)");
    } else {
      Serial.print(" (Remaja)");
    }
  } else {
    Serial.print("Mengukur... ");
    Serial.print(currentHeight, 1);
    Serial.print(" cm");
    
    if (currentHeight < MIN_VALID_HEIGHT) {
      Serial.print(" (Terlalu dekat)");
    } else if (currentHeight > MAX_VALID_HEIGHT) {
      Serial.print(" (Tidak terdeteksi)");
    }
  }
  
  if (debugMode) {
    Serial.print(" | D: ");
    Serial.print(currentDistance, 1);
    Serial.print(" cm | S: ");
    Serial.print(stableCount);
  }
  
  Serial.println();
  lastPrint = millis();
}

/**
 * Tampilkan output JSON (untuk integrasi dengan software lain)
 */
void printJSONMeasurement() {
  JsonDocument doc;  // Gunakan JsonDocument bukan StaticJsonDocument
  
  doc["timestamp"] = millis();
  doc["distance_cm"] = currentDistance;
  doc["height_cm"] = currentHeight;
  doc["average_height_cm"] = averageHeight;
  doc["stable"] = isStable;
  doc["stable_count"] = stableCount;
  doc["valid"] = validateHeight(currentHeight);
  
  serializeJson(doc, Serial);
  Serial.println();
}

/**
 * Rutin kalibrasi
 */
void calibrationRoutine() {
  Serial.println("\n=== MULAI KALIBRASI ===");
  Serial.println("Letakkan objek dengan tinggi diketahui di bawah sensor");
  Serial.println("Tekan Enter untuk melanjutkan...");
  
  while (Serial.available() == 0) {
    delay(100);
  }
  Serial.readString();  // Clear buffer
  
  Serial.print("Masukkan tinggi objek (cm): ");
  while (Serial.available() == 0) {
    delay(100);
  }
  
  float referenceHeight = Serial.parseFloat();
  Serial.println(referenceHeight);
  
  Serial.println("Mengukur...");
  
  // Ambil beberapa sampel untuk kalibrasi
  float totalMeasuredHeight = 0;
  const int calibSamples = 10;
  
  for (int i = 0; i < calibSamples; i++) {
    float distance = getMedianDistance();
    float height = POLE_HEIGHT_CM - distance;
    totalMeasuredHeight += height;
    
    Serial.print("Sampel ");
    Serial.print(i + 1);
    Serial.print(": ");
    Serial.print(height, 1);
    Serial.println(" cm");
    
    delay(200);
  }
  
  float measuredHeight = totalMeasuredHeight / calibSamples;
  calibrationOffset = referenceHeight - measuredHeight;
  
  Serial.println("\n=== HASIL KALIBRASI ===");
  Serial.print("Tinggi referensi: ");
  Serial.print(referenceHeight, 1);
  Serial.println(" cm");
  Serial.print("Tinggi terukur: ");
  Serial.print(measuredHeight, 1);
  Serial.println(" cm");
  Serial.print("Offset: ");
  Serial.print(calibrationOffset, 1);
  Serial.println(" cm");
  Serial.println("=== KALIBRASI SELESAI ===\n");
  
  blinkLED(5, 100);  // Indikator kalibrasi selesai
}

/**
 * Tampilkan info debug
 */
void printDebugInfo() {
  static unsigned long lastDebugPrint = 0;
  
  if (millis() - lastDebugPrint < 1000) {
    return;
  }
  
  Serial.println("\n--- DEBUG INFO ---");
  Serial.print("Raw Distance: ");
  Serial.print(currentDistance);
  Serial.println(" cm");
  
  Serial.print("Readings Buffer: ");
  for (int i = 0; i < NUM_READINGS; i++) {
    Serial.print(readings[(readIndex + i) % NUM_READINGS], 0);
    Serial.print(" ");
  }
  Serial.println();
  
  Serial.print("Total: ");
  Serial.print(total);
  Serial.print(", Average: ");
  Serial.print(total / NUM_READINGS, 1);
  Serial.println();
  
  Serial.print("Free Heap: ");
  Serial.print(ESP.getFreeHeap());
  Serial.println(" bytes");
  Serial.println("-----------------\n");
  
  lastDebugPrint = millis();
}

/**
 * LED blinking untuk indikasi
 */
void blinkLED(int times, int delayTime) {
  for (int i = 0; i < times; i++) {
    digitalWrite(STATUS_LED, HIGH);
    delay(delayTime);
    digitalWrite(STATUS_LED, LOW);
    delay(delayTime);
  }
}

/**
 * Handle serial commands
 */
void handleSerialCommands() {
  if (Serial.available() > 0) {
    char command = Serial.read();
    
    switch (command) {
      case 'd':  // Toggle debug mode
        debugMode = !debugMode;
        Serial.println("Debug mode: " + String(debugMode ? "ON" : "OFF"));
        break;
        
      case 'c':  // Kalibrasi
        calibrationRoutine();
        break;
        
      case 'j':  // JSON output
        printJSONMeasurement();
        break;
        
      case 'r':  // Reset filter
        for (int i = 0; i < NUM_READINGS; i++) {
          readings[i] = 0;
        }
        total = 0;
        stableCount = 0;
        isStable = false;
        Serial.println("Filter reset");
        break;
        
      case '?':  // System info
        printSystemInfo();
        break;
        
      case 'i':  // Increase interval
        measurementInterval += 50;
        Serial.println("Interval: " + String(measurementInterval) + " ms");
        break;
        
      case 'k':  // Decrease interval
        if (measurementInterval > 100) {
          measurementInterval -= 50;
        }
        Serial.println("Interval: " + String(measurementInterval) + " ms");
        break;
        
      case '\n':  // Ignore newline
      case '\r':
        break;
        
      default:
        Serial.println("Perintah tidak dikenal. Gunakan '?' untuk bantuan.");
    }
  }
}

6. Build dan Upload Program

6.1 Clean Build Project

pio run --target clean

6.2 Build dan Upload Project

pio run --target upload

PlatformIO akan otomatis:

1. Mengunduh dependensi yang diperlukan
2. Mengompilasi source code
3. Mengupload firmware ke ESP32

7. Troubleshooting Upload

7.1 Identifikasi Port Serial

ls /dev/ttyUSB*

7.2 Upload dengan Port Spesifik

pio run --target upload --upload-port /dev/ttyUSB0

8. Serial Monitoring

8.1 Membuka Serial Monitor

pio device monitor

8.2 Serial Monitor dengan Baudrate Khusus

pio device monitor -b 115200

9. Mode Download untuk ESP32 DevKitC v4

Prosedur Masuk Mode Download Manual:

1. Tahan tombol BOOT pada ESP32
2. Tekan dan lepas tombol EN (reset)
3. Lepas tombol BOOT

ESP32 DevKitC v4 memerlukan prosedur ini karena tidak memiliki auto-reset circuit untuk programming.

10. Dependencies dan Library

Proyek ini menggunakan library berikut:

• Framework: Arduino (via PlatformIO)
• NewPing: v1.9.7 (library sensor ultrasonik)
• ArduinoJson: v7.4.2 (untuk serialisasi JSON)
• Platform: espressif32

Kesimpulan

Dokumentasi ini memberikan panduan lengkap untuk mengembangkan sistem pengukur tinggi badan berbasis ESP32 dengan PlatformIO. Implementasi mencakup filter data, sistem kalibrasi, validasi, dan output multiple format. PlatformIO menyederhanakan workflow development dengan manajemen dependensi otomatis dan toolchain terintegrasi.