Entwicklung

Ampelschaltung mit Arduino

Dieser Artikel ist älter als zwei Jahre und womöglich veraltet!

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:

Schaltbild

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:

void setup(){

}

void loop(){

}

Als nächstes definieren wir nun am Beginn die digitalen Ausgänge der LEDs:

// Seite 1
int g_1 = 2;    // Grün
int y_1 = 3;    // Gelb
int r_1 = 4;    // Rot

// Seite 2
int g_2 = 8;    // Grün
int y_2 = 7;    // Gelb
int r_2 = 5;    // Rot

Im Setup-Teil des Programms werden dazu mittel pinMode( ) die Typen der Pins definiert:

pinMode(g_1, OUTPUT);
pinMode(y_1, OUTPUT);
pinMode(r_1, OUTPUT);

pinMode(g_2, OUTPUT);
pinMode(y_2, OUTPUT);
pinMode(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.

// Starteinstellung
digitalWrite(r_1, HIGH);    // Rot auf 1 ein
digitalWrite(g_2, HIGH);    // Grün auf 2 ein

// Grünphase von 2
delay(5000);                // Ampelphase mit z.B. 5 Sekunden Länge

// Ende der Grünphase von 2
blink(g_2, 4);                // Blinken am Ende der Grünphase
digitalWrite(g_2, LOW);        // Gründe Licht aus
digitalWrite(y_2, HIGH);    // Gelbes Licht ein
delay(1000);                
digitalWrite(y_2, LOW);        // Gelbes Licht aus
digitalWrite(r_2, HIGH);    // Rotes Licht ein

// Beginn der Grünphase von 1
delay(1000);
digitalWrite(y_1, HIGH);
delay(1000);
digitalWrite(r_1, LOW);
digitalWrite(y_1, LOW);
digitalWrite(g_1, HIGH);

// Grünphase von 1
delay(5000);

// Ende der Grünphase von 1
blink(g_1, 4);
digitalWrite(g_1, LOW);
digitalWrite(y_1, HIGH);
delay(1000);
digitalWrite(y_1, LOW);
digitalWrite(r_1, HIGH);
delay(1000);

// Beginn der Grünphase von 2
digitalWrite(y_2, HIGH);
delay(1000);
digitalWrite(r_2, LOW);
digitalWrite(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.

void blink(int pin, int times){
	for(int i = 0; i < times; i++){
		digitalWrite(pin, LOW);
		delay(500);
		digitalWrite(pin, HIGH);
		delay(500);
	}
}

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:

int g_1 = 2;
int y_1 = 3;
int r_1 = 4;

int g_2 = 8;
int y_2 = 7;
int r_2 = 5;

void setup() {
	pinMode(g_1, OUTPUT);
	pinMode(y_1, OUTPUT);
	pinMode(r_1, OUTPUT);

	pinMode(g_2, OUTPUT);
	pinMode(y_2, OUTPUT);
	pinMode(r_2, OUTPUT);
}

void loop(){
	digitalWrite(r_1, HIGH);
	digitalWrite(g_2, HIGH);
	delay(5000);
	blink(g_2, 4);
	digitalWrite(g_2, LOW);
	digitalWrite(y_2, HIGH);
	delay(1000);
	digitalWrite(y_2, LOW);
	digitalWrite(r_2, HIGH);
	delay(1000);
	digitalWrite(y_1, HIGH);
	delay(1000);
	digitalWrite(r_1, LOW);
	digitalWrite(y_1, LOW);
	digitalWrite(g_1, HIGH);
	delay(5000);
	blink(g_1, 4);
	digitalWrite(g_1, LOW);
	digitalWrite(y_1, HIGH);
	delay(1000);
	digitalWrite(y_1, LOW);
	digitalWrite(r_1, HIGH);
	delay(1000);
	digitalWrite(y_2, HIGH);
	delay(1000);
	digitalWrite(r_2, LOW);
	digitalWrite(y_2, LOW);
}

void blink(int pin, int times){
	for(int i = 0; i < times; i++){
		digitalWrite(pin, LOW);
		delay(500);
		digitalWrite(pin, HIGH);
		delay(500);
	}
}

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.