go modbus

modbus write in pure go, support rtu,ascii,tcp master library,also support tcp slave.

Supported formats

• modbus Serial(RTU,ASCII) Client
• modbus TCP Client
• modbus TCP Server

Features

• object pool design,reduce memory allocation
• fast encode and decode
• interface design
• simple API and support raw data api

Installation

Use go get.

    go get github.com/thinkgos/gomodbus/v2

Then import the modbus package into your own code.

    import modbus "github.com/thinkgos/gomodbus/v2"

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

Example

modbus RTU/ASCII client see example

package main
import (
    "fmt"
    "time"
    "github.com/goburrow/serial"
    modbus "github.com/thinkgos/gomodbus/v2"
)
func main() {
    p := modbus.NewRTUClientProvider(modbus.WithEnableLogger(),
        modbus.WithSerialConfig(serial.Config{
            Address:  "/dev/ttyUSB0",
            BaudRate: 115200,
            DataBits: 8,
            StopBits: 1,
            Parity:   "N",
            Timeout:  modbus.SerialDefaultTimeout,
        }))
    client := modbus.NewClient(p)
    err := client.Connect()
    if err != nil {
        fmt.Println("connect failed, ", err)
        return
    }
    defer client.Close()
    fmt.Println("starting")
    for {
        _, err := client.ReadCoils(3, 0, 10)
        if err != nil {
            fmt.Println(err.Error())
        }
        //    fmt.Printf("ReadDiscreteInputs %#v\r\n", results)
        time.Sleep(time.Second * 2)
    }
}

modbus TCP client see example

package main
import (
    "fmt"
    "time"
    modbus "github.com/thinkgos/gomodbus/v2"
)
func main() {
    p := modbus.NewTCPClientProvider("192.168.199.188:502", modbus.WithEnableLogger())
    client := modbus.NewClient(p)
    err := client.Connect()
    if err != nil {
        fmt.Println("connect failed, ", err)
        return
    }
    defer client.Close()
    fmt.Println("starting")
    for {
        _, err := client.ReadCoils(1, 0, 10)
        if err != nil {
            fmt.Println(err.Error())
        }
        //    fmt.Printf("ReadDiscreteInputs %#v\r\n", results)
        time.Sleep(time.Second * 2)
    }
}

modbus TCP server see example

package main
import (
    modbus "github.com/thinkgos/gomodbus/v2"
)
func main() {
    srv := modbus.NewTCPServer()
    srv.LogMode(true)
    srv.AddNodes(
        modbus.NewNodeRegister(
            1,
            0, 10, 0, 10,
            0, 10, 0, 10),
        modbus.NewNodeRegister(
            2,
            0, 10, 0, 10,
            0, 10, 0, 10),
        modbus.NewNodeRegister(
            3,
            0, 10, 0, 10,
            0, 10, 0, 10))
    err := srv.ListenAndServe(":502")
    if err != nil {
        panic(err)
    }
}

References

• Modbus Specifications and Implementation Guides
• goburrow

JetBrains OS licenses

gomodbus had been being developed with GoLand under the free JetBrains Open Source license(s) granted by JetBrains s.r.o., hence I would like to express my thanks here.

Donation

if package help you a lot,you can support us by:

Alipay

WeChat Pay