1. Vorwort
Arduino-kompatible Ampelkreuzung für Lehr- und Schulungszwecke
Entdecken Sie die Welt der Elektronik und Programmierung mit unserer innovativen Ampelkreuzung, die speziell für Arduino-Enthusiasten entwickelt wurde. Dieses einzigartige Modul ermöglicht es Ihnen, Verkehrsflüsse an Kreuzungen durch individuelle Programmierung von Ampelsequenzen realistisch zu simulieren. Ideal für Bildungszwecke, Hobbyprojekte oder technische Demonstrationsmodelle.
Flexible Ampelkonfiguration
Die Grundplatte bietet Platz für bis zu sechs einzelne Ampeln, die jeweils über drei Farben (Rot, Gelb, Grün) für die Straßenverkehrssteuerung verfügen. Zusätzlich ist jede Ampel mit einer roten und grünen Fußgängerampel ausgestattet, die nach Links oder Rechts ausgerichtet werden kann.
Intelligente Steuerung durch Arduino MEGA
Der integrierte Arduino MEGA Mikrocontroller mit seinen 54 digitalen I/O-Ports und 16 analogen Eingängen bietet ausreichend Kapazitäten, um eine Vielzahl von LEDs anzusteuern und komplexe Ampelschaltungen zu programmieren.
Interaktive Sensoren
In jede Fahrbahn ist ein Fotowiderstand eingebaut, der erkennen kann, ob Fahrzeuge vor der Ampel warten. Dies ermöglicht eine adaptive Verkehrssteuerung, die auf realen Verkehrsbedingungen basiert, einschließlich der Überwachung von Verkehrsstaus.
Erweiterbar und anpassbar
Dank der offenen Architektur des Arduino-Systems können Sie das Modell durch zusätzliche Sensoren und Komponenten erweitern und so das Verhaltensspektrum der Kreuzung noch weiter anpassen.
Einsatzbereiche
Diese Ampelkreuzung eignet sich hervorragend für Schulprojekte, Universitätskurse in Verkehrsingenieurwesen oder Informatik sowie für Hobbybastler, die ihre Fähigkeiten im Bereich der Mikrocontroller-Programmierung und Elektronik erweitern möchten.
Ausblick
Mit der Arduino-kompatiblen Ampelkreuzung von Funduino setzen Sie nicht nur spannende Projekte um, sondern erlernen auch die Grundlagen der digitalen Steuerungstechnik und Sensorik. Ein Muss für jeden Technikbegeisterten!
Fahrbahnen
Die Funduino-Kreuzung verbindet eine zweispurige mit einer dreispurigen Straße. Auf der zweispurigen Straße können Fahrzeuge entweder geradeaus fahren oder nach rechts abbiegen, während auf der dreispurigen Straße Abbiegungen nach links, und rechts möglich sind. Diese Kreuzung lässt sich nahtlos mit den Funduino-Straßenaufklebern erweitern, um mehrere Ampelsysteme miteinander zu koppeln.
2. Praxisbezogene Anleitungen
In der Dokumentation erläutern wir zunächst die Grundlagen der Ampelfunktion, die Rolle und Funktionsweise eines Lichtabhängigen Widerstands (LDR) und dessen Anwendungsmöglichkeiten. Im weiteren Verlauf zeigen wir anhand eines praktischen Beispiels, wie man eine solche Kreuzung realitätsnah programmieren kann.
2.1 Vorbereitung
Zunächst stecken wir den Arduino MEGA Mikrocontroller auf den dafür vorgesehenen Steckplatz auf der Ampelkreuzung und montieren die einzelnen Ampeln. Nebeneinanderstehende Ampeln können mit einem Kunststoffclip verbunden werden um eine höhere Stabilität zu erreichen.
Bei dem Mikrocontroller muss man darauf achten, dass die Grundplatte bei der Montage flach auf einer Unterlage aufliegt, damit sich die Platine nicht zu stark durchbiegt und ggf. beschädigt wird.
Auf dem folgenden Bild ist einer der LDR-Sensoren (Fotowiderstand) abgebildet. Die LDR-Sensoren ändern ihren Widerstand in Abhängigkeit von der Lichtintensität, die auf den Sensor fällt. Dieser Widerstand ist umso geringer, je mehr Licht einfällt, wodurch mehr Strom durchfließen kann. Mit Hilfe eines zweiten Widerstands ergibt sich aus technischer Sicht ein Spannungsteiler. Die Spannung des Sensors wird dann vom Mikrocontroller ausgewertet und kann so prüfen, ob sich auf dem Sensor ein Fahrzeug befindet, welches den Sensor verschattet.
Jeder Ampelsockel ist detailliert beschriftet. Auf der einen Seite ist zu sehen, an welchem digitalen Pin des Mikrocontrollers der entsprechende Kontakt angeschlossen ist. Auf der anderen Seite ist zu sehen, um welche LED bzw. Taster es sich bei der entsprechenden Ampel handelt.
2.2 Eine einzelne LED Programmieren
Aufgabenstellung
Die rote Leuchtdiode einer Ampel soll blinken.
Schaltung
Wir stecken eine Ampel auf den Steckplatz, der sich genau neben dem MEGA-Mikrocontroller befindet. Hier werden die digitalen Pins 34, 35, 36, 37, 38 und 39 verwendet.
Die Zuordnung sieht dabei folgendermaßen aus
Pin 34 – LED für Ampelfarbe Grün
Pin 35 – LED für Ampelfarbe Gelb
Pin 36 – LED für Ampelfarbe Rot
Pin 37 – Kontakt für den Taster
Pin 38 – LED für Fußgängerampel Rot
Pin 39 – LED für Fußgängerampel Grün
Wir benötigen für diese Aufgabe nur einen Pin des Mikrocontrollerboards, den Pin 36. Denn wie oben zu sehen ist, befindet sich an Pin36 des Mikrocontrollers die LED für die rote Ampelfarbe.
An Pin 36 soll eine Spannung ausgegeben werden, denn die LED soll schließlich leuchten. Daher muss im Setup angegeben werden, dass es sich bei dem Pin 36 um einen Ausgang handelt.
Die Erklärungen hinter dem doppelten Schrägstrich „//“ in grauer Schrift dürfen mit in die Arduinosoftware eingegeben werden, haben jedoch keinen Einfluss auf den Ablauf des Sketches. Das sogenannte Auskommentieren ist beim Programmieren sehr sinnvoll, um für sich selber Informationen zum Programm, oder einfach nur Geistesblitze zu hinterlassen.
Wir schreiben mitten in das weiße Eingabefeld der Arduinosoftware den folgenden Sketch. Dabei muss lediglich der fett gedruckte Programmcode auf der linken Seite abgetippt werden. Die „auskommentierten“ Informationen zum Sketch können weggelassen werden.
void setup() //Hier beginnt das Setup.
{ //Hier beginnt ein Programmabschnitt.
pinMode(36, OUTPUT); //Pin 36 soll ein Ausgang sein.
} //Hier ist ein Programmabschnitt beendet.
void loop() //Hier beginnt das Hauptprogramm.
{ //Hier beginnt ein Programmabschnitt.
digitalWrite(36, HIGH);//Schalte die Spannung an Pin36 ein (LED an).
delay(1000); //Warte 1000 Millisekunden (eine Sekunde).
digitalWrite(36, LOW);//Schalte die Spannung an Pin36 aus (LED aus).
delay(1000); //Warte 1000 Millisekunden (eine Sekunde).
} //Programmabschnitt beendet.Nach der letzten geschweiften Klammer im Loop-Teil ist der Sketch abgeschlossen. Wenn der Sketch innerhalb des „Loop“ vom Mikrocontroller bis zur letzten Klammer abgearbeitet wurde, beginnt der Sketch wieder vorne im Loop-Teil. In diesem Beispiel geht dadurch die LED immer wieder an und aus.
Der Sketch sollte nun exakt so aussehen, wie er auf dem folgenden Bild dargestellt ist. Er muss jetzt nur noch auf das Board hochgeladen werden. Das funktioniert mit der rot umkreisten Schaltfläche (oben links in der Software).
Das Programm kann jetzt noch variiert werden. Beispiel: Die LED soll schneller blinken. Dazu verkürzen wir die Wartezeiten (delay) von 1000 Millisekunden auf 200 Millisekunden.
void setup() //Hier beginnt das Setup
{ //Hier beginnt ein Programmabschnitt.
pinMode(36, OUTPUT); //Pin 13 soll ein Ausgang sein.
} //Hier ist ein Programmabschnitt beendet.
void loop() //Hier beginnt das Hauptprogramm
{ //Programmabschnitt beginnt.
digitalWrite(36, HIGH); //Schalte die Spannung an Pin36 ein (LED an).
delay(200); //Warte 200 Millisekunden
digitalWrite(36, LOW); //Schalte die Spannung an Pin36 aus (LED aus).
delay(200); //Warte 200 Millisekunden
} //Programmabschnitt beendet.
Der neue Sketch muss nun wieder auf das Board hochgeladen werden. Bei fehlerfreier Eingabe wird die LED nun schneller blinken.
Aufgabe 2 - Der Wechselblinker
Aufgabe: Zwei Leuchtdioden sollen abwechselnd blinken. Dabei kann die Blinkgeschwindigkeit und der Blinkrhythmus variiert werden.
Für diese Aufgabe verwenden wir die Rote und Grüne LED der Ampel. Daher benötigen wir neben Pin 36 nun auch Pin 34, da hier die grüne LED angeschlossen ist.
void setup()
{ //Wir starten mit dem Setup
pinMode(36, OUTPUT); //Pin 36 ist ein Ausgang.
pinMode(34, OUTPUT); //Pin 34 ist ein Ausgang.
}
void loop()
{ //Das Hauptprogramm beginnt.
digitalWrite(36, HIGH); //Schalte die LED an Pin36 an.
delay(1000); //Warte 1000 Millisekunden.
digitalWrite(36, LOW); //Schalte die LED an Pin36 aus.
digitalWrite(34, HIGH); //Schalte die LED an Pin34 ein.
delay(1000); //Warte 1000 Millisekunden.
digitalWrite(34, LOW); //Schalte die LED an Pin34 aus.
} //Hier am Ende springt das Programm an den Start des Loop-Teils. Also: schalte die LED an Pin36 an… usw…
Je kürzer das „delay“, also die Pause zwischen dem Wechsel der Leucht- und Ruhephasen der LEDs, gewählt wird desto schneller ist der Blinkrhythmus. Der Rhythmus kann dabei so schnell eingestellt werden, dass das menschliche Auge den Wechsel der Leucht- und Ruhephasen nicht mehr erkennen kann. Mit diesem Sketch kann man zum Beispiel die Blinkfolge von Feuerwehr- und Polizeiwagen verschiedenster Länder als Modell nachbauen, oder eine Ampel an einer Bahnschranke.
Für eine Ampelkreuzung wird ein blinken nur dann benötigt, wenn die Anlage ausfällt und alle gelben Ampelfarben blinken sollen. Ist das eine Aufgabe, die du lösen kannst?
2.3 Fotowiederstand (LDR) auslesen
Aufgabe
Eine LED soll leuchten, wenn es dunkel wird bzw. wenn ein Fotowiderstand auf der Fahrbahn abgedeckt wird.
Spannung auslesen
Der Mikrocontroller soll über einen Fotowiderstand auslesen, wie hell es ist. Dazu nutzt man ein einfaches physikalisches Prinzip. Wenn in einem Stromkreis zwei Verbraucher hintereinander angeschlossen sind (Reihenschaltung), dann „teilt“ sich auch die gemeinsam anliegende Spannung. Ein Beispiel: Zwei gleiche Lampen sind in Reihe geschaltet und es wird eine Spannung von 6 Volt angelegt. Dann kann man mit einem Spannungsmessgerät feststellen, dass an den Lampen jeweils nur 3 Volt anliegen. Wenn zwei ungleiche Lampen angeschlossen werden (eine hat einen geringeren Widerstand), dann kann man zwei unterschiedliche Spannungen an den beiden Lampen messen, bspw. 1,5 Volt und 4,5 Volt. Ein Fotowiderstand ändert seinen Widerstand in Abhängigkeit der Lichtstärke. Diesen Effekt nutzt man, um anhand der an ihr anliegenden Spannung einen Wert für Helligkeit bzw. Dunkelheit in Form von verschiedenen Spannungen abzulesen. Damit man hier überhaupt eine Spannungsteilung erzeugen kann, schließt man den Fotowiderstand und einen Widerstand (1 – 10 K Ohm, je nach verwendetem Fotowiderstand. Der Widerstand sollte einen ähnlichen Widerstandswert wie der Fotowiderstand haben) in Reihe an und verbindet sie mit 5 Volt und der „Erdung“ (Ground / GND). Das Mikrocontroller-Board auf der Kreuzung ist in der Lage, analoge Signale (Spannung) zu messen und diese zu verarbeiten. Dies geschieht mit den analogen Eingängen auf dem Board. Dieser wandelt den gemessenen Spannungswert in eine Zahl um, die dann weiter verarbeitet werden kann. 0 Volt entspricht dabei dem Wert 0 und der höchste Messwert bei 5 Volt entspricht dem Wert 1023 (0 bis 1023 entspricht 1024 Zahlen = 10 Bit). Bsp: Es wird eine Spannung von 2,5 Volt gemessen, dann liefert der Mikrocontroller den Wert 512 (1024 : 2).
Der Serielle Monitor
Der „Serielle Monitor“ oder auch engl. „serial monitor“ ist ein wichtiger Bestandteil der Arduino-Software. Mit diesem Monitor kann man sich am PC Daten und Werte anzeigen lassen, die das Mikrocontroller-Board an den PC sendet (Zahlen oder Texte). Das ist sinnvoll, da man nicht immer ein LCD-Display am Mikrocontroller angeschlossen hat, auf dem man bestimmte Werte ablesen könnte. In diesem Sketch wird der Serielle Monitor verwendet, um die Werte anzeigen zu lassen, die das Board von dem Fotowiderstand einliest. Wozu ist das sinnvoll? Mal angenommen, die LED soll erst bei beginnender Dunkelheit anfangen zu leuchten. Dann muss es im Sketch einen Bereich geben, der die Funktion hat: „Wenn der Wert des Fotowiderstandes den Wert x unterschreitet, dann soll die LED leuchten“. Dazu müsste man wissen, wie groß der Wert x bei beginnender Dämmerung ist.
Lösung: Ich sende den ausgelesenen Wert „x“ der Spannung an dem Fotowiderstand bei entsprechender Helligkeit (bspw. Dämmerung) an den Monitor und lasse ihn mir dort anzeigen. Mit diesem Wissen kann ich später das Programm in der folgenden Form abändern. „Wenn der Spannungsausgabewert des Fotowiderstandes einen Wert von „x“ unterschreitet, dann schalte die LED an.“
Im konkreten Beispiel unserer Ampelkreuzung können wir diesen Wert verwenden um in der Software festzulegen, ob sich ein Fahrzeug über dem Sensor befindet oder nicht.
Programmieren
Für das folgende Programm lesen wir den Messwert des „Sensor 1“ aus. Dieser Sensor befindet sich genau neben dem MEGA-Mikrocontroller
int eingang=A0; //Das Wort „eingang“ steht jetzt für den Wert „A0“ (Bezeichnung vom Analogport 0)
int LED=36; //Das Wort „LED“ steht jetzt für den Wert 36. Hier wird also die Rote LED an der Ampel angesteuert, die sich genau neben dem Mikrocontroller befindet.
int sensorwert=0; //Variable für den Sensorwert mit 0 als Startwert
void setup() //Hier beginnt das Setup.
{
Serial.begin(9600); //Die Kommunikation mit dem Seriellen Port wird gestartet, um den Wert des Sensors im Seriellen Monitor darzustellen.
pinMode (LED,OUTPUT);//Der Pin mit der LED (Pin 36) ist jetzt ein
} Ausgang
void loop()
{ //Mit dieser Klammer wird der Loop-Teil geöffnet.
sensorwert=analogRead(eingang); //Die Spannung an dem Fotowiderstand auslesen und unter der Variable „sensorWert“ abspeichern.
Serial.println("Sensorwert="); //Der Befehl „Seriel.print“ erzeugt eine Ausgabe am Seriellen Monitor.: Das Wort „Sensorwert:”
Serial.println(sensorwert); // Ausgabe am Seriellen Monitor. Mit dem Befehl „Serial.println“ wird der Sensorwert des Fotowiderstandes in Form einer Zahl zwischen 0 und 1023 an den Seriellen Monitor gesendet. Durch die Erweiterung um die beiden Buchstaben „LN“ wird aus dem Befehl „Seriel.println“. Dadurch wird bei der Ausgabe am Seriellen Monitor ein Seitenumbruch erzeugt und die Messwerte sind leichter ablesbar
if(sensorwert < 512) //Wenn der Sensorwert unter dem Wert 512 liegt….
{
digitalWrite(LED,HIGH); //…soll die LED leuchten…
}
else //…andernfalls
{
digitalWrite(LED,LOW); //...soll sie nicht leuchten
}
delay(50);//Eine kurze Pause, in der die LED an oder aus ist
} //Mit dieser letzten Klammer wird der Loop-Teil geschlossen.
//Wenn nun der Sensorwert bei normaler Helligkeit bspw. nur den Wert 100 hat (der Wert ist abhängig von den verwendeten Widerständen, von der Helligkeit und von der Stromrichtung), dann nimmt man anstelle des Wertes 512 einen wesentlich kleineren Wert, bei dem die LED zu leuchten beginnen soll. Bspw. nimmt man dann den Wert 90. Den aktuellen Sensorwert kann man sich nun mithilfe des Seriellen Monitor anzeigen lassen. Dazu klickt man oben auf „Werkzeuge“ und anschließend auf „Serieller Monitor“
Im weiteren Verkauf der Kreuzungsprogrammierung verwendet man den gleichen Code, um Entscheidungen in Abhängigkeit des Sensorwertes zu treffen. Zum Beispiel so:
if(sensorwert < 512) //Wenn der Sensorwert unter dem Wert 512 liegt….
{
Passiert Option1 (Zum Beispiel die Ampel für die Fahrzeuge bleibt auf Grün)
}
else //…andernfalls
{
passiert Option2 (Zum Beispiel die Ampel für die Fahrzeuge wechselt zu Rot)
} 2.4 Eine Ampel programmieren
Bei diesem Projekt beginnen wir mit der Programmierung der ersten Ampel.
Wir verwenden dafür einen anderen Steckplatz. Dieses mal nutzen wir den Steckplatz mit den digitalen Pins 4, 5, 6, 7, 8 und 9.
Die Zuordnung sieht dabei folgendermaßen aus
Pin 4 – LED für Ampelfarbe Grün
Pin 5 – LED für Ampelfarbe Gelb
Pin 6 – LED für Ampelfarbe Rot
Pin 7 – Kontakt für den Taster
Pin 8 – LED für Fußgängerampel Rot
Pin 9 – LED für Fußgängerampel Grün
Schritt 3.1: Die Pins definieren
#define AMPEL_1_GRUEN 4
#define AMPEL_1_GELB 5
#define AMPEL_1_ROT 6
#define AMPEL_1_KNOPF 7
#define AMPEL_1_FUSSGAENGER_ROT 8
#define AMPEL_1_FUSSGAENGER_GRUEN 9
//Damit haben wir die Pins der ersten Ampel definiert. Schritt 3.2: Das Setup
void setup()
{
// LEDS
pinMode(AMPEL_1_GRUEN, OUTPUT);
pinMode(AMPEL_1_GELB, OUTPUT);
pinMode(AMPEL_1_ROT, OUTPUT);
pinMode(AMPEL_1_FUSSGAENGER_ROT, OUTPUT);
pinMode(AMPEL_1_FUSSGAENGER_GRUEN, OUTPUT);
// KNOPF
pinMode(AMPEL_1_KNOPF, INPUT_PULLUP);
}In dieser Erklärung legen wir fest, dass die Pins der Ampel, an denen die LEDs angeschlossen sind, als „OUTPUTS“ konfiguriert sind. Dies bedeutet, dass sie Signale aussenden. Die Pins, an denen sich eine Taste befindet, sind als „INPUT“ eingestellt und haben einen sogenannten „PULLUP“ Widerstand. Ein PULLUP-Widerstand sorgt dafür, dass die Spannung an diesem Pin standardmäßig hoch ist. Wird die Taste gedrückt, fällt die Spannung auf niedrig (low). Um zu überprüfen, ob die Taste gedrückt wurde, suchen wir also nicht nach einem hohen (high), sondern einem niedrigen (low) Signal.
Loop
Hier beginnen wir mit der Initialisierung der Ampel und schalten alle LEDs aus, außer die für die Fußgänger und die für die Autos. Diese müssen aktiviert werden.
Dann warten wir 5 Sekunden und schalten die Autoampel von Grün auf Gelb, um zu signalisieren, dass die Ampel gleich auf Rot umschaltet.
Fünf Sekunden später wechselt die Ampel von Gelb auf Rot. Gleichzeitig schaltet die Fußgängerampel von Rot auf Grün.
Wir warten weitere 5 Sekunden. Diese Zeit kann angepasst werden, zum Beispiel, um Fußgängern mehr Zeit zu geben.
Dann schalten wir GELB, um den Autofahrern zu signalisieren, dass sie bald losfahren können. Außerdem schalten wir die Fußgängerampel von Grün auf Rot. Und nach weiteren 5 Sekunden können die Autofahrer wieder fahren.
Die verwendeten Zeiten sind natürlich ausgedacht und haben mit der Realität nichts zu tun. Finde heraus, wie lange die einzelnen Ampelphasen dauern und programmiere deine Ampel mit realistischen Werten!
void loop()
{
// Stelle jede LED auf aus, auser AMPEL_1_FUSSGAENGER_ROT
// und AMPEL_1_GRUEN. Diese sollen an sein.
digitalWrite(AMPEL_1_GRUEN , HIGH);
digitalWrite(AMPEL_1_FUSSGAENGER_ROT, HIGH);
digitalWrite(AMPEL_1_GELB, LOW);
digitalWrite(AMPEL_1_ROT, LOW);
digitalWrite(AMPEL_1_FUSSGAENGER_GRUEN, LOW);
// warten
delay(5000);
// Gehe von Gruen auf Gelb.
digitalWrite(AMPEL_1_GRUEN , LOW);
digitalWrite(AMPEL_1_GELB, HIGH);
// warten
delay(5000);
// Gehe von Gelb auf Rot und setze die Rote Fußgänger
// LED auf die Grüne Fußgänger-LED.
digitalWrite(AMPEL_1_GELB, LOW);
digitalWrite(AMPEL_1_ROT, HIGH);
digitalWrite(AMPEL_1_FUSSGAENGER_ROT, LOW);
digitalWrite(AMPEL_1_FUSSGAENGER_GRUEN, HIGH);
// warten
delay(5000);
// Rot aktivieren und von Fußgänger grün wieder auf Rot wechseln.
digitalWrite(AMPEL_1_GELB, HIGH);
digitalWrite(AMPEL_1_FUSSGAENGER_ROT, HIGH);
digitalWrite(AMPEL_1_FUSSGAENGER_GRUEN, LOW);
delay(5000);
}Anmerkung
Solltest du schon alle Ampeln auf der Kreuzung platziert haben, hast du vielleicht gemerkt, dass weitere Ampeln leuchten. Die Pins 20 und 21 führen standardmäßig eine Spannung von etwa 3,3 V und sind normalerweise zur Signalübertragung vorgesehen. Für unsere Zwecke, nämlich die Steuerung der Ampel, ist diese Standardeinstellung nicht notwendig. Das Setzen dieser Pins auf LOW verhindert zufällige Signale, die beispielsweise dazu führen könnten, dass die Fußgängerampel an Ampel 3 ungewollt aufleuchtet, obwohl dies nicht programmiert wurde. In späteren Beispielen wird diese Einstellung jedoch irrelevant sein, da wir die Ampel manuell steuern und den Pin-Zustand zwischen high und low wechseln fest definieren.
2.5 Mehrere Ampeln gleichzeitig steuern
Hier ist ein konkreteres Beispiel, bei dem wir 4 Ampeln verwenden. Wenn eine Taste gedrückt wird, sollen die Fußgängerampeln nach einer kurzen Zeit auf Grün umschalten.
Um den Sketch kürzer zu halten, werden in dem folgenden Beispiel Strukturen verwendet, sogenannte „Struct“. Aus dieser Struktur heraus wird für jede Ampel ein Objekt erstellt. Die Grundlagen zu den Themen Listen (Arrays) und Strukturen werden hier nicht vertieft. Es handelt sich nur um eine von vielen Möglichkeiten, einen Sketch zu komprimieren.
Wir beginnen diese Anleitung wieder mit einer Roten Ampel für alle Fußgänger. Außerdem sieht eine Fahrtrichtung die Grüne Ampel und die kreuzende Fahrtrichtung eine rote Ampel. Dann prüfen wir, ob einer der Knöpfe gedrückt wurde. Wenn ein Knopf von Fußgängern gedrückt wurde, schalten die Ampeln aller Fahrbahnen langsam auf Rot. Danach bekommen alle Fußgänger ein grünes Signal.
Nach einer gewissen Zeit bekommen die Fußgänger wieder Rot und die Fahrzeuge in eine Fahrtrichtung das grüne Licht.
// Schritt 1: Definition der Struktur "Ampel"
struct Ampel
{
int Rot; // Pin für Auto-Rot
int Gelb; // Pin für Auto-Gelb
int Gruen; // Pin für Auto-Grün
int pedestrain_Rot; // Pin für Fußgänger-Rot
int pedestrain_Gruen; // Pin für Fußgänger-Grün
int pedestrain_Knopf; // Pin für Fußgänger-Button
};Hier finden wir eine grobe Übersicht, wo sich welche Ampel befindet.
Nun werden wir alle Pins in dem zuvor definierten Objekt definieren:
// Schritt 2: Initialisierung von Ampeln für verschiedene Richtungen
Ampel Seite_1_geradeaus = {6, 5, 4, 8, 9, 7};
Ampel Seite_4_geradeaus = {36, 35, 34, 38, 39, 37};
Ampel Seite_2_geradeaus = {18, 17, 16, 20, 21, 19};
Ampel Seite_3_geradeaus = {24, 23, 22, 26, 27, 25};Der vollständige Sketch sieht nun folgendermaßen aus:
#include <Arduino.h>
// Schritt 1: Definition der Struktur "Ampel"
struct Ampel
{
int Rot; // Pin für Auto-Rot
int Gelb; // Pin für Auto-Gelb
int Gruen; // Pin für Auto-Grün
int pedestrain_Rot; // Pin für Fußgänger-Rot
int pedestrain_Gruen; // Pin für Fußgänger-Grün
int pedestrain_Knopf; // Pin für Fußgänger-Button
};
// Schritt 2: Initialisierung von Verkehrslichtern für verschiedene Richtungen
Ampel AMPEL_1 = {6, 5, 4, 8, 9, 7};
Ampel AMPEL_2 = {18, 17, 16, 20, 21, 19};
Ampel AMPEL_3 = {24, 23, 22, 26, 27, 25};
Ampel AMPEL_4 = {36, 35, 34, 38, 39, 37};
// Schritt 3: Initialisierung der Pins im Setup
void setup()
{
Serial.begin(9600);
// Ampel 1
pinMode(AMPEL_1.Rot, OUTPUT);
pinMode(AMPEL_1.Gelb, OUTPUT);
pinMode(AMPEL_1.Gruen, OUTPUT);
pinMode(AMPEL_1.pedestrain_Rot, OUTPUT);
pinMode(AMPEL_1.pedestrain_Gruen, OUTPUT);
pinMode(AMPEL_1.pedestrain_Knopf, INPUT_PULLUP);
// Ampel 2
pinMode(AMPEL_2.Rot, OUTPUT);
pinMode(AMPEL_2.Gelb, OUTPUT);
pinMode(AMPEL_2.Gruen, OUTPUT);
pinMode(AMPEL_2.pedestrain_Rot, OUTPUT);
pinMode(AMPEL_2.pedestrain_Gruen, OUTPUT);
pinMode(AMPEL_2.pedestrain_Knopf, INPUT_PULLUP);
// Ampel 2
pinMode(AMPEL_3.Rot, OUTPUT);
pinMode(AMPEL_3.Gelb, OUTPUT);
pinMode(AMPEL_3.Gruen, OUTPUT);
pinMode(AMPEL_3.pedestrain_Rot, OUTPUT);
pinMode(AMPEL_3.pedestrain_Gruen, OUTPUT);
pinMode(AMPEL_3.pedestrain_Knopf, INPUT_PULLUP);
// Ampel 2
pinMode(AMPEL_4.Rot, OUTPUT);
pinMode(AMPEL_4.Gelb, OUTPUT);
pinMode(AMPEL_4.Gruen, OUTPUT);
pinMode(AMPEL_4.pedestrain_Rot, OUTPUT);
pinMode(AMPEL_4.pedestrain_Gruen, OUTPUT);
pinMode(AMPEL_4.pedestrain_Knopf, INPUT_PULLUP);
}
// Schritt 5: Hauptverkehrslichtsteuerung und Fußgängerübergangserkennung
void loop()
{
// Geradeaus-Ampeln auf Grün setzen
digitalWrite(AMPEL_1.Gruen, HIGH);
digitalWrite(AMPEL_3.Gruen, HIGH);
// Andere Geradeaus-Ampeln auf Rot setzen
digitalWrite(AMPEL_1.Rot, LOW);
digitalWrite(AMPEL_3.Rot, LOW);
digitalWrite(AMPEL_1.Gelb, LOW);
digitalWrite(AMPEL_3.Gelb, LOW);
// Fußgänger-Ampeln auf Rot setzen
digitalWrite(AMPEL_4.pedestrain_Rot, HIGH);
digitalWrite(AMPEL_1.pedestrain_Rot, HIGH);
digitalWrite(AMPEL_2.pedestrain_Rot, HIGH);
digitalWrite(AMPEL_3.pedestrain_Rot, HIGH);
digitalWrite(AMPEL_4.pedestrain_Gruen, LOW);
digitalWrite(AMPEL_1.pedestrain_Gruen, LOW);
digitalWrite(AMPEL_2.pedestrain_Gruen, LOW);
digitalWrite(AMPEL_3.pedestrain_Gruen, LOW);
// Überprüfen, ob Fußgänger-Button gedrückt wurde
if (digitalRead(AMPEL_4.pedestrain_Knopf) == LOW ||
digitalRead(AMPEL_1.pedestrain_Knopf) == LOW ||
digitalRead(AMPEL_2.pedestrain_Knopf) == LOW ||
digitalRead(AMPEL_3.pedestrain_Knopf) == LOW)
{
// Warte 2 Sekunden
delay(2000);
// Geradeaus-Ampeln auf Gelb schalten und dann auf Rot
digitalWrite(AMPEL_1.Gruen, LOW);
digitalWrite(AMPEL_3.Gruen, LOW);
digitalWrite(AMPEL_1.Gelb, HIGH);
digitalWrite(AMPEL_3.Gelb, HIGH);
// Warte 1 Sekunden
delay(1000);
digitalWrite(AMPEL_1.Gelb, LOW);
digitalWrite(AMPEL_3.Gelb, LOW);
digitalWrite(AMPEL_1.Rot, HIGH);
digitalWrite(AMPEL_3.Rot, HIGH);
// Warte 2 Sekunden
delay(2000);
// Fußgänger-Ampeln auf Grün setzen
digitalWrite(AMPEL_4.pedestrain_Gruen, HIGH);
digitalWrite(AMPEL_1.pedestrain_Gruen, HIGH);
digitalWrite(AMPEL_2.pedestrain_Gruen, HIGH);
digitalWrite(AMPEL_3.pedestrain_Gruen, HIGH);
digitalWrite(AMPEL_4.pedestrain_Rot, LOW);
digitalWrite(AMPEL_1.pedestrain_Rot, LOW);
digitalWrite(AMPEL_2.pedestrain_Rot, LOW);
digitalWrite(AMPEL_3.pedestrain_Rot, LOW);
// Warte 5 Sekunden
delay(5000);
// Fußgänger-Ampeln auf Rot setzen
digitalWrite(AMPEL_4.pedestrain_Gruen, LOW);
digitalWrite(AMPEL_1.pedestrain_Gruen, LOW);
digitalWrite(AMPEL_2.pedestrain_Gruen, LOW);
digitalWrite(AMPEL_3.pedestrain_Gruen, LOW);
digitalWrite(AMPEL_4.pedestrain_Rot, HIGH);
digitalWrite(AMPEL_1.pedestrain_Rot, HIGH);
digitalWrite(AMPEL_2.pedestrain_Rot, HIGH);
digitalWrite(AMPEL_3.pedestrain_Rot, HIGH);
// Warte 2 Sekunden
delay(2000);
// Geradeaus-Ampeln auf Gelb schalten
digitalWrite(AMPEL_1.Gelb, HIGH);
digitalWrite(AMPEL_3.Gelb, HIGH);
// Rote Ampeln ausschalten
digitalWrite(AMPEL_1.Rot, HIGH);
digitalWrite(AMPEL_3.Rot, HIGH);
delay(1000);
}
}Funduino - Dein Onlineshop für Mikroelektronik
-
Dauerhaft bis zu 10% Rabatt für Schüler, Studenten und Lehrkräfte
-
Mehr als 2.000 Artikel sofort verfügbar!
-
Über 8 Jahre Erfahrung mit Arduino, 3D-Druck und co.