badline 0.15.1 → 0.16.1

data/lib/badline/pet/cassettes.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The PET's two cassette ports, each with a datasette:
+    #
+    #             read       motor, low runs it   sense, low with a key down
+    #   #1        PIA 1 CA1  PIA 1 CB2            PIA 1 PA4
+    #   #2        VIA CB1    VIA PB4              PIA 1 PA5
+    #
+    # Both record from VIA PB3. The KERNAL reads each tape as the falling
+    # edges its read line makes, as the C64 and VIC-20 do. The machine
+    # passes the motor and write lines on after each write to the I/O
+    # chips (#lines_written).
+    class Cassettes
+      attr_reader :datasette1, :datasette2
+
+      def initialize(pia1, via)
+        @pia1 = pia1
+        @via = via
+        @datasette1 = Drives::Datasette.new
+        @datasette2 = Drives::Datasette.new
+        @datasette1.on_flag { pulse1 }
+        @datasette2.on_flag { pulse2 }
+      end
+
+      def cycle!
+        @datasette1.cycle!
+        @datasette2.cycle!
+      end
+
+      # PA4 and PA5 of PIA 1's port A, low for a deck with a key down.
+      def sense_input
+        value = 0xff
+        value &= 0xef if @datasette1.sense_low?
+        value &= 0xdf if @datasette2.sense_low?
+        value
+      end
+
+      def lines_written
+        port_b = @via.port_b_output
+        @datasette1.motor = !@pia1.cb2_output
+        @datasette2.motor = port_b.nobits?(0x10)
+        write_high = port_b.anybits?(0x08)
+        @datasette1.write_line = write_high
+        @datasette2.write_line = write_high
+      end
+
+      private
+
+      # A falling edge on a read line, and the line back up.
+      def pulse1
+        @pia1.ca1 = false
+        @pia1.ca1 = true
+      end
+
+      def pulse2
+        @via.cb1 = false
+        @via.cb1 = true
+      end
+    end
+  end
+end

data/lib/badline/pet/characters.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The character ROM as the video reads it: 2K of two sets, graphics
+    # (upper case and graphics) from $000 and text (lower and upper case)
+    # from $400, 128 characters of 8 rows each. Bit 7 of a screen code
+    # inverts the character's rows, as the hardware does, so #rows holds
+    # 256 codes a set, each row at (set << 11) | (code << 3) | row. A 4K
+    # ROM, the 8296's, holds two such halves, the second at HALF.
+    class Characters
+      TEXT = 0x800
+
+      HALF = 0x1000
+
+      attr_reader :rows
+
+      def initialize(file)
+        rom = ROM.read(file)
+        @rows = Array.new(rom.length << 1) do |index|
+          set = index >> 11
+          code = (index >> 3) & 0xff
+          bits = rom[(set << 10) | ((code & 0x7f) << 3) | (index & 0x07)]
+          code >= 0x80 ? bits ^ 0xff : bits
+        end
+      end
+
+      # Whether the ROM holds two halves.
+      def halves? = @rows.length > HALF
+    end
+  end
+end

data/lib/badline/pet/cpu.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The PET's 6502, on the PET::Bus.
+    class CPU
+      include Badline::Chips::CPU::Core
+    end
+  end
+end

data/lib/badline/pet/crtc_video.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # What the CRTC boards make of the CRTC's outputs. Each character the
+    # CRTC displays reads the screen RAM at its memory address, MA0-MA9,
+    # and the character ROM's row RA0-RA2 from the half VIA CA2 selects.
+    # On the 80-column boards each character reads two bytes, at twice the
+    # address and the one after, and shows them side by side, 16 dots to a
+    # cycle. MA12 low inverts the picture, and RA3 or RA4 high blanks the
+    # line (NO ROW on the 8032029 and 8032087 schematics' sheet 10), so a
+    # row taller than eight lines shows its first eight alone.
+    #
+    # The 8296's board (+board8296+) reads the screen from the 32K of RAM
+    # from $8000 on: MA0-MA11 count two bytes each from $8000, RA3 alone
+    # blanks the line, and RA4 adds $4000, so lines 16 to 23 of a row
+    # taller than 16 show the RAM under BASIC at $C000. MA13 picks the half
+    # of a 4K character ROM.
+    #
+    # The picture is a Canvas 273 lines high, 704 dots wide on 80 columns
+    # and 384 on 40, framed as xpet frames it. Across, R1's characters sit
+    # in the middle as R1, R0 and R2 stand at the start of the frame, and
+    # each character shows as far right as it comes after its line's
+    # horizontal sync, so a line whose sync moves moves with it. Down, the
+    # frame's first line sits where the lines the last frame showed until
+    # the display stopped at R6 would sit in the middle (a frame where it
+    # never stopped leaves that alone), and each horizontal sync starts the
+    # next line of the picture. Nothing shows within MARGIN dots of either
+    # side.
+    class CRTCVideo
+      HEIGHT = 273
+
+      # The dots at each side that xpet leaves black even where the display
+      # runs on through horizontal sync.
+      MARGIN = 8
+
+      attr_reader :canvas
+
+      # The screen RAM's bytes.
+      attr_writer :cells
+
+      def initialize(characters, via, crtc_registers, columns80:, board8296: false)
+        @cells = []
+        @rows = characters.rows
+        @cell_mask = board8296 ? 0xfff : 0x3ff
+        @ra4 = board8296 ? 0x10 : 0
+        @no_row = board8296 ? 0x08 : 0x18
+        @half = characters.halves? ? 0x2000 : 0
+        @via = via
+        @registers = crtc_registers
+        @wide = columns80
+        @char_shift = columns80 ? 4 : 3
+        @canvas = Canvas.new(columns80 ? 704 : 384, HEIGHT, margin: MARGIN)
+        @displayed = 200
+        @frame_displayed = 0
+        @line_shown = false
+        @y = 0
+        @from_y = 0
+        @to_y = 0
+        @shown_from = 0
+        @shown_to = HEIGHT
+        @on_canvas = false
+        @origin = 0
+        @from = 0
+        @to = 0
+        frame_start
+      end
+
+      def character(address, raster, since_hsync)
+        @line_shown = true
+        return unless @on_canvas
+
+        x = @origin + (since_hsync << @char_shift)
+        @from = x if x < @from
+        @to = x if x > @to
+        bits = raster.anybits?(@no_row) ? 0 : row_bits(address, raster)
+        if @wide
+          @canvas.paint(x, @y, bits >> 8)
+          @canvas.paint(x + 8, @y, bits & 0xff)
+        else
+          @canvas.paint(x, @y, bits)
+        end
+      end
+
+      # Horizontal sync takes the beam to the next line of the picture.
+      def hsync
+        end_canvas_line
+        @y += 1
+        @on_canvas = @y >= 0 && @y < HEIGHT
+      end
+
+      def line_end
+        @frame_displayed += 1 if @line_shown
+        @line_shown = false
+      end
+
+      # The display stops for the rest of the frame after the lines it has
+      # shown, which frame the next one.
+      def rows_end
+        @displayed = @frame_displayed
+      end
+
+      def frame_start
+        end_canvas_line
+        sweep(@shown_from, [@from_y, @shown_to].min)
+        sweep([@to_y, @shown_from].max, @shown_to)
+        @shown_from = @from_y
+        @shown_to = @to_y
+        @frame_displayed = 0
+        regs = @registers
+        @origin = ((@canvas.width - (regs[1] << @char_shift)) >> 1) - ((regs[0] + 1 - regs[2]) << @char_shift)
+        @y = (HEIGHT - (@displayed + 1)) / 2
+        @on_canvas = @y >= 0 && @y < HEIGHT
+        @from_y = @y.clamp(0, HEIGHT)
+        @to_y = @from_y
+      end
+
+      private
+
+      # The row's dots, both bytes' on 80 columns, high byte left.
+      def row_bits(address, raster)
+        set = @via.ca2_output ? Characters::TEXT : 0
+        invert = address.anybits?(0x1000) ? 0 : 0xffff
+        line = set | (raster & 0x07) | ((address & @half) >> 1)
+        cell = address & @cell_mask
+        if @wide
+          base = (cell << 1) | ((raster & @ra4) << 10)
+          left = @rows[line | (@cells[base] << 3)]
+          right = @rows[line | (@cells[base | 1] << 3)]
+          ((left << 8) | right) ^ invert
+        else
+          (@rows[line | (@cells[cell] << 3)] ^ invert) & 0xff
+        end
+      end
+
+      # Sets the line's span to the characters painted on it.
+      def end_canvas_line
+        if @on_canvas
+          @canvas.span(@y, @from, @to + (1 << @char_shift))
+          @to_y = @y + 1
+        end
+        @from = @canvas.width
+        @to = -@canvas.width
+      end
+
+      def sweep(from, to)
+        y = from
+        while y < to
+          @canvas.span(y, 0, 0)
+          y += 1
+        end
+      end
+    end
+  end
+end

data/lib/badline/pet/discrete_video.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The 2001's and 3000 series' video, which runs at 60 Hz on every
+    # board: 260 lines of 64 cycles, 16,640 cycles a frame. The first 200
+    # lines show the 25 rows of characters, one character a cycle from
+    # cycle FIRST_COLUMN of each line on, and the vertical drive line goes
+    # low for the other 60, which the editor's IRQ fires on and its screen
+    # writes wait for. xpet's 2001 and 3032 take 16,640 cycles from one
+    # falling edge of the line to the next, and keep it low for 3,840.
+    #
+    # Each character reads its screen code from the 1K of screen RAM, as
+    # it stands before the CPU's access that cycle, and its row from the
+    # character ROM's half that VIA CA2 selects: graphics while CA2 is low,
+    # text while it is high. The picture is the Canvas, DISPLAY_WIDTH by
+    # DISPLAY_HEIGHT dots with the characters from (BORDER_LEFT,
+    # BORDER_TOP) on, as xpet's screenshots frame it.
+    class DiscreteVideo
+      CYCLES_PER_LINE = 64
+      LINES_PER_FRAME = 260
+      DISPLAYED_LINES = 200
+      COLUMNS = 40
+      FIRST_COLUMN = 24
+      DISPLAY_WIDTH = 384
+      DISPLAY_HEIGHT = 217
+      BORDER_LEFT = 32
+      BORDER_TOP = 8
+
+      attr_reader :column, :line, :canvas
+
+      def initialize(cells, characters, via)
+        @cells = cells
+        @rows = characters.rows
+        @via = via
+        @canvas = Canvas.new(DISPLAY_WIDTH, DISPLAY_HEIGHT)
+        @column = 0
+        @line = 0
+        @row_base = 0
+        @row_line = 0
+        @y = BORDER_TOP
+        @shown = true
+      end
+
+      def cycle!
+        column = @column
+        fetch(column - FIRST_COLUMN) if column >= FIRST_COLUMN && @shown
+        if column < CYCLES_PER_LINE - 1
+          @column = column + 1
+        else
+          @column = 0
+          next_line
+        end
+      end
+
+      # The vertical drive line, high while the lines with characters show.
+      def vertical_drive? = @shown
+
+      private
+
+      def fetch(char)
+        set = @via.ca2_output ? Characters::TEXT : 0
+        bits = @rows[set | (@cells[@row_base + char] << 3) | @row_line]
+        @canvas.paint(BORDER_LEFT + (char << 3), @y, bits)
+      end
+
+      def next_line
+        @line += 1
+        @line = 0 if @line == LINES_PER_FRAME
+        follow_line
+      end
+
+      # Where the line puts the beam: the character row and its ROM row,
+      # the line of the picture, and whether characters show on it.
+      def follow_line
+        @row_line = @line & 0x07
+        @row_base = (@line >> 3) * COLUMNS
+        @y = BORDER_TOP + @line
+        @shown = @line < DISPLAYED_LINES
+      end
+    end
+  end
+end

data/lib/badline/pet/ieee_drive.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "badline/drives/model2031"
+
+module Badline
+  class PET
+    # The PET's true drive: a Drives::Model2031 on the IEEE-488 bus
+    # (IEEEPorts), clocked after the CPU each cycle and reset with it, as
+    # the PET's RES line reaches IFC. The traps on the KERNAL's primitives
+    # (IEEETraps) leave device 8 to the drive while it is device 8.
+    module IEEEDrive
+      # The 2031 on the bus, or nil.
+      attr_reader :drive2031
+
+      # Plugs in a Drives::Model2031, in place of the one there.
+      def attach_drive2031(drive)
+        detach_drive2031
+        drive.host_clock_hz = 1_000_000
+        drive.connect(@ieee.bus)
+        @drive2031 = drive
+        @ieee.lines_written
+        @ieee_trap&.device = trap_device
+        @init_threshold = [@init_threshold, Badline::Drives::Model2031::BOOT_CYCLES].max if @cycles < @init_threshold
+      end
+
+      # Unplugs the 2031, leaving it on a bus of its own.
+      def detach_drive2031
+        drive = @drive2031
+        return unless drive
+
+        drive.connect(Badline::Drives::IEEEBus.new)
+        @drive2031 = nil
+        @ieee_trap&.device = trap_device
+      end
+
+      # The true drive on the bus, or nil.
+      def true_drive = @drive2031
+
+      # Plugs in a 2031 as device 8, in place of the drive there, and
+      # returns it.
+      def plug_true_drive
+        Badline::Drives::Model2031.new.tap { |drive| attach_drive2031(drive) }
+      end
+
+      private
+
+      # The 2031 as keyed snapshot modules named from its device number:
+      # BL-D8, BL-D8-CPU and so on for device 8.
+      def save_drive_modules(sections)
+        drive = @drive2031
+        drive&.save_modules(sections, "BL-D#{drive.device}")
+        sections
+      end
+
+      # The 2031 a snapshot's modules hold, built afresh unless one is on
+      # the bus as the same device, or none when they hold no drive. The
+      # bus then carries the PET's lines as its chips left them.
+      def load_drive_modules(modules)
+        device = 8
+        input = modules.optional("BL-D8")
+        while input.nil? && device < 11
+          device += 1
+          input = modules.optional("BL-D#{device}")
+        end
+        if input
+          detach_drive2031 if @drive2031 && @drive2031.device != device
+          attach_drive2031(Badline::Drives::Model2031.new(device:)) unless @drive2031
+          @drive2031.load_modules(modules, input, "BL-D#{device}")
+        else
+          detach_drive2031
+        end
+        @ieee.lines_written
+      end
+    end
+  end
+end

data/lib/badline/pet/ieee_ports.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The PET's side of the IEEE-488 bus (Drives::IEEEBus), spread over
+    # three chips:
+    #
+    #   PIA 2 port A  DIO1-8 in        PIA 2 port B  DIO1-8 out
+    #   PIA 2 CA2     NDAC out         PIA 2 CB2     DAV out
+    #   PIA 1 PA6     EOI in           PIA 1 CA2     EOI out
+    #   VIA PB0       NDAC in          VIA PB1       NRFD out
+    #   VIA PB6       NRFD in          VIA PB2       ATN out
+    #   VIA PB7       DAV in
+    #
+    # The outputs go through inverting drivers onto the bus, so a 0 on a
+    # data line's port bit pulls the line low, and the inputs read the
+    # lines as they are, a 0 for a low line. It is PIA 2's peripheral, and
+    # answers what PIA 1 and the VIA read of the bus. It pushes the lines
+    # the PET pulls into the bus for the drives on it after every write to
+    # the chips (lines_written).
+    class IEEEPorts
+      attr_reader :bus
+
+      def initialize(bus)
+        @bus = bus
+        @pia1 = @pia2 = @via = nil
+      end
+
+      def connect(pia1, pia2, via)
+        @pia1 = pia1
+        @pia2 = pia2
+        @via = via
+      end
+
+      # The data lines.
+      def read_a(_lines) = ~low_lines & 0xff
+
+      def read_b(_lines) = 0xff
+
+      # PIA 1's PA6 reads EOI.
+      def eoi_input = low_lines.anybits?(Drives::IEEEBus::EOI) ? 0xbf : 0xff
+
+      # The VIA's PB0, PB6 and PB7 read NDAC, NRFD and DAV.
+      def via_inputs
+        low = low_lines
+        value = 0xff
+        value &= 0xfe if low.anybits?(Drives::IEEEBus::NDAC)
+        value &= 0xbf if low.anybits?(Drives::IEEEBus::NRFD)
+        value &= 0x7f if low.anybits?(Drives::IEEEBus::DAV)
+        value
+      end
+
+      # The PET wrote one of its chips: the drives on the bus see the lines
+      # it pulls now.
+      def lines_written
+        bus = @bus
+        bus.host_lines = controller_lines unless bus.drives.empty?
+      end
+
+      private
+
+      def low_lines = @bus.low_lines(controller_lines)
+
+      # The lines the PET pulls low.
+      def controller_lines
+        low = ~@pia2.port_b_output & Drives::IEEEBus::DIO
+        low |= Drives::IEEEBus::EOI unless @pia1.ca2_output
+        low |= Drives::IEEEBus::NDAC unless @pia2.ca2_output
+        low |= Drives::IEEEBus::DAV unless @pia2.cb2_output
+        port_b = @via.port_b_output
+        low |= Drives::IEEEBus::NRFD if port_b.nobits?(0x02)
+        low |= Drives::IEEEBus::ATN if port_b.nobits?(0x04)
+        low
+      end
+    end
+  end
+end

data/lib/badline/pet/ieee_traps.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The disk device 8 serves through the traps on the KERNAL's IEEE-488
+    # primitives (KernalTrap::IEEE), and CHROUT capture. There is no LOAD
+    # or SAVE trap: the ROM's own LOAD and SAVE, and BASIC 4's disk
+    # commands, run through the primitives.
+    module IEEETraps
+      # Puts the storage in device 8. Mounting again swaps the disk while
+      # the machine runs, and the drive keeps its RAM and its status. The
+      # traps leave device 8 to a true drive with that number.
+      def mount(storage)
+        return @dos.insert(storage) if @dos
+
+        @dos = dos = KernalTrap::DOS.new(storage, channel_saves: true)
+        @ieee_trap = KernalTrap::IEEE.new(cpu:, bus:, layout: trap_layout, dos:).install
+        @ieee_trap.device = trap_device
+        @ieee_trap
+      end
+
+      # Takes device 8's storage out, and the traps with it, so the KERNAL
+      # finds no device 8 on the bus.
+      def unmount
+        trap = @ieee_trap
+        return unless trap
+
+        trap.uninstall
+        @ieee_trap = nil
+        @dos = nil
+      end
+
+      # Whether device 8 serves a disk or directory through the traps.
+      def mounted? = !@dos.nil?
+
+      # The path of the disk or directory device 8 serves, or an empty one.
+      def mounted_path = @dos.nil? ? "" : @dos.path
+
+      # Device 8 through the traps in a keyed snapshot module (BL-TRAPDOS):
+      # the storage under storage.*, the DOS, and the IEEE-488 trap under
+      # ieee.*. Nothing mounted writes nothing.
+      def save_trap_dos_fields(out)
+        dos = @dos
+        return unless dos
+
+        Snapshot::StorageSetup.write_fields(dos.storage, out)
+        dos.save_fields(out)
+        @ieee_trap&.save_fields(out, "ieee.")
+      end
+
+      # `detached` mounts a disk image write-protected and no directory.
+      def load_trap_dos_fields(input, detached: false)
+        unmount
+        return if input.missing?
+
+        mount(Snapshot::StorageSetup.read_fields(input, detached:))
+        @dos&.load_fields(input)
+        @ieee_trap&.load_fields(input, "ieee.")
+      end
+
+      # Records what the KERNAL prints through CHROUT (KernalTrap::Chrout).
+      def capture_output
+        @capture_output ||= KernalTrap::Chrout.new(cpu:, bus:, layout: trap_layout).tap do |trap|
+          cpu.install_trap(KernalTrap::Chrout::ADDRESS) { trap.call }
+        end
+      end
+
+      private
+
+      # The IEEELayout of the KERNAL the model runs.
+      def trap_layout = @model.trap_layout
+
+      # Device 8, unless a true drive is device 8.
+      def trap_device
+        device = KernalTrap::Routine::DEVICE
+        true_drive&.device == device ? nil : device
+      end
+    end
+  end
+end

data/lib/badline/pet/keyboard_ports.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # What PIA 1's port B reads from outside the chip: the key matrix's
+    # columns, for the row PA0-PA3 select through a 4-to-10 decoder. The
+    # editor writes a row number to $E810 and reads the row's keys from
+    # $E812, a 0 for each key down. A row number past 9 selects no row.
+    #
+    # The graphics keyboard (N) and the business keyboard (B) are wired
+    # differently, and the editor ROM scans the one its model has. Each
+    # matrix lists its rows in port B bit order, :none where no key sits,
+    # as the editors' key tables place them. The graphics keyboard's
+    # digits are on its keypad; the business keyboard has a row of them
+    # and a keypad (kp0 to kp9 and kp_period).
+    class KeyboardPorts
+      GRAPHICS_MATRIX = [
+        %i[! # % & ( left clr_home cursor_h],
+        [:'"', :"$", :"'", :"\\", :")", :none, :cursor_v, :delete],
+        %i[q e t u o up 7 9],
+        %i[w r y i p none 8 /],
+        %i[a d g j l none 4 6],
+        %i[s f h k : none 5 *],
+        %i[z c b m ; return 1 3],
+        %i[x v n , ? none 2 +],
+        [:lshift, :"@", :"]", :none, :>, :rshift, :"0", :-],
+        [:rvs, :"[", :space, :<, :run_stop, :none, :".", :"="]
+      ].freeze
+
+      BUSINESS_MATRIX = [
+        %i[2 5 8 - kp8 cursor_h none none],
+        %i[1 4 7 0 kp7 up none kp9],
+        [:escape, :s, :f, :h, :"]", :k, :";", :kp5],
+        %i[a d g j return l @ kp6],
+        %i[tab w r y \\ i p delete],
+        [:q, :e, :t, :u, :cursor_v, :o, :"[", :kp4],
+        %i[lshift c b . kp_period none rshift kp3],
+        %i[z v n , kp0 none repeat kp2],
+        %i[rvs x space m clr_home none / kp1],
+        %i[left 3 6 9 run_stop : none none]
+      ].freeze
+
+      attr_reader :keyboard
+
+      def initialize(keyboard)
+        @keyboard = keyboard
+        @pia = nil
+        @ieee = nil
+        @cassettes = nil
+      end
+
+      # The PIA these ports hang off, whose port A selects the row, the
+      # PET's IEEEPorts, which answer PA6, and its Cassettes, which answer
+      # PA4 and PA5.
+      def connect(pia, ieee, cassettes)
+        @pia = pia
+        @ieee = ieee
+        @cassettes = cassettes
+      end
+
+      # Port A's other lines: PA4 and PA5 read the cassette sense switches,
+      # PA6 the IEEE bus's EOI, and the diagnostic sense on PA7 floats high
+      # with nothing on it.
+      def read_a(_lines) = @ieee.eoi_input & @cassettes.sense_input
+
+      def read_b(lines)
+        row = @pia.port_a_output & 0x0f
+        return lines if row > 9
+
+        @keyboard.scan(0x3ff & ~(1 << row), lines).last
+      end
+    end
+  end
+end