badline 0.15.1 → 0.16.0

data/lib/badline/pet/canvas.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The picture a front end shows, a palette index a dot: 0 for black and
+    # 1 for the lit phosphor. The video paints it eight dots at a time, one
+    # character ROM row, and leaves alone the dots that would not change:
+    # each four dots remember the row last painted from them, and a
+    # painting that overlaps theirs from elsewhere makes them forget it.
+    #
+    # Each line keeps the span its last painting covered. When a line's
+    # span changes, the dots it covered before and doesn't now go black.
+    class Canvas
+      # Black and the green of a P1 phosphor, as the VICE testbench's
+      # references draw them.
+      PALETTE = [0x000000, 0x41ff00].freeze
+
+      # The eight dots of each ROM row, the leftmost in bit 7.
+      DOTS = Array.new(256) { |bits| Array.new(8) { |dot| (bits >> (7 - dot)) & 1 } }.freeze
+
+      attr_reader :display, :width, :height, :dirty_lines
+
+      # Nothing paints within +margin+ dots of either side.
+      def initialize(width, height, margin: 0)
+        @first = margin
+        @last = width - 8 - margin
+        @width = width
+        @height = height
+        @display = Array.new(width * height, 0)
+        @dirty_lines = Array.new(height, true)
+        @slot_width = width >> 2
+        @painted = Array.new(@slot_width * height, 0)
+        @span_from = Array.new(height, 0)
+        @span_to = Array.new(height, 0)
+      end
+
+      def palette = PALETTE
+
+      def clear_dirty_lines!
+        @dirty_lines.fill(false)
+      end
+
+      # Paints `bits` on `line` from dot `column` on, if they fit.
+      def paint(column, line, bits)
+        return if column < @first || column > @last
+
+        slot = (line * @slot_width) + (column >> 2)
+        return if @painted[slot] == bits
+
+        @painted[slot] = bits
+        @painted[slot - 1] = -1 if slot.positive?
+        @painted[slot + 1] = -1 if slot + 1 < @painted.length
+        @display[(line * @width) + column, 8] = DOTS[bits]
+        @dirty_lines[line] = true
+      end
+
+      # Sets `line`'s span to the dots from `from` up to `to`, none if `to`
+      # isn't past `from`, and blacks out what its last one covered beyond
+      # it.
+      def span(line, from, to)
+        width = @width
+        from = 0 if from.negative?
+        to = width if to > width
+        from = to = 0 if to <= from
+        old_from = @span_from[line]
+        old_to = @span_to[line]
+        return if from == old_from && to == old_to
+
+        blank(line, old_from, [from, old_to].min) if old_from < from
+        blank(line, [to, old_from].max, old_to) if old_to > to
+        @span_from[line] = from
+        @span_to[line] = to
+      end
+
+      # Blacks out every dot, as at power on.
+      def clear!
+        @display.fill(0)
+        @painted.fill(0)
+        @span_from.fill(0)
+        @span_to.fill(0)
+        @dirty_lines.fill(true)
+      end
+
+      private
+
+      def blank(line, from, to)
+        return if to <= from
+
+        @display.fill(0, (line * @width) + from, to - from)
+        first = (line * @slot_width) + (from >> 2)
+        @painted.fill(0, first, ((to + 3) >> 2) - (from >> 2))
+        @painted[first - 1] = -1 if from >= 4
+        @dirty_lines[line] = true
+      end
+    end
+  end
+end

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,26 @@
+# 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.
+    class Characters
+      TEXT = 0x800
+
+      attr_reader :rows
+
+      def initialize(file)
+        rom = ROM.read(file)
+        @rows = Array.new(0x1000) 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
+    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,142 @@
+# 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 high blanks the line.
+    #
+    # 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:)
+        @cells = []
+        @rows = characters.rows
+        @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?(0x08) ? 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)
+        cell = address & 0x3ff
+        if @wide
+          left = @rows[line | (@cells[cell << 1] << 3)]
+          right = @rows[line | (@cells[(cell << 1) | 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_ports.rb

@@ -0,0 +1,66 @@
+# 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.
+    class IEEEPorts
+      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
+
+      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,75 @@
+# 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.
+      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
+      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
+
+      # The true drive on the bus, which a PET has none of yet: every disk
+      # goes in device 8 through the traps.
+      def true_drive = nil
+
+      # 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
+    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