badline 0.11.0 → 0.11.1

data/lib/badline/drive1541/bus.rb

@@ -18,41 +18,15 @@ module Badline
     # page is what its dummy read found. VICE-testprogs drive/openbus pins
     # both on a real 1541.
     #
-    # While Idle records a pass of the DOS's idle loop, the bus watches it
-    # (see watch!). While Idle looks for an orbit, the bus guards the drive
-    # (see guard!).
+    # While Idle records a pass of the DOS's idle loop, the bus watches it,
+    # and while Idle looks for an orbit, it guards the drive (see
+    # Drive::Watch).
     class Bus
       include Addressable
-
-      # VIA registers, as bits by offset, whose access makes a watched
-      # stretch volatile: reads of either VIA's counters and shift register
-      # and of VIA 1's port B, and writes to VIA 2's timers, shift register
-      # and ACR. Any write to VIA 1 does too (watch_write).
-      VOLATILE_VIA1_READS = 0x0731
-      VOLATILE_VIA2_READS = 0x0730
-      VOLATILE_VIA2_WRITES = 0x0ff0
-
-      # The timer each VIA register reaches, by offset, as bits: 1 for
-      # timer 1 and 2 for timer 2.
-      TIMER_REGISTERS = [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, 0, 0].freeze
+      include Drive::Watch
 
       attr_reader :ram, :rom, :via1, :via2, :data
 
-      # Whether a watched stretch did something that makes it unrepeatable.
-      attr_reader :volatile
-
-      # The RAM a watched stretch read or wrote, as each address's value
-      # from before the first access.
-      attr_reader :touched
-
-      # Whether the drive did something since guard! that reached outside
-      # it, or took something in from outside.
-      attr_reader :tainted
-
-      # The timers the drive read or wrote since guard!, as bits: VIA 1's
-      # timer 1 and timer 2 in bits 0 and 1, and VIA 2's in bits 2 and 3.
-      attr_reader :touched_timers
-
       def initialize(rom:, via1:, via2:)
         addressable_at(0, length: 2**16)
         @ram = Memory.new([], length: 0x0800, start: 0)
@@ -60,38 +34,7 @@ module Badline
         @via1 = via1
         @via2 = via2
         @data = 0
-        @recording = @guarding = @watching = false
-        @volatile = @tainted = false
-        @touched = {}
-        @touched_timers = 0
-        @led = 0
-      end
-
-      # Starts watching: see volatile and touched. The bus stops watching
-      # once the stretch turns volatile.
-      def watch!
-        @recording = true
-        @volatile = false
-        @touched = {}
-        watching!
-      end
-
-      def unwatch!
-        @recording = false
-        watching!
-      end
-
-      # Starts guarding: see tainted and touched_timers. Reading VIA 1's
-      # port B, which reads the serial bus, taints the drive, and so do
-      # any write to VIA 1, whose port B drives the serial bus, a write to
-      # VIA 2's shift register or ACR, and VIA 2 turning the motor on or
-      # changing the LED. The bus stops guarding once the drive is tainted.
-      def guard!
-        @guarding = true
-        @tainted = false
-        @touched_timers = 0
-        @led = @via2.port_b_output & Mechanism::LED
-        watching!
+        init_watch
       end
 
       # The last byte on the data bus and the RAM. What a watched stretch
@@ -138,73 +81,6 @@ module Badline
         end
         watch_write(addr) if @watching
       end
-
-      private
-
-      def watching!
-        @watching = @recording || @guarding
-      end
-
-      def touch(addr)
-        @touched[addr] = @ram.peek(addr) unless @touched.key?(addr)
-      end
-
-      def watch_read(addr)
-        if addr < 0x0800
-          touch(addr) if @recording
-        elsif addr >= 0x1800
-          via1 = addr < 0x1c00
-          watch(via1 ? VOLATILE_VIA1_READS : VOLATILE_VIA2_READS, addr) if @recording
-          guard_read(via1, addr & 0x0f) if @guarding
-        end
-      end
-
-      def watch_write(addr)
-        if addr >= 0x1c00
-          watch_via2_write(addr) if @recording
-          guard_via2_write(addr & 0x0f) if @guarding
-        elsif addr >= 0x1800
-          volatile! if @recording
-          taint! if @guarding
-        end
-      end
-
-      # Any write to VIA 1 makes the stretch volatile (watch_write), and so
-      # does a write to VIA 2 that leaves the motor on.
-      def watch_via2_write(addr)
-        watch(VOLATILE_VIA2_WRITES, addr)
-        volatile! if @recording && @via2.port_b_output.anybits?(Mechanism::MOTOR)
-      end
-
-      def watch(volatile, addr)
-        volatile! if volatile.anybits?(1 << (addr & 0x0f))
-      end
-
-      def volatile!
-        @volatile = true
-        @recording = false
-        watching!
-      end
-
-      def guard_read(via1, offset)
-        return taint! if via1 && offset.zero?
-
-        @touched_timers |= via1 ? TIMER_REGISTERS[offset] : TIMER_REGISTERS[offset] << 2
-      end
-
-      def guard_via2_write(offset)
-        return taint! if offset.between?(0x0a, 0x0b)
-
-        @touched_timers |= TIMER_REGISTERS[offset] << 2
-        lines = @via2.port_b_output
-        taint! if lines.anybits?(Mechanism::MOTOR) || (lines & Mechanism::LED) != @led
-      end
-
-      def taint!
-        @tainted = true
-        @guarding = false
-        watching!
-      end
     end
   end
 end

data/lib/badline/drive1541/byte_ready.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # The Mechanism's BYTE READY line: to VIA 2's CA1, to the CPU's SO pin
+    # through SOE, and on the 1571 to a latch VIA 1's PA7 reads.
+    module ByteReady
+      # VIA 2, which DiskVIA plugs in.
+      attr_writer :via
+
+      # Whether BYTE READY reached SO for the CPU to sample on the drive's
+      # next cycle.
+      attr_accessor :so_pending
+
+      # Whether SO is pending, which the drive's cycle samples and clears.
+      def take_so
+        so = @so_pending
+        @so_pending = false
+        so
+      end
+
+      # The read electronics signal a whole GCR byte. BYTE READY pulls VIA
+      # 2's CA1 low, a falling edge that sets its flag and, with latching
+      # 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.
+      def byte_ready!
+        @byte_latched = true
+        @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
+      end
+
+      # Whether BYTE READY has come since the CPU last read VIA 2, as the
+      # 1571 latches it for VIA 1's PA7.
+      def byte_latched? = @byte_latched
+
+      # A read of VIA 2 clears the 1571's BYTE READY latch.
+      def release_byte_latch
+        @byte_latched = false
+      end
+    end
+  end
+end

data/lib/badline/drive1541/cpu.rb

@@ -5,25 +5,7 @@ module Badline
     # The drive's 6502, on the drive's Bus.
     class CPU
       include Badline::CPU::Core
-
-      # Everything the CPU holds but its cycle and instruction counts: the
-      # registers, the interrupt lines and pipeline, and what the last
-      # instruction left in its working registers. Drive1541::Idle compares
-      # it at two instruction boundaries.
-      def idle_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, @value, @rmw_result]
-      end
-
-      # Counts +cycles+ cycles and +instructions+ instructions that ran
-      # without changing anything idle_state holds.
-      def fast_forward(cycles, instructions)
-        @cycles += cycles
-        @instructions += instructions
-      end
+      include Drive::IdleCPU
     end
   end
 end

data/lib/badline/drive1541/disk.rb

@@ -10,6 +10,11 @@ module Badline
     # nothing between them. A .d64 image fills the whole tracks; a .g64
     # can fill any of them, with tracks of any length.
     #
+    # The disk has a second side, for the 1571's second head, its half
+    # tracks numbered from SIDE on. A .d71 fills both sides, its tracks
+    # 36-70 being tracks 1-35 of the second, and a .g71 holds 84 half
+    # tracks a side. A 1541 reads the first side only.
+    #
     # The head writes into the tracks' bytes, and a write to a half track
     # without data gives it a blank Track first. A disk made from an image
     # remembers it: flush reads the sectors back off the tracks written
@@ -21,6 +26,15 @@ module Badline
 
       MAX_HALF_TRACK = 84
 
+      # Where the second side's half tracks start: its track 1 is SIDE + 2.
+      SIDE = MAX_HALF_TRACK + 1
+
+      # The tracks a side of a .d71 holds.
+      D71_SIDE_TRACKS = 35
+
+      # The half track entries a side of a .g71 holds.
+      G71_SIDE_ENTRIES = 84
+
       # GCR bytes around a track in each speed zone: 200 ms of rotation at
       # 300 rpm, in bytes of 32, 30, 28 and 26 µs.
       TRACK_LENGTHS = [6250, 6666, 7142, 7692].freeze
@@ -51,27 +65,63 @@ module Badline
       # the 325-byte GCR data block. The gap after it takes up the rest.
       SECTOR_LENGTH = SYNC_LENGTH + 10 + HEADER_GAP + SYNC_LENGTH + 325
 
-      # A disk from the image at +path+: a .g64 as its tracks are, and
-      # anything else as a .d64, formatted. `read_only` opens the image
-      # write-protected.
+      # A disk from the image at +path+: a .g64 or .g71 as its tracks are,
+      # a .d71 formatted on both sides, and anything else as a .d64,
+      # formatted. `read_only` opens the image write-protected.
       def self.open(path, read_only: false)
         return from_g64(Storage::G64Image.new(path, read_only:)).opened(path, read_only) if State.g64?(path)
+        return from_d64(Storage::D71Image.new(path, read_only:)).opened(path, read_only) if State.d71?(path)
 
         from_d64(Storage::D64Image.new(path, read_only:)).opened(path, read_only)
       end
 
-      # A disk from a G64 image, each half track as the image stores it,
-      # with its speed map. Flushing it writes the tracks back as they are.
+      # A disk from a G64 or G71 image, each half track as the image stores
+      # it, with its speed map. Flushing it writes the tracks back as they
+      # are.
       def self.from_g64(image)
         disk = new(image)
-        (Mechanism::MIN_HALF_TRACK..MAX_HALF_TRACK).each do |half_track|
-          entry = half_track - Mechanism::MIN_HALF_TRACK
+        image.half_tracks.times do |entry|
           track = image.track(entry)
-          disk.write(half_track, Track.new(*track, image.speeds(entry))) if track
+          disk.write(half_track_of(entry), Track.new(*track, image.speeds(entry))) if track
         end
         disk
       end
 
+      # The half track a G64 or G71 table entry holds: entry 0 is track 1,
+      # and a .g71's entries from G71_SIDE_ENTRIES on are the second
+      # side's.
+      def self.half_track_of(entry)
+        side = entry / G71_SIDE_ENTRIES
+        (side * SIDE) + (entry % G71_SIDE_ENTRIES) + Mechanism::MIN_HALF_TRACK
+      end
+
+      # The table entry of a half track, or nil for one a G64 or G71 has
+      # no entry for.
+      def self.entry_of(half_track)
+        side = half_track / SIDE
+        entry = (half_track % SIDE) - Mechanism::MIN_HALF_TRACK
+        (side * G71_SIDE_ENTRIES) + entry if entry.between?(0, G71_SIDE_ENTRIES - 1)
+      end
+
+      # The half track an image's track number is on: a .d71's tracks past
+      # D71_SIDE_TRACKS are on the second side.
+      def self.d64_half_track(image, track)
+        return track * 2 unless image.sides == 2 && track > D71_SIDE_TRACKS
+
+        SIDE + ((track - D71_SIDE_TRACKS) * 2)
+      end
+
+      # The image's track number a half track holds, or nil for a half
+      # track or one past the image's last.
+      def self.d64_track(image, half_track)
+        side = half_track / SIDE
+        return unless (half_track % SIDE).even?
+
+        track = (half_track % SIDE) / 2
+        track += D71_SIDE_TRACKS if side == 1
+        track if track.positive? && track <= image.track_count && side < image.sides
+      end
+
       # A disk formatted from a D64 image, each sector laid out as the DOS
       # formats it, with the disk ID from the header block. A block the
       # image's error table marks 20, 21, 22, 23, 27 or 29 is written the
@@ -81,7 +131,8 @@ module Badline
       #
       # Each track starts sector 0 at the angle the DOS's N: leaves it: track
       # 1 at the index angle, and each track after it SKEWS[zone] of a turn
-      # round from the last.
+      # round from the last. A .d71's second side starts over at the index
+      # angle.
       def self.from_d64(image)
         track, sector = image.header_block
         header = image.read_block(track, sector)
@@ -89,16 +140,18 @@ module Badline
         disk = new(image)
         angle = 0
         (1..image.track_count).each do |track|
-          angle = (angle + SKEWS[zone(track)]) % SKEW_TURN if track > 1
-          bytes = format_track(image, track, id)
-          disk.write(track * 2, Track.new(bytes.rotate(-(bytes.length * angle / SKEW_TURN)), zone(track)))
+          half_track = d64_half_track(image, track)
+          zone = zone((half_track % SIDE) / 2)
+          angle = half_track == SIDE + 2 ? 0 : (angle + SKEWS[zone]) % SKEW_TURN if track > 1
+          bytes = format_track(image, track, id, zone)
+          disk.write(half_track, Track.new(bytes.rotate(-(bytes.length * angle / SKEW_TURN)), zone))
         end
         disk
       end
 
-      def self.format_track(image, track, id)
+      def self.format_track(image, track, id, zone = zone(track))
         sectors = image.sectors_in(track)
-        length = TRACK_LENGTHS[zone(track)]
+        length = TRACK_LENGTHS[zone]
         gap = (length - (sectors * SECTOR_LENGTH)) / sectors
         bytes = []
         sectors.times do |sector|
@@ -146,7 +199,7 @@ module Badline
 
       def initialize(image = nil)
         @image = image
-        @tracks = Array.new(MAX_HALF_TRACK + 1)
+        @tracks = Array.new(SIDE * 2)
         @written = {}
         @path = nil
         @read_only = false
@@ -188,11 +241,14 @@ module Badline
       def flush
         return flush_tracks if @image.respond_to?(:store_tracks)
 
-        tracks = @written.keys.select { |half| half.even? && (1..@image&.track_count.to_i).cover?(half / 2) }
+        tracks = @written.keys.filter_map do |half|
+          track = @image && Disk.d64_track(@image, half)
+          [half, track] if track
+        end
         @written.clear
         return if tracks.empty?
 
-        sectors = tracks.to_h { |half| [half / 2, SectorReader.read(@tracks[half].bytes, half / 2)] }
+        sectors = tracks.to_h { |half, track| [track, SectorReader.read(@tracks[half].bytes, track)] }
         id = disk_id(sectors)
         warn_lost(sectors)
         @image.store_blocks(sectors.flat_map do |track, found|
@@ -203,9 +259,10 @@ module Badline
       private
 
       def flush_tracks
-        tracks = @written.keys.sort.to_h do |half|
-          [half - Mechanism::MIN_HALF_TRACK, [@tracks[half].bytes, @tracks[half].zone]]
-        end
+        tracks = @written.keys.sort.filter_map do |half|
+          entry = Disk.entry_of(half)
+          [entry, [@tracks[half].bytes, @tracks[half].zone]] if entry
+        end.to_h
         @written.clear
         @image.store_tracks(tracks) unless tracks.empty?
       end

data/lib/badline/drive1541/disk_state.rb

@@ -12,13 +12,18 @@ module Badline
         # for a disk from Disk.open. Nil for a disk made another way.
         attr_reader :path, :read_only
 
-        # A .g64 image by its name, and anything else a .d64.
-        def self.g64?(path) = File.extname(path).casecmp?(".g64")
+        # A .g64 or .g71 image by its name, a .d71 by its name, and anything
+        # else a .d64.
+        def self.g64?(path) = %w[.g64 .g71].include?(File.extname(path).downcase)
+
+        def self.d71?(path) = File.extname(path).casecmp?(".d71")
 
         # A disk for the image at the path, its tracks left for the state.
         def self.reopen(path, read_only)
           if g64?(path)
             Disk.new(Storage::G64Image.new(path, read_only:)).opened(path, read_only)
+          elsif d71?(path)
+            Disk.new(Storage::D71Image.new(path, read_only:)).opened(path, read_only)
           else
             Disk.new(Storage::D64Image.new(path, read_only:)).opened(path, read_only)
           end

data/lib/badline/drive1541/disk_via.rb

@@ -7,8 +7,11 @@ module Badline
     # hears both after every write and reset, since ORB, DDRB, the ACR and
     # the PCR can all change them.
     class DiskVIA < VIA
+      attr_reader :mechanism
+
       def initialize(start:, mechanism:)
         @mechanism = mechanism
+        mechanism.via = self
         super(start:, peripheral: mechanism)
       end
 

data/lib/badline/drive1541/mechanism.rb

@@ -2,6 +2,7 @@
 
 require "badline/drive1541/rotation"
 require "badline/drive1541/mechanism_state"
+require "badline/drive1541/byte_ready"
 
 module Badline
   class Drive1541
@@ -26,7 +27,7 @@ module Badline
     # reads it, and it holds the bit counter at zero, so the first 0 bit
     # after it starts a byte. Every eighth bit after that is BYTE READY,
     # which pulls VIA 2's CA1 low until the next bit and reaches the CPU's
-    # SO pin (see Drive1541#byte_ready!).
+    # SO pin (see byte_ready!).
     #
     # CB2 low selects write mode, where SYNC detection and the flux are
     # off and the clock runs on at the selected rate. At each BYTE READY
@@ -64,9 +65,13 @@ module Badline
     # becomes track 1's, so the DOS's bump leaves the head on track 1 in
     # line with the phase it ends on, and its first step in reaches the
     # half track after it.
+    #
+    # The 1571's stepper is lined up so that phase 0 holds track 1, where
+    # its track 0 sensor looks for the head (Mechanism.new's +slip+).
     class Mechanism
       include Rotation
       include MechanismState
+      include ByteReady
 
       MOTOR = 0x04
       LED = 0x08
@@ -81,11 +86,15 @@ module Badline
 
       attr_reader :disk, :half_track, :zone
 
-      def initialize(drive)
-        @drive = drive
+      # +slip+ is the stepper's phase offset at power-on: 0, where each half
+      # track's phase is the low two bits of its number, or 2 for track 1
+      # on phase 0.
+      def initialize(slip: 0)
+        @via = nil
+        @so_pending = false
         @disk = nil
         @half_track = START_HALF_TRACK
-        @slip = 0
+        @slip = slip
         @motor = false
         @led = false
         @zone = 0
@@ -98,10 +107,30 @@ module Badline
         @bits = 0
         @sync = false
         @byte_ready = false
+        @byte_latched = false
         @writing = false
         @write_shift = 0
         @write_gate = false
         @protected = false
+        @side_base = 0
+        @cycle_ticks = CYCLE
+        load_track
+      end
+
+      # The drive's clock rate: the disk turns on by fewer ticks each
+      # cycle at 2 MHz.
+      def clock_hz=(clock_hz)
+        @cycle_ticks = CYCLE * Drive1541::CLOCK_HZ / clock_hz
+      end
+
+      # The head that reads, 0 or 1, on a drive with two (Disk::SIDE).
+      def side = @side_base.zero? ? 0 : 1
+
+      def side=(side)
+        side_base = side * Disk::SIDE
+        return if side_base == @side_base
+
+        @side_base = side_base
         load_track
       end
 
@@ -117,10 +146,10 @@ module Badline
       # LED, the zone and the clock's rate, the stepper, write mode and
       # where a write starts, and the track and cell under the head. The
       # rest moves only while the motor turns, or as a disk goes in (see
-      # Drive1541::Idle).
+      # Drive::Idle).
       def idle_state
-        [@motor, @led, @zone, @clock, @half_track, @slip, @disk, @track, @index, @mask, @cell_end, @time,
-         @writing, @write_index, @sync]
+        [@motor, @led, @zone, @clock, @half_track, @slip, @side_base, @disk, @track, @index, @mask, @cell_end,
+         @time, @writing, @write_index, @sync, @byte_latched]
       end
 
       # Puts a Disk in, or takes it out with nil, flushing the disk that
@@ -178,7 +207,7 @@ module Badline
       def read_bit(one)
         if @byte_ready
           @byte_ready = false
-          @drive.byte_ready_ended!
+          byte_ready_ended!
         end
         @shift = ((@shift << 1) & 0x3fe) | (one ? 1 : 0)
         if one
@@ -197,7 +226,7 @@ module Badline
       def write_bit(at)
         if @byte_ready
           @byte_ready = false
-          @drive.byte_ready_ended!
+          byte_ready_ended!
         end
         one = @write_shift.anybits?(0x80)
         @write_shift = (@write_shift << 1) & 0xff
@@ -227,10 +256,11 @@ module Badline
       # changed: a half track without data gets a blank track, and a track
       # written at another rate is laid out again at this one.
       def track_written(at)
-        track = @disk.writable_track(@half_track, @zone)
-        @disk.write(@half_track, track.relaid(@zone)) unless track.written_at?(@zone)
+        surface = self.surface
+        track = @disk.writable_track(surface, @zone)
+        @disk.write(surface, track.relaid(@zone)) unless track.written_at?(@zone)
         load_track(at)
-        @disk.written(@half_track)
+        @disk.written(surface)
         @track_written = true
       end
 
@@ -246,9 +276,9 @@ module Badline
         return unless @bits == 8
 
         @bits = 0
-        @write_shift = @writing ? @drive.via2.port_a_output : @shift & 0xff
+        @write_shift = @writing ? @via.port_a_output : @shift & 0xff
         @byte_ready = true
-        @drive.byte_ready!
+        byte_ready!
       end
 
       # The stepper's rotor turns with the head, a phase to each half
@@ -267,6 +297,10 @@ module Badline
         end
       end
 
+      # The half track under the head that reads, numbered on the disk
+      # (see Disk::SIDE).
+      def surface = @half_track + @side_base
+
       def seek(half_track)
         half_track = half_track.clamp(MIN_HALF_TRACK, Disk::MAX_HALF_TRACK)
         return if half_track == @half_track

data/lib/badline/drive1541/mechanism_state.rb

@@ -10,11 +10,10 @@ module Badline
       def save_state(out)
         out.boolean(!@disk.nil?)
         @disk&.save_state(out)
-        [@half_track, @slip, @zone, @clock, @time, @clock_at, @clocks, @shift, @ones, @bits, @write_shift,
+        [@half_track, @slip, @side_base, @zone, @clock, @time, @clock_at, @clocks, @shift, @ones, @bits, @write_shift,
          @index, @mask, @cell_end, @width, @next].each { |value| out.int(value) }
-        [@motor, @led, @sync, @byte_ready, @writing, @write_gate, @protected, @track_written].each do |flag|
-          out.boolean(flag)
-        end
+        [@motor, @led, @sync, @byte_ready, @byte_latched, @writing, @write_gate, @protected,
+         @track_written].each { |flag| out.boolean(flag) }
         out.optional_int(@write_index)
       end
 
@@ -36,6 +35,7 @@ module Badline
       def load_head(input)
         @half_track = input.int
         @slip = input.int
+        @side_base = input.int
         @zone = input.int
         @clock = input.int
         @time = input.int
@@ -57,6 +57,7 @@ module Badline
         @led = input.boolean?
         @sync = input.boolean?
         @byte_ready = input.boolean?
+        @byte_latched = input.boolean?
         @writing = input.boolean?
         @write_gate = input.boolean?
         @protected = input.boolean?

data/lib/badline/drive1541/rotation.rb

@@ -30,12 +30,12 @@ module Badline
       BLANK = Track.new(Array.new(Disk::TRACK_LENGTHS[0], 0).freeze, 0)
 
       # One drive cycle: nothing with the motor off, and otherwise the
-      # disk turns on by 16 ticks, through whatever cells and clocks fall
-      # in them.
+      # disk turns on by a cycle's ticks, 16 at 1 MHz and 8 at 2 MHz,
+      # through whatever cells and clocks fall in them.
       def cycle!
         return unless @motor
 
-        @time += CYCLE
+        @time += @cycle_ticks
         pass_time if @time >= @next
       end
 
@@ -95,7 +95,7 @@ module Badline
       # The track under the head and its layout, leaving the head's place
       # on it as it stands.
       def head_on_track
-        @track = @disk&.track(@half_track) || BLANK
+        @track = @disk&.track(surface) || BLANK
         @bytes = @track.bytes
         @widths = @track.widths
         @length = @track.length
@@ -105,7 +105,7 @@ module Badline
       # The track under the head, from the cell that's under it +time+
       # into the turn.
       def load_track(time = @time)
-        @track = @disk&.track(@half_track) || BLANK
+        @track = @disk&.track(surface) || BLANK
         @bytes = @track.bytes
         @widths = @track.widths
         @length = @track.length