Touch Screen GLCD 160x80, desarrollo con ASM + PIC18F4550

Revisa tu programa compilado como te comenté View->program memory y allí verificas que los datos de la imágen estén a partir de la dirección 0x0800... a mi me solía pasar que declaraba así los datos:

Tabla_Datos
ORG 0x0800
bla bla bla

cuando lo correcto es

ORG 0x0800
Tabla_Datos
bla bla bla

el orden de la etiqueta importa, revisa que no sea tu caso. Muchas veces tuve problemas por eso.
 
Esta pantalla me esta costando bastante, ya logre enviar numeros en modo grafico, solo que no los puedo insertarlos en otro grafico, hay un comando que permite insertar un pixel, la cosa es que si queremos posicionarla digamos en 2,2 en realidad se posicionara en el byte 2
0000 0000000000000000
0100 0000000010000000
osea que se posicionan cada 8 bits, para mi es un problema porque quiero hacer un algoritmo donde se pueda dibujar una linea, como en C: goto(x,y)
 
Aún no he experimentado bien la idea. Pero tengo mas o menos entendido como se haría: Para comenzar se inicializaría un buffer de memoria en RAM para contener los 1600 bytes que requiere el GLCD (aquí el inconveniente de usar uC's), en este buffer se cargarían los datos que se vayan a enviar al GLCD.

Para el caso de dibujar una línea, la idea sería ir calculando que pixeles se encenderían y cuales no, estos cálculos nos deberán arrojar que pixeles se ilumnarán y por medio de apuntadores ir modificando los
bytes por medio de instrucciónes OR y AND para apagar y encender pixeles dentro del buffer del GLCD.

Es una idea algo vaga, la concretaré por estos días que ya he salido de vacaciónes y tendré más tiempo para dedicarle.
 
o claro, yo voy a modificar un archivo en C para que se pueda manejar en PICC y asi disponible para ese lenguaje, a veces es preferible el C que el asm.
 
En estos casos si es preferible un lenguaje de alto nivel, hace la tarea más fácil pero quizás retarde la genereción de imágenes y demandan mucha RAM para cálculos matemáticos
 
Este es un editor de imagenes muy bueno ymucho mas facil que el bitmap y es la version completa



Ami me funciona de maravilla
 

Adjuntos

  • editor.rar
    152.5 KB · Visitas: 55
Última edición:
Este es un editor de imagenes muy bueno ymucho mas facil que el bitmap y es la version completa

Gracias

Como sacar un grafico en la mitad del lcd o en otra parte que no sea la posicion 0x00

Esto se logra reescribiendo el apuntador de posición del LCD, byte alto y bajo, si no mal recuerdo se logra con los comandos 0x0A (byte bajo) y 0x0B (byte alto) en seguida de cada de estos comandos se escribe el número de la posición donde se comenzará a escribir. Consulta el PDF en la pág 21/30
Saludos
 
En efecto, primero tienes la imagen digamos, la de fondo y despues mandas el otro grafico y lo apuntas donde quiere estar, asi se encima la segunda imagen con la primera que se queda "grabada" y se meter 2 o las que sean.
 
he leido el foro y sigo teniendo la duda ¿ no es posible ingresarle texto a una imagen ? e hecho el intento pero no lo he logrado he leido que con otros glcd si es posible. no se si requiera alguna instruccion especial
 
he leido el foro y sigo teniendo la duda ¿ no es posible ingresarle texto a una imagen ? e hecho el intento pero no lo he logrado he leido que con otros glcd si es posible. no se si requiera alguna instruccion especial

No es posible ya que el GLCD solo puede trabajar en dos modos independientes, texto o gráficos, pero no simultáneamente. En el modo gráfico se puede ingresar texto como si fueran pequeñas imágenes (creadas por uno mismo) pero el algoritmo es un tanto complejo para ir posicionando cada "letra" en su respectiva posición de la palabra.
 
Claro es dificil hacer un algoritmo para poner texto en modo grafico, yo lo logré aunque no he podido insertar caracteres encima de otra imagen, luego posteo el codigo
 
Lo prometido es deuda... dejó aquí el programa con el algoritmo que les comenté.
Esta hecho en ensamblador para el PIC18F2450 trabajando a 20 MHz y con un cristal de cuarzo de 32768Hz para generar retardos precisos en el TMR1. El bus de datos del GLCD está conectado de RB0 a RB7,
EN->RA1 y RS a RA0.

Les explicaré como opera el algoritmo:

La idea es como les comenté anteriormente, en el programa están declaradas "minimágenes" de 8 bytes correspondientes a cada letra que se deseé mostrar, estos datos se encuentran a partir de la dirección 0x0900 y cada caracter está declarado por la etiqueta "Letra_A, Letra_B, etc"

Se tienen dos registros Cor_X y Cor_Y los cuales apuntan a las 200 posiciónes para mostrar texto en el GLCD, es decir si establecemos Cor_X=0 y Cor_Y=5, se mostrará el caracter en la fila 6 y columna 0 del GLCD

GLCD Coor.PNG

En el archivo de Excel está un bosquejo donde se observan las direcciones del cursor correspondientes a cada coordenada. (Una coordenada está compuesta por 8 bytes).

tabla.PNG

Cuando se desea mostrar algún caracter es necesario seguir 3 pasos
1-Cargar los registros "Cor_X" y "Cor_Y" en la posición donde se desee mostrar el caracter
2-Cargar el caracter a enviar en W por medio de la instrucción "movlw LOW Letra_A", de esta manera se apunta al inicio del grupo de 8 bytes que conforman a la letra A
3-Llamar a la subrutina GLCD_XY la cual se hará cargo de leer los datos del caracter y posicionarlos en las coordenadas especificadas.

La subrutina "GLCD_XY" básicamente lo que hace es recibir 3 parámetros: 2 datos coordenadas y un dato del caracter a mostrar.

Para calcular la dirección del cursor el GLCD lo que hace es tomar el valor de la coordenada Y y multiplicarla por 160, a este resultado se le suma el valor de la coordenada X y se obtiene el inicio donde se escribirán consecutivamente los 8 bytes correspondientes al caracter

ejemplo.PNG

Como ejemplo muestro como escribir un caracter en la coordenada 2,1 del GLCD

La dirección del cursor es manipulada directamente por medio de los registros PRODL y PRODH, en estos registros se obtiene el resultado de la multiplicación, aproveche estos mismos registros para conformar el apuntador de 16 bits que tiene el GLCD para posicionar el cursor.

La misma subrutina "GLCD_XY" al terminar de escribir un caracter avanza a la siguiente coordenada en X para no tener que reescribir este dato al momento de enviar cadenas de caracteres
Espero haberme explicado, con este ejemplo, de todos modos en el archivo .asm viene comentado aún así cualquier duda que resulte pregunten por acá.

He de aclarar que no he terminado de formar la tabla para todo el abecedario en mayúsculas y minúsculas por lo que les solicito su coperación. Los datos de los caracteres los saco de la misma hoja de datos del GLCD formando byte por byte por lo que es algo pesado.

Aún asi, ójala puedan optimizar más el direccionamiento de letras, ya que por la forma en que lo implementé solo es posible direccionar hasta 256/8 =32 caracteres diferentes de 8 bytes.
En fin, les dejo una foto con el resultado.

IMG_3234.jpg

Saludos :apreton:
 

Adjuntos

  • GLCD_Texto.txt
    25.1 KB · Visitas: 21
  • GLCD.rar
    4 KB · Visitas: 19
Última edición:
Ujule bien eres un maestraso, yo lo hize de forma diferente, hize los carcteres en el bitmap2lcd del 0 al 9 solamente, y despues los almacene en una parte de la memoria de programa, despues jalaba los datos con la funcion tablat. tengo una teoria, como se le podria hacer para agrandar los caracteres, si le ponemos size =1 saldra de tamaño natural, pero ke tal si multiplicamos un bit y se hace 4 bits, osea ke se desplaza a un bit a la derecha a la eskina derecha/abajo y abajo. No se si me explique, que ben trabajo mi rutina la verdad me costo trabajo,
 
Última edición:
La idea en si es similar a la que comentas, salvo porque yo incluí en la rutina el algoritmo de posicionamiento en coordenadas (seguí la idea de la función gotoxy() en C++ que comentaste).
Tu idea de cambiar el tamaño de fuente es llamativa, incluso, no sé, se podría elegir entre diversos tipos de fuentes.
Se me ocurre, para faciliar más la programación, elegir tamaños correspondientes a potencias de 2, por ejemplo en el caso anterior los caracteres están a 8X8 pixeles, se podrían agrandar después a 16X16 o 32X32. Ya pensaré en alguna forma de implementarlo.
Si es algo complicado sobre todo por la parte matemática jaja ahy que estarle pensando como enseñar al uC a calcular las posiciones del GLCD y como administrar su propia memoria.
Pero no es imposible, que te parece si entre varios trabajamos en el programa para llevar a cabo todas estas ideas...
 
Exacto, yo tambien le agrege la funcion de gotoxy, Hize un caracter de 5x10, enviaba un byte y despues le sumaba 20 al puntero para el sig byte. esa idea de tamaño de la fuente es buena, voy a subir mi codigo mañana yo creo porque la tesis me esta matando horrible, tmbn ando desarrollando la rutina del touch, y con lo que pueda ayudaré, tengo la idea de hacer varias librerias como hacer figurillas o caracteres o cosas asi, casi casi como C para que asi se pueda interactuar.
 
Hola amigos pues les comento que estoy siguiendo todo el post y en hora buena que esta de lujo yo estoy haciendo lo mismo que ustedes solo que traduciendo sus códigos de ASM a CCS y me encanta la propuesta de nietzche de generar algunas librerías para poder trabajar de manera más fácil con este GLCD por lo pronto aquí esta el alfabeto.

Código:
byte CONST Inicio[96] =
                        {0xA0 // SPACE
                         0x21 // !
                         0xDE // "
                         0x23 // #
                         0x24 // $
                         0x25 // %
                         0x26 // &
                         0x27 // '
                         0x28 // (
                         0x29 // )
                         0x2A // *
                         0x2B // +
                         0x2C // ,
                         0x2D // -
                         0x2E // .
                         0x2F // /
                         0x30 // 0
                         0x31 // 1
                         0x32 // 2
                         0x33 // 3
                         0x34 // 4
                         0x35 // 5
                         0x36 // 6
                         0x37 // 7
                         0x38 // 8
                         0x39 // 9
                         0x3A // :
                         0x3B // ;
                         0x3C // <
                         0x3D // =
                         0x3E // >
                         0x3F // ?
                         0x40 // @
                         0x41 // A
                         0x42 // B
                         0x43 // C
                         0x44 // D
                         0x45 // E
                         0x46 // F
                         0x47 // G
                         0x48 // H
                         0x49 // I
                         0x4A // J
                         0x4B // K
                         0x4C // L
                         0x4D // M
                         0x4E // N
                         0x4F // O
                         0x50 // P
                         0x51 // Q
                         0x52 // R
                         0x53 // S
                         0x54 // T
                         0x55 // U
                         0x56 // V
                         0x57 // W
                         0x58 // X
                         0x59 // Y
                         0x5A // Z
                         0x5B // [
                         0xCD // \
                         0x5D // ]
                         0x5E // ^
                         0x5F // _
                         0x60 // `
                         0x61 // a
                         0x62 // b
                         0x63 // c
                         0x64 // d
                         0x65 // e
                         0x66 // f
                         0x67 // g
                         0x68 // h
                         0x69 // i
                         0x6A // j
                         0x6B // k
                         0x6C // l
                         0x6D // m
                         0x6E // n
                         0x6F // o
                         0x70 // p
                         0x71 // q
                         0x72 // r
                         0x73 // s
                         0x74 // t
                         0x75 // u
                         0x76 // v
                         0x77 // w
                         0x78 // x
                         0x79 // y
                         0x7A // z
                         0x7B // {
                         0x7C // |
                         0x7D // }
                         0x7E // ->
                         0x7F // <-
                                  };

saludos cordiales.
 
Atrás
Arriba