From 00762d173bb2feac9de8389763bc149ea0f05c21 Mon Sep 17 00:00:00 2001 From: Terekhin Alexandr Date: Fri, 7 Jul 2023 04:28:46 +0300 Subject: [PATCH] New events api implementation --- cli-mon.go | 17 +- ui/helper.go | 43 ---- ui/model.go | 81 ------- ui/ui.go | 23 +- ui/view.go | 37 ++-- yabl/const.go | 52 ++--- yabl/init.go | 555 +++++++++++++++++++++++++---------------------- yabl/protocol.go | 186 ++++------------ 8 files changed, 428 insertions(+), 566 deletions(-) delete mode 100644 ui/helper.go delete mode 100644 ui/model.go diff --git a/cli-mon.go b/cli-mon.go index 262890d..78f75ac 100644 --- a/cli-mon.go +++ b/cli-mon.go @@ -7,12 +7,14 @@ import ( "flag" "fmt" "os" + "reflect" ) func main() { filename := flag.String("f", "", "Candump filename") canbus := flag.String("i", "", "CAN bus interface") stdin := flag.Bool("s", false, "Read from stdin") + gui := flag.Bool("gui", false, "Text mode gui") flag.Parse() var frames <-chan *can.CanFrame @@ -40,5 +42,18 @@ func main() { var messages = yabl.StartProtocolParsing(frames) - ui.InitCliApp(messages) + if *gui { + ui.InitCliApp(messages) + } else { + for msg := range messages { + val := getField(msg.Object, msg.Field) + fmt.Printf("%v %v %v %v\n", msg.Updated, msg.ActionName, msg.Field, val) + } + } +} + +func getField(v yabl.Action, field yabl.FName) interface{} { + r := reflect.ValueOf(v) + f := reflect.Indirect(r).FieldByName(string(field)) + return f.Interface() } diff --git a/ui/helper.go b/ui/helper.go deleted file mode 100644 index 0ab17a9..0000000 --- a/ui/helper.go +++ /dev/null @@ -1,43 +0,0 @@ -package ui - -import "cli-mon/yabl" - -var fNewCIS = func(packet *yabl.ContactorInternalState) *contactorType { - return &contactorType{state: packet} -} -var fGetCIS = func(c *contactorType) *yabl.ContactorInternalState { - return c.state -} -var fSetCIS = func(c *contactorType, packet *yabl.ContactorInternalState) { - c.state = packet -} - -var fNewCES = func(packet *yabl.ContactorInternalErrors) *contactorType { - return &contactorType{errors: packet} -} -var fGetCES = func(c *contactorType) *yabl.ContactorInternalErrors { - return c.errors -} -var fSetCES = func(c *contactorType, packet *yabl.ContactorInternalErrors) { - c.errors = packet -} - -var fNewPPE = func(packet *yabl.PuPresentEnergy) *connectorType { - return &connectorType{energy: packet} -} -var fGetPPE = func(c *connectorType) *yabl.PuPresentEnergy { - return c.energy -} -var fSetPPE = func(c *connectorType, packet *yabl.PuPresentEnergy) { - c.energy = packet -} - -var fNewPP = func(packet *yabl.PuPeriphery) *connectorType { - return &connectorType{state: packet} -} -var fGetPP = func(c *connectorType) *yabl.PuPeriphery { - return c.state -} -var fSetPP = func(c *connectorType, packet *yabl.PuPeriphery) { - c.state = packet -} diff --git a/ui/model.go b/ui/model.go deleted file mode 100644 index 7622406..0000000 --- a/ui/model.go +++ /dev/null @@ -1,81 +0,0 @@ -package ui - -import ( - "cli-mon/yabl" - "github.com/gizak/termui/v3/widgets" - "reflect" -) - -type connectorType struct { - energy *yabl.PuPresentEnergy - state *yabl.PuPeriphery -} - -type contactorType struct { - state *yabl.ContactorInternalState - errors *yabl.ContactorInternalErrors -} - -type modelTypes interface { - *connectorType | *contactorType -} - -type dataTypes interface { - *yabl.PuPresentEnergy | *yabl.PuPeriphery | *yabl.ContactorInternalState | *yabl.ContactorInternalErrors -} - -type fNewType[T modelTypes, V dataTypes] func(e V) T -type fGetType[T modelTypes, V dataTypes] func(m T) V -type fSetType[T modelTypes, V dataTypes] func(m T, e V) - -var connectors = make([]*connectorType, connectorsCount+1) -var contactors = make([]*contactorType, contactorsCount+1) - -var connUI [connectorsCount + 1]*widgets.Paragraph -var contUI [contactorsCount + 1]*widgets.Paragraph -var contactorsErr *widgets.Paragraph - -func process(message yabl.Packet) { - if message == nil { - return - } - - unitId := message.GetUnitId() - - switch msg := message.(type) { - case *yabl.ContactorInternalState: - if updateOrNew(contactors, unitId, msg, fNewCIS, fGetCIS, fSetCIS) { - updateContactorsView(unitId) - } - - case *yabl.ContactorInternalErrors: - if updateOrNew(contactors, unitId, msg, fNewCES, fGetCES, fSetCES) { - updateContactorsStateView() - } - - case *yabl.PuPeriphery: - if updateOrNew(connectors, unitId, msg, fNewPP, fGetPP, fSetPP) { - updateConnectorsView(unitId) - } - - case *yabl.PuPresentEnergy: - if updateOrNew(connectors, unitId, msg, fNewPPE, fGetPPE, fSetPPE) { - updateConnectorsView(unitId) - } - - } -} - -func updateOrNew[T modelTypes, V dataTypes](array []T, id uint, msg V, fNew fNewType[T, V], fGet fGetType[T, V], fSet fSetType[T, V]) bool { - if model := array[id]; model != nil { - if element := fGet(model); !reflect.DeepEqual(element, msg) { - fSet(model, msg) - return true - } - } else { - model = fNew(msg) - array[id] = model - return true - } - return false -} diff --git a/ui/ui.go b/ui/ui.go index 6ae7959..4cf7f1e 100644 --- a/ui/ui.go +++ b/ui/ui.go @@ -12,7 +12,11 @@ const headerHeight int = 4 const contactorsCount = 18 const connectorsCount = 6 -func InitCliApp(events <-chan yabl.Packet) { +var connUI [connectorsCount + 1]*widgets.Paragraph +var contUI [contactorsCount + 1]*widgets.Paragraph +var contactorsErr *widgets.Paragraph + +func InitCliApp(events <-chan *yabl.Event) { if err := ui.Init(); err != nil { log.Fatalf("failed to initialize termui: %v", err) } @@ -86,3 +90,20 @@ func InitCliApp(events <-chan yabl.Packet) { } } } + +func process(message *yabl.Event) { + if message == nil || message.Object == nil { + return + } + + switch msg := message.Object.(type) { + case *yabl.ContactorInternalState: + updateContactorsView(msg) + case *yabl.PuPeriphery: + updateConnectorsView(msg) + case *yabl.PuPresentEnergy: + updateConnectorsView(msg) + case *yabl.ContactorInternalErrors: + updateContactorsStateView(msg) + } +} diff --git a/ui/view.go b/ui/view.go index 5397408..36db113 100644 --- a/ui/view.go +++ b/ui/view.go @@ -125,9 +125,10 @@ func newContactorsErrView() *widgets.Paragraph { return p } -func updateContactorsView(unitId uint) { - p := contUI[unitId] - s := contactors[unitId].state +func updateContactorsView(msg *yabl.ContactorInternalState) { + + p := contUI[msg.GetUnitId()] + s := msg if s == nil || p == nil { return @@ -154,10 +155,26 @@ func updateContactorsView(unitId uint) { } } -func updateConnectorsView(unitId uint) { +var connectorsState [connectorsCount + 1]*yabl.PuPeriphery +var connectorsEnergy [connectorsCount + 1]*yabl.PuPresentEnergy + +func updateConnectorsView(action yabl.Action) { + if action == nil { + return + } + + var unitId = action.GetUnitId() + + switch msg := action.(type) { + case *yabl.PuPeriphery: + connectorsState[unitId] = msg + case *yabl.PuPresentEnergy: + connectorsEnergy[unitId] = msg + } + p := connUI[unitId] - s := connectors[unitId].state - e := connectors[unitId].energy + s := connectorsState[unitId] + e := connectorsEnergy[unitId] if s == nil || e == nil { return @@ -192,15 +209,9 @@ func updateConnectorsView(unitId uint) { e.PresentCurrent) } -func updateContactorsStateView() { +func updateContactorsStateView(e *yabl.ContactorInternalErrors) { p := contactorsErr - if contactors[1] == nil { - return - } - - e := contactors[1].errors - if e == nil { return } diff --git a/yabl/const.go b/yabl/const.go index 76eff8d..2acd615 100644 --- a/yabl/const.go +++ b/yabl/const.go @@ -55,33 +55,33 @@ const ( DEBUG_SWITCH_MODE_PERMANENT_OFF DebugSwitchModeType = 4 DEBUG_SWITCH_MODE_PERMANENT_ON DebugSwitchModeType = 5 - PCpuPresentEnergy PName = "CpuPresentEnergy" - PCpuPeriphery PName = "CpuPeriphery" - PCpuEnergySettings PName = "CpuEnergySettings" - PCpuErrors PName = "CpuErrors" - PCpuDebug PName = "CpuDebug" - PPuPresentEnergy PName = "PuPresentEnergy" - PPuPeriphery PName = "PuPeriphery" - PPuErrors PName = "PuErrors" - PPuDebug PName = "PuDebug" - PSeccTargetEnergy PName = "SeccTargetEnergy" - PSeccErrors PName = "SeccErrors" - PLogicAuth PName = "LogicAuth" - PLogicEnergyMode PName = "LogicEnergyMode" - PLogicErrors PName = "LogicErrors" - PLogicWorkingMode PName = "LogicWorkingMode" - PContactorInternalState PName = "ContactorInternalState" - PContactorInternalErrors PName = "ContactorInternalErrors" - PContactorsInternalForce PName = "ContactorsInternalForce" - PContactorInternalDebug PName = "ContactorInternalDebug" - PPeripheryState PName = "PeripheryState" - PPeripheryInfo PName = "PeripheryInfo" - PPeripheryDebug PName = "PeripheryDebug" - PConverterPresentEnergy PName = "ConverterPresentEnergy" - PConverterErrors PName = "ConverterErrors" - PConverterDebug PName = "ConverterDebug" + PCpuPresentEnergy AName = "CpuPresentEnergy" + PCpuPeriphery AName = "CpuPeriphery" + PCpuEnergySettings AName = "CpuEnergySettings" + PCpuErrors AName = "CpuErrors" + PCpuDebug AName = "CpuDebug" + PPuPresentEnergy AName = "PuPresentEnergy" + PPuPeriphery AName = "PuPeriphery" + PPuErrors AName = "PuErrors" + PPuDebug AName = "PuDebug" + PSeccTargetEnergy AName = "SeccTargetEnergy" + PSeccErrors AName = "SeccErrors" + PLogicAuth AName = "LogicAuth" + PLogicEnergyMode AName = "LogicEnergyMode" + PLogicErrors AName = "LogicErrors" + PLogicWorkingMode AName = "LogicWorkingMode" + PContactorInternalState AName = "ContactorInternalState" + PContactorInternalErrors AName = "ContactorInternalErrors" + PContactorsInternalForce AName = "ContactorsInternalForce" + PContactorInternalDebug AName = "ContactorInternalDebug" + PPeripheryState AName = "PeripheryState" + PPeripheryInfo AName = "PeripheryInfo" + PPeripheryDebug AName = "PeripheryDebug" + PConverterPresentEnergy AName = "ConverterPresentEnergy" + PConverterErrors AName = "ConverterErrors" + PConverterDebug AName = "ConverterDebug" - FContactorReady FName = "FContactorReady" + FContactorReady FName = "ContactorReady" FContactorOn FName = "ContactorOn" FUnexpectedState FName = "UnexpectedState" FIsolated FName = "Isolated" diff --git a/yabl/init.go b/yabl/init.go index 0c0e2ca..7687be5 100644 --- a/yabl/init.go +++ b/yabl/init.go @@ -2,353 +2,388 @@ package yabl import "cli-mon/can" -func init() { - for i := 1; i <= CONNECTOR_COUNT; i++ { - key := key{can.CAN_ID_011, uint(i)} - cpe := CpuPresentEnergy{} - cpuPresentEnergyArray[i] = &cpe +func initialize() { + for i := uint(1); i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_011, i} + cpe := &CpuPresentEnergy{UnitId: 1} + cpuPresentEnergyArray[i] = cpe fields := []field{ - {length: 2, setter: cpe.setPowerDirectionMode}, - {length: 10, setter: cpe.setPresentCurrent}, - {length: 11, setter: cpe.setPresentVoltage}, + {length: 2, setter: cpe.setPowerDirectionMode, name: FPowerDirectionMode}, + {length: 10, setter: cpe.setPresentCurrent, name: FPresentCurrent}, + {length: 11, setter: cpe.setPresentVoltage, name: FPresentVoltage}, } - protocolMap[key] = parameters{fields: fields, interval: 50, name: PCpuPresentEnergy} + protocolMap[key] = action{fields: fields, interval: 50, name: PCpuPresentEnergy, object: cpe} } - cpuPeripheryInstance = &CpuPeriphery{} + cpuPeripheryInstance = &CpuPeriphery{UnitId: 0} fields := []field{ - {length: 2, setter: cpuPeripheryInstance.setContactorInput}, - {length: 2, setter: cpuPeripheryInstance.setCircuitBreakerInput}, - {length: 2, setter: cpuPeripheryInstance.setCircuitBreakerPowerCBInput}, + {length: 2, setter: cpuPeripheryInstance.setContactorInput, name: FContactorInput}, + {length: 2, setter: cpuPeripheryInstance.setCircuitBreakerInput, name: FCircuitBreakerInput}, + {length: 2, setter: cpuPeripheryInstance.setCircuitBreakerPowerCBInput, name: FCircuitBreakerPowerCBInput}, + } + protocolMap[key{can.CAN_ID_014, 0}] = action{ + fields: fields, + interval: 1000, + name: PCpuPeriphery, + object: cpuPeripheryInstance, } - protocolMap[key{can.CAN_ID_014, 0}] = parameters{fields: fields, interval: 1000, name: PCpuPeriphery} - for i := 0; i <= CONNECTOR_COUNT; i++ { - key := key{can.CAN_ID_015, uint(i)} - ces := CpuEnergySettings{} - cpuEnergySettingsArray[i] = &ces + for i := uint(0); i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_015, i} + ces := &CpuEnergySettings{UnitId: i} + cpuEnergySettingsArray[i] = ces fields := []field{ - {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}, + {length: 10, setter: ces.setCurrentMax, name: FCurrentMax}, + {length: 11, setter: ces.setVoltageMax, name: FVoltageMax}, + {length: 14, setter: ces.setPowerMax, name: FPowerMax}, + {length: 11, setter: ces.setTargetBatteryVoltage, name: FTargetBatteryVoltage}, + {length: 11, setter: ces.setTargetGoalVoltage, name: FTargetGoalVoltage}, } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PCpuEnergySettings} + protocolMap[key] = action{fields: fields, interval: 1000, name: PCpuEnergySettings, object: ces} } - cpuErrorsInstance = &CpuErrors{} + cpuErrorsInstance = &CpuErrors{UnitId: 0} fields = []field{ - {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}, + {length: 3, setter: cpuErrorsInstance.setBoardReady, name: FBoardReady}, + {length: 4, setter: cpuErrorsInstance.setOtherError, name: FOtherError}, + {length: 2, setter: cpuErrorsInstance.setRedButtonHard, name: FRedButtonHard}, + {length: 2, setter: cpuErrorsInstance.setRedButtonSoft, name: FRedButtonSoft}, + {length: 2, setter: cpuErrorsInstance.setModulesGone, name: FModulesGone}, + {length: 2, setter: cpuErrorsInstance.setGridVoltageHighErr, name: FGridVoltageHighErr}, + {length: 2, setter: cpuErrorsInstance.setGridVoltageHighWarn, name: FGridVoltageHighWarn}, + {length: 2, setter: cpuErrorsInstance.setGridVoltageLowWarn, name: FGridVoltageLowWarn}, + {length: 2, setter: cpuErrorsInstance.setGridVoltageLowErr, name: FGridVoltageLowErr}, + {length: 11, setter: cpuErrorsInstance.setGridVoltageLow, name: FGridVoltageLow}, + {length: 11, setter: cpuErrorsInstance.setGridVoltageHigh, name: FGridVoltageHigh}, + {length: 2, setter: cpuErrorsInstance.setGridVoltageEmpty, name: FGridVoltageEmpty}, + {length: 2, setter: cpuErrorsInstance.setNotReadySecc, name: FNotReadySecc}, + {length: 2, setter: cpuErrorsInstance.setNotReadyPu, name: FNotReadyPu}, + {length: 2, setter: cpuErrorsInstance.setNotReadyContactors, name: FNotReadyContactors}, + {length: 2, setter: cpuErrorsInstance.setDebugConvertersEnabled, name: FDebugConvertersEnabled}, + {length: 2, setter: cpuErrorsInstance.setContactorInputError, name: FContactorInputError}, + {length: 2, setter: cpuErrorsInstance.setNotReadyPeriphery, name: FNotReadyPeriphery}, + } + protocolMap[key{can.CAN_ID_016, 0}] = action{ + fields: fields, + interval: 1000, + name: PCpuErrors, + object: cpuErrorsInstance, } - protocolMap[key{can.CAN_ID_016, 0}] = parameters{fields: fields, interval: 1000, name: PCpuErrors} - cpuDebugInstance = &CpuDebug{} + cpuDebugInstance = &CpuDebug{UnitId: 0} fields = []field{ - {length: 2, setter: cpuDebugInstance.setDebugModeOn}, - {length: 3, setter: cpuDebugInstance.setDebugContactorInputOn}, - {length: 3, setter: cpuDebugInstance.setDebugCircuitBreakerOn}, - {length: 3, setter: cpuDebugInstance.setDebugRedButtonSoftware}, + {length: 2, setter: cpuDebugInstance.setDebugModeOn, name: FDebugModeOn}, + {length: 3, setter: cpuDebugInstance.setDebugContactorInputOn, name: FDebugContactorInputOn}, + {length: 3, setter: cpuDebugInstance.setDebugCircuitBreakerOn, name: FDebugCircuitBreakerOn}, + {length: 3, setter: cpuDebugInstance.setDebugRedButtonSoftware, name: FDebugRedButtonSoftware}, + } + protocolMap[key{can.CAN_ID_01A, 0}] = action{ + fields: fields, + interval: 1000, + name: PCpuDebug, + object: cpuDebugInstance, } - protocolMap[key{can.CAN_ID_01A, 0}] = parameters{fields: fields, interval: 1000, name: PCpuDebug} - for i := 1; i <= CONNECTOR_COUNT; i++ { - key := key{can.CAN_ID_021, uint(i)} - ppe := PuPresentEnergy{} - puPresentEnergyArray[i] = &ppe + for i := uint(1); i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_021, i} + ppe := &PuPresentEnergy{UnitId: i} + puPresentEnergyArray[i] = ppe fields := []field{ - {length: 2, setter: ppe.setV2GMode}, - {length: 11, setter: ppe.setVoltageBefore}, - {length: 11, setter: ppe.setVoltageAfter}, - {length: 10, setter: ppe.setPresentCurrent}, + {length: 2, setter: ppe.setV2GMode, name: FV2GMode}, + {length: 11, setter: ppe.setVoltageBefore, name: FVoltageBefore}, + {length: 11, setter: ppe.setVoltageAfter, name: FVoltageAfter}, + {length: 10, setter: ppe.setPresentCurrent, name: FPresentCurrent}, } - protocolMap[key] = parameters{fields: fields, interval: 50, name: PPuPresentEnergy} + protocolMap[key] = action{fields: fields, interval: 50, name: PPuPresentEnergy, object: ppe} } - for i := 1; i <= CONNECTOR_COUNT; i++ { - key := key{can.CAN_ID_022, uint(i)} - pp := PuPeriphery{} - puPeripheryArray[i] = &pp + for i := uint(1); i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_022, i} + pp := &PuPeriphery{UnitId: i} + puPeripheryArray[i] = pp fields := []field{ - {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}, + {length: 2, setter: pp.setConnectorInsert, name: FConnectorInsert}, + {length: 2, setter: pp.setContactorOn, name: FContactorOn}, + {length: 2, setter: pp.setConnectorLocked, name: FConnectorLocked}, + {length: 3, setter: pp.setCpLineLevel, name: FCpLineLevel}, + {length: 3, setter: pp.setIsolationState, name: FIsolationState}, + {length: 2, setter: pp.setChargingAllowed, name: FChargingAllowed}, + {length: 2, setter: pp.setPwmEnabled, name: FPwmEnabled}, + {length: 9, setter: pp.setCpLineVoltage, name: FCpLineVoltage}, } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PPuPeriphery} + protocolMap[key] = action{fields: fields, interval: 1000, name: PPuPeriphery, object: pp} } - for i := 1; i <= CONNECTOR_COUNT; i++ { - key := key{can.CAN_ID_023, uint(i)} - pe := PuErrors{} - puErrorsArray[i] = &pe + for i := uint(1); i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_023, i} + pe := &PuErrors{UnitId: 1} + puErrorsArray[i] = pe fields := []field{ - {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}, + {length: 3, setter: pe.setBoardReady, name: FBoardReady}, + {length: 4, setter: pe.setOtherError, name: FOtherError}, + {length: 2, setter: pe.setIncorrectVoltage, name: FIncorrectVoltage}, + {length: 11, setter: pe.setIncorrectVoltageValue, name: FIncorrectVoltageValue}, + {length: 2, setter: pe.setIncorrectCurrent, name: FIncorrectCurrent}, + {length: 10, setter: pe.setIncorrectCurrentValue, name: FIncorrectCurrentValue}, + {length: 2, setter: pe.setIsolationBroken, name: FIsolationBroken}, + {length: 2, setter: pe.setCpLineBroken, name: FCpLineBroken}, + {length: 2, setter: pe.setCpLineGap69, name: FCpLineGap69}, + {length: 3, setter: pe.setCableReady, name: FCableReady}, + {length: 2, setter: pe.setNotReadyCpu, name: FNotReadyCpu}, + {length: 2, setter: pe.setNotReadySecc, name: FNotReadySecc}, + {length: 2, setter: pe.setContactorOutputError, name: FContactorOutputError}, + {length: 2, setter: pe.setDebugContactorOutputEnabled, name: FDebugContactorOutputEnabled}, + {length: 2, setter: pe.setOutputCircuitBreakerEnabled, name: FOutputCircuitBreakerEnabled}, + {length: 12, setter: pe.setOutputCircuitBreakerEnabledValue, name: FOutputCircuitBreakerEnabledValue}, } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PPuErrors} + protocolMap[key] = action{fields: fields, interval: 1000, name: PPuErrors, object: pe} } - for i := 0; i <= CONNECTOR_COUNT; i++ { - key := key{can.CAN_ID_02A, uint(i)} - pd := PuDebug{} - puDebugArray[i] = &pd + for i := uint(0); i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_02A, i} + pd := &PuDebug{UnitId: i} + puDebugArray[i] = pd fields = []field{ - {length: 2, setter: pd.setDebugModeOn}, - {length: 3, setter: pd.setDebugContactorOutputOn}, + {length: 2, setter: pd.setDebugModeOn, name: FDebugModeOn}, + {length: 3, setter: pd.setDebugContactorOutputOn, name: FDebugContactorOutputOn}, } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PPuDebug} + protocolMap[key] = action{fields: fields, interval: 1000, name: PPuDebug, object: pd} } - for i := 1; i <= CONNECTOR_COUNT; i++ { - key := key{can.CAN_ID_041, uint(i)} - ste := SeccTargetEnergy{} - seccTargetEnergyArray[i] = &ste + for i := uint(1); i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_041, i} + ste := &SeccTargetEnergy{UnitId: i} + seccTargetEnergyArray[i] = ste fields = []field{ - {length: 2, setter: ste.setTargetChargingAllow}, - {length: 11, setter: ste.setTargetBatteryVoltage}, - {length: 11, setter: ste.setTargetGoalVoltage}, - {length: 10, setter: ste.setTargetCurrent}, + {length: 2, setter: ste.setTargetChargingAllow, name: FTargetChargingAllow}, + {length: 11, setter: ste.setTargetBatteryVoltage, name: FTargetBatteryVoltage}, + {length: 11, setter: ste.setTargetGoalVoltage, name: FTargetGoalVoltage}, + {length: 10, setter: ste.setTargetCurrent, name: FTargetCurrent}, } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PSeccTargetEnergy} + protocolMap[key] = action{fields: fields, interval: 1000, name: PSeccTargetEnergy, object: ste} } - for i := 1; i <= CONNECTOR_COUNT; i++ { - key := key{can.CAN_ID_042, uint(i)} - se := SeccErrors{} - seccErrorsArray[i] = &se + for i := uint(1); i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_042, i} + se := &SeccErrors{UnitId: i} + seccErrorsArray[i] = se fields = []field{ - {length: 3, setter: se.setBoardReady}, - {length: 2, setter: se.setNotReadyLogic}, + {length: 3, setter: se.setBoardReady, name: FBoardReady}, + {length: 2, setter: se.setNotReadyLogic, name: FNotReadyLogic}, } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PSeccErrors} + protocolMap[key] = action{fields: fields, interval: 1000, name: PSeccErrors, object: se} } - for i := 0; i <= CONNECTOR_COUNT; i++ { - key := key{can.CAN_ID_046, uint(i)} - la := LogicAuth{} - logicAuthArray[i] = &la + for i := uint(0); i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_046, i} + la := &LogicAuth{UnitId: i} + logicAuthArray[i] = la fields = []field{ - {length: 2, setter: la.setAuthMode}, - {length: 3, setter: la.setAuthState}, + {length: 2, setter: la.setAuthMode, name: FAuthMode}, + {length: 3, setter: la.setAuthState, name: FAuthState}, } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PLogicAuth} + protocolMap[key] = action{fields: fields, interval: 1000, name: PLogicAuth, object: la} } - for i := 0; i <= CONNECTOR_COUNT; i++ { - key := key{can.CAN_ID_047, uint(i)} - la := LogicEnergyMode{} - logicEnergyMode[i] = &la + for i := uint(0); i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_047, i} + lem := &LogicEnergyMode{UnitId: i} + logicEnergyMode[i] = lem fields = []field{ - {length: 2, setter: la.setV2gMode}, - {length: 10, setter: la.setCurrentMax}, - {length: 11, setter: la.setVoltageMax}, - {length: 14, setter: la.setPowerMax}, + {length: 2, setter: lem.setV2gMode, name: FV2gMode}, + {length: 10, setter: lem.setCurrentMax, name: FCurrentMax}, + {length: 11, setter: lem.setVoltageMax, name: FVoltageMax}, + {length: 14, setter: lem.setPowerMax, name: FPowerMax}, } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PLogicEnergyMode} + protocolMap[key] = action{fields: fields, interval: 1000, name: PLogicEnergyMode, object: lem} } - logicErrorsInstance = &LogicErrors{} + logicErrorsInstance = &LogicErrors{UnitId: 0} fields = []field{ - {length: 3, setter: logicErrorsInstance.setBoardReady}, - {length: 2, setter: logicErrorsInstance.setNotReadySettings}, + {length: 3, setter: logicErrorsInstance.setBoardReady, name: FBoardReady}, + {length: 2, setter: logicErrorsInstance.setNotReadySettings, name: FNotReadySettings}, + } + protocolMap[key{can.CAN_ID_048, 0}] = action{ + fields: fields, + interval: 1000, + name: PLogicErrors, + object: logicErrorsInstance, } - protocolMap[key{can.CAN_ID_048, 0}] = parameters{fields: fields, interval: 1000, name: PLogicErrors} - logicWorkingMode = &LogicWorkingMode{} + logicWorkingMode = &LogicWorkingMode{UnitId: 0} fields = []field{ - {length: 5, setter: logicWorkingMode.setTargetContactorMode}, - {length: 2, setter: logicWorkingMode.setAvailability}, + {length: 5, setter: logicWorkingMode.setTargetContactorMode, name: FTargetContactorMode}, + {length: 2, setter: logicWorkingMode.setAvailability, name: FAvailability}, + } + protocolMap[key{can.CAN_ID_049, 0}] = action{ + fields: fields, + interval: 1000, + name: PLogicWorkingMode, + object: logicWorkingMode, } - protocolMap[key{can.CAN_ID_049, 0}] = parameters{fields: fields, interval: 1000, name: PLogicWorkingMode} - for i := 0; i <= CONTACTOR_MAX; i++ { - key := key{can.CAN_ID_071, uint(i)} - cis := ContactorInternalState{} - contactorInternalStateArray[i] = &cis + for i := uint(0); i < CONTACTOR_MAX; i++ { + key := key{can.CAN_ID_071, i} + cis := &ContactorInternalState{UnitId: i} + contactorInternalStateArray[i] = cis fields = []field{ - {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}, + {length: 3, setter: cis.setContactorReady, name: FContactorReady}, + {length: 2, setter: cis.setContactorOn, name: FContactorOn}, + {length: 2, setter: cis.setUnexpectedState, name: FUnexpectedState}, + {length: 2, setter: cis.setIsolated, name: FIsolated}, + {length: 2, setter: cis.setDebugEnabled, name: FDebugEnabled}, } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PContactorInternalState} + protocolMap[key] = action{fields: fields, interval: 1000, name: PContactorInternalState, object: cis} } - contactorInternalErrorsInstance = &ContactorInternalErrors{} + contactorInternalErrorsInstance = &ContactorInternalErrors{UnitId: 0} fields = []field{ - {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}, + {length: 3, setter: contactorInternalErrorsInstance.setBoardReady, name: FBoardReady}, + {length: 4, setter: contactorInternalErrorsInstance.setOtherError, name: FOtherError}, + {length: 3, setter: contactorInternalErrorsInstance.setContactorGroupChanged, name: FContactorGroupChanged}, + {length: 4, setter: contactorInternalErrorsInstance.setUnexpectedFormation, name: FUnexpectedFormation}, + {length: 2, setter: contactorInternalErrorsInstance.setCpuNotReady, name: FCpuNotReady}, + {length: 2, setter: contactorInternalErrorsInstance.setPuNotReady, name: FPuNotReady}, + {length: 2, setter: contactorInternalErrorsInstance.setDebug, name: FDebug}, + {length: 5, setter: contactorInternalErrorsInstance.setPresentContactorMode, name: FPresentContactorMode}, + } + protocolMap[key{can.CAN_ID_073, 0}] = action{ + fields: fields, + interval: 1000, + name: PContactorInternalErrors, + object: contactorInternalErrorsInstance, } - protocolMap[key{can.CAN_ID_073, 0}] = parameters{fields: fields, interval: 1000, name: PContactorInternalErrors} - contactorsInternalForce = &ContactorsInternalForce{} + contactorsInternalForce = &ContactorsInternalForce{UnitId: 0} fields = []field{ - {length: 2, setter: contactorsInternalForce.setForceModeEnabled}, - {length: 4, setter: contactorsInternalForce.setForceModeValue}, + {length: 2, setter: contactorsInternalForce.setForceModeEnabled, name: FForceModeEnabled}, + {length: 4, setter: contactorsInternalForce.setForceModeValue, name: FForceModeValue}, } - protocolMap[key{can.CAN_ID_074, 0}] = parameters{fields: fields, interval: 1000, name: PContactorsInternalForce} - - for i := 0; i <= CONTACTOR_MAX; i++ { - key := key{can.CAN_ID_075, uint(i)} - cid := ContactorInternalDebug{} - contactorInternalDebugArray[i] = &cid - fields = []field{ - {length: 2, setter: cid.setDebugModeOn}, - {length: 3, setter: cid.setDebugContactorOn}, - } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PContactorInternalDebug} + protocolMap[key{can.CAN_ID_074, 0}] = action{ + fields: fields, + interval: 1000, + name: PContactorsInternalForce, + object: contactorsInternalForce, } - for i := 0; i <= CONNECTOR_COUNT; i++ { - key := key{can.CAN_ID_067, uint(i)} - ps := PeripheryState{} - peripheryStateArray[i] = &ps + for i := uint(0); i < CONTACTOR_MAX; i++ { + key := key{can.CAN_ID_075, i} + cid := &ContactorInternalDebug{UnitId: i} + contactorInternalDebugArray[i] = cid fields = []field{ - {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}, + {length: 2, setter: cid.setDebugModeOn, name: FDebugModeOn}, + {length: 3, setter: cid.setDebugContactorOn, name: FDebugContactorOn}, } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PPeripheryState} + protocolMap[key] = action{fields: fields, interval: 1000, name: PContactorInternalDebug, object: cid} } - for i := 0; i <= CONNECTOR_COUNT; i++ { - key := key{can.CAN_ID_068, uint(i)} - pi := PeripheryInfo{} - peripheryInfoArray[i] = &pi + for i := uint(0); i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_067, i} + ps := &PeripheryState{UnitId: i} + peripheryStateArray[i] = ps fields = []field{ - {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}, + {length: 3, setter: ps.setOtherErrorSeverity, name: FOtherErrorSeverity}, + {length: 4, setter: ps.setOtherError, name: FOtherError}, + {length: 2, setter: ps.setErrorShakeSensor, name: FErrorShakeSensor}, + {length: 2, setter: ps.setErrorCoolingGroup, name: FErrorCoolingGroup}, + {length: 2, setter: ps.setPeripheryErrorCoolingGroup, name: FPeripheryErrorCoolingGroup}, + {length: 2, setter: ps.setErrorFireEmergency, name: FErrorFireEmergency}, + {length: 2, setter: ps.setErrorFireEmergencyRun, name: FErrorFireEmergencyRun}, + {length: 2, setter: ps.setErrorFireEmergencyControl, name: FErrorFireEmergencyControl}, + {length: 2, setter: ps.setErrorOvervoltageIn, name: FErrorOvervoltageIn}, + {length: 2, setter: ps.setPeripheryErrorPowerSupply, name: FPeripheryErrorPowerSupply}, + {length: 2, setter: ps.setErrorFan, name: FErrorFan}, + {length: 2, setter: ps.setErrorOvervoltageOut, name: FErrorOvervoltageOut}, + {length: 2, setter: ps.setErrorStateRemoteMode, name: FErrorStateRemoteMode}, + {length: 2, setter: ps.setDebugShsnFanEnabled, name: FDebugShsnFanEnabled}, + {length: 2, setter: ps.setDebugShptFanEnabled, name: FDebugShptFanEnabled}, + {length: 2, setter: ps.setDebugIoBoardTestLampEnabled, name: FDebugIoBoardTestLampEnabled}, + {length: 2, setter: ps.setErrorFireEmergencyCircuitBreaker, name: FErrorFireEmergencyCircuitBreaker}, + {length: 2, setter: ps.setErrorExtLightCircuitBreaker, name: FErrorExtLightCircuitBreaker}, + {length: 2, setter: ps.setErrorIndicationCircuitBreaker, name: FErrorIndicationCircuitBreaker}, + {length: 2, setter: ps.setErrorLowVoltagePowerCircuitBreaker, name: FErrorLowVoltagePowerCircuitBreaker}, + {length: 2, setter: ps.setErrorContactorsInternalCircuitBreaker, name: FErrorContactorsInternalCircuitBreaker}, + {length: 2, setter: ps.setErrorPlcCircuitBreaker, name: FErrorPlcCircuitBreaker}, } - protocolMap[key] = parameters{fields: fields, interval: 5000, name: PPeripheryInfo} + protocolMap[key] = action{fields: fields, interval: 1000, name: PPeripheryState, object: ps} } - for i := 0; i <= CONNECTOR_COUNT; i++ { - key := key{can.CAN_ID_06C, uint(i)} - pd := PeripheryDebug{} - peripheryDebugArray[i] = &pd + for i := uint(0); i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_068, i} + pi := &PeripheryInfo{UnitId: i} + peripheryInfoArray[i] = pi fields = []field{ - {length: 2, setter: pd.setDebugModeOn}, - {length: 3, setter: pd.setDebugShsnFan}, - {length: 3, setter: pd.setDebugShptFan}, - {length: 3, setter: pd.setDebugIoBoardTestLamp}, + {length: 2, setter: pi.setInfoDoorOpen, name: FInfoDoorOpen}, + {length: 8, setter: pi.setTempAirIn, name: FTempAirIn}, + {length: 8, setter: pi.setTempAirOut, name: FTempAirOut}, + {length: 2, setter: pi.setStateShsnFan, name: FStateShsnFan}, + {length: 2, setter: pi.setStateShptFan, name: FStateShptFan}, } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PPeripheryDebug} + protocolMap[key] = action{fields: fields, interval: 5000, name: PPeripheryInfo, object: pi} } - for i := 1; i <= CONVERTERS_MAX; i++ { - key := key{can.CAN_ID_061, uint(i)} - cpe := ConverterPresentEnergy{} - converterPresentEnergyArray[i] = &cpe + for i := uint(0); i <= CONNECTOR_COUNT; i++ { + key := key{can.CAN_ID_06C, i} + pd := &PeripheryDebug{UnitId: i} + peripheryDebugArray[i] = pd fields = []field{ - {length: 2, setter: cpe.setV2gMode}, - {length: 11, setter: cpe.setPresentVoltage}, - {length: 10, setter: cpe.setPresentCurrent}, - {length: 8, setter: cpe.setConnectedOut}, + {length: 2, setter: pd.setDebugModeOn, name: FDebugModeOn}, + {length: 3, setter: pd.setDebugShsnFan, name: FDebugShsnFan}, + {length: 3, setter: pd.setDebugShptFan, name: FDebugShptFan}, + {length: 3, setter: pd.setDebugIoBoardTestLamp, name: FDebugIoBoardTestLamp}, } - protocolMap[key] = parameters{fields: fields, interval: 500, name: PConverterPresentEnergy} + protocolMap[key] = action{fields: fields, interval: 1000, name: PPeripheryDebug, object: pd} } - for i := 1; i <= CONVERTERS_MAX; i++ { - key := key{can.CAN_ID_062, uint(i)} - ce := ConverterErrors{} - converterErrorsArray[i] = &ce + for i := uint(1); i < CONVERTERS_MAX; i++ { + key := key{can.CAN_ID_061, i} + cpe := &ConverterPresentEnergy{UnitId: i} + converterPresentEnergyArray[i] = cpe fields = []field{ - {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}, + {length: 2, setter: cpe.setV2gMode, name: FV2gMode}, + {length: 11, setter: cpe.setPresentVoltage, name: FPresentVoltage}, + {length: 10, setter: cpe.setPresentCurrent, name: FPresentCurrent}, + {length: 8, setter: cpe.setConnectedOut, name: FConnectedOut}, } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PConverterErrors} + protocolMap[key] = action{fields: fields, interval: 500, name: PConverterPresentEnergy, object: cpe} } - for i := 0; i <= CONVERTERS_MAX; i++ { - key := key{can.CAN_ID_065, uint(i)} - cd := ConverterDebug{} - converterDebugArray[i] = &cd + for i := uint(1); i < CONVERTERS_MAX; i++ { + key := key{can.CAN_ID_062, i} + ce := &ConverterErrors{UnitId: i} + converterErrorsArray[i] = ce fields = []field{ - {length: 3, setter: cd.setDebugModeOn}, - {length: 4, setter: cd.setDebugEnergyOn}, - {length: 2, setter: cd.setDebugTargetVoltage}, - {length: 2, setter: cd.setDebugTargetCurrent}, + {length: 3, setter: ce.setBoardReady, name: FBoardReady}, + {length: 4, setter: ce.setOtherError, name: FOtherError}, + {length: 2, setter: ce.setNotConnectedOut, name: FNotConnectedOut}, + {length: 2, setter: ce.setNoCommunicationConverter, name: FNoCommunicationConverter}, + {length: 2, setter: ce.setNoCommunicationPuConverter, name: FNoCommunicationPuConverter}, + {length: 2, setter: ce.setInputGridVoltageHigh, name: FInputGridVoltageHigh}, + {length: 2, setter: ce.setInputGridVoltageLow, name: FInputGridVoltageLow}, + {length: 2, setter: ce.setOutputGridVoltageHigh, name: FOutputGridVoltageHigh}, + {length: 2, setter: ce.setOutputGridVoltageLow, name: FOutputGridVoltageLow}, + {length: 11, setter: ce.setInputGridVoltage, name: FInputGridVoltage}, + {length: 11, setter: ce.setOutputGridVoltage, name: FOutputGridVoltage}, + {length: 2, setter: ce.setShortCircuit, name: FShortCircuit}, + {length: 2, setter: ce.setOverHeat, name: FOverHeat}, + {length: 2, setter: ce.setFanBroken, name: FFanBroken}, + {length: 2, setter: ce.setOtherHardwareError, name: FOtherHardwareError}, + {length: 2, setter: ce.setDebugConvEnabled, name: FDebugConvEnabled}, + {length: 2, setter: ce.setDebugConvDisabled, name: FDebugConvDisabled}, } - protocolMap[key] = parameters{fields: fields, interval: 1000, name: PConverterDebug} + protocolMap[key] = action{fields: fields, interval: 1000, name: PConverterErrors, object: ce} + } + + for i := uint(0); i < CONVERTERS_MAX; i++ { + key := key{can.CAN_ID_065, i} + cd := &ConverterDebug{UnitId: i} + converterDebugArray[i] = cd + fields = []field{ + {length: 3, setter: cd.setDebugModeOn, name: FDebugModeOn}, + {length: 4, setter: cd.setDebugEnergyOn, name: FDebugEnergyOn}, + {length: 2, setter: cd.setDebugTargetVoltage, name: FDebugTargetVoltage}, + {length: 2, setter: cd.setDebugTargetCurrent, name: FDebugTargetCurrent}, + } + protocolMap[key] = action{fields: fields, interval: 1000, name: PConverterDebug, object: cd} } } diff --git a/yabl/protocol.go b/yabl/protocol.go index 6f9b51b..c58c1c8 100644 --- a/yabl/protocol.go +++ b/yabl/protocol.go @@ -3,10 +3,10 @@ package yabl import ( "cli-mon/can" "encoding/binary" - "time" + time "time" ) -type Packet interface { +type Action interface { GetUnitId() uint } @@ -32,13 +32,22 @@ type CpLineLevelType uint type IsolationStateType uint type Voltage9BitType float32 -type PName string +type AName string type FName string -type parameters struct { +type Event struct { + UnitId uint + ActionName AName + Field FName + Object Action + Updated time.Time +} + +type action struct { + object Action fields []field interval uint - name PName + name AName } type field struct { @@ -50,10 +59,11 @@ type field struct { } type key struct { - canId, unitId uint + canId uint32 + unitId uint } -var protocolMap map[key]parameters +var protocolMap map[key]action = make(map[key]action) var cpuPresentEnergyArray [CONNECTOR_MAX]*CpuPresentEnergy var cpuPeripheryInstance *CpuPeriphery var cpuEnergySettingsArray [CONNECTOR_MAX]*CpuEnergySettings @@ -69,10 +79,10 @@ var logicAuthArray [CONNECTOR_MAX]*LogicAuth var logicEnergyMode [CONNECTOR_MAX]*LogicEnergyMode var logicErrorsInstance *LogicErrors var logicWorkingMode *LogicWorkingMode -var contactorInternalStateArray [CONNECTOR_MAX]*ContactorInternalState +var contactorInternalStateArray [CONTACTOR_MAX]*ContactorInternalState var contactorInternalErrorsInstance *ContactorInternalErrors var contactorsInternalForce *ContactorsInternalForce -var contactorInternalDebugArray [CONNECTOR_MAX]*ContactorInternalDebug +var contactorInternalDebugArray [CONTACTOR_MAX]*ContactorInternalDebug var peripheryStateArray [CONNECTOR_MAX]*PeripheryState var peripheryInfoArray [CONNECTOR_MAX]*PeripheryInfo var peripheryDebugArray [CONNECTOR_MAX]*PeripheryDebug @@ -80,15 +90,12 @@ var converterPresentEnergyArray [CONVERTERS_MAX]*ConverterPresentEnergy var converterErrorsArray [CONVERTERS_MAX]*ConverterErrors var converterDebugArray [CONVERTERS_MAX]*ConverterDebug -func StartProtocolParsing(frames <-chan *can.CanFrame) <-chan Packet { - result := make(chan Packet) +func StartProtocolParsing(frames <-chan *can.CanFrame) <-chan *Event { + result := make(chan *Event) + initialize() go func() { defer close(result) - var contactorsFirstState [CONTACTOR_MAX]bool - var contactorsFirstErr [CONTACTOR_MAX]bool - var puFirst [CONNECTOR_MAX]bool - var puPeripheryFirst [CONNECTOR_MAX]bool for frame := range frames { if frames == nil { @@ -96,141 +103,38 @@ func StartProtocolParsing(frames <-chan *can.CanFrame) <-chan Packet { } var unitId = uint((frame.CanId & UNIT_ID_MASK) >> UNIT_ID_OFFSET) + var canId = frame.CanId & ACTION_ID_MASK + var k = key{canId: canId, unitId: unitId} + var now = time.Now() - switch { - case frame.CanId&ACTION_ID_MASK == can.CAN_ID_071: - changed := false - var model = ContactorInternalState{UnitId: unitId} - if val, ok := get(0, 3, frame.Payload); ok && model.ContactorReady != BoardReadyType(val) { - model.ContactorReady = BoardReadyType(val) - changed = true - } - if val, ok := get(3, 2, frame.Payload); ok && model.ContactorOn != BooleanType(val) { - model.ContactorOn = BooleanType(val) - changed = true - } - if val, ok := get(5, 2, frame.Payload); ok && model.UnexpectedState != ErrorType(val) { - model.UnexpectedState = ErrorType(val) - changed = true - } - if val, ok := get(7, 2, frame.Payload); ok && model.Isolated != ErrorType(val) { - model.Isolated = ErrorType(val) - changed = true - } - if val, ok := get(9, 2, frame.Payload); ok && model.DebugEnabled != BooleanType(val) { - model.DebugEnabled = BooleanType(val) - changed = true - } - if changed || !contactorsFirstState[unitId] { - contactorsFirstState[unitId] = true - result <- &model - } - case frame.CanId&ACTION_ID_MASK == can.CAN_ID_073: - changed := false - model := ContactorInternalErrors{UnitId: unitId} - if val, ok := get(0, 3, frame.Payload); ok && model.BoardReady != BoardReadyType(val) { - model.BoardReady = BoardReadyType(val) - changed = true - } - if val, ok := get(3, 4, frame.Payload); ok && model.OtherError != ContactorInternalOtherErrorType(val) { - model.OtherError = ContactorInternalOtherErrorType(val) - changed = true - } - if val, ok := get(7, 3, frame.Payload); ok && model.ContactorGroupChanged != ContactorGroupChangedType(val) { - model.ContactorGroupChanged = ContactorGroupChangedType(val) - changed = true - } - if val, ok := get(10, 4, frame.Payload); ok && model.UnexpectedFormation != ContactorInternalOtherErrorType(val) { - model.UnexpectedFormation = ContactorInternalOtherErrorType(val) - changed = true - } - if val, ok := get(14, 2, frame.Payload); ok && model.CpuNotReady != ErrorType(val) { - model.CpuNotReady = ErrorType(val) - changed = true - } - if val, ok := get(16, 2, frame.Payload); ok && model.PuNotReady != ErrorType(val) { - model.PuNotReady = ErrorType(val) - changed = true - } - if val, ok := get(18, 2, frame.Payload); ok && model.Debug != BooleanType(val) { - model.Debug = BooleanType(val) - changed = true - } - if changed || !contactorsFirstErr[unitId] { - contactorsFirstErr[unitId] = true - result <- &model - } - case frame.CanId&ACTION_ID_MASK == can.CAN_ID_021: - changed := false - model := PuPresentEnergy{UnitId: unitId} - if val, ok := get(0, 2, frame.Payload); ok && model.V2GMode != V2GModeType(val) { - model.V2GMode = V2GModeType(val) - changed = true - } - if val, ok := get(2, 11, frame.Payload); ok && model.VoltageBefore != Voltage11BitType(val) { - model.VoltageBefore = Voltage11BitType(val) - changed = true - } - if val, ok := get(13, 11, frame.Payload); ok && model.VoltageAfter != Voltage11BitType(val) { - model.VoltageAfter = Voltage11BitType(val) - changed = true - } - if val, ok := get(24, 10, frame.Payload); ok && model.PresentCurrent != Current10BitType(val) { - model.PresentCurrent = Current10BitType(val) - changed = true - } - if changed || !puFirst[unitId] { - puFirst[unitId] = true - result <- &model - } - case frame.CanId&ACTION_ID_MASK == can.CAN_ID_022: - changed := false - model := PuPeriphery{UnitId: unitId} - if val, ok := get(0, 2, frame.Payload); ok && model.ConnectorInsert != BooleanType(val) { - model.ConnectorInsert = BooleanType(val) - changed = true - } - if val, ok := get(2, 2, frame.Payload); ok && model.ContactorOn != BooleanType(val) { - model.ContactorOn = BooleanType(val) - changed = true - } - if val, ok := get(4, 2, frame.Payload); ok && model.ConnectorLocked != BooleanType(val) { - model.ConnectorLocked = BooleanType(val) - changed = true - } - if val, ok := get(6, 3, frame.Payload); ok && model.CpLineLevel != CpLineLevelType(val) { - model.CpLineLevel = CpLineLevelType(val) - changed = true - } - if val, ok := get(9, 3, frame.Payload); ok && model.IsolationState != IsolationStateType(val) { - model.IsolationState = IsolationStateType(val) - changed = true - } - if val, ok := get(12, 2, frame.Payload); ok && model.ChargingAllowed != BooleanType(val) { - model.ChargingAllowed = BooleanType(val) - changed = true - } - if val, ok := get(14, 2, frame.Payload); ok && model.PwmEnabled != BooleanType(val) { - model.PwmEnabled = BooleanType(val) - changed = true - } - if val, ok := get(16, 9, frame.Payload); ok && model.CpLineVoltage != (Voltage9BitType(val)*0.1-15) { - model.CpLineVoltage = Voltage9BitType(val)*0.1 - 15 - changed = true - } - if changed || !puPeripheryFirst[unitId] { - puPeripheryFirst[unitId] = true - result <- &model - } + param := protocolMap[k] + var start uint8 = 0 + for _, f := range param.fields { + if val, found := get(start, f.length, frame.Payload); found { + start += f.length + f.last = now + if f.value != val { + f.value = val + f.setter(val) + result <- &Event{ + Field: f.name, + ActionName: param.name, + Object: param.object, + UnitId: unitId, + Updated: now, + } + } + } } + } }() return result } -func get(from uint, size uint, buffer []byte) (uint64, bool) { +func get(from uint8, size uint8, buffer []byte) (uint64, bool) { value := binary.LittleEndian.Uint64(buffer) var mask uint64 = ^(ALL_BITS << size)