Cara Menggunakan HLW8032 dengan ESP32 untuk Monitoring Konsumsi Energi

Mengukur konsumsi listrik secara real-time bisa menjadi salah satu proyek menarik menggunakan ESP32. Dengan bantuan IC HLW8032, ESP32 dapat membaca berbagai parameter listrik dan mengolahnya menjadi data yang lebih mudah dipantau. Pada artikel ini, kita akan membahas cara menggunakan HLW8032 dengan ESP32 serta dasar pembacaan data hasil pengukurannya.

Alat dan Bahan

Sebelum memulai praktik, pastikan semua alat dan bahan yang dibutuhkan telah disiapkan agar proses perakitan dan pengujian dapat berjalan dengan baik. Berikut alat dan bahan yang digunakan beserta estimasi harganya:

Topologi Sistem

Sistem yang digunakan terdiri dari ESP32 sebagai mikrokontroler utama dan HLW8032 sebagai sensor pengukur parameter listrik. HLW8032 membaca tegangan, arus, dan daya dari beban listrik, kemudian data hasil pengukuran dikirimkan ke ESP32 untuk diproses dan ditampilkan sebagai informasi monitoring energi.

Gambar 1. Topologi sistem ESP32 dan HLW8032

Cara Kerja

Sistem bekerja dengan HLW8032 sebagai pengukur parameter listrik dan ESP32 sebagai mikrokontroler untuk mengolah data. Saat beban listrik terhubung, HLW8032 melakukan pengukuran terhadap tegangan dan arus yang digunakan oleh beban, kemudian menghasilkan data pengukuran yang dapat dibaca oleh ESP32. ESP32 menerima dan mengolah data tersebut sehingga dapat diperoleh informasi seperti tegangan, arus, daya, dan energi yang digunakan. Data hasil pengukuran selanjutnya dapat ditampilkan pada serial monitor atau media tampilan lainnya untuk memudahkan proses pemantauan.

Pada percobaan, sistem dirakit dengan menghubungkan modul HLW8032 ke ESP32 sesuai dengan konfigurasi yang telah ditentukan. Setelah rangkaian dinyalakan, dilakukan pengujian menggunakan beban listrik untuk melihat apakah data pengukuran dapat terbaca oleh ESP32. Hasil pembacaan kemudian diamati dan dibandingkan untuk memastikan sistem dapat melakukan monitoring sesuai dengan yang diharapkan.

Dokumentasi hasil percobaan:

Dokumentasi hasil percobaan sistem HLW8032 dengan ESP32-C3 dapat dilihat melalui video berikut. Video tersebut menampilkan proses pengujian rangkaian serta hasil pembacaan data dari HLW8032 yang diproses oleh ESP32-C3.

Lihat dokumentasi hasil percobaan di YouTube

Perangkat lunak

Setelah rangkaian HLW8032 dan ESP32-C3 terhubung, diperlukan program untuk membaca dan mengolah data hasil pengukuran dari HLW8032. Program berikut menggunakan komunikasi UART dengan konfigurasi 4800 baud, 8 data bit, even parity, dan 1 stop bit (8E1). Data yang diterima kemudian diproses oleh ESP32-C3 untuk mendapatkan nilai tegangan dan arus, kemudian ditampilkan melalui Serial Monitor.

#include <Arduino.h>

// =====================================================
// PIN ESP32-C3
// =====================================================

#define HLW_RX_PIN 5     // HLW8032 TX -> Optocoupler -> GPIO5
#define HLW_PF_PIN 4     // HLW8032 PF -> Optocoupler -> GPIO4


// =====================================================
// UART HLW8032
// =====================================================

HardwareSerial HLWSerial(1);


// =====================================================
// FRAME HLW8032
// =====================================================

uint8_t frame[24];


// =====================================================
// DATA HLW8032
// =====================================================

uint32_t VolPar = 0;
uint32_t VolData = 0;

uint32_t CurrentPar = 0;
uint32_t CurrentData = 0;

uint32_t PowerPar = 0;
uint32_t PowerData = 0;

uint16_t PF = 0;


// =====================================================
// KONSTANTA SESUAI LIBRARY HLW8032
// =====================================================

// Tegangan:
// VolR1 = 470K x 4
// VolR1 = 1.880.000 ohm
// VolR2 = 1K
//
// VF = VolR1 / VolR2
// VF = 1880

const float VF = 1880.0f;


// Arus:
//
// CurrentRF = 0.1
//
// CF = 1 / (CurrentRF x 1000)
// CF = 0.01

const float CF = 0.01f;


// =====================================================
// KALIBRASI TEGANGAN
// =====================================================
//
// Sebelumnya:
//
// Pembacaan HLW = 171 V
// Tegangan sebenarnya = 215 V
//
// Faktor:
//
// 215 / 171
// = 1.25731
//
// Jika nanti hasil berubah, cukup ubah nilai ini.
// =====================================================

const float VOLTAGE_CAL = 1.25731f;


// =====================================================
// KALIBRASI ARUS
// =====================================================
//
// Untuk sementara belum dikoreksi.
//
// Jika nanti misalnya:
//
// HLW = 0.80 A
// Multimeter = 1.00 A
//
// maka:
//
// CURRENT_CAL = 1.00 / 0.80
//              = 1.25
//
// =====================================================

const float CURRENT_CAL = 1.00000f;


// =====================================================
// STATUS
// =====================================================

bool dataValid = false;

unsigned long lastValidData = 0;
unsigned long lastPrint = 0;


// =====================================================
// CHECKSUM HLW8032
// =====================================================

bool checkChecksum()
{
  uint8_t checksum = 0;

  // Sesuai library:
  // checksum byte 2 sampai byte 22

  for (int i = 2; i <= 22; i++)
  {
    checksum += frame[i];
  }

  return (checksum == frame[23]);
}


// =====================================================
// BACA FRAME HLW8032
// =====================================================

bool readHLW8032()
{
  // ---------------------------------------------------
  // Belum ada data
  // ---------------------------------------------------

  if (HLWSerial.available() == 0)
    return false;


  // ---------------------------------------------------
  // Tunggu frame seperti library asli
  // ---------------------------------------------------

  delay(56);


  // ---------------------------------------------------
  // Cek jumlah byte
  // ---------------------------------------------------

  int availableBytes = HLWSerial.available();


  if (availableBytes < 24)
    return false;


  // ---------------------------------------------------
  // Jika data lebih dari 24 byte,
  // buang byte lama agar mengambil frame terakhir.
  // ---------------------------------------------------

  if (availableBytes > 24)
  {
    int discard = availableBytes - 24;

    while (discard--)
    {
      HLWSerial.read();
    }
  }


  // ---------------------------------------------------
  // Baca 24 byte
  // ---------------------------------------------------

  for (int i = 0; i < 24; i++)
  {
    int b = HLWSerial.read();

    if (b < 0)
      return false;

    frame[i] = (uint8_t)b;
  }


  // ---------------------------------------------------
  // Sesuai library asli:
  // byte ke-2 harus 0x5A
  // ---------------------------------------------------

  if (frame[1] != 0x5A)
  {
    return false;
  }


  // ---------------------------------------------------
  // CHECKSUM
  // ---------------------------------------------------

  if (!checkChecksum())
  {
    return false;
  }


  // ===================================================
  // VOLTAGE PARAMETER
  // ===================================================

  VolPar =
      ((uint32_t)frame[2] << 16) |
      ((uint32_t)frame[3] << 8) |
      frame[4];


  // ===================================================
  // VOLTAGE DATA
  // ===================================================

  if (bitRead(frame[20], 6))
  {
    VolData =
        ((uint32_t)frame[5] << 16) |
        ((uint32_t)frame[6] << 8) |
        frame[7];
  }


  // ===================================================
  // CURRENT PARAMETER
  // ===================================================

  CurrentPar =
      ((uint32_t)frame[8] << 16) |
      ((uint32_t)frame[9] << 8) |
      frame[10];


  // ===================================================
  // CURRENT DATA
  // ===================================================

  if (bitRead(frame[20], 5))
  {
    CurrentData =
        ((uint32_t)frame[11] << 16) |
        ((uint32_t)frame[12] << 8) |
        frame[13];
  }


  // ===================================================
  // POWER PARAMETER
  // ===================================================

  PowerPar =
      ((uint32_t)frame[14] << 16) |
      ((uint32_t)frame[15] << 8) |
      frame[16];


  // ===================================================
  // POWER DATA
  // ===================================================

  if (bitRead(frame[20], 4))
  {
    PowerData =
        ((uint32_t)frame[17] << 16) |
        ((uint32_t)frame[18] << 8) |
        frame[19];
  }


  // ===================================================
  // PF
  // ===================================================

  PF =
      ((uint16_t)frame[21] << 8) |
      frame[22];


  // ===================================================
  // DATA VALID
  // ===================================================

  dataValid = true;
  lastValidData = millis();

  return true;
}


// =====================================================
// HITUNG TEGANGAN
// =====================================================

float getVoltage()
{
  if (VolData == 0)
    return 0.0f;


  // Hitung tegangan dasar
  float voltage =
      ((float)VolPar / (float)VolData)
      * VF
      * 0.001f;


  // Terapkan kalibrasi
  voltage *= VOLTAGE_CAL;


  return voltage;
}


// =====================================================
// HITUNG ARUS
// =====================================================

float getCurrent()
{
  if (CurrentData == 0)
    return 0.0f;


  // Hitung arus dasar
  float current =
      ((float)CurrentPar / (float)CurrentData)
      * CF;


  // Terapkan kalibrasi arus
  current *= CURRENT_CAL;


  return current;
}


// =====================================================
// SETUP
// =====================================================

void setup()
{
  // ===================================================
  // SERIAL MONITOR
  // ===================================================

  Serial.begin(115200);

  delay(1500);


  Serial.println();
  Serial.println("========================================");
  Serial.println("        ESP32-C3 + HLW8032");
  Serial.println("========================================");

  Serial.println("HLW TX  -> Optocoupler -> GPIO5");
  Serial.println("HLW PF  -> Optocoupler -> GPIO4");
  Serial.println();
  Serial.println("UART    : 4800 8E1");
  Serial.println("RX      : GPIO5");
  Serial.println("Invert  : OFF");
  Serial.println();


  // ===================================================
  // GPIO PF
  // ===================================================

  pinMode(
    HLW_PF_PIN,
    INPUT
  );


  // ===================================================
  // UART HLW8032
  // ===================================================
  //
  // TX HLW8032
  //      |
  //      v
  // Optocoupler
  //      |
  //      v
  // GPIO5
  //
  // Inversion OFF karena dari pengujian sebelumnya
  // GPIO5 sudah menerima aktivitas UART.
  // ===================================================

  HLWSerial.begin(
    4800,
    SERIAL_8E1,
    HLW_RX_PIN,
    -1,
    false
  );


  Serial.println("UART HLW8032 siap.");
  Serial.println("Menunggu data...");
  Serial.println();
}


// =====================================================
// LOOP
// =====================================================

void loop()
{
  // ===================================================
  // BACA DATA HLW8032
  // ===================================================

  readHLW8032();


  // ===================================================
  // TAMPILKAN SETIAP 1 DETIK
  // ===================================================

  if (millis() - lastPrint >= 1000)
  {
    lastPrint = millis();


    Serial.println("----------------------------------------");


    if (dataValid &&
        (millis() - lastValidData < 3000))
    {
      float voltage = getVoltage();
      float current = getCurrent();


      // ===============================================
      // TEGANGAN
      // ===============================================

      Serial.print("Voltage : ");
      Serial.print(voltage, 2);
      Serial.println(" V");


      // ===============================================
      // ARUS
      // ===============================================

      Serial.print("Current : ");
      Serial.print(current, 3);
      Serial.println(" A");


      Serial.println("Status  : DATA OK");
    }
    else
    {
      Serial.println("Voltage : --- V");
      Serial.println("Current : --- A");

      Serial.println("Status  : NO DATA");
    }


    Serial.println("----------------------------------------");
  }
}

Pada bagian awal program, library Arduino.h digunakan untuk menyediakan fungsi dasar pemrograman ESP32. Selanjutnya ditentukan pin yang digunakan untuk menerima data dari HLW8032, yaitu GPIO5 untuk jalur TX HLW8032 melalui optocoupler dan GPIO4 untuk sinyal PF.

HardwareSerial HLWSerial(1) digunakan untuk membuat komunikasi UART pada hardware serial nomor 1. Komunikasi tersebut diatur menggunakan konfigurasi 4800, SERIAL_8E1, sehingga ESP32-C3 dapat menerima data dari HLW8032 sesuai format komunikasinya.

Program menyediakan array frame[24] untuk menampung 24 byte data yang dikirimkan oleh HLW8032. Data tersebut kemudian dipisahkan menjadi beberapa parameter, yaitu parameter tegangan, arus, daya, serta data hasil pengukuran masing-masing parameter.

Pada bagian perhitungan, program menggunakan konstanta VF dan CF sebagai faktor untuk mengubah data mentah HLW8032 menjadi nilai tegangan dan arus. Nilai tegangan juga dikalibrasi menggunakan VOLTAGE_CAL, sedangkan CURRENT_CAL disiapkan sebagai faktor kalibrasi arus yang dapat disesuaikan berdasarkan hasil pengukuran menggunakan alat ukur.

Fungsi readHLW8032() bertugas membaca data dari UART. Program memastikan jumlah data yang diterima mencukupi, kemudian membaca 24 byte frame. Data juga diperiksa menggunakan byte penanda 0x5A dan checksum untuk memastikan frame yang diterima valid sebelum diproses lebih lanjut.

Setelah data valid diperoleh, fungsi getVoltage() menghitung nilai tegangan berdasarkan perbandingan parameter dan data tegangan dari HLW8032, kemudian menerapkan faktor kalibrasi. Fungsi getCurrent() melakukan proses yang sama untuk mendapatkan nilai arus.

Pada fungsi setup(), Serial Monitor diatur pada baud rate 115200 dan UART HLW8032 diinisialisasi. Sedangkan pada loop(), ESP32 terus membaca data HLW8032 dan menampilkan hasil pengukuran setiap satu detik. Jika data masih valid, Serial Monitor akan menampilkan nilai tegangan dan arus beserta status DATA OK. Jika tidak ada data yang valid selama beberapa waktu, sistem akan menampilkan NO DATA.

Kesimpulan

Berdasarkan percobaan yang telah dilakukan, ESP32-C3 dapat digunakan untuk membaca dan mengolah data pengukuran dari HLW8032 melalui komunikasi UART. Data yang diterima dapat diproses menjadi informasi tegangan dan arus, kemudian ditampilkan melalui Serial Monitor. Dengan adanya proses validasi data dan kalibrasi, sistem dapat digunakan sebagai dasar untuk membuat perangkat monitoring konsumsi energi listrik secara real-time.

Tags: Arduino, Energy Meter, esp32, HLW8032, IoT, Monitoring Listrik, Sensor Listrik