UDA 0 — La macchina e il suo linguaggio

3 ore (1 di teoria + 2 di laboratorio) · Settimana 1

Obiettivi

Al termine di questa unità:

• sai descrivere, con parole tue, che cosa succede dentro il computer quando esegue un programma;
• riconosci i componenti essenziali di una CPU (registri, ALU, unità di controllo) e il ruolo dei bus;
• distingui linguaggio macchina e linguaggio assembly e sai spiegare a cosa servono assembler e linker;
• hai scritto, assemblato ed eseguito i tuoi primi programmi sul simulatore G80 Lab;
• sai usare i comandi Assembla & Carica, Esegui, Pausa, Passo e sai guardare i registri.

---

1. Dentro la macchina

Un computer è fatto di pochi elementi fondamentali, collegati fra loro:

Componente	Ruolo	Analogia
CPU	esegue le istruzioni	il “cervello”
Memoria	contiene dati e programmi	l‘“archivio”/scrivania
Bus dati	trasporta i dati fra CPU e memoria/periferiche	le “mani”
Bus indirizzi	indica dove leggere o scrivere	il “dito che indica”
Bus di controllo	segnala cosa fare (leggi, scrivi…)	il “cenno del capo”

Dentro la CPU troviamo:

• i registri: piccolissime memorie velocissime (A, B, C, …, PC, SP);
• la ALU (Arithmetic Logic Unit): esegue somme, confronti, operazioni logiche;
• l’unità di controllo: legge e interpreta le istruzioni.

Questo schema è il modello di Von Neumann: dati e istruzioni stanno nella stessa memoria.

Il ciclo di esecuzione

Ogni istruzione passa sempre attraverso tre fasi:

1. Fetch — la CPU legge dalla memoria l’istruzione, all’indirizzo indicato dal registro PC;
2. Decode — l’unità di controllo capisce che cosa vuol dire quell’istruzione;
3. Execute — la esegue e aggiorna i registri; PC passa all’istruzione successiva.

E poi ricomincia. Sempre. Milioni di volte al secondo.

---

2. Dal linguaggio macchina al linguaggio assembly

La CPU capisce solo numeri: ogni istruzione è un byte (a volte più di uno). Per esempio, “carica 85 nel registro A” diventa:

Linguaggio macchina	Linguaggio assembly
3E 55	LD A, 0x55
D3 20	OUT (0x20), A

Scrivere programmi con i numeri è impraticabile: allora si scrivono i mnemonici (LD, OUT, JP…), e uno strumento — l’assembler — li traduce in codice macchina.

  programma.asm        assembler              codice macchina (Intel HEX)
  +---------+         +---------+             +-----------+
  | LD A,55 |  ---->  | G80 Lab |  ------->   | 3E 55 D3… |
  +---------+         +---------+             +-----------+

• l’assembler traduce il sorgente in codice macchina; il linker unisce più file oggetto e risolve i simboli (lo vedremo più avanti);
• il simulatore (G80 Lab) fa finta di essere la macchina: esegue il codice e mostra registri, memoria e periferiche, così possiamo vedere cosa accade.

---

3. Il simulatore G80 Lab

Il nostro G80 è un processore compatibile Z80. Con G80 Lab lavoriamo nel browser, senza installare nulla:

1. apri il simulatore (si apre in una nuova scheda; in alternativa c’è il file singolo G80Lab.html scaricabile dalla pagina Simulatore);
2. l’editor contiene già un programma: premi Assembla & Carica → Esegui;
3. osserva: LED accesi, registri che cambiano, PC che avanza.

I comandi che useremo oggi

Comando	Cosa fa
Assembla & Carica	traduce il sorgente e lo carica in memoria
Esegui ▶ / Pausa ⏸	esegue in continuazione / si ferma
Passo	esegue una sola istruzione: il modo migliore per capire
Reset	riporta il programma all’inizio
velocità	quante istruzioni esegue per fotogramma

Nella schermata trovi anche: registri e flag, la memoria (pagina da 256 byte), il disassemblaggio (il programma “tradotto all’indietro”) e le periferiche simulate.

Trucco: metti la velocità al minimo e usa Passo con il pannello dei registri sott’occhio. Vedrai PC scorrere e A cambiare a ogni istruzione.

---

4. Primo programma (5 minuti)

Nel simulatore, 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

Poi:

1. Assembla & Carica — se ci sono errori, compaiono con il numero di riga;
2. Esegui — i LED contano in binario: 55, 56, 57…
3. Pausa, poi Passo — guarda A e PC cambiare una istruzione alla volta.

Cosa fa il programma, riga per riga:

• ld a, 0x55 — mette nel registro A il valore esadecimale 55 (0x55 è come scrivere 85 in decimale; in binario 0101 0101: i LED accesi sono quelli con bit a 1);
• out (0x20), a — copia A sulla porta 0x20, a cui è collegato il banco degli 8 LED;
• inc a — incrementa A di 1;
• jp ciclo — salta di nuovo all’etichetta ciclo: si ripete all’infinito.

---

5. Laboratorio guidato

Attività A — Conteggio lento

Il programma qui sopra cambia troppo in fretta? Aggiungi una pausa fra un valore e il successivo, usando una subroutine di ritardo (per ora è una scatola nera: la studieremo più avanti, copiala così com’è):

        ld  a, 0
ciclo:
        out (0x20), a
        inc a
        call ritardo
        jp  ciclo

; ---- scatola nera: ritardo (da studiare in UDA 2/3) ----
ritardo:
        push af            ; salva i registri che useremo
        push bc
        ld   b, 0x20       ; prova ad aumentare questo valore…
rout:
        ld   c, 0x00
rin:
        dec  c
        jr   nz, rin
        djnz rout
        pop  bc            ; …e a ripristinarli
        pop  af
        ret

Verifica: i LED cambiano circa 2 volte al secondo (regola B se è troppo veloce o lento).

Attività B — Interruttori → LED

Colleghiamo un ingresso a un’uscita: gli 8 interruttori (porta 0x90) comandano gli 8 LED (porta 0x20).

ciclo:
        in  a, (0x90)      ; leggi gli 8 interruttori
        out (0x20), a      ; copiali sui LED
        jp  ciclo

Verifica: muovendo gli interruttori nella UI, i LED si accendono e spengono di conseguenza.

Attività C — Sfida: lampeggio alternato

Completa (o correggi) questo programma, che deve far alternare due configurazioni di LED (1010 1010 e 0101 0101), con una pausa fra le due:

        ld  a, 0xAA
ciclo:
        out (0x20), a
        ; ... qui manca qualcosa: come si "invertono" tutti i bit di A? ...
        call ritardo
        jp  ciclo

Suggerimento: c’è una istruzione che inverte tutti i bit di A: cercala nella tabella delle istruzioni logiche del manuale (CPL? XOR? prova!).

---

6. Autoverifica

1. A cosa servono i bus dati, indirizzi e controllo?
2. Quali sono i tre passi del ciclo di esecuzione e in che ordine avvengono?
3. Qual è la differenza fra linguaggio macchina e linguaggio assembly?
4. A che cosa serve l’assembler? E il linker?
5. Nel primo programma, perché jp ciclo è indispensabile?

---

7. Compiti e materiali

📎 I file .asm di esempi ed esercizi si scaricano dalla pagina Materiali.

• Compito: fai girare le tre attività, salva i sorgenti e annota sul quaderno «cosa mi aspettavo» e «cosa ho visto» per il primo programma.
• Pre-lettura: manuale, sezioni Registri e flag e Sintassi.
• Materiali collegati: esempi 03-led-contatore.asm e 04-interruttori-led.asm (raccolta esempi del progetto), manuale alla voce LED e Interruttori.
• Prossima unità: registri, istruzioni e modi di indirizzamento (UDA 1).