1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
:lang: fr
:toc:
= La cinématique dans LinuxCNC
[[cha:Cinematique]] (((Cinématique)))
== Introduction
Habituellement quand nous parlons de machines (((Machines CNC)))CNC,
nous pensons à des machines programmées pour effectuer certains
mouvements et effectuer diverses tâches. Pour avoir une représentation
unifiée dans l'espace de ces machines, nous la faisons correspondre à
la vision humaine de l'espace en 3D, la plupart des machines (sinon
toutes) utilisent un système de coordonnées courant, le système
Cartésien.
Le système de coordonnées Cartésiennes est composé de 3 axes (X, Y, Z)
chacun perpendiculaire aux 2 autres. footnote:[Le mot _axes_ est aussi
communément (et incorrectement) utilisé à
propos des machines CNC, il fait référence aux directions des
mouvements de la machine.]
Quand nous parlons d'un programme G-code (RS274/NGC) nous parlons d'un
certain nombre de commandes (G0, G1, etc.) qui ont comme paramètres (X-
Y- Z-). Ces positions se référent exactement à des positions
Cartésiennes. Une partie du contrôleur de mouvements de LinuxCNC est
responsable de la translation entre ces positions et les positions
correspondantes de la cinématique (((cinematique))) de la
machinefootnote:[Cinématique: une fonction à deux voies pour
transformer un espace Cartésien en espace à articulations].
=== Les articulations par rapport aux axes
Une articulation, pour une machine CNC est un des degrés physiques de
liberté de la machine. Elle peut être linéaire (vis à billes) ou
rotative (table tournante, articulations d'un bras robotisé). Il peut y
avoir n'importe quel nombre d'articulations sur une machine. Par exemple,
un robot classique dispose de 6 articulations et une fraiseuse classique
n'en a que 3.
Sur certaines machines, les articulations sont placées de manière à
correspondre aux axes cinématiques (articulation 0 le long de l'axe X,
articulation 1 le long de l'axe Y et articulation 2 le long de l'axe Z), ces
machines sont appelées machines Cartésiennes (((Machines
Cartesiennes))) (ou encore machines à cinématiques triviales
(((Cinematique triviale)))). Ce sont les machines les plus courantes
parmi les machines-outils mais elles ne sont pas courantes dans
d'autres domaines comme les machines de soudage (ex: robots de soudage
de type puma).
== Cinématiques triviales
Comme nous l'avons vu, il y a un groupe de machines sur lesquelles
chacun des axes est placé le long d'un des axes Cartésiens. Sur ces
machines le passage, du plan de l'espace Cartésien (le programme
G-code) au plan de l'espace articulation (l'actuateur actuel de la
machine), est trivial. C'est un simple plan 1:1:
----
pos->tran.x = joints[0];
pos->tran.y = joints[1];
pos->tran.z = joints[2];
pos->a = joints[3];
pos->b = joints[4];
pos->c = joints[5];
----
Dans l'extrait de code ci-dessus, nous pouvons voir comment le plan
est fait: la position X est identique avec la articulation 0, Y avec la
articulation 1 etc. Nous nous référons dans ce cas à une cinématique
directe (une transformation avant), tandis que dans l'extrait de code
suivant il est fait référence à une cinématique inverse (ou une
transformation inverse):
----
joints[0] = pos->tran.x;
joints[1] = pos->tran.y;
joints[2] = pos->tran.z;
joints[3] = pos->a;
joints[4] = pos->b;
joints[5] = pos->c;
----
Comme on peut le voir, c'est assez simple de faire la transformation
d'une machine à cinématique banale (ou Cartésienne). Cela devient un
peu plus compliqué si il manque un axe à la machine.footnote:[Si la
machine (par exemple un tour) est montée avec seulement les axes
X, Z et A et que le fichier d'init de LinuxCNC contient uniquement la
définition de ces 3 articulations, alors l'assertion précédente est fausse.
Parce-que nous avons actuellement (joint0=x, joint1=Z, joint2=A) ce qui
suppose que joint1=Y. Pour faire en sorte que cela fonctionne dans LinuxCNC
il suffit de définir tous les axes (XYZA), LinuxCNC utilisera alors une
simple boucle dans HAL pour l'axe Y inutilisé.]footnote:[Une autre
façon de le faire fonctionner, est de changer le code
correspondant et recompiler le logiciel.]
== Cinématiques non triviales
Il peut y avoir un certain nombre de types de configurations de
machine (robots: puma, scara; hexapodes etc.) Chacun d'eux est mis en
place en utilisant des articulations linéaires et rotatives. Ces articulations
ne correspondent pas habituellement avec les coordonnées Cartésiennes,
cela nécessite une fonction cinématique qui fasse la conversion (en
fait 2 fonctions: fonction en avant et inverse de la cinématique).
Pour illustrer ce qui précède, nous analyserons une simple cinématique
appelée bipode (une version simplifiée du tripode, qui est déjà une
version simplifiée de l'hexapode).
.Définir un bipode[[cap:Bipod-setup]]
image::images/bipod.png[]
Le bipode dont nous parlons est un appareil, composé de deux moteurs
placés sur un mur, à cet appareil un mobile est suspendu par des fils.
Les articulations dans ce cas sont les distances entre le mobile et les
moteurs de l'appareil (nommées AD et BD sur la figure ci-dessus.
La position des moteurs est fixée par convention. Le moteur A est en
(0,0), qui signifie que sa coordonnée X est 0 et sa coordonnée Y
également 0. Le moteur B est placé en (Bx, 0), se qui veut dire que sa
coordonnée X est Bx.
Notre pointe mobile se trouvera au point D défini par les distances AD
et BD, et par les coordonnées Cartésiennes Dx, Dy.
La tâche de la cinématique consistera à transformer les longueurs des
articulations en (AD, BD) en coordonnées Cartésiennes (Dx, Dy) et
vice-versa.
=== Transformation avant[[sec:Forward-transformation]]
Pour effectuer la transformation de l'espace articulation en espace
Cartésien nous allons utiliser quelques règles de trigonomètrie (le
triangle rectangle déterminé par les points (0,0), (Dx,0), (Dx,Dy) et
le triangle rectangle (Dx,0), (Bx,0) et (Dx,Dy).
Nous pouvons voir aisément que *AD^2^=x^2^+y^2^*, de même que *BD^2^=(Bx-x)^2^+y^2^*.
Si nous soustrayons l'un de l'autre nous aurons:
*AD^2^-BD^2^=x^2^+y^2^-x^2^+2*x*Bx-Bx^2^-y^2^*
et par conséquent: *x=(AD^2^-BD^2^+Bx^2^)/(2*Bx)*
De là nous calculons: *y=sqrt(AD^2^-x^2^)*
Noter que le calcul inclus la racine carrée de la différence, mais
qu'il n'en résulte pas un nombre réel. Si il n'y a aucune coordonnée
Cartésienne pour la position de cette articulation, alors la position est
dite singulière. Dans ce cas, la cinématique inverse retourne -1.
Traduction en code:
----
double AD2 = joints[0] * joints[0];
double BD2 = joints[1] * joints[1];
double x = (AD2 - BD2 + Bx * Bx) / (2 * Bx);
double y2 = AD2 - x * x;
if(y2 < 0) return -1;
pos->tran.x = x;
pos->tran.y = sqrt(y2);
return 0;
----
=== Transformation inverse[[sec:Inverse-transformation]]
La cinématique inverse est beaucoup plus simple dans notre exemple, de
sorte que nous pouvons l'écrire directement:
*AD=sqrt(x^2^+y^2^)*
*BD=sqrt((Bx-x)^2^+y^2^)*
ou traduite en code:
----
double x2 = pos->tran.x * pos->tran.x;
double y2 = pos->tran.y * pos->tran.y;
joints[0] = sqrt(x2 + y2);
joints[1] = sqrt((Bx - pos->tran.x)*(Bx - pos->tran.x) + y2);
return 0;
----
== Détails d'implémentation
Un module cinématique est implémenté comme un composant de HAL, et il
est permis d'exporter ses pins et ses paramètres. Il consiste en
quelques fonctions “C” (par opposition au fonctions de HAL):
int kinematicsForward(const double *joint, EmcPose *world, const KINEMATICS_FORWARD_FLAGS *fflags, KINEMATICS_INVERSE_FLAGS *iflags)::
Implémente <<sec:Forward-transformation,la fonction cinématique avant>>.
int kinematicsInverse(const EmcPose * world, double *joints, const KINEMATICS_INVERSE_FLAGS *iflags, KINEMATICS_FORWARD_FLAGS *fflags)::
Implémente <<sec:Inverse-transformation,la fonction cinématique inverse>>.
KINEMATICS_TYPE kinematicsType(void)_::
Retourne l'identificateur de type de la cinématique, typiquement
_KINEMATICS_BOTH_.
int kinematicsHome(EmcPose *world, double *joint, KINEMATICS_FORWARD_FLAGS *fflags, KINEMATICS_INVERSE_FLAGS *iflags)::
La fonction prise d'origine de la cinématique ajuste tous ses
arguments à leur propre valeur à une position d'origine connue. Quand
elle est appelée, cette position doit être ajustée, quand elle est
connue, comme valeurs initiales, par exemple depuis un fichier INI. Si
la prise d'origine de la cinématique peut accepter des points de départ
arbitraires, ces valeurs initiales doivent être utilisées.
int rtapi_app_main(void)::
void rtapi_app_exit(void)::
Il s'agit des fonctions standards d'installation et de la
désinstallation des modules RTAPI.
Quand ils sont contenus dans un seul fichier source, les modules de la
cinématique peuvent être compilés et installés par _comp_. Voir la
manpage _comp(1)_ pour d'autres informations.
|
