Stappenmotorensimulator: stapverlies en naloopshoek

Bediening

Het lab voert de hele beweging bij elke invoer opnieuw uit, dus de sporen volgen de schuifregelaar terwijl je die sleept in plaats van op een startknop te wachten. Er valt niets te starten — de beweging bestaat uit 30 000 integratiestappen en is klaar voordat jouw vinger weer beweegt.

De bovenste grafiek is de positie: de stippellijn is waar de driver denkt dat de as is, de doorgetrokken lijn is waar de rotor werkelijk is. De onderste grafiek is de naloopshoek ertussen, met het stabiele bereik van ±90° gearceerd.

Theorie

Een stappenmotor maakt geen stappen. De driver draait een magnetisch veld in stappen en de rotor volgt het, altijd met een hoek achterop — en het koppel dat daardoor ontstaat is de sinus van die hoek:

T = T_peak(ω) × sin(δ)

δ wordt gemeten in elektrische graden. Een 1,8°-motor heeft 50 rotortanden, dus het magnetisch veld herhaalt zich 50 keer per omwenteling en is één volledige stap precies 90 elektrische graden. Die omrekening is de enige rekenkunde in het hele onderwerp.

Tussen −90° en +90° is de motor een veer: verder achterop vallen betekent sterker teruggetrokken worden. Die stabiele zone is de reden dat een open-loop stappenmotor überhaupt werkt, en elke constante last moet daar blijven zitten. Voorbij 90° slaat de sinus om, waardoor verder achterop vallen minder herstelkoppel oplevert, wat hem nog verder doet achterop vallen — en bij 180° keert het koppel volledig om en begint het naar de volgende pool te trekken. De rotor schuift naar de volgende stabiele tand, één elektrische cyclus — vier volledige stappen — verderop.

Dat zijn twee verschillende getallen, en het lab houdt ze gescheiden. 90° is waar het evenwicht eindigt; een korte overschwing daar voorbij is te overleven, en daarom vernietigt een commando in volledige stappen — een schop van 90°, elke stap — de machine niet. 180° is het punt van geen terugkeer meer.

Drie dingen vergroten de naloopshoek:

• Last. Bij constante snelheid sin(δ) = demanded ÷ available. Een last op de helft van het beschikbare koppel staat op 30°, met 60° marge over.
• Versnelling. Het op gang brengen van de rotor kost koppel uit hetzelfde budget, dus de naloop is het ergst op de helling, niet bij constante snelheid.
• Snelheid, omdat T_peak zelf daalt naarmate de motor sneller draait.

Die laatste is het minst voor de hand liggend. Een wikkeling is een spoel, en hoe sneller de motor draait, hoe moeilijker het is om er stroom in te duwen en er weer uit te halen — de reactantie stijgt met de elektrische frequentie, en de tegen-EMK van de draaiende rotor eet de voedingsspanning op. Het resultaat is een koppeldiagram dat vlak blijft tot een kniksnelheid en daarboven afvalt, en die kniksnelheid wordt bepaald door de voedingsspanning.

Wat de twee regels oplevert die het lab duidelijk moet maken: meer ampères levert koppel, meer volt levert snelheid.

Algoritme

De rotor wordt rechtstreeks geïntegreerd. Niets in deze code detecteert stapverlies, voegt het in of weet dat het mogelijk is — het valt voort uit de sinuswet.

// 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;

Twee details zijn belangrijker dan ze lijken.

Het commando wordt op het microstapraster gekwantiseerd voordat de rotor het ziet. Die trap is de excitatie: bij volledig stappen is elk commando een schop van 90 elektrische graden op een zeer zwak gedempte resonantie, en dat is precies waarom een motor in volledige stappen schreeuwt en een microstappende motor niet.

Het wikkelingsmodel bepaalt het koppelplafond:

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;

Het is een gebundelde stationaire benadering van een chopperdriver, geen fase-voor-fasesimulatie. Het reproduceert de vorm van een echt koppeldiagram en levert beide technische antwoorden; aan de zeer hoge kant werkt het conservatief.

Het bevolen traject komt uit de bestaande bewegingsprofielplanner van de site, dus “met helling” en “zonder helling” zijn dezelfde codepad met een andere acceleratiegrens — er is geen aparte foutmodus ingebouwd.

Begeleide experimenten

Elk experiment isoleert één variabele. Verander verder niets.

1. De helling is de hele machine. Laat alles op de standaardwaarden staan en zet Stapsnelheid om tussen Met helling en Direct naar volledige snelheid.

Dezelfde motor, dezelfde driver, dezelfde stroom, hetzelfde doel. Het enige verschil is of de staprate een helling had, en het verschil tussen beide is de hele beweging.

2. Bepaal de aantreksnelheid. Zet op Direct naar volledige snelheid en verhoog daarna Topsnelheid vanaf 100 mm/s in stappen. Het werkt, en het werkt, en dan ergens rond 200 mm/s werkt het opeens helemaal niet meer — niet geleidelijk. Die drempel is de aantreksnelheid, en dat is een echt getal op echte motoren.

3. Volt levert snelheid. Laad de voorinstelling 12 V-voeding, snel draaien: de beweging loopt vast. Verhoog nu Voedingsspanning naar 24 en zie de beweging voltooien, met de stroomgrens ongewijzigd. Ga daarna terug naar 12 V en probeer het met Stroomgrens te redden — dat lukt niet. Boven de kniksnelheid bereikte de driver de ingestelde stroom nooit.

4. Microstappen levert geen nauwkeurigheid. Houd al het andere vast en zet Microstappen van 1/1 naar 1/16, terwijl je twee dingen afleest:

Het volgvermogen verbetert met ongeveer een factor drie en stopt dan. De lastfout beweegt helemaal niet. Die was 0,044 mm bij volledig stappen en is 0,044 mm bij 1/16 stappen — het verschil is dat 0,044 mm een kwart volledige stap en drie en een halve microstap is, dus fijn microstappen laat dezelfde fout er in de eenheden waarin de driver rapporteert veel slechter uitzien.

5. Uitbreken. Verhoog Weerstandskoppel langzaam bij een bescheiden snelheid. Zie de naloopshoek in de onderste grafiek naar de stippellijn klimmen. Hij blijft op 30° staan, dan 50°, dan 70° — en dan is over één kleine schuifstap de synchronisatie verdwenen. Er is geen waarschuwingsgebied, want voorbij 90° is er geen evenwicht waarin hij kan neerslaan.

7. Volledig stappen is een schop van 90°. Laad de voorinstelling Volledig stappen en lees de pieknaloop af: ongeveer 102°e. Elke enkele stap beveelt de volledige 90° aan, en de traagheid van de rotor draagt hem daardoor heen. Hij komt toch aan — er gaat niets verloren — maar hij zwaait de hele beweging door het gebied dat een motor met belastingskoppel niet aankan. Dat is tegelijk waarom volledig stappen luid is en waarom het zo weinig marge voor last overlaat.

6. De aandrijving verandert het probleem. Zet Aandrijving op de T8-spindel en houd al het andere vast. De resolutie gaat van 80 naar 400 stappen/mm, en dezelfde topsnelheid vraagt nu vijfmaal zoveel staprate.

Wat je moet zien

• Falen is een klif, geen gladde verandering. Er degradeert niets. De naloopshoek groeit vloeiend tot 90° en daarna is de beweging er simpelweg niet meer. Dit is het kenmerkende verschil tussen een stappenmotor en een servoachtige regelkring, die onder last alleen maar vertraagt.
• De machine weet het nooit. De stippellijn van het commando eindigt altijd exact op het doel, omdat de driver elke puls heeft geteld die hij kreeg. Alleen de doorgetrokken lijn vertelt de waarheid, en geen echte machine heeft die lijn.
• De lastfout is er altijd. Zelfs bij een volmaakt verloop staat de rotor tientallen micrometer achter waar de driver zegt dat hij is. Dat is geen fout; het is wat sin(δ) = load ÷ torque vereist.
• Verloren stappen zijn altijd een veelvoud van vier. Probeer er eens een aantal van te maken dat dat niet is.

Naar de hardware

Het belangrijkste verschil is de laatste, maar in een andere zin: een echte machine geeft je geen onderste grafiek. Je kunt de naloopshoek niet zien, dus je kunt de marge waarop je werkt niet zien. De praktische vervanging is om het faalpunt bewust op te zoeken — verhoog snelheid en versnelling tot de as overspringt, ga dan 30 tot 50 procent terug en blijf daar.

Begin bij de bedrading en uitleg van de stroomgrens, kalibreer stappen per millimeter tegen een liniaal, en zet het geheel bij elkaar in de penplotterbouw.

Broncode

De helling is op een echte machine niet optioneel. De blokkerende versie hieronder is hoe de meeste eerste schetsen eruitzien, en dat is de versie die zoemt:

// 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
  }
}

De versie met helling, zonder blokkering. Dit is hetzelfde trapezium dat het lab plant, stap voor stap gegenereerd zodat er verder niets op de microcontroller stilvalt:

#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 en setAcceleration geven je een trapeziumvormig profiel en niets anders — AccelStepper heeft geen S-curveoptie. Voor een jerkbegrensd profiel genereert je de setpoint zelf en voedt je die op een timer aan moveTo.

Als je wilt weten of jouw eigen machine dicht bij de grens zit, is de goedkope test een herhaalbaarheidstest:

// 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

Aannames en hardwareverschillen

De rotordynamica is eerlijk: koppel evenredig met sin(δ) is hoe een hybride stappenmotor werkt, en het slipgedrag is een gevolg van het integreren daarvan in plaats van een regel die in de code is geschreven. De constanten beschrijven een NEMA 17 uit de 17HS4401-klasse — 1,8°, 1,7 A, 2,8 Ω, 3,2 mH, 0,44 N·m houdkracht, met een loopwagen van 300 g die naar de as is teruggerekend.

Wat het model vereenvoudigt: de wikkeling is gebundeld tot een stationaire impedantie en een tegen-EMK-term in plaats van fase voor fase gesimuleerd, waardoor de verre staart van het koppeldiagram pessimistisch is. Detentkoppel — de kleine palerkracht die je voelt als je een stappenmotor zonder stroom met de hand draait — is niet gemodelleerd, en evenmin resonantie in de middenband, het gedrag van de driver in aflopmodus, of enig thermisch effect. De timing is ideaal, dus de stapjitter van een echte microcontroller komt niet voor.

Niets daarvan verandert welke regelaar je moet draaien. Het zijn allemaal redenen om een echte machine te verifiëren in plaats van een getal van deze pagina te vertrouwen.

Schakelschema

De fysieke opstelling die dit modelleert is vier draden van de motor naar een driver, twee draden van de driver naar een microcontroller, en één condensator die mensen steeds weglaten:

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

De componentpagina van de A4988 heeft de volledige pinout, de Vref-tabel voor beide varianten van de meetweerstand, en de reden dat die condensator niet optioneel is.