Sillabo del corso

Programmazione Assembly e periferiche con il simulatore G80 Lab


Destinatari	Classe terza — Istituto Tecnico, indirizzo Informatica e Telecomunicazioni, articolazione Informatica (≈ 20‑30 studenti)
Disciplina ospitante	Informatica (con raccordi a Sistemi e Reti e TPSIT)
Durata	36 ore — 12 settimane × 3 ore (2 di laboratorio + 1 di teoria)
Periodo suggerito	Ottobre → gennaio (primo periodo / inizio secondo)
Ambiente	Laboratorio informatico; simulatore G80 Lab nel browser (nessuna installazione)
Versione	Bozza 1.0 — 27/09/2026

Nota di adattabilità. Il modulo è progettato su 3 ore/settimana per 12 settimane. Può essere erogato anche in 24 ore (2 ore/settimana, tagliando le sfide opzionali) o 30 ore (2,5 ore/settimana) senza toccare i nuclei essenziali (§5, in grassetto le parti irrinunciabili).

1. Idea del corso

Il corso porta lo studente dentro la macchina: dalla rappresentazione dei dati e dall’architettura della CPU fino al linguaggio assembly e alla gestione delle periferiche (LED, display, tastiere, timer, interrupt, motore, forno), usando un simulatore didattico (G80 Lab, compatibile Z80) che funziona nel browser, offline, senza installare nulla.

L’impianto è laboratoriale e per competenze: ogni unità si chiude con un compito significativo verificabile al simulatore (un programma che funziona), e il corso termina con un progetto di controllo che integra più periferiche con interrupt.

Il G80 è particolarmente adatto alla didattica perché espone visivamente ogni concetto: registri e flag a schermo, memoria ispezionabile, disassemblatore e periferiche simulate (LED, LCD, motore, forno…) che rendono osservabile l’effetto di ogni istruzione.

2. Quadro di riferimento

D.P.R. 15 marzo 2010, n. 88 — Regolamento degli Istituti Tecnici: il profilo dell’indirizzo Informatica e Telecomunicazioni richiede la padronanza del rapporto hardware/software e l’uso di linguaggi di programmazione a diversi livelli di astrazione.
Direttiva MIUR n. 4 del 16/01/2012 — Linee guida per il secondo biennio degli Istituti Tecnici: nel secondo biennio la disciplina Informatica affronta l’architettura del calcolatore, i linguaggi di programmazione e il livello macchina (assembly, traduttori, debugging).
D.M. n. 71/2026 (riforma dei quadri orari, a decorrere dal 2026/27): per l’articolazione Informatica la disciplina Informatica in terza ha 198 ore/anno (≈ 6 ore/settimana), con compresenza di insegnante tecnico‑pratico per le attività di laboratorio. Il presente modulo (36 h) occupa quindi circa un quinto del monte ore annuale della disciplina e si colloca tipicamente dopo l’unità sull’architettura degli elaboratori.
Dai programmi svolti di istituti tecnici (es. Ubertini, I.T.C. Levi, Sarrocchi, Pertini) si rileva che in terza sono previsti: architettura di Von Neumann, CPU e registri, linguaggio assembly, set di istruzioni, stile di programmazione e debug, traduttori/assembler e collegamento (linker).

3. Prerequisiti e test d’ingresso

Prerequisiti (dal primo biennio):

sistemi di numerazione binario/esadecimale, conversioni, complemento a due, ASCII;
algebra di Boole, porte logiche, architettura di massima di un calcolatore;
basi di programmazione (variabili, selezione, cicli, funzioni) in un linguaggio ad alto livello;
uso elementare di editor di testo e file.

Test d’ingresso (30 min, prima settimana, non valutativo):

10 conversioni binario ⇄ decimale ⇄ esadecimale;
una tabella di verità semplice e l’espressione booleana corrispondente;
un mini‑programma in pseudo‑codice da tradurre in un ciclo;
domanda aperta: «Che cosa succede, secondo te, dentro il computer quando esegui un programma?» (serve a far emergere il modello mentale di partenza).

4. Risultati di apprendimento

Al termine del corso lo studente sa:

descrivere l’architettura di una CPU semplice (bus, registri, ALU, unità di controllo) e il ciclo fetch–decode–execute;
scrivere, assemblare, eseguire e correggere programmi in linguaggio assembly (sequenza, selezione, iterazione, vettori, stringhe);
usare stack e sottoprogrammi (CALL/RET, PUSH/POP, convenzioni di chiamata);
interfacciare la CPU con le porte di I/O: leggere ingressi, pilotare uscite (LED, interruttori, display 7 segmenti, tastiera, LCD);
distinguere polling e interrupt e implementare una gestione IM2 con tabella dei vettori (EI, RETI);
usare periferiche avanzate (timer CTC, counter, keypad, motore stepper, forno, chart, potenziometro, beeper) in un piccolo progetto di controllo;
applicare un metodo sistematico di debug (passo‑passo, breakpoint, ispezione di memoria e registri, disassemblaggio, modifica di dati a runtime).

Competenze trasversali: problem solving, lettura di documentazione tecnica (manuale, tabella istruzioni), lavoro in coppia, documentazione del codice.

5. Articolazione in unità (UDA)

Totale: 36 h = 12 h teoria + 24 h laboratorio. Legenda: T = teoria, L = laboratorio.

UDA 0 — La macchina e il suo linguaggio (3 h: 1 T + 2 L)

Conoscenze: modello di Von Neumann; CPU (registri, ALU, unità di controllo); bus dati, indirizzi, controllo; memoria; ciclo di esecuzione; linguaggio macchina vs assembly; il ruolo di assembler e linker.
Laboratorio: apertura di G80 Lab (file singolo, offline); tour dell’interfaccia (editor, registri/flag, memoria, disassemblatore, periferiche); primo programma in 5 minuti (LD A, 0x55 / OUT (0x20), A / JP): i LED contano; uso di Assembla & Carica, Esegui, Pausa, Passo.
Materiali: MANUALE.md §1–3 e §7; esempio “primo programma”.
Compito significativo: far lampeggiare i LED con un primo programma modificato.

UDA 1 — Registri, istruzioni e indirizzamenti (6 h: 2 T + 4 L)

Conoscenze: formato delle istruzioni; la famiglia LD; aritmetica (ADD, SUB, INC, DEC); logica (AND, OR, XOR, CPL, CP); flag (S, Z, H, V, N, C) e loro significato; modi di indirizzamento (immediato, registro, diretto, indiretto, indicizzato (IX+d)); equates ed etichette; direttive di base (.org, .db, .dw, .ds, .ascii).
Laboratorio: esempi 01-indirizzamenti.asm, 02-somma-e-flag.asm; Esercizio 1 (Somma); traccia dell’esecuzione con Passo; modifica di un byte in memoria per cambiare i dati di un programma già assemblato.
Verifica formativa: “traccia l’esecuzione” — dato un listato breve, completare una tabella registro/flag passo‑passo.

UDA 2 — Il controllo del flusso (3 h: 1 T + 2 L)

Conoscenze: salti incondizionati e condizionati (JP/JR + condizioni); cicli con DJNZ; selezioni; struttura “confronta e salta”.
Laboratorio: Esercizio 2 (Massimo di tre); esempio 03-led-contatore.asm; sfida: semaforo a due fasi con conteggio sui LED.
Compito significativo: programma nuovo con selezione e ciclo, eseguito al simulatore.

UDA 3 — Memoria, stack e sottoprogrammi (6 h: 2 T + 4 L)

Conoscenze: organizzazione della memoria; vettori e tabelle (.db/.dw); copia di blocchi (LDIR); stack (PUSH/POP, SP); sottoprogrammi (CALL/RET), annidamento, passaggio di parametri e valore di ritorno; convenzioni di salvataggio dei registri.
Laboratorio: Esercizio 4 (Copia di un blocco); ritardo come subroutine che preserva A (completamento Esercizio 3); lettura di un vettore di dati e conteggio con ciclo esterno.
Verifica sommativa n. 1 — prova scritta (1 h, in coda all’UDA): tracciamento di codice, completamento di frammenti, domande su flag e stack.

UDA 4 — Ingressi e uscite: le periferiche di base (6 h: 2 T + 4 L)

Conoscenze: I/O mappato su porte; IN/OUT; il concetto di handshake; la mappa porte del G80; periferiche: LED 0x20, interruttori 0x90, display 7 seg 0xA0/A1, tastiera ASCII 0xC0, LCD 20×10 0xD0 (0x0A = a capo), keypad 16 tasti 0x80/0x81 (bit 7 = dato pronto, bit 0‑3 = tasto).
Laboratorio: esempi 04-interruttori-led, 05-lcd-messaggio (OTIR), 06-tastiera-lcd, 07-keypad-lcd; Esercizio 5 (Eco su LCD); sfida: “contatore di tasti sull’LCD”.
Verifica sommativa n. 2 — prova pratica intermedia (1 h): programma con almeno una porta di ingresso e una di uscita (consegna a scelta tra 2 tracce).

UDA 5 — Interrupt e periferiche avanzate (9 h: 3 T + 6 L)

Conoscenze: polling vs interrupt; interrupt in IM1/IM2; tabella dei vettori e registro I; schema dei device vettorati del G80 (vettore < 0x80, poi 0x83); EI/DI/RETI; timer CTC 0x70/0x71 (costante e prescaler 16/64/256 configurabile nella UI; periodo = costante × prescaler in T‑state); counter/nastro 0xE0/0xE1 (passo ogni 500 ms reali); keypad con interrupt; motore stepper 0xB0; forno (kiln) 0xF0/0xF1; potenziometro 0x40; chart recorder 0x30..0x33; beeper 0x60.
Laboratorio: esempi 08-timer-interrupt (IM2 + LCD + LED), 09-motore-counter, 10-kiln-chart; Esercizio 6 (Interrupt del timer); sfide: lampeggiatore “preciso” a interrupt, pianola con keypad + beeper, linea di trasporto con counter + motore.
Verifica sommativa n. 3 — prova pratica su interrupt (1 h): un servizio IM2 che interagisce con una periferica mentre il programma principale continua a lavorare.

UDA 6 — Progetto finale e documentazione (3 h + lavoro nelle ore di laboratorio della UDA 5)

Progetto (a coppie, vedi §10): sistema di controllo che integra almeno 2 periferiche e almeno 1 device con interrupt, completo di codice commentato e breve relazione.
Laboratorio: sviluppo, debug guidato, presentazione della demo alla classe (5 min per gruppo) e colloquio di verifica sul codice.
Verifica sommativa n. 4 — progetto + colloquio (rubrica in §8).

Ripartizione ore

UDA	Tema	T	L	Totale
0	La macchina e il suo linguaggio	1	2	3
1	Registri, istruzioni e indirizzamenti	2	4	6
2	Il controllo del flusso	1	2	3
3	Memoria, stack e sottoprogrammi	2	4	6
4	I/O e periferiche di base	2	4	6
5	Interrupt e periferiche avanzate	3	6	9
6	Progetto, documentazione e colloqui	1	2	3
	Totale	12	24	36

6. Piano settimanale

Sett.	UDA	Teoria (1 h)	Laboratorio (2 h)	Verifiche
1	0	Architettura, ciclo di esecuzione, assembly vs linguaggio macchina	Primo programma LED; Esegui/Passo/memoria/disassembler	Test d’ingresso
2	1	Istruzioni `LD`, aritmetica; i flag	Esempi 01–02; traccia con Passo	Formativa
3	1	Indirizzamenti, etichette, direttive `.db/.dw`	Esercizio 1; modifica dati in memoria	Formativa
4	2	Salti e cicli (`CP`, `JP/JR`, `DJNZ`)	Esercizio 2; esempio 03; sfida “semaforo”	Compito valutato
5	3	Memoria, vettori, `LDIR`	Esercizio 4; tabelle `.db/.dw`	Formativa
6	3	Stack e sottoprogrammi	Ritardo come subroutine; esercizio 3	Prova scritta 1
7	4	Porte di I/O; `IN`/`OUT`; handshake	Esempi 04–05; LCD con `OTIR`	Formativa
8	4	Tastiera e keypad; buffer sull’LCD	Esercizio 5; esempi 06–07	Prova pratica 2
9	5	Polling vs interrupt; IM2 e vettori	Esempio 08; esercizio 6 (prima parte)	Formativa
10	5	Timer CTC e counter; misura dei tempi	Esercizio 6 (fine); esempi 09–10	Formativa
11	5/6	Motore, forno, chart, potenziometro, beeper	Avvio progetto finale (coppie)	Osservazione
12	6	Documentare e presentare un programma	Completamento, demo, colloqui	Progetto + colloquio

Le ore di laboratorio della settimana 11–12 possono essere parzialmente dedicate al progetto anche anticipando le 3 ore di UDA 6: l’insegnante adatta in base al ritmo della classe.

7. Metodologia

Lezione breve e operativa (10‑15 min): ogni concetto è subito tradotto in un esempio da eseguire al simulatore (“prima si vede, poi si spiega”).
Laboratorio guidato a coppie (pair programming): guida di lavoro con obiettivi in chiaro e criteri di verifica; rotazione dei ruoli. Una postazione ogni due studenti.
Didattica per errori: gli errori dell’assembler e gli “opcode illegali” del G80 diventano occasioni di lettura dei messaggi e di diagnosi guidata.
Debug sistematico: esercizi di tracing con Passo, breakpoint, vista memoria e disassemblatore; gli studenti annotano su una scheda: dove sono, cosa mi aspettavo, cosa vedo.
Sfide a più livelli (base/avanzato) per gestire i diversi ritmi; le sfide non sono obbligatorie per la sufficienza.
Compiti a casa: completare gli esercizi non finiti, riscrivere i programmi con commenti propri, pre‑leggere le tabelle delle porte sul manuale.

8. Strumenti e materiali

Strumento	Dove	Uso
G80 Lab (file singolo `G80Lab.html`)	`distro/` — copiabile su USB	aula senza rete: doppio clic, nessuna installazione
G80 Lab PWA	server locale (`node servi.mjs`) o intranet	installabile, funziona offline
Manuale per studenti	`MANUALE.md` / `distro/MANUALE.html`	sintassi, porte, interrupt, problemi frequenti
12 esempi originali	`examples/` · pagina Materiali	modelli da modificare ed eseguire
6 esercizi con soluzioni	`esercizi/` · pagina Materiali	lavoro autonomo guidato con verifica
Schede stampabili	a cura del docente	mappa istruzioni, tabella porte, scheda tracing
LIM / proiettore	aula	dimostrazioni live

Requisiti tecnici: un browser moderno (Chrome/Edge/Firefox), facoltà di copiare il file singolo su chiavetta; per la PWA basta un PC “server” nella rete locale.

9. Verifiche e valutazione

Tipo	Quando	Strumento	Peso
Diagnostica	sett. 1	test d’ingresso	non valutativa
Formativa	ogni settimana	esercizi `esercizi/` con criteri di verifica, osservazione in lab, test flash 5′	concorre al voto di partecipazione
Sommativa 1	sett. 6	prova scritta (tracing, frammenti, flag/stack)	20 %
Sommativa 2	sett. 8	prova pratica intermedia (I/O)	20 %
Sommativa 3	sett. 10‑11	prova pratica su interrupt	20 %
Sommativa 4	sett. 12	progetto + colloquio	30 %
Partecipazione	tutto il corso	impegno, lavoro di coppia, autonomia	10 %

Criteri minimi di sufficienza: il programma assembla ed esegue senza errori; usa almeno una porta di ingresso e una di uscita; sa spiegare che cosa fa ogni blocco principale del proprio codice; il progetto integra almeno 2 periferiche.

Rubrica del progetto (punteggio 0‑10):

Indicatore	0‑2	3‑5	6‑8	9‑10
Funzionamento	non funziona	funziona in parte	funziona come richiesto	funziona e gestisce casi limite
Uso delle periferiche/interrupt	nessuno	1 periferica	2 periferiche, 1 con interrupt	integrazione solida e motivata
Qualità del codice	illeggibile	poco commentato	chiaro e commentato	strutturato a subroutine, nomi significativi
Autonomia nel debug	bloccato	con aiuto	autonomo	autonomo e aiuta i compagni
Documentazione/presentazione	assente	minima	chiara	efficace ed essenziale

10. Progetto finale — opzioni

Ogni coppia sceglie una proposta (o ne propone una equivalente) e consegna: sorgente commentato, breve relazione (obiettivo, schema delle porte, difficoltà e soluzioni), demo di 5 min.

Colonna luminosa — keypad + LED/7 seg: l’utente digita un numero sul keypad e la colonna LED conta fino a quel valore; timer in interrupt per il ritmo.
Contalattine — counter + motore + LCD: ogni pezzo sul nastro incrementa il conteggio (interrupt del counter), il motore avanza di un passo; l’LCD mostra il totale.
Forno controllato — kiln + potenziometro + chart: la temperatura target si imposta col potenziometro; il programma accende/spegne il riscaldatore (bit 0) e traccia l’andamento sul chart; l’LCD mostra i valori.
Pianola — keypad + beeper + LCD: ogni tasto produce una nota (ritardo calibrato); l’LCD mostra la sequenza suonata; l’ultimo tasto è “riproduci”.
Proposta libera della coppia (da concordare con il docente entro la settimana 11).

Requisiti minimi del progetto: ≥ 2 periferiche; ≥ 1 device gestito in interrupt; codice commentato; uso di almeno una subroutine; dimostrazione funzionante al simulatore.

11. Recupero, potenziamento e inclusione

Recupero in itinere: ogni UDA ha esercizi “base” con soluzione; chi è indietro li completa con la guida del docente e del compagno di banco (peer tutoring).
Prove di recupero: prova pratica aggiuntiva alla fine della UDA 5, focalizzata sui criteri minimi.
Potenziamento: sfide extra (linking multi‑file con .globl/.lcf, “caccia al bug” su codice altrui, disassemblaggio di un blocco di memoria per ricostruire l’assembly).
Inclusione (BES/DSA): consegne suddivise in passi, tabelle delle istruzioni e delle porte sempre disponibili, tempo aggiuntivo (+30 %), uso del Passo e dei breakpoint come strumenti compensativi, verifiche in due parti, possibilità di presentare il progetto con domande guida.

12. Fonti consultate

Documenti di riferimento

D.P.R. 15 marzo 2010, n. 88 e Linee guida (Direttiva MIUR n. 4 del 16/01/2012) — Gazzetta Ufficiale: https://www.gazzettaufficiale.it/eli/id/2012/03/30/12A03290/sg
Quadro orario classico dell’indirizzo (informatica 6 h/sett. in terza, di cui 3 di laboratorio): IIS Peano: https://www.iispeano.edu.it/pagine/quadro-orario-informatica-e-telecomunicazioni
Riforma dei quadri orari 2026/27 (D.M. 71/2026) — sintesi con tabella per l’articolazione Informatica: https://www.professionistiscuola.it/riforma-tecnici-2026-27-quadri-orari-e-classi-di-concorso-indirizzo-per-indirizzo-la-guida-completa/

Strutturazione didattica

Corso Z80 completo (indice per unità: architettura → istruzioni → stack/sottoprogrammi → I/O e interrupt → simulatori): https://www.elemania.altervista.org/micro/index.html
G.R. Wilson, Embedded Systems and Computer Architecture, Newnes — libro da cui nasce il G80: sommario completo (Part 1 Building Blocks, Part 2 Computing Machines: cap. 6 Instruction set and code assembly, 7 Program structures, 9 Input and output ports, 10 Input and output methods, 11 More devices, 12 Assembler and linker tools, 13 The control unit; appendici A/C/D su instruction set, device e strumenti GDS): https://www.oreilly.com/library/view/embedded-systems-and/9780750650649/xhtml/9780080477558_toc.htm
Didattica per unità di apprendimento e compiti significativi (struttura UDA, prodotti intermedi, prodotto finale come prova di competenza): https://www.oltreladidattica.com/post/come-strutturare-un-unità-didattica-di-apprendimento-scarica-esempio

Collocazione nei programmi di terza

Programma svolto classe terza (architettura, assembly, stile di programmazione, set di istruzioni, debug): https://www.ubertini.it/files/sistereti/terza/programma-svolto-terza.pdf
Programma di Informatica classe terza (UDA “Architettura dei calcolatori”, modello di Von Neumann): https://www.itclevi.it/wp-content/uploads/Programmi_2025-26/3A-Informatica.pdf
Programma svolto classe terza (linguaggi, traduttori, compilazione e collegamento): https://lnx.itisothoca.edu.it/wp-content/uploads/2026/06/Informatica_3E_Schirra.pdf
Programma classe terza (architettura di Von Neumann): https://www.istitutosandropertini.it/wp-content/uploads/2022/11/Programma3A_Informatica.pdf

Materiali interni (G80 Lab)

MANUALE.md — manuale per studenti (sintassi, porte, interrupt, problemi frequenti);
docs/02-peripherals.md — semantica e tempi delle periferiche (verificati sul binario);
examples/ — 10 programmi commentati; esercizi/ — 6 esercizi con soluzioni;
STATO.md — stato e limiti noti del simulatore.

13. Note per il docente

Ordine dei contenuti: non anticipare gli interrupt prima che gli studenti padroneggino salti, cicli e subroutine: l’UDA 5 dipende dalle UDA 1‑3.
Tempi: la UDA 5 (periferiche avanzate) è la più compressibile: se il tempo stringe, timer + un device a scelta bastano per il progetto; motore/forno/chart possono diventare dimostrazioni del docente.
Difficoltà note del simulatore: il prescaler del CTC è configurabile (default 256); per le attività sul timer si consiglia di fissarlo all’inizio e mantenerlo fino alla fine.
Valutazione pratica: usare i criteri di verifica già presenti in esercizi/README.md (assemblea pulita, risultato atteso, commenti, robustezza ai dati).
Estensioni: il corso si collega naturalmente a Sistemi e Reti (bus, memoria, I/O) e a TPSIT (progettazione di piccoli sistemi); il progetto finale può diventare un prodotto per l’esame di stato o per un percorso PCTO.