A memória não volátil (NVM) é um componente crucial em muitos sistemas eletrônicos, incluindo microchips, pois retém dados mesmo quando a energia é desligada. Isso é essencial para armazenar firmware, configurações e dados críticos que não devem ser perdidos em caso de falha de energia. No contexto dos microchips, a NVM pode ser encontrada em várias formas, como EEPROM, Flash e FRAM. Este artigo abordará como utilizar a memória não volátil em microchips, com exemplos práticos de código para ilustrar seu uso.

Exemplos:

1. EEPROM em Microcontroladores PIC:

   A EEPROM (Electrically Erasable Programmable Read-Only Memory) é uma forma comum de NVM em microcontroladores PIC. Aqui está um exemplo de como ler e escrever na EEPROM usando o compilador MPLAB XC8:

   #include <xc.h>
   
   // Configuração do microcontrolador
   #pragma config FOSC = INTRC_NOCLKOUT
   #pragma config WDTE = OFF
   #pragma config PWRTE = OFF
   #pragma config MCLRE = ON
   #pragma config CP = OFF
   #pragma config CPD = OFF
   #pragma config BOREN = ON
   #pragma config IESO = OFF
   #pragma config FCMEN = OFF
   #pragma config LVP = OFF
   #pragma config BOR4V = BOR40V
   #pragma config WRT = OFF
   
   void eeprom_write(unsigned char address, unsigned char data) {
      EEADR = address;
      EEDATA = data;
      EECON1bits.EEPGD = 0; // Acessar EEPROM
      EECON1bits.WREN = 1;  // Habilitar gravação
   
      // Sequência de gravação
      INTCONbits.GIE = 0;   // Desabilitar interrupções
      EECON2 = 0x55;
      EECON2 = 0xAA;
      EECON1bits.WR = 1;
      INTCONbits.GIE = 1;   // Habilitar interrupções
   
      while (EECON1bits.WR); // Esperar até a gravação ser concluída
      EECON1bits.WREN = 0;  // Desabilitar gravação
   }
   
   unsigned char eeprom_read(unsigned char address) {
      EEADR = address;
      EECON1bits.EEPGD = 0; // Acessar EEPROM
      EECON1bits.RD = 1;    // Iniciar leitura
      return EEDATA;        // Retornar dado lido
   }
   
   void main(void) {
      unsigned char data;
   
      // Escrever valor 0x55 na posição 0x10 da EEPROM
      eeprom_write(0x10, 0x55);
   
      // Ler valor da posição 0x10 da EEPROM
      data = eeprom_read(0x10);
   
      while (1) {
          // Loop infinito
      }
   }

2. Flash em Microcontroladores AVR:

   A memória Flash é outra forma de NVM comumente usada em microcontroladores AVR. Aqui está um exemplo de como escrever e ler dados na memória Flash usando o compilador AVR-GCC:

   #include <avr/io.h>
   #include <avr/pgmspace.h>
   
   // Função para escrever na memória Flash
   void flash_write(uint16_t address, uint8_t data) {
      while (SPMCSR & (1<<SPMEN)); // Esperar até que o SPM esteja pronto
   
      // Desabilitar interrupções
      uint8_t sreg = SREG;
      cli();
   
      // Preencher buffer de página
      boot_page_fill(address, data);
   
      // Gravar página
      boot_page_write(address);
      boot_spm_busy_wait();
   
      // Reabilitar interrupções
      SREG = sreg;
   }
   
   // Função para ler da memória Flash
   uint8_t flash_read(uint16_t address) {
      return pgm_read_byte_near(address);
   }
   
   int main(void) {
      uint8_t data;
   
      // Escrever valor 0x55 na posição 0x100 da Flash
      flash_write(0x100, 0x55);
   
      // Ler valor da posição 0x100 da Flash
      data = flash_read(0x100);
   
      while (1) {
          // Loop infinito
      }
   }