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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
|
:lang: fr
:toc:
= Les O-codes
[[cha:O-codes]] (((O-codes)))
== Utilisation des O-codes
Les O-codes permettent le contrôle de flux dans les programmes NGC.
Ils commencent par une lettre *O*, qu'il ne faut pas confondre avec le
chiffre *0*. Chaque bloc est associé à une adresse, qui est la valeur utilisée
après la lettre *O*. Il faut prendre soin de bien faire correspondre les
adresses des O-codes.
.Exemple de numérotation
----
o100 sub
(noter que les blocs if - endif utilisent des numéros différents)
o110 if [#2 GT 5]
(du code ici)
o110 endif
(encore du code ici)
o100 endsub
----
Le comportement est indéfini si:
* Le même nombre est utilisé pour plusieurs blocs
* D'autres mots sont utilisés sur une ligne contenant un mot O-.
* Un commentaire est utilisé sur une ligne contenant un mot O-.
[TIP]
L'utilisation de la lettre *o* minuscule facilite la distinction avec le
chiffre *0* qui peut être tapé par erreur. Par exemple: +
*+o100+* est plus facile à distinguer de *+0100+* que *+O100+*.
[[sec:Sous-programmes]]
== Sous-programmes: *sub*, *endsub*, *return*, *call*
(((Sous-programmes)))(((sub)))(((endsub)))(((return)))(((call)))
Les sous-programmes s'étendent d'un 'O- sub' à un 'O- endsub'.
Les lignes, à l'intérieur du sous-programme (le corps du
sous-programme), ne sont pas exécutées dans l'ordre, mais
elles sont exécutées à chaque fois que le sous-programme
est appelé avec un 'O-call'.
.Exemple de sous-programme
----
O100 sub (sous-programme de mouvement rapide à l'origine)
G53 X0 Y0 Z0
O100 endsub
(autres lignes)
O100 call (ici, appel du sous-programme)
M2
----
Pour plus de détails sur ces instructions voir:
* <<sec:G53-Mouvement-Coordonnees-Absolues, mouvement G53>>,
* <<sec:G0, mouvement rapide G0>>,
* <<sec:M2-M30, fin de programme M2>>.
.O- return
À l'intérieur d'un sous-programme, 'O- return' peut être exécuté,
pour retourner immédiatement au code appelant,
comme si 'O- endsub' avait été rencontré.
.Exemple avec 'O- return'
----
o100 sub
o110 if [#2 GT 5] (teste si le paramètre #2 est supérieur à 5)
o100 return (si le test est vrai, retourne au début du sous-programme)
o110 endif
(autre code ici, qui sera exécuté si le paramètre #2 est inférieur à 5)
o100 endsub
----
Voir également les sections:
* <<sec:Operateurs-Binaires, les opérateurs binaires>>,
* <<sec:parametres, les paramètres>>.
.O- call
'O- call' peut prendre jusqu'à 30 arguments optionnels, qui sont
passés au sous-programme comme '#1', '#2' , ..., '#N'. Les paramètres de '#N+1' à
'#30' ont la même valeur dans le contexte de l'appel.
Au retour du sous-programme, les valeurs des
paramètres #1 jusqu'à #30 (quel que soit le nombre d'arguments) sont
restaurés aux valeurs qu'ils avaient avant l'appel.
Parce que '1 2 3' est analysé comme le nombre 123, les paramètres
doivent être placés entre crochets. L'appel de sous-programme suivant,
s'effectue avec 3 arguments:
.Exemple d'appel 'O-'
----
O200 call [1] [2] [3]
----
Les corps de sous-programme ne peuvent pas être imbriqués. Ils ne
peuvent être appelés qu'après avoir été définis. Ils peuvent être
appelés depuis d'autres fonctions et peuvent s'appeler eux même
récursivement, s'il est judicieux de le faire. Le niveau maximum
d'imbrication des sous-programmes est de 10.
Les sous-programmes n'ont pas de 'valeur de retour', mais ils peuvent
changer la valeur des paramètres au dessus de #30 et ces changements
sont visibles depuis le code appelant. Les sous-programmes peuvent
aussi changer la valeur des paramètres nommés globaux.
[[sec:Boucles]]
== Boucles: *do*, *while*, *endwhile*, *break*, *continue*
(((Boucles)))(((do)))(((while)))(((endwhile)))(((break)))(((continue)))
La boucle 'while' a deux structures possibles: 'while - endwhile' et 'do - while'.
Dans chaque cas, la boucle est quittée quand la condition du 'while' devient
fausse. La différence se trouve en fin de test de la condition. La boucle
'do - while' exécute le code dans la boucle puis test la condition.
La boucle 'while - endwhile' effectue le test d'abord.
.Exemple avec 'while - endwhile'
----
(dessine la forme d'une dent de scie)
G0 X1 Y0 (déplacement en position de départ)
#1 = 1 (assigne la valeur 1 au paramètre #1)
F25 (fixe la vitesse d'avance travail)
o101 while [#1 LT 10]
G1 X0
G1 Y[#1/10] X1
#1 = [#1+1] (incrémente le compteur de test)
o101 endwhile
M2 (fin de programme)
----
.Exemple avec 'do - while'
----
#1 = 0 (assigne la valeur 0 au paramètre #1)
o100 do
(debug, paramètre 1 = #1)
o110 if [#1 EQ 2]
#1 = 3 (assigne la valeur 3 au paramètre #1)
(msg, #1 s'est vu assigné la valeur 3)
o100 continue (saute au début de la boucle)
o110 endif
(le code d'usinage ici)
#1 = [#1 + 1] (incrémente le compteur de test)
o100 while [#1 LT 3]
(msg, boucle terminée)
M2
----
À l'intérieur d'une boucle while, 'O- break', quitte immédiatement
la boucle et 'O- continue', saute immédiatement à la prochaine
évaluation de la condition du 'while'. Si elle est vraie, la boucle
recommence au début. Si elle est fausse, la boucle est quittée.
[[sec:Conditionnels]]
== Conditionnel: *if*, *elseif*, *else*, *endif*
(((Conditionnel: if, elseif, else, endif)))(((if)))(((else)))(((elseif)))(((endif)))
Le 'if' conditionnel exécute un groupe d'instructions avec le même nombre 'O'
qui commence avec 'if' et se termine avec 'endif'. Les conditions optionnelles
'elseif' et 'else' peuvent se trouver entre le 'if' et le 'endif'.
Si la condition du 'if' est vraie, les instructions qui suivent le 'if' seront
exécutées jusqu'à, au maximum, l'instruction conditionnelle suivante.
Si la condition du 'if' est fausse, alors les instructions conditionnelles
'elseif' suivantes seront évaluées l'une après l'autre. Si la condition du
'elseif' est vraie alors les instructions suivant ce 'elseif' seront exécutées
jusqu'à l'instruction conditionnelle suivante. Si aucune des conditions du 'if'
ou du 'elseif' n'est vraie, alors les instructions suivant le 'else' seront
exécutées. Quand une condition est vraie, les autres instructions
conditionnelles du groupe ne sont plus évaluées.
.Exemple avec 'if - endif'
----
O102 if [#31 EQ 3] (si le paramètre #31 est égal à 3 alors S2000)
S2000
O102 endif
----
.Exemple avec 'if - elseif - else - endif'
----
o102 if [#2 GT 5] (si le paramètre #2 est supérieur à 5 alors F100)
F100
o102 elseif [#2 LT 2] (sinon si le paramètre #2 est inférieur à 2 alors F200)
F200
o102 else (sinon le paramètre #2 vaut entre 2 et 5 alors F150)
F150
o102 endif
----
[[sec:Repetitions]]
== Répétition: *Repeat*
(((Repeat)))
La répétition 'repeat', exécutera les blocs contenus entre 'repeat' et
'endrepeat' le nombre de fois spécifié entre crochets. L'exemple
suivant montre comment usiner une séries de 5 formes diagonales
commençant à la position courante.
.Exemple avec 'repeat'
----
(Usine 5 formes diagonales)
G91 (Mode incrémental)
O103 repeat [5]
(insérer le code d'usinage ici)
G0 X1 Y1 (Mouvement en diagonale vers la position suivante)
O103 endrepeat
G90 (Mode absolu)
----
== Indirection
(((Indirection)))
L'adresse de O- peut être donnée par un paramètre ou un calcul.
.Exemple d'indirection
----
O[#101+2] call
----
.Calcul des valeurs dans les O-codes
Voici un condensé des sections utiles aux calculs des O-codes:
* <<sec:parametres, les paramètres>>,
* <<sec:Expressions, les expressions>>,
* <<sec:Operateurs-Binaires, les opérateurs binaires>>,
* <<sec:Fonctions, les fonctions>>.
== Appel de fichier
(((Appel de fichier)))
Pour appeler un sous-programme par son nom, ce sous-programme doit contenir
un 'sub' et un 'endsub'. Le fichier appelé doit se trouver dans le répertoire
pointé par la variable 'PROGRAM_PREFIX' ou 'SUBROUTINE_PATH' du fichier ini.
Les noms de fichiers ne peuvent inclure que des lettres *minuscules*, des
chiffres, des points et des tirets bas. Un fichier de sous-programme nommé ne
peut contenir qu'une seule définition de sous-programme.
.Exemple: l'appel d'un fichier nommé
----
o<monfichier> call (appel un fichier nommé)
----
.Exemple: l'appel d'un fichier numéroté
----
o123 call (appel un fichier numéroté)
----
Dans le fichier appelé doit se touver le 'sub' et le 'endsub'
correspondant à l'appel. Le fichier doit être un fichier valide.
.Exemple: le fichier 'monfichier.ngc' appelé
----
o<monfichier> sub
(du code ici)
o<monfichier> endsub
M2
----
[NOTE]
Les noms de fichiers doivent être en lettres minuscules, ainsi 'o<MonFichier>'
sera transformé en 'o<monfichier>' par l'interpréteur.
// vim: set syntax=asciidoc:
|
