Merge achamaikin/CCSModuleSW30Web upstream with fire alarm retained.

Take upstream board rev2, heater, and project cleanup; preserve fire alarm latch, CMD_FIRE_ALARM, and ESTOP maintenance logic.

Co-authored-by: Cursor <cursoragent@cursor.com>

CHAT_SESSION_CHANGELOG.md

@@ -0,0 +1,133 @@
+# Журнал изменений (сессия чата): `fork/CCSModuleSW30Web`
+
+Документ фиксирует доработки проекта **CCSModuleSW30Web** в ветке/каталоге форка  
+`/Users/colorbass/STM32CubeIDE/workspace_1.12.0/fork/CCSModuleSW30Web`, обсуждавшиеся и вносившиеся в рамках описанной сессии (UART, ADC/DMA, CP, отладка IRQ, оптимизация `-Ofast` для кода из прерываний).
+
+---
+
+## 1. UART и протокол
+
+### 1.1. UART3 (Everest / `serial.c`)
+
+- Таймаут «нет связи с хостом»:** `EVEREST_TIMEOUT_MS` = **5000** мс.
+- Жёсткий реинициал при отсутствии RX:** `UART3_REINIT_TIMEOUT_MS` = **1500** мс (с защитой от слишком частых реинициалов через `uart3_last_reinit_tick`).
+- Расширено логирование путей сброса/ошибок приёма и ошибок HAL для диагностики «таймаут без остановки UART3».
+- Колбэки и вспомогательные функции, вызываемые из контекста прерывания, помечены **`ISR_FAST`** (см. раздел 6):  
+  `CCS_RxEventCallback`, `HAL_UART_ErrorCallback`, `uart3_log_hal_error`, `uart3_arm_rx_or_log`, цепочка разбора пакета (`process_received_packet`, `crc16_ibm`, `expected_payload_len`, `apply_command`).
+
+### 1.2. UART2 / `serial_control.c`
+
+- Отдельная логика **`SC_UART2_Watchdog()`**, вызывается из **`SC_Task()`** (не из IRQ).
+- Константы:
+  - **`SC_UART2_REINIT_TIMEOUT_MS`** = **500** мс — порог для жёсткого реинициала при отсутствии пакетов;
+  - **`SC_UART2_PACKET_TIMEOUT_MS`** = **5000** мс — таймаут коммуникации.
+- Сценарий **новый пакет при `BUSY_TX`**: при необходимости **`Abort_IT`**, сброс направления RS-485, затем повторная инициализация UART и приём `ReceiveToIdle_IT` (защита от обрыва TX из-за агрессивного watchdog).
+- Отдельная ветка **жёсткого реинициала при `BUSY_TX`** с логом `USART2 BUSY_TX: hard reinit` (отслеживание `sc_uart2_last_busy_tx_reinit_packet_tick`).
+- HAL-колбэки **`HAL_UARTEx_RxEventCallback`**, **`HAL_UART_TxCpltCallback`** помечены **`ISR_FAST`**.
+
+### 1.3. `SC_SendPacket` и стек CRC/кодирования
+
+- Для единообразной оптимизации пути «IRQ → ответ» на функции **`calculate_crc32`**, **`encode_packet`**, **`parse_packet`**, **`process_received_packet`** и публичную **`SC_SendPacket`** добавлен **`ISR_FAST`**.
+- В **`Core/Inc/serial_control.h`**: подключение **`isr_opt.h`**, прототип **`ISR_FAST void SC_SendPacket(...)`** (согласованность с определением в `.c`).
+
+**Замечание:** `SC_SendPacket` вызывается и из основного потока; для GCC вся функция компилируется с `-Ofast`. При необходимости строгого разделения можно вынести отдельную версию «только из IRQ».
+
+---
+
+## 2. Отладочные линии DBG в `stm32f1xx_it.c`
+
+На время входа/выхода из выбранных обработчиков прерываний поднимается/опускается соответствующий GPIO — удобно для осциллографа (длительность IRQ).
+
+| Линия | Обработчик |
+|--------|------------|
+| **DBG1** | `UART5_IRQHandler` |
+| **DBG2** | `USART2_IRQHandler` |
+| **DBG3** | `USART3_IRQHandler` |
+| **DBG4** | `DMA1_Channel1_IRQHandler`, `ADC1_2_IRQHandler`, `TIM3_IRQHandler` |
+| **DBG5** | `CAN1_RX0_IRQHandler`, `CAN2_TX_IRQHandler`, `CAN2_RX1_IRQHandler` |
+| — | `USART1_IRQHandler` — без обёртки DBG (по согласованию) |
+
+В **`DMA1_Channel1_IRQHandler`** вызывается **`HAL_DMA_IRQHandler(&hdma_adc1)`** для цепочки ADC+DMA.
+
+Для всего файла **`stm32f1xx_it.c`** под GCC добавлено:
+
+```c
+#pragma GCC optimize("Ofast")
+```
+
+(в блоке `USER CODE BEGIN Includes`).
+
+---
+
+## 3. ADC: DMA, глобальные данные, колбэк
+
+- Файлы **`adc.c` / `adc.h`**: структура **`ADC_ScanData_t`**, глобально **`volatile ADC_ScanData_t adc_data`** с полями сырых каналов (`in3_raw`, `cp_raw`, `ntc1_raw`, `ntc2_raw`, `temp_sensor_raw`, `vrefint_raw` и т.д. по фактическому объявлению в заголовке).
+- **`HAL_ADC_ConvCpltCallback`**: копирование из буфера DMA в **`adc_data`**, помечен **`ISR_FAST`**.
+- Публичная **`ADC_ScanStart()`** — запуск сканирования (после калибровки вызывается из инициализации платы).
+- **`board.c`**: после **`HAL_ADCEx_Calibration_Start`** вызывается **`ADC_ScanStart()`**; **`CONN_ReadTemp`** читает **`adc_data.ntc1_raw` / `ntc2_raw`** вместо блокирующего опроса ADC.
+
+**Диагностика (из обсуждения):** если не вызываются **`HAL_ADC_ConvCpltCallback`** / **`HAL_DMA_IRQHandler`**, проверять: срабатывание триггера ADC (например, **TIM3 TRGO**), работу TIM3, порядок инициализации DMA/NVIC, срабатывание **`DMA1_Channel1_IRQHandler`**.
+
+---
+
+## 4. CP (`cp.c` / `cp.h`)
+
+- Измерение опоры на **`adc_data.cp_raw`** (и при необходимости **`vrefint_raw`** по текущей реализации в коде).
+- Логика классификации/порогов приведена к варианту, согласованному с основным **CCSModuleSW30Web** (не форк).
+- Сэмпл по таймеру: уход от тяжёлой работы в IRQ OC — использование **`HAL_TIM_OC_Start`** без прерывания по сравнению, обновление напряжения в **`CP_GetVoltage()`** / основном цикле (**`CP_Loop`** опирается на **`CP_GetState()`** и т.п. по фактическому коду).
+
+---
+
+## 5. Отладочный UART (`debug.c`)
+
+При **`#ifndef USE_WEB_INTERFACE`** (или эквивалентной ветке сборки в файле): колбэк **`HAL_UARTEx_RxEventCallback`** и **`debug_rx_interrupt`** помечены **`ISR_FAST`**.
+
+---
+
+## 6. Оптимизация `-Ofast` для кода из прерываний
+
+### 6.1. Макрос `ISR_FAST`
+
+Файл **`Core/Inc/isr_opt.h`**:
+
+- **GCC:** `#define ISR_FAST __attribute__((optimize("Ofast")))`
+- **Иное:** пустой макрос.
+
+### 6.2. Где используется (по состоянию репозитория)
+
+| Файл | Элементы с `ISR_FAST` / pragma |
+|------|--------------------------------|
+| `stm32f1xx_it.c` | `#pragma GCC optimize("Ofast")` на весь файл (GCC) |
+| `adc.c` | `HAL_ADC_ConvCpltCallback` |
+| `serial.c` | `CCS_RxEventCallback`, `HAL_UART_ErrorCallback`, `uart3_log_hal_error`, `uart3_arm_rx_or_log`, `process_received_packet`, `crc16_ibm`, `expected_payload_len`, `apply_command` |
+| `serial_control.c` | `HAL_UARTEx_RxEventCallback`, `HAL_UART_TxCpltCallback`, `calculate_crc32`, `encode_packet`, `parse_packet`, `process_received_packet`, `SC_SendPacket` |
+| `serial_control.h` | прототип `SC_SendPacket` + `#include "isr_opt.h"` |
+| `psu_control.c` | `HAL_CAN_RxFifo1MsgPendingCallback` |
+| `debug.c` | см. раздел 5 |
+
+---
+
+## 7. Ограничения и переносимость
+
+- **`ISR_FAST`** и pragma в **`stm32f1xx_it.c`** рассчитаны на **GCC** (STM32CubeIDE по умолчанию). Для **IAR / ARM Compiler 6** потребуется отдельная стратегия (прагмы/ключи проекта).
+- **`-Ofast`** допускает агрессивные преобразования с плавающей точкой и перестановки, влияющие на строго воспроизводимую арифметику; для критичных вычислений вне IRQ при необходимости ограничивайте область оптимизации.
+
+---
+
+## 8. Затронутые пути (краткий список)
+
+- `Core/Inc/isr_opt.h` — новый/центральный заголовок оптимизации IRQ.
+- `Core/Inc/serial_control.h` — `isr_opt.h`, `ISR_FAST` у `SC_SendPacket`.
+- `Core/Src/stm32f1xx_it.c` — DBG, DMA ADC, pragma `Ofast`.
+- `Core/Src/adc.c`, `Core/Inc/adc.h` — DMA, `adc_data`, `ADC_ScanStart`, колбэк.
+- `Core/Src/board.c` — калибровка, старт скана, температура из `adc_data`.
+- `Core/Src/cp.c`, `Core/Inc/cp.h` — CP и ADC.
+- `Core/Src/serial.c` — UART3, таймауты, логи, `ISR_FAST`.
+- `Core/Src/serial_control.c` — UART2, watchdog, `ISR_FAST`.
+- `Core/Src/psu_control.c` — CAN RX callback.
+- `Core/Src/debug.c` — отладочный UART под условием сборки.
+- `Core/Src/dma.c`, `gpio.c`, `main.h` — по необходимости для DMA1 Ch1 и DBG-пинов.
+
+---
+
+*Документ сгенерирован для фиксации контекста сессии; при дальнейших правках кода имеет смысл обновлять соответствующие разделы вручную.*

Core/Inc/charger_control.h

@@ -47,6 +47,7 @@ typedef enum __attribute__((packed)){
 	CONN_ERR_HOTPLUG = 8, // Коннектор неожиданно отключился
 	CONN_ERR_EV_COMM = 9, // Ошибка протокола связи с электромобилем
 	CONN_ERR_PSU_FAULT = 10, // Ошибка PSU
+	CONN_ERR_FIRE_ALARM = 11, // Пожарная тревога (до перезагрузки)
 
 }CONN_Error_t;
 

Core/Inc/fire_alarm.h

@@ -0,0 +1,11 @@
+#ifndef INC_FIRE_ALARM_H_
+#define INC_FIRE_ALARM_H_
+
+#include <stdint.h>
+
+uint8_t FireAlarm_IsLatched(void);
+uint8_t FireAlarm_IsBlockingCommand(uint8_t command_code);
+void FireAlarm_Activate(void);
+void FireAlarm_Maintain(void);
+
+#endif /* INC_FIRE_ALARM_H_ */

Core/Inc/main.h

@@ -27,7 +27,7 @@ extern "C" {
 /* USER CODE BEGIN EC */
 #define FW_VERSION_MAJOR 1
 #define FW_VERSION_MINOR 0
-#define FW_VERSION_PATCH 17
+#define FW_VERSION_PATCH 18
 /* USER CODE END EC */
 
 /* Exported macro ------------------------------------------------------------*/

Core/Inc/serial_control.h

@@ -25,6 +25,8 @@
 
 // Перезагрузка для входа в бутлоадер
 #define CMD_DEVICE_RESET		0xB5
+// Пожарная тревога (внешний триггер)
+#define CMD_FIRE_ALARM			0xB7
 
 // Коды ответов
 #define RESP_SUCCESS    		0x12

Core/Src/adc.c

@@ -1,218 +1,218 @@
-/* USER CODE BEGIN Header */
+/* USER CODE BEGIN Header */
-
+
-/* USER CODE END Header */
+/* USER CODE END Header */
-/* Includes ------------------------------------------------------------------*/
+/* Includes ------------------------------------------------------------------*/
-#include "adc.h"
+#include "adc.h"
-
+
-/* USER CODE BEGIN 0 */
+/* USER CODE BEGIN 0 */
-#include "isr_opt.h"
+#include "isr_opt.h"
-static volatile uint16_t adc_dma_raw[6];
+static volatile uint16_t adc_dma_raw[6];
-volatile ADC_ScanData_t adc_data = {0};
+volatile ADC_ScanData_t adc_data = {0};
-static volatile uint8_t adc_scan_data_ready = 0u;
+static volatile uint8_t adc_scan_data_ready = 0u;
-
+
-void ADC_ScanStart(void)
+void ADC_ScanStart(void)
-{
+{
-  if (HAL_ADC_Start_DMA(&hadc1, (uint32_t *)adc_dma_raw, 6u) != HAL_OK)
+  if (HAL_ADC_Start_DMA(&hadc1, (uint32_t *)adc_dma_raw, 6u) != HAL_OK)
-  {
+  {
-    Error_Handler();
+    Error_Handler();
-  }
+  }
-}
+}
-
+
-ISR_FAST void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc)
+ISR_FAST void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc)
-{
+{
-  if (hadc->Instance != ADC1)
+  if (hadc->Instance != ADC1)
-  {
+  {
-    return;
+    return;
-  }
+  }
-
+
-  adc_data.in3_raw = adc_dma_raw[0];
+  adc_data.in3_raw = adc_dma_raw[0];
-  adc_data.cp_raw = adc_dma_raw[1];
+  adc_data.cp_raw = adc_dma_raw[1];
-  adc_data.ntc1_raw = adc_dma_raw[2];
+  adc_data.ntc1_raw = adc_dma_raw[2];
-  adc_data.ntc2_raw = adc_dma_raw[3];
+  adc_data.ntc2_raw = adc_dma_raw[3];
-  adc_data.temp_sensor_raw = adc_dma_raw[4];
+  adc_data.temp_sensor_raw = adc_dma_raw[4];
-  adc_data.vrefint_raw = adc_dma_raw[5];
+  adc_data.vrefint_raw = adc_dma_raw[5];
-  adc_scan_data_ready = 1u;
+  adc_scan_data_ready = 1u;
-}
+}
-
+
-/* USER CODE END 0 */
+/* USER CODE END 0 */
-
+
-ADC_HandleTypeDef hadc1;
+ADC_HandleTypeDef hadc1;
-DMA_HandleTypeDef hdma_adc1;
+DMA_HandleTypeDef hdma_adc1;
-
+
-/* ADC1 init function */
+/* ADC1 init function */
-void MX_ADC1_Init(void)
+void MX_ADC1_Init(void)
-{
+{
-
+
-  /* USER CODE BEGIN ADC1_Init 0 */
+  /* USER CODE BEGIN ADC1_Init 0 */
-
+
-  /* USER CODE END ADC1_Init 0 */
+  /* USER CODE END ADC1_Init 0 */
-
+
-  ADC_ChannelConfTypeDef sConfig = {0};
+  ADC_ChannelConfTypeDef sConfig = {0};
-
+
-  /* USER CODE BEGIN ADC1_Init 1 */
+  /* USER CODE BEGIN ADC1_Init 1 */
-
+
-  /* USER CODE END ADC1_Init 1 */
+  /* USER CODE END ADC1_Init 1 */
-
+
-  /** Common config
+  /** Common config
-  */
+  */
-  hadc1.Instance = ADC1;
+  hadc1.Instance = ADC1;
-  hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
+  hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
-  hadc1.Init.ContinuousConvMode = DISABLE;
+  hadc1.Init.ContinuousConvMode = DISABLE;
-  hadc1.Init.DiscontinuousConvMode = DISABLE;
+  hadc1.Init.DiscontinuousConvMode = DISABLE;
-  hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T3_TRGO;
+  hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T3_TRGO;
-  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
+  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
-  hadc1.Init.NbrOfConversion = 6;
+  hadc1.Init.NbrOfConversion = 6;
-  if (HAL_ADC_Init(&hadc1) != HAL_OK)
+  if (HAL_ADC_Init(&hadc1) != HAL_OK)
-  {
+  {
-    Error_Handler();
+    Error_Handler();
-  }
+  }
-
+
-  /** Configure Regular Channel
+  /** Configure Regular Channel
-  */
+  */
-  sConfig.Channel = ADC_CHANNEL_3;
+  sConfig.Channel = ADC_CHANNEL_3;
-  sConfig.Rank = ADC_REGULAR_RANK_1;
+  sConfig.Rank = ADC_REGULAR_RANK_1;
-  sConfig.SamplingTime = ADC_SAMPLETIME_41CYCLES_5;
+  sConfig.SamplingTime = ADC_SAMPLETIME_41CYCLES_5;
-  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
+  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
-  {
+  {
-    Error_Handler();
+    Error_Handler();
-  }
+  }
-
+
-  /** Configure Regular Channel
+  /** Configure Regular Channel
-  */
+  */
-  sConfig.Channel = ADC_CHANNEL_4;
+  sConfig.Channel = ADC_CHANNEL_4;
-  sConfig.Rank = ADC_REGULAR_RANK_2;
+  sConfig.Rank = ADC_REGULAR_RANK_2;
-  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
+  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
-  {
+  {
-    Error_Handler();
+    Error_Handler();
-  }
+  }
-
+
-  /** Configure Regular Channel
+  /** Configure Regular Channel
-  */
+  */
-  sConfig.Channel = ADC_CHANNEL_8;
+  sConfig.Channel = ADC_CHANNEL_8;
-  sConfig.Rank = ADC_REGULAR_RANK_3;
+  sConfig.Rank = ADC_REGULAR_RANK_3;
-  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
+  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
-  {
+  {
-    Error_Handler();
+    Error_Handler();
-  }
+  }
-
+
-  /** Configure Regular Channel
+  /** Configure Regular Channel
-  */
+  */
-  sConfig.Channel = ADC_CHANNEL_9;
+  sConfig.Channel = ADC_CHANNEL_9;
-  sConfig.Rank = ADC_REGULAR_RANK_4;
+  sConfig.Rank = ADC_REGULAR_RANK_4;
-  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
+  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
-  {
+  {
-    Error_Handler();
+    Error_Handler();
-  }
+  }
-
+
-  /** Configure Regular Channel
+  /** Configure Regular Channel
-  */
+  */
-  sConfig.Channel = ADC_CHANNEL_TEMPSENSOR;
+  sConfig.Channel = ADC_CHANNEL_TEMPSENSOR;
-  sConfig.Rank = ADC_REGULAR_RANK_5;
+  sConfig.Rank = ADC_REGULAR_RANK_5;
-  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
+  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
-  {
+  {
-    Error_Handler();
+    Error_Handler();
-  }
+  }
-
+
-  /** Configure Regular Channel
+  /** Configure Regular Channel
-  */
+  */
-  sConfig.Channel = ADC_CHANNEL_VREFINT;
+  sConfig.Channel = ADC_CHANNEL_VREFINT;
-  sConfig.Rank = ADC_REGULAR_RANK_6;
+  sConfig.Rank = ADC_REGULAR_RANK_6;
-  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
+  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
-  {
+  {
-    Error_Handler();
+    Error_Handler();
-  }
+  }
-  /* USER CODE BEGIN ADC1_Init 2 */
+  /* USER CODE BEGIN ADC1_Init 2 */
-
+
-  /* USER CODE END ADC1_Init 2 */
+  /* USER CODE END ADC1_Init 2 */
-
+
-}
+}
-
+
-void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle)
+void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle)
-{
+{
-
+
-  GPIO_InitTypeDef GPIO_InitStruct = {0};
+  GPIO_InitTypeDef GPIO_InitStruct = {0};
-  if(adcHandle->Instance==ADC1)
+  if(adcHandle->Instance==ADC1)
-  {
+  {
-  /* USER CODE BEGIN ADC1_MspInit 0 */
+  /* USER CODE BEGIN ADC1_MspInit 0 */
-
+
-  /* USER CODE END ADC1_MspInit 0 */
+  /* USER CODE END ADC1_MspInit 0 */
-    /* ADC1 clock enable */
+    /* ADC1 clock enable */
-    __HAL_RCC_ADC1_CLK_ENABLE();
+    __HAL_RCC_ADC1_CLK_ENABLE();
-
+
-    __HAL_RCC_GPIOA_CLK_ENABLE();
+    __HAL_RCC_GPIOA_CLK_ENABLE();
-    __HAL_RCC_GPIOB_CLK_ENABLE();
+    __HAL_RCC_GPIOB_CLK_ENABLE();
-    /**ADC1 GPIO Configuration
+    /**ADC1 GPIO Configuration
-    PA3     ------> ADC1_IN3
+    PA3     ------> ADC1_IN3
-    PA4     ------> ADC1_IN4
+    PA4     ------> ADC1_IN4
-    PB0     ------> ADC1_IN8
+    PB0     ------> ADC1_IN8
-    PB1     ------> ADC1_IN9
+    PB1     ------> ADC1_IN9
-    */
+    */
-    GPIO_InitStruct.Pin = GPIO_PIN_3|CP_ADC_Pin;
+    GPIO_InitStruct.Pin = GPIO_PIN_3|CP_ADC_Pin;
-    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
+    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
-    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
-
+
-    GPIO_InitStruct.Pin = ADC_NTC1_Pin|ADC_NTC2_Pin;
+    GPIO_InitStruct.Pin = ADC_NTC1_Pin|ADC_NTC2_Pin;
-    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
+    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
-    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
-
+
-    /* ADC1 DMA Init */
+    /* ADC1 DMA Init */
-    /* ADC1 Init */
+    /* ADC1 Init */
-    hdma_adc1.Instance = DMA1_Channel1;
+    hdma_adc1.Instance = DMA1_Channel1;
-    hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;
+    hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;
-    hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;
+    hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;
-    hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;
+    hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;
-    hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
+    hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
-    hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
+    hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
-    hdma_adc1.Init.Mode = DMA_CIRCULAR;
+    hdma_adc1.Init.Mode = DMA_CIRCULAR;
-    hdma_adc1.Init.Priority = DMA_PRIORITY_MEDIUM;
+    hdma_adc1.Init.Priority = DMA_PRIORITY_MEDIUM;
-    if (HAL_DMA_Init(&hdma_adc1) != HAL_OK)
+    if (HAL_DMA_Init(&hdma_adc1) != HAL_OK)
-    {
+    {
-      Error_Handler();
+      Error_Handler();
-    }
+    }
-
+
-    __HAL_LINKDMA(adcHandle,DMA_Handle,hdma_adc1);
+    __HAL_LINKDMA(adcHandle,DMA_Handle,hdma_adc1);
-
+
-    /* ADC1 interrupt Init */
+    /* ADC1 interrupt Init */
-    HAL_NVIC_SetPriority(ADC1_2_IRQn, 7, 0);
+    HAL_NVIC_SetPriority(ADC1_2_IRQn, 7, 0);
-    HAL_NVIC_EnableIRQ(ADC1_2_IRQn);
+    HAL_NVIC_EnableIRQ(ADC1_2_IRQn);
-  /* USER CODE BEGIN ADC1_MspInit 1 */
+  /* USER CODE BEGIN ADC1_MspInit 1 */
-
+
-  /* USER CODE END ADC1_MspInit 1 */
+  /* USER CODE END ADC1_MspInit 1 */
-  }
+  }
-}
+}
-
+
-void HAL_ADC_MspDeInit(ADC_HandleTypeDef* adcHandle)
+void HAL_ADC_MspDeInit(ADC_HandleTypeDef* adcHandle)
-{
+{
-
+
-  if(adcHandle->Instance==ADC1)
+  if(adcHandle->Instance==ADC1)
-  {
+  {
-  /* USER CODE BEGIN ADC1_MspDeInit 0 */
+  /* USER CODE BEGIN ADC1_MspDeInit 0 */
-
+
-  /* USER CODE END ADC1_MspDeInit 0 */
+  /* USER CODE END ADC1_MspDeInit 0 */
-    /* Peripheral clock disable */
+    /* Peripheral clock disable */
-    __HAL_RCC_ADC1_CLK_DISABLE();
+    __HAL_RCC_ADC1_CLK_DISABLE();
-
+
-    /**ADC1 GPIO Configuration
+    /**ADC1 GPIO Configuration
-    PA3     ------> ADC1_IN3
+    PA3     ------> ADC1_IN3
-    PA4     ------> ADC1_IN4
+    PA4     ------> ADC1_IN4
-    PB0     ------> ADC1_IN8
+    PB0     ------> ADC1_IN8
-    PB1     ------> ADC1_IN9
+    PB1     ------> ADC1_IN9
-    */
+    */
-    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_3|CP_ADC_Pin);
+    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_3|CP_ADC_Pin);
-
+
-    HAL_GPIO_DeInit(GPIOB, ADC_NTC1_Pin|ADC_NTC2_Pin);
+    HAL_GPIO_DeInit(GPIOB, ADC_NTC1_Pin|ADC_NTC2_Pin);
-
+
-    /* ADC1 DMA DeInit */
+    /* ADC1 DMA DeInit */
-    HAL_DMA_DeInit(adcHandle->DMA_Handle);
+    HAL_DMA_DeInit(adcHandle->DMA_Handle);
-
+
-    /* ADC1 interrupt Deinit */
+    /* ADC1 interrupt Deinit */
-    HAL_NVIC_DisableIRQ(ADC1_2_IRQn);
+    HAL_NVIC_DisableIRQ(ADC1_2_IRQn);
-  /* USER CODE BEGIN ADC1_MspDeInit 1 */
+  /* USER CODE BEGIN ADC1_MspDeInit 1 */
-
+
-  /* USER CODE END ADC1_MspDeInit 1 */
+  /* USER CODE END ADC1_MspDeInit 1 */
-  }
+  }
-}
+}
-
+
-/* USER CODE BEGIN 1 */
+/* USER CODE BEGIN 1 */
-
+
-/* USER CODE END 1 */
+/* USER CODE END 1 */

Core/Src/charger_control.c

@@ -2,6 +2,7 @@
 
 #include "charger_config.h"
 #include "debug.h"
+#include "fire_alarm.h"
 #include "psu_control.h"
 
 ChargingConnector_t CONN;
@@ -17,6 +18,13 @@ void CONN_Init(){
 
 void CONN_Loop(){
     static CONN_State_t last_connState = Unknown;
+
+    if (FireAlarm_IsLatched()) {
+        CONN.chargingError = CONN_ERR_FIRE_ALARM;
+        CONN.EnableOutput = 0;
+        return;
+    }
+
 	if(last_connState != CONN.connState){
 		last_connState = CONN.connState;
 		CONN.connControl = CMD_NONE;

Core/Src/fire_alarm.c

@@ -0,0 +1,74 @@
+#include "fire_alarm.h"
+#include "serial_control.h"
+#include "charger_control.h"
+#include "connector.h"
+#include "serial.h"
+#include "cp.h"
+#include "debug.h"
+
+static uint8_t fire_alarm_latched = 0;
+static uint32_t fire_alarm_last_estop_tick = 0;
+
+extern CCS_ConnectorState_t CCS_ConnectorState;
+
+uint8_t FireAlarm_IsLatched(void) {
+    return fire_alarm_latched;
+}
+
+uint8_t FireAlarm_IsBlockingCommand(uint8_t command_code) {
+    if (!fire_alarm_latched) {
+        return 0;
+    }
+
+    switch (command_code) {
+        case CMD_GET_STATUS:
+        case CMD_GET_INFO:
+        case CMD_GET_LOG:
+        case CMD_DEVICE_RESET:
+            return 0;
+        default:
+            return 1;
+    }
+}
+
+void FireAlarm_Activate(void) {
+    if (fire_alarm_latched) {
+        return;
+    }
+
+    fire_alarm_latched = 1;
+    CONN.chargingError = CONN_ERR_FIRE_ALARM;
+    CONN.connControl = CMD_STOP;
+    CONN.EnableOutput = 0;
+
+    log_printf(LOG_ERR, "FIRE ALARM activated\n");
+
+    CCS_SendEmergencyStop();
+    fire_alarm_last_estop_tick = HAL_GetTick();
+    CP_SetDuty(100);
+    CCS_ConnectorState = CCS_DISABLED;
+    CONN_SetState(Disabled);
+}
+
+void FireAlarm_Maintain(void) {
+    if (!fire_alarm_latched) {
+        return;
+    }
+
+    CONN.chargingError = CONN_ERR_FIRE_ALARM;
+    CONN.EnableOutput = 0;
+    CP_SetDuty(100);
+
+    if ((int32_t)(HAL_GetTick() - fire_alarm_last_estop_tick) >= 1000) {
+        CCS_SendEmergencyStop();
+        fire_alarm_last_estop_tick = HAL_GetTick();
+    }
+
+    if (CCS_ConnectorState != CCS_DISABLED && CCS_ConnectorState != CCS_UNKNOWN) {
+        CCS_ConnectorState = CCS_DISABLED;
+    }
+
+    if (CONN.connState != Disabled) {
+        CONN_SetState(Disabled);
+    }
+}

Core/Src/rgb_controller.c

@@ -2,6 +2,7 @@
 
 #include "board.h"
 #include "charger_control.h"
+#include "fire_alarm.h"
 #include "main.h"
 #include "tim.h"
 #include <string.h>
@@ -100,6 +101,10 @@ RGB_Cycle_t color_error = {
 };
 
 void LED_Write(){
+    if(FireAlarm_IsLatched() || CONN.chargingError == CONN_ERR_FIRE_ALARM){
+      LED_SetColor(&color_error);
+      return;
+    }
     if(CONN.chargingError != CONN_NO_ERROR){
       LED_SetColor(&color_error);
       return;

Core/Src/serial.c

@@ -6,6 +6,7 @@
 #include "cp.h"
 #include "debug.h"
 #include "isr_opt.h"
+#include "fire_alarm.h"
 #include "psu_control.h"
 #include "serial_control.h"
 #include <stdint.h>
@@ -170,6 +171,7 @@ void CCS_SerialLoop(void) {
     static uint32_t stop_tick = 0;
 
     CCS_UART3_Watchdog();
+    FireAlarm_Maintain();
 
     if (CONN.connControl != CMD_NONE) {
         last_cmd = CONN.connControl;
@@ -211,7 +213,8 @@ void CCS_SerialLoop(void) {
 
         if (((CONN.connControl == CMD_STOP) ||
              (CONN.connControl == CMD_FORCE_UNLOCK) ||
-             (CONN.chargingError != CONN_NO_ERROR)) &&
+             (CONN.chargingError != CONN_NO_ERROR) ||
+             FireAlarm_IsLatched()) &&
             ((int32_t)(HAL_GetTick() - last_stop_sent) > 1000)) {
             last_stop_sent = HAL_GetTick();
             log_printf(LOG_WARN, "Stopping charging...\n");
@@ -254,6 +257,10 @@ void CCS_SerialLoop(void) {
     everest_timed_out = host_timeout_stop;
     switch(CCS_ConnectorState){
             case CCS_UNKNOWN:
+                if (FireAlarm_IsLatched()) {
+                    CCS_ConnectorState = CCS_DISABLED;
+                    break;
+                }
                 RELAY_Write(RELAY_CP, 0);
                 CONN_SetState(Unknown);
                 if (config_initialized && !host_timed_out) {
@@ -263,11 +270,15 @@ void CCS_SerialLoop(void) {
             case CCS_DISABLED:
                 RELAY_Write(RELAY_CP, 0);
                 CONN_SetState(Disabled);
-                if ((CONN.chargingError == CONN_NO_ERROR) && !host_timed_out){
+                if (!FireAlarm_IsLatched() && (CONN.chargingError == CONN_NO_ERROR) && !host_timed_out){
                     CCS_ConnectorState = CCS_UNPLUGGED;
                 }
                 break;
             case CCS_UNPLUGGED:
+                if (FireAlarm_IsLatched()) {
+                    CCS_ConnectorState = CCS_DISABLED;
+                    break;
+                }
                 RELAY_Write(RELAY_CP, 1);
                 CONN_SetState(Unplugged);
                 if ((cp_state_buffer == EV_STATE_B_CONN_PREP) || (cp_state_buffer == EV_STATE_C_CONN_ACTIVE)){
@@ -280,6 +291,10 @@ void CCS_SerialLoop(void) {
 
                 break;
             case CCS_AUTH_REQUIRED:
+                if (FireAlarm_IsLatched()) {
+                    CCS_ConnectorState = CCS_DISABLED;
+                    break;
+                }
                 RELAY_Write(RELAY_CP, 1);
                 CONN_SetState(AuthRequired);
                 if(CONN.connControl == CMD_START){
@@ -292,6 +307,10 @@ void CCS_SerialLoop(void) {
                 }
                 break;
             case CCS_CONNECTED:
+                if (FireAlarm_IsLatched()) {
+                    CCS_ConnectorState = CCS_DISABLED;
+                    break;
+                }
                 RELAY_Write(RELAY_CP, 1);
                 if((CCS_EvseState < Preparing) || (CCS_EvseState == AuthRequired)) {
                     CONN_SetState(Preparing);
@@ -308,6 +327,10 @@ void CCS_SerialLoop(void) {
                 }
                 break;
             case CCS_REPLUGGING:
+                if (FireAlarm_IsLatched()) {
+                    CCS_ConnectorState = CCS_DISABLED;
+                    break;
+                }
                 RELAY_Write(RELAY_CP, 0);
                 CONN_SetState(Replugging);
                 if((int32_t)(HAL_GetTick() - replug_tick) > 1000){
@@ -330,7 +353,13 @@ void CCS_SerialLoop(void) {
     }
 
     // 10s timeout: enforce safe-state until host communication recovers.
-    if (host_timeout_stop) {
+    if (FireAlarm_IsLatched()) {
+        CONN.EnableOutput = 0;
+        CP_SetDuty(100);
+        if (CCS_ConnectorState != CCS_DISABLED && CCS_ConnectorState != CCS_UNKNOWN) {
+            CCS_ConnectorState = CCS_DISABLED;
+        }
+    } else if (host_timeout_stop) {
         CONN.EnableOutput = 0;
         CCS_EvseState = Unknown;
         CP_SetDuty(100);

Core/Src/serial_handler.c

@@ -3,6 +3,7 @@
 #include "board.h"
 #include "charger_control.h"
 #include "debug.h"
+#include "fire_alarm.h"
 #include "psu_control.h"
 #include "usart.h"
 #include <string.h>
@@ -27,6 +28,11 @@ void SC_CommandHandler(ReceivedCommand_t* cmd) {
     
     uint8_t response_code = RESP_FAILED;
 
+    if (FireAlarm_IsBlockingCommand(cmd->command)) {
+        SC_SendPacket(NULL, 0, RESP_FAILED);
+        return;
+    }
+
     switch (cmd->command) {
         // Команды БЕЗ аргументов
         case CMD_GET_STATUS:
@@ -86,6 +92,11 @@ void SC_CommandHandler(ReceivedCommand_t* cmd) {
             // }
             response_code = RESP_FAILED;
             break;
+        case CMD_FIRE_ALARM:
+            FireAlarm_Activate();
+            response_code = RESP_SUCCESS;
+            break;
+
         case CMD_DEVICE_RESET:
             // 2. Отправляем SUCCESS (хост может успеть получить его перед ребутом)
             SC_SendPacket(NULL, 0, RESP_SUCCESS);

Debug/Core/Src/fire_alarm.cyclo

@@ -0,0 +1,4 @@
+../Core/Src/fire_alarm.c:14:9:FireAlarm_IsLatched	1
+../Core/Src/fire_alarm.c:18:9:FireAlarm_IsBlockingCommand	8
+../Core/Src/fire_alarm.c:34:6:FireAlarm_Activate	2
+../Core/Src/fire_alarm.c:53:6:FireAlarm_Maintain	6

Debug/Core/Src/subdir.mk

@@ -13,6 +13,7 @@ C_SRCS += \
 ../Core/Src/crc.c \
 ../Core/Src/debug.c \
 ../Core/Src/dma.c \
+../Core/Src/fire_alarm.c \
 ../Core/Src/gpio.c \
 ../Core/Src/main.c \
 ../Core/Src/meter.c \
@@ -41,6 +42,7 @@ C_DEPS += \
 ./Core/Src/crc.d \
 ./Core/Src/debug.d \
 ./Core/Src/dma.d \
+./Core/Src/fire_alarm.d \
 ./Core/Src/gpio.d \
 ./Core/Src/main.d \
 ./Core/Src/meter.d \

Debug/objects.list

@@ -6,6 +6,7 @@
 "./Core/Src/crc.o"
 "./Core/Src/debug.o"
 "./Core/Src/dma.o"
+"./Core/Src/fire_alarm.o"
 "./Core/Src/gpio.o"
 "./Core/Src/main.o"
 "./Core/Src/meter.o"