ac6502 1.0.0 → 1.1.0

package/src/components/IO/SerialCard.ts

@@ -49,11 +49,11 @@ export class SerialCard implements IO {
       case 0x01: // Status Register
         return this.readStatus()
       
-      case 0x02: // Command Register (write-only, returns 0)
-        return 0
+      case 0x02: // Command Register
+        return this.commandRegister
       
-      case 0x03: // Control Register (write-only, returns 0)
-        return 0
+      case 0x03: // Control Register
+        return this.controlRegister
       
       default:
         return 0

package/src/components/Machine.ts

@@ -12,6 +12,10 @@ 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 { IO } from './IO'
 import { readFile } from 'fs/promises'
 
 export class Machine {
@@ -25,21 +29,27 @@ export class Machine {
   cpu: CPU
   ram: RAM
   rom: ROM
-  io1: RAMCard
-  io2: RAMCard
-  io3: RTCCard
-  io4: StorageCard
+  io1: IO
+  io2: IO
+  io3: IO
+  io4: IO
   io5: SerialCard
-  io6: GPIOCard
-  io7: SoundCard
-  io8: VideoCard
+  io6: IO
+  io7: IO
+  io8: IO
 
   cart?: Cart
+  kim: boolean
 
   // GPIO Attachments
   keyboardMatrixAttachment: GPIOKeyboardMatrixAttachment
   keyboardEncoderAttachment: GPIOKeyboardEncoderAttachment
-  joystickAttachment: GPIOJoystickAttachment
+  joystickAttachmentA: GPIOJoystickAttachment
+  joystickAttachmentB: GPIOJoystickAttachment
+
+  // KIM mode attachments
+  lcdAttachment?: GPIOLCDAttachment
+  keypadAttachment?: GPIOKeypadAttachment
 
   isAlive: boolean = false
   isRunning: boolean = false
@@ -52,73 +62,101 @@ export class Machine {
   previousTime: number = performance.now()
 
   transmit?: (data: number) => void
-  render?: (buffer: Buffer<ArrayBufferLike>) => void
+  render?: () => void
   pushAudioSamples?: (samples: Float32Array) => void
 
   //
   // Initialization
   //
 
-  constructor() {
+  constructor(kim: boolean = false) {
+    this.kim = kim
     this.cpu = new CPU(this.read.bind(this), this.write.bind(this))
     this.ram = new RAM()
     this.rom = new ROM()
-    this.io1 = new RAMCard()
-    this.io2 = new RAMCard()
-    this.io3 = new RTCCard()
-    this.io4 = new StorageCard()
-    this.io5 = new SerialCard()
-    this.io6 = new GPIOCard()
-    this.io7 = new SoundCard()
-    this.io8 = new VideoCard()
 
-    // Connect RTCCard IRQ/NMI to CPU
-    this.io3.raiseIRQ = () => this.cpu.irq()
-    this.io3.raiseNMI = () => this.cpu.nmi()
+    this.io5 = new SerialCard()
 
     // Connect SerialCard IRQ/NMI to CPU
     this.io5.raiseIRQ = () => this.cpu.irq()
     this.io5.raiseNMI = () => this.cpu.nmi()
 
-    // Connect SerialCard transmit callback (use arrow function to look up this.transmit at call time)
+    // Connect SerialCard transmit callback
     this.io5.transmit = (data: number) => {
       if (this.transmit) {
         this.transmit(data)
       }
     }
 
-    // Connect VideoCard IRQ/NMI to CPU
-    this.io8.raiseIRQ = () => this.cpu.irq()
-    this.io8.raiseNMI = () => this.cpu.nmi()
-
-    // Connect SoundCard pushSamples callback (use arrow function to look up this.pushAudioSamples at call time)
-    this.io7.pushSamples = (samples: Float32Array) => {
-      if (this.pushAudioSamples) {
-        this.pushAudioSamples(samples)
-      }
-    }
-
-    // Create GPIO Attachments
-    // Keyboard matrix (manual scanning) - highest priority for Port A rows (priority 10)
+    // Always create standard GPIO attachments (for type stability)
     this.keyboardMatrixAttachment = new GPIOKeyboardMatrixAttachment(10)
-    
-    // Keyboard encoder (ASCII on both Port A and Port B) - medium priority (priority 20)
     this.keyboardEncoderAttachment = new GPIOKeyboardEncoderAttachment(20)
-    
-    // Joystick (Port B) - lowest priority, fallback (priority 100)
-    this.joystickAttachment = new GPIOJoystickAttachment(false, 100)
+    this.joystickAttachmentA = new GPIOJoystickAttachment(false, 100)
+    this.joystickAttachmentB = new GPIOJoystickAttachment(false, 100)
+
+    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()
+
+      const gpioCard = new GPIOCard()
+      this.io8 = gpioCard
+
+      // Connect GPIOCard IRQ/NMI to CPU
+      gpioCard.raiseIRQ = () => this.cpu.irq()
+      gpioCard.raiseNMI = () => this.cpu.nmi()
+
+      // Create KIM GPIO Attachments
+      this.lcdAttachment = new GPIOLCDAttachment(16, 2, 10)
+      this.keypadAttachment = new GPIOKeypadAttachment(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)
+
+      // 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)
+        }
+      }
 
-    // Attach peripherals to GPIO Card
-    // Keyboard matrix supports both ports
-    this.io6.attachToPortA(this.keyboardMatrixAttachment)
-    this.io6.attachToPortB(this.keyboardMatrixAttachment)
-    
-    // Keyboard encoder supports both ports
-    this.io6.attachToPortA(this.keyboardEncoderAttachment)
-    this.io6.attachToPortB(this.keyboardEncoderAttachment)
-    
-    // Joystick attached to Port B only
-    this.io6.attachToPortB(this.joystickAttachment)
+      // 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)
+    }
 
     this.cpu.reset()
   }
@@ -147,6 +185,7 @@ export class Machine {
   }
 
   start(): void {
+    this.cpu.reset()
     this.startTime = Date.now()
     this.isRunning = true
     this.isAlive = true
@@ -213,20 +252,27 @@ export class Machine {
   }
 
   onKeyDown(scancode: number): void {
-    // Route keyboard input to attachments
-    this.keyboardMatrixAttachment.updateKey(scancode, true)   // Update keyboard matrix
-    this.keyboardEncoderAttachment.updateKey(scancode, true)  // Update keyboard encoder
+    if (this.kim) {
+      this.keypadAttachment?.updateKey(scancode, true)
+    } else {
+      this.keyboardMatrixAttachment.updateKey(scancode, true)
+      this.keyboardEncoderAttachment.updateKey(scancode, true)
+    }
   }
 
   onKeyUp(scancode: number): void {
-    // Release key from keyboard matrix and encoder
-    this.keyboardMatrixAttachment.updateKey(scancode, false)  // Update keyboard matrix
-    this.keyboardEncoderAttachment.updateKey(scancode, false) // Update keyboard encoder
+    if (!this.kim) {
+      this.keyboardMatrixAttachment.updateKey(scancode, false)
+      this.keyboardEncoderAttachment.updateKey(scancode, false)
+    }
+  }
+
+  onJoystickA(buttons: number): void {
+    this.joystickAttachmentA?.updateJoystick(buttons)
   }
 
-  onJoystick(buttons: number): void {
-    // Update joystick attachment with button states
-    this.joystickAttachment.updateJoystick(buttons)
+  onJoystickB(buttons: number): void {
+    this.joystickAttachmentB?.updateJoystick(buttons)
   }
 
   //
@@ -274,7 +320,7 @@ export class Machine {
     }
 
     if (this.render) {
-      this.render(this.io8.buffer)
+      this.render()
       this.frames += 1
     }
 

package/src/index.ts

@@ -4,9 +4,12 @@ import figlet from 'figlet'
 import { Machine } from './components/Machine'
 import { Command } from 'commander'
 import { SerialPort } from 'serialport'
+import { VideoCard } from './components/IO/VideoCard'
+import { StorageCard } from './components/IO/StorageCard'
+import { SoundCard } from './components/IO/SoundCard'
 import sdl from '@kmamal/sdl'
 
-const VERSION = '1.0.0'
+const VERSION = '1.1.0'
 const WIDTH = 320
 const HEIGHT = 240
 
@@ -40,6 +43,7 @@ interface EmulatorOptions {
   stopbits?: string
   port?: string
   storage?: string
+  kim?: boolean
 }
 
 class Emulator {
@@ -48,14 +52,16 @@ class Emulator {
   private window?: any
   private audioDevice?: any
   private controllers: Map<number, any>
-  private joystickButtonState: number
+  private joystickButtonStateA: number
+  private joystickButtonStateB: number
   private options: EmulatorOptions
 
   constructor(options: EmulatorOptions) {
     this.options = options
-    this.machine = new Machine()
+    this.machine = new Machine(options.kim ?? false)
     this.controllers = new Map()
-    this.joystickButtonState = 0x00
+    this.joystickButtonStateA = 0x00
+    this.joystickButtonStateB = 0x00
   }
 
   async initialize(): Promise<void> {
@@ -98,8 +104,8 @@ class Emulator {
       console.log('Loaded Cart: NONE')
     }
 
-    if (this.options.storage) {
-      await this.machine.io4.loadFromFile(this.options.storage)
+    if (this.options.storage && !this.options.kim) {
+      await (this.machine.io4 as StorageCard).loadFromFile(this.options.storage)
     }
   }
 
@@ -177,6 +183,7 @@ class Emulator {
   }
 
   private setupAudio(): void {
+    if (this.options.kim) return
     try {
       this.audioDevice = sdl.audio.openDevice({ type: 'playback' }, {
         channels: AUDIO_CHANNELS as 1,
@@ -186,7 +193,7 @@ class Emulator {
       })
 
       // Configure SoundCard sample rate to match audio device
-      this.machine.io7.sampleRate = this.audioDevice.frequency
+      ;(this.machine.io7 as SoundCard).sampleRate = this.audioDevice.frequency
 
       // Connect the Machine's audio callback to the SDL audio device
       this.machine.pushAudioSamples = (samples: Float32Array) => {
@@ -211,10 +218,29 @@ class Emulator {
   }
 
   private setupWindow(): void {
+    const isKIM = this.options.kim ?? false
+    const lcd = this.machine.lcdAttachment
+
+    // LCD dot-matrix rendering constants
+    const DOT_SIZE = 2      // Each LCD dot rendered as DOT_SIZE x DOT_SIZE pixels
+    const DOT_GAP = 1       // Gap between dots
+    const LCD_PADDING = 8   // Green border padding around the display
+    const CELL = DOT_SIZE + DOT_GAP
+
+    let windowWidth: number
+    let windowHeight: number
+    if (isKIM && lcd) {
+      windowWidth = LCD_PADDING * 2 + lcd.pixelsWidth * CELL
+      windowHeight = LCD_PADDING * 2 + lcd.pixelsHeight * CELL
+    } else {
+      windowWidth = WIDTH
+      windowHeight = HEIGHT
+    }
+
     this.window = sdl.video.createWindow({
-      title: "6502 Emulator",
-      width: WIDTH * this.machine.scale,
-      height: HEIGHT * this.machine.scale,
+      title: isKIM ? "6502 Emulator (KIM)" : "6502 Emulator",
+      width: windowWidth * this.machine.scale,
+      height: windowHeight * this.machine.scale,
       accelerated: true,
       vsync: true
     })
@@ -229,15 +255,89 @@ class Emulator {
       this.machine.onKeyUp(event.scancode)
     })
 
-    this.machine.render = (buffer: Buffer) => {
-      if (!this.window) { return }
-      this.window.render(WIDTH, HEIGHT, WIDTH * 4, 'rgba32', buffer)
+    if (isKIM && lcd) {
+      const lcdWidth = lcd.pixelsWidth
+      const lcdHeight = lcd.pixelsHeight
+      const renderWidth = windowWidth
+      const renderHeight = windowHeight
+      const rgbaBuffer = Buffer.alloc(renderWidth * renderHeight * 4)
+
+      // Pre-fill with background color (LCD green for padding + gaps)
+      for (let i = 0; i < renderWidth * renderHeight; i++) {
+        const off = i * 4
+        rgbaBuffer[off] = 0x50
+        rgbaBuffer[off + 1] = 0x88
+        rgbaBuffer[off + 2] = 0x38
+        rgbaBuffer[off + 3] = 0xFF
+      }
+
+      this.machine.render = () => {
+        if (!this.window) { return }
+        const buf = lcd.buffer
+
+        // Reset buffer to background color
+        for (let i = 0; i < renderWidth * renderHeight; i++) {
+          const off = i * 4
+          rgbaBuffer[off] = 0x50
+          rgbaBuffer[off + 1] = 0x88
+          rgbaBuffer[off + 2] = 0x38
+          rgbaBuffer[off + 3] = 0xFF
+        }
+
+        // Render each buffer pixel as a dot block
+        for (let by = 0; by < lcdHeight; by++) {
+          for (let bx = 0; bx < lcdWidth; bx++) {
+            const val = buf[by * lcdWidth + bx]
+
+            if (val < 0) {
+              // Gap pixel - skip, shows background color
+              continue
+            }
+
+            let r: number, g: number, b: number
+            if (val === 0) {
+              // Pixel off - slightly brighter than background for visible dot grid
+              r = 0x60; g = 0xA0; b = 0x40
+            } else {
+              // Pixel on - dark
+              r = 0x10; g = 0x20; b = 0x10
+            }
+
+            // Draw DOT_SIZE x DOT_SIZE block
+            const screenX = LCD_PADDING + bx * CELL
+            const screenY = LCD_PADDING + by * CELL
+            for (let dy = 0; dy < DOT_SIZE; dy++) {
+              for (let dx = 0; dx < DOT_SIZE; dx++) {
+                const off = ((screenY + dy) * renderWidth + (screenX + dx)) * 4
+                rgbaBuffer[off] = r
+                rgbaBuffer[off + 1] = g
+                rgbaBuffer[off + 2] = b
+                rgbaBuffer[off + 3] = 0xFF
+              }
+            }
+          }
+        }
+
+        this.window.render(renderWidth, renderHeight, renderWidth * 4, 'rgba32', rgbaBuffer)
+      }
+    } else {
+      const videoCard = this.machine.io8 as VideoCard
+      this.machine.render = () => {
+        if (!this.window) { return }
+        this.window.render(WIDTH, HEIGHT, WIDTH * 4, 'rgba32', videoCard.buffer)
+      }
     }
 
     this.window.on('close', () => this.shutdown())
   }
 
+  private playerForController(deviceId: number): 'A' | 'B' {
+    const ids = Array.from(this.controllers.keys())
+    return ids.indexOf(deviceId) === 0 ? 'B' : 'A'
+  }
+
   private setupControllers(): void {
+    if (this.options.kim) return
     // Controller device add/remove handlers
     (sdl.controller as any).on('deviceAdd', (device: any) => {
       console.log(`Controller added: ${device.name || device.id}`)
@@ -246,9 +346,10 @@ class Emulator {
         const controller = sdl.controller.openDevice(device)
         this.controllers.set(device.id, controller)
         
-        this.setupControllerHandlers(controller, device)
+        const player = this.playerForController(device.id)
+        this.setupControllerHandlers(controller, device, player)
         
-        console.log(`Controller ${device.name || device.id} opened successfully`)
+        console.log(`Controller ${device.name || device.id} opened as Player ${player}`)
       } catch (error) {
         console.error(`Failed to open controller ${device.name || device.id}:`, error)
       }
@@ -257,16 +358,20 @@ class Emulator {
     ;(sdl.controller as any).on('deviceRemove', (device: any) => {
       console.log(`Controller removed: ${device.name || device.id}`)
       
+      const player = this.playerForController(device.id)
       const controller = this.controllers.get(device.id)
       if (controller && !controller.closed) {
         controller.close()
       }
       this.controllers.delete(device.id)
       
-      // Clear joystick state when all controllers are removed
-      if (this.controllers.size === 0) {
-        this.joystickButtonState = 0x00
-        this.machine.onJoystick(this.joystickButtonState)
+      // Clear joystick state for the removed controller's player
+      if (player === 'A') {
+        this.joystickButtonStateA = 0x00
+        this.machine.onJoystickA(this.joystickButtonStateA)
+      } else {
+        this.joystickButtonStateB = 0x00
+        this.machine.onJoystickB(this.joystickButtonStateB)
       }
     })
 
@@ -280,9 +385,10 @@ class Emulator {
           const controller = sdl.controller.openDevice(device)
           this.controllers.set(device.id, controller)
           
-          this.setupControllerHandlers(controller, device)
+          const player = this.playerForController(device.id)
+          this.setupControllerHandlers(controller, device, player)
           
-          console.log(`Controller ${device.name || device.id} opened successfully`)
+          console.log(`Controller ${device.name || device.id} opened as Player ${player}`)
         } catch (error) {
           console.error(`Failed to open controller ${device.name || device.id}:`, error)
         }
@@ -292,90 +398,75 @@ class Emulator {
     }
   }
 
-  private setupControllerHandlers(controller: any, device: any): void {
-    (controller as any).on('buttonDown', (button: string) => {
+  private setupControllerHandlers(controller: any, device: any, player: 'A' | 'B'): void {
+    const getState = () => player === 'A' ? this.joystickButtonStateA : this.joystickButtonStateB
+    const setState = (v: number) => {
+      if (player === 'A') this.joystickButtonStateA = v
+      else this.joystickButtonStateB = v
+    }
+    const send = () => {
+      if (player === 'A') this.machine.onJoystickA(this.joystickButtonStateA)
+      else this.machine.onJoystickB(this.joystickButtonStateB)
+    }
+
+    ;(controller as any).on('buttonDown', (button: string) => {
+      let state = getState()
       switch (button) {
-        case 'dpadUp':
-          this.joystickButtonState |= BUTTON_UP
-          break
-        case 'dpadDown':
-          this.joystickButtonState |= BUTTON_DOWN
-          break
-        case 'dpadLeft':
-          this.joystickButtonState |= BUTTON_LEFT
-          break
-        case 'dpadRight':
-          this.joystickButtonState |= BUTTON_RIGHT
-          break
-        case 'a':
-          this.joystickButtonState |= BUTTON_A
-          break
-        case 'b':
-          this.joystickButtonState |= BUTTON_B
-          break
-        case 'back':
-          this.joystickButtonState |= BUTTON_SELECT
-          break
-        case 'start':
-          this.joystickButtonState |= BUTTON_START
-          break
+        case 'dpadUp':    state |= BUTTON_UP; break
+        case 'dpadDown':  state |= BUTTON_DOWN; break
+        case 'dpadLeft':  state |= BUTTON_LEFT; break
+        case 'dpadRight': state |= BUTTON_RIGHT; break
+        case 'a':         state |= BUTTON_A; break
+        case 'b':         state |= BUTTON_B; break
+        case 'back':      state |= BUTTON_SELECT; break
+        case 'start':     state |= BUTTON_START; break
       }
-      this.machine.onJoystick(this.joystickButtonState)
+      setState(state)
+      send()
     })
 
     ;(controller as any).on('buttonUp', (button: string) => {
+      let state = getState()
       switch (button) {
-        case 'dpadUp':
-          this.joystickButtonState &= ~BUTTON_UP
-          break
-        case 'dpadDown':
-          this.joystickButtonState &= ~BUTTON_DOWN
-          break
-        case 'dpadLeft':
-          this.joystickButtonState &= ~BUTTON_LEFT
-          break
-        case 'dpadRight':
-          this.joystickButtonState &= ~BUTTON_RIGHT
-          break
-        case 'a':
-          this.joystickButtonState &= ~BUTTON_A
-          break
-        case 'b':
-          this.joystickButtonState &= ~BUTTON_B
-          break
-        case 'back':
-          this.joystickButtonState &= ~BUTTON_SELECT
-          break
-        case 'start':
-          this.joystickButtonState &= ~BUTTON_START
-          break
+        case 'dpadUp':    state &= ~BUTTON_UP; break
+        case 'dpadDown':  state &= ~BUTTON_DOWN; break
+        case 'dpadLeft':  state &= ~BUTTON_LEFT; break
+        case 'dpadRight': state &= ~BUTTON_RIGHT; break
+        case 'a':         state &= ~BUTTON_A; break
+        case 'b':         state &= ~BUTTON_B; break
+        case 'back':      state &= ~BUTTON_SELECT; break
+        case 'start':     state &= ~BUTTON_START; break
       }
-      this.machine.onJoystick(this.joystickButtonState)
+      setState(state)
+      send()
     })
 
     controller.on('axisMotion', ({ axis, value }: { axis: string; value: number }) => {
+      let state = getState()
       if (axis === 'leftStickX') {
         if (value < -AXIS_THRESHOLD) {
-          this.joystickButtonState |= BUTTON_LEFT
-          this.joystickButtonState &= ~BUTTON_RIGHT
+          state |= BUTTON_LEFT
+          state &= ~BUTTON_RIGHT
         } else if (value > AXIS_THRESHOLD) {
-          this.joystickButtonState |= BUTTON_RIGHT
-          this.joystickButtonState &= ~BUTTON_LEFT
+          state |= BUTTON_RIGHT
+          state &= ~BUTTON_LEFT
         } else {
-          this.joystickButtonState &= ~(BUTTON_LEFT | BUTTON_RIGHT)
+          state &= ~(BUTTON_LEFT | BUTTON_RIGHT)
         }
-        this.machine.onJoystick(this.joystickButtonState)
+        setState(state)
+        send()
       } else if (axis === 'leftStickY') {
         if (value < -AXIS_THRESHOLD) {
-          this.joystickButtonState |= BUTTON_UP
-          this.joystickButtonState &= ~BUTTON_DOWN
+          state |= BUTTON_UP
+          state &= ~BUTTON_DOWN
         } else if (value > AXIS_THRESHOLD) {
-          this.joystickButtonState |= BUTTON_DOWN
-          this.joystickButtonState &= ~BUTTON_UP
+          state |= BUTTON_DOWN
+          state &= ~BUTTON_UP
         } else {
-          this.joystickButtonState &= ~(BUTTON_UP | BUTTON_DOWN)
+          state &= ~(BUTTON_UP | BUTTON_DOWN)
         }
-        this.machine.onJoystick(this.joystickButtonState)
+        setState(state)
+        send()
       }
     })
 
@@ -422,8 +513,8 @@ class Emulator {
     })
     
     // Save storage data if path was provided
-    if (this.options.storage) {
-      this.machine.io4.saveToFile(this.options.storage).then(() => {
+    if (this.options.storage && !this.options.kim) {
+      (this.machine.io4 as StorageCard).saveToFile(this.options.storage).then(() => {
         process.exit(0)
       }).catch(() => {
         process.exit(1)
@@ -455,6 +546,7 @@ program
   .option('-t, --stopbits <stopbits>', 'Stop Bits (1 | 1.5 | 2)', '1')
   .option('-p, --port <port>', 'Path to the serial port (e.g., /dev/ttyUSB0)')
   .option('-S, --storage <path>', 'Path to storage data file for Compact Flash card persistence')
+  .option('-K, --kim', 'Configure IO for the KIM system target', false)
   .addHelpText('beforeAll', figlet.textSync('6502 Emulator', { font: 'cricket' }) + '\n' + `Version: ${VERSION} | A.C. Wright Design\n`)
   .parse(process.argv)