Je vous propose de vous donner quelques tuyaux pour la réalisation d'une CNC avec Arduino et GRBL. J'ai déjà réalisé ma CNC, mon graveur laser et mon imprimante 3D e vous mettrait donc quelques photos.
La mécanique
Concernant la partie mécanique, je pense que vous avez tous votre idée et surement un budget.
Voici des idées de montage
Ma première CNC bois, alu et tôle
(ne faites pas attention au bordel lol)
Pour la réalisation de celle-ci, j'ai utilisé des coulisses de tiroirs supportant 35Kgrs, des tiges filetées standard de 8, des moteurs NEMA 23 basiques et des 2M542 et drivers. La broche est une KRESS FME1, malgré une ossature et des guides pas vraiment prévus pour ce genre d'utilisation, j'ai fait des tas de choses comme la structure de mon laser en plexy.
Quelques réalisations avec cette machine
Voici quelques détails mécaniques de ma dernière fraiseuse CNC
Désolé pour les clopes lol !!!
J'éspère que cela va vous donner des idées !!!
L'électronique
Le choix concernant cette partie est assez délicat car les drivers doivent supporter la puissance des moteurs, certains drivers ont tendance a sauter des pas lorsque la machine force un peu.
Voici le modèles les plus répandus pour arduino
Très connu, il est constitué d'un circuit ULN2003 qui ne sert qu'a permettre a Arduino de piloter des sorties jusqu'a 500mA.
Le code permute les deux enroulement l'un après l'autre a une certaine fréquence. On peut réaliser des choses sympa mais ne conviens pas pour une CNC.
Celui-ci est semblable a celui-ci dessus mais plus puissant donc idem pas top pour une CNC a moins de lui adjoindre un deuxième module.
Easy driver est déjà un bon départ pour des petits moteurs jusqu'a 0.7A. Il est composé d'un circuit de puissance et permet de gérer les moteurs pas a pas avec simplement deux fils DIR et STEPS
Le dernier né qu'on retrouve actuellement un peu partout et surtout sur les imprimantes 3D. Il existe également avec un petit dissipateur de température. Malgré sa petite taille, il permet de piloter des moteurs jusqu’à 2A.
Pour ce dernier driver, il existe des cartes qui sont en fait des supports et adaptation pour carte Arduino MEGA, celle-ci évite simplement le câblage a réaliser entre les drivers et l'Arduino. Sur la photo on voit les drivers enfichés dessus et la MEGA en-dessous.
Un exemple de câblage de moteur avec easydriver
Nous verrons un peu plus tard les programmes de pilotage des moteurs pas a pas avec Arduino.
Allons directement a la partie la plus intéressante de ce sujet.
Le schéma de câblage
Ici, nous ne sommes pas dans le cas d'une imprimante 3D qui gère les différents élements chauffants ainsi que le moteur de l'extrudeur. Une carte UNO suffit donc amplement. pour la gestion de moteurs et fins de courses.
J'utilise des drivers A4988 avec des moteurs NEMA 17. Comme vous pouvez le constater, il n'y a pas beaucoup de câblage a réaliser. J'ai réalisé un petit circuit imprimé du style shield qui va s'enficher directement sur la carte UNO.
Le typon
Un petit double face et le tour est joué.
Programme
Test de GRBL
Dans la vidéo ci-dessous, vous pouvez voir le fonctionnement ( ce montage a été réalisé pour un laser donc pas de Z), la led représente le fonctionnement du laser.
Des tas de questions et problèmes !!
1) Le meilleur compromis pour le pilotage de la CNC avec GRBL est GRBLcontroler, je l'utilise depuis quelques années maintenant et je n'ai jamais eu de problèmes. La version la mieux aboutie est la 3.6.1
2) Pour configurer la machine, ne pas passer par le mode configuration de GRBLcontroler car souvent les paramètre ne sont pas envoyés dans la mémoire flash de l'arduino. Préférer d'envoyer les paramètres un par un en ligne de commande.
Je vous propose aujourd'hui la fabrication d'un texte défilant avec des matrices a leds et des circuits MAX7219.
Le schéma
Je pourrais vous proposer de créer un circuit imprimé mais il existe des modules tout prêts intégrant le circuit MAX7219, l'afficheur et la connectique permettant leurs mise en série et ça ne coute que quelques euros.
Attention, sur la matrice que j'utilise, il n'y a que 5 broches donc commencez le câblage depuis la droite comme sur mon schéma. Le connecteur du bas est celui qui se trouve sous le circuit intégré.
Je me suis limité a deux afficheurs, mais rien n'empêche d'en mettre plusieurs, il faut simplement les déclarer dans le programme.
Le programme
Je vous met ici deux programmes, dans le premier le texte enregistrées dans le module Arduino et le second programme permettra d'envoyer des messages via le moniteur série de Arduino.
int maxInUse = 2; //A modifier pour changer le nombre d'afficheur, ici on en a deux
MaxMatrix m(data, load, clock, maxInUse);
byte buffer[10];
// Les lignes de texte vous pouvez en rajoutez mais attention a la limite de la mémoire
char string1[] = " Jojo Bricolo ... ";
char string2[] = " Vous souhaite la bienvenue ";
char string3[] = " sur arduino-creations-blogspot.fr ";
void setup(){
m.init(); // initialisation du MAX7219
m.setIntensity(10); // Règlage de l'intensité lumineuse de 0 a 15
Serial.begin(9600); // initialisation du prot série
}
void loop(){
printStringWithShift(string1, 100); // 100 = vitesse de défilement soit 100ms
printStringWithShift(string2, 100);
printStringWithShift(string3, 100);
}
void printCharWithShift(char c, int shift_speed){
if (c < 32) return;
c -= 32;
memcpy_P(buffer, CH + 7*c, 7);
m.writeSprite(32, 0, buffer);
m.setColumn(32 + buffer[0], 0);
Je propose des montages avec des afficheurs LCD ou autre, voici une petite explication concernant leur mise en œuvre. Avec les librairies qu'on peut télécharger, c'est très simple, mais il faut parfois en modifier suivant l'afficheur et le brochage.
Afficheur LCD standard
On trouve dans le commerce pour quelques euros des afficheur de 1 a 4 lignes et de 4 a 20 caractères par lignes.
Lorsqu'on utilise un simple afficheur, pas besoin de télécharger la librairie "LiquidCrystal", elle est déjà incluse dans l'IDE Arduino.
Le programme comportant un afficheur doit commencer par ces lignes.
#include <LiquidCrystal.h> // librairie pour l'afficheur LCD
LiquidCrystal lcd( 7, 8, 9, 10, 11, 12); // définition des broches RS/E/D4/D5/D6/D7, elles seront toujours dans cet ordre coté afficheur, il faut vérifier le doc du constructeur mais en général c'est identique a l'image ci-dessous
Vous constaterez que lors de la définition des broches, on utilise pas toutes les bornes de l'afficheur, celles-ci seront mise a la masse.
Après les déclaration, on configure l'afficheur
void setup() { lcd.begin(20,4); // initialisation de l'afficheur type soit ici 20 caractères et 4 lignes delay(10); // délai 10 ms pour l'initialisation lcd.clear(); // rafraichissement de l'afficheur delay(10); // délai de rafraichissement }
Viens ensuite l'affichage proprement dit
void loop(void) { lcd.setCursor(0,0); // on positionne le curseur caractère 0 ligne 0 cela aurait également put être 10,3 lcd.print ("Bonjour"); // le texte a afficher on appel l'afficheur "lcd" puis on lui demande d'écrire "print" soit afficheur.écris "Bonjour" }
Si vous écrivez ces quelques lignes de programme ( sans mes commentaires), votre afficheur vous dira bonjour.
void setup() { lcd.begin(16,2); // initialisation de l'afficheur type soit ici 16 caractères et 2 lignes delay(10); // délai 10 ms pour l'initialisation lcd.clear(); // rafraichissement de l'afficheur delay(10); // délai de rafraichissement } void loop() { lcd.setCursor(0,0); // on positionne le curseur caractère 0 ligne 0 lcd.print
("Bonjour"); lcd.setCursor(0,1); lcd.print("je m appel joel"); }
Affichage de l'appui sur un bouton poussoir
On garde le même schéma, on rajoute simplement un bouton poussoir
Vous noterez que le BP est raccordé a la masse et non a +, simplement parce que j'utilise la résistance interne de l'arduino.
Le sketch
#include <LiquidCrystal.h> LiquidCrystal lcd( 1, 2, 3, 4, 5, 6); // définition des broches RS/E/D4/D5/D6/D7 int BP = 7; // broche sur laquelle est raccordée le BP
void setup() { lcd.begin(16,2); // initialisation de l'afficheur type soit ici 16 caractères et 2 lignes delay(10); // délai 10 ms pour l'initialisation lcd.clear(); // rafraichissement de l'afficheur delay(10); // délai de rafraichissement pinMode(BP,INPUT_PULLUP); // déclaration du Bouton en entrée avec résistance interne }
void loop() { lcd.setCursor(0,0); // on positionne le curseur caractère 0 ligne 0 lcd.print
("Bonjour"); // on conserve la première ligne lcd.setCursor(0,1); if (digitalRead (BP) == HIGH) // si BP appuyé { lcd.print("Bouton appuye"); // texte affiché } else // ou si BP non appuyé { lcd.print("Bouton relache"); } }
A bientôt pour la suite affichage d'une valeur !!!
Petit montage permettant de faire varier la couleur d'une ou plusieurs leds RGB.
Ce programme a été réalisé a la suite d'une demande faite sur le blog,
j'ai mis deux versions, l'une ou l'on fait varier les couleur a l'aide d'un potentiomètre. Pour la seconde c'est une sonde de température qui fait varier les couleurs, étant donné que je ne fais pas de conversion tension / température, il suffit de remplacer le potentiomètre par la sonde.
Le schéma
Le schéma est très simple, il vous faut
- un potentiomètre 10 Kohms ou une TMP36
- 3 résistances 1 Kohms
- 3 transistors MOSFET canal N ( BUZ11 par exemple)
Variation avec un potentiomètre
Variation avec une sonde TMP36
Variation avec une TMP36 ou LM35 (c'est la même sonde, la seule chose qui change entre les deux est la précision)
On utilise ici 3 sorties PWM qui vont piloter les 3 transistors de puissance.
Le code
Le code est également très simple, on fait un découpage de la valeur de l'entrée analogique (0 à 1023)
puis une lui affecte une gamme de couleur.
/*
Variation RGB by Jojo Bricolo
Voici un lien vers un site qui donne la convertion des couleur en codes
http://www.proftnj.com/RGB3.htm exemple blanc // 255 (rouge),255 (bleu) ,255 (vert)
*/
// Définition des broches
int ledRouge = 10;
int ledVerte = 9;
int ledBleu = 11;
int TmpVal; // Mesure de tension du potentiomètre ou de la TMP36 (pas de conversion pour la sonde, la valeur se situe donc entre 0 et 1023 cela permet plus de possibilité )
// Teinte 1 >>>>>>>> Les teintes varient selon les leds
// Mélange rouge vert
if (TmpVal > 0 && TmpVal < 170) { // si la valeur de la TMP est supérieur a 0 et inférieur a 170
RougeVal = 255; // Rouge au max
//BleuVal = 0; // bleu a 0 avec possibilité d'en rajouter un peu valeur a donner entre 0 et 255.
analogWrite(ledRouge, RougeVal);
VertVal = map(TmpVal, 0, 170, 0, 255); // variation du vert par la fonction de conversion map on dit donc que 0 a 170 (maxi 1023) est égal a 0 a 255, 255 étant la puissance max de la couleur séléctionnée.
analogWrite(ledVerte, VertVal);
//analogWrite(ledBleu, BleuVal);
}
Je vous propose ici de piloter des leds RVB avec une tablette ou un téléphone sous Androïde via Bluetooth.
Nous avons vu précédemment un montage pilotant plusieurs leds, ici on va piloter une ou plusieurs leds RVB ou un bandeau de leds.
Le Schéma
Le schéma est assez simple, on utilise ici un ATM328 avec le bootloader UNO, un module bluetooth, quelques composants et 3 transistors MOSFET permettant de driver jusqu'a 4A sans chauffer.
Comme vous pouvez le voir sur le schéma, il nous faut deux alimentations 1x12V et 1x5V il suffit de mettre un régulateur 7805 sur l'alimentation 12V, je ne l'ai pas mis sur le schéma (peut être un peu de fainéantise lol).
Le circuit terminé.
Pour gagner de la place, celui-ci est en double face
Comme vous pouvez le voir sur la face 2, j'ai apporté quelques modifications de dernière minutes, a la base j'étais parti sur le pilotage via un ULN 2803 mais vu le courant que consomme un bandeau de leds, j'ai laissé cette solution de coté et opter pour des transistors MOSFET. J'ai malgré tout laissé le dessin du circuit intégré, cela permet d'utiliser l'une ou l'autre des solution suivant l’utilisation que l'on veut faire du montage.
En vidéo
Désolé, on ne voit pas bien les couleurs de la leds. Une petite précision concernant les leds, on a toujours tendance a prendre des leds haute luminosité c'est bien lorsqu'elle sont derrière un diffuseur sinon le mélange RVB ne se voit pas. L'idéal est de prendre des leds RVB diffusantes. Idem pour le bandeau de leds, attention il en existe deux sortes l'une ne permet pas le mélange des couleur (une couleur par led), la seconde est full color (les 3 couleurs sont dans la même led).
Le sketch
J'ai crée un programme permettant de piloter les leds par couleur
- Rouge
- Vert
- Bleu
- Jaune
- Blanc
- Blanc clair
- Rose
- Variation de couleur automatique
/*Commande de leds RVB en Bluetooth via Android
Mode de fonctionnement par couleurs
Rouge
Bleu
Jaune
Rose
Bleu clair
Blanc
Automatique
By Jojo Bricolo*/
int ldr = 9;
int ldv = 10;
int ldb = 11;
#define FADESPEED 10 // Vitesse de transition
if (state == 'i') {
Serial.println("Led Automatique");
int r, g, b;
for (r = 0; r < 256; r++) {
analogWrite(ldr, r);
delay(FADESPEED);
}
for (b = 255; b > 0; b--) {
analogWrite(ldb, b);
delay(FADESPEED);
}
for (g = 0; g < 256; g++) {
analogWrite(ldv, g);
delay(FADESPEED);
}
for (r = 255; r > 0; r--) {
analogWrite(ldr, r);
delay(FADESPEED);
}
for (b = 0; b < 256; b++) {
analogWrite(ldb, b);
delay(FADESPEED);
}
for (g = 255; g > 0; g--) {
analogWrite(ldv, g);
delay(FADESPEED);
}
if(flag == 0){
flag=1;
}
}
}
void setColor(int red, int green, int blue)
{
analogWrite(ldr, 255-red);
analogWrite(ldv, 255-green);
analogWrite(ldb, 255-blue);
}
J'ai utilisé les lettres "a-z-e-r-t-y-u-i" pour les diverse couleurs et "h" pour l'arrêt mais rien ne vous empêche de modifier ces lettres. Petit détail, dans le programme j'utilise la fonction "delay" pour le mode fondue de couleur, cela ralenti la fonction suivante demandée quand ce mode est en cours. Donc si le module en fondu, que vous appuyer sur une couleur fixe le programme attends la fin de la séquence avant de valider la commande demandée.
Si cela vous intéresse, je suis en mesure de vous faire un kit ou même vous réaliser ce montage !!! N'hésitez pas a me contacter.
void lcdWrite()
{
lcd.setCursor(0, 0);
lcd.print(minutesCount); //Affichage de la valeur des minutes
lcd.setCursor(3, 0);
lcd.print("min");
lcd.setCursor(0, 1);
lcd.print(secondsCount); //Affichage de la valeur des minutes
lcd.setCursor(3,1);
lcd.print("sec");
}
Aujourd’hui, je vous propose la réalisation d'un thermostat a affichage digital utilisant 1 a 10 sondes ds18B20. Cette réalisation servira pour la régulation des diverses température du graveur Laser. Rien n'interdit de l'utiliser pour la gestion du chauffage ou pour avoir plusieurs indications de température.
Le schéma est assez simple, j'utilise un afficheur 128x64 avec la librairie GLCD a télécharger ici
L'avantage de l'afficheur 128x64 est qu'on peut mettre des petits dessins, un fichier java permettant de générer un fichier .h a partir d'une image est joint dans la librairie, je vous montrerai un peu plus loin comment l'utiliser.
Le schéma
Le schéma est assez simple, afin de pouvoir câbler de cette manière, j'ai du modifier l'ordre des broches dans la librairie. Sinon le câblage est éparpillé sur la UNO. L'afficheur est piloté par un K01008 mais d'autres afficheurs peuvent être utilisés avec la même librairie.
Dans le schéma j'ai oublié de donner la valeur de la résistance se trouvant sur les sondes, il s'agit d'une 4K7.
Le code
#include <glcd.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS_PIN A5 // raccordement des sondes sur la broche A6
OneWire oneWire(ONE_WIRE_BUS_PIN);
DallasTemperature sensors(&oneWire);
DeviceAddress Probe01 = {
0x28, 0x7F, 0x47, 0xFC, 0x04, 0x00, 0x00, 0xE7 };
DeviceAddress Probe02 = {
0x28, 0x59, 0x92, 0xFC, 0x04, 0x00, 0x00, 0x6F };
DeviceAddress Probe03 = {
0x28, 0x59, 0x92, 0xFC, 0x04, 0x00, 0x00, 0x6F };
// Les adresses des sondes peuvent être trouvées grace a un petit programme arduino
#include "fonts/Arial14.h"
#include "fonts/SystemFont5x7.h"
#include "bitmaps/JhIcon.h"
#include "fonts/Arial_bold_14.h"
#include "fonts/Corsiva_12.h"
#include "fonts/Verdana_digits_24.h"
#include "fonts/fixednums7x15.h"
#include "fonts/fixednums8x16.h"
#include "fonts/fixednums15x31.h"
//#include "bitmaps/thermo.h" // image a remplacer, dans la librairie il y a un fichier java permettant de convertir de petites images.
#if DISPLAY_HEIGHT < 64
#error ks0108 example requires a display at least 64 pixels tall
#endif
#if DISPLAY_WIDTH < 128
#error ks0108 example requires a display at least 128 pixels wide
#endif
//unsigned long startMillis;
//unsigned int loops = 0;
//unsigned int iter = 0;
int R1 = A0; // relai 1
int R2 = A1;//relai 2
int R3 = A2; //relai 3
int value_T1 = 0;
int value_T2 = 0;
int value_T3 = 0;
int consT1 = 23; // consigne de température T1
int consT2 = 24;
int consT3 = 25;
if (tempC == -127.00)
{
GLCD.Puts("Erreur "); message d'erreur si une des sondes est déconnectée
}
else
{
GLCD.PrintNumber(tempC);
GLCD.Puts("C ");
}
//xxxxxxxxxxxxxxxxxx temperaturexxxxxxxxxxxxxxx
int temp1 = sensors.getTempC(Probe01); // déclaration des température associée a la sonde
int temp2 = sensors.getTempC(Probe02);
int temp3 = sensors.getTempC(Probe03);
{
digitalWrite (R2,HIGH);
}
if ((temp1) >= consT1 + 1)
// formule a adapter suivant les besoins, ici on dit : si la température de la sonde 1 est égale ou supérieur a la consigne consT1 + 1°, on commande le relais sinon on l'éteint
// cela veut dire que si on donne une consigne de 20°, a 21° le relai s'enclenche et a 19.9° il s'éteint
{
digitalWrite (R1,HIGH); // allumage relai 1
}
else
{
digitalWrite (R1,LOW);
}
if ((temp2) >= consT2 + 1)
{
digitalWrite (R2,HIGH);
}
Sur ce schéma, il y a un afficheur 2x16 lignes, cela conviens aussi il suffit de faire les bonnes déclarations dans le sketch. Le câblage entre le 2x16 et le 4x20 lignes est identique.
