Graveuse Maison

GRAVEUSE CNC

Matériel

Châssis « maison » solide en bois

Récupération : glissières de tiroir (mouvement X,Y), glissière à roulements en V (mouvement Z), vis sans fin d'une ancienne machine (X, Y), tige filetée de 4mm (Z)

Sur châssis horizontal, plateau mobile : moteur et axe Y (longueur)

Sur un pont fixé au châssis horizontal : moteurs et axes horizontalX (largeur) et vertical Z (profondeur gravure)

Sur l'axe Z : berceau pour Dremel (ou ultérieurement laser), fabrication « maison » en tôle alu 5mm

[[Image:]]

[[Image:]]

Arduino Uno

3 moteurs pas à pas : Epson (récup sur imprimante) : Z

2 x Nema 17 0,9A : X Y

3 shields compatibles A4988 Pololu (courant réglable, 2A max)

Essais moteurs et mécanique

Pour tester (ou vérifier!) les moteurs et les shields (fragiles) il est très utile d'avoir une (autre) platine Arduino connectée sur une « breadboard ». Sur internet j'ai trouvé un modèle de sketch que je modifie à volonté :

// --- Commande d'un StepStick/Driver A4988 ----------------------
// A4988_Test.ino
//
// Commande d'un moteur pas-à-pas à l'aide d'un pilote A4988 avec
// Arduino.
//
// Un projet www.mchobby.be (vente de kit et composant)
// Meurisse D. - Licence CC-SA-BY
//
// Un tutoriel http://mchobby.be/wiki/index.php?title=A4988
// Ou Acheter un StepStick A4988
// http://shop.mchobby.be/product.php?id_product=349
//

#define pinEnable 13 // Activation du driver/pilote
#define pinStep 9 // Signal de PAS (avancement)
#define pinDir 8 // Direction 

void setup(){
Serial.begin(9600);
Serial.println("Test A4988");
pinMode( pinEnable, OUTPUT );
pinMode( pinDir , OUTPUT );
pinMode( pinStep , OUTPUT );
}

void loop(){
int i = 0;
int d = 3000;
digitalWrite( pinDir , HIGH); // Direction avant
digitalWrite( pinStep , LOW); // Initialisation de la broche step
Serial.println("Fin initialisation + attendre 2 sec");
delay( 2000 );

// Avance de x pas
for( i=0; i<5000; i++){

//Serial.println( i );
digitalWrite( pinStep, HIGH );
delayMicroseconds( 1000 );
digitalWrite( pinStep, LOW );
delayMicroseconds( 1000 );
//delay (2000);
} 

// Changer de direction
Serial.println("Attendre 2 sec + Retour");
digitalWrite( pinDir , LOW); // Direction avant
delay( 2000 );
d = 350;

// Refaire x pas dans l'autre sens
for( i=0; i<5000; i++){
//Serial.println( i );
digitalWrite( pinStep, HIGH );
delayMicroseconds( 1000 );
digitalWrite( pinStep, LOW );
delayMicroseconds( 1000 );
} 

// Pas de step et pas d'ordre... 
// l'axe du moteur est donc bloqué 

Serial.println("Axe bloque + attendre 2 sec");
delay( 5000 );

// déblocage de l'axe moteur
Serial.println("Deblocage axe");
digitalWrite( pinEnable, HIGH ); // logique inversée

// Fin et blocage du programme
// Presser reset pour recommander
Serial.println("Fin de programme");

while( true );
}

Branchement spécial du moteur Epson , à partir repère bleu sur nappe :

1 1A moteur 1

2 2A moteur 2

3 1B moteur 1

4 2B moteur 2

Pour les deux autres moteurs : ordre normal des fils :

Re 1B moteur 1

Je 1A moteur 1

Nr 2A moteur 2

Vt 2B moteur 2

Réglage courant sur 12V, A4988 enabled (axe bloqué), sans impulsion step : 0,8A

Ne pas négliger l'étape la plus importante (et la plus longue) : la précision de la mécanique.

Après un réglage soigneux de la mécanique (ni durs ni jeux) mesurer la course de chaque axe en fonction du nombre de pas pour pouvoir paramétrer le logiciel de traitement de Gcode

Axe X 9.000 steps = 18 cm

Axe Y 11.000 steps = 22 cm

Axe Z 10.000 steps = 3,9 cm

Logiciels (pour Ubuntu 14.04)

GRBL (côté Arduino)

Le site : https://github.com/grbl/grbl/wiki/Connecting-Grbl donne le détail de la connectique associée à ce logiciel.

Le shield est fait « maison » sur circuit imprimé avec des connecteurs mâle (vers Arduino) et femelle (support contrôleurs moteurs).

Note : GRBL ne sait pas gérer la vitesse du moteur, mais peut commander sa mise en marche.

Installation logicielle d'après : https://github.com/grbl/grbl/wiki/Compiling-Grbl paragraphe « Via the Arduino IDE (All Platforms) » un peu adapté comme ci-après.

Télécharger le code source Grbl (V0.9i) →Fichier grbl-master.zip

Dézipper dans un dossier de travail → Dossier grbl-master

Changement version Arduino recommandé  (>1.6 = 1.6.3 ) (Sous Ubuntu : méthode spéciale car pas possible avec logithèque Ubuntu (note personnelle : voir changements PC-A au 4/4/2015))

Plus simple que la doc Github :

Copier dans le dossier libraries du dossier des sketchs le dossier Grbl du dossier grbl-master. (ce dossier contient des fichiers source (.c et .h) et un dossier examples)

Connecter l'Arduino sur le PC

Lancer l'IDE Arduino

Vérifier le port série (/dev/ttyACM0) et le type de carte (Arduino Uno)

Ouvrir dans l'IDE le sketch /examples/grblUpload/grblUpload.ino

(mis à part les commentaires il n'y a rien dans ce sketch si ce n'est un include)

Compiler et charger dans l'Arduino ce sketch : ils flash le programme Grbl dans la mémoire

Lancer le moniteur série de l'IDE

Modifier les paramètres de transmission : vitesse 115200 bauds, fin de ligne = les deux, NL et CR

On doit voir le message « Grbl 0.9i ['$' for help] » indiquant qu'on peut taper des commandes Grbl (par exemple paramétrer la prise en compte de la CNC) ou des commandes Gcode

Attention : depuis la version Grbl 0.9, la broche Z-limit (voir plus loin la fonction « homing ») n'est plus sur la pin 11 mais sur la pin 12

La pin 12 ne peut donc plus servir pour commander un relais qui démarre/arrête un moteur (ordre Gcode M3/M5)

Si vous voulez le faire, il faut rendre à la pin 11 sa fonction de Z-Limit et la pin 12 pourra servir pour la fonction Spindle Enable (0V=Off, 5V=On)

Pour cela, il faut éditer le fichier /sketchs/libraries/grbl/config.h et mettre en commentaire la ligne qui contient « #define variable_spindle ….. »

Ensuite, compiler et recharger dans l'IDE Arduino le sketch : /examples/grblUpload/grblUpload.ino

Universal Gcode Sender (UGS) (Côté PC)

Sur le site: https://github.com/winder/Universal-G-Code-Sender

Dans le paragraphe Downloads : télécharger le fichier zip → UniversalGcodeSender-v1.0.8.zip

Unzip → dossier UniversalGcodeSender-v1.0.8

Copier le contenu du dossier dans /home/dom/UGS

Lancement du programme java :

dom@PC-A:~/UGS$ java -jar -Xmx256m UniversalGcodeSender*.jar

Tests et Réglages

Avec UGS :

Open Connection, /dev/ttyACM0, vitesse 115200

Paramétrer GRBL : onglet Commandes ($$ ou $x=…) ou mieux Settings → Fimware Setting → GRBL)

Réglage des pas :
X → $100=50 (9000pas/180mm)

Y → $101=50 (11000pas/220mm)

Z → $102=256,4 (10000pas/39mm)

Réglage direction :
$3=7 (direction Z X Y inversées – sur cette machine et selon mes goûts)

Réglage vitesses max:
X → $110=400

Y → $111=400

Z → $112=200

Test des moteurs (onglet Machine Control)

!!! Attention danger de tout casser en bloquant au bout des axes !!!

D'ou l'intérêt d'avoir un bouton d'arrêt d'urgence qui coupe l'alimentation des moteurs.

Passer en mm (et pas en inchs) et utiliser des petites valeurs de course (Step size)

Tester chaque moteur (touches X+ X- Y+ Y- Z+ Z-)

Tester les jeux mécaniques et voir si on ne saute pas des pas moteurs : faire de nombreux aller et retour sur le même axe pour voir si on revient bien à la même position mécanique pour la même position logicielle

GRBL possède des fonctions très intéressantes pour contrôler les courses sur les trois axes.

Il y a plusieurs méthodes possibles.

Voici la mienne :

J'ai installé un contact de fin de course (micro-switch) sur chaque axe, à son origine (pas à son maximum)

Ceci permet d'utiliser la fonction « homing » qui est le retour à la Work Position (x,y,z)=(0,0,0) par la commande $H

Le câblage des switchs sur l'Arduino est, à priori et inutilement, très discuté, j'ai utilisé celui-ci qui me paraît logique du point de vue électronique (et très utilisé !). La Limit Pin passe de +5V à 0V quand le contact est poussé.

Après réglage des courses des switchs, il faut paramétrer GRBL en fonction (dans l'ordre)

Homing Cycle$22=1

Softs Limits$20=1

Pour ma machine :

Max TravelX → $130=200 (mm)

Y → $131=220 (mm)

Z → $132=40 (mm)

Homing dir invert$23= 7

Homing feed$24=25.000(Pour info)

Homing seek$25=600.000 (Pour info)

Close et open de la connexion pour prise en compte. L'alarme est normale, elle sert à nous avertir de la nécessité de calibrer la machine en faisant un homing (commande $H).

Ne pas s'inquiéter si les coordonnées Machine Position sont négatives, le principal est que les coordonnées Work Position soient à 0.

En positionnant la machine ou en interprétant le Gcode, GRBL bloque quand on dépasse les limites.

Générer le Gcode avec Inkscape (0.48.4 r9939)

Le logiciel de dessin 2D utilisé est Inskape.

Une extension à ce logiciel permet de générer du Gcode : Gcodetools V1.7 ( http://www.cnc-club.ru/gcodetools – doc sur http://www.cnc-club.ru/forum/viewtopic.php?t=35#latest_version (doc pas terrible !))

Pour installer : sudo tar xzvf gcodetools-1.7.tar.gz -c /usr/share/inkscape/extensions/

Utilisation : généralités

L'utilisation de cette extension est un peu délicate, voici ce que j'ai compris :

Pour générer du Gcode, il y a trois étapes, les deux premières étant préparatoires

Attention, l'utilisation du point ou la virgule n'est pas très cohérente avec Inkscape !

Extensions → Gcodetools → Orientations points

Z surface= coordonnée Z de la surface du matériau à travailler

Z depth= profondeur de coupe maximale (nombre algébrique – négatif pour profondeur)

→ Appliquer :crée les repères dans un cadre de texte du calque en cours (On peut ensuite modifier ce texte)

Extensions → Gcodetools → Tools library

Choisir le type d'outil

→ Appliquer : crée un cadre de texte dans le calque en cours qui définit l'outil (On peut ensuite modifier ce texte)

Diameter: diamètre outil

Feed : vitesse mouvement

Penetration feed : vitesse pénétration

Shape : Pour les outils coniques (voir : Utilisation : gravure complexe)

Depth step : profondeur de chaque passe de coupe

Extensions → Gcodetools → Path to Gcode (génération du Gcode)

→ onglet Préférences

nom et emplacement fichier généré

Z safe height for G0 move over blank = hauteur de mise en garde de l'outil

→ onglet Options

Scale along Z axis = coefficient (nombre algébrique – négatif pour coupe)

Ce coefficient s'applique à Z depth, Z safe, Depth step

Offset along Z axis = positionnement outil pour début de travail (en surface pièce)

→ onglet Path to Gcode

→ Appliquer pour générer le Gcode

Important : on doit faire Appliquer dans cet onglet pour générer le Gcode

Après moult essais, voici ce que j'ai compris, c'est à dire pas tout

Avant de générer le Gcode :

- sélectionner le dessin à traiter et grouper les objets

- convertir l'objet en chemin (un seul trait de gravure)

et/ou

- convertir le contour en chemin (deux traits de gravure entourant le contour)

Comme déjà dit, les deux textes générés (outils et orientation points) peuvent être modifiés dans le calque par l'outil texte (icône A majuscule), il peut y avoir autant de ces textes que de calques, la génération du Gcode se faisant par calques et pour le dessin sélectionné, ce qui peut être utile pour changer d'outil

Le Gcode généré peut comporter plusieurs passes de coupe

Chaque passe comporte au départ trois commandes :

G00 Zpp.pppp = positionnement initial de l'outil de coupe sans toucher le matériau (mise en garde)

Cette coordonnée dépend des paramètres Zsafe, Offset, Scale

G00 Xxx.xxxx Yyy.yyyy = mouvement X Y sur le matériau en début de coupe (avec le Z précédent)

G01 Zqq.qqqq Fvv.vvvv (Penetrate) = Plongée de l'outil dans le matériau

vv.vvvv = vitesse de pénétration (penetration feed de l'outil)

qq.qqqq = profondeur de passe

En fin de passe, l'outil est mis en garde :

G00 Zpp.pppp

Le cas échéant, les autres passes sont enchainées sur le même modèle

Le nombre de passes dépend des paramètres :

Zdepth (Orientation points)

Scale Z (Path Gcode Options) : nombre algébrique (négatif pour coupe)

Depth step (Outil)

Les formules de calcul :

G0 Zpp.pppp = Offset Z + (Scale Z * Z safe)

G1 Zqq.qqqq = Offset Z – (Scale Z * Depth step)

G1 Zqq.qqqq = Z précédent – (Scale Z * Depth step)

Attention, cette formule est algébrique et tient compte du signe de Scale Z !

Le Gcode fait autant de passes de profondeur Depth step que possible, le G01 Zqq.qqqq au début de la passe étant incrémenté par rapport à celui de la passe précédente.

La profondeur de la dernière passe est réduite de façon à ne pas dépasser Scale Z * Z depth.

Exemples : Zdepth = -2 (profondeur = 2 mm), Scale Z = -1

Si Depth step = 1 il y aura 2 passes de 1mm = 2

Si Depth step = 2 il y aura 1 passe de 2mm = 2

Zdepth = -1,5 (profondeur = 1,5mm), Scale Z = -1

Si Depth step = 1 il y aura 1 passe de 1mm et une passe de 0,5mm = 1,5mm

En fin de travail, il faut faut arrêter l'interprétation du Gcode suivant la même procédure que pour un arrêt d'urgence :

→ $C (File Mode)

→ Soft reset (Machine Control)

→ $H

ou

→ Pause (File Mode)

→ Resume

→ $H (Machine Control)

Utilisation : Gravure simple

L'outil, cylindre fin ou cône, suit les chemins (Contour ou Path) avec un trait fin et de profondeur constante

Exemples :

circuit imprimé avec plan de masse : les pistes sont isolées des autres et de la masse par le trait

gravure de textes inkscape : deux contours pour chaque lettre (dans ce cas sur du plexi)

Outil : cylindre fin ou cône

La découpe déborde de manière égale de chaque côté du chemin (visible dans Inkscape en mode d'affichage contour), elle dépend donc du diamètre de l'outil.

Le style du contour (remplissage, épaisseur) n'influe pas sur la gravure mais, s'il est égal au diamètre de l'outil, permet de visualiser celle-ci

Sinon on peut mettre sans problème le style à aucun remplissage (donc épaisseur = 0) et travailler en mode d'Affichage Contour dans Inkscape.

Utilisation : Gravure complexe

L'outil conique suit l'objet dessiné avec une profondeur variable suivant la largeur de l'objet

Exemple : lettres avec un seul contour et pleins et déliés (calligraphie)

Le paramètre shape de l'outil gère la variation de profondeur

Utilisation : Détourage (ou découpe)

L'outil cylindrique suit les chemins (contour)

Si on veut dimensionner correctement l'objet détouré, dans Inkscape, il faut ajouter (ou soustraire si l'objet est en creux) aux dimensions de l'objet le diamètre de l'outil (demi diamètre de chaque côté du chemin)

Utilisation : Défonçage ou fraisage

Sélectionner le ou les objet qui délimitent l'aire à défoncer

S'il y a plusieurs objets, en sélectionner deux et les associer en faisant : → Chemin ->Union

Associer de la même manière les chemins ainsi associés avec chacun des autres objets

Sélectionner l'option Aire de GcodeTools (et non pas Path to Gcode)

Il y a deux manière de défoncer

- soit en positif : l'objet est relief (en sculpture on dit qu'on doit « descendre le fond »)

→ onglet Aire

→ Appliquer

des chemins de découpe sont générés à l'extérieur des objets sélectionnés

- soit en négatif : l'objet est en creux

→ onglet Fill

→ Appliquer

des chemins de découpe sont générés à l'intérieur des objets sélectionnés

Résumé des paramètres essentiels

Orientation pointsZ DepthProfondeur max (-)

ToolsDepth stepProfondeur de chaque passe

Path to GcodeZsafeRetrait outil / Coord. Z surface

Scale ZCoefficient (peut être différent de -1)

Offset ZCoordonnée pointe outil sur Z surface