İki Arduino I2C Haberleşme: Master-Slave, onReceive ve Struct
İki Arduino I2C haberleşme: master-slave bağlantı, pull-up değeri, Wire.onReceive ve onRequest, adres seçimi, struct gönderme ve ESP32 ile seviye dönüştürme.
İki Arduino haberleşmesi için I2C, yalnızca iki veri kablosu (SDA ve SCL) ile ortak bir GND kullanan ve Arduino'nun yerleşik Wire kütüphanesiyle birkaç satırda kurulan en pratik yöntemlerden biridir. Kartlardan biri denetleyici (eski adıyla master) olur ve konuşmayı her zaman o başlatır; diğeri bir adres alan hedef (slave) olur ve kendisine yazılanı dinler ya da istenince cevap verir. Aynı iki kabloya onlarca hedef bağlanabildiği için bir ana kartın birkaç yardımcı Arduino'yu yönettiği projelerde I2C çok kullanışlıdır.
Bu yazıda iki Arduino Uno'yu adım adım I2C ile bağlıyoruz: bağlantı ve pull-up tablosu, adres seçimi, Wire.onReceive ve Wire.onRequest fonksiyonları, tek bayt gönderme, struct ile çift yönlü veri alışverişi, aynı hatta birden fazla Arduino, ESP32 ve Raspberry Pi Pico ile seviye dönüştürücü üzerinden haberleşme ve I2C ile UART karşılaştırması. I2C'nin temellerini ve tarayıcı kodunu merak ediyorsan önce I2C Nedir? yazısına göz atabilirsin.

I2C'de denetleyici ve hedef (master-slave) nasıl çalışır?
I2C'de bütün cihazlar aynı iki hatta paralel bağlanır. SCL saat hattıdır ve saati her zaman denetleyici üretir; SDA veri hattıdır ve iki yönde de kullanılır. Denetleyici bir mesaja başlamak için "start" koşulu oluşturur, ardından 7 bitlik hedef adresini ve okuma ya da yazma bitini gönderir. O adrese sahip hedef, her baytın sonunda hattı kısa bir süre LOW çekerek ACK (aldım) cevabı verir; adreste kimse yoksa hat HIGH kalır ve buna NACK denir. Bu yüzden I2C'de bir mesajın yerine ulaşıp ulaşmadığını denetleyici hemen öğrenir. En önemli kural şudur: hedef kendi başına konuşamaz. Hedefte yeni bir veri olsa bile denetleyici sorana kadar bekler; denetleyicinin hedefi düzenli aralıklarla yoklaması gerekir. Arduino'nun belgelerinde bu roller "controller" ve "peripheral", I2C standardının yeni sürümünde ise "controller" ve "target" olarak geçer; eski kodlarda gördüğün master ve slave ile aynı anlamdadır.
Bağlantı: iki Arduino arasında I2C kabloları
| Arduino A (denetleyici) | Bağlantı | Arduino B (hedef) | Not |
|---|---|---|---|
| A4 (SDA) | Doğrudan | A4 (SDA) | Çapraz bağlanmaz |
| A5 (SCL) | Doğrudan | A5 (SCL) | Çapraz bağlanmaz |
| GND | Doğrudan | GND | Zorunlu: ortak referans |
| 5V | İsteğe bağlı | 5V | Yalnızca B kartı A'dan beslenecekse |
| SDA ve SCL | 4,7 kΩ ile 5V'a | - | Bütün hat için bir çift direnç yeter |
| Kart | SDA | SCL | Not |
|---|---|---|---|
| Arduino Uno / Nano | A4 | A5 | Uno R3'te AREF yanındaki SDA ve SCL aynı hattır |
| Arduino Mega 2560 | D20 | D21 | Kartın üzerinde 10 kΩ pull-up dirençleri vardır |
| Arduino Leonardo / Micro | D2 | D3 | Uno'dan farklı pinler |
| ESP32 | GPIO 21 | GPIO 22 | 3,3 V; Wire.begin(sda, scl) ile başka pinler seçilebilir |
| Raspberry Pi Pico | GP4 (I2C0) | GP5 (I2C0) | 3,3 V; MicroPython'da başka pin çiftleri de seçilebilir |
Pull-up dirençleri: ne zaman ve hangi değer?
I2C hatlarındaki cihazlar hattı yalnızca LOW'a çekebilir; hattı HIGH'a taşıyan şey pull-up dirençleridir. Arduino'nun AVR kartlarında Wire.begin() SDA ve SCL'de yaklaşık 20–50 kΩ'luk dahili pull-up dirençlerini açar. Kısa kablolu iki Uno ve 100 kHz hızda bu çoğu zaman çalışır, ama bu dirençler I2C için zayıftır; kablo uzadıkça sinyalin yükselme kenarı yavaşlar ve hatalar başlar. Güvenilir bir hat için SDA ve SCL'den 5V'a birer 4,7 kΩ direnç ekle. Alt sınır, LOW durumda çekilen 3 mA'lik akımdan gelir: R(min) = (5 V - 0,4 V) / 3 mA ≈ 1,5 kΩ. Üst sınırı ise hattın kapasitesi belirler: 100 kHz'de 200 pF'lık bir hat için R(maks) ≈ 1000 ns / (0,8473 × 200 pF) ≈ 5,9 kΩ eder. Hesaplar için Ohm Kanunu aracını, pull-up mantığı için Pull-up ve Pull-down Direnci yazısını kullanabilirsin.
| Durum | Önerilen pull-up | Not |
|---|---|---|
| İki Uno, 30 cm'den kısa kablo, 100 kHz | 4,7 kΩ (dahili dirençler de çoğu zaman çalışır) | En sık kullanılan düzen |
| 50 cm–1 m kablo ya da 400 kHz | 2,2 kΩ | Kabloyu yine de olabildiğince kısa tut |
| Hatta Arduino Mega var | Ek direnç gerekmeyebilir | Mega'nın kart üstü 10 kΩ'u diğer dirençlerle paralel olur |
| Hatta pull-up'lı modüller var (OLED, RTC, LCD) | Toplam paralel direnci hesapla | Toplam değer 1,5 kΩ'un altına inmemeli |
| Arduino ile ESP32 ya da Pico | Seviye dönüştürücünün iki yanındaki dirençler | Doğrudan bağlama, aşağıdaki bölüme bak |
Adres seçimi: hangi adresi kullanmalısın?
Hedef Arduino'nun adresini Wire.begin(adres) ile sen seçersin. 7 bitlik adres alanında 0x00–0x07 ve 0x78–0x7F ayrılmış olduğundan kullanabileceğin aralık 0x08–0x77, yani ondalık olarak 8–119'dur. Aynı hatta başka modüller de varsa onların adresleriyle çakışmayan bir değer seç; en güvenli yol, hattaki her şeyi bağladıktan sonra I2C tarayıcı kodunu çalıştırıp dolu adresleri görmektir. Sık kullanılan modüllerin adresleri şunlardır:
| Adres | Bu adresi sık kullanan modüller |
|---|---|
| 0x27 / 0x3F | PCF8574 sürücülü I2C LCD |
| 0x3C / 0x3D | SSD1306 OLED ekran |
| 0x68 | DS1307 ve DS3231 RTC, MPU-6050 |
| 0x76 / 0x77 | BMP280 ve BME280 |
| 0x40 | PCA9685 servo sürücü, INA219 |
| 0x48 | ADS1115 ADC |
| 0x57 | MAX30102, RTC modüllerindeki AT24C32 EEPROM |
| 0x08–0x0F | Genellikle boştur; Arduino hedefler için iyi bir aralık |
Örnek 1: denetleyiciden hedefe bayt göndermek
İlk örnekte A kartı A0'a bağlı bir potansiyometrenin değerini 4'e bölerek 0–255 aralığına indirir ve saniyede 10 kez tek bir bayt olarak 8 numaralı adrese gönderir. B kartı bu baytı alır ve D9'daki LED'in parlaklığını ayarlar. Önce denetleyici kodunu A kartına, ardından hedef kodunu B kartına yükle. Wire kütüphanesi Arduino IDE ile birlikte gelir, ayrıca kurman gerekmez. Denetleyici kodu:
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}B kartına yükleyeceğin hedef kodu:
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}Hedef kodunda iki kritik nokta var. Birincisi Wire.begin(8): adresle başlatılan kart hedef olur. İkincisi Wire.onReceive(): denetleyici veri gönderdiğinde Wire kütüphanesi bu fonksiyonu kendisi çağırır ve gelen bayt sayısını parametre olarak verir. Gelen değeri volatile bir değişkene yazıp yalnızca "yeni veri var" işaretini kaldırıyoruz; LED'i ayarlamak ve Seri Monitör'e yazmak loop() içinde yapılıyor. Denetleyicide ise Wire.endTransmission() dönüş değeri sana mesajın ne olduğunu söyler:
| endTransmission() değeri | Anlamı | Ne yapmalı? |
|---|---|---|
| 0 | Başarılı, hedef her baytı onayladı | - |
| 1 | Veri tampona sığmadı (32 bayttan uzun) | Mesajı parçalara böl |
| 2 | Adrese ACK gelmedi | Adresi, kabloları, GND'yi ve hedefin açık olduğunu kontrol et |
| 3 | Veri baytına ACK gelmedi | Hedef meşgul ya da beklenmeyen uzunlukta veri |
| 4 | Diğer hata | Hat gürültülü ya da pull-up eksik olabilir |
| 5 | Zaman aşımı | Hat takıldı; setWireTimeout() ile kurtarma aç |
onReceive ve onRequest: kesme içinde dikkat edilecekler
- Kısa tut: İki fonksiyon da I2C kesmesinin içinde çalışır. Bu sırada delay(), Serial.print() ya da uzun hesaplamalar kullanma; veriyi bir değişkene yaz ve çık.
- volatile kullan: Kesmede değişen ve loop() içinde okunan işaretleri volatile tanımla; aksi hâlde derleyici değişikliği görmeyebilir. Ayrıntılar için Arduino Interrupt yazısına bak.
- onRequest'te tek seferde yaz: Denetleyici veri istediğinde gönderilecek baytların hepsini Wire.write(dizi, uzunluk) ile bir kerede tampona koy. Veriyi önceden hazırla; onRequest içinde sensör okumak denetleyiciyi bekletir.
- 32 bayt sınırı: AVR'deki Wire tamponu 32 bayttır. Daha uzun veriyi birkaç mesaja böl ya da gerçekten gerekiyorsa UART kullan.
- Uzunluğu kontrol et: onReceive'e gelen bayt sayısını beklediğin uzunlukla karşılaştır; eksik ya da fazla gelen veriyi okuyup at.
- Sıradaki işi beklet: Hedef kart uzun bir işe girmeden önce rapor değişkenlerini güncelle; böylece denetleyici her sorduğunda hazır bir cevap bulur.
Örnek 2: struct ile çift yönlü haberleşme
Gerçek projelerde tek bayttan fazlası gerekir: denetleyici bir komut gönderir, hedef birden çok değer içeren bir rapor döndürür. Değerleri tek tek baytlara bölmek yerine bir struct tanımlayıp onu olduğu gibi göndermek hem okunaklı hem de hızlıdır. Aşağıdaki örnekte denetleyici 2 baytlık bir komutla LED'i ve parlaklığını ayarlar, ardından Wire.requestFrom() ile hedeften 7 baytlık bir rapor ister: potansiyometre değeri (uint16_t), butonun durumu (uint8_t) ve hedefin açık kaldığı süre (uint32_t). Yapıların iki kartta da birebir aynı olması şarttır. Denetleyici kodu:
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}Hedef kartın kodu; yapı tanımları denetleyicidekiyle harfi harfine aynıdır:
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}Hedef kodunda Wire.onRequest() ile kaydedilen fonksiyon, denetleyici veri istediğinde rapor yapısını olduğu gibi gönderir. Raporun kendisi loop() içinde güncellenir. Güncelleme sırasında noInterrupts() ile kesmeleri kısa bir süre durduruyoruz; böylece denetleyici tam o anda soru sorarsa yarısı eski, yarısı yeni bir değer almaz. Gelen komut da aynı korumanın içinde yerel bir kopyaya alınır. Denetleyicideki Wire.setWireTimeout(25000, true) satırı, bir kablo gevşediğinde ya da hedef takıldığında hattın sonsuza kadar kilitlenmesini önler: 25 ms içinde cevap gelmezse Wire kendini sıfırlar.
Birden fazla Arduino'yu aynı hatta bağlamak
I2C'nin UART'a göre en büyük üstünlüğü, aynı iki kabloya çok sayıda hedef bağlanabilmesidir. Her hedef karta farklı bir adres ver (örneğin 8, 9 ve 10), bütün SDA'ları, SCL'leri ve GND'leri birleştir ve hattın tamamı için yalnızca bir çift pull-up direnci kullan. Denetleyici bir dizideki adresleri sırayla dolaşarak her karta komut gönderebilir ve raporunu isteyebilir. Hat uzadıkça kapasite artar; kartları yan yana tut, toplam kablo boyunu birkaç on santimetrede bırak ve gerekirse hızı 100 kHz'de sabitle. Aynı hatta I2C LCD ya da OLED gibi modüller de kullanabilirsin; adresleri çakışmadığı sürece hepsi sorunsuz birlikte çalışır.
Arduino ile ESP32 arasında I2C: seviye dönüştürme
Arduino Uno 5 V, ESP32 ise 3,3 V ile çalışır ve ESP32'nin pinleri 5 V'a dayanıklı değildir. Uno'da Wire.begin() dahili pull-up'ları 5 V'a bağladığı için iki kartı doğrudan bağlamak ESP32'nin pinlerini 5 V'a çeker. Tersi de sorunludur: hattı yalnızca 3,3 V'a çekersen Uno'nun I2C girişleri HIGH için en az 0,7 × 5 V = 3,5 V ister ve 3,3 V bu sınırın altında kalır. Doğru çözüm, her iki yanında pull-up dirençleri bulunan çift yönlü bir BSS138 seviye dönüştürücüdür: modülün HV tarafı Uno'nun 5V'una ve A4/A5'ine, LV tarafı ESP32'nin 3V3'üne ve GPIO 21/22'sine bağlanır, GND'ler ortak olur. Ayrıntılı bağlantı için Lojik Seviye Dönüştürücü yazısına bakabilirsin. ESP32 çekirdeğin 2.0.1 ve sonraki sürümlerinde hedef olarak da çalışabilir, ancak istenen veriyi onRequest anında hazırlamak ESP32'de daha zordur; bu yüzden ESP32'yi denetleyici, Uno'yu hedef yapmak en sorunsuz düzendir. Aşağıdaki kod, Örnek 2'deki Uno hedefinden aynı raporu okur:
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}Raspberry Pi Pico ile I2C denetleyici (MicroPython)
Raspberry Pi Pico da 3,3 V ile çalıştığı için Uno'ya aynı şekilde seviye dönüştürücü üzerinden bağlanır. MicroPython'da struct yapısı yoktur ama struct modülü aynı işi görür: "<HBI" biçimi küçük endian, dolgusuz bir uint16_t, bir uint8_t ve bir uint32_t demektir ve Uno'daki 7 baytlık raporla birebir örtüşür. Kod önce hattı tarar ve bulduğu adresleri yazar, sonra Uno hedefe komut gönderip raporunu okur. Pico'ya yeni başlıyorsan Raspberry Pi Pico Nedir? yazısından başlayabilirsin.
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 mi, UART mı? Karşılaştırma
| Özellik | I2C | UART |
|---|---|---|
| Kablolar | SDA, SCL ve GND (doğrudan) | TX, RX ve GND (çapraz) |
| Cihaz sayısı | Bir denetleyici ve 112'ye kadar adres | Yalnızca iki cihaz |
| Konuşmayı kim başlatır? | Yalnızca denetleyici | İki taraf da istediği an |
| Tipik hız | 100 kHz ya da 400 kHz | 9600–115200 baud |
| Mesafe | Kart üstü ve kısa kablolar (1 m'ye kadar) | Birkaç metre; RS-485 ile çok daha uzun |
| Teslim onayı | Var (ACK ve NACK) | Yok; kendi kontrolünü eklemelisin |
| Mesaj boyutu (Wire) | 32 bayt tampon | Sürekli bayt akışı |
| Arduino Uno'da donanım | A4 ve A5 | D0 ve D1 (USB ile paylaşılır) ya da SoftwareSerial |
Kısa özet: kartlar aynı kutudaysa, bir ana kart birden fazla yardımcı kartı yönetecekse ve mesajın ulaştığından emin olmak istiyorsan I2C seç. Kartlar birbirinden birkaç metre uzaktaysa, iki tarafın da istediği an veri göndermesi gerekiyorsa ya da uzun ve sürekli veri akışı varsa UART daha uygundur; ayrıntılar UART Seri Haberleşme yazısında. Çok yüksek hız gerekiyorsa üçüncü seçenek olarak SPI'ye bakabilirsin.
Sık yapılan hatalar ve çözümleri
- endTransmission() 2 döndürüyor: Hedef bu adreste yanıt vermiyor. Adresin iki kodda aynı olduğunu, SDA ile SCL'nin yer değiştirmediğini, GND'nin bağlı olduğunu ve hedef kodun yüklü olduğunu kontrol et; I2C tarayıcıyla adresi doğrula.
- SDA ve SCL'yi UART gibi çapraz bağlamak: I2C'de SDA SDA'ya, SCL SCL'ye gider; çapraz bağlantıda hiçbir cihaz bulunamaz.
- Program onReceive içinde donuyor: Kesme fonksiyonunda Serial.print(), delay() ya da Wire ile yeni bir iletişim başlatılmış. Fonksiyonda yalnızca veriyi kopyala, işini loop() içinde yap.
- Gelen değerler karışık ya da kaymış: İki karttaki struct tanımları farklı, int gibi boyutu karta göre değişen bir tür kullanılmış ya da packed eklenmemiş. Sabit boyutlu türler ve aynı tanımı kullan.
- Kablo uzayınca rastgele hatalar: Dahili pull-up'lar yetersiz kalıyor. 4,7 kΩ ya da 2,2 kΩ harici direnç ekle, kabloyu kısalt ve hızı 100 kHz'de tut.
- ESP32 bağlanınca hat hiç çalışmıyor ya da ESP32 ısınıyor: 5 V ve 3,3 V doğrudan bağlanmış. Araya çift yönlü bir seviye dönüştürücü koy.
I2C ile iki Arduino'yu konuşturmak, büyük projeleri küçük ve bağımsız parçalara bölmenin en kolay yoludur: bir kart ekranı ve kullanıcıyı yönetirken diğerleri sensörleri okur ya da motorları sürer. Önce tek baytlık örnekle bağlantıyı doğrula, ardından struct'lı çift yönlü örneğe geç. BlueGrays uygulamasındaki 2 Arduino tek yönlü ve çift yönlü haberleşme projelerinde, I2C LCD, I2C hesap makinesi, ESP32 I2C LCD ve DS1307 RTC'li saat projelerinde devre şemalarını ve kodları adım adım bulabilirsin.
Sıkça sorulan sorular
İki Arduino I2C ile nasıl haberleşir?
İki kartın A4 (SDA), A5 (SCL) ve GND pinleri birbirine doğrudan bağlanır. Bir kart Wire.begin() ile denetleyici, diğeri Wire.begin(8) gibi bir adresle hedef olarak başlatılır. Denetleyici beginTransmission, write ve endTransmission ile veri gönderir, requestFrom ile veri ister; hedef bunlara onReceive ve onRequest fonksiyonlarıyla cevap verir.
I2C'de pull-up direnci şart mı?
Evet, I2C hatları açık kollektörlü (open-drain) olduğu için HIGH seviyeyi pull-up dirençleri sağlar. Arduino'nun dahili pull-up'ları kısa kablolu iki kartta çoğu zaman çalışır, ama güvenilir bir hat için SDA ve SCL'den 5V'a 4,7 kΩ direnç eklemek önerilir.
Bir I2C hattına kaç Arduino bağlanabilir?
7 bitlik adreslemeyle 0x08–0x77 arasında 112 adres kullanılabilir, yani teoride 112 hedef bağlanabilir. Pratikte sınırı hattın toplam kapasitesi ve kablo uzunluğu belirler; birkaç kart ve kısa kablolarla sorun yaşamazsın.
Hedef (slave) Arduino denetleyiciye kendiliğinden veri gönderebilir mi?
Hayır. I2C'de iletişimi her zaman denetleyici başlatır; hedef yalnızca kendisine sorulduğunda onRequest ile cevap verir. Hedefte yeni veri olduğunda haber vermesi gerekiyorsa denetleyici düzenli aralıklarla sorar ya da hedef ayrı bir kesme pinini LOW yaparak denetleyiciyi uyarır.
Arduino ile ESP32 I2C ile doğrudan bağlanabilir mi?
Önerilmez. Uno 5 V, ESP32 3,3 V ile çalışır ve Uno'nun dahili pull-up'ları ESP32 pinlerini 5 V'a çeker. BSS138 gibi çift yönlü bir seviye dönüştürücü kullan ve ESP32'yi denetleyici, Uno'yu hedef yap.
I2C ile UART arasındaki fark nedir?
I2C iki kabloyla çok sayıda cihazı adresleriyle aynı hatta toplar ve her baytın ulaştığını ACK ile bildirir, ama konuşmayı yalnızca denetleyici başlatır. UART ise yalnızca iki cihaz arasında çalışır, kabloları çapraz bağlanır ve iki taraf da istediği an veri gönderebilir. Kısa mesafede çok kartlı düzenler için I2C, uzun kablolar ve sürekli veri akışı için UART daha uygundur.
Bu yazıdan sonra yapabileceğin projeler
Tüm projeleri gör
2 Arduino Tek Yönlü Haberleşme
İki Arduino'yu tek bir kabloyla konuşturursun: birindeki butona basınca öbüründeki LED yanar, bir daha basınca söner.

2 Arduino Çift Yönlü Haberleşme
İki Arduino kabloyla birbirine bağlanıp konuşur: birinin butonuna basınca öbürünün ışığı yanar, yeniden basınca söner.

I2C İle LCD Ekran Kullanımı
Arduino'ya kendi ekranını kazandır ve ilk mesajını yazdır. İki satırlık LCD ekran yalnızca birkaç kabloyla bağlanır; önce üst satıra bir selam, ardından alt satıra ikinci bir yazı gelir, ekran…

Arduino I2C Hesap Makinesi
4x4 membran tuş takımı ve 16x2 I2C LCD ekran kullanarak toplama, çıkarma, çarpma ve bölme işlemlerini gerçekleştiren Arduino tabanlı bir hesap makinesi projesidir. I2C sayesinde sadece 2 kablo ile ekran bağlantısı sağlanır, böylece kablo karmaşası azalır ve daha fazla pin kullanıma açık kalır. Ondalıklı sayı girişi ve negatif sayı desteği de bulunmaktadır.

ESP32 I2C LCD Ekran (16x2)
Bu projede 16x2 karakter LCD ekranı I2C protokolü üzerinden ESP32'ye bağlayarak metin görüntülüyoruz. I2C sayesinde sadece 2 data pini (SDA ve SCL) ile ekranı kontrol edebiliyoruz; klasik paralel bağlantıdaki 6+ pin israfı ortadan kalkıyor. Kod ilk satıra sabit bir mesaj, ikinci satıra ise her saniye artan bir sayaç yazdırıyor. Ayrıca başlangıçta I2C tarayıcı çalıştırarak ekranın adresini Serial Monitor'a yazdırıyoruz (genelde 0x27 veya 0x3F).

ESP32 RTC DS1307 ile Dijital Saat (I2C + LCD)
Bu projede DS1307 gerçek zaman saati (RTC) modülü ile 16x2 I2C LCD ekrana saat ve tarih bilgisi yansıtıyoruz. DS1307 pil destekli bir RTC'dir; ESP32 kapansa bile zamanı korur. Her iki modül de aynı I2C hattını (SDA/SCL) paylaşır, böylece sadece iki sinyal kablosu ile çoklu cihaz kontrolü öğrenmiş oluruz. Bu proje sayesinde I2C haberleşme protokolünü, RTC modüllerinin çalışma prensibini ve LCD ekranda dinamik veri gösterimini pratik bir şekilde öğreneceksiniz.

Raket Topu Oyunu - SSD1306
Bir top, iki raket ve sen: video oyunlarının en eskilerinden masa tenisini küçük bir OLED ekranda oynarsın.

Dot Matrix Saat ve Takvim (MAX7219, DS1307)
Masada ya da duvarda duran, saati ve tarihi kayan yazıyla gösteren ışıklı bir pano.
Diğer yazılar
BlueGrays uygulaması
Bu devreyi telefonunda adım adım kur
Devre şeması, kod ve parça listesi tek ekranda. 500'den fazla Arduino, ESP32 ve Pico projesi seni bekliyor.
Telefonunla tara
Kamerayı koda tut; telefonunun uygulama mağazası açılır.
ya da mağazada aç

