chore: release v0.21.3
This commit is contained in:
+109
-8
@@ -25,6 +25,7 @@ package steppir
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
@@ -35,6 +36,10 @@ import (
|
||||
"go.bug.st/serial"
|
||||
)
|
||||
|
||||
// errBadFrame marks a reply that isn't a well-formed status frame. It means
|
||||
// "ignore this poll", not "the link is down".
|
||||
var errBadFrame = errors.New("steppir: malformed status frame")
|
||||
|
||||
// Direction values, matching the app-wide convention (also used by Ultrabeam):
|
||||
// 0 normal, 1 reverse (180°), 2 bidirectional.
|
||||
const (
|
||||
@@ -50,6 +55,15 @@ const (
|
||||
wireBi = 0x80
|
||||
)
|
||||
|
||||
// pendingDirTTL is how long a commanded direction is trusted over the
|
||||
// controller's own report. The elements physically re-tune to swap director and
|
||||
// reflector, and the SDA only reports the new pattern once it starts that move,
|
||||
// so a few seconds is not enough — 4 s (the original value) had the UI snapping
|
||||
// back to "normal" while the antenna was on its way to 180°. Long enough to
|
||||
// cover a real move, short enough that a command the controller never received
|
||||
// self-corrects instead of lying forever.
|
||||
const pendingDirTTL = 45 * time.Second
|
||||
|
||||
// Transport says how to reach the controller.
|
||||
type Transport struct {
|
||||
Mode string // "tcp" | "serial"
|
||||
@@ -94,6 +108,11 @@ type Client struct {
|
||||
// A just-commanded direction is held until the controller's poll reports it —
|
||||
// the motors take a second or two, and a stale poll would otherwise snap the
|
||||
// UI back. Same trick as the Ultrabeam client.
|
||||
//
|
||||
// The hold is deliberately long (pendingDirTTL). It is not just a UI nicety:
|
||||
// the follow loop re-tunes with the direction it reads back from this status,
|
||||
// so a single stale poll reading "normal" would make OpsLog command the
|
||||
// antenna out of 180° all by itself.
|
||||
pendingDir int
|
||||
pendingDirAt time.Time
|
||||
pendingDirSet bool
|
||||
@@ -189,6 +208,12 @@ func (c *Client) pollLoop() {
|
||||
c.connMu.Unlock()
|
||||
|
||||
st, err := c.queryStatus()
|
||||
if errors.Is(err, errBadFrame) {
|
||||
// Framing glitch, not a dead link: skip this tick and keep the
|
||||
// previous status. Dropping the connection here would blink the
|
||||
// UI to "disconnected" over one garbled reply.
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
log.Printf("steppir: status query failed, reconnecting: %v", err)
|
||||
c.closeConn()
|
||||
@@ -197,19 +222,32 @@ func (c *Client) pollLoop() {
|
||||
}
|
||||
st.Connected = true
|
||||
c.statusMu.Lock()
|
||||
if c.pendingDirSet {
|
||||
if time.Since(c.pendingDirAt) > 4*time.Second || st.Direction == c.pendingDir {
|
||||
c.pendingDirSet = false
|
||||
} else {
|
||||
st.Direction = c.pendingDir
|
||||
}
|
||||
}
|
||||
c.applyPendingDir(st)
|
||||
c.lastStatus = st
|
||||
c.statusMu.Unlock()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// applyPendingDir replaces a freshly polled direction with the one the operator
|
||||
// last commanded, until the controller confirms it (or the hold expires). The
|
||||
// caller holds statusMu.
|
||||
func (c *Client) applyPendingDir(st *Status) {
|
||||
if !c.pendingDirSet {
|
||||
return
|
||||
}
|
||||
switch {
|
||||
case st.Direction == c.pendingDir:
|
||||
c.pendingDirSet = false // confirmed — trust the controller's reports again
|
||||
case time.Since(c.pendingDirAt) > pendingDirTTL:
|
||||
c.pendingDirSet = false
|
||||
log.Printf("steppir: controller never confirmed direction %d (still reports %d) — dropping the hold",
|
||||
c.pendingDir, st.Direction)
|
||||
default:
|
||||
st.Direction = c.pendingDir
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) setDisconnected() {
|
||||
c.statusMu.Lock()
|
||||
c.lastStatus = &Status{Connected: false}
|
||||
@@ -232,6 +270,56 @@ func setDeadline(conn io.ReadWriteCloser, d time.Duration) {
|
||||
}
|
||||
}
|
||||
|
||||
// setReadTimeout bounds a single read on either transport, so a drain can tell
|
||||
// "nothing more queued" from "still arriving" without blocking.
|
||||
func setReadTimeout(conn io.ReadWriteCloser, d time.Duration) {
|
||||
switch t := conn.(type) {
|
||||
case net.Conn:
|
||||
_ = t.SetReadDeadline(time.Now().Add(d))
|
||||
case serial.Port:
|
||||
_ = t.SetReadTimeout(d)
|
||||
}
|
||||
}
|
||||
|
||||
// restoreTimeouts puts the normal exchange timeouts back after a drain shortened
|
||||
// them.
|
||||
func restoreTimeouts(conn io.ReadWriteCloser) {
|
||||
setDeadline(conn, 3*time.Second) // TCP: read + write
|
||||
setReadTimeout(conn, 2*time.Second)
|
||||
}
|
||||
|
||||
// drain throws away everything already sitting in the input buffer and returns
|
||||
// how many bytes it discarded.
|
||||
//
|
||||
// This is the fix for the antenna's state appearing tens of seconds out of date.
|
||||
// The SDA controller does not only answer "?A" — it also pushes status frames on
|
||||
// its own (front-panel changes, autotrack moves, each command it processes). We
|
||||
// consume exactly one frame per poll, so every unsolicited frame adds one to a
|
||||
// backlog that only ever grows: reading 11 bytes then returns a frame from
|
||||
// minutes ago. The field log showed it plainly — two consecutive polls 4 s apart
|
||||
// reporting 28280 kHz then 14200 kHz, a frequency last used hours earlier, and a
|
||||
// 180° command not showing up in the status for ~40 s (long after the UI had
|
||||
// given up waiting and snapped the button back to "normal"). Emptying the buffer
|
||||
// immediately before each query means the frame we then read is the answer to
|
||||
// THIS query.
|
||||
func drain(conn io.ReadWriteCloser) int {
|
||||
buf := make([]byte, 512)
|
||||
total := 0
|
||||
// Bounded so a controller that streams continuously can't hold the poll
|
||||
// goroutine here forever. 32 × 512 B is ~1500 frames — far more backlog than
|
||||
// any real link builds up, and it only costs one 30 ms timeout when the
|
||||
// buffer is already empty (reads return immediately while data is queued).
|
||||
for i := 0; i < 32; i++ {
|
||||
setReadTimeout(conn, 30*time.Millisecond)
|
||||
n, err := conn.Read(buf)
|
||||
total += n
|
||||
if err != nil || n == 0 { // timeout / nothing left
|
||||
break
|
||||
}
|
||||
}
|
||||
return total
|
||||
}
|
||||
|
||||
func (c *Client) queryStatus() (*Status, error) {
|
||||
c.connMu.Lock()
|
||||
conn := c.conn
|
||||
@@ -241,7 +329,12 @@ func (c *Client) queryStatus() (*Status, error) {
|
||||
}
|
||||
c.ioMu.Lock()
|
||||
defer c.ioMu.Unlock()
|
||||
setDeadline(conn, 3*time.Second)
|
||||
// Discard any frame the controller pushed on its own since the last poll, so
|
||||
// what we read below is this query's answer and not a stale backlog entry.
|
||||
if n := drain(conn); n > 0 {
|
||||
log.Printf("steppir: discarded %d stale byte(s) queued by the controller before polling", n)
|
||||
}
|
||||
restoreTimeouts(conn)
|
||||
if _, err := conn.Write([]byte("?A\r")); err != nil {
|
||||
return nil, fmt.Errorf("write status cmd: %w", err)
|
||||
}
|
||||
@@ -249,6 +342,14 @@ func (c *Client) queryStatus() (*Status, error) {
|
||||
if _, err := io.ReadFull(conn, buf); err != nil {
|
||||
return nil, fmt.Errorf("read status: %w", err)
|
||||
}
|
||||
// Reject anything that isn't a framed reply rather than decoding garbage into
|
||||
// a frequency and a direction the app would then act on.
|
||||
if buf[0] != '@' || buf[1] != 'A' || buf[10] != 0x0D {
|
||||
log.Printf("steppir: ignoring malformed status frame % X", buf)
|
||||
drain(conn) // resync: drop the rest of whatever we landed mid-way through
|
||||
restoreTimeouts(conn)
|
||||
return nil, errBadFrame
|
||||
}
|
||||
st, err := parseStatus(buf)
|
||||
// Log the raw frame + decode whenever it changes. The motor byte (buf[6]) is
|
||||
// what decides st.MotorsMoving, and that in turn drives the app's "block TX
|
||||
|
||||
@@ -1,8 +1,12 @@
|
||||
package steppir
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// The exact bytes are the correctness checksum. If buildSet ever drifts from the
|
||||
@@ -104,3 +108,120 @@ func TestParseStatus(t *testing.T) {
|
||||
t.Error("active-motors 0xFF (command received) must not read as moving")
|
||||
}
|
||||
}
|
||||
|
||||
// fakeConn stands in for the controller link. rx holds bytes the "controller"
|
||||
// has already sent (what the client will read), tx collects what the client
|
||||
// wrote, and a "?A" query queues `reply` into rx the way the SDA answers.
|
||||
//
|
||||
// Reads never block: an empty rx returns (0, nil), which is exactly how
|
||||
// go.bug.st/serial reports a read timeout, so drain() sees the same
|
||||
// nothing-left signal it gets from real hardware.
|
||||
type fakeConn struct {
|
||||
mu sync.Mutex
|
||||
rx bytes.Buffer
|
||||
tx bytes.Buffer
|
||||
reply []byte
|
||||
}
|
||||
|
||||
func (f *fakeConn) Read(p []byte) (int, error) {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
if f.rx.Len() == 0 {
|
||||
return 0, nil
|
||||
}
|
||||
return f.rx.Read(p)
|
||||
}
|
||||
|
||||
func (f *fakeConn) Write(p []byte) (int, error) {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
f.tx.Write(p)
|
||||
if bytes.Contains(p, []byte("?A")) {
|
||||
f.rx.Write(f.reply)
|
||||
}
|
||||
return len(p), nil
|
||||
}
|
||||
|
||||
func (f *fakeConn) Close() error { return nil }
|
||||
|
||||
var (
|
||||
// 50.150 MHz, normal — the "stuck at 6 m" frame that kept turning up in
|
||||
// F4BPO's friend's log long after the rig had left the band.
|
||||
frame6mNormal = []byte{0x40, 0x41, 0x00, 0x4C, 0x85, 0xD8, 0x00, 0x07, 0x30, 0x38, 0x0D}
|
||||
// 14.250 MHz, 180° — what the controller actually reports right now.
|
||||
frame20m180 = []byte{0x40, 0x41, 0x00, 0x15, 0xBE, 0x68, 0x00, 0x47, 0x30, 0x38, 0x0D}
|
||||
)
|
||||
|
||||
// The controller pushes status frames unsolicited, so they pile up between polls.
|
||||
// Reading one frame per poll then returns state from minutes ago — which is how a
|
||||
// 180° command could take ~40 s to show up in the UI, and how two polls 4 s apart
|
||||
// reported 28 MHz then 14 MHz. queryStatus must empty the backlog first.
|
||||
func TestQueryStatusDiscardsQueuedFrames(t *testing.T) {
|
||||
fc := &fakeConn{reply: frame20m180}
|
||||
fc.rx.Write(frame6mNormal) // two frames the controller pushed on its own
|
||||
fc.rx.Write(frame6mNormal)
|
||||
|
||||
c := &Client{conn: fc}
|
||||
st, err := c.queryStatus()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if st.Frequency != 14250 {
|
||||
t.Errorf("freq = %d kHz, want 14250 — a stale queued frame was read instead of this poll's reply", st.Frequency)
|
||||
}
|
||||
if st.Direction != Dir180 {
|
||||
t.Errorf("direction = %d, want %d (180°)", st.Direction, Dir180)
|
||||
}
|
||||
}
|
||||
|
||||
// A reply we land on mid-frame must be rejected, not decoded into a bogus
|
||||
// frequency and direction the follow loop would then act on — and it must not
|
||||
// look like a dead link either (errBadFrame keeps the connection).
|
||||
func TestQueryStatusRejectsMalformedFrame(t *testing.T) {
|
||||
shifted := append(append([]byte{}, frame20m180[3:]...), 0x40, 0x41, 0x00) // 11 bytes, wrong header
|
||||
c := &Client{conn: &fakeConn{reply: shifted}}
|
||||
if _, err := c.queryStatus(); !errors.Is(err, errBadFrame) {
|
||||
t.Fatalf("err = %v, want errBadFrame", err)
|
||||
}
|
||||
}
|
||||
|
||||
// The direction the operator just commanded is shown until the controller
|
||||
// confirms it. The hold used to be 4 s — two polls — so the button snapped back
|
||||
// to Normal while the elements were still swapping over to 180°.
|
||||
func TestApplyPendingDirHold(t *testing.T) {
|
||||
c := &Client{pendingDir: Dir180, pendingDirAt: time.Now(), pendingDirSet: true}
|
||||
|
||||
// Controller still reports the old pattern: keep showing what was commanded.
|
||||
st := &Status{Direction: DirNormal}
|
||||
c.applyPendingDir(st)
|
||||
if st.Direction != Dir180 {
|
||||
t.Fatalf("direction = %d, want %d while the move is pending", st.Direction, Dir180)
|
||||
}
|
||||
if !c.pendingDirSet {
|
||||
t.Fatal("hold released before the controller confirmed")
|
||||
}
|
||||
|
||||
// Still holding well past the old 4 s window — a SteppIR takes longer than
|
||||
// that to report a pattern change.
|
||||
c.pendingDirAt = time.Now().Add(-10 * time.Second)
|
||||
st = &Status{Direction: DirNormal}
|
||||
c.applyPendingDir(st)
|
||||
if st.Direction != Dir180 {
|
||||
t.Fatalf("direction = %d after 10 s, want %d — the hold expired too early", st.Direction, Dir180)
|
||||
}
|
||||
|
||||
// Controller confirms: release the hold and trust its reports again.
|
||||
st = &Status{Direction: Dir180}
|
||||
c.applyPendingDir(st)
|
||||
if c.pendingDirSet {
|
||||
t.Fatal("hold should be released once the controller reports the commanded direction")
|
||||
}
|
||||
|
||||
// A command the controller never acted on must not lie forever.
|
||||
c.pendingDir, c.pendingDirAt, c.pendingDirSet = DirBi, time.Now().Add(-pendingDirTTL-time.Second), true
|
||||
st = &Status{Direction: DirNormal}
|
||||
c.applyPendingDir(st)
|
||||
if st.Direction != DirNormal || c.pendingDirSet {
|
||||
t.Fatalf("expired hold should fall back to the controller: direction = %d, pending = %v", st.Direction, c.pendingDirSet)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user