Embassy ERS

.gitignore

@@ -45,3 +45,4 @@ fp-info-cache
 # Rust generated files
 controlSystem/RecoveryBoard/firmware-rs/target
 controlSystem/RecoveryBoard/firmware-rs/Cargo.lock
+controlSystem/RecoveryBoard/firmware-rs/__pycache__

controlSystem/RecoveryBoard/firmware-rs/.cargo/config.toml

@@ -1,6 +1,10 @@
 [target.thumbv6m-none-eabi]
 runner = 'probe-rs run --chip STM32F091RCTX'
 
+[alias]
+sender = "run -r --bin sender"
+parachute = "run -r --bin parachute"
+
 [build]
 target = "thumbv6m-none-eabi"
 

controlSystem/RecoveryBoard/firmware-rs/Cargo.toml

@@ -21,6 +21,17 @@ embedded-hal-nb = "1.0.0"
 noline = "0.5.1"
 heapless = "0.9.1"
 format_no_std = "1.2.0"
+embedded-test-linker-script = { version = "0.1.0" }
+
+[dev-dependencies]
+embedded-test = { version = "0.7.0", features=["embassy", "defmt"] }
+
+[lib]
+harness = false # Important: As we bring our own test harness for all tests
+
+[[test]]
+name = "blinky"
+harness = false
 
 [profile.release]
 debug = 2

controlSystem/RecoveryBoard/firmware-rs/README.md

@@ -23,6 +23,8 @@ With all the dependencies installed, you should now be able to navigate to the d
 cargo run --bin blinky --release
 ```
 
+If you are flashing blinky directly onto one of the ERS boards, you will need to set the BOARD environment variable to `"main"`.
+
 After it builds, terminal output should look like this if everything went according to plan:
 
 ```bash
@@ -38,3 +40,25 @@ Programming ✔ 100% [####################]  15.00 KiB @  20.53 KiB/s (took 1s)
 ```
 
 and the led should be blinking.
+
+## Flashing
+
+The commands to flash the binaries are as follows:
+
+*Sender*:
+
+```rust
+cargo sender
+```
+
+*Drogue parachute*:
+
+```rust
+BOARD=drogue cargo parachute
+```
+
+*Main parachute*:
+
+```rust
+BOARD=main cargo parachute
+```

controlSystem/RecoveryBoard/firmware-rs/build.rs

@@ -1,5 +1,21 @@
+use std::env;
+
 fn main() {
+    println!("cargo::rerun-if-env-changed=BOARD");
     println!("cargo:rustc-link-arg-bins=--nmagic");
     println!("cargo:rustc-link-arg-bins=-Tlink.x");
     println!("cargo:rustc-link-arg-bins=-Tdefmt.x");
+    println!("cargo::rustc-link-arg=-Tembedded-test.x");
+    println!("cargo:rustc-link-arg-tests=-Tdefmt.x");
+    println!("cargo:rustc-link-arg-tests=-Tlink.x");
+
+    println!("cargo::rustc-check-cfg=cfg(drogue,main)");
+    if let Ok(board) = env::var("BOARD") {
+        if board == "drogue" {
+            println!("cargo::rustc-cfg=drogue");
+        }
+        if board == "main" {
+            println!("cargo::rustc-cfg=main");
+        }
+    }
 }

controlSystem/RecoveryBoard/firmware-rs/echo_can.py

@@ -0,0 +1,52 @@
+"""
+This script is used to test that your can bus is set up properly.
+With a VulCAN plugged in, run this script in one terminal,
+making sure to pass in the proper path to the VulCAN with the `-d` flag.
+Then have the ERS board or Nucleo run the `echo_can` task in another.
+You should see the two boards echoing CAN messages back and forth.
+* Requires python-can v4.5, pySerial v3.5 *
+"""
+
+import can
+import argparse
+import logging
+from typing import cast
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(
+    format="%(asctime)s - [%(levelname)s]: %(message)s",
+    datefmt="%H:%M:%S",
+    level=logging.INFO,
+)
+
+parser = argparse.ArgumentParser(
+    prog="VulCAN Tester",
+    description="Send or Receive messages via CAN using a VulCAN adapter",
+)
+
+_ = parser.add_argument("--device", "-d", required=True, help="Path to VulCAN")
+
+args = parser.parse_args()
+
+# Ensure proper arg types
+device = cast(str, args.device)
+device = str(device)
+
+
+def main():
+    logger.info("Connecting to VulCAN")
+    bitrate = 1e6
+
+    # Configure the connection to the VulCAN
+    bus = can.interface.Bus(channel="can0", interface="socketcan", bitrate=bitrate)
+
+    logger.info("Echoing CAN messages")
+    while True:
+        message = bus.recv(timeout=None)
+        if message:
+            bus.send(message)
+            logger.info("Echoed message: %s", message)
+
+
+if __name__ == "__main__":
+    main()

controlSystem/RecoveryBoard/firmware-rs/spoof_ers_can.py

@@ -1,4 +1,11 @@
-# Requires python-can v4.5, pySerial v3.5
+"""
+This script uses the Vulcan to spoof the other two parachute boards when you only have one board to use.
+It's purpose is to test that the sender board is functioning properly.
+Make sure to pass in the path to your Vulcan with the `-d` flag when invoking this script.
+You should see that the Vulcan is sending good status messages over the CAN bus that match both drogue and main parachute board heartbeat IDs.
+* Requires python-can v4.5, pySerial v3.5 *
+"""
+
 import can
 import time
 import argparse
@@ -33,17 +40,26 @@ def main():
     # Configure the connection to the VulCAN
     bus = can.interface.Bus(channel="can0", interface="socketcan", bitrate=bitrate)
 
+    status_buf = [
+        2,  # Ring locked
+        100,  # Battery voltage in 0.1 volts (> 9.9v is good)
+        1,  # Batt_ok == True
+        1,  # Shore power Off == true
+        1,  # Received sender message in last two seconds
+        1,  # Board is ready to release parachute
+        0,  # unused
+        0,  # unused
+    ]
+
     while True:
         message_id = 0x710
-        data_bytes = [0x01]
         msg = can.Message(
-            arbitration_id=message_id, data=data_bytes, is_extended_id=False
+            arbitration_id=message_id, data=status_buf, is_extended_id=False
         )
         bus.send(msg)
         message2_id = 0x720
-        data_bytes2 = [0x01]
         msg2 = can.Message(
-            arbitration_id=message2_id, data=data_bytes2, is_extended_id=False
+            arbitration_id=message2_id, data=status_buf, is_extended_id=False
         )
         bus.send(msg2)
         logger.info("Sent messages: %s %s", msg, msg2)