Dasar · 9 mnt baca

I2C master-slave Arduino: menghubungkan dua Arduino dan mengirim struct

I2C master-slave Arduino: pengkabelan dua Arduino, nilai pull-up, Wire.onReceive dan onRequest, memilih alamat, mengirim struct, dan konversi level untuk ESP32.

Rangkaian I2C master-slave Arduino adalah salah satu cara paling praktis untuk menghubungkan dua board: cukup dua kabel data (SDA dan SCL) ditambah ground bersama, dan hanya butuh beberapa baris kode dengan library Wire bawaan Arduino. Satu board menjadi controller (dulu disebut master) dan selalu memulai percakapan; board lainnya menjadi target (slave), yang punya alamat dan mendengarkan apa yang dikirim kepadanya atau menjawab ketika ditanya. Karena puluhan target bisa berbagi dua kabel yang sama, I2C sangat berguna di proyek yang satu board utamanya mengatur beberapa Arduino pembantu.

Di artikel ini kita menghubungkan dua Arduino Uno lewat I2C langkah demi langkah: tabel pengkabelan dan pull-up, memilih alamat, fungsi Wire.onReceive dan Wire.onRequest, mengirim satu byte, pertukaran data dua arah dengan struct, beberapa Arduino di satu bus, berkomunikasi dengan ESP32 dan Raspberry Pi Pico lewat level shifter, serta perbandingan I2C dan UART. Kalau kamu ingin menyegarkan dasar-dasar I2C dan sketch scanner-nya dulu, lihat Apa Itu I2C?.

Arduino Uno
Arduino Uno: bus I2C ada di pin A4 (SDA) dan A5 (SCL); pada board R3, bus yang sama juga dikeluarkan ke header SDA dan SCL di sebelah AREF.

Bagaimana cara kerja controller dan target (master dan slave) di I2C?

Di I2C, semua perangkat tersambung paralel ke dua jalur yang sama. SCL adalah jalur clock, dan selalu controller yang menggerakkannya; SDA adalah jalur data dan membawa data ke dua arah. Untuk memulai pesan, controller membuat kondisi “start”, lalu mengirim alamat 7 bit milik target beserta satu bit baca atau tulis. Target dengan alamat itu menjawab dengan ACK (diterima) dengan menarik jalur ke LOW sebentar di akhir setiap byte; kalau tidak ada yang punya alamat itu, jalur tetap HIGH, dan ini disebut NACK. Karena itulah di I2C controller langsung tahu apakah sebuah pesan sampai. Aturan terpentingnya begini: target tidak bisa berbicara atas kemauannya sendiri. Walaupun punya data baru, target menunggu sampai controller bertanya, jadi controller harus menanyainya secara berkala. Dokumentasi Arduino menyebut peran ini “controller” dan “peripheral”, sedangkan revisi terbaru standar I2C memakai “controller” dan “target”; artinya sama dengan master dan slave di kode lama.

Pengkabelan: sambungan I2C antara dua Arduino

Arduino A (controller)SambunganArduino B (target)Catatan
A4 (SDA)LangsungA4 (SDA)Tidak disilang
A5 (SCL)LangsungA5 (SCL)Tidak disilang
GNDLangsungGNDWajib: referensi bersama
5VOpsional5VHanya jika board B diberi daya dari board A
SDA dan SCL4,7 kΩ ke 5V-Satu pasang resistor cukup untuk seluruh bus
Berbeda dengan UART, kabel I2C tidak disilang: SDA ke SDA dan SCL ke SCL. Selalu sambungkan juga GND kedua board; tanpa ground bersama, komunikasi tidak akan terbentuk atau malah memunculkan error acak. Alasan ground bersama itu wajib bisa kamu baca di Ground Bersama (GND).
BoardSDASCLCatatan
Arduino Uno / NanoA4A5Di Uno R3, pin SDA dan SCL di sebelah AREF adalah bus yang sama
Arduino Mega 2560D20D21Punya resistor pull-up 10 kΩ di board
Arduino Leonardo / MicroD2D3Pin berbeda dari Uno
ESP32GPIO 21GPIO 223,3 V; Wire.begin(sda, scl) memungkinkan memilih pin lain
Raspberry Pi PicoGP4 (I2C0)GP5 (I2C0)3,3 V; di MicroPython kamu bisa memilih pasangan pin lain

Resistor pull-up: kapan perlu dan berapa nilainya?

Perangkat di bus I2C hanya bisa menarik jalur ke LOW; yang mengembalikannya ke HIGH adalah resistor pull-up. Pada board AVR Arduino, Wire.begin() mengaktifkan pull-up internal sekitar 20–50 kΩ di SDA dan SCL. Dengan dua Uno, kabel pendek, dan 100 kHz, itu biasanya berhasil, tetapi resistor tersebut lemah untuk I2C; makin panjang kabelnya, tepi naik sinyal makin lambat dan error mulai muncul. Untuk bus yang andal, pasang satu resistor 4,7 kΩ dari SDA ke 5V dan satu lagi dari SCL ke 5V. Batas bawahnya berasal dari arus 3 mA yang diizinkan dalam keadaan LOW: R(min) = (5 V - 0,4 V) / 3 mA ≈ 1,5 kΩ. Batas atasnya ditentukan oleh kapasitansi bus: pada 100 kHz, untuk bus 200 pF, R(maks) ≈ 1000 ns / (0,8473 × 200 pF) ≈ 5,9 kΩ. Pakai alat Hukum Ohm untuk hitungannya dan baca Resistor Pull-up dan Pull-down untuk memahami gagasannya.

SituasiPull-up yang disarankanCatatan
Dua Uno, kabel di bawah 30 cm, 100 kHz4,7 kΩ (pull-up internal sering kali juga cukup)Susunan yang paling umum
Kabel 50 cm sampai 1 m, atau 400 kHz2,2 kΩTetap usahakan kabel sependek mungkin
Ada Arduino Mega di busMungkin tidak perlu tambahanResistor 10 kΩ milik Mega jadi paralel dengan resistor lainnya
Ada modul ber-pull-up di bus (OLED, RTC, LCD)Hitung total hambatan paralelnyaTotalnya jangan sampai turun di bawah 1,5 kΩ
Arduino dengan ESP32 atau PicoResistor level shifter di tiap sisiJangan sambungkan langsung; lihat bagian di bawah

Memilih alamat: alamat mana yang sebaiknya dipakai?

Alamat Arduino target kamu tentukan sendiri dengan Wire.begin(alamat). Di ruang alamat 7 bit, 0x00–0x07 dan 0x78–0x7F sudah dicadangkan, jadi rentang yang bisa dipakai adalah 0x08–0x77, atau 8 sampai 119 dalam desimal. Kalau ada modul lain di bus, pilih nilai yang tidak bentrok dengan alamat mereka; cara paling aman adalah menyambungkan semuanya lalu menjalankan scanner I2C untuk melihat alamat mana yang sudah terpakai. Berikut alamat modul-modul yang umum:

AlamatModul yang sering memakainya
0x27 / 0x3FLCD I2C dengan backpack PCF8574
0x3C / 0x3DLayar OLED SSD1306
0x68RTC DS1307 dan DS3231, MPU-6050
0x76 / 0x77BMP280 dan BME280
0x40Driver servo PCA9685, INA219
0x48ADC ADS1115
0x57MAX30102, EEPROM AT24C32 pada modul RTC
0x08–0x0FBiasanya kosong; rentang yang bagus untuk target Arduino

Contoh 1: mengirim satu byte dari controller ke target

Di contoh pertama, board A membaca potensiometer di A0, membagi nilainya dengan 4 agar masuk ke rentang 0–255, lalu mengirimkannya 10 kali per detik sebagai satu byte ke alamat 8. Board B menerima byte itu dan mengatur kecerahan LED di D9. Upload dulu sketch controller ke board A, lalu sketch target ke board B. Library Wire sudah termasuk di Arduino IDE, jadi tidak ada yang perlu diinstal. Sketch controller:

C++ (Arduino IDE)
1// Denetleyici (master): potansiyometre değerini hedefe gönderir / Controller (master): sends the pot value to the target
2#include <Wire.h>
3
4const byte TARGET_ADDR = 8;          // hedef kartın adresi / address of the target board
5
6void setup() {
7  Wire.begin();                      // adres verilmedi = denetleyici / no address = controller
8  Serial.begin(9600);
9}
10
11void loop() {
12  byte value = analogRead(A0) / 4;   // 0-1023 -> 0-255
13  Wire.beginTransmission(TARGET_ADDR);
14  Wire.write(value);
15  byte status = Wire.endTransmission();   // 0 = başarılı / 0 = success
16  if (status != 0) {
17    Serial.print(F("I2C hatasi / error: "));
18    Serial.println(status);          // 2 = adres yanıt vermedi / 2 = no ACK on address
19  }
20  delay(100);
21}

Sketch target untuk di-upload ke board B:

C++ (Arduino IDE)
1// Hedef (slave): gelen baytla LED parlaklığını ayarlar / Target (slave): sets the LED brightness from the received byte
2#include <Wire.h>
3
4const byte MY_ADDR = 8;              // bu kartın adresi / this board's address
5const int LED_PIN = 9;               // PWM pini / PWM pin
6
7volatile byte received = 0;
8volatile bool newData = false;
9
10void onReceiveEvent(int howMany) {   // kesme içinde çalışır: kısa tut / runs inside an interrupt: keep it short
11  for (int i = 0; i < howMany; i++) received = Wire.read();   // son bayt kalır / keep the last byte
12  newData = true;
13}
14
15void setup() {
16  Wire.begin(MY_ADDR);               // adresle başlat = hedef / start with an address = target
17  Wire.onReceive(onReceiveEvent);
18  pinMode(LED_PIN, OUTPUT);
19  Serial.begin(9600);
20}
21
22void loop() {
23  if (newData) {
24    newData = false;
25    analogWrite(LED_PIN, received);
26    Serial.println(received);        // Serial'ı kesmenin dışında kullan / use Serial outside the interrupt
27  }
28}

Sketch target punya dua poin penting. Yang pertama Wire.begin(8): board yang dimulai dengan alamat menjadi target. Yang kedua Wire.onReceive(): ketika controller mengirim data, library Wire memanggil fungsi ini dengan sendirinya dan memberinya jumlah byte yang diterima. Nilainya kita simpan di variabel volatile dan kita hanya menaikkan flag “ada data baru”; mengatur LED dan mencetak ke Serial Monitor dilakukan di loop(). Di sisi controller, nilai yang dikembalikan Wire.endTransmission() memberitahumu apa yang terjadi pada pesan itu:

Nilai endTransmission()ArtiYang perlu dilakukan
0Berhasil, target mengonfirmasi setiap byte-
1Data terlalu panjang untuk buffer (lebih dari 32 byte)Pecah pesan menjadi beberapa bagian
2Tidak ada ACK untuk alamatPeriksa alamat, pengkabelan, GND, dan pastikan target mendapat daya
3Tidak ada ACK untuk byte dataTarget sedang sibuk atau menerima panjang data yang tidak terduga
4Error lainBus mungkin ber-noise atau tidak punya pull-up
5TimeoutBus macet; aktifkan pemulihan dengan setWireTimeout()

onReceive dan onRequest: aturan di dalam interrupt

  • Buat sesingkat mungkin: Kedua fungsi berjalan di dalam interrupt I2C. Jangan pakai delay(), Serial.print(), atau perhitungan panjang di sana; simpan data ke sebuah variabel lalu keluar.
  • Pakai volatile: Deklarasikan flag yang berubah di interrupt dan dibaca di loop() sebagai volatile; kalau tidak, compiler bisa saja tidak melihat perubahannya. Detailnya ada di Interrupt Arduino.
  • Tulis semuanya sekaligus di onRequest: Ketika controller meminta data, masukkan semua byte ke buffer dengan satu Wire.write(array, panjang). Siapkan datanya lebih dulu; membaca sensor di dalam onRequest membuat controller menunggu.
  • Batas 32 byte: Buffer Wire di AVR berukuran 32 byte. Pecah data yang lebih panjang ke beberapa pesan, atau pakai UART kalau memang perlu.
  • Periksa panjangnya: Bandingkan jumlah byte yang masuk di onReceive dengan yang kamu harapkan; kalau terlalu banyak atau terlalu sedikit, baca semuanya lalu buang.
  • Siapkan jawaban lebih dulu: Perbarui variabel laporan sebelum target memulai tugas yang panjang, supaya controller selalu menemukan jawaban yang sudah siap.

Contoh 2: komunikasi dua arah dengan struct

Proyek sungguhan butuh lebih dari satu byte: controller mengirim perintah dan target mengembalikan laporan berisi beberapa nilai. Daripada memecah nilai-nilai itu menjadi byte secara manual, lebih rapi dan lebih cepat kalau kamu mendefinisikan sebuah struct dan mengirimnya apa adanya. Di contoh di bawah, controller mengatur LED dan kecerahannya dengan perintah 2 byte, lalu memakai Wire.requestFrom() untuk meminta laporan 7 byte dari target: nilai potensiometer (uint16_t), keadaan tombol (uint8_t), dan lama target menyala (uint32_t). Struct di kedua board harus sama persis. Sketch controller:

C++ (Arduino IDE)
1// Denetleyici: komut gönderir, rapor ister / Controller: sends a command, requests a report
2#include <Wire.h>
3
4struct __attribute__((packed)) Command {   // denetleyici -> hedef / controller -> target (2 bayt / bytes)
5  uint8_t ledOn;
6  uint8_t brightness;
7};
8
9struct __attribute__((packed)) Report {    // hedef -> denetleyici / target -> controller (7 bayt / bytes)
10  uint16_t potValue;
11  uint8_t buttonPressed;
12  uint32_t uptimeMs;
13};
14
15const byte TARGET_ADDR = 8;
16
17void setup() {
18  Wire.begin();
19  Wire.setClock(100000);                   // standart hız 100 kHz / standard mode 100 kHz
20  Wire.setWireTimeout(25000, true);        // hat takılırsa 25 ms'de kurtul / recover if the bus hangs for 25 ms
21  Serial.begin(9600);
22}
23
24void loop() {
25  Command cmd;
26  cmd.ledOn = 1;
27  cmd.brightness = (millis() / 20) % 256;  // yavaşça artan parlaklık / slowly rising brightness
28
29  Wire.beginTransmission(TARGET_ADDR);
30  Wire.write((const uint8_t*)&cmd, sizeof(cmd));
31  byte err = Wire.endTransmission();
32
33  Report r;
34  byte n = Wire.requestFrom(TARGET_ADDR, (byte)sizeof(Report));
35  if (err == 0 && n == sizeof(Report)) {
36    Wire.readBytes((uint8_t*)&r, sizeof(r));
37    Serial.print(F("Pot: "));
38    Serial.print(r.potValue);
39    Serial.print(F("  Buton / button: "));
40    Serial.print(r.buttonPressed);
41    Serial.print(F("  Sure / uptime ms: "));
42    Serial.println(r.uptimeMs);
43  } else {
44    while (Wire.available()) Wire.read();  // yarım veriyi at / drop partial data
45    Serial.println(F("Hedef yanit vermedi / target not responding"));
46  }
47  delay(200);
48}

Sketch board target; definisi struct-nya sama persis dengan yang di controller:

C++ (Arduino IDE)
1// Hedef: komutu uygular, istenince rapor gönderir / Target: applies the command, sends a report on request
2#include <Wire.h>
3
4struct __attribute__((packed)) Command {   // denetleyicideki yapının aynısı / same struct as on the controller
5  uint8_t ledOn;
6  uint8_t brightness;
7};
8
9struct __attribute__((packed)) Report {
10  uint16_t potValue;
11  uint8_t buttonPressed;
12  uint32_t uptimeMs;
13};
14
15const byte MY_ADDR = 8;
16const int LED_PIN = 9;
17const int BUTTON_PIN = 2;
18
19Command cmd;
20Report report;
21volatile bool newCmd = false;
22
23void onReceiveEvent(int howMany) {
24  if (howMany != sizeof(Command)) {        // beklenmeyen uzunluk: at / unexpected length: discard
25    while (Wire.available()) Wire.read();
26    return;
27  }
28  Wire.readBytes((uint8_t*)&cmd, sizeof(cmd));
29  newCmd = true;
30}
31
32void onRequestEvent() {                    // denetleyici veri istedi / the controller asked for data
33  Wire.write((const uint8_t*)&report, sizeof(report));   // tek seferde yaz / write it in one go
34}
35
36void setup() {
37  pinMode(LED_PIN, OUTPUT);
38  pinMode(BUTTON_PIN, INPUT_PULLUP);
39  Wire.begin(MY_ADDR);
40  Wire.onReceive(onReceiveEvent);
41  Wire.onRequest(onRequestEvent);
42}
43
44void loop() {
45  uint16_t pot = analogRead(A0);
46  uint8_t pressed = (digitalRead(BUTTON_PIN) == LOW);
47  uint32_t now = millis();
48
49  noInterrupts();                          // kopyalarken onRequest araya girmesin / keep onRequest out while copying
50  report.potValue = pot;
51  report.buttonPressed = pressed;
52  report.uptimeMs = now;
53  Command c = cmd;
54  bool fresh = newCmd;
55  newCmd = false;
56  interrupts();
57
58  if (fresh) analogWrite(LED_PIN, c.ledOn ? c.brightness : 0);
59}

Di sketch target, fungsi yang didaftarkan dengan Wire.onRequest() mengirim struct laporan apa adanya setiap kali controller meminta data. Laporannya sendiri diperbarui di loop(). Selama pembaruan, kita menghentikan interrupt sejenak dengan noInterrupts(), supaya kalau controller bertanya tepat pada detik itu, ia tidak mendapat nilai yang setengah lama dan setengah baru. Perintah yang masuk juga disalin ke variabel lokal di dalam perlindungan yang sama. Di controller, baris Wire.setWireTimeout(25000, true) mencegah bus terkunci selamanya kalau ada kabel yang longgar atau target macet: kalau tidak ada jawaban dalam 25 ms, Wire me-reset dirinya sendiri.

Selalu pakai tipe berukuran tetap seperti uint8_t, int16_t, dan uint32_t di dalam struct. Di Arduino Uno sebuah int berukuran 2 byte, di ESP32 4 byte; double berukuran 4 byte di Uno dan 8 byte di ESP32. __attribute__((packed)) mencegah compiler menyisipkan byte padding di antara field; tanpa itu, struct yang sama akan berukuran 7 byte di Uno dan 8 byte di ESP32, dan datanya bergeser. AVR dan ESP32 sama-sama little-endian, jadi urutan byte-nya cocok. Untuk menyegarkan ingatan soal bit dan byte, lihat Sistem Bilangan dan Operasi Bitwise.

Menghubungkan beberapa Arduino ke bus yang sama

Keunggulan besar I2C dibanding UART adalah banyak target bisa berbagi dua kabel yang sama. Beri setiap board target alamatnya sendiri (misalnya 8, 9, dan 10), gabungkan semua SDA, semua SCL, dan semua GND, lalu pakai satu pasang resistor pull-up untuk seluruh bus. Controller bisa menelusuri sebuah array alamat, mengirim perintah ke tiap board dan meminta laporannya. Makin panjang bus, makin besar kapasitansinya; letakkan board berdekatan, jaga total panjang kabel di kisaran beberapa puluh sentimeter, dan kalau perlu tetap di 100 kHz. Modul seperti LCD I2C atau OLED juga bisa kamu pasang di bus yang sama; selama alamatnya tidak bentrok, semuanya bekerja bersama tanpa masalah.

I2C antara Arduino dan ESP32: konversi level

Arduino Uno bekerja pada 5 V dan ESP32 pada 3,3 V, dan pin ESP32 tidak tahan 5 V. Karena Wire.begin() di Uno menyambungkan pull-up internal ke 5 V, menghubungkan kedua board secara langsung akan menarik pin ESP32 ke 5 V. Sebaliknya pun bermasalah: kalau bus hanya kamu tarik ke 3,3 V, input I2C Uno butuh minimal 0,7 × 5 V = 3,5 V untuk membaca HIGH, dan 3,3 V tidak mencukupi. Solusi yang benar adalah level shifter BSS138 dua arah dengan resistor pull-up di kedua sisinya: sisi HV ke 5V dan A4/A5 milik Uno, sisi LV ke 3V3 dan GPIO 21/22 milik ESP32, dan GND-nya digabung. Untuk pengkabelan yang lebih rinci, lihat Konverter Level Logika. ESP32 juga bisa berperan sebagai target sejak core versi 2.0.1, tetapi menyiapkan data tepat ketika onRequest dipanggil lebih sulit di ESP32, jadi susunan yang paling minim masalah adalah ESP32 sebagai controller dan Uno sebagai target. Sketch di bawah membaca laporan yang sama dari target Uno di Contoh 2:

C++ (Arduino IDE)
1// ESP32 denetleyici, Arduino Uno hedeften rapor okur / ESP32 controller reads the report from an Arduino Uno target
2#include <Wire.h>
3
4struct __attribute__((packed)) Report {    // Uno'daki yapıyla birebir aynı / exactly the same as on the Uno
5  uint16_t potValue;
6  uint8_t buttonPressed;
7  uint32_t uptimeMs;
8};
9
10const uint8_t TARGET_ADDR = 8;
11
12void setup() {
13  Serial.begin(115200);
14  Wire.begin(21, 22);                      // SDA = GPIO 21, SCL = GPIO 22 (seviye dönüştürücü üzerinden / through a level shifter)
15  Wire.setClock(100000);
16}
17
18void loop() {
19  Report r;
20  uint8_t n = Wire.requestFrom(TARGET_ADDR, (uint8_t)sizeof(Report));
21  if (n == sizeof(Report)) {
22    Wire.readBytes((uint8_t*)&r, sizeof(r));
23    Serial.printf("Pot: %u  Buton / button: %u  Sure / uptime: %lu ms\n",
24                  (unsigned int)r.potValue, (unsigned int)r.buttonPressed, (unsigned long)r.uptimeMs);
25  } else {
26    Serial.println("Uno yanit vermedi / Uno not responding");
27  }
28  delay(500);
29}

Controller I2C di Raspberry Pi Pico (MicroPython)

Raspberry Pi Pico juga bekerja pada 3,3 V, jadi cara menyambungkannya ke Uno sama, yaitu lewat level shifter. MicroPython tidak punya struct ala C, tetapi modul struct melakukan tugas yang sama: format "<HBI" berarti uint16_t, uint8_t, dan uint32_t little-endian tanpa padding, persis cocok dengan laporan 7 byte milik Uno. Kodenya lebih dulu memindai bus dan mencetak alamat yang ditemukan, lalu mengirim perintah ke target Uno dan membaca laporannya. Kalau kamu baru mengenal Pico, mulailah dari Apa Itu Raspberry Pi Pico?.

MicroPython
1from machine import I2C, Pin
2import struct, time
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=100000)   # seviye dönüştürücü üzerinden / through a level shifter
5print("Bulunan adresler / found:", [hex(a) for a in i2c.scan()])
6
7while True:
8    i2c.writeto(8, bytes([1, 128]))                  # Command: ledOn = 1, brightness = 128
9    data = i2c.readfrom(8, 7)                        # Report: 7 bayt / 7 bytes
10    pot, button, uptime = struct.unpack("<HBI", data)   # küçük endian, dolgusuz / little-endian, no padding
11    print("Pot:", pot, "Buton:", button, "ms:", uptime)
12    time.sleep(0.5)

I2C atau UART? Perbandingan

FiturI2CUART
KabelSDA, SCL, dan GND (lurus)TX, RX, dan GND (disilang)
Jumlah perangkatSatu controller dan hingga 112 alamatHanya dua perangkat
Siapa yang memulai percakapan?Hanya controllerKedua sisi, kapan pun mau
Kecepatan umum100 kHz atau 400 kHz9600–115200 baud
JarakDi dalam board dan kabel pendek (hingga 1 m)Beberapa meter; jauh lebih panjang dengan RS-485
Konfirmasi terkirimAda (ACK dan NACK)Tidak ada; kamu harus menambahkan pemeriksaan sendiri
Ukuran pesan (Wire)Buffer 32 byteAliran byte terus-menerus
Hardware di Arduino UnoA4 dan A5D0 dan D1 (berbagi dengan USB) atau SoftwareSerial

Singkatnya: pilih I2C kalau board-board berada di kotak yang sama, kalau satu board utama akan mengatur beberapa board pembantu, dan kalau kamu ingin yakin setiap pesan sampai. Kalau board terpisah beberapa meter, kalau kedua sisi perlu mengirim data kapan saja, atau kalau ada aliran data yang panjang dan terus-menerus, UART lebih cocok; detailnya ada di Komunikasi Serial UART. Kalau butuh kecepatan tinggi, pilihan ketiganya adalah SPI.

Kesalahan umum dan cara memperbaikinya

  • endTransmission() mengembalikan 2: Target tidak menjawab di alamat itu. Periksa bahwa alamatnya sama di kedua sketch, SDA dan SCL tidak tertukar, GND tersambung, dan sketch target sudah di-upload; pastikan alamatnya dengan scanner I2C.
  • Menyilang SDA dan SCL seperti UART: Di I2C, SDA ke SDA dan SCL ke SCL; dengan kabel yang disilang, tidak ada perangkat yang ditemukan.
  • Program macet di dalam onReceive: Fungsi interrupt memakai Serial.print() atau delay(), atau memulai transaksi Wire lain. Di sana cukup salin datanya, lalu kerjakan sisanya di loop().
  • Nilai yang datang kacau atau bergeser: Definisi struct berbeda di antara kedua board, dipakai tipe seperti int yang ukurannya bergantung pada board, atau packed tidak ditambahkan. Pakai tipe berukuran tetap dan definisi yang sama.
  • Error acak begitu kabel makin panjang: Pull-up internal tidak cukup. Tambahkan resistor eksternal 4,7 kΩ atau 2,2 kΩ, pendekkan kabel, dan jaga kecepatan di 100 kHz.
  • Bus berhenti bekerja atau ESP32 menjadi hangat begitu disambungkan: 5 V dan 3,3 V disambungkan langsung. Pasang level shifter dua arah di antaranya.

Membuat dua Arduino berbicara lewat I2C adalah cara termudah untuk memecah proyek besar menjadi bagian-bagian kecil yang mandiri: satu board menangani layar dan pengguna, sementara yang lain membaca sensor atau menggerakkan motor. Pastikan dulu sambungannya dengan contoh satu byte, baru lanjut ke contoh struct dua arah. Di aplikasi BlueGrays kamu bisa menemukan skema rangkaian dan kode langkah demi langkah untuk proyek komunikasi 2 Arduino satu arah dan dua arah, LCD I2C, kalkulator I2C, LCD I2C ESP32, dan jam RTC DS1307.

Pertanyaan umum

Bagaimana dua Arduino berkomunikasi lewat I2C?

Sambungkan pin A4 (SDA), A5 (SCL), dan GND kedua board secara langsung. Satu board dimulai sebagai controller dengan Wire.begin(), yang lain sebagai target dengan alamat, misalnya Wire.begin(8). Controller mengirim data dengan beginTransmission, write, dan endTransmission serta meminta data dengan requestFrom; target menjawab lewat fungsi onReceive dan onRequest.

Apakah perlu resistor pull-up untuk I2C antara dua Arduino?

Ya; jalur I2C bersifat open-drain, jadi level HIGH berasal dari resistor pull-up. Pull-up internal Arduino sering kali cukup untuk dua board dengan kabel pendek, tetapi untuk bus yang andal disarankan menambahkan 4,7 kΩ dari SDA dan dari SCL ke 5V.

Berapa banyak Arduino yang bisa disambungkan ke satu bus I2C?

Dengan pengalamatan 7 bit, ada 112 alamat dari 0x08 sampai 0x77 yang bisa dipakai, jadi secara teori muat 112 target. Dalam praktik, batasnya ditentukan oleh total kapasitansi bus dan panjang kabel; dengan beberapa board dan kabel pendek kamu tidak akan menemui masalah.

Bisakah Arduino slave mengirim data ke master atas kemauannya sendiri?

Tidak. Di I2C, controller-lah yang selalu memulai komunikasi; target hanya menjawab lewat onRequest ketika ditanya. Kalau target perlu memberi tahu bahwa ada data baru, controller menanyainya secara berkala, atau target menarik sebuah pin interrupt terpisah ke LOW untuk memberi sinyal ke controller.

Bisakah Arduino dan ESP32 disambungkan langsung lewat I2C?

Tidak disarankan. Uno bekerja pada 5 V dan ESP32 pada 3,3 V, dan pull-up internal Uno menarik pin ESP32 ke 5 V. Pakai level shifter dua arah seperti BSS138, lalu jadikan ESP32 sebagai controller dan Uno sebagai target.

Apa perbedaan I2C dan UART di Arduino?

I2C menempatkan banyak perangkat di bus yang sama dengan dua kabel dan alamat, serta mengonfirmasi dengan ACK bahwa setiap byte sampai, tetapi hanya controller yang bisa memulai percakapan. UART hanya menghubungkan dua perangkat, kabelnya disilang, dan kedua sisi bisa mengirim data kapan pun mau. I2C cocok untuk beberapa board yang berdekatan; UART cocok untuk kabel panjang dan aliran data terus-menerus.

Lihat semua proyek
Komunikasi Satu Arah Antara 2 Arduino
AR-57Menengah
Premium

Komunikasi Satu Arah Antara 2 Arduino

Kamu membuat dua Arduino berbicara lewat satu kabel: tekan tombol di satu board dan LED di board lain menyala, tekan lagi dan LED mati.

4.4(37)
50
Komunikasi Dua Arah Antara 2 Arduino
AR-58Menengah
Premium

Komunikasi Dua Arah Antara 2 Arduino

Dua Arduino disambung dengan kabel dan saling berbicara: tekan tombol di satu board dan lampu di board lain menyala, tekan lagi dan lampunya mati.

4.5(20)
26
Menggunakan Layar LCD dengan I2C
AR-32Pemula
Premium

Menggunakan Layar LCD dengan I2C

Beri Arduino-mu layar sendiri dan buat ia menulis pesan pertamanya. Layar LCD dua baris tersambung hanya dengan beberapa kabel; sapaan muncul di baris atas, lalu pesan kedua di baris bawah, layar…

4.8(53)
70
Kalkulator I2C Arduino
AR-94Menengah
Premium

Kalkulator I2C Arduino

Proyek kalkulator berbasis Arduino yang melakukan penjumlahan, pengurangan, perkalian, dan pembagian memakai keypad membran 4x4 dan layar LCD I2C 16x2. Berkat I2C, sambungan layar hanya butuh 2 kabel, sehingga kabel tidak semrawut dan lebih banyak pin tetap bebas dipakai. Kalkulator ini juga mendukung input bilangan desimal dan bilangan negatif.

5.0(31)
43
Layar LCD I2C ESP32 (16x2)
ES-17Menengah
Premium

Layar LCD I2C ESP32 (16x2)

Di proyek ini, kita menampilkan teks dengan menyambungkan layar LCD karakter 16x2 ke ESP32 lewat protokol I2C. Berkat I2C, kita bisa mengendalikan layar hanya dengan dua pin data (SDA dan SCL), sehingga tidak perlu memboroskan 6+ pin seperti pada sambungan paralel klasik. Kode mencetak pesan tetap di baris pertama dan penghitung yang naik setiap detik di baris kedua. Selain itu, kita menjalankan pemindai I2C di awal untuk mencetak alamat layar ke Serial Monitor (biasanya 0x27).

4.9(23)
40
Jam Digital dengan ESP32 dan RTC DS1307 (I2C + LCD)
ES-18Menengah
Premium

Jam Digital dengan ESP32 dan RTC DS1307 (I2C + LCD)

Di proyek ini, kita menampilkan waktu dan tanggal di layar LCD I2C 16x2 memakai modul jam real-time (RTC) DS1307. DS1307 adalah RTC berbaterai cadangan yang tetap menjaga waktu meskipun ESP32 dimatikan. Kedua modul berbagi bus I2C yang sama (SDA/SCL), sehingga kita belajar mengendalikan beberapa perangkat hanya dengan dua kabel sinyal. Lewat proyek ini kamu mendapat pengetahuan praktis tentang protokol komunikasi I2C, cara kerja modul RTC, dan tampilan data dinamis di LCD.

4.6(26)
40
Game Bola Pemukul - SSD1306
AR-86Menengah
Premium

Game Bola Pemukul - SSD1306

Satu bola, dua pemukul, dan kamu: kamu bermain tenis meja, salah satu video game paling awal, di layar OLED kecil.

4.5(47)
65
Jam dan Kalender Dot Matrix (MAX7219, DS1307)
AR-84Menengah
Premium

Jam dan Kalender Dot Matrix (MAX7219, DS1307)

Papan bercahaya untuk meja atau dinding yang menampilkan waktu dan tanggal dengan teks berjalan.

5.0(37)
59