pico6502 Technischer Leitfaden

English

Uebersicht

Hardwarearchitektur

Blockdiagramm

┌─────────────────────────────────────────────────────────────────────────┐
│                            pico6502 Board (v2.2)                        │
│                                                                         │
│  ┌───────────────┐   PIO 0: A0–A15, D0–D7      ┌───────────────────┐   │
│  │               │◄──────────────────────────►│  DIP-40 Interface │   │
│  │   RP2350B     │   PIO 1: cycle/ctrl/irq     │   (6502 socket)   │   │
│  │  (300 MHz)    │◄──────────────────────────►│  A0–A15, D0–D7   │   │
│  │               │   PIO 2: PHI1/PHI2 clock ──►│  PHI0/RNW/SYNC   │   │
│  │  Core 0       │                             │  IRQ/NMI/RDY/SO  │   │
│  │  (USB/IO/ESP) │                             └───────────────────┘   │
│  │               │◄──QSPI──►[ 8MB PSRAM ]                             │
│  │  Core 1       │◄──SPI───►[ 16MB Flash ]                             │
│  │  (6502 loop)  │                                                     │
│  │               │◄──FSPI──►┌───────────┐                              │
│  │               │◄──UART──►│   ESP32   │◄──SPI──►[ SD Card ]         │
│  └───────────────┘          │  (WiFi)   │──────────[ Web Server ]     │
│                             └───────────┘                              │
│  [ USB Hub ]──USB──►[ RP2350 USB Bridge ]                             │
└─────────────────────────────────────────────────────────────────────────┘

Hauptkomponenten

GPIO-Zuweisung

Firmwarearchitektur

Flash-Speicherlayout

Dual-Core-Design

PIO-Bus-Interface

PIO-Programme

IRQ-Signalkonventionen

PHI1/PHI2-Takterzeugung

Wartezustaende und RDY

PIO-Architektur — Wie 6502-Buszyklen nachgebildet werden

PHI0 (input):  ──┐        ┌──┐        ┌──
                 │        │  │        │
                 └────────┘  └────────┘

PHI1 (output):    ┌──────┐              ┌──────┐
                  │      │              │      │
               ───┘      └──────────────┘      └───

PHI2 (output): ───┐              ┌──────┐              ┌──
                  │              │      │              │
                  └──────────────┘      └──────────────┘
                  ↑              ↑      ↑
                  │              │      │
            PHI0 faellt    PHI0 steigt  PHI0 faellt
            → kurze Luecke → kurze Luecke → kurze Luecke
            → PHI1 steigt  → PHI1 faellt
                           → PHI2 steigt

// m6502_cycle SM program (PIO 1 SM 0):
//
// start_cycle:
//     wait 0 gpio CLK2      ; Sync to PHI2 falling edge (start of new cycle)
//     irq set 0             ; Signal "ready for new cycle"
//     wait 0 irq 0          ; Wait for C code to load address and clear IRQ 0
// cycle_exec:
//     out exec, 32           ; Pull 32-bit instruction from FIFO, execute it
//     jmp cycle_exec         ; Repeat
// cycle_end:
//     irq set 7              ; Flag end of execution loop
// cycle_exec2:
//     out exec, 32           ; Continue executing injected instructions
//     jmp cycle_exec2        ; Loop until JMP start_cycle

Opcode Fetch (m6502_fetch):
PHI1:      ┌──────┐              ┌──
           │      │              │
        ───┘      └──────────────┘
PHI2:   ───┐              ┌──────┐
           │              │      │
           └──────────────┘      └───
A0–A15: ══╤═══ PC address ══════════╗   (gueltig bei steigender PHI1-Flanke)
R/W̄:    ──┤── high (read) ─────────╢
SYNC:   ──┤── high (fetch) ────────╢   (SYNC high = Opcode-Fetch)
D0–D7:  ══════════════════╤════════╗   (abgetastet bei fallender PHI2-Flanke)
                       opcode


Memory Read (m6502_read):
           Gleiches Timing wie Fetch, aber SYNC = low.


Memory Write (m6502_write):
PHI1:      ┌──────┐              ┌──
           │      │              │
        ───┘      └──────────────┘
PHI2:   ───┐              ┌──────┐
           │              │      │
           └──────────────┘      └───
A0–A15: ══╤═══ address ═════════════╗   (gueltig bei steigender PHI1-Flanke)
R/W̄:    ──┤── low (write) ─────────╢   (R/W̄ low = Schreiben)
SYNC:   ──┤── low ─────────────────╢
D0–D7:  ══════════════╤═══ data ═══╗   (getrieben waehrend PHI2 high)

Speichermodell

Stufe 1 — RP2350 SRAM (Schnelle Dispatch-Tabelle)

// 32-bit membankPtr encoding
// Bits 31–24: MEMBANK_TYPE_xxx constant
// Bits 23–16: PSRAM bank number (0–63)
// Bits 15–0:  Block base address >> 9 (i.e. upper 7 bits of 16-bit address)
#define MEMBANK_ENCODE(type, bank, base) (((type) << 24) | ((bank) << 16) | ((base) >> 9))

Stufe 2 — PSRAM (8MB)

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[] — 6502 has no separate I/O space
} t_6502PSRAM;

Stufe 3 — Flash (16MB)

Speicherblocktypen

Konfigurationsreferenz

esp32.core

esp32.wifi

rp2350.core

rp2350.6502.memory[ ]

rp2350.6502.drivers[ ]

rom[]-Eintrag:

Framework fuer virtuelle Geraete

Handler-Signaturen

// Memory / peripheral handler — installed in memioPtr[addr]
// Called for every access to a MEMBANK_TYPE_FUNC block
typedef uint8_t (*MemoryFunc)(M6502CPU *cpu, bool read, uint16_t addr, uint8_t data);

// Driver init function — registered in virtualFuncMap[]
// Called twice: pass=0 (validation), pass=1 (configuration)
typedef int (*VirtualFunc)(M6502CPU *cpu, t_drvConfig *drvConfig, int pass);

Einen Peripherietreiber schreiben

1. Erstellen Sie eine Handler-Funktion mit der MemoryFunc-Signatur. Der Handler empfaengt read=true fuer 6502-Lesezyklen (RNW=1) und read=false fuer Schreibzyklen (RNW=0).
2. Erstellen Sie eine Init-Funktion mit der VirtualFunc-Signatur. Im Konfigurationsdurchlauf (pass=1) installieren Sie Ihren Handler in cpu->_6502PSRAM->memioPtr[addr] fuer jede Adresse, die Ihr Peripheriegeraet belegt.
3. Registrieren Sie den Treibernamen und die Init-Funktion in der virtualFuncMap[]-Tabelle in M6502CPU.c.
4. Fuegen Sie einen FUNC-Typ-Eintrag im memory-Array der config.json fuer den Adressbereich hinzu.
5. Fuegen Sie einen Treibereintrag in config.json mit dem passenden "name"-Feld hinzu.

ESP32-Koprozessor

SD-Karte

Webserver

Befehlsprotokoll

SWD-Debugging — RP2350

• Die Hauptfirmware-ELF ist build/bin/model/BaseM6502/BaseM6502_0x10020000.elf (nicht BaseZ80).
• Der add-auto-load-safe-path-Eintrag in ~/.gdbinit muss BaseM6502 referenzieren.

OpenOCD-Setup

sudo cp rp2350_tzpu.cfg /usr/local/share/openocd/scripts/target/
openocd -f interface/cmsis-dap.cfg -f target/rp2350_tzpu.cfg -c "adapter speed 5000"

GDB-Konfiguration

set history save on
set history filename ~/.gdb_history
set history size 65536
add-auto-load-safe-path build/bin/model/BaseM6502/.gdbinit:build/bin/model/Bootloader/.gdbinit

# Bootloader — Core 0
cd build/bin/model/Bootloader
cp ../../../../.gdbinit.bootloader.3333 .gdbinit
gdb-multiarch Bootloader.elf

# Bootloader — Core 1 (separates Terminal)
cd build/bin/model/Bootloader
cp ../../../../.gdbinit.bootloader.3334 .gdbinit
gdb-multiarch Bootloader.elf

# Hauptfirmware — Core 0
cd build/bin/model/BaseM6502
cp ../../../../.gdbinit.3333 .gdbinit
gdb-multiarch BaseM6502_0x10020000.elf

# Hauptfirmware — Core 1 (separates Terminal)
cd build/bin/model/BaseM6502
cp ../../../../.gdbinit.3334 .gdbinit
gdb-multiarch BaseM6502_0x10020000.elf

ESP32 — USB-Debugging

openocd -f board/esp32s3-builtin.cfg

xtensa-esp32s3-elf-gdb esp32/build/main.elf
(gdb) target extended-remote :3333

Build-System

Build-Ziele

Build-Befehle

# Setup (einmalig) — vom Projektstammverzeichnis
export PICO_PATH=/path/to/pico-sdk
./get_and_build_sdk.sh

# Standard Release Build
./build_tzpuPico.sh

# Debug Build
./build_tzpuPico.sh DEBUG

# Vollstaendiger Build einschliesslich ESP32-Firmware
./build_tzpuPico.sh ALL

# Nur ESP32 (mit Docker idf54-Alias)
cd projects/tzpuPico/esp32
idf54 build

# RP2350 ueber USB-Massenspeicher flashen (BOOTSEL-Modus)
cp build/bin/model/Bootloader/Bootloader.uf2 /media/$USER/RPI-RP2/
cp build/bin/model/BaseM6502/BaseM6502_0x10020000.uf2 /media/$USER/RPI-RP2/

# ESP32 flashen (initial, ueber esptool)
esptool.py --chip esp32s3 --port /dev/ttyUSB0 --baud 460800 \
  write_flash 0x0   esp32/build/bootloader/bootloader.bin \
             0x8000 esp32/build/partition_table/partition-table.bin \
             0x10000 esp32/build/main.bin

Referenz-Websites

Regulatorischer Hinweis fuer Funkgeraete