Variable auf Display

[Timm (Gast)]

Hallo,

ich habe folgendes Problem.
Ich arbeite mit einem Touchscreen. In der Endlosschleife wird dieser 
abgefragt und dann diverse Variablen ins Display geschrieben. Diese 
Variablen werden also nur einmal ins Display geschrieben, nämliche wenn 
der Screen an der zugehörigen Stell "getoucht" wird. So weit so gut.

Einige der Variaben sind dynamisch, zeitlich veränderlich. Eine Änderung 
der Variablen soll also direkt auf das Display auszugeben sein ohne dass 
der Touchscreen an der besagten Stelle wieder getoucht werden muss.

Ich könnte natürlich wenn der Touchscreen an der besagten Stelle 
getoucht wird eine Hilfsvariable setzen:

Minomalbeispiel:

unsigned char helfer = 0;
int main(void)
{
 while(1)
 {
  ...
  if(10 < x < 20)
  {
   helfer = 1;
   schreibevariableinsDisplay;
  }
  ...
  if(helfer == 1)
  {
   loescheDisplayanVariablenstelle;
   schreibevariableinsDisplay;
  }
 }


}

So ist es natürlich sehr unschön, da der Variablenbereich immer gelöscht 
wird (egal ob sich die Variable verändert oder nicht)und das Display 
flackert.

Die Veränderung der Variable wird von "Außen beeinflusst", 
beispielsweise ein Lichtsensor.
Ich würde also am liebsten nur die Variable neu ins Display scheiben, 
wenn Sie sich wirklich verändert. Wie vergleicht man zwei sich zeitlich 
veränderliche Variablen oder wie geht man so ein Problem an. Vermutlich 
nichts wildes und ich brauche nur einen kleinen Denkanstoss.

Danke und Gruss
Timm

[Peter II (Gast)]

> if(10 < x < 20)

das macht bestimmt nicht das was du willst.


Warum löscht du überhaupt das Display -> das verursacht das Flackern. 
Überschreibe es doch einfach mit dem neuen wert.

[Timm (Gast)]

Peter II schrieb:
>> if(10 < x < 20)
>
> das macht bestimmt nicht das was du willst.

Das is klar. Ich wollte nur die Funktionalität des Touchscreens 
beschreiben.
Besser:
if(lesetouchscreen)
...

Ich lösche, weil ich die Werte ungern übereinandergestapelt auf dem 
Display abgebildet haben möchte. Ich lösche auch nicht das ganze 
Display, sondern nur den Bereich in dem die Variable neu geschrieben 
werden soll.

[Peter II (Gast)]

Timm schrieb:
> Ich lösche, weil ich die Werte ungern übereinandergestapelt auf dem
> Display abgebildet haben möchte.

das kommst jetzt auf das Display an, aber meist überschreibt man immer 
nur ein Zeichen, dafür muss man nichts löschen. Und wenn die neue Zahl 
kürzer ist, dann muss man halt ein Leerzeichen schreiben.

[Mat (Gast)]

speichere einfach den alten Stand der Variablen und vergleiche es mit 
dem neuen Stand, wenn ungleich, dann aufs Display schreiben, sonst 
nicht.
mfg Mat

[Karl H. (kbuchegg)]

Timm schrieb:

> Ich würde also am liebsten nur die Variable neu ins Display scheiben,
> wenn Sie sich wirklich verändert.

Ja dann mach das doch.

> Wie vergleicht man zwei sich zeitlich
> veränderliche Variablen oder wie geht man so ein Problem an.

Indem man sich den Wert in einer Variablen merkt, der gerade am Display 
angezeigt wird. Ehe man einen Wert ausgibt, fragt man einfach ab, ob der 
nicht schon angezeigt wird. Wenn ja, dann braucht man nichts tun. Wenn 
nein, dann muss man das Display updaten und man merkt sich welcher Wert 
jetzt gerade angezeigt wird.

   displayValue = ......;  // irgendein Wert, der sonst nicht vorkommt

   while( 1 )
   {

     .....
     neuerWert = ...... // irgendwie kommt ein auszugebender Wert zustande

     if( neuerWert != displayValue )  // unterscheidet sich der von der Anzeige ?
     {
       displayValue = neuerWert;     // ja, tut er. Also muss die Anzeige aktualisiert werden
       gib den neuen Wert aus
     }
   }

[Frank M. (frank_m35)]

Mit nem Buffer im Mikrocontroller.

Der Buffer (Framebuffer) ist so groß wie dein Display. Alles was du ans 
Display senden willst schreibst du in den Framebuffer. Der Buffer ist 
viel schneller und man sieht kein Flackern, da alles im Buffer, also 
unsichtbar gezeichnet wird. Am Ende der Routine setzt du ein Flag, dass 
das Display neu gezeichnet werden soll.

In deiner Main-Schleife prüfst du ständig ob das Flag zum neu zeichnen 
gesetzt ist, wenn ja, überschreibst du den Inhalt des Displays mit dem 
Inhalt des Framebuffers auf einen Schlag.

Um die Sache weiter zu beschleunigen, kannst du auch noch zusätzlich den 
Bereich, der geändert wurde in einem Struct abspeichern. Ist ein zweites 
Flag gesetzt, welches zeigt ob nur ein kleiner Teil aktualisiert werden 
muss, dann kannst du nur den kleinen Teil ans Display senden.

Hat dein uC nicht so viel RAM und du willst keinen externen anschließen 
um das zu bewerkstelligen, so kannst du Karl Heinzs Vorschlag leicht 
umsetzen.

[Timm (Gast)]

Recht herzlichen Dank für die Antworten!
Es hat mir geholfen

[Klaus W. (mfgkw)]

Eine kleine Abwandlung wäre, nicht einzelne Variaben zu merken und 
jeweils zu vergleichen, sondern stumpf den gesamten Bildschirminhalt in 
zwei Puffern zu halten (je nach Bildschirmgröße, z.B. char ...[4][20]).

Die eigentliche Ausgabe erfolgt im gesamten Programm einfach, indem in 
einen der beiden geschrieben - egal, was vorher drin stand.

In einem weiteren Task (also z.B. einer IR) wird reihum der Inhalt des 
ersten Puffers mit dem zweiten verglichen.
Bei einem Unterschied wird vom ersten in den zweiten kopiert und auf dem 
Display ausgegeben.