badline 0.17.0 → 0.18.0

data/lib/badline/kim1/bus.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Badline
+  class KIM1
+    # The CPU's bus. The board decodes A10-A12 into eight 1K blocks and
+    # leaves A13-A15 alone, so the 8K repeats through all 64K, and the
+    # vectors at $FFFA-$FFFF are the monitor's at $1FFA-$1FFF (User Manual,
+    # figure 3.12 and section 6.2):
+    #
+    # $0000-$03FF - the 1K of RAM
+    # $0400-$16FF - nothing
+    # $1700-$173F - U3's ports and timer, its 16 registers repeated
+    # $1740-$177F - U2's
+    # $1780-$17BF - U3's 64 bytes of RAM
+    # $17C0-$17FF - U2's
+    # $1800-$1BFF - U3's ROM, the tape routines
+    # $1C00-$1FFF - U2's ROM, the monitor
+    #
+    # A read from nothing finds the last byte on the bus. Writes to ROM
+    # and to nothing go nowhere.
+    #
+    # The board takes more RAM, as RAM_CONFIGURATIONS names it: the stock
+    # 1K, 5K with a board in K1-K4 filling $0400-$13FF, or those 5K and
+    # RAM at $2000-$DFFF, with an expansion that decodes A13-A15 and
+    # repeats the first 8K only at $E000-$FFFF, so the vectors are still
+    # the monitor's (User Manual, sections 6.1 and 6.2).
+    class Bus
+      include Addressable
+
+      RAM_CONFIGURATIONS = %i[1k 5k expanded].freeze
+
+      # The RAM, and the one of RAM_CONFIGURATIONS it comes as.
+      attr_reader :ram, :ram_configuration
+
+      # The last byte the CPU read or wrote.
+      attr_reader :data
+
+      # +monitor+ is U2, the 6530-002, and +user+ U3, the 6530-003, with
+      # the RAM `ram` names.
+      def initialize(monitor, user, ram: :"1k")
+        addressable_at(0, length: 2**16)
+        raise ArgumentError, "no KIM-1 RAM configuration named #{ram}" unless RAM_CONFIGURATIONS.include?(ram)
+
+        @u2 = monitor
+        @u3 = user
+        @ram_configuration = ram
+        # The end of RAM in the first 8K, and where the first 8K stops
+        # repeating, past the RAM above it.
+        @low_end = ram == :"1k" ? 0x0400 : 0x1400
+        @mirror_end = ram == :expanded ? 0xe000 : 0x2000
+        @ram = Memory.new([], length: @mirror_end == 0x2000 ? @low_end : @mirror_end, start: 0)
+        @data = 0
+      end
+
+      # The RAM in K, without the 6530s' 64 bytes each.
+      def ram_kb = (@low_end + @mirror_end - 0x2000) >> 10
+
+      # Whether RAM answers at `addr`, the board's or a 6530's.
+      def ram?(addr)
+        offset = addr < 0x2000 || addr >= @mirror_end ? addr & 0x1fff : addr
+        offset < @low_end || offset >= 0x2000 || offset.between?(0x1780, 0x17ff)
+      end
+
+      def peek(addr)
+        offset = addr < 0x2000 || addr >= @mirror_end ? addr & 0x1fff : addr
+        @data = if offset < @low_end || offset >= 0x2000
+                  @ram.peek(offset)
+                elsif offset >= 0x1c00
+                  @u2.read_rom(offset)
+                elsif offset >= 0x1800
+                  @u3.read_rom(offset)
+                elsif (offset >> 8) == 0x17
+                  read_chips(offset)
+                else
+                  @data
+                end
+      end
+
+      def poke(addr, value)
+        @data = value
+        offset = addr < 0x2000 || addr >= @mirror_end ? addr & 0x1fff : addr
+        if offset < @low_end || offset >= 0x2000
+          @ram.poke(offset, value)
+        elsif (offset >> 8) == 0x17
+          write_chips(offset, value)
+        end
+      end
+
+      def power_on!
+        @ram.clear!
+        @u2.ram.map! { 0 }
+        @u3.ram.map! { 0 }
+      end
+
+      private
+
+      # A6 picks U2 over U3, and A7 the RAM over the registers.
+      def read_chips(offset)
+        ram = offset.anybits?(0x80)
+        if offset.anybits?(0x40)
+          ram ? @u2.read_ram(offset) : @u2.peek(offset & 0x0f)
+        else
+          ram ? @u3.read_ram(offset) : @u3.peek(offset & 0x0f)
+        end
+      end
+
+      def write_chips(offset, value)
+        ram = offset.anybits?(0x80)
+        if offset.anybits?(0x40)
+          ram ? @u2.write_ram(offset, value) : @u2.poke(offset & 0x0f, value)
+        else
+          ram ? @u3.write_ram(offset, value) : @u3.poke(offset & 0x0f, value)
+        end
+      end
+    end
+  end
+end

data/lib/badline/kim1/cpu.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Badline
+  class KIM1
+    # The KIM-1's 6502, U1, on the KIM1::Bus.
+    #
+    # With the SST switch on, the board's U26 gate pulls NMI low through
+    # each opcode fetch outside K7, $1C00-$1FFF and its mirrors, where the
+    # monitor runs. The CPU takes the NMI at the end of the instruction
+    # that fetch starts, a 2-cycle one too, so the monitor steps a program
+    # one instruction at a time (User Manual, figure 5.6).
+    class CPU
+      include Badline::Chips::CPU::Core
+
+      # The K7 block's address lines, A10-A12, which the board decodes.
+      K7 = 0x1c00
+
+      # Pulls NMI if the next cycle fetches an opcode outside K7. The
+      # board calls it ahead of each cycle while SST is on.
+      def single_step
+        @nmi = true if boundary? && (@program_counter & K7) != K7
+      end
+    end
+  end
+end

data/lib/badline/kim1/host_terminal.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Badline
+  class KIM1
+    # The KIM-1's teletype on the host's terminal, for `badline kim1
+    # --headless`: what the terminal types goes down the line, and what
+    # the teletype prints comes out on it, without the NULs and RUBOUTs a
+    # terminal doesn't show. The machine runs at its own 1 MHz against the
+    # host's clock, catching up at most CATCH_UP seconds at a time, until
+    # Ctrl-C.
+    #
+    # `console` answers #typing, #read_text and #print_text, as
+    # Audio::Terminal does.
+    class HostTerminal
+      SLICE = 0.01
+      CATCH_UP = 0.1
+
+      def self.run(machine, console) = new(machine, console).run
+
+      # Builds the KIM-1 the command line's `options` name, loads the
+      # program they name (Media::KIM1Media), and runs it on `console`
+      # until Ctrl-C. Returns the exit status, 1 when the program won't
+      # load, which it warns about.
+      def self.start(options, console)
+        path = options.media_path
+        machine = Machine.for_options(options, path)
+        unless path.nil?
+          loaded = Media.attach(machine, path, autostart: true, kim1: Media::KIM1Media.loading(options))
+          console.print_text("#{loaded}\r\n")
+        end
+        run(machine, console)
+      rescue Machine::Unsupported, Storage::Papertape::FormatError, SystemCallError => e
+        warn "#{options.program}: #{path}: #{e.message}"
+        1
+      end
+
+      def initialize(machine, console)
+        @machine = machine
+        @console = console
+        @printed = 0
+        @started = 0.0
+      end
+
+      # Runs until Ctrl-C, and returns the exit status.
+      def run
+        @started = now
+        @console.print_text("KIM-1 teletype at #{@machine.teletype.baud} baud. Ctrl-C: Quit\r\n")
+        @console.typing { loop { step } }
+      rescue Interrupt
+        0
+      end
+
+      private
+
+      def step
+        text = @console.read_text(SLICE)
+        @machine.teletype.type(text) unless text.empty?
+        behind = ((now - @started) * 1_000_000).to_i - @machine.cycles
+        @machine.run_cycles([behind, (CATCH_UP * 1_000_000).to_i].min) if behind.positive?
+        print_output
+      end
+
+      def print_output
+        output = @machine.teletype.output
+        return if output.size == @printed
+
+        @console.print_text(output[@printed, output.size - @printed].gsub("\x00", "").gsub("\x7f", ""))
+        @printed = output.size
+      end
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/badline/kim1/key_entry.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Badline
+  class KIM1
+    # Pressing the panel's keys in turn, each long enough for the monitor
+    # to take it. The monitor takes a key it reads down on two scans in a
+    # row, after a scan with no key down, and a scan takes some 4,300
+    # cycles, so each key is held for HOLD_CYCLES and let go for
+    # RELEASE_CYCLES.
+    module KeyEntry
+      HOLD_CYCLES = 12_000
+      RELEASE_CYCLES = 8_000
+
+      # The panel's keys that type_keys takes by name. Any other word is a
+      # run of hex keys.
+      NAMED_KEYS = %w[AD DA GO PC + ST RS].freeze
+
+      # Presses the keys `text` names once the monitor is running: AD, DA,
+      # GO, PC, + and the hex digits, ST, which pulls NMI, and RS, which
+      # resets the machine. Words go by whitespace, and a word that isn't a
+      # key's name is a hex key for each of its characters, so
+      # "AD 0200 DA A9 +" presses nine keys, and the byte $AD goes in as
+      # "A D".
+      def type_keys(text)
+        keys = text.upcase.split.flat_map { |word| NAMED_KEYS.include?(word) ? [word] : word.chars }
+        unknown = keys.find { |key| !NAMED_KEYS.include?(key) && !Panel::KEYS.include?(key) }
+        raise ArgumentError, "no KIM-1 key named #{unknown}" unless unknown.nil?
+
+        on_init { queue_keys(keys) }
+      end
+
+      # Whether keys type_keys was given are still to be pressed.
+      def typing? = !@pending_keys.nil?
+
+      private
+
+      def queue_keys(keys)
+        @pending_keys = keys
+        @key_down = false
+        @next_key_at = @cycles
+      end
+
+      def feed_keys
+        return if @cycles < @next_key_at
+
+        if @key_down
+          release_key
+          @key_down = false
+          @next_key_at = @cycles + RELEASE_CYCLES
+        else
+          press_next_key
+        end
+      end
+
+      def press_next_key
+        keys = @pending_keys
+        name = keys.shift
+        if name.nil?
+          @pending_keys = nil
+          return
+        end
+        if name == "ST"
+          press_stop
+        elsif name == "RS"
+          press_reset
+        else
+          press_key(name)
+        end
+        @key_down = true
+        @next_key_at = @cycles + HOLD_CYCLES
+      end
+    end
+  end
+end

data/lib/badline/kim1/keyed_modules.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Badline
+  class KIM1
+    # The whole machine as keyed snapshot modules (Snapshot::Keyed), in the
+    # order a load applies them: BL-MACHINE with the setup, the RAM, U2 and
+    # U3, each with its 64 bytes, ports and timer, the panel, the cassette
+    # deck, the teletype, the sound's wiring and the CPU.
+    module KeyedModules
+      def save_modules
+        sound = @sound
+        [Snapshot::Keyed.section("BL-MACHINE") { |out| save_machine_fields(out) },
+         Snapshot::Keyed.section("BL-CPU") { |out| @cpu.save_fields(out) },
+         Snapshot::Keyed.section("BL-RAM") { |out| @bus.save_fields(out) },
+         Snapshot::Keyed.section("BL-U2") { |out| @u2.save_fields(out) },
+         Snapshot::Keyed.section("BL-U3") { |out| @u3.save_fields(out) },
+         Snapshot::Keyed.section("BL-PANEL") { |out| @panel.save_fields(out) },
+         Snapshot::Keyed.section("BL-DECK") { |out| @panel.tape.save_fields(out) },
+         Snapshot::Keyed.section("BL-TTY") { |out| @teletype.save_fields(out) },
+         Snapshot::Keyed.section("BL-SOUND") { |out| out.bool("speaker", sound.speaker) }]
+      end
+
+      # Raises Snapshot::FormatError for the modules of a machine built
+      # another way.
+      def load_modules(modules)
+        machine = modules.machine
+        check_snapshot_setup(Snapshot::KIM1Setup.read_fields(machine))
+        load_machine_fields(machine)
+        @bus.load_fields(modules.required("BL-RAM"))
+        @u2.load_fields(modules.required("BL-U2"))
+        @u3.load_fields(modules.required("BL-U3"))
+        @panel.load_fields(modules.required("BL-PANEL"))
+        @panel.tape.load_fields(modules.required("BL-DECK"))
+        @teletype.load_fields(modules.required("BL-TTY"))
+        @sound.speaker = modules.required("BL-SOUND").bool("speaker", false)
+        @cpu.load_fields(modules.required("BL-CPU"))
+        @cpu.restored!
+        self
+      end
+
+      private
+
+      def check_snapshot_setup(setup)
+        ours = Snapshot::KIM1Setup.of(self)
+        return if setup == ours
+
+        raise Snapshot::FormatError, "the snapshot is of a #{setup}, not a #{ours}"
+      end
+    end
+
+    include KeyedModules
+  end
+end

data/lib/badline/kim1/keyed_state.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Badline
+  class KIM1
+    class Bus
+      # The RAM, the expansion's too, and the last byte on the bus, in a
+      # keyed snapshot module (BL-RAM). The 6530s keep their own 64 bytes.
+      module KeyedState
+        def save_fields(out)
+          @ram.save_fields(out, "ram")
+          out.int("data", @data)
+        end
+
+        def load_fields(input)
+          @ram.load_fields(input, "ram")
+          @data = input.byte("data", @data)
+        end
+      end
+
+      include KeyedState
+    end
+
+    class Panel
+      # The panel's fields in a keyed snapshot module (BL-PANEL): the
+      # TTY/KB jumper, the key held down, the digit lit and its segments
+      # since the cycle they lit, the cycles each segment has been lit,
+      # and what each digit last showed and when. The teletype restores
+      # the line in.
+      module KeyedState
+        def save_fields(out)
+          out.bool("tty", @tty).int("held", @held).int("digit", @digit).int("segments", @segments)
+          out.int("since", @since).ints("lit", @lit).ints("shown", @shown).ints("shown_at", @shown_at)
+        end
+
+        def load_fields(input)
+          @tty = input.bool("tty", false)
+          held = input.int("held", -1)
+          @held = held.between?(0, KEYS.length - 1) ? held : -1
+          digit = input.int("digit", -1)
+          @digit = digit.between?(0, DIGITS - 1) ? digit : -1
+          @segments = input.masked("segments", 0, 0x7f)
+          @since = input.int("since", 0)
+          input.ints_into("lit", @lit)
+          input.ints_into("shown", @shown)
+          input.ints_into("shown_at", @shown_at)
+        end
+      end
+
+      include KeyedState
+    end
+
+    class Tape
+      # The deck's fields in a keyed snapshot module (BL-DECK): whether
+      # PLAY or RECORD is down, how far into the tape the deck is, the next
+      # of the tape's edges to play and PB7's level from it, the level U2
+      # last drove PB7 to, and the tape itself under tape.*: its file's
+      # path, and the time from each crossing to the next, from the start.
+      # The tape goes back in from the module, and STOP after a recording
+      # writes it to that path.
+      module KeyedState
+        def save_fields(out)
+          out.bool("playing", @playing).bool("recording", @recording).int("position", position)
+          out.int("next_edge", @next_edge).bool("high", @high).bool("output_high", @output_high)
+          crossings = @tape.crossings
+          gaps = crossings.each_with_index.map { |time, index| index.zero? ? time : time - crossings[index - 1] }
+          out.text("tape.path", @tape.path).ints("tape.gaps", gaps)
+        end
+
+        def load_fields(input)
+          time = 0
+          crossings = input.ints("tape.gaps", []).map { |gap| time += gap }
+          @tape = Storage::KIMTape.new(input.text("tape.path", ""), crossings:)
+          @playing = input.bool("playing", false)
+          @recording = input.bool("recording", false) && !@playing
+          @stopped_at = input.int("position", 0)
+          @started = @clock.cycles
+          @edges = @playing ? @tape.edges : []
+          @next_edge = input.int("next_edge", 0).clamp(0, @edges.length)
+          @high = input.bool("high", true)
+          @output_high = input.bool("output_high", true)
+        end
+      end
+
+      include KeyedState
+    end
+
+    # The machine's own fields in a keyed snapshot module (BL-MACHINE):
+    # the family, its setup (Snapshot::KIM1Setup), the cycle count, the
+    # SST switch and U3's PB7 wiring, and under host.* whether type_keys
+    # is typing, the keys it has still to press, by their place in KEY_NAMES, the one held, when
+    # the next goes, and the on_init handlers still to run. The badline
+    # version that wrote it is written for reports and never read.
+    module KeyedState
+      # The keys type_keys presses, as host.pending_keys numbers them.
+      KEY_NAMES = (Panel::KEYS + %w[ST RS]).freeze
+
+      # How many more on_init handlers the machine a snapshot was taken of
+      # had yet to run than this one has. Nil until the machine is restored.
+      attr_reader :init_handlers_lost
+
+      # Whether a snapshot saves now (Machine::Settling): the CPU between
+      # instructions or jammed.
+      def settled_for_snapshot? = @cpu.boundary? || @cpu.jammed?
+
+      # Nothing on the board defers its work.
+      def settle_chips_for_snapshot = nil
+
+      def save_machine_fields(out)
+        out.text("family", "kim1").text("written_by", VERSION)
+        Snapshot::KIM1Setup.of(self).write_fields(out)
+        out.int("cycles", @cycles).bool("sst", @sst).bool("irq_wired", @irq_wired)
+        pending = @pending_keys
+        out.bool("host.typing", !pending.nil?)
+        out.ints("host.pending_keys", pending.map { |name| KEY_NAMES.index(name) }) if pending
+        out.bool("host.key_down", @key_down).int("host.next_key_at", @next_key_at)
+        out.int("host.init_pending", @cycles <= @init_threshold ? @init_handlers.length : 0)
+      end
+
+      def load_machine_fields(input)
+        @cycles = input.int("cycles", @cycles)
+        @sst = input.bool("sst", false)
+        @irq_wired = input.bool("irq_wired", false)
+        pending = input.ints("host.pending_keys", []).filter_map { |index| KEY_NAMES[index] if index >= 0 }
+        @pending_keys = input.bool("host.typing", false) ? pending : nil
+        @key_down = input.bool("host.key_down", false)
+        @next_key_at = input.int("host.next_key_at", 0)
+        @init_handlers_lost = [input.int("host.init_pending", 0) - @init_handlers.length, 0].max
+      end
+    end
+
+    include KeyedState
+  end
+end

data/lib/badline/kim1/panel.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Badline
+  class KIM1
+    # The keypad and display on U2's ports (User Manual, figures 3.5 and
+    # 3.6), and the TTY/KB jumper.
+    #
+    # PB1-PB4 feed a 74145 decoder, U24. Its outputs 0-2 select the
+    # keypad's three rows, 3 the jumper, and 4-9 the six LED digits, left
+    # to right. PA0-PA6 drive the selected digit's segments a-g, a high
+    # line lighting one, and read the selected row's keys, a pressed key
+    # pulling its line low: PA6 is the row's first key, PA0 its seventh.
+    # Fitted, the jumper pulls PA0 low while output 3 is selected, which
+    # the monitor reads as teletype mode, and PA7 takes the teletype's
+    # line in (Teletype). PB7 is the cassette's line (Tape).
+    #
+    # Nothing holds the display lit. A program lights each digit in turn
+    # (the monitor's SCANDS, $1F1F), so the panel times how long each
+    # segment is lit from the writes to U2's ports: lit_cycles hands the
+    # totals to a front end, and display reads back what the digits show.
+    class Panel
+      # The keys of the matrix, by the code the monitor's GETKEY ($1F6A)
+      # gives them: the row times 7 plus the column.
+      KEYS = %w[0 1 2 3 4 5 6 7 8 9 A B C D E F AD DA + GO PC].freeze
+
+      # The monitor's segment patterns for 0-F, its table at $1FE7 without
+      # bit 7, which PA7 doesn't drive.
+      HEX_SEGMENTS = [0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07,
+                      0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71].freeze
+
+      DIGITS = 6
+
+      # The decoder output of the leftmost digit.
+      FIRST_DIGIT = 4
+
+      # A digit lit for less than this many cycles at a time doesn't count
+      # as showing anything: the monitor passes its digits through that
+      # quickly between patterns.
+      SHOWN_CYCLES = 100
+
+      # A digit not lit for this many cycles, some five of the monitor's
+      # scans, reads as dark.
+      DARK_CYCLES = 20_000
+
+      # Whether the TTY/KB jumper is fitted.
+      attr_accessor :tty
+
+      # Whether the teletype's line in is high, its idle level. Low, it
+      # pulls PA7 low while PB5 is low, which gates it through.
+      attr_accessor :tty_in_high
+
+      # The cassette deck on PB7.
+      attr_reader :tape
+
+      # +clock+ answers +cycles+, the cycle each write to the ports lands
+      # on.
+      def initialize(clock)
+        @clock = clock
+        @rriot = nil
+        @tty = false
+        @tty_in_high = true
+        @tape = Tape.new(clock)
+        @held = -1
+        @digit = -1
+        @segments = 0
+        @since = 0
+        @lit = Array.new(DIGITS * 7, 0)
+        @shown = Array.new(DIGITS, 0)
+        @shown_at = Array.new(DIGITS, -DARK_CYCLES - 1)
+      end
+
+      # U2, whose port B selects the row the keys are read from.
+      def connect(rriot)
+        @rriot = rriot
+      end
+
+      # Holds down the key KEYS names `name`, and lets go of any other.
+      def press(name)
+        code = KEYS.index(name)
+        raise ArgumentError, "no KIM-1 key named #{name}" if code.nil?
+
+        @held = code
+      end
+
+      def release
+        @held = -1
+      end
+
+      # The name of the key held down, or nil.
+      def held = @held.negative? ? nil : KEYS[@held]
+
+      def read_a(_lines)
+        port_b = @rriot.port_b_output
+        row = decoded(port_b)
+        mask = @tty_in_high || port_b.anybits?(0x20) ? 0xff : 0x7f
+        mask &= 0xfe if row == 3 && @tty
+        held = @held
+        mask &= ~(0x40 >> (held % 7)) & 0xff if held >= 0 && held / 7 == row
+        mask
+      end
+
+      def read_b(_lines) = @tape.input
+
+      # The lines U2's ports drive after a write to them.
+      def lines_written(port_a, port_b)
+        @tape.output(port_b)
+        digit = decoded(port_b) - FIRST_DIGIT
+        digit = -1 unless digit >= 0 && digit < DIGITS
+        segments = digit.negative? ? 0 : port_a & 0x7f
+        return if digit == @digit && segments == @segments
+
+        now = @clock.cycles
+        end_lit(now)
+        @digit = digit
+        @segments = segments
+        @since = now
+      end
+
+      # The cycles each segment has been lit since the last call, seven to
+      # a digit from the left, a to g, and starts counting again.
+      def lit_cycles
+        now = @clock.cycles
+        end_lit(now)
+        @since = now
+        totals = @lit.dup
+        @lit.map! { 0 }
+        totals
+      end
+
+      # The segments, a in bit 0 to g in bit 6, each digit shows: its
+      # pattern the last time it was lit for SHOWN_CYCLES or more, or 0
+      # once it has been dark for DARK_CYCLES.
+      def display
+        now = @clock.cycles
+        Array.new(DIGITS) do |digit|
+          if digit == @digit && @segments != 0 && now - @since >= SHOWN_CYCLES
+            @segments
+          elsif now - @shown_at[digit] <= DARK_CYCLES
+            @shown[digit]
+          else
+            0
+          end
+        end
+      end
+
+      # The display as text, such as "0200 A9": a space for a dark digit
+      # and ? for a pattern that isn't a hex digit, with a space between
+      # the address and the data.
+      def display_text
+        chars = display.map do |segments|
+          next " " if segments.zero?
+
+          index = HEX_SEGMENTS.index(segments)
+          index.nil? ? "?" : index.to_s(16).upcase
+        end
+        "#{chars[0, 4].join} #{chars[4, 2].join}"
+      end
+
+      private
+
+      def decoded(port_b) = (port_b >> 1) & 0x0f
+
+      def end_lit(now)
+        digit = @digit
+        return if digit.negative? || @segments.zero?
+
+        lit = now - @since
+        7.times { |segment| @lit[(digit * 7) + segment] += lit if @segments.anybits?(1 << segment) }
+        return if lit < SHOWN_CYCLES
+
+        @shown[digit] = @segments
+        @shown_at[digit] = now
+      end
+    end
+  end
+end

data/lib/badline/kim1/rriots.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Badline
+  class KIM1
+    # Each 6530 a class of its own, so each keeps one type of peripheral.
+
+    # U2, the 6530-002: the monitor's ROM, and the ports that drive the
+    # keypad, the display, the teletype and the tape. Its peripheral is
+    # the Panel, which hears every write to the port and direction
+    # registers, so it can time how long each LED segment is lit.
+    class MonitorRRIOT < Chips::RRIOT
+      def reset!
+        super
+        @peripheral&.lines_written(port_a_output, port_b_output)
+      end
+
+      def poke(addr, value)
+        super
+        @peripheral.lines_written(port_a_output, port_b_output) if addr.nobits?(0x04)
+      end
+    end
+
+    # U3, the 6530-003: the tape routines' ROM, and the ports the
+    # application connector carries for the user, with nothing on them.
+    class UserRRIOT < Chips::RRIOT
+    end
+  end
+end