La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

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

Presentazioni simili


Presentazione sul tema: "1 Struttura generale del decoder Tipicamente n input, m=2 n outputs 2-to-4, 3-to-8, 4-to-16, etc. Decoder Circuito che converte un codice di input a nbit."— Transcript della presentazione:

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

2 2

3 3 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 (dont care) Decoder binari

4 4

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

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

7 7 Decoder da-3-a-8 3-to-8 Line Decoder y 0 = abc y 1 = abc y 2 = abc y 3 = abc y 4 = abc y 5 = abc y 6 = abc y 7 = abc a b c

8 8 Decoder da-3-a-8 con codice di input Gray 3-to-8 Line Decoder DEG0 DEG45 DEG135 DEG90 DEG315 DEG270 DEG180 DEG225 a b c 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 0 o Y0 45 o Y1 90 o Y3 135 o Y2 180 o Y6 225 o Y7 270 o Y5 315 o Y4

9 9 Decoder da-3-a-8 74x138

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

11 11

12 12

13 13 –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 dellindirizzo –Moltissime altre applicazioni Applicazioni dei decoder

14 14 Decoder in verilog

15 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 16 Sistema telefonico Sistema di periferiche collegate a un computer Sistema multiplexato

17 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 18 Il MUX più semplice:

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

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

21 21 Progetto 2 Esempio di utilizzo di multiplexer e decoder

22 22 seven-seg-decoder

23 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 24

25 25 una cifra diversa

26 26

27 27

28 28

29 29

30 30

31 31

32 32

33 33 I0I0 I1I1 I2I2 I3I3 A B Z Esempio: implementiamo la funzione F(R, S, T) = RS + RT F(R,S,T) = RS1 + RT(S+S) = RS1 + RS0 + RST + RST RS F(R,S,T) T T 1 0 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 + ZT Un mux a quattro input può implementare qualunque funzione a tre variabili

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

35 35

36 36

37 37

38 38 CPUCPU 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 EN2 EN3 EN0=1EN1=1 EN0=0 MUX a quattro input? out0out1 out2out3 out0 out1 out0 Tristate

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

40 40 Le uscite del gate logici che abbiamo studiato finora non possono essere collegate assieme I gate si sparano uno contro laltro

41 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 CPUCPU EN1 EN2 EN3 EN0=1 out0out1 out2out3 EN1=1 EN0=0 out1 out0 buffer tristate: AOUT EN Hi-Z: alta impedenza linea scollegata

42 42

43 43

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

45 45 Tristate party line col 74x138

46 46 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) Considerazioni sulla temporizzazione

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

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

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

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

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

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

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

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

55 55 MUX Arith_result Alu_result selection module mux(Arith_result, Logic_result, selection, Alu_result); funzionalità … endmodule; Sintassi: Logic_result porte 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 module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; … endmodule; Segnale di output: Alu_result

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

57 57 module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; wire selection_n, a0, a1; … endmodule; Instanziamento dei moduli primitivi Arith_result Alu_result selection Logic_result selectionselection_n a0 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); endmodule; 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; 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; 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;

58 58 module mux(Arith_result, Logic_result, selection, Alu_result); input Arith_result, Logic_result,selection; output Alu_result; wire selection_n, a0, a1; … endmodule; Metodo di instanziamento alternativo Arith_result Alu_result selection Logic_result selectionselection_n a0 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); endmodule; 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; 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; 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;

59 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 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 X1X1 XmXm X2X2 Z1Z1 ZmZm Z2Z2 Funzionamento specificato non in termini di gate elementari

60 60 AND: assign Z1 = X1 & X2; Operazioni logiche su coppie di operandi OR: assign Z1 = X1 | X2; NOT: assign Z1 = ~ X1; Alu_result a0 a1 assign Alu_result = a0 | a1; Arith_result selection assign a1 = selection & Arith_result a1 Logic_result selectionselection_n assign a0 = ~ selection & Logic_result a0 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;

61 61 assign Alu_result = selection ? Arith_result : Logic_result; Operatore condizionale 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; Espressione condizione: Se vera (1) Alu_result = Arith_result Se falsa (0) Alu_result = Logic_result

62 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 63 Modulo aritmetico operand1 opcode operand0 Arith_result Operandi: vettori a 8 bit opcode: 4 operazioni vettore a 2 bit 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 = 32b0; … endmodule; 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 = 8b0; 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;

64 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 = 8b0; 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 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 net input reg o net output modulo

66 66 Statement always begin … end Ogni volta che è soddisfatta la condizione in parentesi, vengono eseguiti tutti gli stament contenuti allinterno 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 q=d è eseguito ogni volta che il segnale clk compie una transizione negativa clk) q=d clk) q=d q=d è eseguito ogni volta che il segnale clk compie una transizione positiva

67 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 68 Statement case sintassi case(espressione) alternativa 0: statement 0; alternativa 1: statement 1; … endcase Lespressione è confrontata alle alternative nellordine in cui appaiono Per la prima alternativa per cui ce accordo il corrispondente statement o blocco è eseguito

69 69 module arith_module(operand0, operand1, 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 = 8b0; or operand1 or opcode) case(opcode) 2d0: Arith_result = operand1 + operand0; 2d1 Arith_result = operand1 – operand0; 2d2 Arith_result = zero – operand0; 2d3 Arith_result = operand1 * operand1; endcase endmodule; Esecuzione triggerata da una transizione di uno qualsiasi dei segnali operand o opcode or segnale1 or …)

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

71 71 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 module arith_module(operand0, operand1, opcode, Arith_result); `define ALU_width 8; `define Add 2d0; `define Sub 2d1; `define Neg 2d2; `define Mult 2d3; 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 = 8b0; 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; Dobbiamo cambiare la larghezza in un solo punto

72 72 Modulo logico struttura simile al modulo aritmetico module arith_module(operand0, operand1, opcode, Arith_result); `define ALU_width 8; `define AND 2d0; 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 = 8b0; or operand1 or opcode) case(opcode) `AND : Arith_result = operand1 & operand0; endcase endmodule; AND OR module arith_module(operand0, operand1, opcode, Arith_result); `define ALU_width 8; `define AND 2d0; `define OR 2d1; 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 = 8b0; or operand1 or opcode) case(opcode) `AND : Arith_result = operand1 & operand0; `OR : Arith_result = operand1 | operand0; endcase endmodule; XOR module arith_module(operand0, operand1, opcode, Arith_result); `define ALU_width 8; `define AND 2d0; `define OR 2d1; `define XOR 2d2; 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 = 8b0; 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 2d0; `define OR 2d1; `define XOR 2d2; `define NOT 2d3; 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 = 8b0; 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;

73 73 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] Modulo ALU 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; 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, operand1, opcode[1:0], Arith_result); endmodule; 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, operand1, opcode[1:0], Arith_result); wire [`ALU_width :0] Logic_result; Logic_module myLogic_module(operand0, operand1, opcode[1:0], Logic_result); endmodule; 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, operand1, opcode[1:0], Arith_result); wire [`ALU_width :0] Logic_result; Logic_module myLogic_module(operand0, operand1, opcode[1:0], Logic_result); Mux myMux(Arith_result,Logic_result,opcode[2], ALU_result); endmodule;


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

Presentazioni simili


Annunci Google