switch case mit wartezeiten

[Daniel J. (n0i5ebreak3r)]

Guten Tag,

habe mal wieder eine Frage auf die ich keine Lösung gefunden habe.

Ich möchte zwischen 2 case Anweisung eine Warteschleife einbauen. Das 
ganze soll so aussehen.

...
case dimmup:
     Lampe hochdimme innerhalb von 30Minuten;
     break;

Warteschleife ca 8 Stunden

case dimmdown:
     Lampe runterdimmen innerhalb von 30Minuten;

Wahrscheinlich werde ich mit Timern arbeiten müssen oder ähnliches da 
ich davon aber nicht viel ahnung habe komme ich nicht weiter die dimm 
Funktion und soweiter Funktioniert ja schon ich möchte jetzt bloß das 
nach dem Hochdimmen der ustand für eine Bestimmte Zeit bleibt, bis dann 
zur nächsten Case Anweisung gesprungen wird.

MFG, Daniel Joachims

[Dominik S. (dasd)]

Geht so nicht.
Ich versteh' aber ehrlich gesagt auch nicht so ganz, was du vor hast.
Erläutere das ganze doch bitte noch etwas.

[Rolf M. (rmagnus)]

So richtig Sinn ergibt die Frage niht. Du weißt, was case macht?

[Daniel J. (n0i5ebreak3r)]

Dann erläutere ich mal mein vorhaben,

Ich habe ein Aquarium welches ich mit einem Sonnenaufgang und 
Sonnenuntergang simulieren möchte. Dazu soll ein LED Band mittels PWM 
innerhalb von 30 Minuten hochdimmt werden, am Abend das gleiche nur 
umgekehrt also innerhalb von 30 Minuten runterdimmen. Zwischen diesen 
beiden Aktionen soll ein Zeit definierbar sein.

MFG, Daniel Joachims

[Daniel J. (n0i5ebreak3r)]

Rolf Magnus schrieb:
> So richtig Sinn ergibt die Frage niht. Du weißt, was case macht?

Anscheinden weiß ich das nicht ich habe so eine LED Rainbow Lampe mit 
einem Attiny45 wo ein Programm mit mehreren Case läuft, daran das dies 
nach und nach abgearbeitet werden, habe ich gedacht man kann da zwischen 
auch eine Pause einfügen. Aber da habe ich mich wohl getäuscht.

MFG, Daniel Joachims

[Peter D. (peda)]

Nimm einfach noch einen 3. Case:

case dimmup:
// code
case wait_8h:
// code
case dimmdown:
// code

Peter

[Daniel J. (n0i5ebreak3r)]

Peter Dannegger schrieb:
> Nimm einfach noch einen 3. Case:
>

> case dimmup:
> // code
> case wait_8h:
> // code
> case dimmdown:
> // code
>

>
>
> Peter

Und dann in case wait_8h: eine Warteschleife einbauen?

[Ralf G. (ralg)]

Daniel Joachims schrieb:
> Und dann in case wait_8h: eine Warteschleife einbauen?

Wie ist denn die halbe Stunde für's Dimmen realisiert?
Dieses Unterprogramm einfach auf 8h 'aufbohren'.

[Daniel J. (n0i5ebreak3r)]

Ralf G. schrieb:
> Daniel Joachims schrieb:
>> Und dann in case wait_8h: eine Warteschleife einbauen?
>
> Wie ist denn die halbe Stunde für's Dimmen realisiert?
> Dieses Unterprogramm einfach auf 8h 'aufbohren'.

Das Unterprogramm sieht so aus:

case dimmup:
  abortFade = 0;
  fade(255,255,255,180000,180000,180000);
  break;

case dimmdown:
  abortFade = 0;
  fade(0,0,0,180000,180000,180000);
  break;

Anmerkung ich möchte mich hier nicht mit falschen Federn schmucken. Der 
Original Code stammt vom LED-LAMP FADER Author: Christoph Brennig, 
Copyright (c) 2011. Ich habe diesen auf meine bedürfnisse Angepasst 
abgeändert.

[Rolf M. (rmagnus)]

Daniel Joachims schrieb:
> Rolf Magnus schrieb:
>> So richtig Sinn ergibt die Frage niht. Du weißt, was case macht?
>
> Anscheinden weiß ich das nicht ich habe so eine LED Rainbow Lampe mit
> einem Attiny45 wo ein Programm mit mehreren Case läuft, daran das dies
> nach und nach abgearbeitet werden, habe ich gedacht man kann da zwischen
> auch eine Pause einfügen. Aber da habe ich mich wohl getäuscht.

Beim Switch wird eine Variable eingelesen und verzweigt (case). Je nach 
Wert wird einer der case-Pfade ausgefürt. Es gibt bei den Cases aber 
keine zeitliche Abfolge. Denk auch daran, daß du die cases auch beliebig 
vertauschen kannst, ohne daß das am Programmablauf was ändern würde.
Stell dir vor, du stehst an einer Kreuzung und mußt wählen, ob du nach 
links, geradeaus oder nach rechts gehst. Auf einem Zettel steht, wo du 
hin mußt. Wenn auf dem Zettel "links" oder "geradeaus" steht, läufst du 
sofort los, wenn aber "rechts" drauf steht, wartest du noch 8 Stunden 
mit dem Lesen des Zettels. Klingt irgendwie komisch, oder?

Daniel Joachims schrieb:
> Peter Dannegger schrieb:
>> Nimm einfach noch einen 3. Case:
>>> case dimmup:
>> // code
>> case wait_8h:
>> // code
>> case dimmdown:
>> // code
>> >
>>
>> Peter
>
> Und dann in case wait_8h: eine Warteschleife einbauen?

Mit switch/case alleine kannst du keinen zeitlichen Verlauf machen. Wozu 
bauchst du das da überhaupt? Schreib deinen Ablauf doch einfach so hin:

    hochdimmen();
    wait_8h();
    runterdimmen();

Mit switch/case kann man das auch machen, aber dann mußt du den Code 
zyklisch laufen lassen. Bei Verwendung von Timern brauchst du das. Da 
wartest du aber nicht zwischen den Cases, sondern gehst in jedem Zyklus 
gehst du das switch/case einmal durch und entscheidest da abhängig vom 
Zustand, was du jetzt machst. Als Pseudocode würde das etwa so aussehen:

timer = 0;
zustand = dimmup;
Schleife
{
    switch (zustand)
    {
        case dimmup:
            einen Schritt hochdimmen
            if (timer == 30 Minuten)
            {
                zustand = wait_8h;
                timer = 0;
            }
            break;
        case wait_8h:
            if (timer == 8h)
            {
                zustand = dimmdown;
                timer  = 0;
            }
            break;
        case dimmdown:
            einen Schritt runterdimmen
            if (timer == 30 Minuten)
            {
                 // fertig. was nun?ß
            }
            break;
    }
    wait_1ms(); // oder bei Verwendung eines Timers: warte auf Timer-Event
    timer += 1ms;
}

[Ralf G. (ralg)]

Dann lass die zwei case-Anweisungen und füge jeweils noch 
'fade(255,255,255,180000*16,180000*16,180000*16);' bzw. 
'fade(0,0,0,180000*16,180000*16,180000*16);' ein.
Ich hoffe, dass ich die Zahlen richtig interpretiere, und die 180000 die 
Zeitverzögerung ist.

[Daniel J. (n0i5ebreak3r)]

Ralf G. schrieb:
> Dann lass die zwei case-Anweisungen und füge jeweils noch
> 'fade(255,255,255,180000*16,180000*16,180000*16);' bzw.
> 'fade(0,0,0,180000*16,180000*16,180000*16);' ein.
> Ich hoffe, dass ich die Zahlen richtig interpretiere, und die 180000 die
> Zeitverzögerung ist.

Die ersten 3 Zahlen geben an bis zu welchem Wert gedimmt werden soll. 
Die Letzten 3 Zahlen geben die Zeitspanne an in der das ganze passiert.

[Ralf G. (ralg)]

Daniel Joachims schrieb:
> Die Letzten 3 Zahlen geben die Zeitspanne an in der das ganze passiert.

Na, dann passt's doch! 'Der' dimmt dann einfach weiter :-)

[Daniel J. (n0i5ebreak3r)]

Wäre ja zu schön anscheinend ist dem ganzen ein Zeitliche Grenze gesetz. 
Wo dann der Controller einfach nichts macht außer das alle 3 Kanäle 
sofort auf 100% sind.

[Rolf M. (rmagnus)]

Sieh es als Chance, was neues zu lernen ;-)

[Ralf G. (ralg)]

Daniel Joachims schrieb:
> Wäre ja zu schön anscheinend ist dem ganzen ein Zeitliche Grenze gesetz.

Welche Grenze? Dann probier's doch mal mit Werten im sec...min-Bereich. 
Was passiert bei welchen Zeiten? Evtl. die Funktion eben 16x aufrufen.

Oder mach's richtig:
Rolf Magnus schrieb:
> Sieh es als Chance, was neues zu lernen ;-)

[Stefan ++ (Gast)]

Hallo Leute,

ihr habt euch jetzt alle auf eine "State-Machine" mit case Anweisungen 
und dergleichen eingeschossen und dabei Daniels Problem aus den Augen 
verloren.

Daniel Joachims schrieb:
> Ich habe ein Aquarium welches ich mit einem Sonnenaufgang und
> Sonnenuntergang simulieren möchte.

Zu diesem Zweck braucht er eine Schaltuhr. Also eine Uhr die zu einer 
bestimmten Zeit hochdimmt und zu einer bestimmten Zeit (Einschaltzeit + 
8h) wieder runter dimmt. Er muss auch daran denken, dass der Strom mal 
ausfällt etc., wie synchronisiert er das sonst wieder auf die Tageszeit.

Wie man eine Uhr programmiert ist, denke ich, ist jedem klar.
Dazu brauchts noch eine Eingabemöglichkeit für die Uhrzeit, und eine für 
die Einschaltzeit (+ Ausschaltzeit).
Eine "State-Machine" arbeitet dann nur noch in Abhängigeit davon ob sich 
die aktuelle Uhrzeit zwischen Ein-und Ausschaltzeit befindet oder nicht. 
Im einen Fall wird innerhalb einer halben Stunde bis zum Anschlag hoch 
gedimmt und im anderen bis auf 0 runter.
Alles was man für Uhr und dimmen dazu braucht ist ein Timer-Interrupt 
und das main-Programm beschäftigt sich nur mit den Eingabetasten und 
Anzzeige.

Damit kommt man auch ohne diese unsäglichen Warteschleifen aus, die nach 
meiner Meinung in einem halbwegs vernünftigen Programm nichts zu suchen 
haben. (einzige Ausnahme: kurze Delays im max. 1 stelligen ms-Bereich)

Gruss Stefan

[Karl H. (kbuchegg)]

Stefan ++ hat recht.
Der ganze Ansatz mit dieser Fade-Funktion ist zu nichts zu gebrauchen. 
So verführerisch diese Dinge auch immer wieder klingen, dieser Weg führt 
in einen Sackgasse.

Das Faden muss passieren, indem man sich aus der aktuellen Uhrzeit 
errechnet, welchen Dimmgrad die Lampen zu diesem Zeitpunkt haben sollen.

Wie Stefan schon ausführte, geht das ganze über eine Uhr. Zusätzlich 
führt man noch 4 Zeiten mit (2 würden auch gehen, mit 4 ist es jedoch 
einsichtiger). Man teilt den Tag in 5 Abschnitte ein


  00:00                                        23:59

   -------o---o---------------------o----o-------
   A      B   C                     D    E      F

   DDDDDDDD^^^^HHHHHHHHHHHHHHHHHHHHHHvvvvvDDDDDDD


Im Zeitraum A_bis_B sind die Lampen auf jeden Fall dunkel, genauso wie 
im Zeitraum E_bis_F.
Ist die aktuelle Uhrzeit im Zeitraum C_bis_D, dann sind die Lampen auf 
jeden Fall hell.
Liegt die aktuelle Uhrzeit zwischen B_bis_C dann werden die Lampen 
"hochgedimmt", wobei da keine Zeitschleifen oder dergleichen ablaufen. 
Das ist eine ganz banale Dreisatzrechnung, wie man aus der zeitlichen 
Distanz der aktuellen Zeit zum Punkt B errechnet, auf welchen Dimmgrad 
die Lampen eingestellt werden sollen.
Ganauso die Umkehrung D_bis_E

Als Benutzer legt man einfach die beiden Zeitpunkt C und D fest (oder B 
und E), das Programm errechnet sich die anderen beiden Zeitpunkte (30 
Minuten jeweils dazu bzw. wegzählen) und der Rest sind einfach 4 
Fallunterscheidungen und 2 mal Dreisatzrechnen um den jeweils zur 
aktuellen Tageszeit passenden Dimmgrad der Lampen zu errechnen auf den 
die Lampen gesetzt werden.

Daniel: Zeitabläufe bzw. zeitliche Steuerungen macht man NIE (ausser für 
ganz kurze Zeiten) indem man den µC eine gewisse Zeit lang Däumchen 
drehen lässt, sondern indem man sich eine 'Uhr' ins Programm einbaut und 
Ereignisse an bestimmte Uhrzeiten koppelt.
Für die gewählte Aufgabenstellung ist es sicherlich ausreichend, wenn 
man programmintern eine Uhr mitlaufen hat, die einen Tag in Minuten 
durchzählt, bzw. alle Berechnungen in der Einheit Minuten macht.

[Falk B. (falk)]

Siehe statemachine.

[Daniel J. (n0i5ebreak3r)]

Guten Morgen,

Danke für eure Hinweise und Tipps vorallem mit der Uhr. Mein Problem ist 
und wird sein das ich um etwas von Grund an neu zu programmieren keine 
Ahnung habe. Wohl aber etwas erfahrungen mit fertige Programme anzusehen 
und zu verstehen was darin passiert und dann halt Werte abzuändern (LED 
Lamp Fader).
Auch sagen mir die Begriffe Fuses etwas. Die Tutorial hier habe ich mir 
schon mehramsl durchgelesen und mehr wir Ports einfach an und 
abzuschalten war nicht drin, leider. Ich habe mir jetzt eine Art 
"günstige" Lösung zum Testen aufgebaut. ATmega32 mit externem Quarz 
16MHz und ISP Schnittstelle und USB Programmer welches aus AVRStudio 
4.18 auch gut Funktioniert. Daran am PORTA ein LCD Modul 4x20 Zeichen im 
4-bit Modus welches mit der LCD Library von Peter Fleury arbeiten. Als 
Test habe ich dann hier aus der Codesammlung war das eine einfach Uhr 
mit internem Takt verwendet diese läuft soweit, nur etwas zu schnell. 
Wie gesagt mit der Uhr ist das eine ja eine tolle idee. Die Uhr würde ja 
schon laufen (ohne Datum) aber ich wüsste jetzt nicht wie ich dem 
Programm sagen soll wenn Punkt B erreicht ist dann sollst du jetzt 
folgendes machen. Ich kenne nur aus der Schule SPS Steuerungen mit 
S7Graph (Siemens). Da wird dann strikt von oben nach unten abgearbeitet. 
Ich würde die Sachen mit C+ sehr gerne erlernen. Ich war ja schon auf 
der Suche nach so einem Aquarium Computer. Aber die sind entweder teuer 
oder nicht das was ich brauche. Daher heist es dann selber machen und 
als Chance nutzen was neues zu erlernen.

MFG, frustrierter Daniel J.

[Karl H. (kbuchegg)]

Daniel Joachims schrieb:

> Danke für eure Hinweise und Tipps vorallem mit der Uhr. Mein Problem ist
> und wird sein das ich um etwas von Grund an neu zu programmieren keine
> Ahnung habe. Wohl aber etwas erfahrungen mit fertige Programme anzusehen
> und zu verstehen was darin passiert und dann halt Werte abzuändern (LED
> Lamp Fader).

Tja. das nennt man dann eben 'lernen'.
Und ohne die Dinge zu lernen kommt man eben nicht weit.


> 4-bit Modus welches mit der LCD Library von Peter Fleury arbeiten. Als
> Test habe ich dann hier aus der Codesammlung war das eine einfach Uhr
> mit internem Takt verwendet diese läuft soweit, nur etwas zu schnell.
> Wie gesagt mit der Uhr ist das eine ja eine tolle idee. Die Uhr würde ja
> schon laufen (ohne Datum) aber ich wüsste jetzt nicht wie ich dem
> Programm sagen soll wenn Punkt B erreicht ist dann sollst du jetzt
> folgendes machen.

Du hast eine Variable, die über einen Zeitraum von 24 Stunden von 0 bis 
1439 durchzählt (1 Stunde hat 60 Minuten, also vergehen in 24 Stunden 
1440 Minuten).

7 Uhr 24 morgens wäre dann von Mitternacht an gerechnet ...

  7 * 60 + 24 -> 444

... die 444-te Minute des Tages. Wenn deine 'Minuten-Uhr' also einen 
größeren Wert als 444 hat, dann ist es bereits nach 7 Uhr 24.

> Ich kenne nur aus der Schule SPS Steuerungen mit
> S7Graph (Siemens). Da wird dann strikt von oben nach unten abgearbeitet.

Und wenn dein SPS Programm unten angelangt ist, was passiert dann?
Dann geht es wieder von vorne los.

Im Prinzip genau das gleiche, was auch hier im Hauptprogramm machst:

int main
{
  ...

  while( 1 ) {

    hier kommt deine Logik rein, so wie du das auch
    von der SPS kennst

  }
}


wie sieht deine Logik aus?

  while( 1 ) {

    if( aktuelle_Minute_des_Tages < Schaltzeit_A ||
        aktuelle_Minute_des_Tages >= Schaltzeit_D )
      Lampen aus

    if( aktuelle_Minute_des_Tages >= Schaltzeit_B &&
        aktuelle_Minute_des_Tages < Schaltzeit_C )
      Lampen ein

    if( aktuelle_Minute_des_Tages >= Schaltzeit_A &&
        aktuelle_Minute_des_Tages < Schaltzeit_B )
      Helligkeit = Dimmwert_Aufdimmen( aktueller_Minute_des_Tages )

    if( aktuelle_Minute_des_Tages >= Schaltzeit_C &&
        aktuelle_Minute_des_Tages < Schaltzeit_D )
      Helligkeit = Dimmwert_Abdimmen( aktueller_Minute_des_Tages )
  }


Da sich der Wert von aktuelle_Minute_des_Tages von deiner Uhrenroutine 
innerhalb einer ISR im Laufe eines Tages sauber ändert und durchzählt, 
arbeitet dein Programm den kompletten Lichtzyklus sauber ab.

(Das ist nur das Prinzip. Aber mach dir klar, dass dieses Prinzip genau 
das realisiert, was du haben möchtest. Nimm auch die kleine 'Grafik' von 
oben zu Hilfe um dir das klar zu machen)

> der Suche nach so einem Aquarium Computer. Aber die sind entweder teuer
> oder nicht das was ich brauche. Daher heist es dann selber machen und
> als Chance nutzen was neues zu erlernen.

Dann tu das auch.
Aber es hat auch keinen Sinn, wenn man sich die Kirschen zu hoch hängt. 
Eine zeitlang kann man sich mit 'Malen nach Zahlen' über Wasser halten. 
Aber wer seine eigenen Bilder malen will, kommt nicht drumherum, sich 
auch wirklich erst mal mit dem Aufbau von Bildern, mit Farben, mit 
Pinseln, mit Leinwand etc. auseinanderzusetzen.
Bei dir ist das dann eben eine Programmiersprache und ihre 
Möglichkeiten, ihre Anwendung auf konkrete Probleme. Fürs erste brauchst 
du ausser einfachen Vergleichen, ein bischen rechnen und dem berühmten 
'Dreisatz' (für die Helligkeitswerte in den Dimmstufen) nicht viel mehr. 
(Wie man eine Uhr macht, hast du ja schon gefunden. Jetzt geht es erst 
mal nur noch darum, mit der Uhrzeit etwas anzufangen)

[Simon K. (simon)]

Mann mann Karl Heinz. Ich hab nach dem Lesen der ersten 10 Posts schon 
wieder ganz schnell wütend heruntergescrollt. Dass keinem das auffällt, 
dass man so einfach keinen Mikrocontroller programmiert!
8 Stunden Warteschleife?!

Leute, die mit der Weise wie im Ursprungspost dargestellt, versuchen 
bereits mittelgroße Projekte in einem Mikrocontroller zu realisieren, 
werden einfach klaglos scheitern.

Man muss alle Prozesse die im Mikrocontroller ausgeführt werden zerlegen 
in ganz kleine Stückchen und diese immer zu bestimmten Zeitpunkten 
ausführen.
Es ist jetzt witzlos noch was darüber zu schreiben, da Karl-Heinz genau 
das in ausführlichster Ausführlichkeit schon getan hat.

Wenn es hier einen "Gefällt mir" Knopf an Karl Heinzs Posts gäbe, dann 
wäre dieser sehr schnell abgenutzt :-)

EDIT: Das nicht der falsche Eindruck entsteht, auch wenn das schon mal 
so herüberkommt: Die ganze Sache ist nichts, was man in ein paar Wochen 
lernt. Das ist ein Prozess der über Jahre geht und in den eine Unmenge 
an Erfahrungen einfließt. Meine ersten Programme sahen völlig äquivalent 
aus, bis man eben mal damit an die Grenze stößt.
Sobald man schon mehrere Sachen "parallel" ausführen möchte, ist das 
einfach nicht möglich. Und dann überlegt man sich eben was, bis man 
darauf kommt, was Profis schon längst verinnerlicht haben.

Ich bin in dem "Business" seit vielleicht 8 Jahren intensiv drin (habe 
da schon als kleiner Bub angefangen). Und so lange habe ich gebraucht um 
bis zu meinem heutigen Kenntnisstand zu kommen. Allerdings ist das im 
Vergleich zu Karl Heinz Erfahrungsschhatz ein Witz ;-.)

[Ralf G. (ralg)]

Karl Heinz Buchegger schrieb:
> Stefan ++ hat recht.
> Der ganze Ansatz mit dieser Fade-Funktion ist zu nichts zu gebrauchen.
> So verführerisch diese Dinge auch immer wieder klingen, dieser Weg führt
> in einen Sackgasse.

Simon K. schrieb:
> Mann mann Karl Heinz. Ich hab nach dem Lesen der ersten 10 Posts schon
> wieder ganz schnell wütend heruntergescrollt. Dass keinem das auffällt,
> dass man so einfach keinen Mikrocontroller programmiert!
> 8 Stunden Warteschleife?!

Na klar, fällt das auf! Wenn das aber Daniels Können übersteigt, dann 
erstmal die schnelle Billiglösung mit dem Hinweis, dass man das 
natürlich gaaaanz anders macht. Da kann er erstmal seinen Fischen Tag 
und Nacht vorgaukeln. Und wenn er denen beim Schlafen zuguckt, das Ganze 
nochmal richtig umsetzen!

[Karl H. (kbuchegg)]

Ralf G. schrieb:
> Wenn das aber Daniels Können übersteigt, dann
> erstmal die schnelle Billiglösung mit dem Hinweis, dass man das
> natürlich gaaaanz anders macht. Da kann er erstmal seinen Fischen Tag
> und Nacht vorgaukeln. Und wenn er denen beim Schlafen zuguckt, das Ganze
> nochmal richtig umsetzen!

Ich denke sein Können reicht durchaus, sei nicht so hart. Es ist ganz 
einfach die 'andere Denkweise' an die er sich gewöhnen muss. Wobei er 
mit der SPS ja eigentlich einen Vorteil haben sollte. So was wird ja 
meines Wissens auch ereignisgesteuert programmiert. Oder zumindest so 
ähnlich.

:-)
Und seine Fische werden aus auch noch ein paar Tage/Wochen verkraften, 
wenn die Zeitschaltuhr das Licht hart aufdreht.

[Ralf G. (ralg)]

Karl Heinz Buchegger schrieb:
> Ich denke sein Können reicht durchaus, sei nicht so hart.
Das war jetzt nicht böse gemeint. Ich habe das hier nur so rausgelesen:
Daniel Joachims schrieb:
> Danke für eure Hinweise und Tipps vorallem mit der Uhr. Mein Problem ist
> und wird sein das ich um etwas von Grund an neu zu programmieren keine
> Ahnung habe. Wohl aber etwas erfahrungen mit fertige Programme anzusehen
> und zu verstehen was darin passiert und dann halt Werte abzuändern (LED
> Lamp Fader).
Und hier:
Daniel Joachims schrieb:
> Anmerkung ich möchte mich hier nicht mit falschen Federn schmucken. Der
> Original Code stammt vom LED-LAMP FADER Author: Christoph Brennig,
> Copyright (c) 2011. Ich habe diesen auf meine bedürfnisse Angepasst
> abgeändert.