Module simple d’EEPROM pour Arduino ou autre microcontrôleur

EEPROMs vous seront utiles si vous souhaitez stocker des données sans perdre. De nombreux microcontrôleurs viennent avec une EEPROM interne, mais comme EEPROMs ont un nombre fini (bien que très grand) d’écritures avant qu’ils commencent à devenir défectueux, mon anale rétentive personnage a toujours eu un problème avec l’aide de l’EEPROM interne.
Il existe d’autres raisons aussi pourquoi vous pourriez vouloir utiliser une EEPROM externe : enregistrement dans lequel vous venez de données veulent l’échanger une EEPROM, plutôt que de devoir lire votre microcontrôleur dans le domaine.
De toute façon, je voulais juste partager un module d’EEPROM de génération simple 5 minutes c’est un peu plus simple qu’un préalable, que j’ai publié.
BOM
1 x 24LC256 EEPROM (ou autre taille)
2 x 4 résistances k 7
bandelettes de veroboard 5 de 8
douille de IC DIL 8 broches (facultatif)

J’utilise un 24LC256. C’est un 256 kilobits EEPROM en fait qu’un 32 kilo-octets EEPROM dans mon mode de pensée traditionnel. Ce ne sont pas cher. Peut se le procurer pour environ 80 ct USD.
Bien que le Conseil peut également être utilisé pour des EEPROMS plus petits, comme un 24C32, je conseillerais contre cela. Si c’est ce dont vous avez besoin, acheter un 50 ct RTC DS1307 module qui comprend un 24C32 (qui est en fait 4kByte).

De toute façon, le 24LC256 est une EEPROM I2C, qui est tout à fait standard et qui rend l’utilisation facile
Broches A0, A1 et A2 sélectionnez les adresses I2C, (A0 = pin1, A1 = pin1, A2 = broche 3).
L’adressage est la suivante

Donc si vous vous connecter épinglettes A0, A1, A2 à adresse GND l’I2C sera 1010000 = 0 x 50 en hexadécimal.
Si vous les Connectez tous à Vcc, il sera 1010111 = 0 x 57.
0 x 50 est une adresse qui est souvent utilisée, j’ai décidé de relier A2 et A1 à terre et A0 à Vcc, qui donne 0 x 51. Il également dessina un tadd plus simple.
Broche 7 est la broche « WriteProtect » qui doit être retiré haute pour ReadOnly et faible en lecture/écriture. Évidemment j’ai branché sur le sol.
Le tirer vers le haut de résistances sont les deux 4k 7
Vous y trouverez de nombreuses bibliothèques EEPROM dans la Cour de récréation Arduino j’ai tendance à utiliser ce qui suit le code pour lire et écrire :

 void writeData(int device, unsigned int addr, byte data) // writes a byte of data 'data' to the chip at I2C address 'device', // in memory location 'add' { if ( addr > 65535 ) addr = addr | B00001000; Wire.beginTransmission(device); Wire.write((int)(addr >> 8)); // left-part of pointer address Wire.write((int)(addr & 0xFF)); // and the right Wire.write(data); Wire.endTransmission(); delay(10); } byte readData(int device, unsigned int add) // reads a byte of data from memory location 'add' in chip at I2C address 'device' { byte result; // returned value Wire.beginTransmission(device); // these three lines set the pointer // position in the EEPROM Wire.write((int)(add >> 8)); // left-part of pointer address Wire.write((int)(add & 0xFF)); // and the right Wire.endTransmission(); Wire.requestFrom(device, 1); // now get the byte of data... result = Wire.read(); return result; // and return it as a result of the function readData } 

Notes spéciales si vous utilisez le 24LC1025
Cette carte peut également servir pour EEPROMS plus grande, mais... Si vous l’utilisez pour la 24LC1025, vous devez faire une petite adaptation. Avec cette puce A2 doit être liée au Vcc pour cela à exploiter.

Le 24LC1025 a une limitation limite adressage interne qui est divisée en deux segments de 512K bits. Bloc select bit « B0 » pour contrôler l’accès à chaque segment.

L’adressage est déterminé par 1010B0A1A0R/W-dans lequel le « bit sélectionnez bloc est utilisé pour traiter la partie inférieure ou supérieure 512k bloquer la puce a donc 2 adresses différentes. avec la sélection de A0A1 comme dans ma chambre, ce sont :
1010101 = 0 x 55
1010001 = 0 x 51

Pour mémoire, l’accès de 0.. 65535 l’adresse I2C pour la puce mémoire est 0 x 51. Si vous souhaitez accéder à une mémoire entre 65536..131071 l’adresse de la puce est 0 x 55

Vous ne pouvez pas écrire à travers la limite d’octets 65535..65536 avec briser l’opération en deux appels de write(). Une carte à puce 0 x 51, l’autre à puce 0 x 55.