Eksperimen Komunikasi Serial ESP32: Memahami Protokol I2C dan UART dalam Satu Sistem

Melanjutkan catatan eksperimen sebelumnya mengenai cara membaca sinyal dari pin GPIO, saya melihat ada satu hal penting yang perlu dipecahkan selanjutnya. Membaca realitas fisik dan mengubahnya menjadi data digital di dalam ESP32 barulah langkah awal. Data tersebut tidak akan memberikan fungsi yang maksimal jika hanya mengendap di dalam memori mikrokontroler. Agar sebuah sistem bisa beroperasi dengan utuh, informasi harus didistribusikan ke perangkat lain. Oleh karena itu, pada eksperimen kelima ini, fokus eksplorasi diarahkan pada implementasi komunikasi serial.

Saya merancang sebuah arsitektur sistem di mana ESP32 memegang peran sebagai pusat pemrosesan utama. Mikrokontroler ini ditugaskan untuk membaca kondisi suhu dan kelembapan lingkungan sekitar, lalu mengirimkan hasil pembacaan tersebut secara paralel ke dua titik akhir yang berbeda. Titik pertama adalah sebuah layar OLED yang berfungsi sebagai dasbor pemantauan lokal. Sementara itu, titik kedua adalah layar PC atau laptop yang bertindak sebagai sistem pemantauan eksternal. Untuk menjembatani aliran informasi ke dua arah yang berbeda ini, eksperimen ini akan menguji dan memadukan dua standar protokol komunikasi serial secara bersamaan, yaitu I2C untuk antarmuka layar lokal dan UART untuk pengiriman data ke PC.

Arsitektur Komunikasi: I2C dan UART

Untuk merealisasikan arsitektur pengiriman data paralel tersebut, saya membedah dua jalur komunikasi serial yang akan digunakan secara bersamaan.

Diagram Arsitektur Aliran Data

Jalur pertama ditujukan untuk distribusi data secara lokal di atas konfigurasi breadboard menggunakan protokol I2C (Inter-Integrated Circuit). Dalam perspektif perancangan sistem, I2C ini sangat efisien untuk komunikasi jarak dekat antar komponen perangkat keras. Untuk menampilkan data ke layar OLED, saya hanya perlu menghubungkan dua jalur kabel utama ke ESP32, yaitu jalur SDA (Serial Data Line) untuk perpindahan muatan informasi dan jalur SCL (Serial Clock Line) untuk sinkronisasi waktu transmisi. Pendekatan sinkron ini memastikan paket data suhu dan kelembapan dari memori mikrokontroler tiba di layar secara presisi. Bersamaan dengan proses di atas, jalur kedua bertugas membawa data yang sama keluar dari ekosistem mikrokontroler menuju sistem pemantauan eksternal di PC. Untuk kebutuhan pengiriman ke luar ini, saya memanfaatkan protokol UART (Universal Asynchronous Receiver-Transmitter). Berbeda dengan tata cara I2C, UART beroperasi secara asinkron yang berarti ia tidak memerlukan sinyal clock bersama untuk mengatur ritme pengiriman. Komunikasi ini bersifat point-to-point langsung antara ESP32 dan PC melalui perantara koneksi kabel USB. Secara teknis, aliran informasi bergerak berurutan melalui jalur Tx (Transmit) dari mikrokontroler yang kemudian diterima oleh jalur Rx (Receive) pada komputer. Dengan memadukan kedua protokol ini dalam satu landasan kode, satu sumber data tunggal dari sensor dapat didistribusikan ke layar lokal dan di-log ke sistem komputer tanpa saling mengganggu kinerja masing-masing jalur.

Persiapan Perangkat dan Wiring Sistem

Setelah memetakan arsitektur aliran data, langkah selanjutnya adalah melakukan implementasi fisik di atas breadboard. Eksperimen ini menggunakan empat komponen utama yang sudah tersedia di starter kit, yaitu mikrokontroler ESP32, sensor suhu dan kelembapan DHT11, layar OLED 0.96 inci, dan kabel jumper. Proses wiring saya mulai dengan menghubungkan pin data dari sensor DHT11 ke salah satu pin digital ESP32, misalnya pin 15, sebagai jalur input pembacaan kondisi lingkungan. Selanjutnya, untuk membangun jalur komunikasi I2C, layar OLED saya hubungkan ke pin I2C default dari ESP32. Pin SDA pada layar OLED disambungkan ke pin 21 ESP32, dan pin SCL disambungkan ke pin 22.

Wiring

Namun, pada fase perakitan ini, saya menemui satu kendala teknis: breadboard yang saya gunakan bermasalah sehingga saya harus mem-Bypass koneksi menggunakan kabel jumper secara langsung antar-pin (point-to-point).

Tantangan arsitektur muncul karena layar OLED dan sensor DHT11 sama-sama membutuhkan suplai tegangan 3.3V, sementara modul ESP32 secara bawaan hanya menyediakan satu pin 3V3. Sebagai solusi jalan tengah tanpa perlu memotong atau mencabang kabel secara mekanis, saya menerapkan teknik phantom power. Layar OLED yang membutuhkan arus lebih stabil saya prioritaskan untuk dihubungkan ke pin 3V3 dan GND pada ESP32, dengan jalur data SDA ke pin 21 dan SCL ke pin 22. Sementara itu, untuk sensor DHT11, pin datanya saya sambungkan ke GPIO 15, pin GND ke salah satu pin GND ekstra di ESP32, dan suplai daya (VCC) sensor tersebut saya tancapkan ke pin digital GPIO 4. Sensor DHT11 memiliki konsumsi daya yang sangat kecil, sehingga pin digital ESP32 mampu bertindak sebagai “baterai virtual” yang menyuplai tegangan 3.3V dengan aman.

Deteksi Alamat Perangkat

Sebelum mulai memprogram logika distribusi data, ada satu tahap validasi sistem yang pantang dilewatkan saat bekerja dengan arsitektur bus I2C, yaitu memverifikasi alamat perangkat keras. Karena protokol I2C memungkinkan banyak komponen terhubung secara paralel pada dua kabel yang sama persis (SDA dan SCL), ESP32 membutuhkan identitas unik atau alamat untuk setiap perangkat agar paket data yang dikirim tidak salah sasaran. Untuk tipe layar OLED 0.96 inci yang saya gunakan, lembar data pabrikan umumnya mencantumkan alamat bawaan pada 0x3C. Namun, alih-alih sekadar berasumsi berdasarkan teori, pendekatan integrasi yang baik mengharuskan kita melakukan verifikasi pada tingkat perangkat keras secara empiris.

Oleh karena itu, langkah teknis pertama saya adalah menjalankan sebuah baris kode pemindai sederhana, atau yang lumrah dikenal sebagai I2C Scanner, ke dalam ESP32. Program ini bekerja dengan cara mengetuk setiap pintu alamat yang berpotensi aktif di sepanjang jalur bus I2C, dari 0x01 hingga 0x7F, lalu mendengarkan apakah ada perangkat yang merespons. Hasil dari ketukan elektronik ini kemudian dilaporkan kembali oleh ESP32 melalui jalur komunikasi UART untuk ditampilkan di layar komputer.

#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(115200);
  while (!Serial);
  Serial.println("\nI2C Scanner");
}

void loop() {
  byte error, address;
  int nDevices;

  Serial.println("Scanning...");

  nDevices = 0;
  for(address = 1; address < 127; address++ ) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();

    if (error == 0) {
      Serial.print("I2C device found at address 0x");
      if (address<16) 
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");
      nDevices++;
    }
    else if (error==4) {
      Serial.print("Unknown error at address 0x");
      if (address<16) 
        Serial.print("0");
      Serial.println(address,HEX);
    }    
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");

  delay(5000); // Tunggu 5 detik untuk pemindaian berikutnya
}

Setelah program pemindai berhasil diunggah, saya membuka antarmuka Serial Monitor di komputer dengan kecepatan baud rate 115200. Sesuai dengan ekspektasi rancangan, ESP32 mulai menyisir jalur komunikasi dan layar monitor langsung menampilkan konfirmasi bahwa sebuah perangkat keras I2C berhasil ditemukan tepat di alamat 0x3C. Keberhasilan pemindaian ini memberikan dua lapis konfirmasi sekaligus: pertama, memvalidasi identitas spesifik dari layar OLED yang akan menjadi tujuan data; dan kedua, membuktikan secara elektris bahwa rangkaian kabel fisik pin 21 dan pin 22 dari mikrokontroler telah terhubung dengan sempurna tanpa adanya gangguan interferensi. Dengan terpetakannya alamat dan terverifikasinya jalur fisik ini, sistem kini sepenuhnya siap untuk ditanami kode program distribusi data yang sesungguhnya.

Serial Monitor I2C Scanner

Implementasi Kode dan Pengujian Distribusi Data

Masuk ke tahap pemrograman, fondasi utama dari kode ini adalah menginisialisasi jalur komunikasi dan manajemen daya sejak mikrokontroler pertama kali menyala. Sebelum mengaktifkan sensor, blok kode pertama yang saya eksekusi di dalam fungsi setup() adalah mengonfigurasi GPIO 4 sebagai OUTPUT dan memberikannya status logika HIGH. Instruksi sederhana ini secara efektif mengalirkan tegangan 3.3V untuk menghidupkan sensor DHT11 yang kekurangan pin daya fisik tadi.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <DHT.h>

// Konfigurasi OLED
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

// Konfigurasi Sensor DHT11
#define DHTPIN 15      // Terhubung ke pin 15 ESP32
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  // 1. Inisialisasi UART (Ke PC)
  Serial.begin(115200);

  // 2. Inisialisasi Sensor
  dht.begin();

  // 3. Inisialisasi I2C OLED (Alamat 0x3C)
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("Gagal menginisialisasi OLED"));
    for(;;);
  }
  display.clearDisplay();
  display.setTextColor(WHITE);
}

void loop() {
  // Jeda 2 detik antar pembacaan
  delay(2000);

  // Ambil sampel data fisik
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  // Validasi pembacaan
  if (isnan(h) || isnan(t)) {
    Serial.println("Gagal membaca dari sensor DHT!");
    return;
  }

  // --- DISTRIBUSI JALUR 1: UART (PC/Laptop) ---
  Serial.print("Suhu: ");
  Serial.print(t);
  Serial.print(" *C\t");
  Serial.print("Kelembapan: ");
  Serial.print(h);
  Serial.println(" %");

  // --- DISTRIBUSI JALUR 2: I2C (Layar OLED Lokal) ---
  display.clearDisplay();
  display.setTextSize(1);

  display.setCursor(0,0);
  display.print("Suhu: ");
  display.setTextSize(2);
  display.setCursor(0,10);
  display.print(t);
  display.print(" C");

  display.setTextSize(1);
  display.setCursor(0,35);
  display.print("Kelembapan: ");
  display.setTextSize(2);
  display.setCursor(0,45);
  display.print(h);
  display.print(" %");

  display.display(); // Eksekusi pengiriman data sinkron ke layar
}

Setelah daya stabil, saya membuka komunikasi UART menuju PC dengan baud rate 115200 dan mengaktifkan jalur I2C untuk layar OLED di alamat 0x3C. Setelah seluruh infrastruktur komunikasi dan kelistrikan ini terbuka, logika utama sistem berjalan dalam siklus yang berulang. ESP32 mengambil sampel data suhu dan kelembapan dari sensor DHT11 setiap dua detik. Begitu variabel data ini terisi, mikrokontroler langsung mengeksekusi dua perintah distribusi secara paralel: menyusun tata letak piksel untuk menampilkannya di layar OLED lokal, dan mengirimkan baris teks mentahnya ke komputer melalui kabel USB.

Tampilan serial monitor dan OLED

Untuk menguji keandalan arsitektur aliran data ini, saya menggenggam sensor DHT11 selama beberapa detik agar suhu dan kelembapan naik. Hasilnya berjalan presisi sesuai rancangan. Setiap kali angka pada layar OLED berubah merespons stimulus fisik tersebut, pada rentang milidetik yang sama, baris data baru langsung bergulir di antarmuka Serial Monitor pada layar PC. Pengamatan ini mengonfirmasi bahwa ESP32 terbukti mampu beroperasi secara sinkron untuk mendistribusikan satu sumber data tunggal ke dua platform pemantauan yang berbeda secara bersamaan.

Melalui eksperimen kelima ini, saya melihat langsung bagaimana mikrokontroler seperti ESP32 memiliki fleksibilitas yang tangguh dalam mengelola arsitektur aliran data. Dengan memadukan protokol I2C dan UART di dalam satu landasan program, sistem tidak lagi dibatasi pada satu jalur keluaran tunggal. Data kondisi lingkungan dari satu sensor fisik berhasil direplikasi dan didistribusikan secara sinkron menuju dasbor pemantauan lokal di atas meja sekaligus ke dalam log antarmuka komputer. Pendekatan ini mengonfirmasi bahwa sebuah perangkat keras skala kecil mampu bertindak sebagai simpul distribusi informasi yang andal tanpa mengalami bentrokan transmisi antarkanal komunikasi. Tentu saja, mendistribusikan data ke layar berjarak beberapa sentimeter atau ke komputer melalui kabel USB masih berada dalam ruang lingkup pemantauan jarak dekat. Untuk tahapan eksplorasi sistem berikutnya, tantangan logisnya adalah melepaskan ketergantungan pada kabel fisik. Mengintegrasikan ESP32 dengan protokol komunikasi nirkabel seperti WiFi untuk mengirimkan data sensor langsung ke server cloud akan menjadi langkah krusial dalam merancang arsitektur pemantauan yang mampu menjangkau skala wilayah yang lebih luas.