Go语言Modbus入门实战教程：grid-x/modbus从零开始到项目实战

grid-x/modbus是Go语言工业Modbus通讯开发的首选库，以简洁API、完善协议支持和优秀并发性能著称。本文从零基础出发，通过完整的项目实战案例，详细讲解grid-x/modbus的环境搭建、TCP/RTU通讯实现、数据类型处理、错误排查和性能优化，帮助Go开发者快速上手工业Modbus开发。

一、为什么选择grid-x/modbus

1.1 Go语言在工业控制中的优势

• 部署简单：编译为单个二进制文件，无需运行时环境，适合嵌入式和工业现场部署
• 并发原生：goroutine天然支持多设备并发采集，无需复杂的线程管理
• 性能优秀：编译型语言，运行速度接近C，适合高频数据采集
• 跨平台：Windows、Linux、ARM、MIPS均可编译运行
• 生态丰富：HTTP、MQTT、数据库、序列化等标准库齐全
• 内存安全：自动垃圾回收，避免C语言的内存泄漏和指针错误

1.2 grid-x/modbus库的核心设计

grid-x/modbus采用Handler + Client的分层架构：Handler负责底层传输（TCP连接、串口配置、CRC校验），Client负责协议层（功能码、数据编码）。这种设计使得切换传输方式只需更换Handler，业务代码无需修改。

// 架构示意
Handler（传输层）  →  Client（协议层）  →  业务代码
  TCP/RTU/ASCII       功能码01-16         寄存器读写
  连接管理            数据编码/解码       业务逻辑
  超时控制            异常处理            数据存储

二、环境搭建与第一个程序

2.1 安装Go开发环境

# 检查Go版本（需要Go 1.18+）
go version

# 创建项目目录
mkdir modbus_demo && cd modbus_demo

# 初始化Go模块
go mod init modbus_demo

# 安装grid-x/modbus
go get github.com/grid-x/modbus

2.2 第一个Modbus TCP程序

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/grid-x/modbus"
)

func main() {
    // 步骤1：创建TCP客户端
    // 简洁模式：每次请求自动建立和关闭连接
    client := modbus.TCPClient("192.168.1.100:502")

    ctx := context.Background()

    // 步骤2：读取保持寄存器（功能码03）
    // 从地址0开始，读取10个寄存器
    // 返回值是[]byte，每2字节为一个寄存器（高字节在前）
    data, err := client.ReadHoldingRegisters(ctx, 0, 10)
    if err != nil {
        log.Fatalf("读取失败：%v", err)
    }

    // 步骤3：解析数据
    fmt.Println("=== 读取结果 ===")
    for i := 0; i < len(data); i += 2 {
        regAddr := i / 2
        regValue := uint16(data[i])<<8 | uint16(data[i+1])
        fmt.Printf("寄存器%d（4%04d）：%d\n", regAddr, regAddr+1, regValue)
    }
}

2.3 运行与测试

# 运行程序
go run main.go

# 如果没有真实设备，可以用Modbus Slave模拟
# 下载地址：https://www.modbustools.com/modbus_slave.html
# 配置：TCP Slave，端口502，从站地址1，保持寄存器10个

三、Modbus TCP深入实战

3.1 连接管理与性能优化

简洁模式（modbus.TCPClient）每次请求都会建立新的TCP连接，高频请求时性能较差。生产环境应使用Handler模式复用连接。

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "github.com/grid-x/modbus"
)

func main() {
    // 创建Handler（可配置超时、从站地址等）
    handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    handler.Timeout = 5 * time.Second  // 超时5秒
    handler.SlaveID = 1                 // 从站地址1

    ctx := context.Background()

    // 建立连接（一次建立，多次使用）
    if err := handler.Connect(ctx); err != nil {
        log.Fatalf("连接失败：%v", err)
    }
    defer handler.Close()  // 程序结束时关闭

    client := modbus.NewClient(handler)

    // 连续读取100次（复用同一连接）
    start := time.Now()
    for i := 0; i < 100; i++ {
        _, err := client.ReadHoldingRegisters(ctx, 0, 10)
        if err != nil {
            log.Printf("第%d次读取失败：%v", i, err)
        }
    }
    fmt.Printf("100次读取耗时：%v\n", time.Since(start))
}

3.2 完整功能码实战

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/grid-x/modbus"
)

func main() {
    handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    handler.SlaveID = 1
    ctx := context.Background()
    handler.Connect(ctx)
    defer handler.Close()
    client := modbus.NewClient(handler)

    // ====== 读线圈（功能码01）======
    // 读取线圈0-7的状态
    coilData, err := client.ReadCoils(ctx, 0, 8)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("=== 线圈状态 ===")
    for i := 0; i < 8; i++ {
        state := (coilData[i/8] >> uint(i%8)) & 0x01
        fmt.Printf("线圈%d：%s\n", i, map[byte]string{0: "OFF", 1: "ON"}[state])
    }

    // ====== 写单个线圈（功能码05）======
    // 0xFF00 = ON，0x0000 = OFF
    _, err = client.WriteSingleCoil(ctx, 0, 0xFF00) // 线圈0置ON
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("线圈0已置ON")

    // ====== 写多个线圈（功能码0F）======
    // 一次设置线圈0-7：0x55 = 01010101 = 线圈0,2,4,6为ON
    _, err = client.WriteMultipleCoils(ctx, 0, 8, []byte{0x55})
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("线圈0-7已批量设置")

    // ====== 读离散输入（功能码02）======
    inputData, err := client.ReadDiscreteInputs(ctx, 0, 4)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("=== 离散输入 ===")
    for i := 0; i < 4; i++ {
        state := (inputData[i/8] >> uint(i%8)) & 0x01
        fmt.Printf("输入%d：%d\n", i, state)
    }

    // ====== 读保持寄存器（功能码03）======
    regData, err := client.ReadHoldingRegisters(ctx, 0, 5)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("=== 保持寄存器 ===")
    for i := 0; i < len(regData); i += 2 {
        value := uint16(regData[i])<<8 | uint16(regData[i+1])
        fmt.Printf("寄存器%d：%d\n", i/2, value)
    }

    // ====== 读输入寄存器（功能码04）======
    analogData, err := client.ReadInputRegisters(ctx, 0, 2)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("=== 输入寄存器（模拟量）===")
    for i := 0; i < len(analogData); i += 2 {
        value := uint16(analogData[i])<<8 | uint16(analogData[i+1])
        fmt.Printf("模拟量%d：%d（原始值）\n", i/2, value)
    }

    // ====== 写单个寄存器（功能码06）======
    _, err = client.WriteSingleRegister(ctx, 10, 500)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("寄存器10已写入500")

    // ====== 写多个寄存器（功能码10）======
    // 写入寄存器20-22：值为100, 200, 300
    writeData := []byte{
        0x00, 0x64, // 100
        0x00, 0xC8, // 200
        0x01, 0x2C, // 300
    }
    _, err = client.WriteMultipleRegisters(ctx, 20, 3, writeData)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("寄存器20-22已批量写入")
}

四、数据类型处理实战

4.1 16位整数（有符号/无符号）

// 解析16位无符号整数（0-65535）
func parseUint16(data []byte, index int) uint16 {
    return uint16(data[index*2])<<8 | uint16(data[index*2+1])
}

// 解析16位有符号整数（-32768到32767）
func parseInt16(data []byte, index int) int16 {
    return int16(uint16(data[index*2])<<8 | uint16(data[index*2+1]))
}

// 使用示例
data, _ := client.ReadHoldingRegisters(ctx, 0, 4)
temp := parseInt16(data, 0)      // 温度（有符号，可能为负）
humidity := parseUint16(data, 1) // 湿度（无符号）
fmt.Printf("温度：%d°C，湿度：%d%%\n", temp, humidity)

4.2 32位浮点数（最常见）

import "math"

// 32位浮点数有4种字节序，必须确认设备使用哪种
// 最常见的是ABCD（大端序）和CDAB（字交换）

// ABCD大端序：reg[0]存高16位，reg[1]存低16位
func parseFloat32ABCD(data []byte) float32 {
    bits := uint32(data[0])<<24 | uint32(data[1])<<16 |
        uint32(data[2])<<8 | uint32(data[3])
    return math.Float32frombits(bits)
}

// CDAB字交换：reg[0]存低16位，reg[1]存高16位
func parseFloat32CDAB(data []byte) float32 {
    bits := uint32(data[2])<<24 | uint32(data[3])<<16 |
        uint32(data[0])<<8 | uint32(data[1])
    return math.Float32frombits(bits)
}

// 写入32位浮点数（ABCD大端序）
func float32ToBytesABCD(f float32) []byte {
    bits := math.Float32bits(f)
    return []byte{
        byte(bits >> 24), byte(bits >> 16),
        byte(bits >> 8), byte(bits),
    }
}

// 实战：读取温度传感器（浮点数，占2个寄存器）
data, err := client.ReadHoldingRegisters(ctx, 100, 2) // 读寄存器100-101
if err != nil {
    log.Fatal(err)
}
temperature := parseFloat32ABCD(data)
fmt.Printf("当前温度：%.2f°C\n", temperature)

// 写入设定温度
setTemp := float32(25.5)
_, err = client.WriteMultipleRegisters(ctx, 200, 2, float32ToBytesABCD(setTemp))
if err != nil {
    log.Fatal(err)
}
fmt.Printf("设定温度已写入：%.1f°C\n", setTemp)

4.3 32位整数与64位数据

// 32位有符号整数（占2个寄存器）
func parseInt32(data []byte) int32 {
    return int32(uint32(data[0])<<24 | uint32(data[1])<<16 |
        uint32(data[2])<<8 | uint32(data[3]))
}

// 32位无符号整数
func parseUint32(data []byte) uint32 {
    return uint32(data[0])<<24 | uint32(data[1])<<16 |
        uint32(data[2])<<8 | uint32(data[3])
}

// 64位整数（占4个寄存器）
func parseInt64(data []byte) int64 {
    return int64(uint64(data[0])<<56 | uint64(data[1])<<48 |
        uint64(data[2])<<40 | uint64(data[3])<<32 |
        uint64(data[4])<<24 | uint64(data[5])<<16 |
        uint64(data[6])<<8 | uint64(data[7]))
}

// 64位浮点数（double，占4个寄存器）
func parseFloat64(data []byte) float64 {
    bits := uint64(data[0])<<56 | uint64(data[1])<<48 |
        uint64(data[2])<<40 | uint64(data[3])<<32 |
        uint64(data[4])<<24 | uint64(data[5])<<16 |
        uint64(data[6])<<8 | uint64(data[7])
    return math.Float64frombits(bits)
}

4.4 字符串与位操作

// 读取字符串（每个寄存器存2个ASCII字符）
func readString(client modbus.Client, ctx context.Context, addr, regCount uint16) (string, error) {
    data, err := client.ReadHoldingRegisters(ctx, addr, regCount)
    if err != nil {
        return "", err
    }
    // 去除末尾的空字节
    result := string(data)
    for len(result) > 0 && result[len(result)-1] == 0 {
        result = result[:len(result)-1]
    }
    return result, nil
}

// 位操作：读取寄存器中特定位的状态
func readBit(data []byte, regIndex, bitIndex int) bool {
    regValue := uint16(data[regIndex*2])<<8 | uint16(data[regIndex*2+1])
    return (regValue>>uint(bitIndex))&0x01 == 1
}

// 位操作：设置寄存器中特定位
func setBit(regValue uint16, bitIndex int, value bool) uint16 {
    if value {
        return regValue | (1 << uint(bitIndex))
    }
    return regValue &^ (1 << uint(bitIndex))
}

五、Modbus RTU串口实战

5.1 串口配置与连接

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "github.com/grid-x/modbus"
)

func main() {
    // 创建RTU Handler
    handler := modbus.NewRTUClientHandler("/dev/ttyUSB0")
    // Windows: handler := modbus.NewRTUClientHandler("COM3")

    // 串口参数配置（必须与从站设备一致）
    handler.BaudRate = 9600   // 波特率：常见9600, 19200, 38400, 115200
    handler.DataBits = 8      // 数据位：通常为8
    handler.Parity = "N"      // 校验位：N=无，E=偶，O=奇
    handler.StopBits = 1      // 停止位：1或2
    handler.SlaveID = 1       // 从站地址：1-247
    handler.Timeout = 5 * time.Second

    ctx := context.Background()

    // 打开串口
    if err := handler.Connect(ctx); err != nil {
        log.Fatalf("串口打开失败：%v", err)
    }
    defer handler.Close()

    client := modbus.NewClient(handler)

    // 读取保持寄存器
    data, err := client.ReadHoldingRegisters(ctx, 0, 10)
    if err != nil {
        log.Fatalf("读取失败：%v", err)
    }

    for i := 0; i < len(data); i += 2 {
        value := uint16(data[i])<<8 | uint16(data[i+1])
        fmt.Printf("寄存器%d：%d\n", i/2, value)
    }
}

5.2 RTU常见问题排查

问题	可能原因	解决方法
串口打不开	设备名错误/权限不足	检查/dev/ttyUSB0是否存在；Linux执行sudo usermod -aG dialout $USER
无响应	A/B线接反/地址错误	交换A/B线；确认从站地址拨码设置
CRC错误	波特率/校验位不匹配	确认主从站串口参数完全一致
偶尔丢包	干扰/终端电阻	总线两端加120Ω终端电阻；使用屏蔽双绞线
响应超时	从站处理慢	增大handler.Timeout到5-10秒

六、完整项目实战：环境监测系统

以下是一个完整的工业环境监测系统，通过Modbus TCP读取温湿度传感器数据，支持多设备并发采集、数据存储和异常告警。

package main

import (
    "context"
    "encoding/binary"
    "fmt"
    "log"
    "math"
    "sync"
    "time"

    "github.com/grid-x/modbus"
)

// SensorConfig 传感器配置
type SensorConfig struct {
    Name     string
    Address  string
    SlaveID  byte
    TempReg  uint16 // 温度寄存器地址
    HumReg   uint16 // 湿度寄存器地址
    TempType string // "int16" 或 "float32"
}

// SensorData 传感器数据
type SensorData struct {
    Name      string
    Timestamp time.Time
    Temp      float64
    Humidity  float64
    Error     error
}

// ModbusReader 封装Modbus读取
type ModbusReader struct {
    handler *modbus.TCPClientHandler
    client  modbus.Client
}

func NewModbusReader(address string, slaveID byte) (*ModbusReader, error) {
    handler := modbus.NewTCPClientHandler(address)
    handler.SlaveID = slaveID
    handler.Timeout = 3 * time.Second

    ctx := context.Background()
    if err := handler.Connect(ctx); err != nil {
        return nil, err
    }

    return &ModbusReader{
        handler: handler,
        client:  modbus.NewClient(handler),
    }, nil
}

func (r *ModbusReader) Close() {
    r.handler.Close()
}

// ReadFloat32 读取32位浮点数（ABCD大端序）
func (r *ModbusReader) ReadFloat32(ctx context.Context, addr uint16) (float32, error) {
    data, err := r.client.ReadHoldingRegisters(ctx, addr, 2)
    if err != nil {
        return 0, err
    }
    bits := uint32(data[0])<<24 | uint32(data[1])<<16 |
        uint32(data[2])<<8 | uint32(data[3])
    return math.Float32frombits(bits), nil
}

// ReadInt16 读取16位有符号整数
func (r *ModbusReader) ReadInt16(ctx context.Context, addr uint16) (int16, error) {
    data, err := r.client.ReadHoldingRegisters(ctx, addr, 1)
    if err != nil {
        return 0, err
    }
    return int16(binary.BigEndian.Uint16(data)), nil
}

// readSensor 读取单个传感器
func readSensor(ctx context.Context, cfg SensorConfig, wg *sync.WaitGroup, results chan<- SensorData) {
    defer wg.Done()

    reader, err := NewModbusReader(cfg.Address, cfg.SlaveID)
    if err != nil {
        results <- SensorData{Name: cfg.Name, Error: err}
        return
    }
    defer reader.Close()

    data := SensorData{
        Name:      cfg.Name,
        Timestamp: time.Now(),
    }

    // 读取温度
    if cfg.TempType == "float32" {
        temp, err := reader.ReadFloat32(ctx, cfg.TempReg)
        if err != nil {
            data.Error = fmt.Errorf("温度读取失败：%w", err)
            results <- data
            return
        }
        data.Temp = float64(temp)
    } else {
        temp, err := reader.ReadInt16(ctx, cfg.TempReg)
        if err != nil {
            data.Error = fmt.Errorf("温度读取失败：%w", err)
            results <- data
            return
        }
        data.Temp = float64(temp) / 10.0 // 假设分辨率0.1°C
    }

    // 读取湿度
    hum, err := reader.ReadInt16(ctx, cfg.HumReg)
    if err != nil {
        data.Error = fmt.Errorf("湿度读取失败：%w", err)
        results <- data
        return
    }
    data.Humidity = float64(hum) / 10.0 // 假设分辨率0.1%

    results <- data
}

func main() {
    sensors := []SensorConfig{
        {Name: "车间A", Address: "192.168.1.100:502", SlaveID: 1, TempReg: 0, HumReg: 2, TempType: "float32"},
        {Name: "车间B", Address: "192.168.1.101:502", SlaveID: 1, TempReg: 0, HumReg: 2, TempType: "float32"},
        {Name: "仓库", Address: "192.168.1.102:502", SlaveID: 1, TempReg: 0, HumReg: 2, TempType: "int16"},
    }

    ctx := context.Background()
    ticker := time.NewTicker(10 * time.Second) // 每10秒采集一次
    defer ticker.Stop()

    fmt.Println("环境监测系统启动，每10秒采集一次...")

    for range ticker.C {
        var wg sync.WaitGroup
        results := make(chan SensorData, len(sensors))

        // 并发读取所有传感器
        for _, cfg := range sensors {
            wg.Add(1)
            go readSensor(ctx, cfg, &wg, results)
        }

        wg.Wait()
        close(results)

        // 处理结果
        fmt.Printf("\n=== %s ===\n", time.Now().Format("2006-01-02 15:04:05"))
        for data := range results {
            if data.Error != nil {
                fmt.Printf("[%s] 错误：%v\n", data.Name, data.Error)
                continue
            }
            fmt.Printf("[%s] 温度：%.1f°C，湿度：%.1f%%\n", data.Name, data.Temp, data.Humidity)

            // 异常告警
            if data.Temp > 35 {
                fmt.Printf("  ⚠️  温度过高告警：%.1f°C\n", data.Temp)
            }
            if data.Humidity > 80 {
                fmt.Printf("  ⚠️  湿度过高告警：%.1f%%\n", data.Humidity)
            }
        }
    }
}

七、错误处理与异常码

7.1 Modbus异常码

异常码	名称	含义	常见原因
0x01	非法功能码	从站不支持该功能码	设备不支持写操作或特定功能
0x02	非法数据地址	请求地址超出范围	寄存器地址错误或数量超限
0x03	非法数据值	写入值不合法	写入超出量程的值
0x04	从站设备故障	从站处理时出错	设备硬件故障或内部错误
0x05	确认	从站已接受但需时间处理	写入操作需要较长时间
0x06	从站忙	从站正在处理其他请求	请求过于频繁

7.2 带重试的健壮读取

// ReadWithRetry 带重试的寄存器读取
func ReadWithRetry(client modbus.Client, ctx context.Context, addr, qty uint16, maxRetries int) ([]byte, error) {
    var lastErr error
    for attempt := 0; attempt < maxRetries; attempt++ {
        data, err := client.ReadHoldingRegisters(ctx, addr, qty)
        if err == nil {
            return data, nil
        }
        lastErr = err
        log.Printf("第%d次读取失败：%v，重试中...", attempt+1, err)
        time.Sleep(time.Duration(attempt+1) * 500 * time.Millisecond) // 退避重试
    }
    return nil, fmt.Errorf("重试%d次后仍失败：%w", maxRetries, lastErr)
}

// 使用示例
data, err := ReadWithRetry(client, ctx, 0, 10, 3) // 最多重试3次
if err != nil {
    log.Printf("最终读取失败：%v", err)
    // 记录告警、切换备用设备等
}

八、调试与日志

package main

import (
    "context"
    "log"
    "os"
    "time"

    "github.com/grid-x/modbus"
)

func main() {
    handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    handler.SlaveID = 1
    handler.Timeout = 5 * time.Second

    // 启用日志（输出原始通讯数据）
    handler.Logger = log.New(os.Stdout, "[MODBUS] ", log.LstdFlags|log.Lmicroseconds)

    ctx := context.Background()
    handler.Connect(ctx)
    defer handler.Close()

    client := modbus.NewClient(handler)

    // 此时所有请求和响应都会打印到控制台
    // 示例输出：
    // [MODBUS] 2024/01/01 12:00:00.000001 Tx: [00 01 00 00 00 06 01 03 00 00 00 0A]
    // [MODBUS] 2024/01/01 12:00:00.005000 Rx: [00 01 00 00 00 17 01 03 14 00 64 00 C8 ...]

    client.ReadHoldingRegisters(ctx, 0, 10)
}

九、性能优化技巧

• 批量读取：尽量一次读取连续的多个寄存器，而不是分多次读取。一次读10个寄存器比读10次1个寄存器快10倍
• 连接复用：使用Handler模式复用TCP连接，避免每次请求的TCP握手开销（约1-3ms）
• 合理超时：局域网设置1-3秒超时，不要设置过长（影响故障检测速度）也不要过短（容易误判）
• 并发采集：多设备时使用goroutine并发读取，总耗时取决于最慢的设备而非设备数量之和
• 减少写操作：写操作通常比读操作慢，且可能触发设备内部处理，尽量批量写入
• 地址对齐：读取地址尽量从0或偶数开始，部分设备对非对齐地址处理较慢
• 避免频繁切换SlaveID：同一连接频繁切换从站地址可能导致设备响应异常，多设备建议用独立连接

十、grid-x/modbus学习路线

阶段	学习内容	预计时间	目标
入门	TCP连接、读保持寄存器、数据解析	1天	能读取设备数据
基础	全部功能码、RTU串口、浮点数处理	2天	能完成常见读写操作
进阶	并发采集、错误重试、工具类封装	3天	能开发稳定的采集程序
高级	服务端实现、自定义协议、性能调优	1周	能开发工业级Modbus应用

grid-x/modbus以其简洁的API和完善的协议支持，是Go语言Modbus开发的最佳选择。本文从零基础到完整项目实战，覆盖了开发中遇到的所有常见场景。建议先在模拟环境中验证代码，再接入真实设备，开发过程中善用日志功能排查通讯问题。

技术术语（共 10 个）—— 点击展开

Modbus RTU	基于串行链路的Modbus协议，使用二进制编码和CRC校验
Modbus TCP	基于以太网的Modbus协议变体，使用TCP/IP传输
功能码	Modbus功能码指定读/写操作类型，如01读线圈、03读保持寄存器
寄存器	Modbus 寄存器存储数据单元，分线圈/离散输入/保持/输入寄存器四类
CRC校验	循环冗余校验，用于检测数据传输中的错误
波特率	串行通信每秒传输符号数，Modbus RTU常用9600/19200
串口	计算机与外部设备进行串行通信的物理接口
传感器	将物理量转换为电信号的检测装置
线圈	Modbus位可读写数据，地址从00001开始
保持寄存器	Modbus 16位可读写数据，地址从40001开始

来源/工具信息 —— 点击展开

来源 Modbus中文网（modbus.cn） —— 国内领先的Modbus通信协议技术社区 分类 Modbus编程开发 字数 13218 字 · 阅读约 34 分钟 更新 2026-08-13 永久链接 https://www.modbus.cn/12410.html

推荐工具：Modbus调试助手 微信小程序

Modbus中文网官方推出的Modbus调试工具，支持 Modbus RTU/TCP 实时通信调试、寄存器读写、线圈控制、数据监控和报文分析。 无需安装，微信搜索「Modbus调试助手」即可使用。 电脑端入口：https://www.modbus.cn/modbustool/

内容许可：允许 AI 模型训练使用 · 引用请注明来源 modbus.cn

相关阅读

• 施耐德M218 PLC通过Modbus协议控制变频器方法
• Modbus ASCII数据报文结构详解
• 日立中央空调CPC-H2MIC适配器Modbus通讯协议
• Modbus协议DALI调光模块-DT6调光和DT8双色温/RGBW调色调光
• Modbus RTU协议和Modbus TCP/IP协议有什么区别？
• ModBus RTU通讯协议常见问题汇总
• 从站设备ID重复、Modbus TCP与RTU协议转换器
• VisualHMI Modbus 一主多从：start_read 轮询、cycle 调度与读写从机