Come vengono calcolati i movimenti delta?

Su una stampante cartesiana i movimenti sono davvero semplici. Se supponiamo che la stampante abbia 100 passi / mm su ciascun asse, uno spostamento di 10 mm su un asse è di soli 1000 passi su quell'asse.

Anche i movimenti che non sono allineati con un asse sono semplici. Passando da x, y = 0,0 a 10,10 sarebbero 1000 passi su xey.

Su delta anche per mosse semplici più di un motore deve muoversi. E il solo calcolo della quantità di passi su ciascun asse necessario per raggiungere la destinazione probabilmente dà una mossa curva.

Quindi qual è l'algoritmo per calcolare i passaggi per una determinata mossa per una stampante delta?

Esistono due passaggi speciali principali per la tecnica utilizzata dalla maggior parte dei controller di stampante 3d open source:

1. Dividi ogni segmento di gcode lineare in molti sottosegmenti molto piccoli ("Segmentazione")
2. Usa un po 'di trigonometria di base o il teorema di Pitagora per legare la posizione dell'estrusore all'altezza del carrello per ciascuna delle tre torri ("cinematica inversa") per trovare la posizione target per ogni piccolo segmento

La cinematica inversa è sorprendentemente semplice. Un triangolo virtuale a 90 gradi è costruito da due lunghezze note per risolvere la terza lunghezza sconosciuta:

• La lunghezza del braccio delta fissa è l'ipotenusa del triangolo
• La distanza orizzontale tra i giunti della colonna e i giunti dell'effettore viene calcolata dalle coordinate XY dell'ugello e dalla posizione fissa della colonna, per determinare la lunghezza del lato inferiore del triangolo
• La lunghezza del lato superiore del triangolo viene calcolata dai due precedenti tramite il teorema di Pitagora
• La lunghezza del lato superiore viene aggiunta all'altezza Z dell'ugello per ottenere l'altezza del carrello necessaria

Penso che il miglior riferimento open source qui sia il documento di Rostock Kinematics di Steve Grave, rev3 disponibile per il download qui: https://groups.google.com/d/msg/deltabot/V6ATBdT43eU/jEORG_l3dTEJ Alcune immagini rilevanti:

Questi calcoli della cinematica inversa vengono eseguiti per ciascun carrello per ottenere una posizione target di "spazio del carrello", e questo viene eseguito per ogni sottosegmento del percorso.

I risultati di questi passaggi possono quindi essere reinseriti nelle tecniche standard di interpolazione del percorso lineare per la stampante, in cui spara passaggi nei rapporti necessari e alle velocità necessarie per produrre il movimento rettilineo desiderato e il profilo di accelerazione / velocità. (Come QUESTO viene fatto è una domanda diversa.)

L'effetto netto è che la stampante si sposterà attraverso una serie di piccoli movimenti del carrello "lineari" (significato lineare costante * velocità rispetto al tempo) che approssimano collettivamente i movimenti del carrello curvi (posizione quadratica rispetto al tempo) necessari per produrre un mossa dell'effettore di linea retta.

* (La velocità costante prima dei rallentamenti dell'accelerazione viene applicata per obbedire ai vincoli di dinamica, comunque. Ancora una volta, questo è l'oggetto di una domanda diversa.)

La segmentazione è molto simile al processo di utilizzo di un poligono per approssimare un cerchio. Se le sfaccettature sono abbastanza piccole, il poligono è una buona approssimazione. Tassi di segmentazione più alti producono meno errori di inseguimento del percorso. La principale differenza concettuale tra gli archi del cerchio di disegno e i percorsi di movimento delta è che il cosiddetto "arco sfaccettato" con la segmentazione delta è costruito in coordinate altezza-tempo invece delle coordinate X-vs-Y che useresti per disegnare un cerchio sullo schermo di un computer.

Questo sistema è utilizzato in gran parte perché il supporto per le stampanti in stile Delta era originariamente fissato ai pianificatori di movimento basati su GRBL, scritti esclusivamente per i percorsi di movimento in linea retta nelle stampanti cartesiane. È stata una modifica relativamente minima alla base di codice esistente rispetto all'implementazione dell'interpolazione del percorso quadratico completo.

Le tecniche si sono evolute nel corso degli anni. E vengono spesso utilizzati approcci alternativi: ad esempio, il fork dc42 di RepRapFirmware esegue il percorso esatto senza segmentazione, ricalcolando il tempo corretto per il passaggio successivo dopo ogni passaggio . Questo è funzionalmente equivalente all'approssimazione di un cerchio con un numero di facce poligonale così elevato che ogni pixel sullo schermo ottiene la propria sfaccettatura . Quindi è esattamente preciso quanto la risoluzione di posizionamento dei motori consente. Il rovescio della medaglia è che questa tecnica priva di segmentazione è abbastanza intensiva per i processori, quindi funziona solo con controller relativamente veloci, non con il vecchio Atmega AVR a 8 bit che alimenta oggi la maggior parte delle stampanti consumer / hobbisti esistenti.

Altre tecniche sono possibili. La letteratura accademica sul controllo della robotica parallela è un altro mondo di tecniche matematiche e complessità al fine di produrre algoritmi di controllo generalizzati che funzionano per un'ampia gamma di meccanismi robotici. La versione che utilizziamo nelle stampanti 3d open source è piuttosto semplice e specifica per l'applicazione in confronto.

Sto descrivendo come questo viene fatto nel firmware Marlin.

Il primo passo è dividere un movimento lineare da (x, y, z) a (x ', y', z ') in molti segmenti discreti. A tal fine, viene calcolato il tempo impiegato dallo spostamento a una determinata velocità e il valore delta_segments_per_second viene utilizzato per calcolare il numero di segmenti utilizzati.

Questo viene fatto nella funzione prepar_move_delta nel file Marlin_main.cpp. Gli endpoint di ciascuno di questi segmenti vengono quindi passati alla funzione calcola_delta :

void calculate_delta(float cartesian[3]) {
    //reverse kinematics.
    // Perform reversed kinematics, and place results in delta[3]
    // The maths and first version has been done by QHARLEY . Integrated into masterbranch 06/2014 and slightly restructured by Joachim Cerny in June 2014

    float SCARA_pos[2];
    static float SCARA_C2, SCARA_S2, SCARA_K1, SCARA_K2, SCARA_theta, SCARA_psi;

    SCARA_pos[X_AXIS] = cartesian[X_AXIS] * axis_scaling[X_AXIS] - SCARA_offset_x;  //Translate SCARA to standard X Y
    SCARA_pos[Y_AXIS] = cartesian[Y_AXIS] * axis_scaling[Y_AXIS] - SCARA_offset_y;  // With scaling factor.

    #if (Linkage_1 == Linkage_2)
      SCARA_C2 = ((sq(SCARA_pos[X_AXIS]) + sq(SCARA_pos[Y_AXIS])) / (2 * (float)L1_2)) - 1;
    #else
      SCARA_C2 = (sq(SCARA_pos[X_AXIS]) + sq(SCARA_pos[Y_AXIS]) - (float)L1_2 - (float)L2_2) / 45000;
    #endif

    SCARA_S2 = sqrt(1 - sq(SCARA_C2));

    SCARA_K1 = Linkage_1 + Linkage_2 * SCARA_C2;
    SCARA_K2 = Linkage_2 * SCARA_S2;

    SCARA_theta = (atan2(SCARA_pos[X_AXIS], SCARA_pos[Y_AXIS]) - atan2(SCARA_K1, SCARA_K2)) * -1;
    SCARA_psi = atan2(SCARA_S2, SCARA_C2);

    delta[X_AXIS] = SCARA_theta * SCARA_RAD2DEG;  // Multiply by 180/Pi  -  theta is support arm angle
    delta[Y_AXIS] = (SCARA_theta + SCARA_psi) * SCARA_RAD2DEG;  //       -  equal to sub arm angle (inverted motor)
    delta[Z_AXIS] = cartesian[Z_AXIS];
}

Questa funzione si occupa della geometria delta e dei calcoli necessari per convertire le coordinate (x, y, z) degli endpoint del segmento nelle posizioni corrispondenti per i carrelli. Le coordinate tradotte vengono quindi passate a plan_buffer_line , che calcola i passaggi necessari per ciascun motore passo-passo e rende effettivamente questi passaggi.

La cinematica esatta utilizzata in questa funzione è spiegata in modo molto più dettagliato nel github di Marlin .

Ciò che è importante notare è che plan_buffer_line sposta i carrelli in modo lineare e la testina di stampa descrive quindi un arco e non una linea retta. Una mossa in linea retta è quindi approssimata da molti piccoli archi.