Einführung
I2C kommunikation haben sich die de facto methode der kommunikation zwischen mikrocontroller, mikrocomputer und eine vielzahl von integrierten schaltungen und sensoren. Es gibt es seit 1982 und wurde ursprünglich für den Einsatz in Fernsehempfängern entwickelt.
Obwohl wir in früheren Artikeln viele I2C-Sensoren und -Displays verwendet haben, haben wir nicht untersucht, wie I2C funktioniert und wie es zur Kommunikation zwischen Mikrocontrollern verwendet werden kann.
Heute werden wir das korrigieren und mehr über I2C lernen. Wir werden auch sehen, wie es verwendet werden kann, um Informationen zwischen zwei Arduinos auszutauschen und wie es verwendet werden kann, um einem Arduino zu erlauben, einen anderen zu steuern.
Dies wird der erste von vier Artikeln über I2C sein. In zukünftigen Artikeln werden wir sehen, wie wir unsere eigenen I2C-Geräte bauen können, wie man einen Raspberry Pi und einen Arduino mit I2C verbindet und wie man einige fortgeschrittene I2C-Konfigurationen durchführt, einschließlich der Verwendung mehrerer Master auf einem I2C-Bus.
Los geht’s!
I2C-Kommunikation
I2C ist ein serielles Protokoll, das auf einer langsamen 2-Draht-Schnittstelle verwendet wird. Es wurde ursprünglich 1982 von Phillips entwickelt, um integrierte Schaltungen in Fernsehempfängern miteinander kommunizieren zu lassen.Die Zeiten haben sich geändert, Phillips ist jetzt NXP und I2C ist zu einem Kommunikationsstandard geworden, der von praktisch jedem großen Halbleiterhersteller unterstützt wird.
I2C ist eine Abkürzung für „Inter-Integrated Circuit“. Es wird auch „IIC“ oder „I squared C“ genannt.
Verwendung und Einschränkungen
I2C wird mit Mikrocontrollern wie dem Arduino und mit Mikrocomputern wie dem Raspberry Pi verwendet. Viele Displays und Sensoren verbinden sich über I2C mit ihrem Host-Controller.
I2C hat jedoch einige Einschränkungen. Es ist nicht besonders schnell, obwohl es für die meisten Verwendungszwecke schnell genug ist.
I2C kann nur über kurze Distanzen verwendet werden, schließlich sollte es ursprünglich zwischen integrierten Schaltkreisen auf derselben Leiterplatte kommunizieren. Die maximale Entfernung einer zuverlässigen Übertragung nimmt mit zunehmender Geschwindigkeit ab, bei der langsamsten Geschwindigkeit (100 Kbaud oder eine Taktrate von 100 kHz) beträgt die maximale Entfernung etwa einen Meter.
I2C-Geschwindigkeiten
Der ursprüngliche I2C-Bus hatte eine maximale Geschwindigkeit von 100 kHz. Die meisten gängigen Anwendungen verwenden diese Geschwindigkeit immer noch, da sie für die Übertragung von Daten von Sensoren und zu einfachen Displays völlig ausreicht.
I2C und hat einige höhere geschwindigkeit modi. Nicht alle I2C-Geräte unterstützen diese Modi:
- Fast Mode – Dies hat eine maximale Taktrate von 400 kHz.
- Hi-Speed–Modus – Eine maximale Taktfrequenz von 3,4 MHz
- Ultra Fast-Modus – Maximale Taktfrequenz von 5 MHz
Auf einem I2C-Bus bestimmt der Master die Taktfrequenz.
Funktionsweise von I2C
Ein I2C-Bus verfügt über zwei Signale sowie eine Strom- und eine Masseverbindung.
Die zwei signal linien sind wie folgt:
- SDA–Dies ist die bidirektionale daten linie.
- SCL – Das ist das Taktsignal.
An jede Signalleitung sind zwei Pull-Up-Widerstände angeschlossen, die den Bus auf die Versorgungsspannung ziehen, wenn er inaktiv ist.
Beachten Sie, dass die Versorgungsspannung nicht Standard ist, sie kann entweder 3,3 oder 5 Volt betragen. Es kann auch eine niedrigere Spannung für einige Hochgeschwindigkeits-I2C-Implementierungen sein.
Dieser Unterschied in den Versorgungsspannungen kann Probleme verursachen, wenn Sie I2C-Geräte anschließen, die unterschiedliche Logikpegel verwenden. Wir werden dies in einem zukünftigen Artikel ausführlicher besprechen, wenn ich Ihnen zeige, wie Sie einen Raspberry Pi (3.3-Volt-Logik) mit einem Arduino Uno (5-Volt-Logik).
Es gibt zwei Arten von Geräten, die an den I2C–Bus angeschlossen werden können – Master und Slaves.
Das Master-Gerät steuert den Bus und liefert das Taktsignal. Es fordert Daten von den Slaves einzeln an. Es kann mehr als ein Master-Gerät auf dem Bus sein, aber nur einer kann der aktive Master zu einem bestimmten Zeitpunkt sein.
Den Master-Geräten ist keine Adresse zugewiesen.
Slave-Geräte haben eine Adresse, und diese Adresse muss auf dem Bus eindeutig sein. Sie verwenden ein 7-Bit-Adressierungsschema, sodass sich bis zu 128 Slaves auf einem I2C-Bus befinden können. Im wirklichen Leben wird diese große Sammlung von Geräten nie verwendet, es ist selten, über ein Dutzend I2C-Geräte auf einem Bus zu sehen.
Es wurde ein neueres 10-Bit-Adressierungsschema implementiert, das mit dem vorhandenen 7-Bit-Adressierungsverfahren abwärtskompatibel ist.
Kommerziellen I2C-Geräten wird die I2C-Adresse von NXP zugewiesen, die die Busspezifikationen verwaltet. Obwohl I2C seit 2006 Open Source ist, wird für den Erhalt einer Slave-Adresse von NXP eine Gebühr erhoben. Für Master-Geräte oder für Geräte, die nicht für die kommerzielle Herstellung bestimmt sind, wird keine Gebühr erhoben.
Einigen I2C-Geräten werden mehrere Adressen zugewiesen, normalerweise Abweichungen in den unteren Adressbits. Diese Geräte können manuell für verschiedene Adressen konfiguriert werden, sodass mehrere Geräte desselben Typs auf einem einzigen I2C-Bus verwendet werden können.
Andere I2C-Derivate
Es gibt andere Busse, die vom I2C-Bus abgeleitet wurden und in vielerlei Hinsicht mit I2C kompatibel sind.
- TWI – Die Twin-Wire-Schnittstelle ist praktisch identisch mit dem I2C-Bus. TWI wurde entwickelt, als der I2C-Bus nicht Open Source war und Atmel keine Verletzung des Handelsnamens riskieren wollte. Der einzige große Unterschied zwischen TWI und I2C besteht darin, dass TWI keine fortgeschrittene Technik namens „Clock Stretching“ unterstützt.
- SMBus ist ein weiterer I2C-äquivalenter Bus, der von Intel entwickelt wurde. Wie TWI unterstützt es die meisten I2C-Funktionen.
In einem zukünftigen Artikel werde ich erklären, wie die Daten auf dem I2C-Bus strukturiert sind. Aber jetzt haben wir einige grundlegende I2C-Informationen, genug, um mit dem Experimentieren zu beginnen.
Arduino Draht Bibliothek
Die Arduino hat eine gebaut-in bibliothek für arbeits mit I2C genannt die Draht Bibliothek. Es macht es sehr einfach, auf dem I2C-Bus zu kommunizieren, und es kann den Arduino so konfigurieren, dass er entweder ein Master oder ein Slave wird.
Die Wire-Bibliothek verfügt über mehrere nützliche Funktionen für die Arbeit mit I2C.
- begin() – Dies initiiert die Bibliothek und richtet den Arduino als Master oder Slave ein.
- requestFrom() – Diese Funktion wird vom Master verwendet, um Daten von einem Slave anzufordern.
- beginTransmission() – Diese Funktion wird vom Master verwendet, um Daten an einen bestimmten Slave zu senden.
- endTransmission() – Diese Funktion wird vom Master verwendet, um eine mit der beginTransmission-Funktion gestartete Übertragung zu beenden.
- write() – Wird sowohl vom Master als auch vom Slave zum Senden von Daten auf dem I2C-Bus verwendet.
- available() – Wird sowohl vom Master als auch vom Slave verwendet, um die Anzahl der Bytes in den Daten zu bestimmen, die sie empfangen.
- read() – Liest ein Datenbyte vom I2C-Bus.
- SetClock() – Wird vom Master verwendet, um eine bestimmte Taktfrequenz einzustellen.
- onReceive() – Wird vom Slave verwendet, um eine Funktion anzugeben, die aufgerufen wird, wenn Daten vom Master empfangen werden.
- onRequest() – Wird vom Slave verwendet, um eine Funktion anzugeben, die aufgerufen wird, wenn der Master Daten angefordert hat.
Wir werden einige dieser Funktionen in unseren Skizzen verwenden.
Arduino I2C Verbindungen
Die SDA und SCL verbindungen für I2C sind verschiedene zwischen Arduino modelle. Die Experimente, die ich Ihnen zeigen werde, wurden mit zwei Arduino Unos durchgeführt, aber Sie können andere Modelle des Arduino verwenden, vorausgesetzt, Sie ändern die Pins entsprechend.
Ich habe ein Diagramm zusammengestellt, um Ihnen zu helfen, es herauszufinden. Es enthält einige gängige Arduino-Boards sowie einige der diskreten Chips. Die Pinbelegungen für die Chips, die ich Liste (ATtiny und ATmega328P) sind mit dem DIP-Paket, nicht die Oberflächenmontage diejenigen.
| 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 |
Einige Arduino Uno-Klone haben separate SDA- und SCL-Pins, die Sie auf Wunsch anstelle der beiden analogen Pins verwenden können. Sie sind intern mit demselben Ort verbunden.
Beachten Sie, dass der Arduino Due tatsächlich zwei I2C-Ports hat.
Beachten Sie auch, dass es im Internet einige falsche Anschlussdiagramme für den Pro Mini gibt. Verwenden Sie die beiden analogen Pins A4 und A5, wie in der obigen Tabelle gezeigt.
I2C Zwischen 2 Arduino
Für unser erstes Experiment werden wir zwei Arduinos zusammenbringen und Daten zwischen ihnen austauschen. Ein Arduino wird der Master sein, der andere der Slave.
Ich verwende zwei Arduino Unos, aber Sie können andere Arduino ersetzen, wenn Sie nicht zwei Unos haben. Verwenden Sie das vorherige Diagramm für die Verbindungen.
Anschließen von 2 Arduino
So habe ich meine beiden Arduino Unos miteinander verbunden:
Es ist eine ziemlich einfache Verbindung, im Wesentlichen binden Sie einfach den Boden und die beiden I2C-Pins zusammen.
Eine Sache, die Sie beachten sollten, ist, dass mein Diagramm die Verwendung von Pull-up-Widerständen nicht zeigt. Möglicherweise möchten Sie sie jedoch einschließen, insbesondere wenn Fehler auftreten oder der Betrieb unterbrochen wird.
Um einige Pull-Up-Widerstände anzuschließen, befestigen Sie ein paar 10k-Widerstände an den SDA- und SCL-Leitungen. Schließen Sie das andere Ende an den 5-Volt-Ausgang eines der Arduino an.
Master Demo Sketch
Hier ist die Skizze, die auf dem Arduino verwendet wird, den Sie als Master festgelegt haben.
|
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();
// Seriellen Monitor einrichten
Seriell.begin(9600);
Seriell.println(„I2C Master Demonstration“);
}
leere Schleife() {
Verzögerung(50);
Seriell.println(„Write data to slave“);
// Schreibe ein Zeichen an den Slave
Wire.beginTransmission(SLAVE_ADDR);
Draht.write(0);
Draht.endTransmission();
Seriell.println(„Daten empfangen“);
// Antwort vom Slave lesen
// 5 Zeichen zurücklesen
Draht.requestFrom(SLAVE_ADDR,ANSWERSIZE);
// Zeichen zum String hinzufügen
String response = „“;
while ().verfügbar()) {
Zeichen b = Draht.read();
response += b;
}
// Auf seriellen Monitor drucken
Seriell.println(response);
}
|
Wie bei allen I2C-Skizzen beginnen wir mit der Drahtbibliothek.
Als nächstes definieren wir einige Konstanten, um die I2C-Adresse des Slaves und die Anzahl der Datenbytes darzustellen, die wir von ihm abrufen möchten.
Im Setup initialisieren wir die I2C-Kommunikation als Master. Wir wissen, dass es sich um einen Master handelt, da die begin-Funktion keinen Adressparameter enthält. Wir richten auch einen seriellen Monitor ein und drucken eine Textzeile darauf.
Nun zur Schleife.
Wir beginnen mit einer winzigen Zeitverzögerung, meistens um die Dinge so weit zu verlangsamen, dass wir die Anzeige auf dem seriellen Monitor lesen können.
Als nächstes verwenden wir die beginTransmission-Funktion, um Daten an den Slave zu senden. In diesem Fall sind die Daten, die wir senden, nur eine Zahl Null. Wir beenden das Senden mit einem Aufruf des Endesübertragungsfunktion.
Als nächstes fordern wir einige Daten vom Slave mit der Funktion requestFrom an.
Danach formulieren wir eine Antwortzeichenfolge, indem wir die Daten byteweise vom Slave lesen.
Wir drucken die Details dessen, was wir tun, und die Daten, die wir erhalten, auf den seriellen Monitor. Und dann beenden wir die Schleife und machen alles noch einmal.
Slave Demo Sketch
Nun zu der vom Slave verwendeten Skizze.
|
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>
//Definieren Slave I2C Adresse
#definieren SLAVE_ADDR 9
//Definieren Slave antwort größe
#definieren ANSWERSIZE 5
// Definieren string mit antwort zu Master
String antwort = „Hallo“;
leere setup / Initialisieren I2C kommunikation als Slave
Draht.begin(SLAVE_ADDR);
// Funktion, die ausgeführt wird, wenn Daten vom Master angefordert werden
Draht.onRequest(requestEvent);
// Funktion, die ausgeführt wird, wenn Daten vom Master empfangen werden
Draht.onReceive(receiveEvent);
// Seriellen Monitor einrichten
Seriell.begin(9600);
Seriell.println(„I2C Slave Demonstration“);
}
leere receiveEvent() {
// Lesen während daten erhalten
während (0 <).verfügbar()) {
byte x = Draht.read();
}
// Auf seriellen Monitor drucken
Seriell.println(„Ereignis empfangen“);
}
void requestEvent() {
// Byte-Variable in der richtigen Größe einrichten
Byte-Antwort;
// Formatieren Sie die Antwort als Array
für (byte i=0;i<ANSWERSIZE;i++) {
response = (byte)answer .charAt(i);
}
// Sende die Antwort zurück an den Master
Draht.write(response,sizeof(response));
// Auf seriellen Monitor drucken
Seriell.println(„Request event“);
}
void loop() {
// Zeitverzögerung in der Schleife
Verzögerung(50);
}
|
Wieder einmal beginnen wir mit der Drahtbibliothek. Wie bei der vorherigen Skizze definieren wir auch die I2C-Adresse für den Slave sowie die Anzahl der Bytes, die wir an den Master zurücksenden möchten.
Als nächstes definieren wir die Zeichenfolge, die wir an den Master zurücksenden, in diesem Fall nur das Wort „Hallo“. Wenn Sie dies ändern möchten, stellen Sie sicher, dass Sie die Antwortgrößenkonstante in beiden Skizzen so anpassen, dass sie korrekt ist.
Im Setup initialisieren wir die Verbindung zum I2C-Bus mit einer begin-Funktion. Beachten Sie die unterschiedliche Art und Weise, wie wir dies tun, da dies ein Slave ist, geben wir die I2C-Adresse an, die wir verwenden werden. Auf diese Weise weiß die Drahtbibliothek, dass wir im Slave-Modus arbeiten möchten.
Jetzt müssen wir die Namen der Funktionen definieren, die wir aufrufen, wenn zwei Ereignisse auftreten – eine vom Master empfangene Datenanforderung und vom Master empfangene Daten. Wir richten auch den seriellen Monitor ein und drucken ihn aus.
Die Funktion receiveEvent wird aufgerufen, wenn wir Daten vom Master empfangen. In dieser Funktion lesen wir Daten, während die Daten verfügbar sind, und weisen sie einem Byte zu (denken Sie daran, dass die Daten jeweils byteweise empfangen werden).
Die requestEvent-Funktion wird immer dann aufgerufen, wenn wir eine Anfrage nach Daten vom Master erhalten. Wir müssen unsere Zeichenfolge „Hallo“ an den Master zurücksenden. Da wir die Daten Byte für Byte senden müssen, teilen wir die Zeichen in „Hallo“ in einzelne Elemente in einem Array auf und senden sie dann einzeln.
Wir melden alle unsere Fortschritte in beiden Funktionen an den seriellen Monitor.
Die Schleife in dieser Skizze fügt nur eine Zeitverzögerung hinzu, die der in der Masterskizze verwendeten entspricht.
Ausführen der Demo-Skizzen
Um diese Skizzen auszuführen, müssen Sie in der Lage sein, den seriellen Monitor auf jedem Arduino anzuzeigen. Wenn Sie zwei Computer mit der Arduino IDE installiert haben, wird das viel einfacher.
Unter Microsoft Windows ist es möglich, zwei Instanzen der Arduino IDE zu öffnen. In diesem Fall können Sie beide seriellen Monitore nebeneinander auf demselben Bildschirm anzeigen.
Alternativ können Sie einen Computer verwenden und den zweiten Arduino mit einem eigenen Netzteil einschalten. Sie müssten den Computer und die Stromversorgung zwischen den beiden Arduino umschalten. Auf diese Weise können Sie beide Bildschirme einzeln überwachen.
Arduino Remote mit I2C
In der nächsten Demonstration werden wir ein Potentiometer an den Master Arduino und eine LED an den Slave anschließen. Wir werden das Potentiometer verwenden, um die Blinkrate der LED zu steuern.
Dies ist eine weitere einfache Demonstration, auf der Sie aufbauen können, um etwas Praktischeres zu erstellen.
Remote Demo Hookup
So wird dieses Experiment zusammengestellt.
Es ist im Wesentlichen die gleiche Schaltung wie das vorherige Experiment, mit dem Zusatz des Potentiometers auf dem Master und der LED auf dem Slave.
Beachten Sie, dass die LED am Slave an Pin 13 angeschlossen ist. Da der Arduino Uno über eine integrierte LED an Pin 13 verfügt, können Sie die LED und den Fallwiderstand entfernen, wenn Sie dies wünschen.
Die Ausführungen zu Pull-up-Widerständen gelten auch für diesen Anschluss.
Remote Demo Master Skizze
Die skizze für die master seite von dieses experiment ist sehr einfach, in gewisser weise die I2C seite ist sogar einfacher als die verwendet in die erste demonstration. Dies liegt daran, dass wir nur Daten an den Slave senden und nicht erwarten, Daten zurückzubekommen.
|
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-Steuerung.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() {
// I2C-Kommunikation als Master initialisieren
Draht.begin();
}
void loop() {
delay(50);
// Pot-Wert lesen
// Map im Bereich von 1-255 für die Blitzrate
val = map(analogRead(analogPin), 0, 1023, 255, 1);
// Schreibe ein Zeichen an den Slave
Draht.beginTransmission(SLAVE_ADDR);
Draht.write(val);
Draht.Endübertragung();
}
|
Wie immer müssen wir die Drahtbibliothek am Anfang der Skizze einfügen. Wir werden auch eine Konstante definieren, um die Slave-Adresse zu halten.
Da wir ein Potentiometer verwenden, müssen wir sowohl den Pin, mit dem es verbunden ist, als auch eine Variable definieren, um seinen Wert zu halten.
Alles, was wir im Setup tun, ist, die I2C-Verbindung als Master zu initialisieren.
In der Schleife lesen wir den Potentiometerwert und ordnen ihn einem Bereich von 01-255 zu. Wir müssen das tun, da wir ein Byte an Informationen senden und nur so viele Werte in einem einzigen Byte speichern können.
Beachten Sie, dass wir die Nummerierungssequenz in der Arduino Map–Funktion umkehren, damit sich das System so verhält, wie wir es erwarten – durch Drehen des Potentiometers nach rechts wird die Blitzrate erhöht. Da die „Blitzrate“ durch eine Zeitverzögerung angegeben wird, entspricht eine größere gesendete Zahl einer längeren Blitzrate.
Beachten Sie auch, dass wir nicht den Wert 0 senden, der nur die LED in einem Zustand halten würde. Wir setzen unseren Bereich stattdessen auf 1.
Jetzt geht es nur noch darum, das Byte an den Slave zu senden und die Schleife erneut zu wiederholen.
Remote Demo Empfangen:
Die slave seite bedürfnisse zu empfangen daten von der master und verwenden es zu blinken die LED.
|
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 Steuerung Demo
i2c-slave-demo-steuerung.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;
leere setup () {
pinMode (LED, AUSGANG);
// Initialisieren I2C kommunikation als Slave
Draht.begin(SLAVE_ADDR);
// Funktion, die ausgeführt wird, wenn Daten vom Master empfangen werden
Draht.onReceive(receiveEvent);
// Setup Serial Monitor
Seriell.begin(9600);
Seriell.println(„I2C Slave Demonstration“);
}
void receiveEvent() {
// liest ein Zeichen aus dem I2C
rd = Draht.read();
// Druckwert der eingehenden Daten
Seriell.println(rd);
}
void loop() {
Verzögerung(50);
// Blinkwert berechnen
br = map(rd, 1, 255, 100, 2000);
digitalWrite(LED, HIGH);
delay(br);
digitalWrite(LED, LOW);
delay(br);
}
|
Wir beginnen mit der üblichen Aufnahme der Drahtbibliothek sowie der Definition der slave-Adresse. Wir definieren auch einen Pin für die LED.
Es sind einige zusätzliche Variablen definiert, von denen eine die empfangenen Daten enthält, während die andere den Zeitverzögerungswert für die Blinkrate enthält.
Im Setup setzen wir den I/O-Pin für die LED als Ausgang und initialisieren den I2C-Bus. Da wir die Slave-Adresse in der begin-Funktion verwenden, weiß die Wire-Bibliothek, dass wir als Slave fungieren.
Wir müssen nur eine onReceive Funktion definieren, im Gegensatz zur letzten Demo erwarten wir keine Anfragen vom Master. Wir richten auch den seriellen Monitor ein und drucken ihn aus, wir werden den Monitor verwenden, um die eingehenden Daten anzuzeigen.
Die Funktion receiveEvent liest die eingehenden Daten und weist sie der Variablen I zu. Es druckt auch den Wert auf den seriellen Monitor.
Schließlich verwenden wir in der Schleife die eingehenden Daten, um die LED zu blinken. Wieder einmal verwenden wir die Map-Funktion, um dies zu erreichen, indem wir die eingehenden Werte von 1-255 in einen größeren Bereich ändern. Sie können mit dem Ändern dieses Bereichs experimentieren, um die LED schneller oder langsamer blinken zu lassen, wenn Sie möchten.
Die letzten paar Statements sind im Wesentlichen die Arduino Blink Sketch in disguise! Wir schalten die LED für einen im letzten Schritt festgelegten Zeitraum ein und aus.
Und dann wiederholen wir die Schleife.
Ausführen der Remote-Demo
Laden Sie den Code und schalten Sie beide Arduino ein. Sie können Ihren seriellen Monitor auf dem Slave-Arduino verwenden, um die eingehenden Daten anzuzeigen.
Durch Drehen des Potentiometers sollte nun die LED-Blinkrate am Slave variiert werden.
Fazit
Damit ist unser erster detaillierter Blick auf I2C abgeschlossen. Im nächsten Teil erfahren wir mehr über die Struktur der Daten, die ausgetauscht werden. Wir nehmen auch einen normalen Sensor und verwandeln ihn in einen I2C-Sensor.
Viel Spaß beim Kommunizieren!
Ressourcen
Skizzen – Alle in diesem Artikel verwendeten I2C-Skizzen.
I2C–Informationen – Informationen zum I2C-Protokoll
