Introduction à la mémoire externe avec les microcontrôleurs PIC

Les microcontrôleurs PIC de Microchip offrent des EEPROM et Flash internes pour stocker le code d'application et de petites quantités de données, mais les projets complexes nécessitent souvent plus de capacité. EEPROM externe (Électriquement effacable mémoire programmable à lecture seule) et les puces mémoire Flash fournissent le stockage non volatil supplémentaire nécessaire pour l'enregistrement des données, les paramètres de configuration, les mises à jour de firmware et les actifs multimédias.

Que vous construisiez un enregistreur de données, un nœud de capteur intelligent ou un système intégré qui doit conserver des paramètres critiques après une perte de puissance, comprendre comment interagir efficacement avec la mémoire externe permettra d'économiser du temps de développement et d'améliorer la fiabilité. Nous discuterons du câblage matériel, des détails du protocole de communication, des exemples de code pratique, de la manipulation des erreurs et des techniques avancées comme le nivellement d'usure et la gestion des blocs.

Comprendre l'EEPROM externe et la mémoire Flash

EEPROM et Flash sont des technologies de mémoire non volatiles, ce qui signifie qu'ils préservent les données stockées lorsque la puissance est supprimée. Cependant, ils diffèrent dans l'architecture, l'endurance et les cas d'utilisation typiques:

  • EEPROM – supporte les opérations de lecture et d'écriture au niveau octet. Son endurance est généralement de 1 million de cycles d'effacement/écriture par octet. EEPROM est idéal pour stocker de petites quantités de données fréquemment mises à jour (par exemple, constantes d'étalonnage, préférences des utilisateurs).
  • Mémoire Flash – Optimisé pour les opérations d'effacement et de programme au niveau des blocs. Flash offre une densité beaucoup plus élevée (mégabits aux gigabits) mais une endurance plus faible (généralement 10 000 à 100 000 cycles d'effacement par bloc). Il est utilisé pour le stockage de firmware, les grands journaux de données et les systèmes de fichiers.

EEPROM externe et Flash communiquent avec le PIC via des protocoles série (I2C ou SPI) ou rarement des bus parallèles. Les interfaces série réduisent le nombre de broches et simplifient la disposition des PCB, ce qui en fait le choix dominant pour les conceptions intégrées.

Choisir le bon périphérique mémoire

Lors de la sélection d'une puce mémoire externe pour votre projet PIC, évaluez ces critères :

  • Taille et capacité de mémoire – Estimez le volume de données que votre application génère ou stocke. Pour des données de configuration simples, un EEPROM de 64 kbits (8 KB) peut suffire. Pour des échantillons audio ou des mises à jour de micrologiciels, considérez 16 Mbit ou plus SPI Flash.
  • Protocole de communication – I2C n'utilise que deux fils (SDA et SCL) et prend en charge plusieurs appareils s'adressant; il est plus lent mais plus simple. SPI utilise quatre fils (MISO, MOSI, SCLK, CS) et atteint des vitesses plus élevées, mais nécessite une sélection de puces dédiée par appareil. Choisissez en fonction de votre vitesse et de votre disponibilité de broches.
  • Taux de transfert de données et de vitesse – I2C fonctionne généralement à 100 kHz ou 400 kHz; SPI peut atteindre des dizaines de MHz. Si vous avez besoin d'une diffusion rapide (p. ex. lecture audio), SPI est obligatoire.
  • Consommation d'énergie – EEPROM et Flash ont des courants actifs de lecture/écriture dans la gamme milliampère et des modes de sommeil profonds. Pour les conceptions alimentées par batterie, sélectionnez des puces avec un courant de veille faible (p. ex. 1 μA ou moins).
  • Tension d'exploitation[ – La plupart des PIC fonctionnent à 3,3V ou 5V. Assurez-vous que la puce mémoire supporte la même plage de tension. De nombreux EEPROM modernes fonctionnent de 1,7V à 5,5V, offrant une flexibilité.
  • Coût et disponibilité – Les familles communes comprennent Microchip=s 24AA series (I2C EEPROM), 25AA series (SPI EEPROM), SST25 ou Winbond W25Q series (SPI Flash) et AT24 series (I2C EEPROM).
  • Endurance et rétention – EEPROM offre généralement une endurance d'écriture plus élevée que Flash. La rétention des données est généralement de 40 ans et plus. Pour Flash, considérez le nombre de cycles d'effacement et implémentez le niveau d'usure si vous écrivez fréquemment.

Le guide de sélection série EEPROM de Microchip] fournit des tableaux de comparaison directs. Winbond=s serial NOR Flash portfolio liste les options populaires SPI Flash. Lisez toujours la feuille de données spécifique pour le timing et les ensembles de commandes.

Connexion de la mémoire externe au microcontrôleur PIC

Le câblage matériel dépend de l'interface. Ci-dessous, nous détaillons les connexions I2C et SPI ainsi que des considérations importantes comme les résistances de traction et les condensateurs de découplage.

Interface I2C (IIC)

I2C utilise deux lignes bidirectionnelles : SDA (données sérielles) et SCL (horloge série). Le maître (PIC) contrôle l'horloge et lance des transactions. Chaque esclave a une adresse 7-bit ou 10-bit. Pour EEPROM, l'adresse comprend souvent un préfixe fixe plus trois broches d'adresse matérielle (A0, A1, A2) qui permettent jusqu'à huit appareils sur le même bus.

Fil d'exploitation:

  • Connectez SDA à une broche PIC I/O configurée comme un courant ouvert ou bidirectionnel.
  • Connectez SCL à une autre broche PIC I/O.
  • Ajouter des résistances externes (généralement 4.7 k.) de SDA et SCL à Vcc. La valeur dépend de la capacité et de la vitesse de l'autobus; pour 400 kHz, 2.2 k.
  • Connectez la mémoire , WP (cribe protect) pin à GND pour désactiver la protection matérielle d'écriture, ou à Vcc pour protéger l'ensemble du tableau.
  • Placez un condensateur céramique 0,1 μF près de la mémoire pour découpler le bruit.

Pour les I2C à grande vitesse (1 MHz), gardez les traces courtes et utilisez des pull-ups plus fortes. Exemple puces: Microchip 24LC256 (256 kbit I2C EEPROM), AT24C512 (512 kbit).

Interface SPI

SPI utilise quatre signaux : MOSI (maître dehors, esclave dedans), MISO (maître dedans, esclave dehors), SCLK[ (horloge série), et CS[ (chip select, active low). Chaque esclave SPI nécessite une ligne CS dédiée de la PIC. Plusieurs esclaves peuvent partager MISO, MOSI, SCLK s'ils ne sont pas sélectionnés simultanément.

Fil d'exploitation:

  • Connectez MOSI (sortie PIC) à la mémoire , SI (entrée série).
  • Connectez MISO (entrée PIC) à la mémoire SO (sortie série).
  • Connectez SCLK (sortie PIC) à la mémoire SCK.
  • Connectez CS à une broche de sortie numérique PIC. Pour de multiples souvenirs, utilisez des broches séparées.
  • Ajouter une faible traction (10 k.) sur la ligne CS si nécessaire, bien que la logique typique suffise.
  • Découpler la puissance avec un condensateur 0,1 μF.

Les puces SPI Flash ont souvent des registres d'état et ont besoin de séquences de commandes spécifiques (par exemple WREN avant d'écrire). Exemple de puces : Winbond W25Q32 (32 Mbit SPI Flash), Microchip 25LC256 (256 kbit SPI EEPROM).

Programmation du PIC pour accéder à la mémoire externe

Le microcontrôleur PIC doit initialiser le module périphérique approprié (I2C ou SPI) et envoyer/réception des données selon le protocole de la puce mémoire. Le module MSSP matériel de Microchip , Master Synchronous Serial Port, et le bit-banging logiciel peuvent être utilisés. Le MSSP est préféré pour la fiabilité et la vitesse.

Exemple de code de communication I2C

Ci-dessous, un exemple simplifié mais fonctionnel est utilisé avec le MCC (Microchip Code Configurator) généré par HAL pour un PIC16F18877. Le code écrit un octet unique à un EEPROM I2C à une adresse donnée et le lit ensuite.

// 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;
}

Remarque : Pour les pages écrites, vous ne devez pas franchir une limite de page (généralement 8, 16 ou 64 octets). Consultez la fiche technique pour connaître la taille de la page.

Exemple de code de communication SPI

Pour SPI Flash (p. ex. W25Q32), les opérations d'écriture nécessitent l'activation de write (WREN), puis l'envoi d'une commande Page Program. Voici un exemple minimal en utilisant MSSP en mode maître SPI.

#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 mémoire Flash ne peut pas être écrite sans effacer un secteur entier (généralement 4 KB). Toujours effacer le secteur avant de le reprogrammer. Utilisez la commande Sector Effacer (0x20) suivie d'un sondage sur le registre d'état jusqu'à ce que le bit write-in-progress s'efface.

Techniques avancées : Mises à jour de la mise à niveau, de la gestion de page et du firmware

Lorsque vous stockez de grandes quantités de données ou que vous effectuez des écritures fréquentes, envisagez ces stratégies pour prolonger la vie de la mémoire et maintenir la performance.

  • Taille de nivellement pour EEPROM – Distribuer écrit à plusieurs endroits. Par exemple, maintenir un index de tampon circulaire dans une fente EEPROM dédiée et écrire des données à la page libre suivante. Cela empêche le vieillissement précoce d'un octet.
  • Gestion des blocs de fichiers[ – Utilisez un simple système de fichiers ou table de métadonnées pour suivre les secteurs effacés/en cours d'utilisation.
  • Mise à jour des logiciels de démarrage en direct – Flash externe peut contenir une nouvelle image du firmware. Le chargeur de démarrage PIC lit l'image, l'écrit dans Flash interne et la réinitialise. Assurez-vous que la perte de puissance pendant l'écriture est gérée par une vérification double tampon ou un checksum.
  • Détection et correction d'erreurs[ – Pour les données critiques, ajouter des tableaux de vérification CRC ou XOR simples. À la lecture, vérifier l'intégrité. De nombreux souvenirs externes n'ont pas intégré ECC, donc les vérifications logicielles sont prudentes.

Meilleures pratiques et dépannage

Suivez ces lignes directrices pour minimiser les problèmes et assurer un fonctionnement robuste.

  • Voir toujours la fiche technique – Les paramètres de synchronisation, les commandes et les spécifications de traction varient d'un fabricant à l'autre.
  • Utilisez des résistances de traction appropriées pour I2C – La valeur dépend de la capacité et de la vitesse de l'horloge du bus. Pour un bus avec seulement un ou deux appareils et 400 kHz, commencez par 4.7 k. Utilisez un oscilloscope pour vérifier les bords montants.
  • Mise en œuvre Reconnaissez le sondage[ – Au lieu de délais fixes après l'écriture, envoyez à plusieurs reprises l'adresse du périphérique jusqu'à ce qu'un ACK soit reçu.
  • Keep SPI Traces Short – SPI tourne aux fréquences MHz; les longs fils provoquent des sonneries. Ajoutez des résistances de série (22–47 ↓) près de la sortie PIC pour amortir les réflexions.
  • Utilisez les condensateurs de découplage – Placez 0,1 μF céramique le plus près possible de chaque puce mémoire.
  • Test avec des motifs connus – Écrire alternant 0x55, 0xAA, et vérifier. Vérifier les limites de l'adresse (p. ex., écrire au-delà d'une limite de page doit être évité).
  • Moniteur pour la configuration de bus[ – Si plusieurs périphériques SPI partagent MISO, assurez-vous qu'une seule puce sélection est active à la fois.
  • Protection d'écriture de poignée[ – De nombreux souvenirs ont une broche WP. Soit la tirer bas pour activer l'écriture ou le contrôle via GPIO si vous avez besoin d'une protection sélective.

Exemple de projet : enregistreur de données avec Flash SPI

Pour solidifier les concepts, considérez un simple enregistreur de données qui lit périodiquement un capteur analogique, stocke la valeur dans SPI Flash (par exemple, W25Q16), et utilise un tampon circulaire pour écraser les données les plus anciennes. Le PIC se réveille du sommeil, effectue une conversion, écrit au bloc de secteur actuel, met à jour un pointeur dans EEPROM, et retourne au sommeil. Le Flash externe conserve des années de données avec une consommation minimale d'énergie.

Étapes clés :

  1. Initialiser le MSSP SPI, configurer CS pin comme sortie.
  2. Au démarrage, lisez le pointeur d'écriture actuel d'un petit EEPROM I2C (ou du premier secteur de Flash).
  3. Chaque cycle de logarithme : lire ADC → écrire à la page Flash → pointeur d'accroissement. Si le pointeur atteint la fin de la zone allouée, réinitialisez pour démarrer (circulaire).
  4. Calculer en option la CRC de la dernière page pour détecter la corruption.
  5. Utilisez un sommeil de faible puissance entre les intervalles.

Ce modèle peut être étendu à de multiples capteurs, à l'horodatage et à l'enregistrement par événement.

Conclusion et ressources supplémentaires

En sélectionnant l'interface appropriée (I2C ou SPI), en filant correctement et en mettant en œuvre des routines de lecture/écriture robustes, vous pouvez ajouter un stockage fiable non volatil à tout système embarqué. Des techniques avancées comme le nivellement de l'usure, la gestion de page et le vote Reconnaissez assurent une durabilité à long terme et des performances prévisibles.

Pour plus de détails, consultez les ressources suivantes :

Avec une conception soignée et des tests approfondis, la mémoire externe peut facilement évaluer vos projets PIC pour gérer des ensembles de données plus importants, des mises à jour de firmware et des besoins de configuration persistants. Commencez par une simple boucle d'écriture/de lecture, vérifiez avec un analyseur logique ou un oscilloscope, puis construisez la complexité progressivement.