ericek111/Nonemm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Alternate CQ between the two radios

Browse Source 
Ctrl+B calls CQ on one radio, and when that message has gone out, moves to the
other and calls there. The keyboard, the entry window and the SO2R box follow
each turn. N1MM calls this dueling CQs and puts it on the same key.

The turn is taken when the keyer says the message has ended, not when a timer
guesses it has. So MessageSender grew a Finished event and a ReportsCompletion
flag, and both keyers fill them in: cwdaemon answers the <ESC>h reply request
that now goes out in front of every message, and a WinKeyer clears the busy bit
in the status bytes it sends of its own accord. The status-byte reading is in
WinkeyerStatus, away from the serial port, because that is the half that can be
tested without a keyer on the desk. A keyer that reports nothing refuses to
start alternating CQ rather than keying the second radio over the first.

AlternatingCq itself takes the keyer, a callback that calls CQ on a radio, the
gap and a wait function, so the alternation is tested without sleeping. The gap
is in Config ▸ Keyer and messages and will not go below 100 ms, which is N1MM's
floor too: an SO2R box works relays.

docs/keying.md writes down why cwdaemon does the timing and we do not. N1MM
keys DTR itself with a coarse sleep, a busy-wait and a margin that grows every
time the sleep overshoots, and it raises the thread to TIME_CRITICAL for the
length of the message. The busy-wait ports to Linux; the priority does not,
without CAP_SYS_NICE, and a garbage collection mid-element is audible. A direct
serial keyer stays a reasonable third option, to be taken knowingly.

Running it against a fake daemon that takes 1.5 seconds to play a message: six
CQs went out back to back and the keyboard moved between the two entry windows
each time. Escape stopped it, let the message in flight finish, and started
nothing further.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
ericek111
2026-08-27 23:28:57 +00:00
parent d084789ed2
commit ae48c04e71
17 changed files with 721 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
src/Nonemm.App/AppSession.cs
View File

@@ -24,6 +24,7 @@ public sealed class AppSession : IDisposable
private ClusterClient? cluster;
private StationNetwork? network;
private MessageSender? keyer;
private AlternatingCq? alternating;
private So2rBox? box;
public AppSession(UserPaths paths, Settings settings)
@@ -91,6 +92,10 @@ public sealed class AppSession : IDisposable
public MessageSender? Keyer => keyer;
/// Alternating CQ, or null while there is no keyer. It needs two radios to
/// do anything, and a keyer that reports when a message has gone out.
public AlternatingCq? Alternating => alternating;
/// The SO2R box, or null when there is none and the operator switches the
/// transmitter and the headphones by hand.
public So2rBox? Box => box;
@@ -245,6 +250,8 @@ public sealed class AppSession : IDisposable
/// without one.
public void ApplyKeyerSettings()
{
alternating?.Dispose();
alternating = null;
keyer?.Dispose();
keyer = null;
switch (Settings.KeyerKind.ToLowerInvariant())
@@ -261,6 +268,10 @@ public sealed class AppSession : IDisposable
if (keyer is not null)
{
_ = keyer.SetSpeedAsync(Settings.KeyerSpeed);
alternating = new AlternatingCq(
keyer,
CallCqOnAsync,
TimeSpan.FromMilliseconds(Settings.AlternatingCqGapMs));
}
Changed?.Invoke(this, EventArgs.Empty);
}
@@ -303,12 +314,47 @@ public sealed class AppSession : IDisposable
{
return;
}
activeRadio = (activeRadio + 1) % positions.Count;
MoveToRadio(positions[(activeRadio + 1) % positions.Count].RadioNumber);
}
/// Moves the operator to a radio by number. Alternating CQ calls this from
/// the keyer's thread, so everything it raises is posted by the windows.
public void MoveToRadio(int radioNumber)
{
int at = positions.FindIndex(p => p.RadioNumber == radioNumber);
if (at < 0 || at == activeRadio)
{
return;
}
activeRadio = at;
_ = FollowActiveRadioAsync();
Changed?.Invoke(this, EventArgs.Empty);
ActiveRadioChanged?.Invoke(this, ActiveRadioNumber);
}
/// Moves to the radio and sends its CQ message, which is F1. Used by
/// alternating CQ; the operator's own F1 goes through the entry window.
private async Task CallCqOnAsync(int radioNumber)
{
RadioPosition position = positions.FirstOrDefault(p => p.RadioNumber == radioNumber)
?? throw new InvalidOperationException($"there is no radio {radioNumber}");
if (keyer is null)
{
throw new InvalidOperationException("there is no keyer");
}
string template = Messages.For(
position.Mode.Category,
Settings.CwMessages,
Settings.PhoneMessages)[0];
if (template.Length == 0)
{
throw new InvalidOperationException("F1 has no message — Config ▸ Keyer and messages");
}
MoveToRadio(radioNumber);
await PointTransmitAtAsync(radioNumber).ConfigureAwait(false);
await keyer.SendAsync(MessageExpander.Expand(template, position)).ConfigureAwait(false);
}
/// Puts both radios in the headphones, or goes back to one. An operator
/// listens to the second radio while the first is sending.
public void ToggleListenToBoth()
@@ -414,6 +460,7 @@ public sealed class AppSession : IDisposable
DisposeRadios();
cluster?.Dispose();
network?.Dispose();
alternating?.Dispose();
keyer?.Dispose();
box?.Dispose();
store?.Dispose();

5
src/Nonemm.App/Configuration/Settings.cs
View File

@@ -62,6 +62,11 @@ public sealed record Settings
public int KeyerSpeed { get; init; } = 28;
/// How long alternating CQ leaves between one message ending and the other
/// radio starting. N1MM asks for the same number and will not go below
/// 100 ms, because an SO2R box works relays.
public int AlternatingCqGapMs { get; init; } = 100;
/// Sub-band boundaries the operator has changed. Empty means the defaults
/// in `BandPlan.Default`; an entry replaces one band's boundaries.
public IReadOnlyList<StoredSubBand> SubBands { get; init; } = [];

7
src/Nonemm.App/Dialogs/KeyerDialog.axaml
View File

@@ -15,6 +15,13 @@
<TextBlock Grid.Column="4" Text="Speed" FontSize="11" Opacity="0.7" Margin="0,6,0,1" />
<TextBox Name="SpeedBox" Grid.Row="1" Grid.Column="4" />
</Grid>
<Grid ColumnDefinitions="150,8,*" RowDefinitions="Auto,Auto">
<TextBlock Text="Alternating CQ gap (ms)" FontSize="11" Opacity="0.7" Margin="0,6,0,1" />
<TextBox Name="AlternatingGapBox" Grid.Row="1" />
<TextBlock Grid.Column="2" Grid.Row="1" FontSize="11" Opacity="0.7"
VerticalAlignment="Center" TextWrapping="Wrap"
Text="Ctrl+B starts calling CQ on one radio and then the other. Needs two radios." />
</Grid>
<TextBlock Text="Messages" FontSize="11" Opacity="0.7" Margin="0,10,0,1" />
<StackPanel Orientation="Horizontal" Spacing="6">
<RadioButton Name="CwButton" Content="CW" GroupName="mode" IsChecked="True" />

5
src/Nonemm.App/Dialogs/KeyerDialog.axaml.cs
View File

@@ -22,6 +22,7 @@ public sealed partial class KeyerDialog : Window
KindBox.SelectedItem = settings.KeyerKind;
KindBox.SelectionChanged += (_, _) => ShowTarget();
SpeedBox.Text = settings.KeyerSpeed.ToString();
AlternatingGapBox.Text = settings.AlternatingCqGapMs.ToString();
CwButton.IsCheckedChanged += (_, _) => ShowMessages();
ShowTarget();
BuildMessageBoxes();
@@ -91,6 +92,10 @@ public sealed partial class KeyerDialog : Window
? port
: settings.KeyerPort,
KeyerSpeed = int.TryParse(SpeedBox.Text, out int speed) ? speed : settings.KeyerSpeed,
// N1MM will not go below 100 ms either: the box works relays
AlternatingCqGapMs = int.TryParse(AlternatingGapBox.Text, out int gap)
? Math.Max(100, gap)
: settings.AlternatingCqGapMs,
CwMessages = cwMessages,
PhoneMessages = phoneMessages,
});

45
src/Nonemm.App/Windows/EntryWindow.axaml.cs
View File

@@ -234,6 +234,7 @@ public sealed partial class EntryWindow : Window
break;
case Key.Escape:
e.Handled = true;
session.Alternating?.Stop();
_ = session.Keyer?.AbortAsync();
Logging.Wipe();
SyncBoxes();
@@ -253,6 +254,10 @@ public sealed partial class EntryWindow : Window
e.Handled = true;
MoveFocus(forward: !e.KeyModifiers.HasFlag(KeyModifiers.Shift));
break;
case Key.B when e.KeyModifiers.HasFlag(KeyModifiers.Control):
e.Handled = true;
ToggleAlternatingCq();
break;
case Key.Y when e.KeyModifiers.HasFlag(KeyModifiers.Control):
e.Handled = true;
OnEditLastContact(this, new RoutedEventArgs());
@@ -451,6 +456,46 @@ public sealed partial class EntryWindow : Window
}
}
/// Alternating CQ: CQ on this radio, then the other as each message ends.
/// N1MM calls it dueling CQs and puts it on the same key.
private void ToggleAlternatingCq()
{
if (session.Alternating is not { } alternating)
{
Status("no keyer — Config ▸ Keyer");
return;
}
if (alternating.IsRunning)
{
alternating.Stop();
Status("alternating CQ off");
return;
}
if (session.Positions.Count < 2)
{
Status("alternating CQ needs two radios");
return;
}
if (!alternating.IsPossible)
{
Status("this keyer does not report when a message has gone out");
return;
}
alternating.Stopped -= OnAlternatingStopped;
alternating.Stopped += OnAlternatingStopped;
alternating.Start(radioNumber);
Status($"alternating CQ · radio {radioNumber} first");
}
private void OnAlternatingStopped(object? sender, string reason)
{
if (sender is AlternatingCq alternating)
{
alternating.Stopped -= OnAlternatingStopped;
}
Dispatcher.UIThread.Post(() => Status($"alternating CQ stopped: {reason}"));
}
private void SendMessage(int index)
{
if (Logging is null || session.Keyer is null)

60
src/Nonemm.Keying/CwDaemonSender.cs
View File

@@ -7,21 +7,40 @@ namespace Nonemm.Keying;
/// Sends CW through `cwdaemon`, which keys the radio from a serial or parallel
/// port and is what Linux stations usually run. Its protocol is one UDP
/// datagram per command; escape sequences start with a 0x1B byte.
///
/// `<ESC>h<text>` asks for a reply once the next message has been played, and
/// cwdaemon answers with `h` and that text. The request covers one message
/// only, so it goes out in front of every message.
///
/// Why the timing is cwdaemon's job and not ours: `docs/keying.md`.
public sealed class CwDaemonSender : MessageSender
{
private readonly UdpClient socket = new();
private const string ReplyToken = "nonemm";
// bound before anything is sent, so the reply has somewhere to arrive
private readonly UdpClient socket = new(new IPEndPoint(IPAddress.Any, 0));
private readonly IPEndPoint daemon;
private readonly CancellationTokenSource reading = new();
public CwDaemonSender(string host = "127.0.0.1", int port = 6789)
{
daemon = new IPEndPoint(IPAddress.Parse(host), port);
IsReady = true;
_ = ReadRepliesAsync(reading.Token);
}
public bool IsReady { get; private set; }
public Task SendAsync(string text, CancellationToken cancellation = default) =>
WriteAsync(Encoding.ASCII.GetBytes(text.ToUpperInvariant()), cancellation);
public bool ReportsCompletion => true;
public event EventHandler? Finished;
public async Task SendAsync(string text, CancellationToken cancellation = default)
{
await WriteAsync(Escape('h', ReplyToken), cancellation).ConfigureAwait(false);
await WriteAsync(Encoding.ASCII.GetBytes(text.ToUpperInvariant()), cancellation)
.ConfigureAwait(false);
}
public Task AbortAsync(CancellationToken cancellation = default) =>
WriteAsync([0x1B, (byte)'4'], cancellation);
@@ -29,11 +48,44 @@ public sealed class CwDaemonSender : MessageSender
public Task SetSpeedAsync(int wordsPerMinute, CancellationToken cancellation = default) =>
WriteAsync(Escape('2', wordsPerMinute.ToString()), cancellation);
public void Dispose() => socket.Dispose();
public void Dispose()
{
reading.Cancel();
reading.Dispose();
socket.Dispose();
}
private static byte[] Escape(char command, string argument) =>
[0x1B, (byte)command, .. Encoding.ASCII.GetBytes(argument)];
/// cwdaemon's reply arrives on the same socket the commands went out on.
/// A reply for anything other than our own token is another program's
/// business and is passed over.
private async Task ReadRepliesAsync(CancellationToken cancellation)
{
while (!cancellation.IsCancellationRequested)
{
UdpReceiveResult received;
try
{
received = await socket.ReceiveAsync(cancellation).ConfigureAwait(false);
}
catch (Exception e) when (e is OperationCanceledException or ObjectDisposedException)
{
return;
}
catch (SocketException)
{
// a datagram that could not be read says nothing about the next
continue;
}
if (Encoding.ASCII.GetString(received.Buffer).TrimEnd('\r', '\n') == $"h{ReplyToken}")
{
Finished?.Invoke(this, EventArgs.Empty);
}
}
}
private async Task WriteAsync(byte[] message, CancellationToken cancellation)
{
try

10
src/Nonemm.Keying/MessageSender.cs
View File

@@ -6,6 +6,16 @@ public interface MessageSender : IDisposable
{
bool IsReady { get; }
/// True when the keyer tells us the message has gone out. Alternating CQ
/// needs it: timing a message from the length of its text is a guess that
/// goes wrong exactly when the contest is busy.
bool ReportsCompletion { get; }
/// Everything sent has now gone out on the air. Never raised by a keyer
/// whose `ReportsCompletion` is false. It arrives on whatever thread the
/// keyer reads on, so a handler that touches the screen has to post.
event EventHandler? Finished;
/// Sends the text. Whatever is already going out is finished first unless
/// `Abort` is called.
Task SendAsync(string text, CancellationToken cancellation = default);

21
src/Nonemm.Keying/WinkeyerSender.cs
View File

@@ -15,14 +15,22 @@ public sealed class WinkeyerSender : MessageSender
private const byte ClearBuffer = 0x0A;
private readonly SerialPort port;
private readonly WinkeyerStatus status = new();
public WinkeyerSender(string portName, int baudRate = 1200)
{
port = new SerialPort(portName, baudRate, Parity.None, 8, StopBits.Two);
port.DataReceived += (_, _) => ReadStatus();
}
public bool IsReady => port.IsOpen;
/// The keyer sends a status byte of its own accord whenever it starts or
/// stops sending, so nothing has to be asked for.
public bool ReportsCompletion => true;
public event EventHandler? Finished;
/// Opens the port and puts the keyer in host mode. The keyer answers with
/// its firmware version, which is read and thrown away.
public void Open()
@@ -61,6 +69,19 @@ public sealed class WinkeyerSender : MessageSender
port.Dispose();
}
/// Runs on the serial port's own thread.
private void ReadStatus()
{
int waiting = port.BytesToRead;
for (int at = 0; at < waiting; at++)
{
if (status.Read((byte)port.ReadByte()))
{
Finished?.Invoke(this, EventArgs.Empty);
}
}
}
private void Write(byte[] message)
{
if (!port.IsOpen)

33
src/Nonemm.Keying/WinkeyerStatus.cs Normal file
View File

@@ -0,0 +1,33 @@
namespace Nonemm.Keying;
/// Reads the bytes a WinKeyer sends back in host mode and works out when it has
/// stopped sending.
///
/// A byte from 0xC0 to 0xDF is a status byte; the low six bits are the flags,
/// and 0x04 is set while the keyer is sending. Bytes from 0x80 to 0xBF are the
/// speed pot, and printable bytes are the keyer echoing what it has sent.
/// Neither says anything about the buffer, so both are passed over.
///
/// Where the bit meanings come from: `docs/keying.md`.
public sealed class WinkeyerStatus
{
private const byte StatusLow = 0xC0;
private const byte StatusHigh = 0xDF;
private const byte BusyFlag = 0x04;
public bool IsSending { get; private set; }
/// True on the byte that says the keyer has finished: it was sending and
/// now is not. Every other byte returns false, including a second status
/// byte that repeats what the last one said.
public bool Read(byte value)
{
if (value is < StatusLow or > StatusHigh)
{
return false;
}
bool wasSending = IsSending;
IsSending = (value & BusyFlag) != 0;
return wasSending && !IsSending;
}
}

147
src/Nonemm.Session/AlternatingCq.cs Normal file
View File

@@ -0,0 +1,147 @@
using Nonemm.Keying;
namespace Nonemm.Session;
/// Calls CQ on one radio, and when that message has gone out, moves to the
/// other radio and calls there. N1MM calls it dueling CQs and toggles it with
/// Ctrl+B.
///
/// It runs off the keyer's completion signal. Working out when a message ends
/// from the length of the text would be a guess, and a guess that runs short
/// keys the second radio while the first is still sending.
///
/// Two radios, because that is what an SO2R station has.
public sealed class AlternatingCq : IDisposable
{
private readonly MessageSender keyer;
private readonly Func<int, Task> callCqOn;
private readonly Func<TimeSpan, CancellationToken, Task> wait;
private readonly Lock gate = new();
private CancellationTokenSource? running;
/// `callCqOn` moves the operator to that radio and sends the CQ message.
/// `wait` is there so a test does not have to sleep.
public AlternatingCq(
MessageSender keyer,
Func<int, Task> callCqOn,
TimeSpan gap,
Func<TimeSpan, CancellationToken, Task>? wait = null)
{
this.keyer = keyer;
this.callCqOn = callCqOn;
Gap = gap;
this.wait = wait ?? Task.Delay;
keyer.Finished += OnFinished;
}
/// How long to leave between the message ending and the other radio
/// starting. The relays of an SO2R box need a moment.
public TimeSpan Gap { get; }
public bool IsRunning
{
get
{
lock (gate)
{
return running is not null;
}
}
}
/// The radio it is calling on now.
public int RadioNumber { get; private set; }
/// Raised when it stops by itself, with the reason. Stopping by hand does
/// not raise it.
public event EventHandler<string>? Stopped;
/// True when the keyer can drive this at all.
public bool IsPossible => keyer.ReportsCompletion;
public void Start(int radioNumber)
{
if (!IsPossible)
{
throw new InvalidOperationException("this keyer does not report when a message has gone out");
}
CancellationToken token;
lock (gate)
{
running?.Cancel();
running?.Dispose();
running = new CancellationTokenSource();
token = running.Token;
}
RadioNumber = radioNumber;
_ = CallAsync(radioNumber, token);
}
public void Stop()
{
lock (gate)
{
running?.Cancel();
running?.Dispose();
running = null;
}
}
public void Dispose()
{
keyer.Finished -= OnFinished;
Stop();
}
private void OnFinished(object? sender, EventArgs e)
{
CancellationToken token;
lock (gate)
{
if (running is null)
{
return;
}
token = running.Token;
}
_ = NextAsync(token);
}
private async Task NextAsync(CancellationToken token)
{
try
{
await wait(Gap, token).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
return;
}
if (token.IsCancellationRequested)
{
return;
}
RadioNumber = RadioNumber == 1 ? 2 : 1;
await CallAsync(RadioNumber, token).ConfigureAwait(false);
}
/// A keyer that has gone away stops the whole thing rather than leaving one
/// radio calling into a dead port.
private async Task CallAsync(int radioNumber, CancellationToken token)
{
try
{
await callCqOn(radioNumber).ConfigureAwait(false);
}
catch (Exception e) when (e is InvalidOperationException or IOException)
{
// read before Stop, which cancels this same token
bool stoppedByHand = token.IsCancellationRequested;
Stop();
if (!stoppedByHand)
{
Stopped?.Invoke(this, e.Message);
}
}
}
}

1
src/Nonemm.Session/Nonemm.Session.csproj
View File

@@ -6,6 +6,7 @@
<ProjectReference Include="..\Nonemm.Storage\Nonemm.Storage.csproj" />
<ProjectReference Include="..\Nonemm.Formats\Nonemm.Formats.csproj" />
<ProjectReference Include="..\Nonemm.Spotting\Nonemm.Spotting.csproj" />
<ProjectReference Include="..\Nonemm.Keying\Nonemm.Keying.csproj" />
</ItemGroup>
<PropertyGroup>