Crane2026_LPV_STM32F3_Rust

This repository contains firmware for the Low Profile Vessel (LPV) controller implemented in Rust on the STM32F3Discovery board.
It is part of the broader Crane 2026 project, focusing on autonomous and semi-autonomous embedded control of LPV systems using CAN bus communication, RC input, PWM outputs, and safe real-time scheduling.

Unlike the Crane2026_LPV_STM32F3 (C/FreeRTOS) project, this repository:

Uses Rust with the RTIC (Real-Time Interrupt-driven Concurrency) framework.
Employs bxCAN for CAN communication with filtering and FIFO0 interrupt handling.
Relies on stm32f3xx-hal and embedded-hal crates instead of STM32CubeMX auto-generated code.
Demonstrates memory-safe concurrency with RTIC shared resources.

It also includes examples such as LED blinking (PE9) to verify the Rust + RTIC toolchain setup.

Features

🚦 CAN Communication
- Transmit LPV command messages (ID 0x05) on button press.
- Receive Jetson PWM commands (ID 0x09) via bxCAN.
🎮 RC Receiver
- Interprets IA6S RC receiver data via USART1 (PA9/PA10) and EXTI-based PWM capture (PB8/PB9).
⚙️ PWM Outputs
- Generates actuator control signals on TIM4 (PB6, PB7).
🔄 Concurrency with RTIC
- Deterministic task scheduling with #[task(binds = ...)].
- Shared resources for CAN and PWM channels.
💡 LED Blink Demo
- Onboard LED (PE9) toggled at intervals to validate toolchain setup.
🧰 Multiple Rust Toolchain Options
- OpenOCD + GDB
- cargo-embed + GDB
- probe-rs + VS Code

Hardware

Development Board

STM32F3Discovery (STM32F303VCT6)

Interfaces

CAN Bus
- PD0 → CAN_RX
- PD1 → CAN_TX
- Configured with FIFO0 RX interrupt
PWM Outputs (Timer 4)
- PB6 → TIM4_CH1
- PB7 → TIM4_CH2
USART1 (IA6B RC Receiver)
- PA9 → USART1_TX
- PA10 → USART1_RX
External Interrupt Inputs
- PB8 → RC channel input (EXTI)
- PB9 → RC channel input (EXTI)
Onboard LED
- PE9 → Blinky demo
User Button
- Key 2 → triggers CAN TX (ID 0x05)

Software Requirements

Rust toolchain with embedded targets:
```
rustup target add thumbv7em-none-eabihf
```
arm-none-eabi-gcc (linking support)
Debug tools:
- OpenOCD + arm-none-eabi-gdb, or
- cargo-embed + arm-none-eabi-gdb, or
- probe-rs + VS Code

Install probe-rs tools if needed:

cargo install probe-rs-tools --locked

How to Build, Flash, and Debug

Option A: OpenOCD + GDB

Start OpenOCD:

c:\Openocd\openocd -f interface/stlink.cfg -f target/stm32f3x.cfg

Edit .cargo/config.toml and set:

runner = "arm-none-eabi-gdb -q -x openocd.gdb"

Run:
```
cargo run
```
⚠️ OpenOCD requires load inside openocd.gdb to flash the MCU.

Option B: cargo-embed + GDB

Start cargo-embed:
```
cargo embed
```

Edit .cargo/config.toml and set:

runner = "arm-none-eabi-gdb -q -x embed.gdb"

Run:
```
cargo run
```
✅ cargo-embed can both flash and run.

Option C: probe-rs + VS Code

Install the Debugger for probe-rs extension.
Open the project folder in VS Code, then open main.rs.
Press F5 to build and debug.

CAN Message Table

Message ID	Direction	Data Format / Description
0x05	TX	LPV Commands (3 bytes): • Byte[0] = `lpv_mode` (0=Manual, 1=Automatic) • Byte[1] = Mission ID • Byte[2] = Mission color
0x09	RX	PWM Commands from Jetson (4 bytes): • Byte[0–1] = Left motor PWM (16-bit) • Byte[2–3] = Right motor PWM (16-bit)

Examples

01 02 03 → Automatic, Mission=2, Color=3
03 E8 07 D0 → Left=1000, Right=2000

Repository Structure

Crane2026_LPV_STM32F3_Rust/
├── .cargo/
│   └── config.toml       # Runner configuration
├── .vscode/              # VS Code integration
│   ├── launch.json
│   └── tasks.json
├── src/
│   └── main.rs           # RTIC + HAL application code
├── memory.x              # Linker script
├── Cargo.toml            # Rust manifest
├── openocd.gdb           # OpenOCD + gdb script
├── embed.gdb             # cargo-embed + gdb script
├── .probe-rs.yaml        # probe-rs config
└── README.md             # This file

Behavior Description

RTIC CAN Task
- Bound to USB_LP_CAN_RX0 interrupt, reads incoming frames.
PWM Task
- Updates motor PWM via TIM4_CH1/CH2.
RC Task
- Decodes IA6S RC receiver inputs.
Blinky Demo
- Toggles LED (PE9) to confirm toolchain/debug pipeline.

References

License

This project is intended for educational and research use under the Crane 2026 program.
Refer to the repository for full licensing details.

Big-picture Summary of System Behavior

USART1 → iBUS Input
- The USART1 interrupt (priority 3) only drains RX bytes and enqueues them into a queue.
- Parsing into full iBUS frames and applying logic is deferred to a lower-priority task (process_rx).
- 👉 Keeping the ISR short reduces interrupt latency and prevents blocking other ISRs (like CAN RX).
process_rx Task
- Consumes enqueued bytes, assembles iBUS frames, and decodes channels.
- If in Manual mode, steering and throttle are mixed into left/right PWM signals immediately.
- If in Automatic mode, PWM updates are ignored here and left to CAN messages.
handle_ibus Task
- Interprets switch states for mode, mission, and color selection.
- On a Key-2 button press, sends a 3‑byte CAN message (CTRLID=0x05) with (mode, mission, color).
CAN RX ISR
- Handles PWMID=0x09 messages with two 16‑bit pulse widths.
- In Automatic mode, directly updates TIM4 PWM outputs (PB6/PB7).
PWM Outputs
- TIM4 CH1/CH2 run at 50 Hz (20 ms period), clamped between 1000–2000 µs.
- Manual → driven by iBUS, Automatic → driven by CAN RX.
Why short ISR design?
- You could do all parsing inside the USART ISR, but that would make it long and increase latency.
- The chosen design—short ISR + spawned consumer task—keeps the system more responsive and avoids starving CAN RX interrupts.

wang32/stm32f3_lpv_rtic

About

Resources

Stars

Watchers

Forks

Releases

Languages