Problema con simulazione con ModelSim

[Raeiu991]

Buongiorno a tutti. Ho un problema con ModelSim che non riesco a capire. Premetto che sto usando la versione senza licenza di ModelSim.

Lascio l'immagine del dataflow del progetto su cui sto lavorando.

Come vedete il segnale DataTest_dut non riceve nessuna informazione mentre a sinistra ho un valore (0001) se vado a cliccare su line__1026 mi ritrovo questa assegnazione nel file di netlist generato da Quartus che sto usando per la simulazione gatelevel:

DataTest <= ww_DataTest;

Questa è l'assegnazione.

ww_DataTest è un segnale interno del DUT e da questa assegnazione i valori devono passare al valore DataTest del DUT che poi deve essere letto dal test bench tramite il segnale DataTest_dut.

La cosa che non riesco a capire è il motivo per il quale DataTest non riesce a ricevere nessun valore da ww_DataTest. Non credo che sia un problema di mapping anche perché l'assegnazione è stata fatta durante la fase di sintesi e implementazione di Quartus.

Questo inoltre è l'unico segnale che mi da questo problema.

PS. Usando un test bench più semplice questo problema non c'è quindi mi viene da pensare che sia una limitazione della versione free di modelsim.

[gvee]

Come vedete il segnale DataTest_dut non riceve nessuna informazione (...) ww_DataTest è un segnale interno del DUT e da questa assegnazione i valori devono passare al valore DataTest del DUT che poi deve essere letto dal test bench tramite il segnale DataTest_dut.

Ma DataTest_dut è un input o output? Dallo screenshot sembra un input, ma dalla descrizione che dai a me sembra che sia un output. Se ho capito male problema mio.

[Raeiu991]

Ciao. Nel testbench DataTest_dut è dichiarato come:

signal DataTest_dut : std_logic_vector (3 downto 0); -- uscite per test

In pratica è il segnale del testbench che deve leggere il valore dal DUT.
Capisco la confusione: ho chiamato i segnali del testbench che leggono o scrivono sul DUT come "signal"_dut per dire che legge/scrive sul DUT. Appena capisco questo problema aggiorno i nomi.

[gvee]

Se il disegno è complesso e per motivi professionali non puoi postarne il contenuto, cerca di riprodurre il problema con un disegno semplificato e continua da li, altrimenti devi dare più informazioni.

Con le poche informazioni che dai è impossible dire altro.

[Raeiu991]

Non riesco a mettere un immagine più esaustiva perché la versione di ModelSim che ho non me lo permette. Cercherò di fare uno spiegone aggiungendo porzioni di codice dell'ambiente di simulazione che ho creato. Il problema credo che sia nell'ambiente di simulazione perché usando un testbench più semplice il problema non esiste.

Dal principio: ho compilato su Quartus il progetto e generato i files .vho e .sdo necessari per la simulazione gate level.
Un altro dettaglio importate e che i valori vengono assegnati a DataTest in maniera concorrente. DataTest è definito come out nella top entity e nel file vho che uso per la simulazione.

Ho creato un ambiente di simulazione che utilizza alcune funzioni/process del framework UVVM. Ho strutturato il tutto come segue:

Per ogni componente ho creato tre pkg. Type, Sequencer e BFM. Questi tre pkg sono su 3 livelli di astrazione diversi e vanno rispettivamente dal livello più alto a quello più basso.

N.B: i tipi definit come t_uart_nome vengono definti nel pkg type in base al segnale (in genere std_logic o std_logic_vector)

Il pkg type definisce le strutture dati necessarie per la rappresentazioni delle operazioni del componente:

Codice: Seleziona tutto

type t_uart_transaction_kind is (
    UART_RX,
    UART_TX,
    DATA_TEST_UART
  );

In questo pkg viene definito un record che incapsula le informazioni relative a una singola transazione:

Codice: Seleziona tutto

type t_uart_transaction is record
    kind              : t_uart_transaction_kind;
    baud              : t_uart_baud;
    rxD_ser           : t_uart_rxD_ser;
    txD_ser           : t_uart_txD_ser;
    expected_txD_ser  : t_uart_txD_ser;
    clk_cycle         : integer;
    DataTest          : t_uart_DataTest;
    expected_DataTest : t_uart_DataTest;
    msg_id            : t_msg_id;
    messaggio               : string(1 to C_STANDARD_MSG_LENGTH);
  end record;

il pkg bfm definisce delle strutture dati necessarie per rappresentare le operazioni del componente:

Codice: Seleziona tutto

procedure DataTest_uart(
    signal DataTest   : in t_uart_DataTest;  --è definito in perché deve leggere i dati
    expected_DataTest : in t_uart_DataTest
  ) is

  begin

    check_value( --procedura di UVVM: si occupa di confrontare DataTest letto con un valore atteso
    DataTest,
    expected_DataTest,
    messaggio => pad_string("DataTest status: " & to_string(DataTest) & " (expected: " & to_string(expected_DataTest) & ")", C_STANDARD_MSG_LENGTH)
    );

infine il pkg sequencer orchestra le operazioni chiamando le appropriate procedure BFM in base al tipo di transazione richiesta.

Codice: Seleziona tutto

procedure uart_do_transaction (
    signal baud      : out t_uart_baud;
    signal rxD_ser   : out t_uart_rxD_ser;
    signal txD_ser   : in  t_uart_txD_ser;
    signal DataTest : in  t_uart_DataTest;
    transaction_in   : in  t_uart_transaction
  ) is

  begin

    log(transaction_in.msg_id, "SEQUENCER: Executing transaction: " & transaction_in.messaggio, "uart_Sequencer");

    case transaction_in.kind is

      ...

      when DATA_TEST_UART =>
        DataTest_uart(
        DataTest          => DataTest,
        expected_DataTest => transaction_in.expected_DataTest
        );

Il test vero e proprio è definito come segue:

Codice: Seleziona tutto



...
variable v_transaction_req_uart    : t_uart_transaction;

begin

...

v_transaction_req_uart := init_uart_transaction(
                              kind               => DATA_TEST_UART,
                              baud               => "000",
                              rxD_ser            => '1',
                              clk_cycle          => 1,
                              expected_DataTest  => "0001",
                              messaggio                => pad_string("\nChecking Data test value: ", C_STANDARD_MSG_LENGTH)
                              );
    uart_do_transaction(
    Baud_rate_dut, rxD_ser_dut, txD_ser_dut, DataTest_dut, v_transaction_req_uart
    );

N.B: in questo caso baud, rxD_ser e clk_cycle non sono necessari per effettuare il check di DataTest. Devo inserirli perché se no avrei degli errori di compilazione. In futuro creerò una "transazione" dedicata

Con init_uart_transaction definita come segue:

Codice: Seleziona tutto

--Funzione di utilità per creare un record t_uart_transaction
  function init_uart_transaction(
    kind              : t_uart_transaction_kind;
    baud              : t_uart_baud    := (others => '0');
    rxD_ser           : t_uart_rxD_ser := '0';
    txD_ser           : t_uart_txD_ser := '0';
    expected_txD_ser  : t_uart_txD_ser := '0';
    clk_cycle         : integer;
    DataTest          : t_uart_DataTest                       := (others => 'Z');
    expected_DataTest : t_uart_DataTest                       := (others => 'Z');
    msg_id            : t_msg_id                              := ID_SEQUENCER;
    messaggio               : in string(1 to C_STANDARD_MSG_LENGTH) := (others => ' ')
  ) return t_uart_transaction;

Viene creata la transizione init_uart_transaction che va a popolare la variabile v_transaction_req_uart e viene eseguita la transazione (uart_do_transaction).
Questo è l'esempio di un testcase che viene definito come pkg che poi viene richiamato dal testbench.

Nel testbench dichiaro come componente la top entity da testare, dichiaro i segnali del testbench (in questo caso i segnali_dut), mappo i segnali e dopo definisco il processo principale che esegue i testcase:

Codice: Seleziona tutto

component wsp_aux is
    port (
      ...
      -- Other signals
      DataTest          : out   std_logic_vector (3 downto 0);   

  end component wsp_aux;

....

signal Baud_rate_dut         : std_logic_vector (2 downto 0);

begin

i_wsp_aux : wsp_aux
  port map(
    ...
    DataTest          => DataTest_dut,
    ...

  );



Codice: Seleziona tutto

when C_IT_INT_022 =>
        log(ID_LOG_HDR_XL, "Starting IT_INT_022", "C_HEADER");
        IT_INT_022 (GClk_dut, GReset_dut, B_Life_dut, addr_slot_dut, addr10_dut, addr_low_dut, DataG2_dut, B_AS0n_dut, B_RWn_dut, B_Dack0n_dut, Bd_en_dut, RxD_Ser_dut, TxD_Ser_dut, DataTest_dut, Baud_rate_dut);
        log(ID_LOG_HDR_XL, "Finished IT_INT_022", "C_HEADER");

Questo è come funziona il tutto.

Ho caricato anche un'immagine modificata di quella precedente. Il problema è che ww_DataTest che è un senale interno al DUT riceve informazioni, in simulazione vedo i valori ma non li passa a DataTest (pin del DUT). Internamente funziona tutto anche i registri da cui DataTest riceve i valori.

[gvee]

Hai provato senza la verificazione tramite UVM (per la quale non posso aiutare molto) ?
Voglio dire, con un semplice testbench.

[Raeiu991]

A dire il vero il testbench che usano in azienda (quello semplice) funziona. Sostanzialmente fa la stessa cosa del mio solo che invece di leggere gli input e gli output dal codice li legge da un csv. Su questo testbench è definita una sola libreria con delle procedure che servono al testbench (semplicemente lettura scrittura e confronto e altre cose minori per il logging). Ora che ci penso una differenza tra i due è lo script usato per lanciare la simulazione. In quello aziendale uso lo script .do generato da quartus:

Codice: Seleziona tutto

transcript on
if {[file exists gate_work]} {
   vdel -lib gate_work -all
}
vlib gate_work
vmap work gate_work

vcom -93 -work work {wsp_aux.vho}

vcom -93 -work work {testbench_utils.vhd}
vcom -93 -work work {Testbench.vhd}

vsim -t 1ps +transport_int_delays +transport_path_delays -sdftyp /DUT=wsp_aux_vhd.sdo -L altera -L cycloneive -L gate_work -L work -voptargs="+acc"  testbench

#view structure
#view signals


#run -all

Mentre io ho fatto uno script un po' più complesso in tcl. Ci sono due file:

Compilazione

Codice: Seleziona tutto

####################### CREAZIONE DEI PATH #######################
#-----------------------------------------------------------------
# In questa sezione si creano i path dei source da compilare e
# i percorsi degli script necessari per la compilazione dei PKG
# del progetto.
#-----------------------------------------------------------------

    # Definisce la directory dove risiede UVVM-master.
    set UVVM_MASTER_DIR {../UVVM-master}

    # Definisce la directory dove verranno create le librerie compilate del progetto e di UVVM.
    set TARGET_DIR {../sim}

    #Setting del path common
    set COMMON_SRC {../common}

    #CSetting del path agents
    set AGENTS_SRC {../agents}

    #Setting del path tests
    set TESTCASES_SRC {../tests}

    #Setting del path src
    set SURCE_SRC {../src}

    #Setting del path tb
    set TESTBENCH_SRC {../tb}

    # Definisce la directory contente gli script necessari per la compilazione dei PKG
    set SCRIPT_PATH {../script}
    set COMPILE_PATH_SCRIPT [file join $SCRIPT_PATH my_path_script.tcl]

##################################################################

##################### PULIZIA DELLE LIBRERIE #####################
#-----------------------------------------------------------------
# in questa sezione vengono eliminate le cartelle delle librerie
# contenute in ../sim ad ogni compilazione per poi essere ricreate.
# N.B: In LIB_SUBDIRS vanno inseriti nomi delle librerie del progetto
# che devono essere eliminate
#-----------------------------------------------------------------

    echo "\n--- Eliminazione delle directory delle librerie all'interno di $TARGET_DIR ---\n"

    # Definisci una lista delle sottocartelle delle librerie che vuoi eliminare
    set LIB_SUBDIRS {uvvm_util work common gemini2 analog_in speed_in testcases ser2par uart}

    foreach LIB_NAME $LIB_SUBDIRS {
        set LIB_PATH [file join $TARGET_DIR $LIB_NAME]
        if {[file exists $LIB_PATH] && [file isdirectory $LIB_PATH]} {
            echo "Cancellazione directory libreria: $LIB_PATH"
            # Usa 'catch' per gestire eventuali errori di cancellazione (es. cartella bloccata)
            catch {file delete -force -- $LIB_PATH} RESULT
            if {$RESULT ne ""} {
                puts "ATTENZIONE: Errore durante la cancellazione di $LIB_PATH: $RESULT"
            }
        } else {
            echo "Directory libreria non trovata o non è una directory: $LIB_PATH"
        }
    }

##################################################################

#################### CREAZIONE DELLE LIBRERIE ####################
#-----------------------------------------------------------------
# In questa sezione vengono create e mappate le librerie del progetto
#-----------------------------------------------------------------

    echo "\n--- Creazione e mappatura delle librerie ---\n"

    vlib [file join $TARGET_DIR uvvm_util]
    vmap uvvm_util [file join $TARGET_DIR uvvm_util]

    vlib [file join $TARGET_DIR work]
    vmap work [file join $TARGET_DIR work]

    vlib [file join $TARGET_DIR common]
    vmap common [file join $TARGET_DIR common]

    vlib [file join $TARGET_DIR uart]
    vmap uart [file join $TARGET_DIR uart]

    vlib [file join $TARGET_DIR ser2par]
    vmap ser2par [file join $TARGET_DIR ser2par]

    vlib [file join $TARGET_DIR gemini2]
    vmap gemini2 [file join $TARGET_DIR gemini2]

    vlib [file join $TARGET_DIR analog_in]
    vmap analog_in [file join $TARGET_DIR analog_in]

    vlib [file join $TARGET_DIR speed_in]
    vmap speed_in [file join $TARGET_DIR speed_in]

    vlib [file join $TARGET_DIR testcases]
    vmap testcases [file join $TARGET_DIR testcases]

##################################################################

################ COMPILAZIONE DELLA LIBRERIA UVVM ################

    echo "\n--- Compilazione della UVVM_Library ---\n"

    set UVVM_COMPILE_SCRIPT_PATH_UTIL [file join $UVVM_MASTER_DIR uvvm_util script compile_src.do]
    set UVVM_SOURCE_PATH_UTIL [file join $UVVM_MASTER_DIR uvvm_util]
    set UVVM_OUTPUT_LIB_PATH_UTIL [file join $TARGET_DIR]

    # Esegue il comando 'do' usando 'eval' e 'list' per garantire la corretta espansione
    # 'list' assicura che ogni percorso sia trattato come un singolo argomento
    # 'eval' forza ModelSim a valutare la stringa come un comando Tcl
    eval do [list $UVVM_COMPILE_SCRIPT_PATH_UTIL] [list $UVVM_SOURCE_PATH_UTIL] [list $UVVM_OUTPUT_LIB_PATH_UTIL]

##################################################################

################### COMPILAZIONE DEI COMMON PKG ##################
# ----------------------------------------------------------------
# In questa sezione vengono compilati i common pkg
#-----------------------------------------------------------------

    echo "\n--- Compilazione dei common pkg ---\n"
   
    eval do [list $COMPILE_PATH_SCRIPT] [list $COMMON_SRC] [list $TARGET_DIR]


##################################################################

##################### COMPILAZIONE DEGLI AGENT ###################
# ----------------------------------------------------------------
# In questa sezione vengono compilati gli agent di progetto.
#-----------------------------------------------------------------

    echo "--- Compilazione degli Agent ---\n"

    echo "--- Compilazione agent gemini2 ---\n"
    set SOURCE_PATH_GEMINI2 [file join $AGENTS_SRC gemini2]
   
    eval do [list $COMPILE_PATH_SCRIPT] [list $SOURCE_PATH_GEMINI2] [list $TARGET_DIR]

    echo "--- Compilazione agent uart ---\n"
    set SOURCE_PATH_UART [file join $AGENTS_SRC uart]
   
    eval do [list $COMPILE_PATH_SCRIPT] [list $SOURCE_PATH_UART] [list $TARGET_DIR]

    echo "--- Compilazione agent ser2par ---\n"
    set SOURCE_PATH_SER2PAR [file join $AGENTS_SRC ser2par]
   
    eval do [list $COMPILE_PATH_SCRIPT] [list $SOURCE_PATH_SER2PAR] [list $TARGET_DIR]

    echo "--- Compilazione agent analog_in ---\n"
    set SOURCE_PATH_ANALOG_IN [file join $AGENTS_SRC analog_in]

    eval do [list $COMPILE_PATH_SCRIPT] [list $SOURCE_PATH_ANALOG_IN] [list $TARGET_DIR]

    echo "--- Compilazione agent speed_in ---\n"
    set SOURCE_PATH_SPEED_IN [file join $AGENTS_SRC speed_in]

    eval do [list $COMPILE_PATH_SCRIPT] [list $SOURCE_PATH_SPEED_IN] [list $TARGET_DIR]


##################################################################

#################### COMPILAZIONE DEI TESTCASES ##################
# ----------------------------------------------------------------
# In questa sezione vengono compilati i testcases.
#-----------------------------------------------------------------

    echo "--- Compilazione dei testcases ---\n"
    set SOURCE_PATH_TESTS [file join $TESTCASES_SRC]

    eval do [list $COMPILE_PATH_SCRIPT] [list $SOURCE_PATH_TESTS] [list $TARGET_DIR]

##################################################################

################## COMPILAZIONE DUT & TB #########################

    echo "--- Compilazione del DUT ---\n"
    set SOURCE_PATH_DUT [file join $SURCE_SRC]

    eval do [list $COMPILE_PATH_SCRIPT] [list $SOURCE_PATH_DUT] [list $TARGET_DIR]

    echo "--- Compilazione del testbench ---\n"
    set SOURCE_PATH_TB [file join $TESTBENCH_SRC]

    eval do [list $COMPILE_PATH_SCRIPT] [list $SOURCE_PATH_TB] [list $TARGET_DIR]

##################################################################


echo "-------------------------------------------------------"
echo "Compilation complete"
echo "-------------------------------------------------------"


Run

Codice: Seleziona tutto

######################### CARICARE IL PROGETTO COMPILATO ##################################
# -----------------------------------------------------------------------------------------
# Caricare il testbench per la simulazione
#------------------------------------------------------------------------------------------
echo "--------------------------------------------------------"
echo "  Avvio della simulazione per WSP_AUX Testbench"
echo "--------------------------------------------------------"

# Definisci il nome del file di selezione del testcase
set TESTCASE_FILE "testcase_selection.txt"

# Verifica se il file esiste
if {![file exists $TESTCASE_FILE]} {
    puts "ERRORE: Il file di selezione del testcase non trovato: $TESTCASE_FILE"
    exit 1
}

# Apri il file in modalità lettura
set file_to_open [open $TESTCASE_FILE r]
# Leggi la prima riga del file (il nome del testcase)
set SELECTED_TESTCASE [gets $file_to_open]
# Chiudi il file
close $file_to_open

# Rimuovi eventuali spazi bianchi (whitespace) dalla stringa letta
set SELECTED_TESTCASE [string trim $SELECTED_TESTCASE]

# Stampa a console il testcase selezionato (opzionale, per debug)
echo "Testcase selezionato: $TESTCASE_FILE: $SELECTED_TESTCASE"


# Simula l'entità di testbench top-level 'wsp_aux_tb'
# -sdftyp /path/to/DUT_instance=path/to/sdf_file: specifica l'annotazione SDF
# Costruisce il comando vsim usando il testcase letto dal file
vsim -t 1ps work.wsp_aux_tb -sdftyp /wsp_aux_tb/i_wsp_aux=../sdf/wsp_aux_vhd.sdo -gTEST_CASE="$SELECTED_TESTCASE"





############################################################################################

######################## IMPOSTAZIONE DELLE WAVE ###########################################
# -----------------------------------------------------------------------------------------
# Imposta forme d'onda (facoltativo ma consigliato)
#
# Aggiungi segnali alla finestra delle forme d'onda per l'ispezione
# -----------------------------------------------------------------------------------------
if [winfo exists .main_pane.wave] {
    delete wave *
}

do wave.do
# ----------------------------------------------------------------------------------------
# Aggiunge segnali interni specifici del DUT se desideri ispezionarli
# wave -radix esadecimale /wsp_aux_tb/i_wsp_aux/<qualche_segnale_interno>
# ----------------------------------------------------------------------------------------

###########################################################################################

########################## ESECUZIONE DEL TEST ############################################
run -all

echo "--------------------------------------------------------"
echo "  Simulazione finita!"
echo "--------------------------------------------------------"

##########################################################################################


I file vho e sdo sono gli stessi in entrambi i casi.

Non sono un espertissimo di tcl quindi non so se possa esserci un qualche problema qui

[gvee]

A dire il vero il testbench che usano in azienda (quello semplice) funziona.

Bene, è già un indizio che il problema non sembra essere nel DUT, ma nel TB e/o ambiente di verificazione UVM.

Sostanzialmente fa la stessa cosa del mio solo che invece di leggere gli input e gli output dal codice li legge da un csv.

Non conosco librerie di file I/O in VHDL (uso principalmente solo Verilog o System Verilog). Sicuro che il problema non sia relazionato con la lettura CSV?

[Raeiu991]

Si sono sicuro. Se ci fosse un problema del genere mi sarei aspettato più segnali non definiti. Nella simulazione con il mio testbench quel segnale è l'unico che mi da problemi. I restanti segnali che si vedono nell'immagine funzionano tutti e sono stati mappati come ho mappata DataTest.

[Raeiu991]

Ritorno con 2 novità.
La prima: se dichiaro BUFFER sul file vho DataTest, invece che OUT, l'assegnazione DataTest <= ww_DataTest viene eseguita ma non ho la propagazione del segnale su DataTest_dut. Il segnale su DataTest_dut risulta essere sempre undefined.
La seconda cosa: (lo so che è sbagliato) se inizializzo DataTest_dut nel testbench l'assegnazione DataTest <= ww_DataTest viene eseguita e su DataTest_dut vedo il valore inizializzato. Quando il segnale cambia a questo punto mi ritrovo in uscita XXXX. (questo anche se DataTest lo lascio dichiarato come OUT)

Nella top entity le assegnazioni di DataTest sono queste:

Codice: Seleziona tutto

DataTest(0)  <= DataTx(0);
DataTest(1)  <= DataTx(1);
DataTest(2)  <= DataTx(2);
DataTest(3)  <= IntRxn;

Magari dico una stupidaggine ma essendo che DataTest riceve i dati da due driver diversi ModelSim non riesce ad elaborare l'assegnazione? Anche se a questo punto mi aspetterei comunque un errore di compilazione.

Aggiungo un'altra cosa che magari può aiutare:

Il testbench che legge dati dal csv funziona in questo modo (mi focalizzo solo su DataTest):

- Legge il valore di DataTest sul CSV e lo salva in una variabile vDataTest.
- Si attende un ciclo di clock.
- Viene scritto il valore reale di DataTest su una variabile myDataTest.
- Vengono comparati myDataTest e vDataTest.

Resto a disposizione per ulteriori dettagli nel caso