Quelltext der Seite Projekt 62: I2C-Netzwerk von MSP430-Launchpads

[[Kategorie:Projekte]]
'''Autor:''' [[Theresa Wunsch]] | [[Anna Neuhaus]] <br/>

'''Betreuer:''' [[Benutzer:Mirekgoebel| Prof. Göbel]], [[Benutzer:Ulrich_Schneider| Prof. Schneider]] <br/>

----
→ zurück zum Hauptartikel: [[Angewandte_Elektrotechnik_(WS_16/17)|Angewandte Elektrotechnik (WS 16/17)]]

= Aufgabe =

* Erstellung eines Konzepts
* Verschaltung der MSP430-Launchpads >> Schaltplan, Pin-Belegungs-Tabelle (wie werden die Platinen verbunden?)
* Programmierung mittels der Software 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. 
<br><br>


[[Datei:I2C-Netzwerk - sensorgesteuerte Ampelschaltung.png|gerahmt||zentriert|x250px| Programmablaufplan]]
<br>

=Stückliste=

''' 3'''  &nbsp;&nbsp;&nbsp; MSP430g2553 <br>
''' 2'''   &nbsp;&nbsp;&nbsp; Pullup Widerstände ?kOhm<br>
''' 2'''  &nbsp;&nbsp;&nbsp;  LED Grün<br>
''' 2'''  &nbsp;&nbsp;&nbsp;  LED Rot<br>
''' 4'''  &nbsp;&nbsp;&nbsp;  Vorwiderstände für LED 330Ohm<br>
''' 3'''   &nbsp;&nbsp;&nbsp; Steckbretter<br>
'''20'''   &nbsp;&nbsp;&nbsp;Jumper mit unerschiedlicher Farbe<br>
''' 1'''   &nbsp;&nbsp;&nbsp; Grundplatte <br>
<br>
Als Taster wurde der inbuilt Taster des Launchpads verwendet. 
<br>
<br>
('''Zu beachten''': falls die inbuilt LEDs genutzt werden sollen ist zu beachten, dass nur das rote LED genutzt werden kann. <br>
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:

[[Datei:Projektplan Projekt 62 2.jpg|gerahmt||zentriert|x300px| Projektplan im Projekt 62 (WS16/17)]]

=Grundlagen=
Im folgenden Abschnitt werden Grundlagen zu dem verwendeten Bussystem (I²C) und den verwendeten Pull-up/-down Widerständen vermittelt.<br>
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.
<br>
[[Datei:Grundaufbau I2C.jpg|gerahmt||zentriert|x200px| Grundaufbau eines I²C-Bus]]
<br>
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.
<br>
[[Datei:Zwei Phasen der Uebertragung I2C.jpg|gerahmt||zentriert|x200px| Die zwei Phasen der Übertragung auf einem I²C-Bus]]
<br>
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 Adresslängen wird durch eine besondere Belegung der höherwertigen Adressbits vorgenommen (s.o.). 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]

[[Datei:Pull up widerstand.jpg|gerahmt||zentriert|x200px| Beispielschaltung mit einem Pull-up-Widerstand]]

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]

[[Datei:Pull down widerstand.jpg|gerahmt||zentriert|x200px| Beispielschaltung mit einem Pull-doen-Widerstande]]

=MSP430 Launchpad=

Für die Umsetzung des Projektes wurde der Microcontroller MSP430 von Texas Instruments verwendet.<br>
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:


[[Datei:LaunchPadMSP430G2553-v1.4.jpg|gerahmt|zentriert| x200px | Pin-Belegung des MSP430]]

==Energia==
[[Datei:energia.jpg|gerahmt|links| x100px | Logo Energia (Quelle: energia.nu)]] 
<br><br><br><br><br><br><br><br><br>

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. [2],[6]

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.)

=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'''<br>
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.


----

[[Datei:Masterprogrammierung.png|gerahmt|links| x100px | PAP der Programmierung des Masters]]

Der Quelltext kann dem SVN-Ordner entnommen werden. 
*[https://svn.hshl.de/svn/Elektrotechnik_Fachpraktikum/trunk/Projekte/62_I2C_Netzwerk_von_MSP430Launchpads/Programmablaufplan/ SVN-Projektordner]
<br/> 

----
<br/>  
'''Programmierung des Slave_01'''<br>
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. 

<div style="width:65em; height:20em; overflow:auto; border: 2px solid #088">
<source lang=c>
//************************************************************************************//
//************************************************************************************//
// 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
    }
  }
}
</source>
</div>
Programmierung des Slave_01
<br/> 

----
 
<br/>  
'''Programmierung des Slave_02'''<br>
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. 

<div style="width:65em; height:20em; overflow:auto; border: 2px solid #088">
<source lang=c>
//************************************************************************************//
//************************************************************************************//
// 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
    }
  }
}
</source>
</div>
Programmierung des Slave_02

==Schaltplan==

In der folgenden Abbildung ist der realisierte Schaltungsaufbau des Projektes 62 im WS 16/17 dargestellt.

[[Datei:Schaltungsaufbau Projekt 62x.jpg|gerahmt|zentriert|x600px| Schaltungsaufbau Projekt 62 im WS16/17]]

Die Frtizing-Datei findet sich hier:

[[Datei:Schaltungsaufbau Projekt 62.fzz]]

==Aufbau==
Die Realisierung des Projektes 62 ist im folgenden Bild dargestellt:
<br>
[[Datei:Realisierung Projekt 62.JPG|gerahmt|zentriert| x500px | Realisierung des Projektes 62 im WS16/17]]
<br>
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=
Das Auslesen des I²C-Bus zeigt dass die Datenübertragung über das Bussystem einwandfrei funktioniert (vgl. Abbildung). 
<br>
[[Datei:I2c.png|gerahmt|zentriert| x60px | I²C Bus der Ampelschaltung]] 
<br>
Im angefertigten Video (LINK) kann die gewünschte Funktionsweise betrachtet werden.

=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 [http://193.175.248.52/wiki/index.php/Projekt_65:_Wasserstandsmessger%C3%A4t-Aufsatz_f%C3%BCr_Arduino] oder eine Luefersteuerung zur Raumentfeuchtung[http://193.175.248.52/wiki/index.php/Projekt_63:_Luefersteuerung_zur_Raumentfeuchtung_mit_MSP430-Launchpads].
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 [https://youtu.be/26WkutmjKiI]

=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

[6] Fry, B. Reas, R. https://www.processing.org/ abgerufen am 06.01.17

----
→ zurück zum Hauptartikel: [[Angewandte_Elektrotechnik_(WS_16/17)|Angewandte Elektrotechnik (WS 16/17)]]