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?.

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) | Sambungan | Arduino B (target) | Catatan |
|---|---|---|---|
| A4 (SDA) | Langsung | A4 (SDA) | Tidak disilang |
| A5 (SCL) | Langsung | A5 (SCL) | Tidak disilang |
| GND | Langsung | GND | Wajib: referensi bersama |
| 5V | Opsional | 5V | Hanya jika board B diberi daya dari board A |
| SDA dan SCL | 4,7 kΩ ke 5V | - | Satu pasang resistor cukup untuk seluruh bus |
| Board | SDA | SCL | Catatan |
|---|---|---|---|
| Arduino Uno / Nano | A4 | A5 | Di Uno R3, pin SDA dan SCL di sebelah AREF adalah bus yang sama |
| Arduino Mega 2560 | D20 | D21 | Punya resistor pull-up 10 kΩ di board |
| Arduino Leonardo / Micro | D2 | D3 | Pin berbeda dari Uno |
| ESP32 | GPIO 21 | GPIO 22 | 3,3 V; Wire.begin(sda, scl) memungkinkan memilih pin lain |
| Raspberry Pi Pico | GP4 (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.
| Situasi | Pull-up yang disarankan | Catatan |
|---|---|---|
| Dua Uno, kabel di bawah 30 cm, 100 kHz | 4,7 kΩ (pull-up internal sering kali juga cukup) | Susunan yang paling umum |
| Kabel 50 cm sampai 1 m, atau 400 kHz | 2,2 kΩ | Tetap usahakan kabel sependek mungkin |
| Ada Arduino Mega di bus | Mungkin tidak perlu tambahan | Resistor 10 kΩ milik Mega jadi paralel dengan resistor lainnya |
| Ada modul ber-pull-up di bus (OLED, RTC, LCD) | Hitung total hambatan paralelnya | Totalnya jangan sampai turun di bawah 1,5 kΩ |
| Arduino dengan ESP32 atau Pico | Resistor level shifter di tiap sisi | Jangan 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:
| Alamat | Modul yang sering memakainya |
|---|---|
| 0x27 / 0x3F | LCD I2C dengan backpack PCF8574 |
| 0x3C / 0x3D | Layar OLED SSD1306 |
| 0x68 | RTC DS1307 dan DS3231, MPU-6050 |
| 0x76 / 0x77 | BMP280 dan BME280 |
| 0x40 | Driver servo PCA9685, INA219 |
| 0x48 | ADC ADS1115 |
| 0x57 | MAX30102, EEPROM AT24C32 pada modul RTC |
| 0x08–0x0F | Biasanya 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:
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:
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() | Arti | Yang perlu dilakukan |
|---|---|---|
| 0 | Berhasil, target mengonfirmasi setiap byte | - |
| 1 | Data terlalu panjang untuk buffer (lebih dari 32 byte) | Pecah pesan menjadi beberapa bagian |
| 2 | Tidak ada ACK untuk alamat | Periksa alamat, pengkabelan, GND, dan pastikan target mendapat daya |
| 3 | Tidak ada ACK untuk byte data | Target sedang sibuk atau menerima panjang data yang tidak terduga |
| 4 | Error lain | Bus mungkin ber-noise atau tidak punya pull-up |
| 5 | Timeout | Bus 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:
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:
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.
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:
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?.
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
| Fitur | I2C | UART |
|---|---|---|
| Kabel | SDA, SCL, dan GND (lurus) | TX, RX, dan GND (disilang) |
| Jumlah perangkat | Satu controller dan hingga 112 alamat | Hanya dua perangkat |
| Siapa yang memulai percakapan? | Hanya controller | Kedua sisi, kapan pun mau |
| Kecepatan umum | 100 kHz atau 400 kHz | 9600–115200 baud |
| Jarak | Di dalam board dan kabel pendek (hingga 1 m) | Beberapa meter; jauh lebih panjang dengan RS-485 |
| Konfirmasi terkirim | Ada (ACK dan NACK) | Tidak ada; kamu harus menambahkan pemeriksaan sendiri |
| Ukuran pesan (Wire) | Buffer 32 byte | Aliran byte terus-menerus |
| Hardware di Arduino Uno | A4 dan A5 | D0 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.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
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.

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.

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…

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.

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).

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.

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

Jam dan Kalender Dot Matrix (MAX7219, DS1307)
Papan bercahaya untuk meja atau dinding yang menampilkan waktu dan tanggal dengan teks berjalan.
Artikel lainnya
Aplikasi BlueGrays
Rakit rangkaian ini langkah demi langkah di ponselmu
Skema pengkabelan, kode, dan daftar komponen dalam satu layar. 500+ proyek Arduino, ESP32, dan Pico siap dibuat.
Pindai dengan ponselmu
Arahkan kamera ke kode ini dan toko aplikasi di ponselmu akan terbuka.
atau buka toko aplikasi

