Es wäre doch toll, wenn wir beim Spielen mit den Duplos auch so eine Ampel hätten, wie beim Fahrradfahren. Also Laptop mit in die Werkstatt genommen und für die Kinder bzw. für die Duplo Fahrzeuge eine Ampel gebaut. Damit war aber niemand zufrieden, denn wie soll mal mit einer Ampel spielen, die sich nicht drücken lässt. Also gleich noch einmal Laptop in die Werkstatt und Ampel 2.0 gebaut. Diesesmal mit einem Taster für die Fußgänger.

 Fußgänger- und Autofahrerampel mit Arduino:

Eigentlich ist es nur ein Lauflicht, das gestartet wird, wenn der Taster gedrückt wird. Die Ampelfolge ist klar, die Autos haben grün und die Fußgänger rot. Nach drücken des Taster schaltet die Autoampel über gelb auf rot und die Fußgängerampel wird grün. In umgekehrter Reihenfolge bekommen die Autos wieder grün und die Fußgänger rot. Eigentlich ganz einfach, wie Verdrahtung seht ihr auf dem Breadbord. 

Ampelcode für Arduino:

 // www.kreativekiste.de

// Ampelschaltung Fußgänger 1.3

int _ABVAR_1_zeit = 0 ;void setup()
{
pinMode( 2, INPUT);
pinMode( 5 , OUTPUT);
pinMode( 6 , OUTPUT);
pinMode( 4 , OUTPUT);
pinMode( 3 , OUTPUT);
pinMode( 7 , OUTPUT);
_ABVAR_1_zeit = 3000 ;}

void loop()
{
digitalWrite( 5 , HIGH );
digitalWrite( 6 , HIGH );
if (digitalRead(2))
{
digitalWrite( 5 , LOW );
digitalWrite( 4 , HIGH );
delay( _ABVAR_1_zeit );
digitalWrite( 4 , LOW );
digitalWrite( 3 , HIGH );
delay( _ABVAR_1_zeit );
digitalWrite( 6 , LOW );
digitalWrite( 7 , HIGH );
delay( 6000 );
digitalWrite( 7 , LOW );
digitalWrite( 6 , HIGH );
delay( 2000 );
digitalWrite( 4 , HIGH );
delay( _ABVAR_1_zeit );
digitalWrite( 3 , LOW );
digitalWrite( 4 , LOW );
}
}

 So könnte die Ampel aus dem 3D-Drucker dann später aussehen. Ich habe mit einer rel. niedrigen Auflösung gearbeitet und sie sollte dann später mal schwarz werden aber so für das erste mal ganz net. 

Ampel 2.0 mit permanenten Autoverkehr bzw. dauerhaften Ampelphasen:

So ganz zufrieden waren die Kinder dann doch nicht. Die Lichter der Ampel sollten sich doch bitte die ganze Zeit bewegen. Es sollte also eine richtige Verkehrsampel werden, bei der die Autos permanent fahren und die Fußgänger warten müssen, bis die Ampelphase der Autos zu Ende ist, bis sie über die Straße gehen können. In der GIF Animation könnt ihr die Ampelphasen sehen, wobei die Zeiten in dem Arduino Code dann langsamer sind. 

Das ist aber „für mich" mit dem Arduino gar nicht so einfach, weil dazu Interrupts benötigt werden und die Zeiten recht genau definiert werden müssen. Außerdem ist es recht komplex die Ampel so zu programmieren, dass die Fußgänger wirklich nur bzw. erst dann grün bekommen, wenn die Autofahrer Rotlicht haben.

Wer dennoch mit dem Arduino eine Ampel bauen möchte und keine Interrupts programmieren möchte oder kann, sollte alternativ einen RS-Flip-Flop verwenden. Zum Beispiel den CD4043. Dieser Flip Flop "merkt" sich den gedrückten Taster, bis er nach dem Abfragen resetet wird. 

Deshalb habe ich einfach zwei Attiny 45 verwendet. Zum Einen spare ich mir die Programmierung der Interrupt und der Zeiten, zum Anderen spare ich eine menge Geld, da ein Attiny unter einem Euro kostet. Hier der Aufbau auf dem Breadbord. Eine Anleitung zum Programmieren von Attinys mit dem Arduino findet ihr online.

Eine Anleitung wie Attinys mit dem Arduino programmiert werden, findet ihr hier auf meiner Seite.

Wie das geht? Ganz einfach!

• Attiny 1
  • Das Ampelprogramm für die Autofahrer läuft in einer WIHLE Schleife, also rot, rot-gelb, grün usw.
    • In der Hälfte der Rotphase prüft das Programm den PIN 3
    • Ist dieser HIGH bleibt das Programm „stehen"
      • PIN 4 wird auf HIGH geschaltet
    • Ist PIN 3 wieder LOW, wird PIN 4 auf LOW geschaltet und das Ampelprogramm läuft in der WIHLE Schleife weiter
• Attiny 2
  • Setzt Attiny 2 den PIN 4 auf LOW, damit ist PIN 3 von Attiny 1 wieder LOW und das Ampelprogramm für die Autofahrer kann wieder starten
  • Setzt die rote LED auf HIGH, also haben die Fußgänger rot und müssen warten
  • Das Programm prüft PIN 0 und 3
    • Ist PIN 0 HIGH, hat ein Fußgänger den Taster betätigt
    • PIN 4 HIGH geschaltet
      • Damit ist PIN 3 von Attiny 1 HIGH und hält das Programm bei der nächsten Rotphase an
      • Ist diese Rotphase erreicht, wird PIN 3 von Attiny 2 HIGH. Nun weiß das Programm, dass für die Autos rot ist und startet das Ampelprogramm für die Fußgänger.
        • Ist das Ampelprogramm der Fußgänger zu Ende
• Und das ganze Programm beginnt wieder von vorne

Damit das Ganze etwas übersichtlicher wird, hier das Ampel Programm von Attiny 1 mit Ardublock dargestellt:

Hier das Ampel Programm von Attiny 2 mit Ardublock dargestellt:

Wenn ihr euch so eine Ampel nachbauen wollt, die beiden Codes bzw. Programme auf die Attiny spielen und wie auf dem Breadbord angegeben verdrahten. 

Programm für Attiny 1:

 // www.kreativekiste.de//

Ampelschaltung Fußgänger 2.7

void setup()
{
pinMode( 3, INPUT);
pinMode( 0 , OUTPUT);
pinMode( 4 , OUTPUT);
pinMode( 1 , OUTPUT);
pinMode( 2 , OUTPUT);
}

void loop()
{
digitalWrite( 0 , HIGH );
delay( 2500 );
while ( digitalRead(3) )
{
digitalWrite( 4 , HIGH );
}digitalWrite( 4 , LOW );
digitalWrite( 0 , HIGH );
delay( 2000 );
digitalWrite( 1 , HIGH );
delay( 1500 );
digitalWrite( 0 , LOW );
digitalWrite( 1 , LOW );
delay( 10 );
digitalWrite( 2 , HIGH );
delay( 3500 );
digitalWrite( 2 , LOW );
digitalWrite( 1 , HIGH );
delay( 2000 );
digitalWrite( 1 , LOW );
}

Programm für Attiny 2:

 // www.kreativekiste.de

// Ampelschaltung Fußgänger 2.7 

void setup()
{
pinMode( 3, INPUT);
pinMode( 0, INPUT);
pinMode( 1 , OUTPUT);
pinMode( 4 , OUTPUT);
pinMode( 2 , OUTPUT);
}

void loop()
{
digitalWrite( 1 , HIGH );
if (digitalRead(0))
{
digitalWrite( 4 , HIGH );
}
if (digitalRead(3))
{
digitalWrite( 1 , LOW );
delay( 50 );
digitalWrite( 2 , HIGH );
delay( 2500 );
digitalWrite( 2 , LOW );
delay( 50 );
digitalWrite( 1 , HIGH );
digitalWrite( 4 , LOW );
delay( 50 );
}
}