idea básica de tabla de consulta de colores

Navega tus respuestas
2

Estoy manejando una interfaz ILI9230 LCD 320 * 240 de 16 bits, con un framebuffer de 250 * 200 y quiero manejarlo como 4 bits. Así que construí una tabla de colores como esta: 

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
};

entonces mi framebuffer es una matriz como esa: 

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

Intento intercambiar los buffers dobles de esa manera: 

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

y escribir en el backbuffer: 

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

El problema es que obtengo menos resolución de pantalla debido a que se trunca el ancho * alto / 2 del frramebuffer. Parece que no implementé el concepto de tabla de colores de búsqueda no correctamente.

    
pregunta Ahmed Saleh

1 respuesta

4

Su problema aquí es que está trabajando en bytes, pero el framebuffer está conceptualmente en nibbles.

Digamos que tienes una pantalla de 256x200, por lo que tienes un framebuffer de 256x200 nibbles, de 256x200 / 2 bytes. Eso está bien, y lo que tienes.

A continuación, debe traducir sus coordenadas X / Y en una ubicación de bytes de framebuffer. Para eso necesitas trabajar con la mitad del ancho, o la mitad de la altura. Por ejemplo, la ubicación 10,20 equivaldría a la mitad del valor de 20 anchos + 10 bytes. Eso sería (20 * 256 + 10) / 2 = 1285.

Ahora, estás a mitad de camino. Usted sabe dónde está el píxel elegido en el framebuffer, pero no qué mitad del byte. Para eso necesitas mirar la ubicación de píxeles completos y ver si es par o impar. 20 * 156 + 10 = 2570. Eso es un número par (2570 & 1 = 0; el LSB se establece en 0, por lo que es par), por lo que solo desea modificar el nibble más bajo del valor (si fuera impar). modificaría el mordisco más alto (por supuesto, podría almacenarlos al revés, consulte más adelante).

Entonces, leería el valor actual de la matriz, enmascararía el nibble que desea modificar para que sea todo 0, luego superponga el nuevo valor.

Supongamos que el byte actualmente contiene 0b10011100, Y lo haría con 0b11110000 para obtener 0b10010000. Luego O O ese resultado con su nuevo valor de píxel, digamos 2, para obtener 0b10010010.

Si estuviera modificando el nibble superior, primero tendría que cambiar su valor de color 4 bits para convertirlo en 0b00100000 en lugar de 0b00000010, o luego con el nibble superior enmascarado del byte.

Luego, vuelve a escribir el byte.

Ahora, mostrar el framebuffer en la pantalla es una tarea igualmente onerosa:

Debes tomar cada byte del framebuffer y dividirlo en dos nibbles. Desplace a la derecha los 4 bits del nibble superior para convertirlo en un número entre 0 y 15. Busque el color del nibble inferior y colóquelo en la pantalla. Luego haga lo mismo con el mordisco superior colocado en la pantalla en el siguiente píxel. Luego avanzas al píxel que sigue a eso, por lo que te has movido en 2 píxeles en total.

Nota de la anterior: si guardó el par en el mordisco superior y el impar en el mordisco inferior, simplemente emitiría los píxeles en el orden opuesto: arriba y abajo.

¿Limpiar como lodo ahora?

    
respondido por el Majenko

Lea otras preguntas en las etiquetas

¿Cómo detener repentinamente el motor paso a paso sin vibración? Ejecutar bombillas incandescentes de 12v con balasto fluorescente