Bài 6. Bộ nhớ FLASH trên ESP32

ESP32 là một vi điều khiển mạnh mẽ với nhiều tính năng tiên tiến, trong đó bộ nhớ Flash đóng vai trò quan trọng. Bộ nhớ Flash trên ESP32 không chỉ lưu trữ chương trình mà còn quản lý nhiều dữ liệu quan trọng khác. Bài viết này Điện thông minh E-smart sẽ giúp các bạn tìm hiểu về cấu trúc, chức năng và cách sử dụng bộ nhớ Flash trên ESP32.

Cấu trúc bộ nhớ Flash trên ESP32

ESP32 thường được trang bị bộ nhớ Flash từ 4MB đến 16MB, trong đó:

  • Chương trình (Code): Được lưu trữ trong phần đầu của bộ nhớ Flash. Đây là nơi lưu trữ firmware mà bạn nạp vào ESP32.
  • SPIFFS/LittleFS: ESP32 hỗ trợ hệ thống file SPIFFS LittleFS, cho phép lưu trữ các file văn bản, hình ảnh và dữ liệu khác.
  • Partition Table: Bảng phân vùng chứa thông tin về cách bộ nhớ Flash được chia nhỏ và sử dụng.
bộ nhớ Flash trên ESP32
bộ nhớ Flash trên ESP32

Chức năng của bộ nhớ Flash trên ESP32

  • Lưu trữ chương trình (Firmware): Bộ nhớ Flash lưu trữ mã chương trình mà vi điều khiển sẽ thực thi.
  • Lưu trữ dữ liệu người dùng: Bằng cách sử dụng hệ thống file như SPIFFS hoặc LittleFS, bạn có thể lưu trữ các file cấu hình, hình ảnh và dữ liệu cảm biến.
  • OTA Update (Over-the-Air): Cho phép cập nhật firmware từ xa mà không cần kết nối vật lý.

Sử dụng bộ nhớ Flash trên ESP32

Để sử dụng bộ nhớ Flash trên ESP32, bạn có thể làm theo các bước sau:

Ghi và đọc bộ nhớ Flash dùng thư viện EEPROM:

Lưu trữ và đọc dữ liệu sử dụng EEPROM trên ESP32 cho phép bạn ghi và truy xuất các thông tin quan trọng như cấu hình Wi-Fi và các thông số cảm biến một cách dễ dàng. Thư viện EEPROM giúp bạn thực hiện các thao tác này thông qua các lệnh đơn giản, đảm bảo dữ liệu được lưu trữ bền vững và tồn tại qua các lần reset hoặc mất điện.

Lưu trữ và đọc dữ liệu sử dụng EEPROM

Ghi và đọc 1 ký tự

#include <EEPROM.h>

void setup() {
  Serial.begin(115200);
  EEPROM.begin(512);  // Khởi tạo EEPROM với 512 bytes

  // Ghi dữ liệu vào EEPROM
  EEPROM.write(0, 'A');
  EEPROM.commit();

  // Đọc dữ liệu từ EEPROM
  char value = EEPROM.read(0);
  Serial.print("Đọc từ EEPROM: ");
  Serial.println(value);
}

void loop() {
  // Không làm gì trong vòng lặp này
}

Ghi và đọc 1 chuỗi

#include <EEPROM.h>  // Thư viện EEPROM

void setup() {
  Serial.begin(115200);  // Khởi động Serial Monitor với baud rate 115200
  EEPROM.begin(100);  // Khởi tạo EEPROM với dung lượng 100 bytes

  // Ghi chuỗi "Hello ESP32!" vào EEPROM từ địa chỉ 0
  EEPROM.writeString(0, "Hello ESP32!");
  EEPROM.commit();  // Ghi nội dung vào bộ nhớ Flash

  // Khai báo mảng ký tự để đọc dữ liệu từ EEPROM
  char str[15];
  // Đọc chuỗi từ EEPROM từ địa chỉ 0
  size_t bytesRead = EEPROM.readString(0, str, sizeof(str));

  // Kiểm tra và in ra dữ liệu đọc được
  if (bytesRead > 0) {
    Serial.print("Read Data: ");
    Serial.println(str);
  } else {
    Serial.println("Error reading string from EEPROM.");
  }
}

void loop() {
  // Không làm gì trong vòng lặp này
}

Ghi và đọc biến cấu trúc

#include <EEPROM.h>  // Thư viện EEPROM

// Cấu trúc lưu trữ cấu hình
struct ConfigStore {
  uint8_t flags;  // Biến cờ
  char ssid[32];  // Tên mạng Wi-Fi
  char pass[64];  // Mật khẩu Wi-Fi
} __attribute__((packed));  // Đảm bảo cấu trúc được đóng gói gọn gàng

void setup() {
  Serial.begin(115200);  // Khởi động Serial Monitor với baud rate 115200

  EEPROM.begin(sizeof(ConfigStore));  // Khởi tạo EEPROM với kích thước của cấu trúc ConfigStore

  // Khởi tạo cấu trúc config với dữ liệu ban đầu
  ConfigStore config = {
    0,
    "DTM E-SMART",
    "0919890938"
  };

  // Ghi cấu trúc config vào EEPROM
  EEPROM.put(0, config);
  EEPROM.commit();  // Cam kết ghi dữ liệu vào bộ nhớ Flash

  // Xóa nội dung của config để đảm bảo đọc lại từ EEPROM
  memset(&config, 0, sizeof(config));

  // Đọc cấu trúc config từ EEPROM
  EEPROM.get(0, config);

  // In ra dữ liệu đã đọc được
  Serial.println("\nFlags: " + String(config.flags));
  Serial.println("SSID: " + String(config.ssid));
  Serial.println("PASS: " + String(config.pass));
}

void loop() {
  // Không làm gì trong vòng lặp này
}

Một số hàm thường dùng

[EEPROM Write Functions]

  • size_t writeByte(int address, uint8_t value);
  • size_t writeChar(int address, int8_t value);
  • size_t writeUChar(int address, uint8_t value);
  • size_t writeShort(int address, int16_t value);
  • size_t writeUShort(int address, uint16_t value);
  • size_t writeInt(int address, int32_t value);
  • size_t writeUInt(int address, uint32_t value);
  • size_t writeLong(int address, int32_t value);
  • size_t writeULong(int address, uint32_t value);
  • size_t writeLong64(int address, int64_t value);
  • size_t writeULong64(int address, uint64_t value);
  • size_t writeFloat(int address, float_t value);
  • size_t writeDouble(int address, double_t value);
  • size_t writeBool(int address, bool value);
  • size_t writeString(int address, const char* value);
  • size_t writeString(int address, String value);
  • size_t writeBytes(int address, const void* value, size_t len);

[EEPROM Read Functions]

  • uint8_t readByte(int address);
  • int8_t readChar(int address);
  • uint8_t readUChar(int address);
  • int16_t readShort(int address);
  • uint16_t readUShort(int address);
  • int32_t readInt(int address);
  • uint32_t readUInt(int address);
  • int32_t readLong(int address);
  • uint32_t readULong(int address);
  • int64_t readLong64(int address);
  • uint64_t readULong64(int address);
  • float_t readFloat(int address);
  • double_t readDouble(int address);
  • bool readBool(int address);
  • size_t readString(int address, char* value, size_t maxLen);
  • String readString(int address);
  • size_t readBytes(int address, void * value, size_t maxLen);

Lưu trữ và đọc dữ liệu sử dụng SPIFFS/LittleFS

Lưu trữ và đọc dữ liệu trên ESP32 có thể thực hiện dễ dàng thông qua hệ thống file SPIFFS hoặc LittleFS. Cả hai đều cho phép bạn tạo, đọc, ghi và xóa các file trong bộ nhớ Flash, tương tự như cách làm việc với hệ thống file trên máy tính. Điều này hữu ích trong việc lưu trữ cấu hình, dữ liệu cảm biến và các file khác.

ESP32
Lưu trữ và đọc dữ liệu sử dụng SPIFFS/LittleFS

Code dùng thư viện SPIFFS

#include <SPIFFS.h>

void setup() {
  Serial.begin(115200);

  if (!SPIFFS.begin(true)) {
    Serial.println("Lỗi khi khởi động SPIFFS");
    return;
  }

  // Ghi dữ liệu vào file
  File file = SPIFFS.open("/data.txt", FILE_WRITE);
  if (!file) {
    Serial.println("Lỗi khi mở file để ghi");
    return;
  }
  file.print("Hello, ESP32!");
  file.close();

  // Đọc dữ liệu từ file
  file = SPIFFS.open("/data.txt");
  if (!file) {
    Serial.println("Lỗi khi mở file để đọc");
    return;
  }
  while (file.available()) {
    Serial.write(file.read());
  }
  file.close();
}

void loop() {
  // Không làm gì trong vòng lặp này
}

Code dùng thư viện LittleFS

#include <FS.h>
#include <LittleFS.h>

void setup() {
  Serial.begin(115200);

  // Khởi tạo hệ thống file LittleFS
  if (!LittleFS.begin()) {
    Serial.println("Lỗi khi khởi động LittleFS");
    return;
  }

  // Ghi dữ liệu vào file
  File file = LittleFS.open("/data.txt", FILE_WRITE);
  if (!file) {
    Serial.println("Lỗi khi mở file để ghi");
    return;
  }
  file.print("Hello, ESP32 with LittleFS!");
  file.close();
  Serial.println("Dữ liệu đã được ghi vào file.");

  // Đọc dữ liệu từ file
  file = LittleFS.open("/data.txt");
  if (!file) {
    Serial.println("Lỗi khi mở file để đọc");
    return;
  }
  Serial.println("Nội dung trong file:");
  while (file.available()) {
    Serial.write(file.read());
  }
  file.close();
}

void loop() {
  // Không làm gì trong vòng lặp này
}

Cập nhật OTA

Bạn có thể sử dụng các thư viện như ArduinoOTA để cập nhật firmware từ xa cho ESP32. Việc này giúp bạn dễ dàng nạp các phiên bản mới của chương trình mà không cần phải kết nối vật lý với thiết bị. Quá trình cập nhật OTA không chỉ tiện lợi mà còn tiết kiệm thời gian, đặc biệt là trong các ứng dụng IoT mà thiết bị nằm ở những vị trí khó tiếp cận.

Ưu điểm của bộ nhớ Flash trên ESP32

  • Linh hoạt: Cho phép cập nhật OTA và lưu trữ dữ liệu người dùng một cách dễ dàng.
  • Dung lượng lớn: Với dung lượng từ 4MB đến 16MB, ESP32 có thể lưu trữ nhiều chương trình và dữ liệu.
  • Bền vững: Bộ nhớ Flash có tuổi thọ cao, phù hợp cho các ứng dụng yêu cầu lưu trữ dữ liệu lâu dài.

Kết luận

Bộ nhớ Flash trên ESP32 là một thành phần quan trọng giúp thiết bị này trở thành lựa chọn hàng đầu cho các ứng dụng IoT và nhúng. Việc hiểu rõ cách thức hoạt động và cách sử dụng bộ nhớ Flash sẽ giúp bạn tận dụng tối đa khả năng của ESP32, đồng thời mở ra nhiều cơ hội sáng tạo trong các dự án của mình.

5/5 - (8 bình chọn)

Trả lời

Email của bạn sẽ không được hiển thị công khai. Các trường bắt buộc được đánh dấu *

Chiêu sinh khóa Lập trình ESP32 căn bản, lớp (20h-21h30) 3-5-7 ngày 19/11/2024. Học phí 1tr/khóa (20 buổi). Đăng ký qua zalo: 0919.890.938

X
Contact Me on Zalo