b'\n_START_ARTICLE_\nVerilog\n_START_SECTION_\nPanoramica\n_START_PARAGRAPH_\nIl linguaggio (a volte chiamato Verilog HDL) supporta la progettazione, la verifica, e l\'implementazione di circuiti digitali e pi\xc3\xb9 raramente di circuiti analogici o circuiti misti analogico-digitali a vari livelli di astrazione. _NEWLINE_Gli inventori del Verilog volevano un linguaggio con una sintassi simile al C cos\xc3\xac che fosse familiare agli utilizzatori e facilmente accettato._NEWLINE_Uno dei metodi pi\xc3\xb9 immediati per fare pratica con Verilog \xc3\xa8 l\'utilizzo di board che montano chip FPGA, Field Programmable Gate Array. Ne esistono di diversi produttori fra i quali Digilent e Terasic che montano rispettivamente chip prodotti da Xilinx e da Altera. Tramite i tool forniti dalle case produttrici delle board \xc3\xa8 possibile sintetizzare il codice e caricare il bitstream sul chip FPGA che implementer\xc3\xa0 il circuito progettato._NEWLINE_Il principale concorrente \xc3\xa8 VHDL pi\xc3\xb9 moderno ma allo stesso tempo meno immediato da utilizzare.\n_START_SECTION_\nCaratteristiche\n_START_PARAGRAPH_\nIl linguaggio \xc3\xa8 case sensitive distingue cio\xc3\xa8 tra caratteri maiuscoli e caratteri minuscoli, ha un preprocessore come il C, e le maggiori parole chiave di controllo del flusso del programma, come "if" e "while", sono simili ai pi\xc3\xb9 noti linguaggio di programmazione. La formattazione delle procedure di stampa, gli operatori del linguaggio e la loro precedenza sono simili al C._NEWLINE_\xc3\x88 sbagliato pensare al Verilog come a un linguaggio di programmazione. Infatti l\'esecuzione del codice non \xc3\xa8 sequenziale ma \xc3\xa8 una descrizione del comportamento che deve assumere un modulo, cio\xc3\xa8 un componente che costituir\xc3\xa0 il sistema, per generare delle uscite in risposta a degli ingressi._NEWLINE_Pu\xc3\xb2 essere utile confrontare la sintassi con quella del linguaggio C per memorizzare i costrutti. _NEWLINE_Verilog usa Begin/End invece delle parentesi graffe per definire un blocco di codice. _NEWLINE_Le costanti in Verilog richiedono di essere specificate in termini di larghezza in numero di bit insieme al tipo di base utilizzata per la definizione. Verilog 95 e 2001 non ha strutture, puntatori, sottoprocedure ricorsive, mentre queste sono presenti nel SystemVerilog che ora include queste capacit\xc3\xa0._NEWLINE_Infine il concetto di time \xe2\x80\x94cos\xc3\xac importante per l\'HDL\xe2\x80\x94 non esiste nel C._NEWLINE_Il linguaggio Verilog differisce dai linguaggi di programmazione convenzionali nell\'esecuzione delle istruzioni dato che essendo un linguaggio che descrive hardware ogni modulo pu\xc3\xb2 essere eseguito parallelamente ad altri._NEWLINE_Un progetto Verilog consiste di una gerarchia di moduli. Ciascuno \xc3\xa8 definito da un insieme di ingressi e uscite e porte bidirezionali. Internamente contiene una lista di file e registri. Definizione di processi paralleli e sequenziali ne definiscono il comportamento definendo la relazione tra le porte i registri e i file. Le istruzioni sequenziali sono poste all\'interno di un blocco begin/end in ordine sequenziale all\'interno del blocco._NEWLINE_Tutte le istruzioni concorrenti e tutti i blocchi begin/end sono eseguiti in parallelo._NEWLINE_Un modulo pu\xc3\xb2 contenere una o pi\xc3\xb9 istanze di un altro modulo per definire sotto comportamenti._NEWLINE_La controparte alla compilazione del codice sorgente dei comuni linguaggio di programmazione in Verilog \xc3\xa8 detta sintesi. Mentre nei linguaggio di programmazione il codice sorgente viene tradotto in codice macchina, sequenze di 1 e di 0 nella sintesi alle istruzioni e ai costrutti corrispondono componenti fisici. Le informazioni tratte dalla sintesi in successivi passo di sviluppo sono tradotte in maschere di layout per la stampa dei circuiti integrati oppure in specifico codice detto bitstream per la programmazione di FPGA._NEWLINE_Un sottoinsieme delle istruzioni del linguaggio \xc3\xa8 logicamente sintetizzabile. _NEWLINE_Se il modulo in un disegno contiene soltanto istruzioni sintetizzabili, ovvero non ha dichiarazioni di simulazione, del software pu\xc3\xb2 essere utilizzato per trasformare (sintetizzare) il progetto in una lista di componenti (gate o device) e di connessioni tra loro che descrivono i macro blocchi da implementare in hardware._NEWLINE_La lista di connessioni (netlist) pu\xc3\xb2 essere per esempio in una forma che descrive un circuito integrato di tipo gate array, molto pi\xc3\xb9 raramente uno standard cells, (ovvero degli ASIC)._NEWLINE_Pi\xc3\xb9 comunemente l\'uscita \xc3\xa8 un bitstream utilizzata per un dispositivo programmable logic device (ad esempio, una FPGA).\n_START_SECTION_\nStoria\n_START_PARAGRAPH_\nIl Verilog fu inventato nel 1985 da Phil Moorby presso la Automated Integrated Design Systems (pi\xc3\xb9 tardi denominata Gateway Design Automation) come un linguaggio di programmazione dell\'hardware. Nel 1990 l\'azienda fu comprata da Cadence Design Systems, la quale rese di pubblico dominio il linguaggio, fino ad allora proprietario. Da qui deriv\xc3\xb2 la possibilit\xc3\xa0 di renderlo uno standard, cosa che avvenne con il nome di IEEE 1364, con revisioni nel 1995, 2001 e 2005. Cadence attualmente detiene la propriet\xc3\xa0 completa dei diritti dei simulatori logici della vecchia Gateway.\n_START_SECTION_\nEsempi\n_START_PARAGRAPH_\nUn programma che visualizza "hello world":_NEWLINE_module main;_NEWLINE_  initial _NEWLINE_    begin_NEWLINE_      $display("Hello world!");_NEWLINE_      $finish;_NEWLINE_    endendmodule_NEWLINE_Il codice sopra \xc3\xa8 utile solo per la simulazione. Non \xc3\xa8 possibile sintetizzare con queste istruzioni un circuito che abbia questo comportamento._NEWLINE_Un esempio di 2 flip-flop._NEWLINE_module toplevel(clock, reset);_NEWLINE_ input clock;_NEWLINE_ input reset;_NEWLINE__NEWLINE_ reg ff1;_NEWLINE_ reg ff2;_NEWLINE__NEWLINE_ always @ (posedge reset or posedge clock)_NEWLINE_ if (reset)_NEWLINE_   begin_NEWLINE_     ff1 <= 0;_NEWLINE_     ff2 <= 1;_NEWLINE_   end_NEWLINE_ else_NEWLINE_   begin_NEWLINE_     ff1 <= ff2;_NEWLINE_     ff2 <= ff1;_NEWLINE_   endendmodule_NEWLINE_L\'operatore <= costituisce un altro aspetto del fatto che Verilog \xc3\xa8 un linguaggio per la descrizione dell\'hardware e non un normale linguaggio procedurale. Tale operatore \xc3\xa8 conosciuto come "assegnazione non bloccante". Quando la simulazione viene eseguita, tutti quei segnali impostati mediante "<=" vengono modificati solo dopo che tutte le istruzioni che avvengono nello stesso momento sono state eseguite. Questo rende pi\xc3\xb9 semplice descrivere comportamenti che avvengono simultaneamente._NEWLINE_Nell\'esempio sopra, ff1 \xc3\xa8 assegnato a ff2 e ff2 a ff1. Queste istruzioni sono eseguite durante lo stesso evento temporale. Visto che le assegnazioni sono codificate mediante <=, queste accadono alla fine dell\'evento e sino ad allora tutte le letture dei valori di ff1 e ff2 restituiranno il valore all\'inizio dell\'evento. Questo significa che l\'ordine delle assegnazione non \xc3\xa8 significativo e produrr\xc3\xa0 gli stessi risultati. ff1 e ff2 si scambieranno i valori a ogni ciclo._NEWLINE_L\'altra scelta per l\'assegnazione \xc3\xa8 l\'operatore =, conosciuto come "assegnazione bloccante". Quando viene utilizzato, le cose accadono nella sequenza con cui appaiono, come in un linguaggio procedurale._NEWLINE_Nell\'esempio sopra, se le assegnazioni avessero fatto uso di = invece di <=, l\'ordine con cui compaiono avrebbe influenzato il comportamento: il reset avrebbe impostato ff2 a 1 e ff1 a 0. Al ciclo successivo, ff1 sarebbe stato impostato al valore di ff2, che \xc3\xa8 1 dopo il reset. L\'istruzione successiva verrebbe stata quindi eseguita, e avrebbe impostato ff2 a ff1, che adesso \xc3\xa8 pari a 1. Invece di scambiare i valori a ogni ciclo, ff1 e ff2 sarebbero stati impostati a 1 e rimasti cos\xc3\xac._NEWLINE_Un esempio di contatore:_NEWLINE_module Div20x (rst, clk, cet, cep, count,tc);// TITLE \'Divide-by-20 Counter with enables\'// enable CEP is a clock enable only// enable CET is a clock enable and// enables the TC output// contatore in Verilogparameter size = 5;parameter length = 20;input rst; // questi ingressi/uscite rappresentanoinput clk; // connessioni al moduloinput cet;input cep;output [size-1:0] count;output tc;reg [size-1:0] count; // segnali assegnati_NEWLINE_                      // all\'interno di un blocco "always"_NEWLINE_                      // (o "initial")_NEWLINE_                      // devono essere di tipo "reg"_NEWLINE_                      _NEWLINE_wire tc; // gli altri segnali sono di tipo "wire"// l\'istruzione "always" di seguito indica una// esecuzione in parallelo che// avviene ogni volta che i segnali// "rst" o "clk" effettuano una transizione da basso ad altoalways @ (posedge clk or posedge rst)_NEWLINE_  if (rst) // questo causa il reset del contatore_NEWLINE_    count <= 5\'b0;_NEWLINE_  else_NEWLINE_  if (cet && cep) // entrambi "true"_NEWLINE_    begin_NEWLINE_      if (count == length-1)_NEWLINE_        count <= 5\'b0;_NEWLINE_      else_NEWLINE_        count <= count + 5\'b1; // 5\'b1 &egrave 5 bit_NEWLINE_    end                        // di dimensione e pari_NEWLINE_                               // al valore 1// a "tc" viene assegnato continuamente// il valore dell\'espressioneassign tc = (cet && (count == length-1));endmodule_NEWLINE_Un esempio di ritardo:_NEWLINE_...reg a, b, c, d;wire e;...always @(b or e)_NEWLINE_ begin_NEWLINE_   a = b & e;_NEWLINE_   b = a | b;_NEWLINE_   #5 c = b;_NEWLINE_   d = #6 c ^ e;_NEWLINE_ end_NEWLINE_L\'utilizzo della parola-chiave always sopra illustra l\'altro metodo di utilizzo, cio\xc3\xa8 viene eseguita ogni volta che un\'entit\xc3\xa0 specificata nella lista cambia nell\'esempio b o e. Quando questo avviene, ad a e b sono immediatamente assegnati dei nuovi valori. Dopo 5 unit\xc3\xa0 di tempo, a c \xc3\xa8 assegnato il valore di b, mentre il risultato di c ^ e viene messo da parte in un\'area nascosta. Quindi, dopo altre 6 unit\xc3\xa0 di tempo, questo valore "nascosto" \xc3\xa8 assegnato a d._NEWLINE_Segnali che partono dall\'interno di un processo (un blocco di tipo initial o always devono essere di tipo reg. Segnali che partono dal di fuori di un processo devono essere di tipo wire. La parola-chiave reg non comporta necessariamente un registro hardware.'