Pamięć Eeprom z Arduino
Wbudowana pamięć Eeprom
Wbudowana pamięć EEPROM wynosi 1024 Bajty.
Przykład: Zapisywanie i odczytywanie danych z wbudowanej pamięci EEPROM
#include <EEPROM.h>
int addr = 0;
byte val = 12;
void setup() {
Serial.begin(9600);
EEPROM.write(addr, val);
delay(5);
int readVal = EEPROM.read(addr);
Serial.print("Value read from EEPROM: ");
Serial.println(readVal);
}
void loop() {
}Przykład: Zapisywanie i odczytywanie danych większych od 1B
#include <EEPROM.h>
const int EEPROM_ADDRESS = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
if (Serial.available()) {
//int dataToWrite = Serial.parseInt();
String dataToWrite = Serial.readString();
EEPROM.put(EEPROM_ADDRESS, dataToWrite);
delay(10);
//int valueRead;
String valueRead;
EEPROM.get(EEPROM_ADDRESS, valueRead);
Serial.print("Odczytana wartość: ");
Serial.println(valueRead);
}
}Zewnętrzna pamięć Eeprom FM24C256
Pamięć eeprom posiada domyślny adres I2C: 1010000, który można modyfikować za pomocą pinów A0, A1 i A2.
| 1 | 0 | 1 | 0 | A2 | A1 | A0 | R/W |
Ilość komórek pamięci jest znacznie większa od 255, dlatego ich adresowanie odbywa się za pomocą 16bitowego adresu. Dane zapisywane w buforze mogą zajmować maksymalnie 1B, dlatego adres komórek należy rozdzielić na 2 składowe 8 bitowe.
Pamięć FM24C256 jest podzielona na 64 Bajtowe strony, co umożliwia szybsze i łatwiejsze zapisywanie / odczytywanie danych w kolejnych komórkach.
Mając na uwadze maksymalny rozmiar bufora Arduino, tj. 32 Bajty, w jednej operacji można przesłać maksymalnie 2 Bajty adresu i 30 Bajtów danych.
Zapisywanie 1 Bajta danych do Eeprom
#include <Wire.h>
#define EEPROM_I2C_ADDRESS 0x50
unsigned int eepromAddress = 0;
void setup() {
Wire.begin();
Serial.begin(9600);
int readData = readEEPROM(eepromAddress);
Serial.println(readData);
}
void loop() {
if (Serial.available()) {
int dataToWrite = Serial.parseInt();
writeEEPROM(eepromAddress, dataToWrite);
delay(10);
int readData = readEEPROM(eepromAddress);
Serial.print("Odczytana wartość: ");
Serial.println(readData);
}
}
void writeEEPROM(unsigned int address, byte data) {
Wire.beginTransmission(EEPROM_I2C_ADDRESS);
Wire.write((int)(address >> 8)); // Wyślij wyższy bajt adresu
Wire.write((int)(address & 0xFF)); // Wyślij niższy bajt adresu
Wire.write(data);
Wire.endTransmission();
delay(5);
}
byte readEEPROM(unsigned int address) {
byte rData = 0xFF;
Wire.beginTransmission(EEPROM_I2C_ADDRESS);
Wire.write((int)(address >> 8)); // Wyślij wyższy bajt adresu
Wire.write((int)(address & 0xFF)); // Wyślij niższy bajt adresu
Wire.endTransmission();
// Wire.requestFrom(address, quantity, stop);
Wire.requestFrom(EEPROM_I2C_ADDRESS, 1);
if (Wire.available()) rData = Wire.read();
return rData;
}
Zapisywanie wartości tekstowych do Eeprom
#include <Wire.h>
#define EEPROM_ADDR 0x50 // Adres I2C pamięci EEPROM (7-bitowy adres)
#define BUFFER_SIZE 32 // Maksymalny rozmiar bufora dla I2C
void setup() {
Wire.begin();
Serial.begin(9600);
}
void loop() {
if (Serial.available()) {
String sentence = Serial.readStringUntil('\n');
sentence.trim();
writeStringToEEPROM(0x0000, sentence.c_str());
char buffer[BUFFER_SIZE];
readStringFromEEPROM(0x0000, buffer, BUFFER_SIZE);
Serial.println(buffer);
}
}
void writeStringToEEPROM(uint16_t address, const char* str) {
uint16_t length = strlen(str);
uint16_t offset = 0;
while (offset < length) {
Wire.beginTransmission(EEPROM_ADDR);
Wire.write((uint8_t)(address >> 8)); // Wysłanie starszego bajtu adresu
Wire.write((uint8_t)(address & 0xFF)); // Wysłanie młodszego bajtu adresu
//uint8_t bytesToWrite = min(BUFFER_SIZE - 2, length - offset);
uint8_t bytesToWrite = BUFFER_SIZE - 2; // Odejmujemy 2 bajty dla adresu
for (uint8_t i = 0; i < bytesToWrite; i++) {
Wire.write(str[offset + i]);
}
Wire.endTransmission();
delay(5);
address += bytesToWrite;
offset += bytesToWrite;
}
}
void readStringFromEEPROM(uint16_t address, char* buffer, uint16_t bufferLength) {
uint16_t offset = 0;
while (offset < bufferLength - 1) {
Wire.beginTransmission(EEPROM_ADDR);
Wire.write((uint8_t)(address >> 8)); // Wysłanie starszego bajtu adresu
Wire.write((uint8_t)(address & 0xFF)); // Wysłanie młodszego bajtu adresu
Wire.endTransmission();
uint8_t bytesToRead = min(BUFFER_SIZE, bufferLength - 1 - offset);
Wire.requestFrom(EEPROM_ADDR, bytesToRead);
while (Wire.available()) {
buffer[offset] = Wire.read();
offset++;
if (offset >= bufferLength - 1) {
break; // Zabezpieczenie przed przepełnieniem bufora
}
}
address += bytesToRead;
}
buffer[offset] = '\0'; // Dodanie null terminatora na końcu odczytanego ciągu
}
