- InputInterpreter läuft jetzt in eigenem Background-Thread (Vollgas) - ManualResetEventSlim (_runSignal) blockiert Thread bis RUN aufgerufen wird - SemaphoreSlim (_inputSignal) ersetzt Busy-Wait bei INPUT - Stop() und StopThread() entsperren alle Waits sauber vor Join - _running/_waitingForInput als volatile - MemoryModel: internes Locking (lock(Lock)) auf allen Read/Write/ReadFlat/WriteFlat - Lock-Objekt öffentlich für Bulk-Operationen (Renderer) - MicrononaRenderer: hält Lock für gesamten Frame statt pro ReadFlat-Aufruf Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
248 lines
No EOL
9.9 KiB
C#
248 lines
No EOL
9.9 KiB
C#
/// <summary>
|
||
/// Memory model for Micronona 256.
|
||
///
|
||
/// Address space as seen by the CPU and all high-level layers (Lua, TinyBasic, host):
|
||
///
|
||
/// 0x0000 – 0xDEFF Fixed RAM (56,832 bytes, general purpose)
|
||
/// 0xDF00 – 0xDFFF Hardware registers (256 bytes, I/O)
|
||
/// 0xE000 – 0xFFFF Bank window (8KB, switchable via REG_BANK)
|
||
///
|
||
/// Extended RAM: 256 banks × 8KB = 2MB total.
|
||
/// The bank window at 0xE000 maps to one 8KB slice of extended RAM at a time.
|
||
/// Bank switching is done by writing the desired bank number to REG_BANK (0xDF01).
|
||
///
|
||
/// Bank layout conventions:
|
||
/// Bank 0 Text buffer (40×18×3 bytes: char, fg, bg) starts at offset 0
|
||
/// Bank 255 Font bitmaps (256 glyphs × 8×10 bytes) at end of extended RAM
|
||
///
|
||
/// The CPU and all high-level layers use Read(address)/Write(address) exclusively.
|
||
/// Bank switching is transparent — callers set REG_BANK and then access 0xE000–0xFFFF.
|
||
///
|
||
/// The host (renderer, font loader, etc.) uses ReadFlat/WriteFlat to access extended
|
||
/// RAM directly by absolute byte offset, without affecting the bank register.
|
||
/// </summary>
|
||
public class MemoryModel
|
||
{
|
||
// -------------------------------------------------------------------------
|
||
// Layout constants
|
||
// -------------------------------------------------------------------------
|
||
|
||
public const int BankCount = 25;
|
||
public const int BankSize = 8192; // 8KB per bank
|
||
public const int FixedRamSize = 0xE000; // 56KB fixed RAM (0x0000–0xDFFF)
|
||
public const int IoBase = 0xDF00; // I/O register block start
|
||
public const int IoSize = 256; // 256 I/O registers
|
||
public const int BankWindowBase = 0xE000; // Bank window start address
|
||
|
||
// -------------------------------------------------------------------------
|
||
// I/O register offsets (relative to IoBase = 0xDF00)
|
||
// -------------------------------------------------------------------------
|
||
|
||
public const int REG_MODE = 0x00; // Display mode: 0 = text, 1 = graphics
|
||
public const int REG_BANK = 0x01; // Active bank in the 0xE000 window (0–255)
|
||
public const int REG_KEY_CHAR = 0x02; // Next keypress character (0 = none)
|
||
public const int REG_KEY_FLAGS = 0x03; // Modifier flags (Shift, Ctrl, …)
|
||
public const int REG_TIMER = 0x04; // Auto-incrementing timer; saturates at 255; resets on read
|
||
public const int REG_VSYNC = 0x05; // VSync flag; set by host each frame
|
||
public const int REG_CURSOR_COL = 0x06; // Text cursor position horizontally
|
||
public const int REG_CURSOR_ROW = 0x07; // Text cursor position vertically
|
||
|
||
// -------------------------------------------------------------------------
|
||
// Text mode layout (Bank 0, starting at offset 0)
|
||
// Each cell is 3 bytes: character code, foreground RGB332, background RGB332
|
||
// -------------------------------------------------------------------------
|
||
|
||
public const byte TextCols = 40;
|
||
public const int TextRows = 18;
|
||
public const int TextCellSize = 3;
|
||
public const int TextBankIndex = 0; // Text buffer lives in bank 0
|
||
public const int TextBufferSize = TextCols * TextRows * TextCellSize; // 2160 bytes
|
||
|
||
// Default terminal colors (RGB332)
|
||
public const byte DefaultFg = 0x1C; // Bright green: R=0, G=224, B=0
|
||
public const byte DefaultBg = 0x08; // Dark green: R=0, G=64, B=0
|
||
|
||
// -------------------------------------------------------------------------
|
||
// Font layout (Bank 255, starting at offset 0)
|
||
// 256 glyphs, each 8 pixels wide × 10 pixels tall, 1 bit per pixel packed
|
||
// into 2 bytes per row (only 8 bits used), so 10 bytes per glyph.
|
||
// -------------------------------------------------------------------------
|
||
|
||
public const int FontGlyphWidth = 8;
|
||
public const int FontGlyphHeight = 10;
|
||
public const int FontBankIndex = BankCount-1;
|
||
public const int FontSize = 256 * FontGlyphWidth * FontGlyphHeight; // 20480 bytes
|
||
|
||
// -------------------------------------------------------------------------
|
||
// Threading
|
||
// -------------------------------------------------------------------------
|
||
|
||
/// <summary>
|
||
/// Shared lock for all memory access. Callers may acquire this for bulk
|
||
/// operations (e.g. the renderer locks once per frame instead of once per
|
||
/// ReadFlat call). C# Monitor is re-entrant on the same thread, so nested
|
||
/// lock(Lock) blocks are safe.
|
||
/// </summary>
|
||
public readonly object Lock = new();
|
||
|
||
// -------------------------------------------------------------------------
|
||
// Internal storage
|
||
// -------------------------------------------------------------------------
|
||
|
||
// Fixed RAM: 0x0000–0xDEFF (excludes I/O block)
|
||
private readonly byte[] _fixedRam = new byte[FixedRamSize];
|
||
|
||
// I/O registers: 0xDF00–0xDFFF
|
||
private readonly byte[] _io = new byte[IoSize];
|
||
|
||
// Extended RAM: 256 × 8KB = 2MB, bank-switched into 0xE000–0xFFFF
|
||
private readonly byte[] _extendedRam = new byte[BankCount * BankSize];
|
||
|
||
// -------------------------------------------------------------------------
|
||
// Constructor
|
||
// -------------------------------------------------------------------------
|
||
|
||
public MemoryModel()
|
||
{
|
||
// Bank 0 active by default
|
||
_io[REG_BANK] = TextBankIndex;
|
||
|
||
// Fill text buffer with spaces in default colors
|
||
int textBase = TextBankIndex * BankSize;
|
||
for (int i = 0; i < TextCols * TextRows; i++)
|
||
{
|
||
_extendedRam[textBase + i * TextCellSize + 0] = 0x20; // Space
|
||
_extendedRam[textBase + i * TextCellSize + 1] = DefaultFg;
|
||
_extendedRam[textBase + i * TextCellSize + 2] = DefaultBg;
|
||
}
|
||
}
|
||
|
||
// -------------------------------------------------------------------------
|
||
// CPU / high-level interface (Read/Write by 16-bit address)
|
||
// This is the only interface the CPU emulator, Lua, and TinyBasic use.
|
||
// -------------------------------------------------------------------------
|
||
|
||
/// <summary>
|
||
/// Read a single byte from the 16-bit address space.
|
||
/// </summary>
|
||
public byte Read(ushort address)
|
||
{
|
||
lock (Lock)
|
||
{
|
||
if (address >= IoBase && address < IoBase + IoSize)
|
||
return ReadIo(address - IoBase);
|
||
if (address >= BankWindowBase)
|
||
return ReadBank(address - BankWindowBase);
|
||
return _fixedRam[address];
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Write a single byte to the 16-bit address space.
|
||
/// </summary>
|
||
public void Write(ushort address, byte value)
|
||
{
|
||
lock (Lock)
|
||
{
|
||
if (address >= IoBase && address < IoBase + IoSize)
|
||
WriteIo(address - IoBase, value);
|
||
else if (address >= BankWindowBase)
|
||
WriteBank(address - BankWindowBase, value);
|
||
else
|
||
_fixedRam[address] = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Write multiple bytes sequentially starting at address.
|
||
/// Convenient for loading font glyphs, tile data, strings, etc.
|
||
/// Example: mem.Write(0xE000, 0x48, 0x1C, 0x08);
|
||
/// </summary>
|
||
public void Write(ushort address, params byte[] data)
|
||
{
|
||
lock (Lock)
|
||
{
|
||
for (int i = 0; i < data.Length; i++)
|
||
WriteUnlocked((ushort)(address + i), data[i]);
|
||
}
|
||
}
|
||
|
||
private void WriteUnlocked(ushort address, byte value)
|
||
{
|
||
if (address >= IoBase && address < IoBase + IoSize)
|
||
WriteIo(address - IoBase, value);
|
||
else if (address >= BankWindowBase)
|
||
WriteBank(address - BankWindowBase, value);
|
||
else
|
||
_fixedRam[address] = value;
|
||
}
|
||
|
||
// -------------------------------------------------------------------------
|
||
// Host interface (flat access to extended RAM)
|
||
// Used by the renderer, font loader, and other host-side components.
|
||
// Does not affect the bank register; does not go through the bank window.
|
||
// Address is an absolute byte offset into the 2MB extended RAM (0–2097151).
|
||
// -------------------------------------------------------------------------
|
||
|
||
/// <summary>
|
||
/// Read a single byte from extended RAM by absolute offset.
|
||
/// </summary>
|
||
public byte ReadFlat(int address)
|
||
{
|
||
lock (Lock) return _extendedRam[address];
|
||
}
|
||
|
||
/// <summary>
|
||
/// Write one or more bytes to extended RAM starting at absolute offset.
|
||
/// Example: mem.WriteFlat(255 * BankSize, 0x00, 0x18, 0x3C, 0x66, ...);
|
||
/// </summary>
|
||
public void WriteFlat(int address, params byte[] data)
|
||
{
|
||
lock (Lock)
|
||
{
|
||
for (int i = 0; i < data.Length; i++)
|
||
_extendedRam[address + i] = data[i];
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Return a Span over one full bank in extended RAM.
|
||
/// Useful for bulk operations like SDL texture uploads.
|
||
/// </summary>
|
||
public Span<byte> GetBankSpan(int bank)
|
||
=> _extendedRam.AsSpan(bank * BankSize, BankSize);
|
||
|
||
// -------------------------------------------------------------------------
|
||
// Internal helpers
|
||
// -------------------------------------------------------------------------
|
||
|
||
private byte ReadIo(int reg)
|
||
{
|
||
if (reg == REG_TIMER)
|
||
{
|
||
// Timer resets to 0 on read (after returning current value)
|
||
byte val = _io[REG_TIMER];
|
||
_io[REG_TIMER] = 0;
|
||
return val;
|
||
}
|
||
return _io[reg];
|
||
}
|
||
|
||
private void WriteIo(int reg, byte value)
|
||
{
|
||
// All register writes are simple stores; bank switch takes effect immediately
|
||
_io[reg] = value;
|
||
}
|
||
|
||
private byte ReadBank(int offset)
|
||
{
|
||
int bank = _io[REG_BANK];
|
||
return _extendedRam[bank * BankSize + offset];
|
||
}
|
||
|
||
private void WriteBank(int offset, byte value)
|
||
{
|
||
int bank = _io[REG_BANK];
|
||
_extendedRam[bank * BankSize + offset] = value;
|
||
}
|
||
} |