GbTModuleEV/Core/Src/connector.c

/*
 * connector.c
 *
 * All initialization before 12v_aux
 */

#include "connector.h"
#include "board.h"
#include "edcan.h"
#include <string.h>
#include <charger_gbt.h>


CONN_State_t connectorState;
CONN_t CONN;

uint8_t CC_STATE_FILTERED;

static void CONN_UpdateEdcanOutput(void);

void CONN_Init(){
	memset(&CONN, 0, sizeof(CONN));
	CONN.connControl = CMD_NONE;
	CONN_SetState(Unknown);
}

void CONN_Task(){

	switch (connectorState){
	case Unknown:
		CONN_SetState(Unplugged);
		break;

	case Disabled:
		if(CONN.chargingError == 0) {
			CONN_SetState(Unplugged);
		}
		break;
	case Unplugged: // Ожидание подключения и начала сессии
	{
		// Обновляем признак физического подключения разъёма по уровню CC
		if(CONN_CC_GetState() == GBT_CC_4V){
			CONN.EvseConnected = 1;
			CONN_SetState(AuthRequired);
		}else{
			CONN.EvseConnected = 0;
		}
		break;
	}

	case AuthRequired:
	{
		// Если уровень CC вернулся к 6/12В – считаем, что коннектор выдернули
		if(CONN_CC_GetState() != GBT_CC_4V){
			CONN_SetState(Unplugged);
			GBT_Reset();
			break;
		}

		// Как только появляется 12V AUX от станции – переходим в Preparing (инициализация протокола)
		if(IN_ReadInput(IN_0) == 1){
			CONN_SetState(Preparing);
			GBT_SwitchState(GBT_EV_CONNECTING);
		}
		break;
	}

	case Preparing:
		// Ожидаем переход стейт-машины GB/T в режим зарядки.
		// Как только GBT_State уходит в режим CHARGING – считаем, что начался заряд.
		if(GBT_State == GBT_EV_CHARGING){
			CONN_SetState(Charging);
		}
		if(IN_ReadInput(IN_0) == 0){
			CONN_SetState(Unplugged);
			GBT_Reset();
		}
		break;

	case Charging: // Активная зарядка
		// Завершение по окончанию GB/T-сессии или при падении тока/отключении AUX можно
		// добавить позже. Пока ориентируемся только на завершение GB/T.
		if(GBT_State == GBT_COMPLETE){
			CONN_SetState(Finished);
		}
		if(IN_ReadInput(IN_0) == 0){
			CONN_SetState(Finished);
		}
		break;

	case Finished: // Сессия завершена, ждём окончания и возможного переподключения
		// Когда GB/T стейт-машина полностью вернулась в исходное состояние,
		// можно считать сессию закрытой и вернуться в Unplugged.
		if(CONN_CC_GetState() != GBT_CC_4V){
			CONN_SetState(Unplugged);
			GBT_Reset();
		}
		break;

	case FinishedEV:
	case FinishedEVSE:
		CONN_SetState(Finished);
		break;
	default:
		CONN_SetState(Unknown);

	}

}


void CONN_SetState(CONN_State_t state){
	connectorState = state;
	CONN.connState = state;

	if(connectorState == Unknown) 				EDCAN_printf(LOG_INFO,"Unknown\n");
	if(connectorState == Unplugged) 			EDCAN_printf(LOG_INFO,"Unplugged\n");
	if(connectorState == Disabled) 				EDCAN_printf(LOG_INFO,"Disabled\n");
	if(connectorState == Preparing) 			EDCAN_printf(LOG_INFO,"Preparing\n");
	if(connectorState == AuthRequired) 			EDCAN_printf(LOG_INFO,"AuthRequired\n");
	if(connectorState == WaitingForEnergy) 		EDCAN_printf(LOG_INFO,"WaitingForEnergy\n");
	if(connectorState == ChargingPausedEV) 		EDCAN_printf(LOG_INFO,"ChargingPausedEV\n");
	if(connectorState == ChargingPausedEVSE) 	EDCAN_printf(LOG_INFO,"ChargingPausedEVSE\n");
	if(connectorState == Charging)				EDCAN_printf(LOG_INFO,"Charging\n");
	if(connectorState == AuthTimeout) 			EDCAN_printf(LOG_INFO,"AuthTimeout\n");
	if(connectorState == Finished)				EDCAN_printf(LOG_INFO,"Finished\n");
	if(connectorState == FinishedEVSE)			EDCAN_printf(LOG_INFO,"FinishedEVSE\n");
	if(connectorState == FinishedEV)			EDCAN_printf(LOG_INFO,"FinishedEV\n");
	if(connectorState == Replugging)			EDCAN_printf(LOG_INFO,"Replugging\n");

}


void CONN_CC_ReadStateFiltered() {
    static uint32_t last_change_time;
    static uint32_t last_check_time;
    static uint8_t prev_state;

    if((HAL_GetTick()-last_check_time)<100) return;

    last_check_time = HAL_GetTick();

    uint8_t new_state = CONN_CC_GetStateRaw();

    if (new_state != prev_state) {
        last_change_time = HAL_GetTick();
        prev_state = new_state;
    } else if ((HAL_GetTick() - last_change_time) >= 300) {
        CC_STATE_FILTERED = prev_state;
    }
}

uint8_t CONN_CC_GetState(){
	return CC_STATE_FILTERED;
}
uint8_t CONN_CC_GetStateRaw(){
	//Vref=3.3v = 4095
	//k=1/11
	//Vin = 12v
	//Vin*k= 1.09v
	//12vin = 1353 ADC
//TODO: Filter 100ms
	uint32_t adc;
	float volt;
	ADC_Select_Channel(ADC_CHANNEL_3);
	HAL_ADC_Start(&hadc1);
	HAL_ADC_PollForConversion(&hadc1, 100);
	adc = HAL_ADC_GetValue(&hadc1);
	HAL_ADC_Stop(&hadc1);

	volt = (float)adc/113.4f;
//	if((volt<12.6f) && (volt>11.4f)) return GBT_CC_12V;
//	if((volt<6.8f) && (volt>5.2f)) return GBT_CC_6V;
//	if((volt<4.8f) && (volt>3.2f)) return GBT_CC_4V;
//	if((volt<2.8f) && (volt>1.2f)) return GBT_CC_2V;
	if((volt<13.0f) && (volt>11.0f)) return GBT_CC_12V;
	if((volt<7.2f) && (volt>4.8f)) return GBT_CC_6V;
	if((volt<4.8f) && (volt>3.0f)) return GBT_CC_4V;
	if((volt<3.0f) && (volt>1.0f)) return GBT_CC_2V;
	return GBT_CC_UNKNOWN;
}

float CONN_CC_GetAdc(){
	//TODO: Filters
	//Vref=3.3v = 4095
	//k=1/11
	//Vin = 12v
	//Vin*k= 1.09v
	//12vin = 1353 ADC

	uint32_t adc;
	float volt;
	ADC_Select_Channel(ADC_CHANNEL_3);
	HAL_ADC_Start(&hadc1);
	HAL_ADC_PollForConversion(&hadc1, 100);
	adc = HAL_ADC_GetValue(&hadc1);
	HAL_ADC_Stop(&hadc1);

	volt = (float)adc/113.4f;

	return volt;
}