Schaltungen

I2C zwischen Arduinos

Vielleicht möchten wir manchmal die Arbeitslast eines Arduino mit einem anderen teilen. Oder vielleicht wollen wir mehr digitale oder analoge Pins. Inter-Integrated Circuit oder I2C (ausgesprochen I im Quadrat C) ist die beste Lösung.

I2C ist ein interessantes Protokoll. Es wird normalerweise verwendet, um zwischen Komponenten auf Motherboards in Kameras und in jedem eingebetteten elektronischen System zu kommunizieren.

Hier werden wir einen I2C-Bus mit zwei Arduinos bauen. Wir werden einen Master-Arduino so programmieren, dass er dem anderen Slave-Arduino befiehlt, seine eingebaute LED je nach empfangenem Wert ein- oder zweimal zu blinken.

Um dies aufzubauen, benötigen wir die folgenden "Zutaten":

2 Arduinos
Überbrückungskabel

Diese Anleitung und viele weitere finden Sie in meinem Arduino Development Cookbook, das hier verfügbar ist. : D.

Schritt 1: So verbinden Sie sie

Führen Sie die folgenden Schritte aus, um zwei Arduino-UNOs über I2C zu verbinden:

Verbinden Sie die Pins A4 und A5 eines Arduino mit den gleichen Pins des anderen.
Die GND- Linie muss für beide Arduinos gleich sein. Verbinden Sie es mit einem Jumper.

Wir haben auch eine schematische und eine "Steckbrett" -Implementierung, die beide leicht zu befolgen sind. Zum Glück ist es eine einfache Implementierung.

Denken Sie daran, niemals 5 V und 3, 3 V Arduinos miteinander zu verbinden. Das wird es nicht
verletzt den 5V Arduino, aber es wird sicherlich seinen 3, 3 V Bruder nerven!

Schritt 2: Code

Der folgende Code besteht aus zwei Teilen: dem Mastercode und dem Slave-Code, die auf zwei verschiedenen Arduinos ausgeführt werden. Schauen wir uns zunächst den Mastercode an:

 // Fügen Sie die erforderliche Wire-Bibliothek für I2C hinzu 
#include int x = 0; void setup () {// Startet den I2C-Bus als Master Wire.begin (); } void loop () {Wire.beginTransmission (9); // an Gerät Nr. 9 senden Wire.write (x); // sendet x Wire.endTransmission (); // keine Übertragung mehr senden x ++; // Inkrementiere x wenn (x> 5) x = 0; // `setze x zurück, sobald es 6 Verzögerung (500) bekommt; }}

Und hier ist der Slave-Code, der die vom Master gesendeten Zeichen interpretiert:

 // Fügen Sie die erforderliche Wire-Bibliothek für I2C hinzu 
#include int LED = 13; int x = 0; void setup () {// Definiere den LED-Pin als Output pinMode (LED, OUTPUT); // Starten Sie den I2C-Bus als Slave an Adresse 9 Wire.begin (9); // Hänge eine Funktion an, die ausgelöst wird, wenn etwas empfangen wird. Wire.onReceive (receiveEvent); } void receiveEvent (int bytes) {x = Wire.read (); // ein Zeichen aus dem I2C lesen} void loop () {// Wenn der empfangene Wert 0 ist, blinkt die LED 200 ms lang if (x == '0') {digitalWrite (LED, HIGH); Verzögerung (200); digitalWrite (LED, LOW); Verzögerung (200); } // Wenn der empfangene Wert 3 ms lang 3 Blink-LED ist if (x == '3') {digitalWrite (LED, HIGH); Verzögerung (400); digitalWrite (LED, LOW); Verzögerung (400); }}

Anhänge

I2C_master.ino herunterladen
I2C_slave.ino herunterladen

Schritt 3: Code-Aufschlüsselung

Schauen wir uns zuerst den Meister an . Wir müssen die erforderliche Wire.h- Bibliothek einschließen :

 #umfassen

Dann starten wir in der Setup-Funktion den I2C-Bus mit der Funktion Wire.begin () . Wenn in der Funktion kein Argument angegeben ist, startet Arduino als Master.

Zuletzt senden wir ein Zeichen x, das zwischen 0 und 5 liegt. Wir verwenden die folgenden Funktionen, um
Starten Sie eine Übertragung zum Gerät mit der Adresse 9, schreiben Sie das Zeichen und stoppen Sie dann die Übertragung:

 Wire.beginTransmission (9); // an Gerät Nr. 9 senden Wire.write (x); // sendet x Wire.endTransmission (); // Übertragung beenden

Lassen Sie uns nun den Slave-Arduino-Code untersuchen . Wir fügen hier auch die Wire.h- Bibliothek hinzu, aber jetzt starten wir den I2C-Bus mit Wire.begin (9) . Die Zahl im Argument ist die Adresse, die wir für das Arduino verwenden möchten. Alle Geräte mit der Adresse 9 erhalten die Übertragung.

Jetzt müssen wir irgendwie reagieren, wenn wir eine I2C-Übertragung erhalten. Die folgende Funktion fügt eine Triggerfunktion hinzu, wenn ein Zeichen empfangen wird. Besser gesagt, wenn der Arduino ein Zeichen auf I2C empfängt, führt er die Funktion aus, die er ausführen soll:

 Wire.onReceive (receiveEvent);

Und das ist die Funktion. Hier speichern wir einfach den Wert des empfangenen Zeichens:

 void receiveEvent (int bytes) {x = Wire.read (); }}

In loop () interpretieren wir dieses Zeichen einfach so, dass die eingebaute LED je nach empfangenem Zeichen mit unterschiedlichen Geschwindigkeiten blinkt.

Schritt 4: Weitere Informationen zu I2C

Um die Theorie kurz durchzugehen, benötigt I2C zwei digitale Leitungen: Serielle Datenleitung ( SDA ) zum Übertragen von Daten und serielle Taktleitung ( SCL ) zum Halten der Uhr. Jede I2C-Verbindung kann einen Master und mehrere Slaves haben. Ein Master kann in Slaves schreiben und die Slaves auffordern, Daten anzugeben, aber kein Slave kann direkt in den Master oder in einen anderen Slave schreiben. Jeder Slave hat eine eindeutige Adresse auf dem Bus, und der Master muss die Adressen jedes Slaves kennen, auf den er zugreifen möchte.

Jeder I2C-Bus kann bis zu 112 Geräte unterstützen . Alle Geräte müssen GND gemeinsam nutzen . Die Geschwindigkeit liegt bei 100 kb / s - nicht sehr schnell, aber dennoch respektabel und durchaus brauchbar. Es ist möglich, mehr als einen Master in einem Bus zu haben, aber es ist wirklich kompliziert und wird im Allgemeinen vermieden.

Viele Sensoren verwenden I2C zur Kommunikation, normalerweise Trägheitsmesseinheiten, Barometer,
Temperatursensoren und einige Sonare. Denken Sie daran, dass I2C nicht für lange Kabellängen ausgelegt ist . Je nach verwendetem Kabeltyp können bereits 2 Meter Probleme verursachen.

I2C ist ein kompliziertes Übertragungsprotokoll, aber es ist sehr nützlich. Alle Arduinos implementieren es mit einigen Unterschieden bei den Pin-Zuordnungen:

Board I2C Pins

Uno, Pro Mini A4 (SDA), A5 (SCL)

Mega, Due 20 (SDA), 21 (SCL)

Leonardo, Yun 2 (SDA), 3 (SCL)

Schritt 5: Anschließen weiterer Geräte

Wenn wir mehr als zwei Geräte an einen I2C-Bus anschließen müssen, müssen wir nur alle SDA- und SCL-Leitungen miteinander verbinden. Wir brauchen die Adresse jedes Sklaven, die vom Master Arduino angesprochen werden soll.

Hier ist ein Video einer persönlichen Implementierung mit 1 Master und 3 Slaves.

Weitere Themen zur Arduino-Kommunikation wie Wireless Serial, SD-Karten oder Ethernet finden Sie in meinem Arduino Development Cookbook, das hier verfügbar ist. : D.