Index: trunk/fw_g473rct/SES/src/ah_counter.c =================================================================== --- trunk/fw_g473rct/SES/src/ah_counter.c (revision 27) +++ trunk/fw_g473rct/SES/src/ah_counter.c (revision 28) @@ -27,4 +27,5 @@ // --- LOKALE VARIABLEN - bitte hier dokumentieren ------------------------------ int startMeasurement = 0; +int startMeasurementCEF = 0; // --- LOKALE FUNKTIONS PROTOTYPEN ---------------------------------------------- int getSocAhRated(void); @@ -97,20 +98,29 @@ + int32_t realStrom = (int32_t) sys_data.s.values.batteryCurrent - sys_data.s.parameter.extraDischargeStrom_mA; // bei Strom größer 0 -> Ladestrom CEF rechnen - if(sys_data.s.values.batteryCurrent >= 0) + if (realStrom >= 0) { //99 --> 99% --> 0.99 - cef = sys_data.s.parameter.cef / 100.0; - sys_data.s.values.batteryCurrentCorrected = sys_data.s.values.batteryCurrent * cef; - } - else + if (sys_data.s.values.calculatedCEFAh <= 0) + { + cef = sys_data.s.parameter.cef / 100.0; + } + else + { + cef = sys_data.s.values.calculatedCEFAh / 1000.0; + } + sys_data.s.values.batteryCurrentCorrected = realStrom * cef; + } + else // if (realStrom < 0) { // bei Strom kleiner 0 peukert rechnen //int32_t ratedCurrent = sys_data.s.parameter.cellRatedCurrent * 1000; int32_t ratedCurrent = sys_data.s.parameter.cellCapacity / sys_data.s.parameter.cellRatedDischargeTime; - - if (sys_data.s.values.batteryCurrent < -ratedCurrent) //ACHTUNG mit Minus das vorzeichen gedreht! + + + if (realStrom < -ratedCurrent) //ACHTUNG mit Minus das vorzeichen gedreht! { - current = sys_data.s.values.batteryCurrent; + current = realStrom; iBatDivIbatNenn = current / ratedCurrent; iBatDivIbatNenn = -iBatDivIbatNenn; @@ -119,30 +129,29 @@ sys_data.s.values.batteryCurrentCorrected = (current * calcPow); } - else sys_data.s.values.batteryCurrentCorrected = sys_data.s.values.batteryCurrent; - } - - sys_data.s.values.batteryCurrentCorrected -= (int32_t)sys_data.s.parameter.extraDischargeStrom_mA; - + else sys_data.s.values.batteryCurrentCorrected = realStrom; + } + + // Counting negative current if (sys_data.s.values.batteryCurrent < 0) { - totalDischarge += -sys_data.s.values.batteryCurrent; + totalDischarge += -realStrom; sys_data.s.values.dischargeTotalAh = totalDischarge / 3600000; //Umrechnung von mAs auf Ah - sys_data.s.values.fullCyclesCnt = (uint16_t) ((sys_data.s.values.dischargeTotalAh * 1000) / sys_data.s.parameter.cellCapacity); } else { - totalCharge += sys_data.s.values.batteryCurrent; + totalCharge += realStrom; sys_data.s.values.chargeTotalAh = totalCharge / 3600000; //Umrechnung von mAs auf Ah } - // Aufsummieren sys_data.s.values.mAsCounter += sys_data.s.values.batteryCurrentCorrected; - sys_data.s.values.mAs_AutoMode += (int64_t)sys_data.s.values.batteryCurrentCorrected; + sys_data.s.values.mAs_AutoMode += sys_data.s.values.batteryCurrentCorrected; sys_data.s.values.mAh_AutoMode = sys_data.s.values.mAs_AutoMode / 3600LL; + sys_data.s.values.ahCounterCEF_AutoMode += sys_data.s.values.batteryCurrentCorrected; + sys_data.s.values.whCounterCEF_AutoMode += sys_data.s.values.batteryCurrentCorrected * sys_data.s.values.batteryVoltage; // Begrenzen, Batterie darf nicht über 100% gehen @@ -175,8 +184,16 @@ //und wir starten eine neue Battery Kapazitäts und Energiemessung startMeasurement = 1; + + if (startMeasurementCEF == 1) + { + startMeasurementCEF=0; + sys_data.s.values.calculatedCEFAh = 1000 * (sys_data.s.values.detectedCapacity * 3600) / sys_data.s.values.ahCounterCEF_AutoMode ; + sys_data.s.values.calculatedCEFWh = 1000 * (sys_data.s.values.detectedEnergy * 3600) / sys_data.s.values.whCounterCEF_AutoMode; + } } sys_data.s.values.mAhCounter = sys_data.s.values.mAsCounter / 3600LL; + // --- BATTERY LEER ERKENNUNG static uint16_t cnt; if (sys_data.s.parameter.batteryEmptyDetectionMode == 0) @@ -191,7 +208,9 @@ if ((sys_data.s.values.lastTimeVbatFull >= 3600U) && (sys_data.s.values.lastTimeVbatFull <= 200U * 3600U)) // This line prevents from very high discharge-currents to be used to estimate battery capacity { - // This line is not so important anymore, because we do not allow mAh_AutoMode to be greater than zero + AH_COUNTER_SetDetectedAh(); WH_COUNTER_SetDetectedEnergy(); + sys_data.s.values.ahCounterCEF_AutoMode = 0; + sys_data.s.values.whCounterCEF_AutoMode = 0; startMeasurement = 0; } @@ -222,4 +241,5 @@ WH_COUNTER_SetDetectedEnergy(); startMeasurement = 0; + startMeasurementCEF = 1; } sys_data.s.values.lastTimeVbatEmpty = 0U; Index: trunk/fw_g473rct/SES/src/eeprom.c =================================================================== --- trunk/fw_g473rct/SES/src/eeprom.c (revision 27) +++ trunk/fw_g473rct/SES/src/eeprom.c (revision 28) @@ -1,3 +1,4 @@ -//https://controllerstech.com/eeprom-and-stm32/ +// https://controllerstech.com/eeprom-and-stm32/ +#include #include "eeprom.h" @@ -11,12 +12,12 @@ // Define the I2C extern I2C_HandleTypeDef hi2c3; -#define EEPROM_I2C &hi2c3 +#define EEPROM_I2C &hi2c3 // EEPROM ADDRESS (8bits) -#define EEPROM_ADDR 0xA0 +#define EEPROM_ADDR 0xA0 // Define the Page Size and number of pages -#define PAGE_SIZE 64 // in Bytes -#define PAGE_NUM 4096 // number of pages +#define PAGE_SIZE 64 // in Bytes +#define PAGE_NUM 4096 // number of pages @@ -103,4 +104,8 @@ uint16_t cefW; int16_t batteryEmptyDetectionMode; + uint16_t auxOutputMode; + uint16_t auxOutputSetpointOn; + uint16_t auxOutputSetpointOff; + uint16_t auxOutputInverted; } eeprom_data_t; @@ -138,19 +143,16 @@ - - - // Data to store reated defines -//#define SIZEOF_DEFAULT_EEPROM_DATA (sizeof(eeprom_new_data_t)) -#define SIZEOF_CHANGED_EEPROM_DATA (sizeof(eeprom_data_t)) -#define SIZEOF_DEVICE_INFO (sizeof(device_info_t)) -#define SIZEOF_EEPROM_STATE (sizeof(eeprom_state_t)) - -#define SIZE_OF_DATA_TO_STORE (SIZEOF_CHANGED_EEPROM_DATA + SIZEOF_DEVICE_INFO + SIZEOF_EEPROM_STATE) +//#define SIZEOF_DEFAULT_EEPROM_DATA (sizeof(eeprom_new_data_t)) +//#define SIZEOF_CHANGED_EEPROM_DATA (sizeof(eeprom_data_t)) +//#define SIZEOF_DEVICE_INFO (sizeof(device_info_t)) +//#define SIZEOF_EEPROM_STATE (sizeof(eeprom_state_t)) + +//#define SIZE_OF_DATA_TO_STORE (SIZEOF_CHANGED_EEPROM_DATA + SIZEOF_DEVICE_INFO + SIZEOF_EEPROM_STATE) // Adress related defines #define EEPROM_ADRESS_FIRST_START_ID (0) -#define FIRST_START_ID (0xFF) +#define FIRST_START_ID (0xFF) // See datasheet (Chapter "Initial delivery state") #define CONFIG_ID (01) // Increment by 1 to make compartible update, more than 1 - incompartible #if CONFIG_ID == FIRST_START_ID @@ -166,7 +168,5 @@ - -// muss modulo 8 noch hinzufügen wg 8 byte alignement -static uint8_t eepromData[SIZE_OF_DATA_TO_STORE]; +static eeprom_stored_data_t eepromData; @@ -261,6 +261,8 @@ /* cefW */ 90, // 90% cef for Wh calculations /* Battery Empty Detection Mode*/ 1, // Auto, from BMS - - + /* AUX MODE */ AUX_MODE_HEATER,// Heizung + /* AUX SETPOINT ON */ 13600, // Erkennung Ladegerät ab 13,6V + /* AUX SETPOINT OFF */ 100, // Batterie Entladung wird erkannt bei -100mA + /* AUX Inverted */ 0, // Nicht invertiert }; @@ -281,6 +283,5 @@ uint8_t firstStartCatcher; - EEPROM_Read(0,EEPROM_ADRESS_FIRST_START_ID, &firstStartCatcher, 1); - + EEPROM_Read(0, EEPROM_ADRESS_FIRST_START_ID, &firstStartCatcher, 1); if (firstStartCatcher == FIRST_START_ID) @@ -306,100 +307,26 @@ HAL_StatusTypeDef EEPROM_fullRestore(sys_data_t* data) { - eeprom_stored_data_t* dataToStore; printf("EEPROM FULL RESTORE!\n"); /**************** LESE_DEFAULT_WERTE ************************/ - dataToStore = (eeprom_stored_data_t*) eepromData; - - // Schnittstellenparameter - dataToStore->changedData.baudrate = defaultEepromData.baudrate; - dataToStore->changedData.parityMode = defaultEepromData.parityMode; - dataToStore->changedData.stopBits = defaultEepromData.stopBits; - dataToStore->changedData.slave_adress = defaultEepromData.slave_adress; - - // Offset und Gain - dataToStore->changedData.batteryCurrentOffsetRefTemperatureShunt = defaultEepromData.batteryCurrentOffsetRefTemperatureShunt; - dataToStore->changedData.batteryCurrentOffsetRefTemperatureChip = defaultEepromData.batteryCurrentOffsetRefTemperatureChip; - dataToStore->changedData.batteryCurrentGainRefTempShunt = defaultEepromData.batteryCurrentGainRefTempShunt; - dataToStore->changedData.batteryCurrentGainRefTempChip = defaultEepromData.batteryCurrentGainRefTempChip; - dataToStore->changedData.batteryCurrentOffsetTemperatureCalibrationTemperature = defaultEepromData.batteryCurrentOffsetTemperatureCalibrationTemperature; - dataToStore->changedData.batteryCurrentGainTemperatureCalibrationShuntTemperature = defaultEepromData.batteryCurrentGainTemperatureCalibrationShuntTemperature; - dataToStore->changedData.batteryCurrentGainTemperatureCalibrationChipTemperature = defaultEepromData.batteryCurrentGainTemperatureCalibrationChipTemperature; - dataToStore->changedData.batteryCurrentOffsetRefshuntVoltage = defaultEepromData.batteryCurrentOffsetRefshuntVoltage; - dataToStore->changedData.batteryCurrentOffsetCommonModeCalibrationVoltage = defaultEepromData.batteryCurrentOffsetCommonModeCalibrationVoltage; - dataToStore->changedData.batteryCurrentOffsetCommonModeCompensationFactor = defaultEepromData.batteryCurrentOffsetCommonModeCompensationFactor; - dataToStore->changedData.batteryCurrentOffsetTemperatureCompensationFactor = defaultEepromData.batteryCurrentOffsetTemperatureCompensationFactor; - dataToStore->changedData.batteryCurrentGainRefCurrent = defaultEepromData.batteryCurrentGainRefCurrent; - dataToStore->changedData.batteryCurrentGainTemperatureCompensationShuntFactor = defaultEepromData.batteryCurrentGainTemperatureCompensationShuntFactor; - dataToStore->changedData.batteryCurrentGainTemperatureCompensationChipFactor = defaultEepromData.batteryCurrentGainTemperatureCompensationChipFactor; - - dataToStore->changedData.currentOffset = defaultEepromData.currentOffset; - dataToStore->changedData.currentGain = defaultEepromData.currentGain; - - dataToStore->changedData.currentOffsetFast = defaultEepromData.currentOffsetFast; - dataToStore->changedData.currentGainFast = defaultEepromData.currentGainFast; - - // AH Counter Parameter - dataToStore->changedData.cef = defaultEepromData.cef; - dataToStore->changedData.peukert = defaultEepromData.peukert; - dataToStore->changedData.cellCapacity = defaultEepromData.cellCapacity; - dataToStore->changedData.cellEnergy = defaultEepromData.cellEnergy; - dataToStore->changedData.iBatFull = defaultEepromData.iBatFull; - dataToStore->changedData.tBatFull = defaultEepromData.tBatFull; - dataToStore->changedData.uBatFull = defaultEepromData.uBatFull; - dataToStore->changedData.uBatEmpty = defaultEepromData.uBatEmpty; - dataToStore->changedData.socCalcMode = defaultEepromData.socCalcMode; - dataToStore->changedData.cellRatedDischargeTime = defaultEepromData.cellRatedDischargeTime; - - // Schaltausgänge - dataToStore->changedData.lvpStart = defaultEepromData.lvpStart; - dataToStore->changedData.lvpStop = defaultEepromData.lvpStop; - dataToStore->changedData.ovpStart = defaultEepromData.ovpStart; - dataToStore->changedData.ovpStop = defaultEepromData.ovpStop; - dataToStore->changedData.loadCurrentLimit = defaultEepromData.loadCurrentLimit; - dataToStore->changedData.chargeCurrentLimit = defaultEepromData.chargeCurrentLimit; - dataToStore->changedData.chargeStopHighTemperatureStart = defaultEepromData.chargeStopHighTemperatureStart; - dataToStore->changedData.chargeStopHighTemperatureStop = defaultEepromData.chargeStopHighTemperatureStop; - dataToStore->changedData.chargeStopLowTemperatureStart = defaultEepromData.chargeStopLowTemperatureStart; - dataToStore->changedData.chargeStopLowTemperatureStop = defaultEepromData.chargeStopLowTemperatureStop; - dataToStore->changedData.dischargeStopHighTemperatureStart = defaultEepromData.dischargeStopHighTemperatureStart; - dataToStore->changedData.dischargeStopHighTemperatureStop = defaultEepromData.dischargeStopHighTemperatureStop; - dataToStore->changedData.dischargeStopLowTemperatureStart = defaultEepromData.dischargeStopLowTemperatureStart; - dataToStore->changedData.dischargeStopLowTemperatureStop = defaultEepromData.dischargeStopLowTemperatureStop; - - dataToStore->changedData.uBatEmptyCompStartTemp = defaultEepromData.uBatEmptyCompStartTemp; - dataToStore->changedData.uBatEmptyCompStopTemp = defaultEepromData.uBatEmptyCompStopTemp; - dataToStore->changedData.uBatEmptyCompStopVolt = defaultEepromData.uBatEmptyCompStopVolt; - - dataToStore->changedData.extraDischargeStrom_mA = defaultEepromData.extraDischargeStrom_mA; - dataToStore->changedData.cefW = defaultEepromData.cefW; - dataToStore->changedData.batteryEmptyDetectionMode = defaultEepromData.batteryEmptyDetectionMode; - - + memcpy(&eepromData.changedData, &defaultEepromData, sizeof(eeprom_data_t)); // Eeprom Status Infos - dataToStore->eepromState.writeCounter++; - dataToStore->eepromState.structureSize = sizeof(eeprom_stored_data_t); - dataToStore->eepromState.revisionInfo = 0; - dataToStore->eepromState.firstStartId = CONFIG_ID; - - - /****************EEPROM Speichern********************/ - - EEPROM_Write(0, 0, (uint8_t*)eepromData, SIZE_OF_DATA_TO_STORE); - - - - + eepromData.eepromState.writeCounter++; + eepromData.eepromState.structureSize = sizeof(eeprom_stored_data_t); + eepromData.eepromState.revisionInfo = 0; + eepromData.eepromState.firstStartId = CONFIG_ID; + + /**************** EEPROM Speichern ********************/ + + EEPROM_Write(0, 0, (uint8_t*)&eepromData, sizeof(eeprom_stored_data_t)); /**************** AUSLESEN_UND_PRÜFEN ********************/ return EEPROM_readConfig(data); - - - -} - +} + +//------------------------------------------------------------------------------ //Werkeinstellung ohne Kalibrierwert Überschreibung @@ -407,94 +334,92 @@ { printf("EEPROM FACTORY RESTORE/UPDATE!\n"); - - - eeprom_stored_data_t* dataToStore = (eeprom_stored_data_t*)eepromData; - - EEPROM_readConfig(data); // Restoring calibration data + //eeprom_stored_data_t* dataToStore = &eepromData; + + EEPROM_readConfig(data); // Restoring calibration data // Offset und Gain - dataToStore->changedData.batteryCurrentOffsetRefTemperatureShunt = data->s.parameter.batteryCurrentOffsetRefTemperatureShunt; - dataToStore->changedData.batteryCurrentOffsetRefTemperatureChip = data->s.parameter.batteryCurrentOffsetRefTemperatureChip; - dataToStore->changedData.batteryCurrentOffsetRefshuntVoltage = data->s.parameter.batteryCurrentOffsetRefshuntVoltage; - dataToStore->changedData.batteryCurrentOffsetCommonModeCalibrationVoltage = data->s.parameter.batteryCurrentOffsetCommonModeCalibrationVoltage; - dataToStore->changedData.batteryCurrentOffsetCommonModeCompensationFactor = data->s.parameter.batteryCurrentOffsetCommonModeCompensationFactor; - dataToStore->changedData.batteryCurrentOffsetTemperatureCalibrationTemperature = data->s.parameter.batteryCurrentOffsetTemperatureCalibrationTemperature; - dataToStore->changedData.batteryCurrentOffsetTemperatureCompensationFactor = data->s.parameter.batteryCurrentOffsetTemperatureCompensationFactor; - dataToStore->changedData.currentOffset = data->s.parameter.batteryCurrentOffset; - dataToStore->changedData.currentGain = data->s.parameter.batteryCurrentGainCorrectionFaktor; - dataToStore->changedData.currentOffsetFast = data->s.parameter.batteryCurrentOffsetFast; - dataToStore->changedData.currentGainFast = data->s.parameter.batteryCurrentGainCorrectionFaktorFast; + eepromData.changedData.batteryCurrentOffsetRefTemperatureShunt = data->s.parameter.batteryCurrentOffsetRefTemperatureShunt; + eepromData.changedData.batteryCurrentOffsetRefTemperatureChip = data->s.parameter.batteryCurrentOffsetRefTemperatureChip; + eepromData.changedData.batteryCurrentOffsetRefshuntVoltage = data->s.parameter.batteryCurrentOffsetRefshuntVoltage; + eepromData.changedData.batteryCurrentOffsetCommonModeCalibrationVoltage = data->s.parameter.batteryCurrentOffsetCommonModeCalibrationVoltage; + eepromData.changedData.batteryCurrentOffsetCommonModeCompensationFactor = data->s.parameter.batteryCurrentOffsetCommonModeCompensationFactor; + eepromData.changedData.batteryCurrentOffsetTemperatureCalibrationTemperature = data->s.parameter.batteryCurrentOffsetTemperatureCalibrationTemperature; + eepromData.changedData.batteryCurrentOffsetTemperatureCompensationFactor = data->s.parameter.batteryCurrentOffsetTemperatureCompensationFactor; + eepromData.changedData.currentOffset = data->s.parameter.batteryCurrentOffset; + eepromData.changedData.currentGain = data->s.parameter.batteryCurrentGainCorrectionFaktor; + eepromData.changedData.currentOffsetFast = data->s.parameter.batteryCurrentOffsetFast; + eepromData.changedData.currentGainFast = data->s.parameter.batteryCurrentGainCorrectionFaktorFast; - dataToStore->changedData.batteryCurrentGainRefTempShunt = data->s.parameter.batteryCurrentGainRefTempShunt; - dataToStore->changedData.batteryCurrentGainRefTempChip = data->s.parameter.batteryCurrentGainRefTempChip; - dataToStore->changedData.batteryCurrentGainRefCurrent = data->s.parameter.batteryCurrentGainRefCurrent; - dataToStore->changedData.batteryCurrentGainTemperatureCalibrationShuntTemperature = data->s.parameter.batteryCurrentGainTemperatureCalibrationShuntTemperature; - dataToStore->changedData.batteryCurrentGainTemperatureCompensationShuntFactor = data->s.parameter.batteryCurrentGainTemperatureCompensationShuntFactor; - dataToStore->changedData.batteryCurrentGainTemperatureCalibrationChipTemperature = data->s.parameter.batteryCurrentGainTemperatureCalibrationChipTemperature; - dataToStore->changedData.batteryCurrentGainTemperatureCompensationChipFactor = data->s.parameter.batteryCurrentGainTemperatureCompensationChipFactor; + eepromData.changedData.batteryCurrentGainRefTempShunt = data->s.parameter.batteryCurrentGainRefTempShunt; + eepromData.changedData.batteryCurrentGainRefTempChip = data->s.parameter.batteryCurrentGainRefTempChip; + eepromData.changedData.batteryCurrentGainRefCurrent = data->s.parameter.batteryCurrentGainRefCurrent; + eepromData.changedData.batteryCurrentGainTemperatureCalibrationShuntTemperature = data->s.parameter.batteryCurrentGainTemperatureCalibrationShuntTemperature; + eepromData.changedData.batteryCurrentGainTemperatureCompensationShuntFactor = data->s.parameter.batteryCurrentGainTemperatureCompensationShuntFactor; + eepromData.changedData.batteryCurrentGainTemperatureCalibrationChipTemperature = data->s.parameter.batteryCurrentGainTemperatureCalibrationChipTemperature; + eepromData.changedData.batteryCurrentGainTemperatureCompensationChipFactor = data->s.parameter.batteryCurrentGainTemperatureCompensationChipFactor; // Schnittstellenparameter - dataToStore->changedData.baudrate = defaultEepromData.baudrate; - dataToStore->changedData.parityMode = defaultEepromData.parityMode; - dataToStore->changedData.stopBits = defaultEepromData.stopBits; - dataToStore->changedData.slave_adress = defaultEepromData.slave_adress; - dataToStore->changedData.ibn_day = defaultEepromData.ibn_day; - dataToStore->changedData.ibn_month = defaultEepromData.ibn_month; - dataToStore->changedData.ibn_year = defaultEepromData.ibn_year; - dataToStore->changedData.user_id = defaultEepromData.user_id; + eepromData.changedData.baudrate = defaultEepromData.baudrate; + eepromData.changedData.parityMode = defaultEepromData.parityMode; + eepromData.changedData.stopBits = defaultEepromData.stopBits; + eepromData.changedData.slave_adress = defaultEepromData.slave_adress; + eepromData.changedData.ibn_day = defaultEepromData.ibn_day; + eepromData.changedData.ibn_month = defaultEepromData.ibn_month; + eepromData.changedData.ibn_year = defaultEepromData.ibn_year; + eepromData.changedData.user_id = defaultEepromData.user_id; //Ah counter - dataToStore->changedData.cef = defaultEepromData.cef; - dataToStore->changedData.cellCapacity = defaultEepromData.cellCapacity; - dataToStore->changedData.cellEnergy = defaultEepromData.cellEnergy; - dataToStore->changedData.iBatFull = defaultEepromData.iBatFull; - dataToStore->changedData.peukert = defaultEepromData.peukert; - dataToStore->changedData.tBatFull = defaultEepromData.tBatFull; - dataToStore->changedData.uBatFull = defaultEepromData.uBatFull; - dataToStore->changedData.uBatEmpty = defaultEepromData.uBatEmpty; - dataToStore->changedData.socCalcMode = defaultEepromData.socCalcMode; - dataToStore->changedData.cellRatedDischargeTime = defaultEepromData.cellRatedDischargeTime; + eepromData.changedData.cef = defaultEepromData.cef; + eepromData.changedData.cellCapacity = defaultEepromData.cellCapacity; + eepromData.changedData.cellEnergy = defaultEepromData.cellEnergy; + eepromData.changedData.iBatFull = defaultEepromData.iBatFull; + eepromData.changedData.peukert = defaultEepromData.peukert; + eepromData.changedData.tBatFull = defaultEepromData.tBatFull; + eepromData.changedData.uBatFull = defaultEepromData.uBatFull; + eepromData.changedData.uBatEmpty = defaultEepromData.uBatEmpty; + eepromData.changedData.socCalcMode = defaultEepromData.socCalcMode; + eepromData.changedData.cellRatedDischargeTime = defaultEepromData.cellRatedDischargeTime; // Schaltausgänge - dataToStore->changedData.lvpStart = defaultEepromData.lvpStart; - dataToStore->changedData.lvpStop = defaultEepromData.lvpStop; - dataToStore->changedData.ovpStart = defaultEepromData.ovpStart; - dataToStore->changedData.ovpStop = defaultEepromData.ovpStop; - dataToStore->changedData.loadCurrentLimit = defaultEepromData.loadCurrentLimit; - dataToStore->changedData.chargeCurrentLimit = defaultEepromData.chargeCurrentLimit; - dataToStore->changedData.chargeStopHighTemperatureStart = defaultEepromData.chargeStopHighTemperatureStart; - dataToStore->changedData.chargeStopHighTemperatureStop = defaultEepromData.chargeStopHighTemperatureStop; - dataToStore->changedData.chargeStopLowTemperatureStart = defaultEepromData.chargeStopLowTemperatureStart; - dataToStore->changedData.chargeStopLowTemperatureStop = defaultEepromData.chargeStopLowTemperatureStop; - dataToStore->changedData.dischargeStopHighTemperatureStart = defaultEepromData.dischargeStopHighTemperatureStart; - dataToStore->changedData.dischargeStopHighTemperatureStop = defaultEepromData.dischargeStopHighTemperatureStop; - dataToStore->changedData.dischargeStopLowTemperatureStart = defaultEepromData.dischargeStopLowTemperatureStart; - dataToStore->changedData.dischargeStopLowTemperatureStop = defaultEepromData.dischargeStopLowTemperatureStop; - - dataToStore->changedData.uBatEmptyCompStartTemp = defaultEepromData.uBatEmptyCompStartTemp; - dataToStore->changedData.uBatEmptyCompStopTemp = defaultEepromData.uBatEmptyCompStopTemp; - dataToStore->changedData.uBatEmptyCompStopVolt = defaultEepromData.uBatEmptyCompStopVolt; - - dataToStore->changedData.extraDischargeStrom_mA = defaultEepromData.extraDischargeStrom_mA; - dataToStore->changedData.cefW = defaultEepromData.cefW; - dataToStore->changedData.batteryEmptyDetectionMode = defaultEepromData.batteryEmptyDetectionMode; + eepromData.changedData.lvpStart = defaultEepromData.lvpStart; + eepromData.changedData.lvpStop = defaultEepromData.lvpStop; + eepromData.changedData.ovpStart = defaultEepromData.ovpStart; + eepromData.changedData.ovpStop = defaultEepromData.ovpStop; + eepromData.changedData.loadCurrentLimit = defaultEepromData.loadCurrentLimit; + eepromData.changedData.chargeCurrentLimit = defaultEepromData.chargeCurrentLimit; + eepromData.changedData.chargeStopHighTemperatureStart = defaultEepromData.chargeStopHighTemperatureStart; + eepromData.changedData.chargeStopHighTemperatureStop = defaultEepromData.chargeStopHighTemperatureStop; + eepromData.changedData.chargeStopLowTemperatureStart = defaultEepromData.chargeStopLowTemperatureStart; + eepromData.changedData.chargeStopLowTemperatureStop = defaultEepromData.chargeStopLowTemperatureStop; + eepromData.changedData.dischargeStopHighTemperatureStart = defaultEepromData.dischargeStopHighTemperatureStart; + eepromData.changedData.dischargeStopHighTemperatureStop = defaultEepromData.dischargeStopHighTemperatureStop; + eepromData.changedData.dischargeStopLowTemperatureStart = defaultEepromData.dischargeStopLowTemperatureStart; + eepromData.changedData.dischargeStopLowTemperatureStop = defaultEepromData.dischargeStopLowTemperatureStop; + + eepromData.changedData.uBatEmptyCompStartTemp = defaultEepromData.uBatEmptyCompStartTemp; + eepromData.changedData.uBatEmptyCompStopTemp = defaultEepromData.uBatEmptyCompStopTemp; + eepromData.changedData.uBatEmptyCompStopVolt = defaultEepromData.uBatEmptyCompStopVolt; + + eepromData.changedData.extraDischargeStrom_mA = defaultEepromData.extraDischargeStrom_mA; + eepromData.changedData.cefW = defaultEepromData.cefW; + eepromData.changedData.batteryEmptyDetectionMode = defaultEepromData.batteryEmptyDetectionMode; + eepromData.changedData.auxOutputMode = defaultEepromData.auxOutputMode; + eepromData.changedData.auxOutputSetpointOn = defaultEepromData.auxOutputSetpointOn; + eepromData.changedData.auxOutputSetpointOff = defaultEepromData.auxOutputSetpointOff; + eepromData.changedData.auxOutputInverted = defaultEepromData.auxOutputInverted; - - - - dataToStore->eepromState.writeCounter = dataToStore->eepromState.writeCounter++; - dataToStore->eepromState.structureSize = sizeof(eeprom_stored_data_t); - dataToStore->eepromState.revisionInfo = 0; - dataToStore->eepromState.firstStartId = CONFIG_ID; - - dataToStore->deviceInfo.deviceInfoWritten = 1; - dataToStore->deviceInfo.SN = data->s.parameter.sn; - - EEPROM_Write(0,0, (uint8_t*)dataToStore, SIZE_OF_DATA_TO_STORE); - - + eepromData.eepromState.writeCounter = eepromData.eepromState.writeCounter++; + eepromData.eepromState.structureSize = sizeof(eeprom_stored_data_t); + eepromData.eepromState.revisionInfo = 0; + eepromData.eepromState.firstStartId = CONFIG_ID; + + eepromData.deviceInfo.deviceInfoWritten = 1; + eepromData.deviceInfo.SN = data->s.parameter.sn; + + EEPROM_Write(0,0, (uint8_t*)&eepromData, sizeof(eeprom_stored_data_t)); + return EEPROM_readConfig(data); } @@ -505,5 +430,5 @@ /****************LESE_WERTE_AUS_SYSDATA*********************/ printf("EEPROM STORE CONFIG!\n"); - dataToStore = (eeprom_stored_data_t*) eepromData; + dataToStore = (eeprom_stored_data_t*)&eepromData; // Schnittstellenparameter @@ -578,4 +503,9 @@ dataToStore->changedData.batteryEmptyDetectionMode = data->s.parameter.batteryEmptyDetectionMode; + dataToStore->changedData.auxOutputMode = data->s.parameter.auxOutputMode; + dataToStore->changedData.auxOutputSetpointOn = data->s.parameter.auxOutputSetpointOn; + dataToStore->changedData.auxOutputSetpointOff = data->s.parameter.auxOutputSetpointOff; + dataToStore->changedData.auxOutputInverted = data->s.parameter.auxOutputInverted; + // Eeprom Status Infos dataToStore->eepromState.writeCounter++; @@ -591,5 +521,5 @@ - EEPROM_Write(0,0, (uint8_t*)dataToStore, SIZE_OF_DATA_TO_STORE); + EEPROM_Write(0,0, (uint8_t*)dataToStore, sizeof(eeprom_stored_data_t)); return EEPROM_readConfig(data); @@ -605,8 +535,8 @@ - EEPROM_Read(0, 0, (uint8_t*)eepromData, sizeof(eepromData)); - - - dataToStore = (eeprom_stored_data_t*)eepromData; + EEPROM_Read(0, 0, (uint8_t*)&eepromData, sizeof(eepromData)); + + + dataToStore = (eeprom_stored_data_t*)&eepromData; // Schnittstellenparameter @@ -680,6 +610,11 @@ data->s.parameter.cefW = dataToStore->changedData.cefW; data->s.parameter.batteryEmptyDetectionMode = dataToStore->changedData.batteryEmptyDetectionMode; + + data->s.parameter.auxOutputMode = dataToStore->changedData.auxOutputMode; + data->s.parameter.auxOutputSetpointOn = dataToStore->changedData.auxOutputSetpointOn; + data->s.parameter.auxOutputSetpointOff = dataToStore->changedData.auxOutputSetpointOff; + data->s.parameter.auxOutputInverted = dataToStore->changedData.auxOutputInverted; + - // Geräteinformation @@ -719,4 +654,5 @@ } +//----------------------------------------------------------------------------- void EEPROM_Read (uint16_t page, uint16_t offset, uint8_t *data, uint16_t size) @@ -735,5 +671,8 @@ uint16_t MemAddress = startPage< onv) && (sys_data.s.values.ovp_sense < LVP_DETECTION_LEVEL) && (outputState == 0)) + { + printf("Heater on\r\n"); + outputState = 1; + if (sys_data.s.parameter.auxOutputInverted == 0) + { + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_SET); + } + else + { + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET); + } + + } + + //Ausschalten + //Wenn Spannung am Shunt < setpoint (ladegeräteerkennung 14,8V?) und Entladung + //Oder wenn OVP wieder da ist + //sys_data.s.values.batteryCurrent < sys_data.s.parameter.auxOutputSetpointOff + + if ((sys_data.s.values.shuntVoltage < offv ) || (sys_data.s.values.ovp_sense > LVP_DETECTION_LEVEL)) + { + if (outputState == 1) + { + printf("Heater off\r\n"); + outputState = 0; + if (sys_data.s.parameter.auxOutputInverted == 0) + { + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET); + } + else + { + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_SET); + } + } + } +} + +void AuxModeSOCExec(void) +{ + static int outputState=0; + + + if ((sys_data.s.values.soc > (sys_data.s.parameter.auxOutputSetpointOn*1000)) && (outputState == 0)) + { + printf("AUX on (SOC Mode)\r\n"); + outputState = 1; + if (sys_data.s.parameter.auxOutputInverted == 0) + { + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_SET); + } + else + { + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET); + } + + } + + + if ((sys_data.s.values.soc < (sys_data.s.parameter.auxOutputSetpointOff*1000)) && (outputState == 1)) + { + printf("AUX off (SOC Mode)\r\n"); + outputState = 0; + if (sys_data.s.parameter.auxOutputInverted == 0) + { + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET); + } + else + { + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_SET); + } + } + + +} + + + int16_t loadCurrentLimit; // 30 maximaler Laststrom in A wenn der Strom grer ist als der eingestelle Wert dann wird die Laststrom Protection aktiv, darf nicht unsigned sein, da Entladestrom mit Minus angegeben [A] Default -500 A + int16_t chargeCurrentLimit; // 31 maximaler Ladestrom in A wenn der Strom grer ist als der eingestelle Wert dann wird die Ladestrom Protection aktiv [A] Default:500A + + + int16_t chargeStopHighTemperatureStart; // 32 Abschalttemperatur Ladung wegen zu hoher Temperatur [C * 100] + int16_t chargeStopHighTemperatureStop; // 33 Wiedereinschalttemperatur [C * 100] + + int16_t chargeStopLowTemperatureStart; // 34 Abschalttemperatur Ladung wegen zu niedriger Temperatur [C * 100] + int16_t chargeStopLowTemperatureStop; // 35 Wiedereinschalttemperatur [C * 100] + + int16_t dischargeStopHighTemperatureStart; // 36 Abschalttemperatur Entladung wegen zu hoher Temperatur [C * 100] + int16_t dischargeStopHighTemperatureStop; // 37 Wiedereinschalttemperatur[C * 100] + + int16_t dischargeStopLowTemperatureStart; // 38 Abschalttemperatur EntLadung wegen zu niedriger Temperatur + int16_t dischargeStopLowTemperatureStop; // 39 Wiedereinschalttemperatur + + + +void AuxModeAlarmExec(void) +{ + static int outputState=0; + + + if ( + (sys_data.s.values.shuntTemperature > (chargeStopHighTemperatureStart - 500)) || + (sys_data.s.values.chipTemperature > (chargeStopHighTemperatureStart - 500)) || + (sys_data.s.values.shuntTemperature < (chargeStopLowTemperatureStart + 500)) || + (sys_data.s.values.chipTemperature < (chargeStopLowTemperatureStart + 500)) || + (sys_data.s.values.shuntTemperature > (dischargeStopHighTemperatureStart - 500)) || + (sys_data.s.values.chipTemperature > (dischargeStopHighTemperatureStart - 500)) || + (sys_data.s.values.shuntTemperature < (dischargeStopLowTemperatureStart + 500)) || + (sys_data.s.values.chipTemperature < (dischargeStopLowTemperatureStart + 500)) || + (sys_data.s.values.batteryCurrent > ((chargeCurrentLimit*1000LL) - 10000)) || + (sys_data.s.values.batteryCurrent < ((loadCurrentLimit*1000LL) + 10000)) + + ) + { + if ( outputState == 0) + { + printf("AUX on (Alarm Mode)\r\n"); + outputState = 1; + if (sys_data.s.parameter.auxOutputInverted == 0) + { + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_SET); + } + else + { + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET); + } + } + } + else // Alles OK + { + if ( outputState == 0) + { + printf("AUX off (Alarm Mode)\r\n"); + outputState = 0; + if (sys_data.s.parameter.auxOutputInverted == 0) + { + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET); + } + else + { + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_SET); + } + } + } +} + + +void OUTPUTS_CheckAUX(void) +{ + + switch (sys_data.s.parameter.auxOutputMode) + { + case AUX_MODE_OFF: + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET); + break; + + case AUX_MODE_HEATER: + AuxModeHeaterExec(); + break; + + case AUX_MODE_SOC: + AuxModeSOCExec(); + break; + + case AUX_MODE_ALARM: + AuxModeAlarmExec(); + break; + + + default: + HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET); + break; + + + } + + +} + /*************************** End of file ****************************/ Index: trunk/fw_g473rct/SES/src/sysdata.c =================================================================== --- trunk/fw_g473rct/SES/src/sysdata.c (revision 27) +++ trunk/fw_g473rct/SES/src/sysdata.c (revision 28) @@ -55,6 +55,6 @@ sys_data.s.values.message[0] = 'a'; sys_data.s.values.message[1] = 'b'; - sys_data.s.values.message[18] = 'y'; - sys_data.s.values.message[19] = 'z'; + sys_data.s.values.message[22] = 'y'; + sys_data.s.values.message[23] = 'z'; } Index: trunk/fw_g473rct/SES/src/wh_counter.c =================================================================== --- trunk/fw_g473rct/SES/src/wh_counter.c (revision 27) +++ trunk/fw_g473rct/SES/src/wh_counter.c (revision 28) @@ -41,12 +41,24 @@ if (totalCharge == 0) totalCharge = sys_data.s.values.chargeTotalWh * 3600000; + double cefwh; + if (sys_data.s.values.calculatedCEFWh < 0) + { + cefwh = sys_data.s.parameter.cef / 100.0; + } + else + { + cefwh = sys_data.s.values.calculatedCEFWh / 1000.0; + } + + double realStrom; + realStrom = (int32_t) sys_data.s.values.batteryCurrent - sys_data.s.parameter.extraDischargeStrom_mA; + //------------ separater CEF ----------- // bei Strom größer 0 -> Ladestrom CEF rechnen - if (sys_data.s.values.batteryCurrent >= 0) { - // 99 --> 99% --> 0.99 - int32_t cefW = sys_data.s.parameter.cefW; - sys_data.s.values.correctedStromForChargeWhCnt = (sys_data.s.values.batteryCurrent * cefW) / 100; - sys_data.s.values.correctedStromForChargeWhCnt -= sys_data.s.parameter.extraDischargeStrom_mA; - } else { + if (realStrom >= 0) {// 99 --> 99% --> 0.99 + sys_data.s.values.correctedStromForChargeWhCnt = (realStrom * cefwh) ; + } + else + { sys_data.s.values.correctedStromForChargeWhCnt = sys_data.s.values.batteryCurrentCorrected; } @@ -150,4 +162,5 @@ return (int32_t)SoC; } + int32_t WH_COUNTER_GetSoCAutoTemp(void) { @@ -171,4 +184,5 @@ // dazu zunächst den Mittelwert der noch verbleibenden Spannung vom aktuellen Zeitpunkt bis zur Abschaltung ermittelndazu int64_t avgVoltage = (sys_data.s.values.batteryVoltage + sys_data.s.values.uBatEmptyTempComp) / 2; + //Jetzt mit der verbleibene Kapazität die verbleibene Energie unter den aktuellen Bedingungen ermitteln (Spannung bei akt. Temp)