[cr] add support for sound trigger in rolling buffer mode

Author: jewbetcha

scripts/OpenFlightRollingBuffer.desktop

@@ -1,7 +1,7 @@
 [Desktop Entry]
 Name=OpenFlight Rolling Mode
 Comment=Golf Launch Monitor Kiosk
-Exec=lxterminal -e /home/coleman/openflight/scripts/start-kiosk.sh --mode rolling-buffer
+Exec=lxterminal -e /home/coleman/openflight/scripts/start-kiosk.sh --mode rolling-buffer --trigger sound --sound-pre-trigger 12
 Icon=applications-games
 Terminal=false
 Type=Application

scripts/start-kiosk.sh

@@ -19,6 +19,8 @@ CAMERA_IMGSZ=256
 ROBOFLOW_MODEL=""
 ROBOFLOW_API_KEY=""
 MODE=""
+TRIGGER=""
+SOUND_PRE_TRIGGER=""
 
 # Parse arguments
 while [[ $# -gt 0 ]]; do
@@ -63,6 +65,14 @@ while [[ $# -gt 0 ]]; do
             MODE="$2"
             shift 2
             ;;
+        --trigger)
+            TRIGGER="$2"
+            shift 2
+            ;;
+        --sound-pre-trigger)
+            SOUND_PRE_TRIGGER="$2"
+            shift 2
+            ;;
         --port|-p)
             PORT="$2"
             shift 2
@@ -155,6 +165,14 @@ if [ -n "$MODE" ]; then
     SERVER_CMD="$SERVER_CMD --mode $MODE"
 fi
 
+if [ -n "$TRIGGER" ]; then
+    SERVER_CMD="$SERVER_CMD --trigger $TRIGGER"
+fi
+
+if [ -n "$SOUND_PRE_TRIGGER" ]; then
+    SERVER_CMD="$SERVER_CMD --sound-pre-trigger $SOUND_PRE_TRIGGER"
+fi
+
 # Start the server
 if [ "$MOCK_MODE" = true ]; then
     log "Starting OpenFlight server on port $PORT (MOCK MODE)..."

src/openflight/ops243.py

@@ -942,6 +942,67 @@ def trigger_capture(self, timeout: float = 10.0) -> str:
 
         return full_response
 
+    def wait_for_hardware_trigger(self, timeout: float = 30.0) -> str:
+        """
+        Wait for hardware trigger to fire and read the buffer dump.
+
+        Unlike trigger_capture() which sends S!, this method just waits
+        for data to appear on serial — triggered externally via J3 pin 3
+        (HOST_INT). Used with SoundTrigger (SparkFun SEN-14262).
+
+        Args:
+            timeout: Maximum time to wait for trigger data
+
+        Returns:
+            Raw response string containing JSON lines, or empty string on timeout
+        """
+        if not self.serial or not self.serial.is_open:
+            raise ConnectionError("Not connected to radar")
+
+        # Clear any stale data
+        self.serial.reset_input_buffer()
+
+        response_lines = []
+        start_time = time.time()
+        last_data_time = None
+        bytes_received = 0
+
+        while (time.time() - start_time) < timeout:
+            if self.serial.in_waiting:
+                chunk = self.serial.read(self.serial.in_waiting)
+                response_lines.append(chunk.decode('ascii', errors='ignore'))
+                bytes_received += len(chunk)
+                last_data_time = time.time()
+
+                # Check if we have complete I/Q data
+                full_response = ''.join(response_lines)
+                if '"Q"' in full_response:
+                    q_idx = full_response.rfind('"Q"')
+                    remaining = full_response[q_idx:]
+                    if ']}' in remaining or (
+                        remaining.rstrip().endswith(']')
+                        and remaining.count('[') == remaining.count(']')
+                    ):
+                        break
+
+                time.sleep(0.01)
+            else:
+                # If we've started receiving data, use shorter timeout
+                if last_data_time and (time.time() - last_data_time) > 0.5:
+                    full_response = ''.join(response_lines)
+                    if '"Q"' in full_response:
+                        break
+                time.sleep(0.02)
+
+        full_response = ''.join(response_lines) if response_lines else ""
+
+        if not full_response:
+            logger.info("Hardware trigger: no data received within %ss", timeout)
+        else:
+            logger.info("Hardware trigger: received %d bytes", len(full_response))
+
+        return full_response
+
     def rearm_rolling_buffer(self):
         """
         Re-arm rolling buffer for next capture.

src/openflight/rolling_buffer/trigger.py

@@ -409,12 +409,97 @@ def last_trigger_speed(self) -> float:
         return self._last_trigger_speed
 
 
+class SoundTrigger(TriggerStrategy):
+    """
+    Hardware sound trigger using SparkFun SEN-14262.
+
+    Wiring: SEN-14262 GATE → OPS243-A J3 Pin 3 (HOST_INT)
+    The GATE output goes HIGH on loud sound (club impact).
+    OPS243-A uses rising edge detection on HOST_INT as trigger.
+
+    No software trigger (S!) needed — the radar triggers itself
+    via hardware. We just need to wait for data to appear on serial.
+    """
+
+    def __init__(
+        self,
+        pre_trigger_segments: int = 12,
+    ):
+        """
+        Initialize sound trigger.
+
+        Args:
+            pre_trigger_segments: Number of pre-trigger segments for S# command.
+                Each segment = 128 samples = ~4.27ms at 30ksps.
+                Default 12 gives ~51ms pre-trigger, ~85ms post-trigger.
+                Tune based on mic-to-impact distance.
+        """
+        self.pre_trigger_segments = pre_trigger_segments
+        self._split_configured = False
+
+    def wait_for_trigger(
+        self,
+        radar: "OPS243Radar",
+        processor: RollingBufferProcessor,
+        timeout: float = 30.0,
+    ) -> Optional[IQCapture]:
+        """
+        Wait for hardware sound trigger and capture buffer.
+
+        Unlike other triggers, no S! command is sent. The radar's
+        HOST_INT pin receives the trigger from the SEN-14262 GATE
+        output, causing the radar to dump its rolling buffer automatically.
+        We just block on serial read waiting for the I/Q data to arrive.
+        """
+        # Set pre-trigger split once (persists across captures)
+        if not self._split_configured:
+            radar.set_trigger_split(self.pre_trigger_segments)
+            self._split_configured = True
+
+        logger.info(
+            "Waiting for hardware sound trigger (timeout=%ss, S#%s)...",
+            timeout, self.pre_trigger_segments
+        )
+
+        response = radar.wait_for_hardware_trigger(timeout=timeout)
+
+        if not response:
+            logger.info("Sound trigger timeout - no hardware trigger received")
+            return None
+
+        logger.info("Hardware trigger fired, received %d bytes", len(response))
+
+        # Re-arm for next capture
+        radar.rearm_rolling_buffer()
+
+        capture = processor.parse_capture(response)
+
+        if capture:
+            timeline = processor.process_standard(capture)
+            outbound = [
+                r for r in timeline.readings
+                if r.is_outbound and r.speed_mph >= 15.0
+            ]
+            if outbound:
+                peak = max(r.speed_mph for r in outbound)
+                logger.info("Sound trigger capture: %d readings, peak %.1f mph",
+                           len(outbound), peak)
+            else:
+                logger.info("Sound trigger capture: no significant outbound speed")
+
+        return capture
+
+    def reset(self):
+        """Reset trigger state."""
+        self._split_configured = False
+
+
 def create_trigger(trigger_type: str = "speed", **kwargs) -> TriggerStrategy:
     """
     Factory function to create trigger strategy.
 
     Args:
-        trigger_type: "speed" (recommended), "polling", "threshold", or "manual"
+        trigger_type: "speed" (recommended), "polling", "threshold", "manual", or "sound"
         **kwargs: Arguments passed to trigger constructor
 
     Returns:
@@ -426,12 +511,14 @@ def create_trigger(trigger_type: str = "speed", **kwargs) -> TriggerStrategy:
         - "polling": Continuously capture and check for activity. Simple but slow.
         - "threshold": Speed threshold triggers capture. Less efficient than "speed".
         - "manual": External trigger for testing.
+        - "sound": Hardware sound trigger via SparkFun SEN-14262. <1ms response.
     """
     triggers = {
         "speed": SpeedTriggeredCapture,
         "polling": PollingTrigger,
         "threshold": ThresholdTrigger,
         "manual": ManualTrigger,
+        "sound": SoundTrigger,
     }
 
     if trigger_type not in triggers:

src/openflight/server.py

@@ -659,6 +659,7 @@ def start_monitor(
     mode: str = "streaming",
     trigger_type: str = "polling",
     debug: bool = False,
+    trigger_kwargs: Optional[dict] = None,
 ):
     """
     Start the launch monitor.
@@ -684,7 +685,7 @@ def start_monitor(
     elif mode == "rolling-buffer":
         # Rolling buffer mode for spin detection
         from .rolling_buffer import RollingBufferMonitor
-        monitor = RollingBufferMonitor(port=port, trigger_type=trigger_type)
+        monitor = RollingBufferMonitor(port=port, trigger_type=trigger_type, **(trigger_kwargs or {}))
         print(f"[MODE] Rolling buffer mode enabled (trigger: {trigger_type})")
     else:
         # Default streaming mode
@@ -903,10 +904,15 @@ def main():
     )
     parser.add_argument(
         "--trigger",
-        choices=["polling", "threshold"],
+        choices=["polling", "threshold", "speed", "sound"],
         default="polling",
         help="Trigger strategy for rolling-buffer mode (default: polling)"
     )
+    parser.add_argument(
+        "--sound-pre-trigger",
+        type=int, default=12,
+        help="Pre-trigger segments for sound trigger (default: 12, each ~4.27ms at 30ksps)"
+    )
     args = parser.parse_args()
 
     print("=" * 50)
@@ -947,12 +953,18 @@ def main():
         print("Raw radar readings display ENABLED - signed speed values will be shown")
 
     # Start the monitor
+    # Build trigger-specific kwargs
+    trigger_kwargs = {}
+    if args.trigger == "sound":
+        trigger_kwargs["pre_trigger_segments"] = args.sound_pre_trigger
+
     start_monitor(
         port=args.port,
         mock=args.mock,
         mode=args.mode,
         trigger_type=args.trigger,
         debug=args.debug,
+        trigger_kwargs=trigger_kwargs,
     )
 
     if args.mock: