Merge pull request #18 from Neotron-Compute/kb_support

Nicer KB support

Author: thejpster

Cargo.lock

@@ -19,7 +19,7 @@ panic-probe = { version = "0.2.0", features = ["print-defmt"] }
 # Use this line if you have an STM32F031K6T6
 stm32f0xx-hal = { version = "0.17", features = ["stm32f031", "rt"] }
 debouncr = "0.2"
-pc-keyboard = "0.5"
+heapless= "0.6"
 
 [features]
 # set logging levels here

Cargo.toml

@@ -57,7 +57,7 @@ The NBMC firmware is designed to run on an ST Micro STM32F0 (STM32F031K6T6) micr
 | 29   | PB6  | I2C1_SCL    | I²C Clock                                    |
 | 30   | PB7  | I2C1_SDA    | I²C Data                                     |
 
-Note that in the above table, the UART signals are wired as _Data Terminal Equipment (DTE)_ (i.e. like a PC, not like a Modem).
+Note that in the above table, the UART signals are wired as _Data Terminal Equipment (DTE)_ (i.e. like a PC, not like a Modem). Connect the NMBC *UART Transmit Output* pin to the *Input* pin of something like an FTDI TTL-232R-3V3 cable.
 
 This design should also be pin-compatible with the following SoCs (although this firmware may need changes):
 

README.md

@@ -9,6 +9,11 @@
 ///! # Licence
 ///! This source code as a whole is licensed under the GPL v3. Third-party crates are covered by their respective licences.
 use cortex_m::interrupt::free as disable_interrupts;
+use heapless::{
+	consts::*,
+	i,
+	spsc::{Consumer, Producer, Queue},
+};
 use rtic::app;
 use stm32f0xx_hal::{
 	gpio::gpioa::{PA10, PA11, PA12, PA15, PA2, PA3, PA9},
@@ -21,7 +26,7 @@ use stm32f0xx_hal::{
 };
 
 use neotron_bmc as _;
-use neotron_bmc::monotonic::{Instant, Tim3Monotonic, U16Ext};
+use neotron_bmc::monotonic::{Tim3Monotonic, U16Ext};
 
 /// Version string auto-generated by git.
 static VERSION: &'static str = include_str!(concat!(env!("OUT_DIR"), "/version.txt"));
@@ -44,6 +49,26 @@ pub enum DcPowerState {
 	Off = 0,
 }
 
+/// Handles decoding incoming PS/2 packets
+///
+/// Each packet has 11 bits:
+///
+/// * Start Bit
+/// * 8 Data Bits (LSB first)
+/// * Parity Bit
+/// * Stop Bit
+#[derive(Debug)]
+pub struct Ps2Decoder {
+	bit_count: u8,
+	collector: u16,
+}
+
+/// This is our system state, as accessible via SPI reads and writes.
+#[derive(Debug)]
+pub struct RegisterState {
+	firmware_version: &'static str,
+}
+
 #[app(device = crate::pac, peripherals = true,  monotonic = crate::Tim3Monotonic)]
 const APP: () = {
 	struct Resources {
@@ -82,8 +107,16 @@ const APP: () = {
 		ps2_dat1: PB5<Input<Floating>>,
 		/// The external interrupt peripheral
 		exti: pac::EXTI,
-		/// Our PS/2 keyboard decoder
-		kb: pc_keyboard::Keyboard<pc_keyboard::layouts::Uk105Key, pc_keyboard::ScancodeSet2>,
+		/// Our register state
+		register_state: RegisterState,
+		/// Keyboard PS/2 decoder
+		kb_decoder: Ps2Decoder,
+		/// Mouse PS/2 decoder
+		ms_decoder: Ps2Decoder,
+		/// Keyboard bytes sink
+		kb_c: Consumer<'static, u16, U8>,
+		/// Keyboard bytes source
+		kb_p: Producer<'static, u16, U8>,
 	}
 
 	/// The entry point to our application.
@@ -94,6 +127,8 @@ const APP: () = {
 	/// * Task `button_poll` - checks the power and reset buttons
 	#[init(spawn = [led_power_blink, button_poll])]
 	fn init(ctx: init::Context) -> init::LateResources {
+		static mut Q: Queue<u16, U8> = Queue(i::Queue::new());
+
 		defmt::info!("Neotron BMC version {:?} booting", VERSION);
 
 		let dp: pac::Peripherals = ctx.device;
@@ -174,6 +209,8 @@ const APP: () = {
 
 		defmt::info!("Init complete!");
 
+		let (kb_p, kb_c) = Q.split();
+
 		init::LateResources {
 			serial,
 			pin_uart_cts,
@@ -192,48 +229,49 @@ const APP: () = {
 			ps2_dat0,
 			ps2_dat1,
 			exti: dp.EXTI,
-			kb: pc_keyboard::Keyboard::new(
-				pc_keyboard::layouts::Uk105Key,
-				pc_keyboard::ScancodeSet2,
-				pc_keyboard::HandleControl::MapLettersToUnicode,
-			),
+			register_state: RegisterState {
+				firmware_version: "Neotron BMC v0.0.0",
+			},
+			kb_p,
+			kb_c,
+			kb_decoder: Ps2Decoder::new(),
+			ms_decoder: Ps2Decoder::new(),
 		}
 	}
 
 	/// Our idle task.
 	///
 	/// This task is called when there is nothing else to do. We
 	/// do a little logging, then put the CPU to sleep waiting for an interrupt.
-	#[idle(resources = [])]
-	fn idle(_ctx: idle::Context) -> ! {
+	#[idle(resources = [kb_c])]
+	fn idle(ctx: idle::Context) -> ! {
 		defmt::info!("Idle is running...");
 		loop {
-			cortex_m::asm::wfi();
-			defmt::trace!("It is now {}", crate::Instant::now().counts());
+			if let Some(word) = ctx.resources.kb_c.dequeue() {
+				if let Some(byte) = Ps2Decoder::check_word(word) {
+					defmt::info!("< KB {:x}", byte);
+				} else {
+					defmt::info!("< Bad KB {:x}", word);
+				}
+			}
 		}
 	}
 
 	/// This is the PS/2 Keyboard task.
 	///
+	/// It is very high priority, as we can't afford to miss a clock edge.
+	///
 	/// It fires when there is a falling edge on the PS/2 Keyboard clock pin.
-	#[task(binds = EXTI4_15, resources=[ps2_clk0, ps2_dat0, exti, kb])]
+	#[task(
+		binds = EXTI4_15,
+		priority = 15,
+		resources=[ps2_clk0, ps2_dat0, exti, kb_decoder, kb_p])]
 	fn exti4_15_interrupt(ctx: exti4_15_interrupt::Context) {
-		match ctx
-			.resources
-			.kb
-			.add_bit(ctx.resources.ps2_dat0.is_high().unwrap())
-		{
-			Err(e) => {
-				defmt::warn!("Error decoding kb: {}", e as usize);
-			}
-			Ok(None) => {}
-			Ok(Some(evt)) => {
-				defmt::info!(
-					"Got event core={}, state={}",
-					evt.code as usize,
-					evt.state as usize
-				);
-			}
+		let data_bit = ctx.resources.ps2_dat0.is_high().unwrap();
+		// Do we have a complete word (and if so, is the parity OK)?
+		if let Some(data) = ctx.resources.kb_decoder.add_bit(data_bit) {
+			// Don't dump in the ISR - we're busy. Add it to this nice lockless queue instead.
+			ctx.resources.kb_p.enqueue(data).unwrap();
 		}
 		// Clear the pending flag
 		ctx.resources.exti.pr.write(|w| w.pr15().set_bit());
@@ -347,6 +385,59 @@ const APP: () = {
 	}
 };
 
+impl Ps2Decoder {
+	fn new() -> Ps2Decoder {
+		Ps2Decoder {
+			bit_count: 0,
+			collector: 0,
+		}
+	}
+
+	fn reset(&mut self) {
+		self.bit_count = 0;
+		self.collector = 0;
+	}
+
+	fn add_bit(&mut self, bit: bool) -> Option<u16> {
+		if bit {
+			self.collector |= 1 << self.bit_count;
+		}
+		self.bit_count += 1;
+		if self.bit_count == 11 {
+			let result = self.collector;
+			self.reset();
+			Some(result)
+		} else {
+			None
+		}
+	}
+
+	/// Check 11-bit word has 1 start bit, 1 stop bit and an odd parity bit.
+	fn check_word(word: u16) -> Option<u8> {
+		let start_bit = (word & 0x0001) != 0;
+		let parity_bit = (word & 0x0200) != 0;
+		let stop_bit = (word & 0x0400) != 0;
+		let data = ((word >> 1) & 0xFF) as u8;
+
+		if start_bit {
+			return None;
+		}
+
+		if !stop_bit {
+			return None;
+		}
+
+		let need_parity = (data.count_ones() % 2) == 0;
+
+		// Odd parity, so these must not match
+		if need_parity != parity_bit {
+			return None;
+		}
+
+		Some(data)
+	}
+}
+
 // TODO: Pins we haven't used yet
 // SPI pins
 // spi_clk: gpioa.pa5.into_alternate_af0(cs),