ac6502 1.2.0 → 1.4.0

package/src/components/Machine.ts

@@ -2,21 +2,21 @@ import { CPU } from './CPU'
 import { RAM } from './RAM'
 import { ROM } from './ROM'
 import { Cart } from './Cart'
-import { GPIOCard } from './IO/GPIOCard'
-import { RAMCard } from './IO/RAMCard'
-import { RTCCard } from './IO/RTCCard'
-import { SerialCard } from './IO/SerialCard'
-import { SoundCard } from './IO/SoundCard'
-import { StorageCard } from './IO/StorageCard'
-import { VideoCard } from './IO/VideoCard'
-import { GPIOKeyboardMatrixAttachment } from './IO/GPIOAttachments/GPIOKeyboardMatrixAttachment'
-import { GPIOKeyboardEncoderAttachment } from './IO/GPIOAttachments/GPIOKeyboardEncoderAttachment'
-import { GPIOJoystickAttachment } from './IO/GPIOAttachments/GPIOJoystickAttachment'
-import { GPIOLCDAttachment } from './IO/GPIOAttachments/GPIOLCDAttachment'
-import { GPIOKeypadAttachment } from './IO/GPIOAttachments/GPIOKeypadAttachment'
-import { EmptyCard } from './IO/EmptyCard'
+import { VIA } from './IO/VIA'
+import { RAMBank } from './IO/RAMBank'
+import { RTC } from './IO/RTC'
+import { ACIA } from './IO/ACIA'
+import { Sound } from './IO/Sound'
+import { Storage } from './IO/Storage'
+import { Video } from './IO/Video'
+import { KeyboardMatrixAttachment } from './IO/Attachments/KeyboardMatrixAttachment'
+import { KeyboardEncoderAttachment } from './IO/Attachments/KeyboardEncoderAttachment'
+import { JoystickAttachment } from './IO/Attachments/JoystickAttachment'
+import { LCDAttachment } from './IO/Attachments/LCDAttachment'
+import { KeypadAttachment } from './IO/Attachments/KeypadAttachment'
+import { Empty } from './IO/Empty'
+import { Terminal } from './IO/Terminal'
 import { IO } from './IO'
-import { readFile } from 'fs/promises'
 
 export class Machine {
 
@@ -25,184 +25,304 @@ export class Machine {
 
   private ioCycleAccumulator: number = 0
   private ioTickInterval: number = 128 // adjust (64/128/256)
+  private loopHandle?: ReturnType<typeof setImmediate> | ReturnType<typeof setTimeout>
 
   cpu: CPU
   ram: RAM
   rom: ROM
+  cart?: Cart
+
   io1: IO
   io2: IO
   io3: IO
   io4: IO
-  io5: SerialCard
+  io5: IO
   io6: IO
   io7: IO
   io8: IO
 
-  cart?: Cart
-  kim: boolean
-
-  // GPIO Attachments
-  keyboardMatrixAttachment: GPIOKeyboardMatrixAttachment
-  keyboardEncoderAttachment: GPIOKeyboardEncoderAttachment
-  joystickAttachmentA: GPIOJoystickAttachment
-  joystickAttachmentB: GPIOJoystickAttachment
+  // VIA Attachments
+  keyboardMatrixAttachment?: KeyboardMatrixAttachment
+  keyboardEncoderAttachment?: KeyboardEncoderAttachment
+  joystickAttachmentA?: JoystickAttachment
+  joystickAttachmentB?: JoystickAttachment
 
   // KIM mode attachments
-  lcdAttachment?: GPIOLCDAttachment
-  keypadAttachment?: GPIOKeypadAttachment
+  lcdAttachment?: LCDAttachment
+  keypadAttachment?: KeypadAttachment
 
-  isAlive: boolean = false
+  target: string
   isRunning: boolean = false
   frequency: number = 2000000 // 2 MHz
   scale: number = 2
   frames: number = 0
-  frameDelay: number = 0
-  frameDelayCount: number = 0
   startTime: number = Date.now()
   previousTime: number = performance.now()
 
   transmit?: (data: number) => void
   render?: () => void
-  pushAudioSamples?: (samples: Float32Array) => void
+  play?: (samples: Float32Array) => void
 
   //
   // Initialization
   //
 
-  constructor(kim: boolean = false) {
-    this.kim = kim
+  constructor(target: string) {
+    this.target = target
     this.cpu = new CPU(this.read.bind(this), this.write.bind(this))
     this.ram = new RAM()
     this.rom = new ROM()
 
-    this.io5 = new SerialCard()
+    this.io1 = new Empty()
+    this.io2 = new Empty()
+    this.io3 = new Empty()
+    this.io4 = new Empty()
+    this.io5 = new Empty()
+    this.io6 = new Empty()
+    this.io7 = new Empty()
+    this.io8 = new Empty()
 
-    // Connect SerialCard IRQ/NMI to CPU
-    this.io5.raiseIRQ = () => this.cpu.irq()
-    this.io5.raiseNMI = () => this.cpu.nmi()
+    this.configureTarget(target)
+    
+    this.startTime = Date.now()
+    this.cpu.reset()
+  }
 
-    // Connect SerialCard transmit callback
-    this.io5.transmit = (data: number) => {
-      if (this.transmit) {
-        this.transmit(data)
-      }
-    }
+  configureTarget(target: string): void {
+    if (target === 'kim') {
+      const acia = new ACIA()
+      this.io5 = acia
 
-    // Always create standard GPIO attachments (for type stability)
-    this.keyboardMatrixAttachment = new GPIOKeyboardMatrixAttachment(10)
-    this.keyboardEncoderAttachment = new GPIOKeyboardEncoderAttachment(20)
-    this.joystickAttachmentA = new GPIOJoystickAttachment(false, 100)
-    this.joystickAttachmentB = new GPIOJoystickAttachment(false, 100)
+      // Connect ACIA IRQ/NMI to CPU
+      acia.raiseIRQ = () => this.cpu.irq()
+      acia.raiseNMI = () => this.cpu.nmi()
 
-    if (kim) {
-      this.io1 = new EmptyCard()
-      this.io2 = new EmptyCard()
-      this.io3 = new EmptyCard()
-      this.io4 = new EmptyCard()
-      this.io6 = new EmptyCard()
-      this.io7 = new EmptyCard()
+      // Connect ACIA transmit callback
+      acia.transmit = (data: number) => {
+        if (this.transmit) {
+          this.transmit(data)
+        }
+      }
+
+      this.io1 = new Empty()
+      this.io2 = new Empty()
+      this.io3 = new Empty()
+      this.io4 = new Empty()
+      this.io6 = new Empty()
+      this.io7 = new Empty()
 
-      const gpioCard = new GPIOCard()
-      this.io8 = gpioCard
+      const via = new VIA()
+      this.io8 = via
 
-      // Connect GPIOCard IRQ/NMI to CPU
-      gpioCard.raiseIRQ = () => this.cpu.irq()
-      gpioCard.raiseNMI = () => this.cpu.nmi()
+      // Connect VIA IRQ/NMI to CPU
+      via.raiseIRQ = () => this.cpu.irq()
+      via.raiseNMI = () => this.cpu.nmi()
 
       // Create KIM GPIO Attachments
-      this.lcdAttachment = new GPIOLCDAttachment(16, 2, 10)
-      this.keypadAttachment = new GPIOKeypadAttachment(true, 20)
+      this.lcdAttachment = new LCDAttachment(16, 2, 10)
+      this.keypadAttachment = new KeypadAttachment(true, 20)
 
       // Attach LCD to Port A (control: RS/RW/E on bits 5-7) and Port B (data bus)
-      gpioCard.attachToPortA(this.lcdAttachment)
-      gpioCard.attachToPortB(this.lcdAttachment)
+      via.attachToPortA(this.lcdAttachment)
+      via.attachToPortB(this.lcdAttachment)
 
       // Attach keypad to Port A (bits 0-4)
-      gpioCard.attachToPortA(this.keypadAttachment)
-    } else {
-      const rtcCard = new RTCCard()
-      const storageCard = new StorageCard()
-      const gpioCard = new GPIOCard()
-      const soundCard = new SoundCard()
-      const videoCard = new VideoCard()
-
-      this.io1 = new RAMCard()
-      this.io2 = new RAMCard()
-      this.io3 = rtcCard
-      this.io4 = storageCard
-      this.io6 = gpioCard
-      this.io7 = soundCard
-      this.io8 = videoCard
-
-      // Connect RTCCard IRQ/NMI to CPU
-      rtcCard.raiseIRQ = () => this.cpu.irq()
-      rtcCard.raiseNMI = () => this.cpu.nmi()
-
-      // Connect VideoCard IRQ/NMI to CPU
-      videoCard.raiseIRQ = () => this.cpu.irq()
-      videoCard.raiseNMI = () => this.cpu.nmi()
-
-      // Connect SoundCard pushSamples callback
-      soundCard.pushSamples = (samples: Float32Array) => {
-        if (this.pushAudioSamples) {
-          this.pushAudioSamples(samples)
+      via.attachToPortA(this.keypadAttachment)
+    } else if (target === 'dev') {
+      const acia = new ACIA()
+      this.io5 = acia
+
+      // Connect ACIA IRQ/NMI to CPU
+      acia.raiseIRQ = () => this.cpu.irq()
+      acia.raiseNMI = () => this.cpu.nmi()
+
+      // Connect ACIA transmit callback
+      acia.transmit = (data: number) => {
+        if (this.transmit) {
+          this.transmit(data)
         }
       }
 
+      const rtc = new RTC()
+      const storage = new Storage()
+      const via = new VIA()
+
+      this.io1 = new RAMBank()
+      this.io2 = new RAMBank()
+      this.io3 = rtc
+      this.io4 = storage
+      this.io6 = via
+      this.io7 = new Empty()
+      this.io8 = new Terminal()
+
+      // Connect RTC IRQ/NMI to CPU
+      rtc.raiseIRQ = () => this.cpu.irq()
+      rtc.raiseNMI = () => this.cpu.nmi()
+
+      // Create standard GPIO attachments
+      this.keyboardMatrixAttachment = new KeyboardMatrixAttachment(10)
+      this.keyboardEncoderAttachment = new KeyboardEncoderAttachment(20)
+      this.joystickAttachmentA = new JoystickAttachment(false, 100)
+      this.joystickAttachmentB = new JoystickAttachment(false, 100)
+
       // Attach peripherals to GPIO Card
-      gpioCard.attachToPortA(this.keyboardMatrixAttachment)
-      gpioCard.attachToPortB(this.keyboardMatrixAttachment)
-      gpioCard.attachToPortA(this.keyboardEncoderAttachment)
-      gpioCard.attachToPortB(this.keyboardEncoderAttachment)
-      gpioCard.attachToPortA(this.joystickAttachmentA)
-      gpioCard.attachToPortB(this.joystickAttachmentB)
-    }
+      via.attachToPortA(this.keyboardMatrixAttachment)
+      via.attachToPortB(this.keyboardMatrixAttachment)
+      via.attachToPortA(this.keyboardEncoderAttachment)
+      via.attachToPortB(this.keyboardEncoderAttachment)
+      via.attachToPortA(this.joystickAttachmentA)
+      via.attachToPortB(this.joystickAttachmentB)
+    } else if (target === 'vcs') {
+      this.io5 = new Empty()
+
+      const via = new VIA()
+      const sound = new Sound()
+      const video = new Video()
+
+      this.io1 = new Empty()
+      this.io2 = new Empty()
+      this.io3 = new Empty()
+      this.io4 = new Empty()
+      this.io6 = via
+      this.io7 = sound
+      this.io8 = video
+
+      // Connect Video IRQ/NMI to CPU
+      video.raiseIRQ = () => this.cpu.irq()
+      video.raiseNMI = () => this.cpu.nmi()
+
+      // Connect Sound pushSamples callback
+      sound.pushSamples = (samples: Float32Array) => {
+        if (this.play) {
+          this.play(samples)
+        }
+      }
 
-    this.cpu.reset()
+      // Create standard GPIO attachments
+      this.keyboardMatrixAttachment = new KeyboardMatrixAttachment(10)
+      this.keyboardEncoderAttachment = new KeyboardEncoderAttachment(20)
+      this.joystickAttachmentA = new JoystickAttachment(false, 100)
+      this.joystickAttachmentB = new JoystickAttachment(false, 100)
+
+      // Attach peripherals to GPIO Card
+      via.attachToPortA(this.keyboardMatrixAttachment)
+      via.attachToPortB(this.keyboardMatrixAttachment)
+      via.attachToPortA(this.keyboardEncoderAttachment)
+      via.attachToPortB(this.keyboardEncoderAttachment)
+      via.attachToPortA(this.joystickAttachmentA)
+      via.attachToPortB(this.joystickAttachmentB)
+    } else if (target === 'cob') {
+      const acia = new ACIA()
+      this.io5 = acia
+
+      // Connect ACIA IRQ/NMI to CPU
+      acia.raiseIRQ = () => this.cpu.irq()
+      acia.raiseNMI = () => this.cpu.nmi()
+
+      // Connect ACIA transmit callback
+      acia.transmit = (data: number) => {
+        if (this.transmit) {
+          this.transmit(data)
+        }
+      }
+
+      const rtc = new RTC()
+      const storage = new Storage()
+      const gpio = new VIA()
+      const sound = new Sound()
+      const video = new Video()
+
+      this.io1 = new RAMBank()
+      this.io2 = new RAMBank()
+      this.io3 = rtc
+      this.io4 = storage
+      this.io6 = gpio
+      this.io7 = sound
+      this.io8 = video
+
+      // Connect RTC IRQ/NMI to CPU
+      rtc.raiseIRQ = () => this.cpu.irq()
+      rtc.raiseNMI = () => this.cpu.nmi()
+
+      // Connect Video IRQ/NMI to CPU
+      video.raiseIRQ = () => this.cpu.irq()
+      video.raiseNMI = () => this.cpu.nmi()
+
+      // Connect Sound pushSamples callback
+      sound.pushSamples = (samples: Float32Array) => {
+        if (this.play) {
+          this.play(samples)
+        }
+      }
+
+      // Create standard GPIO attachments
+      this.keyboardMatrixAttachment = new KeyboardMatrixAttachment(10)
+      this.keyboardEncoderAttachment = new KeyboardEncoderAttachment(20)
+      this.joystickAttachmentA = new JoystickAttachment(false, 100)
+      this.joystickAttachmentB = new JoystickAttachment(false, 100)
+
+      // Attach peripherals to GPIO Card
+      gpio.attachToPortA(this.keyboardMatrixAttachment)
+      gpio.attachToPortB(this.keyboardMatrixAttachment)
+      gpio.attachToPortA(this.keyboardEncoderAttachment)
+      gpio.attachToPortB(this.keyboardEncoderAttachment)
+      gpio.attachToPortA(this.joystickAttachmentA)
+      gpio.attachToPortB(this.joystickAttachmentB)
+    } else {
+      this.io1 = new Empty()
+      this.io2 = new Empty()
+      this.io3 = new Empty()
+      this.io4 = new Empty()
+      this.io5 = new Empty()
+      this.io6 = new Empty()
+      this.io7 = new Empty()
+      this.io8 = new Empty()
+    }
   }
 
   //
   // Methods
   //
 
-  loadROM = async (path: string) => {
-    try {
-      this.rom.load(Array.from(new Uint8Array(await readFile(path))))
-    } catch (error) {
-      console.error('Error reading file:', error)
+  loadROM = (data: Uint8Array | number[] | ArrayBuffer) => {
+    if (data instanceof ArrayBuffer) {
+      this.rom.load(Array.from(new Uint8Array(data)))
+    } else if (data instanceof Uint8Array) {
+      this.rom.load(Array.from(data))
+    } else {
+      this.rom.load(data)
     }
   }
 
-  loadCart = async (path: string) => {
-    try {
-      const data = Array.from(new Uint8Array(await readFile(path)))
-      const cart = new Cart()
-      cart.load(data)
-      this.cart = cart
-    } catch (error) {
-      console.error('Error reading file:', error)
+  loadCart = (data: Uint8Array | number[] | ArrayBuffer) => {
+    let dataArray: number[]
+    if (data instanceof ArrayBuffer) {
+      dataArray = Array.from(new Uint8Array(data))
+    } else if (data instanceof Uint8Array) {
+      dataArray = Array.from(data)
+    } else {
+      dataArray = data
     }
-  }
-
-  start(): void {
-    this.cpu.reset()
-    this.startTime = Date.now()
-    this.isRunning = true
-    this.isAlive = true
-    this.loop()
-  }
-
-  end(): void {
-    this.isRunning = false
-    this.isAlive = false
+    const cart = new Cart()
+    cart.load(dataArray)
+    this.cart = cart
   }
 
   run(): void {
     this.isRunning = true
+    this.loop()
   }
 
   stop(): void {
     this.isRunning = false
+    if (this.loopHandle) {
+      if (typeof clearImmediate !== 'undefined') {
+        clearImmediate(this.loopHandle as any)
+      } else {
+        clearTimeout(this.loopHandle as any)
+      }
+      this.loopHandle = undefined
+    }
   }
 
   step(): void {
@@ -211,12 +331,12 @@ export class Machine {
     
     // Tick IO cards for each cycle of the instruction
     for (let i = 0; i < cyclesExecuted; i++) {
-      // SerialCard must be cycle-accurate
+      // ACIA must be cycle-accurate
       this.io5.tick(this.frequency)
       
       this.ioCycleAccumulator++
       if (this.ioCycleAccumulator >= this.ioTickInterval) {
-        // Skip ticking RAMCard IO1 and IO2 since they have no timing behavior
+        // Skip ticking RAMBank IO1 and IO2 since they have no timing behavior
         this.io3.tick(this.frequency)
         this.io4.tick(this.frequency)
         this.io6.tick(this.frequency)
@@ -227,17 +347,30 @@ export class Machine {
     }
   }
 
+  reset(coldStart: boolean): void {
+    this.cpu.reset()
+    this.ram.reset(coldStart)
+    this.io1.reset(coldStart)
+    this.io2.reset(coldStart)
+    this.io3.reset(coldStart)
+    this.io4.reset(coldStart)
+    this.io5.reset(coldStart)
+    this.io6.reset(coldStart)
+    this.io7.reset(coldStart)
+    this.io8.reset(coldStart)
+  }
+
   tick(): void {
     // Execute one CPU clock cycle
     this.cpu.tick()
     
-    // SerialCard must be cycle-accurate
+    // ACIA must be cycle-accurate
     this.io5.tick(this.frequency)
     
     // Tick other IO cards at intervals
     this.ioCycleAccumulator++
     if (this.ioCycleAccumulator >= this.ioTickInterval) {
-      // Skip ticking RAMCard IO1 and IO2 since they have no timing behavior
+      // Skip ticking RAMBank IO1 and IO2 since they have no timing behavior
       this.io3.tick(this.frequency)
       this.io4.tick(this.frequency)
       this.io6.tick(this.frequency)
@@ -248,22 +381,24 @@ export class Machine {
   }
 
   onReceive(data: number): void {
-    this.io5.onData(data) // Pass data to Serial card
+    if (this.target !== 'vcs') {
+      (this.io5 as ACIA).onData(data) // Pass data to Serial card
+    }
   }
 
   onKeyDown(scancode: number): void {
-    if (this.kim) {
+    if (this.target === 'kim') {
       this.keypadAttachment?.updateKey(scancode, true)
     } else {
-      this.keyboardMatrixAttachment.updateKey(scancode, true)
-      this.keyboardEncoderAttachment.updateKey(scancode, true)
+      this.keyboardMatrixAttachment?.updateKey(scancode, true)
+      this.keyboardEncoderAttachment?.updateKey(scancode, true)
     }
   }
 
   onKeyUp(scancode: number): void {
-    if (!this.kim) {
-      this.keyboardMatrixAttachment.updateKey(scancode, false)
-      this.keyboardEncoderAttachment.updateKey(scancode, false)
+    if (this.target !== 'kim') {
+      this.keyboardMatrixAttachment?.updateKey(scancode, false)
+      this.keyboardEncoderAttachment?.updateKey(scancode, false)
     }
   }
 
@@ -280,8 +415,6 @@ export class Machine {
   //
 
   private loop(): void {
-    if (!this.isAlive) { return }
-
     const now = performance.now()
     const elapsedMs = now - this.previousTime
     this.previousTime = now
@@ -299,12 +432,12 @@ export class Machine {
         for (let i = 0; i < ticksToRun; i++) {
           this.cpu.tick()
 
-          // SerialCard must be cycle-accurate
+          // ACIA must be cycle-accurate
           this.io5.tick(this.frequency)
 
           this.ioCycleAccumulator++
           if (this.ioCycleAccumulator >= this.ioTickInterval) {
-            // Skip ticking RAMCard IO1 and IO2 since they have no timing behavior
+            // Skip ticking RAMBank IO1 and IO2 since they have no timing behavior
             this.io3.tick(this.frequency)
             this.io4.tick(this.frequency)
             this.io6.tick(this.frequency)
@@ -319,38 +452,31 @@ export class Machine {
       (this as any)._accumulatorMs = accumulator
     }
 
-    if (this.render && !this.kim) {
-      const videoCard = this.io8 as VideoCard
-      if (videoCard.frameReady) {
-        videoCard.frameReady = false
+    if (this.render && (this.target === 'kim' || this.target === 'dev')) {
+      this.render()
+      this.frames += 1
+    } else if (this.render && (this.target === 'cob' || this.target === 'vcs')) {
+      const Video = this.io8 as Video
+      if (Video.frameReady) {
+        Video.frameReady = false
         this.render()
         this.frames += 1
       }
-    } else if (this.render && this.kim) {
-      this.render()
-      this.frames += 1
     }
 
-    setImmediate(() => this.loop())
+    if (this.isRunning) {
+      if (typeof setImmediate !== 'undefined') {
+        this.loopHandle = setImmediate(() => this.loop())
+      } else {
+        this.loopHandle = setTimeout(() => this.loop(), 0)
+      }
+    }
   }
 
   //
   // Bus Operations
   //
 
-  reset(coldStart: boolean): void {
-    this.cpu.reset()
-    this.ram.reset(coldStart)
-    this.io1.reset(coldStart)
-    this.io2.reset(coldStart)
-    this.io3.reset(coldStart)
-    this.io4.reset(coldStart)
-    this.io5.reset(coldStart)
-    this.io6.reset(coldStart)
-    this.io7.reset(coldStart)
-    this.io8.reset(coldStart)
-  }
-
   read(address: number): number {
     switch(true) {
       case (this.cart && address >= Cart.CODE && address <= Cart.END):