Projekt 32: Komplexer Sensor für Lego Mindstorms EV3

Autoren: Jan Koppius, Thomas Marton, David Duhme
Betreuer: Prof. Schneider

Aufgabe

Entwickeln Sie einen komplexen Sensor für Lego Mindstorms EV3.

Erwartungen an Ihre Projektlösung

Darstellung der Theorie
Realisierung des Aufbaus
Platinenlayout und Gehäuse kompatibel zum Lego Stecksystem (montierbar)
Kommunikation über I2C
Schaltungsentwurf und Simulation mit NI CD
Programmierung des Microcontrollers (z.B. Attiny)
Treiber für EV3 Lobby
Test und Dokumentation
Live Vorführung während der Abschlusspräsentation
Kür: Treiber für Matlab und Simulink

Schwierigkeitsgrad

Schwer (****)

Weiterführende Links

Beschreibung

Dieser Wiki-Eintrag soll ein kurzes Tutorial zur Erstellung eines komplexen Sensor für das Lego EV3 System darstellen. Als komplexer Sensor wurde hierfür ein SHARP Infrarotsensor des Typs GP2Y0D21YK0F gewählt.

Vorgehen

Prinzipiell werden 2 Ansätze zur Zielführung verfolgt. Im ersten Ansatz sollen die Daten des Infrarotsensors vom Arduino Uno eingelesen und am EV3-Brick ausgegeben werden. Die Werte des Infrarotsensors lassen sich über das Kommando "analogRead" vom Arduino einlesen. Aufwändiger gestaltet sich hingegen die Kommunikation zwischen Arduino Board und dem EV3-Brick. Diese kommunizieren über eine sogenannte I2C-Schnittstelle.

Aufgrund der üppigen Bauform des Arduino Uno wird im zweiten Ansatz versucht die Bauform zu reduzieren. Hierzu wird das Arduino Board durch ein Atmel ATtiny 84 (8-Bit Mikrocontroller) auf einer selbstgefrästen Platine ersetzt.

Bill of Material

Datei:BOM.pdf

Software

Windows XP / Mac OSX or higher
Arduino IDE
Lego EV3 Software

I2C-Kommunikation

I2C steht für Inter-Integrated Circuit und beschreibt einen seriellen Datenbus-Typen. Der I2C-Datenbus wurde Anfang der 1980er Jahre von der Philipps Tochtergesellschaft "NXP Semiconductors" entwickelt. Er findet vorwiegend bei der geräteinternen Kommunikation zwischen unterschiedlichen Schaltungsteilen Verwendung. Die Firma Atmel hat die I2C-Technologie adaptiert und verwendet diese unter dem Namen "TWI (Two-Wire-Interface)".

Wie der Name Two-Wire-Interface schon vermuten lässt, kommuniziert der I2C-Bus lediglich über zwei Leitungen. Die erste Leitung ist die Serial Data (SDA) bzw. Datenleitung, welche für den Informationsaustausch zuständig ist. Die zweite Leitung ist die Serial Clock (SCL) bzw. Clockleitung. Diese initialisiert oder stoppt den Informationsaustausch.

Der I2C-Bus basiert auf dem Master-Slave-Prinzip. Somit ist bei jeder Kommunikation genau ein Schaltungsteil als Master deklariert. Dieser initialisiert und beendet die Kommunikation.

Funktionsweise I2C

Master und Slave tauschen Informationen byteweise aus. Als Beispiel für einen solchen Informationsaustausch soll hier nun ausführlich dargelegt werden, wie der Master einen Slave durch Senden der zugehörigen Adresse aktiviert.

Der Slave habe die Adresse 01001100. Dieses Byte muss nun vom Master über den I2C-Bus geschickt werden.

0 - Zunächst befinden sich alle Bausteine im Ruhezustand; er ist durch SDA = 1 und SCL = 1 gekennzeichnet.

1 - Nun sendet der Master ein Start-Signal, indem er durch Schließen der beiden Schalter zuerst SDA und dann SCL auf 0 setzt. Dadurch werden alle Slaves des Bus-Systems in Bereitschaft versetzt: Sie warten jetzt auf das Adressbyte (vgl. Schritt 2).

2 - Der Master sendet nun bitweise die Adresse 01001100. Dabei beginnt er bei dem höchstwertigen Bit (Bit 7), in unserem Beispiel also mit der 0, die am weitesten links steht.

2.1 - Der Master legt Bit 7 an SDA; in unserem Fall wird/bleibt dazu der SDA-Schalter ge- schlossen. Kurz darauf öffnet der Master den SCL-Schalter, so dass die SCL-Leitung vom Zustand 0 in den Zustand 1 übergeht. Dies ist für die Slaves das Signal, das Bit 7 von der Datenleitung SDA entgegenzunehmen und in einem Puffer zwischenzuspei- chern. Kurze Zeit später setzt der Master die Clockleitung SCL wieder auf 0.

2.2 - Der Master legt nun Bit 6 an SDA; in unserem Fall wird dazu der SDA-Schalter geöff- net; durch den Pullabwiderstand erhält die SDA-Leitung jetzt den Zustand 1. Kurz darauf öffnet der Master wieder den SCL-Schalter, so dass die SCL-Leitung erneut vom Zustand 0 in den Zustand 1 übergeht. Dies ist für die Slaves das Signal, das nächste Bit (Bit 6) von der Datenleitung SDA entgegenzunehmen und in einem Puffer zwischenzuspeichern. Kurze Zeit später setzt der Master die Clockleitung SCL wieder auf 0.

2.3-2.8 - Bit 5 bis Bit 0 werden auf gleiche Weise übertragen.

2.9 - Alle Slaves vergleichen nach dem Empfang des Bit 0, ob das empfangene und zwi- schengespeicherte Byte mit ihrer eigenen Adresse übereinstimmt. Derjenige Baustein, welcher Übereinstimmung feststellt, legt nun SDA auf 0; dieses Signal wird Ack- nowledge-Signal (ACK) genannt. Der Master belässt/schaltet derweil SDA auf 1 und legt SCL auf 1. Er prüft nun, ob die SDA-Leitung auf 0 oder 1 liegt. Liegt sie auf 1, geht der Master davon aus, dass sich kein Slave mit der gesendeten Adresse im Bus- System befindet. Liegt auf SDA aber ein 0, zeigt dies dem Master, dass der gewünschte Slave gefunden wurde. Der Master setzt nun seinerseits SCL wieder auf 0 und zeigt damit dem Slave, dass er dessen Acknowledge-Signal erhalten hat. Darauf- hin öffnet der Slave wieder seinen SDA-Schalter (SDA wird dadurch auf 1 gesetzt, so dass der Master im Folgenden die Datenleitung wieder benutzen kann); der Slave ist jetzt zum Empfang eines weiteren Bytes (Datenbyte) bereit. Alle anderen Slaves ge- hen wieder in den Ruhezustand über, bis wieder ein Startsignal erfolgt.

3 - Nachdem durch entsprechende Schritte wie bei 2.1 - 2.9 ein oder mehrere Datenbytes übertragen worden sind, legt der Master sowohl SDA als auch SCL wieder auf 1. Durch dieses Stop- oder Init-Signal wird der ursprüngliche Ruhezustand wiederher- gestellt.

Quelle: Eube, H.; Heinrichs, G.; Ihlefeldt, U. (2008): Das I2C-Bus-System

I2C-Kommunikation: Schaltplan (l.) und Bitfolge (r.)

Abbildungen: Eube, H.; Heinrichs, G.; Ihlefeldt, U. (2008): Das I2C-Bus-System

Sensorkennline

Da es hinsichtlich der Herstellerkennlinie zu starken Abweichungen kommen kann, werden zunächst mindestens zwei eigene Kennlinien anhand von Messungen ermittelt. Der arithmetische Mittelwert beider Distanzmessungen mit dem Infrarotsensor stellt näherungsweise die reelle Kennlinie dar. Stimmt diese Kennlinie weitestgehend mit der Herstellerkennlinie überein, wird im weiteren Verlauf mit der Herstellerkennlinie weitergearbeitet.

Datei:Data sharp.pdf

Datenblatt SHARP Infrarotsensor

Datei:IR Messung.pdf

In unserem Fall stimmen die Messwerte bei Entfernungen über 10cm mit der Hestellerkennline überein, sodass im weiteren Verlauf mit den Daten der Herstellerkennlinie gearbeitet wird.

EV3 Programm

Laden Sie die EV3-Software (falls noch nicht vorhanden) von der Lego-Homepage hier herunter und installieren Sie diese. Anschließend müssen der EV3-Block für die I2C-Kommunikation heruntergeladen [1] werden. Im nächsten Schritt wird der I2C-Block im EV3-Programm über Tools -> Import Block zur EV3-Bibliothek hinzugefügt. Per Drag & Drop lassen sich nun die Blöcke aus der Bibliothek auf der Oberfläche zusammenstellen.

Abbildung: EV3 Programm für die I2C-Kommunikation

In diesem Projekt dient der EV3-Brick ausschließlich als Master der Kommunikation. Die I2C-Kommunikation wird im gelben Block initialisiert. Die AnalogRead-Funktion soll einen Sensorwert (Val) eines Slave-Devices ausgeben. Wichtig ist hierbei, dass beide Geräte (Master und Slave) dieselbe Adresse besitzen (in diesem Projekt 0x04 = 4). Im Feld "Pin" wird der analoge Eingang des Slave-Device definiert. Der grüne Block steht stellvertretend für das Display. Hier wird der Sensorwert (Val) als Text in einem Display-Grid ausgegeben. Anschließend wird die Ausgabe um 0,5s verzögert. Der Loop-Block sorgt dafür, dass der Vorgang solange wiederholt wird, bis der Stop-Knopf des Bricks gedrückt wird.

Arduino Programm

Laden Sie die Arduino IDE Software von der Arduino.cc - Webpage herunter hier und installieren Sie diese. Anschließend öffnen Sie die Datei:Arduino Analog sketch.ino und übertragen die Datei auf den Arduino. Die I2C-Kommunikation auf dem Arduino basiert auf der Wire-Library von Arduino. Diese ist standardmäßig bei der Arduino IDE vorinstalliert. Wird allerdings ein anderer Mikrocontroller, beispielsweise der ATtiny-Serie von AVR verwendet, müssen zusätzlich die Bibliotheken TinyWireM bzw. TinyWireS (ATtiny44/84) installiert werden. Eine genaue Beschreibung der Bibliotheken, sowie eine ausführliche Installationsanleitung befindet sich hier.

Systemschnittstellen: EV3-Arduino-Sensor

Standardmäßig verwendet das Lego EV3-System modifizierte RJ45-Steckverbinder.

Abbildung: Sechsadriges NXT Datenkabel

Entweder man verwendet in diesem Projekt die "originalen" Lego EV3-Steckverbinder oder man verwendet einen herkömmlichen RJ45-Steckerverbinder und bastelt sich nach der folgenden Anleitung hier einen eigenen Lego-Stecker. Nun muss der EV3-Brick mit dem Arduino UNO über die nachfolgende Pinbelegung verschaltet werden.

Abbildung: Dexter Industries: Connecting the EV3 to Arduino

Der Infrarotsensor lässt sich über die 3 Leitungen (VCC, GND und Datenleitung) mit dem Arduino UNO verschalten. Da im EV3-Programm der Eingangs-Pin des Slaves mit Pin=1 definiert wurde, muss die Datenleitung des Infrarotsensors am Eingang A1 anliegen. Die Versorgungsspannung des Infrarotsensors liegt an 5V an. Die Masse entspricht der Masse des Arduino UNO.

Video

zum Video (http://youtu.be/gmF2plAFwPM)

ATtiny 84

Nachdem das Arduino-Programm erfolgreich getestet wurde, sollte dieses auf einen einzelnen Mikrocontroller übertragen werden. Das hat den Vorteil, dass die Bauform des Sensor-Systems erheblich verringert wird. Mit einem Arduino-Mikrocontrollerboard würde der EV3-Sensor zu groß ausfallen und wäre ungeeignet für die Integration in einem Lego-Mindstorm-System. Als Mikrocontroller wird ein ATtiny 84 verwendet. Der ATtiny ist ein 8-Bit Mikrocontroller, der aufgrund seiner kompakten Bauform sehr gut für das Projekt geeignet ist. Er besitzt integrierte Pull-Up-Widerstände für Clock- und Datenleitung (SCL/SDA) und ist damit I2C-fähig. Außerdem lässt sich der ATiny 84 über die Arduino IDE mit der Bibliothek TinyWireS programmieren. Das Flashen des ATtiny 84 mit der Arduino-ISP wurde mit folgender Anleitung [2] durchgeführt.

Das verwendete Arduino-Programm für den ATtiny84 steht hier Datei:ATtiny 84 I2C slave.ino als Download zur Verfügung.

Abbildung: 42 Bots (2013): Programming ATtiny84 with Arduino Uno

Abbildung: Atmel: ATtiny84 - Datasheet

Schaltung & Platine

Die Schaltung für den Sensor wurde mit Multi-Sim und die Platine für die Bauteile mit Ulti-Board erstellt.

Datei:Platine EV3.zip

Gehäuse

Das Gehäuse besteht aus zwei Komponenten. In Komponente_1 wird die Paltine inkl. Stecker, µController und Sensorschnittstelle eingeschoben. Komponente_1 beinhaltet auch die Schnittstelle zum Lego System. Der Sensor wrid vor der eingeschobenen Platine platziert und durch Komponente_2 fixiert. Komponetnen_1 und Komponenten_2 werden durch zwei Schrauben miteinander verbunden.

Die Anfertigung der Gehäusekomponenten kann mithilfe eins generatives Herstellungsverfahrens (3D-Druck), wie Kunststoff-Laser-Sintern, erfolgen.

Datei:CAD Daten.zip

Aktueller Stand

Das Einlesen und die Ausgabe der Sensorwerte auf dem EV3-Brick in Kombination mit dem Arduino funktioniert einwandfrei. Lediglich die Umsetzung des Projektes mit dem ATtiny 84 weist noch Defizite aus. So verschwindet das Clock-Signal nach dem Anschließen des Verbrauchers (Sensors) komplett. Eine externe Spannungssimulation erzielte auch keinen Effekt. Es ist unklar, ob es sich um ein Hardware oder um ein Software-Problem handelt. Die Arduino-Software für den ATtiny 84 basiert auf dem Quellcode für den Arduino. Ein Clock- und Datensignal konnte ohne angeschlossenen Verbraucher gemessen werden.