Add message IDs, transport interface, client package, extract protocol headers

lib/client/client.go

@@ -0,0 +1,90 @@
+package client
+
+import (
+	"fmt"
+	"sync/atomic"
+	"time"
+
+	"github.com/theater/picomap/lib/halfsiphash"
+	"github.com/theater/picomap/lib/msgpack"
+	"github.com/theater/picomap/lib/transport"
+)
+
+var HashKey = [8]byte{}
+
+type Client struct {
+	transport transport.Transport
+	timeout   time.Duration
+	nextID    atomic.Uint32
+}
+
+func New(t transport.Transport, timeout time.Duration) *Client {
+	return &Client{transport: t, timeout: timeout}
+}
+
+func (c *Client) Close() error {
+	return c.transport.Close()
+}
+
+func (c *Client) send(msg any) (uint32, error) {
+	id := c.nextID.Add(1)
+	payload, err := msgpack.Marshal(msg)
+	if err != nil {
+		return 0, fmt.Errorf("encode inner: %w", err)
+	}
+	checksum := halfsiphash.Sum32(payload, HashKey)
+	env := Envelope{MessageID: id, Checksum: checksum, Payload: payload}
+	data, err := msgpack.Marshal(&env)
+	if err != nil {
+		return 0, fmt.Errorf("encode envelope: %w", err)
+	}
+	return id, c.transport.Send(data)
+}
+
+func (c *Client) receive(expectedID uint32) (any, error) {
+	data, err := c.transport.Receive(c.timeout)
+	if err != nil {
+		return nil, fmt.Errorf("receive: %w", err)
+	}
+	if len(data) == 0 {
+		return nil, fmt.Errorf("no response")
+	}
+	var env Envelope
+	if err := msgpack.Unmarshal(data, &env); err != nil {
+		return nil, fmt.Errorf("decode envelope: %w", err)
+	}
+	if env.MessageID != expectedID {
+		return nil, fmt.Errorf("message id mismatch: got %d, want %d", env.MessageID, expectedID)
+	}
+	expected := halfsiphash.Sum32(env.Payload, HashKey)
+	if env.Checksum != expected {
+		return nil, fmt.Errorf("checksum mismatch: got %08x, want %08x", env.Checksum, expected)
+	}
+	var inner any
+	if err := msgpack.Unmarshal(env.Payload, &inner); err != nil {
+		return nil, fmt.Errorf("decode inner: %w", err)
+	}
+	if devErr, ok := inner.(*DeviceError); ok {
+		return nil, devErr
+	}
+	return inner, nil
+}
+
+func (c *Client) roundTrip(req any) (any, error) {
+	id, err := c.send(req)
+	if err != nil {
+		return nil, err
+	}
+	return c.receive(id)
+}
+
+func (c *Client) BOOTSEL() error {
+	resp, err := c.roundTrip(&RequestBOOTSEL{})
+	if err != nil {
+		return err
+	}
+	if _, ok := resp.(*ResponseBOOTSEL); !ok {
+		return fmt.Errorf("unexpected response: %T", resp)
+	}
+	return nil
+}

lib/client/types.go

@@ -0,0 +1,28 @@
+package client
+
+import "github.com/theater/picomap/lib/msgpack"
+
+type ResponseBOOTSEL struct{}
+type RequestBOOTSEL struct{}
+
+type DeviceError struct {
+	Code    uint32
+	Message string
+}
+
+func (e *DeviceError) Error() string {
+	return e.Message
+}
+
+type Envelope struct {
+	MessageID uint32
+	Checksum  uint32
+	Payload   []byte
+}
+
+func init() {
+	msgpack.RegisterExt(0, (*Envelope)(nil))
+	msgpack.RegisterExt(1, (*ResponseBOOTSEL)(nil))
+	msgpack.RegisterExt(2, (*RequestBOOTSEL)(nil))
+	msgpack.RegisterExt(3, (*DeviceError)(nil))
+}

lib/picoserial/picoserial.go

@@ -21,29 +21,29 @@ func FindDevice() (string, error) {
 	return "", nil
 }
 
-func Open(portName string) (serial.Port, error) {
-	return serial.Open(portName, &serial.Mode{BaudRate: 115200})
+type SerialTransport struct {
+	port serial.Port
 }
 
-// SendAndReceive sends data and reads the response with a timeout.
-func SendAndReceive(portName string, data []byte, timeout time.Duration) ([]byte, error) {
-	port, err := Open(portName)
+func Open(portName string) (*SerialTransport, error) {
+	port, err := serial.Open(portName, &serial.Mode{BaudRate: 115200})
 	if err != nil {
 		return nil, fmt.Errorf("opening %s: %w", portName, err)
 	}
-	defer port.Close()
+	return &SerialTransport{port: port}, nil
+}
 
-	port.SetReadTimeout(timeout)
-
-	_, err = port.Write(data)
-	if err != nil {
-		return nil, fmt.Errorf("writing to %s: %w", portName, err)
-	}
+func (t *SerialTransport) Send(data []byte) error {
+	_, err := t.port.Write(data)
+	return err
+}
 
+func (t *SerialTransport) Receive(timeout time.Duration) ([]byte, error) {
+	t.port.SetReadTimeout(timeout)
 	var resp []byte
 	buf := make([]byte, 256)
 	for {
-		n, err := port.Read(buf)
+		n, err := t.port.Read(buf)
 		if n > 0 {
 			resp = append(resp, buf[:n]...)
 		}
@@ -53,3 +53,7 @@ func SendAndReceive(portName string, data []byte, timeout time.Duration) ([]byte
 	}
 	return resp, nil
 }
+
+func (t *SerialTransport) Close() error {
+	return t.port.Close()
+}

lib/transport/transport.go

@@ -0,0 +1,9 @@
+package transport
+
+import "time"
+
+type Transport interface {
+	Send(data []byte) error
+	Receive(timeout time.Duration) ([]byte, error)
+	Close() error
+}

lib/wire/wire.go

@@ -1,57 +0,0 @@
-package wire
-
-import (
-	"fmt"
-
-	"github.com/theater/picomap/lib/halfsiphash"
-	"github.com/theater/picomap/lib/msgpack"
-)
-
-var HashKey = [8]byte{}
-
-type ResponseBOOTSEL struct{}
-type RequestBOOTSEL struct{}
-
-type Envelope struct {
-	Checksum uint32
-	Payload  []byte
-}
-
-func init() {
-	msgpack.RegisterExt(0, (*Envelope)(nil))
-	msgpack.RegisterExt(1, (*ResponseBOOTSEL)(nil))
-	msgpack.RegisterExt(2, (*RequestBOOTSEL)(nil))
-}
-
-func EncodeMessage(msg any) ([]byte, error) {
-	payload, err := msgpack.Marshal(msg)
-	if err != nil {
-		return nil, fmt.Errorf("encode inner: %w", err)
-	}
-
-	checksum := halfsiphash.Sum32(payload, HashKey)
-	env := Envelope{Checksum: checksum, Payload: payload}
-	data, err := msgpack.Marshal(&env)
-	if err != nil {
-		return nil, fmt.Errorf("encode envelope: %w", err)
-	}
-	return data, nil
-}
-
-func DecodeMessage(data []byte) (any, error) {
-	var env Envelope
-	if err := msgpack.Unmarshal(data, &env); err != nil {
-		return nil, fmt.Errorf("decode envelope: %w", err)
-	}
-
-	expected := halfsiphash.Sum32(env.Payload, HashKey)
-	if env.Checksum != expected {
-		return nil, fmt.Errorf("checksum mismatch: got %08x, want %08x", env.Checksum, expected)
-	}
-
-	var inner any
-	if err := msgpack.Unmarshal(env.Payload, &inner); err != nil {
-		return nil, fmt.Errorf("decode inner: %w", err)
-	}
-	return inner, nil
-}