Add support for PC speaker using PWM

Author: pferreir

neotron-bmc-commands/src/lib.rs

@@ -137,4 +137,24 @@ pub enum Command {
 	/// * Length: 4
 	/// * Mode: R/W
 	I2cBaudRate = 0x64,
+	/// # Speaker Duration
+	/// Duration of note, in milliseconds
+	/// * Length: 1
+	/// * Mode: R/W
+	SpeakerDuration = 0x70,
+	/// # Speaker Period (High byte)
+	/// High byte of period (in 48kHz ticks)
+	/// * Length: 1
+	/// * Mode: R/W
+	SpeakerPeriodHigh = 0x71,
+	/// # Speaker Period (High byte)
+	/// High byte of period (in 48kHz ticks)
+	/// * Length: 1
+	/// * Mode: R/W
+	SpeakerPeriodLow = 0x72,
+	/// # Speaker Duty Cycle
+	/// Speaker Duty cycle, in 1/255
+	/// * Length: 1
+	/// * Mode: R/W
+	SpeakerDutyCycle = 0x73
 }

neotron-bmc-pico/README.md

@@ -26,7 +26,7 @@ The MCU has:
 | 12   | PA6  | SPI1_CIPO   | SPI Data Output                              |
 | 13   | PA7  | SPI1_COPI   | SPI Data Input                               |
 | 14   | PB0  | LED         | Output for Power LED                         |
-| 15   | PB1  | BUZZER      | PWM Output for Buzzer                        |
+| 15   | PB1  | SPEAKER     | PWM Output for Speaker                       |
 | 18   | PA8  | IRQ_nHOST   | Interrupt Output to the Host (active low)    |
 | 19   | PA9  | USART1_TX   | UART Transmit Output                         |
 | 20   | PA10 | USART1_RX   | UART Receive Input                           |

neotron-bmc-pico/src/lib.rs

@@ -7,6 +7,7 @@ use panic_probe as _;
 use stm32f0xx_hal as _; // memory layout // panic handler
 
 pub mod ps2;
+pub mod speaker;
 pub mod spi;
 
 // same panicking *behavior* as `panic-probe` but doesn't print a panic message

neotron-bmc-pico/src/main.rs

@@ -17,7 +17,7 @@ use heapless::spsc::{Consumer, Producer, Queue};
 use rtic::app;
 use stm32f0xx_hal::{
 	gpio::gpioa::{PA10, PA11, PA12, PA15, PA2, PA3, PA4, PA8, PA9},
-	gpio::gpiob::{PB0, PB1, PB3, PB4, PB5},
+	gpio::gpiob::{PB0, PB3, PB4, PB5},
 	gpio::gpiof::{PF0, PF1},
 	gpio::{Alternate, Floating, Input, Output, PullDown, PullUp, PushPull, AF1},
 	pac,
@@ -26,7 +26,7 @@ use stm32f0xx_hal::{
 };
 
 use neotron_bmc_commands::Command;
-use neotron_bmc_pico as _;
+use neotron_bmc_pico::{self as _, speaker};
 use neotron_bmc_protocol as proto;
 
 /// Version string auto-generated by git.
@@ -66,6 +66,8 @@ pub struct RegisterState {
 	/// without re-doing a FIFO read. This happens if our response gets a CRC
 	/// error.
 	last_req: Option<proto::Request>,
+	/// The config of the speaker
+	speaker: speaker::RegisterState,
 }
 
 #[app(device = crate::pac, peripherals = true, dispatchers = [USB, USART3_4_5_6, TIM14, TIM15, TIM16, TIM17, PVD])]
@@ -94,16 +96,17 @@ mod app {
 		ResetButtonShortPress,
 		/// The UART got some data
 		UartByte(u8),
+		/// The speaker's config should be reset
+		SpeakerDisable,
 	}
 
 	#[shared]
 	struct Shared {
 		/// The power LED (D1101)
 		#[lock_free]
 		led_power: PB0<Output<PushPull>>,
-		/// The status LED (D1102)
-		#[lock_free]
-		_buzzer_pwm: PB1<Output<PushPull>>,
+		/// The speaker (J1006)
+		speaker: speaker::Hardware,
 		/// The FTDI UART header (J105)
 		#[lock_free]
 		serial: serial::Serial<pac::USART1, PA9<Alternate<AF1>>, PA10<Alternate<AF1>>>,
@@ -219,7 +222,7 @@ mod app {
 			_pin_uart_cts,
 			_pin_uart_rts,
 			mut led_power,
-			mut _buzzer_pwm,
+			_speaker_pwm,
 			button_power,
 			button_reset,
 			mut pin_dc_on,
@@ -245,8 +248,8 @@ mod app {
 				gpioa.pa12.into_alternate_af1(cs),
 				// led_power,
 				gpiob.pb0.into_push_pull_output(cs),
-				// _buzzer_pwm,
-				gpiob.pb1.into_push_pull_output(cs),
+				// speaker_pwm,
+				gpiob.pb1.into_alternate_af0(cs),
 				// button_power,
 				gpiof.pf0.into_pull_up_input(cs),
 				// button_reset,
@@ -289,8 +292,6 @@ mod app {
 		pin_irq.set_high().unwrap();
 		// Power LED is off
 		led_power.set_low().unwrap();
-		// Buzzer is off
-		_buzzer_pwm.set_low().unwrap();
 
 		defmt::info!("Creating UART...");
 
@@ -306,6 +307,10 @@ mod app {
 			&mut rcc,
 		);
 
+		led_power.set_low().unwrap();
+
+		speaker::RegisterState::default().setup(&mut rcc, &dp.TIM14);
+
 		// Set EXTI15 to use PORT A (PA15) - button input
 		dp.SYSCFG.exticr4.modify(|_r, w| w.exti15().pa15());
 
@@ -336,7 +341,7 @@ mod app {
 			_pin_uart_cts,
 			_pin_uart_rts,
 			led_power,
-			_buzzer_pwm,
+			speaker: speaker::Hardware::new(dp.TIM14),
 			button_power,
 			button_reset,
 			state_dc_power_enabled: DcPowerState::Off,
@@ -367,7 +372,7 @@ mod app {
 	/// Our idle task.
 	///
 	/// This task is called when there is nothing else to do.
-	#[idle(shared = [msg_q_out, msg_q_in, spi, state_dc_power_enabled, pin_dc_on, pin_sys_reset], local = [rcc, pin_irq])]
+	#[idle(shared = [msg_q_out, msg_q_in, spi, state_dc_power_enabled, pin_dc_on, pin_sys_reset, speaker], local = [pin_irq, rcc, speaker_task_handle: Option<speaker_pwm_stop::MyMono::SpawnHandle> = None])]
 	fn idle(mut ctx: idle::Context) -> ! {
 		// TODO: Get this from the VERSION static variable or from PKG_VERSION
 		let mut register_state = RegisterState {
@@ -436,20 +441,23 @@ mod app {
 					if ctx.shared.state_dc_power_enabled.lock(|r| *r) == DcPowerState::Off {
 						defmt::info!("Power up requested!");
 						// Button pressed - power on system.
-						// Step 1 - Note our new power state
+						// Step 1 - enable speaker and play power-up tune
+						ctx.shared.speaker.lock(|speaker| speaker.enable());
+						speaker_init_tune::spawn().unwrap();
+						// Step 2 - Note our new power state
 						ctx.shared
 							.state_dc_power_enabled
 							.lock(|r| *r = DcPowerState::Starting);
-						// Step 2 - Hold reset line (active) low
+						// Step 3 - Hold reset line (active) low
 						ctx.shared.pin_sys_reset.lock(|pin| pin.set_low().unwrap());
-						// Step 3 - Turn on PSU
+						// Step 4 - Turn on PSU
 						ctx.shared.pin_dc_on.set_high().unwrap();
-						// Step 4 - Leave it in reset for a while.
+						// Step 5 - Leave it in reset for a while.
 						// TODO: Start monitoring 3.3V and 5.0V rails here
 						// TODO: Take system out of reset when 3.3V and 5.0V are good
 						// Returns an error if it's already scheduled (but we don't care)
 						let _ = exit_reset::spawn_after(RESET_DURATION_MS.millis());
-						// Set 5 - unmask the IRQ
+						// Set 6 - unmask the IRQ
 						irq_masked = false;
 					}
 				}
@@ -469,7 +477,13 @@ mod app {
 					// Is the board powered on? Don't do a reset if it's powered off.
 					if ctx.shared.state_dc_power_enabled.lock(|r| *r) == DcPowerState::On {
 						defmt::info!("Reset!");
-						// Step 1 - Stop any SPI stuff that's currently going on (the host is about to be reset)
+						ctx.shared.pin_sys_reset.lock(|pin| pin.set_low().unwrap());
+
+						// play power-up tune
+						ctx.shared.speaker.lock(|speaker| speaker.enable());
+						speaker_init_tune::spawn().unwrap();
+
+						ctx.shared.pin_sys_reset.lock(|pin| pin.set_low().unwrap());
 						ctx.shared.spi.lock(|s| s.reset(&mut rcc));
 						// Step 2 - Hold reset line (active) low
 						ctx.shared.pin_sys_reset.lock(|pin| pin.set_low().unwrap());
@@ -532,10 +546,43 @@ mod app {
 					// TODO: Copy byte to software buffer and turn UART RX
 					// interrupt off if buffer is full
 				}
+				Some(Message::SpeakerDisable) => {
+					defmt::trace!("Speaker disabled");
+					ctx.shared.speaker.lock(|speaker| speaker.disable());
+					register_state.speaker.set_duration(0);
+				}
 				None => {
 					// No messages
 				}
 			}
+
+			// The speaker PWM needs to be updated (register was updated)
+			if register_state.speaker.needs_update() {
+				defmt::info!("speaker PWM update");
+				register_state.speaker.set_needs_update(false);
+
+				let register = &mut register_state.speaker;
+				let task_handle = ctx.local.speaker_task_handle.take();
+
+				let keep_playing = ctx.shared.speaker.lock(|speaker| {
+					speaker.update(register, || {
+						if let Some(h) = task_handle {
+							// if there's a running "stop" task, reschedule it
+							defmt::trace!("Speaker task cancelled!");
+							h.cancel().unwrap_or_default();
+						}
+					})
+				});
+
+				if keep_playing {
+					// otherwise, spawn a new one
+					defmt::trace!("Speaker task spawned!");
+					ctx.local.speaker_task_handle.replace(
+						speaker_pwm_stop::spawn_after((register.duration() as u64).millis())
+							.unwrap(),
+					);
+				}
+			}
 			// TODO: Read ADC for 3.3V and 5.0V rails and check good
 		}
 	}
@@ -602,6 +649,28 @@ mod app {
 		}
 	}
 
+	/// Initialization melody, played directly by the BMC
+	#[task(shared = [speaker, msg_q_in])]
+	fn speaker_init_tune(mut ctx: speaker_init_tune::Context) {
+		defmt::trace!("Playing startup tone");
+
+		ctx.shared.speaker.lock(|speaker| {
+			// F4
+			speaker.set_note(100, 137, 10);
+		});
+
+		speaker_pwm_stop::spawn_after(100.millis()).unwrap();
+	}
+	/// Task which stops the speaker from playing
+	#[task(shared = [msg_q_in])]
+	fn speaker_pwm_stop(mut ctx: speaker_pwm_stop::Context) {
+		defmt::trace!("Speaker stopped");
+		let _ = ctx
+			.shared
+			.msg_q_in
+			.lock(|q| q.enqueue(Message::SpeakerDisable));
+	}
+
 	/// This is the SPI1 task.
 	///
 	/// It fires whenever there is new data received on SPI1. We should flag to the host
@@ -752,6 +821,9 @@ where
 	// We were not sent what we were sent last time, so forget the previous request.
 	register_state.last_req = None;
 
+	// temporary buffer to hold serialized data while the response is generated
+	let mut data = [0u8; 1];
+
 	// What do they want?
 	let rsp = match (req.request_type, Command::try_from(req.register)) {
 		(proto::RequestType::Read, Ok(Command::ProtocolVersion))
@@ -803,6 +875,48 @@ where
 				proto::Response::new_without_data(proto::ResponseResult::BadLength)
 			}
 		}
+		(proto::RequestType::Read, Ok(Command::SpeakerDuration)) => {
+			defmt::debug!("Reading speaker duration");
+			data[0] = (register_state.speaker.duration() / 10) as u8;
+			proto::Response::new_ok_with_data(&data)
+		}
+		(proto::RequestType::ShortWrite, Ok(Command::SpeakerDuration)) => {
+			defmt::debug!("Writing speaker duration ({})", req.length_or_data);
+			register_state
+				.speaker
+				.set_duration(req.length_or_data as u16 * 10);
+			proto::Response::new_without_data(proto::ResponseResult::Ok)
+		}
+		(proto::RequestType::Read, Ok(Command::SpeakerPeriodHigh)) => {
+			defmt::debug!("Reading speaker period (high)");
+			data[0] = register_state.speaker.period_high();
+			proto::Response::new_ok_with_data(&data)
+		}
+		(proto::RequestType::ShortWrite, Ok(Command::SpeakerPeriodHigh)) => {
+			defmt::debug!("Writing speaker period (high = {})", req.length_or_data);
+			register_state.speaker.set_period_low(req.length_or_data);
+			proto::Response::new_without_data(proto::ResponseResult::Ok)
+		}
+		(proto::RequestType::Read, Ok(Command::SpeakerPeriodLow)) => {
+			defmt::debug!("Reading speaker period (low)");
+			data[0] = register_state.speaker.period_low();
+			proto::Response::new_ok_with_data(&data)
+		}
+		(proto::RequestType::ShortWrite, Ok(Command::SpeakerPeriodLow)) => {
+			defmt::debug!("Writing speaker period (low = {})", req.length_or_data);
+			register_state.speaker.set_period_high(req.length_or_data);
+			proto::Response::new_without_data(proto::ResponseResult::Ok)
+		}
+		(proto::RequestType::Read, Ok(Command::SpeakerDutyCycle)) => {
+			defmt::debug!("Reading speaker duty cycle");
+			data[0] = register_state.speaker.duty_cycle();
+			proto::Response::new_ok_with_data(&data)
+		}
+		(proto::RequestType::ShortWrite, Ok(Command::SpeakerDutyCycle)) => {
+			defmt::debug!("Writing speaker duty cycle ({})", req.length_or_data);
+			register_state.speaker.set_duty_cycle(req.length_or_data);
+			proto::Response::new_without_data(proto::ResponseResult::Ok)
+		}
 		_ => {
 			// Sorry, that register / request type is not supported
 			proto::Response::new_without_data(proto::ResponseResult::BadRegister)