Bitmap abgeschnitten auf GLCD

[Tobias J. (tobiasjohn)]

Hallo zusammen,

ich möchte auf einem DOGM-128 ein Bitmap ausgeben.

Es ist 39x17 pixel groß.

In meiner Routine schreibe ich immer 8 bit auf einem mal. Leider wird 
die letzte Zeile des Bitmaps abgeschnitten wenn in Y-Richtung die Anzahl 
der Pixel nicht durch 8 teilbar ist.

Kann mir jemand sagen wie ich den Fehler ausmerze bzw. ein Bitmap 
pixel-weise schreiben kann?

Ich kann die daten nicht direkt auf das display schreiben sonder muss 
den umweg über den Buffer (disp_ram) gehen.

Hier mein Code:

void display_bitmap(char ROM *bitmap, unsigned char x, unsigned char y, unsigned char dx, unsigned char dy) {
  unsigned char i, j;
  for(j = 0; j < (dy / 8); j++) {
    for(i = 0; i < dx; i++) {
    disp_ram[y/8+j][i+x] = *(bitmap++);
    }
  }
}

Danke für Eure Hilfe!

[Johannes (Gast)]

Poste doch bitte mal deinen ganzen Code (zip) ich bin auch an diesem LCD 
dran.
Danke.

[Karl H. (kbuchegg)]

Tobias John schrieb:

> Kann mir jemand sagen wie ich den Fehler ausmerze

Sobald du erkannt hast, dass dy / 8 immer ein Ganzzahlergebnis hast, bei 
dem die 'Nachkommastellen' einfach abgeschnitten sind, sollte dir auch 
klar sein, dass zb 17 / 8 als Ergebnis 2 hat. Wenn j aber seine Schleife 
2 mal durchläuft, hast du in y Richtung nur 16 Bit ( 2*8) ausgegeben und 
nicht 17.

Du musst dir also nur ausrechnen, wieviele Zeilen dann hinterher noch zu 
schreiben sind und die Bits für diese Zeile mittels Bitmanipulation in 
den Display Buffer schreiben.


Du hast übrigens auch noch ein 2-tes Problem. Nicht nur die Anzahl der 
Pixel in Y-Richtung muss bei dir noch durch 8 teilbar sein, auch die 
Startposition der Bitmap in Y-Richtung muss durch 8 teilbar sein.

Am besten teilst du deine Ausgabe in Y-Richtung in 3 Bereiche auf:

* Abhängig von der Y-Position sind die ersten 0 bis maximal 7
  Pixelreihen mittels Bitmanipulationen in den Display-Buffer zu
  schreiben.
  Wiviele das sind, verrät dir die Y-Position

* Dann kommt der Bereich, indem du komplette Bytes kopieren kannst
  (im Prinzip deine jetzige Schleife)

* Und dann können, abhängig von der Bitmapgröße und der Startposition
  in Y-Richtung noch ein paar Pixelzeilen übrig bleiben, die wieder
  mittels Bitmanipulationen in den Dispaly-Buffer übernommen werden.


Am besten machst du dir erst mal ein paar Skizzen auf Papier und setzt 
Zahlenwerte ein. Auch ein paar Skizzen auf kariertem Papier, die den 
Display-Buffer darstellen können zur Überprüfung deiner Routinen nur von 
Vorteil sein. Jeweils 8 übereinanderliegende Kästchen gehören zusammen 
und bilden ein Byte. Es wird daher sinnvoll sein, sich alle 8 
Kästchenreihen eine Hilfslinie einzuzeichnen um schnell überprüfen zu 
können, ob man bei einer Zuweisung auch tatsächlich nur die gewünschten 
Bits manipuliert.

[Tobias J. (tobiasjohn)]

Hmmm... ich habe es mir schon genau so gedacht.
Ich werde mich mal daran setzen wenn ich mehr Zeit habe.

Danke für die Antwort - sie hilft mir auf jeden Fall!

Gruß,
 Tobias