WIP

.vscode/launch.json

@@ -94,8 +94,8 @@
             "coreConfigs": [
                 {
                     "programBinary": "${workspaceFolder}/target/thumbv7em-none-eabihf/release/nav",
-                    "rttEnabled": true,
-                    "coreIndex": 0,
+                    // "rttEnabled": true,
+                    // "coreIndex": 0,
                 }
             ]
         },

Embed.toml

@@ -10,7 +10,7 @@ protocol = "Swd"
 enabled = true
 
 [default.general]
-chip = "ATSAME51J20A"
+chip = "STM32H733VGTx"
 
 [default.probe]
 protocol = "Swd"

boards/communication/src/communication.rs

@@ -214,7 +214,7 @@ impl CanDevice0 {
                     for message in &mut self.can.rx_fifo_0 {
                         match from_bytes::<Message>(message.data()) {
                             Ok(data) => {
-                                info!("Received message {}", data.clone());
+                                // info!("Received message {}", data.clone());
 
                                 data_manager.handle_data(data);
                             }

boards/communication/src/main.rs

@@ -322,7 +322,7 @@ mod app {
     /// Handles the CAN0 interrupt.
     #[task(priority = 3, binds = CAN0, shared = [can0, data_manager])]
     fn can0(mut cx: can0::Context) {
-        info!("CAN0 interrupt");
+        // info!("CAN0 interrupt");
         cx.shared.can0.lock(|can| {
             cx.shared
                 .data_manager

boards/nav/src/main.rs

@@ -46,6 +46,7 @@ systick_monotonic!(Mono, 500);
 #[inline(never)]
 #[defmt::panic_handler]
 fn panic() -> ! {
+    // stm32h7xx_hal::pac::SCB::sys_reset()
     cortex_m::asm::udf()
 }
 
@@ -69,12 +70,13 @@ mod app {
         sbg_manager: sbg_manager::SBGManager,
         can_command_manager: CanCommandManager,
         can_data_manager: CanDataManager,
+        sbg_power: PB4<Output<PushPull>>,
+
     }
     #[local]
     struct LocalResources {
         led_red: PA2<Output<PushPull>>,
         led_green: PA3<Output<PushPull>>,
-        sbg_power: PB4<Output<PushPull>>,
     }
 
     #[init]
@@ -96,12 +98,22 @@ mod app {
         let backup = pwrcfg.backup().unwrap();
         info!("Backup domain enabled");
         // RCC
-        let rcc = ctx.device.RCC.constrain();
+        let mut rcc = ctx.device.RCC.constrain();
+        let reset = rcc.get_reset_reason();
+        info!("Reset reason: {:?}", reset);
+        // match reset {
+        //     // rcc::ResetReason::PowerOnReset => {
+        //     //     stm32h7xx_hal::pac::SCB::sys_reset();
+        //     //     info!("Power on reset");
+        //     // }
+        //     _ => {
+        //         info!("Reset reason: {:?}", reset);
+        //     }
+        // }
         let fdcan_prec_unsafe = unsafe { rcc.steal_peripheral_rec() }
             .FDCAN
             .kernel_clk_mux(rec::FdcanClkSel::Pll1Q);
 
-        info!("RCC enabled");
         let ccdr = rcc
             .use_hse(48.MHz()) // check the clock hardware
             .sys_ck(200.MHz())
@@ -148,7 +160,7 @@ mod app {
         // c0.enable();
 
         info!("PWM enabled");
-        assert_eq!(ccdr.clocks.pll1_q_ck().unwrap().raw(), 32_000_000);
+        // assert_eq!(ccdr.clocks.pll1_q_ck().unwrap().raw(), 32_000_000);
         info!("PLL1Q:");
         // https://github.com/stm32-rs/stm32h7xx-hal/issues/369 This needs to be stolen. Grrr I hate the imaturity of the stm32-hal
 
@@ -291,6 +303,7 @@ mod app {
         blink::spawn().ok();
         send_data_internal::spawn(r).ok();
         display_data::spawn(s).ok();
+        // sbg_power_on::spawn().ok();
 
         (
             SharedResources {
@@ -300,11 +313,12 @@ mod app {
                 sbg_manager,
                 can_command_manager,
                 can_data_manager,
+                sbg_power,
+
             },
             LocalResources {
                 led_red,
                 led_green,
-                sbg_power,
             },
         )
     }
@@ -384,6 +398,16 @@ mod app {
         });
     }
 
+    #[task(priority = 3, shared = [sbg_power])]
+    async fn sbg_power_on(mut cx: sbg_power_on::Context) {
+        loop {
+            cx.shared.sbg_power.lock(|sbg| {
+                sbg.set_high();
+            });
+            Mono::delay(10000.millis()).await;
+        }
+    }
+
     // Might be the wrong interrupt
     #[task(priority = 3, binds = FDCAN2_IT0, shared = [can_data_manager, data_manager])]
     fn can_data(mut cx: can_data::Context) {
@@ -436,10 +460,12 @@ mod app {
         }
     }
 
-    #[task(priority = 3, local = [sbg_power], shared = [&em])]
-    async fn sleep_system(cx: sleep_system::Context) {
+    #[task(priority = 3, shared = [&em, sbg_power])]
+    async fn sleep_system(mut cx: sleep_system::Context) {
         // Turn off the SBG and CAN, also start a timer to wake up the system. Put the chip in sleep mode.
-        cx.local.sbg_power.set_low();
+        cx.shared.sbg_power.lock(|sbg| {
+            sbg.set_low();
+        });
     }
 
     extern "Rust" {

boards/nav/src/sbg_manager.rs

@@ -108,7 +108,7 @@ impl SBGManager {
         });
         info!("Transfer started");
 
-        while !transfer.get_transfer_complete_flag() {}
+        // while !transfer.get_transfer_complete_flag() {}
         // info!("Transfer complete");
         // info!("{}", unsafe { SBG_BUFFER.assume_init_read() });
 
@@ -196,6 +196,7 @@ pub async fn sbg_sd_task(
  * Handles the SBG data.
  */
 pub fn sbg_dma(mut cx: crate::app::sbg_dma::Context) {
+    info!("DMA interrupt");
     cx.shared.sbg_manager.lock(|sbg| {
         match &mut sbg.xfer {
             Some(xfer) => {

boards/recovery/src/communication.rs

@@ -161,7 +161,7 @@ impl CanDevice0 {
                     for message in &mut self.can.rx_fifo_0 {
                         match from_bytes::<Message>(message.data()) {
                             Ok(data) => {
-                                info!("Sender: {:?}", data.clone());
+                                // info!("Sender: {:?}", data.clone());
                                 data_manager.handle_data(data)?;
                             }
                             Err(e) => {
@@ -174,7 +174,7 @@ impl CanDevice0 {
                     for message in &mut self.can.rx_fifo_1 {
                         match from_bytes::<Message>(message.data()) {
                             Ok(data) => {
-                                info!("CAN Command: {:?}", data.clone());
+                                // info!("CAN Command: {:?}", data.clone());
                                 data_manager.handle_data(data)?;
                             }
                             Err(e) => {

boards/recovery/src/main.rs

@@ -149,9 +149,13 @@ mod app {
         /* GPIO config */
         let led_green = pins.pa03.into_push_pull_output();
         let led_red = pins.pb04.into_push_pull_output();
+        let mut main_ematch = pins.pb12.into_push_pull_output();
+        main_ematch.set_high().ok();
+        loop {}
+
         let gpio = GPIOManager::new(
             // pins switched from schematic
-            pins.pb12.into_push_pull_output(),
+            main_ematch,
             pins.pb11.into_push_pull_output(),
         );
         /* State Machine config */
@@ -323,7 +327,6 @@ mod app {
     /// Handles the CAN0 interrupt.
     #[task(binds = CAN0, shared = [can0, data_manager, &em])]
     fn can0(mut cx: can0::Context) {
-        info!("CAN0 interrupt");
         cx.shared.can0.lock(|can| {
             cx.shared.data_manager.lock(|data_manager| {
                 cx.shared.em.run(|| {