summaryrefslogtreecommitdiff
path: root/docs/src/examples/spindle_fr.txt
blob: 3de83bfec685656c34adb9a349433f32e18364e3 (plain)
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
:lang: fr
:toc:

= Contrôle de la broche

[[cha:Controle-broche]] (((Contrôle de la broche)))

== Vitesse broche en 0-10V (((Vitesse broche en 0-10V)))

Si la vitesse de la broche est contrôlée par un variateur de
fréquence avec une consigne vitesse en 0 à 10V et qu'une carte de conversion 
(DAC) comme la m5i20 est utilisée pour sortir le signal.

Premièrement il faut calculer le facteur d'échelle entre la vitesse
broche et la tension de commande. Dans cet exemple, la vitesse maximale
de la broche sera de 5000 tr/mn pour une tension de commande de 10V.
10 Volts/5000 tr/mn = 0.002 Volts par tr/mn notre facteur d'échelle sera donc 
de 0.002.

Si la carte DAC ne dispose pas d'une fonction échelle, il est nécessaire
d'ajouter un composant _scale_ (echelle) au fichier hal pour calibrer
_motion.spindle-speed-out_ entre 0 et 10 comme demandé par le variateur
de fréquence.
----
loadrt scale count=1
addf scale.0 servo-thread
setp scale.0.gain 0.002
net spindle-speed-scale motion.spindle-speed-out => scale.0.in
net spindle-speed-DAC scale.0.out => «le nom de la sortie de votre DAC»
----

== Vitesse de broche en PWM (((Vitesse de broche en PWM)))

Si la vitesse de la broche peut être contrôlée par un signal de
PWM, utiliser le composant _pwmgen_ pour créer le signal:
----
loadrt pwmgen output_type=0
addf pwmgen.update servo-thread
addf pwmgen.make-pulses base-thread
net spindle-speed-cmd motion.spindle-speed-out => pwmgen.0.value
net spindle-on motion.spindle-on => pwmgen.0.enable
net spindle-pwm pwmgen.0.pwm => parport.0.pin-09-out
# Adapter selon la vitesse maximale de la broche en tr/mn
setp pwmgen.0.scale 1800 
----

La réponse du contrôleur de PWM est simple: 0% donne 0tr/mn, 10%
donnent 180 tr/mn... 100% donnent 1800 tr/mn. Si un minimum est
nécessaire pour faire tourner la broche, suivre l'exemple _nist-lathe_
fourni dans les exemples de configuration pour ajouter un composant
d'échelle.

== Marche broche (((Marche broche)))

Si un signal de marche broche reliant _motion.spindle-on_ à une broche de 
sortie physique est envisagé. Pour relier ces pins à une broche du
port parallèle, ajouter une ligne comme la suivante dans le fichier .hal, 
il faut bien sûr qu'elle soit câblée à l'interface de contrôle.
----
net spindle-enable motion.spindle-on => parport.0.pin-14-out
----

== Sens de rotation de la broche (((Sens de rotation de la broche)))

Pour contrôler le sens de rotation de la broche, les pins de HAL 
_motion.spindle-forward_ et _motion.spindle-reverse_ étant contrôlées par M3 et 
M4, peuvent être mise à une valeur positive différente de zéro pour que 
M3/4 inverse le sens de la broche.

Pour relier ces pins à des broches du port parallèle utiliser, par
exemple, les lignes suivantes dans le fichier .hal, bien sûr ces
broches doivent être câblées à l'interface de contrôle.
----
net spindle-fwd motion.spindle-forward -> parport.0.pin-16-out
net spindle-rev motion.spindle-reverse => parport.0.pin-17-out
----

== Démarrage en rampe(((Démarrage en rampe)))

Si la broche doit démarrer en rampe et que le contrôleur n'a pas cette 
possibilité, HAL pourra le faire. Il faut premièrement détourner la sortie de
_motion.spindle-speed-out_ et la faire transiter par un composant _limit2_
dont l'échelle est ajustée de sorte que la consigne suive une rampe entre 
_motion.spindle-speed-out_ et le périphérique recevant la consigne de vitesse. 
Ensuite, il faut faire connaitre à LinuxCNC le moment ou la broche a atteint sa 
vitesse pour que les mouvements puissent commencer.

Reprenant dans l'exemple en 0-10 V, la ligne:
----
net spindle-speed-scale motion.spindle-speed-out => scale.0.in
----

sera modifiée, comme indiqué dans l'exemple ci-dessous:

.Introduction aux composants de HAL _limit2_ et _near_:
****
Au cas ou vous ne les auriez jamais rencontré auparavant, voici une rapide
introduction à ces deux composants de HAL utilisés dans l'exemple suivant. 

* Le composant de HAL _limit2_ est un composant qui reçoit
   une valeur sur une entrée et fourni une valeur en sortie, limitée entre les
   seuils min et max et _également_, limitée pour ne pas dépasser 
   l'amortissement spécifié. En d'autres termes, les fluctuations de la valeur 
   de sortie seront toujours lentes et cette lenteur est ajustable. 

* Le composant de HAL _near_ est un composant à deux entrées et une sortie 
   binaire qui indique quand les deux entrées sont approximativement égales. 

Voir le manuel de HAL ou les man pages, taper juste _man limit2_ ou _man near_. 
****
----
# charge un composant temps réel limit2 et un near avec des noms aisés à suivre
loadrt limit2 names=spindle-ramp
loadrt near names=spindle-at-speed

# ajoute les fonctions au thread
addf spindle-ramp servo-thread
addf spindle-at-speed servo-thread

# fixe le paramètre max pour l'amortissement
# (accélération/décélération de la broche en unités par seconde)
setp spindle-ramp.maxv 60

# détourne la sortie vitesse broche et l'envoie à l'entrée de la rampe
net spindle-cmd <= motion.spindle-speed-out => spindle-ramp.in

# la sortie de la rampe est envoyée à l'entrée de l'échelle
net spindle-ramped <= spindle-ramp.out => scale.0.in

# pour connaitre quand commencer le mouvement on envoie la vitesse de broche 
# commandée à une entrée du composant spindle-at-speed (qui est un composant near).
# on envoie également le signal de fin de rampe (vitesse actuelle) 
# sur l'autre entrée de spindle-at-speed
net spindle-cmd => spindle-at-speed.in1
net spindle-ramped => spindle-at-speed.in2

# la sortie de spindle-at-speed est envoyée à motion.spindle-at-speed
# et quand elle devient TRUE, les mouvements peuvent commencer
net spindle-ready <= spindle-at-speed.out => motion.spindle-at-speed
----

== Vitesse de broche avec signal de retour

Une information de retour est nécessaire pour que LinuxCNC puisse réaliser
des mouvements synchronisés avec la broche comme le filetage ou la
vitesse de coupe constante. L'assistant de configuration StepConf peut
réaliser les connections lui même si les signaux _Canal A codeur broche_ et 
_Index codeur broche_ sont choisis parmi les entrées.

Matériel supposé présent:

 - Un codeur est monté sur la broche et délivre 100 impulsions par tour
   sur son canal A.
 - Ce canal A est raccordé à la broche 10 du port parallèle.
 - L'index de ce codeur est connecté à la broche 11 du port parallèle.

Configuration de base pour ajouter ces composants:
----
loadrt encoder num_chan=1 
addf encoder.update-counters base-thread 
addf encoder.capture-position servo-thread 
setp encoder.0.position-scale 100 
setp encoder.0.counter-mode 1 
net spindle-position encoder.0.position => motion.spindle-revs 
net spindle-velocity encoder.0.velocity => motion.spindle-speed-in 
net spindle-index-enable encoder.0.index-enable <=> motion.spindle-index-enable 
net spindle-phase-a encoder.0.phase-A 
net spindle-phase-b encoder.0.phase-B 
net spindle-index encoder.0.phase-Z 
net spindle-phase-a <= parport.0.pin-10-in 
net spindle-index <= parport.0.pin-11-in
----

[[sec:Vitesse-Broche-Atteinte]]
== Vitesse broche atteinte
(((Vitesse broche atteilte)))

Si le moteur de broche possède un retour d'information de vitesse provenant d'un 
codeur, il est alors possible d'utiliser la variable _motion.spindle-at-speed_ 
pour permettre à LinuxCNC d'attendre que la broche ait atteint sa vitesse de consigne 
avant d'effectuer tout mouvement. Cette variable passe à TRUE quand la vitesse 
commandée est atteinte. Comme le retour vitesse est la vitesse de consigne 
ne sont jamais _exactement_ identiques, il faut utiliser le composant _near_ 
qui indique quand les deux composantes sont suffisamment proches l'une de l'autre. 

Il est nécessaire de connecter la commande de vitesse broche sur near.n.in1 et
le signal de retour vitesse du codeur sur near.n.in2. La sortie near.n.out est
connectée à motion.spindle-at-speed. Le paramètre near.n.scale doit être ajusté 
pour indiquer dans quelle mesure les deux valeurs sont suffisamment proches 
pour passer activer la sortie. Selon le matériel utilisé, il pourra être utile 
d'ajuster l'échelle.

Les éléments suivants sont à ajouter au fichier HAL pour activer _Spindle At Speed_. 
Si near est déjà présent dans le fichier HAL, augmenter le numéro de composant et
adapter le code suivant en conséquence. S'assurer que le nom du signal est bien
le même dans le fichier HAL.
----
# charger un composant near et l'attacher à un thread
loadrt near
addf near.0 servo-thread

# connecter une entrée à la vitesse de broche commandée
net spindle-cmd => near.0.in1

# connecter une entrée à la mesure de vitesse broche du codeur
net spindle-velocity => near.0.in2

# connecter la sortie sur l'entrée spindle-at-speed
net spindle-at-speed motion.spindle-at-speed <= near.0.out

# Ajuster les entrées de vitesse de broche pour être dans une fourchette de 1%
setp near.0.scale 1.01
----