badline 0.14.0 → 0.15.1

data/lib/badline/chips/tia.rb

@@ -9,20 +9,28 @@ module Badline
     #
     # A pin read as an output returns what the port drives, and one read as
     # an input returns what the other side drives, #inputs, per port.
+    #
+    # A cable plugged in (Drives::Model1551::Cable) hears every write and
+    # reset, which can move the pins it carries.
     class TIA
       attr_reader :ports, :directions
 
       # What the other side drives onto each port's pins.
       attr_reader :inputs
 
+      # The cable to the other side, or nil.
+      attr_accessor :cable
+
       def initialize
         @inputs = [0, 0, 0]
+        @cable = nil
         reset!
       end
 
       def reset!
         @ports = [0, 0, 0]
         @directions = [0, 0, 0]
+        @cable&.moved
       end
 
       def peek(addr)
@@ -43,6 +51,26 @@ module Badline
         else
           @ports[register] = value
         end
+        @cable&.moved
+      end
+
+      # The levels on +port+'s pins as the chip leaves them: an output's
+      # level, and 1 for an input, which the chip doesn't drive.
+      def output(port)
+        direction = @directions[port]
+        (@ports[port] & direction) | (~direction & 0xff)
+      end
+
+      # The ports, their directions and what the other side drives, in a
+      # keyed snapshot module (Snapshot::Keyed, BL-TIA1 and BL-TIA2).
+      def save_fields(out)
+        out.ints("ports", @ports).ints("directions", @directions).ints("inputs", @inputs)
+      end
+
+      def load_fields(input)
+        input.ints_into("ports", @ports)
+        input.ints_into("directions", @directions)
+        input.ints_into("inputs", @inputs)
       end
     end
   end

data/lib/badline/chips/vic/register_log.rb

@@ -43,7 +43,10 @@ module Badline
         # register back at the value it held when the line started.
         def rewind
           @values.length.times { |reg| @values[reg] = @registers[reg] }
-          @seed.each_with_index { |value, reg| @values[reg] = value unless value.nil? }
+          @seed.each_index do |reg|
+            value = @seed[reg]
+            @values[reg] = value unless value.nil?
+          end
           @cursor = 0
           @next_x = @entries.empty? ? Float::INFINITY : @entries[0][0]
         end

data/lib/badline/drives/datasette/keyed_state.rb

@@ -4,13 +4,18 @@ module Badline
   module Drives
     class Datasette
       # The datasette's fields in a keyed snapshot module (Snapshot::Keyed,
-      # BL-TAPE): the keys, the motor, the countdown to the next pulse, and
-      # a tape in it under tape.*: its path, its bytes and how far it has
-      # played. A tape that isn't in leaves tape.* out. The sense and flag
-      # handlers don't fire on load.
+      # BL-TAPE): the keys, the motor, the countdown to the next pulse,
+      # whether it records, the cycles since the write line's last edge and
+      # that line's level, and a tape in it under tape.*: its path, its
+      # bytes and how far it has played. A tape that isn't in leaves tape.* out. A datasette that
+      # times the read line's level adds when in the countdown the line
+      # rises, and whether a recording's low half wave is on the tape. The
+      # sense and flag handlers don't fire on load.
       module KeyedState
         def save_fields(out)
           out.bool("playing", @playing).bool("motor", @motor).int("countdown", @countdown)
+          out.bool("recording", @recording).int("since", @since).bool("write_high", @write_high)
+          out.int("rise_at", @rise_at).bool("low_recorded", @low_recorded) if @level
           tape = @tape
           return out unless tape
 
@@ -23,6 +28,11 @@ module Badline
           @playing = input.bool("playing", @playing)
           @motor = input.bool("motor", @motor)
           @countdown = input.int("countdown", @countdown)
+          @recording = input.bool("recording", @recording)
+          @since = input.int("since", @since)
+          @write_high = input.bool("write_high", @write_high)
+          @rise_at = input.int("rise_at", @rise_at)
+          @low_recorded = input.bool("low_recorded", @low_recorded)
           bytes = input.bytes("tape.bytes", "".b).bytes
           return @tape = nil if bytes.empty?
 

data/lib/badline/drives/datasette.rb

@@ -27,6 +27,7 @@ module Badline
         @motor = false
         @countdown = 0
         @rise_at = 0
+        @low_recorded = false
         @flag_handler = nil
         @sense_handler = nil
       end
@@ -78,6 +79,7 @@ module Badline
         press(true)
         @recording = true
         @since = 0
+        @low_recorded = false
       end
 
       def recording? = @recording
@@ -85,14 +87,21 @@ module Badline
       # The machine's tape write line. While the deck records with its motor
       # running, each rising edge ends a pulse on the tape, as long as the
       # time since the edge before, and plays back as a falling edge on the
-      # read line.
+      # read line. A datasette built with +level: true+ records a version 2
+      # tape's half waves instead: a rising edge ends the low half and a
+      # falling edge the high half after it, so the tape plays back the
+      # levels it recorded (#read_high?).
       def write_line=(high)
-        rose = high && !@write_high
+        edge = high != @write_high
         @write_high = high
-        return unless rose && @recording && running?
+        return unless edge && @recording && running?
 
-        @tape.record_pulse(@since)
-        @since = 0
+        if @level && @tape.half_waves?
+          record_half_wave(high)
+        elsif high
+          @tape.record_pulse(@since)
+          @since = 0
+        end
       end
 
       # Sets the write line's level without recording an edge, as a
@@ -153,6 +162,14 @@ module Badline
         @countdown = first + @rise_at
       end
 
+      # A high half wave goes on the tape only after the low half before it,
+      # so the tape starts with a whole pulse.
+      def record_half_wave(rose)
+        @tape.record_half_wave(@since) if rose || @low_recorded
+        @low_recorded = rose
+        @since = 0
+      end
+
       def press(down)
         return if down == @playing || !@connected
 

data/lib/badline/drives/engine/core.rb

@@ -24,8 +24,11 @@ module Badline
       # sleeps through them too (see Orbit).
       #
       # A model includes Core and builds its parts, sets @clock_hz and
-      # @idle_loop, and runs one drive cycle in step. It hears ATN on
-      # connecting (hear_atn), drives the serial bus (serial_output), and
+      # @idle_loop, and runs one drive cycle in step. Its @serial_port faces
+      # the host: it says whether the host moved the lines the drive
+      # listens to (atn_moved?) and takes them for the next host cycle
+      # (latch_host), as the serial port does for ATN on the serial bus
+      # (SerialConnection) and the TCBM cable does on the 1551. The model
       # answers Idle's and Orbit's questions about its chips, as VIAs does
       # for the 1541 and the 1571.
       module Core
@@ -33,7 +36,7 @@ module Badline
         include Idle
         include Orbit
 
-        attr_reader :device, :serial_bus
+        attr_reader :device
 
         def cpu
           settle!
@@ -62,17 +65,6 @@ module Badline
           @host_clock_hz = clock_hz
         end
 
-        # Plugs the drive into a serial bus, leaving the one it was on. A drive
-        # starts out on a bus of its own, with nothing else on it.
-        def connect(serial_bus)
-          settle!
-          @serial_bus&.detach(self)
-          @serial_bus = serial_bus
-          @serial_port.bus = serial_bus
-          serial_bus.attach(self)
-          hear_atn
-        end
-
         # Puts a Disk in the drive (Disk.from_d64 makes one from an image).
         # Nil takes the disk out.
         def insert(disk)

data/lib/badline/drives/engine/idle.rb

@@ -47,6 +47,14 @@ module Badline
       #
       # The timer's interrupts come round too, and once they do, the drive
       # sleeps on through them (see Orbit).
+      #
+      # A model whose loop counts its passes in a byte of RAM, as the 1551's
+      # increments $61, names it in @pass_counter. A pass may then leave
+      # that byte one higher than it found it, and the drive sleeps only
+      # until the count would wrap, where the loop goes another way. The
+      # model compares the CPU without the increment's working registers
+      # (IdleCPU#counting_state), which skipping the passes sets as the
+      # last one would have left them (IdleCPU#counted).
       module Idle
         # Whether the drive may sleep through its idle loop. On by default,
         # but for a drive whose CPU logs each instruction.
@@ -64,6 +72,7 @@ module Badline
           @recording = false
           @pass_cycles = 0
           @pass_instructions = 0
+          @pass_counter = -1
           init_sleep
           init_orbits
         end
@@ -104,22 +113,51 @@ module Badline
         end
 
         # Whether the counters leave room for a whole pass.
-        def room_for_pass? = quiet_cycles >= @cycles - @record_cycles
+        def room_for_pass? = quiet_cycles >= @cycles - @record_cycles && passes_to_count.positive?
 
         # Sleeps through the pass just recorded, over and over.
         def fall_asleep
-          @pass_cycles = @cycles - @record_cycles
+          pass_cycles = @cycles - @record_cycles
+          @pass_cycles = pass_cycles
           @pass_instructions = @cpu.instructions - @record_instructions
           @asleep = true
           @host_still = false
           @owed = 0
-          @budget = quiet_cycles
+          budget = quiet_cycles
+          unless @pass_counter.negative?
+            counted = passes_to_count * pass_cycles
+            budget = counted if counted < budget
+          end
+          @budget = budget
           anchor
         end
 
+        # The RAM the pass read or wrote as it found it, but for the pass
+        # counter, one higher.
         def ram_as_found?
           ram = @bus.ram
-          @bus.touched.all? { |addr, value| ram.peek(addr) == value }
+          counter = @pass_counter
+          @bus.touched.all? do |addr, value|
+            ram.peek(addr) == (addr == counter ? value + 1 : value)
+          end
+        end
+
+        # How many more passes the pass counter can count before it wraps,
+        # and 1 without a pass counter.
+        def passes_to_count
+          counter = @pass_counter
+          counter.negative? ? 1 : 0xff - @bus.ram.peek(counter)
+        end
+
+        # Counts +passes+ more passes in the pass counter.
+        def count_passes(passes)
+          counter = @pass_counter
+          return if counter.negative?
+
+          ram = @bus.ram
+          count = ram.peek(counter) + passes
+          ram.poke(counter, count)
+          @cpu.counted(count)
         end
       end
     end

data/lib/badline/drives/engine/idle_cpu.rb

@@ -18,6 +18,24 @@ module Badline
            @address, @pointer, @dummy_address, @value, @rmw_result]
         end
 
+        # idle_state but for the byte a read-modify-write read and the one
+        # it wrote, which a pass that counts in RAM leaves one higher each
+        # time (Drives::Engine::Idle's pass counter).
+        def counting_state
+          [@program_counter, @stack_pointer, @a, @x, @y, @status.value,
+           @irq, @nmi, @irq_sample, @irq_pending, @nmi_sample, @nmi_pending, @skip_poll,
+           @boundary_irq, @boundary_nmi, @so_high, @interrupt, @brk, @pending_write, @stalled_at, @traps,
+           @operation, @optional_dummy, @boundary_crossed, @branch_taken,
+           @address, @pointer, @dummy_address]
+        end
+
+        # The working registers as the increment that brought a counter to
+        # +count+ left them.
+        def counted(count)
+          @value = (count - 1) & 0xff
+          @rmw_result = count
+        end
+
         # Counts +cycles+ cycles and +instructions+ instructions that ran
         # without changing anything idle_state holds.
         def fast_forward(cycles, instructions)

data/lib/badline/drives/engine/serial_connection.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    module Engine
+      # A drive on the serial bus, beside Core: the 1541, the 1571 and the
+      # 1581. It hears ATN on connecting (hear_atn) and drives the bus
+      # (serial_output).
+      module SerialConnection
+        attr_reader :serial_bus
+
+        # Plugs the drive into a serial bus, leaving the one it was on. A drive
+        # starts out on a bus of its own, with nothing else on it.
+        def connect(serial_bus)
+          settle!
+          @serial_bus&.detach(self)
+          @serial_bus = serial_bus
+          @serial_port.bus = serial_bus
+          serial_bus.attach(self)
+          hear_atn
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/engine/sleep.rb

@@ -104,6 +104,7 @@ module Badline
           cycles = passes * @pass_cycles
           @cpu.fast_forward(cycles, passes * @pass_instructions)
           fast_forward_chips(cycles)
+          count_passes(passes)
           @cycles += cycles
           @budget -= cycles
           cycles

data/lib/badline/drives/engine.rb

@@ -4,6 +4,7 @@ require "badline/drives/engine/sleep"
 require "badline/drives/engine/idle"
 require "badline/drives/engine/orbit"
 require "badline/drives/engine/core"
+require "badline/drives/engine/serial_connection"
 require "badline/drives/engine/vias"
 require "badline/drives/engine/fast_serial"
 require "badline/drives/engine/idle_cpu"

data/lib/badline/drives/model1541/byte_ready.rb

@@ -9,6 +9,14 @@ module Badline
         # VIA 2, which DiskVIA plugs in.
         attr_writer :via
 
+        # The 1551's TIA, whose port B drives the byte to write
+        # (Drives::Model1551::TIA), where there is no VIA 2.
+        attr_writer :tia
+
+        # The byte the last BYTE READY read, which a 1551's gate array
+        # latches.
+        attr_accessor :latched_byte
+
         # Whether BYTE READY reached SO for the CPU to sample on the drive's
         # next cycle.
         attr_accessor :so_pending
@@ -25,15 +33,23 @@ module Badline
         # on, latches port A. It reaches the CPU's SO pin while VIA 2's CA2
         # (SOE) is high, which lets the DOS spin on BVC for each byte. The CPU
         # samples SO on the next cycle.
+        #
+        # A 1551 has no VIA there: its gate array latches the byte read for
+        # its TIA's port B (latched_byte), and BYTE LATCHED reaches its
+        # CPU's port.
         def byte_ready!
           @byte_latched = true
-          @via.ca1 = false
-          @so_pending = true if @via.ca2_output
+          @latched_byte = @shift & 0xff
+          via = @via
+          return unless via
+
+          via.ca1 = false
+          @so_pending = true if via.ca2_output
         end
 
         # BYTE READY lets go of CA1 with the next bit.
         def byte_ready_ended!
-          @via.ca1 = true
+          @via&.ca1 = true
         end
 
         # Whether BYTE READY has come since the CPU last read VIA 2, as the

data/lib/badline/drives/model1541/mechanism.rb

@@ -90,6 +90,8 @@ module Badline
         # on phase 0.
         def initialize(slip: 0)
           @via = nil
+          @tia = nil
+          @latched_byte = 0
           @so_pending = false
           @disk = nil
           @half_track = START_HALF_TRACK
@@ -275,11 +277,18 @@ module Badline
           return unless @bits == 8
 
           @bits = 0
-          @write_shift = @writing ? @via.port_a_output : @shift & 0xff
+          @write_shift = @writing ? write_byte : @shift & 0xff
           @byte_ready = true
           byte_ready!
         end
 
+        # The byte the write shift register loads in write mode: what VIA 2
+        # drives on port A, or on a 1551 what its TIA drives on port B.
+        def write_byte
+          via = @via
+          via ? via.port_a_output : @tia.port_b_output
+        end
+
         # The stepper's rotor turns with the head, a phase to each half
         # track, so the energized phase pulls the head to the neighbouring
         # half track it belongs to. A phase two away pulls both ways, and the

data/lib/badline/drives/model1541.rb

@@ -18,6 +18,7 @@ module Badline
     # clocks it against the host and sleeps through the DOS's idle loop.
     class Model1541
       include Engine::Core
+      include Engine::SerialConnection
       include Engine::VIAs
 
       CLOCK_HZ = 1_000_000

data/lib/badline/drives/model1551/bus.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1551
+      # The drive CPU's bus, as the gate array decodes it (schematic 251860):
+      #
+      # $0000-$0001 - the 6510T's port (Port)
+      # $0002-$07FF - 2 KB of RAM
+      # $4000-$7FFF - the TIA, its eight registers mirrored
+      # $C000-$FFFF - the DOS ROM
+      #
+      # Writes to the ROM and to the rest go nowhere, and a read from the
+      # rest finds the last byte on the data bus.
+      #
+      # While Engine::Idle records a pass of the DOS's idle loop, the bus
+      # watches it (watch!): the RAM it reads and writes, and whether it
+      # reached the port or the TIA, which makes the pass volatile, but for
+      # reads of the TIA's port A, the cable's data lines, which hold still
+      # until the computer moves them. While Engine::Orbit looks for an
+      # orbit, the bus guards the drive (guard!), and any access to the
+      # port or the TIA taints it.
+      class Bus
+        include Addressable
+
+        attr_reader :ram, :rom, :port, :tia, :data, :volatile, :touched, :tainted, :touched_timers
+
+        def initialize(rom:, port:, tia:)
+          addressable_at(0, length: 2**16)
+          @ram = Memory.new([], length: 0x0800, start: 0)
+          @rom = rom
+          @port = port
+          @tia = tia
+          @data = 0
+          @recording = @guarding = @watching = false
+          @volatile = @tainted = false
+          @touched = {}
+          @touched_timers = 0
+        end
+
+        def peek(addr)
+          return @data = @rom.peek(addr) if addr >= 0xc000
+
+          if addr < 0x0800
+            return @data = port_peek(addr) if addr < 2
+
+            touch(addr) if @recording
+            return @data = @ram.peek(addr)
+          end
+          return @data unless addr.between?(0x4000, 0x7fff)
+
+          watch_chip(addr.nobits?(0x07)) if @watching
+          @data = @tia.peek(addr)
+        end
+
+        def poke(addr, value)
+          @data = value
+          if addr < 0x0800
+            return port_poke(addr, value) if addr < 2
+
+            touch(addr) if @recording
+            @ram.poke(addr, value)
+          elsif addr.between?(0x4000, 0x7fff)
+            watch_chip(false) if @watching
+            @tia.poke(addr, value)
+          end
+        end
+
+        # Starts watching: see volatile and touched.
+        def watch!
+          @recording = true
+          @volatile = false
+          @touched = {}
+          watching!
+        end
+
+        def unwatch!
+          @recording = false
+          watching!
+        end
+
+        # Starts guarding: see tainted.
+        def guard!
+          @guarding = true
+          @tainted = false
+          watching!
+        end
+
+        # The drive's RAM and the byte last on its data bus, in a keyed
+        # snapshot module (BL-D8-RAM).
+        def save_fields(out)
+          out.int("data", @data).bytes("ram", @ram.read(0, @ram.length))
+        end
+
+        def load_fields(input)
+          @data = input.byte("data", @data)
+          ram = @ram.read(0, @ram.length)
+          @ram.write(0, input.bytes_into("ram", ram))
+          @watching = false
+        end
+
+        private
+
+        def port_peek(addr)
+          watch_chip(false) if @watching
+          @port.peek(addr)
+        end
+
+        def port_poke(addr, value)
+          watch_chip(false) if @watching
+          @port.poke(addr, value)
+        end
+
+        def touch(addr)
+          @touched[addr] = @ram.peek(addr) unless @touched.key?(addr)
+        end
+
+        def watching!
+          @watching = @recording || @guarding
+        end
+
+        # The CPU reached the port or the TIA: +steady+ for a read of the
+        # TIA's port A.
+        def watch_chip(steady)
+          if @recording && !steady
+            @volatile = true
+            @recording = false
+          end
+          if @guarding
+            @tainted = true
+            @guarding = false
+          end
+          watching!
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/model1551/cable.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1551
+      # TCBM, the cable between the 1551's TIA and the 6523 TIA in its
+      # interface in the computer's expansion port (zimmers.net's 1551
+      # memory map, schematic 251860):
+      #
+      # - the eight data lines join the two port As;
+      # - the drive's STATUS0 and STATUS1 (PC0-1) reach the computer's PB0-1;
+      # - the drive's ACK (PC3) reaches the computer's PC7;
+      # - the computer's DAV (PC6) reaches the drive's PC7.
+      #
+      # The drive pulls every line up, so a line neither side drives low
+      # reads 1. The computer's other port B and C pins read 0.
+      #
+      # The computer sees the drive's lines as soon as the drive writes
+      # them. The drive sees the computer's a host cycle late, as the
+      # cable latched them at the end of the last (latch_host), as a drive
+      # on the serial bus sees ATN: the cable is the 1551's serial port to
+      # Drives::Engine::Core, and a write that moves the computer's lines
+      # wakes a drive asleep in its idle loop (atn_moved?).
+      class Cable
+        STATUS = 0x03
+        ACK = 0x08
+        DAV = 0x40
+
+        attr_reader :host, :drive
+
+        # Plugs the cable into +host+, the computer's Chips::TIA, and
+        # +drive+, the drive's (Model1551::TIA#chip), for +unit+, the drive.
+        def initialize(host, drive, unit)
+          @host = host
+          @drive = drive
+          @unit = unit
+          @data = 0xff
+          @dav = DAV
+          @moved = false
+          host.cable = self
+          drive.cable = self
+          relatch
+        end
+
+        # Pulls the cable out: the computer's TIA reads 0 on every input and
+        # the drive's lines float high.
+        def unplug
+          @host.cable = nil
+          @drive.cable = nil
+          host_inputs = @host.inputs
+          drive_inputs = @drive.inputs
+          3.times do |port|
+            host_inputs[port] = 0
+            drive_inputs[port] = 0xff
+          end
+        end
+
+        # Whether the computer moved its lines since latch_host.
+        def atn_moved? = @moved
+
+        # Takes the computer's lines for the drive's cycles in the next host
+        # cycle.
+        def latch_host
+          return unless @moved
+
+          @moved = false
+          relatch
+        end
+
+        # Takes the computer's lines as they stand, as a snapshot leaves
+        # them.
+        def relatch
+          host = @host
+          @data = host.output(0)
+          @dav = host.output(2) & DAV
+          @moved = false
+          moved
+        end
+
+        # Either side wrote its TIA: the computer's inputs follow the drive
+        # at once, and the drive's follow the lines last latched.
+        def moved
+          host = @host
+          drive = @drive
+          drive_data = drive.output(0)
+          drive_lines = drive.output(2)
+          host_lines = host.output(2)
+          host_data = host.output(0)
+          host_inputs = host.inputs
+          host_inputs[0] = host_data & drive_data
+          host_inputs[1] = drive_lines & STATUS
+          host_inputs[2] = ((drive_lines & ACK) << 4) | (host_lines & DAV)
+          drive_inputs = drive.inputs
+          drive_inputs[0] = @data & drive_data
+          drive_inputs[2] = (drive_inputs[2] & 0x7f) | (@dav << 1)
+          return if @moved || (host_data == @data && (host_lines & DAV) == @dav)
+
+          @moved = true
+          @unit.host_written!
+        end
+      end
+    end
+  end
+end