picoZ80

El picoZ80 continúa la temática del tranZPUter, reemplazando un Z80 físico en un ordenador host o industrial con una CPU más rápida, más memoria, dispositivos virtuales, conectividad de red (WiFi, BT), carga rápida de aplicaciones desde tarjeta SD y gestión por WiFi. Es una PCB personalizada diseñada para insertarse directamente en el zócalo DIP-40 del CPU Z80 de cualquier ordenador heredado basado en Z80. En lugar de utilizar un procesador Z80 discreto, la placa aloja un microcontrolador RP2350B — un dispositivo Cortex-M33 de doble núcleo a 150MHz capaz de funcionar hasta 300MHz — cuyas máquinas de estado de E/S programable (PIO) toman el control total y ciclo-exacto de los buses de direcciones, datos y control del Z80. El picoZ80 no es un simple adaptador emulador. Cada transacción de bus se gestiona en tiempo real por los motores PIO del RP2350, proporcionando al sistema host exactamente la misma temporización de bus que vería de un Z80 real. Al mismo tiempo, el segundo núcleo del RP2350 y su abundante SRAM integrada, combinados con 8MB de PSRAM externa y 16MB de Flash, permiten un rango prácticamente ilimitado de capacidades adicionales sobre la interfaz Z80 base — incluyendo ejecución acelerada, memoria virtualizada, bancos de ROM, unidades de disco virtuales y emulación completa de personalidades de máquina. Un coprocesador ESP32 proporciona conectividad WiFi y Bluetooth, almacenamiento masivo en tarjeta SD y una interfaz de gestión basada en navegador. Toda la configuración se gestiona desde un único archivo config.json legible por humanos almacenado en la tarjeta SD, lo que significa que no se requiere recompilación para reconfigurar el mapa de memoria de la placa, las imágenes ROM o la selección de controladores. El picoZ80 ha sido demostrado funcionando en múltiples máquinas Sharp MZ. Se están desarrollando un conjunto de personalidades para estas máquinas, y eventualmente para otros sistemas Z80, para proporcionar características muy necesarias, como RAM/ROM banqueada, emulación de disquetes, emulación de QuickDisk, ROM Filing System, TranZPUter Filing System, todo capaz de funcionar simultáneamente. La configuración está completamente dirigida por JSON; añadir soporte para un nuevo host basado en Z80 es cuestión de editar un archivo de configuración y, donde se requiera nuevo comportamiento de E/S, añadir un pequeño controlador en C al código base.

• Reemplazo directo del Z80
  - se instala en cualquier zócalo DIP-40 de Z80. El host ve temporización de bus Z80 normal en todo momento.
• Interfaz de bus PIO ciclo-exacta
  - tres máquinas de estado PIO del RP2350 manejan las señales de dirección, datos y control simultáneamente a la velocidad completa del bus Z80.
• Gran espacio de memoria
  - 8MB de PSRAM organizados como 64 bancos × 64KB, proporcionando un total de 4MB de espacio de direcciones banqueado accesible por contexto de CPU.
• Bancos de ROM/RAM
  - los bloques de memoria son configurables en granularidad de 512 bytes y pueden mapearse como ROM, RAM, memoria física del host o manejadores de funciones virtuales.
• Marco de dispositivos virtuales
  - cualquier bloque de 512 bytes de memoria o rango de puertos de E/S puede estar respaldado por una función en C, habilitando periféricos completamente virtualizados.
• Personalidades de máquina
  - el firmware del Z80 puede configurarse mediante un JSON para funcionar dentro de cualquier host Z80. Las personalidades están disponibles para múltiples máquinas Sharp MZ (MZ-80K, MZ-700, MZ-800, MZ-80A, MZ-80B, MZ-2000, MZ-2200, MZ-2500, MZ-1500), el Amstrad PCW-9512 y el Tatung Einstein TC-01, más una personalidad vainilla OpenZ80 para experimentadores que instalan el picoZ80 en una placa de su propio diseño o en una máquina sin controlador dedicado. Las variantes de compilación dirigida (BaseZ80, SharpZ80, AmstradZ80, TatungZ80, OpenZ80) permiten firmware específico por máquina para un tamaño de binario reducido.
• Emulación de disquetes y QuickDisk
  - controlador de disquetes compatible con WD1773 y emulación de unidad QuickDisk de Sharp, usando imágenes DSK/RAW/D88 en la tarjeta SD.
• WiFi y gestión web
  - el ESP32 integrado proporciona una interfaz web Bootstrap de siete páginas para configuración, gestión de archivos, actualizaciones OTA de firmware y selección de personalidad.
• Shell de depuración ICE
  - un depurador ICE de 49 comandos accesible por USB CDC serial proporciona puntos de interrupción (8 simultáneos), ejecución paso a paso, trazado de ejecución, inspección de registros Z80, lectura/escritura de memoria y E/S, un desensamblador y ensamblador Z80 integrado, creación de imágenes de disco, diagnósticos de bus y monitoreo del estado del sistema.
• Doble partición de firmware
  - dos ranuras de firmware independientes de 5MB permiten actualizaciones OTA seguras; la partición activa se selecciona desde la interfaz web o el cargador de arranque.
• Actualización de firmware por USB
  - el cargador de arranque expone un puente USB para la carga de firmware sin necesidad de un depurador de hardware.

X (Twitter) project preview — picoZ80 in action

La PCB del picoZ80 (revisión 2.5) es una placa compacta multicapa diseñada para ajustarse a la huella física del encapsulado DIP-40 del Z80 y al espacio disponible dentro de las carcasas típicas de ordenadores retro. Toda la lógica opera a 3.3V; las consideraciones de adaptación de niveles y corriente de conducción para el bus de 5V del host se gestionan en el diseño del esquemático. La placa integra cinco subsistemas en una sola PCB: el procesador RP2350B, la interfaz de bus Z80, el coprocesador ESP32, la fuente de alimentación y un hub USB.

• RP2350B (Cortex-M33 doble núcleo)
  - procesador principal, funcionando hasta 300MHz. Ejecuta el bucle principal de emulación Z80 en el Núcleo 1 y gestiona E/S de archivos, USB y retransmisión ESP32 en el Núcleo 0. 512KB de SRAM integrada. La variante RP2350B (a diferencia del RP2350A) proporciona 48 pines GPIO necesarios para el bus Z80 completo.
• 16MB SPI Flash
  - almacena el cargador de arranque, dos ranuras de firmware de aplicación, dos ranuras de configuración y una partición de configuración general. La distribución direccionable total abarca 0x10000000–0x11000000.
• 8MB PSRAM (SPI)
  - RAM pseudo-estática externa que proporciona 64 bancos × 64KB de espacio de direcciones banqueado para la CPU emulada. Conectada al RP2350 mediante un periférico SPI dedicado.
• Coprocesador ESP32
  - proporciona WiFi (802.11 b/g/n, modos AP y cliente), Bluetooth, lector de tarjeta SD y servidor web. Se comunica con el RP2350 mediante un protocolo IPC binario sobre FSPI a 50MHz (con verificación de integridad CRC32, canales DMA preasignados y transferencias de sectores en ráfaga de hasta 16 sectores por transacción) y un UART a 460.8kbaud para comandos de control.
• Ranura de tarjeta SD
  - FAT32, gestionada por el ESP32. Almacena config.json, imágenes ROM, imágenes de disco (DSK, QuickDisk, disco RAM) y árboles de sistemas de archivos TZFS/RFS.
• Hub USB
  - hub USB integrado para conectividad con el host y actualización de firmware.
• Fuente de alimentación de 3.3V
  - convertidor buck eficiente alimentado desde los 5V presentes en el pin VCC del zócalo Z80.

El hardware del picoZ80 está diseñado en KiCad. La revisión actual es v2.5. Los archivos de esquemático y diseño de PCB están disponibles en el repositorio del proyecto bajo kicad/PICOZ80/. El esquemático se divide en cinco hojas:

Todas las asignaciones GPIO del RP2350B, desacoplamiento, oscilador de cristal de 12MHz, Flash de 16MB y conexiones PSRAM de 8MB. El encapsulado QFN-80 del RP2350B se elige específicamente por su conteo de 48 GPIO — el bus Z80 completo (16 direcciones + 8 datos + 12 señales de control) más las señales SPI/UART del ESP32 y USB consumen virtualmente todos los pines disponibles.

Módulo ESP32-S3-PICO-1, interfaz de tarjeta SD (SPI), antena de chip, cabezal de depuración y líneas de comunicación entre procesadores (bus FSPI a 50MHz, UART a 460.8kbaud). Las señales de tarjeta SD y SPI/UART entre procesadores están claramente separadas en esta hoja.

Las conexiones del zócalo DIP de 40 pines y la red de resistencias de la interfaz de bus. Las líneas de dirección A0–A15, las líneas de datos D0–D7 y todas las señales de control del Z80 (MREQ, IORQ, RD, WR, M1, RFSH, BUSREQ, BUSACK, HALT, INT, NMI, WAIT, CLK, RESET) se enrutan a través de resistencias en serie hacia pines GPIO dedicados del RP2350 monitoreados por las máquinas de estado PIO.

Convertidor buck síncrono TLV62590BV de 5V a 3.3V con condensadores de filtrado de entrada/salida. El convertidor debe suministrar la carga combinada del RP2350B a hasta 300MHz, 8MB de PSRAM, ESP32 y hub USB desde el único pin VCC de 5V del zócalo DIP-40 del Z80.

Controlador de hub USB CH334F con conector Mini-B, cristal de 12MHz y puertos descendentes enrutados tanto al RP2350 (para actualización de firmware) como al ESP32 (para acceso USB directo en revisiones más nuevas de la placa).

La PCB fue diseñada lo más pequeña posible para acomodar toda la circuitería necesaria y ajustarse dentro de los límites de un zócalo DIP-40. Se utilizaron los componentes más pequeños que podían ensamblarse manualmente, es decir, dispositivos pasivos 0402/0603 y espaciado de paso de 0.5mm en CI para reducir el tamaño general, y se seleccionó un apilamiento de 6 capas para alojar todos los componentes requeridos. Los diseños iniciales, v2.0 y v2.1 fueron ensamblados manualmente con aplicación puntual de soldadura, colocación manual de componentes y una estación de retrabajo de aire caliente. La versión 2.2 fue ensamblada manualmente con plantilla y horno de reflujo. Las versiones v2.3a y v2.5 fueron ensambladas en una fábrica de PCB.

Haga clic aquí para ver un diagrama interactivo de ubicación de componentes de la PCB y la Lista de Materiales.

Los dos núcleos Cortex-M33 del RP2350B tienen responsabilidades completamente separadas, comunicándose a través de una cola de mensajes entre núcleos (queue_t). El Núcleo 0 gestiona todas las tareas no en tiempo real: puente USB y CDC serial, coordinación de actualización de firmware, E/S de archivos (retransmitida al ESP32 por UART), despacho de comandos ESP32 (cambios de imagen de disquete/QuickDisk, recargas de configuración, consultas de versión), gestión de particiones y supervisión del watchdog. Un temporizador watchdog de hardware monitorea la secuencia de arranque y el bucle principal, con el progreso del arranque rastreado a través de registros scratch del RP2350 que sobreviven a los reinicios del watchdog. Los manejadores de fallos exhaustivos capturan el estado de los registros e información de diagnóstico en la PSRAM, permitiendo el análisis post-reinicio de fallos graves, fallos de bus y fallos de uso. Un registro persistente en PSRAM (plogf) captura mensajes críticos de arranque antes de que el USB esté disponible, complementando el sistema de salida de depuración estándar debugf. El Núcleo 1 ejecuta exclusivamente el bucle principal de emulación de CPU. Atiende los FIFOs PIO para procesar transacciones de bus Z80, resuelve cada dirección contra el mapa de memoria y, según el caso, pasa la transacción al hardware físico del host (tipo PHYSICAL), la atiende desde la PSRAM (tipos RAM/ROM), o llama a una función manejadora de dispositivo virtual (tipo FUNC). La latencia en esta ruta se minimiza manteniendo el bucle interno en SRAM y usando los 512KB de SRAM del RP2350 como tabla de búsqueda rápida para punteros de bloques de memoria.

La interfaz de bus Z80 está implementada completamente en ensamblador PIO del RP2350 (z80.pio). El RP2350 proporciona tres bloques PIO (PIO 0, PIO 1, PIO 2), cada uno con cuatro máquinas de estado. El firmware Z80 utiliza los tres bloques PIO:

• PIO 0 — Bus de direcciones y datos (GPIO 0–23)
  - gestiona el bus de direcciones de 16 bits (A0–A15, GPIO 0–15) y el bus de datos bidireccional de 8 bits (D0–D7, GPIO 16–23). Las máquinas de estado ejecutan los programas z80_addr y z80_data simultáneamente, enviando palabras de dirección y conduciendo o muestreando bytes de datos en sincronía.
• PIO 1 — Señales de control, ejecución de ciclo y refresco DRAM (GPIO 16–47)
  - ejecuta los programas principales de control de bus contra el rango superior de GPIO: la máquina de estado de ciclo (z80_cycle) orquesta todos los ciclos de bus Z80 incluyendo generación integrada de refresco DRAM, solicitud/reconocimiento de bus (z80_busrq), detección de NMI (z80_nmi), sincronización de reloj (z80_clk_sync) y manejo de reconocimiento de interrupciones (z80_int_ack).
• PIO 2 — Temporización del host, reset y estados de espera
  - gestiona las interacciones críticas en tiempo entre el RP2350 y el bus Z80 del host que deben permanecer correctas incluso cuando el Núcleo 1 está atendiendo memoria interna. Cuatro máquinas de estado dedicadas se ejecutan en PIO 2:
  • Detección de RESET (z80_reset) — monitorea la línea RESET del host y señaliza al Núcleo 1 para que el estado de emulación pueda reinicializarse limpiamente en cada reset de hardware.
  • Generador de estados de espera (z80_wait) — inserta estados de espera de ciclo T configurables (controlados por el parámetro JSON tcycwait) asertando /WAIT en el bus del host, estirando ciclos de bus individuales para cumplir con los requisitos de temporización de periféricos más lentos o ROM/RAM banqueada.
  • Sincronización T1 (z80_sync) — detecta el flanco ascendente de T1 en cada ciclo de bus (el punto en que el Z80 coloca una dirección válida en el bus) y señaliza al Núcleo 1 mediante IRQ. Esta sincronización es esencial para aplicaciones que dependen del reloj del host para temporización precisa — incluyendo bucles de retardo por software y E/S sensible al tiempo como control de motor de cassette y bit-banging serial — asegurando que las operaciones de memoria interna del RP2350 no introduzcan deriva de temporización perceptible.

El conjunto completo de programas PIO en z80.pio, agrupados por bloque PIO:

Las máquinas de estado se comunican mediante flags IRQ de PIO en lugar de sondeo, lo que elimina la latencia entre máquinas: IRQ 0 señaliza el inicio de dirección/ciclo, IRQ 1 señaliza la fase de datos, IRQ 2 indica detección de T1, IRQ 3 señaliza un evento RESET, IRQ 4 señaliza NMI, e IRQ 6 señaliza un BUSRQ activo. Dado que los programas PIO se ejecutan independientemente de los núcleos Cortex-M33, la interfaz de bus continúa respondiendo de forma determinista incluso cuando el Núcleo 1 está ocupado con accesos a PSRAM o llamadas a dispositivos virtuales.

Los accesos a memoria se resuelven a través de tres niveles de latencia creciente: Nivel 1 — SRAM del RP2350 (512KB, cero estados de espera)
Un arreglo de 128 entradas de valores membankPtr de 32 bits, uno por cada bloque de 512 bytes del espacio de direcciones Z80 completo de 64KB, proporciona al Núcleo 1 una búsqueda de tipo de bloque O(1) para cada transacción de bus. Este arreglo es la tabla de despacho interna: cada entrada codifica el tipo de bloque y, para bloques respaldados por PSRAM, el desplazamiento en PSRAM. Nivel 2 — PSRAM externa (8MB, SPI)
La PSRAM aloja 64 bancos de imágenes de RAM o ROM de 64KB, más un arreglo de punteros memPtr de 64KB, un arreglo de punteros de función memioPtr de 64KB y un arreglo de punteros de función de E/S ioPtr de 64KB. La latencia de acceso a PSRAM es determinista y se gestiona mediante el periférico SPI del RP2350 con DMA. Nivel 3 — Flash SPI de 16MB
El firmware, las imágenes ROM y el config.json minificado se almacenan en Flash. Las imágenes ROM se copian de Flash a PSRAM en el arranque y luego se sirven desde PSRAM en tiempo de ejecución. No se accede a Flash durante las transacciones normales del bus Z80. Los bloques de memoria se configuran en granularidad de 512 bytes. Los tipos de bloque disponibles son:

La Flash de 16MB está particionada de la siguiente manera:

Cada ranura de configuración puede alojar hasta 64 imágenes ROM y una configuración JSON minificada de 64KB. La ranura activa se registra en la tabla de particiones y puede cambiarse desde la interfaz web o manteniendo presionado el botón correspondiente durante el arranque.

La personalidad activa se selecciona mediante la página Personality de la interfaz web o editando config.json.

El firmware soporta un sistema de compilación dirigida que produce binarios específicos por máquina: pZ80-BaseZ80 incluye todos los controladores (Sharp + Amstrad + Tatung), pZ80-SharpZ80 incluye solo controladores Sharp MZ, pZ80-AmstradZ80 incluye solo controladores Amstrad PCW, pZ80-TatungZ80 incluye solo controladores Tatung Einstein y pZ80-OpenZ80 es la personalidad vainilla/experimentador que expone solo las tarjetas de interfaz independientes de máquina (vea OpenZ80 — Personalidad para Experimentadores más abajo). Cada objetivo se controla mediante definiciones en tiempo de compilación (INCLUDE_SHARP_DRIVERS, INCLUDE_AMSTRAD_DRIVERS, INCLUDE_TATUNG_DRIVERS, INCLUDE_OPEN_DRIVERS). Los siguientes controladores de periféricos están disponibles: Serie Sharp MZ Cuando se compila con INCLUDE_SHARP_DRIVERS, los siguientes controladores de periféricos Sharp se compilan e incluyen y pueden vincularse a cualquier personalidad de hardware virtual mediante la configuración JSON:

• MZ700.c — Conjunto de periféricos Sharp MZ-700
  - gestiona el característico cambio de bancos, video y E/S de teclado del MZ-700 a nivel de periféricos.
• MZ80K.c — Conjunto de periféricos Sharp MZ-80K
  - emulación del MZ-80K original de Sharp de 1978, basada en el controlador del MZ-80A. Proporciona la ROM del monitor SP-1002 (0x0000–0x0FFF), 2KB de VRAM (0xD000–0xD7FF), el 8255 PPI, el 8253 PIT y el escáner de teclado LS367 (0xE000–0xE7FF), y la región de la ROM de arranque de disquetes nativa MZ-80FD/MZ-80FIO (0xF000–0xF3FF). Implementa el intercambio de memoria MEMSW/MEMSWR (reubica el monitor SP-1002 entre 0x0000 y 0xC000) para que CP/M pueda ejecutarse. Soporta operación tanto física (reemplazo directo en un MZ-80K real) como virtual (basada en PSRAM); CP/M requiere modo virtual (o la ruta de remapeo de memoria por controlador) porque el MZ-80K original no tiene hardware de intercambio de memoria. El MZ-80K puede vincular el conjunto completo de tarjetas de interfaz del MZ-80A además de su propio controlador de disquetes nativo. Se soportan dos rutas de disquete distintas: (1) la interfaz nativa MZ80FIO (controlador Toshiba T3444M) — la interfaz de disco MZ-80FD original — que arranca y lee todos los discos del MZ-80K, incluyendo juegos, aplicaciones, BASIC y CP/M; y (2) la tarjeta MZ80AFI (el FDC basado en WD del MZ-80A), que utiliza CP/M — puede arrancar CP/M del MZ-80K y leer discos CP/M originales del MZ-80K desde dentro de CP/M (montados como unidades C:/D:). Use MZ80FIO para el uso general de discos del MZ-80K y MZ80AFI cuando ejecute CP/M. Sub-interfaces: RFS, MZ80FIO (disquetes nativos T3444M), MZ80AFI, MZ-1E14, MZ-1E19, MZ-1R12, MZ-1R18, MZ-1R37, PIO-3034.
• MZ80A.c — Conjunto de periféricos Sharp MZ-80A
  - emulación completa de la máquina MZ-80A incluyendo la ROM del monitor SA-1510, 2KB de VRAM, Intel 8253 PIT (Temporizador de Intervalo Programable con los seis modos de contador), Intel 8255 PPI (Interfaz de Periférico Programable), escáner de teclado LS367 y el mecanismo de intercambio de memoria MEMSW/MEMSWR para soporte de CP/M (intercambia la ROM del monitor en 0x0000 con RAM en 0xC000). Soporta operación tanto física (hardware real) como virtual (basada en PSRAM), incluyendo modo mixto donde el controlador funciona virtualmente pero se usa un controlador de disquetes físico. Sub-interfaces: RFS, MZ80AFI, MZ-1E14, MZ-1E19, MZ-1R12, MZ-1R18.
• MZ2000.c — Conjunto de periféricos Sharp MZ-2000
  - emulación completa de la máquina MZ-2000 con conmutación de modo de memoria boot/normal (BST/NST), superposición de VRAM de caracteres y gráficos con selección de banco, Intel 8253 PIT (4 MHz), Intel 8255 PPI (control de cassette y modo de memoria), Z80 PIO (teclado y paginación de VRAM) y MB8866 FDC. Soporta tanto modo físico (reemplazo directo del Z80 en un MZ-2000 real con detección automática de modo boot/normal) como modo virtual (emulación completa basada en PSRAM con duplicación de ROM IPL). Sub-interfaces: RFS, MZ80AFI, MZ-1E14, MZ-1E19, MZ-1R12, MZ-1R18.
• MZ2200.c — Conjunto de periféricos Sharp MZ-2200
  - emulación de la máquina MZ-2200 basada en la arquitectura del MZ-2000 con 8253 PIT, 8255 PPI, Z80 PIO, MB8866 FDC y CRT a color. Soporta conmutación de modo de memoria BST/NST con superposición de VRAM. Sub-interfaces: RFS, MZ-8BFI/E0054PA, MZ-1E14, MZ-1E19, MZ-1R12, MZ-1R18.
• MZ80B.c — Conjunto de periféricos Sharp MZ-80B
  - emulación de la máquina MZ-80B con ROM IPL de 2K, conmutación de modo BST/NST, pantalla monocroma con páginas duales de VRAM gráfica, 8253 PIT (31.25 kHz), 8255 PPI, Z80 PIO y selección de página gráfica. Se soportan las 10 interfaces de placas de expansión. Sub-interfaces: MZ-8BFI/E0054PA, MZ-1E14, MZ-1E19, MZ-1R12, MZ-1R18, MZ-1R23, MZ-1R37, PIO-3034, Celestite, MZ-1E30.
• MZ2500.c — Conjunto de periféricos Sharp MZ-2500 (SuperMZ)
  - emulación de la máquina MZ-2500 con MMU de 8 páginas (64 bloques de memoria), modos de compatibilidad (MZ-2000, MZ-80B, nativo), sonido FM+PSG OPN YM2203, controlador gráfico G-CRTC, MB8876 FDC, paleta gráfica de 16 entradas, controlador de interrupciones, RTC, puertos de joystick. El modo virtual soporta software controlado por interrupciones mediante manejadores personalizados fetchByte y RETI que ejecutan ciclos de bus M1 físicos (necesarios para los relojes internos temporizado por M1 del gate array), formato de disco nativo D88 con auto-detección dispersa/contigua, y supresión de interrupciones de un solo uso durante la inicialización. Sub-interfaces: MZ-8BFI/E0054PA, MZ-1E14, MZ-1E19, MZ-1R12, MZ-1R18, MZ-1R23, MZ-1R37, PIO-3034, Celestite, MZ-1E30.
• MZ1500.c — Conjunto de periféricos Sharp MZ-1500
  - superconjunto del MZ-700 con unidad Quick Disk integrada, Generador de Caracteres Programable (PCG), sonido estéreo PSG (SN76489AN), interfaz de impresora Z80 PIO, 8253 PIT y selección de modo MZ-700/MZ-1500 por interruptor DIP. Sub-interfaces: RFS, MZ-1E05, MZ-1E14, MZ-1E19, MZ-1R12, MZ-1R18, MZ-1R23, MZ-1R37, PIO-3034, Celestite.
• MZ800.c — Conjunto de periféricos Sharp MZ-800
  - controlador de modo dual que funciona en modo de compatibilidad MZ-700 o en modo nativo MZ-800, conmutando sobre la marcha mediante el registro de Modo de Pantalla del GDG (Generador de Pantalla Gráfica, del inglés Graphics Display Generator) (puerto 0xCE). El modo nativo añade gráficos de 320×200 / 640×200 con una paleta de 4 o 16 colores (planos de VRAM en 0x8000–0xBFFF), sonido PSG SN76489 (puerto 0xF2), puertos de bancos de memoria 0xE0–0xE6, FDC WD1773 y QuickDisk; el modo MZ-700 proporciona el 8255/8253 mapeados en memoria y la VRAM de texto para ejecutar software MZ-700 y CP/M. Modo virtual; reproduce un RETI físico en el bus real para que la cadena de interrupciones en cascada del Z80-PIO (IM2) siga funcionando desde la PSRAM. Sub-interfaces: RFS, MZ80FIO, MZ80AFI, MZ-1E05, MZ-1E14, MZ-1E19, MZ-1E30, MZ-1R12, MZ-1R18, MZ-1R23, MZ-1R37, MZ-8BFI, PIO-3034, Celestite, MZ-8BIO3, MZ-1E24.
• WD1773.c — Controlador de disquetes
  - emula un FDC WD1773 que soporta imágenes de disco de 80 pistas, 2 cabezales, 8 sectores por pista en formatos DSK, RAW y D88 almacenados en la tarjeta SD. Los registros del WD1773 se mapean como bloques de E/S tipo FUNC.
• T3444M.c — Controlador de disquetes Toshiba T3444M/T3444A (MZ-80K)
  - emula el FDC Toshiba T3444M/T3444A usado por la unidad de disquetes MZ-80FD del Sharp MZ-80K. Lee imágenes DSK extendidas CPC con la geometría nativa del MZ-80K (35 pistas, 2 cabezales, 16 sectores/pista, sectores FM de 128 bytes), con hasta cuatro imágenes de unidad simultáneas. Un analizador DSK dedicado recorre las firmas Track-Info del disco porque la tabla de tamaño de pistas CPC-DSK del MZ-80K no es fiable. Usado por la interfaz MZ80FIO — al ser el controlador original/nativo del MZ-80K, arranca y lee todos los tipos de discos del MZ-80K, no solo CP/M.
• MZ80FIO.c — Interfaz de disquetes MZ-80FD / MZ-80FIO (MZ-80K)
  - emula la interfaz Sharp MZ-80FD/MZ-80FIO — la interfaz de disco original del MZ-80K — usando el controlador Toshiba T3444M. Proporciona la ROM de arranque FDIF en 0xF000–0xF3FF y los puertos de registro y comando del T3444M en 0xF8–0xFB. Arranca y lee todos los discos del MZ-80K (juegos, aplicaciones, BASIC y CP/M), soporta hasta cuatro unidades y cambios de disco en tiempo de ejecución desde la interfaz web. Para ejecutar CP/M, puede usarse en su lugar el controlador MZ80AFI del MZ-80A — solo una interfaz de disquetes está activa a la vez, y si ambas están configuradas, MZ80FIO tiene prioridad.
• QDDrive.c — Unidad QuickDisk
  - emula la unidad miniatura de acceso secuencial QuickDisk de Sharp usando archivos de imagen QD en la tarjeta SD. El controlador proporciona emulación completa del Z80 SIO/2 (Canal A para datos de pista espiral, Canal B para control de motor/estado), completo con detección de byte de sincronización en fase de búsqueda, control de motor mediante RTS y operaciones de archivo asincrónicas entre núcleos para acceso a tarjeta SD.
• RFS.c — ROM Filing System
  - implementa la interfaz de bancos y archivos RFS, permitiendo cargar archivos de programa MZF desde la tarjeta SD. La personalidad RFS incluye CP/M v2.23 (48K), el intérprete BASIC personalizado SA-1510 y Microsoft BASIC v4.7, todos mejorados con acceso de lectura/escritura a tarjeta SD para que los programas y datos puedan cargarse y guardarse directamente desde la tarjeta SD sin hardware de cassette o disquete.
• TZFS.c — TranZPUter Filing System
  - un monitor de bajo nivel multibanco y sistema de archivos funcional, modelado sobre el TZFS del tranZPUter SW y su procesador de E/S virtual K64F, y ofrecido como una interfaz seleccionable en la personalidad MZ-700 (registrado junto a RFS en MZ700.c, y en la práctica mutuamente excluyente con él). Mejora el MONITOR 1Z-013A original con acceso a tarjeta SD, banqueo de ROM, un ensamblador / desensamblador y herramientas, y arranca CP/M por debajo del monitor. Los modos de memoria de la máquina se conmutan escribiendo modos tranZPUter (TZMM_ORIG/BOOT/TZFS/TZFS2/TZFS3/TZFS4/CPM/CPM2/COMPAT) en el puerto de E/S 0x60, que reapunta los punteros de banco; el Z80 solicita servicios del sistema de archivos y de CP/M con OUT (0x68), que encola una solicitud de servicio al Core 0 (listado de directorio, carga de archivo y los servicios de unidad de CP/M). Como picoZ80 no tiene acceso directo a la SD, los sectores de 512 bytes de CP/M se leen y escriben a través del ESP32 contra archivos de imagen completos, con las rutas de imagen por unidad tomadas de las entradas param[].file del JSON de la interfaz (plantilla de reserva CPM/SDC16M/RAW/CPMDSK<nn>.RAW). La ROM TZFS es roms/tzfs.bin en la tarjeta SD, ensamblada desde el TZFS/asm/tzfs.asm del proyecto TZFS complementario. Se distribuye en config_MZ-700_MZ-700.json con "enable": 0 — presente pero desactivado por defecto — y se activa en el JSON o desde la página de Configuración de la GUI web.
• MZ-1E05.c — Unidad de interfaz de controlador de disquetes
  - emula la unidad de controlador de disquetes Sharp MZ-1E05, que está basada en el FDC WD1773.
• MZ8BFI.c — Interfaz de disquetes MZ-8BFI / E0054PA (MZ-2000)
  - emula la interfaz de disquetes del MZ-2000 usando el FDC compatible MB8866/WD1773. A diferencia del MZ-1E05, el MZ-8BFI no tiene ROM de controlador integrada — el código del FDC reside en la ROM IPL del MZ-2000. Soporta formato de imagen de disco D88. 40 cilindros, 2 cabezales, 16 sectores/pista, sectores de 256 bytes.
• MZ-1E14.c — Controlador QuickDisk con BIOS ROM (MZ-700 / MZ-800)
  - emula el controlador QuickDisk MZ-1E14, que incluye una BIOS ROM integrada para las máquinas MZ-700 y MZ-800.
• MZ-1E19.c — Controlador QuickDisk sin BIOS ROM (MZ-800 / MZ-2000 / MZ-2200 / MZ-2500)
  - emula el controlador QuickDisk MZ-1E19, que no tiene BIOS ROM integrada y está dirigido a las máquinas MZ-800, MZ-2000, MZ-2200 y MZ-2500.
• MZ-1R12.c — Placa RAM de 32KB con batería de respaldo
  - emula la expansión de RAM Sharp MZ-1R12 de 32KB con batería de respaldo. En lugar de usar una batería real, la imagen de RAM se persiste y restaura desde la tarjeta SD. La placa se usa comúnmente para almacenar una aplicación de modo que esté disponible instantáneamente al arrancar, evitando los largos tiempos de carga de cassette.
• MZ-1R18.c — Placa RAM de 64KB
  - emula la expansión de RAM Sharp MZ-1R18 de 64KB, típicamente usada como disco RAMFILE para almacenamiento de programas o para proporcionar memoria adicional para aplicaciones personalizadas que requieren más que el espacio de direcciones estándar.
• MZ-1R23.c — ROM Kanji MZ-1R23 / ROM de Diccionario MZ-1R24
  - emula las placas de ROM Kanji de 128KB (patrones JIS de 16×16) y ROM de Diccionario opcional de 256KB. Los archivos ROM se cargan desde la tarjeta SD. Puertos de E/S B8h–B9h con lectura de auto-incremento.
• MZ-1R37.c — EMM de 640KB MZ-1R37 (Gestor de Memoria Expandida)
  - emula una placa de memoria expandida de 640KB con espacio de direcciones de 20 bits y latching de dirección de puerto de E/S.
• PIO-3034.c — EMM de 320KB IO DATA PIO-3034
  - emula una placa de memoria expandida de 320KB con contador de direcciones de 19 bits y puerto de datos de auto-incremento.
• Celestite.c — Placa compuesta Celestite LAN / Memoria
  - emula un controlador Ethernet Wiznet W5100 (archivo de registros), controlador de interrupciones, almacenamiento persistente UFM, CMOS RAM MZ-1R12 integrada de 32KB (expandible a 64KB), y EMM MZ-1R37 de 640KB opcional. Puertos de E/S 60h–6Fh. La dirección del servidor de archivos netfs.py es configurable mediante el parámetro JSON ip (por ejemplo, "192.168.1.210:6800"). La implementación de Fase 2 proporciona conectividad TCP/IP real a través del puente ESP32 — los comandos de socket W5100 (OPEN, CONNECT, LISTEN, SEND, RECV, CLOSE) se reenvían al ESP32 que realiza operaciones de socket BSD reales, permitiendo a la placa Celestite comunicarse con servicios de red como el servidor de archivos netfs.py.
• SASI.c + MZ1E30.c — Interfaz de disco duro SASI MZ-1E30
  - emula el controlador de disco duro SASI Sharp MZ-1E30 para MZ-2500/MZ-80B. Soporta hasta 4 objetivos de disco (~21.4 MB cada uno, bloques de 256 bytes), ROM IPL de 32KB, y E/S de sectores bajo demanda desde imágenes de disco en tarjeta SD. Comandos SASI: TEST_UNIT_READY, REQUEST_SENSE, READ(6), WRITE(6), SEEK(6), INQUIRY. Puertos de E/S 0xA4–0xA5 (bus SASI), 0xA8–0xA9 (acceso ROM).
• MZ8BIO3.c / MZ1E24.c — Tarjetas de interfaz serie RS-232C
  - tarjetas serie de doble canal construidas sobre un Zilog Z80 SIO emulado. Puertos 0xB0–0xB3 (base configurable): canal A en 0xB0/0xB1, canal B en 0xB2/0xB3. El canal A se puentea al puerto serie USB CDC 2 y el canal B al puerto serie USB CDC 3, de modo que un terminal, módem o programa de transferencia de archivos en el PC host se comunica con software serie de Sharp. El MZ-8BIO3 usa el cableado del conector "BI", el MZ-1E24 el cableado "ST" de Sharp; por lo demás son idénticos. Sin ROM. Disponible en las personalidades MZ-700, MZ-800, MZ-80B y MZ-1500.
• Z80SIO.c — Emulación Zilog Z80 SIO/2
  - Z80 SIO de precisión a nivel de registro (WR0–WR7, RR0–RR2, interrupciones vectorizadas en modo 2 del Z80 con una cadena en cascada en servicio de 4 niveles), usado por las tarjetas MZ-8BIO3 y MZ-1E24. Utiliza buffers en anillo de un solo productor/un solo consumidor sin bloqueos para mover bytes entre la emulación del Z80 (núcleo 1) y el servicio USB CDC (núcleo 0).

Serie Amstrad PCW Cuando se compila con INCLUDE_AMSTRAD_DRIVERS, los siguientes controladores de periféricos Amstrad se compilan e incluyen:

• PCW9512.c + uPD765.c — Conjunto de periféricos Amstrad PCW-9512
  - emulación completa del Amstrad PCW-9512 con gate array (ASIC), NEC uPD765 FDC (formato CPC DSK), 512KB de RAM con paginación de 4 bancos de 16KB, controlador de impresora de margarita 8041, emulación de secuencia de arranque y creación de imágenes de disco físico. Se soportan modos virtual y físico.

Serie Tatung Einstein Cuando se compila con INCLUDE_TATUNG_DRIVERS, los siguientes controladores de periféricos Tatung se compilan e incluyen:

• EinsteinTC01.c + EinsteinFDC.c + WD1770.c — Conjunto de periféricos Tatung Einstein TC-01
  - emulación completa del Tatung Einstein TC-01 con Z80A @ 4MHz, 64KB RAM + 8KB ROM conmutable (X-TAL MOS), conmutación ROM/RAM mediante puerto 0x24 (cualquier acceso conmuta; las escrituras siempre van a RAM), WD1770 FDC con soporte de disco virtual (40 pistas, 1 cabezal, 10 sectores, 512 bytes — discos de 200KB), TMS9129 VDP (procesador de pantalla de video) con aplicación de temporización entre accesos (~2us de intervalo), AY-3-8910 PSG (sonido de 3 canales) en puertos 0x02-0x03, Z80 CTC (4 canales) en puertos 0x28-0x2B, Z80 PIO en puertos 0x30-0x33, interfaz de teclado en puerto 0x20, y creación de imágenes de disco físico (leer disquete físico a DSK, escribir DSK a disquete físico). Se soportan modos virtual y físico. Sub-interfaz: EinsteinFDC (2 unidades, soporte de formato DSK/D88).

OpenZ80 — Personalidad para Experimentadores Cuando se compila con INCLUDE_OPEN_DRIVERS (el objetivo OpenZ80), el firmware proporciona una personalidad Z80 deliberadamente "vainilla" (src/drivers/Other/Open.c) que no lleva ningún hardware específico de máquina. Su valor clave es que le permite añadir tarjetas de interfaz virtuales tomadas de otras máquinas Sharp, Amstrad y Tatung a un ordenador Z80 a medida o de otro modo no soportado — de modo que puede escribir nuevo software para esas tarjetas, o adaptar software existente para que funcione en su propia máquina. Está destinada a dos tipos de experimentador:

• Está diseñando su propia placa Z80 — inserte el picoZ80 en el zócalo de 40 pines y déjelo actuar como un Z80 simple. En modo físico todo el espacio de direcciones y de E/S de 64K pasa directamente a su placa, y cualquier tarjeta de interfaz independiente de máquina que habilite se superpone en sus puertos de E/S. En modo virtual OpenZ80 presenta una RAM plana de 64K, en la que puede cargar una o más de sus propias imágenes ROM secuencialmente desde 0x0000, de modo que puede poner en marcha una placa que no tiene memoria ni ROM propias.
• Tiene un ordenador Z80 que no tiene un controlador picoZ80 dedicado — comience desde OpenZ80 y uno de los controladores de máquina existentes como base, luego modífiquelo para su máquina (vea más abajo).

OpenZ80 expone solo las tarjetas de interfaz que no necesitan soporte específico de personalidad, y cada una de ellas puede tener su puerto de E/S base reubicado para adaptarse a su placa (vea Puertos de E/S de Interfaz Reubicables): las tarjetas de memoria / archivo-RAM / Kanji MZ-1R12, MZ-1R18, MZ-1R23 y MZ-1R37, el EMM paralelo PIO-3034, las tarjetas serie RS-232C MZ-8BIO3 / MZ-1E24 (Z80 SIO), la interfaz de disquetes WD1773 MZ-1E05 y la placa LAN ESP32 Celestite. Compílelo con build_tzpuPico.sh open. Partiendo de un controlador o BIOS existente Para adaptar el picoZ80 a una nueva máquina, tome uno de los controladores suministrados como punto de partida y modífiquelo. Los controladores de personalidad residen bajo src/drivers/ — las máquinas Sharp en src/drivers/Sharp/ (por ejemplo, MZ700.c, MZ80A.c, MZ80K.c, MZ2000.c), el Amstrad PCW en src/drivers/Amstrad/PCW9512.c, el Tatung Einstein en src/drivers/Tatung/EinsteinTC01.c y la personalidad vainilla en src/drivers/Other/Open.c. Elija la máquina más parecida a la suya y edite su mapa de memoria, manejadores de E/S y distribución de ROM. Las ROM de monitor, IPL, BIOS de CP/M y de arranque de disquetes correspondientes se suministran como código fuente en ensamblador Z80 comentado en los proyectos complementarios RFS y TZFS, en sus directorios asm/, de modo que puede recompilarlas o parchearlas para su máquina:

• ROM de monitor — RFS/asm/sp1002.asm (MZ-80K SP-1002), RFS/asm/sa1510.asm (MZ-80A SA-1510), RFS/asm/1z-013a.asm y TZFS/asm/1z-013a.asm (MZ-700), RFS/asm/mz800_iocs.asm (MZ-800 IOCS).
• Cargadores de arranque (IPL) — TZFS/asm/mz2000_ipl.asm (MZ-2000), TZFS/asm/mz80b_ipl.asm (MZ-80B), RFS/asm/ipl.asm.
• BIOS de CP/M — RFS/asm/cbios.asm y RFS/asm/cpm22-bios.asm (también TZFS/asm/cbios.asm / cbiosII.asm).
• ROM de arranque de disquetes / QuickDisk — RFS/asm/mz80afi.asm (MZ-80A FDC), TZFS/asm/mz80kfdif.asm (MZ-80K FDIF), RFS/asm/mz-1e05.asm, RFS/asm/mz-1e14.asm (QD), RFS/asm/sfd700.asm.
• ROM de sistema de archivos — la propia ROM RFS (RFS/asm/rfs.asm, banqueada) y la ROM TZFS (TZFS/asm/tzfs.asm, banqueada) pueden tomarse como base para un sistema de archivos en ROM personalizado.

Consulte la Guía del Desarrollador para un ejemplo práctico paso a paso de cómo escribir o adaptar un controlador. Se añadirán personalidades Sharp MZ adicionales y soporte para otras máquinas basadas en Z80 en su momento. Múltiples personalidades pueden coexistir en la configuración JSON, cada una asociada a un banco PSRAM diferente. Cambiar de personalidad modifica el mapa de memoria activo y las imágenes ROM cargadas sin reiniciar el host.

El proyecto picoZ80 incluye un servidor de archivos en red basado en Python (tools/NetFileServer/netfs.py) que se ejecuta en un PC con Windows o Linux y sirve archivos de programa MZF al dispositivo BASIC NETx: del Sharp MZ a través de la red. Cuando el picoZ80 está equipado con una placa Celestite (o el controlador virtual Celestite), los programas BASIC que se ejecutan en el MZ pueden cargar, guardar y listar archivos del sistema de archivos del PC usando comandos BASIC estándar con el prefijo de dispositivo NETx:.

python3 netfs.py [--port 6800] [--dir ./mzf_files] [--dir2 path] ... [--dir7 path]

El servidor soporta las unidades 1–7 (NET1: a NET7:), cada una mapeada a un directorio separado en el PC. Comandos soportados: DIR (listado de directorio), READ (cargar datos de archivo), WRITE (guardar archivo), INFO (metadatos de archivo), DELETE y CLOSE. El servidor es multihilo, gestiona el análisis y creación de cabeceras MZF, e incluye un tiempo de espera de conexión de 30 segundos para recuperación de fallos.

La forma más sencilla de compilar el firmware del picoZ80 es descargar y ejecutar el script de configuración automatizada para su plataforma. Instala todas las dependencias, clona los repositorios, configura las rutas y crea scripts de compilación listos para usar — sin necesidad de configuración manual.

Descargue y ejecute el script de configuración desde cualquier directorio. Le solicitará una ubicación de instalación (predeterminada: ~/pico).

curl -O https://git.eaw.app/eaw/pico/raw/branch/master/setup_picoZ80.sh
chmod +x setup_picoZ80.sh
./setup_picoZ80.sh

El script realiza lo siguiente:

• Detecta su sistema operativo (Debian/Ubuntu, Fedora/RHEL, Arch/Manjaro, macOS) e instala los paquetes requeridos — CMake, compilador cruzado ARM, Git, Python, Perl, rsync.
• Clona el repositorio picoZ80, el Pico SDK (rama develop), Pico Examples y Pico Extras con todos los submódulos.
• Configura los scripts de compilación con las rutas correctas e instala la cabecera de placa del picoZ80 en el SDK.
• Opcionalmente configura Docker y descarga la imagen espressif/idf:release-v5.4 para las compilaciones de firmware ESP32.
• Crea ~/picoZ80_env.sh — un archivo de entorno para cargar con source en sesiones futuras. Establece todas las rutas requeridas y proporciona la función auxiliar idf54 para compilaciones ESP32 transparentes mediante Docker (preferido) o una instalación nativa de ESP-IDF (alternativa).

Tras la configuración, cargue el entorno con source y compile:

# Add to your ~/.bashrc or ~/.zshrc for automatic loading:
source ~/picoZ80_env.sh

# Build all RP2350 targets
build_tzpuPico.sh

# Build a specific target family
build_tzpuPico.sh sharp              # Sharp MZ targets only
build_tzpuPico.sh amstrad            # Amstrad PCW targets only
build_tzpuPico.sh tatung             # Tatung Einstein targets only
build_tzpuPico.sh open               # OpenZ80 experimenter persona only

# Build with debug symbols
build_tzpuPico.sh DEBUG

# Build everything including ESP32 firmware
build_tzpuPico.sh ALL

# Build ESP32 firmware only
build_esp32

Descargue setup_picoZ80_windows.ps1 y ejécutelo desde un símbolo de PowerShell de Administrador:

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\setup_picoZ80_windows.ps1

El script de Windows realiza los mismos pasos adaptados al ecosistema Windows:

• Instala las herramientas requeridas mediante winget — Git, CMake, Ninja, Python, Perl y el ARM GNU Toolchain. Proporciona URLs de descarga manual para cualquier herramienta que no pueda instalarse automáticamente.
• Clona todos los repositorios y configura las rutas.
• Crea build_tzpuPico.bat y picoZ80_env.bat preconfigurados para su ubicación de instalación.
• Ofrece tres opciones para las compilaciones ESP32: Docker Desktop, el instalador offline de Espressif ESP-IDF (~1.5 GB), u omitir.

Tras la configuración, abra un nuevo Símbolo del sistema:

picoZ80_env.bat
build_tzpuPico.bat                   REM build all RP2350 targets
build_tzpuPico.bat sharp             REM build Sharp targets only
build_tzpuPico.bat ALL               REM build RP2350 + ESP32
build_tzpuPico.bat esp32             REM build ESP32 firmware only

Nota: no ejecute build_tzpuPico.bat desde un símbolo de PowerShell/CMD de ESP-IDF — la cadena de herramientas ESP-IDF anula cmake y no puede compilar las herramientas anfitrión del RP2350. El archivo por lotes detecta esto y sale con un error claro. La activación de ESP-IDF se gestiona automáticamente en el paso de compilación del ESP32.

El sistema de compilación produce binarios de firmware específicos por máquina para reducir el tamaño del firmware cuando solo se necesita un subconjunto de controladores:

Cada modelo objetivo tiene su propio directorio bajo src/model/ con un CMakeLists.txt dedicado, punto de entrada y scripts de enlazado. Use el objetivo BaseZ80 para máxima compatibilidad o seleccione un objetivo específico de máquina para un binario más pequeño que se ajuste más cómodamente en la partición de firmware de 5MB. El directorio fw/uf2/ contiene las imágenes UF2 del Bootloader (para la carga inicial por almacenamiento masivo USB); el directorio fw/bin/ contiene las imágenes binarias (.bin) de la partición de aplicación para actualizaciones OTA. Las particiones de aplicación se ubican en direcciones Flash no estándar que el formato UF2 no puede expresar, por lo que se usa binario plano para todas las transferencias OTA. Cada objetivo se compila en variantes estándar y DBGSH — la variante DBGSH habilita el shell de depuración ICE completo en el Canal 1 USB CDC.

Si prefiere configurar el entorno manualmente en lugar de usar los scripts de configuración automatizada, los pasos son:

1. Instale los prerequisitos: CMake 3.20+, arm-none-eabi-gcc (compilador cruzado ARM), Git, Python 3, Perl y, opcionalmente, Docker o una instalación nativa de ESP-IDF v5.4 para las compilaciones ESP32.
2. Clone el repositorio principal: git clone https://git.eaw.app/eaw/pico.git <root>
3. Clone el Pico SDK: git clone https://github.com/raspberrypi/pico-sdk.git --branch develop y ejecute git submodule update --init dentro de él.
4. Clone Pico Extras: git clone https://github.com/raspberrypi/pico-extras.git y ejecute git submodule update --init dentro de él.
5. Edite la variable PICO_PATH al inicio de build_tzpuPico.sh para que apunte a su directorio raíz.
6. Ejecute ./build_tzpuPico.sh para compilar el firmware del RP2350, o ./build_tzpuPico.sh ALL para incluir el firmware del ESP32.

Consulte la sección Guía del Desarrollador — Configuración del Entorno de Desarrollo para todos los detalles sobre los procedimientos automatizado y manual.

No hay botón físico BOOTSEL ni Reset en la placa picoZ80. Ambas señales están expuestas en el cabezal de depuración de 6 pines:

Para entrar en el modo de almacenamiento masivo del cargador de arranque del RP2350, use un jumper o sonda en el cabezal de depuración:

1. Mantenga el Pin 6 (BOOTSEL) en bajo.
2. Aplique alimentación, o aserte el Pin 3 (Reset RP2350) en bajo y luego suéltelo — el RP2350 comienza a arrancar.
3. Suelte BOOTSEL rápidamente después del encendido o reset. Mantenerlo en bajo más allá del momento inicial de arranque impide que el RP2350 acceda a la FlashRAM.
4. Conecte el puerto USB del picoZ80 a un PC — el RP2350 se enumera como un dispositivo de almacenamiento masivo USB.
5. Copie Bootloader_<version>.uf2 a la unidad montada. El RP2350 se auto-graba el cargador de arranque y se reinicia.

Todas las actualizaciones subsiguientes del firmware RP2350 pueden realizarse mediante la página web OTA sin tocar el cabezal de depuración.

El ESP32 se graba usando esptool mediante un entorno virtual de Python. En revisiones más nuevas de la placa, el ESP32 aparece como su propio dispositivo USB; en las placas originales con un solo puerto USB solo era accesible a través del RP2350 actuando como puente USB-UART. En ambos casos el Pin 4 (Reset ESP32) en el cabezal de depuración se utiliza para mantener el ESP32 en reset durante la secuencia de arranque del RP2350 cuando sea necesario. Configure el entorno de esptool una vez:

python3 -m venv ./venv/
source ./venv/bin/activate
cd $HOME/esptool

Luego grabe los cuatro componentes del firmware ESP32 en un solo comando, ajustando PORT para coincidir con el nodo de dispositivo asignado por su sistema operativo y BINPATH al directorio que contiene los binarios compilados:

PORT=/dev/tty.usbmodem141403   # adjust to your system
BINPATH=/path/to/build/output

python3 ./esptool.py \
  -p ${PORT} -b 115200 \
  --before default_reset --after hard_reset \
  --chip esp32s3 \
  write_flash \
  --flash_mode dio --flash_size 4MB --flash_freq 80m \
  0x0     ${BINPATH}/bootloader.bin \
  0x8000  ${BINPATH}/partition-table.bin \
  0x9000  ${BINPATH}/ota_data_initial.bin \
  0x10000 ${BINPATH}/sd_card.bin

Todas las actualizaciones subsiguientes del firmware ESP32 pueden realizarse mediante la página web OTA (ota-esp32.htm) sin necesidad de esptool. Nota sobre revisión de placa: Las placas picoZ80 originales (v2.0 a v2.2) tienen un solo puerto USB conectado al RP2350. En estas placas el ESP32 debe programarse mediante el RP2350 actuando como puente USB-UART. Las revisiones más nuevas de la placa añaden un segundo puerto USB conectado directamente al ESP32, permitiendo a esptool direccionarlo independientemente.

• RP2350 OTA
  - navegue a http://<device-ip>/ota-rp2350.htm, seleccione el archivo .bin versionado de fw/bin/ y cárguelo. Las particiones de aplicación se ubican en direcciones Flash no estándar, por lo que se requiere binario puro (no UF2). El cargador de arranque verifica el checksum de la imagen antes de activar la nueva partición.
• ESP32 OTA
  - navegue a http://<device-ip>/ota-esp32.htm y cargue el binario del firmware ESP32. El ESP32 se reinicia automáticamente con el nuevo firmware. La misma página también acepta un archivo FilePack versionado que actualiza el sistema de archivos web del ESP32 en la tarjeta SD — consulte Carga de FilePack a continuación.

Formatee la tarjeta SD como FAT32. Coloque config.json en el directorio raíz. Cree subdirectorios para imágenes ROM, imágenes de disco y árboles de sistema de archivos según se referencien en su configuración. Una vez que la placa esté funcionando, la tarjeta SD también puede gestionarse completamente a través de la página web File Manager.

El picoZ80 soporta depuración completa a nivel de código fuente de ambos núcleos del RP2350 y del coprocesador ESP32. El RP2350 se depura por SWD usando una sonda CMSIS-DAP, con OpenOCD proporcionando un servidor GDB de dos objetivos (un puerto por núcleo). El ESP32-S3 se depura a través de su interfaz USB-JTAG integrada usando el GDB del toolchain Xtensa.

Conexión de hardware
Conecte una sonda ARM DAPLink / CMSIS-DAP (por ejemplo, Raspberry Pi Debug Probe, Black Magic Probe o cualquier adaptador compatible con CMSIS-DAP) al cabezal de depuración de 6 pines en la placa picoZ80. Solo se requieren tres conexiones:

Pin del Cabezal de Depuración	Señal	Función SWD
Pin 1	SWCLK	Reloj Serial Wire
Pin 2	SWDIO	Datos Serial Wire
Pin 5	GND	Referencia de tierra

Iniciando OpenOCD
OpenOCD expone dos puertos de servidor GDB — el puerto 3333 para el Núcleo 0 y el puerto 3334 para el Núcleo 1. El picoZ80 requiere una pequeña modificación al script de objetivo estándar de OpenOCD para RP2350 para habilitar la depuración SMP verdadera con puertos GDB separados por núcleo. Copie el script estándar y descomente la línea target smp:

sudo cp /usr/local/share/openocd/scripts/target/rp2350.cfg \
        /usr/local/share/openocd/scripts/target/rp2350_tzpu.cfg

Luego edite rp2350_tzpu.cfg — encuentre la línea target smp dentro del bloque if {[string compare $_USE_CORE SMP] == 0} y elimine el # inicial:

# Before (rp2350.cfg):
    #target smp $_TARGETNAME_0 $_TARGETNAME_1

# After (rp2350_tzpu.cfg):
    target smp $_TARGETNAME_0 $_TARGETNAME_1

Este único cambio activa el modo SMP para que OpenOCD registre el Núcleo 0 en el puerto GDB 3333 y el Núcleo 1 en el puerto 3334, permitiendo conectar y avanzar paso a paso cada núcleo independientemente. Inicie OpenOCD desde la raíz del proyecto antes de iniciar GDB:

openocd -f interface/cmsis-dap.cfg -f target/rp2350_tzpu.cfg -c "adapter speed 5000"

Inicialización global de GDB (~/.gdbinit)
GDB requiere permiso explícito para auto-cargar archivos .gdbinit por directorio. Añada lo siguiente a ~/.gdbinit, ajustando las rutas para coincidir con la ubicación de su proyecto (mostradas aquí relativas a la raíz del proyecto — use rutas absolutas en ~/.gdbinit si ejecuta GDB desde directorios variables):

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

Copie el archivo .gdbinit apropiado por núcleo al directorio de compilación del Bootloader, luego ejecute gdb-multiarch. El archivo .gdbinit.bootloader.3333 se conecta al Núcleo 0 (puerto 3333) y registra la salida en gdb_core0.txt; .gdbinit.bootloader.3334 se conecta al Núcleo 1 (puerto 3334) registrando en gdb_core1.txt. Abra dos terminales para depurar ambos núcleos simultáneamente:

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

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

Los archivos .gdbinit del firmware principal (.gdbinit.3333 y .gdbinit.3334) definen un comando personalizado xac <address> <count> que vuelca la memoria como salida hexadecimal y ASCII combinada, se conectan al puerto GDB respectivo y continúan la ejecución. Esto es útil para inspeccionar contenidos de bancos PSRAM y estado de dispositivos mapeados en memoria sin detener el bucle de emulación:

# Terminal 1 — Core 0
cd build/bin/model/BaseZ80
cp ../../../../.gdbinit.3333 .gdbinit
gdb-multiarch BaseZ80_0x10020000.elf

# Terminal 2 — Core 1
cd build/bin/model/BaseZ80
cp ../../../../.gdbinit.3334 .gdbinit
gdb-multiarch BaseZ80_0x10020000.elf

# Memory dump example (in GDB prompt):
(gdb) xac 0x20000000 64

El coprocesador ESP32-S3 tiene una interfaz USB-JTAG integrada — no se requiere sonda de depuración externa. Conecte un cable USB desde un PC host directamente al puerto USB del ESP32 en la placa picoZ80. Inicie OpenOCD usando la configuración JTAG integrada del ESP32-S3:

openocd -f board/esp32s3-builtin.cfg

Luego ejecute el GDB de Xtensa apuntando al ELF del firmware ESP32 (ubicado en esp32/build/main.elf relativo a la raíz del proyecto) y conéctese al servidor GDB de OpenOCD:

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

Asegúrese de que el ELF fue compilado desde la misma revisión de código fuente que el firmware grabado en el dispositivo para que los símbolos y direcciones se alineen correctamente.

Todo el comportamiento del picoZ80 se controla mediante config.json en la tarjeta SD. El RP2350 lee este archivo al arrancar a través del ESP32, lo minifica y almacena el resultado en Flash. Si no hay tarjeta SD presente, se usa la configuración almacenada previamente. La configuración puede editarse directamente en el navegador usando la página Config Editor. La estructura de nivel superior es:

{
  "esp32": {
    "core": {
      "device": "Z80",
      "mode":   0
    },
    "wifi": {
      "override":  1,
      "wifimode":  "client",
      "ssid":      "MyNetwork",
      "password":  "MyPassword",
      "ip":        "192.168.1.192",
      "netmask":   "255.255.255.0",
      "gateway":   "192.168.1.1",
      "dhcp":      0,
      "webfs":     "webfs",
      "persist":   0
    }
  },
  "rp2350": {
    "core": {
      "cpufreq":   300000000,
      "psramfreq": 133000000,
      "voltage":   1.10
    },
    "z80": [
      {
        "memory":  [ ... ],
        "io":      [ ... ],
        "drivers": [ ... ]
      }
    ]
  }
}

El objeto de nivel superior esp32 configura el coprocesador ESP32. Contiene dos sub-objetos: core y wifi.

El objeto wifi proporciona un mecanismo para inyectar credenciales WiFi y ajustes de red desde config.json, anulando lo que esté almacenado en NVS. Esto es útil para el aprovisionamiento inicial o para desplegar una configuración de red conocida y funcional sin usar el WiFi Manager web. Establezca override a 0 para ignorar completamente el archivo de configuración y depender de los ajustes NVS persistidos previamente.

El arreglo memory define el mapa de memoria del Z80. Cada entrada cubre una región contigua del espacio de direcciones Z80 de 64KB, redondeada a límites de bloques de 512 bytes.

"memory": [
  {
    "enable":   1,
    "addr":     "0x0000",
    "size":     "0x1000",
    "type":     "ROM",
    "bank":     0,
    "tcycwait": 0,
    "tcycsync": 0,
    "task":     "",
    "file":     "/TZFS/tzfs.rom",
    "fileofs":  0
  },
  {
    "enable":   1,
    "addr":     "0x1000",
    "size":     "0xCFFF",
    "type":     "RAM",
    "bank":     0,
    "tcycwait": 0,
    "tcycsync": 0,
    "task":     "",
    "file":     "",
    "fileofs":  0
  },
  {
    "enable":   1,
    "addr":     "0xD000",
    "size":     "0x1000",
    "type":     "PHYSICAL_VRAM",
    "bank":     0,
    "tcycwait": 2,
    "tcycsync": 0,
    "task":     "",
    "file":     "",
    "fileofs":  0
  }
]

El arreglo io mapea rangos de puertos de E/S del Z80 a manejadores. Los ciclos de E/S se distinguen de los ciclos de memoria por la señal IORQ del Z80, que la máquina de estado de control PIO monitorea.

"io": [
  {
    "enable": 1,
    "addr":   "0xE0",
    "size":   "0x08",
    "type":   "FUNC",
    "func":   "mz700_io"
  },
  {
    "enable": 1,
    "addr":   "0x00",
    "size":   "0xE0",
    "type":   "PHYSICAL"
  }
]

El arreglo drivers vincula instancias de controladores nombrados al contexto Z80. Cada controlador tiene una o más interfaces (listadas bajo la clave "if"), cada una de las cuales puede cargar imágenes ROM, remapear rangos de direcciones, remapear rangos de puertos de E/S y recibir archivos de parámetros.

Para que las tarjetas de interfaz independientes de máquina puedan usarse en placas personalizadas / de experimentador (vea OpenZ80), varias tarjetas pueden tener su puerto de E/S base reubicado. Una tarjeta reubicable lee su dirección base del dstaddr de su entrada iomap (con srcaddr establecido al puerto auténtico de la tarjeta), y usa por defecto su puerto original cuando no hay ninguna entrada iomap presente. La forma más sencilla de configurarlo es el campo Base I/O Port en la página de Configuración GUI, que escribe la entrada iomap correcta por usted. Las tarjetas reubicables y sus bases predeterminadas son:

"drivers": [
  {
    "enable": 1,
    "name":   "MZ700",
    "type":   "PHYSICAL",
    "if": [
      {
        "enable": 1,
        "name":   "main",
        "type":   "PHYSICAL",
        "rom": [
          {
            "enable":   1,
            "file":     "/MZ700/mz700.rom",
            "loadaddr": [
              {
                "enable":   1,
                "position": 0,
                "addr":     "0x0000",
                "bank":     0,
                "size":     "0x1000",
                "tcycwait": 0,
                "tcycsync": 0
              }
            ]
          }
        ],
        "addrmap": [
          {
            "enable":  1,
            "srcaddr": "0x0000",
            "size":    "0x1000",
            "dstaddr": "0x0000"
          }
        ],
        "iomap": [
          {
            "enable":  1,
            "srcaddr": "0xE0",
            "size":    "0x08",
            "dstaddr": "0xE0",
            "16bit":   0
          }
        ],
        "param": [
          {
            "enable": 1,
            "file":   "/config/mz700.cfg"
          }
        ]
      }
    ]
  },
  {
    "enable": 1,
    "name":   "MZ-1E05",
    "type":   "PHYSICAL",
    "if": [
      {
        "enable": 1,
        "name":   "fdc0",
        "type":   "PHYSICAL",
        "rom":    [],
        "addrmap": [],
        "iomap": [
          {
            "enable":  1,
            "srcaddr": "0xD8",
            "size":    "0x04",
            "dstaddr": "0xD8",
            "16bit":   0
          }
        ],
        "param": [
          {
            "enable": 1,
            "file":   "/DSK/MZ700/disk0.dsk"
          }
        ]
      }
    ]
  }
]

A continuación se muestra una configuración mínima que arranca un MZ-700 con ROM, 48KB de RAM, VRAM del host y el controlador de disquetes WD1773:

{
  "rp2350": {
    "core": {
      "cpufreq":   300000000,
      "psramfreq": 133000000,
      "voltage":   1.10
    },
    "z80": [
      {
        "memory": [
          { "enable":1, "addr":"0x0000", "size":"0x1000", "type":"ROM",
            "bank":0, "tcycwait":0, "tcycsync":0, "task":"",
            "file":"/MZ700/mz700.rom", "fileofs":0 },
          { "enable":1, "addr":"0x1000", "size":"0xCFFF", "type":"RAM",
            "bank":0, "tcycwait":0, "tcycsync":0, "task":"", "file":"", "fileofs":0 },
          { "enable":1, "addr":"0xD000", "size":"0x1000", "type":"PHYSICAL_VRAM",
            "bank":0, "tcycwait":2, "tcycsync":0, "task":"", "file":"", "fileofs":0 },
          { "enable":1, "addr":"0xE000", "size":"0x2000", "type":"PHYSICAL",
            "bank":0, "tcycwait":0, "tcycsync":0, "task":"", "file":"", "fileofs":0 }
        ],
        "io": [
          { "enable":1, "addr":"0xE0", "size":"0x08", "type":"FUNC", "func":"mz700_io" },
          { "enable":1, "addr":"0xD8", "size":"0x04", "type":"FUNC", "func":"wd1773_io" }
        ],
        "drivers": [
          {
            "enable":1, "name":"MZ700", "type":"PHYSICAL",
            "if": [{ "enable":1, "name":"main", "type":"PHYSICAL",
                     "rom":[], "addrmap":[], "iomap":[], "param":[] }]
          },
          {
            "enable":1, "name":"MZ-1E05", "type":"PHYSICAL",
            "if": [{ "enable":1, "name":"fdc0", "type":"PHYSICAL",
                     "rom":[], "addrmap":[], "iomap":[],
                     "param":[{ "enable":1, "file":"/DSK/MZ700/disk0.dsk" }] }]
          }
        ]
      }
    ]
  }
}

El picoZ80 incluye un shell de depuración ICE (Emulador en Circuito) interactivo integrado a través del segundo canal serial USB CDC. Conecte un emulador de terminal (115200 baudios, 8N1) al puerto serial de depuración — aparece como el segundo puerto COM/ttyACM cuando el picoZ80 está conectado por USB. El prompt del shell es dbg> . El firmware está disponible en dos variantes: una compilación estándar sin el shell de depuración, y una compilación DBGSH que incluye el depurador ICE completo. La variante DBGSH se identifica por el sufijo _DBGSH en el nombre del archivo de firmware.

El shell de depuración proporciona 49 comandos para la inspección y control en tiempo real de la emulación del CPU Z80:

Puntos de interrupción — se pueden activar hasta 8 puntos de interrupción simultáneamente. Cuando se alcanza un punto de interrupción, la CPU se detiene automáticamente y se muestra la dirección alcanzada. Use go para continuar o step para avanzar paso a paso desde el punto de interrupción. Trazado de ejecución — cuando está habilitado, el PC, opcode y registro de flags de cada instrucción ejecutada se registran en un buffer circular de 512 entradas. Use trace dump para inspeccionar el historial de ejecución reciente con desensamblado completo. Modos de acceso a memoria — dm p lee memoria a través del bus físico Z80 (activando respuestas de hardware real), dm f lee usando ciclos de fetch (M1), dm v lee directamente de la PSRAM virtual (cero actividad de bus) y dm r lee el espacio de direcciones propio del RP2350 (Flash, SRAM, periféricos).

El picoZ80 soporta tres modos de red, seleccionables en tiempo de compilación mediante archivos sdkconfig preconstruidos del ESP32. Cada modo determina cómo se accede a la interfaz web y las páginas de configuración.

USB NCM (Network Control Model) presenta un adaptador Ethernet virtual a través del puerto USB OTG del ESP32. Cuando el picoZ80 está conectado a un ordenador host mediante USB, el host ve una interfaz de red estándar. Un servidor DHCP integrado en el picoZ80 asigna automáticamente una dirección IP al host — no se requiere configuración manual. La interfaz web es entonces accesible en http://192.168.7.1. El modo NCM Only es el predeterminado recomendado para placas enviadas sin certificación WiFi. Proporciona funcionalidad completa de interfaz web (configuración, actualizaciones de firmware, gestión de archivos, selección de personalidad) sin emisión de radiofrecuencia. La red de adaptación de antena WiFi no necesita estar poblada en la PCB. El modo WiFi + NCM habilita ambas interfaces simultáneamente. El servidor HTTP se vincula a todas las interfaces, por lo que las páginas web son accesibles tanto desde WiFi como desde la conexión de red USB. WiFi se conecta de forma asincrónica, por lo que la interfaz USB NCM está disponible inmediatamente al encender. Para cambiar de modo, copie el archivo sdkconfig.mode_* apropiado a sdkconfig en el directorio de compilación del ESP32, recompile y grabe el firmware del ESP32.

Importante: La placa picoZ80 no ha sido sometida a certificación de radiador intencional FCC (EE.UU.) o RED (UE). Tal como se envía, la placa debe tener los componentes de adaptación de antena WiFi sin poblar y el firmware del ESP32 compilado con la configuración NCM Only (sdkconfig.mode_ncm_only). En esta configuración no se emite energía de radiofrecuencia y la placa no está sujeta a regulaciones de radiadores intencionales. Los usuarios finales que deseen usar WiFi pueden poblar la red de adaptación de antena en la PCB, compilar el firmware del ESP32 con sdkconfig.mode_wifi_only o sdkconfig.mode_wifi_and_ncm, y operar la placa bajo la exención de hobbyista/experimental aplicable en su jurisdicción. Cualquier parte que desee vender la placa comercialmente con WiFi habilitado debe primero obtener la certificación FCC y/o RED para el ensamblaje completo.

El coprocesador ESP32 aloja una interfaz de gestión web construida con Bootstrap 4. Conéctese a la red WiFi del picoZ80 (o configure el modo cliente para unirse a su red existente) y navegue a http://<device-ip>/ — por defecto http://192.168.4.1/ en modo Access Point. En modo NCM, la interfaz web se accede en http://192.168.7.1 mediante la conexión de red USB. Consulte Red arriba para detalles de los modos. En el primer encendido en modo WiFi, la placa inicia en modo AP. Use la página WiFi Manager para configurar el modo cliente y asignar una dirección IP fija en su red. Todas las páginas comparten una barra de navegación izquierda común que da acceso con un clic a Status, Config Editor, Config GUI, File Manager, Settings (Firmware → ESP32 / RP2350, WiFi Manager) y Persona. En modo NCM Only, la página WiFi Manager no está presente y la barra de navegación muestra el mismo conjunto de páginas menos WiFi Manager.

La página de inicio muestra el estado en vivo de la placa a través de tres paneles:

• WiFi Configuration / Network Configuration
  - en modos WiFi este panel muestra el SSID actual, la dirección IP asignada, máscara de red y puerta de enlace. En modo NCM Only este panel se titula Network Configuration y muestra el estado de la red USB NCM (dirección IP, máscara de red) en su lugar — no hay información de SSID ni WiFi. El nombre de la placa (tzpuPico) y la cadena de copyright se sirven como variables de plantilla por el servidor web del ESP32.
• Version Information
  - tabla de particiones del ESP32 mostrando todas las ranuras OTA con tipo, sub-tipo, dirección Flash, tamaño, versión de firmware, marca de tiempo de compilación y qué ranura está actualmente en ejecución. Esto facilita la confirmación de qué firmware está activo después de una actualización OTA.
• RP2350 Partitions
  - la tabla de particiones Flash del RP2350 con número de partición, dirección, tamaño, checksum, indicador de activo/en ejecución, licencia, autor, descripción, versión, fecha de compilación y copyright — proporcionando una instantánea completa del estado del firmware del RP2350 junto con la información del ESP32.

Dos menús desplegables en la barra de navegación superior derecha están disponibles en todas las páginas:

• Menú Actions
  - Change Floppy Disk 1 / 2 — seleccione un nuevo archivo de imagen DSK desde la tarjeta SD y móntelo en la ranura 1 o 2 del controlador de disquetes virtual WD1773 sin reiniciar. El nombre del archivo de imagen de disco cargado actualmente se muestra junto a cada entrada (o "none" si no hay imagen cargada).
  - Change QD Disk — intercambie la imagen QuickDisk activa sobre la marcha. El nombre del archivo de imagen QD cargado actualmente se muestra junto a la entrada.
  - Reload RP2350 Config — envíe un comando de recarga al RP2350 a través del UART ESP32–RP2350; el RP2350 re-analiza config.json y re-aplica el mapa de memoria y la configuración de controladores sin un ciclo de alimentación completo.
• Menú Reboot
  - ESP32 — reinicio suave del coprocesador ESP32 (reinicia el servidor web y la pila WiFi, el RP2350 no se afecta).
  - RP2350B — reinicia el procesador RP2350 (re-ejecuta el cargador de arranque y recarga la ranura de firmware activa, la CPU del host se pausa durante el reinicio).
  - Host — aserta la línea de reset del ordenador host, reiniciando el ordenador heredado en el zócalo Z80 sin afectar la placa picoZ80 en sí.
  - IPL Reset — realiza un reinicio IPL (Carga Inicial de Programa) conmutando el bit 3 del Puerto C del 8255 PPI, devolviendo la máquina al modo de arranque (BST). Disponible en las personalidades MZ-80B, MZ-2000, MZ-2200 y MZ-2500 — equivalente a presionar el botón IPL en el hardware original.
  - RP2350 UF2 Boot — fuerza al RP2350 al modo de arranque UF2 USB de ROM mediante el cargador de arranque personalizado. El ESP32 reinicia el RP2350 con el pin BOOT mantenido, luego envía un ID mágico por UART que hace que el cargador de arranque llame a reset_usb_boot(). El RP2350 se presenta como un dispositivo de almacenamiento masivo USB para carga de firmware por arrastrar y soltar UF2. Este es el método de recuperación principal cuando la aplicación principal está dañada (por ejemplo, ajustes incorrectos de reloj/voltaje) — el cargador de arranque personalizado se ejecuta con valores predeterminados seguros y permanece receptivo.
  - RP2350 UF2 Boot (App) — solicita a la aplicación RP2350 en ejecución que entre en modo de arranque UF2 USB mediante comando SPI. Este es un recurso alternativo para situaciones donde el propio cargador de arranque necesita reemplazarse — la aplicación en ejecución llama a reset_usb_boot() directamente. Solo funciona cuando la aplicación está en ejecución y receptiva a comandos SPI.

La página del Editor de Configuración proporciona control completo de edición sobre el archivo de configuración JSON. Modifique la configuración usando el editor WYSIWYG, guarde según sea necesario y haga clic en Apply para reprocesar la configuración. La tarjeta SD mantiene copias de respaldo numeradas automáticas de cada configuración guardada (config.json;1, config.json;2, … siendo el número más alto el más reciente), por lo que siempre es posible volver a una configuración de trabajo anterior. Las configuraciones editadas se guardan de vuelta en la tarjeta SD; al hacer clic en Apply o en una acción de menú "Reload" se envía un comando de recarga al RP2350 a través del UART ESP32–RP2350, haciendo que el RP2350 re-analice y re-aplique la nueva configuración y que el ESP32 analice y recargue su configuración.

La página de Configuración GUI proporciona un editor gráfico basado en formularios para la configuración del picoZ80, complementando el Editor de Configuración JSON directo. En lugar de editar JSON directamente, todos los ajustes se presentan como campos de entrada etiquetados, menús desplegables y tablas editables. Los cambios se guardan en config.json en la tarjeta SD (el archivo existente se respalda automáticamente antes de guardar). Para edición avanzada, el Editor de Configuración permanece disponible para manipulación directa del JSON. La página está organizada en cuatro pestañas: RP2350 Global — ajustes globales del núcleo que aplican a ambas particiones de firmware a menos que se anulen a nivel de partición:

• Core Voltage — voltaje del núcleo RP2350 en voltios (por ejemplo, 1.10 V).
• CPU Frequency (MHz) — velocidad de reloj del RP2350. El rango válido se muestra junto al campo.
• PSRAM Frequency (MHz) — frecuencia de reloj SPI de la PSRAM. Valores más altos mejoran la velocidad de emulación pero pueden reducir la estabilidad en algunas placas.

Partition 1 / Partition 2 — configuración por partición. Cada pestaña de partición tiene el mismo diseño:

• Core Settings — anulaciones específicas de partición para Core Voltage, CPU Frequency y PSRAM Frequency. Si se establecen, tienen prioridad sobre los valores globales para esta partición.
• Memory Regions — una tabla editable que define el mapa de memoria del Z80. Cada fila especifica un bloque de memoria con: Address hexadecimal, Size, Type (ROM, RAM, PHYSICAL o FUNC), T-States (estados de espera), Bank (número de banco PSRAM), Track (indicador de sincronización de ciclo T), File (nombre del archivo de imagen ROM en la tarjeta SD), File Offset y una casilla Load. Se pueden añadir o eliminar filas con los botones Add Memory Region y eliminar.
• I/O Regions — una tabla editable que define el mapa de puertos de E/S del Z80. Cada fila especifica: Address, Size, Type y Function (el manejador del controlador). Añada o elimine filas según sea necesario.
• Drivers — lista los controladores de periféricos activos (por ejemplo, MZ80AFI, RFS, MZ-1E30, Celestite) con interruptores de habilitar/deshabilitar. El botón Add Driver presenta un desplegable de los controladores válidos para el firmware en ejecución — la página lee la cadena de personalidad del firmware y ofrece solo los controladores de esa serie (Sharp, Amstrad, Tatung u Open). Cada controlador lista sus System ROMs (imágenes ROM a nivel de controlador que sobrescriben las ROM del host) y sus Interfaces; se pueden añadir controladores de disquetes, QuickDisk, placas de RAM/ROM, disco duro SASI, tarjetas serie RS-232C e interfaces LAN, y los archivos ROM, imágenes de disco y parámetros de cada interfaz pueden configurarse en línea.
  • Base I/O Port — para las tarjetas de interfaz reubicables (MZ-1R12, MZ-1R18, MZ-1R23, MZ-1R37, PIO-3034, MZ-8BIO3, MZ-1E24, MZ-1E05, Celestite) se muestra un único campo hexadecimal Base I/O Port, precargado con la base auténtica de la tarjeta. Cámbielo para mover los puertos de la tarjeta en una placa personalizada (vea Puertos de E/S de Interfaz Reubicables); la GUI escribe automáticamente la entrada iomap correspondiente, y la omite cuando deja el valor en el predeterminado.
  • Parámetro Port — las tarjetas serie RS-232C (MZ-8BIO3 / MZ-1E24) también aceptan un parámetro numérico Port para su puerto de E/S base (predeterminado 0xB0; canal A → USB CDC 2, canal B → USB CDC 3).

ESP32 — ajustes del coprocesador ESP32:

• Core — tipo de dispositivo ESP32 (por ejemplo, S3S).
• Network Interfaces — controles de habilitar/deshabilitar para ambas redes WiFi y USB NCM:
  • WiFi Enable — casilla para habilitar o deshabilitar WiFi (requiere reinicio; ignorada si WiFi no está compilado en el firmware).
  • NCM Enable — casilla para habilitar o deshabilitar la red USB NCM (requiere reinicio).
  • NCM Retries — ciclos máximos de reintento de conexión (0 = reintentar indefinidamente, 5–1000 = intentos máximos).
  • NCM Retry Period — retardo entre reintentos en segundos (0 = retroceso incremental de 1s hasta 60s, 1–120 = intervalo fijo).
  • NCM IP Address — la dirección IP de la puerta de enlace USB NCM (predeterminada: 192.168.7.1). Al conectar dos placas picoZ80 al mismo host, cada una debe usar una subred diferente (por ejemplo, 192.168.7.1 y 192.168.8.1). Los cambios surten efecto después del reinicio y se persisten en NVS.
  • NCM Netmask — la máscara de subred USB NCM (predeterminada: 255.255.255.0). Los cambios surten efecto después del reinicio.
  • USB Product Name — la cadena de producto del dispositivo USB reportada al sistema operativo del host. macOS usa esto como la etiqueta de la interfaz de red NCM. Cada placa auto-genera un nombre único a partir de su dirección MAC (por ejemplo, "picoZ80-3C4E"); anúlelo aquí para establecer un nombre personalizado (por ejemplo, "picoZ80-MZ700"). Déjelo en blanco para auto-generación. Los cambios surten efecto después del reinicio.
• WiFi Configuration — SSID, contraseña, dirección IP, máscara de red, modo WiFi (Access Point o Client), DHCP (Habilitado o Deshabilitado), ruta del directorio WebFS, período de sondeo y potencia TX. Estos ajustes reflejan la página WiFi Manager pero son editables aquí como parte de la configuración completa.

Haga clic en Save Configuration para escribir los cambios en config.json en la tarjeta SD (la versión anterior se respalda automáticamente) y enviar automáticamente un comando de recarga al RP2350, aplicando la nueva configuración sin un ciclo de alimentación completo. Haga clic en Reload para releer el config.json actual desde la tarjeta SD — útil si ha cometido un error y desea descartar sus cambios y comenzar de nuevo desde el último estado guardado.

El Gestor de Archivos proporciona un navegador de archivos completo basado en web para la tarjeta SD, presentando un diseño de listado de directorios para ver archivos en la tarjeta SD. Está destinado al mantenimiento general de la tarjeta SD: subir imágenes ROM, imágenes de disquetes (DSK), imágenes QuickDisk (QD), imágenes de disco RAM y actualizaciones del sistema de archivos web sin necesidad de extraer la tarjeta. Cada entrada tiene botones de acción para copiar, eliminar, descargar o editar archivos de texto, y un botón Select File de carga en la parte superior permite transferir nuevos archivos desde el PC. La navegación de directorios permite descender a subdirectorios como roms/, dsk/, qd/ y ram/. La subida de archivos tar o gzip desempaquetará y extraerá automáticamente el archivo tar o gzip (o tar.gz) en el directorio actual de la tarjeta SD. Se pueden seleccionar múltiples archivos usando las casillas de verificación en la columna más a la izquierda (o la casilla "Select All" en el encabezado). Cuando se selecciona uno o más elementos, aparecen los botones Download N Items y Delete Selected en el encabezado del panel. La función de descarga obtiene cada archivo secuencialmente con un modal de progreso — los directorios se descargan automáticamente como archivos tar. Un botón Backup SD descarga todo el contenido de la tarjeta SD como un único archivo al ordenador local. Estas funciones son particularmente útiles cuando el picoZ80 está instalado dentro de una máquina host y extraer físicamente la tarjeta SD es impráctico.

La página de Personalidad configura la personalidad de máquina activa independientemente para cada una de las dos particiones de firmware del RP2350. Cada partición tiene su propia columna de botones de radio cubriendo cada tipo de máquina Sharp MZ soportado:

• Basic CPU — emulación Z80 básica sin controladores específicos de máquina; útil para desarrollo Z80 genérico.
• MZ-80A y MZ-80B — serie Sharp MZ-80 (ROM del monitor 1Z-013A, teclado MZ-80, mapa de memoria estándar).
• MZ-700 — Sharp MZ-700 con VRAM conmutada por bancos, controlador de teclado y controladores opcionales de disquete/QuickDisk.
• MZ-800 — Sharp MZ-800 con modos de video extendidos y soporte de QuickDisk.
• MZ-1500 — Sharp MZ-1500 con QuickDisk y disquete opcional.
• MZ-2000, MZ-2200, MZ-2500 — series Sharp MZ posteriores con video de alta resolución y memoria extendida.

Al seleccionar una personalidad y hacer clic en Select Personae se escribe el config.json preconstruido correspondiente en la tarjeta SD (respaldando primero el archivo actual) y se activa una recarga de configuración. Como cada partición de firmware puede contener una personalidad diferente, la placa puede cambiarse entre, por ejemplo, una personalidad MZ-700 en la partición 1 y una personalidad MZ-80A en la partición 2 sin editar la tarjeta SD. La personalidad para experimentadores OpenZ80 (vea OpenZ80 — Personalidad para Experimentadores) es una compilación de firmware dedicada en lugar de una opción de radio en esta página: cargue el firmware OpenZ80 en una partición mediante las páginas de actualización de firmware, luego configure sus tarjetas de interfaz y sus puertos de E/S base en la página de Configuración GUI. Para un Z80 simple en el zócalo sin recursos adicionales en una máquina soportada, la opción Basic CPU anterior sigue disponible.

La página OTA del ESP32 reporta el inventario completo de software del ESP32 antes de aceptar una carga de firmware:

• Panel de Modules
  - muestra la versión de cada componente de software del ESP32: la aplicación principal del ESP32, la biblioteca NVS (almacenamiento no volátil), la pila WiFi, el FilePack (empaquetador del sistema de archivos web) y el WebFS (sistema de archivos web en Flash). Esto facilita confirmar que todos los componentes son consistentes después de una actualización.
• Panel de ESP32 Partitions
  - muestra la tabla completa de particiones OTA del ESP32 (otadata, nvs, phy_init, ota_0, ota_1) con direcciones, tamaños, versiones de firmware, marcas de tiempo de compilación y qué ranura OTA está actualmente activa (marcada "Yes").
• Panel de ESP32 Firmware Upload
  - acepta el binario del ESP32 (.bin) producido por la compilación ESP-IDF. Después de la carga, el ESP32 se reinicia con el nuevo firmware y la ranura anterior se conserva como respaldo.
• Panel de FilePack Upload
  - sube un archivo FilePack versionado a la tarjeta SD. Un FilePack agrupa todos los activos web estáticos del ESP32 (plantillas HTML, CSS, JavaScript y archivos auxiliares) en un único archivo distribuible. Al subir, el ESP32 desempaqueta el archivo en el directorio del sistema de archivos web de la tarjeta SD; cualquier archivo que se reemplace se renombra automáticamente para incluir su número de versión anterior (por ejemplo, webfs → webfs.2.80), preservando la versión anterior para reversión. Esto coincide con el estilo de versionado VAX/VMS utilizado en otras partes de la tarjeta SD, donde cada revisión sucesiva de un archivo editable se preserva con un sufijo numérico: config.json;1, config.json;2, y así sucesivamente — asegurando que ninguna edición se sobrescriba silenciosamente.

La página OTA del RP2350 gestiona las dos particiones de firmware del RP2350:

• Panel de RP2350 Partitions
  - lista las tres particiones: partición 0 (Bootloader), partición 1 (primera ranura de aplicación, por ejemplo "Z80 CPU Emulator") y partición 2 (segunda ranura). Cada fila muestra la dirección Flash, tamaño, checksum, indicador de activo/en ejecución, licencia, autor, descripción, versión y fecha de compilación. La partición actualmente en ejecución se marca "Yes" en la columna Active.
• Panel de RP2350 Firmware Upload
  - acepta un archivo de firmware binario puro .bin de fw/bin/. No se usa UF2 aquí — las particiones de aplicación están ubicadas en direcciones Flash no estándar que UF2 no puede expresar, por lo que la transferencia OTA usa binario crudo. Use los botones de radio Partition 1 / Partition 2 para seleccionar la ranura destino. Dos casillas adicionales están disponibles: Clear App Config borra las imágenes ROM y la partición de configuración JSON minificada asociada a la ranura destino (útil al actualizar a una versión de firmware con un esquema de configuración incompatible), y Clear Flash Header restablece el encabezado de la partición Flash a valores de fábrica, reconstruyendo la tabla de particiones desde cero mientras preserva la configuración del cargador de arranque. La carga se verifica por checksum antes de activar la nueva partición.
• Panel de RP2350 Active Partition
  - cambia independientemente la partición activa sin subir nuevo firmware. Seleccionar una partición aquí activa un reinicio automático en la ranura elegida — útil para alternar entre dos variantes de firmware precargadas (por ejemplo, Z80 y una compilación de prueba) sin ninguna transferencia de archivos.

Nota: La página del Gestor WiFi solo está disponible cuando el firmware del ESP32 está compilado con WiFi habilitado (sdkconfig.mode_wifi_only o sdkconfig.mode_wifi_and_ncm). En modo NCM Only esta página no está presente en la navegación — la conectividad de red se proporciona automáticamente a través de USB NCM sin requerir configuración del usuario. El Gestor WiFi configura cómo el picoZ80 se conecta a una red inalámbrica. El panel superior muestra la configuración WiFi actualmente activa (SSID, IP asignada, máscara de red y puerta de enlace). El formulario Configure WiFi debajo expone todos los ajustes:

• WiFi Mode
  - Access Point: el picoZ80 transmite su propio SSID y usted se conecta directamente a él (útil durante la configuración inicial o cuando no hay red de infraestructura disponible). Client: el picoZ80 se une a una red WiFi existente como estación.
• SSID and Password
  - el nombre y la frase de paso de la red a la que unirse (modo cliente) o a transmitir (modo AP).
• DHCP Mode
  - Enabled: la placa solicita una dirección al servidor DHCP de la red. Disabled: use una IP estática, máscara de red y puerta de enlace como se ingresa en los campos de abajo. Se recomienda una IP fija para que la dirección de la interfaz web sea siempre predecible.

Los ajustes se guardan en el NVS (almacenamiento no volátil) del ESP32 al hacer clic en Save y surten efecto en el próximo reinicio.

Los dos menús desplegables en la barra de navegación superior derecha están disponibles en todas las páginas de la interfaz web, proporcionando acceso rápido a operaciones en tiempo de ejecución y funciones de reinicio del sistema sin navegar fuera de la página actual. El Menú de Acciones (icono de engranaje) proporciona operaciones en tiempo de ejecución que surten efecto inmediatamente sin reinicio: intercambio de imágenes de disquete o QuickDisk sobre la marcha, y activación de una recarga de configuración en vivo en el RP2350. Los nombres de archivo de las imágenes de disco cargadas actualmente se muestran junto a cada entrada para que el operador pueda ver de un vistazo qué imágenes están montadas. El Menú de Reinicio (icono de rotación) proporciona opciones de reinicio dirigido para cada subsistema — ESP32, RP2350, ordenador host e IPL — más dos opciones de recuperación UF2 para regrabar el RP2350 a través de almacenamiento masivo USB cuando la placa es físicamente inaccesible dentro de una máquina host. Las dos entradas UF2 proporcionan rutas de recuperación complementarias: la ruta del cargador de arranque funciona incluso cuando la aplicación principal está dañada, mientras que la ruta de la aplicación funciona incluso cuando el cargador de arranque necesita reemplazarse.

La tabla a continuación contiene todos los sitios referenciados en el diseño y programación del picoZ80.

Sitio	Idioma	Descripción
RP2350 Datasheet	Inglés	Referencia técnica y hoja de datos oficial del Raspberry Pi RP2350.
Pico SDK	Inglés	SDK C/C++ del Raspberry Pi Pico — sistema de compilación y abstracción de hardware utilizada por el firmware del picoZ80.
Z80 CPU User Manual	Inglés	Manual de usuario de la familia de CPU Z80 de Zilog — temporización de bus, conjunto de instrucciones y descripciones de señales.
ESP-IDF	Inglés	Espressif IoT Development Framework utilizado para el firmware del coprocesador ESP32.
Sharp MZ Series	Inglés	Recurso comunitario sobre hardware, software y documentación técnica de los ordenadores Sharp MZ.

La tabla a continuación contiene todas las hojas de datos y manuales referenciados en el diseño y programación del picoZ80.

Hoja de Datos	Idioma	Descripción
RP2350	Inglés	Hoja de datos del microcontrolador Raspberry Pi RP2350.
ESP32-S3	Inglés	Hoja de datos del SoC Espressif ESP32-S3 — coprocesador WiFi/BT en la placa picoZ80.
APS6404L PSRAM	Inglés	Hoja de datos de la PSRAM SPI de 8MB — la RAM extendida principal utilizada para los bancos de memoria.
W25Q128 Flash	Inglés	Hoja de datos de la Flash SPI NOR de 16MB de Winbond — almacena el firmware y las imágenes ROM.
TLV62590	Inglés	Convertidor reductor síncrono de 5V→3.3V de Texas Instruments que alimenta el picoZ80 desde el pin VCC del DIP-40 del Z80.
CH334F	Inglés	Controlador de hub USB 2.0 de 4 puertos CH334F — proporciona funcionalidad de hub USB para las actualizaciones de firmware.

Las primeras vistas previas de desarrollo del proyecto picoZ80 fueron compartidas en X (anteriormente Twitter). La siguiente publicación muestra la placa funcionando por primera vez: https://x.com/engineerswork1/status/1953171627065188841

El picoZ80 instalado en un Sharp MZ-700, ejecutando la personalidad ROM Filing System (RFS). El video demuestra las capacidades de disco virtual y bancos de memoria de la placa.

Un breve clip mostrando una placa Z80 CPU Tester probando el picoZ80. El tester verifica que el picoZ80 es un Z80 genuino, lo identifica como un Z80 NMOS y ejecuta código de prueba a 8 MHz para confirmar la operación correcta.

El picoZ80 v2.5 instalado en un Sharp MZ-80A, cargando un programa desde una cinta de cassette física. La carga de cassette es extremadamente sensible al tiempo — el Z80 debe hacer bit-banging del flujo de datos serial desde el hardware de cinta en tiempo real sin margen para errores de temporización. Este video demuestra que el picoZ80 maneja la temporización crítica del CMT de forma idéntica a un Z80 real.

El picoZ80 v2.5 en un Sharp MZ-80A, leyendo desde un controlador de disquetes real y una unidad de disco física. El acceso a disquetes requiere una interacción precisa y crítica en tiempo entre el Z80 y el hardware FDC WD1773 — el DRQ debe atenderse dentro de ventanas de temporización estrictas o se pierden datos. Este video demuestra que el picoZ80 interactúa con hardware crítico en tiempo real de la misma manera que un Z80 genuino.

El picoZ80 v2.5a instalado en un Sharp MZ-2000, ejecutándose completamente en modo físico — todos los accesos a ROM, RAM y VRAM pasan al hardware real del MZ-2000. El controlador de disquetes está virtualizado, con el picoZ80 emulando el FDC MB8866 y sirviendo imágenes de disco desde la tarjeta SD mientras el resto de la máquina funciona con su hardware original.

No se permite el uso comercial sin permiso expreso por escrito. El diseño de hardware del picoZ80 (esquemáticos, diseño de PCB, archivos KiCad), firmware y todo el software asociado están disponibles solo para uso personal, educativo y no comercial. Ninguna parte de este diseño — incluyendo pero no limitado a los diseños de PCB, lista de materiales, binarios de firmware, código fuente o documentación — puede ser usada, reproducida, fabricada, vendida o incorporada en cualquier producto o servicio comercial sin el permiso expreso por escrito del autor (Philip D. Smart). Para solicitar una licencia comercial o discutir usos permitidos, por favor contacte al autor a través del sitio web eaw.app.

El proyecto picoZ80 se basa en el trabajo de varias personas y proyectos de código abierto. Sus contribuciones se agradecen con gratitud.

• Manuel Sainz de Baranda y Goñi
  Autor de la biblioteca emuladora de CPU Z80 en lenguaje C Z80 (github.com/redcode/Z80). Este núcleo emulador Z80 de alta precisión y ciclo-exacto es utilizado por el firmware del picoZ80 cuando ejecuta instrucciones Z80 internamente en el RP2350, proporcionando comportamiento preciso de flags y soporte de opcodes no documentados. La biblioteca se utiliza bajo los términos de la Licencia Pública General de GNU v3.
• Raspberry Pi Ltd
  Autores del Pico SDK y el hardware RP2350. El ensamblador PIO, el SDK en C, la integración del toolchain CMake y el silicio RP2350B hacen posible la interfaz de bus ciclo-exacta.
• Espressif Systems
  Autores del framework ESP-IDF y el hardware ESP32. El coprocesador ESP32, la pila WiFi, la biblioteca OTA y el marco de almacenamiento NVS sustentan la interfaz de gestión web.
• Philip Smart
  Diseño de hardware (esquemáticos KiCad y diseño de PCB), firmware PIO del RP2350, aplicación web ESP32, sistema de configuración JSON, controladores de personalidades de máquina Sharp MZ y toda la documentación del proyecto.
• Grok (xAI)
  Asistente de IA que proporcionó ayuda valiosa durante la depuración de máquinas de estado PIO — particularmente en el diagnóstico de casos extremos de temporización y problemas de interacción de bus ciclo-exactos en los programas PIO del RP2350.
• Claude (Anthropic)
  Asistente de IA que contribuye a este proyecto en múltiples áreas: redacción y estructuración de la documentación del proyecto, análisis de la interfaz FSPI/UART entre el RP2350 y ESP32 y recomendaciones de mejora de firmware, y asistencia continua en el desarrollo de firmware.

El proyecto picoZ80 está compuesto por varios componentes, cada uno cubierto por su propia licencia:

Componente	Licencia
Firmware RP2350 del picoZ80 (PIO, fuentes en C)	GNU General Public License v3
Firmware ESP32 e interfaz web del picoZ80	GNU General Public License v3
Biblioteca del emulador de CPU Z80 (Manuel Sainz de Baranda y Goñi)	GNU General Public License v3
Archivos de diseño de hardware KiCad (esquemáticos, PCB, Gerbers)	Creative Commons BY-NC-SA 4.0
Documentación y guías de usuario	Creative Commons BY-NC-SA 4.0
Raspberry Pi Pico SDK	BSD 3-Clause
Framework ESP-IDF	Apache License 2.0
Bootstrap 4 (interfaz web)	MIT License

En resumen: el firmware y software que compile a partir del código fuente de este proyecto son de código abierto bajo la GPL v3; los diseños de hardware y la documentación están licenciados bajo CC BY-NC-SA 4.0 (solo uso no comercial — licenciamiento comercial disponible bajo solicitud); las bibliotecas de terceros mantienen sus propias licencias como se lista arriba. Consulte los archivos LICENSE y NOTICE en el repositorio para detalles completos.

Copyright © 2019–2026 Philip Smart. Todos los derechos reservados. Diseños de Hardware — CC BY-NC-SA 4.0
Todos los diseños de hardware (esquemáticos KiCad, diseños de PCB, archivos de fabricación Gerber, listas de materiales) están licenciados bajo la Licencia Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional. Usted es libre de compartir y adaptar los diseños solo para propósitos no comerciales, siempre que otorgue la atribución apropiada y distribuya cualquier modificación bajo la misma licencia. La fabricación o venta comercial requiere una licencia separada — por favor contacte a info@eaw.app. Firmware y Software — GNU GPL v3
El firmware y el código fuente del software son software libre bajo la Licencia Pública General de GNU v3. Usted puede redistribuir y modificar el código bajo los términos de la GPL v3. Cualquier modificación distribuida también debe estar licenciada bajo GPL v3 con el código fuente disponible. Marcas Comerciales y Atribución
Los nombres picoZ80, pico6502 y engineers@work son marcas comerciales de Philip Smart. No puede usar estos nombres para promover productos derivados sin permiso por escrito. No puede eliminar ni alterar avisos de copyright, atribución de autor o créditos de pantalla de inicio/arranque. Cambiar la marca de este proyecto y presentarlo como trabajo propio está expresamente prohibido. Consulte el archivo NOTICE en el repositorio para detalles completos. Licenciamiento Comercial
Si usted es un fabricante o distribuidor interesado en producir placas picoZ80 o pico6502 para venta comercial, por favor contacte a: info@eaw.app. El uso personal, educativo y de hobbyistas/clubes siempre está permitido bajo las licencias de código abierto anteriores. Los textos completos de las licencias se incluyen en el repositorio como LICENSE, LICENSE-HARDWARE.txt y LICENSE-SOFTWARE.txt.

Este dispositivo incorpora un módulo inalámbrico ESP32-S3-PICO-1 que es capaz de transmitir en la banda ISM de 2.4 GHz, convirtiéndolo en un radiador intencional bajo las regulaciones de radiofrecuencia a nivel mundial (incluyendo FCC Part 15 Subpart C en los Estados Unidos, y la Directiva de Equipos de Radio 2014/53/EU en la Unión Europea) cuando WiFi está habilitado. Predeterminado NCM-Only para Placas Sin Certificar
Debido a que el picoZ80 como ensamblaje terminado no ha sido sometido a certificación FCC o RED, las placas deben enviarse con la red de adaptación de antena WiFi sin poblar y el firmware del ESP32 compilado usando la configuración NCM Only (sdkconfig.mode_ncm_only). En esta configuración no se emite energía de radiofrecuencia y la placa no está sujeta a regulaciones de radiadores intencionales. La interfaz web completa permanece accesible por USB en http://192.168.7.1. Consulte la sección Red — Aviso Regulatorio FCC / RED arriba para más detalles. Aunque el módulo ESP32-S3-PICO-1 en sí posee certificaciones regulatorias preexistentes (FCC, CE y otras), esas certificaciones a nivel de módulo no se extienden automáticamente a un producto terminado que incorpora el módulo. La exención de módulo pre-certificado permite a los hobbyistas individuales construir un número limitado de dispositivos para uso personal, experimental o educativo sin obtener autorización de equipo separada. Limitaciones Importantes

• Los dispositivos ensamblados con WiFi habilitado no deben ser vendidos, ofrecidos para la venta, regalados ni distribuidos de ninguna otra manera a terceros a menos que el producto terminado haya sido probado independientemente y se le haya otorgado su propia autorización de equipo (por ejemplo, FCC ID, marcado CE con evaluación de un Organismo Notificado) en la jurisdicción correspondiente.
• Las placas enviadas o distribuidas a otros deben usar la configuración de firmware NCM Only con la red de adaptación de antena WiFi sin poblar.
• Construir este proyecto para uso personal en cantidades limitadas con WiFi habilitado generalmente está permitido bajo las disposiciones de uso hobbyista y experimental (por ejemplo, FCC § 15.23), siempre que el dispositivo no cause interferencia perjudicial.
• Los requisitos regulatorios varían según el país. Los constructores fuera de los Estados Unidos deben consultar su autoridad nacional de radiofrecuencia para las reglas aplicables.

Responsabilidad del Constructor
Es responsabilidad exclusiva del constructor asegurar que cualquier dispositivo construido a partir de estos diseños cumpla con todas las regulaciones de radiofrecuencia aplicables en su jurisdicción. El autor proporciona estos diseños para uso personal, educativo y de hobbyistas y no hace ninguna representación de que un dispositivo construido a partir de ellos satisfaga los requisitos regulatorios para distribución comercial.