raduet/CCSModuleSW30Web
1
0
Fork 0
forked from achamaikin/CCSModuleSW30Web
Code Pull Requests Activity

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

Browse Source 
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
raduet
2026-09-23 14:05:53 +02:00
co-authored by Cursor
parent 644fcf1692
commit 10691b77f2
15 changed files with 10132 additions and 8832 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CCSModuleSW30Web.ioc
+6 -6
View File
@@ -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
+23 -5
View File
@@ -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
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
+17 -1
View File
@@ -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
+1 -1
View File
@@ -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
+1
View File
@@ -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
+50 -2
View File
@@ -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
+8 -3
View File
@@ -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
+3 -1
View File
@@ -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
+639 -21
View File
@@ -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;
}
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};
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
+1
View File
@@ -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
+1
View File
@@ -70,6 +70,7 @@ InfoPacket_t infoPacket = {
};
void ReadVersion(){
Board_SelectInfoBlockAddress();
infoPacket.serialNumber = InfoBlock->serialNumber;
infoPacket.boardVersion = InfoBlock->boardVersion;
infoPacket.stationType = InfoBlock->stationType;
Debug/CCSModuleSW30Web.bin
BIN
View File
Binary file not shown.
Debug/CCSModuleSW30Web.elf
BIN
View File
Binary file not shown.
Debug/CCSModuleSW30Web.hex
+4686 -4391
View File
File diff suppressed because it is too large Load Diff
Debug/CCSModuleSW30Web.srec
+4686 -4391
View File
File diff suppressed because it is too large Load Diff