ASM51

Olá pessoal.

Estou brigando com uma eeprom 24FC1025 que vou usar para armazenar algumas telas de um display mas estou tendo problemas para grava-la.
Fiz um programinha usando um PIC18F4550 em que eu gravo o bitmap na flash e ele joga isso dentro desta eeprom , funcionou bem para os icones de 12x12 pixels, mas agora chegou a hora de gravar as telas grandes de 240x64.
O problema é que para fazer isso eu preciso reconfigurar o meu programa para ficar atento ao buffer interno da eeprom que é de apenas 127 bytes mas estou tendo problemas com acknowledge polling (resposta da memória dizendo que terminou o processo de gravação do buffer pag. 10).

Depois de apanhar bastante descobri que o aplicativo do PicKit2 é capaz de gravar um arquivo .hex ou .bin nesta memória, porém ele não tem recursos para gerar este arquivo a não ser que eu o faça byte por byte, conclusão....


Não custa nada perguntar, mas alguém conhece algum aplicativo capaz de converter um arquivo texto ( ex: minha_tela[2560] ) em um arquivo .hex ou .bin?
Ou alguém teria uma sugestão pratica para gravar estas informações nesta memória de uma forma mais simples?

Obrigado

( ex: minha_tela[2560] )

Eu não entendí isso.
Como voce esta 'montando' o conteudo a ser mostrado?
Voce pode tentar fazer um 'truque' sem usar aplicativo para isso.
Pegue o' conteudo ' a ser mostrado,copie com o mouse apenas os bytes que interessam,crie um arquivo de texto vazio, na hora de nomear,renomeie para .hex e depois 'cole o conteudo'.
Mouse direito,'Novo','Documento de texto',ja renomeie para 'alguma_coisa.hex',o própio Windows vai providenciar um 'cabeçalho 'padrão no arquivo.Deixe o Windows abrindo arquivos .hex,por padrão,com o Bloco de Notas.
Eu poderia programar um mini-aplicativo para isso pra voce,mas eu precisaria de muitos detalhes,alem de não ter tempo...

Olá vtrx, obrigado por responder!!!

Concordo com você, acho que não fui bem claro, vou tentar explicar melhor.
Para os que não viram o datasheet, esta é uma memória eeprom de 1Mbit que estou tentando programar via I2C. Pretendo guardar aproximadamente 20 telas full screen e mais 45 icones de 12x12 que serão apresentadas em um display t6963c de 240x64 pixels usando um PIC16F4550 no MPLab compilando com Hi-tech compiler.
Quando eu citei "minha_tela[2560]" eu estava me referindo a um array de 2560 bytes que é exatamente o que eu preciso para preencher a minha tela toda em modo sprite.

(240/6)x64 = 2560 bytes por tela
(12/6)x12 = 24 bytes por icone

Neste modo, os bytes que formam a imagem contém informação apenas nos 6 primeiros bits MSB, os outros são ignorados e com isso eu consigo usar a biblioteca interna de caracteres do display no formato 6x8 assim tenho uma apresentação melhor do texto, porém preciso de mais bytes para gerar imagens, o que não será problema com esta eeprom externa.

A parte do display ja esta funcionando e também consigo gravar até 127 bytes (tamanho do buffer interno) na eeprom sem problemas, acima disso eu preciso esperar a memória gravar este buffer na secção permanente da mesma aguardando um sinal de acknowledge avisando que posso mandar mais 127 bytes, porém esta é a origem de todos os meus problemas, pois não consigo fazer meu micro reconhecer este acknowledge nem com reza brava.

Continuando...

Pegue o' conteúdo ' a ser mostrado,copie com o mouse apenas os bytes que interessam,crie um arquivo de texto vazio, na hora de nomear,renomeie para .hex e depois 'cole o conteudo'.
Mouse direito,'Novo','Documento de texto',ja renomeie para 'alguma_coisa.hex',o própio Windows vai providênciar um 'cabeçalho 'padrão no arquivo.Deixe o Windows abrindo arquivos .hex,por padrão,com o Bloco de Notas.

...Desculpe pelo tamanho da mensagem...

vtrx, fiz o que você disse mas não funcionou, deu um erro ao importar o arquivo. Sua sugestão é interessante mas acredito que não seja tão simples assim, veja isso.
Fiz um outro teste para tentar entender o que aconteceu, vou explicar. Este é um dos icones que vou usar: Ele é formado pelos 24 bytes do array logo6[] abaixo.

Código: Selecionar todos

//SDCard icon

const char logo6[]={

0x0,0x0,

0x7,0x3C,

0x8,0x4,

0x15,0x14,

0x15,0x14,

0x15,0x14,

0x10,0x4,

0x10,0x4,

0x10,0x4,

0x10,0x4,

0x10,0x4,

0x1F,0x3C,

};

Peguei estes valores e coloquei manualmente no aplicativo do PicKit2 e ficou assim:



Em seguida exportei esta informação para os dois tipos de arquivos suportados, este é o .hex aberto no Notepad.

Código: Selecionar todos

:020000040000FA
:100000000000073C080415141514151410041004FE
:100010001004100410041F3CFFFFFFFFFFFFFFFF51
:10002000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE0
:10003000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD0
:10004000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC0
:10005000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFB0
:10006000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA0
:10007000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF90
:10008000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF80
:10009000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF70
:1000A000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF60
:1000B000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF50
:1000C000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF40
:1000D000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF30
:1000E000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF20
:1000F000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF10
:10010000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
:10011000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEF
:10012000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDF
:10013000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFCF
:10014000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBF
.
.
. "Tirei esta parte pois é muuuuito longo"
.
.
:10FF5000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFB1
:10FF6000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA1
:10FF7000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF91
:10FF8000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF81
:10FF9000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF71
:10FFA000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF61
:10FFB000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF51
:10FFC000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF41
:10FFD000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF31
:10FFE000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF21
:10FFF000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF11
:00000001FF

Este é o .bin aberto no WordPad mas ficou mais apresentável na foto.



Eu também acho que da para fazer um aplicativozinho besta para fazer a conversão, eu poderia fazer isso em VB6 mas antes precisaria entender como funciona a estrutura deste arquivo, o formato .hex parece ser mais amigável.

Veja bem, cada linha sempre começa com ":", a primeira linha tem um valor que não faço idéia do que seja, mas alterei o conteúdo e exportei um novo arquivo e o valor continuou o mesmo ":020000040000FA" para a primeira pagina e ":020000040001F9" para a segunda pagina que se encontra no meio do arquivo, especificamente na linha 4098.
Na segunda linha o valor ":10000000" parece ser um tipo de cabeçalho que vai até ":10FFF000" alterando apenas o terceiro, quarto e quinto byte, este ultimo cabeçalho se encontra na linha 4097, este esquema se repete com os mesmos valores na segunda pagina.
Depois do cabeçalho estão os valores que serão gravados na memória, cada linha contém 16 bytes no formato hexadecimal.

Em seguida estão os únicos valores que serão problema na minha opinião, este último byte de cada linha me parece ser algum tipo de Checksum para verificar a integridade de dados.
Ja tentei fazer uma operação XOR com cada byte de cada linha mas não funcionou, mas confesso que tentei apenas uma vez.
Acredito que se descobrirmos como este suposto Checksum funciona o problema estará resolvido.

Acho que um programinha para fazer a conversão de um arquivo texto comum para um arquivo hex como este seria uma ferramenta e tanto. Outra coisa interessante, acabei de abrir o .hex do meu Pic18F e vi que ele tem a mesma estrutura do .hex da eeprom.

Alguém tem alguma sugestão de como desenrolar este Checksum?
Se alguém estiver interessado em ajudar os arquivos originais estão aqui.

Obrigado

Respondendo eu mesmo...

Encontrei isso aqui:

http://en.wikipedia.org/wiki/Intel_HEX

Era mais ou menos o que eu estava pensando, mas continuo sem entender como funciona o Checksum.
Eu entendi que é a soma de todos os bytes com o complemento de dois do resultado, mas continuou não dando certo.

Alguém entendeu?

veja 01 ex. glcd_editor.exe que acho pode lhe ajudar. tem muitos conversores de bimap-->glcd

que vem com o mikroc. gera uma tabela fonte c a partir do bitmap. pra gerar o .hex pra gravar direto na eeprom é só compilar o fonte gerado (acho). se for no uC prefira inserir direto claro. (não leia uC de traz pra frente)

abç

Regis, sobre o ack_polling , eu utilizo e funciona... vc esta enviando o stop depois de mandar o ultimo dado, após isto esta tentando mandar um start + comando de gravação??

[ ]'s
Sergio

O arquivo binário é mais simples de manipular, pois é puro, sem mascaras e checksum.

O problema é que você esta o manipulando no software errado.

Baixe algum editor hexadecimal, WinHex por exemplo. Isso não pode faltar a um programador.


Para converter o seu array em um .bin, você pode procurar algo na net, ou fazer como o amigo sugerir, compilando a um código qualquer, assim você consegue abrir o .hex gerado eplo compilador e extrair a sua matriz se você tiver o endereço dela pre-definido no seu código.

Acho que o mais correto é voce corrigir o erro de seu programa na hora de testar o 'ack_polling'.
Peça ajuda ao MORAl,ele tem uma matéria de 2007 completa sobre esse assunto,está em ASM,mas creio que voce entenderá como testar o Buffer da memoria,pois esta explicação não é relacionada apenas em ASM.

sei lá, sou contra esse negocio de avatar estilo baratinha, que deixa a gente com uma coisa ruim, com vontade de dar ticão na tela do pc.

lellis escreveu:veja 01 ex. glcd_editor.exe que acho pode lhe ajudar. tem muitos conversores de bimap-->glcd.....
abç

Lellis, obrigado pela sugestão, mas eu ja tenho meus bitmaps convertidos, eu estou tentando é encontrar uma forma de coloca-los dentro da minha eeprom.

barboza escreveu:......O problema é que você esta o manipulando no software errado. ......

Boa Barboza!!! O winHex resolve o problema (usando a versão genérica é claro)...
Basta criar o arquivo da forma que o vtrx explicou anteriormente porém salvando com a extenção .bin, depois abre com o WinHex da um Ctrl+R e converte de Hex Ascii -> Binary e só alegria!!!
Dai basta gravar na memória.
Não sou muito fã de "versões genéricas". Aqui tem uma lista com versões gratuitas com licença GPL, mais tarde vou testar algumas.

Obrigado!!!

Sergio escreveu:Regis, sobre o ack_polling , eu utilizo e funciona... vc esta enviando o stop depois de mandar o ultimo dado, após isto esta tentando mandar um start + comando de gravação??

vtrx escreveu:Acho que o mais correto é você corrigir o erro de seu programa na hora de testar o 'ack_polling'......

Pois então!!! Acho que vocês tem razão, é como coçar a orelha esquerda com a mão direita. Se for olhar pelo lado mais lógico, a opção de concertar meu código faz mais sentido pois ja está meio caminho andado, apesar da dica do Barboza, ainda acho que vale a pena fazer este código funcionar, mais cedo ou mais tarde vou precisar desta função.
Vou tentar entrar em contato com o MORAL mas por via das dúvidas aqui esta a função problemática.

Código: Selecionar todos

 void GravarImagemEEprom(unsigned int end, char pagina)
{   int x=0, TamanhoImagem;
   char BufferEEprom, CrtByte, y=1;
   
   
   if (pagina){            //icone=1
         TamanhoImagem = 24;    //icone 24 bytes
      //   Inicio = 0;         //Inicio da primeira imagem
         CrtByte = 0XA8;        //Pagina 1
                  
      }
    else{                  //Logo=0
         TamanhoImagem = 2560;   //Logo 2560 bytes   
      //   Inicio = 100;      //Inicio da primeira imagem
         CrtByte = 0XA0;        //Pagina 0
      }
   
   

   rw_start_eeprom(end, CrtByte);   //Envia Endereço e Byte de controle
   
   for (x=0; x < TamanhoImagem; x++)
      {
      if (BufferEEprom>126)      //Se o buffer interno da EEprom ficou cheio
         {   
         i2c_stop();         //Avisa EEprom para iniciar a gravação
         BufferEEprom = 0;    //reinicia contador
         while(y)         //Aguarda ACK da Memória
            {
            i2c_start();      //Envia Start
            //i2c_repStart();      
            i2c_waitForIdle();   //Aguarda condição de Idle
            i2c_write(CrtByte);   //Envia Byte de controle
            i2c_waitForIdle();   //Aguarda condição de Idle
            if (!ACKSTAT)y=0;   //Se receber acknowledge sai do loop
            i2c_stop();         //Envia stop
            i2c_waitForIdle();   //Aguarda condição de Idle
            
            }
      i2c_repStart();   
      rw_start_eeprom(end, CrtByte);   //Envia Endereço e Byte de controle
      //i2c_write(CrtByte);
         }
      else
         {
         i2c_write(logo1[x]);   //Aqui define qual array vai ser enviado
         BufferEEprom++;
         end++;   
         y=1;      
         }
      }
      
   i2c_stop();
}

Eu não estou usando as funções internas do compilador Hi-Tech, mas por via das dúvidas aqui estão as que acho suspeitas apesar de funcionarem bem para leitura e escrita abaixo de 127 bytes.

Código: Selecionar todos

void i2c_waitForIdle(void) {
   while (( SSPCON2 & 0b00011111 ) | (SSPSTAT & 0b00000100)) {}; // Aguarda condição de idle e não escreve
}


unsigned char i2c_write( unsigned char i2cWriteData ){
   i2c_waitForIdle();
   //while (BF){};   //Enquanto o Buffer etiver cheio BF=1
   SSPBUF = i2cWriteData;         //Envia byte para o buffer de saida
   return ( ! ACKSTAT  );          // Função retorna '1' se a transmissão receber acknowledge
}



Obrigado a todos

fabim escreveu:sei lá, sou contra esse negocio de avatar estilo baratinha, que deixa a gente com uma coisa ruim, com vontade de dar ticão na tela do pc.

Autocontrole fabim, autocontrole...
Lembre-se, você é mais forte que isso!

Resumindo:

É numa hora dessa que se vê a falta que faz o ASM

DJ

o end da memoria é global ou local?, vi end. declarada em duas funções..

[ ]'s
Sergio

Sergio38br escreveu:o end da memoria é global ou local?, vi end. declarada em duas funções..

[ ]'s
Sergio

É local, mas ela esta declarada apenas na função :

void GravarImagemEEprom(unsigned int end, char pagina)