EEPROM write fix

Core/Inc/EEPROM.h

@@ -19,7 +19,7 @@
 #define PROGRAM_BLOCKSIZE		67
 #define MAX_PROGRAM_COUNT 	256
 #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 MACRO_BLOCKSIZE			129

Core/Src/EEPROM.c

@@ -188,7 +188,7 @@ MemoryStatus saveProg(unsigned char number, Program *prog) {
 			result = EEPROM_MISSING_ELEMENT;
 		}
 	}
-
+	HAL_IWDG_Refresh(&hiwdg);
 	uint16_t totalSize = sizeof(ProgramHeader)
 			+ sizeof(ProgramShot) * prog->header.shotCount;
 
@@ -295,38 +295,46 @@ MemoryStatus EEPROM_EARSE() {
 MemoryStatus FLASH_WriteBlock(uint16_t startAddr, uint8_t number,
                               uint8_t *writeData, uint16_t dataSize, uint16_t blockSize) {
     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;
     }
 
-	uint16_t blockAddr16 = (uint16_t) (startAddr
+    while (bytesWritten < dataSize) {
-			+ (uint16_t) (number * blockSize));
+        uint16_t chunkSize = (dataSize - bytesWritten > maxWriteSize) ? maxWriteSize : (dataSize - bytesWritten);
+        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));
         Buf[0] = blockAddr[0];
         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);
-//	print("Written ");
-//	printNumber(dataSize);
-//	print(" bytes\n");
         HAL_Delay(1);
+
         if (result != HAL_OK) {
             return EEPROM_FAIL;
         }
+
+        bytesWritten += chunkSize;
+        currentAddr += chunkSize;
+    }
+
     return EEPROM_OK;
 }
 
+
 MemoryStatus FLASH_DelBlock(uint16_t startAddr, uint8_t number,
 		uint16_t dataSize) {
 	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)
 			|| (startAddr == START_ADR_PROGRAM && number > MAX_PROGRAM_COUNT)
 			|| (startAddr == START_ADR_MACRO && number > MAX_MACRO_COUNT)) {
-		print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11");
+//		print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11");
 		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,
 			dataSize, 10);
 
-	print("FLASH_ReadBlock: ");
+//	print("FLASH_ReadBlock: ");
-	printNumber(blockAddr16);
+//	printNumber(blockAddr16);
 //	print("\n");
 
 	HAL_Delay(1);
 	if (result != HAL_OK) {
-		print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11");
+//		print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11");
 		return EEPROM_FAIL;
 	}
 	return EEPROM_OK;

Core/Src/IR_CMD_HandlerLogic.c

@@ -205,39 +205,94 @@ void IR_Home_Process() {
 /////////////////////////////////////////////////////////
 
 	case IR_FONT_RIGHT:
+		break;
 //		for (int i = 0; i <= 100; ++i) {
 //			led_progressbar(0, 19, i);
 //			HAL_Delay(10);
 //		}
 //		led_clear();
-		break;
+//		break;
 	{
 		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 ");
+
+			Program wrProg = {0};
+			wrProg.header.countRepeat = 0x11;
+			wrProg.header.options = 0x22;
+			wrProg.header.shotCount = 0x33;
+			memset(&wrProg.shots, 0xAA, sizeof(wrProg.shots));
+
+			for (int i = 0; i < MAX_PROGRAM_COUNT; ++i) {
+			    print("SAVE PROGRAM ");
 			    printNumber(i);
 			    print(" -> ");
-				MemoryStatus saveStat = saveShot(i, &wrShot);
+			    MemoryStatus saveProgStat = saveProg(i, &wrProg);
-				if(saveStat == EEPROM_OK){
+			    if (saveProgStat == EEPROM_OK) {
 			        print("OK");
 			    } else {
 			        print("EEPROM_FAIL");
 			    }
 			    print(" -> ");
 			    HAL_Delay(100);
-				print(" READ -> ");
+
-				Shot rShoot = {0};
+			    print(" READ PROGRAM -> ");
-				MemoryStatus status = getShot(i, &rShoot);
+			    Program rdProg = {0};
+			    MemoryStatus status = getProg(i, &rdProg);
 			    print(" ");
 			    switch (status) {
 			    case EEPROM_FAIL:
@@ -260,28 +315,67 @@ void IR_Home_Process() {
 			        break;
 			    }
 			    print(" -> ");
-				if(memcmp(&rShoot, &wrShot, sizeof(Shot)) == 0){
+			    if (memcmp(&rdProg, &wrProg, sizeof(Program)) == 0) {
 			        print("OK\n");
 			    } else {
 			        print("ERROR !!!!!!!!!!!!!!!!!!!!!\n");
 			    }
 			}
 			print("\n");
+			print("\n");
+
 			////////////////////////////////////////////
-			Program wrProg = {0};
-			wrProg.header.countRepeat = 0x11;
-			wrProg.header.options = 0x22;
-			wrProg.header.shotCount = 0x33;
-			memset(&wrProg.shots, 0x44, sizeof(wrProg.shots));
 
+//			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");
 
-			for (int i = 0; i < MAX_PROGRAM_COUNT; ++i){
-
-			}
-			////////////////////////////////////////////
-			for (int i = 0; i < MAX_MACRO_COUNT; ++i){
-
-			}
 	}
 		break;
 
@@ -320,7 +414,7 @@ void IR_Home_Process() {
 		break;
 	{
 		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) (blockAddr16 & 0xFF) }; // Адрес в формате 2 байта
 		int max_attempts = 15; // Максимальное количество попыток для операции