DIY Planet : Made in Fr

Si vous vous intéressez aux bobines Tesla, ou à tout autre montage tournant autour de la haute tension, vous avez dû être confronté à un moment ou un autre à la réalisation d’une bobine, voir, d’une bobine de grande longueur. Assez rapidement dans ce cas, on se rend compte qu’il vaut mieux être deux : un qui gère la rotation de la bobine, et l’autre qui gère l’avance du fil. Seulement voilà, on n’a pas toujours 2 mains supplémentaires de disponibles. On se contente donc souvent d’une vitesse de rotation (très) lente, de manière à pouvoir gérer l’avance du fil avec les mains, et tout arrêter en cas de soucis en cours de bobinage.  L’inconvénient de cette méthode est que lorsque ça se passe bien, on est limité à cette fameuse vitesse lente, alors qu’on pourrais gagner beaucoup de temps en accélérant.
L’idée, pour améliorer tout ça est d’utiliser un contrôle supplémentaire pour la vitesse de rotation, à savoir une pédale, comme pour les machines à coudre. Bon, n’ayant pas trouvé de pédale de machine à coudre, je m’en suis fabriqué une, qui était dès le début prévue pour ce genre d’usages.

Voulant faire des essais de slayer exciter, j’avais donc besoin d’une bobine de bonne longueur, ce qui était l’occasion rêvée pour tester mon concept jusqu’au bout. Bon, comme le titre le laisse penser, j’ai fait ça à l’arrach, avec premiers outils qui me tombaient sous la main. Ca permet de tester le système avant de passer à une réalisation plus pérenne.  La pédale est équipée d’un potentiomètre, dont la valeur est lue par un arduino. L’entraînement de la bobine se fait avec un moteur pas à pas, piloté par un driver pololu. La bobine de fil est montée sur un dévidoir d’étain.

Concernant le fonctionnement, le moteur accélère lorsqu’on appuie sur la pédale, et s’arrête lorsqu’on relâche complètement. L’avantage, c’est que ça permet de se repositionner de temps en temps, et de prendre une pose si besoin. (Le point de colle visible sur la vidéo ci-dessous est justement là pour bloquer le fil lors d’une pose). La vitesse de rotation est gérée en augmentant/diminuant le délai entre chaque pulse envoyée au module pololu.
Au final, j’ai trouvé ça très pratique, la bobine en question aura été réalisée en moins d’un quart d’heure, là où il m’aurais fallu certainement une bonne heure sans assistance, avec en plus une qualité probablement moindre.

Bleuette marche

Pour commencer, voici une vidéo de Bleuette effectuant ses premiers mouvements :

Bleuette first step from hugo on Vimeo.

L'électronique

Le contrôle des servos de Bleuette (12 pour les pattes + 2 optionnels) se fait au travers d'une carte fille (shield) pour Arduino conçue pour ne pas être totalement dépendante de Bleuette, ainsi, vous pouvez parfaitement l'utiliser pour un tout autre projet.

Ses caractéristiques sont les suivantes :

• Gestion parfaitement synchrones (voir en dessous) de 14 servos
• Contrôle de la tension des servos
• Contrôle du courant consommé par les servos
• Port d'extension intégré (avec disponibilité de l'alimentation +5V et 4 entrées / sorties RA2 à RA5)

Parfaitement synchrone signifie que les impulsions à destination des servos commencent toutes au même moment avec un décalage très très faible, vous pouvez lire la documentation originale sur la carte.

Le pilotage des servos se fait en envoyant des trames de 17 octets contenant une entête, une commande et la position des servos + un checksum.

J'ai fait faire les PCB par Seeedstudio, qui fait de la très bonne qualité pour un prix très intéressant. La carte est simple à réaliser, la soudure du PIC18F452 nécessite tout de même un peu de doigté et un minium de matériel mais ça reste jouable avec du matériel amateur.

Voici une vue de la carte :

Si vous souhaitez faire vous même la carte, rendez-vous sur cette page pour avoir la dernière version des fichiers Eagle : Pcb de Bleuette

Pour ceux qui souhaiteraient se procurer une carte (version 1.0.2), frais de port inclu pour la France métropolitaine :

• La carte seul (sans composant) pour 6€, livraison en France
• Le PIC18F452 programmé : 10€
• Pour le kit complet, carte + composants soudé ou non, me contacter

Notez également que j'ai effectué des modifications récentes sur le schéma de principe et le PCB, elle est dorénavant en 1.2.1 (ajout d'un condensateur de découplage C9, des diodes zener D2 et D3 de protection sur les entrées analogiques, modification de l'interrupteur, ajout d'un pont SJ1 pour le reset).

Logiciel

La méca et l'électronique étant finies, j'ai pu attaquer le logiciel embarqué qui est de 2 sortes :

L'assembleur PIC

Rien de spécial à dire, il se trouve ici et comporte tout ce dont on a besoin pour piloter Bleuette et donc ne devrait plus vraiment évoluer...

Le code pour Arduino

Voici la structure :

• bleuette\bleuette.ino : Le point de départ du code à ouvrir avec l'éditeur Arduino
• bleuette\sequences.h : Ici sont stockées les séquences de mouvement des pattes (voir plus bas)

Et nous avons 4 librairies :

• Bleuette : C'est par ici que tout passe
• Sequencer : C'est lui qui gère les sequences définies dans le fichiers sequences
• ServoController : Pilote de la carte de contrôle de servos
• SerialCommand : Librairie externe très pratique pour la gestion de commande via la liaison série.

Déplacer Bleuette

Pour faire bouger les pattes de Bleuette, c'est assez simple, commençons par un exemple :

bleuette.servo.set(0, 128);

Cela aura pour effet de positionner le servo 0 à sa position intermédiaire 128.

Si maintenant, on souhaite faire faire des pompes à Bleuette, on ne va pas répéter 24 fois la commande précédente pour positionner chaque patte, sinon, on ne va jamais s'en sortir ! Utilisons plutôt, une séquence :

Tout d'abord, déclarons une structure de type motion_t nommée motion_pushup :

// Push up
motion_t motion_pushup[] = {
    {
        DELAY_MIN, // Durée du déplacement courant
        {
            __, __, __, __, __, __, // Position des pattes horizontales
            UP, UP, UP, UP, UP, UP // Position des pattes verticales
        },
        NULL // Une callback qui sera appelée à chaque fin d'exéction de la position
    },
    {
        DELAY_MIN,
        {
            __, __, __, __, __, __,
            DOWN, DOWN, DOWN, DOWN, DOWN, DOWN
        },
        NULL
    }
};

Puis créons la séquence en elle même :

sequence_t seq_pushup = {
    "Push up",  // Le nom de la séquence
    2, // Le nombre de mouvement dans la séquence
    motion_pushup // La structure de déplacement que nous avons créé plus haut
};

Maintenant, nous n'avons plus qu'à appelé la séquence ainsi :

// Pour la jouer en avant
bleuette.sequencer.forward(sequences[seq]);

// Pour la jouer à l'envers
bleuette.sequencer.backward(sequences[seq]);

Voilà pour cette introduction rapide, je vous invite à regarder le code, il est vraiment simple...

Évolution en cours

La prochaine évolution de Bleuette lui donnera de vrais pieds qui lui permettront de moins glisser mais surtout, lui donnera le toucher au travers d'un petit interrupteur, ainsi, en posant une patte, il pourra s'assurer que le sol est bien en dessous...

Voici une vue de ses bouts de pattes :

La partie inférieure (la demi sphere et le cylindre extérieur) est mobile et glisse dans le cylindre plus petit dans lequel se trouve un interrupteur poussoir, c'est ce dernier qui fait office de rappel mécanique.

La partie en contact avec le sol (la demi-sphere sur l'image) sera en PLA Flex afin d'obtenir un maximum d'adhérence.

Ses 6 pattes devraient en être équipées, pour cela, un circuit intégré (4512) branché sur le port OPTION permettra de sélectionner la patte à lire via une adresse sur 3 bits, on occupera ainsi seulement 3 bits de sorties pour l'adressage + 1 bit de sortie pour connaitre l'état (patte posée ou non).

Évolutions futures

Bleuette devrait être équipé d'une liaison Bluetooth, d'un capteur magnétique afin de garder un cap lorsqu'il marche et enfin, d'une tourelle mobile avec un capteur ultrason pour détecter les obstacles devant lui et tout cela intégré dans une seconde carte fille.
Bleuette se sentant un peu à l'étroit avec Arduino, il n'est pas totalement exclu que je porte le code pour tourner sur un Raspberry Pi...

Et bien entendu, Bleuette attend impatiemment des frères et soeurs : toute contribution est la bienvenue !

C’est un projet au long cours que je vous présente ici. Fabien avais besoin d’une petite fraiseuse pour usiner des PCB maison, de mon coté, je me demandais à quel point il était possible de miniaturiser ce type d’outils, et d’en réduire les coûts.
Le declic : Le déclic lui à eu lieu suite à une formation à l’utilisation d’une découpeuse laser. En effet, cette machine permettait d’atteindre une précision remarquable lors de la découpe, ainsi que de faire des angles droits sans les problèmes d’arrondis habituels lors des découpes à la fraiseuse. Là, en voyant ça, ça a fait tilt : c’est comme ça qu’il fallais fabriquer cette fraiseuse ! Pour tout dire, je n’en ai pas dormis de la nuit, commençant déjà à imaginer les plans. D’ailleur, au bout d’un moment, j’ai finit par me relever, histoire d’aller dessiner tout ça et pouvoir enfin me libérer l’esprit (3h du matin quand même ^^)
Le lendemain, je soumet mes plans à Fabien, qui est tout de suite séduit par l’idée :
Construire une micro fraiseuse, entièrement en contreplaqué emboîté, d’une surface inférieure à une feuille A4 de manière à pouvoir tenir facilement sur un bureau, et étant capable d’usiner des circuits au format europe (10x16cm).

Commence alors un gros travail de dessin industriel, à base de logiciel libre (librecad). Le procédé de découpe laser nous autorise à ne dessiner que les découpes, donc simplement en 2d. Après une première version sortie, on se rend rapidement compte que tout ne peut pas être anticipé facilement, et que si l’on continue simplement en 2D, on risque de devoir sortir beaucoup de prototypes avant d’arriver à une version correcte. Nous avons donc utilisé SolidWorks, uniquement pour faire l’assemblage de nos pièces, et ainsi valider les différentes jointures.

Le premier prototype sorti nous avais enchanté par la qualité de la découpe : C’était beau, c’était pro ! Malheureusement pour nous, le second résultat était déjà nettement moins réjouissant. En fait, sous la dénomination « contreplaqué » une grosse quantité de variantes, dans les plaquages, les colles, et les remplissages. Et en achetant le meme bois, chez le même fournisseur, nous avons eu la malchance de tomber sur deux séries différentes, avec un rendu complètement différent. Là où la première se découpait bien, avec des bords nets, la secondes brûlait, et nos assemblages se transformaient en petits tas de charbons. A force de recherches, on a fini par comprendre qu’il fallait du contreplaqué « tout okoumé », c’est à dire dont l’âme est également en okoumé, et non pas en peuplier comme c’est souvent le cas.

Concernant la partie mécanique, étant donné qu’elle est destinée au fraisage de pcb, peu d’efforts seront nécessaires, inutile donc de partir sur de gros moteurs. Nous avons donc utilisé des moteurs Nema11, qui offrent un couple largement suffisant pour une taille ridicule.

Les guidages linéaires se font via des douilles à bille glissant sur des stubs acier, l’entraînement est lui réalisé via une vis trapézoïdale.

Maintenant qu’on a les différentes pièces découpées, et qu’on a les différentes parties mécaniques, on peut commencer l’assemblage.

Reste maintenant à voir ce que ça donne, une fois motorisé.

On remet ça pour l’axe de Y, toujours selon le même procédé, ainsi que l’axe des Z. Comme on est du genre un peu impatient, on a fait un premier essai, avec uniquement l’axe X + Y, et en remplaçant la fraise par un stylo. Autant dire qu’on est plutôt satisfait de ce premier résultat

Concernant le pilotage de la CNC à proprement parler, on utilise une carte Arduino Uno, sur lequel est installé Grbl (pour l’interprétation du gcode). La partie puissance est confiée à 3 modules pololu A4988, le tout refroidit par un ventilateur de PC (on n’a pas mis de radiateur sur les pololu, et on va en avoir besoin).

Le fraisage à proprement parler sera confié à un moteur de mini-perceuse pour lequel je disposais des bons accouplements d’arbre, avec un mandrin de serrage. Malheureusement, il était assez ancien, et on sentait au fur et à mesure de nos tests que la fin approchais. Il a finalement finit par rendre l’âme, et nous avons du trouver une autre solution. Nous l’avons remplacé par un moteur du même type, un peu plus petit, malheureusement l’arbre n’était pas au même diamètre. Heureusement, Fabien a réussi à nous bricoler un couplage à partir du système Dremel.

Malheureusement pour nous, tout n’est pas allé comme sur des roulettes. Premier problème rencontré, l’Arduino se plante en plein milieu d’usinage (cf la photo du dessus). Quelques recherches plus tard, on trouve la cause (et donc la solution), sur certain déplacements (les 3 axes en même temps), notre alim ne suit plus. On met une alim plus puissance, et ça roule
En revanche, un autre problème plus bloquant se profile : les vibrations. En effet, le moteur utilisé n’est pas vraiment prévu pour cet usage, et vibre énormément. Pas sur son support, mais l’axe à l’intérieur de sa cage. Résultat, les premiers traits se passent bien, mais le temps aidant, on se retrouve à usiner un trait de 3mm d’épaisseur avec une fraise de 0.1mm
En revanche la structure en bois nous a convaincu : elle est suffisamment rigide pour que l’usinage se passe bien, et en cas de fausse manip (plantage de fraise à cause d’un mauvais zéro par exemple), l’ensemble plie, mais ne casse pas !

Où en est-on aujourd’hui ?
Le problème des vibrations n’est malheureusement toujours pas résolu. On cherche une solution permettant de coupler un axe moteur qui soit fiable, peu coûteuse, et qui limite au maximum les vibrations. De la meme manière, on recherche un type de moteur (un spindle), dont la taille soit adapté à notre fraiseuse, et surtout à un prix raisonnable. On en a en effet trouvé, mais à 500€, ce qui correspond au prix de la fraiseuse complète. Si des fois vous avez des idées, vous êtes les bienvenus !

Edit : toutes les photos et vidéos du projet sont disponible ici