Boa tarde a todos.

Sabemos que a função EEPROM.put(), usa EEPROM.update() para realizar a gravação, portanto, não reescreve o valor se ele não foi alterado, conforme Nota: https://www.arduino.cc/en/Reference/EEPROMPut

Estou com uma dúvida, se:

1) a função valida o conteúdo da variável passada no parâmetro como um todo, ou 

2) a função valida cada byte do conteúdo da variável passada no parámetro. (imagino que o mais lógico seja essa, porém não achei documentação clara a respeito)

exemplo:


byte teste[2];
teste[0] = 128; //B10000000

teste[1] = 128; //B10000000


EEPROM.put(0, teste); //add0  add1  add2 add3 etc...                     

                                 //128   128    ???   ???   ???

teste[1] = 127; //B01111111

                                 

EEPROM.put(0, teste);

/*aqui vem a dúvida,  a EEPROM queima DOIS ciclos um para teste[0] e outro para teste[1] pq teste é diferente, ou queima UM ciclo para teste[1] porque apenas esse byte é diferente?*/

Alguém sabe a resposta, e onde posso achar essa confirmação?
Grato

Exibições: 110

Responder esta

Respostas a este tópico

olá Antoneli.

      Observe que o vetor "teste[]" tem um tamanho que vc definiu (2 bytes no seu exemplo).  E quando vc chama o "put()", vc passa o endereço inicial onde quer que seja gravado na EEPROM, além de um Ponteiro para o objeto que será gravado (neste caso o próprio "test[]").   Lá dentro da função "put"  é então obtido o tamanho em bytes, do objeto a ser gravado (usando a função "sizeof"),  e em seguida cada byte é lido da EEPROM  a partir do endereço que vc informou no "put()".  E cada byte lido,  é comparado com o correspondente byte do objeto que vc apontou (o "teste[]").  Se a função "put" encontra um byte diferente,  então ela procede à gravação propriamente dita da EEPROM,  e isto é considerado um ciclo de gravação (independente da quantidade total de bytes no Vetor "teste[]", ou da quantidade de bytes que vc alterou naquele Vetor).

      Ou seja, se possível evite alterar um byte apenas no seu Vetor e já proceder à gravação (mesmo que esteja usando o "put()"), pois se de fato o Vetor ficou diferente do que está atualmente na EEPROM, então o processo de gravação será efetivo e um ciclo da vida útil da EEPROM estará sendo contado.

      Assim, o mais interessante (claro, isto se a funcionalidade do seu Sistema permitir) seria vc só iniciar uma gravação (via "put" por exemplo), quando tiver alterado vários bytes no seu Vetor "teste[]", pois se um único byte estiver diferente  do que está na EEPROM,  fará o "put" executar um ciclo de gravação.

     Em outras palavras:  cada chamada  à função "put" corresponderá  a  um único ciclo de gravação,  desde que  pelo menos  um  byte  do seu objeto de dados seja diferente  do que está gravado na EEPROM.   Ou ainda:  não é  a quantidade de bytes alterados que determina a contagem dos ciclos de gravação,  mas sim cada chamada ao "put()" (desde que ao menos um byte tenha sido alterado).

     Há mais detalhes interessantes sobre o ciclo de gravação da EEPROM (embora alguns detalhes dependam do Processador da plataforma).  Como por exemplo o fato de que efetivamente somente os "0" são gravados  e que um apagamento é necessário apenas quando um bit qualquer estiver em "0" e precisar "voltar" pra "1".  Na maioria dos Processadores,  existe uma Máquina de Estados em Hardware (ou seja, um "Controlador da EEPROM")  que conduz o processo de gravação e interage com a execução do código pelo Processador . E ainda há outros detalhes curiosos sobre o processo de gravação.

      Espero ter ajudado.

      abrçs,

      Elcids

ah,  tentando ser ainda mais claro:

      Tomando o código de exemplo que vc postou,  se for feita naquela sequencia, contará como 2 ciclos de gravação.  Isto porque quando vc chama o "put"  pela segunda vez,  vc alterou o Vetor em relação ao que estava já gravado (primeira chamada ao "put"),  então o "put"  detecta a diferença dos dados (nem que seja um único bit que mudou) e então executa um novo ciclo de gravação (ou "queima" de um ciclo de gravação, se vc prefere dizer assim).

      Assim naquele seu exemplo,  ao chamar o "put"  pela segunda vez,  não faz diferença se vc alterou só um byte ou mais bytes no seu Vetor,  pois como vc alterou algum dado no Vetor,   a segunda chamada ao "put"  contará como um ciclo adicional de gravação.

     Então fique atento à taxa que vc chama o "put" (claro, só será executado um ciclo de gravação  se algum dado mudou em relação ao que está na EEPROM).

     abrçs,

     Elcids

Primeiramente obrigado pela resposta.

Vamos ver se entendi, então se eu precisar alterar um vetor de 50 bytes e por exemplo os 50 bytes forem

alterados de A para B sendo que atualmente na EEPROM os 50 bytes possuem o valor A.

byte vetor[50];

for(int i=0; i<50; i++)

  vetor[i]='B';

se fizer isso:

EEPROM.PUT(0, vetor) ;  -> aqui eu utilizo apenas 1 ciclo pois estou fazendo 1 único put de 50bytes "ao mesmo tempo", embora esteja alterando 50 bytes.

ou se fizer isso:

for(int i=0; i<50; i++)

   EEPROM.put(vetor[i]);  -> aqui eu utilizo 50 ciclos?

Att.

Antoneli

sim,

      isso mesmo Antoneli, vai ocorrer exatamente como vc descreveu.

      Ou seja, o que conta é o número de vezes  que vc chama o "put()",  desde que algum valor no objeto que vc está passando ao "put"  seja diferente do valor que está armazenado na EEPROM.

      E não há no hardware do Processador (em mais de 35 anos nessa área, eu nunca vi),  um contador dos ciclos de gravação já executados.  Ou seja,  caso vc queira saber quanto já "queimou" de ciclos de gravação,  terá que fazer essa contagem por sua conta mesmo (e claro, vc tem que detectar que a cada chamada ao "put", algum dado do "objeto passado" foi alterado, já que o próprio "put" não te informa se de fato ele efetivamente gravou).  Mas lembre-se: vc terá que armazenar essa contagem em uma memória também não volátil,  e o caminho mais óbvio é a própria EEPROM, ou seja, na estrutura de dados que vc gravar vc precisaria reservar um campo justamente para sempre armazenar a contagem de ciclos (algo que é incomum de se ver por aí,  e aí também está um dos  empecilhos pra que encontremos algo semelhante implementado no próprio Hardware de um Processador).

     E note que alguns Processadores tem uma EEPROM  emulada  através de Flash, caso por exemplo do ESP8266.  Assim a contagem máxima de ciclos depende desta Flash (chip separado do ESP),  é um parâmetro de fábrica do chip de Memória.  E no caso do ESP8266, quem manda na contagem de ciclos  é o "commit", pois é esta função que de fato grava na Flash (o "put"  apenas coloca os dados a serem gravados em um Vetor que foi reservado quando vc criou o "objeto EEPROM").

     Outra observação interessante, é que uma Flash  é na verdade um "tipo" de EEPROM, porém menos robusta.  Explicando:  o Transistor  que é usado para armazenar um bit  na Flash,  é fisicamente menor que o Transistor  em uma EEPROM "autêntica", e por isso menos robusto,  tendo uma vida útil menor.  Por consequência,  o limite máximo de ciclos é menor em uma Flash (pois os Transistores  sendo menores, aguentam menos as "pancadas" da tensão "VPP" gerada no processo de gravação).  Por outro lado,  como na Flash o referido Transistor é menor,  a Flash também tem uma capacidade de armazenamento (tamanho da Memória, em bits) bem maior que na EEPROM.

      abrçs,

      Elcids

Boa noite AT. (se não gosta que te chame pelas iniciais, avise).

A função EEPROM.put() realmente utiliza a função EEPROM.update() para gravar os dados na EPROM.

A função EEPROM.put() identifica quantos bytes serão gravados na EEPROM em função do tipo da variável

a ser gravada.

Se você definir a vaiável como byte, a função EEPROM.put() vai gravar somente um byte.

Se definir o tipo como int ou unsigned int, ela vai gravar 2 bytes,

se definir  o tipo como long, unsigned long ou float, ela vai gravar 4 bytes.

Como a função EEPROM.put() usa a função EEPROM.update() para esta gravação, se a variável for byte ela vai verificar se o valor é ou não igual ao guardado.

RV mineirin

Eu me interesso por este assunto porque faço a re-programação de rádios INTRACO que exige o conhecimento de memórias EPROM e E2PROM.

No meu fórum no CLUBE do HARDWARE há um post sobre um programa que faz a divisão de memória ou re-paginação delas para facilitar o uso do espaço disponível de acordo com sua capacidade e espaço de memórias disponíveis.

E sugiro visitarem meu BLOG no:  www.clubedohardware.com.br

Ao entrar digite no campo BUSCA :  INTRACO 7000

Vale lembrar que no FÓRUM há um vasto seguimento de assuntos e que para incluir todos eles, foi necessária a criação de 2 páginas que poderá passar despercebida caso o leitor ou visitante não se atente ao fato.

PU4ASL - 73

RSS

© 2021   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço