badline 0.15.0 → 0.15.1

data/lib/badline/plus4/sid_card.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Badline
+  class Plus4
+    # A SID card's SID at $FD40-$FD5F, or at $FE80-$FE9F as Csory's card
+    # puts it, clocked once a TED cycle, as the cards clock it from the
+    # TED's single clock. The SID counts the
+    # cycles that have passed whenever something touches it, rather than
+    # every cycle: a CPU access runs it through the cycle the access is in,
+    # and the host, between cycles, up to the cycle about to start.
+    # `clock` answers the machine's cycles.
+    class SIDCard
+      # Where a card can put its SID.
+      ADDRESSES = [0xfd40, 0xfe80].freeze
+
+      attr_reader :sid, :address
+
+      def initialize(clock, model, address = ADDRESSES.first)
+        raise ArgumentError, format("no SID card at $%04X", address) unless ADDRESSES.include?(address)
+
+        @clock = clock
+        @address = address
+        @sid = Chips::SID.new(model:, at: address)
+        @clocked = 0
+      end
+
+      def model = @sid.model
+
+      def model=(model)
+        catch_up!
+        @sid.model = model
+      end
+
+      def peek(addr)
+        run_to(@clock.cycles + 1)
+        @sid.peek(addr)
+      end
+
+      def poke(addr, value)
+        run_to(@clock.cycles + 1)
+        @sid.poke(addr, value)
+      end
+
+      # The RES line, from the host between cycles.
+      def reset!
+        run_to(@clock.cycles)
+        @sid.reset!
+      end
+
+      # Runs the SID, its voices and its filter, up to the current cycle.
+      def catch_up!
+        run_to(@clock.cycles)
+        @sid.catch_up!
+      end
+
+      def record(rate:, clock_hz:)
+        run_to(@clock.cycles)
+        @sid.record(rate:, clock_hz:)
+      end
+
+      def drain_samples
+        run_to(@clock.cycles)
+        @sid.drain_samples
+      end
+
+      # The SID's fields in a keyed snapshot module (BL-SID), saved once the
+      # machine has settled it (#catch_up!).
+      def save_fields(out) = @sid.save_fields(out)
+
+      def load_fields(input)
+        @sid.load_fields(input)
+      end
+
+      # The SID counts on from the machine's cycle the snapshot was taken at.
+      def restored!
+        @sid.restored!
+        @clocked = @clock.cycles
+      end
+
+      private
+
+      def run_to(target)
+        clocked = @clocked
+        return if clocked >= target
+
+        sid = @sid
+        while clocked < target
+          sid.cycle!
+          clocked += 1
+        end
+        @clocked = clocked
+      end
+    end
+  end
+end

data/lib/badline/plus4/sound_mix.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Badline
+  class Plus4
+    # What a front end plays from a 264 with a SID card fitted: the TED's
+    # sound and the card's SID, each recorded at the audio rate and added
+    # together, clipped to a signed 16-bit sample. A sample one source has
+    # closed waits for the other's. The SID's model is the mix's, as it
+    # is a C64's sound source's, for the pause menu's Sound page.
+    class SoundMix
+      def initialize(ted_sound, sid)
+        @ted_sound = ted_sound
+        @sid = sid
+        @ted_waiting = []
+        @sid_waiting = []
+      end
+
+      def model = @sid.model
+
+      def model=(model)
+        @sid.model = model
+      end
+
+      # Starts both sources recording at `rate` samples a second, their
+      # cycles taken to run at `clock_hz`.
+      def record(rate:, clock_hz:)
+        @ted_sound.record(rate:, clock_hz:)
+        @sid.record(rate:, clock_hz:)
+        @ted_waiting = []
+        @sid_waiting = []
+      end
+
+      # Runs both sources up to the current cycle.
+      def catch_up!
+        @ted_sound.catch_up!
+        @sid.catch_up!
+      end
+
+      # The mixed samples both sources have closed since the last drain.
+      def drain_samples
+        ted = @ted_waiting.concat(@ted_sound.drain_samples)
+        sid = @sid_waiting.concat(@sid.drain_samples)
+        count = [ted.length, sid.length].min
+        mixed = Array.new(count) { |index| (ted[index] + sid[index]).clamp(-0x8000, 0x7fff) }
+        @ted_waiting = ted[count, ted.length - count] || []
+        @sid_waiting = sid[count, sid.length - count] || []
+        mixed
+      end
+    end
+  end
+end

data/lib/badline/plus4/tcbm_drive.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Badline
+  class Plus4
+    # The 264 series' true drives: a Drives::Model1541 and a
+    # Drives::Model1581 on the serial bus (C64::TrueDrives), and a
+    # Drives::Model1551 on TCBM, its interface's TIA in the expansion port
+    # at $FEE0 for device 8 or $FEC0 for device 9. Each sits in a field of
+    # its own, so none makes another's per-cycle call a union.
+    #
+    # A device number has one drive at a time: a 1551 takes the place of a
+    # serial drive with its number, and the other way round.
+    module TCBMDrive
+      # The true drive models plug_true_drive builds.
+      TRUE_DRIVE_MODELS = %w[1541 1551].freeze
+
+      # The 1551 on TCBM, or nil.
+      attr_reader :drive1551
+
+      # The drive plug_true_drive plugs in, "1541" or "1551".
+      attr_reader :true_drive_model
+
+      # Plugs in a Drives::Model1551, its interface's TIA where its device
+      # number puts it, in place of the TCBM interface's own there, and in
+      # place of a serial drive with its number. The traps stop answering
+      # device 8 when the drive is device 8.
+      def attach_drive1551(drive)
+        detach_drive1551
+        device = drive.device
+        detach_drive1541 if @drive1541&.device == device
+        detach_drive1581 if @drive1581&.device == device
+        drive.host_clock_hz = timing.clock_hz
+        @drive1551 = drive
+        @bus.plug_tia(drive.device, drive.host_tia)
+        @serial_trap&.device = serial_trap_device
+        @init_threshold = [@init_threshold, Badline::Drives::Model1551::BOOT_CYCLES].max if @cycles < @init_threshold
+      end
+
+      # Unplugs the Drives::Model1551, leaving the TCBM interface's own TIA,
+      # if there is one, in its place.
+      def detach_drive1551
+        drive = @drive1551
+        return unless drive
+
+        @bus.plug_tia(drive.device, tcbm_tia(drive.device))
+        @drive1551 = nil
+        @serial_trap&.device = serial_trap_device
+      end
+
+      # The true drive: a 1581 ahead of a 1551 ahead of a 1541.
+      def true_drive = @drive1581 || @drive1551 || @drive1541
+
+      # Plugs in the model true_drive_model names as device 8, in place of
+      # the drive there, and returns it.
+      def plug_true_drive
+        return plug_drive1551 if @true_drive_model == "1551"
+
+        unplug_device8
+        detach_drive1581 if drive1581_on_device8?
+        Badline::Drives::Model1541.new.tap { |drive| attach_drive1541(drive) }
+      end
+
+      # Plugs in a 1551 as device 8, in place of the drive there, and
+      # returns it.
+      def plug_drive1551
+        Badline::Drives::Model1551.new.tap { |drive| attach_drive1551(drive) }
+      end
+
+      private
+
+      def init_drives(true_drive_model)
+        unless TRUE_DRIVE_MODELS.include?(true_drive_model)
+          raise ArgumentError, "no true drive model #{true_drive_model} for the Plus/4"
+        end
+
+        @true_drive_model = true_drive_model
+        @drive1541 = nil
+        @drive1551 = nil
+        @drive1581 = nil
+      end
+
+      def save_drive1551_modules(sections)
+        drive = @drive1551
+        drive&.save_modules(sections, "BL-D#{drive.device}")
+        sections
+      end
+
+      def load_drive1551_modules(modules, input, device)
+        return input.adjust("a 1551 as device #{device}, left out") unless [8, 9].include?(device)
+
+        detach_drive1551 if @drive1551 && @drive1551.device != device
+        attach_drive1551(Badline::Drives::Model1551.new(device:)) unless @drive1551
+        @drive1551.load_modules(modules, input, "BL-D#{device}")
+      end
+
+      # The TCBM interface's own TIA for +device+, or nil without one.
+      def tcbm_tia(device)
+        tias = @tias
+        return nil if tias.empty?
+
+        device == 9 ? tias[1] : tias[0]
+      end
+
+      # Device 8, unless a true drive is device 8.
+      def serial_trap_device
+        device = KernalTrap::Routine::DEVICE
+        on_device8 = @drive1551&.device == device || @drive1541&.device == device || drive1581_on_device8?
+        on_device8 ? nil : device
+      end
+
+      # Unplugs the 1541 and the 1551 if either is device 8, for a 1581 to
+      # take its place.
+      def unplug_device8
+        device = KernalTrap::Routine::DEVICE
+        detach_drive1541 if @drive1541&.device == device
+        detach_drive1551 if @drive1551&.device == device
+      end
+    end
+  end
+end

data/lib/badline/plus4/user_port.rb

@@ -6,22 +6,31 @@ module Badline
     # latch: a line reads low where the latch or the outside pulls it. With
     # nothing plugged into the user port, the outside pulls only bit 2, the
     # cassette sense switch, low while a key is down on the deck. The
-    # KERNAL's IRQ reads it there ($CFBF).
+    # KERNAL's IRQ reads it there ($CFBF), and takes P1 as RS-232's clear
+    # to send, sending through the ACIA only while it reads high.
+    #
+    # A device on the user port drives P0-P7 through #inputs, low where its
+    # bit is clear.
     class UserPort
       TAPE_SENSE = 0x04
 
       attr_reader :output
+      attr_accessor :inputs
 
       def initialize(datasette)
         @datasette = datasette
         @output = 0xff
+        @inputs = 0xff
       end
 
       def reset!
         @output = 0xff
       end
 
-      def peek(_addr) = @datasette.sense_low? ? @output & ~TAPE_SENSE : @output
+      def peek(_addr)
+        lines = @output & @inputs
+        @datasette.sense_low? ? lines & ~TAPE_SENSE : lines
+      end
 
       def poke(_addr, value)
         @output = value

data/lib/badline/plus4.rb

@@ -2,6 +2,7 @@
 
 require "badline/chips/ted"
 require "badline/chips/tia"
+require "badline/drives/model1551"
 require "badline/plus4/model"
 require "badline/plus4/cpu"
 require "badline/plus4/cpu_port"
@@ -9,7 +10,11 @@ require "badline/plus4/keyboard_port"
 require "badline/plus4/user_port"
 require "badline/plus4/cassette_sense"
 require "badline/plus4/acia"
+require "badline/plus4/sid_card"
+require "badline/plus4/sound_mix"
+require "badline/plus4/ram_expansion"
 require "badline/plus4/bus"
+require "badline/plus4/tcbm_drive"
 require "badline/snapshot/plus4_setup"
 require "badline/plus4/keyed_parts"
 require "badline/plus4/keyed_state"
@@ -19,20 +24,31 @@ module Badline
   # The Commodore 264 series: the Plus/4, the C16 and the C116. A 7501 on
   # the TED's clock, which runs it once or twice a TED cycle (Chips::TED's
   # Beam), the TED and, on the Plus/4, a 6551 ACIA and the user port's
-  # 6529. Only the TED pulls IRQ, and nothing pulls NMI, which the 7501
-  # doesn't have.
+  # 6529. The TED and the ACIA pull IRQ, and nothing pulls NMI, which the
+  # 7501 doesn't have.
   #
   # The TED paints the picture a front end shows (#video, #timing). Device 8
   # serves disks through the KERNAL traps (C64::KernalTraps), or a true
-  # 1541 or 1581 on the serial bus does (C64::TrueDrives), cartridges go
+  # 1541 or 1581 on the serial bus or a 1551 on TCBM does (TCBMDrive),
+  # cartridges go
   # in the two cartridges' slots, and tapes play on the datasette, whose read
   # line's level the KERNAL times with the TED's timers.
+  #
+  # A SID card, as third parties built for the 264s, puts a SID at
+  # $FD40-$FD5F, or at $FE80-$FE9F as Csory's does. The cards clock it from the TED's single clock, one SID
+  # cycle a TED cycle, 886,724 Hz on PAL, below the C64's 985,248 Hz, so a
+  # C64 tune plays about a semitone flat (plus4world forum threads 38287
+  # and 20130).
+  #
+  # A RAM expansion, Hannes's 256K or 1M or Csory's 256K, banks more RAM
+  # in through a register at $FD16 (RAMExpansion).
   class Plus4
     include IntegerHelper
     include Machine::KeyboardBuffer
     include Machine::Clocking
     include Machine::Settling
     include C64::TrueDrives
+    include TCBMDrive
     include C64::KernalTraps
 
     # The cycle by which the KERNAL has booted and BASIC printed READY,
@@ -46,7 +62,7 @@ module Badline
     DRIVE_BOOT_CYCLES = 1_200_000
 
     attr_reader :model, :bus, :cpu, :ted, :sound, :port, :keyboard, :keyboard_port, :joystick1, :joystick2, :acia,
-                :user_port, :datasette, :tias, :iec_bus, :cycles, :ram_kb, :drive1541, :init_threshold
+                :user_port, :datasette, :tias, :iec_bus, :cycles, :ram_kb, :drive1541, :init_threshold, :sid_card
 
     def family = :plus4
 
@@ -57,8 +73,8 @@ module Badline
     def ram = @bus.ram
 
     # What a front end plays: the TED's sound, which answers #record and
-    # #drain_samples.
-    def sound_source = @sound
+    # #drain_samples, mixed with the SID card's where one is fitted.
+    def sound_source = @sound_mix || @sound
 
     # The chip whose #display a front end shows.
     def video = @ted
@@ -84,11 +100,16 @@ module Badline
     # +model+ names one of Model::ALL, or c116 for the C16, and +ram+ the
     # RAM in K, one of Model::RAM_SIZES, when not the model's own. +tcbm+
     # plugs in a 1551's TCBM interface, the TIAs at $FEC0-$FEFF, with no
-    # drive answering on the other side.
-    def initialize(model: "plus4", ram: nil, tcbm: false, debug: false)
+    # drive answering on the other side. +true_drive_model+ names the drive
+    # plug_true_drive plugs in, "1541" or "1551". +sid_card+ fits a SID
+    # card with a SID of that model, :mos6581 or :mos8580, at
+    # +sid_card_address+, $FD40 or $FE80. +ram_expansion+
+    # fits a RAMExpansion of that kind, :hannes256, :hannes1m or
+    # :csory256, over 64K of the machine's own.
+    def initialize(model: "plus4", ram: nil, tcbm: false, true_drive_model: "1551", sid_card: nil,
+                   sid_card_address: SIDCard::ADDRESSES.first, ram_expansion: nil, debug: false)
       @model = Model.named(model)
-      @ram_kb = ram || @model.ram_kb
-      raise ArgumentError, "no Plus/4 RAM size of #{@ram_kb}K" unless Model::RAM_SIZES.include?(@ram_kb)
+      @ram_kb = fitted_ram(ram, ram_expansion)
 
       @ted = Chips::TED.new(@model.ted)
       @keyboard = Input::Keyboard.new(matrix: KeyboardPort::MATRIX)
@@ -100,39 +121,45 @@ module Badline
       @datasette = Drives::Datasette.new(level: true)
       @port = CPUPort.new(serial_bus: @iec_bus, datasette: @datasette)
       plus4_parts = @model.plus4_parts
-      @acia = plus4_parts ? ACIA.new : nil
+      @cycles = 0
+      @init_threshold = INIT_THRESHOLD
+      @acia_irq = false
+      @acia_due = ACIA::NEVER
+      @due = INIT_THRESHOLD
+      @sid_card = sid_card ? SIDCard.new(self, sid_card, sid_card_address) : nil
+      @acia = plus4_parts ? ACIA.new(self, @model.ted.clock_hz) : nil
       @user_port = plus4_parts ? UserPort.new(@datasette) : nil
       io = Bus::IOPage.new(keyboard_port: @keyboard_port, acia: @acia, user_port: @user_port,
-                           cassette_sense: plus4_parts ? nil : CassetteSense.new(@datasette))
-      @bus = Bus.new(ted: @ted, port: @port, io:, model: @model, ram_kb: @ram_kb)
+                           cassette_sense: plus4_parts ? nil : CassetteSense.new(@datasette),
+                           sid_card: sid_card_at(0xfd40))
+      @bus = Bus.new(ted: @ted, port: @port, io:, model: @model, ram_kb: @ram_kb, ram_expansion:)
       @ted.connect(@bus)
+      @bus.plug_sid_card(sid_card_at(0xfe80))
       @tias = tcbm ? [Chips::TIA.new, Chips::TIA.new] : []
       @bus.plug_tcbm(drive8: @tias[0], drive9: @tias[1]) if tcbm
       @cpu = CPU.new(@bus, debug:)
-      @cycles = 0
       @sound = Chips::TED::Sound.new(self, @model.ted.clock_hz)
       @ted.sound = @sound
+      @sound_mix = @sid_card ? SoundMix.new(@sound, @sid_card) : nil
       @init_handlers = []
       @pending_keys = nil
       @dos = nil
       @serial_trap = nil
       @save_trap = nil
       @capture_output = nil
-      @drive1541 = nil
-      @drive1581 = nil
-      @init_threshold = INIT_THRESHOLD
+      init_drives(true_drive_model)
     end
 
     # One TED cycle: the TED moves on and decides the CPU's clock, then the
     # CPU runs its cycles in it, none while the TED holds the bus.
     def cycle!
-      handle_init if @cycles == @init_threshold
+      handle_due if @cycles >= @due
       feed_keyboard if @pending_keys
 
       ted = @ted
       ted.cycle!
       @datasette.cycle!
-      @cpu.irq = ted.irq?
+      @cpu.irq = ted.irq? || @acia_irq
       slots = ted.cpu_slots
       if slots.zero?
         @cpu.stall!
@@ -142,13 +169,15 @@ module Badline
       end
       @drive1541&.host_cycle!
       @drive1581&.host_cycle!
+      @drive1551&.host_cycle!
 
       @cycles += 1
     end
 
     # The RESET line: the CPU, the port, the 6529s, the ACIA, the bank
-    # latch and ROM selection, and through the serial bus's RESET line, the
-    # drives. The TED has no reset pin.
+    # latch and ROM selection, a RAM expansion's register, the SID card,
+    # and through the serial bus's RESET line, the drives. The TED has no
+    # reset pin.
     def reset!
       @port.reset!
       @keyboard_port.reset!
@@ -156,7 +185,9 @@ module Badline
       @dos&.reset!
       @drive1541&.reset!
       @drive1581&.reset!
+      @drive1551&.reset!
       @acia&.reset!
+      @sid_card&.reset!
       @tias.each(&:reset!)
       @bus.reset!
       @cpu.reset!
@@ -171,6 +202,13 @@ module Badline
       reset!
     end
 
+    # The ACIA's IRQ line, and the cycle it next has something to do at.
+    def acia_changed(irq, due)
+      @acia_irq = irq
+      @acia_due = due
+      schedule
+    end
+
     # Calls the block with the exit code a VICE testprog writes to $FDCF.
     def install_debug_register(&) = @bus.install_debug_register(&)
 
@@ -201,6 +239,18 @@ module Badline
       "#{name} #{standard}, #{@ram_kb}K RAM"
     end
 
+    # The RAMExpansion fitted, or nil.
+    def ram_expansion = @bus.ram_expansion
+
+    # The RAM expansion as the pause menu names it, such as "HANNES, 256
+    # KB", or nil without one.
+    def ram_expansion_label
+      expansion = @bus.ram_expansion
+      return if expansion.nil?
+
+      "#{RAMExpansion::NAMES.fetch(expansion.kind)}, #{expansion.size_kb} KB"
+    end
+
     # Stores a PRG's bytes from its load address on, into RAM, and returns
     # that address.
     def load_prg(data)
@@ -213,6 +263,22 @@ module Badline
 
     private
 
+    # The SID card if it is at +address+, or nil.
+    def sid_card_at(address)
+      card = @sid_card
+      card if card && card.address == address
+    end
+
+    # The RAM in K: +ram+, or the model's own, or 64K under a RAM
+    # expansion, which needs that much.
+    def fitted_ram(ram, ram_expansion)
+      ram_kb = ram || (ram_expansion ? 64 : @model.ram_kb)
+      raise ArgumentError, "no Plus/4 RAM size of #{ram_kb}K" unless Model::RAM_SIZES.include?(ram_kb)
+      raise ArgumentError, "a RAM expansion needs 64K, not #{ram_kb}K" if ram_expansion && ram_kb != 64
+
+      ram_kb
+    end
+
     # The 264 KERNAL's keyboard buffer.
     def keyboard_buffer = Machine::KeyboardBuffer::PLUS4_LAYOUT
 
@@ -232,6 +298,22 @@ module Badline
       @init_threshold = [@init_threshold, Drives::Model1581::BOOT_CYCLES].max if @cycles < @init_threshold
     end
 
+    # What falls due at the start of a cycle: the on_init handlers at the
+    # init threshold, and the ACIA's next character.
+    def handle_due
+      handle_init if @cycles == @init_threshold
+      acia = @acia
+      acia.run!(@cycles) if acia && @cycles >= @acia_due
+      schedule
+    end
+
+    # The next cycle anything falls due at. A drive that raises the init
+    # threshold leaves it early, and handle_due looks again then.
+    def schedule
+      init = @cycles < @init_threshold ? @init_threshold : ACIA::NEVER
+      @due = [@acia_due, init].min
+    end
+
     # BA stops the CPU at a read, and a write goes ahead.
     def clock_cpu(ted)
       ted.ba_low? && !@cpu.pending_write? ? @cpu.stall! : @cpu.cycle!

data/lib/badline/roms/README

@@ -79,6 +79,15 @@ Downloaded from
 https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/new/1581/1581-rom.318045-02.bin
 SHA-1 01228eae6f066bd9b7b2b6a7fa3f667e41dad393.
 
+dos1551.rom
+-----------
+The 1551 disk drive's DOS 2.6, 318008-01, 16 KB for $C000-$FFFF.
+Drives::Model1551 loads it.
+
+Downloaded from
+https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/new/1551/1551.318008-01.bin
+SHA-1 fae3c788ad9a6cc2dbdfbcf6c0264b2ca921d55e.
+
 Commodore VIC-20 ROMs
 =====================
 

data/lib/badline/snapshot/field_doc.rb

@@ -37,7 +37,7 @@ module Badline
       # The machines the doc is made from: each family at power-on, the C64
       # with each kind of expansion, cartridge and media, and a second SID,
       # and the 264 series' models, its TCBM interface, cartridge, tape and
-      # true drive.
+      # true drives, the 1541 and the 1551.
       def self.machines
         {
           "c64" => [C64.new, C64.new(ram_expansion: :plus256k), C64.new(reu: 512),
@@ -45,8 +45,10 @@ module Badline
                     with_drive(:d81), with_extra_sids],
           "vic20" => [Vic20.new, with_rom],
           "c128" => [C128.new(mode: :c128), with_drive(:d71)],
-          "plus4" => [Plus4.new, Plus4.new(model: "c16"), Plus4.new(tcbm: true), plus4_with_cartridge,
-                      plus4_with_tape, plus4_with_drive]
+          "plus4" => [Plus4.new, Plus4.new(model: "c16"), Plus4.new(tcbm: true), Plus4.new(sid_card: :mos6581),
+                      Plus4.new(sid_card: :mos8580, sid_card_address: 0xfe80),
+                      Plus4.new(ram_expansion: :csory256),
+                      plus4_with_cartridge, plus4_with_tape, plus4_with_drive, plus4_with_drive("1551")]
         }
       end
 
@@ -110,8 +112,8 @@ module Badline
         Plus4.new(model: "c16").tap { |machine| machine.datasette.insert(Storage::TAP.new("", bytes:)) }
       end
 
-      def self.plus4_with_drive
-        Plus4.new.tap do |machine|
+      def self.plus4_with_drive(model = "1541")
+        Plus4.new(true_drive_model: model).tap do |machine|
           image = Storage::D64Image.new("", bytes: blank(174_848))
           machine.plug_true_drive.insert(Drives::Model1541::Disk.decode(image))
         end