feat: migrate phoenix sound & music to monorepo (#35)

mk-rw · web-flow · commit 8cd601487303 · 2025-11-28T18:11:45.000-05:00
* feat: migrate phoenix sound &amp; music to monorepo

Migrated the HAL configuration &amp; setup along with music &amp; sound from the
original phoenix code repo. Rewrote some parts to conform with the
service-style architecture for uniformity with the rest of the avionics
monorepo.

* feat: add songs, play songs indefinitely

Add some songs inherited from the original phoenix codebase, and create
a tasks that runs indefinitely, playing through all the music in
`PLAYLIST`.

Some additional code cleanups are included.

* fix: resolve linker errors and remove dead code

Import `defmt_rtt` and match crate versions with argus to fix some
linker errors. Additionally removed the heap code from `HAL.rs` since
it's entirely unused.

* fix(music): correct notes for mario theme

The Mario theme should use quarter notes rather than full notes at 120
BPM.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/boards/phoenix/.cargo/config.toml b/boards/phoenix/.cargo/config.toml
@@ -0,0 +1,9 @@
+[target.'cfg(all(target_arch = "arm", target_os = "none"))']
+runner = "probe-rs run --chip STM32H733VGTx --protocol swd"
+rustflags = ["-C", "link-arg=-Tlink.x", "-C", "link-arg=-Tdefmt.x"]
+
+[env]
+DEFMT_LOG = "debug"
+
+[build]
+target = "thumbv7em-none-eabihf"
diff --git a/boards/phoenix/Cargo.toml b/boards/phoenix/Cargo.toml
@@ -0,0 +1,43 @@
+[package]
+name = "phoenix"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+harness = false
+
+[features]
+default = ["music"]
+music = []
+
+[dependencies]
+cortex-m = { workspace = true }
+cortex-m-rt = { workspace = true }
+static_cell = "2"
+embassy-executor = { version = "0.7.0", features = [
+	"nightly",
+	"task-arena-size-10240",
+	"arch-cortex-m",
+	"executor-thread",
+	"executor-interrupt",
+	"defmt",
+] }
+embassy-stm32 = { version = "0.2.0", features = [
+	"defmt",
+	"stm32h733vg",
+	"time-driver-tim2",
+	"exti",
+	"memory-x",
+	"unstable-pac",
+	"chrono",
+] }
+embassy-sync = { version = "0.6.2", features = ["defmt"] }
+embassy-time = { version = "0.4.0", features = [
+	"defmt",
+	"defmt-timestamp-uptime",
+	"tick-hz-32_768",
+] }
+embedded-alloc = { workspace = true }
+defmt = { workspace = true }
+defmt-rtt = { workspace = true }
+panic-probe = { workspace = true }
diff --git a/boards/phoenix/rust-toolchain.toml b/boards/phoenix/rust-toolchain.toml
@@ -0,0 +1,3 @@
+[toolchain]
+channel = "nightly"
+targets = ["thumbv7em-none-eabihf"]
diff --git a/boards/phoenix/src/lib.rs b/boards/phoenix/src/lib.rs
@@ -0,0 +1,7 @@
+#![no_std]
+#![feature(impl_trait_in_assoc_type)]
+
+#[cfg(feature = "music")]
+pub mod music;
+pub mod sound;
+pub mod utils;
diff --git a/boards/phoenix/src/main.rs b/boards/phoenix/src/main.rs
@@ -0,0 +1,37 @@
+#![no_std]
+#![no_main]
+#![feature(impl_trait_in_assoc_type)]
+
+use defmt::info;
+use defmt_rtt as _;
+use embassy_executor::Spawner;
+use panic_probe as _;
+use phoenix::{
+	sound::service::SoundService,
+	utils::{hal::configure_hal, types::AsyncMutex},
+};
+use static_cell::StaticCell;
+
+/// To change the pin used for sound, see [phoenix::sound::types]
+static SOUND_SERVICE: StaticCell<AsyncMutex<SoundService>> = StaticCell::new();
+#[cfg(feature = "music")]
+static MUSIC_SERVICE: StaticCell<AsyncMutex<phoenix::music::service::MusicService>> = StaticCell::new();
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+	info!("Starting up...");
+	let p = configure_hal();
+
+	let sound = SOUND_SERVICE.init(AsyncMutex::new(SoundService::new(p.TIM3, p.PC6)));
+
+	#[cfg(feature = "music")]
+	{
+		use defmt::error;
+		use phoenix::music::{service::MusicService, tasks::play_music_forever};
+		let music = MUSIC_SERVICE.init(AsyncMutex::new(MusicService::new(sound)));
+		match spawner.spawn(play_music_forever(music)) {
+			Ok(_) => (),
+			Err(e) => error!("Could not spawn music task: {}", e),
+		}
+	}
+}
diff --git a/boards/phoenix/src/music/mod.rs b/boards/phoenix/src/music/mod.rs
@@ -0,0 +1,9 @@
+//! Music playback for Phoenix.
+//!
+//! This module provides functionality for playing music and sound effects using a PWM buzzer.
+//! Some provided songs are included in [songs].
+
+pub mod service;
+pub mod songs;
+pub mod tasks;
+pub mod types;
diff --git a/boards/phoenix/src/music/service.rs b/boards/phoenix/src/music/service.rs
@@ -0,0 +1,35 @@
+//! Playback of some simple songs with the buzzer
+use embassy_time::Timer;
+
+use crate::{
+	music::types::{Melody, Note},
+	sound::service::SoundService,
+	utils::types::AsyncMutex,
+};
+
+pub struct MusicService {
+	sound_service: &'static AsyncMutex<SoundService>,
+}
+
+impl MusicService {
+	pub fn new(sound_service: &'static AsyncMutex<SoundService>) -> Self {
+		Self { sound_service }
+	}
+
+	pub async fn play_song(
+		&self,
+		song: Melody,
+		tempo: f32,
+	) {
+		let beat_length = 60_000f32 / tempo;
+		let mut sound = self.sound_service.lock().await;
+
+		for (note, length) in song {
+			let duration = (length * beat_length) as u64;
+			match note {
+				Note::Pitch(freq) => sound.play_pitch(*freq as u32, duration).await,
+				Note::Rest => Timer::after_millis(duration).await,
+			}
+		}
+	}
+}
diff --git a/boards/phoenix/src/music/songs.rs b/boards/phoenix/src/music/songs.rs
@@ -0,0 +1,52 @@
+//! A bunch of songs to play with the buzzer.
+use Note::{Pitch, Rest};
+
+use crate::music::types::Melody;
+use crate::music::types::Note;
+
+pub const A4: Note = Pitch(440);
+pub const C4: Note = Pitch(262);
+pub const D4: Note = Pitch(294);
+pub const E4: Note = Pitch(330);
+pub const F4: Note = Pitch(349);
+pub const G4: Note = Pitch(392);
+pub const C5: Note = Pitch(523);
+pub const E5: Note = Pitch(659);
+pub const G5: Note = Pitch(784);
+
+pub const TEMPO: f32 = 120.0;
+pub const PLAYLIST: [Melody; 2] = [MARIO_MELODY, TWINKLE_MELODY];
+
+pub const MARIO_MELODY: Melody = &[
+	(E5, 0.25),
+	(E5, 0.25),
+	(Rest, 0.25),
+	(E5, 0.25),
+	(Rest, 0.25),
+	(C5, 0.25),
+	(E5, 0.25),
+	(Rest, 0.25),
+	(G5, 0.5),
+	(Rest, 0.5),
+	(G4, 0.5),
+	(Rest, 0.5),
+];
+
+/// Melody for "Twinkle, Twinkle, Little Star"
+pub const TWINKLE_MELODY: Melody = &[
+	(C4, 1.0),
+	(C4, 1.0),
+	(G4, 1.0),
+	(G4, 1.0),
+	(A4, 1.0),
+	(A4, 1.0),
+	(G4, 2.0),
+	(Rest, 0.5),
+	(F4, 1.0),
+	(F4, 1.0),
+	(E4, 1.0),
+	(E4, 1.0),
+	(D4, 1.0),
+	(D4, 1.0),
+	(C4, 2.0),
+];
diff --git a/boards/phoenix/src/music/tasks.rs b/boards/phoenix/src/music/tasks.rs
@@ -0,0 +1,15 @@
+use crate::{
+	music::{
+		service::MusicService,
+		songs::{PLAYLIST, TEMPO},
+	},
+	utils::types::AsyncMutex,
+};
+
+#[embassy_executor::task]
+pub async fn play_music_forever(music: &'static AsyncMutex<MusicService>) {
+	for song in PLAYLIST.iter().cycle() {
+		let guard = music.lock().await;
+		guard.play_song(song, TEMPO).await;
+	}
+}
diff --git a/boards/phoenix/src/music/types.rs b/boards/phoenix/src/music/types.rs
@@ -0,0 +1,10 @@
+/// A note, representing either a pitch (with a frequency in Hz), or a rest.
+// NOTE: Derive Copy since it's basically just a cheap integer copy
+#[derive(Clone, Copy)]
+pub enum Note {
+	Pitch(u16),
+	Rest,
+}
+
+/// An array of notes with a length, in beats.
+pub type Melody = &'static [(Note, f32)];
diff --git a/boards/phoenix/src/sound/mod.rs b/boards/phoenix/src/sound/mod.rs
@@ -0,0 +1,6 @@
+//! Simple sound output via the onboard buzzer.
+//!
+//! For more complex sound output, see [crate::music].
+
+pub mod service;
+pub mod types;
diff --git a/boards/phoenix/src/sound/service.rs b/boards/phoenix/src/sound/service.rs
@@ -0,0 +1,80 @@
+use embassy_stm32::{
+	Peripheral,
+	gpio::OutputType,
+	time::{Hertz, khz},
+	timer::{
+		Channel1Pin,
+		simple_pwm::{PwmPin, SimplePwm},
+	},
+};
+use embassy_time::Timer;
+
+use crate::sound::types::TimerPin;
+
+/// Play sounds using a PWM buzzer.
+///
+/// Due to there being no equivalent of what `AnyPin` is to GPIO pins for timer pins, the timer
+/// picked has to be hard-coded in [TimerPin].
+pub struct SoundService {
+	pwm: SimplePwm<'static, TimerPin>,
+}
+
+impl SoundService {
+	pub fn new(
+		pin: impl Peripheral<P = TimerPin> + 'static,
+		buzzer: impl Peripheral<P = impl Channel1Pin<TimerPin>> + 'static,
+	) -> Self {
+		let buzz_out_pin = PwmPin::new_ch1(buzzer, OutputType::PushPull);
+		let pwm = SimplePwm::new(pin, Some(buzz_out_pin), None, None, None, khz(4), Default::default());
+		let mut sound_service = Self { pwm };
+		// Set the volume to 100% by default
+		sound_service.set_volume(100).unwrap();
+
+		sound_service
+	}
+
+	/// Play some pitch with a frequency of `freq` Hz, for `duration` ms.
+	pub async fn play_pitch(
+		&mut self,
+		freq: u32,
+		duration: u64,
+	) {
+		self.pwm.set_frequency(Hertz::hz(freq));
+		self.pwm.ch1().enable();
+		Timer::after_millis(duration).await;
+		self.pwm.ch1().disable();
+	}
+
+	/// Set the duty cycle of the buzzer to change output volume.
+	///
+	/// 100% volume is equal to 50% duty cycle, 0% is 0% duty cycle.
+	/// Returns `Err(())` if the value is invalid (> 100). For an unchecked variant prone to
+	/// panicking, see [SoundService::set_volume_unchecked]
+	pub fn set_volume(
+		&mut self,
+		volume_percent: u8,
+	) -> Result<(), u8> {
+		// Technically since volume percentage is half of duty cycle percentage, it's
+		// allowable to go up to 200% (Although it makes no real difference)
+		if volume_percent > 200 {
+			// For now just return the delta in volume
+			return Err(volume_percent - 200);
+		}
+
+		self.set_volume_unchecked(volume_percent);
+
+		Ok(())
+	}
+
+	/// Set the duty cycle of the buzzer to change output volume.
+	///
+	/// See [SoundService::set_volume] for a checked variant which returns a [Result]
+	/// rather than panic on an invalid value.
+	pub fn set_volume_unchecked(
+		&mut self,
+		volume_percent: u8,
+	) {
+		let duty_cycle_percent = volume_percent / 2;
+		self.pwm.ch1().set_duty_cycle_percent(duty_cycle_percent);
+	}
+}
diff --git a/boards/phoenix/src/sound/types.rs b/boards/phoenix/src/sound/types.rs
@@ -0,0 +1,4 @@
+use embassy_stm32::peripherals::TIM3;
+
+/// The timer used in [super::service::SoundService](SoundService)
+pub type TimerPin = TIM3;
diff --git a/boards/phoenix/src/utils/hal.rs b/boards/phoenix/src/utils/hal.rs
@@ -0,0 +1,48 @@
+//! Setup and configuration of the HAL.
+use embassy_stm32::{
+	Config, Peripherals, init,
+	rcc::{AHBPrescaler, APBPrescaler, HSIPrescaler, Pll, PllDiv, PllMul, PllPreDiv, PllSource, Sysclk, VoltageScale},
+};
+
+pub fn configure_hal() -> Peripherals {
+	let mut config = Config::default();
+
+	// Clock configuration
+	//
+	config.rcc.hsi = Some(HSIPrescaler::DIV1);
+	config.rcc.csi = true;
+
+	config.rcc.pll1 = Some(Pll {
+		source: PllSource::HSI,
+		prediv: PllPreDiv::DIV4,
+		mul: PllMul::MUL50,
+		divp: Some(PllDiv::DIV2),
+		divq: Some(PllDiv::DIV8),
+		divr: None,
+	});
+	config.rcc.pll2 = Some(Pll {
+		source: PllSource::HSI,
+		prediv: PllPreDiv::DIV4,
+		mul: PllMul::MUL50,
+		divp: Some(PllDiv::DIV2),
+		divq: Some(PllDiv::DIV8),
+		divr: None,
+	});
+	config.rcc.pll3 = Some(Pll {
+		source: PllSource::HSI,
+		prediv: PllPreDiv::DIV4,
+		mul: PllMul::MUL50,
+		divp: Some(PllDiv::DIV2),
+		divq: Some(PllDiv::DIV8),
+		divr: None,
+	});
+	config.rcc.sys = Sysclk::PLL1_P; // 400 Mhz
+	config.rcc.ahb_pre = AHBPrescaler::DIV2; // 200 Mhz
+	config.rcc.apb1_pre = APBPrescaler::DIV2; // 100 Mhz
+	config.rcc.apb2_pre = APBPrescaler::DIV2; // 100 Mhz
+	config.rcc.apb3_pre = APBPrescaler::DIV2; // 100 Mhz
+	config.rcc.apb4_pre = APBPrescaler::DIV2; // 100 Mhz
+	config.rcc.voltage_scale = VoltageScale::Scale1;
+
+	init(config)
+}
diff --git a/boards/phoenix/src/utils/mod.rs b/boards/phoenix/src/utils/mod.rs
@@ -0,0 +1,2 @@
+pub mod hal;
+pub mod types;
diff --git a/boards/phoenix/src/utils/types.rs b/boards/phoenix/src/utils/types.rs

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+[toolchain]`
	`2`	`+channel = "nightly"`
	`3`	`+targets = ["thumbv7em-none-eabihf"]`