Mot-clé - électronique

Fil des billets - Fil des commentaires

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

Vendredi, décembre 27 2013

DIY – Générateur de Marx

C’est pas encore l’heure des bonnes résolutions, mais je renoue ici avec une de mes passion premières, un peu délaissée ces derniers temps : la haute tension.
Le montage auquel je me suis attaqué aujourd’hui est assez simple dans son fonctionnement, il s’agit d’un générateur de Marx, qui permet de multiplier une tension. L’avantage de ce montage, est qu’outre sa simplicité, la tension de sortie est directement proportionnelle au nombre d’étages mis en jeux (aux pertes près).

Générateur de Marx

Générateur de Marx

Le concept consiste à charger X condensateurs en parallèles, et les décharger en série. Pour arriver à un pareil résultat, on va utiliser des éclateurs. En effet, tant que la tension  aux bornes du condensateur ne dépasse pas une certaine tension, rien ne se passe, les condensateurs se chargent tranquillement, et la tension à leurs bornes augmente peu à peu.

Charge

Charge

 

Mais lorsque cette tension est atteinte, un arc électrique se produit sur l’éclateur, qui deviens ainsi conducteur.

Décharge. En bleu ciel, les arcs électriques

Décharge. En bleu ciel, les arcs électriques

(oui, désolé pour les couleurs un peu flashy, ça pique les yeux, je sais)
Pour que ça fonctionne (bien), il y a tout de même quelques paramètres importants à respecter. Déjà, il faut que la tension d’alimentation soit suffisamment élevée pour pouvoir produire un arc électrique, sinon les éclateurs ne fonctionneront pas. Ensuite, les résistances de charges. J’ai un peu galéré pour trouver des résistances correctes pour ce montage. Au début, j’étais partis avec des résistances couches carbone (les classiques), mais rapidement les arcs sont passés par le côté de la résistance, détruisant celles-ci. J’ai ensuite voulu utiliser des résistances de puissances en céramique. Mauvaise idée : elles ont été détruites en totalité sur un seul shoot. Je suspecte plus la déflagration d’avoir endommagé l’intérieur que la chauffe proprement dite car elles étaient sensées tenir plus que les couches carbone, ce qui n’aura pas été le cas ici. Finalement, j’ai utilisé des résistances bobinées de puissances, et après quelques dizaines de minutes de fonctionnement, tout à l’air en ordre de marche. Dernier point, la distance entre les éclateurs est relativement importante, c’est d’elle que dépendra la « tension de claquage »

Mon générateur de Marx

Mon générateur de Marx

Comme on peut le voir sur la photo, mon générateur est constitué de 6 étages, ce qui multiplie donc par 6 la tension d’entrée… En théorie. En effet, mes éclateurs étant difficiles à régler, ma tension de claquage est assez loin du maximum débité par mon alimentation. Au final, je dois arriver à une tension de 10Kv par condensateur, soit 60Kv en sortie.
Les éclateurs sont de simples fils de cuivre recourbés, passés au papier de verre pour enlever l’émail.

Le générateur en action

Le générateur en action. Le père Noël fait 12cm

Petit détail pour ceux qui serais tentés par l’expérience, et qu’il est difficile de rendre sur une photo : C’est extrêmement bruyant !! (genre mitraillette dans le salon)

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

Jeudi, avril 25 2013

Capteur optique de vitesse et sens de rotation (2)

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

Patron du premier codeur

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

codeur-papier

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

Mauvais signal avec la roue en PLA

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

Roue en résine photosensible

Illustration 7 : Roue en résine photosensible

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

Roue codeuse en place

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.

 

Mardi, avril 23 2013

Capteur optique de vitesse et sens de rotation (1)

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.

  1. 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

Codeur optique – premier test

Il est aussi possible avec cette technologie de déterminer le sens de rotation… à condition d’ajouter un 2e photo-transistor judicieusement placé à côté du premier. Le signal optique reçu par le 2e 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

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

Premier croquis du codeur à sens

Dans le prochain article… la mise en oeuvre pratique.

 

 

Lundi, avril 1 2013

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

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

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

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.

Le montage avec une led pour tester.

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

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

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


media

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

Lundi, mars 25 2013

DIY – Régulateur PWM

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

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

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

Le résultat final

Une petite vidéo du montage en fonctionnement :


media

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

- page 1 de 6