badline 0.13.0 → 0.14.0

data/lib/badline/drives/datasette.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
-require "badline/drives/datasette/saved_state"
+require "badline/drives/datasette/keyed_state"
 
 module Badline
   module Drives
     # The 1530 datasette. Plays a pulse stream into CIA 1's FLAG pin while the
     # motor runs with a key pressed, and reports the keys through the cassette
     # sense line on the $01 port. With RECORD down too, it records the
-    # machine's write line onto the tape instead.
+    # machine's write line onto the tape instead. Built with +level: true+,
+    # it also times the read line's level, for a machine that reads that
+    # (#read_high?) rather than the falling edges.
     class Datasette
-      include SavedState
-
       # What inserting a tape raises on a machine without a cassette port.
       class Missing < ArgumentError; end
-
       attr_reader :tape
       attr_writer :motor
 
-      def initialize(tape = nil)
+      def initialize(tape = nil, level: false)
         @tape = tape
+        @level = level
         @connected = true
         @playing = false
         @recording = false
@@ -26,6 +26,7 @@ module Badline
         @since = 0
         @motor = false
         @countdown = 0
+        @rise_at = 0
         @flag_handler = nil
         @sense_handler = nil
       end
@@ -64,6 +65,7 @@ module Badline
       def rewind
         @tape&.rewind
         @countdown = 0
+        @rise_at = 0
       end
 
       def play! = press(true)
@@ -93,6 +95,12 @@ module Badline
         @since = 0
       end
 
+      # Sets the write line's level without recording an edge, as a
+      # snapshot loads it.
+      def write_level=(high)
+        @write_high = high
+      end
+
       def playing? = @playing
 
       # Sense reads low while a key is down on the deck.
@@ -102,11 +110,22 @@ module Badline
 
       def running? = @playing && @motor && !@tape.nil?
 
+      # The tape read line's level, on a datasette built with +level: true+.
+      # Each pulse holds it low for its first half and high for its second,
+      # up to the falling edge that ends it. A version 2 tape times each
+      # half, and a version 0 or 1 tape's pulse plays as two equal halves.
+      # It reads high while the tape isn't playing.
+      def read_high?
+        return true unless running? && !@recording
+
+        @countdown.positive? && @countdown <= @rise_at
+      end
+
       def cycle!
         return unless running?
         return @since += 1 if @recording
 
-        @countdown = @tape.next_pulse.to_i if @countdown.zero?
+        next_pulse if @countdown.zero?
         return if @countdown.zero?
 
         @countdown -= 1
@@ -120,6 +139,20 @@ module Badline
 
       private
 
+      def next_pulse
+        return @countdown = @tape.next_pulse.to_i unless @level
+        return next_half_waves if @tape.half_waves?
+
+        @countdown = @tape.next_pulse.to_i
+        @rise_at = @countdown / 2
+      end
+
+      def next_half_waves
+        first = @tape.next_half_wave.to_i
+        @rise_at = @tape.next_half_wave.to_i
+        @countdown = first + @rise_at
+      end
+
       def press(down)
         return if down == @playing || !@connected
 

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

@@ -86,6 +86,9 @@ module Badline
         # is the same at the end of every pass the drive sleeps through.
         def led_on? = @mechanism.led_on?
 
+        # The power LED, which stays lit.
+        def power_led_on? = true
+
         # Stores what the head wrote since the motor last stopped in the
         # disk's image, as the motor stopping does.
         def flush

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

@@ -38,14 +38,11 @@ module Badline
           @host = @bus.host_lines
         end
 
-        # The host's lines as last latched. The jumpers and the bus are the
-        # drive's wiring.
-        def save_state(out)
-          out.int(@host)
-        end
+        # The host's lines as the port latched them, under `prefix`.
+        def save_fields(out, prefix) = out.int("#{prefix}host", @host)
 
-        def load_state(input)
-          @host = input.int
+        def load_fields(input, prefix)
+          @host = input.int("#{prefix}host", @host)
         end
 
         # Whether the host has moved ATN since the last latch_host.

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

@@ -38,19 +38,6 @@ module Badline
           init_watch
         end
 
-        # The last byte on the data bus and the RAM. What a watched stretch
-        # touched is Idle's, and a restored bus isn't watching.
-        def save_state(out)
-          out.int(@data)
-          @ram.save_state(out)
-        end
-
-        def load_state(input)
-          @data = input.int
-          @ram.load_state(input)
-          @watching = false
-        end
-
         def peek(addr)
           return @data = @rom.peek(addr | 0x4000) if addr >= 0x8000
 

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
+require "badline/media/extensions"
 require "badline/drives/model1541/sector_reader"
-require "badline/drives/model1541/disk/saved_state"
 
 module Badline
   module Drives
@@ -23,7 +23,8 @@ module Badline
       # host file. The disk is write-protected when the image won't take
       # writes.
       class Disk
-        include SavedState
+        # Whether the image is a .g64 or .g71, by its name.
+        def self.g64?(path) = Media::Extensions.kind(path) == :gcr
 
         MAX_HALF_TRACK = 84
 
@@ -61,16 +62,16 @@ module Badline
         # formatted. `read_only` opens the image write-protected.
         def self.open(path, read_only: false)
           image = image_for(path, read_only)
-          (SavedState.g64?(path) ? from_g64(image) : from_d64(image)).opened(path, read_only)
+          (Disk.g64?(path) ? from_g64(image) : from_d64(image)).opened(path, read_only)
         end
 
         # The image at +path+, by its name: a .g64 or .g71, a .d71, and
-        # anything else a .d64.
-        def self.image_for(path, read_only)
-          return Storage::G64Image.new(path, read_only:) if SavedState.g64?(path)
-          return Storage::D71Image.new(path, read_only:) if File.extname(path).casecmp?(".d71")
+        # anything else a .d64. `bytes` stands in for the file's contents.
+        def self.image_for(path, read_only, bytes = nil)
+          return Storage::G64Image.new(path, read_only:, bytes:) if Disk.g64?(path)
+          return Storage::D71Image.new(path, read_only:, bytes:) if File.extname(path).casecmp?(".d71")
 
-          Storage::D64Image.new(path, read_only:)
+          Storage::D64Image.new(path, read_only:, bytes:)
         end
 
         # A disk from a G64 or G71 image, each half track as the image stores

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

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1541
+      class Disk
+        # The kinds of image a disk embeds, by name.
+        IMAGE_KINDS = %w[none d64 d71 g64].freeze
+
+        # A disk's fields in a keyed snapshot module (BL-D8-DISK): the image
+        # file's path and how it was opened, the image as last flushed,
+        # embedded under image and image.kind, each half track that differs
+        # from what the image decodes to, as track<H>.zone, track<H>.speeds
+        # and track<H>.gcr, raw GCR as the head sees it, and the half tracks
+        # written since the last flush.
+        module KeyedState
+          # The image's path, expanded, and whether it was opened read-only,
+          # for a disk from Disk.open. Nil for a disk made another way.
+          attr_reader :path, :read_only
+
+          # Notes the image's path and how it was opened.
+          def opened(path, read_only)
+            @path = File.expand_path(path)
+            @read_only = read_only
+            self
+          end
+
+          def save_fields(out)
+            path = @path
+            out.text("path", path) if path
+            out.bool("read_only", @read_only == true)
+            image = @image
+            decoded = nil
+            if image
+              out.text("image.kind", Disk.image_kind(image)).text("image.path", image.path.to_s)
+              out.bytes("image", image.contents)
+              decoded = Disk.decode(image)
+            end
+            @tracks.each_with_index { |track, half| save_track_fields(out, half, track, decoded) }
+            out.ints("written", @written.keys)
+          end
+
+          def load_track_fields(input)
+            @tracks.each_index do |half|
+              zone = input.optional_int("track#{half}.zone")
+              next if zone.nil?
+
+              speeds = input.ints("track#{half}.speeds", [])
+              gcr = input.bytes("track#{half}.gcr", "".b).bytes
+              @tracks[half] = Track.new(gcr, zone, speeds.empty? ? nil : speeds.dup)
+            end
+            @written.clear
+            input.ints("written", []).each { |half| @written[half] = true }
+            self
+          end
+
+          private
+
+          def save_track_fields(out, half, track, decoded)
+            return if track.nil?
+
+            original = decoded&.track(half)
+            return if original && original.zone == track.zone && original.speeds == track.speeds &&
+                      original.bytes == track.bytes
+
+            out.int("track#{half}.zone", track.zone)
+            speeds = track.speeds
+            out.ints("track#{half}.speeds", speeds) if speeds
+            out.bytes("track#{half}.gcr", track.bytes)
+          end
+        end
+
+        include KeyedState
+
+        # The kind of `image`, by name.
+        def self.image_kind(image)
+          return "g64" if image.is_a?(Storage::G64Image)
+          return "d71" if image.is_a?(Storage::D71Image)
+
+          "d64"
+        end
+
+        # The tracks `image` holds, as an insert decodes them.
+        def self.decode(image) = image.is_a?(Storage::G64Image) ? from_g64(image) : from_d64(image)
+
+        # The disk a keyed snapshot module describes: its embedded image
+        # decoded, with the tracks the module holds laid over it. The image
+        # takes writes back to its file only while that file is there and
+        # the reader isn't `detached`. With no image, the disk is the
+        # tracks alone, write-protected.
+        def self.from_fields(input, detached: false)
+          path = input.text("path", "")
+          read_only = input.bool("read_only", false)
+          kind = input.choice("image.kind", IMAGE_KINDS, "none")
+          image_path = input.text("image.path", "")
+          disk = kind == "none" ? Disk.new : from_image(input, kind, image_path, read_only || detached)
+          disk.opened(path, read_only || kind == "none") unless path.empty?
+          disk.load_track_fields(input)
+        end
+
+        def self.from_image(input, kind, path, read_only)
+          bytes = input.bytes("image", "".b).bytes
+          writable_path = path.empty? || !File.file?(path) ? "" : path
+          image = case kind
+                  when "g64" then Storage::G64Image.new(writable_path, read_only:, bytes:)
+                  when "d71" then Storage::D71Image.new(writable_path, read_only:, bytes:)
+                  else Storage::D64Image.new(writable_path, read_only:, bytes:)
+                  end
+          decode(image)
+        end
+      end
+
+      class Mechanism
+        # The head, the motor, the stepper and the read and write
+        # electronics in a keyed snapshot module (BL-D8-MECH): where the
+        # head is, the disk's place in its turn, the read clock's next
+        # clock in cycles from now, the shift registers and the flags. The
+        # cell under the head, its width and the next event come from the
+        # track and the time on load, the cell period from the zone, and
+        # the write protection from the disk.
+        module KeyedState
+          def save_fields(out)
+            out.int("half_track", @half_track).int("slip", @slip).int("side", @side_base).int("zone", @zone)
+            out.int("time", @time).int("read_clock_in", @clock_at - @time).int("clocks", @clocks)
+            out.int("shift", @shift).int("ones", @ones).int("bits", @bits).int("write_shift", @write_shift)
+            out.bool("motor", @motor).bool("led", @led).bool("sync", @sync).bool("byte_ready", @byte_ready)
+            out.bool("byte_latched", @byte_latched).bool("writing", @writing).bool("write_gate", @write_gate)
+            out.bool("track_written", @track_written).optional_int("write_index", @write_index)
+          end
+
+          # Puts `disk` under the head without flushing the one there, as a
+          # snapshot load replaces it.
+          def load_fields(input, disk)
+            @disk = disk
+            load_head_fields(input)
+            load_flag_fields(input)
+            @clock = Track.cell(@zone)
+            @protected = disk&.write_protected? || false
+            track_written = input.bool("track_written", false)
+            write_index = input.optional_int("write_index")
+            load_track(@time)
+            @track_written = track_written
+            @write_index = write_index
+          end
+
+          private
+
+          def load_head_fields(input)
+            @half_track = input.int("half_track", @half_track)
+            @slip = input.masked("slip", @slip, 0x03)
+            @side_base = input.int("side", @side_base)
+            @zone = input.masked("zone", @zone, 0x03)
+            @time = input.int("time", @time)
+            @clock_at = @time + input.int("read_clock_in", @clock_at - @time)
+            @clocks = input.int("clocks", @clocks)
+            @shift = input.int("shift", @shift)
+            @ones = input.int("ones", @ones)
+            @bits = input.int("bits", @bits)
+            @write_shift = input.int("write_shift", @write_shift)
+          end
+
+          def load_flag_fields(input)
+            @motor = input.bool("motor", @motor)
+            @led = input.bool("led", @led)
+            @sync = input.bool("sync", @sync)
+            @byte_ready = input.bool("byte_ready", @byte_ready)
+            @byte_latched = input.bool("byte_latched", @byte_latched)
+            @writing = input.bool("writing", @writing)
+            @write_gate = input.bool("write_gate", @write_gate)
+          end
+        end
+
+        include KeyedState
+      end
+
+      class Bus
+        # 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
+      end
+
+      # The drive's own fields in a keyed snapshot module (BL-D8): its model,
+      # its clock phase and cycle count, the SO pulse due, and the host's
+      # lines as the serial port latched them. A save settles the drive first, so it is awake;
+      # a load forgets its orbits.
+      module KeyedState
+        def save_fields(out)
+          settle!
+          out.text("model", model_name).int("phase", @phase).int("cycles", @cycles)
+          out.bool("so_pending", @mechanism.so_pending)
+          @serial_port.save_fields(out, "serial.")
+          out
+        end
+
+        def load_fields(input)
+          settle!
+          input.choice("model", [model_name], model_name)
+          @phase = input.int("phase", @phase)
+          @cycles = input.int("cycles", @cycles)
+          @mechanism.so_pending = input.bool("so_pending", @mechanism.so_pending)
+          @serial_port.load_fields(input, "serial.")
+        end
+
+        def restored! = forget_orbits
+
+        # The drive as modules of its own, named from `name` (BL-D8 for
+        # device 8): its own fields, its RAM, each VIA, the CPU, the
+        # mechanism and the disk, when one is in.
+        def save_modules(sections, name)
+          sections << Snapshot::Keyed.section(name) { |out| save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-RAM") { |out| @bus.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-VIA1") { |out| @via1.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-VIA2") { |out| @via2.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-CPU") { |out| @cpu.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-MECH") { |out| @mechanism.save_fields(out) }
+          disk = @mechanism.disk
+          sections << Snapshot::Keyed.section("#{name}-DISK") { |out| disk.save_fields(out) } if disk
+          sections
+        end
+
+        # The drive from its modules, `input` being its own. No disk module
+        # means no disk in the drive.
+        def load_modules(modules, input, name)
+          load_fields(input)
+          @bus.load_fields(modules.required("#{name}-RAM"))
+          @via1.load_fields(modules.required("#{name}-VIA1"))
+          @via2.load_fields(modules.required("#{name}-VIA2"))
+          @cpu.load_fields(modules.required("#{name}-CPU"))
+          disk = modules.optional("#{name}-DISK")
+          mechanism = modules.required("#{name}-MECH")
+          @mechanism.load_fields(mechanism, disk.nil? ? nil : Disk.from_fields(disk, detached: modules.detached?))
+          @via1.restored!
+          @via2.restored!
+          @cpu.restored!
+          restored!
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "badline/drives/model1541/rotation"
-require "badline/drives/model1541/mechanism/saved_state"
 require "badline/drives/model1541/byte_ready"
 
 module Badline
@@ -71,7 +70,6 @@ module Badline
       # its track 0 sensor looks for the head (Mechanism.new's +slip+).
       class Mechanism
         include Rotation
-        include SavedState
         include ByteReady
 
         MOTOR = 0x04

data/lib/badline/drives/model1541.rb

@@ -9,7 +9,7 @@ require "badline/drives/model1541/track"
 require "badline/drives/model1541/disk"
 require "badline/drives/model1541/mechanism"
 require "badline/drives/model1541/disk_via"
-require "badline/drives/model1541/saved_state"
+require "badline/drives/model1541/keyed_state"
 
 module Badline
   module Drives
@@ -19,7 +19,6 @@ module Badline
     class Model1541
       include Engine::Core
       include Engine::VIAs
-      include SavedState
 
       CLOCK_HZ = 1_000_000
 

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

@@ -40,19 +40,6 @@ module Badline
           init_watch
         end
 
-        # The last byte on the data bus and the RAM. What a watched stretch
-        # touched is Idle's, and a restored bus isn't watching.
-        def save_state(out)
-          out.int(@data)
-          @ram.save_state(out)
-        end
-
-        def load_state(input)
-          @data = input.int
-          @ram.load_state(input)
-          @watching = false
-        end
-
         def peek(addr)
           return @data = @rom.peek(addr) if addr >= 0x8000
           return @data = chip_peek(addr) if addr >= 0x2000

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1571
+      class WD1770
+        # The controller's registers, status and result in a keyed snapshot
+        # module (BL-D8-FDC), and how many of the drive CPU's cycles until a
+        # command under way finishes. It loads after the CPU, which that
+        # counts from.
+        def save_fields(out)
+          out.ints("registers", @registers).int("status", @status).int("result", @result)
+          out.int("due_in", @due - @cpu.cycles)
+        end
+
+        def load_fields(input)
+          input.ints_into("registers", @registers)
+          @status = input.byte("status", @status)
+          @result = input.int("result", @result)
+          @due = @cpu.cycles + input.int("due_in", @due - @cpu.cycles)
+        end
+      end
+
+      class Bus
+        # 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
+      end
+
+      # The drive's own fields in a keyed snapshot module (BL-D8), as the
+      # 1541's. The clock rate, the side and the fast serial direction come
+      # from VIA 1's port A once the VIAs are loaded.
+      module KeyedState
+        def save_fields(out)
+          settle!
+          out.text("model", model_name).int("phase", @phase).int("cycles", @cycles)
+          out.bool("so_pending", @mechanism.so_pending)
+          @serial_port.save_fields(out, "serial.")
+          out
+        end
+
+        def load_fields(input)
+          settle!
+          input.choice("model", [model_name], model_name)
+          @phase = input.int("phase", @phase)
+          @cycles = input.int("cycles", @cycles)
+          @mechanism.so_pending = input.bool("so_pending", @mechanism.so_pending)
+          @serial_port.load_fields(input, "serial.")
+        end
+
+        def restored!
+          @fast_serial_out = @via1.port_a_output.anybits?(FAST_SERIAL_OUT)
+          port_a_written(@via1.port_a_output)
+          push_fast_output(@fast_serial_out ? fast_pins : 0)
+          forget_orbits
+        end
+
+        # The drive as modules of its own, as the 1541's, with the CIA and
+        # the WD1770.
+        def save_modules(sections, name)
+          sections << Snapshot::Keyed.section(name) { |out| save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-RAM") { |out| @bus.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-VIA1") { |out| @via1.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-VIA2") { |out| @via2.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-CIA") { |out| @cia.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-CPU") { |out| @cpu.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-FDC") { |out| @fdc.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-MECH") { |out| @mechanism.save_fields(out) }
+          disk = @mechanism.disk
+          sections << Snapshot::Keyed.section("#{name}-DISK") { |out| disk.save_fields(out) } if disk
+          sections
+        end
+
+        # The drive from its modules, `input` being its own. The WD1770
+        # counts from the CPU's cycles, so it loads after the CPU.
+        def load_modules(modules, input, name)
+          load_fields(input)
+          @bus.load_fields(modules.required("#{name}-RAM"))
+          @via1.load_fields(modules.required("#{name}-VIA1"))
+          @via2.load_fields(modules.required("#{name}-VIA2"))
+          @cia.load_fields(modules.required("#{name}-CIA"))
+          @cpu.load_fields(modules.required("#{name}-CPU"))
+          @fdc.load_fields(modules.required("#{name}-FDC"))
+          disk = modules.optional("#{name}-DISK")
+          mechanism = modules.required("#{name}-MECH")
+          @mechanism.load_fields(mechanism,
+                                 disk.nil? ? nil : Model1541::Disk.from_fields(disk, detached: modules.detached?))
+          @via1.restored!
+          @via2.restored!
+          @cia.restored!
+          @cpu.restored!
+          restored!
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/drives/model1571/wd1770.rb

@@ -54,20 +54,6 @@ module Badline
           offset.zero? ? command(value) : @registers[offset] = value
         end
 
-        def save_state(out)
-          out.ints([*@registers, @status, @due, @result])
-        end
-
-        # A state from before the controller ran commands holds the four
-        # registers alone.
-        def load_state(input)
-          values = input.ints
-          @registers = values[0, 4]
-          @status = values[4] || 0
-          @due = values[5] || 0
-          @result = values[6] || 0
-        end
-
         private
 
         def command(value)

data/lib/badline/drives/model1571.rb

@@ -5,7 +5,7 @@ require "badline/drives/model1571/wd1770"
 require "badline/drives/model1571/serial_port"
 require "badline/drives/model1571/serial_via"
 require "badline/drives/model1571/bus"
-require "badline/drives/model1571/saved_state"
+require "badline/drives/model1571/keyed_state"
 
 module Badline
   module Drives
@@ -28,7 +28,6 @@ module Badline
       include Engine::Core
       include Engine::VIAs
       include Engine::FastSerial
-      include SavedState
 
       CLOCK_HZ = 1_000_000
       FAST_CLOCK_HZ = 2_000_000

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

@@ -41,19 +41,6 @@ module Badline
           @touched_timers = 0
         end
 
-        # The last byte on the data bus and the RAM. What a watched stretch
-        # touched is Idle's, and a restored bus isn't watching.
-        def save_state(out)
-          out.int(@data)
-          @ram.save_state(out)
-        end
-
-        def load_state(input)
-          @data = input.int
-          @ram.load_state(input)
-          @watching = false
-        end
-
         def peek(addr)
           return @data = @rom.peek(addr) if addr >= 0x8000
           return @data = chip_peek(addr) if addr >= 0x2000