hallo zusammen. ich habe die aufgabe mit einem mycrocontroller (arduino) mehrere leds der reihe nach zu schalten und mit einem button soll ich das programm starten/stoppen können dies habe ich über ein input signal gelöst. mein problem ist die programmierung, da ich eine schleife benutze. der schalter reagiert aber die LEDs machen ihren durchlauf weiter vielleicht hat jemand ne idee, wie ich den code umstellen kann oder ne bessere variante. const int buttonPin = 2; const int ledPin1 = 13; const int ledPin2 = 12; const int ledPin3 = 11; const int ledPin4 = 10; int buttonState = 0; void setup() { pinMode(ledPin1, OUTPUT); pinMode(ledPin2, OUTPUT); pinMode(buttonPin, INPUT); pinMode(ledPin3, OUTPUT); pinMode(ledPin4, OUTPUT); } void loop() { buttonState = digitalRead(buttonPin); if (buttonState == HIGH) { digitalWrite(ledPin2, HIGH); digitalWrite(ledPin1, LOW); digitalWrite(ledPin3, LOW); digitalWrite(ledPin4, LOW); } else { digitalWrite(ledPin2, LOW); digitalWrite(ledPin3, LOW); digitalWrite(ledPin4, LOW); digitalWrite(ledPin1, HIGH); delay(800); digitalWrite(ledPin1, LOW); delay(50); } if (buttonState == HIGH) { digitalWrite(ledPin2, HIGH); digitalWrite(ledPin1, LOW); digitalWrite(ledPin3, LOW); digitalWrite(ledPin4, LOW); } else { digitalWrite(ledPin2, LOW); digitalWrite(ledPin1, LOW); digitalWrite(ledPin4, LOW); digitalWrite(ledPin3, HIGH); delay(800); digitalWrite(ledPin3, LOW); delay(50); } if (buttonState == HIGH) { digitalWrite(ledPin2, HIGH); digitalWrite(ledPin1, LOW); digitalWrite(ledPin3, LOW); digitalWrite(ledPin4, LOW); } else { digitalWrite(ledPin2, LOW); digitalWrite(ledPin1, LOW); digitalWrite(ledPin3, LOW); digitalWrite(ledPin4, HIGH); delay(800); digitalWrite(ledPin4, LOW); delay(50); } }
Hallo Daniel, befürchte es wird niemand aus Deiner Aufganenstellung schlau. Soll eine bestimmtes Bitmuster alle x Sekunden augegeben werden? Wenn der Taster gedrückt wird, was soll dann passieren? Axel
Wenn ich deinen Code richtig gelesen habe sollte das gleich disem Code sein:
1 | const int buttonPin = 2; |
2 | const int ledPin1 = 13; |
3 | const int ledPin2 = 12; |
4 | const int ledPin3 = 11; |
5 | const int ledPin4 = 10; |
6 | |
7 | void setup() |
8 | {
|
9 | pinMode(ledPin1, OUTPUT); |
10 | pinMode(ledPin2, OUTPUT); |
11 | pinMode(buttonPin, INPUT); |
12 | pinMode(ledPin3, OUTPUT); |
13 | pinMode(ledPin4, OUTPUT); |
14 | }
|
15 | |
16 | void loop() |
17 | {
|
18 | //Set everything low at the beginning
|
19 | digitalWrite(ledPin1, LOW); |
20 | digitalWrite(ledPin2, LOW); |
21 | digitalWrite(ledPin3, LOW); |
22 | digitalWrite(ledPin4, LOW); |
23 | |
24 | if (digitalRead(buttonPin)) |
25 | {
|
26 | // Light just LED 2 until button is released
|
27 | digitalWrite(ledPin2, HIGH); |
28 | }
|
29 | else
|
30 | {
|
31 | // Light LED 1,3 and 4 for 0.8 seconds with 0.05 second pauses
|
32 | digitalWrite(ledPin1, HIGH); |
33 | delay(800); |
34 | digitalWrite(ledPin1, LOW); |
35 | delay(50); |
36 | |
37 | digitalWrite(ledPin3, HIGH); |
38 | delay(800); |
39 | digitalWrite(ledPin3, LOW); |
40 | delay(50); |
41 | |
42 | digitalWrite(ledPin4, HIGH); |
43 | delay(800); |
44 | digitalWrite(ledPin4, LOW); |
45 | delay(50); |
46 | }
|
47 | }
|
Das bedeutet, solange keine Taste gedrückt wird, leuchten der Reihe nach immer LED 1,3 und 4 für jeweils 800ms mit einer 50ms Pause. Wenn die Taste gedrückt wird leuchtet LED 2. ABER: Es wird nur alle 2,5 Sekunden geprüft, ob der Taster derückt ist. D.h. du wenn LED 2 leuchten soll, musst du effektiv den Taster drücken sobald LED 4 leuchtet und solange gedrückt halten, bis LED 2 leuchtet.
Kurze Anmerkung, ob der Taster für LED 2 gedrückt werden muss oder LED 2 gerade leuchtet wenn LED 2 nicht gedrückt wird, hängt natürlich davon ab, ob der buttonPin als pullup oder pulldown geschaltet ist.
letztenendes ist das hier die Aufgabe. habe nur andere ein und ausgänge gewählt und weniger genutzt um die programmierung zu testen Mit einem an Pin 13 angeschlossenen Schalter oder Taster soll das Programm gestartet bzw. gestoppt werden können. • Die digitalen Ausgänge 1 - 9 sind so zu programmieren, dass im Sekundentakt jeweils ein Ausgang das Signal" 1" führt. Mit dieser Spannung soll mittels eines Transistors BC 546B eine LED angesteuert werden. Die LED D1 - D9 sind in der Farbe "Grün" und die LED D10 in der Farbe "Rot" auszuführen. Wählen Sie die LED mit IF = 10 - 15 mA. • Der Ausgang 10 soll nach Aktivierung durch den Schalter I Taster ,,1"-Signal führen, am Ausgang 12 soll ein Signal mit f = 10Hz anliegen. der Ausgang 12 ist der, welcher mit dem Schalter Verbunden ist
@verwirrter anfänger. genau so läufts ab. ich versuche grad mit das ganze mit ner änderung von buttonstate zu kombinieren, damit der taster nicht gedrückt bleiben muss, aber das problem ist immernoch, dass das programm, so wie es ist, weiterlöuft. wenn ich das ganze mit 9 leds mache wird die zeit ziemlich lange. kann man die buttonState abfrage nicht irgendwie zwischen die ansteuerung der einzelnen leds setzen?
Grundsätzlich würd ich das so machen, dass du zählst wie lange die LED schon leuchtest und dann umschaltest. Ich bin gerade auf der Arbeit, deshlab hier nur als Pseudodcode:
1 | short currentLed = 13; |
2 | short timeOn = 0; |
3 | short state = 0; |
4 | |
5 | loop() { |
6 | |
7 | if (digitalRead(buttonPin)) { |
8 | // Light just LED 2 until button is released
|
9 | digitalWrite(ledPin2, HIGH); |
10 | currentLed = 13; |
11 | timeOn = 0; |
12 | }
|
13 | else { |
14 | digitalWrite(ledPin2, LOW); |
15 | if(timeOn >= 200) { |
16 | // LED war 1s an, ausschalten und naechste LED asuwaehlen
|
17 | digitalWrite(currentLed, LOW); |
18 | currentLed--; |
19 | if(--currentLed < 10) { |
20 | currentLed = 13; |
21 | }
|
22 | digitalWrite(currentLed, HIGH); |
23 | timeOn = 0; |
24 | }
|
25 | }
|
26 | delay(5); |
27 | }
|
Nur sehr grob. Du zälst wieviele 5ms schleifen die jeweilige LED an war und wenn sie mehr als 200 Schleifen an war gehst du zur nächsten LED weiter. Mögliche Verbesserungen: - LED Pins in einen array packen und den index erhöhen, erlaubt dir die LEDs an nicht aufeinanderfolgenden Pins anzuschließen - Button entprellen / debouncen, ist nicht wirklich notwendig, da du beim prellen einfach ein paar mal resetest bis du letzlich anfängst, ist aber ne gute Angewohnheit
Korrektur, da fehlte noch ein timeOn++:
1 | short currentLed = 13; |
2 | short timeOn = 0; |
3 | short state = 0; |
4 | |
5 | loop() { |
6 | |
7 | if (digitalRead(buttonPin)) { |
8 | // Light just LED 2 until button is released
|
9 | digitalWrite(ledPin2, HIGH); |
10 | currentLed = 13; |
11 | timeOn = 0; |
12 | }
|
13 | else { |
14 | digitalWrite(ledPin2, LOW); |
15 | if(timeOn >= 200) { |
16 | // LED war 1s an, ausschalten und naechste LED asuwaehlen
|
17 | digitalWrite(currentLed, LOW); |
18 | currentLed--; |
19 | if(--currentLed < 10) { |
20 | currentLed = 13; |
21 | }
|
22 | digitalWrite(currentLed, HIGH); |
23 | timeOn = 0; |
24 | }
|
25 | timeOn++; |
26 | }
|
27 | delay(5); |
28 | }
|
hmm...das funktioniert jetzt zwar, aber ich kann mit dem knopf so nur das programm auf dem aktuellen stand anhalten ich bin jetzt so weit, dass ich mit dem knopf alles starten und anhalten kann, allerding immernoch erst zu dem zeitunkt, an dem die schleife virbei ist const int buttonPin = 2; const int ledPin1 = 13; const int ledPin2 = 12; const int ledPin3 = 11; const int ledPin4 = 10; const int analogOutPin = 8; int outputValue = 0; int fadeValue = 0; int buttonPushCounter = 0; int buttonState = 0; int lastButtonState = 0; void setup() { pinMode(ledPin1, OUTPUT); pinMode(ledPin2, OUTPUT); pinMode(buttonPin, INPUT); pinMode(ledPin3, OUTPUT); pinMode(ledPin4, OUTPUT); Serial.begin(9600); } void loop() { digitalWrite(ledPin1, LOW); digitalWrite(ledPin2, LOW); digitalWrite(ledPin3, LOW); digitalWrite(ledPin4, LOW); buttonState = digitalRead(buttonPin); if (buttonState != lastButtonState) { if (buttonState == HIGH) { buttonPushCounter++; } else { } lastButtonState = buttonState; } if (buttonPushCounter % 2 == 0) { digitalWrite(ledPin2, HIGH); for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) { analogWrite(analogOutPin, fadeValue); delay(0.5); } for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) { analogWrite(analogOutPin, fadeValue); delay(0.5); } } else { digitalWrite(ledPin1, HIGH); delay(800); digitalWrite(ledPin1, LOW); delay(20); digitalWrite(ledPin3, HIGH); delay(800); digitalWrite(ledPin3, LOW); delay(20); digitalWrite(ledPin4, HIGH); delay(800); digitalWrite(ledPin4, LOW); delay(20); } }
Hallo, bin Anfänger mit der Programmierung und weis nicht weiter, kann mir jemand ein Programm schreiben für Aeduino uno,ähnich wie weiter oben, um meine Blinker am Fahrad zu steuern? -Habe 2 Taster, Links und Taster Rechts eingebaut. Zwei LED,s. für Links und Rechts (Blinker). Mit Taster Links, Blinker Links einschalten und beim 2x dücken auf den Taster, soll Blinken aus gehen. Für rechten Taster, auch so. Wenn man den einen oder den anderen Taster/Blinker als ersten gedrückt hat, soll der andere Blinker nicht kommen, ausser man bleibt 2 od. 3sec. auf beide Taster, dann kommen beide Led als Warnblink und nochmal 1drücken gehen die wieder aus. Wäre Euch sehr dankbar. Grüße
oh, habe tippfehle, weiter oben meine ich drücken, nicht dücken, sory.
>kann mir jemand ein Programm schreiben für Aeduino uno,ähnich wie weiter >oben, um meine Blinker am Fahrad zu steuern? Was zahlst du?
defekte Lapt0p compaq, ibm älteres laptop? oder 5? reden wir darüber
Hallo, wer könnte mir schreiben, wie ich weiter unten dasProgr.realisieren kann, mit den 2n Taster(für Blinker Rechts) eine 2Led unabhängig von der andere (Led Links) Blinken lasse und beim 2x Taster Rechts drücke, wieder stopt? Und wie sichere ich es so, dass nur einer Blinker kommt? (Beide Blinker sollen dann kommen, nur wen man 3 sec. beide Taster gedrückt sind und 4 sec Tastendruck wieder aus. /* Blinker Fahrad, 1x drücken blinken ein, 2x drücken, blinken aus*/ const int TasterL = 2; // Taster für Blinker Links: Pin 2 const int TasterR = 3; // Taster für Blinker Rechts: Pin3 const int ledPin13 = 13; // Reserve const int ledPin10 = 10; // Led Blinker für Links const int ledPin11 = 11; // Led Blinker für Rechts int fadeValue = 0; int buttonPushCounter = 0; int buttonState = 0; int lastButtonState = 0; void setup() { pinMode(TasterL, INPUT); //Pin 2 als Eingang für Taster Links pinMode(TasterR, INPUT); //Pin 3 als Eingang für Taster Rechts pinMode(ledPin10, OUTPUT); //Pin 10 als Ausgang Blinker Links pinMode(ledPin11, OUTPUT); //Pin 10 als Ausgang Blinker Rechts pinMode(ledPin13, OUTPUT); // soll immer aus Serial.begin(9600); } void loop() { digitalWrite(ledPin10, LOW); digitalWrite(ledPin11, LOW); digitalWrite(ledPin13, LOW); buttonState = digitalRead(TasterL); if (buttonState != lastButtonState) { if (buttonState == HIGH) { buttonPushCounter++; } else { } lastButtonState = buttonState; } if (buttonPushCounter % 2 == 0) { for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) { delay(0.5); } for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) { delay(0.5); } } else { digitalWrite(ledPin10, HIGH); delay(400); digitalWrite(ledPin10, LOW); delay(550); } }
John Pic schrieb: > Hallo, bin Anfänger mit der Programmierung und weis nicht weiter, kann > mir jemand ein Programm schreiben für Aeduino uno,ähnich wie weiter > oben, um meine Blinker am Fahrad zu steuern? BItte kapere keine himmelalten Threads. Du hast ein neues Problem, also mach auch einen neuen Thread auf.
> wer könnte mir schreiben, wie ich weiter unten dasProgr. > realisieren kann, Das Wichtigste, was du realisiern musst ist, das dir das Arduino FRamework ein System vorgibt, welches du nicht verlassen sollst/darfst. Deine Funktion loop() wird regelmässig aufgerufen. D.h. du musst agieren, wie jemand, dem man alle 2 Sekunden einen Fusstritt gibt, der sich dann umschaut, die jeweilige Situation bewertet und entscheidet was jetzt, genau in diesem Moment, anhand dieser Bewertung zu tun gibt. Diese Aktion machst du dann und fällst wieder in einen Schlaf. Bis dann 2 Sekunden später der nächste Fusstritt kommt, an dem du dir wieder die Situation ansiehst, etc. etc. So Dinge, wie längere Schleifen, in denen dann auch noch gewartet wird, willst du nicht haben. Derartige Warteschleifen ersetzt du dadurch, dass du mitzählst, wie oft du einen Fusstritt bekommen hast und zb. beim 10-ten Tritt dann was tust.
Johnpic schrieb: > Und wie sichere ich es so, dass nur einer Blinker kommt? > (Beide Blinker sollen dann kommen, nur wen man 3 sec. beide Taster > gedrückt sind und 4 sec Tastendruck wieder aus. Mit Deiner Programmlogik. Wie wäre es denn, wenn Du zuerst mal mit einer etwas einfacheren Steuerung anfängst, bei der Du nicht darauf achten mußt, wie lange welche Tasten gedrückt werden, sondern nur, ob sie gedrückt werden? Vorschlag von mir: Linker Button ==> wenn Blinker aus, dann links blinken an ==> wenn Blinker an, dann Blinker aus Rechter Button ==> wenn Blinker aus, dann rechts blinken an ==> wenn Blinker an, dann Blinker aus Beide Buttons ==> beide Blinker an D.h. der Doppelblinker würde bei jedem beidseitigen Tastendruck aktiviert werden und könnte mit Druck jedes einzelnen Buttons deaktivert werden, wenn er eingeschaltet ist. Ebenso würde jeder andere Blinker deaktiviert werden, wenn ein weiterer Button gedrückt wird. Gggf. noch zusätzlich mit der Option, dass wenn auf der einen Seite geblinkt wird und dann auf der anderen Seite der Button gedrückt wird, direkt von Linksblinken auf Rechtsblinken umgeschaltet werden kann. Auf jeden Fall aber erstmal so, dass es auf die Dauer der Tastendrücke nicht ankommt. Wie wär's denn damit für den Anfang?
hm, danke Leute, ist echt lustig manchmals, gut auch die einfache Logik,ich versuchs ma, doch wäre nett wenn ich paar Beispiele hätte. grüße
johnpic schrieb: > hm, danke Leute, ist echt lustig manchmals, gut auch die einfache > Logik,ich versuchs ma, doch wäre nett wenn ich paar Beispiele hätte. > grüße Dass die Arduino-Entwicklungsumgebung mit einem - wie ich finde - interessanten und erweiterungsfähigen Beispiel für eine blinkende LED kommt, das weißt Du? Zu finden über: Datei - Beispiele - Digital - BlinkWithoutDelay Dieses "Blinken ohne Delay" finde ich für einen Blinker sehr interessant, weil jedes "delay" Deine Programmausführung anhält und Du während eines laufenden Delays nicht auf Tastendrücke reagieren kannst. In einem normalen Programm ohne Interrupt-Routinen führt ein "delay(800)" dazu, dass unter Umständen mehr als 0,8 Sekunden lang auf eine Taste gedrückt werden muss, bevor die Schaltung den Tastendruck überhaupt auswerten kann. In einem Programm mit interruptgesteuerter Button-Abfrage führt ein "delay(800)" dazu, dass zwar ein Tastendruck registriert reagiert wird, aber die Umschaltung des Blinkprogramms dann ggf. erst mit 0,8 Sekunden Verzögerung tatsächlich stattfindet. Ich würde daher auf dem Beispielprogramm "BlinkWithoutDelay" aufbauen, auf Delays im Programm verzichten, dieses Programm auf die Ansteuerung von zwei LEDs (bzw. 2 LED-Kanälen links/rechts) erweitern und für die Buttons zwei Interrupt-Serviceroutinen schreiben, in denen der Blinkstatus geändert wird, sobald Knöpfe gedrückt werden. So, dass die Blinkschaltung blitzschnell und ohne Verzögerung auf die Buttons reagiert. Viel Code braucht man dazu nicht zu schreiben. Wenn Du Probleme hast, schreibe ich Dir dazu mal was hin.
Jürgen danke für die Erklärung und die Tips von anderen, doch wie sieht ein Programm mit Interuptgest......aus? bitte schreibe mir, so kann ich vergleichen, eher lernen. Wäre super. Ich habe nochmal einiges für 2 Tater und 2 Leds propiert, doch ohne Erfolg.
1 | /* Blinker Fahrad, 1x drücken blinken ein, 2x drücken, blinken aus*/
|
2 | |
3 | const int TasterL = 2; // Taster für Blinker Links |
4 | const int TasterR = 3; // Taster für Blinker Rechts |
5 | const int ledPin13 = 13; // |
6 | const int ledPin10 = 11; // Led Blinker für Links |
7 | const int ledPin11 = 10; // Led Blinker für Rechts |
8 | |
9 | //int outputValue = 0;
|
10 | int fadeValue = 0; |
11 | int buttonPushCounter = 0; |
12 | int buttonState = 0; |
13 | int lastButtonState = 0; |
14 | |
15 | |
16 | void setup() |
17 | {
|
18 | pinMode(TasterL, INPUT); |
19 | pinMode(TasterR, INPUT); |
20 | pinMode(ledPin10, OUTPUT); |
21 | pinMode(ledPin11, OUTPUT); |
22 | pinMode(ledPin13, OUTPUT); |
23 | Serial.begin(9600); |
24 | }
|
25 | |
26 | void loop() |
27 | {
|
28 | digitalWrite(ledPin10, LOW); |
29 | digitalWrite(ledPin11, LOW); |
30 | digitalWrite(ledPin13, LOW); |
31 | buttonState = digitalRead(TasterL); |
32 | |
33 | |
34 | if (buttonState != lastButtonState) { |
35 | |
36 | if (buttonState == HIGH) |
37 | {
|
38 | buttonPushCounter++; |
39 | }
|
40 | else
|
41 | { } |
42 | |
43 | lastButtonState = buttonState; |
44 | }
|
45 | |
46 | |
47 | if (buttonPushCounter % 2 == 0) |
48 | {
|
49 | digitalWrite(ledPin2, HIGH); |
50 | for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) |
51 | {
|
52 | analogWrite(analogOutPin, fadeValue); |
53 | delay(0.5); |
54 | }
|
55 | |
56 | for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) |
57 | {
|
58 | analogWrite(analogOutPin, fadeValue); |
59 | delay(0.5); |
60 | }
|
61 | |
62 | }
|
63 | else
|
64 | {
|
65 | |
66 | digitalWrite(ledPin10, HIGH); |
67 | delay(400); |
68 | digitalWrite(ledPin10, LOW); |
69 | delay(550); |
70 | |
71 | /*digitalWrite(ledPin11, HIGH);
|
72 | delay(800);
|
73 | digitalWrite(ledPin11, LOW);
|
74 | delay(20); */
|
75 | }
|
76 | }
|
johnpic schrieb: > bitte schreibe mir, so kann ich vergleichen, eher lernen. > Wäre super. > Ich habe nochmal einiges für 2 Tater und 2 Leds propiert, doch ohne > Erfolg. Hm, wundert mich irgendwie nicht. Einerseits schreibst Du vom Blinken, andererseits sieht Dein Code danach aus, als wenn Du über Analogausgänge LEDs eher in einem fließenden Übergang per Pulsweitenmodulation heller werden und danach wieder runterdimmen möchtest: > analogWrite(analogOutPin, fadeValue); Blinken heißt für mich aber: Ein- und Ausschalten. Ich habe Dir mal eine Blinker- und Warnblinkerlogik gebastelt und hänge sie als Code dran. Auf Interruptsteuerung habe ich verzichtet, die Taster werden gepollt. Der Code ist nicht ganz perfekt, aber er funktioniert und Du kannst ja selbst damit weitermachen, wenn Du ihn durchschaut hast. Ideen wären beispielsweise, folgendes zu ändern: 1. Nach dem Warnblinken wird bei Betätigung eines Tasters auf Linksblinken oder Rechtsblinken geschaltet. Erst mit zwei Betätigungen derselben Taste ist nach dem Warnblinken der Warnblinker aus. 2. Die Blinkintervalle sind vollkommen unabhängig von der Tastaturbetätigung über Timer gesteuert. Dadurch kann es beim Einschalten passieren, dass der Blinker gerade aus ist und erst nach Ablauf des Aus-Intervalls anfängt zu blinken. Vielleicht bekommst Du ja Ideen.
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.