DidaWiki

Per realizzare una rete combinatoria in Verilog abbiamo due modi:

• utilizzare una tabella di verità
• utilizzare un'espressione dell'algebra booleana

Si definisce un modulo di tipo “primitive”, ovvero un modulo racchiuso fra le due righe

   primitive nomedelmodulodadefinire(listadeiparametriinuscitaeiningresso);
   end primitive

Il nome del modulo è una stringa qualunque. La lista dei parametri dichiara un parametro come

   [input|output] nomeparametro

Un modulo primitive può definire un tabella di verità che produce un solo bit in uscita. Per ogni bit di una funzione che produce un'uscita a più bit va definito un modulo primitive diverso. Il modulo deve avere tante variabili in ingresso quanti sono gli ingressi del modulo.

Esempio di definizione di un modulo commutatore a due vie con ingressi da 1 bit:

primitive commutatoreADueVie32(output z, input x, input y, input alpha); 
   ...
end primitive

La parola chiave che definisce il tipo del parametro, in input o in output, può essere indicata una sola volta prima della lista dei parametri formali che hanno quel tipo. Ad esempio, l'intestazione precedente può essere data come

primitive commutatoreADueVie32(output z, input x,  y,  alpha); 
   ...
end primitive

Per prassi, i parametri di output si indicano prima di quelli di input.

Si definisce una tabella di verità di n variabili di ingresso e una variabile di uscita elencando righe di n valori delle variabili separate da spazi seguite dai due punti, dal valore corrispondente della variabile di uscita e dal punto e virgola fra le parole chiave “table” e “end table”. Ad esempio:

table
  0 0 : 0 ; 
  0 1 : 1 ; 
  1 0 : 1 ; 
  1 1 : 1 ;
end table

definisce l'OR di due variabili da un bit.

Valori “don't care” nella tabella di verità possono essere indicati con il punto interrogativo.

Ad esempio:

primitive k(output z, input alpha, x, y); 
  table
    0 1 ? : 1;
    0 0 ? : 0;
    1 ? 1 : 1; 
    1 ? 0 : 0; 
  end table
end primitive

definisce il commutatore a due vie da un bit.

Si definisce un modulo di tipo “module”, ovvero un modulo racchiuso fra le due righe

   module nomedelmodulodadefinire(listadeiparametriinuscitaeiningresso);
   end module

Il nome del modulo è una stringa qualunque. La lista dei parametri dichiara un parametro come

   [input|output] nomeparametro["["dimensioniInBit"]"]

dove le dimensioni in bit vengono date con un'espressione che comprende l'indice del bit più significativo, seguito dai due punti, seguito dall'indice del bit meno significativo. Ad esempio

   input alpha[1:0]

indica una variabile in ingresso da due bit, il cui bit più significativo è

   alpha[1]

e quello meno significativo è

   alpha[0]

Esempio di definizione di un modulo commutatore a due vie con ingressi da 2 bit:

module commutatoreADueVie2bit(output z[1:0], input x[1:0], input y[1:0], input alpha); 
   ...
end module

Il corpo del modulo può contenere una o più istruzioni di “assign”

assign nomeVar = espressioneBooleana; 

dove il nome della variabile da assegnare denota un valore di un bit e l'espressione booleana usa i simboli “&” per l'and “+” per l'or e “~” per il not.

Dunque il commutatore di cui abbiamo dato l'intestazione può essere completato come segue:

module commutatoreADueVie2bit(output z[1:0], input x[1:0], input y[1:0], input alpha); 
   
   assign z[1] = ((~alpha) & x[1]) + (alpha & y[1]);
   assign z[0] = ((~alpha) & x[0]) + (alpha & y[0]);
   
end module

Lo statement “assign” è detto assegnamento continuo e il significato è (informalmente) fai in modo che la variabile assegnata valga in continuazione quanto vale l'espressione. Se le variabili dell'espressione cambiano, il valore della variabile deve cambiare di conseguenza immediatamente.

Un modulo, definito come “primitive” o “module” può essere utilizzato dichiarandone un'istanza, ovvero nominandone il nome utilizzato per la definizione, dando un nome all'istanza del modulo e passando una lista di parametri attuali:

   commutatoreADueVie2bit   K1(z1,xx,yy, a); 

definisce un'istanza del modulo “commutatoreADueVie2bit” che si chiama “K1” e che associa al parametro formale in uscita “z” il parametro attuale “z1”, al formale “x” l'attuale “xx”, etc.