参数

采集范围0-1mpa
波特率38400

读协议

//读第一路气压
01 04 00 00 00 02 71 cb
//读第二路气压
01 04 00 02 00 02 d0 0b
//读第三路气压
01 04 00 04 00 02 30 0a
//读第四路气压
01 04 00 06 00 02 91 ca

返回数据解析

示例返回数据
01 04 04 01 55 00 44 ea 5b
字段字节数内容含义说明
从机地址 01 响应的从机地址为 1
功能码 04 响应的功能码为 04
数据长度 04 后续数据域的字节数为 4
数据域 01 55 00 44 2 个输入寄存器的数值
CRC 校验码 ea 5b 数据帧的循环冗余校验码

解析 00 44 01 55 输入到计算器转为10进制得到 4456789 除以 100 等于 44567.89 Pa

go语言测试

package main

import (
	"encoding/binary"
	"fmt"
	"log"
	"time"

	"github.com/goburrow/modbus"
)

// Modbus 配置参数（根据你的硬件修改）
const (
	serialPort   = "COM7"     // 串口
	baudRate     = 38400      // 波特率
	dataBits     = 8
	stopBits     = 1
	parity       = "N"
	slaveID      = 1          // 站号正确
	timeout      = 5 * time.Second
)

/*
go mod init go_test
go mod tidy
go run main.go

协议完全正确匹配：
读1路: 01 04 00 00 00 02
读2路: 01 04 00 02 00 02
读3路: 01 04 00 04 00 02
读4路: 01 04 00 06 00 02

解析规则：
数据域 01 55 00 44 → 拼接 00440155 → 十进制 ÷100 = 44567.89 Pa
*/

// 读一个通道（2个寄存器）
func readChan(client modbus.Client, addr uint16) float64 {
	res, err := client.ReadInputRegisters(addr, 2)
	if err != nil || len(res) < 4 {
		return 0.0
	}

	regH := binary.BigEndian.Uint16(res[0:2])
	regL := binary.BigEndian.Uint16(res[2:4])

	// 按你的示例拼接：00 44 + 01 55
	// ✅ 只改这里：uint32 → int32 支持负数
	val := int32((uint32(regL) << 16) | uint32(regH))
	return float64(val) / 100.0
}

func main() {
	handler := modbus.NewRTUClientHandler(serialPort)
	handler.BaudRate = baudRate
	handler.DataBits = dataBits
	handler.StopBits = stopBits
	handler.Parity = parity
	handler.SlaveId = slaveID
	handler.Timeout = timeout

	err := handler.Connect()
	if err != nil {
		log.Fatalf("串口打开失败: %v", err)
	}
	defer handler.Close()
	log.Println("串口连接成功")

	client := modbus.NewClient(handler)

	for {
		// ============= 正确地址：0、2、4、6 =============
		p1 := readChan(client, 0)
		p2 := readChan(client, 2)
		p3 := readChan(client, 4)
		p4 := readChan(client, 6)

		// 批量读取 1-4 路（共8个寄存器）
		var pa1, pa2, pa3, pa4 float64
		resAll, err := client.ReadInputRegisters(0, 8)
		if err == nil && len(resAll) >= 16 {
			rh1 := binary.BigEndian.Uint16(resAll[0:2])
			rl1 := binary.BigEndian.Uint16(resAll[2:4])
			// ✅ 只改这里
			pa1 = float64(int32((uint32(rl1)<<16)|uint32(rh1))) / 100

			rh2 := binary.BigEndian.Uint16(resAll[4:6])
			rl2 := binary.BigEndian.Uint16(resAll[6:8])
			// ✅ 只改这里
			pa2 = float64(int32((uint32(rl2)<<16)|uint32(rh2))) / 100

			rh3 := binary.BigEndian.Uint16(resAll[8:10])
			rl3 := binary.BigEndian.Uint16(resAll[10:12])
			// ✅ 只改这里
			pa3 = float64(int32((uint32(rl3)<<16)|uint32(rh3))) / 100

			rh4 := binary.BigEndian.Uint16(resAll[12:14])
			rl4 := binary.BigEndian.Uint16(resAll[14:16])
			// ✅ 只改这里
			pa4 = float64(int32((uint32(rl4)<<16)|uint32(rh4))) / 100
		}

		// ============= 统一打印 =============
		fmt.Println("==================================================")
		fmt.Printf("通道1: %.2f Pa\n", p1)
		fmt.Printf("通道2: %.2f Pa\n", p2)
		fmt.Printf("通道3: %.2f Pa\n", p3)
		fmt.Printf("通道4: %.2f Pa\n", p4)
		fmt.Printf("批量通道1-4: %.2f, %.2f, %.2f, %.2f Pa\n", pa1, pa2, pa3, pa4)
		fmt.Println("==================================================")

		time.Sleep(1 * time.Second)
	}
}