G80 Lab — Manuale d'uso

Simulatore ed ambiente di sviluppo per il processore G80 (compatibile Z80), pensato per

imparare il linguaggio assembly e l'interfacciamento con le periferiche.

1. Come si apre

Serve solo un browser moderno (Chrome, Edge, Firefox). Nessuna installazione.

2. La schermata

Colonna sinistra

• Programma (assembly): l'editor dove scrivi il programma. Sopra ci sono gli esempi

preimpostati, Apri .asm… per caricare un file dal disco e Salva .asm… per scaricare

il sorgente sull'ultimo file (o su un nome nuovo).

• Esecuzione: pulsanti Reset / Passo / ⌁ ciclo / Esegui-Pausa, la velocità

(istruzioni per fotogramma, con i preset 🐢 lenta / ▶ normale / ⚡ veloce) e il

prescaler del CTC. Sotto: registri e flag

(clic su un registro per modificarne il valore, come il menu *Registers* del G80Sim).

• Memoria: vista a pagine da 256 byte con ◀ / ▶, Vai al PC e

clic su un byte per modificarlo. Sotto, tre linguette: Dis-assembly (16 istruzioni),

Instruction Trace (istruzioni eseguite, con dettaglio a scelta) e Listing (.lst)

(il listato dell'assembler, come *View assembly listing*).

Colonna destra

• CPU — vista a blocchi: i registri interni (IR, A + flag, coppie BC/DE/HL,

IX/IY/SP/PC, MAR) e i segnali di bus dell'ultima operazione

(MEMRQ/RD/WR/IORQ). Pulsante ⛶ modalità LIM per proiettare a schermo intero.

• Micro-operazioni: la sequenza di trasferimenti che la CPU esegue per l'**ultima

istruzione** (fetch, ALU, memoria, I/O) con il messaggio in stile simulatore originale;

▶ micro-passo scorre la sequenza, ↻ riparte.

• Periferiche: LED, display 7 segmenti, LCD, chart recorder, potenziometro,

interruttori, tastiera, keypad, motore, kiln, beeper.

• Porte (port monitor): per ogni porta usata dal programma, ultima direzione, ultimo

valore letto/scritto e conteggi.

• Log I/O: messaggi (breakpoint, interrupt, link, porte non standard).

3. Primo programma (5 minuti)

1. Cancella l'editor e scrivi:

        ld  a, 0x55       ; A = 0101 0101
ciclo:
        out (0x20), a     ; mostra A sugli 8 LED
        inc a             ; A = A + 1
        jp  ciclo         ; ripeti

1. Premi Assembla & Carica (se ci sono errori, compaiono sotto i pulsanti con il numero di riga).
2. Premi Esegui ▶ → i LED contano in binario.
3. Premi Pausa, poi Passo per avanzare una istruzione alla volta e osservare i registri.

Suggerimento: usa Passo con la velocità al minimo per *vedere* come cambiano i registri.

4. Scrivere programmi (sintassi)

Commenti, etichette, costanti

; commento fino a fine riga
LEDS = 0x20          ; costante (equate)
inizio:              ; etichetta (indirizzo)
        out (LEDS), a

Numeri ed espressioni

127 (decimale) · 0x1F (esadecimale) · "a" (carattere) · -1

Espressioni: + - * / & | ^ << >> ~ ( ) e differenze fra etichette (fine - inizio = lunghezza).

Direttive

Istruzioni

Tutte le istruzioni Z80 documentate (LD, ADD, JP, CALL, RST, IN/OUT, LDIR, …) e i prefissi

CB/ED/DD/FD (indici IX/IY, indirizzamento (IX+5)).

5. Eseguire e controllare

Il programma si ferma quando: arriva a HALT, incontra un breakpoint, o esegue un'istruzione

illegale per il G80 (compare un messaggio nel log).

Per togliere un breakpoint: clic di nuovo sulla riga rossa, oppure ✕ Togli breakpoint,

oppure rimetti lo stesso indirizzo e premi *Imposta/Rimuovi*. C'è un solo breakpoint alla volta.

6. Registri e flag

Flag mostrati come S Z 5 H 3 V N C:

S segno · Z zero · H half-carry · V overflow/parità · N sottrazione · C carry.

(Verde = flag attivo.)

7. Memoria, disassemblaggio, trace e vista CPU

• Pagine da 256 byte: ◀ 256 / 256 ▶; scrivi un indirizzo nel campo per saltare; Vai al PC.
• Clic su un byte → inserisci il nuovo valore esadecimale (utile per modificare dati a runtime).
• Il byte del PC è evidenziato in verde, il breakpoint in rosso.
• Dis-assembly (linguetta): il disassemblaggio delle istruzioni a partire dall'indirizzo

visualizzato — clic su una riga = imposta/togli breakpoint.

• Instruction Trace (linguetta): registro delle istruzioni eseguite, una riga per

istruzione: indirizzo, byte, disassemblaggio, registri (A, BC, DE, HL, F) e

T-state consumati. Per capire *come* funziona un'istruzione: mettila in un programma,

premi Passo e leggi la riga. Il trace si riempie usando Passo o quando la linguetta

è attiva; pulisci trace lo svuota (massimo 500 righe, le più vecchie escono).

Con messaggi si sceglie il dettaglio: *solo istruzioni*, *+ fetch*, *+ micro-operazioni*.

• Listing (.lst) (linguetta): il listato completo dell'assembler (indirizzi, byte, sorgente),

come *View assembly listing* del G80Sim; con il multi-file mostra la link map.

• CPU — vista a blocchi (pannello a destra): mostra il "dentro" del processore, come la

plancia del simulatore originale:

- IR = opcode dell'istruzione in esecuzione; A e i flag; le coppie

BC/DE/HL; IX/IY/SP/PC; MAR = ultimo indirizzo comparso sul bus;

- i segnali di bus (MEMRQ, RD, WR, IORQ) si accendono secondo l'ultima

operazione: *fetch istruzione*, *lettura/scrittura memoria*, *IN/OUT*;

- sotto il riquadro: l'ultima operazione di bus, la prossima istruzione (a PC) e

lo stato (IM, IFF1, R, HALT);

- ⛶ modalità LIM: ingrandisce il pannello a tutto schermo (per proiettare) e mostra una

barra di comandi integrata: *Reset*, *Passo*, *⌁ ciclo*, *Esegui/Pausa*, *micro-passo*,

*chiudi*. Scorciatoie da tastiera in modalità LIM: Spazio = Passo, C = ciclo,

R = Esegui/Pausa, Esc = chiudi.

• Micro-operazioni (pannello sotto la vista CPU): per l'ultima istruzione eseguita mostra

il messaggio Execute instruction with op code 3E: LD A, n e la **sequenza delle

micro-operazioni**: fetch (PC → MAR, M[MAR] → MDR, MDR → IR, PC + 1 → PC) seguita

dai passi di esecuzione (operando, ALU, scritture in memoria, I/O). Con ▶ micro-passo si

evidenzia una micro-operazione per volta; ↻ torna all'inizio. È la vista per spiegare

*come* la CPU decodifica ed esegue una singola istruzione.

8. Periferiche (porte di I/O)

Esempi rapidi

        out (0x20), a        ; accendi i LED secondo A
        in  a, (0x90)        ; leggi gli interruttori
        out (0xD0), a        ; scrivi un carattere sul LCD
        in  a, (0x40)        ; leggi il potenziometro

Tempi delle periferiche

• Nastro (counter) e kiln: avanzano con il tempo reale (un passo / una lettura ogni 500 ms, come il simulatore originale).
• Timer CTC: conta i cicli della CPU; il periodo è costante × prescaler, dove il prescaler si sceglie dalla tendina CTC (16/64/256).

9. Interrupt (IM2)

Schema tipico (usato dal timer, dal counter e dal keypad):

        .org 0x0010
VTab:   .dw servizio          ; tabella dei vettori (indirizzo pari)

        .org 0x0100
inizio:
        ld  a, 0x08
        out (0x70), a         ; costante del timer
        ld  a, VTab
        out (0x71), a         ; byte basso del vettore
        ld  a, 0x83
        out (0x71), a         ; abilita (bit0 run, bit1 interrupt)
        ld  a, 0
        ld  i, a              ; byte alto della tabella
        im  2
        ei
ciclo:
        jp  ciclo             ; programma principale

servizio:
        push af
        ; ... fai qualcosa ...
        pop af
        ei
        reti

Regole utili:

• il vettore si scrive prima (valore < 0x80), poi 0x83 per abilitare;
• I fornisce il byte alto dell'indirizzo della tabella;
• nel servizio: salva i registri, esegui, EI e RETI.

10. Più file e linking

Nell'editor puoi scrivere più file separati da una riga marcatore:

;=== FILE: main.asm ===
        .globl valore
        .seg CODE (rel)
        ld  a, 7
        ld  (valore), a
        .seg RAM (rel)
valore: .ds 1

;=== FILE: extra.asm ===
        .globl valore
        .seg CODE (rel)
        ld  a, (valore)
        add a, 2
        ld  (valore), a
        halt

Premendo Assembla & Carica l'app assembla ogni file e poi linka: i segmenti con lo stesso

nome vengono uniti, i simboli .globl risolti (la link map compare nel log).

11. Modalità G80 e differenze dallo Z80

Il G80 è compatibile Z80, ma non implementa:

• DAA
• LD R,A e LD A,R
• i registri half-index IXH/IXL/IYH/IYL
• l'istruzione non documentata SLL (CB 00110xxx)

Se usi queste istruzioni, il programma si ferma con "opcode illegale" (nel log).

L'hardware di interrupt dei device supporta solo IM1 e IM2.

12. Esempi ed esercizi

• esempi/ — 12 programmi commentati (LED, LCD, tastiera, keypad, timer+interrupt,

motore, kiln, multi-file, progetti di riferimento del finale) + esempi/README.md.

• esercizi/ — 6 esercizi con consegna, file di partenza (TODO) e soluzioni;

leggi esercizi/README.md.

13. Problemi frequenti

14. Glossario

• Assembly: linguaggio a basso livello, una riga ≈ una istruzione della CPU.
• Assembler: traduce il sorgente in codice macchina (qui: .ihx).
• Linker: unisce più file oggetto e risolve i simboli.
• Registro: piccola memoria dentro la CPU (A, B, C, …).
• Flag: bit che descrivono l'ultimo risultato (zero, carry, …).
• Porta di I/O: indirizzo con cui si parla alle periferiche (IN/OUT).
• Interrupt: richiesta di attenzione alla CPU (qui IM2 con tabella di vettori).
• Breakpoint: indirizzo dove l'esecuzione si ferma per controllare lo stato.
• Segmento: blocco di codice/dati, assoluto (abs) o rilocabile (rel).

*G80 Lab — manuale per studenti. Aggiornato al 27/09/2026.*