Drives do display Grafico G128641BNHDWB

[rebelk]

e ai jerek consigui mais alguma coisa com as funçoes do glcd,
estou apanhando pra dedeu e ainda não consegui entender como
é que depois de convertido o desenho para .bas como é q é organizado para ser gravado na eeprom , ele cria umas matrizis
de valores , é ai onde me amarro, vc poderia me explicar como é isso ?

[__JEREK__]

e ai jerek consigui mais alguma coisa com as funçoes do glcd,
estou apanhando pra dedeu e ainda não consegui entender como
é que depois de convertido o desenho para .bas como é q é organizado para ser gravado na eeprom , ele cria umas matrizis
de valores , é ai onde me amarro, vc poderia me explicar como é isso ?

é rebelk, a coisa é complicada mesmo!!! tambem estou tentando entender esses drives, o estranho é que para armazenar os icones ele colocou de uma forma e a figura grande ele armazenou de uma outra forma.

os outros drives que vc achou são para Hitech, ai complica.

no maximo o que consigo fazer é mostrar um figura 4x4 na tela, escrever na tela usando os caracteres da CG RAM, mas não entendo como alterar o tamanho da figura para, por exemplo, colocar uma figura na tela todo ou 3x4.

e vc como esta ai??

[rebelk]

é meu caro eu tambem estou apanhando pra caramba,
se eu conseguir alguma coisa a mais te dou um toque ,
valeu garoto!

[__JEREK__]

bom, pelo menos agente sabe que os drives funcionam, é só questão de tempo até entender ele.

[rebelk]

OLHA AI QUE LOUCURA

http://www.casemodbr.com/forum//viewtop ... d1d15e1172

[rebelk]

OS CARAS SÃO CRIATIVOS

http://www.casemodbr.com/forum/viewtopi ... 7898958982

[rebelk]

controladora t6963c


http://www.cc.isel.ipl.pt/Pessoais/Ezeq ... t6963c.pdf

http://www.deetc.isel.ipl.pt/microproce ... nloads.htm

[rebelk]

jerek da uma olhada

http://www.quickbuilder.co.uk/qb/preview/index.htm

[rebelk]

progama glcd


http://www.quickbuilder.co.uk/qb/projects/glcd.htm

[__JEREK__]

http://liquid-mp3.schijf.org/index.php?content=photo

[__JEREK__]

rebelk, dá sinal de vida aê meu irmãozinho, vê se esse material que preparei lhe ajuda em alguma coisa.

Fiz dua novas funções para os drives do T6963, na verdade nas duas se completam, mas acho que vai facilitar para fazer janela com qualquer tamanho que escolher e qualquer posição da tela. Recomendo que coloque essas duas funções no arquivo T6963.C.

a primeira é fazJanela(); que pega caracteres em um lugar pre-definido na CG RAM para criar os cantos da janela (só os cantos).

Código: Selecionar todos

void fazJanela(int go_row, int go_col, int row, int col, int CG)
{

  int row_cont = 0;
  int col_cont = 0;

    for(row_cont=0; row_cont <row; row_cont++){
       for(col_cont =0; col_cont <col; col_cont++){

             if((col_cont == 0)&&(row_cont == 0))
                {
                    GDispCGCharAt(col_cont+go_col, row_cont+go_row, cg++);
                }

             if((col_cont == (col -1))&&(row_cont == 0))
                {
                    GDispCGCharAt(col_cont +1+go_col, row_cont+go_row, cg++);
                }
         }

         col_cont =0;

             if((col_cont == 0)&&(row_cont == (row -1)))
                {
                    GDispCGCharAt(col_cont+go_col, row_cont+1+go_row, cg++);
                }
     }
  GDispCGCharAt(col+go_col, row+go_row, cg++);

}

a segunda é FazBorda() que coloca a borda da janela:

Código: Selecionar todos

// coloca bordas nas janelas
void FazBorda(int go_row, int go_col, int row, int col, int CG)
{

  int row_cont = 0;
  int col_cont = 0;


  for(row_cont=0; row_cont< row; row_cont++)
  {
   for(col_cont =0; col_cont< col; col_cont++)
   {

      if((row_cont>0)&&(row_cont<row)&&(col_cont==col-1))
        {
            GDispCGCharAt(col_cont+ 1 + go_col, row_cont + go_row, CG +1);
        }

      if((row_cont>0)&&(row_cont<row)&&(col_cont==0))
        {
            GDispCGCharAt(col_cont + go_col, row_cont + go_row, CG);
        }

     if((col_cont>0)&&(col_cont<col)&&(row_cont==0))
        {
            GDispCGCharAt(col_cont + go_col, row_cont + go_row, CG +2);
        }

     if((row_cont==row-1)&&(col_cont>0))
        {
            GDispCGCharAt(col_cont + go_col, row_cont + 1 + go_row, CG +3);
        }

    }
  }
}

Entenda que, logo de cara eu tentei criar a tela toda como se fosse um desenho unico, percebi que era furada pois em poucas telas vc vai encher toda CG RAM do LCD (que tem capacidade de 128 caracteres). O certo é fazer desse jeito, uma função que pega os cantos da janela (4 caracteres) e coloca nos lugares que desejamos e coloca a borda (+ 4 caracteres), ou seja, com 8 caracteres na CG RAM podemos fazer uma janela completa no tamanho e posição escolhida.

O unico detalhe é o seguinte, o caracteres que compoem a janela devem ser armazenados em sequencia, por exemplo os cantos da jenela tem que estar nos endereços 0, 1, 2, 3 ou qualquer outro endereço desde que estejam em sequencia.

O mesmo vale para a borda, deve estar em sequencia. Nesse exemplo esta em 4, 5, 6, 7. O endereço do primeiro caracter deve ser informado quando chamar a função.

Mais um detalhe, acho que vacilei na hora de escrever as rotinas e acho que inverti o nome das variaveis, por isso onde estiver row pode ser coluna e onde esta col pode ser linha (as vezes) mas é só seguir o exemplo que não vai ter problemas.

Segue o exemplo:

Código: Selecionar todos

#include <16F877a.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)

#include "t6963.h"
#include "t6963.c"
#include "Janela 1.h"

void figura(); // carrega figura na CG RAM

void main()
{
   GDispInit();                                      // Inicialização do display T6963C
   FontSize = 8;                                     // Fonte no modo tamanho 8 ou 6
   GDispSetMode(XOR_MODE|INT_CG_MODE);               // Exclusive OR mode, internal CG character RAM
   GDispSetMode(TEXT_GRH_ON);                        // Text ON, Graphics ON
   GDispClrTxt();                                    // Limpa a area de texto
   GDispClrGrh();                                    // Limpa a area de grafico (ponto-a-ponto)

   figura();                                         // função que carega a figura da janela na CG RAM

  while(1)

      {

      fazJanela(0,0, 11, 3, 0);       // Mostra os cantos da janela 1 nas:
                                      // Coordenadas = col 0
                                      //             = row 0
                                      // Quantidade de colunas = 11
                                      // Quantidade de linhas  =  3
                                      // Onde esta gravado o 1° caracter na CG RAM = 0

      FazBorda( 0, 0, 11, 3, 4);      // Mostra a borda da janela 1:
                                      // coordenada = col 0
      GDispGoto(1,1);                 //              row 0
      printf(GDispChar,"Janela 1  "); // Quantidade de colunas = 11
      delay_ms(2500);                 // Quantidade de linhas  =  3
      GDispGoto(2,1);                 // Onde esta gravada o 1° caracter na CG RAM = 0
      printf(GDispChar,"Teste OK! ");
      delay_ms(2500);

      fazJanela(1,1, 11, 3, 0);
      FazBorda( 1, 1, 11, 3, 4); // (int go_row, int go_col, int col, int row, int CG)
      GDispGoto(2,2);
      printf(GDispChar,"Janela 2  ");
      delay_ms(2500);
      GDispGoto(3,2);
      printf(GDispChar,"Teste OK! ");
      delay_ms(2500);

      fazJanela(2,2, 11, 3, 0);
      FazBorda( 2, 2, 11, 3, 4); // (int go_row, int go_col, int col, int row, int CG)
      GDispGoto(3,3);
      printf(GDispChar,"Janela 3  ");
      delay_ms(2500);
      GDispGoto(4,3);
      printf(GDispChar,"Teste OK! ");
      delay_ms(2500);

      fazJanela(3,3, 11, 3, 0);
      FazBorda( 3, 3, 11, 3, 4); // (int go_row, int go_col, int col, int row, int CG)
      GDispGoto(4,4);
      printf(GDispChar,"Janela 4  ");
      delay_ms(2500);
      GDispGoto(5,4);
      printf(GDispChar,"Teste OK! ");
      delay_ms(2500);

      fazJanela(4,4, 11, 3, 0);
      FazBorda( 4, 4, 11, 3, 4); // (int go_row, int go_col, int col, int row, int CG)
      GDispGoto(5,5);
      printf(GDispChar,"Janela 5  ");
      delay_ms(2500);
      GDispGoto(6,5);
      printf(GDispChar,"Teste OK! ");
      delay_ms(2500);

      GDispClrTxt();                                    // Limpa a tela

      fazJanela(0, 0, 15, 7, 0);
      FazBorda( 0, 0, 15, 7, 4); // (int go_row, int go_col, int col, int row, int CG)
      delay_ms(2000);

      GDispGoto(2,1);
      printf(GDispChar,"Luciano Costa");
      delay_ms(2500);
      GDispGoto(4,1);
      printf(GDispChar,".asm51.eng.br");
      delay_ms(2500);

      GDispClrTxt();
      GDispClrGrh();

      }
} // FIM DO PROGRAMA


void figura()
{

int i =0;
               for(i=0;i<8;i++) CGBuffer[i] = canto_esquerdo_superior[i]; // Armazena o desenho dos
               GDispDefCGChar(0, &CGBuffer[0]);                           // cantos da janela na CG RAM
                                                                          // do Display. É possível
               for(i=0;i<8;i++) CGBuffer[i] = canto_esquerdo_inferior[i]; // acumular de 0 até 127 caracteres
               GDispDefCGChar(1, &CGBuffer[0]);

               for(i=0;i<8;i++) CGBuffer[i] = canto_direito_superior[i];
               GDispDefCGChar(2, &CGBuffer[0]);

               for(i=0;i<8;i++) CGBuffer[i] = canto_direito_inferior[i];
               GDispDefCGChar(3, &CGBuffer[0]);

////////////////////////////        BORDAS      ///////////////////////////////////

               for(i=0;i<8;i++) CGBuffer[i] =  tela_top[i];               // Armazena desenho das bordas
               GDispDefCGChar(4, &CGBuffer[0]);

               for(i=0;i<8;i++) CGBuffer[i] =  tela_bottom[i];
               GDispDefCGChar(5, &CGBuffer[0]);

               for(i=0;i<8;i++) CGBuffer[i] =  tela_left[i];
               GDispDefCGChar(6, &CGBuffer[0]);

               for(i=0;i<8;i++) CGBuffer[i] =  tela_right[i];
               GDispDefCGChar(7, &CGBuffer[0]);
}


fonte do arquivo Janela 1.h

Código: Selecionar todos

// canto 1


int canto_esquerdo_superior[9]=
{
0xFF,   // 11111111
0xC0,   // 11000000
0x88,   // 10001000
0x98,   // 10011000
0x88,   // 10001000
0x88,   // 10001000
0x9C,   // 10011100
0x80    // 10000000
};

// canto 2
int canto_direito_superior[9]=
{
0xFF,   // 11111111
0x03,   // 00000011
0x19,   // 00011001
0x25,   // 00100101
0x09,   // 00001001
0x11,   // 00010001
0x3D,   // 00111101
0x01    // 00000001
};

// canto 3
int  canto_esquerdo_inferior[9]=
{
0x80,   // 10000000
0x9c,   // 10011100
0x84,   // 10000100
0x98,   // 10011000
0x84,   // 10000100
0x9c,   // 10011100
0xC0,   // 11000000
0xFF    // 11111111
};

// canto 4
int canto_direito_inferior[9]=
{
0x01,   // 00000001
0x11,   // 00010001
0x15,   // 00010101
0x15,   // 00010101
0x1D,   // 00011101
0x05,   // 00000101
0x03,   // 00000011
0xFF    // 11111111
};

// canto 8,0
int tela_top[9]=
{
0xFF,   // 11111111
0x00,   // 00000000
0x00,   // 00000000
0x00,   // 00000000
0x00,   // 00000000
0x00,   // 00000000
0x00,   // 00000000
0x00    // 00000000
};

// canto 8,0
int tela_bottom[9]=
{
0x00,   // 00000000
0x00,   // 00000000
0x00,   // 00000000
0x00,   // 00000000
0x00,   // 00000000
0x00,   // 00000000
0x00,   // 00000000
0xFF    // 11111111
};

// canto 8,0
int tela_left[9]=
{
0x80,   // 10000000
0x80,   // 10000000
0x80,   // 10000000
0x80,   // 10000000
0x80,   // 10000000
0x80,   // 10000000
0x80,   // 10000000
0x80    // 10000000
};

// canto 8,0
int tela_right[9]=
{
0x01,   // 00000001
0x01,   // 00000001
0x01,   // 00000001
0x01,   // 00000001
0x01,   // 00000001
0x01,   // 00000001
0x01,   // 00000001
0x01    // 00000001
};

O resultado desse exemplo é esse:


Observação: a função figura() foi feita para faciliatar a armazenagem dos 8 desenhos na CG RAM.

eu acho que desse jeito ficou um pouco mais fácil de entender do que o exemplo original, e a função fazjanela vai facilitar tambem.

essas funções foram testadas na real e funcionaram muito bem, com tudo não estão livres de bugs, mas funcionou muito bem aqui. Se alguem quiser melhorar as funções para ficarem mais eficientes por favor, sinta-se avontade, só pesso que poste a nova função para que todos possamos aproveitar.

Espero ter ajudado em alguma coisa.

Valeu, boa sorte!!!

[rebelk]

valeu jerek , vou verificar

jerek eu consigo escrever textos no glcd , mas não estou conseguindo enviar para o lcd um desenho qualquer ,

me explica ai passo a passo como qual o procedimento para enviar um desenho para a eeprom e depois ler e enviar para o lcd.

eu consigo criar um desenho no progama que vc indicou ,
transformo ele em uma matrix ,só que ai surgi duvidas ,

1º qual o endereço inicial para enviar o desenho para a eeprom?

2º como é organizado os bytes do desenho criado tipo ( linhas e colunas.


me expica como é que o desenho é enviado para a ram do lcd e depois para a tela do lcd?


todas estas duvidas estão surgindo , pois eu ainda não tinha progamado estes tipos de lcd .
estou tendo muita dificuldades para entender como é que é distribuido
as linhas e colunas deste lcd , vc tem o datacheet deste lcd , eu tenho um aqui mas ele não tem a informação de como é a oganização da tela do lcd.


passei um email para vc , pois eu quero valar contigo por telefone + vc é muito dificil.

mas valeu pelas dicas



fkleberp@ibest.com.br

[rebelk]

jerek lendo com atenção as suas funções , deu para entender bastante coisa , mas eu ainda não consegui enviar um desenho com a tela cheia para ram do lcd, eu criei uma matriz com os 1024 baytes na rom eu leio de oito em oito e envio para a cg ram( id 0 a id 127) , mas na hora de visualizar na tela os dados vem dobrados , ou seja os caracteres da 1º e 2º linha
se repete na 3º e 4º e 5 e 6 7 e 8 ,

o que sera que esta acontecendo?

me da uma luz ai jerek!!!!!!!!!!!

[__JEREK__]

Olá rebelk, vou explicar o que eu entendi.

A melhor maneira de entender como funciona o display é imaginar que a tela
é dividida em 16 colunas e 8 linhas:



Faça o desenho e converta para array. Faça cada array contendo 1 caracter (8 byte)

Exemplo:

Código: Selecionar todos

char caracter_1[9] = { 
0x00,  //   00000000
0x7E,  //   01111110
0x42,  //   01000010
0x5A,  //   01011010
0x5A,  //   01011010
0x42,  //   01000010
0x7E,  //   01111110
0x00}; //   00000000

para armazenar esse desenho na CG RAM do display vc usa a função:

Código: Selecionar todos

GDispDefCGChar(0, &caracter_1[0]);             // Armazena os 8 bytes dentro da tabela
                                               // caractet_1 na CG RAM do display na
                                               // posição 0. Essa posição é definida pelo
                                               // programador.

O endereço inicial na na CG RAM é 0 e vai até 127. Você pode armazenar 128 caracteres, cada caracter com 8 bytes.

Agora vc já tem um caracter que vc criou que esta armazenado em um lugar
pré definido por você.

Para fazer aparecer o caracter na tela do display use essa função:

Código: Selecionar todos

GDispCGCharAt(col,row,CGRAM);                  // mostra o caracter armazenado na posição
                                               // 'CGRAM'da CG RAM dos display na
                                               // coluna 'col', linha 'row' 

ou seja, você armazena um caracter no local 'x' da CG RAM e depois busca esse caracter na
posição 'x' e mostra na tela.


você pode fazer um desenho de tela inteira, dividi-lo em em 128 caracteres (128 array de 8 byts) e montar o desenho no display. Não entendi como o autor do drive fez (ele dividiu a figura em arrays de 72 bytes) mas basicamente é o mesmo.

[__JEREK__]

só por curiosidade, depois vc tenta essa outra função...

vai fazer esse desenho

Código: Selecionar todos

#include <16F877a.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)

#include "t6963.h"
#include "t6963.c"

senoidal1(int col, int row);

void main()
{
   GDispInit();                                      // Inicialização do display T6963C
   FontSize = 8;                                     // Fonte no modo tamanho 8 ou 6
   GDispSetMode(XOR_MODE|INT_CG_MODE);               // Exclusive OR mode, internal CG character RAM
   
   GDispSetMode(TEXT_GRH_ON);                        // Text ON, Graphics ON
   GDispClrTxt();                                    // Limpa a area de texto
   GDispClrGrh();                                    // Limpa a area de grafico (ponto-a-ponto)

armazena_figura_cgram();

  while(1)

      {
                 senoidal1( 0, 15);   
                 senoidal1(31, 15);
                 senoidal1(62, 15);
       
                 delay_ms(2000);
       
                 GDispClrTxt();                       // Limpa a area de texto
                 GDispClrGrh();                       // Limpa a area de grafico (ponto-a-ponto)       
      }
     
} // FIM DO PROGRAMA


senoidal1(int col, int row)
{

// 1° parte    col row

GDispSetPixel(col + 0, row ,    BLACK);
delay_ms(20);
GDispSetPixel(col + 1, row ,    BLACK);
delay_ms(20);
GDispSetPixel(col + 2, row - 1, BLACK);
delay_ms(20);
GDispSetPixel(col + 3, row - 1, BLACK);
delay_ms(20);
GDispSetPixel(col + 4, row - 2, BLACK);
delay_ms(20);
GDispSetPixel(col + 5, row - 3, BLACK);
delay_ms(20);
GDispSetPixel(col + 6, row - 4, BLACK);
delay_ms(20);
GDispSetPixel(col + 6, row - 5, BLACK);
delay_ms(20);
GDispSetPixel(col + 7, row - 6, BLACK);
delay_ms(20);
GDispSetPixel(col + 7, row - 7, BLACK);
delay_ms(20);

// 2° parte

GDispSetPixel(col +  8, row -  8, BLACK);
delay_ms(20);
GDispSetPixel(col +  8, row -  9, BLACK);
delay_ms(20);
GDispSetPixel(col +  9, row - 10, BLACK);
delay_ms(20);
GDispSetPixel(col +  9, row - 11, BLACK);
delay_ms(20);
GDispSetPixel(col + 10, row - 12, BLACK);
delay_ms(20);
GDispSetPixel(col + 11, row - 13, BLACK);
delay_ms(20);
GDispSetPixel(col + 12, row - 14, BLACK);
delay_ms(20);
GDispSetPixel(col + 13, row - 14, BLACK);
delay_ms(20);
GDispSetPixel(col + 14, row - 15, BLACK);
delay_ms(20);
GDispSetPixel(col + 15, row - 15, BLACK);

// 3° parte

GDispSetPixel(col + 16, row - 15, BLACK);
delay_ms(20);
GDispSetPixel(col + 17, row - 15, BLACK);
delay_ms(20);
GDispSetPixel(col + 18, row - 14, BLACK);
delay_ms(20);
GDispSetPixel(col + 19, row - 14, BLACK);
delay_ms(20);
GDispSetPixel(col + 20, row - 13, BLACK);
delay_ms(20);
GDispSetPixel(col + 21, row - 12, BLACK);
delay_ms(20);
GDispSetPixel(col + 22, row - 11, BLACK);
delay_ms(20);
GDispSetPixel(col + 22, row - 10, BLACK);
delay_ms(20);
GDispSetPixel(col + 23, row -  9, BLACK);
delay_ms(20);
GDispSetPixel(col + 23, row -  8, BLACK);

// 4° parte

GDispSetPixel(col + 24, row -  7, BLACK);
delay_ms(20);
GDispSetPixel(col + 24, row -  6, BLACK);
delay_ms(20);
GDispSetPixel(col + 25, row -  5, BLACK);
delay_ms(20);
GDispSetPixel(col + 25, row -  4, BLACK);
delay_ms(20);
GDispSetPixel(col + 26, row -  3, BLACK);
delay_ms(20);
GDispSetPixel(col + 27, row -  2, BLACK);
delay_ms(20);
GDispSetPixel(col + 28, row -  1, BLACK);
delay_ms(20);
GDispSetPixel(col + 29, row -  1, BLACK);
delay_ms(20);
GDispSetPixel(col + 30, row -  0, BLACK);
delay_ms(20);
GDispSetPixel(col + 31, row -  0, BLACK);
}