Introduzione alla memoria esterna con microcontrollori PIC

I microcontrollori PIC di Microchip offrono EEPROM interno e Flash per la memorizzazione del codice di applicazione e piccole quantità di dati, ma i progetti complessi richiedono spesso più capacità. EEPROM esterno (Electrically Erasable Programmable Read-Only Memory) e chip di memoria Flash forniscono la memoria extra non volatile necessaria per la registrazione dei dati, parametri di configurazione, aggiornamenti firmware e attività multimediali.

Che si stia costruendo un registratore di dati, un nodo intelligente del sensore, o un sistema integrato che deve mantenere le impostazioni critiche dopo la perdita di potenza, capire come interfacciare la memoria esterna in modo efficiente salverà il tempo di sviluppo e migliorare l'affidabilità.

Comprensione EEPROM esterno e memoria flash

Sia EEPROM che Flash sono tecnologie di memoria non volatili, il che significa che conservano i dati memorizzati quando il potere viene rimosso. Tuttavia, differiscono in architettura, resistenza e casi di uso tipico:

  • EEPROM[] – Supporta operazioni di lettura e scrittura a livello byte. La sua resistenza è tipicamente di 1 milione di cicli di cancellazione/scrittura per byte. EEPROM è ideale per la memorizzazione di piccole quantità di dati frequentemente aggiornati (ad esempio, costanti di calibrazione, preferenze dell'utente).
  • Memoria flash[] – Ottimizzata per le operazioni di cancellazione e programma a livello di blocco. Flash offre una densità molto più elevata (megabit a gigabits) ma una resistenza più bassa (tipicamente da 10.000 a 100.000 cicli di cancellazione per blocco).

EEPROM esterno e Flash comunicano con il PIC tramite protocolli seriali (I2C o SPI) o raramente bus paralleli. Le interfacce seriali riducono il conteggio dei perni e semplificano il layout del PCB, rendendoli la scelta dominante per i disegni incorporati.

Scegliere il dispositivo di memoria giusto

Quando si seleziona un chip di memoria esterno per il progetto PIC, valutare questi criteri:

  • Dimensione e capacità di memoria[[[]] – Per stimare il volume di dati generati o memorizzate, è sufficiente una EEPROM a 64 kbit (8 KB) per campioni audio o aggiornamenti firmware, prendere in considerazione 16 Mbit o SPI Flash più grande.
  • ]Protocollo di comunicazione[ – I2C utilizza solo due fili (SDA e SCL) e supporta più dispositivi di indirizzamento; è più lento ma più semplice. SPI utilizza quattro fili (MISO, MOSI, SCLK, CS) e raggiunge velocità più elevate ma richiede un chip selezionato per dispositivo dedicato.
  • Speed and Data Transfer Rate[[[] – I2C funziona tipicamente a 100 kHz o 400 kHz; SPI può raggiungere decine di MHz. Se avete bisogno di streaming veloce (ad esempio, riproduzione audio), SPI è obbligatorio. Per leggere occasionalmente di piccoli blocchi di configurazione, I2C sta bene.
  • Consunzione di potenza[ – Sia EEPROM che Flash hanno correnti di lettura/scrittura attiva nella gamma milliampere e nelle modalità di sonno profondo. Per i disegni alimentati a batteria, selezionare chip con corrente di standby bassa (ad esempio, 1 μA o meno).
  • Tensione di funzionamento[[] – La maggior parte dei PIC lavorano a 3.3V o 5V. Assicurare che il chip di memoria supporta la stessa gamma di tensione. Molti EEPROM moderni operano da 1.7V a 5.5V, fornendo flessibilità.
  • Cost and Availability[ – Le famiglie comuni includono la serie 24AA di Microchip (I2C EEPROM), la serie 25AA (SPI EEPROM), la serie SST25 o Winbond W25Q (SPI Flash), e la serie AT24 (I2C EEPROM).
  • Indurance and Retention[[] – EEPROM offre solitamente una maggiore resistenza di scrittura rispetto a Flash. La ritenzione di dati è tipicamente 40+ anni. Per Flash, consideri il numero di cicli di cancellazione e implementa il livellamento dell'usura se si scrive frequentemente.

La guida seriale EEPROM di Microsoft [[] fornisce tabelle di confronto diretto. [Il portafoglio seriale NOR Flash di Winbond elenca le opzioni popolari di SPI Flash.

Collegamento della memoria esterna al microcontrollore PIC

Il cablaggio hardware dipende dall'interfaccia. Qui di seguito dettagliamo le connessioni I2C e SPI insieme a considerazioni importanti come resistenze pull-up e condensatori di decoupling.

Interfaccia I2C (IIC)

I2C utilizza due linee bidirezionali: SDA e SCL (orologio seriale). I dispositivi master (PIC) controllano l'orologio e avviano le transazioni. Ogni schiavo ha un indirizzo a 7 bit o a 10 bit.

Vuoi:

  • Collegare SDA a un pin PIC I/O configurato come open-drain o bi-direzionale.
  • Collegare SCL ad un altro pin PIC I/O.
  • Aggiungere resistenze esterne (tipicamente 4.7 kΩ) da SDA e SCL a Vcc. Il valore dipende dalla capacità e dalla velocità del bus; per 400 kHz, può essere necessario 2,2 kΩ.
  • Collegare il pin WP della memoria (testi la scrittura) a GND per disabilitare la protezione della scrittura hardware, o a Vcc per proteggere l'intero array.
  • Posizionare un condensatore ceramico da 0,1 μF vicino al perno di potenza della memoria per decouple rumore.

Per l'I2C ad alta velocità (1 MHz), tenere traccia breve e utilizzare pull-up più forti. Esempio chip: Microchip 24LC256 (256 kbit I2C EEPROM), AT24C512 (512 kbit).

Interfaccia SPI

SPI usa quattro segnali: MOSI (master out, slave in), MISO[ (master in, slave out), ]SCLK[ISO (orologio seriale dedicato), e CS [FLT:]

Vuoi:

  • Collegare MOSI (uscita PIC) al SI della memoria (ingresso seriale).
  • Collegare MISO (ingresso IPIC) alla memoria SO (uscita seriale).
  • Collegare SCLK (uscita PIC) al SCK della memoria.
  • Collegare CS a un pin di uscita digitale PIC. Per memorie multiple, utilizzare pin separati.
  • Aggiungere la pull-up debole (10 kΩ) sulla linea CS se necessario, anche se la logica tipica basta.
  • Potenza decisa con un condensatore da 0,1 μF.

I chip SPI Flash hanno spesso dei registri di stato e necessitano di sequenze di comando specifiche (ad esempio, WREN prima di scrivere). Esempio: Winbond W25Q32 (32 Mbit SPI Flash), Microchip 25LC256 (256 kbit SPI EEPROM).

Programmazione del PIC per accedere alla memoria esterna

Il microcontrollore PIC deve inizializzare il modulo periferica appropriato (I2C o SPI) e quindi inviare/ricevere i dati secondo il protocollo del chip di memoria.

Esempio di codice di comunicazione I2C

Di seguito è riportato un esempio semplificato ma funzionale utilizzando il MCC (Microchip Code Configurator) generato HAL per un PIC16F18877. Il codice scrive un byte singolo a un EEPROM I2C in un determinato indirizzo e poi lo legge indietro.

// Assumes I2C1_Initialize() called earlier.
// Device address: 0xA0 (for write) – actual address depends on A0-A2 pins.
#define EEPROM_ADDR 0xA0

void I2C_WriteByte(uint16_t memAddr, uint8_t data) {
 I2C1_Start(); // Generate start condition
 I2C1_Write(EEPROM_ADDR); // Send device address + write bit
 I2C1_Write((uint8_t)(memAddr >> 8)); // High address byte
 I2C1_Write((uint8_t)(memAddr)); // Low address byte
 I2C1_Write(data); // Data byte
 I2C1_Stop(); // Generate stop condition
 __delay_ms(5); // Wait for internal write cycle (tWR)
}

uint8_t I2C_ReadByte(uint16_t memAddr) {
 uint8_t data;
 I2C1_Start();
 I2C1_Write(EEPROM_ADDR); // Device address + write for dummy write
 I2C1_Write((uint8_t)(memAddr >> 8));
 I2C1_Write((uint8_t)(memAddr));
 I2C1_RepeatedStart(); // Repeated start to change direction
 I2C1_Write(EEPROM_ADDR | 0x01); // Device address + read bit
 data = I2C1_Read(0); // NAK after last byte
 I2C1_Stop();
 return data;
}

Nota: Per le scritture di pagina, non è necessario attraversare un limite di pagina (di solito 8, 16, o 64 byte). Consultare il foglio di dati per la dimensione della pagina. Inoltre, inquinare per il riconoscimento dopo il ciclo di scrittura è più efficiente rispetto a ritardi fissi.

Esempio di codice di comunicazione SPI

Per SPI Flash (ad esempio W25Q32), le operazioni di scrittura richiedono l'attivazione di scrittura (WREN), quindi l'invio di un comando di Programma di pagina.

#define FLASH_CS LATAbits.LATA0 // Chip select pin

void SPI_WriteEnable(void) {
 FLASH_CS = 0;
 SPI1_Exchange8bit(0x06); // WREN command
 FLASH_CS = 1;
}

void SPI_FlashPageProgram(uint32_t addr, uint8_t *data, uint8_t len) {
 SPI_WriteEnable();
 FLASH_CS = 0;
 SPI1_Exchange8bit(0x02); // Page Program command
 SPI1_Exchange8bit((uint8_t)(addr >> 16)); // High address byte
 SPI1_Exchange8bit((uint8_t)(addr >> 8));
 SPI1_Exchange8bit((uint8_t)(addr));
 for (uint8_t i = 0; i < len; i++) {
 SPI1_Exchange8bit(data[i]);
 }
 FLASH_CS = 1;
 __delay_ms(5); // tPP max 5 ms typical
}

void SPI_FlashRead(uint32_t addr, uint8_t *buffer, uint32_t count) {
 FLASH_CS = 0;
 SPI1_Exchange8bit(0x03); // Read command
 SPI1_Exchange8bit((uint8_t)(addr >> 16));
 SPI1_Exchange8bit((uint8_t)(addr >> 8));
 SPI1_Exchange8bit((uint8_t)(addr));
 for (uint32_t i = 0; i < count; i++) {
 buffer[i] = SPI1_Exchange8bit(0x00);
 }
 FLASH_CS = 1;
}

La memoria Flash non può essere scritta senza cancellare un intero settore (tipicamente 4 KB).Cancellare sempre il settore prima di riprogrammarlo. Utilizzare il comando Sector Erase (0x20) seguito da inquinare il registro di stato fino a quando il bit di scrittura in uscita non si schiarisce.

Tecniche avanzate: Livellamento dell'usura, gestione delle pagine e aggiornamenti firmware

Quando si memorizzano grandi quantità di dati o si eseguono scritture frequenti, prendere in considerazione queste strategie per estendere la vita della memoria e mantenere le prestazioni.

  • Livello di usura per EEPROM[[] – Distribuisci scrive in più posizioni. Ad esempio, mantieni un indice di buffer circolare in uno slot EEPROM dedicato e scrivi i dati alla prossima pagina gratuita.
  • Gestione blocco file[[] – Utilizzare un semplice file system o una tabella dei metadati per monitorare quali settori vengono cancellati / in uso. I tipici chip flash SPI di consumo hanno 4 settori KB; la cancellazione di un settore richiede decine di millisecondi.
  • Firmware Over-the-Air (FOTA) Aggiornamenti[[ – Flash esterno può contenere una nuova immagine del firmware. Il bootloader PIC legge l'immagine, lo scrive a Flash interno e reimposta. Assicurare la perdita di potenza durante la scrittura è gestito tramite una verifica a doppio buffer o checksum.
  • Rilevamento e correzione dell'errore[[] – Per i dati critici, append CRC o semplici controlli XOR. Su lettura, verifica l'integrità. Molti ricordi esterni non hanno incorporato ECC, quindi i controlli software sono prudenti.

Migliori Pratiche e Risoluzione dei problemi

Seguire queste linee guida per minimizzare i problemi e raggiungere un funzionamento robusto.

  • Sempre consulta il Datasheet[[] – I parametri di sincronizzazione, i set di comandi e le specifiche di pull-up variano tra i produttori.
  • Utilizzare resistori per l'attacco corretto per I2C – Il valore dipende dalla capacità di bus e dalla velocità dell'orologio. Per un autobus con uno o due dispositivi e 400 kHz, iniziare con 4.7 kΩ. Utilizzare un oscilloscopio per verificare i bordi in salita.
  • Implement Acknowledge Polling[[] – Invece di ritardi fissi dopo le scritture, più volte inviare l'indirizzo del dispositivo fino a quando non viene ricevuto un ACK.
  • Keep SPI Traces Short[[[] – SPI corre a frequenze MHz; i fili lunghi causano l'anelloing.
  • Usa condensatori di rivestimento[ – Posizionare la ceramica di 0.1 μF il più vicino possibile al perno Vdd di ogni chip di memoria.
  • Test con i modelli noti[] – Scrivere alternando 0x55, 0xAA e verificare. Controllare i confini degli indirizzi (ad esempio, scrivere attraverso un limite di pagina dovrebbe essere evitato).
  • Monitor per il contenuto degli autobus[[] – Se i dispositivi SPI multipli condividono MISO, assicurarsi che un solo chip selezionato sia attivo alla volta.
  • Protezione dello scritto del maneggio[[] – Molti ricordi hanno un perno WP. O tiralo basso per consentire la scrittura o il controllo tramite GPIO se avete bisogno di protezione selettiva.

Esempio di progetto: Data Logger con SPI Flash

Per solidificare i concetti, prendere in considerazione un semplice data logger che legge periodicamente un sensore analogico, memorizza il valore in SPI Flash (ad esempio, W25Q16) e utilizza un buffer circolare per sovrascrivere i dati più antichi. Il PIC si sveglia dal sonno, effettua una conversione, scrive al blocco del settore corrente, aggiorna un puntatore in EEPROM e torna a dormire.

Passi chiave:

  1. Inizializzare SPI MSSP, configurare il pin CS come output.
  2. All'avvio, leggere il puntatore di scrittura corrente da un piccolo I2C EEPROM (o dal primo settore di Flash).
  3. Ogni ciclo di registrazione: leggere ADC → scrivere a Flash page → puntatore di incremento. Se il puntatore raggiunge la fine dell'area assegnata, resettare per iniziare (circolare).
  4. Opzionalmente calcolare CRC dell'ultima pagina per rilevare la corruzione.
  5. Utilizzare sonno a bassa potenza tra intervalli.

Questo modello può essere esteso a sensori multipli, timestamp e registrazione guidata eventi.

Conclusione e ulteriori risorse

Integrando la memoria esterna EEPROM e Flash con microcontroller PIC apre una vasta gamma di applicazioni che richiedono più archiviazione di memoria interna in grado di fornire. Selezionando l'interfaccia appropriata (I2C o SPI), il cablaggio correttamente, e implementando robuste routine di lettura / scrittura, è possibile aggiungere un'archiviazione non volatile affidabile a qualsiasi sistema incorporato.

Per ulteriori informazioni, visitare le seguenti risorse:

Con un'attenta progettazione e un test approfondito, la memoria esterna può scalare senza soluzione di continuità i progetti PIC per gestire più grandi set di dati, aggiornamenti firmware e necessità di configurazione persistenti.