32Bit Zähler zählt nur bis 255.

[Gustl B. (-gb-)]

Hallo,

also ich möchte einen (oder viele) 32Bit Zähler.

Ich habe dazu einen
signal buffer: std_logic_vector(31 downto 0);
und zu dem zähle ich 1 dazu, also

buffer <= buffer + 1;

Ja das geht auch jedoch zählt er nur bis 255 und fängt dann wieder bei 0 
an.
Woran liegt das und wie kann ich das lösen?

Wenn ich noch einen
signal x: unsigned(31 downto 0);
dazuhole und dann in drei aufeinanderfolgenden Takten

x <= unsigned(buffer);

x <= x + 1;

buffer <= std_logic_vector(x);

mache, dann wird weiterhin nur bis 255 gezählt?!

[Fehlerteufel (Gast)]

Fehler in Zeile 42.

[Ach komm (Gast)]

Der Fehler ist eigentlich ziemlich offensichtlich. Wenn man ein bisschen 
programmieren kann. Schon mal darüber nachgedacht, was für einen Typ von 
Variable du da hochzählst...

[Gustl B. (-gb-)]

Integer sollte doch 32Bit sein, dann ist Unsigned doch eigentlich weil 
ohne Vorzeichen auch 32Bits aber nur positiv. Gut ich habe gelesen es 
sich scheinbar 31 Bit. std_logic_vector sollte aber doch immer die Länge 
haben die man angibt. Und wenn ich da dann einen mit 31 downto 0) 
machen, warum zählt auch der dann nur bis 255? wird da immer 1 als 
"00000001" hinzuaddiert? Und kein Übertrag ins 8. und höhere Bit 
mitgenommen?

Und wenn das der Fehler ist, wie mache ich das richtig? Muss ich die 
Zahl/Vector in kleine 8-Bit Vektoren zerlegen?!

[Johann (Gast)]

Woher weist Du das er nur bis 355 zählt hast Du es mal simuliert und 
hast Du vielleicht ein Reset den Du uns verschwiegen hast?

[raketenfred (Gast)]

Sicher, dass ein Integer 32bit auf einem 8-Bit AVR hat ?!

[Gustl B. (-gb-)]

Klar verschweige ich etwas, aber nur damit es vielleicht einfacher wird 
und der Fehler eingegrenzt wird.

signal buffer: std_logic_vector(31 downto 0);

buffer <= buffer + 1;

Das zählt nur bis 255 und dann wieder von 0 hoch. Getestet habe ich das 
eben mit einem Spektrum. Da wird in jedem Kanals eine solche 32 Bit Zahl 
hochgezählt wenn ein entsprechendes Bitmuster reinkommt. Und dann kann 
ich das Spektrum zum PC schicken und da angucken - und da war in jedem 
Kanal etwas kleiner 256 drinnen - zum Glück haben wir noch alte 
Messgeräte die auch zeigen was jeweils in einem Kanals ist.
Und da steht dass in dem Kanal x eben z.B. y drinnen ist. Und bei mir 
hier am FPGA Board wird angezeigt, dass in demselben Kanal x der Wert z 
drinnen ist. Und komischwerweise ist der Zusammenhang z = y - (n*255) - 
und das bei jedem Kanal in dem mehr wie 255 drin sein sollte.

Gut ein Schreib oder Leseproblem mit dem RAM ist es nicht, weil wenn ich 
statt

buffer <= buffer + 1;

ein

buffer <= "110000010000010001001000";

hinschreibe bekomme ich auch für den entsprechenden Kanal in dem 
hochgezählt werden sollte konstant diesen Wert am PC.

Ich will wirklich nur eine 32 Bit Zahl hochzählen.

Und ist Integer immer unterschiedlich? Wo gibt es eine Übersicht über 
die Datentypen in VHDL? Beim AVR hätte ich gedacht, dass der dann eben 
mehr Register braucht wie bei 64Bit Zahlen auf einem 32Bit System.

[Tokyo D. (tokyodrift)]

Gustl Buheitel schrieb:
> Und ist Integer immer unterschiedlich? Wo gibt es eine Übersicht über
> die Datentypen in VHDL? Beim AVR hätte ich gedacht, dass der dann eben
> mehr Register braucht wie bei 64Bit Zahlen auf einem 32Bit System.
Bei VHDL hat ein Integer keine feste Größe, wie auch der FPGA keine 
Register hat. Das ist halt kein Prozessor sondern ein PLD. Integer heißt 
in dem Zusammenhang nur "Ganzzahl", sonst nichts. Auch ist ein Integer 
hardwaretechnisch nichts anderes als ein STD_LOGIC_VECTOR.

Poste den Code, sonst wird das nichts mit der Hilfe hier.

[(prx) A. K. (prx)]

Gustl Buheitel schrieb:

> hochgezählt wenn ein entsprechendes Bitmuster reinkommt. Und dann kann
> ich das Spektrum zum PC schicken und da angucken - und da war in jedem
> Kanal etwas kleiner 256 drinnen

M.a.W: Es existieren noch ungezählte andere potentielle Fehlerquellen 
zwischen Zähler und PC-Bildschirm.

[Gustl B. (-gb-)]

Wenn ihr wirklich wollt ... mir geht es aber nur um den Zähler oder 
müsste das so richtig funktionieren?

library ieee;
use ieee.std_logic_1164.all;
use IEEE.std_logic_arith.all; 
use IEEE.std_logic_unsigned.all;
use IEEE.numeric_std.all;

entity spek is

port (clock: in std_logic;
    oe, wr, ce, neues: out std_logic;
    addr: out std_logic_vector(23 downto 1);
    data: inout std_logic_vector(15 downto 0);
    pins12: in std_logic_vector(11 downto 0);
  --  pins8: in std_logic_vector(7 downto 0);
    trigger: in std_logic;
    output, rs232data : out std_logic_vector(7 downto 0);
    input: in std_logic_vector(7 downto 0);
    i,rdy: in std_logic);
end spek;

architecture Behavioral of spek is

signal c: integer range 0 to 7 := 7; --counter von init
signal c1: integer range 0 to 12 := 0; --counter von rs232
signal c2: integer range 0 to 25 := 25; --counter beim messen
signal cv: std_logic_vector(23 downto 1); --counter rs232
signal o: std_logic_vector(15 downto 0); --output rs232
signal buff: std_logic_vector(31 downto 0); --buffer beim messen
signal pins: std_logic_vector(11 downto 0); --pin IO
signal ipins: std_logic_vector(11 downto 0); --pin IO invertiert
signal sigc: integer range 0 to 300 := 0; --impulszähler

signal count: integer range 0 to 50 := 50; --trigger latenz
signal doc: integer range 0 to 50000000; --auslesebuttoncounter
signal do2: std_logic; --auslesesignal, sync
signal b,neu,fall: std_logic; --r,w flag
signal send: std_logic_vector(7 downto 0):= "00000000"; --output von init
signal adc: std_logic_vector(23 downto 1):= "00000000000000000000000"; --addrcount von init
signal ad1: std_logic_vector(23 downto 1):= "00000000000000000000000"; --addr1
signal ad2: std_logic_vector(23 downto 1):= "00000000000000000000000"; --addr2
signal sro: std_logic_vector(15 downto 0); --sram out
signal sri: std_logic_vector(15 downto 0); --sram in

signal ac: integer range 0 to 50000000; --auslesebuttoncounter

begin

pins <= pins12; --pinmap
ipins <= "111111111111" - pins; --addresse an der gezählt wird bzw. invertierte pins

data <= sro when b = '0' else "ZZZZZZZZZZZZZZZZ";
sri <= data when b = '1';

output <= send;

process --auslesebutton einsyncen
  begin
    wait until rising_edge(clock);
    if (doc<10000000) then
       doc <= doc + 1;
    end if;
    if (i ='1') then
        doc <= 0;
    end if;
   if doc = 9999999 then --neu!
    do2 <= '1';
   end if;
   if doc = 10000000 then
    do2 <= '0';
  end if;
end process;

process --falling edge einsyncen
    variable sr : std_logic_vector (3 downto 0) := "0000";
  begin
    wait until rising_edge(clock);
    fall <= not sr(2) and sr(3);
    sr := sr(2 downto 0) & trigger;
end process;

process --falling edge einsyncen
  begin
    wait until rising_edge(clock);
    if count < 50 then
      count <= count + 1;
      neu <= '0';
    end if;
    if fall='1' then
      count <= 0;
    end if;
    if count = 49 then
      neu <= '1';
    end if;
    if count = 50 then
      neu <= '0';
    end if;
end process;


process begin
   wait until rising_edge(clock);
  
  if input /= "00000010" then
    neues <= '0';
  end if;

-------------------------------------------------------------------------------------------------------------------------------------------

  if input = "00000001" then --RAM Nullen
  
    if c < 7 then
      c <= c + 1;
    elsif c = 7 and adc < 2097153 then --spektrumlänge x2 BIG
      c <= 0;
    elsif c = 7 and adc = 2097153 and do2 = '1' then
      adc <= "00000000000000000000000";
    end if;

    if c = 0 then --leds geben status aus
      if adc = 1 then
        send <= "00000000";
      elsif adc = 262144 then
        send <= "00000001";
      elsif adc = 524288 then
        send <= "00000011";
      elsif adc = 786432 then
        send <= "00000111";
      elsif adc = 1048576 then
        send <= "00001111";
      elsif adc = 1310720 then
        send <= "00011111";
      elsif adc = 1572864 then
        send <= "00111111";
      elsif adc = 1835008 then
        send <= "01111111";
      elsif adc = 2097152 then
        send <= "11111111";
      end if;

    elsif c = 1 then --1. schreibzugriff
      ce <= '1';
      oe <= '0';
      wr <= '0';
      b <= '1';
    elsif c = 2 then
      ce <= '0';
      oe <= '0';
      wr <= '1';
      b <= '1';
      addr <= adc;
    elsif c = 3 then
      ce <= '0';
      oe <= '0';
      wr <= '0';
      b <= '0';
      addr <= adc;
      sro <= "0000000000000000";
    elsif c = 4 then
      ce <= '1';
      oe <= '0';
      wr <= '0';
      b <= '0';
      addr <= adc;
      sro <= "0000000000000000";

    elsif c = 5 then
      adc <= adc + 1;
      b <= '1';
    end if;
    
-------------------------------------------------------------------------------------------------------------------------------------------    

  elsif input = "00000010" then --lesen und über rs232 ausgeben

    if do2 = '1' then
      c1 <= 0;
      cv <= "00000000000000000000000";
    end if;
    if c1 = 12 and cv < 2097151 then  --BIG
      c1 <= 0;
      cv <= cv + 1;
      rs232data <= "00000000";
    end if;
    
    if cv = 0 then --nur ausgabe
      send <= "00000000";
    elsif cv = 262144 then
      send <= "00000001";
    elsif cv = 524288 then
      send <= "00000011";
    elsif cv = 786432 then
      send <= "00000111";
    elsif cv = 1048576 then
      send <= "00001111";
    elsif cv = 1310720 then
      send <= "00011111";
    elsif cv = 1572864 then
      send <= "00111111";
    elsif cv = 1835008 then
      send <= "01111111";
    elsif cv = 2097151 then
      send <= "11111111";
    end if;
    
    if c1 = 0 then --1. lesezugriff
      ce <= '1';
      oe <= '1';
      wr <= '1';
      b <= '1';
      c1 <= c1 + 1;
      o <= "0000000000000000";
    elsif (c1 = 1 or c1 = 2) then
      ce <= '0';
      oe <= '1';
      wr <= '1';
      b <= '1';
      addr <= cv;
      c1 <= c1 + 1;
    elsif (c1 = 3 or c1 = 4 or c1 = 5) then
      ce <= '0';
      oe <= '0';
      wr <= '1';
      b <= '1';
      addr <= cv;
      o <= sri;
      c1 <= c1 + 1;
      neues <= '0';
      
    elsif c1 = 6 and rdy = '1' then
      neues <= '1';
      rs232data <= o(7 downto 0);
      c1 <= c1 + 1;
    elsif c1 = 7 then
      neues <= '1';
      c1 <= c1 + 1;
    elsif c1 = 8 then
      neues <= '0';
      c1 <= c1 + 1;
      
    elsif c1 = 9 and rdy = '1' then
      neues <= '1';
      rs232data <= o(15 downto 8);
      c1 <= c1 + 1;
    elsif c1 = 10 then
      neues <= '1';
      c1 <= c1 + 1;
    elsif c1 = 11 then
      neues <= '0';
      c1 <= c1 + 1;
    end if;
    
-------------------------------------------------------------------------------------------------------------------------------------------
    
  elsif input > "01000000" then --messen! zwei lese und zwei schreibzugriffe

    if c2 < 25 then
      c2 <= c2 + 1;
    elsif c2 = 25 and neu = '1' then
      c2 <= 0;
      ad1(1) <= '0';
      ad1(13 downto 2) <= ipins;
      ad1(23 downto 14) <= "0000000000";
      ad2(1) <= '1';
      ad2(13 downto 2) <= ipins;
      ad2(23 downto 14) <= "0000000000";
    end if;
    
    if c2 = 0 then
     b <= '1';
     buff <= "00000000000000000000000000000000";
     
    elsif c2 = 1 then --1. lesezugriff
      ce <= '1';
      oe <= '1';
      wr <= '1';
      b <= '1';
    elsif (c2 = 2 or c2 = 3) then
      ce <= '0';
      oe <= '1';
      wr <= '1';
      b <= '1';
      addr <= ad1;
    elsif (c2 = 4 or c2 = 5 or c2 = 6) then
      ce <= '0';
      oe <= '0';
      wr <= '1';
      b <= '1';
      addr <= ad1;
       buff(15 downto 0) <= sri;
      
    elsif c2 = 7 then --2. lesezugriff
      ce <= '1';
      oe <= '1';
      wr <= '1';
      b <= '1';
    elsif (c2 = 8 or c2 = 9) then
      ce <= '0';
      oe <= '1';
      wr <= '1';
      b <= '1';
      addr <= ad2;
    elsif (c2 = 10 or c2 = 11 or c2 = 12) then
      ce <= '0';
      oe <= '0';
      wr <= '1';
      b <= '1';
      addr <= ad2;
      buff(31 downto 16) <= sri;
    
    elsif c2 = 13 and buff /= "11111111111111111111111111111111" then
       buff <= buff + 1;
     
    elsif c2 = 14 then --1. schreibzugriff
      ce <= '1';
      oe <= '0';
      wr <= '0';
      b <= '1';
    elsif c2 = 15 then
      ce <= '0';
      oe <= '0';
      wr <= '1';
      b <= '1';
      addr <= ad1;
    elsif c2 = 16 then
      ce <= '0';
      oe <= '0';
      wr <= '0';
      b <= '0';
      addr <= ad1;
      sro <= buff(15 downto 0);
    elsif c2 = 17 then
      ce <= '1';
      oe <= '0';
      wr <= '0';
      b <= '0';
      addr <= ad1;
      sro <= buff(15 downto 0);

    elsif c2 = 18 then --2. schreibzugriff
      ce <= '1';
      oe <= '0';
      wr <= '0';
      b <= '1';
    elsif c2 = 19 then
      ce <= '0';
      oe <= '0';
      wr <= '1';
      b <= '1';
      addr <= ad2;
    elsif c2 = 20 then
      ce <= '0';
      oe <= '0';
      wr <= '0';
      b <= '0';
      addr <= ad2;
      sro <= buff(31 downto 16);
    elsif c2 = 21 then
      ce <= '1';
      oe <= '0';
      wr <= '1';
      b <= '0';
      addr <= ad2;
      sro <= buff(31 downto 16);

    elsif c2 = 22 then
      b <= '1';
      buff <= "00000000000000000000000000000000";
    end if;
    
    
    if sigc < 300 and ac /= 50000000 and neu = '1' then
      sigc <= sigc + 1;
    elsif ac = 49999999 then
      if sigc = 0 then
        send(5 downto 0) <= "000000";
      elsif sigc > 0 and sigc < 50 then
        send(5 downto 0) <= "000001";
      elsif sigc > 49 and sigc < 100 then
        send(5 downto 0) <= "000011";
      elsif sigc > 99 and sigc < 150 then
        send(5 downto 0) <= "000111";
      elsif sigc > 149 and sigc < 200 then
        send(5 downto 0) <= "001111";
      elsif sigc > 199 and sigc < 250 then
        send(5 downto 0) <= "011111";
      elsif sigc > 249 and sigc < 300 then
        send(5 downto 0) <= "111111";
      elsif sigc > 299 then
        send(5 downto 0) <= "110011";  
      end if;
    elsif ac = 50000000 then
      sigc <= 0;
    end if;
    
    if ac < 50000000 then
      ac <= ac + 1;
    elsif ac = 50000000 then
      ac <= 0;
    end if;
        
    if input = "10000000" and ac > 25000000 then
      send(7 downto 6) <= "10";
    elsif input = "10000000" and ac < 25000000 then
      send(7 downto 6) <= "00";
    end if;
    
    
    
  end if;
end process;


end Behavioral;

Natürlich gibt es noch mehr Komponenten, aber die gehen, also Senden 
über rs232 geht, die Leds und 7Seg-Displays auch.

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

Gustl Buheitel schrieb:
> Ich habe dazu einen
> signal buffer: std_logic_vector(31 downto 0);
> und zu dem zähle ich 1 dazu, also
> buffer <= buffer + 1;
Mit Vektoren rechnet man nicht.

raketenfred schrieb:
> Sicher, dass ein Integer 32bit auf einem 8-Bit AVR hat ?!
Was hat VHDL mit AVR zu tun?

Gustl Buheitel schrieb:
> Und ist Integer immer unterschiedlich?
Nein. Da sind offenbar ein paar Softwerker reingerutscht. Und da sind in 
C Integer mindestens 2 Byte breit.
> Beim AVR hätte ich gedacht, dass der dann eben
> mehr Register braucht wie bei 64Bit Zahlen auf einem 32Bit System.
Das kommt auf den Compiler an...

> Wo gibt es eine Übersicht über die Datentypen in VHDL?
Weil du jederzeit selber jede Menge Typen definieren kannst, ist die 
Frage an sich ungünstig...

Zeig mal etwas mehr Code. Und am besten auch, wie du siehst, dass da nur 
bis 255 gezählt wird (Testbench).

[Gustl B. (-gb-)]

Eine Testbench habe ich nicht, da wird ja auch nur immer in dem Kanal 
hochgezählt für den das passende Bitmuster anliegt.

Und dass nur bis 255 gezählt wird sehe ich aus dem Spektrum, dass hier 
gebaut wird und aus dem Vergleichsspektrum, da kann man schön sehen, 
dass hier im Spektrum nach 255 in dem entsprechenden Kanal wieder bei 0 
begonnen wird. Wenn z.B. im vergleichsspektrum in einem Kanal 1234 
drinnen sein sollte, dann ist hier 210 = 1234 - 4*256 drinnen. Und das 
geht bei jedem Kanal nur dass 4 eben nicht immer 4 ist.

Ok mit was rechnet man denn was 32 Bit ist und wirklich 32 Bit verwendet 
werden können, also nicht wie mit Vorzeichen nur 31?

[Tokyo D. (tokyodrift)]

[...]
if c2 < 25 then
      c2 <= c2 + 1;
[...]
end if;
[...]
if c2 = 13 and buff /= "11111111111111111111111111111111" then
      buff <= buff + 1;
[...]
end if;
[...]

Das läuft parallel. Kannst mir das mal erklären?

[Gustl B. (-gb-)]

Ja was ist damit? Das eine zählt hoch und das andere guckt wo der Zähler 
ist und macht dann was. Das ist quasi eine Sequenz aus 25 Takten in 
denen der Reihe nach die Ramzugriffe abgearbeitet werden. Also das 
sollte nicht das Problem sein.

[Tokyo D. (tokyodrift)]

Gustl Buheitel schrieb:
> Ja was ist damit? Das eine zählt hoch und das andere guckt wo der Zähler
> ist und macht dann was. Das ist quasi eine Sequenz aus 25 Takten in
> denen der Reihe nach die Ramzugriffe abgearbeitet werden. Also das
> sollte nicht das Problem sein.

Das Problem sehe ich darin, dass du etwas weiter unten schreibst

   elsif c2 = 22 then
      b <= '1';
      buff <= "00000000000000000000000000000000";

Naja, es wird c2 so wie ich das sehe ja in jedem Takt inkrementiert. 
Also trift c2=13 ja nur einen einzigen Takt zu, danach wird buf wieder 
auf 0 zurückgesetzt. Oder übersehe ich da gerade etwas?

[Gustl B. (-gb-)]

Ja. Da wird vor Takt 13 aus dem RAM in den buff gelesen, bei Takt 13 
sollte buff um 1 erhöht werden, zwischen Takt 13 und 22 wird buff dann 
wieder in den RAM geschrieben und bei Takt 22 wird buff geleert.
Das ist eben nicht nur ein 32 Bit Zähler sondern sehr viele (hier 2^20) 
und da die nicht im FPGA Platz haben liegen die im RAM und brauchen 
4MBytes.

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

Gustl Buheitel schrieb:
> Wenn ihr wirklich wollt ...
Das wäre jetzt aber besser als Anhang (mit Endung .vhd) aufgehoben 
gewesen...

Ich habe eher den Eindruck, da passt was mit dem Zusammenbauen des 
32-Bit Weerts nicht so richtig.
Aber ich würde dir hier eine Testbench unbedingt empfehlen...

BTW:
      buff <= "00000000000000000000000000000000";
So gehts übersichtlicher:
      buff <= (others=>'0');

Oder statt dem:
    buff /= "11111111111111111111111111111111"
wenigstens so:
    buf /= x"FFFFFFFF"

[Tokyo D. (tokyodrift)]

Lothar Miller schrieb:
> Ich habe eher den Eindruck, da passt was mit dem Zusammenbauen des
> 32-Bit Weerts nicht so richtig.
Er sagt allerdings dass wenn er buff einen Festen Wert zuweist alles 
stimmt.

Mach doch bitte mal buff zu einem integer bevor du da was dazuzählst. 
Vielleicht gehts ja dann.

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

Julian X. schrieb:
> Mach doch bitte mal buff zu einem integer bevor du da was dazuzählst.
> Vielleicht gehts ja dann.
Das geht aber schon sehr in Richtung "Handauflegen"...
Und zudem ist es gar nicht gut, eine vorzeichenlose 32-Bit Zahl als 
vorzeichenbehafteten 32-Bit Integer zu interpretieren...
Für solche Wortbreiten gibt es den Datentyp UNSIGNED.

BTW:
Das hier

signal sigc: integer range 0 to 300 := 0; --impulszähler
:
      if sigc = 0 then
        send(5 downto 0) <= "000000";
      elsif sigc > 0 and sigc < 50 then
        send(5 downto 0) <= "000001";
      elsif sigc > 49 and sigc < 100 then
        send(5 downto 0) <= "000011";
      elsif sigc > 99 and sigc < 150 then
        send(5 downto 0) <= "000111";
      elsif sigc > 149 and sigc < 200 then
        send(5 downto 0) <= "001111";
      elsif sigc > 199 and sigc < 250 then
        send(5 downto 0) <= "011111";
      elsif sigc > 249 and sigc < 300 then
        send(5 downto 0) <= "111111";
      elsif sigc > 299 then
        send(5 downto 0) <= "110011";  
      end if;

ginge auch so:

      if sigc = 0 then       send(5 downto 0) <= "000000";
      elsif sigc < 50  then  send(5 downto 0) <= "000001";
      elsif sigc < 100 then  send(5 downto 0) <= "000011";
      elsif sigc < 150 then  send(5 downto 0) <= "000111";
      elsif sigc < 200 then  send(5 downto 0) <= "001111";
      elsif sigc < 250 then  send(5 downto 0) <= "011111";
      elsif sigc < 300 then  send(5 downto 0) <= "111111";
      else                   send(5 downto 0) <= "110011";  
      end if;

Dann sieht man auch ein Muster...

[Gustl B. (-gb-)]

Ähm ja richtig Integer, und da ist meine Frage, wie mache ich das mit 32 
Bit?

    elsif c2 = 13 then
      
      buff_i <= to_integer(unsigned(buff)); --hier geht nicht

    elsif c2 = 14 then
      
      buff_i <= buff_i + 1;
     
    elsif c2 = 15 then
    
      buff <= conv_std_logic_vector(buff_i,32);

So sieht das doch aus mit

signal buff_i: integer;

Aber ich bekomme immer ein "to_integer can not have such operands in 
this context.". Das in Bytes zerlegen und lesen und schreiben geht 
vermutlich, da ich den selben Code ja zweimal verwende, also auch in der 
Funktion die nacheinander den RAM ließt und über rs232 ausgibt was 
funktioniert und geschrieben wird wenn der RAM genullt wird, da kann ich 
den RAM ja auch alternativ mit z.B. lauter "1100110011001100" 
beschreiben und mir ausgeben lassen und das funktioniert, nur dieser 
Zähler eben nicht.

[T.M. (Gast)]

Zunächst machst du aus

library ieee;
use ieee.std_logic_1164.all;
use IEEE.std_logic_arith.all; 
use IEEE.std_logic_unsigned.all;
use IEEE.numeric_std.all;

dieses

library ieee;
use ieee.std_logic_1164.all;
use IEEE.numeric_std.all;

Die Libs std_logic_arith & std_logic_unsigned sind ganz großer Mist, 
weil nicht standardisiert. Wenn man die numeric_std benutzt hat man 
alles was man braucht.
Dann dürfte auch

buff_i <= to_integer(unsigned(buff));

funktionieren.

[T.M. (Gast)]

Achso, aus

buff <= conv_std_logic_vector(buff_i,32);

wird dann

buff <= std_logic_vector(to_unsigned(buff_i, 32));

Du hast in deinem Code oben munter durcheinander 
Konvertierungsfunktionen der drei Libraries benutzt, da kann die 
Synthese schonmal durcheinander kommen. Wie gesagt, NUR die numeric_std 
benutzen und die darin enthaltenen Funktionen.

Siehe: http://wiki.jhor.de/images/d/d6/Numeric_std.jpg

[Gustl B. (-gb-)]

Ja ... super, jetzt kann ich aber kein +, - oder = verwenden also die 
bräuchte ich schon irgendwie. Also vor allem sowas wie ein 
std_logic_vector minus ein anderer std_logic_vector oder auch plus.

[Christian R. (supachris)]

Gustl Buheitel schrieb:
> Ja ... super, jetzt kann ich aber kein +, - oder = verwenden also die
> bräuchte ich schon irgendwie. Also vor allem sowas wie ein
> std_logic_vector minus ein anderer std_logic_vector oder auch plus.

Du sollst ja auch nicht mit Vektoren rechnen, sondern mit unsigned und 
signed.

[T.M. (Gast)]

Wenn du unbedingt zwei als std_logic_vector definierte Signale zB. 
addieren willst, kannst du das dann über Konvertierungsfunktionen 
weiterhin machen:

signal a, b, c: std_logic_vector(31 downto 0);
....
c <= std_logic_vector(unsigned(a) + unsigned(b));
c <= std_logic_vector(signed(a) + signed(b));

Die kannst durch die Konvertierungsfunktionen also selbst entscheiden, 
ob du signed oder unsigned arbeiten willst, eine Möglichkeit, die du mit 
dieser, ich nenne sie jetzt einfach mal Wurstbibliothek, 
std_logic_unsigned nicht hast, weil du dich da für die ganze 
architecture auf unsigned festnagelst.

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

Dort im Beitrag "Codecheck Erstlingswerk VHDL Newbie :)" gehts weiter... :-/

[T.M. (Gast)]

Ich kann sowas bald nicht mehr lesen ;-)