badline 0.15.0 → 0.16.0

data/lib/badline/pet.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "badline/pet/rom_sets"
+require "badline/pet/model"
+require "badline/pet/cpu"
+require "badline/pet/via"
+require "badline/pet/via_ports"
+require "badline/pet/keyboard_ports"
+require "badline/pet/ieee_ports"
+require "badline/pet/ieee_traps"
+require "badline/pet/cassettes"
+require "badline/pet/characters"
+require "badline/pet/canvas"
+require "badline/pet/discrete_video"
+require "badline/pet/crtc_video"
+require "badline/pet/bus"
+require "badline/pet/sound"
+require "badline/snapshot/pet_setup"
+require "badline/pet/keyed_parts"
+require "badline/pet/keyed_state"
+require "badline/pet/keyed_modules"
+
+module Badline
+  # The Commodore PET and CBM: a 6502 at 1 MHz, two 6520 PIAs at $E810 and
+  # $E820, a 6522 VIA at $E840 and, from the 4032 on, a 6545 CRTC at
+  # $E880. Every chip's IRQ is wired to the CPU's, and nothing pulls NMI.
+  # Nothing halts the CPU either: the video reads the screen RAM between
+  # its accesses.
+  #
+  # The video's vertical drive line, low in the retrace, reaches PIA 1's
+  # CB1, whose falling edge is the editor's 50 or 60 Hz interrupt, and the
+  # VIA's PB5. The discrete boards count it out themselves
+  # (DiscreteVideo), and the CRTC boards take it from the CRTC's vertical
+  # sync, inverted.
+  #
+  # The key matrix hangs off PIA 1 (KeyboardPorts), the graphics one or
+  # the business one as the model has, and type_text types through the
+  # editor's keyboard buffer.
+  #
+  # The discrete boards paint their picture (DiscreteVideo) on a Canvas.
+  # The CRTC boards paint theirs from the CRTC's outputs (CRTCVideo).
+  # The VIA's CB2 is the sound (Sound).
+  #
+  # Device 8 answers through traps on the KERNAL's IEEE-488 primitives
+  # (IEEETraps), on a bus nothing else is plugged into (IEEEPorts), and
+  # each cassette port has a datasette (Cassettes). It runs headless.
+  class PET
+    include Machine::KeyboardBuffer
+    include Machine::Clocking
+    include Machine::Settling
+    include IEEETraps
+
+    attr_reader :model, :bus, :cpu, :pia1, :pia2, :via, :crtc, :keyboard, :ieee, :cassettes, :cycles, :init_threshold
+
+    # The editor's frame rate: 50 or 60 on a CRTC board, 60 on the others.
+    attr_reader :refresh_hz
+
+    # The RAM below $8000, in K.
+    attr_reader :ram_kb
+
+    def ram = @bus.ram
+
+    # Reads and writes memory as the CPU sees it, through the bus.
+    def peek(addr) = @bus.peek(addr)
+
+    def poke(addr, value) = @bus.poke(addr, value)
+
+    def install_debug_register(&) = @bus.install_debug_register(&)
+
+    def family = :pet
+
+    # The datasette on cassette port #1, where a tape goes in (Cassettes).
+    def datasette = @cassettes.datasette1
+
+    # +model+ names one of Model::ALL, with +ram_kb+ of RAM below $8000
+    # (Model::RAM_SIZES) in place of the model's own when not nil. A CRTC
+    # model runs its 50 Hz editor, or its 60 Hz one for +refresh_hz+ 60.
+    # +basic+ and +editor+ name ROMs the board takes in place of its own
+    # (Model.upgraded).
+    def initialize(model: Model::DEFAULT, ram_kb: nil, refresh_hz: 50, debug: false, basic: nil, editor: nil)
+      @model = Model.upgraded(Model.named(model), basic, editor)
+      ram_kb ||= @model.ram_kb
+      raise ArgumentError, "a PET has no #{ram_kb}K RAM board" unless Model::RAM_SIZES.include?(ram_kb)
+
+      @ram_kb = ram_kb
+
+      @refresh_hz = @model.crtc? ? refresh_hz : 60
+      @crtc_video = @model.crtc?
+      @vertical_drive = true
+      matrix = @model.keyboard == :business ? KeyboardPorts::BUSINESS_MATRIX : KeyboardPorts::GRAPHICS_MATRIX
+      @keyboard = Input::Keyboard.new(matrix:)
+      keyboard_ports = KeyboardPorts.new(@keyboard)
+      registers = Array.new(Chips::CRTC::MASKS.length, 0)
+      @pia1 = Chips::PIA.new(peripheral: keyboard_ports)
+      @ieee = IEEEPorts.new(Drives::IEEEBus.new)
+      @pia2 = Chips::PIA.new(peripheral: @ieee)
+      @via = VIA.new(start: 0xe800, peripheral: VIAPorts.new(self))
+      @sound = Sound.new(@via)
+      @cassettes = Cassettes.new(@pia1, @via)
+      keyboard_ports.connect(@pia1, @ieee, @cassettes)
+      characters = Characters.new(@model.characters)
+      @crtc_output = CRTCVideo.new(characters, @via, registers, columns80: @model.video == :crtc80)
+      @crtc = Chips::CRTC.new(@crtc_output, registers:)
+      @ieee.connect(@pia1, @pia2, @via)
+      @bus = Bus.new(model: @model, ram_kb:, editor: @model.editor(@refresh_hz), pia1: @pia1, pia2: @pia2,
+                     via: @via, crtc: @crtc)
+      @crtc_output.cells = @bus.screen.cells
+      @discrete = DiscreteVideo.new(@bus.screen.cells, characters, @via)
+      @canvas = @crtc_video ? @crtc_output.canvas : @discrete.canvas
+      cassettes = @cassettes
+      @bus.on_io_write { cassettes.lines_written }
+      @cpu = CPU.new(@bus, debug:)
+      @cycles = 0
+      @init_handlers = []
+      @pending_keys = nil
+      @dos = nil
+      @ieee_trap = nil
+      @capture_output = nil
+      @init_threshold = boot_cycles(ram_kb)
+    end
+
+    # The vertical drive line, high but in the retrace.
+    def vertical_drive? = @vertical_drive
+
+    # The model, its RAM and its editor's frame rate as the pause menu
+    # names them, such as "8032, 32K RAM, 50 HZ".
+    def model_label = "#{@model.name.upcase}, #{@ram_kb}K RAM, #{@refresh_hz} HZ"
+
+    # The Canvas a front end shows.
+    def video = @canvas
+
+    # The 1 MHz clock and the frame the editor sets up, and all of the
+    # Canvas. The CRTC editors' lines and frames are their ROM's
+    # (ROMSets.crtc_frame), which a program can change. 80 columns show
+    # two dots to a window pixel.
+    def timing
+      crop = [0, 0, @canvas.width, @canvas.height]
+      if @crtc_video
+        cycles_per_line, lines_per_frame = ROMSets.crtc_frame(@model.editor(@refresh_hz), @refresh_hz)
+        Timing.new(clock_hz: 1_000_000, cycles_per_line:, lines_per_frame:,
+                   crop:, pixel_width: 1, dots: @model.video == :crtc80 ? 2 : 1)
+      else
+        Timing.new(clock_hz: 1_000_000, cycles_per_line: DiscreteVideo::CYCLES_PER_LINE,
+                   lines_per_frame: DiscreteVideo::LINES_PER_FRAME, crop:, pixel_width: 1, dots: 1)
+      end
+    end
+
+    # The video counts and moves the vertical drive line, then the PIAs
+    # and the VIA clock, ahead of the CPU.
+    def cycle!
+      handle_init if @cycles == @init_threshold
+      feed_keyboard if @pending_keys
+
+      if @crtc_video
+        @crtc.cycle!
+        drive_retrace(!@crtc.vsync?)
+      else
+        @discrete.cycle!
+        drive_retrace(@discrete.vertical_drive?)
+      end
+      @pia1.cycle!
+      @pia2.cycle!
+      @via.cycle!
+      @sound.cycle! if @sound.recording?
+      @cassettes.cycle!
+      @cpu.irq = @pia1.irq? || @pia2.irq? || @via.irq?
+      @cpu.cycle!
+
+      @cycles += 1
+    end
+
+    # What a front end plays: the VIA's CB2 (Sound), which answers #record
+    # and #drain_samples.
+    def sound_source = @sound
+
+    # The RES line reaches the CPU, the PIAs, the VIA, the CRTC and the
+    # 8096's control register.
+    def reset!
+      @pia1.reset!
+      @pia2.reset!
+      @via.reset!
+      @crtc.reset!
+      @bus.reset!
+      @cpu.reset!
+    end
+
+    # Switches the machine off and on: RAM starts cleared, and the RES
+    # line resets everything else.
+    def power_cycle!
+      @bus.power_on!
+      reset!
+    end
+
+    # Puts a program file's bytes where its first two say, through the bus,
+    # and returns that address.
+    def load_prg(data)
+      load_addr = data[0] | (data[1] << 8)
+      bytes = data[2..] || []
+      bytes = bytes[0, 0x10000 - load_addr] if load_addr + bytes.length > 0x10000
+      bytes.each_with_index { |byte, i| @bus.poke(load_addr + i, byte) }
+      load_addr
+    end
+
+    # Where the editor keeps its keyboard buffer: in page 2 under BASIC 1,
+    # in the zero page and page 2 under BASIC 2 and 4.
+    def keyboard_buffer
+      @model.basic1? ? Machine::KeyboardBuffer::PET_BASIC1_LAYOUT : Machine::KeyboardBuffer::PET_LAYOUT
+    end
+
+    private
+
+    # The cycle by which the KERNAL has booted and BASIC printed READY,
+    # with a margin. The RAM test takes most of it, about 41,000 to
+    # 44,000 cycles a K, and the CRTC editors take another 600,000 or so
+    # before it: READY is up by about 440,000 on a 2001 with 8K, 1,450,000
+    # on a 3032 and 1,980,000 on an 8032.
+    def boot_cycles(ram_kb) = (@model.basic == "pet/basic4.rom" ? 700_000 : 150_000) + (46_000 * ram_kb)
+
+    def drive_retrace(high)
+      return if high == @vertical_drive
+
+      @vertical_drive = high
+      @pia1.cb1 = high
+    end
+  end
+end

data/lib/badline/plus4/acia/frames.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Badline
+  class Plus4
+    class ACIA
+      # A character's frame and how long it takes. A start bit, 5 to 8
+      # data bits, a parity bit where the command enables one, and the stop
+      # bits: one, or with control bit 7 two, but one and a half for 5 bits
+      # without parity and one for 8 bits with it (6551 datasheet). Each bit
+      # takes 16 periods of the baud rate generator's 16x clock, the 1.8432
+      # MHz crystal divided by the rate's divisor, which the machine's
+      # cycles are counted against, carrying what is left of a cycle from
+      # one character to the next.
+      module Frames
+        CRYSTAL_HZ = 1_843_200
+
+        # The crystal's divisor for each baud rate the control register
+        # selects: the external clock, then 50, 75, 109.92, 134.58, 150,
+        # 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600 and 19,200.
+        DIVISORS = [1, 2304, 1536, 1048, 856, 768, 384, 192, 96, 64, 48, 32, 24, 16, 12, 6].freeze
+
+        def word_length = 8 - ((@control >> 5) & 0x03)
+
+        def word_mask = (1 << word_length) - 1
+
+        # The frame's length in half bits.
+        def frame_halves
+          length = word_length
+          parity = @command.anybits?(0x20)
+          stops = if @control < 0x80 || (length == 8 && parity) then 2
+                  elsif length == 5 && !parity then 3
+                  else 4
+                  end
+          ((1 + length + (parity ? 1 : 0)) * 2) + stops
+        end
+
+        private
+
+        # The cycle a character the transmitter, or else the receiver,
+        # starts at `time` ends at.
+        def after(time, transmitter)
+          units = frame_halves * 8 * DIVISORS[@control & 0x0f] * @clock_hz
+          if transmitter
+            units += @transmit_remainder
+            @transmit_remainder = units % CRYSTAL_HZ
+          else
+            units += @receive_remainder
+            @receive_remainder = units % CRYSTAL_HZ
+          end
+          time + (units / CRYSTAL_HZ)
+        end
+      end
+    end
+  end
+end

data/lib/badline/plus4/acia.rb

@@ -1,44 +1,304 @@
 # 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,
-    # as a stub with nothing on the line: it never receives, its
-    # transmitter is always empty, and it never interrupts. The command and
-    # control registers keep what is written to them, and a write to the
-    # status register, a programmed reset, clears the command register's
-    # low five bits.
+    # 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
-      STATUS = 0x10
+      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
 
-      attr_reader :command, :control
+      # Far enough ahead that it never comes.
+      NEVER = 1 << 60
 
-      def initialize
+      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
 
-      def irq? = false
+      # 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 1 then STATUS
+        when 0
+          @receiver_full = false
+          @receive_data
+        when 1 then read_status
         when 2 then @command
-        when 3 then @control
-        else 0
+        else @control
         end
       end
 
       def poke(addr, value)
         case addr & 0x03
-        when 1 then @command &= 0xe0
-        when 2 then @command = value
-        when 3 then @control = value
+        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
     end
   end