pseudo Zufallszahl Tiny13

[David .. (david1)]

Hallo, ich bastel grade an einem Programm zur beleuchtung eines 
gegenstandes.

Dazu hab ich einen ATTiny13, nun soll damit in gewissen Abständen eine 
LED an und aus gehen (stark vereinfach gesagt), das tut auch alles so 
wie es soll.


Nur bräuchte ich jetzt einen pseudo Zufallsgenerator damit die Sequenz 
immer etwas unterschiedlich aussieht, ich hab zwar jetzt schon 
gegoogelt, aber irgendwie erschlägt mich das "Angebot" deutlich.

Kennt da vlt jemand was was nicht viel Speicher braucht?
Ich brauch einfach eine "Zufallszahl zwischen 0 und 10 oder sowas 
ähnliches.

Denn davon hab ich auf dem Tiny13 wirklich ziemlich wenig.


Gruß
David

[Blaise Pascal (Gast)]

>aber irgendwie erschlägt mich das "Angebot" deutlich

Mathematik scheint nicht dein Ding zu sein ..

http://www.mathematik.tu-darmstadt.de/fbereiche/stochastik/contents/summerschool/t1.php

Einfacher gehts nicht.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Welche Programmiersprache benutzt du denn? In C und Basic gibts es da 
meistens schon fertige Funktionen. In Assembler habe ich mal ein 19-bit 
Shifter von Dave VanHorn auf einen Tiny portiert:

; register defs 
.def  stateA  = r9
.def  stateB  = r10
.def  stateC  = r11
.def  temp  =r16  ;misc usage, must be in upper regs for IMMED mode
.def  temphi  =r17  ;misc usage, 
.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    scratch
        ;22222111 11111110 00000000
        ;43210987 65432109 87654321
        
        mov     scratch,stateA
        mov     scratch2,stateB
        mov     scratch3,stateC

        mov     temp,scratch          ;Make copy
        mov     temphi,scratch3        ;Make copy

        rol     scratch                ;Shift the bits D7->Carry
        rol     scratch2               ;Carry->D0 D7->Carry
        rol     scratch3               ;Carry->D0 D7->Carry, but that will be fixed.
        ;Now we have to Xor the bits to see what
        ;goes in to bit 1

        rol     temphi                  ;Move bit 19->20
        andi    temphi,$08              ;Important that D1,0 be zero

        andi    temp,$13               ;Mask out irrelevants, protecting bit 19
        or      temphi,temp            ;Get bits 5->21 2->18 1->17

        andi    temphi,$18              ;Nuke bits 18,17
        lsr     temphi                  ;19->19 5->20
        lsr     temphi                  ;19->18 5->19
        lsr     temphi                  ;19->17 5->18

        eor     temphi,temp            ;First xor, result in temphi (5x2 in 02 and 19x1 in 01)
        mov     temp,temphi            ;Make a copy
        ror     temp                   ;Move the 5x2 result to 01
        andi    temphi,$01              ;Mask off everything else
        andi    temp,$01               ;in both
        eor     temphi,temp            ;
        brne    state_random_1          ;If one, do that, else 
state_random_0: 
        ;Set a zero in the lsb of the low byte
        mov     temp,scratch          ;Get the low byte
        andi    temp,$FE               ;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
        mov     scratch,temp          ;Put it back
state_random_exit:
        mov     stateA,scratch
        mov     stateB,scratch2
        mov     stateC,scratch3
  mov     temp,scratch        ; and return it
        ret

[c-hater (Gast)]

Matthias Sch. schrieb:

> In Assembler habe ich mal ein 19-bit
> Shifter von Dave VanHorn auf einen Tiny portiert:
> [...]

OMG.

Ein sehr schönes Beispiel dafür, dass die Verwendung von Assembler 
alleine noch nicht zwangsläufig gute oder effiziente Programme 
hervorbringt...

Das hier macht exakt dasselbe, braucht dafür allerdings nur die Hälfte 
der Register und weniger als die Hälfte der Taktzyklen und hat als 
i-Tüpfelchen auch noch eine konstante Laufzeit, was manchmal auch nicht 
ganz unwichtig ist:

.def  stateA  = r9
.def  stateB  = r10
.def  stateC  = r11
.def  temp    = r16

random:
    clr tmp
    sbrc stateA,0
    inc tmp
    sbrc stateA,1
    inc tmp
    sbrc stateA,4
    inc tmp
    sbrc stateC,2
    inc tmp
    lsr tmp
    rol stateA
    rol stateB
    rol stateC
    mov tmp,stateA
    ret

[c-hater (Gast)]

c-hater schrieb:

> random:
>     clr tmp

Übrigens fällt mir gerade noch auf:

Wenn man das clr tmp durch ser tmp ersetzt, macht der Code zwar nicht 
mehr exakt das, was die Vorlage tut, ist aber dafür stabil, mutiert also 
nicht zum Konstantengenerator, wenn der Wert im Schieberegister mal 
zufällig 0 ist...

Auch die Wahl der Polynomkoeffizienten sollte man vielleicht nochmal 
überdenken. Mir scheint, wenn man nur zwei benutzt, nämlich Bit 21 und 
Bit 19 oder Bit 21 und Bit 17, wird die Zufallsfolge deutlich länger 
werden. Als abgenehmer Nebeneffekt würde dadurch auch noch der Code um 
weitere 4 Takte schneller werden.