Mot-clé - Planet-Libre

Fil des billets - Fil des commentaires

Mardi, juin 19 2012

L’impression 3D, c’est cool quand ça coule !

Ca y est !!!!

Elle marche !!!

 

Et oui, après pas mal de galères pour régler tout ça, l’imprimante marche. Il y a encore quelques ajustements à faire, mais rien de bien méchant. J’arrive à imprimer des couches de 0.15 mm ce qui me semble tout à fait convenable.

Depuis les derniers épisodes ( 1, 2, 3, 4 ) j’ai mis en place le support de la tête d’impression. Le support avait été modélisé à l’aide d’openscad puis les différentes parties découpées à la fraiseuse dans du PVC avant d’être assemblées par collage.

Hotend mount

Les deux roulements linéaires sont justes rentrés en force dans leurs logements. Il n’y a aucun jeu.

 

 

La suite concerne le moteur d’extrusion, c’est là que j’ai eu beaucoup de soucis. L’extrudeur est une pièce « temporaire » que je vais remplacer rapidement dès que je pourrais imprimer. De nombreux modèles existent, en particulier les modèles de type huxley ou les wades et leurs dérivés.

Dans l’immédiat je vais encore mettre à contributio openscad et la fraiseuse. J’ai à ma disposition, 2 engrenages et un moteur NEMA23.

Le modèle sera celui-ci:

 

OpenScad Model

 

Ce qui donne un truc monstrueux mais néanmoins fonctionnel

Extrudeur 1

 

Extrudeur 1

 

J’installe alors un tube en PTFE de 4mm de diamètre intérieur ( à trouver chez Weber métaux à Paris ) pour guider le filament entre l’extrudeur et la tête mobile. Tout marche à peu près, mais je galère avec l’entrainement du filament. Ca patine beaucoup, trop de pression sur le fil… bref pas terrible. Je le démonte et remonte plusieurs fois en changeant la pièce qui agrippe le filament: boulon taillé à la dremel, poulie crantée… tout y passe jusqu’au moment ou dans un nième démontage j’explose littéralement mon bel engrenage !

Quelle m… ne pouvant toujours pas imprimer, il faut trouver une autre solution. Je n’ai pas d’engrenage aussi gros… rien qui traîne :-(

Je tombe alors sur un moteur NEMA 17, sa poulie et une courroie de la bonne taille. J’assemble tout ça rapidement et reprend mes tests.

 

Extrudeur 2

Pour entraîner le filament,  j’ai opté pour un insert en laiton de 6 mm dans lequel j’ai taillé des dents à la dremel puis que j’ai collé avec de la cyano sur l’axe.

Ça marche enfin.

Les premières pièces peuvent sortir !

J’accumule les tests et les phases de calibrage en suivant ce qui est préconisé sur le site reprap et chez l’excellent richrap.

test 1

Pas terrible mais le carré est carré… un début.

 

S’ensuit de nombreux tests

encore des tests

 

Il y a même un « croco cochon » caché dans le tas de PLA !

 

De temps en temps, plus de plastique qui sort de la tête, galère… souvent au bout de 15 à 30 min d’impression… je démonte, remonte purge la tête… rien à faire jusqu’au moment ou je trouve un minuscule morceau de plastique ( probablement du PEHD ) qui s’est glissé dans la tête. Depuis que je l’ai viré, plus de soucis d’alimentation. Il faut dire que la tête de 0.35mm ne laisse que peu de marge pour laisser passer des cochonneries qui auraient pu se déposer sur le filamement…

Au bout d’un moment les bons réglages sont trouvés et des pièces fiables commencent à être produites…

Engrenage

 

puis d’autres…

 

Jeux d’engrenages

 

J’ai rencontré un problème qui n’est pas encore résolu: quand la tête « saute un vide », le PLA doit arrêter de couler pour éviter de laisser des filaments dans tous les sens. C’est pour cela que Slic3r que j’utilise prévoit un paramètre « retraction » qui permet de retirer le filament pour stopper son écoulement. Seulement quand je fais ça, c’est pire, je me retrouve avec des patés sur mes pièces.

patés

En réalité c’est du au « bowden tube » qui guide le filament, il y a 1mm de jeu qui absorbe et ralentit la rétractation du filament ce qui est contre productif et produit des patés. Pour le moment en attendant un tube de 3.19mm, j’ai désactivé le paramètre et le résultat est très correct.

 

Pour ce qui est de la vitesse d’impression, on peut surement mieux faire ( la mécanique de l’imprimante me permet de monter à 200 mm / s )

 

Slic3r

 

Mais je doit pour cela régler le problème de tube et améliorer le moteur de l’extrudeur. Le résultat est quand même à la hauteur de mes espérances, l’imprimante va pouvoir se mettre à jour dans les semaines qui viennent !

 

Voilà une vue d’ensemble de la bête :-)

La bête

Reste à ranger le câblage, mettre l’électronique dans une boite… encore du boulot…

 

La machine tourne avec le firmware Marlin 1.0 RC

Elle est pilotée par le couple Slic3r ( 0.8.4 dev ) et pronterface le tout sous Linux bien entendu. Encore une chaîne opensource, open hardware !

 

Openscad -> STL -> Slice3r -> Pronterface -> RAMPS 1.4

 

Pronterface

 

Possédant maintenant une imprimante 3D et une fraiseuse, je trouve l’impression 3D absolument fascinante. On dessine un object ou on le télécharge sur « Thingiverse« , on clique sur imprimer et au bout de quelques (longues) minutes, on manipule un objet tout neuf qui n’a pas grand chose à envier à une production industrielle !

L’impression 3D pour tous, le révolution de demain ? Surement… avec de nouveaux enjeux

Dimanche, mai 20 2012

L’impression 3D, la « tête » d’impression et Openscad: l’OpenSource à la rescousse

Le tendeur en S dont j’avais évoqué l’idée dans le post précédent est maintenant réalisé. Il fonctionne à merveille :-)

Les pièces du tendeur

 

Tendeur en place

 

J’ai eu ensuite quelques déboires avec les axes X et Y. J’ai finalement réglé mes problèmes en remplaçant tous les paliers par des roulements à billes. En effet, les paliers glissent très bien mais dès que les courroies sont sous tension, les déplacements sont plus durs et ça fini a un moment ou à un autre par coincer provoquant ainsi des mouvements saccadés…

J’ai donc usiné des nouveaux supports pour y insérer des roulements à billes de rollers à la place des paliers.

 

Roulements

Pour les chariots, j’ai remplacé le double palier par une douille à billes prisonnière à l’intérieur du chariot.

Douille à billes

Après ces quelques modifications, tout fonctionne parfaitement ! Pour les déplacements en Y, j’ai fait des premiers tests, j’arrive à une vitesse de 12 000 mm / min. Je ne pense pas pouvoir imprimer à cette vitesse, mais la machine supporte sans problème  une vitesse de déplacement élevée.

 

Reste à réaliser le support de la tête d’impression… Ce n’est pas une mince affaire, la pièce est relativement complexe, et j’ai du mal à la visualiser et surtout à en estimer les mesures exactes. J’arrive à mes limites ;-)

Heureusement, l’ordinateur est là pour nous aider à simuler différents modèles de support. L’idéal pour moi étant de réaliser un modèle 3D qui me servira ensuite à projeter à plat les pièces pour pouvoir ensuite les fraiser.

 

Le premier « truc » qui vous vient à l’idée: SolidWorks ! Oui et bien c’est « très » cher et je ne l’ai pas. Sketchup alors ? Non, il ne tourne pas sous linux ( même avec Wine je n’y arrive pas ). Alors comme toujours on va regarder du côté des solutions opensource. J’en connais 4 que j’utilise régulièrement:

  • LibreCAD: Excellent outil mais qui se limite à la 2D, nous l’utiliserons pour compléter les projections 2D des pièces.
  • HeeksCAD: Pour ce qui est de la conception 3D, il le permet mais j’ai du mal avec son ergonomie…
  • FreeCAD: Très bien, dessin 3D paramétrique, pas trop dur à prendre en main. Mais il a un gros soucis pour le moment. Autant il permet de créer des pièces facilement autant il est très difficile de les assembler dans un modèle 3D complet. A surveiller dans les futures versions, il évolue assez vite.
  • OpenSCAD: Un outil atypique ! Il permet de dessiner des pièces complexes en 3D paramétrique, mais ici, point d’interface graphique, le dessin se fait à l’aide d’un langage de programmation.

 

Espace de travail

 

Mon choix s’est donc porté sur Openscad. Il présente aussi l’avantage de générer des fichiers STL qui seront utiles lors de l’utilisation de l’imprimante 3D. D’où l’intérêt de commencer à le maîtriser dès maintenant.

 

Openscad dispose d’un éditeur intégré mais celui-ci est peu évolué. Si vous voulez plus de convivialité, vous pouvez utiliser un éditeur externe. Pour celà, il faut « cacher » l’éditeur intégré et cocher l’option « Automatic reload and compile »

Option

 

Options

 

Si vous utilisez emacs comme moi, vous pouvez lui dire de traiter les fichier « scad » comme des fichiers C. Ça permet d’avoir une bonne indentation et une coloration syntaxique correcte.

Pour cela, il faut mettre les lignes suivantes dans le fichier « .emacs »

(add-to-list 'auto-mode-alist '("\\.scad$" . c-mode))

 

L’environnement est prêt, on peut commencer à travailler. Pour commencer par des choses simples, modélisons  une douille à bille.

// Linear Ball Bearing
include 
 
$fn=50;
$lbb_inner_diameter=8;
$lbb_outer_diameter=15;
$lbb_length=24;
 
module linear_bearing_15_24()
{
  color(Aluminum) difference()
    {
      cylinder($lbb_length,$lbb_outer_diameter/2,$lbb_outer_diameter/2,center=true);
      cylinder($lbb_length+1,$lbb_inner_diameter/2,$lbb_inner_diameter/2,center=true);
    }
}
 
//For test
linear_bearing_15_24();

Linear ball bearing

C’est très simple, juste la différence entre 2 cylindres ! Là ou c’est génial: on ajuste les variables et hop on change les côtes.

 

Pour continuer, un peu plus compliqué: la tête chauffante. On va la modéliser rapidement pour qu’elle nous serve ensuite de repère pour la construction du support.

 

// HotEnd jhead MK IV
$fn=50;
 
$hotend_resistor_diameter=5;
$hotend_filament_diameter=3;
$hotend_outer_diameter=16;
$hotend_peek_length=50;
 
// Peek element
module peek() {
color(black) difference()
  {
    difference()
      {
	// Peek cylinder
	cylinder($hotend_peek_length,$hotend_outer_diameter/2,$hotend_outer_diameter/2);
	// Hole for filament
	translate([0,0,5]) cylinder($hotend_peek_length,$hotend_filament_diameter/2,$hotend_filament_diameter/2);
      }
 
    // Mount groove
    translate([0,0,$hotend_peek_length-10])
	{
	  difference()
	    {
	      cylinder(5,9,9);
	      cylinder(5,6,6);
	    }
	}
  }
 
}
 
module copper_end()
{
  translate([-5,-6.5,3])
    {
      difference()
	{
	  cube(size = [16,13,8]);
	  translate([12,15,4])
	    {
	      rotate([90,0,0])
		{
		  cylinder(20,$hotend_resistor_diameter/2,$hotend_resistor_diameter/2);
		}
	    }
	}
    }
  difference()
	{
	  cylinder(3,1,4.5);
	  cylinder(3,0.35,3);
	}
  translate([0,0,3])
    {
      difference()
	{
	  cylinder(20,4,4);
	  translate([0,0,1]) cylinder(21,3,3);
	}
    }
}
 
module hotend()
{
  translate([0,0,13])
    {
      peek();
    }
  copper_end();
}
 
// For test
hotend();

 

Hotend

 

Pas mal non ;-)

 

Et pour terminer le support. Grâce à openscad, on peut changer les côtes, déplacer les perçages… pour simuler tout ce qui nous passe par la tête !

Même si ça peut paraître compliqué au premier abord, c’est très agréable à utiliser. Je ne prétends pas maîtriser complètement l’outil, mais je me débrouille.

 

Autre point très intéressant, on peut utiliser des conditions et autres boucles. Ici j’utilise quelques variables qui si elles sont initialisées à 1 modifient le rendu pour me permettre d’obtenir rapidement les projections à plat.

 

// Hotend Mount
 
include ;
include ;
 
$top_length=50;
$top_width=50;
$side_height=50;
$hole_cable_diameter=15;
 
$fromA=0;
$fromB=0;
$fromtop=0;
 
module mount_top()
{
  difference()
    {
	cube(size = [$top_length,$top_width,15]);
	translate([15,15,-2]) cylinder(20,$hotend_outer_diameter/2,$hotend_outer_diameter/2);
    }
}
 
module mount_side_A()
{
  rotate([0,90,0])
    {
      difference()
	{
	  cube(size = [$side_height,$top_length+5,5]);
	  translate([25,40,0])
	    {
	      cylinder(15,$lbb_outer_diameter/2,$lbb_outer_diameter/2, center=true);  
 
	    }
	}
      if ($fromA==0)
	{
	  translate([25,40,5]) linear_bearing_15_24();
	}
    }
}
 
module mount_side_B()
{
  rotate([90,90,0])
    {
      difference()
	{
	  cube(size = [$side_height,$top_length,5]);
	  translate([40,35,0]) cylinder(15,$lbb_outer_diameter/2,$lbb_outer_diameter/2, center=true);
	  translate([30,15,1]) cylinder(10,$hole_cable_diameter/2,$hole_cable_diameter/2, center=true);        
 
	}
       if ($fromB==0)
	 {
      translate([40,35,0]) linear_bearing_15_24();
	 }
    }
}
 
module mount_complete()
{
  if ( $fromA==0 && $fromB==0 )
    {
      mount_top();
    }
 
  if ($fromtop==0 && $fromB==0)
    {
      translate([-5,-5,15]) mount_side_A();
    }
  if ($fromtop==0 && $fromA==0)
    {
      translate([0,0,15]) mount_side_B();
    }
  if ($fromtop==0 && $fromA==0 && $fromB==0)
    {
      color(black) translate([15,15,-48]) #hotend();
    }
}
 
module mount_full()
{
 
  if ($fromtop==0 && $fromA==0 && $fromB==0)
    {
      // rod A
      rotate([0,90,0]) translate([10,35,-50]) cylinder(300,4,4);
      // rod B
      rotate([90,90,0]) translate([25,35,-150]) cylinder(300,4,4);
    }
  //Holes for hotend groove
  difference()
    {
      mount_complete();
      translate([23,-10,7.5]) rotate([-90,0,0]) cylinder(40,2.5,2.5);
      translate([7,-10,7.5]) rotate([-90,0,0]) cylinder(40,2.5,2.5);
    }
}
 
if ( $fromtop==1 )
  {
    projection(cut=false) mount_full();
  }
 
if ( $fromA==1 )
  {
    projection(cut=false) rotate([0,90,0]) mount_full();
  }
 
if ( $fromB==1 )
  {
    projection(cut=false) rotate([90,0,0]) mount_full();
 
  }
if ( $fromtop==0 && $fromA==0 && $fromB==0 )
  {
    mount_full();
  }

 

Hotend mount

 

Si l’on utilise les variables indiquées en haut du fichier, on obtient les projections à plat des 3 faces qui m’intéressent.

Si: $fromA=1;

fromA

Si $fromB=1;

 

FromB

 

Si $fromTop=1;

 

FromTOP

 

Le tout peut être exporté en DXF pour être ensuite utilisé dans LibreCAD puis HeeksCNC pour le fraisage des pièces. Seul petit bémol, les cercles et arcs de cercles sont des successions de segment ce qui n’est pas optimal. On peut facilement les reprendre dans Librecad.

Les différents plans sont regroupés dans un Zip si vous voulez jouer avec openscad.

Si un expert openscad passe par là, il peut nous donner des astuces dans les commentaires, je suis preneur ;-)

La suite sur la fraiseuse…

Mercredi, février 29 2012

Tamponne moi un barbu

Un petit tutoriel vidéo mettant en scène pas mal de logiciels libres pour créer des tampons à l’aide d’une fraiseuse numérique.

 

Avant le tutoriel en vidéo, voici la liste des outils utilisés:

  • Inkscape: Logiciel de dessin vectoriel utilisé ici pour vectoriser un fichier PNG.
  • LibreCad: Logiciel de CAD qui sert juste pour éditer le fichier DXF sortant d’inkscape.
  • F-engrave: L’outil indispensable pour la gravure numérique.
  • EMC: Le logiciel de pilotage de la fraiseuse.

Ne pas oublier le logo de @lagrottedubarbu

 
Le tutoriel en vidéo:

Samedi, janvier 21 2012

Flux de création de fichiers GCODE avec des outils libres

Après le petit tutoriel de ce matin, voici un post qui résume le « flux de production » de mes fichiers GCODE.

  • La base

Tout commence par l’objet indipensable à la prise de mesure: le pied à coulisse.

  • Les matériaux

Une fois l’objet à créer correctement dimensionné, il faut trouver le matériau dans lequel on va le créer. J’utilise principalement des bois et plastiques, les métaux étant (à par pour de la gravure) trop difficiles à fraiser avec mon matériel (il manque un refroidissement liquide ou un moteur de broche avec une faible vitesse et un gros couple).

  • Pour le bois, je prends en général du MDF ou du contreplaqué qui peuvent faire entre 3 et 15 mm.
  • Pour le plastique j’utilise beaucoup le PVC qui a un bon rapport qualité / prix ainsi que du PEHD ( c’est ce qui est utilisé pour les plaques à découper dans votre cuisine ;-)   ou encore du DELRIN (qui est excellent mais cher)

Le choix du matériau est fait, maintenant les logiciels ! Ne soyez pas effrayés, il y en a un certain nombre mais chacun est très performant dans son domaine.

  • Les logiciels de CAO

Pour dessiner des pièces à usiner, celui que j’utilise le plus, c’est LibreCAD. C’est un fork libre du projet QCAD. Avec un peu d’habitude, vous dessinerez en quelques minutes des pièces relativement complexes en 2D. Vous pouvez commencer par regarder le tutoriel d’Andre PASCUAL, il parle de QCAD mais c’est la même chose, à part les icones qui changent, le principe est identique et le tutoriel est excellent.

 

Quand il s’agit de graver des dessins ou du texte, rien de vaut inkscape qui n’est plus à présenter. Il est préférable lorsque vous utilisez inkscape pour créer des fichiers DXF, nécessaires dans la suite du flux de production, d’enregistrer avec le greffon « Better DXF Output ». Pour certains dessins contenant des courbes de bezier ( splines ), je suis obligé d’ouvrir les DXF de LibreCAD avec Inkscape puis de les réenregistrer pour qu’il convertisse tout en polyline. Sinon, j’ai des plantages lors de la génération du GCODE avec HeeksCNC. Un bug qui sera surement corrigé par les développeurs, mais en attendant…

Dans un autre cadre très particulier, celui de la création de circuits imprimés, j’utilise KiCAD, un concurrent du très connu EagleCAD. Avec ce logiciel, je génère des fichiers GERBER qui seront ensuite convertis en GCODE.

  • Les logiciels de création du GCODE

Ici, seulement deux logiciels sont utilisés:

HeeksCAD / HeeksCNC vont permettre de transformer le fichier DXF 2D en un fichier permettant de piloter la machine CNC. On renseigne au logiciel le diamètre de l’outil, son positionnement par rapport à la pièce, la vitesse d’avance… Bien qu’assez jeune, ce logiciel donne de très bon résultats.

 

En dehors des DXF, il y a les fichiers GERBER de Kicad. Là j’utilise pcb2gcode qui est un logiciel en ligne de commande.

 

pcb2gcode --metric --zsafe 2 --zwork -0.06 --offset 0.2 --zchange 25 --mill-feed 100 --mill-speed 5000 --back $back
  •  Pilotage de la CNC

Ici, un seul choix et non des moindres: EMC (LinuxCNC). Il prend en entrée les fichiers gcode et pilote la machine au travers d’un support temps réel du noyau linux. Il est préférable d’ailleurs de lui dédier une ancienne machine.

Et voilà après 2 heures de travail une manette de coinceur pour un voilier. L’originale en rouge est fendue, la nouvelle en DELRIN est très solide :-) et identique à l’originale (les économies de plastique en moins), elle parait plus épaisse mais ce n’est qu’un effet d’optique sur la photo.

 

 

Diagramme du flux de production

 

Si vous connaissez, utilisez d’autres outils, mettez les en commentaire c’est toujours intéressant !

Lundi, décembre 21 2009

Librairie Arduino pour afficheur Oled : Oled4d

Voici une librairie libre de gestion d'afficheur OLED de la société 4D Systems pour Arduino.

Comme leur nom l'indique très bien, ils utilisent la technologie OLED avec tous les avantages de cette technologie : pas besoin d'un rétroéclairage, ils ont un angle de vue de 180°, bonne consommation, très bon contraste, vous pouvez les trouver entre autres chez Lextronic ou encore chez Sparkfun.

Le jeu d'instructions n'est pas toujours très logique mais est assez complet, le principal défaut de ces afficheurs est le prix, à 65€ l'unité, j'imagine mal comment espérer faire de la petite série...

Ces afficheurs sont pilotables directement par le biais d'une connection série dans lequel on envoie directement des commandes d'assez hauts niveaux :

  • Set Background Color
  • Put Pixel
  • Erase Screen
  • Draw Rectangle
  • Place String of ASCII Text
  • ...

Ils disposent également d'un port microSD permettant ainsi de charger des images ou encore des bouts de programmes, attention cependant, car n'espérez pas mettre des images jpg dans la microSD ou autre et les afficher comme ça, d'un coup, ça ne fonctionnera pas, tout d'abord, car le chip de 4D ne gère pas les images compressées mais uniquement des champs de bits et surtout car il n'y a aucune gestion de FAT gérée par le controleur, ainsi, il est possible d'accéder au contenu de la microSD depuis votre programme mais uniquement en brut : à nous de gérer la couche du système de fichiers...

Tester la libraire

Voici la marche à suivre pour tester cette librairie avec Arduino (la librairie peut parfaitement fonctionner hors du projet Arduino...) :

  1. Créer un dossier Oled4d dans le dossier Libraries de votre installation Arduino et copiez dedans le fichier Oled4d.h.
  2. Créez un nouveau projet Arduino et copiez le contenu du fichier oled4d.pde dedans.
  3. Compilez le source, envoyez dans la cible et voilà, vous devriez avoir quelque chose de ce genre s'afficher :

Oui, il s'agit bien de Tux ! ;)

Comment ça fonctionne ?

Voici un petit bout de code :

// Créer l'objet en interface série logiciel
Oled4dSoft oled = Oled4dSoft(serial, 8);

// Pour utiliser l'uart « hardware », procéder ainsi :
//Oled4dHard oled = Oled4dHard(Serial, OLED_RESET_PIN);

// Initialise l'écran
oled.init();

// Efface l'écran
oled.clear();

// Dessine un cercle
oled.drawCircle(64, 64, 20, RGB(255, 255, 0));

// Affiche du texte
oled.drawText(1, 3, SMALL, GREEN, "Hello world !");

Voilà, je pense que l'exemple est assez explicite et logique...

Vour remarquerez qu'il est possible de passer par l'uart intégré à l'Atmel ou de passer par l'uart logiciel avec la libraire NewSoftSerial (cette librairie dispose de fonctions avancées et est bien supérieure à la librairie d'uart fourni par défaut dans le projet Arduino).

Démo

Voici une petite démo affichant en vrac des lignes, des triangles, des cercles, des polygones, des rectangles...
La vidéo reflète assez mal les couleurs de l'écran qui sont bien vives en réel.

Écran Oled de 4D System piloté par Arduino

Futures évolutions

Actuellement, cette librairie supporte uniquement les instructions standards (General Command Set), les autres (Extended Command Set), qui permettent entre autre un accès au contenu de la microsd, ne sont pas encore gérées mais le plus gros du travail est fait...

Téléchargement

Cette librairie est mise à disposition sous license GPL.
Vous pouvez télécharger la toute dernière version de cette librairie depuis mon compte GitHub à l'adresse suivante : http://github.com/hugokernel/Oled4D

Je mettrai à jour également la page sur le wiki : http://www.digitalspirit.org/wiki/projets/oled4d.

Vendredi, décembre 4 2009

Planet Madeinfr : Regroupement d'articles francophones sur le « fait soit même »

Ouverture ce jour d'un planet (un regroupement d'article issus de différents blogs au sein d'un même blog), consacré au « fait soit même » (autrement appelé « Do It Yourself » outre atlantique) avec une forte attirance pour l'électronique, sa petite particularité est que tous les articles diffusés sont en français.

La publication sur le planet est ouverte à tout le monde, il suffit de posséder un blog et des articles en français sur le sujet, et de nous le signaler par le biais du formulaire approprié.

L'adresse de ce planet est : http://planet.madeinfr.org/

Il est aussi possible de suivre les articles et l'actualité de Made in Fr sur Twitter et Identi.ca :

 

Lundi, octobre 6 2008

Fraiseuse CNC sous Linux, « Do It Yourself »

Après quelques tests sur ma précédente fraiseuse, je me suis rendu compte que le manque de précision était fatal à ce genre de machine. Bien décidé à ne pas laisser tomber, j’ai décidé d’en reconstruire une nouvelle beaucoup plus précise.

Le cahier des charges est assez simple:

  • La machine doit rester bon marché
  • Il s’agit d’une petite fraiseuse de bureau et non d’un routeur de 2x3m
  • Elle devra fonctionner sous EMC2 (Linux Ubuntu 8.04)
  • Elle devra être suffisement précise pour réaliser des gravures de circuits imprimés.
  • La conception se fera au feeling, je suis incapable de concevoir une telle machine sur plans.

J’ai choisi des matériaux faciles à trouver, il s’agit de tube carré en aluminium vendu en barres de 1 mètre chez LeroyMerlin, de tige filetée de 6mm, de boulons de 6mm et de roulements à billes de roller et d’autres récupérés dans des imprimantes ainsi que du tube de 25mm en acier pour la potence de l’axe Z.

La motorisation est assurée par 3 moteurs pas à pas unipolaires 4.1V 1.1A acheté chez Technimaniacs, les prix sont très corrects et le service parfait :-) à recommander. Je n’ai pas réutilisé les anciens moteurs, ils nécessitaient d’être démultipliés ce qui me faisait perdre en précision, de plus, leur puissance était vraiment limite.

Pour ce qui est de l’électronique, il s’agit de la même carte que ma première fraiseuse, un kit de chez HobbyCnc. Elle a le mérite de bien fonctionner et d’être très bon marché par rapport à la concurrence. Le pilotage ce fait cette fois sous linux avec EMC2. Un excellent logiciel opensource de pilotage de fraiseuse.

La chaine logiciel (opensource)utilisée est la suivante:

  • Qcad pour le dessin des pièces. Les fichiers sont enregistrés en DXF

  • Gcnccam pour générer le GCODE

  • Ensuite c’est axis qui est utilisé comme interface à EMC2.

EMC2 est installé sur une ubuntu 8.04 avec un noyau temps réel RTLinux. C’est absolument nécessaire sur ce type de machine afin de garantir la précision du fraisage.

Pour la gravure de circuits imprimés, il y a Eagle et un script de génération du Gcode. Je ne suis pas certain que ce soit facilement faisable avec Kicad :-(

Voici quelques photos de la machine construite. Le seul gros problème rencontré: un axe des Z trop souple donc une machine très imprécise. Je l’ai donc entièrement refait en acier soudé au chalumeau. Il est maintenant très rigide. Pour le reste, c’est assez simple, un châssis rectangulaire en aluminium dans lequel vient coulisser le mobile de l’axe des Y. C’est sur ce mobile Y que vient glisser le plateau de fraisage. L’axe des Z qui porte la dremel est guidé par des rails en alu. Des roulements de roller maintiennent le chariot Z en place.

Cnc mill Z axis Z axis IMG_5911 Z axis Z axis IMG_5913 Ball bearing from rollers IMG_5916 Aluminium rails Y stepper mount Unipolar steppers IMG_5917 ball bearing from old printers Limit switch from old printers Electronics Electronics Plugs Power supply 12v 80Va First test

Voilà une petite vidéo de test avec le fichier de démo d’Axis. Le fraisage ne se termine pas la course de ma machine étant trop limitée. Pour un premier test, la précision est au rendez-vous.