Algebre booleane e progetto logico dei calcolatori digitali/Progetto logico di un calcolatore digitale: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
ortografia |
wikifico |
||
Riga 1:
{{Algebre
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'''.<bra sua volta, />
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, innanzi tutto, 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 copleto 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: innanzi tutto 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.
=== Formatto della parola ===
Una parola (o voce) in un calcolatore è un insieme ordinato di digits che viene trattato dal calcolatre come una unità unitaria.
Si dice che il calcolatore ha una struttura a parole (a voci) se un da e che questa sia piccola.to 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:
::::::<math>x=x_o x_1 x_2 x_3 x_4 x_5 x_6 x_7 x_8</math
Una parola viene trattata dalla 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 furi dell'intervallo sopra indicato può essere rappresentato nel calcolatore moltiplicandolo per '''2<sup>n</sup>''', con un appropriato valore di '''n'''.
La moltiplicazione per '''2<sup>n</sup>''' 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.
[[File:Formato istruzioni.png|right]]
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: perr 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 ===
[[File:Configurazione di un semplice calcolatore digitale.png|right]]
[[File:Memory resgister.png|right|right]]
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 cin 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<sub>(ji)</sub>''', dove '''j''' indica la '''J<sup>(sima)</sup>''' parola ed '''i''' il '''bit<sup>(simo)</sup>.
ene messo tra il registr '''C'''
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 '''Flipo-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)
[[File:Registri di un calcolatore digitale semplice.png|right]]
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<sub>0</sub> R<sub>1</sub> R<sub>2</sub>''' memorizzano il codice operativo, mentre i 6 bits da '''R<sub>3</sub>''' a '''R<sub>9</sub>''' 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<sub>2</sub> F<sub>3</sub> F<sub>4</sub>''', 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 impilsi temporsali 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 Flipo-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 switchs '''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 ipoteticosno raggruppate in tabella 4.3.3 seguente
{|
|-
!
|-
|
|-
|
|-
|
|-
|
|-
|
|-
|
|-
|
|-
|
|-
|
|}
Poiché la macchina non o0mpie 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 effett nove operazioni.
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<sub>7</sub>'''.
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<sub>3</sub>''' e '''A<sub>4</sub>'''.
La parte codice operativo della istruzione che si trova ora nel registro '''R''' viene trasferita al registro '''F''' tramite la porta '''A<sub>8</sub>''' sotto il controllo del segnale '''i''', mentre il segnale di controllo '''c''' trasferisce la parte indirizzo tramite la porta '''A<sub>1</sub>''' 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<sub>3</sub>''' e '''A<sub>4</sub>''', un numero dalla memoria al registro '''R''', ed il segnale di controllo '''g''' determina, mediante la porta '''A<sub>9</sub>''', 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<sub>6</sub>''', conserva mediante la porta '''A<sub>5</sub>''', il controllo dellaccumulatore 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 II<sup>a</sup>, 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
{|
|-
!
!! Operazioni richieste............... !! Operazioni ausiliarie
|-
|
|-
|
|-
|
|-
|
|-
| Trasferimento incondizionato (100uvwxyz) ||
|-
|
|-
| Test Shift left (1010100yz ||
|-
| Azzeramento accumulatore (1010010yz ||
|-
| Stop (10010001yz) || 0=>G ;0=>C ; 1=>F || nessuna
Line 155 ⟶ 232:
|-
| Comando inserimento dati (manuale) || (Q<sub>ij)</sub>=>M<sub>ij</sub> || 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.
:::::<math>(M<C>)\Rightarrow R</math>
dove '''C''' contiene l'indirizzo di memoria '''uvwxyz.
La seconda operzione è: ''addizionare il contenuto del registro '''R''' al contenuto del registro '''A''', e conserva il risultato nel registro '''A'''.
Simbolicamente si ha:
:::::<math>(R)+(A)\Rightarrow A</math>
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:
:::::<math>(A)\Rightarrow M<C></math>
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:
:::::<math>(A_{i-1})\Rightarrow A_i\ \ \ \ \ dove\ i=1,....,8</math>
:::::<math>(A_0)\Rightarrow A_0</math>
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:
:::::<math>(A_{i+1})\Rightarrow A_i\ \ \ \ \ dove\ i=1,....,7</math>
:::::<math>(A_0)\Rightarrow A_8</math>
Questa operazione di '''shift''' a sinistra muove il bit più a sinistra del registro '''A''' in maniera circolare.
L'azzeramento dell'accumulatore diventa:
:::::<math>0\Rightarrow A</math>
L'istruzione di '''stop''' consiste nell'arrestare la macchina e porre nel registro '''C''' il primo indirizzo '''000000'''; simbolicamente:
:::::<math>0\Rightarrow G\ \ \ \ \ e\ \ \ \ \ 0\Rightarrow C</math>
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:
:::::<math>1\Rightarrow G\ \ \ \ \ e\ \ \ \ \ (Q_{ji})\Rightarrow M_{ji}</math>
La prima espressione indica il set del Flip-Flop '''G''' mentre la seconda indica l'inserimento del contrnuto dell'interruttore '''Q<sub>ji</sub>''' nel bit di memoria '''M<sub>ji</sub>'''
=== 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.
[[File:Tabella 4.4.2.png|right]]
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:
:::::<math>(M<C>)\Rightarrow R</math>
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''':
:::::<math>Op[R]\Rightarrow I[F]</math>
:::::<math>Ad[R]\Rightarrow C</math>
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 cosi 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''':
:::::<math>(C)\Rightarrow Ad[R]</math>
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.
[[File:Operazioni durante cicli di istruzione e di esecuzione.png|right]]
Questo indirizzo della istruzione che è stato preso in considerazione deve essere conservato in qualche maniera in quanto l'indirizzo della nuova istruzione è ottnuto 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 '''R'''precedentemente descritta.
Le operazioni che avvengono durante il '''ciclo istruzioni''' sono sempre le stesse, mentre quelle che compaioni 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: esoo 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:
:::::<math>(M<C>)\Rightarrow R</math>
Durante l'operazione di caricamento dell'operando, il contenuto della parte indirizzo di '''R''' che alro non è se non l'indirizzo della attuale istruzione, viene trasferito in '''C''':
:::::<math>Ad[R]Rightarrow C</math>
L'operando ora contenuto in '''R'' viene addizionato al contenuto del registro '''<a''' (che è un accumulatore):
:::::<math>(R)+(A)\Rightarrow A</math>
Infine, il contenuto del registro '''C''' (contenente l'indirizzo della attuale istruzione) viene incrementato di '''1''' diventando cosi l'indirizzo della nuova istruzione:
:::::<math>(C)+1\Rightarrow C</math>
Cosi 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 proce de come nel caso del trasferimento incondizionato, se la condizione è verificata '''(A<sub>0</sub>=1)'''; se la condizione non è verificata (A<sub>0</sub>=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'[[w:control unit|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<sub>1</sub>,F<sub>2</sub>,F<sub>3</sub>,F<sub>4</sub>'''.
I Flip-Flop '''f<sub>2</sub>''' e '''f<sub>4</sub>''' 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 cob quattro flip-flop, si possono presentare 16 stati; essi vengono indicati con la notazione '''f<sub>i</sub>''' 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.
:::::<math>(tavola\ 4.4.4)\ \ Stati\ dello\ operation\ counter</math>
Line 276 ⟶ 422:
|}
Poiché sono sufficienti 14 stati, i comandi '''f<sub>6</sub>''' e '''f<sub>7</sub>''' non vengono usati. Gli stati '''f<sub>4</sub>''' e '''f<sub>10</sub>'''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<sub>10</sub>''' a '''f<sub>4</sub>'''; 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<sub>0</sub>, f<sub>1</sub>, f<sub>2</sub>, f<sub>3</sub>, f<sub>4</sub>, f<sub>5</sub>''' sono relativi a comandi di istruzioni e questa scelta fa si che il Flip-Flop '''F<sub>1</sub>''' sia uguale a '''0''' per tutti i comandi di istruzione, semplificando cosi 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ò costrure la figura 4.4.5 detta anche diagramma di stato in cui compaiono gli stati del calcolatoredopo 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<sub>4</sub>''', mentre le altre tre operzioni relative al ciclo-istruzione avvengono allo stato '''f<sub>10</sub>'''.
La sequenza interna dedl ciclo esecutivodipende dal contenuto dei Flip-Flop '''R<sub>0</sub>, R<sub>1</sub>, R<sub>2</sub>'''.
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 quando'''R<sub>0</sub>R<sub>1</sub>R<sub>2</sub>''' è 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<sub>0</sub>, f<sub>1</sub>, f<sub>2</sub>, f<sub>3</sub> e f<sub>5</sub> mentre non è necessaria se l'istruzione appena eseguita è un trasferimento incondizionato.
L'operazione di incremento di '''1''' avviene durante lo stato '''f<sub>11</sub>'''.
L'operazione di prendere dalla memoria l'operando avviene durante gli stati '''f<sub>0</sub>''' e '''f<sub>1</sub>''' mentre le operazioni di addizione e di sottrazione vengono eseguite agli stati '''f<sub>8</sub>''' e '''f<sub>9</sub>''' rispettivamente.
Allo stato '''f<sub>15</sub>''', 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<sub>15</sub>''' a causa dell'operazione '''1=>F''':
Perciò, sotto il comando di stop il calcolatore non si arresta ma viene sospesa solo la sequenza operativa.<br/
Quando lo switch ''S''' viene messo nello stato '''off'''
A questo punto, l'operation counter assume lo stato '''f<sub>15</sub>''' 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 stato'''f<sub>4</sub>
Poiché il contenuto del registro '''C''' era stato cambiato in '''000000''', il calcolatore comincia dall'istruzione contenuta nella prima posizione di memoria.
[[File:State-operation diagram of the simple digital computer..png|center]]
== 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'''.
Cambia inoltre quando '''f<sub>10</sub>''' (1010) diventa '''f<sub>0</sub>''' (0000), con '''R<sub>0</sub>,R<sub>1</sub>,R<sub>2</sub>''' (000).
In breve lo stato del Flip-Flop '''F<sub>1</sub>''' cambia quando si presenta una delle sei seguenti condizioni.
::<math>f_10\bar R_0\bar R_1\bar R_2+f_10\bar R_0\bar R_1 R_2+f_10\bar R_0R_1\bar R_2+f_10\bar R_1R_2+f_10R_0|bar R_1R_2+f_10R_0\bar R_1|bar R_2=f_10</math>
Le altre condzioni che detertminano il cambiamento dello stato di '''F<sub>1</sub>''' 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<sub>1</sub>, F<sub>2</sub>, F<sub>3</sub>, F<sub>4</sub>'''.
::<math>f_{1t}=[f_4+f_{10}+f_0+f_1f_2\bar A_0+f_3+f_5(C_0+C_1+C_2+C_3)+f_{11}+f_{15}G]p</math>
::<math>f_{2t}=[f_4G+f_{10}R_0+f_2A_0+f_{11}+f{12}+f_{13}+f_{14}]p</math>
::<math>f_{3t}=[f_4+f_{10}\bar R_1+f_2A_0+f_5(C_2+C_3)+f_8+f_9+f_{11}+f_{12}+f_{13}+f_{15}G]p</math>
::<math>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</math>
[[File:Valori assunti da Flip-Flop.png|right]]
Quando il contatore si trova nello stato '''f<sub>15</sub>''' ed 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<sub>i</sub>''' durante tale operazione.
Le equazioni di input dei Flip-Flop '''F''' in tale caso saranno:
:::::<math>f_{it}=\bar F_i G f_{15} p\ \ \ \ \ i=1,...4\ \ (4.5.3</math>
Poiché '''f<sub>15</sub>''' è '''F<sub>1</sub>F<sub>2</sub>F<sub>3</sub>F<sub>4</sub>'''=1111, negF<sub>i</sub> f<sub>15</sub> 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).
[[File:Diagrazmma logico dell'operatio counter e decoder.png|center]]
=== Accumulatore ===
Come mostrato nel diagramma 4.4.5, l'accumulatore interviene durante l'esecuzione delle operazioni relative agli stati:
:::::<math>f_8 : [R]+(A)\Rightarrow A</math>
:::::<math>f_9 : (A)-(R)\Rightarrow A</math>
:::::<math>f_{12}:(A_0)\Rightarrow A_0\ \ \ \ (A_{i-1})\Rightarrow A_i\ \ \ \ i=1,...,8</math>
:::::<math>f_{13}:(A_0)\Rightarrow A_8\ \ \ \ (A_{i+1})\Rightarrow A_i\ \ \ \ i=0,...,7</math>
:::::<math>f_{14}:=\Rightarrow A</math>
Durante l'operazione di addizione relativa allo stato '''f<sub>8</sub>,A<sub>i</sub>''' e '''R<sub>i</sub>''' sono gli '''i<sup>simi</sup>''' bits degli addendi.
'''K<sub>i</sub>''' è il riporto dovuto alla somma fatta sugli (i+1)<sup>simi</sup> bits.
L'operazione di somma viene mostrata in tabella 4.5.5.
::<math> Tabella\ 4.5.5</math>
{| class="wikitable" style ="text-align:center"
Line 361 ⟶ 554:
|}
Da tale tabella, si ricavano le seguenti equazioni di input:
:::::<math>Q_{it}=(R\oplus K_i)f_8p\ \ \ \ i=0,...,8\ \ \ \ \ (4.5.6)</math>
mentre per il riporto si ha:br/>
:::::<math>K_{i-1}=(R_iK_i+R_iA_i+A_iK_i)f_8P\ \ \ \ i=1,....,8</math
:::::<math>K_8=0</math>
Per l'operazione di sottrazione relativa allo stato '''f<sub>9</sub>''', A<sub>i</sub> e R<sub>i</sub> sono rispettivamente l'i<sup>simo</sup> bit del minuendo e dell'i<sup>simo</sup> bit del sottraendo.
Le equazioni di input del riporto sono le stesse di (4.5.6) ad eccezione di '''R<sub>i</sub>''' che viene sostituito da <math>\bar R_i</math> e '''K<sub>8</sub>''' viene sostituito da '''1'''in modo da sostituire il contenuto di '''R''' con il suo complemento a 2.
Le equazioni di input e del riporto sono quindi:
::::<math>a_{it}=(\bar R_i\oplus K_i)f_9 p\ \ \ \ \ i=0,....,8\ \ \ (4.5.7)</math>
::::<math>K_{i-1}=\bar R_iK_i+\bar R_iA_i+A_iK_i)f_9 p\ \ \ \ i=1,..,8</math>
::::<math>K_8=f_9 p</math>
[[File:Operazione di scorrimento a destra.png|right]]
L'operazione di scorrimento a destra avviene allo stato '''f<sub>12</sub>'''.
Esso fa scorrere il contenuto dell'accumulatore di un bit a destra mentre lo stato di '''A<sub>0</sub>''' rimane inalterato.
La tabella (4.5.8) rappresenta l'operazione di scorrimento a destra.
Le equazioni di input sono:
:::::<math>a_{it}=(A_{i-1}\oplus A_i f_{12} p\ \ \ \ i=1,...,8</math>
Non vi è alcuna equazione per '''a<sub>0t</sub>''' in quanto lo stato del Flip-Flop '''A<sub>0</sub>''' non deve cambiare.
L'operazione di scorrimento a sinistra avvierne allo stato '''f<sub>13</sub>'''.
Essa fa scorrere il contenuto dell'accumulatore di un bit verso sinistra mentre lo stao di '''A<sub>8</sub>'''viene sostituito da quello di '''A<sub>0</sub>'''.
[[File:Azzeramento dellaaccumulatore.png|right]]
Le equazioni di input saranno:
:::::<math>a_{it}=(A_i\oplus A_{i+1} f_{13} p\ \ \ \ i=0,...,7</math>
:::::<math>a_{8t}=(A_0\oplus A_8 f_{13} p</math>
L'operazione di azzeramento dell'accumulatore avviene allo stato '''f<sub>14</sub>''' (tabella 4.5.9):
Le equazioni di input sono:
:::::<math>a_{it}=A_if_{14} p\ \ \ \ i=0,...,8</math>
quindi le equazioni di input dei Flip-Flop che costituiscono l'accumulatore '''A''' saranno:
::<math>a_{it}=(R_ip\oplus K_i)f_8p+(\bar R_i\oplus K_i)f_9p+(A_{i-1}\oplus A_i)f_{12}p+(A_i\oplus A_{i+1}f_{13}p+A_if_{14}p\ \ \ \ \ i=1,...,7</math>
::math>a_{0t}=(A_0\oplus K_0)f_8p+(\bar R_0\oplus K_0)f_9p+(A_0\oplus A_1)f_{13}p+a_0f_{14}p</math>
::math>a_{8t}=(A_8\oplus K_8)f_8p+(\bar R_8\oplus K_8)f_9p+(A_7\oplus A_8)f_{12}p+(A_0\oplus A_8)f_{13}p+a_8f_{14}p</math>
::<math>K_{i-1}=(R_iK_i+R_iA_i+A_iK_i)f_8p+(\bar R_iK_i+|bar R_iA_i+A_iK_i)f_9p</math>
i=1,...,8
::<math>K_8=f_9p</math>
Il diagramma logico dell'i<sup>simo</sup> stadio dell'accumulatore viene presentato in fig.4.5.10
[[File:Diagramma logico di uno stadio dell'accumulatore.png|center]]
=== Memory address register ===
Nel diagramma di stato di fig-4.4.5, il registro '''C''' deve permettere le seguenti operazioni:
::<math>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</math>
La tabella della verità relativa alla operazione (Ad[R]=>C è quella posta a fianco.
Le equazioni di input da tale tavola sono:
:::::<math>C_{it}=(R_{i+3}\oplus C_i)gp\ \ \ \ i=0,...,5</math>
:::::<math>g=f_{10}+ f_0+f_1+f_2\bar A_0+f_3+f_5</math>
L'operazione '''(C)+1=>C''' avviene allo stato '''f<sub>11</sub>''': durante questa operazione, il registro '''C''' funziona come un contatore binario.
Le equazioni di input saranno quindi:
::::<math>C_{5t}=f_{11}p</math>
::::<math>C_{4t}=C_5f_{11}p=C_5c{5t}</math>
::::<math>C_{3t}=C_4C_5f_{11}p=C_4c_{4t}</math>
::::<math>C_{2t}=C_3C_4C_5f_{11}p=C_3c_{3t}</math>
::::<math>C_{1t}=C_2C_3C_4C_5f_{11}p=C_2c_{2t}</math>
::::<math>C_{0t}=C_1C_2C_3C_4C_5f_{11}p=C_1c{1t}</math>
La terza operazione, quella inerente all'azzeramento del registro '''C''', viene eseguita allo stato '''<math>f_{15}\bar G</math>'''
La tavola della Verità corrispondente è uguale a quella di Fig-4.5.9.<BR/>
Le equazioni di input sono:
:::::<math>c_{it}=C_1f_{15}\bar Gp</math>
In definitiva, le equazioni di input dei Flip-Flop relativi al memory-address register sono:
::::<math>c_{0t}=C_1C_2C_3C_4C_5f_{11}p+(R_3\oplus C_0)gp+C_0f_{15}\bar G p</math>
::::<math>c_{1t}=C_2C_3C_4C_5f_{11}p+(R_4\oplus C_1)gp+C_1f_{15}\bar G p</math>
::::<math>c_{2t}=C_3C_4C_5f_{11}p+(R_5\oplus C_2)gp+C_2f_{15}\bar G p</math>
::::<math>c_{3t}=C_4C_5f_{11}p+(R_6\oplus C_3)gp+C_3f_{15}\bar G p</math>
::::<math>c_{4t}=C_5f_{11}p+(R_7\oplus C_4)gp+C_4f_{15}\bar G p</math>
::::<math>c_{5t}=f_{11}p+(R_8\oplus C_5)gp+C_5f_{15}\bar G p</math>
dove <math>g=f_{10}+f_0+f_1+f_2\bar A_0+f_3+f_5</math>
In fig-4.5.11 compare un diagramma logico relativo al memory-address register.<br/ In questa figura è indicat anche l'address decoder, che non è altro che una matrice con 6 coppie di input e 64 output.
Gli output '''D<sub>j</sub>''' (j<sup>sima</sup> parola) del decodificatore sono rappresentati come:
:::::<math>D_0=\bar C_0 \bar C_1 \bar C_2 \bar C_3 \bar C_4 \bar C_5</math>
:::::<math>D_1=\bar C_0 \bar C_1 \bar C_2 \bar C_3 \bar C_4 C_5</math>
:::::<math>..................</math>
:::::<math>D_{63}=C_0C_1C_2C_3C_4C_5\ \ \ \ \ \ \ \ (4.5.12)</math>
[[File:Logic diagrtam of the memory-address register.png|center]]
=== 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:
::::::<math>f_{10}:(C)\Rightarrow Ad[R]</math>
::::::<math>f_0,f_1,f_4:(M<C>)\Rightarrow R</math>
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:
:::::<math>r_{it}=(C_{i-3}\oplus R_i)f_{10}p\ \ \ \ \ i=3,...,8</math>
La seconda operazione prende una parola dalla memoria il cui indirizzo è dato dal contenuto del registro '''C'''e la conserva nel registro '''R'''.
L'indirizzo contenuto viene indicato con la notazione '''D<sub>j</sub>''', dove '''J''' specifica la '''j<sup>sima</sup>''' parola.
Nella memoria del nostro ipotetico calcolatore vi sono 576 bits conservati in 64 parole; essi vengono espressi con il simbolo '''M<sub>ji</sub>'''il quale indica il contenuto del '''i<sub>simo</sub>''' bit relativo alla'''j<sub>sima</sub>''' parola.
L'operazione di trasferimento del bit '''M<sub>ji</sub>''' dalla memoria all'i<sub>simo</sub> bit del registro '''R'''è la stesssa di quella di tabella 4.5.13, dove '''C<sub>i-3</sub>''' viene sostituito da '''M<sub>ji</sub>'''
Le equazioni di input sono:
:::::<math>r_{it}=(\bar M_{ji}R_i+M_{ji}\bar R_i)(f_0+f_1+f_4)p</math>
Le equazioni precedenti non sono complete in quanto contemplano solo il trasferimento del contenuto del bit '''M<sub>ji</sub>''' e non considerano la selezione della voce di indirizzo '''D<sub>j</sub>'''Se il bit '''i<sup>simo</sup>''' della '''j<sub>sima</sub>''' parola in m3emoria viene selezionato mediante il comando '''D<sub>j</sub>''' (il quale può esseree uno qualsiasi dei 64 comandi di indirizzo) '''M<sub>ji</sub>''' e <math>\bar M_{ji}</math> vengono sostituiti dalle equazioni seguenti:
:::::<math>\sum_{j=0}^{63} M_{ji} D_j=M_{0i}D_0+.....+M_{63i}D_{63}</math>
:::::<math>\sum_{j=0}^{63} \bar M_{ji} D_j=M_{0i}D_0+.....+M_{63i}D_{63}</math>
Per cui, le equazioni di input diventano:
:::<math>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</math>
In definitiva, le equazioni di input del registro '''R''' saranno:
:::<math>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</math>
:::<math>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</math>
dove '''D<sub>j</sub>''' è dato dall'equazione (4.5.12).
In fig-4.5.14, cvompare il diagramma logico dello '''i<sup>simo</sup>''' stadio del registro '''R'''.
[[File:Diagramma logico dello i-esimo stadio dello instruction register.png|center]]
=== 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:
::::::<math>f_3:(A)\Rightarrow M<C></math>
::::::<math>mnuale\ :(Q_{ji}\Rightarrow M_{ji}</math
La prima operazione memorizza il contenuto dell'accumulatore nella memoria con l'indirizzo selezionato da '''D<sub>j</sub>''' allo stato '''f<sub>3</sub>''':
::::::<math>
Le equazioni di input saranno allora:
::::<math>m_{jit}=(A_i\oplus M_{ji})f_3D_j p\ \ \ \ i=o,..,8\ \ \ \ j=0,...,63</math>
[[File:Operazione di input.png|right]]
La seconda operazione consiste nell'inserire delle parole in memoria mediante gli interruttori '''Q'''
Se '''Q<sub>ji</sub>''' indica l'interruttore connesso al bit di memoria '''M<sub>ji</sub>''', l'operazione ha la tabella di verità affiancata.
La forma finale delle equazioni di input della unità di memoria è:
:::::<math>m_{ji}=(A_i\oplus M_{ji})f_3D_jp+(Q_{ji}\oplus M_{ji}p\ \ \ \ i=0,...,8\ \ \ \ j=o,...,63</math>
In fig-4.5.15 compare un diagramma logico abbreviato del registro di memoria.
[[File:Diagramma logico abbreviato del registro di memoria.png|center]]
=== 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:
:::::<math>f_5C_3:0\Rightarrow G</math>
:::::<math>manuale:(S)\Rightarrow G</math>
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:
:::::::<math>g_t=Gf_5C_3p</math>
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 è:
:::::::<math>g_t=Gf_5C_3p+(S\oplus G9p</math>
[[File:Figure 4.5.16.png|center]]
== 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:
* -1 Accensione del calcolatore. Se il Flip-Flop di avvio-arresto si trova nello stato '''1''' durante questo periodo, il calcolatore funzioneera in maniera irregolare.
* -2 Si mette lo switch '''S''' nella posizione '''off'''.<br />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'''.<br />Si inserisce il programma in memoria mediante gli interruttori '''Q'''.
* -3 Si mette lo switch '''S''' nella posizione '''ON'''.<br />Il Flip-Flop '''G'''assume lo stati '''1''' e la macchina comincia ad esguire il programma. La prima istruzione si trova nella memoria di indirizzo '''000000'''.
* -4 Il programma deve terminare con una istruzione di stop: questa ultima inserisce '''0''' in '''G''', '''1111''' in '''F''' e '''000000''' in '''C'''.<br />Un nuovo programma può essere inserito nella memoria ed il calcolatore può iniziare il calcolo rimettendo lo switch nella posizione '''ON'''.
* -5 Si leggono i risultati ottenuti mediante dispositivi luminosi connessi ai Flip-Flop di memoria (non mostrati nei diagrammi precedenti).
[[File:Operazioni in un calcolatore digitale semplificato.png|center]]
[[Categoria:Algebre
{{Avanzamento|75%|6 novembre 2016}}
| |||