Gravure d'un compteur CNC FANUC
Il arrive, de temps en temps, que l'on ai besoin de graver un compteur incrémental sur une série de pièces, ou de graver la semaine et l'année de la fabrication, ou encore
de graver une taille pour cette même série.
Je ne parlerais pas, ici, de la gravure d'un texte alphabétique qui rendrait la programmation beaucoup trop complexe. Pour ce type de gravure qui, ma fois, n'évolue pas, je préfère rester sur une gravure
complète en FAO.
Ci dessous des exemples de ce que l'on pourrait attendre :
Graver une taille...
Graver un compteur...
Graver la semaine et l'année de fabrication...
|
|
Avant de commencer à se lancer tête baissée dans une opération de gravure en FAO, il y a quelques questions a se poser :
- La gravure que je veux faire peut elle évoluée (en terme de valeur) ?
- La gravure que je veux faire peut elle changée de taille (en hauteur) ?
- La gravure que je veux faire doit elle pouvoir changer de position sur la piéce ?
Si je réponds oui à au moins une de ces questions, alors j'ai un intéret certain à passer par de la programmation paramétrée.
Cette analyse étant faite, il va falloir se poser beaucoup de questions pour mettre ce principe en application :
- Comment graver à la taille que je désire ?
- Graver à une hauteur de 1mm puis lui appliquer une échelle : par exemple 5 pour avoir une hauteur de 5mm.
- Comment positionner ma gravure ?
- Graver à l'origine.
- J'aurais ainsi la possibilité de positionner la gravure en faisant un décalage.
- Ou d'incorporer ce décalge dans la position des points.
- Vais je pouvoir graver des grandes valeurs en une seule fois ?
- Non. Il va falloir que je grave digit après digit (chiffre après chiffre).
- Je vais devoir inclure le décalage supplémentaire de l'écartement entre chaque digit.
- Il va donc falloir que je récupère un plan coté des digits pour connaitre l'espacement entre ceux ci.
- Je vais aussi devoir récupérer des parties de programme de gravure pour chaque digit.
- La gravure aura t'elle toujours la même profondeur ?
- Ca va être en fonction de l'outil utilisé et de la taille des digits.
- Si j'utilise une fraise à graver avec un angle de 30°, plus la gravure sera grande, plus je devrais descendre en profondeur.
- Si j'utilise une fraise droite (2 tailles), j'aurais peut être à graver à différentes profondeurs.
Ces bases étant posées, je vais pouvoir commencer à dessiner les chiffres dans un logiciel de FAO.
On se rappelle, je dois dessiner chaque digit à l'origine et de hauteur 1mm.
Pour me simplifier la tâche, je vais dessiner chaque digit sur une couche différente de façon à ne pas mélanger les différentes géométries.
Pour avoir les cotes d'encombrement et d'espacement, je vais profiter de mon précédent dessin pour y ajouter des cotes qui me serviront plus tard :
Maintenant que nous avons les bases, prenons notre logiciel de FAO favori et créons le programme qui nous permettra de graver tous ces digits :
:0001(0)
(GRAVURE 0 )
G0G90X.058Y.752
Z2.
G1Z-.3F500
X.056 Y .229
X.06 Y.208
X.091 Y.121
X.151 Y.051
X.23 Y.006
X.32 Y-.009
X.412 Y.006
X.491 Y.051
X.548 Y.121
X.579 Y.208
X.589 Y.737
X.556 Y.831
X.499 Y.903
X.421 Y.95
X.33 Y.972
X.233 Y.955
X.153 Y.909
X.09 Y.842
X.058 Y.752
G0Z2.
(GRAVURE 1)
G0G90X.008Y.719
Z2.
G1Z-.3F500
X.168Y.826
X.288Y.977
Y-.014
G0Z2.
(GRAVURE 2)
G0G90X.03Y.776
Z2.
G1Z-.3F500
X.065Y.857
X.129Y.919
X.212Y.959
X.302Y.972
X.408Y.953
X.496Y.903
X.556Y.83 |
X.578Y.736
X.55Y.627
X.473Y.504
X.357Y.382
X.207Y.273
X.084Y.159
X.006Y0.
X.578
G0Z2.
(GRAVURE 3)
G0G90X.02Y.776
Z2.
G1Z-.3F500
X.054Y.856
X.112Y.917
X.189Y.955
X.275Y.966
X.374Y.95
X.454Y.902
X.51Y.829
X.531Y.734
X.517Y.654
X.475Y.587
X.41Y.537
X.329Y.514
X.318
X.39Y.496
X.483Y.44
X.548Y.355
X.574Y.251
X.552Y.153
X.489Y.068
X.396Y.011
X.278Y-.009
X.188Y.004
X.105Y.041
X.04Y.1
X-.005Y.179
G0Z2.
(GRAVURE 4)
G0G90X.647Y.26
Z2.
G1Z-.3F500 |
X.007
X.508Y.977
Y-.014
G0Z2.
(GRAVURE 5)
G0G90X.558Y.963
Z2.
G1Z-.3F500
X.144
X.059Y.479
X.162Y.556
X.29Y.581
X.403Y.558
X.497Y.497
X.562Y.403
X.587Y.288
X.561Y.169
X.494Y.075
X.399Y.013
X.287Y-.009
X.197Y.004
X.116Y.041
X.051Y.099
X.006Y.177
G0Z2.
(GRAVURE 6)
G0G90X.557Y.817
Z2.
G1Z-.3F500
X.453Y.927
X.305Y.966
X.167Y.93
X.066Y.824
X.027Y.703
X.007Y.475
X.05Y.157
X.06Y.136
X.156Y.033
X.3Y-.009
X.402Y.013
X.492Y.077
X.553Y.17
X.575Y.287 |
X.553Y.4
X.495Y.493
X.408Y.557
X.3Y.581
X.19Y.558
X.101Y.497
X.042Y.405
X.02Y.292
G0Z2.
(GRAVURE 7)
G0G90X.007Y.963
Z2.
G1Z-.3F500
X.561
X.396Y.705
X.306Y.55
X.219Y.333
X.188Y.182
X.165Y-.042
G0Z2.
(GRAVURE 8)
G0G90X.29Y.514
Z2.
G1Z-.3F500
X.189Y.531
X.108Y.578
X.052Y.65
X.031Y.743
X.052Y.831
X.108Y.903
X.189Y.953
X.29Y.972
X.39Y.953
X.47Y.903
X.526Y.831
X.547Y.743
X.526Y.65
X.47Y.578
X.39Y.531
X.29Y.514
X.18Y.493
X.09Y.437
X.028Y.354 |
X.006Y.251
X.028Y.153
X.09Y.069
X.18Y.014
X.29Y-.007
X.399Y.014
X.49Y.069
X.551Y.153
X.573Y.251
X.551Y.354
X.49Y.437
X.399Y.493
X.29Y.514
G0Z2.
(GRAVURE 9)
G0G90X.022Y.144
Z2.
G1Z-.3F500
X.126Y.032
X.274Y-.009
X.412Y.027
X.508Y.133
X.545Y.219
X.561Y.314
X.568Y.41
X.572Y.492
X.558Y.696
X.52Y.821
X.424Y.926
X.279Y.972
X.171Y.943
X.084Y.882
X.026Y.788
X.004Y.674
X.026Y.557
X.084Y.464
X.172Y.4
X.279Y.376
X.386Y.399
X.476Y.461
X.537Y.553
X.56Y.666
G0Z2.
M99 |
Je reconnais que ce programme est un peu long (j'ai quand même supprimer les lignes d'entête et de fin qui ne servent à rien dans notre cas).
Nous allons nous concentrer, dans cet exemple, sur la gravure du digit "1". En effet, les autres digits répondront aux mêmes règles.
Pour ce faire, il faudra séparer la gravure de chaque digit dans un sous programme que nous pourrons appeler ultérieurement. Je conseille
vivement de prendre un numèro de sous programme qui se termine par le digit en question : :..0 pour le "0", :..1 pour le "1", ...
Pour ma part, je vais choisir :0100, :0101, :0102, ...
:0101(1)
(GRAVURE 1)
G0 G90 X.008 Y.719
Z2.
G1 Z-.3F500
X.168 Y.826
X.288 Y.977
Y-.014
G0 Z2.
M99
Une fois que j'ai créé tous mes sous programme, il est temps de commencer à les utiliser, mais comment ?
Ce que l'on a fait, c'est créer des sous programmes, donc nous avons la fonction auxiliaire M98 P.. qui nous le permet :
...
M98 P100
M98 P101
M98 P102
M98 P103
...
Mais nous voici déjà avec le premier probléme : nous avons gravé tous les digits à l'origine et l'un par dessus l'autre. Pas très lisible, tout ça !
Le deuxième problème visible c'est la taille pour la hauteur des digits : on a tout gravé à une taille de 1mm ...
Pour la position, une possibilité que nous avons, c'est de faire un décalage d'origine avant chaque gravure :
...
G52 X.. Y..
M98 P100
G52 X.. Y..
M98 P101
G52 X.. Y..
M98 P102
G52 X.. Y..
M98 P103
...
Mais, je pense que vous l'aurez compris, c'est assez fastidieux !
C'est une possibilité lorsque l'on doit graver une taille, par exemple, ou graver une information comme la semaine et l'année. La modification du code est
assez simple. Par contre, vais-je devoir toujours graver des digits en taille 1mm de haut ?
Non, et c'est pour cela que nous allons faire intervenir les paramètres.
La deuxième possibilité pour appeler un sous programme est de l'appeler en tant que macro client. Et comment on fais ça me direz vous ?
Et bien on va tout simplement utiliser la fonction préparatoire G65 P.. qui nous permet, non seulement, d'appeler un sous programme mais aussi de lui passer
des arguments. Mais qu'est que des arguments ?
Des arguments, sur FANUC, ce sont des lettres avec des valeurs qui seront récupérés, dans le sous programme, sous forme de paramètre. Un exemple concret que vous
connaissez tous pour l'avoir utilisé souvent, est un cycle de perçage : G81 X.. Y.. Z.. F..
En réalité, les lettres X, Y, Z et F, ici, sont des arguments de la routine G81. La fonction G81 est, en fait, un appel à un sous programme particulier via la fonction G65 P... Mais je ne rentrerais pas dans les détails de ces fonctions.
Il y a aussi les spécifications d'argument II, mais, à part l'étendue du nombre d'arguments, il n'est pas simple de s'y retrouver.
Pour commencer, nous allons utiliser cet appel pour positionner notre digit. Pour la clarté de la rédaction, je n'utiliserais que le digit "1" qui n'a pas trop de ligne.
Bien sûr, il faudra faire les mêmes opérations sur les sous programmes des autres digits.
G65 P101 X20 Y15
G65 : appel de sous programme
P101 : numéro du sous programme appelé
X20 : argument X récupéré en tant que paramètre #24 ayant pour valeur 20
Y15 : argument Y récupéré en tant que paramètre #25 ayant pour valeur 15
Transformons, maintenant le sous programme du digit "1" pour tenir compte de la position souhaitée :
:0101(1)
(GRAVURE 1)
G0 G90 X[#24+.008] Y[#25+.719]
Z2.
G1 Z-.3 F500
X[#24+.168] Y[#25+.826]
X[#24+.288] Y[#25+.977]
Y[#25+-.014]
G0 Z2.
M99
Maintenant, si on s'occupait de la taille des caractères ? Je vous rappelle que, pour l'instant, on grave à une taille de 1mm de hauteur...
Rajoutons un paramètre. Pour des raisons de compréhention, je vais choisir l'argument H pour hauteur.
G65 P101 X20 Y15 H5
G65 : appel de sous programme
P101 : numéro du sous programme appelé
X20 : argument X récupéré en tant que paramètre #24 ayant pour valeur 20
Y15 : argument Y récupéré en tant que paramètre #25 ayant pour valeur 15
H5 : argument H récupéré en tant que paramètre #11 ayant pour valeur 5
Transformons à nouveau nos sous programmes :
:0101(1)
(GRAVURE 1)
G0 G90 X[#24+[#11*.008]] Y[#25+[#11*.719]]
Z2.
G1 Z-.3 F500
X[#24+[#11*.168]] Y[#25+[#11*.826]]
X[#24+[#11*.288]] Y[#25+[#11*.977]]
Y[#25+[#11*-.014]]
G0 Z2.
M99
J'utilise, ici, des crochets "[]" pour éviter les problèmes de priorité des opérateurs. Mais un autre soucis vois le jour :
Si j'oublis de mettre l'argument H dans l'appelle du sous programme, le paramètre #11 aura une valeur nulle à l'intérieur de mon sous programme !
Il va donc falloir que je lui donne une valeur par défaut. Pour faire cela, on va tester la valeur du paramètre #11 en début de sous programme. Si sa
valeur est égale à 0, c'est que j'ai oublié de mettre l'argument H dans l'appel. Je vais donc pouvoir lui donner une valeur "par défaut". Celle ci sera donc égale à 1.
:0101(1)
(GRAVURE 1)
IF[#11EQ0]THEN#11=1(VALEUR PAR DEFAUT DE H)
G0 G90 X[#24[+#11*.008]] Y[#25+[#11*.719]]
Z2.
G1 Z-.3 F500
X[#24+[#11*.168]] Y[#25+[#11*.826]]
X[#24+[#11*.288]] Y[#25+[#11*.977]]
Y[#25+[#11*-.014]]
G0 Z2.
M99
- Allons un peu plus loin dans l'amélioration de la gravure. Les possibilités que j'aimerais apporter sont :
- Gérer la profondeur de gravure et le point d'approche. Effectivement, si je prends mon origine Z en dessous de la pièce,
un Z2 d'approche me met dans la pièce. Pas bon, tout ça ! De plus je voudrais pouvoir graver plus ou moins profond que 0.3mm.
Je vais donc rajouter 2 arguments qui seront Z (#26) pour la profondeur et R (#18) pour le point d'approche.
- L'avance peu aussi changer en fonction de la vitesse de rotation et de la matière à usiner. Je vais aussi rajouter l'argument F (#9)
pour donner l'avance que je souhaite.
- Et, bien sûr, ne pas oublier de leur donner des valeurs par défaut, sinon chaque argument oublié aura une valeur nulle.
:0101(1)
(GRAVURE 1)
IF[#11EQ0]THEN#11=1(VALEUR PAR DEFAUT DE H)
IF[#18EQ0]THEN#18=2(VALEUR PAR DEFAUT DE R)
IF[#26EQ0]THEN#26=-0.3(VALEUR PAR DEFAUT DE Z)
IF[#9EQ0]THEN#9=200(VALEUR PAR DEFAUT DE F)
G0 G90 X[#24+[#11*.008]] Y[#25+[#11*.719]]
Z#18
G1 Z#26 F#9
X[#24+[#11*.168]] Y[#25+[#11*.826]]
X[#24+[#11*.288]] Y[#25+[#11*.977]]
Y[#25+[#11*-.014]]
G0 Z#18
M99
Maintenant que nous avons la possiblité de graver tous les digits à l'endroit de notre choix, à la taille que nous voulons, à la profondeur souhaitée,
il est temps de nous attaquer à la réalisation de notre compteur.
Listons ce dont j'aurais besoin :
- Un compteur : pour cela j'utiliserais une variable que je pourrais initialiser à la valeur souhaitée et incrémenter au court du programme.
Je choisis la variable #500 aléatoirement. Toutefois, attention de ne pas l'utilisée ailleurs dans le programme, sinon ça va tout casser !
- Savoir sur combien de digits je veux graver : 2 chiffres, 3, 4 ou plus. Je vais le faire sur 3 chiffres.
- La taille que vont avoir mes digits : 5mm, 8mm ou autre. Je prends une hauteur de 6mm.
- A quelle position je vais graver. Allez, on commence à X35 Y10
- A quelle profondeur. Gravure sur 0.5mm
- A quelle vitesse d'avance. Pourquoi pas 600
Commençons par le commencement...
J'ai dit, plus haut, que je voulais utiliser la variable #500 pour sauvegarder le compteur. Je vais donc initialiser cette variable avec la valeur de début
que je souhaite graver.
Ici : 1
En IMD, je tape, au clavier : #500=1 [EOB] [INS] [DCY]. Je devrais faire cette opération à chaque mise en route du programme pour avoir, soit la continuité de la série précédente, soit redémarrer à 1.
Bien, on en voit le bout. Maintenant, il va falloir que je fasse des calculs pour récupérer chaque digit du compteur.
Par exemple, si mon compteur en est à 102, il faut que je récupère le 1, le 0 et le 2 pour pouvoir appeler le bon sous programme.
- Question : comment récuperer la valeur "1" du compteur "102" ?
- Réponse : je divise par 100... Oui mais que fais je des décimales (0.02) ?
Il y a, sur FANUC, une fonction que l'on va pouvoir utiliser : FIX[]. Cette fonction permet de ne garder que la partie entière d'un nombre
- Question : comment récuperer la valeur "0" du compteur "102" ?
- Réponse : je divise par 10... Oui mais que fais je des décimales (0.2) ?
- Encore oui, mais je vais me retrouver avec une valeur de 10 (la centaine + la dizaine)
Alors il va falloir que j'enleve cette centaine pour ne plus avoir à m'en inquiéter. Et je devrais faire ceci à chaque nouveau calcul.
La programmation paramétrée oblige l'utilisateur à beaucoup réfléchir avant de commencer à faire son programme, sinon il s'expose à beaucoup d'incohérences
et, au final, avoir un programme qui ne fonctionnera pas selon ses attentes.
Passons à la réalisation de notre programme :
...
(recuperation de la centaine)
#100=FIX[#500/100]
(recuperation de la dizaine)
#101=FIX[[#500-[#100*100]]/10]
(recuperation unite)
#102=FIX[#500-[#100*100]-[#101*10]]
(appel des sous programmes)
(decalage entres digits : 0.77*6 = 4.62)
G65 P#100 X35 Y10 Z-0.5 R2 H6 F600 (gravure du digit des centaines)
G65 P#101 X[35+4.62] Y10 Z-0.5 R2 H6 F600 (gravure du digit des dizaines)
G65 P#102 X[35+4.62+4.62] Y10 Z-0.5 R2 H6 F600 (gravure du digit des unites)
#500=#500+1
...
Et voilà, le travail est accompli. Nous voici avec la gravure d'un compteur qui sera incrémenter après chaque gravure.
Il y a encore des améliorations qui peuvent être apportées à ce code, mais ceci est fonction du but à atteindre.
N'hésitez pas à me contacter par email si quelques points devraient être éclairci pour une meilleur compréhention.
