Decoder Struttura generale del decoder

Presentazione sul tema: "Decoder Struttura generale del decoder"— Transcript della presentazione:

1 Decoder Struttura generale del decoder
Circuito che converte un codice di input a nbit in un codice di output a m bit. Struttura generale del decoder Tipicamente n input, m=2n outputs 2-to-4, 3-to-8, 4-to-16, etc.

2

3 Decoder binari Circuito da-n-a-2n
Codice 1-fra-m:contiene m bit con un solo bit asserito ad ogni istante Decoder da-2-a-4: Si noti la notazione “x” (don’t care)

4

5 Diagramma logico del decoder da-2-a-4 con enable

6 Decoder da-2-a-4 in logica negativa
Buffer di input (meno carico) gate NAND (più veloci)

7 Decoder da-3-a-8 y0 = a’b’c’ y1 = a’b’c 3-to-8 Line y2 = a’bc’ Decoder

8 Decoder da-3-a-8 con codice di input Gray
Il codice di input non rappresenta necessariamente gli interi da 0 a 2n-1. Supponiamo che il codice di input sia il codice Gray di un disco di codifica meccanica con otto posizioni. Posizione del disco I2 I1 I0 output del decoder binario 0o Y0 45o Y1 90o Y3 135o Y2 180o Y6 225o Y7 270o Y5 315o Y4 3-to-8 Line Decoder DEG0 DEG45 DEG135 DEG90 DEG315 DEG270 DEG180 DEG225 a b c

9 Decoder da-3-a-8 74x138

10 Decoder da-2-a-4 controllato da un contatore a 2 bit

11

12

13 Applicazioni dei decoder
Memoria dei microprocessori Selezione di diversi banchi di memoria Sistemi di input/output di microprocessori Selezione di diversi dispositivi Decodifica di istruzioni di microprocessori Abilitazione di diverse unità funzionali Chips di memoria Abilitazione di diverse righe di memoria a seconda dell’indirizzo Moltissime altre applicazioni

14 Decoder in verilog

15 multiplexing Multiplexing nella forma più semplice: un tasto (switch) meccanico capace di selezionare fra diverse sorgenti Sorgenti: 4 microfoni che inviano a una stazione remota di ascolto della polizia segrenta Una volta al mese un agente segreto agisce sul tasto per ascoltare uno dei microfoni

16 Sistema multiplexato Sistema telefonico Sistema di periferiche collegate a un computer

17 Multiplexing: hardware
Sono necessari due elementi: 1. circuito passa/blocca analogo al tasto chiuso/aperto 2. circuito di decodifica che chiuderà solo uno degli elementi passa/blocca per volta pass/block’ segnale-in segnale-out IN pass/block’ OUT  gate AND pass/block Multiplexer 2-to-1

18 Il MUX più semplice:

19 Mux a quattro input Circuito che fa “collega” uno dei quattro input all’ouput out a seconda del valore delle due linee di selezione SEL[1..0]

20 Mux a quattro input Circuiti passa/blocca Decoder da-2-a-4
EN0 IN1 EN1 IN2 EN2 IN3 EN3 Circuiti passa/blocca Decoder da-2-a-4 Z OR dei segnali

21 Progetto 2  Esempio di utilizzo di multiplexer e decoder

22 seven-seg-decoder

23 FPGA seven-seg-decoder Dalla FPGA escono solo 7 linee di controllo dei led comuni ai 4 array E’ necessario interporre un MUX fra i 4 seven-seg-decoder e le linee di uscita

24

25 una cifra diversa

26

27

28

29

30

31

32

33 Un mux a quattro input può implementare qualunque funzione a tre variabili
Esempio: implementiamo la funzione F(R, S, T) = R’S’ + RT T 1 I0 I1 I2 I3 R S F(R,S,T) Z F(R,S,T) = R’S’•1 + RT•(S+S’) = R’S’•1 + R’S•0 + RS•T + RS’•T A B 00 01 11 10 Functions of how many input variables can be implemented by an 8-t0-1 MUX? Utilizzare un 8-to-1 MUX per implementare la funzione: F(X,Y,Z,T) = XY’ + Z’T

34 Implementazione “tradizionale”
Come implementare la funzione logica con un mux?

35

36

37

38 Tristate Consideriamo una serie di dispositivi collegati a una CPU tramite una linea comune (bus) La CPU può abilitare uno dei dispositivi per volta che accede al bus trasmettendo dati EN0 EN1 EN0=1 EN1=1 EN0=0 out0 out1 out0 out0 out1 C P U out2 out3 EN2 EN3 MUX a quattro input?

39 Come facciamo a fare MUX?
Problema: è impossibile mettere in OR OUT0, ..., OUT3 IN0 EN0 NO! IN1 EN1 output sul bus? IN2 EN2 IN3 EN3

40 Le uscite del gate logici che abbiamo studiato finora non possono essere collegate assieme
I gate si “sparano” uno contro l’altro

41 Come facciamo a fare MUX?
Andrebbe bene un sistema tale che se un dispositivo non è abilitato è come se non fosse fisicamente collegato al bus EN1 EN1=1 EN0=0 out1 out0 EN0=1 out0 out1 C P U out2 out3 EN2 EN3 Hi-Z: alta impedenza  linea scollegata  buffer tristate: A OUT EN

42

43

44 Mux con buffers tristate
periferica data0 EN0 out0 data1 EN1 out1 output sul bus? data2 EN2 out2 SI! data3 EN3 out3 data## dati che la periferica ## trasmette se richiesto (EN## asserito dalla CPU)

45 Tristate party line col 74x138

46 (tpLZ e tpHZ dovrebbero essere minori di tpZL tpZH)
Considerazioni sulla temporizzazione Per impedire conflitti, dovrebbero andare nello stato Hi-Z più velocemente di quanto impiegano per andare nello stato Hi-Z (tpLZ e tpHZ dovrebbero essere minori di tpZL tpZH)

47 Per sicurezza, la logica di controllo dovrebbe garantire un tempo morto sulla party line durante il quale nessuno pilota la linea.

48 Esempio motivante: l’unità logico-aritmetica (ALU)
Parte importante del percorso dei dati nell’architettura di una CPU Come tutto l’hardware, può essere disegnata usando un linguaggio di programmazione orientato all’hardware (HDL) Utile esempio perchè può essere facilmente decomposta operand1 alu_result ALU operand2 ALU operation opcode

49 Esempio motivante: l’unità logico-aritmetica (ALU)
Insieme di operazioni: operand1 alu_result ALU Logic AND OR XOR NOT operand2 ALU operation opcode Arithmetic add subtract multiply negate

50 Struttura della ALU Modulo aritmetico logico arithmetic operation MUX
2 arithmetic operation logic MUX Modulo aritmetico logico Arith_result Logic_result operand1 operand0 Alu_result 1 opcode selection

51 Struttura della ALU ALU Modulo Aritmetico logico MUX 2 1 selection
Arith_result Logic_result operand1 operand0 Alu_result 2 opcode 1 selection

52 VERILOG HDL Disegni organizzati gerarchicamente
Ciascun elemento del disegno ha: Un’interfaccia ben definita Una precisa specifica del comportamento usando o: Una descrizione algoritmica Una descrizione strutturale dell’hardware Modella la concorrenza, la temporizzazione, e il clock: Gestisce circuiti asincroni e sincroni I disegni possono essere simulati

53 arithmetic_module_arch
Struttura gerarchica della ALU alu_arch alu arithmetic_module_arch arithmetic_module Arithmetic Functionality logic_module_arch logic_module Logic mux_arch mux Multiplexer Procedura bottom-up: cominciamo a modellare gli elementi più in basso

54 Mux: introduzione ai moduli e porte
Il blocco costruttivo fondamentale di verilog è il modulo  elemento o collezione di blocchi di livello più basso. Arith_result Alu_result MUX module mux(Arith_result, Logic_result, Alu_result); Dichiarazione varibili … Funzionalità endmodule; Sintassi: Logic_result selection

55 Dichiarazione di variabili: segnali di input e output
module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,Alu_result; … endmodule; Segnali di input: Arith_result, Logic_result, selection porte module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; … endmodule; Segnale di output: Alu_result Arith_result Alu_result MUX Sintassi: Logic_result module mux(Arith_result, Logic_result, selection, Alu_result); funzionalità … endmodule; selection

56 Disegno a livello di gate
Verilog supporta i gate logici fondamentali come moduli primitivi predefiniti. Arith_result a1 selection Alu_result Logic_result a0 selection selection_n net: connessioni fra elementi hardware module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; wire selection_n, a0, a1; … endmodule; Le net sono dichiarate con la keyword wire. Hanno valori pilotati continuamente dagli output dei dispositivi cui sono collegate Gli input e output del modulo sono implicitamente wire

57 Instanziamento dei moduli primitivi
Arith_result a1 module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; wire selection_n, a0, a1; not (selection_n,selection); and (a1,selection,Arith_result); endmodule; selection module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; wire selection_n, a0, a1; not (selection_n,selection); and (a1,selection,Arith_result); and (a0,selection_n,Logic_result); or (Alu_result,a0,a1); endmodule; Alu_result Logic_result module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; wire selection_n, a0, a1; not (selection_n,selection); and (a1,selection,Arith_result); and (a0,selection_n,Logic_result); endmodule; a0 selection selection_n module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; wire selection_n, a0, a1; not (selection_n,selection); endmodule; module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; wire selection_n, a0, a1; … endmodule;

58 Metodo di instanziamento alternativo
Arith_result a1 module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; wire selection_n, a0, a1; not (selection_n,selection); and (a1,selection,Arith_result); endmodule; selection module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; wire selection_n, a0, a1; not not1(selection_n,selection); and and1(a1,selection,Arith_result); and and0(a0,selection_n,Logic_result); or or1(Alu_result,a0,a1); endmodule; Alu_result Logic_result module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; wire selection_n, a0, a1; not (selection_n,selection); and (a1,selection,Arith_result); and (a0,selection_n,Logic_result); endmodule; a0 selection selection_n module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; wire selection_n, a0, a1; not (selection_n,selection); endmodule; module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; wire selection_n, a0, a1; … endmodule;

59 Un maggiore livello di astrazione: modellazione del flusso dei dati (dataflow)
Modellazione a livello di gate: intuitivo tuttavia non efficiente per componenti con un numero di gate grande. Modellazione del flusso dei dati: rappresentazione di un circuito in termini del flusso dei dati fra input e output a un livello più astratto X1 Xm X2 Z1 Zm Z2 Funzionamento specificato non in termini di gate elementari Assegnazione continua assign: istruzione fondamentale per pilotare un valore su una net: wire Z1; assign Z1 = operazione logica su X1, X2, … X1, X2, ... = operandi Operazione logica: operatore

60 Operazioni logiche su coppie di operandi
assign Z1 = X1 & X2; OR: assign Z1 = X1 | X2; NOT: assign Z1 = ~ X1; module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; assign Alu_result = (~ selection & Logic_result) | (selection & Arith_result); endmodule; Arith_result selection  assign a1 = selection & Arith_result a1 Alu_result a0 a1  assign Alu_result = a0 | a1; Logic_result selection selection_n  assign a0 = ~ selection & Logic_result a0

61 Operatore condizionale
assign Alu_result = selection ? Arith_result : Logic_result; Espressione condizione: Se vera (1) Alu_result = Arith_result Se falsa (0) Alu_result = Logic_result module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; assign Alu_result = selection ? Arith_result : Logic_result; endmodule;

62 Vettori ALU a 8 bit: Arith_result, Logic_result e ALU_result sono numeri a 8 bit module mux(Arith_result, Logic_result, selection, Alu_result); input [7:0] Arith_result, Logic_result,selection; output [7:0] Alu_result; assign Alu_result = selection ? Arith_result : Logic_result; endmodule; Arith_result  Arith_result[7:0] Logic_result  Logic_result[7:0] ALU_result  ALU_result[7:0]

63 Modulo aritmetico operand1 operand0 Arith_result opcode
module arith_module(operand0, operand1, opcode, Arith_result); input [7:0] operand0, operand1; output [7:0] Arith_result; input [1:0] opcode; wire [7:0] zero = 8’b0; wire [7:0] op0 = operand1 + operand0; wire [7:0] op1 = operand1 – operand0; wire [7:0] op2 = zero – operand0; wire [7:0] op3 = operand1 * operand1; … endmodule; Operandi: vettori a 8 bit opcode: 4 operazioni  vettore a 2 bit Operazioni: opcode = 0  Arith_result = operand0 + operand1 opcode = 1  Arith_result = operand0 - operand1 opcode = 2  Arith_result = zero – operand0 opcode = 3  Arith_result = operand0 * operand1 module arith_module(operand0, operand1, opcode, Arith_result); input [7:0] operand0, operand1; output [7:0] Arith_result; input [1:0] opcode; wire [7:0] zero = 32’b0; … endmodule;

64 Le quattro operazioni devono essere multiplexate  mux 1 di 4 con operatori condizionali annidati
module arith_module(operand0, operand1, opcode, Arith_result); input [7:0] operand0, operand1; output [7:0] Arith_result; input [1:0] opcode; wire [7:0] zero = 8’b0; wire [7:0] op0 = operand1 + operand0; wire [7:0] op1 = operand1 – operand0; wire [7:0] op2 = zero – operand0; wire [7:0] op3 = operand1 * operand1; assign Arith_result = opcode[1] ? (opcode[0] ? op3 : op2) : (opcode[0] ? op1 : op0); endmodule;

65 Variabili di tipo registro (reg)
I registri rappresentano elementi di memorizzazione dati (data storage) Mantengono il loro valore finchè un altro valore è posto su essi A differenza di una net un registro non necessita un driver e non sono pilotati continuamente Non devono essere confusi con i registri hardware costruiti con flip-flop D e che possono cambiare il loro valore solo sul bordo di un clock  possono cambiare valore a un istante qualsiasi. Sono dichiarati con la keyword reg. net reg o net input output modulo

66 Statement always begin … end Ogni volta che è soddisfatta la condizione in parentesi, vengono eseguiti tutti gli stament contenuti all’interno del blocco begin-end Blocco begin-end: analogo a un raggruppamento di istruzioni {} del linguaggio di programmazione C. q=d q=d è eseguito ogni volta che il segnale clk cambia valore clk) q=d q=d è eseguito ogni volta che il segnale clk compie una transizione positiva q=d è eseguito ogni volta che il segnale clk compie una transizione negativa clk) q=d

67 Possono essere presenti più blocchi always in un modulo:
 tutti i blocchi funzionano simultaneamente e in modo concorrenziale  caratteristica fondamentale del funzionamento dei componenti hardware  caratteristica distintiva di Verilog rispetto a un linguaggio come il C in cui tutte le istruzioni sono eseguite in modo sequenziale La variabile q a cui è assegnato d a ogni bordo negativo del segnale clk deve essere necessariamente di tipo reg  deve mantenere il valore fra due istanti in cui si verifica la condizione negedge clk clk) q=d

68 Statement case sintassi
case(espressione) alternativa 0: statement 0; alternativa 1: statement 1; … endcase L’espressione è confrontata alle alternative nell’ordine in cui appaiono Per la prima alternativa per cui c’e’ accordo il corrispondente statement o blocco è eseguito

69 module arith_module(operand0,
opcode, Arith_result); input [7:0] operand0, operand1; output [7:0] Arith_result; reg [7:0] Arith_result; input [1:0] opcode; wire [7:0] zero = 8’b0; or operand1 or opcode) case(opcode) 2’d0: Arith_result = operand1 + operand0; 2’d1 Arith_result = operand1 – operand0; 2’d2 Arith_result = zero – operand0; 2’d3 Arith_result = operand1 * operand1; endcase endmodule; Esecuzione triggerata da una transizione di uno qualsiasi dei segnali operand o opcode or segnale1 or …)

70 Abbellimenti Assegamo un nome alle varie operazioni:
Opcode = 2’d3  Mult module arith_module(operand0, operand1, opcode, Arith_result); `define Add 2’d0; `define Sub 2’d1; `define Neg 2’d2; `define Mult 2’d3; input [7:0] operand0, operand1; output [7:0] Arith_result; reg [7:0] Arith_result; input [1:0] opcode; wire [7:0] zero = 8’b0; or operand1 or opcode) case(opcode) `Add : Arith_result = operand1 + operand0; `Sub : Arith_result = operand1 – operand0; `Neg : Arith_result = zero – operand0; `Mult : Arith_result = operand1 * operand0; endcase endmodule; Opcode = 2’d2  Neg module arith_module(operand0, operand1, opcode, Arith_result); `define Add 2’d0; `define Sub 2’d1; `define Neg 2’d2; input [7:0] operand0, operand1; output [7:0] Arith_result; reg [7:0] Arith_result; input [1:0] opcode; wire [7:0] zero = 8’b0; or operand1 or opcode) case(opcode) `Add : Arith_result = operand1 + operand0; `Sub : Arith_result = operand1 – operand0; `Neg : Arith_result = zero – operand0; endcase endmodule; Assegamo un nome alle varie operazioni: Opcode = 2’d1  Sub module arith_module(operand0, operand1, opcode, Arith_result); `define Add 2’d0; `define Sub 2’d1; input [7:0] operand0, operand1; output [7:0] Arith_result; reg [7:0] Arith_result; input [1:0] opcode; wire [7:0] zero = 8’b0; or operand1 or opcode) case(opcode) `Add : Arith_result = operand1 + operand0; `Sub : Arith_result = operand1 – operand0; endcase endmodule; module arith_module(operand0, operand1, opcode, Arith_result); `define Add 2’d0; input [7:0] operand0, operand1; output [7:0] Arith_result; reg [7:0] Arith_result; input [1:0] opcode; wire [7:0] zero = 8’b0; or operand1 or opcode) case(opcode) `Add : Arith_result = operand1 + operand0; endcase endmodule; Opcode = 2’b0  Add

71 Generalizzare il codice
module arith_module(operand0, operand1, opcode, Arith_result); `define ALU_width 8; `define Add 2’d0; `define Sub 2’d1; `define Neg 2’d2; `define Mult 2’d3; input [`ALU_width-1:0] operand0, operand1; output [`ALU_width-1:0] Arith_result; reg [`ALU_width-1:0] Arith_result; input [1:0] opcode; wire [`ALU_width-1:0] zero = 8’b0; or operand1 or opcode) case(opcode) `Add : Arith_result = operand1 + operand0; `Sub : Arith_result = operand1 – operand0; `Neg : Arith_result = zero – operand0; `Mult : Arith_result = operand1 * operand0; endcase endmodule; Generalizzare il codice Il nostro progetto richiede una ALU a 8 bit. Un upgrade potrebbe richiedere la processazione di numeri a 16 bit.  modulo generico funzionante in entrambi i casi con modifiche minime Dobbiamo cambiare la larghezza in un solo punto

72 Modulo logico struttura simile al modulo aritmetico AND OR XOR NOT
module arith_module(operand0, operand1, opcode, Arith_result); `define ALU_width 8; `define AND 2’d0; `define OR 2’d1; `define XOR 2’d2; input [`ALU_width-1:0] operand0, operand1; output [`ALU_width-1:0] Arith_result; reg [`ALU_width-1:0] Arith_result; input [1:0] opcode; wire [`ALU_width-1:0] zero = 8’b0; or operand1 or opcode) case(opcode) `AND : Arith_result = operand1 & operand0; `OR : Arith_result = operand1 | operand0; `XOR : Arith_result = operand0 ^ operand1; endcase endmodule; NOT module logic_module(operand0, operand1, opcode, Arith_result); `define ALU_width 8; `define AND 2’d0; `define OR 2’d1; `define XOR 2’d2; `define NOT 2’d3; input [`ALU_width-1:0] operand0, operand1; output [`ALU_width-1:0] Arith_result; reg [`ALU_width-1:0] Arith_result; input [1:0] opcode; wire [`ALU_width-1:0] zero = 8’b0; or operand1 or opcode) case(opcode) `AND : Arith_result = operand1 & operand0; `OR : Arith_result = operand1 | operand0; `XOR : Arith_result = operand0 ^ operand1; `NOT : Arith_result = ~operand0; endcase endmodule; Modulo logico OR module arith_module(operand0, operand1, opcode, Arith_result); `define ALU_width 8; `define AND 2’d0; `define OR 2’d1; input [`ALU_width-1:0] operand0, operand1; output [`ALU_width-1:0] Arith_result; reg [`ALU_width-1:0] Arith_result; input [1:0] opcode; wire [`ALU_width-1:0] zero = 8’b0; or operand1 or opcode) case(opcode) `AND : Arith_result = operand1 & operand0; `OR : Arith_result = operand1 | operand0; endcase endmodule; module arith_module(operand0, operand1, opcode, Arith_result); `define ALU_width 8; `define AND 2’d0; input [`ALU_width-1:0] operand0, operand1; output [`ALU_width-1:0] Arith_result; reg [`ALU_width-1:0] Arith_result; input [1:0] opcode; wire [`ALU_width-1:0] zero = 8’b0; or operand1 or opcode) case(opcode) `AND : Arith_result = operand1 & operand0; endcase endmodule; AND struttura simile al modulo aritmetico

73 Modulo ALU Input: operand0[7:0], operand1[7:0], opcode[2:0]
Mux module ALU(operand0, operand1, opcode, ALU_result); `define ALU_width 8; input [`ALU_width :0] operand0, operand1; input [2:0] opcode; output [`ALU_width :0] ALU_result; wire [`ALU_width :0] Arith_result; Arith_module myArith_module(operand0, opcode[1:0], Arith_result); wire [`ALU_width :0] Logic_result; Logic_module myLogic_module(operand0, Logic_result); Mux myMux(Arith_result,Logic_result,opcode[2], endmodule; Modulo ALU Unità logica module ALU(operand0, operand1, opcode, ALU_result); `define ALU_width 8; input [`ALU_width :0] operand0, operand1; input [2:0] opcode; output [`ALU_width :0] ALU_result; wire [`ALU_width :0] Arith_result; Arith_module myArith_module(operand0, opcode[1:0], Arith_result); wire [`ALU_width :0] Logic_result; Logic_module myLogic_module(operand0, Logic_result); endmodule; output: ALU_result[7:0] module ALU(operand0, operand1, opcode, ALU_result); `define ALU_width 8; input [`ALU_width :0] operand0, operand1; input [2:0] opcode; output [`ALU_width :0] ALU_result; … endmodule; module ALU(operand0, operand1, opcode, ALU_result); `define ALU_width 8; input [`ALU_width :0] operand0, operand1; input [2:0] opcode; … endmodule; Input: operand0[7:0], operand1[7:0], opcode[2:0] Unità aritmetica module ALU(operand0, operand1, opcode, ALU_result); `define ALU_width 8; input [`ALU_width :0] operand0, operand1; input [2:0] opcode; output [`ALU_width :0] ALU_result; wire [`ALU_width :0] Arith_result; Arith_module myArith_module(operand0, opcode[1:0], Arith_result); endmodule;