Arbeit mit txt-Datein in Vivado

[Natalia Kaptsova (Gast)]

Hallo,
Ich habe ein Projekt, der früher mithilfe von ISE gemacht war und alles 
in Ordnung war, aber jetzt muss ich den Projekt im Vivado haben. Ein 
Teil des Projektes ist mit Realisierung eines RAMs in VHDL verbunden. 
Die Dateien müssen von einem TXT-Datei heruntergeladet sein. Jetzt kann 
das Projekt die Datein öffnen, aber herunterladet es die Werte leider 
nicht. Können sie mir empfehlen, was kann falsch sein? Gibt es 
irgendwechle Besonderheiten, die mit Vivado verbunden sind?

Ein Teil des Codes ist unten dargestellt:

IMPURE FUNCTION InitRamFromFile RETURN RamType IS
--!!-----------------------------------------------------!!--
        --! read the first line of file and return line length
        IMPURE FUNCTION filelinelength RETURN integer IS
        FILE RamFile                : text;
        VARIABLE RamFileLine        : line;
        VARIABLE line_width_buffer  : std_logic_vector(31 DOWNTO 0); -- 
xilinx toolchain cant read integer
        VARIABLE file_line_length   : integer := 0;
        VARIABLE filestat           : file_open_status;
        VARIABLE c                  : character;
        VARIABLE is_string          : boolean;
        BEGIN


            IF g_loadfile'length /= 0 THEN -- string is not empty
                file_open(filestat, RamFile, g_loadfile, read_mode );
                    IF filestat /= open_ok THEN
                        REPORT "Datei nicht geoeffnet. Filestat = " & 
file_open_status'IMAGE(filestat) & " Filename = " & g_loadfile;
                        RETURN 1; -- 1 to avoid v_hex_value and 
v_bin_value range warning
                    END IF;

                -- from file to memory to variable
                readline(RamFile,  RamFileLine);
                hread(RamFileLine, line_width_buffer);
                file_line_length := 
to_integer(unsigned(line_width_buffer));

                file_close(RamFile);
            ELSE
                RETURN 1; -- 1 to avoid v_hex_value and v_bin_value 
range warning
            END IF;

            REPORT "INFO File " & g_loadfile & " FileLineLength = " & 
integer'IMAGE(file_line_length);
                --REPORT natural'IMAGE(width); -- debug
            RETURN file_line_length;

        END FUNCTION filelinelength;

--!!-----------------------------------------------------!!--
-- call function filelinelength to use linelength as const/parameter
CONSTANT linelength        : integer := filelinelength;

VARIABLE line_count        : natural := 0;

-- xilinx xst can not read integer from file
-- workaround over hread() to std_logic_vector and then conversion to 
integer
-- first line in memory file must be 8 hex digits representing the 
character per line
-- second line must be 8 hex digits representing the line count
VARIABLE conversion_buffer  : std_logic_vector(31 DOWNTO 0);

FILE  RamFile               : text;
VARIABLE  RamFileLine       : line;
VARIABLE  I                 : natural := 0;
VARIABLE  v_RAM             : RamType := (OTHERS => (OTHERS => 
g_init_value));
VARIABLE  v_hex_value       : std_logic_vector((4 * linelength) - 1 
DOWNTO 0);
VARIABLE  v_bin_value       : std_logic_vector(linelength - 1 DOWNTO 0);
    BEGIN
    -- no file selected
    IF g_loadfile'length = 0 THEN
        return v_RAM; -- RAM full of g_init_value
    ELSE
        file_open(RamFile, g_loadfile);
        readline(RamFile, RamFileLine); -- read line width again, but 
ignore it
        readline(RamFile, RamFileLine); -- read line count

        hread(RamFileLine, conversion_buffer);
        line_count := to_integer(unsigned(conversion_buffer));

        REPORT "INFO File " & g_loadfile & " FileLineCount = " & 
integer'IMAGE(line_count);
          --REPORT natural'IMAGE(2 ** depth); -- debug

        IF line_count > (2 ** g_depth) THEN
            REPORT "Memory file has more data then RAM can hold. 
Truncating.";
            line_count := (2 ** g_depth);
        END IF;

          IF g_hex = true THEN
                IF (4 * lineLength) /= g_width THEN
                REPORT "hex: File line must have " & 
natural'IMAGE((g_width/4)) & " characters per line. Aborting!";
                    file_close(RamFile);
                    return v_RAM;
                END IF;
          ELSE
                IF lineLength /= g_width THEN
                REPORT "bin: File line must have " & 
natural'IMAGE(g_width) & " characters per line. Aborting!";
                    file_close(RamFile);
                    return v_RAM;
                END IF;
          END IF;



        FOR c IN 0 TO line_count - 1 LOOP
            readline(RamFile, RamFileLine);
            -- hex is generic
            IF g_hex THEN
                    -- read hex values
                    hread(RamFileLine, v_hex_value);
                    -- check if file input is shorter
                    --IF 4 * linelength < width THEN
                    --    v_RAM(I)(4 * linelength - 1 DOWNTO 0) := 
v_hex_value;
                    --ELSE
                        -- only use #width characters
                        v_RAM(I) := v_hex_value(g_width - 1 DOWNTO 0);
                    --END IF;
            ELSE
                    -- read bin values
                    read(RamFileLine, v_bin_value);
                    -- check if file input is shorter
                    --IF linelength < width THEN
                        v_RAM(I)(linelength - 1 DOWNTO 0) := 
v_bin_value;
                    --ELSE
                        -- only use #width characters
                    --    v_RAM(I) := v_bin_value(width - 1 DOWNTO 0);
                    --END IF;
            END IF;
            I := I + 1;
        END LOOP;

        file_close(RamFile);
        RETURN  v_RAM;
    END IF;
    file_close(RamFile);
    RETURN  v_RAM;
END FUNCTION InitRamFromFile;


Vielen Dank für ihre Antworte,
Natalia

[Slippin J. (gustavo_f)]

Ich kenne mich mit Vivado nicht so gut aus, aber eine Xilinx-Lösung 
wurde schon mal in diesem Thread vorgeschlagen:
Beitrag "RAM mit Filedaten intialisieren (VHDL)"