Muss man Array-Zeiger zurücksetzen?

International Deutsch
1

Hallöle.
Ich möchte auf meinem Wetter-Schreiber alle sechs Minuten einen Punkt ausgeben.

Momentan gibts da nur zwei Graphen, Innentemperatur und Luftdruck.
Das Ganze wird auf zwei, je 240 pixel langen, Skalen gezeichnet.

Dazu habe ich zwei Arrays gebastelt:

byte tempGraph[240];    // Array für Temperatur-Schreiber
 byte tempKurz;         // runtergerechneter Wert für den Graphen
byte baroGraph[240];    // Array für Luftdruck-Schreiber
byte luftDruckKurz;     // runtergerechneter Luftdruckwert für den Graphen

Das Runterrechnen passt nur die Werte an die Skalen an-weiter nix (und ausserdem könnte der Luftdruckwert grösser werden als ein Byte, aber nur mit Bytes hält sich der Speicherbedarf in erträglichen Grenzen.
Alle sechs Minuten wird nun folgender Zauber ausgelöst:

{
  graphZeiger=((stunde*10)+(minute/6)-1) ;     // Zeiger für die Arrays berechnen
  Serial.print("ich mach ja schon...");
  Serial.println(graphZeiger);
  luftDruckKurz = luftDruck-895;               // Wert an Skala anpassen
  baroGraph[graphZeiger]=luftDruckKurz;        // Wert eintragen
  tempKurz=tempCelsius-5;                      // Wert an Skala anpassen
  tempGraph[graphZeiger]=tempKurz;             // und eintragen
}

Die serielle Ausgabe ist nix weiter als debugging, ich gucke lieber, obs hinhaut, als meinen Künsten zu vertrauen... :confused:

Jetzt frage ich mich, was nach 24 Stunden passiert. Dann sind die Arrays nämlich voll-muss ich den Zeiger zurücksetzen, oder fängt der von selbst wieder bei 0 an, weil ja die Länge der Arrays sowieso feststeht?

Falls sich jemand fragt, was die Speicherverschwendung soll: das Ganze läuft aufm Nextion, und es gibt da keine Möglichkeit (angeblich aus Speichermangel), Werte für die Wellenform-Komponente an eine inaktive Seite zu senden.
Daher muss ich, wenn die Seite aufgerufen wird, jedes mal sämtliche Werte des Tages neu schicken.
Grauslich, geht aber nicht anders- und der Mega hat den Speicher.
Später werd ich das vermutlich auf SD-Karte umstricken...

2

Rabenauge:
fängt der von selbst wieder bei 0 an, weil ja die Länge der Arrays sowieso feststeht?

Mit der Größe des Arrays hat das nichts zu tun. Sondern bei mit deiner Formel für die Berechnung des Index aus der Zeit. Wenn der um 23:59 noch im Array liegt ist alles in Ordnung (wenn Stunden und Minuten die Uhrzeit ist).

Für sowas gibt es Ringpuffer. Das ist eine Datenstruktur die intern ein Array verwaltet und automatisch die ältesten Daten überschreibt wenn das voll ist.

3

Nur zur sprachlichen Verständigung: tempGraph[graphZeiger]

tempGraph ist der Name des Feldes und der Zeiger in den Speicher auf das erste Feldelement. graphZeiger ist der Index und "zeigt" auf ein Feldelement. Bei 240 Feldelementen darf der Index die Werte 0 bis 239 annehmen.

graphZeiger=((stunde*10)+(minute/6)-1) ;

Wenn Deine Uhr von 0:00 bis 23:59 geht, dann ist um 0:00 graphZeiger==-1, was ein ungültiger Index ist.

graphZeiger=(stunde*10)+(minute/6);

Das ergibt gültige Werte für den Index von 0 bis 239.

Oder?

4

Danke für die Aufklärung der richtigen Begriffe- damit hab ich immer wieder mal Schwierigkeiten. :slight_smile:
Und auch für den Hinweis, dass um 0.00 '-1' rauskommen wird- da hätte ich selber drauf kommen können. :confused:

Stimmt auch: das -1 ist unnötig, das hab ich sogar in den Skalen schon (unbewusst) berücksichtigt.
Dass im obigen Beispiel die Variable graphZeiger überhaupt nicht aus dem Array laufen kann, fiel mir dann aufm Weg ins Körbchen auch noch ein.

5

Hallo,

mal was anderes wegen dem Speicher. Warum speicherst du die Werte in einem Array überhaupt ab? Neuen Wert aller 6min berechnen und auf Display ausgegeben - fertig. Das Display speichert seine Anzeige selbst. Warum nochmal im µC vorhalten?
Außer du möchtest die Anzeige zwischen verschiedenen Graphen wechseln, dann mußte natürlich aus dem Speicher heraus neu zeichnen lassen.
Sind so meine Gedanken. :wink:

6

Rabenauge:
Danke für die Aufklärung der richtigen Begriffe- damit hab ich immer wieder mal Schwierigkeiten. :slight_smile:

Da bist Du nicht alleine, ich habe da auch so meine Baustellen :wink:

Rabenauge:
Und auch für den Hinweis, dass um 0.00 '-1' rauskommen wird- da hätte ich selber drauf kommen können. :confused:

Ein ungültiger Zeiger kann zu sehr merkwürdigen Ergebnissen während der Programmlaufzeit führen und ist meist nur sehr schwer zu lokalisieren. Daher schaue ich da immer sehr genau hin. Ein gutes Programm sollte auch eine Sicherheitsabfrage drin haben. Etwas mehr tippen kann sich lohnen :slight_smile:

7

Doc_Arduino:
Neuen Wert aller 6min berechnen und auf Display ausgegeben - fertig. Das Display speichert seine Anzeige selbst.

Wenn ich immer nur die neuen Werte zeichne, habe ich dann irgendwann eine vielzahl von unterschiedlichen Grafen auf dem Display, oder?

Ich habs für mich so gelöst, dass ich einen Ringspeicher mitführe, und vor dem Zeichnen des neuen Wertes den alten auf dem Display lösche (=mit Hintergrundfarbe überschreibe)

Oder gibts da einen geschickteren Weg?
Am liebsten wäre mir eine rollende Anzeige gewesen, aber das habe ich nicht hingebekommen.

8

Hallo,

stimmt, dann wird nichts gelöscht. Blöd. :confused:

Was meinst du mit rollender Anzeige?
Aktuell denke ich an eine einzigste Pixelspalte die man aktualisiert und inkrementiert, am Ende auf Spalte 0 setzt.
Das wäre eine Art Drucker voller Breite. Beim Display die Höhe. Ob die geführte Spalte dann ein, zwei oder drei Linien zeichnet ist der egal.
Meine theoretische Überlegung geht soweit, dass man entweder alle Werte für die Spalte berechnet und speichert um dann alles auf einmal hintereinander auf das Display auszugeben, also diese eine Spalte. Oder man jedes Pixel der Spalte berechnet und sofort ausgibt. Letzteres benötigt laut meiner Überlegung keinen großen Speicher. Und wenn die Spalte wieder vorn (links) anfängt, wird altes mit der neuen Spalte überschrieben, sodass nichts altes stehen bleiben dürfte. Damit dürfte selbst ein Ringspeicher nicht mehr notwendig sein.

9

Ich tu das eben weil die Seite mit den Graphen nicht ununterbrochen angezeigt werden wird.
Die ist eher ein Zusatz-wenn schon Nextion, dann reizen wir das Ding doch auch mal aus.
Ja, und dann, der Spieltrieb...

Rollende Anzeige?
Sowas:
Eine dicke Papierrolle dreht sich langsam hinterm Fenster, rechts am Rand wird geschrieben, und hinten wischt die einer immer wieder ab, wie echte Barographen das machen, mit Endlos-Papier?

Dazu müsstest du entweder jeden Wert (der im Fenster auftaucht) im Display speichern (in meinem Fall masochistisch, das gäb 480 Variablen für die beiden bisherigen Anzeigen), und bei jedem neuen Wert alle neu schreiben (bzw. umkopieren), oder aber den Graphen gar nicht nutzen, und das per Hand machen, mit den Zeichenfunktionen. Bei letzterem hättest du auch noch die Möglichkeit, die Skala (den Hintergrund) mitrollen zu lassen.
Gäb auch nicht weniger Variablen. Im Grunde läuft es dann auf selbergestrickte Arrays hinaus.
Viel Spass beim hantieren in dem ulkigen Editor.... :confused:
Ich hatte diese ausabemethode erst auch erwogen, aber dann müssten bei mir tatsächlich auch die Hintergründe mitscrollen, und das ist mir erstmal zu aufwendig.

Angeblich gibts die Funktion (Graphen im Nextion speichern) deshalb nicht, weil da der Speicher in den Dingern nicht reicht- aber das käm natürlich drauf an, wieviele und wie grosse Variablen gespeichert werden müssten. Da ich mir da auch unsicher bin, mach ichs halt erstmal aufm Mega (da kosten mich die beiden Arrays zusammen auch nur ~600 Byte). Später soll das auf ne SD-Karte, die ich als Laufwerk für verschiedenes benutzen will.

Das mit dem Überschreiben (bzw. alte Werte verschwinden lassen) erledigt sich bei mir selber, wenn die Seite z.B. um Mitternacht mal kurz gewechselt wird.
Kann man ja auch automatisieren-und sich ne passende Zeit für aussuchen.

10

Hallo,

okay, du musst das speichern, verstanden. Du möchtest den bis dahin gemalten Graphen behalten nach einem Bildwechsel?

@ Gunther

Dicke Papierolle, auch verstanden. Das entspricht meiner oben gedachten Möglichkeit. Ich betrachte das anders herum.
Stelle dir das Display vor. Lege darauf senkrecht einen Stift. Den Stift bewege ich von links nach rechts senkrecht und beginnt wieder links. Wie ein Oszibild. Der Stift ist die Pixelspalte die ich immer neu schreiben würde.

Wenn die Daten langsam kommen, kann man Spalte für Spalte schreiben so wie die Daten reinkommen. Es flimmert nicht. Träger Plotter.

Kommen die Daten schnell rein, schreibt man einmal von links nach rechts komplett durch und wartet ca. 500ms und schreibt dann die gerade aktuellen Daten. So wie man es auf einem LCD Display auch machen würde. Man rechnet die Pixelwerte der Spalte durch von oben nach unten oder umgekehrt und rückt eine Spaltenpos. weiter. Benötigt keinen großen Speicher, außer man will die aktuelle Spalte puffern. Sollte eigentlich so funktionieren - denke ich.

11

So isses.
Die Werte sollen, schön nacheinander, eben als Graph eingetragen werden.
Die Skalen sehen dann so aus, dass vorne die 0 steht (null Uhr...) und ganz hinten die 24 (genaugenommen müsste es ne 23.56 sein).
Alle sechs Minuten wird ein Wert gespeichert-eben im Array.

Wenn ich jetzt die Graphen-Seite aktiviere, kann ich den Verlauf seit 0.00 Uhr komplett sehen, und genau so soll das sein. Der letzte Punkt ist dann nahezu auch die aktuelle Uhrzeit.

Inzwischen kämpfe ich allerdings mit nem ganz anderen Problem: es gelingt mir seit Stunden nicht, vom Mega aus rauszufinden, wann eben diese Seite aktiviert wurde.
Ich sende von der Seite aus drei Zeichen (print "bar"- und habs immerhin auch schon ab und an geschafft, dass diese Zeichen dann auch im seriellen Monitor mal erscheinen, aber nie genauso-als String eben.
Blöd ist, dass man das selber machen muss, jeder Kram im Nextion kann eine ID von selber senden- Seiten nich. Da soll auch nichts erst gedrückt werden müssen-Seite aufrufen und Arduinchen zeichnet drauflos....

Jemand ne einfache Idee, wie ich zuverlässig erkennen kann, wenn eine bestimmte Seite aufgerufen wird?
Mein Plan war, jeder Seite nen kleinen Namen zu geben (drei Buchstaben, das reicht)- hatte ich auch schonmal drin, funktionierte aber erbärmlich- und somit im Arduino zu wissen, welche Seite grade aktiv ist...
Das Nextion-Forum ist nutzlos, weil da bei jeder zweiten Antwort nur nach der Nextion-Bibliothek gekräht wird, die ich aber nicht benutzen will.

12

Rabenauge:
Jemand ne einfache Idee, wie ich zuverlässig erkennen kann, wenn eine bestimmte Seite aufgerufen wird?

sendme liefert die aktuelle Seite,
ändert die sich bist du auf einer anderen.

sendme: send current pageID to UART

Example:

sendme //no parameters

Remarks:

If you want the page auto-send pageID every refresh, simply enter sendme in page initialize event.

13

Ja- auf sendme() bin ich auch gestossen.
Einfach ist aber anders- ich hab nämlich rund ein Dutzend Bildschirmseiten (bisher, Tendenz steigend), und je nachdem, was da gesendet wird (die Nummer oder der Klartext-Name?) kann die Auswertung auch recht aufwendig sein.

Wenn ich es recht verstanden hab, ist das ein überflüssiger Befehl, man kann genauso ein print "Seitenname" benutzen?

In beiden Fällen liegt die Tücke nicht darin, das Nextion senden zu lassen, sondern in der Auswertung im Arduino.
Hab inzwischen meinen alten Versuch dazu überarbeitet und es scheint zu funktionieren.

14

Du beschwerst dich darüber dass etwas nicht ginge,
dann darüber dass du nicht in der Lage bist die Antworten zu verarbeiten,
in dem Zug erklärst du noch das, das du suchtest, für überflüssig.

In der Auswertung von seriellen Datenströmen sehe ich keine Tücke.