Doch ein Zufall

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Aufgrund technischer Veränderungen ist der Mailverkehr innerhalb des Forums (Private Nachrichten) nur noch eingeschränkt möglich. Die Einschränkung ist notwendig, um zusätzliche Betriebskosten für das Forum zu vermeiden. Näheres zu den Hintergründen im Thread "Aktuelles zum Forum".Wir bitten um Verständnis.

    Hinweis kann nach Kenntnisnahme deaktiviert werden!

    • Hi Dekaman,
      genau diesen Ansatz hatte ich zuerst verfolgt. Ich befürchtete (und habe auch gestestet) das dann bei gleichmäßig bleibender Dunkelheit der Wert am Analog-Input gleich bleibt und damit der Zufall wieder nur ein mathematisches Ergebnis darstellt.

      Ich habe in mehreren Versuchen den LDR abgedunkelt und dann jedesmal den gleichen Rhythmus (= die gleichen "Zufalls"-Ergebnisse) bekommen. Ist halt nur ein Computer: kann nur 0 und 1, das dafür unheimlich schnell. Und wiederholt nur, was in seinem Programm drin steht. Eben ein Hochgeschwindigkeitstrottel mit Hang zum Perfektionismus.
    • HRi schrieb:

      Hi Dekaman,
      genau diesen Ansatz hatte ich zuerst verfolgt. Ich befürchtete (und habe auch gestestet) das dann bei gleichmäßig bleibender Dunkelheit der Wert am Analog-Input gleich bleibt und damit der Zufall wieder nur ein mathematisches Ergebnis darstellt.
      Da haben wir uns wahrscheinlich falsch verstanden.
      Wenn es dunkel wird, liest du Time$ aus. Da kannst du dann mit Left(h$) , mid(m$) und mit Right(s$)
      separieren. Mit Val() hast du dann 3 Zahlen h,m,s. Daraus errechnest du dann eine Variable,
      zb. : h*m+s . Diesen Wert trägst du dann in __RSEED ein. Das ist dann der Startwert für dein RND().
      Anschließend kannst du RND() ganz normal nutzen.
      Da davon auszugehen ist, das es nicht immer zur gleichen Zeit dunkel wird, hast du auch immer wieder
      neue Startwerte für RND(). Und mit jedem neuen Startwert ergibt sich auch ein neues Muster für deine
      Beleuchtung.
      Also, wenn es dunkel wird, einmal __RSEED setzen. Und erst beim nächsten Dunkel werden den Vorgang
      wiederholen.
      Ich hoffe, ich habe mich verständlich ausgedrückt.

      Detlef
      Leichtsinn ist kein Mut, Vorsicht keine Feigheit.
    • stefanhamburg schrieb:

      den ADC mit „Schmutz“ abzufragen und den Wert dann dem _rseed zuzuweisen.
      Eigentlich ist es egal, wo man den "Zufall" herholt. Entscheidend ist doch, wie du schreibst
      "den Wert dann dem _rseed zuzuweisen.". Wir sind uns aber darin einig, es ist keine "saubere"
      ESD Geschichte. Möchte ich betonen, a_19_23577ce2 bevor wir Fredred wieder mit Blitzen erschrecken . a_19_23577ce2

      Ich würde es nicht so machen, aber jeder soll so programmieren, wie er es kann, und es ihm gefällt.

      Detlef
      Leichtsinn ist kein Mut, Vorsicht keine Feigheit.
    • Counter schrieb:

      Vorschlag:
      Und wenn man den watchdog timer nutzt und damit immer den Rnd neu mischt? Geht automatisch und ohne Taster usw.
      Hilft nix, bei jedem Start wird die gleiche Anzahl von Takten zum Mischen führen, immer die gleiche 'Mischsequenz' ausgeführt... Alles, was innerhalb der Programms abläuft, läuft auch bei jedem Start gleich ab. Man braucht eine 'Störung' von außen, die den Ablauft verändert.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Counter schrieb:

      Vorschlag:
      Und wenn man den watchdog timer nutzt und damit immer den Rnd neu mischt? Geht automatisch und ohne Taster usw.
      Ein kleinwenig könnte sich doch ändern. Meines Wissens hat der watchdog einen eigenen Oszillator, der sicherlich nicht auf Stabilität getrimmt ist. Wenn man den mit dem stabileren Hauptoszillator vergleicht, gibt es vielleicht Interferenzen, die vom Programmstart zu Programmstart unterschiedlich sind. Aber da muss ja auch wieder der watchdogoszillator verstimmt werden, durch veränderte chip-Temperatur. Also doch wieder eine Störung von außen.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Der ADC ist eine sehr gute Quelle für Zufall, nicht nur ein fliegender Pin, sondern auch wenn eine fixe Spannung anliegt.
      Im Datenblatt ist die Genauigkeit mit +-2 LSB angegeben, d.h. die letzten 2 Bits "flattern" immer herum.
      Man könnte zb. beim Start des Controllers 16x samplen und immer das letzte Bit verwenden, um damit einen wirklich zufälligen Startwert für ___rseed zu erhalten.
    • Hallo Zaubara,

      ein interessanter Ansatz. Allerdings habe ich beim Testen herausgefunden, dass das letzte Bit nicht wirklich unregelmäßig flattert. Ich hatte z.B. bei einem Spannungsteiler aus einer Silizium-Diode und einem 47K Widerstand ( VCC --Diode--o--47K-- GND) eine signifikannte Häufung bei der 0. Mit einem Spannungsteiler aus zwei Widerständen (10K, 47K) ergab sich eine noch deutlichere Häufung bei der 1. Nun habe ich mal getestet, wie das Ganze sich verhält, wenn man vor jeder Zufallszahl den Ausgangswert des RND neu definiert. Dazu habe ich 25 mal das letzte BIT des ADC addiert, dieses Ergebnis dem ___rssed zugewiesen und dann mit RND den Zufallswert ermittelt. Und das scheint die Lösung zu sein! Denn nun habe ich bei 1.000 Durchläufen mit RND(5) eine statistische Abweichung von bis maximal 10%. Das ist mir zufällig genug.

      Nun habe ich auch keinen offenen Input-Port mehr und kann dem nächsten Gewitter beruhigt entgegensehen. ;)

      Vielen Dank an alle!
    • Ich nochmal. Wenn ich jetzt _rseed zB den Wert 20 verpasse und dann Rnd(5) rechnen lassen, bekomme ich als Zufallszahl den selben Wert, wenn ich danach _rseed wieder mit 20 belege und wieder Rnd(5) ausführen lasse? Ich denke schon. Deshalb ist es in meinen Augen genauso zufällig, wenn du gleich mit einer Summe aus den bit arbeitest. Oder hab' ich jetzt einen Denkfehler drin?
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Hallo tschoeatsch,

      ich denke, da hast Du Recht. Wenn ___rseed den Startwert für RND darstellt, dann wäre das logisch. Da ich aber nur das letzte Bit vom GETADC-Wert nehme, welches ja "flattert" bekomme ja mal eine 0 und mal eine 1. Dieses eher zufällige Ergebnis lasse ich 25 mal addieren. Da kommt irgendendeine Zahl zwischen 0 (= 25 mal Bit 1 gleich 0) und 25 (= 25 mal Bit 1 gleich 1) heraus. Dieses Ergebnis ist dann mein Startwert. Würde man einfach alle Bit des GETADC nehmen, so müsste ja jedesmal ein Wert herauskommen, der nur auf dem letzten Bit "flattert". Der Rest bleibt gleich. Damit wären nur zwei Startwerte möglich. Ich habe es jetzt noch etwas zufälliger gemacht, indem die die festen Schleifendurchläufe zur Zählung der Bit mit RND(31) variabel gemacht habe. Außerdem addiere ich die Bit immer weiter auf und vergleiche aufeinanderfolgenden Startwerte. Sie müssen unterschiedlich sein. Damit schließe ich aus, dass auch mal nur 0-Bit gelesen werden.

      Hier der Code für die Ermittlung der Zufallszahlen. GETADC(0) ist der Wert meines LDR.

      Quellcode

      1. Zufallszahl:
      2. While Zufall = Lzufall
      3. For N = 1 To Rnd(31)
      4. Temp = Getadc(0)
      5. If Temp.1 = 1 Then Incr Zufall
      6. Next N
      7. Wend
      8. Lzufall = Zufall
      9. ___rseed = Zufall
      10. Wer = Rnd(8)
      11. Was = Rnd(3)
      12. If Was = 1 Or Was = 2 Then 'An wird doppelt soviel wie Aus
      13. Was = An
      14. Else
      15. Was = Aus
      16. End If
      17. Return
      18. 'WER steht hier für den entsprechenden Ausgang
      19. 'WAS symbolisiert, ob die Lampe an- oder ausgeschaltet werden soll
      Alles anzeigen

      Das habe ich nun in meine Steuerung eingebaut. Mit dem Ergebnis bin ich zufrieden.
    • HRi schrieb:

      Nun habe ich auch keinen offenen Input-Port mehr und kann dem nächsten Gewitter beruhigt entgegensehen.

      Ist erfreulich das du auch handwerklich alles perfektioniert hast.
      Bedaure nur das mein Grundsätzlicher Hinweis(electrostatically sensitive devices) so in die Lächerlichkeit gezogen wird.
      Die statische Aufladung an sich ist nicht mehr das Hauptproblem - die Entladung aufgrund von Potentialunterschieden ist sehr wohl ein gewaltiges geworten.
      Vielleicht ist es heutzutage nicht mehr so wie ich es vor ca. 50 Jahren gelehrt bekam und noch respektiere/anwende. Na klar die „Dingerzeiten“ ändern sich rasant aber wohl nicht die Natur- Physikgesetze.

      Nun habe ich auch mal meinen „Gedankenblitz“, nannte ich „Dynamischer timer“ getestet.
      Wenn ich Seed = Timer1 und Random(1000) setze hat Seed im „Startmoment“ schon einen Zufallswert. Initialisiere ich RND mit diesem ist der Zufall für „GLEICH“ 2^32 oder verständlicher erklärt wie ein Sechser im Lotte.

      Mein Glück, dass meine Variante, mit berechtigtem Hinweis,„Zufallswert ist nicht nur von außen möglich“ verdammt wurde. Starteinstellungen können doch in derer Laufzeit beeinflusst werden. Oder nicht?
      Kann mit meinem Vorschlag nicht garantieren das vielleicht in 99 Jahren doch der Startwert gleich sein könnte.

      Nun hat @HRi sein Ziel erreicht und das ist ein guter Abschluss.

      Mit freundlichen Grüßen
    • fredred schrieb:

      Wenn ich Seed = Timer1 und Random(1000) setze hat Seed im „Startmoment“ schon einen Zufallswert. Initialisiere ich RND mit diesem ist der Zufall für „GLEICH“ 2^32 oder verständlicher erklärt wie ein Sechser im Lotte.
      Auch ich jetzt ein letztes mal.
      Du hast Recht, wenn du sagst mit deinem Verfahren erzeugst du eine Zufallszahl. Aber wenn du deinen Aufbau neu startest, bekommst du genau dieselbe Zufallszahl wieder. Dein Programm wird mit dem Systemtakt abgearbeitet. Dein timer läuft mit dem Systemtakt. Dein Rnd(1000) und dein timer1 laufen mit dem Systemtakt. Warum soll sich da von Start zu Start was ändern? Ein Start ist bei mir jetzt ein Stromversorgungeinschalten, nicht ein reset zwischen drin. Dein seed im 'Startmoment' ist immer die gleiche Zahl, einfach weil ein Stück code auch immer die gleiche Taktzahl braucht, bis er verarbeitet ist. Wäre ja schlimm, wenn ein NOP plötzlich mal 2 Takte bräuchte. Aber das brauche ich dir als Assemblerverständiger doch nicht erzählen.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • tschoeatsch schrieb:

      Aber das brauche ich dir als Assemblerverständiger doch nicht erzählen.
      Oh nein. Dies musst du mir nicht erzählen.

      Warum weigerst du dich eine Art Task beim Programmstart zu starten.

      Do Timer. Weiß nicht nach Start was für ein blabla da drin steht. Dann mit Do die Hauptschleife starten, dann blaa übernehmen. Ja blaa ist in einem Zeitraster einfach nur ein rollierentes blabla.

      Mal so nebenbei auch in Assembler sind min 8 Takte nötig um ein Byte zu „befüllen“. Nun läuft Timer asynchron zum Programmablauf. Dann zeig mal praktisch das Seed bei Start mit RND synchron sein sollte. Vermute das dieser erst mal „leer“ ist. Also noch mal ein Durchlauf und erst dann ab zur Ausgabe.

      Na ja was ein NOP ist. Weis ich wohl nicht.
    • Machen wir weiter..
      wenn ein timer gestartet wird, fängt er bei 0 an. Wieso soll ein timer asyncron zum Programm laufen, wenn beide mit derselben Taktquelle getaktet werden?
      Wenn es so einfach wäre, warum wird das dann bei der Funktion rnd() nicht einfach umgesetzt und stattdessen darauf hingewiesen, dass die Zufallszahlen nach dem Start immer in derselben Reihenfolge errechnet werden?
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Hallo , ich denke, das Thema "Erzeugung zufälliger Zufallszahlen" ist noch lange nicht ausdiskutiert.
      Ich finde diese Diskussion auch sehr spannend.
      aber

      HRi schrieb:

      wie bei mir zwischen 0 und 7 zur Lichtsteuerung bei einer Modelleisenbahn gesucht.
      Das es beim dunkel werden im Dorf mal hier oder da ein Licht eingeschaltet wird, ist normal.
      Es wird sich aber kaum ein Betrachter der Anlage hinstellen, und mit Stoppuhr und Block notieren,
      wann und wo und wie lange irgendwo ein Licht brennt.
      Ich finde dieses Thema für eine Modellbahn als overkill.!!
      Aber im Allgemeinen ein Thema, das lohnt, diskutiert zu werden.
      Also weitermachen !

      Detlef
      Leichtsinn ist kein Mut, Vorsicht keine Feigheit.
    • Klar, weiter geht's, ist ja interessant.
      Ich hab' jetzt mal ein Programm geschrieben, das im Simulator läuft und einfach den Stand von timer1 ausgibt und 2 Zufallszahlen.

      BASCOM-Quellcode

      1. $regfile = "m8def.dat"
      2. $crystal = 800000
      3. $hwstack = 64
      4. $swstack = 32
      5. $framesize = 30
      6. $sim
      7. Config Lcd = 20x4
      8. Initlcd
      9. Cls
      10. Locate 1 , 1 : Lcd Timer1
      11. Locate 2 , 1 : Lcd Rnd(1000)
      12. Locate 2 , 6 : Lcd Rnd(1000)
      13. Do
      14. Loop
      15. End
      Alles anzeigen
      Das gibt mir der Simulator aus
      Zufallszahlentest.PNG
      Jetzt kann ja mal einer von euch dieses Programm laufen lassen, was dann raus kommt.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Hallo tschoeatsch,
      Warum sollte da beim zweiten Lauf oder bei uns was anderes rauskommen?
      Der Timer läuft übrigens nicht und wird immer 0 ausgeben.
      Wenn es nur darum geht, beim nächsten Einschalten eine andere Abfolge zu bekommen, würde ich einen Zähler im eeprom beim Start einlesen und dann erhöht abspeichern und diesen dann dem ____rseed zuweisen. Sollte im Normalfall nicht zu erkennen sein.

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von hero ()