From 5967ad0865ec60961cc01fa9205601134a0b44a1 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sat, 23 Mar 2024 17:08:03 -0400
Subject: [PATCH] Sketch out whole protocol, albeit faulty.

---
 Machines/Acorn/Archimedes/Keyboard.hpp | 138 +++++++++++++++++++++----
 1 file changed, 119 insertions(+), 19 deletions(-)

diff --git a/Machines/Acorn/Archimedes/Keyboard.hpp b/Machines/Acorn/Archimedes/Keyboard.hpp
index 61eb8b36a..75de0d2b7 100644
--- a/Machines/Acorn/Archimedes/Keyboard.hpp
+++ b/Machines/Acorn/Archimedes/Keyboard.hpp
@@ -17,46 +17,146 @@ struct Keyboard {
 	Keyboard(HalfDuplexSerial &serial) : serial_(serial) {}
 
 	void set_key_state(int row, int column, bool is_pressed) {
+//		if(!scan_keyboard_) return;
+		// TODO: scan_keyboard_ seems to end up in the wrong state. Investigate.
+
 		const uint8_t prefix = is_pressed ? 0b1100'0000 : 0b1101'0000;
-		queue_.push_back(static_cast<uint8_t>(prefix | row));
-		queue_.push_back(static_cast<uint8_t>(prefix | column));
-		dequeue_next();
+		enqueue(static_cast<uint8_t>(prefix | row), static_cast<uint8_t>(prefix | column));
+		consider_dequeue();
 	}
 
 	void update() {
 		if(serial_.events(KeyboardParty) & HalfDuplexSerial::Receive) {
+			const auto reset = [&]() {
+				serial_.output(KeyboardParty, HRST);
+				phase_ = Phase::Idle;
+			};
+
 			const uint8_t input = serial_.input(KeyboardParty);
-			switch(input) {
-				case HRST:
-					// TODO:
-				case RAK1:
-				case RAK2:
+
+			// A reset command is always accepted, usurping any other state.
+			if(input == HRST) {
+				phase_ = Phase::ExpectingRAK1;
+				event_queue_.clear();
+				serial_.output(KeyboardParty, HRST);
+				return;
+			}
+
+			switch(phase_) {
+				case Phase::Idle:
+					switch(input) {
+						case RQID:	// Post keyboard ID.
+							serial_.output(KeyboardParty, 0x81);	// Declare this to be a UK keyboard.
+							phase_ = Phase::ExpectingACK;
+						break;
+
+						case PRST:	// "1-byte command, does nothing."
+						break;
+
+						case RQMP:
+							// TODO: real mouse data.
+							enqueue(0, 0);
+						break;
+
+						default:
+							if((input & 0b1111'0000) == 0b0100'0000) {
+								// RQPD; request to echo the low nibble.
+								serial_.output(KeyboardParty, 0b1110'0000 | (input & 0b1111));
+							}
+
+							if(!(input & 0b1111'1000)) {
+								// LEDS: should set LEd outputs.
+							}
+						break;
+					}
+				break;
+
+				case Phase::ExpectingRAK1:
+					if(input != RAK1) {
+						reset();
+						break;
+					}
 					serial_.output(KeyboardParty, input);
+					phase_ = Phase::ExpectingRAK2;
 				break;
 
-				case RQID:
-					serial_.output(KeyboardParty, 0x81);	// TODO: what keyboard type?
+				case Phase::ExpectingRAK2:
+					if(input != RAK2) {
+						reset();
+						break;
+					}
+					serial_.output(KeyboardParty, input);
+					phase_ = Phase::ExpectingACK;
 				break;
 
-				case BACK:
-					dequeue_next();
+				case Phase::ExpectingBACK:
+					if(input != BACK) {
+						reset();
+						break;
+					}
+					phase_ = Phase::ExpectingACK;
 				break;
 
-				default:
-					printf("Keyboard declines to respond to %02x\n", input);
+				case Phase::ExpectingACK:
+					switch(input) {
+						default:
+							reset();
+						break;
+
+						case NACK:
+							scan_keyboard_ = scan_mouse_ = false;
+						break;
+						case SMAK:
+							scan_keyboard_ = scan_mouse_ = true;
+						break;
+						case MACK:
+							scan_keyboard_ = false;
+							scan_mouse_ = true;
+						break;
+						case SACK:
+							scan_keyboard_ = true;
+							scan_mouse_ = false;
+						break;
+					}
+					phase_ = Phase::Idle;
 				break;
 			}
+
+			consider_dequeue();
+		}
+	}
+
+	void consider_dequeue() {
+		if(phase_ == Phase::Idle) {
+			dequeue_next();
 		}
 	}
 
 private:
 	HalfDuplexSerial &serial_;
 
-	std::vector<uint8_t> queue_;
-	void dequeue_next() {
-		if(queue_.empty()) return;
-		serial_.output(KeyboardParty, queue_[0]);
-		queue_.erase(queue_.begin());
+	bool scan_keyboard_ = false;
+	bool scan_mouse_ = false;
+	enum class Phase {
+		ExpectingRAK1,
+		ExpectingRAK2,
+		ExpectingBACK,
+		ExpectingACK,
+		Idle,
+	} phase_ = Phase::Idle;
+
+	std::vector<uint8_t> event_queue_;
+	void enqueue(uint8_t first, uint8_t second) {
+		event_queue_.push_back(first);
+		event_queue_.push_back(second);
+	}
+	bool dequeue_next() {
+		// To consider: a cheaper approach to the queue than this; in practice events
+		// are 'rare' so it's not high priority.
+		if(event_queue_.empty()) return false;
+		serial_.output(KeyboardParty, event_queue_[0]);
+		event_queue_.erase(event_queue_.begin());
+		return true;
 	}
 
 	static constexpr uint8_t HRST	= 0b1111'1111;	// Keyboard reset.