Simulation in ISE

[Andreas Ehret (Gast)]

Hallo,

da ich mit der Simulation bzw. der korrekten Erzeugung eines Testbenchs
immer Schwierigkeiten hatte, habe ich versucht, eine Funkuhr ohne
Simulation zu programmieren.

Zum Testen habe ich anhand mehrerer LEDs den Zustand der einzelnen
Module überwacht. Allerdings ist der Code jetzt doch relativ
umfangreich geworden, abgesehen davon habe ich Schwierigkeiten mit der
Auswertung.

Deswegen werde ich um eine richtige Simulation wohl nicht herum kommen.
Zu meiner Frage:

Wenn ich ein Testbench Waveform in ISE erstelle, habe ich ja nur
eingeschränkte Möglichkeiten.
Wie kann ich sinnvoll ein TB erstellen? Müsste ich das von Hand
schreiben? Und, wie macht man das, dass man bestimmte Teile des
Programms so schreibt, dass Sie nur für den Simulator sichtbar sind,
und andere Teile, dass Sie nur für die Synthese sichtbar sind?
Das wäre besonders für meine Taktteilungen wichtig, da ich das
DCF-Signal mit 1 kHz abtaste, dies jedoch in der Simulation aufgrund
der Auslastung Unfug wäre.
Und ich will mir nicht jedes Mal neu überlegen, wie ich die Werte für
die Taktteilung und Auswertung ändern muss, wenn ich nur simulieren
möchte.

Viele Grüße
   Andy

[TheMason (Gast)]

bestimmte teile kann man z.b. mit --pragma synthesis on/off für die
synthese ein und ausschalten soweit ich weiß.
die genauen pragmas und wie diese für ise bzw. modelsim lauten weiß ich
nicht genau. müsste aber irgendwo in dem pdf-dschungel etwas zu finden
sein.

generell wirst du um eine simulation mit tb nicht drum herumkommen.
hab im moment dasselbe problem. nur bei mir ists noch etwas
grundlegender (kann z.b. keine instanziierten komponenten vernünftig
simulieren).

wenn du den dcf mit 1 khz tastest kannst du doch einfach die auflösung
der tb ändern. müsste unter modelsim bei den projekteinstellungen
stehen. du brauchst ja keine pico-sekunden. kannst den ja einfach auf
us stellen und dann geht die simulation auch deutlich fixer.

tbs werden eigentlich immer von hand geschrieben.
bei der simulation hat man dann auch die ganzen möglichkeiten die sich
in der hardware nicht synthetisieren lassen (dateien, gleitkommazahlen,
prozeduren, wait anweisungen usw)

[Zeeshan K. (Firma: rwth) (zeeshan)]

Hi,
I want to simulate a CAN softcore written in Verilog, using ISE 
Simulator.
I know how to construct an input signal by constructing the waveform 
provided by ISE simulator, however this method is not very efficient if 
one wants to give a long bit sequence as input (I am talking about over 
a 50 messages, each containing about 100 bits). However, it can be very 
easily done if i can give an input signal using an input file or 
something similar, in which i can list the input bytes and corresponding 
timings or something similar.
I currently dont know of such a method and will highly appreciate if 
someone can guide me about it.
Thanks and regards,
Zeeshan

[Nephilim (Gast)]

in der Testbench kannst du wie im folgenden Beispiel Files einbinden 
woraus dann die Inputs eingelesen werden können.

file Input_Signal_Name: text open read_mode is"textfile.txt";

[Zeeshan (Gast)]

The suggested command was:

file Input_Signal_Name: text open read_mode is"textfile.txt";

I wrote the following command in the Tcl Shell Window:

file rd_i: text open read_mode is"inputfile.txt";

(assuming I should write the name of the input signal in place of 
'Input_Signal_Name' and name of the input text file in place of 
"textfile.txt")

the response I get is:

bad option "rd_i:": must be atime, attributes, channels, copy, delete, 
dirname, executable, exists, extension, isdirectory, isfile, join, link, 
lstat, mtime, mkdir, nativename, normalize, owned, pathtype, readable, 
readlink, rename, rootname, separator, size, split, stat, system, tail, 
type, volumes, or writable

What am I doing wrong here ? How should I do it correctly ?
I have already tried to search for the "file" command, but couldn't find 
anything helpful.

Thanks.

[Nephilim (Gast)]

write the following line direct into the architecture of the 
VHDL-testbench file. not in a TCL-script.

file Input_Signal_Name: text open read_mode is"textfile.txt";

with commands like "read" or "readline" can you read from the file.

[Zeeshan K. (Firma: rwth) (zeeshan)]

Can you point to some reading/help material, which lists and explains 
the commands (like the "read" and "readline" mentioned by you) related 
to VHDL Testbench file programming.
Thanks again.

[Nephilim (Gast)]

i have found these commands in an automatic generated testbench were all 
stimuli and results are in external ascii-files.

the important parts of the testbench are following:

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use std.textio.all;
use IEEE.std_logic_textio.all;

entity test_InvPend is
end test_InvPend;

architecture beh of test_InvPend is

component InvPend
port (
  clk : in std_logic;
  GlobalReset : in std_logic;
  GlobalEnable1 : in std_logic;
  Control_Synplify_Port_In : in std_logic_vector(15 downto 0); 
  Control_Synplify_Port_In1 : in std_logic_vector(15 downto 0);
  Control_Synplify_Port_In2 : in std_logic_vector(15 downto 0);
  Control_Synplify_Port_Out : out std_logic_vector(15 downto 0)
);
--
end component; 
.
.
.
file logFile: text open write_mode is"simlog.txt";
file Control_Synplify_Port_InFile: text open read_mode is"Inport_InvPend_Control_Synplify_Port_In.dat";
file Control_Synplify_Port_In1File: text open read_mode is"Inport_InvPend_Control_Synplify_Port_In1.dat";
file Control_Synplify_Port_In2File: text open read_mode is"Inport_InvPend_Control_Synplify_Port_In2.dat";
file Control_Synplify_Port_OutRefFile: text open read_mode is"Outport_InvPend_Control_Synplify_Port_Out.dat";
file Control_Synplify_Port_OutOutFile: text open write_mode is"Simout_InvPend_Control_Synplify_Port_Out.dat";
.
.
.
.
-- Apply Input Vectors -----
  if (rising_edge(clk_int)) then
    if (isNotFirstRise1) then
      if (endfile(Control_Synplify_Port_InFile)) then
        isSimulationEnd1 <= true;
      else 
        readline(Control_Synplify_Port_InFile, VectorLine);
        read(VectorLine, tmp_Control_Synplify_Port_In, good => VectorValid);
        Control_Synplify_Port_In_int <= tmp_Control_Synplify_Port_In;
      end if;
    end if;
    if (isNotFirstRise1) then
      if (endfile(Control_Synplify_Port_In1File)) then
        isSimulationEnd1 <= true;
      else 
        readline(Control_Synplify_Port_In1File, VectorLine);
        read(VectorLine, tmp_Control_Synplify_Port_In1, good => VectorValid);
        Control_Synplify_Port_In1_int <= tmp_Control_Synplify_Port_In1;
      end if;
    end if;
    if (isNotFirstRise1) then
      if (endfile(Control_Synplify_Port_In2File)) then
        isSimulationEnd1 <= true;
      else 
        readline(Control_Synplify_Port_In2File, VectorLine);
        read(VectorLine, tmp_Control_Synplify_Port_In2, good => VectorValid);
        Control_Synplify_Port_In2_int <= tmp_Control_Synplify_Port_In2;
      end if;
    end if;
  end if;
if (rising_edge(clk_int) and (GlobalReset_int='0'))then
    if(loop_cnt1 >= 0) then
      if (endfile(Control_Synplify_Port_OutRefFile)) then
        isSimulationEnd1 <= true;
      else 
        readline(Control_Synplify_Port_OutRefFile, VectorLine);
        read(VectorLine, ref_Control_Synplify_Port_Out, good => VectorValid);

        tmp_Control_Synplify_Port_Out := Control_Synplify_Port_Out_int;

        write(OutLine, tmp_Control_Synplify_Port_Out);
        writeline(Control_Synplify_Port_OutOutFile, OutLine);

      end if;
      if(not(tmp_Control_Synplify_Port_Out = ref_Control_Synplify_Port_Out)) then
        misFlg := TRUE;
        write(OutLine, string'("Vector failed for port: Control_Synplify_Port_Out"));        writeline(logFile, OutLine);
        write(OutLine, string'("Expecting: "));        write(OutLine, ref_Control_Synplify_Port_Out);        writeline(logFile, OutLine);
        write(OutLine, string'("Actual:    "));        write(OutLine, tmp_Control_Synplify_Port_Out);        writeline(logFile, OutLine);
      end if;

      if(misFlg) then
        mismatch1 <= mismatch1 + 1;
        write(OutLine,  string'("Mismatch at clk cycle no "));
        write(OutLine, loop_cnt1);
        writeline(logFile, OutLine);
        write(OutLine, string'("-----------------------------"));
        writeline(logFile, OutLine);
      end if;
    end if;

    loop_cnt1 <= loop_cnt1 + 1;
  end if;
    end process;

i hope the code will help. i have no other material at the moment. look 
at the libraries. for these commands you need the std.textio library.

[Zeeshan K. (Firma: rwth) (zeeshan)]

Thanks for the example code...
Can you kindly send the complete testbench ?
I will need it to understand e.g. the role of some of the temp variables 
etc.

[Nephilim (Gast)]

if you can post an email adress, for exapmle one where you can put all 
your spam to, then can i send you the whole project files.

[Zeeshan K. (Firma: rwth) (zeeshan)]

right ... my email address is : [e-mail]
thanks.

[Nephilim (Gast)]

you've got mail