Grundidee einer Farbnachschlagetabelle

Ich fahre eine ILI9230 LCD 320 * 240 16-Bit-Schnittstelle mit einem Framebuffer von 250 * 200 und möchte sie als 4-Bit fahren. Also habe ich eine Nachschlage-Farbtabelle wie folgt erstellt:

u16 LUT[16] = {
    //0      1      2     3    4    5    6    7    8       
    BLACK, BRIGHTRED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE,
    // 9      A    B      C    D     E   F
    BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE
};

dann ist mein Framebuffer ein Array wie dieses:

#define fbWidth      256
#define fbHeight     200
char frameBuffer[fbWidth*fbHeight/2]; // 256*200*4bit

Ich versuche, die Doppelpuffer wie folgt auszutauschen:

for(i=0;i< fbWidth*fbHeight/2;i++)
        {
         u16 color = LUT[frameBuffer[i]];
         *(__IO uint16_t *) (Bank1_LCD_D)= color;
        }

und in den Backbuffer zu schreiben:

    // color is 2
frameBuffer[fbWidth * y + x] = color;

Das Problem ist, dass ich weniger Bildschirmauflösung erhalte, weil ich die Framebuffer-Breite * Höhe / 2 abgeschnitten habe. Es sieht so aus, als hätte ich das Konzept der Farbtabellensuche nicht richtig implementiert.

Auf was führst du den Code aus? Versuchen Sie, den Wert von auszudrucken fbWidth*fbHeight/2. Versuchen Sie, einen einzelnen Framebuffer zum Laufen zu bringen und den Code so einfach wie praktisch zu gestalten.
ARMCortex M3. Ich habe versucht, das Ergebnis von fbWidth*fbHeight/2 durch den entsprechenden Wert zu ersetzen, aber es gibt immer noch etwas, das nicht funktioniert, und ich kann es nicht herausfinden. Leider habe ich gerade kein Jtag
Wenn Sie keine Möglichkeit haben, Daten herauszubekommen, machen Sie das Programm einfach. Verwenden Sie zunächst einen Framebuffer mit einer Länge von 1 Scanzeile (320) und schreiben Sie dieselbe Zeile wiederholt.

Antworten (1)

Ihr Problem hier ist, dass Sie in Bytes arbeiten, aber der Framebuffer ist konzeptionell in Nibbles.

Angenommen, Sie haben einen Bildschirm von 256 x 200, also haben Sie einen Framebuffer von 256 x 200 Nibbles von 256 x 200/2 Bytes. Das ist in Ordnung, und was Sie haben.

Sie müssen dann Ihre X/Y-Koordinaten in eine Framebuffer-Byte-Position übersetzen. Dafür müssen Sie mit halber Breite oder halber Höhe arbeiten. Beispielsweise würde die Stelle 10,20 dem halben Wert von 20 Breiten + 10 Bytes entsprechen. Das wäre (20 * 256 + 10) / 2 = 1285.

Jetzt sind Sie auf halbem Weg. Sie wissen, wo sich Ihr gewählter Pixel im Framebuffer befindet, aber nicht, welche Hälfte des Bytes. Dazu müssen Sie sich die vollständige Pixelposition ansehen und sehen, ob sie gerade oder ungerade ist. 20 * 156 + 10 = 2570. Das ist eine gerade Zahl (2570 & 1 = 0; das LSB ist auf 0 gesetzt, also gerade), also möchten Sie nur das niedrigste Halbbyte des Werts ändern (wenn es ungerade wäre). würde das höchste Nibble modifizieren - natürlich könnten Sie sie auch andersherum speichern - siehe später).

Sie würden also den aktuellen Wert aus dem Array lesen, das Nibble ausblenden, das Sie ändern möchten, damit es alle 0 ist, und dann den neuen Wert überlagern.

Angenommen, das Byte enthält derzeit 0b10011100, Sie würden es UND mit 0b11110000 zu 0b10010000 führen. Dann ODER dieses Ergebnis mit Ihrem neuen Pixelwert, sagen wir 2, um 0b10010010 zu ergeben.

Wenn Sie das obere Halbbyte ändern würden, müssten Sie zuerst Ihren Farbwert um 4 Bit nach links verschieben, um es 0b00100000 anstelle von 0b00000010 zu machen, und dann oder es mit dem maskierten oberen Halbbyte des Bytes.

Dann schreibst du das Byte wieder zurück.

Jetzt ist die Anzeige des Framebuffers auf dem Bildschirm eine ähnlich lästige Aufgabe:

Sie müssen jedes Byte des Framebuffers nehmen und es in zwei Nibbles aufteilen. Verschieben Sie das obere Halbbyte um 4 Bits nach rechts, um es zu einer Zahl zwischen 0 und 15 zu machen. Schlagen Sie die Farbe für das untere Halbbyte nach und platzieren Sie es auf dem Bildschirm. Machen Sie dann dasselbe mit dem oberen Nibble, das im nächsten Pixel auf dem Bildschirm platziert wird. Dann gehst du zum nächsten Pixel vor, also hast du dich insgesamt um 2 Pixel bewegt.

Beachten Sie von früher - wenn Sie die geraden im oberen Nibble und die ungeraden im unteren Nibble gespeichert haben, würden Sie die Pixel nur in der umgekehrten Reihenfolge ausgeben - oben und dann unten.

Jetzt klar wie Schlamm?

erstaunlich :) vielen Dank.. woher hast du all das Wissen und die Algorithmen oben :)? Bücherempfehlung?
Selbstlernen und Programmieren. Zwei Jahre auf dem College, drei an der Universität, dann 15 Jahre in Software und Hardware ;) Außerdem habe ich meine eigene TFT-Bibliothek für den PIC32 geschrieben, die Framebuffering und CLUT macht: github.com/majenkotech/TFT Fühlen Sie sich frei, Code oder Ideen zu übernehmen das du magst.
Grundidee einer Farbnachschlagetabelle
AntwortenHierDatenschutz-Bestimmungen1y, 0v