Stratix blockram

Der Block Ram wird wohl intern mit 16 bit Adresse angebunden sein, 
deswegen geht nicht mehr.
Eine andere Begründung fällt mir jedenfalls nicht ein.


Sehe aber dein Problem nicht... wenn ich dich richtig verstanden habe 
bekommst du immer 32bit die du schreiben willst.

Also speicherst du die 32bit einfach schon im high/low teil des 64bit 
Registers was einen Takt später mit den nächsten 32bit komplett 
geschrieben wird.

Klar ist das ein wenig mehr Logikverbrauch, aber bei so einem Riesenchip 
spielt das wohl keine Rolle.

@Thomas

ich bin ein FPGA anfänger daher sind komplexe sachen noch nicht drin. LA 
sources sind da, fehlt nur RAM. Spectrum Anlyser brauche ich nicht, für 
digitales oscilloskop brauche ich AD wandler, das kann doch der FPGA 
nicht.
Verkaufen will ich nicht,mit so einem riesen chip eröfnen sich so viele 
möglichkeiten, gut ich weiss noch nciht welche aber schadet nciht etwas 
reserve zu haben.



@Iulius

wenn ich high/low die 32bit speichere und die nacheinander auslese 
entsteht doch eine verzögerung.
takt - high 32 lesen (in time)
takt - low 32 lesen (1 takt verzögert)
takt - address couter erhöhen (gehört zu design sowieso)
takt - high 32 lesen (1 task schon verögert durch low 32 von 
voraddresse)
takt - low 32 lesen (2 takte schon verzögert)

oder ist das total falsch und die low32 sind nur jedesmal einen takt 
verzögert?

Geht sowas auch bei jeder taktflanke?

Kannst du bitte das als vhdl beispiel zeigen? Ich habe mir paar vhdl 
memory controller angeguckt, nur wie ich die high/low ohne zeit verlust 
buffern soll verstehe ich nicht ganz.

mal ein beispiel für 32bit lesen und 64bit schreiben.

1

eingang_32bit : in STD_LOGIC_VECTOR (31 downto 0); 

2

ausgang_64bit : out STD_LOGIC_VECTOR (63 downto 0);

3

writeenable : out STD_LOGIC;

4

eingang_adresse : out STD_LOGIC_VECTOR (15 downto 0);

5

ausgang_adresse : out STD_LOGIC_VECTOR (15 downto 0);

6

...

7

SIGNAL puffer : STD_LOGIC_VECTOR (31 downto 0);

8

SIGNAL addr_puffer_eingang : STD_LOGIC_VECTOR (15 downto 0);

9

SIGNAL addr_puffer_ausgang : STD_LOGIC_VECTOR (15 downto 0);

10

SIGNAL write_wait : STD_LOGIC := '0';

11

...

12

13

schreiben: process(takt,write_wait)

14

begin

15

 IF RISING_EDGE(takt) THEN

16

17

  IF write_wait='0'

18

   writeenable <= 1; -- hier : low aktiv

19

   puffer <= eingang_32bit;

20

  else

21

   ausgang_64bit <= puffer & eingang_32bit;

22

   ausgang_adresse <= addr_puffer_ausgang;

23

   writeenable <= 0;

24

   addr_puffer_ausgang <= addr_puffer_ausgang +'1'

25

  end if;  

26

27

  write_wait <= not write_wait;

28

29

  eingang_adresse <= addr_puffer_eingang;

30

  addr_puffer_eingang <= addr_puffer_eingang +'1';

31

32

 end if;

33

end process schreiben;

hoffe das ist verständlich.


das mit dem 64bit register war etwas unglicklich formuliert oben...du 
speicherst natürlich nur den einen teil zwischen und brauchst demzufolge 
auch nur einen 32bit puffer.


so hast du aber 64bit in 2 takten, also wieder 32bit pro takt.


Falls du was anderes meinst, beschreib es bitte mal genauer.