ZPU Evo Guida per Sviluppatori

English


Introduzione

Benvenuti nella Guida per Sviluppatori della ZPU Evolution. Questa guida eโ€™ destinata a studenti, hobbisti e ingegneri che desiderano comprendere, costruire, modificare ed estendere il processore ZPU Evolution. Che stiate seguendo un corso di microprocessori, imparando lo sviluppo FPGA o esplorando il design di CPU soft-core, questa guida vi accompagneraโ€™ attraverso tutto, dai concetti di base alla personalizzazione avanzata.

La ZPU eโ€™ un microprocessore a 32 bit basato su stack, originariamente progettato da ร˜yvind Harboe di Zylin AS. La ZPU Evolution (Evo) eโ€™ una versione avanzata creata da Philip Smart che aggiunge significativi miglioramenti delle prestazioni, caching, istruzioni estese e un ampio framework System-on-Chip (SoC). Lโ€™intero design eโ€™ open source e implementato in VHDL per la sintesi su FPGA Intel/Altera.

Cosa imparerete

Lavorando con questa guida, sarete in grado di:

  • Comprendere lโ€™architettura della CPU basata su stack e come differisce dai design basati su registri
  • Apprendere come funziona il set di istruzioni della ZPU a livello hardware
  • Essere in grado di configurare, costruire e programmare bitstream FPGA per diverse schede di sviluppo
  • Sapere come aggiungere nuove istruzioni hardware alla CPU
  • Comprendere lโ€™architettura SoC, inclusi controller di memoria, UART, timer e gestione degli interrupt
  • Essere in grado di scrivere, compilare e eseguire programmi C sulla ZPU
  • Configurare build CI/CD automatizzati con Jenkins e Docker

Prerequisiti

Per ottenere il massimo da questa guida, dovreste avere:

  • Conoscenze base di logica digitale - Comprensione di flip-flop, multiplexer, macchine a stati e strutture di bus
  • Qualche esperienza con VHDL - Capacitaโ€™ di leggere dichiarazioni di entitaโ€™ VHDL, assegnazioni di segnali e blocchi di processo
  • Programmazione C - Familiaritaโ€™ con la sintassi C, puntatori e compilazione
  • Una scheda di sviluppo FPGA - Una delle schede supportate (DE10 Nano, E115, CYC1000, QMV o DE0 Nano)
  • Intel Quartus Prime - Versione 17.1.1 Standard Edition (o la versione containerizzata Docker)

Parte 1: Comprendere l'architettura ZPU

Processori basati su stack vs. basati su registri

La maggior parte dei processori che incontrerete (ARM, x86, RISC-V) sono basati su registri: hanno un set fisso di registri nominati (R0-R15, EAX, ecc.) e le istruzioni specificano su quali registri operare. Ad esempio, ADD R0, R1, R2 significa โ€œsomma R1 e R2, memorizza in R0โ€.

La ZPU eโ€™ un processore basato su stack. Invece di registri nominati, utilizza uno stack Last-In-First-Out (LIFO). Le operazioni lavorano implicitamente sugli elementi superiori dello stack:

Stack prima di ADD:         Stack dopo ADD:
  โ”Œโ”€โ”€โ”€โ”€โ”€โ”                    โ”Œโ”€โ”€โ”€โ”€โ”€โ”
  โ”‚  3  โ”‚ โ† TOS              โ”‚  7  โ”‚ โ† TOS (3+4)
  โ”œโ”€โ”€โ”€โ”€โ”€โ”ค                    โ”œโ”€โ”€โ”€โ”€โ”€โ”ค
  โ”‚  4  โ”‚ โ† NOS              โ”‚ ... โ”‚
  โ”œโ”€โ”€โ”€โ”€โ”€โ”ค                    โ””โ”€โ”€โ”€โ”€โ”€โ”˜
  โ”‚ ... โ”‚
  โ””โ”€โ”€โ”€โ”€โ”€โ”˜

TOS = Top of Stack, NOS = Next on Stack.

Percheโ€™ unโ€™architettura a stack?

  1. Codifica minima delle istruzioni - Non sono necessari campi registro. ADD eโ€™ solo un byte (opcode 00000101), mentre un ADD basato su registri necessita di campi registro sorgente e destinazione (2-4 byte).
  2. Impronta FPGA molto piccola - Il decoder eโ€™ banale e richiede elementi logici minimi.
  3. Facile target per il compilatore - La valutazione delle espressioni si mappa naturalmente sulle operazioni dello stack (Notazione Polacca Inversa).
  4. Compromesso - Le macchine a stack sono tipicamente piuโ€™ lente per operazione rispetto alle macchine a registri a causa della manipolazione aggiuntiva dello stack, ma il sistema di caching della ZPU Evo mitiga significativamente questo aspetto.

Il modello di memoria della ZPU

La ZPU ha uno spazio di memoria piatto, indirizzabile per byte, a 32 bit. Tutti i dispositivi di memoria e IO condividono questo spazio:

Address Space (24-bit example, configurable):
โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”
โ”‚ 0x000000 - 0x01FFFF : Boot BRAM (128KB)      โ”‚  โ† Program + Stack
โ”‚                        Reset vector at 0x0000 โ”‚
โ”‚                        Emulation vectors      โ”‚
โ”‚                        0x0000-0x0400          โ”‚
โ”œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ค
โ”‚ 0x020000 - 0x03FFFF : Application RAM (opt)   โ”‚  โ† Secondary BRAM
โ”œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ค
โ”‚ 0x040000 - 0xFEFFFF : SDRAM (optional)        โ”‚  โ† External memory
โ”œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ค
โ”‚ 0xFF0000 - 0xFFFFFF : Memory-Mapped I/O       โ”‚  โ† Peripherals
โ”œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ค
โ”‚ 0x1000000 - 0x1FFFFFF: Wishbone bus (optional) โ”‚  โ† Extended region
โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜

Punti importanti:

  • Lo stack risiede nella parte superiore della BRAM e cresce verso il basso
  • Il programma inizia allโ€™indirizzo 0x0000 (configurabile)
  • Gli indirizzi 0x0000-0x0400 sono riservati per i vettori di emulazione (spiegati in seguito)
  • I dispositivi IO sono mappati in memoria nella parte superiore dello spazio di indirizzi
  • Il bus Wishbone, quando abilitato, raddoppia lo spazio di indirizzi

I cinque modelli di CPU

Il SoC ZPU Evolution supporta cinque modelli di CPU intercambiabili, selezionabili in fase di build. Solo uno puoโ€™ essere attivo:

Model Logic Elements Performance Wishbone Best For
Small ~400 LEs Baseline No Minimum footprint applications
Medium ~600 LEs ~1.5x Small No Better performance, still small
Flex ~800 LEs ~1.8x Small No Good balance of size and speed
Evo ~2500 LEs ~3x Small Yes Maximum performance, full features
Evo Minimal ~1200 LEs ~2x Small Yes Evo with reduced instruction set

Il modello Evo aggiunge:

  • Cache istruzioni L1 (basata su registri, configurabile 8-256 voci)
  • Cache istruzioni L2 (basata su BRAM, configurabile 256-4096 byte)
  • Memory Transaction Processor (coda per operazioni di memoria)
  • Doppio bus di memoria (bus di sistema + bus Wishbone opzionale)
  • Bus istruzioni opzionale (porta BRAM separata per il fetch delle istruzioni)
  • Hardware Byte/Word Write (eliminazione dei cicli Read-Modify-Write)
  • Supporto istruzioni estese (istruzioni multi-byte)

Codifica delle istruzioni

Le istruzioni della ZPU sono larghe 8 bit. La codifica eโ€™ notevolmente semplice:

Bit 7 = 1: IM instruction (7-bit immediate value in bits 6:0)
Bit 7 = 0:
  Bits 6:5 = 00: Core instructions (opcode in bits 4:0)
  Bits 6:5 = 01: STORESP (store to stack offset in bits 4:0)
  Bits 6:5 = 10: EMULATE (emulation vector index in bits 4:0)
  Bits 6:5 = 11: LOADSP (load from stack offset in bits 4:0)

Caricamento di una costante a 32 bit: Poicheโ€™ ogni istruzione IM puoโ€™ trasportare solo 7 bit, caricare un valore completo a 32 bit richiede fino a 5 istruzioni IM consecutive. La cache L1 nella Evo consente di eseguire fino a 5 istruzioni IM in un singolo ciclo, rendendo il caricamento delle costanti molto efficiente.

Vettori di emulazione

Una caratteristica chiave della ZPU eโ€™ lโ€™emulazione delle istruzioni. Le istruzioni contrassegnate come EMULATE (bit opcode 6:5 = 10) si diramano a un vettore nellโ€™intervallo 0x0000-0x0400. Ogni vettore eโ€™ di 32 byte:

Vector address = instruction[4:0] * 32

Se unโ€™istruzione hardware non eโ€™ implementata (disabilitata nella configurazione), attiva il percorso EMULATE, dove il microcodice software implementa lโ€™operazione. Questo consente alla CPU di eseguire lo stesso software indipendentemente da quali istruzioni sono presenti in hardware โ€“ solo a velocitaโ€™ diverse.

Questo eโ€™ cioโ€™ che rende la ZPU unicamente flessibile: potete scambiare risorse FPGA con prestazioni abilitando/disabilitando selettivamente le istruzioni hardware.

Parte 2: Struttura del progetto

Layout delle directory

ZPU/
โ”œโ”€โ”€ cpu/                          # CPU core implementations
โ”‚   โ”œโ”€โ”€ zpu_core_evo.vhd          # ZPU Evolution CPU (3688 lines)
โ”‚   โ”œโ”€โ”€ zpu_core_small.vhd        # ZPU Small CPU
โ”‚   โ”œโ”€โ”€ zpu_core_medium.vhd       # ZPU Medium CPU
โ”‚   โ”œโ”€โ”€ zpu_core_flex.vhd         # ZPU Flex CPU
โ”‚   โ”œโ”€โ”€ zpu_pkg.vhd               # CPU package (opcodes, config)
โ”‚   โ””โ”€โ”€ zpu_uart_debug.vhd        # Debug serialiser
โ”‚
โ”œโ”€โ”€ devices/                      # Peripheral IP cores
โ”‚   โ”œโ”€โ”€ sysbus/                   # System bus peripherals
โ”‚   โ””โ”€โ”€ WishBone/                 # Wishbone bus peripherals
โ”‚
โ”œโ”€โ”€ build/                        # FPGA board build files
โ”‚   โ”œโ”€โ”€ Makefile                  # Build targets for all boards/CPUs
โ”‚   โ””โ”€โ”€ *_zpu.qpf/qsf            # Board-specific Quartus projects
โ”‚
โ”œโ”€โ”€ zpu_soc.vhd                   # SoC top level (2346 lines)
โ”œโ”€โ”€ zpu_soc_pkg.vhd               # SoC configuration package
โ”œโ”€โ”€ zpu_soc_pkg.tmpl.vhd          # Template for build system
โ””โ”€โ”€ README.md                     # Project documentation

File sorgente principali spiegati

zpu_pkg.vhd - Il pacchetto di configurazione a livello CPU. Contiene definizioni degli opcode, configurazione della larghezza del bus di indirizzi, dichiarazioni dei componenti per i core CPU, configurazione del debug e flag di abilitazione del bus istruzioni.

zpu_soc_pkg.vhd - La configurazione a livello SoC. Contiene la selezione del modello CPU, le frequenze di clock della scheda, la geometria della memoria, i flag di abilitazione/disabilitazione delle periferiche, i parametri di dimensione della cache e le costanti della mappa di memoria.

zpu_soc.vhd - Il modulo SoC principale. Qui tutto si riunisce: istanziazione del core CPU selezionato, collegamento di BRAM, SDRAM, UART, timer, scheda SD, ecc.

cpu/zpu_core_evo.vhd - Lโ€™implementazione della CPU Evo (3688 righe). Contiene il decoder delle istruzioni e la macchina a stati di esecuzione, cache L1, cache L2, Memory Transaction Processor e gestione dello stack.

Parte 3: Configurare il SoC

I dettagli completi della configurazione โ€“ selezione del modello CPU, configurazione della memoria, abilitazione delle periferiche e tuning della cache Evo โ€“ sono identici alla versione inglese e sono spiegati in dettaglio liโ€™.

Parte 4: Costruire i bitstream FPGA

Se volete semplicemente un bitstream funzionante in fretta, utilizzate lo script di setup automatico per la vostra piattaforma (vedi Setup e build automatici qui sotto). Installa l'intera tool chain (Intel Quartus Prime Lite 17.1 e, dove necessario, Docker), clona il repository, permette di scegliere la scheda e la CPU e costruisce fino al completamento — senza richiedere alcuna conoscenza preliminare degli strumenti. I workflow `Makefile`, Quartus diretto e Docker che seguono sono per chi vuole pilotare gli strumenti a mano.

Setup e build automatici (consigliato)

Gli script di setup inclusi installano tutto il necessario (Intel Quartus Prime Lite 17.1 e, dove necessario, Docker), clonano il repository se non siete gia' all'interno di un checkout, permettono di scegliere la scheda e la variante di CPU di destinazione e costruiscono il bitstream FPGA fino al completamento. Ogni script e' autonomo — copiate solo il singolo file per la vostra piattaforma ed eseguitelo. Sono stati verificati end‑to‑end su Windows (nativo), macOS (Intel, tramite Docker) e Linux.
Script Piattaforma Note
setup_ZPU_windows.cmd Windows 10 / 11 Consigliato su Windows โ€” launcher da doppio clic; mantiene aperta la finestra e registra in setup_ZPU_log.txt. Installazione nativa, senza WSL.
setup_ZPU_windows_native.ps1 Windows 10 / 11 Lo script PowerShell sottostante (installa Git for Windows + Quartus 17.1 tramite winget / lโ€™installer Intel).
setup_ZPU.sh Linux / macOS Quartus nativo su Linux; unโ€™immagine Docker Quartus headless su macOS (solo Mac Intel โ€” Quartus eโ€™ x86-64).
build_zpu.sh tutte Wrapper di build portabile. Rieseguitelo in qualsiasi momento per il rebuild: ./build_zpu.sh [BOARD] [CPU].

Windows โ€” fate doppio clic su setup_ZPU_windows.cmd, oppure da PowerShell:

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

macOS / Linux:

chmod +x setup_ZPU.sh
./setup_ZPU.sh

Ogni script chiede quale scheda e variante di CPU costruire (predefinito QMV / EVO) e, salvo che venga eseguito dallโ€™interno di un checkout, dove clonare il repository. Al termine avrete build/<BOARD>_<CPU>.sof (il bitstream di configurazione FPGA) e un build/<BOARD>_<CPU>.rbf compresso. Schede: QMV (predefinita), DE10_nano, DE0_nano, E115, CYC1000; CPU: EVO (predefinita), EVO_MINIMAL, FLEX, MEDIUM, SMALL.

Per un rebuild successivo senza rieseguire il setup (su Windows Gitย Bash, prima export PATH="/c/altera/17.1/quartus/bin64":$PATH):

./build_zpu.sh E115 EVO           # board + CPU
./build_zpu.sh --list             # list all boards / CPUs
ZPU_RTL_METHOD=docker ./build_zpu.sh QMV EVO   # force the headless Docker image

Override di ambiente utili: ZPU_REPO_URL (repository da clonare; predefinito il pubblico https://git.eaw.app/eaw/zpu.git), ZPU_BOARD / ZPU_CPU (salta i prompt), ZPU_RTL_METHOD=native|docker, ZPU_DIR (build in un checkout esistente) e ZPU_QUARTUS_BIN (punta a un bin/bin64 Quartus esistente).

Utilizzo del Makefile

Il modo piuโ€™ semplice per il build eโ€™ il Makefile nella directory build/:

cd ZPU/build
make DE10_nano_EVO        # DE10-Nano con CPU Evo
make E115_SMALL           # E115 con CPU Small
make CYC1000_MEDIUM       # CYC1000 con CPU Medium

Cosa succede durante un build:

  1. Il Makefile copia zpu_soc_pkg.tmpl.vhd e imposta il modello CPU selezionato a 1 tramite sed
  2. Il file zpu_soc_pkg.vhd generato sostituisce quello esistente
  3. Quartus esegue la sintesi โ€“ converte il VHDL in una netlist
  4. Quartus esegue il fitter (Place & Route) โ€“ mappa sulle risorse FPGA effettive
  5. Quartus esegue lโ€™assembler โ€“ genera il file di programmazione .sof
  6. quartus_cpf converte il .sof in .rbf (Raw Binary Format)

Parti 5-6: Set di istruzioni e aggiunta di nuove istruzioni

Le tabelle complete del set di istruzioni (istruzioni core, istruzioni emulabili, istruzioni estese) e la guida passo-passo per lโ€™aggiunta di nuove istruzioni hardware si trovano nella versione inglese.

Parte 7: L'ecosistema software -- IOCP, zOS e applicazioni

Panoramica degli strati software

Lo stack software standard su un sistema ZPU Evolution eโ€™:

โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”
โ”‚              Applicazioni                          โ”‚
โ”‚  (ed, kilo, tbasic, mbasic, Benchmark,             โ”‚
โ”‚   programmi propri -- caricati dalla SD card)       โ”‚
โ”œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ค
โ”‚         zOS -- Sistema Operativo                    โ”‚
โ”‚  (Shell, file system, 80+ comandi, caricamento app, โ”‚
โ”‚   gestione memoria, gestione interrupt)             โ”‚
โ”œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ค
โ”‚         IOCP -- Bootloader                          โ”‚
โ”‚  (Init hardware, boot da SD card, upload seriale,   โ”‚
โ”‚   monitor memoria -- integrato nella BRAM)          โ”‚
โ”œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ค
โ”‚         ZPU Hardware (FPGA)                         โ”‚
โ”‚  (CPU, BRAM, SDRAM, UART, SD, Timer, Interrupts)    โ”‚
โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜

La sequenza di avvio eโ€™: FPGA acceso -> IOCP esegue dalla BRAM -> IOCP carica zOS dalla SD card -> zOS presenta una shell -> lโ€™utente esegue le applicazioni.

IOCP -- Il Bootloader

IOCP (I/O Control Program) eโ€™ il primo codice che viene eseguito quando la ZPU si accende. Eโ€™ integrato direttamente nella Block RAM dellโ€™FPGA durante la sintesi, quindi eโ€™ sempre disponibile โ€“ nessuna scheda SD o memoria esterna eโ€™ necessaria per la sua esecuzione.

I livelli di funzionalitaโ€™ di IOCP vanno da Full (~40 KB con tutti i comandi) a Tiny (~3-5 KB, solo bootstrap). I dettagli sui protocolli di upload seriale, comandi e layout della memoria si trovano nella versione inglese.

zOS -- Il sistema operativo

zOS (ZPU Operating System) eโ€™ il sistema operativo standard per la ZPU Evolution. Fornisce una shell a riga di comando, supporto completo del file system, gestione della memoria e la capacitaโ€™ di caricare e eseguire applicazioni dalla scheda SD โ€“ paragonabile a come CP/M o il primo DOS fornivano un ambiente a riga di comando per eseguire programmi.

Le funzionalitaโ€™ della shell di zOS includono: 80+ comandi, editing di riga tipo Readline con cronologia, supporto AUTOEXEC.BAT e un sistema di aiuto.

Applicazioni

Applicazioni incluse: ed (editor di testo VT100), kilo (editor VT100 avanzato), tbasic (interprete Tiny BASIC), mbasic (Mini BASIC v1.0), dhry (Dhrystone v2.1 benchmark), coremark (CoreMark v1.0 benchmark).

Costruire il software

Tutto il software ZPU (IOCP, zOS e applicazioni) viene costruito dal repository zOS con uno script build.sh unificato. I parametri di build completi e i comandi di esempio si trovano nella versione inglese.

Parti 8-13: Argomenti avanzati

Le sezioni complete su Software personalizzato, Architettura SoC, Configurazione specifica per scheda, CI/CD, Debugging e Risorse aggiuntive si trovano nella versione inglese di questo documento.

Esercizi per studenti

  1. Base: Costruire la ZPU Small per la vostra scheda. Collegare un terminale a 115200 baud e interagire con IOCP.
  2. Intermedio: Modificare zpu_soc_pkg.vhd per cambiare la dimensione della BRAM. Osservare lโ€™impatto sullo spazio stack disponibile.
  3. Intermedio: Abilitare il controller PS2 e collegare una tastiera. Scrivere un programma C che restituisca i tasti premuti.
  4. Avanzato: Aggiungere unโ€™istruzione hardware SWAP (come descritto nella Parte 6). Verificarla con assembly inline.
  5. Avanzato: Portare il design su una nuova scheda FPGA attualmente non supportata.
  6. Esperto: Implementare una nuova istruzione estesa utilizzando il meccanismo EXTEND.