Merge branch 'main' of https://git.whblueocean.cn/communication-protocol/modbus into cfy-feat-dev

Reviewed-on: #11

client.go

@@ -1212,8 +1212,8 @@ func (mc *ModbusClient) readRegistersWithFunctionCode(addr uint16, quantity uint
 		return
 	}
 
-	// 16 * 16 * 40
-	if quantity > 10240 {
+	// 16 * 40
+	if quantity > 640 {
 		err = ErrUnexpectedParameters
 		mc.logger.Error("quantity of registers exceeds 10240")
 		return

rtu_transport.go

@@ -188,55 +188,6 @@ func (rt *rtuTransport) WriteResponse(res *pdu) (err error) {
 	return
 }
 
-func calculateModbusCRC16(data []byte) uint16 {
-	// 初始值 (标准 Modbus RTU)
-	var crc uint16 = 0xFFFF
-
-	// 遍历所有需要校验的字节
-	for _, b := range data {
-		// 1. 当前 CRC 异或当前字节 (注意：字节 b 转换为 uint16)
-		crc = crc ^ uint16(b)
-
-		// 2. 8 次迭代进行位运算
-		for i := 0; i < 8; i++ {
-			// 检查最低有效位 (LSB)
-			if crc&0x0001 != 0 {
-				// 如果 LSB 是 1: 右移一位，然后异或多项式 0xA001
-				// 0xA001 是 0x8005 反射后的结果
-				crc = (crc >> 1) ^ 0xA001
-			} else {
-				// 如果 LSB 是 0: 直接右移一位
-				crc = crc >> 1
-			}
-		}
-	}
-
-	// 3. 返回最终的 CRC 值
-	return crc
-}
-
-// 示例用法：使用此函数替换您原来的 crc.add/crc.value 逻辑
-
-// 假设您的数据帧已完整接收到 rxbuf 中
-func checkCRC(rxbuf []byte, totalFrameSize int) bool {
-	// 1. 确定校验范围 (地址到数据结束)
-	crcEndIndex := totalFrameSize - 2
-	dataToVerify := rxbuf[0:crcEndIndex]
-
-	// 2. 使用模拟从机的函数计算 CRC
-	calculatedCRC := calculateModbusCRC16(dataToVerify)
-
-	// 3. 提取接收到的 CRC (Little-Endian 顺序)
-	recvCRCLow := rxbuf[crcEndIndex]
-	recvCRCHigh := rxbuf[crcEndIndex+1]
-
-	// 4. 重组接收到的 CRC
-	receivedCRC := (uint16(recvCRCHigh) << 8) | uint16(recvCRCLow)
-
-	// 5. 比较
-	return calculatedCRC == receivedCRC
-}
-
 // Waits for, reads and decodes a frame from the rtu link.
 func (rt *rtuTransport) readRTUFrame() (res *pdu, err error) {
 	var rxbuf []byte
@@ -332,8 +283,8 @@ func (rt *rtuTransport) readRTUFrame() (res *pdu, err error) {
 		crc.add(rxbuf[0:crcEndIndex]) // 校验范围从 rxbuf[0] 到数据域结束
 
 		// 比较接收到的 CRC
-		// sentHigh := rxbuf[crcEndIndex]  // C_high (例如 0x8B)
-		// sentLow := rxbuf[crcEndIndex+1] // C_low (例如 0xB0)
+		sentHigh := rxbuf[crcEndIndex]  // C_high (例如 0x8B)
+		sentLow := rxbuf[crcEndIndex+1] // C_low (例如 0xB0)
 
 		// 由于 isEqual 期望 (low, high)，我们需要将 sentLow 传给 low
 
@@ -344,11 +295,11 @@ func (rt *rtuTransport) readRTUFrame() (res *pdu, err error) {
 
 		// fmt.Println("len: ", len(rxbuf[crcEndIndex-10:crcEndIndex]))
 
-		// if !crc.isEqual(sentLow, sentHigh) {
-		// 	err = ErrBadCRC
-		// 	fmt.Println("crc: ", sentLow, sentHigh, "byte needed: ", bytesNeeded)
-		// 	return
-		// }
+		if !crc.isEqual(sentHigh, sentLow) {
+			err = ErrBadCRC
+			// fmt.Println("crc: ", sentLow, sentHigh, "byte needed: ", bytesNeeded)
+			return
+		}
 
 		// 8. 构造 PDU
 		// Payload 包含：自定义数据 (4 bytes) + Data (N bytes)
@@ -465,24 +416,29 @@ func (rt *rtuTransport) readRTUFrameWithRes() (res *pdu, err error) {
 	// 标准modbus响应已读取完成，现在读取自定义数据
 	// 设置5秒超时来读取自定义数据
 	customDataTimeout := 5 * time.Second
-	err = rt.link.SetDeadline(time.Now().Add(customDataTimeout))
+	deadline := time.Now().Add(customDataTimeout)
+	err = rt.link.SetDeadline(deadline)
 	if err != nil {
 		return
 	}
 
-	// fmt.Println("---: ", rxbuf[:10])
-
-	// a := make([]byte, 100)
-	// n, err := io.ReadFull(rt.link, a)
-	// fmt.Println("n: ", n, "err: ", err, "a: ", a)
-	time.Sleep(1 * time.Second)
-
 	// 使用临时缓冲区循环读取自定义数据
 	tempBuf := make([]byte, 256) // 每次读取最多256字节
 	totalRead := 0
 	startPos := 3 + bytesNeeded
+	var lastErr error // 记录最后一次非超时错误
 
 	for {
+		// 检查是否已经超时
+		if time.Now().After(deadline) {
+			// 超时时间到，退出循环
+			// 如果有之前记录的错误，使用它；否则err保持为nil（超时是正常的）
+			if lastErr != nil {
+				err = lastErr
+			}
+			break
+		}
+
 		// 检查缓冲区是否还有空间
 		if startPos+totalRead+len(tempBuf) > len(rxbuf) {
 			// 如果缓冲区不够，扩展它
@@ -499,31 +455,23 @@ func (rt *rtuTransport) readRTUFrameWithRes() (res *pdu, err error) {
 			totalRead += n
 		}
 
-		// 如果遇到超时错误，说明没有更多数据了
+		// 如果遇到超时错误，说明超时时间到了，退出循环
 		if readErr != nil {
 			if os.IsTimeout(readErr) {
-				// 超时是正常的，说明自定义数据读取完成
+				// 超时时间到，退出循环
+				// 如果有之前记录的错误，使用它；否则err保持为nil（超时是正常的）
+				if lastErr != nil {
+					err = lastErr
+				}
 				break
 			}
-			// 其他错误需要检查是否是EOF（数据读取完成）
-			if readErr == io.EOF {
-				break
-			}
-			// 对于其他错误，如果已经读取了一些数据，继续处理
-			if totalRead == 0 {
-				err = readErr
-				return
-			}
-			break
+			// 记录非超时错误，但继续等待直到超时
+			lastErr = readErr
+			// 继续循环，等待超时
 		}
 
-		// 如果读取的字节数少于请求的，说明没有更多数据了
-		if n < len(tempBuf) {
-			break
-		}
 	}
 
-	// 返回标准响应的payload（地址+值，4字节）+ 自定义数据
 	// 标准响应的payload在 rxbuf[2:3+bytesNeeded-2] 位置
 	standardPayloadStart := 2
 	standardPayloadEnd := 3 + bytesNeeded - 2
@@ -538,9 +486,7 @@ func (rt *rtuTransport) readRTUFrameWithRes() (res *pdu, err error) {
 	res = &pdu{
 		unitId:       rxbuf[0],
 		functionCode: rxbuf[1],
-		// payload包含标准响应的payload + 自定义数据
-		payload: completePayload,
-		// payload: a,
+		payload:      completePayload,
 	}
 
 	return

serial.go

@@ -1,6 +1,6 @@
 package modbus
 
-import	(
+import (
 	"time"
 
 	"github.com/goburrow/serial"
@@ -10,43 +10,46 @@ import	(
 // 1) satisfy the rtuLink interface and
 // 2) add Read() deadline/timeout support.
 type serialPortWrapper struct {
-	conf		*serialPortConfig
-	port		serial.Port
-	deadline	time.Time
+	conf     *serialPortConfig
+	port     serial.Port
+	deadline time.Time
 }
 
 type serialPortConfig struct {
-	Device		string
-	Speed		uint
-	DataBits	uint
-	Parity		uint
-	StopBits	uint
+	Device   string
+	Speed    uint
+	DataBits uint
+	Parity   uint
+	StopBits uint
 }
 
 func newSerialPortWrapper(conf *serialPortConfig) (spw *serialPortWrapper) {
 	spw = &serialPortWrapper{
-		conf:	conf,
+		conf: conf,
 	}
 
 	return
 }
 
 func (spw *serialPortWrapper) Open() (err error) {
-	var parity	string
+	var parity string
 
 	switch spw.conf.Parity {
-	case PARITY_NONE:	parity	= "N"
-	case PARITY_EVEN:	parity	= "E"
-	case PARITY_ODD:	parity	= "O"
+	case PARITY_NONE:
+		parity = "N"
+	case PARITY_EVEN:
+		parity = "E"
+	case PARITY_ODD:
+		parity = "O"
 	}
 
 	spw.port, err = serial.Open(&serial.Config{
-		Address:	spw.conf.Device,
-		BaudRate:	int(spw.conf.Speed),
-		DataBits:	int(spw.conf.DataBits),
-		Parity:		parity,
-		StopBits:	int(spw.conf.StopBits),
-		Timeout:	10 * time.Millisecond,
+		Address:  spw.conf.Device,
+		BaudRate: int(spw.conf.Speed),
+		DataBits: int(spw.conf.DataBits),
+		Parity:   parity,
+		StopBits: int(spw.conf.StopBits),
+		Timeout:  100 * time.Millisecond,
 	})
 
 	return
@@ -64,11 +67,12 @@ func (spw *serialPortWrapper) Close() (err error) {
 // attempting to read from the serial port.
 // If Read() is called before the deadline, a read attempt to the serial port
 // is made. At this point, one of two things can happen:
-// - the serial port's receive buffer has one or more bytes and port.Read()
-//   returns immediately (partial or full read),
-// - the serial port's receive buffer is empty: port.Read() blocks for
-//   up to 10ms and returns serial.ErrTimeout. The serial timeout error is
-//   masked and Read() returns with no data.
+//   - the serial port's receive buffer has one or more bytes and port.Read()
+//     returns immediately (partial or full read),
+//   - the serial port's receive buffer is empty: port.Read() blocks for
+//     up to 10ms and returns serial.ErrTimeout. The serial timeout error is
+//     masked and Read() returns with no data.
+//
 // As the higher-level methods use io.ReadFull(), Read() will be called
 // as many times as necessary until either enough bytes have been read or an
 // error is returned (ErrRequestTimedOut or any other i/o error).

tcp_transport.go

@@ -154,8 +154,13 @@ func (tt *tcpTransport) readMBAPFrame() (p *pdu, txnId uint16, err error) {
 	// the byte count includes the unit ID field, which we already have
 	bytesNeeded--
 
+	maxTCPFrameLen := maxTCPFrameLength
+	if rxbuf[1] == fcCustomize {
+		maxTCPFrameLen = 647
+	}
+
 	// never read more than the max allowed frame length
-	if bytesNeeded+mbapHeaderLength > maxTCPFrameLength {
+	if bytesNeeded+mbapHeaderLength > maxTCPFrameLen {
 		err = ErrProtocolError
 		return
 	}