#include "serial.h" #include "cp.h" #include "connector.h" #include "board.h" #include "debug.h" #include "isr_opt.h" #include #include #include "charger_config.h" #include "psu_control.h" extern UART_HandleTypeDef huart3; extern uint8_t config_initialized; static void send_state(void); static void CCS_SendResetReason(void); CCS_MaxLoad_t CCS_MaxLoad; uint32_t CCS_Power = 0; uint32_t CCS_EnergyWs = 0; uint32_t CCS_Energy = 0; uint32_t last_cmd_sent = 0; uint32_t last_stop_sent = 0; CONN_Control_t last_cmd = CMD_NONE; uint8_t ev_enable_output = 0; #define CMD_INTERVAL 10 #define MAX_TX_BUFFER_SIZE 256 #define MAX_RX_BUFFER_SIZE 256 #define EVEREST_TIMEOUT_MS 5000u #define UART3_REINIT_TIMEOUT_MS 1500u static uint8_t rx_buffer[MAX_RX_BUFFER_SIZE]; static uint8_t tx_buffer[MAX_TX_BUFFER_SIZE]; uint8_t ESTOP = 0; uint8_t REPLUG = 0; static uint8_t enabled = 0; static uint8_t pwm_duty_percent = 100; uint8_t isolation_enable = 0; static uint32_t last_host_seen = 0; static uint8_t everest_timed_out = 0; static uint32_t last_everest_timeout_log_tick = 0; static uint32_t uart3_last_packet_tick = 0; static uint32_t uart3_last_reinit_tick = 0; CCS_State_t CCS_State; CCS_EvInfo_t CCS_EvInfo; CONN_State_t CCS_EvseState; CCS_ConnectorState_t CCS_ConnectorState = CCS_UNPLUGGED; ISR_FAST static uint8_t process_received_packet(const uint8_t* packet, uint16_t packet_len); static void CCS_UART3_Watchdog(void); ISR_FAST static void uart3_log_hal_error(uint8_t uart_num, uint32_t err) { if (err == HAL_UART_ERROR_NONE) { log_printf(LOG_ERR, "UART%u HAL error decode: NONE\n", uart_num); return; } log_printf(LOG_ERR, "UART%u HAL error decode: %s%s%s%s%s%s raw=0x%08lx\n", uart_num, (err & HAL_UART_ERROR_PE) ? "PE " : "", (err & HAL_UART_ERROR_NE) ? "NE " : "", (err & HAL_UART_ERROR_FE) ? "FE " : "", (err & HAL_UART_ERROR_ORE) ? "ORE " : "", (err & HAL_UART_ERROR_DMA) ? "DMA " : "", #ifdef HAL_UART_ERROR_INVALID_CALLBACK (err & HAL_UART_ERROR_INVALID_CALLBACK) ? "INV_CB " : "", #else "", #endif (unsigned long)err); } ISR_FAST static void uart3_arm_rx_or_log(const char *where) { HAL_StatusTypeDef st = HAL_UARTEx_ReceiveToIdle_IT(&huart3, rx_buffer, sizeof(rx_buffer)); if (st == HAL_OK) { return; } uint32_t err_after = HAL_UART_GetError(&huart3); log_printf(LOG_ERR, "UART3 RX arm failed (%s): HAL_Status=%d err_after=0x%08lx\n", where, (int)st, (unsigned long)err_after); uart3_log_hal_error(3u, err_after); if (err_after != HAL_UART_ERROR_NONE) { (void)HAL_UART_Abort_IT(&huart3); } } ISR_FAST void CCS_RxEventCallback(UART_HandleTypeDef *huart, uint16_t size) { if (huart != &huart3) { log_printf(LOG_WARN, "UART3 RX drop: wrong huart in RxEventCallback (size=%u)\n", (unsigned)size); return; } if (size == 0u) { log_printf(LOG_WARN, "UART3 RX drop: RxEvent size=0 (idle, no payload)\n"); uart3_arm_rx_or_log("RxEventCallback"); return; } if (size > sizeof(rx_buffer)) { log_printf(LOG_ERR, "UART3 RX drop: size=%u > rx_buffer %u (overflow, not parsed)\n", (unsigned)size, (unsigned)sizeof(rx_buffer)); uart3_arm_rx_or_log("RxEventCallback"); return; } uart3_last_packet_tick = HAL_GetTick(); uart3_last_reinit_tick = uart3_last_packet_tick; process_received_packet(rx_buffer, size); uart3_arm_rx_or_log("RxEventCallback"); } ISR_FAST void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) { uint32_t error = HAL_UART_GetError(huart); uint8_t uart_num = (huart == &huart2) ? 2 : (huart == &huart3) ? 3 : (huart == &huart5) ? 5 : 0; log_printf(LOG_ERR, "UART%u HAL error (ISR): raw=0x%08lx — RX may be corrupted until re-arm\n", uart_num, (unsigned long)error); uart3_log_hal_error(uart_num, error); (void)HAL_UART_Abort_IT(huart); if (huart == &huart3) { uart3_arm_rx_or_log("ErrorCallback"); } } void CCS_SerialLoop(void) { static uint32_t replug_tick = 0; static uint32_t replug_watchdog_tick = 0; static uint32_t replug_watchdog1_tick = 0; static uint32_t last_state_sent = 0; if ((&huart3)->RxState == HAL_UART_STATE_READY) { uart3_arm_rx_or_log("SerialLoop"); } CCS_UART3_Watchdog(); if (CONN.connControl != CMD_NONE) { last_cmd = CONN.connControl; } if((HAL_GetTick() - last_cmd_sent) > CMD_INTERVAL){ if ((HAL_GetTick() - last_state_sent) >= 200) { send_state(); last_state_sent = HAL_GetTick(); } if (ESTOP) { log_printf(LOG_ERR, "ESTOP triggered\n"); CCS_SendEmergencyStop(); ESTOP = 0; } if (((CONN.connControl == CMD_STOP) || (CONN.chargingError != CONN_NO_ERROR)) && ((HAL_GetTick() - last_stop_sent) > 1000)) { last_stop_sent = HAL_GetTick(); log_printf(LOG_WARN, "Stopping charging...\n"); CCS_SendEmergencyStop(); } if (((CCS_EvseState == FinishedEV) || (CCS_EvseState == FinishedEVSE)) && ((HAL_GetTick() - last_stop_sent) > 1000)) { last_stop_sent = HAL_GetTick(); log_printf(LOG_WARN, "FinishedEV, stopping...\n"); CCS_SendEmergencyStop(); } } (void)replug_watchdog_tick; (void)replug_watchdog1_tick; if (!config_initialized) { // Keep connector in Unknown until host sends valid SET_CONFIG. RELAY_Write(RELAY_CP, 1); CONN_SetState(Unknown); } else { switch(CCS_ConnectorState){ case CCS_DISABLED: RELAY_Write(RELAY_CP, 0); CONN_SetState(Disabled); if (CONN.chargingError == CONN_NO_ERROR){ CCS_ConnectorState = CCS_UNPLUGGED; } break; case CCS_UNPLUGGED: 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)){ CCS_ConnectorState = CCS_AUTH_REQUIRED; } if (CONN.chargingError != CONN_NO_ERROR){ log_printf(LOG_ERR, "Charging error %d, state -> disabled\n", CONN.chargingError); CCS_ConnectorState = CCS_DISABLED; } break; case CCS_AUTH_REQUIRED: RELAY_Write(RELAY_CP, 1); CONN_SetState(AuthRequired); if(CONN.connControl == CMD_START){ log_printf(LOG_INFO, "Charging permitted, start charging\n"); CCS_ConnectorState = CCS_CONNECTED; } if (cp_state_buffer == EV_STATE_A_IDLE){ log_printf(LOG_INFO, "Car unplugged\n"); CCS_ConnectorState = CCS_UNPLUGGED; } break; case CCS_CONNECTED: RELAY_Write(RELAY_CP, 1); if(CCS_EvseState < Preparing) { CONN_SetState(Preparing); } else { CONN_SetState(CCS_EvseState); } if (cp_state_buffer == EV_STATE_A_IDLE){ log_printf(LOG_INFO, "Car unplugged\n"); CCS_ConnectorState = CCS_UNPLUGGED; } if(REPLUG > 0){ log_printf(LOG_INFO, "Replugging...\n"); CCS_ConnectorState = CCS_REPLUGGING; } break; case CCS_REPLUGGING: RELAY_Write(RELAY_CP, 0); CONN_SetState(Replugging); if((HAL_GetTick() - replug_tick) > 1000){ replug_tick = HAL_GetTick(); if(REPLUG > 0){ if (REPLUG != 0xFF) REPLUG--; } else { log_printf(LOG_INFO, "Replugging finished, but car unplugged\n"); CCS_ConnectorState = CCS_UNPLUGGED; } } if(REPLUG == 0){ if(cp_state_buffer == EV_STATE_B_CONN_PREP){ log_printf(LOG_INFO, "Replugging finished, car plugged, state -> auth required\n"); CCS_ConnectorState = CCS_AUTH_REQUIRED; } } break; } } // If Everest timeout happened, keep safe-state and limit log frequency. // The safe-state must remain until we receive a valid packet from the host. if (everest_timed_out) { if (last_everest_timeout_log_tick == 0 || (HAL_GetTick() - last_everest_timeout_log_tick) >= EVEREST_TIMEOUT_MS) { log_printf(LOG_ERR, "Everest timeout\n"); last_everest_timeout_log_tick = HAL_GetTick(); } CONN.EnableOutput = 0; CCS_EvseState = Unknown; CP_SetDuty(100); } else if (last_host_seen > 0 && (HAL_GetTick() - last_host_seen) > EVEREST_TIMEOUT_MS) { log_printf(LOG_ERR, "Everest timeout\n"); everest_timed_out = 1; last_host_seen = HAL_GetTick(); // reset after the first timeout last_everest_timeout_log_tick = HAL_GetTick(); CONN.EnableOutput = 0; CCS_EvseState = Unknown; CP_SetDuty(100); } else { if (last_cmd == CMD_STOP) { CONN.EnableOutput = 0; } else { CONN.EnableOutput = ev_enable_output ? 1 : 0; if((CONN.EnableOutput == 0) && (CONN.connState == Preparing)){ CONN.EnableOutput = 0; } } } if ((cp_state_buffer == EV_STATE_B_CONN_PREP) || (cp_state_buffer == EV_STATE_C_CONN_ACTIVE) || (cp_state_buffer == EV_STATE_D_CONN_ACT_VENT)) { CONN.EvConnected = 1; } else { CONN.EvConnected = 0; } } void CCS_Init(void){ CP_Init(); CP_SetDuty(100); CCS_MaxLoad.maxVoltage = PSU_MAX_VOLTAGE; // 1000V CCS_MaxLoad.minVoltage = PSU_MIN_VOLTAGE; //150V CCS_MaxLoad.maxCurrent = PSU_MAX_CURRENT*10; //100A CCS_MaxLoad.minCurrent = PSU_MIN_CURRENT*10; //1A CCS_MaxLoad.maxPower = PSU_MAX_POWER; //30000W uart3_last_packet_tick = HAL_GetTick(); uart3_last_reinit_tick = uart3_last_packet_tick; CCS_SendResetReason(); log_printf(LOG_INFO, "CCS init\n"); } ISR_FAST static uint16_t crc16_ibm(const uint8_t* data, uint16_t length) { uint16_t crc = 0xFFFFu; for (uint16_t i = 0; i < length; i++) { crc ^= data[i]; for (uint8_t j = 0; j < 8; j++) { if (crc & 1u) { crc = (crc >> 1) ^ 0xA001u; } else { crc >>= 1; } } } return crc; } static uint16_t CCS_BuildPacket(uint8_t cmd, const void* payload, uint16_t payload_len, uint8_t* out, uint16_t out_max) { uint16_t total_len = (uint16_t)(1u + payload_len + 2u); if (total_len > out_max) return 0; out[0] = cmd; if (payload_len && payload != NULL) { memcpy(&out[1], payload, payload_len); } uint16_t crc = crc16_ibm(out, (uint16_t)(1u + payload_len)); out[1u + payload_len] = (uint8_t)(crc & 0xFFu); out[1u + payload_len + 1u] = (uint8_t)((crc >> 8) & 0xFFu); return total_len; } static void CCS_SendPacket(uint8_t cmd, const void* payload, uint16_t payload_len) { uint16_t len = CCS_BuildPacket(cmd, payload, payload_len, tx_buffer, sizeof(tx_buffer)); if (len > 0) { HAL_UART_Transmit_IT(&huart3, tx_buffer, len); } last_cmd_sent = HAL_GetTick(); } static void CCS_SendResetReason(void) { CCS_SendPacket(CMD_M2E_RESET, NULL, 0); } void CCS_SendEmergencyStop(void) { CCS_SendPacket(CMD_M2E_ESTOP, NULL, 0); } void CCS_SendStart(void) { CCS_SendPacket(CMD_M2E_START, NULL, 0); } static void CCS_CalculateEnergy(void) { static uint32_t lastTick = 0; uint32_t currentTick = HAL_GetTick(); uint32_t elapsedTimeMs = currentTick - lastTick; lastTick = currentTick; CCS_Power = CONN.MeasuredVoltage * CONN.MeasuredCurrent / 10; CCS_EnergyWs += (CCS_Power * elapsedTimeMs) / 1000; if(CCS_EvseState == Unplugged) { CCS_EnergyWs = 0; } CCS_Energy = CCS_EnergyWs / 3600; } static void send_state(void) { CCS_CalculateEnergy(); CCS_State.DutyCycle = CP_GetDuty(); CCS_State.OutputEnabled = PSU0.CONT_enabled; CCS_State.MeasuredVoltage = (uint16_t)CONN.MeasuredVoltage; if (CONN.RequestedVoltage == 500) CCS_State.MeasuredVoltage = 500; // fake CCS_State.MeasuredCurrent = (uint16_t)CONN.MeasuredCurrent; CCS_State.Power = CCS_Power; CCS_State.Energy = CCS_Energy; if(CCS_ConnectorState == CCS_CONNECTED){ CCS_State.CpState = cp_state_buffer; } else { CCS_State.CpState = EV_STATE_A_IDLE; } CCS_State.MaxVoltage = CCS_MaxLoad.maxVoltage; CCS_State.MinVoltage = CCS_MaxLoad.minVoltage; CCS_State.MaxCurrent = CCS_MaxLoad.maxCurrent; CCS_State.MinCurrent = CCS_MaxLoad.minCurrent; CCS_State.MaxPower = CCS_MaxLoad.maxPower; CCS_State.IsolationValid = isolation_enable; CCS_State.IsolationResistance = 900000; CCS_SendPacket(CMD_M2E_STATE, &CCS_State, sizeof(CCS_State)); } ISR_FAST static uint16_t expected_payload_len(uint8_t cmd) { switch (cmd) { case CMD_E2M_PWM_DUTY: return sizeof(e2m_pwm_duty_t); case CMD_E2M_ENABLE_OUTPUT: return sizeof(e2m_enable_output_t); case CMD_E2M_RESET: return sizeof(e2m_reset_t); case CMD_E2M_ENABLE: return sizeof(e2m_enable_t); case CMD_E2M_REPLUG: return sizeof(e2m_replug_t); case CMD_E2M_SET_OUTPUT_VOLTAGE: return sizeof(e2m_set_output_t); case CMD_E2M_ISOLATION_CONTROL: return sizeof(e2m_isolation_control_t); case CMD_E2M_EV_INFO: return sizeof(CCS_EvInfo_t); case CMD_E2M_EVSE_STATE: return sizeof(CONN_State_t); case CMD_E2M_KEEP_ALIVE: return 0; default: return 0xFFFFu; } } ISR_FAST static void apply_command(uint8_t cmd, const uint8_t* payload, uint16_t payload_len) { (void)payload_len; last_host_seen = HAL_GetTick(); everest_timed_out = 0; last_everest_timeout_log_tick = 0; switch (cmd) { case CMD_E2M_PWM_DUTY: { const e2m_pwm_duty_t* p = (const e2m_pwm_duty_t*)payload; uint8_t duty = p->pwm_duty_percent; if (duty > 100) duty = 100; pwm_duty_percent = duty; CP_SetDuty(duty); break; } case CMD_E2M_ENABLE_OUTPUT: { const e2m_enable_output_t* p = (const e2m_enable_output_t*)payload; ev_enable_output = (p->enable_output != 0); break; } case CMD_E2M_RESET: { const e2m_reset_t* p = (const e2m_reset_t*)payload; if (p->reset) { log_printf(LOG_WARN, "Everest reset command\n"); // CCS_SendResetReason(); // HAL_Delay(10); // NVIC_SystemReset(); } break; } case CMD_E2M_ENABLE: { const e2m_enable_t* p = (const e2m_enable_t*)payload; enabled = (p->enable != 0); (void)enabled; break; } case CMD_E2M_SET_OUTPUT_VOLTAGE: { const e2m_set_output_t* p = (const e2m_set_output_t*)payload; CONN.RequestedVoltage = p->voltage_V; CONN.WantedCurrent = p->current_0p1A; break; } case CMD_E2M_ISOLATION_CONTROL: { const e2m_isolation_control_t* p = (const e2m_isolation_control_t*)payload; isolation_enable = p->command; break; } case CMD_E2M_EV_INFO: { memcpy(&CCS_EvInfo, payload, sizeof(CCS_EvInfo_t)); CONN.SOC = (uint8_t)(CCS_EvInfo.soc / 10); break; } case CMD_E2M_EVSE_STATE: { CCS_EvseState = (CONN_State_t)payload[0]; break; } case CMD_E2M_REPLUG: { (void)payload; CP_SetDuty(pwm_duty_percent); break; } case CMD_E2M_KEEP_ALIVE: { last_host_seen = HAL_GetTick(); break; } default: log_printf(LOG_WARN, "UART3 RX warn: cmd 0x%02x CRC/len OK but no switch case (expected_payload vs apply_command)\n", cmd); break; } } ISR_FAST static uint8_t process_received_packet(const uint8_t* packet, uint16_t packet_len) { if (packet_len < 3u) { if (packet_len == 0u) { log_printf(LOG_WARN, "UART3 RX drop: too_short len=0 (empty chunk)\n"); } else if (packet_len == 1u) { log_printf(LOG_WARN, "UART3 RX drop: too_short len=1 b0=0x%02x\n", packet[0]); } else { log_printf(LOG_WARN, "UART3 RX drop: too_short len=2 b0=0x%02x b1=0x%02x\n", packet[0], packet[1]); } return 0; } uint8_t cmd = packet[0]; uint16_t payload_len = (uint16_t)(packet_len - 3u); uint16_t received_crc = (uint16_t)packet[packet_len - 2u] | (uint16_t)packet[packet_len - 1u] << 8; uint16_t calculated_crc = crc16_ibm(packet, (uint16_t)(1u + payload_len)); if (received_crc != calculated_crc) { log_printf(LOG_ERR, "UART3 RX drop: crc_mismatch cmd=0x%02x total_len=%u payload_len=%u " "crc_rx=0x%04x crc_calc=0x%04x\n", cmd, (unsigned)packet_len, (unsigned)payload_len, (unsigned)received_crc, (unsigned)calculated_crc); return 0; } uint16_t expected_len = expected_payload_len(cmd); if (expected_len == 0xFFFFu) { log_printf(LOG_WARN, "UART3 RX drop: unknown_cmd cmd=0x%02x total_len=%u payload_len=%u\n", cmd, (unsigned)packet_len, (unsigned)payload_len); return 0; } if (expected_len != payload_len) { log_printf(LOG_ERR, "UART3 RX drop: len_mismatch cmd=0x%02x expected_payload=%u got_payload=%u " "total_len=%u\n", cmd, (unsigned)expected_len, (unsigned)payload_len, (unsigned)packet_len); return 0; } if (payload_len > 0) { apply_command(cmd, &packet[1], payload_len); } else { apply_command(cmd, NULL, 0); } return 1; } static void CCS_UART3_Watchdog(void) { const uint32_t now = HAL_GetTick(); const uint32_t since_last_packet = now - uart3_last_packet_tick; if ((since_last_packet >= UART3_REINIT_TIMEOUT_MS) && ((now - uart3_last_reinit_tick) >= UART3_REINIT_TIMEOUT_MS)) { (void)HAL_UART_Abort_IT(&huart3); (void)HAL_UART_DeInit(&huart3); (void)HAL_UART_Init(&huart3); (void)HAL_UARTEx_ReceiveToIdle_IT(&huart3, rx_buffer, sizeof(rx_buffer)); log_printf(LOG_ERR, "UART3 RX recover: stalled (no RxEvent data for %ums), hard reinit\n", (unsigned)UART3_REINIT_TIMEOUT_MS); uart3_last_reinit_tick = now; } }