Categorygithub.com/houaq/modbus
modulepackage
0.0.0-20211119011347-3afca28d75a4
Repository: https://github.com/houaq/modbus.git
Documentation: pkg.go.dev

# README

go modbus

Fault-tolerant, fail-fast implementation of Modbus protocol in Go.

Supported functions

Bit access:

  • Read Discrete Inputs
  • Read Coils
  • Write Single Coil
  • Write Multiple Coils

16-bit access:

  • Read Input Registers
  • Read Holding Registers
  • Write Single Register
  • Write Multiple Registers
  • Read/Write Multiple Registers
  • Mask Write Register
  • Read FIFO Queue

Supported formats

  • TCP
  • Serial (RTU, ASCII)

Usage

Basic usage:

// Modbus TCP
client := modbus.TCPClient("localhost:502")
// Read input register 9
results, err := client.ReadInputRegisters(8, 1)

// Modbus RTU/ASCII
// Default configuration is 19200, 8, 1, even
client = modbus.RTUClient("/dev/ttyS0")
results, err = client.ReadCoils(2, 1)

Advanced usage:

// Modbus TCP
handler := modbus.NewTCPClientHandler("localhost:502")
handler.Timeout = 10 * time.Second
handler.SlaveId = 0xFF
handler.Logger = log.New(os.Stdout, "test: ", log.LstdFlags)
// Connect manually so that multiple requests are handled in one connection session
err := handler.Connect()
defer handler.Close()

client := modbus.NewClient(handler)
results, err := client.ReadDiscreteInputs(15, 2)
results, err = client.WriteMultipleRegisters(1, 2, []byte{0, 3, 0, 4})
results, err = client.WriteMultipleCoils(5, 10, []byte{4, 3})
// Modbus RTU/ASCII
handler := modbus.NewRTUClientHandler("/dev/ttyUSB0")
handler.BaudRate = 115200
handler.DataBits = 8
handler.Parity = "N"
handler.StopBits = 1
handler.SlaveId = 1
handler.Timeout = 5 * time.Second

err := handler.Connect()
defer handler.Close()

client := modbus.NewClient(handler)
results, err := client.ReadDiscreteInputs(15, 2)

References

# Functions

ASCIIClient creates ASCII client with default handler and given connect string.
ASCIIOverTCPClient creates ASCII over TCP client with default handler and given connect string.
NewASCIIClientHandler allocates and initializes a ASCIIClientHandler.
NewASCIIOverTCPClientHandler allocates and initializes a ASCIIOverTCPClientHandler.
NewClient creates a new modbus client with given backend handler.
NewClient2 creates a new modbus client with given backend packager and transporter.
NewRTUClientHandler allocates and initializes a RTUClientHandler.
NewRTUOverTCPClientHandler allocates and initializes a RTUOverTCPClientHandler.
NewTCPClientHandler allocates a new TCPClientHandler.
RTUClient creates RTU client with default handler and given connect string.
RTUOverTCPClient creates RTU over TCP client with default handler and given connect string.
TCPClient creates TCP client with default handler and given connect string.

# Constants

ExceptionCodeAcknowledge error code.
ExceptionCodeGatewayPathUnavailable error code.
ExceptionCodeGatewayTargetDeviceFailedToRespond error code.
ExceptionCodeIllegalDataAddress error code.
ExceptionCodeIllegalDataValue error code.
ExceptionCodeIllegalFunction error code.
ExceptionCodeMemoryParityError error code.
ExceptionCodeServerDeviceBusy error code.
ExceptionCodeServerDeviceFailure error code.
FuncCodeMaskWriteRegister 16-bit wise access.
FuncCodeReadCoils for bit wise access.
FuncCodeReadDiscreteInputs for bit wise access.
FuncCodeReadFIFOQueue 16-bit wise access.
FuncCodeReadHoldingRegisters 16-bit wise access.
FuncCodeReadInputRegisters 16-bit wise access.
FuncCodeReadWriteMultipleRegisters 16-bit wise access.
FuncCodeWriteMultipleCoils for bit wise access.
FuncCodeWriteMultipleRegisters 16-bit wise access.
FuncCodeWriteSingleCoil for bit wise access.
FuncCodeWriteSingleRegister 16-bit wise access.

# Structs

ASCIIClientHandler implements Packager and Transporter interface.
ASCIIOverTCPClientHandler implements Packager and Transporter interface.
Error implements error interface.
InvalidLengthError is returned by readIncrementally when the modbus response would overflow buffer implemented to simplify testing.
ProtocolDataUnit (PDU) is independent of underlying communication layers.
RTUClientHandler implements Packager and Transporter interface.
RTUOverTCPClientHandler implements Packager and Transporter interface.
TCPClientHandler implements Packager and Transporter interface.

# Interfaces

Client declares the functionality of a Modbus client regardless of the underlying transport stream.
ClientHandler is the interface that groups the Packager and Transporter methods.
Connector exposes the underlying handler capability for open/connect and close the transport channel.
Packager specifies the communication layer.
Transporter specifies the transport layer.

# Type aliases

ErrTCPHeaderLength informs about a wrong header length.