Archives de catégorie : Uncategorized

Toner Transfer

Après un ptit hack sur une version insecure de wordpress, mon article sur la procrastination a dégagé, tant pis.

Hier j’ai fait un essai de circuit imprimé par toner transfert. Tout le monde connait, je vais pas m’étendre sur le concept. Je vais juste résumer la “recette” qui a marché.

  • Impression sur un papier photo quelconque a l’aspect glacé.
  • Décapage du cuivre avec de la poudre a récurer, puis finalisation à l’acétone pour virer toute trace grasse.
  • Fer à repasser à la température max (lin). D’autres recommandent “Coton”.
  • J’ai gardé du papier autour de l’impression pour “emballer” le bout de PCB, but: éviter que le dessin ne glisse. Il faut vraiment pas que ca bouge, on le voit quasiment pas mais au décollage on se rend compte qu’on a “deux images” superposées.
  • J’ai appuyé sans bouger pendant environ 1 minute, le fer bien a plat sur le circuit.
  • J’ai laissé tremper le papier dans l’eau jusqu’a ce que la majorité du papier se décolle sans forcer
  • Il reste des fibres de partout, je les ai grattées avec une vieille brosse a dents dure
  • Après séchage on remarque que le toner est encore collé a plein de fibres, mais elles ne gênent pas.
  • Il restait quelques bouts de fibres de papier entre les pistes, je les ai virées avec un petit grattoir en observant a la loupe (ca peut être des bouts vraiments petits)

Voila ce que ca donne:

Toner transfer terminé

Remarques

  • Pas de panique si on rate, c’est “recyclable”. Le toner part très bien à l’acétone (ou au scotch brite). Il faut tout bien renettoyer après.
  • Je pense que ca marcherait aussi bien avec du papier normal
  • Si c’est mal nettoyé, le toner n’adhère pas, ca peut arriver sur des petites zones. Dans mon cas j’ai comblé la zone avec du stylo peinture “Edding”.

Pour la gravure, pas de perchlo, j’ai utilisé de l’acide chlorhydrique de grande surface, mélangée à de l’eau en part approximativement égales. J’ai ajouté une cuillère a soupe d’eau oxygénée à 110 volumes. Cela a pris une minute sans trop chauffer. Je voulais conserver un plan de masse complet a l’arrière, j’ai utilisé du scotch pour protéger le cuivre de l’acide.

Gravure au CuCl2

Et voici le CI gravé:

Le PCB terminé

Je suis plutot satisfait du résultat. Il y avait très longtemps que je n’avais pas fait de circuit imprimé, car je n’ai rien pour insoler.

Par contre, ce n’est pas assez précis pour faire des circuits RF. Pour cela il faudra jouer au dry film bleu (les substrats RF présensibilisés sont introuvables, alors que bruts… on en trouve) et passer par la case insolation.

Ce midi j’ai obtenu le foret de 0.6mm pour percer les quelques vias GND, je reposterai le montage une fois terminé.

Making of: le chargeur Qi de Skywodd

Hello a tous!

Maintenant que Skywodd a publié son article sur le sujet, je peux enfin “en parler”! J’étais en effet resté discret à sa demande, mais j’ai effectivement pas mal bossé sur l’usinage des blocs de bois de son chargeur.

Bon, je passe sur les détails, vous avez bien compris qu’il s’agit d’un chargeur inductif permettant le transfert d’énergie sans contact.

Pour la petite histoire, dans ce système, c’est le récepteur (le tel) qui informe le chargeur de combien d’énergie il a besoin. Le tel communique avec le chargeur en modulant rapidement le courant de charge selon un protocole pas trop compliqué. Le chargeur répond en adaptant son fonctionnement aux besoins de l’objet chargé. Il n’y a pas une grande intelligence là dedans, le seul truc prévu est l’identification (pour que le chargeur évite de démarrer quand on pose un simple objet métallique non-Qi sur la surface) et la régulation du courant de charge. Bref.

J’ai donc eu pour mission d’usiner les blocs de chêne-qu’on-déconne-pas-avec. Skywodd m’a livré des fichiers DXF (contours 2D, un peu comme du SVG) obtenus à partir de ses pièces 3D. De mon coté j’ai chargé ces DXF dans CamBam pour en sortir des trajets d’outils.

Oui, le DXF n’est qu’un dessin, un peu comme le STL de l’impression 3D. Après, il reste encore à appliquer les paramètres de la machine et de l’outil (vitesse de coupe, diamètre de la fraise, épaisseur des passes, en impression 3D on parlerait plutôt de diamètre de buse, épaisseur des couches, et on utiliserait Slic3r).

En sortie on a donc du G-Code, qui sont des instructions de positionnement adaptées à une machine en particulier. J’insiste, je ne vous passerai pas mes g-codes, parce qu’ils vous seraient inutiles si votre machine n’a pas les mêmes moteurs, la même fraise, ou la même broche (perceuse).

Il faut savoir que la vitesse de coupe lors des déplacements dépend du matériau, de la vitesse de rotation de la broche, du nombre de dents et du diamètre de la fraise. Quand on fait les choses bien, on part de l’info “vitesse du point de coupe” (qui est le point du diamètre de la fraise qui se déplace pour arracher la matière). Selon le matériau, il faut avoir la bonne “vitesse de coupe”, qui est liée à la dureté de la matière. Ensuite, selon l’outil, on en déduit une vitesse d’avance et une vitesse de rotation, selon le diamètre de la fraise, et le type d’opération (rainurage, surfaçage, etc).

Vous remarquez une chose: je n’ai pas parlé de la puissance de la broche… En effet, on ne la choisit pas, selon le matériau et l’outil, on obtient des paramètres à utiliser, et il faut espérer que la broche est assez puissante pour les utiliser! Et je fais quoi si ma perceuse n’est pas assez puissante? Eh bien il n’y a pas le choix, il faut couper moins vite, mais c’est totalement sous-optimal, et le risque est de faire chauffer l’outil, par frottements précisément. Oui c’est fou: on use son outil si on ne coupe pas assez vite!

Et là arrive un autre problème: la rigidité de la machine: si on coupe trop vite, le risque que la machine se déforme est très important, et il ne faut pas se faire d’illusion: toute précision inférieure à 1/10 de mm est très difficile à atteindre, surtout avec une machine de type Shapeoko…

Ensuite il y a autre chose: la fragilité du matériau. Je n’ai eu aucun problème avec le bois, que l’on a fixé au bâti de la machine par 3 vis M6 à chaque fois, et qui est assez sympa à couper. En revanche, le plexi a été une autre histoire, comme l’a dit Skywodd: c’est un matériau fragile car cassant, plutôt dur, et plutôt fondant; donc c’est un défi, il faut couper vite sinon le plastique fond, mais pas trop profond à chaque passe sinon on force dessus et il casse. Je l’ai aussi nettement moins bien fixé, j’ai utilisé du scotch double face, et ce scotch résiste mal aux vibratons… Bilan, 5 pièces réussies, 3 à la benne!

Malgré tout, on arrive à faire des choses, mais il faut garder à l’esprit que l’usinage est une technique très exigeante, même quand on n’usine pas du métal. Dans tous les cas, tout nouvel outil, tout nouveau matériau demande de faire des essais de coupe pour trouver les bons paramètres machine. Dans le cas du métal c’est facile, on trouve des abaques, on sait que l’alu machin allié truc a besoin d’une vitesse d’avance de tartempion en rainurage, mais pour le bois, les différents types de plastique (PMMA, Acrylique,  Polycarbonate, PVC, Nylon, etc…) on ne trouve pas toujours (presque jamais) la bonne info.

A propos des types de fraise: Pour le bois, j’ai utilisé une fraise carbure “1 dent” de type défonceuse, diamètre 4mm. Ne surtout pas utiliser l’acier rapide (HSS) pour autre chose que pour le métal, il chauffe et s’use très rapidement. Au moins le carbure coupe moins (les dents en céramiques ont des rayons de courbure plus importants sur les arêtes) mais il supporte très bien les hautes températures. Pour le plexi j’ai utilisé une fraise deux dents hélicoïdale en carbure, toujours de 4mm. Ma broche Milwaukee a une pince qui accepte toutes les fraises avec des soies (axe de fixation) de 6mm.

Pour finir je remercie Skywodd de m’avoir fait faire ces opérations, qui ont amélioré mon expérience en usinage. Je le remercie de m’avoir passé un module pour mes propres essais.

Bon, assez parlé, place aux images!

 PS: le chêne utilisé est superbe une fois enduit d’huile d’olive. Elle rentre bien en quelques jours, et elle nourrit bien le bois qui prend une plus belle teinte.

Essais de vitesses de coupe
Essais de vitesses de coupe. Notez le “Pour essais” 🙂
En cours de découpe
En cours de découpe. Y’a des copeaux partout!
Deux blocs finis
Deux blocs finis. Il faudra faire les finitions au papier de verre…
Crash dans le plexi
Crash dans le plexi: la plaque s’est décollée du support.

L’an Deux Mil Quatorze

Et voila, nous sommes déja en 2014! Cette année est très vite passée, et, surtout, les six derniers mois ont bien été remplis.

Petite rétrospective:

Septembre 2012: Inscription sur twitter

Janvier 2013: J’ai fait 29 tweets en 4 mois.

Janvier-Juin : Pas grand chose, je bricole des petits trucs sans les finir, j’écris quelques articles sur mon blog, surtout pour présenter d’autres projets…

Juin: Début de ma prise en main sérieuse de Twitter.

28 Juillet: changement de nom de mon site. OpenMakersDaily, c’est trop long, ça fait site de news alors que je veux présenter mes projets, il est mieux d’utiliser mon indicatif radioamateur comme nom de “code”. Reste à changer le logo, j’avoue, j’ai la flemme.

Septembre: je reçois ma fraiseuse eShapeoko avec pour but d’en faire une imprimante 3D.

Octobre: Je deviens membre de l’Electrolab.

Décembre: J’ai presque fini les modifs pour transformer ma fraiseuse en imprimante 3D. La fraiseuse, elle, a découpé plusieurs dizaines de pièces qui m’ont servi soit de protos, soit d’éléments de construction pour d’autres projets.

1er janvier 2014: j’ai envoyé 2562 tweets de plus en 6 mois. Ce soir, 2610 messages, 109 abonnements, 198 followers.

Twitter est donc mon réseau social de prédilection, je suis toujours aux abonnés absents sur Facebook et les autres. Je ne compte pas m’y inscrire, cela me prendrait trop de temps. J’aime twitter pour son coté spontané, rapide, facile à utiliser, et surtout pour la qualité des contacts que j’y ai noués. Merci à vous.

Que va t il se passer ici en 2014?

Eh bien, on continue!  Il y a énormément de choses à faire! Et j’ai peu de temps, mon emploi (développeur expert C et assembleur en (très-)embarqué et cryptographie) me prenant toute la journée, j’ai appris à mettre à profit chaque moment de libre. Le RER, quand j’arrive à y trouver une place, me “sert” à coder, la pause midi me sert à twitter et le soir me permet d’avancer mes projets plus matériels. Le mardi soir est réservé à l’Electrolab, un vendredi par mois au Radio-Club, et le reste du temps est libre pour bosser sauf exception.

Je veux absolument terminer les projets suivants:

  • Conversion de ma fraiseuse en imprimante 3D fonctionnelle
  • Extrudeur de filament recyclé à partir de bouchons de bouteille (et tout ce qui va avec)

Mais j’ai aussi d’autres idées, surtout logicielles, que je ferai avancer à leur rythme:

  • Désassembleur/analyseur pour plate formes embarquées MSP430/PIC/AVR/ARM/autres. Je veux un IDA open source.
  • Générateur de nombres aléatoires de haute sécurité
  • Micro-PC/console à base de STM32
  • D’autres trucs à base de MSP430 (il m’a l’air bien sympa cet animal)
  • J’aimerais bien aussi faire des “recherches” en sécurité, USB, etc.
  • Il me faut aussi faire avancer les micro-turbines (prochaine étape: équilibrage!)

Bref, que du bon, je ne m’ennuierai pas!

Bonne année, et bonne bricole!

[Electronique/Radio] Emettre et recevoir à plus d’1 GHz

Il y a quelque temps, j’ai re-conçu le circuit imprimé d’un appareil très utilisé en hyper-fréquences, le PLVCXO, pour le rendre plus “2013”. Cet appareil est un synthétiseur de fréquence dans la gamme des 100 MHz. Il utilise comme référence un 10 MHz stable issu d’un GPS ou d’un quartz thermostaté, ce qui lui permet d’asservir un très bon oscillateur à quartz grâce à un circuit PLL de référence ADF4110. La plage de fréquence est très restreinte (quelques kHz) mais le signal généré est très bon (grâce au quartz). Il peut donc générer une seule fréquence (celle du quartz), mais il le fait de manière extrêmement précise, et non dépendante de la température (un quartz tout seul, ça dérive pas mal!) Cet appareil est très utilisé avant des multiplicateurs de fréquence, qui servent d’oscillateur locaux pour des transverters micro-ondes. Je sais que je parle chinois, voir un peu plus bas pour comprendre.

Je lui ai appliqué les modifications suivantes:

  • Utilisation d’un PIC CMS plus récent (18f2620) avec UART,
  • permettant une reprogrammation facile du PLL par port série, et ouvrant la voie à une commande par signal à 10 kHz directement issu de certains modules GPS
  • Basé sur la dernière conception de F6DRO (non publiée) qui sépare l’oscillateur de la partie logique grâce à une cloison métallique de blindage
  • Réalisation en circuit imprimé ‘professionnel’ chez SeeedStudio avec trous métallisés et masque de protection.

Ceci me permettra de réaliser un oscillateur précis sur 96 MHz.

Ensuite, le deuxième montage que j’attaque est un transverter 1296 MHz. Cette fréquence est la fréquence principale de la bande radio-amateur 1 GHz, autrement dit, la bande des 23 centimètres.

Rappelons sommairement comment fonctionne un récepteur moderne: la fréquence à recevoir est:

  • sélectionnée par un filtre de bande (passe-bande éliminant les signaux parasites, GSM, FM, etc),
  • puis est amplifiée par un pré-amplificateur linéaire à bas bruit (un LNA) afin de pouvoir traiter ce signal.
  • Ensuite, le signal reçu est mélangé à un oscillateur dit local, ce qui produit des signaux dont les fréquences sont la somme et la différence des fréquences du signal et de l’oscillateur local (Depuis le lycée on sait que cos a cos b = cos((a+b)/2) + cos((a-b)/2), aux signes près…)

L’émission d’un signal utilise ces mêmes étapes, mais en ordre inverse. Un ampli de puissance (PA) remplace le LNA.

Ce principe est fondamental en radio, c’est ce qu’on appelle la réception (ou transmission) hétérodyne, ou changement de fréquence. A la sortie du mélangeur (un multiplicateur de tensions par exemple), on obtient un signal de caractéristiques identiques à ce qu’on avait au départ, mais dont toutes les fréquences sont décalées vers le bas. C’est ce qu’on appelle une “fréquence intermédiaire”. Celle ci peut alors être traitée plus facilement, que ce soit par des composants analogiques (démodulateur FM, etc) ou bien… Par un autre récepteur radio!

Dans notre cas, c’est exactement ce qu’on fait. Un transverter permet de recevoir et de transmettre à 1296 MHz avec un simple poste de radio VHF, à 144 MHz!

Maintenant quelques calculs rapides. Pour translater la fréquence de 144 à 1296 MHz, on va utiliser une somme de fréquences, et la fréquence qu’il faut ajouter est de : 1296 – 144 = 1152 MHz. Or on a vite remarqué que 1152 = 96 x 12. Ce n’est pas un hasard, toutes les bandes radio-amateurs sont grossièrement des multiples des bandes précédentes afin de pouvoir utiliser des multiplieurs de fréquence pour les oscillateurs locaux.

Pour rappel:

  • Bandes HF : 1.8 – 3.5 – 7 – 14 – 28 – multiples évidents. Je ne parlerai pas de WARC 🙂
  • 144 MHz ~28 MHz x 5
  • 430 MHz ~ 144MHz x 3
  • 1296 MHz ~ 430 MHz x 3
  • Bandes hyper: 2320, 5700, 10300, 24 GHz, 47 GHz, 122 GHz, doubles ou triples.

Si j’arrive à multiplier par 12 un signal de 96 MHz, j’aurai la fréquence requise. Comment multiplier une fréquence? C’est facile: on utilise des transistors montés pour “trop” amplifier, ce qui les fait saturer. Le montage produit des harmoniques (pairs ou impairs selon le montage). En filtrant la bonne fréquence, on peut donc sélectionner uniquement l’harmonique qui nous intéresse. Si le signal obtenu est faible, ce n’est pas grave, on peut l’amplifier (normalement cette fois). Multiplier par 12 peut se faire en 3 étapes, car 12=2x2x3, et il est facile de construire des multiplicateurs par 2 ou 3.

Tout le secret des ultra et extra hautes fréquences est donc réparti entre l’oscillateur local et le mélangeur. Ces éléments vont permettre de transférer un signal à une fréquence manipulable dans toute autre bande pour laquelle faire un appareil complet serait un cauchemar, mais où la réalisation d’oscillateurs (par multiplication de fréquences plus basses) et de mélangeurs (avec des diodes spéciales) est possible. On comprend maintenant pourquoi toutes les bandes amateurs ont des multiples multiples: Réaliser un poste pour une bande supérieure nécessite d’abord la réalisation d’un oscillateur local, qu’il est pratique de réaliser avec un multiplicateur!

Bref.

Donc j’ai à réaliser:

-un plvcxo (j’ai fait le print, j’ai obtenu les composants, le programme du pic est plus ou moins fait)

-un transverter (pareil, j’ai récupéré le kit complet)

Je pense travailler dessus mercredi soir et jeudi soir. Je reviendrai aux nouvelles!

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

Impression 3D de précision

Après m’être amusé avec des micro turbines, je m’étais amusé à modéliser une turbine sur openscad. J’y ai passé pas mal de temps, et le rendu 3D était devenu très correct. Vous pouvez retrouver le fichier scad de ce projet ici: turbine.scad

Maintenant que je suis assez proche de la réalisation de mon imprimante 3D, je me suis intéressé à la possibilité d’imprimer réellement cette turbine en 3D.

Jennyfer de l’Electrolab est une spécialiste de l’impression 3D, dont vous entendrez plus parler dans les mois à venir. Elle maîtrise vraiment sa machine et les processus d’impression, de la conception à la réalisation. Son imprimante personnelle n’est plus un jouet, mais une machine fiable et fonctionnelle qui a tourné en continu pendant un mois sans nécessiter aucun re-réglage, et fait maintenant concurrence à Stratasys (pour un prix largement moins élevé).

Après quelques discussions, elle m’a proposé d’imprimer ma mini turbine, ce qui est à la fois une grande chance pour moi, car je peux réaliser un proto sur une machine excellente, et pour elle c’est un défi, car ma pièce est vraiment petite et elle peut tester sa machine dans des conditions pas faciles.

J’ai appris au passage quelques informations sur la modélisation en vue de l’impression.

Contrairement à ce que beaucoup de gens pensent,il ne s’agit pas simplement de concevoir un objet arbitraire et de l’imprimer comme un document word. En poursuivant cette idée, il y aura beaucoup de déceptions. En effet, le processus d’impression 3D doit être envisagé dès le début de la conception. En particulier, pour cette pièce, il y a une particularité : elle est composée uniquement de murs fins, sans aucun volume rempli. Nous sommes donc en mode “remplissage 100%” ,et là, le slicer (logiciel qui découpe l’objet en tranches) ne sait pas remplir de zone plus étroite que la taille du filament.
Nous avons donc revu ensemble les épaisseurs des pales et des murs fins, pour qu’ils correspondent à un nombre entier de filaments, ici deux. Dans le cas contraire, le slicer n’aurait pas pu remplir entièrement le volume des murs, déja très fins, les filaments auraient été trop espacés (c’est à dire séparés par des espaces trop fins pour être remplis).

Voici le résultat de l’impression de l’objet tel que je l’ai modélisé. Les paramètres utilisés sur son imprimante étaient: filament ABS, couches de 0,2 mm, buse de 0,25 mm (pour un filament extrudé de 0,34 mm). Les murs et les pales de cet objet ne font que deux filaments de largeur, soit 0,68 mm, et le diamètre total de la roue atteint 26 mm:

Les objets conçus sous OpenSCAD
Les objets conçus sous OpenSCAD

Cette impression est peu satisfaisante. Je n’étais pas devant la machine pendant l’impression, mais Jennyfer m’a dit que la première couche avait été imprimée par sa chaine logicielle de façon un peu bizarre, en plusieurs fois, sans passages réguliers. Après avoir supposé que le STL généré par OpenSCAD avait quelques problèmes, j’ai trouvé la vraie raison. En modélisant mon objet sous openscad, j’ai voulu m’assurer que l’objet final avait bien l’épaisseur voulue et pas plus, donc les faces de la roue sont “rectifiées” et les dépassements des pales (disposées à 45 degrés) sont rabotés au passage. Si on observe avec précision le résultat, on voit que la surface des pales en contact avec la base d’impression est formée de petits triangles, alors que la zone des pales proche du moyeu a une épaisseur “nulle”:

La première couche est liée à ce biseautage
La première couche est liée à ce biseautage

En conséquence, le slicer a décidé que la couche zéro était uniquement composée du moyeu, du carter, et de ces petites zones triangulaires. Le corps des pales commence réellement à la couche suivante. De plus, il se trouve que le fichier STL généré par OpenSCAD a des problèmes de fermeture, on dit vulguairement qu’ “il n’est pas manifold”, c’est à dire que la surface du solide comporte des trous. Heureusement, les logiciels de conception semblent capables de s’en sortir malgré ce problème en faisant des “réparations”.

Voici le chemin de l’extrudeur pour la couche zéro, modélisé par OpenSCAM:

G-code de la première couche
G-code de la première couche

Effectivement, la couche zéro est composée de petits triangles. A cause de cela, l’objet imprimé est de très mauvaise qualité, car la couche zéro est imparfaite, l’objet n’est pas stable.

Jennyfer a alors repris la conception de la roue dans son modeleur, mais a implémenté ce rabotage différemment, ce qui fait que ses essais d’impression sont bien mieux réussis. Remarquez que la couche zéro de ces pièces est bien plane:

La meme pièce, après reprise (couche zéro à gauche)
La meme pièce, après reprise (couche zéro à gauche)

Après montage des roulements (de ventilateur de PC) et insertion de l’axe (d’un chariot de lecteur DVD), je dois dire que le respect des côtes est quasi parfait, le roulement et l’axe se sont insérés en force mais sans problème, le frottement est suffisant pour maintenir fermement les éléments en place sans glissements. J’ai pu ensuite ajouter de petites rondelles en laiton (coupées au coupe-tube et finies à la lime), et couper un carter dans une canette de coca pour obtenir une turbine qui tourne vraiment bien dans le tube d’un aspirateur:

Les pièces prêtes à assembler
Les pièces prêtes à assembler
La turbine assemblée
La turbine assemblée

Il y a donc plusieurs leçons importantes à retenir:

  • On peut obtenir des pièces mécaniques de très bonne qualité (celles ci sont encore à améliorer)
  • Il faut concevoir la pièce en ayant en tête le processus d’impression, et la machine utilisée. C’est évident, mais la surexcitation actuelle des médias aurait tendance à nous faire oublier l’importance du travail de modélisation. A ce propos, on remarque les problèmes que peuvent poser un site comme thingiverse: un objet donné sera sans doute bien imprimé sur la machine de l’auteur, mais des petites variations de procédé vont certainement aboutir à des problèmes d’impression partout ailleurs. Surtout pour les pièces fines.
  • La couche zéro est très importante. C’est elle qui conditionne la qualité de toute la pièce qu’elle supporte.
  • Les dimensions de la pièce sont importantes, surtout quand on veut des pièces de faible épaisseur. Le comportement du slicer doit être bien compris pour lui “donner à manger” des pièces qui se comporteront bien.

J’ai donc appris beaucoup de choses en fabriquant ce petit objet, et je suis certain que tout ceci me fera gagner beaucoup de temps plus tard. Je réinsiste donc une fois de plus: sans modélisation adéquate, on ne peut pas utiliser une imprimante 3D et attendre des résultats de qualité. Toute la chaine d’outils doit être maitrisée, et il faut absolument modéliser sa pièce en pensant à son mode de réalisation.

Je vais donc remodéliser ma pièce pour corriger ces problèmes.

A+!

[algo] Comment calculer une moyenne glissante sur un microcontrôleur à faibles ressources

Pour commencer, je dois dire que l’idée pour cet article m’a été suggérée par Audran (@alf_arobase) lors de discussions à l’Electrolab sur son super projet que je ne dévoilerai pas sans son autorisation! Mais c’est un truc très bien! Bref, cet article est surtout une synthèse des trucs dont on a discuté hier soir, et que j’ai relativement mal expliqué. Avec du recul, ça va mieux.

Le problème

Supposons que l’on ait à mesurer en temps réel un signal analogique à l’aide d’un petit microcontrôleur, pour, par exemple, déterminer quand ce signal passe sous un seuil, et déclencher un signal. Ceci peut être fait de manière triviale, en effectuant une mesure avec l’ADC, en la comparant avec le seuil, puis en décidant l’état du signal de sortie.

Ceci, en réalité, n’est qu’une théorie. Dans la réalité, plusieurs effets vont rendre cette technique impraticable:

  • Le signal à mesurer peut être très bruité;
  • L’ADC peut manquer de précision et sortir des valeurs de mesure différentes alors que le signal reste constant.

En conséquence, quand le signal sera proche de la limite, il va varier rapidement entre les états “signal détecté” et “signal non détecté”. Comme les mesures se feront en général à un rythme rapide, les variations du signal de sortie seront également très rapides, et probablement assez aléatoires.

Que peut on faire? Idéalement, on voudrait se passer de toutes ces petites variations rapides, pour retenir la valeur moyenne du signal à un moment donné. On peut aussi appliquer un filtre passe-bas au signal de l’ADC, car il est équivalent de dire que seules les basses fréquences (les variations lentes) du signal de l’ADC nous intéressent.

Première option: y’a moyen de moyenner (le signal)

La première chose qu’on peut faire, c’est diminuer l’influence des imperfections de l’ADC, c’est le plus facile.
Au lieu de mettre à jour le signal de sortie à chaque fois qu’un échantillon ADC est lu, on peut lire 4 échantillons, ou N, en faire la moyenne, et utiliser cette moyenne pour prendre la décision sur le signal de sortie. Dans ce cas, chaque fois qu’on moyenne 2^n valeurs d’ADC, on gagne n bits de résolution.

Cette méthode s’appelle la décimation. Ça s’invente pas.

Exemple, si je moyenne 4 valeurs, la moyenne pourra prendre, après la virgule, les valeurs x.00, x.25, x.50, ou x.75. Quatre valeurs après la virgule peuvent être codées avec deux bits, c’est deux bits de gagnés sur la résolution, au prix d’une vitesse d’acquisition plus faible. Autre manière de voir: additionner 4 nombres de M bits nécessite M+2 bits pour coder le résultat.

En embarqué, surtout avec des microcontrôleurs 8 bits, on n’aime pas les virgules, c’est donc un bon exemple d’application des calculs en virgule fixe. Faire la moyenne de N valeurs revient à les additionner, et c’est tout. Le résultat aura un dénominateur de N. Si on veut une moyenne du même ordre de grandeur que les résultats de mesure initiaux, on peut alors utiliser une division entière. Si on est malin, on fait une moyenne sur 2^N valeurs, et la chère division se transforme en simple décalage à droite.

Deuxième option : calculer une moyenne mobile

La moyenne c’est bien, mais cela pose un problème. Pour avoir des valeurs bien filtrées, il faut faire une moyenne sur beaucoup de valeurs, par exemple 64 ou 128, ce qui va diviser le “débit virtuel” de l’ADC moyenné par autant, et peut devenir vraiment un gros problème. De plus, chaque échantillon décimé va représenter un groupe d’acquisitions, une “case”, mais sans lien continu entre elles.

La moyenne mobile va nous aider.

La moyenne mobile, on la rencontre très fréquemment sur les graphes boursiers. En effet, les cours de bourse varient très chaotiquement, et un moyennage permet d’y voir plus clairement des tendances. Mais attention: dans ce domaine, faire une moyenne selon la première méthode reviendrait à utiliser un cours journalier pour calculer un cours moyen par semaine. On comprend bien que pour calculer des tendances au jour le jour, on ne peut pas se contenter d’une valeur toute les semaines, même si on tente de l’interpoler.

L’astuce consiste alors à calculer chaque jour une moyenne sur les N jours précédents. Chaque jour, la nouvelle moyenne prend en compte une partie des valeurs qui ont déjà été utilisées la veille, et ajoute l’information du nouveau jour. Ainsi, chaque jour, chaque valeur prend en compte les valeurs précédentes, mais cela atténue les variations rapides, puisque les données de chaque jour interviennent plusieurs fois dans le calcul. Voici à quoi cela ressemble sur le cours de, disons, RedHat pour rester dans l’open source. Ici j’ai demandé à tracer la moyenne mobile sur 50 jours (un classique). J’ai aussi tracé le graphe des valeurs par semaine (donc décimées), je vous l’affiche d’abord:

Cours de RedHat sur 1 an, décimation par semaine
Cours de RedHat sur 1 an, décimation par semaine
Cours de RedHat sur 1 an, décimation par jour, et moyenne mobile sur 50 jours
Cours de RedHat sur 1 an, décimation par jour, et moyenne mobile sur 50 jours

Bon, en bref: la décimation est effectivement moins bruitée que le graphe quotidien (moins de variations rapides). Mais elle contient moins de points (évidemment, 52 semaines par an au lieu de 365 jours). Et si votre seuil de basculement était à 50 dollars, eh bien les basculements seraient toujours aussi nombreux que sans filtrage. La décimation n’aurait eu aucun effet sur ce point.

Par contre la moyenne mobile, en rouge, varie plus “sagement”, tout en reproduisant les “tendances” du signal bruité, et surtout, elle existe pour chaque point de la courbe! Elle ne croise que 2 fois le seuil à $50.

A quoi cela va-t-il ressembler dans le cas de notre ADC? Eh bien c’est strictement la même chose. Chaque fois qu’on fait l’acquisition d’un échantillon, on en calcule la moyenne mobile, et on utilise cette valeur pour prendre la décision sur le signal de sortie.

Moyenne mobile: méthode naïve.

De manière simplifiée, on va avoir besoin d’un tableau pour stocker l’historique des N dernières valeurs. On aura besoin d’un index pour se souvenir de notre position, et d’une routine qui calcule la moyenne.

#define Nbits 4
#define N (1<<Nbits) //Du coup, N est une puissance de 2, ici 16
uchar hist[N];
uchar hist_index;

void init(void) {
    for(hist_index=0;hist_index<N;hist_index++) {
        hist[hist_index]=0;
    }
    hist_index=0;
}

void adc_interrupt(void) {
    uchar sample,i,filtered;
    ushort mm;

    //pseudo fonction pour lire l'ADC
    sample = adc_read();

    //stockage
    hist[hist_index] = sample;
    hist_index++;
    if(hist_index==N) { //gestion buffer circulaire
        hist_index = 0;
    }

    //Calcul brut de la MM
    mm=0;
    for(i=0;i<N;i++) {
        mm += hist[i];
    }

    //maintenant on peut jouer avec la moyenne mobile mm
    //si on veut qu'elle soit du même ordre de grandeur que les samples:
    filtered = mm >> Nbits
}

Cette méthode marche. Mais si N devient grand, le nombre d’additions à réaliser pour le calcul de mm devient énorme, et la routine d’interruption prendra énormément de temps. Il ne faut pas utiliser ce code, il est nul.

Moyenne mobile: Méthode pratique

On va repartir sur quelques bouts de maths : pas bien difficile, des suites. Imaginez des tableaux et des indices, c’est la même chose.

Définissons le signal en sortie de l’ADC comme une suite numérique.

s(n) == valeur lue de l’ADC à l’étape N

Appelons K le nombre de valeurs qu’on veut utiliser dans notre moyenne.

La moyenne mobile est alors définie comme

mm(n) = somme des s(n) pour les K dernières valeurs / K

Oublions tout de suite la division par K (elle est triviale et optionnelle, surtout si K est une puissance de 2)

Donc, on fait la somme des K dernières valeurs :

mm(n) = s(n) + s(n-1) + s(n-2) … + s(n-K+1)

Si cette expression vous perturbe, vous n’avez qu’à imaginer que s(n) est aussi définie pour des valeurs négatives de n, ou alors, qu’elle vaut zéro en ces points. En tout cas, ne vous prenez pas le chou avec ça. Dans le programme ça disparaitra.

C’est en gros le calcul qu’on a fait dans l’algo naïf.

 

Prenons un peu de recul et écrivons le calcul que nous allons faire à l’étape suivante pour calculer mm(n+1) :

mm(n+1) = s(n+1) + s(n-1+1) + s(n-2+1) … + s(n-K+1+1)

soit:

mm(n+1) = s(n+1) + s(n) + … + s(n-K+2)

Allez, ajoutons, pour le fun des maths, s(n-K+1) de chaque coté. Ca ne change rien n’est ce pas? Si A=B, alors A+truc = B+même_truc.

mm(n+1) + s(n-K+1) = s(n+1) + s(n) + … + s(n-K+2)+ s(n-K+1)

Quelle surprise… Mais c’est presque cette vieille mm(n) ! Mais si:

mm(n+1) + s(n-K+1) = s(n+1) + s(n) + … + s(n-K+2)+ s(n-K+1)

Au boulot:

mm(n+1) + s(n-K+1) = s(n+1) + mm(n)

Maintenant, on enlève s(n-K+1) de chaque coté :

mm(n+1) = s(n+1) + mm(n) – s(n-K+1)

C’est gagné. Observons ce qu’on a obtenu:

 

La nouvelle moyenne mobile, c’est  l’ancienne moyenne mobile, plus la valeur la plus récente, moins la plus ancienne.

 

Et ça, c’est vachement cool, parce que ça veut dire que dans mon programme, je n’ai plus que DEUX additions à faire à chaque IRQ, au lieu de calculer toute la somme à chaque fois!

Concrètement on a besoin de quoi? La valeur plus récente, on vient de la lire depuis l’ADC. Il faut se souvenir des anciennes valeurs. Combien d’anciennes valeurs? Exactement K. Après K étapes, ma plus ancienne valeur sera la valeur récente actuelle.

  1. A l’init, ma moyenne vaut zéro, et mes anciennes valeurs valent zéro (ça règle le problème des indices négatifs).
  2. A chaque irq, je lis un sample de l’ADC.
  3. Je mets à jour ma moyenne mobile
  4. Je stocke ce sample dans le tableau des anciennes valeurs
  5. Profit!

Allez, je termine le suspense avec le petit programme d’exemple qui implémente ça:

#define Nbits 4
#define N (1<<Nbits) //Du coup, N est une puissance de 2, ici 16
uchar hist[N];
uchar plus_ancien; //(@skywodd: pas volatile, touchée que dans l'irq après l'init)
volatile ushort mm; //stockage pour la moyenne, doit être une var globale

void init(void) {
    //effacer les valeurs anciennes
    for(plus_ancien=0;plus_ancien<N;plus_ancien++) {
        hist[plus_ancien] = 0;
    }
    //on commencera à stocker à cet offset
    plus_ancien = 0;
    mm = 0;
}

void irq_adc(void) {
    //acquisition
    sample = acd_read();

    //calcul MM
    mm = mm + sample - hist[plus_ancien];

    //cette plus ancienne valeur n'est plus utile, on y stocke la plus récente
    hist[plus_ancien] = sample;
    plus_ancien ++;
    if(plus_ancien==N) { //gestion du buffer circulaire
        plus_ancien=0;
    }
    //La MM est déjà prête à utiliser
}

Au début, avant d’avoir effectivement lu N (ou K) valeurs, la mm va augmenter lentement, il y a donc un petit régime transitoire avant que les choses se stabilisent. C’est inévitable, c’est une caractéristique des filtres.

Certains vont me dire, mais ça marche comme un filtre ! Eh bah oui, on a un genre de filtre passe bas à réponse impulsionnelle infinie (un mot compliqué pour dire que si tous vos samples ADC sont nuls sauf le premier, (et que la précision est infinie), alors tous les samples qui suivent auront une valeur non nulle…).

Les pros du traitement de signal me contrediront sans doute, mais c’est  pas grave. “Avec les mains”, ça marche, le signal est lissé.

Et voila, maintenant vous saurez dire que vous savez utiliser un ATTiny (ou autre :)) comme un DSP !

La combinaison

Bien sûr , si votre source de données a un débit élevé, rien ne vous empêche de calculer une moyenne mobile de valeurs préalablement décimées… Je sais pas trop si il y a quelque chose à y gagner…

 

A+ pour de nouveaux algos!

[eShapeOko] Tentative de planification

Mon projet d’impression 3D se met en place. Les moteurs ont été expédiés et la machine commandée. D’après le responsable de MakerSlide, toutes les machines seront expédiées après le 26 Aout.

D’ici là, il y a des choses à faire pour ce projet, et la todolist commence à se remplir. J’ai donc décidé de faire un véritable planning pour clarifier l’ordre des choses à faire et définir des priorités.

J’ai commencé à faire une liste dans excel, mais la complexité est telle que j’ai dû me mettre à la recherche d’une alternative à MS Project. Je connaissais le projet GanttProject, mais ses options de planifications sont trop simples, je n’ai pas réussi à trouver facilement comment planifier une tâche au plus tard, ce qui révèle un logiciel soit mal fait, soit incomplet. Il y a aussi pas mal de problèmes d’ergonomie (quelle galère pour gérer les dépendances, il faut cliquer dans la case de gauche sur chaque ligne, sinon l’action n’est pas prise en compte!) Dans tous les cas, ce logiciel allait me faire perdre du temps. Un rapide tour sur Wikipédia m’a rapidement orienté vers ProjectLibre, qui se veut un clone libre de MS Project. Je dois avouer que ce programme est assez moche, mais il fait son boulot correctement et permet une planification “évoluée” des tâches.

Voici donc le document auquel je suis arrivé : Voir le PDF

Bien évidemment à part pour les choses déja faites, les durées sont fantaisistes 😀

Comme on peut le voir, j’ai pu découper le projet en grandes tranches. Je commencerai par valider le fonctionnement mécanique de la plate forme XYZ sans outil, puis à partir de là, on pourra faire quelque chose de plus évolué. Le mode tour a été pensé à la base pour fabriquer les pièces de l’extrudeur, mais après quelques recherches, la fabrication d’un mandrin n’est pas du tout facile,son achat serait cher, et puis il faut une autre broche à vitesse précisément contrôlée (et un index), donc je pense que cette partie sera très complexe, je l’ai repoussée à plus tard, et je me servirai d’un tour déja fonctionnel (soit via l’Electrolab, soit chez mes amis radio-amateurs mécaniciens) pour réaliser l’extrudeur. Par contre la réalisation d’un mandrin fraisé ou imprimé sera un truc à prévoir, même si c’est juste pour le fun.

Donc voici les étapes principales:

  • Base mécanique fonctionnelle
  • Fraiseuse numérique (ne devrait pas demander beaucoup plus de travail)
  • Imprimante 3D (demande la réalisation d’un extrudeur)

La première action de la première étape est donc la réalisation des drivers de moteurs pas à pas. Initialement, je devais me faire offrir des modules Pololu, mais je n’ai aucune nouvelle de ce coté, donc je vais commencer avec des L298. Comme grbl pilote les moteurs grâce à des impulsions (dir/step) il me faut aussi réaliser un indexeur, ce qui devrait être très simple avec un PIC. La seule différence avec les modules Pololu, c’est que je ne gèrerai pas le microstep, mais ce n’est pas très grave pour le début (mes moteurs seront des 400 pas par tour).

Les autres modes (commande manuelle avec volants et tournage) sont ou deviennent optionnels et seront réalisées plus tard.

Voici ce qui est déja réalisé:

  • Compilation de grbl : j’ai testé, cela fonctionne sans problème. Par contre je réalise que grbl ne sait pas piloter les températures d’un extrudeur, ce qui demandera la recherche d’un autre firmware. En attendant, grbl sera suffisant pour le mode fraiseuse.
  • Achat d’une plaque de verre pour le support de l’impression 3D (5 euros)
  • Achat de vis en laiton pour fabriquer des buses (1 euro)
  • Récupération de prises DB25 pour le câblage des moteurs. Je ne veux pas voir de fils trainer partout 🙂 Quand l’impression 3D sera fonctionnelle, j’imprimerai des maillons de chaine passe-câble pour que ce soit encore plus propre.
  • Récupération d’une broche, qui est en fait le premier outil que j’ai acheté. C’est une mini perceuse Maxicraft, qui m’a servi à percer mes premiers circuits imprimés réalisés au feutre noir et perchlo 😀 Cette perceuse fait 42 watts, ce qui est peu, mais sera utile pour commencer des essais de fraisage, probablement au début dans de la cire de bougie, puis dans du MDF.
  • Recherche d’infos sur les fraises. Des fraises cylindriques dremel se trouvent facilement à 10 euros les deux.
  • Mise en route de la récupération de mon arduino nano prêté à @hugokernel 🙂
  • Réflexion sur l’extrudeur: je me suis renseigné sur les types de filaments disponibles, il y en a deux selon les machines (1.75mm pour les buses fines <0.4mm et 3mm pour les buses plus grosses) Je commencerai par un extrudeur pour du fil fin, puis on verra ensuite pour un extrudeur 3mm.
  • Réflexions sur le banc chauffant: je pensais utiliser du scotch de cuivre, mais c’est pénible, alors que le mode fraiseuse me permettra de graver facilement un circuit imprimé.
  • Il faut que je sois capable de programmer un avr. Pour ça, je crois que mon raspberry pi pourra m’aider, il me semble avoir lu qu’on pouvait utiliser les gpios du rpi pour programmer l’avr, c’est à confirmer, et pas tout de suite, ce n’est pas urgent!

Idées supplémentaires: j’adorerais réaliser une extrudeuse de filaments pour récupérer le PEHD des boutons de bouteille 🙂 Je ne vais pas me priver de la concevoir, et je pense qu’elle sera très facile à réaliser, avec des éléments de plomberie! Je commence à collectionner les bouchons!

Publication de SDCC 3.3.0 et gputils 1.2.0

Une nouvelle version de SDCC, le compilateur C pour PIC18, Z80, MCS51 et dérivés vient d’être publiée. Elle corrige de nombreux bugs et génère du code encore meilleur.

Pour les PIC18, il est conseillé d’utiliser simultanément les outils PIC libres gputils en version 1.2.0 qui a été publié il y a quelques jours.

Ensemble, ces deux logiciels permettent de développer facilement en C pour PIC18, même si le code généré est loin d’être optimal.

Utilisez les liens de l’article pour télécharger ces deux nouveaux logiciels, disponibles pour windows 32 et 64 bits, ainsi que pour Linux et mac.