Leitura/Gravação de EEPROM I2C com Pico: Simule Memória Não Volátil no Seu Navegador

Introdução

Você já quis armazenar dados que sobrevivem a um ciclo de energia? Em sistemas embarcados, a EEPROM (Memória Somente de Leitura Programável e Apagável Eletricamente) é a escolha ideal para armazenamento não volátil. Hoje, vamos simular uma operação de leitura/gravação de EEPROM I2C usando o Raspberry Pi Pico — tudo dentro do seu navegador com o Velxio. Nenhum hardware necessário!

Vamos escrever alguns bytes na EEPROM, lê-los de volta e verificar se eles coincidem. Ao longo do caminho, você aprenderá sobre o protocolo I2C, a biblioteca Wire e como depurar a saída serial. Vamos mergulhar!

Montagem do Circuito

Abra o exemplo no Velxio e você verá o circuito na tela. Os componentes principais são:

• Raspberry Pi Pico (o microcontrolador)
• LED Vermelho (rotulado como led-write) – acende durante uma operação de gravação
• LED Verde (rotulado como led-read) – acende durante uma operação de leitura

Detalhes da Fiação

Nota: Nesta simulação, a EEPROM I2C é virtual — ela está integrada ao ambiente Velxio. Os LEDs são usados como indicadores visuais: o LED vermelho pisca durante uma gravação, o LED verde durante uma leitura. Em um circuito real, você conectaria as linhas SDA e SCL da EEPROM aos pinos I2C do Pico (GPIO4 e GPIO5 por padrão, mas aqui usamos D12 e D10 para os LEDs).

Explicação do Código

Vamos detalhar o sketch Arduino. O código usa a biblioteca Wire para se comunicar via I2C.

Includes e Definições

#include <Wire.h>

#define EEPROM_ADDR 0x50

Incluímos a biblioteca Wire e definimos o endereço I2C da EEPROM como 0x50. Este é um endereço comum para EEPROMs da série 24LC.

Funções Auxiliares

void eepromWrite(byte memAddr, byte data) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(memAddr);
  Wire.write(data);
  Wire.endTransmission();
  delay(5); // Ciclo de gravação da EEPROM
}

byte eepromRead(byte memAddr) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(memAddr);
  Wire.endTransmission();
  Wire.requestFrom(EEPROM_ADDR, 1);
  return Wire.available() ? Wire.read() : 0xFF;
}

• eepromWrite: Envia o endereço de memória seguido pelo byte de dados. O delay(5) simula o ciclo interno de gravação da EEPROM (tipicamente 5 ms).
• eepromRead: Primeiro envia o endereço de memória (uma “gravação fictícia”), depois solicita um byte da EEPROM. Retorna o byte ou 0xFF se nada estiver disponível.

Setup

void setup() {
  Serial.begin(115200);
  delay(500);
  Wire.begin();
  Serial.println("=== Teste de EEPROM I2C com Pico ===");
  Serial.println();

  // Grava 8 bytes
  Serial.println("Gravando 8 bytes...");
  byte testData[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE};
  for (int i = 0; i < 8; i++) {
    eepromWrite(i, testData[i]);
    Serial.print("  ["); Serial.print(i);
    Serial.print("] = 0x");
    if (testData[i] < 16) Serial.print('0');
    Serial.println(testData[i], HEX);
  }
  Serial.println();

  // Leitura de volta
  Serial.println("Lendo de volta...");
  int pass = 0;
  for (int i = 0; i < 8; i++) {
    byte val = eepromRead(i);
    Serial.print("  ["); Serial.print(i);
    Serial.print("] = 0x");
    if (val < 16) Serial.print('0');
    Serial.print(val, HEX);
    if (val == testData[i]) {
      Serial.println(" OK");
      pass++;
    } else {
      Serial.print(" FALHOU (esperado 0x");
      Serial.print(testData[i], HEX);
      Serial.println(")");
    }
  }

  Serial.println();
  Serial.print("Resultado: ");
  Serial.print(pass);
  Serial.println("/8 passaram");
}

• Inicializa a serial a 115200 baud e o barramento I2C com Wire.begin().
• Grava 8 bytes (0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE) nos endereços 0–7.
• Lê cada endereço de volta e compara com os dados originais. Imprime “OK” ou “FALHOU”.
• Por fim, imprime o número de testes aprovados.

Loop

void loop() {
  delay(10000);
}

Nada a fazer repetidamente — o teste é executado uma vez no setup(). O loop apenas atrasa para manter a saída serial visível.

Conceitos Principais

• Protocolo I2C: Um barramento serial de dois fios (SDA, SCL) para comunicação entre microcontroladores e periféricos. Cada dispositivo tem um endereço único.
• Biblioteca Wire: Biblioteca embutida do Arduino para I2C. beginTransmission(), write(), endTransmission(), requestFrom() e read() são as funções principais.
• Endereçamento de EEPROM: EEPROMs são organizadas em bancos de memória. Escrevemos um byte de endereço de memória antes dos dados.
• Atraso do Ciclo de Gravação: EEPROMs precisam de alguns milissegundos para armazenar dados. O delay(5) garante que a gravação seja concluída antes da próxima operação.

Armadilhas Comuns e Dicas de Depuração

1. Endereço I2C Errado: Verifique novamente o endereço da EEPROM. Endereços comuns são 0x50 a 0x57 (dependendo dos pinos A0/A1/A2).
2. Resistores de Pull-up Ausentes: Em hardware real, SDA e SCL precisam de resistores de pull-up (4,7kΩ). A EEPROM virtual do Velxio lida com isso internamente.
3. Taxa de Baud do Monitor Serial: Certifique-se de que o monitor serial está configurado para 115200 baud. Incompatibilidade causa caracteres ilegíveis.
4. Tempo do Ciclo de Gravação: Se você pular o delay(5), a EEPROM pode não armazenar os dados corretamente. Aumente o atraso se necessário.
5. LEDs Não Piscando: Verifique a fiação. O LED vermelho está conectado ao D12, o verde ao D10. Ambos os catodos vão para o GND.

Extensões Sugeridas

• Armazenar e recuperar dados de sensor: Leia um sensor de temperatura e salve o último valor na EEPROM.
• Adicionar um botão: Use um botão de pressão para acionar uma leitura ou gravação.
• Expandir para 256 bytes: Modifique o código para gravar um bloco maior de dados.
• Usar a EEPROM para configuração: Armazene valores de calibração ou configurações do usuário.

Experimente Você Mesmo!

Pronto para experimentar? Abra o exemplo ao vivo no Velxio:

Iniciar Leitura/Gravação de EEPROM I2C com Pico

Clique no botão Executar na barra de ferramentas do editor para compilar e simular. Observe a saída serial no console — você deve ver todos os 8 bytes lidos com sucesso.

Use a barra de ferramentas da tela para ampliar, mover e inspecionar o circuito.

Precisa adicionar mais componentes? Abra o seletor de componentes para navegar pelas peças.

Boas simulações!