Eeprom teste

[antonio]

Pessoal tudo bem!

Estou tentando brincar com memoria externae esta funcionado o codigo não apresenta qualquer erro de compilação , mas na depuração assim como nos registos de memoria nao mostra o que eu quero, que eh memorizar os valores segintes na eeprom 24LC256!
write_ext_eeprom(0, 1365);
write_ext_eeprom(3, 2750);
Mas na realidade na memoria interna não estou vendo isso não?olha a imagem?
Algem pode dar uma olhada no codigo e ver onde estou errando?
desde jà agradeço

Código: Selecionar todos

#include <16F877A.H>
#fuses XT, NOWDT, NOPROTECT, BROWNOUT, PUT, NOLVP
#use delay(clock = 4000000)
//#use i2c(master,sda=EEPROM_SDA,scl=EEPROM_SCL)

#define EEPROM_SDA  PIN_D1
#define EEPROM_SCL  PIN_D0
#include <flex_lcd.c>
#include <24256.c>

//=====================================
void main()
{
lcd_init();
delay_ms(100);
printf(lcd_putc,"Start\n\r");

init_ext_eeprom();
                                         
write_ext_eeprom(0, 1365);
write_ext_eeprom(3, 2750); 
lcd_gotoxy(1,1);
printf(lcd_putc,"%d", read_ext_eeprom(0));
lcd_gotoxy(1,2);
printf(lcd_putc,"%d", read_ext_eeprom(3));

while(1);     
}


[fabim]

o tõen, to olhando a rotina.
no caso seria
grava.........(endereço, valor); ?

Se for isto, você precisa saber se esta rotina em questão, aceita um valor maior que um byte em VALOR.
Veja que valores cabiveis para um byte variam de 0 a 255;
no seu caso, os valores são maiores do que 255.

write_ext_eeprom(0, 1365);
write_ext_eeprom(3, 2750);

Confere isto, depois me da um retorno.

Abraços

[ze]

conferido mas....
ahhh. tirou o prazer de ele descobrir sozinho rs
que tal

unsigned int x;
write_ext_eeprom(0, x);
write_ext_eeprom(1, x>>8);
e recuperar
x=read_ext_eeprom(0) | (unsigned int)read_ext_eeprom(1)<<8;

"Confere isto, depois me da um retorno. "
abç

[barboza]

1365d = 0555h
2750d = 0ABEh


end(0) = 0xAA
end(3) = 0xBE


A função só aceita byte, então trunca o valor que você passa.

o AA no end(1) deve ser de algum teste anterior que fez...

[antonio]

Pessoal grato pelo poio!

Eu vouh responder aos 3 colegas acima!

Fabim eu atè eentendo sim o que vc falou cara!! ou seje vc quer dizer que cada posição da memoria soh armazena valores no maximo até 255, certo?

Se for isto, você precisa saber se esta rotina em questão, aceita um valor maior que um byte em VALOR.

a que rotina è que vc se refere? eu estou a usar a biblioteca do 24Lc256 e pelo que vi no data a memoria em questão é de 16bits certo ou errado? por isso deveria suportar este valor!

lellis
isto aqui em baixo eu entendo, vc declara uma variavel de 8bits e os valores vai atè 255, mas eu quero que vai mais longe!

unsigned int x;
write_ext_eeprom(0, x);

agora isto aqui a seguir estou voando !

write_ext_eeprom(1, x>>8);
e recuperar
x=read_ext_eeprom(0) | (unsigned int)read_ext_eeprom(1)<<8;

barboza

A função só aceita byte, então trunca o valor que você passa.

No meu caso que estou aprendendo e apanhando , e um caso è esse fazer truncamento !

No LCD, o cara não esta mostrando nada certo, vamos indo Ok!!

atè

[barboza]

Sua memória, como todas da da serie 24C... são de 8 bits.

The Microchip Technology Inc. 24AA256/24LC256/
24FC256 (24XX256*) is a 32K x 8 (256 Kbit) Serial
Electrically Erasable PROM, capable of operation
across a broad voltage range (1.8 V to 5.5 V).

Cuidado, uma coisa é ter mais bits para endereço, mas o dado armazenado é em 8 bits, ous eja 1 byte.

......

Se quer guardar variaveis maiores de 1 byte, você precisa fazer isso em passos de 1 byte.
No seu exemplo você 1 int, ou seja 2 bytes.
Uma opção é salvar como o lelis indicou ou usar ponteiros para a RAM, salvar, incrementar até a quantidade que quer. Mas deixamos isso pra depois.

Código: Selecionar todos

unsigned int x;
write_ext_eeprom(0, x);
write_ext_eeprom(1, x>>8);


Isso declara a variavel como int, 2 bytes
salva o primeiro byte
desloca 8 bits a direita, ficando com o segundo byte e salva no segundo endereço (1).

0555h
byte 1 = 55h
0555h >> 8
byte 2 = 05h

Para recuperar é o inverso já dito.


.....


Truncar é quando onde você quer salvar não suporta o tamanho que tem.
Você esta com uma variável int, 2 bytes, e passando para uma função que aceita variáveis do tipo byte, então ela irá receber e salvar o que consegue ou seja 1 byte, o primeiro.

Procure por truncamento e arredondamento para entender melhor isso.

int = 0555h
byte <- 55h

[antonio]

barboza´olha aí soh!

No seu exemplo você 1 int, ou seja 2 bytes.

Para meu espanto vc diz que uma int,eh 2 byts ,como? explica ?

Olha eu foi direitinho o livro do Fabio e na pagina 60, tabela 5.2 fala que uma variavel do tipo" int" eh de 8 bits ou seja 1 bytes

Assim como como o lellis indicou( unsigned int x; )eu pensava que eh de 8 bits na tabela fala isso! agora pode existir qualquer maneira de fazer isso !

Deixo aqui um pedido de desculpas a minha ignorancia!

[vtrx]

Para meu espanto vc diz que uma int,eh 2 byts ,como? explica ?

Se não me engano,isso depende do compilador,me corrijam se eu estiver errado.

[barboza]

Para meu espanto vc diz que uma int,eh 2 byts ,como? explica ?

Se não me engano,isso depende do compilador,me corrijam se eu estiver errado.

Sim isso depende do compilador, mas se estiver usando CCS, ai não sei....

int = 2 bytes
char = 1 byte

Como o seu problema nos leva a isso, acredito que em seu compilador int são 2 bytes.

Você já testou as indicações propostas?

[antonio]

barboza

Você já testou as indicações propostas?

Sim,testei sim como o lellis indicou e funca blz , penso que esteja correto!

Realmente eu estou a usar CCS eu esqueci se indicar qual o compilador em questão no primeiro poste, por isso o meu susto!

Eu testei com outro exemplo para armazenar um calendario, ou seja 04/02/2010 mas não deu certo, tem ideia como devo fazer??tentei do mesmo jeito anterior ,mas não vai não!

A ideia era comparar o calendario do Ds1307 com uma data memorizada na eeprom caso for igual,faz qualquer coisa!

È claro que isto è tudo teste que estouh fazendo soh pra ver como funca a eeprom,eu nunca trabalhei com eeprom por tanta bagunça

Dah uma força pro mano !!

Dah uma olhada em baixo!

[barboza]

Teste isso ai:

Código: Selecionar todos

void write_to_eeprom(int addr_eep, char *ptr_ram, int size)
{
    while (size--)
    {
        write_ext_eeprom(addr_eep++, *ptr_ram++);
    }
}

void read_from_eeprom(int addr_eep, char *ptr_ram, int size)
{
    while (size--)
    {
        *ptr_ram++ = read_ext_eeprom(addr_eep++);
    }
}

void main(void)
{
    char dia = 4;
    char mes = 2;
    int ano = 2010;

    write_to_eeprom(0, &dia, sizeof(dia));
    write_to_eeprom(1, &mes, sizeof(mes));
    write_to_eeprom(2, &ano, sizeof(ano));

    read_from_eeprom(0, &dia, sizeof(dia));
    read_from_eeprom(1, &mes, sizeof(mes));
    read_from_eeprom(2, &ano, sizeof(ano));

    lcd_gotoxy(1,1);
    printf(lcd_putc,"%02d\%02d\%04i", dia, mes, ano);

}



[antonio]

barboza
Cara funciona sim mas no ano falha ,olha em baixo o que mostra!


Não pra fazer o seguinte modo assim oh,04/02/2010 ou assim 04.02.2010

[barboza]

barboza
Cara funciona sim mas no ano falha ,olha em baixo o que mostra!


Não pra fazer o sehinte modo assim oh,04/02/2010 ou assim 04.02.2010

Poste o codigo que vc usou...
Não esta como o que te envie.

[antonio]

Não eu unicamente adaptei ao circuito que tinha como o LCD
veja o codigo!
Olha soh estas funcões que vc postou no codigo e pra trabalhar com dados tipo FLOAT, neste caso não estamos trabalhando com esses dados, ajuda aí a entender melhor !!

Código: Selecionar todos

#include <16F877A.H>
#fuses XT, NOWDT, NOPROTECT, BROWNOUT, PUT, NOLVP
#use delay(clock = 4000000)
//#use i2c(master,sda=EEPROM_SDA,scl=EEPROM_SCL)

#define EEPROM_SDA  PIN_D1
#define EEPROM_SCL  PIN_D0
#include <flex_lcd.c>
#include <24256.c>

//=====================================
void write_to_eeprom(int addr_eep, char *ptr_ram, int size)
{
    while (size--)
    {
        write_ext_eeprom(addr_eep++, *ptr_ram++);
    }
}

void read_from_eeprom(int addr_eep, char *ptr_ram, int size)
{
    while (size--)
    {
        *ptr_ram++ = read_ext_eeprom(addr_eep++);
    }
}

void main(void)
{

    char dia = 4;
    char mes = 2;
    int ano = 2010;
 lcd_init();
delay_ms(100);
printf(lcd_putc,"Start\n\r");

init_ext_eeprom();                                                           

    write_to_eeprom(0, &dia, sizeof(dia));
    write_to_eeprom(1, &mes, sizeof(mes));
    write_to_eeprom(2, &ano, sizeof(ano));

    read_from_eeprom(0, &dia, sizeof(dia));
    read_from_eeprom(1, &mes, sizeof(mes));
    read_from_eeprom(2, &ano, sizeof(ano));

    lcd_gotoxy(1,1);
    printf(lcd_putc,"%02d\%02d\%04i", dia, mes, ano);
   while(1);
}

[barboza]

Tente isso:

Mas antes de fazer control + C, control + V, entenda o q estamos fazendo.

Código: Selecionar todos

#include <16F877A.H>
#fuses XT, NOWDT, NOPROTECT, BROWNOUT, PUT, NOLVP
#use delay(clock = 4000000)
//#use i2c(master,sda=EEPROM_SDA,scl=EEPROM_SCL)

#define EEPROM_SDA  PIN_D1
#define EEPROM_SCL  PIN_D0
#include <flex_lcd.c>
#include <24256.c>

//=====================================
void write_to_eeprom(long int addr_eep, BYTE *ptr_ram, long int size)
{
    while (size--)
    {
        write_ext_eeprom(addr_eep++, *ptr_ram++);
    }
}

void read_from_eeprom(long int addr_eep, BYTE *ptr_ram, long int size)
{
    while (size--)
    {
        *ptr_ram++ = read_ext_eeprom(addr_eep++);
    }
}

void main(void)
{

    BYTE dia = 4;
    BYTE mes = 2;
    int ano = 2010;
 lcd_init();
delay_ms(100);
printf(lcd_putc,"Start\n\r");

init_ext_eeprom();                                                           

    write_to_eeprom(0, &dia, sizeof(dia));
    write_to_eeprom(1, &mes, sizeof(mes));
    write_to_eeprom(2, (BYTE *) &ano, sizeof(ano));

    read_from_eeprom(0, &dia, sizeof(dia));
    read_from_eeprom(1, &mes, sizeof(mes));
    read_from_eeprom(2, (BYTE *) &ano, sizeof(ano));

    lcd_gotoxy(1,1);
    printf(lcd_putc,"%02d/%02d/%04i", dia, mes, ano);
   while(1);
}


Achei uma referencia para 24256.c aqui:
http://user.chol.com/~ascbbs/ccscdrv2/24256.C
deve ser essa que esta usando.