I2C -Kommunikation zwischen zwei Arduino -Boards
Dieser Artikel deckt:
- Was ist I2C -Kommunikation in Arduino
- I2C -Stifte in Arduino
- Was ist I2C -Drahtbibliothek
- Verbinden Sie zwei Arduino -Boards mit i2c als Master und Sklave
- Schematisch
- Hauptkennziffer
- Sklavencode
- Ausgang
- Abschluss
Was ist I2C -Kommunikation in Arduino
I2c (Zwischenintegrierte Schaltung) ist ein beliebtes Protokoll zum Anschließen von Mikrocontrollern mit Peripheriegeräten wie Sensoren und Displays. Arduino Uno, eine weit verbreitete Mikrocontroller -Karte, kann so konfiguriert werden.
Einige Haupthighlights der I2C -Kommunikation umfassen:
Multi-Master- und Multi-Sklaven-Fähigkeit: I2C unterstützt mehrere Master -Geräte und mehrere Sklavengeräte in einem einzelnen Bus und ermöglicht die Kommunikation zwischen mehreren Geräten gleichzeitig.
Niedrige Stiftanzahl: I2C verwendet nur zwei Zeilen, SDA und SCL, für die Kommunikation, wodurch die Anzahl der erforderlichen Verbindungen reduziert und die Verkabelung vereinfacht wird.
Adressierbare Geräte: Jedes I2C -Gerät im Bus hat eine eindeutige Adresse, die eine einfache Identifizierung und Kommunikation mit bestimmten Geräten ermöglicht.
Schnelle Geschwindigkeit: I2C ist in der Lage, hohe Datenraten von bis zu 3.4 Mbit / s, damit es für Hochgeschwindigkeitsdatenübertragungsanwendungen geeignet ist.
Leistungssparung: I2C ermöglicht die Kommunikation mit geringer Leistung zwischen Geräten, indem Geräte in geringe Leistungsmodi eingesetzt werden können, wenn sie nicht kommunizieren und auf Anfrage aufwachen.
I2C -Stifte in Arduino
In der I2C -Kommunikation werden zwei Zeilen verwendet:
- Datenleitung (SDA): Datenlinie zum Austausch von Daten zwischen Master- und Sklavengeräten.
- Taktlinie (Scl): Taktlinie zur Synchronisierung der I2C -Kommunikation zwischen Geräten.
Der Master Arduino steuert die I2C -Uhr -Linie und beginnt die Kommunikation mit Peripheriegeräten, während die Sklavengeräte auf die Anfragen des Masteres reagieren.
In der folgenden Tabelle finden Sie die Pinouts der I2C -Schnittstelle auf verschiedenen Arduino -Boards:
| Planke | I2C -Stifte |
|---|---|
| Arduino Nano | SDA-A4 | SCL-A5 |
| Arduino Mega | SDA-A4 | SCL-A5 und SDA-20 | SCL-21 |
| Arduino Leonardo | SDA-A4 | SCL-A5 |
| Arduino uno | SDA-A4 | SCL-A5 |
| Arduino Micro | SDA-02 | SCL-03* |
*I2C -Stifte können variieren, je nachdem, welche Board -Version Sie verwenden. Bitte sehen Sie das jeweilige Datenblatt für weitere Details an.
Was ist I2C -Drahtbibliothek
Die I2C -Drahtbibliothek ist in einer IDE vorinstalliert, die die Kommunikation zwischen I2C -Geräten aufbaut. Die Bibliothek enthält Funktionen zum Konfigurieren und Kommunizieren im I2C -Bus, einschließlich Funktionen zur Initialisierung des Busses als Master- oder Slave -Gerät, Senden und Empfangen von Daten und Steuern der Taktgeschwindigkeit.
Die Bibliothek erleichtert es einfach, mit I2C-Geräten zu kommunizieren, indem die Details des I2C-Protokolls auf niedrigem Niveau abstrahiert und einfache Funktionen auf hoher Ebene bereitgestellt werden, die in Arduino-Skizzen verwendet werden können. Zum Beispiel die Start() Funktion wird verwendet, um den I2C -Bus als Master- oder Slave -Gerät zu initialisieren
Die Bibliothek unterstützt auch die Verwendung mehrerer I2C -Busse und ermöglicht die Kommunikation mit mehreren Geräten gleichzeitig. Wenn Sie mit mehreren Sensoren oder Displays für ein Projekt zu tun haben, ist dies hilfreich.
Verbinden Sie zwei Arduino -Boards mit i2c als Master und Sklave
Um die I2C -Kommunikation zwischen zwei Arduino Uno -Boards zu errichten, müssen die SDA- und SCL -Stifte beider Boards miteinander verbunden sein und eine gemeinsame Grundlage teilen. Die Kommunikation kann durch die Verwendung der eingebauten Drahtbibliothek in Arduino erreicht werden, die Funktionen zum Konfigurieren und Kommunizieren im I2C -Bus enthält.
Schematisch
Das folgende Bild zeigt zwei Arduino Uno-Boards, die in der Master-Slave-Konfiguration verbunden sind:
Hauptkennziffer
Laden Sie den folgenden Code in das Master Arduino Board hoch:
#include /*Drahtbibliothek für I2C -Kommunikation* /
int x = 0; /*Initialisieren Sie eine Variable zum Speichern einer Zahl*/
void setup ()
/*Starten Sie den I2C -Bus als Master*/
Kabel.Start();
void Loop ()
/*I2C -Busadresse wird als 9 für Slave -Geräte*/festgelegt
Kabel.BeginnTransmission (9);
Kabel.schreiben (x); /*sendet x*/
Kabel.Endtransmission (); /*Hören Sie auf zu übertragen*/
x ++; /*Inkrement x*/
if (x> 5) x = 0; /*Zurücksetzen x Sobald es 6*////
Verzögerung (1000);
Der von der I2C Master Library gestartete Code enthält. Eine Variable wird initialisiert, die die Ganzzahlwerte ab 0 bis 5 speichert. Die I2C -Adresse für das Slave -Gerät ist als 9 definiert. Verwenden Sie die Funktion der Kabelbibliothek
Auf dem Master Board die Start() Die Funktion initialisiert den I2C -Bus als Master -Gerät
Sobald die Boards konfiguriert sind, können sie über den i2c -Bus miteinander kommunizieren. Der Master Arduino fordert Daten von Slave Arduino Board und der Slave an, die mit den angeforderten Daten antworten können.
Sklavencode
Laden Sie den folgenden Code in Slave Arduino Board hoch, mit dem LED verbunden ist:
#enthalten
int led = 13; /*LED -Pin für Ausgabe*/
int x = 0; /*Variable, um Wert von Master Arduino*/zu erhalten
void setup ()
PinMode (LED, Ausgabe); /*LED -Pin als Ausgabe eingestellt*/
Kabel.Beginnen Sie (9); /*I2c Slave -Gerät wird die Daten von Master unter der Adresse#9*/gelesen
Kabel.OnReceive (EmpfängerEvent); /*Eine Funktion anhängen, um auszulösen, wenn etwas empfangen wird*/
void recement (int bytes)
x = Draht.lesen(); /*Lesen Sie ein Zeichen aus dem I2C -Master*/
void Loop ()
/*Wenn der Wert empfangen wird 0 Blink LED für 200 ms*/
if (x == 0)
DigitalWrite (LED, hoch);
Verzögerung (200);
DigitalWrite (LED, niedrig);
Verzögerung (200);
/*Wenn der erhaltene Wert 3 Blink LED für 400 ms*/ist
if (x == 3)
DigitalWrite (LED, hoch);
Verzögerung (400);
DigitalWrite (LED, niedrig);
Verzögerung (400);
Der Code begann mit der Drahtbibliothek und als nächstes setzen wir die eingebaute LED an Pin 13 von Slave Arduino als Ausgabe. Als nächstes eine Variable X wird definiert, die Daten vom Master Arduino empfangen. Mit diesem Ganzzahlwert werden wir die LED nach Erhalt in einem bestimmten Charakter blinken.
In Schleife(), Der empfangene Charakter wird dann in eine andere Geschwindigkeit des LED -Blinzelns übersetzt, abhängig vom empfangenen Charakter. Wenn die Bedingung verwendet wird, wenn das empfangene Zeichen des Master -Geräts 0 ist, blinzelt die LED mit 200 ms und wenn das empfangene Zeichen 3 LED mit einer Verzögerung von 400 ms blinkt.
Im Falle einer anderen geführten Charaktere bleiben.
Ausgang
In der Ausgabe können wir jedes Mal, wenn der Master mit Slave Arduino Blinzeln verbunden ist, ein Zeichen von 0 oder 3 sendet.
Abschluss
Mit der I2C -Kommunikation können mehrere Geräte mit einem gemeinsamen Bus miteinander kommunizieren. Arduino -Boards können so konfiguriert werden. Die Verwendung von I2C-Kommunikation mit mehreren Geräten innerhalb eines Projekts ist daher einfacher und effizienter.