Schrittmotor-Simulator: Schrittverlust und Lagewinkel

Steuerung

Das Labor fährt den ganzen Hub bei jeder Eingabe neu — die Spuren folgen dem Schieber beim Ziehen statt auf Start zu warten. Es gibt nichts zu starten — der Hub sind 30 000 Integrationsschritte und endet, bevor sich dein Finger bewegt.

Das obere Diagramm ist Position: Die gestrichelte Linie ist, wo der Treiber die Achse wähnt, die durchgezogene wo der Rotor wirklich ist. Das untere Diagramm ist der Lagewinkel dazwischen mit schattiertem stabilem ±90°-Band.

Theorie

Ein Schrittmotor macht keine Schritte. Der Treiber dreht ein Magnetfeld in Inkrementen, und der Rotor folgt ihm, immer etwas hinterherhängend — und das Moment, das er erzeugt, ist der Sinus dieses Winkels:

T = T_peak(ω) × sin(δ)

δ misst in elektrischen Graden. Ein 1,8°-Motor hat 50 Rotorzähne, seine Magnetik wiederholt sich also 50-mal pro Umdrehung, und ein Vollschritt sind exakt 90 elektrische Grad. Diese Umrechnung ist die einzige Arithmetik im ganzen Thema.

Zwischen −90° und +90° ist der Motor eine Feder: Weiter zurückfallen, härter zurückgezogen werden. Dieser stabile Bereich ist, warum ein ungeregelter Schrittmotor überhaupt funktioniert — dort muss jede Dauerlast sitzen. Jenseits 90° kippt der Sinus um: Weiteres Zurückfallen erzeugt weniger Rückstellmoment, was weiteres Zurückfallen macht — und bei 180° kehrt sich das Moment glatt um und zieht zum nächsten Pol. Der Rotor rutscht zum nächsten stabilen Zahn, einen elektrischen Zyklus — vier Vollschritte — entfernt.

Das sind zwei verschiedene Zahlen, und das Labor hält sie auseinander. 90° ist, wo das Gleichgewicht endet; kurzes Überschwingen darüber ist überlebbar — darum zerstört ein Vollschrittbefehl — ein 90°-Tritt, jeder Schritt — die Maschine nicht. 180° ist der Punkt ohne Wiederkehr.

Drei Dinge lassen den Lagewinkel wachsen:

• Last. Im Beharrungslauf sin(δ) = verlangt ÷ verfügbar. Last bei halbem verfügbarem Moment sitzt bei 30° und lässt 60° Marge.
• Beschleunigung. Den Rotor in Gang zu bringen kostet Moment aus demselben Budget — der Lagewinkel ist also auf der Rampe am schlimmsten, nicht bei Tempo.
• Drehzahl, denn T_peak selbst fällt mit steigender Motordrehzahl.

Letzteres ist am wenigsten offensichtlich. Eine Wicklung ist eine Induktivität, und je schneller der Motor dreht, desto schwerer lässt sich Strom hinein- und herauszwingen — Reaktanz steigt mit elektrischer Frequenz, und die Gegen-EMK des drehenden Rotors frisst Versorgungsspannung. Ergebnis ist eine Momentkurve, flach bis zu einer Eckdrehzahl und fallend dahinter, und die Ecke setzt die Versorgungsspannung.

Daraus die zwei Regeln, für die das Labor existiert: Mehr Ampere kaufen Moment, mehr Volt kaufen Drehzahl.

Algorithmus

Der Rotor wird direkt integriert. Nichts in diesem Code erkennt Schrittverlust, fügt ihn ein oder weiß, dass er möglich ist — er fällt aus dem Sinusgesetz.

// per 20 us tick
const ideal    = sampleProfile(plan, time).position;         // mm the planner wants
const command  = Math.round(ideal * stepsPerMm) / stepsPerMm; // the driver only does whole microsteps
const lag      = rotorTeeth * (commandAngle - theta);         // electrical radians

const { torque } = peakTorque(setup, omega);                  // falls with speed
const friction   = loadTorque * Math.tanh(omega / 0.5);       // smooth Coulomb, one line
const accel      = (torque * Math.sin(lag) - friction - damping * omega) / inertia;

theta += omega * dt + 0.5 * accel * dt * dt;
omega += accel * dt;

Zwei Details zählen mehr, als sie aussehen.

Das Kommando wird quantisiert auf das Mikroschrittraster, bevor der Rotor es sieht. Diese Treppe ist die Anregung: Bei Vollschritt ist jedes Kommando ein 90-Elektrograd-Tritt bei sehr leicht gedämpfter Resonanz — exakt darum schreit ein vollschrittiger Motor und ein mikroschrittiger nicht.

Das Wicklungsmodell setzt die Momentdecke:

const backEmf   = kT * speed;
const impedance = Math.hypot(resistance, rotorTeeth * speed * inductance);
const current   = Math.min(currentLimit, Math.max(0, supplyVolts - backEmf) / impedance);
const torque    = Math.SQRT2 * kT * current;

Es ist eine konzentrierte Beharrungsnäherung eines zerhackenden Treibers, keine phasengenaue Simulation. Es reproduziert die Form einer echten Momentkurve und gibt beide Ingenieurantworten richtig; ganz oben läuft es konservativ.

Die kommandierte Trajektorie kommt vom vorhandenen Bewegungsprofil-Planer der Seite — „mit Rampe“ und „ohne“ sind derselbe Codepfad mit anderer Beschleunigungsgrenze, es ist kein separater Fehlermodus einprogrammiert.

Geführte Experimente

Jedes isoliert eine einzige Variable. Ändere nichts sonst.

1. Die Rampe ist die ganze Maschine. Lasse alles auf Standard und kippe Schrittrate zwischen Mit Rampe und Sofort Volltempo.

Gleicher Motor, gleicher Treiber, gleicher Strom, gleiches Ziel. Der einzige Unterschied ist, ob die Schrittrate gerampt wurde — und der Unterschied dazwischen ist der ganze Hub.

2. Finde die Anlauffrequenz. Setze Sofort Volltempo und hebe Spitze von 100 mm/s schrittweise. Es geht, und geht, und dann irgendwo um 200 mm/s geht es gar nicht mehr — nicht allmählich. Diese Schwelle ist die Anlauffrequenz, und sie ist eine echte Zahl an echten Motoren.

3. Volt kaufen Drehzahl. Lade die Voreinstellung 12-V-Versorgung, schnell fahren: Der Hub blockiert. Hebe nun Versorgungsspannung auf 24, und sieh ihn durchgehen, Stromgrenze unangetastet. Dann zurück auf 12 V und versuche stattdessen Stromgrenze zur Rettung — du kannst nicht. Jenseits der Eckdrehzahl erreichte der Treiber den Sollstrom nie.

4. Mikroschritt kauft keine Genauigkeit. Fixiere alles und schalte Mikroschritt von 1/1 bis 1/16, zwei Dinge lesend:

Die Folgegenauigkeit bessert sich etwa dreifach und stoppt dann. Der Lastfehler bewegt sich gar nicht. Er war 0,044 mm bei Vollschritt und ist 0,044 mm bei Sechzehntelschritt — der Unterschied: 0,044 mm ist ein Viertel Vollschritt und dreieinhalb Mikroschritte, feiner Mikroschritt lässt also denselben Fehler in Treibereinheiten viel schlimmer aussehen.

5. Kippen. Hebe Widerstandsmoment langsam bei mäßigem Tempo. Beobachte den Lagewinkel im unteren Diagramm zur gestrichelten Linie klettern. Er sitzt bei 30°, dann 50°, dann 70° — und dann, über ein kleines Schieberinkrement, ist der Gleichlauf weg. Es gibt keinen Warnbereich, denn jenseits 90° gibt es kein Gleichgewicht zum Einpendeln.

7. Vollschritt ist ein 90°-Tritt. Lade die Voreinstellung Vollschritt und lies die Spitzenlage: etwa 102°e. Jeder einzelne Schritt kommandiert die vollen 90°, und der Schwung des Rotors trägt ihn darüber. Er kommt dennoch an — nichts geht verloren — verbringt aber den ganzen Hub schwingend durch den Bereich, den sich ein belasteter Motor nicht leisten kann. Darum ist Vollschritt zugleich laut und lässt so wenig Lastmarge.

6. Die Mechanik ändert das Problem. Schalte Mechanik auf T8-Spindel bei sonst fixiertem allem. Auflösung geht von 80 auf 400 Schritte/mm, und dieselbe Spitze braucht nun fünffache Schrittrate.

Was du beobachten solltest

• Versagen ist Klippe, nicht Hang. Nichts altert. Der Lagewinkel wächst glatt bis 90°, und dann ist der Hub schlicht weg. Das ist der definierende Unterschied zum servoartigen geschlossenen Kreis, der unter Last nur langsamer wird.
• Die Maschine merkt nie etwas. Die gestrichelte Kommandolinie endet immer exakt auf Ziel, denn der Treiber zählte jeden Impuls, den er bekam. Nur die durchgezogene Linie sagt die Wahrheit, und keine echte Maschine hat diese Linie.
• Der Lastfehler ist immer da. Selbst im perfekten Lauf hängt der Rotor dutzende Mikrometer hinterher, wo der Treiber ihn wähnt. Kein Fehler; das verlangt sin(δ) = Last ÷ Moment.
• Verlorene Schritte sind immer ein Vielfaches von vier. Versuche, eine Zählung zu erzeugen, die es nicht ist.

Umsetzung auf Hardware

Der wichtigste Unterschied ist der letzte in anderem Sinn: Eine echte Maschine gibt dir kein unteres Diagramm. Du kannst den Lagewinkel nicht sehen, also nicht die Marge, auf der du fährst. Der praktische Ersatz ist, die Versagensgrenze bewusst zu suchen — Tempo und Beschleunigung heben, bis die Achse springt, dann 30 bis 50 Prozent zurück und dort leben.

Beginne mit der Verdrahtungs- und Stromgrenzen-Anleitung, kalibriere Schritte je Millimeter gegen ein Lineal und setze alles im Stiftplotter-Bau zusammen.

Quellcode

Die Rampe ist auf echter Maschine nicht optional. Die blockierende Version unten ist, wie die meisten ersten Sketche aussehen — und sie brummt:

// What not to ship: the step rate jumps from zero to full.
void moveBlocking(long steps, unsigned delayUs) {
  for (long i = 0; i < steps; i++) {
    digitalWrite(STEP_PIN, HIGH);
    delayMicroseconds(2);
    digitalWrite(STEP_PIN, LOW);
    delayMicroseconds(delayUs);      // constant => no acceleration at all
  }
}

Die gerampte, nichtblockierende Version. Das ist dasselbe Trapez, das das Labor plant, Schritt für Schritt erzeugt, sodass nichts sonst auf dem Mikrocontroller steht:

#include <AccelStepper.h>

const float STEPS_PER_MM = 80.0;          // 20T GT2 pulley at 1/16 stepping
AccelStepper axis(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);

void setup() {
  pinMode(EN_PIN, OUTPUT);
  digitalWrite(EN_PIN, LOW);              // active low: energise

  axis.setMaxSpeed(200 * STEPS_PER_MM);   // 200 mm/s
  axis.setAcceleration(2000 * STEPS_PER_MM);
}

void loop() {
  if (axis.distanceToGo() == 0) {
    axis.moveTo(axis.currentPosition() == 0 ? lround(60 * STEPS_PER_MM) : 0);
  }
  axis.run();                             // returns immediately — call it constantly
  checkEndstops();                        // which is only possible because it does
}

setMaxSpeed und setAcceleration geben dir ein Trapezprofil und sonst nichts — S-Kurven-Option gibt es in AccelStepper keine. Für ein ruckbegrenztes Profil erzeugst du den Sollwert selbst und fütterst ihn per Zeitgeber in moveTo.

Ob deine eigene Maschine nah an der Kante steht, zeigt billig ein Wiederholtest:

// Drive a long move out and back, N times, then check whether home moved.
// Anything other than a multiple of four full steps is not step loss.
for (int i = 0; i < 20; i++) { moveTo(LONG_MOVE); runToPosition(); moveTo(0); runToPosition(); }
// now re-home and compare the reported position against zero

Annahmen und Unterschiede zur Hardware

Die Rotordynamik ist ehrlich: Moment proportional zu sin(δ) ist, wie ein Hybrid-Schrittmotor arbeitet, und das Schlupfverhalten folgt aus dessen Integration statt regelcodierter Regel. Die Konstanten beschreiben NEMA-17-Klasse 17HS4401 — 1,8°, 1,7 A, 2,8 Ω, 3,2 mH, 0,44 N·m Halte, mit reflektierten 300 g Schlitten auf der Welle.

Was das Modell vereinfacht: Die Wicklung ist zu Beharrungsimpedanz plus Gegen-EMK-Term konzentriert statt Phase für Phase simuliert — der ferne Auslauf der Momentkurve ist also pessimistisch. Rastmoment — das kleine Rasten, das du fühlst, wenn du einen stromlosen Schrittmotor von Hand drehst — ist nicht modelliert, noch Mittenbandresonanz, noch Treiber-Abklingverhalten, noch irgendein thermischer Effekt. Timing ist ideal, der Schritjitter eines echten Mikrocontrollers erscheint also nicht.

Nichts davon ändert, an welchem Knopf zu drehen ist. Alles sind Gründe, eine echte Maschine zu verifizieren statt einer Zahl von dieser Seite zu trauen.

Schaltplan

Der physische Aufbau, den dies modelliert, sind vier Drähte vom Motor zum Treiber, zwei Drähte vom Treiber zum Mikrocontroller und ein Kondensator, den Leute ständig weglassen:

Arduino 5V  ──── VDD
Arduino GND ──── GND (logic) ──┬── GND (motor) ──── PSU −
PSU + (12–24 V) ──── VMOT ──┬──┴── 100 µF electrolytic, close to the board
Pin 3 ──── STEP             RESET ──┬── SLEEP
Pin 4 ──── DIR              MS1, MS2, MS3 ──── 5 V   (1/16)
Pin 5 ──── ENABLE (active low)
Coil A ──── 1A, 1B          Coil B ──── 2A, 2B

Die A4988-Komponentenseite hat die volle Pinbelegung, die Vref-Tabelle für beide Sense-Widerstand-Varianten und den Grund, warum dieser Kondensator nicht optional ist.