Temeller · 8 dk okuma

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

Arduino Uno
Arduino Uno: I2C hattı A4 (SDA) ve A5 (SCL) pinlerindedir; R3 kartlarda aynı hat AREF pininin yanındaki SDA ve SCL başlıklarına da çıkar.

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ğrudanA4 (SDA)Çapraz bağlanmaz
A5 (SCL)DoğrudanA5 (SCL)Çapraz bağlanmaz
GNDDoğrudanGNDZorunlu: ortak referans
5Vİsteğe bağlı5VYalnızca B kartı A'dan beslenecekse
SDA ve SCL4,7 kΩ ile 5V'a-Bütün hat için bir çift direnç yeter
UART'ın aksine I2C'de kablolar çapraz bağlanmaz: SDA, SDA'ya; SCL, SCL'ye gider. İki kartın GND'sini de mutlaka birleştir; GND bağlanmazsa haberleşme ya hiç kurulmaz ya da rastgele hatalar verir. Ortak toprağın neden şart olduğunu GND ve Ortak Toprak yazısında okuyabilirsin.
KartSDASCLNot
Arduino Uno / NanoA4A5Uno R3'te AREF yanındaki SDA ve SCL aynı hattır
Arduino Mega 2560D20D21Kartın üzerinde 10 kΩ pull-up dirençleri vardır
Arduino Leonardo / MicroD2D3Uno'dan farklı pinler
ESP32GPIO 21GPIO 223,3 V; Wire.begin(sda, scl) ile başka pinler seçilebilir
Raspberry Pi PicoGP4 (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-upNot
İki Uno, 30 cm'den kısa kablo, 100 kHz4,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 kHz2,2 kΩKabloyu yine de olabildiğince kısa tut
Hatta Arduino Mega varEk direnç gerekmeyebilirMega'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 hesaplaToplam değer 1,5 kΩ'un altına inmemeli
Arduino ile ESP32 ya da PicoSeviye dönüştürücünün iki yanındaki dirençlerDoğ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:

AdresBu adresi sık kullanan modüller
0x27 / 0x3FPCF8574 sürücülü I2C LCD
0x3C / 0x3DSSD1306 OLED ekran
0x68DS1307 ve DS3231 RTC, MPU-6050
0x76 / 0x77BMP280 ve BME280
0x40PCA9685 servo sürücü, INA219
0x48ADS1115 ADC
0x57MAX30102, RTC modüllerindeki AT24C32 EEPROM
0x08–0x0FGenellikle 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:

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}

B kartına yükleyeceğin hedef kodu:

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}

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ğeriAnlamıNe yapmalı?
0Başarılı, hedef her baytı onayladı-
1Veri tampona sığmadı (32 bayttan uzun)Mesajı parçalara böl
2Adrese ACK gelmediAdresi, kabloları, GND'yi ve hedefin açık olduğunu kontrol et
3Veri baytına ACK gelmediHedef meşgul ya da beklenmeyen uzunlukta veri
4Diğer hataHat gürültülü ya da pull-up eksik olabilir
5Zaman 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:

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}

Hedef kartın kodu; yapı tanımları denetleyicidekiyle harfi harfine aynıdır:

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}

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.

Struct'ta her zaman uint8_t, int16_t, uint32_t gibi boyutu sabit türler kullan. Arduino Uno'da int 2 bayt, ESP32'de 4 bayttır; double ise Uno'da 4, ESP32'de 8 bayttır. __attribute__((packed)) derleyicinin alanlar arasına dolgu baytı koymasını engeller; bu olmadan aynı yapı Uno'da 7, ESP32'de 8 bayt olurdu ve veriler kayardı. AVR ve ESP32 ikisi de küçük endian olduğu için bayt sırası aynıdır. Bitlerin ve baytların yapısını tazelemek istersen Sayı Sistemleri ve Bit İşlemleri yazısına bak.

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:

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}

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.

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 mi, UART mı? Karşılaştırma

ÖzellikI2CUART
KablolarSDA, SCL ve GND (doğrudan)TX, RX ve GND (çapraz)
Cihaz sayısıBir denetleyici ve 112'ye kadar adresYalnızca iki cihaz
Konuşmayı kim başlatır?Yalnızca denetleyiciİki taraf da istediği an
Tipik hız100 kHz ya da 400 kHz9600–115200 baud
MesafeKart ü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 tamponSürekli bayt akışı
Arduino Uno'da donanımA4 ve A5D0 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.

Tüm projeleri gör
2 Arduino Tek Yönlü Haberleşme
AR-57Orta
Premium

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.

4.4(37)
50
2 Arduino Çift Yönlü Haberleşme
AR-58Orta
Premium

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.

4.5(20)
26
I2C İle LCD Ekran Kullanımı
AR-32Başlangıç
Premium

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…

4.8(53)
70
Arduino I2C Hesap Makinesi
AR-94Orta
Premium

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.

5.0(31)
43
ESP32 I2C LCD Ekran (16x2)
ES-17Orta
Premium

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

4.9(23)
40
ESP32 RTC DS1307 ile Dijital Saat (I2C + LCD)
ES-18Orta
Premium

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.

4.6(26)
40
Raket Topu Oyunu - SSD1306
AR-86Orta
Premium

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.

4.5(47)
65
Dot Matrix Saat ve Takvim (MAX7219, DS1307)
AR-84Orta
Premium

Dot Matrix Saat ve Takvim (MAX7219, DS1307)

Masada ya da duvarda duran, saati ve tarihi kayan yazıyla gösteren ışıklı bir pano.

5.0(37)
59