badline 0.16.0 → 0.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e262717ff30b8634c869b951cbb627fead4c6d4270cb0f9251cfadb567c0edef
-  data.tar.gz: 6c35c8a8313fe7de6de0d7df4a8436bebc160e1267e11132bd84c0be0abc50b0
+  metadata.gz: 3e6b53df8a82bbf9f9524441b6d948fb245c0e81c589757dcd23b7e69fbd4c69
+  data.tar.gz: 83e5a043f2a09ed982663e1df4a0f4e2c5483791417fd1220785dab8d0e39d42
 SHA512:
-  metadata.gz: b9de5e45e9ab8b0d8a18c98815599c6055f0fc1a44a2324f34f60753a3096d5c254edad42852e7bf0bf1507b1fb845512cca41117fb6f5f51988fa3a41be0204
-  data.tar.gz: 5102663a8eee7f811f9e88b81ff79948ad4f1011d790551a8d8bbba53de29c676f4055db0fe15a2e1085b0bbe3efee805e2db421ba5161b77c9abbaefb181623
+  metadata.gz: f739ad0afd029d46648ceff8307e010ca6290e4c8951175e30c70e08ec11385dba966c79ebd2d3d5a93e52db922b0362b45239825e3f42e750ee4f0fe56589a5
+  data.tar.gz: d5e22aa87453b2446e2d5c2168f99076e4a950a753022fd5dc5946fb56ababc156bcda2b0d57ed1e90a923dee9d693c7040187f4475d8c1a6e50afa5346ca7e3

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.16.1](https://github.com/elektronaut/badline/compare/v0.16.0...v0.16.1) (2026-10-18)
+
+
+### Features
+
+* add the 2031 disk drive on the PET's IEEE-488 bus ([bcc76a5](https://github.com/elektronaut/badline/commit/bcc76a536a44bdb6173b26823c83a5026a788c4f))
+* add the CBM 8296 ([48fb14d](https://github.com/elektronaut/badline/commit/48fb14d0d94b75cf003d7601c637158801acaef8))
+* put a true 2031 on the PET's device 8 with --true-drive ([c64e1b4](https://github.com/elektronaut/badline/commit/c64e1b4245b1390ba6d57e5ffaad620c4055b5cd))
+* read and write xpet's .vsf snapshots for the PET ([607050b](https://github.com/elektronaut/badline/commit/607050b9c72767e335d2b488afd0d3c4ce153c81))
+* save a PET's 2031 in its snapshots ([a8d6880](https://github.com/elektronaut/badline/commit/a8d68806a34e34f45c02fb7a5a00dd2699ccb618))
+
+
+### Bug Fixes
+
+* blank the CRTC PETs' character lines past the eighth ([f02db02](https://github.com/elektronaut/badline/commit/f02db02a6255944b552b6a5f3e8108483ae78875))
+
 ## [0.16.0](https://github.com/elektronaut/badline/compare/v0.15.1...v0.16.0) (2026-10-17)
 
 

data/README.md

@@ -82,7 +82,7 @@ differences noted in the table. `--help` lists the options for either.
 | --- | --- |
 | `--no-autostart` | Attach the media and stop at `READY.`, so you can type the `LOAD` yourself |
 | `--writable` | Let the machine write to disk images. Without it, a disk goes in write-protected: the drive reports `26,WRITE PROTECT ON` for any write and the image file stays as it was |
-| `--true-drive` | Put an emulated 1541 on device 8 instead of the KERNAL traps, or a 1551 on the Plus/4. See [Media](#media) |
+| `--true-drive` | Put an emulated 1541 on device 8 instead of the KERNAL traps, a 1551 on the Plus/4, or a 2031 on the PET. See [Media](#media) |
 | `--drive-type 1541` | On the Plus/4, make the true drive on device 8 an emulated 1541 on the serial bus in place of the 1551. It implies `--true-drive`. See [The Plus/4](#the-plus4) |
 | `-s`, `--subtune N` | Pick a subtune of a `.sid` file, counting from 1 |
 | `--sid 6581`, `--sid 8580` | Fit the older or newer SID. `--sid auto`, the default, takes a `.sid` tune's own |
@@ -115,7 +115,7 @@ differences noted in the table. `--help` lists the options for either.
 | `--script FILE` | Run the events in `FILE`, one `FRAME:EVENT` a line |
 | `--screenshot FILE` | Save the last frame as a `.bmp` |
 | `--save-snapshot FILE` | Save the machine as a `.vsf` snapshot after the last frame |
-| `--vice` | Add VICE's modules to `--save-snapshot`'s C64 snapshot, so x64sc opens it too |
+| `--vice` | Add VICE's modules to `--save-snapshot`'s C64 or PET snapshot, so x64sc or xpet opens it too |
 
 ```sh
 badline --unpaced --frames 12000 --true-drive disk1.d64 \
@@ -302,7 +302,8 @@ badline pet --model 2001            # The first PET, with BASIC 1
 
 `--model` picks the machine: `8032` (the default, 32K, 80 columns and
 the business keyboard), `8096` (an 8032 with the 64K board at `$FFF0`),
-`4032` (40 columns on a CRTC and the graphics keyboard), `3032` (the
+`8296` (128K on one board, below), `4032` (40 columns on a CRTC and the
+graphics keyboard), `3032` (the
 discrete 40-column board with BASIC 2), `3032b` (the same with the
 business keyboard) and `2001` (8K, BASIC 1 and the chiclet keyboard).
 `--ram 4k`, `8k` or `16k` fits less RAM in place of the model's own, as
@@ -324,7 +325,22 @@ cycles, 400 to a frame. `4-80-b-50hz-0283`, the chip dated 0283, runs
 lines of 64 cycles, 313 to a frame, with the screen's rows a scanline
 closer together and lower down. Both boot to the same READY.
 
+The 8296 is an 8032 on a board of its own, with 128K: 32K below
+`$8000`, 32K above it, whose first 4K hold the screen and the rest lies
+under the ROMs, and a 64K board banked through `$FFF0` as the 8096's is.
+Writes from `$8000` up go to the RAM under the ROMs, and `--jumpers`
+fits the jumpers that let reads find it there: `ram9` and `rama` for RAM
+at `$9000` and `$A000`, as xpet's `-petram9` and `-petramA`, and
+`userport` for the user port's PA0 to PA2 to switch it in over BASIC,
+the editor and the KERNAL. Its CRTC's RA4 is an address line, so the
+lines past the 16th of a tall character row show RAM from `$C000`. It
+runs its own 50 Hz editor, `4-80-b-50hz-8296`, with lines of 59 cycles,
+339 to a frame, and takes the 8032's editors too. `--characters din`
+fits the German boards' 4K character ROM, whose two halves R12's bit 5
+picks between.
+
 ```sh
+badline pet --model 8296 --jumpers ram9,rama  # An 8296 with RAM at $9000 and $A000
 badline pet --model 2001 --basic 2   # A 2001 with BASIC 2
 badline pet --model 3032 --basic 4   # A 3032 with BASIC 4, without a CRTC
 badline pet --editor 4-80-b-60hz     # An 8032 at 60 Hz, as --60hz runs it
@@ -341,11 +357,13 @@ A program loads at the start of BASIC, `$0401`, and runs. A `.d80`, a
 `.d82` or a tape made for the PET starts a PET without `pet`, but a
 program that loads at `$0401` starts a C64, since a VIC-20 with 3K loads
 there too. Disks go through the KERNAL traps on the IEEE-488 bus as
-device 8, and tapes play on cassette port 1. The keys type what the host's
+device 8, or with `--true-drive` an emulated 2031 on the bus, which
+reads `.d64` and `.g64` images, and tapes play on cassette port 1. The keys type what the host's
 keys type, on either keyboard, and `Alt` adds the PET's `SHIFT`:
 [Input](#input) lists the rest. The pause
 menu's Power page names the model, its RAM and its frame rate, and its
-Expansion port page its RAM and the 8096's 64K board. The PET has no
+Expansion port page its RAM and the 8096's 64K board, or the 8296's
+jumpers. The PET has no
 joysticks. `F11` and the Snapshots page save it as they do the others,
 but not for VICE.
 
@@ -357,7 +375,8 @@ newest, even after badline has quit and started again. badline also
 autosaves every two minutes of play, and the pause menu's Snapshots page
 saves under a name and loads any of them. Snapshots from badline 0.14.0
 on load in every later version. They use VICE's `.vsf` format: badline
-opens those x64sc saves, and x64sc opens badline's saved with `--vice`.
+opens those x64sc and xpet save, and x64sc and xpet open badline's saved
+with `--vice`.
 See [doc/snapshots.md](doc/snapshots.md) for where they're kept, what
 they hold and how far the two agree.
 
@@ -534,12 +553,16 @@ in cartridge 1 as it does from the command line.
   receives at its baud rates, with nothing on the user port; Ruby code
   driving the machine can plug in a terminal, whose bytes it feeds and
   drains, or a loopback plug (`Plus4::ACIA#plug`).
-- **PET and CBM**: the 2001, 3032, 3032b, 4032, 8032 and 8096, with
-  BASIC 1, 2 or 4, the discrete video and the 6545 CRTC on 40 and 80
+- **PET and CBM**: the 2001, 3032, 3032b, 4032, 8032, 8096 and 8296,
+  with BASIC 1, 2 or 4, the discrete video and the 6545 CRTC on 40 and 80
   columns, both 6520 PIAs and the 6522 VIA, the graphics and business
-  keyboards, the sound on the VIA's CB2, the 8096's 64K board, both
+  keyboards, the sound on the VIA's CB2, the 8096's 64K board, the
+  8296's 128K with its jumpers, RA4 and 4K character ROM, both
   cassette ports and device 8 on the IEEE-488 bus through the KERNAL
   traps, `.d80` and `.d82` among its disks (`badline pet`).
+- **2031**: the PET's single drive, the 1541's board and DOS 2.6 on the
+  IEEE-488 bus, with the bus's handshake on every line
+  (`badline pet --true-drive`).
 - **1541**: an emulated drive running its own DOS (`--true-drive`).
 - **1571**: the C128D's drive running DOS 3.0, in 1541 mode and in 1571
   mode at 2 MHz with both sides of a `.d71` or `.g71`, and fast serial

data/doc/media.md

@@ -38,6 +38,15 @@ On the Plus/4 and the C16, `--true-drive` puts an emulated 1551 there
 instead, on TCBM, the parallel cable to its interface in the expansion
 port, and `--drive-type 1541` a 1541 on the serial bus.
 
+On the PET, `--true-drive` puts an emulated 2031 there, the 1541's board
+with an IEEE-488 interface, running DOS 2.6 and answering the bus's
+handshake line by line. It reads `.d64` and `.g64` images, which BASIC 2
+and 4 autostart with `LOAD"*",8` and `RUN`; a `.d80` or `.d82` needs the
+traps. BASIC 1's LOAD never finishes on the drive, since its UNLISTEN
+leaves its command in the device number the LOAD then talks to, but its
+OPEN, INPUT# and PRINT# work, and the error channel with them. `--basic
+2`, the upgrade Commodore sold, loads.
+
 A `.g64` holds the disk's raw GCR, half tracks and all, so copy
 protection and fast loaders that read it work.
 

data/doc/snapshot-format.md

@@ -68,9 +68,10 @@ Written by the C64, VIC-20, C128, Plus/4, PET.
 | `host.true_drive_model` | text: 1541 1551 | Plus/4: "1551" |
 | `refresh_hz` | int | PET: 50 or 60 |
 | `rom.basic` | text | PET: "pet/basic4.rom" or "pet/basic1.rom" |
-| `rom.editor` | text | PET: "pet/editor4-80-b-50hz.rom" or "pet/editor1.rom" |
+| `rom.editor` | text | PET: "pet/editor4-80-b-50hz.rom" or "pet/editor1.rom" or "pet/editor4-80-b-50hz-8296.rom" |
 | `rom.kernal` | text | PET: "pet/kernal4.rom" or "pet/kernal1.rom" |
 | `rom.characters` | text | PET: "pet/characters2.rom" or "pet/characters1.rom" |
+| `jumpers` | text | PET: "" |
 | `vertical_drive` | bool | PET: true |
 
 ## BL-RAM
@@ -84,9 +85,10 @@ Written by the C64, VIC-20, C128, Plus/4, PET.
 | `bus.high_bank` | int & 0x3 | Plus/4: 0 |
 | `bus.rom_selected` | bool | Plus/4: true |
 | `bus.data` | byte | Plus/4: 255; PET: 253 |
-| `screen` | bytes | PET: 2048 × 0 or 1024 × 0 |
+| `screen` | bytes | PET: 2048 × 0 or 1024 × 0 or 32768 × 0 |
 | `expansion.control` | byte | PET: 0 |
 | `expansion.ram` | bytes | PET: 65536 × 0 |
+| `expansion.user_port` | int | PET: 7 |
 
 ## BL-COLORRAM
 

data/doc/snapshots.md

@@ -143,16 +143,57 @@ doesn't open it, and badline doesn't open xplus4's. `--vice` and
 ## The PET
 
 Every PET and CBM model saves and restores the same way. A snapshot of
-one holds its RAM, the screen RAM, an 8096's 64K board with its control
-register, both PIAs, the VIA, the CPU, the CRTC on the boards that have
-one, the picture with where the video is in its frame, the tapes in both
-datasettes with their places on them, and the disk or directory device 8
-serves through the IEEE-488 traps. It restores into a machine of the same
-model with the same RAM, the same editor frame rate and the same ROMs,
-which come with the model. Its file names its machine `PET`, as xpet's
-do, and holds only badline's modules, so xpet doesn't open it, and
-badline doesn't open xpet's. `--vice` and
-`computer.export_snapshot(path)` refuse a PET.
+one holds its RAM, the screen RAM, or on an 8296 all 32K from `$8000`,
+an 8096's or 8296's 64K board with its control register and the user
+port lines the 8296's RAM follows, both PIAs, the VIA, the CPU, the
+CRTC on the boards that have one, the picture with where the video is
+in its frame, the tapes in both datasettes with their places on them,
+and the disk or directory device 8 serves through the IEEE-488 traps.
+It restores into a machine of the same model with the same RAM, the
+same editor frame rate, the same ROMs, which come with the model, and
+an 8296's same jumpers. Its file names its machine `PET`, as xpet's do,
+and holds only badline's modules, so xpet doesn't open it unless it is
+saved with `--vice` (see [xpet](#xpet)).
+
+### xpet
+
+A PET snapshot saved with `--vice`, or `computer.export_snapshot(path)`,
+also holds xpet's modules for the CPU, the RAM with the screen RAM, or
+an 8296's 32K from `$8000`, an 8096's or 8296's board and its control
+register, the CRTC, both PIAs and the VIA, and the ones xpet 3.10 needs
+to open the file, with nothing open on the file system drive and
+nothing on the user port. The CRTC module carries the discrete boards'
+video too, in xpet's terms. The file says it is in VICE's snapshot
+format 1.0, the only one xpet reads.
+
+xpet 3.10 opens those snapshots as long as its model and editor match:
+`-model 2001`, `3032`, `3032B`, `4032`, `8032`, `8096` or `8296`, and
+for a badline editor other than xpet's own, `-editor` naming badline's
+ROM. xpet's 8296 runs the 8032's editor, 901474-04 dated 0283, so an
+8296 saved for it has to run that editor (`--editor 4-80-b-50hz-0283`),
+and xpet takes the 8296's jumpers from its own settings. It keeps its
+own drives and datasettes and leaves out badline's tapes and disk. Its
+CRTC loses a few lines on opening any snapshot, its own too, so a
+program it runs on from one finds the vertical sync a few hundred
+cycles later than one it ran without stopping.
+
+Snapshots xpet saves open in badline through the same modules: the CPU
+at its instruction boundary, the RAM, the screen RAM, an 8096's or
+8296's board, the CRTC's registers and beam, both PIAs' registers and
+flags, and the VIA's registers, timers and shift register. A program
+badline runs on from xpet's snapshot finds the vertical sync on the
+cycle xpet does, so the two run on alike, cycle for cycle. The picture
+starts again with the next frame. xpet doesn't save its ROMs, which
+keyboard it has or an 8296's jumpers, so the board, the RAM and the
+CRTC's frame build the machine: a 2001, a 3032 for any other discrete
+board, a 4032, an 8032, an 8096 or an 8296 with none of its jumpers
+fitted, at 50 or 60 Hz, and an 8032, 8096 or 8296 whose CRTC lines are
+64 cycles long runs xpet's own 50 Hz editor, 901474-04 dated 0283. A
+SuperPET's snapshot fails. It reports the modules it leaves out, such
+as the drives, the datasettes and the keyboard, and carries on without
+them. Restored into a running PET, an xpet snapshot fails for a PET
+built another way, such as a 3032B, and otherwise switches the machine
+off and on, keeping its tapes and the disk device 8 serves.
 
 ## VICE
 

data/lib/badline/drives/ieee_bus.rb

@@ -8,9 +8,13 @@ module Badline
     # pulls it low. The PET is the controller and always on the bus, and
     # reads back every line it drives.
     #
-    # No device plugs in yet, so the lines carry the controller's levels
-    # alone: nobody answers a handshake, and the KERNAL reports DEVICE NOT
-    # PRESENT for every device the traps don't serve.
+    # The controller pushes the lines it pulls whenever they may have moved
+    # (host_lines=), and the bus holds them for the drives, which take them
+    # a host cycle late. Each drive on the bus answers the lines it pulls
+    # (ieee_low_lines) while ATN is or isn't low, from its own outputs, which
+    # hold still while it sleeps. With no drive on the bus nobody answers a
+    # handshake, and the KERNAL reports DEVICE NOT PRESENT for every device
+    # the traps don't serve.
     class IEEEBus
       # The lines as bits, the data lines in the low byte, DIO1 in bit 0.
       DIO = 0x00ff
@@ -20,9 +24,51 @@ module Badline
       NDAC = 0x0800
       ATN = 0x1000
 
+      # The lines the controller last pushed.
+      attr_reader :host_lines
+
+      attr_reader :drives
+
+      def initialize
+        @drives = []
+        @host_lines = 0
+      end
+
+      # The controller pushes the lines it pulls, and the drives look at
+      # them again.
+      def host_lines=(lines)
+        @host_lines = lines
+        drives = @drives
+        i = 0
+        while i < drives.length
+          drives[i].host_written!
+          i += 1
+        end
+      end
+
+      def attach(drive)
+        @drives << drive unless @drives.include?(drive)
+      end
+
+      def detach(drive)
+        @drives.delete(drive)
+      end
+
       # The lines low on the bus while the controller pulls the lines in
       # +controller+ low.
-      def low_lines(controller) = controller
+      def low_lines(controller)
+        low = controller
+        drives = @drives
+        return low if drives.empty?
+
+        atn = controller.anybits?(ATN)
+        i = 0
+        while i < drives.length
+          low |= drives[i].ieee_low_lines(atn)
+          i += 1
+        end
+        low
+      end
     end
   end
 end

data/lib/badline/drives/model2031/ieee_port.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model2031
+      # VIA 1's side of the IEEE-488 bus (Drives::IEEEBus), through a 75160
+      # for the data lines and a 75161 for the control lines (schematic
+      # 2031038, sheet 2):
+      #
+      #   PA0-7  DIO1-8                   PB4  T/R, high to talk
+      #   PB0    ATN acknowledge (ATNA)   PB5  HD SEL, unused
+      #   PB1    NRFD                     PB6  DAV
+      #   PB2    NDAC                     PB7  ATN in, high while ATN is low
+      #   PB3    EOI                      CA1  ATN in, as PB7
+      #
+      # The ports read and drive the lines' levels, 0 for a low line. T/R
+      # turns the transceivers: talking, the drive drives the data lines,
+      # DAV and EOI, and reads NRFD and NDAC; listening, the other way round.
+      # EOI turns back to the bus while ATN is low. A pin the transceiver
+      # drives the bus from reads the drive's own side, high but for what
+      # the VIA or a jumper pulls low.
+      #
+      # An XOR of ATN in and ATNA drives two 7406s that pull NRFD and NDAC
+      # low on the bus, so the drive answers ATN before the DOS gets to it,
+      # and holds the bus until the DOS acknowledges. ATNA reaches the XOR
+      # only while PB0 is an output, and is low there otherwise, which
+      # leaves the bus alone while the DOS reads the jumpers.
+      #
+      # The device number jumpers are diodes from PB0 and PB1 to CA2: with
+      # CA2 low, a fitted diode pulls its line low, and the DOS reads the
+      # device number off the two at reset, 8 with both fitted. Lifting the
+      # one on PB0 adds 1, and the one on PB1 2.
+      #
+      # The drive takes the controller's lines a host cycle late, as the
+      # serial drives do (Engine::SerialLines): latch_host takes them at the
+      # end of each host cycle.
+      class IEEEPort
+        ATNA = 0x01
+        NRFD = 0x02
+        NDAC = 0x04
+        EOI = 0x08
+        TALK = 0x10
+        DAV = 0x40
+        ATN_IN = 0x80
+
+        attr_reader :bus
+
+        # The lines the controller pulled, as latch_host took them.
+        attr_reader :host
+
+        def initialize(device:, bus:)
+          raise ArgumentError, "a 2031 is device 8 to 11, not #{device}" unless device.between?(8, 11)
+
+          @diodes = ~(device - 8) & 0x03
+          @via = nil
+          @host = 0
+          self.bus = bus
+        end
+
+        # The drive's VIA 1, whose outputs it drives the bus with.
+        attr_writer :via
+
+        def bus=(bus)
+          @bus = bus
+          latch_host
+        end
+
+        # Takes the controller's lines for the drive cycles of the next host
+        # cycle.
+        def latch_host
+          @host = @bus.host_lines
+        end
+
+        # Whether the controller has moved ATN since the last latch_host.
+        def atn_moved? = (@bus.host_lines ^ @host).anybits?(IEEEBus::ATN)
+
+        def atn_low? = @host.anybits?(IEEEBus::ATN)
+
+        # The data lines, while the transceiver listens.
+        def read_a(_lines) = talking? ? 0xff : ~@bus.low_lines(@host) & 0xff
+
+        # The control lines the transceiver turns towards the drive, and
+        # ATN.
+        def read_b(_lines)
+          low = @bus.low_lines(@host)
+          value = 0x7f
+          if talking?
+            value &= ~NRFD if low.anybits?(IEEEBus::NRFD)
+            value &= ~NDAC if low.anybits?(IEEEBus::NDAC)
+            value &= ~EOI if low.anybits?(IEEEBus::EOI) && low.anybits?(IEEEBus::ATN)
+          else
+            value &= ~EOI if low.anybits?(IEEEBus::EOI)
+            value &= ~DAV if low.anybits?(IEEEBus::DAV)
+          end
+          value |= ATN_IN if low.anybits?(IEEEBus::ATN)
+          value & jumpers
+        end
+
+        # The lines the drive pulls low while ATN is low or not, as bus bits.
+        def ieee_low_lines(atn)
+          via = @via
+          lines = via.port_b_output & jumpers
+          low = 0
+          if lines.anybits?(TALK)
+            low |= ~via.port_a_output & IEEEBus::DIO
+            low |= IEEEBus::DAV if lines.nobits?(DAV)
+            low |= IEEEBus::EOI if lines.nobits?(EOI) && !atn
+          else
+            low |= IEEEBus::NRFD if lines.nobits?(NRFD)
+            low |= IEEEBus::NDAC if lines.nobits?(NDAC)
+          end
+          low |= IEEEBus::NRFD | IEEEBus::NDAC if atn != (lines & via.port_b_directions).anybits?(ATNA)
+          low
+        end
+
+        # The controller's lines as the port latched them, under `prefix`.
+        def save_fields(out, prefix) = out.int("#{prefix}host", @host)
+
+        def load_fields(input, prefix)
+          @host = input.int("#{prefix}host", @host)
+        end
+
+        private
+
+        def talking? = @via.port_b_output.anybits?(TALK)
+
+        # PB0 and PB1 as the jumper diodes leave them: pulled low through
+        # each fitted one while CA2 is low.
+        def jumpers = @via.ca2_output ? 0xff : ~@diodes & 0xff
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model2031
+      # 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
+      # controller's lines as the IEEE-488 port latched them under ieee.*. 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, "ieee.")
+          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, "ieee.")
+        end
+
+        # 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, as the 1541's.
+        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 : Model1541::Disk.from_fields(disk, detached: modules.detached?))
+          @via1.restored!
+          @via2.restored!
+          @cpu.restored!
+          forget_orbits
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/drives/model2031/parts.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model2031
+      # VIA 1, facing the IEEE-488 bus (IEEEPort), a class of its own so
+      # its peripheral keeps one type, apart from the serial drives'.
+      class IEEEVIA < Chips::VIA
+        # DDRB, whose PB0 says whether the VIA drives ATNA (IEEEPort).
+        def port_b_directions = @ddrb
+      end
+
+      # The drive CPU's bus, decoded as the 1541's (Model1541::Bus), with
+      # VIA 1 an IEEEVIA.
+      class Bus < Model1541::Bus
+      end
+
+      # The drive's 6502, on the drive's Bus.
+      class CPU
+        include Badline::Chips::CPU::Core
+        include Engine::IdleCPU
+      end
+    end
+  end
+end

data/lib/badline/drives/model2031.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "badline/drives/model1541"
+require "badline/drives/ieee_bus"
+require "badline/drives/model2031/parts"
+require "badline/drives/model2031/ieee_port"
+require "badline/drives/model2031/keyed_state"
+
+module Badline
+  module Drives
+    # The 2031 disk drive of the PET and CBM: the 1541's board with an
+    # IEEE-488 interface in place of the serial one (Commodore schematic
+    # 2031038). A 6502 at 1 MHz runs DOS 2.6 from 16 KB of ROM, with 2 KB
+    # of RAM, VIA 1 at $1800 on the IEEE-488 bus (IEEEPort) and VIA 2 at
+    # $1C00 running the 1541's GCR Mechanism, decoded as the 1541's.
+    #
+    # Drives::Engine::Core clocks it against the host and sleeps through
+    # the DOS's idle loop, as the 1541's, until ATN moves or a timer is due
+    # (Engine::VIAs). The bus reads the lines it pulls without waking it.
+    class Model2031
+      include Engine::Core
+      include Engine::VIAs
+
+      CLOCK_HZ = 1_000_000
+
+      # Where the DOS's idle loop starts over (see Drives::Engine::Idle).
+      IDLE_LOOP = 0xec4d
+
+      # The host cycles by which a 2031 switched on with the machine has run
+      # its DOS's RAM test and ROM checksums and reads its jumpers.
+      BOOT_CYCLES = 1_300_000
+
+      attr_reader :ieee_bus
+
+      def model_name = "2031"
+
+      # +rom+ covers $C000-$FFFF, and defaults to the DOS image in the ROM
+      # path. +device+ is the number the jumpers set, 8 to 11.
+      def initialize(rom: nil, host_clock_hz: CLOCK_HZ, device: 8, debug: false)
+        @device = device
+        @ieee_bus = IEEEBus.new
+        @serial_port = IEEEPort.new(device:, bus: @ieee_bus)
+        @via1 = IEEEVIA.new(start: 0x1800, peripheral: @serial_port)
+        @serial_port.via = @via1
+        @mechanism = Model1541::Mechanism.new
+        @via2 = Model1541::DiskVIA.new(start: 0x1c00, mechanism: @mechanism)
+        @bus = Bus.new(rom: rom || ROM.load("dos2031.rom", 0xc000), via1: @via1, via2: @via2)
+        @cpu = CPU.new(@bus, debug:)
+        @clock_hz = CLOCK_HZ
+        @idle_loop = IDLE_LOOP
+        @host_clock_hz = host_clock_hz
+        @phase = 0
+        @cycles = 0
+        init_idle(debug)
+        @via1.ca1 = false
+        @via1.reset!
+        connect(@ieee_bus)
+      end
+
+      # Plugs the drive into an IEEE-488 bus, leaving the one it was on.
+      def connect(ieee_bus)
+        settle!
+        @ieee_bus.detach(self)
+        @ieee_bus = ieee_bus
+        @serial_port.bus = ieee_bus
+        ieee_bus.attach(self)
+        hear_atn
+      end
+
+      # The lines the drive pulls on the bus while ATN is low or not
+      # (IEEEPort). They hold still while it sleeps, so reading them leaves
+      # it asleep.
+      def ieee_low_lines(atn) = @serial_port.ieee_low_lines(atn)
+
+      private
+
+      # One drive cycle, as the 1541's (Model1541#step): the mechanism, then
+      # ATN on VIA 1's CA1, the VIAs and the CPU.
+      def step
+        so = @mechanism.take_so
+        @mechanism.cycle!
+        @via1.ca1 = @serial_port.atn_low?
+        @via1.cycle!
+        @via2.cycle!
+        @cpu.irq = @via1.irq? || @via2.irq?
+        @cpu.so! if so
+        @cpu.cycle!
+        @cycles += 1
+      end
+    end
+  end
+end

data/lib/badline/frontend/menu/menu_pages.rb

@@ -156,10 +156,19 @@ module Badline
         toggle(plus4? ? "SID CARD" : "SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], model == :mos8580 ? 1 : 0])
       end
 
-      # The PET's memory: its RAM, and the 8096's 64K board.
+      # The PET's memory: its RAM, the 8096's 64K board, and the 8296's
+      # 128K with the jumpers that put RAM under its ROMs.
       def draw_pet_memory
+        model = @computer.model
+        return draw_8296_memory if model.cbm8296?
+
         info("RAM", "#{@computer.ram_kb}K")
-        info("EXPANSION RAM", @computer.model.expansion ? "64K BOARD" : "")
+        info("EXPANSION RAM", model.expansion ? "64K BOARD" : "")
+      end
+
+      def draw_8296_memory
+        info("RAM", "128K, 64K OF IT BANKED")
+        info("JUMPERS", @computer.jumpers.join(", ").upcase)
       end
 
       # Saving now and by name, loading a named save, and the quicksaves

data/lib/badline/kernal_trap/ieee.rb

@@ -23,6 +23,9 @@ module Badline
       UNTALK_COMMAND = 0x5f
       UNLISTEN_COMMAND = 0x3f
 
+      # The device the traps serve, or nil to serve none.
+      attr_accessor :device
+
       def initialize(cpu:, bus:, layout:, dos:)
         @cpu = cpu
         @bus = bus