Daten in flash speichern und abrufen?

[Igor (Gast)]

Hallo,


ich hätt da mal ne frage: Ich möchte gerne werte in ein Flash speicher 
einlesen und sie bei bedarf ausgeben. Ich hab aber leider keine Ahnung 
wie ich das machen soll :(..... bin zwischen Anfänger und 
Fortgeschrittener...


Z.B ich lege werte für eine Efunkion ab. und möchte sie ausgeben?


Wie müsst ich das macheN?


Kann mir da jemand etwas helfen?



Danke


Gruß

[Igor (Gast)]

Ach ja ich verwende ein Spartan 6, SP601 board mit ISE als 
entwicklung...

[Iulius (Gast)]

Mit den Infos kann dir echt niemand helfen...

- welches board ?
- adressierung ?
- datenblatt vom flash ?
- Wo ist das konkrete Problem ?

wird dir wohl niemand hier mal eben den kompletten Flash "Controller" 
schreiben.

[Igor (Gast)]

Hi,



- welches board ?   >SP601 Board XC6SLX16-CS324-2CES FPGA
- adressierung ?    > ?
- datenblatt vom flash ? > 
http://www.numonyx.com/Documents/Datasheets/308551_J3D_Discrete_DS.pdf.
- Wo ist das konkrete Problem ? > welchen weg gibt es überhaupt daten 
einzulesen und auszugeben.


Beispiel. Ich möchte eine E funktion abspeichern und diese ausgeben bei 
z.B jeder fallenden flanke vom clock.


Wie müsst ich da vorgehen? um die daten einzuspeichern und auszugeben?



Gruß

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

> Wie müsst ich da vorgehen? um die daten einzuspeichern und auszugeben?
Das steht im Datenblatt des Flashs.
Ja, ich weiß, die Antwort ist etwas flapsig, aber deine Frage ist 
übertragen etwa: Wie starte und lande ich einen Airbus A380?
Keiner weiß, ob du einen Pilotenschein hast, schon mal irgendein 
Flugzeug geflogen hast, und was für ein Typ das war.
Zurückübertragen heißt das: welche Kenntnisse hast du?

> welchen weg gibt es überhaupt daten einzulesen und auszugeben.
Du könntest einen uC auf dem FPGA implementieren, der das macht.
Du könntest eine Statemachine auf dem FPGA implementieren.

BTW: woher bekommst du die Werte dieser e-Funktion?


> Beispiel. Ich möchte eine E funktion abspeichern und diese ausgeben bei
> z.B jeder fallenden flanke vom clock.
Dann mußt du den Takt erst mal vervielfachen, denn um einen Wert aus dem 
Flash zu lesen sind einige aktionen nötig, von denen jede einen 
Taktzyklus braucht.

[Igor (Gast)]

:) also da mit dem aribus trifft es genau.


Ich möchte die werte selber erstellen und sie im Flash speichern und 
dann abrufen....

Gibt es den irgendein Beispiel?




Gruß

[M. (Gast)]

Hallo,


bzw. für den Anfang wie kann ich über Impact eine Datei in ein Flash 
ablegen?


Flash hat 16 Mb größe.... und ich möchte 2 12bit breite werte 
einspeichern z.b "111111111111" und "000000000000";


Wie muss meine Datei ausschauen?



Gruß

[mki (Gast)]

Bestimmt gibt es da ein paar Beispiele. Der Flash hat bestimmt ein 
ChipEnable, ein ReadEnable oder WriteEnable, ein paar Addressleitungen 
und ein paar Datenleitungen als input und output (alles nur geraten). 
Wenn dem so ist dann ist es ja ganz einfach:
- ChipEnable auf 1
- Read/WriteEnable auf 1 oder 0 (je nach dem was man machen will)
- Addresse anlegen
- Daten anlegen
- ein Takt warten und die Daten sind gespeicher (bzw. wurden gelesen)

Welche Leitungen genau da sind und wie die heißen, steht im Datenblatt. 
Wie die angesprochen werden und welche Zeitanforderungen die haben, 
steht irgentwo darunter.

[igor (Gast)]

Hi,

ja das Datenblatt hab ich mir angeschaut und da steht die Grafik mit den 
Taktanforderungen... ich wollte für den Anfang einfach mal versuchen 
über Impact ins flash zu laden.

Ich dachte sowas wie ein .coe file wo ich quasi daten hinterlege. Sowas 
wollte ich mal in flash reinladen, eine datei wo daten sind....


Und da komm ich nicht so drauf...



Gruß

[Marcus W. (Gast)]

Auch wenn du den Flash mit einem Muster füllst, so musst du dir dannach 
ein VHDL-Modul schreiben, dass den Flash auch wieder lesen kann.
Denke eher das ist dein primäres Problem.

Und wenn du ein Modul zum Auslesen hast, dann kannst du auch problemlos 
die Schreibfunktion dazu schreiben. Nur wird dir das hier keiner 
abnehmen, das musst du schon selbst machen oder du schaust mal auf 
Opencores.org und holst dir da ein paar Anregungen.

[Iulius (Gast)]

Bitte bedenken das es sich um einen Configurationsflash beinhaltet.

Das man so einfach da rein schreiben kann ist nicht gesichert. Beim 
Virtex 5 z.b. geht das mit dem Startup Block von Xilinx, beim Spartan 6 
weiß ichs nicht.

Jedenfalls kann man den Takt- sowie Schreibpin nicht ohne weiteres 
nutzen.

[igor (Gast)]

Ok,

danke für die Antwort. Ich weiß das ich das Auslesen selber machen muss 
in vhdl, ich wollte einfach mal probieren etwas in den flash zu 
speichern und zwar mit der impact.


Kann mir jemand nur bitte sagen wie es den ungefähr gehen müsste mit der 
impact?hat das jemand mal gemacht?  Wie muss dann meine Datei aussehen? 
welche endung muss sie haben? Wie müssen die daten aussehen?




Danke

[Iulius (Gast)]

Impact frisst das intel hex format mcs, das (nach kurzer suche per 
google) recht einfach zu verstehen ist.

Eventuell musst du ihm aber vorgaukeln das da eine Konfiguration für den 
Spartan drinne steht, damit er es flasht, so genau weiß ich das nicht, 
hab bisher den config-flash noch nicht für sowas missbraucht.



Aber denk dran, du kannst den flash nur auslesen wenn du die config pins 
des spartans nutzen kannst, das geht nicht einfach per ucf.

siehe z.b. xapp 1020.


sinvoller wäre wohl in jedem Fall den ddr2 zu nutzen, der nicht nur 
bedeutend schneller ist, sondern auch größer, langlebiger und mit 
Referenzdesign.

[Igor (Gast)]

Hallo,

also ich habe es geschaft meine Konfiguration ins Flash zu laden. Meine 
Frage:

Kann ich eine quasi Konfiguration erstellen in dem mehrere Daten dem 
ausgang zuweise . Diese Konfig ins flash lade.

Dann würd ich eine zweite Konfig erstellen in dem ich einen Eingang hab 
dem ich dem Ausgang von der KOnfig vom Flash zuweise und quasi diese 
Daten dann für den Eingang benutze. Die Konfig würd ich dann ganz normal 
gleich in den Spartan laden...



Würde dies theoretisch gehen?



Gruß

[Christian R. (supachris)]

Wie bitte was?

[Igor (Gast)]

Sorry etwas umständlich beschrieben...

Ich möchte ja Daten ins Flash speichern und diese verwenden. So um dies 
zu tuen erstelle ich eine quasi Konfiguration, diese ist aber nur mit 
Daten versehen die auf einem Ausgang anliegen. Um es ins Flash zu laden 
via Impact, muss es ja ein .mcs Datei sein.


Dann möchte ich mir diese Daten aus dem Flash (die ja eingespeichert 
sind) verwenden.

Die Verwendung passiert dann in der richtigen Konfiguration von meine 
Program welches ich dann direkt in den Chip lade.

Beispiel.

Im Flash sind 6 Werte 8 bit breit eingespeichert. Diese 6 Werte lade ich 
dann aus dem Flash und multiplizere sie mit einem Wert von meine 
Program....


Ich hoffe etwas besser beschrieben...



Gruß

[Iulius (Gast)]

Vorgehensweise :

- Controller im FPGA implementieren der nach oben verlinktem Datenblatt 
arbeitet

Dürfte nicht allzu wild sein.. Adressleitung ensprechend dem zu ladenden 
Wert  + die paar enables und dann kannst 1 Takt später den Wert an den D 
Pins abgreifen. BPI Flash ist da wohl ziemlich simpel gestrickt.

- Die Pins musst natürlich korrekt zuweisen.

Da dies ein Konfigurationsflash ist wirst du höchstenswarscheinlich 
keinen direkten Zugriff auf die Pins haben.

Du musst also eine xilinx Primitive instantiieren anstatt diese Pins 
einfach als in/out des top levels zu beschreiben.

nennt sich "STARTUP_SPARTAN6". Allerdings findet man kaum Informationen 
dazu. Im zweifelsfall an die Beschreibung im xapp 1020 halten (natürlich 
musst du trotzdem die STARTUP_SPARTAN6 instantieren und nicht die 
virtex5 primitive !)

- per Impact flash beschreiben (mit deinen Werten)
- per Impact FPGA laden (mit Bitfile)


Bei konkreten Fragen kann man sicher auch mehr dazu sagen.

[Christian R. (supachris)]

Am besten schaust du mal im Configuration User Guide, wie man zusätzlich 
zum Config-File noch andere Daten in den Flash mit packt, die man dann 
benutzen kann. Beim Spartan 3 stand es irgendwo drin, glaube bei 
MultiBoot, wahrscheinlich gehts beim S6 ähnlich. Auf jeden Fall muss der 
FPGA erst mit dem konfig-File aus dem Flash geladen werden, bevor du mit 
dem eben geladenen Programm auf den Flash zugreifen kannst. Sonst 
müsstest du ja den FPGA erst mal über JTAG oder sonstwas anderes 
konfigurieren. Wieso nimmst du nicht den SPI Flash x4 auf dem Board für 
die Config? Dann hast du den BPI Flash ganz für das Design alleine....

[Igor (Gast)]

Ok, danke erstmal!

Hab mir schon das Datenblatt angeschaut vom Flash, und da steht ja wie 
mann die Signal anlegen muss wenn man daten schreiben bzw. lesen muss. 
Werde mich mal dran versuchen, und werde mich dann nochmal an euch 
wenden und wenn ihr lust habt könntet ihr mir vielleicht nochmal solche 
hilfreichen Tipps geben...wofür ich euch SEHR dankbar bin/wäre.




Gruß


Igor

[Igor (Gast)]

Hallo,

ich hab mir jetzt mal das intel hex format angeschaut. Angenommen ich 
möchte wie oben schon mal beschrieben daten im Flash ablegen z.B paar 
werte,  das ich mir diese werte als daten im hex format schreibe z.B

:10010000214601360121470136007EFE09D2190140 - WERT 1
:10010000214601360121470146807EFE0982190140 - WERT 2
:10010000214601360121470136007EFE09D2190140 - WERT 3... usw

diese dann im BPI ablege als mcs. Und dann im SPI eine Konfig erstelle 
die dann diese ausließt?



Kann man es so machen ?


Gruß

[Igor (Gast)]

Hallo,

also habe es jetzt mal so versucht. Ich habe eine .mcs datei erstellt 
und folgendes eingefügt

:10000000FFB07A543A281C130D09060403020101BB
:00000001FF

Dies bedeutet das ich 16 Werte 8bit breit abgespeichert habe.

Ich habe dann mich nach dem Datenblatt gehalten und habe folgendes 
geschrieben

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity FLASH_CONTROLLER is
    Port (   FLASH_RESET    : in  STD_LOGIC;
          FLASH_CLK     : in  STD_LOGIC;
          FLASH_ADD    : out   std_logic_vector (23 downto 0);
          FLASH_CE      : out std_logic;                 -- CHIP ENABLE
          FLASH_OE      : out std_logic;                  -- OUT ENABLE
          FLASH_DATA    : in STD_LOGIC_vector (7 downto 0);
          DATAOUT      : out std_logic_vector (7 downto 0));
end FLASH_CONTROLLER;

architecture Behavioral of FLASH_CONTROLLER is

Signal cnt     : integer range 0 to 3;
Signal CE,OE   : std_logic:='1';
Signal ADD,ADD1: std_logic_vector(23 downto 0);
Signal DA      : std_logic_vector(7 downto 0);
Signal ADD_ENABLE: std_logic;
begin
  
  FLASH_CE  <= CE;
  FLASH_OE  <= OE;
  FLASH_ADD <=ADD;
  ---------------------------------------------
  COUNT:process (FLASH_CLK) 
  begin
    if rising_edge (FLASH_CLK) then
      if cnt = 0 then
        ADD_ENABLE<= '1';
      elsif cnt = 3 then
        cnt<=0;
      else
        ADD_ENABLE<= '0';
        cnt <=cnt +1;
      end if;
    end if;
  end process COUNT;
  -----------------------------------------------
  FLASH_ADDRESSEN: process (FLASH_CLK)
  begin
    if rising_edge(FLASH_CLK) then
      if ADD_ENABLE = '1' then
        ADD1<=ADD1+1;
      elsif ADD1 = "111111111111111111111111" then
        ADD1<=   "000000000000000000000000";
      else
        ADD1<=ADD1;
      end if;
    end if;
  end process FLASH_ADDRESSEN;
  -------------------------------------------------
  FLASH: process (cnt)
  begin
    case cnt is
    
      when 0 =>  ADD <= ADD1;
              CE  <= '0';
              OE  <= '0';
    
      when 1 =>  ADD <= ADD;
              CE  <= '0';
              OE  <= '0';
    
      when 2 =>  ADD<=ADD;
              CE <='0';
              OE <='0';
              DATAOUT <= FLASH_DATA;
    
      when 3 =>  ADD<=ADD;
              CE <='1';
              OE <='1';
      end case;
  end process FLASH;
  --------------------------------------------------
end Behavioral;

Habe es jetzt trotzdem mal mit UCF probiert da Sie im Xilinx Datenblatt 
standen. Dies hab ich direkt programiert und die mcs ins Flash abgelegt, 
also zumindestens denk ich das...


Funzt natürlich nicht... was denkt ihr darüber?

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

Igor schrieb:
> Funzt natürlich nicht... was denkt ihr darüber?
Du hast ein Latch gebaut, das würde ich mir mal genauer ansehen:

  FLASH: process (cnt)
  begin
    case cnt is
      when 0 =>  ADD <= ADD1;
              CE  <= '0';
              OE  <= '0';
    
      when 1 =>  ADD <= ADD;
               :

Und dann ist auch noch die Sensitivliste unvollständig. In diesen 
kombinatorischen Prozess gehören eigentlich FLASH_DATA und ADD und ADD1 
auch mit rein. Aber das ist dein kleinstes Problem...


> Signal CE,OE   : std_logic:='1';
Das ist unnötig, weil es für kombinatorisch erzeugte Signale keinen 
Defaultwert geben kann.


> Funzt natürlich nicht... was denkt ihr darüber?
Was sagt die Simulation?

[Igor (Gast)]

Hallo,

danke für den Tipp. Woher kommt der Latch ich hab doch alle Fälle 
ausformuliert? Oder nicht?


So wie ich das jetzt gesehen habe ist eigentlich das größte Problem 
Daten  ins Flash zu kriegen, denn einfach eine .mcs zu erstellen mit den 
Zeilen:

:10000000FFB07A543A281C130D09060403020101BB
:00000001FF

will er mir nicht reinschreiben => Wahrscheinlich weil ich ihm 
vorgaukeln müsste das es um eine Konfig file handelt... nur was muss ich 
noch in die mcs einfügen das er mir die obigen Daten auch reinschreibt? 
:(



Das mit der Simulation ist so ein Ding, hab nicht verstanden wie ich das 
Simuliere ... ich weis ist mir etwas peinlich...


Gruß

[Igor (Gast)]

Hallo,

folgendes ist mir aufgefallen, als ich den schalter auf SPI Flash gelegt 
hatte und somit BPI aus war, hatt er die datei regeschrieben. Wenn der 
Schalter auf Bpi ist, und spi flash aus ist, dann schreibt er die datei 
nicht ...hm wieso?


Und ich verstehe nicht warum ich latch produziere, ich hab doch alle 
Fälle ausformuliert. Hier nochmal der veränderte Code

----------------------------------------------------------------------------------
-- Company: 
-- Engineer: 
-- 
-- Create Date:    17:15:57 12/21/2009 
-- Design Name: 
-- Module Name:    FLASH_CONTROLLER - Behavioral 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description: 
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity FLASH_CONTROLLER is
    Port (   FLASH_RESET    : in  STD_LOGIC;
          FLASH_CLK     : in  STD_LOGIC;
          FLASH_ADD    : out   std_logic_vector (23 downto 0);
          FLASH_CE      : out std_logic;                 -- CHIP ENABLE
          FLASH_OE      : out std_logic;                  -- OUT ENABLE
          FLASH_DATA    : in STD_LOGIC_vector (7 downto 0);
          DATAOUT      : out std_logic_vector (7 downto 0));
end FLASH_CONTROLLER;

architecture Behavioral of FLASH_CONTROLLER is

Signal cnt             : integer range 0 to 3;
Signal CE,OE           : std_logic;
Signal ADD            : std_logic_vector(23 downto 0);
Signal ADD1            : std_logic_vector(23 downto 0):="000000000000000000000000";
Signal DA              : std_logic_vector(7 downto 0);
Signal ADD_ENABLE        : std_logic;
begin
  
  FLASH_CE  <= CE;
  FLASH_OE  <= OE;
  FLASH_ADD <=ADD;
  ---------------------------------------------
  COUNT:process (FLASH_CLK) 
  begin
    if rising_edge (FLASH_CLK) then
      if cnt <=3 then
        cnt<=cnt+1;
      elsif cnt = 0 then
        ADD_ENABLE<= '1';
      elsif cnt = 3 then
        cnt<=0;
      else
        ADD_ENABLE<= '0';
      end if;
    end if;
  end process COUNT;
  -----------------------------------------------
  FLASH_ADDRESSEN: process (FLASH_CLK)
  begin
    if rising_edge(FLASH_CLK) then
      if ADD_ENABLE = '1' then
        ADD1<=ADD1+1;
      elsif ADD1 = "111111111111111111111111" then
        ADD1<=   "000000000000000000000000";
      else
        ADD1<=ADD1;
      end if;
    end if;
  end process FLASH_ADDRESSEN;
  -------------------------------------------------
  FLASH: process (FLASH_CLK)
  begin
    case cnt is
    
      when 0 =>  ADD <= ADD1;
              CE  <= '0';
              OE  <= '0';
              DA <=DA;
      when 1 =>  ADD <= ADD;
              CE  <= '0';
              OE  <= '0';
              DA  <=DA;
      when 2 =>  ADD<=ADD;
              CE <='0';
              OE <='0';
              DA <= FLASH_DATA;
      when 3 =>  ADD<=ADD;
              CE <='1';
              OE <='1';
              DA<=DA;
      when others=>ADD<=ADD;
              CE <='1';
              OE <='1'; 
              DA <=DA;
      end case;
  end process FLASH;
  --------------------------------------------------
    DATAOUT<=DA;




end Behavioral;

mann das macht langsam kein spaß mehr.. :(

[Christian R. (supachris)]

Igor schrieb:

> mann das macht langsam kein spaß mehr.. :(

Kein Wunder, wenn man so unstrukturiert, ohne Simulation und ohne 
Vorkenntnisse da ran geht. Da musst du jetzt durch. Als erstes würde ich 
empfehlen, dass du einen kompletten Flash-Controller in VHDL schreibst, 
der sich an das Datenblatt des Chips hält. Wenn du das erfolgreich 
simuliert hast, und die Waveforms genauso aussehen wie im Datenblatt des 
Flashes kannst du an der ImPact-Geschichte weiter arbeiten. Da musst du 
halt etwas tiefer eindringen, vielleicht will Impact noch irgendwelche 
Checksummen und sowas. Ich bekomme auch immer mal seltsame Warnungen, 
von wegen x4-Modus und sowas. Also irgendwie ist da noch mehr ins mcs 
File rein codiert. Ohne eine Verifikation des Designs ist das alles nur 
Rätsel-Raten. Also lerne Modelsim zuerst....dann kommst du auch voran.

[Igor (Gast)]

Hallo,

so jetzt hat es geklappt. Hier der Code

----------------------------------------------------------------------------------
-- Company: 
-- Engineer: 
-- 
-- Create Date:    17:15:57 12/21/2009 
-- Design Name: 
-- Module Name:    FLASH_CONTROLLER - Behavioral 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description: 
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity FLASH_CONTROLLER is
    Port (   FLASH_RESET    : in  STD_LOGIC;
          FLASH_CLK     : in  STD_LOGIC;
          FLASH_ADD    : out   std_logic_vector (23 downto 0);
          FLASH_RP      : out  std_logic; 
          FLASH_CE      : out std_logic;                 -- CHIP ENABLE
          FLASH_OE      : out std_logic;                  -- OUT ENABLE
          FLASH_DATA    : in STD_LOGIC_vector (7 downto 0);
          DATAOUT      : out std_logic_vector (7 downto 0));
end FLASH_CONTROLLER;

architecture Behavioral of FLASH_CONTROLLER is
---------------------------------------------
Signal cnt             : integer range 0 to 3:=0;
Signal CE,OE,RP         : std_logic;
Signal ADD            : std_logic_vector(23 downto 0):="111111111111111111111111";
Signal DATA_ENABLE      : std_logic;
Signal DA              : std_logic_vector(7 downto 0);
Signal ADD_ENABLE        : std_logic;
---------------------------------------------
begin

  ---------------------------------------------
  COUNT:process (FLASH_CLK) 
  begin
    if FLASH_RESET = '1' then
      cnt<=0;
    elsif falling_edge (FLASH_CLK) then
      cnt<=cnt+1;
    elsif cnt = 3 then
      cnt<=0;
    else
      cnt <=cnt;
    end if;
  end process COUNT;
  ---------------------------------------------
  TEST: process (cnt)
  begin
    case cnt is
    when 0 =>     ADD_ENABLE <= '1'; 
              DATA_ENABLE <= '0';
              CE        <=  '0';
              OE        <=  '0';
              RP        <=  '1';
    
    when 1 =>     ADD_ENABLE <= '0'; 
              DATA_ENABLE <= '0';
              CE        <=  '0';
              OE        <=  '0';
              RP        <=  '1';
    
    when 2 =>     ADD_ENABLE <= '0'; 
              DATA_ENABLE <= '1';
              CE        <=  '0';
              OE        <=  '0';
              RP        <=  '1';
    
    when 3 =>    ADD_ENABLE <= '0'; 
              DATA_ENABLE <= '0';
              CE        <=  '1';
              OE        <=  '1';
              RP        <=  '1';
    when others  => ADD_ENABLE <= '0'; 
              DATA_ENABLE <= '0';
              CE        <= '1';
              OE        <= '1';
              RP        <=  '1';
    end case;
  end process TEST;  
  -----------------------------------------------
  FLASH_DATEN_EINLESEN: process (FLASH_CLK)
  begin
    if falling_edge(FLASH_CLK) then
      if DATA_ENABLE = '1' then
        DA<=FLASH_DATA;
      else
        DA<=DA;
      end if;
    end if;
  end process FLASH_DATEN_EINLESEN;
  -------------------------------------------------
  FLASH_ADDRESSEN_AUSLESEN: process (FLASH_CLK)
  begin
    if falling_edge(FLASH_CLK) then
      if ADD_ENABLE = '1' then
        ADD<=ADD+1;
      elsif ADD = "000000000000000000011111" then
          ADD<= "000000000000000000000000";
      else
        ADD<=ADD;
      end if;
    end if;
  end process FLASH_ADDRESSEN_AUSLESEN;
  -------------------------------------------------
  
    DATAOUT  <=  DA;
    FLASH_RP <= RP;
    FLASH_CE  <= CE;
    FLASH_OE  <= OE;
    FLASH_ADD <=ADD;

end Behavioral;

Ich denke das ich noch bei der Addresszuweisung noch ein Fehler hab, 
weil ich nie auf Wert 0 komme, das behebe ich noch.

Danke an euch alle.


Gruß

[Igor (Gast)]

Hallo,


da mein Flash nur 8 bit Daten hergeben kann, und ich aber 12 bit brauche 
muss ich also alle 2 zyklen 2 byte zusammensetzen. Dazu habe ich oben 
den Code umgeschriebn und ein Zusandsautomat erstellt.

Meine Frage, mein Ausgang ist 12 bit breit. Wie weise ich den unteren 
bits das untere byte aus den Flash und den höreren bits das höhere byte 
aus den Flash zu?

Wie ich das über den Zustandautomaten mache, weiß ich schon, mir gehts 
nur um Teil wo ich die Zuweisung machen soll. ICh habs mal im code 
geschrieben.
Ich wäre euch für ein Tipp Dankbar!

Hier mal der VHDL CODE

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity FLASH_CONTROLLER is
    Port (   FLASH_RESET    : in  STD_LOGIC;
          FLASH_CLK     : in  STD_LOGIC;
          FLASH_ADD    : out   std_logic_vector (23 downto 0);
          FLASH_RP      : out  std_logic; 
          FLASH_CE      : out std_logic;                 -- CHIP ENABLE
          FLASH_OE      : out std_logic;                  -- OUT ENABLE
          FLASH_DATA    : in STD_LOGIC_vector (7 downto 0);
          DATAOUT      : out std_logic_vector (16 downto 0));
end FLASH_CONTROLLER;

architecture Behavioral of FLASH_CONTROLLER is
---------------------------------------------
Signal cnt1,cnt2                : integer range 0 to 4;
Signal CE,OE,RP                 : std_logic;
Signal ADD                    : std_logic_vector(23 downto 0);
Signal DATA_ENABLE_HI,DATA_ENABLE_LOW  : std_logic;
Signal DA_HI                  : std_logic_vector(15 downto 8);
Signal DA_LOW                  : std_logic_vector (7 downto 0);
Signal BYTE_SCHREIBEN            : std_logic;
Signal ADD_ENABLE,COUNT_ENABLE1,COUNT_ENABLE2  : std_logic;
type STATE_TYPE is (Grundzustand,Vorbereiten,Warten,Lesen_HI,Lesen_LOW,Anlegen_LOW,Anlegen_HI); 
Signal naechster_zustand: STATE_TYPE;
Signal aktueller_zustand: STATE_TYPE:=Grundzustand;

---------------------------------------------
begin

  --------------- ENABLE SIGNALE--------------
            
  ---------------------------------------------

  ZUSTAND_WEITERGEBEN:process (FLASH_CLK)
    begin
      if FLASH_RESET = '1' then
        aktueller_zustand<=Grundzustand;
      elsif rising_edge(Flash_CLK) then
        aktueller_zustand <= naechster_zustand;
      end if;
  end process ZUSTAND_WEITERGEBEN;  
  ---------------------------------------------
  
  Zustandsautomat:process (aktueller_zustand,ADD) 
  begin
  case aktueller_zustand is
    
    when Grundzustand =>    ADD_ENABLE       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '1';
                    OE            <=  '1';
                    RP            <=  '1';
                    naechster_zustand <= Vorbereiten;
        
    when Vorbereiten   =>   ADD_ENABLE       <= '1'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Warten;
    
    when Warten      =>    ADD_ENABLE       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Lesen_HI;
    
    
    when Lesen_HI      =>  ADD_ENABLE       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '1';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Anlegen_LOW;
      
    when Anlegen_LOW    =>  ADD_ENABLE       <= '1'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';          
                    if ADD = "000000000000000000011111" then
                    naechster_zustand <= Grundzustand;  
                    else
                    naechster_zustand <= Lesen_LOW;
                    end if;
    
    when Lesen_LOW      =>  ADD_ENABLE       <= '0'; 
                    BYTE_SCHREIBEN    <= '1';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '1';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Anlegen_HI;
    
    when Anlegen_HI    =>  ADD_ENABLE       <= '1'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';          
                    if ADD = "000000000000000000011111" then
                    naechster_zustand <= Grundzustand;  
                    else
                    naechster_zustand <= Lesen_HI;
                    end if;
    
    
    end case;
  end process Zustandsautomat;
  -------------------------------------------------  
  FLASH_ADDRESSEN_AUSLESEN: process (FLASH_CLK)
  begin
    if falling_edge(FLASH_CLK) then
      if ADD = "000000000000000000011111" then
        COUNT_ENABLE1<= '1';
        ADD<= "000000000000000000000000";
      elsif ADD_ENABLE = '1' then
        ADD<=ADD+1;
      else
        COUNT_ENABLE1<= '0';
        ADD<=ADD;
      end if;
    end if;
  end process FLASH_ADDRESSEN_AUSLESEN;
  -------------------------------------------------
  FLASH_DATEN_EINLESEN_HI_BITS: process (FLASH_CLK)
  begin
    if rising_edge(FLASH_CLK) then
      if DATA_ENABLE_HI = '1' then
        DA_HI<=FLASH_DATA;
      else
        DA_HI<=DA_HI;
      end if;
    end if;
  end process FLASH_DATEN_EINLESEN_HI_BITS;
  -------------------------------------------------
  FLASH_DATEN_EINLESEN_LOW_BITS: process (FLASH_CLK)
  begin
    if rising_edge(FLASH_CLK) then
      if DATA_ENABLE_LOW = '1' then
        DA_LOW<=FLASH_DATA;
      else
        DA_LOW<=DA_LOW;
      end if;
    end if;
  end process FLASH_DATEN_EINLESEN_LOW_BITS;
  -------------------------------------------------
  2BYTE_ZUSAMENSETZEN: process (FLASH_CLk)
  begin
    if falling_edge (FLASH_CLK) then
      if BYTE_SCHREIBEN  = '1'; then
        (DATAOUT 15 downto 8) <= DA_HI; ------------ HIER WIE MACHE ICH DAS? 
        (DATAOUT downto 0 <= DA_LOW;
      else
        DATAOUT<=DATAOUT;
      end if;
    
    end if;
  end process 2BYTE_ZUSAMENSETZEN;
  
  
  
  
  -------------------------------------------------
  --DATAOUT  <=  DA;
  FLASH_RP <= RP;
  FLASH_CE  <= CE;
  FLASH_OE  <= OE;
  FLASH_ADD <=ADD;
  -------------------------------------------------
end Behavioral;

[Iulius (Gast)]

meinst du das so ?

DATAOUT(15 downto 8) <= DA_HI;
DATAOUT(7 downto 0 <= DA_LOW;

alternativ :

dataout <= da_hi & da_low;

ansonsten kann ich mir nicht vorstellen was du meinst.


Achja : dein dataout soll 17 bit(16 downto 0) breit sein ?

Falls ja musst du natürlich noch vorne oder hinten ein bit anhängen.

[Igor (Gast)]

Ja genau das meine ich,

Mein Ausgang ist 12 bit breit, aus den Flash kommt 2 mal 8 bit, wobei 
halt die oberen 4 bit leer sind.


> dataout <= da_hi & da_low;

Wie kann man sich das vorstellen, denn ich muss halt das erste byte von 
FLASH meinem ausgang 12 downto 7, und das zweite byte vom FLASH meinem 
ausgang 7 downto 0 zuweisen!


Dazu kommt noch das ich 4 bits nicht brauche... den 2 byte sind 16 bit, 
davon brauche ich aber nur 12. Muss ich dann mein Ausgang auf 16 bit 
erweitern, aber in der ucf nichts machen? oder



Danke Gruß

[Christian R. (supachris)]

DATAOUT <= DA_High(3 downto 0) & DA_LOW;

& ist in VHDL ein Verkettungs-Operator. Hier verkettet er das untere 
Nibble vom Highbyte mit dem gesamten Lowbyte. Somit ergibts 12 Bit.
Das gleiche nur anders geschrieben wäre:

DATAOUT(11 downto 8) <= DA_High(3 downto 0);
DATAOUT(7 downto 0) <= DA_LOW;

[Igor (Gast)]

Hi,


genau das hab ich gemeint, vielen vielen Dank!

Wenn ich jetzt den  Dezimalwert 4095 => binär 111111111111 => HEX FFF,
in 2 byte zerlege, dann kriegt für das hi_byte den wert 0F und das low 
byte den wert FF? => (0FFF) und wenn es unter 8 bit ist, dann ist das hi 
byte immer 00 ?



Gruß

[Iulius (Gast)]

Nein, du bekommst exakt x"FFF" und nicht x"0FFF" und ein high"byte" gibt 
es bei 12 bit nicht.

Für letzteres müsstest du volle 16 Bit benutzen.

Das würde dann z.b. so aussehen :

DATAOUT <= "0000" & DA_High(3 downto 0) & DA_LOW;


Allerdings ist mir immer noch unklar was du nun eigentlich willst : 12 
oder 16 bit.

Dein code ist ausgerichtet auf 16, aber du schreibst ständig von 12...

[Igor (Gast)]

Oh, ich will nur 12 bit haben. Vom Flash kommen 8 bit, also muss ich 2 
mal auslesen! Und die daten  im Flash müssen gesplitet sein.


Aber das verwirrt mich halt, meine daten aus den flash sind nur 12 bit, 
da ich aber 2 mal auslesen muss komme ich ja auf 16 bit... :) jetzt 
verplannt es mich selber!


Ich wusste halt nicht wass ich mit den 4 bits vom HI_Byte machen soll 
die ich nicht brauche....?

Also was müsst ich jetzt ändern?

Gruß

[Iulius (Gast)]

Du solltest dir erstmal im Klaren darüber sein wie du speicherst.

Möglichkeit 1 (einfach und verschwenderisch) :

Du speicherst 2 8 byte werte und verwendest davon nur die unteren 12 
Bit. D.h. 4 bit vom auslesen werden immer weggeworfen.

Hier wäre es sinnvoll 2 * 6 bit zu verwenden und z.b. immer die oberen 2 
bit weg zu werfen.

Dann musst du nicht 2 unterschiedliche schaltungen für high und lowbyte 
aufbauen wie du es bisher tust.


Möglichkeit 2(nicht viel schwerer + schneller + sparsamer) :

du nutzt den vollen Speicherbereich aus und die oberen 4 bit sind 
praktisch shcon die unteren 4 bit des nächsten 12 Bit wertes.

D.h. du müsstest nur 3 mal lesen um 2 12 Bit Werte zu bekommen.



Hier kommts eben drauf an was du willst : für einen ersten Versuch 
reicht Methode 1 sicher auch und dein Aufbau warscheinlich auch.

Ist also nur ein Tipp wie ich es machen würde.


In jedem Fall sollte aber dein Dataout nur 12 bit breit sein (11 downto 
0) wenn du nur 12 bit haben möchtest.


Und beachten musst du natürlich auch wie du die Daten im Flash 
speicherst, das muss ja genauso passieren wie du auslesen willst später.

[Igor (Gast)]

Hallo,

vielen Dank für die Ratschläge. Ich habe es nach der ersten Methode 
gemacht und wollte jetzt mal ein Zahlenbeispiel geben und wollte mal 
fragen ob es so passt und ob der vhdl code dazu passt.

Ich habe die Zahl 4095 => in hexadezimal 0FFF. Ich habe dann das erste 
byte in 0F und das zweite byte FF in der mcs datei geschrieben. Und mein 
zustandsautomat funktioniert so:


Grundzustand =>
=> Vorbereiten (Hier wird Addresse angelegt) =>
=> Warten =>
=> Lesen_HI (Hier wird das erste Byte gelesen was ja den 0F wert hat)
=> Anlegen_low (Nächste Addresse wird angelegt)
=> Lesen_low(Hier wird das zweite byte gelesen was ja den FF Wert hat 
und ich gebe hier die daten Aus)
=> Anlegen_HI => (Nächst Addresse anlegen) Lesen_HI (Hier wieder zurück 
ans LesenHI)


--------
Nach den Ratschlag Simulieren zu sollen, hab ich mir Modelsim instaliert 
und lese mir ein Tutorail durch. Ich komme aber nicht so ganz zu recht. 
Ich habe eine Testbench erstellt, und auch ins Modelsim geladen, aber es 
wird nicht so simuliert wie ich es programmiert habe. Ich habe mal ein 
Bild angehängt. Muss ich noch was beachten, oder gibt es ein 
verständlichers Tutorial als das von Xilinx??

Hier jetzt mal der vhdl code

----------------------------------------------------------------------------------
-- Company: 
-- Engineer: 
-- 
-- Create Date:    17:15:57 12/21/2009 
-- Design Name: 
-- Module Name:    FLASH_CONTROLLER - Behavioral 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description: 
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity FLASH_CONTROLLER is
    Port (   FLASH_RESET    : in  STD_LOGIC;
          FLASH_CLK     : in  STD_LOGIC;
          FLASH_ADD    : out   std_logic_vector (23 downto 0);
          FLASH_RP      : out  std_logic; 
          FLASH_CE      : out std_logic;                 -- CHIP ENABLE
          FLASH_OE      : out std_logic;                  -- OUT ENABLE
          FLASH_DATA    : in STD_LOGIC_vector (7 downto 0);
          DATAOUT      : out std_logic_vector (11 downto 0));
end FLASH_CONTROLLER;

architecture Behavioral of FLASH_CONTROLLER is
---------------------------------------------

Signal CE,OE,RP                 : std_logic;
Signal ADD                    : std_logic_vector(23 downto 0);
Signal DATA_ENABLE_HI,DATA_ENABLE_LOW  : std_logic;
Signal DA_HI                  : std_logic_vector(7 downto 0);
Signal DA_LOW                  : std_logic_vector (7 downto 0);
Signal BYTE_SCHREIBEN            : std_logic;
Signal ADD_ENABLE,ADD_VOLL          : std_logic;
-------------------------------- ZUSTANDSAUTOMAT ----------------------------------------------
type STATE_TYPE is (Grundzustand,Vorbereiten,Warten,Lesen_HI,Lesen_LOW,Anlegen_LOW,Anlegen_HI); 
Signal naechster_zustand: STATE_TYPE;
Signal aktueller_zustand: STATE_TYPE:=Grundzustand;

-----------------------------------------------------------------------------------------------
begin

  --------------- ENABLE SIGNALE--------------
            
  ---------------------------------------------

  ZUSTAND_WEITERGEBEN:process (FLASH_CLK)
    begin
      if FLASH_RESET = '1' then
        aktueller_zustand<=Grundzustand;
      elsif rising_edge(Flash_CLK) then
        aktueller_zustand <= naechster_zustand;
      end if;
  end process ZUSTAND_WEITERGEBEN;  
  ---------------------------------------------
  
  Zustandsautomat:process (aktueller_zustand,ADD_VOLL) 
  begin
  case aktueller_zustand is
    
    when Grundzustand =>    ADD_ENABLE       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '1';
                    OE            <=  '1';
                    RP            <=  '1';
                    naechster_zustand <= Vorbereiten;
        
    when Vorbereiten   =>   ADD_ENABLE       <= '1'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Warten;
    
    when Warten      =>    ADD_ENABLE       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Lesen_HI;
    
    
    when Lesen_HI      =>  ADD_ENABLE       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '1';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Anlegen_LOW;
      
    when Anlegen_LOW    =>  ADD_ENABLE       <= '1'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';          
                    if ADD_VOLL = '1'  then
                    naechster_zustand <= Grundzustand;  
                    else
                    naechster_zustand <= Lesen_LOW;
                    end if;
    
    when Lesen_LOW      =>  ADD_ENABLE       <= '0'; 
                    BYTE_SCHREIBEN    <= '1';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '1';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Anlegen_HI;
    
    when Anlegen_HI    =>  ADD_ENABLE       <= '1'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';          
                    if ADD_VOLL = '1'  then
                    naechster_zustand <= Grundzustand;  
                    else
                    naechster_zustand <= Lesen_HI;
                    end if;
    
    
    end case;
  end process Zustandsautomat;
  -------------------------------------------------  
  FLASH_ADDRESSEN_AUSLESEN: process (FLASH_CLK)
  begin
    if falling_edge(FLASH_CLK) then
      if ADD = "000000000000000000011111" then
        ADD_VOLL<='1';
        ADD<= "000000000000000000000000";
      elsif ADD_ENABLE = '1' then
        ADD<=ADD+1;
      else
        ADD_VOLL<= '0';
        ADD<=ADD;
      end if;
    end if;
  end process FLASH_ADDRESSEN_AUSLESEN;
  -------------------------------------------------
  FLASH_DATEN_EINLESEN_HI_BITS: process (FLASH_CLK)
  begin
    if rising_edge(FLASH_CLK) then
      if DATA_ENABLE_HI = '1' then
        DA_HI<=FLASH_DATA;
      else
        DA_HI<=DA_HI;
      end if;
    end if;
  end process FLASH_DATEN_EINLESEN_HI_BITS;
  -------------------------------------------------
  FLASH_DATEN_EINLESEN_LOW_BITS: process (FLASH_CLK)
  begin
    if rising_edge(FLASH_CLK) then
      if DATA_ENABLE_LOW = '1' then
        DA_LOW<=FLASH_DATA;
      else
        DA_LOW<=DA_LOW;
      end if;
    end if;
  end process FLASH_DATEN_EINLESEN_LOW_BITS;
  -------------------------------------------------
  BYTE_ZUSAMENSETZEN: process (FLASH_CLK)
  begin
    if falling_edge (FLASH_CLK) then
      if BYTE_SCHREIBEN  = '1' then
        DATAOUT <= DA_HI(3 downto 0) & DA_LOW; 
      end if;
    
    end if;
  end process BYTE_ZUSAMENSETZEN;
  
  
  
  
  -------------------------------------------------
  --DATAOUT  <=  DA;
  FLASH_RP <= RP;
  FLASH_CE  <= CE;
  FLASH_OE  <= OE;
  FLASH_ADD <=ADD;
  -------------------------------------------------
end Behavioral;

Danke Gruß

[Christian R. (supachris)]

Gib mal noch die Testbench dazu, da schau ich mal. Prinzipiell simuliert 
Modelsim das, was du beschrieben hast.

[Igor (Gast)]

Ah ok, hier mal die Bench! Danke

[Christian R. (supachris)]

Ja, das Hauptprobelm ist, dass ADD keinen definierten Anfangszustand hat 
und du außerdem den Reset aus der Testbench heraus gar nicht bedienst. 
Wenn du das beides nachrüstet, läuft die Simulation.

[Igor (Gast)]

Hi,

also vielen Dank werd es gleich machen!

>Reset aus der Testbench heraus gar nicht bedienst.

Wie ist das gemeint? Ich muss den Wert für reset im modelsim eingeben?




Gruß

[Christian R. (supachris)]

Nein. Die Testbench stellt die äußere "Beschaltung" deines Moduls oder 
gesamten Designs dar. Alle externen Signale, die in das Modul herin 
gehen, musst du irgendwie bedienen. Wenn du alles verifizieren willst, 
müsstest du auch noch ein simples Modell für den Flash beschrieben, also 
dessen Funktion in VHDL nachbilden. Für den einfachsten Fall reicht es 
bei dir hier sicherlich das Reset mal kurz auf 1 gehen zu lassen, um 
alles zu intialisieren.

[Igor (Gast)]

Also so ganz hat das noch nicht funktioniert, ich wollte z.B alle Enable 
Signale aus dem Zustandsautomat simulieren, da zeigt er mir nichts an 
bzw. no data? Das Clocksignal hat ne größere Periode als im Vhdl. Ich 
dachte er erkennt was ich programiert habe und simuliert es nach.. oder?

[Christian R. (supachris)]

Er simuliert das, was du vorgibst. Das CLK Signal wird ja in der 
Testbench erzeugt und hatte dort bei deinem File 1µs Periodendauer. Bei 
mir klappte die Simulation, der Adress-Zähler zählt hoch und wird dann 
irgendwann zurück gesetzt. Wenn etwas nicht wie erwartet geht, kannst du 
anhand der Simulation herausfinden, was schief läuft. Bei No Data kann 
es sein, dass du die Simulation noch mal neu starten musst. Benutze mal 
das .do File im Anhang, das kannst du in Modelsim direkt starten. Es 
startet die Simulation, zeigt alle Signale an und lässt die Simulation 
einige zeit laufen. Das File kannst din Modelsim zum Projekt hinzufügen 
und dann mit Execute ausführen.

[Igor (Gast)]

Hi,

ja das mit der Addresse klappt auch, ich wollte nur auch alle anderen 
Signale mal anschauen. Ich hab es umgebaut um die daten schneller aus 
den falsh zu kriegen und hab das ganze jetzt mit 40 Mhz betrieben was ja 
einer Periodendauer von 25 ns wäre. Wie der auf 1 us kommt ist mir 
schleierhaft. naja ich teste mal weiter, danke für deine Mühe :)

[Christian R. (supachris)]

Durch diese Definition in der Testbench ist die Periodendauer 
festgelegt:

-- Clock period definitions
   constant FLASH_CLK_period : time := 1us;

Das musst du halt anpassen. Dem Simulator ist das völlig egal, welche 
Periodendauer du angibst...der simuliert ja erst mal nur Logik.

[Igor (Gast)]

Hallo,

so jetzt hab ich mal die Signale die ich wollte. 2 Fragen,

wieso wird alle data signale nicht weiter geändert?

Wie kann man den Abstand der  weißen senkrechten Striche in Modelsim 
verkleinern, das sie auf die Flanken passen?



Gruß


Igor

[Christian R. (supachris)]

Igor schrieb:

> wieso wird alle data signale nicht weiter geändert?

Weil du ja vom Flash keine Daten lieferst. Du müsstest den Flash in der 
Testbench so nachbilden, dass er bei unterschiedlichen Adressen 
unterschiedliche Daten liefert am Ausgang.

> Wie kann man den Abstand der  weißen senkrechten Striche in Modelsim
> verkleinern, das sie auf die Flanken passen?

Die sind durch den Zoom-Faktor so vorgegeben. Vielleicht kannst du mit 
Cursorn arbeiten um die Flankenbeziehungen zu sehen. Du kannst beliebig 
viele davon einfügen.