Merge branch 'main' into hyacinth-range-test

Author: TheCodeinator

firmwares/flight_computer/src/bin/rocket.rs

@@ -71,18 +71,27 @@ async fn main(low_priority_spawner: Spawner) -> ! {
 
     let (can1_tx, can1_rx) = ((), ());
     let (can2_tx, can2_rx) = ((), ());
-    // let (usb_downlink, usb_uplink) = ((), ());
+    #[cfg(feature = "usb")]
     let (usb_downlink, usb_uplink) = fw::usb::start(board.usb_driver, low_priority_spawner);
+
     let (eth_downlink, eth_uplink) = fw::ethernet::start(board.ethernet, low_priority_spawner, seed);
 
-    fw::recovery::start_recovery_task(load_outputs, high_priority_spawner, &MAIN_RECOVERY_SIG, &PARABREAKS_SIG).await;
+    fw::recovery::start_recovery_task(
+        settings.main_output_settings.clone(),
+        load_outputs,
+        high_priority_spawner,
+        &MAIN_RECOVERY_SIG,
+        &PARABREAKS_SIG,
+    )
+    .await;
 
     let vehicle = Vehicle::init(
         board.sensors,
         board.outputs.leds,
         load_outputs,
         (can1_tx, can1_rx),
         (can2_tx, can2_rx),
+        #[cfg(feature = "usb")]
         (usb_downlink, usb_uplink),
         (eth_downlink, eth_uplink),
         (lora_downlink, lora_uplink),

firmwares/flight_computer/src/buzzer.rs

@@ -340,7 +340,8 @@ pub async fn run(mut pwm: SimplePwm<'static, embassy_stm32::peripherals::TIM2>,
                     FlightMode::RecoveryDrogue | FlightMode::RecoveryMain => Some(&SHORT_WARNING_MELODY),
                     FlightMode::HardwareArmed => Some(&HWARMED),
                     FlightMode::Armed | FlightMode::ArmedLaunchImminent => Some(&ARMED),
-                    FlightMode::Landed => Some(&LANDED),
+                    // FlightMode::Landed =>#[cfg(feature = "std")] Some(&LANDED),
+                    FlightMode::Idle => Some(&IDLE_AGAIN),
                     _ => None,
                 };
             }

firmwares/flight_computer/src/recovery.rs

@@ -6,25 +6,27 @@ use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::channel::{Channel, Receiver, Sender};
 use embassy_sync::signal::Signal;
 use embassy_time::{Duration, Timer};
-use shared_types::FlightMode;
+use shared_types::{FlightMode, settings::RecoveryOutputSettings};
 
 pub static MAIN_RECOVERY_SIG: Signal<CriticalSectionRawMutex, bool> = Signal::new();
 pub static PARABREAKS_SIG: Signal<CriticalSectionRawMutex, bool> = Signal::new();
 
 pub async fn start_recovery_task(
+    main_output_settings: RecoveryOutputSettings,
     load_outputs: &'static Mutex<CriticalSectionRawMutex, LoadOutputs>,
     spawner: SendSpawner,
     main_recovery_sig: &'static Signal<CriticalSectionRawMutex, bool>,
     parabreaks_sig: &'static Signal<CriticalSectionRawMutex, bool>,
 ) {
-    spawner.spawn(run_main_recovery(load_outputs, main_recovery_sig)).unwrap();
+    spawner.spawn(run_main_recovery(main_output_settings, load_outputs, main_recovery_sig)).unwrap();
     spawner.spawn(run_parabreaks(load_outputs, parabreaks_sig)).unwrap();
 }
 // TODO: add settings
 
 // TODO: check timings, add timings in settings
 #[embassy_executor::task]
 async fn run_main_recovery(
+    settings: RecoveryOutputSettings,
     load_outputs: &'static Mutex<CriticalSectionRawMutex, LoadOutputs>,
     main_recovery_sig: &'static Signal<CriticalSectionRawMutex, bool>,
 ) {
@@ -34,23 +36,22 @@ async fn run_main_recovery(
             continue;
         }
 
-        // TODO: think if should arm here
-        unsafe {
-            load_outputs.lock_mut(|o| o.arm());
-        }
-        for _ in 0..3 {
+        Timer::after(Duration::from_millis(settings.forewarning_duration.into())).await;
+
+        // Check armed status
+        for _ in 0..settings.num_pulses {
             unsafe {
                 load_outputs.lock_mut(|o| o.activate(LoadOutput::Out1));
             }
             defmt::info!("Main recovery motor active.");
 
-            Timer::after(Duration::from_millis(500)).await;
+            Timer::after(Duration::from_millis(settings.pulse_high_duration.into())).await;
             unsafe {
                 load_outputs.lock_mut(|o| o.deactivate(LoadOutput::Out1));
             }
             defmt::info!("Main recovery motor stop.");
 
-            Timer::after(Duration::from_millis(500)).await;
+            Timer::after(Duration::from_millis(settings.pause_duration.into())).await;
         }
     }
 }

firmwares/flight_computer/src/vehicle.rs

@@ -57,7 +57,7 @@ pub struct Vehicle {
 
     can1: ((), ()),
     can2: ((), ()),
-
+    #[cfg(feature = "usb")]
     usb: (
         Sender<'static, CriticalSectionRawMutex, DownlinkMessage, 3>,
         Receiver<'static, CriticalSectionRawMutex, UplinkMessage, 3>,
@@ -105,7 +105,7 @@ impl Vehicle {
         load_outputs: &'static Mutex<CriticalSectionRawMutex, LoadOutputs>,
         can1: ((), ()),
         can2: ((), ()),
-        usb: (
+        #[cfg(feature = "usb")] usb: (
             Sender<'static, CriticalSectionRawMutex, DownlinkMessage, 3>,
             Receiver<'static, CriticalSectionRawMutex, UplinkMessage, 3>,
         ),
@@ -151,6 +151,7 @@ impl Vehicle {
 
             can1,
             can2,
+            #[cfg(feature = "usb")]
             usb,
             eth,
             lora,
@@ -267,8 +268,9 @@ impl Vehicle {
                 info!("UplinkMessage: ReadSettings");
                 // let _ = self.usb.0.try_send(DownlinkMessage::Settings(self.settings.clone()));
                 let _ = self.eth.0.try_send(DownlinkMessage::Settings(self.settings.clone()));
-                // FIXME: remember to re-enable
-                // let _ = self.lora.0.try_send(DownlinkMessage::Settings(self.settings.clone()));
+
+                // FIXME: tried re-enabling, but did not work
+                let _ = self.lora.0.try_send(DownlinkMessage::Settings(self.settings.clone()));
             }
             UplinkMessage::WriteSettings(settings) => {
                 info!("UplinkMessage: WriteSettings");
@@ -312,6 +314,7 @@ impl Vehicle {
         // Send telemetry via Usb
 
         if let Some(msg) = usb_msg {
+            #[cfg(feature = "usb")]
             let _res = self.usb.0.try_send(msg);
             // match res {
             //     Ok(_) => defmt::info!("usb telemetry send successful"),
@@ -327,9 +330,10 @@ impl Vehicle {
         // Store data in flash
         self.flash.tick().await;
         if self.mode >= FlightMode::ArmedLaunchImminent {
-            if let Some(msg) = flash_msg {
-                let _ = self.flash.write_message(msg);
-            }
+            // FIXME: the impl has a bug
+            // if let Some(msg) = flash_msg {
+            //     let _ = self.flash.write_message(msg);
+            // }
         }
 
         //// Broadcast telemetry to payloads
@@ -343,14 +347,19 @@ impl Vehicle {
 
         // We are going to or beyond Armed, switch to max tx power and arm ACS
         if new_mode >= FlightMode::Armed && self.mode < FlightMode::Armed {
+            // TODO: lora max power
             //self.radio.set_max_transmit_power();
-            // TODO:
+            // TODO: think about arm AND de-arm
+            unsafe {
+                self.load_outputs.lock_mut(|o| o.arm());
+            }
+            info!("Arming Recovery");
         }
         // TODO:: move maybe
-        if self.mode == FlightMode::RecoveryDrogue {
+        if new_mode == FlightMode::RecoveryDrogue {
             self.parabreaks_sig.signal(true);
         }
-        if self.mode == FlightMode::RecoveryMain {
+        if new_mode == FlightMode::RecoveryMain {
             self.main_recovery_sig.signal(true);
         }
 

gui/src/widgets/fc_settings.rs

@@ -362,15 +362,15 @@ impl FcSettingsUiExt for Settings {
                         "pulses of"
                     });
                     ui.add(
-                        DragValue::new(&mut self.drogue_output_settings.output_high_time)
+                        DragValue::new(&mut self.drogue_output_settings.pulse_high_duration)
                             .suffix(" ms")
                             .speed(1)
-                            .range(0..=10000),
+                            .range(0..=100000),
                     );
                     if self.drogue_output_settings.num_pulses > 1 {
                         ui.weak("with");
                         ui.add(
-                            DragValue::new(&mut self.drogue_output_settings.output_low_time)
+                            DragValue::new(&mut self.drogue_output_settings.pause_duration)
                                 .suffix(" ms")
                                 .speed(1)
                                 .range(0..=10000),
@@ -380,7 +380,7 @@ impl FcSettingsUiExt for Settings {
                         ui.weak("after");
                     }
                     ui.add(
-                        DragValue::new(&mut self.drogue_output_settings.output_warning_time)
+                        DragValue::new(&mut self.drogue_output_settings.forewarning_duration)
                             .suffix(" ms")
                             .speed(1)
                             .range(0..=10000),
@@ -405,15 +405,15 @@ impl FcSettingsUiExt for Settings {
                         "pulses of"
                     });
                     ui.add(
-                        DragValue::new(&mut self.main_output_settings.output_high_time)
+                        DragValue::new(&mut self.main_output_settings.pulse_high_duration)
                             .suffix(" ms")
                             .speed(1)
                             .range(0..=10000),
                     );
                     if self.main_output_settings.num_pulses > 1 {
                         ui.weak("with");
                         ui.add(
-                            DragValue::new(&mut self.main_output_settings.output_low_time)
+                            DragValue::new(&mut self.main_output_settings.pause_duration)
                                 .suffix(" ms")
                                 .speed(1)
                                 .range(0..=10000),
@@ -423,7 +423,7 @@ impl FcSettingsUiExt for Settings {
                         ui.weak("after");
                     }
                     ui.add(
-                        DragValue::new(&mut self.main_output_settings.output_warning_time)
+                        DragValue::new(&mut self.main_output_settings.forewarning_duration)
                             .suffix(" ms")
                             .speed(1)
                             .range(0..=10000),

shared_types/src/settings.rs

@@ -154,41 +154,64 @@ pub enum Orientation {
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct RecoveryOutputSettings {
-    /// time to enable recovery outputs (after warning tone, ms)
-    pub output_high_time: u32,
-    /// time delay between recovery output pulses (ms)
-    pub output_low_time: u32,
+    /// Duration for each pulse.
+    pub pulse_high_duration: u32,
+    /// Time delay between recovery output pulses (ms)
+    pub pause_duration: u32,
     /// number of recovery output pulses
     pub num_pulses: u32,
     // TODO: unused for actual sound duration
-    /// duration of warning tone to play before enabling outputs (ms)
-    pub output_warning_time: u32,
+    /// Duration of warning tone to play before enabling outputs (ms)
+    pub forewarning_duration: u32,
     /// Warning sound frequency
     pub output_warning_frequency: f32,
 }
 
+// FIXME: fix/remove this
 impl RecoveryOutputSettings {
     pub fn total_duration(&self) -> u32 {
-        self.output_warning_time
-            + self.num_pulses * self.output_high_time
-            + (self.num_pulses - 1) * self.output_low_time
+        self.forewarning_duration
+            + self.num_pulses * self.pulse_high_duration
+            + (self.num_pulses - 1) * self.pause_duration
     }
 
     pub fn currently_high(&self, time_in_mode: u32) -> bool {
-        let phase_duration = self.output_high_time + self.output_low_time;
-        time_in_mode > self.output_warning_time
+        let phase_duration = self.pulse_high_duration + self.pause_duration;
+        time_in_mode > self.forewarning_duration
             && time_in_mode < self.total_duration()
-            && (time_in_mode - self.output_warning_time) % phase_duration < self.output_high_time
+            && (time_in_mode - self.forewarning_duration) % phase_duration < self.pulse_high_duration
     }
 }
-
+/*
 impl Default for RecoveryOutputSettings {
     fn default() -> Self {
         Self {
-            output_high_time: 500,
-            output_low_time: 0,
+            pulse_high_duration: 500,
+            pause_duration: 0,
             num_pulses: 1,
-            output_warning_time: 500,
+            forewarning_duration: 500,
+            output_warning_frequency: 500.0,
+        }
+    }
+}
+
+*/
+impl RecoveryOutputSettings {
+    fn default_main() -> Self {
+        Self {
+            pulse_high_duration: 200,
+            pause_duration: 500,
+            num_pulses: 2,
+            forewarning_duration: 500,
+            output_warning_frequency: 500.0,
+        }
+    }
+    fn default_parabreaks() -> Self {
+        Self {
+            pulse_high_duration: 16_000,
+            pause_duration: 0,
+            num_pulses: 1,
+            forewarning_duration: 500,
             output_warning_frequency: 500.0,
         }
     }
@@ -312,19 +335,8 @@ impl Default for Settings {
             apogee_min_falling_time: 100,
             main_output_mode: MainOutputMode::default(),
             main_output_deployment_altitude: 450.0,
-            drogue_output_settings: RecoveryOutputSettings {
-                output_high_time: 300,
-                output_low_time: 200,
-                num_pulses: 3,
-                output_warning_time: 200,
-                ..Default::default()
-            },
-            main_output_settings: RecoveryOutputSettings {
-                output_high_time: 200,
-                output_low_time: 500,
-                num_pulses: 3,
-                ..Default::default()
-            },
+            drogue_output_settings: RecoveryOutputSettings::default_parabreaks(),
+            main_output_settings: RecoveryOutputSettings::default_main(),
             lora: LoRaSettings::default(),
             lora_downlink_settings: LoraLinkSettings::default_downlink(),
             lora_uplink_settings: LoraLinkSettings::default_uplink(),