Mot-clé - Arduino

Fil des billets - Fil des commentaires

Dimanche, avril 20 2014

Thermomètre Nixie Steampunk

Fan de ce style depuis pas mal de temps déjà, c’est ma première réalisation concrète. L’idée était de réaliser un (joli) thermomètre d’ambiance, histoire de savoir quelle température il fait dans la pièce. J’avais déjà réalisé un thermomètre à tubes Nixies, mais ce dernier avait deux défauts : les tubes n’étaient pas centrés sur le pcb, et il consommait un peu trop pour avoir envie de le laisser allumé en permanence (et en plus, il n’était pas « habillé »…).

Du coups, la première étape de cette réalisation a été de refaire un pcb complet. Pas simplement déplacer les tubes, j’en ai profité pour alléger le tout, histoire de supprimer les composants qui n’étaient pas nécessaires. En effet, sur la version précédente, j’utilisais un NE555 pour générer les impulsions nécessaires à la haute tension. Désormais cette tâche est réalisée par le microcontrolleur lui-même.

Schéma thermomètre Nixie

Schéma thermomètre Nixie

Quitte a devoir reprogrammer le microcontrolleur pour rajouter la génération de la haute tension, j’en ai profité pour tout ré-écrire en avrc. Ca me permet d’avoir un timing très précis, autant sur la génération du signal HT que sur le multiplexage des tubes. (La fréquence est importante pour la génération de la haute tension car elle joue pour beaucoup dans le rendement). Mon code aurais pu être grandement optimisé si j’avais un peu mieux réfléchi à mes branchements, mais sur ma version, je m’étais trompé sur certaines liaisons (ce qui expliquera les fils visibles sur les photos). Le schéma proposé corrige ces erreurs.

tarthermomètre nixie (AVRC)

 

Thermomètre à tube Nixie Steampunk

Thermomètre à tube Nixie Steampunk

Pour l’habillage, je me suis fait un peu plaisir. Les deux « chapeaux » sont en laiton, que j’ai tourné, moitié façon meca, c’est à dire en utilisant le tour de manière traditionnelle, moitié à main levée à l’aide d’une lime (pour les arrondis notamment). Le reste de l’accastillage est composé de différents tubes de laitons, diamètre 5 et 3mm, que l’on trouve facilement en magasin de modélisme.
Le tube est quand a lui un tube de plexyglass acheté pour l’occasion.

Socle vu de dessous

Socle vu de dessous

Le socle a été tourné dans un beau morceau de chêne, par un ami car je ne disposais pas de tour à bois, et le tour à metal n’est vraiment pas adapté à ce genre d’opérations. Le plot du milieu est assez profond pour que le tube laiton soit bien maintenu, mais ne va pas jusqu’en bas pour pouvoir laisser passer les fils. J’ai repris ensuite le socle tourné pour le fraiser afin de fixer le connecteur d’alimentation, et fait les 4 perçages nécessaires (2 pour les tubes verticaux, un pour le capteur de température, et un pour le connecteur d’alim).

Détail du capteur de température

Détail du capteur de température

Le capteur de température utilisé est un LM35. Pas particulièrement esthétique donc. Pour le masquer, je l’ai donc glissé à l’intérieur d’une douille de 22lr qu’un ami tireur m’a gentiment fourni. Le capteur est fixé à l’intérieur à la colle à chaud.

En fonctionnement

En fonctionnement

Dimanche, janvier 19 2014

DIY – shield PWM

Bon, petit montage pas bien compliqué à la demande d’un client : pouvoir utiliser tous les canaux PWM d’un arduino Uno, avec de la puissance.
Vous l’aurez deviné, un petit mosfet piloté par le PWM et le tour est (presque) joué. On y ajoute une diode de flyback (si on veut pouvoir y connecter par la suite des charges inductives), et des connecteurs, le tour est joué.

Shield PWM Arduino

Shield PWM Arduino

Bien sûr, il ne faut pas oublier l’alimentation de l’arduino (on utilisera un 7805 tout bête pour ça, accompagné d’un condensateur pour le lissage), ainsi qu’une petite diode signalant que le montage est en fonctionnement.
La charge que vous pourrez connecter à ce montage dépendra directement des mosfets choisis : 100v jusqu’à 9A dans mon cas, avec des IRF520. (Bon, en vrai les pistes du PCB ne devraient tenir que jusqu’à 4 ampères environ)
L’intérêt de ce montage, outre le fait de pouvoir piloter des moteurs CC, est de piloter les guirlandes de led RGB. En effet, en utilisant 3 cannaux, vous pilotez chaque composante de votre ruban de led, et la puissance disponible permet d’alimenter des rubans de grande longueur.

 

Shield PWM avec led RGB

Shield PWM avec led RGB

Samedi, septembre 14 2013

DIY – BOB le bipède

L’autre jour en surfant, je suis tombé sur ce petit projet sympa : BoB. Un petit robot bipède, avec une bouille tellement mimi que j’étais sûr que mon fiston l’adorerais. Comme en plus j’avais tout ce qu’il fallait sous la main pour en construire un, je me suis lancé :)

Tout d’abord, une petite liste de ce qu’il vous faudra :

  • Les pièces plastiques, imprimées
  • 4 servo-moteurs 9g
  • Un arduino micro, ou équivalent
  • un connecteur de pile 9v, ou mieux, une lipo 7.4v (2s)
  • Un lm7805
  • un capteur de distance à ultrason, de préférence avec 2 modules (pour faire les yeux)
  • quelques vis à plastique (récupérées sur de vieux portables par exemple).

Les pièces plastiques sont téléchargeables ici : http://www.thingiverse.com/thing:43708

Le montage ne pose pas de soucis particulier. Il faut fixer un servo sur chaque pied, et deux autres servos sur la base.

Le montage de la base

Le montage de la base

Pour ceux à qui l’assemblage ne paraîtrait pas logique, vous trouverez un guide d’assemblage détaillé ici : http://www.instructables.com/id/BoB-the-BiPed/

Contrairement à ce qui est indiqué dans cet instructable, en utilisant un arduino micro et une pile 9v (ou une petite lipo), tout rentre dans le boitier, à l’exception d’un interrupteur que j’ai fait ressortir pour pouvoir allumer/éteindre la bête.

Voici une petite présentation de la tête de notre nouvel ami, juste avant de passer à l’alésoir,  afin de faciliter le passage des yeux capteurs ultra-son.

P1020169

Lors de l’assemblage, je vous recommande vivement de noter la correspondance entre les servos et les pins de l’arduino, vous serez amené à les configurer dans le programme, et une erreur empêchera notre ami de se déplacer.

Une fois tout assemblé, il faut centrer les servos, à l’aide d’un petit programme arduino les positionnant à 90°. lorsque les servos sont à 90°, les pieds doivent être à plat, et les jambes bien centrées. Si ce n’est pas le cas, modifiez l’angle du servo jusqu’à tomber au plus juste, et notez la valeur correspondante (vous devrez la modifier dans le programme). Faîtes bien cette manip pour chaque servo.

Exemple de programme de centrage :

#include <Servo.h>
Servo servo;
void setup()
{
servo.attach(9);  //changez cette valeur pour chacun des servos à centrer
}

void loop()
{
servo.write(90);
}

Une fois ceci fait, téléchargez le code source ici : http://letsmakerobots.com/node/35877

Il vous faudra modifier au moins deux partie du code :
- La première partie se situe en en-tête du fichier, et correspond aux pins rattachées à vos servos. Notez que Hip sont les cuisses et Ankle les pieds.
- La seconde se situe en fin de fichier, dans les fonctions NormalWalk et ShortWalk. C’est ici que vous pourrez modifier le centrage de vos servos (selon les relevés que vous aviez fait précédemment), ainsi que les angles max (souvent limités par le plastique qui arrive en butée)

Une fois ceci fait, il ne vous reste plus qu’à compiler/uploader, et à admirer votre petit robot se dandiner sous vos yeux (et moi admirer mon fiston s’émerveiller :))

BoB le bipède

BoB le bipède

Vendredi, mai 17 2013

DIY – Thermomètre à tube Nixie

Ce projet, qui m’aura occupé quelques temps, est parti de trois points :

- Je n’avais pas de thermomètre chez moi, et ma femme et moi n’avons pas tout à fait la même sensibilité à la température, cela permet de donner une valeur objective et d’ajuster en conséquence (soit on met le chauffage, soit l’autre enfile un pull ;) )
- J’avais besoin de tester un circuit de commutation pour tubes Nixie (spoiler : dans le but de réaliser une horloge), mais sur un nombre limité de tube, car en cas d’erreur, c’est très pénible de dessouder le tube et de le ressouder
- J’avais envie de réaliser un montage CMS le plus compact possible, et de tester au passage la mise en oeuvre de CMS taille 0402.

Si si, il y a un composant sur C6. La LED est une 5mm, placée là pour donner l'echelle.

Si si, il y a un composant sur C6. La LED est une 5mm, placée là pour donner l’échelle.

Le montage se divise donc en 4 parties : la mesure de la température, effectuée par un vénérable LM35 (mais le montage permet aussi l’utilisation d’un LM73 plus précis) ; l’élévation de tension pour alimenter les tubes, le contrôle des tubes, et le pilotage de tout ça, réalisé par un Atmega328, version cms évidemment.

Le schéma d'ensemble

Le schéma d’ensemble

La partie mesure de température ne nécessite pas d’explications particulières. A noter simplement que le LM73 fonctionne en I2C, et que dans ce cas, il faut impérativement mettre les résistances de pullup R6 et R7. Dans le cas du lm35, elles ne sont plus nécessaires car ce dernier fonctionne en analogique, la sortie de celui-ci étant à connecter à la broche 4 de l’emplacement du lm73 (A5/SCL sur l’atmega).

La partie élévateur de tension est désormais classique sur mon site, il s’agit de la même que pour mes compteurs geiger, à savoir NE555 + Mosfet + bobine. Un petit condensateur 400v sert à lisser la tension obtenue.

La mise en oeuvre de l’AtMega328 n’a rien de spécifique. Il faut en revanche noter deux connecteurs, un connecteur ISP, et un connecteur permettant de brancher un adaptateur série. Le premier devant servir à charger le bootloader Arduino sur l’Atmega, le second à charger le programme/débugger comme s’il s’agissait d’un simple Arduino. Pour une raison que j’ignore, bien que le bootloader soit correctement chargé, il n’a fonctionné que sur une seule de trois cartes que j’ai assemblé. Après tests, la communication série s’effectue correctement et dans les deux sens, mais impossible de flasher l’atmega par ce biais (si quelqu’un a une idée…). Du coups, la programmation se fait via ISP, et le debug par la connexion série.

La partie la plus intéressante de ce montage est la partie pilotage des tubes nixie. Un des objectifs était de réaliser le montage le plus compact possible, exit donc les drivers type 7441, tout sera fait ici à base de transistors.
Afin de ne pas trop consommer, l’affichage des 2 digits ne se fera pas simultanément, mais l’un après l’autre, de manière très rapide, la persistance rétinienne se chargeant de donner l’impression d’un affichage fixe.
Coté cathode, les transistors sont dans une configuration peu courante : la base est commune à tous les transistors, en permanence à +5v, ce qui permet de n’avoir qu’une seule résistance (mais qui impose de n’utiliser qu’un seul digit à la fois). La commutation se fait en ramenant l’émetteur du transistor voulu à  0v. Dans cette configuration, il faut autant d’entrées/sorties sur le microcontrolleur que de digits, mais en l’occurrence, l’Atmega nous en propose nettement plus que nécessaire dans notre cas.

Le driver coté anode

Le driver coté anode

Coté anode, il aurais été possible également de mettre un simple transistor NPN avec une résistance pour faire le travail. Cependant, la consommation « à vide » aurais été supérieure à la consommation lors de l’affichage sur un tube, ce qui n’est clairement pas le but recherché.
Le montage ci-dessus « coupe » le courant, en limitant les pertes à des valeurs infimes. La résistance R12 et le transistor NPN forment un driver de courant constant, réglé de manière à laisser passer juste le courant nécessaire au déblocage du transistor PNP.

Thermomètre Nixie

Le thermomètre Nixie assemblé

Le circuit complet tiens sur un PCB de 5x5cm double face. J’aurais probablement pu faire encore plus petit, mais ça me semblais déjà un bon début !

Le circuit vu du dessus

Le circuit vu du dessus

Concernant l’assemblage du PCB, rien de spécial à mentionner, celui-ci étant étonnamment plus facile à assembler que ce qu’il pourrais sembler au premier abord, et ce, malgré le fait que j’ai soudé des résistances 0805 sur des emplacements 0603 (donc un peu plus petits que les résistances). Ayant fait plusieurs essais, j’ai testé différentes techniques de soudure, je vous ferais un petit topo là-dessus dans un prochain article. Globalement, si on omet les 2 composants 0402 (taille qui n’était pas impérative du tout, mais pour faire des tests), ce n’est pas vraiment plus compliqué qu’avec du traversant, au contraire même.  Le circuit intégré demande un petit coups de main, mais ça se fais très bien, et très rapidement. Les 0402, pour le coups, sont assez délicat à placer, leur petite taille faisant qu’ils se collent à la pane du fer à souder par capillarité, et leur taille nécessite de bons yeux en plus d’une bonne loupe (idéalement, une bino)

Enfin, pour finir, le code source, qui n’a rien de très spécifique, il se contente de récupérer la valeur du lm35, et décomposer le résultat obtenu en deux digits, les unité et les dizaines.

thermometre

Lundi, mars 25 2013

Des nouvelles de Bleuette

Point presse

Tout d'abord, un point people, l'information du développement de Bleuette à plutôt bien circulée et Bleuette s'est retrouvée sur plusieurs sites importants :

La vidéo sur Vimeo à été vue plus de 6000 fois.

Plutôt plaisant de voir que ça intéresse du monde mais j'attends avec grande impatience le moment ou un autre Bleuette pointera le bout de son nez en PLA... ;)

Évolutions

Nouvelle carte fille

La shield Bleuette permet le pilotage des servos et le contrôle de la tension / courant consommé par les servos, pour pouvoir ajouter des capteurs multiples, il est tout à fait possible d'utiliser les broches libres des ports de l'Arduino mais il n'y en a pas assez pour tous les capteurs voulus sur Bleuette, du coup, le besoin d'une nouvelle carte d'extension s'est fait sentir et voici ce qu'elle permet :

  • 8 entrées supplémentaires multiplexées utilisant que 4 entrées / sorties (3 d'adressage et une sortie)
  • Connection pour une carte GY-27 contenant un accéléromètre et un compas
  • Un module Bluetooth JY-MCU
  • Une connection pour une guirlande de led RGB à base de LPD8806
  • Un mosfet pour pouvoir piloter un élément de puissance (je ne sais pas vraiment quoi pour le moment...)

Voici le schéma de principe et le PCB associé (cliquez dessus pour agrandir) :
Schéma de principe de la carte d'extension de Bleuette PCB de la carte d'extension de Bleuette

Le schéma de principe au format est Eagle se trouve par ici : sensor.sch et le PCB : sensor.brd

Comme vous pouvez le voir, le PCB n'est pas dense du tout, du coup, il est simple à réaliser avec des moyens modestes.

Mécanique

Pas de grande nouveauté pour la partie mécanique sauf pour les pieds, ces derniers ont été imprimés en PLA Flex permettant d'avoir un peu de souplesse et trempé dans du PlastiDip afin d'avoir un meilleur grip en plus d'un super rendu !

Avant trempage dans le PlastiDip et après :
Les pieds de Bleuette

Tous les éléments d'un pied de Bleuette, on aperçoit l'interrupteur poussoir, le piston et le cylindre et le pied recouvert de PlastiDip :
L'ensemble des pièces constituant un pied de Bleuette

Le tout assemblé :
Vue d'un pied

Le fichier source au format OpenSCAD des pieds de Bleuette est disponible, comme tout le reste de Bleuette sur GitHub / Bleuette.

Le cerveau

J'ai subi beaucoup de soucis avec la carte Arduino, notamment des problèmes de programmation, m'obligeant à recommencer la phase 3-4 fois de suite des fois...
Tous ces ennuis m'ont conduit à radicalement changer ma manière de développer avec Arduino, notamment en utilisant Ino, un outils en ligne de commande pour compiler, programmer, etc, bref, un remplaçant du mal aimé environnement par défaut d'Arduino.

Les problèmes de liaison avec la carte Leonardo m'ont également conduit à une solution radicale, j'ai embarqué un Raspberry Pi dans Bleuette auquel est relié la carte Leonardo, ainsi, c'est le Raspberry Pi qui programme la carte Arduino, ça complique un peu mais au moins, je suis moins gêné...

À force d'utiliser ce système, ce qui devait arriver arriva et j'ai donc décidé de créer une carte fille pour le Raspberry Pi qui permettra de piloter Bleuette directement avec cette dernière.
Bien entendu, je ne laisse pas tomber pour autant le dèveloppement sur Arduino, disons que celui ci sera la version simplifiée.

Bleuette embarquant un Raspberry Pi :
Bleuette embarquant un Raspberry Pi

D'ici peu, je publierai un article expliquant toutes les caractéristiques de la carte d'extension pour Raspberry Pi.

Mercredi, février 20 2013

DIY – Bobineuse à l’arrach’

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.

Sans assistance, ce genre de bobine tourne vite au cauchemard

Sans assistance, ce genre de bobine tourne vite au cauchemar

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.


media

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.


media

Lundi, février 11 2013

DIY – Compteur geiger, dosimètre

Ceux qui me suivent depuis un petit moment déjà auront remarqué qu’il ne s’agit pas là de mon premier coups d’essai. Mon précédent compteur geiger fonctionnait bien, mais j’avais envie (besoin) d’avoir une info un peu plus précise que ce que peuvent apporter une série de « bip-bip » plus ou moins rapprochés. C’était également pour moi l’occasion de ne plus seulement survoler l’aspect fonctionnel de la chose, mais faire en sorte d’avoir une mesure cohérente, en rapport avec les specs précises du tube utilisé un SBM-20 (СБМ-20), un grand classique.

Pour ce montage, le but étant la mesure, hors de question donc de me contenter d’une tension « à peu près » comme pour le montage précédent. Et comme j’ai également besoin de remonter des infos plus précises, passage (quasi) obligé par un écran LCD, et donc un microcontrolleur. Cependant, je trouvais que l’information « analogique » gardait un certain intérêt (instantanée), et un petit coté « ambiance » pour le bi-bip.

Dosimètre

La nouvelle version du compteur geiger.

Le montage comporte donc parties distinctes :

  • L’alimentation haute tension, qui délivrera 400V (et pas plus ;) )
  • Le tube geiger qui fera la détection
  • Le microcontrolleur qui comptera le nombre d’impulsions et affichera la mesure sur l’écran LCD
  • Un mini circuit audio, piloté par l’arduino, qui donnera les pulses audio.

La partie alimentation, est un montage élévateur simple, à base de NE555, mosfet et inductance. Il s’alimente entre 9 et 12v et permet d’obtenir une tension supérieure aux 400v requis (dans les 480v). Un condensateur 600v est placé en sortie afin de lisser la tension, et de parer aux pics de consommation induits par le tube lorsqu’il est en présence de matériaux très radioactifs. La tension est ensuite limitée a 400v via deux diodes zener de 200V en série.Lors de mes premiers tests, je n’avais pas mis les zener, et le tube était en état de saturation quasi-permanente, faussant ainsi toute mesure.

A la sortie du tube, le signal est récupéré par un optocoupleur, afin de transmettre l’information au microcontrolleur sans les parasites qui vont avec. Une petite subtilité ici, une LED est placée en parallèle de l’optocoupleur, elle m’a servis lors de la mise au point notamment, afin de m’assurer que les taux mesurés étaient bien identiques des 2 cotés de l’optocoupleur.

La partie microcontrolleur est assurée par un Arduino très fortement dépouillé ;) Je n’ai gardé que l’Atmega328p, le quartz et les condensateurs… La programmation peut se faire ultérieurement en connectant un adaptateur usb2serial à l’emplacement prévu. Je n’ai pas prévu de connecteur ICSP, il est donc impératif d’utiliser des Atmega avec un bootloader préchargé.
Le comptage des impulsions se fait en comptant non pas les fronts montants, mais les fronts descendants. En effet, le comptage des fronts montants était trop soumis aux perturbations de l’alimentation HT à proximité, alors qu’avec les fronts descendants, plus de soucis. Le pullup interne de l’arduino est donc activé, lorsque l’optocoupleur devient passant, la tension à la borne de l’arduino devient nulle. Le comptage se fait en utilisant une interruption matérielle, qui incrémente un compteur, en parallèle de l’incrémentation d’un timer.

Schéma dosimètre

Schéma dosimètre, cliquez pour télécharger le PDF

Comme indiqué précédemment, la pulse audio est envoyée par l’arduino, plutôt qu’en prise directe. Deux intérêts à cela : pas de perturbation de la mesure du fait de problèmes d’impédances, et ça me permet un debug plus facile en comparant cette sortie à l’état de la led placée en parallèle de l’optocoupleur.

Les prochaines étapes : le faire étalonner par un copain qui bosse au CEA, histoire de valider la mesure, et ressortir un joli PCB qui va bien pour une jolie mise en boîtier. Bref, vous l’aurez compris, une version 3 est sur les rails, mais les modifications seront essentiellement cosmétiques.

Pour finir, une petite vidéo du montage en fonctionnement :


media

Le code source du programme :  Dosimetre.pde

Nouvelles avancées de Bleuette !

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 :
La carte électronique de Bleuette

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 :

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 :
Le bout de patte faisant office de capteur

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 !

- page 1 de 5