pico6502 Guia del Desarrollador

English

Vision general

• M6502CPU.c / M6502CPU.h reemplazan a Z80CPU.c / Z80CPU.h como archivos principales de despacho y framework de drivers.
• El 6502 no tiene un espacio de direcciones I/O separado — no hay array ioPtr[] ni seccion JSON iomap. Todos los perifericos se virtualizan como bloques tipo FUNC en el mapa de memoria de 64 KB.
• La interfaz de bus PIO (M6502.pio) implementa reloj bifasico PHI1/PHI2 en lugar del modelo de reloj unico del Z80.
• El directorio objetivo de compilacion es BaseM6502 en lugar de BaseZ80.
• La clave de seccion CPU JSON es "6502" en lugar de "z80".

Arbol de codigo fuente

tzpuPico/
├── CMakeLists.txt                          Archivo de compilacion de nivel superior
├── src/
│   ├── CMakeLists.txt                      Archivo de compilacion a nivel fuente — agregar nuevos archivos de driver aqui
│   ├── M6502CPU.c                          *** ARCHIVO CLAVE: despacho 6502, framework drivers, virtualFuncMap
│   ├── M6502.pio                           Programas PIO: clock, addr, data, cycle, fetch, read, write, irq, nmi, so
│   ├── include/
│   │   ├── M6502CPU.h                      *** ARCHIVO CLAVE: todas las definiciones de tipo y macros 6502
│   │   └── drivers/
│   │       └── BBC/
│   │           └── ModelB.h               Header del driver BBC Model B (relleno inicial)
│   ├── drivers/
│   │   └── BBC/
│   │       └── ModelB.c                   *** DRIVER EJEMPLO/RELLENO (persona BBC Model B)
│   └── model/
│       ├── BaseM6502/
│       │   ├── CMakeLists.txt             Objetivos de compilacion por modelo
│       │   └── main.c                     Punto de entrada (lanzamiento Core 0 + Core 1)
│       └── Bootloader/
│           └── main.c                     Bootloader compartido (mismo del picoZ80)
└── esp32/
    └── main/
        └── ...                            Firmware ESP32 (compartido con picoZ80)

Diferencias clave con el picoZ80

Sin espacio de direcciones I/O separado

Struct t_6502PSRAM

// src/include/M6502CPU.h (simplificado)
typedef struct {
    uint8_t      RAM[MAX_MEMORY_BANKS * MEMORY_PAGE_SIZE]; // 64 bancos x 64 KB = 4 MB area RAM/ROM
    MemoryFunc   memPtr[MEMORY_PAGE_SIZE];                  // 64K redireccion lectura por byte (tipo PTR)
    MemoryFunc   memioPtr[MEMORY_PAGE_SIZE];                // 64K array handlers mapeados memoria (tipo FUNC)
    // NOTA: sin ioPtr[] — el 6502 no tiene espacio I/O separado
} t_6502PSRAM;

Firma de la funcion handler

// Handler llamado para bloques MEMBANK_TYPE_FUNC en cada acceso
typedef uint8_t (*MemoryFunc)(M6502CPU *cpu, bool read, uint16_t addr, uint8_t data);

// Parametros:
//   cpu  — puntero a la struct M6502CPU
//   read — true para ciclo lectura 6502 (RNW=1), false para ciclo escritura (RNW=0)
//   addr — direccion 16 bits que activo este handler
//   data — byte escrito (solo significativo cuando read=false)
// Retorno:
//   byte a colocar en el bus de datos (solo significativo cuando read=true)

Framework de drivers

Escribir un nuevo driver

1. Crear un archivo header en src/include/drivers/<Family>/MyDriver.h
2. Crear un archivo de implementacion en src/drivers/<Family>/MyDriver.c
3. Agregar el archivo fuente a src/CMakeLists.txt
4. Incluir el driver en M6502CPU.c bajo una guardia #ifdef INCLUDE_<FAMILY>_DRIVERS
5. Registrar el driver en virtualFuncMap[] en M6502CPU.c
6. Agregar una entrada de driver JSON en config.json

Plantilla de driver minima

// src/include/drivers/BBC/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/BBC/VIA6522.h"

typedef struct {
    uint8_t  regs[16];
    bool     irqPending;
} t_VIA6522State;

static t_VIA6522State ViaState = { .irqPending = false };

static uint8_t VIA6522_Handler(M6502CPU *cpu, bool read, uint16_t addr, uint8_t data)
{
    uint8_t reg = addr & 0x0F;
    if(read) return ViaState.regs[reg];
    ViaState.regs[reg] = data;
    return 0;
}

static uint8_t VIA6522_Reset(M6502CPU *cpu)
{
    memset(&ViaState.regs, 0, sizeof(ViaState.regs));
    ViaState.irqPending = false;
    return 0;
}

int VIA6522_Init(M6502CPU *cpu, t_drvConfig *drvConfig, int pass)
{
    if(pass == 0) return (strcasecmp(drvConfig->name, "via6522") == 0) ? 1 : 0;
    for(uint16_t addr = 0xC000; addr <= 0xC00F; addr++)
        cpu->_6502PSRAM->memioPtr[addr] = VIA6522_Handler;
    cpu->reset_ptr = VIA6522_Reset;
    debugf("VIA6522: Inicializado en 0xC000–0xC00F\n");
    return 1;
}

Registro en virtualFuncMap

static const t_VirtualFuncMap virtualFuncMap[] = {
    { "BBCModelB", BBCModelB_Init },   // entrada existente
    { "via6522",   VIA6522_Init   },   // su nuevo driver
    { NULL, NULL }                     // terminador
};

Patrones de hooks de memoria

Errores comunes

Sitios de referencia

Aviso regulatorio inalambrico