Comment faire l'électronique de sa CNC DIY

Petite précision avant de commencer, nous allons seulement voir ici les bases pour faire l'électronique de sa CNC. 
Je sais qu'il y a du matériel plus récent, plus performant qui permet plus de fonctionnalités, etc... Mais là, je vais vous montrer les grandes lignes avec du matériel simple et sans rentrer dans le détail de tous les paramétrages pointus.

1 - MATÉRIEL

Pour l'électronique que je vais vous présenter, on va se baser sur une carte Arduino Uno qui est simple à prendre en main, équipée d'une CNC Shield V3 de chez Protoneer :

On aurait pu faire sans CNC Shield, mais déjà :

- c'est long, fastidieux.
- c'est pas résistant ni à la poussière ni aux vibrations, c'est un coup à avoir des courts-circuits de partout.
- c'est très compliqué à intégrer proprement dans un boîtier car ça prend de la place et à cause du point 2, il faut bien le protéger.

Voici le genre de montage que la CNC Shield permet d'éviter :

Pour la motorisation, nous allons utiliser des moteurs Nema17, qui sont des moteurs pas à pas, 200 pas par révolution. Ce sont des moteurs utilisés dans 99 % des imprimantes 3D et CNC grand public qu'on peut trouver un peu partout sur Amazon ou autre.

Les moteurs pas à pas ne sont pas des moteurs classiques que l'on branche sur une alimentation et qui se mettent à tourner comme par magie.
Ils effectuent une série "de crans", de pas, pour tourner, ce qui permet de contrôler précisément leur vitesse, leur sens de rotation et surtout leur position.

Dans notre cas, les Nema17 font 200 pas pour faire un tour complet. Ce qui signifie que l'on peut contrôler leur position à 360 / 200 = 1.8° près !

Pour leur faire faire un pas, il faut leur envoyer une impulsion électrique. C'est-à-dire que pour les faire tourner, il faut leur envoyer une série d'impulsions :
- En contrôlant le nombre d'impulsions qu'on envoie, on contrôle leur position.
- En contrôlant la fréquence des impulsions, on contrôle leur vitesse.

On ne peut pas envoyer directement les signaux de commande de l’Arduino vers les moteurs, car les moteurs demandent beaucoup plus de puissance que ce que l’Arduino peut fournir.

Pour convertir ces signaux de commande en signaux capables d’alimenter le moteur, on utilise un composant électronique appelé driver moteur.

Dans notre cas, le driver reçoit de l’Arduino les impulsions de commande (et l’information de sens de rotation), puis il amplifie ces ordres et les transforme en impulsions électriques de puissance, qu’il envoie ensuite au moteur pour le faire tourner.

Il existe 2 références de drivers moteur HYPER connus : les DRV8825 et les A4988.

(Encore une fois, je sais qu'il existe plus de références de drivers moteurs, plus performants avec des fonctionnalités plus poussées type Trinamic avec système de réduction de bruit, détection de perte de pas, etc. mais ici, je reste sur des choses simples.)

Ces deux drivers moteurs sont protégés contre les surchauffes (dans une certaine limite, évidemment) mais ils ont 2 différences importantes :

• le courant maximal que peut envoyer le driver au moteur
• le nombre de divisions de "micro-stepping"

Voici les valeurs pour ces deux drivers :

• DRV8825 : Courant admis jusqu'à 1.5A sans refroidissement, 2.2A avec un refroidissement très efficace (radiateur + ventilateur). Division maximale de 1/32 pour le micro-stepping.
• A4988 : Courant admis 1.2A avec refroidissement, et 2A avec un refroidissement efficace (radiateur). Division maximale de 1/16 pour le micro-stepping.

Un courant plus élevé va permettre de mettre des moteurs plus gros donc plus gourmands et/ou pouvoir faire forcer les moteurs un peu plus. Ici, le DRV8825 accepte plus de courant donc il permet plus de marge pour choisir ses moteurs.

Le micro-stepping, quant à lui, consiste à diviser le pas d'un moteur en pas encore plus petits, donc à multiplier le nombre de pas total du moteur pour faire 1 tour.

Par exemple, notre moteur Nema17 - 200 pas par révolution, avec un micro-stepping de 1/2, effectuera 200 x 2 = 400 pas pour faire un tour. Donc, en suivant la logique, le DRV8825 est capable de multiplier par 32 le nombre de pas de notre moteur, alors que le A4988 le multiplie au maximum par 16.

Je préfère naturellement les DRV8825 car il admet plus de courant et possède un micro-stepping bien plus fin.

Et enfin, pour alimenter tout ça, nous allons avoir besoin d'une alimentation assez puissante principalement pour supporter la charge des moteurs. Chaque moteur consomme environ 5W, ce qui nous donne 20W sur un montage à 4 moteurs.

J'utilise personnellement une alimentation 12V 5A (environ 60W) qui est largement suffisante pour mon utilisation :

2 - LOGICIELS

Maintenant qu'on a fait un peu le tour du matériel, nous allons voir les logiciels nécessaires pour programmer, paramétrer et piloter une CNC.

Le premier logiciel dont on va avoir besoin, c'est l'Arduino IDE, qui est l'environnement de développement Arduino. Il est totalement gratuit et va nous permettre de programmer dans notre carte Arduino le logiciel embarqué, aussi appelé firmware en anglais. Pour l'installer, rien de compliqué, il suffit de le télécharger et de suivre un classique "Suivant Suivant...".

Voici le lien pour le télécharger : Arduino IDE - Software

Une fois que vous l'avez installé, lancez-le pour vérifier qu'il s'est bien installé. Vous devriez avoir cette fenêtre :

Branchez votre carte Arduino à l'ordinateur et vérifiez dans l'onglet "Outils" que le logiciel est capable de reconnaître votre carte correctement.

Vous pouvez sélectionner le port de communication (qui devrait apparaître) et le type de carte. Vérifiez que tout est bien détecté, sinon choisissez le bon type de carte.

A ce stade, vous êtes capable de programmer votre Arduino, mais la question est : avec quel firmware ?

Nous allons utiliser ici le firmware GRBL, qui est open source (gratuit) et très largement utilisé dans les CNCs grand public. Il est même assez utilisé pour que des logiciels très connus comme Fusion360 intègrent l'exportation des chemins d'usinage au format GRBL.

Voici le lien pour le télécharger : GRBL - Last Release

Vous allez devoir télécharger le zip "Source code (zip)".

Il suffit ensuite de l'extraire, vous devriez avoir une arborescence de dossiers et de fichiers. Le seul dossier qui va nous intéresser, c'est "grbl".

Ce dossier est une bibliothèque pour le logiciel Arduino IDE. On va donc retourner sur le logiciel et inclure ce dossier en cliquant sur "Ajouter la bibliothèque ZIP" dans l'onglet "Croquis > Inclure une bibliothèque".

Là, vous naviguez jusqu'à l'endroit où vous aurez extrait le dossier et vous sélectionnez le dossier "grbl" (ce n'est pas un dossier zip, mais ça marche quand même).

Après ça, en retournant dans l'onglet croquis, vous devriez avoir la bibliothèque grbl qui est apparue dans le même onglet :

Vous avez maintenant GRBL prêt ! Il ne nous reste plus qu'à programmer la carte Arduino avec.

Pour cela, nous allons simplement ouvrir le projet Arduino IDE fourni avec GRBL. Comme on a ajouté GRBL en tant que bibliothèque, on a juste à aller sur "Fichier > Exemples > grbl > grblUpload", et le projet va s'ouvrir dans une nouvelle fenêtre !

Il ne reste plus qu'à "téléverser" le programme sur la carte Arduino en cliquant sur ce petit bouton en haut à gauche de la fenêtre :

Dans la console noire en bas de la fenêtre, vous devriez voir des choses passer, des informations de compilation et de téléversement. Vous êtes en train de programmer GRBL dans votre Arduino !

Attendez un peu jusqu'à ce que la programmation soit terminée. La console devrait ressembler à cela, affichant "Téléversement terminé" si tout s'est bien passé :

(Il y a des messages de warning au niveau de la mémoire disponible, c'est normal, GRBL utilise la quasi-totalité de la place disponible sur la mémoire de l'Arduino.)

Et voilà ! Vous avez programmé votre carte Arduino, avec GRBL. Arduino IDE vous indique que le téléversement s'est bien passé, mais nous n'avons pas encore le moyen de vérifier que GRBL lui-même fonctionne bien...

C'est donc le moment d'introduire le troisième et dernier logiciel dont on va avoir besoin, j'ai nommé : CNC JS !

CNC JS va nous permettre de communiquer avec GRBL. Nous allons pouvoir le paramétrer mais aussi et surtout, piloter notre CNC !

Pareil que pour les autres logiciels, nous allons télécharger et installer CNCJS, voici le lien : CNCJS - Last release

Une fois installé, vous pouvez le lancer, vous devriez avoir cette fenêtre :

Vous pouvez voir à gauche une section intitulée "Connexion". Sélectionnez le port de communication de votre Arduino (le même que dans Arduino IDE), réglez la vitesse de transmission à 115200 (je ne vais pas rentrer dans les détails), puis cliquez sur "Ouvrir".

La section "Console" juste en dessous devrait s'ouvrir et afficher un tas de paramètres en blanc sur un joli fond noir :

Ces paramètres sont envoyés par GRBL, ce qui veut dire que GRBL est correctement exécuté. En remontant un peu dans la console, vous devriez même retrouver le numéro de version de GRBL que vous venez d'installer.

On vient de terminer l'installation des logiciels et la programmation de l'arduino. Nous allons aussi vérifier que GRBL a bien été installé et qu'il répondait. Nous allons maintenant passer au montage / assemblage des composants entre eux.

3 - MONTAGE

Le montage est plutôt simple, c'est du lego !

Pour commencer, nous allons monter la carte CNC Shield sur l'arduino. À ce niveau, on ne peut pas vraiment se tromper.

Ensuite, on va placer les cavaliers de micro-stepping. Il y a 3 emplacements possibles sous chaque emplacement de driver moteur.

En fonction de comment on positionne les jumpers (cavaliers), on sélectionne le mode de division de micro-stepping. Voici le tableau de correspondance pour chaque référence de driver :

Retenez bien quel mode vous avez sélectionné, ça va être très important pour la suite !

Personnellement, je mets tous les jumpers sur le DRV8825. Je suis à 1/32 de micro-stepping.

Ensuite, on colle les radiateurs souvent livrés avec les drivers. Si, comme moi, vous avez une machine assez grosse, je vous conseille d'acheter des radiateurs beaucoup plus gros qui permettront de mieux refroidir vos drivers.

Nous allons pouvoir placer les drivers sur leur emplacement respectif, sur la CNC Shield.

ATTENTION : Ici, il faut bien regarder et positionner la pin "Enable" (ou "En") du driver sur la pin Enable de la CNC Shield, sinon vous êtes sûr de tout griller.

Une fois que vous avez mis tous vos drivers en faisant attention à la pin Enable, nous allons nous attarder sur le 4ème emplacement de driver moteur.

Sur la CNC Shield, à côté de chaque emplacement de driver moteur, il y a le nom de l'axe que ce driver va piloter (X, Y ou Z), mais il y a aussi un 4ème driver intitulé 'A'.

Ce 4ème driver va pouvoir recopier tous les mouvements d'un des 3 autres axes, au choix. Si, comme moi, vous avez une CNC avec 2 moteurs pour 1 seul axe, vous allez devoir utiliser cette fonctionnalité de duplication d'un axe. (Dans mon cas, c'est l'axe Y qui dispose de 2 moteurs.)

Sur le côté de la CNC Shield, vous avez des emplacements pour des jumpers portant le nom des axes. Vous allez devoir placer 2 jumpers côte à côte pour sélectionner l'axe que vous voulez répliquer.

Il nous reste plus qu'à brancher l'alimentation et les 4 moteurs. Pour l'alimentation, c'est simple, il y a un bornier sur le CNC Shield, on met le + sur le fil rouge, le - sur le fil noir...

Attention quand même, il ne faut pas brancher l'alimentation sur l'Arduino directement mais bien sur le bornier de la CNC Shield. L'Arduino sera simplement alimenté par le port USB.

Pour brancher les moteurs, se trouve un connecteur à 4 pins à côté de chaque driver. Il n'y a pas de sens particulier, car en retournant le connecteur, on inverse simplement le sens de rotation du moteur.

Le montage est terminé ! Nous pouvons passer au paramétrage de GRBL.

4 - PARAMÉTRAGE

Pour le paramétrage, on va rebrancher notre Arduino en USB à l'ordinateur et on va alimenter la CNC Shield avec l'alimentation branchée juste avant.

Une fois que tout est branché, nous pouvons retourner sur CNCJS, ouvrir la communication et ouvrir la section console.

Vous devriez avoir comme plus haut tout cela qui s'affiche :

CNCjs 1.9.20 [Grbl]
Connected to COM7 with a baud rate of 115200
Grbl 1.1h ['$' for help]
client> $$
$0=10 (Step pulse time, microseconds)
$1=25 (Step idle delay, milliseconds)
$2=0 (Step pulse invert, mask)
$3=0 (Step direction invert, mask)
$4=0 (Invert step enable pin, boolean)
$5=0 (Invert limit pins, boolean)
$6=0 (Invert probe pin, boolean)
$10=3 (Status report options, mask)
$11=0.010 (Junction deviation, millimeters)
$12=0.002 (Arc tolerance, millimeters)
$13=0 (Report in inches, boolean)
$20=0 (Soft limits enable, boolean)
$21=1 (Hard limits enable, boolean)
$22=0 (Homing cycle enable, boolean)
$23=0 (Homing direction invert, mask)
$24=25.000 (Homing locate feed rate, mm/min)
$25=500.000 (Homing search seek rate, mm/min)
$26=250 (Homing switch debounce delay, milliseconds)
$27=1.000 (Homing switch pull-off distance, millimeters)
$30=17000 (Maximum spindle speed, RPM)
$31=3000 (Minimum spindle speed, RPM)
$32=0 (Laser-mode enable, boolean)
$100=50.000 (X-axis travel resolution, step/mm)
$101=50.000 (Y-axis travel resolution, step/mm)
$102=50.000 (Z-axis travel resolution, step/mm)
$110=500.000 (X-axis maximum rate, mm/min)
$111=500.000 (Y-axis maximum rate, mm/min)
$112=500.000 (Z-axis maximum rate, mm/min)
$120=50.000 (X-axis acceleration, mm/sec^2)
$121=50.000 (Y-axis acceleration, mm/sec^2)
$122=50.000 (Z-axis acceleration, mm/sec^2)
$130=400.000 (X-axis maximum travel, millimeters)
$131=400.000 (Y-axis maximum travel, millimeters)
$132=150.000 (Z-axis maximum travel, millimeters)
ok
>

On va seulement s'attarder sur les 4 paramètres les plus importants.

En premier, le paramètre "$1=25", c'est le paramètre qui va indiquer à GRBL au bout de combien de temps il doit éteindre (dés-alimenter) le moteur après un mouvement. L'unité de ce paramètre est la milliseconde.

Par défaut, après un mouvement, le moteur est éteint au bout de 25 ms.

Un moteur alimenté va forcer pour garder sa position actuelle. S'il est éteint, il n'exercera aucune force pour garder sa position et pourra tourner très facilement.

Prenons l'exemple de l'axe Z qui fait monter / descendre la fraise. Lorsque l'on découpe une planche, le moteur de l'axe Z va faire descendre la fraise dans le bois, puis va rester à sa position durant toute la découpe. C'est là que l'on commence à comprendre le problème.

Si le moteur descend à la bonne position puis s'éteint, vu qu'il n'applique aucune force pour garder sa position, il va très certainement "glisser" plus bas à cause des vibrations pendant le fraisage !

Pour corriger ce problème, il suffit de mettre 255 au paramètre $1. GRBL considère que 255 est un temps infini, donc il n’éteindra jamais les moteurs même après un mouvement. Attention, de 1 à 254, GRBL prendra le paramètre comme des millisecondes, seule la valeur 255 est considérée comme l'infini.

Nous allons donc tout simplement taper cette ligne dans la console :

$1=255

Le second paramètre, c'est le groupe "$100", "$101" et "$102". Il s'agit de la résolution de déplacement pour chaque axe (X, Y et Z dans l'ordre).

La résolution de déplacement s'exprime en pas par millimètre, c'est le nombre de pas que doit effectuer le moteur pour faire déplacer notre machine de 1 mm.

Pour calculer la résolution, il nous faut :

• Le nombre de pas de base de notre moteur (dans notre cas, c'est 200)
• Le mode de micro-stepping choisi, c'est ici qu'il est très important (dans mon cas, 1/32)
• Le système de guidage de la machine (dans mon cas, des vis trapézoïdales 8 mm par tour)

Sur ma machine, j'utilise des DRV8825 et des vis trapézoïdales dont l'écrou avance de 8 mm à chaque fois que la vis fait 1 tour.

Voici donc un exemple de calcul de la résolution basé sur les valeurs de ma machine :

(200 pas (Nema17) x 32 (micro-stepping)) / 8 (vis trapézoidale) = (200 x 32) / 8 = 800 pas / millimètre

Nous allons faire un deuxième exemple pour une machine à courroie GT2. Ce sont les courroies classiques utilisées en impression 3D, elles ont un pas de 2 mm par dent. Nous allons aussi dire que le moteur est équipé d'une poulie de 20 dents et qu'on utilise un A4988 en 1/16 microstepping.

Donc voici le calcul :

(200 pas (Nema17) x 16 (micro-stepping)) / (2 (pas de la courroie) x 20 (nombre de dents de la poulie)) = (200 x 16) / (2 x 20) = 80 pas / millimètre

Nous allons donc renseigner cette valeur à GRBL (dans mon cas, 800) :

$100=800
$101=800
$102=800

C'est avec cette valeur que l'on peut calculer la précision atteignable (théorique) par notre machine en divisant 1 millimètre par le nombre de pas :

1 mm / 800 pas = 0,00125 mm

1 mm / 80 pas = 0,0125 mm

Le troisième paramètre, c'est le groupe "$110", "$111" et "$112". C'est la vitesse de déplacement maximale pour chaque axe (X, Y et Z dans l'ordre).

Le quatrième paramètre, c'est le groupe "$120", "$121" et "$122". C'est l'accélération pour chaque axe (X, Y et Z dans l'ordre).

La vitesse s'exprime en mm/min, littéralement "combien de millimètres va parcourir la machine en 1 minute".

L'accélération s'exprime en mm/sec², en gros plus la valeur rentrée ici sera grande, plus l'accélération sera forte.

Ces deux valeurs vont beaucoup dépendre de votre machine, son poids, sa taille et le type d'usinage que vous allez effectuer (une gravure laser peut accepter des accélérations et une vitesse beaucoup plus grandes qu'une découpe de bois, par exemple).

Je ne peux donc pas vous donner les valeurs parfaites pour votre machine... Vous allez devoir faire des essais !

Je peux quand même vous donner un exemple pour avoir des paramètres de départ pour vos essais :

Sur ma machine qui est grande, lourde et qui découpe principalement du bois, j'ai 2000 mm/min en vitesse, et 200 mm/sec² en accélération :

$110=2000
$111=2000
$112=2000
$120=200
$121=200
$122=200

Et voilà, cet article touche à sa fin. Je ferai bientôt un nouvel article sur "comment faire pour générer un fichier d'usinage pour une CNC sous GRBL".

Dites-moi ce que vous avez pensé de cet article en commentaire et quel article vous aimeriez pour une prochaine fois !

A bientôt !