libmodbusgo

func (*Error) Code ¶

func (e *Error) Code() ErrorCode

func (*Error) Error ¶

func (e *Error) Error() string

func (ErrorCode) Error ¶

func (c ErrorCode) Error() (e *Error)

func (*Modbus) Close ¶

func (x *Modbus) Close()

Close modbus_close - close a Modbus connection

The modbus_close() function shall close the connection established with the backend set in the context.

ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

func (*Modbus) Connect ¶

func (x *Modbus) Connect() (err error)

Connect modbus_connect - establish a Modbus connection

The modbus_connect() function shall establish a connection to a Modbus server, a network or a bus using the context information of libmodbus context given in argument.

ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

func (*Modbus) DisableQuirks ¶

func (x *Modbus) DisableQuirks(quirksMask ModbusQuirks) (err error)

DisableQuirks modbus_disable_quirks - disable a list of quirks according to a mask

The function shall disable the quirks according to the provided mask. It's useful to revert changes applied by a previous call to modbus_enable_quirks

To reset all quirks, you can use the specific value MODBUS_QUIRK_ALL.

modbus_enable_quirks(ctx, MODBUS_QUIRK_MAX_SLAVE | MODBUS_QUIRK_REPLY_TO_BROADCAST);

...

// Reset all quirks
modbus_disable_quirks(ctx, MODBUS_QUIRK_ALL);

ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

err = ctx.DisableQuirks(MODBUS_QUIRK_ALL)
if err != nil {
	fmt.Println(err)
	return
}

func (*Modbus) EnableQuirks ¶

func (x *Modbus) EnableQuirks(quirksMask ModbusQuirks) (err error)

EnableQuirks modbus_enable_quirks - enable a list of quirks according to a mask

The function is only useful when you are confronted with equipment which does not respect the protocol, which behaves strangely or when you wish to move away from the standard.

In that case, you can enable a specific quirk to workaround the issue, libmodbus offers the following flags:

• MODBUS_QUIRK_MAX_SLAVE allows slave adresses between 247 and 255.
• MODBUS_QUIRK_REPLY_TO_BROADCAST force a reply to a broacast request when the device is a slave in RTU mode (should be enabled on the slave device).

You can combine the flags by using the bitwise OR operator.

ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

err = ctx.EnableQuirks(MODBUS_QUIRK_MAX_SLAVE | MODBUS_QUIRK_REPLY_TO_BROADCAST)
if err != nil {
	fmt.Println(err)
	return
}

func (*Modbus) Flush ¶

func (x *Modbus) Flush() (err error)

Flush modbus_flush - flush non-transmitted data

The modbus_flush() function shall discard data received but not read to the socket or file descriptor associated to the context 'ctx'.

func (*Modbus) Free ¶

func (x *Modbus) Free()

Free modbus_free - free a libmodbus context

The modbus_free() function shall free an allocated modbus_t structure.

ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

func (*Modbus) GetByteTimeout ¶

func (x *Modbus) GetByteTimeout() (timeout time.Duration, err error)

GetByteTimeout modbus_get_byte_timeout - get timeout between bytes

The modbus_get_byte_timeout() function shall store the timeout interval between two consecutive bytes of the same message in the to_sec and to_usec arguments.

ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

timeout, err := ctx.GetByteTimeout()
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println(timeout)

func (*Modbus) GetHeaderLength ¶

func (x *Modbus) GetHeaderLength() (length int)

GetHeaderLength modbus_get_header_length - retrieve the current header length

The modbus_get_header_length() function shall retrieve the current header length from the backend. This function is convenient to manipulate a message and so it's limited to low-level operations.

func (*Modbus) GetIndicationTimeout ¶

func (x *Modbus) GetIndicationTimeout() (timeout time.Duration, err error)

GetIndicationTimeout modbus_get_indication_timeout - get timeout used to wait for an indication (request received by a server).

The modbus_get_indication_timeout() function shall store the timeout interval used to wait for an indication in the to_sec and to_usec arguments. Indication is the term used by the Modbus protocol to designate a request received by the server.

The default value is zero, it means the server will wait forever.

ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

timeout, err := ctx.GetIndicationTimeout()
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println(timeout)

func (*Modbus) GetResponseTimeout ¶

func (x *Modbus) GetResponseTimeout() (timeout time.Duration, err error)

GetResponseTimeout modbus_get_response_timeout - get timeout for response

The modbus_get_response_timeout() function shall return the timeout interval used to wait for a response in the to_sec and to_usec arguments.

ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

timeout, err := ctx.GetResponseTimeout()
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println(timeout)

func (*Modbus) GetSlave ¶

func (x *Modbus) GetSlave() (slave int, err error)

GetSlave modbus_get_slave - get slave number in the context

The modbus_get_slave() function shall get the slave number in the libmodbus context.

func (*Modbus) GetSocket ¶

func (x *Modbus) GetSocket() (s int, err error)

GetSocket modbus_get_socket - get the current socket of the context

The modbus_get_socket() function shall return the current socket or file descriptor of the libmodbus context.

func (*Modbus) MaskWriteRegister ¶

func (x *Modbus) MaskWriteRegister(addr int, andMask uint16, orMask uint16) (err error)

MaskWriteRegister modbus_mask_write_register - mask a single register

The modbus_mask_write_register() function shall modify the value of the holding register at the address 'addr' of the remote device using the algorithm:

new value = (current value AND 'and') OR ('or' AND (NOT 'and'))

The function uses the Modbus function code 0x16 (mask single register).

func (*Modbus) ReadBits ¶

func (x *Modbus) ReadBits(addr int, nb int) (out []byte, err error)

ReadBits modbus_read_bits - read many bits

The modbus_read_bits() function shall read the status of the nb bits (coils) to the address addr of the remote device. The result of reading is stored in dest array as unsigned bytes (8 bits) set to TRUE or FALSE.

You must take care to allocate enough memory to store the results in dest (at least nb * sizeof(uint8_t)).

The function uses the Modbus function code 0x01 (read coil status).

func (*Modbus) ReadInputBits ¶

func (x *Modbus) ReadInputBits(addr int, nb int) (out []byte, err error)

ReadInputBits modbus_read_input_bits - read many input bits

The modbus_read_input_bits() function shall read the content of the nb input bits to the address addr of the remote device. The result of reading is stored in dest array as unsigned bytes (8 bits) set to TRUE or FALSE.

You must take care to allocate enough memory to store the results in dest (at least nb * sizeof(uint8_t)).

The function uses the Modbus function code 0x02 (read input status).

func (*Modbus) ReadInputRegisters ¶

func (x *Modbus) ReadInputRegisters(addr int, nb int) (out []uint16, err error)

ReadInputRegisters modbus_read_input_registers - read many input registers

The modbus_read_input_registers() function shall read the content of the nb input registers to address addr of the remote device. The result of the reading is stored in dest array as word values (16 bits).

You must take care to allocate enough memory to store the results in dest (at least nb * sizeof(uint16_t)).

The function uses the Modbus function code 0x04 (read input registers). The holding registers and input registers have different historical meaning, but nowadays it's more common to use holding registers only.

func (*Modbus) ReadRegisters ¶

func (x *Modbus) ReadRegisters(addr int, nb int) (out []uint16, err error)

ReadRegisters modbus_read_registers - read many registers

The modbus_read_registers() function shall read the content of the nb holding registers to the address addr of the remote device. The result of reading is stored in dest array as word values (16 bits).

You must take care to allocate enough memory to store the results in dest (at least nb * sizeof(uint16_t)).

The function uses the Modbus function code 0x03 (read holding registers).

ctx := ModbusNewRtu("/dev/ttyUSB0", 115200, 'N', 8, 1)
if ctx == nil {
	fmt.Println("Unable to create the libmodbus context")
	return
}
defer ctx.Free()
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

err = ctx.SetSlave(1)
if err != nil {
	fmt.Println(err)
	return
}
out, err := ctx.ReadRegisters(0, 2)
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println(out)

func (*Modbus) Receive ¶

func (x *Modbus) Receive() (req []byte, err error)

Receive modbus_receive - receive an indication request

The modbus_receive() function shall receive an indication request from the socket of the context ctx. This function is used by a Modbus slave/server to receive and analyze indication request sent by the masters/clients.

If you need to use another socket or file descriptor than the one defined in the context ctx, see the function modbus_set_socket.

func (*Modbus) ReceiveConfirmation ¶

func (x *Modbus) ReceiveConfirmation() (rsp []byte, err error)

ReceiveConfirmation modbus_receive_confirmation - receive a confirmation request

The modbus_receive_confirmation() function shall receive a request via the socket of the context ctx. This function must be used for debugging purposes because the received response isn't checked against the initial request. This function can be used to receive request not handled by the library.

The maximum size of the response depends on the used backend, in RTU the rsp array must be MODBUS_RTU_MAX_ADU_LENGTH bytes and in TCP it must be MODBUS_TCP_MAX_ADU_LENGTH bytes. If you want to write code compatible with both, you can use the constant MODBUS_MAX_ADU_LENGTH (maximum value of all libmodbus backends). Take care to allocate enough memory to store responses to avoid crashes of your server.

var ctx *Modbus // just for test

rsp, err := ctx.ReceiveConfirmation()
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println(rsp)

func (*Modbus) Reply ¶

func (x *Modbus) Reply(req []byte, mm *ModbusMapping) (err error)

Reply modbus_reply - send a response to the received request

The modbus_reply() function shall send a response to received request. The request req given in argument is analyzed, a response is then built and sent by using the information of the modbus context ctx.

If the request indicates to read or write a value the operation will done in the modbus mapping mb_mapping according to the type of the manipulated data.

If an error occurs, an exception response will be sent.

This function is designed for Modbus servers.

func (*Modbus) ReplyException ¶

func (x *Modbus) ReplyException(req []byte, ecode uint) (err error)

ReplyException modbus_reply_exception - send an exception response

The modbus_reply_exception() function shall send an exception response based on the 'exception_code' in argument.

The libmodbus provides the following exception codes:

• MODBUS_EXCEPTION_ILLEGAL_FUNCTION (1)
• MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS (2)
• MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE (3)
• MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE (4)
• MODBUS_EXCEPTION_ACKNOWLEDGE (5)
• MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY (6)
• MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE (7)
• MODBUS_EXCEPTION_MEMORY_PARITY (8)
• MODBUS_EXCEPTION_NOT_DEFINED (9)
• MODBUS_EXCEPTION_GATEWAY_PATH (10)
• MODBUS_EXCEPTION_GATEWAY_TARGET (11)

The initial request req is required to build a valid response.

func (*Modbus) ReportSlaveId ¶

func (x *Modbus) ReportSlaveId() (dest *ReportSlaveId, err error)

ReportSlaveId modbus_report_slave_id - returns a description of the controller

The modbus_report_slave_id() function shall send a request to the controller to obtain a description of the controller.

The response stored in dest contains:

• the slave ID, this unique ID is in reality not unique at all so it's not possible to depend on it to know how the information are packed in the response.
• the run indicator status (0x00 = OFF, 0xFF = ON)
• additional data specific to each controller. For example, libmodbus returns the version of the library as a string.

The function writes at most max_dest bytes from the response to dest so you must ensure that dest is large enough.

ctx := ModbusNewRtu("/dev/ttyUSB0", 115200, 'N', 8, 1)
if ctx == nil {
	fmt.Println("Unable to create the libmodbus context")
	return
}
defer ctx.Free()
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

report, err := ctx.ReportSlaveId()
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println(report.SlaveId)
fmt.Println(report.RunIndicatorStatus)

func (*Modbus) RtuGetRts ¶

func (x *Modbus) RtuGetRts() (mode int, err error)

RtuGetRts modbus_rtu_get_rts - get the current RTS mode in RTU

The modbus_rtu_get_rts() function shall get the current Request To Send mode of the libmodbus context ctx. The possible returned values are:

• MODBUS_RTU_RTS_NONE
• MODBUS_RTU_RTS_UP
• MODBUS_RTU_RTS_DOWN

This function can only be used with a context using a RTU backend.

func (*Modbus) RtuGetRtsDelay ¶

func (x *Modbus) RtuGetRtsDelay() (us time.Duration, err error)

RtuGetRtsDelay modbus_rtu_get_rts_delay - get the current RTS delay in RTU

The modbus_rtu_get_rts_delay() function shall get the current Request To Send delay period of the libmodbus context 'ctx'.

This function can only be used with a context using a RTU backend.

func (*Modbus) RtuGetSerialMode ¶

func (x *Modbus) RtuGetSerialMode() (mode int, err error)

RtuGetSerialMode modbus_rtu_get_serial_mode - get the current serial mode

The modbus_rtu_get_serial_mode() function shall return the serial mode currently used by the libmodbus context:

• MODBUS_RTU_RS232, the serial line is set for RS-232 communication. RS-232 (Recommended Standard 232) is the traditional name for a series of standards for serial binary single-ended data and control signals connecting between a DTE (Data Terminal Equipment) and a DCE (Data Circuit-terminating Equipment). It is commonly used in computer serial ports

• MODBUS_RTU_RS485, the serial line is set for RS-485 communication. EIA-485, also known as TIA/EIA-485 or RS-485, is a standard defining the electrical characteristics of drivers and receivers for use in balanced digital multipoint systems. This standard is widely used for communications in industrial automation because it can be used effectively over long distances and in electrically noisy environments. This function is only available on Linux kernels 2.6.28 onwards and can only be used with a context using a RTU backend.

func (*Modbus) RtuReceive ¶ added in v0.1.1

func (x *Modbus) RtuReceive() (req []byte, err error)

RtuReceive modbus_receive - receive an indication request

The modbus_receive() function shall receive an indication request from the socket of the context ctx. This function is used by a Modbus slave/server to receive and analyze indication request sent by the masters/clients.

If you need to use another socket or file descriptor than the one defined in the context ctx, see the function modbus_set_socket.

func (*Modbus) RtuReceiveConfirmation ¶ added in v0.1.1

func (x *Modbus) RtuReceiveConfirmation() (rsp []byte, err error)

RtuReceiveConfirmation modbus_receive_confirmation - receive a confirmation request

The modbus_receive_confirmation() function shall receive a request via the socket of the context ctx. This function must be used for debugging purposes because the received response isn't checked against the initial request. This function can be used to receive request not handled by the library.

The maximum size of the response depends on the used backend, in RTU the rsp array must be MODBUS_RTU_MAX_ADU_LENGTH bytes and in TCP it must be MODBUS_TCP_MAX_ADU_LENGTH bytes. If you want to write code compatible with both, you can use the constant MODBUS_MAX_ADU_LENGTH (maximum value of all libmodbus backends). Take care to allocate enough memory to store responses to avoid crashes of your server.

func (*Modbus) RtuSetCustomRts ¶

func (x *Modbus) RtuSetCustomRts(cb SetRtsCallback) (err error)

RtuSetCustomRts modbus_rtu_set_custom_rts - set a function to be used for custom RTS implementation

The modbus_rtu_set_custom_rts() function shall set a custom function to be called when the RTS pin is to be set before and after a transmission. By default this is set to an internal function that toggles the RTS pin using an ioctl call.

Note that this function adheres to the RTS mode, the values MODBUS_RTU_RTS_UP or MODBUS_RTU_RTS_DOWN must be used for the function to be called.

This function can only be used with a context using a RTU backend.

func (*Modbus) RtuSetRts ¶

func (x *Modbus) RtuSetRts(mode int) (err error)

RtuSetRts modbus_rtu_set_rts - set the RTS mode in RTU

The modbus_rtu_set_rts() function shall set the Request To Send mode to communicate on a RS-485 serial bus. By default, the mode is set to MODBUS_RTU_RTS_NONE and no signal is issued before writing data on the wire.

To enable the RTS mode, the values MODBUS_RTU_RTS_UP or MODBUS_RTU_RTS_DOWN must be used, these modes enable the RTS mode and set the polarity at the same time. When MODBUS_RTU_RTS_UP is used, an ioctl call is made with RTS flag enabled then data is written on the bus after a delay of 1 ms, then another ioctl call is made with the RTS flag disabled and again a delay of 1 ms occurs. The MODBUS_RTU_RTS_DOWN mode applies the same procedure but with an inverted RTS flag.

This function can only be used with a context using a RTU backend.

ctx := ModbusNewRtu("/dev/ttyUSB0", 115200, 'N', 8, 1)
if ctx == nil {
	fmt.Println("Unable to create the libmodbus context")
	return
}
defer ctx.Free()
ctx.SetSlave(1)
ctx.RtuSetSerialMode(MODBUS_RTU_RS485)
ctx.RtuSetRts(MODBUS_RTU_RTS_UP)
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

report, err := ctx.ReportSlaveId()
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println(report.SlaveId)
fmt.Println(report.RunIndicatorStatus)

func (*Modbus) RtuSetRtsDelay ¶

func (x *Modbus) RtuSetRtsDelay(us time.Duration) (err error)

RtuSetRtsDelay modbus_rtu_set_rts_delay - set the RTS delay in RTU

The modbus_rtu_set_rts_delay() function shall set the Request To Send delay period of the libmodbus context 'ctx'.

This function can only be used with a context using a RTU backend.

func (*Modbus) RtuSetSerialMode ¶

func (x *Modbus) RtuSetSerialMode(mode int) (err error)

RtuSetSerialMode modbus_rtu_set_serial_mode - set the serial mode

The modbus_rtu_set_serial_mode() function shall set the selected serial mode:

• MODBUS_RTU_RS232, the serial line is set for RS-232 communication. RS-232 (Recommended Standard 232) is the traditional name for a series of standards for serial binary single-ended data and control signals connecting between a DTE (Data Terminal Equipment) and a DCE (Data Circuit-terminating Equipment). It is commonly used in computer serial ports.

• MODBUS_RTU_RS485, the serial line is set for RS-485 communication. EIA-485, also known as TIA/EIA-485 or RS-485, is a standard defining the electrical characteristics of drivers and receivers for use in balanced digital multipoint systems. This standard is widely used for communications in industrial automation because it can be used effectively over long distances and in electrically noisy environments.

This function is only supported on Linux kernels 2.6.28 onwards.

ctx := ModbusNewRtu("/dev/ttyUSB0", 115200, 'N', 8, 1)
if ctx == nil {
	fmt.Println("Unable to create the libmodbus context")
	return
}
defer ctx.Free()
ctx.SetSlave(1)
ctx.RtuSetSerialMode(MODBUS_RTU_RS485)
ctx.RtuSetRts(MODBUS_RTU_RTS_UP)
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

report, err := ctx.ReportSlaveId()
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println(report.SlaveId)
fmt.Println(report.RunIndicatorStatus)

func (*Modbus) SendRawRequest ¶

func (x *Modbus) SendRawRequest(raw []byte) (err error)

SendRawRequest modbus_send_raw_request - send a raw request

The modbus_send_raw_request() function shall send a request via the socket of the context ctx. This function must be used for debugging purposes because you have to take care to make a valid request by hand. The function only adds to the message, the header or CRC of the selected backend, so raw_req must start and contain at least a slave/unit identifier and a function code. This function can be used to send request not handled by the library.

The public header of libmodbus provides a list of supported Modbus functions codes, prefixed by MODBUS_FC_ (eg. MODBUS_FC_READ_HOLDING_REGISTERS), to help build of raw requests.

ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

req := []byte{0xFF, MODBUS_FC_READ_HOLDING_REGISTERS, 0x00, 0x01, 0x0, 0x05}

err = ctx.SendRawRequest(req)
if err != nil {
	fmt.Println(err)
	return
}
rsp, err := ctx.ReceiveConfirmation()
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println(rsp)

func (*Modbus) SendRawRequestTid ¶

func (x *Modbus) SendRawRequestTid(raw []byte, tid int) (err error)

func (*Modbus) SetByteTimeout ¶

func (x *Modbus) SetByteTimeout(timeout time.Duration) (err error)

SetByteTimeout modbus_set_byte_timeout - set timeout between bytes

The modbus_set_byte_timeout() function shall set the timeout interval between two consecutive bytes of the same message. The timeout is an upper bound on the amount of time elapsed before select() returns, if the time elapsed is longer than the defined timeout, an ETIMEDOUT error will be raised by the function waiting for a response.

The value of to_usec argument must be in the range 0 to 999999.

If both to_sec and to_usec are zero, this timeout will not be used at all. In this case, modbus_set_response_timeout() governs the entire handling of the response, the full confirmation response must be received before expiration of the response timeout. When a byte timeout is set, the response timeout is only used to wait for until the first byte of the response.

func (*Modbus) SetDebug ¶

func (x *Modbus) SetDebug(flag bool) (err error)

SetDebug modbus_set_debug - set debug flag of the context

The modbus_set_debug() function shall set the debug flag of the modbus_t context by using the argument flag. By default, the boolean flag is set to FALSE. When the flag value is set to TRUE, many verbose messages are displayed on stdout and stderr. For example, this flag is useful to display the bytes of the Modbus messages.

func (*Modbus) SetErrorRecovery ¶

func (x *Modbus) SetErrorRecovery(errorRecovery ModbusErrorRecoveryMode) (err error)

SetErrorRecovery modbus_set_error_recovery - set the error recovery mode

The modbus_set_error_recovery() function shall set the error recovery mode to apply when the connection fails or the byte received is not expected. The argument error_recovery may be bitwise-or'ed with zero or more of the following constants.

By default there is no error recovery (MODBUS_ERROR_RECOVERY_NONE) so the application is responsible for controlling the error values returned by libmodbus functions and for handling them if necessary.

When MODBUS_ERROR_RECOVERY_LINK is set, the library will attempt an reconnection after a delay defined by response timeout of the libmodbus context. This mode will try an infinite close/connect loop until success on send call and will just try one time to re-establish the connection on select/read calls (if the connection was down, the values to read are certainly not available any more after reconnection, except for slave/server). This mode will also run flush requests after a delay based on the current response timeout in some situations (eg. timeout of select call). The reconnection attempt can hang for several seconds if the network to the remote target unit is down.

When MODBUS_ERROR_RECOVERY_PROTOCOL is set, a sleep and flush sequence will be used to clean up the ongoing communication, this can occurs when the message length is invalid, the TID is wrong or the received function code is not the expected one. The response timeout delay will be used to sleep.

The modes are mask values and so they are complementary.

It's not recommended to enable error recovery for a Modbus slave/server.

ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()
err := ctx.SetErrorRecovery(MODBUS_ERROR_RECOVERY_LINK | MODBUS_ERROR_RECOVERY_PROTOCOL)
if err != nil {
	fmt.Println(err)
	return
}
err = ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

func (*Modbus) SetIndicationTimeout ¶

func (x *Modbus) SetIndicationTimeout(timeout time.Duration) (err error)

SetIndicationTimeout modbus_set_indication_timeout - set timeout between indications

The modbus_set_indication_timeout() function shall set the timeout interval used by a server to wait for a request from a client.

The value of to_usec argument must be in the range 0 to 999999.

If both to_sec and to_usec are zero, this timeout will not be used at all. In this case, the server will wait forever.

func (*Modbus) SetResponseTimeout ¶

func (x *Modbus) SetResponseTimeout(timeout time.Duration) (err error)

SetResponseTimeout modbus_set_response_timeout - set timeout for response

The modbus_set_response_timeout() function shall set the timeout interval used to wait for a response. When a byte timeout is set, if elapsed time for the first byte of response is longer than the given timeout, an ETIMEDOUT error will be raised by the function waiting for a response. When byte timeout is disabled, the full confirmation response must be received before expiration of the response timeout.

The value of to_usec argument must be in the range 0 to 999999.

ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

err = ctx.SetResponseTimeout(0)
if err != nil {
	fmt.Println(err)
	return
}

func (*Modbus) SetSlave ¶

func (x *Modbus) SetSlave(slave int) (err error)

SetSlave modbus_set_slave - set slave number in the context

The modbus_set_slave() function shall set the slave number in the libmodbus context.

It is usually only required to set the slave ID in RTU. The meaning of this ID will be different if your program acts as client (master) or server (slave).

As RTU client, modbus_set_slave() sets the ID of the remote device you want to communicate. Be sure to set the slave ID before issuing any Modbus requests on the serial bus. If you communicate with several servers (slaves), you can set the slave ID of the remote device before each request.

As RTU server, the slave ID allows the various clients to reach your service. You should use a free ID, once set, this ID should be known by the clients of the network. According to the protocol, a Modbus device must only accept message holding its slave number or the special broadcast number.

In TCP, the slave number is only required if the message must reach a device on a serial network. Some not compliant devices or software (such as modpoll) uses the slave ID as unit identifier, that's incorrect (cf page 23 of Modbus Messaging Implementation Guide v1.0b) but without the slave value, the faulty remote device or software drops the requests! The special value MODBUS_TCP_SLAVE (0xFF) can be used in TCP mode to restore the default value.

The broadcast address is MODBUS_BROADCAST_ADDRESS. This special value must be use when you want all Modbus devices of the network receive the request.

ctx := ModbusNewRtu("/dev/ttyUSB0", 115200, 'N', 8, 1)
if ctx == nil {
	fmt.Println("Unable to create the libmodbus context")
	return
}
defer ctx.Free()
err := ctx.Connect()
if err != nil {
	fmt.Println(err)
	return
}
defer ctx.Close()

err = ctx.SetSlave(1)
if err != nil {
	fmt.Println(err)
	return
}
out, err := ctx.ReadRegisters(0, 2)
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println(out)

func (*Modbus) SetSocket ¶

func (x *Modbus) SetSocket(s int) (err error)

SetSocket modbus_set_socket - set socket of the context

The modbus_set_socket() function shall set the socket or file descriptor in the libmodbus context. This function is useful for managing multiple client connections to the same server.

const NB_CONNECTION = 100
ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()

ss, err := ctx.TcpListen(NB_CONNECTION)
if err != nil {
	fmt.Println(err)
	return
}

var mm *ModbusMapping // TODO:

var ms int
rs := &unix.FdSet{}
rs.Zero()
rs.Set(ss)

// ... TODO:

if rs.IsSet(ms) {
	ctx.SetSocket(ms)
	req, err := ctx.Receive()
	if err == nil {
		ctx.Reply(req, mm)
	}
}

func (*Modbus) TcpAccept ¶

func (x *Modbus) TcpAccept() (socket int, err error)

TcpAccept modbus_tcp_accept - accept a new connection on a TCP Modbus socket (IPv4)

The modbus_tcp_accept() function shall extract the first connection on the queue of pending connections, create a new socket and store it in libmodbus context given in argument. If available, accept4() with SOCK_CLOEXEC will be called instead of accept().

const NB_CONNECTION = 100
ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()

_, err := ctx.TcpListen(NB_CONNECTION)
if err != nil {
	fmt.Println(err)
	return
}
_, err = ctx.TcpAccept()
if err != nil {
	fmt.Println(err)
	return
}

func (*Modbus) TcpListen ¶

func (x *Modbus) TcpListen(nb int) (socket int, err error)

TcpListen modbus_tcp_listen - create and listen a TCP Modbus socket (IPv4)

The modbus_tcp_listen() function shall create a socket and listen to maximum nb_connection incoming connections on the specified IP address. The context ctx must be allocated and initialized with modbus_new_tcp before to set the IP address to listen, if IP address is set to NULL or '0.0.0.0', any addresses will be listen.

const NB_CONNECTION = 100
ctx := ModbusNewTcp("127.0.0.1", 502)
if ctx == nil {
	return
}
defer ctx.Free()

_, err := ctx.TcpListen(NB_CONNECTION)
if err != nil {
	fmt.Println(err)
	return
}
_, err = ctx.TcpAccept()
if err != nil {
	fmt.Println(err)
	return
}

func (*Modbus) TcpPiAccept ¶

func (x *Modbus) TcpPiAccept() (err error)

TcpPiAccept modbus_tcp_pi_accept - accept a new connection on a TCP PI Modbus socket (IPv6)

The modbus_tcp_pi_accept() function shall extract the first connection on the queue of pending connections, create a new socket and store it in libmodbus context given in argument. If available, accept4() with SOCK_CLOEXEC will be called instead of accept().

const NB_CONNECTION = 100
ctx := ModbusNewTcpPi("::0", "502")
if ctx == nil {
	return
}
defer ctx.Free()

_, err := ctx.TcpPiListen(NB_CONNECTION)
if err != nil {
	fmt.Println(err)
	return
}
err = ctx.TcpPiAccept()
if err != nil {
	fmt.Println(err)
	return
}

func (*Modbus) TcpPiListen ¶

func (x *Modbus) TcpPiListen(nb int) (socket int, err error)

TcpPiListen modbus_tcp_pi_listen - create and listen a TCP PI Modbus socket (IPv6)

The modbus_tcp_pi_listen() function shall create a socket and listen to maximum nb_connection incoming connections on the specified nodes. The context ctx must be allocated and initialized with modbus_new_tcp_pi before to set the node to listen, if node is set to NULL or '0.0.0.0', any addresses will be listen.

const NB_CONNECTION = 100
ctx := ModbusNewTcpPi("::0", "502")
if ctx == nil {
	return
}
defer ctx.Free()

_, err := ctx.TcpPiListen(NB_CONNECTION)
if err != nil {
	fmt.Println(err)
	return
}
err = ctx.TcpPiAccept()
if err != nil {
	fmt.Println(err)
	return
}

func (*Modbus) TcpReceive ¶ added in v0.1.1

func (x *Modbus) TcpReceive() (req []byte, err error)

TcpReceive modbus_receive - receive an indication request

The modbus_receive() function shall receive an indication request from the socket of the context ctx. This function is used by a Modbus slave/server to receive and analyze indication request sent by the masters/clients.

If you need to use another socket or file descriptor than the one defined in the context ctx, see the function modbus_set_socket.

func (*Modbus) TcpReceiveConfirmation ¶ added in v0.1.1

func (x *Modbus) TcpReceiveConfirmation() (rsp []byte, err error)

RtuReceiveConfirmation modbus_receive_confirmation - receive a confirmation request

The modbus_receive_confirmation() function shall receive a request via the socket of the context ctx. This function must be used for debugging purposes because the received response isn't checked against the initial request. This function can be used to receive request not handled by the library.

The maximum size of the response depends on the used backend, in RTU the rsp array must be MODBUS_RTU_MAX_ADU_LENGTH bytes and in TCP it must be MODBUS_TCP_MAX_ADU_LENGTH bytes. If you want to write code compatible with both, you can use the constant MODBUS_MAX_ADU_LENGTH (maximum value of all libmodbus backends). Take care to allocate enough memory to store responses to avoid crashes of your server.

func (*Modbus) TcpSocket ¶ added in v0.1.5

func (x *Modbus) TcpSocket() int

TcpSocket get listened tcp socket (IPv4)

func (*Modbus) WriteAndReadRegisters ¶

func (x *Modbus) WriteAndReadRegisters(writeAddr int, src []uint16, readAddr int, readNb int) (dest []uint16, err error)

WriteAndReadRegisters modbus_write_and_read_registers - write and read many registers in a single transaction

The modbus_write_and_read_registers() function shall write the content of the write_nb holding registers from the array 'src' to the address write_addr of the remote device then shall read the content of the read_nb holding registers to the address read_addr of the remote device. The result of reading is stored in dest array as word values (16 bits).

You must take care to allocate enough memory to store the results in dest (at least nb * sizeof(uint16_t)).

The function uses the Modbus function code 0x17 (write/read registers).

func (*Modbus) WriteBit ¶

func (x *Modbus) WriteBit(addr int, status byte) (err error)

WriteBit modbus_write_bit - write a single bit

The modbus_write_bit() function shall write the status of status at the address addr of the remote device. The value must be set to TRUE or FALSE.

The function uses the Modbus function code 0x05 (force single coil).

func (*Modbus) WriteBits ¶

func (x *Modbus) WriteBits(addr int, data []byte) (err error)

WriteBits modbus_write_bits - write many bits

The modbus_write_bits() function shall write the status of the nb bits (coils) from src at the address addr of the remote device. The src array must contains bytes set to TRUE or FALSE.

The function uses the Modbus function code 0x0F (force multiple coils).

func (*Modbus) WriteRegister ¶

func (x *Modbus) WriteRegister(addr int, value uint16) (err error)

WriteRegister modbus_write_register - write a single register

he modbus_write_register() function shall write the value of value holding registers at the address addr of the remote evice.

he function uses the Modbus function code 0x06 (preset single register).

func (*Modbus) WriteRegisters ¶

func (x *Modbus) WriteRegisters(addr int, data []uint16) (err error)

WriteRegisters modbus_write_registers - write many registers

The modbus_write_registers() function shall write the content of the nb holding registers from the array src at address addr of the remote device.

The function uses the Modbus function code 0x10 (preset multiple registers).

func (*ModbusMapping) Free ¶

func (mm *ModbusMapping) Free()

Free modbus_mapping_free - free a modbus_mapping_t structure

The function shall free the four arrays of modbus_mapping_t structure and finally the modbus_mapping_t itself referenced by mb_mapping.

BITS_ADDRESS := 0
BITS_NB := 10
INPUT_BITS_ADDRESS := 0
INPUT_BITS_NB := 10
REGISTERS_ADDRESS := 0
REGISTERS_NB := 10
INPUT_REGISTERS_ADDRESS := 0
INPUT_REGISTERS_NB := 10
mm := ModbusMappingNewStartAddress(
	uint(BITS_ADDRESS),
	uint(BITS_NB),
	uint(INPUT_BITS_ADDRESS),
	uint(INPUT_BITS_NB),
	uint(REGISTERS_ADDRESS),
	uint(REGISTERS_NB),
	uint(INPUT_REGISTERS_ADDRESS),
	uint(INPUT_REGISTERS_NB),
)
defer mm.Free()
fmt.Println(mm.NbBits())
fmt.Println(mm.NbInputBits())
fmt.Println(mm.NbInputRegisters())
fmt.Println(mm.NbRegisters())

Output:

10
10
10
10

func (*ModbusMapping) GetTabBits ¶

func (mm *ModbusMapping) GetTabBits(addr int) byte

func (*ModbusMapping) GetTabInputBits ¶

func (mm *ModbusMapping) GetTabInputBits(addr int) byte

func (*ModbusMapping) GetTabInputRegisters ¶

func (mm *ModbusMapping) GetTabInputRegisters(addr int) uint16

func (*ModbusMapping) GetTabRegisters ¶

func (mm *ModbusMapping) GetTabRegisters(addr int) uint16

func (*ModbusMapping) MarshalBinary ¶ added in v0.1.6

func (mm *ModbusMapping) MarshalBinary() (buff []byte, err error)

func (*ModbusMapping) NbBits ¶

func (mm *ModbusMapping) NbBits() int

func (*ModbusMapping) NbInputBits ¶

func (mm *ModbusMapping) NbInputBits() int

func (*ModbusMapping) NbInputRegisters ¶

func (mm *ModbusMapping) NbInputRegisters() int

func (*ModbusMapping) NbRegisters ¶

func (mm *ModbusMapping) NbRegisters() int

func (*ModbusMapping) SetTabBits ¶

func (mm *ModbusMapping) SetTabBits(addr int, v byte)

func (*ModbusMapping) SetTabInputBits ¶

func (mm *ModbusMapping) SetTabInputBits(addr int, v byte)

func (*ModbusMapping) SetTabInputRegisters ¶

func (mm *ModbusMapping) SetTabInputRegisters(addr int, v uint16)

func (*ModbusMapping) SetTabRegisters ¶

func (mm *ModbusMapping) SetTabRegisters(addr int, v uint16)

func (*ModbusMapping) StartBits ¶

func (mm *ModbusMapping) StartBits() int

func (*ModbusMapping) StartInputBits ¶

func (mm *ModbusMapping) StartInputBits() int

func (*ModbusMapping) StartInputRegisters ¶

func (mm *ModbusMapping) StartInputRegisters() int

func (*ModbusMapping) StartRegisters ¶

func (mm *ModbusMapping) StartRegisters() int

func (*ModbusMapping) TabBits ¶

func (mm *ModbusMapping) TabBits() iter.Seq2[int, byte]

func (*ModbusMapping) TabInputBits ¶

func (mm *ModbusMapping) TabInputBits() iter.Seq2[int, byte]

func (*ModbusMapping) TabInputRegisters ¶

func (mm *ModbusMapping) TabInputRegisters() iter.Seq2[int, uint16]

func (*ModbusMapping) TabRegisters ¶

func (mm *ModbusMapping) TabRegisters() iter.Seq2[int, uint16]

func (*ModbusMapping) UnmarshalBinary ¶ added in v0.1.6

func (mm *ModbusMapping) UnmarshalBinary(data []byte) (err error)