feat: Yaesu control panel (meters, bands, DSP, TX), and drop a stale Flex hint

A console pane for the native Yaesu backend, in the same shape as the Icom and Flex ones: S/PO/SWR meters, band and mode rows, AF/RF/squelch, AGC, the IPO/AMP1/ AMP2 front-end selector, ATT, NB, DNR + level, narrow filter, power in watts, mic gain, VOX, split and ATU tune. Three decisions worth keeping: Panel reads are STAGGERED and live in their own file, away from ReadState. Meters poll every cycle; settings only change when someone turns a knob, so they refresh every 8th cycle and right after any set. Polling all of it every cycle would put twenty queries a second on the serial link the frequency display shares. Band buttons use the rig's own band memory (BS) rather than a frequency we pick, so 20 m lands where the operator last was on 20 m — what the radio's own band keys do. A set is followed by a read-back, so the panel shows what the RIG ended up with, not what we asked for; the two differ whenever a value is out of range or the mode forbids the control. And a control the model lacks keeps its previous value instead of dropping to zero, which reads as a setting that reset itself. The S9 point of the S-meter scale is a hypothesis (the manual does not state it) and is commented as such — one number to correct if reports come out an S unit off, rather than a fudge spread through the RST helper. Also removes the FlexRadio settings blurb, which explained the backend to someone who had already chosen it.
2026-07-29 11:17:08 +02:00
parent e2aba828a9
commit 842d4708a7
12 changed files with 1072 additions and 15 deletions
@@ -73,6 +73,7 @@ import { BandMap } from '@/components/BandMap';
 import { WorldMap, LocatorMap } from '@/components/MainMap';
 import { FlexPanel } from '@/components/FlexPanel';
 import { IcomPanel } from '@/components/IcomPanel';
+import { YaesuPanel } from '@/components/YaesuPanel';
 import { AntGeniusPanel, type AGStatus } from '@/components/AntGeniusPanel';
 import { TunerGeniusPanel, type TGStatus } from '@/components/TunerGeniusPanel';
 import { ScpPanel, type ScpResult } from '@/components/ScpPanel';
@@ -1319,12 +1320,12 @@ export default function App() {
  // map ("map1"), the locator street map ("map2"), the cluster grid or the
  // worked-before grid. Per-profile (stored via SetUIPref → profile-prefixed),
  // so it's loaded async on mount and re-read on profile:changed below.
-  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'netcontrol';
+  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'netcontrol';
  const [mapZoomSignal, setMapZoomSignal] = useState(0); // bump → world map auto-zooms now
  const [mainPaneLeft, setMainPaneLeft] = useState<MainPaneKind>('map1');
  const [mainPaneRight, setMainPaneRight] = useState<MainPaneKind>('map2');
  const loadMainPanes = useCallback(async () => {
-    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'netcontrol';
+    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'netcontrol';
    const [l, r] = await Promise.all([
      GetUIPref('mainPaneLeft').catch(() => ''),
      GetUIPref('mainPaneRight').catch(() => ''),
@@ -4279,6 +4280,12 @@ export default function App() {
              onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
          </div>
        );
+      case 'yaesu':
+        return (
+          <div className="h-full w-full min-h-0 rounded-lg overflow-hidden border border-border">
+            <YaesuPanel onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
+          </div>
+        );
      case 'icom':
        return (
          <div className="h-full w-full min-h-0 rounded-lg overflow-hidden border border-border">
@@ -6074,6 +6081,7 @@ export default function App() {
          onMainPaneChanged={(side, v) => { if (side === 'left') setMainPaneLeft(v as MainPaneKind); else setMainPaneRight(v as MainPaneKind); }}
          flexAvailable={catState.backend === 'flex'}
          icomAvailable={catState.backend === 'icom'}
+          yaesuAvailable={catState.backend === 'yaesu'}
        />
      )}

@@ -156,6 +156,7 @@ interface Props {
  onMainPaneChanged?: (side: 'left' | 'right', value: string) => void; // live Main-view layout update
  flexAvailable?: boolean; // CAT backend is FlexRadio → offer it as a Main pane
  icomAvailable?: boolean; // CAT backend is Icom → offer the Icom console as a Main pane
+  yaesuAvailable?: boolean; // CAT backend is Yaesu → offer the Yaesu console as a Main pane
 }

 // Pretty little card showing what OpsLog will stamp on each QSO based on
@@ -817,7 +818,7 @@ function RelayAutoPanel() {
 // cluster grid or the worked-before grid. Per-profile (stored via SetUIPref,
 // which is profile-prefixed). Self-contained so it owns its async-loaded state.
 const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol'];
-function MainViewPanes({ onChanged, flexAvailable, icomAvailable }: { onChanged?: (side: 'left' | 'right', value: string) => void; flexAvailable?: boolean; icomAvailable?: boolean }) {
+function MainViewPanes({ onChanged, flexAvailable, icomAvailable, yaesuAvailable }: { onChanged?: (side: 'left' | 'right', value: string) => void; flexAvailable?: boolean; icomAvailable?: boolean; yaesuAvailable?: boolean }) {
  const { t } = useI18n();
  const [left, setLeft] = useState('map1');
  const [right, setRight] = useState('map2');
@@ -826,10 +827,11 @@ function MainViewPanes({ onChanged, flexAvailable, icomAvailable }: { onChanged?
    ...MAIN_PANE_VALUES,
    ...(flexAvailable ? ['flex'] : []),
    ...(icomAvailable ? ['icom'] : []),
+    ...(yaesuAvailable ? ['yaesu'] : []),
  ].map((value) => ({ value, label: t(`settings.pane.${value}`) }))
    .sort((a, b) => a.label.localeCompare(b.label));
  useEffect(() => {
-    const valid = (v: string) => v === 'flex' || v === 'icom' || MAIN_PANE_VALUES.includes(v);
+    const valid = (v: string) => v === 'flex' || v === 'icom' || v === 'yaesu' || MAIN_PANE_VALUES.includes(v);
    Promise.all([GetUIPref('mainPaneLeft').catch(() => ''), GetUIPref('mainPaneRight').catch(() => '')])
      .then(([l, r]) => { if (valid(l)) setLeft(l); if (valid(r)) setRight(r); });
  }, []);
@@ -1024,7 +1026,7 @@ const ICOM_MODELS: { name: string; addr: number }[] = [
  { name: 'IC-9700', addr: 0xA2 },
 ];

-export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChanged, flexAvailable, icomAvailable }: Props) {
+export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChanged, flexAvailable, icomAvailable, yaesuAvailable }: Props) {
  const { t } = useI18n();
  const [selected, setSelected] = useState<SectionId>((initialSection as SectionId) || 'station');
  const [loading, setLoading] = useState(true);
@@ -2664,11 +2666,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
          </p>
          </>
          )}
-          {catCfg.backend === 'flex' && (
-            <p className="text-xs text-muted-foreground">
-              {t('cat.flexHint')}
-            </p>
-          )}
        </div>
      </>
    );
@@ -5133,7 +5130,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
          </label>
          <TelemetryToggle />

-          <MainViewPanes onChanged={onMainPaneChanged} flexAvailable={flexAvailable} icomAvailable={icomAvailable} />
+          <MainViewPanes onChanged={onMainPaneChanged} flexAvailable={flexAvailable} icomAvailable={icomAvailable} yaesuAvailable={yaesuAvailable} />

          <div className="border-t border-border/60 pt-4 space-y-2">
            <h4 className="text-sm font-semibold text-foreground">{t('gen.pwEnc')}</h4>
@@ -0,0 +1,367 @@
+import { useEffect, useRef, useState } from 'react';
+import { Radio, AudioLines, Mic, Activity, SlidersHorizontal, Antenna } from 'lucide-react';
+import {
+  GetYaesuState, RefreshYaesuPanel,
+  SetYaesuPower, SetYaesuMicGain, SetYaesuAFGain, SetYaesuRFGain, SetYaesuSquelch,
+  SetYaesuAGC, SetYaesuPreamp, SetYaesuAtt, SetYaesuNB, SetYaesuNR, SetYaesuNRLevel,
+  SetYaesuNarrow, SetYaesuVOX, SetYaesuSplit, SetYaesuBand, TuneYaesuATU,
+  GetCATState, SetCATMode,
+} from '../../wailsjs/go/main/App';
+import { cn } from '@/lib/utils';
+import { useI18n } from '@/lib/i18n';
+import { sMeterRST } from '@/lib/rst';
+
+type YaesuState = {
+  available: boolean; model?: string; mode?: string;
+  transmitting: boolean; split: boolean;
+  s_meter: number; power_meter: number; swr_meter: number;
+  rf_power: number; mic_gain: number; af_gain: number; rf_gain: number; squelch: number;
+  agc?: string; preamp: number; att: number;
+  nb: boolean; nr: boolean; nr_level: number; narrow: boolean; vox: boolean;
+};
+
+const ZERO: YaesuState = {
+  available: false, transmitting: false, split: false,
+  s_meter: 0, power_meter: 0, swr_meter: 0,
+  rf_power: 0, mic_gain: 0, af_gain: 0, rf_gain: 0, squelch: 0,
+  preamp: 0, att: 0, nb: false, nr: false, nr_level: 0, narrow: false, vox: false,
+};
+
+// Band buttons use the rig's OWN band memory (CAT "BS"), not a frequency we
+// choose: pressing 20 m lands where the operator last was on 20 m, which is what
+// the radio's own band keys do. That is why these are band names, not Hz.
+const BANDS = ['160m', '80m', '40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m'];
+
+const MODES = ['SSB', 'CW', 'RTTY', 'FT8', 'AM', 'FM'];
+
+// The FTDX10/FTDX101 preamp is a three-way front-end selector, not an on/off:
+// IPO bypasses the preamp entirely (best on a quiet, high-signal band), AMP1 and
+// AMP2 add gain. Presenting it as a toggle would hide the middle position.
+const PREAMPS = [{ v: '0', l: 'IPO' }, { v: '1', l: 'AMP1' }, { v: '2', l: 'AMP2' }];
+const AGCS = [{ v: 'FAST', l: 'FAST' }, { v: 'MID', l: 'MID' }, { v: 'SLOW', l: 'SLOW' }, { v: 'AUTO', l: 'AUTO' }];
+
+function fmtVFO(hz?: number): string {
+  if (!hz || hz <= 0) return '––.–––.––';
+  const mhz = Math.floor(hz / 1_000_000);
+  const khz = Math.floor((hz % 1_000_000) / 1000);
+  const h2 = Math.floor((hz % 1000) / 10);
+  return `${mhz}.${String(khz).padStart(3, '0')}.${String(h2).padStart(2, '0')}`;
+}
+
+function bandOfHz(hz?: number): string {
+  if (!hz || hz <= 0) return '';
+  const mhz = hz / 1_000_000;
+  const bands: [string, number, number][] = [
+    ['160m', 1.8, 2.0], ['80m', 3.5, 4.0], ['60m', 5.25, 5.45], ['40m', 7.0, 7.3],
+    ['30m', 10.1, 10.15], ['20m', 14.0, 14.35], ['17m', 18.068, 18.168],
+    ['15m', 21.0, 21.45], ['12m', 24.89, 24.99], ['10m', 28.0, 29.7], ['6m', 50.0, 54.0],
+  ];
+  for (const [name, lo, hi] of bands) if (mhz >= lo && mhz <= hi) return name;
+  return '';
+}
+
+function modeMatches(btn: string, cur?: string): boolean {
+  if (!cur) return false;
+  if (btn === 'SSB') return cur === 'SSB' || cur === 'USB' || cur === 'LSB';
+  if (btn === 'FT8') return cur === 'FT8' || cur === 'FT4' || cur === 'DATA';
+  return btn === cur;
+}
+
+
+// Split the 0-100 S-meter reading into S units + dB over S9.
+//
+// The FTDX10 answers SM0 on a 0-255 scale and its manual does not say where S9
+// falls; the front panel puts it at roughly half travel, which is the 50 used
+// here. That figure is a HYPOTHESIS — if reports come out consistently one S
+// unit off on a radio, this is the number to correct, not the RST helper.
+function sParts(v: number): { s: number; over: number; label: string } {
+  if (v >= 50) {
+    const over = Math.max(0, Math.round((v - 50) * 60 / 50));
+    return { s: 9, over, label: over > 0 ? `S9+${over}` : 'S9' };
+  }
+  const s = Math.max(0, Math.min(9, Math.round(v / 5.5)));
+  return { s, over: 0, label: `S${s}` };
+}
+
+function Slider({ value, onChange, disabled, accent = '#2563eb' }: {
+  value: number; onChange: (v: number) => void; disabled?: boolean; accent?: string;
+}) {
+  const v = Math.max(0, Math.min(100, value));
+  const ref = useRef<HTMLInputElement>(null);
+  // React's onWheel is passive, so preventDefault is ignored there — attach a
+  // native non-passive listener, and read live values through refs so the
+  // handler never closes over a stale value.
+  const valRef = useRef(value); valRef.current = value;
+  const cbRef = useRef(onChange); cbRef.current = onChange;
+  const disRef = useRef(disabled); disRef.current = disabled;
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const onWheel = (e: WheelEvent) => {
+      if (disRef.current) return;
+      e.preventDefault();
+      const nv = Math.max(0, Math.min(100, valRef.current + (e.deltaY < 0 ? 1 : -1)));
+      if (nv !== valRef.current) cbRef.current(nv);
+    };
+    el.addEventListener('wheel', onWheel, { passive: false });
+    return () => el.removeEventListener('wheel', onWheel);
+  }, []);
+  return (
+    <input
+      ref={ref}
+      type="range" min={0} max={100} value={v} disabled={disabled}
+      onChange={(e) => onChange(parseInt(e.target.value, 10))}
+      className={cn('flex-1 h-1.5 rounded-full appearance-none cursor-pointer disabled:opacity-30 disabled:cursor-default',
+        '[&::-webkit-slider-thumb]:appearance-none [&::-webkit-slider-thumb]:size-3.5 [&::-webkit-slider-thumb]:rounded-full',
+        '[&::-webkit-slider-thumb]:bg-card [&::-webkit-slider-thumb]:border-2 [&::-webkit-slider-thumb]:shadow-sm')}
+      style={{ background: `linear-gradient(to right, ${accent} ${v}%, var(--muted))`, borderColor: accent }}
+    />
+  );
+}
+
+function Segmented({ value, options, onChange }: {
+  value: string; options: { v: string; l: string }[]; onChange: (v: string) => void;
+}) {
+  return (
+    <div className="inline-flex rounded-md border border-border overflow-hidden shrink-0">
+      {options.map((o) => (
+        <button key={o.v} type="button" onClick={() => onChange(o.v)}
+          className={cn('px-2 py-1 text-[11px] font-bold tracking-wide transition-colors border-l border-border first:border-l-0',
+            value === o.v ? 'bg-primary text-primary-foreground' : 'bg-card text-muted-foreground hover:bg-muted')}>
+          {o.l}
+        </button>
+      ))}
+    </div>
+  );
+}
+
+function Chip({ on, onClick, label, title }: { on: boolean; onClick: () => void; label: string; title?: string }) {
+  return (
+    <button type="button" onClick={onClick} title={title}
+      className={cn('shrink-0 px-2 py-1 rounded-md text-[11px] font-bold border transition-colors',
+        on ? 'bg-success border-success text-success-foreground' : 'bg-card text-muted-foreground border-border hover:bg-muted')}>
+      {label}
+    </button>
+  );
+}
+
+function Card({ icon: Icon, title, accent, children }: { icon: any; title: string; accent?: string; children: React.ReactNode }) {
+  return (
+    <div className="rounded-xl border border-border bg-card shadow-sm overflow-hidden">
+      <div className="flex items-center gap-2 px-3 py-2 border-b border-border/60 bg-muted/30">
+        <Icon className="size-4" style={{ color: accent ?? 'var(--primary)' }} />
+        <span className="text-xs font-bold uppercase tracking-wider text-foreground/80">{title}</span>
+      </div>
+      <div className="p-3 space-y-3">{children}</div>
+    </div>
+  );
+}
+
+function Row({ label, children }: { label: string; children: React.ReactNode }) {
+  return (
+    <div className="flex items-center gap-2">
+      <span className="w-16 shrink-0 text-[11px] font-bold uppercase tracking-wider text-muted-foreground">{label}</span>
+      {children}
+    </div>
+  );
+}
+
+function Meter({ label, value, accent, onClick, title }: {
+  label: string; value: number; accent: string; onClick?: () => void; title?: string;
+}) {
+  const v = Math.max(0, Math.min(100, value));
+  const body = (
+    <>
+      <span className="w-9 shrink-0 text-[11px] font-bold uppercase tracking-wider text-muted-foreground">{label}</span>
+      <div className="flex-1 h-2.5 rounded-full bg-muted/60 overflow-hidden">
+        <div className="h-full rounded-full transition-[width] duration-150" style={{ width: `${v}%`, background: accent }} />
+      </div>
+      <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{v}</span>
+    </>
+  );
+  if (onClick) {
+    return <button type="button" onClick={onClick} title={title} className="flex items-center gap-2 w-full hover:opacity-80">{body}</button>;
+  }
+  return <div className="flex items-center gap-2">{body}</div>;
+}
+
+export function YaesuPanel({ onReportRST }: { onReportRST?: (rst: string) => void }) {
+  const { t } = useI18n();
+  const [st, setSt] = useState<YaesuState>(ZERO);
+  const [freqHz, setFreqHz] = useState(0);
+  const [err, setErr] = useState('');
+
+  // Optimistic local values for the sliders. Without them a drag fights the
+  // poll: the rig's older reading arrives mid-gesture and yanks the thumb back.
+  const [local, setLocal] = useState<Partial<YaesuState>>({});
+  const localAtRef = useRef(0);
+
+  useEffect(() => {
+    let alive = true;
+    const tick = async () => {
+      try {
+        const s = (await GetYaesuState()) as YaesuState;
+        const c = await GetCATState();
+        if (!alive) return;
+        setSt(s);
+        setFreqHz((c as any)?.freq_hz ?? 0);
+        // Drop the optimistic overlay once the rig has had time to answer with
+        // the new value — 1.2 s covers the slow-beat settings read.
+        if (Date.now() - localAtRef.current > 1200) setLocal({});
+        setErr('');
+      } catch (e: any) {
+        if (alive) setErr(String(e?.message ?? e));
+      }
+    };
+    tick();
+    const id = window.setInterval(tick, 400);
+    return () => { alive = false; window.clearInterval(id); };
+  }, []);
+
+  const view = { ...st, ...local };
+
+  // Every setter follows the same shape: show the value at once, remember when,
+  // and let the poll take over. A rejected command surfaces as an error rather
+  // than as a control that silently springs back.
+  function push<K extends keyof YaesuState>(key: K, value: YaesuState[K], fn: () => Promise<void>) {
+    setLocal((l) => ({ ...l, [key]: value }));
+    localAtRef.current = Date.now();
+    fn().catch((e) => setErr(String(e?.message ?? e)));
+  }
+
+  const band = bandOfHz(freqHz);
+
+  if (!st.available) {
+    return (
+      <div className="h-full w-full flex items-center justify-center p-6 text-center">
+        <div className="space-y-1">
+          <Radio className="size-8 mx-auto text-muted-foreground/50" />
+          <p className="text-sm text-muted-foreground">{t('yaesu.notConnected')}</p>
+          {err && <p className="text-xs text-destructive">{err}</p>}
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="h-full w-full overflow-auto p-3 space-y-3">
+      {/* VFO + status */}
+      <div className="rounded-xl border border-border bg-card shadow-sm px-4 py-3 flex items-center justify-between gap-3 flex-wrap">
+        <div>
+          <div className="text-[10px] font-bold uppercase tracking-wider text-muted-foreground">{st.model || 'Yaesu'}</div>
+          <div className="text-2xl font-mono tabular-nums font-bold">{fmtVFO(freqHz)}</div>
+        </div>
+        <div className="flex items-center gap-2">
+          {st.transmitting && (
+            <span className="px-2 py-1 rounded-md text-[11px] font-bold bg-destructive text-destructive-foreground">TX</span>
+          )}
+          <Chip on={view.split} onClick={() => push('split', !view.split, () => SetYaesuSplit(!view.split))} label="SPLIT" />
+          <button type="button" onClick={() => TuneYaesuATU().catch((e) => setErr(String(e?.message ?? e)))}
+            title={t('yaesu.tuneHint')}
+            className="px-2 py-1 rounded-md text-[11px] font-bold border border-border bg-card text-muted-foreground hover:bg-muted">
+            TUNE
+          </button>
+        </div>
+      </div>
+
+      {err && <p className="text-xs text-destructive px-1">{err}</p>}
+
+      {/* Meters */}
+      <Card icon={Activity} title={t('yaesu.meters')}>
+        <Meter label="S" value={view.s_meter} accent="var(--chart-1, #2563eb)"
+          onClick={onReportRST ? () => { const sp = sParts(view.s_meter); onReportRST(sMeterRST(sp.s, sp.over, view.mode)); } : undefined}
+          title={t('yaesu.sToRst')} />
+        <Meter label="PO" value={view.power_meter} accent="var(--success, #16a34a)" />
+        <Meter label="SWR" value={view.swr_meter} accent="var(--warning, #d97706)" />
+      </Card>
+
+      {/* Bands + modes */}
+      <Card icon={Antenna} title={t('yaesu.bandMode')}>
+        <div className="flex flex-wrap gap-1">
+          {BANDS.map((b) => (
+            <button key={b} type="button"
+              onClick={() => SetYaesuBand(b).catch((e) => setErr(String(e?.message ?? e)))}
+              className={cn('px-2 py-1 rounded-md text-[11px] font-bold border transition-colors',
+                band === b ? 'bg-primary border-primary text-primary-foreground' : 'bg-card text-muted-foreground border-border hover:bg-muted')}>
+              {b.replace('m', '')}
+            </button>
+          ))}
+        </div>
+        <div className="flex flex-wrap gap-1">
+          {MODES.map((m) => (
+            <button key={m} type="button"
+              onClick={() => SetCATMode(m).catch((e) => setErr(String(e?.message ?? e)))}
+              className={cn('px-2 py-1 rounded-md text-[11px] font-bold border transition-colors',
+                modeMatches(m, view.mode) ? 'bg-primary border-primary text-primary-foreground' : 'bg-card text-muted-foreground border-border hover:bg-muted')}>
+              {m}
+            </button>
+          ))}
+        </div>
+      </Card>
+
+      {/* Receive */}
+      <Card icon={AudioLines} title={t('yaesu.receive')}>
+        <Row label="AF">
+          <Slider value={view.af_gain} onChange={(v) => push('af_gain', v, () => SetYaesuAFGain(v))} />
+          <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.af_gain}</span>
+        </Row>
+        <Row label="RF">
+          <Slider value={view.rf_gain} onChange={(v) => push('rf_gain', v, () => SetYaesuRFGain(v))} />
+          <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.rf_gain}</span>
+        </Row>
+        <Row label="SQL">
+          <Slider value={view.squelch} onChange={(v) => push('squelch', v, () => SetYaesuSquelch(v))} />
+          <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.squelch}</span>
+        </Row>
+        <Row label="AGC">
+          <Segmented value={view.agc ?? 'AUTO'} options={AGCS} onChange={(v) => push('agc', v, () => SetYaesuAGC(v))} />
+        </Row>
+        <Row label="FRONT">
+          <Segmented value={String(view.preamp)} options={PREAMPS} onChange={(v) => push('preamp', parseInt(v, 10), () => SetYaesuPreamp(parseInt(v, 10)))} />
+          <Chip on={view.att > 0} onClick={() => push('att', view.att > 0 ? 0 : 12, () => SetYaesuAtt(view.att > 0 ? 0 : 12))} label="ATT" />
+        </Row>
+      </Card>
+
+      {/* Noise + filter */}
+      <Card icon={SlidersHorizontal} title={t('yaesu.noiseFilter')}>
+        <div className="flex items-center gap-2 flex-wrap">
+          <Chip on={view.nb} onClick={() => push('nb', !view.nb, () => SetYaesuNB(!view.nb))} label="NB" />
+          <Chip on={view.nr} onClick={() => push('nr', !view.nr, () => SetYaesuNR(!view.nr))} label="DNR" />
+          <Chip on={view.narrow} onClick={() => push('narrow', !view.narrow, () => SetYaesuNarrow(!view.narrow))} label="NAR" />
+        </div>
+        <Row label="DNR">
+          {/* 1-15 on the rig, shown as-is rather than rescaled to a percentage:
+              the radio's own display counts 1-15, and matching it is what makes
+              the panel readable next to the front panel. */}
+          <input type="range" min={1} max={15} value={view.nr_level || 1} disabled={!view.nr}
+            onChange={(e) => { const v = parseInt(e.target.value, 10); push('nr_level', v, () => SetYaesuNRLevel(v)); }}
+            className="flex-1 h-1.5 rounded-full appearance-none cursor-pointer disabled:opacity-30 accent-primary" />
+          <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.nr_level || 1}</span>
+        </Row>
+      </Card>
+
+      {/* Transmit */}
+      <Card icon={Mic} title={t('yaesu.transmit')}>
+        <Row label="PWR">
+          {/* Watts, not a percentage: the rig reports and takes watts, and a
+              percentage would be a second unit to reconcile every time. */}
+          <input type="range" min={5} max={100} value={view.rf_power || 5}
+            onChange={(e) => { const v = parseInt(e.target.value, 10); push('rf_power', v, () => SetYaesuPower(v)); }}
+            className="flex-1 h-1.5 rounded-full appearance-none cursor-pointer accent-primary" />
+          <span className="w-10 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.rf_power}W</span>
+        </Row>
+        <Row label="MIC">
+          <Slider value={view.mic_gain} onChange={(v) => push('mic_gain', v, () => SetYaesuMicGain(v))} />
+          <span className="w-8 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.mic_gain}</span>
+        </Row>
+        <Row label="VOX">
+          <Chip on={view.vox} onClick={() => push('vox', !view.vox, () => SetYaesuVOX(!view.vox))} label="VOX" />
+          <button type="button" onClick={() => RefreshYaesuPanel().catch((e) => setErr(String(e?.message ?? e)))}
+            className="ml-auto px-2 py-1 rounded-md text-[11px] font-bold border border-border bg-card text-muted-foreground hover:bg-muted">
+            {t('yaesu.refresh')}
+          </button>
+        </Row>
+      </Card>
+    </div>
+  );
+}
@@ -106,7 +106,7 @@ const en: Dict = {
  'settings.pane.map1': 'Map — great-circle + beam', 'settings.pane.map2': 'Map — locator (street)',
  'settings.pane.cluster': 'Cluster spots', 'settings.pane.worked': 'Worked before',
  'settings.pane.recent': 'Recent QSOs', 'settings.pane.netcontrol': 'Net control',
-  'settings.pane.flex': 'FlexRadio controls', 'settings.pane.icom': 'Icom console',
+  'settings.pane.flex': 'FlexRadio controls', 'settings.pane.icom': 'Icom console', 'settings.pane.yaesu': 'Yaesu console', 'yaesu.notConnected': 'Yaesu CAT not connected', 'yaesu.meters': 'Meters', 'yaesu.bandMode': 'Band & mode', 'yaesu.receive': 'Receive', 'yaesu.noiseFilter': 'Noise & filter', 'yaesu.transmit': 'Transmit', 'yaesu.refresh': 'Refresh', 'yaesu.tuneHint': 'Start an antenna-tuner cycle', 'yaesu.sToRst': 'Click to fill the RST sent',
  'theme.auto': 'Auto (system)', 'theme.light-warm': 'Warm light', 'theme.light-cool': 'Cool light',
  'theme.light-sage': 'Sage light', 'theme.dim-slate': 'Dim slate', 'theme.dark-warm': 'Warm dark',
  'theme.dark-graphite': 'Graphite dark', 'theme.high-contrast': 'High contrast',
@@ -287,7 +287,6 @@ const en: Dict = {
  'cat.tciHost': 'TCI host', 'cat.tciHint': 'Enable the TCI server in ExpertSDR2/EESDR (Options → TCI). Default port 40001. Use 127.0.0.1 when OpsLog runs on the same PC.', 'cat.tciSpots': 'Show cluster spots on the panorama', 'cat.tciSpotsHint': "(spots from OpsLog's DX cluster appear on the SDR panadapter)",
  'cat.pollMs': 'Poll interval (ms)', 'cat.delayMs': 'CAT delay (ms)', 'cat.digitalDefault': 'Default digital mode (when rig reports DIG)', 'cat.modeBeforeFreq': 'Set mode before frequency', 'cat.modeBeforeFreqHint': '(older rigs that drop the mode after a band change)',
  'cat.omnirigHint': 'Configure your rig (COM port, baud rate, model) in OmniRig\'s own settings GUI first. OpsLog will read whichever Rig slot you select here. Set CAT delay above 0 if your rig drops commands sent back-to-back (some older Kenwood/Yaesu). OmniRig only reports generic "DIG" for digital modes — Default digital mode is the specific mode OpsLog will surface (and log).',
-  'cat.flexHint': 'Native SmartSDR API — no OmniRig needed. Frequency, mode and split are read in real time from the radio (no polling, no second-click mode bug). Use Detect radios or enter the IP. Default digital mode is what OpsLog logs when the slice is in a digital mode (DIGU/DIGL).',
  'cat.rotatorOk': "Packet sent — antenna should swing to 0° (north). If it didn't, check PstRotator host/port and that PstRotator's UDP listener is enabled.",
  'cat.ubOk': 'Connected — the antenna responded with a status frame.',
  // External services (repeated labels)
@@ -519,7 +518,7 @@ const fr: Dict = {
  'settings.pane.map1': 'Carte — orthodromie + faisceau', 'settings.pane.map2': 'Carte — locator (rue)',
  'settings.pane.cluster': 'Spots cluster', 'settings.pane.worked': 'Déjà contactés',
  'settings.pane.recent': 'QSO récents', 'settings.pane.netcontrol': 'Gestion de net',
-  'settings.pane.flex': 'Contrôles FlexRadio', 'settings.pane.icom': 'Console Icom',
+  'settings.pane.flex': 'Contrôles FlexRadio', 'settings.pane.icom': 'Console Icom', 'settings.pane.yaesu': 'Console Yaesu', 'yaesu.notConnected': 'CAT Yaesu non connecté', 'yaesu.meters': 'Mesures', 'yaesu.bandMode': 'Bande et mode', 'yaesu.receive': 'Réception', 'yaesu.noiseFilter': 'Bruit et filtre', 'yaesu.transmit': 'Émission', 'yaesu.refresh': 'Actualiser', 'yaesu.tuneHint': "Lancer un cycle d'accord d'antenne", 'yaesu.sToRst': 'Cliquer pour remplir le RST envoyé',
  'theme.auto': 'Auto (système)', 'theme.light-warm': 'Clair chaud', 'theme.light-cool': 'Clair froid',
  'theme.light-sage': 'Clair sauge', 'theme.dim-slate': 'Ardoise tamisé', 'theme.dark-warm': 'Sombre chaud',
  'theme.dark-graphite': 'Sombre graphite', 'theme.high-contrast': 'Contraste élevé',
@@ -689,7 +688,6 @@ const fr: Dict = {
  'cat.tciHost': 'Hôte TCI', 'cat.tciHint': 'Active le serveur TCI dans ExpertSDR2/EESDR (Options → TCI). Port par défaut 40001. Utilise 127.0.0.1 si OpsLog tourne sur le même PC.', 'cat.tciSpots': 'Afficher les spots cluster sur le panorama', 'cat.tciSpotsHint': "(les spots du cluster DX d'OpsLog apparaissent sur le panadapter SDR)",
  'cat.pollMs': 'Intervalle de poll (ms)', 'cat.delayMs': 'Délai CAT (ms)', 'cat.digitalDefault': 'Mode numérique par défaut (quand le poste indique DIG)', 'cat.modeBeforeFreq': 'Régler le mode avant la fréquence', 'cat.modeBeforeFreqHint': '(anciens postes qui perdent le mode après un changement de bande)',
  'cat.omnirigHint': "Configure d'abord ton poste (port COM, débit, modèle) dans l'interface de réglages d'OmniRig. OpsLog lira le slot Rig que tu choisis ici. Mets le délai CAT au-dessus de 0 si ton poste perd des commandes envoyées coup sur coup (certains anciens Kenwood/Yaesu). OmniRig ne rapporte qu'un « DIG » générique pour les modes numériques — le mode numérique par défaut est le mode précis qu'OpsLog affichera (et loggera).",
-  'cat.flexHint': "API SmartSDR native — pas besoin d'OmniRig. Fréquence, mode et split sont lus en temps réel depuis la radio (sans poll, sans le bug du mode au 2ᵉ clic). Utilise Détecter les radios ou saisis l'IP. Le mode numérique par défaut est ce qu'OpsLog logge quand la slice est en mode numérique (DIGU/DIGL).",
  'cat.rotatorOk': "Paquet envoyé — l'antenne devrait tourner vers 0° (nord). Sinon, vérifie l'hôte/port PstRotator et que l'écouteur UDP de PstRotator est activé.",
  'cat.ubOk': "Connecté — l'antenne a répondu avec une trame de statut.",
  'es.autoUpload': 'Envoi automatique à chaque nouveau QSO', 'es.uploadTiming': "Moment de l'envoi", 'es.immediate': 'Immédiat', 'es.delayed': 'Différé (1–2 min, permet de corriger les erreurs)', 'es.onClose': "À la fermeture (par lot)", 'es.testConn': 'Tester la connexion', 'es.testing': 'Test…', 'es.password': 'Mot de passe', 'es.showPass': 'Afficher le mot de passe', 'es.hidePass': 'Masquer le mot de passe', 'es.apiKey': 'Clé API', 'es.cloudlogUrl': "Adresse de l'instance", 'es.cloudlogUrlPh': 'https://log.exemple.fr', 'es.cloudlogStationId': 'ID de station', 'es.cloudlogKeyPh': 'clé API lecture/écriture', 'es.cloudlogHint': "Cloudlog et Wavelog sont auto-hébergés : indiquez l'adresse de VOTRE instance (une IP convient en réseau local). La clé API se crée dans Compte → API Keys et doit être en lecture/écriture ; l'ID de station est le numéro de l'emplacement sous lequel les QSO sont classés (page Station Locations). Les doublons sont refusés par le serveur, renvoyer un QSO est donc sans risque.", 'es.forceCall': "Forcer l'indicatif de station", 'es.accountEmail': 'E-mail du compte', 'es.logbookCall': 'Indicatif du carnet',
@@ -499,6 +499,8 @@ export function GetWinkeyerSettings():Promise<main.WinkeyerSettings>;

 export function GetWinkeyerStatus():Promise<winkeyer.Status>;

+export function GetYaesuState():Promise<cat.YaesuTXState>;
+
 export function HasBuiltinReferences(arg1:string):Promise<boolean>;

 export function IcomRefresh():Promise<void>;
@@ -755,6 +757,8 @@ export function RefreshCtyDat():Promise<main.CtyDatInfo>;

 export function RefreshSolar():Promise<void>;

+export function RefreshYaesuPanel():Promise<void>;
+
 export function ReloadUDPIntegrations():Promise<Array<string>>;

 export function RemovePassphrase(arg1:string):Promise<void>;
@@ -911,6 +915,36 @@ export function SetUltrabeamDirection(arg1:number):Promise<void>;

 export function SetWinkeyerTrace(arg1:boolean):Promise<void>;

+export function SetYaesuAFGain(arg1:number):Promise<void>;
+
+export function SetYaesuAGC(arg1:string):Promise<void>;
+
+export function SetYaesuAtt(arg1:number):Promise<void>;
+
+export function SetYaesuBand(arg1:string):Promise<void>;
+
+export function SetYaesuMicGain(arg1:number):Promise<void>;
+
+export function SetYaesuNB(arg1:boolean):Promise<void>;
+
+export function SetYaesuNR(arg1:boolean):Promise<void>;
+
+export function SetYaesuNRLevel(arg1:number):Promise<void>;
+
+export function SetYaesuNarrow(arg1:boolean):Promise<void>;
+
+export function SetYaesuPower(arg1:number):Promise<void>;
+
+export function SetYaesuPreamp(arg1:number):Promise<void>;
+
+export function SetYaesuRFGain(arg1:number):Promise<void>;
+
+export function SetYaesuSplit(arg1:boolean):Promise<void>;
+
+export function SetYaesuSquelch(arg1:number):Promise<void>;
+
+export function SetYaesuVOX(arg1:boolean):Promise<void>;
+
 export function StartCWDecoder():Promise<void>;

 export function StationSetRelay(arg1:string,arg2:number,arg3:boolean):Promise<void>;
@@ -947,6 +981,8 @@ export function TestStationDevice(arg1:main.StationDevice):Promise<main.StationT

 export function TestUltrabeam(arg1:main.UltrabeamSettings):Promise<void>;

+export function TuneYaesuATU():Promise<void>;
+
 export function TunerGeniusActivate(arg1:number):Promise<void>;

 export function TunerGeniusAutotune():Promise<void>;
@@ -946,6 +946,10 @@ export function GetWinkeyerStatus() {
  return window['go']['main']['App']['GetWinkeyerStatus']();
 }

+export function GetYaesuState() {
+  return window['go']['main']['App']['GetYaesuState']();
+}
+
 export function HasBuiltinReferences(arg1) {
  return window['go']['main']['App']['HasBuiltinReferences'](arg1);
 }
@@ -1458,6 +1462,10 @@ export function RefreshSolar() {
  return window['go']['main']['App']['RefreshSolar']();
 }

+export function RefreshYaesuPanel() {
+  return window['go']['main']['App']['RefreshYaesuPanel']();
+}
+
 export function ReloadUDPIntegrations() {
  return window['go']['main']['App']['ReloadUDPIntegrations']();
 }
@@ -1770,6 +1778,66 @@ export function SetWinkeyerTrace(arg1) {
  return window['go']['main']['App']['SetWinkeyerTrace'](arg1);
 }

+export function SetYaesuAFGain(arg1) {
+  return window['go']['main']['App']['SetYaesuAFGain'](arg1);
+}
+
+export function SetYaesuAGC(arg1) {
+  return window['go']['main']['App']['SetYaesuAGC'](arg1);
+}
+
+export function SetYaesuAtt(arg1) {
+  return window['go']['main']['App']['SetYaesuAtt'](arg1);
+}
+
+export function SetYaesuBand(arg1) {
+  return window['go']['main']['App']['SetYaesuBand'](arg1);
+}
+
+export function SetYaesuMicGain(arg1) {
+  return window['go']['main']['App']['SetYaesuMicGain'](arg1);
+}
+
+export function SetYaesuNB(arg1) {
+  return window['go']['main']['App']['SetYaesuNB'](arg1);
+}
+
+export function SetYaesuNR(arg1) {
+  return window['go']['main']['App']['SetYaesuNR'](arg1);
+}
+
+export function SetYaesuNRLevel(arg1) {
+  return window['go']['main']['App']['SetYaesuNRLevel'](arg1);
+}
+
+export function SetYaesuNarrow(arg1) {
+  return window['go']['main']['App']['SetYaesuNarrow'](arg1);
+}
+
+export function SetYaesuPower(arg1) {
+  return window['go']['main']['App']['SetYaesuPower'](arg1);
+}
+
+export function SetYaesuPreamp(arg1) {
+  return window['go']['main']['App']['SetYaesuPreamp'](arg1);
+}
+
+export function SetYaesuRFGain(arg1) {
+  return window['go']['main']['App']['SetYaesuRFGain'](arg1);
+}
+
+export function SetYaesuSplit(arg1) {
+  return window['go']['main']['App']['SetYaesuSplit'](arg1);
+}
+
+export function SetYaesuSquelch(arg1) {
+  return window['go']['main']['App']['SetYaesuSquelch'](arg1);
+}
+
+export function SetYaesuVOX(arg1) {
+  return window['go']['main']['App']['SetYaesuVOX'](arg1);
+}
+
 export function StartCWDecoder() {
  return window['go']['main']['App']['StartCWDecoder']();
 }
@@ -1842,6 +1910,10 @@ export function TestUltrabeam(arg1) {
  return window['go']['main']['App']['TestUltrabeam'](arg1);
 }

+export function TuneYaesuATU() {
+  return window['go']['main']['App']['TuneYaesuATU']();
+}
+
 export function TunerGeniusActivate(arg1) {
  return window['go']['main']['App']['TunerGeniusActivate'](arg1);
 }
@@ -1074,6 +1074,58 @@ export namespace cat {
 	        this.fixed = source["fixed"];
 	    }
 	}
+	export class YaesuTXState {
+	    available: boolean;
+	    model?: string;
+	    mode?: string;
+	    transmitting: boolean;
+	    split: boolean;
+	    s_meter: number;
+	    power_meter: number;
+	    swr_meter: number;
+	    rf_power: number;
+	    mic_gain: number;
+	    af_gain: number;
+	    rf_gain: number;
+	    squelch: number;
+	    agc?: string;
+	    preamp: number;
+	    att: number;
+	    nb: boolean;
+	    nr: boolean;
+	    nr_level: number;
+	    narrow: boolean;
+	    vox: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new YaesuTXState(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.available = source["available"];
+	        this.model = source["model"];
+	        this.mode = source["mode"];
+	        this.transmitting = source["transmitting"];
+	        this.split = source["split"];
+	        this.s_meter = source["s_meter"];
+	        this.power_meter = source["power_meter"];
+	        this.swr_meter = source["swr_meter"];
+	        this.rf_power = source["rf_power"];
+	        this.mic_gain = source["mic_gain"];
+	        this.af_gain = source["af_gain"];
+	        this.rf_gain = source["rf_gain"];
+	        this.squelch = source["squelch"];
+	        this.agc = source["agc"];
+	        this.preamp = source["preamp"];
+	        this.att = source["att"];
+	        this.nb = source["nb"];
+	        this.nr = source["nr"];
+	        this.nr_level = source["nr_level"];
+	        this.narrow = source["narrow"];
+	        this.vox = source["vox"];
+	    }
+	}

 }