DIY Planet : Made in Fr

DIY – Thermomètre à tube Nixie

Éric G. — Fri, 17 May 2013 20:19:20 -0400

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’é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

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

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.

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

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

DIY – Savon maison, le retour…

Éric G. — Sun, 12 May 2013 19:31:14 -0400

Le premier test m’avais bien plu, et j’avais trouvé l’opération amusante. Vu les quantités que j’avais fait la dernière fois, mes savonnettes sont passées assez vite. J’ai donc décidé de remettre ça, mais cette fois « pour de vrai », avec des ingrédients sympa, en plus grosse quantité, et au passage, en impliquant Madame

Premièrement, la recette

Lors de ma précédente tentative, je n’avais utilisé que de l’huile d’olive, et la première huile essentielle qui me tombais sous la main, à savoir du clou de girofle. Bon, ça marchait bien, ça allais bien pour se laver les mains, mais c’était quand même pas le savon le plus appétissant que je connaisse…
Cette fois-ci, on va s’ouvrir un peu plus l’appétit avec du savon à l’huile de coco et à la vanille.

Les ingrédients

Voici la liste des courses :
200g d’huile de coco (plus du beurre en fait, mais ça s’appelle huile quand même)
400g d’huile d’olive
85g de soude caustique
200ml d’eau

Première étape, peser les ingrédients

La soude

Comme le nom de l’étape le laisse deviner, on pèse chacun des ingrédients dans des récipients séparés. Pour la soude, j’ai préféré bricoler un récipient en papier plutôt que d’utiliser de la vaisselle de cuisine ou un récipient en plastique dont la tenue à la soude n’était pas garantie.

L’huile de coco

Bon, alors l’huile de coco, ça a deux caractéristiques : Ca ressemble à du saindoux, mais ça sent sacrément bon ! (a tel point que ça donne envie de la goûter tel quel)

Seconde étape, mélanger

Alors là, pas question de faire n’importe quoi, la soude est un produit dangereux. Blouse, lunettes (de chimie) obligatoires (gants vivement conseillés au passage).
Il faut tout d’abord dissoudre les cristaux de soude dans l’eau. La réaction est exothermique, et peut dégager des fumées, il est donc recommandé de faire ça sur le balcon. Donc, dans le saladier, verser l’eau, puis, petit à petit (cuillère à cuillère), verser les cristaux de soude dans l’eau, et remuant (avec un autre instrument que celui qui vous sert à prendre les cristaux de soude!). Je le rappelle, pour ceux qui sont pas habitués, pas d’eau dans la soude, toujours la soude dans l’eau, sinon il y a risque de projections.

Une fois cette étape réalisée, il faut mélanger les corps gras à la soude, de la même manière, en procédant petit à petit au début, puis plus franchement.

Vu comme ça c’est pas appétissant, mais ça sent bon !

Après avoir un peu touillé à la cuillère, je vous conseille de passer au mixer, car il va falloir mélanger longtemps…
Il faut donc mélanger jusqu’à la trace, qui prend entre 15 et 30 min en fonction en la température entre autre. Pour pas tuer votre mixer, je vous conseille de faire ça par tranche de 5 min, avec des poses pour le laisser refroidir entre chaque.
Au bout d’un moment, le mélange commence à épaissir, et le filet qui coule du mixer laisse une marque en surface. C’est la « trace ».

La trace

A ce moment là, vous pouvez ajouter les huiles essentielles (de vanille donc, dans mon cas).

Troisième étape, le moulage et le séchage

Bon, là, faites pas comme moi, et prévoyez suffisammentde moules pour vos savons ! J’avais prévu de jolis moules à madeleines, mais une fois ceux-ci remplis, il me restait encore les 3/4 de la préparation ! Résultat des courses, j’ai mis le reste dans un bac de glace, pour les découper en tranches de 2cm d’épaisseur une fois durcis.

Les savons moulés

Là encore, l’odeur est très appétissante, combinée à la forme de madeleine, on en mangerais
Au bout de 2/3 jours, il faut les démouler. Il est possible de les entourer de film alimentaire pour qu’ils ne blanchissent pas.

Reste maintenant la partie la plus difficile : attendre ! J’avais testé mes précédents savons au bout d’un mois, et ils étaient encore un peu irritants. Au bout de 2 mois en revanche, ils étaient parfaits ! Je pense donc ne pas utiliser ceux-là avant le mois de Juillet, mais promis, je vous ferais un retour à ce moment là !

Capteur optique de vitesse et sens de rotation (2)

Éric G. — Thu, 25 Apr 2013 10:35:10 -0400

Deuxième partie : de l’idée à la mise en oeuvre.

Passons donc, comme promis, à la construction de ce capteur de vitesse ET sens de rotation.

D’abord, dessiner le patron. Je choisis de faire 3 largeurs de franges sur 24 degrés selon le dessin suivant (Fig 4).

Fig. 4 : Patron du premier codeur

Les fronts « noirs » seront régulièrement répartis tous les 8° dans le sens trigo, cette répartition régulière pourra être la base de la mesure de vitesse, en se basant sur les fronts montants pour un sens de rotation, descendants pour l’autre sens. La première frange occultante aura 2° de large, la deuxième 4°, et la dernière 6°. Ceci répété 16 fois pour faire le tour. J’aurai donc une roue dentée à 48 créneaux par tour, ce qui suffit bien pour la précision dont j’ai besoin. Le premier prototype sera fait d’une roue dessinée sur l’ordinateur, imprimée sur un film transparent, découpée grâce aux petits ciseaux de couturière piqués à ma charmante épouse, et collée à nouveau sur un bouton de potentiomètre placé sur l’arbre moteur. Résultat nul : imprimante jet d’encre sur film transparent = pas du tout opaque, les variations de signal sont trop faibles. Je l’imprime sur du papier blanc, collé sur film plastique pour rigidifier, puis découpé aux ciseaux : c’est mieux au niveau du signal, mais mes découpes sont imprécises et les différences de largeurs de bandes sont trop irrégulières pour permettre une détection fiable du sens de rotation. C’est en plus très fragile. Néanmoins, le principe est validé : les créneaux obtenus à l’oscillo étant bien identifiables lorsque la fabrication des encoches est correcte (voir photo 5).

Photo 5 : Codeur « papier »

Je construis un modèle STL, en réduisant un peu la résolution pour faciliter la fabrication (10 séries de 3 encoches sur 360° au lieu de 16) et l’imprime sur une RepRap… mais le plastique est trop translucide et je ne peux pas augmenter l’épaisseur sinon elle ne passera plus dans la fourche !! De plus la précision de la Reprap est trop limite, et les bords pas nets car les fils de PLA (le plastique utilisé) bavent un peu… les durées différentes sont difficilement identifiables (illustration 6).

Illustration 6 : Mauvais signal avec la roue en PLA

Tant pis, je passe à l’imprimante 3D Z-builder (flashage de résine UV par un vidéo projecteur) à laquelle j’ai aussi accès (merci Gi-Nova, et merci Christofer !) et obtiens enfin un modèle suffisamment précis, rigide, opaque… (illustration 7) qui va permettre de mesurer vitesse et sens de rotation de mes moteurs (vitesses variant de -120 à +120 tr/min).

Illustration 7 : Roue en résine photosensible

Et voici la roue codeuse sur le système final en cours d’assemblage… (photo 8).

Photo 8 : Roue codeuse en place

Pour la partie logiciel :

Afin de compter de manière fiable les fronts, j’ai opté pour l’utilisation d’interruptions, une qui compte les fronts montants et enregistre leurs dates, une autre pour les fronts descendants. Sur l’Arduino, le plus simple et fiable que j’ai trouvé est d’utiliser 2 entrées différentes pour cela (et comme entre temps j’ai investi dans un MEGA, cela ne me pose plus de gros soucis ). Le programme principal calcule alors la largeur (durée) des créneaux par différence de dates, conserve toujours les 3 derniers créneaux, et fait les calculs lorsque le créneau détecté est plus grand que les 2 précédents.

Pour être précis, notons ces durées (délai entre front montant et front descendant) dt1, dt2, dt3 dans l’ordre d’apparition. Nous venons de dire que au moment où nous faisons le calcul de vitesse et de sens dt3 est supérieur à dt1 et dt2. Alors si dt1<dt2, le sens de rotation est direct, mais si dt1>dt2, le sens de rotation est indirect. Dans le sens direct, la fréquence des fronts montants est à peu près régulière et permet de calculer assez précisément la vitesse angulaire de la roue codeuse (nombre de fronts montants comptés, ramené au temps passé depuis le dernier calcul). Dans le sens indirect ce sont les fronts descendants qui sont réguliers.

Voili-voila. Si vous avez besoin d’un capteur de vitesse vous donnant le sens de rotation : Do It Yourself !

Phil.

Une Borne d'Arcade maison -38-

Makoto Doushite — Tue, 23 Apr 2013 15:15:00 +0200

Suite de l'étude précédente :

Attention, ce billet peut ressembler à la fin du projet, mais il s'agit juste d'une partie des derniers travaux ! Néanmoins ceux qui attendaient de voir le meuble terminé vont être servit ^^;

Il reste en effet quelques bricoles à faire, comme le monnayeur, les artworks latéraux, la configuration graphique Pixel Perfect, la config détaillée de l'émulateur, la mise en place de l'éclairage, une grille de protection sur la trappe de maintenance, et autres trucs qui me passeront par la tête pour faire évoluer la machine…

Les cales :

Durant une semaine, j'ai mis en couleurs les tasseaux servant de cales au meuble.

Cette fois-ci, j'ai appliqué la sous-couché et la peinture au pinceaux, en utilisant le même blanc que sur la borne, auquel j'ai mélangé un peu de noir (petit pot Pébéo Déco) pour faire un gris pas trop moche…
En 3 ou 4 couches poncées au 600 entre chaque.

Marquee :

Je me suis occupé du découpage des deux pièces de plexis destinées au chapeau, que l'on appellera marquee…

Découpés aussi les trous pour les haut-parleurs et retiré le film protecteur :

Instruction Cards :

De même, découpage du plexis pour l'emplacement de l'instruction cards, vissé dans le panel.

Les vis seront cachées par des bandes de carte plastique d'un mm d'épaisseur, peintes en Chainmail (Couleur Games WorkShop Citadel)
J'aurais pu la fabriquer, mais bon… J'ai préféré acheter une véritable fente à pièces japonaise, que j'ai dû limer pour laisser passer les pièces en €, étant donné que les ¥ sont plus fines.

Puis j'ai simplement reporté et découpé la fente dans le panel, pour enfin y visser cet Entry Coin.

Bezel :

Long travail sur le bezel, désolé, pas beaucoup d'images pour ce travail ingrat de ponçage à la lime destiné à jointurer correctement la carte plastique que j'avais donc collé sur le bezel de la télé.

La nature de son plastique étant par chance la même que la carte plastique (styrène) les deux matières avaient bien fusionnées lors du collage à la colle qui va bien (Tamiya Extra Thin, ou Mr. Hobby Mr.Cements), rendant l'opération aisée… Si certains endroits n'étaient pas correctement liés, un peu de mastic (Sintofer ou Tamiya Putty) ont arrangé la jointure.
Mais c'est bien après le sous-couchage à la bombe (Citadel Games WorkShop Black Chaos) que les défauts des jointures ont le plus sautés aux yeux, nécessitant une seconde séance de masticage/ponçage !

Une petite vidéo ^^

Si la Vidéo ne s'affiche pas, c'est que vous utilisez un navigateur obsolète !
>>Télécharger Firefox<<

On y voit le passage de la sous-couche, on n'y voit pas le passage à l'aérographe d'une couche de noir (Pébéo Déco) dilué au liquide nettoyant les vitres, et enfin on y aperçoit rapidement une couche de Klir, ce produit vitrifiant les sols, mais aussi les poumons, d'où l'utilisation du masque à cartouche !
Ce produit qui n'est en effet pas prévu pour être pulvérisé a tout pour plaire au bricoleux, super vernis résistant, ultra-bon marché, et qui ne jaunis pas.
Bref, un bezel arrangé avec des techniques de maquettistes, bien utiles !

Et donc le résultat, en peinture :

Puis avec le vernis Klir :

Artworks :

Après quelques heures de dessin vectoriel sur inkscape (dispo en annexe du billet), j'ai pu imprimer les marquee et les mettre en place.

Le carton de calendrier va rester en place tel qu'il est disposé, dans le but de maintenir en sandwich le marquee et d'opacifier les zones qui ne seront pas illuminées par le tube fluo.

Il sert aussi de support aux coffrages des hauts parleurs, recouverts de colant noir en guise de grille de protection.

Ordi :

Un truc dont je n'avais pas encore parlé, c'est le décès de la carte mère d'origine.

Déjà bancale, elle ne voulait plus rien savoir, et a donc été remplacée par un modèle équivalent (P4 2Ghz - 512Mo) mais plus petit pour lequel j'ai confectionné un boitier sur mesure avec du contreplaqué de récup.
Cette carte mère a aussi permis le déport de la prise casque et de ports USB, grâce à sont front panel dont j'ai rallongé les câbles.
De plus, le système fonctionne maintenant depuis une clé USB !!

Photos :

Voilà, je vous laisse avec cette séance photos et une petite vidéo !

Légende :
- En vert pour Advance Mame.
- En Rouge pour Advance Menu.
- En bleu, ces boutons sont reliés directement au front panel de la télé, sur les boutons de volume.

Si la Vidéo ne s'affiche pas, c'est que vous utilisez un navigateur obsolète !
>>Télécharger Firefox<<

À suivre…

Capteur optique de vitesse et sens de rotation (1)

Éric G. — Tue, 23 Apr 2013 11:47:58 -0400

Bonjour à tous. Aujourd’hui, je ne suis là que pour ce petit édito, car j’ai le plaisir d’accueillir mon premier invité sur ce blog, à savoir Philippe, qui va vous présenter un sujet très bien documenté, et qui j’en suis sûr vous sera utile !

Hello, voici mon premier article dans l’esprit « DIY », soyez indulgents svp ;-)

Merci aussi à Eric de me prêter une petite place dans son blog

Dans le cadre de la fabrication d’un système mécanique à plusieurs arbres (un train épicycloïdal pour être précis), j’avais besoin de mesurer les vitesses de rotation de chacun d’eux… en fait la vitesse ET le sens de rotation. N’ayant pas trouvé ailleurs de système équivalent à celui que j’ai mis au point, je me dis que cela vaut le coup de partager cette idée avec les bricoleurs intéressés.

Première partie : du besoin à l’idée.

Parmi les capteurs de vitesse (souvent capteurs de mouvement incrémentaux pour ce type de mesure) on trouve diverses techniques, parmi lesquelles des technologies magnétiques (sur certains compteurs de vitesse pour vélos par exemple) ou des solutions optiques sur lesquelles nous allons nous concentrer dans la suite.

Une solution simple pour construire un capteur de vitesse est d’utiliser une fourche optique (LED d’un côté + photo-transistor de l’autre) dans laquelle on fait passer un disque ajouré. Avec une fourche simple de ce type, connectée sur une entrée numérique d’un microcontrôleur, il est possible de compter un nombre d’impulsions par seconde et donc une vitesse de rotation en fonction du nombre de rainures disposées sur le disque codeur. J’ai donc commencé par effectuer quelques tests sur la base d’un cadran translucide de bouton de potentiomètre sur lequel j’ai collé des adhésifs radialement pour simuler des rainures radiales (photo 1). Une petite fourche et son électronique d’alimentation (récupérée sur un capteur de fin de course de Reprap, merci Pierrot), et me voici à mesurer la vitesse d’un petit moto-réducteur DC en comptant les interruptions sur une carte Arduino UNO. Petit gag (mais ça marche très bien quand même) : j’ai bien placé mon adhésif sur les 10 chiffres noirs du cadran de potentiomètre, mais l’adhésif n’est pas complètement opaque, et on voit donc passer sur l’oscillo les chiffres qui masquent le faisceau lumineux plus efficacement que le scotch orange !

Photo 1 :

Codeur optique – premier test

Il est aussi possible avec cette technologie de déterminer le sens de rotation… à condition d’ajouter un 2^e photo-transistor judicieusement placé à côté du premier. Le signal optique reçu par le 2^e transistor étant décalé temporellement par rapport au premier, on obtient des signaux en quadrature dont le sens de déphasage permet de déterminer le sens de rotation. Voir l’excellent site de « Rémy Sonelec » pour plus d’explications sur ce type de codeur :

http://www.sonelec-musique.com/electronique_theorie_encodeur_optique.html

Et sachez que la plupart d’entre vous (sauf peut-être les plus jeunes) ont utilisé pendant des heures ce genre de capteur, puisqu’il a équipé la grande majorité des souris à boules pendant des années (Photo 2).

Photo 2 :

Souris a boule : 2 photo-transistors

(source : http://fr.wikiversity.org/wiki/Capteur/Capteur_de_position )

Inconvénient de cette technique à deux transistors : il faut doubler le nombre de photo-transistors (eh oui). En outre, plus il y a de capteurs = plus il y a d’entrées utilisées sur le micro-contrôleur… Or je prévoyais pour mon application de mesurer les vitesses de 3 moteurs, de piloter un afficheur LCD, ainsi que quelques autres éléments consommateurs de ports… incompatible avec l’Arduino UNO L. D’où la recherche d’une solution nécessitant un seul photo-transistor pour avoir la vitesse ET le sens de rotation d’un codeur optique… Comment faire ?? Eh bien appliquer ce que l’on enseigne aux élèves ingénieurs concepteurs de produits innovants : la méthode TRIZ ! Pour ceux qui ne connaissent pas voici un point de départ : http://www.triz40.com

Au-delà des 40 principes et des matrices de contradiction, TRIZ est aussi un état d’esprit, une manière de réfléchir. J’avoue donc que je n’ai pas passé en revue tous les tableaux fournis dans la méthode. Je trouve intéressant d’essayer de vous expliquer le raisonnement…

Ne voulant pas me palucher tous les tableaux et principes de Triz, j’ai donc simplement essayé d’utiliser un principe de générique de la méthode : « regarder le problème autrement, à l’envers, en séparant ou regroupant des éléments, en inversant ou permutant des paramètres… ». Voici en synthèse a posteriori ce que cela peut donner :

Les capteurs à fourche existants (souris, etc.) utilisent la séparation spatiale des récepteurs, qui sont fixes (2 photo-transistors) pour générer une séparation temporelle de 2 signaux. Mais je ne veux pas utiliser 2 récepteurs différents : contradiction. Que pourrait-on inverser ou permuter dans ce schéma, que pourrait-on regarder autrement ? Utiliser une « séparation temporelle » plutôt que spatiale ? Cela voudrait dire quoi ?…

Ne pas travailler du côté du récepteur, mais du côté de l’émetteur ? Mais l’émetteur, c’est quoi ? La LED qui est émet la lumière ? Non, ce n’est pas elle qui génère le signal proportionnel à la vitesse de rotation : c’est la roue rainurée. à La roue pourrait-elle générer une variation temporelle du signal ? Ca voudrait dire des signaux irréguliers ? Bof, que pourrais-je en déduire ? Ou des signaux réguliers mais de durées différentes ? Et alors ? Poursuivons quand même : peut-être donc si je ne faisais pas des rainures toutes identiques… une large, une étroite, une large, une étroite ? Les durées de 2 créneaux successifs seraient différentes. On revient à une décomposition spatiale (variation de largeur des rainures) pour générer une séparation temporelle, mais cette fois sur la roue au lieu du transistor. Non cela ne marche pas, j’aurai une alternance de signaux court-long-court-long quel que soit le sens de rotation. Aucun intérêt… ne jamais abandonner J … poursuivons… si 2 largeurs de rainures ne suffisent pas, mettons-en 3 ! Oui… avec une succession de rainures de largeurs 1 ;2 ;3 ;1 ;2 ;3 ;1… qui génère des signaux de 3 durées différentes ordonnées de même, la permutation des trois valeurs deviendra « impaire » lorsque le sens de rotation va changer : 1 ;3 ;2 ;1 ;3 ;2 ;1 ;3 ;… Je crois que c’est gagné !! Il suffira de regarder dans quel ordre passent les créneaux de différentes largeurs.

Concrètement, ceci s’est traduit par quelques nuits de réflexion, et quelques « gribouillis » sur le tableau blanc des enfants…

Premier croquis du codeur à sens

Dans le prochain article… la mise en oeuvre pratique.

Une Borne d'Arcade maison -37-

Makoto Doushite — Wed, 17 Apr 2013 09:35:00 +0200

Suite de l'étude précédente :

Aie ! Grave à la bourre je suis ^^;

Depuis plus d'un mois je n'ai pas cessé de travailler sur la borne, voulant mettre un bon coup de collier pour achever l'ouvrage, les événements s'enchainant alors très vite, notamment pour le travail de peinture qui nécessita une organisation particulière.

Ainsi j'accumule un retard important de trois ou quatre billets dans la publication… Désolé pour ceux qui suivent particulièrement cette série >_<; mais sachez que la borne est terminée à 99% et que les comptes rendu devraient maintenant s'enchainer rapidement.

Où en étions nous donc ?? Ha, j'avais terminé la sous-couche de la pièce principale, et restait du travail sur…

Le capot :

Comme je l'évoquais alors, il restait des trous en haut et en bas, en partie comblés avec des morceaux de bois, que j'ai donc parachevé avec du mastic à bois.

Pour le bas il a fallut créer et sculpter la forme arrondie inversée afin de lier de PVC à la base en bois.
Un travail difficile où il fallait assurer une symétrie et une jointure la plus harmonieuse possible avec pour seul outil de mesure l'œil, mais surtout la main !

D'abord grossièrement, la pâte déposée et séchée, puis sculptée à la lime métal et au papier à poncer, et enfin après une couche l'enduis poncée (blanc) :

Voilà pour le haut, très facile à faire.

Travail de « jointurage » également pour la gouttière du bas… Le but étant qu'après la peinture, on ne distingue plus ce qui fut du plastique et du bois.

Même chose pour le long des montants côté cadre, et côté jointure du PVC avec le plaquage en médium de 3 mm.

Au niveau du chapeau, j'ai sculpté par ajout de matière, les arrondis formant les deux coins…

Ici aussi, la difficulté étant d'obtenir une bonne symétrie.

Voilà l'ensemble enduit, prêt pour une passe de sous-couche de peinture !

Peinture :

Et un petit effet « avant/après » :

Toutes les pièces sont donc sous-couchées. J'ai alors travaillé d'arrache pied tous les soirs pour rattraper les bévues passées.

Les parties latérales et le dos en pin qui avaient bues la sous-couche jusqu'à faire ressortir les nervures du bois ont été poncées… Mais le résultat n'étant pas satisfaisant, j'ai ré-enduit/poncé par dessus, puis refait une passe de sous-couche, et enfin poncé légèrement.

Résultat bien lisse !

En fait j'ai perdu du temps, pour les pièces en pin, j'aurais dû sous-coucher puis enduire/poncer et re-sous-coucher d'emblée.

Bref, ensuite ponçage intégral au papier abrasif, grain 240.

Le week-end suivant, installation des bâches pour une première couche de blanc brillant le samedi, appliquée en 3 voiles successifs.

Le résultat m'a fait peur, avec tous les dessins du bois qui sont réapparus en léger relief !!
Puis le lendemain, magique, en séchant la peinture s'était tendue et l'effet s'est estompé.
Malgré tout, un effet peau d'orange prononcé due à la pulvérisation subsistait, donc le dimanche et durant la semaine suivante, ponçage au papier 400 avec de l'eau, pour aussi rattraper les coulures dues à mon inexpérience avec ce pistolet.

Le week-end suivant, chargé… Samedi, nouvelle couche de blanc en 3 voiles.

La nuit pour sécher et le dimanche matin, ponçage intégral au papier 600 avec de l'eau.
Dimanche après-midi, nouvelle couche de blanc en 4 voiles, histoire de vider complètement le godet à peinture.

Après séchage au toucher, démontage des bâches et nettoyage complet du pistolet et du compresseur.

Peinture terminée ! Ouf >_<

Prix à titre indicatif :

- Peinture blanc brillant acrylique 2,5 L = 39€90

À suivre…

Range tes outils dans ton vieux Jeans

Pierre Doucet — Sun, 14 Apr 2013 08:03:14 +0200

10 minutes pour réutiliser un vieux jeans afin de ranger ses outils.

Premiers pas avec le pcDuino

Pierre Vernaeckt — Sat, 13 Apr 2013 22:33:54 +0200

Si vous êtes un peu au courant de tout ce qui se passe dans le monde du DIY, vous avez peut-être entendu parler du pcDuino, concurrent direct du RaspberryPi. Certes, il n’a pas bénéficié du même effet d’annonce, mais pourtant il le mérite au moins autant. En effet, c’est une incroyable petite bestiole qui pousse le concept de mini-ordinateur hackable à souhait bien plus loin encore que le RasPi…

Trêve de bla-bla, voyons un peu à quoi ressemble l’engin:

Au programme:

CPU: Cortex A8 cadencé à 1GHz
GPU: OpenGL ES2.0, OpenVG 1.1 Mali 400 core
1Go de RAM
Ports: HDMI, Ethernet, 3 ports USB
Slot micro-SD (pour le stockage)

Déjà là, on sent bien que le Raspberry Pi a du souci à se faire! CPU beaucoup plus puissant, 1Go de RAM contre 256/512Mo…Mais attendez, ce n’est que le début!

La carte embarque une mémoire flash NAND de 2Go. Ca semble con comme ça, mais l’intérêt est avant tout d’y loger le système d’exploitation. Et oui, là où le Raspi charge l’OS en RAM à partir d’une carte SD, le pdDuino utilise une mémoire flash. Et là, croyez-moi, ça dépote. A titre d’info, le pcDuino effectue un reboot complet en 45 secondes. D’ailleurs, parlons-en de l’OS…

Le pcDuino est livré avec Ubuntu 12.10, mais il est possible d’y installer un Android Ice Cream Sandwich. Oui, vous avez bien lu. Ubuntu et Android. Je vous laisse imaginer la suite!

Bon, on est pas mal là quand même! Et si je vous dit que ce n’est pas fini? Si je vous dis en plus que le pcDuino est compatible avec la plupart des shields Arduino?

Elle est pas belle la vie?

Le pcDuino dispose en effet des quatres séries de pins d’un Arduino standard: les analog, les PWM, les TX/RX…et ça, c’est vraiment cool.

Maintenant, passons au travaux pratiques!

Première prise en main

Pour lancer la bestiole, rien de plus simple: clavier, souris, écran sur le HDMI, Ethernet, alimentation. Quelques secondes plus tard, tadaaaaa:

Petit test de Chrome:

Bon, visiblement ça fonctionne! Maintenant, il s’agit de configurer tout ce petit monde!

Configurer le clavier

Parce que le QWERTY ça va 5 minutes:

sudo dpkg-reconfigure keyboard-configuration

Si nécessaire, rebootez:

sudo reboot

Configurer SSH

Oui, ça peut aider, non? Cette partie est un basée sur cet article.

Tout d’abord, on se créé un utilisateur qu’on ajoute de suite au groupe admin, histoire d’avoir les droits qui vont bien et de pouvoir faire du sudo avec ce compte:

sudo su
adduser deabdird

puis:

adduser deadbird admin

Ensuite, récupérez votre adresse IP:

ifconfig

Installez le package SSH:

apt-get install ssh

Puis nano, un éditeur de texte en ligne de commande:

apt-get install nano

Le but est d’éditer un peu la conf de SSH pour le sécuriser un tout petit peu plus. Modifiez la ligne suivante:

PermitRootLogin yes

PermitRootLogin no

et ajoutez celle-ci:

AllowUsers deadbird

Ces changements permettent de n’autoriser que l’user que vous avez créé à se logger en SSH. Maintenant, rebootez et testez avec une autre machine.

Changer la résolution

Si comme moi vous brancher votre pcDuino sur un écran d’ordi avec un adapteur HDMI vers VGA, vous devriez avoir une résolution moisie. Mon but: avoir du 1280*1024. Changer la résolution d’affichage n’est pas une partie de plaisir, mais voici la manip, tirée du site the greathouses:

Tout d’abord, installez git, libusb et pkg-config:

sudo apt-get install git libusb-1.0.0-dev pkg-config

Ensuite, nous allons récupérer et compiler les sources de sunxi-tools, un programme permettant d’éditer le fichier evb.bin, où se trouve la configuration de l’affichage.

git clone https://github.com/linux-sunxi/sunxi-tools

cd sunxi-tools

make

Maintenant, il va nous falloir accéder à evb.bin, qui est stocké dans la partition de boot, plus précisément dans la mémoire flash de la carte:

sudo mount /dev/nanda /boot

Maintenant, vous avez accès à evb.bin:

ls /boot

Avant de modifier le fichier, faites-en une copie:

sudo cp /boot/evb.bin /boot/evb.bin.bak

Ensuite, décompilez le fichier evb.bin et faites-en un fichier:

./bin2fex /boot/evb.bin &gt;evb.conf

Ouvrez-le avec nano.

Attention à ce que vous touchez dans ce fichier, il y a là de quoi cramer votre pcDuino!

A ce propos, di vous voulez vraiment mettre les mains dans le cambouis, allez donc voir le FEX Guide ici, vous y trouverez de quoi charcuter l’evb.bin. Mais encore une fois, attention…

Cherchez une section nommée “disp_init” (utilisez Ctrl+W pour chercher avec nano). Elle devrait ressembler à ceci:

[disp_init]
disp_init_enable = 1
disp_mode = 0
screen0_output_type = 3
screen0_output_mode = 5
screen1_output_type = 3
screen1_output_mode = 9
fb0_framebuffer_num = 2
fb0_format = 10
fb0_pixel_sequence = 0
fb0_scaler_mode_enable = 1
fb1_framebuffer_num = 2
fb1_format = 10
fb1_pixel_sequence = 0
fb1_scaler_mode_enable = 0

Modifiez la valeur de la variable “screen0_output_mode”:

HDMI Mode	Resolution
0	480i
1	576i
2	480p
3	576p
4	720p50
5	720p60 (default)
6	1080i50
7	1080i60
8	1080p24
9	1080p50
10	1080p60
11	PAL
12	PAL_SVIDEO
14	NTSC
15	NTSC_SVIDEO
17	PAL_M
18	PAL_M_SVIDEO
19	PAL_NC
21	PAL_NC_SVIDEO
23	1080p24-3D
24	720p50-3D
25	720p60-3D
26	1360×768-60
27	1280×1024-60

Une fois les modifs enregistrées, transformez le fichier en un nouvel evb.bin:

sudo ./fex2bin evb.conf /boot/evb.bin

puis démontez la partition:

umount /boot

et redémarrez:

sudo reboot

Et là…croisez les doigts. Si ca ne fonctionne pas, recommencez la manip inverse ou restaurez l’evb.bin que vouz avez sauvegardé. Essayez d’autres résolutions jusqu’à tomber sur quelque chose de bien.

[Réparation] Et la lumière fut

Fabien B. — Sat, 13 Apr 2013 18:36:27 +0200

Bonjour tout le monde !

Il y a quelques temps (une grosse semaine environ) ma "lampe loupe" d’atelier a rendu l’âme.
Bien sûr, comme il s’agit de ma lampe il a fallu que celle-ci crame de manière spectaculaire.
Juste s’éteindre sans se rallumer c’était trop lui en demander …

Du coup sans que je ne m’y attende le néon ET le starter (quitte à faire) ont explosé dans un ultime flash lumineux.

Comme certains diront que j’exagère un peu voici à quoi ressemble désormais le néon :

L’étincelle (si on peut vraiment appeler ça une étincelle) a fait fondre le support en fer + plastique qui est maintenant complétement collé au verre du néon …

Et le starter ?
Ce truc made in chinois de mauvaise qualité ?

Et bien lui aussi a décidé d’avoir une fin grandiose …

Résistance cramée x1

Résistance cramée x2 (juste derrière la broche centrale du transistor de puissance)

Et bonus fusible fondu !
(Il servait franchement à rien ce fusible de 1A. Il a largement eu le temps de laisser tout le circuit cramer avant de fondre …)

–

Réparation

Une fois la fumée et l’infâme odeur de plastique brulé dissipée j’ai tenté de réparer le starter.
Pour le néon … pas trop le choix je suis allé en acheter un neuf dans un magasin de bricolage.

J’ai donc testé le circuit : diodes ok, transistors ok, condo ok et bobinage ok.
En gros deux résistances de 11 et 13 ohms à remplacer … facile !

–

Le test

Pour pouvoir tester ma réparation j’ai fait un truc HYPER DANGEREUX, que seul un abruti comme moi avec un Qi proche de celui d’un concombre de mer pourrait imaginer.
NE FAITE PAS ÇA CHEZ VOUS – non sérieux c’est dangereux !

En gros j’ai branché deux grippes-fils dans une prise, elle même reliée au 220v du secteur pour alimenter manuellement le circuit.
C’est l’idée de merde par excellence mais j’avais pas mieux sur le moment.

Et le résultat ?
Je vous laisse juger par vous même :

Manifestement il y a eu comme un "petit" problème

–

La solution

Si j’ai décidé de faire un article sur ce fail monumental c’est que j’avais un truc à vous montrer

La solution à mon problème de starter m’as été donné par NETeagle sur twitter :

@skywodd Tu peux le remplacer en récupérant un starter de puissance équivalente sur des lampes à économie d’énergie

— NETeagle (@t4nk8) 7 avril 2013

(désolé amis tweetos je ne peux pas inclure le jolie widget twitter sur mon wordpress)

Sur le coup j’étais un peu septique mais en fait c’est THE solution !

L’astuce consiste à prendre le starter d’une lampe néon à économie d’énergie.
Comme souvent le néon crame avant le starter (sauf chez moi bien sûr) on peut récupérer un starter dans une lampe HS de même puissance que la lampe qu’on veut sauver.

Ça demande une scie et un peu de patience mais le résultat est là.

J’ai démonté deux lampes HS de respectivement 10 et 12 watts.
Le circuit est similaire, pour ne pas dire identique, à celui de mon starter.

En cherchant sur le net j’ai même trouvé le schéma "type" de ce genre de starter électronique.
En fait c’est tout bête, le circuit est composé de 4 parties :
- un pont de diode pour redresser le 220v alternatif + un gros condensateur de lissage
- un auto-oscillateur à self
- un hacheur de tension réalisé avec deux gros transistors (bipolaires) de puissance
- un transformateur pour générer la haute tension qui alimente le néon

Si j’avais le temps j’aurai presque pu faire mon propre starter … mais bon c’est pas mon but.

Pour tester j’ai câblé le starter de 12W sur mon néon de 22W.
Celui-ci s’est allumé sans problème mais pas à pleine puissance (ce qui est assez logique avec un starter de seulement 12W), qu’importe cela prouve bien que le principe marche.

Du coup je suis allé acheter une lampe à économie d’énergie de 23W, cout total : un peu moins de 6€ !
Comparé aux 40€ d’une lampe neuve c’est une réelle économie d’argent

(montage définitif avec le starter de la lampe de 23w)

Remarque : le starter "hacké" est 2 voire 3 fois plus petit que celui de base … comme quoi la taille ne compte pas

–

Conclusion

Si vous avez une "lampe loupe" et des lampes à économie d’énergie HS (de même puissance) ne les jetez pas !
Gardez de côté le starter il vous sera peut être utile par la suite

Bon WE et bon bidouillage à tous !

Classé dans:Corrigé, projet Tagged: hack, madeinfr

DIY – Plante verte pour geek

Éric G. — Thu, 11 Apr 2013 16:11:26 -0400

Si vous êtes comme moi, c’est à dire que vous aimez bien les plantes vertes, mais que vous avez la fâcheuse tendance à les oublier, rassurez vous, il n’y a pas que les cactus qui sont fait pour vous. Il est tout à fait possible d’avoir une vraie plante, sans avoir à configurer un reminder pour penser à l’arroser ! (Astuce : ça marche aussi si vous avez la fâcheuse habitude de trop les arroser, ou tout ce que vous voulez qui fait que votre plante verte dépérit en moins d’une semaine)

La liste des courses

Pour réaliser ce petit miracle, il vous faut un socle (ici à gauche, un morceau de plexiglas usiné avec une rainure qui va bien. Pratique mais pas obligatoire), une cloche en verre (après coups, celle là s’avère un peu petite), une plante verte pas trop capricieuse non plus et aimant bien les ambiances humides et/ou tropicales, et du silicone, pas obligatoire, mais c’est pour valider le concept.

Vous l’aurez deviné, l’idée est de reproduire le concept de l’écosphère, version plante verte. On met donc la plante verte (préalablement arrosée mais pas trop non plus) sous cloche, et on scelle le tout hermétiquement.
Le fonctionnement général est le suivant :
- en journée, la plante respire du co2 et produit de l’oxygène, et transpire de la vapeur d’eau.
- La vapeur d’eau se condense sur les parois, et est ré-absorbée par les racines
- La nuit, la plante consomme de l’oxygène et produit du CO2.

Pour les nutriments, c’est un peu la même idée : les poussent qui meurent sont décomposées et ré-assimilées pas la plante.

Pour ce qui est de la plante verte, je suis personnellement partis sur le genre Soleirolia : ça coûte pas cher, ça se trouve dans toutes les jardineries, et surtout les conseils de culture laissaient envisager de bons résultats : « Placez la plante à l’extérieur ou à l’intérieur dans une structure de type terrarium/paludarium avec beaucoup d’humidité atmosphérique pour une croissance optimale »Dernier avantage, elle rentrait dans ma cloche en verre qui s’est avérée être beaucoup plus petite en vrai que ce dont elle avais l’air sur les photos
Sinon, pourquoi le silicone ? S’il n’est en rien obligatoire, il présente deux avantages majeurs : Il permet de soulever la plante par la cloche et non par par le socle, ce qui évite quelques petites déconvenues, et rend les échanges intérieur/extérieur impossibles. Je suis donc sûr que la condensation proviens bien de la plante, ainsi que l’atmosphère qui n’est pas perturbé par le milieu ambiant.

Une « ecosphère » terrestre

Pour la conclusion, je n’ai pas posté l’article tout de suite, histoire de vérifier que la chose survivait un peu…. et pour le moment, ça se passe plutôt bien, elle est sous cloche depuis le 22 mars. Record à battre : 53 ans

Nouveau VTT – Montage perso à base d’un cadre MBK R-Force XC1 Carbone

Nicolas Baccelli — Sun, 07 Apr 2013 11:21:00 +0200

Mon nouveau vélo, acheté en pièces détachées d'occasion ou neuves pour certaine.

J'ai pas mal galéré sur certaine partie du montage, notamment sur la fourche et le réglage de la transmission, mais je suis finalement très content du résultat !

Il fait environ 11.6Kg, pour à peu près 1600€ sans les outils.

Cadre : MBK Carbon tout suspendu taille M

Armotisseur : Fox float RP 23 (100mm)

Fourche : RockShox Reba RL (100mm)

Roues : Crossmax ST 2009

Pneus : Maxxis (Tubeless)

Transmission et pédalier : Deore XT

Il reste à régler la fourche et l’amortisseur en fonction de mon poids (à l'aide d'une pompe haute pression que je n'ai pas)

DIY – Interrupteur télécommandé pour modélisme

Éric G. — Mon, 01 Apr 2013 12:09:56 -0400

Bon, si je me suis embêté à vous pondre une série d’articles sur la programmation AVR, c’est que j’avais une petite idée derrière la tête. En l’occurrence, j’avais besoin de pouvoir couper une alimentation embarquée dans un avion RC, bien sûr à distance.
L’idée était donc de réaliser un petit périphérique qui se connecte comme un servo-moteur standard de modélisme, mais qui active un relais en fonction de la valeur.

Déjà, il est important de savoir à quoi ressemble les signaux transmis par le récepteur RC aux servos :

Credit : http://nononux.free.fr

Bon, il s’agit d’une sorte de PWM, mais avec un champs très limité car allant de 5 à 10% de la valeur. Dans mon cas, je ne suis intéressé que par 2 cas : On ou Off. Je décide donc de couper à 50%, de manière à pouvoir utiliser le manche des gaz en guise d’interrupteur : de 0 à 50% je suis Off, de 50% à 100% je suis On.
A partir de là, il y a plusieurs façons de voir les choses : il est possible de régler ça en analogique pur, mais j’avais peur que ce soit trop sensible aux éventuelles perturbations. (Et dans mon cas, je préférerais que ce ne soit pas sensible ). Je suis donc partis sur la solution numérique pour traiter les impulsions.
Comme c’est pour embarquer dans un avion RC, il ne faut pas que ce soit lourd, donc j’ai choisi le micro-controlleur le plus petit possible, à savoir l’AtTiny85, que vous devez bien connaître désormais (voir ici, ici et ici), et qui plus est dans sa version CMS.

Le sch

Comme vous pouvez le constater sur le schéma ci-dessus, la partie électronique est réduite au strict minimum : Un régulateur de tension, pour fournir le 5v nécessaire à tout l’appareillage (servos, récepteur, etc…) dans le cas où l’on ne dispose pas de BEC (par exemple s’il n’y a pas de moteur). L’AtTiny85 dans sa configuration la plus simple (oscillateur interne), un mosfet pour piloter le relais, et le relais en lui même, petit relais 5v, capable de couper 175W quand même.
Le circuit a été réalisé sur un PCB de 0.8mm d’épaisseur, de manière, là encore à gagner du poids.

Vous l’aurez donc compris, dans ce montage, c’est le code qui fait tout le travail :

#include <avr/io.h>
#include <avr/interrupt.h>

//	   ___
//  PB5  *|+  |*  VCC
//  PB3  *|   |*  PB2
//  PB4  *|   |*  PB1   --> declenchement relais
//  GND  *|___|*  PB0   --> entrée PWM
//

volatile int count = 0; //le rapport cyclique
volatile int toff = 0;  //durée du signal à 0
volatile int ton = 0;	//durée du signal haut

int main(void)
{
	//configuration de la pin de sortie
	DDRB |= (1 << PORTB1); 	//on configure PB1 en tant que sortie
				//DDRB = Port B Data Direction Register

	//configuration du timer1 (Ton)
	TCCR0B |= (1 << CS00) | (1<<CS02); 	//Set up timer1 with prescaler 1/1024


	//configuration des interruptions
	GIMSK |= (1 << PCIE); 	//Enable pin change interrupt for PORTB 
				//GIMSK = General Interrupt Mask Register
				//PCIE = Pin Change Interrupt Enable

	PCMSK = (1 << PB0);  	//Enable pin change interrupt for PB0 (pcint0)
				//PCMSK = Pin Change Mask Register

	sei(); //mise en place des interrupts (set global interrupts)

	for(;;)
	{
		
		
		if(count>=7.5) //Si le rapport cyclique est > à 7 (Ton ~1.5ms)
		{
			PORTB |= (1 << PB1);
		}
		else
		{
			PORTB &= ~(1<<PB1);
		}
	}
}


ISR (PCINT0_vect) { //vecteur d'interruption
	if (PINB & (1<<PB0)) // detection de front montant
	{  
		
		toff = TCNT0; 	//Enregistrement de la valeur du timer Toff
		TCNT0 = 0;	//Réinitialisation du timer
	}
	else //detection de front descendant
	{
		ton = TCNT0;	//Enregistrement de la valeur du timer Ton
		TCNT0 = 0;	//Réinitialisation du timer
		if(toff)	//si on a déjà une valeur pour Toff
		{
			count = (ton*100L)/(ton+toff); //Le rapport cyclique = ton/(Ton+toff)
		}		
	}
}

Voilà, il ne reste donc plus qu’à assembler tout ça, et à tester :

Le montage avec une led pour tester.

La chaîne complète, avec le récepteur

Et histoire de vérifier que tout fonctionne, une petite vidéo :

Voilà, un nouvel article prochainement pour vous faire voir l’utilisation réelle du bidule
Ps : c’est un kit que vous retrouverez sur la boutique

DIY – Régulateur PWM

Éric G. — Mon, 25 Mar 2013 18:11:40 -0400

Dans la série montage à toujours avoir sous la main, je voudrais le régulateur de tension PWM !
Concrètement, ce montage permet de régler l’intensité lumineuse d’une ampoule ou d’une led, ou encore de régler la vitesse de rotation d’un moteur CC, en jouant sur la largeur des impulsions. Concrètement, la tension appliquée aux bornes de la charge ne change pas, mais on la laisse passer plus ou moins longtemps. Principal avantage, le rendement. Par exemple, si la charge que vous souhaitez piloter consomme beaucoup de courant, une régulation classique dissipera beaucoup de chaleur, ce qui ne sera pas le cas avec ce type de montage. Quelques explications.

modulation PWM

Prenons une tension d’entrée (Vin) de 5v. Si la durée de la pulsation Ton est de 10ms, et Toff est de 10ms, alors la tension équivalente de sortie sera de Vin*(Ton/(Ton+Toff)), en l’occurrence 5*10/(10+10) = 2.5V. Comme je le disais au dessus, je parle bien de tension équivalente, car si vous mesurez la sortie avec un oscilloscope, vous verriez des créneaux 0-5v tels que présentés dans le dessin ci-dessus.
Maintenant qu’on a vu le fonctionnement, voyons le montage à proprement parlé :

Régulateur PWM

Le coeur du montage est un NE555, qui génère des impulsions avec un rapport cyclique (rapport cyclique = Ton/Ton+Toff) variable. L’inconvénient de ce montage est que la fréquence varie légèrement lorsque l’on change le rapport cyclique. Ce n’est pas gênant pour contrôler l’intensité d’une led ou la vitesse d’un moteur, mais si c’est pour faire des mesures d’efficacité par exemple, il faut en tenir compte.

La diode 1N4004 permet de brancher une charge inductive (moteur CC), en filtrant les retours de tensions. Le modèle de la diode peut être à adapter en fonction de la puissance moteur.

Le montage est prévu à la base pour une charge fonctionnant en 12v, avec une tension d’alimentation inférieure à 20 volts. Il est cependant tout à fait possible d’utiliser des charges de 24v, avec des tensions d’alimentations supérieures (max 37v), en prenant soin de mettre une résistance bobinée de 220 ohms en R5, afin d’éviter que le LM317 n’ai trop de chaleur à dissiper (ceci dit, il n’alimente que le NE555, donc la consommation est assez réduite). Dans le cas standard, cette résistance est inutile.

Voici le résultat une fois monté sur un joli PCB :

Le résultat final

Une petite vidéo du montage en fonctionnement :

Je profite de cet article pour inaugurer une nouvelle rubrique à ma boutique, à savoir les Kits ! Vous y retrouverez au fur et à mesure certains des montages déjà présentés ici (dont ce montage), et bien sur tous ceux à venir que je jugerais intéressants

Des nouvelles de Bleuette

Charles Rincheval — Mon, 25 Mar 2013 14:56:00 +0100

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 :

Sur Hackaday : 3d printed hexapod robot
Une introduction que j'ai écrite en anglais sur le blog officiel d'Ultimaker : Bleuette : A 3d printed hexapod robot made with Ultimaker !
Sur le blog officiel Arduino : Bleuette, the hexapod robot

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) :

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 :

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 :

Le tout assemblé :

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 :

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

Programmation Avr, dernière partie

Éric G. — Sun, 17 Mar 2013 21:06:56 -0400

Ok, trois articles sur le sujet ça peut paraître court, mais ça constitue déjà une bonne introduction, qui devrais vous permettre d’envisager la suite par vous-même. Nous allons aujourd’hui nous pencher sur un autre élément essentiel de la programmation avr :

Les interruptions

Imaginez que vous êtes en train de souder un circuit quand tout à coups la sonnette de votre porte d’entrée résonne. Vous pouvez arrêter ce que vous étiez en train de faire (mais rien ne vous y oblige), aller répondre, et revenir à vos soudures. Et c’est exactement comme ça que se passe une interruption dans le monde informatique, ici représentée par la sonnette.

Les interruptions peuvent être matérielles (changement d’état d’une broche, timer qui arrive à une certaine valeur), ou logicielles, et le nombre d’interruption disponibles dépend du modèle d’avr.
Les différentes interruptions disponibles sur votre microcontrolleur sont visibles sur la table des vecteurs d’interruptions de la datasheet (ici, je suis toujours sur l’Attiny85)

Vecteurs d’interruption

Lorsqu’une interruption se produit, l’avr stoppe ce qu’il était en train de faire pour exécuter la fonction que vous souhaitiez rattacher à cette interruption. Pour ce faire, il utilise une table des vecteurs d’interruption, positionnée au début de sa mémoire flash, afin de faire la correspondance Interruption <–> fonction.

Afin d’utiliser une interruption sur notre avr, nous avons besoin de faire 3 choses :

Positionner le bit Enable Interrupt (en général avec la fonction sei(), set global interrupt, mais peut aussi être positionné à la main)
Positionner les bits de chaque interruption.
et enfin remplir la condition de l’interruption.

Comme d’habitude, nous allons voir ensemble un petit exemple. Ce programme servira à compter les impulsions reçues sur la pin 5 de l’Attiny85. Lorsqu’il arrivera à 200 ou plus, il allumera une led sur la pin 6. Les impulsions pourront être crées avec un bouton poussoir (attention au debounce) ou un générateur de signal.

#include <avr/io.h>
#include <avr/interrupt.h>

//	   ___
//  PB5  *|+  |*  VCC
//  PB3  *|   |*  PB2
//  PB4  *|   |*  PB1   --> sortie led
//  GND  *|___|*  PB0   --> entrée surveillée
//

volatile int count = 0; //compte des interrupts


int main(void)
{
	//configuration de la pin de sortie
	//configuration des interruptions
		//Positionnement du Global Interrupt MaSK register
		//Positionnement du Pin Change Mask Register
		//mise en place des interrupts (set global interrupts)

	for(;;)
	{
		
		
		//Si on a eu 200 impulsions ou plus
		{
			//on alume la led
		}
		//sinon
		{
			//On éteind la led
		}
	}
}


ISR (PCINT0_vect) { //vecteur d'interruption
	// detection de front montant
	{  
		//on ajoute 1 au décompte
	}
	//detection de front descendant
	{
		//ici on ne fais rien, juste pour l'exemple...
	}
}

Voilà, déjà, on peut remarquer en fin de code la façon dont est définie le vecteur d’interruption. Un autre détail à remarquer est la déclaration de ma variable count. Cette variable étant utilisée à la fois par mon programme principal et par ma fonction, il est impératif de la déclarer en volatil, sous peine de ne jamais la voir s’incrémenter.
Voyons voir maintenant comment déclarer nos interruptions (encore une fois, les valeurs des bits sont tirés de la datasheet, cf page 53, chapitre 9.3.2) :

#include <avr/io.h>
#include <avr/interrupt.h>

//	   ___
//  PB5  *|+  |*  VCC
//  PB3  *|   |*  PB2
//  PB4  *|   |*  PB1   --> sortie led
//  GND  *|___|*  PB0   --> entrée surveillée
//

volatile int count = 0; //compte des interrupts


int main(void)
{
	//configuration de la pin de sortie
	//configuration des interruptions
		//Positionnement du Global Interrupt MaSK register
                GIMSK |= (1 << PCIE); 	//Enable pin change interrupt for PORTB 
		    		        //GIMSK = General Interrupt Mask Register
				        //PCIE = Pin Change Interrupt Enable
		//Positionnement du Pin Change Mask Register
                PCMSK = (1 << PB0);  	//Enable pin change interrupt for PB0 (pcint0)
		  		        //PCMSK = Pin Change Mask Register
		//mise en place des interrupts (set global interrupts)
                sei();

	for(;;)
	{
		
		
		//Si on a eu 200 impulsions ou plus
		{
			//on alume la led
		}
		//sinon
		{
			//On éteind la led
		}
	}
}


ISR (PCINT0_vect) { //vecteur d'interruption
	// detection de front montant
	{  
		//on ajoute 1 au décompte
	}
	//detection de front descendant
	{
		//ici on ne fais rien, juste pour l'exemple...
	}
}

Quelques petites explications complémentaires s’imposent ici. J’ai décidé de dédier une pin de mon Attiny85 à la surveillance du signal d’entrée, j’ai donc utilisé les Pin Change Interrupt. Mais si j’avais voulu utiliser ma broche pour d’autres choses en parallèle, j’aurais du utiliser les External Interrupt Request (donc positionner le bit INT0 au lieu de PCIE). Il faut également noter que par défaut, une interruption ne peut en interrompre une autre (comprendre : les interruptions sont désactivées le temps du traitement du vecteur d’interruption actuel). Il est cependant possible (mais pas franchement recommandé) de les réactiver en réutilisant sei() à l’intérieur de la déclaration du vecteur d’interruption. De la même manière, si vous souhaitez qu’une portion de votre code ne soit interrompue sous aucun prétexte, vous pouvez utiliser la fonction cei().
Voici maintenant le code complet :

#include <avr/io.h>
#include <avr/interrupt.h>

//	   ___
//  PB5  *|+  |*  VCC
//  PB3  *|   |*  PB2
//  PB4  *|   |*  PB1 
//  GND  *|___|*  PB0   --> entrée surveillée
//

volatile int count = 0; //compte des interrupts


int main(void)
{
	//configuration de la pin de sortie
	DDRB |= (1 << PORTB1); 	//on configure PB1 en tant que sortie
				//DDRB = Port B Data Direction Register

	//configuration des interruptions
	GIMSK |= (1 << PCIE); 	//Enable pin change interrupt for PORTB 
				//GIMSK = General Interrupt Mask Register
				//PCIE = Pin Change Interrupt Enable

	PCMSK = (1 << PB0);  	//Enable pin change interrupt for PB0 (pcint0)
				//PCMSK = Pin Change Mask Register

	sei(); //mise en place des interrupts (set global interrupts)

	for(;;)
	{
		
		
		if(count>=200) //Si on a eu 200 impulsions ou plus
		{
			PORTB |= (1 << PB1);
		}
		else
		{
			PORTB &= ~(1<<PB1);
		}
	}
}


ISR (PCINT0_vect) { //vecteur d'interruption
	if (PINB & (1<<PB0)) // detection de front montant
	{  
		count = count++;
	}
	else //detection de front descendant
	{
		//ici on ne fais rien, juste pour l'exemple...
	}
}

Bon, passons sur les modifications d’état de la led, déjà abordées auparavant. Il est ici intéressant de noter comment se fait la détection d’un front montant ou descendant : à la suite d’un changement d’état, on lit l’état de la pin PB0, si elle est à l’état haut c’était un front montant, sinon, un front descendant.
Voilà, c’était le dernier article de cette série, qui sera suivi très bientôt d’une application concrète