Pseudzufallszahlen LPC 1768

[Christian Walker (Gast)]

Hallo,

ich bin ein ziemlicher Anfänger in der Mikrokontrollerprogrammierung und 
mich würde mal interessieren, wie ich auf einem Mikrocontroller wie dem 
LPC 1768 Pseudozufallszahlen in C generieren kann. Es gibt hier zwar 
einen Artikel, aber da wird nur auf richtige Zufallszahlen eingegangen, 
die brauche ich aber nicht. Also mein Beispiel sollte relativ einfach 
sein.

Liebe Grüße

Christian

[Michael R. (mexman)]

Hallo,

> ich bin ein ziemlicher Anfänger in der Mikrokontrollerprogrammierung und
> mich würde mal interessieren, wie ich auf einem Mikrocontroller wie dem
> LPC 1768 Pseudozufallszahlen in C generieren kann. Es gibt hier zwar
> einen Artikel, aber da wird nur auf richtige Zufallszahlen eingegangen,
> die brauche ich aber nicht. Also mein Beispiel sollte relativ einfach
> sein.

8 Bit:

;*********************************************************************** 
***
;                   Zufallszahlen (RANDOM = 1...FE)
;*********************************************************************** 
***
           ;RANDOM <> 0 zum Start
        RLF     RANDOM, W       ;
        RLF     RANDOM, W       ;
        BTFSC   RANDOM, 3       ;
        XORLW   1               ;
        BTFSC   RANDOM, 4       ;
        XORLW   1               ;
        BTFSC   RANDOM, 5       ;
        XORLW   1               ;
        MOVWF   RANDOM          ;
;*********************************************************************** 
***

[Michael R. (mexman)]

Die ASM Befehle musst Du fuer Deinen uC wohl anpassen.


Gruss

Michael

[Lötlackl *. (pappnase)]

Wenns in C sein soll, wie wäre es mit rand() aus der stdlib?

mfg

[heinz (Gast)]

Goggle mal nach Linear rückgekoppeltes Schieberegister (lfsr)

[Christian (Gast)]

** Lötlackl schrieb:
> Wenns in C sein soll, wie wäre es mit rand() aus der stdlib?
>
> mfg

Kann man denn die rand() Funktion einfach so auf einem Mikrocontroller 
verwenden?

Linear rückgekoppeltes Schieberegister werde ich mir mal anschauen, 
danke dafür.

[Lötlackl *. (pappnase)]

Christian schrieb:
> Kann man denn die rand() Funktion einfach so auf einem Mikrocontroller
> verwenden?

Ich hatte das schon mal gemacht. Bin dann über was anderes gestolpert, 
kam sogar hier irgendwo aus dem Forum, glaube ich. Siehe Anhang

mfg

[Michael F. (startrekmichi)]

Was auch sehr gut und einfach funktioniert ist der hier, den habe ich 
letztens mal auf einen FPGA gepackt:
http://de.wikipedia.org/wiki/Xorshift

Man braucht halt wirklich nur Xor und Shifts. Die Parameter sind etwas 
kritisch, aber für 32 und 64 Bit sind die gültigen glaube ich im 
originalen Paper aufgelistet. Wenn dir 8 oder 16 Bit reichen, gibt's die 
Werte hier:
http://www.arklyffe.com/main/2010/08/29/xorshift-pseudorandom-number-generator/

[Christian (Gast)]

Michael Frangenberg schrieb:
> Was auch sehr gut und einfach funktioniert ist der hier, den habe ichletztens 
mal auf einen FPGA gepackt:http://de.wikipedia.org/wiki/XorshiftMan braucht halt 
wirklich nur Xor und Shifts. Die Parameter sind etwaskritisch, aber für 32 und 64 
Bit sind die gültigen glaube ich imoriginalen Paper aufgelistet. Wenn dir 8 oder 
16 Bit reichen, gibt's dieWerte 
hier:http://www.arklyffe.com/main/2010/08/29/xorshift-p...

Das ist ein wirklich guter Link. Vielen Dank dafür.

Die einzige Möglichkeit, die mir eingefallen ist, um Zufallszahlen 
zwischen 30 und 120 zu erzeugen:

uint8_t xorshift8() 
{
    y8 ^= (y8 << 7);
    y8 ^= (y8 >> 5);
    return y8 ^= (y8 << 3);
}

uint8_t GetRandomNumberBetween30And120()
{
  uint8_t value;
  do
  {
    value=xorshift8();
  }while(value<30||value>120);
  return value;
}

Zwar ziemlich dämlich, aber es funktioniert erstmal.

[sebastian (Gast)]

Hi,
würde das hier auch funktionieren?

uint8_t GetRandomNumberBetween30And120()
{

  return (uint8_t)((uint16_t)xorshift8()*6/17)+30;
}

gruß
Seb

[Michael F. (startrekmichi)]

sebastian schrieb:
> Hi,
> würde das hier auch funktionieren?
>
> uint8_t GetRandomNumberBetween30And120()
> {
>
>   return (uint8_t)((uint16_t)xorshift8()*6/17)+30;
> }

Allgemein muss man dran denken, dass der Xorshift keine 0 erzeugen kann, 
dann wäre nämlich nichts mehr zum shiften da. Das ist auch der Grund, 
warum es nur wenige korrekte Parameter gibt. In diesem Fall würde es 
sogar noch funktionierten, aber nur wegen der Integerdivision. Und man 
sollte sicherheitshalber folgendes schreiben (6/17==0):
return (uint8_t)(  ((uint16_t)xorshift8()*6) /17) +30;

Was für Anforderungen hast du denn an die Zufallszahlen? Diese Rechnung 
wird dir durch die Quantisierung (nur ganze Zahlen) nämlich die 
Verteilung der Zahlen verschlechtern, sprich es wird keine saubere 
Gleichverteilung mehr sein. Unter dem Gesichtspunkt ist die "dämliche" 
Lösung besser, die liefert nämlich weiterhin eine Gleichverteilung.

mfg
 Michael

[sebastian (Gast)]

Michael Frangenberg schrieb:
> In diesem Fall würde es
> sogar noch funktionierten, aber nur wegen der Integerdivision. Und man
> sollte sicherheitshalber folgendes schreiben (6/17==0):
> return (uint8_t)(  ((uint16_t)xorshift8()*6) /17) +30;

Ja, nach ANSI haben zwar * und / die selbe Prio und deshalb sollte dann 
von links nach rechts berechnet werden, aber sicherer ist mit der 
Klammer.

> Was für Anforderungen hast du denn an die Zufallszahlen?

Ich, keine. Habe nur beim ansehen des Beispiels überlegt, wie man die 
lösung mit der Schleife in eine Berechnung umsetzten kann.
Bei der Schleifen Lösung kann e ja zu einem ziemlichen "pumpen" in der 
Laufzeit kommen?

> Diese Rechnung
> wird dir durch die Quantisierung (nur ganze Zahlen) nämlich die
> Verteilung der Zahlen verschlechtern, sprich es wird keine saubere
> Gleichverteilung mehr sein. Unter dem Gesichtspunkt ist die "dämliche"
> Lösung besser, die liefert nämlich weiterhin eine Gleichverteilung.

Ja, das habe ich mir berits gedacht. Aber in Stochastik habe ich immer 
geschlafen ;-)