diff --git a/app.go b/app.go
index d99dbfc..9e8cc4a 100644
--- a/app.go
+++ b/app.go
@@ -57,6 +57,7 @@ import (
 	"hamlog/internal/relaydev"
 	"hamlog/internal/rigctld"
 	"hamlog/internal/rotator/dcu1"
+	"hamlog/internal/rotator/spid"
 	"hamlog/internal/rotator/gs232"
 	"hamlog/internal/rotator/pst"
 	"hamlog/internal/rotgenius"
@@ -14186,6 +14187,10 @@ type RotatorDevice struct {
 	Transport    string `json:"transport"`     // ARCO: "tcp" (LAN) | "serial" (USB COM)
 	ComPort      string `json:"com_port"`      // GS-232 serial transport
 	Baud         int    `json:"baud"`          // GS-232 serial baud (an ERC needs it; an ARCO ignores it)
+	// SpidModel picks the SPID dialect: "rot2prog" (RAS/BIG-RAS/MD-01/MD-02,
+	// azimuth + elevation) or "rot1prog" (the older azimuth-only controller).
+	// They differ in reply length and baud rate, so guessing is not an option.
+	SpidModel string `json:"spid_model,omitempty"`
 }
 
 // logicalRotor is one addressable rotor. Flattening the device list expands a
@@ -14198,7 +14203,7 @@ type logicalRotor struct {
 
 // normRotorType clamps a rotor type to a known backend.
 func normRotorType(t string) string {
-	if t == "rotgenius" || t == "arco" || t == "dcu1" {
+	if t == "rotgenius" || t == "arco" || t == "dcu1" || t == "spid" {
 		return t
 	}
 	return "pst"
@@ -14224,6 +14229,7 @@ func deviceLink(d RotatorDevice, sub int) rotorLink {
 	l := rotorLink{
 		Type: normRotorType(d.Type), Host: d.Host, Port: d.Port,
 		Transport: d.Transport, ComPort: d.ComPort, Baud: d.Baud, HasElevation: d.HasElevation,
+		SpidModel: d.SpidModel,
 	}
 	if l.Host == "" {
 		l.Host = "127.0.0.1"
@@ -14232,7 +14238,12 @@ func deviceLink(d RotatorDevice, sub int) rotorLink {
 		l.Port = rotatorDefaultPort(l.Type)
 	}
 	if l.Baud <= 0 {
-		l.Baud = 9600
+		// A SPID runs at 600 or 1200 baud depending on the dialect; 0 lets its
+		// driver pick, and forcing 9600 here would have made every controller
+		// mute for a reason nobody would guess.
+		if l.Type != "spid" {
+			l.Baud = 9600
+		}
 	}
 	if l.Transport != "serial" {
 		l.Transport = "tcp"
@@ -14368,6 +14379,7 @@ type rotorLink struct {
 	ComPort      string
 	Baud         int
 	HasElevation bool
+	SpidModel    string // SPID: "rot2prog" (default) | "rot1prog"
 }
 
 // activeRotorIndex returns the compass-selected rotor index, clamped to the
@@ -14415,6 +14427,22 @@ func dcu1Client(l rotorLink) *dcu1.Client {
 	return dcu1.New(l.Host, l.Port)
 }
 
+// spidClient builds the SPID (AlfaSpid) client for a rotor.
+//
+// Serial only, and that is the point: these controllers have a COM port and
+// nothing else. The request this answers was to drive them WITHOUT PstRotator
+// sitting in between, so there is no network transport to offer.
+//
+// Baud 0 lets the driver take the dialect's documented default — 600 baud for
+// Rot2Prog, 1200 for Rot1Prog. Those numbers look wrong and are not.
+func spidClient(l rotorLink) *spid.Client {
+	m := spid.Rot2Prog
+	if l.SpidModel == string(spid.Rot1Prog) {
+		m = spid.Rot1Prog
+	}
+	return spid.New(l.ComPort, l.Baud, m)
+}
+
 // RotatorHeading is the live antenna heading for the status bar and compass.
 type RotatorHeading struct {
 	Enabled bool   `json:"enabled"`
@@ -14481,6 +14509,16 @@ func (a *App) GetRotatorHeading() RotatorHeading {
 		base.Azimuth = az
 		base.Raw = raw
 		return base
+	case "spid":
+		az, _, herr := spidClient(link).Heading()
+		if herr != nil {
+			base.Raw = herr.Error()
+			return base
+		}
+		base.OK = true
+		base.Azimuth = az
+		base.Raw = fmt.Sprintf("%d°", az)
+		return base
 	case "dcu1":
 		az, raw, herr := dcu1Client(link).Heading()
 		if herr != nil {
@@ -14531,6 +14569,8 @@ func (a *App) RotatorGoToPath(az int, el int, path string) error {
 		return rotgenius.New(link.Host, link.Port).GoTo(link.Num, az)
 	case "arco":
 		return arcoClient(link).GoTo(az)
+	case "spid":
+		return spidClient(link).GoTo(az, el)
 	case "dcu1":
 		return dcu1Client(link).GoTo(az)
 	default:
@@ -14550,6 +14590,8 @@ func (a *App) RotatorStop() error {
 		return rotgenius.New(link.Host, link.Port).Stop()
 	case "arco":
 		return arcoClient(link).Stop()
+	case "spid":
+		return spidClient(link).Stop()
 	case "dcu1":
 		return dcu1Client(link).Stop()
 	default:
@@ -14570,6 +14612,8 @@ func (a *App) RotatorPark() error {
 		return fmt.Errorf("park is a PstRotator feature; not available on the Rotator Genius")
 	case "arco":
 		return fmt.Errorf("park is a PstRotator feature; not available over the ARCO GS-232 link")
+	case "spid":
+		return fmt.Errorf("park is a PstRotator feature; a SPID controller has no park command")
 	case "dcu1":
 		return fmt.Errorf("park is a PstRotator feature; not available over the DCU-1 link")
 	default:
@@ -14610,6 +14654,15 @@ func testRotorLink(l rotorLink) error {
 		// GS-232 — without moving the antenna.
 		_, _, err := arcoClient(l).Heading()
 		return err
+	case "spid":
+		if strings.TrimSpace(l.ComPort) == "" {
+			return fmt.Errorf("select the SPID controller's COM port first")
+		}
+		// A status read proves the port, the baud rate and the dialect at once,
+		// without moving anything — and a wrong dialect shows up here as a reply
+		// of the wrong length rather than as an antenna that turns oddly later.
+		_, _, err := spidClient(l).Heading()
+		return err
 	case "dcu1":
 		if l.Transport == "serial" && strings.TrimSpace(l.ComPort) == "" {
 			return fmt.Errorf("select the DCU-1 controller's COM port first")
diff --git a/changelog.json b/changelog.json
index c489428..769ca2d 100644
--- a/changelog.json
+++ b/changelog.json
@@ -3,10 +3,12 @@
     "version": "0.25.3",
     "date": "",
     "en": [
-      "Confirmations: a LoTW contact marked V (verified) counted for the awards but not for the band/mode matrix, the slot statistics or the row colours — they only accepted Y. One entity could read “validated” in Awards and “worked” beside it."
+      "Confirmations: a LoTW contact marked V (verified) counted for the awards but not for the band/mode matrix, the slot statistics or the row colours — they only accepted Y. One entity could read “validated” in Awards and “worked” beside it.",
+      "Rotators: SPID / AlfaSpid controllers are driven natively over their own COM port — Rot2Prog and Rot1Prog — so PstRotator is no longer needed in between. Two towers means two rotors, as before."
     ],
     "fr": [
-      "Confirmations : un contact LoTW marqué V (vérifié) comptait pour les diplômes mais pas pour la matrice bande/mode, les statistiques de créneaux ni la coloration des lignes — elles n’acceptaient que Y. Une même entité pouvait être « validée » dans Diplômes et « travaillée » juste à côté."
+      "Confirmations : un contact LoTW marqué V (vérifié) comptait pour les diplômes mais pas pour la matrice bande/mode, les statistiques de créneaux ni la coloration des lignes — elles n’acceptaient que Y. Une même entité pouvait être « validée » dans Diplômes et « travaillée » juste à côté.",
+      "Rotors : les contrôleurs SPID / AlfaSpid sont pilotés nativement par leur propre port COM — Rot2Prog et Rot1Prog — sans passer par PstRotator. Deux pylônes restent deux rotors, comme avant."
     ]
   },
   {
diff --git a/frontend/src/components/SettingsModal.tsx b/frontend/src/components/SettingsModal.tsx
index 58185d1..75b4cfd 100644
--- a/frontend/src/components/SettingsModal.tsx
+++ b/frontend/src/components/SettingsModal.tsx
@@ -3674,7 +3674,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             const isRG = dev.type === 'rotgenius';
             const isARCO = dev.type === 'arco';
             const isDCU1 = dev.type === 'dcu1';
-            const isSerialCap = isARCO || isDCU1; // COM-port or serial-over-IP controllers
+            // A SPID has a COM port and nothing else — no network transport to
+            // offer, which is the whole point of driving it without PstRotator.
+            const isSPID = dev.type === 'spid';
+            const isSerialCap = isARCO || isDCU1 || isSPID; // COM-port or serial-over-IP controllers
             const transport = dev.transport ?? 'tcp';
             return (
               <div key={dev.id || i} className="rounded-xl border border-border bg-card/40 p-3 space-y-3">
@@ -3693,13 +3696,14 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     {/* Each backend gets its default port: Rotator Genius 9006, ARCO 4001
                         (placeholder — must match the ARCO's LAN menu), PstRotator 12000. */}
                     <Select value={dev.type ?? 'pst'}
-                      onValueChange={(v) => patch(i, { type: v as any, port: v === 'rotgenius' ? 9006 : (v === 'arco' || v === 'dcu1') ? 4001 : 12000, ...(v === 'dcu1' ? { transport: 'serial' } : {}) })}>
+                      onValueChange={(v) => patch(i, { type: v as any, port: v === 'rotgenius' ? 9006 : (v === 'arco' || v === 'dcu1') ? 4001 : 12000, ...(v === 'dcu1' || v === 'spid' ? { transport: 'serial' } : {}), ...(v === 'spid' ? { baud: 600, spid_model: 'rot2prog' } : {}) })}>
                       <SelectTrigger className="h-9"><SelectValue /></SelectTrigger>
                       <SelectContent>
                         <SelectItem value="pst">PstRotator (UDP)</SelectItem>
                         <SelectItem value="rotgenius">Rotator Genius (4O3A, native)</SelectItem>
                         <SelectItem value="arco">GS-232A controller (microHAM ARCO, ERC…)</SelectItem>
                         <SelectItem value="dcu1">Hy-Gain DCU-1 (RotorCard DXA, Rotor-EZ, Green Heron)</SelectItem>
+                        <SelectItem value="spid">SPID / AlfaSpid (RAS, BIG-RAS, MD-01, MD-02)</SelectItem>
                       </SelectContent>
                     </Select>
                   </div>
@@ -3716,8 +3720,24 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                       </Select>
                     </div>
                   )}
+                  {/* SPID: pick the dialect. They differ in reply length AND baud
+                      rate, so this cannot be detected — a wrong choice is a
+                      controller that never answers. */}
+                  {isSPID && (
+                    <div className="space-y-1">
+                      <Label>{t('rot.spidModel')}</Label>
+                      <Select value={dev.spid_model || 'rot2prog'}
+                        onValueChange={(v) => patch(i, { spid_model: v as any, baud: v === 'rot1prog' ? 1200 : 600 })}>
+                        <SelectTrigger className="h-9"><SelectValue /></SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="rot2prog">Rot2Prog (RAS, BIG-RAS/HR, MD-01, MD-02)</SelectItem>
+                          <SelectItem value="rot1prog">Rot1Prog (azimuth only)</SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </div>
+                  )}
                   {/* ARCO and DCU-1 controllers reach over the LAN (TCP) or a serial COM. */}
-                  {isSerialCap && (
+                  {isSerialCap && !isSPID && (
                     <div className="space-y-1">
                       <Label>Connection</Label>
                       <Select value={transport} onValueChange={(v) => patch(i, { transport: v as any })}>
@@ -3751,10 +3771,13 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                       <Button size="sm" variant="outline" className="h-9" onClick={() => ListSerialPorts().then((p) => setWkPorts((p ?? []) as string[])).catch(() => {})}>
                         <ArrowDown className="size-3.5 rotate-90" />
                       </Button>
-                      <Select value={String(dev.baud || 9600)} onValueChange={(v) => patch(i, { baud: Number(v) })}>
+                      {/* A SPID runs at 600 or 1200 baud — not a typo, a pulse
+                          controller has nothing to say quickly. Offering only the
+                          usual rates would have left it permanently mute. */}
+                      <Select value={String(dev.baud || (isSPID ? 600 : 9600))} onValueChange={(v) => patch(i, { baud: Number(v) })}>
                         <SelectTrigger className="h-9 w-28"><SelectValue /></SelectTrigger>
                         <SelectContent>
-                          {[4800, 9600, 19200, 38400, 57600].map((b) => (
+                          {(isSPID ? [600, 1200, 2400, 4800, 9600] : [4800, 9600, 19200, 38400, 57600]).map((b) => (
                             <SelectItem key={b} value={String(b)}>{b} baud</SelectItem>
                           ))}
                         </SelectContent>
@@ -3784,6 +3807,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 {isRG && <p className="text-xs text-muted-foreground">{t('rot.rgHint')}</p>}
                 {isARCO && <p className="text-xs text-muted-foreground">{t('rot.arcoHint')}</p>}
                 {isDCU1 && <p className="text-xs text-muted-foreground">{t('rot.dcu1Hint')}</p>}
+                {isSPID && <p className="text-xs text-muted-foreground">{t('rot.spidHint')}</p>}
                 {/* Which antenna this rotor carries — only relevant with >1 rotor. */}
                 {multi && (
                   <div className="space-y-1 max-w-xs">
diff --git a/frontend/src/lib/i18n.tsx b/frontend/src/lib/i18n.tsx
index b45d9e8..48182ec 100644
--- a/frontend/src/lib/i18n.tsx
+++ b/frontend/src/lib/i18n.tsx
@@ -285,6 +285,7 @@ const en: Dict = {
   'cat.hint': "Reads the rig's frequency / band / mode and pushes them into the entry strip in real time. Use OmniRig (free, any rig) or — for FlexRadio — the native SmartSDR API (no OmniRig needed, real-time, no second-click mode bug).",
   'ag2.hint': 'OpsLog talks to the 4O3A Antenna Genius switch over TCP (GSCP protocol). The port is fixed at 9007, so only the device IP is needed. A docked widget then lets you switch antennas per port (A/B).', 'ag2.password': 'Remote password', 'ag2.passwordPh': 'blank on LAN', 'ag2.passwordHint': 'Only needed when reaching the device remotely — it then announces "AG AUTH" and rejects commands until you log in. Leave blank on the local network.',
   'tg2.hint': 'OpsLog talks to the 4O3A Tuner Genius XL over TCP (port fixed at 9010), so only the device IP is needed. A docked widget then shows SWR and forward power and offers Tune, Bypass and Operate/Standby. Control it directly (not through the radio) so OpsLog uses just one of the box\'s connection slots.', 'tg2.enable': 'Enable Tuner Genius control', 'tg2.portHint': 'The TCP port is fixed at 9010 on the device.', 'tg2.password': 'Remote code', 'tg2.passwordPh': 'blank on LAN', 'tg2.passwordHint': 'Only needed when reaching the device remotely — it then announces "AUTH" and rejects commands until you log in. Leave blank on the local network.',
+  'rot.spidHint': 'Native SPID protocol over the controller’s COM port — no PstRotator needed. Pick the dialect above: Rot2Prog answers with azimuth and elevation at 600 baud, Rot1Prog with azimuth only at 1200.', 'rot.spidModel': 'SPID protocol',
   'rot.enable': 'Enable rotator control', 'rot.testOkRG': 'Connected — the Rotator Genius accepted the command (moving to 0°).',  'rot.type': 'Rotator type', 'rot.rotatorNum': 'Rotator #', 'rot.dual': 'Two rotors', 'rot.rotor1': 'Rotor 1', 'rot.rotor2': 'Rotor 2', 'rot.name': 'Name', 'rot.antenna': 'Antenna', 'rot.antenna1': 'Rotor 1 antenna', 'rot.antenna2': 'Rotor 2 antenna', 'rot.name1': 'Rotor 1 name', 'rot.name2': 'Rotor 2 name', 'rot.antStd': 'Standard antenna', 'rot.antMotor': 'Motorized (Ultrabeam/SteppIR)', 'rot.add': 'Add rotor', 'rot.remove': 'Remove rotor', 'rot.none': 'No rotor configured. Click “Add rotor” to add one.', 'rot.rgDual': 'This Rotator Genius drives two rotors (adds a second one)', 'rot.testRotor1': 'Test rotor 1', 'rot.testRotor2': 'Test rotor 2', 'rot.dualHint': 'Two independent rotors of any type — for example an ARCO and a Rotator Genius side by side. Configure each below; OpsLog shows a Rotor 1/2 toggle on the compass to pick which one it turns and displays. Set each rotor to "Motorized" so the boom/pattern paths (reverse, bidirectional) show only for the one that carries the Ultrabeam/SteppIR. (For a single Rotator Genius driving two rotors, set both to Rotator Genius with the same host and rotator # 1 and 2.)', 'rot.rgHint': 'Talks directly to a 4O3A Rotator Genius over TCP (default port 9006) — no PstRotator needed. Rotator # selects which of the two rotators to drive.', 'rot.arcoHint': "Talks directly to any controller set to Yaesu GS-232A — no PstRotator needed. microHAM ARCO: set Config → LAN → CONTROL PROTOCOL (or USB CONTROL PROTOCOL) to 'Yaesu GS-232A'; on USB the baud rate does not matter. ERC (Easy Rotor Control, incl. ERC Mini): its emulation MUST be set to GS-232 — an ERC left on Hy-Gain DCU-1 speaks a different command set and will not answer — then pick its COM port and the same baud rate as in the ERC configuration.", 'rot.dcu1Hint': "Speaks the Hy-Gain DCU-1 command set (RotorCard DXA, Idiom Press Rotor-EZ, Green Heron). Connect over the controller's COM port (a DCU-1 is 4800 baud; RotorCard/Green Heron may differ — match the controller) or over TCP through a serial-over-IP bridge. Azimuth only, no elevation. New backend — please report if your controller needs a different command or baud.", 'rot.hint': "OpsLog sends UDP commands to PstRotator. Enable PstRotator's UDP listener (Setup → Communication → UDP) before testing.",
   'extsvc.hint': 'Upload logged QSOs to online logbooks. Each service uploads automatically on a new QSO when enabled; timing is per-service (immediate, or a 1–2 min delay so a mis-logged QSO can still be fixed first).',
   'hw.motorTxInhibit': 'Inhibit transmission while the antenna is moving', 'hw.motorTxInhibitHint': 'Blocks the FlexRadio from transmitting while the elements move (needs FlexRadio in API mode + this antenna enabled). No effect with other radios.', 'hw.motorAntenna': 'Ultrabeam / Steppir', 'hw.motorEnable': 'Enable antenna control', 'hw.motorType': 'Antenna type', 'hw.motorTransport': 'Connection', 'hw.motorTcp': 'Network (TCP)', 'hw.motorSerial': 'Serial (COM)', 'hw.motorCom': 'Serial port', 'hw.motorBaud': 'Baud', 'hw.steppirHint': 'SteppIR controllers are RS-232 serial (the DATA OUT DB9 port). Serial = a USB↔RS-232 (FTDI) adapter, shown as a COM port. Network = a serial-to-Ethernet bridge (as for the Ultrabeam).', 'hw.steppirRange': 'Tunable range', 'hw.steppirRangeHint': "The SteppIR's frequency coverage. On a band outside this range (e.g. 30 m on a 20 m–6 m SteppIR) OpsLog won't try to tune the antenna and won't inhibit transmission. Default 13–54 MHz (20 m–6 m); widen the low edge (e.g. 6) for a 40 m-equipped SteppIR.", 'hw.motorBands': 'Covered bands', 'hw.motorStep': 'Re-tune step', 'hw.motorBandFreqHint': 'Frequency each band button tunes the antenna to (kHz). Leave empty for the default shown.', 'hw.motorFollow': 'Follow rig frequency (auto-tune the antenna)', 'hw.ultrabeam': 'Antenna (Ultrabeam)', 'hw.audioVoice': 'Audio devices & voice keyer',
@@ -708,6 +709,7 @@ const fr: Dict = {
   'cat.hint': "Lit la fréquence / bande / mode du poste et les injecte dans le bandeau de saisie en temps réel. Utilise OmniRig (gratuit, tout poste) ou — pour FlexRadio — l'API native SmartSDR (sans OmniRig, temps réel, sans le bug du mode au 2ᵉ clic).",
   'ag2.hint': "OpsLog dialogue avec le switch 4O3A Antenna Genius en TCP (protocole GSCP). Le port est fixé à 9007, seule l'IP de l'appareil est nécessaire. Un widget ancré permet ensuite de commuter les antennes par port (A/B).", 'ag2.password': 'Mot de passe distant', 'ag2.passwordPh': 'vide en LAN', 'ag2.passwordHint': "Nécessaire seulement à distance — l'appareil annonce alors « AG AUTH » et refuse les commandes tant qu'on n'est pas identifié. Laisse vide sur le réseau local.",
   'tg2.hint': "OpsLog dialogue avec le 4O3A Tuner Genius XL en TCP (port fixé à 9010), seule l'IP de l'appareil est nécessaire. Un widget ancré affiche le ROS et la puissance directe et propose Accord, Bypass et Operate/Standby. Pilotage direct (pas via la radio) pour n'utiliser qu'une des connexions de la boîte.", 'tg2.enable': "Activer le contrôle du Tuner Genius", 'tg2.portHint': "Le port TCP est fixé à 9010 sur l'appareil.", 'tg2.password': 'Code distant', 'tg2.passwordPh': 'vide en LAN', 'tg2.passwordHint': "Nécessaire seulement à distance — l'appareil annonce alors « AUTH » et refuse les commandes tant qu'on n'est pas identifié. Laisse vide sur le réseau local.",
+  'rot.spidHint': 'Protocole SPID natif sur le port COM du contrôleur — sans PstRotator. Choisissez le dialecte ci-dessus : Rot2Prog répond azimut et élévation à 600 bauds, Rot1Prog azimut seul à 1200.', 'rot.spidModel': 'Protocole SPID',
   'rot.enable': 'Activer le contrôle du rotator', 'rot.testOkRG': 'Connecté — le Rotator Genius a accepté la commande (rotation vers 0°).',  'rot.type': 'Type de rotator', 'rot.rotatorNum': 'Rotator n°', 'rot.dual': 'Deux rotors', 'rot.rotor1': 'Rotor 1', 'rot.rotor2': 'Rotor 2', 'rot.name': 'Nom', 'rot.antenna': 'Antenne', 'rot.antenna1': 'Antenne rotor 1', 'rot.antenna2': 'Antenne rotor 2', 'rot.name1': 'Nom du rotor 1', 'rot.name2': 'Nom du rotor 2', 'rot.antStd': 'Antenne standard', 'rot.antMotor': 'Motorisée (Ultrabeam/SteppIR)', 'rot.add': 'Ajouter un rotor', 'rot.remove': 'Supprimer le rotor', 'rot.none': 'Aucun rotor configuré. Cliquez sur « Ajouter un rotor ».', 'rot.rgDual': 'Ce Rotator Genius pilote deux rotors (en ajoute un second)', 'rot.testRotor1': 'Tester rotor 1', 'rot.testRotor2': 'Tester rotor 2', 'rot.dualHint': 'Deux rotors indépendants de n\'importe quel type — par exemple un ARCO et un Rotator Genius côte à côte. Configurez chacun ci-dessous ; OpsLog affiche un sélecteur Rotor 1/2 sur le compas pour choisir celui qu\'il tourne et affiche. Réglez chaque rotor sur « Motorisée » pour que les tracés de boom/diagramme (inverse, bidirectionnel) n\'apparaissent que pour celui qui porte l\'Ultrabeam/SteppIR. (Pour un seul Rotator Genius pilotant deux rotors, réglez les deux sur Rotator Genius avec le même hôte et le rotator n° 1 et 2.)', 'rot.rgHint': 'Parle directement à un Rotator Genius 4O3A en TCP (port 9006 par défaut) — sans PstRotator. Le n° choisit lequel des deux rotators du boîtier piloter.', 'rot.arcoHint': "Parle directement à tout contrôleur réglé sur Yaesu GS-232A — sans PstRotator. microHAM ARCO : régler Config → LAN → CONTROL PROTOCOL (ou USB CONTROL PROTOCOL) sur « Yaesu GS-232A » ; en USB la vitesse est sans importance. ERC (Easy Rotor Control, ERC Mini compris) : son émulation DOIT être réglée sur GS-232 — un ERC laissé en Hy-Gain DCU-1 parle un autre jeu de commandes et ne répondra pas — puis choisir son port COM et la même vitesse que dans la configuration de l'ERC.", 'rot.dcu1Hint': "Parle le jeu de commandes Hy-Gain DCU-1 (RotorCard DXA, Idiom Press Rotor-EZ, Green Heron). Connexion via le port COM du contrôleur (un DCU-1 est à 4800 bauds ; RotorCard/Green Heron peuvent différer — reprendre la vitesse du contrôleur) ou en TCP via un pont série-sur-IP. Azimut uniquement, pas d'élévation. Nouveau pilote — signalez si votre contrôleur nécessite une autre commande ou vitesse.", 'rot.hint': "OpsLog envoie des commandes UDP à PstRotator. Active l'écouteur UDP de PstRotator (Setup → Communication → UDP) avant de tester.",
   'extsvc.hint': "Envoie les QSO enregistrés vers des carnets en ligne. Chaque service upload automatiquement à chaque nouveau QSO si activé ; le délai est propre à chaque service (immédiat, ou 1–2 min pour corriger un QSO mal saisi avant).",
   'hw.motorTxInhibit': "Inhiber la transmission pendant que l'antenne bouge", 'hw.motorTxInhibitHint': "Empêche le FlexRadio d'émettre pendant que les éléments bougent (nécessite le FlexRadio en API + cette antenne activée). Sans effet avec les autres radios.", 'hw.motorAntenna': 'Antenne motorisée', 'hw.motorEnable': "Activer le contrôle de l'antenne", 'hw.motorType': "Type d'antenne", 'hw.motorTransport': 'Connexion', 'hw.motorTcp': 'Réseau (TCP)', 'hw.motorSerial': 'Série (COM)', 'hw.motorCom': 'Port série', 'hw.motorBaud': 'Débit', 'hw.steppirHint': "Les contrôleurs SteppIR sont en RS-232 série (port DB9 « DATA OUT »). Série = un adaptateur USB↔RS-232 (FTDI), vu comme un port COM. Réseau = un pont série-Ethernet (comme pour l'Ultrabeam).", 'hw.steppirRange': 'Plage accordable', 'hw.steppirRangeHint': "La couverture en fréquence de la SteppIR. Sur une bande hors de cette plage (p. ex. 30 m avec une SteppIR 20 m-6 m), OpsLog n'essaie pas d'accorder l'antenne et n'inhibe pas l'émission. Défaut 13-54 MHz (20 m-6 m) ; abaisse la borne basse (p. ex. 6) pour une SteppIR équipée 40 m.", 'hw.motorBands': 'Bandes couvertes', 'hw.motorStep': 'Pas de réaccord', 'hw.motorBandFreqHint': "Fréquence sur laquelle chaque bouton de bande accorde l'antenne (kHz). Laisser vide pour le défaut affiché.", 'hw.motorFollow': "Suivre la fréquence du rig (accord auto de l'antenne)", 'hw.ultrabeam': 'Antenne (Ultrabeam)', 'hw.audioVoice': 'Périphériques audio & manipulateur vocal',
diff --git a/frontend/wailsjs/go/models.ts b/frontend/wailsjs/go/models.ts
index 937fa30..955027b 100644
--- a/frontend/wailsjs/go/models.ts
+++ b/frontend/wailsjs/go/models.ts
@@ -3033,6 +3033,7 @@ export namespace main {
 	    transport: string;
 	    com_port: string;
 	    baud: number;
+	    spid_model?: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new RotatorDevice(source);
@@ -3054,6 +3055,7 @@ export namespace main {
 	        this.transport = source["transport"];
 	        this.com_port = source["com_port"];
 	        this.baud = source["baud"];
+	        this.spid_model = source["spid_model"];
 	    }
 	}
 	export class RotatorHeading {
diff --git a/internal/rotator/spid/spid.go b/internal/rotator/spid/spid.go
new file mode 100644
index 0000000..97834e9
--- /dev/null
+++ b/internal/rotator/spid/spid.go
@@ -0,0 +1,257 @@
+// Package spid drives a SPID (AlfaSpid) rotator over its own serial protocol,
+// Rot1Prog or Rot2Prog — the controllers sold as RAS, RAK, BIG-RAS/HR, MD-01
+// and MD-02.
+//
+// It exists so an operator with SPID rotators does not need PstRotator running
+// just to turn an antenna. Two towers with a controller each is the ordinary
+// case; each one is a separate serial port and a separate rotor in OpsLog.
+//
+// WIRE FORMAT
+//
+// Every command is 13 bytes:
+//
+//	 0    1  2  3  4    5    6  7  8  9    10   11  12
+//	0x57 H1 H2 H3 H4   PH   V1 V2 V3 V4   PV   K  0x20
+//
+// K is the command: 0x0F stop, 0x1F status, 0x2F set.
+//
+// The DIGITS ARE ASCII in a command ('0'+d) and RAW BYTES in a reply (0..9).
+// That asymmetry is the whole trap in this protocol: send raw digits and the
+// controller ignores you, read them as ASCII and every heading is 48 degrees
+// times a hundred out. It is pinned by the tests beside this file.
+//
+// PH and PV are the resolution in pulses per degree — 1, 2 or 4 — and are raw
+// in both directions. The target is scaled by it:
+//
+//	u_az = PH × (360 + az)      and the four decimal digits of u_az are sent
+//
+// A reply is 12 bytes for Rot2Prog (azimuth and elevation) or 5 for Rot1Prog
+// (azimuth only, three digits):
+//
+//	az = H1×100 + H2×10 + H3 + H4/10 − 360
+//
+// The 360 offset is what lets the controller report a rotator that has turned
+// past north in either direction, which is the point of a pulse-counting
+// rotator: −180…540 rather than 0…359.
+//
+// Serial is 8N1 at 600 baud for Rot2Prog and 1200 for Rot1Prog. Those are not
+// typos — a pulse controller has nothing to say quickly.
+//
+// Verified against Hamlib's spid.c (rotators/spid/spid.c), which is the
+// reference implementation, and SPID's published protocol note. NOT yet run
+// against real hardware here; the tests pin the frames, the controller is the
+// only thing that can confirm the rest.
+package spid
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"go.bug.st/serial"
+)
+
+// Model selects the dialect.
+type Model string
+
+const (
+	Rot1Prog Model = "rot1prog" // azimuth only, 5-byte reply, 1200 baud
+	Rot2Prog Model = "rot2prog" // azimuth + elevation, 12-byte reply, 600 baud
+)
+
+const (
+	cmdStop   = 0x0F
+	cmdStatus = 0x1F
+	cmdSet    = 0x2F
+
+	frameStart = 0x57
+	frameEnd   = 0x20
+)
+
+// Client is one controller on one serial port.
+//
+// The port is opened per exchange rather than held: a rotator is polled every
+// few seconds at most, and holding a COM port open for the life of the program
+// is what stops an operator from using their controller's own software
+// alongside — which they will want while they are still trusting this.
+type Client struct {
+	mu    sync.Mutex
+	port  string
+	baud  int
+	model Model
+	// resolution is pulses per degree: 1, 2 or 4. The controller is configured
+	// for one of them and answers with it, so a wrong value here corrects itself
+	// on the first status read.
+	resolution byte
+}
+
+// New builds a client. baud 0 takes the model's documented default.
+func New(comPort string, baud int, model Model) *Client {
+	if model != Rot1Prog {
+		model = Rot2Prog
+	}
+	if baud <= 0 {
+		baud = 600
+		if model == Rot1Prog {
+			baud = 1200
+		}
+	}
+	return &Client{port: strings.TrimSpace(comPort), baud: baud, model: model, resolution: 1}
+}
+
+// BuildStatus frames the "where are you" command.
+func BuildStatus() []byte { return buildCmd(0, 0, 0, 0, cmdStatus) }
+
+// BuildStop frames the "stop now" command.
+func BuildStop() []byte { return buildCmd(0, 0, 0, 0, cmdStop) }
+
+// BuildSet frames a target. resolution is the controller's pulses per degree.
+//
+// Azimuth is offset by 360 before scaling, so a target of −10° and one of 350°
+// are different instructions: the first turns anticlockwise past north, the
+// second does not. Feeding a 0…359 heading in is therefore always safe.
+func BuildSet(az, el float64, resolution byte) []byte {
+	if resolution == 0 {
+		resolution = 1
+	}
+	uaz := int(float64(resolution)*(360+az) + 0.5)
+	uel := int(float64(resolution)*(360+el) + 0.5)
+	return buildCmd(uaz, uel, resolution, resolution, cmdSet)
+}
+
+func buildCmd(uaz, uel int, ph, pv byte, k byte) []byte {
+	c := make([]byte, 13)
+	c[0] = frameStart
+	if k == cmdSet {
+		c[1] = '0' + byte(uaz/1000%10)
+		c[2] = '0' + byte(uaz/100%10)
+		c[3] = '0' + byte(uaz/10%10)
+		c[4] = '0' + byte(uaz%10)
+		c[5] = ph
+		c[6] = '0' + byte(uel/1000%10)
+		c[7] = '0' + byte(uel/100%10)
+		c[8] = '0' + byte(uel/10%10)
+		c[9] = '0' + byte(uel%10)
+		c[10] = pv
+	}
+	c[11] = k
+	c[12] = frameEnd
+	return c
+}
+
+// ParseStatus decodes a reply. Returns the azimuth, the elevation (0 for
+// Rot1Prog) and the resolution the controller reported.
+func ParseStatus(buf []byte, model Model) (az, el float64, resolution byte, err error) {
+	want := 12
+	if model == Rot1Prog {
+		want = 5
+	}
+	if len(buf) < want {
+		return 0, 0, 0, fmt.Errorf("spid: short reply (%d bytes, want %d)", len(buf), want)
+	}
+	if buf[0] != frameStart || buf[want-1] != frameEnd {
+		return 0, 0, 0, fmt.Errorf("spid: not a reply frame: % X", buf[:want])
+	}
+	az = float64(buf[1])*100 + float64(buf[2])*10 + float64(buf[3])
+	if model == Rot1Prog {
+		return az - 360, 0, 1, nil
+	}
+	az += float64(buf[4]) / 10
+	el = float64(buf[6])*100 + float64(buf[7])*10 + float64(buf[8]) + float64(buf[9])/10
+	resolution = buf[5]
+	if resolution == 0 {
+		resolution = 1
+	}
+	return az - 360, el - 360, resolution, nil
+}
+
+// GoTo points the rotator at az (and el, on a Rot2Prog with elevation).
+func (c *Client) GoTo(az int, el int) error {
+	c.mu.Lock()
+	res := c.resolution
+	c.mu.Unlock()
+	e := 0.0
+	if el >= 0 && c.model == Rot2Prog {
+		e = float64(el)
+	}
+	_, err := c.exchange(BuildSet(float64(az), e, res), 0)
+	return err
+}
+
+// Stop interrupts a rotation in progress.
+func (c *Client) Stop() error {
+	// The controller answers a stop with its position, like a status — read it
+	// so the reply does not sit in the buffer and get taken for the ANSWER to
+	// the next poll, which would report a heading one command stale for ever.
+	_, err := c.exchange(BuildStop(), c.replyLen())
+	return err
+}
+
+// Heading reads the current position.
+func (c *Client) Heading() (az int, el int, err error) {
+	buf, err := c.exchange(BuildStatus(), c.replyLen())
+	if err != nil {
+		return 0, 0, err
+	}
+	a, e, res, err := ParseStatus(buf, c.model)
+	if err != nil {
+		return 0, 0, err
+	}
+	// Believe the controller about its own resolution: it is configured on the
+	// front panel, and a wrong guess here would scale every target we send.
+	c.mu.Lock()
+	c.resolution = res
+	c.mu.Unlock()
+	return int(a + 0.5), int(e + 0.5), nil
+}
+
+func (c *Client) replyLen() int {
+	if c.model == Rot1Prog {
+		return 5
+	}
+	return 12
+}
+
+// exchange opens the port, writes one frame and reads the expected reply.
+func (c *Client) exchange(cmd []byte, wantBytes int) ([]byte, error) {
+	if c.port == "" {
+		return nil, fmt.Errorf("spid: no serial port configured")
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	p, err := serial.Open(c.port, &serial.Mode{
+		BaudRate: c.baud, DataBits: 8, Parity: serial.NoParity, StopBits: serial.OneStopBit,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("spid: open %s: %w", c.port, err)
+	}
+	defer p.Close()
+	// 600 baud is 60 bytes a second: a 12-byte reply takes a fifth of a second
+	// to arrive on the wire alone, before the controller has thought about it.
+	_ = p.SetReadTimeout(2 * time.Second)
+	if _, err := p.Write(cmd); err != nil {
+		return nil, fmt.Errorf("spid: write: %w", err)
+	}
+	if wantBytes == 0 {
+		return nil, nil
+	}
+	buf := make([]byte, 0, wantBytes)
+	tmp := make([]byte, wantBytes)
+	deadline := time.Now().Add(3 * time.Second)
+	for len(buf) < wantBytes && time.Now().Before(deadline) {
+		n, err := p.Read(tmp)
+		if n > 0 {
+			buf = append(buf, tmp[:n]...)
+			continue
+		}
+		if err != nil {
+			break
+		}
+	}
+	if len(buf) < wantBytes {
+		return nil, fmt.Errorf("spid: no reply from %s (%d of %d bytes) — check the port, the baud rate (%d) and that nothing else holds the controller",
+			c.port, len(buf), wantBytes, c.baud)
+	}
+	return buf, nil
+}
diff --git a/internal/rotator/spid/spid_test.go b/internal/rotator/spid/spid_test.go
new file mode 100644
index 0000000..5be487a
--- /dev/null
+++ b/internal/rotator/spid/spid_test.go
@@ -0,0 +1,99 @@
+package spid
+
+import (
+	"math"
+	"testing"
+)
+
+// The frames are pinned against Hamlib's spid.c, the reference implementation.
+// This protocol has one trap and it is here: digits go out as ASCII and come
+// back RAW. Getting that backwards points an antenna at a heading nobody asked
+// for, and nothing in the app would notice.
+func TestSetFrameMatchesTheReference(t *testing.T) {
+	// Hamlib: u_az = PH × (360 + az), then the four decimal digits as ASCII;
+	// PH and PV raw; K = 0x2F.
+	got := BuildSet(0, 0, 1) // 360 → "0360"
+	want := []byte{0x57, '0', '3', '6', '0', 0x01, '0', '3', '6', '0', 0x01, 0x2F, 0x20}
+	assertBytes(t, "az 0 res 1", got, want)
+
+	// 90° at half-degree resolution: 2 × 450 = 900 → "0900".
+	got = BuildSet(90, 0, 2)
+	want = []byte{0x57, '0', '9', '0', '0', 0x02, '0', '7', '2', '0', 0x02, 0x2F, 0x20}
+	assertBytes(t, "az 90 res 2", got, want)
+
+	// A quarter-degree controller, 359°: 4 × 719 = 2876.
+	got = BuildSet(359, 0, 4)
+	want = []byte{0x57, '2', '8', '7', '6', 0x04, '1', '4', '4', '0', 0x04, 0x2F, 0x20}
+	assertBytes(t, "az 359 res 4", got, want)
+}
+
+// Status and stop carry no position: every data byte is zero, only K differs.
+func TestStatusAndStopFrames(t *testing.T) {
+	assertBytes(t, "status", BuildStatus(),
+		[]byte{0x57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1F, 0x20})
+	assertBytes(t, "stop", BuildStop(),
+		[]byte{0x57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0F, 0x20})
+}
+
+// A reply's digits are RAW, and the 360 offset is what lets a pulse-counting
+// controller report a rotator that has turned past north — the whole reason
+// these rotators exist.
+func TestParseStatusRot2Prog(t *testing.T) {
+	// 0x57 H1 H2 H3 H4 PH V1 V2 V3 V4 PV 0x20
+	// az digits 4,5,1,5 → 451.5 − 360 = 91.5
+	frame := []byte{0x57, 4, 5, 1, 5, 0x02, 3, 6, 0, 0, 0x02, 0x20}
+	az, el, res, err := ParseStatus(frame, Rot2Prog)
+	if err != nil {
+		t.Fatalf("ParseStatus: %v", err)
+	}
+	if math.Abs(az-91.5) > 0.001 {
+		t.Errorf("az = %v, want 91.5", az)
+	}
+	if math.Abs(el-0) > 0.001 {
+		t.Errorf("el = %v, want 0", el)
+	}
+	if res != 2 {
+		t.Errorf("resolution = %d, want 2 — the controller's own value must win", res)
+	}
+}
+
+// Rot1Prog: five bytes, three digits, no elevation.
+func TestParseStatusRot1Prog(t *testing.T) {
+	az, el, res, err := ParseStatus([]byte{0x57, 4, 5, 1, 0x20}, Rot1Prog)
+	if err != nil {
+		t.Fatalf("ParseStatus: %v", err)
+	}
+	if math.Abs(az-91) > 0.001 {
+		t.Errorf("az = %v, want 91", az)
+	}
+	if el != 0 || res != 1 {
+		t.Errorf("el = %v, res = %d — Rot1Prog has neither", el, res)
+	}
+}
+
+// A truncated or foreign frame must be refused rather than decoded into a
+// heading: half a reply read as a position turns an antenna somewhere real.
+func TestParseStatusRefusesRubbish(t *testing.T) {
+	for name, frame := range map[string][]byte{
+		"short":    {0x57, 4, 5, 1},
+		"no start": {0x00, 4, 5, 1, 5, 1, 3, 6, 0, 0, 1, 0x20},
+		"no end":   {0x57, 4, 5, 1, 5, 1, 3, 6, 0, 0, 1, 0x00},
+		"empty":    {},
+	} {
+		if _, _, _, err := ParseStatus(frame, Rot2Prog); err == nil {
+			t.Errorf("%s: decoded without complaint", name)
+		}
+	}
+}
+
+func assertBytes(t *testing.T, what string, got, want []byte) {
+	t.Helper()
+	if len(got) != len(want) {
+		t.Fatalf("%s: % X\nwant     % X", what, got, want)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("%s: % X\nwant     % X", what, got, want)
+		}
+	}
+}