Da ich mich jetzt im Besitz eines Arduino Mikrocontroller-Boardes befinde, nun ein erster Artikel über dieses faszinierende Stück Technik. Mit einem Arduino kann man einfach Elektronik ansteuern, wie zum Beispiel LEDs, Servos, Temperatursensoren usw., indem man ein Programm am Computer programmiert und dann über ein USB-Kabel auf das Board überträgt.
Für meinen ersten Artikel über dieses Thema habe ich mich für eine Ampelschaltung entschieden. Zwei Seiten einer Ampel, zum Beispiel bei einer Baustelle, sollen gesteuert werden. Wie bei einer österreichischen Straßenampel soll die Ampel außerdem grün blinken können.
Hardware
Ich habe dazu einen Arduino Uno und folgenden Aufbau verwendet:
Achtung: Ich habe in diesem Aufbau die Widerstände für die Einfachheit weggelassen! Bitte LEDs nie ohne Vorwiderstand betreiben!
Jede LED ist dabei einzeln über einen Digitalport ansteuerbar. Ich habe aus Platzgründen die Ports 2,3,4,5,7 und 8 dafür verwendet.
Programmierung
Wie bei jedem Arduino-Sketch beginnt auch dieses Programm mit den beiden wohlbekannten Funktionen:
1void setup(){
2
3}
4
5void loop(){
6
7}Als nächstes definieren wir nun am Beginn die digitalen Ausgänge der LEDs:
1// Seite 1
2int g_1 = 2; // Grün
3int y_1 = 3; // Gelb
4int r_1 = 4; // Rot
5
6// Seite 2
7int g_2 = 8; // Grün
8int y_2 = 7; // Gelb
9int r_2 = 5; // Rot
Im Setup-Teil des Programms werden dazu mittel pinMode( ) die Typen der Pins definiert:
1pinMode(g_1, OUTPUT);
2pinMode(y_1, OUTPUT);
3pinMode(r_1, OUTPUT);
4
5pinMode(g_2, OUTPUT);
6pinMode(y_2, OUTPUT);
7pinMode(r_2, OUTPUT);Kommen wir nun zum eigentlichen Ampel-Programm. Dieser Teil des Codes befindet sich, damit er sich am Ende wiederholt, im loop( )-Teil. Ich habe dazu einfach nacheinander, unterbrochen mit delay( ) Aufrufen, die Vorgänge der Ampelschaltung prozedural programmiert. Natürlich wäre der Code mit OOP wesentlich übersichtlicher, dafür auch für den Anfang schwerer zu verstehen.
1// Starteinstellung
2digitalWrite(r_1, HIGH); // Rot auf 1 ein
3digitalWrite(g_2, HIGH); // Grün auf 2 ein
4
5// Grünphase von 2
6delay(5000); // Ampelphase mit z.B. 5 Sekunden Länge
7
8// Ende der Grünphase von 2
9blink(g_2, 4); // Blinken am Ende der Grünphase
10digitalWrite(g_2, LOW); // Gründe Licht aus
11digitalWrite(y_2, HIGH); // Gelbes Licht ein
12delay(1000);
13digitalWrite(y_2, LOW); // Gelbes Licht aus
14digitalWrite(r_2, HIGH); // Rotes Licht ein
15
16// Beginn der Grünphase von 1
17delay(1000);
18digitalWrite(y_1, HIGH);
19delay(1000);
20digitalWrite(r_1, LOW);
21digitalWrite(y_1, LOW);
22digitalWrite(g_1, HIGH);
23
24// Grünphase von 1
25delay(5000);
26
27// Ende der Grünphase von 1
28blink(g_1, 4);
29digitalWrite(g_1, LOW);
30digitalWrite(y_1, HIGH);
31delay(1000);
32digitalWrite(y_1, LOW);
33digitalWrite(r_1, HIGH);
34delay(1000);
35
36// Beginn der Grünphase von 2
37digitalWrite(y_2, HIGH);
38delay(1000);
39digitalWrite(r_2, LOW);
40digitalWrite(y_2, LOW);Zum Blinken der Ampel habe ich eine Funktion namens blink( ) verwendet. Diese stellt das Blinken der grünen Lampe am Ende der Grünphase in Österreich nach.
1void blink(int pin, int times){
2 for(int i = 0; i < times; i++){
3 digitalWrite(pin, LOW);
4 delay(500);
5 digitalWrite(pin, HIGH);
6 delay(500);
7 }
8}Zusammenfassung
Mit diesem Code kann man nun bereits die “Ampelanlage” steuern. Sie sollte sich wie bei echten Vorbild verhalten. Hier nochmal der gesamte Code des Programmes:
1int g_1 = 2;
2int y_1 = 3;
3int r_1 = 4;
4
5int g_2 = 8;
6int y_2 = 7;
7int r_2 = 5;
8
9void setup() {
10 pinMode(g_1, OUTPUT);
11 pinMode(y_1, OUTPUT);
12 pinMode(r_1, OUTPUT);
13
14 pinMode(g_2, OUTPUT);
15 pinMode(y_2, OUTPUT);
16 pinMode(r_2, OUTPUT);
17}
18
19void loop(){
20 digitalWrite(r_1, HIGH);
21 digitalWrite(g_2, HIGH);
22 delay(5000);
23 blink(g_2, 4);
24 digitalWrite(g_2, LOW);
25 digitalWrite(y_2, HIGH);
26 delay(1000);
27 digitalWrite(y_2, LOW);
28 digitalWrite(r_2, HIGH);
29 delay(1000);
30 digitalWrite(y_1, HIGH);
31 delay(1000);
32 digitalWrite(r_1, LOW);
33 digitalWrite(y_1, LOW);
34 digitalWrite(g_1, HIGH);
35 delay(5000);
36 blink(g_1, 4);
37 digitalWrite(g_1, LOW);
38 digitalWrite(y_1, HIGH);
39 delay(1000);
40 digitalWrite(y_1, LOW);
41 digitalWrite(r_1, HIGH);
42 delay(1000);
43 digitalWrite(y_2, HIGH);
44 delay(1000);
45 digitalWrite(r_2, LOW);
46 digitalWrite(y_2, LOW);
47}
48
49void blink(int pin, int times){
50 for(int i = 0; i < times; i++){
51 digitalWrite(pin, LOW);
52 delay(500);
53 digitalWrite(pin, HIGH);
54 delay(500);
55 }
56}Natürlich kann man das typisch österreichische Ampelblinken auch weglassen und das Programm objektorient neu schreiben, aber an diesem Beispiel sieht man recht deutlich wie einfach und schnell sich so eine eigentlich komplexe Schaltung mittels Arduino verwirklichen lässt.
Der gesamte Code dieses Beispiels steht unter der CC-BY-SA-Lizenz.
