Hola!!
Me compré un glcd 128x64 marca winstar con el controlador ks0108 .
Para probarlo utilicé las librerías de Jal asociadas a ese controlador y la common,tambien la print.
Para entender su funcionamiento, hice correr un ejemplo para el 16f877a. a 20Mhz.
Realmente me desilucionó....
Lo único que funcionó de ese ejemplo fué la directiva glcd_box (hacer un marco según las coordenadas)
Eso me dejó levemente tranquilo porque al abarcar el marco toda la pantalla, pude constatar que los dos controladores funcionaban, (lleva uno por lado de pantalla)
Nunca pude poner un string, ni siquiera el del ejemplo.
Solo me deja poner caracteres sueltos y nada más que en el lado izquierdo de la pantalla.
Es muy extraño porque en el procedimiento de escritura de caracteres original de la libreria de jal, queda bien definido en que lugar debe escribir en función de las cordenadas y el caracter a imprimir, o sea que la selección de lado la hace el mismo procedimiento.
Ni hablar de colocar un dato como la temperatura, no lo toma.
Si alguien probó las librerías, por favor avisenme del resultado porque yo tengo mis dudas que funcionen correctamente.
Gracias!!
Hola YO. ¿Cómo andas?
Te cuento que yo he tenido varios problemas con las librerías de JAL, y las que puedo reemplazar por una creada por mi, ni lo dudo, lo hago de cero.
Para que te des una idea, la librería del ADC, pierde mucho tiempo y ajusta bit al divino botón. La librería personalizada para tal PIC, funciona muchísimo mejor, censa mejor y es más rápido.
Te debe estar pasando lo mismo. Hay cosas que la librería, las debe hacer mal.
Si querés, te puedo dar una mano para crear una librería para ese LCD ¿te parece?
Hola David!!
Gracias a Dios y la Virgencita ando bien, desde hace un tiempo con sobretrabajo (habràs notado que ando poco por los foros) pero no me quejo, espero salir de vacaciones pronto :\
Me entusiasmò el tema de los glcd porque vi algunas pantallas de aparatos de meteorologia (centrales portàtiles) que mostraban la condiciòn del tiempo con dibujos y me dije Porquè no?
Luego vi por internet que hay programas gratuitos que segùn el dibujo que hagas en el, te genera el còdigo para el pixelado automàticamente y que muchos lo usan, entonces me decidì y comprè la pantallita para practicar y poder pasar a la de color ( que para eso tambien Jal tiene librerias ), pero hoy dudo mucho de que pueda avanzar en el tema con las mismas.
Te agradezco infinitamente que te intereses por el tema y como muestra de ello, y en agradecimiento a todo lo que aprendo al lado tuyo en este foro y en donde vos estès, es que te voy a mandar a la direcciòn que vos me digas, una pantallita de èstas (compre dos) sin ningun compromiso, te la regalo para que hagas con ella lo que quieras (y si te dà dolor de cabeza la podes reventar contra el suelo, como tengo ganas de hacer yo con la mia :jeje: )
Bueno, espero tu respuesta y un fuerte abrazo para vos en particular y para todo el foro en general!!!
Pero no tienes que agradecer nada Yovani. Acá estamos todos para aprender, yo solo cree el lugar. El foro no es nada sin ustedes.
Realmente, me da pena aceptar el regalo, porque te repito, no me debes nada de nada. Al contrario, yo tengo que estar agradecido con ustedes que participan en el foro.
Abrazos.
David:
Tu humildád es digna de un buen hijo de María, pero ahora me haces sentir mal a mi......
¿Alguna vez te ganaste una medalla, un trofeo, un reconocimiento por haber hecho algo bien?
Yo si y es muy gratificante.
Me gustaría que lo tomes de esa manera, sin pena, no te olvides que también es mi humilde forma de decir gracias por algo que Tu humildad no te deja valorar.
De todas maneras la desición es tuya (y el GLCD tambien :jeje:)
Ya estoy saliendo de viaje y vuelvo el lunes.
Tenes mi correo.
Fuerte abrazo!
Bueno. Te mando un MP ok!
Y ya llegó nomás. Estoy más feliz que un niño con juguete nuevo :\ :\
(http://www.meteorologiafacil.com.ar/foros/index.php?action=dlattach;topic=711.0;attach=485)
(http://www.meteorologiafacil.com.ar/foros/index.php?action=dlattach;topic=711.0;attach=487)
(http://www.meteorologiafacil.com.ar/foros/index.php?action=dlattach;topic=711.0;attach=489)
(http://www.meteorologiafacil.com.ar/foros/index.php?action=dlattach;topic=711.0;attach=491)
Felicitaciones David por el chiche nuevo :\ :\ :\ . Ahora ha aprovecharlo.
Felicitaciones YO por el gesto. ok!
Gracias HJ.
Si, ahora hay que sacarle el jugo.
Realmente muy buen gesto y por favor no reventarlo contra el piso, solo es cuestion de paciencia y de insistir, insistir, insistir, de probar y probar hasta que las cosas salgan, siempre salen, a veces solo es cuestion ponerle un freno a la ansiedad y tomarse el tiempo que sea necesario.
Un Abrazo a ambos
Gracias Ricber.
EN un par de horas, me voy a poner a jugar con él. :\
Bravo llegò bien :\
Gracias Hj
Gracias Ricber
Abrazos a todos
Hola muchachos, ¿como andan?
David ¿como te fué con el display, lo pudiste probar?
Yo voy a ver detalladamente las instrucciones para el manejo de ese modelo y voy a compararlas con la librería original, para ver si el display es compatible con las instrucciones de Jal.
Ya tengo algo en borrador, después lo pego y vemos si estoy equivocado en mi interpretación.
Me tomé todo éste tiempo para desenchufarme y arrancar con más ganas, como ves Ricber te estoy haciendo caso, y por cierto ¿ya practicaste algo en éste lenguaje?
Y vos HJ ¿que onda, probaste algo de Jal?
Un abrazo a todos!!
Cita de: YO en Abril 23, 2012, 03:53:07 PM
Y vos HJ ¿que onda, probaste algo de Jal?
Ni....
Lo mío es el ASM, por cuestiones de trabajo estoy incursionando de a poco con C18 y con MikroC por hobby ya que compre la entrenadora easyPIC6 de mikro-e, pero mi cerebro se niega a pensar en algo diferente al ASM.... son cuestiones del alma...
del almanaque, es que los años no vienen solos.
Así que el Jal, lamentablemente, va ha continuar postergado por el momento.
Saludos
HJ
Hola YO. Estuve haciendo pruebas, pero no logro hacerlo andar. La luz de fondo anda, pero no aparece ningún caracter en la pantalla.
El pin del contraste, lo conecté a GND y nada. Lo mismo pasó cuando lo conecté a +5V. Primero había probado con un potenciómetro.
Sigo buscando posibles errores.
Una pregunta, si se alimenta el GLCD y el contraste; ¿Se enciende algunos puntos como lo hace un LCD normal?
Hola, encontré esta librería en un par de foros y aparentemente anda... se las dejo en consideración. Obviamente no tengo ni idea si puede o no andar.
Enlace 1 (http://code.google.com/p/jallib/source/browse/trunk/project/catpad_mw/v01catpad/glcd_ks0108mw.jal?spec=svn1856&r=1856)
Enlace 2 (http://www.techtir.ie/node/1003419)
Saludos
HJ
-- Title: lcd_ks0108 - Library for KS0108 compatible LCD
-- Author: Serkan Ayyýldýz Copyright (c) 2006..2009, all rights reserved.
-- Adapted-by: Joep Suijs
-- some small changes: Michael Watterson (c)2010
-- Compiler: >=2.2
--
-- This file is part of jallib (http://jallib.googlecode.com)
-- Released under the ZLIB license (http://www.opensource.org/licenses/zlib-license.html)
--
-- Sources:
--
-- Description: Library for KS0108 compatible graphic lcd with 128x64 resolution.
--
--
-- Notes:
--
const KS0108_LEFT = 0
const KS0108_RIGHT = 1
const KS0108_CMD_ON = 0x3F
const KS0108_CMD_OFF = 0x3E
const KS0108_CMD_PAGE = 0xB8
const KS0108_CMD_COLUMN = 0x40
const KS0108_CMD_TOP_RAM = 0xC0
-- Purpose: Write a byte of data to the specified chip
-- Inputs: 1) chipSelect - which chip to write the data to
-- 2) data - the byte of data to write
procedure _ks0108_write(byte in side, byte in data) is
if side == 1 then -- Choose which side to write to
GLCD_CS2 = high
else
GLCD_CS1 = high
end if
GLCD_RW = low -- Set for writing
GLCD_DATAPRT = data -- Put the data on the port
GLCD_DATAPRT_DIR = all_output
_usec_delay (1)
GLCD_E = high -- Pulse the enable pin
_usec_delay (2)
--delay2_us
GLCD_E = low
GLCD_CS1 = low -- Reset the chip select lines
GLCD_CS2 = low
--delay_2us()
_usec_delay (2)
end procedure
-- Purpose: Reads a byte of data from the specified chip
-- Ouputs: A byte of data read from the chip
function _ks0108_read(byte in side) return byte is
var byte data -- Stores the data read from the LCD
GLCD_DATAPRT_DIR = all_input -- Set port d to input
if side == 1 then -- Choose which side to write to
GLCD_CS2 = high
else
GLCD_CS1 = high
end if
GLCD_RW = high -- Set for reading
_usec_delay (1) -- delay_cycles(1)
GLCD_E = high -- Pulse the enable pin
_usec_delay (2)
data = GLCD_DATAPRT -- Get the data from the display's output register
GLCD_E = low
GLCD_CS1 = low -- Reset the chip select lines
GLCD_CS2 = low
_usec_delay (2)
return data -- Return the read data
end function
-- Purpose: Turn the display on
procedure lcd_on() is
_ks0108_write(KS0108_LEFT, KS0108_CMD_ON)
_ks0108_write(KS0108_RIGHT, KS0108_CMD_ON)
end procedure
-- Purpose: Turn the display off
procedure lcd_off() is
_ks0108_write(KS0108_LEFT, KS0108_CMD_OFF)
_ks0108_write(KS0108_RIGHT, KS0108_CMD_OFF)
end procedure
-- Purpose: Set the page number
-- Inputs: A page number (0 - 7)
procedure _ks0108_page(byte in side , byte in page) is
_ks0108_write(side, KS0108_CMD_PAGE | page)
end procedure
-- Purpose: Set the column address
-- Inputs: The column address (0 - 63)
procedure _ks0108_column(byte in side, byte in column) is
_ks0108_write(side, KS0108_CMD_COLUMN | column)
end procedure
-- Purpose: Specify reads and writes are instructions
procedure _ks0108_inst() is
GLCD_DI = low
end procedure
-- Purpose: Specify reads and writes are data
procedure _ks0108_data() is
GLCD_DI = high
end procedure
-- Purpose: Turn a pixel on a graphic LCD on or off
-- Inputs: 1) x - the x coordinate of the pixel
-- 2) y - the y coordinate of the pixel
-- 3) color - ON or OFF
procedure PlotPixel(byte in x, byte in y, bit in onoff) is
var byte data , yy
var byte side = KS0108_LEFT -- Stores which chip to use on the LCD
if x > 127 then
x = x -128
end if
if x > 63 then -- Check for first or second display area
x = x - 64
side = KS0108_RIGHT
end if
if y > 191 then
y = y -192
elsif y > 127 then
y = y - 128
elsif y > 63 then
y = y -64
end if
_ks0108_inst() -- Set for instruction
_ks0108_column(side,x) -- Set the horizontal address
_ks0108_page(side,(y / 8)) -- Set the page address
_ks0108_data() -- Set for data
data = _ks0108_read(side) -- Need two reads to get data at new address
data = _ks0108_read(side) -- DO NOT REMOVE 2nd Read!
-- add XOR code
if onoff == 1 then
-- bit_set(data, y%8) -- Turn the pixel on
yy = y % 8
data = data | ( 1 << yy )
else -- or
-- bit_clear(data, y%8) -- turn the pixel off
yy = y % 8
data = data & !( 1 << yy )
end if
_ks0108_inst() -- Set for instruction
_ks0108_column(side,x) -- Set the horizontal address
_ks0108_data() -- Set for data
_ks0108_write(side, data) -- Write the pixel data
end procedure
procedure _ks0108_write_byte(byte in x, byte in y, byte in veri) is
var byte side = KS0108_LEFT -- Stores which chip to use on the LCD
if x > 127 then
x = x -128
end if
if (x > 63)then -- Check for first or second display area
x = x - 64
side = KS0108_RIGHT
end if
if y > 191 then
y = y -192
elsif y > 127 then
y = y - 128
elsif y > 63 then
y = y -64
end if
_ks0108_inst() -- Set for instruction
_ks0108_column(side,x) -- Set the horizontal address
_ks0108_page(side,(y / 8)) -- Set the page address
_ks0108_data() -- Set for data
_ks0108_write(side, ! veri) -- Write the pixel data
end procedure
-- Purpose: Fill the LCD screen with the passed in color
-- Inputs: ON - turn all the pixels on
-- OFF - turn all the pixels off
procedure lcd_fill(byte in data) is
var byte i, j
i = 0 -- Loop through the vertical pages
for 8 loop
_ks0108_inst() -- Set for instruction
_ks0108_page(KS0108_LEFT,i) -- Set page address
_ks0108_page(KS0108_RIGHT,i)
_ks0108_column(KS0108_LEFT,0) -- Set horizontal address to 0
_ks0108_column(KS0108_RIGHT,0)
_ks0108_data() -- Set for data
-- Loop through the horizontal sections
for 64 loop
_ks0108_write(KS0108_LEFT ,data) -- Write the byte of data
_ks0108_write(KS0108_RIGHT,data)
end loop
i = i + 1
end loop
end procedure
-- Purpose: Initialize the LCD.
-- Call before using any other LCD function.
procedure lcd_init() is
-- Initialze some pins
GLCD_DATAPRT = 0x00
GLCD_DATAPRT_DIR = all_output
GLCD_RW_DIRECTION = output
GLCD_CS1_DIRECTION = output
GLCD_E_DIRECTION = output
GLCD_DI_DIRECTION = output
--GLCD_RST_DIRECTION = output
GLCD_CS2_DIRECTION = output
--GLCD_RST = high
GLCD_E = low
GLCD_CS1 = low
_ks0108_inst() -- Set for instruction
_ks0108_write(KS0108_LEFT, KS0108_CMD_TOP_RAM | 0) -- First RAM line at the top of the screen
_ks0108_write(KS0108_RIGHT, KS0108_CMD_TOP_RAM | 0) -- First RAM line at the top of the screen
_ks0108_page (KS0108_LEFT ,0) -- Set the page address to 0
_ks0108_page (KS0108_RIGHT,0)
_ks0108_column(KS0108_LEFT ,0) -- Set the column address to 0
_ks0108_column(KS0108_RIGHT,0)
lcd_on() -- Turn the display on
lcd_fill(0) -- Clear the display
end procedure
-- use for sprites or fonts that are multiple of 8 high
procedure BlitColumn (byte in x, byte in y, byte in column ) is
_ks0108_inst() -- Set for instruction
if (x > 128) then
x = x -128
end if
if y > 191 then
y = y -192
elsif y > 127 then
y = y - 128
elsif y > 63 then
y = y -64
end if
if (x < 64) then
_ks0108_column(KS0108_LEFT,x) -- Set the horizontal address
_ks0108_page(KS0108_LEFT, (y / 8)) -- Set the page address
_ks0108_data() -- Set for data
_ks0108_write(KS0108_LEFT, column) -- Write the pixel data
else
_ks0108_column(KS0108_RIGHT, x-64) -- Set the horizontal address
_ks0108_page(KS0108_RIGHT, (y / 8)) -- Set the page address
_ks0108_data() -- Set for data
_ks0108_write(KS0108_RIGHT, column) -- Write the pixel data
end if
end procedure
procedure PlotColumn(byte in x, byte in y, byte in column, bit in ink, bit in replace) is
-- if ink is false, invert column data
-- if replace is true, plot 0 and 1 ink, else plot only only ink value ink
var byte data
var byte side = KS0108_LEFT -- Stores which chip to use on the LCD
if x > 127 then
x = x -128
end if
if x > 63 then -- Check for first or second display area
x = x - 64
side = KS0108_RIGHT
end if
if y > 191 then
y = y -192
elsif y > 127 then
y = y - 128
elsif y > 63 then
y = y -64
end if
if replace then
if ink then
data = column
else
data = ! column
end if
else
_ks0108_inst() -- Set for instruction
_ks0108_column(side,x) -- Set the horizontal address
_ks0108_page(side,(y / 8)) -- Set the page address
_ks0108_data() -- Set for data
data = _ks0108_read(side) -- Need two reads to get data at new address
data = _ks0108_read(side) -- DO NOT REMOVE 2nd Read!
if ink then
data = data | column
else
data = data & (! column)
end if
end if
_ks0108_inst() -- Set for instruction
_ks0108_column(side,x) -- Set the horizontal address
_ks0108_page(side,(y / 8)) -- Set the page address
_ks0108_data() -- Set for data
_ks0108_write(side, data) -- Write the pixel data
end procedure
Edito: Cuando hice en MikroC el programa para controlar el LCD del Nokia 1100 tube que trabajar con loas lectras como si fuesen imágenes, es decir, posicionar el cursor y dibujar el punto correspondiente.
Edito 2: Hoja de datos (http://ftp://docenti.ing.units.it/arc_stud/Carrato_Giulio/Calcolatori_Elettronici_3/Docum/LCD20KS0108.pdf).
Si, con el contraste a fondo se realzan todos los pixeles.
Fijate si tenes el display conectado de esta manera:
Pin 1 = GND
2 = + 5v.
3 = Vo (cursor de preset contraste)
4 = D/I
5 = R/W
6 = E
7 = DB0
8 = DB1
9 = DB2
10 = DB3
11 = DB4
12 = DB5
13 = DB6
14 = DB7
15 = CS1
16 = CS2
17 = RST
18 = Vee (salida a preset de contraste 10 K el otro extremo va a GND)
19 = Led + (conectar a resistor de 220 o 100 ohm y èste a 12 volts )
20 = Led - ( a misma fuente de 12 volts )
De otra forma no funciona.
Hay muchas formas de conexiòn pero para èste modelo es esta.
Chequealo y contame
¡Ajá! Ahí está mi error.
La salida Vee, la dejé al aire. No lo puse en el contraste.
Probando.......
Gracias HJ!
Ya probé con librerías diferentes y todas hechas por la misma gente, pero ninguna funciona completamente, por ejemplo: la librería original funciona con otra libreria adicional llamada common,que a su vez debería trabajar con las otras que son las Font (hay una para cada tamaño de letra y son tres).
Pero como te decía, con la librería original del paquete Jal no puedo poner una palabra completa, solo me deja poner caracteres sueltos, pero el comando print no toma los caracteres de la tabla automáticamente para formar palabras completas.
Si lo puedo hacer con otra librería que no está en el paquete, escribe la palabra completa pero....
esa librería no me deja poner las direcciones de escritura que yo quiero, corrijo, me deja, pero después las pone en forma aleatoria donde se le ocurre, y para peor como el display está dividido en dos controladores diferentes siempre lo hace con el de la derecha, según la dirección que le pongas la librería decide de que lado escribir y a que altura, y ésto en la librería está muy bien definido, pero no hace lo que debería.
Para colmo las librerias que no están en el paquete no son compatibles totalmente con estas y no podes mezclar nada porque directamente no te compila, aunque tengan todas las mismas bases, están renombradas para diferenciarlas y hasta encontré un sitio en donde ellos mismos dicen que tienen algunos problemas no resueltos todavía con el compilador (justamente hablando del tema del glcd)
Es probable que :
1) o estoy haciendo algo mal, que ni siquiera funcionan los ejemplos.
2) que la forma de direccionar no sea la correcta para este display en particular.
3) que las librerías no me entiendan (o al revez :jeje:)
Una de las cosas que me llama la atención de la librería que encontraste es que no tenga la tabla con todos los caracteres de escritura, será cuestión de probarla, despues te cuento.
Hola David!
El contraste trabaja con con tensión negativa según tengo entendido, por lo tanto, por la entrada Vo tendrías una variación de 0 a -5v o lo que salga por Vee
Espero que haya resistido los 5v+ que le mandaste, medio como que me asusta........
Anda :\ Se encendieron todos los puntos del GLCD.
Se salvó porque jamás los dejo mucho tiempo cuando no anda de una. Es una prevención que tomo y que estoy acostumbrado hacer. Si no anda de una, apago todo.
Ahora a empezar a trabajar en ella.
Uffff, menos mal!! :\ :\
El Dr. Frankenstein decìa: -Està vivo, viiiivoooo- jajajajaja
jajajajajaja
Consulta, por casualidad ¿tenés el protocolo de comunicación del controlador KS0108?
Así no me gasto en entender esas librerías que no sabemos si andan y me pongo hacer una yo, paso a paso.
Si , lo encontrè y me lo puse a descifrar antes de salir de vacaciones, es justamente lo que tengo en borrador pero en la compu de la fàbrica, acà tengo una copia hecha a mano del original, la escaneo y la pego en un rato.
Acà estàn los comandos para el glcd:
Fijate la columna RS es lo mismo que D/I = Dato/Instruccion
Gracias. :\
Bueno, ahí lo estuve estudiando un poco, más lo que leí por toda la red, no parece ser complicado de usar.
El controlador, tiene una matriz en la RAM con la misma cantidad de pixeles. Esto está dividido en dos columnas. Cada columna tiene un ancho de 64 bit que se controla con un contador. Este contador se manipula el registro de dirección.
Cada fila, tiene un ancho de 8 bit, que son las entradas del LCD. Esto quiere decir que los datos se ingresan en forma vertical y no horizontal ¿es verdad esto?
Finalmente, para manejarnos por las páginas del 0 al 7; tenemos el registro Página.
Me olvidaba; para seleccionar las que columna se trabaja; se selecciona con los pines CS1 y CS2.
Lo que me resta saber, es si hay una configuración previa como los LCD comunes; en donde se configura si se trabaja con 8 o 4 bit; con cursor o sin cursor; si el texto se desplaza o no; etc. Por lo visto no, y hago la conclusión que solo habría que indicar que se debe encender el LCD y empezar a mandarle la información a mostrar.
Bueno, trataré de mañana empezar a escribir una librería al respecto.
Hola!
Para comenzar a utilizar los comandos hay que tener en cuenta lo siguiente:
Los pines del Pic que seleccionemos para comunicarnos deberían tener los siguientes valores:
Glcd encendido=
D/I = 0 - le decimos al glcd que va una instrucción.
R/W = 0
Puerto de datos = 00111111 = 0x3F
*****************************************
Glcd apagado=
D/I = 0 - le decimos al glcd que va una instrucción.
R/W = 0
Puerto de datos = 00111110 = 0x3E
*****************************************
Setear dirección Y=
D/I = 0 - le decimos al glcd que va una instrucción.
R/W = 0
Puerto de datos = 01xxxxxx
[0 a 63]
Sumar 64 al valor Y necesario para colocar el valor correcto en el puerto ej.:
Se quiere dar a Y la posición 12
12 = 00001100 = 0x0C
+ 64 = 01000000 = 0x40
___
76 = 01001100 = 0x4C
Entonces para la dirección Y 12 en el puerto deberíamos poner 01001100
********************************************************
Setear página (0 a 7) En función de la posición x (posición horizontal)=
D/I = 0 - le decimos al glcd que va una instrucción.
R/W = 0
Puerto de datos = 10111xxx
[0 a 7]
Sumar 184 al valor x necesario para colocar el valor correcto en el puerto
De esta forma dividimos la pantalla en 8 franjas horizontales según valor de los tres bits mas bajos.
*********************************************************************
Setear línea de inicio del display
D/I = 0 - le decimos al glcd que va una instrucción.
R/W = 0
Puerto de datos = 11xxxxxx
[0 a 63]
Sumar 192 al valor x necesario para colocar el valor correcto en el puerto
**********************************************************
Escribir dato en display
D/I = 1 - le decimos al glcd que va un dato.
R/W = 0
Puerto de datos = xxxxxxxx
Ahora si en el puerto de datos ponemos el valor completo de 8 bits.
Despues de la instrucción de escritura la dirección "Y" se incrementa automáticamente en 1
********************************************************
Para cualquier instruccion que seleccionemos, deberíamos completarla con:
Seleccion de mitad de pantalla a usar =
Lado Izquierdo
CS1 = 1
CS2 = 0
Lado Derecho
CS1 = 0
CS2 = 1
****************
Pulso de Habilitación
E = 1
Tiempo de toma de datos (por lo menos cuatro ciclos de máquina)
E = 0
(Este parámetro hay que estudiarlo bien porque no lo encontré definido por el fabricante, ya que él asume que se debería Leer el status del display para saber si se liberó de su tarea y puede recibir más información.)
Esto lleva a más código y tiempo de ejecución, por eso simplemente le damos un tiempo prudencial para que resuelva su tarea.
En ningún lado vi la posibilidád de usar solo 4 bits de datos
Lo del cursor me parece que lo tendremos que resolver por código, igual que el desplazamiento
La escritura se realiza en cada página y en forma vertical
El dibujo se realiza pixel por pixel o punto por punto en cualquier sector de la pantalla
Por favor si estoy errado en algo corrijanme.
Perfecto, es lo que pensaba.
A la tarde, intentaré darle vida. Ahora me tengo que poner a estudiar.
Al momento, estoy escribiendo un pequeño programa si librerías. Estoy haciendo todo. Pero estoy con una duda. No entiendo que se controla con la línea.
Las columnas, se selecciona con CS1 y CS2. Las páginas, se controlan con el registro PÁGINAS.
Ahora bien, cada página, tiene su columna, que se selecciona con el puntero controlador. Si los valores se agregan en forma vertical, para que son las líneas?
En el adjunto marca así una página:
d0
d1
d2
d3
d4
d5
d6
d7
Si hago una pequeña matrix de 0 a 5, es así:
/ c0 c1 c2 c3 c4 c5
d0 aa bb cc dd ee ff
d1 ab bc cd de ef fg
d2 ac bd ce df eg fh
d3 ad be cf dg eh fi
d4 ae bf cg dh ei fj
d5 af bg ch di ej fk
d6 ag bh ci dj ek fl
d7 ah bi cj dk el fm
Y quiero encender el pixcel aa; debo configurar columna 1 con CS1 = 1 y CS2 = 0. Seleccionar el contador D/I = 0 y R/W = 0 portd = 0x40 (contador = 0) Seleccionar la página 0 colocando D/I = 0 y R/W = 0, y enviar por el puerto D (en mi caso, que está conectado a la entrada de datos del GLCD) portd = 0b10111000
Luego debería configurar la línea ¿? ???
Entonces, una vez echo esto, coloco los pines D/I = 1 R/W = 0 portd = 0b00000001 y habilito al LCD E = 1 lo dejo por 1000 ms (por dar un tiempo prudente) y luego coloco E = 0
Ahora bien, si yo quiero encender los pixceles aa; ac; ae; ag; hago todo lo mismo pero por el puerto d, en vez de mandar 0x01, envío portd = 0xAA.
Para dejarlo en claro, supongamos que deseamos encender solo el pixcel di (c3,d5); lo que tengo que hacer es:
-- Seleccionamos Columna 1
CS1 = 1
CS2 = 0
D/I = 0 -- Seleccionamos contador 3
R/W = 0
portd = 0x43
E = 1
delay_100ms(10)
E = 0
D/I = 0 -- Seleccionamos página 0
R/W = 0
portd = 0xB8
E = 1
delay_100(10)
E = 0
-- Encendemos el pixcel deseado
D/I = 1
R/W = 0
portd = 0x40 -- d6 = 1, el resto = 0
E = 1
delay_100ms(10)
E = 0
Fijate si esto puede ayudar:
A ver.. yo lo entiendo de esta manera:
CS1 maneja 64 columnas y 64 filas (las primeras de la izquierda)
CS2 maneja la misma cantidàd pero de la derecha.
Seleccionando CS1 no elijo una columna, elijo trabajar con las primeras 64
Del mismo modo, tampoco elijo una sola fila, elijo las 64 de la izquierda.
Ahora bien, si al eje vertical lo llamamos columna, le adjudicamos el prefijo "y"
Si al eje horizontal lo llamamos fila, le adjudicamos el prefijo "x"
Al elegir una pàgina, tenemos 8 posiciones "x" y tambien tenemos 64 posiciones "y"
De acuerdo a èsto, aunque seleccionemos CS1 y Pàgina, todavìa nos faltarìa definir dentro de la pàgina, las coordenadas x e y.
Lo siguiente que analizo es que tengo dos comandos o instrucciones que me permiten manejar independientemente 64 posiciones.
La direcciòn "y" ya la tenemos definida porque es la que maneja el contador de direcciones, y es el que se incrementa automàticamente.
Por lo tanto, podrìamos deducir que lo que se llama lìnea de salida, bien podrìa ser el valor que nos falta para la direcciòn "x" (que justamente maneja 64 posiciones)
Si tenemos en cuenta que el contador maneja y, lo de lìnea de salida lo podrìamos interpretar como: linea = horizontal = x, y salida como ùltimo dato para que se active el pixel (un poco de imaginaciòn me lo tengo que permitir jejeje)
¿Se entendiò mi razonamiento, puede ser que tenga lògica?
No olvidemos que antes de cargar los valores de direcciòn tenemos que encender el display y poner a cero todas las direcciones, o sea inicializar el display.
Tal vez el pdf que adjunto les de una ayuda en esto.
Saludos
HJ
Cita de: HJ en Abril 25, 2012, 10:49:14 PM
Tal vez el pdf que adjunto les de una ayuda en esto.
Saludos
HJ
Me refiero a los diagramas de flujo para trabajar con este tipo de GLCD
Gracias HJ.
Lo bajé y lo estoy analizando. Por lo que vi, muy por encima, los registros son iguales.
YO: Entiendo lo que decís, pero se contrapone a como se toman los datos del puerto de datos del GLCD. Ahí está el porqué no logro entender el registro línea.
Tomamos una página cualquiera, por ejemplo la 6; y tomamos los primero 64 bit de largo, por ejemplo CS1 =1 y CS2 = 0
En esta página, (y en las demás también) el alto es de 8 bit ¿verdad?; son los que corresponde a los 8 bit de entrada de datos del GLCD. O sea, de la descripción de los pines que subiste son:
7 = DB0
8 = DB1
9 = DB2
10 = DB3
11 = DB4
12 = DB5
13 = DB6
14 = DB7
Lo que acabo de decir, ¿es verdad? Si lo que digo es verdad, quiere decir que la información entra en forma vertical y no horizontal. La única manera de que entienda del registro línea, es que los 8 bit de ancho de cada página NO sea los datos de entrada, y que la información se introduzca en forma horizontal
La primera prueba que hice, no lo logré hacer andar. Una vez que lo haga, entenderé como se encienden los pixceles. Como no logro encontrar el protocolo de comunicación; no sabía como inicializar al GLCD.
Gracias HJ
David
Entiendo y estoy de acuerdo en que para escribir dentro de una página, se haga en forma vertical.
Eso está muy claro.
Lo que pienso es que debe existir otra forma de direccionamiento más directo, sin necesidád de seleccionar una página.
Y creo que por allí va el tema de la línea.
En una página, El contador avanza verticalmente, y esto para la escritura está perfecto, entonces pienso que si tengo que hacer un dibujo con una tabla de datos ¿tengo que cambiar permanentemente de página o el contador se desborda y salta solo a la página siguiente?
Esto lo sabremos seguramente a medida que avancemos.
Lo que me imagino es que usando el direccionamiento x,y sin usar una página determinada, con el solo hecho de indicarle al display la cordenada del punto que queremos usar, éste se debería encender automáticamente sin ningún dato, pues elegimos un solo punto, y esto quizás simplificaría el programa del dibujo.
Seguramente estoy completamente equivocado y (no me asombra) pues son solo suposiciones, ya que como decís no contamos con el protocolo de comunicación. yo creía que lo tenía pero es solo lo que publique, no encontré nada en muchas horas de búsqueda, es más se me ocurrió que se le podría pedir a Winstar directamente pero necesito un traductor chino o ingles para mi es lo mismo jejeje
Ok.
Eso se me suena muy lógico si es solo para encender un pixcel único.
Le voy a mandar un mensaje a ver que me dicen.
Bien ojalá respondan!
Me olvidaba de algo inportante:
¿tenes conectado el pin de reset a algun lado? deberia ir directo a +5v. para probarlo.
Si lo manejas por el micro entonces una salida baja resetea el glcd
Si, me aseguré de ponerlo a 5V desde un pin del pic.
Lo que pasa, es que no lo había inicializado.
Husmeando por la páginas de ellos, encontré esto. Un programa en ASM para trabajar con el GLCD. (http://www.winstar.com.tw/UserFiles/downloads/120107783101065865564.asm) Esto, más el diagrama de flujo que nos brindó HJ, tenemos que sacarlo andando.
No lo puedo hacer andar, ni con el ejemplo que trae JALv2 &%$#
YO, ¿Cuál fue el programa que utilizaste y que al menos, te mostró algo?
Hola David met!
Aca te paso el programa que armè con instrucciones que vi por todos lados en la red y analizando las librerias de control.
Disculpà el desorden del còdigo, pero a medida que lo probaba le agregaba, le sacaba o anulaba lìneas.
Sirve para ver algo en la pantalla y analizar funcionamiento, nada màs.
Al conectarlo, el programa tarda como 15 segundos en hacer algo, no te asustes, no lo desenchufes enseguida, yo hacìa eso y no me daba cuenta que lo ùnico que pasaba era que lo ùnico que andaba en la primera etapa eran los retardos, el resto nada, y despuès te saluda y despliega todo su poderìo :jeje:
-- GLCD prueba 2 (la uno falla) y esta tambien jeje!!
include 16f877a
pragma target clock 20_000_000
pragma target OSC hs
pragma target LVP disabled
pragma target WDT disabled
enable_digital_io()
-- declare a user-defined font >> declarar un tipo de letra definido por el usuario
-- it's a kind of sprite definition...es una especie de definición Objeto ...
-- Deben ser definidos antes glcd_font incluir
-- must be defined before glcd_font include
const byte FONT_UDF_0XFE = 0xFE
const byte FONT_UDF_0XFE_BYTE_PER_CHAR = 5
const byte FONT_UDF_0XFE_WIDTH = 5
const byte FONT_UDF_0XFE_HEIGHT = 8
const byte FONT_UDF_0XFE_BIT_DIRECTION = FONT_BOTTOM_LEFT_VERTICAL
const byte FONT_UDF_0XFE_CHARS [] = "A "
-- ***************************************************
-- Definimos los puertos relacionados con el GLCD (adaptalo al tuyo)
-- ***************************************************
var volatile byte GLCD_DATAPRT is portd
var volatile byte GLCD_DATAPRT_DIR is portd_direction
var volatile bit GLCD_RW is pin_b4
var volatile bit GLCD_CS1 is pin_b0
var volatile bit GLCD_E is pin_b5
var volatile bit GLCD_DI is pin_b2
var volatile bit GLCD_RST is pin_c0
var volatile bit GLCD_CS2 is pin_b1
var volatile bit GLCD_RW_DIRECTION is pin_b4_direction
var volatile bit GLCD_CS1_DIRECTION is pin_b0_direction
var volatile bit GLCD_E_DIRECTION is pin_b5_direction
var volatile bit GLCD_DI_DIRECTION is pin_b2_direction
var volatile bit GLCD_RST_DIRECTION is pin_c0_direction
var volatile bit GLCD_CS2_DIRECTION is pin_b1_direction
-- ****************************************************
-- Incluimos las librerias que usaremos
-- ****************************************************
-- Using block write is fastest, but you can only use one font type:
-- FONT_TOP_LEFT_HORIZONTAL
--; const GLCD_USE_BLOCK_WRITE = FALSE
const FONT_AUTO_WRAP = false
include glcd_8x12_font
include glcd_5x7_font
include glcd_font
include print
include format
include delay
include glcd_ks0108 --
include glcd_common
-- Ahora inicializamos el glcd
glcd_init()
; lcd_setcursor(2,10)
forever loop
-- Set font size
; glcd_font_use(FONT_8X12)
-- print "X:" and "Y:" at bottom left
glcd_char_x_pos = 3
glcd_char_y_pos = 10
const byte string_x[] = "X: "
print_string(glcd,string_x)
delay_100ms(30)
lcd_fill(0) -- Clear the display
-- Definimos los textos
const byte str1[] = "Hola "
const byte str2[] = "Aca estoy"
var byte x
var byte y
var byte char
;LCD_GoToXY 7, 1
-- Ahora los vamos a colocar
glcd_char_y_pos = 20
glcd_char_x_pos = 20
print_string(glcd,str1)
glcd_char_y_pos = 10
glcd_char_x_pos = 40
print_string(glcd,str2)
delay_100ms(30)
lcd_fill(0) -- Clear the display
_ks0108_write(KS0108_LEFT ,80)
delay_100ms(80)
lcd_fill(0) -- Clear the display
;ks0108_LEFT
ks0108_write_char(67,10,72)
ks0108_write_char(73,10,79)
ks0108_write_char(79,10,76)
ks0108_write_char(85,10,65)
;delay_100ms(30)
;glcd_write_char(20,20)
;lcd_setcursor(2,10)
;glcd_char_goto(2,10)
lcd_fill(0) -- Clear the display
ks0108_write_char(3,10,72)
ks0108_write_char(9,10,79)
ks0108_write_char(15,10,76)
ks0108_write_char(21,10,65)
delay_100ms(30)
; lcd_fill(0) -- Clear the display
glcd_clear_screen()
;glcd_write_char(60, 10,65)
delay_100ms(30)
lcd_fill(0) -- Clear the display
glcd_box(0,0,127,63)
delay_100ms(30)
ks0108_write_byte(20,20,55)
glcd_char_y_pos = 50
glcd_char_x_pos = 100
print_string(glcd,str1)
delay_100ms(30)
lcd_fill(0) -- Clear the display
glcd_char_y_pos = 15
glcd_char_x_pos = 70
print_string(glcd,str1)
delay_100ms(30)
lcd_fill(0) -- Clear the display
glcd_char_y_pos = 20
glcd_char_x_pos = 20
;ks0108_write_byte(glcd,str1)
lcd_fill(0) -- Clear the display
-- print "X:" and "Y:" at bottom left
;glcd_char_x_pos = 20
;glcd_char_y_pos = 20
;const byte string_x[] = "X: "
;print_string(glcd,string_x)
delay_100ms(30)
lcd_fill(0) -- Clear the display
; glcd_clear_screen()
-- draw some font
const byte hello_string[] = "HelLo World "
--
glcd_font_use(FONT_5X7) -- set font size
print_string(glcd,hello_string) -- print characters to lcd
; var byte x,y,char
char=32
delay_100ms(5)
for 8 using y loop
for 25 using x loop
glcd_char_goto(y,x)
glcd = char
char = char + 1
if (char > 122) then char = 32 end if
end loop
end loop
end loop
Comentarios del programa:
Fijate que la ùnica forma de escribir "HOLA", fuè caracter por caracter segùn la tabla de la librerìa.
ks0108_write_char(3,10,72)
ks0108_write_char(9,10,79)
ks0108_write_char(15,10,76)
ks0108_write_char(21,10,65)
no lo pude escribir todo junto de una sola vez con print
glcd_char_y_pos = 20
glcd_char_x_pos = 20
print_string(glcd,str1)
Lo interesante fuè cuando probè con : glcd_clear_screen()
Te llena la pantalla punto por punto aumentando el contador automàticamente!
Lo contrario ocurre con : lcd_fill(0)
Te borra la pantalla de una
Esta instrucciòn funcionò de una pero no lo probè con otras coordenadas : glcd_box(0,0,127,63)
Esto que es original de Jal, tampoco funcionò, aunque no entiendo porque no lo direccionaron
-- draw some font
const byte hello_string[] = "HelLo World "
--
glcd_font_use(FONT_5X7) -- set font size
print_string(glcd,hello_string) -- print characters to lcd
Estas lìneas no fueron modificadas, no se le borrò nada pero ¿y donde lo ponen?
Probalo y contanos Abrazos
Excelente.
Ahora me voy a almorzar con la flia y a la vuelta, lo pruebo. Así tengo algo por donde empezar.
Excelente. Ahí anduvo.
Ahora a empezar a estudiarlo. :\
Vamos todavìa!!! :\ :\
Yo sigo probando sobre la misma base, a ver que logro!
David, probè el razonamiento que desarrollaste para el encendido del pixcel di (c3,d5) y funciona perfectamente con el encabezado del programa que te pasè :\ :\ :\ :\ :\ probà èsto:
include 16f877a
pragma target clock 20_000_000
pragma target OSC hs
pragma target LVP disabled
pragma target WDT disabled
enable_digital_io()
-- declare a user-defined font >> declarar un tipo de letra definido por el usuario
-- it's a kind of sprite definition...es una especie de definición Objeto ...
-- Deben ser definidos antes glcd_font incluir
-- must be defined before glcd_font include
const byte FONT_UDF_0XFE = 0xFE
const byte FONT_UDF_0XFE_BYTE_PER_CHAR = 5
const byte FONT_UDF_0XFE_WIDTH = 5
const byte FONT_UDF_0XFE_HEIGHT = 8
const byte FONT_UDF_0XFE_BIT_DIRECTION = FONT_BOTTOM_LEFT_VERTICAL
const byte FONT_UDF_0XFE_CHARS [] = "A "
const FONT_AUTO_WRAP = false
include glcd_8x12_font
include glcd_5x7_font
include glcd_font
-- ***************************************************
-- Definimos los puertos relacionados con el GLCD
-- ***************************************************
var volatile byte GLCD_DATAPRT is portd
var volatile byte GLCD_DATAPRT_DIR is portd_direction
var volatile bit GLCD_RW is pin_b4
var volatile bit GLCD_CS1 is pin_b0
var volatile bit GLCD_E is pin_b5
var volatile bit GLCD_DI is pin_b2
var volatile bit GLCD_RST is pin_c0
var volatile bit GLCD_CS2 is pin_b1
var volatile bit GLCD_RW_DIRECTION is pin_b4_direction
var volatile bit GLCD_CS1_DIRECTION is pin_b0_direction
var volatile bit GLCD_E_DIRECTION is pin_b5_direction
var volatile bit GLCD_DI_DIRECTION is pin_b2_direction
var volatile bit GLCD_RST_DIRECTION is pin_c0_direction
var volatile bit GLCD_CS2_DIRECTION is pin_b1_direction
-- ****************************************************
-- Incluimos las librerias que usaremos
-- ****************************************************
-- Using block write is fastest, but you can only use one font type:
-- FONT_TOP_LEFT_HORIZONTAL
--; const GLCD_USE_BLOCK_WRITE = FALSE
include print
include format
include delay
include glcd_ks0108
include glcd_common
-- Ahora inicializamos el glcd
glcd_init()
-- Y ponemos el puntito de David
forever loop
lcd_fill(0) -- Clear the display
GLCD_CS1 = 1
GLCD_CS2 = 0
GLCD_DI = 0 -- Seleccionamos contador 3
GLCD_RW = 0
GLCD_DATAPRT = 0x43
GLCD_E = 1
delay_100ms(2)
GLCD_E = 0
GLCD_DI = 0 -- Seleccionamos página 0
GLCD_RW = 0
GLCD_DATAPRT = 0xB8
GLCD_E = 1
delay_100ms(2)
GLCD_E = 0
-- Encendemos el pixcel deseado
GLCD_DI = 1
GLCD_RW = 0
GLCD_DATAPRT = 0x40 -- d6 = 1, el resto = 0
GLCD_E = 1
delay_100ms(2)
GLCD_E = 0
delay_100ms(30)
GLCD_CS1 = 0
GLCD_CS2 = 1
GLCD_DI = 0 -- Seleccionamos contador 3
GLCD_RW = 0
GLCD_DATAPRT = 0x43
GLCD_E = 1
delay_100ms(2)
GLCD_E = 0
GLCD_DI = 0 -- Seleccionamos página 0
GLCD_RW = 0
GLCD_DATAPRT = 0xB8
GLCD_E = 1
delay_100ms(2)
GLCD_E = 0
-- Encendemos el pixcel deseado
GLCD_DI = 1
GLCD_RW = 0
GLCD_DATAPRT = 0x40 --
GLCD_E = 1
delay_100ms(2)
GLCD_E = 0
delay_100ms(30)
end loop
Al fin me hace caso a lo que le pongo :\ :\ :\
Un ejemplo simple para probar el contador de direcciones:
-- **************************************
-- Dibujamos una lìnea de 8 bit
-- **************************************
for 5 loop
GLCD_CS1 = 0
GLCD_CS2 = 1
GLCD_DI = 0 -- Seleccionamos contador 3
GLCD_RW = 0
GLCD_DATAPRT = 0x43
GLCD_E = 1
delay_100ms(1)
GLCD_E = 0
GLCD_DI = 0 -- Seleccionamos página 0
GLCD_RW = 0
GLCD_DATAPRT = 0xB8
GLCD_E = 1
delay_100ms(1)
GLCD_E = 0
-- Encendemos el pixcel deseado
GLCD_DI = 1
GLCD_RW = 0
GLCD_DATAPRT = 0xff --
GLCD_E = 1
delay_100ms(1)
GLCD_E = 0
-- **********************************
-- Dibujamos una lìnea en crecimiento
-- **********************************
-- En la direcciòn que dimos, para ver como funciona el contador
-- de direcciones
-- Solo enviaremos datos
-- Encendemos el pixcel deseado
GLCD_DI = 1
GLCD_RW = 0
GLCD_DATAPRT = 0x01 --
GLCD_E = 1
delay_100ms(1)
GLCD_E = 0
delay_100ms(3)
GLCD_DI = 1
GLCD_RW = 0
GLCD_DATAPRT = 0x03 --
GLCD_E = 1
delay_100ms(1)
GLCD_E = 0
delay_100ms(3)
GLCD_DI = 1
GLCD_RW = 0
GLCD_DATAPRT = 0x07 --
GLCD_E = 1
delay_100ms(1)
GLCD_E = 0
delay_100ms(3)
GLCD_DI = 1
GLCD_RW = 0
GLCD_DATAPRT = 0x0f --
GLCD_E = 1
delay_100ms(1)
GLCD_E = 0
delay_100ms(3)
GLCD_DI = 1
GLCD_RW = 0
GLCD_DATAPRT = 0x1f --
GLCD_E = 1
delay_100ms(1)
GLCD_E = 0
delay_100ms(3)
GLCD_DI = 1
GLCD_RW = 0
GLCD_DATAPRT = 0x3f --
GLCD_E = 1
delay_100ms(1)
GLCD_E = 0
delay_100ms(3)
GLCD_DI = 1
GLCD_RW = 0
GLCD_DATAPRT = 0x7f --
GLCD_E = 1
delay_100ms(1)
GLCD_E = 0
delay_100ms(3)
GLCD_DI = 1
GLCD_RW = 0
GLCD_DATAPRT = 0xff --
GLCD_E = 1
delay_100ms(1)
GLCD_E = 0
lcd_fill(0) -- Borramos la pantalla
end loop
El efecto de èsto es similar al del medidor de señal del celular
Le bajè el tiempo de toma de datos y hasta acà no hay problema. :D
Si hacemos un procedimiento para enviar datos, achicamos còdigo y lo podemos usar en la librerìa.
Yo estuve, hasta recién, jugando con el GLCD.
Mirá lo que hice (vas a tener que compilarlo, o subir deirectamente el hex al pic):
include 16f877a
pragma target clock 20_000_000
pragma target OSC hs
pragma target LVP disabled
pragma target WDT disabled
enable_digital_io()
-- ***************************************************
-- Definimos los puertos relacionados con el GLCD (adaptalo al tuyo)
-- ***************************************************
var volatile byte GLCD_DATAPRT is portd
var volatile byte GLCD_DATAPRT_DIR is portd_direction
var volatile bit GLCD_RW is pin_b4
var volatile bit GLCD_CS1 is pin_b0
var volatile bit GLCD_E is pin_b5
var volatile bit GLCD_DI is pin_b2
var volatile bit GLCD_RST is pin_c0
var volatile bit GLCD_CS2 is pin_b1
var volatile bit GLCD_RW_DIRECTION is pin_b4_direction
var volatile bit GLCD_CS1_DIRECTION is pin_b0_direction
var volatile bit GLCD_E_DIRECTION is pin_b5_direction
var volatile bit GLCD_DI_DIRECTION is pin_b2_direction
var volatile bit GLCD_RST_DIRECTION is pin_c0_direction
var volatile bit GLCD_CS2_DIRECTION is pin_b1_direction
-- Incluimos las librerías --
include delay
include glcd_ks0108 --
-- Ahora inicializamos el glcd --
glcd_init()
-- Borramos la pantalla --
lcd_fill(0) -- Clear the display
var byte x, y
-- Dibujamos MF en el GLCD --
-- Dibujamos una línea vertical desde 3 hasta 49 --
y = 3
for 46 loop
glcd_write_pixel(5,y)
y = y + 1
end loop
-- Dibujamos una línea horizontal desde 5 hasta 15 --
x = 5
for 10 loop
glcd_write_pixel(x,49)
x = x + 1
end loop
-- Dibujamos una línea vertical desde 49 hasta 22 --
y = 49
for 27 loop
glcd_write_pixel(15,y)
y = y - 1
end loop
-- Dibujamos una línea oblícua desde 15;22 hasta 23;30
x = 15
y = 22
for 9 loop
glcd_write_pixel(x,y)
x = x + 1
y = y + 1
end loop
-- Dibujamos una línea oblícua desde 23;30 hasta 31;22
x = 23
y = 30
for 9 loop
glcd_write_pixel(x,y)
x = x + 1
y = y - 1
end loop
-- Dibujamos una línea vertical desde 22 hasta 49 --
Y = 22
for 27 loop
glcd_write_pixel(31,y)
y = y + 1
end loop
-- Dibujamos una línea horizontal desde 31 hasta 41
x = 31
for 10 loop
glcd_write_pixel(x,49)
x = x + 1
end loop
-- Dibujamos una línea vertical desde 49 hasta 30
y = 49
for 19 loop
glcd_write_pixel(41,y)
y = y - 1
end loop
-- Dibujamos una línea horizontal desde 41 hasta 55
x = 41
for 14 loop
glcd_write_pixel(x,30)
x = x + 1
end loop
-- Dibujamos una línea vertical desde 30 hasta 20
y = 30
for 10 loop
glcd_write_pixel(55,y)
y = y - 1
end loop
-- Dibujamos una línea horizontal desde 55 hasta 41
x = 55
for 14 loop
glcd_write_pixel(x,20)
x = x - 1
end loop
-- Dibujamos una línea vetical desde 20 hasta 13
y = 20
for 7 loop
glcd_write_pixel(41,y)
y = y - 1
end loop
-- Dibujamos una línea horizontal desde 41 hasta 66
x = 41
for 25 loop
glcd_write_pixel(x,13)
x = x + 1
end loop
-- Dibujamos una línea vertical desde 13 hasta 3
y = 13
for 10 loop
glcd_write_pixel(66,y)
y = y - 1
end loop
-- Dibujamos una línea horizontal desde 66 hasta 31
x = 66
for 35 loop
glcd_write_pixel(x,3)
x = x - 1
end loop
-- Dibujamos una línea oblicua desde 31;3 hasta 23;11
x = 31
y = 3
for 8 loop
glcd_write_pixel(x,y)
x = x - 1
y = y + 1
end loop
-- Dibujamos una línea oblicua desde 23;11 hasta 15;3
x = 23
Y = 11
for 8 loop
glcd_write_pixel(x,y)
x = x - 1
y = y - 1
end loop
-- Dibujamos una línea horizontal desde 15 hasta 5
x = 15
for 10 loop
glcd_write_pixel(x,3)
x = x - 1
end loop
-- Escribimos GRACIAS YO POR EL GLCD desde 56;5
ks0108_write_char(5,56,71) -- G
ks0108_write_char(11,56,82) -- R
ks0108_write_char(17,56,65) -- A
ks0108_write_char(23,56,67) -- C
ks0108_write_char(29,56,73) -- I
ks0108_write_char(35,56,65) -- A
ks0108_write_char(41,56,83) -- S
ks0108_write_char(50,56,89) -- Y
ks0108_write_char(56,56,79) -- O
ks0108_write_char(65,56,80) -- P
ks0108_write_char(71,56,79) -- O
ks0108_write_char(77,56,82) -- R
ks0108_write_char(86,56,69) -- E
ks0108_write_char(92,56,76) -- L
ks0108_write_char(101,56,71) -- G
ks0108_write_char(107,56,76) -- L
ks0108_write_char(113,56,67) -- C
ks0108_write_char(119,56,68) -- D
forever loop
asm sleep
end loop
Adjuntado está el hex.
Muy lindo el último efecto.
Se me ocurrió abrir un hilo explicando procedimiento por procedimiento cada librería de JAL en un tema nuevo ¿Qué te parece?
Yo empezaría por la librería glcd_ks0108
Luego, podemos seguir por las otras.
Buenìsimo David, buenìiiiiisimo :\ :\ :\
El logo de Meteorologia Fàcil te quedò perfecto.
Es un "hola mundo" muy especial y te lo agradezco ok!
Me parece muy bien el hacer un hilo con la interpretaciòn de las librerìas.
Podrìamos hacer un comentario, seguido de algùn ejemplo simple, y ver si cumple las expectativas.
Estoy contento, estamos en carrera!!
Me alegro que te haya gustado.
Acá subo una foto para que lo puedan ver todos. Anoche terminé muy tarde y no hice a tiempo
(http://www.meteorologiafacil.com.ar/foros/index.php?action=dlattach;topic=711.0;attach=511)
Mañana abro el nuevo hilo, o si prefieres, hazlo tu. A este hilo lo dejamos para seguir resolviendo problemas y dudas. ¿Te parece?
Abrazos.
Listo, nuevo hilo abierto. (http://www.meteorologiafacil.com.ar/foros/index.php?topic=720.msg3461#msg3461)
En èste, como decìs, volcaremos las dudas e inquietudes que surjan.
Saludos
Editado para agregar la url del nuevo sitio.
David.
Hola a todos!
Estuve probando algunos gràficos, hice una pantalla con un logo, le dì un tiempo y quise mostrar otra imagen, hasta acà todo bien, pero cuando comencè a diseñar la segunda, se me complicò a poco de comenzar.
Como compilaba cada vez que terminaba una parte del dibujo, saltò un problema en la ùltima y el compilador mandò èsto :
Clean: Deleting intermediary and output files.
Clean: Done.
Executing: "C:\PIC\jalv2\compiler\jalv2.exe" GLCD_2.JAL -s "C:\PIC\jalv2\lib" -no-clear
jal 2.4o (compiled May 8 2011)
generating p-code
2686 tokens, 163619 chars; 4648 lines; 13 files
generating PIC code pass 1
generating PIC code pass 2
writing result
Code area: 8767 of 8192 used (words) <------<
GLCD_2.JAL:489: PIC image too big! <------<
Data area: 89 of 352 used
Software stack available: 96 bytes
Hardware stack depth 2 of 8
1 errors, 0 warnings
BUILD FAILED: Mon Apr 30 18:48:55 2012
Evidentemente èsta forma de dibujar con : ks0108_write_char, consume mucho espacio, tendremos que buscar otra.
Lo que no entiendo es porquè, si eliminè todas las librerìas que no usaba, siempre tenìa la misma cantidàd de còdigo, serà que las mete despuès.
Segùn el ICPROG todavìa tenìa medio Pic vacio.
Saludos
Ese procedimiento, está más dedicado a la escritura de caracteres, o al menos eso me da la sensación.
Yo creo que lo mejor, para dibujar, es el procedimiento glcd_write_pixel(x,y)
Perdòn, el procedimiento que utilicè para dibujar era : glcd_write_pixel , con ks0108_write_char, puse algunas letras, pero muy pocas y se me acabò el espacio.
Espero que me deje poner dibujos y datos como los de temperatura, humedad, presiòn, (los de mi central)
Si no entra todo en un programa, va a estar complicado, ya que pensaba hacer distintas pantallas con dibujos representativos, pero no llegue ni a la segunda. ???
Algo que aún no investigué, es si la pantalla de GLCD tiene memoria EEPROM o Flash disponible para el usuario. Si es así, se puede guardar los gráficos con un programa, y luego hacerlo ejecutar con el programa final. ¿Se entiende?
Winstar no te contestò ?
¡Que poca informaciòn para un producto tan especìfico!! ???
Si los chinos pusieran un super de electrònica en cada barrio, seguro que al pasar por la caja aparte de las pilas te dirìan ; "lleva catalogo, lleva catalogo" jajajajaja
Cita de: YO en Mayo 01, 2012, 11:20:41 AM
¡Que poca informaciòn para un producto tan especìfico!! ???
Es todo un tema, hay varias empresas, y no me preguntes por que, pero que la información "clasificada" solo se le entrega a determinados clientes, me ha pasado con la gente de SIMCom que fabrican los módulos celulares SIM900, también con los de fabricantes de los chip de grabación de audio ISD, el chip lo fabricaba ChipCom, despues Winbond y ahora lo hace Nuvoton, y la información pública se reduce a unas 10 hoyas, mientras que para los clientes son como 500...
Así que puede estar por alli el tema de la poca información que se encuentra sobre los display Winstar.
Hace unos años, quise reciclar unos de esos display al vacío que venían en algunas viejas máquinas sumadoras, tengo varios, todos marca FUTABA, y la información que logre reunir fue realmente escasa. Y los correos que les envié, sospecho que ni los leyeron.
Saludos
HJ
No, aún no me contestaron y sospecho que no lo harán.
Voy a dejar pasar un mes o dos, y les voy a mandar un e-mail diciéndole que les voy a comprar uno, pero que antes, necesito toda la información de los GLCD. Seguro que hasta me mandan un ejemplo de programa escrito en JAL ;D
Hola a todos.
YO o David, el que pueda, que suba una imagen de la parte de atrás del GLCD donde se puedan leer todas las etiquetas y leyendas del mismo, ya que por lo que leí, el 12864A de Winstar puede tener 3 controladores diferentes.
En la foto que David colocó al comienzo de este hilo el reflejo no me deja leer la etiqueta.
Saludos
HJ
Edito: No es por nada en particular, solo una curiosidad.
Hola HJ!
Esta noche, cuando llegue a casa me fijo.
Saludos!
Gracias YO, no es algo de apuro, solo curiosidad.
Sacandin foting ;D ;D ;D
Aquí está:
(http://www.meteorologiafacil.com.ar/foros/index.php?action=dlattach;topic=711.0;attach=515)
Les adelanto algo.
Parece ser que estos módulos pueden incluir diferentes controladores de un par de fabricantes.
1- el S6B1713 (KS1713) de Samsung para el WX12864A
2- la pareja de S6B0108 y S6B0107 (KS0108 y KS0107) también de Samsung para el WG12864A
3- la pareja de NT7107 y NT7108 de Neotec para el WG12864A
Las parejas de los puntos 2 y 3 aparentemente son totalmente compatibles.
Saludos
HJ
Gracias David, es el WG12864A, mas tarde buscaré algo específico en el foro de Winstar.
Saludos
HJ
Edito: Por si alguno anda con ganas.... se accede a las hojas de datos de los controladores por acá (http://www.winstar.com.tw/service_download.php?lang=es), y también está el acceso al Foro.
Si, y lo peor de todo, es la poca información que hay sobre estos controladores >:(
No logro cambiar el tamaño de la fuente del GLCD para poder usar las librerías glcd_8x12_font; etc. Hace más de 3 horas que analicé, probé y solucioné un montón de errores que me tiraba el jal. Pero aún así, no pude hacerlo andar. Este debe ser el motivo por el cual actualizaron la librería modificándola bastante.
Hice lo siguiente:
-- Incluimos las librerías --
include delay
include glcd_8x12_font
const bit GLCD_FONT_USAGE = true -- Hace incluir el procedimiento de la fuente externa de tipo de letra.
const byte _glcd_font_current_byte_per_char = 8 -- Indico el alto de la letra.
const byte glcd_font_lookup = FONT_8X12_CHARS[] -- Este me trajo dolores de cabeza (*)
include glcd_ks0108 --
(*) Tuve que deshacer esta línea y modificar la librería glcd_ks0108. Donde decía glcd_font_lookup la cambié por FONT_8X12_CHARS
para que jal invocara la tabla correcta. Además, se debe escribir el caracter con el procedimiento lcd_write_char().
Pero aún así, no hay forma de hacerlo andar correctamente y no logro encontrar el porqué. Se me hace que es un fallo de dicha librería.
Este es el programa que utilicé:
include 16f877a
pragma target clock 20_000_000
pragma target OSC hs
pragma target LVP disabled
pragma target WDT disabled
enable_digital_io()
-- ***************************************************
-- Definimos los puertos relacionados con el GLCD (adaptalo al tuyo)
-- ***************************************************
var volatile byte GLCD_DATAPRT is portd
var volatile byte GLCD_DATAPRT_DIR is portd_direction
var volatile bit GLCD_RW is pin_b4
var volatile bit GLCD_CS1 is pin_b0
var volatile bit GLCD_E is pin_b5
var volatile bit GLCD_DI is pin_b2
var volatile bit GLCD_RST is pin_c0
var volatile bit GLCD_CS2 is pin_b1
var volatile bit GLCD_RW_DIRECTION is pin_b4_direction
var volatile bit GLCD_CS1_DIRECTION is pin_b0_direction
var volatile bit GLCD_E_DIRECTION is pin_b5_direction
var volatile bit GLCD_DI_DIRECTION is pin_b2_direction
var volatile bit GLCD_RST_DIRECTION is pin_c0_direction
var volatile bit GLCD_CS2_DIRECTION is pin_b1_direction
-- Incluimos las librerías --
include delay
include glcd_8x12_font
const bit GLCD_FONT_USAGE = true
const byte _glcd_font_current_byte_per_char = 12
-- const word glcd_font_lookup = FONT_8X12_CHARS[]
include glcd_ks0108 --
-- Ahora inicializamos el glcd --
glcd_init()
-- Borramos la pantalla --
lcd_fill(0)
;
lcd_write_char(10,10,"P")
forever loop
asm sleep
end loop
Hola !
A mi me tira èsta falla:
generating p-code
C:\PIC\jalv2\lib/(1)glcd_ks0108.jal:464: "glcd_font_lookup" not defined
C:\PIC\jalv2\lib/(1)glcd_ks0108.jal:464: Too many parameters (0 expected, 1 found)
C:\PIC\jalv2\lib/glcd_font.jal:69: 'glcd_font_usage' previously defined
C:\PIC\jalv2\lib/glcd_font.jal:72: '_glcd_font_current_byte_per_char' previously defined
C:\PIC\jalv2\lib/glcd_font.jal:99: assign to constant
5 errors, 0 warnings
¿Te hace lo mismo?
No, me da otro error.
El lunes, si tengo tiempo, te copio y pego el error.
Aquí está el error que me da
GLCD1.jal:37: constant expression expected
C:\JALv2\lib/glcd_ks0108.jal:464: value missing
C:\JALv2\lib/glcd_ks0108.jal:464: 'end' expected (got ']')
C:\JALv2\lib/glcd_ks0108.jal:464: {FOR starts at C:\JALv2\lib/glcd_ks0108.jal:463}
C:\JALv2\lib/glcd_ks0108.jal:464: 'end' expected (got ']')
C:\JALv2\lib/glcd_ks0108.jal:464: {procedure starts at C:\JALv2\lib/glcd_ks0108.jal:452}
C:\JALv2\lib/glcd_ks0108.jal:464: 'end' expected (got ']')
C:\JALv2\lib/glcd_ks0108.jal:464: {IF starts at C:\JALv2\lib/glcd_ks0108.jal:449}
C:\JALv2\lib/glcd_ks0108.jal:464: unexpected token: "]"
9 errors, 0 warnings
Hay un error en la librería glcd_ks0108.jal y es justamente en dicha línea que me da error. Dicha línea está escrito:
cx = glcd_font_lookup(indx)
y el indx debe estar entre corchetes, así
cx = glcd_font_lookup[indx]
Si, està mal, en la librerìa Font 8x12 està asì ; const byte FONT_8X12_CHARS []
Raro que con el mìsmo còdigo, tire diferentes fallas
¿Viste? Es raro.
Yo voy a preparar una librería solo del GLCD en el que incluirá todo lo necesario. Diferentes tamaños de letras, para dibujar círculos, cuadrados; líneas; etc. Y para que el compilador solo incluya aquellos procedimientos y funciones que vamos a usar; le agregaré una directiva que se deberá habilitar por medio de una constante. Así ahorramos memoria en el PIC.
Al final, decidí seguir por la otra librería. La GLCD_COMMON.JAL
Es una librería que soporta GLCD a color.
Hay 4 procedimientos que no logro hacerlos andar y no estoy muy seguro de como funciona. Por eso no quiero mencionarlo en el hilo del glcd sin secretos.
Los procedimientos son:
glcd_write_char_pbp()
glcd_write_char_block()
glcd_put()
glcd_draw_image()
Hola a todos!!
Volví del viaje, hoy cuando llegue a casa voy a probar esta: glcd_draw_image().
Por lo poco que ví, si el display no es en colores, no se puede usar..., veremos
Saludos!
Si, es por eso que no lo puedo usar; pero intenté engañar a la librería y no pude.
Claro, en la librerìa lcd_ks0108 ya està declarado asì : const byte GLCD_COLOR_BITS = 1 -- black & white, monochrome.
Y en la glcd_common està discriminado de èsta manera :
elsif GLCD_COLOR_BITS == 1 then
-- not supported yet
end if ??? ??? >:( >:(
A eso, no lo vi eh?!
Hola
David: ¿intentaste poner algún valor del AD en el display?
Yo todavía no pude. ???
No, no lo he echo.
Me estoy rompiendo la cabeza para ver, como ahorrar memoria FLASH del PIC. Quiero hacer una pequeña animación y no me alcanza.
Pruebo con enviar datos obtenidos desde el A/D del PIC.
Tengo problemas a la hora de colocar las palabras o frases. No se ubican donde yo quiero.
Por ejemplo, si le doy las coordenadas x = 5 y = 7, las letras a escribir las corre con respecto a la coordena y. Lo más raro, es que si cambio y = 7 por y = 9, lo mueve como 4 puntos hacia abajo y no dos.
Sospecho que tengo un conflicto entre las librerías ks0108_glcd y glcd_common.
Estoy modificando completamente el programa, pero tengo un pequeño problema. El compilador deja de funcionar cuando está compilando.
¿Me pueden hacer el favor de compilar el siguiente programa? No se que es lo que está provocando que deje de funcionar el programa.
Gracias.
Hola David Met!
Cuando llegue a casa esta tarde lo pruebo!
Te comento que a mi me pasó lo mismo, después de borrar una buena parte del programa anterior, lo salvé y lo quise compilar, y se colgaba como buscando lo que faltaba.
Cerré el MPLab y volví a entrar y se solucionó todo.
En otra oportunidád, el sistema operativo me avisó que el compilador de Jal tenía un problema, y que debía cerrarse.
Viste que loco, a mi me pasó lo mismo con las palabras, yo pensé que estaba haciendo algo mal, y no sabía que.
Con los números ma pasó igual o peor, ya que ni siquiera aparecen....
Despues te cuento
Yo, hasta reinicié la PC.
Sospecho que el problema me lo dan las instruciones repeat until; pero me quiero asegurar.
Estoy pensando serieamente descargar la versión anterior.
Confirmado!! tu programa està engualichado.
Toda vez que intentè compilar, solo parpadeaba la barra de herramientas, le fuì eliminando partes para ver si, aunque con error, comenzaba a compilar y nada, siempre lo mismo.
Luego lo pegue sobre un proyecto ya compilado y me pasò lo mismo : nada!!
Lo màs curioso fuè cuando lo borrè y dejè lo que sì se podìa compilar, ni siquiera lo hacìa con mi base que antes funcionaba, o sea, lo que antes andaba dejò de funcionar.
Cerrè el MPLab, lo volvì a abrir, carguè nuevamente mi base, y volviò a funcionar.
Fuè como que se bloqueò todo cuando carguè tu programa eh?! :me callo:
A la miércoles. Hice un virus :me callo:
Jajajajajaja Se comporta igualito jajajajaja
Creo que la cosa pasa por la cantidád de loop que le haces dar, se marea y se pierde jajajajaja
Hablando en serio, ¿no hay un límite para la cantidad de loops?
Yo, sospecho lo mismo.
Un usuario de Ucontrol, me dijo que pruebe poniendo --;@main
Es raro, pero lo voy a probar.
Bueno, el --;@main no lo solucionó.
Voy a empezar a eliminar algunos for para ver que pasa.
Bien!!
Esto hay que tenerlo muy en cuenta por si vuelve a ocurrir ok!
Perdón YO. Justo cuando modifiqué mi respuesta, tu estabas respondiendo.
En realidad me equivoqué de programa a la hora de compilar :muerto! No funcionó.
Entonces Kaput!
No queda más remedio que mutilar el programa y ver donde salta la liebre.
Yo lo voy a intentar esta noche, a ver que encuentro
Ojo el virus sigue vivo jajajajaja
Hola David!
Hoy pude meterle mano a tu virus y ya encontrè el problema:
Fijate esto, mutilando el programa encontre que hasta acà, el resultado es bueno.
ks0108_write_char(29,y,"O")
ks0108_write_char(35,y,"R")
forever loop
asm sleep
end loop
Clean: Deleting intermediary and output files.
Clean: Deleted file "C:\PIC\jalv2\project\Pdavid.HEX".
Clean: Done.
Executing: "C:\PIC\jalv2\compiler\jalv2.exe" Pdavid.jal -no-clear
jal 2.4o (compiled May 8 2011)
generating p-code
2725 tokens, 95548 chars; 2634 lines; 5 files
generating PIC code pass 1
generating PIC code pass 2
writing result
Code area: 5879 of 8192 used (words) <-------<< Fijate acà
Data area: 54 of 352 used
Software stack available: 96 bytes
Hardware stack depth 2 of 8
0 errors, 0 warnings
Loaded C:\PIC\jalv2\project\Pdavid.HEX.
BUILD SUCCEEDED: Sat Jun 23 21:30:00 2012
Ahora vemos màs adelante:
ks0108_write_char(29,y,"O")
ks0108_write_char(35,y,"R")
ks0108_write_char(41,y,"O")
forever loop
asm sleep
end loop
Y el resultado es:
jal 2.4o (compiled May 8 2011)
generating p-code
2725 tokens, 95539 chars; 2625 lines; 5 files
generating PIC code pass 1
generating PIC code pass 2
writing result
Code area: 6044 of 8192 used (words) <<----------<< Estas alcanzando el màximo
Data area: 54 of 352 used
Software stack available: 96 bytes
Hardware stack depth 2 of 8
0 errors, 0 warnings
Y ahora.....
ks0108_write_char(35,y,"R")
ks0108_write_char(41,y,"O")
ks0108_write_char(47,y,"L")
forever loop
asm sleep
end loop
Pasa èsto:
Clean: Deleting intermediary and output files.
Clean: Deleted file "C:\PIC\jalv2\project\Pdavid.HEX".
Clean: Done.
Executing: "C:\PIC\jalv2\compiler\jalv2.exe" Pdavid.jal -no-clear
jal 2.4o (compiled May 8 2011)
generating p-code
2725 tokens, 95535 chars; 2621 lines; 5 files
generating PIC code pass 1
generating PIC code pass 2
BUILD SUCCEEDED: Sat Jun 23 21:39:08 2012
Se desbordò la capacidàd del compilador para leer el programa, o lo que serìa lo mismo: CARTON LLENO!
Esto ya me pasò queriendo dibujar ??? eh?! :me callo: :que mal!: :que mal!:
¿ Y ahora que hacemos, Jal queda chico ?
Abrazos!
noooooooooooooooooooooooooooooooo, me la quiero cortar.
La solución es deducible, sacar partes de programas que no se utilizan.
Yo ya estoy haciendo una propia librería, ya que sospecho que hay un error en dicha librería porque no me deja ubicar las cosas donde yo quiero. Voy a poner solo las cosas que voy a utilizar.
Ahora, ¿porqué en vez de bloquearse y cerrarse JALv2, no me tira error de desbordamiento de la memoria flash?
Bueno, es algo que notificaré a sus creadores.
Acabo de encontrar un posible error en la librería que estamos utilizando. La librería ks0108, calcula todo para ahorrarnos trabajo. Dependiendo de las coordenadas que queremos dibujar, la librería calcula a cual de los dos chip hay que escribirlo.
La pantalla del GLCD, está dividida en dos mitades de 64 bit cada uno (a lo ancho), a estos chips se los selecciona con CS1 o CS2. Cada chip maneja hasta 64 bit. Entonces ¿qué pasa cuando se selecciona la coordenada 128 del eje x? Pues la librería chequea esto, si supera de 64, quiere decir que se utiliza el chip CS2, y a continuación resta el valor de la coordenada en 64, para dejarlo en este rango. Por ejemplo, si seleccionamos 128 y le resta 64, nos queda 64 y corresponde al chip CS2. ¿Me siguen?
Para ello, utiliza una rutina o procedimiento, para hacer este cálculo, y calcula la columna con un OR. Esto hace un mal cálculo. Si hacemos 64 or 64 (que es especificada en una de las constante) nos da específicamente 64. Pero si por ejemplo deseamos escribir en la coordenada 70.
La librería hace: 70 - 64 = 6 --> Chips CS2
Luego hace 64 | 6 = 70
Como se dieron cuenta, se desborda.
Prometo ampliar más. Ahora tengo que estudiar para el miércoles y no me dedicaré, seguramente, hasta el jueves.
Vemos una luz al final :\
Estoy reescribiendo, casi por completo, la librería.
Al parecer, hay mucho más errores.
En poco tiempo, subiré las pruebas echas.
Hola amigos.
Les cuento que tengo, casi completa la librería que estoy haciendo para el GLCD. La re escribí por completo, con la ayuda que me brindó YO en el presente tema pero en la página 3 (http://www.meteorologiafacil.com.ar/foros/index.php?topic=711.msg3455#msg3455)
Coinciden muy pocas cosas de la librería que trae JAL, pero solo porque la use de guía para algunas cosas. No obstante, como dije en el párrafo anterior, la re escribí por completo.
Aún falta por terminar, pero quiero compartirla con ustedes para que la chequeen y me cuenten que se le puede mejorar y que se le puede agregar. A continuación indico lo que tengo en mente para agregarle:
- Fuente (solo 5x7)
- Corregir error al encender un pixel. En el presente, no se puede encender dos pixel uno debajo del otro porque borra uno (*)
- Lectura de un pixel
(*) Esto pasa, porque cuando se manda a escribir un pixel, se envía 8 datos (del d0 al d7) y estos están en vertical. Por ejemplo, si se desea encender el pixel 0 de la página 0, luego el pixel 1 de la misma página (misma columna x) el pixel 0 se apaga. Si no se entiende lo explico mejor (ahora me tengo que ir a cenar).
Bueno, está adjuntado.
NOTA IMPORTANTE, los nombres de los procedimientos y funciones están en castellano, por lo que no es compatible con el original de JAL. Por dos motivos, soy argentino y hablo español, y la segunda, porque para evitar lío con la librería original.
EDITO: Eliminado el archivo adjunto. Ver algunos mensajes más abajo.
Sigo dando vueltas con el tema de escribir un pixel. No logro que responda bien.
Para solucionar el problema del que borra el pixel escrito anterior (si están en la misma página y columna), se me ocurrió leer el estado de los pixeles en esa página, para luego aplicar un XOR en el pixel que deseo escribir.
Cuando escribo el primer pixel, el mismo se hace en forma correcta, pero a la hora de agregar el segundo pixel, no lo hace en forma correcta. Sospecho de un problema con la lectura del GLCD. Al parecer tiene auto-incremento; pero a pesar de que vuelvo hacer el ajuste de las coordenadas, el procedimiento no funciona bien.
Voy a tener que ver como lo hace otros lenguajes.
Hola Amigos!!!, ¿como estàn?
Que lo tirò!!! la estàs haciendo nomàs!!! :\
David, creo que te estàs rompiendo la cabeza con algo que quizàs no se use.
Analizando el tema del borrado del pixel anterior, creo que si la ùnica forma de decirle al glcd ; poneme un punto acà y otro màs abajo dentro de la misma pàgina, es con una palabra de 8 bits, directamente indicale donde poner el segundo punto, o los que quieras, justamente de una sola vez en esa palabra.
No veo la aplicaciòn que podrìa tener reescribir un pixel bajo el otro en forma inmediata y de a uno a la vez dudo: En todo caso, si esto fuera muy necesario, dudo: La librerìa tendrìa que tener la opciòn de incremento de pixels en el lugar ya escrito, leer esa posiciòn, compararla con el dato actual y agregarle el que le quieras poner.
Todo èsto, asume lìneas de programa que ocuparìan espacio al cuete si no se usa.
Si se quiere poner una letra o un nùmero, se activan todos los pixels que corresponden a la primera columna, luego a la segunda, y asì hasta la 5ta. pero todos a la vez, es decir los ocho de esa coordenada porque ya hay un mapa para ello.
Si querès dibujar, haces lo mismo, de a ocho a la vez, e incrementas o cambias la direcciòn, no podes cambiar eso, por màs que quieras, si podès modificar la palabra, pero siempre de a ocho y viendo si lo que tenìas escrito antes, debe cambiar o no.
Tal vez tengas algùn motivo especial que no conozco para querer hacer èsto. Pero ¿Tiene sentido pràctico ùtil? dudo: dudo: dudo:
Ahora que recuerdo, el glcd tiene incremento automàtico por lo menos en el eje X, dentro de la pàgina, y cuando èsta se desborda, pasa a la pàgina siguiente, èsto se podrìa aprovechar para no tener que escribir la direcciòn inmediata, eliminando lìneas de programa.
Un abrazo!
El problema pasa por lo siguiente. La siguiente instrucción, no la hace correctamente:
escribir_pixel(0,0)
escribir_pixel(0.1)
Cuando enciende el segundo pixel, me apaga el primero.
Se que es mejor hacer encender de a 8 pixel, y esto se implementa con escribir_byte(x,y,dato); pero si por x motivos, hay que apagar un pixel, o encender otro; ejecutar el procedimiento escribir_pixel, borrará o encenderá algunos pixeles que se desean mantenerlos intactos.
Es por ello, que se me ocurrió leer el estado de la página a modificar, y actualizar el valor de dicha página, pero no logro hacerlo en forma correcta. Este método, no es novedoso, ya que estudiando la librería que trae JAL, trabaja de esta manera.
Me juego la cabeza de que tengo dos problemas, estoy haciendo mal el procedimiento para leer el estado de una página y en la ejecución de escribir un pixel.
No obstante, me gustó mucho tu idea, que el procedimiento escribir_pixel, llame al procedimiento escribir_byte y trabajar de esta forma. Veré si el lunes, puedo implementarlo (mañana domingo, no me parece que tenga tiempo).
Estuve probando la librerìa y tengo una duda:
El valor de la lectura del glcd ¿queda en lectura_glcd?, porque si es asì el compilador no lo sabe :jeje:
Tratè de poner el pixel, luego leerlo y cambiarlo de lugar, pero me parece que algo interpreto mal :
glcd_ini()
var byte leido
escribir_pixel(10,10) -- Esto funciona
lectura_byte(10,10)
leido = lectura_glcd
escribir_byte(10,20,leido)
asm sleep
Y resulta esto:
Prueba_libreria_David.jal:282: warning: return value ignored
Prueba_libreria_David.jal:284: "lectura_glcd" not defined
Prueba_libreria_David.jal:284: '=' expected (got 'escribir_byte')
2 errors, 1 warnings
lectura_byte, es una función, y por lo tanto, debes llamarlo así:
leido = lectura_byte(10,10)
Bueno, ahora anda. :\ :\
Me había olvidado de poner a cero los pines CS1 y CS2 :P
Ahí está adjuntado para el que lo quiera probar.
En otra librería voy a colocar la fuente para que no ocupen espacio si nadie la utiliza.
Al igual que voy hacer otra librería para hacer rectángulos, círculos, elipses, etc.
Al final, todo este lío vino porque el GLCD escribía donde se le cantaba y no donde yo quería. Ahora que estuve haciendo mi librería propia, descubrí el porqué.
Esto ocurre, porque la librería analiza la página a escribir y en esa trabaja. Por lo tanto, cuando dibujamos un rectángulo, o escribimos, solo lo hace por página, es decir, que solo disponemos de 8 renglones para escribir, dibujar, etc. Esto es así, porque se ahorra mucha memoria flash del PIC. Si se quiere trabajar en forma independiente a las páginas, consumiría mucha memoria.
Así que, a moldearse en los 8 renglones disponibles.
Pero debo confesar que estoy agradecido haberlo descubierto ahora, porque aprendí como usar un GLCD. Como ven, no hay mal que por bien no venga.
Bien David!!!
En cuanto pueda la pruebo, ultimamente ando con los tiempos limitadisimos, pero en cuanto termine de montar las màquinas que estoy instalando, me re prendo.
Saludos a todos!!!
Hola!!
Ya probè el encender y apagar el pixel en forma individual con èste simple programa y cumple con el objetivo perfectamente.
forever loop
escribir_pixel(10,10)
escribir_pixel(11,11)
escribir_pixel(12,12)
escribir_pixel(15,0)
escribir_pixel(15,1)
escribir_pixel(15,2)
escribir_pixel(1,12)
escribir_pixel(1,13)
escribir_pixel(1,14)
delay_100ms(30)
escribir_pixel(11,11)
escribir_pixel(15,1)
escribir_pixel(1,13)
delay_100ms(30)
end loop
De diez :\ ok!
Excelente.
Ahora he modificado esa librería que utilizaste, y le he sacado la opción de alternar en el procedimiento de encender_pixel. Le agregué una entrada más para especificar si se quiere encender o apagar el pixel. Me vi obligado a esto porque estoy re-adaptando la librería glcd_common a la librería que hice.
Confieso que me gusta más ahora, porque si por accidente se sobre escribía un pixel, este se apagaba y encontrar el error podía ser un dolor de cabeza.
Logré hacer andar el círculo, pero no la elipse. Irónicamente para hacer un círculo, se hace con la elipse, pero a la hora de hacer una elipse, le falta encender 8 pixeles.
Más tarde, explico mejor el problema que tengo (ahora me tengo que ir hacer las compras).
Tengo algo curioso a la hora de compilar la librería que estoy adaptando. JAL me da la siguiente advertencia (warning) cuando compilo:
CitarC:\JALv2\lib/glcd_figuras.jal:77: warning: signed/unsigned mismatch
C:\JALv2\lib/glcd_figuras.jal:77: warning: signed/unsigned mismatch
Y la linea 77 corresponde a: var sbyte*2 cx14 = cx + dx, cx23 = cx - dx
procedure _glcd_escribir_4_pixeles_elipse(byte in cx, sbyte in dx, byte in cy, sbyte in dy, bit in enc_apa) is
var sbyte*2 cx14 = cx + dx, cx23 = cx - dx
var sbyte*2 cy12 = sbyte(cy) + dy, cy34 = sbyte(cy) - dy
escribir_pixel(byte(cx14), byte(cy12), enc_apa)
escribir_pixel(byte(cx14), byte(cy34), enc_apa)
escribir_pixel(byte(cx23), byte(cy12), enc_apa)
escribir_pixel(byte(cx23), byte(cy34), enc_apa)
end procedureLa linea var sbyte*2 cy12 = sbyte(cy) + dy, cy34 = sbyte(cy) - dy ; le especifiqué sbyte para que deje de dar advertencia.
Pero miren como está en la librería glcd_common:
Citarprocedure _glcd_write_4_ellipse_pixels( byte*GLCD_X_SIZE in cx,
sbyte*(GLCD_X_SIZE + 1) in dx,
byte*GLCD_Y_SIZE in cy,
sbyte*(GLCD_Y_SIZE + 1) in dy) is
var sbyte*(GLCD_X_SIZE + 1) cx14 = cx + dx, -- x-coord quadrant 1 and 4
cx23 = cx - dx -- " " 2 and 3
var sbyte*(GLCD_Y_SIZE + 1) cy12 = cy + dy, -- y-coord " 1 and 2
cy34 = cy - dy -- " " 3 and 4
Y probé esta librería y no me da advertencia. (GLCD_X_SIZE, en mi caso, vale 1; por eso yo puse sbyte*2).
En fin, si me ayudan a entenderlo, se los voy a agradecer.
Cita de: David Met en Julio 24, 2012, 06:35:01 PM
Y probé esta librería y no me da advertencia. (GLCD_X_SIZE, en mi caso, vale 1; por eso yo puse sbyte*2).
En fin, si me ayudan a entenderlo, se los voy a agradecer.
desde mi total y completa ignorancia en JALv2....
Si en lugar de
sbyte*2, colocas
sbyte*(2).Saludos
HJ
No, me sigue dando la misma advertencia.
Citarprocedure _glcd_escribir_4_pixeles_elipse(byte in cx, sbyte in dx, byte in cy, sbyte in dy, bit in enc_apa) is
Citarprocedure _glcd_write_4_ellipse_pixels( byte*GLCD_X_SIZE in cx,
sbyte*(GLCD_X_SIZE + 1) in dx,
byte*GLCD_Y_SIZE in cy,
sbyte*(GLCD_Y_SIZE + 1) in dy) is
continuando desde mi total ignorancia en JALv2, noto esas diferencias marcadas en rojo, en tu casoi sería *1 o *2 según el caso
saludos
HJ
No, eso no era.
De todas maneras, ya lo pude solucionar. El problema estaba en otro procedimiento que llamaba a este procedimiento que les mostré. Mi error fue que no eran compatibles los tipo de variables y sus tamaños.
Encontré el error porque dejé de buscarlo en ese procedimiento. Para evitar errores similares, re-adapté la librería glcd_common a mi librería.
En un ratito, lo comparto con ustedes.
Que bueno que hayas encontrado el origen del problema David.
Saludos
HJ
Bueno, por ahora es la versión beta hasta tanto probarla bien.
Si alguno de ustede, lo puede probar, se los voy a agradecer mucho; y si no hay error, lo publico en otro tema para que quede más a la vista.
glcd_ks0108_opt es el controlador de la pantalla GLCD. (está adjuntado aquí) (http://www.meteorologiafacil.com.ar/foros/index.php?action=dlattach;topic=711.0;attach=563)
glcd_fuente dispone de los caracteres alfanuméricos de tamaño 5x7
glcd_figuras es una librería para dibujar líneas, círculos, elipse y cajas (llenas y vacías).
Por favor, cualquier error, indíquenmelo, así lo puedo solucionar.
Hola a todos!!
Ya me pongo a probar!! :\ despuès les cuento
Hola David!
Hice una pequeña correcciòn acà:
-
-- _fuente_5x7_tabla[] - Tabla caracter. <<<-----<<<
-- ----------------------------------------------------------------------------
-- 91 * 5 bytes = 455
-- ----------------------------------------------------------------------------
const byte _font_5x7_table[] = { <<<-----<<<
for 5 loop
cx = _fuente_5x7_tabla[indx] <<<-----<<<
escribir_byte(x,y,cx)
indx = indx + 1
x = x + 1
end loop
Esta librerìa funciona perfectamente con las pruebas que realicè, colocando caracter por caracter :\
La librerìa de formas tambien funciona :\ :\ :\
Que buen trabajo David! FELICITACIONES ok! ok! ok!
Perfectamente explicado!!
Voy a seguir probando....
Se me chispoteó ese pequeño detalle.
Gracias YO por probarlo
Por nada David! contà con eso ok!
Hice una animaciòn muy simple (correr una caja llena a lo largo del display.)
Le indiquè la posiciòn de inicio y luego hago el desplazamiento, pero a vaces, cuando lo reinicio, solo la dibuja en el lado derecho, y otras veces directamente no lo dibuja.
Es como que no estàn reiniciados CS1 y CS2.
El còdigo es èste :
glcd_ini()
var byte ca_1 = 26
var byte ca_2 = 16
var byte ca_3 = 111
var byte ca_4 = 54
var byte li_1 = 111
var byte li_2 = 16
var byte li_3 = 111
var byte li_4 = 54
forever loop
if ca_1 > 0 then
glcd_caja_llena(ca_1,ca_2,ca_3,ca_4,1) --Dibuja una caja llena, desde 26 altura = 16 base = 54 largo = 111
glcd_linea(li_1,li_2,li_3,li_4,0) -- Dibuja una línea.apagandola
delay_100ms(10)
ca_1 = ca_1 - 1
ca_2 = ca_2
ca_3 = ca_3 - 1
ca_4 = ca_4
li_1 = li_1 - 1
li_2 = li_2
li_3 = li_3 - 1
li_4 = li_4
elsif ca_1 == 0 then
ca_1 = 0
glcd_caja_llena(ca_1,ca_2,ca_3,ca_4,1)
glcd_linea(li_1,li_2,li_3,li_4,0)
delay_100ms(10)
ca_2 = ca_2
ca_3 = ca_3 - 1
ca_4 = ca_4
li_1 = li_1 - 1
li_2 = li_2
li_3 = li_3 - 1
li_4 = li_4
end if
if li_1 == 0 then
asm sleep
end if
end loop
¿Que te parece que puede ser? ???
Ese problema que mencionas, me hace lo mismo.
Yo pensaba que era ruido eléctrico; ya que cuando lo reseteaba, andaba de 10.
Tal vez en algún lado me olvidé de resetear al GLCD con los pines CS1 CS2.
Linda la animación.
Yo estoy haciendo una, pero que aún no logro hacer andar.
Hay dos cosas que no logro hacer, 4 barras deslizables. Y un correcto funcionamiento/trabajo del ADC del PIC. Este varía de 0 a 155, cuando debería llegar a 255. Por ahora sigo sin encontrar el error.
Las barras deslizables, se mueven según el valor del ADC. Con 255, están llenas; y con 0, están vacías.
Aquí está el código:
-- -----------------------------------------
include delay
include glcd_ks0108_opt
include glcd_figuras
include glcd_fuente
const bit ADC_HIGH_RESOLUTION = low
const byte ADC_NCHANNEL = 5
const byte ADC_NVREF = ADC_NO_EXT_VREF
--include adc
--adc_init()
-- ****************************************************************************
-- INICIALIZAMOS EL GLCD
-- ---------------------
glcd_ini()
-- ****************************************************************************
-- CONFIGURAMOS AL ADC.
-- --------------------
TRISA = 0x1F -- RA0 a RA5 entrada.
ADCON1 = 0x02
ADCON0 = 0x81
function leer_cad(byte in canal)return byte is
var byte resultado_cad
case canal of
0: ADCON0 = ADCON0 | 0 -- AN0
1: ADCON0 = ADCON0 | 8 -- AN1
2: ADCON0 = ADCON0 | 16 -- AN2
3: ADCON0 = ADCON0 | 24 -- AN3
4: ADCON0 = ADCON0 | 32 -- AN4
5: ADCON0 = ADCON0 | 40 -- AN5
6: ADCON0 = ADCON0 | 48 -- AN6
7: ADCON0 = ADCON0 | 56 -- AN7
end case
_usec_delay(20) -- 20uS
ADCON0_GO = 1
while ADCON0_GO loop end loop -- Esperamos hasta que la conversión finalice.
resultado_cad = ADRESH
return resultado_cad
end function
-- ****************************************************************************
-- DIBUJAMOS LA PLANTILLA EN EL GLCD
-- ---------------------------------
var byte avanzar_sup = 0
var byte avanzar_inf = 0
procedure mensaje_superior(byte in x, byte in y) is
glcd_caracteres(x,y,"M")
x = x + 6
glcd_caracteres(x,y,"E")
x = x + 6
glcd_caracteres(x,y,"T")
x = x + 6
glcd_caracteres(x,y,"E")
x = x + 6
glcd_caracteres(x,y,"O")
x = x + 6
glcd_caracteres(x,y,"L")
x = x + 6
glcd_caracteres(x,y,"O")
x = x + 6
glcd_caracteres(x,y,"G")
x = x + 6
glcd_caracteres(x,y,"I")
x = x + 6
glcd_caracteres(x,y,"A")
x = x + 6
glcd_caracteres(x,y," ")
x = x + 6
glcd_caracteres(x,y,"F")
x = x + 6
glcd_caracteres(x,y,"A")
x = x + 6
glcd_caracteres(x,y,"C")
x = x + 6
glcd_caracteres(x,y,"I")
x = x + 6
glcd_caracteres(x,y,"L")
end procedure
procedure mensaje_inferior(byte in x, byte in y) is
glcd_caracteres(x,y,"P")
x = x + 6
glcd_caracteres(x,y,"R")
x = x + 6
glcd_caracteres(x,y,"U")
x = x + 6
glcd_caracteres(x,y,"E")
x = x + 6
glcd_caracteres(x,y,"B")
x = x + 6
glcd_caracteres(x,y,"A")
x = x + 6
glcd_caracteres(x,y," ")
x = x + 6
glcd_caracteres(x,y,"G")
x = x + 6
glcd_caracteres(x,y,"L")
x = x + 6
glcd_caracteres(x,y,"C")
x = x + 6
glcd_caracteres(x,y,"D")
end procedure
glcd_linea(0,9,127,9,1)
glcd_linea(0,10,127,10,1)
glcd_linea(0,51,127,51,1)
glcd_linea(0,52,127,52,1)
glcd_linea(26,11,26,50,1)
glcd_linea(27,11,27,50,1)
glcd_linea(104,11,104,50,1)
glcd_linea(103,11,103,50,1)
glcd_caja(29,16,101,23,1)
glcd_caja(29,24,101,31,1)
glcd_caja(29,32,101,39,1)
glcd_caja(29,40,101,47,1)
glcd_caracteres(0,20,"P")
glcd_caracteres(6,20,"O")
glcd_caracteres(12,20,"T")
glcd_caracteres(20,20,"1")
glcd_caracteres(0,27,"P")
glcd_caracteres(6,27,"O")
glcd_caracteres(12,27,"T")
glcd_caracteres(20,27,"2")
glcd_caracteres(0,35,"I")
glcd_caracteres(6,35,"R")
glcd_caracteres(0,40,"T")
glcd_caracteres(6,40,"E")
glcd_caracteres(12,40,"M")
glcd_caracteres(18,40,"P")
-- ****************************************************************************
-- OBTIENE LOS VALORES DE LAS CAJAS SEGÚN VALOR DEL ADC.
-- -----------------------------------------------------
procedure act_cajas(byte in valor, byte out puntos_enc, byte out puntos_apa) is
valor = valor * 100 / 255 -- Obtenemos el porcentaje del rango medido.
valor = valor * 62 / 100 -- Con el porcentaje anterior, obtenemos la cantidad
-- de puntos que contienen las cajas.
valor = valor + 29
puntos_enc = valor
valor = 101 - valor
puntos_apa = valor
end procedure
-- ****************************************************************************
-- OBTENCIÓN DEL CÓDIGO ASCII.
-- ---------------------------
const byte _codigo_ascii[] = {
0x30, -- 0
0x31, -- 1
0x31, -- 2
0x33, -- 3
0x34, -- 4
0x35, -- 5
0x36, -- 6
0x37, -- 7
0x38, -- 8
0x39 -- 9
}
--
function codigo_ascii(byte in dato) return byte is
var byte cod_ascii = dato
var byte ca
ca = _codigo_ascii[cod_ascii]
return ca
end function
-- ****************************************************************************
-- PROCEDIMIENTO PARA DESCOPONER UN NÚMERO.
-- ----------------------------------------
procedure descomponer(byte in cad, byte out cen, byte out dec, byte out uni) is
var byte temporal
temporal = cad
cad = cad / 100
cen = cad
cad = temporal
cad = cad % 100
cad = cad / 10
dec = cad
cad = temporal
cad = cad % 10
uni = cad
end procedure
-- ****************************************************************************
-- ENVÍA EL RESULTADO DECOMPUESTO EN CENTENA, DECENA Y UNIDAD AL GLCD.
-- -------------------------------------------------------------------
procedure cad_glcd(byte in x, byte in y, byte in cad) is
var byte cen,dec,uni
var byte puntos_enc, puntos_apa
var byte temp
descomponer(cad,cen,dec,uni)
temp = cen
cen = codigo_ascii(temp)
glcd_caracteres(x,y,cen)
temp = dec
dec = codigo_ascii(temp)
x = x + 7
glcd_caracteres(x,y,dec)
temp = uni
uni = codigo_ascii(temp)
x = x + 7
glcd_caracteres(x,y,uni)
end procedure
-- ****************************************************************************
-- MENÚ PRINCIPAL.
-- ---------------
var word pot_1
var word pot_2
var word ir
var word temp
forever loop
-- delay_1s(1)
-- avanzar_sup = avanzar_sup + 1
-- avanzar_inf = avanzar_inf + 1
mensaje_superior(avanzar_sup,0)
mensaje_inferior(avanzar_inf,60)
var byte resultado_cad
var byte puntos_enc, puntos_apa
pot_1 = 0
pot_2 = 0
ir = 0
temp = 0
for 50 loop
resultado_cad = leer_cad(0)
pot_1 = pot_1 + word(resultado_cad)
resultado_cad = leer_cad(1)
pot_2 = pot_2 + word(resultado_cad)
resultado_cad = leer_cad(2)
ir = ir + word(resultado_cad)
resultado_cad = leer_cad(3)
temp = temp + word(resultado_cad)
end loop
pot_1 = pot_1 / 50
pot_2 = pot_2 / 50
ir = ir / 50
temp = temp / 50
cad_glcd(106,20,byte(pot_1))
act_cajas(byte(pot_1),puntos_enc,puntos_apa)
glcd_caja_llena(30,17,puntos_enc,22,1)
glcd_caja(puntos_apa,17,100,22,0)
cad_glcd(106,27,byte(pot_2))
act_cajas(byte(pot_2),puntos_enc,puntos_apa)
glcd_caja_llena(30,25,puntos_enc,30,1)
glcd_caja(puntos_apa,25,100,30,0)
cad_glcd(106,35,byte(ir))
act_cajas(byte(ir),puntos_enc,puntos_apa)
glcd_caja_llena(30,33,puntos_enc,38,1)
glcd_caja(puntos_apa,33,100,38,0)
cad_glcd(106,40,byte(temp))
act_cajas(byte(temp),puntos_enc,puntos_apa)
glcd_caja_llena(30,41,puntos_enc,46,1)
glcd_caja(puntos_apa,41,100,46,0)
end loop
El que lo quiera montar, debe tener en cuanta, que no funciona correctamente.
EL error que tenía de que no variaba de 0 a 255, es que en la tabla que obtiene el caracter ASCII de los números, el dos tenía guardado 0x31, cuando en realidad le corresponde 0x32.
También, descubrí un error que, hasta hace rato, desconocía su funcionamiento.
Resulta que CASE variable OF
END CASE
No funcionaba como pensaba. Yo pensaba que saltaba directamente a la opción igual a la variable. Por ejemplo:
case temporal of
0: asm nop
1: asm nop
2: asm nop
3: asm nop
end case
Si temporal vale 0, solo ejecuta la opción primera; o sea, la linea 0: asm nop
Pero grande fue mi sorpresa que, cuando temporal valía 3, en ves de dirigirse inmediatamente a la línea 3: asm nop, empezaba por la línea 0 y laejecutaba; luego ejecutaba la línea 1: asm nop y lo mismo con la linea 2:asm nop
En fin, es algo nuevo que he aprendido hoy.
He actualizado la librería glcd_ks0108_opt para evitar que el GLCD arranque mal.
Por favor, pruebenlo así ya, después de un tiempo, lo saco de beta para lanzarlo como la versión estabilizada.
Hola David!
Es muy extraño lo que te hace el CASE OF, ya que la tabla donde tengo resuelto los algoritmos para el punto de rocío funciona saltando directamente al lugar indicado y trae solo ese valor dudo:
En cuanto pueda pruebo la librería y te cuento
Saludos!
Hola a todos!!
David, probè la nueva versiòn de la librerìa y sigue arrancando mal.
Solo arranca bien con el reset, como vos decias ???
¡Qué macana!
Seguiré buscando el error.
Hola!
Hice èsto en el procedimiento de arrancar
GLCD_CS2_DIRECTION = output
GLCD_RST = high
GLCD_RST = low
GLCD_RST = high
_glcd_cs1_cs2()
y arrancò bien de una, probè varias veces y no fallò.
Luego, encendì, apaguè y volvì a encender ràpido y fallò. ???
Ahora voy a ponerle un retardo, para que estè bajo un poco màs y te cuento.
Bueno, de diez arranques fallò 2.
Algo mejorò pero no deberìa fallar una :jeje:
Algo es algo.
Hola a todos!!
David, tengo una duda con el procedimiento de borrar lìneas, ya que si dibujo una caja llena y la quiero hacer desplazar horizontalmente, simplemente dibujo una lìnea por delante y borro la ùltima lìnea del lado contrario.
Esto funciona perfectamente y muy ràpido sin fallar.
Si utilizo la misma tecnica desplazando la caja hacia abajo, la lìnea que agrego (en el eje Y) se dibuja bien, pero la contraria, (del eje Y) me borra de a ocho.
Yo le doy un avance de a uno, pero si no suma 8 no borra y lo peor es que las borra todas juntas ???
Es como que solo puede borrar la pàgina completa :jeje:
Serà problema del procedimiento de borrar lìnea en la librerìa?
Eso pasa por una razón, estás justo modificando dos páginas simultáneamente y la librería que hice, no soporta eso.
Si haces una caja de 5 pixel de alto, y si la haces desplazar uno hacia abajo y mientras se mantenga en la misma página, no debería pasar.
Gracias David, yo no le encontraba el motivo pero me parecìa que era asì
Yo no lo pude probar, ya que estoy en el trabajo.
Pensandolo bien, nunca se puede trabajar en forma simultànea en dos pàginas, ya que las instrucciones se ejecutan una y luego la otra y el tamaño de la caja llena es glcd_caja_llena(12,10,51,33,1)
Lo curioso es que por debajo de la caja, si, dibuja de a una lìnea, pero al borrar la lìnea superior de la caja, lo hace borrando ocho a la vez, no de a una como le pido.
Si, siempre trabaja por página, porque los datos se agregan así. No se puede escribir un pixel sin modificar los 7 restantes. Por eso, antes de escribir un pixel, lee la página por completo; y de acuerdo con los que se quiere hacer, si encender o apagar, realiza una operación AND o XOR.
Para trabajar con dos páginas a la vez, hay que escribir un procedimiento que analice cual de las dos páginas se modifican, recuperarlas antes y enmascarar los pixeles que no se desean modificar. Esto produce una carga extra al CP.
Si quieres lo podemos implementar como una opción, pero reduciría memoria disponible y tiempo.
Quizàs venga bien cuando la memoria sobre ;D