Translate

mercredi 12 février 2014

Commande de leds RVB en Bluetooth

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


int state;
int flag=0;
void setup() {
 
pinMode (ldr,OUTPUT);
pinMode (ldv,OUTPUT);
pinMode (ldb,OUTPUT);

Serial.begin(9600);
}

void loop() {


  if(Serial.available() > 0){
state = Serial.read();
flag=0;
  }

  if (state == 'a') {
  digitalWrite (ldr,HIGH);
  digitalWrite (ldv,HIGH);
  digitalWrite (ldb,HIGH);
 
  if(flag == 0){
Serial.println("Led Blanc");
flag=1;
}
}
else
 if (state == 'z') {
  digitalWrite (ldr,HIGH);
  digitalWrite (ldv,HIGH);
  digitalWrite (ldb,LOW);
 
  if(flag == 0){
Serial.println("Led Jaune");
flag=1;
}
}
else
 if (state == 'e') {
  digitalWrite (ldr,HIGH);
  digitalWrite (ldv,LOW);
  digitalWrite (ldb,HIGH);
 
  if(flag == 0){
Serial.println("Led Rose");
flag=1;
}
}
  else
   if (state == 'r') {
  digitalWrite (ldr,LOW);
  digitalWrite (ldv,HIGH);
  digitalWrite (ldb,HIGH);
 
  if(flag == 0){
Serial.println("Led Bleu clair");
flag=1;
}
}
else
 if (state == 't') {
  digitalWrite (ldr,LOW);
  digitalWrite (ldv,LOW);
  digitalWrite (ldb,HIGH);
 
  if(flag == 0){
Serial.println("Led Bleu");
flag=1;
}
}

else
 if (state == 'y') {
  digitalWrite (ldr,LOW);
  digitalWrite (ldv,HIGH);
  digitalWrite (ldb,LOW);
 
  if(flag == 0){
Serial.println("Led vert");
flag=1;
}
}
else
 if (state == 'u') {
  digitalWrite (ldr,HIGH);
  digitalWrite (ldv,LOW);
  digitalWrite (ldb,LOW);
 
  if(flag == 0){
Serial.println("Led Rouge");
flag=1;
}
}
else
 if (state == 'h') {
  digitalWrite (ldr,LOW);
  digitalWrite (ldv,LOW);
  digitalWrite (ldb,LOW);
 
  if(flag == 0){
Serial.println("Led : Arret");
flag=1;
}
}
else

 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.

samedi 8 février 2014

Temporisation LCD de 1s a 99mn 99s

Vous trouverez ici une temporisation LCD réglable par boutons.

Le schéma

Très simple comme la plus part des montages a base de arduino.
L'afficheur est un LCD 1x16 ligne.


Quoi de plus simple!!!! A la fin de la temporisation, le buzzer vibrera pendant 2 secondes.

Le code

/* Temporisation by Jojo Bricolo*/

#include <LiquidCrystal.h>

int Bpdepart = 7; //Bouton start
int Bpplus = 8; //Bouon +
int Bpmoins = 9; //Bouton -
int Relai = 10; //Base du transistor
int buzzer = 11; //buzzer

int upRead1 = 0; //variable Bouton +
int upRead2 = 0; //Variable vitesse bouton +
int downRead1 = 0; //variable Bouton -
int downRead2 = 0; //Variable vitesse bouton -
int startRead1 = 0; //variable Bouton start
int startRead2 = 0;

int timerCount = 0; //variable comptage
int minutesCount = 0; //variable minutes
int secondsCount = 0; //Variable secondes


LiquidCrystal lcd(5, 6, 4, 3, 2, 1); // E, RS, D4, D5, D6, D7


void setup() {
lcd.print("Tempo");
delay(1000);
lcd.clear();
lcd.print("Appui BP");
pinMode(Relai, OUTPUT);
pinMode(buzzer, OUTPUT);
pinMode(Bpdepart, INPUT);
pinMode(Bpplus, INPUT);
pinMode(Bpmoins, INPUT);
Serial.begin(9600); //open serial port
}


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");
}


void loop() {

  //Gestion des boutons
  upRead1 = digitalRead(Bpplus);
  downRead1 = digitalRead(Bpmoins);
  startRead1 = digitalRead(Bpdepart);

 
  delay(40);
  upRead2 = digitalRead(Bpplus);
  downRead2 = digitalRead(Bpmoins);
  startRead2 = digitalRead(Bpdepart);


  delay(100);

 
  if(upRead1==upRead2 && upRead1==HIGH)
  {
   lcd.clear();
   secondsCount = secondsCount+5; //Valeur d'incrémentation, ici de 5 en 5 secondes peut être modifié suivant les besoins
   if(secondsCount==60)
   {
    minutesCount++;
    secondsCount=0;
   }
   lcdWrite();
  }

 
    if(downRead1==downRead2 && downRead1==HIGH)
  {
   lcd.clear(); //clear lcd
   secondsCount = secondsCount-5; // Valeur d'incrémentation, ici de 5 en 5 secondes peut être modifié suivant les besoins
   if(minutesCount>0)
   {
    if(secondsCount==-5)
   {
    secondsCount=55;
    minutesCount--;
   }
   else
   {
    if(secondsCount<0)
   {
    secondsCount = 0;
    minutesCount = 0;
   }
   }
   }
   lcdWrite();

   if(secondsCount<0)
   {
     secondsCount=0;
     lcd.clear();
     lcd.print("0");
   }
  }

  if(startRead1==startRead2 && startRead1==HIGH)
  {

    timerCount = (minutesCount*60) + secondsCount;
    int timerCount2 = timerCount;
    Serial.println(timerCount);
    for(int i=timerCount;i>0;i--)
    {
       lcd.clear();

       if(timerCount2>60)
       {
         minutesCount = timerCount2/60;
         secondsCount = timerCount2%60;
       }
       else if(secondsCount==60)
       {
          secondsCount=59;
       }
       else
       {
        minutesCount = 0;
        secondsCount = timerCount2;
       }


   lcdWrite();

       digitalWrite(Relai, HIGH);
       delay(1000);
       timerCount2--;
    }

   lcd.clear();
   lcd.print("Fin");

     digitalWrite(Relai, LOW);

   //turn on piezo buzzer
   analogWrite(buzzer, 255);
   delay(3000);

     analogWrite(buzzer, 0);
   delay(2000);
   lcd.clear();
   lcd.print("Tempo");
   delay(3000);
   lcd.clear();
   lcd.print("BY JOJO"); // vous pouvez ici mettre votre nom

 
   timerCount = 0;
   minutesCount = 0;
   secondsCount = 0;
  }

}


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.

Thermostat multi sondes et multi sorties a affichage LCD

Version afficheur 128X64



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;

void setup(){
  sensors.setResolution(Probe01,10);
  sensors.setResolution(Probe02, 10);

  GLCD.Init(NON_INVERTED);  // initialisation de l'afficheur en fond clair pour un fond sombre, il suffit d'enlever le NON_
  GLCD.ClearScreen(); 
 

  pinMode (R1,OUTPUT);
  pinMode (R2,OUTPUT);
  pinMode (R3,OUTPUT);
}


void  loop(){  

  GLCD.SelectFont(SystemFont5x7);  
  GLCD.GotoXY(2, 2);
  GLCD.DrawRoundRect(0,0,127,63, 5, BLACK); 

  sensors.requestTemperatures();

  GLCD.GotoXY(22, 24);

  GLCD.SelectFont(Corsiva_12);
  GLCD.Puts("Temp 1 "); // texte affiché a modifier selon vos envies
  printTemperature(Probe01);

  GLCD.GotoXY(22, 36);
  GLCD.Puts("Temp 2 ");
  printTemperature(Probe02);
  delay(1000);
 }

void printTemperature(DeviceAddress deviceAddress)
{
  float tempC = sensors.getTempC(deviceAddress);

  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);
}

else
   {
    digitalWrite (R2,LOW);
  }

if ((temp3) >= consT3 + 1)
{
  digitalWrite (R3,HIGH);
}
else
   {
    digitalWrite (R3,LOW);
  }
}


Version 4x20 lignes


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.

Le code

#include <OneWire.h>
#include <DallasTemperature.h>
#include <Wire.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd (5,6,4,3,2,1);

#define ONE_WIRE_BUS 15

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

DeviceAddress Probe01 = { 0x28, 0x13, 0x2A, 0xA8, 0x04, 0x00, 0x00, 0x72 };
DeviceAddress Probe02 = { 0x28, 0x71, 0x17, 0xA8, 0x04, 0x00, 0x00, 0xB7 };
DeviceAddress Probe03 = { 0x28, 0x35, 0x98, 0xFC, 0x04, 0x00, 0x00, 0x6C };


void setup() {


sensors.begin();

  sensors.setResolution(Probe01, 10);
  sensors.setResolution(Probe02, 10);
  sensors.setResolution(Probe03, 10);


 lcd.begin (20,4);
 delay (10);
  lcd.clear ();
  delay (10);
  lcd.setCursor (3,1);
   lcd.print ("Fraiseuse CNC");
   lcd.setCursor (2,2);
   lcd.print ("BY JOJO BRICOLO");
   delay(4000);
   lcd.clear ();
  delay (10);

}

void loop() {
  //lcd.clear ();
  //delay (10);
  sensors.requestTemperatures();
 
 lcd.setCursor(0,3); //Start at character 0 on line 0
  lcd.print("X");
  displayTemperature(Probe01); 
 
  lcd.setCursor(7,3); //Start at character 0 on line 1
  lcd.print("Y");
  displayTemperature(Probe02); 
 
  lcd.setCursor(14,3); //Start at character 0 on line 2
  lcd.print("Z");
  displayTemperature(Probe03); 
 
   delay(1000);
 
}

void displayTemperature(DeviceAddress deviceAddress)
{

float tempC = sensors.getTempC(deviceAddress);

   if (tempC == -127.00) // Measurement failed or no device found
   {
    lcd.print("Erreur");
   }
   else
   {
   //lcd.print("C=");
   lcd.print(tempC);
  
   }
}

Le sketch pour trouver l'adresse des DS 18B20


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.

vendredi 27 décembre 2013

CNC Laser suite

Nouvelle page pour la partie électronique, ce sera plus simple.

Je rappel que ceux qui souhaitent avoir les divers programmes soit Gcode pour la mécanique ou programme arduino peuvent me les demander en me laissant un message.


Petit Rappel très important:

N'oubliez pas que le laser est dangereux, ce n'est pas un jouet comme ceux qu'on trouve dans la guerre des étoiles lol.


C'est même marqué dessus alors n'oubliez pas vos lunettes (celles de protection, pas celles de vue) adaptées a la longueur d'onde de votre laser

Bon ça va!!! je suis pas rasé et tout et tout mais ....... je porte les lunettes de protection!!!!!

Le driver et son paramétrage


Comme je vous l'avait dit, j'ai récupéré une carte chinoise qui beugait, elle sautais des pas en Z. Comme je n'utilise pas l' axe Z en automatique cela ne me dérange pas.

Pour les raccordement, il suffit de se fier a la doc fournie par le vendeur.

Le paramétrage des entrées sortie a  déjà été traité, je vais donc vous parler des paramètres de vitesse.
Pour commencer, il faut déjà prendre en compte  le nombre de pas moteur, en général 200 pas. Le rapport d'avance de la vis par tour exemple, une vis standard de 8 avance de 1.25 mm par tour.
Pour certains drivers notamment celui que j'utilise il suffit de multiplier le nombre de pas par l'avance de la vis.

Soit dans mon cas pour une vis hélicoïdale de 8 ayant une évolution de 1.5mm par tour le calcul est:

200 / 1.5 = 133.3333

Le calcul finale est:
200 pas / 1.5 mm/tour x 2 = 266.6666 pas, on vas donc renseigner la case pas par mm et y mettre le résultat de calcul


sur cette photo, on a 320 qui correspond a une tige de 8 standard cette case est a renseigner pour chaque axe et a sauvegarder a chaque fois en cliquant sur " Enregistrer l'axe en cours"

Cette fenêtre étant ouverte, on peut paramétrer la vitesse de manière très simple.
Il suffit de faire monter le curseur a coté du graphique et d'appuyer sur lest flèches hautes et basses du clavier. Le moteur va tourner dans un sens puis dans l'autre faite cette manip jusqu’à ce que le moteur ne tourne plus correctement, cela veut dire que le vitesse demandée est trop rapide pour le moteur. Ne plus toucher au curseur, allez dans la case vitesse et réduisez de 100 la valeur affichée. Quand j'ai testé mes moteur, il grognaient a 900 mm/mn j'ai donc mis 800.

Voila pour les cartes chinoises qu'on trouve sur Ebay.

Les autres cartes type M542 qui je précise sont milles fois plus fiable, j'ai remplacé la carte citée ci dessus par des M542, c'est le jour et la nuit.

La voici en image
dans ce cas, c'est un driver par moteur et une carte de commande

si je peux donner mon avis, c'est cette option qu'il faudrait prendre même si c'est plus cher.

Pour paramétrer cette carte, la formule est différente, on divise la valeur des micros pas programmé sur le driver (micro switch) par le rapport de la vis

Exemple:
Les switch sont sur 16 micro pas soit 3200 pas /révolution de la vis.

La formule est donc

3200/ 1.25 (pour une vis de 8 standard) = 2560

C'est cette valeur qu'il faut mettre dans la case pas ""par mm"" au lieu des 320 vus sur la photo ci dessus.
 


lundi 2 décembre 2013

CNC Laser




Je vous présente ma dernière réalisation en cours. Rien a voir avec Arduino malgré que je souhaitait piloter l'ensemble avec une UNO.

Après avoir fabriqué une fraiseuse CNC, j'ai voulu y adapter un Laser pour réaliser de la découpe plus fine en complément de la broche. A force de chercher, j'ai décider de fabriquer une machine complète.

L'ensemble est réalisé en plexi de 10mm

Avant toute chose, le laser est très dangereux pour les yeux, même un rayon indirect peu faire de gros dégats, il est obligatoire de se protéger avec des lunettes spécifique. Il faut bien choisir ses lunette car elles ne sont pas universelles, il y a plusieurs sortes adaptées a chaque longueur d'onde du laser. Un laser est également dangereux pour la peau, il peut créer des brûlures profondes, en faisant mes tests, je me suis brulé simplement en passant rapidement la main par inadvertance devant le rayon.
2watts c'est peu mais en Laser, ça commence a causer!!!!



Ceux qui souhaitent les  Gcodes ou le programme Arduino peuvent me laisser un message et je leur enverrai le tout.

Dimension de gravure format A4

En images

 Le protique déjà monté découpé a la fraiseuse CNC







 Tout a été réalisé a la fraiseuse y compris les paliers


Ci dessus la plaque servant a supporter les rails et le Laser

Face avant et arrière avec un palier en place

Les coté en cours d'usinage



La partie support est assemblée, il reste la gestion des axes et le laser a installer.

Pour le fraisage des divers éléments, j'ai utilisé:

- Draftsight pour la partie dessins a l'échelle - téléchargement:
http://www.3ds.com/fr/produits-et-services/draftsight/
- CAMBAM pour la génération des Gcodes  - téléchargement: http://www.cambam.info/downloads/
- Mach3 pour la gestion de la graveuse - téléchargement: http://www.mach3fr.com/V2/mach3/



Les moteurs


Nous allons passer a la partie translation.
N'ayant besoin que d'une faible puissance, je suis parti sur la base de deux moteurs pas a pas NEMA 17 (l'axe Y sera quand même assez lourd si motorisation).




Ici nous n'avons besoin de motoriser que deux axes X et Y, le Z se fera en manuel bien que cela ne s'avère pas nécessaire si on utilise un driver laser analogique. J'aborderai ce sujet plus tard dans la mise en œuvre du laser.

Le driver

Le driver avait été acheté pour ma fraiseuse a broche, cette carte a des soucis de fabrication, elle a tendance a perdre des pas en Z. Etant donné que nous n'avons pas besoin de l'axe Z ça tombe très bien !!!






J'alimente celle-ci en 24V malgré que la doc technique du driver donne 12V pour les NEMA 17, ça ne pose aucun soucis puisque les moteurs pas a pas sont commandés en courant. Cette tension plus élevée permet de ne pas perdre de couple a haute vitesse.

Pour ceux qui se posent la question, il n'existe pas de drivers en USB, il est nécessaire de posséder un ancien PC avec un port parallèle. J'ai essayé de faire fonctionner le driver avec un portable, ça ne fonctionne pas car l'alimentation n'est pas assez puissante.

Configuration des moteurs

J'utilise mach3 pour la gestion de ma fraiseuse donc je vais faire pareil pour le laser. Vous pouvez le télecharger en version gratuite  limitée a 500 lignes.

Téléchargement de mach3

Ouvrez mach3

Configuration des ES


 Onglet sortie moteur, configurez les sorties suivant les données de votre driver
Onglets sorties

Configurez les sortie de validation toujours suivant votre driver.





Allez dans l'onglet configuration des moteurs


Cette fenêtre s'ouvre

Là il suffit de donner les valeurs suivantes :
-Nombre de pas par tour
-Vitesse d'avance max
-Accélération

Attention, il faut valider chaque axe indépendamment.

Configuration de mach 3 pour la gravure laser.



Ouvrez mach3
Allez dans l'onglet configuration puis configuration générale


 Dans cette page, il faut cocher axe Z sortie 6 pour la valider

Cliquer OK

Puis onglet général, configuration des E/S


  Onglet gestion de la broche, cocher la fonction laser

Ne pas fermer la fenêtre !!!!!!!!

Maintenant il faut paramétrer la sortie de commande pour le laser, pour ma part ayant une commande TTL, j'ai validé la sortie relai qui est la broche 9

Dans la même fenêtre onglet configuration des sorties, validez la sortie 6 et affectez lui la broche voulue, ici la 9.


Cliquez sur OK et voila, la commande laser est validée. Elle fonctionne de la manière suivante, dès que Z descend sous zéro le laser s'allume dès qu'elle passe au dessus de zéro il s'éteint.


Le principe de câblage


Concernant la carte driver, rien de compliqué, il suffit de câbler selon la doc du fabriquant.


Le principe est simple, J'ai mis les 3 limites X,Y et Z, sur la 4éme entrée j'y ai mis l'arrêt d'urgence manuel et celui géré par le module Arduino. Ceci n'est pas figé, c'est une esquisse qui donne une idée du câblage. Le schéma est assez complet, les MZ (moteurs Z ne sont pas utilisés dans mon cas).

Que fait Arduino??

  1.  Il gère la température du module Peltier
  2. Il gère la température de Laser
  3. Il gère le courant du Laser par le biais soit d'une sortie ANA qui attaquera le driver, soit une sortie directe en PWM a voir car encore en cours d'étude. Passer par Arduino pour le courant de la diode a l'avantage de donner des limites et éventuellement de pouvoir donner des consignes de puissance suivant les matériaux a usiner. Certains diront que la diode peut être pilotée en linéaire par le driver Oui!! mais celui-ci ne surveille pas les limites et comme les drivers sont presque universels soit pour des courants allant de 0A a quelques ampères, on a vite fait de griller la diode avec une fausse manipulation
  4. Il affiche les températures
  5. Il affiche le courant du Laser
  6. Je vais peut être gérer les limites et les afficher afin de savoir laquelle a beugué car avec mach3 on ne sait pas quelle limite a décroché. Il ne fait pas de distinction, pour lui c'est un AU.

Le matériel utilisé pour la partie contrôle avec Arduino.

  1.  1 carte SEEDUINO MEGA (j'ai opté pour celle-ci parce que c'est une MEGA qui a la taille d'une UNO!!!)
  2. 1 afficheur 128x64 (j'ai pris un module avec rétro éclairage RVB
  3. 2 Sondes DS18B20
  4. potentiomètre 10K ohms
  5. 3 Relais 5V a définir une fois terminé
La câblage en vrac pour les essais

  

L' affichage de la consigne de courant dans la diode, du courant consommé , de la température du Laser et de la température du module peltier (coté dissipateur).


 Concernant la consigne, une valeur maximum est a configurer a la programmation cette valeur sera donnée en fonction de la diode.

J'ai généré une alarme température


En mode alarme, l'afficheur clignote en rouge et dans le cas d'une alarme température comme ici (consigne a 30°) un thermomètre s'affiche. A la disparition de l'alarme l'écran redeviens normal mais le thermomètre reste affiché jusqu’à ce que le défaut soit acquitté manuellement. Pour un défaut de courant ce sera un ampèremètre et pour un défaut de translation ???? a voir .

J'oubliais, une alarme génère un arrêt d'urgence afin de pouvoir redémarrer la gravure là ou le programme c'est arrêté.

Encore un peu de mécanique

Avant de passer au laser, il me restait un peu de mécanique a faire, voici quelques images

Réalisation des ecrous d'entraînement avec des prolongateurs de tige filetée et des petit fer plat perforés








Détails sur le refroidissement du laser, entre celui-ci et le dissipateur, on retrouve le module peltier.
Il manque encore un ventilateur au dessus du dissipateur, il est commandé et je ne l'ai pas encore eu, il sera assez puissant pour refroidir le peltier et souffler sur les fumées afin de ne pas abîmer la lentille du Laser.

La fixation est provisoire juste pour faire des essais


Essai en vidéo



Une deuxième vidéo, il me reste un petit réglage a faire dans mach3 car on voit un point a l'endroit ou le laser démarre et s'arrête. Il faut que celui-ci s'allume et s'arrête tout de suite alors qu'il reste allumé une seconde au même endroit.




A suivre ....... !!!

Une petite suite.


Après ces fêtes de Noël, je m'y suis remis, avant tout j'ai trouvé la solution au problème cité ci dessus c'est une mauvaise programmation dans le Gcode, je n'ai pas donné les bonnes infos concernant l'axe Z.

J'ai acheté un vieux PC sur EB pour 28€, que j'ai démonté pour récupérer la carte mère, l'alim et le disque dur.
J'ai réalisé une boite aux dimensions adaptée a la partie mécanique.


J'ai réussi a tout mettre dans un coffret de 480 x 290 x 90, on y trouve même le driver et l'arduino.
 N'ayant pas assez de place en hauteur pour refroidir le processeur,  j'ai fabriqué  un caisson avec une turbine de manière a refouler l'air chaud sur le coté.


L' arrière


Toute les plaque ont encore une fois été découpées avec ma fraiseuse a broche.

Vue d'ensemble


Allumé





J'éspère que vous avez remarqué les lunettes de protections (lunettes vertes), je rappel que c'est super important et obligatoire!!!!

Détails de la face avant



La partie mécanique terminée, je vais pouvoir parler de la technique dans une autre page.

Petite nouveauté!!!

Suite a une demande, j'ai fabriqué la partie mécanique de cette machine en kit. Si cela vous intéresse, n'hésitez pas a me contacter.