Die MSP430 ist ein 16-Bit-Mikrocontroller von Texas Instruments. Er ist besonders für die Anwendung mit niedrigem Stromverbrauch optimiert. Den Controller kann man mit den Programmiersprachen C oder auch Assembler programmieren. Typische Anwendungen des Controllers sind heut zu Tage z.B. Wärmezähler, Tauchcomputer, aber auch Blutdruckmessgeräte.
Texas Instruments stellt für die MSP430 Entwicklungssysteme zu Verfügung, wie z.B. das MSP430 Launchpad, welches wir haben und sehr beliebt ist wegen des geringen Preises.
Die MSP430 hat 20 verschiedene Pins mit unterschiedlichen Funktionen.
- VCC: An VCC liegt immer 3,3V Spannung an.
- GND: GND steht für Ground und hat immer 0V Spannung.
- Hardware an Pins: Diese Pins sind auch mit der Hardware direkt verbunden. Pin 2 und 14 sind hier bei für die rote und grüne LED, Pin 5 und 16 als einfacher Taster und Reset-Button.
- analoge Ausgänge: 7 ports sind analoge Ausgänge und können somit ein Potential zwischen 0,0V und 3,3V anlegen. (ports 4, 9, 10, 12, 13, 14, 19)
- analoge Eingänge: 8 ports sind analoge Eingäne und können somit physikalische Größen messen. (ports 2, 3, 4, 5, 6, 7, 14, 15)
- Die anderen Ports haben sich variierende Möglichkeiten. SIe können z.B. analog und/oder digital sein, haben aber teils auch andere Funktionen.- Tips: ... reserviert werden sollten die ports
✔ analoge Eingänge: ports 2, 5, 6, 7 (können ferner auch als digitale Ein- / Ausgänge verwendet werden)
✗ 16 und 17 für spy-bi-wire
✗ 18 und 19 für den Anschluss eines Quarzkristalls
✗ 3 und 4 für eine serielle Kommunikation mit einem angeschlossenen Computer
... vorzugsweise verwendet werden als:
✔ digitale Ein-/Ausgänge: ports 8, 11 (können nur als solche verwendet werden)
✔ analoge Ausgänge: ports 9, 10, 12, 13, 14, 15 (können als digitale und analoge Ein- und Ausgänge verwendet werden)
ⓘ ports können durch ihre Nummer (2-19) oder besondere Bezeichnung benannt werden (z.B. P1_0 oder RED_LED) (Quelle: http://msp430g2.blogspot.de/p/1-msp430-tips-n-sketches.html )
✗ 16 und 17 für spy-bi-wire
✗ 18 und 19 für den Anschluss eines Quarzkristalls
✗ 3 und 4 für eine serielle Kommunikation mit einem angeschlossenen Computer
... vorzugsweise verwendet werden als:
✔ digitale Ein-/Ausgänge: ports 8, 11 (können nur als solche verwendet werden)
✔ analoge Ausgänge: ports 9, 10, 12, 13, 14, 15 (können als digitale und analoge Ein- und Ausgänge verwendet werden)
ⓘ ports können durch ihre Nummer (2-19) oder besondere Bezeichnung benannt werden (z.B. P1_0 oder RED_LED) (Quelle: http://msp430g2.blogspot.de/p/1-msp430-tips-n-sketches.html )
Programmieren der MSP
Als Programm zum Programmieren der MSP verwende ich Energia (http://energia.nu/), da es Freeware ist. Zum installieren muss man den heruntergeladenen Ordner einfach nur in das gewünschte Verzeichnis entpacken.
Ein Programmcode der MSP wird als Sketch bezeichnet. Er hat vollgende Grundstruktur:
|Sketch|
/*Konstanten(1. Buchstabe groß) und Variablen(1. Buchstabe klein) werden am Anfang eines Programms definiert. Bsp einer Konstanten:*/
const int PortGrueneLED = 14
void setup ( )
{
/*dieser Teil des Programms läuft nur einmal ab und dient deswegen zum einstellen des Pinmodes oer zum Start der seriellen Kommunikation. Auch die Zeichenanzahl pro Zeile für einen LCD kann hier festgelegt werden.*/
}
void loop ( )
{
//hier befindet sich das eigentliche Programm(der Programmcode), welches unendlich oft abläuft.
}
--------------------------
//:Kennzeichen für einen einzeiligen Kommentar
/* [...] */: Einklammerung eines mehrzeiligen Kommentars
Kommentare sind im späteren Programm wichtig für das nachvollziehen des Programms von Anderen, aber auch für einen selbst. Somit sollte man so oft wie möglich einen Kommentar schreiben um später alles nachvollziehen zu können und auch mögliche Denkfehler zu erkennen.
Bevor man das geschriebene Programm auf die MSP übertragen kann muss man noch ein paar Sachen einstellen:
- Tools > Board > Launchpad w/ msp430
- Tools > Serial Port > COM (in der Regel die höchste Nummer)
Ausgänge ansteuern
Mit der MSP430 kann man analoge und digitale Ports ansteuern(siehe "Die MSP430). Hierfür gibt es allgemeine Anweisungen, aber auch spezifische für Bauteile.
digitalen Port steuern
|Sketch|
void setup ( )
{
pinMode(2, OUTPUT); /*pinMode definiert einen Port als In- oder Output. In diesem Fall Port 2 als Output */
}
void loop ( )
{
digitalWrite (2, HIGH); //digitalWrite legt in diesem Fall 3,3V an Port 2 an
delay (1000); //1000ms Verzögerung bzw Pause
digitalWrite (2, LOW); //digitalWrite legt wieder 0V Spannung an den Port 2 an
delay (1000); //1000ms Verzögerung bzw Pause
}
--------------------------pinMode(*Port*, *In- oder Output*): definiert einen Port als In- oder Output
digitalWrite(*Port*, *HIGH oder LOW*): setzt einen digitalen Port entweder HIGH(3,3V) oder LOW(0V)
delay(*zeit(in ms)*): Pausiert das Programm für die Vorgeschriebene Zeit
analogen Port steuern
|Sketch|
void setup ( )
void setup ( )
{
//für analoge Ports muss kein pinMode verwendet werden
}
void loop ( )
{
analogeWrite(10, 255); //an Port 10 liegen 3,3V an
delay(500); //Pause
analogeWrite(10, 0); //an Port 10 liegen 0V an
delay(500); //Pause
}
--------------------------
analogeWrite(*port*, *Spannung*): legt zwischen 0V und 3,3V Spannung an. Der Wert der Spannung wird durch Zahlen zwischen 0 und 255 angegeben.
Die analoge Steuerung eines ports läuft mittels Pulsweitenmodulation (PWM. Das heißt, dass bei analogeWrite(10, 127) die Hälfte der Zeit die Ausgangsspannung LOW und die andere Hälfte der Zeit HIGH ist.
analogeWrite(*port*, *Spannung*): legt zwischen 0V und 3,3V Spannung an. Der Wert der Spannung wird durch Zahlen zwischen 0 und 255 angegeben.
Die analoge Steuerung eines ports läuft mittels Pulsweitenmodulation (PWM. Das heißt, dass bei analogeWrite(10, 127) die Hälfte der Zeit die Ausgangsspannung LOW und die andere Hälfte der Zeit HIGH ist.
|Sketch|
int z = 20; //legt den Wert von der Variable z auf 20 fest
int z = 20; //legt den Wert von der Variable z auf 20 fest
void setup ( )
{
Serial.begin(9600); //serieller Port mit Datenrate 9600bps
}
void loop ( )
{
Serial.print("Wert der Variable z: "); //"Wert der Variable z: " wird angezeigt
Serial.printin(z); //Wert der Variable z wird angezeigt
z++; //z wird um 1 erhöht
delay(1000);
}
--------------------------
Serial.begin(*Anzahl der bps): öffnet einen seriellen Port und legt die Datenrate fest
Serial.begin(*Anzahl der bps): öffnet einen seriellen Port und legt die Datenrate fest
Serial.print("*text*"):Eine Nachricht die angezeigt wird (ohne Zeilenumbruch)
Serial.printin("*text*"): Eine Nachricht die angezeigt wird (mit Zeilenumbruch)
Man kann ohne die Anführungszeichen auch Variablen anzeigen lassen.
Messen mit der MSP430
Man kann mit der MSP430 auch Werte aus z.B. Sensoren ermitteln und somit die Umwelt beachten. Dies geht wie mit den Ausgängen analog, aber auch digital.
Variablen, rechnen mit Variablen
|Sketch|
int x = 4; //x ist 4 für energia
int x = 4; //x ist 4 für energia
int y = 2 ; //y ist 2 für energia
void setup ( )
{
Serial.begin(9600);
int addieren = x + y;
int substrahieren = x - y;
int multiplizieren = x * y;
int dividieren = x / y;
}
void loop ( )
{
Serial.printin("Allle Rechen operatoren:");
Serial.printin(addieren);
Serial.printin(substrahieren);
Serial.printin(multiplizieren);
Serial.printin(dividieren);
x++;
y--;
delay(2000);
}
--------------------------
int: Legt eine frei benennbare Variable fest(keine Umlaute!), die mit einem Wert belegt werden kann. Somit kann man z.B. einem Port einen Namen geben um den Programmcode leicht verständlicher zu machen, oder aber auch bei einer Port-Änderung nur an einer Stelle die Zahl ändern zu müssen.
Die Rechenoperatoren werden folgend dargestellt: (arithmetische Operatoren)
int: Legt eine frei benennbare Variable fest(keine Umlaute!), die mit einem Wert belegt werden kann. Somit kann man z.B. einem Port einen Namen geben um den Programmcode leicht verständlicher zu machen, oder aber auch bei einer Port-Änderung nur an einer Stelle die Zahl ändern zu müssen.
Die Rechenoperatoren werden folgend dargestellt: (arithmetische Operatoren)
- Addition: x + y
- Substraktion: x - y
- Multiplikation: x * y
- Division: x / y
Bei der Opperation werden die Datentypen beibehalten. So können Integer keine Nachkommastellen angeben und so wird das Ergebnis Auf- oder Abgerundet. Wenn Operanden 2 unterschiedliche Datentypen haben, dann wird der größere genommen.
Es gibt außerdem noch gemischte Zuweisungen, bei denen arithmetische Operatoren mit einer Variablen Zuweisung verbunden werden:
- x++ = x = x + 1
- x-- = x = x - 1
- x+= y = x = x + y
- x -= y = x = x - y
- x *= y = x = x * y
- x /= y = x = x / y
Gemischte Zuweisungen werden Hauptsächlich in Schleifen verwendet.
Datentypen:
byte:
- speichert 8 bit numerischen ganzzahligen Wert ohne Dezimalkomma (von 0 bis 255)
int:
- speichert 16 bit numerischen ganzzahligen Wert ohne Dezimalkomma (von -32.767 bis 32.768)
long:
- speichert 32 bit numerischen ganzzahligen Wert ohne Dezimalkomma (von -2,147,483,648 bis 2,147,483,647)
float:
- speichert 32 Fliesskomma Zahlen oder Nummern mit Nachkommastellen (von -3.4028235E+38 bis 3.4028235E+38)
Messen an digitalen Eingängen
void loop ( )
Messen an analogen Eingängen
|Sketch|
void setup ( )
|Sketch|
Messen an digitalen Eingängen
|Sketch|
int wechselschalter = 10;
int wechselschalter = 10;
int led = 2;
int Schalterzustand = 0;
void setup ( )
{
pinMode(led, OUTPUT);
pinMode(wechselschalter, INPUT);
}
void loop ( )
{
Schalterzustand = digitalRead(Wechselschalter); /*liest Spannung am Port 10 ab und überschreibt "Schalterzustand" */
digitalWrite(LED, HIGH);
}
--------------------------
digitalRead(*Port*): Liest die Spannung an einem Port ab, kann aber nur zwischen 3,3V und 0V unterscheiden. Dies ist geeignet für Schalter, da diese entweder die ganze Spannung durch lassen, oder gar keine.
digitalRead(*Port*): Liest die Spannung an einem Port ab, kann aber nur zwischen 3,3V und 0V unterscheiden. Dies ist geeignet für Schalter, da diese entweder die ganze Spannung durch lassen, oder gar keine.
Schalter: Es gibt 2 Möglichkeiten Schalter(mit Bsp. Taster) in eine Schaltung einzubauen:
- mit einem pullup-Wiederstand; hierbei wird der Taster zwischen der Spannungsquelle und GND eingebaut und ein Wiederstand zwischen der Spannungsquelle und dem Eingang. Dadurch erhält man ein logisches LOW wenn man den Taster drückt.
- mit einem pulldown-Wiederstand; hierbei wird der Taster zwischen der Spannungsquelle und dem Eingang eingebaut und ein Wiederstand zwischen der Spannungsquelle und GND. Dadurch erhält man ein logisches HIGH wenn man den Taster drückt.
http://www.elektronik-kompendium.de/public/schaerer/pullr.htm
Messen an analogen Eingängen
|Sketch|
void setup ( )
{
Serial.begin(9600);
}
void loop ( )
{
int sensorWert = analogRead(A0);
Serial.printin(sensorWert);
delay(1000);
}
--------------------------
analogRead(*Pin*): Liest die Spannung eines analogen Pins aus. Dabei sind 0V 0 und 3,3V 1023. Analoge Pins müssen nicht zuerst als Eingang definiert werden um einen Wert aus ihnen abzulesen.
analogRead(*Pin*): Liest die Spannung eines analogen Pins aus. Dabei sind 0V 0 und 3,3V 1023. Analoge Pins müssen nicht zuerst als Eingang definiert werden um einen Wert aus ihnen abzulesen.
Potentiometer: Mit einem Potentiometer kann man die Spannung meist mit einem Rad verstellen. Er hat 3 Anschlüsse: linker Außenkontakt(an Masse anschliesen), Schleiferkontakt(an Pin anschließen), rechter Außenkontakt(an VCC anschließen). In der Mitte des Potentiometers ist ein Schleifer, der an einer Kohlebahn schleift. Durch das Drehen verlängert/verkürzt sich der Weg, den der Strom durchlaufen muss und somit auch die stärke des Wiederstandes.
http://www.gassel-online.de/physik/stat8/bild_p5.gif
Control Structures
Unter Control Structures versteht man die ganzen Schleifen, aber auch Unterprogramme und Entscheidungen. Vorallem die "If else"-Entscheidung ist entscheidend für das Programmieren und kann auch nicht umschrieben werden.
Entscheidungen mit if ( ) { } else { }
Control Structures
Unter Control Structures versteht man die ganzen Schleifen, aber auch Unterprogramme und Entscheidungen. Vorallem die "If else"-Entscheidung ist entscheidend für das Programmieren und kann auch nicht umschrieben werden.
Entscheidungen mit if ( ) { } else { }
|Sketch|
int led = 2;
int schalter = 10;
void setup ( )
int schalter = 10;
void setup ( )
{
pinMode(led, OUTPUT);
pinMode(schalter, INPUT);
}
void loop ( )
{
schalterWert = digitalRead(schalter);
if (schalterWert == 0) {
digitalWrite(led, LOW);
}
else {
digitalWrite(led, HIGH);
}
}
--------------------------
pinMode(led, OUTPUT);
pinMode(schalter, INPUT);
}
void loop ( )
{
schalterWert = digitalRead(schalter);
if (schalterWert == 0) {
digitalWrite(led, LOW);
}
else {
digitalWrite(led, HIGH);
}
}
--------------------------
if (*Bedingung*) {*bei wahrer Bedingung*} else {*bei falscher Bedingung*}: Die if ( ) { } else ( ) Entscheidung hat zunächst eine Bedingung, die sie am Anfang überprüft. Ist diese wahr, springt das Programm direkt unter den if-Teil und führt die Befehle aus. Ist die Bedingung falsch, so springt das Programm hinter den else-Teil und führt die Befahle aus. Dannach läuft das Programm normal weiter.
Zählschleifen mit for ( ) { }
|Sketch|
void setup ( )
{
pinMode(2, OUTPUT)
pinMode(3, OUTPUT)
pinMode(4, OUTPUT)
pinMode(5, OUTPUT)
pinMode(6, OUTPUT)
pinMode(7, OUTPUT)
pinMode(8, OUTPUT)
pinMode(9, OUTPUT)
pinMode(10, OUTPUT)
}
void loop ( )
{
for (int licht = 2 ; licht <= 10; licht += 1)
{
digitalWrite(licht, HIGH):
delay(100);
}
}
--------------------------
for (*Startwert Variable*; *Endwert Variable*; *Schrittweite*) {*Befehle*}: Für die for ( )-Schleife muss am Anfang ein Startwert einer Variable gegeben werden und dannach der Wert den sie maximal oder auch minimal erreichen soll. Die Schrittweite bestimmt wie viel jede Wiederholung dazu addiert/substrahiert/... wird. Anschließend schreibt man Befehle, die das Programm dann abspielt. Hierbei wird meistens die Variable, die erhöht wird, genommen, wodurch z.B. mit jeder Wiederholung der Ton höher wird.
Unterprogramme
Unterprogramme
|Sketch|
int ledrot = 2;
int ledgruen = 14;
int ledgruen = 14;
void setup ( )
{
pinMode(2, OUTPUT)
pinMode(14, OUTPUT)
}
void loop ( )
{
blinklicht ( );
delay(1000)
}
void blinklicht ( )
{
digitalWrite(ledrot, HIGH)
delay(500)
digitalWrite(ledrot, LOW)
digitalWrite(ledgruen, HIGH)
delay(500)
digitalWrite(ledgruen, LOW)
}
--------------------------
void *Unterprogrammname* ( ) {*Befehle*}: Hiermit kann man ein Unterprogramm definieren, welches abgerufen wird, wenn der Programmname im Hauptprogramm genannt wird. anschließend springt das Programm wieder an die Stelle wo es in das Unterprogramm gekommen ist. Dies ist vor allem dann nützlich, wenn man eine bestimmte Befehlskette öfters benötigt. Dann kann man ein Unterprogramm mit der Befehlskette definieren und es ist platzsparend und leichter lesbar.
Keine Kommentare:
Kommentar veröffentlichen