TODOPIC
Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: camigod en 21 de Marzo de 2009, 23:15:08
-
Hola a todos,
Estoy iniciando con la glcd y tengo una cuya referencia es LM12864LFW y maneja el driver KS0108,
Uso C18 para programarla pero me baso en la libreria GLCD.C de CCS para manejarla.
Converti el codigo de PICC a MPLAB, pero tengo problemas con la visualizacion y creo q debe ser un bug de la libreria pues estoy seguro que la conversion es correcta.
El problema es que cuando escribo un pixel con la funcion glcd_pixel(x,y,color) se encienden otros pixeles en la columna de la direccion dada.
(http://C:\Documents and Settings\Camilo Andres\Desktop\glcd.jpg)
El programa es el siguiente:
#include <p18f4550.h>
#include <delays.h>
#include <math.h>
#include "GLCD.h"
void main(){
ADCON1 = 15;
TRISE = 0;
TRISC = 0;
TRISD = 0;
glcd_init(ON);
glcd_pixel(0,1,1);
while(1){}
}
Le doy la orden de encender solo el primer pixel, sin embargo imprime los bits 3,4,5 y 7. si intento encender otro ocurre lo mismo.
Supongo que el problema esta en la funcion de lectura de la libreria, que se encarga de leer que dato existia antes para cambiar unicamente un pixel, pero no se como podria arreglarlo. Por favor si alguien conoce la solucion agradeceria su ayuda.
muchas gracias de antemano.
Hasta luego
ADJUNTO LA IMAGEN
-
Hola.
Un offtopic .... donde compraste la LCD? y cuanto te co$$$to?
-
La compre en el centro de la electronica en bogota jejeje, en la 9 con 19, costo $80000.
-
(http://img201.imageshack.us/img201/3769/kiko.jpg)
bueno, fuera de bromas aca te paso un codigo de una simulacion en C18 del glcd.
-
:shock: :shock: :shock:
$ 80000 ???
Telefono: ????? :-/ :-/ :-/ Como se llama el sitio?
Voy a mandar por unas!!!! a ese precio!!!!! esta muy bueno
:mrgreen: :mrgreen:
-
jajaja muchas gracias por el ejemplo, ya con el puedo empezar a diseñar una libreria, supongo que el problema debio ser por el tiempo de los retardos.. :x... jejje, porque realizando un programa en PICC y simulandolo funciona bien.... :?.
Bueno poco a poco se aprende mas...
jajjaa y no entendi muy bn los sarcasmos MLO_.... esta muy cara??? porq a mi no me parecio barata jajajajaja.
pero pues el telefono y local no los se. Pero la direccion es Cra 9 con calle 19, Es un edificio AMARILLO, muy conocido a proposito, y en TODOS los locales en los q pregunte costaba eso, es mas, habian unas de 128x64 un poco mas pequeñas, al parecer sin luz... no lo se, y costaban 60000.
Bueno muchas gracias de nuevo a todos.
Hasta luego
-
en mi pais cuestan 80 soles que equivalen a maso o menos 25 dolares. por eso puse mi cara de kiko :-)
(http://img201.imageshack.us/img201/3769/kiko.jpg)
-
aaaaa, entonces esta muy cara.... :(jajajajaja.
Una ultima pregunta, q mas q pregunta es una inquietud, tengo en mis manos dos pequeños tesoros para mi, y son las pantallas LCD de un celular NOKIA 6103... seria MUY MUY AGRADABLE hacerlas funcionar, el problema son los conectores que tienen, asi que me preguntaba si ninguno de ustedes conoce algun metodo o algun conector que permita manjarlas...
Gracias
-
sube las fotos, eso ayudaria con la identificacion 8)
-
Aca subo la imagen de la GLCD.
(http://www.ucontrol.com.ar/wiki/images/thumb/5/57/GLCD-1.jpg/350px-GLCD-1.jpg)
-
Hola.
Nada que ver camigod .. me parece un muy buen precio!!! por eso te pedi el numero de telefono, para comunicarme y enviar por algunas de ellas. Mhh .... me toca abusar de ti y pedirte comedidamente que me averigues el telefono y el nombre del local :g) :g) necesito algunas ... si podrias????? he???? si .... anda di que si ... si?????
(http://img201.imageshack.us/img201/3769/kiko.jpg)
-
Hola,
Podria darte la direccion concreta del edificio, pero el numero telefonico del local donde la compre no lo tengo, pero si llegas a esta direccion no te sera dificil encontrar un local en el que la vendan, ya que la mayoria trabaja con la misma mercancia.
DIRECCION: Cra 9 No. 19-30
-
Hola de nuevo :D
Lo siento pero el ejemplo que publico micro_cadaver no maneja lectura de la LCD, es decir, simplemente imprime un arreglo ya establecido para formar las diferentes imagenes.
El problema que tengo, es que por mas que lo intento no logro compilar una funcion que me permita leer cierta direccion en la LCD, y es importante hacerlo ya que si lo que necesito hacer es encender un pixel determinado, es necesario conocer que habia en dicha columna de bits anteriormente.
Entonces la pregunta concreta seria... como realizar una funcion de lectura de la LCD en MPLAB C18
Gracias de nuevo.
-
Hola.
Gracias camigod ... el problema es que estoy un poquito lejos (Pasto) de Bogota ... por eso necesitaba el telefono ... para ver si podia contactarme con ellos ....
Saludos
-
Hola MLO_, Ya consegui el numero y la direccion del local donde la consegui.
IMPORTACIONES VARGAS
Tel: 286 5194
Cra 9 No. 19-30 Local 115
Fax: 283 5682
Hasta luego
-
(http://www.ucontrol.com.ar/wiki/images/thumb/5/57/GLCD-1.jpg/350px-GLCD-1.jpg)
Que parecido al mio!!!! :) :) :) :) :)
Hablando en serio, aqui (Libreria de gráficos para GLCD K0108 en CCS (http://www.ucontrol.com.ar/wiki/index.php/CCS_-_Libreria_de_gr%C3%A1ficos_para_GLCD_K0108)) tienes una libreria que pone puntos sin problemas en ese display. Esta bastante facil para pasarla a C18 y esta todo bastante comentado:
/////////////////////////////////////////////////////////////////////////
// Conexiones de pines del GLCD (Con chipset K0108) //
// //
// 1: CS1 <-> B1 //
// 2: CS1 <-> B0 //
// 6: R/S <-> B2 //
// 7: R/W <-> B3 //
// 8: E <-> B4 //
// 9..16: D0..D7 <-> D0..D7 //
// 17: Reset <-> B5 //
// //
// Los valores pueden cambiarse con los DEFINE que están más abajo //
//---------------------------------------------------------------------//
// > GLCD_limpiar(color) //
// "Borra" la pantala, llenando la del color seleccionado. //
// color = 0 : puntos apagados //
// color = 1 : puntos encendidos //
// //
// > GLCD_RAM2LCD() //
// Vuelca el contenido de la RAM a la pantalla. //
// solo funciona si FAST_GLCD está definido. //
//---------------------------------------------------------------------//
// > GLCD_inicializa(modo) //
// Inicializa el GLCD, y debe llamarse ANTES de cualquier otra. //
// modo = 0 : GLCD en ON //
// modo = 1 : GLCD en OFF //
// //
// EN LAS SIGUIENTES FUNCIONES, SIEMPRE SE RESPETA QUE: //
// color = 0 : puntos apagados //
// color = 1 : puntos encendidos //
// //
// > GLCD_punto(x,y,color) //
// Dibuja un punto en x,y. 0,0 es la esquina superior izquierda. //
// //
// > GLCD_linea(x1,y1,x2,y2,color) //
// Dibuja una linea desde (x1,y1) a (x2,y2) //
// //
// >GLCD_rectangulo (x1,y1,x2,y2,color) //
// Dibuja un rectangulo con esquinas en (x1,y1) y (x2,y2) //
// //
// >GLCD_caja (x1,y1,x2,y2,color) //
// Dibuja un rectangulo pintado con esquinas en (x1,y1) y (x2,y2) //
// //
// >GLCD_circulo (x1,y1,r,color) //
// Dibuja un circulo con centro en (x1,y1) y radio R //
// //
/////////////////////////////////////////////////////////////////////////
//Pines a usar
#define GLCD_CS1 PIN_E2
#define GLCD_CS2 PIN_E1
#define GLCD_DI PIN_C3
#define GLCD_RW PIN_C2
#define GLCD_E PIN_C1
#define GLCD_RESET PIN_E0
//Lados del GLCD
#define GLCD_lado_CS1 0
#define GLCD_lado_CS2 1
BYTE GLCD_leeBYTE(int1 lado);
//-----------------------------------------------------------------------
//Escribe un byte en una de las mitades de la pantalla (lado=0:izq Lado=1:der)
//-----------------------------------------------------------------------
void GLCD_enviaBYTE(int1 lado, BYTE dato)
{
if(lado) output_high(GLCD_CS2); // Selecciono la mitad correspondiente
else output_high(GLCD_CS1);
output_low(GLCD_RW); // Modo escritura
output_d(dato); // Coloco el dato en el puerto y...
delay_us(1); // ...espero.
output_high(GLCD_E); // Pongo el bit Enable en alto y...
delay_us(2); // ...espero.
output_low(GLCD_E); // Pongo el bit Enable en bajo.
output_low(GLCD_CS1); // Libero la linea CS1 y...
output_low(GLCD_CS2); // CS2.
}
//-----------------------------------------------------------------------
// Lee un byte de una de las dos mitades de la pantalla
//-----------------------------------------------------------------------
BYTE GLCD_leeBYTE(int1 lado)
{
BYTE dato;
set_tris_d(0xFF); // Puerto D como entrada
output_high(GLCD_RW); // GLCD en Modo lectura
// Selecciono la mitad del display a leer.
if(lado) output_high(GLCD_CS2);
else output_high(GLCD_CS1);
delay_us(1); // Espero...
output_high(GLCD_E); // Pongo en alto el pin enable y...
delay_us(2); // ...espero.
dato = input_d(); // Guardo en "dato" el valor devuelto y...
output_low(GLCD_E); // ...pongo en bajo el pin enable.
// Vuelvo a poner en bajo las lineas CS1 y CS2.
output_low(GLCD_CS1);
output_low(GLCD_CS2);
return dato;
}
//-----------------------------------------------------------------------
// Limpia el GLCD (pinta toda la pantalla de un color)
//-----------------------------------------------------------------------
void GLCD_limpiar(int1 color)
{
int8 i, j;
// Recorre las 8 paginas (vertical)
for(i = 0; i < 8; ++i)
{
output_low(GLCD_DI); // Modo instruccion
//Comienzo, en cada página, desde la dirección 0
GLCD_enviaBYTE(GLCD_lado_CS1, 0b01000000);
GLCD_enviaBYTE(GLCD_lado_CS2, 0b01000000);
//Selecciono la direccion dentro de la pagina
GLCD_enviaBYTE(GLCD_lado_CS1, i | 0b10111000);
GLCD_enviaBYTE(GLCD_lado_CS2, i | 0b10111000);
output_high(GLCD_DI); // Modo datos
// Recorre las dos mitades (horizontales)
for(j = 0; j < 64; ++j)
{ GLCD_enviaBYTE(GLCD_lado_CS1, 0xFF * color); // Enciende/apaga pixeles
GLCD_enviaBYTE(GLCD_lado_CS2, 0xFF * color); // Enciende/apaga pixeles
}
}
}
//-----------------------------------------------------------------------
//Esta funcion inicializa el LCD.
//-----------------------------------------------------------------------
void GLCD_inicializa(int1 modo)
{
// Pone los pines de control en el estado correcto.
output_high(GLCD_RESET);
output_low(GLCD_E);
output_low(GLCD_CS1);
output_low(GLCD_CS2);
output_low(GLCD_DI); // Modo instruccion
// Envio datos de inicialización -----------------------
GLCD_enviaBYTE(GLCD_lado_CS1, 0xC0);
GLCD_enviaBYTE(GLCD_lado_CS2, 0xC0);
GLCD_enviaBYTE(GLCD_lado_CS1, 0x40);
GLCD_enviaBYTE(GLCD_lado_CS2, 0x40);
GLCD_enviaBYTE(GLCD_lado_CS1, 0xB8);
GLCD_enviaBYTE(GLCD_lado_CS2, 0xB8);
// Si modo = 1 inicializa encendido. Sino, apagado.
if(modo == 1)
{ GLCD_enviaBYTE(GLCD_lado_CS1, 0x3F); // Enciendo el GLCD
GLCD_enviaBYTE(GLCD_lado_CS2, 0x3F); }
else {
GLCD_enviaBYTE(GLCD_lado_CS1, 0x3E); // Apago el GLCD
GLCD_enviaBYTE(GLCD_lado_CS2, 0x3E); }
// Borro la pantalla
GLCD_limpiar(0);
}
//-----------------------------------------------------------------------
// Dibuja un pixel
//-----------------------------------------------------------------------
void GLCD_punto(int8 x, int8 y, int1 color)
{
BYTE dato;
int1 lado = GLCD_lado_CS1; // Lado en que voy a dibujar.
if(x > 63) // Veo si cae del otro lado
{ x -= 64;
lado = GLCD_lado_CS2;}
output_low(GLCD_DI); // Modo instruccion
bit_clear(x,7); // Limpio bit MSB...
bit_set(x,6); // ...y pongo el bit 6 en 1
GLCD_enviaBYTE(lado, x); //Envio la dirección de la coordenada X
// Calculo en que pagina de las 8 cae...
GLCD_enviaBYTE(lado, (y/8 & 0xBF) | 0xB8);
output_high(GLCD_DI); // ...y paso a Modo datos
//Se necesitan dos lecturas para que devuelva el dato en la nueva direccion
GLCD_leeBYTE(lado);
dato = GLCD_leeBYTE(lado);
//De acuerdo al valor de color...
if(color == 1) bit_set(dato, y%8); // Enciendo el pixel
else bit_clear(dato, y%8); // apago el pixel
output_low(GLCD_DI); // Modo instruccion
GLCD_enviaBYTE(lado, x); // Fijo el lado a escribir,
output_high(GLCD_DI); // pongo en Modo Datos y....
GLCD_enviaBYTE(lado, dato); // dibujo el pixel
}
//-----------------------------------------------------------------------
// Dibuja una linea desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_linea(int x1, int y1, int x2, int y2, int1 color)
{
//Declaro variables-------------------
signed int x, y, incremento_x, incremento_y, distancia_x, distancia_y;
signed long P;
int i;
//Calculo las diferencias entre las coordenadas de origen y destino
distancia_x = abs((signed int)(x2 - x1));
distancia_y = abs((signed int)(y2 - y1));
//Inicializo x e y con las coordenadas de origen
x = x1;
y = y1;
//Calculo el sentido de los incrementos (positivos o negativos)
//en funcion de la posicion del origen y el destino
if(x1 > x2) incremento_x = -1; else incremento_x = 1;
if(y1 > y2) incremento_y = -1; else incremento_y = 1;
//Si la distancia horizontal es mayor a la vertical...
if(distancia_x >= distancia_y)
{ P = 2 * distancia_y - distancia_x;
for(i=0; i<=distancia_x; ++i)
{
GLCD_punto(x, y, color);
if(P < 0)
{ P += 2 * distancia_y;
x += incremento_x; }
else
{ P += 2*distancia_y - 2*distancia_x;
x += incremento_x;
y += incremento_y;}
}
}
//Si la distancia vertical es mayor a la horizontal...
else
{ P = 2 * distancia_x - distancia_y;
for(i=0; i<=distancia_y; ++i)
{ GLCD_punto(x, y, color);
if(P < 0)
{ P += 2 * distancia_x;
y += incremento_y; }
else
{ P += 2 * distancia_x - 2 * distancia_y;
x += incremento_x;
y += incremento_y; }
}
}
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// Dibuja un rectángulo desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_rectangulo(int x1, int y1, int x2, int y2, int1 color)
{
GLCD_linea(x1,y1,x2,y1,color);
GLCD_linea(x1,y1,x1,y2,color);
GLCD_linea(x1,y2,x2,y2,color);
GLCD_linea(x2,y1,x2,y2,color);
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// Dibuja un rectángulo PINTADO desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_caja(int x1, int y1, int x2, int y2, int1 color)
{
//Declaro variables-------------------
int i;
for(i=y1;i<=y2;i++) {
GLCD_linea(x1,i,x2,i,color); }
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// Dibuja un circulo con centro en (x1,y1), radio y color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_circulo(int x1, int y1, int radio, int1 color)
{
signed int d, x, y;
//Inicializo las variables.
d = 1 - radio;
x = 0;
y = radio;
//Dibujo los cuatro pixeles que "caen" sobre los ejes cartesianos.
GLCD_punto(x1, y1 + radio, color);
GLCD_punto(x1, y1 - radio, color);
GLCD_punto(x1 + radio, y1, color);
GLCD_punto(x1 - radio, y1, color);
//Este es el bucle que pinta los octavos de la circunferencia.
while(x < y) {
if(d < 0) {d = d + 2 * x + 3;}
else {d = d + 2 * (x - y ) + 5;
y = y - 1 ;}
x = x + 1;
//Pone el punto en cada uno de los "octantes".
GLCD_punto(x1 + x, y1 + y, color);
GLCD_punto(x1 - x, y1 + y, color);
GLCD_punto(x1 + x, y1 - y, color);
GLCD_punto(x1 - x, y1 - y, color);
GLCD_punto(x1 + y, y1 + x, color);
GLCD_punto(x1 - y, y1 + x, color);
GLCD_punto(x1 + y, y1 - x, color);
GLCD_punto(x1 - y, y1 - x, color);
}
}
-
jajaja hasta el mismo fondo!!
-
jajaa si, la imagen la saque de google buscando la referencia d la mia, pero es esactamente igual,
y si, de las librerias de CCS fue q saque las mias para MPLAB, pero hay un problema con la funcion de leerbyte...
y no logro hacer que funcione... no se que podra ser, pero en las simulaciones nunca lee el dato y termina borrando el pixel anterior y sobreponiendo el nuevo.
Gracias.
-
:mrgreen: :-/ :mrgreen: :-/ :mrgreen: :-/ :mrgreen: :-/
MUCHAS GRACIAS CAMIGOD
:mrgreen: :-/ :mrgreen: :-/ :mrgreen: :-/ :mrgreen: :-/