Leitura/Gravação de EEPROM I2C com Arduino: Um Guia Completo

Introdução

Você já precisou armazenar dados de configuração ou pequenas quantidades de informações não voláteis em seus projetos Arduino? As EEPROMs I2C são uma solução perfeita — são baratas, fáceis de usar e exigem apenas dois fios para comunicação. Neste tutorial, usaremos o simulador online Velxio para construir um teste completo de leitura/gravação de EEPROM I2C. Você aprenderá como escrever dados em uma EEPROM virtual no endereço 0x50 e lê-los de volta, verificando se tudo funciona.

O Velxio fornece um ambiente de simulação analógica com precisão SPICE, permitindo testar seu código sem nenhum hardware físico. Vamos mergulhar!

Visão Geral do Circuito

O circuito é notavelmente simples porque a EEPROM I2C está integrada ao ambiente virtual. O único componente necessário é um Arduino Uno. A EEPROM é simulada internamente e conectada aos pinos I2C do Arduino (A4 para SDA e A5 para SCL). Nenhuma fiação externa é necessária — o simulador gerencia o barramento I2C automaticamente.

Para montar o circuito:

1. Abra o editor Velxio e adicione um Arduino Uno a partir do seletor de componentes.
2. A EEPROM I2C já faz parte da simulação; você não precisa adicioná-la manualmente.
3. O código se comunicará com a EEPROM no endereço 0x50.

Você pode encontrar o Arduino Uno na categoria “Microcontroladores” no seletor de componentes. Uma vez colocado, a tela mostrará a placa pronta para programação.

Explicação do Código

Vamos examinar o sketch Arduino que realiza as operações de leitura/gravação. O código é escrito em C++ usando a biblioteca padrão Wire para comunicação I2C.

// I2C EEPROM Read/Write Test
// Virtual EEPROM at address 0x50
// Writes values to registers, then reads them back.

#include <Wire.h>

#define EEPROM_ADDR 0x50

void writeEEPROM(byte reg, byte value) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(reg);    // register address
  Wire.write(value);  // data
  Wire.endTransmission();
  delay(5); // EEPROM write cycle time
}

byte readEEPROM(byte reg) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(reg);
  Wire.endTransmission();

  Wire.requestFrom(EEPROM_ADDR, 1);
  if (Wire.available()) {
    return Wire.read();
  }
  return 0xFF;
}

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

  Serial.println("============================");
  Serial.println(" I2C EEPROM R/W Test (0x50)");
  Serial.println("============================");
  Serial.println();

  // Write test pattern
  Serial.println("Writing test data...");
  for (byte i = 0; i < 8; i++) {
    byte value = (i + 1) * 10;  // 10, 20, 30, ...
    writeEEPROM(i, value);
    Serial.print("  Write reg[");
    Serial.print(i);
    Serial.print("] = ");
    Serial.println(value);
  }

  Serial.println();
  Serial.println("Reading back...");

  // Read back and verify
  byte errors = 0;
  for (byte i = 0; i < 8; i++) {
    byte expected = (i + 1) * 10;
    byte actual = readEEPROM(i);
    Serial.print("  Read  reg[");
    Serial.print(i);
    Serial.print("] = ");
    Serial.print(actual);

    if (actual == expected) {
      Serial.println("  [OK]");
    } else {
      Serial.print("  [FAIL] expected ");
      Serial.println(expected);
      errors++;
    }
  }

  Serial.println();
  if (errors == 0) {
    Serial.println("All tests PASSED!");
  } else {
    Serial.print(errors);
    Serial.println(" test(s) FAILED.");
  }
}

void loop() {
  // Nothing to do
  delay(1000);
}

Como o Código Funciona

• writeEEPROM(reg, value): Esta função envia o endereço do registrador e o byte de dados para a EEPROM. Ela usa Wire.beginTransmission(), Wire.write() e Wire.endTransmission(). Um atraso de 5 ms simula o tempo do ciclo de gravação da EEPROM.
• readEEPROM(reg): Primeiro, envia o endereço do registrador para a EEPROM (uma “gravação fictícia”), depois solicita um byte usando Wire.requestFrom(). Se houver dados disponíveis, lê e retorna; caso contrário, retorna 0xFF.
• setup(): Inicializa a biblioteca Wire e a comunicação serial. Escreve um padrão de teste (10, 20, 30, …) nos registradores 0 a 7, depois os lê de volta e compara com os valores esperados. Qualquer discrepância incrementa um contador de erros.
• loop(): Vazio, com um pequeno atraso para manter a placa ativa.

Conceitos-Chave para Estudantes

1. Protocolo I2C: O I2C usa dois fios (SDA e SCL) e um endereço de 7 bits para se comunicar com múltiplos dispositivos. O endereço 0x50 da EEPROM é comum para muitos chips da série AT24C.
2. Ciclo de Gravação da EEPROM: EEPROMs precisam de alguns milissegundos para gravar dados internamente. O delay(5) em writeEEPROM() garante que a gravação seja concluída antes da próxima operação.
3. Gravação Fictícia para Leitura: Para ler de um registrador específico, primeiro você envia o endereço do registrador (uma operação de gravação), depois emite uma reinicialização repetida ou uma parada/início para ler os dados. O código usa uma abordagem de parada/início.
4. Verificação de Erros: O sketch verifica cada leitura em relação ao valor esperado, o que é uma boa prática para testar a comunicação.

Problemas Comuns e Dicas de Depuração

• Endereço Errado: Certifique-se de que o endereço da EEPROM corresponde ao seu dispositivo. A EEPROM virtual usa 0x50. Se você receber 0xFF de volta, o endereço pode estar errado.
• Resistores de Pull-up Ausentes: Em hardware real, as linhas I2C precisam de resistores de pull-up. No Velxio, eles são simulados internamente, então você não precisa adicioná-los.
• Monitor Serial: Use o Monitor Serial no Velxio para ver a saída. Clique no ícone do Monitor Serial na barra de ferramentas.
• Tempo: Se as leituras falharem intermitentemente, aumente o atraso após as gravações. A EEPROM virtual é rápida, mas dispositivos reais podem precisar de mais tempo.

Use a barra de ferramentas para compilar e executar seu código. O Monitor Serial exibirá os resultados do teste.

Extensões Sugeridas

1. Gravar Dados Maiores: Modifique o código para escrever e ler uma string ou um array de bytes.
2. Gravação por Página: Muitas EEPROMs suportam gravação por página (escrevendo múltiplos bytes em uma única transação). Tente implementar isso.
3. EEPROM Externa: Adicione um componente EEPROM físico (se disponível no Velxio) e conecte-o ao Arduino.
4. Registro de Dados: Use a EEPROM para armazenar leituras de sensores e recuperá-las posteriormente.

Conclusão

Você construiu com sucesso um teste de leitura/gravação de EEPROM I2C no Velxio! Este projeto demonstra os fundamentos da comunicação I2C e da memória não volátil. O ambiente virtual facilita a experimentação sem hardware. Agora, tente estender o código ou integrá-lo a um projeto maior.

Pronto para construir o seu próprio? Abra o exemplo ao vivo no Velxio e comece a programar: Exemplo de Leitura/Gravação de EEPROM I2C. Boa simulação!