Add TonHe 30kW PSU control with LV/HV restart (v1.0.37).

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

CCSModuleSW30Web.ioc

@@ -311,10 +311,10 @@ PC12.GPIOParameters=GPIO_Label
 PC12.GPIO_Label=HEATER
 PC12.Mode=Asynchronous
 PC12.Signal=UART5_TX
-PC14-OSC32_IN.Mode=LSE-External-Oscillator
-PC14-OSC32_IN.Signal=RCC_OSC32_IN
-PC15-OSC32_OUT.Mode=LSE-External-Oscillator
-PC15-OSC32_OUT.Signal=RCC_OSC32_OUT
+PC14-OSC32_IN.Locked=true
+PC14-OSC32_IN.Signal=GPIO_Analog
+PC15-OSC32_OUT.Locked=true
+PC15-OSC32_OUT.Signal=GPIO_Analog
 PC2.GPIOParameters=GPIO_Speed,GPIO_Label
 PC2.GPIO_Label=DBG1
 PC2.GPIO_Speed=GPIO_SPEED_FREQ_HIGH
@@ -462,8 +462,8 @@ RCC.PLLSourceVirtual=RCC_PLLSOURCE_HSE
 RCC.Prediv1Source=RCC_PREDIV1_SOURCE_PLL2
 RCC.Prediv2=RCC_HSE_PREDIV2_DIV5
 RCC.Prediv2FreqValue=5000000
-RCC.RTCClockSelection=RCC_RTCCLKSOURCE_LSE
-RCC.RTCFreq_Value=32768
+RCC.RTCClockSelection=RCC_RTCCLKSOURCE_LSI
+RCC.RTCFreq_Value=40000
 RCC.SYSCLKFreq_VALUE=72000000
 RCC.SYSCLKSource=RCC_SYSCLKSOURCE_PLLCLK
 RCC.TimSysFreq_Value=72000000

Core/Inc/board.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <stdint.h>
+#include "charger_config.h"
 
 typedef enum{
 	RELAY_AUX0 = 0,
@@ -40,22 +41,39 @@ typedef enum{
 
 uint8_t IN_ReadInput(inputNum_t input_n);
 
-// Версия устройства
-#define VERSION_OFFSET (0x1E4)
+// ConfigBlock: new bootloader at 0x08007800, legacy at 0x080001E4
+#define VERSION_OFFSET         (0x08007800u)
+#define VERSION_OFFSET_LEGACY  (0x080001E4u)
 
 typedef struct __attribute__((packed)) {
-	uint32_t serialNumber;           // Байты 0-3
-	uint8_t stationType;             // Байт 4
-	uint8_t boardVersion;            // Байт 5
-	uint8_t addrEdcan;               // Байт 6
-	uint8_t maxPower;                // Байт 7
-	uint8_t pad[7];                  // bytes 8-14, see edcan.h
+	uint32_t serialNumber;            // Байты 0-3
+	uint8_t stationType;              // Байт 4
+	uint8_t boardVersion;             // Байт 5
+	uint8_t addrEdcan;                // Байт 6
+	uint8_t contactorConfig;          // Байт 7
+	uint8_t connectorConfig;          // Байт 8
+	uint8_t maxPower;                 // Байт 9, 5 кВт/bit
+	uint8_t psuType;                  // Байт 10
+	uint8_t meterType;                // Байт 11
+	uint8_t balancerType;             // Байт 12
+	uint8_t autostartMode;            // Байт 13
+	uint8_t motorEnable;              // Байт 14
 	uint16_t connector1CurrentLimitA; // Байты 15-16, A; 0 = legacy PSU_MAX_CURRENT
-	uint8_t reserved[45];            // Байты 17-63
+	uint16_t connector2CurrentLimitA; // Байты 17-18
+	uint16_t connector3CurrentLimitA; // Байты 19-20
+	uint8_t reserved[43];             // Байты 21-63
 } InfoBlock_t;
 
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
+_Static_assert(sizeof(InfoBlock_t) == 64, "InfoBlock_t must be 64 bytes");
+#endif
+
 extern InfoBlock_t *InfoBlock;
 
+void Board_SelectInfoBlockAddress(void);
 void Board_LoadInfoBlockLimits(void);
 uint16_t Board_GetConnectorCurrentLimit_0p1A(void);
 uint16_t Board_ClampCurrent_0p1A(uint16_t current_0p1A);
+PsuType_t Board_GetPsuType(void);
+uint16_t Board_GetPsuMaxCurrentA(void);
+uint32_t Board_GetPsuMaxPowerW(void);

Core/Inc/charger_config.h

@@ -7,8 +7,21 @@
 #define PSU_MIN_CURRENT 1  //1A/bit
 #define PSU_MAX_POWER   40000 //1W/bit
 
+#define PSU_BLOCK_POWER_30KW    30000u
+#define PSU_BLOCK_POWER_40KW    40000u
+#define PSU_BLOCK_CURRENT_30KW  100u
+#define PSU_BLOCK_CURRENT_40KW  133u
+
 #define PSU_NUM 1
 
+/* Values match bootloader-flasher firmwares.json psuTypes[].value (InfoBlock byte 10). */
+typedef enum {
+	PSU_TYPE_NONE = 0,
+	PSU_TYPE_NIUERA_30KW = 1,
+	PSU_TYPE_NIUERA_40KW = 2,
+	PSU_TYPE_TONHE_30KW = 3
+} PsuType_t;
+
 /* Dynamic LV clamp (CS60 hv_limit): active only on overload at low bus voltage. */
 #define PSU_LV_CLAMP_V              499u
 #define PSU_HV_LIMIT_ON_THRESHOLD   480u
@@ -17,7 +30,10 @@
 #define PSU_HV_LOAD_CURRENT         300u   /* 30.0 A, MeasuredCurrent is 0.1 A/bit */
 #define PSU_HV_LIMIT_MAX_COUNT      3u
 
-/* Fast discharge: PSU off/on cycle on step-down setpoint (unloaded bus). */
+/* TonHe group start: ≤500 V = LV, >500 V = HV. LV→HV while ON dies; HV→LV stays ON. */
+#define TONHE_HV_THRESHOLD_V          500u
+
+/* Fast discharge: Niuera off/on cycle on step-down (unloaded bus). TonHe skips this. */
 #define PSD_ENABLE                    1u
 #define PSD_MAX_CMD_CURRENT_0P1A      20u   /* 2.0 A */
 #define PSD_MAX_MEASURED_CURRENT_0P1A   30u   /* 3.0 A */

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 36
+#define FW_VERSION_PATCH 37
 /* USER CODE END EC */
 
 /* Exported macro ------------------------------------------------------------*/

Core/Inc/psu_control.h

@@ -7,6 +7,7 @@ void PSU_Init();
 void PSU_Enable(uint8_t addr, uint8_t enable);
 void PSU_SetVoltageCurrent(uint8_t addr, uint16_t voltage, uint16_t current);
 void PSU_ReadWrite(void);
+PsuType_t PSU_GetType(void);
 
 // --- Состояние силового модуля (DC30, один PSU) ---
 

Core/Src/board.c

@@ -10,16 +10,64 @@ InfoBlock_t *InfoBlock = (InfoBlock_t *)(VERSION_OFFSET);
 
 static uint16_t s_connector_max_current_0p1A = (uint16_t)PSU_MAX_CURRENT * 10u;
 
+void Board_SelectInfoBlockAddress(void)
+{
+	const volatile uint32_t *new_base = (const volatile uint32_t *)VERSION_OFFSET;
+
+	if (*new_base == 0xFFFFFFFFu) {
+		InfoBlock = (InfoBlock_t *)VERSION_OFFSET_LEGACY;
+	} else {
+		InfoBlock = (InfoBlock_t *)VERSION_OFFSET;
+	}
+}
+
+PsuType_t Board_GetPsuType(void)
+{
+	/* Legacy ConfigBlock has no psuType field; keep Niuera path. */
+	if (InfoBlock == (InfoBlock_t *)VERSION_OFFSET_LEGACY) {
+		return PSU_TYPE_NONE;
+	}
+	return (PsuType_t)InfoBlock->psuType;
+}
+
+uint16_t Board_GetPsuMaxCurrentA(void)
+{
+	switch (Board_GetPsuType()) {
+	case PSU_TYPE_TONHE_30KW:
+	case PSU_TYPE_NIUERA_30KW:
+		return (uint16_t)PSU_BLOCK_CURRENT_30KW;
+	case PSU_TYPE_NIUERA_40KW:
+		return (uint16_t)PSU_BLOCK_CURRENT_40KW;
+	case PSU_TYPE_NONE:
+	default:
+		return (uint16_t)PSU_MAX_CURRENT;
+	}
+}
+
+uint32_t Board_GetPsuMaxPowerW(void)
+{
+	switch (Board_GetPsuType()) {
+	case PSU_TYPE_TONHE_30KW:
+	case PSU_TYPE_NIUERA_30KW:
+		return PSU_BLOCK_POWER_30KW;
+	case PSU_TYPE_NIUERA_40KW:
+		return PSU_BLOCK_POWER_40KW;
+	case PSU_TYPE_NONE:
+	default:
+		return (uint32_t)PSU_MAX_POWER;
+	}
+}
+
 static uint16_t Board_ResolveConnectorCurrentLimitA(uint16_t raw_limit_a)
 {
-	return (raw_limit_a == 0u) ? (uint16_t)PSU_MAX_CURRENT : raw_limit_a;
+	return (raw_limit_a == 0u) ? Board_GetPsuMaxCurrentA() : raw_limit_a;
 }
 
 void Board_LoadInfoBlockLimits(void)
 {
 	const uint16_t limit_a = Board_ResolveConnectorCurrentLimitA(InfoBlock->connector1CurrentLimitA);
 	uint32_t limit_0p1a = (uint32_t)limit_a * 10u;
-	const uint32_t hw_max_0p1a = (uint32_t)PSU_MAX_CURRENT * 10u;
+	const uint32_t hw_max_0p1a = (uint32_t)Board_GetPsuMaxCurrentA() * 10u;
 
 	if (limit_0p1a > hw_max_0p1a) {
 		limit_0p1a = hw_max_0p1a;

Core/Src/main.c

@@ -220,6 +220,10 @@ int main(void)
   log_printf(LOG_INFO, "Connector current limit: %u.%u A\n",
              (unsigned)(Board_GetConnectorCurrentLimit_0p1A() / 10u),
              (unsigned)(Board_GetConnectorCurrentLimit_0p1A() % 10u));
+  log_printf(LOG_INFO, "PSU type: %u (%u W / %u A)\n",
+             (unsigned)Board_GetPsuType(),
+             (unsigned)Board_GetPsuMaxPowerW(),
+             (unsigned)Board_GetPsuMaxCurrentA());
   log_printf(LOG_INFO, "FW version: %d.%d.%d\n", infoPacket.fw_version_major, infoPacket.fw_version_minor, infoPacket.fw_version_patch);
   CAN1_MinimalReInit();
   PSU_Init();
@@ -261,11 +265,12 @@ void SystemClock_Config(void)
   /** Initializes the RCC Oscillators according to the specified parameters
   * in the RCC_OscInitTypeDef structure.
   */
-  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE|RCC_OSCILLATORTYPE_LSE;
+  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE|RCC_OSCILLATORTYPE_LSI|RCC_OSCILLATORTYPE_LSE;
   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
   RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV5;
-  RCC_OscInitStruct.LSEState = RCC_LSE_ON;
+  RCC_OscInitStruct.LSEState = RCC_LSE_OFF;
   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
+  RCC_OscInitStruct.LSIState = RCC_LSI_ON;
   RCC_OscInitStruct.Prediv1Source = RCC_PREDIV1_SOURCE_PLL2;
   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
@@ -292,7 +297,7 @@ void SystemClock_Config(void)
     Error_Handler();
   }
   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_RTC|RCC_PERIPHCLK_ADC;
-  PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
+  PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
   PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV6;
   if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
   {

Core/Src/power_setpoint_executor.c

@@ -145,7 +145,9 @@ PowerSetpointTryResult_t PowerSetpoint_TryApply(void)
 	ctx = build_context();
 	action = PowerSetpoint_Decide(&applied, &pending, &ctx);
 
-	if (action == POWER_SETPOINT_FAST_DISCHARGE) {
+	/* TonHe dumps HV→LV itself; LV→HV is a group stop/start in psu_control. */
+	if ((action == POWER_SETPOINT_FAST_DISCHARGE) &&
+	    (PSU_GetType() != PSU_TYPE_TONHE_30KW)) {
 		fd_target = pending;
 		fd_active = 1u;
 		setpoint_dirty = 0u;

Core/Src/psu_control.c

@@ -24,24 +24,95 @@ PSU_t PSU0;
 
 #define CAN_DELAY 20
 #define PSU_VOLTAGE_THRESHOLD 20 // Порог напряжения для определения состояния (В)
-#define PSU_ONLINE_TIMEOUT 500 // Таймаут для определения состояния (мс)
+#define PSU_ONLINE_TIMEOUT 500 // Таймаут Niuera (мс)
+#define PSU_TONHE_ONLINE_TIMEOUT 3000u /* PF=01 ~0.5–1 с по документу/записи */
 #define PSU_STARTUP_DELAY 4000 // Задержка 2 секунды перед включением
 #define PSU_DIAG_LOG_MS 2000u
 #define PSU_SUDDEN_OFF_DEBOUNCE_MS 200u
 
+/* TonHe V1.2/V1.3: 125 kbit/s already on CAN2, extended 29-bit PDU1.
+ * Start/stop is group PF=04 then PF=03 with a member bit, not addressed PF=06.
+ * TONHE_MODULE_ADDR: live SA for the bitmask (4 on the bench). 0 = first SA that answers A0. */
+#define TONHE_SA_CTRL          0xA0u
+#define TONHE_DA_BROADCAST     0xFFu
+#define TONHE_MODULE_ADDR      4u
+#define TONHE_PF_STATUS        0x01u
+#define TONHE_PF_AC            0x0Bu
+#define TONHE_PF_EXT           0x91u
+#define TONHE_PF_GROUP_CMD     0x03u
+#define TONHE_PF_UI_MASK       0x04u
+#define TONHE_PF_HEARTBEAT     0x05u
+#define TONHE_P_GROUP_CMD      2u
+#define TONHE_P_UI_MASK        4u
+#define TONHE_P_HEARTBEAT      6u
+#define TONHE_CMD_START        0xAAu
+#define TONHE_CMD_STOP         0x55u
+#define TONHE_HEARTBEAT_MS     4000u
+#define TONHE_CMD_MIN_MS       200u
+#define TONHE_STATE_OFF        0x00u
+#define TONHE_STATE_ON         0x01u
+#define TONHE_STATE_FAULT_OFF  0x11u
+#define TONHE_RESTART_RETRY_MS 500u
+#define TONHE_RESTART_OFF_MS   10000u
+#define TONHE_RESTART_ON_MS    10000u
+
+typedef enum {
+	TONHE_RESTART_IDLE = 0,
+	TONHE_RESTART_STOP,
+	TONHE_RESTART_WAIT_OFF,
+	TONHE_RESTART_START,
+	TONHE_RESTART_WAIT_ON
+} TonHeRestart_t;
+
 uint32_t can_lastpacket;
 
 extern CAN_HandleTypeDef hcan2;
 
 static uint16_t psu_last_can_v;
 static uint16_t psu_last_can_i_0p1A;
+static uint16_t psu_cmd_v = PSU_MIN_VOLTAGE;
+static uint16_t psu_cmd_i_0p1A;
 static uint8_t psu_last_good_s0;
 static uint8_t psu_last_good_s1;
 static uint8_t psu_last_good_s2;
+static PsuType_t psu_type;
+static uint16_t psu_max_current_a = PSU_MAX_CURRENT;
+static uint8_t psu_output_cmd_on;
+static uint8_t tonhe_state;
+static uint8_t tonhe_sa;
+static uint32_t tonhe_last_cmd_ms;
+static uint8_t tonhe_last_sent_start = 0xFFu;
+static uint16_t tonhe_last_sent_v;
+static uint16_t tonhe_last_sent_i;
+static uint16_t tonhe_faults;
+static uint8_t tonhe_pfc;
+static uint16_t tonhe_ext_x;
+static uint8_t tonhe_ext_valid;
+static uint32_t tonhe_hb_tick;
+static TonHeRestart_t tonhe_restart;
+static uint32_t tonhe_restart_tick;
+static uint32_t tonhe_restart_cmd_ms;
+static uint16_t tonhe_run_v;
+static uint8_t tonhe_run_valid;
 
 static void PSU_SendCmd(uint8_t source, uint8_t destination, uint8_t cmd, void *data);
+static void PSU_SwitchState(PSU_State_t state);
 static void PSU_LogActiveStatusFlags(LogLevel_t level);
 static void PSU_MonitorStatusAndUnexpectedOff(void);
+static uint8_t PSU_IsTonHe(void);
+static void PSU_TonHeSend(uint8_t priority, uint8_t pf, uint8_t da, const uint8_t *data);
+static void PSU_TonHeHeartbeat(void);
+static void PSU_TonHeSendGroupUi(uint16_t voltage_v, uint16_t current_0p1A, uint8_t force);
+static void PSU_TonHeSendGroupOnOff(uint8_t start, uint8_t force);
+static void PSU_TonHeRefreshFlags(void);
+static void PSU_TonHeRx(uint32_t ext_id, uint32_t dlc, const uint8_t *rx);
+static uint8_t PSU_TonHeIsHv(uint16_t voltage_v);
+static uint8_t PSU_TonHeNearTarget(uint16_t target_v);
+static uint8_t PSU_TonHeLvEstablished(void);
+static uint8_t PSU_TonHeCanLvHvRestart(uint16_t target_v);
+static void PSU_TonHeRestartReset(void);
+static void PSU_TonHeRestartBegin(void);
+static void PSU_TonHeRestartTask(void);
 
 static const char *PSU_StateName(PSU_State_t state)
 {
@@ -65,6 +136,460 @@ static const char *PSU_StateName(PSU_State_t state)
 	}
 }
 
+static uint8_t PSU_IsTonHe(void)
+{
+	return (psu_type == PSU_TYPE_TONHE_30KW) ? 1u : 0u;
+}
+
+PsuType_t PSU_GetType(void)
+{
+	return psu_type;
+}
+
+static uint8_t PSU_TonHeIsHv(uint16_t voltage_v)
+{
+	return (voltage_v > TONHE_HV_THRESHOLD_V) ? 1u : 0u;
+}
+
+/* Same window as Niuera PSD_ON_WAIT: measured U near the commanded setpoint. */
+static uint8_t PSU_TonHeNearTarget(uint16_t target_v)
+{
+	uint16_t v_low;
+
+	v_low = (target_v > PSD_PRECHARGE_TOLERANCE_V) ?
+	        (uint16_t)(target_v - PSD_PRECHARGE_TOLERANCE_V) : 0u;
+	return (CONN.MeasuredVoltage >= v_low) ? 1u : 0u;
+}
+
+static uint8_t PSU_TonHeLvEstablished(void)
+{
+	if ((tonhe_run_valid == 0u) || PSU_TonHeIsHv(tonhe_run_v) ||
+	    PSU_TonHeIsHv(CONN.MeasuredVoltage)) {
+		return 0u;
+	}
+	return PSU_TonHeNearTarget(tonhe_run_v);
+}
+
+static uint8_t PSU_TonHeCanLvHvRestart(uint16_t target_v)
+{
+	if ((tonhe_restart != TONHE_RESTART_IDLE) ||
+	    (PSU0.state != PSU_CONNECTED) ||
+	    (psu_output_cmd_on == 0u) ||
+	    (PSU0.PSU_enabled == 0u) ||
+	    (tonhe_run_valid == 0u) ||
+	    PSU_TonHeIsHv(tonhe_run_v) ||
+	    (PSU_TonHeIsHv(target_v) == 0u)) {
+		return 0u;
+	}
+	return PSU_TonHeLvEstablished();
+}
+
+static void PSU_TonHeRestartReset(void)
+{
+	tonhe_restart = TONHE_RESTART_IDLE;
+	tonhe_run_valid = 0u;
+}
+
+static void PSU_TonHeRestartBegin(void)
+{
+	if (tonhe_restart != TONHE_RESTART_IDLE) {
+		return;
+	}
+	log_printf(LOG_INFO, "TonHe LV->HV restart %u->%u\n",
+	           (unsigned)tonhe_run_v, (unsigned)psu_cmd_v);
+	tonhe_restart = TONHE_RESTART_STOP;
+	tonhe_restart_tick = HAL_GetTick();
+}
+
+static void PSU_TonHeRestartTask(void)
+{
+	uint32_t now;
+
+	if (!PSU_IsTonHe() || (tonhe_restart == TONHE_RESTART_IDLE)) {
+		return;
+	}
+
+	if (!CONN.EnableOutput || !PSU0.ready || PSU0.cont_fault || PSU0.psu_fault) {
+		log_printf(LOG_WARN, "TonHe LV->HV restart abort\n");
+		tonhe_restart = TONHE_RESTART_IDLE;
+		return;
+	}
+
+	now = HAL_GetTick();
+
+	switch (tonhe_restart) {
+	case TONHE_RESTART_STOP:
+		PSU_TonHeSendGroupOnOff(0u, 1u);
+		tonhe_restart = TONHE_RESTART_WAIT_OFF;
+		tonhe_restart_tick = now;
+		break;
+
+	case TONHE_RESTART_WAIT_OFF:
+		if (PSU0.PSU_enabled == 0u) {
+			tonhe_restart = TONHE_RESTART_START;
+			tonhe_restart_tick = now;
+		} else if ((now - tonhe_restart_tick) > TONHE_RESTART_OFF_MS) {
+			log_printf(LOG_WARN, "TonHe LV->HV restart off timeout V=%u\n",
+			           (unsigned)CONN.MeasuredVoltage);
+			PSU0.psu_fault = 1;
+			CONN.chargingError = CONN_ERR_PSU_FAULT;
+			tonhe_restart = TONHE_RESTART_IDLE;
+			PSU_SwitchState(PSU_CURRENT_DROP);
+		}
+		break;
+
+	case TONHE_RESTART_START:
+		PSU_TonHeSendGroupUi(psu_cmd_v, psu_cmd_i_0p1A, 1u);
+		ED_Delay(CAN_DELAY);
+		PSU_TonHeSendGroupOnOff(1u, 1u);
+		psu_output_cmd_on = 1u;
+		tonhe_restart_cmd_ms = now;
+		tonhe_restart = TONHE_RESTART_WAIT_ON;
+		tonhe_restart_tick = now;
+		break;
+
+	case TONHE_RESTART_WAIT_ON:
+		if ((PSU0.PSU_enabled != 0u) && PSU_TonHeNearTarget(psu_cmd_v)) {
+			tonhe_run_v = psu_cmd_v;
+			tonhe_run_valid = 1u;
+			tonhe_restart = TONHE_RESTART_IDLE;
+			log_printf(LOG_INFO, "TonHe LV->HV restart done V=%u\n",
+			           (unsigned)CONN.MeasuredVoltage);
+		} else {
+			if ((now - tonhe_restart_cmd_ms) >= TONHE_RESTART_RETRY_MS) {
+				PSU_TonHeSendGroupUi(psu_cmd_v, psu_cmd_i_0p1A, 1u);
+				ED_Delay(CAN_DELAY);
+				PSU_TonHeSendGroupOnOff(1u, 1u);
+				tonhe_restart_cmd_ms = now;
+			}
+			if ((now - tonhe_restart_tick) > TONHE_RESTART_ON_MS) {
+				log_printf(LOG_ERR, "TonHe LV->HV restart on timeout V=%u target=%u\n",
+				           (unsigned)CONN.MeasuredVoltage, (unsigned)psu_cmd_v);
+				PSU0.psu_fault = 1;
+				CONN.chargingError = CONN_ERR_PSU_FAULT;
+				tonhe_restart = TONHE_RESTART_IDLE;
+				PSU_SwitchState(PSU_UNREADY);
+			}
+		}
+		break;
+
+	default:
+		tonhe_restart = TONHE_RESTART_IDLE;
+		break;
+	}
+}
+
+static uint32_t PSU_TonHeMakeId(uint8_t priority, uint8_t pf, uint8_t da, uint8_t sa)
+{
+	return ((uint32_t)(priority & 7u) << 26) |
+	       ((uint32_t)pf << 16) |
+	       ((uint32_t)da << 8) |
+	       (uint32_t)sa;
+}
+
+static uint16_t PSU_TonHeU16le(const uint8_t *data, uint8_t offset)
+{
+	return (uint16_t)data[offset] | ((uint16_t)data[offset + 1u] << 8);
+}
+
+static void PSU_TonHePutU16le(uint8_t *data, uint8_t offset, uint16_t value)
+{
+	data[offset] = (uint8_t)(value & 0xFFu);
+	data[offset + 1u] = (uint8_t)((value >> 8) & 0xFFu);
+}
+
+static void PSU_ApplyOutputTelemetry(uint16_t voltage_v, int16_t current_0p1A, uint8_t temperature)
+{
+	PSU0.outputVoltage = voltage_v;
+	PSU0.outputCurrent = current_0p1A;
+	PSU0.temperature = temperature;
+	if (PSU0.state >= PSU_READY) {
+		CONN.MeasuredVoltage = PSU0.outputVoltage;
+		CONN.MeasuredCurrent = (uint16_t)PSU0.outputCurrent;
+		CONN.Power = CONN.MeasuredCurrent * CONN.MeasuredVoltage / 10u;
+		CONN.outputEnabled = PSU0.PSU_enabled;
+	}
+}
+
+static void PSU_TonHeRefreshFlags(void)
+{
+	PSU_Status0_t s0;
+	PSU_Status1_t s1;
+	PSU_Status2_t s2;
+
+	memset(&s0, 0, sizeof(s0));
+	memset(&s1, 0, sizeof(s1));
+	memset(&s2, 0, sizeof(s2));
+
+	s0.shortCircuitFault = (tonhe_faults & 0x8000u) ? 1u : 0u;
+	s0.internalCommunicationFault = (tonhe_faults & 0x0200u) ? 1u : 0u;
+	s0.inputBusLineFault = (tonhe_faults & 0x0100u) ? 1u : 0u;
+	s0.dischargeFault = (tonhe_faults & 0x0400u) ? 1u : 0u;
+
+	s1.dcSideOffStatus = (tonhe_state != TONHE_STATE_ON) ? 1u : 0u;
+	s1.moduleFaultAlarm = ((tonhe_faults & 0x0080u) || (tonhe_state == TONHE_STATE_FAULT_OFF)) ? 1u : 0u;
+	s1.fanFaultAlarm = (tonhe_faults & 0x0040u) ? 1u : 0u;
+	s1.overTempAlarm = (tonhe_faults & 0x0020u) ? 1u : 0u;
+	s1.outputOverVoltageAlarm = (tonhe_faults & 0x0008u) ? 1u : 0u;
+	s1.outputOverCurrentAlarm = (tonhe_faults & 0x0010u) ? 1u : 0u;
+
+	s2.powerLimitStatus = (tonhe_faults & 0x4000u) ? 1u : 0u;
+	s2.moduleAddressDuplicate = (tonhe_pfc & 0x10u) ? 1u : 0u;
+	s2.threePhaseInputPhaseLossAlarm = (tonhe_faults & 0x0002u) ? 1u : 0u;
+	s2.threePhaseInputUnbalanceAlarm = (tonhe_pfc & 0x04u) ? 1u : 0u;
+	s2.inputUnderVoltageAlarm = (tonhe_faults & 0x0001u) ? 1u : 0u;
+	s2.inputOverVoltageAlarm = (tonhe_faults & 0x0004u) ? 1u : 0u;
+	s2.pfcSideOffStatus = (tonhe_faults & 0x0800u) ? 1u : 0u;
+
+	/* PF=91 is optional; missing it must not look like a zero mask. */
+	if (tonhe_ext_valid) {
+		if (tonhe_ext_x & 0x0004u) {
+			s1.canCommunicationInterruptAlarm = 1u;
+		}
+		if (tonhe_ext_x & 0x0300u) {
+			s2.powerLimitStatus = 1u;
+		}
+		if (tonhe_ext_x & 0x2000u) {
+			s1.moduleFaultAlarm = 1u;
+		}
+	}
+
+	PSU0.status0.bits = s0;
+	PSU0.status1.bits = s1;
+	PSU0.status2.bits = s2;
+	psu_last_good_s0 = PSU0.status0.raw;
+	psu_last_good_s1 = PSU0.status1.raw;
+	psu_last_good_s2 = PSU0.status2.raw;
+}
+
+static void PSU_TonHeSend(uint8_t priority, uint8_t pf, uint8_t da, const uint8_t *data)
+{
+	int8_t retry_counter = 10;
+	CAN_TxHeaderTypeDef tx_header;
+	uint32_t tx_mailbox;
+	HAL_StatusTypeDef can_result;
+	uint8_t payload[8];
+
+	memcpy(payload, data, 8);
+	tx_header.ExtId = PSU_TonHeMakeId(priority, pf, da, TONHE_SA_CTRL);
+	tx_header.RTR = CAN_RTR_DATA;
+	tx_header.IDE = CAN_ID_EXT;
+	tx_header.DLC = 8;
+
+	while (retry_counter > 0) {
+		if (HAL_CAN_GetTxMailboxesFreeLevel(&hcan2) > 0) {
+			can_result = HAL_CAN_AddTxMessage(&hcan2, &tx_header, payload, &tx_mailbox);
+			if (can_result == HAL_OK) {
+				return;
+			}
+		}
+		ED_Delay(1);
+		retry_counter--;
+	}
+}
+
+static void PSU_TonHeHeartbeat(void)
+{
+	uint8_t zeros[8];
+	uint32_t now = HAL_GetTick();
+
+	if ((tonhe_hb_tick != 0u) && ((now - tonhe_hb_tick) < TONHE_HEARTBEAT_MS)) {
+		return;
+	}
+	tonhe_hb_tick = now;
+	memset(zeros, 0, sizeof(zeros));
+	PSU_TonHeSend(TONHE_P_HEARTBEAT, TONHE_PF_HEARTBEAT, TONHE_DA_BROADCAST, zeros);
+}
+
+static void PSU_TonHeEncodeUi(uint8_t *data, uint8_t u_off, uint8_t i_off,
+                              uint16_t voltage_v, uint16_t current_0p1A)
+{
+	uint32_t u_raw = (uint32_t)voltage_v * 10u;
+	uint32_t i_raw = (uint32_t)current_0p1A * 10u;
+
+	if (u_raw > 10000u) {
+		u_raw = 10000u;
+	}
+	if (i_raw > 50000u) {
+		i_raw = 50000u;
+	}
+	PSU_TonHePutU16le(data, u_off, (uint16_t)u_raw);
+	PSU_TonHePutU16le(data, i_off, (uint16_t)i_raw);
+}
+
+static uint8_t PSU_TonHeLiveSa(void)
+{
+	if (TONHE_MODULE_ADDR != 0u) {
+		return (uint8_t)TONHE_MODULE_ADDR;
+	}
+	return tonhe_sa;
+}
+
+static uint8_t PSU_TonHeAcceptSa(uint8_t sa)
+{
+	if ((sa == 0u) || (sa == TONHE_SA_CTRL)) {
+		return 0u;
+	}
+	if (TONHE_MODULE_ADDR != 0u) {
+		return (sa == (uint8_t)TONHE_MODULE_ADDR) ? 1u : 0u;
+	}
+	if (tonhe_sa == 0u) {
+		tonhe_sa = sa;
+	}
+	return (sa == tonhe_sa) ? 1u : 0u;
+}
+
+/* PDF group mask: bit (SA-1)%24, bank (SA-1)/24. SA=4 → 08 00 00, bank 0. */
+static uint8_t PSU_TonHeFillMask(uint8_t *bytes, uint8_t sa)
+{
+	uint8_t idx;
+	uint8_t bit;
+	uint32_t k;
+
+	if (sa < 1u) {
+		sa = 1u;
+	}
+	idx = (uint8_t)(sa - 1u);
+	bit = (uint8_t)(idx % 24u);
+	k = (1uL << bit);
+	bytes[0] = (uint8_t)(k & 0xFFu);
+	bytes[1] = (uint8_t)((k >> 8) & 0xFFu);
+	bytes[2] = (uint8_t)((k >> 16) & 0xFFu);
+	return (uint8_t)((idx / 24u) & 0x0Fu);
+}
+
+static void PSU_TonHeClampUi(uint16_t *voltage_v, uint16_t *current_0p1A)
+{
+	uint16_t min_i = (uint16_t)PSU_MIN_CURRENT * 10u;
+
+	if (*voltage_v < PSU_MIN_VOLTAGE) {
+		*voltage_v = PSU_MIN_VOLTAGE;
+	}
+	if (*current_0p1A < min_i) {
+		*current_0p1A = min_i;
+	}
+}
+
+static void PSU_TonHeSendGroupUi(uint16_t voltage_v, uint16_t current_0p1A, uint8_t force)
+{
+	uint8_t data[8];
+	uint8_t sa = PSU_TonHeLiveSa();
+	uint32_t now;
+
+	if (sa == 0u) {
+		return;
+	}
+	PSU_TonHeClampUi(&voltage_v, &current_0p1A);
+	now = HAL_GetTick();
+	if (!force &&
+	    (tonhe_last_sent_v == voltage_v) &&
+	    (tonhe_last_sent_i == current_0p1A) &&
+	    ((now - tonhe_last_cmd_ms) < TONHE_CMD_MIN_MS)) {
+		return;
+	}
+
+	memset(data, 0, sizeof(data));
+	data[3] = PSU_TonHeFillMask(data, sa);
+	PSU_TonHeEncodeUi(data, 4, 6, voltage_v, current_0p1A);
+	PSU_TonHeSend(TONHE_P_UI_MASK, TONHE_PF_UI_MASK, TONHE_DA_BROADCAST, data);
+	if (force || (tonhe_last_sent_v != voltage_v) || (tonhe_last_sent_i != current_0p1A)) {
+		log_printf(LOG_INFO, "TonHe PF04 U=%u I=%u.%uA sa=%u mask=%02X\n",
+		           (unsigned)voltage_v,
+		           (unsigned)(current_0p1A / 10u),
+		           (unsigned)(current_0p1A % 10u),
+		           (unsigned)sa,
+		           (unsigned)data[0]);
+	}
+	tonhe_last_cmd_ms = now;
+	tonhe_last_sent_v = voltage_v;
+	tonhe_last_sent_i = current_0p1A;
+}
+
+static void PSU_TonHeSendGroupOnOff(uint8_t start, uint8_t force)
+{
+	uint8_t data[8];
+	uint8_t sa = PSU_TonHeLiveSa();
+	uint32_t now;
+
+	if (sa == 0u) {
+		return;
+	}
+	now = HAL_GetTick();
+	if (!force &&
+	    (tonhe_last_sent_start == start) &&
+	    ((now - tonhe_last_cmd_ms) < TONHE_CMD_MIN_MS)) {
+		return;
+	}
+
+	memset(data, 0, sizeof(data));
+	data[4] = PSU_TonHeFillMask(data, sa);
+	data[3] = start ? TONHE_CMD_START : TONHE_CMD_STOP;
+	PSU_TonHeSend(TONHE_P_GROUP_CMD, TONHE_PF_GROUP_CMD, TONHE_DA_BROADCAST, data);
+	if (force || (tonhe_last_sent_start != start)) {
+		log_printf(LOG_INFO, "TonHe PF03 %s sa=%u mask=%02X\n",
+		           start ? "AA" : "55",
+		           (unsigned)sa,
+		           (unsigned)data[0]);
+	}
+	tonhe_last_cmd_ms = now;
+	tonhe_last_sent_start = start;
+}
+
+ISR_FAST static void PSU_TonHeRx(uint32_t ext_id, uint32_t dlc, const uint8_t *rx)
+{
+	uint8_t pf;
+	uint8_t da;
+	uint8_t sa;
+
+	if (dlc < 8u) {
+		return;
+	}
+
+	pf = (uint8_t)((ext_id >> 16) & 0xFFu);
+	da = (uint8_t)((ext_id >> 8) & 0xFFu);
+	sa = (uint8_t)(ext_id & 0xFFu);
+
+	/* Group path still reports from the module SA to controller A0. */
+	if ((da != TONHE_SA_CTRL) || (PSU_TonHeAcceptSa(sa) == 0u)) {
+		return;
+	}
+
+	if (pf == TONHE_PF_STATUS) {
+		uint16_t v_raw = PSU_TonHeU16le(rx, 1);
+		uint16_t i_raw = PSU_TonHeU16le(rx, 3);
+		uint16_t v = (uint16_t)(v_raw / 10u);
+		int16_t i = (int16_t)(i_raw / 10u);
+
+		tonhe_state = rx[0];
+		tonhe_faults = PSU_TonHeU16le(rx, 5);
+		tonhe_pfc = rx[7];
+		PSU_TonHeRefreshFlags();
+
+		PSU0.online = 1u;
+		/* Niuera-style: enabled = bus up, not the ON command bit. */
+		PSU0.PSU_enabled = (v >= PSU_VOLTAGE_THRESHOLD) ? 1u : 0u;
+		can_lastpacket = HAL_GetTick();
+		/* Measured only — do not overwrite commanded U/I. */
+		psu_last_can_v = v;
+		psu_last_can_i_0p1A = (uint16_t)i;
+		PSU_ApplyOutputTelemetry(v, i, PSU0.temperature);
+	} else if (pf == TONHE_PF_AC) {
+		PSU_06.VAB = PSU_TonHeU16le(rx, 0);
+		PSU_06.VBC = PSU_TonHeU16le(rx, 2);
+		PSU_06.VCA = PSU_TonHeU16le(rx, 4);
+		PSU0.tempAmbient = PSU_TonHeU16le(rx, 6);
+		PSU0.temperature = (uint8_t)PSU0.tempAmbient;
+		can_lastpacket = HAL_GetTick();
+		PSU0.online = 1u;
+	} else if (pf == TONHE_PF_EXT) {
+		tonhe_ext_x = PSU_TonHeU16le(rx, 2);
+		tonhe_ext_valid = 1u;
+		PSU_TonHeRefreshFlags();
+		can_lastpacket = HAL_GetTick();
+		PSU0.online = 1u;
+	}
+}
+
 static void PSU_LogPeriodicDiag(void)
 {
 	static uint32_t last_log_ms;
@@ -192,7 +717,8 @@ static void PSU_MonitorStatusAndUnexpectedOff(void)
 	                (PSU0.state == PSU_CONT_WAIT_ACK_ON));
 
 	expect_on = in_charging && (CONN.EnableOutput != 0) && (PSU0.state == PSU_CONNECTED) &&
-	            !host_export_off;
+	            !host_export_off &&
+	            (!PSU_IsTonHe() || (tonhe_restart == TONHE_RESTART_IDLE));
 
 	if (!inited) {
 		prev_s0 = PSU0.status0.raw;
@@ -407,6 +933,11 @@ ISR_FAST void HAL_CAN_RxFifo1MsgPendingCallback(CAN_HandleTypeDef *hcan){
 
     if(HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO1, &RxHeader, RxData) == HAL_OK)
     {
+    	if (PSU_IsTonHe()) {
+    		PSU_TonHeRx(RxHeader.ExtId, RxHeader.DLC, RxData);
+    		return;
+    	}
+
     	memcpy(&CanId, &RxHeader.ExtId, sizeof(CanId_t));
 
 		/* Для DC30 поддерживается только один силовой модуль (source == 0) */
@@ -456,21 +987,9 @@ ISR_FAST void HAL_CAN_RxFifo1MsgPendingCallback(CAN_HandleTypeDef *hcan){
 				uint16_t v = PSU_09.moduleNVoltage / 1000;
 				int16_t  i = PSU_09.moduleNCurrent / 100;
 
-				// Обновляем модель PSU0 по телеметрии
-				PSU0.outputVoltage = v;
-				PSU0.outputCurrent = i;
-				PSU0.PSU_enabled   = (v >= PSU_VOLTAGE_THRESHOLD);
-				PSU0.online        = 1;
-				PSU0.temperature   = PSU_04.moduleTemperature;
-
-				// Экспортируем значения из PSU0 в CONN только,
-				// когда модуль хотя бы в состоянии READY и выше
-				if(PSU0.state >= PSU_READY){
-					CONN.MeasuredVoltage = PSU0.outputVoltage;
-					CONN.MeasuredCurrent = PSU0.outputCurrent;
-					CONN.Power = CONN.MeasuredCurrent * CONN.MeasuredVoltage / 10;
-					CONN.outputEnabled = PSU0.PSU_enabled;
-				}
+				PSU0.PSU_enabled = (v >= PSU_VOLTAGE_THRESHOLD);
+				PSU0.online = 1;
+				PSU_ApplyOutputTelemetry(v, i, PSU_04.moduleTemperature);
 			}
     	}
     }
@@ -510,7 +1029,27 @@ void PSU_Init(){
 	PSU0.state = PSU_UNREADY;
 	PSU0.statetick = HAL_GetTick();
 
-	PSU0.power_limit = PSU_MAX_POWER; // kW
+	psu_type = Board_GetPsuType();
+	psu_max_current_a = Board_GetPsuMaxCurrentA();
+	PSU0.power_limit = Board_GetPsuMaxPowerW();
+	psu_output_cmd_on = 0u;
+	psu_cmd_v = PSU_MIN_VOLTAGE;
+	psu_cmd_i_0p1A = (uint16_t)PSU_MIN_CURRENT * 10u;
+	psu_last_can_v = 0u;
+	psu_last_can_i_0p1A = 0u;
+	tonhe_sa = (TONHE_MODULE_ADDR != 0u) ? (uint8_t)TONHE_MODULE_ADDR : 0u;
+	tonhe_last_sent_start = 0xFFu;
+	tonhe_ext_valid = 0u;
+	tonhe_hb_tick = 0u;
+	PSU_TonHeRestartReset();
+	tonhe_run_v = PSU_MIN_VOLTAGE;
+
+	if (PSU_IsTonHe()) {
+		log_printf(LOG_INFO, "PSU proto: TonHe 30kW group SA=%u (0=discover)\n",
+		           (unsigned)TONHE_MODULE_ADDR);
+	} else {
+		log_printf(LOG_INFO, "PSU proto: Niuera type=%u\n", (unsigned)psu_type);
+	}
 
 	PSU_Enable(0, 0);
 	PowerSetpoint_Init();
@@ -523,6 +1062,21 @@ void PSU_Enable(uint8_t addr, uint8_t enable){
 	if(addr != 0) return;
 	if(PSU0.online == 0) return;
 
+	psu_output_cmd_on = enable ? 1u : 0u;
+	if (PSU_IsTonHe()) {
+		if (enable) {
+			PSU_TonHeSendGroupUi(psu_cmd_v, psu_cmd_i_0p1A, 1u);
+			ED_Delay(CAN_DELAY);
+			PSU_TonHeSendGroupOnOff(1u, 1u);
+		} else {
+			tonhe_restart = TONHE_RESTART_IDLE;
+			tonhe_run_valid = 0u;
+			PSU_TonHeSendGroupOnOff(0u, 1u);
+		}
+		ED_Delay(CAN_DELAY);
+		return;
+	}
+
 	data.enable = !enable;
 	PSU_SendCmd(0xF0, addr, 0x1A, &data);
 	ED_Delay(CAN_DELAY);
@@ -530,6 +1084,11 @@ void PSU_Enable(uint8_t addr, uint8_t enable){
 
 void PSU_SetHVMode(uint8_t addr, uint8_t enable){
 	PSU_1D_t data;
+	if (PSU_IsTonHe()) {
+		(void)addr;
+		(void)enable;
+		return;
+	}
 	memset(&data, 0, sizeof(data));
 	data.enable = !enable;
 	if(addr != 0) return;
@@ -547,6 +1106,34 @@ void PSU_SetVoltageCurrent(uint8_t addr, uint16_t voltage, uint16_t current){
 		voltage = PSU_LV_CLAMP_V;
 	}
 
+	psu_cmd_v = voltage;
+	psu_cmd_i_0p1A = current;
+
+	if (PSU_IsTonHe()) {
+		if (tonhe_restart != TONHE_RESTART_IDLE) {
+			return;
+		}
+		if (psu_output_cmd_on && tonhe_run_valid &&
+		    (PSU_TonHeIsHv(tonhe_run_v) == 0u) && PSU_TonHeIsHv(voltage)) {
+			if (PSU_TonHeCanLvHvRestart(voltage)) {
+				PSU_TonHeRestartBegin();
+			}
+			/* Keep the LV PF=04 until measured LV is real. */
+			return;
+		}
+		if (psu_output_cmd_on) {
+			PSU_TonHeSendGroupUi(voltage, current, 0u);
+			if (PSU0.PSU_enabled) {
+				tonhe_run_v = voltage;
+				tonhe_run_valid = 1u;
+			}
+		}
+		return;
+	}
+
+	psu_last_can_v = voltage;
+	psu_last_can_i_0p1A = current;
+
 	uint32_t current_ma = current * 100;
 	uint32_t voltage_mv = voltage * 1000;
 
@@ -560,8 +1147,6 @@ void PSU_SetVoltageCurrent(uint8_t addr, uint16_t voltage, uint16_t current){
 	data.moduleVoltage[2] = (voltage_mv >>   8) & 0xFF;
 	data.moduleVoltage[3] = (voltage_mv >>   0) & 0xFF;
 
-	psu_last_can_v = voltage;
-	psu_last_can_i_0p1A = current;
 	PSU_SendCmd(0xF0, addr, 0x1C, &data);
 
 }
@@ -605,10 +1190,14 @@ void PSU_ReadWrite(){
 
 	uint8_t zero_data[8] = {0,0,0,0,0,0,0,0};
 
-	PSU_SendCmd(0xF0, 0, 0x04, zero_data);ED_Delay(CAN_DELAY);
-	PSU_SendCmd(0xF0, 0, 0x06, zero_data);ED_Delay(CAN_DELAY);
-	// PSU_SendCmd(0xF0, 0, 0x08, zero_data);ED_Delay(CAN_DELAY);
-	PSU_SendCmd(0xF0, 0, 0x09, zero_data);ED_Delay(CAN_DELAY);
+	if (PSU_IsTonHe()) {
+		PSU_TonHeHeartbeat();
+	} else {
+		PSU_SendCmd(0xF0, 0, 0x04, zero_data);ED_Delay(CAN_DELAY);
+		PSU_SendCmd(0xF0, 0, 0x06, zero_data);ED_Delay(CAN_DELAY);
+		// PSU_SendCmd(0xF0, 0, 0x08, zero_data);ED_Delay(CAN_DELAY);
+		PSU_SendCmd(0xF0, 0, 0x09, zero_data);ED_Delay(CAN_DELAY);
+	}
 
 	// Power Limit
 	if ((CONN.WantedCurrent/10) * CONN.MeasuredVoltage > PSU0.power_limit){
@@ -617,8 +1206,8 @@ void PSU_ReadWrite(){
 		CONN.RequestedCurrent = CONN.WantedCurrent;
 	}
 
-	if(CONN.RequestedCurrent > (PSU_MAX_CURRENT*10)){
-		CONN.RequestedCurrent = PSU_MAX_CURRENT*10;
+	if(CONN.RequestedCurrent > (psu_max_current_a * 10u)){
+		CONN.RequestedCurrent = psu_max_current_a * 10u;
 	}
 	CONN.RequestedPower = CONN.RequestedCurrent * CONN.RequestedVoltage / 10;
 
@@ -648,6 +1237,7 @@ void PSU_Task(void){
 	static uint32_t psu_on_tick = 0;
 	static uint32_t cont_ok_tick = 0;
 	static uint32_t fd_on_last_cmd_ms = 0;
+	static uint32_t tonhe_on_retry_ms = 0;
 	PowerSetpointTryResult_t psd_result;
 
 #if PSD_ENABLE
@@ -661,13 +1251,15 @@ void PSU_Task(void){
 #endif
 
 	// Обновляем ONLINE/READY по таймауту
-	if((HAL_GetTick() - can_lastpacket) > PSU_ONLINE_TIMEOUT){
+	if((HAL_GetTick() - can_lastpacket) > (PSU_IsTonHe() ? PSU_TONHE_ONLINE_TIMEOUT : PSU_ONLINE_TIMEOUT)){
 		if (PSU0.online) {
 			log_printf(LOG_WARN, "PSU CAN timeout age=%lums -> offline\n",
 			           (unsigned long)(HAL_GetTick() - can_lastpacket));
 		}
 		PSU0.online = 0;
 		PSU0.PSU_enabled = 0;
+		tonhe_restart = TONHE_RESTART_IDLE;
+		tonhe_run_valid = 0u;
 		PSU_04.moduleTemperature = 0;
 		PSU_04.modularForm0 = 0;
 		PSU_04.modularForm1 = 0;
@@ -714,6 +1306,9 @@ void PSU_Task(void){
 		PSU0.enableOutput = 0;
 		RELAY_Write(RELAY_DC, 0);
 		if(PSU0.online && PSU0.enableAC && !PSU0.cont_fault){
+			if (PSU_IsTonHe()) {
+				PSU_Enable(0, 0);
+			}
 			PSU_SwitchState(PSU_INITIALIZING);
 		}
 		break;
@@ -738,6 +1333,7 @@ void PSU_Task(void){
 		}
 		if(CONN.EnableOutput){
 			PSU_Enable(0, 1);
+			tonhe_on_retry_ms = HAL_GetTick();
 			PSU_SwitchState(PSU_WAIT_ACK_ON);
 		}
 		break;
@@ -745,12 +1341,24 @@ void PSU_Task(void){
 	case PSU_WAIT_ACK_ON:
 
 		if(PSU0.PSU_enabled && PSU0.ready){
+			if (PSU_IsTonHe()) {
+				tonhe_run_v = tonhe_last_sent_v;
+				tonhe_run_valid = 1u;
+			}
 			PSU_SwitchState(PSU_CONT_WAIT_ACK_ON);
 		}else if(PSU_StateTime() > 10000){
 			PSU0.psu_fault = 1;
 			CONN.chargingError = CONN_ERR_PSU_FAULT;
 			PSU_SwitchState(PSU_UNREADY);
 			log_printf(LOG_ERR, "PSU on timeout\n");
+		}else if (PSU_IsTonHe() &&
+		           ((HAL_GetTick() - tonhe_on_retry_ms) >= TONHE_RESTART_RETRY_MS)) {
+			/* Retry the LV/HV start already sent — do not jump to a later HV cmd. */
+			PSU_TonHeSendGroupUi(tonhe_last_sent_v, tonhe_last_sent_i, 1u);
+			ED_Delay(CAN_DELAY);
+			PSU_TonHeSendGroupOnOff(1u, 1u);
+			psu_output_cmd_on = 1u;
+			tonhe_on_retry_ms = HAL_GetTick();
 		}
 		break;
 
@@ -774,9 +1382,19 @@ void PSU_Task(void){
 	case PSU_CONNECTED:
 		// Основное рабочее состояние
 		if(!CONN.EnableOutput || !PSU0.ready){
+			tonhe_restart = TONHE_RESTART_IDLE;
+			tonhe_run_valid = 0u;
 			PSU_SwitchState(PSU_CURRENT_DROP);
 			break;
 		}
+		if (PSU_IsTonHe() && (tonhe_restart == TONHE_RESTART_IDLE) &&
+		    PSU_TonHeCanLvHvRestart(psu_cmd_v)) {
+			PSU_TonHeRestartBegin();
+		}
+		PSU_TonHeRestartTask();
+		if (PSU0.state != PSU_CONNECTED) {
+			break;
+		}
 		// контроль контактора: 1 c таймаут
 		if (IN_ReadInput(IN_CONT_FB_DC) != RELAY_Read(RELAY_DC)){
 			if((HAL_GetTick() - cont_ok_tick) > 1000){

Core/Src/serial.c

@@ -394,6 +394,7 @@ void CCS_Init(void){
 void CCS_UpdateMaxLoadFromInfoBlock(void)
 {
 	CCS_MaxLoad.maxCurrent = Board_GetConnectorCurrentLimit_0p1A();
+	CCS_MaxLoad.maxPower = Board_GetPsuMaxPowerW();
 }
 
 ISR_FAST static uint16_t crc16_ibm(const uint8_t* data, uint16_t length) {

Core/Src/serial_control.c

@@ -70,6 +70,7 @@ InfoPacket_t infoPacket = {
 };
 
 void ReadVersion(){
+	Board_SelectInfoBlockAddress();
 	infoPacket.serialNumber = InfoBlock->serialNumber;
     infoPacket.boardVersion = InfoBlock->boardVersion;
     infoPacket.stationType = InfoBlock->stationType;