pico6502 Entwicklerhandbuch

Übersicht

• M6502CPU.c / M6502CPU.h ersetzen Z80CPU.c / Z80CPU.h als Haupt-Dispatch- und Treiberframework-Dateien.
• Der 6502 hat keinen separaten I/O-Adressraum — es gibt kein ioPtr[]-Array und keinen iomap-JSON-Abschnitt. Alle Peripheriegeräte werden als Blöcke vom Typ FUNC in der 64KB-Speicherbelegung virtualisiert.
• Das PIO-Bus-Interface (M6502.pio) implementiert eine Zweiphasen-PHI1/PHI2-Taktung anstelle des Z80-Einzeltaktmodells.
• Das Build-Zielverzeichnis ist src/model/Base6502 statt BaseZ80; der Build-Befehl lautet ./build_tzpuPico.sh 6502.
• Der JSON-CPU-Abschnittsschlüssel ist "6502" statt "z80" — wie z80[] ist er ein nach Flash-Partition indiziertes Array, und jeder Partitionseintrag trägt cputype ("6502" oder "6512") und dbeoverride.

Quellbaum

tzpuPico/
├── CMakeLists.txt                          Top-Level-Build-Datei
├── src/
│   ├── CMakeLists.txt                      Quellcode-Build-Datei — neue Treiberdateien hier hinzufügen
│   ├── M6502.c                             *** SCHLÜSSELDATEI: der 6502-Emulationskern — alle 151 offiziellen
│   │                                           Instruktionen + jeder undokumentierte Opcode; keine RP2350-
│   │                                           Abhängigkeit, baut daher nativ für Tests und den Simulator
│   ├── M6502CPU.c                          *** SCHLÜSSELDATEI: Core-1-Bus-Orchestrator, Treiberframework,
│   │                                           virtualFuncMap, Konfigurations-Parsing (Gegenstück zu Z80CPU.c)
│   ├── M6502dis.c                          Disassembler + Einzeilen-Assembler (Tabelle generiert aus
│   │                                           den eigenen Decode-Fällen von M6502.c)
│   ├── M6502.pio                           PIO-Bus-Engine — Pinbelegung des gepufferten v2.3-Interface; alle
│   │                                           Bus-SMs synchronisieren auf CLK2_IN
│   ├── dbgsh.c                             CPU-neutrale Debug-Shell (mit dem Z80 geteilt — Dispatch
│   │                                           über die t_CpuOps-Vtable)
│   ├── Z80CPU.c / Z80CPU.h                 Z80-Gegenstück (nicht in pico6502-Builds verwendet)
│   ├── FSPI.c / FSPI.h                     Flash-SPI-Interface (gemeinsam)
│   ├── ESP.c / ESP.h                       ESP32-Kommunikationsschicht (gemeinsam)
│   ├── psram.c / psram.h                   PSRAM-Allokation und -Verwaltung (gemeinsam)
│   ├── cJSON.c / cJSON.h                   JSON-Parser für config.json (gemeinsam)
│   ├── include/
│   │   ├── M6502CPU.h                      *** SCHLÜSSELDATEI: alle 6502-Typdefinitionen und Makros
│   │   ├── M6502.h                         Kern-Definitionen
│   │   ├── M6502dis.h                      Assembler-/Disassembler-API
│   │   ├── cpu.h                           t_CpuOps-Vtable + CPU_MEMBANKPTR()/CPU_PSRAM() —
│   │   │                                       das, was dbgsh CPU-neutral macht
│   │   ├── dbghooks.h                      Gemeinsame Breakpoint-/Debug-Hook-Definitionen
│   │   ├── flash_ram.h                     Flash-Konfigurationsspeicher + der nichtflüchtige BBC-Bereich
│   │   └── drivers/
│   │       ├── Other/
│   │       │   └── Open6502.h             Open6502-Treiber-Header
│   │       ├── I8271.h                    Intel-8271-Chipmodell-API (hostunabhängig)
│   │       ├── WD177x.h                   WD1770/1772/1773-Chipmodell-API (hostunabhängig)
│   │       ├── MC6854.h                   Motorola-MC6854-ADLC-Chipmodell-API (hostunabhängig)
│   │       └── Acorn/
│   │           ├── BBCModelB.h            BBC-B-Treiber-Header
│   │           ├── BBCCMT.h               UEF-Bandlaufwerk-Header
│   │           ├── BBCFDC.h               Header des virtuellen 8271-Floppy-Interface
│   │           ├── BBCMMC.h               Header der virtuellen MMFS-Karte
│   │           └── BBCNet.h               Header des virtuellen Econet-Moduls
│   ├── drivers/
│   │   ├── Other/
│   │   │   └── Open6502.c                 Vanilla-/Experimentier-Persona — ROM-Laden, Bank-0-ROM-
│   │   │                                       Schreibschutz (darauf läuft der Apple I)
│   │   ├── I8271.c                        Intel-8271-FDC-Chipmodell — Datenblatt-Befehlssatz, abstrakte Medien
│   │   ├── WD177x.c                       WD1770/1772/1773-FDC-Chipmodell — Typ I–IV, Roh-Spur-Lesen/Schreiben
│   │   ├── MC6854.c                       MC6854-ADLC-Chipmodell — FIFOs auf Frame-Ebene, Status, Interrupts
│   │   └── Acorn/
│   │       ├── BBCModelB.c                *** DER BBC-MODEL-B-TREIBER: Maschinenwissen für die Bus-
│   │       │                                   Engine (BBCModelB_Tuning), virtuelle Sideways-Sockel,
│   │       │                                   OS-Sockel, Model-A-RAM, Master-Modus, CMOS-/SWRAM-Persistenz
│   │       ├── BBCCMT.c                   *** ERSTES VIRTUELLES GERÄT: UEF-Bandlaufwerk — virtueller 6850-ACIA
│   │       │                                   + Serial ULA, virtuelle IRQ-Leitung, LOAD + SAVE, gzip-UEF
│   │       ├── BBCFDC.c                   Virtuelle Floppy-Anbindung: 8271 bei $FE80 oder 1770 + Latch (Acorn- /
│   │       │                                   Watford- / Master-Boards), INT→/NMI über den Geräte-Timer, zwei
│   │       │                                   Laufwerke aus SSD/DSD/DDS/DDD/ADF/ADL/MMB-Images (Seitenpaarung),
│   │       │                                   PSRAM-Write-Back-Cache
│   │       ├── BBCMMC.c                   Virtuelle MMFS-Karte: partielles User-VIA-Overlay, SPI-SD-Zustands-
│   │       │                                   automat, FAT16-Fassade über dem MMB, Write-Back-Cache
│   │       └── BBCNet.c                   Virtuelles Econet: ADLC bei $FEA0 + Stationsverknüpfungen, Vier-Wege-
│   │                                           Handshake ↔ AUN über den ESP32-UDP-Socket, PSRAM-Ringe
│   ├── test/
│   │   └── M6502/                         Host-native Konformitätstests (make -C src/test/M6502 run)
│   └── model/
│       ├── CMakeLists.txt                 Makro add_m6502_model_targets() — 4 Varianten pro Modell,
│       │                                       partielles LTO auf M6502.c + M6502CPU.c
│       ├── Base6502/                      Vanilla-Modell (INCLUDE_OPEN6502_DRIVERS)
│       │   ├── main.c                     Einstiegspunkt (Core-0-Service-Schleife + Core-1-Start, Flash-
│       │   │                                   Konfigurationsspeicher, Takt/Spannung, POR-Supervisor)
│       │   ├── main_memmap_partition_1.ld Linker-Skript für Slot 1
│       │   └── main_memmap_partition_2.ld Linker-Skript für Slot 2
│       ├── BBC6502/                       Base6502 + INCLUDE_ACORN_DRIVERS (verwendet Base6502/main.c wieder)
│       └── Bootloader/
│           ├── CMakeLists.txt
│           └── main.c                     Gemeinsamer Bootloader (gleich wie picoZ80)
├── sim/
│   ├── 6502/                              pico6502sim — eigenständiger Host-Simulator (siehe unten)
│   └── src/
│       ├── host_apple1.c                  Synthetischer Apple-I-Host
│       └── host_bbc.c                     Synthetischer BBC-Model-B-Host (System-VIA, Tastatur, MODE 7)
├── tools/econet/                          Mitgelieferte AUN-Daemons (aund, PiEconetBridge) + build.sh,
│                                               fileserver.sh, examples/, README.md
├── PIPELINE_REDESIGN.md                   Das Design-Protokoll der Bus-Engine-Geschwindigkeitskampagne
├── timing/, *.kvdat, *.py                 Logikanalysator-Aufzeichnungen (echter 6502 vs. pico6502) + Werkzeuge
└── esp32/
    ├── CMakeLists.txt
    ├── personas/                          config_<Partition1>_<Partition2>.json — Basic6502, Apple-I, BBC-B
    └── main/
        └── ...                            ESP32-Firmware (mit picoZ80 geteilt; CPU-bewusste Web-GUI)

Wesentliche Unterschiede zum picoZ80

Kein separater I/O-Adressraum

PIO-Bus-Interface-Unterschiede

PIO-Programmierung — Wie C-Code Buszyklen steuert

                  Core 1 (C code)                       PIO State Machines
                  ─────────────                         ──────────────────
    1. Core calls fetchOpcode →             m6502_addr: idling on the ladder — after each
       m6502FetchOpcodeFused(addr)           genuine PHI2 fall + tADS it polls the FIFO at
                  │                          4 rungs (~cycles 17/30/43/68)
    2. Shadow valid for addr?  ──yes──→     (serve: byte returned to the core NOW; a no-capture
                  │ no                        read may still run so the bus stays identical)
    3. Push {set y,5 | ~addr} ─────────→    m6502_addr: out x,16 / out exec,16
       (burst of 6)                          read_next: mov pins,!x  → A0–A15 driven
                  │                                     irq set 4    → "address valid"
                  │                          m6502_latch: wait irq4, wait PHI2 rise, spin while
                  │                                     high, sample AFTER the fall, push
                  │                          m6502_addr: jmp x-- (address ascends), next fall,
                  │                                     drive again … six bytes, one per cycle
    4. Pop RX FIFO ←───────────────────     one capture word per driven address
       verify against shadow (must match)
       extra bytes → harvest buffer
                  │
    5. Core executes; operands come
       from the harvest buffer / shadow
       with zero bus operations

    WRITE: push {data} to m6502_data first, then {jmp wdrive | ~addr} to m6502_addr.
           wdrive: set R/W low, drive address — m6502_data (wait 0 gpio RNW) drives D0–D7,
           start_addr restores R/W high at the next fall (+~45ns hold) — one cycle, one strobe.
    I/O:   push a gated word (irq0 handshake) — the classic serialised cycle via m6502_cycle,
           followed by the I/O chase (a no-capture park read of $FFFC).

t_6502PSRAM-Struktur

// src/include/M6502CPU.h (simplified)
typedef struct {
    uint8_t      RAM[MAX_MEMORY_BANKS * MEMORY_PAGE_SIZE]; // 64 banks × 64KB = 4MB RAM/ROM area
    MemoryFunc   memPtr[MEMORY_PAGE_SIZE];                  // 64K per-byte read redirect (PTR type)
    MemoryFunc   memioPtr[MEMORY_PAGE_SIZE];                // 64K memory-mapped handler array (FUNC type)
    // NOTE: no ioPtr[] — the 6502 has no separate I/O space
} t_6502PSRAM;

Handler-Funktionssignatur

// Handler called for MEMBANK_TYPE_FUNC blocks on every access
typedef uint8_t (*MemoryFunc)(M6502CPU *cpu, bool read, uint16_t addr, uint8_t data);

// Parameters:
//   cpu  — pointer to the M6502CPU struct (access PSRAM, state, queues via this)
//   read — true for a 6502 read cycle (RNW=1), false for a write cycle (RNW=0)
//   addr — 16-bit address that triggered this handler
//   data — byte written (only meaningful when read=false)
// Return:
//   byte to place on the data bus (only meaningful when read=true)

Debug-Shell — Eine Shell, zwei CPUs

Treiberframework

• Der virtualFuncMap[]-Registrierungstabelle und wie das JSON-Feld "name" einer Treiber-Init-Funktion zugeordnet wird.
• Der VirtualFunc-Typdefinition und dem M6502CPU_getVirtualFunc()-Lookup.
• Dem zweiphasigen Init-Ablauf (Validierungsdurchlauf, dann Konfigurationsdurchlauf).
• Den Treiber-Lifecycle-Callbacks: reset_ptr, poll_ptr, task_ptr.

Der Open6502-Treiber

Core-1-Dispatch-Schleife

1. Power-on-Supervisor: den Host im Reset halten, bis die Dienste von Core 0 bereit sind (Obergrenze 15 s); R/W auf high parken.
2. Hold-/Park-Anforderungen von Core 0 mit einer RAM-residenten Warteschleife bedienen (sicher während des Flash-Löschens), ebenso die entprellte /RES-Leitung (die Reset-Sequenz läuft nach dem Loslassen), den DBE-Busfreigabe-Hold des 6512 und den /NMI-Flankendetektor.
3. g_fastTickHook aufrufen, falls ein Treiber einen installiert hat (die Baud-Taktung des Bandlaufwerks), und den poll_ptr der Treiber etwa alle 250 ms.
4. m6502_run(1024) ausführen — oder jeweils eine Instruktion im Einzelschritt-, Breakpoint- oder Trace-Modus, mit optionaler Opcode-Wiederlese-Verifikation. Darin lösen die Callbacks fetchOpcode/readMem/writeMem des Kerns jede Adresse gegen _membankPtr[addr >> 9] auf und dispatchen nach Blocktyp: PHYSICAL / PHYSICAL_HW (eine Busoperation über die obige Engine), RAM / ROM (PSRAM), FUNC (memioPtr[addr]), PTR (memPtr[]-Umleitung).
5. Interrupts einmal pro Instruktion abtasten — der physische /IRQ-Schnappschuss ODER-verknüpft mit g_m6502VirtIrq — und IRQ/NMI über eine Sieben-Zyklen-Sequenz ausliefern, die jeden laufenden Prefetch abräumt.

// Simplified M6502CPU_readMem / M6502CPU_writeMem dispatch
uint8_t M6502CPU_readMem(M6502CPU *cpu, uint16_t addr)
{
    uint32_t entry = cpu->_membankPtr[addr >> 9];
    uint8_t  type  = (entry >> 24) & 0xFF;
    uint8_t  bank  = (entry >> 16) & 0xFF;
    uint32_t base  = (entry & 0xFFFF) << 9;

    switch(type)
    {
        case MEMBANK_TYPE_RAM:
        case MEMBANK_TYPE_ROM:
            return cpu->_6502PSRAM->RAM[(bank * MEMORY_PAGE_SIZE) + addr];

        case MEMBANK_TYPE_FUNC:
            if(cpu->_6502PSRAM->memioPtr[addr] != NULL)
                return cpu->_6502PSRAM->memioPtr[addr](cpu, true, addr, 0);
            return 0x00;

        case MEMBANK_TYPE_PTR:
            if(cpu->_6502PSRAM->memPtr[addr] != NULL)
                return cpu->_6502PSRAM->memPtr[addr](cpu, true, addr, 0);
            return 0x00;

        case MEMBANK_TYPE_PHYSICAL:
        default:
            return 0xFF;  // Pass-through to real host hardware
    }
}

Einen neuen Treiber schreiben

1. Eine Header-Datei in src/include/drivers/<Family>/MyDriver.h anlegen
2. Eine Implementierungsdatei in src/drivers/<Family>/MyDriver.c anlegen
3. Die Compile-Definition INCLUDE_<FAMILY>_DRIVERS der Familie für den Modell-Build aktivieren (Treiberquellen werden in-situ per #include eingebunden, nicht als separate Übersetzungseinheiten aufgeführt)
4. Den Treiber in M6502CPU.c unter dem #ifdef INCLUDE_<FAMILY>_DRIVERS-Guard einbinden
5. Den Treiber in virtualFuncMap[] in M6502CPU.c registrieren
6. Einen JSON-Treibereintrag in config.json hinzufügen

Minimale Treibervorlage

// src/include/drivers/Acorn/VIA6522.h
#ifndef VIA6522_H
#define VIA6522_H

#include "M6502CPU.h"

int VIA6522_Init(M6502CPU *cpu, t_drvConfig *drvConfig, int pass);

#endif

// src/drivers/BBC/VIA6522.c
#include "../../include/M6502CPU.h"
#include "../../include/drivers/Acorn/VIA6522.h"

// --- Internal state ---
typedef struct {
    uint8_t  regs[16];      // VIA internal registers (ORB, ORA, DDRB, DDRA, T1CL, T1CH, ...)
    bool     irqPending;
} t_VIA6522State;

static t_VIA6522State ViaState = { .irqPending = false };

// --- Memory handler (called for every access to 0xC000–0xC00F) ---
static uint8_t VIA6522_Handler(M6502CPU *cpu, bool read, uint16_t addr, uint8_t data)
{
    uint8_t reg = addr & 0x0F;   // VIA has 16 internal registers

    if(read)
    {
        return ViaState.regs[reg];
    }
    else
    {
        ViaState.regs[reg] = data;
        // TODO: implement timer, shift register, port logic as needed
        return 0;
    }
}

// --- Reset handler (called when host system resets) ---
static uint8_t VIA6522_Reset(M6502CPU *cpu)
{
    memset(&ViaState.regs, 0, sizeof(ViaState.regs));
    ViaState.irqPending = false;
    return 0;
}

// --- Init function (called during JSON config parse) ---
int VIA6522_Init(M6502CPU *cpu, t_drvConfig *drvConfig, int pass)
{
    if(pass == 0)
    {
        // Validation pass — just check the name matches
        return (strcasecmp(drvConfig->name, "via6522") == 0) ? 1 : 0;
    }

    // Configuration pass — install handlers
    // Install the handler for all 16 VIA registers at 0xC000–0xC00F
    for(uint16_t addr = 0xC000; addr <= 0xC00F; addr++)
    {
        cpu->_6502PSRAM->memioPtr[addr] = VIA6522_Handler;
    }

    // Register reset callback
    cpu->reset_ptr = VIA6522_Reset;

    debugf("VIA6522: Initialised at 0xC000–0xC00F\n");
    return 1;
}

JSON-Konfiguration

{
  "rp2350": {
    "6502": {
      "memory": [
        { "enable":1, "addr":"0x0000", "size":"0xC000",
          "type":"RAM",  "bank":0, "task":"", "file":"" },
        { "enable":1, "addr":"0xC000", "size":"0x0010",
          "type":"FUNC", "bank":0, "task":"via6522", "file":"" },
        { "enable":1, "addr":"0xE000", "size":"0x2000",
          "type":"ROM",  "bank":0, "task":"", "file":"/ROM/bios.rom" }
      ],
      "drivers": [
        { "enable":1, "name":"via6522" }
      ]
    }
  }
}

In virtualFuncMap registrieren

// In M6502CPU.c — add to virtualFuncMap[]
static const t_VirtualFuncMap virtualFuncMap[] = {
    { "Open6502",  Open6502_Init },    // existing entries
    { "BBC-B",     BBCModelB_Init },
    { "via6522",   VIA6522_Init  },    // your new driver
    { NULL, NULL }                     // terminator
};

CMakeLists.txt-Änderung

# The Acorn family already exists — it is what the BBC6502 model enables:
#   src/model/CMakeLists.txt
#   add_m6502_model_targets(BBC6502 "" "INCLUDE_OPEN6502_DRIVERS;INCLUDE_ACORN_DRIVERS")
# A new family gets its own INCLUDE_<FAMILY>_DRIVERS define in the model's list.

# And in M6502CPU.c, alongside the existing includes:
#ifdef INCLUDE_ACORN_DRIVERS
#include "../drivers/Acorn/BBCModelB.c"
#include "../drivers/Acorn/BBCCMT.c"      // binds to the persona, hence after it
#include "../drivers/Acorn/VIA6522.c"     // your new driver
#endif

Erstellen und Testen

# From the project root — Base6502 only, or the full build for BBC6502
./build_tzpuPico.sh 6502
./build_tzpuPico.sh

# Flash via USB mass-storage
cp build/bin/model/BBC6502/BBC6502_0x10020000.uf2 /media/$USER/RPI-RP2/

# Or OTA: upload via http://<device-ip>/ota-rp2350.htm

# Or prove the change first with no hardware at all:
cd sim/6502 && mkdir -p build && cd build && cmake .. && make -j$(nproc)
cd ../.. && ./run.sh apple1

Speicher-Hook-Muster

FUNC-Block — Virtuelles Peripheriegerät

// Install handler for address range 0xD000–0xD0FF (256-byte peripheral block)
for(uint16_t addr = 0xD000; addr <= 0xD0FF; addr++)
{
    cpu->_6502PSRAM->memioPtr[addr] = MyPeripheral_Handler;
}

RAM-Schreib-Abfangen

// Handler intercepts writes; passes reads to PSRAM
static uint8_t ZeroPage_Intercept(M6502CPU *cpu, bool read, uint16_t addr, uint8_t data)
{
    if(read)
    {
        // Read from PSRAM normally
        return cpu->_6502PSRAM->RAM[addr];
    }
    else
    {
        // Write to PSRAM and update shadow state
        cpu->_6502PSRAM->RAM[addr] = data;
        MyDriver_OnZeroPageWrite(addr, data);
        return 0;
    }
}

// In init: set the block type to FUNC and install the handler
cpu->_membankPtr[0x0000 >> 9] = MEMBANK_ENCODE(MEMBANK_TYPE_FUNC, 0, 0x0000);
cpu->_6502PSRAM->memioPtr[0x0000] = ZeroPage_Intercept;
// ... repeat for each 512-byte block in the range

Verteilte / einzelne Adressen

// Only addresses 0xFFFE and 0xFFFF (6502 reset vector) are intercepted
cpu->_6502PSRAM->memioPtr[0xFFFE] = ResetVector_Lo_Handler;
cpu->_6502PSRAM->memioPtr[0xFFFF] = ResetVector_Hi_Handler;

Maschinen-Personas — Apple I und der BBC Model B

Der BBC-B-Treiber — Maschinenwissen als Treiber

void BBCModelB_Tuning(t_M6502CPU *cpu)
{
    g_ioRegionLo   = 0xFC00;   // FRED/JIM/SHEILA: the engine never speculates into or across it.
    g_ioRegionHi   = 0xFF00;
    g_shadowWrLo   = 0x0000;   // main RAM: this CPU is the sole writer -> write-through shadow.
    g_shadowWrHi   = 0x8000;
    g_pageRegAddr  = 0xFE30;   // ROMSEL, partially decoded (hence the mask)...
    g_pageRegMask  = 0xFFF0;
    g_pageRegionLo = 0x8000;   // ...banks the sideways ROM window.
    g_pageRegionHi = 0xC000;
    g_burstSpec    = 6;        // MMFS-safe at 6 with ROMSEL declared (the map barrier).
}

• Sideways-ROM/RAM-Sockel — sechzehn ROMSEL-Bänke können jeweils virtuell aus dem PSRAM bestückt werden (Pool-Bänke 1–4, 16K pro Sockel): ein ROM-Image von SD (virtuelles ROM) oder beschreibbares Sideways-RAM. Ein aktivierter Sockel überlagert die physische Bank; der ROMSEL-Schreibzugriff erreicht weiterhin das Hardware-Latch, damit die eigene Dekodierung des Hosts konsistent bleibt, aber solange eine überlagerte Bank ausgewählt ist, wird jeder Lese- und Schreibzugriff auf $8000–$BFFF aus dem PSRAM bedient. So wird MMFS oder ein Sprach-ROM hinzugefügt, ohne die Maschine zu öffnen.
• OS-Sockel — ein 16K-OS-Image, über $C000–$FFFF virtualisiert, wobei das I/O-Fenster durchgereicht und die $FF00–$FFFF-Vektoren byteweise behandelt werden; fileoffset wählt das OS aus einem größeren (MegaROM-)Image aus.
• Model-A-RAM — 16K PSRAM-gestütztes RAM, über $4000–$7FFF gelegt, sodass das OS einen 32K-Model-B sieht. Null Buszyklen — was zugleich der Vorbehalt ist: die Video-ULA holt den Bildschirmspeicher aus dem Host-DRAM und kann virtuelles RAM nicht sehen, sodass das Bildschirmverhalten auf einem echten Model A noch zu verifizieren ist (eine Write-Through-Option, wie sie der PCW-Videopfad des picoZ80 verwendet, ist der wahrscheinliche nächste Schritt).
• Master-Modus — LYNNE 20K Shadow, HAZEL 8K und ANDY 4K mit virtualisiertem ACCCON ($FE34), ein virtuelles CMOS/RTC auf dem System-VIA, und der CMOS-Kern erzwungen, weil MOS 3.x 65C12-Code ist. Erwartet ein MOS-3.x-Image im OS-Sockel. Das DFS (Bank 9) und ADFS (Bank 13) des MegaROM werden nur voreingestellt, wenn BBCFDC_MasterFdc() einen virtuellen 1770 auf dem Master-Board meldet (oder presetdiscroms es erzwingt); andernfalls bleibt Bank 13 außerhalb der Alias-Maske, damit das eigene Filing-ROM des Hosts durchscheint, passend zum FILE-13-CMOS-Standard.
• Persistenz — virtuelles CMOS und Sideways-RAM werden auf SD gespeichert (Standard), in den nichtflüchtigen Flash-Bereich (flash_ram.h, geschrieben über eine MSG_WRITE_NVRAM-Inter-Core-Nachricht, während Core 1 im RAM geparkt ist) oder gar nicht.
• Interfaces — das if[]-Array bindet CMT-UEF (Bandlaufwerk), BBC-FDC (virtueller 8271 oder WD1770 mit zwei Laufwerken), BBC-MMC (virtuelle MMFS-Karte) und BBC-NET (virtuelles Econet-Modul, AUN über IP). Jedes wird von M6502CPU_configDriversFromJSON in den SetConfig-Aufruf des Interface übernommen, bevor das Init der Persona läuft, und jedes stellt die Einstiegspunkte Init / Remap / FastTick / Poll / HostReset bereit, die die Persona aufruft.

BBCCMT — das erste virtuelle Gerät und die virtuelle IRQ-Leitung

BBCFDC und BBCMMC — Chipmodelle, Block-Caches und NMI-Besitz

BBCNet — Econet als Protokollbrücke

Host-Simulator (pico6502sim)

Erstellen und Ausführen

cd sim/6502
mkdir -p build && cd build
cmake .. && make -j$(nproc)

# Launch a machine (from sim/)
../run.sh apple1        # Apple I, synthetic host, 1.023 MHz
../run.sh bbcmodelb     # BBC Model B, synthetic host, 2 MHz — MODE 7 on the terminal
../run.sh bbcmaster     # BBC Master 128, headless, 2 MHz (CMOS core)

Der synthetische Apple-I-Host

Der synthetische BBC-Model-B-Host

Eine eigene Host-Maschine anbinden

typedef struct {
    uint8_t (*fetchOp) (uint16_t addr);                // opcode fetch (SYNC asserted)
    uint8_t (*readMem) (uint16_t addr);                // data read
    void    (*writeMem)(uint16_t addr, uint8_t data);  // write
    void    (*hostReset)(void);                        // host-side reset
} t_Sim6502BusOps;

void sim6502_setBusOps(const t_Sim6502BusOps *ops);    // NULL restores the floating bus
void sim6502_assertIRQ(bool active);                   // level: re-assert every cycle while low
void sim6502_assertNMI(bool active);                   // edge-triggered

Core 0 / Core 1-Interaktion

Häufige Fallstricke

Referenz-Websites

Regulatorischer Hinweis für Funkgeräte