escribir medida analogica con glcd_text57()

[PICYO]

vale chicos, ya está. Cómo no, era una chorrada, y eso ya lo sabia..por eso me tenía tan mosca. Al intentar hacer la presentacion del dibujo por función, antes he uqerido pasar por puntero, y guardarlo en un puntero ( claro) que lo definia del mismo nombre que el nombre del array del archivo.h
ggrr!

[bmb]

Me alegra que lo solucionaras.  Como vas con el método alternativo que te ha sugerido Suky?  Sería interesante que también lograras que funcionara.  Nos va a tocar estudiar C18 

Saludos!

[PICYO]

Hola!
Bueno, la verdad es que me voy mirando el foro ( es estar delante del pc y poner el foro) y mirarme mas preguntas de gente, además que voy haciendo mas cosas, sin prisa pero con pausa . Aun no me he puesto, pero lo suyo es que trataré de hacer ( sin copiar, que si no no tiene sentido) lo de Suky ( me lo estudiaré a ver que hace) y hacerlo yo. Pero...uhhh si con C18 puedo pasar parámetro por puntero, va a ser que la balanza se declinará hacia C18 ( aunque CCS nunca sería bueno de dejar e compilarlo eh ?)

[PICYO]

Bueno, estoy escribiendo mi pequeño manual ( por poner un nombre...) de como funciona tu funcion, Suky, y de momento he llegado a estas conclusiones :

Código: C

1. /* Interpretar la funcion    " void glcd_writeByte(int1 side, BYTE data);" para uso en la funcion de Suky
2. "void glcd_frame_rom(long Offset);", con motivo de poder usar arrays, usando archivos externos: CCS NO DEJA USAR PUNTEROS PARA ELLO. Solución:
3.  Crear un unico buffer, y darle un offset
4.  
5. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
6. // ------------------COMO FUNCIONA  " void glcd_writeByte(int1 side, BYTE data);" ----------------------------------
7. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
8.  
9.  
10. En caso que se ponga side=1, elije el PIN GLCD_CS2, o lo que es lo mismo :PIN_B1   // Chip Selection 2
11. sino,
12.                      side=0, elije el PIN GLCD_CS1, lo que es lo mismo: PIN_B0   // Chip Selection 1
13.  
14. Side=1 --> escribe el byte en la parte izquierda de la pantalla .---|
15.                                                                     |          ||||||||||||||||||||||||||
16.                                                                     |->        || side=1    |side=0    ||
17. Side=0 --> escribe el byte en la parte derecha de la pantalla.  --- |          || GLCD_CS2  | GLCD_CS1 ||
18.                                                                                ||           |          ||
19.                                                                                ||||||||||||||||||||||||||
20.  
21.  
22.  
23.  
24.  
25.  
26. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
27. // ------------------COMO FUNCIONA  " void glcd_frame_rom(long Offset);" ----------------------------------
28. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
29.  
30.  
31.      output_low(GLCD_DI); --> pone a 1 el PIN_B2 del PIC, para indicar al display,  modo de lectura de instruccion
32.      glcd_writeByte(GLCD_LEFT, 0b01000000); --> Escojemos lado izquierdo de la pantalla y lo ponemos 0. Segun HDM64GS12.c, en esa direccion esta ésa órden.
33.      glcd_writeByte(GLCD_LEFT, i | 0b10111000); --> inicializa la direccion de memoria, en la memoria del Display.Usa OR:
34.                                                     Setea cada  bit del Byte del buffer, del lado correspondiente de la pantalla, o sea, bit a bit, dice donde ha
35.                                                     de escribir.
36.  
37.  
38.    ___________________________
39.   |        TABLA DE OR                  |    Por ejemplo, si i=2 (i=0b00000010)  0b00000010 |0b01000000 = 0b10000010
40.   |___________________________|
41.   | BitA  BitB   Resultado              |
42.   |-------------------------------|
43.   |  0      0       0                        |
44.   |  0      1       1                        |
45.   |  1      0       1                        |
46.   |  1      1       1                        |
47.   |___________________________ |
48.  
49.  
50.      output_high(GLCD_DI);                   --> Despues de direccionar el dato a insertar, el PIN_B2 está a 1 para poner PIN GLCD_DI en aviso de insercion de datos.
51.      for(j = 0; j < 64; ++j){
52.         glcd_writeByte(GLCD_LEFT, Frame[k]); --> Ahora, se dibuja ya la izquierda de la pantalla, correspondiente a las columnas,eje y ( anchura de 64 pixeles)
53.         k+=1;                                    ¿ Que sentido tiene el offset? Al ser un array unidimensional, el eje "x" no queda especificado, por lo tanto,
54.         delay_us(10);                            en main() está dirijiendo el offset donde escribir, o lo que es lo mismo, relacionando coordenadas (x,y) del pixel a
55.      }                                           escribir.
56.  
57.  
58.  
59.  
60. */

Suky, estoy analizando tu función antes de jugar con ella, y creo que entiendo todo el proceso. El hecho de hacer un offset es porqué
el array es unidimensional. El fichero de la imagen, contiene 1024 bytes (8192 bits), asi que entiendo que el tratamiento del offset empieze por0.
En 0 empieza ( supongo) por el lado superior izquierdo de la pantalla. Pero no entiendo por qué lo haces en 3 veces ( hablo del offset puesto desde el main), no acabo de
entender la forma de escritura del display: escribe las 64 primeras columnas. Ahi hay 1024 bytes.Sumas 1024 de nuevo (2048) y escribe otras 64 columnas desde el nuevo ofset
del archivo imagen.Pero no entiendo esas " 3 tacadas" de offset, entenderia si cada suma que hicieras de offset, sumara un total de 8192 bits. Así, todos los bits de la imagen
quedarían repartidos en diferentes filas por el offset. pero no, suma un número inferior, asi que no debe ser asi como funciona. Cuál es el sentido pues de exactamente esos  numeros
en el offset ?

Código: C

1. while(1){    
2.  
3.      glcd_frame_rom(0);
4.      delay_ms(100);
5.      glcd_frame_rom(1024);  
6.      delay_ms(100);
7.      glcd_frame_rom(2048);
8.      delay_ms(100);
9.      glcd_frame_rom(3072);
10.      delay_ms(100);
11.  
12.   }    //  0+1024=2048 +1024= 3072 +1024=4096....

....  que pasa hasta los 8192 bits?? (1024 bytes *8 )

[Suky]

Para guardar los datos de una imagen que ocupa 128x64 pixeles necesitamos: (128*64)/8=1024 Bytes. O sea que cada 1024 bytes tenemos una nueva imagen. Los datos están guardados en el array empezando desde la esquina superior izquierda, en donde los bytes son columnas. (De esa manera dispone los bytes un GLCD con driver ks0108)

Entonces al hacer glcd_frame_rom(0), dibujamos una imagen en la pantalla completa, y con glcd_frame_rom(1024) dibujamos otra imagen.


Saludos!

[PICYO]

ahh vale, ya entiendo. Se dibuja de 1024 en 1024 bytes, y por columnas. O sea, cada columna está escrita en 1024 bytes, y lo que realmente se hace es que se va superponiendo fila a fila ( escribiendo en cada columna) la imagen, por ejemplo, para escribir lo haria un modo asi tal que:

escribo 1
escribo1+escribo2
escribo1+escribo2+escribo3
(...)
escribo1+(...) escribo64

Si asi, entiendo pues el offset. Voy a usarla pues, ahora que sé porqué.
Gracias !

[PICYO]

ups..no me compila. He agregado la funcion dentro del archivo  HDM64GS12.c, como has dicho, y el problema me sale exactamente el mismo, no sabe que es Frame ( he cambiado por logo, mi archivo logo.h con su cont byte logo[]).       

[Suky]

Adjunto una imagen de como se envían los datos. Donde el byte 0 es el de la izquierda superior, y el byte 1023 es el de la esquina inferior derecha.

ups..no me compila. He agregado la funcion dentro del archivo  HDM64GS12.c, como has dicho, y el problema me sale exactamente el mismo, no sabe que es Frame ( he cambiado por logo, mi archivo logo.h con su cont byte logo[]).        

En este archivo (HDM64GS12.c), debes agregar un include al archivo que tiene el buffer, en mi caso por ejemplo: #include "Frames.c"



Por aquí deje una librería para usar en CCS o C18 independientemente. Y como C18 permite punteros a rom, se puede utilizar la siguiente función:

Código: C

1. void vGLCDImagen(unsigned char x,unsigned char y,unsigned char LargoX,unsigned char LargoY,rom char *Data){
2. unsigned char x_temp, y_temp,i,Cant_Byte_Y,Data_temp;
3.  
4.    Cant_Byte_Y=((LargoY-1)/8)+1;
5.    
6.    for(i=0;i<Cant_Byte_Y;i++){
7.       for(x_temp=x;x_temp<x+LargoX;x_temp++){
8.                  Data_temp=*Data++;
9.          for(y_temp=0;y_temp<LargoY-i*8;y_temp++){
10.             vGLCDPoint(x_temp,y_temp+y+i*8,(Data_temp&0x01));
11.                         Data_temp>>=1;
12.          }
13.       }
14.    }
15. }

Y usarla por ejemplo:

Código: C

1. // Dibujamos imagen partiendo desde x=0, y=0, tamaño 128x64, imagen nombre: Imagen128x64 (ubicada en Fuentes.c)
2.         vGLCDImagen(0,0,128,64,&Imagen01_128x64[0]);
3.         #ifdef GLCD_USE_MODE_FAST                       // Si está habilitado el modo rapido, actualizamos pantalla.
4.         vGLCDUpdate();
5.         #endif

Saludos!

[PICYO]

si, cierto, debia poner ese include en el HD...c, pero al ponerlo en mi main(), creía que sería suficiente. Ahora bien ha compilado, pero ha salido una nuve de bits que nada tiene que ver con mi imagen. He probado a hacer otro array distinto, volviendo al bit2LCD, a ver si era por algo relacionado con ellos ( estaba usando el programa que me paso bmb), pero nada. De momento usaré la forma que me dijo bmb, de hecho así me ha salido. Iré directamente a ver lo que me has enseñado en último plano, para poder usar punteros directamente

[Suky]

Puede ser que la manera de crear el array no tenga nada que ver como lo guarda en la RAM el GLCD ks0108, y como en la función de bmb, se envía pixel por pixel no hay problema. Esto debería solucionarse eligiendo la manera correcta al crear el array unidimensional con el software.


Saludos!