Archives de catégorie : Projets

Consultez ici la liste de mes projets

Milliwattmètre à AD8307

Note: tous les liens s’ouvrent dans un nouvel onglet.

Introduction

Le circuit AD8307 d’Analog Devices est un détecteur logarithmique. Il est capable de mesurer la puissance d’un signal radio jusqu’à 500 MHz.

Voyons pourquoi la caractéristique logarithmique est intéressante. Un détecteur à diode (un pont de diodes utilisant des diodes Schottky rapides) produit un signal de sortie proportionnel à la puissance du signal radio. C’est pratique pour des signaux importants, mais en pratique, si le signal est trop faible, le détecteur sort soit aucune tension, soit une tension trop faible pour être mesurée sans amplificateur additionnel.

Un détecteur logarithmique, au contraire, est construit comme une suite d’amplificateurs saturables, et produit une tension correspondant au… logarithme de la puissance radio, en général quelques millivolts par décibel. Pour faire simple, cela fonctionne comme un multimètre à calibre automatique. Chaque fois que le signal est trop grand ou trop petit, le chip passe au “calibre” précédent ou suivant et donne une information mesurable. Cela lui permet d’avoir une plage de sensibilité (dynamique) beaucoup plus grande, tout en gardant un signal de sortie qui varie dans des proportions limitées.

On peut alors utiliser ce composant comme milliwattmètre (ou wattmètre avec le bon atténuateur). Mesurer de manière précise une puissance RF dans une large plage dynamique a de nombreuses applications pratiques, comme par exemple la réalisation d’un analyseur scalaire, ou la mesure de composants RF, comme des atténuateurs ou amplificateurs.

Dans le cas de l’AD8307, la dynamique est de 90 dB.

10dB représentent un rapport de 10^(10/10)=10 entre le mini et le maxi détectable, soit par ex. de 1 a 10 mW ou de 100 mW à 1W.

90dB représentent un rapport de 10^(90/10) = 10^9, soit 1 milliard, par ex de 1uW à 1 kW, ou encore 1nW à 1W, ou de 1pW à 1mW

Dans notre cas le maximum détectable est de de +15 dBm (30mW), ce qui amène le minimum à -75 dBm (30 pW, oui pico-watts!)

Ce rapport de 1 milliard entre la puissance la plus basse mesurable et la plus élevée est ramené a une plage de tension de 5V, la fonction logarithme “écrase” donc considérablement ces variations extrêmes de puissance pour les rendre mesurables. Une variation de 10 dB produira un résultat de 200 mV que le signal mesuré varie de -70 à -60 dB ou bien de -10 à 0 dB.

Le schéma

Le schéma est un classique qu’on retrouve un peu partout sur le web. L’impédance d’entrée du circuit est spécifiée a 1.1 kohms, une résistance parallèle de 52.3 ohms  permet de la ramener au classique 50 ohms. On peut alors faire une mesure directe de la puissance envoyée par une source de cette impédance sans réflexions parasites.

500 MHz est une bande passante très large, donc attention aux bruits divers mesurés en même temps que le signal utile: Il faudra bien blinder le boitier!

L’alimentation est régulée à 5V et nettoyée par des condensateurs de découplage. une résistance série de faible valeur sur l’alimentation de l’AD8307 améliore encore ce découplage (en cas de “pics” (bruit) de consommation, une différence de potentiel apparait aux bornes de cette résistance, ce qui évite de faire varier d’autant la tension du bus commun d’alimentation. Les potentiomètres de réglage de la pente et de l’offset sont repris du datasheet du composant et permettent de régler précisément le “gain” du circuit a 20 mV par décibel.

La sortie du circuit est bufferisée par un ampli-io rail to rail qui permet de fournir assez de courant sous une impédance suffisamment basse pour attaquer un cable et un multimètre ou un convertisseur analogique-numérique. Lui aussi est alimenté a travers une résistance série, et les condensateurs de découplage sont au plus près de la patte d’alimentation

Réalisation

Le PCB (13x45mm, panel de 8 circuits à l’échelle 1) est réalisable par la méthode du toner transfer sur de l’époxy double face. Il y a un straps et trois vias de masse (0.6mm, faisable a la main avec un petit mandrin pour éviter de casser le foret dans une dremel qui vibre!) Nul besoin de trous métallisés, on s’en sort en soudant des bouts de fil rigides de chaque coté du PCB. Le circuit a été étamé au fer a souder pour éviter son oxydation, en utilisant du flux colophane pour faciliter le mouillage. Souder d’abord l’ad8307 et l’ampli op, puis les passifs 0805 et finir par les potentiomètres (5Eur le bout, soyez délicats!) Finir par une SMA “flange” ou “end launch” en laiton (les modèles inox ou nickelés ne sont pas soudables).

Le montage

Le circuit finalisé, après test, est enveloppé d’une petite boite faite en clinquant de laiton. La version “flange” de la fiche SMA facilite la réalisation du blindage.

On peut ensuite visser à la SMA un adaptateur SMA male-male pour protéger la fiche SMA femelle, car celle ci est fragile.

Tests et calibration

Alimenter le montage sous 9V DC.

Pour calibrer il faut disposer:

  • d’une source RF de puissance suffisante (10 dBm) à une fréquence moyenne, par ex. 10 MHz. J’utilise un OCXO mais un oscillateur DIL suivi d’un DC-block (100nF en série, Xc=0.16 ohms @ 10 MHz) fonctionne aussi.
  • d’atténuateurs 10,10,20,30 dB. Attention à ne pas appliquer la composante continue d’un signal TTL (Vcc/2) à un atténuateur résistif!

Connecter l’atténuateur 10 dB (signal sur l’AD8307 aux alentours de 0 dBm). Mesurer le niveau, de sortie et le noter.

Connecter des atténuateurs supplémentaires pour diminuer le signal de, disons 50 ou 60 dB supplémentaires. Mesurer encore la tension. On doit trouver 60×20 = 1200 mV de moins. Régler le potentiomètre Slope (RV1) pour que ce soit le cas (théoriquement le potard permet un réglage entre 18 et 22 mV/dB). OK, la pente est calibrée.

Note: il faut mesurer boitier fermé, même si on doit l’ouvrir pour régler RV1 !

Ensuite, court-circuiter l’entrée et calibrer l’intercept (RV2) pour avoir xxx mV (TBD).

Une meilleure calibration, plus absolue est possible avec un générateur d’amplitude connue (ce n’est pas si évident).

Mais dans la plupart des cas, on va vouloir mesurer des atténuations ou des amplifications par rapport à une référence, donc seul le réglage de la pente est réellement “critique” et pourrait être à revoir pour des fréquences vraiment faibles ou élevées. D’après le datasheet, il devrait être encore bon à 100 MHz. En général une mesure large bande commence par une acquisition permettant la calibration automatique du détecteur sur chaque fréquence. Nous en reparlerons plus tard.

Utilisation

Il suffit d’alimenter le montage et de lire le niveau de signal a l’aide d’un multimètre ou d’un galvanomètre.

On peut bien entendu connecter la sortie du montage à un ADC pour lire le niveau de signal sur un arduino ou autre. La résolution de l’ADC donnera directement l’incrément de puissance mesurable:

8 bits: 256 steps -> 90/256 = 0.35 dB/step
10 bits: 1024 steps -> 0.09 dB/step
12 bits: 4096 steps -> 0.02 dB/step

A partir de 12 bits on atteint une précision qu’il n’est pas réaliste d’obtenir, même avec des calibrations métrologiques de haute précision (pour des mesures plus précises, comme on le fait en radiastronomie, il faut un radiomètre, il y a plusieurs technologies). Les effets de la température, de la linéarité, et de la réponse en fréquence sont plus importants que cette précision théorique. Même 0.1 dB significatifs sont difficiles à justifier. Donc inutile de donner des mesures en dB avec plus d’un chiffre significatif, cette précision n’a aucune signification. 0.5 dB est déja une bonne indication. Lors de votre mesure avec un arduino, pensez à moyenner plusieurs mesures pour éviter les effets du bruit de la mesure et de l’ADC.

Compilation de FreeDV sous linux mint (ubuntu, debian, etc)

Après de longues discussions sur twitter, je m’intéresse un peu a la Digital Voice (modes digitaux pour la transmission de la voix).

Autant le dire tout de suite: Vous ne trouverez ici ni DSTAR ni DMR, on est pas la pour polémiquer (ni pour personne d’autre d’ailleurs ©).

Je m’intéresse uniquement au logiciel libre freedv, et au codec libre qu’il intègre, codec2. Ce codec est capable de coder la voix humaine (et non un signal arbitraire) de manière très compacte, on parle d’environ 64 bits toutes les 20 ms. Ce codec a été inventé par l’auteur de speex, un codec très utilisé en téléphonie.

Ce flux de bits est encodé dans une modulation de type OFDM utilisant 16 porteuses modulées en QPSK, espacées de 75 Hz, pour une bande passante totale de 1,5 kHz, ce qui est la moitié de la bande nécessaire a la transmission de la voix en analogique, en modulation SSB.

La réception se fait via la sortie HP, et la transmission se fait via l’entrée micro et d’un transceiver. Un PC et une carte son suffisent au décodage, mais il faut bien sûr 2 cartes son pour transmettre et recevoir: Ce genre de truc fait parfaitement l’affaire pour un budget réduit (j’ai pas d’action chez eux mais leur glutte fonctionne).

Bref, pour commencer a tester, faut du soft. celui ci s’appelle freedv. Il est distribué via subversion et utilise cmake

Installez un peu plus de bazar sur votre distro si ce n’est pas déja fait

sudo apt-get update
sudo apt-get install cmake subversion gcc binutils libwxgtk3.0-dev libhamlib-dev libsndfile1-dev

Ensuite il faut portaudio, mais uniquement la version 19 (les autres ne fonctionnent pas a cause d’une API différente, oui j’ai testé). Donc:

sudo apt-get install portaudio19-dev

Sauf que chez moi le paquet portaudio19-dev ne veut pas installer automatiquement ses dépendances. Bref, faites dans l’ordre:

sudo apt-get install libjack0
sudo apt-get install libjack-dev
sudo apt-get install portaudio19-dev

et ca devrait être bon.

NOTE: sur mon système certaines de ces libs sont déja installées, cela demande peut être d’autres dépendances, merci de me les indiquer en commentaires. Si vous utilisez du redhat like, et que vous arrivez a compiler, faites moi signe et on ajoutera ces infos.

Une fois que c’est fait on obtient le code de freedv. Pour la version stable on prend:

 svn co https://svn.code.sf.net/p/freetel/code/freedv/branches/1.2 freedv

Si on préfère la version de développement (a fonctionné chez moi mais peut être temporairement cassée):

 svn co https://svn.code.sf.net/p/freetel/code/freedv-dev freedv

Une fois fait on crée un répertoire de compilation et on y entre:

mkdir freedv-build
cd freedv-build

et on lance la configuration

cmake ../freedv

si cela provoque une erreur signalez moi la dans les commentaires pour qu’on en parle, si cela finit bien on lance la compil avec

make

et une fois arrivé a 99% on obtient un binaire freedv dans le dossier src, qu’on peut lancer:

src/freedv

Ce qui donne la fenêtre principale du programme:

Interface de FreeDV 1.2
Interface de FreeDV 1.2

 

Dans le menu Tools on peut configurer les cartes sons a utiliser, et plein d’autres choses encore que je n’ai pas encore découvert.

En tout cas… ca a buildé!

IEEE 802.15.4 avec MRF24J40, ST Nucleo et NuttX

Et non Zigbee, qui est une stack de protocole complète!

Il y a longtemps que ce protocole radio basse consommation me plait. Le fait qu’il soit un standard m’attire car il garantit une certaine interopérabilité entre les fabricants de chips.

Je m’intéresse pour l’instant au 802.15.4, qui est un peu l’Ethernet du Zigbee.

Il y a longtemps (OH SHI– en dec 2012) j’avais acheté une paire de modules Microchip MRF24J40MA, et j’avais essayé de les faire fonctionner avec des PIC18. Sans grand succès. La relecture de l’article vous donnera des détails sur le protocole et la ou j’en étais resté.

Depuis, j’ai beaucoup joué avec les ARM Cortex, et j’ai gagné pas mal d’expérience en programmation système. Je travaille quotidiennement avec le RTOS NuttX qui permet de développer facilement des apps embarquées, avec un framework très complet de drivers.

En mélangeant tout cela, j’ai rapidement pu développer un driver NuttX pour le MRF24J40. Le chemin a été long:

-le bus SPI du STM32F411 ne fonctionnait pas; il perdait le LSB des transmissions a cause d’un mauvais réglage du slew-rate

-les datasheets du MRF24J40 sont écrites avec les pieds… un peu comme toutes les docs Microchip, quoi… Donc pour les fonctions basiques pas de problème, mais pour les détails, il faut passer du temps sur le web, les forums Microchip, les exemples de code… pour arriver a tout faire coller

Hier j’ai pu me procurer un module haute puissance (MRF24J40MC, avec antenne extérieure). Et rebelote… Pour arriver a faire fonctionner correctement les amplis RF du module, il m’a fallu une journée complète, avant de réaliser que la config des amplis doit être faite beaucoup plus souvent que prévu!

Enfin bref j’ai pu tout faire coller et maintenant, ma carte Nucleo se comporte maintenant comme un couteau suisse ieee.

La détection d’énergie (scan passif) fonctionne, le secret pour un bon affichage est de ne pas afficher la valeur recue, mais de mettre a jour l’affichage si on recoit une valeur supérieure a la valeur actuelle, et sinon de faire baisser le signal recu “artificiellement”, exactement comme sur un vu-mètre audio. La raison est simple: les paquets sont si courts qu’il est rare d’en voir passer suffisamment pendant une simple mesure.

nsh> i8 /dev/ieee0 scan
IEEE packet sniffer/dumper argc=3

11 : [ 58] #######
12 : [104] #############
11 : [ 57] ####### 
11 : [ 61] #######   
12 : [ 89] ########### 
13 : [ 80] ##########
14 : [ 61] ####### 
15 : [145] ##########################           
16 : [190] #######################          
17 : [102] ############    
18 : [111] #############       
19 : [111] #############   
20 : [  0]                                       
21 : [ 55] ###### 
22 : [ 66] ######## 
23 : [ 26] ###                                  
24 : [  0]                                 
25 : [ 12] #                                 
26 : [ 46] #####

Bon c’est bien rigolo ca, mais le scan actif est bien plus intéressant. Il s’agit d’envoyer, sur chaque canal, des “beacon requests”, puis d’attendre les “beacons”, des paquets qui informent sur la présence d’un noeud réseau. Voici un exemple de sortie:

chan=13 rssi=138 lqi=117 len= 11 [6942/0100 -> none] FFCF000046344752582F30
chan=15 rssi= 41 lqi=116 len= 19 [507C/0200 -> none] FF0F000000228C2DFD01E0C8B656BEFFFFFF00
chan=25 rssi=  0 lqi=117 len=  6 [C513/4DD5 -> none] FF4F0000CE01

Le RSSI est le niveau de puissance recue (arbitraire, 0-255), le LQI la qualité de réception (pas forcément liée à la puissance), entre crochets on a les champs d’adressage 802.15.4 (les beacons ont une adresse source mais pas d’adresse de destination car ce sont des broadcasts), puis la payload MAC:

“FF” -> réseau sans structure temporelle (superframe)
“CF” -> options
“00” -> Pas de Guaranteed Timeslot
“00” -> Pas de pending address
(pour ce charabia, voir la spec 802.15.4, elle est dispo en téléchargement gratuit)

Ce qui suit est le champ d’infos de la balise, il peut contenir n’importe quoi. Il y a un format spécial pour Zigbee, que je ne connais pas encore; c’est probablement ce qui est utilisé sur le paquet du canal 15.

Le canal 13 est celui que j’ai utilisé pour mon prototype de coordinateur, qui utilise une autre carte Nucleo. La payload est définie a “46344752582F30”, C’est a dire “F4GRX/0”, maniere d’être identifiable si on me décode, comme tout bon radio-amateur doit le faire.

Conclusion

Je me suis bien amusé avec ce protocole. Le projet a été suspendu pendant longtemps, mais la persévérance a payé: les couches basses fonctionnent.

Je peux maintenant passer au codage du coordinateur ‘en vrai’. Le coordinateur est un peu le “point d’accès wifi”. Il sert de plaque tournante a des périphériques ieee a intelligence (et conso) réduite.

Le code sera bientot intégré dans le code principal du RTOS NuttX. En attendant, le code est consultable dans mon fork de nuttx sur BitBucket, dans la branche ieee:
git clone https://bitbucket.org/slorquet/nuttx
git checkout ieee

La sauce secrète est ici: https://bitbucket.org/slorquet/nuttx/src/72ff5be3ee257b385751d5678901aa9edb45a1f9/drivers/ieee802154/mrf24j40.c?at=ieee

Ce a quoi il faut ajouter ce fork des apps de base NuttX:
git clone https://bitbucket.org/slorquet/apps
git checkout ieee

Allez un jour je vous expliquerai comment faire fonctionner NuttX. Sachez déja que ce sera sous Linux, parce que c’est trop galère sous Windows.

Fraise sans chantilly

Hello,

La semaine dernière j’ai pu utiliser la fraiseuse conventionnelle de l’Electrolab.

Je m’en suis servi pour surfacer le dessous de la pièce en laiton coulée la dernière fois. J’en ai profité pour nettoyer aussi quelques autres surfaces.

La qualité du laiton coulé “a la maison” est très bonne. Le bloc de métal est très homogène et sans bulles.

La pièce a été mise de niveau dans l’étau de la fraiseuse en se basant sur la distance entre le tube et la fraise, il y a environ 1mm d’erreur d’horizontalité sur la longueur totale du tube (45cm). On va dire que c’est assez horizontal pour notre affaire.

Fraisage
Fraisage de l’arrière

 

Le dessous est fini, passons au dessus.
Le dessous est fini, passons au dessus.

 

Breubreubreu
Breubreubreu, ici viendront des taraudages et la base d’un entonnoir rectangulaire

 

Tout propre!
Tout propre!

 

Une petite vidéo est dispo ici:

https://www.youtube.com/watch?v=6GDFvNYa6RA

 

Silence on coule

Hop, un petit article comme promis.

La semaine dernière les copains de l’Electrolab ont coulé en laiton le modèle de fonderie que j’avais fait en polystyrène.

Donc voila, maintenant j’ai la trémie de l’extrudeur, c’est vraiment super. La pièce pèse plusieurs kilos, et quand je l’ai récupérée, elle était super moche :

Brut de fonderie!
Brut de fonderie!

C’est incroyable comme la piece brute est moche. Normal, elle a été moulée dans le sable, le procédé est violent. Les surfaces sont tres irregulieres, il y a eu des fuites de métal, et comme mon pote s’est dépêché pour la mouler, elle est un peu tordue, arquée.

Un coup de meleuse pour avoir l'air plus présentable!
Un coup de meleuse pour avoir l’air plus présentable!

Un coup de meleuse avec disque abrasif (visible en fond), et hop la couleur laiton refait surface! C’est super long, j’ai fini le nettoyage a la simple brosse métallique, c’est plus facile et l’état de surface est plus intéressant.

La vis se présente bien
La vis se présente bien

La vis et le palier se présentent bien, mais rien ne rentre comme prévu. C’est normal, il faut ajuster tout cela a la lime et en usinage. En particulier, le palier a du mal a rentrer, et Tom m’a aidé a réusiner la pièce coulée; les derniers dixièmes de mm ont été réglés… au marteau, pour enfoncer le palier dans son logement. Il finira brasé. On a eu du mal a faire rentrer le tube en cuivre. Pendant un moment, j’ai même envisagé de ne pas le faire traverser… mais les copeaux de plastique arrivent a se coincer entre la vis et la trémie, pas cool… Le problème de déformation de la pièce a finalement été réglé… a coup de masse! Un seul coup de marteau bien placé, et hop, le tube et la vis sont parfaitement rentrés!

Le tube et le palier sont en place
Le tube et le palier sont en place

Etapes suivantes: brasure du tube et du raccord palier, puis ouverture du tube dans la trémie, et enfin, percage et taraudage des flancs et des pieds, puis formation de l’entonnoir avec de la tole fine.

Le long chemin de la réalisation d’une imprimante 3D

Dans ces jours silencieux, ce n’est que le blog qui est resté blanc! J’ai beaucoup avancé sur mes réalisations, en particulier sur l’impression 3D.

eShapeoko

Je développe encore mon expertise 🙂 Je conçois maintenant pas mal d’objets à partir d’assemblages de morceaux découpés dans des plaques de MDF 6mm. Après le support de turbines, j’ai fait une nouvelle boite pour l’électronique de l’imprimante (avec l’arduino mega reçu, le Pololu de l’extrudeur, les mosfets de commande des chauffages et ventilateurs, et beaucoup de connectique!)

Contrôleur d'imprimante 3D (état au 9 déc 2013)
Contrôleur d’imprimante 3D (état au 9 déc 2013)

Il reste encore un peu de câblage à finir.

Coté usinage encore, j’ai trouvé une broche qui me fait de l’oeil, la Milwaukee DG30E, dispo chez BHV, 500 watts, 33000 rpm, pinces interchangeables, et surtout, pas de jeu! Seule inconnue: le bruit!

Coté logiciel, Marlin tourne déja dans l’Arduino, avec une configuration adaptée à ma machine, très similaire pour la commande à une carte Generation 7 ou à un shield RAMPS.

Coté chauffage

J’ai enfin pu utiliser le tour et la fraiseuse de l’Electrolab, merci encore à Ellyan pour sa patience et sa pédagogie. Je ne prétends pas encore maîtriser ces machines complexes, mais je commence au moins à me débrouiller. J’ai réalisé les pièces suivantes, qui réimplémentent d’une manière simplifiée l’extrudeur miniature de la foldarap:

  • Equerrage et surfaçage d’un bloc 10x12x20mm pour le corps de chauffe. Perçage à 6mm pour la résistance de chauffage, perçage et taraudage M4 pour la mini-buse et le tube en acier de connexion à la partie froide.
  • Equerrage et surfaçage d’un bloc de 10x12x40mm pour le corps froid. Perçage à 3mm pour la fixation sur le radiateur, perçage et taraudage M4 pour la connexion à la partie chaude, et perçage/taraudage borgne M5 pour l’embout pneumatique.
  • Surfaçage, perçage concentrique à 2mm et 0.5mm dans de la tige filetée laiton pour fabriquer la buse. Je remercie énormément Emmanuel Gilloz de m’avoir indiqué cet objet, particulièrement simple à réaliser et extrêmement économique (encore plus que mes boutons en laiton du BHV!).
  • Perçage concentrique et réduction de diamètre de vis filetée M4 pour la connexion entre les blocs chauds et froids (isolateur thermique)
  • Surfaçage du radiateur pour permettre la fixation du bloc froid.

Si vous avez tout suivi, vous devez imaginer à quoi ressemble mon extrudeur. Dans tous les cas, en voici une image:

Extrudeur type Foldarap
Extrudeur type Foldarap. L’isolateur est une version de test, trop courte.

Coté filament

Mon extrudeur est de type “Bowden”, c’est à dire que le chauffage et l’avance du filament sont séparés par un tube flexible. Il me faut donc créer un bloc d’avance de filament. Celui ci a été conçu selon ma méthode MDF, il se base sur un moteur pas à pas pas très costaud, mais dont l’axe est cannelé juste comme il faut pour m’éviter la fabrication d’une vis d’avance! Et dire que ce moteur dormait depuis plusieurs années dans un tiroir… Comme quoi la récupération a du bon 😀

Etat actuel du pousse-filament
Etat actuel du pousse-filament
Modélisation du pousse-filament
Modélisation partielle du pousse-filament

Lit chauffant

Je n’ai encore rien fait de ce coté, je sais qu’il est indispensable pour l’ABS, mais pour le PLA, ce n’est pas le cas. je le construirai si besoin.

 

Le moment de la première impression s’approche donc à grands pas!

Les objets du week end

Cette semaine a vu pas mal d’avancement sur plusieurs projets. Je n’ai pas exactement respecté le planning que je m’étais fixé dans le dernier article, mais ce n’est pas grave. J’avance sur mes projets au rythme de mon inspiration et de mes possibilités. Ce qui est plus important est de rester actif et d’avoir en vue l’ensemble des projets, pour être réactif et saisir les occasions d’avancer sur chacun.

Impression 3D

Cette semaine avait lieu le Web2Connect, un salon du blogging et des activités en ligne. Il y avait beaucoup de conférences, je n’en ai suivi que quelques unes (Bitcoin, Sécurité web, etc) et j’ai passé beaucoup de temps avec les gars de Dood Studio, qui exposaient leur imprimante 3D (un mix open source de Reprap, Ultimaker et Makerbot) dans le ‘village de l’innovation’ du W2C.

Dood Studios au W2C13
Dood Studios au W2C13

Nous avons donc sympathisé, et comme ils cherchaient des modèles à imprimer, je leur ai passé le STL de la turbine que j’avais déja tenté d’imprimer auparavant. Résultat moche, comme avant. Nous avons alors tenté de remodéliser une turbine sur solidworks, et miracle, l’impression est de bien meilleure qualité:

Différents STL
Différents STL. A gauche OpenSCAD, à droite Solidworks. PLA, buse 0,5mm.

Mystère… les objets sont quand même bien similaires à l’écran! Nous avons alors décidé de comparer les STL avec meshlab, et la vérité nous a alors sauté aux yeux:

 

Facettes OpenSCAD
Facettes OpenSCAD
Facettes SolidWorks
Facettes SolidWorks

Le STL pondu par OpenSCAD contient des triangles très fins et très allongés, qui partent tous d’un même point, ce qui perturbe slic3r. Le STL produit par Solidworks est formé de triangles bien plus triangulaires, qui “fonctionnent” clairement mieux !

Je n’ai pas trop d’espoir avec OpenSCAD… Il faudrait pouvoir appliquer une re-triangulation “optimale” de Delaunay à ces “mauvais” STL, mais la mise en pratique me dépasse totalement, tant pis! C’est dommage, car l’idée de modéliser grâce à un script me plaisait bien.

eShapeoko

La découpe, gravure et perçage de plaques de MDF, de 3 à 6mm, est maintenant une opération routinière ici: Je maîtrise (à peu près!) ce procédé 🙂 Les plaques sont fixées efficacement au martyr avec du scotch double face, je fais des coupes de 1 à 1.5mm de profondeur à une vitesse de 100 à 150 mm/minute, selon la propreté de la découpe que je souhaite.

Ma perceuse de 60 watts est toujours un peu faible, je compte sur le Père Noël pour me fournir une défonceuse Bosch de plus grande puissance (600 Watts, ce qui me donnera accès à la découpe d’aluminium).

La fraise est une deux dents, d’origine proxxon, en carbure. Diamètre 2mm.

Coté logiciel, j’utilise Inkscape pour importer des DXF ou créer des dessins vectoriels moi même, puis makercam pour calculer les trajets d’outils, et enfin Grbl Controller pour envoyer les ordres à la machine. Ces logiciels sont gratuits.

Carte de puissance

Première chose, après l’avoir modélisé, j’ai découpé et intégré un boitier en MDF pour la carte de puissance qui commande la machine. Celle ci contient en réalité uniquement les modules Pololu et beaucoup de connectique! La machine est maintenant alimentée en 24V, ce qui me permet des déplacements plus rapides (jusqu’à 3000 mm/min sur X et Y au lieu de 2200, et jusqu’à 200mm/min au lieu de 150 sur Z). L’arduino de commande est toujours “en l’air” mais cela ne devrait pas durer 🙂

Modélisation et résultat
Modélisation et résultat
La carte électronique en place
La carte électronique en place

L’assemblage utilise des écrous logés dans des fraisages dans l’épaisseur du MDF.

Adaptateur d’aspirateur

J’ai trouvé un flexible qui me permet d’aspirer la poussière en temps réel. C’est plus propre et plus pratique! Par contre ce flexible est beaucoup plus fin (18mm) que le tube de l’aspi (35mm). Dans un esprit DIY, plutôt que d’utiliser du scotch (ce qui immobilise l’aspirateur) ou d’acheter un truc, j’ai découpé des trous de diamètres progressifs (18-25-30-35), que j’ai assemblé avec 4 grandes vis M3. Les vis qui dépassent servent à maintenir le tube de l’aspirateur sans avoir besoin de scotch! C’est vachement compliqué pour la fonction, mais ça fait le boulot et c’était sympa à fabriquer!

Cône d'adaptation en 6 couches
Cône d’adaptation en 6 couches

Banc d’équilibrage

Les micro-turbines que je prépare vont tourner à très grande vitesse. Et donc, auront besoin d’être très bien équilibrées. Un balourd entraînerait des vibrations, qui auraient des effets néfastes : bruit, usure des roulements (qui seront mis à rude épreuve par les températures). En me promenant sur le web à la recherche de systèmes d’équilibrages, j’ai trouvé un site chinois qui vend plein de ces appareils. Voici deux exemples qui ont été une “révélation” pour moi:

Système d'équilibrage
Système d’équilibrage
Détails du palier
Détails du palier

Ces photos décrivent tout ce que j’avais besoin de savoir. Il y a un entrainement par courroie souple, une mesure de la vitesse de rotation, un palier à roulements de chaque coté, et une mesure de vibration sur le palier, qui peut être faite avec un accéléromètre. L’objet à mesurer peut être déposé très facilement entre les roulements quel que soit son diamètre, et maintenu avec un troisième galet; ce qui m’enlève de la tête le problème du palier à simple roulement que j’imaginais. Bref, j’étais à coté de la plaque, et voilà qu’on m’y remet!

Une telle machine (ou au moins un proto) n’est pas très difficile à imaginer et à concevoir avec ma machine. En quelques heures de modélisation et de réalisation, j’ai une petite machine pour le genre de turbines que je vais utiliser. Voici quelques étapes de la réalisation:

Détails du palier
Détails du palier

 

Autre vue
Autre vue
Fixation de la roulette supérieure
Fixation de la roulette supérieure
Assemblage final
Assemblage presque final (à droite, avec la roue imprimée)

Les roulements 3x4x8mm sont de récupération dans divers ventilateurs de CPU, et les rondelles de 1mm en laiton sont fabriquées maison par découpe dans un tube laiton de 4mm extérieur attaqué au coupe-tube, puis limées à la bonne épaisseur.

Nous voila donc en bon chemin sur la réalisation des turbines, plastique ou métalliques. Les étapes suivantes seront l’entrainement par courroie et la mesure d’accélération/vitesse, mais nous n’en sommes pas encore là!

Ce qui n’a pas avancé

Electronique et radio
J’y reviendrai dans un article pour demain, sinon celui ci va devenir trop long.

Buses reprap
le mini-tour n’était pas disponible. Normalement je pourrai avancer ce soir

arduino
Il est commandé (auprès d’un vendeur ebay français), et a été envoyé rapidement, mais je n’ai pas de nouvelles. Je vais relancer tout ça…

[eShapeoko] table, perçages

Ce week end j’ai pu travailler à nouveau sur ma fraiseuse eShapeoko. Pour commencer, j’ai refixé correctement la machine sur sa planche, en vérifiant que l’équerrage était correct. J’ai également rectifié les pattes de fixation, car celles ci empêchaient le chariot (gantry) de se déplacer jusqu’en butée:

Pattes de fixation
Pattes de fixation

J’ai ensuite acheté les équerres nécessaires à la finalisation de la table. J’ai pu finir de monter celle ci, et y poser la machine. C’est quand même bien plus commode que posée sur un tabouret! La table est un peu flexible, mais l’ajout futur d’étagères intermédiaires en améliorera la rigidité. Pour l’instant ce sont des tiges filetées qui garantissent la solidité de la table, et j’ai utilisé une étagère de récupération:

La fraiseuse sur sa table
La fraiseuse sur sa table

Ensuite, j’ai recalibré les déplacements sur X,Y et également Z (que je n’avais pas vérifié jusqu’à présent). X et Y ont été vérifiés au pied à coulisse, un calcul sur excel m’a confirmé que les déplacements étaient corrects (0,999mm de déplacement pour 1mm demandé).

Sur Z, j’ai rencontré un petit problème. A cause de la démultiplication produite par la vis sans fin, le nombre de pas pour avancer de 1mm est gigantesque, surtout en microstep 1/32: la vis M8 avance de 1,25mm par tour, et à 400 steps/tour, on arrivait à 10240 microsteps/mm. En configurant cette valeur dans grbl, celui ci s’est bloqué, puis au redémarrage, s’est mis dans une boucle infinie d’alarmes, sans pouvoir en sortir. J’ai alors tenté de reprogrammer le firmware par avrdude, et ceci n’a rien donné. En effet, les paramètres de grbl sont stockés en EEPROM, et effacer le logiciel principal n’y fait rien. avrdude n’a pas non plus d’option pour effacer l’EEPROM. Je m’en suis sorti en :

  • lisant l’EEPROM dans un fichier HEX,
  • puis en modifiant ce fichier HEX pour n’y mettre que des 0xFF (valeur de mémoire effacée, attention il faut recalculer les checksums de chaque ligne!),
  • puis en reprogrammant ce contenu modifié dans l’EEPROM.

Il a ensuite été facile de retrouver tous les paramètres, qui étaient encore affichés dans l’appli de contrôle.

Pour m’en sortir, j’ai alors programmé l’axe Z en microstep 1/8 pour obtenir un nombre de steps/mm raisonnable, puis j’ai dû ensuite diminuer la vitesse max de déplacement, car les moteurs ne suivaient plus le rythme: trop de pas par mm pour une vitesse donnée, cela demandait aux moteurs de mettre à jour leur position trop rapidement.

A ce propos une discussion à l’Electrolab la semaine dernière m’a convaincu que passer l’alimentation des moteurs à 24V aurait un effet bénéfique sur la vitesse max de rotation, sans avoir d’incidence sur le courant max, puisque celui ci est réglé en interne par les drivers. Je suis donc à la recherche d’une alim 24V de récupération.

J’ai donc maintenant une machine calibrée sur X,Y, et Z. Etape suivante: le perçage de la table.

Ce perçage va me servir à maintenir des objets bien fixés sur la table, pour permettre leur usinage. J’ai percé des trous de 6 mm tous les 5 cm, puis j’ai agrandi leur base à 8mm pour pouvoir y faire entrer des inserts à griffes. Voici une série de photos pour décrire tout ça:

Broche Bosch 500 watts. Seul reproches: le bruit, et la forme pas pratique :)
Broche Bosch 500 watts. Seuls reproches: le bruit, et la forme pas pratique 🙂 On fait avec ce qu’on a…
Ca marche quand même très bien...
Ca marche quand même très bien…
Après 35 trous et beaucoup de patience de mon épouse...
Après 35 trous et beaucoup de patience de mon épouse… Premier insert vu de dessous.
Les griffes rentrent en serrant par dessus.
Les griffes rentrent en serrant par dessus. La chute d’alu sert à répartir les forces de serrage pour protéger la table.
Seulement 16 inserts étaient prévus au départ...
Seulement 16 inserts étaient prévus au départ… Il faudra ENCORE aller chez Casto Merlin 🙂

Un problème apparait: la poussière… J’envisage deux solutions: soit des bouts de scotch sous les trous vides soit une petite planche de MDF vissée sous celle ci. Mais j’ai peur que les trous se remplissent vite de poussière. En écrivant, je viens de trouver une solution alternative: boucher les trous inutilisés en y vissant des boulons courts par dessous.

 

Quelles sont les prochaines étapes?

J’ai vraiment envie d’essayer l’impression 3D. Je vais donc me préoccuper des accessoires nécessaires. Le premier d’entre eux est le plateau chauffant, c’est une résistance de chauffage en circuit imprimé placé sous une plaque de verre, elle même recouverte de kapton. Une thermistance mesure la température au centre, et le courant est contrôlé par l’arduino de l’imprimante, via un transistor MOSFET de puissance. Je crois pouvoir me procurer facilement du circuit imprimé de grande taille, il sera gravé par la shapeoko. Le défi sera de maintenir le circuit imprimé de manière parfaitement horizontale par rapport à la fraise pendant que je le graverai.

Il me restera ensuite à lancer une commande ebay pour du kapton et un arduino mega, qui est le modèle utilisé par à peu près tous les firmwares d’impression, dont celui que j’envisage: Marlin.

[Tech] Fail en H et gain d’expérience

A l’origine, cet article devait également parler de moteurs brushless, mais j’ai décidé d’en faire deux articles, car cela aurait été trop long. Cet article est déja long, car j’ai volontairement détaillé son contenu pour qu’il soit facile à comprendre.

Vous connaissez tous les ponts en H: ce sont ces réseaux de transistors de puissance qui servent à changer le sens de rotation des moteurs. Plus généralement, ce sont des éléments de commande de puissance permettant le changement du sens du courant dans chaque ligne de puissance. On peut s’en servir pour plein de choses: commander un moteur DC, pas à pas, ou brushless, piloter un élément Peltier, etc. ou tout élément de puissance nécessitant un changement rapide du sens du courant qui le traverse.

Si on a pas besoin de commuter rapidement le sens du courant, un relais 2RT fait l’affaire 🙂

Nous verrons plus tard comment fonctionne un moteur brushless. Pour l’instant, disons seulement qu’il faut donc une carte de commutation pour changer le sens du courant dans les phases du moteur. Pas de secret, il y a plein de docs sur le sujet sur Internet. Cette carte de commutation génère les signaux logiques (0V-5V), mais évidemment, il faut des transistors de commande.

Il y a deux manières de réaliser un pont en H avec des MOSFETs:

Types de ponts
Types de ponts
  • Soit avec des FETs de type N coté “masse”, et des FETs de type P coté “alim”. C’est cette solution que j’ai choisie.
  • Soit avec uniquement des MOSFETs de type N, et un montage “compliqué” qui génère des tensions flottantes pour commander les FETs du coté “alim”. Des chips intégrés existent, mais pour un proto, ça n’est pas du tout amusant.

Pour rappel, le pilotage d’un FET se fait en appliquant une tension entre Grille et Source (VGS = Ug-Us), ce qui autorise le passage d’un courant entre drain et source (Id).

Pour le FET N, cette tension VGS doit être positive. Le FET N est conducteur quand sa grille est à une tension supérieure à sa tension de déclenchement (5-6V environ pour les MOSFETs de puissance), et il est isolant quand sa grille est à la masse. Entre les deux, le FET est dans une zone où il se comporte linéairement, mais la pente de la courbe Id en fonction de Vgs est très raide, il y a beaucoup de variations entre différents composants d’une même série, et les MOSFETs de puissance détestent travailler dans ce mode “résistif” où ils chauffent beaucoup. Mais ça marche, j’ai déja fait une source de courant variable de cette manière, en utilisant un ampli-op pour asservir la tension aux bornes d’un shunt (avec un gros radiateur, et un MOSFET N qui supportait 100A – en commutation, car en linéaire, c’est beaucoup moins).

Pour le FET P, cette tension VGS doit être négative. Et la source est reliée à l’alimentation. Le FET P est conducteur quand sa grille est à une tension inférieure d’environ 5-6V à la tension d’alim du moteur, et il est isolant quand sa grille est à la tension d’alimentation. Attention, je répète je n’ai pas dit que la tension de grille était à 5V, j’ai bien dit 5V en dessous de la source! Pour une tension d’alim de 12V, le FET P connecté à l’alim est donc totalement conducteur quand la tension sur sa grille est en dessous de 7V (=12-5).

On remarque vite que des niveaux logiques ne conviennent pas pour piloter des MOSFETs. Les courants débités par les microcontrôleurs sont déjà un problème, ils sont trop faibles, ce qui va ralentir le temps de commutation des FETs (et donc les faire chauffer). Les tensions surtout posent problème:

  • A zéro volts, on peut bloquer le FET N, et rendre le FET P passant.
  • Mais à 5 volts, le FET N est partiellement passant, et le FET P est toujours passant, car il reste encore 7V (12-5 dans notre cas) entre G et S.

Il faut donc translater ces niveaux de tension à des valeurs qui permettent de faire fonctionner les FETs.

Mon idée initiale a été d’utiliser des transistors bipolaires que j’avais déja, des BC547 et BC557, et des résistances de pull up/down pour réaliser ces translateurs de niveau. Voici en gros le schéma utilisé (les transistors supplémentaires coté N sont censés être des inverseurs pour que toutes les commandes soient positives:

Pont à pilotage Bipolaire
Pont approximativement pifométrique, qui aurait dû marcher. Dessin Kicad.

Grossière erreur, surtout du coté des FET N : les valeurs de composants utilisés ont été calculés de manière totalement “proto-pifométrique-fond-de-tiroir”, je fais passer du courant dans la base mais pas trop, ça saturera à tous les coups, ben… non, ça ne marche pas! Une mesure rapide des niveaux de tension obtenus m’a rapidement montré des tensions bien trop faibles pour commuter les FET N de manière fiable. Après quelques minutes de fonctionnement, un passage de doigt sur les FET m’a révélé une température bien au delà du raisonnable (je me suis pas brûlé, mais ma sueur s’est évaporée avec un petit pshitt), et maintenant, le moteur saute des pas, alors qu’au début de la manip, au moins, toutes les étapes de la commutation étaient observables. J’ai donc explosé au moins un FET N par l’épreuve du feu. Contrairement aux régulateurs de tension et autres, les FETs ne sont donc pas du tout protégés en température…

Mon erreur a été de négliger le pilotage correct des MOSFETs. Ce montage aurait dû marcher, je ne pense pas qu’il soit faux, c’est un problème de choix de composants.

Je dois dire que je suis passé à deux doigts de laisser tomber ce sous-projet (alors que je néglige ma shapeoko), qui était censé être un bricolage rapide du week end. Tout ceci se passait, bien entendu, le dimanche soir à 1h du matin, avec le boulot le lendemain, et pas mal de fatigue accumulée. Un peu désespéré, j’ai googlé “mosfet drive” un peu plus longtemps que d’habitude, et je suis tombé sur cette magnifique page qui expliquait exactement ce que j’avais besoin de savoir: le B-A-BA du pilotage des mosfets avec des composants discrets:

http://modularcircuits.tantosonline.com/blog/articles/h-bridge-secrets/h-bridge_drivers/

Cet article fait en fait partie d’une grande série:

http://modularcircuits.tantosonline.com/blog/articles/h-bridge-secrets/

Voyez vous, ce n’est pas que j’adore réinventer la roue, mais je veux comprendre ce que je fais, alors utiliser un circuit intégré pour piloter un FET dans un prototype, ce n’est pas mon truc. Je sais que ça existe, je sais que ça marche, donc je n’utiliserais ce genre de circuit que si, justement, la compréhension du pilotage des FET n’est pas le point central du projet.

Bref, malgré l’envie de dormir, je lis la page sus-citée, qui mentionne un montage particulièrement intéressant. Je vous la fais en résumé: Puisque le problème des FET est leur pilotage par des niveaux logiques, eh bien on essayons d’utiliser des FETs dont les tension de commutation sont compatibles avec des niveaux logiques. Ces FETs existent, mais ils ne sont pas capables de commuter de grosses charges.

Ce translateur de niveau est un simple MOSFET N dont le niveau logique est compatible avec des signaux logiques. On peut utiliser pour ça le BS170, qui est un FET N de faible puissance, mais dont la tension de déclenchement est de 3V, c’est directement compatible avec un signal logique. Ce MOSFET est câblé en drain ouvert (équivalent du collecteur ouvert) et peut donc “clamper” sa sortie à la masse, qui sera le niveau “0”. Le niveau “1”, lui, est indéfini, il est présent quand le FET est isolant, et sa tension est définie par un pull-up externe, que l’on connecte donc entre le drain et le +12V. On a donc construit un translateur de niveau inverseur.

Le problème est maintenant déplacé: on sait transformer des signaux 0V-5V en signaux 0V-12V, mais le signal haut (+12) n’est pas très franc: A cause de la capacité d’entrée du FET, la résistance du pull-up implique un temps de commutation plus élevé (T=RC), ce qui va certaiment faire chauffer le transistor. On peut régler ce problème en diminuant le pull-up (mais la conso augmentee inutilement) ou en intercalant un inverseur CMOS discret, constitué d’une paire de mos complémentaires (BS170 et BS250): Cet inverseur sera très rapidement déclenché par la tension issue du pull-up, mais il pourra fournir un courant élevé au FET final, car cette paire est directement connectée à l’alimentation, sans résistance. Voici à quoi cela ressemble:

Pilotage CMOS
Pilotage CMOS (R= 4K7) Chaque MOSFET de puissance a droit au même circuit.

J’insiste sur ce point du chargement correct et rapide de la capacité d’entrée des transistors MOSFET, car c’est un sujet très important pour la commutation de (grande) puissance. Pendant le chargement, le FET est demi-passant, et c’est principalement à ce moment qu’il chauffe. Ce n’est pas négligeable, car en PWM, il y a beaucoup de commutations! Regardez un datasheet, la capacité est donnée directement en nano-coulombs, ce qui donne le temps de commutation du FET: Q=IT -> T=Q/I, le temps de commutation est donc d’autant plus court que le courant de commutation est important.

Il peut y avoir un dernier problème, qui ne nous concerne pas vraiment, mais qui devient important si les tensions de pilotage sont plus élevées: la grille d’un FET ne supporte pas toujours la tension d’alimentation du moteur. Il y a en général une limite (destructive) vers 15V. On va alors piloter la grille du FET via un régulateur shunt Résistance Série/Zener à la masse, ce qui évite de le détruire.

Je n’ai pas abordé le sujet des ponts à base de FET N uniquement, il faut savoir qu’ils ont besoin d’une pompe de charge pour produire une tension VGS suffisante pour le FET coté alim. En général, cette pompe implique que le FET supérieur ne peut pas rester enclenché pendant un temps infini, car la pompe de charge a des fuites inévitables et demande un rechargement régulier. Il faut piloter ces ponts en PWM et s’assurer que les FETs supérieurs ne sont jamais pilotés par un PWM à 100%. Pour mon prototype, c’est assez gênant pour faire des essais à basse vitesse, c’est pour ça que je n’ai pas choisi cette conception même si les FET N sont moins chers et plus efficaces que les FET P. Je réserverai les FET N au montage final, si j’en ai besoin.

Voici donc la fin de mon tour d’horizon sur le pilotage des ponts en H, si on veut en savoir plus, je recommande chaudement la lecture des pages que j’ai trouvées, qui décrit avec une infinité de détails tout ce que l’on peut faire avec des ponts. Ces articles sont vraiment très, très complets, je n’ai pas encore eu le temps de tout lire! Je terminerai avec une image de l’état actuel du montage:

Prototype
Le prototype

C’est un pont à 3 branches, pour piloter un moteur brushless. La position des transistors est prévue pour une fixation sur un radiateur de CPU… Ne pas oublier les kits d’isolation, les semelles sont connectées aux drains! J’ai ajouté une résistance de 0R1 pour mesurer le courant consommé.

A+ pour l’application aux brushless!