Fabrication d’une fraiseuse numérique.

Depuis plusieurs mois, j’hésitais entre me diriger vers une imprimante 3D ou vers une fraiseuse numérique. Et, bien que leurs finalités soient assez différentes, il reste quand même pas mal de similitudes. Les possibilités sont variées : un produit tout monté, plus cher mais a priori, sans problème, une création maison, intéressant mais risqué ou un kit qu’il faut juste assembler, un bon compromis.

Au final, j’ai choisi une quatrième solution que je n’avais pas envisagée, j’ai eu entre les mains 'Build your own CNC machine' et ça a été la révélation … des instructions complètes et détaillées sur la construction d’une fraiseuse numérique d’une taille convenable (zone de travail de +/- 1000mmx500mm) faite en MDF. Ce n’est certainement pas l’état de l’art du point de vue fraiseuse, mais tenter l’expérience me semblait tout à fait réaliste, même si je n’avais jamais abordé un projet aussi ambitieux. De plus, ayant fait l’acquisition récemment d’une scie table, c’était le projet idéal pour l’inaugurer. 

Je ne vais pas entrer dans les détails techniques de la réalisation de la fraiseuse et encore moins poster les plans de celle-ci vu qu’ils font partie intégrante du livre. Je poste plutôt les photos des différentes étapes qui m’ont permis d’arriver à un résultat fonctionnel.

Le travail que je vous décris ici représente une grosse centaine d’heures de boulot … peut-être un peu plus, j’avoue ne pas avoir vraiment compté de manière précise. J’ai fait au fur et à mesure du projet quelques ajustements, principalement parce que les plans sont en mesures impériales et non en mesures métriques.

Pour les éléments mécaniques, j’ai commencé par essayer de me fournir auprès de chez moi, mais ce n’était pas évident. Un petit tour sur ebay m’a permis de trouver assez bien d’éléments, mais malheureusement à des prix relativement élevés … et n’étant pas sûr du résultat final, je voulais limiter les risques. Je me suis finalement rabattu  sur le site du livre (http://buildyourcnc.com) qui offrait des prix tout à fait compétitifs même en incluant la livraison. J’y ai commandé les roulements à billes, les moteurs pas-à-pas, les contrôleurs et les systèmes de couplage :

Une fois le matériel minimal acquis, j’ai entamé la réalisation de la base qui est composée de deux plaques de MDF de 1200x600x18mm boulonnées. Les plaques supportent les deux rails sur lesquels vont venir se déplacer la partie mobile  : 

Avant de continuer, j’ai effectué une première rectification : les rails d’origine se sont avérés trop petits et ne m’inspiraient guère confiance … J’ai préféré assurer, vu qu’une grosse partie de la fraiseuse repose dessus. En plus de cela, les petites cornières en alu avaient tendance à bomber au milieu de la longueur une fois les vis serrées.

Voilà qui est plus rassurant. Le pont mobile de la fraiseuse est soutenu lui aussi par deux rails sur lesquels viennent se placer des roulements à billes : 

Il a fallut être assez précis avec le placement des roulements à billes vu qu’ils soutiennent le pont et qu’aucun jeu n’est permis.

Avant de placer le pont, j’ai du fixer les pieds de la base. Dans ceux-ci sont enchâssés deux roulements à billes dans lesquels la tige filetée de l’axe principal va venir se placer. Ici aussi, un alignement parfait était indispensable afin que le moteur ne force jamais :

La tige filetée sera placée plus tard … J’ai cherché en vain des tiges filetées de plus d’un mètre, mais c’est loin d’être standard. Idéalement il faudrait des vis à billes, qui sont prévues pour ce genre d’utilisation, mais leur prix risquait de faire exploser mon budget, je me suis donc rabattu sur un produit plus courant et surtout beaucoup moins cher. Je pourrai toujours remplacer mes axes plus tard. 

L’étape suivante fut la mise en place des côtés et de la partie basse du pont : 

Les rails avec les roulements à billes sont soutenus par la tête des vis, elles-même boulonnées à l’arrière. Cela s’avère très solide et permet un réglage fin de la position du rail.

La largeur de la partie basse a été mesurée une fois les pièces latérales finies,  vu que la distance entre les deux côtés dépend en partie de la taille des rails en alu. On peut voir aussi les roulements à billes de l’axe secondaire.

La partie haute du pont est renforcée afin de limiter le travail de la structure. Nous retrouvons ici la même chose que pour l’axe principal, deux rails en alu vont soutenir la partie mobile allant de droite à gauche.

Et rebelote pour l’axe suivant : 

Je suis passé après à l’assemblage de la tête se déplaçant sur le pont :

J’ai attendu d’avoir terminé le gros oeuvre des trois axes pour choisir une défonceuse. J’ai pris un modèle assez petit qui ne déforcerait pas la structure à cause de son poids, et qui avait comme autre avantage d’être assez bon marché (+/- 60€). Le bouton marche arrêt étant de type poussoir, j’ai usiné une petite pièce en bois qui appuie toujours dessus, j’avais dans l’idée de ne pas perdre la garantie de l’appareil … 

Mais après avoir étudié les différentes possibilités de fixation de la défonceuse sur ma base, j’ai pris l’option de démonter les ‘pistons’ de l’appareil (adieu garantie) et de placer le patin sous mon support en bois. Ceci a comme double avantage de descendre le moteur plus bas et donc d’exposer plus la fraise (donc rainures plus profondes), mais surtout de permettre un démontage aisé de l’appareil afin d’en changer la tête.

L’axe de la défonceuse reste ainsi assez proche du centre de la structure, ce qui limite aussi l’effet de levier. 

Les 3 tiges filetées pouvaient maintenant être placées. J’ai commencé par la plus courte, question de me faire la main : 

Le placement semblait assez simple, j’ai donc testé le deuxième axe en plaçant en plus le support du moteur :

Après avoir effectué un premier test du moteur, il s’est avéré que les vibrations étaient bien trop fortes. La source du problème était l’espace entre la tige filetée qui a un diamètre de 12mm et l’intérieur du roulement à billes, ainsi que l’espace entre la tige filetée et le système de couplage : tout était hors axe. Le système de serrage ne permettait pas de placer l’axe au centre du coupleur, il manquait très peu, mais suffisamment pour générer beaucoup de vibrations. Après plusieurs tests, c’est une bague en papier alu qui a donné les meilleurs résultats pour combler l’espace du système de couplage, même en serrant elle ne s’écrasait pas. Par contre, pour centrer l’axe dans les roulements à billes, j’ai utilisé du Teflon qui est plus souple et qui amortit bien les vibrations résiduelles.

Même chose pour l’axe tertiaire avec un peu de mise en place propre des câbles :

J’ai utilisé des tubes souples pour passer les connexions des moteurs (4 fils par moteurs) : 

J’avais toujours le problème de l’axe principal qui faisait plus d’un mètre, j’ai finalement assemblé deux tiges filetées avec un boulon plus large bien calé avec une pointe de colle et un second boulon pour éviter tout mouvement :

Après avoir placé les moteurs sur les trois axes et câblé les contrôleurs, il fallait commander tout ça. Je suis parti sur une solution légère, je voulais éviter d’avoir un PC installé dans ma cave et, j’avoue aussi, avoir un panneau de contrôle sur mesure me plaisait mieux. Je me suis tourné vers ce que je connaissais le mieux, à savoir la plateforme arduino. J’ai pris un mega pour simplifier la connectique et éviter les multiplexeurs et autres chips externes. Pour relier au panneau de contrôle, j’ai fait un shield de debounce hardware, ce qui évite de devoir gérer ce problème en software, le résultat est propre et simple.

La première version du panneau utilisait des boutons poussoirs qui visiblement n’appréciaient guère la poussière, j’en ai perdu 2 en 2 jours. J’ai donc opté pour des boutons poussoirs étanches que j’avais en stock, ils sont plus durs mais bien plus adaptés. J’en ai profité pour placer un joystick pour le déplacement manuel de la fraiseuse, c’est plus intuitif que des boutons en croix.

Quand la fraiseuse sera totalement opérationnelle, je me ferai un nouveau panneau sur mesure qui finira parfaitement la machine.

Une fois le tout cablé, je suis passé aux premiers tests de base intégrés dans les options du panneau de contrôle : 

Une fois le fonctionnement de base validé, il fallait pouvoir envoyer des schémas plus complexes. Pour ce faire, j’ai aussi ajouté un lecteur de carte sd permettant de lire des fichiers en GCode. Il me reste encore un peu de debugging à faire, la fraise à tendance à descendre de plus en plus lorsque le code est complexe, j’ai déjà eu quelques sueurs froides, mais les premiers résultats sont prometteurs : 

Il reste encore pas mal de travail, surtout du côté software, pour pouvoir utiliser l’appareil de manière confortable.

Pour ce qui est du chantier en cours, j’ai dèjà mis aussi deux couches de vernis sur le MDF pour éviter que celui-ci ne gonfle à cause de l’humidité. J’ai aussi commencé à placer des contacts de bout de course pour permettre une calibration plus simple de l’appareil. Cela me permettra de faire le zérotage de la machine et de m’assurer que les découpes se feront toujours au même endroit. 

Pour conclure, voici une courte vidéo de la machine en action :

Un variateur discret …

Ayant acheté récemment quelques capteurs magnétiques bon marché à deux axes chez SureElectronics (http://www.sureelectronics.net/goods.php?id=944), j’ai tenté dans un premier temps de les utiliser comme simples compas.

Problème gênant : il est impossible de compenser de manière précise l’inclinaison du capteur sans utiliser d’autres capteurs de type gyroscopique. Par contre, si l’on reste sur un plan horizontal, les mesures sont assez précises et cela malgré le faible coût des capteurs (6$), j’ai été agréablement surpris. Les capteurs à trois axes simplifient le problème mais sont beaucoup plus chers… 

L’utilisation du capteur est simple : la communication passe par de l’I2C et il est possible de lire les données jusqu’à 50 fois par secondes. De plus, une commande de remise à zéro permet de remettre le capteur dans son état initial, ce qui est nécessaire quand il a été soumis à un champ magnétique trop intense.

Après quelques essais et un peu de code, je pouvais récupérer un angle correspondant à l’orientation du capteur. J’ai dû passer par une phase de calibration pour déterminer les valeurs minimales et maximales sur les deux axes. Pour cela, j’ai procédé à une calibration simple : J’ai placé le capteur le long de ma table de travail et j’ai récupéré les valeur x et y, j’ai fait de même en tournant à 90° puis à 180° puis à 270°. J’ai ensuite déterminé les valeurs minimales et maximales sur chaque axe sur l’ensemble des mesures.

Les valeurs calibrées sont calculées comme suit :

cal_x=(raw_x-((max_x+min_x)/2))/((max_x-min_x)/2)
cal_y=(raw_y-((max_y+min_y)/2))/((max_y-min_y)/2)

Les valeurs calibrées varient alors approximativement dans une fourchette de -1 à 1, l’angle peut être obtenu grâce à un peu de trigonométrie:

if (( cal_x ==0) && ( cal_y <0))
       angle=PI/2;
else if (( cal_x ==0) && ( cal_y >0))
      angle=-PI/2;
else if (cal_x<0)
      angle=PI-atan(cal_y/cal_x);
else if ((cal_x>0) && (cal_y<0))
      angle=-atan( cal_y/cal_x );
else if (( cal_x >0) && ( cal_y >0))
      angle=(2*PI)-atan( cal_y/cal_x );

En jouant avec des magnets empruntés à mon frigo, j’ai remarqué que le capteur permettait aussi de détecter précisément l’orientation d’un aimant ainsi que sa présence. Les valeurs captées augmentent fortement en intensité mais le calcul de l’angle est toujours valable. L’intensité du champ magnétique est calculé comme suit :

intensity=sqrt(cal_x*cal_x+cal_y*cal_y)

Tant qu’il n’y a pas d’aimant dans les environs, l’intensité reste en dessous de 1.5 (sauf si j’incline le capteur) pour passer à des valeurs bien plus élevées qui dépendent de la distance qui sépare le capteur de l’aimant et de l’intensité de l’aimant. Au delà d’une certaine intensité, le capteur doit être remis à zéro car il renvoie des valeurs totalement incorrectes. Ce n’est pas un réel problème pour l’utilisation que je veux en faire, il y aura toujours au minimum une plaque de 2cm de bois entre le capteur et l’aimant, je dois juste éviter d’avoir un aimant trop puissant.

Il y a cependant un léger problème de stabilité des données lorsque l’on reste dans une position supposée fixe. Pour limiter l’oscillation, j’ai amorti les données en fonction du déplacement : si la différence avec la mesure précédente est faible, alors je ne tiens que très peu compte de cette nouvelle valeur, par contre, si la différence est marquée, j’en tiens plus compte. Ceci a donc pour effet de stabiliser les données mais assure une bonne réactivité en cas de mouvements plus importants.  

Une fois le code validé, l’utilisation pratique a été assez évidente : j’ai prototypé un contrôleur pour un rail de leds RGB acheté aussi chez SureElectronics (http://www.sureelectronics.net/goods.php?id=1223). Ce rail fonctionne en 12V et peut tirer jusqu’à 15w, j’ai donc utilisé des Mosfets IRLZ34N qui peuvent être contrôlés directement par un port de l’arduino et supportent des tensions nettement plus élevées que mes besoins réels. L’autre avantage de ces Mosfets est de supporter les modes PWM ce qui me permet de régler l’intensité de chacun des canaux de couleur. Le schéma global est le suivant :  

Je n’ai pas pris la peine de graver un circuit mais j’ai plutôt utilisé une platine d’essai circulaire pouvant être montée comme un shield Arduino.

J’ai alimenté l’arduino en 12V, sachant que cela reste dans la zone acceptée, ce qui m’a permis de récupérer sur le shield le 12V (pin Vin) et le 5V. J’ai soudé un connecteur coudé directement sur le shield pour me brancher sur le rail de leds :

  

L’aimant, lui, est camouflé dans le pied d’une figurine d’Eizo Auditore (Assassin’s Creed) :

 

J’ai profité du contrôle indépendant que j’avais sur les canaux de couleur pour corriger la couleur de ma rampe de leds qui tirait sur le bleu. J’ai obtenu un blanc bien plus pur en réduisant le canal bleu de 65%.

L’intensité globale de la rampe de leds dépend de l’orientation de la figurine: plus elle fait face, plus l’intensité de la rampe est forte. Lorsque l’on pose la figurine, une transition douce évite de passer directement de l’état éteint à l’état allumé, il en est de même lorsqu’on l’enlève.

Il reste juste le problème de la réponse non linéaire des leds à régler : une intensité de 50% au niveau du PWM ne correspond pas à une couleur moyenne située entre l’intensité maximale et le noir. C’est un phénomène qui est aussi présent sur les écrans/téléviseurs et j’ai d’ailleurs utilisé la même correction que celle utilisée en vidéo (2.2) pour obtenir un rampe de variation bien plus correcte (http://fr.wikipedia.org/wiki/Correction_gamma).

Le calcul consiste à élever l’intensité entrante à la puissance 2.2 pour obtenir la valeur corrigée qui contrebalancera la courbe de réponse des leds :

  

Pour conclure, voici une vidéo du système en action : 

Et voici le code complet dans sa version actuelle : 

// Led compass control
// By -Gil- (c)2012
// http://domoduino.tumblr.com/
// http://domoduino-world.tumblr.com/
//
 
#include "Arduino.h"
#include <Wire.h>
 
int calibration=-1;
 
int PreviousCompass_x=0;
int PreviousCompass_y=0;
int Compass_x=0;
int Compass_y=0;
float Compass_xcal=0;
float Compass_ycal=0;
int Compass_minx=1920;
int Compass_miny=1935;
int Compass_maxx=2131;
int Compass_maxy=2136;
float Compass_dist=0.0;
float ProximityFade=0.0;
int RotationValue=255;
 
 
float Compass_angle=0.0;
#define COMPASS_CARD_ADR B0110000  
const byte COMPASS_comp_reg_addr = B00000000;
const byte COMPASS_read_comp = B00000001;
const byte COMPASS_reset_comp = B00000100;
const byte COMPASS_set_comp = B00000010;
 
void setCompass()
{
   Wire.beginTransmission(COMPASS_CARD_ADR);
   Wire.write((uint8_t)COMPASS_comp_reg_addr);
   Wire.write((uint8_t)COMPASS_set_comp);
   Wire.endTransmission();
   delay(20);
}
 
void resetCompass()
{
   Wire.beginTransmission(COMPASS_CARD_ADR);
   Wire.write((uint8_t)COMPASS_comp_reg_addr);
   Wire.write((uint8_t)COMPASS_reset_comp);
   Wire.endTransmission();
   delay(20);
}
 
void readCompass()
{
 
   Wire.beginTransmission(COMPASS_CARD_ADR);
   Wire.write((uint8_t)COMPASS_comp_reg_addr);
   Wire.write((uint8_t)COMPASS_read_comp);
   Wire.endTransmission();
   delay(10);
 
   byte x_msb = 0;
   byte x_lsb = 0;
   byte y_msb = 0;
   byte y_lsb = 0;
 
   // read data from the sensor
   Wire.requestFrom(COMPASS_CARD_ADR, 5);
   int avail = Wire.available();
   if (avail == 5)
   {
      x_msb = Wire.read();
      x_lsb = Wire.read();
      y_msb = Wire.read();
      y_lsb = Wire.read();
   }
 
 
   int newCompass_x=((int)x_msb)<<8 | (int)x_lsb;
   int newCompass_y=((int)y_msb)<<8 | (int)y_lsb;
 
   int deltax=abs(newCompass_x-PreviousCompass_x);
   int deltay=abs(newCompass_y-PreviousCompass_y);
 
   // Filter the result to avoid jitter
   float deltaxFriction=deltax/10.0f;
   float deltayFriction=deltay/10.0f;
 
   if (deltaxFriction>1.0)
      deltaxFriction=1.0f;
   if (deltayFriction>1.0)
      deltayFriction=1.0f;
 
   Compass_x=(newCompass_x*deltaxFriction)
            +(PreviousCompass_x*(1.0-deltaxFriction));
   Compass_y=(newCompass_y*deltayFriction)
            +(PreviousCompass_y*(1.0-deltayFriction));
 
   PreviousCompass_x=Compass_x;
   PreviousCompass_y=Compass_y;
 
   // calibrate the values
   Compass_xcal=(Compass_x
            -((Compass_maxx+Compass_minx)*0.5))
            /((Compass_maxx-Compass_minx)*0.5);
   Compass_ycal=(Compass_y
            -((Compass_maxy+Compass_miny)*0.5))
            /((Compass_maxy-Compass_miny)*0.5);
 
   // compute magnetic field intensity
   Compass_dist=sqrt(Compass_xcal*Compass_xcal
            +Compass_ycal*Compass_ycal);
 
   // compute angle
   if ((Compass_xcal==0) && (Compass_ycal<0))
      Compass_angle=PI/2;
   if ((Compass_xcal==0) && (Compass_ycal>0))
      Compass_angle=-PI/2;
   if (Compass_xcal<0)
      Compass_angle=PI-atan(Compass_ycal/Compass_xcal);
   if ((Compass_xcal>0) && (Compass_ycal<0))
      Compass_angle=-atan(Compass_ycal/Compass_xcal);
   if ((Compass_xcal>0) && (Compass_ycal>0))
      Compass_angle=(2*PI)-atan(Compass_ycal/Compass_xcal);
}
 
 
 
void setup()  
{
      Wire.begin();
 
      // reset the compass when starting/restarting
      resetCompass();
      setCompass();
}
 
void loop()  
{
      readCompass();
 
      if (Compass_dist>1.5) // Is there a magnet ?
      {
            // Fade in
            ProximityFade=ProximityFade+0.05;
            if (ProximityFade>1.0)
                  ProximityFade=1.0f;
 
            float intensity=(Compass_angle-PI/2)/(PI);
            if (intensity<0)
                intensity=0;
            if (intensity>1)
                intensity=1;
            RotationValue=255*pow((float)intensity,2.2);
      }
      else
      {
            // Fade out
            ProximityFade=ProximityFade-0.05;
            if (ProximityFade<0.0)
                ProximityFade=0.0f;
      }
      int finalFade=RotationValue*ProximityFade;
 
      analogWrite(3, finalFade);         //R        
      analogWrite(5, finalFade);         //G      
      analogWrite(6, finalFade*0.35); //B (fixed)    
 
      delay(30);                            
}

Vous pouvez aussi suivre Domoduino sur Google+ ici. N’hésitez pas à laisser des commentaires!

--Tagged under: Arduino--

Horloge multifonction (1ère partie)

Voici un projet qui est dans mes cartons depuis maintenant pas mal de mois et qui arrive enfin à un niveau de finition montrable. Le temps que j’y consacre est inversement proportionnel au temps passé à jouer sur console, ce qui en explique l’avancée laborieuse.

L’idée est d’avoir une horloge autonome multifonction utilisant un double afficheur led de 24x16 … J’avais déjà parlé de ces afficheurs lors d’un post précédent: achetés chez SureElectronics pour une bouchée de pain (14$), ils sont très bien finis, un peu inégaux au niveau de l’intensité des leds, mais globalement d’un excellent rapport qualité/prix.

Du point de vue fonctionnalité de l’horloge, il y a évidemment l’heure, la date mais aussi la température et l’humidité relative.

Je voulais aussi une horloge sympa niveau design qui n’ai pas trop l’air d’être un proto fait sur un breadboard à la va-vite. Je me suis donc procuré une plaque de plexi dans laquelle j’ai découpé une face avant et une arrière. Pour éviter les vis et boulons en façade, je me suis pris un kit de tarauds pour visser les tiges filetées directement dans le plexi sans qu’elles ressortent à l’avant … 

  Je n’avais jamais taraudé avant cela, mais finalement c’est simple et le résultat est très propre et solide. J’ai pris 1m de tige filetée que j’ai découpé pour avoir mon afficheur, le circuit et l’arduino pris en sandwich entre la face avant et la face arrière. La face arrière n’est pas encore placée actuellement, mais voici ce que donne la fixation de l’afficheur sur la face avant :

Pour surélever l’afficheur, j’ai découpé des petites sections de tube en alu afin d’éviter de voir le filetage. De plus, cela me permet d’avoir une distance fixe entre le plexi et le circuit imprimé. J’ai placé en tout 4 fixations par afficheur pour être certain que rien ne bouge au final. 

Pour ce qui est de la partie électronique:

  • un arduino comme élément central.
  • un DS1307 pour assurer une base de temps relativement solide et éviter de perdre l’heure en cas de coupure de courant.
  • un DC-SS500 de chez sure electronics pour la température et l’humidité
  • une photorésistance pour régler l’intensité de l’afficheur en fonction de l’éclairage ambiant.
  • un RFM12B pour la communication externe.

La communication externe n’est pas encore présente actuellement mais la place du chip est réservée sur le circuit. 

L’afficheur led est géré grâce à la librairie de Miles Burton que vous pouvez trouver ici. Son utilisation est simple et peut contrôler jusqu’à 4 afficheurs chaînés. Sur ce projet, je n’en ai que 2 chaînés et 4 fils sont utilisés : clock, data, CS1, CS2 … ainsi que l’alimentation, évidemment. J’ai juste fait quelques ajouts à la librairie pour avoir des fonts de taille double, vu que je compte pouvoir configurer le type d’affichage dans le futur. 

Voici le schéma complet du circuit (cliquez dessus pour l’avoir en plus haute définition) :

 

  Le tout a été monté sur un petit circuit expérimental, mais vu la simplicité du cablage, cela me semblait acceptable comme solution : 

L’arduino et le circuit sont posés sur du tape double face qui les maintiens en place mais surtout les isole des afficheurs.

Actuellement, l’heure est affichée en permanence sur la première ligne de texte, et sur la deuxième ligne, on a le jour/la date, l’humidité et la température en alternance. Le code est encore très expérimental … dès que celui-ci sera un peu plus finalisé, je le posterai.

Une fois la partie RF connectée, je compte faire communiquer l’horloge avec le reste de mes circuits. Je pourrai tracer les variations de température, humidité et luminosité sur mon poste central, et je pourrai aussi envoyer de commandes à l’horloge, telles que : 

  • remise à l’heure
  • changement d’affichage
  • message personnalisé 

A suivre dans un prochain post.

Joystick arcade V2.1

J’ai été confronté récemment à une limitation de mon joystick arcade maison: il est impossible de jouer au nouveau Mortal Kombat … pas assez de boutons. Pour rappel, j’ai utilisé des joypads xbox360 dont j’ai connecté les boutons A,B,X,Y, LB et RB. Mais c’est insuffisant car MK utilise aussi les deux gâchettes LT et RT, et il est très difficile de faire sans.

Jusqu’à présent tous les boutons et pads directionnels étaient de simples boutons on/off, mais ici, les gâchettes sont des petits potentiomètres (de 10K Ohm) comme vous pouvez voir sur la photo ci-dessous :  

 

Pour simuler le comportement du potentiomètre, j’ai simplement considéré les deux positions extrêmes de celui-ci en utilisant un bouton poussoir inverseur et deux résistances. Dans la positions de repos, un fil est en contact direct et l’autre passe par une résistance de 10K Ohm. Une fois que l’on pousse sur le bouton, la situation est inversée. Le schéma suivant représente ce que j’avais avant et ce que j’ai maintenant : 

Ce qui donne une fois monté sur un microswitch de bouton d’arcade : 

La partie soudure sur le circuit imprimé du joypad a été bien plus simple que pour les boutons précédents. J’ai retiré les potentiomètres à l’aide d’une pompe à dessouder et j’avais ensuite une place nette pour connecter mes trois fils. Le tout est suivi d’un coup de pistolet à colle pour éviter tous mouvements intempestifs des fils.

 

Pour des raisons ergonomiques, j’ai ajouté les deux boutons en dessous du bloc de six existant.

J’aurais aimé aussi déporter les leds placées sur le joypad afin de voir quand il est connecté et quel joueur est sélectionné. Devoir dessouder des leds surface mounted n’est déjà pas simple, mais essayer de connecter des fils après sur une aussi petite zone, cela me parait encore plus compliqué … Si quelqu’un a déjà fait ce genre d’opérations, je serais intéressé par la marche à suivre et/ou les outils à utiliser :-) … 

Radio retro V1.1

C’est reparti pour une amélioration de ma radio rétro avec media player intégré … Je n’aimais pas du tout l’écran externe et j’ai donc décidé de l’intégrer dans le meuble pour avoir une solution monobloc.

J’ai retiré toute la partie habillage de ce qui était un haut parleur dans la radio d’origine. Le tout était maintenu par des vis, ce fut très simple.

J’ai gardé une partie de la ‘grille’ du haut parleur pour maintenir l’écran en place. Cet écran ne couvrant qu’une partie de la zone dégagée, j’ai essayé de conserver au maximum le look de la radio. 

Je n’ai pas découpé le tissus à raz pour pouvoir le rabattre et le coller afin d’avoir une finition un peu plus propre.

J’ai ensuite collé l’écran grâce à un pistolet à colle. C’est assez barbare, j’en convient, mais je n’avais pas du tout le courage et l’outillage pour mettre en place une système de fixation propre et démontable.

L’avantage principal, en dehors de l’esthétique de la radio, est une simplification non négligeable du câblage. L’écran est alimenté directement par le transformateur du PC intégré et le câble VGA reste caché dans le boitier de la radio.

Seconde amélioration apportée à la radio, elle peut maintenant communiquer avec des modules externes grâce à un arduino accompagné d’un shield RF maison.

Mes premiers essais de communication sans fil entre arduinos utilisait des xbees, mais ceux-ci s’avèrent chers et j’avoue ne pas avoir su mettre en place une communication rapide et réactive avec plus de deux postes.

Je me suis donc replié sur une solution plus simple et qui répond à mes attentes, des modules RFM12B … le prix est très démocratique (5.5€ sur Jeelabs) et l’utilisation est relativement simple avec les librairies fournies par Jeelabs. Voici mon prototype de shield : 

L’ensemble des pins est câblé car je prévois des extensions futures.

De l’autre côté, j’ai aussi un prototype de module multifonction. Celui-ci est basé sur un arduino mini pro, un capteur de température et d’humidité (Sure electronics), un capteur de luminosité (Sure electronics) et deux leds multicolores (BlinkM).

L’idée est de créer plusieurs de ces modules afin de relever la température et l’humidité dans les différentes pièces de ma maison. J’ai ajouté ici deux leds multicolores pour permettre un éclairge léger de l’arrière de mon téléviseur qui sera le premier emplacement de test.

J’ai monté le module RF sur des pin headers que j’ai plié pour me retrouver avec un module facilement utilisable sur un breadboard, l’espacement de base des connecteurs du module RF étant plus faible que la normale.

Les autres modules : 

Voici l’ensemble assemblé avec un régulateur de tension en prime pour alimenter le tout via un petit transformateur bon marché : 

J’ai modifié l’interface de mon media player pour pouvoir changer facilement la couleur de mes leds, c’est encore un proto, mais je peux déjà jouer avec.

Je n’ai pas encore intégré l’affichage de la température, humidité et luminosité …  la partie sketch arduino est terminée, il ne reste plus que la partie c# de l’interface à mettre à jour.

Il reste encore quelques améliorations à apporter, principalement au niveau du software qui est encore assez limité pour le moment. Mais pour une utilisation au quotidien, cela s’avère assez efficace.

Intervallomètre - essais

Comme promis, voici deux vidéos réalisées grâce à mon intervallomètre maison.

J’ai utilisé un canon 550d avec un objectif sigma 50mm 1.4 … le tout en manuel pour éviter d’avoir des variations d’intensité d’une photo à l’autre.

Je profite de ce post, pour signaler que je viens de lancer une version ‘internationale’ de mon blog : Domoduino world. Mais, lecteurs francophones, rassurez-vous, je vais continuer à écrire tous mes articles en français et les traduire ensuite en anglais … 

Intervallomètre

Voici un petit projet autour d’un arduino mini pro qui a été relativement simple à faire et qui me permet de me relancer un peu dans mes projets électroniques quelque peu délaissés ces derniers mois.

Qu’est-ce qu’un intervallomètre ? Il s’agit d’une fonction que l’on retrouve sur certains appareils photos ou sur des boitiers de contrôle externes qui permet de prendre des photos à intervalle régulier, généralement dans le but d’en faire des vidéos. Typiquement, on photographie la progression de nuages dans le ciel et on repasse le tout à grande vitesse. Je n’ai pas encore de fichiers d’exemple à poster, mais dès que j’aurai un résultat acceptable, je l’ajouterai à mon blog.

Pour m’interfacer sur le reflex, j’utilise simplement l’entrée jack 2.5mm “remote control” qui permet de déclencher le focus et le zoom à distance. Le cablage est le suivant :

 

Pour isoler le contrôle de l’appareil du reste du circuit, deux optocoupleurs 4n35 font parfaitement le boulot. Ils sont tout deux reliés à une pin digital de l’arduino accompagnés chacun de leur résistance de 560 Ohm. 

Ça, c’est pour la partie contrôle, mais il faut maintenant avoir une interface digne de ce nom … j’ai opté pour un petit afficheur LCD de 4cm de large (HMC16223SG) que j’avais acheté chez Pollin. Il est muni d’un contrôleur HD44780 que je contrôle en 4bits pour limiter le cablage (7 pins utilisés à la place de 11). Petit désavantage, il n’y a pas de backlight, mais bon, ce n’est pas des plus critique sur ce projet.

J’ai trouvé un petit boitier sympa qui m’a permis de caser tout ça, il fait 13x6x3cm, est muni d’un emplacement pour une pile 9v et permet l’intégration d’un LCD grâce à une petite fenêtre en plastique. J’ai du malgré tout me battre pour que tout rentre dedans …

Voici ce que cela donne de l’intérieur :

  

J’ai placé en façade 3 boutons poussoirs pour se promener dans les menus. J’ai repris les mêmes que ceux de ma télécommande vu le peu d’espace qu’ils occupent.

Et l’extérieur :

Les boutons de droite permettent de se déplacer dans les menus, le bouton de gauche sélectionne l’entrée courante du menu et une fois cela fait, les deux autres boutons permettent de changer la valeur associée.

Le menu est organisé comme suit :

  • GO - démarre la prise de photo 
  • Automatique (Nombre de photos/Intervalle/Temps total) - permet de choisir le paramètre qui sera calculé automatiquement. Par ex : si Nombre de photos est sélectionné, il sera calculé automatiquement en fonction du temps total et de l’intervalle entre les photos.
  • Intervalle - temps de pause entre chaque photo.
  • Nombre de photo.
  • Temps total.
  • Utilisation du focus - Active ou non la mise au point avant de prendre la photo.
  • Durée du focus.
  • Délai avant la première photo.
  • Mode de test.

Il y a deux leds en façade, la verte permet de voir si l’appareil est allumé. La deuxième permet de voir si une entrée menu est actuellement selectionnée (allumée en continu) ou si une session de photo est en cours (clignotement à chaque seconde).

Petite cerise sur le gâteau, je stocke les paramètres dans l’eeprom et donc d’une session à l’autre, pas besoin de tout régler à nouveau.

Le soft représente quand même 650 lignes de code, mais j’avoue avoir été assez fainéant et ce n’est pas des plus optimisé … mais tout fonctionne, c’est le principal :-).

Des extensions sont facilement envisageables: le déclenchement de prise de photos en fonction du son ou de la lumière. Il me reste encore quelques pins de libres sur l’arduino, donc, tout est faisable … si j’arrive à caser encore quelque chose dans le boitier.

J’espère pouvoir faire bientôt quelques essais et poster cela ici.D’autre part, si le code vous intéresse, je peux le poster, mais j’ai la fâcheuse habitude de nommer toutes mes variables en anglais … 

--Tagged under: arduino photo--

Joystick arcade

Question de changer un peu, je vais poster quelques images d’un projet que j’ai commencé il y a maintenant un paquet d’années et que je remets à jour régulièrement. Peu de rapport avec les arduinos ou la domotique, mais on reste dans le domaine du fait maison … 

J’ai toujours été grand amateur de jeux vidéos et, en particulier, de jeux d’arcade. Il y a maintenant quelques années, je me suis commandé de quoi monter mon propre joystick arcade à partir de véritables pièces de bornes d’arcade. En cherchant un peu je suis tombé sur un magasin en ligne où l’on peut trouver de tout et au détail : http://www.happcontrols.com/. Ils sont visiblement toujours en activité. 

L’ensemble du matériel est de très bonne qualité, tous les boutons sont à microswitch et donc très résistants malgré tous les mauvais traitements qu’ils pourraient subir.

Dans un premier temps, j’avais utilisé une petite carte USB I-PAC (http://www.ultimarc.com/ipac1.html) qui émulait un clavier et qui avait le grand avantage d’autoriser autant de boutons/touches pressées simultanément que l’on désire, ce qui n’est pas le cas d’un clavier classique. Mais, depuis quelques années, j’ai un peu délaissé mon PC comme plateforme de jeu pour une XBOX 360, ce qui rendait mon joystick inutile.

J’ai donc vampirisé deux manettes Xbox360 sans fils qui avaient fait leur temps et ne fonctionnaient plus tout à fait comme elles devaient. J’ai gratté les surface conductrices et soudé à même le circuit imprimé des nappes de fils.

 

Je n’ai raccordé que les contrôles digitaux question de me simplifier la vie. Et, de l’autre côté de la nappe j’ai raccordé les boutons à microswitchs :

Le tout deux fois, question de pouvoir jouer à deux … c’est un minimum pour une partie d’arcade réussie :-). Le résultat final :

Si vous avez des questions sur ce projet, n’hésitez pas, j’espère que cela donnera des idées à certains … au final, ce n’est pas très complexe à réaliser et le fun est maximal !

Plus tard, j’aimerais pousser le projet plus loin jusqu’à monter le tout dans un meuble d’arcade … mais ce sera pour une autre fois, quand j’aurai un peu plus d’espace … et surtout de temps … 

Radio retro & co.

Avant tout, une excellente année 2010 à tous … J’espère arriver à poster un peu plus régulièrement cette année … Ca ne devrait pas être trop difficile remarquez … :p …

News tout récente: le blog Domoduino est maintenant référencé par http://planet.madeinfr.org/ … Je vais faire mon possible pour être à la hauteur et ne pas (trop) raconter de stupidités.

Vu que mes posts sont plutôt étallés dans le temps, j’ai pas mal de choses à raconter (il faut bien voir les côtés positifs). J’ai d’abord mis au point un petit prototype d’éclairage pour ma cage d’escalier qui utilise un détecteur de mouvements PIR, ensuite, j’ai intégré un petit pc basé sur une ASUS AT3N7A-I dans une vieille radio accompagné d’un petit ampli.

        Eclairage d’appoint déclenché par infrarouges

J’ai utilisé un détecteur pir standard, 3 connecteurs : +5v, ground et signal. Le signal est à haut quand quelque chose entre dans le champ de vision du détecteur autrement il est à bas … rien de plus simple de ce côté-là. Pour ce qui est de l’éclairage led, j’ai utilisé une barette led de 1W de chez sure electronics (http://www.sureelectronics.net/) … Je recommande chaudement ce magasin en ligne, ils ont des produits incroyables à des prix ridiculement bas. Les barettes leds par example sont à 2.2$ pièce et elles ressemblent à ceci :

Leur luminosité est trop forte pour l’usage que je voulais en faire, je n’ai pas spécialement envie d’avoir un escalier pleinement éclairé au milieu de la nuit, j’ai donc opté pour un contrôle de leur intensité en utilisant une modulation de fréquence d’alimentation (PWM). Le problème est que ces leds consomment 80ma par plaque, ce qui est supérieur à ce que supporte une sortie arduino, de plus elles sont alimentées en 12V et non 5V. Après un peu de recherche, j’ai trouvé ce qu’il me fallait : Un ULN2003A, c’est à dire un Darlington array contrôlable en 5V supportant plusieurs dizaines de volts en charge et jusqu’à 500ma, tout à fait ce qu’il me fallait. Pour gérer tout ça, j’ai utilisé un mini arduino pro … oui, c’est plutôt ‘Overkill’ comme solution, mais l’idée à terme est d’y ajouter un détecteur de température, d’humidité et autres joyeusetés.

Le système a fonctionné plus ou moins 15 jours, ensuite l’arduino a cessé toute activité … la led d’alimentation fonctionne encore, mais le reste est mort. Après autopsie, j’ai détecté une erreur de connexion de ma part … le +5v de détecteur PIR était branché sur la pin Reset et non sur la VCC … Je ne comprends toujours pas comment le détecteur pouvait fonctionner. J’ai rectifié le branchement et j’ai profité de l’occasion pour y ajouter un régulateur de tension digne de ce nom afin d’éviter de faire chauffer celui qui est placé sur le board du mini. L’alimentation que j’utilise est de 9.5v, ce qui est dans les normes du mini, mais bon … dans le doute et vu que j’avais quelques régulateurs sous la main …

Une fois que le système aura fait ses preuves, je brancherai 2 ou 3 plaques de leds avec du plexi poncé devant afin de diffuser la lumière de manière un peu plus propre et définitive que ce que j’ai actuellement.

Le software actuel est on ne peut plus simple: si il y a détection de mouvement, il y a un ‘fade’ vers le niveau maximal de luminosité … après 15 secondes sans aucune activité dans le champ de vision du détecteur, il y a un ‘fade to black’. Si vous êtes intéressé par le code, je le posterai.

        Radio rétro

J’utilisais depuis quelques temps un petit pc comme media player dans mon living, mais il était vieux, consommait pas mal et niveau performances, c’était assez déplorable. J’ai craqué pour une carte mère AT3N7A-I de chez Asus (processeur ATOM et contrôleur ION), 2Gb de RAM et Windows 7 … je ne le regrette pas du tout. L’avantage de Seven est d’intègrer un support touchscreen de base et mon PC est justement connecté sur un petit écran 7 pouces tactile (acheté sur Ebay).

Pour éviter d’avoir un pc et un ampli sous les yeux tous les jours, j’ai décidé d’intégrer le tout dans une vieille radio à lampes qui était totalement hors d’usage. En plus de cela, j’ai du ajouter une alimentation PC et un préampli.

Pour le préampli, j’ai tenté un kit velleman stéréo alimenté sur du 2x12V et j’avoue avoir été TRES déçu par le son … impossible d’éviter le bourdonnement du au transformateur, même en éloignant celui-ci du circuit. Au final je l’ai complètement supprimé (les photos suivantes ont été prises alors qu’il était encore présent) et la qualité du son est maintenant bien supérieure à ce que je pouvais avoir. Le réglage du volume doit maintenant se faire sur le PC et non plus via un potentiomètre … mais je compte bien y remédier bientôt.

Pour la partie ampli, la aussi j’ai été chez Sure electronics pour y trouver un ampli 2x100W classe D qui est vraiment impeccable vu son prix de 40$.

Voici l’ampli et le préampli intégré dans le boitier :

Les deux potentiomètres visibles sont pour les basses et trebles, la nappe de fils déporte le troisième potentiomètre en façade pour pouvoir régler le volume. Le petit ventilateur situé sur l’ampli est totalement inaudible … il y en a même un de remplacement fourni avec.

Le PC lui est dans un boitier ouvert, ce qui m’a permis de retirer le ventilateur de base qui était particulièrement bruyant car trop petit et tournant trop vite. Pour compenser ce manque, j’ai installé un ventilo 12 cm sous volté à l’arrière de la radio … je n’ai absolument aucun problème de chauffe. Je dois encore remplacer le ventilo 12cm (qui était une récup’) par un noisebocker ou similaire afin de supprimer tout bruit venant de la radio. Je dois aussi me commander une alimentation fanless qui rendra l’ensemble totalement silencieux, ce qui n’est pas encore le cas.

Voici l’arrière une fois le tout refermé :

Et l’avant :

 

Le bouton gauche est un bouton poussoir servant à démarrer le pc, j’ai simplement démonté un bouton existant et collé le bouton d’origine avec de la colle forte.

Le bouton de droit est sur un potentiomètre qui devrait servir à régler le volume … mais vu que j’ai supprimé le préampli, il est maintenant inutilisé. Je pense sérieusement à intégrer une partie électronique customisée pour pouvoir l’utiliser … je pourrais aussi le remplacer par un potentiomètre digital (comme je l’ai fait pour ma télécommande) de manière à pouvoir contrôler le niveau sonore sur le PC directement et/ou sur la radio.

Pour ce qui est du software, c’est du fait maison aussi. Le tout est en c# et utilise le protocole UPNP pour énumérer les source sons (mp3, webradios …). Je posterai quelques screenshots si cela vous intéresse …

Ceci cloture don le premier long post de 2010 … je vous tiendrai au courant de l’évolution de ces deux projets et aussi d’un troisième dont je n’ai pas encore parlé : une horloge basée sur un affichage de type matrice à led.

Télécommande V0.2

L’intégration de la nouvelle télécommande est finalisée (temporairement :p) … Niveau fonctionnalité, je suis très proche de ce que j’avais dans la V0.1, la différence principale réside dans le LCD graphique et les commandes et menus s’y affichant.

J’ai adopté aussi un look très industriel années 70 … je dois encore modifier le potentiomètre numérique blanc qui va sans doute passer au noir un pour être plus assorti aux boutons.

Je me suis fait plaisir aussi en ajoutant un détecteur infrarouge qui permet d’allumer automatiquement la backlight du LCD quand j’approche la main … la preuve en image :

J’ai un peu ramé pour le déclenchement de la backlight, elle tire quand même 500ma et les PCF8574 que j’utilise sont assez limités de ce côté-là … dans un premier temps j’ai utilisé un relais, mais il générait un problème aléatoire qui faisait passer toutes les entrées du PCF8574 à haut. Finalement, le vendeur de mon magasin d’électronique m’a proposé d’utiliser un Mosfet IRLZ34N qui s’avère fonctionner parfaitement … et en plus j’évite le bruit du relais.

Du point de vue menu/boutons , j’ai un changé d’approche: La rangée supérieure active la commande reprise sur le bas du LCD (XBOX 360, Bureau …), la rangée du bas permet de changer la commande active.

J’ai donc sur la première colonne la possibilité de changer l’entrée active de mon ampli et du switch DVI : Xbox, PC, ON ou OFF. En pratique, le ON ne sert à rien puisque le passage à PC ou Xbox allume l’ampli aussi. La deuxième colonne me permet de basculer l’éclairage du bureau ou de la salle de bain adjacente. La dernière colonne sert de menu de configuration et ne contient pas grand chose pour le moment, mis à part un reset forcé du LCD.

Le boitier est un peu plus grand que la version précédente, mais le LCD est bien plus lisible et va me permettre d’ajouter quelques informations comme la date, l’heure, la température … etc.

En parallèle à la finalisation du boitier, j’ai commandé quelques “gadgets” chez http://www.sure-electronics.com/, le choix et surtout les prix sont carrément bluffants. Je dois dire que je suis très satisfait de la qualité de leur matériel, c’est très professionnel surtout si l’on considère le prix de revient. J’ai, entre autre, commandé des affichages leds 16x24 (11.64$ !!!) afin d’en faire une horloge murale … mais ce sera l’objet d’un futur billet.

Theme created by: Roy David Farber and Hunson. Powered By: Tumblr...
1 of 3