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:

Função MAP ()

Como o próprio nome diz, a função map() do Arduíno faz o mapeamento de um intervalo numérico em outro intervalo numérico desejado. Conforme figura 1, notamos que  um intervalo numérico que vai de um valor mínimo até um valor máximo, será mapeado para um novo valor de saída definido pelo programador.

Figura 1. Adicionar legenda

A sintaxe da função map() é dado por:

map (x, IN_min, IN_max, OUT_min, OUT_max);

onde temos:

X               - Variável com valor a ser convertido.
IN_min     -  Limite inferior do intervalo de entrada
IN_max    -  Limite superior do intervalo de entrada
OUT_min - Limite inferior do intervalo de saída
OUT_max- Limite superior do intervalo de saída

Essa função pode ser interessante quando queremos modular um pulso usando PWM (se não conhece PWM clique aqui) que será controlado por um potenciômetro. Considerando que os valores medidos no potenciômetro podem variar de 0 a 1023 para realizar o mapeamento será necessário implementar o seguinte código:

void loop()

{

  

  potenciometro = analogRead(5); //Leitura do analógico onde o potenciômetro esta ligado

  

  Converte= map(potenciometro,0,1023,0,255);

  

  analogWrite(10,Converte); //Escrita no pino digital com PWM

} 

A implementação do código acima pode ser visto no vídeo clicando na figura abaixo. Neste vídeo, iremos controlar a velocidade de um motor DC com um potenciômetro.  

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

Operador de Concatenação

Quando uma seleção de dados é realizada através do comando Select você pode vincular colunas à outras colunas assim como adicionar String ao resultado da sua consulta, usando o operador de concatenação  | | . onde as colunas/strings em cada lado do operador são concatenadas para formar uma coluna de saída única. Para entender melhor, observe a figura 1 onde temos uma tabela aluno. Nesta tabela, o endereço do aluno esta dividido em 3 campos: Logradouro, compl_aluno e cidade_aluno e o nome esta dividido em nome_aluno e sobrenome_aluno.

Figura 1. Tabela de alunos

Usando as informações apresentadas na figura 1, a concatenação entre os campos usados para forma o endereço do aluno sera dado por: (logradouro||compl_aluno||cidade_aluno) e resultando da seleção usando a concatenação de colunas é apresentada na figura 2.

Select logradouro||compl_aluno||cidade_aluno From aluno;

Figura 2. Seleção usando concatenação dos campo de endereço

Lembrando que o nome da coluna que será exibido pode ser renomeado usando a clausula AS conforme figura 3.

Figura 3. Seleção usando concatenação e renomeação de colunas usando clausula AS.

Assim como concatenar colunas, é possível criar seleções adicionando Strings ao conteúdo selecionado na tabela. Abaixo é possível verificar o comando usado para realizar a concatenação de colunas e uma string e o resultado desta concatenação é apresentado na figura 4. 

SELECT nome_aluno||' mora na '|| logradouro AS teste_concatenação FROM aluno;

Figura 4. Resultado de seleção usando concatenação de colunas (nome_aluno e logradouro) e da string 'mora na'.

No exemplo acima foi concatenada a String 'mora na' aos campos nome_aluno e logradouro. Não esqueça que todas vez que uma string for concatenada, o valor dessa string deve estar entre aspas simples.

Espero que tenha ajudado, se curtiu nosso conteúdo, curtas nossas redes sociais....

Estruturas de controle: Comando de Decisão - Pseudocódigo

Em nossa postagem anterior falamos sobre o comando decisão, sua importância e como usa-lo (clique aqui para acessar nossa postagem anterior). Baseado nos mesmos exemplos iremos mostrar como trabalhar com os comandos de decisão. Na figura 1 abaixo temos o exemplo de um fluxograma e o pseudocódigo equivalente de um programa que calcula a média de duas notas digitadas via teclado. 

Figura 1. Fluxograma de programa para calcular média.

Algoritmo MEDIA_2_NOTAS
Var
   N1      : real
   N2      : real
   Media : real

Inicio
  leia N1, N2
  Media=(N1+N2)/2
  escreva Media
Fim

No pseudocódigo acima temos a representação de um programa que irá calcular e exibir a média de duas notas digitadas via teclado. Agora vamos imaginar um programa onde é necessário exibir a mensagem "Aluno aprovado" ou "Aluno reprovado" em função do resultado da média onde todo aluno com média inferior a 6,0 esta reprovado.

Note que é impossível o aluno estar aprovado e reprovado ao mesmo tempo, ou seja, nosso programa deverá "escolher" qual mensagem será exibida. Neste caso será obrigatório o uso de comandos de decisão.

Comando de decisão- São estruturas lógicas condicionais onde uma decisão é tomada baseada numa condição especifica cujo resultado sempre será Verdadeiro ou Falso. Se a condição for verdadeira, pode-se executar uma instrução ou conjunto de instruções. Se a condição não for verdadeira (Falsa), pode-se executar outro conjunto de instruções.

Em pseudocódigo, o comando de decisão é representado pela sequencia de instruções discriminadas abaixo. O equivalente em fluxograma esta representado na figura 2.

Figura 2. fluxograma do comando de decisão.

se (condição) então
 
   instruções se condição for verdadeira

senão

   instruções se condição não for verdadeira

fim_se
 

A primeira linha de instrução é o Se (condição) então onde o programa irá tomar a decisão sobre qual bloco de instruções ele irá executar. Logo abaixo desta primeira instrução, temos todas a instruções que serão executadas pelo programa caso a condição seja verdadeira. Já a instrução senão marca o inicio do bloco de instruções que será executado caso a condição for falsa (senão for verdadeira). O comando de decisão em pseudo código deve ser sempre finalizado com a instrução fim_se. Agora que já conhecemos a estrutura de decisão precisamos definir onde o comando de decisão será inserido no exemplo apresentado na figura 1 para que nosso programa funcione corretamente. Neste caso iremos analisar a média das duas notas para saber se o aluno foi aprovado ou reprovado, logo nosso comando de decisão deverá ser inserido após o calculo da média conforme indicado na figura 3.

Figura 3. Seta vermelha indica onde devemos inserir o comando de decisão.

Definido onde o comando de decisão será inserido no fluxograma, será necessário definir a condição e quais instruções serão executadas caso a condição seja verdadeira ou falsa. Em nosso caso, a condição será a média menor que 6,0 (media < 6,0) logo se a média< 6,0 (verdadeiro) exibiremos a mensagem "Aluno reprovado", se a média não for menor que 6,0(falso) exibiremos a mensagem "Aluno aprovado". Neste o fluxograma (figura 4) e pseudocódigo que ficarão conforme indicado abaixo.

Figura 4. Fluxograma do calculo de média .

Algoritmo MEDIA_2_NOTAS
Var
   N1      : real
   N2      : real
   Media : real

Inicio

  leia N1, N2

  Media=(N1+N2)/2

  se (media <6 ) então

   escreva "aluno Reprovado"

  senão

   escreva "aluno Aprovado"

  fim_se

Fim

Notamos que na condição temos:   media < 6 onde o sinal "<"  é o que chamamos de operador relacional. A tabela I abaixo mostra os operadores relacionais usados nos comandos de decisão.

Tabela I, Operadores relacionais.

Os operadores relacionais podem ser usados de acordo com sua necessidade ou da maneira que o programador considerar mais conveniente, olhe nossa postagem sobre comando de decisão em fluxograma e confira que um mesmo exercício pode ser feito de maneiras diferentes.

Todo comando "se" deve ser finalizado com um  fim_se. O fim_se indica que sua estrutura de decisão foi finalizada e qualquer instrução após o fim do comando de decisão será executada independente se a condição lógica for verdadeira ou falsa. Observe os fluxogramas da figura 5 abaixo e seus respectivos pseudocódigos logo abaixo:

Figura 6. A importância de definir o local exato do o comando de decisão termina.

Notamos que no Caso A a media será exibida após a finalização do comando de decisão, já no Caso B, a media será exibida antes do termino do comando de decisão dentro da condição verdadeira desse controle. Em termos mais práticos, no Caso A a média será exibida independente se o aluno foi aprovado ou reprovado, já no Caso B a média só será exibida se o aluno for reprovado.
Alguns casos podemos ter um comando de decisão onde a condição falsa é descartada, nestes casos temos o chamado desvio condicional simples e o fluxograma é representado como na figura 6.

Figura 6. Desvio condicional simples.

Algoritmo MEDIA_2_NOTAS
Var
   N1      : real
   N2      : real
   Media : real

Inicio

  leia N1, N2

  Media=(N1+N2)/2

  se (media <6 ) então

   escreva "aluno Reprovado"

 fim_se

Fim

Neste caso temos somente o comando se e a condição, as instruções que serão executadas caso a condição seja verdadeira e finalizamos o comando de decisão com o fim_se.

Atenção: O comando de decisão com desvio condicional simples sempre deve ter a condição verdadeira da condição apresentada no comando de decisão. Não é usual ter um comando de decisão com instruções somente na saída falsa do comando.

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