badline 0.16.1 → 0.17.0

data/lib/badline/plus4/acia.rb

@@ -1,305 +1,11 @@
 # frozen_string_literal: true
 
-require "badline/plus4/acia/frames"
-
 module Badline
   class Plus4
-    # The Plus/4's 6551 ACIA at $FD00-$FD0F, its four registers repeated:
-    #
-    # $FD00 - read the receiver's data, write the transmitter's
-    # $FD01 - read the status, write a programmed reset
-    # $FD02 - the command register
-    # $FD03 - the control register
-    #
-    # Status: bit 0 a parity error, 1 a framing error, 2 an overrun, 3 the
-    # receiver full, 4 the transmitter empty, 5 DCD and 6 DSR as their pins
-    # read (1 high, not asserted), 7 an interrupt. Reading it clears bit 7.
-    #
-    # Command: bit 0 DTR, which also enables the receiver and every
-    # interrupt, bit 1 set disables the receiver's interrupt, bits 2-3 the
-    # transmitter (00 off with RTS high, 01 on with its interrupt, 10 on
-    # without, 11 sending a break), bit 4 echoes what is received, bits 5-7
-    # the parity.
-    #
-    # Control: bits 0-3 the baud rate from the 1.8432 MHz crystal (0, the
-    # 16x external clock, runs straight from the crystal, 115,200 baud),
-    # bit 4 the receiver's clock (0 the RxC pin, which nothing drives on the
-    # Plus/4, so the receiver hears nothing), bits 5-6 the word length (8
-    # down to 5 bits) and bit 7 the stop bits (Frames).
-    #
-    # The transmitter runs in whole characters while it is on: at the end
-    # of each it hands the character it shifted out to the line, moves a
-    # waiting byte from the data register into the shift register and sets
-    # the transmitter empty, and with its interrupt on interrupts while the
-    # register is empty, every character until a byte comes. The first
-    # character ends a character's time after the transmitter comes on.
-    # The receiver takes a character's time for each byte the line sends,
-    # and a byte that arrives while the last is unread is lost to an
-    # overrun. The receiver full, and DCD or DSR changing, interrupt unless
-    # bit 1 disables it.
-    #
-    # The user port carries no CTS, so the transmitter is always clear to
-    # send; the KERNAL takes the user port's 6529 P1 as its handshake.
-    #
-    # What is on the other end of the user port (#plug): nothing, where
-    # DCD and DSR read high and what is sent goes nowhere; a terminal,
-    # which asserts DCD and DSR, sends what the host feeds it (#feed) while
-    # DTR is asserted and keeps what it receives for the host to drain
-    # (#drain); or a loopback plug, which returns TxD to RxD and DTR to DSR
-    # and DCD.
-    #
-    # The machine runs the ACIA at the cycle it next has something to do
-    # (#due) through #run!, and learns its IRQ line and that cycle from
-    # `clock`'s #acia_changed, whose #cycles is the time.
-    class ACIA
-      include Frames
-
-      PARITY_ERROR = 0x01
-      FRAMING_ERROR = 0x02
-      OVERRUN = 0x04
-      RECEIVER_FULL = 0x08
-      TRANSMITTER_EMPTY = 0x10
-      DCD = 0x20
-      DSR = 0x40
-      IRQ = 0x80
-
-      NOTHING = 0
-      TERMINAL = 1
-      LOOPBACK = 2
-
-      # No shift in progress.
-      IDLE = -1
-
-      # Far enough ahead that it never comes.
-      NEVER = 1 << 60
-
-      attr_reader :command, :control, :device, :due
-
-      def initialize(clock, clock_hz)
-        @clock = clock
-        @clock_hz = clock_hz
-        @device = NOTHING
-        @incoming = []
-        @received = []
-        reset!
-      end
-
-      # The RES line: every register cleared, the transmitter empty and
-      # both shift registers stopped.
-      def reset!
-        @command = 0
-        @control = 0
-        @errors = 0
-        @receiver_full = false
-        @transmitter_empty = true
-        @irq = false
-        @receive_data = 0
-        @transmit_data = 0
-        @shifting = IDLE
-        @transmit_at = NEVER
-        @transmit_remainder = 0
-        @receive_at = NEVER
-        @receive_remainder = 0
-        @clock_lost = false
-        @lines = modem_lines
-        changed
-      end
-
-      def irq? = @irq
-
-      # DTR and RTS as asserted, low on the pins.
-      def dtr? = @command.anybits?(0x01)
-
-      def rts? = @command.anybits?(0x0c)
-
-      # Whether the transmitter sends a break, holding TxD low.
-      def break? = @command & 0x0c == 0x0c
-
-      # Plugs NOTHING, a TERMINAL or a LOOPBACK plug into the user port.
-      def plug(device)
-        @device = device
-        @incoming.clear
-        lines_changed
-        start_receiving
-        changed
-      end
-
-      # Bytes the terminal sends, one a character's time while DTR is
-      # asserted.
-      def feed(bytes)
-        return unless @device == TERMINAL
-
-        @incoming.concat(bytes)
-        start_receiving
-        changed
-      end
-
-      # What the terminal has received since the last drain.
-      def drain
-        received = @received
-        @received = []
-        received
-      end
-
-      # Runs what falls due up to cycle `now`: the transmitter's character
-      # ends, then the receiver's.
-      def run!(now)
-        end_character while @transmit_at <= now
-        receive_character while @receive_at <= now
-        changed
-      end
-
-      def peek(addr)
-        case addr & 0x03
-        when 0
-          @receiver_full = false
-          @receive_data
-        when 1 then read_status
-        when 2 then @command
-        else @control
-        end
-      end
-
-      def poke(addr, value)
-        case addr & 0x03
-        when 0 then write_data(value)
-        when 1 then write_command(@command & 0xe0, clear_overrun: true)
-        when 2 then write_command(value)
-        else @control = value
-        end
-        changed
-      end
-
-      # The status as a read finds it, without clearing the interrupt.
-      def status
-        status = @errors | (@lines & (DCD | DSR))
-        status |= RECEIVER_FULL if @receiver_full
-        status |= TRANSMITTER_EMPTY if @transmitter_empty
-        @irq ? status | IRQ : status
-      end
-
-      private
-
-      def read_status
-        value = status
-        @irq = false
-        changed
-        value
-      end
-
-      def write_data(value)
-        @transmit_data = value
-        @transmitter_empty = false
-      end
-
-      def write_command(value, clear_overrun: false)
-        was_on = transmitter_on?
-        @command = value
-        @errors &= ~OVERRUN if clear_overrun
-        start_transmitting if transmitter_on? && !was_on
-        stop_transmitting unless transmitter_on? || @shifting != IDLE
-        lines_changed
-        start_receiving
-      end
-
-      def transmitter_on?
-        control = @command & 0x0c
-        control != 0 && control != 0x0c
-      end
-
-      def interrupts? = @command.anybits?(0x01)
-
-      def receiver_interrupts? = @command & 0x03 == 0x01
-
-      def transmitter_interrupts? = @command & 0x0d == 0x05
-
-      def receiving? = dtr? && @control.anybits?(0x10)
-
-      def start_transmitting
-        @transmit_remainder = 0
-        @transmit_at = after(@clock.cycles, true)
-      end
-
-      def stop_transmitting
-        @transmit_at = NEVER
-      end
-
-      # A character's end: the character shifted out goes to the line, and
-      # the transmitter takes the next byte or interrupts while it has none.
-      def end_character
-        sent = @shifting
-        @shifting = IDLE
-        deliver(sent) unless sent == IDLE
-        on = transmitter_on?
-        if on && !@transmitter_empty
-          @shifting = @transmit_data & word_mask
-          @transmitter_empty = true
-        end
-        @irq = true if on && @transmitter_empty && transmitter_interrupts?
-        if on || @shifting != IDLE
-          @transmit_at = after(@transmit_at, true)
-        else
-          stop_transmitting
-        end
-      end
-
-      def deliver(byte)
-        case @device
-        when TERMINAL then @received << byte
-        when LOOPBACK then take(byte) if receiving?
-        end
-      end
-
-      def start_receiving
-        return unless @receive_at == NEVER && !@incoming.empty? && receiving?
-
-        @receive_remainder = 0
-        @receive_at = after(@clock.cycles, false)
-      end
-
-      def receive_character
-        byte = @incoming[0]
-        @incoming.delete_at(0)
-        take(byte)
-        @receive_at = !@incoming.empty? && receiving? ? after(@receive_at, false) : NEVER
-      end
-
-      # A whole character in from RxD: into the data register, or lost to
-      # an overrun while the last is unread. In echo mode it goes back out
-      # to the terminal.
-      def take(byte)
-        if @receiver_full
-          @errors |= OVERRUN
-        else
-          @receive_data = byte & word_mask
-          @receiver_full = true
-          @errors = 0
-        end
-        @received << byte if @device == TERMINAL && @command & 0x1c == 0x10
-        @irq = true if receiver_interrupts?
-      end
-
-      # DCD and DSR as the device drives them, interrupting on a change.
-      def lines_changed
-        lines = modem_lines
-        return if lines == @lines
-
-        @lines = lines
-        @irq = true if receiver_interrupts?
-      end
-
-      def modem_lines
-        case @device
-        when TERMINAL then 0
-        when LOOPBACK then dtr? ? 0 : DCD | DSR
-        else DCD | DSR
-        end
-      end
-
-      def changed
-        @due = [@transmit_at, @receive_at].min
-        @clock.acia_changed(@irq && interrupts?, @due)
-      end
+    # The Plus/4's 6551 at $FD00-$FD0F, on the user port. Nothing drives
+    # its RxC pin, and the user port carries no CTS; the KERNAL takes the
+    # user port's 6529 P1 as its handshake.
+    class ACIA < Chips::ACIA
     end
   end
 end

data/lib/badline/plus4/keyed_parts.rb

@@ -52,50 +52,6 @@ module Badline
       include KeyedState
     end
 
-    class ACIA
-      # The registers, the status, the shift register and when the
-      # transmitter's character ends, in a keyed snapshot module (BL-ACIA).
-      # What the device on the user port has still to send stays with the
-      # host, and the receiver starts on it again once loaded (#restored!).
-      # A snapshot from before the transmitter's timing was saved starts
-      # its character clock on load.
-      module KeyedState
-        def save_fields(out)
-          out.int("command", @command).int("control", @control).int("errors", @errors)
-          out.bool("receiver_full", @receiver_full).bool("transmitter_empty", @transmitter_empty).bool("irq", @irq)
-          out.int("receive_data", @receive_data).int("transmit_data", @transmit_data).int("shifting", @shifting)
-          out.int("transmit_at", @transmit_at).int("transmit_remainder", @transmit_remainder)
-        end
-
-        def load_fields(input)
-          @command = input.byte("command", @command)
-          @control = input.byte("control", @control)
-          @errors = input.masked("errors", 0, PARITY_ERROR | FRAMING_ERROR | OVERRUN)
-          @receiver_full = input.bool("receiver_full", false)
-          @transmitter_empty = input.bool("transmitter_empty", true)
-          @irq = input.bool("irq", false)
-          @receive_data = input.byte("receive_data", 0)
-          @transmit_data = input.byte("transmit_data", 0)
-          @shifting = input.int("shifting", IDLE)
-          @transmit_remainder = input.int("transmit_remainder", 0)
-          transmit_at = input.optional_int("transmit_at")
-          @transmit_at = transmit_at || NEVER
-          @clock_lost = transmit_at.nil?
-        end
-
-        def restored!
-          @receive_at = NEVER
-          @lines = modem_lines
-          start_transmitting if @clock_lost && transmitter_on?
-          @clock_lost = false
-          start_receiving
-          changed
-        end
-      end
-
-      include KeyedState
-    end
-
     class Bus
       # The ROM bank latch, whether ROM is selected and the last byte on the
       # bus, under `prefix`, and the cartridges' ROMs by slot (#save_slot_fields),

data/lib/badline/plus4.rb

@@ -2,6 +2,7 @@
 
 require "badline/chips/ted"
 require "badline/chips/tia"
+require "badline/chips/acia"
 require "badline/drives/model1551"
 require "badline/plus4/model"
 require "badline/plus4/cpu"

data/lib/badline/roms/README

@@ -100,6 +100,34 @@ https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/old/2031/
 and concatenated.
 SHA-1 c53e180a96649ceb3f421739e8dc66faba7cba44.
 
+8050/fdc-901869-01.rom
+----------------------
+The 6530 of the 8050 and 8250's floppy controller with the DOS 2.7
+mask for MPI mechanisms, 901869-01 (6530-48): the 1 KB ROM the
+controller runs from $FC00-$FFFF. Chips::RRIOT holds it.
+SHA-1 3a9a80f72ce76e5f5c72513f8ef7553212912ae3.
+
+8050/fdc-901885-04.rom
+----------------------
+The same 6530 with the DOS 2.7 mask for Micropolis mechanisms,
+901885-04 (6530-47). It differs from 901869-01 in 104 bytes.
+SHA-1 0dc9a3b60f1b866c63eebd882403532fc59fe57f.
+
+8050/dos-2.7.rom
+----------------
+The 8050 and 8250's DOS 2.7, 16 KB for the interface processor's
+$C000-$FFFF: 901887-01 ($C000-$DFFF, SHA-1
+b10603195f240118fe5fb6c6dfe5c5097463d890) followed by 901888-01
+($E000-$FFFF, SHA-1 2e6c2d7ca934e5c550ad14bd5e9e7749686b7af4). xcbm2
+and xpet with -drive8type 8050 or 8250 run the same 16 KB.
+Drives::Model8050 loads it.
+SHA-1 d50b093828888146596f17ae0df9ef3dfde71b05.
+
+Both downloaded from
+https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/old/8050/
+and named by the 8050's parts list
+(https://www.zimmers.net/anonftp/pub/cbm/schematics/drives/old/8050/parts.txt).
+
 Commodore VIC-20 ROMs
 =====================
 
@@ -348,3 +376,86 @@ second half is 901447-10 byte for byte, and its first a DIN set, with
 the German letters and the section sign in place of @ [ \ ] and in
 some of the graphics. The CRTC's MA13, bit 5 of R12, picks the half.
 SHA-1 9616f7f18757cccefb702a945f954b644d5b17d1.
+
+Commodore CBM-II ROMs
+=====================
+
+Downloaded from
+https://www.zimmers.net/anonftp/pub/cbm/firmware/computers/b/
+for the B series (610, 620, 710 and 720) and the P500 (510). Each BASIC
+is its two 8K chips concatenated, $8000-$9FFF followed by $A000-$BFFF,
+as the PET's are. Nothing maps them yet.
+
+cbm2/kernal-04a.rom
+-------------------
+The B series KERNAL, 901244-04a (kernal.901244-04a.bin), for
+$E000-$FFFF in segment 15. The default, the one VICE runs on every B
+model.
+SHA-1 abb26418b9e1614a8f52bdeee0822d4a96071439.
+
+cbm2/kernal-03b.rom
+-------------------
+The B series KERNAL of the 1983 release, 901244-03b
+(kernal.901244-03b.bin), for $E000-$FFFF in segment 15. Its entry
+points and page 3 vectors are 901244-04a's.
+SHA-1 a624899c236bc4458570144d25aaf0b3be08b2cd.
+
+cbm2/basic128.rom
+-----------------
+BASIC 128 for the 610 and 710, 901243-04a and 901242-04a
+(b128-8000.901243-04a.bin, SHA-1
+08d333208060ee2ce84d4532028d94f71c016b96, and b128-a000.901242-04a.bin,
+SHA-1 7c6de17d46a3343dc597d9b9519cf63037b31908) concatenated, for
+$8000-$BFFF in segment 15. The default, paired with kernal-04a.rom.
+SHA-1 9409f92e167984096fe4d5913714bff6214c3b2d.
+
+cbm2/basic128-02b.rom
+---------------------
+BASIC 128 of the 1983 release, 901243-02b and 901242-02b
+(b128-8000.901243-02b.bin, SHA-1
+625f7337ea972a8bce2bdf2daababc0ed0b3b69b, and b128-a000.901242-02b.bin,
+SHA-1 56e8d2f86bf73ba36b3d3cb84dd75806b66c530a) concatenated, for
+$8000-$BFFF in segment 15. Paired with kernal-03b.rom.
+SHA-1 0da8311666521a1d5d7c80561550f9037f652989.
+
+cbm2/basic256.rom
+-----------------
+BASIC 256 for the 620 and 720, 901241-03 and 901240-03
+(b256-8000.901241-03.bin, SHA-1
+2d46be2cd89594b718cdd0a86d51b6f628343f42, and b256-a000.901240-03.bin,
+SHA-1 0d7f77746290afba8d0abeb87c9caab9a3ad89ce) concatenated, for
+$8000-$BFFF in segment 15. Both KERNALs run it.
+SHA-1 53314b4d565cc405a67a0936b935e6e08955580d.
+
+cbm2/characters-600.rom
+-----------------------
+The 600's character generator, 901237-01 (characters.901237-01.bin),
+4K: two sets of 128 glyphs, 16 bytes each, an 8x8 matrix in the first
+eight rows.
+SHA-1 e63bf18da48e5a53c99ef127c1ae721333d1d102.
+
+cbm2/characters-700.rom
+-----------------------
+The 700's character generator, 901232-01 (characters.901232-01.bin),
+4K: two sets of 128 glyphs, 16 bytes each, an 8x16 matrix. zimmers.net
+also has 901232-02, from a 710, which differs in 139 bytes. xcbm2 runs
+-01 on its 710, and a 710's boot screen painted with it matches xcbm2's
+dot for dot.
+SHA-1 e7f3cbc8e282f79a00c3e95d75c8d725ee3c6287.
+
+cbm2/p500-kernal.rom
+--------------------
+The P500's KERNAL, 901234-02 (kernal.901234-02.bin), for $E000-$FFFF in
+segment 15. The P500's character generator is the C64's,
+character.rom above.
+SHA-1 097197d4d08e0b82e0466a5f1fbd49a24f3d2523.
+
+cbm2/p500-basic.rom
+-------------------
+The P500's BASIC 128, 901236-02 and 901235-02
+(p500-basic-lo.901236-02.bin, SHA-1
+f50240407bade901144f7e9f489fa9c607834eca, and
+p500-basic-hi.901235-02.bin, SHA-1
+1b9a55f12f8cf025754d8029cc5324b474c35841) concatenated, for
+$8000-$BFFF in segment 15.
+SHA-1 e69531d45f5993f8e53c6bd9ab2a7bc10fe2d02f.

data/lib/badline/snapshot/cbm2_setup.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    # How a CBM-II was built: its model's name, one of CBM2::Model::ALL or
+    # CBM2::P500::Model::ALL, its KERNAL, one of the model's KERNALS, its
+    # mains, 50 or 60 Hz, and whether the DRAM refresh takes its cycles,
+    # the arguments CBM2.new or CBM2::P500.new takes.
+    CBM2Setup = Data.define(:model, :kernal, :mains_hz, :refresh)
+
+    class CBM2Setup
+      MODELS = (CBM2::Model::ALL + CBM2::P500::Model::ALL).map(&:name).freeze
+
+      KERNALS = (CBM2::Model::KERNALS.keys + CBM2::P500::Model::KERNALS.keys).freeze
+
+      MAINS = [50, 60].freeze
+
+      # The setup of `machine`.
+      def self.of(machine)
+        new(model: machine.model.name, kernal: machine.kernal, mains_hz: machine.mains_hz, refresh: machine.refresh?)
+      end
+
+      # The model by name, the KERNAL, the mains and the refresh, in a keyed
+      # snapshot module.
+      def write_fields(out)
+        out.text("model", model).text("kernal", kernal).int("mains_hz", mains_hz).bool("dram_refresh", refresh)
+      end
+
+      def self.read_fields(input)
+        model = input.choice("model", MODELS, CBM2::Model::DEFAULT)
+        kernal = input.choice("kernal", KERNALS, "04a")
+        mains_hz = input.int("mains_hz", 50)
+        unless MAINS.include?(mains_hz)
+          raise FormatError, "the snapshot is of a CBM-II at #{mains_hz} Hz, which badline doesn't build"
+        end
+
+        new(model:, kernal:, mains_hz:, refresh: input.bool("dram_refresh", true))
+      end
+
+      # A machine built this way, at power-on.
+      def build
+        return CBM2::P500.new(model:, mains_hz:) if CBM2::P500::Model.include?(model)
+
+        CBM2.new(model:, kernal:, mains_hz:, refresh:)
+      end
+
+      def to_s
+        machine = "#{model} with KERNAL #{kernal} at #{mains_hz} Hz"
+        refresh || CBM2::P500::Model.include?(model) ? machine : "#{machine} without the DRAM refresh"
+      end
+    end
+  end
+end

data/lib/badline/snapshot/container.rb

@@ -38,9 +38,14 @@ module Badline
       PLUS4 = "PLUS4"
       # xpet names its machine PET, for every model.
       PET = "PET"
+      # xcbm2 names its machine CBM-II, for every B series model.
+      CBM2 = "CBM-II"
+      # xcbm5x0 names its machine CBM-II-5x0, the P500.
+      CBM2_5X0 = "CBM-II-5x0"
       # The file format version each machine's VICE emulator reads, where
-      # it isn't FORMAT_MAJOR.0: xpet refuses any other than 1.0.
-      FORMAT_MAJORS = { PET => 1 }.freeze
+      # it isn't FORMAT_MAJOR.0: xpet and xcbm2 refuse any other than 1.0, and
+      # xcbm5x0 writes 0.0.
+      FORMAT_MAJORS = { PET => 1, CBM2 => 1, CBM2_5X0 => 0 }.freeze
       GZIP_MAGIC = "\x1f\x8b".b
 
       # The VICE version block, when VICE wrote the file: four version

data/lib/badline/snapshot/field_doc/markdown.rb

@@ -7,7 +7,8 @@ module Badline
       # its default, with keys that differ only in a unit's number, such as
       # voice1 to voice3, on one row.
       class Markdown
-        NAMES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128", "plus4" => "Plus/4", "pet" => "PET" }.freeze
+        NAMES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128", "plus4" => "Plus/4", "pet" => "PET",
+                  "cbm2" => "CBM-II" }.freeze
         TAG_TYPES = { Keyed::INT => "int", Keyed::BOOL => "bool", Keyed::BYTES => "bytes", Keyed::INTS => "ints",
                       Keyed::TEXT => "text" }.freeze
 
@@ -31,7 +32,8 @@ module Badline
           `int & 0x..` are ints cut to the latch's width. A text that lists
           its values takes one of them. An optional int is absent when the
           latch holds nothing. A true drive's modules are named from its
-          device number, `BL-D8` to `BL-D11`, and the SIDs past the first
+          device number, `BL-D8` to `BL-D11`, or to `BL-D15` for an 8050 or
+          an 8250. The SIDs past the first
           are `BL-SID2` onwards, in the order they were fitted. Keys with
           `<N>` stand for each numbered unit. A default of "written only" is
           a key the load doesn't read, or reads only when the snapshot has

data/lib/badline/snapshot/field_doc.rb

@@ -37,8 +37,11 @@ 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,
       # the 264 series' models, its TCBM interface, cartridge, tape and
-      # true drives, the 1541 and the 1551, and a CRTC PET, a 2001, an 8096,
-      # an 8296 with its user port jumpered and a PET with a disk and tapes.
+      # true drives, the 1541 and the 1551, a CRTC PET, a 2001, an 8096,
+      # an 8296 with its user port jumpered, a PET with a disk and tapes and
+      # one with a true 2031, one with an 8050 and one with an 8250, and a
+      # 610, a 720, a 610 with a cartridge and one with a disk, and a PAL
+      # and an NTSC 510.
       def self.machines
         {
           "c64" => [C64.new, C64.new(ram_expansion: :plus256k), C64.new(reu: 512),
@@ -51,7 +54,10 @@ module Badline
                       Plus4.new(ram_expansion: :csory256),
                       plus4_with_cartridge, plus4_with_tape, plus4_with_drive, plus4_with_drive("1551")],
           "pet" => [PET.new, PET.new(model: "2001"), PET.new(model: "8096"),
-                    PET.new(model: "8296", characters: "din", jumpers: %w[userport]), pet_with_media]
+                    PET.new(model: "8296", characters: "din", jumpers: %w[userport]), pet_with_media,
+                    pet_with_drive, pet_with_unit("8050"), pet_with_unit("8250")],
+          "cbm2" => [CBM2.new, CBM2.new(model: "720", kernal: "03b", mains_hz: 60), cbm2_with_cartridge,
+                     cbm2_with_disk, CBM2::P500.new, CBM2::P500.new(model: "510ntsc")]
         }
       end
 
@@ -66,8 +72,37 @@ module Badline
         end
       end
 
+      # A PET with a 2031 holding a blank disk.
+      def self.pet_with_drive
+        PET.new.tap do |machine|
+          image = Storage::D64Image.new("", bytes: blank(174_848))
+          machine.plug_true_drive.insert(Drives::Model1541::Disk.decode(image))
+        end
+      end
+
+      # A PET with an 8050 or an 8250 holding a blank disk in drive 0.
+      def self.pet_with_unit(model)
+        image = if model == "8250"
+                  Storage::D82Image.new("", bytes: blank(1_066_496))
+                else
+                  Storage::D80Image.new("", bytes: blank(533_248))
+                end
+        PET.new.tap { |machine| machine.plug_drive8050(model).insert(Drives::Model8050::Disk.new(image)) }
+      end
+
       def self.blank(length) = Array.new(length, 0)
 
+      # A 610 with a disk in device 8 through the traps.
+      def self.cbm2_with_disk
+        CBM2.new.tap { |machine| machine.mount(Storage::D64Image.new("", read_only: true, bytes: blank(174_848))) }
+      end
+
+      # A 610 with an 8K cartridge ROM at $2000.
+      def self.cbm2_with_cartridge
+        chip = Storage::CRTFile::Chip.new(chip_type: 0, bank: 0, address: 0x2000, data: blank(0x2000))
+        CBM2.new.tap { |machine| machine.attach_cartridge([chip]) }
+      end
+
       def self.with_cartridge(type)
         chips = [0x8000, 0xa000].map do |address|
           Storage::CRTFile::Chip.new(chip_type: 2, bank: 0, address:, data: blank(0x2000))