rouggy/OpsLog
0
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 108 Wiki Activity

feat(tci): the voice keyer can send its messages through the radio

Browse Source 
The radio now appears as a device in both audio lists — 'Radio (TCI
network audio)' — so the receive audio and the voice keyer can both take
the CAT link instead of a sound card. No virtual cable, no second card, no
Windows mixer between the recording and the air.

The transmit side reuses the exchange the tone probe established, with a
WAV in place of the sine: the radio asks, we answer with the next slice,
and it sets the pace. The message is converted once, up front, rather than
per frame — a voice message is a few hundred kilobytes, and resampling
inside a callback that has 21 ms to answer would put arithmetic on the
path where a late frame is a gap on the air.

The PTT is untouched by all this: the keyer keys before and unkeys after
exactly as it does with a sound card, so a transmission is bracketed by
the same code whichever way the audio travels. And the playback runs OFF
the CAT goroutine, since everything else about the rig goes through that
one place and a ten-second message would otherwise freeze the frequency
display and the antenna following for ten seconds.

Two refusals rather than silent failure. A radio that has gone away stops
being offered as a device at all, and a radio whose transmit audio source
is still the microphone is caught within a fifth of a second — a voice
keyer that transmits silence is worse than one that says why it will not.
This commit is contained in:
rouggy
2026-08-25 23:59:09 +02:00
parent d4d22eb4b2
commit deeb654482
6 changed files with 429 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app.go
+89 -32
View File
@@ -781,8 +781,8 @@ type App struct {
// so closing the QSL Manager — or starting another download — stops the previous
// one instead of leaving it running against the app-lifetime context (which made
// a still-running QRZ sync bleed its log into a freshly started LoTW download).
confDLMu sync.Mutex
confDLCancel context.CancelFunc
confDLMu sync.Mutex
confDLCancel context.CancelFunc
// hamlogUnmatched holds the confirmations the last HAMLOG.online import
// could not place onto a QSO, kept so they can be exported and worked
@@ -790,31 +790,31 @@ type App struct {
// accumulated: it describes one run, not a history.
hamlogUnmatchedMu sync.Mutex
hamlogUnmatched []qso.QSO
udpLogMu sync.Mutex // serialises UDP auto-log so concurrent packets can't both pass the dedup check
adifMonMu sync.Mutex // guards the ADIF-monitor config (file list + per-file read offsets)
syncMu sync.Mutex // serialises folder synchronisation: config, the seq counter, and the append to our own file
syncSent int64 // changes written to the folder this session
syncReceived int64 // changes taken from the other machines this session
syncLast time.Time // last completed pass, for the status panel
syncErr string // last folder error, shown in settings — a share that dropped is otherwise invisible
relayAutoMu sync.Mutex // serialises relay auto-control evaluation
relayAutoLast map[string]bool // deviceID|relay → last applied on/off, so we only switch on a real change
relayAutoOn atomic.Bool // cached "auto-control enabled" so the CAT hot path skips work when off
relayDrvMu sync.Mutex // guards the cached relay drivers below
relayDrv map[string]cachedRelay // deviceID → live driver (reused across polls; stateful boards can't be reopened per call)
pttPort serial.Port // open serial port while PTT (RTS/DTR) is asserted
pttKeyedMethod string // "cat" | "rts" | "dtr" while keyed; "" when idle
pttGen int64 // bumped on every key; a delayed unkey only fires if unchanged (guards against a stale release cutting a new transmission)
startupErr string // captured for surfacing to the frontend
settingsScoped atomic.Bool // true once a.settings is scoped to the active profile — GetUIPref/SetUIPref (per-profile) must wait for it, else an early call reads the wrong scope and e.g. resets the theme
dbPath string // settings/config database file (settings + profiles); may be a user-chosen location
logbookPath string // default SQLite logbook file (QSOs), next to the settings db — used when a profile doesn't point elsewhere
logDbPath string // resolved SQLite file actually backing logDb ("" on MySQL, or when the settings db serves as the logbook) — the file the backup snapshots
logDb *sql.DB // QSO logbook connection — MySQL, a per-profile SQLite file, or the default logbook.db (never the settings db, except on fallback)
dbBackend string // "sqlite" | "mysql" — the logbook backend actually opened at startup
dbBackendErr string // non-empty when a configured MySQL backend failed and we fell back to SQLite
offlineQ *offlineq.Queue // ADIF outbox: QSOs logged while the DB was unreachable
offlineMode bool // last write failed because the DB was unreachable
udpLogMu sync.Mutex // serialises UDP auto-log so concurrent packets can't both pass the dedup check
adifMonMu sync.Mutex // guards the ADIF-monitor config (file list + per-file read offsets)
syncMu sync.Mutex // serialises folder synchronisation: config, the seq counter, and the append to our own file
syncSent int64 // changes written to the folder this session
syncReceived int64 // changes taken from the other machines this session
syncLast time.Time // last completed pass, for the status panel
syncErr string // last folder error, shown in settings — a share that dropped is otherwise invisible
relayAutoMu sync.Mutex // serialises relay auto-control evaluation
relayAutoLast map[string]bool // deviceID|relay → last applied on/off, so we only switch on a real change
relayAutoOn atomic.Bool // cached "auto-control enabled" so the CAT hot path skips work when off
relayDrvMu sync.Mutex // guards the cached relay drivers below
relayDrv map[string]cachedRelay // deviceID → live driver (reused across polls; stateful boards can't be reopened per call)
pttPort serial.Port // open serial port while PTT (RTS/DTR) is asserted
pttKeyedMethod string // "cat" | "rts" | "dtr" while keyed; "" when idle
pttGen int64 // bumped on every key; a delayed unkey only fires if unchanged (guards against a stale release cutting a new transmission)
startupErr string // captured for surfacing to the frontend
settingsScoped atomic.Bool // true once a.settings is scoped to the active profile — GetUIPref/SetUIPref (per-profile) must wait for it, else an early call reads the wrong scope and e.g. resets the theme
dbPath string // settings/config database file (settings + profiles); may be a user-chosen location
logbookPath string // default SQLite logbook file (QSOs), next to the settings db — used when a profile doesn't point elsewhere
logDbPath string // resolved SQLite file actually backing logDb ("" on MySQL, or when the settings db serves as the logbook) — the file the backup snapshots
logDb *sql.DB // QSO logbook connection — MySQL, a per-profile SQLite file, or the default logbook.db (never the settings db, except on fallback)
dbBackend string // "sqlite" | "mysql" — the logbook backend actually opened at startup
dbBackendErr string // non-empty when a configured MySQL backend failed and we fell back to SQLite
offlineQ *offlineq.Queue // ADIF outbox: QSOs logged while the DB was unreachable
offlineMode bool // last write failed because the DB was unreachable
catFlexSpots bool // push cluster spots to the FlexRadio panadapter
catFlexDVKDax bool // raise the Flex transmit DAX button around a voice message
@@ -8313,8 +8313,49 @@ type AudioSettings struct {
// ListAudioInputDevices / ListAudioOutputDevices enumerate WASAPI endpoints
// for the device dropdowns.
func (a *App) ListAudioInputDevices() ([]audio.Device, error) { return audio.ListInputDevices() }
func (a *App) ListAudioOutputDevices() ([]audio.Device, error) { return audio.ListOutputDevices() }
// ListAudioInputDevices lists the microphones and line inputs, plus THE RADIO
// when the CAT link carries its receive audio.
//
// Same reasoning as the output list: over TCI there is no sound device for
// Windows to show, so without this the one correct answer to "where does the
// received audio come from" could not be chosen at all.
func (a *App) ListAudioInputDevices() ([]audio.Device, error) {
devs, err := audio.ListInputDevices()
if err != nil {
return devs, err
}
if a.tciAudioAvailable() {
devs = append([]audio.Device{{ID: audio.NetworkDeviceID, Name: "Radio (TCI network audio)"}}, devs...)
}
return devs, nil
}
// tciAudioAvailable says whether the active CAT backend is a radio that streams
// its audio over the CAT link.
func (a *App) tciAudioAvailable() bool {
if a.cat == nil {
return false
}
_, ok := a.cat.TCIAudioState()
return ok
}
// ListAudioOutputDevices lists the sound cards, plus THE RADIO ITSELF when the
// CAT link can carry transmit audio.
//
// Offered only while it is actually available, and named as a radio rather than
// as a protocol: an operator choosing where their voice goes is picking between
// "my sound card" and "the radio", not between WASAPI and TCI.
func (a *App) ListAudioOutputDevices() ([]audio.Device, error) {
devs, err := audio.ListOutputDevices()
if err != nil {
return devs, err
}
if audio.NetworkPlayerReady() {
devs = append([]audio.Device{{ID: audio.NetworkDeviceID, Name: "Radio (TCI network audio)"}}, devs...)
}
return devs, nil
}
// GetAudioSettings returns the stored audio config (preroll defaults to 8s).
func (a *App) GetAudioSettings() (AudioSettings, error) {
@@ -8416,6 +8457,15 @@ func (a *App) SaveAudioSettings(s AudioSettings) error {
return err
}
}
// Choosing the radio as the receive device opens its stream, and choosing
// anything else closes it. Done HERE rather than left to the next restart:
// a device chosen in a dropdown that only takes effect after a relaunch
// reads as a device that does not work.
if s.FromRadio == audio.NetworkDeviceID {
a.startTCIRecording()
} else if a.tciAudioAvailable() && a.settingOr(keyTCIRecAudio, "") != "1" {
_ = a.cat.TCIAudioDo(func(t cat.TCIAudioController) error { return t.StopTCIAudio() })
}
// Apply device/preroll/enable changes to the running recorder.
a.startQSORecorderIfEnabled()
// And to a monitor ALREADY RUNNING: the operator is listening while they
@@ -8460,7 +8510,7 @@ func (a *App) startQSORecorderIfEnabled() {
// nothing right to point at. The stream is pushed into the recorder instead
// — same samples, no sound card in the middle, and no virtual cable to set up.
from := cfg.FromRadio
a.qsoRecPushed = a.icomNetAudioActive()
a.qsoRecPushed = a.icomNetAudioActive() || cfg.FromRadio == audio.NetworkDeviceID
if a.qsoRecPushed {
from = audio.PushedSource
}
@@ -15141,6 +15191,12 @@ func (a *App) reloadCAT() {
} else {
a.catSig = sig
}
// Withdraw the radio as an audio output before deciding anything else. The
// TCI case below puts it back; every other backend, and a CAT link turned
// off entirely, leaves it withdrawn — a voice keyer that still lists a radio
// it can no longer reach would play a message to nowhere, and the operator
// hears their own PTT click and assumes it went out.
a.installTCITXPlayer(false)
if !s.Enabled {
a.cat.Stop()
return
@@ -15267,6 +15323,9 @@ func (a *App) reloadCAT() {
// app_tci_rec.go. Armed after the backend is up, since it is the
// backend that carries the stream.
defer a.startTCIRecording()
// And the other direction: the voice keyer can send its messages over
// the same link — see app_tci_dvk.go.
defer a.installTCITXPlayer(true)
tb := cat.NewTCI(s.TCIHost, s.TCIPort, s.DigitalDefault, s.TCISpots)
// Clicking one of our spots on the ExpertSDR panorama fills the entry form.
tb.OnSpotClick = func(call string, hz int64) {
@@ -20341,8 +20400,6 @@ func clampSpotMax(n int) int {
return n
}
// GetSpotTTLMinutes returns how long a spot stays in the list, in minutes.
// 0 means spots are kept until the count cap pushes them out, which is what
// OpsLog always did.