Random

[Andreas Sathle (Gast)]

Hallo,

habe ein kleines Problem. Ich brauche eine Zufallszahl zwischen 1 und
6.

Habe dieses Package im Internet gefunden.

Allerdings kriege ich immer wieder die gleiche Zahl zurück.

Wenn ich Seed erste Zahl in der Klammer ändere, bekomme ich zwar eine
andere Zahl, aber jedes mal die unf initialisieren ?!?
--------------------------------------------------------------------
process(test_btn)
      variable unf:  Uniform := InitUniform(7, 2.0, 6.0);
      variable rnd:  real := 0.0;
      variable rnd_int : integer;
  begin
    if test_btn='1' then
      GenRnd(unf);
      rnd := unf.rnd;
      rnd_int := INTEGER(rnd);
      AUSGABE<=rnd_int;
    end if;

  end process;
--------------------------------------------------------------------

kann mir bitte einer sagen wo ich den Fehler mache bzw. mir einen
anderen Zufallsgenerator schicken.

Danke und Grüße
Andreas

[Jochen Pernsteiner (Gast)]

Willst Du das mal synthetisieren oder brauchst Du die Zufallszahl nur
für Simulationszwecke?

Falls ersteres zutrifft: was Du brauchst ist ein rückgekoppeltes
Schieberegister (englisch: "Linear Feedback Shift Register", oder
kurz LFSR).

Schau mal bei Google.

[Andreas Sathle (Gast)]

Eigentlich beides.

Ich habe jetzt ein LFSR runtergeladen....allerdings bekomme ich das
gleiche ergebniss wie bei dem Random oben.

Ich denke ich habe es einfach nicht verschtanden wie die beiden
funktionieren.

Hier eine Simulation die ich laufen lasse:
-------------------------------------------------------------------
architecture test of LFSR_generic_test is
Signal clock_in : STD_LOGIC :='0';
Signal reset_in : STD_LOGIC :='0';
Signal load_in  : STD_LOGIC :='0';
Signal seed_in  : std_logic_vector(2 downto 0);
begin

  -- instantiate a 3 bit LFSR
  LFSR1: LFSR_GENERIC generic map (  Width => 3  )
            port map  (  clock => clock_in,
                    resetn => reset_in,
                    load => load_in,
                    seed => seed_in,
                    parallel_out => parallel_out1,
                    serial_out => serial_out1
                  );
clock_in<= not clock_in after 10 ns;
load_in <= '1' after 100 ns;
seed_in <= "110" after 100 ns;
reset_in<= '1' after 1000 ns;
--------------------------------------------------------------------

parallel_out wir am anfang mit "111" und nach 100ns "110"<-seed
ausgegeben.

ich will aber das ich jedesmall eine andere zahl bekommen. Wie bekomme
ich das hin?

Kann mir bitte einen Beispiel hier reinposten oder per Mail schicken.

Grüße und schönes Wochenende
Andreas

[Andreas Sathle (Gast)]

clock_in<= not clock_in after 10 ns;
load_in <= '1' after 50 ns, '0' after 60 ns;
seed_in <= "011" after 100 ns;
reset_in<= '1' after 110 ns;

kleine änderung bei der simulation. jetzt sieht der ergebniss zwar
besser aus. aber wenn ich immer zu gleichen zeit auf out zugreifen
werde, dann bekomme ich auch den gleichen ergebniss.

stimmt das? wenn ja kann ich das irgendwie ändern?

[Jochen Pernsteiner (Gast)]

>aber wenn ich immer zu gleichen zeit auf out zugreifen
>werde, dann bekomme ich auch den gleichen ergebniss.

Klar stimmts. Ein LFSR ist ja auch nur ein
PSEUDO-Zufallszahlengenerator.

Du kannst keine Zufallszahl per Algorithmus herstellen. Sonst wäre es
ja auch keine Zufallszahl mehr.
Das einzige was Du machen kannst ist die Bitsequenz vergrößern =>
LFSR mit mehr Bits benutzen.

Wirkliche Zufallszahlen bekommst Du nur durch zufällige Prozesse, z.B.
Kernzerfall: Du schliesst einen Geigerzähler an den FPGA an.
Allerdings etwas unpraktisch.

[Andreas Sathle (Gast)]

Danke Jochen, hast mir trotzdem sehr geholfen.

Grüße
Andreas

[Freak5 (Gast)]

Er könnte doch einfach einen Pin mit einer kleinen Antenne ausstatten
und diesen Pin immer wieder einlesen.

Oder einfach irgendeinen Chip nehmen und übertakten. Da kommt dann auch
was zufälliges heraus. Vielleicht funzt das ja mit nem untervolteten
Ramspeicher auch(auch schon etwas übertrieben für 1-6, aber damit
könnte man das sicher richtig zufällig hinbekommen)

P.S.: Ist alles gerade ausgedacht worden. Ich bin ein Noob. Achtung.

[FPGA-User (Gast)]

mich würde mal interessieren, ob folgendes funktioniert:

1.) ein NAND-Gatter im FPGA rückkoppeln, 2. Eingang als Enable nutzen
ena = 1 : oszillator läuft
ena = 0 : off

process(nand_out, ena)
begin
   nand_out <= nand_out nand ena;
end

2.) mit diesem Signal einen "langsamen" Addierer übertakten:

signal slow_cnt_q : std_logic_vector(63 downto 0);
-- irgendeine Konstante
constant ADD_VAL  : std_logic_vector(63 downto 0) :=
x"6428946163675746";

process(reset, nand_out)
begin
   if reset='1' then
      slow_cnt_q <= (others=>'0')
   elsif rising_edge(nand_out) then
      clow_cnt_q <= slow_cnt_q + CONST;
   end if;
end process;

3.) ena vom NAND eine fixe Zeit auf '1' setzen, danach
Addierer auslesen
Ob das geht?

[Andreas Sathle (Gast)]

Ich habe das Problem wie folgt "gelöst"

Ich werde den LFSR gleich am Anfang starten und der läuft dann
durchgehend.

Das Project wird durch Benutzen der Star/Reset Taste gestartet.

Da die Zeitdifferenz zwischen dem Einschalten des Boards und dem Start
des Projects "immer" unterschiedlich ist...wird auch "immer" eine
andere Zahl ausgelesen.

Noch einfacher währe wenn man eine Endlosschleife programmiert die eine
Int-Zahl hoch inkrementiert. Man liest die genau wie oben dann beim
Start des Projects ab.