Add an inaccurate, basic Archimedes.

.github/workflows/build.yml

@@ -53,7 +53,7 @@ jobs:
     name: SDL UI / scons / ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-11, macos-12, macos-13, macos-14, ubuntu-latest]
+        os: [macos-14, ubuntu-latest]
     runs-on: ${{ matrix.os }}
     steps:
     - name: Checkout

Components/9918/Implementation/9918.cpp

@@ -163,7 +163,7 @@ void Base<personality>::posit_sprite(int sprite_number, int sprite_position, uin
 	}
 
 	const auto sprite_row = uint8_t(screen_row - sprite_position);
-	if(sprite_row < 0 || sprite_row >= sprite_height_) return;
+	if(sprite_row >= sprite_height_) return;	// The less-than-zero case is dealt with by the cast to unsigned.
 
 	if(fetch_sprite_buffer_->active_sprite_slot == mode_timing_.maximum_visible_sprites) {
 		status_ |= StatusSpriteOverflow;

Components/I2C/I2C.cpp

@@ -0,0 +1,226 @@
+//
+//  I2C.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 16/03/2024.
+//  Copyright © 2024 Thomas Harte. All rights reserved.
+//
+
+#include "I2C.hpp"
+
+#include "../../Outputs/Log.hpp"
+
+using namespace I2C;
+
+namespace {
+
+Log::Logger<Log::Source::I2C> logger;
+
+}
+
+void Bus::set_data(bool pulled) {
+	set_clock_data(clock_, pulled);
+}
+bool Bus::data() {
+	bool result = data_;
+	if(peripheral_bits_) {
+		result |= !(peripheral_response_ & 0x80);
+	}
+	return result;
+}
+
+void Bus::set_clock(bool pulled) {
+	set_clock_data(pulled, data_);
+}
+bool Bus::clock() {
+	return clock_;
+}
+
+void Bus::set_clock_data(bool clock_pulled, bool data_pulled) {
+	// Proceed only if changes are evidenced.
+	if(clock_pulled == clock_ && data_pulled == data_) {
+		return;
+	}
+
+	const bool prior_clock = clock_;
+	const bool prior_data = data_;
+	clock_ = clock_pulled;
+	data_ = data_pulled;
+
+	// If currently serialising from a peripheral then shift onwards on
+	// every clock trailing edge.
+	if(peripheral_bits_) {
+		// Trailing edge of clock => bit has been consumed.
+		if(!prior_clock && clock_) {
+			logger.info().append("<< %d", (peripheral_response_ >> 7) & 1);
+			--peripheral_bits_;
+			peripheral_response_ <<= 1;
+
+			if(!peripheral_bits_) {
+				signal(Event::FinishedOutput);
+			}
+		}
+		return;
+	}
+
+	// Not currently serialising implies listening.
+	if(!clock_ && prior_data != data_) {
+		// A data transition outside of a clock cycle implies a start or stop.
+		in_bit_ = false;
+		if(data_) {
+			logger.info().append("S");
+			signal(Event::Start);
+		} else {
+			logger.info().append("W");
+			signal(Event::Stop);
+		}
+	} else if(clock_ != prior_clock) {
+		// Bits: wait until the falling edge of the cycle.
+		if(!clock_) {
+			// Rising edge: clock period begins.
+			in_bit_ = true;
+		} else if(in_bit_) {
+			// Falling edge: clock period ends (assuming it began; otherwise this is a preparatory
+			// clock transition only, immediately after a start bit).
+			in_bit_ = false;
+
+			if(data_) {
+				logger.info().append("0");
+				signal(Event::Zero);
+			} else {
+				logger.info().append("1");
+				signal(Event::One);
+			}
+		}
+	}
+}
+
+void Bus::signal(Event event) {
+	const auto capture_bit = [&]() {
+		input_ = uint16_t((input_ << 1) | (event == Event::Zero ? 0 : 1));
+		++input_count_;
+	};
+
+	const auto acknowledge = [&]() {
+		// Post an acknowledgement bit.
+		peripheral_response_ = 0;
+		peripheral_bits_ = 1;
+	};
+
+	const auto set_state = [&](State state) {
+		state_ = state;
+		input_count_ = 0;
+		input_ = 0;
+	};
+
+	const auto enqueue = [&](std::optional<uint8_t> next) {
+		if(next) {
+			peripheral_response_ = static_cast<uint16_t>(*next);
+			peripheral_bits_ = 8;
+			set_state(State::AwaitingByteAcknowledge);
+		} else {
+			set_state(State::AwaitingAddress);
+		}
+	};
+
+	const auto stop = [&]() {
+		set_state(State::AwaitingAddress);
+		active_peripheral_ = nullptr;
+	};
+
+	// Allow start and stop conditions at any time.
+	if(event == Event::Start) {
+		set_state(State::CollectingAddress);
+		active_peripheral_ = nullptr;
+		return;
+	}
+
+	if(event == Event::Stop) {
+		if(active_peripheral_) {
+			active_peripheral_->stop();
+		}
+		stop();
+		return;
+	}
+
+	switch(state_) {
+		// While waiting for an address, don't respond to anything other than a
+		// start bit, which is actually dealt with above.
+		case State::AwaitingAddress:	break;
+
+		// To collect an address: shift in eight bits, and if there's a device
+		// at that address then acknowledge the address and segue into a read
+		// or write loop.
+		case State::CollectingAddress:
+			capture_bit();
+			if(input_count_ == 8) {
+				auto pair = peripherals_.find(uint8_t(input_) & 0xfe);
+				if(pair != peripherals_.end()) {
+					active_peripheral_ = pair->second;
+					active_peripheral_->start(input_ & 1);
+
+					if(input_&1) {
+						acknowledge();
+						set_state(State::CompletingReadAcknowledge);
+					} else {
+						acknowledge();
+						set_state(State::ReceivingByte);
+					}
+				} else {
+					state_ = State::AwaitingAddress;
+				}
+			}
+		break;
+
+		// Receiving byte: wait until a scheduled acknowledgment has
+		// happened, then collect eight bits, then see whether the
+		// active peripheral will accept them. If so, acknowledge and repeat.
+		// Otherwise fall silent.
+		case State::ReceivingByte:
+			if(event == Event::FinishedOutput) {
+				return;
+			}
+			capture_bit();
+			if(input_count_ == 8) {
+				if(active_peripheral_->write(static_cast<uint8_t>(input_))) {
+					acknowledge();
+					set_state(State::ReceivingByte);
+				} else {
+					stop();
+				}
+			}
+		break;
+
+		// The initial state immediately after a peripheral has been started
+		// in read mode and the address-select acknowledgement is still
+		// being serialised.
+		//
+		// Once that is completed, enqueues the first byte from the peripheral.
+		case State::CompletingReadAcknowledge:
+			if(event != Event::FinishedOutput) {
+				break;
+			}
+			enqueue(active_peripheral_->read());
+		break;
+
+		// Repeating state during reading; waits until the previous byte has
+		// been fully serialised, and if the host acknowledged it then posts
+		// the next. If the host didn't acknowledge, stops the connection.
+		case State::AwaitingByteAcknowledge:
+			if(event == Event::FinishedOutput) {
+				break;
+			}
+			if(event != Event::Zero) {
+				stop();
+				break;
+			}
+
+			// Add a new byte if there is one.
+			enqueue(active_peripheral_->read());
+		break;
+	}
+}
+
+void Bus::add_peripheral(Peripheral *peripheral, int address) {
+	peripherals_[address] = peripheral;
+}

Components/I2C/I2C.hpp

@@ -0,0 +1,82 @@
+//
+//  I2C.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 16/03/2024.
+//  Copyright © 2024 Thomas Harte. All rights reserved.
+//
+
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <unordered_map>
+
+namespace I2C {
+
+/// Provides the virtual interface for an I2C peripheral; attaching this to a bus
+/// provides automatic protocol handling.
+struct Peripheral {
+	/// Indicates that the host signalled the start condition and addressed this
+	/// peripheral, along with whether it indicated a read or write.
+	virtual void start([[maybe_unused]] bool is_read) {}
+
+	/// Indicates that the host signalled a stop.
+	virtual void stop() {}
+
+	/// Requests the next byte to serialise onto the I2C bus after this peripheral has
+	/// been started in read mode.
+	///
+	/// @returns A byte to serialise or std::nullopt if the peripheral declines to
+	/// continue to communicate.
+	virtual std::optional<uint8_t> read() { return std::nullopt; }
+
+	/// Provides a byte received from the bus after this peripheral has been started
+	/// in write mode.
+	///
+	/// @returns @c true if the write should be acknowledged; @c false otherwise.
+	virtual bool write(uint8_t) { return false; }
+};
+
+class Bus {
+public:
+	void set_data(bool pulled);
+	bool data();
+
+	void set_clock(bool pulled);
+	bool clock();
+
+	void set_clock_data(bool clock_pulled, bool data_pulled);
+
+	void add_peripheral(Peripheral *, int address);
+
+private:
+	bool data_ = false;
+	bool clock_ = false;
+	bool in_bit_ = false;
+	std::unordered_map<int, Peripheral *> peripherals_;
+
+	uint16_t input_ = 0xffff;
+	int input_count_ = -1;
+
+	Peripheral *active_peripheral_ = nullptr;
+	uint16_t peripheral_response_ = 0xffff;
+	int peripheral_bits_ = 0;
+
+	enum class Event {
+		Zero, One, Start, Stop, FinishedOutput,
+	};
+	void signal(Event);
+
+	enum class State {
+		AwaitingAddress,
+		CollectingAddress,
+
+		CompletingReadAcknowledge,
+		AwaitingByteAcknowledge,
+
+		ReceivingByte,
+	} state_ = State::AwaitingAddress;
+};
+
+}

Components/Serial/Line.cpp

@@ -161,9 +161,7 @@ void Line<include_clock>::update_delegate(bool level) {
 		// Forward as many bits as occur.
 		Storage::Time time_left(cycles_to_forward, int(clock_rate_.as_integral()));
 		const int bit = level ? 1 : 0;
-		int bits = 0;
 		while(time_left >= time_left_in_bit_) {
-			++bits;
 			if(!read_delegate_->serial_line_did_produce_bit(this, bit)) {
 				read_delegate_phase_ = ReadDelegatePhase::WaitingForZero;
 				if(bit) return;