-
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
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
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
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
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
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
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
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
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
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
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
Bascom RND Befehl nicht wirklich Randome?
Also ich bin der Meinung das der RND befehl in Bascom nicht wirklich zufällig ist . Hier mein Programm: [code] $regfile = "m8def.dat" $crystal = 1000000 Config Pinb.1 = Output Config Lcdpin = Pin , Db4 = Portd.4 , Db5 = Portd.5 , Db6 = Portd.6 , _ Db7 = Portd.7 , E = Portd.3 , Rs = Portd.2 Config Lcd = 16 * 1 Cursor Off Config Portb.2 = Output Dim Zufall As Byte Dim Speed As Byte Dim I As Byte Dim Speed2 As Byte Portb.2 = 1 Portc.5 = 1 Do If Pinb.1 = 1 Then Zufall = Rnd(10) Speed = 1 Speed2 = 0.7 If Zufall = 7 Then Cls Locate
-
Thread
Zufallszahlen erzeugen
Die random()-Funktion funktioniert in der avr-libc praktisch genauso wie auf einem PC: sie erzeugt eine Pseudo-Zufallszahlenfolge (allerdings eines kleineren Wertebereichs durch den kleineren Datentyp "int"
Nimm die Funktion hier... ;-) public int getRandomNumber() { return 4; // chosen by fair dice roll // guaranteed to be random }
-
Thread
Zufallszahlen für PIC in ASM?
Hi, wie kann ich mit einem PIC 16F630 (Pseudo-) Zufallszahlen erzeugen? Am besten ohne äussere Beschltung also nur durch Zuhilfenahme von Assembler code? Ich habe schon gesucht aber nichts gefunden. ...warscheilich weil es unmöglich ist
Schau mal hier :http://www.piclist.com/techref/microchip/rand8bit.htm?key=random&from= MFG Ralf
-
Thread
Quellcode für Pseudozufallsgenerator
für Controller mit MUL-Befehl kann man leicht die bekannte Formel SEED=181*(OLDSEED)+359 [8 bit random number=high(SEED)] benutzen, um 8 bit Random-Werte zu erzeugen. Wenn es wichtig ist, dass beim Neustart des Prozessors auch "neue" Zufallszahlen erzeugt werden, muss man den Seed-Wert (in rndseed und
Ulrich [c] /**********************************************************************/ /** Simple pseudo random number generator. * * \note Based on work on Xorshift RNGs by George Marsaglia. * This simple implementation uses y as a fixed seed. * * \return number in range 0..2^32
-
Thread
Funktionsgeneratoren a la JDS6600, FY6800/6900 & Co.
Was mir dort besonders negativ aufgefallen ist: Das Rauschsignal ist nicht zufällig, sondern als Pseudo-Random-Noise in ziemlich schlechter Qualität generiert.
chris_ schrieb im Beitrag #6518570: > Das Rauschsignal ist nicht zufällig, sondern als Pseudo-Random-Noise in > ziemlich schlechter Qualität generiert. Der "Random-Noise" wird nicht laufend berechnet oder gar analog erzeugt, sondern ist – wie die meisten anderen Waveforms auch – aus 8192
-
Thread
mehr als drei Speicherstellen bei inline-assembly (avr-gcc)
Variablen int8_t und int16_t und die muss ich alle irgendwie da übergeben... Ich sehe aber, dass mein Pseudo-Code nicht gerade optimal war... best L
schon recht. Aber in diesem speziellen Fall will ich wirklich die Adresse. Und ja, mein initialer Pseudo-Code-Schnippsel war fehlerhaft in der Beziehung)... L
-
Thread
Anschaffung Logic Analyzer
Uebergaenge aufzeichnen. Ein einfaches Taktsignal bringt das schon zum Scheitern, oder ein PRBS (pseudo-random bit stream) erst recht - und hier noch ein kleines Geheimnis - solche PRBS-Datenstroeme sind nicht gerade selten.
Uebergaenge aufzeichnen. Ein einfaches Taktsignal bringt das schon > zum Scheitern, oder ein PRBS (pseudo-random bit stream) erst recht - und > hier noch ein kleines Geheimnis - solche PRBS-Datenstroeme sind nicht > gerade selten.
-
Thread
Wie erstellt man einen Pseudo Zufallsgenerator Atemga8(c)
Taste gedrückt wurde... nach 5 mal >>Mittelwert >LCD -- wollte fragen wie man so quasi einen Pseudo Zufallsgenerator einbaut ...., weil sonst wird die Reaktionszeit verfälscht, da die eine Led immer im gleichen "Rysums" angeht sprich jede 3 sec nachdem gedrückt wurde (_delay_ms(3000);)..... hoffe
rand bzw. random in verbindung mit srandom bzw. srand ggf. noch mit ADC rauschen als seed
-
Thread
Zufallsgenerator mit einem AT90S8515
Echte Zufallswerte wirst du so nicht bekommen, höchstens sg. Pseudo Zufallszahlen. Guckst du hier: http://www.agner.org/random/ Um echte Zufallszahlen zu bekommen, benötigst du auch einen richtigen Zufallsprozess. Z. B. das Rauschen von Halbleiterbauelementen. Dies
Ich denke mal auch, das die Kombination aus Pseudo-Zufallszahlengenerator mit einem Startwert aus dem "zappeln" des niederwertigsten Bits vom ADC aureichend zufällig ist. Kommt natürlich immer darauf ann, was man damit machen will, und in welchem
-
Thread
Zufallsgenerator und Pinbelegung
http://www.mikrocontroller.net/articles/Zufallszahlen http://mywebpages.comcast.net/orb/ Open Random Bit Generator, ein 8-Pin-PIC mit ADC und 100k von einem Ausgang zum ADC-Eingang. Der Ausgang wird mit endlicher Wahrscheinlichkeit nach H oder L geschaltet, das Rauschen des letzten Bits im ADC liefert
In C ist das eine recht simple Sache: [c]public int getRandomNumber() { return 4; // chosen by fair dice roll // guaranteed to be random } [/c] :))
-
Thread
Zufall per Hardware erzeugen
Hallo, auch wenn mir die random Funktion genügt, so würde ich doch für den STm32F1xx eine zufällige Startzahl benöitigen, damit nicht immer die gleichen Zahlen entstehen. Der F1 hat keinen RNG wie der F4. Nur ist es bei uC mit Zufall
irgendeine Hashfunktion)? Wenn man Daten aus den Entropy-Pools input_pool oder blocking_pool (-> /dev/random) entnimmt, weden diese mit SHA-1 gehasht und gefalten. Für /dev/urandom wird ChaCha20 aus dem input_pool geseedet.
-
Thread
Raspberry Pi 2 mit Quad-Core ARM Cortex A7, 1 GB RAM
Sequential Read : 23.673 MB/s Sequential Write : 15.861 MB/s Random Read 512KB : 23.350 MB/s Random Write 512KB : 15.700 MB/s Random Read 4KB (QD=1) : 7.875 MB/s [ 1922.6 IOPS] Random Write 4KB (QD=1) : 3.462 MB/s [ 845.2 IOPS] Random Read 4KB (QD=32) : 8.871 MB
Class 10 UHS-1 microSD: > > Sequential Read : 23.673 MB/s > Sequential Write : 15.861 MB/s > Random Read 512KB : 23.350 MB/s > Random Write 512KB : 15.700 MB/s > Random Read 4KB (QD=1) : 7.875 MB/s [ 1922.6 IOPS] > Random Write 4KB (QD=1) : 3.462 MB/s [ 845.2 IOPS] > Random Read 4KB (QD=32) :
-
Thread
Digispark Attiny85 schneller booten lassen.
byte y; void setup() { pinMode(links, OUTPUT); pinMode(rechts, OUTPUT); } void loop() { x=random(5)*50; analogWrite(links, x); delay(random(250)); y=random(5)*50; analogWrite(rechts, y); delay(random(250)); } Es funktioniert auch so wie es so soll. Und blinkt und blitzt pausenlos bis
Paradebeispiel für einen Tiny13. Der lässt sich ebenfalls über die Arduino IDE proggen, mit ISP und Pseudo-Bootloader für die IDE oder auch mit echtem Bootloader, da wird der Platz dann knapp... Keine Platine, nur ein kleiner Käfer mit 8 Beinchen
-
Thread
AVR und Zufallszahlen erzeugen
welche sprache? in c gibts dafür funktionen, in codevision z.B. int rand (void) generates a pseudo-random number between 0 and 32767.
dazu stehen Pseudo-Zufalls-Geenratoren. Diese entsprechen ganz exakt der Mathematik, sind also absolut exakt vorhersehbar, und somit kann man über die Wahl der richtigen Paramerter und Verfahren auch ganz exakt ausrechnen
-
Thread
Zufallszahlen mit Attiny13
zufallszahl.Kann man schön im AVR-Studio testen . [avrasm] ;RAND1 - RAND3 = ram oder Register Init_Random: ;first time ldi TEMP,$AA ;Init the random number generator mov RAND1,TEMP ;since a 00,00,00 state will not mov RAND2,TEMP ;progress. mov RAND3,TEMP ;you can get a timer
dass sie nicht bei jedem Einschalten den gleichen Ablauf liefert. Auch ein > 100-Bit breiter Pseudo-Zufallsgenerator braucht einen ZUFÄLLIGEN Startwert, um nicht immer wieder den selben Ablauf zu liefern.
-
Thread
ARM HardFault
Random .. schrieb im Beitrag #5334529: > Der HardFault ist die letzte Eskalationsstufe eines Faults Leider falsch. Die letzte Stufe ist der Lockup - wenn ein Fault im HardFault Handler selbst auftritt
Jim M. schrieb im Beitrag #5334535: > Random .. schrieb im Beitrag #5334529: >> Der HardFault ist die letzte Eskalationsstufe eines Faults > > Leider falsch. Die letzte Stufe ist der Lockup - wenn ein Fault im > HardFault Handler selbst
-
Thread
Azubi Elektro Projekt
Nicht-Deterministische Zufallszahlengeneratoren. Deine Aussage gilt nur für erstere; auch PRNG (pseudo random number generator) genannt.
Nicht-Deterministische Zufallszahlengeneratoren. > Deine Aussage gilt nur für erstere; auch PRNG (pseudo random number > generator) genannt. Ja das stimmt so. Für dieses Spiel ist ein PRNG die richtige Wahl. Die PRNG sind eine Untermenge aller RNG. Dass MaWin den PRNG meinte, ging aus dem Kontext