Esempio illustrato · TAKE 005
Una macroistruzione, dieci micro passi: dal prelievo del comando al caricamento di 7 nell’accumulatore.
Come leggere le immagini: la riga gialla e il contatore MC indicano la prossima microistruzione da eseguire. Ogni schermata mostra lo stato dopo il passo spiegato. Il microprogramma qui documentato usa acc:=0 e plus per realizzare TAKE.
MC, PC e i due bus
Due contatori scelgono le operazioni; due bus trasportano indirizzi e contenuti.
MC — Microcode Counter
MC significa Microcode Counter, cioè contatore del microcodice: indica l’indirizzo della prossima microistruzione da eseguire.
- MC = 010 → il prossimo passo è
acc:=0. - MC = 011 → il prossimo passo è
ins->ab. - MC = 015 → il prossimo passo è
mc:=0, che riporta MC a 000 per iniziare un nuovo prelievo.
PC indica dove leggere l’istruzione nella RAM; MC indica quale operazione interna eseguire nel microcodice.
PC — Program Counter
Il contatore del programma conserva l’indirizzo RAM usato per prelevare l’istruzione. Con PC = 000 si preleva il comando nella cella 000. Dopo pc++, PC diventa 001. Non contiene il dato da sommare né l’indirizzo della riga del microcodice.
AB — Address Bus, bus degli indirizzi
Il bus azzurro indica quale cella RAM è selezionata. Durante il prelievo riceve l’indirizzo da PC; durante la lettura del dato riceve l’operando da INS. Per TAKE 005 passa da 000 a 005. Cambiare AB seleziona una cella ma non copia automaticamente il suo contenuto su DB.
DB — Data Bus, bus dei dati
Il bus verde trasporta il contenuto letto o da scrivere. Nel prelievo di TAKE 005 contiene 01 005, cioè il codice dell’istruzione; nella lettura del dato contiene 00 007, cioè 7. In Johnny DB può trattenere il valore fra due passi: è una semplificazione didattica.
Domande guida: AB risponde a “dove?”, DB a “quale contenuto?”, PC a “quale istruzione del programma?”, MC a “quale passo interno?”.
Le sigle da ricordare
Bus, registri e contatori che incontrerai nei passaggi.
| Sigla | Nome | Funzione |
|---|---|---|
RAM | Random Access Memory — memoria ad accesso casuale | Conserva istruzioni e dati in celle numerate. |
AB | Address Bus — bus degli indirizzi | Indica la cella RAM coinvolta nel trasferimento. |
DB | Data Bus — bus dei dati | Trasporta il contenuto letto o da scrivere; in Johnny può trattenerlo fra due passi. |
ACC | Accumulator — accumulatore | Conserva il dato di lavoro e il risultato delle operazioni. |
INS | Instruction Register — registro istruzione | Contiene il comando prelevato e il suo operando. |
PC | Program Counter — contatore del programma | Indica l’indirizzo RAM usato per il prelievo dell’istruzione. |
MC | Microcode Counter — contatore del microcodice | Indica la prossima microistruzione da eseguire. Non è l’indirizzo del dato in RAM. |
Come leggere un comando: ram->db significa “copia il contenuto della cella RAM selezionata nel bus dei dati”. La freccia indica la direzione del trasferimento. mc:=0 significa “imposta MC a zero”.
0. Preparazione: istruzione in 000, dato in 005
Il comando si trova nella cella 000; il dato da caricare si trova nella cella 005.
Inserisci TAKE 005 nella cella 000: Hi = 01, Lo = 005. Nella cella 005 inserisci 7, visualizzato come 00 007. Dopo Reset, PC e MC sono 000 e ACC è zero.
L’indirizzo 000 contiene il comando; 005 è l’indirizzo del dato; 7 è il numero da caricare. TAKE deve produrre ACC = 7 senza modificare RAM[005].
1. Prelievo: pc->ab
Dal Program Counter (contatore del programma) all’Address Bus (bus degli indirizzi).
La microistruzione 000 copia PC sul bus degli indirizzi. Con PC = 000, AB diventa 000 e seleziona la cella dell’istruzione. MC avanza a 001. Il valore di ACC resta zero.
2. Prelievo: ram->db
Dalla RAM al Data Bus (bus dei dati): si legge il codice dell’istruzione.
Alla riga 001 si legge RAM[000]. Il bus dei dati riceve 01 005, cioè il codice della macroistruzione. Non è ancora il dato 7. MC passa a 002.
3. Prelievo: db->ins
Dal Data Bus (bus dei dati) all’Instruction Register (registro istruzione).
La riga 002 copia DB nel registro istruzione INS. Ora INS contiene 01 005: la parte 01 identifica TAKE, la parte 005 indica l’indirizzo del dato. MC passa a 003.
4. Scelta del microprogramma: ins->mc
Dal codice operativo nel registro istruzione alla scelta del microprogramma.
La riga 003 usa il codice operativo 01 per portare MC a 010, inizio del microprogramma TAKE. Non usa l’operando 005: quello servirà per selezionare il dato.
5. Esecuzione TAKE: acc:=0
Azzeramento dell’Accumulator (accumulatore), prima di caricare il nuovo dato.
La riga 010 azzera ACC. Nell’esempio era già zero, quindi il numero visualizzato non cambia. Il passo è comunque necessario: prepara l’accumulatore affinché la successiva somma carichi soltanto il dato desiderato. MC passa a 011.
6. Esecuzione TAKE: ins->ab
Dal registro istruzione all’Address Bus (bus degli indirizzi): si seleziona la cella 005.
La riga 011 copia l’operando di INS sul bus degli indirizzi: AB passa da 000 a 005. La RAM seleziona la cella del dato e mostra 00 007. Il bus DB contiene ancora 01 005: cambiare l’indirizzo non legge automaticamente il dato. MC passa a 012.
7. Esecuzione TAKE: ram->db
Dalla RAM al Data Bus (bus dei dati): si legge il numero 7.
La riga 012 legge RAM[005]. DB riceve 00 007 e sostituisce il codice dell’istruzione che conteneva prima. ACC è ancora zero. MC passa a 013.
8. Esecuzione TAKE: plus
Il dato sul Data Bus viene sommato all’accumulatore azzerato.
La riga 013 somma DB ad ACC: 0 + 7 = 7. ACC ora contiene il dato richiesto. MC passa a 014. PC è ancora 000: nella schermata pc++ è evidenziata perché deve essere eseguita al prossimo clic.
9. Completare TAKE: pc++ e mc:=0
Si aggiorna il contatore del programma e si torna all’inizio del microcodice.
Completiamo gli ultimi due passi e osserviamo lo stato dopo ciascuno nelle nuove schermate.
- Esegui la riga 014,
pc++: PC passa da 000 a 001 e MC avanza a 015.
- Esegui la riga 015,
mc:=0: MC torna a 000 e il controllo è pronto al prelievo successivo.
Stato finale: ACC = 7, PC = 001, MC = 000, AB = 005, DB = 7, INS = 01 005. RAM[005] conserva 7.
Fermati qui: nella serie di immagini RAM[001] contiene zero, non HLT. Per eseguire un programma completo inserisci prima HLT 000 nella cella 001.
Dopo TAKE: inizia il prelievo successivo
Il nuovo indirizzo del programma passa sul bus degli indirizzi per il ciclo successivo.
La terza nuova schermata mostra un clic ulteriore, oltre i dieci passi di TAKE: la microistruzione pc->ab del nuovo ciclo copia PC = 001 in AB. La RAM seleziona la cella 001 e MC avanza a 001, dove la prossima operazione sarà ram->db.
ACC resta 7 e DB conserva ancora 7: cambiare indirizzo non legge automaticamente la RAM. Il valore 00 000 mostrato nella zona RAM è il contenuto della cella 001 selezionata, mentre il bus verde mostra ancora 00 007.
Questa schermata appartiene al ciclo seguente, non alla macroistruzione TAKE appena completata. Nella prova completa inserisci HLT 000 in 001 prima di proseguire.
Riepilogo della sequenza
Quattro passi per leggere il comando e sei per eseguire TAKE.
| Fase | Indirizzo MC | Microistruzione |
|---|---|---|
| Prelievo | 000 | pc->ab |
| Prelievo | 001 | ram->db |
| Prelievo | 002 | db->ins |
| Prelievo | 003 | ins->mc |
| Esecuzione TAKE | 010 | acc:=0 |
| Esecuzione TAKE | 011 | ins->ab |
| Esecuzione TAKE | 012 | ram->db |
| Esecuzione TAKE | 013 | plus |
| Esecuzione TAKE | 014 | pc++ |
| Esecuzione TAKE | 015 | mc:=0 |
Quattro passi di prelievo e sei di esecuzione. La sequenza di TAKE è acc:=0 → ins->ab → ram->db → plus → pc++ → mc:=0.
Prova di comprensione
Verifica il ruolo dei bus e l’avanzamento dei contatori.
- Perché DB contiene prima 01 005 e poi 00 007?
- Perché si azzera ACC prima di plus?
- Perché nella schermata con ACC = 7, PC è ancora 000?
Mostra le risposte corrette
- Prima si legge l’istruzione in 000, poi il dato in 005.
- Con ACC azzerato, sommare il dato equivale a caricarlo: nessun valore precedente si aggiunge al risultato.
- Il passo pc++ è il prossimo da eseguire e non è ancora avvenuto.
Documentazione
Schermate di riferimento e manuali del simulatore.
La sequenza è ricavata dalle schermate di Johnny 1.01 fornite per questa lezione. Manuali del progetto. Il microcodice è modificabile: verifica la sequenza caricata nel tuo simulatore.