Comment sont calculés les mouvements delta?

Sur une imprimante cartésienne, les mouvements sont vraiment simples. Si nous supposons que l'imprimante a 100 pas / mm sur chaque axe, un déplacement de 10 mm sur un axe ne représente que 1000 pas sur cet axe.

Les mouvements qui ne sont pas alignés sur un axe sont également simples. Passer de x, y = 0,0 à 10,10 équivaudrait à 1000 pas sur x et y.

Sur les deltas, même pour les mouvements simples, plus d'un moteur doit se déplacer. Et le simple calcul du nombre de pas sur chaque axe nécessaire pour atteindre la destination donne probablement un mouvement incurvé.

Alors, quel est l'algorithme pour calculer les étapes d'un mouvement donné pour une imprimante delta?

La technique utilisée par la plupart des contrôleurs d'imprimante 3D open source comporte deux étapes principales:

1. Divisez chaque segment de gcode linéaire en beaucoup de très petits sous-segments ("Segmentation")
2. Utilisez une trigonométrie de base ou le théorème de Pythagore pour lier la position de l'extrudeuse à la hauteur du chariot pour chacune des trois tours ("cinématique inverse") pour trouver la position cible pour chaque petit segment

La cinématique inverse est étonnamment simple. Un triangle virtuel à 90 degrés est construit à partir de deux longueurs connues pour résoudre la troisième longueur inconnue:

• La longueur du bras delta fixe est l'hypoténuse du triangle
• La distance horizontale entre les joints de colonne et les joints effecteurs d'extrémité est calculée à partir des coordonnées XY de la buse et de la position fixe de la colonne, pour déterminer la longueur du côté inférieur du triangle
• La longueur du côté supérieur du triangle est calculée à partir des deux précédents via le théorème de Pythagore
• La longueur du côté supérieur est ajoutée à la hauteur Z de la buse pour obtenir la hauteur de chariot nécessaire

Je pense que la meilleure référence open-source ici est le document Rostock Kinematics de Steve Grave, rev3 disponible en téléchargement ici: https://groups.google.com/d/msg/deltabot/V6ATBdT43eU/jEORG_l3dTEJ Quelques images pertinentes:

Ces calculs de cinématique inverse sont effectués pour chaque chariot pour obtenir une position cible "d'espace de chariot", et ceci est effectué pour chaque sous-segment de chemin.

Les résultats de ces étapes peuvent ensuite être réinsérés dans les techniques d'interpolation de chemin linéaire standard pour l'imprimante, dans lesquelles elle déclenche des étapes dans les rapports nécessaires et aux taux nécessaires pour produire le mouvement en ligne droite souhaité et le profil d'accélération / vitesse. (Comment cela est fait est une question différente.)

L'effet net est que l'imprimante se déplacera à travers une série de petits mouvements de chariot "linéaires" (linéaire signifiant vitesse constante par rapport au temps) qui approximent collectivement les mouvements de chariot incurvés (position quadratique par rapport au temps) nécessaires pour produire un mouvement effecteur terminal en ligne droite.

* ( Vitesse constante avant que les ralentissements d'accélération ne soient appliqués afin de respecter les contraintes dynamiques, de toute façon. Encore une fois, cela fait l'objet d'une question différente.)

La segmentation est très similaire au processus d'utilisation d'un polygone pour approximer un cercle. Si les facettes sont suffisamment petites, le polygone est une bonne approximation. Des taux de segmentation plus élevés produisent moins d'erreurs de suivi de chemin. La principale différence conceptuelle entre dessiner des arcs de cercle et des trajectoires de mouvement Delta est que le soi-disant «arc à facettes» avec segmentation Delta est construit en coordonnées hauteur-temps au lieu des coordonnées X-vs-Y que vous utiliseriez pour dessiner un cercle sur un écran d'ordinateur.

Ce système est utilisé en grande partie parce que la prise en charge des imprimantes de style Delta était à l'origine boulonnée sur des planificateurs de mouvement basés sur GRBL qui étaient écrits exclusivement pour des trajectoires de mouvement en ligne droite dans les imprimantes cartésiennes. Il s'agissait d'une modification relativement minime de la base de code existante par rapport à la mise en œuvre d'une interpolation de chemin quadratique complète.

Les techniques ont évolué au fil des ans. Et des approches alternatives sont souvent utilisées: par exemple, la fourche dc42 de RepRapFirmware effectue un suivi de chemin exact sans segmentation, en recalculant l'heure appropriée pour l'étape suivante après chaque étape . Ceci est fonctionnellement équivalent à l'approximation d'un cercle avec un nombre de facettes de polygone si élevé que chaque pixel de l'écran a sa propre facette . Il est donc exactement aussi précis que le permet la résolution de positionnement des moteurs. L'inconvénient est que cette technique sans segmentation est assez gourmande en processeur, donc elle ne fonctionne que sur des contrôleurs relativement rapides, et non sur l'Atmega AVR 8 bits plus ancien qui alimente la plupart des imprimantes grand public / amateurs actuelles.

D'autres techniques sont possibles. La littérature académique sur le contrôle de la robotique parallèle est un tout autre monde de techniques mathématiques et de complexité afin de produire des algorithmes de contrôle généralisés qui fonctionnent pour un large éventail de mécanismes de robot. La version que nous utilisons dans les imprimantes 3D open-source est assez simple et spécifique à l'application en comparaison.

Je décris comment cela se fait dans le firmware Marlin.

La première étape consiste à diviser un mouvement linéaire de (x, y, z) à (x ', y', z ') en plusieurs segments discrets. À cette fin, la durée du mouvement à une vitesse donnée est calculée et la valeur delta_segments_per_second est utilisée pour calculer le nombre de segments utilisés.

Cela se fait dans la fonction prepare_move_delta du fichier Marlin_main.cpp. Les points de terminaison de chacun de ces segments sont ensuite passés à la fonction Calculate_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];
}

Cette fonction prend en charge la géométrie delta et les calculs nécessaires pour convertir les coordonnées (x, y, z) des extrémités de segment en positions correspondantes pour les chariots. Les coordonnées traduites sont ensuite passées à plan_buffer_line , qui calcule les étapes nécessaires pour chaque moteur pas à pas et fait réellement ces étapes se produire.

La cinématique exacte utilisée dans cette fonction est expliquée beaucoup plus en détail dans le github de Marlin .

Ce qui est important à noter est que plan_buffer_line déplace les chariots de manière linéaire, et la tête d'impression décrit donc un arc et non une ligne droite. Un déplacement en ligne droite est ainsi approximé par de nombreux petits arcs.