-
Thread
Pseudo random sequences
Hallo, ich bin neu im forum und brauche ihre Hilfe. Ich versuche seit Tage einen linear schieberegister zu zeichnen und dann ein Sequenz mit matlab zu erzeugen aber ich kann es nicht.die länge des registers betrag m=20 mit dem primitiven Polynom x^20 +x^3 +1.Kann mir jemanden helfen? LG Jens
-
Thread
Schnelle (Pseudo-)Zufallszahlen
Der STM32F2xx hat ein "RNG - Random Number Genrator" im Chip.
Also global integer Rest = 0; Rest = Rest - 14; if Rest <= 0 then Rest = Rest + byte Random; byte Zufall = Rest mod 14; Diese Methode setzt voraus das unser Random eine unendlich lange Zufallsfolge erzeugt. Wenn dem so ist dann ist das Resultat Zufall egal mit welchem Modulus man
-
Thread
Zufallszahl beim Start des AVR gewinnen
10 Mio.) Man könnte das zwar noch verwirbeln, indem man die Werte dann als Startwerte für einen Pseudo-Random-Generator nimmt, aber das wäre dann doch wieder irgendwie korreliert. Also langer Rede, kurzer Sinn, was für ein Bauelement, Algorithmus, was immer, nimmt man dafür? Grüße Christoph
sie dann abwechselnd nehmen, oder auch z.b. mit bestimmten events das Random iterieren, um keine Sequenz zu generieren. Der Grund des Random-numer, zusätzlich zur Produktnumber ist, daß diese Geheim ist, d.h. nur der Hersteller kennt die Assotiation zwischen Random und Seriennummer
-
Thread
einfacher, kleiner(!) Pseudo Zufallsgenerator gesucht
Eine Liste von Methoden: http://en.wikipedia.org/wiki/List_of_random_number_generators Besonders einfach ist dieser hier: http://en.wikipedia.org/wiki/List_of_random_number_generators . Dort ist er allerdings nicht besonders gut erklärt. Ich meine, man shiftet
uint8_t Constant = MYRAND_CONSTANT; //implicit %256 by 8-bit datatype overflow g_nLastRandom = (g_nLastRandom * Multiplier + Constant)/* % MYRAND_MODULO*/; return g_nLastRandom; } [/C] So etwas hab ich mal für meine GeekClock gebraucht. Beachte aber, dass du immer noch einen Startwert
-
Thread
pseudo Zufallszahl Tiny13
.def scratch =r22 .def scratch2 =r23 .def scratch3 =r24 ; state_random ; ; Random number generator ; Maximal length 19 bit shift register sequence, adapted from the ; "getting started" notes of Dave van Horn. Thanks, Dave! random: ; scratch3 scratch2
;Make the LSB zero mov scratch,temp ;Put it back rjmp state_random_exit ;Bye bye state_random_1: ;Set a one in the lsb of the low byte mov temp,scratch ;Get the low byte ori temp,$01 ;Make the LSB one
-
Thread
float zufallszahl (negativer und positiver Bereich)
Mann, les mal ein simples C-Buch. [pre] The rand() function shall compute a sequence of pseudo-random integers in the range [0, {RAND_MAX}]. [/pre] Und noch viel wichtiger: [pre] The srand() function uses the argument as a seed for a new sequence of pseudo-random numbers to be returned
präzise definiert, was den Wertebereich angeht, da kann nix schiefgehen. Zitat: [pre] 7.20.2 Pseudo-random sequence generation functions 7.20.2.1 The rand function Synopsis #include <stdlib.h> int rand(void); Description The rand function computes a sequence of pseudo-random integers
-
Thread
Formel für Pseudozufallszahlen
nicht nur einen Funktionsaufruf für die Ermittlung einer Pseudo-Zufallszahl verwenden kannst, sondern dass die Controller-Hardware einen True-Random-Number-Generator bereitstellt, aus dem Du per Funktionsaufruf eine echte Zufallszahl statt einer Pseudo-Zufallszahl
sein, > dass Du mit der Software nicht nur einen Funktionsaufruf für die > Ermittlung einer Pseudo-Zufallszahl verwenden kannst, sondern dass die > Controller-Hardware einen True-Random-Number-Generator bereitstellt, aus > dem Du per Funktionsaufruf eine echte Zufallszahl statt einer > Pseudo-Zufallszahl
-
Thread
Random
Hallo, anbei ein Routine, die ich irgendwo im Netz gefunden habe. Da ich ziemlich lange suchen durfte, hilft es vielleicht auch anderen. Das Ding erzeugt Pseudo-Zufallszahlen, als Seed sollte man irgendwie mit einem zufälligen Wert <> 0 laden, ADC auslesen oder sowas, sonst bekommt man immer die gleiche Folge. Ich brauchte das für eine hochwichtige Sache: meine Frau hat ein Modell-Puppenhaus. Das hat einen Kamin. Der sollte "brennen". Das, was man als Flackerlicht im Modellhandel bekommt, war ein Witz. Nun flackern 15 LED und 3 sind ständig an, 6x gelb, 6x rot und 6x orange. Angtrieben
-
Thread
Random
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: --------------------------------------------------------------
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 =>
-
Thread
Frequency Hopping Synchronisation
modulation technique where the transmitter frequency hops from channel to channel in a predetermined but pseudo-random manner. The signal is de-hopped at the receiver by a frequency synthesiser controlled by a pseudo-random sequence generator synchronised to the transmitter's pseudo-random generator." "Direct Sequence (ds): A spread spectrum modulation technique where a pseudo-random code directly phase modulates a carrier, increasing the bandwidth of the transmission. The resulting signal has a noise-like spectrum. The signal is despread by correlating with a pseudo-random
-
Thread
ADCL auslesen
>Ich weiß immer noch nicht, was ein PRNG ist. Pseudo Random Noise Generator. >Rauschen am ADC ist besser als ein PRNG in SW. Dann aber auch echtes Rauschen an den ADC geben und nicht einfach das nur letzte Bit auswerten. Wo kommt dieses Rauschen
nicht, was ein PRNG ist. > > Aber hier über Zufallsgeneratoren schwadronieren. Super. > PRNG= Pseudo Random Number Generator > http://de.wikipedia.org/wiki/PRNG > > >> Andere Leute wiederum wissen nicht, was ein EVZ ist. > > Interessiere mich leider nicht sooo sehr für die schweizerische
-
Thread
Zufallszahlen mit Atmega8
Meine Lösung sieht so aus: [avrasm] ;generates 16 bit random value (16Bit SR with feedback on Bit 0, 2, 11, 15) RANDOM: mov Temp, RandomL ;exor feedback outputs for SR input andi Temp, 0b00000001 lsl Temp lsl Temp eor Temp, RandomL andi Temp, 0b00000100 swap Temp lsl Temp mov TempH, RandomH andi TempH, 0b00001000 swap TempH eor TempH, RandomH andi TempH, 0b10000000 eor TempH, Temp rol TempH rol RandomL rol RandomH ret [/avrasm] RandomL und RandomH müssen
-
Thread
Zufallszahlen
shift register. ... das ist der Kern der "Voodoo" in den Libraries ja meistens. Nennt sich dann Pseudo-Random-Binary-Sequence. ("PRBS") Das Problem des OT war aber ... Crazy Harry schrieb im Beitrag #7713640: > und festgestellt, daß immer die gleichen LEDs leuchten. ... dass dieses "linear
ich am entsprechenden PC war. Kann aber 1-2 Tage dauern. Ich habe auch schon den Startwert als Random gesetzt, also RandomSeed(Random) aber selbst das bringt immer das gleiche Muster.
-
Thread
Zufallszahl mit falscher Verteilung
Wenn die Spanne < der max Pseudo-Zufallszahl ist, versuch mal den folgenden Ansatz: Multipliziere das ganz normale RANDOM() Ergebnis mit der gewünschten SPANNE (= 1 + MAX - MIN) und teile das Ergebnis durch das maximale Ergebnis von RANDOM() + 1. Anschließend addierst du den gewünschten MIN-Wert. Ergebnis: Pseudo-Zufallszahlen von MIN...MAX, dabei haben alle Ausgabewerte des Pseudo-Zufallszahlen- generators ein Mitspracherecht
-
Thread
CortexM3 include problem
You can set the random seed using srand; it does nothing beyond storing its argument in the static variable used by rand. You can exploit this to make the pseudo-random sequence less predictable, if you wish, by using some
set the same random seed at the outset. Returns rand returns the next pseudo-random integer in sequence; it is a number between 0 and RAND_MAX (inclusive). srand does not return a result. Portability rand
-
Thread
pseudo zufall als pwm ersatz
die man gar nicht selbst gekommen wäre. Also, ich fasse die Verfahren zusammen: 1. PWM 2. Pseudo-random-noise mit rückgekoppeltem Shiftregister 3. höherwertige und niederwertige Bits des PWM Zählers tauschen 4. Primzahlincrement bei PWM-Zähler verwenden Na, das ist doch schon einiges. Vermuten
ajax wrote: > Also, ich fasse die Verfahren zusammen: > > 1. PWM > 2. Pseudo-random-noise mit rückgekoppeltem Shiftregister > 3. höherwertige und niederwertige Bits des PWM Zählers tauschen > 4. Primzahlincrement bei PWM-Zähler verwenden Du hast das Delta-Sigma Verfahren
-
Thread
Echte Zufallszahlen gigabyteweise herstellen (keine Pseudozufallszahlen)
macht der besser als eine beliebig andere Pkattform, außer dass > es bestimmt auch wieder nur Pseudo ist? Er dürfte bedeutend billiger sein als ein Hardware-Random-Generator. Ausserdem recht schnell mit 25Mbits pro Sekunde. Laut Datenblatt, Kap.27 aind es echte Zufallszahlen. http://ww1.microchip.com
zumindest sowas: "Thermal noise in the analog circuitry is digitized to provide entropy for a true random number generator (TRNG). The TRNG produces 16-bit uniformly distributed numbers. The Ember software uses the TRNG to seed a pseudo random number generator (PRNG)." Letzteres dürfte wohl am billigsten
-
Thread
Zufallszahlen
http://en.wikipedia.org/wiki/Hardware_random_number_generator http://www.vanheusden.com/aed/
http://www.true-random.com
-
Thread
MSP430 Binäre Zufallszahl generieren und darauf LEDs aufleuchten lassen
spezielle Hardware, die physikalische Eigenschaften ausnutzt. Hat ein Standard MSP430 aber nicht. Pseudo Random Generator ist dein Freund für die Suche. zB sowas: unsigned short lfsr = 0xACE1u; unsigned bit; unsigned rand(){ bit = ((lfsr >> 0) ^ (lfsr >> 2) ^ (lfsr >> 3) ^ (lfsr >> 5) )
; call to get new number mov.w &lfsr16, R8 ; load pseudo random number srbps_1 cal #show_next_bit ; ... some more code bit.w #0x0001, R9 ; test for rmore bits to show jnz srbps_1
-
Thread
Schieberegister für LTSpice
... das muss noch erweitert werden .... :-) 20er Fibonacci-LFSR zu Erzeugung mithilfe von " pseudo-random binary sequence" für weißes Rauschen .... Einstellung, Beweis und Vergleich mit LTspice dass es auch weißes Rauschen ist fehlt mir noch .... also ein ordentliches qualifiziertes Preview
musste noch erweitert werden .... :-) > > 20er Fibonacci-LFSR zu Erzeugung mithilfe von > " pseudo-random binary sequence" für weißes Rauschen .... > > Einstellung, Beweis und Vergleich mit LTspice dass es auch weißes > Rauschen ist fehlt mir noch .... also ein ordentliches qualifiziertes >
-
Thread
AVR Zufalsgenerator
(myRandom & 0xFF) >> 8; _delay_ms(20); } [/c] ADC Init usw. sind hier nicht bei, musst du selber schreiben.
Matthias Sch. schrieb im Beitrag #4174638: > PortB = (myRandom & 0xFF) >> 8; Q: was steht jetzt in PortB? (bzw. PORTB?)
-
Thread
echte Zufallszahlen erzeugen (Hardware RNG)
Aus dem STM32F$xx reference manual: RNG introduction The RNG processor is a random number generator, based on a continuous analog noise, that provides a random 32-bit value to the host when read. The RNG passed the FIPS PUB 140-2 (2001 October 10) tests with a success ratio of
pitschu schrieb im Beitrag #3435758: > The RNG processor is a random number generator, based on a continuous > analog noise, > that provides a random 32-bit value to the host when read. Interessant. Andererseits, da ja 1000 Transistoren in einem IC heutzutage
-
Thread
ATTINY85 als DCF77-Empfänger
dissemination-of-legal-time/dcf77/dcf77-phase-modulation.html In addition to the amplitude modulation (AM), a pseudo-random phase noise is modulated onto the carrier of DCF77. For this purpose, the phase is shifted in accordance with a binary random sequence by ±15,6°, the mean value of the carrier phase remaining
Noname (Gast) 26.12.2021 20:13 >In addition to the amplitude modulation (AM), a pseudo-random phase >noise is modulated onto the carrier of DCF77. For this purpose, the >phase is shifted in accordance with a binary random sequence by ±15,6°, >the mean value of the carrier phase
-
Thread
Zufallszahlen
random() schon mal die Suchfunktion hier probiert ??????? http://www.mikrocontroller.net/forum/read-1-31959.html
Ist natürlich nur die halbe Miete: /echte/ Zufallszahlen generiert man so nicht, nur pseudo-Zufall (PRNG - pseudo random number generator). Um echte Zufallszahlen haben sich vor allem die Kryptografen viele Gedanken gemacht, dort kann man nachlesen. In jedem Falle braucht man außer einem
-
Thread
Zufallszahl bei Start des Mikrocontrollers
bei jedem Neustart des Controllers anders sein. Aktuell verwende ich folgendes: [c] // Set Random Wakeup-ID m_random = xorshift8(); srand(m_random); WAKEUP_ID = STARTDEFID + (rand() % 31); [/c] Ist ja egtl. auch verständlich damit ich immer die gleiche Zahl erhalte, da die Base immer die
Wüsste jetzt wie ein MC-Program aus sich selbst heraus (Pseudo)Zufallszeiten erzeugen kann. Eine möglichkeit wäre bei der Initialisierung am CAN-BUS auf irgendwelche Signale zu lauschen und dabei einen Timer mitlaufen zulassen. Den Timer könnte man dann (beschnitten
-
Thread
Zufallszahl in C
naja rand() gibt dir nen Random integer wieder und mit % sorgst du dafür das der zwischen 0>=zahl<20 liegt
Alles viel zu kompliziert. Die Profis von XKCD machen das so [c]int getRandomNumber() { return 4; // chosen by fair dice roll. // guaranteed to be random. }[/c] :D
-
Thread
Stressfragen im Vorstellungsgespräch
finden, sondern man will diese echten Schwächen niemals nicht im VG erläutern. Deshalb muss man Pseudo Schwächen suchen und deshalb ist die Frage so blöd.
Random .. schrieb im Beitrag #5963999: > Hatte bei einem meiner ersten Gespräche bei einem der großen > embedded Chiphersteller (der mittlerweile aufgekauft wurde) folgende > Situation: > Meine eig.
-
Thread
Mikrokontroller Crash Kurs mit ANSI-C, mit ATMega Register Nutzung Gesperrt
lfsr = (lfsr >> 1) | (bit << 15); return lfsr; } [/c] Anbei die Histogramme für PseudoRandom(), (int)random & 255 und lsfr1(), jeweils für 20000 Durchläufe. Ich denke, man kann die Unterschiede sehen. ;-) (Hatte mich jetzt mal persönlich interessiert, wie gut sowas jeweils ist.)
(lfsr >> 1) | (bit << 15); > > return lfsr; > } > [/c] > > Anbei die Histogramme für PseudoRandom(), (int)random & 255 und lsfr1(), > jeweils für 20000 Durchläufe. Ich denke, man kann die Unterschiede > sehen. ;-) > > (Hatte mich jetzt mal persönlich interessiert, wie gut sowas jeweils
-
Thread
STM32: Arrays und Performance
= 42UL; /*pseudo-random, reproducible init*/ for (cnt = 0; cnt < ROWS * COLS; cnt++) world_8[cnt] = (INT8) Random(ALIVE+1UL); } static void Gol_Init_32(INT32 *world_32) { uint32_t cnt; rand_state = 42UL; /*pseudo-random, reproducible init*/ for (cnt = 0; cnt < ROWS * COLS; cnt++) world_32[cnt] = (INT32) Random(ALIVE+1UL); } static void Gol_Iteration_8(const INT8 *old_world, INT8 *new_world
-
Thread
CRC in FSK-Funkübertragungsstrecke
control loops" "The 9-bit pseudo-random number (“PN9”) generator is shown in the top of Figure 1. The generator is described by the polynomial x9 + x5 + x0. The PN9 generates all the values between 1 through 511 (inclusively) in a pseudo-random order as it is clocked. The latches are all set to ones at the start of a whitening operation." https://www.google.com/url?sa=t&source=web&rct=j&url=http://www.ti.com/lit/an/swra322/swra322
-
Thread
VHDL Debuging
. Ansonsten fuer die Module (koennen auch mehrere sein) eine saubere Testbench, die idealerweise Pseudo-Random Stimuli generiert. In der Testbench wird aus diesen Stimuli auch das erwartete Ergebnis berechnet (am besten von einer zweiten Person, um grobe Missverstaendnisse auszuschliessen) und dann wird
request/response Sequenzen kannst du dann in einer loop zig-tausendmal laufen lassen und immer neue pseudo-random Daten generieren. >Ich hätte auch solche assert mit Erwartungswerten gefüllt. Wie >Statemachine hat einen unzulässigen Zustand erreicht. Wenn deine Component ein Signal 'fsm_invalid'
-
Thread
Welches FPGA Board für TRNG (VHDL)
Hallo, für ein FH-Projekt sollen wir einen TRNG (True Random Number Generator) auf einem FPGA-Board realisieren. Erfahrung haben wir mit VHDL und weniger mit Verilog. Vielleicht hat ja jemand in diesem Forum diesbezüglich Erfahrung und kann mir und meiner
Rat geben auf welche > "featues" wir beim Kauf achten sollen. ?Bist Du sicher das ihre True Random und nich Pseudo-Random generieren wollt? Mit FPGA erzeugt man Pseudo-random über ein LFSR und dafür genügt ein kleiner FPGA aus dem letzten Jahrtausend. https://en.wikipedia.org/wiki/Linear-feedback_shift_register
-
Thread
zufallszahl Arduino
Hallo Leute ;) Ich habe mal eine kurze Frage zum random() Befehl. Ich beschreibe zurzeit ein Arduino mega 2560. Hier mal der Code: zufallszahl=random(1,6) Ich rufe diesen Code mehrmals hintereinander auf. Als ich mir mal die Zahlen anzeigen
random() hat genau gar nichts mit Zufall zu tun. random() generiert eine pseudo-Zufällige folge von zahlen. Die sieht zar zufällig aus, ist aber komplett deterministisch. Da der ATMega beim Reset halt alles
-
Thread
Rauschgenerator-> Welchen verwenden?
Peter R. schrieb im Beitrag #4817470: > Ein Pseudo-Zufallsgenerator mit sehr großer Kettenlänge ist dann doch > die passende Lösung. Wenn da die Zykluslänge über mehrere Tage geht, ist > das "Pseudo" garnicht mehr wirksam. Oh, Vorsicht! Sobald
leistungsfähige parametrisierbare Zufallsgeneratoren: http://www.boost.org/doc/libs/1_62_0/doc/html/boost_random.html
-
Thread
Verifikationsplan
gibt es auch eine oder mehrere Testbenches. Die arbeiten entweder mit fixen Parametern oder mit Pseudo-Random-Pattern. Bei fixen Parametern gebe ich natuerlich auch die erwarteten Ergebnisse vor, bei Pseudo-Random 'rechnet' die Testbench die erwarteten Werte selber aus (in einer Procedure oder Function
TB kann ja schliesslich auch fehlerhaft sein. Aber die allermeisten Sachen kann man auch mit Random-pattern in einer TB beschreiben und die Ergebnisse vorhersagen. Wenn ich auf die Signal-waves schaue erwarte ich ja auch was ganz bestimmtes um die Simulation bewerten zu koennen.
-
Thread
AVR: Zufallszahlengenerator - zufälliger Startwert
beschrieben. Eine Rauschquelle per ADC sampeln und damit die Zuffallsszahl erstellen. Stichwort True Random Number Generator https://en.wikipedia.org/wiki/Hardware_random_number_generator Die Kunst ist für die Entscheidung 1 oder 0 möglichst 0.5 für die Wahrscheinlichkeit zu erreichen. http://robertnz.net
#5717340: > Ich nutze einfach die angehängte Zufallsfunktion. ... und hast keine Ahnung wie pseudo-zufällig diese Werte wirklich sind.
-
Thread
RAND-Funktion
soooo anstrengend ist!!!!!!!!! int rand (void) The rand() function computes a sequence of pseudo-random integers in the range of 0 to RAND_MAX (as defined by the header file <stdlib.h>). The srand() function sets its argument seed as the seed for a new sequence of pseudorandom numbers to be
the underlying algorithm already uses 32-bit calculations, this causes a loss of precision. See random() for an alternate set of functions that retains full 32-bit precision. tz, tz, tz
-
Thread
Zufallszahl
oder weniger) haben. Na, das ist aber nicht (ganz) richtig. Es gibt zwei "Sorten": a.) Pseudo-Zufallszahlen b.) "echte" Zufallszahlen Pseudo-Zufallszahlen werden durch Pseudo-Zufallsgeneratoren erzeugt, auch PRNG (Pseudo Random Number Generator) genannt. Die "echten" Zufallszahlen sind
hoch die Wahrscheinlichkeit ist, ob eine Zahlenfolge nun zufällig ist oder nicht. Wenn Du bei Pseudo-Zufallszahlen mit statistischen Methoden feststellst, dass es höchstwahrscheinlich keine Zufallszahlen sind, ist der Algorithmus zum Erzeugen der Pseudo-Zufallszahlen untauglich. Wenn Du bei "echten
-
Thread
Einfacher Zufallsgenerator
moin Einfacher 24 Bit pseudo Generator Der Wert steht nach aufruf in Rand1 - Rand3 Rand ist im einfachsten Fall ein Register Init_Random: ;first time ldi TEMP,$AA ;Init the random number generator mov RAND1
, und dort ist der RAM-Inhalt nach PowerUp mehr oder weniger zufällig. Weiter geht's dann mit Pseudo-Zufall, weil's so einfach ist natürlich hausgemacht :-) Johann
-
Thread
Random-Algorithmus mit Seed-Möglichkeit
Hallo zusammen, Ich nutze zurzeit folgenden Algorithmus zur Erzeugung von Pseudo-Zufallszahlen: [c]static uint32_t do_random(uint32_t *ctx) { /* * Compute x = (7^5 * x) mod (2^31 - 1) * wihout overflowing 31 bits: * (2^31 - 1) = 127773 * (7^5) + 2836 * From "Random number generators: good ones are hard to find", * Park and Miller, Communications of the ACM, vol. 31, no. 10, * October 1988, p. 1195. */ uint32_t hi, lo, x; x = *ctx
-
Thread
[Arduino]Code mit Random funktioniert nicht
Gegenteil, die Arduino Doku ist eigentlich sogar recht ausführlich. http://arduino.cc/de/Reference/Random
bereits vorgeschlagen, stattdessen eine global deklarierte Variable verwenden. Und: Du erzeugst Pseudo-Zufallszahlen. So wie Du es machst, werden die Zufallszahlen immer in derselben Reihenfolge erzegt, d.h. bei verschiedenen Aufrufen der random-Funktion werden zwar nacheinander verschiedene Zufallszahlen
-
Thread
The NSA Back Door to NIST
The NIST standard gives a list of explicit mathematical data (E, p, n, f, P, Q) to be used for pseudo-random number generation. [...] No explanation is given of the particular choices (E, p, n, f, P, Q). We are told to use these data and not to question why. [...] It is a matter of public fact
AES zu generieren und dann mit AES CBC weiter zu arbeiten. CSPRNG = cryptographically secure pseudo-random number generator https://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_generator
-
Thread
Zeigt her Eure Layouts!
Angeregt durch Lothars LED-Stern, hier mal das Layout einer mit knapp 500 LEDs aufgebauten Pseudo-Analoguhr.
> Angeregt durch Lothars LED-Stern, hier mal das Layout einer mit > knapp 500 LEDs aufgebauten Pseudo-Analoguhr. Wundern würde es mich nicht, wenn euer CEO-MOD mit einer 10.000 LED Platine daherkommt ;-)
-
Thread
Zufallsgenerator - ungleiche Startwerte erzeugen
Hallo zusammen, ich nutze den Zufallsgenerator random() aus der stdlib, um Zufallszahlen von 0 bis 42 zu erzeugen (Das Resultat der random-Funktion wird mit Modulo zurechtskaliert). Nun ist es aber so, dass diese Funktion immer dieselbe Zahlenfolge
^= POLY; b >>= 1; // nächstes Bit von b } return c; } // Liefert eine Pseudo-Zufallszahl x mit 1 <= x <= 2^DEGREE-1 = 32767 unsigned short prandom(void) { return (unsigned short) (seed = pprod (seed, ROOT)); } // Liefert eine Pseudo-Zufallszahl x mit 1 <= x <= 2^23
-
Thread
Deterministischer Pseudozufall
Das was du möchtest sind wohl Counter Based Random Number Generators (http://www.deshawresearch.com/resources_random123.html). Eigentlich sind die für parallele Architekturen wie Grafikkarten gedacht aber sollten auch auf Mikrocontrollern laufen. Ich
wo in der Folge deine Sequenz startet. Deshalb laufen die Dinger auch unter PR(B)N Generatoren (Pseudo Random (Binary) Number Generator). Bei richtiger Wahl der Rückkopplungseingänge werden alle 2^32 - 1 erlaubten Zustände im Lauf von einem Zyklus genau einmal angenommen. Dein Systemgedächnis von dem
-
Thread
LTSpice - Versuch Rauschen mit Spannungsquelle zu erzeugen gibt konstante Werte
man das die Kurve irregulär (pseudo-zufällig) wird. Ebenso bewirkt eine Multiplikation mit etwa 100, das die Kurve nicht mehr konstant aussieht sondern irregulär. Vielen Dank nochmal. Falls möglich würde ich gerne noch eine Frage
Es gibt drei "random"-Funktionen. rand() rechteckig random()leicht gerundet white()stark gerundet rand(1k*time) berechnet jede ms einen neuen Zufallswert. Siehe Bild.
-
Thread
Zufallszahlen
Algorithmus, wie Du ihn beschrieben hast, verwenden. Deshalb nennen sich solche Funktionen auch _Pseudo-Zufallsgenerator_. Echte Zufallzahlen gibt es unter vernüftigen Betriebssystemen z.B. unter /dev/random.
lsl TEMP2 call RANDOM_BIT lsl TEMP2 call RANDOM_BIT lsl TEMP2 call RANDOM_BIT cpi TEMP2,37 brsh RANDOM_AGAIN mov RANDOM,TEMP2 sei ret RANDOM_BIT:
-
Thread
Verstehe den Reset vom Atmega328P nicht
} int main(void) { uart_init(); srand(getSeed()); sprintf(buffer, "Hallo Welt, Random %d\r\n", rand()%256); uart_puts(buffer); DDRB |= 1<<5; while (1) { _delay_ms(500); PORTB ^= 1<<5; sprintf(buffer, "Neues Random %d\r\n", rand()%256); uart_puts(buffer
#endif /* UART_H_ */ [/c] Als Ausgabe auf dem Terminal (Putty) erfolgt nur [c] Hallo Welt, Random 241 Hallo Welt, Random 252 Hallo Welt, Random 241 Hallo Welt, Random 252 Hallo Welt, Random 241 Hallo Welt, Random 252 Hallo Welt, Random 241 Hallo Welt, Random 252 [...] [/c]
-
Thread
VHDL: Zufallswerte für die Initialisierung erzeugen
Martin S. schrieb im Beitrag #7898741: > Mit real und random ist das nicht eindeutig aufloesbar, Die Frage ist, was die Synthese zum Erstellungszeitpunkt dann für Werte nimmt? Florian schrieb im Beitrag #7901457: > es sieht in der Simulation gut aus und
bei jeder Synthese anders waren. PS: Ich habe gerade nochmal nachgelesen. https://vhdlwhiz.com/random-numbers/ "Just like other pseudo-random number generators, uniform will generate the same sequence of numbers when called with the same initial seed values. Because of this behavior, you can rerun
-
Thread
Random-Access bei ZBT SRAM
Hallo, weiß jemand, wie die Performance bei Zufälligen Zugriffsmustern auf ein ZBT SRAM ist? Ist das sowas ähnliches wie ein Pseudo-SRAM, oder handelt es sich wirklich um ein richtiges SRAM mit synchronem Interface? Grüße Gast