Inleiding
I2C communications zijn de de facto methode geworden om te communiceren tussen microcontrollers, microcomputers en een verscheidenheid aan geïntegreerde schakelingen en sensoren. Het bestaat al sinds 1982 en werd oorspronkelijk ontwikkeld voor gebruik in televisieontvangers.
hoewel we veel I2C-sensoren en-displays hebben gebruikt in eerdere artikelen, hebben we niet echt gekeken naar hoe I2C werkt en hoe het kan worden gebruikt om te communiceren tussen microcontrollers.
vandaag zullen we dat corrigeren en meer leren over I2C. we zullen ook zien hoe het kan worden gebruikt om informatie uit te wisselen tussen twee Arduino ‘ s en hoe het kan worden gebruikt om een Arduino een andere te laten besturen.
Dit zal de eerste van vier artikelen over I2C zijn. in toekomstige artikelen zullen we zien hoe we onze eigen I2C-apparaten kunnen bouwen, hoe we een Raspberry Pi en een Arduino kunnen koppelen met I2C en hoe we enkele geavanceerde I2C-configuraties kunnen uitvoeren, waaronder het gebruik van meerdere masters op één I2C-bus.
laten we beginnen!
I2C-communicatie
I2C is een serieel protocol dat wordt gebruikt op een 2-draads interface met lage snelheid. Het werd oorspronkelijk ontwikkeld door Phillips in 1982 om geïntegreerde schakelingen in televisieontvangers in staat te stellen met elkaar te communiceren.
tijden zijn veranderd, Phillips is nu NXP en I2C is uitgegroeid tot een communicatiestandaard die wordt ondersteund door vrijwel elke belangrijke halfgeleiderfabrikant.
I2C is een afkorting voor “Inter-Integrated Circuit”. Het wordt ook wel “IIC” of”I kwadraat C” genoemd.
gebruik en beperkingen
I2C wordt gebruikt met microcontrollers zoals de Arduino en met microcomputers zoals de Raspberry Pi. Veel displays en sensoren communiceren met hun Host controller met behulp van I2C.
I2C heeft echter een aantal beperkingen. Het is niet bijzonder snel, hoewel voor de meeste van de beoogde toepassingen is het genoeg snel genoeg.
I2C kan alleen over korte afstanden worden gebruikt, want het was oorspronkelijk bedoeld om te communiceren tussen geïntegreerde schakelingen op dezelfde printplaat. De maximale afstand van betrouwbare transmissie neemt af naarmate de snelheid toeneemt, bij de langzaamste snelheid (100 Kbaud of een kloksnelheid van 100 KHz) is de maximale afstand ongeveer een meter.
I2C-snelheden
de oorspronkelijke I2C-bus had een maximumsnelheid van 100 KHz. De meest voorkomende toepassingen gebruiken deze snelheid nog steeds, omdat het voldoende is voor het overbrengen van gegevens van sensoren en eenvoudige displays.
I2C en heeft een aantal hogere snelheidsmodi. Niet alle I2C-apparaten ondersteunen deze modi:
- snelle modus – dit heeft een maximale kloksnelheid van 400 KHz.
- Hi-Speed Mode – a maximum clock frequency fo 3,4 MHz
- Ultra Fast Mode – Maximum clock frequency of 5 MHz
op een I2C-bus bepaalt de master de kloksnelheid.
hoe I2C werkt
een I2C-bus heeft twee signalen, samen met een stroom-en grondverbinding.
de twee signaallijnen zijn als volgt:
- SDA – dit is de bidirectionele datalijn.
- SCL – Dit is het kloksignaal.
Er zijn twee pull-up weerstanden aangesloten op elke signaallijn, ze trekken de bus tot de voedingsspanning wanneer deze inactief is.
merk op dat de voedingsspanning niet standaard is, deze kan 3,3 of 5 volt zijn. Het kan ook een lagere spanning zijn voor sommige high-speed I2C-implementaties.
Dit verschil in voedingsspanningen kan problemen veroorzaken wanneer u I2C-apparaten interfaceert die verschillende logische niveaus gebruiken. We zullen dit meer bespreken in een toekomstig artikel Wanneer Ik u laten zien hoe u een Raspberry Pi interface (3.3-volt logica) met een Arduino Uno (5-volt logica).
er zijn twee soorten apparaten die kunnen worden gekoppeld aan de I2C bus – Masters en Slaves.
het hoofdapparaat bestuurt de bus en levert het kloksignaal. Het vraagt gegevens van de slaven afzonderlijk. Er kan meer dan één master-apparaat in de bus zitten, maar slechts één kan op een bepaald moment de actieve master zijn.
De master apparaten hebben geen adres toegewezen.
Slave apparaten hebben een adres, en dit adres moet uniek zijn op de bus. Ze gebruiken een 7-bit adresseringsschema, zodat tot 128 slaves op één I2C bus kunnen zitten. In het echte leven wordt deze grote verzameling apparaten nooit gebruikt, het is zeldzaam om meer dan een dozijn I2C-apparaten op één bus te zien.
een nieuwer 10-bits adresseringsschema is geïmplementeerd, het is achterwaarts compatibel met de bestaande 7-bits adresseringsmethode.
commerciële I2C-apparaten krijgen een I2C-adres toegewezen door NXP, die de busspecificaties onderhouden. Hoewel I2C is open source sinds 2006 is er een vergoeding in rekening gebracht voor het verkrijgen van een slave adres van NXP. Er is geen vergoeding vereist voor master-apparaten, of voor apparaten die niet bedoeld zijn voor commerciële productie.
aan sommige I2C-apparaten worden meerdere adressen toegewezen, meestal varianties in de onderste adresbits. Deze apparaten kunnen handmatig worden geconfigureerd voor verschillende adressen, waardoor meerdere apparaten van hetzelfde type kunnen worden gebruikt op een enkele I2C-bus.
andere I2C-derivaten
Er zijn andere bussen die zijn afgeleid van de I2C-bus, en die in veel opzichten compatibel zijn met I2C.
- TWI – de Twin Wire Interface is vrijwel identiek aan de I2C bus. Dit is eigenlijk de bus die de Arduino gebruikt, TWI werd ontwikkeld toen de I2C bus was niet open source en Atmel wilde niet het risico van een handelsnaam schending. Het enige grote verschil tussen TWI en I2C is dat TWI geen ondersteuning biedt voor een geavanceerde techniek genaamd “klok stretching”.
- SMBus is een andere I2C gelijkwaardige bus, ontwikkeld door Intel. Net als TWI ondersteunt het de meeste I2C-functies.
In een toekomstig artikel zal ik uitleggen hoe de gegevens op de I2C-bus gestructureerd zijn. Maar nu hebben we wat basis I2C informatie, genoeg om te gaan experimenteren.
Arduino Wire Library
de Arduino heeft een ingebouwde bibliotheek voor het werken met I2C genaamd de Wire Library. Het maakt het zeer gemakkelijk om op de I2C-bus te communiceren, en het kan de Arduino configureren om of een meester of een slaaf te worden.
De Wire-bibliotheek heeft verschillende nuttige functies voor het werken met I2C.
- begin() – dit initieert de bibliotheek en stelt de Arduino in om master of slave te zijn.
- requestFrom() – deze functie wordt gebruikt door de master om gegevens van een slave aan te vragen.
- beginTransmission() – deze functie wordt gebruikt door de master om gegevens naar een opgegeven slave te verzenden.
- endTransmission() – deze functie wordt door de master gebruikt om een transmissie te beëindigen die met de starttransmission-functie is gestart.
- write() – gebruikt door zowel master als slave om gegevens op de I2C bus te verzenden.
- available() – gebruikt door zowel master als slave om het aantal bytes te bepalen in de data die ze ontvangen.
- read () – leest een byte data van de I2C bus.
- SetClock() – gebruikt door de master om een specifieke klokfrequentie in te stellen.
- onReceive() – gebruikt door de slave om een functie te specificeren die wordt aangeroepen wanneer gegevens van de master worden ontvangen.
- onRequest() – gebruikt door de slave om een functie te specificeren die wordt aangeroepen wanneer de master gegevens heeft opgevraagd.
We zullen enkele van deze functies gebruiken in onze schetsen.
Arduino I2C-verbindingen
de SDA-en SCL-verbindingen voor I2C verschillen tussen Arduino-modellen. De experimenten die ik je ga laten zien zijn gedaan met behulp van twee Arduino Unos, maar je kunt andere modellen van de Arduino gebruiken mits je de pinnen dienovereenkomstig verandert.
Ik heb een grafiek samengesteld om je te helpen het uit te zoeken. Het bevat een aantal gemeenschappelijke Arduino boards, evenals een paar van de discrete chips. De pinouts voor de chips i lijst (ATTiny en ATmega328P) zijn met de DIP pakket, niet de surface-mount degenen.
| Arduino Board or Chip | SDA | SCL |
| Uno | A4 | A5 |
| Mega2560 | 20 | 21 |
| Nano | A4 | A5 |
| Pro Mini | A4 | A5 |
| Leonardo | 2 | 3 |
| Due (has two I2C) | 20 + SDA1 | 20 + SCL1 |
| ATTiny85 & ATTiny45 | 5 | 7 |
| ATmega328P | 27 | 28 |
sommige Arduino Uno klonen hebben aparte SDA en SCL pinnen en je kunt ze gebruiken in plaats van de twee analoge pinnen als je wilt. Ze zijn intern verbonden met dezelfde plaats.
merk op dat de Arduino Due eigenlijk twee I2C poorten heeft.
houd er ook rekening mee dat er een aantal onjuiste aansluitschema ‘ s op het internet zijn voor de Pro Mini. Gebruik de twee analoge pennen, A4 en A5, zoals weergegeven in de tabel hierboven.
I2C tussen 2 Arduino ‘s
voor ons eerste experiment zullen we twee Arduino’ s samen Hoogen en gegevens tussen hen uitwisselen. De ene Arduino zal de meester zijn, de andere de slaaf.
Ik gebruik twee Arduino Uno ‘s, maar je kunt andere Arduino’ s vervangen als je geen twee Uno ‘ s hebt. Gebruik de vorige grafiek voor de verbindingen.
aansluiten van 2 Arduino ‘s
zo heb ik mijn twee Arduino Uno’ s met elkaar verbonden:
Het is een vrij eenvoudige aansluiting, in wezen bind je gewoon de grond en de twee I2C pinnen aan elkaar.
een ding om je bewust van te zijn is dat mijn diagram niet het gebruik van pull-up weerstanden laat zien, Ik vond dat alles leek te werken correct zonder hen. Echter, je zou willen om ze op te nemen, vooral als u fouten of intermitterende werking ervaren.
om een aantal pull-up weerstanden aan te sluiten attacheer je een paar 10K weerstanden op de SDA en SCL lijnen. Bevestig het andere uiteinde aan de 5-volt uitgang van een van de Arduino ‘ s.
Master Demo Sketch
Hier is de sketch die zal worden gebruikt op de Arduino die u hebt aangewezen als master.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
/*
I2C Master Demo
i2c-master-demo.ino
Demonstrate use of I2C bus
Master sends character and gets reply from Slave
DroneBot Workshop 2019
https://dronebotworkshop.com
*/
// Include Arduino Wire library for I2C
#include <Wire.h>
// Define Slave I2C Address
#define SLAVE_ADDR 9
// Define Slave answer size
#define ANSWERSIZE 5
void setup() {
// Initialize I2C communications as Master
Wire.begin();
/ / seriële monitor instellen
serieel.begin (9600);
serieel.println (“I2C Master Demonstration”);
}
void loop () {
delay(50);
Serial.println (“Write data to slave”);
// Schrijf een charatre naar de Slave
draad.beginTransmission (SLAVE_ADDR);
draad.write (0);
draad.endTransmission ();
Serial.println (“Receive data”);
// Read response from Slave
// read back 5 characters
Wire.requestFrom (SLAVE_ADDR, ANSWERSIZE);
/ / karakters toevoegen aan string
String response=””;
while (Wire.available ()) {
char b = Wire.read ();
response + = b;
}
/ /Print naar seriële Monitor
serieel.println (response);
|
zoals bij alle I2C-schetsen, beginnen we met het opnemen van de Wire-bibliotheek.
vervolgens definiëren we een paar constanten om het I2C adres van de slave weer te geven en het aantal bytes aan data dat we ervan verwachten terug te halen.
in de Setup initialiseren we de I2C communicatie als een master. We weten dat het een meester is omdat er geen adresparameter is in de begin-functie. We zetten ook een seriële monitor in en printen er een regel tekst naar af.
nu naar de lus.
we beginnen met een kleine tijdsvertraging, meestal om de dingen genoeg te vertragen zodat we het scherm op de seriële monitor kunnen lezen.
vervolgens gebruiken we de starttransmission functie om data naar de slave te sturen. In dit geval zijn de gegevens die we verzenden slechts een getal nul. We eindigen met een oproep naar de endTransmission functie.
vervolgens vragen we wat gegevens terug van de slave met behulp van de requestFrom functie.
daarna formuleren we een reactiestring door de data, een byte per keer, van de slave te lezen.
we printen de details van wat we doen en van de gegevens die we ontvangen naar de seriële monitor. Dan maken we de lus af en doen we het opnieuw.
Slave Demo Sketch
nu op de sketch die door de slave wordt gebruikt.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
/*
I2C Slave Demo
i2c-slave-demo.ino
Demonstrate use of I2C bus
Slave receives character from Master and responds
DroneBot Workshop 2019
https://dronebotworkshop.com
*/
// Include Arduino Wire library for I2C
#include <Wire.h>
// define Slave I2C Address
#define SLAVE_ADDR 9
// Define Slave answer size
#define ANSWERSIZE 5
// Define string with response to Master
String answer = “Hello”;
Void setup() {
// initialiseer I2C communicatie als slave
draad.begin (SLAVE_ADDR);
// functie om uit te voeren wanneer gegevens gevraagd worden van master
Wire.onRequest (requestEvent);
// functie om uit te voeren wanneer gegevens ontvangen van master
Wire.oneceive (receivevent);
/ / seriële Monitor instellen
serieel.begin (9600);
serieel.println (“I2C Slave Demonstration”);
}
void receivevent () {
// lezen terwijl data ontvangen
terwijl (0 < Wire.available ()) {
byte x = Wire.read();
}
// Print naar seriële Monitor
serieel.println (“Receive event”);
}
void requestEvent () {
/ / Setup byte variabele in de juiste grootte
byte response;
/ / formatteer het antwoord als array
voor (byte i=0;i<ANSWERSIZE;i++) {
response = (byte)antwoord.charAt (i);
}
// stuur antwoord terug naar de Master
draad.write (response, sizeof (response));
// Print naar seriële Monitor
serieel.println(“Request event”);
void loop () {
/ / time delay in loop
delay(50);
}
|
eenmaal opnieuw beginnen we met het opnemen van de Wire library. Net als bij de vorige schets definiëren we ook het I2C adres voor de slave, evenals het aantal bytes dat we van plan zijn terug te sturen naar de master.
vervolgens definiëren we de string die we terug gaan sturen naar de master, in dit geval alleen het woord “Hallo”. Als u besluit om dit te veranderen zorg ervoor dat u de ANSWERSIZE constante in beide schetsen correct aan te passen.
in de Setup initialiseren we de verbinding met de I2C bus met een begin functie. Let op de andere manier waarop we dit doen, omdat dit een slave is specificeren we het I2C adres dat we gaan gebruiken. Door dit te doen weet de Wire library dat we in slave modus willen werken.
nu moeten we de namen definiëren van de functies die we zullen aanroepen wanneer er twee gebeurtenissen plaatsvinden – een data request ontvangen van de master en data ontvangen van de master. We installeren en printen ook naar de seriële monitor.
de functie receivevent wordt aangeroepen wanneer we gegevens van de master ontvangen. In deze functie lezen wij gegevens terwijl de gegevens beschikbaar zijn en wijzen het aan een byte toe (herinner, zullen de gegevens één byte per keer worden ontvangen).
de requestEvent functie wordt aangeroepen wanneer we een verzoek voor gegevens van de master krijgen. We moeten onze tekenreeks “Hallo” terugsturen naar de meester. Aangezien wij de gegevens één byte per keer moeten verzenden verdelen wij de karakters in “Hallo” in individuele punten in een reeks en verzenden hen dan één-voor-één.
we rapporteren al onze voortgang in beide functies aan de seriële monitor.
de lus in deze schets voegt gewoon een vertraging toe, die overeenkomt met de vertraging die in de hoofdschets wordt gebruikt.
de Demoschetsen uitvoeren
om deze schetsen uit te voeren moet u de seriële monitor op elke Arduino kunnen bekijken. Als u twee computers met de Arduino IDE geïnstalleerd dan dat zal het een stuk gemakkelijker maken.
Op Microsoft Windows is het mogelijk om twee exemplaren van de Arduino IDE te openen. Als dat gebeurt, kunt u beide seriële monitoren naast elkaar op hetzelfde scherm weergeven.
afwisselend kunt u een computer gebruiken en de tweede Arduino met een eigen voeding aanzetten. Je zou de computer en de voeding tussen de twee Arduino ‘ s moeten wisselen. door dit te doen zou je beide schermen één voor één kunnen monitoren.
Arduino Remote met behulp van I2C
In de volgende demonstratie zullen we een potentiometer aan de master Arduino en een LED aan de slave haken. We zullen de potentiometer gebruiken om de knippersnelheid van de LED te regelen.
Dit is een andere eenvoudige demonstratie, je kunt er op voortbouwen om iets praktischer te maken.
Remote Demo aansluiting
Hier is hoe dit experiment wordt samengesteld.
Het is in wezen dezelfde aansluiting als het vorige experiment, met de toevoeging van de potentiometer op de master en de LED op de slave.
merk op dat de LED op de slave is aangesloten op pin 13. Aangezien Arduino Uno een ingebouwde leiden op speld 13 heeft kunt u leiden en zijn dalende weerstand elimineren als u wenst.
de opmerkingen over pull-up weerstanden zijn ook van toepassing op deze aansluiting.
Remote Demo Master Sketch
de sketch voor de masterzijde van dit experiment is zeer eenvoudig, in sommige opzichten is de I2C-zijde nog eenvoudiger dan die welke in de eerste demonstratie werd gebruikt. Dit komt omdat we alleen gegevens naar de slave sturen en niet verwachten dat we ze terug krijgen.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
/*
I2C Master Control Demo
i2c-master-demo-control.ino
Demonstrate use of I2C bus
Master sends potentimeter position data
DroneBot Workshop 2019
https://dronebotworkshop.com
*/
// Include Arduino Wire library for I2C
#include <Wire.h>
// Define Slave I2C Address
#define SLAVE_ADDR 9
// Analog pin for potentiometer
int analogPin = 0;
// Integer to hold potentiometer value
int val = 0;
void setup () {
/ / Initialiseer I2C-communicatie als Master
Wire.begin ();
}
void loop () {
vertraging(50);
/ / Leespotwaarde
/ / kaart naar bereik van 1-255 voor flitssnelheid
val = kaart(analogRead (analogin)), 0, 1023, 255, 1);
/ / Schrijf een charatre naar de Slave
draad.beginTransmission (SLAVE_ADDR);
draad.write (val);
draad.eindtransmissie ();
}
|
Zoals altijd moeten we de Wire-bibliotheek aan het begin van de schets toevoegen. We zullen ook een constante definiëren om het slavenadres vast te houden.
omdat we een potentiometer gebruiken, moeten we zowel de pin waarmee het verbonden is als een variabele definiëren om zijn waarde vast te houden.
alles wat we doen in de Setup is het initialiseren van de I2C verbinding als een master.
In de lus lezen we de potentiometerwaarde en zetten deze in op een bereik van 01-255. We moeten dat doen omdat we één byte aan informatie verzenden en slechts zoveel waarden in één byte kunnen houden.
merk op dat we de nummering in de Arduino kaart functie omkeren, dit wordt gedaan zodat het systeem zich gedraagt zoals we verwachten – het draaien van de potentiometer naar rechts verhoogt de flitssnelheid. Aangezien de “flitssnelheid” door een vertraging wordt gespecificeerd, zal een groter aantal dat wordt verzonden gelijk zijn aan een langere flitssnelheid.
merk ook op dat we de waarde 0 niet sturen, die de LED in één staat zou houden. We zetten ons bereik in plaats daarvan op 1.
nu is het gewoon een kwestie van het verzenden van de byte naar de slave en het herhalen van de lus opnieuw.
Remote Demo Receive Sketch
De slave zijde moet data ontvangen van de master en deze gebruiken om de LED te knipperen.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
/*
I2C Slave Control Demo
i2c-slave-demo-control.ino
Demonstrate use of I2C bus
Receives potentimeter position data
Controls LED blink rate
DroneBot Workshop 2019
https://dronebotworkshop.com
*/
// Include Arduino Wire library for I2C
#include <Wire.h>
// Define Slave I2C Address
#define SLAVE_ADDR 9
// Define LED Pin
int LED = 13;
// Variable for received data
int rd;
// Variable for blink rate
int br;
void setup () {
pinMode (LED, OUTPUT);
/ / Initialiseer I2C-communicatie Als Slave
draad.begin (SLAVE_ADDR);
// functie om uit te voeren wanneer gegevens ontvangen van master
Wire.onceive (receivevent);
// Setup Serial Monitor
Serial.begin (9600);
serieel.println (“I2C Slave Demonstration”);
}
void receivevent () {
// lees één teken uit de I2C
rd = Wire.read ();
// Afdrukwaarde van inkomende gegevens
serieel.println (rd);
}
void loop() {
vertraging(50);
// Bereken knipperen waarde
br = map(rd, 1, 255, 100, 2000);
digitalWrite(LED, HIGH);
delay(br);
digitalWrite(LED, LAAG);
delay(br);
}
|
We beginnen met de gebruikelijke opnemen van de Draad van de bibliotheek, alsmede het bepalen van de slave-adres. We definiëren ook een pin voor de LED.
Er worden een aantal extra variabelen gedefinieerd, waarbij de ene de ontvangen gegevens bevat, terwijl de andere de tijdvertragingswaarde voor de knippersnelheid heeft.
in de Setup zetten we de I/O pin voor de LED als uitgang en initialiseren we de I2C bus. Als we het slave-adres gebruiken in de begin-functie, Weet De Wire-bibliotheek dat we als slaaf handelen.
we hoeven alleen een onReceive functie te definiëren, in tegenstelling tot de laatste demo verwachten we geen verzoeken van de master. We zetten ook op en printen naar de seriële monitor, we zullen de monitor gebruiken om de inkomende gegevens te bekijken.
de receivevent-functie leest de binnenkomende gegevens en wijst deze toe aan de I-variabele. Het drukt ook de waarde naar de seriële monitor.
ten slotte gebruiken we in de lus de binnenkomende gegevens om de LED te knipperen. Nogmaals gebruiken we de kaartfunctie om dit te bereiken, waarbij we de binnenkomende waarden van 1-255 naar een breder bereik veranderen. U kunt experimenteren met het wijzigen van dit bereik om de LED sneller of langzamer te laten knipperen als u dat wilt.
de laatste paar verklaringen zijn in wezen de Arduino Blink sketch in disguise! We zetten de LED aan en uit voor een periode die we in de laatste stap hebben bepaald.
en dan herhalen we de lus.
het uitvoeren van de Demo op afstand
Laad de code en voer beide Arduino ‘ s in. U kunt uw seriële monitor op de slave Arduino gebruiken om de inkomende gegevens te bekijken.
draaien van de potentiometer moet nu de knippersnelheid van de LED op de slave variëren.
conclusie
Dit is het einde van onze eerste gedetailleerde blik op I2C. In de volgende aflevering zullen we meer te weten komen over de structuur van de gegevens die worden uitgewisseld. We nemen ook een gewone sensor en maken er een I2C sensor van.
veel plezier met communiceren!
hulpbronnen
schetsen-alle I2C-schetsen die in dit artikel worden gebruikt.
I2C-informatie – Informatie over de I2C-protocol.
