Arduino Forum

International => Deutsch => Topic started by: pussy123 on Dec 25, 2018, 11:08 am

Title: Einen Loop zeitlich begrenzen
Post by: pussy123 on Dec 25, 2018, 11:08 am
Hallo,
ich bin absoluter Anfänger.
Ich habe folgenden Code, der mittels einer RGB-LED einen Fernseher simuliert (Modellbau).
Den Loop möchte ich gerne zeitlich begrenzen, also z.B. auf eine Dauer von 2 Minuten.
Ich weiß aber nicht, wie das geht.
Kann mir hier jemand behilflich sein?

Code: [Select]

#include <avr/pgmspace.h>

#define redPin    (3)
#define greenPin  (5)
#define bluePin   (6)

void setup() {
}

const uint8_t brightness[][4] PROGMEM = {
        // duration, red, green, blue
{  1,   1,   1,   1},
{ 11,   2,   2,   2},
{  7,   3,   3,   3},
{  4,   4,   4,   4},
{  1,   5,   4,   4},
{  1,   5,   5,   5},
{  1,   6,   5,   5},
{  1,   6,   6,   6},
{  1,   7,   7,   7},
{  1,   8,   7,   7},
{  1,   8,   8,   8},
{  1,   9,   8,   8},
{  1,  11,   9,   9},
{  1,  13,  11,  11},
{  1,  13,  11,  13},
{  1,  16,  13,  13},
{  1,  19,  16,  16},
{  1,  23,  19,  19},
{  2,  27,  23,  23},
{  1,  32,  27,  27},
{  1,  38,  32,  32},
{  1,  45,  32,  38},
{  1,  54,  38,  38},
{  1,  64,  45,  45},
{  1,  64,  54,  54},
{  1,  76,  64,  64},
{  1,  90,  64,  76},
{  1, 107,  76,  76},
{  1, 128,  90,  90},
{  1, 152, 107, 107},
{  1, 180, 128, 128},
{ 20, 152, 128, 128},
{  3, 152, 107, 128},
{  1, 152, 107, 107},
{ 21, 128, 107, 107},
{  1, 128, 107,  90},
{  6, 128,  90,  90},
{  6, 107,  90,  90},
{  4, 107,  90,  76},
{  8,  90,  76,  76},
{  4,  90,  76,  64},
{  9,  76,  76,  64},
{  1,  76,  76,  54},
{  5,  76,  64,  54},
{  7,  64,  64,  45},
{ 11,  64,  64,  38},
{  6,  54,  54,  38},
{  7,  54,  54,  32},
{ 10,  45,  54,  32},
{  6,  45,  54,  27},
{  1,  45,  54,  32},
{  1,  45,  54,  27},
{  1,  27,  64,  64},
{  1,  27,  54,  64},
{  8,  27,  54,  54},
{212,  19,  27,  23},
{ 17,  19,  27,  27},
{ 23,  27,  54,  54},
{121,  23,  54,  54},
{  3,  23,  54,  45},
{ 17,  23,  54,  54},
{  9,  38,  32,  19},
{ 13,  38,  32,  23},
{  1,  38,  32,  19},
{  1,  38,  32,  23},
{  1,  38,  32,  19},
{  1,  38,  32,  23},
{ 24,  32,  32,  16},
{  4,  32,  27,  16},
{  8,  32,  32,  16},
{  6,  32,  32,  13},
{ 30,  27,  27,  13},
{ 14,  32,  32,  13},
{ 30,  32,  27,  13},
{  1,  32,  32,  13},
{  2,  32,  27,  13},
{ 14,  32,  27,  11},
{  4,  27,  27,  11},
{  1,   5,   5,   3},
{  1,   4,   5,   3},
{  2,   5,   6,   3},
{ 13,   5,   6,   4},
{  1,   5,   6,   3},
{  1,   5,   6,   4},
{  1,   5,   6,   3},
{  1,   5,   6,   4},
{  8,   6,   6,   4},
{  1,   5,   6,   4},
{  1,   6,   6,   4},
{  1,   6,   7,   4},
{ 39,   6,   8,   4},
{  4,   7,   8,   4},
{ 47,   6,   7,   3},
{ 38,   6,   6,   3},
{  4,   6,   7,   3},
{  2,   6,   7,   4},
{ 54,   7,   8,   4},
{  4,   7,   9,   4},
{  7,   7,   8,   4},
{ 42,   7,   9,   4},
{ 14,   7,   9,   5},
{  4,   8,   9,   5},
{  9,   8,  11,   5},
{  4,   9,  11,   5},
{  1,   9,  11,   6},
{ 10,   9,  13,   6},
{  8,  11,  13,   6},
{  5,   9,  13,   6},
{  1,  11,  13,   6},
{  1,   9,  13,   6},
{  1,  11,  13,   6},
{  4,  11,  13,   7},
{  1,  11,  13,   6},
{  4,   9,  13,   6},
{  7,   9,  13,   7},
{  1,   9,  13,   6},
{  1,   9,  13,   7},
{  6,  11,  13,   7},
{  1,   9,  13,   7},
{ 44,  11,  13,   7},
{ 24,   9,  13,   7},
{ 31,  11,  13,   7},
{ 13,   9,  13,   7},
{  1,  11,  13,   7},
{  1,   9,  13,   7},
{126,   9,  11,   7},
{  1,   8,  11,   7},
{  2,   7,  11,   7},
{ 34,  19,  76,  90},
{ 64,   7,  11,   7},
{ 71,   9,  11,   7},
{ 21,  11,  11,   7},
{  1,   9,  11,   7},
{  1,  11,  11,   7},
{ 27,   9,  11,   7},
{  5,  11,  11,   7},
{  4,   9,  11,   7},
{  9,  27,  32,  32},
{ 11,  23,  32,  32},
{  1,  27,  32,  32},
{  3,  23,  32,  27},
{ 13,  23,  27,  27},
{  1,  23,  32,  27},
{  1,  23,  27,  27},
{  1,  23,  32,  27},
{  1,  23,  27,  27},
{  1,  23,  32,  27},
{  1,  23,  27,  27},
{ 10,  23,  32,  27},
{ 34,  23,  27,  27},
{  1,  23,  32,  27},
{  1,  23,  27,  27},
{ 23,  23,  32,  27},
{  2,  27,  32,  27},
{  3,  23,  32,  32},
{ 81,  27,  32,  32},
{ 26,  27,  38,  32},
{  2,  27,  38,  38},
{  5,  27,  45,  38},
{  9,  38,  90, 107},
{  4,  38,  76,  76},
{  1,  38,  64,  64},
{  1,  32,  64,  64},
{  3,  32,  64,  76},
{  1,  32,  76,  76},
{  1,  38,  76,  76},
{  3,  38,  64,  76},
{  1,  32,  64,  76},
{ 26,   4,   8,   6},
{ 48,  23,  45,  64},
{ 39,  38,  64,  76},
{ 25,  32,  64,  76},
{  3,  38,  64,  76},
{  7,  38,  76,  76},
{ 24,  38,  64,  76},
{  4,  38,  76,  76},
{  1,  45,  76,  76},
{  4,   8,  11,  11},
{  2,   8,  11,   9},
{  1,   9,  11,   9},
{  6,  38,  90, 107},
{  3,  45,  90, 107},
{  6,  23, 107, 180},
{  1,  27,  45,  23},
{  2,  32,  45,  23},
{  1,  27,  45,  23},
{ 80,  45,  13,  11},
{ 36,  27, 107, 214},
{ 52,  32,  76,  64},
{ 59,  27,  45,  23},
{ 55,  23,  38,  23},
{  1,  11,  16,  11},
{  1,   3,   3,   3},
{  1,   2,   2,   2},
{ 25,   3,   4,   3},
{ 29,   3,   3,   2},
{  1,   3,   3,   3},
{  2,   3,   3,   2},
{  4,   2,   3,   2},
{  1,   3,   3,   2},
{  1,   2,   3,   2},
{ 22,   2,   2,   2},
{255,   2,   2,   2},
{210,   2,   3,   2},
{  2,   3,   3,   2},
{ 21,   3,   3,   3},
{  4,   3,   3,   2},
{  1,   3,   3,   3},
{  3,   3,   3,   2},
{  1,   3,   3,   3},
{ 36,   3,   4,   3},
{  1,   3,   3,   3},
{  1,   7,   7,   7},
{  1,   8,   7,   7},
{  1,   7,   7,   7},
{  1,   8,   7,   7},
{ 16,   8,   7,   8},
{  1,  23,   9,   3},
{  1,  19,   8,   3},
{  1,  13,   6,   2},
{  1,   6,   3,   2},
{  1,   2,   1,   2},
{  1,   1,   1,   1},
{ 22,  32, 128, 214},
{ 17,  32, 107, 214},
{  6,  32, 107, 180},
{ 17,  32,  90, 180},
{  1,  32, 107, 180},
{ 62,  32, 107, 214},
{  8,  32, 128, 214},
{ 11,  32, 107, 214},
{  3,  32, 128, 214},
{ 47,  32, 107, 214},
{  2,  32, 107, 180},
{198,   1,   1,   1},
{  1,   1,   1,   1}
};

void loop() {
        int elements = sizeof(brightness) / sizeof(brightness[0]);
       
        for (int i=0; i < elements; i++) {
                int count = pgm_read_byte(&(brightness[i][0]));
                int red   = pgm_read_byte(&(brightness[i][1]));
                int green = pgm_read_byte(&(brightness[i][2]));
                int blue  = pgm_read_byte(&(brightness[i][3]));

                analogWrite(redPin,   red);
                analogWrite(greenPin, green);
                analogWrite(bluePin,  blue);
   
                for (int j=count; j>0; j--)
                        delay(40);
        }
}
Title: Re: Einen Loop zeitlich begrenzen
Post by: noiasca on Dec 25, 2018, 11:13 am
du musst fertig überlegen:

Wenn du nach 2 Minuten dein Geblinke ausschalten willst, wodurch soll das gezappel wieder eingeschaltet werden?
Title: Re: Einen Loop zeitlich begrenzen
Post by: HotSystems on Dec 25, 2018, 11:37 am
Die loop begrenzen ist sicher keine gute Idee.
Die sollte immer durchlaufen und dann lässt du millis() mitzählen und schaltest das Geflacker aus.
Per Taster kannst du es dann bei Bedarf wieder einschalten.
Und nach der gewünschten Zeit schaltet es wieder aus.
Title: Re: Einen Loop zeitlich begrenzen
Post by: combie on Dec 25, 2018, 12:06 pm
Quote
Den Loop möchte ich gerne zeitlich begrenzen, also z.B. auf eine Dauer von 2 Minuten.
Ich weiß aber nicht, wie das geht.
Kann mir hier jemand behilflich sein?
Klar!



Ablaufsteuerung
Meine Standardantwort zu Ablaufsteuerungen:
Quote
Eine Stichworte Sammlung für Google Suchen:
Endlicher Automat,
State Machine,
Multitasking,
Coroutinen,
Ablaufsteuerung,
Schrittkette,
BlinkWithoutDelay, 
--
Blink Without Delay (https://www.arduino.cc/en/Tutorial/BlinkWithoutDelay)
Der Wachmann (https://forum.arduino.cc/index.php?topic=423688.0)
--
Multitasking Macros  (https://forum.arduino.cc/index.php?topic=415229.msg2859554)
Intervall Macro (https://forum.arduino.cc/index.php?topic=413734.msg2848523)
Title: Re: Einen Loop zeitlich begrenzen
Post by: michael_x on Dec 25, 2018, 12:27 pm
Quote
Den Loop möchte ich gerne zeitlich begrenzen, also z.B. auf eine Dauer von 2 Minuten.
Code: [Select]
void loop() {
  if (millis() > 2*60*1000L) return;  // nach 2 Minuten nichts mehr machen.
...
}
reagiert dann nur noch auf Reset

Normalerweise nimmt man statt eines Absolutwerts millis() immer eine Differenz (millis ( ) - startzeit) und macht doch noch ein bisschen mehr als nichts, nach Ablauf der Zeit.
Title: Re: Einen Loop zeitlich begrenzen
Post by: pussy123 on Dec 25, 2018, 08:04 pm
Hallo zusammen,

vielen Dank für eure Antworten!

Ich habe mich anscheinend zu ungenau ausgedrückt. Sorry!

Daher möchte ich präziser beschreiben, was ich eigentlich möchte: 

Ich möchte das Programm für das Wohnzimmer eines Hauses auf meiner Modellbahn nutzen und dabei den folgenden Ablauf simulieren:

Wenn das Wohnzimmer "betreten wird", soll die Wohnzimmer-Lampe (eine separate weiße LED) an gehen, 20 Sekunden später soll die im Sketch dargestellte TV-Simulation starten, diese soll für eine bestimmte Zeit laufen (die erwähnten 2 Minuten), dann TV-Simulation aus und 20 Sekunden später soll auch die weiße LED aus gehen (Wohnzimmer wird verlassen).

Es wäre super nett, wenn ihr mir Programmzeilen schreiben könntet. Sowas wie Endlicher Automat,
State Machine, Multitasking, Coroutinen, Ablaufsteuerung ... sagen mir überhaupt nichts!

DANKE!
Title: Re: Einen Loop zeitlich begrenzen
Post by: Tommy56 on Dec 25, 2018, 08:11 pm
Die von Dir noch nicht beantwortete Frage lautete: Wodurch soll der Ablauf (dann wieder) gestartet werden?

Gruß Tommy
Title: Re: Einen Loop zeitlich begrenzen
Post by: combie on Dec 25, 2018, 08:14 pm
Quote
Es wäre super nett, wenn ihr mir Programmzeilen schreiben könntet.
Ich nenne das mal vorsichtig: Überzogene Erwartungshaltung.


Quote
Sowas wie Endlicher Automat, State Machine, Multitasking, Coroutinen, Ablaufsteuerung ... sagen mir überhaupt nichts!
Das kannst du ändern.


Title: Re: Einen Loop zeitlich begrenzen
Post by: pussy123 on Dec 25, 2018, 09:51 pm
@Tommy, ich habe mir so gedacht, ich würde anschließend in anderen Räumen die Lichter in unterschiedlichen Zeitabständen an und ausschalten lassen, um dann den von mir beschriebenen Ablauf im Wohnzimmer erneut zu starten.
Title: Re: Einen Loop zeitlich begrenzen
Post by: HTML-Fan on Dec 25, 2018, 09:59 pm
Also damit ich das jetzt richtig verstehe:

Stimmt das so oder habe ich das falsch verstanden?
Title: Re: Einen Loop zeitlich begrenzen
Post by: pussy123 on Dec 25, 2018, 11:21 pm
Also 2 bis 8 definitiv ja.
Ob das mit dem Reset so sein muss, das kann ich nicht sagen (fehlende Kenntnisse  :smiley-confuse:)
Title: Re: Einen Loop zeitlich begrenzen
Post by: michael_x on Dec 25, 2018, 11:44 pm
Einfacher wäre:
9. 5 Minuten warten, dann weiter bei 2.

Dann kann man das ewig laufen lassen.
Title: Re: Einen Loop zeitlich begrenzen
Post by: Doc_Arduino on Dec 25, 2018, 11:52 pm
Hallo,

weil Weihnachten ist lauffähig abgeändert.  :)
Pins und Zeiten kannste selbst für dich korrigieren.
Das Einzigste was blockiert ist die for Schleife in der simulation_TV() aber das stört hier nicht.
Dadurch läuft die TV Simu noch einmal komplett durch wenn die TV EIN-Zeit vorher knapp "verpasst" wurde.
Sollte hier auch egal sein. Die Dauer eines TV Simulationsdurchlaufes kannste ausrechnen.

Ist zu lang zum einbetten.
Title: Re: Einen Loop zeitlich begrenzen
Post by: pussy123 on Dec 26, 2018, 09:53 am
Guten Morgen Doc-Arduino,
vielen, vielen Dank für den Sketch. Läuft super. Spiele jetzt mit den Zeiten rum.
Demnächst versuche ich weitere LEDs mit unterschiedlichen Ein- und Aus-Zeiten zu implementieren.
Werde mich sicherlich noch mal melden  :D
Vielen Dank auch an alle anderen.
Wünsche noch einen angenehmen 2. Weihnachtstag.

 
Title: Re: Einen Loop zeitlich begrenzen
Post by: noiasca on Dec 26, 2018, 10:03 am
OT: eigentlich eine nette Weihnachtsgeschichte, die zeigt wenn man nett ist dann bekommt man auch mal Sachen die das übliche Maß an Programmhilfe bei weitem überschreitet. Kommt immer darauf an, wie man in den Wald ruf.

Leider haben noch nicht alle Neuanmeldungen dieses zwischenmenschliche System verstanden und so warten sie bis zum Sonnenuntergang ^^
Title: Re: Einen Loop zeitlich begrenzen
Post by: Doc_Arduino on Dec 26, 2018, 11:45 am
Hallo,

genau spiele rum, lerne zu verstehen was im Sketch alles wie passiert. Am Bestern wäre wenn du den Sketch irgendwann komplett lesen kannst. Dann haste viel gewonnen.

@ noiasca:   :smiley-mr-green:
Title: Re: Einen Loop zeitlich begrenzen
Post by: HTML-Fan on Dec 26, 2018, 01:20 pm
Kleine Idee: Verändere doch den Sketch so, dass das Flackern nicht immer gleich ist, sondern zufällig generiert. 1. ist es dann etwas realistischer, da ja nicht immer das gleiche Programm im Fernsehen läuft und 2. musst du dann nicht dieses KByte oder wie viel das ist für das Speichern der Werte im Array draufgehen lassen.
Title: Re: Einen Loop zeitlich begrenzen
Post by: Doc_Arduino on Dec 26, 2018, 05:19 pm
Hallo,

wir machen noch eine kleine Schönheitsänderung.
Das RGB ausschalten am Ende der simulation_TV Funktion nehmen wir raus.
Das schreiben wir in den case Zweig TV_Simu rein. Das 3x digitalWrite meine ich.
Code: [Select]

case TV_SIMU: if ( verzoegerung(10000, letzte_zeit) ) {  // 10 Sekunden
                   letzte_zeit = millis();
                   digitalWrite(redPin, LOW);
                   digitalWrite(greenPin, LOW);
                   digitalWrite(bluePin, LOW);
                   Serial.println("TV Simulation aus ... Pause 2");
                   zustand = PAUSE_ZWEI;
                 }
                 else {
                  zustand = TV_EIN;
                 }
                 break;

Das bewirkt das Endgültige aus erst beim Zustandswechsel zur nächsten Pause. Damit kannste nahtlos wiederholende Lichteffekte erstellen ohne das nach Durchlaufende der TV zwangsweise kurz ausgeht.