Arduino "Glücksrad"

Hallo liebe Community,

ich finde bislang weder mit mit meinem eigenen Wissen, noch im Internet eine Lösung für mein - vermutlich recht kleines - Problem. Nun hoffe ich, dass ich hier eine schnelle Antwort bekommen.

Ich möchte mit einem Schrittmotor und einem Arduino Uno eine Art Glücksspirale bauen. Der Motor soll sich so lange drehen bis die Zeit X abgelaufen ist. Die Zeit X soll eine Zufallszeit zwischen 2 und 12 Sekunden sein. Danach soll der Motor stoppen, bis man erneut einen Button betätigt.

Es folgt mein bisheriger Stand. Aktuell dreht sich der Motor pausenlos weiter...

const int motorPin1 = 2;  // Ror      - In 1
const int motorPin2 = 3;  // Braun    - In 2
const int motorPin3 = 4; //  Schwarz  - In 3
const int motorPin4 = 5; //  Weiß     - In 4
                          // Red    - pin 5 (VCC)

const int motorSpeed = 1000;

unsigned long previousMillis = 0; 
unsigned long interval = 1000;    

void setup() {
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
}

void loop ()
{
  
  int zufall = random(2000, 12000);
  unsigned long  currentMillis = millis;

if (currentMillis - zufall >= 10000) 

{
// 1
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 2
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 3
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 4
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 5
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);
 
  // 6
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, HIGH);
  delayMicroseconds(motorSpeed);

  // 7
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, HIGH);
  delayMicroseconds(motorSpeed);

  // 8
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, HIGH);
  delayMicroseconds(motorSpeed);

} else

{
  
  // STOP
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delay(5000);

}
}

Ich würde mich sehr freuen, wenn ihr mir helfen könntet! DANKE!

Echsenmann:
Ich möchte mit einem Schrittmotor und einem Arduino Uno eine Art Glücksspirale bauen. Der Motor soll sich so lange drehen bis die Zeit X abgelaufen ist. Die Zeit X soll eine Zufallszeit zwischen 2 und 12 Sekunden sein. Danach soll der Motor stoppen, bis man erneut einen Button betätigt.

Was für ein Button?

In dem von Dir geposteten Code kommt überhaupt KEIN BUTTON vor!

Und um was für Hardware geht es bei dem Stepper-Motor?

Um einen der chinesischen Spielzeug-Steppermotoren 28BYJ-48 mit einer kleinen ULN2003 Treiberplatine?

Vollkommen richtig. Das ist ja momentan auch nicht das Problem. Einen Button einfügen kann ich ja später immer noch. Deshalb habe ich momentan übergangsweise die 5 Sekunden Pause am Ende eingebaut. Nur leider kommt es nie dazu, da er offensichtlich dauerhaft die Schleife wiederholt und die if-Bedingung anscheinend immer vorliegt.

Echsenmann:
Das ist ja momentan auch nicht das Problem. Einen Button einfügen kann ich ja später immer noch.

Wenn Du eine vollständige Hardwareschaltung hast, kannst Du das Programm auch später immer noch schreiben.

Bei Deinem derzeitigen Code scheinst Du Dir auch nicht darüber im klaren sein, dass ein Arduino nur einen pseudo-random number generator bereitstellt und keinen true-random number generator.

Daher wird beim ersten Aufruf der Zeile
int zufall = random(2000, 12000);
nach jedem Programmstart (nach Power-on oder reset)
immer exakt dieselbe Zufallszahl generiert werden.

Und wenn Du die Funktion mehrmals nacheinander aufrufst, dann wird zwar jedesmal eine andere zufällige Zahl erzeugt, aber nach jedem power-on oder reset des Proggramms wird immer genau dieselbe Abfolge von Zufallszahlen generiert werden.

Ansonsten bin ich hier raus.
Den Affenkram, dass Du auf Tastendruck einen chinesischen Steppermotor laufen lassen möchtest, aber Du hast weder in der Hardwareschaltung noch im Code einen Tastschalter enthalten, mache ich nicht mit.
Einen funktionierenden Code einfügen kann ich ja später immer noch.

Und wenn nicht in diesem Forums-Thread.
Dann eben in einem anderen Forums-Thread mit einem anderen Thema.

BYE, und schönen Sonntag noch!

Ich hoffe, du hast dich nicht zu sehr über mich aufgeregt. Verstehe nicht ganz, warum du meine Fragestellung derartig kritisierst.

Ich habe ein Problem, bei welchem ich mir bislang selbst nicht helfen konnte. Ansonsten hätte ich hier nicht geschrieben.
Vielleicht hat dich meine Fragestellung einfach etwas durcheinander gebracht. Ich hätte auch schreiben können, dass der Motor eine Zufallszeit X laufen soll und dann für 5 Sekunden stoppen soll. Dann wäre zumindest mein bisheriger Code passend gewesen! Sorry dafür.

Und: Nein, mir ist bislang nicht bewusst gewesen, dass es sich um ein pseudo-random handelt. Gut, dass du es mir nun mitteilst. Bin ich wieder etwas schlauer.

Vielleicht findet sich ja hier doch noch jemand, der auf mein wahres Problem eingeht!

Echsenmann:
Ich hätte auch schreiben können, dass der Motor eine Zufallszeit X laufen soll und dann für 5 Sekunden stoppen soll. Dann wäre zumindest mein bisheriger Code passend gewesen!

Echt jetzt? Deinen bisherigen Code hältst Du für passend zur Beschreibung "dass der Motor eine Zufallszeit X laufen soll und dann für 5 Sekunden stoppen soll"?

Also wenn ich mir Deinen bisherigen Code ansehe, dann vermute ich eher, dass der Code Deinen Steppermotor am Laufen halten würde bis der Motor verreckt.

Ein Programm mit der Beschreibung "dass der Motor eine Zufallszeit X laufen soll und dann für 5 Sekunden stoppen soll" müßte anders aussehen, meiner bescheidenen Meinung nach jedenfalls.

Ich würde einen Zustandsautomaten mit zwei Zuständen programmieren:

  1. Motor dreht
  2. M otor stoppt

Und eine Umschaltlogik wie folgt verwenden

  • wenn Zustand 1. vorliegt, schalte nach einer Zufallszeit X in Zustand 2.
  • wenn Zustand 2. vorliegt, schalte nach einer festen Zeit 5000ms in Zustand 1.

Brauchst Du dabei Unterstützung in Form eines funktionierenden Codebeispiels?

Unterstützung wäre dafür natürlich wunderbar.

Also wenn ich mir Deinen bisherigen Code ansehe, dann vermute ich eher, dass der Code Deinen Steppermotor am Laufen halten würde bis der Motor verreckt.

Das habe ich ja bereits im ersten Post geschrieben. Er läuft und läuft und läuft und...

Habe in meinem Code versucht es mit der if-funktion zu regeln. Aber wenn das auch anders möglich ist, erweitere ich gern meinen recht begrenzten Arduino-Horizont. Danke schonmal!

Du kannst den Start des Zufallsgenerators etwas von einem Störsignal abhängig machen, indem Du im setup() einen unbeschalteten Analogeingang liest.
Teilweise Pseudocode, da ich nicht weiß, wie Du Deinen Taster angeschlossen hast. Ohne Taster die Tasterfunktion im Setup aufrufen.
Den Motorcode habe ich mir auch geschenkt.

unsigned long intervall, currentMillis, previousMillis = 0;
boolean dreht = false;
 
// Taster Abfrage und Zufallszahl 
void taster() {
   if (! dreht && taster_gedrueckt) {
     previousMillis = millis();  // Startzeitpunkt  
     intervall = random(2000, 12000);
     dreht = true;
   } 
}

void setup() {
  ...
  randomSeed(analogRead(0));
}

void loop() {
   taster();
   currentMillis = millis();
   if (dreht && currentMillis - previousMillis >= intervall) {
     dreht = false;
   }
   if (dreht) {
     // Motor drehen lassen ohne zu blockieren
   }
   else {
     // Motor anhalten
   }
}

Gruß Tommy

Echsenmann:
Ich würde mich sehr freuen, wenn ihr mir helfen könntet! DANKE!

Ich habe Dir mal einen Beispielcode gemacht, mit Debug-Ausgaben auf Serial/9600 Baud.

const int motorPin1 = 2;  // Ror      - In 1
const int motorPin2 = 3;  // Braun    - In 2
const int motorPin3 = 4; //  Schwarz  - In 3
const int motorPin4 = 5; //  Weiß     - In 4
const int motorSpeed = 1000;

void setup() 
{
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
  Serial.begin(9600);
}

enum{DREHEN,HALTEN}; // Enumeration für zwei Betriebszustände
byte state=DREHEN;
int zufallsZeit=random(2000, 12000);
unsigned long stateActiveSince;

  void drehen() // Funktion für Betriebszustand DREHEN
  // den Stepper acht Schritte machen lassen
{
  // 1
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 2
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 3
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 4
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 5
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);
 
  // 6
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, HIGH);
  delayMicroseconds(motorSpeed);

  // 7
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, HIGH);
  delayMicroseconds(motorSpeed);

  // 8
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, HIGH);
  delayMicroseconds(motorSpeed);
  if(millis()-stateActiveSince>=zufallsZeit) 
  {
    state=HALTEN;
Serial.println("Halten");
        stateActiveSince=millis();
  }
}

void halten() // Funktion für Betriebszustand HALTEN
{
// HALTEN
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
if(millis()-stateActiveSince>=5000) 
  {
    state=DREHEN;
    Serial.println("Drehen");
    
    zufallsZeit=random(2000, 12000); // neue ZufallsZeit
    stateActiveSince=millis();
  }
      
}

void loop ()
{
  if (state==DREHEN) drehen();
  if (state==HALTEN) halten();

}

Und beachte die sehr aufgeräumte loop() Funktion!

Ich hoffe, die Programmlogik ist einigermaßen einleuchtend.

Im Zustand DREHEN wird immer die Funktion drehen() aufgerufen
Im Zustand HALTEN wird immer die Funktion halten() aufgerufen

Und die Umschaltung nach Zeitablauf erfolgt immer in der aufgerufenen Funktion.

Probier's mal aus!

Als Idee vielleicht: Mehrere Randoms nutzen ?

A) mit RND1 den Stepper in einem Bereich +/- U/Min um die normale Drehzahl starten (unterschiedlicher "Schwung")
B) mit RND2 eine unterschiedliche Zeit ca. +/- 1/2 Sekunde um die minimale Drehzeit warten (vom "Schwung" abhängig ?)
C) mit RND3 in unterschiedlichen Schrittweiten die Drehzahl langsam auf 0/Stop fahren (auch "Schwung"abhängig ?)

Den "Schwung" vielleicht aus der Drückzeit des Tasters ermitteln ????

..... dann säh das auch fast so aus wie einechtes GLÜCKSRAD. Da sind dann (regelmäßige) Wiederholungen sicher eher wirkliche Zufall.

PING PING PING PING PING ..... :slight_smile:

EDIT: jurs war schneller. Die Idee passt auch gut dazu. Kombinieren.

TERWI:
NG PING PING PING ..... :slight_smile:

Genau, und dann noch einen Piezo-Lautsprecher dran, der anfangs nach Drehbeginn ein schnell schnarrendes Geräusch abgibt, das dann mit zunehmender Drehdauer langsamer und langsamer schnarrt, so wie sich auch das Glücksrad langsamer und langsamer dreht, bis es schließlich stehen bleibt...

Ich kaufe ein 'A'!

Also der Beispielcode von jurs funktioniert einwandfrei und macht eigentlich genau das, was ich erwartet habe. Danke dafür! ;)...achja...und ich verstehe ihn sogar recht gut! :smiley:

Die Sache mit dem "Pseudo-Random" habe ich jetzt auch live gesehen. Die Abstände sind tatsächlich nach jedem Start gleich...von daher interessiert mich TERWI's Idee schon brennend. Wäre natürlich absolut perfekt, wenn die einzelnen "Schwünge" wirklich ganz individuell sind und man auch bei 25. mal Starten nicht weiß, wo der Zeiger am Ende hinzeigt...

Ich muss allerdings an dieser Stelle zugeben, dass ich aktuell nicht weiß, wie ich so etwas in den Code einbaue...könntet ihr mir da zumindest auf die Sprünge helfen?

Echsenmann:
Also der Beispielcode von jurs funktioniert einwandfrei und macht eigentlich genau das, was ich erwartet habe. Danke dafür! ;)...achja...und ich verstehe ihn sogar recht gut! :smiley:

Die Sache mit dem "Pseudo-Random" habe ich jetzt auch live gesehen. Die Abstände sind tatsächlich nach jedem Start gleich...von daher interessiert mich TERWI's Idee schon brennend. Wäre natürlich absolut perfekt, wenn die einzelnen "Schwünge" wirklich ganz individuell sind und man auch bei 25. mal Starten nicht weiß, wo der Zeiger am Ende hinzeigt...

Ich muss allerdings an dieser Stelle zugeben, dass ich aktuell nicht weiß, wie ich so etwas in den Code einbaue...könntet ihr mir da zumindest auf die Sprünge helfen?

Um den "richtigen Zufall" ins Spiel zu bringen, brauchst Du den Button. Und einen Tastendruck des Benutzers.

Den Algorithmus dafür haben mal Spieleprogrammierer vor über 40 Jahren "erfunden", als sie Spieler zu Beginn eines Spiels zum Drücken eines "Startknopfes aufgefordert haben.

"press any key to start the game".
Oder "press the A button to start the game".

In dem Fall, dass eine Interaktion eines Benutzers stattfindet, kannst Du den ZEITPUNKT der ERSTEN AKTION DES BENUTZERS dazu verwenden, einen "richtig zufälligen Startwert für den Pseudo-Zufallszahlengenerator zu setzen.

Der Gedanke dahinter: Selbst derselbe Spieler wird es wohl kaum mehrere Spielrunden nacheinander schaffen, eine Taste oder einen Button in exakt derselben Millisekunde oder gar derselben Mikrosekunde nach Spielbeginn zu drücken, und daher kann man den "Zeitpunkt der ersten Benutzeraktion" als einen sehr guten"zufälligen" Startwert betrachten, um damit einen Pseudo-Zufallszahlengenerator zu initialisieren.

Die Arduino-Funktion zum Setzen des Startwerts für den Zufallsgenerator ist:
https://www.arduino.cc/en/Reference/RandomSeed

Und um echte Zufallszahlen zu generieren, mußt Du nun nur den Zeitpunkt der ersten Benutzeraktion verwenden, um den Startwert auf einen zufälligen Wert zu setzen.
Beispielsweise den Zufallszahlengenerator mit der Anzahl der Microsekunden nach Programmstart initialisieren, wenn der Benutzer den Button zum ersten mal drückt. Etwa nach der Logik:

if (buttonPressed()) randomSeed(micros());

Und danach ist der Zufallszahlengenerator mit einem Startwert gefüttert, der zufällig ist und dafür sorgt, dass die Sequenz der danach erzeugten Zufallszahlen wirklich zufällig ist und nicht immer dieselbe Sequenz nach jedem Reset.

Du kannst eine bessere Zufallszahl auch dadurch gewinnen, daß Du die Zeit zwischen Reset und Tastendruck als Grundlage für eine Zufallszahlgenerierung (randomSeed) nimmst. So mache ich das beim Würfeln.

jurs war schneller :slight_smile:

Soweit ich mich aus Jahren zuvor erinnern kann, werden hier eigentlich keine kompletten HOW-TO's per Thread gegeben. A bisserl mitdenken muss nicht nur der NewBie :slight_smile:

Als erstes würde ich aus deinem Code erst mal die eigentliche Schrittmotorsteuerung aus der LOOP() herausnehmen und als separate Funktion einsetzen.
Besser noch: Such mal ein wenig nach STEPPER CONTROL o. ä. u. a. - es gibt reichlich LIBs dazu, welche u. a. einzelne Funktionen haben, wie sich der Stepper-Speed mittels Funktion sehr einfach steuern lässt.

Ein Standard-Stepper macht 200 Steps per Umdrehung - deiner auch ?

Als nächstes wäre dann mal interessant zu wissen, wie schnell sich das GR drehen soll und wieviel Steps vom Motor eine Umdrehung machen. Nimm mal Papier, Stift und Taschenrechner zur Hand (oder den Kopf ?).
Ich würde mal sagen so in etwa 1,5 - 3,0 U/sekunde sollte es sich drehen ?! (boaaah ist das lange her ....)
Also Steps etwa 300 - 600 / sekunde

Diesen Faktor sollte man aus einer Random-Zahl herleiten - also z.B. speed = random(300, 600) .

Den "Schwung" kann man wie gesagt aus einer begrenzten Zeit eines Tastendruckes her ableiten
und diesen dann mit dem Speed "irgendwie geschickt verknüpfen".
JETZT ABER TRICKY:
Damit keiner meint: Je länger, desto schneller ..... (das wär ja bekloppt / schmeisst irgendwann das GR aus dem Studio wegen Fliehkraft ....) verbinden wir noch die Tasten-Druck-Zeitmit einem zweiten Randomwert, der in einer Schleife Ständig zwischen einem min. und max. Wert hin- und herläuft.
Selbiger pickt dann beim loslassen wirklich einen (in einem festen Bereich !!!) wirklich wahrlosen Wert heraus und macht das ganze zum echten Glücksspiel.

Aus mittlerer Umdrehungszahl X Beschleunigung von Taster (langsamer oder schneller) wird dann die Startgeschwindigkeit des GR berechnet und eine Zeitschleife gestartet, welche den natürlichen Bremsvorgang simuliert.

In dieser Schleife müsste man nun mittels einacher Berechnungen oder höherer Mathematik berechnen, wann das GR diurch "Reingungsverluste" normalerweise zum stehen kommt.
Linear, logarhytmisch, exponetiell oder wie auch immer einfach erst mal fixe Zeit .......

Während besagter Schleife wird nun der Speed des Steppers reduziert und dieser steht irgendwann.

...... so wie ich das vorhersehe, immer auf dem 'Ü' :slight_smile:

Next tricky-thing:
Wenn man das beim Start "kalibriert" und der Zeiger immer vom letzen Feld losläuft, kann man ja auch entsprechend der Felder diese durch einen LED-Kreis ersetzen. Am besten RGBs, die dann beim jedem "Überlauf" des Zeigers bis Stop ne andere Farbe haben ..... Schön bunt.

Aber bevor man sich in Progger-Details vertieft: ..... das haben doch schon sicher zich Leute gemacht !?
Roulette oder so ?

Geh mal in dich und such ein wenig im WeltWeitenWahnsinn.
Ansonsten frag'ste hier noch mal kurz wie das genau geht .... :slight_smile:

:o

Ich bin am herumschnipseln. Und so kann ich es mir auch Stück für Stück logisch zusammenbasteln. Bis hierhin hat das - mit eurer Hilfe - gut funktioniert. :slight_smile:

Aber ich glaube nicht, dass ich jemals deine Idee verstehen werde. Dazu bin ich zu wenig im Arduino Thema. Das ganze soll ein "einfacher Flaschendrehersatz" werden. Batterie ran und zack wird ein Teammitglied per Zeiger ausgewählt. Möchte das Ganze in einem Holzgehäuse verbauen und ein laminiertes Blatt Papier als "Spielfläche" verwenden, da die Teammitglieder auch immer wieder (jährlich) wechseln.

Verstehe euch absolut, wenn ihr sagt: "Ein wenig selbst nachdenken wird gefordert...nicht einfach nur fertigen Code abholen!"

Aber um deinen Gedanken selbst zu erarbeiten wird mir am Ende wohl einfach die Zeit fehlen...! Ich danke euch trotzdem sehr für die Hilfe...! DANKE!

TERWI:
Ein Standard-Stepper macht 200 Steps per Umdrehung - deiner auch ?

Wenn es der 28BYJ-48 ist, hat der ein Getriebe drin, welches berücksichtigt werden muß. Mein "Spielzeug-Steppermotor" hat ein Getriebe 1:64 und 64 Schritte je Umdrehung, macht aus Arduino-Sicht 4096.

agmue:
Mein "Spielzeug-Steppermotor" hat ein Getriebe 1:64 und 64 Schritte je Umdrehung.

Die "Schritte pro Umdrehung ist korrekt mit 64 nur auf den Motor bezogen, bei einer 8-Schritt Ansteuerung.
Die Getriebeübersetzung bei diesen chinesischen Spielzeug-Steppern ist aber nur "ungefähr" 1:64;

Ganz genau läßt sich diese Übersetzung mit diesen Zähnezahlen an den Zahnrädern nicht realisieren:

Die genaue Übersetzung des Getriebes liegt wohl eher bei = 1:63.68395, hat hier im Arduino-Forum mal jemand vorgerechnet.

Zack - hat der jurs noch ein Karma, weil wichtige Info wie ich persönlich finde.

@Echsenmann
Hol dir mal ein für downchiling taugliches Getränk oder sonstwas und denk mit den Info's hier erst mal über den komplexen Zusammenhang noch ne Runde nach.
Das ist ehrlich lieb & nett gemeint, weil: Irgendwann blockt die Glatze und nix will wirklich weiter.
Morgen noch mal rum-kugeln, dann landest'e eh wieder hier und es geht weiter mit/nach neuen Erkentnnissen.
Über-übermorgen iss das Ding "Fettich" !

jurs:
Die genaue Übersetzung des Getriebes liegt wohl eher bei = 1:63.68395, hat hier im Arduino-Forum mal jemand vorgerechnet.

Danke für den Hinweis! Eine ungerade Zahl ist natürlich blöd, da muß der Referenzpunkt regelmäßig abgefragt werden, was machbar ist. Sonst verhält sich das Glücksrad seinem Namen entsprechend.

Noch ein Hinweis: Die Programmbibliothek AccelStepper kann solche unipolaren Schrittmotoren ansteuern. Aber: Ist es überhaupt so ein Motor?