DashyFox/PingPong
1
0
Fork 0
mirror of https://github.com/DashyFox/StackSport.git synced 2025-05-04 15:20:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

EEPROM write fix

Browse Source
This commit is contained in:
DashyFox 2024-10-09 15:10:28 +03:00
parent 08b99d8ec2
commit 4506f53d95
3 changed files with 195 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Core/Inc/EEPROM.h
View File

@ -19,7 +19,7 @@
#define PROGRAM_BLOCKSIZE 67 #define PROGRAM_BLOCKSIZE 67
#define MAX_PROGRAM_COUNT 256 #define MAX_PROGRAM_COUNT 256
#define MAX_SHOT_COUNT_IN_PROGRAMS \ #define MAX_SHOT_COUNT_IN_PROGRAMS \
(PROGRAM_BLOCKSIZE-sizeof(ProgramHeader)) /sizeof(ProgramShot) // ((PROGRAM_BLOCKSIZE-sizeof(ProgramHeader)) /sizeof(ProgramShot)-1) //
#define START_ADR_MACRO (START_ADR_PROGRAM + (PROGRAM_BLOCKSIZE*MAX_PROGRAM_COUNT)) #define START_ADR_MACRO (START_ADR_PROGRAM + (PROGRAM_BLOCKSIZE*MAX_PROGRAM_COUNT))
#define MACRO_BLOCKSIZE 129 #define MACRO_BLOCKSIZE 129

72
Core/Src/EEPROM.c
View File

@ -188,7 +188,7 @@ MemoryStatus saveProg(unsigned char number, Program *prog) {
result = EEPROM_MISSING_ELEMENT; result = EEPROM_MISSING_ELEMENT;
} }
} }
HAL_IWDG_Refresh(&hiwdg);
uint16_t totalSize = sizeof(ProgramHeader) uint16_t totalSize = sizeof(ProgramHeader)
+ sizeof(ProgramShot) * prog->header.shotCount; + sizeof(ProgramShot) * prog->header.shotCount;
@ -293,40 +293,48 @@ MemoryStatus EEPROM_EARSE() {
MemoryStatus FLASH_WriteBlock(uint16_t startAddr, uint8_t number, MemoryStatus FLASH_WriteBlock(uint16_t startAddr, uint8_t number,
uint8_t *writeData, uint16_t dataSize, uint16_t blockSize) { uint8_t *writeData, uint16_t dataSize, uint16_t blockSize) {
HAL_StatusTypeDef result; HAL_StatusTypeDef result;
const uint16_t maxWriteSize = 64; // Максимальный размер блока для EEPROM AT24
uint16_t currentAddr = startAddr + (number * blockSize);
uint16_t bytesWritten = 0;
// Проверка на корректность входных данных // Проверка на корректность входных данных
if ((startAddr == START_ADR_SHOT && number >= MAX_SHOT_COUNT) if ((startAddr == START_ADR_SHOT && number >= MAX_SHOT_COUNT) ||
|| (startAddr == START_ADR_PROGRAM && number >= MAX_PROGRAM_COUNT) (startAddr == START_ADR_PROGRAM && number >= MAX_PROGRAM_COUNT) ||
|| (startAddr == START_ADR_MACRO && number >= MAX_MACRO_COUNT)) { (startAddr == START_ADR_MACRO && number >= MAX_MACRO_COUNT)) {
return EEPROM_OUT_OF_RANGE; return EEPROM_OUT_OF_RANGE;
} }
uint16_t blockAddr16 = (uint16_t) (startAddr while (bytesWritten < dataSize) {
+ (uint16_t) (number * blockSize)); uint16_t chunkSize = (dataSize - bytesWritten > maxWriteSize) ? maxWriteSize : (dataSize - bytesWritten);
uint8_t blockAddr[2] = { HIBYTE(blockAddr16), LOBYTE(blockAddr16) }; uint16_t blockAddr16 = currentAddr;
uint8_t blockAddr[2] = { HIBYTE(blockAddr16), LOBYTE(blockAddr16) };
unsigned char Buf[dataSize + 2]; unsigned char Buf[chunkSize + 2];
memset(Buf, 0x00, sizeof(Buf)); memset(Buf, 0x00, sizeof(Buf));
Buf[0] = blockAddr[0]; Buf[0] = blockAddr[0];
Buf[1] = blockAddr[1]; Buf[1] = blockAddr[1];
for (unsigned char i = 0; i < dataSize; i++) for (uint16_t i = 0; i < chunkSize; i++) {
Buf[i + 2] = writeData[i]; Buf[i + 2] = writeData[bytesWritten + i];
}
result = HAL_I2C_Master_Transmit(&hi2c1, (AT24C_ADRESS << 1), Buf, result = HAL_I2C_Master_Transmit(&hi2c1, (AT24C_ADRESS << 1), Buf, (chunkSize + 2), 10);
(dataSize + 2), 10); HAL_Delay(1);
// print("Written ");
// printNumber(dataSize); if (result != HAL_OK) {
// print(" bytes\n"); return EEPROM_FAIL;
HAL_Delay(1); }
if (result != HAL_OK) {
return EEPROM_FAIL; bytesWritten += chunkSize;
} currentAddr += chunkSize;
return EEPROM_OK; }
return EEPROM_OK;
} }
MemoryStatus FLASH_DelBlock(uint16_t startAddr, uint8_t number, MemoryStatus FLASH_DelBlock(uint16_t startAddr, uint8_t number,
uint16_t dataSize) { uint16_t dataSize) {
HAL_StatusTypeDef result; HAL_StatusTypeDef result;
@ -365,7 +373,7 @@ MemoryStatus FLASH_ReadBlock(uint16_t startAddr, uint8_t number,
if ((startAddr == START_ADR_SHOT && number > MAX_SHOT_COUNT) if ((startAddr == START_ADR_SHOT && number > MAX_SHOT_COUNT)
|| (startAddr == START_ADR_PROGRAM && number > MAX_PROGRAM_COUNT) || (startAddr == START_ADR_PROGRAM && number > MAX_PROGRAM_COUNT)
|| (startAddr == START_ADR_MACRO && number > MAX_MACRO_COUNT)) { || (startAddr == START_ADR_MACRO && number > MAX_MACRO_COUNT)) {
print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11"); // print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11");
return EEPROM_OUT_OF_RANGE; return EEPROM_OUT_OF_RANGE;
} }
@ -381,13 +389,13 @@ MemoryStatus FLASH_ReadBlock(uint16_t startAddr, uint8_t number,
result = HAL_I2C_Master_Receive(&hi2c1, (AT24C_ADRESS << 1) | 1, readData, result = HAL_I2C_Master_Receive(&hi2c1, (AT24C_ADRESS << 1) | 1, readData,
dataSize, 10); dataSize, 10);
print("FLASH_ReadBlock: "); // print("FLASH_ReadBlock: ");
printNumber(blockAddr16); // printNumber(blockAddr16);
// print("\n"); // print("\n");
HAL_Delay(1); HAL_Delay(1);
if (result != HAL_OK) { if (result != HAL_OK) {
print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11"); // print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11");
return EEPROM_FAIL; return EEPROM_FAIL;
} }
return EEPROM_OK; return EEPROM_OK;

214
Core/Src/IR_CMD_HandlerLogic.c
View File

@ -205,83 +205,177 @@ void IR_Home_Process() {
///////////////////////////////////////////////////////// /////////////////////////////////////////////////////////
case IR_FONT_RIGHT: case IR_FONT_RIGHT:
break;
// for (int i = 0; i <= 100; ++i) { // for (int i = 0; i <= 100; ++i) {
// led_progressbar(0, 19, i); // led_progressbar(0, 19, i);
// HAL_Delay(10); // HAL_Delay(10);
// } // }
// led_clear(); // led_clear();
break; // break;
{ {
sound_play_note((Note_t){0, 0, 50},3); sound_play_note((Note_t){0, 0, 50},3);
Shot wrShot; // Shot wrShot;
wrShot.isExist = 0xAA; // wrShot.isExist = 0xAA;
wrShot.countRepeatShot = 0xBB; // wrShot.countRepeatShot = 0xBB;
wrShot.rotationAxial = 0xCC; // wrShot.rotationAxial = 0xCC;
wrShot.rotationHorizontal = 0xDD; // wrShot.rotationHorizontal = 0xDD;
wrShot.rotationVertical = 0xEE; // wrShot.rotationVertical = 0xEE;
wrShot.speedRollerBottom = 0xFF; // wrShot.speedRollerBottom = 0xFF;
wrShot.speedRollerTop = 0x0F; // wrShot.speedRollerTop = 0x0F;
wrShot.speedScrew = 0xF0; // wrShot.speedScrew = 0xF0;
//
// for (int i = 0; i < MAX_SHOT_COUNT; ++i) {
// print("SAVE ");
// printNumber(i);
// print(" -> ");
// MemoryStatus saveStat = saveShot(i, &wrShot);
// if(saveStat == EEPROM_OK){
// print("OK");
// } else {
// print("EEPROM_FAIL");
// }
// print(" -> ");
// HAL_Delay(100);
// print(" READ -> ");
// Shot rShoot = {0};
// MemoryStatus status = getShot(i, &rShoot);
// print(" ");
// switch (status) {
// case EEPROM_FAIL:
// print("EEPROM_FAIL");
// break;
// case EEPROM_MISSING_ELEMENT:
// print("EEPROM_MISSING_ELEMENT");
// break;
// case EEPROM_OUT_OF_RANGE:
// print("EEPROM_OUT_OF_RANGE");
// break;
// case EEPROM_WRONG_STARTADDR:
// print("EEPROM_WRONG_STARTADDR");
// break;
// case EEPROM_OK:
// print("EEPROM_OK");
// break;
// default:
// print("???");
// break;
// }
// print(" - > ");
// if(memcmp(&rShoot, &wrShot, sizeof(Shot)) == 0){
// print("OK\n");
// } else {
// print("ERROR !!!!!!!!!!!!!!!!!!!!!\n");
// }
// }
// print("\n");
for (int i = 0; i < MAX_SHOT_COUNT; ++i) {
print("SAVE ");
printNumber(i);
print(" -> ");
MemoryStatus saveStat = saveShot(i, &wrShot);
if(saveStat == EEPROM_OK){
print("OK");
} else {
print("EEPROM_FAIL");
}
print(" -> ");
HAL_Delay(100);
print(" READ -> ");
Shot rShoot = {0};
MemoryStatus status = getShot(i, &rShoot);
print(" ");
switch (status) {
case EEPROM_FAIL:
print("EEPROM_FAIL");
break;
case EEPROM_MISSING_ELEMENT:
print("EEPROM_MISSING_ELEMENT");
break;
case EEPROM_OUT_OF_RANGE:
print("EEPROM_OUT_OF_RANGE");
break;
case EEPROM_WRONG_STARTADDR:
print("EEPROM_WRONG_STARTADDR");
break;
case EEPROM_OK:
print("EEPROM_OK");
break;
default:
print("???");
break;
}
print(" - > ");
if(memcmp(&rShoot, &wrShot, sizeof(Shot)) == 0){
print("OK\n");
} else {
print("ERROR !!!!!!!!!!!!!!!!!!!!!\n");
}
}
print("\n");
//////////////////////////////////////////// ////////////////////////////////////////////
Program wrProg = {0}; Program wrProg = {0};
wrProg.header.countRepeat = 0x11; wrProg.header.countRepeat = 0x11;
wrProg.header.options = 0x22; wrProg.header.options = 0x22;
wrProg.header.shotCount = 0x33; wrProg.header.shotCount = 0x33;
memset(&wrProg.shots, 0x44, sizeof(wrProg.shots)); memset(&wrProg.shots, 0xAA, sizeof(wrProg.shots));
for (int i = 0; i < MAX_PROGRAM_COUNT; ++i) {
print("SAVE PROGRAM ");
printNumber(i);
print(" -> ");
MemoryStatus saveProgStat = saveProg(i, &wrProg);
if (saveProgStat == EEPROM_OK) {
print("OK");
} else {
print("EEPROM_FAIL");
}
print(" -> ");
HAL_Delay(100);
for (int i = 0; i < MAX_PROGRAM_COUNT; ++i){ print(" READ PROGRAM -> ");
Program rdProg = {0};
MemoryStatus status = getProg(i, &rdProg);
print(" ");
switch (status) {
case EEPROM_FAIL:
print("EEPROM_FAIL");
break;
case EEPROM_MISSING_ELEMENT:
print("EEPROM_MISSING_ELEMENT");
break;
case EEPROM_OUT_OF_RANGE:
print("EEPROM_OUT_OF_RANGE");
break;
case EEPROM_WRONG_STARTADDR:
print("EEPROM_WRONG_STARTADDR");
break;
case EEPROM_OK:
print("EEPROM_OK");
break;
default:
print("???");
break;
}
print(" -> ");
if (memcmp(&rdProg, &wrProg, sizeof(Program)) == 0) {
print("OK\n");
} else {
print("ERROR !!!!!!!!!!!!!!!!!!!!!\n");
}
} }
print("\n");
print("\n");
//////////////////////////////////////////// ////////////////////////////////////////////
for (int i = 0; i < MAX_MACRO_COUNT; ++i){
} // Macro wrMacro = {0};
// wrMacro.header.programmCount = 0x55;
// memset(&wrMacro.programs, 0x66, sizeof(wrMacro.programs));
//
// for (int i = 0; i < MAX_MACRO_COUNT; ++i) {
// print("SAVE MACRO ");
// printNumber(i);
// print(" -> ");
// MemoryStatus saveMacroStat = saveMacro(i, &wrMacro);
// if (saveMacroStat == EEPROM_OK) {
// print("OK");
// } else {
// print("EEPROM_FAIL");
// }
// print(" -> ");
// HAL_Delay(100);
//
// print(" READ MACRO -> ");
// Macro rdMacro = {0};
// MemoryStatus status = getMacro(i, &rdMacro);
// print(" ");
// switch (status) {
// case EEPROM_FAIL:
// print("EEPROM_FAIL");
// break;
// case EEPROM_MISSING_ELEMENT:
// print("EEPROM_MISSING_ELEMENT");
// break;
// case EEPROM_OUT_OF_RANGE:
// print("EEPROM_OUT_OF_RANGE");
// break;
// case EEPROM_WRONG_STARTADDR:
// print("EEPROM_WRONG_STARTADDR");
// break;
// case EEPROM_OK:
// print("EEPROM_OK");
// break;
// default:
// print("???");
// break;
// }
// print(" -> ");
// if (memcmp(&rdMacro, &wrMacro, sizeof(Macro)) == 0) {
// print("OK\n");
// } else {
// print("ERROR !!!!!!!!!!!!!!!!!!!!!\n");
// }
// }
// print("\n");
} }
break; break;
@ -320,7 +414,7 @@ void IR_Home_Process() {
break; break;
{ {
uint8_t buf[1024]; // Буфер для чтения данных размером 128 байт uint8_t buf[1024]; // Буфер для чтения данных размером 128 байт
uint16_t blockAddr16 = START_ADR_SHOT; // Начальный адрес EEPROM uint16_t blockAddr16 = START_ADR_PROGRAM; // Начальный адрес EEPROM
uint8_t blockAddr[2] = { (uint8_t) (blockAddr16 >> 8), uint8_t blockAddr[2] = { (uint8_t) (blockAddr16 >> 8),
(uint8_t) (blockAddr16 & 0xFF) }; // Адрес в формате 2 байта (uint8_t) (blockAddr16 & 0xFF) }; // Адрес в формате 2 байта
int max_attempts = 15; // Максимальное количество попыток для операции int max_attempts = 15; // Максимальное количество попыток для операции