ac6502 1.2.0 → 1.4.0

package/src/components/IO/{StorageCard.ts → Storage.ts}

@@ -1,9 +1,7 @@
 import { IO } from '../IO'
-import { readFile, writeFile } from 'fs/promises'
-import { existsSync } from 'fs'
 
 /**
- * StorageCard - Emulates a Compact Flash card in 8-bit IDE mode
+ * Storage - Emulates a Compact Flash card in 8-bit IDE mode
  * 
  * Emulates a 128MB CF card with ATA-style register interface.
  * Uses LBA (Logical Block Addressing) for sector access.
@@ -25,12 +23,12 @@ import { existsSync } from 'fs'
  * 0xEC: Identify Drive
  * 0xEF: Set Features (accepted but not implemented)
  */
-export class StorageCard implements IO {
+export class Storage implements IO {
 
   // Constants
   private static readonly STORAGE_SIZE = 128 * 1024 * 1024  // 128MB
   private static readonly SECTOR_SIZE = 512
-  private static readonly SECTOR_COUNT = StorageCard.STORAGE_SIZE / StorageCard.SECTOR_SIZE  // 262144 sectors
+  private static readonly SECTOR_COUNT = Storage.STORAGE_SIZE / Storage.SECTOR_SIZE  // 262144 sectors
 
   // Status Register Flags
   private static readonly STATUS_ERR = 0x01  // Error
@@ -43,13 +41,13 @@ export class StorageCard implements IO {
   private static readonly ERR_IDNF = 0x10    // ID Not Found
 
   // Storage and Identity data (in-memory simulation)
-  private storage: Buffer
-  private identity: Buffer
+  private storage: Uint8Array
+  private identity: Uint8Array
 
   // Data buffer (512 bytes)
-  private buffer: Buffer = Buffer.alloc(StorageCard.SECTOR_SIZE)
+  private buffer: Uint8Array = new Uint8Array(Storage.SECTOR_SIZE)
   private bufferIndex: number = 0
-  private commandDataSize: number = StorageCard.SECTOR_SIZE
+  private commandDataSize: number = Storage.SECTOR_SIZE
   private sectorOffset: number = 0
 
   // Registers
@@ -72,8 +70,8 @@ export class StorageCard implements IO {
 
   constructor() {
     // Initialize storage and identity buffers
-    this.storage = Buffer.alloc(StorageCard.STORAGE_SIZE, 0x00)
-    this.identity = Buffer.alloc(StorageCard.SECTOR_SIZE)
+    this.storage = new Uint8Array(Storage.STORAGE_SIZE)
+    this.identity = new Uint8Array(Storage.SECTOR_SIZE)
     this.generateIdentity()
     this.reset(true)
   }
@@ -137,7 +135,7 @@ export class StorageCard implements IO {
 
   reset(coldStart: boolean): void {
     this.bufferIndex = 0x0000
-    this.commandDataSize = StorageCard.SECTOR_SIZE
+    this.commandDataSize = Storage.SECTOR_SIZE
     this.sectorOffset = 0
 
     this.error = 0x00
@@ -147,7 +145,7 @@ export class StorageCard implements IO {
     this.lba1 = 0x00
     this.lba2 = 0x00
     this.lba3 = 0xE0
-    this.status = 0x00 | StorageCard.STATUS_RDY
+    this.status = 0x00 | Storage.STATUS_RDY
     this.command = 0x00
 
     this.isIdentifying = false
@@ -162,36 +160,36 @@ export class StorageCard implements IO {
 
   private executeCommand(): void {
     // New command so clear errors and flags
-    this.status &= ~StorageCard.STATUS_ERR
-    this.status &= ~StorageCard.STATUS_DRQ
+    this.status &= ~Storage.STATUS_ERR
+    this.status &= ~Storage.STATUS_DRQ
     this.error = 0x00
-    this.commandDataSize = StorageCard.SECTOR_SIZE * this.sectorCount
+    this.commandDataSize = Storage.SECTOR_SIZE * this.sectorCount
     this.bufferIndex = 0
     this.sectorOffset = 0
 
     // Check if already executing a command
     if (this.isTransferring || this.isIdentifying) {
-      this.status |= StorageCard.STATUS_ERR
-      this.error |= StorageCard.ERR_ABRT
+      this.status |= Storage.STATUS_ERR
+      this.error |= Storage.ERR_ABRT
       return
     }
 
     switch (this.command) {
       case 0xC0: { // Erase sector
         if (!this.sectorValid()) {
-          this.status |= StorageCard.STATUS_ERR
-          this.error |= StorageCard.ERR_ABRT | StorageCard.ERR_IDNF
+          this.status |= Storage.STATUS_ERR
+          this.error |= Storage.ERR_ABRT | Storage.ERR_IDNF
         } else {
-          const offset = this.sectorIndex() * StorageCard.SECTOR_SIZE
-          this.storage.fill(0x00, offset, offset + StorageCard.SECTOR_SIZE)
+          const offset = this.sectorIndex() * Storage.SECTOR_SIZE
+          this.storage.fill(0x00, offset, offset + Storage.SECTOR_SIZE)
         }
         break
       }
 
       case 0xEC: { // Identify drive
-        this.identity.copy(this.buffer, 0, 0, StorageCard.SECTOR_SIZE)
-        this.commandDataSize = StorageCard.SECTOR_SIZE
-        this.status |= StorageCard.STATUS_DRQ
+        this.buffer.set(this.identity.subarray(0, Storage.SECTOR_SIZE))
+        this.commandDataSize = Storage.SECTOR_SIZE
+        this.status |= Storage.STATUS_DRQ
         this.isIdentifying = true
         break
       }
@@ -199,13 +197,13 @@ export class StorageCard implements IO {
       case 0x20: // Read sector
       case 0x21:
         if (!this.sectorValid()) {
-          this.status |= StorageCard.STATUS_ERR
-          this.error |= StorageCard.ERR_ABRT | StorageCard.ERR_IDNF
+          this.status |= Storage.STATUS_ERR
+          this.error |= Storage.ERR_ABRT | Storage.ERR_IDNF
         } else {
           // Load first sector into buffer
-          const offset = this.sectorIndex() * StorageCard.SECTOR_SIZE
-          this.storage.copy(this.buffer, 0, offset, offset + StorageCard.SECTOR_SIZE)
-          this.status |= StorageCard.STATUS_DRQ
+          const offset = this.sectorIndex() * Storage.SECTOR_SIZE
+          this.buffer.set(this.storage.subarray(offset, offset + Storage.SECTOR_SIZE))
+          this.status |= Storage.STATUS_DRQ
           this.isTransferring = true
         }
         break
@@ -217,18 +215,18 @@ export class StorageCard implements IO {
       case 0x30: // Write sector
       case 0x31:
         if (!this.sectorValid()) {
-          this.status |= StorageCard.STATUS_ERR
-          this.error |= StorageCard.ERR_ABRT | StorageCard.ERR_IDNF
+          this.status |= Storage.STATUS_ERR
+          this.error |= Storage.ERR_ABRT | Storage.ERR_IDNF
         } else {
-          this.status |= StorageCard.STATUS_DRQ
+          this.status |= Storage.STATUS_DRQ
           this.isTransferring = true
         }
         break
 
       default:
         // Unsupported command
-        this.status |= StorageCard.STATUS_ERR
-        this.error |= StorageCard.ERR_ABRT
+        this.status |= Storage.STATUS_ERR
+        this.error |= Storage.ERR_ABRT
         break
     }
   }
@@ -242,14 +240,14 @@ export class StorageCard implements IO {
       } else {
         this.bufferIndex = 0
         this.isIdentifying = false
-        this.status &= ~StorageCard.STATUS_DRQ
+        this.status &= ~Storage.STATUS_DRQ
       }
 
       return data
     } else if (this.isTransferring) {
       const data = this.buffer[this.bufferIndex]
 
-      if (this.bufferIndex < StorageCard.SECTOR_SIZE - 1) {
+      if (this.bufferIndex < Storage.SECTOR_SIZE - 1) {
         this.bufferIndex++
       } else {
         this.bufferIndex = 0
@@ -257,11 +255,11 @@ export class StorageCard implements IO {
 
         if (this.sectorOffset < this.sectorCount) {
           // Load the next sector
-          const offset = (this.sectorIndex() + this.sectorOffset) * StorageCard.SECTOR_SIZE
-          this.storage.copy(this.buffer, 0, offset, offset + StorageCard.SECTOR_SIZE)
+          const offset = (this.sectorIndex() + this.sectorOffset) * Storage.SECTOR_SIZE
+          this.buffer.set(this.storage.subarray(offset, offset + Storage.SECTOR_SIZE))
         } else {
           this.isTransferring = false
-          this.status &= ~StorageCard.STATUS_DRQ
+          this.status &= ~Storage.STATUS_DRQ
         }
       }
 
@@ -274,21 +272,21 @@ export class StorageCard implements IO {
   private writeBuffer(value: number): void {
     this.buffer[this.bufferIndex] = value
 
-    if (this.bufferIndex < StorageCard.SECTOR_SIZE - 1) {
+    if (this.bufferIndex < Storage.SECTOR_SIZE - 1) {
       this.bufferIndex++
     } else {
       this.bufferIndex = 0
 
       // Write the current sector to storage
-      const offset = (this.sectorIndex() + this.sectorOffset) * StorageCard.SECTOR_SIZE
-      this.buffer.copy(this.storage, offset, 0, StorageCard.SECTOR_SIZE)
+      const offset = (this.sectorIndex() + this.sectorOffset) * Storage.SECTOR_SIZE
+      this.storage.set(this.buffer.subarray(0, Storage.SECTOR_SIZE), offset)
 
       this.sectorOffset++
 
       // Check if all sectors have been written
       if (this.sectorOffset >= this.sectorCount) {
         this.isTransferring = false
-        this.status &= ~StorageCard.STATUS_DRQ
+        this.status &= ~Storage.STATUS_DRQ
       }
     }
   }
@@ -298,7 +296,7 @@ export class StorageCard implements IO {
   }
 
   private sectorValid(): boolean {
-    return this.sectorIndex() < StorageCard.SECTOR_COUNT
+    return this.sectorIndex() < Storage.SECTOR_COUNT
   }
 
   private generateIdentity(): void {
@@ -434,40 +432,39 @@ export class StorageCard implements IO {
   }
 
   /**
-   * Load storage data from a file
-   * If the file doesn't exist, storage remains empty (initialized to 0x00)
+   * Load storage data from a Uint8Array, ArrayBuffer, or number array
+   * If data is not provided or wrong size, storage remains empty
    */
-  async loadFromFile(filePath: string): Promise<void> {
-    try {
-      if (existsSync(filePath)) {
-        const data = await readFile(filePath)
-        // Ensure the file is exactly the expected size
-        if (data.length === StorageCard.STORAGE_SIZE) {
-          data.copy(this.storage, 0, 0, StorageCard.STORAGE_SIZE)
-          console.log(`Storage loaded from: ${filePath}`)
-        } else {
-          console.warn(`Warning: Storage file size mismatch. Expected ${StorageCard.STORAGE_SIZE} bytes, got ${data.length} bytes.`)
-          console.warn('Storage will remain empty.')
-        }
-      } else {
-        console.log(`Storage file not found: ${filePath}`)
-        console.log('A new storage file will be created on exit.')
-      }
-    } catch (error) {
-      console.error('Error loading storage file:', error)
+  loadData(data: Uint8Array | ArrayBuffer | number[] | null): void {
+    if (!data) {
+      console.log('No storage data provided. Storage will remain empty.')
+      return
+    }
+
+    let uint8Data: Uint8Array
+    if (data instanceof ArrayBuffer) {
+      uint8Data = new Uint8Array(data)
+    } else if (data instanceof Uint8Array) {
+      uint8Data = data
+    } else {
+      uint8Data = new Uint8Array(data)
+    }
+
+    // Ensure the data is exactly the expected size
+    if (uint8Data.length === Storage.STORAGE_SIZE) {
+      this.storage.set(uint8Data)
+      console.log(`Storage loaded (${Storage.STORAGE_SIZE} bytes)`)
+    } else {
+      console.warn(`Warning: Storage data size mismatch. Expected ${Storage.STORAGE_SIZE} bytes, got ${uint8Data.length} bytes.`)
+      console.warn('Storage will remain empty.')
     }
   }
 
   /**
-   * Save storage data to a file
+   * Get storage data as Uint8Array for saving
    */
-  async saveToFile(filePath: string): Promise<void> {
-    try {
-      await writeFile(filePath, this.storage)
-      console.log(`Storage saved to: ${filePath}`)
-    } catch (error) {
-      console.error('Error saving storage file:', error)
-    }
+  getData(): Uint8Array {
+    return new Uint8Array(this.storage)
   }
 
 }

package/src/components/IO/Terminal.ts

@@ -0,0 +1,34 @@
+import { IO } from '../IO'
+import { VTAC } from 'vtac-terminal'
+
+/**
+ * Terminal - Emulates the VTAC fantasy terminal
+ *
+ * Register Map:
+ * $00: Data / Status Register
+ *   Write: sends byte to VTAC for processing
+ *   Read:  always returns 0 (bit 7 is a busy flag on the real device; busy is never set here)
+ */
+export class Terminal implements IO {
+
+  raiseIRQ = () => {}
+  raiseNMI = () => {}
+
+  readonly vtac: VTAC = new VTAC()
+
+  read(address: number): number {
+    // Status register: bit 7 is busy flag on real device, never busy in emulation
+    return 0
+  }
+
+  write(address: number, data: number): void {
+    const register = address & 0x00
+    if (register === 0x00) {
+      this.vtac.parse(data)
+    }
+  }
+
+  tick(frequency: number): void {}
+  reset(coldStart: boolean): void {}
+
+}