Hola a todos!
En éste nuevo sitio, analizaremos las librerías de Jal, para el display glcd Ks 0108, y como son varias, comenzaremos con los procedimientos de la librería glcd_ks0108
Todos los aportes serán bienvenidos!

Saludos!


Parte A - Librería glcd_ks0108.jal

1- Configuración (con adjunto de la librería)

2- Funciones y Procedimientos Parte 1

3- Funciones y Procedimientos Parte 2

Parte B - Librería glcd_common.jal

1- Configuración (con adjunto de las librerías necesarias).

2- Dibujar líneas

3- Cajas vacías y llenas

4- Elipses y círculos

La librería que vamos a tratar aquí, es la que trae el compilador JALv2. Y para evitar malos entendidos, estará adjunto en los respectivos mensajes. Cabe aclarar que, en versiones futuras, se pueda dar el caso de una modificación de dichas librerías y esto podrá hacer que no funcione de la misma manera que nosotros la haremos aquí. Por lo tanto, aquellos que no puedan hacer andar el GLCD con la librería que les trajo su versión de JALv2, deben descargar estas para evitar más dolores de cabeza. En otras palabras, el tutorial que haremos acá, está basado en las librerías adjuntas.

Parte A


Configuración.

Lo primero que debemos saber, es que necesita cada librería y como configurarlo para que ande correctamente. No está demás en saber que necesita porque esto nos ayudará a ahorrar memoria y ciclos de máquina. Si hay ciclos de máquinas innecesario, hará que el PIC tarde más en hacer su trabajo.

Aclaración muy importante: Salvo en caso de que indiquemos lo contrario, jamás se modificaran las librerías para hacerlas trabajar. Toda línea de programa que escribiremos, será sobre NUESTRO programa y JAMÁS sobre dichas librerías.

Lo primero que debemos hacer antes de incluir la librería glcd_ks0108.jal, es indicarle al compilador, sobre que puertos y sobre que bit de cada puerto, conectaremos el PIC al GLCD.

-- ***************************************************
-- Definimos los puertos relacionados con el GLCD    (adaptalo al tuyo)
-- ***************************************************
-- 1
var volatile byte GLCD_DATAPRT is portd
var volatile byte GLCD_DATAPRT_DIR is portd_direction
-- 2
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
-- 3
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

Es importante saber que se puede cambiar los bit y los puertos para comunicarse. Cada uno lo ajustará según sus necesidades y disponibilidad. Como aquí lo hemos echo, está en uno de los ejemplos que trae JALv2.

Lo siguiente, es para aclarar a los usuarios que no estén muy avanzados en este lenguaje. Si tu ya sabes lo que significa cada línea de programa anterior, puedes saltear al siguiente punto.

Bien, dividimos la configuración es tres partes.
Vamos con la primer parte.

--1
var volatile byte GLCD_DATAPRT is portd
var volatile byte GLCD_DATAPRT_DIR is portd_direction

En la primer línea, le indicamos al compilador, que renombre al puerto d (portd) como GLCD_DATAPRT. En la librería, maneja dicho nombre para trabajar sobre el puerto d; por lo que es obligatorio respetar el nombre. Seguramente te habrás dado cuenta que sobre el puerto d; conectaremos los 8 bit de datos del GLCD (D0 a D7)
En la segunda línea, renombramos, de la misma manera; al registro TRISD del PIC con el nombre GLCD_DATAPRT_DIR. El TRISD, el jal lo llama como portd_direction

Segunda parte:

-- 2
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

Las 6 líneas, hacen lo mismo cada uno, pero se diferencia en los bit de control de cada bit del GLCD. Se trata de renombrar a cada bit de dicho puerto por un nombre; así se evita recordar como está conectado el PIC al GLCD y confundir bit por otros y que nos provocaría muchos dolores de cabeza, al no saber donde está el error. Recuerden que el compilador da errores de sintaxis o de variables no declaradas.
Al igual que en la primer parte, es obligatorio respetar los nombres porque así se utilizan en la librería.

RW es el bit de control de Lectura (read) Escritura (write)
CS1 es el bit de selección de la primera mitad horizontal de la pantalla. Los primeros 64 bit.
E es el bit de control de habilitación del GLCD (enable)
DI es el bit de control de Datos (data) o de instrucción para el GLCD (instruction)
RST es el bit para resetear al GLCD (reset)
CS2 es el bit de selección de la segunda mitad horizontal de la pantalla. Los segundos 64 bit.

Tercera parte:

-- 3
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

Si entendieron la primera parte, entenderán esta.

Funciones y Procedimientos

Recordatorio: Las funciones devuelven un valor, mientras que los procedimientos no. Tantos como las funciones o como los procedimientos, se les puede enviar una dato. Dependerá de como esté echo los mismo, para requerir datos o no.

Inicio del GLCD

glcd_init()

Este procedimiento debe ser ejecutado una sola vez y antes de empezar a trabajar con el GLCD. No requiere ningún dato.

Encender el GLCD

lcd_on()

Este procedimiento enciende el GLCD. No es necesario ejecutarlo luego de ejecutar glcd_init(). Si debe ser ejecutado si se ejecuta el que lo apaga lcd_off(). Son útiles si se quiere apagar o encender el GLCD una vez inicializado y evitar inicializarlo de nuevo.

Apagar el GLCD

lcd_off()

Este procedimiento apaga el GLCD.

Borrar o rellenar la pantalla.

lcd_fill(a)

Este procedimiento borra la pantalla, es decir, apaga todos los pixceles; o también puede encenderlos todos. Este si requiere de un dato a; que pueden ser solo dos opciones: ON; OFF ó 1; 0

lcd_fill(on) -- Rellena la pantalla. Enciende todos los pixceles.
lcd_fill(off) -- Borra toda la pantalla. Apaga todos los pixceles.

Encender un pixcel.

glcd_write_pixel(x,y)

Este procedimiento enciende un pixcel deseado. Es muy útil para dibujar. Requiere de dos datos x; y. Estos son las coordenada del pixcel que deseamos encender.

x puede tomar cualquier valor de 0 a 128 (para un GLCD de 128 pixceles horizontales).
y puede tomar cualquier valor de 0 a 64 (para un GLCD de 64 pixceles verticales).

Ejemplo. Deseamos encender el pixcel de la coordenada x = 23 y = 60

glcd_write_pixel(23,60)

Escribir un caracter.

ks0108_write_char(x,y,char)

Este procedimiento escribe un caracter en el GLCD especificando su coordenadas x; y. Char corresponde al número decimal del código ASCII. Como notaron, se necesita 3 datos a ingresar, dos de coordenada y uno del caracter a mostrar.

El caracter tiene un ancho de 5 pixcel (eje x) por un alto de 7 pixcel (eje y). Esto es importante saberlo, porque si no se respeta el ancho y/o el alto, las letras se encimarán.

Normalmente, las coordenadas de cada caracter, corresponde a la parte inferior izquierda del caracter; pero no siempre es así. La librería controla que el caracter entre entero, tomando la decisión de cambiar la posición o anularlo. Hay que prestar atención al lugar seleccionado, y ante la duda, experimentar.

Para elegir el caracter, hay dos maneras de hacerlo, la cual, yo recomiendo la segunda para evitar confusiones y pérdidas de tiempo.
1- Poniendo directamente el valor decimal del código ASCII correspondiente; por ejemplo 71 que corresponde a la G
2- Colocar directamente el caracter deseado entre comillas dobles ""; así el compilador sustituirá el número correcto por nosotros.

Ejemplo 1:

ks0108_write_char(5,15,71) -- G

Ejemplo 2:

ks0108_write_char(5,15,"G") -- G

Más adelante, veremos como hacer para cambiar el ancho y alto de los caracteres a mostrar, entre 5x7; 6x8; 8x12.

Escribir un byte

ks0108_write_byte(x,y,veri)

Este procedimiento, trabaja de la misma forma que el anterior. La diferencia radica en que se escribe un byte en el GLCD.

Leer un byte

ks0108_read_byte(x,y)

Esta función, retorna la lectura del byte de las coordenadas x;y.

Ejemplo:

var byte i
i = ks0108_read_byte(5;15) -- i contiene el byte de la coordenada 5;15.

---

Hemos finalizado la librería ks_0108.jal. Continuaremos con otra librería.

La librería que vamos a tratar aquí, es la que trae el compilador JALv2. Y para evitar malos entendidos, estará adjunto en los respectivos mensajes. Cabe aclarar que, en versiones futuras, se pueda dar el caso de una modificación de dichas librerías y esto podrá hacer que no funcione de la misma manera que nosotros la haremos aquí. Por lo tanto, aquellos que no puedan hacer andar el GLCD con la librería que les trajo su versión de JALv2, deben descargar estas para evitar más dolores de cabeza. En otras palabras, el tutorial que haremos acá, está basado en las librerías adjuntas.

Parte B


Esta librería, nos ayudará a realizar diferentes gráficos. Los cuales son:

• Líneas
• Cajas
• Cajas llenas
• Elipses
• Círculos
• Dibujar imagenes

Configuración.

Lo primero que debemos saber, es que necesita cada librería y como configurarlo para que ande correctamente. No está demás en saber que necesita porque esto nos ayudará a ahorrar memoria y ciclos de máquina. Si hay ciclos de máquinas innecesario, hará que el PIC tarde más en hacer su trabajo.

Aclaración muy importante: Salvo en caso de que indiquemos lo contrario, jamás se modificaran las librerías para hacerlas trabajar. Toda línea de programa que escribiremos, será sobre NUESTRO programa y JAMÁS sobre dichas librerías.

Lo primero que debemos hacer antes de incluir la librería glcd_common.jal, es colocar varios constantes, el cual, guiarán a la librería de que tipo de GLCD estamos trabajando y como queremos trabajar. Esto es de suma importancia para que se dibujen en forma correcta cualquier dibujo que queramos mostrar en el GLCD, por lo que no debe ser tomado a la ligera y se debe entender que es lo que se está haciendo.

const byte GLCD_X_PIXELS -- Especifica el ancho del GLCD, o sea, la cantidad de pixeles en el eje horizontal.
const byte GLCD_Y_PIXELS -- Especifica el alto del GLCD, o sea, la cantidad de pixeles en el eje vertical.
const byte GLCD_COLOR_BITS -- Indica la cantidad de colores que tiene el GLCD. 1 para blanco y negro; 16 para 16 colores.
const bit GLCD_CLIPPING -- Indica si se requiere recorte.

El recorte sirve para evitar que los pixeles se dibujen en cualquier lado cuando el dibujo exceda los límites del GLCD. Si se omite o se especifica como falso (FALSE; 0) la rutina no garantiza que se dibuje en forma correcta cuando un gráfico exceda los límites del GLCD. En caso de darle un valor verdadero (TRUE; 1) la rutina recortará el dibujo hasta los límites del GLCD.

Si el GLCD es color, hay que incluir las siguiente constantes, además de GLCD_COLOR_BITS:

const byte glcd_pen_color -- Especifica el color del lápiz. Este también puede ser variable.
const byte glcd_background_color -- Especifica el color de la luz de fondo. Este también puede ser variable.

También es necesario agregar dos procedimientos:

glcd_write_char(x,y,char) -- Si no está implementada, se utilizará la que está en la librería glcd_font.jal
glcd_write_pixel(x,y) -- En el caso de que el procedimiento anterior no se pueda usar {glcd_write_char(x,y,char)} , se puede usar este procedimiento para dibujar las letras {glcd_write_pixel(x,y)} Si una o ninguna de las dos está implementado; las mismas no estará disponibles.

Ejemplo de configuración para un GLCD de 128x64 monocromático.

const byte GLCD_X_PIXELS = 128
const byte GLCD_Y_PIXELS = 64
const byte GLCD_COLOR_BITS = 1
const bit GLCD_CLIPPING = 1

Relación con la librería glcd_ks0108.jal

Esta librería, ya tiene configurado algunas cosas para esta librería (glcd_common.jal); por lo que nos hace la tarea más fácil. Ahora bien, hay que prestar atención a como incluirlo en nuestro programa.
Recuerde que, el compilador JALv2, analiza de arriba hacia abajo. Esto implica que, si un procedimiento A necesita de un segundo procedimiento B para funcionar; este último B, debe estar antes que A. Y pasa lo mismo los las constantes y variables.
Por lo tanto, siguiendo este razonamiento, nos daremos cuenta que, primero debe incluirse la librería glcd_ks0108 y luego la glcd_common.jal.

include glcd_ks0108
const bit GLCD_CLIPPING = 1
include glcd_common

Como notarán, faltan las constantes GLCD_X_PIXELS; GLCD_Y_PIXELS; GLCD_COLOR_BITS. Es porque en dicha librería, ya está especificado en forma correcta.
Si usted desea utilizar esta librería (glcd_ks0108) con otro GLCD con diferente tamaño, deberá modificar la librería. Sea cuidadoso con lo que modifica, porque de lo contrario no le funcionará en forma correcta.

Para finalizar esta primera etapa de la librería glcd_common; se incluye también la librería glcd_font. Esto es debido porque dicha librería, necesita y la incluye por nosotros, a la librería glcd_font. Por lo tanto, descargar los dos y en nuestro programa NO debe incluirse a gcld_font.

Procedimientos

Dibujar líneas

glcd_line(x0,y0,x1,y1)

Este procedimiento nos permite dibujar una línea horizontal, vertical o una diagonal. Necesita de 4 valores para dibujar. Es un procedimiento muy fácil de usar.

x0; y0 especifica el punto de inicio de la línea.
x1; y1 especifica el punto final de la línea.

Veamos algunos ejemplo.

Línea horizontal:

glcd_line(0,0,10,0)

Esto dibujará una línea desde la posición 0;0 hasta 10;0
Como notarán, solo se movió en el eje x, pero no sobre en el eje y.

Línea vertical:

glcd_line(0,0,0,10)

Esto dibujará una línea desde la posición 0;0 hasta 0;10
Como notarán, no se movió del eje x, solo lo hizo en el eje y

Línea oblicua
Viendo los ejemplo anteriores, es fácil darse cuenta como hacer una línea oblicua.

glcd_line(0,0,10,10)

Esto dibujará una línea desde la posición 0;0 hasta 10;10
Como notarán, se movió sobre los dos ejes.

Dibujar cajas vacías

glcd_box(x0,y0,x1,y1)

Este procedimiento nos permite dibujar una caja vacía o sin rellenar. Necesita de 4 valores para dibujar. Es un procedimiento muy fácil de usar. Como es de esperar, la caja puede ser un cuadrado o un rectángulo.

x0; y0 especifica la parte superior izquierda de la caja.
x1; y1 especifica la parte inferior derecha de la caja.

Veamos dos ejemplos.

Caja cuadrada:

glcd_box(0,0,10,10)

Esto dibujará una caja cuadrada, porque avanzó la misma cantidad en el eje x y en el eje y. Este cuadrado estará comprendido entre las coordenadas 0;0 al 10;10

Caja rectangular:

glcd_box(0,0,10,20)

Esto dibujará una caja rectangular, porque avanzó más sobre el eje y que sobre el eje x. Por lo tanto, este rectángulo estará parado. Su ubicación estará comprendido entre 0;0 al 10;20

Dibujar cajas llenas

glcd_box_fill(x0,y0,x1,y1)

Este procedimiento nos permite dibujar una caja llena. Necesita de 4 valores para dibujar. Es un procedimiento muy fácil de usar. Como es de esperar, la caja puede ser un cuadrado o un rectángulo.

x0; y0 especifica la parte superior izquierda de la caja.
x1; y1 especifica la parte inferior derecha de la caja.

Veamos dos ejemplos.

Caja cuadrada llena:

glcd_box_fill(0,0,10,10)

Esto dibujará una caja cuadrada llena, porque avanzó la misma cantidad en el eje x y en el eje y. Este cuadrado estará comprendido entre las coordenadas 0;0 al 10;10

Caja rectangular llena:

glcd_box_fill(0,0,10,20)

Esto dibujará una caja rectangular llena, porque avanzó más sobre el eje y que sobre el eje x. Por lo tanto, este rectángulo estará parado. Su ubicación estará comprendido entre 0;0 al 10;20

Dibujar elipses

glcd_ellipse(cx,cy,xradius,yradius)

Este procedimiento nos permite dibujar una elipse. Necesita de 4 valores para dibujar. Es un procedimiento muy fácil de usar.

cx; cy especifica el centro de la elipse.
xradius; yradius especifica el radio de cada eje cartesiano. Si ambos valores son iguales, en vez de ser una elipse, será un círculo.

Veamos un ejemplo.

Elipse:

glcd_ellipse(64,32,5,10)

Esto dibujará una elipse en el centro del GLCD. El radio del eje x vale 5 pixeles, y el radio del eje y vale 10 pixeles.

Dibujar círculos

glcd_circle(cx,cy,radius)

Este procedimiento nos permite dibujar un círculo. Necesita de 3 valores para dibujar. Es un procedimiento muy fácil de usar.

cx; cy especifica el centro del círculo.
radius especifica el radio del círculo.

Veamos un ejemplo.

Círculo:

glcd_circle(64,32,10)

Esto dibujará un círculo en el centro del GLCD con radio de 10 pixceles.

Una curiosidad. Este procedimiento utiliza el procedimiento de la elipse repitiendo el radio en el eje x y en el eje y.