pico6502 Guide du Developpeur

Vue d'ensemble

• M6502CPU.c / M6502CPU.h remplacent Z80CPU.c / Z80CPU.h comme fichiers principaux de dispatch et de framework de pilotes.
• Le 6502 n'a pas d'espace d'adressage E/S séparé — il n'y a pas de tableau ioPtr[] et pas de section JSON iomap. Tous les périphériques sont virtualisés sous forme de blocs de type FUNC dans la carte mémoire de 64 Ko.
• L'interface bus PIO (M6502.pio) implémente une horloge biphasée PHI1/PHI2 plutôt que le modèle à horloge unique du Z80.
• Le répertoire cible de build est src/model/Base6502 plutôt que BaseZ80 ; la commande de build est ./build_tzpuPico.sh 6502.
• La clé de section CPU du JSON est "6502" plutôt que "z80" — comme z80[], c'est un tableau indexé par partition flash, et chaque entrée de partition porte cputype ("6502" ou "6512") et dbeoverride.

Arborescence des sources

tzpuPico/
├── CMakeLists.txt                          Fichier de build de niveau supérieur
├── src/
│   ├── CMakeLists.txt                      Fichier de build au niveau source — ajoutez ici les nouveaux fichiers pilotes
│   ├── M6502.c                             *** FICHIER CLÉ : le cœur d'émulation 6502 — les 151 instructions
│   │                                           officielles + tous les opcodes non documentés ; aucune dépendance
│   │                                           RP2350, il se compile donc nativement pour les tests et le sim
│   ├── M6502CPU.c                          *** FICHIER CLÉ : orchestrateur du bus sur Core 1, framework de pilotes,
│   │                                           virtualFuncMap, analyse de la config (miroir de Z80CPU.c)
│   ├── M6502dis.c                          Désassembleur + assembleur une ligne (table générée à partir
│   │                                           des propres cas de décodage de M6502.c)
│   ├── M6502.pio                           Moteur de bus PIO — brochage de l'interface bufferisée v2.3 ; toutes les
│   │                                           SM du bus se synchronisent sur CLK2_IN
│   ├── dbgsh.c                             Shell de débogage indépendant du CPU (partagé avec le Z80 — dispatch
│   │                                           via la vtable t_CpuOps)
│   ├── Z80CPU.c / Z80CPU.h                 Équivalent Z80 (non utilisé pour les builds pico6502)
│   ├── FSPI.c / FSPI.h                     Interface SPI flash (partagé)
│   ├── ESP.c / ESP.h                       Couche de communication ESP32 (partagé)
│   ├── psram.c / psram.h                   Allocation et gestion de la PSRAM (partagé)
│   ├── cJSON.c / cJSON.h                   Parseur JSON pour config.json (partagé)
│   ├── include/
│   │   ├── M6502CPU.h                      *** FICHIER CLÉ : toutes les définitions de types et macros 6502
│   │   ├── M6502.h                         Définitions du cœur
│   │   ├── M6502dis.h                      API assembleur/désassembleur
│   │   ├── cpu.h                           vtable t_CpuOps + CPU_MEMBANKPTR()/CPU_PSRAM() —
│   │   │                                       ce qui rend dbgsh indépendant du CPU
│   │   ├── dbghooks.h                      Définitions partagées des points d'arrêt/hooks de débogage
│   │   ├── flash_ram.h                     Stockage de la config en flash + la région non volatile BBC
│   │   └── drivers/
│   │       ├── Other/
│   │       │   └── Open6502.h             En-tête du pilote Open6502
│   │       ├── I8271.h                    API du modèle de puce Intel 8271 (indépendant de l'hôte)
│   │       ├── WD177x.h                   API du modèle de puce WD1770/1772/1773 (indépendant de l'hôte)
│   │       ├── MC6854.h                   API du modèle de puce ADLC Motorola MC6854 (indépendant de l'hôte)
│   │       └── Acorn/
│   │           ├── BBCModelB.h            En-tête du pilote BBC-B
│   │           ├── BBCCMT.h               En-tête du lecteur de cassettes UEF
│   │           ├── BBCFDC.h               En-tête de l'interface disquette 8271 virtuelle
│   │           ├── BBCMMC.h               En-tête de la carte MMFS virtuelle
│   │           └── BBCNet.h               En-tête du module Econet virtuel
│   ├── drivers/
│   │   ├── Other/
│   │   │   └── Open6502.c                 Persona vanille/expérimentateur — chargement de ROM, protection
│   │   │                                       en écriture de la ROM de la banque 0 (l'Apple I tourne dessus)
│   │   ├── I8271.c                        Modèle de puce FDC Intel 8271 — jeu de commandes de la datasheet, média abstrait
│   │   ├── WD177x.c                       Modèle de puce FDC WD1770/1772/1773 — Types I–IV, lecture/écriture de piste brute
│   │   ├── MC6854.c                       Modèle de puce ADLC MC6854 — FIFO au niveau trame, état, interruptions
│   │   └── Acorn/
│   │       ├── BBCModelB.c                *** LE PILOTE BBC MODEL B : connaissance de la machine pour le moteur
│   │       │                                   de bus (BBCModelB_Tuning), supports sideways virtuels,
│   │       │                                   support OS, RAM Model A, mode Master, persistance CMOS/SWRAM
│   │       ├── BBCCMT.c                   *** PREMIER PÉRIPHÉRIQUE VIRTUEL : lecteur de cassettes UEF — ACIA 6850 virtuel
│   │       │                                   + Serial ULA, ligne IRQ virtuelle, LOAD + SAVE, UEF gzip
│   │       ├── BBCFDC.c                   Glu disquette virtuelle : 8271 à $FE80 ou 1770 + latch (cartes Acorn /
│   │       │                                   Watford / Master), INT→/NMI via le timer de périphérique, deux
│   │       │                                   lecteurs à partir d'images SSD/DSD/DDS/DDD/ADF/ADL/MMB (appariement des faces),
│   │       │                                   cache PSRAM à écriture différée
│   │       ├── BBCMMC.c                   Carte MMFS virtuelle : recouvrement partiel du User VIA, machine d'état
│   │       │                                   SD SPI, façade FAT16 sur le MMB, cache à écriture différée
│   │       └── BBCNet.c                   Econet virtuel : ADLC à $FEA0 + liaisons de stations, handshake en
│   │                                           quatre temps ↔ AUN via le socket UDP de l'ESP32, anneaux PSRAM
│   ├── test/
│   │   └── M6502/                         Tests de conformité natifs sur l'hôte (make -C src/test/M6502 run)
│   └── model/
│       ├── CMakeLists.txt                 Macro add_m6502_model_targets() — 4 variantes par modèle,
│       │                                       LTO partiel sur M6502.c + M6502CPU.c
│       ├── Base6502/                      Modèle vanille (INCLUDE_OPEN6502_DRIVERS)
│       │   ├── main.c                     Point d'entrée (boucle de service Core 0 + lancement Core 1, stockage
│       │   │                                   de la config en flash, horloge/tension, superviseur POR)
│       │   ├── main_memmap_partition_1.ld Script d'édition de liens pour le Slot 1
│       │   └── main_memmap_partition_2.ld Script d'édition de liens pour le Slot 2
│       ├── BBC6502/                       Base6502 + INCLUDE_ACORN_DRIVERS (réutilise Base6502/main.c)
│       └── Bootloader/
│           ├── CMakeLists.txt
│           └── main.c                     Bootloader partagé (identique au picoZ80)
├── sim/
│   ├── 6502/                              pico6502sim — simulateur hôte autonome (voir ci-dessous)
│   └── src/
│       ├── host_apple1.c                  Hôte Apple I synthétique
│       └── host_bbc.c                     Hôte BBC Model B synthétique (VIA système, clavier, MODE 7)
├── tools/econet/                          Démons AUN embarqués (aund, PiEconetBridge) + build.sh,
│                                               fileserver.sh, examples/, README.md
├── PIPELINE_REDESIGN.md                   Le dossier de conception de la campagne de vitesse du moteur de bus
├── timing/, *.kvdat, *.py                 Captures d'analyseur logique (6502 réel vs pico6502) + outils
└── esp32/
    ├── CMakeLists.txt
    ├── personas/                          config_<Partition1>_<Partition2>.json — Basic6502, Apple-I, BBC-B
    └── main/
        └── ...                            Firmware ESP32 (partagé avec le picoZ80 ; GUI web consciente du CPU)

Différences clés avec le picoZ80

Pas d'espace d'adressage E/S séparé

Différences de l'interface bus PIO

Programmation PIO — Comment le code C pilote les cycles bus

                  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).

Struct t_6502PSRAM

// 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;

Signature de la fonction handler

// 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)

Shell de débogage — Un seul shell, deux CPU

Framework de pilotes

• La table d'enregistrement virtualFuncMap[] et la façon dont le champ JSON "name" est mis en correspondance avec une fonction d'initialisation de pilote.
• Le typedef VirtualFunc et la recherche M6502CPU_getVirtualFunc().
• Le flux d'initialisation en deux passes (passe de validation puis passe de configuration).
• Les callbacks de cycle de vie des pilotes : reset_ptr, poll_ptr, task_ptr.

Le pilote Open6502

Boucle de dispatch de Core 1

1. Superviseur de mise sous tension : maintenir l'hôte en reset jusqu'à ce que les services de Core 0 soient prêts (plafond de 15 s) ; garer R/W au niveau haut.
2. Servir les requêtes de maintien/parcage de Core 0 avec une boucle d'attente résidant en RAM (sûre pendant l'effacement de la flash), la ligne /RES anti-rebond (la séquence de reset s'exécute après relâchement), le maintien de libération de bus DBE du 6512, et le détecteur de front /NMI.
3. Appeler g_fastTickHook si un pilote en a installé un (le cadencement en bauds du lecteur de cassettes), et le poll_ptr des pilotes environ toutes les 250 ms.
4. Exécuter m6502_run(1024) — ou une instruction à la fois en mode pas à pas, point d'arrêt ou trace, avec vérification optionnelle par relecture de l'opcode. À l'intérieur, les callbacks fetchOpcode/readMem/writeMem du cœur résolvent chaque adresse contre _membankPtr[addr >> 9] et dispatchent selon le type de bloc : PHYSICAL / PHYSICAL_HW (une opération bus via le moteur ci-dessus), RAM / ROM (PSRAM), FUNC (memioPtr[addr]), PTR (redirection memPtr[]).
5. Échantillonner les interruptions une fois par instruction — l'instantané du /IRQ physique combiné par OU avec g_m6502VirtIrq — et délivrer IRQ/NMI via une séquence de sept cycles qui vide tout prefetch en cours.

// 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
    }
}

Écrire un nouveau pilote

1. Créer un fichier d'en-tête dans src/include/drivers/<Family>/MyDriver.h
2. Créer un fichier d'implémentation dans src/drivers/<Family>/MyDriver.c
3. Activer la définition de compilation INCLUDE_<FAMILY>_DRIVERS de la famille pour le build du modèle (les sources des pilotes sont #includees in situ, et non listées comme unités de compilation séparées)
4. Inclure le pilote dans M6502CPU.c sous la garde #ifdef INCLUDE_<FAMILY>_DRIVERS
5. Enregistrer le pilote dans virtualFuncMap[] dans M6502CPU.c
6. Ajouter une entrée de pilote JSON dans config.json

Modèle de pilote minimal

// 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;
}

Configuration JSON

{
  "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" }
      ]
    }
  }
}

Enregistrement dans virtualFuncMap

// 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
};

Modification de CMakeLists.txt

# 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

Compilation et test

# 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

Modèles de hooks mémoire

Bloc FUNC — Périphérique virtuel

// 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;
}

Interception des écritures RAM

// 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

Adresses éparses / individuelles

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

Personas machine — Apple I et BBC Model B

Le pilote BBC-B — La connaissance de la machine sous forme de pilote

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).
}

• Supports sideways ROM/RAM — chacune des seize banques ROMSEL peut être peuplée virtuellement depuis la PSRAM (banques de pool 1–4, 16K par support) : une image ROM depuis la SD (ROM virtuelle) ou de la RAM sideways inscriptible. Un support activé prend le pas sur la banque physique ; l'écriture ROMSEL atteint toujours le latch matériel afin que le décodage propre de l'hôte reste cohérent, mais tant qu'une banque remplacée est sélectionnée, chaque lecture et écriture de $8000–$BFFF est servie depuis la PSRAM. C'est ainsi que MMFS ou une ROM de langage est ajoutée sans ouvrir la machine.
• Support OS — une image OS de 16K virtualisée sur $C000–$FFFF avec la fenêtre E/S laissée en passage et les vecteurs $FF00–$FFFF gérés octet par octet ; fileoffset extrait l'OS d'une image plus grande (MegaROM).
• RAM Model A — 16K de RAM adossée à la PSRAM superposée en $4000–$7FFF afin que l'OS voie un Model B de 32K. Zéro cycle bus — ce qui est aussi la réserve : l'ULA vidéo lit la mémoire écran dans la DRAM de l'hôte et ne peut pas voir la RAM virtuelle, de sorte que le comportement de l'écran sur un vrai Model A reste à vérifier (une option d'écriture traversante, comme celle utilisée par le chemin vidéo PCW du picoZ80, est la suite probable).
• Mode Master — shadow LYNNE de 20K, HAZEL de 8K et ANDY de 4K avec ACCCON ($FE34) virtualisé, une CMOS/RTC virtuelle sur le VIA système, et le cœur CMOS forcé car MOS 3.x est du code 65C12. Attend une image MOS 3.x dans le support OS. Le DFS (banque 9) et l'ADFS (banque 13) de la MegaROM ne sont préréglés que lorsque BBCFDC_MasterFdc() signale un 1770 virtuel sur la carte Master (ou que presetdiscroms le force) ; sinon la banque 13 est laissée hors du masque d'alias afin que la ROM de système de fichiers propre à l'hôte apparaisse, conformément à la valeur CMOS par défaut FILE 13.
• Persistance — CMOS virtuelle et RAM sideways sauvegardées sur SD (par défaut), dans la région non volatile de la flash (flash_ram.h, écrite via un message inter-cœurs MSG_WRITE_NVRAM pendant que Core 1 est garé en RAM), ou pas du tout.
• Interfaces — le tableau if[] lie CMT-UEF (lecteur de cassettes), BBC-FDC (8271 ou WD1770 virtuel avec deux lecteurs), BBC-MMC (carte MMFS virtuelle) et BBC-NET (module Econet virtuel, AUN sur IP). Chacune est capturée par M6502CPU_configDriversFromJSON dans l'appel SetConfig de l'interface avant que l'init de la persona ne s'exécute, et chacune expose des points d'entrée Init / Remap / FastTick / Poll / HostReset que la persona appelle.

BBCCMT — le premier périphérique virtuel, et la ligne IRQ virtuelle

BBCFDC et BBCMMC — Modèles de puce, caches de blocs et propriété du NMI

BBCNet — Econet comme pont de protocole

Simulateur hôte (pico6502sim)

Compilation et exécution

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)

L'hôte Apple I synthétique

L'hôte BBC Model B synthétique

Attacher votre propre machine hôte

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

Interaction Core 0 / Core 1

Pièges courants

Sites de référence

Avis réglementaire sans fil