Arduino UNO | IF Schleife |

[Ostfront (Gast)]

Guten Tag,

Ich habe hier ein kleineres Problem, und hoffe mir kann jemand helfen.

Ich würde gerne mit 2 Tastern 2 Leds ansteuern:

---------------------------------------------------------------------

Taster 1 wird gedrück ----> Led 1 blinkt ---> Taster 1 wird erneut 
gedrückt

------> Led 1 geht aus


Taster 2 wird gedrückt ----> Led 2 blinkt ---> Taster 2 wird erneut 
gedrückt

------> Led 2 geht aus

----------------------------------------------------------------------

Leider weiß ich nicht wie ich das machen soll ohne dass man einen der 
Taster

nur 1 mal drücken muss. Deshalb habe ich jetzt das ganze jetzt einfach 
mit

2 if und while Schleifen gemacht - geht nicht ;/

Hier der Code :

int TasterR = 12;
int TasterL = 11;
int LedL = 13;
int LedR = 10;

void setup(){
  pinMode(TasterR,INPUT);
  pinMode(TasterL,INPUT);
  pinMode(LedL,OUTPUT);
  pinMode(LedR,OUTPUT);
}

void loop(){
  
  if (digitalRead(TasterL)== HIGH){
  while(digitalRead(TasterL)== HIGH){
    digitalWrite(LedL,HIGH);
    delay(500);
    digitalWrite(LedL,LOW);
    delay(500);
    digitalWrite(LedL,HIGH);
    delay(500);
    digitalWrite(LedL,LOW);
    delay(500);
  }
  }
  
  if (digitalRead(TasterL)== LOW){
  while(digitalRead(TasterL)== LOW){
    digitalWrite(LedL,LOW);
    delay(500);
  }
  }
  
  //-----------------------------------------------
 
 if (digitalRead(TasterR)== HIGH){
  while(digitalRead(TasterR)== HIGH){
    digitalWrite(LedR,HIGH);
    delay(500);
    digitalWrite(LedR,LOW);
    delay(500);
    digitalWrite(LedR,HIGH);
    delay(500);
    digitalWrite(LedR,LOW);
    delay(500);
  }
  }
  
  if (digitalRead(TasterR)== LOW){
  while(digitalRead(TasterR)== LOW){
    digitalWrite(LedR,LOW);
    delay(500);
  }
  }
    
}

Es passiert einfach nichts wenn ich einen der Taster drücke ...
Wenn ich allerdings den 1 Teil alleine benutze geht es (über //--- ...)

Ich hoffe mir kann jemand helfen ^^

Danke !

[if-Abfrage (Gast)]

http://www.if-schleife.de/

[Immitsch Berater (Gast)]

"if-Abfrage" rotzte einen Link hin....

Ist das die einzige "Hilfe", die Du geben kannst? Armes Schwein!

[Jürgen S. (jurs)]

Ostfront schrieb:
> Es passiert einfach nichts wenn ich einen der Taster drücke ...

Wenn Du auf das Drücken der Taster reagieren möchtest, dann mußt Du 
nicht auf den Status des Tasters an sich reagieren, sondern auf eine 
Statusänderung.

Arbeite dazu das Arduino StateChangeDetection-Beispiel durch!

In der Arduino-Software zu finden unter:
Datei - Beispiele - 02.Digital - StateChangeDetection

[if-Abfrage (Gast)]

Immitsch Berater schrieb:
> Ist das die einzige "Hilfe", die Du geben kannst?
Nein.

[Immitsch Berater (Gast)]

Immitsch Berater fragte:
>> Ist das die einzige "Hilfe", die Du geben kannst?
>Nein.

Na -nicht so einsilbig! Gib eine vernünftige Hilfe, so ein blöder Link
nützt dem TO soviel wie Fußpilz.

[Winfried J. (Firma: Nisch-Aufzüge) (winne)]

Immitsch Berater schrieb:
> "if-Abfrage" rotzte einen Link hin....
>
> Ist das die einzige "Hilfe", die Du geben kannst? Armes Schwein!

deine leistung ist eher geringer zu bewerten, denn obige hatte 
wenigstens Informationsgehalt was deinem Beitrag nicht entnehmbar ist.

Also klage der Armselige nicht über Armut Anderer.


Back to topic

Du musst zusätzlich den gegenwärtigen zustand verarbeiten und die 
Tastenabfrage unabhängig vom Blinken also auch während der Blinkroutine 
erledigen.

wenn du  also keine Interrupts benutzen willst solltest du Flags, welche 
welche den Tastenstatus und den zustand der LEDS zwischenspeichern.

Beachte, dass während des Blinkens in deinem jetzigen Programm nichts 
anderes passieren kann.

[Dieter F. (Gast)]

Guggst Du hier: http://arduino.cc/de/Reference/BooleanVariables

[Immitsch Berater (Gast)]

Winfried schrieb:
>Also klage der Armselige nicht über Armut anderer.

Entschuldige gleich mehrfach, großer Meister...

Mir geht nur immer dann der Hut hoch, wenn schulmeisternde Nicht-helfer
in Gang kommen.

[klapper (Gast)]

Immitsch Berater schrieb:
> Immitsch Berater fragte:
>>> Ist das die einzige "Hilfe", die Du geben kannst?
>>Nein.
>
> Na -nicht so einsilbig! Gib eine vernünftige Hilfe, so ein blöder Link
> nützt dem TO soviel wie Fußpilz.

Das ist Basiswissen. Dagegen enthalten deine Beiträge, Immitsch Berater, 
überhaupt keine Hilfe und ziehen vollkommen richtige Beiträge auch noch 
runter.

[Forengast (Gast)]

Immitsch Berater schrieb:
> Gib eine vernünftige Hilfe, so ein blöder Link nützt dem TO soviel
> wie Fußpilz.

Du denkst etwas kurz.

Erstmal nützt es den anderen, wenn er damit in die Lage versetzt wird, 
einen weniger unsinnigen Titel für seinen Thread zu wählen. Und damit 
nützt er sich selbst, weil dann vielleich nicht so viele, von seiner 
eigentlichen Frage abweichenden Beiträge kommen.

[Dieter F. (Gast)]

Während die beiden sich weiter streiten ...
Meine Antwort war auch etwas kurz:-)

Leider weiß ich nicht, wie Du die Taster angeschlossen hast. "Üblich" 
ist ein interner Pullup-Widerstand am Taster-Pin (wie im Beispiel-Link) 
mit Schalten gegen GND.

Wenn Du das so machst, kannst Du den Beispiel-Code (erstmal für einen 
Taster) nahezu unverändert übernehmen. Nur das Blinken muss noch 
ermöglicht werden (Kommentare entfernt ...):

void loop()
{
  if (digitalRead(switchPin) == LOW)
  {
    delay(100);
    running = !running;
  }
  if (running)
  {
    digitalWrite(LEDpin, HIGH);
    delay(500);
    digitalWrite(LEDpin, LOW);
    delay(500);
  }
}

Sinngemäß kannst Du jetzt 2 "running"-Variablen für 2 Taster und 2 LEDs 
einrichten ...

[omg (Gast)]

Dieter Frohnapfel schrieb:
> Sinngemäß kannst Du jetzt 2 "running"-Variablen für 2 Taster und 2 LEDs
> einrichten ...

Warum soll er es für die andere Taste machen, wenn der Code für die 
erste schon nicht funktioniert.
 .. aber hast recht, soll er seine Hausaufgaben selber machen.

[Dieter F. (Gast)]

omg schrieb:
> Warum soll er es für die andere Taste machen, wenn der Code für die
> erste schon nicht funktioniert.

Wäre nicht schlecht, wenn Du liest bevor Du hier "rumgrätzt". Meine 
Aussage bezog sich auf den von mir angegeben Link zur Nutzung boolscher 
Variablen. Wenn er das übernimmt und den Code wie angegeben anpasst 
sollte das Ganze schonmal für eine LED und einen Taster funktionieren.

Jetzt kannst Du Dich gerne darüber aufregen, wieso kein Interrupt 
genutzt wird ... :-)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Ostfront schrieb:
> delay(500);
Ich habe die Ursache aller Probleme entdeckt. Mit einem delax() 
vernichtet man einfach teure Rechenzeit.

Sieh dir mal die Funktion millis() an. Sie ist (zusammen mit einer 
Zustandsvariablen) die Lösung deiner Probleme. Denk mal drüber nach: die 
Hauptschleife läuft ständig mit maximaler Geschwindigkeit durch. Und 
abhängig von einem Tastendruck merkst du dir in einer Variablen, was 
gerade für ein Zustand aktuell ist und reagierst darauf...

[Rolf Magnus (Gast)]

Dieter Frohnapfel schrieb:
> omg schrieb:
>> Warum soll er es für die andere Taste machen, wenn der Code für die
>> erste schon nicht funktioniert.
>
> Wäre nicht schlecht, wenn Du liest bevor Du hier "rumgrätzt". Meine
> Aussage bezog sich auf den von mir angegeben Link zur Nutzung boolscher
> Variablen. Wenn er das übernimmt und den Code wie angegeben anpasst
> sollte das Ganze schonmal für eine LED und einen Taster funktionieren.

Der hilft eigentlich gar nicht. Das Problem sind, wie Lothar schon 
schreibt, die Delays, die für's Blinken benutzt werden. Die sind bei 
deiner Lösung immer noch da.

> Jetzt kannst Du Dich gerne darüber aufregen, wieso kein Interrupt
> genutzt wird ... :-)

Die wären allerdings eine Lösung. Man kriegt es zur Not auch ohne 
Interrupt, nur mit einem Timer hin, aber mit Interrupt ist es eigentlich 
einfacher. Wichtig ist halt, die Delays loszuwerden, da die halt alles 
blockieren. Wärend eines Blinkzyklus wird halt keine Taste abgefragt, 
und eine zweite LED noch parallel zu handhaben, wird damit auch nicht 
besser.

Immitsch Berater schrieb:
> Mir geht nur immer dann der Hut hoch, wenn schulmeisternde Nicht-helfer
> in Gang kommen.

Merkst aber leider nicht, daß du selbst einer davon bist. Du belehrst 
andere, wie sie zu antworten haben, bringst aber selbst exakt 0 Hilfe.

Immitsch Berater schrieb:
> Ist das die einzige "Hilfe", die Du geben kannst? Armes Schwein!

Von dir kam noch weniger, und das muss man erstmal schaffen.

[marc (Gast)]

>Mit einem delax() ..

Delax ... ein wunderbares Wort. Das gefällt mir sehr gut. Es ist we 
"relax" nur langsamer. "Delax" eben.

[Immitsch Berater (Gast)]

Rolf Magnus schrieb:
>Wichtig ist halt , die Delays loszuwerden, da die halt alles
>blockieren. Wärend eines Blinkzyklus wird halt keine Taste abgefragt,
>und eine zweite LED noch parallel zu handhaben, wird damit auch nicht
>besser.

Du regst Dich über "Delay" auf, verwendest aber in 2 Sätzen 3x "Halt".
Da steht ja das Programm nur noch...

[klapper (Gast)]

Immitsch Berater schrieb:
> Rolf Magnus schrieb:
>>Wichtig ist halt , die Delays loszuwerden, da die halt alles
>>blockieren. Wärend eines Blinkzyklus wird halt keine Taste abgefragt,
>>und eine zweite LED noch parallel zu handhaben, wird damit auch nicht
>>besser.
>
> Du regst Dich über "Delay" auf, verwendest aber in 2 Sätzen 3x "Halt".
> Da steht ja das Programm nur noch...

Oh wie lustig, ein richtiger Droll.

[Rolf Magnus (Gast)]

klapper schrieb:
> Oh wie lustig, ein richtiger Droll.

Vor allem ein richtiger Troll. Als solcher hat er sich damit jetzt 
endgültig geoutet.

[Dieter F. (Gast)]

Ist ja wirklich konstruktiv hier ...

O.K. - mein letzter Vorschlag war nicht so prall (schlecht abgeleitet 
vom einfachen Ein- / Ausschalten) - aber wie nachstehend sollte es in 
Arduino-Kreisen (nicht unbedingt meine Welt) funktionieren:

unsigned long LedR_time  = Millis();
unsigned long Blink_time = 500;

void loop()
{
  if (digitalRead(TasterR) == LOW)
  {
    delay(100);
    runningR = !runningR;
    LedR_time = Millis();

    if (runningR)
       digitalWrite(LedR, HIGH);
    else
       digitalWrite(LedR, LOW);
  }

  if (runningR)
  {
     if((Millis() - LedR_time) > Blink_time)
     {
         if (digitalRead(LedR) == LOW)
             digitalWrite(LedR, HIGH);
         else
             digitalWrite(LedR, LOW);
         LedR_time = Millis();
     }
  }
}

Das geht sicher noch viel eleganter (mit "richtigen Timern und 
Interrupts" und ordentlicher Entprell-Routine) :-) sollte aber in dieser 
Form (mit dem impliziten Millis()-Interrupt) wenigstens funktionieren.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dieter Frohnapfel schrieb:
> Das geht sicher noch viel eleganter (mit "richtigen Timern und
> Interrupts" und ordentlicher Entprell-Routine) :-)
Es geht ganz ohne jegliches Delay noch wesentlich einfacher. Ich 
verwende hier einfach zwei Zustandsautomaten mit Namen Blinken1 und 
BLinken2:

unsigned long tiAkt;
unsigned long tiBlinken1;
unsigned long tiBlinken2;
int Blinken1; // 0 = nicht Blinken // ungleich 0 --> Blinken 
int Blinken2; // das LSB zeigt den Pegel für die LED an:
              // ungerade Zahl => LED an, Gerade Zahl => LED aus
void loop() 
  // die für diese Schleife gültige Zeit ein einziges Mal am Schleifenanfang abholen
  tiAkt = millis();

  // Taster 1
  if (digitalRead(Taster1) == HIGH) // Taster 1 nicht betätigt
    tiEntprelle1 = tiAkt+20;
  if (tiAkt>tiEntprelle1) {        // Timout => Taster 1 min. 10ms betätigt
    tiBlinken1 = tiAkt;
    tiEntprelle1 = ti.Akt+20000;   // Gebastelt: wird schon keiner den Taster 20 Sekunden lang drücken... ;-)
    if (Blinken1!=0)               // sind wir mit Blinken beschäftigt? 
      Blinken1 = 0;                // ja: ausschalten
    else
      Blinken1 = 1;                // nein: mit dem Blinken anfangen
  }
  if (Blinken1==0) {               // müssen wir überhaupt Blinken?
        digitalWrite(Led1, LOW);   // nein: LED ausschalten
  } else {                         
    if (tiAkt>tiBlinken1) {        // ja: Zeit für nächsten Pegelwechsel?
      if (Blinken1&1)              // LSB abfragen (gerade/ungerade) 
        digitalWrite(Led1, HIGH);
      else
        digitalWrite(Led1, LOW);
      Blinken1++;                  // LSB umschalten
      tiBlinken1 = tiAkt +500;     // nächste Aktion in 500ms
    }
  }

  // Taster 2
  if (digitalRead(Taster2) == HIGH) // Taster 2 nicht betätigt
    tiEntprelle1 = tiAkt+20;
  if (tiAkt>tiEntprelle2) {        // Timeout => Taster 2 min. 10ms betätigt
    tiBlinken2 = tiAkt;
    tiEntprelle2 = ti.Akt+20000;   // Gebastelt: wird schon keiner den Taster 20 Sekunden lang drücken... ;
    if (Blinken2!=0)               // sind wir mit Blinken beschäftigt? 
      Blinken2 = 0;                // ja: ausschalten
    else 
      Blinken2 = 1;                // nein: zu Blinken anfangen
  }
  if (Blinken2==0) {               // müssen wir überhaupt Blinken?
        digitalWrite(Led2, LOW);   // nein: LED ausschalten
  } else {                         
    if (tiAkt>tiBlinken2) {        // ja: Zeit für nächsten Pegelwechsel?
      if (Blinken2&1)              // LSB abfragen (gerade/ungerade) 
        digitalWrite(Led2, HIGH);
      else
        digitalWrite(Led2, LOW);
      Blinken2++;                  // LSB umschalten
      tiBlinken2 = tiAkt +500;     // nächste Aktion in 500ms
    }
  }
  
  // Sonstige Zustandsautomaten
  // ...
}

Weit&breit kein delay(). Und nur der impilizite Interrupt für millis().
Man könnte den Trick mit dem Hochzählen von Blinken1/2 
selbstverständlich auch entkoppeln, und eine richtige Flankenerkennung 
einbauen, um "verständlicheren" Code zu erhalten:

int Blinken1;  // 0 = nicht Blinken // 1 = Blinken 
int OnOff1;    // 0 = LED aus // 1 = LED an
int Taste1Alt; // für Flankenerkennung
 
void loop() 
  // die für diese Schleife gültige Zeit ein einziges Mal am Schleifenanfang abholen
  tiAkt = millis();

  // Taster 1
  if (digitalRead(Taster1) == HIGH) { // Taster 1 nicht betätigt
    tiEntprelle1 = tiAkt+20;
    Taste1Alt = HIGH;
  }
  if (tiAkt>tiEntprelle1) {        // Timout => Taster 1 min. 10ms betätigt
    if (Taste1Alt==HIGH) {         // Flanke?  
      Taste1Alt = LOW;
      tiBlinken1 = tiAkt;
      Blinken1 = !Blinken;         // Zustand "Blinken" umschalten
      OnOff = 1;
    }
  }
  if (Blinken1==0) {               // müssen wir überhaupt Blinken?
        digitalWrite(Led1, LOW);   // nein: LED ausschalten
  } else {                         
    if (tiAkt>tiBlinken1) {        // ja: Zeit für nächsten Pegelwechsel?
      if (OnOff1==1) {             // Zustand abfragen 
        digitalWrite(Led1, HIGH);
        OnOff1 = 0;
    } else {
        digitalWrite(Led1, LOW);
        OnOff1 = 1;
    }
    tiBlinken1 = tiAkt +500;       // nächste Aktion in 500ms
  }

  // Taster 2 entsprechend
  //...

  // Sonstige Zustandsautomaten
  // ...

Der Trick bei diesem Programmierstil ist, dass es schnurzegal ist, in 
welcher Reihenfolge die Automaten berechnet werden, sie sind unabhängig 
voneinander. Und es ist sogar schnurzegal, in welcher Reihenfolge die 
if-Abfragen kommen. Dieser Code wird genausogut funktionieren:

unsigned long tiAkt;
unsigned long tiBlinken1;
unsigned long tiBlinken2;
int Blinken1; // 0 = nicht Blinken // ungleich 0 --> Blinken 
int Blinken2; // das LSB zeigt den Pegel für die LED an:
              // ungerade Zahl => LED an, Gerade Zahl => LED aus
void loop() 
  // die für diese Schleife gültige Zeit ein einziges Mal am Schleifenanfang abholen
  tiAkt = millis();

  // Sonstige Zustandsautomaten
  // ...

  // Taster 1
  if (Blinken1==0) {               // müssen wir überhaupt Blinken?
        digitalWrite(Led1, LOW);   // nein: LED ausschalten
  } else {                         
    if (tiAkt>tiBlinken1) {        // ja: Zeit für nächsten Pegelwechsel?
      if (Blinken1&1)              // LSB abfragen (gerade/ungerade) 
        digitalWrite(Led1, HIGH);
      else
        digitalWrite(Led1, LOW);
      Blinken1++;                  // LSB umschalten
      tiBlinken1 = tiAkt +500;     // nächste Aktion in 500ms
    }
  }
  if (tiAkt>tiEntprelle1) {        // Timout => Taster 1 min. 10ms betätigt
    if (Taste1Alt==HIGH) {         // Flanke?  
      Taste1Alt = LOW;
      tiBlinken1 = tiAkt;
      Blinken1 = !Blinken;         // Zustand "Blinken" umschalten
    }
  }
  if (digitalRead(Taster1) == HIGH) { // Taster 1 nicht betätigt
    tiEntprelle1 = tiAkt+20;
    Taste1Alt = HIGH;
  }
  
  // Taster 2 entsprechend
  //...

[Dieter F. (Gast)]

Lothar Miller schrieb:
> noch wesentlich einfacher

Ob das nun so ist - oder auch nicht liegt im Ermessen des Betrachters.

Nur um zwei LEDs mit Taster zum Blinken zu bringen reicht die 
"Billig-Lösung" :-) - denke ich - auch aus. Die 200 mS "Verlust" sind in 
diesem Fall sicher zu verschmerzen.

Wenn da noch mehr hinzukommt wird der TO andere Wege gehen müssen. Aber 
dazu gibt es ja auch X Tutorials und Beispiele ...

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dieter Frohnapfel schrieb:
> Ob das nun so ist - oder auch nicht liegt im Ermessen des Betrachters.
Es ist wesentlich einfacher, wenn man sich die SPS-Automaten-Denkweise 
mal angeeignet hat:
Einlesen (Eingänge und Zeitstempel in Variablen, die sich während der 
Verarbeitung nicht ändern)
Verarbeiten (schnellstmögliche Berechung der aktiven Zustände mit 
lokalen Variablen)
Ausgabe (aus den Zustandsvariablen an die Ausgänge)

Idealerweise wird im Verarbeitungsteil keine EA direkt manipuliert.

Und dass dieses Verfahren gut funktioniert beweisen zigmilliarden SPS, 
die von jedem angelernten Schlosser (bitte nicht persönlich nehmen!) 
programmiert werden können. Und zwar so, dass der Rest der Anlage 
unverändert funktioniert.

Dieter Frohnapfel schrieb:
> Wenn da noch mehr hinzukommt wird der TO andere Wege gehen müssen.
Das ist der Witz beim obigen Prinzip: er muss es einfach irgendwo 
dazubauen, weil die anderen Schritte auch in der Reihenfolge komplett 
unabhängig sind.

[Dieter F. (Gast)]

Lothar Miller schrieb:
> Es ist wesentlich einfacher, wenn man sich die SPS-Automaten-Denkweise
> mal angeeignet hat:

Da ich mich beruflich damit beschäftige ist mir das EVA-Prinzip durchaus 
geläufig. Trotzdem erlaube ich mir eine eigene Denkweise :-) (nicht böse 
gemeint ...).

Es geht hier um ein Led an / Led aus Spielchen eines vermeintlichen 
Anfängers, der sich ja nicht weiter äußert (lacht sich vielleicht über 
die Beiträge kaputt ?).

Wir können jetzt auch über Multitasking, Multithreading und andere 
interessante Ansätze debattieren - das führt aber, glaube ich, zu weit.

Übrigens wollte ich mal Schreiner werden (nach Astronaut, Chemiker und 
...) hat sich aber im Laufe meines Lebens anders ergeben :-)

[chris_ (Gast)]

Man könnte das Problem natürlich auch mit meinem Programm Sequencer 
lösen:

http://hobby-roboter.de/forum/viewtopic.php?f=4&t=143

Die zweite, etwas kompliziertere Ausführung ist für mehrere Sequenzen ( 
Tasks ).

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

chris_ schrieb:
> Man könnte das Problem natürlich auch mit meinem Programm Sequencer
> lösen:
Oder ein Mulitasking OS aufsetzen...

> Man könnte das Problem natürlich auch mit meinem Programm Sequencer
> lösen:
Ich würde dort die Zeit aber auf stabilere Beine als auf ein delay(1) 
stellen...

[omg (Gast)]

Dieter Frohnapfel schrieb:
> void loop()
> {
>   if (digitalRead(TasterR) == LOW)
>   {
>     delay(100);
>     runningR = !runningR;
>     LedR_time = Millis();
>
>     if (runningR)
>        digitalWrite(LedR, HIGH);
>     else
>        digitalWrite(LedR, LOW);
>   }
>
>   if (runningR)
>   {
>      if((Millis() - LedR_time) > Blink_time)
>      {
>          if (digitalRead(LedR) == LOW)
>              digitalWrite(LedR, HIGH);
>          else
>              digitalWrite(LedR, LOW);
>          LedR_time = Millis();
>      }
>   }
> }

Wow jetz hast du es ja noch schlechter gemacht.



Dieter Frohnapfel schrieb:
> Da ich mich beruflich damit beschäftige ist mir das EVA-Prinzip durchaus
> geläufig. Trotzdem erlaube ich mir eine eigene Denkweise :-) (nicht böse
> gemeint ...).
 Hoffentlich bekomme ich nie ein Produkt das du erdacht hast.

Dieter Frohnapfel schrieb:
> Es geht hier um ein Led an / Led aus Spielchen eines vermeintlichen
> Anfängers, der sich ja nicht weiter äußert
 Das offensichtlich viel zu kompliziert für Deine Denkweise ist.
 Er hat genau geschrieben das er das Blinken mit einem Tastendruck an 
bzw abgeschaltet haben möchte.
 Du bietest ihm dagegen einen Code der wie wild das Blinken an und 
abschaltet solange eine Taste gedrückt ist oder nicht.

Dieter Frohnapfel schrieb:
> Meine Aussage bezog sich auf den von mir angegeben Link zur Nutzung >boolscher 
Variablen.
  Wenn du schon ein Beispiel bringst, sollte die Variable auch irgendwo 
herkommen, und beinhalten wo die Variable herkommt. Auf jeden Fall ein 
miserables Beispiel, oder soll es ein Zufallergebniss bringen?

Dieter Frohnapfel schrieb:
> Wenn er das übernimmt und den Code wie angegeben anpasst
> sollte das Ganze schonmal für eine LED und einen Taster funktionieren.
 Ebend genau nicht, weil dein Code der Tastenerkennung absoluter Schrot 
ist und absolut gar nichts mit der Aufgabenstellung zu tun hat. Du 
toggelst deine undefinierte "boolsche Variable",  nur einfach dumm rum, 
solange eine Taste gedrückt ist oder nicht gedrückt ist(ka welche Logik 
seine Tasten haben).
 Den Code wie man blinken lässt hatte er ja schon selber.
 Vielleicht solltest du die das Posting des TO einfach mal durchlesen 
und versuchen seine Aufgabe die er lösen möchte zu verstehen.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dieter Frohnapfel schrieb:
> Wir können jetzt auch über Multitasking, Multithreading und andere
> interessante Ansätze debattieren
Das ist doch hier keinesfalls das Thema. Und auch der Einsatz eines 
komplexen Schedulers macht eine Aufgabe nicht automatisch einfach. Es 
ist nur so, dass viele Anfänger (auch ich damals!) die delay() 
Geschichte noch kapieren, EVA dann aber als "Eingabe, Verarbeitung, 
Ausgabe" verstehen, und gleich mal auf die Eingabe warten.
Siehe das da: 
http://www.inf-schule.de/programmierung/imperativeprogrammierung/konzepteimp/programme/konzept_eva
EVA auf dem uC bedeutet aber "Einlesen, Verarbeiten, Ausgeben" oder 
markanter "Eingänge, Verarbeitung, Ausgänge". Dann ist klar, wann was zu 
passieren hat. Und EVA passiert auch nicht nur einmal, sondern ständig 
in einer Schleife. Pro Sekunde mindestens 1000 mal.

Auf jeden Fall ist mir ein Programm, in dem wertvoll gekaufte und 
versorgte Rechenzeit mit einem delay() vernichtet wird, von vorn herein 
suspekt. Denn evtl. brauche ich diese Rechenzeit später mal dringend für 
eine Erweiterung. Und dann geht es los: Ist dieses delay() hier wichtig, 
oder darf ich es rausmachen?

Dieter Frohnapfel schrieb:
> Es geht hier um ein Led an / Led aus Spielchen eines vermeintlichen
> Anfängers, der sich ja nicht weiter äußert
Es ist egal ob er sich äussert. Andere werden diesen Thread finden...

Und es sind doch genau diese einfachen LED Spielchen, an denen man das 
saubere Programmieren lernen sollte/müsste/könnte. Oder darf man so 
"simple" Sachen als Anfänger ruhig schlampig machen, richtig komplexe 
Sachen dann aber bitteschön schon sauber?

[Dieter F. (Gast)]

Lothar Miller schrieb:
> Oder darf man so
> "simple" Sachen als Anfänger ruhig schlampig machen, richtig komplexe
> Sachen dann aber bitteschön schon sauber?

Dann hast Du Dein erstes Led an/aus wahrscheinlich mit Multitasking oder 
Zustandsautomat etc. programmiert? Kann ich nicht glauben ... aber 
nichts ist unmöglich ...

Lothar Miller schrieb:
> in dem wertvoll gekaufte und
> versorgte Rechenzeit

häh - auf einem Arduino? Leben wir im gleichen Universum?

Lothar Miller schrieb:
> Und EVA passiert auch nicht nur einmal, sondern ständig
> in einer Schleife. Pro Sekunde mindestens 1000 mal.

Und wo steht das geschrieben? Interessant, muss ich mir merken, als 
feste Größe.

Wenn ich Dir auf den Schlips getreten habe - sorry, wollte ich nicht. 
Brauchst Dich auch gar nicht über mich aufzuregen - schon eher über die 
unsachlichen Beiträge, die hier sonst noch so auftauchen. Da wir die 
beiden einzigen Namentlichen (außer  Winfried J.) in diesem anonymen 
Gewurschtel sind ist es sowieso lächerlich.

Ist für mich jetzt erledigt, da der TO sowieso unsichtbar ist. Habe auch 
nicht gerade eine Privat-Fehde mit Dir am laufen ...

[Dieter F. (Gast)]

Lothar Miller schrieb:
> Oder darf man so
> "simple" Sachen als Anfänger ruhig schlampig machen, richtig komplexe
> Sachen dann aber bitteschön schon sauber?

Oh, da fällt mir noch eine hübsche Analogie ein, die ich noch loswerden 
möchte.

Du hast den Schlosser angesprochen. Der feilt im ersten Lehrjahr 
ordentlich an irgendwelchen Werkstücken rum - mit ganz primitiven 
Mitteln (einer Feile) - um das Handwerk zu erlernen. Später nutzt er 
auch Maschinen - auch Computer-gesteuert (hier kommt der Hilfs-Schlosser 
mit der SPS-Programmierung ins Spiel).

Aber ohne die Grundlagen - in diesem Fall Feilen - läuft da nichts. Man 
muss erstmal ein Gefühl für ein "Werkstück" bekommen ...

Die Spielerei mit Leds etc. sehe ich ähnlich.

Jetzt bin ich ruhig :-)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dieter Frohnapfel schrieb:
> Lothar Miller schrieb:
>> Oder darf man so
>> "simple" Sachen als Anfänger ruhig schlampig machen, richtig komplexe
>> Sachen dann aber bitteschön schon sauber?
> Dann hast Du Dein erstes Led an/aus wahrscheinlich mit Multitasking oder
> Zustandsautomat etc. programmiert? Kann ich nicht glauben ... aber
> nichts ist unmöglich ...
Wie schon Lothar Miller schrieb:
>> dass viele Anfänger ( *auch ich damals!* ) die delay() Geschichte noch
>> kapieren, EVA dann aber als "Eingabe, Verarbeitung, Ausgabe" verstehen,
>> und gleich mal auf die Eingabe warten.
Das bedeutet, dass auch ich erst mal lernen musste, ohne 
Millisekunden-lange Delays auszukommen.

> Lothar Miller schrieb:
>> in dem wertvoll gekaufte und versorgte Rechenzeit
> häh - auf einem Arduino?
Auch dort. Kann ja gut sein, dass ein Arduino-Programmierer später mal 
was anderes macht...
> Leben wir im gleichen Universum?
Ja, ein Arduino besteht aus einem AVR und wird mit einem C Derivat 
programmiert. Genau das selbe machen "Profis" auch. Nur evtl. mit einer 
anderen IDE...

> Lothar Miller schrieb:
>> Und EVA passiert auch nicht nur einmal, sondern ständig
>> in einer Schleife. Pro Sekunde mindestens 1000 mal.
> Und wo steht das geschrieben?
In der Zeile vor deiner Frage... ;-)
Im Ernst: wenn ich eine Hauptschleife programmiere, dann kommt dort ein 
Performance-Zähler rein (kein Aufwand: nur ein Funktionsaufruf), der die 
durchschnittliche und die maximale Schleifenzeit ermittelt. Und wenn die 
Schleifenzeit über eine ms ansteigt, ist das für mich ein Warnsignal und 
ich sehe mir die Ursache schon mal genauer an.

> Wenn ich Dir auf den Schlips getreten habe
Keine Sorge, die Diskussion ist sehr sachlich (mal von ein paar verbalen 
Fouls [omg] abgesehen).

> Übrigens wollte ich mal Schreiner werden (nach Astronaut, Chemiker und
> ...) hat sich aber im Laufe meines Lebens anders ergeben :-)
Da hatte ich es leicht: ich wollte schon mit 10 Jahren Ingenieur werden. 
Weil nämlich dieser dämliche Detektorempfänger aus dem "Werkbuch für 
Jungen" ums Verrecken nicht funktioniert hat. Wobei, da fällt mir ein: 
auch andere Dinge daraus haben nicht so richtig funktioniert...  :-/

Dieter Frohnapfel schrieb:
> Aber ohne die Grundlagen - in diesem Fall Feilen - läuft da nichts.
Richtig, man muss am Code herumfeilen. Man darf schon mal ein delay() 
reinprogrammieren, dann muss aber die Frage kommen: Brauche ich das 
wirklich? Möchte ich Rechenzeit vernichten? Wie kann ich das umgehen?

Was meinst du, wie schnell ein PC wäre, wenn alle delay() sauber 
herausprogrammiert worden wären?
(Klar kann da bei einem delay() ein Taskwechsel kommen, wenn das OS es 
kann, aber den gibts auch nicht für lau...)
Ich denke: wir würden uns wundern...

[Dieter F. (Gast)]

Lothar Miller schrieb:
> "Werkbuch für
> Jungen"

Hanni Thöne (oder so ähnlich) - auch für mich "Zukunftsweisend" :-)

Falsch - jetzt fällt es mir ein "Was Jungen basteln" kommt von "Hanni 
Thöne" oder so ähnlich ... Scheinst in etwa mein Jahrgang (ü50) zu sein.

Ich (wie wahrscheinlich viele Andere) bin hier nur Hobby-mässig 
unterwegs. Ich verdiene mein Geld weder mit Arduino- noch mit anderer 
Programmierung (omg - wer auch immer das sein mag - kann aufatmen :-))

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dieter Frohnapfel schrieb:
> Scheinst in etwa mein Jahrgang (ü50) zu sein.
Nein, noch u50...  :-P

> Lothar Miller schrieb:
>> "Werkbuch für Jungen"
Rudolf Wollmann
Gabs in einigen Auflagen (ich habe 2 davon) bis 1991:
http://www.amazon.de/Werkbuch-Jungen-Bastelbuch-Einf%C3%BChrungen-Grundlagen/dp/3473423521

[Dieter F. (Gast)]

Lothar Miller schrieb:
> Nein, noch u50...  :-P

Jungfuchs :-)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dieter Frohnapfel schrieb:
> Jungfuchs :-)
Grufti... ;-)

[Winfried J. (Firma: Nisch-Aufzüge) (winne)]

na da wären ja nun die alten Säcke (darf mich dazu zählen, Jg 60)unter 
sich und der Jungspunt von TO auf und davon.
;) geschafft.

Namaste

[if-gott (Gast)]

https://if-abfrage.de

Wenn es richtig sein soll.

[if-gott (Gast)]

https://if-abfrage.de/