feat: add rig control for Doppler correction

Add CAT protocol drivers (Kenwood, Yaesu modern/legacy, Icom CI-V,
rigctld) to send Doppler-corrected frequencies to radios. Extends
DopplerWindow with Chart/Setup tabs, mode selector with SatNOGS
mapping, and live correction status bar.

- Shared serial transports (text + binary) in src/serial/transport.ts
  with configurable delimiter, fixed-length reads, and shared baud rates
- Five protocol drivers validated against official docs and Hamlib source
- Rig store with timer-based correction loop and push model from DopplerWindow
- Auto-select next pass when DopplerWindow opens
- Setup UI with protocol/baud/CI-V address config and bridge tool guide
- Disabled styles for Button/Input/Select, footerPadding prop on DraggableWindow
- Unified baud rates, renamed mode labels to serial/rotctld/rigctld
- Matched DopplerWindow width to RotatorWindow (400px, noPad)

Author: sandrwich

src/app.ts

@@ -54,6 +54,7 @@ import { palette } from './ui/shared/theme';
 import { chart } from './ui/shared/touch-metrics';
 import { feedbackStore } from './stores/feedback.svelte';
 import { rotatorStore } from './stores/rotator.svelte';
+import { rigStore } from './stores/rig.svelte';
 import { FeedbackEvent } from './feedback/types';
 
 export class App {
@@ -741,6 +742,7 @@ export class App {
     feedbackStore.load();
     feedbackStore.installGlobalListeners();
     rotatorStore.load();
+    rigStore.load();
     beamStore.onTrackingUpdate = (state) => rotatorStore.handleTrackingUpdate(state);
     uiStore.loadPassFilters();
     uiStore.loadMarkerGroups(this.cfg.markerGroups);

src/rig/civ.ts

@@ -0,0 +1,185 @@
+import type { RigDriver, RigConnectOptions } from './protocol';
+import { BinarySerialTransport } from '../serial/transport';
+
+/**
+ * Icom CI-V binary protocol over serial.
+ *
+ * Frame format: [FE FE] [toAddr] [fromAddr] [cmd] [subcmd?] [data...] [FD]
+ * - FE FE = preamble
+ * - toAddr = radio's CI-V address (default 0x94 for IC-7300)
+ * - fromAddr = controller address (always 0xE0)
+ * - FD = end of message
+ *
+ * Frequency is 5 BCD bytes, LSB first (10 digits of Hz).
+ * Response: radio echoes command, then sends reply with FB (ok) or FA (error).
+ *
+ * Common CI-V addresses:
+ *   IC-705  = 0xA4    IC-7300 = 0x94
+ *   IC-9700 = 0xA2    IC-7100 = 0x88
+ *   IC-7610 = 0x98    IC-R8600 = 0x96
+ */
+const PREAMBLE = 0xFE;
+const EOM = 0xFD;
+const CONTROLLER_ADDR = 0xE0;
+const CMD_READ_FREQ = 0x03;
+const CMD_SET_FREQ = 0x05;
+const CMD_SET_MODE = 0x06;
+const ACK = 0xFB;
+const NAK = 0xFA;
+
+/** Encode Hz as 5 BCD bytes, LSB first (Icom CI-V format). */
+function hzToBcd(hz: number): Uint8Array {
+  const s = Math.round(hz).toString().padStart(10, '0');
+  const bcd = new Uint8Array(5);
+  // s = "0145800000" (10 digits) → BCD pairs from right to left
+  for (let i = 0; i < 5; i++) {
+    const hi = parseInt(s[9 - 2 * i - 1], 10);
+    const lo = parseInt(s[9 - 2 * i], 10);
+    bcd[i] = (hi << 4) | lo;
+  }
+  return bcd;
+}
+
+/** Decode 5 BCD bytes (LSB first) to Hz. */
+function bcdToHz(bcd: Uint8Array, offset: number): number {
+  let hz = 0;
+  let mult = 1;
+  for (let i = 0; i < 5; i++) {
+    const b = bcd[offset + i];
+    hz += ((b >> 4) * 10 + (b & 0x0F)) * mult;
+    mult *= 100;
+  }
+  return hz;
+}
+
+const MODE_CODES: Record<string, number> = {
+  LSB: 0x00, USB: 0x01, AM: 0x02, CW: 0x03, FM: 0x05, 'CW-R': 0x07, 'RTTY': 0x04,
+};
+
+export class CivDriver implements RigDriver {
+  readonly name = 'Icom CI-V';
+  private transport = new BinarySerialTransport();
+  private civAddress: number = 0x94;
+
+  get connected() { return this.transport.connected; }
+
+  set onDisconnect(cb: (() => void) | null) { this.transport.onDisconnect = cb; }
+  get onDisconnect() { return this.transport.onDisconnect; }
+
+  isSupported(): boolean {
+    return this.transport.isSupported();
+  }
+
+  async connect(options: RigConnectOptions): Promise<void> {
+    if (options.civAddress !== undefined) this.civAddress = options.civAddress;
+    await this.transport.open(options.baudRate ?? 19200);
+  }
+
+  async disconnect(): Promise<void> {
+    await this.transport.close();
+  }
+
+  async setFrequency(hz: number): Promise<void> {
+    const bcd = hzToBcd(hz);
+    const frame = new Uint8Array([
+      PREAMBLE, PREAMBLE, this.civAddress, CONTROLLER_ADDR,
+      CMD_SET_FREQ, ...bcd, EOM,
+    ]);
+    const response = await this.transport.sendAndReceive(frame, EOM);
+    if (response.length === 0) return;
+    if (this.isEcho(response, frame)) {
+      const ack = await this.readResponse();
+      this.checkAck(ack);
+    } else if (this.isForUs(response)) {
+      this.checkAck(response);
+    } else {
+      // Unsolicited frame — try to read the real response
+      const ack = await this.readResponse();
+      this.checkAck(ack);
+    }
+  }
+
+  async getFrequency(): Promise<number | null> {
+    const frame = new Uint8Array([
+      PREAMBLE, PREAMBLE, this.civAddress, CONTROLLER_ADDR,
+      CMD_READ_FREQ, EOM,
+    ]);
+    const response = await this.transport.sendAndReceive(frame, EOM);
+    if (response.length === 0) return null;
+
+    // Skip echo and unsolicited frames
+    let data = response;
+    if (this.isEcho(response, frame)) {
+      data = await this.readResponse();
+    } else if (!this.isForUs(response)) {
+      data = await this.readResponse();
+    }
+    if (data.length === 0) return null;
+
+    // Response: FE FE E0 <addr> <cmd> <5 BCD bytes> FD
+    const cmdIdx = this.findCmd(data, CMD_READ_FREQ) ?? this.findCmd(data, CMD_SET_FREQ);
+    if (cmdIdx === null || cmdIdx + 6 > data.length) return null;
+    return bcdToHz(data, cmdIdx + 1);
+  }
+
+  async setMode(mode: string): Promise<void> {
+    const code = MODE_CODES[mode.toUpperCase()];
+    if (code === undefined) return;
+    const frame = new Uint8Array([
+      PREAMBLE, PREAMBLE, this.civAddress, CONTROLLER_ADDR,
+      CMD_SET_MODE, code, EOM,  // omit filter byte — radio uses its default
+    ]);
+    const response = await this.transport.sendAndReceive(frame, EOM);
+    if (response.length === 0) return;
+    if (this.isEcho(response, frame)) {
+      const ack = await this.readResponse();
+      this.checkAck(ack);
+    } else if (this.isForUs(response)) {
+      this.checkAck(response);
+    } else {
+      const ack = await this.readResponse();
+      this.checkAck(ack);
+    }
+  }
+
+  /** Check if frame is addressed to us (from radio to controller). */
+  private isForUs(frame: Uint8Array): boolean {
+    return frame.length >= 4
+      && frame[0] === PREAMBLE && frame[1] === PREAMBLE
+      && frame[2] === CONTROLLER_ADDR
+      && frame[3] === this.civAddress;
+  }
+
+  /** Read next frame addressed to us, skipping unsolicited transceive broadcasts. */
+  private async readResponse(): Promise<Uint8Array> {
+    for (let attempt = 0; attempt < 4; attempt++) {
+      const frame = await this.transport.sendAndReceive(new Uint8Array(0), EOM);
+      if (frame.length === 0) return frame;
+      if (this.isForUs(frame)) return frame;
+      // Not for us — unsolicited transceive broadcast, skip and try again
+    }
+    return new Uint8Array(0);
+  }
+
+  private isEcho(response: Uint8Array, sent: Uint8Array): boolean {
+    if (response.length !== sent.length) return false;
+    for (let i = 0; i < sent.length; i++) {
+      if (response[i] !== sent[i]) return false;
+    }
+    return true;
+  }
+
+  private checkAck(frame: Uint8Array): void {
+    if (frame.length === 0) return;
+    for (let i = 0; i < frame.length; i++) {
+      if (frame[i] === NAK) throw new Error('CI-V: command rejected (NAK)');
+    }
+  }
+
+  private findCmd(frame: Uint8Array, cmd: number): number | null {
+    for (let i = 4; i < frame.length; i++) {
+      if (frame[i] === cmd) return i;
+    }
+    return null;
+  }
+}

src/rig/kenwood.ts

@@ -0,0 +1,62 @@
+import type { RigDriver, RigConnectOptions } from './protocol';
+import { SerialTransport } from '../serial/transport';
+
+/**
+ * Kenwood/Elecraft CAT protocol over serial.
+ * Uses `;` as command terminator. 11-digit frequency format.
+ *
+ * Commands:
+ *   FA00145800000;  — set VFO A frequency (11 digits, Hz)
+ *   FA;             — query VFO A frequency
+ *   MD1;            — set mode (1=LSB, 2=USB, 3=CW, 4=FM, 5=AM, 6=FSK, 7=CW-R)
+ */
+const MODE_CODES: Record<string, string> = {
+  LSB: '1', USB: '2', CW: '3', FM: '4', AM: '5', FSK: '6', 'CW-R': '7',
+};
+
+export class KenwoodDriver implements RigDriver {
+  readonly name = 'Kenwood';
+  private transport = new SerialTransport(';');
+
+  get connected() { return this.transport.connected; }
+
+  set onDisconnect(cb: (() => void) | null) { this.transport.onDisconnect = cb; }
+  get onDisconnect() { return this.transport.onDisconnect; }
+
+  isSupported(): boolean {
+    return this.transport.isSupported();
+  }
+
+  async connect(options: RigConnectOptions): Promise<void> {
+    await this.transport.open(options.baudRate ?? 9600);
+    // Disable auto-information mode to prevent unsolicited status messages
+    await this.transport.sendOnly('AI0;');
+  }
+
+  async disconnect(): Promise<void> {
+    await this.transport.close();
+  }
+
+  async setFrequency(hz: number): Promise<void> {
+    const freq = Math.round(hz).toString().padStart(11, '0');
+    await this.transport.sendOnly(`FA${freq};`);
+  }
+
+  async getFrequency(): Promise<number | null> {
+    let response = await this.transport.sendCommand('FA;');
+    // If radio echoes the query back, read the actual response
+    if (response === 'FA') {
+      response = await this.transport.sendCommand('');
+    }
+    const match = response.match(/FA(\d+)/);
+    if (!match) return null;
+    const hz = parseInt(match[1], 10);
+    return isNaN(hz) ? null : hz;
+  }
+
+  async setMode(mode: string): Promise<void> {
+    const code = MODE_CODES[mode.toUpperCase()];
+    if (!code) return;
+    await this.transport.sendOnly(`MD${code};`);
+  }
+}

src/rig/protocol.ts

@@ -0,0 +1,40 @@
+/** Standard radio operating modes sent to rigs via setMode(). */
+export const RADIO_MODES = ['FM', 'USB', 'LSB', 'CW', 'AM'] as const;
+
+/** Map SatNOGS signal mode names to radio operating modes. */
+const SATNOGS_TO_RADIO: Record<string, string> = {
+  FM: 'FM', AFSK: 'FM', APT: 'FM', LRPT: 'FM', NFM: 'FM',
+  USB: 'USB', BPSK: 'USB', SSTV: 'USB', FSK: 'USB', GFSK: 'USB',
+  LSB: 'LSB', CW: 'CW', AM: 'AM',
+};
+
+/** Convert a SatNOGS mode string to a radio mode, or '' if unknown. */
+export function satnogsModeToRadio(satnogsMode: string | null): string {
+  if (!satnogsMode) return '';
+  return SATNOGS_TO_RADIO[satnogsMode.toUpperCase()] ?? '';
+}
+
+/** Connection mode for the rig. */
+export type RigMode = 'serial' | 'network';
+
+/** Serial protocol variants for rig control. */
+export type RigSerialProtocol = 'kenwood' | 'yaesu' | 'yaesu-legacy' | 'civ';
+
+export interface RigConnectOptions {
+  baudRate?: number;
+  wsUrl?: string;
+  civAddress?: number;
+}
+
+/** Abstract interface all rig protocol drivers implement. */
+export interface RigDriver {
+  readonly name: string;
+  readonly connected: boolean;
+  isSupported(): boolean;
+  connect(options: RigConnectOptions): Promise<void>;
+  disconnect(): Promise<void>;
+  setFrequency(hz: number): Promise<void>;
+  getFrequency(): Promise<number | null>;
+  setMode?(mode: string): Promise<void>;
+  onDisconnect: (() => void) | null;
+}