Ob für die Modellbahn, LEGO oder den Schulunterricht, eine funktionierende Ampelanlage ist einfach super! Sie kann mit unter sehr komplex werden. Hier zeige ich dir, wie du die Ampelanlage einer einfachen Kreuzung mit Fußgängerampel mit Arduino aufbauen kannst.
Bauteile
- LEDs (Dieses 500 LED-Set hab ich benutzt).
- 10 Widerstände 220 Ohm
Schaltplan
Natürlich können auch die anderen Ampeln der Anlage einfach parallel betrieben werden. Dazu bitte auch den Hinweis weiter unten beachten.
Hintergrund
Welche Ampelphasen gibt es denn bei so einer Ampel? Sehen wir uns die Kreuzung mal genauer an.
Genau wie die Animation könnte man auch die Ampelanlage als Bild betrachten. Die einzelnen Lampen sind die Pixel und die sind entweder an oder aus (Bitmap). Und wie bei einer Animation ist jeder Zustand ein Frame, sozusagen ein Standbild. Welche Bilder sind das denn genau?
Links sind also die Bilder, rechts ist bereits ein Array-Code. Es ist ein zweidimensionales Array. Wir können es genau so verwenden und müssen nur bestimmen, welcher »State« (oder Frame) gezeigt werden soll.
Um nicht so viel Code schreiben zu müssen, legen wir eine extra Methode an:
void zeigeAmpelphase() {
for (int i = 0; i < 10; i++) {
digitalWrite(ledPins[i], ampelphasen[myState][i]);
}
delay(wartezeiten[myState]);
}
Die For-Schleife sorgt dafür, dass jede LED des Arrays ausgewertet wird.
Da nicht jede Ampelphase gleich lang angezeigt wird, gibt es ein weiteres Array mit den Wartezeiten der jeweiligen Ampelphase. Diese wird ebenfalls in der zeigeAmpelphase()-Methode ausgewertet.
Anzeige
Code
Der gesamte Code sieht so aus:
int ledPins[10] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int ampelphasen[10][10] = {
{1, 0, 0, 0, 1, 0, 0, 1, 1, 0}, // state 0
{1, 0, 0, 1, 0, 0, 0, 1, 1, 0}, // state 1
{1, 0, 0, 1, 0, 0, 1, 0, 1, 0}, // state 2
{1, 0, 0, 1, 0, 1, 0, 0, 1, 0}, // state 3
{1, 1, 0, 1, 0, 1, 0, 0, 1, 0}, // state 4
{0, 0, 1, 1, 0, 1, 0, 0, 0, 1}, // state 5
{0, 0, 1, 1, 0, 1, 0, 0, 1, 0}, // state 6
{0, 1, 0, 1, 0, 1, 0, 0, 1, 0}, // state 7
{1, 0, 0, 1, 0, 1, 0, 0, 1, 0}, // state 8
{1, 0, 0, 1, 0, 1, 1, 0, 1, 0} // state 9
};
int wartezeiten[10] = {5000, 2000, 500, 2000, 500, 5000, 2000, 500, 2000, 500};
int myState = 0;
void setup() {
for (int i = 0; i < 10; i++) {
pinMode(ledPins[i], OUTPUT);
}
}
void zeigeAmpelphase() {
for (int i = 0; i < 10; i++) {
digitalWrite(ledPins[i], ampelphasen[myState][i]);
}
delay(wartezeiten[myState]);
}
void loop() {
zeigeAmpelphase();
myState++;
if (myState >= 10) myState = 0;
}
Hinweis: Ein digitaler Kanal des Arduino-Boards kann bis zu 60 mA liefern. Alle Pins zusammen sind für maximal 200 mA ausgelegt. Bei 5mm Signal-LEDs beträgt der Strom bei einem Vorwiderstand von 220 Ohm 12 – 15 mA. Es können also pro digitalen Pin 4 LEDs gleichzeitig betrieben werden und nicht mehr als 13 LEDs gleichzeitig leuchten. Ansonsten musst du eine Verstärkerschaltung einbauen.
Ampelanlage mit Anforderungstaster
Da in den Kommentaren danach gefragt wurde (danke an Ben und Mani), habe ich noch eine Version mit Anforderungstastern für die Fußgängerampeln erstellt.
Code
Um die Anforderungstaster nutzen zu können, muss der Code umgebaut werden. Der Befehl
delay();
muss durch Timer-Funktionen ersetzt werden. Das habe ich hier mal im Detail erklärt: Timer mit Arduino – Die Alternative zu Delays.
Wird nun einer der Taster gedrückt und befindet sich gerade die kreuzende Fahrspur im Grün-Modus, wird die vorgesehene Fahrzeit auf 0 gesetzt und somit wird die nächste Ampelphase ausgeführt.
int ledPins[10] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int button1Pin = 12; // Fussgaengerschalter 1
int button2Pin = 13; // Fussgaengerschalter 2
int ampelphasen[10][10] = {
{1, 0, 0, 0, 1, 0, 0, 1, 1, 0}, // state 0
{1, 0, 0, 1, 0, 0, 0, 1, 1, 0}, // state 1
{1, 0, 0, 1, 0, 0, 1, 0, 1, 0}, // state 2
{1, 0, 0, 1, 0, 1, 0, 0, 1, 0}, // state 3
{1, 1, 0, 1, 0, 1, 0, 0, 1, 0}, // state 4
{0, 0, 1, 1, 0, 1, 0, 0, 0, 1}, // state 5
{0, 0, 1, 1, 0, 1, 0, 0, 1, 0}, // state 6
{0, 1, 0, 1, 0, 1, 0, 0, 1, 0}, // state 7
{1, 0, 0, 1, 0, 1, 0, 0, 1, 0}, // state 8
{1, 0, 0, 1, 0, 1, 1, 0, 1, 0} // state 9
};
long wartezeiten[10] = {5000, 2000, 500, 2000, 500, 5000, 2000, 500, 2000, 500};
int myState = 0;
long myTimer = 0;
long myTimeout = 0;
void setup() {
for (int i = 0; i < 10; i++) {
pinMode(ledPins[i], OUTPUT);
}
pinMode(button1Pin, INPUT_PULLUP);
pinMode(button2Pin, INPUT_PULLUP);
}
void zeigeAmpelphase() {
for (int i = 0; i < 10; i++) {
digitalWrite(ledPins[i], ampelphasen[myState][i]);
}
}
void loop() {
if (myTimer+myTimeout<millis()){
myTimer=millis();
myState++;
if (myState >= 10) myState = 0;
myTimeout=wartezeiten[myState];
zeigeAmpelphase();
}
if ((digitalRead(button1Pin)==LOW)&&(myState==0)) myTimeout=0;
if ((digitalRead(button2Pin)==LOW)&&(myState==5)) myTimeout=0;
delay(10);
}
Hier noch eine alternative Version, in der die Fußgänger nach dem Betätigen des Tasters noch etwas warten müssen:
int ledPins[10] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int button1Pin = 12; // Fussgaengerschalter 1
int button2Pin = 13; // Fussgaengerschalter 2
int ampelphasen[10][10] = {
{1, 0, 0, 0, 1, 0, 0, 1, 1, 0}, // state 0
{1, 0, 0, 1, 0, 0, 0, 1, 1, 0}, // state 1
{1, 0, 0, 1, 0, 0, 1, 0, 1, 0}, // state 2
{1, 0, 0, 1, 0, 1, 0, 0, 1, 0}, // state 3
{1, 1, 0, 1, 0, 1, 0, 0, 1, 0}, // state 4
{0, 0, 1, 1, 0, 1, 0, 0, 0, 1}, // state 5
{0, 0, 1, 1, 0, 1, 0, 0, 1, 0}, // state 6
{0, 1, 0, 1, 0, 1, 0, 0, 1, 0}, // state 7
{1, 0, 0, 1, 0, 1, 0, 0, 1, 0}, // state 8
{1, 0, 0, 1, 0, 1, 1, 0, 1, 0} // state 9
};
long wartezeiten[10] = {5000, 2000, 500, 2000, 500, 5000, 2000, 500, 2000, 500};
int myState = 0;
long myTimer = 0;
long myTimeout = 0;
void setup() {
for (int i = 0; i < 10; i++) {
pinMode(ledPins[i], OUTPUT);
}
pinMode(button1Pin, INPUT_PULLUP);
pinMode(button2Pin, INPUT_PULLUP);
}
void zeigeAmpelphase() {
for (int i = 0; i < 10; i++) {
digitalWrite(ledPins[i], ampelphasen[myState][i]);
}
}
void loop() {
if (myTimer + myTimeout < millis()) {
myTimer = millis();
myState++;
if (myState >= 10) myState = 0;
myTimeout = wartezeiten[myState];
zeigeAmpelphase();
}
if ((digitalRead(button1Pin) == LOW) && (myState == 0)) {
myTimer = millis();
myTimeout = 2000;
}
if ((digitalRead(button2Pin) == LOW) && (myState == 5)) {
myTimer = millis();
myTimeout = 2000;
}
delay(10);
}
Und hier noch eine (ungetestete) Variante für Ampelanlagen aus Österreich auf Anfrage von Harald, bei der die Auto-Ampeln viermal blinken, bevor sie auf Gelb schalten.
int ledPins[10] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int button1Pin = 12; // Fussgaengerschalter 1
int button2Pin = 13; // Fussgaengerschalter 2
int ampelphasen[26][10] = {
{1, 0, 0, 0, 1, 0, 0, 1, 1, 0}, // state 0
{1, 0, 0, 1, 0, 0, 0, 1, 1, 0}, // state 1
{1, 0, 0, 1, 0, 0, 0, 0, 1, 0}, // state 2 B
{1, 0, 0, 1, 0, 0, 0, 1, 1, 0}, // state 3 B
{1, 0, 0, 1, 0, 0, 0, 0, 1, 0}, // state 4 B
{1, 0, 0, 1, 0, 0, 0, 1, 1, 0}, // state 5 B
{1, 0, 0, 1, 0, 0, 0, 0, 1, 0}, // state 6 B
{1, 0, 0, 1, 0, 0, 0, 1, 1, 0}, // state 7 B
{1, 0, 0, 1, 0, 0, 0, 0, 1, 0}, // state 8 B
{1, 0, 0, 1, 0, 0, 0, 1, 1, 0}, // state 9 B
{1, 0, 0, 1, 0, 0, 1, 0, 1, 0}, // state 10
{1, 0, 0, 1, 0, 1, 0, 0, 1, 0}, // state 11
{1, 1, 0, 1, 0, 1, 0, 0, 1, 0}, // state 12
{0, 0, 1, 1, 0, 1, 0, 0, 0, 1}, // state 13
{0, 0, 1, 1, 0, 1, 0, 0, 1, 0}, // state 14
{0, 0, 0, 1, 0, 1, 0, 0, 1, 0}, // state 15 B
{0, 0, 1, 1, 0, 1, 0, 0, 1, 0}, // state 16 B
{0, 0, 0, 1, 0, 1, 0, 0, 1, 0}, // state 17 B
{0, 0, 1, 1, 0, 1, 0, 0, 1, 0}, // state 18 B
{0, 0, 0, 1, 0, 1, 0, 0, 1, 0}, // state 19 B
{0, 0, 1, 1, 0, 1, 0, 0, 1, 0}, // state 20 B
{0, 0, 0, 1, 0, 1, 0, 0, 1, 0}, // state 21 B
{0, 0, 1, 1, 0, 1, 0, 0, 1, 0}, // state 22 B
{0, 1, 0, 1, 0, 1, 0, 0, 1, 0}, // state 23
{1, 0, 0, 1, 0, 1, 0, 0, 1, 0}, // state 24
{1, 0, 0, 1, 0, 1, 1, 0, 1, 0} // state 25
};
long wartezeiten[26] = {5000, 2000, 200, 200, 200, 200, 200, 200, 200, 200, 500, 2000, 500, 5000, 2000,200, 200, 200, 200, 200, 200, 200, 200, 500, 2000, 500};
int myState = 0;
long myTimer = 0;
long myTimeout = 0;
void setup() {
for (int i = 0; i < 10; i++) {
pinMode(ledPins[i], OUTPUT);
}
pinMode(button1Pin, INPUT_PULLUP);
pinMode(button2Pin, INPUT_PULLUP);
}
void zeigeAmpelphase() {
for (int i = 0; i < 10; i++) {
digitalWrite(ledPins[i], ampelphasen[myState][i]);
}
}
void loop() {
if (myTimer + myTimeout < millis()) {
myTimer = millis();
myState++;
if (myState >= 26) myState = 0;
myTimeout = wartezeiten[myState];
zeigeAmpelphase();
}
if ((digitalRead(button1Pin) == LOW) && (myState == 0)) {
myTimer = millis();
myTimeout = 2000;
}
if ((digitalRead(button2Pin) == LOW) && (myState == 13)) {
myTimer = millis();
myTimeout = 2000;
}
delay(10);
}
Wenn dir das Projekt gefallen hat und du von weiteren interessanten Projekten inspiriert werden willst, sieh dir doch mal mein neues E-Book »Arduino Projekte Volume 1« an!
- Die beliebtesten Arduino-Projekte von StartHardware
- Inklusive Schaltplan, Beschreibung und Code
- Arduino-Schnellstart-Kapitel
- Kompakter Programmierkurs
Das ist wirklich super geworden die Schaltung
das mit Fritzing muss ich mal testen, habe eigene Schaltungen gemacht
und Platinen nur noch nicht auf die Idee gekommen die mit Fritzing zu testen
Was mir aufgefallen ist, beim ersten Code:
Schaltung von rot nach grün ist in Ordnung
von grün nach rot fehlt der Schritt grün gelb
Hast du den Code in der zwischen zeit mal angepasst
mit besten Grüßen
Wuppermatze
Ampelanlage finde ich super! Soweit in jeder Richtung logisch! Versuche allerdings, die Ampelschaltung für Fußgänger realistisch zu schalten, d.h. auf Tastendruck wird das Hauptprogramm unterbrochen, die Amper für Fahrzeuge schaltet sofort auf rot und die Fußgängerroutine läuft ab. Dann soll die Ampelanlage wieder neu in ihrem loop starten. Das habe ich nicht hinbekommen, auch nicht mit interrupts. Gibt es da ne Lösung oder einen Tip?
Grüße
Ampelanlage finde ich super! Soweit in jeder Richtung logisch! Versuche allerdings, die Ampelschaltung für Fußgänger realistisch zu schalten, d.h. auf Tastendruck wird das Hauptprogramm unterbrochen, die Amper für Fahrzeuge schaltet sofort auf rot und die Fußgängerroutine läuft ab. Dann soll die Ampelanlage wieder neu in ihrem loop starten. Das habe ich nicht hinbekommen, auch nicht mit interrupts. Gibt es da ne Lösung oder einen Tip?
Grüße
Hallo Rainer, das ist doch das Verhalten, das der Code macht, oder nicht? Liebe Grüße Stefan
Kleine Frage würden sie auch eine Ampel Schaltung für einen großen rc pacur schreiben natürlich kosten los versteht sich
Ich verstehe die Frage nicht.
Funktioniert Perfekt
Hallo Stefan
Habe zwei Fragen:
1. Wenn ich meinen Code so anpasse wie du ihn gemacht hast für die Steuerung mit Anforderungstaster dann überspringt er natürlich den State0 da ja myState++; vor zeigeAmpelphase(); kommt.
Das möchte ich aber nicht so haben. Wie könnte ich also den Loop anpassen, dass er den Ablauf wie ohne Anforderungstaster macht.
2. Irgendwie bekomme ich es einfach nicht hin, dass der Loop unterbricht wenn ich mein Taster drücke. Der Taster soll den State0 wieder einberufen und somit diese Fahrspur grün schalten.
Testhalber habe ich es so gemacht, dass dies passiert wenn die kreuzende Fahrspur grün hat (State6) und ich den Taster drücke. Aber es passiert einfach nix… Habe das Gefühl mein Code stimmt nicht. Kannst du ihn mal ansehen?
Mein Code sieht folgendermassen aus:
// C++ code
//
int ledPins[9] = {9, 8, 7, 6, 5, 4, 3, 2, 1};
int buttonNSPin = 12;
int buttonEWPin = 11;
int buttonPPin= 10;
int test[2][11] = {
{1, 1, 1, 1, 1, 1, 1, 1, 1}, // testate 0
{0, 0, 0, 0, 0, 0, 0, 0, 0}, // testate 1
};
int testpause[2] = {3000, 3000};
int myTestate = 0;
int phase[11][9] = {
{1, 0, 0, 1, 0, 0, 1, 0, 0}, // state 0
{1, 1, 0, 1, 0, 0, 1, 0, 0}, // state 1
{0, 0, 1, 1, 0, 0, 1, 0, 0}, // state 2
{0, 1, 0, 1, 0, 0, 1, 0, 0}, // state 3
{1, 0, 0, 1, 0, 0, 1, 0, 0}, // state 4
{1, 0, 0, 1, 1, 0, 1, 0, 0}, // state 5
{1, 0, 0, 0, 0, 1, 1, 0, 0}, // state 6
{1, 0, 0, 0, 1, 0, 1, 0, 0}, // state 7
{1, 0, 0, 1, 0, 0, 1, 0, 0}, // state 8
{1, 0, 0, 1, 0, 0, 0, 0, 1}, // state 9
{1, 0, 0, 1, 0, 0, 0, 1, 0}, // state 10
};
long pause[11] = {3000, 1000, 10000, 4000, 3000, 1000, 10000, 4000, 3000, 10000, 5000};
int myState = 0;
long myTimer = 0;
long myTimeout = 0;
void setup() {
for (int i = 0; i < 9; i++) {
pinMode(ledPins[i], OUTPUT);
}
pinMode(buttonNSPin, INPUT_PULLUP);
pinMode(buttonEWPin, INPUT_PULLUP);
pinMode(buttonPPin, INPUT_PULLUP);
// Test-LED
for (int i = 0; i < 9; i++) {
digitalWrite(ledPins[i], test[myTestate][i]);
}
delay(testpause[myTestate]);
myTestate++;
for (int i = 0; i < 9; i++) {
digitalWrite(ledPins[i], test[myTestate][i]);
}
delay(testpause[myTestate]);
}
void showphase() {
for (int i = 0; i < 9; i++) {
digitalWrite(ledPins[i], phase[myState][i]);
}
delay(pause[myState]);
}
void loop() {
if (myTimer + myTimeout = 11) myState = 0;
myTimeout = pause[myState]
showphase();
}
if ((digitalRead(buttonNSPin) == LOW)&&(myState == 6)) myTimeout=0;
delay(10);
}
}
Herzlichen Dank im Voraus !!
Hi Sam, also der State 0 wird ja nur beim ersten Durchlauf übersprungen, danach wird der ja so wie die anderen States ausgeführt. Ich habe das so gemacht, um den Code möglichst kurzzuhalten. Und der Button in deinem Beispiel wird ja nur angewendet, wenn der State 6 ist. Wenn du den immer auslösen willst, guck dir mal die Verwendung von Interrupts an. Liebe Grüße Stefan
Hallo Stefan,
ich möchte mithilfe des Arduinos eine zeit-und sensorgesteuerte Ampelanlage bauen und es sollte eine Vorrangschaltung für Fahrzeuge enthalten sein, weißt du wie man das macht?
Hallo René,
ich würde das wahrscheinlich so ähnlich machen, wie es mit dem Anforderungstaster funktioniert, nur dass es halt kein Taster sondern der Sensor ist. Die Zeitsteuerung ist ja schon eingebaut.
Liebe Grüße
Stefan
Hallo Stefan,
ich brauche für ein Projekt eine Ampelschaltung mit zwei sich kreuzenden Spuren, und auf der Hauptspur zusätzlich eine Linksabbieger Spur. Eine Fußgängerschaltung ist auch intergiert, jedoch alle über einen Taster angeschlossen. Jede Spur besitzt jedoch zusätzlich noch einen Wartetaster.
Wie bekomme ich es hin, das ich in jedem State , jeden Taster abfrage und dann auch immer die komplette Schaltphase einer Ampel(grün gelb rot) zu Ende laufen lasse, bis ich das durch den Taster geforderte State springe? Kann ich verschiedene Spuren Priorisieren?
Danke und Grüße
Hi Anton, das macht doch das Programmbeispiel weiter unten. Anforderungstaster, die immer funktionieren und dann muss man noch ein bisschen warten, bis es grün wird. Den Code musst du doch nur noch um die Linksabbieger-Spuren erweitern. Guck mal, ob du das vielleicht übersehen hast. Liebe Grüße
Hallo Stefan,
vielen Dank für deinen tollen Sketch und deinerAusführlichen Beschreibung zur Ampelsteuerung
Ich habe schon mehrere Ampeln mit Adruino Nano auf unserem Modellbauparcours ( LKW 1:14 ) 300qm
verbaut – meine Vereinskollegen haben mich gefragt ob es auch möglich sei wie bei uns in Österreich üblich das die grüne LED bevor sie auf gelb umschlatet 4 mal blinkt
bin damit sehr überfordert :-)
kannst du mir hier weiterhelfen ?
Grüße Harald !
Hallo Harald,
ich habe jetzt dem Beitrag ganz unten noch die Code-Variante für Österreich angefügt. Im Austausch musst du den Code aber testen und mir sagen, ob das so funktioniert. Außerdem hätte ich super gern Bilder eures Parcours mit den Ampeln, um sie hier im Beitrag einzufügen. Gern an hallo@starthardware.org ;-) – Ich verlinke auch gern auf eure Website.
Liebe Grüße
Stefan
Hallo Stefan,
das Programm ist wirklich super, vielen Dank dafür! Ich hätte eine Frage zu einer Erweiterung: Wäre es möglich, auch noch einen Summer/akustischen Signalgeber hinzuzufügen, der in der Grünphase der Fußgängerampeln in Intervallen summt?
Viele Grüße
Reg
Ja klar, das sollte gehen. Du musst ja nur im Loop fragen, ob myState 0 (Fussgänger 2 Grün) oder 5 (Fussgänger 1 Grün) ist. Ohne es getestet zu haben, könnte der folgende Code schon funktionieren. Wenn der Zustand der Ampel 0 ist, wird ein Ton an Pin 14 (das ist der analoge Input Pin 0) ausgegeben. Dieser Ton pulsiert Zeitbasiert zwischen 500 und 1500 Herz. Wenn der Zustand 1 ist passiert das Gleiche am Pin 15 (Analog In 1). An diese Pins kannst du einfach Piezos oder Transducer anschließen.
if (myState == 0){
if (millis()%200) {
tone(14,500);
} else tone(14,1500);
} else if (myState == 5){
if (millis()%200) {
tone(15,500);
} else tone(15,1500);
} else {
noTone(14);
noTone(15);
}
Den Code kannst du einfach direkt ins Loop z. B. direkt über dem delay(10) einfügen. Hoffentlich klappt es :-)
Hi Stefan,
ich hatte mir das Video in YouTube angeschaut zwecks Ampelschaltung echt Klasse.
Jetzt meine Frage: Was ist das für eine Software die du da nutzt wo du erklärst wie wo was hin muss ?
Hi Matthias,
vielen Dank für die netten Worte :-) Die Software heißt Fritzing und in ihr gibt es Breadboard-, Schaltplan- und Platinenansicht. Ich hab früher für Fritzing gearbeitet und mag sie sehr, auch wenn sie ein paar Eigenheiten hat, aber wer hat die nicht?! :-D
Liebe Grüße
Stefan
Hallo Stefan,
vielen lieben Dank für den übersichtlichen Code, dank der vielen Array-Lösungen.
Ich meine einen winzigen Fehler für die Startphase (state 0 ) entdeckt zu haben:
state 0 wird beim ersten Durchlauf des Programms nicht korrekt angezeigt, erst ab dem zweiten Durchlauf. Es wundert mich allerdings, dass das bislang unbemerkt / unkommentiert blieb.
Verbesserungvorschlag: myState erst nach gezeigter Ampelphase erhöhen:
zeigeAmpelphase();
myState++;
if (myState >= 10) myState = 0;
Hallo Stefan,
ich finde deinen Sketch zur Ampelschaltung hervorragend und sehr clever gelöst! Die Schaltung funktioniert super!
Ich habe jedoch noch eine Frage:
Ich möchte einen Schalter einbauen, der die Fußgängerampel jederzeit von rot auf grün stellt. Wie könnte man dieses Problem mithilfe deiner Schaltung bewältigen?
Liebe Grüße
Hallo Mani,
ich habe gerade das gleiche Anliegen und würde auch gerne einen Schalter einbauen. Doch ich weiss nicht wie das gehen sollte. Hast du es eventuell herausgefunden wie das geht?
Mit freundlichen Grüsse
So Ben und Mani, ich habe den Beitrag angepasst. Ihr findet nun eine Version mit Anforderungstastern. Bitte probiert das mal aus und sagt mir bescheid, ob das so klappt.
Liebe Grüße
Grüße Dich!
Aber (+) und (-) bei Uno und breadboard?
5v oder 9v?
Bitte schreib ein kurze nachricht!
Ich bedanke mich sehr!
Ich hab Deine Frage noch nicht ganz verstanden, aber gesehen, dass im Schaltplan noch ein Kabel zwischen er blauen Stromschiene des Breadboards zum GND (-) des Arduinos fehlt. Der (+) kommt ja sozusagen aus den digitalen Pins. Hilft dir das schon weiter? Ich ändere die Schaltung auch gleich noch. Liebe Grüße
Geschafft!!! Danke dir sehr! Ich bin 45 jahre alt, aber anfinger in Arduino! Lg Aurelian
Lieber Stefan,
Kannst Du mir sagen wo kann ich finde eine schaltplan mit code, für eine Arduino 6 servo control und programierung mit bluethoot?
Tja, das weiß ich leider nicht. Wie man viele Servos mit Arduino steuern kann, hab ich ja neulich beschrieben. Ansonsten hab ich nur das hier im Netz gefunden.
Super! Danke dir sehr für deine Hilfe nochmal! LG Aurelian
Sehr gerne :-)
Hallo, habe die Schaltung mit dem Arduinio aufgebaut und sie funktioniert wunderbar.
Nun möchte ich allerdings die Schaltung auf meiner Modellbahnanlage einsetzen und versuche, den Code auf einen ATTiny 4313 aufzuspielen. Es funktioniert aber nicht. Die LED`s leuchten teilweise nur konstant. Was mache ich falsch ? Oder kann man den Code nicht auf einen 4313 übertragen? Für kurze Info wäre ich dankbar.
Hallo Wilfried, vielen Dank für Deine Frage. Klingt ja spannend. Ich würde mich über ein paar Fotos der Modellbahn-Ampel freuen ;-) Das Programm sollte eigentlich auch auf dem ATTiny 4313 laufen. Da passieren jetzt keine besonders verrückten Sachen im Code. Hast Du mal einen anderen ATTiny probiert? Funktioniert ein normales blink()-Programm wie erwartet?
Liebe Grüße
Stefan
danke fürs lebenretten