Lendo e gravando dados em EEPROM externa usando Arduino: 5 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

EEPROM significa Electrically Erasable Programmable Read-Only Memory.

EEPROM é muito importante e útil porque é uma forma de memória não volátil. Isso significa que mesmo quando a placa é desligada, o chip EEPROM ainda retém o programa que foi escrito nele. Portanto, quando você desliga a placa e a liga novamente, o programa que foi gravado na EEPROM pode ser executado. Então, basicamente, a EEPROM armazena e executa um programa, não importa o quê. Isso significa que você pode desligar um dispositivo, mantê-lo desligado por 3 dias e voltar e ligá-lo e ele ainda pode executar o programa que foi programado nele. É assim que a maioria dos dispositivos eletrônicos de consumo funciona.

Este projeto é patrocinado pelo LCSC. Tenho usado componentes eletrônicos do LCSC.com. A LCSC tem um forte compromisso em oferecer uma ampla seleção de componentes eletrônicos genuínos de alta qualidade ao melhor preço com uma rede global de remessas para mais de 200 países. Inscreva-se hoje e ganhe $ 8 de desconto em seu primeiro pedido.

A EEPROM também é muito eficiente, pois bytes individuais em uma EEPROM tradicional podem ser lidos, apagados e reescritos independentemente. Na maioria dos outros tipos de memória não volátil, isso não pode ser feito. Os dispositivos EEPROM seriais, como o EEPROM da série 24 da Microchip, permitem que você adicione mais memória a qualquer dispositivo que possa falar I²C.

Suprimentos

1. EEPROM - 24LC512
2. ATmega328P-PU
3. Cristal de 16 MHz
4. Tábua de pão
5. Resistor 4,7 k Ohm x 2
6. Capacitor 22 pF x 2

Etapa 1: Fundamentos da EEPROM

O chip Microchip 24LC2512 pode ser adquirido em um pacote DIP de 8 pinos. Os pinos no 24LC512 são bastante diretos e consistem em alimentação (8), GND (4), proteção contra gravação (7), SCL / SDA (6, 5) e três pinos de endereço (1, 2, 3).

Uma breve história da ROM

Os primeiros computadores do tipo "Programa armazenado" - como calculadoras de mesa e intérpretes de teclado - começaram a usar ROM na forma de ROM de matriz de diodo. Esta era uma memória composta de diodos semicondutores discretos colocados em um PCB especialmente organizado. Isso deu lugar ao Mask ROM com o advento dos circuitos integrados. Mask ROM era muito parecido com Diode Matrix ROM, mas foi implementado em uma escala muito menor. Isso significava, no entanto, que você não poderia simplesmente mover alguns diodos com um ferro de solda e reprogramá-lo. A máscara ROM teve de ser programada pelo fabricante e, a partir de então, não foi alterada.

Infelizmente, o Mask ROM era caro e demorava muito para ser produzido porque cada novo programa exigia um dispositivo totalmente novo a ser fabricado por uma fundição. Em 1956, no entanto, esse problema foi resolvido com a invenção do PROM (ROM programável), que permitiu aos desenvolvedores programar os próprios chips. Isso significava que os fabricantes podiam produzir milhões do mesmo dispositivo não programado, o que o tornava mais barato e prático. PROM, no entanto, só poderia ser gravado uma vez usando um dispositivo de programação de alta tensão. Depois que um dispositivo PROM foi programado, não havia como retornar o dispositivo ao seu estado não programado.

Isso mudou em 1971 com a invenção da EPROM (Erasable Programmable ROM) que - além de adicionar outra letra à sigla - trouxe consigo a capacidade de apagar o dispositivo e devolvê-lo a um estado "em branco" usando uma forte fonte de luz ultravioleta. Isso mesmo, você teve que acender uma luz forte no IC para reprogramá-lo, não é legal? Bem, parece que é muito legal, a menos que você seja um desenvolvedor trabalhando em firmware, caso em que você realmente gostaria de ser capaz de reprogramar o dispositivo usando sinais elétricos. Isso finalmente se tornou realidade em 1983 com o desenvolvimento da EEPROM (Electrically Erasable Programmable ROM) e com isso, chegamos à sigla atual de difícil manejo.

Etapa 2: peculiaridades da EEPROM

Existem duas desvantagens principais na EEPROM como método de armazenamento de dados. Na maioria dos aplicativos, os prós superam os contras, mas você deve estar ciente deles antes de incorporar a EEPROM em seu próximo projeto.

Em primeiro lugar, a tecnologia que faz a EEPROM funcionar também limita o número de vezes que ela pode ser reescrita. Isso tem a ver com os elétrons ficarem presos nos transistores que constituem a ROM e se acumularem até que a diferença de carga entre "1" e "0" seja irreconhecível. Mas não se preocupe, a maioria das EEPROMs tem um número máximo de reescrita de 1 milhão ou mais. Contanto que você não esteja gravando continuamente na EEPROM, é improvável que você alcance este máximo. Em segundo lugar, a EEPROM não será apagada se você remover a energia dela, mas ela não reterá seus dados indefinidamente. Os elétrons podem sair dos transistores e passar pelo isolador, apagando efetivamente a EEPROM com o tempo. Dito isso, isso geralmente ocorre ao longo dos anos (embora possa ser acelerado pelo calor). A maioria dos fabricantes afirma que seus dados estão seguros na EEPROM por 10 anos ou mais em temperatura ambiente. E há mais uma coisa que você deve ter em mente ao selecionar um dispositivo EEPROM para o seu projeto. A capacidade da EEPROM é medida em bits e não em bytes. Uma EEPROM de 512K comporta 512Kbits de dados, ou seja, apenas 64KB.

Etapa 3: Conexão de Hardware Arduino

Ok, agora que sabemos o que é EEPROM, vamos conectar um e ver o que ele pode fazer! Para fazer nosso dispositivo falar, precisaremos conectar a alimentação e também as linhas seriais I²C. Este dispositivo, em particular, funciona a 5 VCC, então vamos conectá-lo à saída de 5 V do nosso Arduino UNO. Além disso, as linhas I²C precisarão de resistores pull-up para que a comunicação ocorra corretamente. O valor desses resistores depende da capacitância das linhas e da frequência que você deseja comunicá-lo, mas uma boa regra para aplicações não críticas é mantê-lo na faixa de kΩ. Neste exemplo, usaremos resistores pull-up de 4,7kΩ.

Existem três pinos neste dispositivo para selecionar o endereço I²C, desta forma você pode ter mais de um EEPROM no barramento e endereçar cada um de forma diferente. Você poderia simplesmente aterrar todos eles, mas iremos conectá-los para que possamos instalar um dispositivo de maior capacidade posteriormente no tutorial.

Usaremos um breadboard para conectar tudo junto. O diagrama abaixo mostra a conexão correta para a maioria dos dispositivos I²C EEPROM, incluindo o EEPROM Microchip série 24 que vendemos.

Etapa 4: Leitura e Escrita

Na maioria das vezes, quando você usa um EEPROM em conjunto com um microcontrolador, não precisa realmente ver todo o conteúdo da memória de uma vez. Você apenas lerá e escreverá bytes aqui e ali conforme necessário. Neste exemplo, no entanto, vamos gravar um arquivo inteiro na EEPROM e, em seguida, ler tudo de volta para que possamos visualizá-lo em nosso computador. Isso deve nos deixar confortáveis com a ideia de usar a EEPROM e também nos dar uma ideia de quantos dados realmente cabem em um pequeno dispositivo.

Escreva algo

Nosso esboço de exemplo simplesmente pegará qualquer byte que vier pela porta serial e o gravará na EEPROM, acompanhando ao longo do caminho quantos bytes gravamos na memória.

A gravação de um byte de memória na EEPROM geralmente ocorre em três etapas:

1. Envie o Byte mais significativo do endereço de memória no qual deseja escrever.
2. Envie o Byte menos significativo do endereço de memória no qual deseja escrever.
3. Envie o byte de dados que deseja armazenar neste local.

Provavelmente, existem algumas palavras-chave que explicam simplesmente:

Endereços de Memória

Se você imaginar todos os bytes em uma EEPROM de 512 Kbit em uma linha de 0 a 64.000 - porque há 8 bits em um byte e, portanto, você pode colocar 64.000 bytes em uma EEPROM de 512 Kbit - então um endereço de memória é o lugar em linha onde você encontraria um byte específico. Precisamos enviar esse endereço para a EEPROM para que ela saiba onde colocar o byte que estamos enviando.

Bytes mais significativos e menos significativos

Como há 32.000 lugares possíveis em uma EEPROM de 256 Kbit - e como 255 é o maior número que você pode codificar em um byte - precisamos enviar esse endereço em dois bytes. Primeiro, enviamos o Byte mais significativo (MSB) - os primeiros 8 bits neste caso. Em seguida, enviamos o Byte menos significativo (LSB) - os segundos 8 bits. Porque? Porque é assim que o dispositivo espera recebê-los, isso é tudo.

Escrita de página

Gravar um byte de cada vez é bom, mas a maioria dos dispositivos EEPROM tem algo chamado "buffer de gravação de página" que permite que você grave bytes múltiplos ao mesmo tempo da mesma forma que faria com um único byte. Estaremos aproveitando isso em nosso esboço de exemplo. A EEPROM usa um contador interno que aumenta automaticamente a localização da memória com cada byte de dados seguinte que recebe. Depois que um endereço de memória é enviado, podemos segui-lo com até 64 bytes de dados. A EEPROM assume (corretamente) que um endereço de 312 seguido por 10 bytes gravará o byte 0 no endereço 312, o byte 1 no endereço 313, o byte 2 no endereço 314 e assim por diante.

Leia algo

A leitura da EEPROM segue basicamente o mesmo processo de três etapas da escrita na EEPROM:

1. Envie o Byte mais significativo do endereço de memória no qual deseja escrever.
2. Envie o Byte menos significativo do endereço de memória no qual deseja escrever.
3. Peça o byte de dados nesse local.

Etapa 5: esquemas e código

Código:

#incluir

# define eeprom 0x50 // define o endereço base da EEPROM

void setup () {

Wire.begin (); // cria um objeto Wire

Serial.begin (9600);

endereço interno sem sinal = 0; // primeiro endereço da EEPROM

Serial.println ("Escrevemos o código postal 22222, um código postal"); para (endereço = 0; endereço <5; endereço ++) writeEEPROM (eeprom, endereço, '2'); // Grava 22222 na EEPROM

para (endereço = 0; endereço <5; endereço ++) {Serial.print (readEEPROM (eeprom, endereço), HEX); }}

void loop () {

/ * não há nada na função loop () porque não queremos que o arduino grave repetidamente a mesma coisa na EEPROM continuamente. Queremos apenas uma gravação única, então a função loop () é evitada com EEPROMs. * /}

// define a função writeEEPROM

void writeEEPROM (int deviceaddress, unsigned int eeaddress, byte data) {Wire.beginTransmission (deviceaddress); Wire.write ((int) (eeaddress >> 8)); // escreve o MSB Wire.write ((int) (eeaddress & 0xFF)); // escreve o LSB Wire.write (data); Wire.endTransmission (); }

// define a função readEEPROM

byte readEEPROM (int deviceaddress, unsigned int eeaddress) {byte rdata = 0xFF; Wire.beginTransmission (deviceaddress); Wire.write ((int) (eeaddress >> 8)); // escreve o MSB Wire.write ((int) (eeaddress & 0xFF)); // escreve o LSB Wire.endTransmission (); Wire.requestFrom (deviceaddress, 1); if (Wire.available ()) rdata = Wire.read (); return rdata; }