I2C-Workshop, 18: Arduino als I2C-Slave (Seite 2)

Durch seine simple Funktionsweise eignet es sich gut für einen einfachen Test (Listing 2). Sobald das Kommando i2cdetect -y 1 eine Ausgabe liefert, können Sie davon ausgehen, dass der I²C-Bus fehlerfrei arbeitet. Funktionieren auch die Schreib- und Lese-Operationen, arbeiten Soft- und Hardware einwandfrei. Der vom Sensor konkret zurückgelieferte Wert hängt dabei von der Helligkeit im Raum ab.

$ i2cdetect -y 1
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- 23 -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
$ i2cset -y 1 0x23 0x10
$ i2cget -y 1 0x23 0x00
0x0a

Arduino Mega

Wir verwenden den Arduino Mega im Folgenden als I²C-Slave statt wie sonst üblich als I²C-Master am Bus. Um das relativ triviale Programm in diesem Modus zu betreiben, müssen Sie es erst einmal in den Controller laden. Dazu verwenden Sie die Arduino IDE, die der Einfachheit halber direkt auf dem RasPi läuft. Diesen verbinden Sie nun über ein USB-Kabel mit dem Arduino.

Die IDE laden Sie bei Bedarf von der Homepage des Projekts herunter. Da sie auf dem Pi laufen soll, wählen Sie die aktuelle Version [4] für ARM-Prozessoren. Danach entpacken Sie die Dateien und führen das Skript für die Installation aus (Listing 3).

$ tar -xvf arduino-Version-linuxarm.tar.xz
$ cd  arduino-Version
$ sh install.sh
$ ./arduino

In der Arduino IDE wählen Sie jetzt unter Tools den Board-Manager für den Arduino Mega aus. Um zu überprüfen, ob die IDE ordnungsgemäß funktioniert, laden Sie ein Beispielprogramm in den Controller. Ein solches Programm finden Sie unter File | Examples | 01 Basics | Blink in der IDE. Es bringt die Onboard-LED zum Blinken. Um es zu bauen und hochzuladen, drücken Sie den Upload-Button (zweite Schaltfläche von links in der Leiste). Nach dem Übertragen beginnt die LED direkt zu blinken.

Nun ist es an der Zeit, die I²C-Schnittstellen des Arduino Mega mit dem RasPi zu verbinden. Das klappt nicht ganz so einfach wie erhofft, da der Arduino mit einer Spannung von 5 Volt am I²C-Bus arbeitet, der RasPi aber nur maximal 3,3 Volt an den GPIOs verträgt.

Um dieses Problem zu lösen, verwenden Sie einen sogenannten Level Shifter [5] zwischen den beiden Geräten. Er sorgt dafür, dass jeder der zwei Bausteine den für ihn passenden Spannungspegel erhält. Abbildung 2 zeigt den kompletten Aufbau; Abbildung 3 den dazugehörigen Schaltplan.

Abbildung 2: Der Testaufbau mit Arduino, Raspberry Pi und Level Shifter, wobei Letzterer dafür sorgt, dass die unterschiedlichen Spannungen von Mikrocontroller und Mini-PC nicht für Probleme sorgen.

Abbildung 3: Der Schaltplan zum Testaufbau fällt diesmal recht einfach aus: Controller und PC bringen bereits die meisten Komponenten mit.

Jetzt können Sie darangehen, den Arduino tatsächlich zu programmieren. Das recht übersichtliche Beispielprogramm aus Listing 4 importiert zunächst die Wire-Bibliothek, um die I²C-Unterstützung zu erhalten. Mit der Zeile Wire.begin(0x20); sorgen Sie dafür, dass der Arduino sich am I²C-Bus unter der Adresse 0x20h anmeldet.

#import <Wire.h>
void setup() {
  Wire.begin(0x20);
  Wire.onRequest(requestEvent);
  pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
  digitalWrite(LED_BUILTIN, LOW);
  delay(2000);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
}
void requestEvent(){
  static char c = 0;
  Wire.write(c);
  c++;
  if (c==255) c=0;
}

Die nächste Zeile registriert einen sogenannten Event-Handler für die Schnittstelle. Das bedeutet, dass die Software die angegebene Funktion immer dann ausführt, wenn ein Ereignis am fraglichen Interface auftritt. Der Handler requestEvent() schreibt dann eine Zahl auf den Bus, die sich bei jedem Aufruf um eins erhöht – keine besonders kreative Funktion, aber hervorragend zum Testen geeignet.

Die Funktion loop() enthält das eingangs schon erwähnte Blink-Beispiel. Dafür gibt es zwei Gründe: Zum einen zeigt es, dass das Programm erfolgreich geladen ist, denn das Puls-Pausen-Verhältnis weicht vom ersten Programm ab. Zum anderen sehen Sie, dass der Event-Handler parallel zum Hauptprogramm läuft. Im Klartext bedeutet das, dass der Arduino autark arbeitet (etwa beim Erfassen von Messwerten) und Sie asynchron Ergebnisse abfragen können, ohne in den Ablauf des Hauptprogramms einzugreifen.

Um zu überprüfen, ob das Programm auch wie gewünscht arbeitet, laden Sie es in den Arduino und verbinden sich mithilfe der I²C-Tools auf die Schnittstelle des Controllers. Als Erstes testen Sie mit dem Befehl i2cdetect, ob dieser sich am Bus meldet; danach fragen Sie den aktuellen Wert des Zählers ab. Sieht die Ausgabe so aus wie in Listing 5, hat so weit alles geklappt.

$ i2cdetect -y 1
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: 20 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
$ i2cget -y 1 0x20
0x00
$ i2cget -y 1 0x20
0x01
$ i2cget -y 1 0x20
0x02
$ i2cget -y 1 0x20
0x03

Go-Programm

Das Beispielprogramm ist wie eingangs schon erwähnt in Go geschrieben. Für den Zugriff auf die Hardware kommt die Bibliothek des Gobot-Projekts [6] zum Einsatz. Dabei handelt es sich um ein Framework zur Software-Entwicklung für Roboter, Drohnen und IoT-Geräte, das aktuell 32 unterschiedliche Hardware-Plattformen unterstützt.