Xst:738 - HDL ADVISOR - 768 flip-flops were inferred for signal xxx.

[tomi (Gast)]

Hallo zusammen,

ich benutze gerade xilinx- spartan 3a xc3s1400a.
Wenn ich ein RAM so beschrieben, kriege ich so eine meldung von XST:

Xst:738 - HDL ADVISOR - 768 flip-flops were inferred for signal 
<dout_tmp>. You may be trying to describe a RAM in a way that is 
incompatible with block and distributed RAM resources available on 
Xilinx devices, or with a specific template that is not supported. 
Please review the Xilinx resources documentation and the XST user manual 
for coding guidelines. Taking advantage of RAM resources will lead to 
improved device usage and reduced synthesis time.

ENTITY output_reg_file IS
GENERIC (--input Register
  INPUT_REG_FILE_ANZAHL      : INTEGER := 1;
  --output Register
  OUTPUT_REG_FILE_ANZAHL     : INTEGER := 48);
  PORT ( sys_clk        : IN  STD_LOGIC;
        rd_reg: IN  STD_LOGIC_VECTOR (OUTPUT_REG_FILE_ANZAHL+INPUT_REG_FILE_ANZAHL DOWNTO INPUT_REG_FILE_ANZAHL+1);
  reg_file_to_cpu_tmp : IN  reg16         (OUTPUT_REG_FILE_ANZAHL+INPUT_REG_FILE_ANZAHL DOWNTO INPUT_REG_FILE_ANZAHL+1);
reg_file_to_cpu      : OUT STD_LOGIC_VECTOR (15 DOWNTO 0));
END output_reg_file;

----------------------------------------------------------------------------------
ARCHITECTURE BEHAVIORAL OF output_reg_file IS
SIGNAL dout_tmp : reg16 (OUTPUT_REG_FILE_ANZAHL+INPUT_REG_FILE_ANZAHL DOWNTO INPUT_REG_FILE_ANZAHL+1);
BEGIN

---OUTPUT_REG_FILE_ANZAHL >= 1---------------------------------------------------
  output_regfile_gen_condition: IF OUTPUT_REG_FILE_ANZAHL >= 1 GENERATE
    output_regfile_gen: FOR i IN INPUT_REG_FILE_ANZAHL+1 TO OUTPUT_REG_FILE_ANZAHL+INPUT_REG_FILE_ANZAHL GENERATE
      
      --output_regfile_process----------------------------------------------
      output_regfile_pro: PROCESS
      BEGIN
        WAIT UNTIL RISING_EDGE(sys_clk);
        dout_tmp(i) <= reg_file_to_cpu_tmp(i);
      END PROCESS output_regfile_pro;
      
      --an DATA-bus-Anschließen----------------------------------------------
      WITH rd_reg(i) SELECT
        reg_file_to_cpu <= dout_tmp(i)  WHEN '1', 
                   (OTHERS => 'Z') WHEN OTHERS;
                  
    END GENERATE output_regfile_gen;
  END GENERATE output_regfile_gen_condition;

---OUTPUT_REG_FILE_ANZAHL = 0---------------------------------------------------
  gen_condition: IF OUTPUT_REG_FILE_ANZAHL = 0 GENERATE
        reg_file_to_cpu <= (OTHERS => 'Z');                         
    END GENERATE gen_condition;
  
END BEHAVIORAL;

48-Register x 16-bit = 768 flip-flop.
was für ein contraint muss ich vielleicht noch hinzufügen?

vielen dank im vorraus und ciao aus hannover!^^

lg Tom

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

tomi schrieb:
> 48-Register x 16-bit = 768 flip-flop.
Ja, passt.

> was für ein contraint muss ich vielleicht noch hinzufügen?
Nichts. Wenn du (aus welchen Gründen auch immer) genau sowas willst, 
dann darfst du den Rat des Ratgebers einfach erst mal ignorieren.
Nur solltest du irgendwann in dich gehen und dich fragen:
warum meint der, das könnte man evtl. anders besser machen?

> Wenn ich ein RAM so beschrieben, kriege ich so eine meldung von XST:
Ja, kennst du denn ein RAM als Baustein, wo du auf alle Speicherzellen 
gleichzeitig zugreifen kannst? So etwa:
>>>  dout_tmp(i) <= reg_file_to_cpu_tmp(i);
Ich nicht...  :-/
Auf die RAMs, die ich kenne, wird immer wortweise zugegriffen (8, 16, 
32, 64-Bit).

Als Tipp: sieh dir mal an, wie RAMs in VHDL beschrieben werden. Für 
Xilinx ist der XST-User-Guide maßgeblich:

Please review the Xilinx resources documentation and 
the XST user manual for coding guidelines.

[tomi (Gast)]

hi Lothar,

vielen dank erstmal für die Antwort!^^

Lothar Miller schrieb:
> Ja, kennst du denn ein RAM als Baustein, wo du auf alle Speicherzellen
> gleichzeitig zugreifen kannst? So etwa:
>>>>  dout_tmp(i) <= reg_file_to_cpu_tmp(i);
> Ich nicht...  :-/
> Auf die RAMs, die ich kenne, wird immer wortweise zugegriffen (8, 16,
> 32, 64-Bit).

für die zeile:

>>>>  dout_tmp(i) <= reg_file_to_cpu_tmp(i);

Weil ich so gemacht habe:

TYPE reg16  IS ARRAY (NATURAL RANGE <>) OF STD_LOGIC_VECTOR (15 DOWNTO 0);

SIGNAL dout_tmp : reg16 (OUTPUT_REG_FILE_ANZAHL+INPUT_REG_FILE_ANZAHL DOWNTO INPUT_REG_FILE_ANZAHL+1);

--
--
dout_tmp(i) <= reg_file_to_cpu_tmp(i);

meine ich, das ist schon 16-bit-register, also nicht einzelnen 
Speocherzelle.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

tomi schrieb:
> meine ich, das ist schon 16-bit-register,
Ja, das sind bis dahin (49 downto 2) = 48 einzelne 16 Bit Register. Die 
dann aber parallel (und gleichzeitig) über ein Generate irgendwoanders 
hin zugewiesen werden:

FOR i IN 2 TO 49 GENERATE
   :
   dout_tmp(i) <= reg_file_to_cpu_tmp(i);
   :
END GENERATE;

Das ist, was üblicherweise mit "Massive Parallel Processing" umworben 
wird... ;-)


BTW1: wenn du neu im VHDL-Geschäft bist, solltest du für die Synthese 
solche Konstrukte wie Generate und Loop gleich mal vergessen...

BTW2: (49 downto 2)
warum so einen seltsamen Range?

[tomi (Gast)]

Lothar Miller schrieb:
> Das ist, was üblicherweise mit "Massive Parallel Processing" umworben
> wird... ;-)

macht das dem Syntheser langsamer, oder ist es gefählich wegen der 
xst-meldung? was man besser machen kann?

Lothar Miller schrieb:
> BTW2: (49 downto 2)
> warum so einen seltsamen Range?

ich will also ein bus-interface zwischen FPGA und µC aufbauen, nach 
meiner fantasie:D

Mit diesem Code will ich 48-ADC-Resultregister, je 16-bit, von µC 
auslesen.Hier nenne ich output-resgiter-file, also von FPGA aus.

Und die
>>>> INPUT_REG_FILE_ANZAHL      : INTEGER := 1;

ist die steuerregister. Der µC schreibt Controlword für ADC. Deswegen 
fängt bei mir die outputregister ab INPUT_REG_FILE_ANZAHL + 1 = 2.

Über generic-parameter muss ich für andere Modul nur gewünschte 
input,-output-register anpasssen, dann wird es automatisch generiert.

Lothar Miller schrieb:
> BTW1: wenn du neu im VHDL-Geschäft bist, solltest du für die Synthese
> solche Konstrukte wie Generate und Loop gleich mal vergessen...

ja, nicht so lange beschäftige ich mich mit FPGA.
Ohne Generate ist mir schwer, zumindest meiner Meinung nach...

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

tomi schrieb:
> macht das dem Syntheser langsamer, oder ist es gefählich wegen der
> xst-meldung? was man besser machen kann?
Du verbrauchst unendlich viel Ressourcen, weil keine RAMs instantiiert 
werden können. Das ist das Problem...  :-/

> Ohne Generate ist mir schwer, zumindest meiner Meinung nach..
Mit Generate wird das mit garantierter Sicherheit nicht einfacher. Wie 
du hier selber siehst...

> Mit diesem Code will ich 48-ADC-Resultregister, je 16-bit, von µC
> auslesen.
Skizziere für dich selber mal auf einem Blatt Papier, wie du die Daten 
aus dem ADC abholst. Denn das FPGA selber hat ja keinen ADC. Und 
irgenwoher müssen die Daten ja kommen. Hat der ADC auch einen 
16-Bit-Bus? Welcher ADC ist das? Was willst du denn überhaupt machen?

[tomi (Gast)]

Lothar Miller schrieb:
> Skizziere für dich selber mal auf einem Blatt Papier, wie du die Daten
> aus dem ADC abholst. Denn das FPGA selber hat ja keinen ADC. Und
> irgenwoher müssen die Daten ja kommen. Hat der ADC auch einen
> 16-Bit-Bus? Welcher ADC ist das? Was willst du denn überhaupt machen?

ich benutze 6 x AD7367, der ist 14-bit ADC, aber µC bus ist 16. Für die 
input-reg-file möchte ich read_write-register:

ENTITY input_reg_file IS
  GENERIC (INPUT_REG_FILE_ANZAHL    : INTEGER:= 1);
PORT ( sys_clk        : IN    STD_LOGIC;
     wr_reg         : IN    STD_LOGIC_VECTOR (INPUT_REG_FILE_ANZAHL DOWNTO 1);
     rd_reg         : IN    STD_LOGIC_VECTOR (INPUT_REG_FILE_ANZAHL DOWNTO 1);
     cpu_databus     : INOUT  STD_LOGIC_VECTOR (15 DOWNTO 0);
     reg_file_from_cpu       : OUT    reg16         (INPUT_REG_FILE_ANZAHL DOWNTO 1));
END input_reg_file;

----------------------------------------------------------------------------------
ARCHITECTURE BEHAVIORAL OF input_reg_file IS
--

SIGNAL input_reg_tmp : reg16            (INPUT_REG_FILE_ANZAHL DOWNTO 1);
BEGIN

--intern wired-----------------------------------------------------------------
  reg_file_from_cpu <= input_reg_tmp;
  
    input_regfile_gen: FOR i IN 1 TO INPUT_REG_FILE_ANZAHL GENERATE
      
      --Schreiben, Richtung: µC----> FPGA------------------  
      wr_input_regfile_pro: PROCESS
      BEGIN
        WAIT UNTIL RISING_EDGE(sys_clk);
        IF wr_reg(i) = '1' THEN
          input_reg_tmp(i) <= cpu_databus;
        END IF;
      END PROCESS wr_input_regfile_pro;
      
      --Lesen, Richtung: FPGA----> µC-----------------------
      WITH rd_reg(i) SELECT
        cpu_databus <= input_reg_tmp(i)  WHEN '1', 
              (OTHERS => 'Z') WHEN OTHERS;                
  
    END GENERATE input_regfile_gen;

Lothar Miller schrieb:
> tomi schrieb:
>> macht das dem Syntheser langsamer, oder ist es gefählich wegen der
>> xst-meldung? was man besser machen kann?
> Du verbrauchst unendlich viel Ressourcen, weil keine RAMs instantiiert
> werden können. Das ist das Problem...  :-/
>
>> Ohne Generate ist mir schwer, zumindest meiner Meinung nach..
> Mit Generate wird das mit garantierter Sicherheit nicht einfacher. Wie
> du hier selber siehst...

gibts andere bessere weise?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dann kannst du sowieso immer nur auf 16 Bits gleichzeitig zugreifen.

Ergo mußt du "nur" einen Multiplexer bauen, der dir den passenden ADC 
auf deinen uC durchschaltet...
Oder sollen die ADC automon vom FPGA kontrolliert werden?

Aber wie gesagt: zeichne das mal auf ein Blatt Papier, gib den Bauteilen 
Namen und mach ein Foto davon. Und das postest du hier, dann sieht man 
weiter...

> gibts andere bessere weise?
Die Antwort lautet mit Sicherheit: Ja.
Genaueres lässt sich aber erst mit einer genauen Aufgabenstellung sagen.

[tomi (Gast)]

Lothar Miller schrieb:
> Oder sollen die ADC automon vom FPGA kontrolliert werden?

ja genau. Über einen Input_Register definiere ich control-bit(z.b. 
Start/Stop-bit; Synchron mit anderem ADC..) für 6 ADC, und schreibe ich 
über µC.

Am Anhang ist das Blockschlatbild. Oben ist typische Verbindung über 
extern Bus von µC. Dabei gibtd 16-bit Datenbus, 8-bit Addressbus, read 
(rd), write(wr) und chip select (cs).

In FPGA schreibe ich sozusagen businterface mit generic parameter, wie 
vorher gesehen. D.h. für jede Modul muss ich Anzahl der 
input,-output-16bit-register(registerfile), Anfang-address festlegen. In 
diesem Fall hier für Modull AD-Wandler typ 14-bit AD7367(4 kanal) brache 
ich ein Input-register (benutzt aber nur 6 bit für start/stop der 6 ADC) 
und 48 -outputregister für results.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

tomi schrieb:
> Oben ist typische Verbindung über extern Bus von µC.
> Dabei gibtd 16-bit Datenbus, 8-bit Addressbus
Und genau mit diesen Bussen gehst du jetzt richtigerweise erst mal auf 
ein DPRAM. Denn genau so (wie ein RAM) hast du doch auch deine 
Registersätze in der Bildmitte definiert...
Mit der Adresse selektierst du ein bestimmtes 16-Bit Wort, in das dann 
Daten geschrieben werden oder von dem gelesen wird.

Und auf der anderen Seite des DPRAM ist die Verwaltung (FSM) der 
AD-Wandler angeschlossen.

[tomi (Gast)]

Lothar Miller schrieb:
> Und genau mit diesen Bussen gehst du jetzt richtigerweise erst mal auf
> ein DPRAM. Denn genau so (wie ein RAM) hast du doch auch deine
> Registersätze in der Bildmitte definiert...
> Mit der Adresse selektierst du ein bestimmtes 16-Bit Wort, in das dann
> Daten geschrieben werden oder von dem gelesen wird.
>
> Und auf der anderen Seite des DPRAM ist die Verwaltung (FSM) der
> AD-Wandler angeschlossen.



Alles scheint richtig zu sein, oder? oder problem liegt daran, ob mein 
spartan 3a hat Dual Port RAM (DPRAM) oder nicht?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

tomi schrieb:
> oder problem liegt daran, ob mein
> spartan 3a hat Dual Port RAM (DPRAM) oder nicht?
Der hat das schon.

> Alles scheint richtig zu sein, oder?
Nein. Lies dir den Thread hier nochmal von Anfang an durch: deine 
Beschreibung funktioniert nicht für ein RAM. Man kann nicht ein ganzes 
Ram auf einmal hin- und herkopieren.

>>>> Als Tipp: sieh dir mal an, wie RAMs in VHDL beschrieben werden.
>>>> Für Xilinx ist der XST-User-Guide maßgeblich...
Also: lies dort mal nach, wie denn die Beschreibung für ein RAM 
aussieht. Eines ist klar: ein GENERATE kommt in so einer Beschreibung 
nicht vor.

[tomi (Gast)]

danke Lothar für die Antwort, lese ich mal user guide^^

best gruß!