grafische Flüssigkristallanzeige schnell löschen

Nein, solch einen Befehl gibt es nicht.

Deine Grafikroutinen sind aber ziemlich schlecht, wenn du 0,5s für 
5220Byte brauchst. Versuch mal diese zu optimieren.

Ansonsten könnte man eine zweite Speicherseite anlegen, und immer 
abwechselnd eine Seite beschreiben, während die andere angezeigt wird. 
Das setzt aber 32kB RAM auf dem LCD vorraus.

Eine andere Möglichkeit wäre jeder Pixel einzeln zu löschen. Dazu muss 
man speichern welche Pixel wo gesetzt sind, und beim Zeichnen von dem 
Pixel an x=1 wird vorher der gesetzte Pixel an x=1 gelöscht. Die alte 
Kurve wird also abgebaut und die neue gleichzeitig aufgebaut.

Ich kenne den Grafikkontroller nicht, aber wenn du das LCD umschalten 
zwischen horizontaler und verticaler Addressierung, dann könntest du 
versuchen, immer pro Messwert (1 Pixel auf x-y Achse?) einen senkrechte 
Pixelreihe löschen, das heist du löscht nur den Bereich in dem die Kurve 
gezeichnet wird.
Und wenn die neue Kurve nicht stark von der alten abweicht, dann kannst 
die Länge der Pixelreihe noch verkürzen.

Oder noch besser wenn du weist wo der alte Messwert war kannst du diesen 
Pixel direkt löschen.

Ein kleiner Ideenschub zu der "wandernden" Anzeige:
Man nimmt ein Array mit 240 Elementen.
Soll nun ein Messpunkt auf dem LCD dargestellt werden, wird zuerst im 
Array nachgeschaut, welcher Punkt vorher gesetzt war und dieser wird 
gelöscht. Dann wird der aktuelle Punkt gesetzt und im Array gespeichert. 
Das geht man dann von 0-239 durch.
Das komplette löschen des LCDs entfällt dadurch komplett.

Mach es doch so wie bei den "echten" EKGs. Einfach alle Spalten des 
Bildschirms durchgehen und mit dem aktuellen Messewert überschreiben. 
Dann musst du überhaupt nie was löschen.

Nur dass das spaltenweise Überschreiben beim T6963 in üble 
Bitschiebereien ausartet. Der Speicher ist horizontal organisiert, 
Zeilen löschen wäre kein Problem. Wenn man sich den Wert in einem Array 
vorhält, spart man da viel Zeit.

Also ich hab für meinen MP3 Player einen Display Treiber programmiert, 
der dir vielleicht weiterhelfen könnte.
Verwende ihn um ein Balken-Frequenzspektrum anzuzeigen.
Der aktualisiert nur das was wirklich nötig ist. Ein kompletter 
Bildaufbau ist nur in den seltesten Fällen notwendig.
Der Treiber ermöglicht es auch auf einem Bildschirm mehrere "Fenster" zu 
öffnen um mehrere Kurven gleichzeitig darstellen zu können. Wie bei 
einem LP12 (Defi + EKG Funktion) wäre es also denkbar die drei 
relevanten EKG Kurven anzuzeigen.

Das Projekt klingt interessant. Kann man dazu mehr Informationen haben?
Ich arbeite beim Samariterbund Österreich und so ein DIY EKG Gerät für 
die private Notfalltasche wäre schon sehr verlockend. Auch wenn es 
vielleicht kein Profi-Gerät sein sollte, je nachdem wie viel Know-How 
darin steckt, etliche der Herzerkrankungen wären dennoch erkennbar.

Ein LP12 ist ein halbautomatischer Defibrillator wie er bei 
Rettungsorganisationen eingesetzt wird.
Wer ihn sich ansehen will, hier ein Link:
http://www.lifepak.de/produkte/lp12.pdf

Mit DIY EKG Gerät bezeichne ich ein Do-It-Yourself EKG Gerät, was man 
beispielsweise als Bausatz verkaufen könnte. Handelsübliche EKG Geräte 
sind sehr teuer. Der LP12 kostet beispielsweise 10000 Euro (je nach 
Ausstattung). Herzrhythmusstörungen zu erkennen sollte aber mit einem 
"selbstgebauten" auch relativ einfach sein.

EKG Diagramme zu lesen ist nicht trivial. Wer wirklich ein EKG Diagramm 
verstehen und interpretieren will muss dafür lange lernen und Kurse auf 
der UNI besuchen. Viele Ärzte können es nicht einmal. Ich geb's zu, ich 
kann es auch nur teilweise. Aber als Rettungssanitäter muss ich das 
ohnehin nicht können...


Schon mal daran gedacht das ganze mit einem FPGA zu lösen? Hätte vor 
allem was Performance betrifft sehr große Vorteile.

Wenn du einer Zusammenarbeit nicht abgeneigt bist, dann würde ich gerne 
mitmachen.
Ich habe insofern großes Interesse daran, da dieses Gerät beispielsweise 
für Remote-Monitoring eingesetzt werden könnte.
Dies genau zu erläutern würde den Rahmen dieses Threads sprengen. 
Einsetzbar wäre es zur Früherkennung von Herzerkrankungen und darauf 
basierender autonomer Alamierung eines Notarztteams. Selbstverständlich 
wäre für dieses Monitoring nur EKG zu wenig. Hierzu wären noch weitere 
Vitalparameter relevant.




-------------------------
www.poms-engineering.at

Oh, ist ja einiges gegangen in dem Thread seit ich das letzte mal 
vorbeigeschaut habe.

Also, eigentlich hat "unscheinbarer WM-Rahul" ziemlich genau beschrieben 
was ich gemeint habe. Du legst dir ein Array mit 240 Elementen an. Dazu 
brauchst du noch einen Index, der am Anfang auf Null steht. Wenn du nun 
einen Messwert hast, dann nimmst du erstmal den Wert im Array, der von 
Index angezeigt wird und löschst das betreffende Pixel. Danach setzt du 
das Pixel mit dem neuen Wert und erhöhst Index um Eins. Sobald Index 240 
erreicht setzt du ihn auf 0. Braucht dann für jeden Messwert gerademal 
zwei Zugriffe auf's LCD, das sollte in 5ms wohl zu schaffen sein. Da 
könntest du wohl eher noch Probleme mit dem Speichern auf die SD-Karte 
bekommen, einzelne Schreibzugriffe sind da recht langsam. Wenn du einen 
Controller mit genügend RAM hast (F168 ist gut, 1kB brauchst du ja eh um 
auf die SD zu schreiben), dann kannst du dir ein zweites Array anlegen, 
in dem du jeweils beim "Überlauf" von Index alle Werte 
zwischenspeicherst und dann die Funktion zum Speichern auf die SD 
aufrufst. Dann muss das Neuzeichnen halt in einem Interrupt passieren.

> Im Prinzip hab ich schon verstanden, was du meinst, muss aber zu meiner
> Schande gestehen, dass ich mit meinen bescheidenen
> Programmierkenntnissen es nicht in ein Programm umsetzen kann.

Wo liegt das Problem?

Du definierst dir ein Array. Im Beispiel mach ichs mal 256
Einträge gross. In jedem Eintrag wird abgelegt, auf welcher
Höhe das Pixel gesetzt wurde.


unsigned char Werte[256];


und wenn du jetzt einen neuen Wert hast, der in Spalte x ausgegeben
werden soll, löscht du das Pixel, dass im Durchgang zuvor gesetzt
wurde. Welches das ist, steht im Array


     clear_pixel( x, Werte[x] );
     set_pixel( x, NeuerWert );
     Werte[x] = NeuerWert;

x wird dabei immer grösser, bis du den rechten Rand erreicht
hast, danach beginnt x wieder bei 0 (der nächste Durchgang).

Mach dir unbedingt ein paar Funktionen zum setzen und
löschen von Pixel an einer bestimmten Position. Vereinfacht
die weitere Programmierung ungemein!

Und bau dein Programm um.
So wie du das machst zeichnest du jedesmal im
Interrupt das komplette Bild neu. Das ist ziemlich
unsinnig. Im Interrupt brauchst du nur den neuen Messwert
feststellen, das x um 1 erhöhen und obigen Lösch/Neuzeichnen
Prozedur ausführen. x nach abprüfen ob der rechte Rand
erreicht ist und gegenenfalls x wieder auf 0 zurücksetzen.

Sinngemäss also so:


unsigned char Werte[128];
unsigned char x;


interrupt()
{

   besorge neuen Messwert;

   clear_pixel( x, Werte[x] );
   set_pixel( x, Messwert );
   Werte[x] = Messwert;

   x++;
   if( x == 128 )
     x = 0;
}

Entschuldigung.
128 waren ja die Zeilen, du hast ja 240 Spalten.
Also:

unsigned char Werte[240];
unsigned char x;


interrupt()
{

   besorge neuen Messwert;

   clear_pixel( x, Werte[x] );
   set_pixel( x, Messwert );
   Werte[x] = Messwert;

   x++;
   if( x == 240 )
     x = 0;
}

> wieder bei x = 0 angefangen, wobei zunächst eine um 50 Zeilen
> verschobene 2. Kurve gezeichnet wird, bevor nach dem 2. Durchgang das
> eigentliche Löschen des gesamten grafischen Teils der Anzeige beginnt.

Genau darum geht es.
Wozu den graphischen Teil komplett löschen?
Im Array steht für jede Spalte in welcher Zeile ein Pixel
gesetzt wurde. Nur dieses 1 Pixel wird gelöscht und
dann ist diese komplette Spalte wieder leer.

> Wenn ein Impuls sehr steil ist, werden unter Umständen nur 2 bis 3
> Bildpunkte in y-Richtung gesetzt, wodurch das Diagramm schwer lesbar
> wird. Deshalb lasse ich bei Messwertdifferenzen von >4 Bildpunkten
> zusätzliche Bildpunkte in y-Richtung setzen.
> Das könnte auch später noch gelöst werden.

Ist immer noch das gleiche Prinzip.
Du musst dir in einem Durchlauf von links nach rechts Information
hinterlassen, wo du welche Pixel gesetzt hast. Im nächsten
links-rechts Durchlauf nimmst du diese Information her um gezielt
nur diese gesetzten Pixel zu löschen.
Anstatt den kompletten Graphikbereich mit x-tausend Pixel zu löschen,
löscht du nur die 3 oder 4 Pixel in der Spalte in der du als
nächstes auszugeben gedenkst.

Wenn mehrere Pixel gesetzt werden, dann würde och mir halt 2
Arrys machen. Eines für die untere Grenze, eines für
die obere Grenze. Alle dazwischenliegenden Pixel sind zu löschen.

> Wie ist das wirklich? oder müsste man noch etwas einstellen.

Sodern die Interrupts freigegeben sind. Ja klar. Genau das
ist ja das Prinzip eines Interrupts: Er unterbricht die momentane
Programmausführung und wendet sich was anderem zu.
Haarig wird es nur, wenn bereits ein Interrupt behandelt wird
und während dieser Behandlung ein neuer Interrupt auftritt.

Ist nur so eine Idee:

Und wenn man kurzzeitig das Display von der Versorgungsspannung trennt, 
um den Inhalt zu löschen?


Bernhard

> genauso mach ich es schon.

Ganz ehrlich.
Dein Programm ist ein dermassen undurchsichtiger,
unübersichtlicher Kauderwelsch. Da mach ich mir
nicht die Mühe, dass im Detail zu analysieren.

Wenn du
  * konsistente und vor allem sinnvolle Einrückungen
  * vernünftige Variablennamen
  * Für 'Pixel setzen', 'Pixel löschen' eigene Funktionen

machen würdest, wäre schon viel gewonnen.

Und komm mir nicht mit: Funktionsaufrufe dauern so lange.
Die paar µS für den gesparten Funktionsaufruf retten
dein Timing auch nicht.

> Ist nur so eine Idee:
>
> Und wenn man kurzzeitig das Display von der Versorgungsspannung
> trennt, um den Inhalt zu löschen?

* so ein Display muss in der Regel initialisiert werden
* auf dem Display ist ja wahrscheinlich nicht nur die
  Kurve drauf. Da gibt es sicher auch noch Achsenkreuze
  mit Beschriftungen. All das muss dann wieder restauriert werden.


Das ist doch kein Problem. 5ms sind für einen Prozessor
eine halbe Ewigkeit. Die paar Pixel zu löschen kann doch
nicht das Problem sein.

Wenn ich mir allerdings die Schleifen anschaue die die
senkrechten Linien malen, wird mir schlecht.

> clear_pixel( x, Werte[x] );
> set_pixel( x, Messwert );
> damit kann ich Moment nichts anfangen, da ich es noch nicht verstehe.

Das sind ganz normale Funktionsaufrufe.
Genauso wie du dir eine EKG Funktion definiert hast.
Nur werden halt diesen Funktionen noch Werte mitgegeben,
damit die Funktionen damit rechnen können.

Du brauchst also eine Funktion set_pixel. Diese Funktion
soll natürlich mitbekommen, die Zeile und die Spalte
in der das Pixel zu setzen ist.

Die Funktion schaut also so aus. (Ich hab keine
Ahnung ob die Berechnung so stimmt, ich übernehm das
aus deinem Code. Du musst also die Berechnung kontrollieren).


void clear_pixel( unsigned char Zeile, unsigned char Spalte )
{
  ...

Hier wird also vereinbart dass es eine Funktion clear_pixel
geben soll. Diese Funktion bekommt 2 Argumente mit. Die
Zeilennummer und die Spaltennummer. Innerhalb der Funktion
sollen die mitgegebenen Argumente in den Variablen Zeile
und Spalte abgelegt sein. Ach ja: Die Argumente machen
wir unsigned char, weil das völlig ausreicht. Ein unsigned
char kann Zahlen von 0 bis 255 aufnehmen. Deine Zeilennummern
bewegen sich von 0 bis 240. Die Spaltennummern von 0 bis 128.
Alles also im Bereich 0 bis 255.

Wichtig: Innerhalb der Funktion konzentrieren wir uns
nur darauf was es bedeutet an eine bestimmte Funktion
ein Pixel zu setzen. Das ist die Aufgabe dieser Funktion.
Nicht mehr und nicht weniger.

Weiter im Text

1

#define PIXEL_PRO_SPALTE   128

2

#define PIXEL_PRO_ZEILE    240

3

4

#define PIXEL_PRO_BYTE       6

5

#define BYTE_PRO_ZEILE     ( PIXEL_PRO_ZEILE / PIXEL_PRO_BYTE )

6

#define START_GRAPHIK      0x200  /* Die Startadresse im Bildspeicher */

7

8

void clear_pixel( unsigned char Spalte, unsigned char Zeile )

9

{

10

  unsigned int StartAddr;

11

12

  // Wir wollen den 0/0 Punkt links unten im Eck

13

  // haben. Das Display hat aber den 0/0 Punkt links oben

14

  // im Eck. Also drehen wir die Zeilennummer entsprechend um

15

16

  Zeile = PIXEL_PRO_SPALTE - Zeile;

17

18

  // Die Startadresse im Bildspeicher berechnen

19

  StartAddr = START_GRAPHIK +

20

              Zeile * BYTE_PRO_ZEILE +

21

              Spalte / PIXEL_PRO_BYTE;

22

23

  WriteData( StartAddr & 0xFF );     // Das Low Byte ausgeben

24

  WriteData( StartAddr >> 8 );       // Das High Byte ausgeben

25

  WriteCtrl( 0x24 );

26

  WriteCtrl( 0xF0 | (5 - Spalte % PIXEL_PRO_BYTE ) );    // 1111 0 xxx   0  löscht einen Bildpunkt;

27

}

Mangels Display kann ich die Funktion natürlich nicht testen.
Deine Aufgabe ist es, die entsprechende set_pixel Funktion zu
schreiben. Schau dir auch an, wie ich mit ein paar defines
die meisten Zahlen aus der Funktion verbannt habe. Zum einen
erreiche ich dadurch eine gute Anpassbarkeit an andere Displays
mit andern Pixelzahlen. Zum anderen wird dadurch die Funktion
selbstdokumentierend.

Um jetzt sagen wir mal eine senkrechte Linie zu zeichnen, kann
ich zb eine Funktion schreiben:

void VertLine( unsigned char Spalte,
               unsigned char ZeileStart,
               unsigned char ZeileEnd )
{
  // Die Funktion zeichnet eine senkrechte Linie in einer Spalte
  // Die Linie beginnt in der Zeile ZeileStart und endet in
  // der Zeile ZeileEnd. Die Pixel Spalte/ZeileStart bzw.
  // Spalte/ZeileEnd werden gesetzt!

  unsigned char Zeile;

  // Wenn ZeileStart grösser ZeileEnd ist, dann werden beide
  // vertauscht. Dadurch kann die Linie immer von Start nach
  // End gezeichnet werden

  if( ZeileStart > ZeileEnd ) {
    unsigned char Temp = ZeileStart;
    ZeileStart = ZeileEnd;
    ZeileEnd = Temp;
  }

  // Jetzt die Linie zeichnen
  for( Zeile = ZeileStart; Zeile < ZeileEnd; ++Zeile )
    set_pixel( Spalte, Zeile );
}

Siehst du. Um eine senrechte Linie zu zeichnen wird einfach
nur ausgerechnet, welche Pixel zu setzen sind. Das eigentliche
Pixel setzen übernimmt die Funktion set_pixel. Dadurch erreichen
wir zunächst mal, dass sich diese Funktion nicht mehr um die
Low-Level Details der Byte Adressierung kümmern muss. Das ist
auch nicht ihre Aufgabe. Zum anderen wird die Funktion einfach
genug, dass man durch hinschauen feststellen kann ob das
stimmen kann. Genau das ist nämlich eines der Geheimnisse in
der Programmierung: Probleme so aufteilen, dass man die Komplexität
beherrschen kann. Diese Funktion löst bereits ein nicht so triviales
Problem, nämlich das Zeichnen einer senkrechten Linie. Durch
das sinnvolle unterteilen in Bausteine (Pixel setzen) und Verwendung
dieses Bausteins, wird die Funktion aber wieder einfach genug, um
sie ohne grosse Probleme schreiben zu können. Ein guter Programmierer
ist nicht einer, der 1000 Zeilen Funktionen schreiben und verstehen
kann. Ein guter Programmierer ist jener, der es schafft
komplizierte Dinge in einfachere Bausteine aufzuteilen und mit diesen
einfacheren Bausteinen das komplizierte Problem zu lösen.

Damit haben wir aber schon die Bausteine beisammen um
uns der EKG Funktion zuwenden zu können:

Was ist ihre Aufgabe. Sie soll den Messwert übernehmen
und in der nächsten Spalte ausgeben. Dabei soll sie aber
auch berücksichtigen, dass bei einer Differenz von 1 zum
letzten Messwert nur 1 Pixel gesetzt werden soll und wenn
die Differenz größer als 4 Pixel ist, soll eine senkrechte
Linie gezeichnet werden.

Na dann schreiben wir das doch so

void EKG( unsigned char Messwert )
{
  char Differenz;

  // Die Different zum vorhergehenden Messwert berechnen
  // Achtung: Die Differenz kann auch negativ sein! Das darf
  // aber nicht sein, da wir unsigned rechnen!
  // Das naheliegende Differenz = abs( Alt - Jetzt )
  // funktioniert also nicht.
  //
  if( Messwert > MesswertAlt )
    Differenz = Messwert - MesswertAlt;
  else
    Different = MesswertAlt - Messwert;

  if( Differenz < 4 )
    set_pixel( DieseSpalte, Messwert );

  else
    VertLine( DieseSpalte, MesswertAlt, Messwert );
}

Siehst du, wie simpel auf einmal die Funktion geworden ist.
Alle Schritte sind auch für einen Blinden nachvollziehbar.

Das ist jetzt die Überarbeitete Version dessen was du
bereits hast. Zum Rest, wie du das Löschen besser organsieren
kannst, wurde ja schon genug geschrieben.

Besorg dir unbedingt Literatur. Wenn du über Programmorganisation
nicht viel weist, ist das verzeihlich. Wenn du aber aus Unkenntnis
der Möglichkeiten in C schlechte Programme schreibst, so ist das
einfach nur nachlässig. Und gerade bei einem Gerät, das im
medizinischen Bereich eingesetzt werden soll, ist Nachlässigkeit
absolut inakzeptabel.