Eeprom atmega328

[Queiros19]

Boa tarde fórum Clube do Hardware!

Tenho um Arduino Uno em casa a funcionar com Automação residencial e tenho o ATMEGA328 a fazer um acesso a EEPROM de 2 em 2 seg durante pelo menos 20h, o que da um total de 32mil acessos acho eu, será que gasta de forma significativamente a EEPROM? Ja ouvi falar em 100.000 acessos, é verdade?

[vtrx]

Se for Eeprom interna, sim.

[ricardospimentel]

Lá no datachite do Atmega328 fala-se de 100.000 ciclos de escrita e limpeza (write/erase) como afirmaste Vtrx. Tirando isso, acredito que as operações de leitura não contam e podem ser realizadas até o fim dos tempos. Se eu estiver errado, me corrijam, por favor.

[RR1000]

Boa tarde fórum Clube do Hardware!

Tenho um Arduino Uno em casa a funcionar com Automação residencial e tenho o ATMEGA328 a fazer um acesso a EEPROM de 2 em 2 seg durante pelo menos 20h, o que da um total de 32mil acessos acho eu, será que gasta de forma significativamente a EEPROM? Ja ouvi falar em 100.000 acessos, é verdade?

Qual seria a finalidade da leitura? não seria o caso de um cartão externo SD.

[Queiros19]

Apenas a usar a EEPROM do atmega328 para guardar os valores da saídas do meu sistema de automação residencial em caso de falha de energia, manter as saídas no mesmo valor, mas vou ter de arranjar uma maneira de aceder a EEpROm o menor número de vezes possível, como por exemplo, esperar e testar as alterações e caso exista uma alteração ai sim, grava na eeprom caso contraio, nem lá vai mexer!

Mas e no caso de ser uma eeprom externa?

Alguém tem alguma rotina que consiga mexer numa eeprom externa via I2C?

[aphawk]

Não há nenhuma restrição quanto a leituras na EEprom.

Mas quando voce faz uma gravação em um simples byte, isso sim degrada a EEprom, e a estimativa minima que a Atmel garante são 100.000 escritas antes de a eeprom começar a falhar nas gravações.

Mesmo se você usar uma eeprom externa ela também vai falhar mais ou menos com 1 milhão de escritas, ou seja, apenas atrasa o problema....

Eu sugiro você usar uma RAM normal, assim você pode gravar e alterar quantas vezes quiser, e em caso de queda de energia, fazer um simples sistema de backup com bateria para aguentar enquanto o conteúdo da RAM é passado para a EEprom do Atmega, que é um tempo pequeno, e logo depois desligar o circuito todo.

Segue um excelente exemplo de como usar uma SRAM I2C com um Arduíno :

http://arduino-related.livejournal.com/1414.html

Paulo

[Queiros19]

boa noite, comprei o PCF8570 aqui numa loja, e fiz a experiencia, implementei no meu sistema de automação, mas apanhei um problema, esta a funcionar a aceder tudo maravilha, mas quando faço reset ao Arduino (mesmo sem retirar alimentação do PCF8570) as variaveis vão todas a zero, exprimentei até a alimentaçaõ individual, só para o PCF e continua a dar reset, alguem me pode ajudar?

[vtrx]

use uma 24C16 ou24C512.

PCF8570 é uma RAM.

[Queiros19]

Tenho uma 24C04WP e uma 24LC32A, alguém me arranja uma rotina para uma delas?

[ricardospimentel]

Lá na última página do datachite na versão da NXP fala do Power Saving Mode e podes ou deixar o uC controlar tal estado ou simplesmente utilizar um pull-up no pino test.

[Queiros19]

Boa noite ricardospimentel, não percebi o que seu post, peço-lhe que repita sff

Obrigado

[vtrx]

Qual a linguagem de programação voce está usando e qual compilador?

[ricardospimentel]

Oi Vtrx, dá-me só uma licencinha para responder ao colega sobre a questão acima, rapidim:

Eu estava falando do PCF8570. Já experimentou o modo Power Saving dele (aquele modo explicado nas últimas páginas do datachite (datasheet) da NXP)? Acho que esta função é apenas para colocar o chip em modo de economia, mas como não sei como programas teu chip, então tenta este teste. Quem sabe é isso!?

Outra possibilidade é a de se seu programa estar zerando suas variáveis no momento do reset do seu microcontrolador.

Por favor me desculpe se não entendi, mas o que quer dizer "sff"?

Pronto, fim da "licencinha", he-hê!

[Queiros19]

Bom dia ricardospimentel, ja não estou casa e ja não tenho o código a minha beira, mas a cena de estar a resetar as variáveis dentro do iniciador parece-me uma solução valida, secalhar distraído estou a fazer isso, tenho de ir ver isso!

Ontem acabei por me esquecer de ir ver o datasheet mas hoje vejo e logo te digo alguma coisa se tiver alguma duvida!

Sff = se faz favor xD

Bom dia vtrx, uso uma board Arduino Uno e programo com a IDE da Arduino!

[aphawk]

Segue um excelente exemplo de como usar uma SRAM I2C com um Arduíno :

http://arduino-related.livejournal.com/1414.html

Paulo

Oi Queiros,

Acho que você não viu o link que postei algumas mensagens acima.... é código feito para Arduíno mesmo, e bem simples de se usar.

Quanto a zerar a memória, voce tem de criar um tipo de flag e ver se existem dados válidos na memória, e se for o caso, tem de continuar de onde parou. Eu também acho que o seu próprio programa está zerando as variáveis, pois olhei o datasheet de cabo a rabo, e não tem nenhuma possibilidade de estar zerando por algum problema das linhas SDA e SCL.

Paulo

[Queiros19]

Vi sim seu link, vi ontem e fui a correr comprar um PCF8570, paguei 5€ por um CI. De 6 pernos

Vou testar o reset das variáveis porque creio que seja isso.

É com o PCF8570 que estou a ter esse problema!

apresento aqui a definição das variaveis

boolean valuea;
boolean valueb;
boolean valuec;
boolean valued;
boolean valuee;

tem aqui a inicialização da comunicação I2C

void setup()
{
  Wire.begin();
  Serial.begin(57600);

as rototinas que estou a usar

void [COLOR="Red"]memw[/COLOR](int i2c_addr, word address, byte data)  //Write to i2c SRAM
{
  Wire.beginTransmission(i2c_addr);
  Wire.write((byte)lowByte(address)); 
  Wire.write((byte)highByte(address)); 
  Wire.write(data); 
  Wire.endTransmission(); 
}


byte [COLOR="Lime"]memr[/COLOR](int i2c_addr, word address) //Read from i2c SRAM
{
  Wire.beginTransmission(i2c_addr);
  Wire.write((byte)lowByte(address)); 
  Wire.write((byte)highByte(address)); 
  Wire.endTransmission();
  Wire.requestFrom(i2c_addr,1);

  if(Wire.available())
  { return Wire.read(); } 
  return B00000000;
}

e aqui a maneira como as acesso

void ramwrite()
{
 [COLOR="Red"] memw[/COLOR](addr_ram,20, valuea);
  [COLOR="red"]memw[/COLOR](addr_ram,21, valueb);
  [COLOR="red"]memw[/COLOR](addr_ram,22, valuec);
  [COLOR="red"]memw[/COLOR](addr_ram,23, valued);
  [COLOR="red"]memw[/COLOR](addr_ram,24, valuee);  
}

void ramread()
{
  valuea = [COLOR="Lime"]memr[/COLOR](addr_ram,20);
  valueb = [COLOR="lime"]memr[/COLOR](addr_ram,21);
  valuec = [COLOR="lime"]memr[/COLOR](addr_ram,22);
  valued = [COLOR="lime"]memr[/COLOR](addr_ram,23);
  valuee = [COLOR="lime"]memr[/COLOR](addr_ram,24);
  if(valuea == 1){digitalWrite(candd,HIGH);}
  if(valuea == 0){digitalWrite(candd,LOW);}
  if(valuea == 1){digitalWrite(cande,HIGH);}
  if(valuea == 0){digitalWrite(cande,LOW);}
  if(valuea == 1){digitalWrite(tv,HIGH);}
  if(valuea == 0){digitalWrite(tv,LOW);}
  if(valuea == 1){digitalWrite(rad,HIGH);}
  if(valuea == 0){digitalWrite(rad,LOW);}
  if(valuea == 1){digitalWrite(tom,HIGH);}
  if(valuea == 0){digitalWrite(tom,LOW);}  
}

e estou a seguir o link que o aphawk me indicou

este aqui:

http://arduino-related.livejournal.com/1414.html

[Visitante]

geralmente memorias nao volateis tem ciclos de escrita e leitura limitados