Drives do display Grafico G128641BNHDWB

[rebelk]

JEREK ve este prog ai , se for um desenho pequeno apaarece normal no lcd , mas se for um deselho maior ele aparece repetido , ve ai o que pode ser ?




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

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


#define EEPROM_SDA PIN_C4
#define EEPROM_SCL PIN_C3
#include <24256.c>

//////////////////////////////////////////////////////////////////////////
//

const unsigned int8 desenho_1[]= // desenho da placa
{
// linha 1
0x01,0x03,0x03,0x03,0x03,0x03,0x1F,0x23, // coluna 0
0xFF,0xFF,0xFF,0xFF,0xFB,0xFB,0xD5,0xF5, // coluna 1
0xFF,0xFF,0xFF,0xFF,0x38,0x38,0x7B,0x39, // coluna 2
0x00,0x80,0x80,0x80,0x80,0x80,0x80,0x80, // coluna 3

// linha 2
0x23,0x5F,0xA3,0xA3,0xDF,0xE3,0xE3,0xDF, // coluna 0
0xF5,0xD5,0xFB,0xFB,0xFF,0xFF,0xFF,0xFF, // coluna 1
0x39,0x7B,0x78,0x78,0xFF,0xFF,0xFF,0xFF, // coluna 2
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80, // coluna 3

0xE3,0xE3,0xDF,0xE3,0xE3,0xDF,0xE3,0xE3,
0xFC,0xFC,0xDF,0x8F,0x8F,0xDF,0xFC,0xFC,
0xFF,0xFF,0x7F,0xFB,0xFB,0x7B,0xFF,0xFF,
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,

0xDF,0xE3,0xE3,0xDF,0xE3,0xFF,0xDF,0xE3,
0xFF,0xFF,0xFF,0xFF,0xFC,0xFD,0xDD,0x8C,
0xFF,0xFF,0xFF,0xFF,0x7F,0xFF,0xFF,0xFB,
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,

0xFF,0xDF,0xE3,0xFF,0xDF,0xE3,0xFF,0xDF,
0xDF,0xDF,0xFC,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFB,0x7B,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,

0xE3,0xFF,0xDF,0xE3,0xFF,0xDF,0xE3,0xE3,
0xFB,0xFB,0xF3,0x1B,0xFB,0xFB,0xF3,0xFF,
0x7F,0xFF,0xFF,0x7D,0xFD,0xFD,0x3B,0xFF,
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
};


const unsigned int8 desenho_2[]= // desenho do operario
{
0xFF,0xFF,0xFF,0xFF,0xF1,0xF1,0xF0,0xFC,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x3F,0x07,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,

0xFC,0xFC,0xE0,0xE1,0xE1,0xFF,0xFF,0xFF,
0x07,0x00,0xF8,0xE6,0xE6,0xC7,0xE7,0xE7,
0xFF,0xFF,0x01,0x00,0x00,0xFF,0xE7,0xE7,
0xFF,0xFF,0xFF,0x03,0x03,0x07,0xFF,0xFF,
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,

0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xE6,0xC4,0xCC,0xCC,0xCC,0x8C,0x8C,0x87,
0xE7,0x67,0x67,0x67,0x67,0x67,0xE7,0xE7,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,

0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x80,0x80,0xE0,0xE3,0xE3,0xE3,0xF3,0xF3,
0x07,0x07,0x07,0xCF,0xCF,0xCF,0x8F,0x1F,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,

0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xF3,0xF3,0xF3,0xF3,0xF2,0xF2,0xF0,0xF0,
0x1F,0x1F,0x3F,0x3F,0x3F,0x3F,0x7F,0x7F,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,

0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xE0,0xE7,0xE7,0xEF,0xCF,0xCF,0xCF,0xCF,
0x3F,0x3F,0x3F,0x3F,0x1F,0x1F,0x9F,0x9F,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,

0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xCF,0xCF,0xCF,0xC7,0xC7,0xE7,0xC7,0x87,
0x8F,0x8F,0x8F,0x8F,0x8F,0xCF,0xC7,0xE7,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,

0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x87,0xDF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xE7,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,

};

const unsigned int8 desenho_3[]={
0x3F,0xFF,0x80,0x81,0x80,0x81,0xF0,0x0F, // desenho da mão
0x00,0xFE,0x01,0xFE,0x20,0xC0,0x80,0x00,
};



//**********************************************************************************
//**********************************************************************************


mostra_figura_3(int8 lin,int8 col)
{
int8 id=0;
int8 linha=0;
int8 coluna=0;

for(linha=0;linha<1;linha++)
{
for(coluna=0;coluna<2;coluna++)
{
GDispCGCharAt( lin, col++ , id++ ); //delay_ms(5);
}
}


}


//**********************************************************************************
//**********************************************************************************
carreg_figura_3() // carrega figura na CG RAM
{

unsigned int8 i =0;
unsigned int16 end =0;
int8 id=0;
int8 linha=0;
int8 coluna=0;

for(linha=0;linha<1;linha++)
{
for(coluna=0;coluna<2;coluna++)
{
for(i=0;i<8;i++)
{
CGBuffer[i] = desenho_3[end++]; //delay_ms(5); // acumular de 0 até 127 caracteres
}
GDispDefCGChar(id++, &CGBuffer[0]);
}
}



}

//**********************************************************************************
//**********************************************************************************


mostra_figura_2(int8 lin,int8 col)
{
int8 id=0;
int8 linha=0;
int8 coluna=0;

for(linha=0;linha<8;linha++)
{
for(coluna=0;coluna<5;coluna++)
{
GDispCGCharAt( linha, coluna , id++ ); // delay_ms(5);
}
}


}


//**********************************************************************************
//**********************************************************************************
carreg_figura_2() // carrega figura na CG RAM
{

unsigned int8 i =0;
unsigned int16 end =0;
int8 id=0;
int8 linha=0;
int8 coluna=0;

for(linha=0;linha<8;linha++)
{
for(coluna=0;coluna<5;coluna++)
{
for(i=0;i<8;i++)
{
CGBuffer[i] = desenho_2[end++]; //delay_ms(5); // acumular de 0 até 127 caracteres
}
GDispDefCGChar(id++, &CGBuffer[0]);
}
}



}

//**********************************************************************************
//**********************************************************************************


mostra_figura_1(int8 lin,int8 col)
{
int8 id=0;
int8 linha=0;
int8 coluna=0;

for(linha=0;linha<6;linha++)
{
for(coluna=0;coluna<4;coluna++)
{
GDispCGCharAt( linha, coluna , id++ ); //delay_ms(5);
}
}


}


//**********************************************************************************
//**********************************************************************************
carreg_figura_1() // carrega figura na CG RAM
{

unsigned int8 i =0;
unsigned int16 end =0;
int8 id=0;
int8 linha=0;
int8 coluna=0;

for(linha=0;linha<6;linha++)
{
for(coluna=0;coluna<4;coluna++)
{
for(i=0;i<8;i++)
{
CGBuffer[i] = desenho_1[end++]; //delay_ms(5); // acumular de 0 até 127 caracteres
}
GDispDefCGChar(id++, &CGBuffer[0]);
}
}



}


//**********************************************************************************
//**********************************************************************************

void main()
{
int8 vezes=0;
// int8 repete=0;


GDispInit(); //T6963C display initialization
FontSize = 8; //8 font mode
GDispSetMode(XOR_MODE|INT_CG_MODE); //Exclusive OR mode, internal CG character RAM
GDispSetMode(TEXT_GRH_ON); //Text ON, Graphics ON
GDispClrTxt(); //Clear the text area
GDispClrGrh(); //Clear the graphics area (dot-by-dot!)


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


for (;;)
{

carreg_figura_3(); // carrega figura na CG RAM
for(vezes=0;vezes<8;vezes++)
{
mostra_figura_3(vezes,0);
delay_ms(450); //
GDispClrTxt(); //
GDispClrGrh(); //
}


GDispClrTxt(); //
GDispClrGrh(); //

carreg_figura_1(); // carrega figura na CG RAM
mostra_figura_1(0,0);
delay_ms(2000); //
GDispClrTxt(); //
GDispClrGrh(); //
Delay_ms(500);

carreg_figura_2(); // carrega figura na CG RAM
mostra_figura_2(0,0);
delay_ms(2000); //no need to explain!
GDispClrTxt(); //clear the text
GDispClrGrh(); //clear the graphic
Delay_ms(500);

}

}

[__JEREK__]

rebelk, estou olhando aqui e não estou achando nada errado mas tambem so revisei o código pois a droga do meu 16F877 queimou não sei como, tenho que comprar outra, por isso não vou conseguir testar esse programa na pratica por enquanto.

Poderia descrever como é esse repetido que a figura fica? Se tivesse uma imagem era melhor ainda.

No programa que você colocou tem duas figura grandes (1 e 2) e uma pequena (3), vc colocou só a pequena em um loop, e as grandes em outro loop, será que não é isso que esta errado?

Chegou a testar um desenho de cada vez para ter certeza que não uma função não esta influenciando a outra?

Já verificou se o pino FS esta aterrado??

[rebelk]

rebelk, estou olhando aqui e não estou achando nada errado mas tambem so revisei o código pois a droga do meu 16F877 queimou não sei como, tenho que comprar outra, por isso não vou conseguir testar esse programa na pratica por enquanto.

Poderia descrever como é esse repetido que a figura fica? Se tivesse uma imagem era melhor ainda.

No programa que você colocou tem duas figura grandes (1 e 2) e uma pequena (3), vc colocou só a pequena em um loop, e as grandes em outro loop, será que não é isso que esta errado?

Chegou a testar um desenho de cada vez para ter certeza que não uma função não esta influenciando a outra?

Já verificou se o pino FS esta aterrado??


jerek eu testei uma de cada vez, e o resultado é o mesmo ,
se eu for enviar um desenho grande( tela cheia) no lcd ( vamos supor uma pessoa em pé ) aparece normal ate a metade do lcd , a parte de baixo do desenho não é desenhada , e sim é desenhada novamente
a parte de cima do mesmo desenho . deu para entende?

o pino FS esta aterrado ( em 0v ).

o resto das funções da para ultilizar sem nenhum problema !

o unico problema é esse enviar para a cgram em desenho de tela cheia!

[__JEREK__]

Rebelk, poderia colocar essas figuras em formato bmp para que eu possa fazer o download??

[rebelk]

posso mas só não sei como!!!!!!!!!!!

[rebelk]

enviei para

luciano2004costa@gmail.com

[rebelk]

e ai luciano , tu tem alguma novidade , as outra funções ate q da para
desenrolar , mas enviar um desenho para o lcd com tela cheia , nada inda!

[__JEREK__]

Não rebelk, ainda não consegui muito progresso pois estou sem o 16F877, mas estou tentando fazer um programa para poder fazer a conversão dos desenhos. Não esta pronto ainda, mas vc pode fazer download da versão beta (hehehe até parece...) é bem fácil de usar.



Você tanto pode desenhar nele quanto pode converter uma figura bmp.

Download:
http://rapidshare.com/files/9605186/Converte_BMP_para_LCD.rar.html

Ele converte cada 8 bytes do desenho em uma tabela, assim você pode salvar caracter por caracter no GLCD, talvez assim você consiga montar a imagem no GLCD até eu achar um jeiro mais prático.

Ps. o programa esta com alguns bugs ainda mas dá pra usar

[rebelk]

pó cara tu é d + , valeu luciano!

[rebelk]

não estou conseguindo baixar , manda para o meu email!

[__JEREK__]

eu testei o link e baixou legal mas mandei o programa para o seu email tambem, verifica se chegou ai.

falow!!!

[rebelk]

chegou luciano , valeu !

[rebelk]

e ai luciano blz ? Consegui fazer algumas coizas
com o lcd , ´so não consegui ainda foi escrever um desenho com tela cheia , vc conseguiu mais alguma coiza?



da uma olha ai , ele desenha qualquer quadrado com tamanhos entre 2 por 2 a 8 por 16 tamanho , maximo!


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

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


const int8 cantos[]=
{
0b11111111,
0b10000000,
0b10000000,
0b10000000, // 0 canto superior esquerdo
0b10000000,
0b10000000,
0b10000000,
0b10000000,

0b11111111,
0b00000001,
0b00000001,
0b00000001, //1 canto superior direito
0b00000001,
0b00000001,
0b00000001,
0b00000001,

0b00000001,
0b00000001,
0b00000001,
0b00000001, // 2 canto inferior direito
0b00000001,
0b00000001,
0b00000001,
0b11111111,

0b10000000,
0b10000000,
0b10000000,
0b10000000, // 3 canto inferior esquerdo
0b10000000,
0b10000000,
0b10000000,
0b11111111,

0b11111111,
0b00000000,
0b00000000,
0b00000000,// 4 traço superior
0b00000000,
0b00000000,
0b00000000,
0b00000000,

0b00000000,
0b00000000,
0b00000000,
0b00000000,// 5 traço inferior
0b00000000,
0b00000000,
0b00000000,
0b11111111,

0b00000001,
0b00000001,
0b00000001,
0b00000001,// 6 traço direito
0b00000001,
0b00000001,
0b00000001,
0b00000001,

0b10000000,
0b10000000,
0b10000000,
0b10000000,// 7 traço esquerdo
0b10000000,
0b10000000,
0b10000000,
0b10000000

0b00000000,
0b00000000,
0b00000000,
0b00000000,// 8 // matriz em branco para apagar os rascunhos
0b00000000, // dentro do quadrado
0b00000000,
0b00000000,
0b00000000

};

//**********************************************************************************
//**********************************************************************************

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

int8 i =0;
int8 end=0;
int8 id=0; for(id=0;id<9;id++)
{
for(i=0;i<8;i++) CGBuffer[i] = cantos[end++];
GDispDefCGChar(id, &CGBuffer[0]); // cantos da janela na CG RAM
}

}

//**********************************************************************************
//**********************************************************************************

// função para apagar todo o quadrado
apaga_quadrado( int8 linha, int8 coluna, int8 X , int8 Y , )
{
int8 lin=0, col=0;
int8 vezes=0;


for(lin=0; lin < X ;lin++ )
{
for(col=0; col<Y ;col++ )
{
GDispCGCharAt(lin+linha,col+coluna, ; // conteudo

}
}

}

//**********************************************************************************
//**********************************************************************************


void mostra_figura( int8 linha, int8 coluna, int8 X , int8 Y) // X*Y=ao tamanho do quadrado
{
int8 lin=0, col=0;
int id=0;
int8 vezes=0;

apaga_quadrado( linha, coluna, X , Y );

GDispCGCharAt(linha ,coluna, 0); //delay_ms(500); // retirar este delay
GDispCGCharAt(linha,(Y-1)+coluna, 1);//delay_ms(500);
GDispCGCharAt((X-1)+linha,(Y-1)+coluna, 2); //delay_ms(500);
GDispCGCharAt((X-1)+linha,coluna, 3); //delay_ms(500);

col=coluna+1;
for(vezes=0; vezes<(Y-2) ;vezes++ )
{
GDispCGCharAt(linha,vezes+col, 4); //delay_ms(500);
}

for(vezes=0; vezes<(Y-2) ;vezes++ )
{
GDispCGCharAt(linha+X-1,vezes+col, 5); //delay_ms(500);
}

lin=linha+1;
for(vezes=0; vezes<(X-2) ;vezes++ )
{
GDispCGCharAt(lin+vezes,(Y-1)+coluna, 6); //delay_ms(500);
}

lin=linha+1;
for(vezes=0; vezes<(X-2) ;vezes++ )
{
GDispCGCharAt(lin+vezes, coluna, 7); //delay_ms(500);
}


}


//**********************************************************************************
//**********************************************************************************



void main()
{

int8 T=2;

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();

while(1)

{
// figura();


mostra_figura( 0, 0, 3, 5); // linha, coluna, 3 linhas por 5 colunhas
GDispGoto(1,2);
printf(GDispChar,"0"); //
delay_ms(1000);
// apaga( 0, 0, 3, 5 , apaga_conteudo );
// delay_ms(1000);


mostra_figura( 1, 1, 3, 5); // linha, coluna,
GDispGoto(2,3);
printf(GDispChar,"1"); //
delay_ms(1000);

mostra_figura( 2, 2, 3, 5); // linha, coluna,
GDispGoto(3,4);
printf(GDispChar,"2"); //
delay_ms(1000);

mostra_figura( 3, 3, 3, 5); // linha, coluna,
GDispGoto(4,5);
printf(GDispChar,"3"); //
delay_ms(1000);

mostra_figura( 4, 4, 3, 5); // linha, coluna,
GDispGoto(5,6);
printf(GDispChar,"4"); //
delay_ms(1000);

mostra_figura( 5, 5, 3, 5); // linha, coluna,
GDispGoto(6,7);
printf(GDispChar,"5"); //
delay_ms(1000);

mostra_figura( 0, 12, 8, 3); // 8/3 coluna,
GDispGoto(1,13);
printf(GDispChar,"T"); //
GDispGoto(2,13);
printf(GDispChar,"e"); //
GDispGoto(3,13);
printf(GDispChar,"s"); //
GDispGoto(4,13);
printf(GDispChar,"t"); //
GDispGoto(5,13);
printf(GDispChar,"e"); //
delay_ms(3000);



GDispClrTxt();
GDispClrGrh();
delay_ms(300);

}
}

[__JEREK__]

Ficou muito boa essa função, mesmo sem poder testar na pratica mas ficou pequena e simples!

rebelk, comprei o PIC 16F877A, amanhã o cara deve estar mandando pra mim pelos correios!!!

[rebelk]

luciano tu comprou onde e a quanto ?