Teil 1:
Es geht nicht ohne Grundkenntnisse der Programmierung! Aus diesem Grund gibt es hier eine kleine Einführung. Woher bekommt man die Entwicklungsumgebung? Wozu braucht man setup() und loop()? Was sind Konstanten und wofür ist #define? Wie setzt man die Ausgangsspannung an einem Pin?
Teil 2:
Wir schauen die Pin's etwas genauer an und klären, wofür sie verwendet werden können. Befehle wie pinMode(), digitalWrite(), und digitalRead() müssen wir kennen.
Was sind Variablen und wofür kann man sie einsetzen?
Teil 3:
Ohne Schleifen, Bedingungen und Funktionen können wir kein anständiges Programm schreiben. Darum beschäftigen wir und heute damit.
Die Entwicklungsumgebung kann von https://www.arduino.cc/en/Main/Software heruntergeladen werden. Nach der Installation muss noch der Arduino per USB verbunden werden und schon kann das Beispielprogramm Blink ausgeführt werden.
Bereits hier kann man einige grundlegende Dinge der Arduinoprogrammierung erkennen.
So sehen wir zuerst einen Kommentarblock. Mehrzeilige Kommentare werden zwischen /* und */ eingeschlossen. Mit // leitet man einen Kommentar ein, der bis zum Ende der aktuellen Zeile geht.
Zuerst sehen wir die Funktion setup(). Sie wird genau einmal beim Start des Programmes ausgeführt. Darin werden alle notwendigen Initialisierungen vorgenommen. Dadurch wird sichergestellt, dass sich der Arduino beim Start in einem definierten Zustand befindet.
Die eigentliche Arbeit wird in loop() geleistet. Dieser Programmteil wird in einer Schleife immer und immer wieder ausgeführt. Im Gegensatz zu normalen Computer läuft auf dem Arduino nur ein einziges Programm. Dieses wird mit dem Einschalten des Arduinos gestartet und erst durch Abschalten des Stromes beendet.
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
Most Arduinos have an on-board LED you can control. On the Uno and
Leonardo, it is attached to digital pin 13. If you're unsure what
pin the on-board LED is connected to on your Arduino model, check
the documentation at http://www.arduino.cc
This example code is in the public domain.
modified 8 May 2014
by Scott Fitzgerald
*/
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin 13 as an output.
pinMode(13, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
Die Programmiersprache ist C, bezw. C++. Allerdings stehen die Standarlibraries dieser Sprachen nicht vollständig zur Verfügung. Dafür gibt es viele Arduino - spezifische Befehle, die das Programmieren recht einfach machen. Eine Beschreibung findet ihr auf https://www.arduino.cc/en/Reference/HomePage.
Der Arduino besitzt mehrere digitale Ein- und Ausgänge. Ob es ein Ausgang oder ein Eingang ist, bestimmt der Befehl pinMode(). pinMode(LED_PIN,OUTPUT) definiert den Pin als Ausgang. pinMode(EINGANGS_PIN,INPUT) definiert ihn als Eingang. Da er in unbeschaltetem Zustand kein definiertes Eingangssignal besitzt, kann man mit pinMode(EINGANGS_PIN,INPUT_PULLUP) einen internen PullUp - Widerstand hinzuschalten.
Mit digitalWrite() wird der Ausgang gesetzt, mit digitalRead() wird der Eingang abgefragt. Die möglichen Zustände sind HIGH (5V bei einem UNO) und LOW (0V).
Die Bezeichnungen in Grossbuchstaben sind Konstanten. Ihre Werte werden einmal gesetzt und können dann nicht mehr verändert werden. HIGH, LOW, INPUT .. sind vordefinierte Konstanten. LED_PIN und EINGANGS_PIN werden vom Programmierer z. Bsp. mit const int LED_PIN = 8 definiert.
Anstelle von Konstanten könnte man auch #define verwenden. Man muss allerdings beachten, dass das keine Konstante ist. Es handelt sich um ein Makro, das einfach den Text hinter define an der betreffenden Stelle einsetzt.
const int LED_PIN = 8;
const int EINGANGS_PIN = 7;
// Eine andere Möglichkeit:
// #define EINGANGS_PIN 7
void setup() {
pinMode(LED_PIN, OUTPUT);
pinMode(EINGANGS_PIN,INPUT_PULLUP);
}
void loop() {
digitalWrite(LED_PIN,digitalRead(EINGANGS_PIN));
}
Der UNO besitzt 20 Pins, die als Ein- oder Ausgänge benutzt werden können.
Digitale Ausgänge:
Alle 20 Pins können dazu verwendet werden. Sie werden initialisiert mit pinMode(nr,OUTPUT). Für nr können Werte von 0 bis 19 eingesetzt werden. Auf dem Board sind allerdings nur 14 Pins als digital gekennzeichnet. Es ist aber trotzdem möglich, die Analogen Pins A0 bis A5 digital zu verwenden. Sie entsprechen den Nummern 14 bis 19. Anstelle dieser Nummern können auch die Konstanten A0 bis A5 verwendet werden. Die Werte werden mit digitalWrite(nr,HIGH) (setzt den Pin auf 5V) oder digitalWrite(nr,LOW) (setzt den Pin auf 0V) gesetzt.
Digitale Eingänge:
Dazu sind ebenfalls alle 20 Pins geeignet. Die Initialisierung erfolgt mit pinMode(nr,INPUT). Gelesen wird mit digitalRead(nr). Dabei wird HIGH (entspricht 1) oder LOW (entspricht 0) zurückgegeben. Unbeschaltete Eingänge haben keinen definierten Wert. Um Probleme zu vermeiden, sollte hardwaremässig dafür gesorgt werden, dass der Eingangspegel immer definiert ist. Glücklicherweise ist diese Hardware bereits im Arduino eingebaut. Es handelt sich um einen PullUp - Widerstand (Widerstand gegen 5V), der mit pinMode(nr,INPUT_PULLUP) aktiviert werden kann. Damit ist der unbeschaltete Eingang immer auf HIGH. Wenn kein pinMode() gesetzt wird, ist der Pin automatisch als Eingang ohne PullUp geschaltet.
Analoge Ausgänge (PWM):
Diese Bezeichnung ist eigentlich falsch, da der ausgegebene Wert nicht analog ist. Stattdessen wird eine Pulsweitenmodulation (PWM) verwendet, das aus einem digitalen Rechtecksignal besteht, bei dem das Verhältnis von HIGH und LOW festgelegt wird. Es können am UNO nur die Pins 3, 5, 6, 9, 10 und 11 verwendet werden. Sie sind mit dem Zeichen ~ gekennzeichnet. Eine Initialisierung ist nicht notwendig, durch den Befehl analogWrite(nr,wert) wird der Pin automatisch in den erforderlichen Zustand versetzt. Für wert kann eine Zahl zwischen 0 und 255 verwendet werden.
Analoge Eingänge:
Das sind echte analoge Eingänge, die über einen eingebauten Analog - Digitalwandler (ADC) die angelegte Spannung in einen Wert von 0 bis 1023 umrechnen. Die dafür geeigneten Pins sind auf dem Board als analoge Eingänge gekennzeichnet (A0 bis A5). Eine Initialisierung ist nicht notwendig, gelesen werden kann mit analogRead(nr).
Einige Pins können noch Spezialaufgaben erfüllen. Darauf wird aber hier noch nicht eingegangen. Genauere Informationen findet man auf https://www.arduino.cc/en/Main/ArduinoBoardUno. Wichtig sind noch Pin 0 und 1. Diese werden für die serielle Schnittstelle verwendet und sollten möglichst freigehalten werden.
Variablen
Ein wichtiges Konzept jeder Programmiersprache sind die Variablen. Sie haben wie Konstanten einen Namen, einen Typ und einen Wert. Allerdings kann dieser Wert beliebig oft geändert werden. Bedingung ist nur, dass der neue Wert dem definierte Typ entspricht.
Die Definition ist einfach:
int a; // Das ist eine Variable mit dem Namen a, die eine ganze Zahl aufnehmen kann.
float b = 0.5; // Das ist eine Variable mit dem Namen b, die eine Dezimalzahl aufnehmen kann. Der Wer ist zu Beginn auf 0.5 festgelegt.
Die möglichen Typen sind auf https://www.arduino.cc/en/Reference/HomePage unter Data Types angegeben. Strings und Arrays sind Spezialfälle, die später besprochen werden.
Schleifen, Bedingungen, Funktionen und weitere Konstrukte
Eine gute deutschsprachige Einführung findet ihr im Arduino - Programmierhandbuch von Netzmafia.