Feu de circulation Funduino (CMS)

FunduinoDernière mise à jour le 11.09.2024

34 WS2812-LEDs, acht Taster und zehn Fotowiderstände auf einer Platine

Die Funduino Ampelkreuzung bringt eine komplette Kreuzung auf eine Platine: 34 einzeln ansteuerbare WS2812-LEDs für die Fahrzeug- und Fußgängerampeln, acht Taster für Fußgänger und zehn Fotowiderstände, mit denen du erkennst, ob an einer Ampel ein Fahrzeug wartet.

In dieser Anleitung arbeitest du dich von einer einzelnen Ampel bis zur vollständigen Phasensteuerung der Kreuzung vor. Zum Schluss liest du Taster und Fotowiderstände aus – die Grundlage für eine bedarfsgerechte Ampelschaltung.

Funduino Ampelkreuzung in SMD-Bauweise mit vier Fahrtrichtungen — Die Ampelkreuzung im Überblick

Die Ampelkreuzung im Überblick

Eine Ampel regelt den Verkehr auf der Straße. Sie zeigt mit Lichtsignalen an, wann Fahrzeuge und Fußgänger anhalten müssen, wann sie sich bereit machen sollen und wann sie fahren dürfen. Weltweit unterscheiden sich Ampeln im Detail: Die Phasen sind unterschiedlich lang, und Gelb leuchtet mancherorts zusammen mit Rot oder Grün.

Diese Anleitung zeigt dir, wie du die Funduino Ampelkreuzung in SMD-Ausführung aufbaust und programmierst. Für alle Beispiele hier gilt:

Rot: Fahrzeuge müssen anhalten.
Gelb: Fahrzeuge machen sich bereit, zu fahren oder anzuhalten.
Grün: Fahrzeuge dürfen fahren.

Die Beispiele kannst du als Ausgangspunkt nehmen und an die Ampelschaltung anpassen, die du vor Ort kennst.

Die Spannungsversorgung

Auf der Ampelkreuzung sitzen 34 Leuchtdioden und zehn Fotowiderstände. Dafür reicht der Strom nicht aus, den ein typischer Mikrocontroller liefern kann. Versorge die Kreuzung deshalb unabhängig vom Mikrocontroller über den DC-Jack mit einer Spannung von 6 V bis 9 V.

Direkt neben dem DC-Jack sitzt der Spannungswandler. Er erzeugt aus jeder Spannung zwischen 6 V und 9 V eine Versorgungsspannung von 5 V für alle Module auf der Platine. Auch wenn du einen Mikrocontroller mit 3,3 V Systemspannung verwendest, bekommen die Module dadurch die richtige Spannung.

Der Hohlstecker muss außen 5,5 mm und innen 2,1 mm messen. Der Pluspol liegt innen, der Minuspol außen.

Widerspruch im Artikel: Hier steht, die Kreuzung müsse unabhängig vom Mikrocontroller versorgt werden. In der Verkabelungsanweisung zum Einzelampel-Beispiel heißt es dagegen „VIN an der Kreuzung: Verbinde mit 5V vom Arduino“. Über den 5-V-Pin des Arduino lassen sich 34 LEDs nicht sicher betreiben.

DC-Jack und Spannungswandler auf der Platine — DC-Jack und Spannungswandler

Hohlstecker mit 5,5 mm Außen- und 2,1 mm Innendurchmesser — Der passende Stecker: 5,5 mm außen, 2,1 mm innen

1 / 2

Die WS2812-LEDs

Auf der Kreuzung sind WS2812-LEDs verbaut. Jede dieser LEDs lässt sich einzeln ansteuern und enthält die drei Farben Rot, Grün und Blau, die sich zu vielen weiteren Farben mischen lassen.

Ansteuerung: Du steuerst die LEDs über eine Bibliothek, zum Beispiel Adafruit NeoPixel. Jede LED ist unabhängig ansprechbar – ideal für komplexe Lichtmuster.
Vorteil: Eine lange Kette von LEDs braucht nur eine einzige Datenleitung. Dadurch arbeitet die Ampelkreuzung mit einem Arduino ebenso zusammen wie mit einem ESP32 oder einem Raspberry Pi Pico.

WS2812-Leuchtdioden auf der Ampelkreuzung — 34 einzeln ansteuerbare WS2812-LEDs

Beispiel: eine einzelne Ampel programmieren

Zum Einstieg programmierst du eine einzelne Ampel, die die klassischen Phasen Rot, Rot-Gelb, Grün und Gelb durchläuft.

Verkabelung

VIN an der Kreuzung an 5V des Arduino
GND an der Kreuzung an GND des Arduino
SIG an der Kreuzung an Pin 3 des Arduino – über diesen Pin werden die LEDs angesteuert

Installiere anschließend die Bibliothek „Adafruit NeoPixel“ über den Bibliotheksverwalter der Arduino IDE.

So arbeitet der Sketch:

Die Ampel durchläuft die Phasen Rot, Rot-Gelb, Grün und Gelb.
Jede Phase wird über setAmpel() gesetzt, die die Farbe der jeweiligen LED bestimmt.
Die delay()-Befehle legen fest, wie lange eine Phase dauert.

Im Artikel steht dieser Sketch nicht in einem Codeblock, sondern als Folge einzelner Absätze – ohne Monospace und ohne Einrückung, deshalb nicht am Stück kopierbar. Die Angabe „VIN an 5V vom Arduino“ widerspricht der Spannungsversorgung aus Schritt 2. #define NUMPIXELS 3 gilt nur für dieses Beispiel mit einer einzelnen Ampel; die ganze Kreuzung hat 34 LEDs.

Beispiel: eine einzelne Ampel

#include <Adafruit_NeoPixel.h>
// Pin und Anzahl der WS2812 LEDs
#define DATA_PIN 3
#define NUMPIXELS 3 // 3 LEDs für die Ampel
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, DATA_PIN, NEO_GRB + NEO_KHZ800);
// Funktion zum Setzen der Ampelfarbe
void setAmpel(int pixel, int r, int g, int b) {
 strip.setPixelColor(pixel, strip.Color(r, g, b));
 strip.show();
}
void setup() {
 strip.begin(); // Initialisiere WS2812 LEDs
 strip.show(); // Alle LEDs ausschalten
}
void loop() {
 // Phase Rot
 setAmpel(0, 255, 0, 0); // Rot an
 setAmpel(1, 0, 0, 0); // Gelb aus
 setAmpel(2, 0, 0, 0); // Grün aus
 delay(5000); // 5 Sekunden Rot
 // Phase Rot-Gelb
 setAmpel(0, 255, 0, 0); // Rot an
 setAmpel(1, 255, 255, 0); // Gelb an
 setAmpel(2, 0, 0, 0); // Grün aus
 delay(2000); // 2 Sekunden Rot-Gelb
 // Phase Grün
 setAmpel(0, 0, 0, 0); // Rot aus
 setAmpel(1, 0, 0, 0); // Gelb aus
 setAmpel(2, 0, 255, 0); // Grün an
 delay(5000); // 5 Sekunden Grün
 // Phase Gelb
 setAmpel(0, 0, 0, 0); // Rot aus
 setAmpel(1, 255, 255, 0); // Gelb an
 setAmpel(2, 0, 0, 0); // Grün aus
 delay(2000); // 2 Sekunden Gelb
}

Die Taster für Fußgänger

Auf der Kreuzung sitzen acht Taster. Fußgänger signalisieren damit, dass sie die Straße überqueren wollen. Das lohnt sich, weil eine Kreuzung deutlich effizienter arbeitet, wenn die Hauptfahrspuren nicht unterbrochen werden, solange niemand wartet.

Jeweils zwei Taster gehören zu einer Fahrspur, denn es spielt keine Rolle, auf welcher Straßenseite gedrückt wurde. Die zusammengehörenden Paare sind mit „Side1“, „Side2“, „Side3“ und „Side4“ beschriftet.

Die Taster haben einen Pulldown-Widerstand: Solange niemand drückt, liegt an den Kontakten GND an. Beim Tastendruck liegt dort das VIN-Signal an, bei einer Versorgung mit 5 V also 5 V.

Fotowiderstände und Multiplexer CD74HC4067

Zehn Fotowiderstände prüfen modellhaft, ob an einer Position auf der Kreuzung ein Fahrzeug steht.

Damit kannst du eine intelligente Ampelschaltung bauen: Wartet an einer Fahrbahn kein Fahrzeug, kann sie dauerhaft auf Rot bleiben, und die übrigen Fahrzeuge müssen nicht unnötig anhalten. Bei komplexeren Programmen lässt sich auch prüfen, ob eine Fahrbahn am Kreuzungsausgang verstopft ist – eine Linksabbiegerspur kann dann auf Rot bleiben, damit sich der Kreuzungsbereich nicht füllt.

Der Analogmultiplexer CD74HC4067

Der Arduino hat nur wenige analoge Eingänge, die Kreuzung aber zehn analoge Sensoren. Der Multiplexer löst das: Er ist ein elektronischer Verteiler, der einen von 16 Kanälen auf einen einzigen analogen Pin durchschaltet. Welcher Kanal aktiv ist, bestimmst du über die vier Steuerpins S0, S1, S2 und S3, die auf der Kreuzung beschriftet sind. Es ist immer nur ein Kanal gleichzeitig durchgeschaltet.

Die Kombinationen der Steuerpins

Fotowiderstand 1: S0 LOW / S1 LOW / S2 LOW / S3 LOW
Fotowiderstand 2: S0 HIGH / S1 LOW / S2 LOW / S3 LOW
Fotowiderstand 3: S0 LOW / S1 HIGH / S2 LOW / S3 LOW
Fotowiderstand 4: S0 HIGH / S1 HIGH / S2 LOW / S3 LOW
Fotowiderstand 5: S0 LOW / S1 LOW / S2 HIGH / S3 LOW
Fotowiderstand 6: S0 HIGH / S1 LOW / S2 HIGH / S3 LOW
Fotowiderstand 7: S0 LOW / S1 HIGH / S2 HIGH / S3 LOW
Fotowiderstand 8: S0 HIGH / S1 HIGH / S2 HIGH / S3 LOW
Fotowiderstand 9: S0 LOW / S1 LOW / S2 LOW / S3 HIGH
Fotowiderstand 10: S0 HIGH / S1 LOW / S2 LOW / S3 HIGH

Im Sketch schaltest du zuerst den gewünschten Kanal durch und liest anschließend den analogen Pin aus. Der folgende Programmblock zeigt das am Beispiel von Fotowiderstand 3.

Fotowiderstände in der Fahrbahn der Ampelkreuzung — Zehn Fotowiderstände erkennen wartende Fahrzeuge

Multiplexer ansteuern – Beispiel für Fotowiderstand 3

digitalWrite(S0, LOW);
digitalWrite(S1, HIGH);
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
SensorWert = analogRead(Analogpin);

Die gesamte Kreuzung programmieren

Jetzt steuerst du die komplette Kreuzung mit zwei Fahrtrichtungen und zwei Fußgängerampeln. Eine gesonderte Linksabbiegerampel bleibt außen vor, und auch die Taster und die Fotowiderstände werden hier noch nicht abgefragt.

Der Ablauf ist in acht Phasen aufgeteilt, die jeweils alle Ampeln der Kreuzung setzen:

Phase 1: Richtung 1 Rot, Richtung 2 Grün, Fußgänger 1 Grün, Fußgänger 2 Rot. Richtung 2 fährt, die Fußgänger der ersten Richtung überqueren die Straße.
Phase 2: Richtung 1 Rot, Richtung 2 Gelb, Fußgänger 1 Grün, Fußgänger 2 Rot. Richtung 2 bereitet sich auf das Anhalten vor.
Phase 3: Beide Fahrtrichtungen Rot. Eine kurze Sicherheitsphase, damit sich die Kreuzung leert.
Phase 4: Richtung 1 Gelb, Richtung 2 Rot, beide Fußgängerampeln Rot. Richtung 1 bereitet sich auf Grün vor.
Phase 5: Richtung 1 Grün, Richtung 2 Rot, Fußgänger 1 Rot, Fußgänger 2 Grün.
Phase 6: Richtung 1 Gelb vor Rot, Richtung 2 Rot, Fußgänger 2 schaltet auf Rot.
Phase 7: Beide Fahrtrichtungen Rot, Fußgänger 1 Grün.
Phase 8: Richtung 1 Rot, Richtung 2 Gelb, Fußgänger 1 Grün, Fußgänger 2 Rot. Richtung 2 bereitet sich auf das Anfahren vor.

Die Funktion setAmpel() setzt jeweils zwei LEDs einer Fahrtrichtung, setFussgaengerAmpel() schaltet die vier grünen und die vier roten LEDs einer Fußgängerampel gemeinsam um.

Phasenübersicht und Sketch widersprechen sich bei Phase 3: Die Übersicht nennt für Fußgängerampel 2 „Rot“, der Sketch schaltet sie dort auf Grün. In Phase 6 lässt der Sketch Fahrtrichtung 2 und Fußgängerampel 1 ganz aus; sie behalten zufällig den richtigen Zustand aus Phase 5, was aber nicht zum Aufbau der übrigen Phasen passt.

Die gesamte Kreuzung in acht Phasen

#include <Adafruit_NeoPixel.h>
// Pin und Anzahl der WS2812 LEDs
#define DATA_PIN 3
#define NUMPIXELS 34 // Gesamtzahl der LEDs
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, DATA_PIN, NEO_GRB + NEO_KHZ800);
// Funktion zum Setzen der Ampelfarbe für eine Richtung
void setAmpel(int pixel1, int pixel2, int r, int g, int b) {
 strip.setPixelColor(pixel1, strip.Color(r, g, b));
 strip.setPixelColor(pixel2, strip.Color(r, g, b));
 strip.show();
}
// Funktion zum Setzen der Fußgängerampel mit mehreren LEDs
void setFussgaengerAmpel(int gruen1, int gruen2, int gruen3, int gruen4, int rot1, int rot2, int rot3, int rot4,
bool gruenAn) {
 if (gruenAn) {
 // Grün an, Rot aus
 strip.setPixelColor(gruen1, strip.Color(0, 255, 0));
 strip.setPixelColor(gruen2, strip.Color(0, 255, 0));
 strip.setPixelColor(gruen3, strip.Color(0, 255, 0));
 strip.setPixelColor(gruen4, strip.Color(0, 255, 0));
 strip.setPixelColor(rot1, strip.Color(0, 0, 0));
 strip.setPixelColor(rot2, strip.Color(0, 0, 0));
 strip.setPixelColor(rot3, strip.Color(0, 0, 0));
 strip.setPixelColor(rot4, strip.Color(0, 0, 0));
 } else {
 // Rot an, Grün aus
 strip.setPixelColor(gruen1, strip.Color(0, 0, 0));
 strip.setPixelColor(gruen2, strip.Color(0, 0, 0));
 strip.setPixelColor(gruen3, strip.Color(0, 0, 0));
 strip.setPixelColor(gruen4, strip.Color(0, 0, 0));
 strip.setPixelColor(rot1, strip.Color(255, 0, 0));
 strip.setPixelColor(rot2, strip.Color(255, 0, 0));
 strip.setPixelColor(rot3, strip.Color(255, 0, 0));
 strip.setPixelColor(rot4, strip.Color(255, 0, 0));
 }
 strip.show();
}
void setup() {
 strip.begin(); // Initialisiere WS2812 LEDs
 strip.show(); // Alle LEDs ausschalten
}
void loop() {
 // Phase 1: Richtung 1 Rot, Richtung 2 Grün, Fußgänger 1 Grün, Fußgänger 2 Rot
 setAmpel(15, 6, 255, 0, 0); // Richtung 1 Rot an
 setAmpel(16, 7, 0, 0, 0); // Richtung 1 Gelb aus
 setAmpel(17, 8, 0, 0, 0); // Richtung 1 Grün aus
 delay(2000); // 2 Sekunden warten, bevor Fußgänger 1 Grün wird
 setFussgaengerAmpel(18, 32, 24, 26, 19, 33, 25, 27, true); // Fußgänger 1 Grün
 setAmpel(0, 9, 0, 0, 0); // Richtung 2 Rot aus
 setAmpel(1, 10, 0, 0, 0); // Richtung 2 Gelb aus
 setAmpel(2, 11, 0, 255, 0); // Richtung 2 Grün an
 setFussgaengerAmpel(20, 22, 30, 28, 21, 23, 31, 29, false); // Fußgänger 2 Rot
 delay(5000); // 5 Sekunden Grünphase für Richtung 2
 // Phase 2: Richtung 1 bleibt Rot, Richtung 2 schaltet auf Gelb, Fußgänger 2 auf Rot
 setAmpel(15, 6, 255, 0, 0); // Richtung 1 Rot an
 setAmpel(16, 7, 0, 0, 0); // Richtung 1 Gelb aus
 setAmpel(17, 8, 0, 0, 0); // Richtung 1 Grün aus
 setFussgaengerAmpel(18, 32, 24, 26, 19, 33, 25, 27, true); // Fußgänger 1 Grün
 setAmpel(0, 9, 0, 0, 0); // Richtung 2 Rot aus
 setAmpel(1, 10, 255, 255, 0); // Richtung 2 Gelb an
 setAmpel(2, 11, 0, 0, 0); // Richtung 2 Grün aus
 setFussgaengerAmpel(20, 22, 30, 28, 21, 23, 31, 29, false); // Fußgänger 2 Rot
 delay(2000); // 2 Sekunden Gelbphase für Richtung 2
 // Phase 3: Beide Richtungen zeigen Rot, Fußgänger 1 Grün, Fußgänger 2 Rot
 setAmpel(15, 6, 255, 0, 0); // Richtung 1 Rot an
 setAmpel(16, 7, 0, 0, 0); // Richtung 1 Gelb aus
 setAmpel(17, 8, 0, 0, 0); // Richtung 1 Grün aus
 setFussgaengerAmpel(18, 32, 24, 26, 19, 33, 25, 27, true); // Fußgänger 1 Grün
 setAmpel(0, 9, 255, 0, 0); // Richtung 2 Rot an
 setAmpel(1, 10, 0, 0, 0); // Richtung 2 Gelb aus
 setAmpel(2, 11, 0, 0, 0); // Richtung 2 Grün aus
 delay(2000); // 2 Sekunden warten, bevor Fußgänger 2 Grün wird
 setFussgaengerAmpel(20, 22, 30, 28, 21, 23, 31, 29, true); // Fußgänger 2 Grün
 delay(1000); // 1 Sekunde beide Richtungen Rot
 // Phase 4: Richtung 1 schaltet auf Gelb, Richtung 2 bleibt Rot, Fußgänger 1 auf Rot
 setAmpel(15, 6, 255, 0, 0); // Richtung 1 Rot an
 setAmpel(16, 7, 255, 255, 0); // Richtung 1 Gelb an
 setAmpel(17, 8, 0, 0, 0); // Richtung 1 Grün aus
 setFussgaengerAmpel(18, 32, 24, 26, 19, 33, 25, 27, false); // Fußgänger 1 Rot
 setAmpel(0, 9, 255, 0, 0); // Richtung 2 Rot an
 setAmpel(1, 10, 0, 0, 0); // Richtung 2 Gelb aus
 setAmpel(2, 11, 0, 0, 0); // Richtung 2 Grün aus
 delay(2000); // 2 Sekunden Gelbphase für Richtung 1 vor Grün
 // Phase 5: Richtung 1 Grün, Richtung 2 bleibt Rot, Fußgänger 2 Grün
 setAmpel(15, 6, 0, 0, 0); // Richtung 1 Rot aus
 setAmpel(16, 7, 0, 0, 0); // Richtung 1 Gelb aus
 setAmpel(17, 8, 0, 255, 0); // Richtung 1 Grün an
 setFussgaengerAmpel(18, 32, 24, 26, 19, 33, 25, 27, false); // Fußgänger 1 Rot
 setAmpel(0, 9, 255, 0, 0); // Richtung 2 Rot an
 setAmpel(1, 10, 0, 0, 0); // Richtung 2 Gelb aus
 setAmpel(2, 11, 0, 0, 0); // Richtung 2 Grün aus
 setFussgaengerAmpel(20, 22, 30, 28, 21, 23, 31, 29, true); // Fußgänger 2 Grün
 delay(5000); // 5 Sekunden Grünphase für Richtung 1
 // Phase 6: Richtung 1 schaltet auf Gelb vor Rot, Richtung 2 bleibt Rot, Fußgänger 2 auf Rot
 setAmpel(15, 6, 0, 0, 0); // Richtung 1 Rot aus
 setAmpel(16, 7, 255, 255, 0); // Richtung 1 Gelb an
 setAmpel(17, 8, 0, 0, 0); // Richtung 1 Grün aus
 setFussgaengerAmpel(20, 22, 30, 28, 21, 23, 31, 29, false); // Fußgänger 2 Rot
 delay(2000); // 2 Sekunden Gelbphase für Richtung 1 vor Rot
 // Phase 7: Beide Richtungen zeigen Rot, Fußgänger 1 auf Grün, Fußgänger 2 bleibt Rot
 setAmpel(15, 6, 255, 0, 0); // Richtung 1 Rot an
 setAmpel(16, 7, 0, 0, 0); // Richtung 1 Gelb aus
 setAmpel(17, 8, 0, 0, 0); // Richtung 1 Grün aus
 delay(2000); // 2 Sekunden warten, bevor Fußgänger 1 Grün wird
 setFussgaengerAmpel(18, 32, 24, 26, 19, 33, 25, 27, true); // Fußgänger 1 Grün
 setAmpel(0, 9, 255, 0, 0); // Richtung 2 Rot an
 setAmpel(1, 10, 0, 0, 0); // Richtung 2 Gelb aus
 setAmpel(2, 11, 0, 0, 0); // Richtung 2 Grün aus
 setFussgaengerAmpel(20, 22, 30, 28, 21, 23, 31, 29, false); // Fußgänger 2 Rot
 delay(1000); // 1 Sekunde beide Richtungen Rot
 // Phase 8: Richtung 1 bleibt Rot, Richtung 2 schaltet auf Gelb, Fußgänger 1 Grün, Fußgänger 2 auf Rot
 setAmpel(15, 6, 255, 0, 0); // Richtung 1 Rot an
 setAmpel(16, 7, 0, 0, 0); // Richtung 1 Gelb aus
 setAmpel(17, 8, 0, 0, 0); // Richtung 1 Grün aus
 setFussgaengerAmpel(18, 32, 24, 26, 19, 33, 25, 27, true); // Fußgänger 1 Grün
 setAmpel(0, 9, 255, 0, 0); // Richtung 2 Rot an
 setAmpel(1, 10, 255, 255, 0); // Richtung 2 Gelb an
 setAmpel(2, 11, 0, 0, 0); // Richtung 2 Grün aus
 setFussgaengerAmpel(20, 22, 30, 28, 21, 23, 31, 29, false); // Fußgänger 2 Rot
 delay(2000); // 2 Sekunden Gelbphase für Richtung 2
}

Taster und Fotowiderstände auslesen

Dieser Sketch schaltet nacheinander alle zehn Fotowiderstände durch, gibt die Messwerte im seriellen Monitor aus und prüft danach die vier Tastergruppen. Er eignet sich gut, um die Schwellenwerte für „Fahrzeug steht an der Ampel“ zu ermitteln, bevor du sie in deine eigene Ampelsteuerung einbaust.

Im Sketch sind int LED = 12; und int SchwelleDunkelheit = 400; angelegt, werden aber nirgends verwendet.

Taster und Fotowiderstände auslesen

int Fotowiderstand = A0;
int LED = 12;
int SchwelleDunkelheit = 400;
int S0 = 4;
int S1 = 5;
int S2 = 6;
int S3 = 7;
int p = 5;
int SensorWert = 0;
int Taster1 = 8;
int Taster2 = 9;
int Taster3 = 10;
int Taster4 = 11;
int TasterStatus = 0;
void setup() {
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(Taster1, INPUT);
pinMode(Taster2, INPUT);
pinMode(Taster3, INPUT);
pinMode(Taster4, INPUT);
 // Seriellen Monitor starten
Serial.begin(9600);
}
void loop() {
 // 1
digitalWrite(S0, LOW);
digitalWrite(S1, LOW);
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
delay(p);
 SensorWert = analogRead(Fotowiderstand);
Serial.print(SensorWert);
Serial.print(" ");
 // 2
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
delay(p);
 SensorWert = analogRead(Fotowiderstand);
Serial.print(SensorWert);
Serial.print(" ");
 // 3
digitalWrite(S0, LOW);
digitalWrite(S1, HIGH);
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
delay(p);
 SensorWert = analogRead(Fotowiderstand);
Serial.print(SensorWert);
Serial.print(" ");
 // 4
digitalWrite(S0, HIGH);
digitalWrite(S1, HIGH);
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
delay(p);
 SensorWert = analogRead(Fotowiderstand);
Serial.print(SensorWert);
Serial.print(" ");
 // 5
digitalWrite(S0, LOW);
digitalWrite(S1, LOW);
digitalWrite(S2, HIGH);
digitalWrite(S3, LOW);
delay(p);
 SensorWert = analogRead(Fotowiderstand);
Serial.print(SensorWert);
Serial.print(" ");
 // 6
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
digitalWrite(S2, HIGH);
digitalWrite(S3, LOW);
delay(p);
 SensorWert = analogRead(Fotowiderstand);
Serial.print(SensorWert);
Serial.print(" ");
 // 7
digitalWrite(S0, LOW);
digitalWrite(S1, HIGH);
digitalWrite(S2, HIGH);
digitalWrite(S3, LOW);
delay(p);
 SensorWert = analogRead(Fotowiderstand);
Serial.print(SensorWert);
Serial.print(" ");
 // 8
digitalWrite(S0, HIGH);
digitalWrite(S1, HIGH);
digitalWrite(S2, HIGH);
digitalWrite(S3, LOW);
delay(p);
 SensorWert = analogRead(Fotowiderstand);
Serial.print(SensorWert);
Serial.print(" ");
 // 9
digitalWrite(S0, LOW);
digitalWrite(S1, LOW);
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
delay(p);
 SensorWert = analogRead(Fotowiderstand);
Serial.print(SensorWert);
Serial.print(" ");
 // 10
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
delay(p);
 SensorWert = analogRead(Fotowiderstand);
Serial.print(SensorWert);
Serial.print(" ");
 // Tasater abfragen
 TasterStatus = digitalRead(Taster1);
if (TasterStatus == HIGH) {
Serial.print("Taster1 aktiv");
}
 TasterStatus = digitalRead(Taster2);
if (TasterStatus == HIGH) {
Serial.print("Taster2 aktiv");
}
 TasterStatus = digitalRead(Taster3);
if (TasterStatus == HIGH) {
Serial.print("Taster3 aktiv");
}
 TasterStatus = digitalRead(Taster4);
if (TasterStatus == HIGH) {
Serial.println("Taster4 aktiv");
} else if (TasterStatus == LOW) {
Serial.println(" ");
}
}

Évaluer le guide