feat: mcu-util signup cmd (#1255)

It mimics the actions performed by orb-core duting a signup.

Required for the temperature testing.

Author: sky-mart

mcu-util/src/main.rs

@@ -195,11 +195,59 @@ enum OpticsOpts {
     /// Test camera trigger for 10 seconds with default options: 30fps, IR-LEDs 100us.
     #[clap(subcommand)]
     TriggerCamera(Camera),
+    /// Replicate the MCU command sequence orb-core sends during a signup capture
+    #[clap(action)]
+    Signup(SignupOpts),
     /// Polarizer command
     #[clap(subcommand)]
     Polarizer(PolarizerOpts),
 }
 
+/// IR wavelength selection, mirrors orb_messages InfraredLEDs.Wavelength.
+#[derive(ValueEnum, Debug, Clone, Copy, PartialEq)]
+pub enum IrWavelength {
+    /// 850nm (orb-core default)
+    L850,
+    /// 940nm
+    L940,
+    /// 850nm, left side only
+    L850Left,
+    /// 850nm, right side only
+    L850Right,
+    /// 940nm, left side only
+    L940Left,
+    /// 940nm, right side only
+    L940Right,
+    /// 850nm, center only
+    L850Center,
+    /// 850nm, side only
+    L850Side,
+    /// 940nm, single emitter
+    L940Single,
+}
+
+/// Replicates orb-core's signup capture: enable IR LEDs, set FPS, start the IR
+/// eye + face camera triggers, hold for a few seconds, then stop the triggers
+/// and disable the IR LEDs.
+#[derive(Parser, Debug, Clone, Copy)]
+pub struct SignupOpts {
+    /// IR LED wavelength (orb-core uses l850)
+    #[clap(long, value_enum, default_value = "l850")]
+    wavelength: IrWavelength,
+    /// IR LED on-duration in microseconds (orb-core default is 350)
+    #[clap(long, default_value = "350")]
+    duration_us: u16,
+    /// Camera frame rate (orb-core uses 30)
+    #[clap(long, default_value = "30")]
+    fps: u32,
+    /// How long to hold the capture before tearing it down, in seconds
+    #[clap(long, default_value = "5")]
+    seconds: u64,
+    /// Also start the RGB face camera trigger (Diamond orbs)
+    #[clap(long)]
+    rgb: bool,
+}
+
 #[derive(Parser, Debug, Clone, Copy)]
 enum GimbalHomeOpts {
     /// Auto-home the gimbal by hitting the limits, more accurate but slow and noisy.
@@ -433,6 +481,9 @@ async fn execute(args: Args) -> Result<()> {
                 };
                 orb.main_board_mut().trigger_camera(camera, fps).await?
             }
+            OpticsOpts::Signup(opts) => {
+                orb.main_board_mut().signup_capture(opts).await?
+            }
             OpticsOpts::Polarizer(PolarizerOpts::Stress {
                 speed,
                 repeat,

mcu-util/src/orb/main_board.rs

@@ -10,7 +10,10 @@ use crate::orb::dfu::BlockIterator;
 use crate::orb::revision::OrbRevision;
 use crate::orb::{dfu, BatteryStatus};
 use crate::orb::{Board, OrbInfo};
-use crate::{Camera, GimbalHomeOpts, Leds, PolarizerOpts, RebootBehavior};
+use crate::{
+    Camera, GimbalHomeOpts, IrWavelength, Leds, PolarizerOpts, RebootBehavior,
+    SignupOpts,
+};
 use orb_mcu_interface::can::canfd::CanRawMessaging;
 use orb_mcu_interface::can::isotp::{CanIsoTpMessaging, IsoTpNodeIdentifier};
 use orb_mcu_interface::orb_messages;
@@ -318,6 +321,130 @@ impl MainBoard {
         Ok(())
     }
 
+    /// Replicates the MCU command sequence orb-core sends during a signup
+    /// capture: enable the IR LEDs, set the on-duration and FPS, start the IR
+    /// eye + face camera triggers, hold, then stop the triggers and disable the
+    /// IR LEDs.
+    pub async fn signup_capture(&mut self, opts: SignupOpts) -> Result<()> {
+        use main_messaging::jetson_to_mcu::Payload;
+        use orb_messages::main::infrared_le_ds::Wavelength as W;
+
+        let wavelength = match opts.wavelength {
+            IrWavelength::L850 => W::Wavelength850nm,
+            IrWavelength::L940 => W::Wavelength940nm,
+            IrWavelength::L850Left => W::Wavelength850nmLeft,
+            IrWavelength::L850Right => W::Wavelength850nmRight,
+            IrWavelength::L940Left => W::Wavelength940nmLeft,
+            IrWavelength::L940Right => W::Wavelength940nmRight,
+            IrWavelength::L850Center => W::Wavelength850nmCenter,
+            IrWavelength::L850Side => W::Wavelength850nmSide,
+            IrWavelength::L940Single => W::Wavelength940nmSingle,
+        };
+
+        // --- enable (orb-core: set_ir_wavelength, set_ir_duration, set_fps, start triggers) ---
+        self.send_checked(
+            Payload::InfraredLeds(main_messaging::InfraredLeDs {
+                wavelength: wavelength as i32,
+            }),
+            &format!("⚡️ IR LEDs enabled ({:?})", opts.wavelength),
+        )
+        .await?;
+        self.send_checked(
+            Payload::LedOnTime(main_messaging::LedOnTimeUs {
+                on_duration_us: u32::from(opts.duration_us),
+            }),
+            &format!("💡 IR LED on-duration set to {}us", opts.duration_us),
+        )
+        .await?;
+        self.send_checked(
+            Payload::Fps(main_messaging::Fps { fps: opts.fps }),
+            &format!("🎥 FPS set to {}", opts.fps),
+        )
+        .await?;
+        self.send_checked(
+            Payload::StartTriggeringIrEyeCamera(
+                main_messaging::StartTriggeringIrEyeCamera {},
+            ),
+            "📸 IR eye camera trigger started",
+        )
+        .await?;
+        self.send_checked(
+            Payload::StartTriggeringIrFaceCamera(
+                main_messaging::StartTriggeringIrFaceCamera {},
+            ),
+            "📸 IR face camera trigger started",
+        )
+        .await?;
+        if opts.rgb {
+            self.send_checked(
+                Payload::StartTriggeringRgbFaceCamera(
+                    main_messaging::StartTriggeringRgbFaceCamera {},
+                ),
+                "📸 RGB face camera trigger started",
+            )
+            .await?;
+        }
+
+        info!("⏳ holding capture for {}s ...", opts.seconds);
+        time::sleep(Duration::from_secs(opts.seconds)).await;
+
+        // --- teardown (orb-core: stop triggers, disable_ir_led) ---
+        self.send_checked(
+            Payload::StopTriggeringIrEyeCamera(
+                main_messaging::StopTriggeringIrEyeCamera {},
+            ),
+            "🛑 IR eye camera trigger stopped",
+        )
+        .await?;
+        self.send_checked(
+            Payload::StopTriggeringIrFaceCamera(
+                main_messaging::StopTriggeringIrFaceCamera {},
+            ),
+            "🛑 IR face camera trigger stopped",
+        )
+        .await?;
+        if opts.rgb {
+            self.send_checked(
+                Payload::StopTriggeringRgbFaceCamera(
+                    main_messaging::StopTriggeringRgbFaceCamera {},
+                ),
+                "🛑 RGB face camera trigger stopped",
+            )
+            .await?;
+        }
+        self.send_checked(
+            Payload::InfraredLeds(main_messaging::InfraredLeDs {
+                wavelength: W::None as i32,
+            }),
+            "🌑 IR LEDs disabled",
+        )
+        .await?;
+        self.send_checked(
+            Payload::LedOnTime(main_messaging::LedOnTimeUs { on_duration_us: 0 }),
+            "💡 IR LED on-duration reset to 0",
+        )
+        .await?;
+
+        Ok(())
+    }
+
+    /// Sends a main-MCU payload and turns a non-success ack into an error,
+    /// logging `what` on success.
+    async fn send_checked(
+        &mut self,
+        payload: main_messaging::jetson_to_mcu::Payload,
+        what: &str,
+    ) -> Result<()> {
+        match self.send(McuPayload::ToMain(payload)).await {
+            Ok(CommonAckError::Success) => {
+                info!("{}", what);
+                Ok(())
+            }
+            Ok(ack) => Err(eyre!("{what}: ack {ack:?}")),
+            Err(e) => Err(eyre!("{what}: {e:?}")),
+        }
+    }
+
     pub(crate) async fn polarizer(&mut self, opts: PolarizerOpts) -> Result<()> {
         let (command, angle) = match opts {
             PolarizerOpts::Home => (