modbusDevice

package
v3.11.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 6, 2026 License: MIT Imports: 13 Imported by: 0

Documentation

Index

Constants

View Source 
const InputRegisterAddressOffset = 30000

Variables

View Source 
var RegisterList7M38 = func() []FinderRegister {
	productRegisters := []FinderRegister{
		NewFinderRegister(
			"Device Info",
			"ModelNumber",
			"Model Number",
			FinderTStr16,
			30001, 30008,
			nil, -1,
			"",
			600,
		),
		NewFinderRegister(
			"Device Info",
			"SerialNumber",
			"Serial Number",
			FinderTStr8,
			30009, 30012,
			nil, -1,
			"",
			601,
		),
		NewFinderRegister(
			"Device Info",
			"SoftwareReference",
			"Software Reference",
			FinderT1,
			30013, 30013,
			nil, -1,
			"",
			602,
		),
		NewFinderRegister(
			"Device Info",
			"HardwareReference",
			"Hardware Reference",
			FinderTStr2,
			30014, 30014,
			nil, -1,
			"",
			603,
		),
		NewFinderRegister(
			"Essential",
			"P1valid",
			"Phase 1 measurement",
			FinderT1,
			30101, 30101,
			invalidEnum,
			0,
			"",
			30,
		),
		NewFinderRegister(
			"Essential",
			"P2valid",
			"Phase 2 measurement",
			FinderT1,
			30101, 30101,
			invalidEnum,
			1,
			"",
			31,
		),
		NewFinderRegister(
			"Essential",
			"P3valid",
			"Phase 3 measurement",
			FinderT1,
			30101, 30101,
			invalidEnum,
			2,
			"",
			32,
		),
	}

	ret := make([]FinderRegister, 0, len(productRegisters)+len(RegisterList7M38FloatRegisters))
	ret = append(ret, productRegisters...)

	for _, fr := range RegisterList7M38FloatRegisters {
		ret = append(ret,
			NewFinderRegister(
				fr.cat,
				fr.name,
				fr.desc,
				FinderTFloat,
				fr.addr, fr.addr+1,
				nil, -1,
				fr.unit,
				fr.sort,
			),
		)
	}

	return ret
}
View Source 
var RegisterList7M38FloatRegisters = []struct {
	addr                  uint16
	sort                  int
	cat, name, desc, unit string
}{
	{32480, 620, "Device Info", "RunTime", "Run time", "s"},
	{32484, 0, "Essential", "UAvgPN", "Uavg (phase to neutral)", "V"},
	{32486, 1, "Essential", "UAvgPP", "Uavg (phase to phase)", "V"},
	{32488, 100, "Current", "SI", "S I", "A"},
	{32490, 25, "Essential", "Pt", "Active Power Total", "W"},
	{32492, 200, "Power", "Qt", "Reactive Power Total", "var"},
	{32494, 201, "Power", "St", "Apparent Power Total", "VA"},
	{32496, 21, "Essential", "PFt", "Power Factor Total", ""},
	{32498, 5, "Essential", "F", "Frequency", "Hz"},
	{32500, 10, "Essential", "U1", "U1", "V"},
	{32502, 11, "Essential", "U2", "U2", "V"},
	{32504, 12, "Essential", "U3", "U3", "V"},
	{32508, 300, "Phase Geometry", "U12", "U12", "V"},
	{32510, 301, "Phase Geometry", "U23", "U23", "V"},
	{32512, 302, "Phase Geometry", "U31", "U31", "V"},
	{32516, 101, "Current", "I1", "I1", "A"},
	{32518, 102, "Current", "I2", "I2", "A"},
	{32520, 103, "Current", "I3", "I3", "A"},
	{32524, 104, "Current", "INCalc", "I neutral (calculated)", "A"},
	{32526, 105, "Current", "InMeas", "I neutral (measured)", "A"},
	{32528, 106, "Current", "Iavg", "Iavg", "A"},
	{32530, 20, "Essential", "P1", "Active Power Phase L1", "W"},
	{32532, 21, "Essential", "P2", "Active Power Phase L2", "W"},
	{32534, 22, "Essential", "P3", "Active Power Phase L3", "W"},
	{32538, 202, "Power", "Q1", "Reactive Power Phase L1", "var"},
	{32540, 203, "Power", "Q2", "Reactive Power Phase L2", "var"},
	{32542, 204, "Power", "Q3", "Reactive Power Phase L3", "var"},
	{32544, 205, "Power", "Qt", "Reactive Power Total", "var"},
	{32546, 206, "Power", "S1", "Apparent Power Phase L1 ", "VA"},
	{32548, 207, "Power", "S2", "Apparent Power Phase L2 ", "VA"},
	{32550, 208, "Power", "S3", "Apparent Power Phase L3 ", "VA"},
	{32552, 209, "Power", "St", "Apparent Power Total", "VA"},
	{32554, 210, "Power", "PF1", "Power Factor Phase 1", ""},
	{32556, 211, "Power", "PF2", "Power Factor Phase 2", ""},
	{32558, 212, "Power", "PF3", "Power Factor Phase 3", ""},
	{32560, 213, "Power", "PFt", "Power Factor Total", ""},
	{32562, 214, "Power", "PF1", "CAP/IND P. F. Phase 1", ""},
	{32564, 215, "Power", "PF2", "CAP/IND P. F. Phase 2", ""},
	{32566, 216, "Power", "PF3", "CAP/IND P. F. Phase 3", ""},
	{32568, 217, "Power", "PFt", "CAP/IND P. F. Total", ""},
	{32570, 310, "Phase Geometry", "J1", "j1 (angle between U1 and I1)", "°"},
	{32572, 311, "Phase Geometry", "J2", "j2 (angle between U2 and I2)", "°"},
	{32574, 312, "Phase Geometry", "J3", "j3 (angle between U3 and I3) ", "°"},
	{32576, 313, "Phase Geometry", "Jt", "Power Angle Total (atan2(Pt,Qt))", "°"},
	{32578, 314, "Phase Geometry", "J12", "j12 (angle between U1 and U2)", "°"},
	{32580, 315, "Phase Geometry", "J23", "j23 (angle between U2 and U3)", "°"},
	{32582, 316, "Phase Geometry", "J31", "j31 (angle between U3 and U1)", "°"},
	{32588, 400, "Distortion", "I1Thd", "I1 THD", "%"},
	{32590, 401, "Distortion", "I2Thd", "I2 THD", "%"},
	{32592, 402, "Distortion", "I3Thd", "I3 THD", "%"},
	{32594, 403, "Distortion", "U1Thd", "U1 THD", "%"},
	{32596, 404, "Distortion", "U2Thd", "U2 THD", "%"},
	{32598, 405, "Distortion", "U3Thd", "U3 THD", "%"},
	{32638, 500, "Energy Counter", "EcN1", "Energy Counter n1", "Wh"},
	{32640, 501, "Energy Counter", "EcN2", "Energy Counter n2", "varh"},
	{32642, 502, "Energy Counter", "EcN3", "Energy Counter n3", "Wh"},
	{32644, 503, "Energy Counter", "EcN4", "Energy Counter n4", "varh"},
	{32658, 40, "Essential", "InternalTemp", "Internal Temperature", "°C"},
	{32985, 610, "Device Info", "Unom", "nominal phase voltage", "V"},
	{32987, 611, "Device Info", "Inom", "nominal phase current", "A"},
	{32989, 612, "Device Info", "Pnom", "nominal phase power", "W"},
	{32991, 613, "Device Info", "Ptot", "nominal total power", "W"},
	{32993, 614, "Device Info", "Itot", "nominal total current", "A"},
	{32995, 615, "Device Info", "Fnom", "nominal frequency", "Hz"},
}

Functions

func FinderReadEnumRegister 

func FinderReadEnumRegister(c *DeviceStruct, register FinderRegister) (v dataflow.Value, err error)

func FinderReadFloatRegister 

func FinderReadFloatRegister(c *DeviceStruct, register FinderRegister) (v dataflow.Value, err error)

func FinderReadInputRegisters 

func FinderReadInputRegisters(c *DeviceStruct, register FinderRegister) (response []byte, err error)

func FinderReadInputRegistersRaw 

func FinderReadInputRegistersRaw(c *DeviceStruct, register FinderRegister) (response []byte, err error)

func FinderReadRegister 

func FinderReadRegister(c *DeviceStruct, reg FinderRegister) (v dataflow.Value, err error)

func FinderReadStringRegister 

func FinderReadStringRegister(c *DeviceStruct, register FinderRegister) (v dataflow.Value, err error)

func FinderReadUInt16Register 

func FinderReadUInt16Register(c *DeviceStruct, register FinderRegister) (v dataflow.Value, err error)

func WaveshareReadRelays 

func WaveshareReadRelays(writeRead WriteReadBusFunc, deviceAddress byte) (state [8]bool, err error)

func WaveshareReadSoftwareRevision 

func WaveshareReadSoftwareRevision(writeRead WriteReadBusFunc, deviceAddress byte) (version string, err error)

func WaveshareWriteRelay 

func WaveshareWriteRelay(writeRead WriteReadBusFunc, deviceAddress byte, relayNr uint16, command Command) (err error)

Types

type Command 

type Command uint16
const (
	RelayOpen  Command = 0x0000
	RelayClose Command = 0xFF00
)

Open / closed is reversed compared to the documentation of Waveshare. However, I opened the unit and found that sending a FF00 energize the relay and the LED.

type Config 

type Config interface {
	Bus() string
	Kind() types.ModbusDeviceKind
	Address() byte
	RelayDescription(name string) string
	RelayOpenLabel(name string) string
	RelayClosedLabel(name string) string
	PollInterval() time.Duration
}

type DeviceStruct 

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

func NewDevice 

func NewDevice(
	deviceConfig device.Config,
	modbusConfig Config,
	modbus Modbus,
	stateStorage *dataflow.ValueStorage,
	commandStorage *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 FinderRegister 

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

func NewFinderRegister 

func NewFinderRegister(
	category, name, description string,
	registerType FinderRegisterType,
	addressBegin, addressEnd uint16,
	enum map[int]string,
	bit int,
	unit string,
	sort int,
) FinderRegister

func (FinderRegister) CountBytes 

func (r FinderRegister) CountBytes() int

func (FinderRegister) CountRegisters 

func (r FinderRegister) CountRegisters() int

type FinderRegisterType 

type FinderRegisterType int
const (
	FinderT1 FinderRegisterType = iota
	FinderTStr2
	FinderTStr8
	FinderTStr16
	FinderTFloat
)

type FunctionCode 

type FunctionCode byte
const (
	FinderFunctionReadHoldingResgisters FunctionCode = 0x03
	FinderFunctionReadInputRegisters    FunctionCode = 0x04
)
const (
	WaveshareFunctionReadRelay             FunctionCode = 0x01
	WaveshareFunctionReadAddressAndVersion FunctionCode = 0x03
	WaveshareFunctionWriteRelay            FunctionCode = 0x05
)

type Modbus 

type Modbus interface {
	Name() string
	Shutdown()
	WriteRead(request []byte, responseBuf []byte) error
}

type WriteReadBusFunc 

type WriteReadBusFunc func(request []byte, responseBuf []byte) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.