victronDevice

Documentation

Index

• Variables
• type Config
• type DeviceStruct
  • func NewDevice(deviceConfig device.Config, victronConfig Config, ...) *DeviceStruct
  • func (c *DeviceStruct) Model() string
  • func (c *DeviceStruct) Run(ctx context.Context) (err error, immediateError bool)
• type VictronRegister
  • func FilterRegisters(input []VictronRegister, registerFilter dataflow.RegisterFilterConf) (output []VictronRegister)
  • func FilterRegistersByName(input []VictronRegister, names ...string) (output []VictronRegister)
  • func MergeRegisters(maps ...[]VictronRegister) (output []VictronRegister)
  • func NewEnumRegisterStruct(category, name, description string, address uint16, bit int, static bool, ...) VictronRegister
  • func NewNumberRegisterStruct(category, name, description string, address uint16, static bool, signed bool, ...) VictronRegister
  • func NewTextRegisterStruct(category, name, description string, address uint16, static bool, sort int) VictronRegister
  • func RegisterFactoryByProduct(product vedirect.VeProduct) []VictronRegister

Variables

var RegisterListBmv = MergeRegisters(
	RegisterListBmvMonitor,
	RegisterListBmvProduct,
	RegisterListBmvHistoric,
)

var RegisterListBmv700 = FilterRegistersByName(
	RegisterListBmv,
	"AuxVoltage",
	"BatteryTemperature",
	"MidPointVoltage",
	"MidPointVoltageDeviation",
	"AuxVoltageMinimum",
	"AuxVoltageMaximum",
)

var RegisterListBmv702 = FilterRegistersByName(
	RegisterListBmv,
	"ProductRevision",
	"Description",
)

var RegisterListBmv712 = FilterRegistersByName(
	RegisterListBmv,
	"ProductRevision",
	"Description",
)

var RegisterListBmvHistoric = []VictronRegister{
	NewNumberRegisterStruct(
		"Historic",
		"DepthOfTheDeepestDischarge",
		"Depth of the deepest discharge",
		0x0300,
		false,
		true,
		10,
		0,
		"Ah",
		300,
	), NewNumberRegisterStruct(
		"Historic",
		"DepthOfTheLastDischarge",
		"Depth of the last discharge",
		0x0301,
		false,
		true,
		10,
		0,
		"Ah",
		301,
	), NewNumberRegisterStruct(
		"Historic",
		"DepthOfTheAverageDischarge",
		"Depth of the average discharge",
		0x0302,
		false,
		true,
		10,
		0,
		"Ah",
		302,
	), NewNumberRegisterStruct(
		"Historic",
		"NumberOfCycles",
		"Number of cycles",
		0x0303,
		false,
		false,
		1,
		0,
		"",
		303,
	), NewNumberRegisterStruct(
		"Historic",
		"NumberOfFullDischarges",
		"Number of full discharges",
		0x0304,
		false,
		false,
		1,
		0,
		"",
		304,
	), NewNumberRegisterStruct(
		"Historic",
		"CumulativeAmpHours",
		"Cumulative amp hours",
		0x0305,
		false,
		true,
		10,
		0,
		"Ah",
		305,
	), NewNumberRegisterStruct(
		"Historic",
		"MainVoltageMinimum",
		"Minimum voltage",
		0x0306,
		false,
		false,
		100,
		0,
		"V",
		306,
	), NewNumberRegisterStruct(
		"Historic",
		"MainVoltageMaximum",
		"Maximum voltage",
		0x0307,
		false,
		false,
		100,
		0,
		"V",
		307,
	), NewNumberRegisterStruct(
		"Historic",
		"TimeSinceFullCharge",
		"Time since full charge",
		0x0308,
		false,
		false,
		1,
		0,
		"s",
		308,
	), NewNumberRegisterStruct(
		"Historic",
		"NumberOfAutomaticSynchronizations",
		"Number of automatic synchronizations",
		0x0309,
		false,
		false,
		1,
		0,
		"",
		309,
	), NewNumberRegisterStruct(
		"Historic",
		"NumberOfLowMainVoltageAlarms",
		"Number of low voltage alarms",
		0x030A,
		false,
		false,
		1,
		0,
		"",
		310,
	), NewNumberRegisterStruct(
		"Historic",
		"NumberOfHighMainVoltageAlarms",
		"Number of high voltage alarms",
		0x030B,
		false,
		false,
		1,
		0,
		"",
		311,
	), NewNumberRegisterStruct(
		"Historic",
		"AuxVoltageMinimum",
		"Minimum starter voltage",
		0x030E,
		false,
		true,
		100,
		0,
		"V",
		312,
	), NewNumberRegisterStruct(
		"Historic",
		"AuxVoltageMaximum",
		"Maximum starter voltage",
		0x030F,
		false,
		true,
		100,
		0,
		"V",
		313,
	), NewNumberRegisterStruct(
		"Historic",
		"AmountOfDischargedEnergy",
		"Amount of discharged energy",
		0x0310,
		false,
		false,
		100,
		0,
		"kWh",
		314,
	), NewNumberRegisterStruct(
		"Historic",
		"AmountOfChargedEnergy",
		"Amount of charged energy",
		0x0311,
		false,
		false,
		100,
		0,
		"kWh",
		315,
	),
}

var RegisterListBmvMonitor = []VictronRegister{
	NewNumberRegisterStruct(
		"Essential",
		"Power",
		"Power",
		0xED8E,
		false,
		true,
		1,
		0,
		"W",
		0,
	), NewNumberRegisterStruct(
		"Essential",
		"CurrentHighRes",
		"Current",
		0xED8C,
		false,
		true,
		1000,
		0,
		"A",
		1,
	),
	NewNumberRegisterStruct(
		"Essential",
		"MainVoltage",
		"Main voltage",
		0xED8D,
		false,
		true,
		100,
		0,
		"V",
		2,
	),
	NewNumberRegisterStruct(
		"Monitor",
		"AuxVoltage",
		"Aux (starter) voltage",
		0xED7D,
		false,
		false,
		100,
		0,
		"V",
		100,
	),
	NewNumberRegisterStruct(
		"Monitor",
		"Consumed",
		"Consumed",
		0xEEFF,
		false,
		true,
		10,
		0,
		"Ah",
		101,
	), NewNumberRegisterStruct(
		"Essential",
		"SOC",
		"State of charge",
		0x0FFF,
		false,
		false,
		100,
		0,
		"%",
		3,
	), NewNumberRegisterStruct(
		"Monitor",
		"TTG",
		"Time to go",
		0x0FFE,
		false,
		false,
		1,
		0,
		"min",
		102,
	), NewNumberRegisterStruct(
		"Essential",
		"BatteryTemperature",
		"Battery Temperature",
		0xEDEC,
		false,
		false,
		100,
		-273.15,
		"°C",
		4,
	), NewNumberRegisterStruct(
		"Monitor",
		"MidPointVoltage",
		"Mid-point voltage",
		0x0382,
		false,
		false,
		100,
		0,
		"V",
		104,
	), NewNumberRegisterStruct(
		"Monitor",
		"MidPointVoltageDeviation",
		"Mid-point voltage deviation",
		0x0383,
		false,
		true,
		10,
		0,
		"%",
		105,
	), NewEnumRegisterStruct(
		"Monitor",
		"SynchronizationState",
		"Synchronization state",
		0xEEB6, -1,
		false,
		map[int]string{
			0: "false",
			1: "true",
		},
		106,
	),
}

var RegisterListBmvProduct = []VictronRegister{
	NewNumberRegisterStruct(
		"Product",
		"ProductId",
		"Product id",
		0x0100,
		true,
		false,
		1,
		0,
		"",
		200,
	),
	NewNumberRegisterStruct(
		"Product",
		"ProductRevision",
		"Product revision",
		0x0101,
		true,
		false,
		1,
		0,
		"",
		201,
	),
	NewTextRegisterStruct(
		"Product",
		"SerialNumber",
		"Serial number",
		0x010A,
		true,
		202,
	),
	NewTextRegisterStruct(
		"Product",
		"ModelName",
		"Model name",
		0x010B,
		true,
		203,
	),
	NewTextRegisterStruct(
		"Product",
		"Description",
		"Description",
		0x010C,
		true,
		204,
	),
	NewNumberRegisterStruct(
		"Product",
		"Uptime",
		"Device uptime",
		0x0120,
		false,
		false,
		1,
		0,
		"s",
		205,
	),
}

var RegisterListInverter = MergeRegisters(
	RegisterListInverterProduct,
	RegisterListInverterGeneric,
	RegisterListInverterOffReasons,
	RegisterListInverterWarningReasons,
	RegisterListInverterHistory,
	RegisterListInverterOperation,
	RegisterListInverterAcOutControl,
	RegisterListInverterBatteryControl,
	RegisterListInverterDynamicCutoff,
	RegisterListInverterRelayControl,
)

var RegisterListInverterAcOutControl = []VictronRegister{
	NewNumberRegisterStruct(
		"AC-out settings",
		"AcOutVoltageSetpoint",
		"Voltage Setpoint",
		0x0230,
		true,
		false,
		100,
		0,
		"V",
		400,
	),
	NewNumberRegisterStruct(
		"AC-out settings",
		"AcOutVoltageSetpointMin",
		"Voltage Setpoint Minimum",
		0x0231,
		true,
		false,
		100,
		0,
		"V",
		401,
	),
	NewNumberRegisterStruct(
		"AC-out settings",
		"AcOutVoltageSetpointMax",
		"Voltage Setpoint Maximum",
		0x0232,
		true,
		false,
		100,
		0,
		"V",
		402,
	),

	NewEnumRegisterStruct(
		"AC-out settings",
		"InvWaveSet50HzNot60Hz",
		"Frequency",
		0xEB03, -1,
		true,
		map[int]string{
			0: "60 Hz",
			1: "50 Hz",
		},
		405,
	),
	NewNumberRegisterStruct(
		"AC-out settings",
		"InvOperEcoModeInvMin",
		"Inverter Eco Mode Inv Min",
		0xEB04,
		true,
		true,
		1000,
		0,
		"A",
		406,
	),
	NewNumberRegisterStruct(
		"AC-out settings",
		"InvOperEcoModeRetryTime",
		"Inverter Eco Mode Retry Time",
		0xEB06,
		true,
		false,
		4,
		0,
		"s",
		407,
	),
	NewNumberRegisterStruct(
		"AC-out settings",
		"InvOperEcoLoadDetectPeriods",
		"Inverter Eco Load Detect Periods",
		0xEB10,
		true,
		false,
		1,
		0,
		"",
		408,
	),
}

var RegisterListInverterBatteryControl = []VictronRegister{
	NewNumberRegisterStruct(
		"Battery settings",
		"ShutdownLowVoltageSet",
		"Shutdown Low Voltage",
		0x2210,
		true,
		false,
		100,
		0,
		"V",
		500,
	),
	NewNumberRegisterStruct(
		"Battery settings",
		"AlarmLowVoltageSet",
		"Alarm Low Voltage Set",
		0x0320,
		true,
		false,
		100,
		0,
		"V",
		501,
	),
	NewNumberRegisterStruct(
		"Battery settings",
		"AlarmLowVoltageClear",
		"Alarm Low Voltage Clear",
		0x0321,
		true,
		false,
		100,
		0,
		"V",
		502,
	),
	NewNumberRegisterStruct(
		"Battery settings",
		"VoltageRangeMin",
		"Voltage Range Min",
		0x2211,
		true,
		false,
		100,
		0,
		"V",
		503,
	),
	NewNumberRegisterStruct(
		"Battery settings",
		"VoltageRangeMax",
		"Voltage Range Max",
		0x2212,
		true,
		false,
		100,
		0,
		"V",
		504,
	),
}

var RegisterListInverterDynamicCutoff = []VictronRegister{
	NewEnumRegisterStruct(
		"Dynamic Cutoff",
		"InvProtUbatDynCutoffEnable",
		"Dynamic Cutoff Enable",
		0xEBBA, -1,
		true,
		map[int]string{
			0: "Disabled",
			1: "Enabled",
		},
		600,
	),
	NewNumberRegisterStruct(
		"Battery settings",
		"InvProtUbatDynCutoffFactor",
		"Factor",
		0xEBB7,
		true,
		false,
		1,
		0,
		"",
		601,
	),
	NewNumberRegisterStruct(
		"Battery settings",
		"InvProtUbatDynCutoffFactor2000",
		"Factor 2000",
		0xEBB5,
		true,
		false,
		1,
		0,
		"",
		602,
	),
	NewNumberRegisterStruct(
		"Battery settings",
		"InvProtUbatDynCutoffFactor250",
		"Factor 250",
		0xEBB3,
		true,
		false,
		1,
		0,
		"",
		603,
	),
	NewNumberRegisterStruct(
		"Battery settings",
		"InvProtUbatDynCutoffFactor5",
		"Factor 5",
		0xEBB2,
		true,
		false,
		1,
		0,
		"",
		604,
	),
	NewNumberRegisterStruct(
		"Battery settings",
		"InvProtUbatDynCutoffVoltage",
		"Voltage",
		0xEBB1,
		true,
		false,
		1000,
		0,
		"V",
		605,
	),
}

var RegisterListInverterGeneric = []VictronRegister{
	NewEnumRegisterStruct(
		"Essential",
		"DeviceState",
		"Device state",
		0x0201, -1,
		false,
		map[int]string{
			0: "Off",
			1: "Low Power",
			2: "Fault",
			9: "Inverting",
		},
		10,
	),

	NewEnumRegisterStruct(
		"Operation",
		"DeviceMode",
		"Device mode",
		0x0200, -1,
		false,
		map[int]string{
			2:    "Inverter On",
			3:    "Device On",
			4:    "Device Off",
			5:    "Eco mode",
			0xFD: "Hibernate",
		},
		300,
	),
}

var RegisterListInverterHistory = []VictronRegister{
	NewNumberRegisterStruct(
		"History",
		"HistoryTime",
		"Time",
		0x1040,
		false,
		false,
		1,
		0,
		"s",
		310,
	),
	NewNumberRegisterStruct(
		"History",
		"HistoryEnergy",
		"Energy",
		0x1041,
		false,
		false,
		100,
		0,
		"kVAh",
		311,
	),
}

var RegisterListInverterOffReasons = []VictronRegister{
	NewEnumRegisterStruct(
		"Off Reasons",
		"DeviceOffReasonNoInputPower",
		"No input power",
		0x0207, 0,
		false,
		inactiveActiveEnum,
		200,
	),
	NewEnumRegisterStruct(
		"Off Reasons",
		"DeviceOffReasonPowerButton",
		"Soft power button or SW controller",
		0x0207, 2,
		false,
		inactiveActiveEnum,
		201,
	),
	NewEnumRegisterStruct(
		"Off Reasons",
		"DeviceOffReasonRemoteInput",
		"HW remote input connector",
		0x0207, 3,
		false,
		inactiveActiveEnum,
		202,
	),
	NewEnumRegisterStruct(
		"Off Reasons",
		"DeviceOffReasonInternal",
		"Internal reason (see alarm reason)",
		0x0207, 4,
		false,
		inactiveActiveEnum,
		203,
	),
	NewEnumRegisterStruct(
		"Off Reasons",
		"DeviceOffReasonPayGo",
		"PayGo, out of credit, need token",
		0x0207, 5,
		false,
		inactiveActiveEnum,
		204,
	),
}

var RegisterListInverterOperation = []VictronRegister{
	NewNumberRegisterStruct(
		"Essential",
		"AcOutCurrent",
		"AC Output Current",
		0x2201,
		false,
		true,
		10,
		0,
		"A",
		2,
	),
	NewNumberRegisterStruct(
		"Essential",
		"AcOutVoltage",
		"AC Output Voltage",
		0x2200,
		false,
		true,
		100,
		0,
		"V",
		1,
	),

	NewNumberRegisterStruct(
		"Operation",
		"InvLoopGetIinv",
		"Inverter Loop get I inv",
		0xEB4E,
		false,
		true,
		1000,
		0,
		"A",
		301,
	),
	NewNumberRegisterStruct(
		"Essential",
		"DcChannel1Voltage",
		"Input Battery Voltage",
		0xED8D,
		false,
		true,
		100,
		0,
		"V",
		3,
	),
}

var RegisterListInverterProduct = []VictronRegister{
	NewNumberRegisterStruct(
		"Product",
		"ProductId",
		"Product id",
		0x0100,
		true,
		false,
		1,
		0,
		"",
		100,
	),
	NewNumberRegisterStruct(
		"Product",
		"ProductRevision",
		"Hardware Revision",
		0x0101,
		true,
		false,
		1,
		0,
		"",
		101,
	),
	NewNumberRegisterStruct(
		"Product",
		"AppVer",
		"Software Revision",
		0x0102,
		true,
		false,
		1,
		0,
		"",
		102,
	),
	NewTextRegisterStruct(
		"Product",
		"SerialNumber",
		"Serial number",
		0x010A,
		true,
		103,
	),
	NewTextRegisterStruct(
		"Product",
		"ModelName",
		"Model name",
		0x010B,
		true,
		104,
	),
	NewNumberRegisterStruct(
		"Product",
		"ACOutRatedPower",
		"AC Out Rated Power",
		0x2203,
		true,
		true,
		1,
		0,
		"VA",
		105,
	),

	NewNumberRegisterStruct(
		"Product",
		"ACOutNomVoltage",
		"AC Out Nominal Voltage",
		0x2202,
		true,
		false,
		1,
		0,
		"V",
		106,
	),
	NewNumberRegisterStruct(
		"Product",
		"BatVoltage",
		"Battery Voltage",
		0xEDEF,
		true,
		false,
		1,
		0,
		"V",
		106,
	),
}

var RegisterListInverterRelayControl = []VictronRegister{}

var RegisterListInverterWarningReasons = []VictronRegister{
	NewEnumRegisterStruct(
		"Warning Reasons",
		"DeviceWarningReasonLowBatVoltage",
		"Low battery voltage",
		0x031C, 0,
		false,
		inactiveActiveEnum,
		210,
	),
	NewEnumRegisterStruct(
		"Warning Reasons",
		"DeviceWarningReasonHighBatVoltage",
		"High battery voltage",
		0x031C, 1,
		false,
		inactiveActiveEnum,
		211,
	),
	NewEnumRegisterStruct(
		"Warning Reasons",
		"DeviceWarningReasonLowTemp",
		"Low temperature",
		0x031C, 5,
		false,
		inactiveActiveEnum,
		212,
	),
	NewEnumRegisterStruct(
		"Warning Reasons",
		"DeviceWarningReasonHighTemp",
		"High temperature",
		0x031C, 6,
		false,
		inactiveActiveEnum,
		213,
	),
	NewEnumRegisterStruct(
		"Warning Reasons",
		"DeviceWarningReasonOverload",
		"Overload",
		0x031C, 8,
		false,
		inactiveActiveEnum,
		214,
	),
	NewEnumRegisterStruct(
		"Warning Reasons",
		"DeviceWarningReasonPoorDC",
		"Poor DC connection",
		0x031C, 9,
		false,
		inactiveActiveEnum,
		215,
	),
	NewEnumRegisterStruct(
		"Warning Reasons",
		"DeviceWarningReasonLowAcVoltage",
		"Low AC-output voltage",
		0x031C, 10,
		false,
		inactiveActiveEnum,
		216,
	),
	NewEnumRegisterStruct(
		"Warning Reasons",
		"DeviceWarningReasonHighAcVoltage",
		"High AC-output voltage",
		0x031C, 11,
		false,
		inactiveActiveEnum,
		217,
	),
}

var RegisterListSolar = MergeRegisters(
	RegisterListSolarPanelData,
	RegisterListSolarChargerData,
	RegisterListSolarProduct,
	RegisterListSolarGeneric,
	RegisterListSolarSettings,
)

var RegisterListSolarChargerData = []VictronRegister{
	NewNumberRegisterStruct(
		"Essential",
		"BatteryTemperature",
		"Battery temperature",
		0xEDEC,
		false,
		false,
		100,
		-273.15,
		"°C",
		5,
	),
	NewNumberRegisterStruct(
		"Charger",
		"ChargerMaximumCurrent",
		"Charger maximum current",
		0xEDDF,
		false,
		false,
		10,
		0,
		"A",
		201,
	),
	NewNumberRegisterStruct(
		"Charger",
		"SystemYield",
		"System yield",
		0xEDDD,
		false,
		false,
		100,
		0,
		"kWh",
		202,
	),
	NewNumberRegisterStruct(
		"Charger",
		"SystemYieldResettable",
		"System yield (resettable)",
		0xEDDC,
		false,
		false,
		100,
		0,
		"kWh",
		203,
	),
	NewNumberRegisterStruct(
		"Charger",
		"ChargerInternalTemperature",
		"Charger internal temperature",
		0xEDDB,
		false,
		true,
		100,
		0,
		"°C",
		204,
	),
	NewEnumRegisterStruct(
		"Generic",
		"ChargerErrorCode",
		"Charger error",
		0xEDDA, -1,
		false,
		map[int]string{
			0:   "No error",
			2:   "Battery voltage too high",
			17:  "Charger internal temperature too high",
			18:  "Charger excessive output current",
			19:  "Charger current polarity reversed",
			20:  "Charger bulk time expired (when 10 hour bulk time protection active)",
			21:  "Charger current sensor issue (bias not within expected limits during off state)",
			26:  "Charger terminals overheated",
			28:  "Converter issue (dual converter models, one of the converters is not working)",
			33:  "Input voltage too high",
			34:  "Input excessive current",
			38:  "Input shutdown (due to excessive battery voltage)",
			39:  "Input shutdown (current flowing while the converter is switched off)",
			66:  "Incompatible device in the network (for synchronized charging)",
			67:  "BMS connection lost",
			68:  "Network misconfigured (e.g. combining ESS with ve.smart networking)",
			116: "Calibration data lost",
			117: "Incompatible firmware (i.e. not for this model)",
			119: "Settings data invalid / corrupted (use restore to defaults and set to recover)",
		},
		401,
	),
	NewNumberRegisterStruct(
		"Essential",
		"ChargerCurrent",
		"Charger current",
		0xEDD7,
		false,
		false,
		10,
		0,
		"A",
		1,
	),
	NewNumberRegisterStruct(
		"Essential",
		"ChargerVoltage",
		"Charger voltage",
		0xEDD5,
		false,
		false,
		100,
		0,
		"V",
		2,
	),

	NewNumberRegisterStruct(
		"Essential",
		"YieldToday",
		"Yield today",
		0xEDD3,
		false,
		false,
		100,
		0,
		"kWh",
		3,
	),
	NewNumberRegisterStruct(
		"Charger",
		"MaximumPowerToday",
		"Maximum power today",
		0xEDD2,
		false,
		false,
		1,
		0,
		"W",
		205,
	),
	NewNumberRegisterStruct(
		"Essential",
		"YieldYesterday",
		"Yield yesterday",
		0xEDD1,
		false,
		false,
		100,
		0,
		"kWh",
		4,
	),
	NewNumberRegisterStruct(
		"Charger",
		"MaximumPowerYesterday",
		"Maximum power yesterday",
		0xEDD0,
		false,
		false,
		1,
		0,
		"W",
		207,
	),
}

var RegisterListSolarGeneric = []VictronRegister{
	NewEnumRegisterStruct(
		"Generic",
		"DeviceMode",
		"Device mode",
		0x0200, -1,
		false,
		map[int]string{
			0: "Charger off",
			4: "Charger off",
			1: "Charger on",
		},
		400,
	),
	NewEnumRegisterStruct(
		"Essential",
		"State",
		"Device state",
		0x0201, -1,
		false,
		map[int]string{
			0:   "Not charging",
			2:   "Fault",
			3:   "Bulk Charging",
			4:   "Absorption Charging",
			5:   "Float Charging",
			7:   "Manual Equalise",
			245: "Wake-Up",
			247: "Auto  Equalise",
			252: "External Control",
			255: "Unavailable",
		},
		6,
	),
}

var RegisterListSolarPanelData = []VictronRegister{
	NewNumberRegisterStruct(
		"Essential",
		"PanelPower",
		"Panel power",
		0xEDBC,
		false,
		false,
		100,
		0,
		"W",
		0,
	),
	NewNumberRegisterStruct(
		"Panel",
		"PanelVoltage",
		"Panel voltage",
		0xEDBB,
		false,
		false,
		100,
		0,
		"V",
		100,
	),
	NewNumberRegisterStruct(
		"Panel",
		"PanelCurrent",
		"Panel current",
		0xEDBD,
		false,
		false,
		10,
		0,
		"A",
		101,
	),
	NewNumberRegisterStruct(
		"Panel",
		"PanelMaximumVoltage",
		"Panel maximum voltage",
		0xEDB8,
		true,
		false,
		100,
		0,
		"V",
		102,
	),
	NewEnumRegisterStruct(
		"Panel",
		"TrackerMode",
		"Tracker mode",
		0xEDB3, -1,
		false,
		map[int]string{
			0: "off",
			1: "voltage/current limited",
			2: "MPP tracker",
		},
		103,
	),
}

var RegisterListSolarProduct = []VictronRegister{
	NewNumberRegisterStruct(
		"Product",
		"ProductId",
		"Product id",
		0x0100,
		true,
		false,
		1,
		0,
		"",
		300,
	),
	NewNumberRegisterStruct(
		"Product",
		"GroupId",
		"Group id",
		0x0104,
		true,
		false,
		1,
		0,
		"",
		301,
	),
	NewTextRegisterStruct(
		"Product",
		"SerialNumber",
		"Serial number",
		0x010A,
		true,
		302,
	),
	NewTextRegisterStruct(
		"Product",
		"ModelName",
		"Model name",
		0x010B,
		true,
		303,
	),
}

var RegisterListSolarSettings = []VictronRegister{
	NewEnumRegisterStruct(
		"Settings",
		"AdaptiveMode",
		"Adaptive mode",
		0xEDFE, -1,
		true,
		map[int]string{
			0: "off",
			1: "on",
		},
		500,
	),
	NewNumberRegisterStruct(
		"Settings",
		"AutomaticEqualisationMode",
		"Automatic equalisation mode",
		0xEDFD,
		true,
		false,
		1,
		0,
		"",
		501,
	),
	NewNumberRegisterStruct(
		"Settings",
		"BatteryAbsorptionTimeLimit",
		"Battery absorption time limit",
		0xEDFB,
		true,
		false,
		100,
		0,
		"h",
		502,
	),
	NewNumberRegisterStruct(
		"Settings",
		"BatteryAbsorptionVoltage",
		"Battery absorption voltage",
		0xEDF7,
		true,
		false,
		100,
		0,
		"V",
		503,
	),
	NewNumberRegisterStruct(
		"Settings",
		"BatteryFloatVoltage",
		"Battery float voltage",
		0xEDF6,
		true,
		false,
		100,
		0,
		"V",
		504,
	),
	NewNumberRegisterStruct(
		"Settings",
		"BatteryEqualisationVoltage",
		"Battery equalisation voltage",
		0xEDF4,
		true,
		false,
		100,
		0,
		"V",
		505,
	),
	NewNumberRegisterStruct(
		"Settings",
		"BatteryTempCompensation",
		"Battery temperature compensation",
		0xEDF2,
		true,
		true,
		100,
		0,
		"mV/K",
		506,
	),
	NewEnumRegisterStruct(
		"Settings",
		"BatteryType",
		"Battery type",
		0xEDF1, -1,
		false,
		map[int]string{
			1:   "Gel Victron Long Life (14.1V)",
			2:   "Gel Victron Deep discharge (14.3V)",
			3:   "Gel Victron Deep discharge (14.4V)",
			4:   "AGM Victron Deep discharge (14.7V)",
			5:   "Tubular plate cyclic mode 1 (14.9V)",
			6:   "Tubular plate cyclic mode 2 (15.1V)",
			7:   "Tubular plate cyclic mode 3 (15.3V)",
			8:   "LiFEPO4 (14.2V)",
			255: "User defined",
		},
		507,
	),
	NewNumberRegisterStruct(
		"Settings",
		"BatteryMaximumCurrent",
		"Battery maximum current",
		0xEDF0,
		true,
		false,
		10,
		0,
		"A",
		508,
	),
	NewNumberRegisterStruct(
		"Settings",
		"BatteryVoltage",
		"Battery voltage",
		0xEDEF,
		true,
		false,
		1,
		0,
		"V",
		509,
	),
	NewEnumRegisterStruct(
		"Settings",
		"BatteryVoltageSetting",
		"Battery voltage setting",
		0xEDEA, -1,
		false,
		map[int]string{
			0:  "Auto detection at startup",
			12: "12V battery",
			24: "24V battery",
			36: "36V battery",
			48: "48V battery",
		},
		511,
	),
	NewEnumRegisterStruct(
		"Settings",
		"BmsPresent",
		"BMS present",
		0xEDE8, -1,
		false,
		map[int]string{
			0: "no",
			1: "yes",
		},
		512,
	),
	NewNumberRegisterStruct(
		"Settings",
		"TailCurrent",
		"Tail current",
		0xEDE7,
		true,
		false,
		10,
		0,
		"A",
		513,
	),
	NewNumberRegisterStruct(
		"Settings",
		"LowTempCurrent",
		"Low temperature charge current",
		0xEDE6,
		true,
		false,
		10,
		0,
		"A",
		514,
	),
	NewEnumRegisterStruct(
		"Settings",
		"AutoEqualiseStop",
		"Auto equalise stop on voltage",
		0xEDE5, -1,
		false,
		map[int]string{
			0: "no",
			1: "yes",
		},
		515,
	),
	NewNumberRegisterStruct(
		"Settings",
		"EqualisationCurrentLevel",
		"Equalisation current level",
		0xEDE4,
		true,
		false,
		1,
		0,
		"%",
		516,
	),
	NewNumberRegisterStruct(
		"Settings",
		"EqualisationDuration",
		"Equalisation duration",
		0xEDE3,
		true,
		false,
		100,
		0,
		"h",
		517,
	),
	NewNumberRegisterStruct(
		"Settings",
		"ReBulkVoltageOffset",
		"Re-bulk voltage offset",
		0xED2E,
		true,
		false,
		100,
		0,
		"V",
		518,
	),
	NewNumberRegisterStruct(
		"Settings",
		"BatteryLowTemperatureLevel",
		"Battery low temperature level",
		0xEDE0,
		true,
		true,
		100,
		0,
		"°C",
		519,
	),
}

Types

type Config

type Config interface {
	Device() string
	Kind() types.VictronDeviceKind
}

type DeviceStruct

type DeviceStruct struct {
	device.State
	// contains filtered or unexported fields
}

func NewDevice

func NewDevice(
	deviceConfig device.Config,
	victronConfig Config,
	stateStorage *dataflow.ValueStorage,
) *DeviceStruct

func (*DeviceStruct) Model

func (c *DeviceStruct) Model() string

func (*DeviceStruct) Run

func (c *DeviceStruct) Run(ctx context.Context) (err error, immediateError bool)

type VictronRegister

type VictronRegister struct {
	dataflow.RegisterStruct
	// contains filtered or unexported fields
}

func FilterRegisters

func FilterRegisters(input []VictronRegister, registerFilter dataflow.RegisterFilterConf) (output []VictronRegister)

func FilterRegistersByName

func FilterRegistersByName(input []VictronRegister, names ...string) (output []VictronRegister)

func MergeRegisters

func MergeRegisters(maps ...[]VictronRegister) (output []VictronRegister)

func NewEnumRegisterStruct

func NewEnumRegisterStruct(
	category, name, description string,
	address uint16,
	bit int,
	static bool,
	enum map[int]string,
	sort int,
) VictronRegister

func NewNumberRegisterStruct

func NewNumberRegisterStruct(
	category, name, description string,
	address uint16,
	static bool,
	signed bool,
	factor int,
	offset float64,
	unit string,
	sort int,
) VictronRegister

func NewTextRegisterStruct

func NewTextRegisterStruct(
	category, name, description string,
	address uint16,
	static bool,
	sort int,
) VictronRegister

func RegisterFactoryByProduct

func RegisterFactoryByProduct(product vedirect.VeProduct) []VictronRegister