# Algebre booleane e progetto logico dei calcolatori digitali/Progetto logico di un calcolatore digitale

Algebre booleane e progetto logico dei calcolatori digitali
Copertina Tutti i moduli · Sviluppo
Parte prima: Algebre booleane
    1.1 IntroduzioneAlgebre booleane e progetto logico dei calcolatori digitali/Introduzione
    1.2 Sistemi di numerazione, aritmetica binariaAlgebre booleane e progetto logico dei calcolatori digitali/Sistemi di numerazione, aritmetica binaria
    1.3 CodiciAlgebre booleane e progetto logico dei calcolatori digitali/Codici
    1.4 Teoria della commutazioneAlgebre booleane e progetto logico dei calcolatori digitali/Teoria della commutazione
    1.5 Algebra delle classi - Algebra della logicaAlgebre booleane e progetto logico dei calcolatori digitali/Algebra delle classi - Algebra della logica
    1.6 Algebre booleaneAlgebre booleane e progetto logico dei calcolatori digitali/Algebre booleane
    1.7 Funzioni booleaneAlgebre booleane e progetto logico dei calcolatori digitali/Funzioni booleane
    1.8 Rappresentazione geometrica delle funzioni booleane e loro minimizzazioneAlgebre booleane e progetto logico dei calcolatori digitali/Rappresentazione geometrica delle funzioni booleane e loro minimizzazione
Parte seconda: Circuiti logici e calcolatori digitali
    2.1 Circuiti logici e di memoriaAlgebre booleane e progetto logico dei calcolatori digitali/Circuiti logici e di memoria
    2.2 Circuiti di un calcolatore digitale (a)Algebre booleane e progetto logico dei calcolatori digitali/Circuiti di un calcolatore digitale (a)
    2.3 Circuiti di un calcolatore digitale (b)Algebre booleane e progetto logico dei calcolatori digitali/Circuiti di un calcolatore digitale (b)
    2.4 Progetto logico di un calcolatore digitaleAlgebre booleane e progetto logico dei calcolatori digitali/Progetto logico di un calcolatore digitale
Modifica il sommario
chiudi indice
Nei capitoli precedenti sono stati descritti i circuiti logici capaci di manipolare le informazioni e di memorizzarle, ed è stato presentato un metodo algebrico utile alla rappresentazione di questi circuiti.
Nel presente capitolo si cercherà di presentare il progetto logico di un semplice calcolatore digitale.

## Progetto del calcolatore

Un calcolatore digitale opera mediante delle informazioni, numeriche o di altro tipo, rappresentate in forma digitale.
Dal punto di vista del progetto logico, un calcolatore digitale può essere idealmente descritto come l'insieme de dispositivi di memoria bistabili (per es. flip-flop) connessi da reti logiche.
Lo stato di queste memorie di tipo discreto cambia in certi istanti; lo stato iniziale viene fissato dal programma.
La programmazione di un problema per un calcolatore digitale consiste nella preparazione di una sequenza di istruzioni mediante la quale il problema dato viene risolto dal calcolatore.
Per questo fine, la programmazione comprende l'analisi del problema, la preparazione di un diagramma a blocchi, e la codifica delle istruzioni. Il progetto di un calcolatore digitale può essere diviso in tre fasi: progetto del sistema, progetto logico, progetto dei circuiti.
Nella prima fase vengono prese in considerazione le richieste del problema e le specifiche del calcolatore tenendo conto del costo, delle dimensioni, della manutenzione, ecc. Questa fase richiede siano precisate le operazioni richieste (aritmetiche, logiche, e altre), la velocità delle operazioni, i metodi per il controllo degli errori ed altri dispositivi quali:registri indice, interruttori, ecc., capaci di fornire un uso più efficiente della macchina.
Si può includere in questa fase la selezione del tipo di circuiti logici, il tipo di memoria e le sue capacità, la qualità e la quantità dei dispositivi di input-output.
La seconda fase stabilisce il formato della parola, la configurazione della macchina e l istruzioni di macchina; questa fase termina una volta stabilito un insieme di equazioni logiche o un insieme di diagrammi logici dettagliati.
La terza fase comporta il progetto dei circuiti logici, della memoria e dei dispositivi di ingresso-uscita.
Il progetto logico di un calcolatore può essere, a sua volta, diviso in tre fasi: progetto funzionale, progetto simbolico, progetto dettagliato. Nella prima fase viene stabilito, innanzitutto, il formato della parola. Vengono scelti i registri, i contatori, le matrici, gli addizionatori e gli altri elementi; questi vengono completati con la memoria scelta ed i dispositivi di input-output in modo da stabilire un particolare insieme di istruzioni di macchina:
Nella seconda fase viene stabilita la sequenza di controllo del programma e le istruzioni di macchina vengono espresse in istruzioni simboliche. Durante questa fase è utile uno studio dettagliato della sequenza di operazioni relative alle istruzioni di macchina
Nella terza fase viene elaborato un insieme di equazioni logiche od un insieme di diagrammi logici che descrivono le singole le singole operazioni del calcolatore.
Nell'attuale progetto logico di un semplice calcolatore digitale, vengono costruite in modo completo le equazioni logiche; i diagrammi logici verranno mostrati abbastanza dettagliatamente in modo che il diagramma completo possa essere ricavato dal lettore.

## Progetto del sistema

Il calcolatore che verrà illustrato nel seguito fornisce un esempio di progetto logico di un calcolatore digitale capace di memorizzare un programma (stored-program computer) e capace di eseguire un certo numero di operazioni elementari quali la somma, la sottrazione, lo shift a destra e a sinistra di un bit, il trasferimento condizionato e incondizionato. Per semplicità il funzionamento del calcolatore si considera sincrono, binario e parallelo.

## Progetto funzionale

La prima fase del progetto del progetto logico è il progetto funzionale: innanzitutto viene stabilito il formato della parola.
La configurazione del calcolatore viene formulata scegliendo i registri, le matrici, la memoria ed i dispositivi di input-output. Vengono stabilite le istruzioni di macchina e si dà una breve descrizione della sequenza operativa.

### Formato della parola

Una parola (o voce) in un calcolatore è un insieme ordinato di digits che viene trattato dal calcolatore come una unità unitaria.
Si dice che il calcolatore ha una struttura a parole (a voci) se un da e che questa sia piccola. Un numero o una istruzione viene rappresentata mediante una parola.
Per facilitare lo studio del nostro ipotetico calcolatore, supponiamo di fissare la lunghezza della parola e che questa sia piccola. Come vedremo una parola corta consente un numero piccolo di istruzioni di macchina e di indirizzi di memoria.
La lunghezza di parla scelta per questo esempio è di 9 bits:
                   $x=x_{o}x_{1}x_{2}x_{3}x_{4}x_{5}x_{6}x_{7}x_{8}$
Una parola viene trattata dall'unità aritmetica come un numero: in questo caso il formato della parola viene chiamato formato del numero.
Sempre in questo esempio, il numero viene dato in una rappresentazione binaria frazionaria con i numeri negativi dati dal complemento a 2 del corrispondente numero positivo.
Il punt0 binario viene rappresentato idealmente tra i bits x_0 e x_1, mentre x_0 rappresenta il segno.
Poiché il valore di un numero binario con segno è compreso nell'intervallo -1≤x<1 il nostro calcolatore viene chiamato binary fractional computer.
Quanto detto non costituisce una vera restrizione per i calcoli, poiché un numero fuori dell'intervallo sopra indicato può essere rappresentato nel calcolatore moltiplicandolo per 2$^n$, con un appropriato valore di n.
La moltiplicazione per 2$^n$ non è altro che una operazione di shift.
Poiché il punto binario è fisso, il calcolatore è un fixed-point computer.
Esso differisce da un floating-point computer, capace di lavorare con una aritmetica in virgola mobile.
La parola considerata come istruzione è suddivisa in due parti (campi): il codice operativo e l'indirizzo. Il formato istruzione del nostro calcolatore sarà quindi:
Con un solo indirizzo, questo formato viene chiamato simple-address format
La porzione di tre bit chiamata codice operativo costituisce un codice binario di una operazione di macchina: per es. esso indica un trasferimento, una operazione aritmetica o logica.
I sei bits della parte indirizzo costituiscono il numero dell'indirizzo di memoria di una voce; questa parola di memoria viene chiamata operando. Un tale formato di istruzione indica che una operazione (specificata dalla porzione di codice operativo) viene eseguita sull'operando conservato nella posizione di memoria specificata dalla porzione di indirizzo.
Certe istruzioni non necessitano di operandi:in questo caso la parte relativa all'indirizzo può essere usata per altri scopi.

### Configurazione del calcolatore

La configurazione del nostro calcolatore ipotetico è mostrata in fig. 4.3.1.
Per essere uno stored-programm computer il calcolatore deve memorizzare sia i numeri che le istruzioni.
Questa considerazione fa introdurre l'unità di memoria (indicata con i registri M): la sua capacità è di 64 parole di 9 bits ciascuna.
Come mostrato in figura 4.3.2, questi flip-flop sono denotati con M$_{(ji)}$, dove j indica la J$^{(sima)}$ parola e i il bit$^{(simo)}$.
Ad ogni locazione di memoria viene attribuito un indirizzo : la selezione degli indirizzi viene fatta mediante il memory register C.
Il registro C consiste di 6 flip-flop (fig. 4.3.2).
Un duplicatore di indirizzi viene messo tra il registro C e la memoria.
Perché il calcolatore possa eseguire operazioni aritmetiche, occorre introdurre una unità aritmetica, capace in questo caso semplice di sole somme e sottrazioni.
Un accumulatore (registro A) è sufficiente come unità aritmetica: esso consiste in 9 bits, in modo da memorizzare una intera parola (fig. 4.3.2)
Quando una istruzione viene presa dalla memoria, essa viene conservata temporaneamente in un registro per essere successivamente eseguita. L'apposito registro viene chiamato intruction register (R) ed è ovviamente di 9 bits
I bit R$_0$ R$_1$ R$_2$ memorizzano il codice operativo, mentre i 6 bits da R$_3$ a R$_9$ conservano la parte indirizzo della parola istruzione.
La necessità di eseguire un controllo di sequenze introduce la program control unit.
Il nostro calcolatore ha un operation counter (F), di 4 bits (fig. 4.3.2), I tre bits F$_2$ F$_3$ F$_4$, danno il codice operativo.
L'operation counter conteggia gli impulsi di un orologio e genera i segnali di controllo mediante un decodificatore di operazioni.
Un generatore di impulsi d'orologio da una sequenza di impulsi temporali con periodo τ.
L'impulso di orologio serve a sincronizzare le operazioni del calcolatore.
Un altro clock-pulse generator (non indicato in fig. 4.3.1) genera un singolo impulso: esso è sotto il controllo dell'operatore che in questa maniera, può osservare il procedere del calcolatore passo per passo.
Altro dispositivo di controllo è il Fliop-Flop G, capace di avviare od arrestare le operazioni del calcolatore.
Il controllo del flip-flop G è accessibile all'esterno mediante lo switch (interruttore) S.
Come dispositivi di input capaci di inserire in memoria dati e istruzioni, vi sono gli switch Q mentre per fornire i risultati ci possono essere dei dispositivi luminosi (non indicati in fig. 4.3.1). Sia gli switchs Q che i dispositivi luminosi sono connessi ai singoli bit di memoria.
I dispositivi luminosi sono anche connessi ai singoli bit dei registri in modo da osservare le operazioni del calcolatore durante eventuali test.

### Istruzioni di macchina

Formuliamo ora l'insieme di istruzioni che la macchina è capace di eseguire.
La lista di istruzioni capace di risolvere un certo problema deve essere ovviamente codificata prima di essere caricata nel calcolatore in modo che le istruzioni stesse siano comprensibili alla macchina:
Le istruzioni eseguibili da questo calcolatore ipotetico sono raggruppate in tabella 4.3.3 seguente
| Codice........... | Istruzione | Descrizione dell'istruzione |
| 000 uvwxyz | Addizione | Prende il numero dalla memoria all'indirizzo uvwxyz, lo mette nel registro R; somma il contenuto di R al contenuto del registro A e conserva il risultato nel registro A. |
| 001 uvwxyz | Sottrazione | Prende il numero dalla memoria all'indirizzo uvwxyz, lo mette nel registro R; sottrae il contenuto di R al contenuto del registro A e conserva il risultato nel registro A. |
| 010 uvwxyz | trasferimento condizionato | Se A$_0$=1 (segno di A negativo) si prende come nuova istruzione quella contenuta nella memoria all'indirizzo uvwxyz; se A$_0$=0 (segno di A positivo), si prende la nuova istruzione in sequenza. |
| 100 uvwxyz | trasferimento incondizionato | Prende la nuova istruzione dalla memoria di indirizzo uvwxyz. |
| 011 uvwxyz | Memorizzazione | Memorizza il contenuto del registro A nell'indirizzo uvwxyz di memoria |
| 1011000 yz | Shift a destra | - |
| 1010100 yz | Shift a sinistra | Ilo contenuto del registro A viene shiftato a sinistra di 1 bit. |
| 1010010 yz | Azzera l'accumulatore | Si azzera l'accumulatore A |
| 1010001 yz | Stop | Stop della macchina e nel registro C compare l'indirizzo 000000. |
Poiché la macchina non compie alcuna operazione in relazione agli organi di input-output, non sono previste istruzioni relative ad operazioni di ingresso-uscita.
La quantità uvwxyz indica uno dei 64 possibili indirizzi di memoria.
È da osservare che le ultime quattro istruzioni di tabella 4.3.3 non fanno riferimento a posizioni di memoria (cioè non è necessario un operando e quindi la parte indirizzo può essere utilizzata nella codificazione del codice operativo).
Quindi, pur avendo solo 3-bit a disposizione del codice, si hanno in effetti nove operazioni.

### Sequenza operativa del calcolatore

Facendo riferimento alla configurazione di fig-4.3.1, le istruzioni codificate che formano un programma vengono inserite per prima cosa in memoria tramite l'interruttore Q attraverso la porta A$_7$.
L'operatore pone l'interruttore S in posizione ON e la macchina incomincia a funzionare.
Lo stato di tutti i registri viene cambiato tramite i segnali di controllo provenienti dallo operation counter.
Questi cambiamenti possono solo aver luogo in concomitanza degli impulsi di orologio.
Quando la macchina opera per la prima volta, il contenuto del registro C è 000000; per cui la prima parola di memoria è la prima istruzione.
Il segnale di controllo h trasferisce questa istruzione dall'unità di memoria al registro R tramite le porte A$_3$ e A$_4$.
La parte codice operativo della istruzione che si trova ora nel registro R viene trasferita al registro F tramite la porta A$_8$ sotto il controllo del segnale i, mentre il segnale di controllo c trasferisce la parte indirizzo tramite la porta A$_1$ al registro C.
Il codice operativo nel registro F è ora decodificato e vengono generati i comandi necessari all'esecuzione dell'istruzione,
Per le operazioni aritmetiche, il segnale di controllo d trasferisce, attraverso le porte A$_3$ e A$_4$, un numero dalla memoria al registro R, ed il segnale di controllo g determina, mediante la porta A$_9$, la realizzazione di una specifica operazione aritmetica sul numero contenuto in R e su quello inizialmente in A.
Per le operazioni di shift e di azzeramento dell'accumulatore si ha il segnale di controllo f.
L'operazione di trasferimento relativa alla sequenza di controllo avviene sotto i segnali b o H, mentre il segnale e, selezionando la porta A$_6$, conserva mediante la porta A$_5$, il controllo dell'accumulatore nella memoria all'indirizzo che si trova nel registro C.
L'ultima istruzione del programma in memoria è in genere una istruzione di stop: l'operation counter invia il segnale di controllo a al flip-flop G e la macchina si ferma.

## Fase di progettazione simbolica

In questa fase viene stabilita la sequenza di controllo del programma e le operazioni di macchina vengono rappresentate mediante espressioni simboliche.
Tra i simboli già introdotti nel Cap. 3 Parte IIa, dobbiamo introdurre il seguente: < >, con cui indichiamo l'indirizzo di una parola di memoria e precisamente M<C> indica la locazione di memoria il cui indirizzo è nel registro C.
Le istruzioni indicate in tabella 4.3.3 vengono ora espresse in termini di espressioni simboliche elencate nella seguente tabella 4.4.1
| Istruzioni..................................................... | ! Operazioni richieste............... | Operazioni ausiliarie |
| Addizione (000uvwxyz) | (M<C>=>R; (R)+(A)=>A | (Ad[R])=>C; (C)+10=>C |
| Sottrazione (001uvwxyz) | (M<C>R=>R; (A)-(R)=>A | come sopra |
| Trasferimento condizionato (010uvwxyz) | nessuno | come sopra se A$_0$=0 nessuno se A$_0$=1 |
| Memorizzazione (011uvwxyz) | (A)=>M<C> | (Ad[R])=>C; (C)+1=>C |
| Trasferimento incondizionato (100uvwxyz) | nessuno | nessuno |
| Shift right (1011000) | (A$_{{i-1}}$=>A$_i$; (A)$_0$=>A$_0$ | (Ad[R])?>C; (C)+1=>C |
| Test Shift left (1010100yz | (A$_{i+1}$)=>A$_i$; (A$_0$)=>A$_8$ | come sopra |
| Azzeramento accumulatore (1010010yz | 0=>A | come sopra |
| Stop (10010001yz) | 0=>G; 0=>C; 1=>F | nessuna |
| Comando d'avvio (manuale) | 1=>G | nessuna |
| Comando inserimento dati (manuale) | (Q$_{ij)}$=>M$_{ij}$ | nessuna |
L'addizione mostrata in tabella 4.3.3 è costituita da due operazioni La prima operazione consiste nel prendere un numero dalla memoria di indirizzo uvwxyz e metterlo nel registro R, simbolicamente.
                $(M<C>)\Rightarrow R$
dove C contiene l'indirizzo di memoria uvwxyz.
La seconda operazione è: addizionare il contenuto del registro R al contenuto del registro A, e conserva il risultato nel registro A. Simbolicamente si ha:
                $(R)+(A)\Rightarrow A$
Nella tabella 4.4.1 compaiono le due espressioni simboliche per la istruzione di addizione. Si hanno inoltre due espressioni simboliche simili alle precedenti, per la sottrazione.
L'istruzione di memorizzazione del contenuto del registro (A) nella memoria di indirizzo uvwxyz, si esprime come:
                $(A)\Rightarrow M<C>$
dove C contiene il riferimento all'indirizzo di memoria uvwxyz.
L'istruzione di shift' a destra consiste nello spostare il contenuto del registro A di un bit a destra e simbolicamente:
                $(A_{i-1})\Rightarrow A_{i}\ \ \ \ \ dove\ i=1,....,8$
                $(A_{0})\Rightarrow A_{0}$
La seconda espressione dice che lo shift a destra richiede che il bit più a sinistra del registro A conservi il valore originale durante l'operazione di scorrimento.
L'operazione di shift a sinistra richiede che il contenuto del registro A sia spostato di 1 bit a sinistra:
                $(A_{i+1})\Rightarrow A_{i}\ \ \ \ \ dove\ i=1,....,7$
                $(A_{0})\Rightarrow A_{8}$
Questa operazione di shift a sinistra muove il bit più a sinistra del registro A in maniera circolare.
L'azzeramento dell'accumulatore diventa:
                $0\Rightarrow A$
L'istruzione di stop consiste nell'arrestare la macchina e porre nel registro C il primo indirizzo 000000; simbolicamente:
                $0\Rightarrow G\ \ \ \ \ e\ \ \ \ \ 0\Rightarrow C$
L'operazione di avvio del calcolo e di inserimento delle istruzioni dei dati in memoria non vengono indicate in tabella 4.4.1 in quanto operazioni manuali.
Simbolicamente, esse sono:
                $1\Rightarrow G\ \ \ \ \ e\ \ \ \ \ (Q_{ji})\Rightarrow M_{ji}$
La prima espressione indica il set del flip-flop G mentre la seconda indica l'inserimento del contenuto dell'interruttore Q$_{ji}$ nel bit di memoria M$_{ji}$

### Ciclo d'istruzione e ciclo di esecuzione

Sia le istruzioni che i dati di un programma capace di risolvere un certo problema vengono inizialmente conservati in memoria.
Il programmatore scrive queste istruzioni in una sequenza in accordo con l'ordine degli indirizzi di memoria in cui queste istruzioni verranno memorizzate.
Nel nostro calcolatore ipotetico la prima istruzione del programma viene messa nella posizione 000000.
Il calcolatore esegue la sequenza di istruzioni conservata in memoria: esso opera secondo una sequenza interna eseguendo ogni istruzione come vengono chiamate, una dopo l'altra, dal programma.
La sequenza interna passa da un ciclo d'istruzione ad un ciclo di esecuzione.
Durante il ciclo istruzione viene presa una istruzione dalla memoria e il calcolatore viene posto nelle condizioni di poter compiere la esecuzione di una sola istruzione.
Durante il ciclo esecuzione viene eseguita l'istruzione ed il calcolatore viene posto nelle condizioni di poter tornare al ciclo istruzione.
In fig-4.4.2 sono raffigurati entrambi i cicli.
Durante la fase del ciclo di istruzione vi sono quattro operazioni (fig-4.4.3a); la prima permette di prendere una istruzione: una parola viene presa dalla memoria il cui indirizzo è nel registro C (000000 per la prima istruzione) e trasferita nel registro R; simbolicamente:
                $(M<C>)\Rightarrow R$
Il contenuto di C (memory-address) durante questa operazione è un instruction address.
La seconda e terza operazione (che avvengono contemporaneamente) sono operazioni di trasferimento mediante le quali vengono trasferite la porzione del codice operativo dal registro R, Op[R], nella porzione istruzione del registro F, e la parte indirizzo di R, Ad[R] nel registro C:
                $Op[R]\Rightarrow I[F]$
                $Ad[R]\Rightarrow C$
A questo istante la la parte indirizzo di R, è un operand address e quindi non è più l'indirizzo di istruzione menzionato nella fase precedente.
Dopo il trasferimento la parte di codice operativo fa generare dal decodificatore di operazioni, dei segnali di comando, dando così inizio all'esecuzione della istruzione mentre l'indirizzo dell'operando si trova ora nel registro R:
Normalmente questo ciclo istruzione è completo: nel nostro calcolatore ipotetico, data la sua semplicità, è necessaria una quarta operazione che trasferisca l'indirizzo della istruzione contenuta in C nella parte indirizzo di R:
                $(C)\Rightarrow Ad[R]$
Il motivo di questa ulteriore operazione è dovuto al fatto che la parte indirizzo del registro R (operand address) viene trasferita nel registro C e quindi l'indirizzo della istruzione contenuta in C (000000 per la prima istruzione) viene perduto.
Questo indirizzo della istruzione che è stato preso in considerazione deve essere conservato in qualche maniera in quanto l'indirizzo della nuova istruzione è ottenuto da quello della presente, sommando 1.
Poiché la parte indirizzo del registro R è stata trasferita nel registro C e non è usata per il momento. l'indirizzo della presente istruzione può essere trasferito per una memorizzazione temporanea nella parte indirizzo del registro R.
In altre parole, l'indirizzo della presente istruzione contenuto in C viene trasferito in R e nello stesso istante l'indirizzo dell'operando contenuto i R viene trasferito in C.
Questi due trasferimenti simultanei sono possibili se si fa l'ipotesi che i flip-flop dei registri R e C abbiano un delay sufficiente.
In un calcolatore digitale ordinario con capacità di memorizzazione di programmi c'è generalmente un ulteriore contatore di istruzioni atto a memorizzare l'indirizzo della attuale istruzione e, tramite incremento di 1 unità dopo l'esecuzione di una istruzione si determina l'indirizzo della nuova istruzione da eseguire.
In tal caso non è necessaria l'operazione di trasferimento da C ad Rprecedentemente descritta.
Le operazioni che avvengono durante il ciclo istruzioni sono sempre le stesse, mentre quelle che compaiono durante il ciclo esecuzione dipendono dal codice operativo dell'istruzione.
In fig-4.4.3b si è preso in considerazione il ciclo esecutivo di una istruzione d'addizione: esso incomincia prendendo la parola operando dalla memoria localizzata dall'operand address contenuto in C. La parola operando è trasferita nel registro R che viene utilizzato attualmente come memoria temporanea:
                $(M<C>)\Rightarrow R$
Durante l'operazione di caricamento dell'operando, il contenuto della parte indirizzo di R che altro non è se non l'indirizzo della attuale istruzione, viene trasferito in C:
                $Ad[R]\Rightarrow C$
L'operando ora contenuto in R viene addizionato al contenuto del registro <a (che è un accumulatore):
                $(R)+(A)\Rightarrow A$
Infine, il contenuto del registro C (contenente l'indirizzo della attuale istruzione) viene incrementato di 1 diventando così l'indirizzo della nuova istruzione:
                $(C)+1\Rightarrow C$
Così il ciclo esecutivo risulta completo.
La nuova istruzione è pronta per essere presa dalla memoria mediante la prima operazione del ciclo istruzione dell'indirizzo di memoria indicato dal contenuto di C.
Nel caso di una istruzione di trasferimento incondizionato, l'indirizzo della nuova istruzione è dato dall'indirizzo dell'operando.
Nel caso di una istruzione di trasferimento condizionato, la sequenza procede come nel caso del trasferimento incondizionato, se la condizione è verificata (A$_0$=1); se la condizione non è verificata (A$_0$=0), la nuova istruzione da eseguire viene determinata mediante l'operatore (C)+1=>C.
L'operazione ausiliaria (1=>F) viene spiegata nel seguito.

### Diagramma di stato

L'unità di controllo del programma (registro F) del nostro calcolatore ipotetico consiste in un contatore e in un decodificatore associato (fig-4.3.2).
Gli stati del contatore rappresentano gli stati del calcolatore; quindi la sequenza degli stati del contatore controlla la sequenza operativa del calcolatore.
Poiché sono contemplate nove operazioni, sono richiesti all'operation counter nove stati, e ciò implica un minimo di 4 Flip-Flop, F$_1$,F$_2$,F$_3$,F$_4$.
I flip-flop f$_2$ e f$_4$ costituiscono la parte istruzione del registro F(o I[F]); in essi vengono memorizzati i 3 bit della porzione codice operativa del registro istruzioni R.
Per un contatore con quattro flip-flop, si possono presentare 16 stati; essi vengono indicati con la notazione f$_i$ in tabella 4.4.4 (l'indice i rappresenta il numero binario corrispondente di 4 bit).
ogni stato rappresenta 1 segnale di comando. come si vede da tavola 4.4.4.
Stati dello operation counter :
| operation counter F$_1$ F$_2$ F$_3$ F$_4$.......... | stato................. | segnali di comando |
| 0 0 0 0 | f$_0$ | comando di addizione |
| 0 0 0 1 | f$_1$ | comando di sottrazione |
| 0 0 1 0 | f$_2$ | comando di trasferimento condizionale |
| 0 0 1 1 | f$_3$ | comando di immagazzinaggio |
| 0 1 0 0 | f$_4$ | comando ciclo istruzioni |
| 0 1 0 1 | f$_5$ | comando per f$_{12}$, f$_{13}$, f$_{14}$, f$_{15}$ |
| 0 1 1 0 | f$_6$ | non usato |
| 0 1 1 1 | f$_7$ | non usato |
| 1 0 0 0 | f$_8$ | comando operazione di addizione |
| 1 0 0 1 | f$_9$ | comando operazione di sottrazione |
| 1 0 1 0 | f$_{10}$ | comando ciclo istruzioni |
| 1 0 1 1 | f$_{11}$ | comando operazione aggiunta di 1 |
| 1 1 0 0 | f$_{12}$ | comando di scorrimento a destra |
| 1 1 0 1 | f$_{13}$ | comando di scorrimento a sinistra |
| 1 1 1 0 | f$_{14}$ | comando di svuotamento dell'accumulatore |
| 1 1 1 1 | f$_{15}$ | comando di arresto |
Poiché sono sufficienti 14 stati, i comandi f$_6$ e f$_7$ non vengono usati. Gli stati f$_4$ e f$_{10}$sono quelli corrispondenti al ciclo istruzione; gli stati rimanenti corrispondono al ciclo esecutivo.
Poiché vi sono 9 istruzioni, vi sono nove possibili percorsi da f$_{10}$ a f$_4$; durante il ciclo esecutivo, la sequenza operativa segue una di queste nove vie.
Quando il calcolatore esegue un programma, non fa altro che percorrere ciclicamente queste vie del diagramma di stato (fig-4.4.5) in accordo con le istruzioni programmate.
La scelta dei 14 segnali di comando tra i 16 possibili stati del contatore non è del tutto arbitraria ma è stata fatta cercando di semplificare la logica del circuito.
Infatti gli stati f$_0$, f$_1$, f$_2$, f$_3$, f$_4$, f$_5$ sono relativi a comandi di istruzioni e questa scelta fa si che il flip-flop F$_1$ sia uguale a 0 per tutti i comandi di istruzione, semplificando così la logica del circuito.
Mediante la tabella 4.4.4 e conoscendo la sequenza di controllo relativa ai cicli-istruzione e cicli.esecuzione si può costruire la figura 4.4.5 detta anche diagramma di stato in cui compaiono gli stati del calcolatore dopo le singole operazioni e le operazioni conseguenti ad ogni singolo stato.
In figura 4.4.5 l'operazione di prendere una istruzione in memoria durante il ciclo-istruzione avviene allo stato f$_4$, mentre le altre tre operazioni relative al ciclo-istruzione avvengono allo stato f$_{10}$.
La sequenza interna del ciclo esecutivo dipende dal contenuto dei flip-flop R$_0$, R$_1$, R$_2$.
Vi sono sei strade: per l'addizione, la sottrazione, il trasferimento condizionato, il trasferimento incondizionato, il comando di memorizzazione, inoltre vi sono le strade che compaiono quandoR$_0$R$_1$R$_2$ è 101 e indicano le operazioni di left-shift, right-shift, clear accumulator e stop.
L'operazione che costruisce l'indirizzo relativo all'istruzione successiva (detto anche indirizzo di ritorno) avviene negli stati f$_0$, f$_1$, f$_2$, f$_3$ e f$_5$ mentre non è necessaria se l'istruzione appena eseguita è un trasferimento incondizionato.
Uno zero viene inserito nel flip-flop G allo stato f$_5$ se C$_3$ è 1.
L'operazione di incremento di 1 avviene durante lo stato f$_{11}$.
L'operazione di prendere dalla memoria l'operando avviene durante gli stati f$_0$ e f$_1$ mentre le operazioni di addizione e di sottrazione vengono eseguite agli stati f$_8$ e f$_9$ rispettivamente.
Allo stato f$_{15}$, il comando di stop inserisce tutti 0 nel registro C e tutti 1 nel registro F.
L'operation counter continua a conteggiare i segnali dell'orologio ma il suo stato rimane f$_{15}$ a causa dell'operazione 1=>F:
Perciò, sotto il comando di stop il calcolatore non si arresta ma viene sospesa solo la sequenza operativa.
Quando lo switch S' viene messo nello stato off, il flip-flop G assume lo stato 0: il calcolatore continua ad eseguire l'istruzione in corso fino a quando l'operation counter, raggiunge lo stato f$_4$.
A questo punto, l'operation counter assume lo stato f$_{15}$ e rimane in tale stato.
Quando la sequenza è stata sospesa, può essere ripristinata ponendo lo switch S nella posizione ON
Quando questo accade, il Flip-Flop G assume lo stato 1 e l'operation counter assume lo statof$_4$
Poiché il contenuto del registro C era stato cambiato in 000000, il calcolatore comincia dall'istruzione contenuta nella prima posizione di memoria.

## Equazioni logiche

Durante questa fase vengono derivate le equazioni logiche dei circuiti, partendo dalle espressioni simboliche di figura 4.4.5.
Queste equazioni rappresentano le equazioni di input dei Flip-flop dei registri F,A,C,R,M e del Flip-Flop G.

### Operation counter

Nell'operation counter vi sono quattro flip-flop F$_1$,F$_2$,F$_3$,F$_4$: esso deve realizzare la sequenza di figura 4.4.5 ed assumere lo stato 1111 quando G è 0.
Da figura 4.4.5 si ha allora che lo stato del flip-flop F$_1$ cambia quando dallo stato f$_4$ (0100) si passa allo stato f$_{10}$ (1010).
Cambia inoltre quando f$_{10}$ (1010) diventa f$_0$ (0000), con R$_0$,R$_1$,R$_2$ (000).
In breve lo stato del flip-flop F$_1$ cambia quando si presenta una delle sei seguenti condizioni.
       $f_{1}0{\bar {R}}_{0}{\bar {R}}_{1}{\bar {R}}_{2}+f_{1}0{\bar {R}}_{0}{\bar {R}}_{1}R_{2}+f_{1}0{\bar {R}}_{0}R_{1}{\bar {R}}_{2}+f_{1}0{\bar {R}}_{1}R_{2}+f_{1}0R_{0}|barR_{1}R_{2}+f_{1}0R_{0}{\bar {R}}_{1}|barR_{2}=f_{1}0$
Le altre condizioni che determinano il cambiamento dello stato di F$_1$ possono essere dedotte con considerazioni simili, tenendo sempre presente il diagramma di stato di figura 4.4.5.
Chiamando quindi p l'impulso d'orologio che commuta i flip-flop, si hanno le seguenti equazioni di input per F$_1$, F$_2$, F$_3$, F$_4$.
       $f_{1t}=[f_{4}+f_{10}+f_{0}+f_{1}f_{2}{\bar {A}}_{0}+f_{3}+f_{5}(C_{0}+C_{1}+C_{2}+C_{3})+f_{11}+f_{15}G]p$
       $f_{2t}=[f_{4}G+f_{10}R_{0}+f_{2}A_{0}+f_{11}+f{12}+f_{13}+f_{14}]p$
       $f_{3t}=[f_{4}+f_{10}{\bar {R}}_{1}+f_{2}A_{0}+f_{5}(C_{2}+C_{3})+f_{8}+f_{9}+f_{11}+f_{12}+f_{13}+f_{15}G]p$
       $f_{4t}=[f_{4}{\bar {G}}+f_{10}R_{2}+f_{2}{\bar {A}}_{0}+f_{5}(C_{0}+C_{2})+f_{8}+f_{11}+f_{12}+f_{14}+f_{15}G]p$
Quando il contatore si trova nello stato f$_{15}$ e il flip-flop G ha valore 0, viene richiesta l'operazione 1=>F: in tavola 4.5.2 vengono mostrati i valori assunti dai flip-flop F$_i$ durante tale operazione.
Le equazioni di input dei flip-flop F in tale caso saranno:
                $f_{it}={\bar {F}}_{i}Gf_{15}p\ \ \ \ \ i=1,...4\ \ (4.5.3$
Poiché f$_{15}$ è F$_1$F$_2$F$_3$F$_4$=1111, negF$_i$ f$_{15}$ nella equazione 4.5.3 è sempre 0, e quindi l'equazione (4.5.3) non è necessaria.
Le equazioni 4.5.1 sono le equazioni di input del registro F-
In fig. 4.5.4 compare il diagramma logico relativo alle (4.5.1).

### Accumulatore

Come mostrato nel diagramma 4.4.5, l'accumulatore interviene durante l'esecuzione delle operazioni relative agli stati:
                $f_{8}:[R]+(A)\Rightarrow A$
                $f_{9}:(A)-(R)\Rightarrow A$
                $f_{12}:(A_{0})\Rightarrow A_{0}\ \ \ \ (A_{i-1})\Rightarrow A_{i}\ \ \ \ i=1,...,8$
                $f_{13}:(A_{0})\Rightarrow A_{8}\ \ \ \ (A_{i+1})\Rightarrow A_{i}\ \ \ \ i=0,...,7$
                $f_{14}:=\Rightarrow A$
Durante l'operazione di addizione relativa allo stato f$_8$,A$_i$ e R$_i$ sono gli i$^{simi}$ bits degli addendi.
K$_i$ è il riporto dovuto alla somma fatta sugli (i+1)$^{simi}$ bits.
L'operazione di somma viene mostrata in tabella 4.5.5.
       $Tabella\ 4.5.5$
| A$_i$ | R$_i$ | K$_i$ | K$_{i-1}$ | A$_i$ t | Q$_{it}$ |
| 0 | 0 | 0 | 0 | 0 | 0 |
| 0 | 0 | 1 | 0 | 1 | 1 |
| 0 | 1 | 0 | 0 | 1 | 1 |
| 0 | 1 | 1 | 1 | 0 | 0 |
| 1 | 0 | 0 | 0 | 1 | 0 |
| 1 | 0 | 1 | 1 | 0 | 1 |
| 1 | 1 | 0 | 1 | 0 | 1 |
| 1 | 1 | 1 | 1 | 1 | 0 |
Da tale tabella, si ricavano le seguenti equazioni di input:
                $Q_{it}=(R\oplus K_{i})f_{8}p\ \ \ \ i=0,...,8\ \ \ \ \ (4.5.6)$
mentre per il riporto si ha:br/>
                $K_{i-1}=(R_{i}K_{i}+R_{i}A_{i}+A_{i}K_{i})f_{8}P\ \ \ \ i=1,....,8$
                $K_{8}=0$
Per l'operazione di sottrazione relativa allo stato f$_9$, A$_i$ e R$_i$ sono rispettivamente l'i$^{simo}$ bit del minuendo e dell'i$^{simo}$ bit del sottraendo.
Le equazioni di input del riporto sono le stesse di (4.5.6) ad eccezione di R$_i$ che viene sostituito da ${\bar {R}}_{i}$ e K$_8$ viene sostituito da 1in modo da sostituire il contenuto di R con il suo complemento a 2.
Le equazioni di input e del riporto sono quindi:
             $a_{it}=({\bar {R}}_{i}\oplus K_{i})f_{9}p\ \ \ \ \ i=0,....,8\ \ \ (4.5.7)$
             $K_{i-1}={\bar {R}}_{i}K_{i}+{\bar {R}}_{i}A_{i}+A_{i}K_{i})f_{9}p\ \ \ \ i=1,..,8$
             $K_{8}=f_{9}p$
L'operazione di scorrimento a destra avviene allo stato f$_{12}$.
Esso fa scorrere il contenuto dell'accumulatore di un bit a destra mentre lo stato di A$_0$ rimane inalterato.
La tabella (4.5.8) rappresenta l'operazione di scorrimento a destra.
Le equazioni di input sono:
                $a_{it}=(A_{i-1}\oplus A_{i}f_{12}p\ \ \ \ i=1,...,8$
Non vi è alcuna equazione per a$_{0t}$ in quanto lo stato del flip-flop A$_0$ non deve cambiare.
L'operazione di scorrimento a sinistra avviene allo stato f$_{13}$.
Essa fa scorrere il contenuto dell'accumulatore di un bit verso sinistra mentre lo stato di A$_8$ viene sostituito da quello di A$_0$.
Le equazioni di input saranno:
                $a_{it}=(A_{i}\oplus A_{i+1}f_{13}p\ \ \ \ i=0,...,7$
                $a_{8t}=(A_{0}\oplus A_{8}f_{13}p$
L'operazione di azzeramento dell'accumulatore avviene allo stato f$_{14}$ (tabella 4.5.9):
Le equazioni di input sono:
                $a_{it}=A_{i}f_{14}p\ \ \ \ i=0,...,8$
quindi le equazioni di input dei flip-flop che costituiscono l'accumulatore A saranno:
       $a_{it}=(R_{i}p\oplus K_{i})f_{8}p+({\bar {R}}_{i}\oplus K_{i})f_{9}p+(A_{i-1}\oplus A_{i})f_{12}p+(A_{i}\oplus A_{i+1}f_{13}p+A_{i}f_{14}p\ \ \ \ \ i=1,...,7$
       $a_{0t}=(A_{0}\oplus K_{0})f_{8}p+({\bar {R}}_{0}\oplus K_{0})f_{9}p+(A_{0}\oplus A_{1})f_{13}p+a_{0}f_{14}p$
       $a_{8t}=(A_{8}\oplus K_{8})f_{8}p+({\bar {R}}_{8}\oplus K_{8})f_{9}p+(A_{7}\oplus A_{8})f_{12}p+(A_{0}\oplus A_{8})f_{13}p+a_{8}f_{14}p$
       $K_{i-1}=(R_{i}K_{i}+R_{i}A_{i}+A_{i}K_{i})f_{8}p+({\bar {R}}_{i}K_{i}+|barR_{i}A_{i}+A_{i}K_{i})f_{9}p$
i=1,...,8
       $K_{8}=f_{9}p$
Il diagramma logico dell'i$^{simo}$ stadio dell'accumulatore viene presentato in fig. 4.5.10

### Memory address register

Nel diagramma di stato di fig-4.4.5, il registro C deve permettere le seguenti operazioni:
       $f_{10}+f_{0}+f_{1}+f_{2}{\bar {A}}_{0}+f_{3}+f_{5}\ \ \ :(Ad[R])\Rightarrow C\ \ \ :(C)+1\Rightarrow C\ \ \ :0\Rightarrow C$
La tabella della verità relativa alla operazione (Ad[R]=>C è quella posta a fianco.
Le equazioni di input da tale tavola sono:
                $C_{it}=(R_{i+3}\oplus C_{i})gp\ \ \ \ i=0,...,5$
                $g=f_{10}+f_{0}+f_{1}+f_{2}{\bar {A}}_{0}+f_{3}+f_{5}$
L'operazione (C)+1=>C avviene allo stato f$_{11}$: durante questa operazione, il registro C funziona come un contatore binario.
Le equazioni di input saranno quindi:
             $C_{5t}=f_{11}p$
             $C_{4t}=C_{5}f_{11}p=C_{5}c{5t}$
             $C_{3t}=C_{4}C_{5}f_{11}p=C_{4}c_{4t}$
             $C_{2t}=C_{3}C_{4}C_{5}f_{11}p=C_{3}c_{3t}$
             $C_{1t}=C_{2}C_{3}C_{4}C_{5}f_{11}p=C_{2}c_{2t}$
             $C_{0t}=C_{1}C_{2}C_{3}C_{4}C_{5}f_{11}p=C_{1}c{1t}$
La terza operazione, quella inerente all'azzeramento del registro C, viene eseguita allo stato $f_{15}{\bar {G}}$
La tavola della Verità corrispondente è uguale a quella di Fig. 4.5.9.
Le equazioni di input sono:
                $c_{it}=C_{1}f_{15}{\bar {G}}p$
In definitiva, le equazioni di input dei flip-flop relativi al memory-address register sono:
             $c_{0t}=C_{1}C_{2}C_{3}C_{4}C_{5}f_{11}p+(R_{3}\oplus C_{0})gp+C_{0}f_{15}{\bar {G}}p$
             $c_{1t}=C_{2}C_{3}C_{4}C_{5}f_{11}p+(R_{4}\oplus C_{1})gp+C_{1}f_{15}{\bar {G}}p$
             $c_{2t}=C_{3}C_{4}C_{5}f_{11}p+(R_{5}\oplus C_{2})gp+C_{2}f_{15}{\bar {G}}p$
             $c_{3t}=C_{4}C_{5}f_{11}p+(R_{6}\oplus C_{3})gp+C_{3}f_{15}{\bar {G}}p$
             $c_{4t}=C_{5}f_{11}p+(R_{7}\oplus C_{4})gp+C_{4}f_{15}{\bar {G}}p$
             $c_{5t}=f_{11}p+(R_{8}\oplus C_{5})gp+C_{5}f_{15}{\bar {G}}p$
dove $g=f_{10}+f_{0}+f_{1}+f_{2}{\bar {A}}_{0}+f_{3}+f_{5}$
In fig. 4.5.11 compare un diagramma logico relativo al memory-address register. In questa figura è indicata anche l'address decoder, che non è altro che una matrice con 6 coppie di input e 64 output.
Gli output D$_j$ (j$^{sima}$ parola) del decodificatore sono rappresentati come:
                $D_{0}={\bar {C}}_{0}{\bar {C}}_{1}{\bar {C}}_{2}{\bar {C}}_{3}{\bar {C}}_{4}{\bar {C}}_{5}$
                $D_{1}={\bar {C}}_{0}{\bar {C}}_{1}{\bar {C}}_{2}{\bar {C}}_{3}{\bar {C}}_{4}C_{5}$
                $D_{63}=C_{0}C_{1}C_{2}C_{3}C_{4}C_{5}\ \ \ \ \ \ \ \ (4.5.12)$

### Instruction register

L'instruction register permette la memorizzazione temporanea di una parola presa dall'unità di memoria:
Come è mostrato in fig-4.4.5, sono richieste le esecuzioni delle seguenti operazioni:
                   $f_{10}:(C)\Rightarrow Ad[R]$
                   $f_{0},f_{1},f_{4}:(M<C>)\Rightarrow R$
La prima operazione, relativa al trasferimento del contenuto del registro C nella parte indirizzo del registro R ha la tabella della verità affiancata.
Le equazioni di input saranno quindi:
                $r_{it}=(C_{i-3}\oplus R_{i})f_{10}p\ \ \ \ \ i=3,...,8$
La seconda operazione prende una parola dalla memoria il cui indirizzo è dato dal contenuto del registro Ce la conserva nel registro R.
L'indirizzo contenuto viene indicato con la notazione D$_j$, dove J specifica la j$^{sima}$ parola.
Nella memoria del nostro ipotetico calcolatore vi sono 576 bits conservati in 64 parole; essi vengono espressi con il simbolo M$_{ji}$il quale indica il contenuto del i$_{simo}$ bit relativo allaj$_{sima}$ parola.
L'operazione di trasferimento del bit M$_{ji}$ dalla memoria all'i$_{simo}$ bit del registro R è la stessa di quella di tabella 4.5.13, dove C$_{i-3}$ viene sostituito da M$_{ji}$
Le equazioni di input sono:
                $r_{it}=({\bar {M}}_{ji}R_{i}+M_{ji}{\bar {R}}_{i})(f_{0}+f_{1}+f_{4})p$
Le equazioni precedenti non sono complete in quanto contemplano solo il trasferimento del contenuto del bit M$_{ji}$ e non considerano la selezione della voce di indirizzo D$_j$Se il bit i$^{simo}$ della j$_{sima}$ parola in m3emoria viene selezionato mediante il comando D$_j$ (il quale può esseree uno qualsiasi dei 64 comandi di indirizzo) M$_{ji}$ e ${\bar {M}}_{ji}$ vengono sostituiti dalle equazioni seguenti:
                $\sum _{j=0}^{63}M_{ji}D_{j}=M_{0i}D_{0}+.....+M_{63i}D_{63}$
                $\sum _{j=0}^{63}{\bar {M}}_{ji}D_{j}=M_{0i}D_{0}+.....+M_{63i}D_{63}$
Per cui, le equazioni di input diventano:
          $r_{it}=[{\bar {R}}_{i}(\sum _{j=0}^{63}M_{ji}D_{j})+R_{i}(\sum _{j=0}^{63}{\bar {M}}_{ji}D_{j})](f_{0}+f_{1}+f_{4})p\ \ \ \ i=0,...,8$
In definitiva, le equazioni di input del registro R saranno:
          $r_{it}=[{\bar {R}}_{i}(\sum _{j=0}^{63}M_{ji}D_{j})+R_{i}(\sum _{j=0}^{63}{\bar {M}}_{ji}D_{j})](f_{0}+f_{1}+f_{4})p\ \ \ \ i=0,...,2$
          $r_{it}=[{\bar {R}}_{i}(\sum _{j=0}^{63}M_{ji}D_{j})+R_{i}(\sum _{j=0}^{63}{\bar {M}}_{ji}D_{j})](f_{0}+f_{1}+f_{4})p+(C_{i-3}\oplus R_{i})f_{10}\ \ \ \ i=3,...,8$
dove D$_j$ è dato dall'equazione (4.5.12).
In fig-4.5.14, cvompare il diagramma logico dello i$^{simo}$ stadio del registro R.

### Unità di memoria

La memoria nel nostro ipotetico calcolatore è costituita da un insieme di 576 flip-flop: essa deve poter eseguire le due operazioni seguenti:
                   $f_{3}:(A)\Rightarrow M<C>$
                   $mnuale\ :(Q_{ji}\Rightarrow M_{ji}$
La prima operazione memorizza il contenuto dell'accumulatore nella memoria con l'indirizzo selezionato da D$_j$ allo stato f$_3$:
                   $f_{3}D_{j}:(A_{i})\Rightarrow M_{ji}\ \ \ \ \ i=0,...,8$
Le equazioni di input saranno allora:
             $m_{jit}=(A_{i}\oplus M_{ji})f_{3}D_{j}p\ \ \ \ i=o,..,8\ \ \ \ j=0,...,63$
La seconda operazione consiste nell'inserire delle parole in memoria mediante gli interruttori Q
Se Q$_{ji}$ indica l'interruttore connesso al bit di memoria M$_{ji}$, l'operazione ha la tabella di verità affiancata.
La forma finale delle equazioni di input della unità di memoria è:
                $m_{ji}=(A_{i}\oplus M_{ji})f_{3}D_{j}p+(Q_{ji}\oplus M_{ji}p\ \ \ \ i=0,...,8\ \ \ \ j=o,...,63$
In fig-4.5.15 compare un diagramma logico abbreviato del registro di memoria.

### Start-stop Flip-Flop

La partenza e l'arresto del calcolatore vengono controllati mediante il flip-flop G, il quale viene a sua volta attivato dall'interruttore S mediante operazione manuale.
Le due operazioni richieste sono:
                $f_{5}C_{3}:0\Rightarrow G$
                $manuale:(S)\Rightarrow G$
La prima operazione cambia il Flip-Flop G nello stato 0 quando compare lo stato f_5 e C_3 è 1; le equazioni di input sono quindi:
                      $g_{t}=Gf_{5}C_{3}p$
La seconda operazione mette in ON od in OFF l'interruttore S per permettere l'avvio o l'arresto della macchina.
L'equazione di input è:
                      $g_{t}=Gf_{5}C_{3}p+(S\oplus G9p$

## Un calcolatore completo

Nei paragrafi precedenti abbiamo stabilito le equazioni di input di tutti i registri del nostro ipotetico calcolatore.
La configurazione del calcolatore dato in fig-4.3.1 può essere ora completata dando le equazioni simboliche relative ai singoli registri (fig. 4.6.1).
Questo diagramma può essere reso più dettagliato usando i diagrammi logici stabiliti nei precedenti paragrafi.
La procedura operativa del nostro calcolatore sarà la seguente:
* Accensione del calcolatore. Se il Flip-Flop di avvio-arresto si trova nello stato 1 durante questo periodo, il calcolatore funzioneera in maniera irregolare.
* Si mette lo switch S nella posizione off. Questo implica che lo start-stop Flip-Flop sia nello stato 0, lo operation counter in 1111 e l'indirizzo contenuto nel memory address register uguale a 000000. Si inserisce il programma in memoria mediante gli interruttori Q.
* Si mette lo switch S nella posizione ON. Il Flip-Flop Gassume lo stati 1 e la macchina comincia ad esguire il programma. La prima istruzione si trova nella memoria di indirizzo 000000.
* Il programma deve terminare con una istruzione di stop: questa ultima inserisce 0 in G, 1111 in F e 000000 in C. Un nuovo programma può essere inserito nella memoria ed il calcolatore può iniziare il calcolo rimettendo lo switch nella posizione ON.
* Si leggono i risultati ottenuti mediante dispositivi luminosi connessi ai flip-flop di memoria (non mostrati nei diagrammi precedenti).