Homen met eindstops: machine- en werkcoördinaten

Het probleem dat homen oplost

Een stappenmotoras die op open lus draait heeft een perfect geheugen van alles wat hem opgedragen is, en geen enkele kennis van waar hij staat. Zet hem aan en zijn interne positieteller leest nul — niet omdat de slede op nul staat, maar omdat een geheel getal op nul begint.

Erger: de teller kan ook terwijl de machine draait onjuist zijn. Een verloren stap hoor je niet: de driver blijft pulsen tellen, de firmware blijft hem geloven, en de slede staat nu permanent met een veelvoud van vier volle stappen verschoven. Niets in de regellus zal het ooit merken, want er is geen lus.

Homen is het antwoord op beide. Het is het enige moment in de werking van een machine waarin de positie uit de fysieke wereld wordt gemeten in plaats van opgebouwd uit een telling — en alles wat er daarna op volgt hangt ervan af.

Het zoeken in drie fasen

Rij op de schakelaar af, stop wanneer hij schakelt, en noem dat nul. Dat werkt, en het herhaalt tot op een halve millimeter, wat waardeloos is. Elke echte machine doet het in drie doorgangen:

1. Snel zoeken. Rij op de schakelaar af met een snelheid die je uit ongeduld kiest, niet uit nauwkeurigheid. Deze doorgang bestaat alleen om dichterbij te komen, en hij kan de volle lengte van de as afleggen.
2. Terugwijken. Trek je enkele millimeters terug tot de schakelaar vrijgeeft. Dit maakt de derde doorgang mogelijk, en het bewijst bovendien dat de schakelaar een schakelaar is en geen vastgelopen ingang.
3. Langzaam opnieuw zoeken. Nader opnieuw aan met een kleine fractie van de eerste snelheid en leg het schakelpunt vast. Dat is de meting.

De langzame doorgang is om mechanische redenen belangrijk. Een hefboommicroschakelaar schakelt zodra zijn plunjer een bepaalde afstand heeft afgelegd, maar de slede beweegt door terwijl de firmware reageert en terwijl de as afremt. Bij 50 mm/s met een detectievertraging van 2 ms legt de slede 0,1 mm af voorbij het schakelpunt voordat iemand het weet. Bij 2 mm/s is dat 0,004 mm. De langzame nadering zet de eigen herhaalbaarheid van de schakelaar — een paar micron op een degelijke microschakelaar — om in de herhaalbaarheid van de machine, in plaats van de afremafstand het te laten overheersen.

Typische instellingen zien er zo uit:

Een eindstop bedraden

De schakelaar zelf is dezelfde hefboommicroschakelaar die een robot als stootplaat gebruikt, en de bedradingsregel is dezelfde:

const int X_MIN_PIN = 9;

void setup() {
  pinMode(X_MIN_PIN, INPUT_PULLUP);   // NO to ground, pin pulled up
}

bool endstopTriggered() {
  return digitalRead(X_MIN_PIN) == LOW;
}

Verbind COM met massa en NO met de pin, met de interne pull-up aan. Een gebroken draad lees je dan als “niet geschakeld”, en dat is voor een homen-schakelaar de veilige storing: de machine vindt home niet en stopt, in plaats van te beslissen dat hij er al staat.

Dat is het omgekeerde van de regel voor een noodstop, waar je juist normaal gesloten wilt zodat een doorgesneden draad de machine stopt. Een homen-schakelaar en een noodstop hebben tegengestelde veilige toestanden, en ze allebei op dezelfde manier bedraden is een echte fout, geen kwestie van stijl.

Twee details veroorzaken de meeste eindstopproblemen:

• Ontdender hem. Eén indruk levert ongeveer negen overgangen op over 4,7 ms. Tijdens het homen poll je in een dichte lus, dus de eerste flank is degene die je wilt, en alles daarna moet je een paar milliseconden negeren. Hang nooit een interrupt aan die flanken telt.
• Leg de kabel van de eindstop weg van de motorkabels. Een lange, onafgeschermde draad evenwijdig aan een choppende stappenmotorkabel pikt precies dat soort ruis op dat op een schakelactie lijkt. Als homen werkt met de motoren uitgeschakeld en misgaat zodra ze draaien, is dit de reden.

Machinecoördinaten en werkcoördinaten

Na het homen weet de machine precies één ding: waar de eindstop staat. Dat punt, plus een vaste verschuiving, bepaalt machine-nul — in G-code het coördinatenstelsel G53. Het is een eigenschap van het frame. Het beweegt niet, en het is na elke homencyclus hetzelfde.

Dat is bijna nooit het punt waarvandaan je je werk wilt meten. Daarom houdt een machine een tweede, verplaatsbare oorsprong aan: het werkcoördinatenstelsel, G54 tot en met G59, gedefinieerd als een verschuiving ten opzichte van machine-nul.

Die scheiding verdient zichzelf terug zodra je dezelfde opdracht twee keer uitvoert. De G-code zegt “teken een vierkant van 50 mm met beginpunt X0 Y0”. Plak het papier ergens handig vast, jog naar de hoek, zet daar de werkcoördinaten op nul, en voer uit. Verplaats het papier, stel opnieuw op nul, en voer het identieke bestand uit. Het programma is niet veranderd; de verschuiving wel.

Machine-nul is wat het frame kent. Werk-nul is wat de opdracht kent. Ze gescheiden houden is de reden dat je geen bestand hoeft te bewerken om een onderdeel te verplaatsen.

Zachte grenzen

Met een bekende machine-oorsprong kan de firmware bewegingen weigeren die het werkbereik zouden verlaten — nog voordat de slede daar is. Dat zijn zachte grenzen, en ze zijn strikt beter dan de harde variant, omdat ze de machine stoppen bij een geplande afremming in plaats van door een botsing.

; GRBL
$20=1        ; soft limits on
$130=200.0   ; X max travel, mm
$131=200.0   ; Y
$132=60.0    ; Z

Een machine met ingeschakelde zachte grenzen en zonder homencyclus is een machine met zachte grenzen die hij niet kan handhaven, want het werkbereik wordt gemeten vanaf een oorsprong die hij niet heeft. De meeste firmware weigert daarom te draaien tot er is gehomed, en de foutmelding die dat oplevert is geen last — het is de vergrendeling die werkt.

Harde eindschakelaars aan het uiteinde van elke as zijn een aparte, grofere terugvaloptie voor wanneer de zachte grenzen fout zijn. Veel kleine machines laten ze weg en vertrouwen alleen op de zachte grenzen, en dat is een verdedigbare ruil als niets op de machine je pijn kan doen.

De toestandsmachine

Homen is van nature een kleine toestandsmachine, en het als zodanig schrijven houdt de afhandeling van timeouts eerlijk:

enum HomeState { IDLE, SEEK_FAST, BACK_OFF, SEEK_SLOW, HOMED, FAILED };
HomeState state = IDLE;
long stateStartedAt = 0;

void homingStep() {
  switch (state) {
    case SEEK_FAST:
      if (endstopTriggered()) { stopNow(); enter(BACK_OFF); }
      // an axis that never finds its switch must give up, not grind
      else if (travelled() > AXIS_LENGTH_MM + 10) enter(FAILED);
      break;

    case BACK_OFF:
      if (!endstopTriggered() && travelled() >= BACKOFF_MM) enter(SEEK_SLOW);
      break;

    case SEEK_SLOW:
      if (endstopTriggered()) {
        stopNow();
        machinePosition = HOME_OFFSET_MM;   // the one real measurement
        enter(HOMED);
      } else if (travelled() > BACKOFF_MM * 2) enter(FAILED);
      break;
  }
}

De FAILED-takken zijn het deel dat je moet overnemen. Een as die zoekt en nooit schakelt, heeft een losse schakelaar, een vastgelopen slede, of de as verliest stappen die hij krijgt — en in alle drie de gevallen is het juiste antwoord stoppen en dat zeggen. Een homenroutine zonder timeout schuurt je slede met alle genoegen in een frame vast, zolang jij het toelaat.

Wanneer het misgaat

Waar dit past

Homen is hoe een machine met open lus dat ene terugkrijgt wat hij structureel niet kan meten. Het is de moeite waard duidelijk te zijn over wat het wel en niet oplevert: het maakt de positie van de machine correct aan het begin van een opdracht, en verder niets. Verliest de as midden in een opdracht stappen omdat de stroomgrens of het acceleratieprofiel fout is, dan reset homen tussen twee ritten de fout elke keer op nul zonder hem ook maar te verhelpen.

De aanwijzing is simpel. Een machine die nauwkeurig homt en een opdracht op de verkeerde plek afrondt, heeft een bewegingsprobleem en geen homenprobleem.