fbpixel
Installer Arduino IDE sur Raspberry Pi

Installer Arduino IDE sur Raspberry Pi

Nous allons voir dans ce tutoriel comment installer le logiciel Arduino IDE et CLI sur Raspberry Pi et ainsi combiner les forces des deux systèmes.

Vérifier la configuration de votre système

Pour savoir quelle version de l’IDE télécharger et installer, vous devez connaitre les spécificités de votre système. Notamment l’architecture du noyau (Linux kernel). Il existe plusieurs commandes possibles.

uname -a #display os and kernel info
cat /proc/version 
architecturekernel
i386/i486/i586/i686/armv7l32 bit
x86_64(Intel)/aarch64(Arm)/armv864 bit
cat /proc/cpuinfo #cpu architecture

La commande la plus directe est de deamnder sur combien de bit est encodé une variable LONG

getconf LONG_BIT # result is 32 or 64

Installation d’Arduino IDE

Sur la page de téléchargement d’Arduino, sélectionnez la version correspondante à votre système et téléchargez-la.

Vous pouvez effectuer cette procédure en ligne de commande. en connaissant le nom du fichier arduino-1.8.19-linux<architecture>.tar.xz

pour mon système aarch64 :arduino-1.8.19-linuxaarch64.tar.xz

wget https://downloads.arduino.cc/arduino-1.8.19-linuxaarch64.tar.xz

Naviguez jusqu’à l’archive, puis décompressez le dossier.

tar -xvf arduino-1.8.19-linuxaarch64.tar.xz
rm arduino-1.8.19-linuxaarch64.tar.xz

Puis installer le logiciel

cd arduino-1.8.19
sudo ./install.sh

Problème de connexion au port série

Si vous avez un problème de connexion avec le port série de l’Arduino, il se peut que vous ayez une autorisation limitée.

Vérifier les droits d’accès au port série

ls -l /dev/ttyACM*

Output

crw-rw---- 1 root dialout 166, 0 févr. 15 12:47 /dev/ttyACM0

Voud devez alors accordez les droits en lecture et écriture

sudo chmod a+rw /dev/ttyACM0

Bonus: Installation de Arduino-CLI sur Raspberry Pi

Si votre système n’a pas accès à une interface graphique (headless, accès SSH), vous pouvez utiliser les lignes de commandes pour créer, compiler et téléverser vos scripts Arduino.

Un autre outil plus récent et plus puissant est Arduino-CLI que vous pouvez installer avec la commande

curl -fsSL https://raw.githubusercontent.com/arduino/arduino-cli/master/install.sh | sh
mv bin/* Arduino/
cd Arduino
chmod a+x arduino-cli
alias arduino-cli='sudo ./arduino-cli'

Mettre à jour la liste des cartes supportées

arduino-cli core update-index

Installer ensuite le gestionnaire de cartes

arduino-cli core install arduino:avr

Vérifiez les cartes connectées au Raspberry Pi et noter les noms FQBN

arduino-cli board list

Créer un nouveau sketch

arduino-cli sketch new mysketch

Modifier le sketch avec le code désiré

nano mysketch/mysketch.ino
void setup() {
        Serial.begin(9600);
        Serial.println("System ready");
        delay(1000);
}

void loop() {
        Serial.println("System running");
        delay(500);
}

Compiler le code en spécifiant le nom de la carte (retrouvez le nom sous la colonne FQBN avec

arduino-cli compile --fqbn arduino:avr:mega mysketch/

Téléverser le code dans une carte

arduino-cli upload -p /dev/ttyACM0 --fqbn arduino:avr:mega mysketch/

Installer de nouvelles librairies

arduino-cli lib install library_name

Pour ouvrir un moniteur série, vous pouvez utiliser Putty

sudo apt-get install putty putty-tools
sudo putty /dev/ttyACM0 -serial -sercfg 9600,8,n,1,N &

Rajouter des URLs de gestion de cartes ESP32 et ESP8266

Créez un fichier de configuration

arduino-cli config init

Modifiez le fichier pour rajouter les url des cartes

sudo nano /root/.arduino15/arduino-cli.yaml
board_manager:
    additional_urls: [
    "https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json",
    "https://arduino.esp8266.com/stable/package_esp8266com_index.json"
]

Ensuite mettez à jour le gestionnaire

arduino-cli core update-index
acros2@acros2-desktop:~/Arduino$ arduino-cli core update-index
Downloading index: package_index.tar.bz2 downloaded                                                                                           
Downloading index: package_esp32_index.json downloaded                                                                                        
Downloading index: package_esp8266com_index.json downloaded                                                                                   
Downloading index: package_index.tar.bz2 downloaded                                                                                           
Downloading index: package_esp32_index.json downloaded                                                                                        
Downloading index: package_esp8266com_index.json downloaded 

Installer le gestionnaire pour ESP32 et ESP8266

arduino-cli core install esp32:esp32
arduino-cli core install esp8266:esp8266

Pour connaitre le nom fqbn à utliser en fonction de la carte arduino-cli board listall esp32

arduino-cli compile --fqbn esp32:esp32:esp32 mysketch
arduino-cli upload -p /dev/ttyUSB0 --fqbn esp32:esp32:esp32 mysketch

Sources

Installation et câblage d’une carte Ramps 1.4 pour une MPCNC

Installation et câblage d’une carte Ramps 1.4 pour une MPCNC

Une MPCNC est l’acronyme de “Mostly Printed CNC”, ce qui signifie qu’elle est principalement construite à partir de pièces imprimées en 3D. Il s’agit d’une machine CNC (Computer Numerical Control) qui permet de réaliser des opérations d’usinage, de gravure, de découpe ou de fraisage sur différents matériaux tels que le bois, le plastique ou l’aluminium. La MPCNC est conçue pour être abordable et facile à construire, grâce à son architecture modulaire et à l’utilisation de composants électroniques couramment disponibles. Elle est basée sur le principe de la fraiseuse à portique ou un Laser, où un chariot mobile se déplace le long de 3 axes (X et Y principalement, et Z pour régler la hauteur de l’outil légèrement ) tandis que l’outil effectue les opérations sur le matériau. La MPCNC peut être contrôlée par un logiciel de commande numérique, qui envoie des instructions précises aux moteurs pour déplacer les axes selon les coordonnées spécifiées.
Ici, nous nous appuyons sur la MPCNC de V1 Engineering, pour construire notre propre Graveuse et Découpe Lase. Nous aborderons essentiellement le câblage de la Machine, le guide technique pour imprimer et monter les pièces se trouvant sur le site de V1 Engineering.

La carte Ramps 1.4 est une carte d’extension électronique utilisée dans les imprimantes 3D et les machines CNC. Le terme “Ramps” est un acronyme pour “RepRap Arduino Mega Pololu Shield”. Elle est spécifiquement conçue pour fonctionner avec la plateforme Arduino Mega et offre une interface de contrôle pour les moteurs pas à pas, les capteurs, les fins de course, les ventilateurs, etc. La carte Ramps 1.4 est dotée de plusieurs emplacements pour les pilotes de moteurs pas à pas Pololu A4988 ou DRV8825, qui fournissent la puissance nécessaire pour contrôler les moteurs de la machine CNC ou de l’imprimante 3D. Elle intègre également des connecteurs pour les thermistances, les ventilateurs de refroidissement, les afficheurs LCD, les boutons de commande et d’autres périphériques. La carte Ramps 1.4 est compatible avec divers logiciels de contrôle, des firmware, tels que Marlin ou GRBL, qui permettent de gérer précisément les mouvements des moteurs et de superviser l’impression ou l’usinage en cours.

Matériel

  • Carte Ramps 1.4
  • Arduino Mega 2560
  • 5 Moteurs pas à pas : 17HS15-1504S-X1
  • 3 Pilotes de moteurs pas à pas : DRV8825
  • Alimentation Sortie 12V et 20A: S-250-12
  • 1 Laser 20W : LD4070HA
  • Des fils.

Montage Ramps 1.4 sur Arduino Mega

Après avoir monté la structure de votre MPCNC, il vous faut monter la partie électronique, et pour cela, on commence avec la Ramps 1.4. Comme décrit précédemment, c’est un Shield pour carte Arduino Mega, ce qui rend le montage assez simple. Il suffit d’empiler les broches et les pins des 2 cartes :

Ensuite on vient placer les jumpers pour les drivers. Il faut relier les pins qui se trouveront sous les drivers sur la carte tel que :

Ensuite, on passe aux pilotes des moteurs pas à pas qui permettent la communication entre les moteurs et la carte. Ils ont aussi une fonction très importante de limiter le courant dans les moteurs pour éviter les surchauffes. Il suffit de les enfoncer dans les pins juste des jumpers tel que :

Réglage du potentiomètre de chaque driver

Il est TRÈS important de faire cette étape correctement, si le courant est trop élevé, cela provoque une surchauffes moteurs qui finit par les abîmer sur des longues durées.
Commençons par calculer le courant maximum à laisser passer dans les moteurs. Pour cela il faut vous référer à l’équation qui limite le courant dans la datasheet de votre Pilote.
Ici, pour les DRV8825, on a l’équation suivantes : Limit Current = VREF x 2
VREF est la tension qu’on mesure aux bornes du pilote et qu’on règle avec le potentiomètre et Limite Current est le Courant/Phase consommé par votre moteur, valeur indiqué dans la datasheet de votre moteur pas à pas. Ici, pour les 17HS15-1504S-X1 on Courant/Phase = 1,5 A
Donc pour savoir la valeur de VREF, on a VREF = Limite Current / 2 = 1,5 / 2 = 0,75 V.
Cependant, ici, nos moteurs pas à pas ne portent pas de charges lourdes, qui nécessitent davantage de courant. 0,75 V étant le maximum, on peut réduire cette valeur pour limiter la surchauffe des moteurs, à 60%. Soit VREF(diminué) = 0,75 x 0,6 = 0,45 V.

Maintenant, après avoir branché votre carte à l’alimentation 12V ( pensez bien à régler la tension de sortie de l’alimentation avec un tournevis et en mesurant la tension aux bornes des sorties ), munissez vous d’un multimètre pour mesurer VREF aux bornes du pilote comme ceci :

Vous pouvez mesurer directement VREF entre la masse du pilote et sur le potentiomètre directement. Pour régler, il vous faudra un tournevis assez fin pour manipuler la vis du potentiomètre et changer la valeur VREF à la tension souhaitée, ici 0,45V.

Branchement des moteurs pas-à-pas

Une fois votre VREF réglé, vous pouvez brancher les moteurs pas-à-pas. On remarque alors ici sur notre machine, nous avons deux moteurs pas-à-pas pour chacun des axes X et Y, ce qui nécessite de les brancher en séries pour qu’ils puissent être contrôler par le même pilote. On peut aussi les brancher en parallèle mais nous vous déconseillons fortement car cela consommerait davantage de courant.

Vous pouvez remarquer que les moteurs pas-à-pas sont branchés en séries, ce qui implique de couper des câbles et de les resouder. Les couleurs représentés sur ce schéma sont celles des couleurs de câbles usuellement vendu avec des moteurs pas-à-pas. Faites bien attention à l’ordre des câbles lors des branchements. Aussi, on peut remarquer que l’axe Y le sur schéma n’as pas les couleurs de câbles dans le même ordre que les autres, mais un ordre inversé. C’est normal, vous pouvez inverser l’ordre des couleurs branchés sur la carte Ramps 1.4 pour inverser le sens de rotation des moteurs, pour qu’ils correspondent à votre installation. Il faudra faire des tests pour savoir s’ils tournent dans le bon sens.

Branchement du Laser

Ceci est une étape qui peut varier car il dépend de l’outil que vous brancherez sur votre MPCNC. Vous pouvez y brancher une fraiseuse par exemple.
Ici, nous prendrons comme exemple le branchement du Laser 20W LD4070HA. On l’alimentera en 12V par la pin D9 et on contrôlera la puissance du laser par la Pin Digital 11 en PWM.

Voilà maintenant le câblage électrique terminé ! Pour la partie software et firmware, vous pouvez suivre ce tutoriel.

Sources :

  • https://docs.v1e.com/electronics/ramps/
  • https://docs.v1e.com/mpcnc/intro/
  • https://docs.v1e.com/electronics/steppers/
  • https://forum.v1e.com/t/stepper-motor-voltage/18573
  • https://www.youtube.com/watch?v=89BHS9hfSUk
  • http://voidmicro.com/Products/Laser/LD4070HA-en.html?page=page_laser
Installer PlatformIO IDE sur Visual Studio Code

Installer PlatformIO IDE sur Visual Studio Code

Dans ce tutoriel nous allons configurer Visual Studio Code pour pouvoir lancer des scripts C/C++ avec PlatformIO IDE, qui est très utile pour programmer des microcontrôleurs tels que Arduino ou ESP32.

Matériel

  • Ordinateur
  • Carte Arduino UNO ou autre
  • Câble USB pour connecter la carte Arduino au PC

Installation de Visual Studio Code et de PlatformIO IDE

Suivez les étapes d’installation en téléchargeant .Net 6.0

Ouvrez ensuite Visual Studio Code.

Cherchez PlatformIO IDE dans l’onglet “Extensions” sur la colonne à gauche de Visual Studio Code et cliquez sur “installer”.

Une fois installé, fermez puis relancez Visual Studio Code pour que le logiciel soit bien paramétré avec PlatformIO IDE. Vous devriez alors arrivez sur la page d’accueil de l’IDE.

Démarrer votre premier Project en C avec PlatformIO IDE

Pour cela, cliquez sur ” + New Project ” et remplissez la fenêtre qui apparaît.

Ici, en terme d’exemple, j’ai choisi une carte Arduino Uno et le cadre sera aussi de type Arduino, c’est à dire que l’on va retrouver les fonctions setup() et loop() dans le fichier principal main. La création de projet peut prendre un peu de temps.

On peut remarquer à gauche dans l’espace de travail notre projet qu’on retrouve différent sous dossier. C’est le dossier ” src ” qu’on va retrouver les scriptes sources du projet, dont le fichier principal “main.cpp ” dans lequel on a va écrire notre scripte pour programmer notre carte Arduino Uno. Dans ce cadre préconstruit Arduino, on peut remarquer que dans l’entête dans du programme la ligne de commande ” #include “. Cette ligne de commande est très importante car elle permet à votre projet d’utiliser toutes les librairies et les fonctions principales que l’ont peut retrouver dans Arduino IDE.

Débuter avec un programme en C sur PlatformIO IDE

Pour tester votre premier projet en C sur PlatformIO IDE, vous allez téléverser un petit programme pour faire clignoter une LED sur la carte Arduino Uno et avoir un retour via liaison série sur l’état de la Led sur le terminal de Visual Studio Code.

// Ici dans l'entête du programme, on inclut les librairies et prototypes de fonctions nécessaires
#include <Arduino.h>

// Ici on met nos initialisations
void setup() 
{ 
    Serial.begin(9600); //ouverture pour communiquer via le port série
    pinMode(13, OUTPUT); //On initialise le pin 13 qui est associé à la LED en sortie pour pouvoir l'allumer et l'éteindre
} //Fin de la fonction setup()

// Ici dans la fonction loop on vient placer le script qui se répètera en boucle dans l'Arduino
void loop() 
{
  digitalWrite(13,HIGH); //Place le pin digital 13 à l'état HAUT (5V) -> Led allumée
  Serial.println("Led allumée");//Nous renvoie par la liaison série l'état de la Led Allumé
  delay(500); //Met en pause le programme pendant la valeur de 500 en ms

  digitalWrite(13,LOW); //Place le pin digital 13 à l'état BAS (0V) -> Led éteinte
   Serial.println("Led éteinte");//Nous renvoie par la liaison série l'état de la Led éteinte
  delay(500); //Met en pause le programme pendant la valeur de 500 en ms
} // Fin de la fonction

Une fois votre programme copier collé, vous pouvez le téléverser. Assurez vous que l’Arduino soit bien branché à un des ports USB de votre ordinateur.
Pour téléverser le programme, il existe des raccourcis qu’on peut activer en cliquant dessus tout en bas de Studio Visual Code :

  1. compiler le programme ;
  2. compiler, nettoyer et de téléverser le programme dans la carte Arduino ( la détection du PORT USB utilisé se fait automatiquement ) ;
  3. nettoyer le Terminal ainsi que la carte microcontrôleur branché ( de supprimer le script enregistré dessus ) ;
  4. tester le programme ;
  5. ouvrir un moniteur pour la Liaison Série et recevoir des envoies de la carte ( ou d’en envoyer ). Lorsque ce moniteur appelé “Serial Monitor” est ouvert, le téléversement d’un programme est impossible. Alors avant de téléverser un nouveau programme, il faut fermer le moniteur en cliquant une fois sur le terminal, puis en appuyant sur les touches Ctrl + C ;
  6. Permet d’ouvrir un Terminal.

Une fois que vous avez cliqué sur téléversement, vous devriez avoir un retour dans un terminal qui confirme que la compilation et le téléversement a été un succès qui ressemble à ceci :

Ensuite, cliquez sur la commande pour ouvrir un Moniteur et établir la liaison série.

Vous pouvez alors observer le retour de l’état de la Led en direct sur le moniteur.

Comment installer un librairie externe sur Visual Studio Code pour la PlatformIO IDE

Pour cela rien de plus. Télécharger d’abord votre librairie externe. Une fois que vous aurez un fichier .zipp, vous devez l’extraire ( ou copiez collez de dossier non compressé de la librairie ) dans ce dossier là ( ici la librairie qui nous servira d’exemple sera ServoLib, qui sert à faciliter la commande de servo-moteur ) :

On pourra retrouver l’accès ce dossier ” lib ” de votre projet fait pour accueillir les libraires externes via Visual Studio Code.

Une fois une librairie installé dans votre projet, vous devez l’inclure dans le programme dans l’entête tel que :

Voilà, maintenant vous avez toutes les bases pour débuter sur PlatformIO IDE pour programmer en C/C++ !

Utilisation d’un écran Nextion avec Arduino

Utilisation d’un écran Nextion avec Arduino

L’écran Nextion est une des meilleures solutions pour créer une interface graphique afin de piloter votre projet Arduino. L’interface la plus connue pour interagir avec un Arduino est l’écran LCD avec quelques boutons et potentiomètres au prix des entrées-sorties et d’une surcharge du code Arduino. Nous allons voir dans ce tutoriel comment configurer un écran Nextion et comment l’utiliser avec Arduino

Matériel

  • Arduino (ou autre carte avec port UART)
  • Écran Nextion
  • Adaptateur USB-TTL 5V
  • 4x Dupont wire avec connecteur JST

Présentation de la carte Nextion

L’interface de base pour piloter un Arduino, et présent dans tous les kits, est l’écran LCD avec quelques boutons et potentiomètres qui existe sous forme de Shield LCD. Il existe aussi des Shield muni d’écran tactile mais, ces derniers, utilisent toutes les entrées-sorties de l’Arduino et surcharge le code Arduino. Une solution à cela est d’utiliser un écran Nextion qui contient son propre programme et communique avec n’importe quelle microcontrôleur avec le port série.

N.B.: Il est possible de créer une interface graphique sur PC ou créer une interface web pour piloter le projet en ajoutant un module de communication sans fil.

Installation et présentation de l’éditeur Nextion

Téléchargez et installez l’éditeur Nextion

Lorsque vous ouvrez un nouveau projet ou fichier, le logiciel vous demande le modèle de l’écran (dans notre cas NX4832K035_011). Vous pouvez modifier la selection dans le menu Device>Settings

Puis choisissez l’orientation de l’écran et l’encodage.

Création d’une interface graphique

Nous allons utiliser l’éditeur graphique Nextion pour créer notre interface graphique. Dans cet exemple, nous allons ajouter:

  • Une image
  • Quelques textes pour le titre ou pour afficher des données
  • Un bouton qui modifie l’interface
  • Un bouton qui envoie une commande sur le port série
  • Un timer qui rafraichit l’interface
  • Une variable qui stocke une donnée reçue du port série

Pour ajouter un objet cliquez sur l’objet désiré dans la fenêtre Toolbox et l’objet sera inséré automatiquement dans la fenêtre Display. Vous pouvez ensuite configurer l’objet dans la fenêtre Attributes

Vous pouvez télécharger le fichier IHM à importer dans Nextion Editor. Avec cet exemple, vous serez en mesure de créer des interfaces bien plus complexes.

Ajouter une image

Pour ajouter une image, il faut d’abord importer une image dans le logiciel à l’aide de la touche (+) de la fenêtre “Picture”

Vous pouvez ensuite insérer un objet Picture dans la fenêtre Display puis sélectionnez l’image en appuyant sur l’attribut pic > browse…

N.B.: Ajouter une image aux dimensions désirées

Ajouter du texte

Avant de rajouter un objet text, il vous faut générer une police de caractère. Ceci peut se faire dans Tools> Generate Font

Une fois la police générée, vous pouvez la sélectionnez dans l’attribut font de l’objet Text. Vous pouvez ensuite modifier le texte dans l’attribut txt (Attention au nombre de caractère maximum txt_maxl).

Nous ajoutons quatre objets texte:

  • Le label titre
  • l’état de la LED
  • le label “Analog Val”
  • la valeur analogique reçue du micrcontrôleur

Ajouter un bouton

Une fois l’objet bouton ajouté à l’interface, vous pouvez régler dans les attributs:

  • le texte affiché
  • la couleur lorsque le bouton est pressé
  • la couleur lorsque la couleur est relâché

Dans la fenêtre Events, il est possible de programmer ce que l’écran va faire lorsque le bouton est pressé ou relâché. Il y a un certain nombre d’instructions que vous pouvez utiliser dans ces fenêtres. Notamment:

  • Modifier des éléments de l’interface (Ex: t0.txt=”Pressed”)
  • Envoyer l’identifiant du bouton via le port série
  • Envoyer une autre commande avec prints
  • Bouton b0
  • Bouton b1

Dans l’onglet Touch Release Event , nous écrivons la commande suivante qui est une commande prédéfinie de la librairie Nextion et correspondant à trigger1()

printh 23 02 54 01

  • Bouton b2

Pour le bouton b2, nous utilisons la même commande mais pour trigger2()

printh 23 02 54 02

Ajouter un timer

L’objet Timer permet d’exécuter un code régulièrement. Particulièrement utile pour récupérer des données provenant du port série et mettre à jour l’interface.

Dans l’onglet Timer event, nous utilisons la fonctions covx pour convertir la valeur de la variable en string et l’écrire dans le texte t4

covx analog0.val,t4.txt,0,0

Charger le programme sur l’écran Nextion

Brancher la carte Nextion au convertisseur USB-TTL

Pour charger l’interface, appuyez sur Compile puis Upload

Connexion de l’écran Nextion au microcontrôleur Arduino

Pour téléverser le code Arduino sur la carte, les pin RX et TX doivent être déconnectées de l’écran.

Utilisation de la librairie Nextion.h

Il existe différentes librairies que vous pouvez utiliser pour gérer un écran Nextion

Nous utilisons EasyNextion

Dans Nextion Editor, nous définissons un event release “printh 23 02 54 01” pour le bouton ON et un event release “printh 23 02 54 02” pour le bouton Off.

A l’aide de la fonction NextionListen(), ces commandes vont activer les fonctions trigger1 et trigger2.

#include "EasyNextionLibrary.h"

#define baudrate 9600

EasyNex myNex(Serial);

//Variables
uint16_t analog;
bool ledstate;

const int REFRESH_TIME = 100;
unsigned long refresh_timer = millis();

void setup() {
  myNex.begin(baudrate);

  pinMode(A0, INPUT);
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  myNex.NextionListen();

  if ((millis() - refresh_timer) > REFRESH_TIME) {
    analog = analogRead(A0);
    myNex.writeNum("analog0.val", analog);

    refresh_timer = millis();
  }
}

//`printh 23 02 54 XX` , where `XX` the id for the triggerXX() in HEX.
void trigger1() {
  digitalWrite(LED_BUILTIN, HIGH);
  myNex.writeStr("t2.txt", "LED ON");
}

void trigger2() {
  digitalWrite(LED_BUILTIN, LOW);
  myNex.writeStr("t2.txt", "LED OFF");
}

Résultats

Bonus: Nextion Editor Simulator

Nextion propose un simulateur permettant de tester les interactions entre l’écran et microcontrôleur et l’interface graphique. Ce simulateur est accessible en appuyant sur “Debug”

Sources

Contrôler une CNC avec laserGRBL et un shield CNC

Contrôler une CNC avec laserGRBL et un shield CNC

Nous allons voir dans ce tutoriel comment piloter une CNC à l’aide du logiciel laserGRBL, d’un Arduino et d’un shield CNC. Si vous avez un atelier ou souhaitez fabriquer des objets par vous-même, vous allez certainement vouloir fabriquer ou piloter(hacker) une fraiseuse numérique (ou CNC).

Nous avons vu dans un précédent tutoriel une description du Shield CNC, Nous allons voir comment l’utiliser pour piloter une fraiseuse numérique. Dans ce tutoriel, je ne développe pas la conception mécanique mais la partie électronique et logiciel.

Matériel

  • Machine CNC (Fraiseuse numérique ou graveuse laser)
  • CNC Shield
  • Arduino UNO ou compatible
  • Stepper driver DRV8825

Schéma de connexion

Le Shield CNC et le laser s’alimente en 12V. Nous utilisons un transistor pour régler la puissance du laser.

Repérez les axes X,Y et Z sur la machine et branchez les moteurs en conséquence sur la carte. Faites attention à l’ordre

Régler les pilotes de moteur pas-à-pas

  • Courant limite

Les moteurs pas-à-pas sont dimensionnés pour un certain niveau de courant. En fonction de la tension d’alimentation, il est possible de régler le courant limite délivré par le driver à l’aide d’un multimètre et du potentiomètre qui se trouve sur la carte. Pour cela, il faut mesurer la tension entre le potentiomètre et la masse.

Puis régler le potentiomètre en suivant la formule suivante Vref= max_current/2

Exemple: Pour 1.2A, la valeur mesurée au potentiomètre doit être de 0.6V

  • Résolution

Il peut être important aussi de régler la résolution du driver à l’aide des cavaliers pour améliorer la précision et réduire les bruits de vibration. Vous pouvez choisir entre différentes résolutions: jusqu’à 16 pour les A4988 et 32 pour les DRV8825.

M0M1M2DRV8825A4988
LowLowLowFull stepFull step
HighLowLow1/2 step1/2 step
LowHighLow1/4 step1/4 step
HighHighLow1/8 step1/8 step
LowLowHigh1/16 stepNC
HighLowHigh1/32 stepNC
LowHighHigh1/32 stepNC
HighHighHigh1/32 step1/16 step

Installer le firmware GRBL sur Arduino

Télécharger la librairie GRBL pour Arduino.. Dezippez le fichier, grbl-master.zip

Dans l’IDE Arduino, importez la libraire GRBL. Dans croquis>Inclure une bibliothèque> Ajouter la bibliothèque .ZIP, puis sélectionnez le dossier grbl-master/grbl

N.B: GRBL pour Arduino Mega

Pour flasher le firmware sur la carte Arduino, sélectionnez le Fichier>Exemples> grbl>grpblUpload et téléversez le code sur le microcontrôleur.

Installer LaserGRBL

Télécharger et installer LaserGRBL

Connectez-vous ensuite à l’Arduino pour pouvoir utiliser l’interface afin de tester et configurer votre CNC

Si vous le préférez, il est possible d’installer LaserGRBL sous Linux pour avoir une machine dédié à la graveuse

Configurer GRBL pour votre CNC

Une fois le shield CNC branché et le logiciel LaserGRBL installé, vous allez pouvoir configurer les paramètres de la machine.

Pour cela, un menu est disponible dans l’interface.

N.B.: Vous pouvez aussi retrouver ces paramètres dans le fichier config.h (C:\Users\ADMIN\Documents\Arduino\libraries\grbl\config.h)

Valeur de mm per step ($100,$101 et $102) est donnée par la formule suivante sur chaque axe

step/mm= (step/rev)/(mm/rev)*microstep

la conversion nombre de pas moteur vers mm va dépendre de l’architecture de la CNC

Deux exemples répandus sont:

  • la courroie poulie GT2 (mm/rev=pas courroie* nombre de dent=2*20=40)
  • la vis sans fin T8 (mm/rev=8)
Calcul du nombre de pas par mm ($100, $101 ou $102)







Il y a certains paramètres à prendre en compte si vous avez des fins de courses et si vous utilisez un laser.

Pour configurer un laser, vous devez modifier les paramètres suivants:

  • $30=255 max spindle speed (Laser PWM maximum value)
  • $32=0 min spindle speed (Laser PWM minimum value)
  • $32=1 Laser mode activated

Pour les vitesse et accélérations, il vous faudra expérimenter un peu pour trouver les paramètres qui correspondent à votre machine.

Ajustements mécaniques

Quelques ajustements doivent être effectués avant d’utiliser la machine correctement. Vérifiez bien les points suivants

  • Resserré les boulons et les courroies
  • régler le point zéro
  • régler le focus du laser
  • Vérifier les branchements

Résultats

Pour référence, voici les paramètres de laserGRBL pour une graveuse laser 240x340mm piloté par Shield CNC et un Arduino UNO

$0=10
$1=25
$2=0
$3=2
$4=0
$5=0
$6=0
$10=1
$11=0.010
$12=0.002
$13=0
$20=0
$21=1
$22=1
$23=3
$24=50.000
$25=1000.000
$26=250
$27=2.000
$30=255
$31=0
$32=1
$100=160.000
$101=160.000
$102=160.000
$110=8000.000
$111=8000.000
$112=8000.000
$120=500.000
$121=500.000
$122=500.000
$130=240.000
$131=340.000
$132=200.000

Et le résultat d’une gravure laser

Sources