Stappen per millimeter: riemen, schroefspindels, resolutie

Eén getal, één formule

Een stapdriver telt pulsen. Je machine beweegt in millimeters. Het getal dat daartussen omzet is stappen per millimeter, en elke andere kalibratie op de machine hangt ervan af dat het klopt.

De formule verandert nooit:

steps/mm = (full steps per revolution × microstepping) ÷ travel per revolution

De teller wordt bepaald door de motor en de driver — een motor van 1.8° bij 1/16 stappen geeft altijd 200 × 16 = 3200 microstappen per omwenteling. De noemer is het enige deel dat van jouw machine afhangt, en dat is een mechanische vraag: hoeveel verplaatst de as zich als de as een keer draait?

Riemen

Bij een getande riem is de verplaatsing per omwenteling simpelweg het aantal tanden op de riemschijf maal de steek van de riem. GT2-riem heeft een steek van 2 mm, en een riemschijf met twintig tanden is de standaard op vrijwel elke hobbymachine:

travel  = 20 teeth × 2 mm = 40 mm per revolution
steps/mm = (200 × 16) ÷ 40 = 80

Daar is hij dan, die 80 stappen/mm in de X- en Y-configuratie van elke 3D-printer. Het is geen magische constante; het is 20-tands GT2 bij zestien stapverdeling, en met een riemschijf met zestien tanden wordt het 100.

Merk op dat de rij met dertig tanden niet netjes deelbaar is. 53,333… stappen/mm is volledig toegestaan — firmware bewaart het als een float en accumulateert fractiestappen — maar het betekent wel dat geen enkele positie ooit precies op een stapgrens ligt, en dat is één klein argument voor de tandtellingen die iedereen anders gebruikt.

Schroefspindels

Bij een schroef is de verplaatsing per omwenteling de voer — en voer is niet hetzelfde als steek. Dit is de meest voorkomende fout in het hele onderwerp.

• Steek is de afstand tussen opeenvolgende schroefgangen.
• Voer is hoe ver de moer in één omwenteling reist.
• Voer = steek × aantal gangen.

Een eenkangige schroef heeft voer gelijk aan steek. Maar de alomgebruikte T8-schroef heeft een steek van 2 mm met vier afzonderlijke schroefhelixen naast elkaar gewikkeld, dus één omwenteling schuift de moer vier gangen op:

lead     = 2 mm pitch × 4 starts = 8 mm per revolution
steps/mm = (200 × 16) ÷ 8 = 400

En daar is het andere getal dat je hebt gezien. Meet je de gangafstand van een T8 met een schuifmaat, dan krijg je 2 mm, reken je 1600 stappen/mm en komt elke beweging vier keer te kort uit. Tel de gangen aan het uiteinde van de schroef — je ziet de vier afzonderlijke helixen — of draai hem gewoon een volle omwenteling langs een liniaal.

Kiezen tussen beide

Resolutie is niet gratis. Een schroefspindel met tien keer de resolutie van een riem heeft ook tien keer zoveel pulsen nodig voor dezelfde afstand — dus bij een vaste maximale stapfrequentie is hij tien keer langzamer. Dat is de afweging, en hij is hard:

Precies daarom gebruikt een 3D-printer riemen voor X en Y en een schroef voor Z. X en Y bewegen snel en dragen bijna niets. Z beweegt langzaam, draagt het gewicht van een bed of een portaal en mag niet doorzakken als de voeding uitvalt — en de ondiepe helixhoek van een T8 maakt hem zelfremmend, dus hij loopt niet terug onder belasting.

Het getal van 40 000 stappen/s in die tabel is ook een echte grens, geen theoretische. Een Arduino Uno die stapimpulsen in software klokt haalt rond 10 000 tot 15 000 per seconde voordat de lus het niet meer bijhoudt, wat op een T8 bij 1/16 stapverdeling ongeveer 30 mm/s is. Moet een schroefas sneller dan dat, dan zijn de antwoorden minder microstappen, een sneller bord of een hardwaretimer — geen grotere motor.

Koppelmoment, en wat de tabel niet zegt

Mechanisme wisselen verandert de belasting die de motor ziet, niet alleen de snelheid. Een schroefspindel vermenigvuldigt de kracht met ongeveer 2π × radius ÷ lead, dus een T8 maakt van een bescheiden motorkoppelmoment een flinke axiale kracht — en daarom kan een Z-as met een kleine motor een zwaar bed tillen.

De riem doet het omgekeerde. Een GT2-riemschijf met twintig tanden heeft een steekdiameter van 12,7 mm, dus de riemspanning is het motorkoppelmoment gedeeld door 6.4 mm. Een motor die 0.3 N·m levert maakt ongeveer 47 N op de riem, en dat is alles wat je krijgt. Slaat je X-as stappen over wanneer hij ergens tegenaan loopt, dan is dit de rekensom daarachter.

De gespiegelde traagheid verandert ook, en in dezelfde richting: hoe fijner het mechanisme, hoe minder de massa van het loopwagen telt voor de motor, en dat is deels waarom een schroefas agressieve versnelling verdraagt die een riemas niet verdraagt. Je kunt het effect direct zien in de stappenmotorensimulator — wissel het mechanisme van riem naar schroefspindel terwijl je alles andere constant houdt en kijk wat er met de veelhoek gebeurt.

Kalibreer het, vertrouw het niet

Het berekende getal is een startpunt, geen antwoord. Riemen rekken, riemschijven hebben maattolerantie, en schroefspindels worden verkocht met optimistische beschrijvingen. Meet:

1. Markeer de loopwagen tegen een vast referentiepunt. Een stukje plakband en een scherpe potloodlijn.
2. Geef een lange verplaatsing op — 100 mm, niet 10 mm. Fout is een percentage, dus een langere verplaatsing meet hem nauwkeuriger.
3. Meet wat er werkelijk is gebeurd met een schuifmaat of stalen liniaal.
4. Corrigeer met een verhouding:

new steps/mm = old steps/mm × (commanded ÷ measured)

Opgedragen 100 mm, gemeten 98.4 mm, nu op 80: 80 × 100 ÷ 98.4 = 81.3 steps/mm.

Herhaal daarna de meting om te bevestigen. Eén correctie die niet convergeert betekent dat de fout geen schaalfout is — en het verschil is diagnostisch:

Die laatste twee rijen vatten de meeste eerste bouwsels samen, en het zijn allebei rekenkundige en niet mechanische fouten.

Rotatieassen: stappen per graad

Niet elke as is lineair. Een draaitafel, een filamentextruder, de draaias van een cameraschuif en een robotgewricht hebben dezelfde vraag met een andere noemer — en bij een rotatieas is de noemer meestal een overbrengingsverhouding in plaats van een mechanisme:

steps/degree = (full steps × microstepping × gear ratio) ÷ 360

Een motor van 1.8° bij 1/16 via een 5:1-reductie geeft (200 × 16 × 5) ÷ 360 = 44.4 steps per degree, oftewel 0.0225° resolutie. Het is de moeite waard op te merken dat dit dezelfde rekensom is als bij een riem, met 360 graden in de plaats van de millimeters per omwenteling.

De extruder van een 3D-printer is de uitzondering, omdat hij wordt opgegeven in stappen per millimeter filament terwijl het een riemaandrijving is. De noemer is de effectieve omtrek van de gefreesde riemschijf, niet de nominale diameter — de tanden bijten in het filament, dus de werkelijke grijpstraal is kleiner dan die op het onderdeel staat. Daarom rekent niemand E-steps uit en meet iedereen ze:

1. Markeer het filament op 120 mm boven de toevoer van de extruder.
2. Extrudeer precies 100 mm.
3. Meet opnieuw van de toevoer naar de markering. Lees je 27 mm, dan heb je 93 mm geëxtrudeerd, niet 100.
4. new = old × 100 ÷ 93. Bij 93 stappen/mm is dat 100 stappen/mm.

Het startpunt van 120 mm is met opzet: het laat genoeg filament over dat de markering de toevoer nooit bereikt, zelfs als de extruder flink overextrudeert.

Niet-gehele stappen per millimeter

Zodra je hebt gekalibreerd, is het getal niet meer rond — 80 wordt 81,3, en een verplaatsing van 10 mm wordt 813.0 stappen. Firmware gaat hier correct mee om, maar zelfgebouwde code meestal niet, want de voor de hand liggende implementatie gooit bij elke verplaatsing het fractiegedeelte weg:

// Wrong: truncates on every call. Two hundred 0.1 mm moves land 1.4 mm short.
long stepsFor(float mm) { return (long)(mm * stepsPerMm); }

Bij 81.3 stappen/mm is een verplaatsing van 0.1 mm 8.13 stappen, en dat wordt afgekapt tot 8. De 0.13 wordt weggegooid, en wordt opnieuw weggegooid bij de volgende verplaatsing, en die daarna. Over een paar honderd korte segmenten — en dat is precies wat een kromme of een invulpatroon is — stapelt de fout zich op tot iets zichtbaars.

De oplossing is de rest bewaren in plaats van de positie:

// Right: carry the fraction forward, so the error never accumulates past one step.
float carry = 0;

long stepsFor(float mm) {
  float exact = mm * stepsPerMm + carry;
  long whole = lround(exact);
  carry = exact - whole;        // always within half a step
  return whole;
}

Nu is de grootste fout op elk moment een halve stap — 0.006 mm op deze as — en hij groeit nooit. Dit is dezelfde truc die Bresenham-lijnrasterisatie gebruikt, en dezelfde reden dat firmware positie in stappen bijhoudt in plaats van in millimeters: een geheel stapaantal kan niet drijven, een float-positie in millimeters wel.

In firmware

Marlin en GRBL bewaren het getal allebei als instelbare parameter, dus je hoeft zelden opnieuw te compileren:

; Marlin — X, Y, Z, E
M92 X80 Y80 Z400 E93
M500          ; save to EEPROM

; GRBL
$100=80       ; X steps/mm
$101=80       ; Y
$102=400      ; Z

Noteer wat je hebt ingesteld. De meest frustrerende versie van dit probleem is een machine die ooit correct is gekalibreerd, opnieuw is geflasht en stilletjes is teruggevallen op de firmwarestandaardwaarden.

Volgende

Het getal hierboven vertelt de machine hoe ver hij is verplaatst. Het zegt niets over waar hij begon — en een machine in de open lus heeft geen manier om dat bij het opstarten te weten. Daar is referentievaststelling met eindstoppen voor.