Progettare un semplice ALU

Devo progettare un ALU con due ingressi A e B a 8 bit e controllare gli ingressi x, ye z che supportano le seguenti operazioni:

x  y  z  |  operation

0  0  0  |  S = A-B
0  0  1  |  S = A+B
0  1  0  |  S = A*8
0  1  1  |  S = A/8
1  0  0  | S = A NAND B (bitwise)
1  0  1  | S = A XOR B (bitwise)
1  1  0  | s = reverse the bits of A
1  1  1  | S = NOT A (bitwise)

Questo dovrebbe essere fatto con un sommatore a 8 bit e un extender di logica aritmetica. Leggendo il mio libro di testo, vedo che lo scopo di un AL-extender è quello di modificare i bit di input in modo che un sommatore, piuttosto che un sacco di componenti extra, possa essere usato per fare tutto (o almeno questo è quello che ho capito da esso ). Ad esempio, l'AL-extender potrebbe inserire i bit nel complemento a due in modo che l'adder esegua una sottrazione. Allo stesso modo, per le operazioni logiche bit a bit, i bit potrebbero essere modificati in modo appropriato e uno degli input del sommatore potrebbe essere solo zero in modo che il risultato arrivi correttamente.

Ma cosa faccio esattamente riguardo alla moltiplicazione? Il mio libro è molto vago, quindi non sono sicuro se un extender AL mi richiederebbe di fare qualcosa di intelligente per fare in modo che l'adder faccia il lavoro (basta aggiungere 8 volte nel mio caso? ... ah ah), o se io può semplicemente lanciare un moltiplicatore lì dentro. Dovrò leggere sulla divisione, ma scommetto che è simile alla moltiplicazione.

Bene, comunque, la linea di fondo è ancora, che cosa è "permesso" che un extender AL possa / possa avere in esso? Il suo unico scopo è modificare l'input in modo che possa essere inviato a un sommatore?

* EDIT: Beh, è ​​una moltiplicazione / divisione per 8, quindi questo può essere facilmente eseguito spostando a sinistra oa destra per 3. Avrei ancora un AL / extender reale / corretto se aggiungessi alcuni comandi? (Forse sto pensando troppo a un principiante assoluto ...)

L'approccio più semplice sarebbe quello di decodificare gli ingressi xyz in otto righe. Quindi da questi, si implementa la logica che guida le linee di selezione dei chip per abilitare l'unità appropriata che gestisce gli ingressi, nonché eventuali trasformazioni necessarie affinché l'unità esegua il corretto funzionamento.

Non penso che tu possa usare un sommatore per le tue operazioni logiche perché il sommatore trasporta (a meno che non abbia qualche input che disabilita il comportamento della propagazione del riporto). Ma puoi avere una singola unità per fare tutta la logica.

Forse c'è un motivo per cui chiamano questi ALU, con A e L. separate :)

La moltiplicazione per 8 significa solo guidare gli zeri sulle tre linee di input più basse, ignorare le tre linee superiori e mappare la linea da 0 a linea 3, da 1 a 4 e così via. È come un interruttore ferroviario.

(Cheat)
La soluzione più semplice ma più potente è utilizzare una memoria Flash come tabella di ricerca per i risultati. Ingresso A 8 bit + Ingresso B 8 bit + Il codice operativo 3 bit è 19 bit. Scegli un 512 k$\times$Flash a 16 bit (circa $ 2), utilizzare le 19 linee di input come indirizzo e programmarlo con i risultati per ciascuna combinazione di input. In questo modo puoi eseguire qualsiasi operazione tu voglia. Vuoi il peccato (A)? Basta aggiungere una tabella di ricerca sinusoidale di 256 parole, puoi anche avere un risultato preciso a 16 bit. Non sei limitato alla moltiplicazione per 8; puoi moltiplicare A per B. Come saggio, puoi dividere A per B e ottenere un quoziente di 8 bit e un resto di 8 bit. Per la moltiplicazione e la divisione utilizzerai tutti i bit in un blocco di 64 kword, ma ad esempio l'inversione dei bit ne fa un uso meno efficiente: non dipende dal valore di B, quindi avrai 256 valori identici per ogni ingresso A e il byte di ordine superiore non verrebbe nemmeno utilizzato. Quindi, mentre hai solo bisogno di 256$\times$ 8 = 2048 bit per l'inversione dei bit che useresti 65536 $\times$16 = 1048576 bit; non è molto efficiente. Potresti definirlo un grave svantaggio della soluzione Flash, ma vorrei vederti implementare un 8$\times$ 8 moltiplicatore utilizzando porte logiche di base per $ 2.

OK, forse non lo vuoi; le porte logiche sono molto più impegnative. Come dice Kaz , inizia con un decodificatore da 3 a 8 per avere un segnale univoco per ogni codice operativo. Puoi farlo con cancelli di base, ma per iniziare suggerirei di usare un 74HC238. Quando l'ALU funziona è ancora possibile sostituire l'HC238 con una raccolta di porte.

Ciò che non si desidera per il moltiplicatore è un registro a scorrimento che si sposta a sinistra 3 volte. Questa è una funzione registrata che ha bisogno di un orologio, invece di una funzione combinatoria che produce immediatamente il risultato. (Notare che Flash produce anche qualsiasi risultato in nanosecondi, sebbene più lento rispetto alla logica combinatoria.) Avere un percorso da A0 a Y3, da A1 a Y4, ecc., Che si abilita con il codice operativo decodificato "010". Allo stesso modo, Y3 sarà collegato ad A6 se il segnale "011" è attivo (divisione), e ad A4 quando l'opcoe è "110" (inversione di bit). Ciò significa molto multiplexing.

Per tornare a Flash, puoi anche creare una combinazione di logica combinatoria per operazioni semplici, come NAND, NOR, spostamento a sinistra, spostamento a destra$^{(*)}$e usa Flash solo per la moltiplicazione e la divisione. Potresti usare un Flash più piccolo (128 kword anziché 512 kword) o aggiungere funzioni più avanzate, come il seno che ho dato come esempio (forse non il migliore, ma sono sicuro che puoi pensare a qualcosa).

$^{(*)}$Come mai hai una moltiplicazione per 8, ma non lo spostamento di base più a sinistra? Spostare sinistra / destra, ruotare sinistra / destra (sia tramite carry che non) sono indispensabili per qualsiasi ALU, e puoi dividere per 8 usando 3 diritti di spostamento, mentre non puoi dividere per 2. L'inversione dei bit è un tipico DSP funzione, ma non vuoi costruire un DSP per cominciare, vero? Vorrei cambiare le funzioni in

x  y  z  |  operation

0  0  0  |  S = A - B
0  0  1  |  S = A + B
0  1  0  |  S = shift left A by 1 bit
0  1  1  |  S = shift right A by 1 bit
1  0  0  |  S = A NAND B (bitwise)
1  0  1  |  S = A XOR B (bitwise)
1  1  0  |  S = rotate left A
1  1  1  |  S = NOT A (bitwise)

Mi sono bloccato sullo stesso problema dallo stesso libro. Fortunatamente mi sono imbattuto in questo thread che mi ha dato un'idea di cosa fare. Kaz ha un ottimo punto sulla guida di zeri e linee di mappatura. L'extender ALU in questo libro è progettato con n (n che rappresenta il numero di bit su cui operare) componenti combinatori identici ma separati e un componente diverso per il carry in. Questi componenti hanno cinque ingressi e due uscite. I cinque ingressi sono: 'X', 'Y', 'Z' (per selezionare l'operazione) e 'a', 'b' (singoli bit di A e B con lo stesso significato). Immagino che l'idea qui sia quella di dividere il problema in blocchi più piccoli per avere una tabella di verità di dimensioni ragionevoli. Cioè 5 ingressi contro 8 + 8 + 3 = 19 ingressi se l'extender accetterebbe tutti i bit dagli ingressi di controllo A e B plus. Adesso, se l'extender fosse composto in questo modo (19 input) penso che la logica della moltiplicazione potrebbe essere implementata in quel singolo componente, ma scrivere una tabella di verità per questo sarebbe fuori discussione. Quindi, comunque, la mia soluzione è usare i mux dopo ogni componente che gestisce i singoli bit aeb assumendo che il componente sia già progettato in modo tale che un input XYZ = 010 passi 'un' bit invariato e filtra 'b', ovvero 'b' = 0. Il mux dovrebbe avere due input, uno dal componente sopra e uno dal componente tre posti a destra. Tre mux più a destra dovrebbero avere zeri come secondo input. Una semplice logica combinatoria con una porta AND e due inverter può impostare i mux quando XYZ = 010.