Alvoria Neura


Komunikasi i2c Master Slave Esp32 Devkit V1

Tutorial: Komunikasi Antara Dua Modul ESP32 DevKit V1 Menggunakan Metode I2C

Tujuan Tutorial

  • Menghubungkan dua modul ESP32 menggunakan komunikasi I2C.
  • Mengirimkan data dari master ke slave melalui I2C.
  • Menangani respons dari slave ke master menggunakan I2C.

Pada tutorial ini, kita akan belajar cara menghubungkan dua modul ESP32 DevKit V1 untuk saling berkomunikasi menggunakan metode I2C (Inter-Integrated Circuit). Dalam sistem ini, satu modul akan bertindak sebagai master dan modul lainnya sebagai slave. Metode I2C adalah salah satu protokol komunikasi yang banyak digunakan untuk menghubungkan mikrokontroler dengan sensor atau perangkat lainnya.

Apa itu I2C?

I2C (Inter-Integrated Circuit) adalah sebuah protokol komunikasi serial yang digunakan untuk komunikasi antar perangkat dalam jarak dekat. Protokol ini menggunakan dua saluran utama:

  1. SDA (Serial Data Line): Saluran untuk data.
  2. SCL (Serial Clock Line): Saluran untuk sinyal clock yang mengatur kecepatan komunikasi.

I2C memungkinkan banyak perangkat untuk berbagi dua jalur yang sama, sehingga sangat efisien dalam komunikasi antar banyak perangkat. Salah satu perangkat akan bertindak sebagai master, yang mengontrol jalannya komunikasi, sedangkan perangkat lainnya bertindak sebagai slave, yang hanya merespons perintah dari master.

Perbedaan Master Dan Slave

  • Master: Mengirimkan data ke slave melalui I2C.
  • Slave: Menerima data dari master dan memberikan respons balik.

1. Komponen yang Dibutuhkan:

Sebelum kita mulai, pastikan Anda memiliki:

  • 2 buah ESP32 DevKit V1.
  • Kabel jumper untuk menghubungkan pin antara dua modul.
  • Komputer dengan Arduino IDE terinstal.
  • Kabel USB untuk menghubungkan ESP32 ke komputer.
  • Sensor atau perangkat lain (opsional, tergantung kebutuhan aplikasi).

2. Wiring (Diagram / Skema Koneksi)

Koneksi antara kedua modul ESP32 adalah sebagai berikut:

ESP32 (Master) ESP32 (Slave)
SDA (pin 21) SDA (pin 21)
SCL (pin 22) SCL (pin 22)
GND GND
VCC (untuk memberikan daya ke kedua modul) VCC (untuk memberikan daya ke kedua modul).

Catatan: Pastikan bahwa SDA dan SCL dari kedua modul terhubung dengan benar dan juga sambungkan GND dari kedua modul agar komunikasi dapat dilakukan dengan baik.

3. Instalasi dan Persiapan

Sebelum menulis kode, pastikan Anda sudah:

  1. Instalasi Arduino IDE: Pastikan Anda sudah menginstal Arduino IDE terbaru di komputer Anda. Anda bisa mendownloadnya di sini.
  2. Menambahkan Board ESP32 pada Arduino IDE:

    • Buka Arduino IDE.
    • Pilih File > Preferences dan tambahkan URL berikut ke dalam "Additional Boards Manager URLs":
      • https://dl.espressif.com/dl/package_esp32_index.json

    • Pilih Tools > Board > Boards Manager....
    • Cari "ESP32" dan klik "Install".
  3. Pilih Board ESP32:

    • Pilih Tools > Board > ESP32 Dev Module.

4. Kode untuk Master (ESP32)

Pada kode master, ESP32 akan mengirimkan data ke slave menggunakan I2C. Berikut adalah kode untuk modul master:


#include <Wire.h>

#define SLAVE_ADDR 8  // Alamat I2C slave

void setup() {
    Wire.begin();          // Mulai komunikasi I2C sebagai master
    Serial.begin(115200);  // Mulai komunikasi serial untuk debugging

    Serial.println("Master siap mengirim data ke slave...");
}

void loop() {
    Wire.beginTransmission(SLAVE_ADDR);  // Mulai transmisi ke slave dengan alamat 8
    Wire.write("Hello, Slave!");         // Mengirimkan pesan ke slave
    Wire.endTransmission();              // Mengakhiri transmisi

    Serial.println("Data dikirim ke slave");

    delay(1000);  // Delay 1 detik sebelum mengirim data lagi
}

Penjelasan Kode Master:

  1. Wire.begin(): Menginisialisasi komunikasi I2C sebagai master.
  2. Wire.beginTransmission (SLAVE_ADDR): Memulai transmisi data ke slave dengan alamat yang telah ditentukan (dalam hal ini 8).
  3. Wire.write("Hello, Slave!"): Mengirimkan data berupa string "Hello, Slave!" ke slave.
  4. Wire.endTransmission(): Mengakhiri transmisi data ke slave.
  5. Serial.begin(115200): Memulai komunikasi serial untuk debugging dan melihat status pengiriman data.
  6. delay(1000): Menambahkan jeda selama 1 detik sebelum transmisi berikutnya.

5. Kode untuk Slave (ESP32)

Pada kode slave, ESP32 akan menerima data yang dikirim oleh master melalui I2C. Berikut adalah kode untuk modul slave:


#include <Wire.h>

#define SLAVE_ADDR 8  // Alamat I2C slave

void setup() {
    Wire.begin(SLAVE_ADDR);      // Mulai komunikasi I2C sebagai slave dengan alamat 8
    Wire.onReceive(receiveEvent); // Menentukan fungsi yang akan dipanggil saat data diterima
    Serial.begin(115200);        // Mulai komunikasi serial untuk debugging

    Serial.println("Slave siap menerima data...");
}

void loop() {
    // Fungsi ini akan dipanggil secara otomatis ketika data diterima
    delay(100);  // Delay kecil untuk menjaga sistem tetap responsif
}

void receiveEvent(int byteCount) {
    while (Wire.available()) {  // Mengecek apakah ada data yang diterima
    char c = Wire.read();     // Membaca data dari master
    Serial.print(c);          // Menampilkan data yang diterima
    }
    Serial.println();  // Menambahkan baris baru setelah menerima data
}

Penjelasan Kode Slave:

  1. Wire.begin(SLAVE_ADDR): Menginisialisasi komunikasi I2C sebagai slave dengan alamat yang ditentukan (dalam hal ini 8).
  2. Wire.onReceive(receiveEvent): Mendaftarkan event handler yang akan dipanggil setiap kali slave menerima data dari master.
  3. receiveEvent(int byteCount): Fungsi ini akan dipanggil saat slave menerima data. Fungsi ini membaca dan menampilkan setiap karakter yang diterima dari master ke monitor serial.
  4. Serial.print(c): Mencetak data yang diterima ke monitor serial untuk tujuan debugging.
  5. delay(100): Memberikan sedikit jeda untuk memastikan sistem tetap responsif.

6. Menghubungkan ESP32

Ikuti langkah-langkah berikut untuk menghubungkan kedua modul ESP32:

  1. SDA (pin 21 pada ESP32 Master) ke SDA (pin 21 pada ESP32 Slave).
  2. SCL (pin 22 pada ESP32 Master) ke SCL (pin 22 pada ESP32 Slave).
  3. GND ke GND (ground dari kedua modul).
  4. VCC ke VCC (untuk memberikan daya ke kedua modul).

Catatan: Pastikan semua koneksi sudah benar dan kedua modul terhubung dengan baik.

7. Meng-upload Kode ke ESP32

  1. Sambungkan kedua modul ESP32 ke komputer Anda melalui kabel USB.
  2. Pilih port yang sesuai di Tools > Port untuk masing-masing modul.
  3. Pilih board ESP32 yang sesuai di Tools > Board.
  4. Upload kode untuk Master ke modul pertama dan Slave ke modul kedua.

8. Verifikasi Hasil

  1. Setelah meng-upload kode, buka Serial Monitor pada Arduino IDE.
  2. Setel baud rate Serial Monitor ke 115200.
  3. Anda akan melihat output berikut:
    • Master akan mengirimkan pesan "Data dikirim ke slave" setiap detik.
    • Slave akan menerima pesan dan menampilkan "Hello, Slave!" dan mencetaknya ke monitor serial.

Kesimpulan

Pada tutorial ini, kita telah berhasil menghubungkan dua modul ESP32 DevKit V1 menggunakan komunikasi I2C. Modul pertama bertindak sebagai master, mengirimkan data ke modul kedua yang bertindak sebagai slave. Melalui tutorial ini, Anda dapat memahami bagaimana cara kerja komunikasi I2C antar mikrokontroler, yang memungkinkan perangkat untuk saling bertukar data secara efisien dengan menggunakan hanya dua jalur utama (SDA dan SCL).


Metode I2C sangat efisien dalam komunikasi antar banyak perangkat, dan dengan memahami dasar-dasar komunikasi ini, Anda dapat mengembangkan berbagai aplikasi berbasis ESP32 yang melibatkan komunikasi antar banyak perangkat. Anda juga dapat memperluas konsep ini untuk menghubungkan berbagai sensor atau perangkat lainnya ke ESP32 menggunakan I2C dalam proyek IoT Anda.


Dengan mengikuti tutorial ini, Anda dapat mengaplikasikan pengetahuan I2C untuk menciptakan sistem yang lebih kompleks dan lebih berguna dalam berbagai aplikasi IoT.