lc_garage/internal/service/uhf/serial_reader.go

package uhf

import (
	"errors"
	"github.com/tarm/serial"
	"io"
	"os"
	"sync"
	"time"
)

type SerialReader struct {
	COMPort     string
	BaudRate    int
	port        *serial.Port
	isConnected bool
	buffer      []byte // 拼包缓冲区
	ioMu        sync.Mutex
}

func NewSerialReader(comPort string, baudRate int) *SerialReader {
	return &SerialReader{
		COMPort:  comPort,
		BaudRate: baudRate,
	}
}

func (s *SerialReader) Connect() error {
	s.ioMu.Lock()
	defer s.ioMu.Unlock()
	cfg := &serial.Config{
		Name:        s.COMPort,
		Baud:        s.BaudRate,
		ReadTimeout: 1 * time.Second,
		Size:        8,
		Parity:      serial.ParityNone,
		StopBits:    serial.Stop1,
	}
	port, err := serial.OpenPort(cfg)
	if err != nil {
		s.isConnected = false
		return err
	}
	s.port = port
	s.isConnected = true
	return nil
}

func (s *SerialReader) Disconnect() error {
	s.ioMu.Lock()
	defer s.ioMu.Unlock()
	if s.port != nil {
		_ = s.port.Close()
	}
	s.isConnected = false
	s.buffer = nil
	return nil
}

func (s *SerialReader) IsConnected() bool {
	s.ioMu.Lock()
	defer s.ioMu.Unlock()
	return s.isConnected
}

func (s *SerialReader) SendData(data []byte) error {
	s.ioMu.Lock()
	defer s.ioMu.Unlock()
	return s.sendDataLocked(data)
}

func (s *SerialReader) sendDataLocked(data []byte) error {
	if !s.isConnected {
		return errors.New("串口未连接")
	}
	n, err := s.port.Write(data)
	if err != nil {
		return err
	}
	if n != len(data) {
		return errors.New("发送不完整")
	}
	return nil
}

// ==============================
// 🔥 关键修复：串口返回完整25字节帧
// ==============================
func (s *SerialReader) ReadData() ([]byte, error) {
	s.ioMu.Lock()
	defer s.ioMu.Unlock()
	return s.readDataLocked()
}

func (s *SerialReader) readDataLocked() ([]byte, error) {
	if !s.isConnected {
		return nil, errors.New("串口未连接")
	}

	buf := make([]byte, 1024)
	for {
		n, err := s.port.Read(buf)
		if err != nil {
			if err == io.EOF || os.IsTimeout(err) {
				break
			}
			s.isConnected = false
			return nil, err
		}
		if n > 0 {
			s.buffer = append(s.buffer, buf[:n]...)
		}

		// 找25字节完整帧
		for len(s.buffer) >= 25 {
			if s.buffer[0] == 0xCF {
				frame := s.buffer[:25]
				s.buffer = s.buffer[25:]
				return frame, nil
			} else {
				s.buffer = s.buffer[1:]
			}
		}

		// 超时退出
		if len(s.buffer) == 0 {
			break
		}
	}

	return nil, ErrReadTimeout
}

func (s *SerialReader) SendAndRecv(data []byte) ([]byte, error) {
	s.ioMu.Lock()
	defer s.ioMu.Unlock()
	if err := s.sendDataLocked(data); err != nil {
		return nil, err
	}
	time.Sleep(100 * time.Millisecond)
	return s.readDataLocked()
}