rouggy
4e2a5877d6
From a user's log, repeating throughout the session: rigctld: split off failed: cat: this radio's backend cannot set split rigctld: unimplemented command "X PKTUSB -1" Both are answered with an error, and JTDX treats a rig-control error as fatal: it abandoned a transmission 0.86 seconds into a 13.8-second frame. "S 0" — split OFF. Fake It uses no split, and JTDX still sends this to be sure. A backend that cannot SET split was refusing a request that was ALREADY satisfied. It now succeeds when the rig is simplex, without touching the rig at all. Arming still fails loudly: there the request is real and unmet, and a client that believes it transmits up the band while the radio sits on the DX's frequency is exactly what that refusal exists to prevent. "X <mode>" — set_split_mode. Sent during ordinary setup, Fake It included, where there is no second VFO to give a mode to. Accepted now: applied when a split is in force, and a plain success otherwise, because the transmit VFO already has that mode — it is the same VFO. get_split_mode answers to match. Both regressions fail without the fix with the exact codes from that log, RPRT -9 and RPRT -11.
105 lines
4.2 KiB
Go
105 lines
4.2 KiB
Go
package rigctld
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// WSJT-X in "Split Operating: Rig" sends set_split_vfo then set_split_freq. Both
|
|
// used to answer RPRT 0 and do NOTHING: the software believed it was
|
|
// transmitting up the band while the radio stayed on the receive frequency —
|
|
// on a pileup, straight onto the DX, with no trace anywhere.
|
|
func TestSetSplitReachesTheRig(t *testing.T) {
|
|
rig := &fakeRig{freq: 14074000, mode: "FT8"}
|
|
s := New(0, rig, func(string, ...any) {})
|
|
|
|
if got, _ := s.handle("S 1 VFOB"); !strings.HasPrefix(got, "RPRT 0") {
|
|
t.Fatalf("set_split_vfo answered %q", got)
|
|
}
|
|
// Arming alone must NOT touch the rig: without a frequency it would transmit
|
|
// on whatever the second VFO happened to hold.
|
|
if len(rig.splitCalls) != 0 {
|
|
t.Errorf("split was armed before a frequency arrived: %v", rig.splitCalls)
|
|
}
|
|
|
|
if got, _ := s.handle("I 14075300.000000"); !strings.HasPrefix(got, "RPRT 0") {
|
|
t.Fatalf("set_split_freq answered %q", got)
|
|
}
|
|
if len(rig.splitCalls) != 1 || rig.splitCalls[0] != "true:14075300" {
|
|
t.Fatalf("rig saw %v, want one call arming split on 14075300", rig.splitCalls)
|
|
}
|
|
|
|
if got, _ := s.handle("S 0 VFOA"); !strings.HasPrefix(got, "RPRT 0") {
|
|
t.Fatalf("split off answered %q", got)
|
|
}
|
|
if len(rig.splitCalls) != 2 || !strings.HasPrefix(rig.splitCalls[1], "false:") {
|
|
t.Errorf("rig saw %v, want split cleared", rig.splitCalls)
|
|
}
|
|
}
|
|
|
|
// A backend that cannot do split must produce an ERROR the client can report.
|
|
// Answering success and doing nothing is what caused the original fault, and it
|
|
// is the one outcome that must never come back.
|
|
func TestSetSplitRefusalIsReported(t *testing.T) {
|
|
rig := &fakeRig{freq: 14074000, noSplit: true}
|
|
s := New(0, rig, func(string, ...any) {})
|
|
|
|
s.handle("S 1 VFOB")
|
|
got, _ := s.handle("I 14075300.000000")
|
|
if strings.HasPrefix(got, "RPRT 0") {
|
|
t.Errorf("a rig that cannot split answered %q — the client will transmit on the wrong frequency", got)
|
|
}
|
|
}
|
|
|
|
// "Fake It" uses NO split, and JTDX still sends "S 0" to make sure. A backend
|
|
// that cannot SET split used to answer an error to that — a refusal of a
|
|
// request that was already satisfied — and JTDX read it as rig control failing
|
|
// and abandoned the transmission a second into a 13.8-second frame.
|
|
//
|
|
// Reported against a Yaesu whose backend cannot arm split from software.
|
|
func TestSplitOffOnASimplexRigSucceeds(t *testing.T) {
|
|
rig := &fakeRig{freq: 14074000, mode: "FT8", noSplit: true}
|
|
s := New(0, rig, func(string, ...any) {})
|
|
|
|
if got, _ := s.handle("S 0 VFOA"); !strings.HasPrefix(got, "RPRT 0") {
|
|
t.Errorf("split off on a simplex rig answered %q — nothing needed doing", got)
|
|
}
|
|
// And it must not have bothered the rig at all.
|
|
if len(rig.splitCalls) != 0 {
|
|
t.Errorf("rig was asked to clear a split it did not have: %v", rig.splitCalls)
|
|
}
|
|
|
|
// Arming, however, must still fail loudly: there the request is real and
|
|
// unmet, and a client that believes it is transmitting up the band while the
|
|
// radio sits on the DX's frequency is the bug this refusal exists to prevent.
|
|
if got, _ := s.handle("S 1 VFOB"); !strings.HasPrefix(got, "RPRT 0") {
|
|
t.Fatalf("arming is deferred to set_split_freq: %q", got)
|
|
}
|
|
if got, _ := s.handle("I 14075300.000000"); strings.HasPrefix(got, "RPRT 0") {
|
|
t.Error("arming split on a backend that cannot must report a failure")
|
|
}
|
|
}
|
|
|
|
// X (set_split_mode) is sent by WSJT-X and JTDX during ordinary setup, Fake It
|
|
// included — where there is no second VFO to give a mode to. Answering "not
|
|
// implemented" made JTDX give up on rig control mid-transmission.
|
|
func TestSplitModeIsAccepted(t *testing.T) {
|
|
rig := &fakeRig{freq: 14074000, mode: "FT8"}
|
|
s := New(0, rig, func(string, ...any) {})
|
|
|
|
// No split: nothing to target, and succeeding is honest — the transmit VFO
|
|
// already has that mode because it is the same VFO.
|
|
if got, _ := s.handle("X PKTUSB -1"); !strings.HasPrefix(got, "RPRT 0") {
|
|
t.Errorf("set_split_mode answered %q", got)
|
|
}
|
|
if rig.mode != "FT8" {
|
|
t.Errorf("the mode was changed with no split in force: %q", rig.mode)
|
|
}
|
|
|
|
// Reading it back must answer a mode and a passband, never an error.
|
|
got, _ := s.handle("x")
|
|
if !strings.Contains(got, "FT8") {
|
|
t.Errorf("get_split_mode = %q, want the current mode", got)
|
|
}
|
|
}
|