Padroneggiare $display in Verilog: Tecniche efficaci di debug e controllo del display

By 佐川 直弘 | Naohiro Sagawa (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。

1. Introduzione: L’importanza e lo scopo di “display” in Verilog

Cosa significa “display” in Verilog?

In Verilog, $display è un task di sistema usato come strumento per “visualizzare” lo stato interno di un progetto durante la simulazione. Simile al printf di C, consente di stampare segnali, valori di variabili e stringhe su un terminale o console, svolgendo un ruolo centrale nel debug e nella verifica funzionale.

Perché $display è essenziale per lo sviluppo in Verilog?

• Migliorata efficienza del debug : Nei progetti di circuiti complessi, visualizzare se i segnali interni funzionano correttamente è fondamentale. Utilizzando $display, è possibile controllare istantaneamente i valori dei segnali di interesse durante la simulazione.
• Visualizzazione della simulazione : Quando si tracciano le transizioni di valore in punti specifici nel tempo, le forme d’onda da sole possono non essere sufficienti. I log di display forniscono un mezzo affidabile per indicare quei momenti precisi.
• Utile anche per la documentazione : Quando si comunica l’intento di progetto o le regole operative ad altri ingegneri, inserire log di display annotati può migliorare la comprensione del codice.

Scopo e struttura di questo articolo

In questo articolo, spiegheremo metodicamente quanto segue:

1. Sintassi di base e utilizzo : Un’introduzione accurata alla sintassi fondamentale e all’uso di $display.
2. Confronto con altri task di sistema : Organizzeremo le differenze tra i task correlati al display come $write, $strobe e $monitor.
3. Specificatori di formato e tecniche di utilizzo avanzate : Verranno introdotti l’uso di specificatori di formato come %d, %b, %h, %s e tecniche speciali di visualizzazione.
4. Esempi pratici di utilizzo : Mostreremo l’uso concreto in testbench e codice con esempi, fornendo know-how immediatamente applicabile.
5. Applicazioni di controllo del display : I casi d’uso includeranno output hardware come LCD o controllo del monitor e visualizzazione di testo/immagine.

Con questa struttura, sia i principianti sia gli utenti intermedi potranno comprendere correttamente $display in Verilog e applicarlo nella pratica. In ogni sezione successiva, procederemo in modo chiaro usando esempi e diagrammi quando possibile.

2. Nozioni di base di $display: Sintassi, casi d’uso e precauzioni

Sintassi di base di $display

Quando si utilizza $display in Verilog, la sintassi di base è la seguente.

$display("string or format specifiers", signal1, signal2, ...);

• Parte stringa : Scrivi qualsiasi testo o specificatore di formato (ad esempio: %d, %b, %h).
• Argomenti : Elenca i nomi dei segnali o le variabili da stampare nel formato corrispondente.

Esempio: Visualizzare il conteggio del clock e i valori dei segnali

$display("Time=%0t : clk=%b, reset=%b", $time, clk, reset);

In questo esempio, vengono stampati il tempo di simulazione e i valori dei segnali clock/reset.

Casi d’uso di $display

1. Comprendere l’avanzamento della simulazione Inserendo $display in punti specifici del progetto è possibile verificare quale parte del codice è stata raggiunta dall’esecuzione.
2. Verifica dei valori dei segnali Anche quando i visualizzatori di forme d’onda rendono difficile comprendere intuitivamente rami condizionali o transizioni di stato, l’output testuale facilita la comprensione.
3. Visualizzazione di messaggi condizionali Combinandolo con istruzioni if è possibile registrare messaggi solo quando vengono soddisfatte condizioni specifiche. if (reset) $display("Reset asserted at %0t", $time);

Differenza tra $display e $write

$display aggiunge automaticamente un a capo alla fine dell’output. Al contrario, $write continua l’output senza aggiungere un a capo.

Esempio:

$display("Hello");
$display("World");

Output:

Hello
World

$write("Hello");
$write("World");

Output:

HelloWorld

Se hai bisogno di log più chiari riga per riga, usa $display. Quando vuoi formattare gli output su una sola riga, usa $write.

Precauzioni

1. Evitare output eccessivo Se usi $display ad ogni ciclo di clock, i log diventano grandi e la leggibilità diminuisce. → Usa condizioni per ridurre l’output.
2. Utilizzare la visualizzazione del tempo Stampare $time o $realtime ti permette di catturare con precisione il timing delle operazioni.
3. Compito solo per la simulazione $display non può essere usato per la sintesi (implementazione FPGA/ASIC). È strettamente uno strumento di debug solo per la simulazione.

3. Confronto dei task di sistema per l’output dei log: $display, $write, $strobe, $monitor

Verilog offre task di sistema oltre a $display per l’output. I loro diversi casi d’uso e timing rendono efficiente comprendere come usarli in modo distinto.

$display: Task di visualizzazione standard

• Caratteristiche Aggiunge automaticamente una nuova riga e registra una linea per ogni invocazione.
• Caso d’uso È comunemente usato come metodo di debug di base; puoi chiamarlo in qualsiasi momento per un output una tantum.

$write: Visualizzazione senza nuova riga

• Caratteristiche Non aggiunge una nuova riga e quindi continua l’output sulla stessa linea.
• Caso d’uso Utile quando vuoi visualizzare più valori affiancati.
• Esempio $write("A=%d, ", a); $write("B=%dn", b); → Output: A=5, B=10 .

$strobe: Output alla fine del ciclo di simulazione

• Caratteristiche Stampa i valori dopo che tutte le valutazioni della simulazione nel passo corrente sono completate.
• Caso d’uso Utile per evitare condizioni di gara (quando più segnali cambiano simultaneamente).
• Esempio $strobe("Time=%0t, signal=%b", $time, sig); → Mentre $display può mostrare valori intermedi, $strobe mostra valori stabilizzati.

$monitor: Output di tracciamento automatico

• Caratteristiche Output automatico quando qualsiasi segnale monitorato cambia.
• Caso d’uso Comodo quando vuoi monitorare un insieme di segnali in modo continuo.
• Esempio $monitor("At %0t: a=%b, b=%b", $time, a, b); → Registra quando a o b cambiano.

Tabella riepilogativa

Consigli per un uso efficace

• Usa $display di default : Leggibile e facile per i principianti.
• Usa $write quando vuoi un output combinato su una singola riga .
• Usa $strobe quando ti servono valori stabilizzati dopo i cambiamenti .
• Usa $monitor quando ti serve un monitoraggio continuo dei segnali .

4. Specificatori di formato e tecniche avanzate di visualizzazione

Con task come $display o $write, puoi includere “specificatori di formato” nelle stringhe per stampare segnali o variabili nei formati desiderati. Poiché somiglia al printf di C, usarli correttamente in base al tuo scopo migliora notevolmente l’efficienza del debug.

Specificatori di formato base

Esempi pratici

1. Visualizzare un segnale in più formati reg [7:0] data = 8'b10101010; $display("data = %b (bin), %d (dec), %h (hex)", data, data, data); → Esempio di output: data = 10101010 (bin), 170 (dec), AA (hex)
2. Verificare la gerarchia del modulo $display("Current module hierarchy is %m"); → Esempio di output: Current module hierarchy is top.u1.counter
3. Visualizzare il tempo di simulazione $display("Time=%0t: clk=%b", $time, clk); → Esempio di output: Time=100: clk=1

Advanced Display Techniques

• Zero‑padding e larghezza campo Puoi specificare lo zero‑padding o la larghezza del campo come %0d. Esempio: $display("Count=%04d", count); → Output: Count=0012
• Distinzione tra firmato e senza segno %d tratta i valori come firmati, %u li tratta come senza segno. Se un valore negativo non viene visualizzato come previsto, correggi lo specificatore.
• Formattazione di messaggi multilinea Usa n per andare a capo per leggibilità. Esempio: $display("Start of testnSignal A=%bnSignal B=%b", A, B);

Precautions

• Attenzione alla larghezza dei bit: i segnali Verilog possono avere larghezze diverse; usare %d può causare troncamenti o problemi di estensione del segno.
• Gestione dei valori indefiniti (X, Z): se includi bit indefiniti, usare %b visualizzerà direttamente x o z.

5. Esempi pratici: utilizzo di $display in testbench e moduli dei testbench fino al logging di debug condizionale.

Esempio base: output in un testbench

Inserendo $display in un testbench, puoi osservare il comportamento durante la simulazione.

module tb_counter;
  reg clk;
  reg reset;
  wire [3:0] count;

  // DUT (Device Under Test)
  counter uut (
    .clk(clk),
    .reset(reset),
    .count(count)
  );

  // Clock generation
  initial begin
    clk = 0;
    forever #5 clk = ~clk;  // invert every 5 units
  end

  // Test scenario
  initial begin
    reset = 1;
    #10 reset = 0;

    #50 $finish;
  end

  // Display state
  always @(posedge clk) begin
    $display("Time=%0t | reset=%b | count=%d", $time, reset, count);
  end
endmodule

In questo esempio, ogni fronte di salita del clock genera l’output di reset e count. Poiché puoi ispezionare i log di testo così come le forme d’onda, il tracciamento del comportamento diventa più semplice.

Esempio di display condizionale

Combinandolo con istruzioni if puoi registrare solo quando vengono soddisfatte condizioni specifiche.

always @(posedge clk) begin
  if (count == 4'd10) begin
    $display("Count has reached 10 (Time=%0t)", $time);
  end
end

→ Questo ti permette di evitare log superflui mentre individui gli eventi di tuo interesse.

Esempio di messaggio di debug

Durante il debug del progetto è efficace catturare quando un segnale entra in uno “stato inatteso”.

always @(posedge clk) begin
  if (count > 4'd12) begin
    $display("WARNING: count overflow detected! Time=%0t, value=%d", $time, count);
  end
end

→ Puoi scoprire rapidamente difetti di progetto o comportamenti di simulazione inattesi.

Monitorare più segnali insieme

Quando si stampano molti segnali, raccoglierli in un’unica riga usando $display rende i log più leggibili.

$display("Time=%0t | clk=%b | reset=%b | A=%h | B=%h | SUM=%h",
         $time, clk, reset, A, B, SUM);

Riepilogo dei consigli pratici

• Inserisci $display nel testbench per visualizzare il progresso
• Usa rami condizionali per affinare i log
• Genera messaggi di avviso per rilevare anomalie
• Consolida più segnali in una riga per migliorare la leggibilità

6. Applicazioni di controllo display (pixel/testo/immagine)

Finora abbiamo introdotto $display per i log di simulazione. Nel frattempo Verilog è anche ampiamente usato per il “controllo display” nelle implementazioni hardware (LCD, VGA, output HDMI). In questa sezione, introdurremo brevemente come implementare la visualizzazione su schermo a livello hardware.

Concetto fondamentale del controllo display

Per visualizzare testo o immagini su uno schermo, devi generare segnali video anziché semplicemente usare $display. I segnali di controllo tipici includono:

• HSYNC (Horizontal Sync): segnale che indica la fine di ogni riga
• VSYNC (Vertical Sync): segnale che indica la fine di ogni fotogramma
• RGB Data: segnale che rappresenta il colore di ogni pixel (es., 8 bit × 3 = colore a 24 bit)

In Verilog, controlli questi segnali tramite contatori e macchine a stati e li emetti in base al timing per realizzare il “display su schermo”.

Example 1: Displaying Color Bars

L’esempio più semplice consiste nel visualizzare barre di colore orizzontalmente su uno schermo.

always @(posedge clk) begin
  if (h_counter < 100)       rgb <= 24'hFF0000; // red
  else if (h_counter < 200)  rgb <= 24'h00FF00; // green
  else if (h_counter < 300)  rgb <= 24'h0000FF; // blue
  else                       rgb <= 24'h000000; // black
end

→ Questo produce barre di colore rosso, verde e blu allineate orizzontalmente sullo schermo.

Esempio 2: Visualizzazione del Testo

Per la visualizzazione del testo si prepara una ROM dei caratteri e si converte il pattern di punti di ogni carattere in pixel.

// Referencing the pattern of 'A' from the font ROM and displaying
if (font_rom[char_code][y][x] == 1'b1)
    rgb <= 24'hFFFFFF;  // white for display
else
    rgb <= 24'h000000;  // black background

→ Questo disegna un carattere specifico (ad es., “A”) sullo schermo.

Esempio 3: Visualizzazione di Immagini

Per visualizzare un’immagine si legge il bitmap pre‑memorizzato (ROM o memoria esterna) e lo si converte in output di pixel.

rgb <= image_rom[addr];  // Retrieve color data from ROM

Nei sistemi embedded che utilizzano FPGA, questo metodo consente di visualizzare icone o loghi semplici.

Differenza rispetto al debug $display

• $display è output di testo (solo simulazione)
• Il controllo del display è generazione di segnale video (implementabile in hardware)

Sebbene i loro scopi differiscano, gli studenti di Verilog spesso confondono i due.

• “Voglio verificare il comportamento durante la simulazione” → Usa $display
• “Voglio inviare l’output a uno schermo reale su FPGA” → Progetta la logica del segnale video

Espansione delle Applicazioni

• Sui board FPGA per l’apprendimento, Verilog è spesso usato per display a 7 segmenti LED o piccoli display LCD.
• Avanzando ulteriormente, è possibile costruire sistemi che supportano output VGA/HDMI per lo sviluppo di giochi o la visualizzazione di GUI.
• Combinando la conoscenza di $display con la logica di controllo del display, è possibile gestire il “display” sia nella simulazione sia nell’hardware reale.

7. Uso Appropriato e Suggerimenti in Base agli Scenari di Applicazione

Quando parliamo di “display” in Verilog ci sono due aspetti: i task $display solo per simulazione, e il controllo del display nell’implementazione hardware. Usare ciascuno in modo appropriato porta a uno sviluppo e debug efficienti.

Uso nella Simulazione

1. $display come log di debug
   • Outputta variabili o segnali critici con $display per verificare se il tuo progetto si comporta come previsto.
   • Verificare “valori in condizioni specifiche” o “contatore che raggiunge determinati punti” tramite log è efficiente.
2. Evita output eccessivi
   • Outputtare ad ogni ciclo di clock inonda i log e ne riduce la leggibilità. Restringi le condizioni.
   • Esempio: if (state == ERROR) $display("Errore verificato a %0t", $time);
3. Differenzia tra i task
   • $monitor → Per i segnali che desideri monitorare continuamente
   • $strobe → Quando hai bisogno di outputtare valori stabilizzati
   • $write → Per output orizzontale formattato

Uso nel Controllo del Display Hardware

1. Display a 7 segmenti per l’apprendimento
   • Nei progetti FPGA per principianti, visualizzare il valore di un contatore su un LED a 7 segmenti è standard.
   • Combinalo con l’output di simulazione $display per approfondire la comprensione della differenza tra display e simulazione.
2. Controllo di monitor LCD o VGA
   • Usa ROM dei caratteri o ROM di immagini per visualizzare testo o immagine.
   • Utilizzando anche $display nella simulazione puoi verificare doppie volte che la generazione del segnale video sia corretta.
3. Overlay di debug in hardware
   • Puoi sovrapporre “valore del contatore”, “coordinate”, “messaggi di debug” sull’output video reale.
   • Nello sviluppo FPGA è comune “rendere lo schermo stesso uno strumento di debug”.

Suggerimenti Pratici

• Segui simulazione → flusso hardware Prima usa $display per verificare il comportamento in simulazione, poi passa alla logica di controllo del display per l’implementazione hardware.
• Usa log e forme d’onda in tandem I log testuali da $display indicano “tempistica dell’evento”, mentre le forme d’onda mostrano “transizioni dettagliate”. Usarli entrambi aumenta la precisione del debug.
• Uniforma il formato dei messaggi nello sviluppo di squadra Standardizzare il formato dei messaggi $display (prefisso, visualizzazione del tempo, ecc.) rende più facile l’analisi dei log quando più persone lavorano insieme.

Sommario

• I task di tipo $display sono strumenti di “osservazione” solo per simulazione
• Il controllo del display indica l’implementazione hardware “metodo di visualizzazione”
• Usandoli appropriatamente e combinandoli è possibile abilitare uno sviluppo efficiente

8. FAQ (Domande Frequenti)

Q1. Qual è la differenza tra $display e $monitor?

A. $display stampa una volta al momento in cui viene chiamato. Al contrario, $monitor stampa automaticamente ogni volta che un segnale registrato cambia.

• Per debug una tantum → $display
• Per monitoraggio continuo → $monitor

Q2. Quando dovrei usare $strobe?

A. $strobe stampa il valore stabilizzato alla fine di un ciclo di simulazione. Per esempio, quando più segnali cambiano simultaneamente su un fronte di clock, $display potrebbe mostrare valori intermedi. In tali casi $strobe è comodo per mostrare i valori finali.

Q3. Qual è l’uso del specificatore di formato %m?

A. %m stampa il nome della gerarchia del modulo corrente. In progetti grandi, registrare “da quale gerarchia proviene il messaggio” rende l’analisi molto più semplice.

$display("Current module: %m");

Esempio di output:

Current module: top.u1.counter

Q4. I miei log sono diventati enormi perché ho usato molti $display. Cosa devo fare?

A. Le seguenti misure sono efficaci:

• Usa istruzioni if per filtrare l’output
• Stampa solo il rilevamento di errori o eventi specifici
• Usa $monitor per osservare solo i segnali minimi necessari
• Scrivi su un file di log e applica strumenti di filtraggio durante l’analisi

Q5. $display può essere usato per la sintesi (FPGA/ASIC)?

A. No. $display è strettamente un compito solo per simulazione. Gli strumenti di sintesi lo ignorano, quindi non si riflette nell’hardware reale. Se vuoi visualizzare l’output su hardware reale devi progettare con “LED a 7 segmenti”, “LCD”, “logica di controllo VGA”, ecc., in Verilog.

Q6. Come visualizzo testo o immagini su hardware reale?

A. Non tramite $display, ma generando segnali video.

• Display a 7 segmenti → Per visualizzare numeri o caratteri semplici
• VGA/LCD → Genera segnali HSYNC, VSYNC, RGB e li controlla
• Testo → Usa ROM dei caratteri e genera pattern di punti
• Immagini → Memorizza bitmap in ROM o memoria esterna e genera i pixel di conseguenza

9. Conclusione & Prossimi Passi

Sommario di questo articolo

In questo articolo abbiamo trattato il “display” in Verilog dalle basi alle applicazioni. I punti chiave includono:

1. Nozioni di base di $display
   • Un compito di simulazione che visualizza segnali o variabili, utilizzabile in modo simile al printf di C.
2. Differenze con i compiti correlati
   • $write → Visualizza senza newline
   • $strobe → Stampa i valori stabilizzati alla fine del ciclo di simulazione
   • $monitor → Monitora automaticamente i cambiamenti di segnale
3. Uso dei specificatori di formato
   • Usando %b, %d, %h, %m, %t, puoi generare log più chiari e pratici.
4. Esempi pratici
   • Inserisci $display nei test bench per monitorare il progresso.
   • Usa messaggi condizionali per abilitare un debug efficiente.
5. Applicazioni nel controllo del display
   • $display è solo per simulazione; l’implementazione hardware utilizza HSYNC, VSYNC, RGB per output di testo/immagine.
   • Dall’apprendimento del display a 7 segmenti al controllo avanzato VGA/HDMI, sono possibili espansioni.

Prossimi Passi

• Passa a SystemVerilog → Nel linguaggio successivo SystemVerilog puoi utilizzare funzionalità di debug più avanzate (assertion, $display migliorato, ecc.).
• Combina con il visualizzatore di forme d’onda → Combinando i log di $display con i dati delle forme d’onda puoi analizzare sia i valori numerici sia le transizioni, aumentando la precisione del debug.
• Impara l’output hardware del display → In un piccolo progetto su scheda FPGA prova a visualizzare su display a 7 segmenti o LCD per sperimentare la differenza tra “display di simulazione” e “controllo hardware del display”.
• Applica nello sviluppo di squadra → Standardizzando il formato dei messaggi $display migliori l’efficienza dell’analisi dei log nello sviluppo con più persone.

In conclusione

$display è più di un semplice “output di testo”. È uno strumento potente per il debug della simulazione. E quando ti avventuri nel mondo del controllo del display, puoi provare la gioia di mostrare grafica su monitor reali tramite FPGA.
Spero che questo articolo aiuti gli studenti di Verilog a comprendere chiaramente sia il “debug della simulazione” sia l’“output hardware del display”.