ac6502 1.2.0 → 1.4.0

package/dist/components/IO/RTCCard.d.ts

@@ -0,0 +1,107 @@
+import { IO } from '../IO';
+/**
+ * DS1511Y Real-Time Clock IC Emulation
+ *
+ * Register Map (0x00-0x1F):
+ * 0x00: Seconds (BCD, 00-59)
+ * 0x01: Minutes (BCD, 00-59)
+ * 0x02: Hours (BCD, 00-23)
+ * 0x03: Day of Week (1-7, 1=Sunday)
+ * 0x04: Date (BCD, 01-31)
+ * 0x05: Month (BCD, 01-12) + Control bits (EOSC, E32K)
+ * 0x06: Year (BCD, 00-99)
+ * 0x07: Century (BCD, 00-39)
+ * 0x08: Alarm Seconds (BCD, 00-59) + AM1 bit
+ * 0x09: Alarm Minutes (BCD, 00-59) + AM2 bit
+ * 0x0A: Alarm Hours (BCD, 00-23) + AM3 bit
+ * 0x0B: Alarm Day/Date + AM4, DY/DT bits
+ * 0x0C: Watchdog (0.1 Second and 0.01 Second)
+ * 0x0D: Watchdog (0.1 Second and Second)
+ * 0x0E: Control A (BLF1, BLF2, PBS, PAB, TDF, KSF, WDF, IRQF)
+ * 0x0F: Control B (TE, CS, BME, TPE, TIE, KIE, WDE, WDS)
+ * 0x10: RAM Address (Extended RAM Address pointer)
+ * 0x11: Reserved
+ * 0x12: Reserved
+ * 0x13: RAM Data (Extended RAM Data at address pointed to by 0x10)
+ */
+export declare class RTCCard implements IO {
+    raiseIRQ: () => void;
+    raiseNMI: () => void;
+    private userSeconds;
+    private userMinutes;
+    private userHours;
+    private userDayOfWeek;
+    private userDate;
+    private userMonth;
+    private monthControl;
+    private userYear;
+    private userCentury;
+    private internalSeconds;
+    private internalMinutes;
+    private internalHours;
+    private internalDayOfWeek;
+    private internalDate;
+    private internalMonth;
+    private internalYear;
+    private internalCentury;
+    private alarmSeconds;
+    private alarmMinutes;
+    private alarmHours;
+    private alarmDayDate;
+    private watchdog1;
+    private watchdog2;
+    private watchdogCounterCentis;
+    private watchdogCycleCounter;
+    private controlA;
+    private controlB;
+    private ramAddress;
+    private ramData;
+    private cycleCounter;
+    private cpuFrequency;
+    private transferCycleCounter;
+    private pendingUserToInternal;
+    private userSyncNeeded;
+    private lastTEEnabled;
+    constructor();
+    /**
+     * Initialize RTC with current system time
+     */
+    private initializeWithCurrentTime;
+    /**
+     * Convert decimal to BCD (Binary Coded Decimal)
+     */
+    private decimalToBCD;
+    /**
+     * Convert BCD to decimal
+     */
+    private bcdToDecimal;
+    /**
+     * Get the number of days in a month
+     */
+    private getDaysInMonth;
+    /**
+     * Get next day of week
+     */
+    private getNextDayOfWeek;
+    private copyInternalToUser;
+    private copyUserToInternal;
+    private getTransferCyclesRequired;
+    private markUserTimeWrite;
+    /**
+     * Increment time by one second
+     */
+    private incrementTime;
+    /**
+     * Check if alarm should trigger
+     */
+    private checkAlarm;
+    private raiseInterruptIfEnabled;
+    private setKickstartFlag;
+    private decodeWatchdogCentis;
+    private reloadWatchdog;
+    private stepWatchdog;
+    read(address: number): number;
+    write(address: number, data: number): void;
+    tick(frequency: number): void;
+    reset(coldStart: boolean): void;
+}

package/dist/components/IO/SerialCard.d.ts

@@ -0,0 +1,76 @@
+import { IO } from '../IO';
+/**
+ * SerialCard - Emulates a 6551 ACIA (Asynchronous Communications Interface Adapter)
+ *
+ * Register Map:
+ * $00: Data Register (read/write)
+ * $01: Status Register (read) / Programmed Reset (write)
+ * $02: Command Register (write)
+ * $03: Control Register (write)
+ */
+export declare class SerialCard implements IO {
+    raiseIRQ: () => void;
+    raiseNMI: () => void;
+    transmit?: (data: number) => void;
+    private dataRegister;
+    private statusRegister;
+    private commandRegister;
+    private controlRegister;
+    private transmitBuffer;
+    private receiveBuffer;
+    private parityError;
+    private framingError;
+    private overrun;
+    private irqFlag;
+    private echoMode;
+    private cycleCounter;
+    private baudRate;
+    /**
+     * Read from ACIA register
+     */
+    read(address: number): number;
+    /**
+     * Write to ACIA register
+     */
+    write(address: number, data: number): void;
+    /**
+     * Read data from receive buffer
+     */
+    private readData;
+    /**
+     * Write data to transmit buffer
+     */
+    private writeData;
+    /**
+     * Read status register
+     */
+    private readStatus;
+    /**
+     * Write to command register
+     */
+    private writeCommand;
+    /**
+     * Write to control register
+     */
+    private writeControl;
+    /**
+     * Get baud rate from control register code
+     */
+    private getBaudRate;
+    /**
+     * Programmed reset
+     */
+    private programmedReset;
+    /**
+     * Tick - emulate ACIA timing
+     */
+    tick(frequency: number): void;
+    /**
+     * Reset the ACIA
+     */
+    reset(coldStart: boolean): void;
+    /**
+     * Receive data from external source
+     */
+    onData(data: number): void;
+}

package/dist/components/IO/Sound.d.ts

@@ -0,0 +1,120 @@
+import { IO } from '../IO';
+/**
+ * MOS 6581 SID (Sound Interface Device) Emulation
+ *
+ * Register Map ($00-$1C):
+ *   Voice 1: $00-$06
+ *   Voice 2: $07-$0D
+ *   Voice 3: $0E-$14
+ *   Filter:  $15-$17
+ *   Volume:  $18
+ *   Paddle:  $19-$1A (read-only)
+ *   OSC 3:   $1B (read-only)
+ *   ENV 3:   $1C (read-only)
+ *
+ * Each voice has:
+ *   Frequency  (16-bit, lo/hi)
+ *   Pulse Width (12-bit, lo/hi)
+ *   Control Register (waveform select, gate, sync, ring mod, test)
+ *   Attack/Decay (4-bit each)
+ *   Sustain/Release (4-bit each)
+ *
+ * Waveforms: Triangle, Sawtooth, Pulse, Noise
+ * Filter: 12-bit cutoff, resonance, low/band/high-pass, voice routing
+ *
+ * Clock rate: ~1 MHz (NTSC: 1,022,727 Hz, PAL: 985,248 Hz)
+ * Output: mono audio samples passed via callback to the host emulator
+ *
+ * Reference: MOS 6581 SID datasheet, reSID by Dag Lem
+ */
+/** Default SID clock rate (NTSC) */
+export declare const SID_CLOCK_NTSC = 1022727;
+export declare const SID_CLOCK_PAL = 985248;
+export declare const enum EnvelopeState {
+    ATTACK = 0,
+    DECAY = 1,
+    SUSTAIN = 2,
+    RELEASE = 3
+}
+export declare class SIDVoice {
+    accumulator: number;
+    frequency: number;
+    pulseWidth: number;
+    control: number;
+    prevGate: boolean;
+    noiseShift: number;
+    waveformOutput: number;
+    envelopeState: EnvelopeState;
+    envelopeLevel: number;
+    envelopeCounter: number;
+    attackRate: number;
+    decayRate: number;
+    sustainLevel: number;
+    releaseRate: number;
+    exponentialCounter: number;
+    exponentialCounterPeriod: number;
+    reset(): void;
+}
+export declare class Sound implements IO {
+    raiseIRQ: () => void;
+    raiseNMI: () => void;
+    /** Callback to push audio samples to the host emulator */
+    pushSamples?: (samples: Float32Array) => void;
+    /** Raw register file (write-only from CPU perspective, except reads at $19-$1C) */
+    private registers;
+    /** Three oscillator voices */
+    private voices;
+    /** Filter state */
+    private filterCutoff;
+    private filterResonance;
+    private filterRouting;
+    private filterMode;
+    private masterVolume;
+    /** Filter integrator state (continuous) */
+    private filterLP;
+    private filterBP;
+    private filterHP;
+    /** Cycle accumulator for sample rate conversion */
+    private cycleAccumulator;
+    /** Target audio sample rate */
+    sampleRate: number;
+    /** SID clock rate */
+    sidClock: number;
+    /** Internal sample buffer for pushing to host */
+    private sampleBuffer;
+    private sampleBufferIndex;
+    read(address: number): number;
+    write(address: number, data: number): void;
+    tick(frequency: number): void;
+    reset(coldStart: boolean): void;
+    private updateVoiceRegister;
+    private updateGlobalRegister;
+    private clockOneCycle;
+    private clockOscillator;
+    private generateWaveform;
+    private clockEnvelope;
+    /**
+     * Update the exponential counter period based on current envelope level.
+     * The real SID uses an exponential curve for decay/release by varying
+     * the counter period at specific envelope level thresholds.
+     */
+    private updateExponentialPeriod;
+    private generateSample;
+    /**
+     * Convert the 11-bit filter cutoff register value to a frequency in Hz.
+     * The SID's cutoff mapping is complex and varies between chips.
+     * This approximation covers the usable range (~30 Hz to ~12 kHz).
+     */
+    private computeFilterCutoff;
+    private flushSampleBuffer;
+    /** Get a voice for inspection */
+    getVoice(index: number): SIDVoice;
+    /** Get current register value */
+    getRegister(reg: number): number;
+    /** Get current filter cutoff frequency in Hz */
+    getFilterCutoffHz(): number;
+    /** Get master volume (0-15) */
+    getMasterVolume(): number;
+    /** Get filter routing bitmask */
+    getFilterRouting(): number;
+}