Speak new SPI protocol.

Author: jonathanpallant

neotron-bmc-pico/Cargo.toml

@@ -13,6 +13,7 @@ defmt-rtt = "0.3"
 heapless= "0.7"
 panic-probe = { version = "0.3", features = ["print-defmt"] }
 stm32f0xx-hal = { version = "0.17", features = ["stm32f030x6", "rt"] }
+neotron-bmc-protocol = { path = "../neotron-bmc-protocol" }
 systick-monotonic = "1.0"
 embedded-hal = "*"
 

neotron-bmc-pico/src/main.rs

@@ -24,6 +24,7 @@ use stm32f0xx_hal::{
 };
 
 use neotron_bmc_pico as _;
+use neotron_bmc_protocol as proto;
 
 /// Version string auto-generated by git.
 static VERSION: &'static str = include_str!(concat!(env!("OUT_DIR"), "/version.txt"));
@@ -52,7 +53,7 @@ pub enum DcPowerState {
 /// This is our system state, as accessible via SPI reads and writes.
 #[derive(Debug)]
 pub struct RegisterState {
-	firmware_version: &'static str,
+	firmware_version: [u8; 32],
 }
 
 #[app(device = crate::pac, peripherals = true, dispatchers = [USB, USART3_4_5_6, TIM14, TIM15, TIM16, TIM17, PVD])]
@@ -303,7 +304,8 @@ mod app {
 			_ps2_dat1,
 			exti: dp.EXTI,
 			register_state: RegisterState {
-				firmware_version: concat!("Neotron BMC ", env!("CARGO_PKG_VERSION")),
+				firmware_version:
+					*b"Neotron BMC v0.3.1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
 			},
 			kb_q_out,
 			spi,
@@ -323,7 +325,7 @@ mod app {
 	/// Our idle task.
 	///
 	/// This task is called when there is nothing else to do.
-	#[idle(shared = [kb_q_out, spi])]
+	#[idle(shared = [kb_q_out, spi, register_state])]
 	fn idle(mut ctx: idle::Context) -> ! {
 		defmt::info!("Idle is running...");
 		loop {
@@ -335,27 +337,63 @@ mod app {
 				}
 			}
 
-			let mut rx_buffer = [0u8; 3];
-			let mut has_packet = false;
+			let mut req = None;
 			ctx.shared.spi.lock(|spi| {
 				let mut mark_done = false;
 				if let Some(data) = spi.get_received() {
-					if data.len() == 3 {
-						rx_buffer.copy_from_slice(data);
-						mark_done = true;
-						has_packet = true;
+					use proto::Receivable;
+					match proto::Request::from_bytes(data) {
+						Ok(inner_req) => {
+							mark_done = true;
+							req = Some(inner_req);
+						}
+						Err(proto::Error::BadLength) => {
+							// Need more data
+						}
+						Err(e) => {
+							defmt::warn!("Bad Req ({:02x})", e as u8);
+							mark_done = true;
+						}
 					}
 				}
 				if mark_done {
-					spi.set_transmit(&[0x11, 0x22, 0x33, 0x44, 0x55, 0x66])
-						.unwrap();
+					// Couldn't do this whilst holding the `data` ref.
 					spi.mark_done();
 				}
 			});
-			if has_packet {
-				if rx_buffer != [0xAA, 0x10, 0x01] {
-					defmt::info!("Bad RX {:?}", rx_buffer);
-				}
+
+			match req {
+				Some(req) => match req.request_type {
+					proto::RequestType::Read | proto::RequestType::ReadAlt => {
+						let rsp = match req.register {
+							0x00 => {
+								let length = req.length_or_data as usize;
+								if length > ctx.shared.register_state.firmware_version.len() {
+									proto::Response::new_without_data(
+										proto::ResponseResult::BadLength,
+									)
+								} else {
+									let bytes = &ctx.shared.register_state.firmware_version;
+									proto::Response::new_ok_with_data(&bytes[0..length])
+								}
+							}
+							_ => proto::Response::new_without_data(
+								proto::ResponseResult::BadRegister,
+							),
+						};
+						ctx.shared.spi.lock(|spi| {
+							spi.set_transmit_sendable(&rsp).unwrap();
+						});
+					}
+					_ => {
+						let rsp =
+							proto::Response::new_without_data(proto::ResponseResult::BadLength);
+						ctx.shared.spi.lock(|spi| {
+							spi.set_transmit_sendable(&rsp).unwrap();
+						});
+					}
+				},
+				None => {}
 			}
 
 			// TODO: Read ADC for 3.3V and 5.0V rails and check good
@@ -421,7 +459,7 @@ mod app {
 	///
 	/// It fires whenever there is new data received on SPI1. We should flag to the host
 	/// that data is available.
-	#[task(binds = SPI1, shared = [spi, register_state])]
+	#[task(binds = SPI1, shared = [spi])]
 	fn spi1_interrupt(mut ctx: spi1_interrupt::Context) {
 		ctx.shared.spi.lock(|spi| {
 			spi.handle_isr();

neotron-bmc-pico/src/spi.rs

@@ -3,8 +3,6 @@
 //! Unlike the HAL, this implement 'SPI Peripheral Mode', i.e. for when the
 //! clock signal is an input and not an output.
 
-use core::convert::TryInto;
-
 use stm32f0xx_hal::{pac, prelude::*, rcc::Rcc};
 
 pub struct SpiPeripheral<const RXC: usize, const TXC: usize> {
@@ -143,35 +141,17 @@ impl<const RXC: usize, const TXC: usize> SpiPeripheral<RXC, TXC> {
 		self.raw_write(0xFF);
 		// Get an IRQ when there's RX data available
 		self.enable_rxne_irq();
-		// self.disable_txe_irq();
 	}
 
 	/// Disable the SPI peripheral (i.e. when CS is high)
 	pub fn disable(&mut self) {
-		self.disable_txe_irq();
 		self.disable_rxne_irq();
 		self.dev.cr1.modify(|_r, w| {
 			w.spe().disabled();
 			w
 		});
 	}
 
-	/// Enable TX Empty interrupt
-	fn enable_txe_irq(&mut self) {
-		self.dev.cr2.modify(|_r, w| {
-			w.txeie().set_bit();
-			w
-		});
-	}
-
-	/// Disable TX Empty interrupt
-	fn disable_txe_irq(&mut self) {
-		self.dev.cr2.modify(|_r, w| {
-			w.txeie().clear_bit();
-			w
-		});
-	}
-
 	/// Enable RX Not Empty interrupt
 	fn enable_rxne_irq(&mut self) {
 		self.dev.cr2.modify(|_r, w| {
@@ -269,8 +249,25 @@ impl<const RXC: usize, const TXC: usize> SpiPeripheral<RXC, TXC> {
 			*space = *inc;
 		}
 		self.tx_ready = data.len();
-		// Start the IRQ driven data transmission
-		// self.enable_txe_irq();
 		Ok(())
 	}
+
+	/// Render some message into the TX buffer.
+	///
+	/// You get an error if you try to load too much.
+	pub fn set_transmit_sendable(
+		&mut self,
+		message: &dyn neotron_bmc_protocol::Sendable,
+	) -> Result<(), ()> {
+		self.tx_ready = 0;
+		self.tx_idx = 0;
+
+		match message.render_to_buffer(&mut self.tx_buffer) {
+			Ok(n) => {
+				self.tx_ready = n;
+				Ok(())
+			}
+			Err(_) => Err(()),
+		}
+	}
 }

neotron-bmc-protocol/Cargo.toml

@@ -7,3 +7,4 @@ license = "BlueOak-1.0.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+defmt = "0.3"

neotron-bmc-protocol/src/lib.rs

@@ -5,6 +5,8 @@
 // Modules and Imports
 // ============================================================================
 
+use defmt::Format;
+
 mod crc;
 
 // ============================================================================
@@ -32,7 +34,7 @@ pub trait Receivable<'a>: Sized {
 // ============================================================================
 
 /// The ways this API can fail
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, Format)]
 pub enum Error {
 	BadCrc,
 	BadLength,
@@ -43,7 +45,7 @@ pub enum Error {
 
 /// The kinds of [`Request`] the *Host* can make to the NBMC
 #[repr(u8)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, Format)]
 pub enum RequestType {
 	Read = 0xC0,
 	ReadAlt = 0xC1,
@@ -55,7 +57,7 @@ pub enum RequestType {
 
 /// The NBMC returns this code to indicate whether the previous [`Request`] was
 /// succesful or not.
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, Format)]
 pub enum ResponseResult {
 	/// The [`Request`] was correctly understood and actioned.
 	Ok = 0xA0,
@@ -83,7 +85,7 @@ pub enum ResponseResult {
 // ============================================================================
 
 /// A *Request* made by the *Host* to the *NBMC*
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Format)]
 pub struct Request {
 	pub request_type: RequestType,
 	pub register: u8,
@@ -92,7 +94,7 @@ pub struct Request {
 }
 
 /// A *Response* sent by the *NBMC* in reply to a [`Request`] from a *Host*
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Format)]
 pub struct Response<'a> {
 	pub result: ResponseResult,
 	pub data: &'a [u8],
@@ -101,7 +103,7 @@ pub struct Response<'a> {
 
 /// Describes the [semantic version](https://semver.org) of this implementation
 /// of the NBMC interface.
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, Format)]
 pub struct ProtocolVersion {
 	major: u8,
 	minor: u8,
@@ -232,7 +234,7 @@ impl<'a> Receivable<'a> for Request {
 	/// let req = Request::from_bytes(&bytes).unwrap();
 	/// ```
 	fn from_bytes(data: &'a [u8]) -> Result<Request, Error> {
-		if data.len() != 4 {
+		if data.len() < 4 {
 			return Err(Error::BadLength);
 		}
 		let calc_crc = calculate_crc(&data[0..=3]);
@@ -267,7 +269,7 @@ impl TryFrom<u8> for ResponseResult {
 
 impl<'a> Response<'a> {
 	/// Make a new OK response, with some optional data
-	pub fn ok_with_data(data: &'a [u8]) -> Response<'a> {
+	pub fn new_ok_with_data(data: &'a [u8]) -> Response<'a> {
 		Response {
 			result: ResponseResult::Ok,
 			data,
@@ -281,7 +283,7 @@ impl<'a> Response<'a> {
 	}
 
 	/// Make a new error response
-	pub fn new(result: ResponseResult) -> Response<'a> {
+	pub fn new_without_data(result: ResponseResult) -> Response<'a> {
 		Response {
 			result,
 			data: &[],
@@ -299,15 +301,15 @@ impl<'a> Sendable for Response<'a> {
 	/// # use neotron_bmc_protocol::{Response, ResponseResult, Sendable};
 	/// let mut buffer = [0u8; 5];
 	///
-	/// let req = Response::ok_with_data(&[]);
+	/// let req = Response::new_ok_with_data(&[]);
 	/// assert_eq!(req.render_to_buffer(&mut buffer).unwrap(), 2);
 	/// assert_eq!(&buffer[0..=1], [0xA0, 0x69]);
 	///
-	/// let req = Response::ok_with_data(&[0x00, 0x01]);
+	/// let req = Response::new_ok_with_data(&[0x00, 0x01]);
 	/// assert_eq!(req.render_to_buffer(&mut buffer).unwrap(), 4);
 	/// assert_eq!(&buffer[0..=3], [0xA0, 0x00, 0x01, 0x4F]);
 	///
-	/// let req = Response::new(ResponseResult::BadRequestType);
+	/// let req = Response::new_without_data(ResponseResult::BadRequestType);
 	/// assert_eq!(req.render_to_buffer(&mut buffer).unwrap(), 2);
 	/// assert_eq!(&buffer[0..=1], [0xA2, 0x67]);
 	/// ```