TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: thegame en 23 de Julio de 2020, 15:13:08

Título: Error de visualización GLCD, con protocolo I2C [SOLUCIONADO]
Publicado por: thegame en 23 de Julio de 2020, 15:13:08

Buenas a todos compañeros, quiero saber si me pueden ayudar con lo siguiente:

Tengo una pantalla GLCD, 128X64, la cual la he probado y funciona correctamente, dicha pantalla la he conectado a un PIC18F26K22, para que la controle, lo cual hace, mostrandome texto e imagenes, este pic esta armado en una pcb, que a su ves, por medio del protocolo I2C, se comunica con otra pcb que realiza el papel de maestro, con un PIC18F46K22 (prácticamente son el mismo solo variando la memoria de programa).

Ahora, la comunicación maestro ----> esclavo (por I2C), es correcta, ya que la he comprobado enviandole un caracter (una letra) ó numero, y validándolo por medio de una condicional (algo como: if(dato=='a')), de modo que la comunicación es correcta, el dato enviado por parte del maestro y el recibido por parte del esclavo es correcto, por lo que compruebo que se entienden.

Ahora, lo que yo quiero y he intentado hacer y no logro es, que el dato que recibe el esclavo, sea un numero o caracter, lo dibuje en la GLCD

He intentado algo como:

Código: [Seleccionar]

sprintf(cadena_datos,"%u",dato_recibido);
glcd_text57(0,0,cadena_datos,1,1);
glcd_update();

Con lo que obtengo caracteres ilegibles, en la posicion que le indico, pero no dibuja el dato que llega por I2C al esclavo.

Es decir, si el maestro envia un 25, el esclavo lo recibe pero no dibuja en la GLCD el 25, dibuja cualquier cosa.

Ahora si yo hago:

Código: [Seleccionar]

cadena_datos[4]="hola";

glcd_text57(0,0,cadena_datos,1,1);
glcd_update();

Sin problema me escribe lo que la cadena tiene.

Es mas un problema de formato, pero he intentado de muchas formas, cambiando los identificadores %u,%c,%s,%d, etc etc etc sin exito
He intentado con funciones para convertir el numero en cadena y que al pasarlo a la funcion que escribe en el glcd sea ya una cadena, y nada

Alguien ha trabajado con ello, o sabe como deberia pasarle el dato a la funcion glcd_text57()?????????

Muchas gracias de antemano

Saludos

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: KILLERJC en 23 de Julio de 2020, 16:27:09

Código: C

1. cadena_datos[4]={0,0,0,0};
2.  
3. dato_recibido=25;
4. sprintf(cadena_datos,"%u",dato_recibido);
5. glcd_text57(0,0,cadena_datos,1,1);
6. glcd_update();

y

Código: C

1. cadena_datos[4]="25";
2.  
3. glcd_text57(0,0,cadena_datos,1,1);
4. glcd_update();

funcionan igual ? Sino es algun problema de libreria. Lo que hay que identificar es: Cual libreria

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: thegame en 23 de Julio de 2020, 18:03:46

Que tal KillerJc

ambas opciones que planteas, funcionan.

es cuando recibo desde el i2c, el dato proveniente del maestro, cuando falla.

En la interrupcion del esclavo tengo esto:

Código: [Seleccionar]

#INT_SSP
void recepcion_i2c(void)
{
   dato=i2c_read(GLCD);
   i2c_datos=1;
}

Y en el main ( ) del esclavo, proceso asi:

Código: [Seleccionar]

void main()
{
   //Configuracion y Plantilla base del GLCD
   configuracion();
   plantilla_base();
   
   //Ciclo infinito
   while(true)
   { 
      if(i2c_datos==1)
      {
         i2c_datos=0;
         sprintf(cadena_datos,"%u",dato);
         glcd_text57(73,18,cadena_datos,2,1);
         glcd_update();
         
      }
     
   }
}

y pues, no funciona, no se que estare haciendo mal

Saludos y gracias

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: remi04 en 23 de Julio de 2020, 18:36:04

Prueba al ponerle el monario * a :

  glcd_text57(73,18,*cadena_datos,2,1);

   A falta de ver más código, si estas usando bootloader.  Si usas protección de lectura/escritura de las secciones de memoria de bootloader pued darte problemas los punteros por ahí. Se han dado casos.

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: KILLERJC en 23 de Julio de 2020, 19:00:03

No creo que sea el problema.

Es raro lo que planteas... Por lo siguiente...., Esto:

Código: C

1. dato_recibido=25;
2. sprintf(cadena_datos,"%u",dato_recibido);
3. glcd_text57(0,0,cadena_datos,1,1);
4. glcd_update();

Todo esto suponiendo que sea un byte.
Es exactamente lo mismo que si dato es 25. Siendo que puede ser un numero de 0 a 255, entonces lo mas seguro es que cadena_datos tenga minimo 4 lugares. A no ser que lo uses para otra cosa. Lo unico que se podria plantear es que la recepcion es mala, aun asi el valor de dato estaria entre los valores y no existirian los problemas que comentas.

Respecto a lo planteado por Remi

Si es un array  escribir *cadena_datos[0] o cadena_datos no hay diferencia, *cadena_datos es el puntero del puntero. Ahora lo que no comprendo es como se protegeria la RAM, como el lo plantea, ya que el array esta en RAM.

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: thegame en 23 de Julio de 2020, 19:22:52

Remi, ya lo habia probado antes como lo planteas, y no funciona, el dato sigue dibujandose ilegiblemente.

Killer, la recepcion del i2c, por parte del esclavo, y la correspondiente transmision del maestro, la he corroborado, y funciona correctamente, el colocar algo como esto:

Código: [Seleccionar]

if(dato_recibido==25)
{
     output_high(PIN_B1);
}

sin problema se activa el pin, y si le envió desde el maestro, un numero diferente a 25, no se activa, lo que me hace pensar que se entienden entre ellos y que los datos se transmiten y reciben bien.

incluso, use el código de ejemplo que trae CCS, en el maestro:

Código: [Seleccionar]

unsigned int8wData[16];
int1 ack;

ack = i2c_transfer_out(0x10,1, 1);

if(ack==0)
     printf("\r\nData transferred successfully");
else
     printf("\r\nData transferred unsuccessfully");

Haciendo las adecuaciones adecuadas claro esta, y siempre obtengo la respuesta de transferencia satisfactoria.

Esa, cadena_datos, solo se usa para recibir lo que el maestro envia, y dibujarlo, para nada mas.

De verdad que no entiendo porque no dibuja el dato recibido como debe de ser.

Les comparto la librería que estoy usando, y el código del esclavo que al final es el del problema.

Saludos y gracias

Librería ST7920:

Código: [Seleccionar]

/************************************************************************
*   LCD graphics driver for Digole 12864w with ST7920 driver using       *
*   CCS software. May work with other ST7920 driven LCD. It has          *
*   the following Pin assignments                                        *
*                                                                        *
*   Pin 1 ------------> Gnd                                              *   
*   Pin 2 ------------> +5volts                                          *
*   Pin 3 ------------> Contrast                                         *
*   Pin 4 ------------> Register Select                                  *
*   Pin 5 ------------> Read/Write                                       *
*   Pin 6 ------------> Enable                                           *
*   Pin 7-14 ---------> Data bits                                        *
*   Pin 15 -----------> PSB (parallel=high & serial=low)                 *
*   Pin 16 -----------> NoConnection                                     *
*   Pin 17 -----------> Reset                                            *
*   Pin 18 -----------> Vout                                             *
*   Pin 19 -----------> +5volts                                          *
*   Pin 20 -----------> Gnd                                              *
*                                                                        *
*   This driver is using 8bit parallel operation for optimal RAM         *
*   requirements, if you want i can change it to 4 bit operation.        *
*                                                                        *
*   Developed by Christian Rebogio                                       *
*   suggestions and request please email me at                           *
*   christian.rebogio@gmail.com                                          *
*                                                                        *
* READ THE DATASHEET FOR ST7920!!!!!!!                                   *
************************************************************************/
// change the pin assignment depending on your circuit

#define  rs  PIN_C1                    //COMMNAD/DATA SELECT
#define  rw  PIN_C0                    //READ/WRITE SELECT             
#define  e   PIN_C2                    //ENABLE SIGNAL                 
#define  rst PIN_C5                    //RESET SIGNAL   

#define ON  1
#define OFF 0
#define YES 1
#define NO  0
#define XVAL 16  // 16 X 16 or 256 for there is 8 word values for the upper and lower
#define YVAL 32

// PSB is tied to Vcc for this driver because this driver uses Parallel
// operation.
// data is sent using port B so change output_b() to other ports you
//want to use. Dont for get to change the Busy pin @ lcd_check_busy

#define GLCD_WIDTH   128

/////////////////////////////////////////////////////////////////////////
//// Defines a 5x7 font
/////////////////////////////////////////////////////////////////////////
const unsigned int8 FONT[51][5] ={0x00, 0x00, 0x00, 0x00, 0x00, // SPACE
                         0x00, 0x00, 0x5F, 0x00, 0x00, // !
                         0x00, 0x03, 0x00, 0x03, 0x00, // "
                         0x14, 0x3E, 0x14, 0x3E, 0x14, // #
                         0x24, 0x2A, 0x7F, 0x2A, 0x12, // $
                         0x43, 0x33, 0x08, 0x66, 0x61, // %
                         0x36, 0x49, 0x55, 0x22, 0x50, // &
                         0x00, 0x05, 0x03, 0x00, 0x00, // '
                         0x00, 0x1C, 0x22, 0x41, 0x00, // (
                         0x00, 0x41, 0x22, 0x1C, 0x00, // )
                         0x14, 0x08, 0x3E, 0x08, 0x14, // *
                         0x08, 0x08, 0x3E, 0x08, 0x08, // +
                         0x00, 0x50, 0x30, 0x00, 0x00, // ,
                         0x08, 0x08, 0x08, 0x08, 0x08, // -
                         0x00, 0x60, 0x60, 0x00, 0x00, // .
                         0x20, 0x10, 0x08, 0x04, 0x02, // /
                         0x3E, 0x51, 0x49, 0x45, 0x3E, // 0
                         0x00, 0x04, 0x02, 0x7F, 0x00, // 1
                         0x42, 0x61, 0x51, 0x49, 0x46, // 2
                         0x22, 0x41, 0x49, 0x49, 0x36, // 3
                         0x18, 0x14, 0x12, 0x7F, 0x10, // 4
                         0x27, 0x45, 0x45, 0x45, 0x39, // 5
                         0x3E, 0x49, 0x49, 0x49, 0x32, // 6
                         0x01, 0x01, 0x71, 0x09, 0x07, // 7
                         0x36, 0x49, 0x49, 0x49, 0x36, // 8
                         0x26, 0x49, 0x49, 0x49, 0x3E, // 9
                         0x00, 0x36, 0x36, 0x00, 0x00, // :
                         0x00, 0x56, 0x36, 0x00, 0x00, // ;
                         0x08, 0x14, 0x22, 0x41, 0x00, // <
                         0x14, 0x14, 0x14, 0x14, 0x14, // =
                         0x00, 0x41, 0x22, 0x14, 0x08, // >
                         0x02, 0x01, 0x51, 0x09, 0x06, // ?
                         0x3E, 0x41, 0x59, 0x55, 0x5E, // @
                         0x7E, 0x09, 0x09, 0x09, 0x7E, // A
                         0x7F, 0x49, 0x49, 0x49, 0x36, // B
                         0x3E, 0x41, 0x41, 0x41, 0x22, // C
                         0x7F, 0x41, 0x41, 0x41, 0x3E, // D
                         0x7F, 0x49, 0x49, 0x49, 0x41, // E
                         0x7F, 0x09, 0x09, 0x09, 0x01, // F
                         0x3E, 0x41, 0x41, 0x49, 0x3A, // G
                         0x7F, 0x08, 0x08, 0x08, 0x7F, // H
                         0x00, 0x41, 0x7F, 0x41, 0x00, // I
                         0x30, 0x40, 0x40, 0x40, 0x3F, // J
                         0x7F, 0x08, 0x14, 0x22, 0x41, // K
                         0x7F, 0x40, 0x40, 0x40, 0x40, // L
                         0x7F, 0x02, 0x0C, 0x02, 0x7F, // M
                         0x7F, 0x02, 0x04, 0x08, 0x7F, // N
                         0x3E, 0x41, 0x41, 0x41, 0x3E, // O
                         0x7F, 0x09, 0x09, 0x09, 0x06, // P
                         0x1E, 0x21, 0x21, 0x21, 0x5E, // Q
                         0x7F, 0x09, 0x09, 0x09, 0x76};// R

const unsigned int8 FONT2[44][5]={0x26, 0x49, 0x49, 0x49, 0x32, // S
                         0x01, 0x01, 0x7F, 0x01, 0x01, // T
                         0x3F, 0x40, 0x40, 0x40, 0x3F, // U
                         0x1F, 0x20, 0x40, 0x20, 0x1F, // V
                         0x7F, 0x20, 0x10, 0x20, 0x7F, // W
                         0x41, 0x22, 0x1C, 0x22, 0x41, // X
                         0x07, 0x08, 0x70, 0x08, 0x07, // Y
                         0x61, 0x51, 0x49, 0x45, 0x43, // Z
                         0x00, 0x7F, 0x41, 0x00, 0x00, // [
                         0x02, 0x04, 0x08, 0x10, 0x20, // \
                         0x00, 0x00, 0x41, 0x7F, 0x00, // ]
                         0x04, 0x02, 0x01, 0x02, 0x04, // ^
                         0x40, 0x40, 0x40, 0x40, 0x40, // _
                         0x00, 0x01, 0x02, 0x04, 0x00, // `
                         0x20, 0x54, 0x54, 0x54, 0x78, // a
                         0x7F, 0x44, 0x44, 0x44, 0x38, // b
                         0x38, 0x44, 0x44, 0x44, 0x44, // c
                         0x38, 0x44, 0x44, 0x44, 0x7F, // d
                         0x38, 0x54, 0x54, 0x54, 0x18, // e
                         0x04, 0x04, 0x7E, 0x05, 0x05, // f
                         0x08, 0x54, 0x54, 0x54, 0x3C, // g
                         0x7F, 0x08, 0x04, 0x04, 0x78, // h
                         0x00, 0x44, 0x7D, 0x40, 0x00, // i
                         0x20, 0x40, 0x44, 0x3D, 0x00, // j
                         0x7F, 0x10, 0x28, 0x44, 0x00, // k
                         0x00, 0x41, 0x7F, 0x40, 0x00, // l
                         0x7C, 0x04, 0x78, 0x04, 0x78, // m
                         0x7C, 0x08, 0x04, 0x04, 0x78, // n
                         0x38, 0x44, 0x44, 0x44, 0x38, // o
                         0x7C, 0x14, 0x14, 0x14, 0x08, // p
                         0x08, 0x14, 0x14, 0x14, 0x7C, // q
                         0x00, 0x7C, 0x08, 0x04, 0x04, // r
                         0x48, 0x54, 0x54, 0x54, 0x20, // s
                         0x04, 0x04, 0x3F, 0x44, 0x44, // t
                         0x3C, 0x40, 0x40, 0x20, 0x7C, // u
                         0x1C, 0x20, 0x40, 0x20, 0x1C, // v
                         0x3C, 0x40, 0x30, 0x40, 0x3C, // w
                         0x44, 0x28, 0x10, 0x28, 0x44, // x
                         0x0C, 0x50, 0x50, 0x50, 0x3C, // y
                         0x44, 0x64, 0x54, 0x4C, 0x44, // z
                         0x00, 0x08, 0x36, 0x41, 0x41, // {
                         0x00, 0x00, 0x7F, 0x00, 0x00, // |
                         0x41, 0x41, 0x36, 0x08, 0x00, // }
                         0x02, 0x01, 0x02, 0x04, 0x02};// ~
/////////////////////////////////////////////////////////////////////////

const BYTE TEXT[51][5] ={0x00, 0x00, 0x00, 0x00, 0x00, // SPACE
                         0x00, 0x00, 0x5F, 0x00, 0x00, // !
                         0x00, 0x03, 0x00, 0x03, 0x00, // "
                         0x14, 0x3E, 0x14, 0x3E, 0x14, // #
                         0x24, 0x2A, 0x7F, 0x2A, 0x12, // $
                         0x43, 0x33, 0x08, 0x66, 0x61, // %
                         0x36, 0x49, 0x55, 0x22, 0x50, // &
                         0x00, 0x05, 0x03, 0x00, 0x00, // '
                         0x00, 0x1C, 0x22, 0x41, 0x00, // (
                         0x00, 0x41, 0x22, 0x1C, 0x00, // )
                         0x14, 0x08, 0x3E, 0x08, 0x14, // *
                         0x08, 0x08, 0x3E, 0x08, 0x08, // +
                         0x00, 0x50, 0x30, 0x00, 0x00, // ,
                         0x08, 0x08, 0x08, 0x08, 0x08, // -
                         0x00, 0x60, 0x60, 0x00, 0x00, // .
                         0x20, 0x10, 0x08, 0x04, 0x02, // /
                         0x3E, 0x51, 0x49, 0x45, 0x3E, // 0
                         0x04, 0x02, 0x7F, 0x00, 0x00, // 1
                         0x42, 0x61, 0x51, 0x49, 0x46, // 2
                         0x22, 0x41, 0x49, 0x49, 0x36, // 3
                         0x18, 0x14, 0x12, 0x7F, 0x10, // 4
                         0x27, 0x45, 0x45, 0x45, 0x39, // 5
                         0x3E, 0x49, 0x49, 0x49, 0x32, // 6
                         0x01, 0x01, 0x71, 0x09, 0x07, // 7
                         0x36, 0x49, 0x49, 0x49, 0x36, // 8
                         0x26, 0x49, 0x49, 0x49, 0x3E, // 9
                         0x00, 0x36, 0x36, 0x00, 0x00, // :
                         0x00, 0x56, 0x36, 0x00, 0x00, // ;
                         0x08, 0x14, 0x22, 0x41, 0x00, // <
                         0x14, 0x14, 0x14, 0x14, 0x14, // =
                         0x00, 0x41, 0x22, 0x14, 0x08, // >
                         0x02, 0x01, 0x51, 0x09, 0x06, // ?
                         0x3E, 0x41, 0x59, 0x55, 0x5E, // @
                         0x7E, 0x09, 0x09, 0x09, 0x7E, // A
                         0x7F, 0x49, 0x49, 0x49, 0x36, // B
                         0x3E, 0x41, 0x41, 0x41, 0x22, // C
                         0x7F, 0x41, 0x41, 0x41, 0x3E, // D
                         0x7F, 0x49, 0x49, 0x49, 0x41, // E
                         0x7F, 0x09, 0x09, 0x09, 0x01, // F
                         0x3E, 0x41, 0x41, 0x49, 0x3A, // G
                         0x7F, 0x08, 0x08, 0x08, 0x7F, // H
                         0x00, 0x41, 0x7F, 0x41, 0x00, // I
                         0x30, 0x40, 0x40, 0x40, 0x3F, // J
                         0x7F, 0x08, 0x14, 0x22, 0x41, // K
                         0x7F, 0x40, 0x40, 0x40, 0x40, // L
                         0x7F, 0x02, 0x0C, 0x02, 0x7F, // M
                         0x7F, 0x02, 0x04, 0x08, 0x7F, // N
                         0x3E, 0x41, 0x41, 0x41, 0x3E, // O
                         0x7F, 0x09, 0x09, 0x09, 0x06, // P
                         0x1E, 0x21, 0x21, 0x21, 0x5E, // Q
                         0x7F, 0x09, 0x09, 0x09, 0x76};// R

const BYTE TEXT2[44][5]={0x26, 0x49, 0x49, 0x49, 0x32, // S
                         0x01, 0x01, 0x7F, 0x01, 0x01, // T
                         0x3F, 0x40, 0x40, 0x40, 0x3F, // U
                         0x1F, 0x20, 0x40, 0x20, 0x1F, // V
                         0x7F, 0x20, 0x10, 0x20, 0x7F, // W
                         0x41, 0x22, 0x1C, 0x22, 0x41, // X
                         0x07, 0x08, 0x70, 0x08, 0x07, // Y
                         0x61, 0x51, 0x49, 0x45, 0x43, // Z
                         0x00, 0x7F, 0x41, 0x00, 0x00, // [
                         0x02, 0x04, 0x08, 0x10, 0x20, // \
                         0x00, 0x00, 0x41, 0x7F, 0x00, // ]
                         0x04, 0x02, 0x01, 0x02, 0x04, // ^
                         0x40, 0x40, 0x40, 0x40, 0x40, // _
                         0x00, 0x01, 0x02, 0x04, 0x00, // `
                         0x20, 0x54, 0x54, 0x54, 0x78, // a
                         0x7F, 0x44, 0x44, 0x44, 0x38, // b
                         0x38, 0x44, 0x44, 0x44, 0x44, // c
                         0x38, 0x44, 0x44, 0x44, 0x7F, // d
                         0x38, 0x54, 0x54, 0x54, 0x18, // e
                         0x04, 0x04, 0x7E, 0x05, 0x05, // f
                         0x08, 0x54, 0x54, 0x54, 0x3C, // g
                         0x7F, 0x08, 0x04, 0x04, 0x78, // h
                         0x00, 0x44, 0x7D, 0x40, 0x00, // i
                         0x20, 0x40, 0x44, 0x3D, 0x00, // j
                         0x7F, 0x10, 0x28, 0x44, 0x00, // k
                         0x00, 0x41, 0x7F, 0x40, 0x00, // l
                         0x7C, 0x04, 0x78, 0x04, 0x78, // m
                         0x7C, 0x08, 0x04, 0x04, 0x78, // n
                         0x38, 0x44, 0x44, 0x44, 0x38, // o
                         0x7C, 0x14, 0x14, 0x14, 0x08, // p
                         0x08, 0x14, 0x14, 0x14, 0x7C, // q
                         0x00, 0x7C, 0x08, 0x04, 0x04, // r
                         0x48, 0x54, 0x54, 0x54, 0x20, // s
                         0x04, 0x04, 0x3F, 0x44, 0x44, // t
                         0x3C, 0x40, 0x40, 0x20, 0x7C, // u
                         0x1C, 0x20, 0x40, 0x20, 0x1C, // v
                         0x3C, 0x40, 0x30, 0x40, 0x3C, // w
                         0x44, 0x28, 0x10, 0x28, 0x44, // x
                         0x0C, 0x50, 0x50, 0x50, 0x3C, // y
                         0x44, 0x64, 0x54, 0x4C, 0x44, // z
                         0x00, 0x08, 0x36, 0x41, 0x41, // {
                         0x00, 0x00, 0x7F, 0x00, 0x00, // |
                         0x41, 0x41, 0x36, 0x08, 0x00, // }
                         0x02, 0x01, 0x02, 0x04, 0x02};// ~
                         
//////////////////////////////////////////////////////////////////////////////////
//The following are the functions included in this driver file
// glcd_readbyte();
// glcd_instruction( instruction );
// glcd_data( data ); - data can be an array of characters!
// glcd_check_busy();
// glcd_update(); -must be called always after writing a pixel or using functions
//                 from GRAPHICS.C .. Only applicaticable in Graphing mode
// glcd_fillscreen( ON or OFF);
// glcd_init_graph(); initialize for graphing mode
// glcd_init_basic(); initilize for accessing the stored Characters
//                     you can use glcd_data() for writing text
// glcd_pixel(x coordinate, y coordinate, ON or OFF);
//            -WORKS WITH GRAPHIC.C  from CCS Drivers
// glcd_plot_image(width,height,X coor, Y coor, inverse);
//            -plots the image[] array. Declare it first before this driver.
//             or modify this driver
//
//////////////////////////////////////////////////////////////////////////////////



typedef union
{
  int16 word;
  int8 nbyte[2];
} Dots;

typedef struct
{
  int1 refresh;
  Dots pix[YVAL][XVAL];   // Max dimensions for display (x,y) = (128,32)
  } GD_RAM;             //  (0,0) corresponds to upper lefthand corner.

GD_RAM gdram;


unsigned int8 glcd_readByte (unsigned int1 address)
{
  unsigned int8 data;   // Stores the data read from the LCD
  if(address==1){
     output_high(rs);
  }
  if(address==0){
     output_low(rs);
  }
  output_high(rw);//GLCD_RW = RW_READ;      // Set for reading
  output_high(e);//GLCD_E = 1;      // Pulse the enable pin
  delay_us(1);
  data=input_b();      // Get the data from the display's output register
  output_low(e);//GLCD_E = 0;
  return (data);
}

 
void glcd_check_busy(){
   int1 busy=1;
   output_low(rs);      // LOW RS and High RW will put the lcd to
   output_high(rw);      // read busy flag and address counter
   while(busy){         // will cycle until busy flag is 0
      output_high(e);
      if(!input(PIN_B7)){
         busy=0;
      }
      output_low(e);
   }
}
 
void glcd_instruction(unsigned char x){
   glcd_check_busy();      //must be satisfied before sending instruction
   output_low(rs);      // LOW RS and LOW RW will put the lcd to
   output_low(rw);      // Write instruction mode
   output_b(x);         // 8bit data to bus
   output_high(e);      // enable
   delay_us(1);       
   output_low(e);      // disable
}

void glcd_data(unsigned char x){
   glcd_check_busy();
   output_high(rs);      // HIGH RS and LOW RW will put the lcd to
   output_low(rw);      // Write data register mode
   output_b(x);
   output_high(e);
   delay_us(1);
   output_low(e);
}
 

void glcd_fillScreen (unsigned int1 color)
{
  int8 v, h;
  int16 d;

  d = (color == ON ? 0xFFFFL : 0x0000L);

  for (v=0; v < YVAL; v++)
  {
    for (h=0; h < XVAL; h++)
    {
      gdram.pix[v][h].word = d;
    }
  }
  gdram.refresh = TRUE;
}

void glcd_update ()
{
   int8 v, h;
   if (gdram.refresh)
   {
     for (v = 0; v <YVAL; v ++) // 64
     {
       if (v <32) // first part
       {
          glcd_instruction (0x80 | v); // Set Vertical Address.
          glcd_instruction (0x80); // Set Horizontal Address.
       }
       else // second lcd stop
       {
          glcd_instruction (0x80 | (v - 32)); // Set Vertical Address.
          glcd_instruction (0x88); // Set Horizontal Address.
       }
       for (h = 0; h <XVAL; h ++) // 8
       {
         glcd_data (gdram.pix [v] [h] .nbyte [1]); // Write High Byte.
         glcd_data (gdram.pix [v] [h] .nbyte [0]); // Write Low Byte.
       }
     }
     gdram.refresh = FALSE;
   }
}

void glcd_init_graph(){
   delay_ms(40);
   output_low(rst);         //reset LCD
   delay_us(1);                     
   output_high(rst);        //LCD normal operation
   glcd_instruction(0x30);   //set 8 bit operation and basic instruction set
   delay_us(144);
   glcd_instruction(0x0C);   //display on cursor off and char blink off
   delay_us(100);
   glcd_instruction(0x01);   //display clear
   delay_ms(10);
   glcd_instruction(0x06);   //entry mode set
   delay_us(72);                 
   glcd_instruction(0x34);    // Select extended instruction set.
   delay_ms (10);
   glcd_instruction(0x36);    // Graphic display ON.
   delay_ms (10);

   glcd_fillScreen (OFF);
   glcd_update ();

}

void glcd_init_basic(){
   delay_ms(40);
   output_low(rst);         //reset LCD
   delay_us(1);                     
   output_high(rst);        //LCD normal operation
   glcd_instruction(0x30);   //set 8 bit operation and basic instruction set
   delay_us(144);
   glcd_instruction(0x0C);   //display on cursor off and char blink off
   delay_us(100);
   glcd_instruction(0x01);   //display clear
   delay_ms(10);
   glcd_instruction(0x06);   //entry mode set
   delay_us(72);                 
}

void glcd_pixel(int8 x, int8 y, int1 color)
{
  int8 v, h, b;
  if(y>31){x += 128; y-= 32;};
  v = y;
  h = x/16;
  b = 15 - (x%16);
 
  if (color == ON) bit_set (gdram.pix[v][h].word, b);
  else bit_clear (gdram.pix[v][h].word, b);

  gdram.refresh = TRUE;
}

//credits to http://www.ccsinfo.com/forum/viewtopic.php?t=32819&highlight=st7920//
///////////////////////////////////////////////////////////////////////////////////

//****************************************************************************//
// Purpose:       Write text on a graphic LCD                                 //
// Inputs:        (x,y) - The upper left coordinate of the first letter       //
//                textptr - A pointer to an array of text to display          //
//                size - The size of the text: 1 = 5x7, 2 = 10x14, ...        //
//                color - ON or OFF                                           //
// Dependencies:  glcd_pixel()                                                //
//****************************************************************************//
void glcd_text57(int x, int y, char* textptr, int size, int1 color)
{
   unsigned int8 j, k, l, m;                       // Loop counters
   unsigned int8 pixelData[5];                     // Stores character data

   for(; *textptr != '\0'; ++textptr, ++x)// Loop through the passed string
   {
      if(*textptr < 'S') // Checks if the letter is in the first font array
         memcpy(pixelData, FONT[*textptr - ' '], 5);
      else if(*textptr <= '~') // Check if the letter is in the second font array
         memcpy(pixelData, FONT2[*textptr - 'S'], 5);
      else
         memcpy(pixelData, FONT[0], 5);   // Default to space

      // Handles newline and carriage returns
      switch(*textptr)
      {
         case '\n':
            y += 7*size + 1;
            continue;
         case '\r':
            x = 0;
            continue;
      }

      if(x+5*size >= GLCD_WIDTH)          // Performs character wrapping
      {
         x = 0;                           // Set x at far left position
         y += 7*size + 1;                 // Set y at next position down
      }
      for(j=0; j<5; ++j, x+=size)         // Loop through character byte data
      {
         for(k=0; k < 7; ++k)             // Loop through the vertical pixels
         {
            if(bit_test(pixelData[j], k)) // Check if the pixel should be set
            {
               for(l=0; l < size; ++l)    // These two loops change the
               {                          // character's size
                  for(m=0; m < size; ++m)
                  {
                     glcd_pixel(x+m, y+k*size+l, color); // Draws the pixel
                  }
               }
            }
         }
      }
   }
}

void glcd_image_xy(int ancho, int alto,int x, int y, int1 inverse, unsigned char *imagen) //ancho maximo:128, alto maximo:64, x= fila, y=columna, inverse= invertir color, imagen= arreglo a dibujar)
{
   unsigned int i, j, k;
   unsigned int16 count=0;
   int width  = ancho;
   int height = alto;
   glcd_fillScreen(OFF);                        //Clears the screen (opt.)
   if(inverse)
   {
      for(i=0;i<height;i+=8)
      {   
         for(j=0;j<width;j++)
         {
            for(k=0;k<8;k++)
            {
               if(~bit_test(imagen[count],k))
               {
                  glcd_pixel(x+j,y+i+k,ON);
               }
            }
            count++;
         }
      }
   }
   else
   {
      for(i=0;i<height;i+=8)
      {   
         for(j=0;j<width;j++)
         {
            for(k=0;k<8;k++)
            {
               if(bit_test(imagen[count],k))
               {
                  glcd_pixel(x+j,y+i+k,ON);
               }
            }
            count++;
         }
      }
   }
}

Codigo del Esclavo:

Código: [Seleccionar]


//**************LIBRERIA PRINCIPAL PIC, FUSES, DELAY, CRISTAL
#include<18f26k22.h>
#fuses HSH,NOWDT,NOPROTECT,NOLVP,NODEBUG,NOBROWNOUT,PUT,NOPLLEN,NOFCMEN,NOIESO
#use delay(clock=20Mhz)

//*********************MAPEO DE PLANTILLA BASE DE PANTALLA GLCD**************************************
unsigned char plantilla_1_glcd [] = {
0xFF, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xFF, 0xFF, 0xFF
};

//************************MAPEO DE LOGO MCU TRONICS************************************************
unsigned char splash_glcd [] = {
0xFF, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x87, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x87, 0x87, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x80, 0xF0, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xF8, 0xF0, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x80, 0x80, 0xC0, 0xF0, 0xF8, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xF0, 0xC0, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xF0, 0xF8, 0xFC, 0xFC, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x07, 0x03, 0x03, 0x03, 0x03, 0x07, 0x07, 0x07, 0x0F, 0x1E, 0x1C, 0x3C, 0x38, 0x38,
0x20, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xF0, 0xFE,
0xFF, 0x3F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFC, 0xF8,
0x7C, 0x3E, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xF0,
0x80, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
0x80, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0xFF, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFE, 0xFF, 0x7F, 0x0F,
0x01, 0x00, 0x00, 0x00, 0x03, 0x03, 0x0F, 0x0F, 0x3F, 0x3F, 0x3F, 0x1F, 0x0F, 0x07, 0x01, 0x00,
0x00, 0x00, 0x00, 0x03, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFE, 0xF0, 0xC0, 0x01, 0x03, 0x0F, 0x0F, 0x3F, 0x3F, 0x7F, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF8, 0xC0, 0xC0, 0xC0, 0xE0, 0xE0, 0xE0, 0xE0, 0x70, 0x70, 0x3C, 0x3E, 0x1F, 0x0F,
0x07, 0x03, 0x00, 0x0F, 0x3F, 0x3F, 0x7F, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xC0, 0xC0, 0xC0, 0xC0, 0xE0, 0xE0, 0xE0, 0xE0, 0xF0, 0x78, 0x7C, 0x3F, 0x1F, 0x0F, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0xCE, 0xCE, 0xCE,
0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE,
0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0x8E, 0x8E, 0x8E, 0x0E, 0x0E, 0x0E, 0x8E, 0x8E, 0xCE,
0xCE, 0xCE, 0xCE, 0x4E, 0xCE, 0xCE, 0xCE, 0x8E, 0x8E, 0x8E, 0x0E, 0xCE, 0xCE, 0xCE, 0x8E, 0x8E,
0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0xCE, 0xCE, 0x0E, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE,
0xCE, 0x0E, 0x0E, 0x8E, 0x8E, 0xCE, 0xCE, 0xCE, 0xCE, 0x4E, 0xEE, 0xEE, 0xCE, 0xCE, 0x8E, 0x8E,
0x0E, 0x8E, 0xCE, 0xCE, 0xCE, 0xEE, 0xEE, 0xEE, 0xCE, 0xCE, 0x8E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E,
0x0E, 0x0E, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xC0, 0xC0, 0xC0, 0xE0, 0xE1, 0x77, 0x7F, 0x3E, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x01, 0x81, 0x83, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x7F, 0x7F, 0x7F,
0x7F, 0x7F, 0xFE, 0xFE, 0xFE, 0xFC, 0xFC, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x00, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x81, 0x81, 0xC3, 0xC3,
0xCF, 0x9F, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFD, 0xF9, 0xF0, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03,
0x03, 0x03, 0x03, 0x03, 0x01, 0x03, 0x03, 0x03, 0x03, 0x02, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03,
0x03, 0x03, 0x03, 0x02, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
0x03, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01,
0x01, 0x03, 0x03, 0x07, 0x07, 0x07, 0x07, 0x07, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0,
0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0,
0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0,
0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0,
0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0,
0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0,
0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0,
0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xE0, 0xFF, 0xFF, 0xFF
};

//***************LIBRERIAS AUXILIARES***************************
#include"ST7920.h"
//#include<stdlib.h>
//#include <graphics.c>
//****************PERIFERICOS************************************
#use i2c(SLAVE,SCL=PIN_C3,SDA=PIN_C4,ADDRESS=0x10,SLOW=100000,FORCE_HW,STREAM=GLCD)

//****************PROTOTIPOS DE FUNCIONES************************
void configuracion(void);
void plantilla_base(void);

//****************VARIABLES**************************************
char titulo_texto[20]="Despachador de Agua";
char signo_pesos[2];
char recibido[10]="Recibido:";
char cadena_datos[5]={' ',' ',' ',' ',' '};
unsigned int8 dato=0,dato_r=0;
int1 i2c_datos=0;

//***************INTERRUPCIONES*********************************
#INT_SSP
void recepcion_i2c(void)
{
   dato=i2c_read(GLCD);
   i2c_datos=1;
}
//Funcion main()
void main()
{
   //Configuracion y Plantilla base del GLCD
   configuracion();
   plantilla_base();
   
   //Ciclo infinito
   while(true)
   { 
      if(i2c_datos==1)
      {
         i2c_datos=0;
         sprintf(cadena_datos,"%u",dato);
         glcd_text57(73,18,cadena_datos,2,1);
         glcd_update();
         
      }
     
   }
}

void configuracion(void)
{
   //Habilitacion de interrupciones
   enable_interrupts(INT_SSP);
   enable_interrupts(PERIPH);
   enable_interrupts(GLOBAL);
   clear_interrupt(INT_SSP);
   //Inicializacion de GLCD
   glcd_init_graph();
   //Dibujamos el splash del logo MCU Tronics
   //glcd_image_xy(128,64,0,0,NO,splash_glcd);
   //glcd_update();
   //delay_ms(2000);
}

void plantilla_base(void)
{
   //Dibujamos la plantilla base
   glcd_image_xy(128,64,0,0,NO,plantilla_1_glcd);
   //Colocamos todos los textos
   glcd_text57(6,4,titulo_texto,1,1);
   glcd_text57(4,21,recibido,1,1);
   sprintf(signo_pesos,"$");
   glcd_text57(60,18,signo_pesos,2,1);
   //Dibujamos los textos y la plantilla
   glcd_update();
}


Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: thegame en 23 de Julio de 2020, 19:41:36

adjunto imagen de como dibuja el dato que le envió, en este caso, se le envió un 25.

  - Tienes que ingresar para ver archivos adjuntos -  

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: KILLERJC en 23 de Julio de 2020, 20:04:19

Eso no parece que sea el 25 el problema (envio,recepcion, ya que el 25 está)... Sino como que en ese lugar el 25 sale mal... Probaste algun codigo enviando el 25 unicamente, de esa forma y en el mismo lugar del LCD?

O sera que las otras partes escritas traen el problema y es problema del LCD...

El envio y recepcion, funcionan.
Escribir en el LCD tambien. Y se nota claramente el 25, funciona en otras partes. imagino que eso es el 1,1 las coordenadas de comienzo. Por lo que las librerias funcionan.
Ahi se logra ver que es el 25, si funciona bien para las posiciones 1,1, entonces funcionaria correctamente para las posiciones esas que tenes.
Por eso tal ves sea algo del LCD.

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: thegame en 23 de Julio de 2020, 20:17:33

Si lo hago dibujar con el otro código expuesto, es decir sin involucrar el dato recibido desde el maestro, lo dibuja a la perfección en la misma posición exacta.

se los muestro:

  - Tienes que ingresar para ver archivos adjuntos -  

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: thegame en 23 de Julio de 2020, 20:25:58

Lo he echo dibujar en otra posicion del GLCD, tomando en cuenta el caracter recibido desde el maestro, y tiene el mismo efecto, mal mal remal:

  - Tienes que ingresar para ver archivos adjuntos -  

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: KILLERJC en 23 de Julio de 2020, 20:29:27

pregunta... RAM ocupada? que no estemos teniendo problemas por eso.

Listemos que cosas funcionan y que no..

Conversion a decimal - SI
Comunicacion - SI
LCD - SI
Librerias - SI

Lo mas raro es que es el MISMO patron en ambos...

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: thegame en 23 de Julio de 2020, 20:36:28

Tengo actualmente el 81% ocupada, la ocupan una imagen que uso de presentacion al arranque, un splash, y la otra es la plantilla, los marcos basicamente.

Permiteme y saco una, y pruebo....

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: thegame en 23 de Julio de 2020, 20:41:42

Negativo, la reduje hasta el 29%, y sigue mal

y si, es el mismo patron mal dibujado sin importar a donde lo mueva o incluso variando el tamaño.

saludos

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: KILLERJC en 23 de Julio de 2020, 20:44:11

Bueno ultima prueba.... con reduccion del 29% por las dudas.


Recibir el dato, comprobarlo con dato == 25
Convertirlo a ASCII, comprobarlo con cadena_datos[0] == '2' && cadena_datos[1] =='5' && cadena_datos[2] == 0

Si todo esta perfecto, entonces pasamos a ver si es algo de la libreria del GLCD. Al menos te ayudaria a encerrar un poco mas el problema y si es posible un debugger mejor.

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: thegame en 23 de Julio de 2020, 21:29:32

Corrigeme si estoy mal Killer, para la conversion a ASCII, es correcto asi:

Código: [Seleccionar]

a=(int)dato/10;
dato=dato-(a*10);
b=(int)dato/1;
         
cadena_datos[0]="0"+a;
cadena_datos[1]="0"+b;

En alguna otra prueba que hice, envie desde el maestro, una 'a', y en el esclavo revisaba ese mismo caracter y me lo corroboraba sin problema

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: thegame en 23 de Julio de 2020, 21:39:43

Corrección, hice lo siguiente dentro del main, en el ciclo infinito, teniendo ocupada solo el 29% de la RAM:

Código: [Seleccionar]

while(true)
   { 
      if(i2c_datos==1 && dato==25)
      {
         i2c_datos=0;
         
         a=(int)dato/10;
         dato=dato-(a*10);
         b=(int)dato/1;
         
         cadena_datos[0]=a+'0';
         cadena_datos[1]=b+'0';
         
         if(cadena_datos[0]=='2' && cadena_datos[1]=='5')
         {
            glcd_text57(73,18,recibido_ok,2,1);
            glcd_update();
         }
         
      }
     
   }

y obtuve en pantalla:

  - Tienes que ingresar para ver archivos adjuntos -  

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: KILLERJC en 23 de Julio de 2020, 22:27:50

Eso quiere decir que esta correctamente el 25 en cadena_datos...

Ojo, recorda que necesitas terminarlo con un 0 en cadena_datos[2]. Y podes enviar eso al LCD

Ya con cadena_datos[0] = '2', en [1] = '5' y en [2] = '\0' (ó cero - 0)  podrias enviarle al LCD...

Deberia darte el mismo error, ya que aca todo comprueba que la conversion es correcta, se esta recibiendo lo correcto, etc. luego solo resta ver el codigo de la libreria.

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: thegame en 24 de Julio de 2020, 03:02:10

pues, dicho y echo, agregue lo que me faltaba, en la posicion cadena_datos[2] (el cero), y el error, es el mismo, no hace falta subir foto, es identico.  :(

voy a ver si encuentro algo en la libreria, agradezco y agradecere mucho tu apoyo Killer, y de todos los compañeros

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: remi04 en 24 de Julio de 2020, 07:49:26

  ¿El puerto del glcd está compartiendo el mismo I2c??, o es SPI compartiendo líneas SDA SCL ?? 

    Haz una comunicación I2C, una vez hecha envíale al glcd otro valor cualquiera desde una variable, y no el valor recibido.

    Si te aparece el error es posible que el fallo sea que de alguna manera esa comunicación i2C entre máster y slave este enviando algo al glcd previamente.

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: thegame en 24 de Julio de 2020, 10:17:30

Que tal remi04, el I2C esta independiente de las conexiones del GLCD, la comunicacion entre maestro y esclavo es correcta, la hemos descartado paso a paso con Killer.

Ahora, la parte de envio desde otra variable, funciona correctamente, al punto de que, cualquier dato que le mandas a la GLCD proveniente desde el PIC que la controla (interno digamos), lo dibuja correctamente, y el dato que proviene desde el maestro (externo), aunque correcto el dato, no lo dibuja correctamente.

Saludos y seguimos probando

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: KILLERJC en 24 de Julio de 2020, 11:06:43

Eso me preocupa, porque de un OK a un 25 no hay diferencias. Son dos lugares de memoria + un caracter nulo por igual en ambos casos.

Las únicas diferencias pueden ser donde están almacenados (direcciones si estan en RAM) Un error en RAM no debería provocar esto, ya que estaría escribiendo y leyendo otra cosa.. Por lo tanto no seria correcto, un error de acceso tal ves. Ya que sabemos que el 25 esta, pero con caracteres extras. Por otra parte, escribiéndolo normalmente al 25 funciona bien, por lo que no debería tener problemas.

Cosas a probar.

- Podes mostrar como estas definiendo el OK y el array cadena_datos?
- Podes cambiar de lugar el cadena_datos, dentro de lo que definís las variables? (ponerlo al principio, o definirlo dentro del mismo if, asi se crea allí. O déjalo y definimos otro array

Código: C

1. while(true)
2.    {
3.       if(i2c_datos==1)
4.       {
5.          i2c_datos=0;
6.          char test[3];
7.          test[2]='\0';
8.  
9.          a=(int)dato/10;
10.          dato=dato-(a*10);
11.          b=(int)dato/1;
12.          
13.          test[0]=a+'0';
14.          test[1]=b+'0';
15.          
16.          glcd_text57(73,18,test,2,1);
17.          glcd_update();
18.       }
19.    }

- Ocurre con todos los números probaste un 52, 32, 28 como para ver si los errores se mantienen en todos los digitos, o únicamente el 2 y el 5.
- Probaste otro tamaño ( el 1 que seria el mas simple dentro del algoritmo )


Sino ya pasamos a modificar la libreria del GLCD para tratar de entender que esta pasando. Ya que es lo unico que tenemos para ver cual es el posible problema.

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: Duende_Azul en 24 de Julio de 2020, 12:00:14

Antes de escribir un nuevo carácter, tienes que borrar el anterior, la lcd no lo hace automáticamente...


glcd_text57(73,18,test_ant,2,0); //Esto escribe el carácter anterior pero apagando los pixeles
glcd_update();

glcd_text57(73,18,test,2,1);      //Escribe el nuevo carácter
glcd_update();

También puedes limpiar toda la pantalla y reescribirla de nuevo pero se ve mucho parpadeo y muy pirata...

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: KILLERJC en 24 de Julio de 2020, 12:39:07

No entiendo que tiene que ver una cosa con la otra....

El script reescribe un bloque de 5x7 por cada caracter, y dependiendo del tamaño lo que hace es multiplicarlo, es decir 10x14, 15x21
Escribe tanto los 0, como los 1. Por lo que el bloque deberia verse bien.

Ademas por lo comentado el problema esta cuando se se usa lo recibido por el I2C, pasado a ASCII en un string y luego mostrarlo, ya que mostrar el mismo numero pero sin recibirlo funciona perfecto como podes ver en las imagenes.

La pregunta es ya que es el mismo contenido....

¿Cual es la diferencia entre crear una string en memoria, o usar un algun string ya "prearmado"? Y lo unico que veo es el lugar de almacenamiento.
Pero si fallara el lugar de almacenamiento, entonces significa que escribiria cualquier cosa. Ya que vos guardas un 2, y podes leer un 8 supongamos si falla algun bit. Pero este no es el caso.
Se puede ver el 2 y el 5 claramente en la imagen, pero con algunos "extras".

¿Sera que esta activado el I2C y sea un problema de hardware? Imposible, ya que mostramos que al recibir y transformar correctamente el 25 en "25" pero mostrando la palabra "OK" funciona perfecto.

Poco a poco fuimos probando y dividiendo el problema. El proximo paso que queda probar es el acceso a memoria del script que muestra en el LCD. Que los datos traidos de memoria sean los correctos.
Pero con un string fijo funciona, entonces el acceso a la FLASH donde esta contenido no "debería" ser el problema. Entonces .... Tengo un '2' en ambos casos. Lo se porque vemos el 2. En uno lo dibuja bien y en otro no. Algo falla en este punto.

Por que al buscar el segundo bit, en ves de recibir:
0x42, 0x61, 0x51, 0x49, 0x46,

Esta escribiendo:

0x42, 0x65, 0x53, 0x7F, 0x46,


- ¿Lo lee mal de la Flash?
- ¿El script esta haciendo algo raro? ¿Que cambia con una letra almacenada en algún lado y en otro ?
- ¿Es problema del compilador, generando algun codigo raro en ese momento?

Ruido no parece ser porque en multiples imagenes, tenes el mismo problema, los mismos valores.

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: thegame en 24 de Julio de 2020, 15:40:39

esta de locos esto.

Killer:

-Si he probado cambiar la declaración a otro sitio y el problema es el mismo
-Ocurre con todos los números, sin excepción
-El tamaño lo he cambiado hasta 4, y lo mismo, el problema se replica

Ahora me ha metido la duda Duende, y si se esta sobreescribiendo otro dato, y por eso se ve asi???

Pero....de donde?? del maestro??? al final estoy poniendo a trabajar el PIC como un dispositivo I2C, no es un CI puramente I2C como lo seria un expansor por ejemplo, e igual se esta dejando algo previo

Tengo que revisar y sigo probando

saludos y muchas gracias por la ayuda, espero porder resolverlo

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: remi04 en 24 de Julio de 2020, 17:57:40

Yo sigo pensando que el problema aparece solo y únicamente cuando se produce una transmisión I2c.

   Me explico:

     - generas una variable y la inicializas con valor 25.
     - envías la variable al glcd y el 25 aparece perfecto.

    El otro caso:

     - generas igualmente una variable y la inicializas con valor 25.
     - haces una transmisión I2c “por hacerla”, no vamos a utilizar su valor, solo me interesa que se produzca la operación. I2c
      - envías la variable al glcd.  No la recibida por I2c sino la generada.

     ¿Aparece el problema o se sigue viendo bien el 25? 

Título: Re:Error de visualización GLCD, con protocolo I2C
Publicado por: thegame en 25 de Julio de 2020, 02:41:40

Que tal remi04, tal como lo planteas, mi respuesta es, se sigue viendo correctamente y el problema no ocurre

Título: Re:Error de visualización GLCD, con protocolo I2C [SOLUCIONADO]
Publicado por: thegame en 25 de Julio de 2020, 03:17:40

Bueno muchachos, pues al fin funciona, ni Killer,ni remi04, ni mucho menos yo tenia razon, Duende Azul, tenias razon.

Voy a tratar de explicar lo mejor que pueda

Cuando Duende hizo el comentario de tener que borrar el caracter anterior antes de escribir el que queria (que claramente se dibujaba la silueta, me puse a observar con detenimiento justo el momento cuando dibujaba, y aunque era muy dificil, se notaba que ponia algo antes, parpadeaba.

entonces, pues fui al lugar que nunca sospeche, el codigo del maestro, solo pondre el main() para simplificar, este es mi codigo de prueba:

Código: [Seleccionar]

void main(void)
{
   init_device();
   
   delay_ms(1000);
   
   i2c_start(i2c_maestro);
   i2c_write(i2c_maestro,0x10);
   i2c_write(i2c_maestro,25);
   i2c_stop();
   
   while(true)
   {
     
   }
}

Ok, como se ve, envio la direccion del esclavo, y despues el dato, como se haria normalmente con cualquier dispositivo I2C, o al menos asi lo hago yo, con lo que yo no contaba, era que, el dato de la direccion del esclavo, tambien lo tomaba como un valor valido a procesar, yo pense que lo descartaba al momento de coincidir con la direccion del esclavo, y era el siguiente dato (mi amado 25) el que tomaria, pues no, el puñetero 0x10, se metia, que en decimal es un 16, y ese señores, es el que se colaba detras del 25.

He echo la modificacion similar a como la planteo Duende Azul, quedando asi:

Código: [Seleccionar]

void main()
{
   //Configuracion y Plantilla base del GLCD
   configuracion();
   plantilla_base();
 
   //Ciclo infinito
   while(true)
   { 
      if(i2c_datos==1)
      {
         i2c_datos=0;
         
         sprintf(cadena_datos,"%u",dato);
         glcd_text57(10,10,cadena_datos,4,0);
         sprintf(cadena_datos,"%u",dato);
         glcd_text57(10,10,cadena_datos,4,1);
         glcd_update();       
      }
     
   }
}

y ahora si, funciona, me muestra el bellisimo 25, integro, nitido, y sin pixeles añadidos, ese o cualquier numero, o letra

creo que tal ves lo correcto seria, antes de escribir el dato final, borar el area a trabajar, no toda la pantalla como bien lo apuntaba Duende Azul, solo un recuadro digamos, y despues de ello, ahora si, escribir el dato final

mi teoria es que, como el PIC no es un componente puramente I2C, tiene detalles como este, de no excluir la direccion propia y tomarlo como un dato, o al menos no lo hace del modo como lo haria un componente puramente I2C, llamese un DS1307, por ejemplo, o similar.

Si existe alguna manera, o funcion, que pueda implementar y mejorar esto, se los agradecere mucho, asi como doy gracias al buen Killer, a remi04, y por su puesto a Duende Azul por la atencion y ayuda prestada, sin su ayuda no se hubiera logrado, como siempre, orgulloso de pertenecer a una comunidad tan colaboradora como lo es TodoPIC.

Si existe alguna duda en la que pueda ayudar del tema, no duden en preguntarme

Saludos compañeros

Título: Re:Error de visualización GLCD, con protocolo I2C [SOLUCIONADO]
Publicado por: KILLERJC en 25 de Julio de 2020, 11:08:59

Eso me pasa por asumir que la libreria del GLCD escribiria los 0 tambien. Y en parte mejor que no era asi.

Pero en fin esto no paso por tener que "borrar" para escribir algo. Ya que esto quiere decir que hay algo pre-existente en el GLCD. Y supuestamente no era el caso nuestro. Si lo borrabas y escribis en el GLCD, el problema seguiria existiendo. Y podria haberte afectado en otra parte, hasta que llegues al tema del I2C.

El problema estaba en el manejo del I2C, y si este tiene la obligacion de recibir la direccion, ya que podes usar cualquier direccion, distinto de otro integrado donde la direccion es "fija" pero por dentro es lo mismo.

Bueno... menos mal que se soluciono, sino ya le estaba buscando algun problema al compilador. Sirve de experiencia xD.

Título: Re:Error de visualización GLCD, con protocolo I2C [SOLUCIONADO]
Publicado por: Duende_Azul en 25 de Julio de 2020, 11:32:29

Cita de: KILLERJC en 25 de Julio de 2020, 11:08:59

... ya le estaba buscando algun problema al compilador. Sirve de experiencia xD.

Ese es mi mayor temor en la vida... que el problema sea del compilador...  :D

Título: Re:Error de visualización GLCD, con protocolo I2C [SOLUCIONADO]
Publicado por: thegame en 25 de Julio de 2020, 14:06:58

que tal chicos, el asunto es que, cuando por ejemplo manejas un dispositivo I2C, el ejemplo que puse el DS1307 (RTC), el maestro envia al bus la direccion del reloj, el reloj la reconoce y a partir de ahi puedes comunicarte con el exclusivamente.

entonces, si digamos la direccion del reloj es 0xA0, el reloj no usa ese dato para modificar ninguno de sus registros, solo lo reconoce y hasta ahi, es hasta el siguiente dato que lo trabaja para sus registros.

en el caso de mi PIC no sucede asi, su direccion es 0x10, la reconoce, y la usa como dato para mostrar en el glcd, no la ignora, a eso me referia

saludos

Título: Re:Error de visualización GLCD, con protocolo I2C [SOLUCIONADO]
Publicado por: KILLERJC en 25 de Julio de 2020, 14:59:19

Bueno pero en este caso es un dispositivo programado... que ofrece la opcion de pasar la direccion, por que puede tener varias direcciones, para distintas partes (dentro del mismo micro) o por otros motivos.

Citar

The SSPxADD register (Register 15-7) contains the Slave mode address. The first byte received after a Start or Restart condition is compared against the value stored in this register. If the byte matches, the value is loaded into the SSPxBUF register and an interrupt is generated. If the value does not match, the module goes Idle and no indication is given to the software that anything happened

Es decir solo las direcciones que coinciden generan una interrupcion y permiten la llegada de datos. En este caso no tiene sentido que pase la direccion, y es el funcionamiento de tu dispositivo (sensor, rtc, etc).

PERO...

Ademas tenes una mascara.

Citar

An SSPx Mask (SSPxMSK) register (Register 15-6) is available in I2C Slave mode as a mask for the value held in the SSPxSR register during an address comparison operation. A zero (‘0’) bit in the SSPxMSK register has the effect of making the corresponding bit of the received address a “don’t care”.

Donde podes crear un cierto "rango" de direcciones, en los cuales podes recibir tus datos, o por ejemplo si quisieras analizar todo el trafico de I2C y enviarlo por UART a una PC.
O tener la direccion con terminacion 1 para una cosa, y la terminacion 2 para otra.
Es necesario tener el valor de la direccion para saber a que se dirige y por lo tanto necesitas si o si el valor de la dirección.

Sino estarías acotando el funcionamiento del I2C. Y como todo, aumenta la complejidad del modulo (entenderle, usarlo, crearlo) pero permite mas cosas.

Por lo que no lo veo como algo "malo", lo malo fue que no lei el datasheet antes :P jeje y asumi igual que vos que la direccion no pasaba.

Título: Re:Error de visualización GLCD, con protocolo I2C [SOLUCIONADO]
Publicado por: remi04 en 25 de Julio de 2020, 15:12:35

Yo cuando he trabajado I2c en slave con un pic he recibido primero la dirección y si es la deseada atendía una interrupción donde enviaba ACK y recibía el siguiente dato.

  Luego no solo eso, sino que ademas comprobaba si a continuación hay condición de stop o de re-start. Por si el máster me quiere enviar varios bytes seguidos.

   Lo que pasa es que lo hago todo manejando manualmente el módulo y no tirando de librerías. Daba por sentado que la librería Haría todo eso, y más en CCS.

 

Título: Re:Error de visualización GLCD, con protocolo I2C [SOLUCIONADO]
Publicado por: KILLERJC en 25 de Julio de 2020, 15:31:36

Tenes que ver el micro... Este micro posee todo eso.. Los micros mas viejos no y habia que hacerlo como vos los planteas.

Si la direccion no es la correcta, ni avisa al software.
Si vos no lees el dato y el buffer esta lleno, automaticamente manda un NACK
Si recibe un dato envia el ACK.

Y asi... pero podes hacerlo por software si lo deseas. Pudiendo generar un NACK si esta ocupado el micro por ejemplo al detectar cierta direccion.

Te digo que uno de los grandes dolores de cabeza era generar esa maquina de estado.. Interrupcion por un start, interrupcion por un stop, etc, etc. Ahora es mucho mas sencillo xD.

Título: Re:Error de visualización GLCD, con protocolo I2C [SOLUCIONADO]
Publicado por: thegame en 25 de Julio de 2020, 15:37:13

Completamente de acuerdo Killer,remi04, asumí que operaria de cierto modo y cometí el error de no leerme la parte del I2C del datasheet nuevamente, es que muchas veces tenemos tan mecanizada cierta acción o proceso que cuando pasa algo fuera de lo que acostumbramos ver, sucede esto jejeje, lección, aprendida

al menos queda la experiencia para no cometer el mismo error y al contrario, mejorar el proceso