Mot-clé - expérimentation

Fil des billets - Fil des commentaires

Vendredi, juin 24 2016

Le niveau de précision du pauvre

Voilà, ça y est, mon tour est posé sur sa dalle, je peux enfin l’utiliser. Pour maximiser sa précision, il est vivement recommandé de le mettre de niveau. Pour se faire, point de niveau de maçonnerie, il faut utiliser un niveau de précision, précision de l’ordre de 0,01mm/m.

Sauf que c’est pas complètement donné, surtout pour un équipement qui servira 2 fois dans l’année maximum. En y réfléchissant un peu, il est possible d’obtenir une bonne précision avec un niveau laser. Alors d’accord, un niveau laser, c’est pas non plus donné (pour un correct j’entends), mais au moins ça peut servir pour tous les autres travaux, et c’est facile d’en trouver en prêt chez les copains.

L’idée, c’est de se servir d’un miroir (ou de plusieurs) comme d’amplificateurs d’erreurs. Un petit schéma étant plus parlant qu’un long discours, voici la procédure que j’ai suivi :

niveau_laser

Mesure de précision avec un niveau laser

Il faut partir du principe que le faisceau est parfaitement vertical (normalement vrai pour un niveau de bonne facture, et dans tous les cas, ça se vérifie facilement). Le faisceau sort du niveau avec un angle, de manière à tracer une ligne verticale sur le mur d’en face. Il se reflète sur le miroir qui est posé sur la surface à régler. Si la surface n’est pas parfaitement de niveau, le faisceau réfléchi aura un décalage, et une seconde ligne apparaîtra sur le mur d’en face. Quand les deux lignes superposées sont confondues, c’est que l’on est de niveau… pour une direction. Reste ensuite à faire de même pour l’autre direction, et revérifier que tout n’a pas bougé.

Et niveau précision du coups ? Et bien, le faisceau fait environ 1mm de large, la précision escomptée est donc de 1mm/2h, h étant la distance entre l’origine du faisceau et l’endroit le plus éloigné où vous pouvez voir les 2 faisceaux. Dans mon cas, j’étais à 3m, ce qui me donne une précision de l’ordre de 0,1mm/m. Pas aussi bon qu’un niveau de mécanicien, mais définitivement meilleur qu’un niveau de maçon. Pour améliorer encore la chose, il aurais suffi de mettre un second miroir, pour augmenter « virtuellement » la distance.

Mais j’ai fait ça en pleine journée, et le faisceau devenais difficile à lire à cause de la luminosité. Je m’en contenterais pour le moment !

Merci à Fred pour le coups de main et le laser !

Mardi, juin 7 2016

Recyclage de laiton

Ca fait déjà quelques temps que je voulais savoir si ma petite fonderie était capable de fondre quelque chose qui fond à plus haute température que l’aluminium. L’autre matériaux que j’utilise régulièrement, c’est le laiton. En plus, c’est un métal qui coûte assez cher, mais qui est très facile à récupérer en déchetterie ou en ressourcerie.
Ce week-end, j’avais envie de me bricoler une petite pointe à tracer, genre ça https://www.youtube.com/watch?v=o8Bd8G21Vv8
Comme d’habitude, quand on a envie de faire quelque chose, on n’a pas ce qu’il faut sous la main, en l’occurrence, pas de brut de laiton. Et pourquoi pas ne pas essayer de se fondre son propre brut pour l’usiner ensuite, en partant de déchets ?

La matière première

La matière première

J’avais toute une collection d’embouts de plomberie en laiton, que j’avais récupéré à la ressourcerie du coin, et pendant les travaux de ma maison. A la louche, un bon Kilo, largement plus que nécessaire.

Quelques petites modifications de ma fonderie plus tard (jusque là, elle était en mode la-rache, je devais tenir le brûleur à la main), consistant à souder un support pour mon brûleur, j’étais prêt à fondre. D’ailleurs, bonne inspiration de souder ce support, car autant fondre de l’alu ne prend que 5/10 minutes, autant le laiton a mis une bonne grosse demi-heure à fondre !

du beau laiton fondu !

du beau laiton fondu !

 

Le moule aura été assez simple à faire : un tas de sable tassé, j’insère un tube pvc pour creuser, et c’est parti !

P1040202

manifestement, j’avais la tremblotte, j’en ai mis partout. Pas grave, je refondrais les résidus la prochaine fois. L’essentiel c’est que mon barreau est bien plein.

Après démoulage

Après démoulage

La pièce n’est pas très belle a voir (je n’ai manifestement pas assez dégazé), mais peut être utilisable quand même, c’est l’usinage qui le dira.

usinage d'un morceau pour voir

usinage d’un morceau pour voir

J’usine une extrémité pour voir ce que ça donne, et c’est plutôt une bonne surprise. Ca se comporte très bien à l’usinage, je ne sent pas de différence avec du brut industriel (contrairement à l’aluminium). Quelques trous, mais ça me laisse espérer de pouvoir rattraper la chose.

C'est parti, on enlève tout !

C’est parti, on enlève tout !

Un peu d’usinage plus loin, je suis plus ou moins contraint de m’arrêter. Mon barreau n’est pas très long, donc pour pouvoir usiner correctement toute la surface, j’ai besoin d’une contre-pointe… Que je n’ai pas encore reçu.

Première face, ça a l'air d'aller

Première face, ça a l’air d’aller

Deuxième face, c'est déjà moins joli

Deuxième face, c’est déjà moins joli

Voilà, mon process n’est pas encore parfait, loin de là, mais ça montre que c’est possible et que le résultat peut être satisfaisant. Le morceau réalisé n’étant pas pour une pièce sollicitée mécaniquement, je pense que je vais le garder tel quel, ça donnera un petit cachet à mon stylet. Il ne me reste plus qu’à attendre ma contre-pointe !

Économiquement parlant, ce n’est pas à proprement parler viable en l’état, car je chauffe au gaz uniquement, ce qui coûte assez cher. (je pense avoir passé bien 3Kg de propane (pas pensé à peser, malheureusement). Mais je suis en train de réfléchir à un brûleur propane/huile qui devrais fortement baisser les coûts, l’huile étant récupérée.

Mardi, janvier 26 2016

Fonderie aluminium

A défaut de faire dans l’exclusivité, ce petit montage va me permettre de faire quelques coulées en attendant le retrofit de mon gros fours de fonderie. En effet, ce dernier consomme 15Kw d’électricité, et mon abonnement ne le permet pas (et je ne tiens pas à en changer). L’idée sera donc de le baisser à une valeur plus raisonnable, et d’améliorer l’isolation de l’existant. En attendant, comme j’aimerais pouvoir faire quelques pièces, voici le bricolage d’une petite fonderie au gaz (et potentiellement par la suite avec un brûleur à huile.)
La première étape est de récupérer une bouteille de gaz, et de la vider. Il y a plein de tutos sur le net pour ça, voici la méthode que j’ai utilisé :
– ouvrir la bouteille pour vider ce qui reste et veut bien partir. Laisser la bouteille ouverte quelques jours, c’est toujours ça de pris.
– A l’aide d’une clef à molette (si possible de grande taille), dévissez le robinet de la bouteille. Je me suis aidé d’un maillet caoutchouc pour le desserrer au début.
– Avec un entonnoir introduit à l’emplacement du robinet, remplir la bouteille d’eau. Une fois pleine à raz-bord, secouer un peu pour être sûr qu’il ne reste plus de poches de gaz, et vider la bouteille. Elle est maintenant prête à être malmenée.

J’ai ensuite coupé la bouteille en 2, à environ 10cm du haut.

La bouteille coupée

La bouteille coupée

L’idée est d’insérer un tube en acier (~6cm de diamètre) légèrement sur le côté de la bouteille, pas en plein milieu, de manière à créer un vortex à l’intérieur, ce qui réparti mieux la chaleur. J’ai présenté mon tube et tracé le contour au feutre. J’ai ensuite percé une série de trous qui m’aideront à découper le passage du tube. La découpe sera finalisée à la meuleuse.

La bouteille percée

La bouteille percée

En parallèle, je soude quelques barres d’acier à l’intérieur du chapeau de la bouteille, ils permettront de retenir le mortier réfractaire, même avec les dilatations. J’ai également fait une découpe en suivant les lignes de soudures, pour faire sauter le filletage du robinet. Ca permet également d’agrandir la cheminée.

La préparation du chapeau

La préparation du chapeau

J’ai ensuite collé au silicone un morceau de tube PVC (qui par chance était de la bonne dimension, la prochaine fois je mesurerais avant de couper ;)). L’objectif de ce tube est de retenir le mortier dans le chapeau, tout en faisant une cheminée pour l’évacuation. Il sera enlevé, ainsi que tout le silicone restant une fois le mortier pris.

La préparation du chapeau

La préparation du chapeau

Il ne reste plus maintenant qu’à remplir le chapeau de mortier réfractaire.

Remplir à raz-bord de mortier...

Remplir à raz-bord de mortier…

En attendant que ça sèche, je continue le corps de la fonderie. Je met 4cm de vermiculite au fond de la bouteille, et recouvre d’environ 1cm de mortier réfractaire. Il va maintenant falloir s’occuper des parois de la fonderie. J’ai trouvé un morceau de tuyau de poêle qui convenais bien : bien lisse, en le plaçant au centre de la bouteille il laisse environ 6cm d’épaisseur de parois, et suffisamment de place à l’intérieur

Présentation du tuyau dans la bouteille

Présentation du tuyau dans la bouteille

Il faut donc maintenant découper l’emplacement du tube d’acier, mais cette fois-ci, comme l’épaisseur est fine, je vais pouvoir utiliser une cisaille à tôle.

Découpe du tuyau

Découpe du tuyau

présentation du tube acier

présentation du tube acier

Il faut maintenant mettre tout ça en place dans la bouteille, et ajuster au mieux pour que le tube acier soit plus plus tangent au tuyau. Une fois tout bien calé, un peu de silicone pour faire l’étanchéité (il sera enlevé après coulée du mortier).

Mise en position de l'ensemble

Mise en position de l’ensemble

Avant de couler le mortier, je voulais un système me permettant de déplacer facilement la fonderie par la suite. J’ai donc décidé de lui mettre des poignées afin de la soulever facilement. Les poignées seront faites avec 2 porte-bouteilles raccourcis et soudés sur le côté de la bouteille.

Les futures poignées

Les futures poignées

La bouteille avec ses deux oreilles :)

La bouteille avec ses deux oreilles :)

Voilà, il ne reste plus qu’à couler le mortier réfractaire

on remplis jusqu'à raz-bord !

on remplis jusqu’à raz-bord !

J’ai ensuite laissé sécher longtemps (une bonne semaine), avant de commencer de légères chauffes (5 min, 10, 15, etc…) de manière à ne pas fendre le mortier.

L'ensemble terminé, après une série de chauffes.

L’ensemble terminé, après une série de chauffes.

Pour le creuset, j’ai commencé par un petit creuset fait à partir d’un extincteur, mais je vais rapidement essayer de m’en faire un en céramique (plus durable)

Le creuset

Le creuset

Pour le brûleur, je suis parti sur un brûleur d’herbes au propane (trouvé à ~30€, méfiez vous, on trouve les même à 90€ !), que j’ai repercé pour améliorer la prise d’air. Ca ne semble d’ailleurs pas tout à fait suffisant, je vais donc ajouter une entrée d’air forcé (décapeur thermique ? ), et je vous ferais des photos de tout ça </div>
    
    
          <p class= aucun rétrolien

Samedi, octobre 31 2015

construction d’un compost en palette recyclées…

Je profite du beau temps de ces derniers jours pour bosser un peu au jardin, histoire de sortir le nez des travaux.
Ayant une grande surface d’espace vert, j’ai énormément de déchets végétaux à traiter. Les emmener à la déchetterie serait possible mais pas très écolo (18km pour y aller), d’autant qu’ils peuvent avantageusement être réutilisés, sous forme de compost. En le commençant maintenant, je devrais pouvoir avoir du bon compost prêt pour le printemps.
Pour ce projet, il vous faudra :
– 5 palettes récupérées (entre 0 et 5€max)
– 8 cornières métalliques (8€)
– un tasseau quelconque d’environ 3m de long
– un grillage assez fin (optionnel)

Première étape :

première étape

première étape

Fixer deux palettes à angle droit à l’aide de deux cornières.

Seconde étape :

Seconde étape

Seconde étape

Fixer la troisième palette aux deux précédentes, pour former un « U ». Vérifier avec un niveau à bulle que la palette du fond est bien horizontale.
Vous pouvez ensuite rajouter la quatrième palette dans l’alignement, et la cinquième, de manière à former un « M ».

Troisième étape :

Troisième étape

Troisième étape

Fixez maintenant le tasseau aux trois branches du M, ça leur évitera de s’écarter quand le compost sera chargé.

Dernière étape :
Si vous en avez, mettez du grillage à l’intérieur de vos palettes, ça évitera au compost de se sauver… Si vous n’en avez pas,vous pouvez clouer quelques planches, de manière à réduire les interstices, pour les mêmes raisons.

Bilan : un projet qui aura duré un gros quart d’heure, coûté moins de 10€, et qui, j’en suis sûr, me rendra de grand services au printemps </div>
    
    
          <p class= aucun rétrolien

Lundi, juin 22 2015

DIY – Broyeuse à plastique, proto 1

Oui, je sais, en ce moment, je ne poste pas beaucoup. Pas que je ne fasse rien, bien au contraire, mais les projets en cours sont un peu plus long à finaliser, donc nécessairement le rythme de publication s’en ressent.
Il y a quelques temps, je me suis monté une imprimante 3D, que j’utilise beaucoup pour du prototypage. Mais qui dit prototype, dit aussi ratés, et ça m’embêtait « un poil » de penser à tout ce plastique jeté après usage. J’ai donc commencé à réfléchir sur une solution de recyclage. Certes, il y a déjà beaucoup de choses sur le net à ce sujet, mais je n’ai pas trouvé beaucoup de choses concluantes en open-source, ou alors des kits à acheter, mais sans réussir à trouver les plans.
Pour recycler le plastique, il faut deux étapes : un broyeur, permettant de réduire la taille des morceaux de plastique, et un extrudeur, qui transformera ces petits morceaux en un nouveau filament.
La première étape étant de broyer les déchets, c’est donc sur cette partie que je me suis penché en premier. L’avantage, c’est que ça permet au passage de réduire le volume des déchets, pour le stockage « en attendant ».
Broyeuse à plastique

L’idée de cette broyeuse est d’avoir deux séries de dents tournant en sens inverse, et venant mordre le plastique. Petit à petit, elle va « grignoter » le plastique en copeaux plus ou moins fins.

Dent de la broyeuse

Les dents viennent s’emmancher sur un arbre hexagonal, de manière à ne pas glisser même avec des efforts très importants dessus. L’arbre est ensuite passé au tour, pour le réduire au diamètre de 8mm (rond maintenant), et sera inséré dans des roulements à billes de chaque côté.

Deux pignons ont été dessinés, de manière à ce que le premier arbre entraîne la rotation du second, sans facteur de réduction. Les deux arbres tournent donc à la même vitesse, et en sens inverse. Pour le moment, j’utilise une perceuse pour l’entraînement, mais à terme la broyeuse aura son moteur autonome.

Les dents on été réalisées en plexiglass. L’idée était de valider que tout s’emboîtait bien avant de passer à une version métal (il y en a quand même pour une grosse soixantaine d’euros de découpe pour le métal), d’autant que j’avais une découpeuse laser sous la main, et des chutes de plexi (d’où l’aspect sur certaines pièces).
La bonne surprise, c’est que le plexi semble assez résistant pour broyer du PLA (pas trop épais). Pour combien de temp ? Aucune idée, mais en attendant, ça me permet de valider bien des choses.

J’ai maintenant quelques petits points à finir/revoir sur le châssis, en particulier la fixation du moteur, et je pourrais passer à un second prototype, qui sera vraisemblablement fonctionnel. Ensuite, je pourrais passer à la partie extrudeur :)

Jeudi, février 26 2015

Moteur à électroaimant 100% récup

Il pleut aujourd’hui ? Vous savez pas quoi faire pour passer le temps ? Vous avez une montagne de vieux disques durs en attente de recyclage ?
Si vous avez répondu oui à au moins une de ces questions, ce projet est fait pour vous !
L’idée est simple : utiliser l’électroaimant d’un disque dur pour produire une rotation du disque, comme le ferait le piston d’un moteur thermique ou vapeur. Ne cherchez pas une quelconque justification technique à ce projet, il n’y en a aucune, mais ça fait un petit moteur rigolo, avec un joli bruit, et c’est amusant :)

Il vous faut un disque prêt à être sacrifié. Peut importe qu’il ne marche déjà plus, de toutes façons, il ne fonctionnera plus ensuite (en tant que disque dur tout du moins)
Un disque dur prêt à être sacrifié

Il va maintenant falloir le désosser, en faisant attention à certaines pièces. A cette étape, il y a de grande chances que vous ayez besoin d’un petit tournevis torx. Commencez par enlever l’étiquette du capot, une vis se cache sous celle-ci.

Vis cachée

Désossez ensuite la carte électronique, et mettez là de côté, elle servira plus tard. (il suffit de dévisser, elle vient ensuite toute seule. Enlevez également la mousse ou l’isolant qui est dessous)

La carte à démonter

Une fois toutes les vis enlevées, vous pouvez ouvrir le disque. Il faut des fois utiliser un petit tournevis plat pour amorcer l’ouverture. Si ça ne viens pas, ne forcez pas, vous avez sans doute oublié une vis.
Il faut maintenant enlever l’aimant au dessus du bras de lecture. Il n’est pas collé, simplement maintenant par son magnétisme (costaud). Enlevez le simplement en tirant dessus (ne le lachez pas, sinon il va se repositionner violemment, et risque de se casser), et mettez le de côté. Inutile d’enlever l’aimant de son support métallique, laissez en un seul morceau.
Vous pouvez également enlever (et jeter) toutes les petites pièces plastiques servant à parquer les têtes.

l'intérieur du disque

A l’aide d’un tournevis plat, dévissez le pivot des têtes de lectures, ainsi que le connecteur relié aux têtes par nappe souple.

démontage des têtes

Les têtes de lectures se constituent d’un corps en aluminium assez rigide, terminé par des languettes métalliques souples supportant les éléments de lecture magnétiques. Avec un cutter, détachez précautionneusement toutes les lamelles souples du corps en aluminium. Vous pouvez casser les nappes souples des têtes sans hésiter, mais pas le grosse nappe reliant les têtes au connecteur.

Le résultat

Dans les vis que vous avez récupéré lors de l’ouverture, certaines auront une tête très plate et fine. Prenez en une, et insérez là entre les deux bras supérieurs du support de tête (vous pouvez les écarter avec un tournevis plat que vous faites tourner). Mettez un morceau de papier plié de manière à combler l’intervalle entre les 2 bras et maintenir la vis en place. Chauffez les premier bras et la vis avec un fer à souder et étamez. Ca se fait pas trop mal avec un fer d’électronique, mais la soudure accroche assez mal sur l’aluminium, il faut bien chauffer, ce qui prend un petit moment. Coupez un bout de tube laiton de diamètre 3mm, et étamez l’intérieur. Chauffez, et enquillez le tube sur la vis, rajoutez de l’étain si nécessaire pour que l’ensemble tienne bien.

Soudure de la came

Sur le disque central fixant les plateaux du disque, soudez avec la même méthode (sans la vis) un tube laison, bien vertical.

les cames

Il faut maintenant remonter la tête de lecture en revissant son axe de rotation, et en repositionnant l’aimant au dessus. Refixez également le contact pour le circuit. Maintenez la tête de lecture en position haute (ie le plus vers le disque possible), et faites tourner le plateau jusqu’à ce que les 2 cames soient le plus proche possible. Coupez un bout de tube laiton de cette distance moins 1mm environ.
Etamez 2 rondelles de 3mm, écrasez le tube laiton aux extrémités, et soudez une rondelle de chaque côté.
la bielle

faites tourner les plateaux pour vérifier qu’il n’y a pas de point dur. S’il y en a, déssoudez une rondelle, raccourcissez légèrement le tube, remontez, retestez, etc…

Il faut maintenant repérer les fils de l’électroaimant des têtes de lectures. Prenez une alimentation 12v, et testez tous les contacts (certaines positions vont faire fumer de petits composants sur la nappe, tant pis pour eux </div>
    
    
          <p class= aucun rétrolien

Vendredi, octobre 17 2014

Régulation PID, faire de jolis graphiques 2/2

La dernière fois, je vous ai présenté une méthode essentiellement graphique, permettant une bonne approximation des paramètres PID de votre régulateur. Encore faut-il savoir comment tracer les graphiques, c’est ce que je me propose de vous expliquer dans cet article. Il est bien sûr évident que cette méthode peut être utilisée pour tracer des graphiques à partir de tout type de données, du moment que les données arrivent via un port série.
La première étape va consister à récupérer les données du port série sur un PC. Comme souvent, il existe plusieurs façon de faire, je vous présenterais celle que j’ai utilisé ici : un petit script python.

import serial
import sys

serialport = serial.Serial("/dev/ttyACM0", 9600, timeout=1)
line = []

while True:
    for c in serialport.read():
        line.append(c)
        if c == '\n':
            for s in line:
                f=open('myfile','a')
                sys.stdout.write(s)
                f.write(s)
                f.close
            line = []
            break

serialport.close()

Ce petit script prend les caractères arrivant sur le port série, jusqu’au caractère marquant la fin de ligne, puis écrit la ligne dans un fichier. Ca peut éventuellement suffire pour tracer un graphique… Mais dans ce cas précis, on veut pouvoir également envoyer une consigne au régulateur, la modifier afin de suivre la réaction de ce dernier. Problème : comment envoyer des données sans perturber la lecture des données et ne pas sauter de mesure ?
Là encore, il y a plusieurs méthodes possibles, certaines plus complexes que d’autres. Celle que j’ai choisi permet de garder un programme simple, mais ne fonctionnera que sous linux. Ceux sous un autre système chercheront du côté du multithreading…

import serial
import sys
import select

serialport = serial.Serial("/dev/ttyACM0", 9600, timeout=1)
line = []

while True:
        while sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
          ligne = sys.stdin.readline()
          if ligne:
            print(ligne)
            serialport.write(ligne+'\r\n')
          else: # an empty line means stdin has been closed
            print('eof')
            exit(0)
        else:
            for c in serialport.read():
                    line.append(c)
                    if c == '\n':
                        for s in line:
                                f=open('myfile','a')
                                sys.stdout.write(s)
                                f.write(s)
                                f.close
                                line = []
                    break

serialport.close()

Ah oui, j’ouvre et ferme le fichier a chaque écriture, de manière à pouvoir accéder aux données pendant l’exécution du programme. Ca permet de visualiser l’évolution du graphique en temps réel.
Les données sont envoyées par le microcontrolleur sous la forme . Je n’ai pas de mesure de temps, chaque échantillon étant pris à un intervalle d’une seconde, il suffit de compter les échantillons pour connaître le temps écoulé.

Passons maintenant au graphique lui-même. Pour cela, j’utilise le logiciel Gnuplot, outil très puissant de tracé de courbes dont nous n’utiliseront ici qu’une infime quantité de ses possibilités. Lorsque vous lancez gnuplot en ligne de commande, vous vous retrouvez avec un shell dans lequel vous pourrez lancer vos commandes gnuplot.

plot 'myfile' using 1 smooth bezier title 'temperature', 
'myfile' using 2  with line title 'CO', 
'myfile' using 3 with line title 'Setpoint'
 plot 'myfile' using 1 

Indique que l’on va tracer une courbe correspondant aux données de la première colonne du fichier

smooth bezier

Indique que l’on veut lisser les données. Il n’est pas toujours intéressant de lisser les données, par exemple, ici la colonne 3 correspondant à la consigne n’est pas lissée, ce qui permet de visualiser le moment exact du changement de consigne. Par contre, dans le cas des valeurs mesurées, cela permet de s’affranchir du bruit sur les mesures.

title 'temperature'

Légende de la courbe. Pratique dès qu’il y a plus d’une courbe.

Par défaut, gnuplot va afficher le résultat à l’écran. Pour pouvoir enregistrer le résultat dans un fichier il faut taper les instructions suivantes :

set terminal "png"
set output "monfichier.png"
replot

Nota : avec la commande replot (ou avec le bouton replot de la gui), vous pouvez rafraîchir les données affichées, de manière à visualiser en continu vos données…
Il y a certainement plein d’amélioration possibles à ma méthode, mais je vous la présente car elle a le mérite d’être simple et rapide à mettre en oeuvre, tout en fournissant de bons résultats :)

Dimanche, septembre 14 2014

Régulation PID, comment la régler 1/2

Étant donné que je n’ai pas encore tout le matériel nécessaire pour avancer mes autres projets, j’en profite pour approfondir un peu mes connaissances théoriques et vous en fait donc profiter. Mon projet ici est simple : Réguler une température à l’aide d’un microcontrolleur, mais surtout bien comprendre les tenants et aboutissements des différents réglages et algorithmes. L’objectif ici n’est pas tant d’expliquer ce qu’est un PID, ni comment il fonctionne dans le detail, mais plutôt de donner une méthode permettant d’approximer les coefficients du régulateur.

Je profiterais de cette expérience pour faire 2 articles :
– celui-ci concernant le PID a proprement parler
– Un second article concernant ma méthode pour obtenir des courbes « lives » a partir d’un arduino et d’un PC.

Qu’es-ce qu’un PID

Pour simplifier, on parlera dans la suite de régulation de température, vu que ce sera notre application ici. Mais bien entendu, une régulation peut se faire sur tout type de process (vitesse, débit, etc…)

Lorsqu’on veut réguler la température (d’une pièce par exemple), l’idée la plus simple qui nous vient à l’esprit est de faire une régulation tout-ou-rien : on est en dessous d’un premier seuil, on allume la chauffe, on passe au dessus d’un second seuil on coupe la chauffe. Cette façon de procéder, bien que très simple à implémenter n’est pas exempte de défauts. Par exemple, la température ne sera jamais vraiment constante, même si elle l’est « en moyenne ». Selon le process, on peut arriver à fortement dépasser les consignes (dans un sens ou dans l’autre), en fonction de l’inertie du système, ce qui peut s’avérer nuisible selon ce qu’on veut faire. Enfin, la puissance du chauffage oscillera entre 0 et 100%, ce qui engendre une surconsommation non négligeable.

La régulation PID permet de coller « au plus juste » à la consigne, en évitant les dépassement (en fonction du réglage comme on le verra plus loin), et en n’utilisant que la puissance nécessaire à aller à la consigne et à la maintenir. Concrètement, dans PID, on a P pour Proportionnelle, D pour Dérivée, et I pour Intégrale. Si comme moi vous avez tendance à être un peu allergique aux maths, vous commencez déjà à vous sauver, mais en fait c’est moins compliqué que ça n’en a l’air.

Proportionnelle : c’est ni plus ni moins que la différence entre votre consigne et la valeur actuelle, multiplié par un coefficient de proportionnalité (Que vous définissez, cf la suite). Dans la suite, nous l’écrirons Kc.e(t)

Intégrale : A chaque mesure, vous allez avoir une différence avec la consigne (en plus ou en moins). Prenez cette erreur à chaque pas de temps, multipliez la par un (autre) coefficient de proportionnalité, et additionnez le résultat de tous les pas de temps depuis le début, et vous avez la fameuse composante Intégrale. Dans la suite, l’intégrale sera notée de la façon suivante :

I

 

Dérivée : Son rôle est de « freiner » l’augmentation de puissance calculée en fonction de P et de I, de manière à ne pas dépasser la consigne. C’est une façon de prendre en compte la vitesse d’évolution de notre process. Pour le calculer, vous faites erreur actuelle – erreur précédente, multiplié par un troisième coefficient de proportionnalité

La formule globale de notre régulateur PID peut donc s’écrire de la manière suivante (plus d’explications plus bas):

Formule PID, source ControlGuru

Formule PID, source ControlGuru

 

Description du materiel

Le montage utilisé pour ces essais est très simple : un arduino, un bouton 2 positions, 1 capteur de température (DS18B20), un mosfet (IRF540), une résistance 10Ω 5W, et une alimentation 12V. Le mosfet est piloté par une sortie PWM de l’arduino, et gère le courant (puissance) transitant dans la résistance. Cette dernière chauffe donc plus ou moins en fonction du ratio PWM (la tension change) envoyé par l’arduino. Le bouton 2 positions sert à passer d’une première consigne (valeur PWM 5 sur 255) à une seconde (valeur PWM 30 sur 255) Un petit programme python enregistre les valeurs dans un fichier texte sur le pc (via connection série), et j’utilise GnuPlot pour avoir une jolie courbe et pouvoir lire les valeurs des graphiques plus facilement que directement sur l’image. Par la suite, j’ai ameliore mon script python, de maniere a pouvoir saisir une consigne via le port serie, tout en continuant de logguer.

Montage régulation de température

Montage régulation de température. Attention, utiliser une résistance 5W mini !

Méthode de réglage

Je vous présente une méthode « graphique » directement tirée du site Control Guru, appliquée à mon montage de test. Ce site étant en anglais et très dense en informations, j’ai essayé de résumer les points essentiels ici. J’invite ceux qui voudraient approfondir le sujet à consulter ce site qui est une véritable mine d’information sur la régulation.

Définitions

  • PV : Process Variable, cela correspond à la grandeur mesurée que l’on veut influencer (la température dans cet exemple)
  • CO : Controller Output , la sortie de notre contrôleur en %. (Correspond à l’ouverture de la vanne par exemple)
  • Kp : Gain du process
  • Kc : Gain du contrôleur

Introduction

Une fois modélisé notre boucle de contrôle, nous allons pouvoir en déterminer les trois paramètres principaux par expérimentation, mesure et calcul (et oui…)

Les paramètres à déterminer sont :

  • Kp : la Gain du process, ou, dit autrement, le sens et la grandeur de la variation de la sortie
  • Tp : Constante de temps du process, ou la vitesse de variation quand le process a commencé à répondre
  • θp : (Prononcer Thêta P) Temps mort du process, ou le délai écoulé avant que le process commence à réagir
Boucle de contrôle

Boucle de contrôle

Afin de pouvoir déterminer nos trois paramètres, il va nous falloir mesurer la façon dont réagis notre système. La première étape consiste donc à fixer une première valeur de sortie à notre contrôleur (CO) et attendre que la variable de sortie (PV, ici la température) soit bien stabilisée.

Une fois cette dernière stable, nous allons modifier la valeur de sortie du contrôleur (CO), et mesurer le changement obtenu sur la variable de sortie (PV). On logue bien sûr tout ça dans un fichier, avec les pas de temps, de manière à pouvoir également déterminer le temps mort du process (θp) et la vitesse de variation (Tp).

On se sert ensuite de ces mesures pour tracer un joli graphique, qui nous servira à déterminer nos différentes valeurs.

La formule permettant de déterminer notre premier paramètre Kc, qui est à la base du calcul de nos 3 paramètres (cf. formule) est la suivante :

source : controlguru

source : controlguru

pour déterminer Kc, nous devons donc commencer par déterminer différentes variables intermédiaires.

Calcul de Kp

Kp décrit le sens et de combien va évoluer PV, en fonction d’un changement de consigne (CO) Le cacul de Kp est assez simple : Kp=ΔPV/ΔCO ou en d’autre termes Kp = (différence en PV initial et PV final)/(différence entre consigne initiale et finale)

Sur mon prototype, j’ai modifié la consigne initiale (1,96%) pour une nouvelle consigne à 11.76%, voici la courbe obtenue:

Graphique test du système.

Graphique test du système.

En appliquant la formule ci-dessus, on a donc Kp = (79-40)/(11,76-1,96) = 39/9.8 = 3.98°C/%

Détermination de la constante de temps Tp

Tp représente le « en combien de temps » le système va réagir. En partant du même graphique, on va déterminer quand l’état de sortie vaut 63% de δPV, à partir du moment où le système à déjà commencé à réagir (et pas à partir du moment où on a modifié la consigne. Pour ceux qui se demandent d’où sort les 63%, vous trouverez toutes les explications (attention, maths !) dans ce pdf Fichier:Derive63rule.pdf On regarde donc le nombre de secondes écoulées lorsqu’on arrive à 63% de δPV (ici 39*0.63 + 40 = 64.6°C), et le nombre de secondes écoulées au moment où le système commence à réagir (très rapide ici)

Détermination de la constante de temps TP

Détermination de la constante de temps Tp

On obtiens donc Tp = 172 secondes.

Le cas de θp

θp représente le temps mort avant réaction. Dans une boucle de contrôle, il n’est jamais très bon d’avoir du temps mort, et il sera nécessaire d’avoir cette valeur la plus faible possible. Du fait de mon montage de test, le temps mort est ici très réduit. Ceci s’explique facilement par la position du capteur (sur la résistance), et par le faible volume à chauffer (uniquement la résistance. De manière assez intuitive, on imagine très bien que plus le volume à chauffer sera important, plus le temps mort sera long, pour une même puissance de chauffe.

Si on reprend le graphique ci-dessus, on vois que la consigne a été modifié à T1=195s, et j’ai décider de compter le début de la réaction à T2=198s. On a donc θp = T2 – T1 = 198 – 195 = 3s.

Il est intéressant de noter ici que mon échantillonnage étant d’une seconde, la valeur de θp peut être sensiblement erronée, du fait de sa faible durée dans ce cas.

Application à un modèle PID

Formule PID, source ControlGuru

Formule PID, source ControlGuru

Avec:

  • CO = Sortie du contrôleur (Controller Output)
  • CObias = biais du contrôleur, ou valeur nulle.
  • e(T) = Erreur actuelle, définie par SP – PV
  • SP = consigne (Set Point)
  • PV = valeur actuelle du process (Process Value)
  • Kc = Gain du controlleur, un paramètre de réglage
  • Ti = reset time, un paramètre de réglage
  • Td = derivative time, un paramètre de réglage

Calcul du gain et du reset time

Il faut tout d’abord se demander si notre process accepte un dépassement de consigne ou pas, ainsi que la vitesse à laquelle ce process doit réagir.

  • Si on accepte un dépassement, on peut choisir un réglage agressif, et donc un faible temps de réponse (petit Tc). Dans ce cas, Tc est le plus grand de 0.1Tp ou 0.8θp
  • Modéré, le contrôleur produira peu ou pas de dépassement. Dans ce cas, Tc est le plus grand de 1.Tp ou 8.θP
  • Conservateur, le contrôleur ne produira pas de dépassement, mais ira doucement, Tc sera le plus grand de 10.Tp ou 80.θP

Une fois décidé du comportement de notre contrôleur, et calculé Tc, on peut calculer le gain du contrôleur et le reset time grâce à la formule suivante :

source : controlguru

source : controlguru

Pour mon application, je vais choisir un comportement modéré. Tc sera donc la plus grande valeur de 1.Tp ou 8.θP (1×172 ou 8*3=24). On retiendra donc Tc = 172.

J’obtiens donc Kc = (1/3.98)*(172/(3+172)) = 0.25%/°C et Ti = 172

Je peux maintenant calculer mes deux principaux paramètres P et I :
P = Kc = 0.25
I=Kc/Ti. = 0.25/172 = 0.00145
Reste à déterminer D. la formule permettant de déterminer D est Kc.Td, avec Td = (Tp.θP)/(2Tp+θP) = (172*3)/(344+3) = 1.487. D vaut donc 0.25*1.487=0.372
D = 0.372

Mise en application

Reste maintenant à confronter les calculs à la réalité. Voici le code Arduino que j’ai utilisé pour effectuer mes tests :

#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 2
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors(&oneWire);
DeviceAddress insideThermometer;

unsigned long lastTime;
double Input, Output, Setpoint;
double ITerm, lastInput;
double kp, ki, kd;
int sampleTime = 1000; //1 sec
double outMin, outMax;
String cmd = String("");
double tfirst = 0;

float printTemperature(DeviceAddress deviceAddress)
{
  sensors.getAddress(insideThermometer, 0);
  float tempC = sensors.getTempC(deviceAddress);
  Serial.print(tempC);
  Serial.print(" ");
  Serial.print(Output);
  Serial.print(" ");
  Serial.println(Setpoint);
  return(tempC);
}

void compute()
{
  unsigned long now = millis();
  int timeChange = (now-lastTime);
  if(timeChange>=sampleTime)
    {
      //get the new input value
      Input = getInput();
      //compute all working error variables
      double error = Setpoint - Input;
      ITerm+=(ki * error);
      if(ITerm>outMax) ITerm = outMax;
      else if(ITerm < outMin) ITerm = outMin;
      double dInput = (Input - lastInput);
      
      //compute PID output
      Output = kp * error + ITerm - kd * dInput;
      if(Output > outMax) Output = outMax;
      else if(Output < outMin) Output = outMin;
      
      //remember some variables for next round
      lastInput = Input;
      lastTime = now;
    }
}

void setTunings(double Kp, double Ki, double Kd)
{
  double sampleTimeInSec = ((double)sampleTime)/1000;
  kp = Kp;
  ki = Ki * sampleTimeInSec;
  kd = Kd / sampleTimeInSec;
}

void setSampleTime(int NewSampleTime)
{
  if (NewSampleTime>0)
  {
    double ratio = (double)NewSampleTime / (double)sampleTime;
    
    ki *= ratio;
    kd /= ratio;
    sampleTime = (unsigned long)NewSampleTime;
  }
}

void setOutputLimits(double Min, double Max)
{
  if(Min > Max) return;
  outMin = Min;
  outMax = Max;
  
  if(Output > outMax) Output = outMax;
  else if (Output < outMin) Output = outMin;
  
  if(ITerm>outMax) ITerm = outMax;
  else if(ITerm<outMin) ITerm = outMin;
}

double getInput(void)
{
  sensors.setResolution(insideThermometer, 9);
  sensors.requestTemperatures(); // Send the command to get temperatures
  return printTemperature(insideThermometer);
}

void setup()
{
  Serial.begin(9600);
  pinMode(3, OUTPUT);
  Setpoint = 0; //on fixe 0 de consigne
  double P, I, D;
  P = 0.25;
  I = 0.00145;
  D = 0.372;
  int STime = 1000;
  setTunings(P,I,D);
  setSampleTime(STime);
  setOutputLimits(0, 255);
}

void loop(){
compute();
analogWrite(3,Output);
if (Serial.available() > 0) {
      char SerialInByte;
      SerialInByte = Serial.read();
      
      if(SerialInByte==13){
        Setpoint = cmd.toInt();
        cmd = String("");
      }
      else
      {
        cmd += String(SerialInByte);
      }
  }
}

et voici le résultat :

Test des paramètres PID calculés

Test des paramètres PID calculés

Conclusion :

J’ai utilisé des paramètres « conservateurs » afin d’éviter de dépasser la consigne. On peut voir qu’effectivement la consigne n’est jamais dépassée, au prix d’une montée en charge un peu lente. En partant sur cette bonne base, il est maintenant facile d’affiner si l’on souhaite quelque chose d’un peu plus réactif, il reste de la marge de manœuvre.

Sources :

La régulation étant un vaste domaine, j’ai trouvé beaucoup d’informations pertinentes sur les deux sites suivants. Si vous n’êtes pas anglophobe, et désirez approfondir le sujet, je vous les recommandes chaudement !
ControlGuru
brettbeauregard.com, auteur d’osPID

- page 1 de 3