From c7d660a762857864e73ffccf17627a5c620da6e3 Mon Sep 17 00:00:00 2001 From: Terekhin Alexandr Date: Thu, 6 Jul 2023 00:30:01 +0300 Subject: [PATCH] New data, complete initialization --- can/can.go | 42 ++++ yabl/protocol.go | 537 ++++++++++++++++++++++++++++++++++++++++++++++- yabl/setters.go | 270 +++++++++++++++++++++++- yabl/strings.go | 12 ++ 4 files changed, 859 insertions(+), 2 deletions(-) diff --git a/can/can.go b/can/can.go index f441dc4..1bc6b6e 100644 --- a/can/can.go +++ b/can/can.go @@ -13,8 +13,29 @@ import ( const CAN_ID_071 = 0x071 const CAN_ID_073 = 0x073 +const CAN_ID_074 = 0x074 +const CAN_ID_075 = 0x075 const CAN_ID_021 = 0x021 const CAN_ID_022 = 0x022 +const CAN_ID_023 = 0x023 +const CAN_ID_011 = 0x011 +const CAN_ID_014 = 0x014 +const CAN_ID_015 = 0x015 +const CAN_ID_016 = 0x016 +const CAN_ID_01A = 0x01A +const CAN_ID_02A = 0x02A +const CAN_ID_041 = 0x041 +const CAN_ID_042 = 0x042 +const CAN_ID_046 = 0x046 +const CAN_ID_047 = 0x047 +const CAN_ID_048 = 0x048 +const CAN_ID_049 = 0x049 +const CAN_ID_067 = 0x067 +const CAN_ID_068 = 0x068 +const CAN_ID_06C = 0x06C +const CAN_ID_061 = 0x061 +const CAN_ID_062 = 0x062 +const CAN_ID_065 = 0x065 type CanFrame struct { CanId uint32 @@ -109,8 +130,29 @@ func StartCan(canbus string) (<-chan *CanFrame, error) { var filter []unix.CanFilter = []unix.CanFilter{ {Id: CAN_ID_071, Mask: 0xFFF}, {Id: CAN_ID_073, Mask: 0xFFF}, + {Id: CAN_ID_074, Mask: 0xFFF}, + {Id: CAN_ID_075, Mask: 0xFFF}, {Id: CAN_ID_021, Mask: 0xFFF}, {Id: CAN_ID_022, Mask: 0xFFF}, + {Id: CAN_ID_011, Mask: 0xFFF}, + {Id: CAN_ID_014, Mask: 0xFFF}, + {Id: CAN_ID_015, Mask: 0xFFF}, + {Id: CAN_ID_016, Mask: 0xFFF}, + {Id: CAN_ID_01A, Mask: 0xFFF}, + {Id: CAN_ID_023, Mask: 0xFFF}, + {Id: CAN_ID_02A, Mask: 0xFFF}, + {Id: CAN_ID_041, Mask: 0xFFF}, + {Id: CAN_ID_042, Mask: 0xFFF}, + {Id: CAN_ID_046, Mask: 0xFFF}, + {Id: CAN_ID_047, Mask: 0xFFF}, + {Id: CAN_ID_048, Mask: 0xFFF}, + {Id: CAN_ID_049, Mask: 0xFFF}, + {Id: CAN_ID_067, Mask: 0xFFF}, + {Id: CAN_ID_068, Mask: 0xFFF}, + {Id: CAN_ID_06C, Mask: 0xFFF}, + {Id: CAN_ID_061, Mask: 0xFFF}, + {Id: CAN_ID_062, Mask: 0xFFF}, + {Id: CAN_ID_065, Mask: 0xFFF}, } if socket, err := NewCan(); err == nil { diff --git a/yabl/protocol.go b/yabl/protocol.go index a0915c3..a242201 100644 --- a/yabl/protocol.go +++ b/yabl/protocol.go @@ -3,11 +3,14 @@ package yabl import ( "cli-mon/can" "encoding/binary" + "time" ) const ( + CONVERTERS_MAX = 18 + 1 CONTACTOR_MAX = 18 + 1 - CONNECTOR_MAX = 6 + 1 + CONNECTOR_COUNT = 6 + CONNECTOR_MAX = CONNECTOR_COUNT + 1 ALL_BITS = 0xFFFFFFFFFFFFFFFF UNIT_ID_OFFSET = 12 UNIT_ID_MASK = 0b111111111111 << UNIT_ID_OFFSET @@ -81,6 +84,19 @@ type ContactorInternalErrors struct { CpuNotReady ErrorType PuNotReady ErrorType Debug BooleanType + PresentContactorMode ContactorModeType +} + +type ContactorsInternalForce struct { + UnitId uint + ForceModeEnabled BooleanType + ForceModeValue ForceModeType +} + +type ContactorInternalDebug struct { + UnitId uint + DebugModeOn BooleanType + DebugContactorOn DebugSwitchModeType } type PuPresentEnergy struct { @@ -117,6 +133,12 @@ type LogicEnergyMode struct { PowerMax Power14BitType } +type LogicErrors struct { + UnitId uint + BoardReady BoardReadyType + NotReadySettings ErrorType +} + type LogicWorkingMode struct { UnitId uint TargetContactorMode ContactorModeType @@ -216,6 +238,89 @@ type SeccErrors struct { NotReadyLogic ErrorType } +type PeripheryState struct { + UnitId uint + OtherErrorSeverity BoardReadyType + OtherError OtherError4BitType + ErrorShakeSensor ErrorType + ErrorCoolingGroup ErrorType + PeripheryErrorCoolingGroup ErrorType + ErrorFireEmergency ErrorType + ErrorFireEmergencyRun ErrorType + ErrorFireEmergencyControl ErrorType + ErrorOvervoltageIn ErrorType + PeripheryErrorPowerSupply ErrorType + ErrorFan ErrorType + ErrorOvervoltageOut ErrorType + ErrorStateRemoteMode ErrorType + DebugShsnFanEnabled BooleanType + DebugShptFanEnabled BooleanType + DebugIoBoardTestLampEnabled BooleanType + ErrorFireEmergencyCircuitBreaker ErrorType + ErrorExtLightCircuitBreaker ErrorType + ErrorIndicationCircuitBreaker ErrorType + ErrorLowVoltagePowerCircuitBreaker ErrorType + ErrorContactorsInternalCircuitBreaker ErrorType + ErrorPlcCircuitBreaker ErrorType +} + +type PeripheryInfo struct { + UnitId uint + InfoDoorOpen BooleanType + TempAirIn SignedAirTemp8BitType + TempAirOut SignedAirTemp8BitType + StateShsnFan BooleanType + StateShptFan BooleanType +} + +type PeripheryDebug struct { + UnitId uint + DebugModeOn BooleanType + DebugShsnFan DebugSwitchModeType + DebugShptFan DebugSwitchModeType + DebugIoBoardTestLamp DebugSwitchModeType +} + +type ConverterPresentEnergy struct { + UnitId uint + V2gMode V2GModeType + PresentVoltage Voltage11BitType + PresentCurrent Current10BitType + ConnectedOut ConnectedOut8bitType +} + +type ConverterErrors struct { + UnitId uint + BoardReady BoardReadyType + OtherError OtherError4BitType + NotConnectedOut ErrorType + NoCommunicationConverter ErrorType + NoCommunicationPuConverter ErrorType + InputGridVoltageHigh ErrorType + InputGridVoltageLow ErrorType + OutputGridVoltageHigh ErrorType + OutputGridVoltageLow ErrorType + InputGridVoltage Voltage11BitType + OutputGridVoltage Voltage11BitType + ShortCircuit ErrorType + OverHeat ErrorType + FanBroken ErrorType + OtherHardwareError ErrorType + DebugConvEnabled BooleanType + DebugConvDisabled BooleanType +} + +type ConverterDebug struct { + UnitId uint + DebugModeOn BooleanType + DebugEnergyOn DebugSwitchModeType + DebugTargetVoltage Voltage11BitType + DebugTargetCurrent Current10BitType +} + +type SignedAirTemp8BitType int +type ConnectedOut8bitType uint +type ForceModeType uint type SignedVoltage12bitType int type DebugSwitchModeType uint type OtherError4BitType uint @@ -235,6 +340,400 @@ type CpLineLevelType uint type IsolationStateType uint type Voltage9BitType float32 +type parameters struct { + fields []content + interval uint +} + +type content struct { + length uint8 + setter func(uint64 uint64) + value uint64 + last time.Time +} + +type key struct { + canId, unitId uint +} + +var protocolMap map[key]parameters +var cpuPresentEnergyArray [CONNECTOR_MAX]*CpuPresentEnergy +var cpuPeripheryInstance *CpuPeriphery +var cpuEnergySettingsArray [CONNECTOR_MAX]*CpuEnergySettings +var cpuErrorsInstance *CpuErrors +var cpuDebugInstance *CpuDebug +var puPresentEnergyArray [CONNECTOR_MAX]*PuPresentEnergy +var puPeripheryArray [CONNECTOR_MAX]*PuPeriphery +var puErrorsArray [CONNECTOR_MAX]*PuErrors +var puDebugArray [CONNECTOR_MAX]*PuDebug +var seccTargetEnergyArray [CONNECTOR_MAX]*SeccTargetEnergy +var seccErrorsArray [CONNECTOR_MAX]*SeccErrors +var logicAuthArray [CONNECTOR_MAX]*LogicAuth +var logicEnergyMode [CONNECTOR_MAX]*LogicEnergyMode +var logicErrorsInstance *LogicErrors +var logicWorkingMode *LogicWorkingMode +var contactorInternalStateArray [CONNECTOR_MAX]*ContactorInternalState +var contactorInternalErrorsInstance *ContactorInternalErrors +var contactorsInternalForce *ContactorsInternalForce +var contactorInternalDebugArray [CONNECTOR_MAX]*ContactorInternalDebug +var peripheryStateArray [CONNECTOR_MAX]*PeripheryState +var peripheryInfoArray [CONNECTOR_MAX]*PeripheryInfo +var peripheryDebugArray [CONNECTOR_MAX]*PeripheryDebug +var converterPresentEnergyArray [CONVERTERS_MAX]*ConverterPresentEnergy +var converterErrorsArray [CONVERTERS_MAX]*ConverterErrors +var converterDebugArray [CONVERTERS_MAX]*ConverterDebug + +func init() { + for i := 1; i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_011, uint(i)} + cpe := CpuPresentEnergy{} + cpuPresentEnergyArray[i] = &cpe + fields := []content{ + {length: 2, setter: cpe.setPowerDirectionMode}, + {length: 10, setter: cpe.setPresentCurrent}, + {length: 11, setter: cpe.setPresentVoltage}, + } + protocolMap[key] = parameters{fields: fields, interval: 50} + } + + cpuPeripheryInstance = &CpuPeriphery{} + fields := []content{ + {length: 2, setter: cpuPeripheryInstance.setContactorInput}, + {length: 2, setter: cpuPeripheryInstance.setCircuitBreakerInput}, + {length: 2, setter: cpuPeripheryInstance.setCircuitBreakerPowerCBInput}, + } + protocolMap[key{can.CAN_ID_014, 0}] = parameters{fields: fields, interval: 1000} + + for i := 0; i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_015, uint(i)} + ces := CpuEnergySettings{} + cpuEnergySettingsArray[i] = &ces + fields := []content{ + {length: 10, setter: ces.setCurrentMax}, + {length: 11, setter: ces.setVoltageMax}, + {length: 14, setter: ces.setPowerMax}, + {length: 11, setter: ces.setTargetBatteryVoltage}, + {length: 11, setter: ces.setTargetGoalVoltage}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } + + cpuErrorsInstance = &CpuErrors{} + fields = []content{ + {length: 3, setter: cpuErrorsInstance.setBoardReady}, + {length: 4, setter: cpuErrorsInstance.setOtherError}, + {length: 2, setter: cpuErrorsInstance.setRedButtonHard}, + {length: 2, setter: cpuErrorsInstance.setRedButtonSoft}, + {length: 2, setter: cpuErrorsInstance.setModulesGone}, + {length: 2, setter: cpuErrorsInstance.setGridVoltageHighErr}, + {length: 2, setter: cpuErrorsInstance.setGridVoltageHighWarn}, + {length: 2, setter: cpuErrorsInstance.setGridVoltageLowWarn}, + {length: 2, setter: cpuErrorsInstance.setGridVoltageLowErr}, + {length: 11, setter: cpuErrorsInstance.setGridVoltageLow}, + {length: 11, setter: cpuErrorsInstance.setGridVoltageHigh}, + {length: 2, setter: cpuErrorsInstance.setGridVoltageEmpty}, + {length: 2, setter: cpuErrorsInstance.setNotReadySecc}, + {length: 2, setter: cpuErrorsInstance.setNotReadyPu}, + {length: 2, setter: cpuErrorsInstance.setNotReadyContactors}, + {length: 2, setter: cpuErrorsInstance.setDebugConvertersEnabled}, + {length: 2, setter: cpuErrorsInstance.setContactorInputError}, + {length: 2, setter: cpuErrorsInstance.setNotReadyPeriphery}, + } + protocolMap[key{can.CAN_ID_016, 0}] = parameters{fields: fields, interval: 1000} + + cpuDebugInstance = &CpuDebug{} + fields = []content{ + {length: 2, setter: cpuDebugInstance.setDebugModeOn}, + {length: 3, setter: cpuDebugInstance.setDebugContactorInputOn}, + {length: 3, setter: cpuDebugInstance.setDebugCircuitBreakerOn}, + {length: 3, setter: cpuDebugInstance.setDebugRedButtonSoftware}, + } + protocolMap[key{can.CAN_ID_01A, 0}] = parameters{fields: fields, interval: 1000} + + for i := 1; i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_021, uint(i)} + ppe := PuPresentEnergy{} + puPresentEnergyArray[i] = &ppe + fields := []content{ + {length: 2, setter: ppe.setV2GMode}, + {length: 11, setter: ppe.setVoltageBefore}, + {length: 11, setter: ppe.setVoltageAfter}, + {length: 10, setter: ppe.setPresentCurrent}, + } + protocolMap[key] = parameters{fields: fields, interval: 50} + } + + for i := 1; i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_022, uint(i)} + pp := PuPeriphery{} + puPeripheryArray[i] = &pp + fields := []content{ + {length: 2, setter: pp.setConnectorInsert}, + {length: 2, setter: pp.setContactorOn}, + {length: 2, setter: pp.setConnectorLocked}, + {length: 3, setter: pp.setCpLineLevel}, + {length: 3, setter: pp.setIsolationState}, + {length: 2, setter: pp.setChargingAllowed}, + {length: 2, setter: pp.setPwmEnabled}, + {length: 9, setter: pp.setCpLineVoltage}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } + + for i := 1; i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_023, uint(i)} + pe := PuErrors{} + puErrorsArray[i] = &pe + fields := []content{ + {length: 3, setter: pe.setBoardReady}, + {length: 4, setter: pe.setOtherError}, + {length: 2, setter: pe.setIncorrectVoltage}, + {length: 11, setter: pe.setIncorrectVoltageValue}, + {length: 2, setter: pe.setIncorrectCurrent}, + {length: 10, setter: pe.setIncorrectCurrentValue}, + {length: 2, setter: pe.setIsolationBroken}, + {length: 2, setter: pe.setCpLineBroken}, + {length: 2, setter: pe.setCpLineGap69}, + {length: 3, setter: pe.setCableReady}, + {length: 2, setter: pe.setNotReadyCpu}, + {length: 2, setter: pe.setNotReadySecc}, + {length: 2, setter: pe.setContactorOutputError}, + {length: 2, setter: pe.setDebugContactorOutputEnabled}, + {length: 2, setter: pe.setOutputCircuitBreakerEnabled}, + {length: 12, setter: pe.setOutputCircuitBreakerEnabledValue}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } + + for i := 0; i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_02A, uint(i)} + pd := PuDebug{} + puDebugArray[i] = &pd + fields = []content{ + {length: 2, setter: pd.setDebugModeOn}, + {length: 3, setter: pd.setDebugContactorOutputOn}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } + + for i := 1; i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_041, uint(i)} + ste := SeccTargetEnergy{} + seccTargetEnergyArray[i] = &ste + fields = []content{ + {length: 2, setter: ste.setTargetChargingAllow}, + {length: 11, setter: ste.setTargetBatteryVoltage}, + {length: 11, setter: ste.setTargetGoalVoltage}, + {length: 10, setter: ste.setTargetCurrent}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } + + for i := 1; i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_042, uint(i)} + se := SeccErrors{} + seccErrorsArray[i] = &se + fields = []content{ + {length: 3, setter: se.setBoardReady}, + {length: 2, setter: se.setNotReadyLogic}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } + + for i := 0; i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_046, uint(i)} + la := LogicAuth{} + logicAuthArray[i] = &la + fields = []content{ + {length: 2, setter: la.setAuthMode}, + {length: 3, setter: la.setAuthState}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } + + for i := 0; i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_047, uint(i)} + la := LogicEnergyMode{} + logicEnergyMode[i] = &la + fields = []content{ + {length: 2, setter: la.setV2gMode}, + {length: 10, setter: la.setCurrentMax}, + {length: 11, setter: la.setVoltageMax}, + {length: 14, setter: la.setPowerMax}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } + + logicErrorsInstance = &LogicErrors{} + fields = []content{ + {length: 3, setter: logicErrorsInstance.setBoardReady}, + {length: 2, setter: logicErrorsInstance.setNotReadySettings}, + } + protocolMap[key{can.CAN_ID_048, 0}] = parameters{fields: fields, interval: 1000} + + logicWorkingMode = &LogicWorkingMode{} + fields = []content{ + {length: 5, setter: logicWorkingMode.setTargetContactorMode}, + {length: 2, setter: logicWorkingMode.setAvailability}, + } + protocolMap[key{can.CAN_ID_049, 0}] = parameters{fields: fields, interval: 1000} + + for i := 0; i <= CONTACTOR_MAX; i++ { + key := key{can.CAN_ID_071, uint(i)} + cis := ContactorInternalState{} + contactorInternalStateArray[i] = &cis + fields = []content{ + {length: 3, setter: cis.setContactorReady}, + {length: 2, setter: cis.setContactorOn}, + {length: 2, setter: cis.setUnexpectedState}, + {length: 2, setter: cis.setIsolated}, + {length: 2, setter: cis.setDebugEnabled}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } + + contactorInternalErrorsInstance = &ContactorInternalErrors{} + fields = []content{ + {length: 3, setter: contactorInternalErrorsInstance.setBoardReady}, + {length: 4, setter: contactorInternalErrorsInstance.setOtherError}, + {length: 3, setter: contactorInternalErrorsInstance.setContactorGroupChanged}, + {length: 4, setter: contactorInternalErrorsInstance.setUnexpectedFormation}, + {length: 2, setter: contactorInternalErrorsInstance.setCpuNotReady}, + {length: 2, setter: contactorInternalErrorsInstance.setPuNotReady}, + {length: 2, setter: contactorInternalErrorsInstance.setDebug}, + {length: 5, setter: contactorInternalErrorsInstance.setPresentContactorMode}, + } + protocolMap[key{can.CAN_ID_073, 0}] = parameters{fields: fields, interval: 1000} + + contactorsInternalForce = &ContactorsInternalForce{} + fields = []content{ + {length: 2, setter: contactorsInternalForce.setForceModeEnabled}, + {length: 4, setter: contactorsInternalForce.setForceModeValue}, + } + protocolMap[key{can.CAN_ID_074, 0}] = parameters{fields: fields, interval: 1000} + + for i := 0; i <= CONTACTOR_MAX; i++ { + key := key{can.CAN_ID_075, uint(i)} + cid := ContactorInternalDebug{} + contactorInternalDebugArray[i] = &cid + fields = []content{ + {length: 2, setter: cid.setDebugModeOn}, + {length: 3, setter: cid.setDebugContactorOn}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } + + for i := 0; i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_067, uint(i)} + ps := PeripheryState{} + peripheryStateArray[i] = &ps + fields = []content{ + {length: 3, setter: ps.setOtherErrorSeverity}, + {length: 4, setter: ps.setOtherError}, + {length: 2, setter: ps.setErrorShakeSensor}, + {length: 2, setter: ps.setErrorCoolingGroup}, + {length: 2, setter: ps.setPeripheryErrorCoolingGroup}, + {length: 2, setter: ps.setErrorFireEmergency}, + {length: 2, setter: ps.setErrorFireEmergencyRun}, + {length: 2, setter: ps.setErrorFireEmergencyControl}, + {length: 2, setter: ps.setErrorOvervoltageIn}, + {length: 2, setter: ps.setPeripheryErrorPowerSupply}, + {length: 2, setter: ps.setErrorFan}, + {length: 2, setter: ps.setErrorOvervoltageOut}, + {length: 2, setter: ps.setErrorStateRemoteMode}, + {length: 2, setter: ps.setDebugShsnFanEnabled}, + {length: 2, setter: ps.setDebugShptFanEnabled}, + {length: 2, setter: ps.setDebugIoBoardTestLampEnabled}, + {length: 2, setter: ps.setErrorFireEmergencyCircuitBreaker}, + {length: 2, setter: ps.setErrorExtLightCircuitBreaker}, + {length: 2, setter: ps.setErrorIndicationCircuitBreaker}, + {length: 2, setter: ps.setErrorLowVoltagePowerCircuitBreaker}, + {length: 2, setter: ps.setErrorContactorsInternalCircuitBreaker}, + {length: 2, setter: ps.setErrorPlcCircuitBreaker}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } + + for i := 0; i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_068, uint(i)} + pi := PeripheryInfo{} + peripheryInfoArray[i] = &pi + fields = []content{ + {length: 2, setter: pi.setInfoDoorOpen}, + {length: 8, setter: pi.setTempAirIn}, + {length: 8, setter: pi.setTempAirOut}, + {length: 2, setter: pi.setStateShsnFan}, + {length: 2, setter: pi.setStateShptFan}, + } + protocolMap[key] = parameters{fields: fields, interval: 5000} + } + + for i := 0; i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_06C, uint(i)} + pd := PeripheryDebug{} + peripheryDebugArray[i] = &pd + fields = []content{ + {length: 2, setter: pd.setDebugModeOn}, + {length: 3, setter: pd.setDebugShsnFan}, + {length: 3, setter: pd.setDebugShptFan}, + {length: 3, setter: pd.setDebugIoBoardTestLamp}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } + + for i := 1; i <= CONVERTERS_MAX; i++ { + key := key{can.CAN_ID_061, uint(i)} + cpe := ConverterPresentEnergy{} + converterPresentEnergyArray[i] = &cpe + fields = []content{ + {length: 2, setter: cpe.setV2gMode}, + {length: 11, setter: cpe.setPresentVoltage}, + {length: 10, setter: cpe.setPresentCurrent}, + {length: 8, setter: cpe.setConnectedOut}, + } + protocolMap[key] = parameters{fields: fields, interval: 500} + } + + for i := 1; i <= CONVERTERS_MAX; i++ { + key := key{can.CAN_ID_062, uint(i)} + ce := ConverterErrors{} + converterErrorsArray[i] = &ce + fields = []content{ + {length: 3, setter: ce.setBoardReady}, + {length: 4, setter: ce.setOtherError}, + {length: 2, setter: ce.setNotConnectedOut}, + {length: 2, setter: ce.setNoCommunicationConverter}, + {length: 2, setter: ce.setNoCommunicationPuConverter}, + {length: 2, setter: ce.setInputGridVoltageHigh}, + {length: 2, setter: ce.setInputGridVoltageLow}, + {length: 2, setter: ce.setOutputGridVoltageHigh}, + {length: 2, setter: ce.setOutputGridVoltageLow}, + {length: 11, setter: ce.setInputGridVoltage}, + {length: 11, setter: ce.setOutputGridVoltage}, + {length: 2, setter: ce.setShortCircuit}, + {length: 2, setter: ce.setOverHeat}, + {length: 2, setter: ce.setFanBroken}, + {length: 2, setter: ce.setOtherHardwareError}, + {length: 2, setter: ce.setDebugConvEnabled}, + {length: 2, setter: ce.setDebugConvDisabled}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } + + for i := 0; i <= CONVERTERS_MAX; i++ { + key := key{can.CAN_ID_065, uint(i)} + cd := ConverterDebug{} + converterDebugArray[i] = &cd + fields = []content{ + {length: 3, setter: cd.setDebugModeOn}, + {length: 4, setter: cd.setDebugEnergyOn}, + {length: 2, setter: cd.setDebugTargetVoltage}, + {length: 2, setter: cd.setDebugTargetCurrent}, + } + protocolMap[key] = parameters{fields: fields, interval: 1000} + } +} + func StartProtocolParsing(frames <-chan *can.CanFrame) <-chan Packet { result := make(chan Packet) @@ -423,6 +922,10 @@ func (l *LogicEnergyMode) GetUnitId() uint { return l.UnitId } +func (l *LogicErrors) GetUnitId() uint { + return l.UnitId +} + func (l *LogicWorkingMode) GetUnitId() uint { return l.UnitId } @@ -462,3 +965,35 @@ func (s *SeccTargetEnergy) GetUnitId() uint { func (e *SeccErrors) GetUnitId() uint { return e.UnitId } + +func (c *ContactorsInternalForce) GetUnitId() uint { + return c.UnitId +} + +func (c *ContactorInternalDebug) GetUnitId() uint { + return c.UnitId +} + +func (p *PeripheryState) GetUnitId() uint { + return p.UnitId +} + +func (p *PeripheryInfo) GetUnitId() uint { + return p.UnitId +} + +func (p *PeripheryDebug) GetUnitId() uint { + return p.UnitId +} + +func (c *ConverterPresentEnergy) GetUnitId() uint { + return c.UnitId +} + +func (c *ConverterErrors) GetUnitId() uint { + return c.UnitId +} + +func (c *ConverterDebug) GetUnitId() uint { + return c.UnitId +} diff --git a/yabl/setters.go b/yabl/setters.go index 1c74445..00ca94a 100644 --- a/yabl/setters.go +++ b/yabl/setters.go @@ -48,6 +48,10 @@ func (t *ContactorInternalErrors) setDebug(val uint64) { t.Debug = BooleanType(val) } +func (t *ContactorInternalErrors) setPresentContactorMode(val uint64) { + t.PresentContactorMode = ContactorModeType(val) +} + func (t *PuPresentEnergy) setV2GMode(val uint64) { t.V2GMode = V2GModeType(val) } @@ -93,7 +97,7 @@ func (t *PuPeriphery) setPwmEnabled(val uint64) { } func (t *PuPeriphery) setCpLineVoltage(val uint64) { - t.CpLineVoltage = Voltage9BitType(val) + t.CpLineVoltage = Voltage9BitType(val)/10 - 15 } func (t *LogicAuth) setAuthMode(val uint64) { @@ -339,3 +343,267 @@ func (e *SeccErrors) setBoardReady(val uint64) { func (e *SeccErrors) setNotReadyLogic(val uint64) { e.NotReadyLogic = ErrorType(val) } + +func (l *LogicEnergyMode) setV2gMode(val uint64) { + l.V2gMode = V2GModeType(val) +} + +func (l *LogicEnergyMode) setCurrentMax(val uint64) { + l.CurrentMax = Current10BitType(val) +} + +func (l *LogicEnergyMode) setVoltageMax(val uint64) { + l.VoltageMax = Voltage11BitType(val) +} + +func (l *LogicEnergyMode) setPowerMax(val uint64) { + l.PowerMax = Power14BitType(val * 100) +} + +func (l *LogicErrors) setBoardReady(val uint64) { + l.BoardReady = BoardReadyType(val) +} + +func (l *LogicErrors) setNotReadySettings(val uint64) { + l.NotReadySettings = ErrorType(val) +} + +func (c *ContactorsInternalForce) setForceModeEnabled(val uint64) { + c.ForceModeEnabled = BooleanType(val) +} + +func (c *ContactorsInternalForce) setForceModeValue(val uint64) { + c.ForceModeValue = ForceModeType(val) +} + +func (c *ContactorInternalDebug) setDebugModeOn(val uint64) { + c.DebugModeOn = BooleanType(val) +} + +func (c *ContactorInternalDebug) setDebugContactorOn(val uint64) { + c.DebugContactorOn = DebugSwitchModeType(val) +} + +func (p *PeripheryState) setOtherErrorSeverity(val uint64) { + p.OtherErrorSeverity = BoardReadyType(val) +} + +func (p *PeripheryState) setOtherError(val uint64) { + p.OtherError = OtherError4BitType(val) +} + +func (p *PeripheryState) setErrorShakeSensor(val uint64) { + p.ErrorShakeSensor = ErrorType(val) +} + +func (p *PeripheryState) setErrorCoolingGroup(val uint64) { + p.ErrorCoolingGroup = ErrorType(val) +} + +func (p *PeripheryState) setPeripheryErrorCoolingGroup(val uint64) { + p.PeripheryErrorCoolingGroup = ErrorType(val) +} + +func (p *PeripheryState) setErrorFireEmergency(val uint64) { + p.ErrorFireEmergency = ErrorType(val) +} + +func (p *PeripheryState) setErrorFireEmergencyRun(val uint64) { + p.ErrorFireEmergencyRun = ErrorType(val) +} + +func (p *PeripheryState) setErrorFireEmergencyControl(val uint64) { + p.ErrorFireEmergencyControl = ErrorType(val) +} + +func (p *PeripheryState) setErrorOvervoltageIn(val uint64) { + p.ErrorOvervoltageIn = ErrorType(val) +} + +func (p *PeripheryState) setPeripheryErrorPowerSupply(val uint64) { + p.PeripheryErrorPowerSupply = ErrorType(val) +} + +func (p *PeripheryState) setErrorFan(val uint64) { + p.ErrorFan = ErrorType(val) +} + +func (p *PeripheryState) setErrorOvervoltageOut(val uint64) { + p.ErrorOvervoltageOut = ErrorType(val) +} + +func (p *PeripheryState) setErrorStateRemoteMode(val uint64) { + p.ErrorStateRemoteMode = ErrorType(val) +} + +func (p *PeripheryState) setDebugShsnFanEnabled(val uint64) { + p.DebugShsnFanEnabled = BooleanType(val) +} + +func (p *PeripheryState) setDebugShptFanEnabled(val uint64) { + p.DebugShptFanEnabled = BooleanType(val) +} + +func (p *PeripheryState) setDebugIoBoardTestLampEnabled(val uint64) { + p.DebugIoBoardTestLampEnabled = BooleanType(val) +} + +func (p *PeripheryState) setErrorFireEmergencyCircuitBreaker(val uint64) { + p.ErrorFireEmergencyCircuitBreaker = ErrorType(val) +} + +func (p *PeripheryState) setErrorExtLightCircuitBreaker(val uint64) { + p.ErrorExtLightCircuitBreaker = ErrorType(val) +} + +func (p *PeripheryState) setErrorIndicationCircuitBreaker(val uint64) { + p.ErrorIndicationCircuitBreaker = ErrorType(val) +} + +func (p *PeripheryState) setErrorLowVoltagePowerCircuitBreaker(val uint64) { + p.ErrorLowVoltagePowerCircuitBreaker = ErrorType(val) +} + +func (p *PeripheryState) setErrorContactorsInternalCircuitBreaker(val uint64) { + p.ErrorContactorsInternalCircuitBreaker = ErrorType(val) +} + +func (p *PeripheryState) setErrorPlcCircuitBreaker(val uint64) { + p.ErrorPlcCircuitBreaker = ErrorType(val) +} + +func (p *PeripheryInfo) setInfoDoorOpen(val uint64) { + p.InfoDoorOpen = BooleanType(val) +} + +func (p *PeripheryInfo) setTempAirIn(val uint64) { + p.TempAirIn = SignedAirTemp8BitType(val - 67) +} + +func (p *PeripheryInfo) setTempAirOut(val uint64) { + p.TempAirOut = SignedAirTemp8BitType(val - 67) +} + +func (p *PeripheryInfo) setStateShsnFan(val uint64) { + p.StateShsnFan = BooleanType(val) +} + +func (p *PeripheryInfo) setStateShptFan(val uint64) { + p.StateShptFan = BooleanType(val) +} + +func (p *PeripheryDebug) setDebugModeOn(val uint64) { + p.DebugModeOn = BooleanType(val) +} + +func (p *PeripheryDebug) setDebugShsnFan(val uint64) { + p.DebugShsnFan = DebugSwitchModeType(val) +} + +func (p *PeripheryDebug) setDebugShptFan(val uint64) { + p.DebugShptFan = DebugSwitchModeType(val) +} + +func (p *PeripheryDebug) setDebugIoBoardTestLamp(val uint64) { + p.DebugIoBoardTestLamp = DebugSwitchModeType(val) +} + +func (c *ConverterPresentEnergy) setV2gMode(val uint64) { + c.V2gMode = V2GModeType(val) +} + +func (c *ConverterPresentEnergy) setPresentVoltage(val uint64) { + c.PresentVoltage = Voltage11BitType(val) +} + +func (c *ConverterPresentEnergy) setPresentCurrent(val uint64) { + c.PresentCurrent = Current10BitType(val) +} + +func (c *ConverterPresentEnergy) setConnectedOut(val uint64) { + c.ConnectedOut = ConnectedOut8bitType(val) +} + +func (c *ConverterErrors) setBoardReady(val uint64) { + c.BoardReady = BoardReadyType(val) +} + +func (c *ConverterErrors) setOtherError(val uint64) { + c.OtherError = OtherError4BitType(val) +} + +func (c *ConverterErrors) setNotConnectedOut(val uint64) { + c.NotConnectedOut = ErrorType(val) +} + +func (c *ConverterErrors) setNoCommunicationConverter(val uint64) { + c.NoCommunicationConverter = ErrorType(val) +} + +func (c *ConverterErrors) setNoCommunicationPuConverter(val uint64) { + c.NoCommunicationPuConverter = ErrorType(val) +} + +func (c *ConverterErrors) setInputGridVoltageHigh(val uint64) { + c.InputGridVoltageHigh = ErrorType(val) +} + +func (c *ConverterErrors) setInputGridVoltageLow(val uint64) { + c.InputGridVoltageLow = ErrorType(val) +} + +func (c *ConverterErrors) setOutputGridVoltageHigh(val uint64) { + c.OutputGridVoltageHigh = ErrorType(val) +} + +func (c *ConverterErrors) setOutputGridVoltageLow(val uint64) { + c.OutputGridVoltageLow = ErrorType(val) +} + +func (c *ConverterErrors) setInputGridVoltage(val uint64) { + c.InputGridVoltage = Voltage11BitType(val) +} + +func (c *ConverterErrors) setOutputGridVoltage(val uint64) { + c.OutputGridVoltage = Voltage11BitType(val) +} + +func (c *ConverterErrors) setShortCircuit(val uint64) { + c.ShortCircuit = ErrorType(val) +} + +func (c *ConverterErrors) setOverHeat(val uint64) { + c.OverHeat = ErrorType(val) +} + +func (c *ConverterErrors) setFanBroken(val uint64) { + c.FanBroken = ErrorType(val) +} + +func (c *ConverterErrors) setOtherHardwareError(val uint64) { + c.OtherHardwareError = ErrorType(val) +} + +func (c *ConverterErrors) setDebugConvEnabled(val uint64) { + c.DebugConvEnabled = BooleanType(val) +} + +func (c *ConverterErrors) setDebugConvDisabled(val uint64) { + c.DebugConvDisabled = BooleanType(val) +} + +func (d *ConverterDebug) setDebugModeOn(val uint64) { + d.DebugModeOn = BooleanType(val) +} + +func (d *ConverterDebug) setDebugEnergyOn(val uint64) { + d.DebugEnergyOn = DebugSwitchModeType(val) +} + +func (d *ConverterDebug) setDebugTargetVoltage(val uint64) { + d.DebugTargetVoltage = Voltage11BitType(val) +} + +func (d *ConverterDebug) setDebugTargetCurrent(val uint64) { + d.DebugTargetCurrent = Current10BitType(val) +} diff --git a/yabl/strings.go b/yabl/strings.go index a748f9a..bd5b38a 100644 --- a/yabl/strings.go +++ b/yabl/strings.go @@ -199,3 +199,15 @@ func (d DebugSwitchModeType) String() string { func (s SignedVoltage12bitType) String() string { return fmt.Sprintf("%d", s) } + +func (f ForceModeType) String() string { + return fmt.Sprintf("MODE_%d", f) +} + +func (t SignedAirTemp8BitType) String() string { + return fmt.Sprintf("%d", t) +} + +func (c ConnectedOut8bitType) String() string { + return fmt.Sprintf("%d", c) +}