Min/Max über 24h

[Ingo L. (corrtexx)]

Hallo Forum,

ich möchte über 24h gleitend Temperatur min/max Werte erfassen. Ich habe 
einen Temperatursensor, der von einem Mega8 (ja, alt, ich weiss, müssen 
aber weg ;) ) sekündlich ausgelesen wird. Die Abtastrate ist so hoch, 
weil ich die Temperatur in einem Container nicht unter eine bestimmte 
Temperatur fallen lassen will und ich mit bis zu 6kW gegen heize. Jetzt 
erscheint es mir wenig sinnvoll, 60*60*24 Werte in einen Buffer zu 
schreiben und dann daraus Min/Max suchen, kann der AVR auch nicht. Ich 
finde gedanklich keinen Ansatz, kann mir jemand helfen?

[Simi S. (kokoianer)]

Salüü

Neuen Wert mit dem aktuellen Min/Max Werten vergleichen.
Wenn er grösser bzw. kleiner ist, den Min/Max Wert ersetzen.

Braucht keine Rechenleistung ;)

Gruss

[Ingo L. (corrtexx)]

Simi S. schrieb:
> Neuen Wert mit dem aktuellen Min/Max Werten vergleichen.
> Wenn er grösser bzw. kleiner ist, den Min/Max Wert ersetzen.
Und wie bekomme ich da 24h rein? Ein Min/Max Tracker ist ja kein 
Problem. Eine RTC gibt es nicht, ich benötige die Werte also relativ zu 
24h, ohne Zeitstempel und co..

[Mario L. (mlatzig)]

Warum musst du die History auf die Sekunde genau haben?

Reicht es nicht, aktuelle Temperaturwerte sekündlich aktuell zu haben 
und in der 24Stunden-History nur mit einer Auflösung von z.B. 1-5 
Minuten (Byte pro Temperaturwert) zu speichern, um daraus die 
statistischen Werte, wie Min/Max/Avg etc. zu berechnen?

[Chris D. (myfairtux) (Moderator)]

Ingo L. schrieb:
> Und wie bekomme ich da 24h rein? Ein Min/Max Tracker ist ja kein
> Problem. Eine RTC gibt es nicht, ich benötige die Werte also relativ zu
> 24h, ohne Zeitstempel und co..

Du benötigst also alle Werte?

1024 Bytes RAM und 512 Bytes EEPROM
Sportliche Aufgabe, je nach Daten ;-)

Wie sehen denn die Daten aus, insbesondere deren Auflösung?

Wenn sich die Temperatur über die Zeit wenig ändert, dann reicht 
eventuell ein Zeitstempel inkl. Richtung der Temperaturänderung.
Du lässt also einen Zähler sekündlich raufzählen und speicherst nur bei 
einer Temperaturänderung die Art der Richtungsänderung.

Wenn Du davon ausgehen kannst, dass sich die Temperatur wenigstens alle 
127 Sekunden einmal ändert, dann haut es schon ohne Komprimierung fast 
hin.
Die ersten sieben Bits sind dann die Anzahl der verstrichenen Sekunden 
und das achte gibt an, in welche Richtung sich die Temperatur um einen 
Schritt geändert hat.

Ändert sich die Temperatur aber schneller oder in größeren Sprüngen oder 
gar nicht, dann wird es wieder eng ;-)

Ansonsten müsste man wohl mit einer Komprimierung arbeiten, die 
sämtliche bisherigen Daten beinhaltet und sich daraufhin optimiert.

[Ingo L. (corrtexx)]

Danke für die Tips. Ich habe es jetzt so gemacht, dass ich die mittlere 
Temperatur in einem 5min-Fenster weglogge und aus diesem Mittel-Buffer 
(288 Ints) die Min/Max ermittele. Reicht mir so.

[georg (Gast)]

Ingo L. schrieb:
> Die Abtastrate ist so hoch,
> weil ich die Temperatur in einem Container nicht unter eine bestimmte
> Temperatur fallen lassen will

Ich bezweifle sehr, dass sich die Temperatur in einem Container 
innerhalb einer Sekunde relevant ändert. Aber so ein Overkill schadet 
auch nicht.

Grundsätzlich ist die Frage: brauchst du nun ein Temperatur-Log über 24 
Stunden oder nur die Min/Max-Temperatur? Dafür musst du nicht mehr als 
diese beiden Werte speichern.

Georg

[Äxl (geloescht) (Gast)]

georg schrieb:
> Grundsätzlich ist die Frage: brauchst du nun ein Temperatur-Log über 24
> Stunden oder nur die Min/Max-Temperatur? Dafür musst du nicht mehr als
> diese beiden Werte speichern.

eben - diese Frage stelle ich mir auch gerade.
Du brauchst zwei Variablen
eine nennst Du MAX, die ande MIN.
die MAX belegst Du mit NULL vor und die andere mit "1000Grad" (wie immer 
deine Maßeinheit aussieht).
Jetzt misst du einfach vor dich hin und vergleichst deinen Messwert mit 
MAX("0") und mit MIN("1000Grad")
wenn der Messwert kleiner MIN ist, wird das ab sofort den neues MIN.
Ist der Messwert größer als MAX, wird das dein neuer Maximalwert.
Das in eine Schleife und gut.
Am Ende des Tages hast Du dann MIN mit zB 23Grad (ist ja >0) und MAX mit 
zB. 43Grad belegt (< 1000Grad).
Na - und den letzten Messwert hast Du auch.

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

Ingo L. schrieb:
> Die Abtastrate ist so hoch, weil ich die Temperatur in einem Container
> nicht unter eine bestimmte Temperatur fallen lassen will und ich mit bis
> zu 6kW gegen heize.
Ähem, diesen Gedankengang kannst du nochmal gehen und kommst dann sicher 
an das richtige Ziel. Als Denkanstoß: wie schnell ist denn deine 
6kW-Heizung? Bringt die nach 10 Sekunden schon so richtig heiß?

Äxl (geloescht) schrieb:
> Am Ende des Tages hast Du dann MIN mit zB 23Grad (ist ja >0) und MAX mit
> zB. 43Grad belegt (< 1000Grad). Na - und den letzten Messwert hast Du auch.
Die Forderung war aber nicht "min-max vom letzten Tag", sondern "min max 
in den vergangenen 24h". Das ist ein grundlegender Unterschied.

Ich würde das etwa so angehen, dass ich für jede der 24 vergangenen 
Stunden einen min-max-Wert entsprechend deiner Beschreibung ermittle und 
in einem Ringpuffer ablege. Aus diesen 24 mix-max-Werten wird dann ein 
einziger min-max-Wert der vergangenen 24h berechnet...

[Ingo L. (corrtexx)]

Lothar M. schrieb:
> Ähem, diesen Gedankengang kannst du nochmal gehen und kommst dann sicher
> an das richtige Ziel. Als Denkanstoß: wie schnell ist denn deine
> 6kW-Heizung? Bringt die nach 10 Sekunden schon so richtig heiß?
Ja, is sicher Overkill

Lothar M. schrieb:
> Äxl (geloescht) schrieb:
>> Am Ende des Tages hast Du dann MIN mit zB 23Grad (ist ja >0) und MAX mit
>> zB. 43Grad belegt (< 1000Grad). Na - und den letzten Messwert hast Du auch.
> Die Forderung war aber nicht "min-max vom letzten Tag", sondern "min max
> in den vergangenen 24h". Das ist ein grundlegender Unterschied.
Genau, Min/Max über gegen unendlich is kein Problem

Lothar M. schrieb:
> Ich würde das etwa so angehen, dass ich für jede der 24 vergangenen
> Stunden einen min-max-Wert entsprechend deiner Beschreibung ermittle und
> in einem Ringpuffer ablege. Aus diesen 24 mix-max-Werten wird dann ein
> einziger min-max-Wert der vergangenen 24h berechnet...
Das ist sogar eine noch bessere Variante als meine derzeitige. Danke!

[Ideengeber (Gast)]

Servus,

Lothar M. schrieb:
> Ich würde das etwa so angehen, dass ich für jede der 24 vergangenen
> Stunden einen min-max-Wert entsprechend deiner Beschreibung ermittle und
> in einem Ringpuffer

wozu der Ringspeicher für die Stunden-Min/Max?

Es sollen für die letzten 24h min/max ermittelt werden, dafür brauche 
ich drei Variable: MIN, MAX und einen Sekundenzähler.

Zum Startzeitpunkt werden wie oben schon erwähnt die Werte so gesetzt:
MIN= 1000
MAX= -1000
COUNT=0

Bei jeder Messung werden MIN/MAX angepasst und COUNT um eins erhöht. 
Wenn COUNT==86400 sind die 24h-Stunden rum und die Endergebnisse können 
aus MIN und MAX gelesen werden. Für die Datenermittlung über mehrere 
Tage besteht keine Forderung.


Gruß,

[Rolf M. (rmagnus)]

Ideengeber schrieb:
> wozu der Ringspeicher für die Stunden-Min/Max?
>
> Es sollen für die letzten 24h min/max ermittelt werden, dafür brauche
> ich drei Variable: MIN, MAX und einen Sekundenzähler.

Und wie bekommst du die Werte, die älter sind als 24h wieder 
rausgerechnet?

> Zum Startzeitpunkt werden wie oben schon erwähnt die Werte so gesetzt:
> MIN= 1000
> MAX= -1000
> COUNT=0
>
> Bei jeder Messung werden MIN/MAX angepasst und COUNT um eins erhöht.
> Wenn COUNT==86400 sind die 24h-Stunden rum und die Endergebnisse können
> aus MIN und MAX gelesen werden.

Und danach? Dann muss der erste gemessene Wert ja wieder aus dem 
Durchschnitt entfernt werden.

> Für die Datenermittlung über mehrere Tage besteht keine Forderung.

Aber dafür, dass zu jedem Zeitpunkt ein Minimum und Maximum über die 
letzten 24 Stunden vorhanden ist. Nicht über die Zeit seit dem letzten 
ganzzahligen Vielfachen von 24 Stunden. Also ein gleitender Min- und 
Max-Wert, wie es ja auch im Ursprungsposting gleich am Anfang seht:

Ingo L. schrieb:
> über 24h *gleitend*

[Ingo L. (corrtexx)]

Ingo L. schrieb:
>> Ich würde das etwa so angehen, dass ich für jede der 24 vergangenen
>> Stunden einen min-max-Wert entsprechend deiner Beschreibung ermittle und
>> in einem Ringpuffer ablege. Aus diesen 24 mix-max-Werten wird dann ein
>> einziger min-max-Wert der vergangenen 24h berechnet...
> Das ist sogar eine noch bessere Variante als meine derzeitige. Danke!
Das ist eigentlich genau die Variante die ich benötigte. Ich habe es nur 
nicht geschafft mein Problem so "frei" zu machen.

Rolf M. schrieb:
>> Für die Datenermittlung über mehrere Tage besteht keine Forderung.
>
> Aber dafür, dass zu jedem Zeitpunkt ein Minimum und Maximum über die
> letzten 24 Stunden vorhanden ist. Nicht über die Zeit seit dem letzten
> Vielfachen von 24 Stunden. Also ein gleitender Min- und Max-Wert, wie es
> ja auch im Ursprungsposting gleich am Anfang seht:
>
> Ingo L. schrieb:
>> über 24h *gleitend*
Richtig

[Ingo L. (corrtexx)]

Für alle die es interessiert:

if ( Temperature <= TEMP_MAX && Temperature >= TEMP_MIN ){
        if ( Temperature > TempHistoryMax[TempIndex] ) TempHistoryMax[TempIndex] = Temperature;
        if ( Temperature < TempHistoryMin[TempIndex] ) TempHistoryMin[TempIndex] = Temperature;
        
        if ( ++MinuteCounter >= ONE_HOUR ){// 1 Hour is over, next Hour
          MinuteCounter = 0;
          // Reset Index
          if ( ++TempIndex >= NR_OF_TEMPS ) TempIndex = 0;
        }
      }

und

if ( Flags.ReadMaxima == SET ){
      Flags.ReadMaxima = CLEAR;
      for ( uint8_t i = 0; i < NR_OF_TEMPS; i++ ){
        if ( TempHistoryMax[i] > TempMax24 ) TempMax24 = TempHistoryMax[i];
        if ( TempHistoryMin[i] < TempMin24 ) TempMin24 = TempHistoryMin[i];
      }
    }

wobei NR_OF_TEMPS hier 24(Stunden) is. Danke Leute, ich habs selber 
nicht gesehen wie trivial es ist.

[Karl K. (karl2go)]

Lothar M. schrieb:
> Ich würde das etwa so angehen, dass ich für jede der 24 vergangenen
> Stunden einen min-max-Wert entsprechend deiner Beschreibung ermittle und
> in einem Ringpuffer ablege. Aus diesen 24 mix-max-Werten wird dann ein
> einziger min-max-Wert der vergangenen 24h berechnet...

Genau so wird das gemacht.

Äxl (geloescht) schrieb:
> die MAX belegst Du mit NULL vor und die andere mit "1000Grad" (wie immer
> deine Maßeinheit aussieht

Und wenn die Temp unter Null geht? Und wenn noch kein Wert gemessen, 
dann gibt min 1000°C aus?

Besser: -32768 als NaN  definieren und als Anfangswert festsetzen. Dann 
abfragen, ob NaN. Auch alle noch nicht berechneten Min-Max im Ringbuffer 
als NaN setzen.

[Ideengeber (Gast)]

Ingo L. schrieb:
> über 24h *gleitend*

In der Tat, das habe ich überlesen.
Ich korrigiere mich: Der Ringbuffer ist nötig.

Ingo L. schrieb:
> Aber dafür, dass zu jedem Zeitpunkt ein Minimum und Maximum über die
> letzten 24 Stunden vorhanden ist. Nicht über die Zeit seit dem letzten
> ganzzahligen Vielfachen von 24 Stunden.

Wobei Lothar auch schon vereinfacht. Ich verwende ein 24h-Raster, er ein 
Stunden-Raster. Gleitend würde nur eine Speicherung im Sekundentakt 
(Messfrequenz) sein. Aber das Prinzip ist natürlich richtig und es 
sollte auch immer ausreichend vereinfacht werden.

Gruß,

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

Ideengeber schrieb:
> Aber das Prinzip ist natürlich richtig und es sollte auch immer
> ausreichend vereinfacht werden.
Aus diesem Grund würde ich für die letzten 24h auch nicht 24 Werte 
speichern, sondern 32 (also jeweils für alle 45min. einen neuen Satz 
min-max-Werte berechnen). Denn dann wird die 
Ringpufferüberlaufverwaltung noch einfacher und ist letztlich ein 
"index&=0x1f;"...  ;-)

[Ingo L. (corrtexx)]

Lothar M. schrieb:
> Denn dann wird die
> Ringpufferüberlaufverwaltung noch einfacher und ist letztlich ein
> "index&=0x1f;"...  ;-)
:-), das is zu viel des Guten

[Ingo L. (corrtexx)]

So, nun nochmal, sodass es auch funktioniert:

if ( Temperature <= TEMP_MAX && Temperature >= TEMP_MIN ){
        static uint8_t IndexhangeOccoured = 0;
        
        if ( IndexchangeOccoured ){
          TempHistoryMax[TempIndex] = TEMP_MIN;
          TempHistoryMin[TempIndex] = TEMP_MAX;
          IndexchangeOccoured = CLEAR;
        }
        if ( Temperature > TempHistoryMax[TempIndex] ) TempHistoryMax[TempIndex] = Temperature;
        if ( Temperature < TempHistoryMin[TempIndex] ) TempHistoryMin[TempIndex] = Temperature;
        
        if ( ++MinuteCounter >= ONE_HOUR ){// 1 Hour is over, next Hour
          MinuteCounter = 0;
          // Reset Index
          if ( ++TempIndex >= NR_OF_TEMPS ) TempIndex = 0;
          IndexchangeOccoured = SET;
        }
      }

und

if ( Flags.ReadMaxima == SET ){
      Flags.ReadMaxima = CLEAR;
      TempMax48 = TEMP_MIN;
      TempMin48 = TEMP_MAX;
      for ( uint8_t i = 0; i < NR_OF_TEMPS; i++ ){
        if ( TempHistoryMax[i] > TempMax48 ) TempMax48 = TempHistoryMax[i];
        if ( TempHistoryMin[i] < TempMin48 ) TempMin48 = TempHistoryMin[i];
      }
    }

Man muss den neuen Index auch wieder überschreiben können ohne sein 
altes Maxima zu überschreiten.

[Marc V. (Firma: Vescomp) (logarithmus)]

Ingo L. schrieb:
> if ( Temperature <= TEMP_MAX && Temperature >= TEMP_MIN ){

 Da werden aber nur die Werte zwischen altem TEMP_MAX und
 altem TEMP_MIN in Betracht gezogen, oder ?
 Wozu soll das gut sein und wie kriegst du neue TEMP_MAX und _MIN ?

 Und:

        if ( Temperature > TempHistoryMax[TempIndex] ) TempHistoryMax[TempIndex] = Temperature;
        if ( Temperature < TempHistoryMin[TempIndex] ) TempHistoryMin[TempIndex] = Temperature;

 Besser:

        if ( Temperature > TempHistoryMax[TempIndex] ) TempHistoryMax[TempIndex] = Temperature;
        else if ( Temperature < TempHistoryMin[TempIndex] ) TempHistoryMin[TempIndex] = Temperature;

EDIT:
 TEMP_MAX und TEMP_MIN sind Konstanten um Ausreisser zu verhindern?

[Ingo L. (corrtexx)]

Marc V. schrieb:
> TEMP_MAX und TEMP_MIN sind Konstanten um Ausreisser zu verhindern?
Genau, alles darüber und darunter sind unplausibel und werden in 
entsprechenden Fehlerauswertungen abgefangen.

Marc V. schrieb:
> if ( Temperature > TempHistoryMax[TempIndex] )
> TempHistoryMax[TempIndex] = Temperature;
>         else if ( Temperature < TempHistoryMin[TempIndex] )
> TempHistoryMin[TempIndex] = Temperature;
Würde bedeuten, solange ich den Fall steigender Temperaturen habe, 
würden keine Minima erfasst werden d.h. nach dem Start würde solange der 
initial Min-Wert nicht berücksichtigt. Das erscheint mit nicht sinnvoll.

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

Ingo L. schrieb:
> Würde bedeuten, solange ich den Fall steigender Temperaturen habe,
> würden keine Minima erfasst werden d.h. nach dem Start würde solange der
> initial Min-Wert nicht berücksichtigt. Das erscheint mit nicht sinnvoll.
Korrekt und logisch:
Weil der min-Wert natürlich vom max-Wert völlig unterschiedlich ist und 
beide nicht irgendwie zusammen gehören, muss natürlich auch die 
Auswertung für beide einzeln durchgeführt werden.

Ich würde den Wert schon beim Einlesen auf Plausibilität prüfen und 
ggfs. den die Berechnung des min-max-Werts gar nicht starten. 
Genausowenig wie unplausible Werte in die Regelung eingehen sollten.

   :
   :
   if (TempNeuerWert){
     if (TempAkt<TMinStunde) TMinStunde=TempAkt;  

     if (TempAkt>TMaxStunde) TMaxStunde=TempAkt;  

     if (NeueStunde) {
       // min-max-Werte der letzen Stunde speichern
       PufferMin[idx] = TMinStunde;
       PufferMax[idx] = TMaxStunde;
       // Index verwalten
       idx++;
       idx&=0x1f;
       // "freie" Variablen zur Auswertung verwenden
       TMaxStunde = PufferMin[0];
       TMinStunde = PufferMax[0];
       for (int i=1; i<32; i++) {
         if (PufferMin[idx]<TMinStunde) TMinStunde=PufferMin[idx];  
         if (PufferMax[idx]>TMaxStunde) TMaxStunde=PufferMax[idx];  
       }
       TMin24h = TMinStunde;
       TMax24h = TMaxStunde;
     }
     // aktuelle Temperatur als Ausgangswert für die nächste Stunde festlegen
     TMinStunde = TempAkt;
     TMaxStunde = TempAkt;
   }
   :
   :

Ingo L. schrieb:
> IndexchangeOccoured
BTW: man muss nicht unbedingt englische Begriffe nehmen, wenn man kein 
Mutersprachler ist und nicht Gefahr läuft, dass der Code auch von Indern 
verstanden, will sagen "bearbeitet" werden muss...  ;-)

https://www.google.com/search?q=occured

[Marc V. (Firma: Vescomp) (logarithmus)]

Ingo L. schrieb:
> Würde bedeuten, solange ich den Fall steigender Temperaturen habe,
> würden keine Minima erfasst werden d.h. nach dem Start würde solange der
> initial Min-Wert nicht berücksichtigt. Das erscheint mit nicht sinnvoll.

 Nein, aber das kann sowieso nicht sein.
 Temperatur kann nicht größer als TempHistoryMax[TempIndex] sein und
 gleichzeitig kleiner als TempHistoryMin[TempIndex].

[Falk B. (falk)]

@Lothar M. (lkmiller) (Moderator)

>> IndexchangeOccoured
>BTW: man muss nicht unbedingt englische Begriffe nehmen, wenn man kein
>Mutersprachler ist und nicht Gefahr läuft, dass der Code auch von Indern
>verstanden, will sagen "bearbeitet" werden muss...  ;-)

Yes, in deed!

http://www.amazon.de/Weniger-schlecht-programmieren-Kathrin-Passig/dp/3897215675/ref=sr_1_1?ie=UTF8&qid=1444238128&sr=8-1&keywords=weniger+schlecht+programmieren

Dort werden die diversen falschen Freunde erklärt und richtig gestellt, 
wenn man nur some brocken englisch spricht.

[Marc V. (Firma: Vescomp) (logarithmus)]

Lothar M. schrieb:
> Korrekt und logisch:

 Nein.

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

Doch, und zwar wenn man die beiden Arrays mit einem Initialwert von z.B. 
-40 für die Maximal- und +140 für die Minimaltemperatur vorbelegt.

Denn sonst müsste man beim ersten Einlesen einer gültigen Temperatur 
beiden Arrays diese Temperatur gegeben werden. Irgendwie holprig, 
Ausnahme auf Ausnahme...
Deshalb würde ich auch nicht auf dem Puffer herumrechnen.

[Marc V. (Firma: Vescomp) (logarithmus)]

Lothar M. schrieb:
> Doch, und zwar wenn man die beiden Arrays mit einem Initialwert von z.B.
> -40 für die Maximal- und +140 für die Minimaltemperatur vorbelegt.

 Ich sehe das so:

 Beim ersten Einlesen ist Temperatur z.B. +20.
 Maximaltemperatur geht auf +20, Minimaltemperatur bleibt auf +140.

 a) Beim zweiten Einlesen ist Temperatur unverändert oder weniger.
    Maximaltemperatur unverändert, Minimaltemperatur geht auf +20.

 b) Bei nächsten 10 Messungen ist Temperatur += 0.1
    Maximaltemperatur wird korrigiert, Minimaltemp. unverändert.

    Auswertung für beide Fälle:
    Solange MinTemp == +140, MinTemp = MaxTemp.
    Solange MaxTemp == -40, MaxTemp = MinTemp.

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

Korrekt, solange a) zutrifft.
Besser und der Realität entsprechend wäre allerdings, wenn die 
Minimaltemperatur schon beim ersten Durchlaufen richtig gesetzt würde... 
?

Falk B. schrieb:
> @Lothar M. (lkmiller) (Moderator)
>>> IndexchangeOccoured
>> BTW: man muss nicht unbedingt englische Begriffe nehmen, wenn man kein
>>>Mutersprachler ist und nicht Gefahr läuft, dass der Code auch von
>> Indern >verstanden, will sagen "bearbeitet" werden muss...  ;-)
> Yes, in deed!
Muss das hier nicht "indeed" heißen? ?

[georg (Gast)]

Marc V. schrieb:
> Beim ersten Einlesen ist Temperatur z.B. +20.
>  Maximaltemperatur geht auf +20, Minimaltemperatur bleibt auf +140.

Warum? Man kann den normalen Algorithmus anwenden, dann werden mit dem 
ersten Wert beide gesetzt - es ist doch auch überhaupt nichts falsch 
daran, wenn Min und Max den gleichen Wert haben. Bei einer konstanten 
Temperatur ist das ja zwangsläufig der Fall und völlig korrekt.

Worauf man dagegen achten müsste ist dass die Startwerte von -40 und 
+140 nicht in eine Rechnung einbezogen werden. Das ist der Fall, wenn 
man so verfährt wie von mir beschrieben und die erste Berechnung erst 
nach der ersten Messung durchführt, was einfach ist: es wird immer nach 
einem neuen Messwert das gewünschte berechnet.

Georg

[Marc V. (Firma: Vescomp) (logarithmus)]

Lothar M. schrieb:
>> Yes, in deed!
> Muss das hier nicht "indeed" heißen? ?

 He no good speeka amerikano.
 In dead.

[Ingo Less (Gast)]

@Lothar
Der Unterschied zu meiner Variante is, dass mein 24h Wert schon ab dem 
Einschalten verfügbar ist, deiner erst nach „NeueStunde“. Oder?

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

Einfach NeueStunde mit 1 und die beiden Puffer passend initialisieren, 
dann geht das... ?

[Ingo Less (Gast)]

Würdest du direkt in deine Buffer arbeiten hättest du die Werte on the 
fly... Aber dafür kenne ich dein Programm zu wenig

[Stefan F. (Gast)]

Brauchst du eigentlich die min/max Werte der letzten 24 Stunden oder die 
min/max Werte pro Tag (mit Reset um Mitternacht oder so).

[Ingo Less (Gast)]

24h

[Stefan F. (Gast)]

Also wirklich 24h. Jetzt wäre die nächste Frage, wie genau dieses 24h 
Fenster eingehalten werden muss. Wenn wir zum Beispiel sagen, dass 
dieses nur auf die Minute genau sein muss, reduziert sich der 
Speicherbedarf auf 1/60.

Du musst dann einfach nur von jeder Minute den jeweiligen min und max 
Wert speichern.

60 Minuten x 24 Stunden x 2 Bytes x 2 Werte (min+max) = 5,8kB. Das würde 
in einen ATmega1284 passen.

Wenn 2 Minuten Intervalle erlaubt sind, wären sogar die vielen Modelle 
mit 4kB RAM geeignet.

Die größeren Intervalle der historischen Speicherung halten dich nicht 
davon ab, die Messungen jede Sekunde durchzuführen und damit zu Regeln.

[Ingo Less (Gast)]

@Stefan
Ich schätze deine Beiträge sehr. Aber hast du diesen Threat komplett 
gelesen? Das Problem ist gelöst, die Hardware steht fix und fertig. Aber 
trotzdem danke! Is nicht böse gemeint