Erro na gravação da Flash

[HC908]

Amigos abaixo esta a rotina q eu uso para gravar dados na memoria flash, o problema q mando gravar os dados apartir da posiição 18080 e os dados são gravados a partir da posição 180C0, o q vcs acham. o ponteiro TBLPTR quando chama a função vai para o endereço 18080.

Código: Selecionar todos

#define offsetmemory 0x18080
#define TAM_BUFFER_FLASH 64
u8   buffer_flash[TAM_BUFFER_FLASH];
#pragma udata buffer_flash=0x700


void erase_flash(void);
void flash_move_buffer(uint16 addr);
void write_flash(uint16 endereco, uint8 value);
uint8 read_flash(uint16 endereco);
unsigned short long write_flash_block(unsigned short long endereco_reg, unsigned char quant_dado_escreve, unsigned char *dados_rom);
void read_flash_block( unsigned short long endereco_reg, unsigned char quant_dado_le, unsigned char * dado_rom);

void flash_move_buffer(uint16 addr)
{
   addr=addr/TAM_BUFFER_FLASH;
   read_flash_block(addr,TAM_BUFFER_FLASH,buffer_flash);
}
void write_flash(uint16 endereco, uint8 value)
{
   flash_move_buffer(endereco);
   buffer_flash[endereco%TAM_BUFFER_FLASH]=value;
   endereco=endereco/TAM_BUFFER_FLASH;
   write_flash_block(endereco,TAM_BUFFER_FLASH,buffer_flash);   
}
uint8 read_flash(uint16 endereco)
{
   flash_move_buffer(endereco);
   return buffer_flash[endereco%TAM_BUFFER_FLASH];
}

void read_flash_block( unsigned short long endereco_reg, unsigned char quant_dado_le, unsigned char * dado_rom )
/*************************************************************************************************************************************
*                                   Lê o conteúdo da memória FLASH apontado por endereco_reg                                         *
*                                                                                                                       *
* Sendo:                                                                                                                *
* endereco_reg: Endereço do registrador.                                                                                 *
* dado_rom: Ponteiro para o vetor contendo os dados.                                                                     *
* quant_dado_le: Quantidade de bytes que devem ser lidos.                                                                  *
* Observação: A proteção contra leitura de tabela deve estar desabilitada.                                               *
*                                                                                                                     *
*
*                                                              *
* Autor: Wellington Messias Silva de Oliveira.                                                                                      *
*************************************************************************************************************************************/
{
   unsigned char cont_dado_lido;
   TBLPTR = (endereco_reg*TAM_BUFFER_FLASH) + offsetmemory ; //Carrega o endereço inicial da memória de programa.
   INTCONbits.GIE = 0;    //Desabilita as interrupções.
   
   for (cont_dado_lido=0 ; cont_dado_lido<quant_dado_le ; cont_dado_lido++)
   {
      _asm
         TBLRDPOSTINC //Lê a tabela apontada pelo ponteiro TBLPTR e a incrementa após a leitura.
      _endasm
     
      //Carrega o conteúdo da memória de programa FLASH para o buffer.
      dado_rom [cont_dado_lido] = TABLAT;
   }
   INTCONbits.GIE = 1; //Habilita as interrupções.
}

unsigned short long write_flash_block(unsigned short long endereco_reg, unsigned char quant_dado_escreve, unsigned char *dados_rom)
/****************************************************************************************************************************************
*                                       Escreve no endereço da memória FLASH apontado por endereco_reg                                  *
*                                                                                                                             *
* Sendo:                                                                                                                  *
* endereco_reg: Endereço do registrador.                                                                                  *
* dado_rom: Ponteiro para o vetor contendo os dados.                                                                      *
* quant_dado_escreve: Quantidade de bytes que devem ser escritos.                                                         *
* Observação: A proteção contra escrita de tabela deve estar desabilitada.                                                 *
*                                                                                                                          *
*                                                                  *
* Autor: Wellington Messias Silva de Oliveira. .                                                                                         *
****************************************************************************************************************************************/
{
   unsigned char cont_dado_escrito;
   unsigned char rep_laco;
   unsigned char quant_dado_escreve_b[2];
   endereco_reg=(endereco_reg*TAM_BUFFER_FLASH) + offsetmemory;
   TBLPTR = endereco_reg; //Carrega o endereço inicial da memória de programa.
   EECON1bits.WREN = 1;   //Habilita a escrita na memória.
   EECON1bits.FREE = 1;   //Habilita apagar a fila da memória FLASH (64bytes) apontada por TBLPTR.
   INTCONbits.GIE = 0;   //Desabilita as interrupções.
   EECON2 = 0x55;   //Carrega o valor 0x55 no registrador EECON2. (sequência obrigatória)
   EECON2 = 0xAA;   //Carrega o valor 0xAA no registrador EECON2. (sequência obrigatória)
   EECON1bits.WR = 1;   //Apaga a fila da memória FLASH (64bytes).
   INTCONbits.GIE = 1;   //Habilita as interrupções.
   for (cont_dado_escrito=0 ; cont_dado_escrito<quant_dado_escreve; cont_dado_escrito++)
   {
         //Carrega o byte do buffer para o registro da memória de programa.
     //endereco_reg++;
      TABLAT = dados_rom[cont_dado_escrito];
   
      _asm
            //Escreve na tabela indicada pelo ponteiro TBLPTR e a incrementa após a escrita.
           TBLWTPOSTINC
      _endasm
   }
   EECON1bits.WREN = 1;   //Habilita a escrita na memória.
   INTCONbits.GIE = 0;   //Desabilita as interrupções.
   EECON2 = 0x55;   //Carrega o valor 0x55 no registrador EECON2. (sequência obrigatória)
   EECON2 = 0xAA;   //Carrega o valor 0xAA no registrador EECON2. (sequência obrigatória)
   EECON1bits.WR = 1;   //Inicia o ciclo para escrever os 32bytes na memória FLASH.
 
   INTCONbits.GIE = 1;   //Habilita as interrupções.
   EECON1bits.WREN = 0;   //Desabilita a escrita na memória.
   TBLPTR=endereco_reg=(endereco_reg*TAM_BUFFER_FLASH) + offsetmemory;
   /*Força o ponteiro TBLPTR para a posição do próximo bloco*/
   TBLPTR=(endereco_reg*TAM_BUFFER_FLASH) + TAM_BUFFER_FLASH;

   return TBLPTR; //Retorna o valor do ponteiro para uma possível sequência de escrita. (endereco+64)
}


[fabim]

cara não sei se é o seu caso.
Mais eu li em um datasheet uma vez, sobre gravação de flash que é em pacotes de 32em32 ou 64 em 64.
Cuja deve ser por exemplo alterados os bytes de 45...64.
para gravar tem que pegar os 64, alterar de 45 a 64, e depois gravar os 64 novamente.
Pelo que esta porecendo aí, o 080, vai para o 0c0 porque o 0c0 é o ponteiro inicial seguinte do proximo frame de N bytes.
O proprio compilador esta fazendo a correção.

Sei lá se é isto, só de uma conferinhada.!!

Abraços

Fabim

[Nanico]

Ola HC908 - obrigado por compartilhar o código. Estou com problemas para salvar algumas variaveis no 24J10. Antes de cair em cima do código, gostaria de saber para qual processador vc escreveu estas funções.
Obrigado & Abraço