Como usar a EEPROM no Arduino

cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br


Neste tutorial, veremos a memória EEPROM no Arduino. A memória EEPROM é um tipo de memória externa na qual o Arduino pode gravar. Você pode usá-lo para armazenar arquivos e registrar dados do sensor. Para demonstrar como usar a memória EEPROM no Arduino, criaremos um projeto que lê a temperatura de um termistor e grava os dados do sensor em uma EEPROM externa.

Anúncio PCBWay

Da ROM para a EEPROM

ROM significa Memória Somente Leitura e foi usada nos primeiros microcontroladores para armazenar tipicamente o sistema operacional do computador. De fato, o que foi usado foi o PROM (Programmable Read-Only Memory) e é programado ou “queimado” externamente em um programador especial com altas tensões. E uma vez programado, torna-se imutável e precisa voltar desde o início.

A EPROM (memória somente leitura programável apagável) surgiu em seguida. Tem uma pequena janela de vidro e pode ser apagada sob uma forte luz UV. Em seguida, pode levá-lo de volta ao programador e fazer novamente o chamado “gravar e travar”. Depois veio a EEPROM ou a memória somente leitura programável apagável eletricamente. Com isso, você pode reter os chips e voltar para a borracha UV no local.

Capacidade EEPROM

Com a criação da EEPROM, a ROM não é mais um dispositivo somente leitura, mas algo que você pode escrever de volta semelhante à RAM (Memória de Acesso Aleatório). A EEPROM é consideravelmente mais lenta que a RAM e tem uma limitação quanto ao número de gravações (normalmente 1 milhão). Mas isso não deve ser um problema, porque existem 2 versões da EEPROM. A primeira versão é onde você pode gravar dados de maneira paralela em bytes e a outra é a serial usando I2C onde você escreve de maneira serial. Possui uma vida útil limitada de retenção de dados, que normalmente é de 10 anos.

Leia Também  Domótica: O que é e como funciona?

A memória flash veio a seguir e foi capaz de armazenar muito mais dados no mesmo tamanho. Embora a EEPROM possa ser escrita byte a byte, a memória flash grava em blocos ou em grandes blocos, tipicamente 512 bytes por vez. Observe que o número de vezes que você pode escrever é geralmente 100.000, portanto, você precisa gerenciar isso.

O tamanho da memória EEPROM pode ser enganoso, pois geralmente é especificado em bits e não em bytes. Uma EEPROM de 256K pode armazenar 256K bits de dados ou apenas 32K bytes, cerca de 16 páginas de texto sem formatação. Além disso, ele funciona como uma memória não volátil, o que significa que ele pode reter sua memória mesmo após o ciclo de energia voltar (em oposição à memória volátil que perde seu conteúdo após a remoção da energia).

O que há dentro do chip?

Normalmente, cada bit de memória é composto de dois transistores de efeito de campo ou FETs. Uma delas é a memória FET, que possui um portão flutuante que pode ser carregado ou descarregado. Pode ser definido como 1 ou 0. O segundo FET é o portão que permite que o primeiro seja gravado ou lido.

Como usar a EEPROM no Arduino 1
Diferentes tipos de EEPROMs

Por que adicionar uma EEPROM externa e não apenas usar um cartão SD? A EEPROM é muito mais rápida para ler e gravar do que em um cartão SD. Possui mais espaço (32kB em comparação com 1kB no UNO) e é mais estável do que um cartão SD que pode cair fora de seu compartimento devido a vibrações.

Além disso, o I2O protocolo C facilita o uso em comparação com o SPI usado nos cartões SD. O 24LC256 vem em diferentes variações. É mostrado acima um pacote DIP IC, uma placa de interrupção que inclui resistores pull-up e uma mais sofisticada com seletores de endereço embutidos.

Leia Também  12 lições chave que você pode aprender com o Kickstarter para o seu negócio!

Usando EEPROM no Arduino

Agora, vamos construir um projeto que gravará dados de temperatura de um termistor na EEPROM. Um termistor é um resistor que altera a resistência com a temperatura. Para mais informações sobre termistores, leia aqui.

cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br

Peças necessárias

Como usar a EEPROM no Arduino 3

Definir o endereço

Se você deseja conectar mais de uma EEPROM 24LC256 a um microcontrolador, será necessário variar os endereços de cada um, utilizando os pinos 1 a 3, altos ou baixos. Como existem três (3) linhas de endereço, pode haver 8 dispositivos EEPROM (23= 8) Mas cada um deve ter um endereço único. Se você estiver usando apenas um, aterre os 3 pinos e obterá um endereço de 0x50. O pino de proteção contra gravação, pino 7, geralmente fica alto, mas o deixa baixo.

Conecte a junção do termistor e o resistor de 10k a A0. Observe que os parâmetros para a equação de Steinhart dependem do tipo específico de termistor que você está usando. Se você tiver um diferente, seus resultados podem variar, mas você pode calcular os parâmetros aqui.

Código do Projeto

#include 
#define xAddr 0x50 //defines the base address of the external EEPROM
byte hiByte;
byte loByte;
byte i;
char buffer[10];
char newStr[10];
unsigned int eepromAdd = 0;
int ThermistorPin = A0;
int Vo;
float R1 = 10000;
float logR2, R2, T;
float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;

void setup() {
  Serial.begin(9600);
  Wire.begin(); //creates a Wire object

  /*
  //write an integer 
  int myInt = 5678;
  hiByte = highByte(myInt); //breaks up into into 2 bytes
  loByte = lowByte(myInt);
  writeEEPROM(xAddr, eepromAdd, hiByte); //write a byte
  writeEEPROM(xAddr, eepromAdd+1, loByte); //write a byte
  //now read it back
  hiByte = readEEPROM(xAddr, eepromAdd);
  loByte = readEEPROM(xAddr, eepromAdd + 1); //step 1
  int newInt = word(hiByte, loByte);
  Serial.println(newInt); 
  */
}

void loop() {
  Vo = analogRead(ThermistorPin);
  R2 = R1 * (1023.0 / (float)Vo - 1.0);
  logR2 = log(R2);
  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
  T = T - 273.15; //in centigrade
  //T = (T * 9.0)/ 5.0 + 32.0; // un-comment for Fahrenheit

  Serial.print("Temperature measured: "); 
  Serial.print(T);
  Serial.println(" C"); 
  delay(500);

  //convert float to string and write it to the EEPROM
  char chrFloat[] = "";; 
  char buffer[10];
  dtostrf(T, 6, 4, buffer);  //6 is minimum width, 4 is precision; float value is copied onto buff
  strcat( chrFloat, buffer); //append the converted (float now string)
 
  //write the string:
  for(byte i=0; i<=strlen(chrFloat);i++)
     writeEEPROM(xAddr, eepromAdd+i, chrFloat[i]); //write a byte

  //read it back:
  for(i=0; i<=strlen(chrFloat);i++)
      newStr[i] = readEEPROM(xAddr, eepromAdd + i); //read a byte 
  newStr[i] = 0;
  
  Serial.print("Temperature from EEPROM "); 
  Serial.println(atof(newStr),2); //convert ASCII to float with 2 decimals
}

//write a byte or single char - less than 256
void writeEEPROM(int devAddr, unsigned int eeAddr, byte data ) {
  Wire.beginTransmission(devAddr);
  Wire.write((byte)eeAddr >> 8);      //writes the most significant byte, move LSB off to right to get rid of it
  Wire.write((byte)eeAddr & 0xFF);    //writes the least significant byte, mask off LSB with bitwise AND 0
  Wire.write(data);
  Wire.endTransmission();
  delay(5);  //need this for sure
  }

//read a byte or single char - less than 256
byte readEEPROM(int devAddr, unsigned int eeAddr ) {
  byte readByte = 0;
  Wire.beginTransmission(devAddr);
  Wire.write((byte)eeAddr >> 8);      //writes the most significant byte
  Wire.write((byte)eeAddr & 0xFF);    //writes the least significant byte
  Wire.endTransmission();
  Wire.requestFrom(devAddr,1);
  if (Wire.available()) 
    readByte = Wire.read();
  return readByte;
  }

Depois que a temperatura, T, é lida, nós a salvamos na EEPROM e depois a lemos novamente. Observando a linha 50, convertemos o valor flutuante T em uma sequência de caracteres do tipo c dtostr() e adicione-o à nossa string chrFloat. Em seguida, escrevemos e lemos de volta a partir da EEPROM. Isso é feito pelo ‘mecanismo’ do programa writeEEPROM() e readEEPROM() onde a string é escrita e lida byte a byte. Assim, você pode usar as funções para ler / gravar bytes ou caracteres únicos ou através de um loop ou de uma string longa.

Observe que você não deve usar seqüências de caracteres com mais de 32 bytes. Para seu uso, eu também incluí (comentei) como ler / escrever um número inteiro no final da instalação. Um número inteiro ocupa 2 bytes, então você precisa dividi-lo em 2 bytes para salvar e, em seguida, ao ler, junte-o novamente com word().

Saída na janela serial

A janela serial deve ficar assim:

Como usar a EEPROM no Arduino 5

cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br