265 lines
6.7 KiB
C++
265 lines
6.7 KiB
C++
#include <Wire.h>
|
||
#include <ctype.h>
|
||
/*
|
||
Разъем 6 пинов (2 ряда по 3 пина):
|
||
|
||
+--------------+---------+---------+--+
|
||
|--------------| none | SCL |--| <-- верхний ряд, пины 1 и 2
|
||
+--------------+---------+---------+--+
|
||
|--------------| GND | 3.3V |--| <-- нижний ряд, пины 3 и 4
|
||
+--------------+---------+---------+--+
|
||
|--------------| none | SDA |--| <-- нижний ряд, пины 5 и 6
|
||
+--------------+---------+---------+--+
|
||
|
||
Пояснения:
|
||
- SCL = I2C Clock pin
|
||
- SDA = I2C Data pin
|
||
- GND = общий минус
|
||
- 3.3V = питание EEPROM
|
||
- none = не подключен
|
||
*/
|
||
|
||
#define EEPROM_SIZE 256
|
||
#define I2C_MIN_ADDR 0x50
|
||
#define I2C_MAX_ADDR 0x57
|
||
|
||
#define SDA_PIN 8
|
||
#define SCL_PIN 9
|
||
|
||
uint8_t eeprom_addr = 0;
|
||
uint16_t versionAddr = 0x54; // версия начинается с этого адреса
|
||
uint16_t startAddr = 0x04; // адрес записи строк по умолчанию
|
||
char moduleStr[32] = {0}; // буфер для модуля
|
||
char versionStr[32] = {0}; // буфер для версии
|
||
|
||
|
||
bool ensureEEPROM() {
|
||
if (eeprom_addr == 0) { // 0 - значит еще не найдена
|
||
return findEEPROM();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
bool findEEPROM() {
|
||
Serial.println("Scanning for EEPROM...");
|
||
|
||
for (uint8_t addr = I2C_MIN_ADDR; addr <= I2C_MAX_ADDR; addr++) {
|
||
Wire.beginTransmission(addr);
|
||
if (Wire.endTransmission() == 0) {
|
||
eeprom_addr = addr;
|
||
Serial.print("Found EEPROM at address 0x");
|
||
Serial.println(eeprom_addr, HEX);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
Serial.println("EEPROM not found!");
|
||
return false;
|
||
}
|
||
|
||
|
||
void eepromWriteByte(uint8_t addr, uint8_t data) {
|
||
if (!ensureEEPROM()) {
|
||
Serial.println("EEPROM not found! Write aborted.");
|
||
return;
|
||
}
|
||
Wire.beginTransmission(eeprom_addr);
|
||
Wire.write(addr);
|
||
Wire.write(data);
|
||
Wire.endTransmission();
|
||
delay(5);
|
||
}
|
||
|
||
uint8_t eepromReadByte(uint8_t addr) {
|
||
if (!ensureEEPROM()) {
|
||
Serial.println("EEPROM not found! Write aborted.");
|
||
return 0xFF;
|
||
}
|
||
|
||
Wire.beginTransmission(eeprom_addr);
|
||
Wire.write(addr);
|
||
Wire.endTransmission();
|
||
|
||
Wire.requestFrom(eeprom_addr, (uint8_t)1);
|
||
if (Wire.available()) {
|
||
return Wire.read();
|
||
}
|
||
|
||
return 0xFF;
|
||
}
|
||
|
||
void writeStringToEEPROM(const char* str, uint16_t addr) {
|
||
if (!ensureEEPROM()) {
|
||
Serial.println("EEPROM not found! Write aborted.");
|
||
return;
|
||
}
|
||
|
||
size_t len = strlen(str);
|
||
if (addr + len + 1 > EEPROM_SIZE)
|
||
len = EEPROM_SIZE - addr - 1;
|
||
|
||
if (addr < versionAddr) {
|
||
// Очистить всё пространство от addr до versionAddr (не включая versionAddr)
|
||
for (uint16_t i = addr; i < versionAddr; i++) {
|
||
eepromWriteByte(i, 0xFF);
|
||
}
|
||
} else {
|
||
// Очистить только область для новой строки (len + 1 — включая нулевой терминатор)
|
||
for (size_t i = 0; i < len + 1; i++) {
|
||
eepromWriteByte(addr + i, 0xFF);
|
||
}
|
||
}
|
||
|
||
Serial.print("Writing to EEPROM @ 0x");
|
||
Serial.print(addr, HEX);
|
||
Serial.print(": ");
|
||
Serial.println(str);
|
||
|
||
for (size_t i = 0; i < len; i++) {
|
||
eepromWriteByte(addr + i, str[i]);
|
||
}
|
||
eepromWriteByte(addr + len, 0); // null-терминатор
|
||
}
|
||
|
||
void readModuleFromEEPROM() {
|
||
if (!ensureEEPROM()) {
|
||
Serial.println("EEPROM not found! Write aborted.");
|
||
return;
|
||
}
|
||
memset(moduleStr, 0, sizeof(moduleStr));
|
||
for (size_t i = 0; i < sizeof(moduleStr) - 1; i++) {
|
||
uint8_t b = eepromReadByte(startAddr + i);
|
||
if (b == 0 || b == 0xFF) {
|
||
moduleStr[i] = 0;
|
||
break;
|
||
}
|
||
moduleStr[i] = (char)b;
|
||
}
|
||
moduleStr[sizeof(moduleStr)-1] = 0;
|
||
|
||
Serial.print("[EEPROM] Module read: ");
|
||
Serial.println(moduleStr);
|
||
}
|
||
|
||
void readVersionFromEEPROM() {
|
||
if (!ensureEEPROM()) {
|
||
Serial.println("EEPROM not found! Write aborted.");
|
||
return;
|
||
}
|
||
memset(versionStr, 0, sizeof(versionStr));
|
||
|
||
for (size_t i = 0; i < sizeof(versionStr) - 1; i++) {
|
||
uint8_t b = eepromReadByte(versionAddr + i);
|
||
if (b == 0 || b == 0xFF) {
|
||
versionStr[i] = 0;
|
||
break;
|
||
}
|
||
versionStr[i] = (char)b;
|
||
}
|
||
|
||
versionStr[sizeof(versionStr) - 1] = 0;
|
||
|
||
Serial.print("[EEPROM] Version read: ");
|
||
Serial.println(versionStr);
|
||
}
|
||
|
||
|
||
void readAndDumpEEPROM() {
|
||
if (!ensureEEPROM()) {
|
||
Serial.println("EEPROM not found! Write aborted.");
|
||
return;
|
||
}
|
||
Serial.println("\nDumping full EEPROM contents:\n");
|
||
|
||
for (uint16_t base = 0; base < EEPROM_SIZE; base += 16) {
|
||
char ascii[17] = {0};
|
||
|
||
Serial.print("0x");
|
||
if (base < 0x10) Serial.print('0');
|
||
Serial.print(base, HEX);
|
||
Serial.print(": ");
|
||
|
||
for (uint8_t i = 0; i < 16; i++) {
|
||
uint8_t val = eepromReadByte(base + i);
|
||
if (val < 0x10) Serial.print('0');
|
||
Serial.print(val, HEX);
|
||
Serial.print(' ');
|
||
|
||
ascii[i] = isPrintable(val) ? (char)val : '.';
|
||
}
|
||
|
||
Serial.print(" |");
|
||
Serial.print(ascii);
|
||
Serial.println("|");
|
||
}
|
||
}
|
||
|
||
void setup() {
|
||
Serial.begin(9600);
|
||
while (!Serial);
|
||
|
||
setupUI();
|
||
Wire.begin(SDA_PIN, SCL_PIN);
|
||
|
||
bool eeprom_found = findEEPROM();
|
||
|
||
if (eeprom_found) {
|
||
readModuleFromEEPROM();
|
||
readVersionFromEEPROM();
|
||
}
|
||
|
||
Serial.println("Ready.");
|
||
Serial.println("Set start address with 'ADDR=<number>'");
|
||
Serial.println("Set version with 'VER=<version_string>'");
|
||
Serial.println("Then type string and press ENTER to write it.");
|
||
Serial.print("Current start address = 0x");
|
||
Serial.println(startAddr, HEX);
|
||
}
|
||
|
||
|
||
String inputBuffer;
|
||
|
||
void loop() {
|
||
while (Serial.available()) {
|
||
char c = Serial.read();
|
||
if (c == '\n' || c == '\r') {
|
||
inputBuffer.trim();
|
||
|
||
if (inputBuffer.length() > 0) {
|
||
if (inputBuffer.startsWith("ADDR=")) {
|
||
String valStr = inputBuffer.substring(5);
|
||
int val = valStr.toInt();
|
||
if (val >= 0 && val < EEPROM_SIZE) {
|
||
startAddr = (uint16_t)val;
|
||
Serial.print("Start address set to 0x");
|
||
Serial.println(startAddr, HEX);
|
||
} else {
|
||
Serial.println("Invalid address! Must be 0..255");
|
||
}
|
||
}
|
||
else if (inputBuffer.startsWith("VER=")) {
|
||
String ver = inputBuffer.substring(4);
|
||
ver.trim();
|
||
ver.toCharArray(versionStr, sizeof(versionStr));
|
||
writeStringToEEPROM(versionStr, versionAddr);
|
||
Serial.print("Version written: ");
|
||
Serial.println(versionStr);
|
||
}
|
||
else {
|
||
writeStringToEEPROM(inputBuffer.c_str(), startAddr);
|
||
delay(100);
|
||
readAndDumpEEPROM();
|
||
}
|
||
}
|
||
|
||
inputBuffer = "";
|
||
Serial.println("\nEnter command or string:");
|
||
} else {
|
||
inputBuffer += c;
|
||
}
|
||
}
|
||
|
||
loopUI();
|
||
}
|