Jeudi, février 28 2019

Un pré-ampli phono dans une manette NES

Cela fait un petit moment que je n'ai rien posté! Après deux années assez chargées, je commence à retrouver du temps pour être créatif.

J'ai réalisé dernièrement un préampli pour une platine disque que j'ai trouvé dans une brocante. Histoire de pouvoir écouter les vieux vinyles sur mon ampli DIY


Comme toujours en électronique DIY, le plus dur à trouver et le plus cher est souvent le boitier. Je n'ai pas été charmé par ce que j'ai trouvé dans le commerce. Alors je me suis dit que je pouvais détourner un objet.

Et j'ai pensé à une de mes vieilles manettes nintendo qui trainait (je pensais l'utiliser pour piloter un arduino dans une application quelconque mais je n'en ai pas encore eu l'occasion).
Alors c'est parti pour le tuto:

Voici à quoi ressemble une manette NES démontée:


Il faut faire tenir cette carte (ampli phono) et les connectiques qui vont avec. Le problème, c'est les gros composants (condensateurs) qui sont montés à la vertical: ça ne va pas tenir!


Donc, on va les dessouder et essayer de les placer un peu plus loin, à l'horizontale.

On va maintenant essayer de gagner un peu de place dans la manette en enlevant le superflu...

Oui, ça fait des déchets....

On va maintenant percer pour les connecteurs:


on implante un peu tout ça:


on pense à la masse (elle permet de réduire le bruit), il y a toujours une connectique pour la masse sur les platines:



On s'applique et on ferme le tout:



voici d'autres visuels du pré-ampli terminé:





je suis fier de mon préamp !!!

Je suis prêt à redécouvrir le son des 70'


A+

Antoine


Samedi, février 23 2019

Une éolienne à axe vertical -14-

Suite de l'ouvrage précédent :

Peinture :

  • Afin de protéger le métal de la rouille, nous avons passé deux couches de peinture à l'eau, au pistolet pour les grandes surfaces, et aux pinceaux pour le reste.

Cette opération a nécessité le démontage complet de la partie rotative, afin de peindre à l’abri.
Autant nous n'avons pas eu de chance côté vent, la météo étant extrêmement clémente pour un mois de Février (j'ai coupé le chauffage, c'est vous dire !), autant du coup la mise en peinture du mât en extérieur a été facilitée, avec les deux couches dans la même journée, à la température idéale conseillée inscrite sur le pot.
dsc04041.jpg dsc04042.jpg

Ajustements :

Avant de procéder au remontage de la partie rotative, il fallait que je m'attaque à un problème évident. Le roulement conique prend l'eau et son graissage n'est pas efficace…
En effet, puisqu'il est logé dans une case et qu'il n'est pas étanche, car en deux parties (contrairement au roulement du haut, plus classique) l'eau s'accumule dessus. La case n'étant pas fermée, la graisse appliquée se sauve.

  • J'ai donc confectionné ces deux pièces, découpées dans une boite d'emballage plastique et collées à la cyanoacrylate, qui s'emboîtent autour du roulement.

dsc04038.jpg dsc04039.jpg dsc04040.jpg 20190216_152404.jpg

  • Avec l'idée donc de remplir cette boite de graisse…

dsc04044.jpg dsc04047.jpg
Le remontage complet des ailes a été aussi l'occasion de graisser correctement toutes les pièces pivots mobiles.

  • La boîte à graisse prend sa place tranquillement comme prévu, et pour parfaire le tout, une tôle d'inox a été taillée sur mesure pour venir recouvrir les bras et le roulement de manière à empêcher l'eau de passer, tout en ne bridant pas la rotation. J'ai ajouté une collerette imprimée (que j'aurai dû faire plus grande encore) en deux pièces collées autour de l'axe pour dévier les eaux de ruissellement.

20190216_161858.jpg 20190216_161915.jpg 20190216_161941.jpg dsc04068.jpg

  • La même chose a été faite pour le bras du haut, tôle + collerette + bouchon.

dsc04051.jpg dsc04052.jpg

Mise en place de la génératrice :

Pour connecter le générateur à l'éolienne plusieurs idées ont été envisagées, et c'est finalement la récupération d'une roue de vélo lors d'une visite à la déchetterie qui semble la plus facile à mettre en place et offrira une démultiplication mécanique de l'ordre de 22.

  • Pour fixer la roue à l'axe de l'éolienne, comme pour les croix qui tiennent les ailes, a été utilisé un tube de vélo, soudé sur la cassette de la roue.

dsc04049.jpg dsc04048.jpg

  • Voici ce que donne cet ensemble, avec une cordelette pour figurer la future courroie.

dsc04066.jpg

  • Une petite vidéo !
  • Quelques photos :

dsc04055.jpg dsc04056.jpg dsc04069.jpg dsc04057.jpg
dsc04054.jpg dsc04058.jpg dsc04062.jpg dsc04067.jpg

Mise à jour soft :

  • Ce fût aussi l'occasion de mettre à jour le programme de l'anémomètre qui présentait quelques défauts.

J'avais en effet basé celui-ci sur des exemples de mise en œuvre, et force était de constater que tous les exemples que j'ai trouvé via l'ternet mesuraient des intervalles, ce qui explique pourquoi dans les vidéos démo que j'ai filmée, les valeurs sont toujours les mêmes qui reviennent.

J'ai donc entièrement repensé le programme, et c'est carrément mieux !
De plus j'ai mis là main sur un véritable anémomètre et j'ai ainsi pu calibrer le miens, à peu de choses prés, les mesures de vitesses de vent sont donc correctes.
Quant aux mesures de rotation de l'éolienne en rpm (PGM dispo ici), j'ai pu vérifier que mon programme était ultra précis à l'aide d'un vrai tachymètre.

  • Démo en vidéo, le rafraîchissement des valeurs se fait toutes les demi-secondes :


À suivre…

Vendredi, février 22 2019

Une éolienne à axe vertical -13-

Suite de l'ouvrage précédent :

  • Comme prévu, j'ai donc décidé d'attaquer la partie production électrique avec la fabrication d'une génératrice à aimant permanent.

Malgré l'obsolescence annoncée du projet par Vijay, j'ai procédé à la fabrication de cette première version, quitte à y apporter mes propres modifications futures.
Je vais donc détailler ici l'assemblage et la mise en place du générateur sur l'éolienne.


Préparatifs :

Je rappelle la source du projet réalisé par Vijay : https://hackaday.io/project/159568-portal-point-generator, ma version diffère mécaniquement quelques peu.

Matériel nécessaire :

- Les pièces imprimées 3D avec du filament PET-G. (fichiers en annexe du billet).
- 16 Aimants au Neodynium de type N52, à champ magnétique axial, dimensions : 40x20x10 mm.
- 510 g environ de fil de cuivre émaillé de 0,25mm (30 AWG).
- 1 pont de diode redresseur à 3 phases de 50A. (utilisé ici pour test, sera remplacé par un régulateur de charge)
- 10 cosses électrique isolées 6,35 mm.
- 3 roulements 608ZZ.
- 1 tige lisse ∅8 mm de 200 mm de long.
- 2 rondelles M8.
- 4 vis M6x60 mm.
- 4 rondelles M6.
- 4 tiges filetées de ∅4 mm x 100 mm de long.
- 2 tiges filetées de ∅4 mm x 90 mm de long.
- 2 vis M4x15 mm.
- 12 rondelles M4.
- 14 écrous M4.
- 32 vis M3x20 mm à têtes fraisées.
- 32 écrous M3.
- 1 plaque de métal de 1,2mm d'épaisseur 200x400 mm.
- ruban adhésif polyimide, type Kapton.
- colle chaude au pistolet.
- colle cyanoacrylate.

  • Les pièces sont à imprimer en double, à l’exception du stator. Pour réduire les durées d'impressions, j'ai tranché en 0,3 mm.

Il y a deux disques en métal de 150 mm de diamètre à découper dans de la tôle d'environ 1,2 mm, que j'ai récupéré sur la carcasse d'une tour d'ordinateur.
dsc04001.jpg dsc04003.jpg dsc04004.jpg dsc04005.jpg
dsc04006.jpg dsc04008.jpg dsc04009.jpg dsc04010.jpg



Les aimants, fabrication des rotors :

Rien de très compliqué dans avec cette partie, il faut juste être très précautionneux !
En effet les aimants ont une force terrible et en cas de choc il peuvent éclater, il faut donc veiller à ce qu'ils ne se touchent jamais au cours du processus.

  • Il faut d'abord repérer les pôles opposés en attribuant arbitrairement pour le premier aimant un « S » pour Sud sur l'une des faces, puis en l'utilisant en référence pour taguer les faces de tous les autres aimants.

Je plaçais donc ma main sur l'aimant référence, et passait par dessus chaque aimant, en les tenants fermement, si l'aimant sous ma main se soulevait j'avais un pôle Nord…

  • Une fois ceci fait, on peut placer un à un les aimants dans les logements prévu sur les deux rotors, en encollant le pourtour de l'aimant de colle chaude. Une fois en place, je rajoutais un filet de colle dans l'interstice pour avoir une belle jointure avec le plastique.

Les pôles Sud sont mis en place un à un, puis c'est au tour des pôles Nord. Pour ces derniers il faut se méfier car il sont fortement attirés dans leurs logement, on n'a donc pas droit à l'erreur au moment du collage !
dsc04029.jpg dsc04017.jpg

  • Les disques de métal doivent être percés exactement comme les rotors, afin de laisser passer les vis de fixation des couvercles.

Je disposais donc d'un gabarit (Field_stopper.stl) pour effectuer le perçage proprement à la perceuse à colonne.
Ce sont des vis de ∅3 mm qui vont être utilisée et comme toujours il faut bien penser à repasser un forêt de ∅3 dans les trous des pièces imprimées. Cependant, l'ultra précision n'étant pas humaine, je conseille de percer les plaques de métal en ∅3,2 voir ∅3,5 mm, pour éviter toutes mauvaises surprise d’alignement de trous pour la suite.
dsc04034.jpg dsc04035.jpg

  • Le placement des disques de métal est assez délicat, gare aux doigts, ça pince jusqu'au sang à n'en point douter !

Et c'est quasi impossible à décoller ou replacer en cas de mauvais alignement, sauf à taper dessus…
dsc04036.jpg dsc04037.jpg

dsc04019.jpg

  • Ensuite reste à visser les 32 vis M3x20 mm à têtes fraisées, et mettre en place l'écrou M4 dans son logement central, avec la vis M4x15 mm qui servira au blocage en place du rotor sur la tige lisse de ∅8 mm.

Vous remarquerez aussi que j'ai indiqué « dessus - dessous » sur chacun des couvercles des rotors, avec un trait de repère jusque sur la tranche.
C'est donc un trait à aligner en cas de démontage du couvercle, afin que les pôles du rotor du dessous soit bien alignés avec les pôle du rotor du dessus, sans quoi rien ne fonctionnerait.


Bobinage, fabrication du stator :

  • Ici nous abordons la partie la plus complexe, le cœur du générateur, celle que va déterminer l'efficience de l'appareil.

Un tas de paramètres entrent en jeux quant à la génération d'électricité, comme la section du fil, le nombre de tour effectués sur chaque bobines, le nombre de bobines, etc. Ici, on ne pourra jouer que sur la section du fil de cuivre et le nombre de tours.

J'ai décidé de faire confiance au projet de Vijay et j'ai donc, faute de savoir y calculer quoique ce soit, « presque » suivi ses indications.

  • Comme vous allez le voir, la génératrice étant facile à démonter/remonter, il est d'ailleurs tout à fait envisageable de changer le stator si les caractéristiques électriques obtenues n'étaient pas satisfaisantes.
  • Pour me faciliter la tâche, j'ai démonté une visseuse que j'ai fixé sur un support grâce à un peu d'impression3D, afin d'utiliser le gabarit d'enroulement de Vijay. Le moteur est directement alimenté en 5V via un potentiomètre pour régler la vitesse. Ce n'est normalement pas à faire, le potentiomètre chauffe beaucoup et sa valeur trop importante rend le réglage de la vitesse très imprécis, mais j'ai fait avec ce que j'avais sous la main…

dsc03991.jpg dsc03993.jpg dsc03994.jpg dsc03999.jpg

  • Vijay indique rapidement dans une de ses vidéos 700 tours à faire, mais comme il restait de la place dans les logements à bobine, j'ai décidé d'en faire 200 de plus, au pire je pourrais les retirer si besoin…
  • Une petite vidéo, pour voir comment ça se passe :
  • Mais comment compte-on les tours me direz-vous ?!!

Bah facile, avec un Arduino !

Comme pour le projet Anémomètre, il suffit d'utiliser un capteur Hall 3144 et un aimant, connectés ici à un Arduino ProMini 5V. Le capteur à son petit support imprimé, et l'aimant est collé au gabarit.
CompteTour_bb.png dsc03996.jpg dsc03998.jpg dsc03997.jpg

  • Voici le programme « Compte Tours », il s'utilise en ouvrant « le moniteur série » pour y voir défiler le compte-tours.
/****************/
/* DÉCLARATIONS */
/****************/
// le capteur à effet Hall est connecté à la pin 2 = int0
volatile int count = 0;

/*********/
/* SETUP */
/*********/
void setup() {
  Serial.begin ( 115200 );  // init du mode débug
  attachInterrupt(0, tour, FALLING);   // Pin capteurs
}
/*************/
/* FONCTIONS */
/*************/
void tour(){  // appelée par l'interruption
  count++;
  Serial.print("Tour N° : "),
  Serial.println(count);
}
/*************/
/* PROGRAMME */
/*************/
void loop() {
  delay(1000);
}
  • Une petite vidéo pour illustrer le Compte-tours :
  • Voilà, maintenant qu'on a nos 6 bobines (environ 85 grammes chacune), il suffit de les sécuriser un peu plus en ajoutant des bandes d'adhésif polyimide, puis de les placer dans leurs logements, quitte à les mouler quelque peu à la main.

On ajoute aussi un roulement au centre (j'ai été obligé de limer le plastique pour le faire entrer, il semble que le design3D ne soit pas optimal ici).

  • Plutôt que d'imprimer un couvercle de 1,2 mm, et comme j'en avais sous la mains pour mes maquettes, j'ai découpé un disque dans de la carte plastique (polystyrène) de 1,5 mm d'épaisseur. Plus rapide et fiable.

dsc04021.jpg dsc04020.jpg

  • J'ai repris le schéma de câblage à 9 bobines indiqué par Vijay, pour le passer à 6 bobines, et ensuite reporter les indications sur le disque de CP afin de me faciliter la tâche de soudure. Vous pardonnerez mon dessin brouillon, si j'ai le temps je le redessinerais… ou pas.

Une fois sûr de mon coup, j'ai encollé à la cyanoacrylate le périmètre et le centre du disque, mis le disque en place, puis posé une planche par dessus et mis sous presse à l'aide d'un serre-joint prenant ma table en sandwich pour une dizaines de minutes.
dsc04025.jpg dsc04024.jpg.

dsc04026.jpg

  • Pour la soudure il faut d'abord retirer un peu d'émail au bout des fils, et c'est en brûlant ces extrémités puis en ponçant au papier 800 que j'ai obtenu le meilleur résultat facilement. Une peu de gaine thermo de-ci de-là, et les fils ont été logés et collés au pistolet dans la gorge prévu tout autour du stator.

Le câble électrique rouge, vert et bleu a été récupéré sur une alim ATX hors service d'ordi.



Assemblage :

C'est presque terminé…

  • Un roulement est a placer au centre d'un couvercle, avec aussi les 4 tiges filetées de 100 mm, 4 rondelles et 4 écrous M4. Par dessus on engage le corps inférieur. Dans celui-ci on ajoute le demi-support de mât, tenu par une tiges filetée de 90 mm, 2 rondelles et 2 écrous M4.

dsc04012.jpg dsc04013.jpg dsc04014.jpg dsc04015.jpg

  • Et là je me rend compte que j'ai oublié de prendre quelques photos… Donc on enfiche la tige lisse ∅8 mm sur un des rotors, et on vient placer ça sur le roulement, en pensant bien à intercaler une rondelle de ∅8 mm au niveau du roulement et un « spacer » (pièce imprimée) entre le rotor et le stator.

dsc04027.jpg

  • Ensuite il faut engager le stator par dessus, et on peut s'arrêter et faire quelques tests :

En vidéo :


  • Le test passé, c'est à ce moment qu'on été sécurisé les câbles avec la colle chaude.

dsc04030.jpg dsc04031.jpg

  • Pour la suite, il faut glisser un autre « spacer » entre le stator et le rotor supérieur qu'on va mettre au dessus, en prenant garde à aligner les pôles des aimants… De toute manière le champ magnétique est si puissant que les rotors vont s'aligner tout seul, et peut-être même venir écraser le stator. J'ai donc dû ajouter une ou deux rondelles pour maintenir un écart suffisant, tout en comprenant bien pourquoi Vijay travaillait sur une seconde version avec des roulements différents, de type « thrust ». Il est donc probable que j'étudie moi aussi une mise à jour, mais en attendant, voici un nouveau test vidéo :
  • Reste à engager de corps supérieur et son couvercle orné du dernier roulement. J'ai ajouté une poulie temporaire et une collerette anti-pluie.

dsc04032.jpg dsc04033.jpg

  • Et donc voici quelques mesures sur un très très vieux oscilloscope, juste pour illustrer un peu le redressement du courant depuis les 3 phases (qu'il aurait été sympa de capturer ensemble pour ainsi observer le déphasage entre les sinusoïdes, résultant directement de la position des bobines dans le stator) vers du courant continu « en vaguelettes », qui témoignent chacune du sommet des 3 sinusoïdes.



Fini ?

Voilà donc pour le générateur !
Les premiers tests nous ont permis d'allumer prudemment, à rotation manuelle plus ou moins constante, une ampoule 24V 3W.
À titre indicatif, quelques mesures à vide, c'est à dire sans charge électrique :

- 12V à 45 rpm
- 24V à 80 rpm
- 32V à 115 rpm
- 50V à 170 rpm
- 70V à 256 rpm
- 80V à 280 rpm
- 90V à 310 rpm
- 100V à 350 rpm

Le pont de diodes sera donc remplacé par un « régulateur de charge », circuit destiné à réguler la tension variable triphasée que produit la vitesse de rotation inégale d'une éolienne, afin de ressortir en 12V ou 24V continu, pour enfin pouvoir être exploité sur une charge de batterie.

À suivre…

Samedi, janvier 5 2019

Un anémomètre WiFi -2-

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

  • Avoir un affichage sur le web c'est bien…

Une petite vidéo :

  • Mais un module d'affichage physique c'est quand même plus pratique !

Une petite vidéo :

  • Une seconde démo en vidéo, avec le programme de l'anémomètre revu et corrigé. Le rafraîchissement des valeurs se fait toutes les demi-secondes :
  • J'ai donc passé quelques jours à concevoir ce boîtier client qui fonctionne à base lui aussi d'un NodeMCU connecté au réseau WiFi de la maison, et qui récupère les infos de vitesse transmise par l'anémomètre.

Principe :

Ce client se connecte à l'anémomètre et récupère le fichier JSON ( http://192.168.0.34:8080/mesures.json) afin de le parser toutes les secondes, reste alors à afficher l'information.

Ce sont donc des vieux afficheurs matriciel DLG7137 qui vont faire le travail.
Pour chaque afficheurs il aurait fallu employer un registre à décalage, afin de pouvoir adresser les données à afficher sur chaque matrices, comme cela à été fait sur le WebRadioReveilWiFi, mais ne disposant pas de suffisamment de 74HC595, j'ai dû procéder autrement.
Les DLG7137 disposent en effet d'une pin Write (WR/) qui n'autorise l'affichage de la donnée qu'au moment où elle passe à l'état bas.
Du coup en reliant tous les afficheurs entre eux et en faisant circuler l'information, il restait au programme de valider la pin Write du bon afficheur au bon moment pour afficher le caractère attendu sur chacun des afficheurs.
Et comme le NodeMCU ne dispose pas de suffisamment de papattes pour pouvoir brancher les 12 pins Write des 12 afficheurs, j'ai donné ce travail à faire à deux registres 74HC595, permettant ainsi d'adresser 16 pins Write.

ClientAfficheur_bb.png
Note : J'ai oublié de câbler les deux condensateurs de découplage utiles aux registres 74HC595 !!
Ne les oubliez-pas ! (100nF directement entres les pattes d'alimentation 8 et 16)

Réalisation :

Pas de plaquette de circuit imprimé réalisée cette fois, par manque de temps et aussi car le boîtier serait unique, j'ai donc soudé le tout un quatre ou six heures sur une plaquette à trous, puis j'ai dessiné le boîtier en 3D pour impression.

  • La plaquette à trous :

dsc03958.jpg dsc03960.jpg

  • Le boîtier imprimé, avec un petit bouton pour appuyer sur le reset du NodeMCU.

dsc03956.jpg dsc03957.jpg

  • J'ai trouvé un morceau de plexis de 2mm d'épaisseur, que j'ai peint sur l'envers à l'aérographe au Tamiya smoke X-19 afin de donner un côté fumé à ce vitrage, ensuite collé à l'intérieur du boîtier :

dsc03961.jpg dsc03962.jpg

  • La plaquette est mise en place en la glissant dans la rainure prévue, puis c'est au tour du couvercle :

dsc03964.jpg dsc03965.jpg

  • Voilà…

dsc03966.jpg dsc03969.jpg]

  • C'est classe moi j'dis :D :

dsc03967.jpg dsc03971.jpg
Le module affiche NoData lorsque la transmission de donnée se passe mal, comme par exemple lorsque l'anémomètre est éteint.

Programme :

  • Le code du NodeMCU est trop imposant pour être présenté correctement dans cette page, il est téléchargeable en pièce jointe ou consultable ici.

  • Vous aurez remarqué au passage que j'ai donc connecté un second capteur à effet Hall pour mesurer la vitesse de rotation de l'éolienne, le code est dispo ici.

Vendredi, janvier 4 2019

Une éolienne à axe vertical -12-

Suite de l'ouvrage précédent :

L'éolienne n'avait pu être mise en place la dernière fois, faute de visserie suffisante pour terminer l'assemblage, et de coupleur de câble métallique nécessaire à la sécurisation du mât.

dsc03985.jpg

  • Nous avons donc dressé le mât sur son emplacement, vissé le boulon de sécurisation et resserré les 4 écrous du plot.

Ensuite après avoir enfoncé des piquets dans le sol, trois câbles ont été tendu pour raccorder ces piquets aux anneaux soudés au sommet du mât, grâce aux coupleurs de câble.
Sans système de tendeur à vis ce ne fût pas vraiment facile à régler, mais le mât est tout de même quasi de niveau, à 90° dans toutes les directions.
dsc03984.jpg dsc03982.jpg
dsc03981.jpg dsc03988.jpg

Ce n'est qu'ensuite que nous avons suspendu le rotor de l'éolienne au mât, je n'ai pas fait de photo du mât seul…

  • Au sommet du mât, on peut apercevoir l'anémomètre que j'avais bricolé, et contre l'axe de rotation, un aimant sécurisé au silicone (tout autre type de colle aurait fait l'affaire), passe en face de la pièce imprimée3D orange dans laquelle siège un capteur Hall, branché sur le NodeMCU de l'anémomètre, permettant de transmettre les vitesses du vents et de rotation de l'éolienne sur un boîtier récepteur (billet à venir) :

dsc03972.jpg 20181230_144315.jpg

Bon alors ces photos ont en fait été prises le lendemain, car le jour ou nous l'avons accroché, la nuit tombait, et j'ai donné les derniers coup de clef dans la pénombre…

Les ailes étaient alors repliées et nous pensions la laisser comme ça jusqu'au lendemain, mais la tentation de l'ouvrir était trop grande !

  • Une petite vidéo :

dsc03976.jpg Le lendemain j'ai donc fignolé ce qu'il y avait à fignoler, et pris tous ces clichés tranquillement, ainsi qu'une seconde vidéo.

  • Il n'y avait quasi pas de vent, on peut voir l'anémomètre s’arrêter, mais l'éolienne continue de tourner par inertie.

Car oui, pour le moment ça tourne à vide, elle sera décrochée afin d'être peinte.


dsc03979.jpg dsc03980.jpg

  • Une petite vidéo :


  • Cette éolienne Savonius est absolument silencieuse et démarre très facilement à faible vent, sachant que le haut des ailes est perché à 3m58, et le bas à 2m70.

La suite ?

L'ingénierie à donc été ici faite au fur et à mesure, rythme imposé par la nature des matériaux de récupération qui constituent cette éolienne.

Je sais que de par sa nature, cette machine à un mauvais rendement, et il est fort probable que produire du courant exploitable avec tournera à l'échec, auquel cas elle pourrait finir par exemple, en éolienne de pompage mécanique.

J'ai vu aussi que depuis le début de cet ouvrage, il y a 3 ans, pas mal d'autres travaux avaient poppé par-ci par-là, et notamment l'idée de coupler une éolienne Darrieus à l'éolienne Savonius, afin de bénéficier des avantages de ces deux types, tout en réduisant les inconvénients.

  • Malgré tout, je vais passer maintenant à l'étude de la génératrice et je fais des recherche en ce sens.

Ce projet notamment pourrait bien m'aider à avancer…
https://hackaday.io/project/159568-portal-point-generator
Sur le web il y a pas mal de documentation vidéos et photos sur le sujet, mais je constate avec déception, que côté littérature, y'a pas grand chose.
Tous les projets que j'ai pour le moment découvert semblent avancer de manière empirique et rien n'est documenté quant aux calculs électromagnétiques concernant notamment la détermination du type de fil (diamètre, nb de spires), puissances attendue, force de résistances prévue… Bref, pas de théorie.
Le soucis c'est que je ne suis pas à l'aise avec ce sujet, et soit je tombe sur ce genre de ressources donc sans théorie ni calculs expliqués, soit je trouve des cours théoriques d'électromagnétisme auxquels je ne pige rien. Pas de ressources ayant donc synthétisé les deux, simplement.

  • Si vous avez de bonnes adresses, je suis preneur !!

Voici quelques liens qui synthétisent assez bien le concept :
La conversion d'un alternateur en générateur : https://www.youtube.com/watch?v=VRaiHStZ1A8
L'explication simple de la production d'électricité : https://www.youtube.com/watch?v=ZaIn6tjfquo
http://www.fabriquer-eolienne.com/fabrication-generateur/
http://lowtechlab.org/wiki/Eolienne_200W

À suivre…

Lundi, novembre 19 2018

Un anémomètre WiFi -1-

dsc03927.jpg

Récemment on m'a indiqué l'existence d'une plaquette électronique du genre Arduino, mais qui a la particularité de pouvoir « faire du WiFi ».
D'abord dubitatif quant à l'utilité du truc, étant donné que je m'étais très bien passé de la chose jusqu'à présent, le truc est resté en idle dans un coin de mon esprit malade, jusqu'à ressurgir suite à mes derniers travaux sur l'Éolienne du jardin
Hé oui ! Je me suis dit que ce serait pas mal de savoir quelle vitesse de vent serait nécessaire pour pousser sur les ailes et la faire tourner, de savoir à quelle vitesse elle tournait aussi, et de pouvoir ainsi régler la tension du ressort de vitesse de rotation constante, un peu mieux qu'au… pif.

  • J'avais donc une plaquette NodeMCUv3 LoLin (à base de puce ESP8266) sous la main et après quelques tests j'ai constaté que bah c'est comme Arduino, rien de compliqué.
  • Et puis pour faire client ou serveur Web, bah c'était pas comme Arduino… et qu'il faudrait se sortir les doigts…

Oui car on peut servir des pages web, alors on pense assez vite à ordi-phone et une jauge de visualisation.
Enfin en vrai, réflexe électronicien, j'ai tout de suite pensé afficheur à leds, mais récupérer les données via du web… wé, je garde l'idée… Alors :

Pour mon projet final j'aurais besoin d'une plaquette NodeMCU en mode serveur web, perchée sur l'éolienne, pour remonter les mesures de rotation de l’anémomètre (vent) et de l'éolienne (rpm).
Les data seraient consultables via un navigateur sur un ordi ou un ordi-phone, sous forme de jauge de vitesse instantanée.
Elles seraient aussi récupérable pour former des graphiques de statistiques.
Un second NodeMCU avec des afficheurs à leds serait utilisé pour s'affranchir d'un ordi.

  • Bon c'est pas forcément facile à suivre, alors voici un dessin :

anemometre3.png

Simple anémomètre :

  • Bref, pour le moment on va juste fabriquer un anémomètre simple, avec une jauge sur ordi.

(voir même sur internet si on fait le nécessaire pour faire « sortir » les pages web).

Matériel requis :
dsc03947.jpg

- La mécanique imprimée en 3D disponible ici.
- 1 Capteur à effet Hall US1881 (absent de cette photo).
- 2 aimants permanents au néodyme ∅6 mm x 3 mm (absent de cette photo).
- 1 plaquette NodeMCUv3 LoLin.
- 1 résistance 10kΩ.
- 2 roulements à billes : ∅5 int x ∅10 ext x 4 mm.
- 1 tige filetées : ∅5 mm de 10 mm de long.
- 5 écrous de ∅5 mm.
- 3 vis : ∅3 mm de 10 mm de long (tête fraisée).
- 3 vis : ∅4 mm de 12-15 mm de long (tête poêlée).
- Un ordi avec port USB et le soft Arduino IDE.


Compétences requises :

- Électronique.
- Web design (html, css, JavaScript, Json).
Où sinon t'as du temps et l'âme d'un bidouilleur et t'y arriveras !… du coup j'ai appris plein de trucs.


Le montage :

  • Commençons par insérer les écrous dans les logements prévu après avoir percé les opercules (permettant l'impression au dessus des trous sans supports), puis à fermer la structure avec les vis de ∅3 mm.

dsc03944.jpg dsc03946.jpg

  • Insérer un roulement dans son support, puis insérer le support dans le fond.

dsc03935.jpg dsc03934.jpg

  • Préparer la tige filetée avec deux écrous bloqués à 3 mm du bord de la tige. L'idée c'est qu'une fois en place sur le roulement la tige puisse tourner librement.

dsc03936.jpg dsc03937.jpg

  • Ensuite, régler la hauteur du support d'aimants (en gris, aimants pas encore dispo sur la photo) pour qu'il soit à hauteur du logement du capteur Hall (une des petites fentes, capteur pas encore dispo sur la photo). Le NodeMCU se loge simplement à l'endroit prévu.

dsc03940.jpg dsc03941.jpg

  • Voilà, on peut mettre le roulement du haut et fermer le bas avec les vis de ∅4 mm après avoir taraudé les trous de vis. Le socle est donc ici adapté pour s'enficher sur le mât de l'éolienne, en lieu et place du cône que j'avais imprimé alors.

dsc03943.jpg dsc03932.jpg

  • Coller le chapeau à la cyanoacrylate par dessus (après avoir percé l'opercule) puis placer un écrou pas trop bas, et visser le col par dessus après l'avoir taraudé au ∅5 mm, voire même ajouté du vernis/résine de blocage au filetage. Ceci devrait permettre de protéger le boîtier et le roulement de la pluie.

dsc03931.jpg dsc03930.jpg

  • Reste à visser les hélices, et serrer le tout avec un écrou. (Photo en début de billet)



Le schéma :

  • Pas trop compliqué…

Anemometre01_bb.png

Le câblage :

  • C'est facile à câbler… Et il suffit de glisser le capteur à effet Hall dans une des deux fentes prévues. Avec le capteur US1881 il faut placer deux aimants sur le support, un orienté pôle nord, et l'autre pôle sud (cf.datasheet).

dsc03949.jpg dsc03952.jpg

Programmation du NodeMCU :

  • Pour programmer un NodeMCU avec l'Arduino IDE il faudra rajouter le support du module esp8266, voici 3 pages qui vous expliqueront comment faire : Via fais-le-toi-meme.fr ou henrys-bench.

Tout le code de l'anémomètre est téléchargeable ici ou en annexe à ce billet.
Créer un dossier qui contiendra cette arborescence :

Anemometre_esp8266_WifiSVR_SPIFFS_Hall/Anemometre_esp8266_WifiSVR_SPIFFS_Hall.ino
Anemometre_esp8266_WifiSVR_SPIFFS_Hall/data/index.html
Anemometre_esp8266_WifiSVR_SPIFFS_Hall/data/css/style.css
Anemometre_esp8266_WifiSVR_SPIFFS_Hall/data/js/java_vent.js
Anemometre_esp8266_WifiSVR_SPIFFS_Hall/data/js/jquery.min.js
Anemometre_esp8266_WifiSVR_SPIFFS_Hall/data/js/loader.js
  • Ainsi pour programmer la plaquette, il suffira de procéder au téléversement du projet Arduino, ça c'est comme d'habitude avec l'Arduino IDE.

Contrairement à un Arduino classique, l'upload peut s'avèrer être très long, on peut donc augmenter la vitesse via le menu Outils et sélectionner Upload Speed : 921600

  • Et pour téléverser les fichiers html, css et JavaScript, il faudra cliquer Outils et cliquer ESP8266 Sketch Data Upload, ce qui aura pour effet d'immédiatement copier les fichiers contenu dans le dossier data sur la plaquette.

Sauf que ce menu n'est pas disponible par défaut !
Il faut en effet télécharger un fichier à déposer dans le dossier du « carnet de croquis », sous une arborescence spécifique, ce qui donne chez moi : /home/user/Arduino/tools/ESP8266FS/tool/esp8266fs.jar
Tout est expliqué ici : https://github.com/esp8266/arduino-esp8266fs-plugin


Fonctionnement :
Ensuite ouvrir Outils > Moniteur série , qui devrait afficher l'adresse IP de la plaquette (sinon appuyer sur le bouton Reset), et rendez-vous sur un navigateur avec cette IP en URL et voila !
anemometre.png
C'est une petite entrée en matière intéressante de la conception d'un « appareil connecté », j'ai découvert comment tout ça s'articule…
Plus à l'aise avec l'électronique, je touche mes limites techniques concernant la partie développement web, avec pas mal de méconnaissances du sujet qu'il faut que je travaille (wé j'en suis resté au web 1.0…), en vue dans de prochains billets, d'aborder les divers éléments liés à mes besoins plus spécifiques.

Principe :
L'aimant passe devant le capteur à effet Hall à chaque rotation de l'axe de l'anémomètre, ce qui envoie une impulsion qui est alors réccupérée par le NodeMCU pour être traitée afin de mesurer la vitesse de rotation, puis de la convertir en Km/h. Cette mesure est envoyée au serveur Web sous la forme d'un fichier JSON écrit en zone SPIFFS, qui est mis à jour toutes les secondes (valeur réglable au début du code Arduino)

Présentation du contenu des fichiers :
J'ai commenté assez largement le code, mais n'espérez pas tout comprendre si un des langages vous échappe…

Le fichier JSON ressemble à ceci :

{
  "VitesseVent":"25"
}

Lorsqu'on consulte la page Web, le JavaScript contenant la jauge est appelé et celui-ci récupére la valeur du JSON pour animer l'aiguille et afficher la valeur, toutes les secondes (en adéquation avec le réglage du code Arduino)

  • Le fichier data/js/jquery.min.js est une libraire standard (ou un truc du genre) qui se télécharge sur internet.
  • Le fichier data/js/loader.js est une libraire google (ou un truc du genre) qui se télécharge chez google chart.
google.charts.load('current', {
        'packages': ['gauge']
      });
      google.charts.setOnLoadCallback(drawChart); //  https://developers.google.com/chart/interactive/docs/gallery/gauge

      function drawChart() {    // Fonction principale : 

        // Create and populate the data table.
        var dataGaugeVent = google.visualization.arrayToDataTable([
          ['Label', 'Value'],
          ['Vent', 0],
        ]);

        // formatage avec un suffixe et # pour arrondir
        var formatter = new google.visualization.NumberFormat({
          suffix: ' Km/h',
          pattern: '#'
        });

        // définition des options documentée ici https://developers.google.com/chart/interactive/docs/gallery/gauge
        var options = {
          width: 800, height: 720,
          greenFrom:0, greenTo: 60,   // zones de couleurs
          yellowFrom:60, yellowTo: 80,
          redFrom: 80, redTo: 100,
          majorTicks: ['0', 10, 20, 0, 0, 50, 0, 0, 80, 90, 100], // graduations
          minorTicks: 5, // graduations
          max: 100, min: 0,
          animation: {
            duration: 100,  // vitesse de l'aiguille
            easing: 'linear',   // comportement de l'aiguille
          }
        };

        // init du graphisme
        var GaugeVent = new google.visualization.Gauge(document.getElementById('chart_div_vent'));

        // tracé du graphisme
        GaugeVent.draw(dataGaugeVent, options);
        updateGauge();  // exécute la fontion
        setInterval(updateGauge, 100); // appelle les données de la fonction et définit la vitesse de rafraichissement

        function updateGauge() {     // fonction de mise raffraichissement des données réccupérée dans le fichier json https://www.w3schools.com/jquery/ajax_getjson.asp

          $.getJSON('/mesures.json',

            function(data) {

              $.each(data,

                function(nom, valeur) {

                  dataGaugeVent.setValue(0, 1, valeur); // premier nb pour le N° de la gauge si plusieurs, puis 0 pour modifier le champ label (sinon:1 pour le champ Value), puis la valeur extraite du json
                  GaugeVent.draw(dataGaugeVent, options); // tracé du graphisme
                  formatter.format(dataGaugeVent, 1); // applique le formattage à la seconde collonne du tableau (1) qui correspond à la valeur

                });
            });
        }
      }
  • Le fichier data/css/style.css pour la mise en page :
.container_inner {
   background-color: #555555;
  width: 450px;
  margin-left: -165px;
  padding-left: 60px;
  padding-top: 160px;
  padding-bottom: 160px;
  position: fixed;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
}
  • Le fichier data/index.html, où l'on charge les 3 JavaScripts et la feuille de style css. Puis on y appelle le graphisme de la gauge.
<!DOCTYPE html>
<html>
	<head>
		<title>Eolienne</title>
		<link rel="stylesheet" type="text/css" href="css/style.css">
		<script type="text/javascript" src="js/jquery.min.js"></script>
		<script type="text/javascript" src="js/loader.js"></script>
		<script type="text/javascript" src="js/java_vent.js"></script>
	</head>
  
	<body>
		<div class="container_inner">
			<div id="chart_div_vent"></div>
      </div>
	</body>
</html>
  • Le fichier Anemometre_esp8266_WifiSVR_SPIFFS_Hall.ino, qui contient le code C++ type « Arduino », pour mesurer la vitesse de rotation et envoyer les données au serveur Web.
#include <ESP8266WebServer.h>
#include <FS.h>
#include <WiFiUdp.h>  //pour upload de pgm Arduino via wifi
#include <ArduinoOTA.h> //pour upload de pgm Arduino via wifi

/****************/
/* DÉCLARATIONS */
/****************/
ESP8266WebServer server ( 8080 );   // on instancie un serveur ecoutant sur le port 80
#define pinHallAnemo D2   // le capteur à effet Hall est connecté à la pin D2
#define ssid      "xxxx"    // WiFi SSID
#define password  "****"  // WiFi password
unsigned long rpmVent = 0;
unsigned long vitVentKMH = 0;
unsigned long dateDernierChangementVent = 0;
unsigned long dateDernierChangementKMH = 0;
float intervalleKMH = 0;

/*********/
/* SETUP */
/*********/
void setup() {
  Serial.begin ( 115200 );    // init du mode débug
  // Connexion au WiFi
  WiFi.begin ( ssid, password );
  // Attente de la connexion au réseau WiFi / Wait for connection
  while ( WiFi.status() != WL_CONNECTED ) {
    delay ( 500 ); 
    Serial.print ( "." );
  }
  // Connexion WiFi établie
  Serial.println ( "" );
  Serial.print ( "Connected to " ); Serial.println ( ssid );
  Serial.print ( "IP address: " ); Serial.println ( WiFi.localIP() );

  // Montage de la zone mémoire SPIFFS
  if (!SPIFFS.begin()) {
    Serial.println("SPIFFS Mount failed");
  } 
  else {
    Serial.println("SPIFFS Mount succesfull");
  }
  delay(50);

  // Pin capteurs
  attachInterrupt(pinHallAnemo, rpm_vent, FALLING); 
  
  // Pages web du serveur
  server.serveStatic("/js", SPIFFS, "/js");       // dossier js qui contient les fichiers JavaScripts
  server.serveStatic("/css", SPIFFS, "/css");     // dossier css qui contient les fichiers css
  server.serveStatic("/", SPIFFS, "/index.html"); // racine du serveur, pointe l'index.html
  server.on("/mesures.json", sendMesures);        // écrit le fichier json à l'appel de la fonction
  server.begin();                                 // démarre le serveur
  Serial.println ( "HTTP server started" );
  ArduinoOTA.setHostname("AnemometreWiFi");   // on donne une petit nom a notre module, pour upload de pgm Arduino via wifi
  // ArduinoOTA.setPassword((const char *)"1357");
  ArduinoOTA.begin();   // initialisation de l'OTA, pour upload de pgm Arduino via wifi
}

/*************/
/* FONCTIONS */
/*************/
void rpm_vent()   // appelée par l'interruption, Anémomètre vitesse du vent.
{ 
  unsigned long dateCourante = millis();
  intervalleKMH = (dateCourante - dateDernierChangementVent);
  Serial.print ( "intervalle en s : " );
  Serial.println (intervalleKMH/1000); // affiche l'intervalle de temps entre deux passages
  if (intervalleKMH != 0)  // attention si intervalle = 0, division par zero -> erreur
  {
    rpmVent = 60 / (intervalleKMH /1000);  
  }
  vitVentKMH = ( rpmVent / 12 );
  Serial.print ( "vitVentKMH : " );
  Serial.println ( vitVentKMH ); // affiche les rpm  
  Serial.println ( "" );
  dateDernierChangementVent = dateCourante;
}


void sendMesures()    // appelée par le serveur web
{  
 String json = "{"rpm":"" + String(vitVentKMH) + ""}";
// prépare et formate la valeur pour le fichier json sous la forme : {"VitesseVent":"0.00"}
//                          {
//                            "VitesseVent":"25"
//                          }
  server.send(200, "application/json", json);   // envoie dans le valeur dans le fichier json qui tourne en mémoire
//  Serial.println("Mesures envoyees");
}


void RemiseZeroVitVentKMH ()
{
  unsigned long dateCouranteKMH = millis();
  if (intervalleKMH == intervalleKMH) // Si ça ne tourne plus (valeur plus mise à jour)
  {  
    float dureeKMH = (dateCouranteKMH - dateDernierChangementKMH);
    if (dureeKMH > 10000) // Si ça ne tourne plus depuis 10 secondes
    {
      Serial.print ( "dureeKMH : " );
      Serial.println ( dureeKMH ); // affiche les rpm  
      vitVentKMH = 0;  // Remsise à zero !
      dateDernierChangementKMH = dateCouranteKMH;    
    }
  }
}

/*************/
/* PROGRAMME */
/*************/
void loop()
{
  server.handleClient();  // à chaque iteration, on appelle handleClient pour que les requetes soient traitees
  RemiseZeroVitVentKMH ();
  delay(100); // la boucle fait tourner sendMesures(), via handleClient, régler delais si besoin de mettre à jour le JSON qu'à une fréquence voulue plutôt qu'instantanément 
  ArduinoOTA.handle();  // régler upload speed à 9600 : verifie si un upload de programme Arduino est envoyé sur l'ESP8266
}

Projet inspiré de celui-ci :
https://projetsdiy.fr/projet-diy-anemometre-girouette-objet-connecte-esp8266/
https://projetsdiy.fr/esp8266-web-serveur-partie5-gauges-graphiques-google-charts/#top_ankor

À Suivre…

Jeudi, novembre 1 2018

WebRadioRéveilWifi -Fin-

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

Une petite vidéo :

Mercredi, octobre 31 2018

Impression en 3D d’un capot à poussière pour affleureuse Bosch

L’utilisation de mon affleureuse génère beaucoup de poussières difficiles à capter. Pour améliorer la récupération des poussières, j’ai modelé un capot à l’aide de freecad.

De part la forme de la pièce, l’impression de supports est indispensable. Le connecteur pour l’aspirateur est standard et fait 35mm.

L’impression est réalisée en ABS avec des couches de 0.2mm.

La pièce est disponible en téléchargement sur Thingiverse.

- page 1 de 99