Cách sử dụng EEPROM trong Arduino

Tìm hiểu cách sử dụng EEPROM, viết tắt của bộ nhớ chỉ đọc có thể lập trình có thể xóa bằng điện, trên bo mạch Arduino.
Bộ vi điều khiển trên bo mạch Arduino có 512 byte EEPROM: bộ nhớ có giá trị được giữ khi tắt bo mạch (giống như một ổ cứng nhỏ).

Các chức năng trong lớp EEPROM được tự động đưa vào nền tảng cho bo mạch, nghĩa là bạn không cần cài đặt bất kỳ thư viện bên ngoài nào.

Yêu cầu phần cứng

Tất cả các bo sau đều có EEPROM:

Arduino UNO R4 Minima
Arduino UNO R4 Wi-Fi
Arduino UNO Rev.3
Arduino UNO WiFi Rev.2
Arduino Mega 2560 Rev.3
Arduino Nano mỗi
vi mạch Arduino
Arduino Leonardo
Arduino nano

Xóa EEPROM

Ví dụ này minh họa cách đặt tất cả các byte đó thành 0, khởi tạo chúng để chứa thông tin mới, sử dụng hàm EEPROM.write().
/*
* Xóa EEPROM
*
* Đặt tất cả các byte của EEPROM thành 0.
* Vui lòng xem eeprom_iteration để biết thêm chi tiết
* xem cách duyệt qua EEPROM.
*
* Mã ví dụ này thuộc phạm vi công cộng.
*/
#include

void setup() {
// khởi tạo chân LED làm đầu ra.

pinMode(13, OUTPUT);
/***
Lặp lại qua từng byte của bộ lưu trữ EEPROM.
Bộ xử lý AVR lớn hơn có kích thước EEPROM lớn hơn, ví dụ:
- Arduino Duemilanove: Bộ lưu trữ 512 B EEPROM.
- Arduino Uno: Bộ lưu trữ 1 kB EEPROM.
- Arduino Mega: Bộ lưu trữ 4 kB EEPROM.
Thay vì mã hóa cứng độ dài, bạn nên sử dụng hàm độ dài được cung cấp trước.
Điều này sẽ làm cho code di động tới tất cả các bộ xử lý AVR.
***/
for (int i = 0 ; i < EEPROM.length() ; i++) {
EEPROM.write(i, 0);
}
// bật đèn LED khi chúng ta hoàn thành
digitalWrite(13, HIGH);
}

void loop() {
/** Vòng lặp rỗng. **/
}

EEPROM CRC

CRC là một cách đơn giản để kiểm tra xem dữ liệu đã thay đổi hay bị hỏng hay chưa. Ví dụ này tính toán giá trị CRC trực tiếp trên các giá trị EEPROM. CRC này giống như một chữ ký và bất kỳ thay đổi nào trong CRC được tính toán đều có nghĩa là thay đổi dữ liệu được lưu trữ. Mục đích của ví dụ này là làm nổi bật cách đối tượng EEPROM có thể được sử dụng giống như một mảng.

/***

Thuật toán CRC được tạo bởi pycrc, giấy phép MIT ( https://github.com/tpircher/pycrc ).

CRC là một cách đơn giản để kiểm tra xem dữ liệu đã thay đổi hay bị hỏng hay chưa.

Ví dụ này tính toán giá trị CRC trực tiếp trên các giá trị EEPROM.

Mục đích của ví dụ này là làm nổi bật cách đối tượng EEPROM có thể được sử dụng giống như một mảng.

***/
#include
#include

void setup() {
// Bắt đầu nối tiếp
Serial.begin(9600);

while (!Serial) {
; // đợi cổng nối tiếp kết nối. Chỉ cần thiết cho cổng USB gốc

}

//In độ dài của dữ liệu để chạy CRC.
Serial.print("EEPROM length: ");

Serial.println(EEPROM.length());
//In kết quả gọi eeprom_crc()
Serial.print("CRC32 of EEPROM data: 0x");

Serial.println(eeprom_crc(), HEX);

Serial.print(" Done!");
}

void loop() {
/* Vòng lặp rỗng */
}

unsigned long eeprom_crc(void) {

const unsigned long crc_table[16] = {

0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,

0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,

0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,

0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c

};

unsigned long crc = ~0L;

for (int index = 0 ; index < EEPROM.length() ; ++index) {

crc = crc_table[(crc ^ EEPROM[index]) & 0x0f] ^ (crc >> 4);

crc = crc_table[(crc ^ (EEPROM[index] >> 4)) & 0x0f] ^ (crc >> 4);

crc = ~crc;

}

return crc;
}

Nhận EEPROM

Mục đích của ví dụ này là để chỉ ra cách các phương thức đặt và nhận cung cấp một hành vi khác với hành vi ghi và đọc, hoạt động trên các byte đơn. Nhận các biến khác nhau từ EEPROM lấy một số byte có liên quan đến kiểu dữ liệu của biến.

/***

ví dụ eeprom_get.

Cho thấy cách sử dụng phương thức EEPROM.get().

Để đặt trước dữ liệu EEPROM, hãy chạy ví dụ sketch eeprom_put.

Bản sketch này sẽ chạy mà không có nó, tuy nhiên, các giá trị được hiển thị

sẽ được hiển thị từ những gì đã có trên EEPROM.

Điều này có thể khiến đối tượng nối tiếp in ra một chuỗi lớn

rác nếu không có ký tự null bên trong một trong các chuỗi
nạp vào.

***/
#include

void setup() {

float f = 0.00f; //Biến lưu trữ dữ liệu đọc từ EEPROM.

int eeAddress = 0; //Địa chỉ EEPROM để bắt đầu đọc từ

Serial.begin(9600);

while (!Serial) {

; // đợi cổng nối tiếp kết nối. Chỉ cần thiết cho cổng USB gốc

}

Serial.print("đọc float từ EEPROM: ");

// Lấy dữ liệu float từ EEPROM tại vị trí 'eeAddress'

EEPROM.get(eeAddress, f);

Serial.println(f, 3); // Bước này có thể in ra 'ovf, nan' nếu dữ liệu bên trong EEPROM không phải là số float hợp lệ.

/***

Vì get cũng trả về một tham chiếu đến 'f', bạn có thể sử dụng nó nội tuyến.

Ví dụ: Serial.print( EEPROM.get( eeAddress, f ) );

***/

/***

Get cũng có thể được sử dụng với các cấu trúc tùy chỉnh.

Tôi đã tách cái này thành một chức năng bổ sung.

***/

secondTest(); // Chạy thử nghiệm tiếp theo.
}

struct MyObject {

float field1;

byte field2;

char name[10];
};

void secondTest() {

int eeAddress = sizeof(float); // Di chuyển địa chỉ sang byte tiếp theo sau float 'f'.

MyObject customVar; // Biến để lưu trữ đối tượng tùy chỉnh được đọc từ EEPROM.

EEPROM.get(eeAddress, customVar);

Serial.println("Đọc đối tượng tùy chỉnh từ EEPROM: ");

Serial.println(customVar.field1);

Serial.println(customVar.field2);

Serial.println(customVar.name);
}

void loop() {

/* Vòng lặp rỗng */
}

Lặp lại EEPROM

Mục đích của ví dụ này là chỉ ra cách đi qua toàn bộ không gian bộ nhớ EEPROM với các cách tiếp cận khác nhau. Mã được cung cấp không tự chạy mà nên được sử dụng làm nguồn cung cấp các đoạn mã để sử dụng ở nơi khác.

/***

eeprom_iteration ví dụ.

Một tập hợp các đoạn ví dụ làm nổi bật

phương pháp đơn giản nhất để duyệt qua EEPROM.

Chạy bản sketch này là không cần thiết, đây là

chỉ cần làm nổi bật các phương pháp lập trình nhất định.

***/

#include

void setup() {

/***

Lặp lại EEPROM bằng vòng lặp for.

***/

for (int index = 0 ; index < EEPROM.length() ; index++) {

// Thêm một vào mỗi ô trong EEPROM

EEPROM[ index ] += 1;

}

/***

Lặp lại EEPROM bằng vòng lặp while.

***/

int index = 0;

while (index < EEPROM.length()) {

// Thêm một vào mỗi ô trong EEPROM

EEPROM[ index ] += 1;

index++;

}

/***

Lặp lại EEPROM bằng vòng lặp do-while.

***/

int idx = 0; // Đã sử dụng 'idx' để tránh xung đột tên với 'index' ở trên.

do {

// Thêm một vào mỗi ô trong EEPROM

EEPROM[ idx ] += 1;

idx++;

} while (idx < EEPROM.length());

} // Kết thúc chức năng thiết lập.

void loop() {}

Đặt EEPROM

Mục đích của ví dụ này là để hiển thị phương thức EEPROM.put() ghi dữ liệu trên EEPROM bằng cách sử dụng cả EEPROM.update() chỉ ghi dữ liệu nếu nó khác với nội dung trước đó của các vị trí được ghi. Số byte được ghi có liên quan đến kiểu dữ liệu hoặc cấu trúc tùy chỉnh của biến được ghi.

/***

eeprom_put ví dụ.

Cho thấy cách sử dụng phương thức EEPROM.put().

Ngoài ra, sketch này sẽ đặt trước dữ liệu EEPROM cho

ví dụ phác thảo eeprom_get.

Lưu ý, không giống như phiên bản byte đơn EEPROM.write(),

phương pháp đặt sẽ sử dụng ngữ nghĩa cập nhật. Như trong một byte

sẽ chỉ được ghi vào EEPROM nếu dữ liệu thực sự

khác biệt.

***/

#include

struct MyObject {

float field1;

byte field2;

char name[10];
};

void setup() {

Serial.begin(9600);

while (!Serial) {

; // đợi cổng nối tiếp kết nối. Chỉ cần thiết cho cổng USB gốc

}

float f = 123.456f; // Biến để lưu trữ trong EEPROM.

int eeAddress = 0; // Vị trí chúng ta muốn đặt dữ liệu.

// Một call đơn giản, với địa chỉ đầu tiên và đối tượng thứ hai.

EEPROM.put(eeAddress, f);

Serial.println("Viết kiểu dữ liệu float!");

/** Put cũng được thiết kế để sử dụng với các cấu trúc tùy chỉnh. **/

//Dữ liệu cần lưu trữ.

MyObject customVar = {

3.14f,

65,

"Working!"

};

eeAddress += sizeof(float); // Di chuyển địa chỉ sang byte tiếp theo sau float 'f'.

EEPROM.put(eeAddress, customVar);

Serial.print("Viết kiểu dữ liệu tùy chỉng! xem sketch ví dụ eeprom_get để xem làm thế nào truy xuất các giá trị!");
}

void loop() {

/* Vòng lặp rỗng */
}

EEPROM Đọc

Ví dụ này minh họa cách đọc giá trị của từng byte EEPROM bằng hàm EEPROM.read() và cách in các giá trị đó ra cửa sổ nối tiếp của Phần mềm Arduino (IDE).

/*
* EEPROM Đọc
*
* Đọc giá trị của từng byte của EEPROM và in ra
* vào máy tính.
*/

#include

// bắt đầu đọc từ byte đầu tiên (địa chỉ 0) của EEPROM
int address = 0;
byte value;

void setup() {
// khởi tạo serial và đợi port mở:
Serial.begin(9600);
while (!Serial) {
; // đợi cổng nối tiếp kết nối. Chỉ cần thiết cho cổng USB gốc
}
}

void loop() {
// đọc một byte từ địa chỉ hiện tại của EEPROM
value = EEPROM.read(address);

Serial.print(address);
Serial.print(" ");
Serial.print(value, DEC);
Serial.println();

/***
Tiến tới địa chỉ tiếp theo, khi ở cuối khởi động lại từ đầu.

Bộ xử lý AVR lớn hơn có kích thước EEPROM lớn hơn, ví dụ:
- Arduino Duemilanove: Bộ lưu trữ 512 B EEPROM.
- Arduino Uno: Bộ lưu trữ 1 kB EEPROM.
- Arduino Mega: Bộ lưu trữ 4 kB EEPROM.

Thay vì mã hóa cứng độ dài, bạn nên sử dụng hàm độ dài được cung cấp trước.
Điều này sẽ làm cho mã của bạn di động tới tất cả các bộ xử lý AVR.
***/
address = address + 1;
if (address == EEPROM.length()) {
address = 0;
}

/***
Vì các kích thước EEPROM là lũy thừa của hai, nên gói (ngăn tràn) của một
Địa chỉ EEPROM cũng có thể thực hiện được theo từng bit và có độ dài - 1.

++address &= EEPROM.length() - 1;
***/

delay(500);
}

Cập nhật EEPROM

Mục đích của ví dụ này là để hiển thị phương thức EEPROM.update() chỉ ghi dữ liệu nếu nó khác với nội dung trước đó của các vị trí sẽ được ghi. Giải pháp này có thể tiết kiệm thời gian thực hiện vì mỗi thao tác ghi mất 3,3 ms; EEPROM cũng có giới hạn 100.000 chu kỳ ghi trên mỗi vị trí, do đó tránh ghi lại cùng một giá trị ở bất kỳ vị trí nào sẽ làm tăng tuổi thọ tổng thể của EEPROM.

/***
Phương pháp cập nhật EEPROM

Lưu trữ các giá trị được đọc từ đầu vào analog 0 vào EEPROM.
Các giá trị này sẽ ở trong EEPROM khi bo mạch
tắt và có thể được truy xuất sau bởi một sketch khác.

Nếu một giá trị không thay đổi trong EEPROM, nó sẽ không bị ghi đè
điều này sẽ làm giảm tuổi thọ của EEPROM một cách không cần thiết.

***/

#include

/** địa chỉ hiện tại trong EEPROM (tức là byte nào chúng ta sẽ ghi tiếp theo) **/
int address = 0;

void setup() {
/** thiết lập trống **/
}

void loop() {
/***
cần chia cho 4 vì đầu vào analog có phạm vi từ
0 đến 1023 và mỗi byte của EEPROM chỉ có thể chứa một
giá trị từ 0 đến 255.
***/
int val = analogRead(0) / 4;

/***
Cập nhật ô EEPROM cụ thể.
những giá trị này sẽ vẫn ở đó khi bo được
tắt.
***/
EEPROM.update(address, val);

/***
Hàm EEPROM.update(address, val) tương đương như sau:

if( EEPROM.read(address) != val ){
EEPROM.write(address, val);
}
***/

/***
Tiến tới địa chỉ tiếp theo, khi ở cuối khởi động lại từ đầu.

/***
Vì các kích thước EEPROM là lũy thừa của hai, nên gói (ngăn tràn) của một
Địa chỉ EEPROM cũng có thể thực hiện được theo từng bit và có độ dài - 1.

++address &= EEPROM.length() - 1;
***/

delay(100);
}

Viết EEPROM

Ví dụ này minh họa cách lưu trữ các giá trị được đọc từ đầu vào analog 0 vào EEPROM bằng cách sử dụng hàm EEPROM.write(). Các giá trị này sẽ nằm trong EEPROM khi tắt bo mạch và có thể được lấy lại sau bởi một sketch khác.

* Viết EEPROM

* Lưu trữ các giá trị được đọc từ đầu vào analog 0 vào EEPROM.

* Các giá trị này sẽ nằm trong EEPROM khi bo mạch

* đã tắt và có thể được truy xuất sau bằng một sketch khác.

#include

/** địa chỉ hiện tại trong EEPROM (nghĩa là byte nào chúng ta sẽ ghi tiếp theo) **/
int addr = 0;

void setup() {

/** Thiết lập trống. **/
}

void loop() {

/***

Cần chia cho 4 vì đầu vào analog có phạm vi từ

0 đến 1023 và mỗi byte của EEPROM chỉ có thể chứa một