Manipulação de EEPROM - parte 2

Conforme discutido em nossa postagem Manipulação de EEPROM, os dados são gravados em formato de Byte o que gera um problema porque em 1 Byte, só é possível armazenar  valor de 255 em decimal.

11111111 =  255

Quando precisamos guardar valores maiores que 255 é preciso fazer uma adaptação para que seja possível recuperar os valores armazenado. Para isso precisaremos de duas posições de memoria, onde iremos dividir o valor por 256 e armazenar o valor do Quociente numa posição da memória e o valor do resto em outra posição de memória. No exemplo abaixo, iremos armazenas o numero 72010.

Após realizar o calculo de 72010/256, iremos armazenar o valor 281 na primeira posição de memória e 74 na segunda posição de memoria. O programa abaixo mostra o codificação do caso apresentado.

#include <EEPROM.h>

void setup()
{
  Serial.begin(9600);
}

int Q;
int resto;

void loop()
{
  Serial.print("Gravando 72010 na memoria EEPROM : ");
  Q= 72010/256;
  resto = 72010%256;
  EEPROM.write(0, Q);
  Serial.printDado 1 : ");
  Serial.println(Q);
 
  EEPROM.write(1, resto);  // % operador para extrair o resto da divisão
  Serial.print("Dado 2 : ");
  Serial.println(resto);
} 


Para realizar a leitura da memória, precisaremos realizar a operação inversa, onde precisaremos ler as duas posições de memoria onde os números foram gravados, recuperar os valores e aplicar a seguinte fórmula:

Valor original = (dado1 * 256) + dado2

Segue codificação do exemplo acima.


#include <EEPROM.h>

void setup()
{
  Serial.begin(9600);
}

int Q;
int resto;

void loop()
{
  Serial.println("\nLendo numero da memoria EEPROM... ");
 
  Q = EEPROM.read(0);// lendo valor do Quociente da divisão no endereço 0 da memória
  resto = EEPROM.read(1); // lendo valor do resto da divisão no endereço 1 da memória
 
 
  Serial.print("Valor = ");
  int x = (Q * 256) + resto;
  Serial.println(x);
}e

Pratique:

Exercício 1 - Faça que se comunique com o usuário através da USB e receba um numero via USB  e salve na memória EEPROM, como sabemos que a EEPROM tem um tempo de vida, voce deve criar controles para que a memória só seja acessada quando realmente houver um dado a ser gravado.

Não esqueça do like do video e de curtir nossa pagina no facebook no link abaixo:

Manipulação de EEPROM

Todos os modelos Arduíno (pelo menos os que eu conheço) possuem uma EEPROM (Electrically Erasable Programmable Read-Only Memory).  O modelo UNO possui uma memória de 1k Byte EEPROM que pode ser usada pelos programadores em aplicações onde valores aferidos por sensores ou outros dispositivos precisam ficar armazenadas de maneira não volátil e por longos períodos de tempo. Para facilitar a vida do programador, a  biblioteca EEPROM.h que oferece as seguintes funções como:

    - EEPROM.write()

    - EEPROM.read()

    - EEPROM.update()

    - EEPROM.length()

    - EEPROM.clear

EEPROM.write escreve um byte para um determinado endereço da EEPROM cuja a sintaxe é dada por:

EEPROM.write (endereço, valor);

onde:
      endereço:  local para onde escrever, a partir de 0 ( int )
      valor: o valor a escrever, de 0 a 255 ( byte )

Exemplo:

// neste exemplo iremos gravar os números de 0 a 255 nos endereços de 0 a 255.

#include <EEPROM.h>

void setup()
{
  for (int i = 0; i < 255; i++)
    EEPROM.write(i, i)
}

void loop()
{
}

Observe que a gravação dos dados foi realizada na função setup. Isso foi feito propositalmente pois a memória EEPROM tem uma vida útil especificada de aproximadamente 100.000 ciclos de gravação / exclusão, portanto, talvez seja necessário ter cuidado com a frequência com que você escreve nela, logo evite gravar e apagar a EEPROM dentro da função loop sem uma lógica que controle essas operações.

EEPROM.read  é responsável por ler um byte para um determinado endereço da EEPROM cuja a sintaxe é dada por:

EEPROM.read (endereço);

onde:
      endereço:  local para onde ler, os endereços começam em 0 ( int )

Exemplo:

/* exemplo tirado do site arduino.cc onde os valores de 0 a 512 serão lidos e apresentados na serial */
#include <EEPROM.h>

int a = 0;
int value;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  value = EEPROM.read(a);

  Serial.print(a);
  Serial.print("\t");
  Serial.print(value);
  Serial.println();

  a = a + 1;

  if (a == 512)
    a = 0;

  delay(500);
}

EEPROM.update escreve um byte para a EEPROM. O valor é escrito apenas se diferir do que já foi salvo no mesmo endereço. A sintaxe do update é dada por:

EEPROM.update(endereço, valor);

onde:
      endereço:  local para onde escrever, a partir de 0 ( int )
      valor: o valor a escrever, de 0 a 255 ( byte )

Exemplo:

//exemplo retirado de Arduino.cc

#include <EEPROM.h>

void setup()

{

  for (int i = 0; i < 255; i++) {

    // this performs as EEPROM.write(i, i)

    EEPROM.update(i, i);

  }

  for (int i = 0; i < 255; i++) {

    // write value "12" to cell 3 only the first time

    // will not write the cell the remaining 254 times

    EEPROM.update(3, 12);

  }

}

void loop()

{

}

EEPROM.length esta função devolve um valor contendo o número de células na EEPROM. Nem todos os dispositivos têm o mesmo tamanho de EEPROM, isso pode ser útil para escrever códigos portáveis ​​para diferentes Arduinos. Como não há passagem de paraetros, a sintaxe do comando é dada por:

EEPROM.length();

Exemplo:

/* exemplo tirado do site arduino.cc onde os valores de 0 a o final da memória não importando o tamanho da memória. Os valores lidos são mostrados apresentados na serial */

#include <EEPROM.h>

int a = 0;
int value;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  value = EEPROM.read(a);

  Serial.print(a);
  Serial.print("\t");
  Serial.print(value);
  Serial.println();

  a = a + 1;

  if (a == EEPROM.length())
    a = 0;

  delay(10);
}

Pratique:

Exercício 1 - Faça um programa que se comunique com o usuário através da USB e pergunte se ele quer gravar ou ler uma informação na EEPROM. Quando a opção for ler um dado, o usuário deve digitar o endereço da informação. Quando a opção for gravar um dado, o Arduino deve saber qual é a primeira posição livre da memória para realizar a gravação.

Exercício 2 - Como descrito na teoria acima, um endereço de memória possui só 1 byte que corresponde no máximo ao valor 255 em decimal. Faça um programa onde seja possível gravar e ler um valor maior que 255 na memória da EEPROM.

Para acessar um conteúdo extra sob gravação e leitura de EEPROM clique aqui.

Não esqueça do like do vídeo e de curtir nossa pagina no facebook no link abaixo:

Uso da instrução printf e seus tags

Pertencente a biblioteca Stdio.h (Standard Input/Output- entradas e saídas padrões), comando printf é usado para escrever uma mensagem no monitor. Nesta mensagem podemos exibir tanto caracteres alfanuméricos assim como o conteúdo de variáveis. 

Sintaxe:

printf("expressão de controle",argumentos);

A expressão de controle pode conter caracteres que serão exibidos na tela e/ou códigos de formatação para os argumentos. Os argumentos são separados por vírgula. Simplificando a explicação entre aspas devemos escrever o texto que será exibido e nos argumentos indicaremos as variáveis que serão exibidas.

Exemplo 1. A instrução abaixo irá exibir a mensagem "Primeiro exemplo do uso de printf" no monitor. Neste caso, a instrução printf só utiliza a expressão de controle.

      printf("Primeiro exemplo do uso de printf");

Exatamente o texto digitado entre aspas será mostrado na tela. Se for colocado espaço(s) no inicio das aspas, o texto será exibido da mesma forma.

      printf("   Primeiro exemplo do uso de printf");

O printf sempre iniciará a exibição na ultima posição em que o curso se encontra. Se a instrução printf for usada duas vezes na sequencia o texto será exibido na mesma linha.

      printf("Nao adianta usar 2 vezes a instrucao printf");

      printf("o texto sempre sera escrito na sequencia");

Note que a ultima palavra do primeiro comando printf (palavras em vermelho) aparecerá junto da vogal "o" do inicio do segundo printf. Isso ocorre porque o texto sempre é iniciado na ultima posição do cursor que neste caso era logo após a palavra "printf". A figura 1 mostra como ficará o texto.

Figura 1. A palavra "printf" aparece junto da vogal "o".

Para solucionar isso basta acrescentar espaços no inicio do segundo printf conforme mostra o codigo abaixo e a figura 2. 

      printf("Nao adianta usar 2 vezes a instrucao printf");

      printf("   o texto sempre sera escrito na sequencia");

Figura 2. A seta vermelha indica onde os espaços foram foram inseridos.

A expressão do comando printf pode conter códigos de formatação que indicam como os textos devem ser impressos. Por exemplo, quando queremos escrever um texto em linhas diferentes devemos colocar o tag \n no local onde desejamos pular a linha.

      printf("Nao adianta usar 2 vezes a instrucao printf\n");

      printf("o texto sempre sera escrito na sequencia");

A figura 3 mostra o texto em duas linhas em consequência do uso do tag \n.

Figura 3. Indicação do uso do tag \n no printf

Podemos usar um único printf e usar quantos tags de pular linha forem necessários. Olhe a instrução abaixo e veja como o texto será exibido na tela na figura 4.

printf("Podemos usar somente 1 printf \ne pular linha sempre que necessario\n\npodemos pular quantas linhas forem necessarias\n\n\n\neste caso pulamos 4 linhas");

Figura 4. Todo o texto apresentado na imagem foi digitado em um único printf.

A figura 5 mostra uma tabela com tags que podem ser usados para formatar textos no printf.

Figura 5. Tags que podem ser usados no printf.

Mostrando variáveis no printf

Os conteúdos das variáveis também são exibidos na tela utilizando o comando pinrtf. Para isso devemos indicar na expressão de controle do comando que tipo de variável que será exibida e mostrar no argumento a variável que desejamos mostrar o conteúdo na tela. Abaixo temos como ficará a instrução printf quando desejamos exibir uma variável.

Figura 6. 

No caso da instrução acima o programa irá exibir o conteúdo de uma variável do tipo inteiro "chamada" numero. A informação que uma variável que será exibida é do tipo inteiro é dada pelo formatador %d mostrada na expressão de controle da instrução. Cada tipo de dado terá um formatador especifico como mostra a tabela abaixo.

Figura 7. Formatadores e suas funções

O printf pode exibir mais de uma variável assim como exibir variáveis e textos. Veja o exemplo de código na figura 8 e o programa sendo executado na figura 9.

Figura 8. Código mostrando o uso do printf onde são exibidas variáveis.

Figura 9. Execução do programa do código apresentado na figura 8.

É possível exibir mais de uma variável no mesmo printf. Para isso, é preciso colocar o numero de formatadores na expressão de controle equivalente ao numero de variáveis que iremos exibir e os respectivos identificados na sequencia que serão exibidos na expressão do comando. As instruções abaixo mostram um exemplo da exibição de mais de uma variável no printf.

printf("\n\n Vou exibir a variavel A,B,C e D na sequencia %d %d %d %d \n\n\n\n\n", a, b, c, d); 

printf("\n\n Tambem podemos ter texto intercalando a exibicao das varaiveis \n exemplo A= %d na sequencia temos B = %d\n\n", a, b); 

Durante a execução do programa, as formatações de inteiros %d mostradas nas instruções acima estão marcadas com setas na figura 10.

Figura 10. Execução de programa onde são exibidas mais de 1 variável por printf.

Ainda ta com duvida, curta nossa pagina no facebook e poste sua duvida lá....