Rutinas propias para llenar buffer de Video?

[elgarbe]

Hola, este tema guarda relacion al OSD que estoy diseñando con el LPC1769: http://www.todopic.com.ar/foros/index.php?topic=42254.0

Finalmente pude pasar a modo gráfico. Para ello, tengo un buffer de (32x16) (512 pixel horiontal) x 230 pixeles de alto. Ese buffer es sacado por el MOSI del SPI línea por línea por medio del DMA.
Entonces ahora tengo que hacer rutinas para llenar ese buffer con informacion a mostrar en pantalla.
Por ahora solo he podido hacer lo siguiente:

Código: [Seleccionar]

#define PIX_Y 234
#define PIX_X 32  //En realidad es Char_X. Pixel sería 32x16
#define FIRST_LINE 30
#define LAST_LINE 220
#define FNT_H 14

.....

for(i=0;i<PIX_Y;i++)
for(j=0;j<PIX_X;j++)
memhead[i][j] = 0;

for(i=POS_Y;i<(POS_Y+FNT_H);i++){
idx=('e'-32)*FNT_H+(i-POS_Y);
memhead[i][0] = fnt3[idx];
idx=('l'-32)*FNT_H+(i-POS_Y);
memhead[i][1] = fnt3[idx];
idx=('g'-32)*FNT_H+(i-POS_Y);
memhead[i][2] = fnt3[idx];
idx=('a'-32)*FNT_H+(i-POS_Y);
memhead[i][3] = fnt3[idx];
idx=('r'-32)*FNT_H+(i-POS_Y);
memhead[i][4] = fnt3[idx];
idx=('b'-32)*FNT_H+(i-POS_Y);
memhead[i][5] = fnt3[idx];
idx=('e'-32)*FNT_H+(i-POS_Y);
memhead[i][6] = fnt3[idx];
idx=('T'-32)*FNT_H+(i-POS_Y);
memhead[i][14] = fnt3[idx];
idx=('E'-32)*FNT_H+(i-POS_Y);
memhead[i][15] = fnt3[idx];
idx=('S'-32)*FNT_H+(i-POS_Y);
memhead[i][16] = fnt3[idx];
idx=('T'-32)*FNT_H+(i-POS_Y);
memhead[i][17] = fnt3[idx];
idx=('O'-32)*FNT_H+(i-POS_Y);
memhead[i][26] = fnt3[idx];
idx=('S'-32)*FNT_H+(i-POS_Y);
memhead[i][27] = fnt3[idx];
idx=('D'-32)*FNT_H+(i-POS_Y);
memhead[i][28] = fnt3[idx];
}

Primero limpio la memoria. Luego en un lazo for recorro las FNT_H líneas que forman un caracter. La fuente que uso tiene este formato:

Código: [Seleccionar]

//
//  Font data for Berlin Sans FB Demi 12pt
//

// Character bitmaps for Berlin Sans FB Demi 12pt
const short fnt3[] =
{
// @0 '!' (14 pixels wide)
0b0000000000000000, //
0b0000000000000000, //
0b0000000000000000, //
0b0000000000000000, //
0b0000000000000000, //
0b0000000000000000, //
0b0000000000000000, //
0b0000000000000000, //
0b0000000000000000, //
0b0000000000000000, //
0b0000000000000000, //
0b0000000000000000, //
0b0000000000000000, //
0b0000000000000000, //

El primer caracter es el ' ' espacio (CHR 32). Entonces para obtener el primer short de la fuente resto 32 al caracter que quiero escrivir y lo multiplico por 14. Luego, en funcion de la línea (son 14 por caracyer) voy sumando 1 de offset.

Esta forma para texto funciona, no es lo mejor, pero por ahora funaciona.

El tema está en si alguien tiene experiencia en llenar buffer de video con gráficos (líneas más que nada) y texto de forma más optima.

Yo voy a tener una serie de variables en memoria que siempre deben presenarce en el mismo lugar. Entonces pensé en hacer una lista enlazada y configurar  un canal DMA para que llene el buffer de video de forma autónoma cada cierto tiempo...
El layout de un OSD es como este:
http://b.vimeocdn.com/ts/147/667/14766782_640.jpg
http://www.feiyu-tech.com/uploads/images/2012_11/1211270811053578.jpg

Entonces las dudas son: sería útil configurar un nuevo DMA para recolectar las variables del sistema y copiarlas al buffer de memoria? esto me lo pregunto, porque yo voy a tener las variables en STRINGS, pero como vieron mas arriba, no es tan directo el paso de caracter a dato en el buffer, hay varios indices y offsets...
La otra duda es si alguien conoce alguna rutina que me permita dibujar líneas entre dos puntos dados...

aguardo comentarios!

Saludos

[MGLSOFT]

Muy bueno!!

[ppyote]

No te serviría las rutinas que utiliza los glcd para dibujar esas líneas?

[elgarbe]

Muy bueno!!

Gracias, jeje, si llego a unir todo y funciona 

Sds.

[elgarbe]

No te serviría las rutinas que utiliza los glcd para dibujar esas líneas?

La verdad, nunca use un glcd. Estimo que pueden servir. alguna librería para recomendarme?

Saludos!

[ppyote]

No te serviría las rutinas que utiliza los glcd para dibujar esas líneas?

La verdad, nunca use un glcd. Estimo que pueden servir. alguna librería para recomendarme?

Saludos!

cualquiera de las que hay para ccs, lo único claro está, que te tocara modificarla para que en vez de envíar  el valor por un puerto,
sólo cambie el buffer de la imagen
busca glcd ccs en el foro que seguro das con una que dibuje líneas

[elgarbe]

Parecía más fácil... pero encontre un post de Ariel donde estan implementadas las funciones de Lineas, circulos y otros. De paso estuve leyendo sobre la disecretiacion de Bresenham's asique tengo resuelto la parte líneas... ahora me falta estudiar si puedo implementar DMA en alguna parte del código y la duda más grande, establecer que es más rápido, configurar el DMA o copiar memoria a memoria en un lao for...

Saludos!

[elgarbe]

Para los impacientes que no aguantan a ver resultados aqui va la parte de impresion de texto automatizada:

Las funciones que implemente son:

Código: [Seleccionar]

void put_char(short X, short Y, char Car){
short i;

for(i=Y; i<(Y+FNT3_H); i++)
membuff1[i][X] = fnt3[(Car - 32) * FNT3_H + (i-Y)];
}

// ***********************
// Funcion para enviar una cadena de caracteres
void put_string(short X, short Y, char *pcString){
int i = 0;
// loop through until reach string's zero terminator
while (pcString[i] != 0) {
put_char(X, Y, pcString[i]); // print each character
X++;
i++;
}
}

Y el código de pruebas es:

Código: [Seleccionar]

int main (void){
short i, j;
// short idx;

for(i=0;i<PIX_Y;i++)
for(j=0;j<PIX_X;j++)
membuff1[i][j] = 0;

put_string(0, 200, "elgarbe");

SSP0Init(); // Inicializo el bus SPI
DMAInit();
tim2_init(0); // Inicializamos el Tmr2 y le establecemos prioridad 0. La mas alta
EINTInit(); // Inicializo las interrupciones externas - LM1881

while ( 1 ){
}
}

Con el uso del buffer de memoria y el envío por DMA quedó muy limpio el programa. Esta quedando una buena base para recivir el resto de la spartes.

El resultado:



Saludos!

[MGLSOFT]

Excelente !!
Me interesa aprender a usar el DMA en PIC24 y DSPIC, tengo que levantar datos de 4 canales de un conversor A/D por SPI, y me parece ideal hacerlo con el DMA.
Sabes donde encuentro información al respecto??

[elgarbe]

http://www.todopic.com.ar/foros/index.php?topic=38271.0
Ahí hay algo. Despues hay que tener unas cuestiones puntuales sobre la transferencia por spi. Como el dma debe funcionar de forma independiente y de fondo, he leído que hay que hacer algunos pasos para que el spi lea el adc.

Fijate el post de merlinz, sino te sirve busco esa otra info que te digo. Creo que habia puesto en google spi dma lpc17xx la explicacion servia para cualquier micro...

Saludos!