Projekt 62: I2C-Netzwerk von MSP430-Launchpads
Autor: Theresa Wunsch | Anna Neuhaus
Betreuer: Prof. Göbel | Prof. Schneider
Aufgabe
- Erstellung eines Konzepts
- Verschaltung der MSP430-Launchpads >> Schaltplan, Pin-Belegungs-Tabelle (wie werden die Platinen verbunden?)
- Programmierung mit C mit energia
- Ansteuern/Auslesen der Aktoren/Sensoren
- Test und wiss. Dokumentation
- Machen Sie ein spektakuläres Video, welches die Funktion visualisiert.
- Dokumentation der technischen Funktion der verwendeten Bauteile
- Vorführung während der Abschlusspräsentation
Lösungskonzept - sensorgesteuerte Ampelschaltung
Zur Lösung der Aufgabenstellung soll eine sensorgesteuerte Ampelschaltung realisiert werden. Hierzu werden 3 MSP430 launchpads über ein I²C-Netzwerk mit einander verbunden. Das Netzwerk besteht aus einem Master als Sender und zwei Slaves als Empfänger. Der Sensor (in diesem Fall ein Taster) ist mit dem Master verbunden. Als Ausgabe an den Slaves fungieren rote und grüne LEDs.
Passiert ein Fußgänger den Sensor schaltet die Ampel auf grün. Um zusätzlich die Möglichkeit einer seriellen Schnittstelle darzustellen, wird lediglich ein Slave auf das Signal des Tasters reagieren. Der andere Slave wird auf ein seriell eingegebenes Signal schalten.
Unser Lösungskonzept stellt eine automatische Ampelschaltung für Fußgänger dar. Wir möchten ein Netzwerk aus drei Mikrocontrollern erstellen, von denen einer der „Master“ und die anderen beiden „Slaves“ sind. Nähere Erläuterungen zu den beiden Rollen finden sich in den Grundlagen.
Es soll eine Ampelschaltung realisiert werden, bei der der Master den Slaves den Befehl zum „Grün-Schalten“ erteilt. Ein Fußgänger soll an einer Kreuzung, mit drei aufeinander folgenden Ampeln, lediglich an der ersten Säule das Grünsignal anfordern. Die anderen Ampeln werden, mit einer Zeitverzögerung, automatisch auf Grün schalten.
Stückliste
3 MSP430g2553
2 Pullup Widerstände ?kOhm
2 LED Grün
2 LED Rot
4 Vorwiderstände für LED 330Ohm
3 Steckbretter
20 Jumper mit unerschiedlicher Farbe
1 Grundplatte
Als Taster wurde der inbuilt Taster des Launchpads verwendet.
(Zu beachten: falls die inbuilt LEDs genutzt werden sollen ist zu beachten, dass nur das rote LED genutzt werden kann.
Das grüne LED kann nicht verwendet werden, da es die selbe Pinbelegung hat wie der SDA-Anschluss, der für das I²C-Netzwerk notwendig ist.)
Projektplan
Um das Projekt zu planen und zeitlich einzuteilen wurde ein Projektplan erstellt. Dieser ist in der folgenden Abbildung dargestellt:
Grundlagen
Im folgenden Abschnitt werden Grundlagen zu dem verwendeten Bussystem (I²C) und den verwendeten Pull-up/-down Widerständen vermittelt.
Diese Grundlagen sollen das Verständnis für das vorliegende Projektes und erleichtern und einen Nachbau ermöglichen.
I²C-Bus
Der I²C-Bus (Inter-Integrated-Circut-Bus) wurde im Jahr 1982, von dem Unternehmen Philips entwickelt. Er ist ausgelegt für eine einfache und kostengünstige Vernetzung, von integrierten Schaltkreisen. Der I²C-Bus wird vor allem bei Mikrocontrollern, aber auch bei A/D und D/A-Wandlern, Echtzeituhren, Display-Treibern und einigen weiteren elektrotechnischen Bestandteilen verwendet.
Der I²C-Bus ist ein getakteter synchroner Zweidraht-Bus. Das bedeutet er besitzt eine Daten- und eine Taktleitung.
Der Bus enthält mindestens einen Master und eine beliebige Anzahl von Slaves. Der I²C ist jedoch auch fähig ein Multi-Master-System abzubilden, dass bedeutet mehrere Master und mehrere Slaves.
Die Master sprechen die Slaves an, so dass ein Slave niemals eigenständig Daten senden kann. Der oder die Master koordinieren den Zugriff auf den Bus. Sie bestimmen, welcher Slave Daten senden oder empfangen darf.
Die Datenübertragung auf dem I²C-Bus wird in zwei Phasen aufgeteilt. Die Adressierung und die Datenübertragung.
In der Adressierungs-Phase wird zunächst eine Adresse zur Selektion des gewünschten Slaves übertragen. Diese Adresse kann wahlweise 7 oder 10 Bits lang sein. Die Unterscheidung zwischen beiden Adresslangen wird durch eine besondere Belegung der höherwertigen Adressbits vorgenommen (s.u.). Das letzte Datenbit (R/W) legt fest, ob der Master Daten senden (R/W=0) oder empfangen (R/W=1) will.
In der zweiten Phase werden nun die Daten byteweise solange übertragen, bis die Übertragung des gesamten Blockes durch den Sender „planmäßig“ oder durch den Empfänger vorzeitig beendet wird. Dazu wird ein Quittierungstakt verwendet.
Quellen: [1], [3], [5]
Pull-up/ -down Widerstände
Ein Pullup- oder Pulldown-Widerstand wird dazu verwendet, einen Eingang auf einen definierten Wert zu "ziehen". Normalerweise befindet sich der Eingang im Zustand "schwebend/hochohmig", welcher sich irgendwo zwischen High und Low befindet. Nun sind Schaltungen nicht komplett ohne Störsignale, und durch Einstrahlungen von Signalen kann es passieren, dass kurzzeitig ein Wert über- oder unterschritten wird und der Eingang plötzlich ein High- oder Lowsignal bekommt. Dies führt dann zu unerklärlichen und unregelmäßig auftretenden Fehlern. Um dies zu vermeiden wird, während nichts am Eingang passiert, dieser auf High gezogen (pullup). Will man also einen Taster haben, der Low schaltet, so will man für den Rest der Zeit High am Eingang liegen haben. Dies kann man erreichen, indem man den Eingang fest mit VCC verbindet. Vom Eingang geht nun eine Leitung nach VCC und eine über den Taster nach GND. Leider würde dies zu einem Kurzschluss führen sobald man den Taster drückt und die Schaltung könnte (und würde höchstwahrscheinlich) Schaden nehmen. Deshalb wird nun zwischen VCC und dem Eingang ein hochohmiger Widerstand eingesetzt, der Pullup-Widerstand. Bei geschlossenem Taster wird nun der Strom über den Pullup-Widerstand nach GND fließen und der Input liegt auf GND (0V). [4]
Der Pulldown-Widerstand funktioniert analog zum Pullup-Widerstand, nur dass nun VCC geschaltet werden soll und somit der Eingang auf GND gezogen werden muss. Dies geschieht in gleicher Weise wie beim Pullup, nur dass der Pulldown-Widerstand nun zwischen GND und dem Eingang platziert wird. Schließt man nun wieder den Taster, liegt am Eingang Vcc an --> High. [4]
MSP430 Launchpad
Für die Umsetzung des Projektes wurde der Microcontroller MSP430 von Texas Instruments verwendet.
Im Folgenden wird zunächst die Pin-Belegung des Launchpads sowie die verwendete Programmier-Software vorgestellt.
Verkabelung / Pin-Belegung
Die PIN-Belegung verhält sich bei dem MSP430 wie in folgender Abbildung dargestellt:
Energia
Die zur Programmierung verwendete Software für das MSP430-Launchpad ist Energia des Herstellers Texas Instrument. Die Entwicklungsumgebung basiert auf Processing und soll auch technisch weniger Versierten den Zugang zur Programmierung und zu Mikrocontrollern erleichtern. (vgl. https://www.processing.org/). [2]
Für die Umsetzung des Projektes wurde die Version "Energia_0101E0015" verwendet. Die Nutzung dieser Version ist zu empfehlen da sie alle benötigten Funktionen fehlerfrei ermöglicht. Bei anderen Versionen kam es unter anderem zu Problemen bei der Erkennung der angeschlossenen launchpads, der kompilierung von Codes sowie zu Fehlern bei der Nutzung der wire.h-Bibliothek.
Der Download ist unter folgendem Link möglich: http://energia.nu/download/ (Bitte beachten: Zusätzlich zur Software müssen zwingend die entsprechenden Treiber heruntergeladen werden.)
Energia ist eine freiverfügbare Software, zur Programmierung und Verdrahtung von Mikrocontrollern. Speziell für den MSP430 von Texas Instruments. Die Software ist nahezu voll identisch, mit der Plattform zur Programmierung von Arduino, lediglich die Oberflächenfarbe ist anders. Mit Hilfe von Energia kann der Mikrocontroller MSP430 vom PC aus programmiert werden. Das Programm bietet schon vorerstellte Befehle, bei denen der Programcode vollständig automatisch eingefügt wird. Dies ermöglicht eine leichte Verwendung und führt zu schnellen Ergebnissen. [2]
Umsetzung
Programmierung
Die Programmierung teilt sich in drei Teile auf. Im Folgenden ist die Programmierung des Masters sowie der beiden Slaves (Slave_01, Slave_02) dargestellt.
Programmierung des Masters
Die Aufgabe des Masters ist es die Daten des Sensors an die Slaves in geeigneter Form über I2C-Netzwerk zu senden. Für das Ein- und Ausschalten der LEDs benötigen die Slaves die Signale "High" und "Low".
Das Signal für den Slave_01 erhält der Master durch einen Taster. Der Zustand des Tasters wird zunächst an die Variable "c" übergeben. Zusätzlich die die Variable "current" eingeführt um den Zustand speichern zu können.
//************************************************************************************//
//************************************************************************************//
// I2C - Netzwerk (Ampelschaltung)
// Master
// Autoren: Anna Neuhaus & Theresa Wunsch
// 05.01.2016
//************************************************************************************//
//
// Über ein I2C Netzwerk werden Daten von einem Master an verschiedene Slaves gesendet.
// Genutzt wird die "Wire.h" Bibliothek
// Hierbei wird ein Sensor sowie eine serielle Schnittstelle zur Eingabe genutzt.
//
//************************************************************************************//
// Quellen: Nicholas Zambetti <http://www.zambetti.com>
//************************************************************************************//
//************************************************************************************//
#define LED RED_LED
#include <Wire.h>
int current; // Zustand (t -1) des Tasters
void setup()
{
Serial.begin(9600);
pinMode(LED, OUTPUT);
pinMode(PUSH2, INPUT_PULLUP);
Wire.begin(); // join i2c bus (address optional for master)
digitalWrite(LED, LOW);
delay(200);
digitalWrite(LED, HIGH);
delay(200);
digitalWrite(LED, LOW);
delay(200);
}
// Funktion um den Slave_01 mittels Taster zu steuern
void loop()
{
int c = digitalRead(PUSH2); // Zustand der Variable c wird über den eingebauten Taster eingelesen
if(c==LOW && current==HIGH)
{
Wire.beginTransmission(5); // Beginn der Übertragung an Adresse 5
Wire.write('H'); // senden des Buchstaben H (H steht für High)
Wire.endTransmission(); // Ende der Übertragung
c=HIGH; //setzte c auf High
current=LOW; //setzte current aus Low
delay(500);
}
else if (c==LOW && current==LOW)
{
Wire.beginTransmission(5); // Beginn der Übertragung an Adresse 5
Wire.write('L'); // senden des Buchstaben L (L steht für Low)
Wire.endTransmission(); // Ende der Übertragung
c=LOW; // setzte c auf Low
current=HIGH; //setzte current auf High
delay(500);
}
// Funktion um Slave_02 über eine serielle Schnittstelle zu steuern
while(Serial.available())
{
char d = Serial.read(); // d wird über die serielle Schnittstelle eingelesen (Eingabemöglichkeiten: "H" und "L"
if(d == 'H')
{
Wire.beginTransmission(6); // Beginn der Übertragung an Adresse 6
Wire.write('H'); // Senden des Buchstaben "H"
Wire.endTransmission(); // Ende der Übertragung
}
else if (d == 'L')
{
Wire.beginTransmission(6); //Beginn der Übertragung an Adresse 6
Wire.write('L'); // Senden des Buchstaben "L"
Wire.endTransmission(); // Ende der Übertragung
}
}
}
Programmierung des Masters
Programmierung des Slave_01
Der erste Slave soll die Signale die durch den Taster eingegeben werden empfangen. Er erhält die Adressierung "5".
Je nach dem welches Signal der Slave empfängt (High oder Low) wird das grüne oder rote LED eingeschalten. Das jeweilig andere LED wird dementsprechend ausgeschalten.
//************************************************************************************//
//************************************************************************************//
// I2C - Netzwerk (Ampelschaltung)
// Slave_01
// Autoren: Anna Neuhaus & Theresa Wunsch
// 05.01.2016
//************************************************************************************//
//
// Über ein I2C Netzwerk werden Daten von einem Master an verschiedene Slaves gesendet.
// Genutzt wird die "Wire.h" Bibliothek
// Hierbei wird ein Sensor sowie eine serielle Schnittstelle zur Eingabe genutzt.
// Der folgende Code betrifft den Slave der durch einen Sensor (Taster) gesteuert wird.
// Wenn der Slave_01 das Signal "High" empfängt schaltet er eine rote LED aus und eine grüne LED an.
// bei Empfangen des "LOW" Signals wird das grüne LED wieder ausgeschalten und das rote LED eingeschalten.
//
// HSHL-Wiki: http://193.175.248.52/wiki/index.php/Projekt_62:_I2C-Netzwerk_von_MSP430-Launchpads
//************************************************************************************//
// Quellen: Nicholas Zambetti <http://www.zambetti.com>
//************************************************************************************//
//************************************************************************************//
#define LED RED_LED
#include <Wire.h>
void setup()
{
Serial.begin(9600); // starten einer seriellen Ausgabe
Serial.println("Slave receiver.");
Wire.begin(5); // Adressierung wird aus "5" festgelegt (vgl. Mastercode)
Wire.onReceive(receiveEvent);
pinMode(6, OUTPUT); // rotes LED
pinMode(7, OUTPUT); //grünes LED
digitalWrite(6, HIGH); //anschalten des roten LEDs
digitalWrite(7, LOW); // grünes LED ist auf LOW gesetzt
}
void loop()
{
}
// Funktion wird ausgeführt wenn Daten vom Master empfangen werden
void receiveEvent(int howMany)
{
while(Wire.available()) // solange die Verbindung besteht
{
char c = Wire.read(); // Die empfangenen Daten werden als character gespeichert
Serial.print(c); // und ausgegeben.
if(c == 'H')
{
digitalWrite(6, LOW); // rote LED wird ausgeschalten
digitalWrite(7, HIGH); // grüne LED wird eingeschalten
}
else if (c=='L')
{
digitalWrite(6, HIGH); //grüne LED wird ausgeschalten
digitalWrite(7, LOW); //rote LED wird eingeschalten
}
}
}
Programmierung des Slave_01
Programmierung des Slave_02
Der zweite Slave soll die Signale die durch die serielle Schnittstelle eingegeben werden empfangen. Er erhält die Adressierung "5".
Je nach dem welches Signal der Slave empfängt (High oder Low) wird das grüne oder rote LED eingeschalten. Das jeweilig andere LED wird dementsprechend ausgeschalten.
//************************************************************************************//
//************************************************************************************//
// I2C - Netzwerk (Ampelschaltung)
// Slave_02
// Autoren: Anna Neuhaus & Theresa Wunsch
// 05.01.2016
//************************************************************************************//
//
// Über ein I2C Netzwerk werden Daten von einem Master an verschiedene Slaves gesendet.
// Genutzt wird die "Wire.h" Bibliothek
// Hierbei wird ein Sensor sowie eine serielle Schnittstelle zur Eingabe genutzt.
// Der folgende Code betrifft den Slave der durch eine serielle Schnittstelle gesteuert wird.
// Wenn der Slave_01 das Signal "High" empfängt schaltet er eine rote LED aus und eine grüne LED an.
// bei Empfangen des "LOW" Signals wird das grüne LED wieder ausgeschalten und das rote LED eingeschalten.
//
// HSHL-Wiki: http://193.175.248.52/wiki/index.php/Projekt_62:_I2C-Netzwerk_von_MSP430-Launchpads
//************************************************************************************//
// Quellen: Nicholas Zambetti <http://www.zambetti.com>
//************************************************************************************//
//************************************************************************************//
#define LED RED_LED
#include <Wire.h>
void setup()
{
Serial.begin(9600); // starten einer seriellen Ausgabe
Serial.println("Slave receiver.");
Wire.begin(6); // Adressierung wird aus "6" festgelegt (vgl. Mastercode)
Wire.onReceive(receiveEvent);
pinMode(6, OUTPUT); //rotes LED
pinMode(7, OUTPUT); //grünes LED
digitalWrite(6, HIGH); //anschalten des roten LEDs
digitalWrite(7, LOW); // grünes LED ist auf LOW gesetzt
}
void loop()
{
}
// Funktion wird ausgeführt wenn Daten vom Master empfangen werden
void receiveEvent(int howMany)
{
while(Wire.available()) // solange die Verbindung besteht
{
char c = Wire.read(); // Die empfangenen Daten werden als character gespeichert
Serial.print(c); // und ausgegeben
if(c == 'H')
{
digitalWrite(6, LOW); // rote LED wird ausgeschalten
digitalWrite(7, HIGH); // grüne LED wird eingeschalten
}
else if (c=='L')
{
digitalWrite(6, HIGH); //grüne LED wird ausgeschalten
digitalWrite(7, LOW); //rote LED wird eingeschalten
}
}
}
Programmierung des Slave_02
Schaltplan
FRITZING SKIZZE!
Aufbau
Die Realisierung des Projektes 62 ist im folgenden Bild dargestellt:
Es wurde eine Edelstahlplatte gelasert, die einen Kreisverkehr darstellen soll. Dieser verfügt über zwei Fussgängerübergänge mit Ampeln. In der Mitte befindet sich der Master und an den unteren Ecken die beiden Slaves. Der ganze Aufbau wurde wie unter dem Punkt "Schaltplan" dargestellt verkabelt.
Fazit
Ausblick
Durch das Projekt wurde gezeigt wie ein I²C-Netzwerk mittels der MSP430-Launchpads umgesetzt werden kann. Bisher wurde als Sensor ein Taster eingebaut. Zur Weiterentwicklung des Projektes ist hier die Verwendung von weiteren (auch unterschiedlichen) Sensoren möglich. Auch die Ausgabe, die bisher mit LEDs geschieht, könnte erweitert werden. Denkbar sind hier beispielsweise Displays oder die Speicherung als xcl.Tabellen.
Im WiSe16/17 wurden neben dem I²C-Netzwerk weitere Projekte durch die Studenten durchgeführt. Beispiele hierfür sind zum Beispiel ein Wasserstandsanzeiger [1] oder eine Luefersteuerung zur Raumentfeuchtung[2]. Denkbar wäre es diese Projekte über ein I²C-Netzwerk miteinander zu verknüpfen und praktische Anwendungsfelder zu entwickeln. Hierbei wird jedoch empfoheln auf eine Arduino basierte Plattform umzusteigen.
Video
Zu diesem Projekt wurde ein Ergebnisvideo angefertigt. Dieses lässt sich unter dem folgenden Link abrufen
Quellen
[1] Bähring, H. (2010). Anwendungsorientierte Mikroprozessoren. Hagen: Springer Verlag.
[2] Energia. (12. 10 2016). Energia Software. Von About Energia: http://energia.nu/ abgerufen am 10.10.16
[3] Kügele, R., & Wegenast, J. (12. 10 2016). Einführung in Mokrocontroller. Von ELMICRO: https://elmicro.com/files/nwt/mikrocontroller_schuelerheft_v31d.pdf abgerufen am 18.10.16
[4] rn-wissen. (05. 10 2016). Von http://rn-wissen.de/wiki/index.php/Pullup_Pulldown_Widerstand abgerufen am 25.10.16
[5] Sathiyamoorthy, R. (10. 10 2016). I2C-Bus. Von HTI Burgdorf: https://prof.ti.bfh.ch/uploads/media/I2C_bus.pdf abgerufen am 15.11.16