feat: CW through the Yaesu keyer — fifth CW engine

The radio has a keyer and a command to feed it (KY), so an FTDX10 needs no
WinKeyer and no second cable, exactly as the Icom CI-V and Flex CWX engines
already do. The rig keys with its own timing, which is why the spacing is right
where a PC keying a line through USB latency drifts.

Text is filtered to what the keyer can actually send: an unsupported byte does
not produce an error on a Yaesu, it can abort the whole buffer, so the rest of a
macro would vanish silently. It is then fed in 24-character pieces, waiting for
room between them — the rig DROPS what does not fit, again with no error, so a
contest CQ would lose its tail.

STOP is the honest gap. Yaesu documents no buffer-clear, so it drops the
transmitter (TX0) instead: nothing queued reaches the air, which is what Escape
means to an operator. It deliberately does NOT send "KY0;" — a plausible-looking
clear that the rig would read as the CHARACTER zero and transmit.

A test caught a real one on the way: tabs and newlines were dropped as
"unsupported", gluing the words either side together, so a macro written on two
lines went out as CQCQ. Whitespace now becomes a word gap before filtering.

Settings warn when the Yaesu keyer is selected without the Yaesu CAT backend —
otherwise it simply never keys, with nothing on screen saying why.

Send path follows the CAT reference and how Hamlib drives these rigs; NOT yet
verified on the air.

app.go

@@ -15005,3 +15005,24 @@ func (a *App) SetYaesuBreakIn(on bool) error {
 func (a *App) YaesuZeroIn() error {
 	return a.yaesuDo(func(y cat.YaesuController) error { return y.YaesuZeroIn() })
 }
+
+// YaesuSendCW keys a CW message through the Yaesu's own keyer (CAT "KY"), so an
+// FTDX10 needs no WinKeyer and no second cable.
+func (a *App) YaesuSendCW(text string) error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	err := a.cat.YaesuDo(func(y cat.YaesuController) error { return y.SendCW(text) })
+	if err != nil {
+		applog.Printf("yaesu cw: YaesuSendCW(%q) failed: %v", text, err)
+	}
+	return err
+}
+
+// YaesuStopCW aborts the message being sent.
+func (a *App) YaesuStopCW() error {
+	if a.cat == nil {
+		return fmt.Errorf("cat not initialized")
+	}
+	return a.cat.YaesuDo(func(y cat.YaesuController) error { return y.StopCW() })
+}

changelog.json

@@ -4,6 +4,7 @@
     "date": "2026-07-28",
     "en": [
       "Yaesu control panel: with the native Yaesu backend, a console tab and Main-view pane give S/PO/SWR meters, band and mode buttons, AF/RF/squelch, AGC, IPO-AMP1-AMP2, a 6/12/18 dB attenuator, NB, DNR, narrow filter, power, mic gain, VOX, split and ATU tune. CW, RTTY, DIGI and PSK show their sideband — click an active button again to switch it. Pressing SPLIT places the transmit VFO relative to where you are listening — up 1 kHz on CW and data, up 5 kHz on phone — and shows the transmit frequency; +1k and +5k buttons cover the rest.",
+      "CW through the Yaesu keyer: a fifth CW engine sends your macros with the radio own keyer (CAT \"KY\") — no WinKeyer, no second cable. Pick \"Yaesu (rig keyer)\" in Settings → CW keyer, with the Yaesu CAT backend active.",
       "The Yaesu console follows the mode: in CW the microphone gain and VOX disappear and a CW card takes their place with keyer speed, break-in and ZIN (zero-in).",
       "Native Xiegu CAT (G90, X6100, X6200, X5105): a new backend talks CI-V straight to the radio — frequency, mode, split and PTT. Pick \"Xiegu (native CI-V)\" in Settings → CAT. Untested on a radio so far, feedback welcome.",
       "CAT sharing: OpsLog can now serve its rig connection to other programs (Settings → CAT → Share CAT). WSJT-X, JTDX, MSHV or Log4OM connect with rig model \"Hamlib NET rigctl\" at 127.0.0.1:4532 — needed because a native CAT backend holds the radio serial port on its own. Works with every backend, and with both Hamlib command dialects (JTDX names the VFO, MSHV does not).",
@@ -18,6 +19,7 @@
     ],
     "fr": [
       "Panneau de contrôle Yaesu : avec le backend Yaesu natif, un onglet console et un volet de la vue principale offrent les mesures S/PO/ROS, les boutons de bande et de mode, AF/RF/squelch, AGC, IPO-AMP1-AMP2, un atténuateur 6/12/18 dB, NB, DNR, filtre étroit, puissance, gain micro, VOX, split et accord d'antenne. CW, RTTY, DIGI et PSK affichent leur bande latérale — recliquez sur le bouton actif pour en changer. Appuyer sur SPLIT place le VFO d'émission par rapport à votre écoute — +1 kHz en CW et numérique, +5 kHz en phonie — et affiche la fréquence d'émission ; les boutons +1k et +5k couvrent le reste.",
+      "CW par le keyer Yaesu : un cinquième moteur CW envoie vos macros avec le keyer de la radio (CAT « KY ») — sans WinKeyer ni second câble. À choisir dans Réglages → Keyer CW sous « Yaesu (keyer de la radio) », avec le backend CAT Yaesu actif.",
       "La console Yaesu suit le mode : en CW, le gain micro et le VOX disparaissent au profit d'une carte CW avec la vitesse du manipulateur, le break-in et ZIN (zéro-in).",
       "CAT Xiegu natif (G90, X6100, X6200, X5105) : un nouveau backend dialogue en CI-V directement avec la radio — fréquence, mode, split et PTT. À choisir dans Réglages → CAT sous « Xiegu (CI-V natif) ». Pas encore testé sur une radio, retours bienvenus.",
       "Partage du CAT : OpsLog peut désormais servir sa liaison radio aux autres logiciels (Réglages → CAT → Partager le CAT). WSJT-X, JTDX, MSHV ou Log4OM s'y connectent avec le modèle « Hamlib NET rigctl » sur 127.0.0.1:4532 — nécessaire car un backend CAT natif occupe seul le port série. Fonctionne avec tous les backends, et avec les deux dialectes Hamlib (JTDX nomme le VFO, MSHV non).",

frontend/src/App.tsx

@@ -38,7 +38,7 @@ import {
   ListCountries,
   GetWinkeyerSettings, SaveWinkeyerSettings, ListSerialPorts, GetWinkeyerStatus,
   WinkeyerConnect, WinkeyerDisconnect, WinkeyerSend, WinkeyerStop, WinkeyerSetSpeed, WinkeyerBackspace,
-  IcomSendCW, IcomStopCW, IcomSetKeySpeed, IcomSetBreakIn, GetIcomState,
+  IcomSendCW, YaesuSendCW, YaesuStopCW, IcomStopCW, IcomSetKeySpeed, IcomSetBreakIn, GetIcomState,
   FlexSendCW, FlexStopCW, FlexSetKeySpeed, FlexBackspaceCW,
   GetDVKMessages, GetDVKStatus, DVKPlay, DVKStop,
   StartCWDecoder, StopCWDecoder, SetCWDecoderPitch,
@@ -965,7 +965,7 @@ export default function App() {
   // CI-V 0x17 (no extra hardware — sends over the CAT connection). Macros,
   // auto-call and <LOGQSO> are shared; only the transport differs.
   const [wkEngine, setWkEngine] = useState<string>('winkeyer');
-  const cwSource: 'winkeyer' | 'icom' | 'flex' = wkEngine === 'icom' ? 'icom' : wkEngine === 'flex' ? 'flex' : 'winkeyer';
+  const cwSource: 'winkeyer' | 'icom' | 'flex' | 'yaesu' = wkEngine === 'icom' ? 'icom' : wkEngine === 'flex' ? 'flex' : wkEngine === 'yaesu' ? 'yaesu' : 'winkeyer';
   const cwSourceRef = useRef(cwSource);
   useEffect(() => { cwSourceRef.current = cwSource; }, [cwSource]);
   // CW break-in (0=OFF, 1=SEMI, 2=FULL) — must be on for the rig's 0x17 keyer to
@@ -1001,6 +1001,7 @@ export default function App() {
   useEffect(() => {
     const connected = cwSource === 'icom' ? (catState.backend === 'icom' && catState.connected)
       : cwSource === 'flex' ? (catState.backend === 'flex' && catState.connected)
+      : cwSource === 'yaesu' ? (catState.backend === 'yaesu' && catState.connected)
       : wkStatus.connected;
     wkActiveRef.current = wkEnabled && connected;
   }, [wkEnabled, wkStatus.connected, cwSource, catState.backend, catState.connected]);
@@ -2558,7 +2559,7 @@ export default function App() {
         // current WPM, so it scales automatically.
         const keyed = resolved + ' ';
         setWkSent(resolved);
-        const sendFn = cwSourceRef.current === 'flex' ? FlexSendCW : cwSourceRef.current === 'icom' ? IcomSendCW : null;
+        const sendFn = cwSourceRef.current === 'flex' ? FlexSendCW : cwSourceRef.current === 'icom' ? IcomSendCW : cwSourceRef.current === 'yaesu' ? YaesuSendCW : null;
         if (sendFn) await sendFn(keyed).catch((e) => setError(String(e?.message ?? e)));
         else await WinkeyerSend(keyed).catch((e) => setError(String(e?.message ?? e)));
         // Only WAIT for the CW to finish on the FINAL segment — auto-call needs the
@@ -2591,6 +2592,7 @@ export default function App() {
     wkSendGenRef.current++; // cancel any in-flight macro send (and its pending <LOGQSO> log)
     if (cwSourceRef.current === 'icom') IcomStopCW().catch(() => {});
     else if (cwSourceRef.current === 'flex') FlexStopCW().catch(() => {});
+    else if (cwSourceRef.current === 'yaesu') YaesuStopCW().catch(() => {});
     else WinkeyerStop().catch(() => {});
   }
   // runAutoCall sends macro i, waits for the keyer to finish, waits the chosen
@@ -3495,6 +3497,7 @@ export default function App() {
           stopAutoCall();
           wkSendGenRef.current++; // abort an in-flight macro send so a pending <LOGQSO> won't fire
           if (cwSourceRef.current === 'icom') IcomStopCW().catch(() => {});
+          else if (cwSourceRef.current === 'yaesu') YaesuStopCW().catch(() => {});
           else if (cwSourceRef.current === 'flex') FlexStopCW().catch(() => {});
           else WinkeyerStop().catch(() => {});
         }

frontend/src/components/SettingsModal.tsx

@@ -3309,6 +3309,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                   <SelectItem value="winkeyer">{t('wk.engWinkeyer')}</SelectItem>
                   <SelectItem value="serial">{t('wk.engSerial')}</SelectItem>
                   <SelectItem value="icom">{t('wk.engIcom')}</SelectItem>
+                  <SelectItem value="yaesu">{t('wk.engYaesu')}</SelectItem>
                   <SelectItem value="flex">{t('wk.engFlex')}</SelectItem>
                   <SelectItem value="tci" disabled>{t('wk.engTci')}</SelectItem>
                 </SelectContent>
@@ -3324,6 +3325,12 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             </label>
           </div>
 
+          {wk.engine === 'yaesu' && (!catCfg.enabled || catCfg.backend !== 'yaesu') && (
+            <p className="text-xs font-medium text-warning -mt-1 flex items-start gap-1.5">
+              <span aria-hidden>⚠</span>
+              <span>{t('wk.catWarnYaesu', { backend: catCfg.enabled ? (catCfg.backend || 'none') : 'disabled' })}</span>
+            </p>
+          )}
           {wk.engine === 'icom' ? (
             <>
               {(!catCfg.enabled || catCfg.backend !== 'icom') && (

frontend/src/components/WinkeyerPanel.tsx

@@ -26,7 +26,7 @@ interface Props {
   wpm: number;
   macros: WKMacro[];
   sent: string; // text echoed back by the keyer as it transmits
-  source: 'winkeyer' | 'icom' | 'flex';      // CW output engine (chosen in Settings → CW Keyer)
+  source: 'winkeyer' | 'icom' | 'flex' | 'yaesu'; // CW output engine (chosen in Settings → CW Keyer)
   breakIn?: number;                          // Icom CW break-in: 0=OFF, 1=SEMI, 2=FULL
   onSetBreakIn?: (mode: number) => void;
   onSelectPort: (p: string) => void;
@@ -101,16 +101,18 @@ export function WinkeyerPanel({
         <Radio className="size-4 text-primary shrink-0" />
         {/* CW output engine (chosen in Settings → CW Keyer). */}
         <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground shrink-0">
-          {source === 'icom' ? 'Icom CW' : source === 'flex' ? 'Flex CWX' : 'WinKeyer'}
+          {source === 'icom' ? 'Icom CW' : source === 'flex' ? 'Flex CWX' : source === 'yaesu' ? 'Yaesu CW' : 'WinKeyer'}
         </span>
         <span className={cn('size-2 rounded-full', connected ? (status.busy ? 'bg-warning animate-pulse' : 'bg-success') : 'bg-muted-foreground/40')}
           title={connected ? (status.busy ? t('wkp.sending') : t('wkp.connectedV', { version: status.version })) : t('wkp.disconnected')} />
         <div className="flex-1" />
-        {source === 'icom' || source === 'flex' ? (
+        {source === 'icom' || source === 'flex' || source === 'yaesu' ? (
           <span className="text-[11px] font-medium text-muted-foreground">
             {source === 'flex'
               ? (connected ? t('wkp.cwxReady') : t('wkp.cwxOffline'))
-              : (connected ? t('wkp.civReady') : t('wkp.civOffline'))}
+              : source === 'yaesu'
+                ? (connected ? t('wkp.rigReady') : t('wkp.rigOffline'))
+                : (connected ? t('wkp.civReady') : t('wkp.civOffline'))}
           </span>
         ) : !connected ? (
           <>

frontend/src/lib/i18n.tsx

@@ -163,7 +163,7 @@ const en: Dict = {
   'wk.escClears': 'ESC clears the callsign too (otherwise ESC only stops transmission)',
   'wk.esm': 'ESM — Enter Sends Message (CW)',
   'wk.esmHint': 'In CW with the keyer on, Enter fires a macro by QSO stage instead of logging: empty callsign → F1 (CQ); callsign entered → F2 (report) and focus jumps to RST; Enter in RST → F3 (TU), which logs if the macro contains <LOGQSO>.',
-  'wk.engWinkeyer': 'WinKeyer (K1EL, serial)', 'wk.engSerial': 'Serial port (DTR=CW / RTS=PTT)', 'wk.engIcom': 'Icom CI-V (rig keyer)', 'wk.engFlex': 'FlexRadio (CWX)', 'wk.engTci': 'TCI (coming soon)',
+  'wk.engWinkeyer': 'WinKeyer (K1EL, serial)', 'wk.engSerial': 'Serial port (DTR=CW / RTS=PTT)', 'wk.engIcom': 'Icom CI-V (rig keyer)', 'wk.engYaesu': 'Yaesu (rig keyer)', 'wk.catWarnYaesu': 'The Yaesu keyer needs the Yaesu CAT backend — CAT is currently {backend}.', 'wk.engFlex': 'FlexRadio (CWX)', 'wk.engTci': 'TCI (coming soon)',
   'wk.icomNote': "Icom CI-V keys CW through the rig's own keyer over the existing CAT connection (command 0x17) — it reuses the CAT COM port set in Settings → CAT, so there's nothing else to wire up here. Put the rig in CW mode. Weight, ratio, sidetone, paddle mode… are configured on the radio; only the speed is set from here (the rig's KEY SPEED).",
   'wk.flexNote': "FlexRadio keys CW through the radio's CWX keyer over the existing SmartSDR CAT connection — no WinKeyer or SmartCAT needed. It reuses the connection set in Settings → CAT, so there's nothing else to wire up here. Put a slice in CW mode. Only the speed is set from here; weight, sidetone and break-in are configured on the radio (break-in must be on for CW to actually transmit).",
   'wk.catWarnIcom': 'Your CAT backend is set to {backend}. Icom CI-V CW needs the CAT backend set to Icom and connected — change it under Settings → CAT interface, otherwise sending CW will fail.',
@@ -346,7 +346,7 @@ const en: Dict = {
   'adx.introPart1': 'Every ADIF 3.1.7 field not shown in the other tabs. Pick a field to add it, or type a custom/vendor tag (e.g. ', 'adx.introPart2': '). Stored losslessly and exported in the ', 'adx.fullMode': 'full', 'adx.introPart3': ' ADIF mode.', 'adx.addFieldPh': 'Add ADIF field…', 'adx.showDeprecated': 'Show deprecated', 'adx.noExtra': 'No extra ADIF fields. Use the picker above to add one.', 'adx.deprecated': 'deprecated', 'adx.intl': 'intl', 'adx.nonStandard': 'non-standard', 'adx.removeField': 'Remove field',
   // Hardware panels (winkeyer / dvk / antgenius / flex / icom)
   'wkp.sending': 'Sending…', 'wkp.connectedV': 'Connected (v{version})', 'wkp.disconnected': 'Disconnected', 'wkp.comPort': 'COM port', 'wkp.noPorts': 'No ports', 'wkp.refreshPorts': 'Refresh ports', 'wkp.connect': 'Connect', 'wkp.disconnect': 'Disconnect', 'wkp.hide': 'Hide / disable WinKeyer',
-  'wkp.sourceHint': 'CW output: WK = WinKeyer hardware · CI-V = the Icom rig’s own keyer (over CAT, no extra hardware)', 'wkp.civReady': 'Icom CI-V ready', 'wkp.civOffline': 'Icom not connected (Settings → CAT)', 'wkp.cwxReady': 'Flex CWX ready', 'wkp.cwxOffline': 'Flex not connected (Settings → CAT)',
+  'wkp.sourceHint': 'CW output: WK = WinKeyer hardware · CI-V = the Icom rig’s own keyer (over CAT, no extra hardware)', 'wkp.rigReady': 'Rig keyer ready', 'wkp.rigOffline': 'Rig CAT offline', 'wkp.civReady': 'Icom CI-V ready', 'wkp.civOffline': 'Icom not connected (Settings → CAT)', 'wkp.cwxReady': 'Flex CWX ready', 'wkp.cwxOffline': 'Flex not connected (Settings → CAT)',
   'wkp.cwSpeed': 'CW speed (WPM)', 'wkp.faster': 'Faster', 'wkp.slower': 'Slower', 'wkp.cwText': 'CW text', 'wkp.sendOnTypeHint': 'Key each character live as you type (backspace removes un-sent chars)', 'wkp.sendOnType': 'send on type', 'wkp.phLive': 'Type — sent live…', 'wkp.phEnter': 'Type and press Enter to send…', 'wkp.clear': 'Clear', 'wkp.send': 'Send', 'wkp.abort': 'Abort (clear keyer buffer)', 'wkp.stop': 'Stop',
   'wkp.breakIn': 'Break-in', 'wkp.breakInHint': "The rig's CW keyer only transmits when break-in is SEMI or FULL. OFF keys the sidetone but stays in receive.", 'wkp.bkOff': 'OFF', 'wkp.bkOffWarn': "won't transmit — set SEMI or FULL",
   'wkp.autoCallHint': 'Click a CQ macro (one whose text contains CQ) to resend it on a loop — message, gap, repeat — until you send another macro (e.g. a report), press Stop, or hit ESC. Non-CQ macros send once.', 'wkp.autoCall': 'Auto-call', 'wkp.gap': 'gap', 'wkp.gapHint': 'Seconds to wait after the message before resending', 'wkp.loopHint': 'click a CQ macro to loop it', 'wkp.macroN': 'Macro {n}',
@@ -574,7 +574,7 @@ const fr: Dict = {
   'wk.escClears': "ÉCHAP efface aussi l'indicatif (sinon ÉCHAP arrête seulement la transmission)",
   'wk.esm': 'ESM — Entrée envoie le message (CW)',
   'wk.esmHint': "En CW avec le keyer actif, Entrée envoie un macro selon l'étape du QSO au lieu de loguer : indicatif vide → F1 (CQ) ; indicatif saisi → F2 (report) et le focus passe au RST ; Entrée dans le RST → F3 (TU), qui logue si le macro contient <LOGQSO>.",
-  'wk.engWinkeyer': 'WinKeyer (K1EL, série)', 'wk.engSerial': 'Port série (DTR=CW / RTS=PTT)', 'wk.engIcom': 'Icom CI-V (keyer de la radio)', 'wk.engFlex': 'FlexRadio (CWX)', 'wk.engTci': 'TCI (bientôt)',
+  'wk.engWinkeyer': 'WinKeyer (K1EL, série)', 'wk.engSerial': 'Port série (DTR=CW / RTS=PTT)', 'wk.engIcom': 'Icom CI-V (keyer de la radio)', 'wk.engYaesu': 'Yaesu (keyer de la radio)', 'wk.catWarnYaesu': 'Le keyer Yaesu nécessite le backend CAT Yaesu — le CAT est actuellement : {backend}.', 'wk.engFlex': 'FlexRadio (CWX)', 'wk.engTci': 'TCI (bientôt)',
   'wk.icomNote': "L'Icom CI-V manipule la CW via le keyer interne de la radio sur la connexion CAT existante (commande 0x17) — il réutilise le port COM CAT défini dans Réglages → CAT, rien d'autre à câbler ici. Mets la radio en mode CW. Poids, ratio, sidetone, mode paddle… se règlent sur la radio ; seule la vitesse est définie ici (KEY SPEED de la radio).",
   'wk.flexNote': "FlexRadio manipule la CW via le keyer CWX de la radio sur la connexion SmartSDR CAT existante — pas besoin de WinKeyer ni de SmartCAT. Il réutilise la connexion définie dans Réglages → CAT, rien d'autre à câbler ici. Mets une slice en mode CW. Seule la vitesse est définie ici ; poids, sidetone et break-in se règlent sur la radio (le break-in doit être activé pour que la CW parte vraiment).",
   'wk.catWarnIcom': "Ton backend CAT est réglé sur {backend}. La CW Icom CI-V nécessite le backend CAT réglé sur Icom et connecté — change-le dans Réglages → Interface CAT, sinon l'envoi CW échouera.",
@@ -741,7 +741,7 @@ const fr: Dict = {
   'ctp.stopContest': 'Arrêter le contest', 'ctp.startContest': 'Démarrer le contest', 'ctp.activeHint': 'Le formulaire de saisie affiche Env/Reç et un badge DUPE ; les QSO sont marqués avec ce contest.', 'ctp.inactiveHint': 'Choisis un contest, règle la fenêtre, puis Démarrer.', 'ctp.scoreboard': 'Tableau des scores', 'ctp.estimate': 'estimation', 'ctp.qsos': 'QSO', 'ctp.mult': 'Mult', 'ctp.scoreEst': 'Score (est.)', 'ctp.last60': 'Dernières 60 min', 'ctp.band': 'Bande',
   'adx.introPart1': 'Tous les champs ADIF 3.1.7 non affichés dans les autres onglets. Choisis un champ à ajouter, ou saisis un tag personnalisé/constructeur (ex. ', 'adx.introPart2': '). Stocké sans perte et exporté en mode ADIF ', 'adx.fullMode': 'complet', 'adx.introPart3': '.', 'adx.addFieldPh': 'Ajouter un champ ADIF…', 'adx.showDeprecated': 'Afficher les obsolètes', 'adx.noExtra': 'Aucun champ ADIF supplémentaire. Utilise le sélecteur ci-dessus pour en ajouter un.', 'adx.deprecated': 'obsolète', 'adx.intl': 'intl', 'adx.nonStandard': 'non standard', 'adx.removeField': 'Supprimer le champ',
   'wkp.sending': 'Émission…', 'wkp.connectedV': 'Connecté (v{version})', 'wkp.disconnected': 'Déconnecté', 'wkp.comPort': 'Port COM', 'wkp.noPorts': 'Aucun port', 'wkp.refreshPorts': 'Rafraîchir les ports', 'wkp.connect': 'Connecter', 'wkp.disconnect': 'Déconnecter', 'wkp.hide': 'Masquer / désactiver le WinKeyer',
-  'wkp.sourceHint': 'Sortie CW : WK = WinKeyer matériel · CI-V = le keyer interne de l’Icom (via CAT, sans matériel en plus)', 'wkp.civReady': 'Icom CI-V prêt', 'wkp.civOffline': 'Icom non connecté (Réglages → CAT)', 'wkp.cwxReady': 'Flex CWX prêt', 'wkp.cwxOffline': 'Flex non connecté (Réglages → CAT)',
+  'wkp.sourceHint': 'Sortie CW : WK = WinKeyer matériel · CI-V = le keyer interne de l’Icom (via CAT, sans matériel en plus)', 'wkp.rigReady': 'Keyer radio prêt', 'wkp.rigOffline': 'CAT radio hors ligne', 'wkp.civReady': 'Icom CI-V prêt', 'wkp.civOffline': 'Icom non connecté (Réglages → CAT)', 'wkp.cwxReady': 'Flex CWX prêt', 'wkp.cwxOffline': 'Flex non connecté (Réglages → CAT)',
   'wkp.cwSpeed': 'Vitesse CW (WPM)', 'wkp.faster': 'Plus rapide', 'wkp.slower': 'Plus lent', 'wkp.cwText': 'Texte CW', 'wkp.sendOnTypeHint': 'Manipule chaque caractère en direct à la frappe (retour arrière supprime les caractères non émis)', 'wkp.sendOnType': 'émission à la frappe', 'wkp.phLive': 'Tape — émis en direct…', 'wkp.phEnter': 'Tape et appuie sur Entrée pour émettre…', 'wkp.clear': 'Effacer', 'wkp.send': 'Émettre', 'wkp.abort': 'Interrompre (vider le tampon du manipulateur)', 'wkp.stop': 'Stop',
   'wkp.breakIn': 'Break-in', 'wkp.breakInHint': "Le manipulateur interne de la radio n'émet que si le break-in est SEMI ou FULL. OFF génère la tonalité mais reste en réception.", 'wkp.bkOff': 'OFF', 'wkp.bkOffWarn': "n'émettra pas — mettre SEMI ou FULL",
   'wkp.autoCallHint': "Clique une macro CQ (dont le texte contient CQ) pour la réémettre en boucle — message, pause, répétition — jusqu'à envoyer une autre macro (ex. un report), appuyer sur Stop ou ESC. Les macros non-CQ ne sont émises qu'une fois.", 'wkp.autoCall': 'Appel auto', 'wkp.gap': 'pause', 'wkp.gapHint': 'Secondes à attendre après le message avant de réémettre', 'wkp.loopHint': 'clique une macro CQ pour la boucler', 'wkp.macroN': 'Macro {n}',

frontend/wailsjs/go/main/App.d.ts

@@ -1035,4 +1035,8 @@ export function WinkeyerStop():Promise<void>;
 
 export function WorkedBefore(arg1:string,arg2:number):Promise<qso.WorkedBefore>;
 
+export function YaesuSendCW(arg1:string):Promise<void>;
+
+export function YaesuStopCW():Promise<void>;
+
 export function YaesuZeroIn():Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -2018,6 +2018,14 @@ export function WorkedBefore(arg1, arg2) {
   return window['go']['main']['App']['WorkedBefore'](arg1, arg2);
 }
 
+export function YaesuSendCW(arg1) {
+  return window['go']['main']['App']['YaesuSendCW'](arg1);
+}
+
+export function YaesuStopCW() {
+  return window['go']['main']['App']['YaesuStopCW']();
+}
+
 export function YaesuZeroIn() {
   return window['go']['main']['App']['YaesuZeroIn']();
 }

internal/cat/yaesu_cw.go

@@ -0,0 +1,128 @@
+package cat
+
+// CW keying through the Yaesu's own keyer — the KY command.
+//
+// This is the fifth CW engine, alongside WinKeyer, the DTR/RTS line keyer, the
+// Icom CI-V keyer and FlexRadio's CWX. The point is the same in each: no extra
+// hardware, no second cable. The radio holds the text and keys it with its own
+// timing, which is why the character spacing is perfect where a PC keying a line
+// through USB latency is not.
+//
+//	KY;           → KY0;  buffer has room / KY1; buffer full
+//	KY <text>;            queue up to 24 characters
+//
+// The leading SPACE after KY is part of the command, not padding.
+//
+// Verified on: nothing yet — the send path follows the FTDX10/FTDX101 CAT
+// reference and the way Hamlib drives these rigs. STOP is the uncertain half:
+// Yaesu documents no way to clear the buffer, so see StopCW.
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+// yaesuCWChunk is the most characters one KY command accepts. Longer text is
+// split and fed as the rig drains its buffer.
+const yaesuCWChunk = 24
+
+// yaesuCWAllowed is what the rig's keyer can actually send. Anything else is
+// dropped rather than passed through: an unsupported byte can abort the whole
+// buffer, losing the rest of the message with no error anywhere.
+const yaesuCWAllowed = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 /?.,-=+:;()"
+
+// SendCW queues a message on the rig's keyer.
+//
+// Text is filtered, upper-cased and fed in 24-character pieces, waiting for room
+// between pieces. Without that wait a long macro would silently lose its tail:
+// the rig drops what does not fit rather than reporting an error.
+func (y *Yaesu) SendCW(text string) error {
+	msg := filterYaesuCW(text)
+	if msg == "" {
+		return nil
+	}
+	for len(msg) > 0 {
+		n := yaesuCWChunk
+		if len(msg) < n {
+			n = len(msg)
+		}
+		chunk := msg[:n]
+		msg = msg[n:]
+		if err := y.waitCWBuffer(4 * time.Second); err != nil {
+			return err
+		}
+		y.mu.Lock()
+		err := y.write("KY " + chunk + ";")
+		y.mu.Unlock()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// StopCW aborts the message being sent.
+//
+// Yaesu documents no buffer-clear, so this drops the transmitter instead: TX0
+// takes the rig out of transmit, which is what an operator pressing Escape
+// actually wants. Anything still queued is not keyed on the air.
+//
+// It deliberately does NOT send "KY0;" — a plausible-looking clear that the rig
+// would read as the CHARACTER zero and dutifully send. A wrong guess here
+// transmits, which is worse than an imperfect abort.
+func (y *Yaesu) StopCW() error {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+	if y.port == nil {
+		return fmt.Errorf("yaesu: not connected")
+	}
+	return y.write("TX0;")
+}
+
+// waitCWBuffer blocks until the keyer reports room, or the deadline passes.
+// A rig that never answers the status query is not a reason to refuse to send —
+// we go ahead once, and the worst case is the truncation we were avoiding.
+func (y *Yaesu) waitCWBuffer(within time.Duration) error {
+	deadline := time.Now().Add(within)
+	for {
+		y.mu.Lock()
+		if y.port == nil {
+			y.mu.Unlock()
+			return fmt.Errorf("yaesu: not connected")
+		}
+		r, err := y.ask("KY;")
+		y.mu.Unlock()
+		if err != nil {
+			debugLog.Printf("yaesu cw: KY status query failed (%v) — sending anyway", err)
+			return nil
+		}
+		if len(r) >= 3 && r[2] == '0' {
+			return nil // room in the buffer
+		}
+		if time.Now().After(deadline) {
+			return fmt.Errorf("yaesu: the keyer buffer stayed full for %s", within)
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+}
+
+// filterYaesuCW upper-cases and strips what the keyer cannot send.
+func filterYaesuCW(text string) string {
+	var b strings.Builder
+	for _, r := range strings.ToUpper(text) {
+		// Any whitespace becomes a word gap FIRST. Dropping tabs and newlines as
+		// "not in the allowed set" glued the words either side together: a macro
+		// written on two lines went out as CQCQ.
+		if r == '\t' || r == '\n' || r == '\r' {
+			b.WriteByte(' ')
+			continue
+		}
+		if strings.ContainsRune(yaesuCWAllowed, r) {
+			b.WriteRune(r)
+		}
+	}
+	// Runs of spaces become one: the rig sends each as a word gap, so three in a
+	// row is three gaps and the message crawls.
+	return strings.Join(strings.Fields(b.String()), " ")
+}

internal/cat/yaesu_cw_test.go

@@ -0,0 +1,63 @@
+package cat
+
+import (
+	"strings"
+	"testing"
+)
+
+// What reaches the rig's keyer.
+//
+// An unsupported byte does not produce an error on a Yaesu — it can abort the
+// whole buffer, so the rest of the message is lost silently. Filtering is
+// therefore part of correctness, not tidiness.
+func TestFilterYaesuCW(t *testing.T) {
+	cases := []struct{ in, want string }{
+		{"cq cq de f4bpo", "CQ CQ DE F4BPO"},
+		{"F4BPO/P", "F4BPO/P"},
+		{"599 tu 73", "599 TU 73"},
+		// Accents and symbols the keyer has no code for.
+		{"héllo", "HLLO"},
+		{"a*b#c", "ABC"},
+		// Runs of whitespace collapse: the rig sends each space as a word gap, so
+		// three in a row is three gaps and the message crawls.
+		{"cq    cq", "CQ CQ"},
+		{"  padded  ", "PADDED"},
+		{"\tcq\ncq\t", "CQ CQ"},
+		{"", ""},
+		{"   ", ""},
+	}
+	for _, c := range cases {
+		if got := filterYaesuCW(c.in); got != c.want {
+			t.Errorf("filterYaesuCW(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+}
+
+// Long macros have to be split: one KY command carries 24 characters and the rig
+// DROPS what does not fit rather than reporting an error, so a contest CQ would
+// lose its tail with no sign anywhere.
+func TestYaesuCWChunking(t *testing.T) {
+	msg := filterYaesuCW("cq cq cq de f4bpo f4bpo f4bpo pse k")
+	if len(msg) <= yaesuCWChunk {
+		t.Fatalf("test message is %d chars — too short to exercise chunking", len(msg))
+	}
+	var chunks []string
+	for rest := msg; len(rest) > 0; {
+		n := yaesuCWChunk
+		if len(rest) < n {
+			n = len(rest)
+		}
+		chunks = append(chunks, rest[:n])
+		rest = rest[n:]
+	}
+	for i, c := range chunks {
+		if len(c) > yaesuCWChunk {
+			t.Errorf("chunk %d is %d chars, over the %d limit", i, len(c), yaesuCWChunk)
+		}
+	}
+	// Nothing added, nothing lost: the message the operator typed is what the
+	// keyer receives.
+	if joined := strings.Join(chunks, ""); joined != msg {
+		t.Errorf("chunks rejoin to %q, want %q", joined, msg)
+	}
+}

internal/cat/yaesu_panel.go

@@ -82,6 +82,9 @@ type YaesuController interface {
 	SetYaesuKeySpeed(int) error
 	SetYaesuBreakIn(bool) error
 	YaesuZeroIn() error
+	// CW keying through the rig's own keyer (KY) — the fifth CW engine.
+	SendCW(string) error
+	StopCW() error
 	SetYaesuSplit(bool) error
 	SetYaesuSplitOffset(int64) error
 	SetYaesuBand(string) error