Basis · 12 min leestijd

Wat is I2C? SDA, SCL, pull-upweerstanden en een Arduino-scanner

Wat is I2C en hoe werkt het? SDA en SCL, 7-bits adressen, de berekening van pull-upweerstanden, een I2C-scannersketch, adresconflicten en de pinnen van Uno, ESP32 en Pico.

I2C (Inter-Integrated Circuit) is een serieel communicatieprotocol waarmee een microcontroller met tientallen sensoren, displays en modules praat via slechts twee signaaldraden (SDA en SCL). Het wordt uitgesproken als "I-kwadraat-C" en in sommige datasheets heet het IIC of TWI (Two Wire Interface). De I2C-LCD, het OLED-display, de MPU6050-versnellingsmeter, de BMP280-druksensor en de DS1307-klokmodule die je in Arduino-projecten gebruikt, spreken allemaal dit protocol; je kunt ze allemaal parallel op dezelfde twee draden aansluiten en elk bereiken via zijn eigen adres.

In deze gids leer je hoe I2C elektrisch werkt, wat adressen betekenen, waarom pull-upweerstanden onmisbaar zijn en hoe je hun waarde berekent. Daarna zie je stap voor stap een pintabel voor de Arduino Uno, ESP32 en Raspberry Pi Pico, een I2C-scannersketch dat elk apparaat op de bus vindt, een voorbeeld van registers lezen zonder bibliotheek en oplossingen voor veelvoorkomende problemen zoals adresconflicten.

I2C-LCD-adaptermodule met een PCF8574-chip
I2C-LCD-adapter: de PCF8574-chip, aan de achterkant van de LCD gesoldeerd, brengt een LCD met 16 pinnen terug tot vier draden (GND, VCC, SDA, SCL) en antwoordt meestal op adres 0x27 of 0x3F.

Wat is I2C en hoe werkt het?

I2C is in 1982 ontwikkeld door Philips (nu NXP) zodat chips op dezelfde printplaat met weinig draden konden communiceren. Er zijn twee rollen op de bus: de controller (vroeger master genoemd), die elke overdracht start en de klok genereert, en de targets (vroeger slaves), die daarop reageren. In Arduino-projecten is de controller bijna altijd de Arduino, ESP32 of Pico, terwijl sensoren en displays targets zijn.

  • SDA (Serial Data): De lijn die data in beide richtingen vervoert. De controller stuurt adressen en commando's en de sensor stuurt zijn metingen terug over dezelfde lijn.
  • SCL (Serial Clock): De klokleiding. Bij elke klokpuls wordt één bit op SDA gelezen en de controller genereert de klok.
  • GND (gemeenschappelijke massa): De referentie voor de signalen. Ook modules met aparte voedingen moeten een gemeenschappelijke GND delen.

De lijnen zijn open-drain: geen enkel apparaat trekt een lijn ooit hoog, het kan hem alleen laag trekken. Wat een lijn op 1 houdt, zijn de pull-upweerstanden die SDA en SCL met de voedingsspanning verbinden. Daarom is er geen kortsluiting, ook niet als twee apparaten tegelijk proberen te praten; als één apparaat de lijn laag trekt, zien alle andere een 0. Een I2C-bericht verloopt zo:

  1. START: Terwijl SCL hoog is, trekt de controller SDA van 1 naar 0 en elk apparaat op de bus gaat luisteren.
  2. Adres en richtingsbit: Het 7-bits adres wordt verstuurd, gevolgd door een lees- (1) of schrijfbit (0).
  3. ACK: Het apparaat dat het adres heeft, trekt SDA laag tijdens de 9e klokpuls om te zeggen: "ik ben hier". Doet niemand dat, dan heet het een NACK.
  4. Databytes: Elke byte wordt als 8 bits verstuurd en de ontvanger antwoordt op elke byte met een ACK. Bij de meeste sensoren is de eerste byte het nummer van het register dat je leest of schrijft.
  5. STOP: Terwijl SCL hoog is, stijgt SDA van 0 naar 1 en is de bus weer vrij. Bij lezen wordt een herhaalde START gebruikt in plaats van een STOP, zodat de richting kan wisselen zonder de bus los te laten.

Door I2C te vergelijken met de twee andere veelgebruikte protocollen in de Arduino-wereld zie je wanneer je het moet kiezen:

KenmerkI2CSPIUART (Serial)
Signaaldraden2 (SDA, SCL)3 gedeeld (MOSI, MISO, SCK) + één CS per apparaat2 (TX, RX)
Aantal apparatenMeer dan 100 adressen op één busZoveel als er vrije CS-pinnen zijnMeestal 2 apparaten
Typische snelheid100 kHz, 400 kHz, 1 MHz10 MHz en hoger9600 – 115200 baud
ApparaatselectieVia adresVia CS-pinGeen, punt-tot-punt
Typisch gebruikSensoren, klokken, kleine displays, EEPROMSD-kaarten, TFT-displays, RFIDGPS, Bluetooth, verbinding met een computer

I2C-snelheden en technische grenzen

ModusMaximale snelheidMaximale stijgtijdWaar wordt het gebruikt?
Standaardmodus (Sm)100 kHz1000 nsStandaard, lange draden
Snelle modus (Fm)400 kHz300 nsOLED, MPU6050, BMP280
Snelle modus plus (Fm+)1 MHz120 nsPico en sommige nieuwere sensoren
Hogesnelheidsmodus (Hs)3,4 MHz80 ns (400 pF), speciale drivers nodigZeldzaam in hobbyprojecten

De Arduino Wire-bibliotheek begint standaard op 100 kHz; de meeste sensoren ondersteunen ook 400 kHz en daar schakel je naartoe met Wire.setClock(400000). Een hogere snelheid laat displays soepeler verversen, maar maakt de bus ook gevoeliger voor draadlengte en pull-upwaarde. Volgens de standaard mag de totale buscapaciteit (draden plus apparaatpinnen) niet hoger zijn dan 400 pF. Gewone jumperdraden en lintkabels voegen 50–100 pF per meter toe en elke apparaatpin tot 10 pF. Daarom is I2C bedoeld voor gebruik op één printplaat of met draden van enkele tientallen centimeters. Boven 1 meter moet je de snelheid verlagen, sterkere pull-ups gebruiken of busverlengers zoals de P82B715 toevoegen.

I2C-adressen: 7-bits, 8-bits en gereserveerde adressen

Elk apparaat op de bus heeft een 7-bits adres, wat in theorie 128 adressen geeft. Omdat de bereiken 0x00–0x07 en 0x78–0x7F voor speciale doeleinden zijn gereserveerd, zijn de bruikbare adressen de 112 adressen van 0x08 tot 0x77. Het adres wordt meestal door de chipfabrikant vastgelegd, maar op veel modules kun je de laatste bits wijzigen met soldeerjumpers of pinnen genaamd A0, A1, A2 of AD0.

Nu het verwarrende deel: sommige datasheets en de labels op de achterkant van modules geven het adres als 8 bits op, inclusief de richtingsbit. Op de achterkant van een OLED-board staat bijvoorbeeld "0x78", maar het adres in de code is 0x3C; staat er op een LCD-module 0x4E, dan is het adres in de code 0x27. De regel is simpel: deel de 8-bitswaarde door 2 (schuif hem één bit naar rechts) en je hebt het 7-bits adres. De bibliotheken voor Arduino, ESP32 en MicroPython verwachten allemaal 7-bits adressen.

ModuleChipStandaardadresKan het worden gewijzigd?
I2C-LCD-module (16x2, 20x4)PCF8574 / PCF8574A0x27 / 0x3FMet A0–A2-jumpers: 0x20–0x27 of 0x38–0x3F
0,96-inch OLEDSSD13060x3C0x3D via een weerstand op de achterkant
Versnellingsmeter en gyroscoopMPU60500x680x69 als AD0 = 1
RealtimeklokDS1307 / DS32310x68Nee
Druk en temperatuurBMP280 / BME2800x76 of 0x77Hangt af van de SDO-pin
LichtintensiteitBH17500x230x5C als ADDR = 1
16-bits ADCADS11150x480x48–0x4B via de ADDR-pin
16-kanaals servo- en PWM-driverPCA96850x40Tientallen adressen vanaf 0x40 via A0–A5-jumpers
EEPROM-geheugenAT24C32 / AT24C2560x500x50–0x57 via A0–A2
I2C-multiplexerTCA9548A0x700x70–0x77 via A0–A2
Als je een Tiny RTC-module (DS1307) scant, verschijnt naast 0x68 ook adres 0x50; dat is geen fout, het is de AT24C32-EEPROM op de module. Op ZS-042-modules met een DS3231 antwoordt datzelfde geheugen op 0x57.

Pull-upweerstanden: waarom je ze nodig hebt en hoe je de waarde kiest

Omdat apparaten op een I2C-bus de lijnen alleen laag kunnen trekken, zorgen de pull-upweerstanden voor het hoge niveau. Is de weerstand te groot, dan vertraagt de buscapaciteit de overgang van 0 naar 1, worden de flanken van het signaal afgerond en worden bits bij hoge snelheden verkeerd gelezen. Is hij te klein, dan stijgt de stroom die een apparaat moet afvoeren als het de lijn laag trekt; de standaard eist alleen dat een apparaat minstens 3 mA bij 0,4 V kan afvoeren, dus de pull-up moet de stroom daaronder houden.

Deze formules geven de twee grenzen: de minimale weerstand is R(min) = (VCC − 0,4 V) / 3 mA en de maximale is R(max) = t(rise) / (0,8473 × C(bus)). Bij 5 V is R(min) = 4,6 V / 0,003 A ≈ 1,53 kΩ en bij 3,3 V ≈ 0,97 kΩ. Op een korte bus met 100 pF capaciteit is R(max) ≈ 11,8 kΩ bij 100 kHz en ≈ 3,5 kΩ bij 400 kHz. Daarom zijn in de praktijk 4,7 kΩ voor 100 kHz en 2,2 kΩ voor 400 kHz en drukke bussen de meest gebruikte waarden. Met de tool Weerstandskleurcode lees je de kleurbanden van een weerstand af en met de tool RC-tijdconstante zie je de vertraging die weerstand en capaciteit veroorzaken.

SituatieAanbevolen pull-upOpmerking
Eén module, korte draden, 100 kHz4,7 kΩ – 10 kΩDe meeste modules hebben ze al
Meerdere modules, 400 kHz2,2 kΩ – 4,7 kΩDe weerstanden op de modules komen parallel te staan
Draden langer dan 50 cm2,2 kΩ en 100 kHzTwist SDA niet met SCL; twist elk met GND
3,3V-bus (ESP32, Pico)2,2 kΩ – 4,7 kΩSluit de weerstanden aan op 3,3 V, niet op 5 V
De meeste modules hebben al pull-upweerstanden van 4,7 kΩ of 10 kΩ en de weerstanden van modules op dezelfde bus komen parallel te staan. Hebben drie modules elk 4,7 kΩ, dan is het totaal ongeveer 1,57 kΩ; bij 5 V zit dat net onder de grens van 3 mA. Combineer je vier of vijf modules, dan moet je misschien bij een paar de pull-ups verwijderen of hun soldeerjumper doorknippen.

Op de Arduino Uno schakelt Wire.begin() ook de interne pull-upweerstanden van 20–50 kΩ van de ATmega328P in. Met één module en 10–20 cm draad werken ze vaak, maar ze zijn niet betrouwbaar; externe weerstanden zijn altijd beter. Gebruik je een kale sensorprint zonder pull-ups, vergeet dan niet een weerstand van 4,7 kΩ toe te voegen van zowel SDA als SCL naar VCC.

I2C-pinnen: Arduino Uno, Mega, ESP32, ESP8266 en Pico

BoardSDASCLOpmerking
Arduino Uno / NanoA4A5Op de Uno R3 zijn de SDA- en SCL-pinnen naast AREF dezelfde bus als A4/A5
Arduino Mega 25602021Op de Mega zijn A4 en A5 geen I2C
Arduino Leonardo / MicroD2D3Dit zijn digitale pinnen
ESP32 (DevKit)GPIO 21GPIO 22Andere pinnen kun je kiezen met Wire.begin(SDA, SCL); de tweede bus is Wire1
ESP8266 NodeMCUD2 (GPIO 4)D1 (GPIO 5)Software-I2C, pinnen kunnen worden gewijzigd
Raspberry Pi PicoGP4 (I2C0)GP5 (I2C0)I2C0 en I2C1 zijn beschikbaar op veel pinparen
De Arduino Uno werkt op 5 V, terwijl de ESP32, ESP8266 en Pico op 3,3 V werken. Als een module op een 3,3V-board met 5 V wordt gevoed en zijn pull-ups naar 5 V gaan, stijgen de SDA- en SCL-lijnen naar 5 V en kunnen pinnen die niet 5V-tolerant zijn beschadigd raken. Voed de module met 3,3 V of gebruik tussen de twee spanningen een bidirectionele niveauconverter op basis van BSS138-transistors.

Stap voor stap: adressen vinden met een I2C-scannersketch

Als je een nieuwe module hebt, is het eerste wat je doet de adressen van de apparaten op de bus achterhalen. Een I2C-scanner stuurt een leeg bericht naar elk adres van 0x08 tot 0x77 en toont de adressen die met een ACK antwoorden. Zo weet je zowel dat de module goed is aangesloten als welk adres je in je code moet zetten.

  1. Verbind de GND van de module met de GND van de Arduino en de VCC met 5V (met 3.3V voor modules die alleen 3,3 V ondersteunen).
  2. Verbind SDA met A4 en SCL met A5. Heb je meerdere modules, verbind dan al hun SDA- en SCL-pinnen op het breadboard.
  3. Upload de onderstaande sketch en open de Serial Monitor op 115200 baud.
  4. Noteer de getoonde adressen. Verschijnt er niets, controleer dan de bedrading, de gemeenschappelijke GND en de pull-upweerstanden.
  5. Haal de modules een voor een los en sluit ze weer aan om te bevestigen welk adres bij welk apparaat hoort; de scanner scant elke 5 seconden opnieuw.
C++ (Arduino IDE)
1#include <Wire.h>
2
3void printHex(byte addr) {
4  Serial.print(F("0x"));
5  if (addr < 16) Serial.print('0');    // tek haneliye sıfır ekle / pad single digit
6  Serial.print(addr, HEX);
7}
8
9void setup() {
10  Serial.begin(115200);
11  Wire.begin();                         // Uno: A4 = SDA, A5 = SCL
12#if defined(ARDUINO_ARCH_AVR)
13  Wire.setWireTimeout(3000, true);      // AVR (Uno, Nano, Mega): hat kilitlenirse 3 ms sonra kurtar / recover a stuck bus after 3 ms
14#endif
15  Serial.println(F("I2C tarayici / I2C scanner"));
16}
17
18void loop() {
19  byte found = 0;
20  for (byte addr = 0x08; addr <= 0x77; addr++) {   // geçerli 7 bit adresler / valid 7-bit addresses
21    Wire.beginTransmission(addr);
22    byte err = Wire.endTransmission();             // 0 = cihaz ACK verdi / device acknowledged
23    if (err == 0) {
24      Serial.print(F("Bulundu / found: "));
25      printHex(addr);
26      Serial.println();
27      found++;
28    } else if (err == 4 || err == 5) {
29      Serial.print(F("Hat hatasi / bus error at "));
30      printHex(addr);
31      Serial.println();
32    }
33  }
34  if (found == 0) {
35    Serial.println(F("Cihaz yok: kablolari ve pull-up'lari kontrol et / no devices: check wiring and pull-ups"));
36  } else {
37    Serial.print(found);
38    Serial.println(F(" cihaz bulundu / device(s) found"));
39  }
40  Serial.println();
41  delay(5000);                          // 5 sn sonra yeniden tara / rescan after 5 s
42}
Resultaat van endTransmission()BetekenisWat te doen
0Het apparaat bevestigde zijn adres (ACK)Gebruik dit adres in je code
1Data te lang voor de bufferZie je nooit in een scanner; schrijf op de Uno niet meer dan 32 bytes tegelijk
2NACK op adresGeen apparaat op dit adres, normaal tijdens het scannen
3NACK op dataHet apparaat weigerde het commando; controleer het registernummer
4Andere busfoutKortsluiting, ontbrekende pull-ups of ruis
5TimeoutDe bus zit vast; controleer de bedrading en de voeding

De regel setWireTimeout in de sketch is belangrijk: als SDA of SCL kortgesloten is, of een apparaat blijft hangen en de lijn laag houdt, kan de Wire-bibliotheek van de Uno met standaardinstellingen eeuwig wachten en je programma laten vastlopen. Met de timeout ingeschakeld geeft de bibliotheek het na 3 ms op, reset de I2C-hardware en meldt de scanner het probleem met een foutcode. De regel is omgeven door #if, zodat hij alleen op AVR-boards (Uno, Nano, Mega) wordt gecompileerd; de Wire-bibliotheken van ESP32 en ESP8266 hebben al hun eigen timeoutbeveiliging, dus dezelfde sketch compileert en draait ongewijzigd op alle drie de platforms.

I2C zonder bibliotheek: registers lezen en schrijven

Bibliotheken maken het leven makkelijker, maar onder de motorkap doen ze allemaal hetzelfde: ze sturen het registernummer naar het apparaat en lezen daarna bytes uit dat register of schrijven er bytes naar. Als je dit één keer zelf doet, kun je de datasheet van een nieuwe sensor lezen en hem ook zonder bibliotheek gebruiken. Het onderstaande voorbeeld haalt de MPU6050-sensor uit de slaapstand, leest zijn identiteitsregister (WHO_AM_I) en berekent daarna temperatuur en versnelling op de Z-as uit de ruwe waarden.

MPU-6050-module met versnellingsmeter en gyroscoop
MPU-6050-module: hij sluit via zijn pinnen VCC, GND, SCL en SDA aan op de I2C-bus en de AD0-pin kiest adres 0x68 of 0x69.
C++ (Arduino IDE)
1#include <Wire.h>
2
3const byte MPU_ADDR = 0x68;             // AD0 GND'de; AD0 = 3.3V ise 0x69 / AD0 low; 0x69 if AD0 high
4
5void writeReg(byte reg, byte value) {
6  Wire.beginTransmission(MPU_ADDR);
7  Wire.write(reg);                      // önce yazmaç adresi / register address first
8  Wire.write(value);                    // sonra veri / then the data
9  Wire.endTransmission();               // STOP gönder / send STOP
10}
11
12int16_t readWord(byte reg) {
13  Wire.beginTransmission(MPU_ADDR);
14  Wire.write(reg);
15  Wire.endTransmission(false);          // STOP yok, tekrarlı START / no STOP, repeated START
16  Wire.requestFrom(MPU_ADDR, (byte)2);  // 2 bayt iste / request 2 bytes
17  uint8_t hi = Wire.read();
18  uint8_t lo = Wire.read();
19  return (int16_t)(((uint16_t)hi << 8) | lo);
20}
21
22void setup() {
23  Serial.begin(115200);
24  Wire.begin();
25  Wire.setClock(400000);                // hızlı mod 400 kHz / fast mode 400 kHz
26  writeReg(0x6B, 0x00);                 // PWR_MGMT_1: uykudan uyandır / wake up from sleep
27  Wire.beginTransmission(MPU_ADDR);
28  Wire.write(0x75);                     // WHO_AM_I yazmacı / WHO_AM_I register
29  Wire.endTransmission(false);
30  Wire.requestFrom(MPU_ADDR, (byte)1);
31  Serial.print(F("WHO_AM_I = 0x"));
32  Serial.println(Wire.read(), HEX);     // 68 beklenir / expect 68
33}
34
35void loop() {
36  int16_t raw = readWord(0x41);         // TEMP_OUT_H ve TEMP_OUT_L / TEMP_OUT_H and TEMP_OUT_L
37  float tempC = raw / 340.0 + 36.53;    // veri sayfasındaki formül / datasheet formula
38  int16_t az = readWord(0x3F);          // Z ekseni ivmesi / Z-axis acceleration
39  Serial.print(F("Sicaklik / temp: "));
40  Serial.print(tempC, 1);
41  Serial.print(F(" C   AccZ: "));
42  Serial.println(az / 16384.0, 2);      // +-2g aralığında 16384 = 1 g / 16384 = 1 g at +-2g
43  delay(500);
44}

Let op de regel endTransmission(false) in de leesfunctie: die wisselt de richting met een herhaalde START in plaats van een STOP, zodat geen ander apparaat ertussen kan komen en de sensor niet vergeet welk register is gevraagd. Als WHO_AM_I 0x68 teruggeeft, is de communicatie perfect. Op goedkope kloonmodules kan de waarde 0x70 of een ander getal zijn; dat betekent dat de chip een compatibel maar ander model is, zoals de MPU6500, en dat is de reden dat sommige kant-en-klare bibliotheken "sensor not found" melden. De temperatuurformule (ruwe waarde / 340 + 36.53) komt rechtstreeks uit de MPU6050-datasheet; voor versnelling in het bereik ±2 g is een ruwe waarde van 16384 gelijk aan 1 g, dus een sensor die plat op tafel ligt toont ongeveer 1.00 op de Z-as.

Meerdere apparaten op één bus en adresconflicten

Het grootste voordeel van I2C is dat je apparaten parallel op dezelfde twee draden kunt aansluiten, zolang hun adressen verschillen. Een LCD (0x27), een OLED (0x3C), een BMP280 (0x76) en een DS3231-klok (0x68) kunnen bijvoorbeeld prima dezelfde pinnen A4 en A5 delen; elke bibliotheek praat met zijn eigen adres terwijl de andere apparaten rustig meeluisteren. Problemen beginnen als twee apparaten hetzelfde adres hebben: beide sturen een ACK, hun data botst en meestal werkt geen van beide. Zo los je het op:

  • Wijzig de adrespin: Verbind je de AD0-pin van de MPU6050 met 3,3 V, dan wordt zijn adres 0x69 en is het conflict met de DS3231 (0x68) weg.
  • Gebruik de soldeerjumpers: De A0–A2-jumpers op LCD-modules bieden 8 adressen en de ADDR-pin van de ADS1115 biedt er 4.
  • Open een tweede I2C-bus: Verplaats het conflicterende apparaat naar aparte pinnen met Wire1 op de ESP32 of I2C1 op de Pico.
  • Voeg een I2C-multiplexer toe: De TCA9548A opent acht aparte subbussen vanaf één adres (0x70); je kunt zelfs acht OLED's met hetzelfde adres aansluiten.
  • Apparaten met een vast adres: Sommige chips, zoals de DS1307 of HTU21D, hebben een adres dat helemaal niet te wijzigen is; voor die chips helpt alleen een aparte bus of een multiplexer.

I2C op de ESP32: willekeurige pinnen en twee aparte bussen

Op de ESP32 kan de I2C-hardware flexibel naar de pinnen worden gerouteerd. De standaardpinnen zijn GPIO 21 (SDA) en GPIO 22 (SCL), maar met Wire.begin(SDA, SCL) kies je bijna elke twee GPIO's die je wilt. De klassieke ESP32 en de ESP32-S3 hebben twee I2C-controllers, dus je kunt twee sensoren met hetzelfde adres op twee aparte bussen laten draaien; de ESP32-C3 heeft er maar één. GPIO 34–39 zijn alleen-invoer en kunnen niet voor I2C worden gebruikt. Voor de volledige pinindeling van het board kijk je in de tool Pinout en voor een algemene introductie zie je Wat is de ESP32?.

C++ (Arduino IDE)
1#include <Wire.h>
2
3// Klasik ESP32'de iki I2C denetleyicisi vardır: Wire ve Wire1 / the classic ESP32 has two I2C controllers: Wire and Wire1
4
5void scan(TwoWire &bus, const char *name) {
6  Serial.printf("%s:\n", name);
7  for (uint8_t addr = 0x08; addr <= 0x77; addr++) {
8    bus.beginTransmission(addr);
9    if (bus.endTransmission() == 0) {
10      Serial.printf("  bulundu / found 0x%02X\n", addr);
11    }
12  }
13}
14
15void setup() {
16  Serial.begin(115200);
17  Wire.begin(21, 22);                   // SDA, SCL: varsayılan pinler / default pins
18  Wire1.begin(32, 33, 400000);          // SDA, SCL, hız: başka iki GPIO / SDA, SCL, speed: any two other GPIOs
19  scan(Wire, "Wire  (SDA 21, SCL 22)");
20  scan(Wire1, "Wire1 (SDA 32, SCL 33)");
21}
22
23void loop() {
24}

I2C op de Raspberry Pi Pico (MicroPython)

De RP2040-chip van de Pico heeft twee controllers genaamd I2C0 en I2C1 en elk daarvan kan naar meerdere pinparen worden gerouteerd. Voor I2C0 kun je GP0/GP1, GP4/GP5, GP8/GP9, GP12/GP13, GP16/GP17 en GP20/GP21 gebruiken; voor I2C1 GP2/GP3, GP6/GP7, GP10/GP11, GP14/GP15, GP18/GP19 en GP26/GP27. In elk paar is de even pin SDA en de oneven pin SCL. In MicroPython is de scanner één regel: i2c.scan() geeft een lijst met de adressen die met een ACK antwoorden. Omdat de Pico op 3,3 V draait, is het voeden van modules via de 3V3(OUT)-pin de veiligste optie; hoewel de RP2040 ook 1 MHz Fast mode plus ondersteunt, geeft 400 kHz op een breadboard minder verrassingen. Voor je eerste stappen met de Pico zie je Wat is de Raspberry Pi Pico?.

MicroPython
1from machine import Pin, I2C
2
3i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)   # I2C0: GP4 = SDA, GP5 = SCL
4devices = i2c.scan()                                 # ACK veren adresler / addresses that ACK
5
6if devices:
7    for addr in devices:
8        print("Bulundu / found:", hex(addr))
9else:
10    print("Cihaz yok / no devices")
11
12# MPU6050 varsa WHO_AM_I yazmacını oku / if an MPU6050 is present, read WHO_AM_I
13if 0x68 in devices:
14    i2c.writeto_mem(0x68, 0x6B, b"\x00")             # uykudan uyandır / wake up
15    who = i2c.readfrom_mem(0x68, 0x75, 1)[0]
16    print("WHO_AM_I:", hex(who))                     # 0x68 beklenir / expect 0x68

Projectideeën met I2C

  • Mini-weerstation: Meet druk en temperatuur met een BMP280 en toon ze op een OLED-display; beide modules delen dezelfde twee draden.
  • Digitale klok: Lees de tijd uit een DS3231-klokmodule en toon hem op een I2C-LCD-display.
  • Hellingmeter: Bereken de hoek met een MPU6050 en teken het resultaat op de OLED als een waterpas.
  • Wi-Fi-sensornode: Volg een sensor die is aangesloten op de pinnen D1 en D2 van een ESP8266 NodeMCU vanaf je telefoon.
  • Robotarm met 16 servo's: Bestuur 16 servo's met slechts twee pinnen via een PCA9685-driver.
  • Datalogger: Schrijf elke minuut een meting naar een AT24C256-EEPROM, zodat de data een stroomonderbreking overleeft.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
De scanner vindt geen apparatenSDA en SCL verwisseld, geen gemeenschappelijke GND of de module krijgt geen stroomControleer de bedrading; op de Uno is A4 = SDA en A5 = SCL
De scanner loopt vast of meldt bij elk adres foutenBus kortgesloten of pull-ups ontbrekenVoeg setWireTimeout toe; meet de voedingsspanning op de rustende SDA en SCL
De sketch compileert maar het display blijft leegVerkeerd adres in de code (0x27 in plaats van 0x3F)Gebruik het adres dat de scanner vond
Op de achterkant van het board staat 0x78 en de code werkt nietHet 8-bits adres is gebruiktDeel door 2: 0x78 → 0x3C
Twee sensoren werken niet samenAdresconflictWijzig de adrespin, gebruik een tweede bus of een TCA9548A
Willekeurige vastlopers, storingen als een motor draaitLange draden, ruis of een zwakke voedingKort de draden in, ga terug naar 100 kHz, voeg condensatoren van 100 nF toe aan de modules
Een pin van een ESP32 of Pico is beschadigdPull-ups naar 5 V aangesloten op een 3,3V-pinVoed de module met 3,3 V of gebruik een niveauconverter
Een multimeter is je beste vriend bij I2C-problemen: met de voeding aan en zonder communicatie moet je op zowel SDA als SCL de voedingsspanning (5 V of 3,3 V) meten. Zie je 0 V, dan heeft een apparaat de lijn kortgesloten of is het vastgelopen. Met het board zonder stroom kun je ook grofweg de totale pull-upwaarde op de bus vinden door de weerstand tussen SDA en VCC te meten.

I2C is de handigste manier om met slechts twee draden displays, klokken, sensoren en geheugen aan je project toe te voegen; als je adressen, pull-upweerstanden en de scannersketch begrijpt, los je de meeste problemen in een paar minuten op. In de BlueGrays-app vind je projecten die I2C gebruiken, zoals het I2C-LCD-display, het Pong-spel op een OLED-display, een digitale klok met een DS1307 en een ESP32-weerdisplay, elk met schakelschema's en code stap voor stap.

Veelgestelde vragen

Wat is het verschil tussen I2C en SPI?

I2C gebruikt adressering om meer dan honderd apparaten op dezelfde twee draden te zetten, maar is meestal beperkt tot 100–400 kHz. SPI heeft drie gedeelde draden nodig plus een aparte chip-select-pin (CS) voor elk apparaat; daarvoor haalt het 10 MHz en meer. I2C heeft de voorkeur voor sensoren en kleine displays, SPI voor SD-kaarten en kleuren-TFT-displays.

Hoeveel apparaten kun je op een I2C-bus aansluiten?

7-bits adressering geeft 112 bruikbare adressen. In de praktijk wordt de grens minder bepaald door het aantal adressen dan door de buscapaciteit (maximaal 400 pF) en de parallelle pull-upweerstanden; 5–10 apparaten werken prima op een breadboard. Gebruik voor meer een TCA9548A-multiplexer of een tweede I2C-bus.

Welke waarde moeten I2C-pull-upweerstanden hebben?

4,7 kΩ voor 100 kHz en korte draden en 2,2 kΩ voor 400 kHz of bussen met veel apparaten zijn de meest gebruikte waarden. Ga niet onder 1,5 kΩ op een 5V-bus of onder 1 kΩ op een 3,3V-bus. Denk er ook aan dat de weerstanden op je modules parallel komen te staan.

Welke pinnen zijn I2C op de Arduino Uno?

Op de Arduino Uno en Nano is SDA pin A4 en SCL pin A5. De Uno R3 heeft nog twee pinnen met het label SDA en SCL naast AREF, maar die zijn op het board verbonden met A4 en A5 en vormen dus geen aparte bus. Op de Mega zijn de I2C-pinnen 20 (SDA) en 21 (SCL).

Wat is de maximale lengte van een I2C-kabel?

I2C is ontworpen voor korte afstanden op een printplaat; bij 100 kHz en met geschikte pull-ups werkt het meestal tot ongeveer 1 meter. Voor langere afstanden moet je de snelheid verlagen, getwiste kabel gebruiken of overstappen op busdrivers zoals de P82B715. Voor meerdere meters is RS-485 of een draadloze verbinding de betere keuze.

Wat moet ik doen als de I2C-scanner mijn apparaat niet vindt?

Controleer eerst of SDA en SCL op de juiste pinnen zitten, of de gemeenschappelijke GND is aangesloten en of de module stroom krijgt. Controleer daarna de pull-ups door de voedingsspanning op de rustende SDA en SCL te meten. Wordt het nog steeds niet gevonden, probeer de module dan alleen met korte draden op 100 kHz, en zorg op de ESP32 dat je de juiste pinnen aan Wire.begin hebt doorgegeven.

Alle projecten bekijken
Een lcd-scherm gebruiken met I2C
AR-32Beginner
Premium

Een lcd-scherm gebruiken met I2C

Geef je Arduino een eigen scherm en laat hem zijn eerste bericht schrijven. Het lcd-scherm met twee regels sluit je aan met maar een paar draden; op de bovenste regel verschijnt een groet, daarna een…

4.8(53)
70
ESP32 I2C-LCD-display (16x2)
ES-17Gemiddeld
Premium

ESP32 I2C-LCD-display (16x2)

In dit project sluit je een 16x2-tekens-LCD via I2C aan op de ESP32 en toon je tekst. Met I2C bedien je het scherm met slechts 2 datapinnen (SDA en SCL), in plaats van de 6+ pinnen die een klassieke parallelle aansluiting verspilt. De code toont op de eerste regel een vaste tekst en op de tweede regel een teller die elke seconde oploopt. Bij het opstarten schrijft een I2C-scanner ook het adres van het display naar de Serial Monitor (meestal 0x27 of 0x3F).

4.9(23)
40
Digitale klok met ESP32 en DS1307-RTC (I2C + LCD)
ES-18Gemiddeld
Premium

Digitale klok met ESP32 en DS1307-RTC (I2C + LCD)

In dit project tonen we de tijd en de datum op een 16x2 I2C-LCD met de DS1307 realtimeklok-module (RTC). De DS1307 is een RTC met batterijback-up die de tijd bijhoudt, ook als de ESP32 uit staat. Beide modules delen dezelfde I2C-bus (SDA/SCL), zodat je leert hoe je met slechts twee signaaldraden meerdere apparaten bestuurt. Met dit project krijg je praktische kennis van het I2C-communicatieprotocol, de werking van RTC-modules en het dynamisch tonen van gegevens op een LCD.

4.6(26)
40
Arduino I2C-rekenmachine
AR-94Gemiddeld
Premium

Arduino I2C-rekenmachine

Een rekenmachineproject op basis van Arduino dat optellen, aftrekken, vermenigvuldigen en delen doet met een 4x4-membraantoetsenbord en een 16x2 I2C-LCD. Dankzij I2C sluit je het display aan met slechts 2 draden, zodat er minder kabelwirwar is en meer pins vrij blijven. Ook decimale getallen en negatieve getallen worden ondersteund.

5.0(31)
43
Paddleballspel - SSD1306
AR-86Gemiddeld
Premium

Paddleballspel - SSD1306

Een bal, twee batjes en jij: op een klein OLED-scherm speel je tafeltennis, een van de allereerste videogames.

4.5(47)
65
ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)
ES-32Gevorderd
Premium

ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)

In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Anders dan bij de I2C-LCD-versie gebruiken we hier een SSD1306 OLED-display (128×64), met grote tekst en vectoricoontjes voor een rijkere weergave. Zeven weericonen (zonnig, regenachtig, sneeuw en meer) worden direct getekend, zonder bitmapbestanden.

4.3(10)
22
Dotmatrix-klok en -kalender (MAX7219, DS1307)
AR-84Gemiddeld
Premium

Dotmatrix-klok en -kalender (MAX7219, DS1307)

Een oplichtend bord voor op je bureau of aan de muur dat de tijd en de datum toont in scrollende tekst.

5.0(37)
59
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

4.7(7)
12