From 419c55d807b89caedb76619562a6a7cde3273d2e Mon Sep 17 00:00:00 2001
From: DashyFox <DashyFox@yandex.ru>
Date: Wed, 11 Sep 2024 00:32:41 +0300
Subject: [PATCH] EEPROM and USB CDC

---
 .cproject                      |   2 +-
 Core/Inc/EEPROM.h              |   9 +-
 Core/Src/EEPROM.c              | 389 ++++++++++++++++++++++-----------
 Core/Src/IR_CMD_HandlerLogic.c | 151 +++++--------
 Core/Src/Print.c               |   2 -
 Core/Src/main.c                |   5 +-
 Core/Src/stm32f1xx_it.c        |   2 +
 USB_DEVICE/App/usbd_cdc_if.c   |   1 +
 8 files changed, 336 insertions(+), 225 deletions(-)

diff --git a/.cproject b/.cproject
index 8dd7048..4c0e158 100644
--- a/.cproject
+++ b/.cproject
@@ -36,7 +36,7 @@
 							</tool>
 							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.400718382" name="MCU/MPU GCC Compiler" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler">
 								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.debuglevel.1282773953" name="Debug level" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.debuglevel" useByScannerDiscovery="false" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.debuglevel.value.g3" valueType="enumerated"/>
-								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.optimization.level.394842051" name="Optimization level" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.optimization.level" useByScannerDiscovery="false"/>
+								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.optimization.level.394842051" name="Optimization level" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.optimization.level" useByScannerDiscovery="false" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.optimization.level.value.oz" valueType="enumerated"/>
 								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.definedsymbols.1350178782" name="Define symbols (-D)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.definedsymbols" useByScannerDiscovery="false" valueType="definedSymbols">
 									<listOptionValue builtIn="false" value="DEBUG"/>
 									<listOptionValue builtIn="false" value="USE_HAL_DRIVER"/>
diff --git a/Core/Inc/EEPROM.h b/Core/Inc/EEPROM.h
index 42b4de5..8d47b68 100644
--- a/Core/Inc/EEPROM.h
+++ b/Core/Inc/EEPROM.h
@@ -109,13 +109,18 @@ typedef struct Statistics{
 }Statistics;
 
 typedef struct InfoBlock{
+	char init_uid[11];
 	HardwareInit_t hwInfo;
 	Statistics statInfo;
 }InfoBlock;
 
+extern InfoBlock infoBlock;
 
-MemoryStatus FLASH_WriteBlock(uint16_t startAddr, uint8_t number, uint8_t *writeData, uint8_t dataSize);
-MemoryStatus FLASH_ReadBlock(uint16_t startAddr, uint8_t number, uint8_t *readData, uint8_t dataSize);
+MemoryStatus EEPROM_INIT();
+MemoryStatus EEPROM_EARSE();
+
+MemoryStatus FLASH_WriteBlock(uint16_t startAddr, uint8_t number, uint8_t *writeData, uint16_t dataSize);
+MemoryStatus FLASH_ReadBlock(uint16_t startAddr, uint8_t number, uint8_t *readData, uint16_t dataSize);
 
 
 MemoryStatus saveShot(unsigned char number, Shot *shot);
diff --git a/Core/Src/EEPROM.c b/Core/Src/EEPROM.c
index d7d0a24..c29a6dd 100644
--- a/Core/Src/EEPROM.c
+++ b/Core/Src/EEPROM.c
@@ -2,163 +2,302 @@
 #include "pca9685.h"
 #include "usbd_cdc_if.h"
 #include "Print.h"
+#include "RobotFunctions.h"
+
+InfoBlock infoBlock;
 
-		
 MemoryStatus saveInfoBlock(InfoBlock *infoBlock) {
-    return FLASH_WriteBlock(START_ADR_STAT, 0, (uint8_t *)infoBlock, sizeof(InfoBlock));
+	return FLASH_WriteBlock(START_ADR_STAT, 0, (uint8_t*) infoBlock,
+			sizeof(InfoBlock));
 }
 
 MemoryStatus getInfoBlock(InfoBlock *infoBlock) {
-	MemoryStatus status = FLASH_ReadBlock(START_ADR_STAT, 0, (uint8_t *)infoBlock, sizeof(InfoBlock));
+	MemoryStatus status = FLASH_ReadBlock(START_ADR_STAT, 0,
+			(uint8_t*) infoBlock, sizeof(InfoBlock));
 
-    if (status != EEPROM_OK) {
-        return EEPROM_FAIL;
-    }
+	if (status != EEPROM_OK) {
+		return EEPROM_FAIL;
+	}
 
-    return EEPROM_OK;
+	return EEPROM_OK;
 }
 
-
-MemoryStatus saveShot(unsigned char number, Shot* shot)
-{
-    if (FLASH_WriteBlock(START_ADR_SHOT, number, (uint8_t*)shot, SHOT_BLOCKSIZE) == EEPROM_OK) {
-        return EEPROM_OK;
-    }
-    return EEPROM_FAIL;
+MemoryStatus saveShot(unsigned char number, Shot *shot) {
+	if (FLASH_WriteBlock(START_ADR_SHOT, number, (uint8_t*) shot,
+	SHOT_BLOCKSIZE) == EEPROM_OK) {
+		return EEPROM_OK;
+	}
+	return EEPROM_FAIL;
 }
 
-MemoryStatus getShot(unsigned char number, Shot* shot)
-{
-    if (FLASH_ReadBlock(START_ADR_SHOT, number, (uint8_t*)shot, SHOT_BLOCKSIZE) != EEPROM_OK) {
-        return EEPROM_FAIL;
-    }
-    if (!shot->isExist) {
-        return EEPROM_MISSING_ELEMENT;
-    }
-    return EEPROM_OK;
+MemoryStatus getShot(unsigned char number, Shot *shot) {
+	if (FLASH_ReadBlock(START_ADR_SHOT, number, (uint8_t*) shot, SHOT_BLOCKSIZE)
+			!= EEPROM_OK) {
+		return EEPROM_FAIL;
+	}
+	if (!shot->isExist) {
+		return EEPROM_MISSING_ELEMENT;
+	}
+	return EEPROM_OK;
 }
 
-MemoryStatus saveProg(unsigned char number, Program* prog)
-{
-    MemoryStatus result = EEPROM_OK;
-    for (uint16_t i = 0; i < MAX_NUMBER_SHOTS_IN_PROGRAMS; ++i) {
-        Shot shot;
-        MemoryStatus stat = getShot(prog->shots[i].id, &shot);
-        if (!(stat == EEPROM_OK || stat == EEPROM_MISSING_ELEMENT)) {
-            return EEPROM_FAIL;
-        }
-        if (!shot.isExist) {
-            // todo: добавить в запросы для загрузки снимков
-            result = EEPROM_MISSING_ELEMENT;
-        }
-    }
+MemoryStatus saveProg(unsigned char number, Program *prog) {
+	MemoryStatus result = EEPROM_OK;
+	for (uint16_t i = 0; i < MAX_NUMBER_SHOTS_IN_PROGRAMS; ++i) {
+		Shot shot;
+		MemoryStatus stat = getShot(prog->shots[i].id, &shot);
+		if (!(stat == EEPROM_OK || stat == EEPROM_MISSING_ELEMENT)) {
+			return EEPROM_FAIL;
+		}
+		if (!shot.isExist) {
+			// todo: добавить в запросы для загрузки снимков
+			result = EEPROM_MISSING_ELEMENT;
+		}
+	}
 
-    if (FLASH_WriteBlock(START_ADR_PROGRAM, number, (uint8_t*)prog, PROGRAM_BLOCKSIZE) != EEPROM_OK) {
-        return EEPROM_FAIL;
-    }
-    return result;
+	if (FLASH_WriteBlock(START_ADR_PROGRAM, number, (uint8_t*) prog,
+	PROGRAM_BLOCKSIZE) != EEPROM_OK) {
+		return EEPROM_FAIL;
+	}
+	return result;
 }
 
-MemoryStatus getProg(unsigned char number, Program* prog)
-{
-    if (FLASH_ReadBlock(START_ADR_PROGRAM, number, (uint8_t*)prog, PROGRAM_BLOCKSIZE) != EEPROM_OK) {
-        return EEPROM_FAIL;
-    }
+MemoryStatus getProg(unsigned char number, Program *prog) {
+	if (FLASH_ReadBlock(START_ADR_PROGRAM, number, (uint8_t*) prog,
+	PROGRAM_BLOCKSIZE) != EEPROM_OK) {
+		return EEPROM_FAIL;
+	}
 
-    if (!prog->header.isExist) {
-        return EEPROM_MISSING_ELEMENT;
-    }
+	if (!prog->header.isExist) {
+		return EEPROM_MISSING_ELEMENT;
+	}
 
-    return EEPROM_OK;
+	return EEPROM_OK;
 }
 
-MemoryStatus saveMacro(unsigned char number, Macro* macro)
-{
-    MemoryStatus result = EEPROM_OK;
-    for (uint16_t i = 0; i < MAX_NUMBER_PROGRAMS_IN_MACRO; ++i) {
-        Program prog;
-        MemoryStatus stat = getProg(macro->programs[i].id, &prog);
-        if (!(stat == EEPROM_OK || stat == EEPROM_MISSING_ELEMENT)) {
-            return EEPROM_FAIL;
-        }
-        if (!prog.header.isExist) {
-            result = EEPROM_MISSING_ELEMENT;
-            // todo: добавить в запросы для загрузки программ
-        }
-    }
+MemoryStatus saveMacro(unsigned char number, Macro *macro) {
+	MemoryStatus result = EEPROM_OK;
+	for (uint16_t i = 0; i < MAX_NUMBER_PROGRAMS_IN_MACRO; ++i) {
+		Program prog;
+		MemoryStatus stat = getProg(macro->programs[i].id, &prog);
+		if (!(stat == EEPROM_OK || stat == EEPROM_MISSING_ELEMENT)) {
+			return EEPROM_FAIL;
+		}
+		if (!prog.header.isExist) {
+			result = EEPROM_MISSING_ELEMENT;
+			// todo: добавить в запросы для загрузки программ
+		}
+	}
 
-    if (FLASH_WriteBlock(START_ADR_MACRO, number, (uint8_t*)macro, MACRO_BLOCKSIZE) != EEPROM_OK) {
-        return EEPROM_FAIL;
-    }
+	if (FLASH_WriteBlock(START_ADR_MACRO, number, (uint8_t*) macro,
+	MACRO_BLOCKSIZE) != EEPROM_OK) {
+		return EEPROM_FAIL;
+	}
 
-    return result;
+	return result;
 }
 
+MemoryStatus getMacro(unsigned char number, Macro *macro) {
+	if (FLASH_ReadBlock(START_ADR_MACRO, number, (uint8_t*) macro,
+	MACRO_BLOCKSIZE) != EEPROM_OK) {
+		return EEPROM_FAIL;
+	}
 
-MemoryStatus getMacro(unsigned char number, Macro* macro)
-{
-    if (FLASH_ReadBlock(START_ADR_MACRO, number, (uint8_t*)macro, MACRO_BLOCKSIZE) != EEPROM_OK) {
-        return EEPROM_FAIL;
-    }
-
-    if (!macro->header.isExist) {
-        return EEPROM_MISSING_ELEMENT;
-    }
-    return EEPROM_OK;
+	if (!macro->header.isExist) {
+		return EEPROM_MISSING_ELEMENT;
+	}
+	return EEPROM_OK;
 }
 
+MemoryStatus EEPROM_EARSE() {
+	uint16_t addr = 0;
+	uint16_t old_addr = 0;
+	do {
+		uint8_t Buf[255];
+		memset(Buf, 0xFF, sizeof(Buf));
+		FLASH_WriteBlock(addr, 0, Buf, (uint8_t) sizeof(Buf));
+		old_addr = addr;
+		addr += sizeof(Buf);
+	} while (old_addr <= addr);
 
-MemoryStatus FLASH_WriteBlock(uint16_t startAddr, uint8_t number, uint8_t *writeData, uint8_t dataSize)
-{
-    HAL_StatusTypeDef result;
-
-    // Проверка на корректность входных данных
-    if ((startAddr == START_ADR_SHOT && number > MAX_NUMBER_SHOTS) ||
-        (startAddr == START_ADR_PROGRAM && number > MAX_NUMBER_PROGRAMS) ||
-        (startAddr == START_ADR_MACRO && number > MAX_NUMBER_MACRO)) {
-        return EEPROM_OUT_OF_RANGE;
-    }
-
-    uint16_t blockAddr16 = (uint16_t)(startAddr + (uint16_t)(number * dataSize));
-    uint8_t blockAddr[2] = {HIBYTE(blockAddr16), LOBYTE(blockAddr16)};
-
-    unsigned char Buf[dataSize + 2];
-    memset(Buf, 0x00, sizeof(Buf));
-    Buf[0] = blockAddr[0];
-    Buf[1] = blockAddr[1];
-
-    for (unsigned char i = 0; i < dataSize; i++) Buf[i + 2] = writeData[i];
-
-    result = HAL_I2C_Master_Transmit(&hi2c1, (AT24C_ADRESS << 1), Buf, (dataSize + 2), 10);
-    HAL_Delay(1);
-    if(result != HAL_OK){
-    	return EEPROM_FAIL;
-    }
-    return EEPROM_OK;
+	return EEPROM_OK;
 }
 
-MemoryStatus FLASH_ReadBlock(uint16_t startAddr, uint8_t number, uint8_t *readData, uint8_t dataSize)
-{
-    HAL_StatusTypeDef result;
+MemoryStatus EEPROM_INIT() {
+	MemoryStatus status = getInfoBlock(&infoBlock);
+	if (status != EEPROM_OK) {
+		char errorMsg[] = "Error reading InfoBlock from EEPROM\n";
+		CDC_Transmit_FS((uint8_t*) errorMsg, strlen(errorMsg));
+		return status;
+	}
+	char uid_ref[11] = "Stack_Sport";
+	if (memcmp(&(infoBlock.init_uid), &uid_ref, 11) != 0) {
+		char errorMsg[] = "uid non equal\n\n";
+		CDC_Transmit_FS((uint8_t*) errorMsg, strlen(errorMsg));
 
-    // Проверка на корректность входных данных
-    if ((startAddr == START_ADR_SHOT && number > MAX_NUMBER_SHOTS) ||
-        (startAddr == START_ADR_PROGRAM && number > MAX_NUMBER_PROGRAMS) ||
-        (startAddr == START_ADR_MACRO && number > MAX_NUMBER_MACRO)) {
-        return EEPROM_OUT_OF_RANGE;
-    }
+		EEPROM_EARSE();
 
-    memset(readData, 0x00, dataSize);
+		memset(&infoBlock, 0x00, sizeof(InfoBlock));
+		char uid[] = "Stack_Sport";
+		memcpy(infoBlock.init_uid, uid, 11);
 
-    uint16_t blockAddr16 = (uint16_t)(startAddr + (uint16_t)(number * dataSize));
-    uint8_t blockAddr[2] = {HIBYTE(blockAddr16), LOBYTE(blockAddr16)};
+		infoBlock.hwInfo.timings.preRun = 3500;
 
-    result = HAL_I2C_Master_Transmit(&hi2c1, (AT24C_ADRESS << 1), blockAddr, 2, 10);
-    HAL_Delay(1);
-    result = HAL_I2C_Master_Receive(&hi2c1, (AT24C_ADRESS << 1) | 1, readData, dataSize, 10);
-    HAL_Delay(1);
-    if(result != HAL_OK){
-    	return EEPROM_FAIL;
-    }
-    return EEPROM_OK;
+		infoBlock.hwInfo.motors.speed_Rollers_min = 0;
+		infoBlock.hwInfo.motors.speed_Screw_min = 0;
+
+		infoBlock.hwInfo.servos[SERVO_AXIAL].invert = 0;
+		infoBlock.hwInfo.servos[SERVO_AXIAL].min = 0;
+		infoBlock.hwInfo.servos[SERVO_AXIAL].def = 90;
+		infoBlock.hwInfo.servos[SERVO_AXIAL].max = 180;
+
+		infoBlock.hwInfo.servos[SERVO_HORIZONTAL].invert = 0;
+		infoBlock.hwInfo.servos[SERVO_HORIZONTAL].min = 0;
+		infoBlock.hwInfo.servos[SERVO_HORIZONTAL].def = 90;
+		infoBlock.hwInfo.servos[SERVO_HORIZONTAL].max = 180;
+
+		infoBlock.hwInfo.servos[SERVO_VERTICAL].invert = 0;
+		infoBlock.hwInfo.servos[SERVO_VERTICAL].min = 0;
+		infoBlock.hwInfo.servos[SERVO_VERTICAL].def = 90;
+		infoBlock.hwInfo.servos[SERVO_VERTICAL].max = 180;
+
+		infoBlock.statInfo.totalShots = 0;
+		infoBlock.statInfo.totalPrograms = 0;
+		infoBlock.statInfo.totalMacros = 0;
+
+		status = saveInfoBlock(&infoBlock);
+		if (status != EEPROM_OK) {
+			char errorMsg[] = "EEPROM FAIL\n";
+			CDC_Transmit_FS((uint8_t*) errorMsg, strlen(errorMsg));
+			return status;
+		}
+		status = getInfoBlock(&infoBlock);
+
+		if (status != EEPROM_OK) {
+			char errorMsg[] = "Error reading InfoBlock from EEPROM\n";
+			CDC_Transmit_FS((uint8_t*) errorMsg, strlen(errorMsg));
+			return status;
+		}
+	}
+
+	// Буфер для строки вывода
+	char buffer[128];
+
+	// Вывод информации о HardwareInit_t
+	snprintf(buffer, sizeof(buffer), "Hardware Initialization:\n");
+	CDC_Transmit_FS((uint8_t*) buffer, strlen(buffer));
+
+	char char_tmp[12];
+	memcpy(char_tmp, infoBlock.init_uid, 11);
+	char_tmp[11] = '\0';
+	snprintf(buffer, sizeof(buffer), "init_uid: %s\n", char_tmp);
+	CDC_Transmit_FS((uint8_t*) buffer, strlen(buffer));
+
+	snprintf(buffer, sizeof(buffer),
+			"Servo 1: Invert=%u, Min=%u, Default=%u, Max=%u\n",
+			infoBlock.hwInfo.servos[0].invert, infoBlock.hwInfo.servos[0].min,
+			infoBlock.hwInfo.servos[0].def, infoBlock.hwInfo.servos[0].max);
+	CDC_Transmit_FS((uint8_t*) buffer, strlen(buffer));
+
+	snprintf(buffer, sizeof(buffer),
+			"Servo 2: Invert=%u, Min=%u, Default=%u, Max=%u\n",
+			infoBlock.hwInfo.servos[1].invert, infoBlock.hwInfo.servos[1].min,
+			infoBlock.hwInfo.servos[1].def, infoBlock.hwInfo.servos[1].max);
+	CDC_Transmit_FS((uint8_t*) buffer, strlen(buffer));
+
+	snprintf(buffer, sizeof(buffer),
+			"Servo 3: Invert=%u, Min=%u, Default=%u, Max=%u\n",
+			infoBlock.hwInfo.servos[2].invert, infoBlock.hwInfo.servos[2].min,
+			infoBlock.hwInfo.servos[2].def, infoBlock.hwInfo.servos[2].max);
+	CDC_Transmit_FS((uint8_t*) buffer, strlen(buffer));
+
+	snprintf(buffer, sizeof(buffer),
+			"Motors: Speed_Rollers_Min=%u, Speed_Screw_Min=%u\n",
+			infoBlock.hwInfo.motors.speed_Rollers_min,
+			infoBlock.hwInfo.motors.speed_Screw_min);
+	CDC_Transmit_FS((uint8_t*) buffer, strlen(buffer));
+
+	// Вывод информации о DelayTimes
+	snprintf(buffer, sizeof(buffer), "Timings: PreRun=%u\n",
+			infoBlock.hwInfo.timings.preRun);
+	CDC_Transmit_FS((uint8_t*) buffer, strlen(buffer));
+
+	// Вывод информации о Statistics
+	snprintf(buffer, sizeof(buffer), "Statistics:\n");
+	CDC_Transmit_FS((uint8_t*) buffer, strlen(buffer));
+
+	snprintf(buffer, sizeof(buffer), "Total Shots: %lu\n",
+			infoBlock.statInfo.totalShots);
+	CDC_Transmit_FS((uint8_t*) buffer, strlen(buffer));
+
+	snprintf(buffer, sizeof(buffer), "Total Programs: %lu\n",
+			infoBlock.statInfo.totalPrograms);
+	CDC_Transmit_FS((uint8_t*) buffer, strlen(buffer));
+
+	snprintf(buffer, sizeof(buffer), "Total Macros: %lu\n\n",
+			infoBlock.statInfo.totalMacros);
+	CDC_Transmit_FS((uint8_t*) buffer, strlen(buffer));
+
+	return status;
+}
+
+MemoryStatus FLASH_WriteBlock(uint16_t startAddr, uint8_t number,
+		uint8_t *writeData, uint16_t dataSize) {
+	HAL_StatusTypeDef result;
+
+	// Проверка на корректность входных данных
+	if ((startAddr == START_ADR_SHOT && number > MAX_NUMBER_SHOTS)
+			|| (startAddr == START_ADR_PROGRAM && number > MAX_NUMBER_PROGRAMS)
+			|| (startAddr == START_ADR_MACRO && number > MAX_NUMBER_MACRO)) {
+		return EEPROM_OUT_OF_RANGE;
+	}
+
+	uint16_t blockAddr16 = (uint16_t) (startAddr
+			+ (uint16_t) (number * dataSize));
+	uint8_t blockAddr[2] = { HIBYTE(blockAddr16), LOBYTE(blockAddr16) };
+
+	unsigned char Buf[dataSize + 2];
+	memset(Buf, 0x00, sizeof(Buf));
+	Buf[0] = blockAddr[0];
+	Buf[1] = blockAddr[1];
+
+	for (unsigned char i = 0; i < dataSize; i++)
+		Buf[i + 2] = writeData[i];
+
+	result = HAL_I2C_Master_Transmit(&hi2c1, (AT24C_ADRESS << 1), Buf,
+			(dataSize + 2), 10);
+	HAL_Delay(1);
+	if (result != HAL_OK) {
+		return EEPROM_FAIL;
+	}
+	return EEPROM_OK;
+}
+
+MemoryStatus FLASH_ReadBlock(uint16_t startAddr, uint8_t number,
+		uint8_t *readData, uint16_t dataSize) {
+	HAL_StatusTypeDef result;
+
+	// Проверка на корректность входных данных
+	if ((startAddr == START_ADR_SHOT && number > MAX_NUMBER_SHOTS)
+			|| (startAddr == START_ADR_PROGRAM && number > MAX_NUMBER_PROGRAMS)
+			|| (startAddr == START_ADR_MACRO && number > MAX_NUMBER_MACRO)) {
+		return EEPROM_OUT_OF_RANGE;
+	}
+
+	memset(readData, 0x00, dataSize);
+
+	uint16_t blockAddr16 = (uint16_t) (startAddr
+			+ (uint16_t) (number * dataSize));
+	uint8_t blockAddr[2] = { HIBYTE(blockAddr16), LOBYTE(blockAddr16) };
+
+	result = HAL_I2C_Master_Transmit(&hi2c1, (AT24C_ADRESS << 1), blockAddr, 2,
+			10);
+	HAL_Delay(1);
+	result = HAL_I2C_Master_Receive(&hi2c1, (AT24C_ADRESS << 1) | 1, readData,
+			dataSize, 10);
+	HAL_Delay(1);
+	if (result != HAL_OK) {
+		return EEPROM_FAIL;
+	}
+	return EEPROM_OK;
 }
diff --git a/Core/Src/IR_CMD_HandlerLogic.c b/Core/Src/IR_CMD_HandlerLogic.c
index 84ed680..ef00fef 100644
--- a/Core/Src/IR_CMD_HandlerLogic.c
+++ b/Core/Src/IR_CMD_HandlerLogic.c
@@ -73,109 +73,72 @@ void IR_Home_Process() {
 		break;
 
 	case IR_F_BTN: {
-	    InfoBlock infoBlock;
-
-	    // Чтение структуры InfoBlock из EEPROM
-	    MemoryStatus status = getInfoBlock(&infoBlock);
-	    if (status != EEPROM_OK) {
-	        char errorMsg[] = "Error reading InfoBlock from EEPROM\n";
-	        CDC_Transmit_FS((uint8_t*)errorMsg, strlen(errorMsg));
-	        break;
-	    }
-
-	    // Буфер для строки вывода
-	    char buffer[128];
-
-	    // Вывод информации о HardwareInit_t
-	    snprintf(buffer, sizeof(buffer), "Hardware Initialization:\n");
-	    CDC_Transmit_FS((uint8_t*)buffer, strlen(buffer));
-
-	    snprintf(buffer, sizeof(buffer), "Servo 1: Invert=%u, Min=%u, Default=%u, Max=%u\n",
-	             infoBlock.hwInfo.servos[0].invert, infoBlock.hwInfo.servos[0].min,
-	             infoBlock.hwInfo.servos[0].def, infoBlock.hwInfo.servos[0].max);
-	    CDC_Transmit_FS((uint8_t*)buffer, strlen(buffer));
-
-	    snprintf(buffer, sizeof(buffer), "Servo 2: Invert=%u, Min=%u, Default=%u, Max=%u\n",
-	             infoBlock.hwInfo.servos[1].invert, infoBlock.hwInfo.servos[1].min,
-	             infoBlock.hwInfo.servos[1].def, infoBlock.hwInfo.servos[1].max);
-	    CDC_Transmit_FS((uint8_t*)buffer, strlen(buffer));
-
-	    snprintf(buffer, sizeof(buffer), "Servo 3: Invert=%u, Min=%u, Default=%u, Max=%u\n",
-	             infoBlock.hwInfo.servos[2].invert, infoBlock.hwInfo.servos[2].min,
-	             infoBlock.hwInfo.servos[2].def, infoBlock.hwInfo.servos[2].max);
-	    CDC_Transmit_FS((uint8_t*)buffer, strlen(buffer));
-
-	    snprintf(buffer, sizeof(buffer), "Motors: Speed_Rollers_Min=%u, Speed_Screw_Min=%u\n",
-	             infoBlock.hwInfo.motors.speed_Rollers_min, infoBlock.hwInfo.motors.speed_Screw_min);
-	    CDC_Transmit_FS((uint8_t*)buffer, strlen(buffer));
-
-	    // Вывод информации о DelayTimes
-	    snprintf(buffer, sizeof(buffer), "Timings: PreRun=%u\n", infoBlock.hwInfo.timings.preRun);
-	    CDC_Transmit_FS((uint8_t*)buffer, strlen(buffer));
-
-	    // Вывод информации о Statistics
-	    snprintf(buffer, sizeof(buffer), "Statistics:\n");
-	    CDC_Transmit_FS((uint8_t*)buffer, strlen(buffer));
-
-	    snprintf(buffer, sizeof(buffer), "Total Shots: %lu\n", infoBlock.statInfo.totalShots);
-	    CDC_Transmit_FS((uint8_t*)buffer, strlen(buffer));
-
-	    snprintf(buffer, sizeof(buffer), "Total Programs: %lu\n", infoBlock.statInfo.totalPrograms);
-	    CDC_Transmit_FS((uint8_t*)buffer, strlen(buffer));
-
-	    snprintf(buffer, sizeof(buffer), "Total Macros: %lu\n", infoBlock.statInfo.totalMacros);
-	    CDC_Transmit_FS((uint8_t*)buffer, strlen(buffer));
-
-	    break;
+		EEPROM_INIT();
 	}
+		break;
 
+	case IR_PAUSE: {
+		uint8_t buf[1024];  // Буфер для чтения данных размером 128 байт
+		uint16_t blockAddr16 = 0; // Начальный адрес EEPROM
+		uint8_t blockAddr[2] = { (uint8_t) (blockAddr16 >> 8),
+				(uint8_t) (blockAddr16 & 0xFF) }; // Адрес в формате 2 байта
+		int max_attempts = 15; // Максимальное количество попыток для операции
+		int attempts = 0; // Счетчик попыток
+		HAL_StatusTypeDef status;
 
-	case IR_PAUSE:
-	{
-	    uint8_t buf[8];  // Буфер для чтения данных размером 128 байт
-	    uint16_t blockAddr16 = 0; // Начальный адрес EEPROM
-	    uint8_t blockAddr[2] = { (uint8_t)(blockAddr16 >> 8), (uint8_t)(blockAddr16 & 0xFF) }; // Адрес в формате 2 байта
-	    int max_attempts = 15; // Максимальное количество попыток для операции
-	    int attempts = 0; // Счетчик попыток
-	    HAL_StatusTypeDef status;
+		do {
+			// Отправляем адрес в EEPROM
+			status = HAL_I2C_Master_Transmit(&hi2c1, (AT24C_ADRESS << 1),
+					blockAddr, 2, 1000);
+			if (status != HAL_OK) {
+				HAL_Delay(1); // Задержка перед повтором
+				attempts++;
+				continue; // Переход к следующей попытке
+			}
 
-	    do {
-	        // Отправляем адрес в EEPROM
-	        status = HAL_I2C_Master_Transmit(&hi2c1, (AT24C_ADRESS << 1), blockAddr, 2, 1000);
-	        if (status != HAL_OK) {
-	            HAL_Delay(5); // Задержка перед повтором
-	            attempts++;
-	            continue; // Переход к следующей попытке
-	        }
+			HAL_Delay(1); // Небольшая задержка
 
-	        HAL_Delay(5); // Небольшая задержка
+			// Читаем 128 байт данных из EEPROM
+			status = HAL_I2C_Master_Receive(&hi2c1, (AT24C_ADRESS << 1) | 1,
+					buf, sizeof(buf), 1000);
+			if (status == HAL_OK) {
+				// Данные успешно считаны, выводим их
+				char buffer[16];
+				for (int i = 0; i < sizeof(buf); ++i) {
+					if (i % 8 == 0)
+						print(" ");
+					if (i % 32 == 0)
+						print("\n");
 
-	        // Читаем 128 байт данных из EEPROM
-	        status = HAL_I2C_Master_Receive(&hi2c1, (AT24C_ADRESS << 1) | 1, buf, sizeof(buf), 1000);
-	        if (status == HAL_OK) {
-	            // Данные успешно считаны, выводим их
-	            char buffer[16];
-	            for (int i = 0; i < sizeof(buf); ++i) {
-	                if (i % 8 == 0) print(" ");
-	                if (i % 32 == 0) print("\n");
+					snprintf(buffer, sizeof(buffer), "%02X ", buf[i]); // Преобразуем байт в шестнадцатеричную строку
+					CDC_Transmit_FS((uint8_t*) buffer, strlen(buffer));
+				}
+				break; // Выход из попыток, если чтение успешно
+			} else {
+				print("Read Error EEPROM\n");
+				HAL_Delay(1); // Задержка перед повтором
+				attempts++;
+			}
+		} while (attempts < max_attempts);
 
-	                snprintf(buffer, sizeof(buffer), "%02X ", buf[i]);  // Преобразуем байт в шестнадцатеричную строку
-	                CDC_Transmit_FS((uint8_t*)buffer, strlen(buffer));
-	            }
-	            break; // Выход из попыток, если чтение успешно
-	        } else {
-	            print("Read Error EEPROM\n");
-	            HAL_Delay(5); // Задержка перед повтором
-	            attempts++;
-	        }
-	    } while (attempts < max_attempts);
-
-	    if (status != HAL_OK) {
-	        print("Failed to read EEPROM after multiple attempts\n");
-	    }
+		if (status != HAL_OK) {
+			print("Failed to read EEPROM after multiple attempts\n");
+		}
+		print("\n\n\n");
 	}
-	break;
+		break;
 
+	case IR_ESC: {
+
+		if (EEPROM_EARSE() != EEPROM_OK) {
+			char errorMsg[] = "Error EEPROM_EARSE\n\n";
+			CDC_Transmit_FS((uint8_t*) errorMsg, strlen(errorMsg));
+		} else {
+			char doneMsg[] = "EEPROM_EARSE Done\n\n";
+			CDC_Transmit_FS((uint8_t*) doneMsg, strlen(doneMsg));
+		}
+	}
+		break;
 
 	case IR_DEBUG: {
 		uint8_t i2c_address;
diff --git a/Core/Src/Print.c b/Core/Src/Print.c
index 6c0b0da..7fae9d8 100644
--- a/Core/Src/Print.c
+++ b/Core/Src/Print.c
@@ -13,7 +13,6 @@ void print(char* str){
 		size++;
 	}
 	CDC_Transmit_FS((unsigned char*)str, size);
-	HAL_Delay(1);
 }
 
 void int_to_str(int number, char *str, int base)
@@ -56,5 +55,4 @@ void printNumber(long int number)
 
     // Отправка строки через USB CDC
     CDC_Transmit_FS((uint8_t*)buffer, strlen(buffer));
-    HAL_Delay(1);
 }
diff --git a/Core/Src/main.c b/Core/Src/main.c
index ce30ece..2eca5ea 100644
--- a/Core/Src/main.c
+++ b/Core/Src/main.c
@@ -176,11 +176,11 @@ int main(void)
 	
 	// BufShots[1] = GetShot(0);
 
-initcomlete = 1;
 
 	 Shiftreg[0] = 0x00; Shiftreg[1] = 0x44; Shiftreg[2] = 0x00; SetShiftReg(Shiftreg); HAL_Delay(10);
 	 Shiftreg[0] = 0x00; Shiftreg[1] = 0x66; Shiftreg[2] = 0x00; SetShiftReg(Shiftreg); HAL_Delay(10);
 	 Shiftreg[0] = 0x00; Shiftreg[1] = 0x77; Shiftreg[2] = 0x00; SetShiftReg(Shiftreg); HAL_Delay(10);
+	 EEPROM_INIT();
 	 Shiftreg[0] = 0x01; Shiftreg[1] = 0x77; Shiftreg[2] = 0x01; SetShiftReg(Shiftreg); HAL_Delay(10);
 	 Shiftreg[0] = 0x03; Shiftreg[1] = 0x77; Shiftreg[2] = 0x03; SetShiftReg(Shiftreg); HAL_Delay(10);
 	 Shiftreg[0] = 0x07; Shiftreg[1] = 0x77; Shiftreg[2] = 0x07; SetShiftReg(Shiftreg); HAL_Delay(10);
@@ -190,6 +190,7 @@ initcomlete = 1;
 	 Shiftreg[0] = 0x7F; Shiftreg[1] = 0x77; Shiftreg[2] = 0x7F; SetShiftReg(Shiftreg); HAL_Delay(10);
 	 Shiftreg[0] = 0x00; Shiftreg[1] = 0x00; Shiftreg[2] = 0x00; SetShiftReg(Shiftreg); HAL_Delay(10);
 	
+initcomlete = 1;
 	
 	
   HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_1);     // ������ �� ������ 1 �6 ������ ��� ��������� �� PA0 PA1
@@ -203,6 +204,8 @@ initcomlete = 1;
   /* Infinite loop */
   /* USER CODE BEGIN WHILE */
 
+
+
   Shot testShot;
   memset(&testShot, 0x00, sizeof(Shot));
   getShot(3, &testShot);
diff --git a/Core/Src/stm32f1xx_it.c b/Core/Src/stm32f1xx_it.c
index 3e07762..719ad2d 100644
--- a/Core/Src/stm32f1xx_it.c
+++ b/Core/Src/stm32f1xx_it.c
@@ -570,6 +570,8 @@ void TIM3_IRQHandler(void)
   // Обработка переполнения таймера
   if (TIM3->SR & TIM_SR_UIF)
   {
+	  current_capture1 = 0xFFFFFFFF;
+	  current_capture2 = 0xFFFFFFFF;
     // Сброс флага переполнения
     TIM3->SR &= ~TIM_SR_UIF;
   }
diff --git a/USB_DEVICE/App/usbd_cdc_if.c b/USB_DEVICE/App/usbd_cdc_if.c
index 72bfef8..dc235ba 100644
--- a/USB_DEVICE/App/usbd_cdc_if.c
+++ b/USB_DEVICE/App/usbd_cdc_if.c
@@ -286,6 +286,7 @@ uint8_t CDC_Transmit_FS(uint8_t* Buf, uint16_t Len)
   }
   USBD_CDC_SetTxBuffer(&hUsbDeviceFS, Buf, Len);
   result = USBD_CDC_TransmitPacket(&hUsbDeviceFS);
+  while(hcdc->TxState != 0);
   /* USER CODE END 7 */
   return result;
 }