Mercredi, mai 20 2015

Montage d’une meuble moidules

Bonjour,

Lors de mes pérégrinations sur les sites d’impression 3D, j’étais tombé sur un projet thingiverse : Moidules ! Le concept est au final assez simple : des pièces imprimées en 3D donnant la possibilité de se créer un meuble sur mesure et modulaire.

Concept simple qui m’a plu tout de suite. Cela n’a rien de novateur, mais j’aime bien ce genre de projet, et j’avais besoin de me réaliser un petit meuble à poser sur mon bureau pour ranger une grosse partie de mon bordel électronique. Du coup banco, je me suis lancé sur le projet.

Réalisation du projet.

Vu que mon imprimante 3D ne fonctionnait toujours pas, j’ai utilisé une imprimante de mon fablab : la printrbot. Petite, robuste et efficace, ce fut une bon choix. Niveau plastique, j’avais en stock du PLA bleu de chez esun. De la moyenne qualité donc, mais en quantité suffisante pour le projet et à un coût raisonnable (environ 22€ / kilo)

J’ai dessiné sur papier mon meuble, puis j’ai compté ce qu’il me fallait imprimer comme pièces. 34 pièces en tout décomposées de la manière suivante :

- B Left : 2
- B Right : 2
- T Module : 20
- L Module : 4
- X Modules : 6

Les premières pièces imprimées

Les premières pièces imprimées

Clairement, 34 pièces, c’est long à imprimer. Surtout quand on réalise qu’il faut environ 1h15 en moyenne pour réaliser une pièce. Soit pour l’ensemble un peu plus de 42h d’impressions. Oui oui, vous avez bien lu, il fallait un peu moins de 2 jours d’impression pour si peu de pièces (les joies de l’impression 3D). Et pourtant j’avais monté la vitesse en passant d’un facteur 100 à un facteur 180, car après test, c’était la limite avant de perdre en qualité. Et tout ça, sans compter le fait que j’ai foiré toute une après midi d’impressions (il y a des jours, où rien ne va).

Printing moidules pieces with a @printrbot at @FabLabThi pic.twitter.com/46CShGdYgS

— Manuel Esteban (@Yaug) 21 Mars 2015

 

Bref, outre le temps d’impression, qui du coup s’est étalé sur le plusieurs semaines, il y avait aussi le poids. J’ai utilisé environ 1,5 kg de plastique pour réaliser ces pièces. J’ai documenté le projet sur le forum du thilab et annoncé mes avancées au fur et à mesure.

Quand j’ai enfin vu le bout de ces impressions, je me suis mis à la recherche des planches. Car ce projet moidules avait un problème : il était fait par des anglosaxons. Et un bon anglosaxon, ça se doit d’utiliser des tailles non standard. Là, pas question de pied, de pouce ou de pierre, ils ont juste fait le projet pour du 9mm. Le genre de planche pas chiante à trouver du tout à trouver quoi …

Une fois que j’ai commencé le projet, Philippe, un des membres du Thilab a pris le temps de réaliser des versions customisables de ce projet, où l’on peut adapter à peu près toutes les tailles. Le tout est disponible sur thingiverse, je vous conseille plutôt d’utiliser cette version ! Si il faut, d’autres formes pratiques ont été ajoutées.

Ayant commencé pour du 9mm, je suis allé jusqu’au bout, et j’ai fini par trouver mes planches dans un magasin au Luxembourg. Ouf !

Montage

Une fois l’ensemble des pièces imprimées et les planches achetées, vint le moment du montage. Et hop, à peine lancé, je me rend compte que j’ai un décalage et que mes planches flottes dans les pièces imprimées… ça valait le coup de se décarcasser à acheter du 9mm. Je pense que le problème est lié au fait que j’ai imprimé en PLA, et qu’il y a du y avoir une rétractation du plastique. J’ai utilisé tout simplement du papier replié pour boucher un peu les trous (système D quand tu nous tiens).

Impression de la dernière pièce

Impression de la dernière pièce

Après deux petits heures de montage (dont une bonne partie à caler les planches correctement), j’obtiens finalement un meuble ! Reste que mon design étant ce qu’il est, avec le jeu des pièces plastiques, il s’affaisse un peu milieu. Rien de bien grave vu que je ne compte pas y mettre de trucs ultra lourd, mais c’est tout de même dommage.

Montage terminé !

Montage terminé !

Le meuble en place

Le meuble en place

 Conclusion

En soit le projet est donc intéressant car il permet une certaine flexibilité, vous créez votre meuble en fonction de vos besoins, vous lui donnez la forme que vous voulez. C’est donc du pur meuble DIY, et c’est aussi ce qui me plaisait.

Notez qu’il est possible d’utiliser tout type de matière tant que cela n’est pas trop lourd. Je pense tester un projet avec du verre par exemple.

L’autre intérêt c’est que les pièces sont réutilisables par la suite. Si vous déménagez, vous pouvez alors utiliser les pièces pour réaliser un autre meuble.

Niveau coût, il faut tout de même étudier son projet. Il faut prendre en compte le coût du plastique ainsi que celui du bois (et le bois c’est souvent bien cher …). Dans mon projet par exemple, j’aurais pu ne pas faire une colonne intermédiaire ça m’aurais éviter des problèmes de résistances, et ça m’aurait fait beaucoup moins de pièces à imprimer.

Bref, j’ai bien aimé le projet et je pense me servir de ce type de connecteur (mais avec ceux réalisés par le Thilab) dans d’autres projets, en simplifiant le schéma cette fois ci.

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

Dimanche, janvier 25 2015

HdmiPi : De kickstarter à mon salon

Bonjour à tous,

Voila plusieurs mois que j’ai reçu un des projets pour raspberry pi que j’avais financé sur la plateforme de financement participatif Kickstarter : HDMIPI.

Le pitch du projet : fournir au raspberry pi un écran hdmi haute définition de qualité pour un prix raisonnable. Projet intéressant pour qui a envie d’afficher des infos domotique sur son Pi par exemple. Une description au format pdf est disponible sur le site. Mais comme tous mes projets financés sur kickstarter, il est arrivé chez moi, j’ai ouvert le carton, je me suis dit cool ! Et j’en suis resté là :)

Il est temps de corriger cette bêtise, et de tester le HdmiPi !

Pour vous aider, voici la vidéo de 30 minutes expliquant en anglais comment monter votre HdmiPi.

Commençons par ouvrir la boite reçue. Tout est plutôt bien emballé et protégé.

Ouverture du carton

Ouverture du carton

Une fois tout déballé, cela ressemble à ça  (pour le kit que j’avais pris sur kickstarter)

 

On déballe tout

On déballe tout

Le kit que j’avais pris contient :

  • L’écran
  • Les divers élèments de la structure
  • La carte hdmipi
  • le chargeur 5.2V/2A
  • Le connecteur hdmi pour brancher sur le pi
  • Le connecteur USB / Micro Usb
  • Les vis de fixation
Zoom sur la carte HDMI Pi

Zoom sur la carte HDMI Pi

En déballant et en suivant le processus d’installation, je me rend compte que la plaque d’acrylique est en mauvais état. Voyez vous même en dessous.

Et bien non ! C’est juste que je suis un boulet, j’ai oublié d’enlever un des films de protection (chaud à enlever il faut dire …)

La plaque en mauvais état

La plaque avec un film que j’ai oublié d’enlever

Sur le moment, pas vraiment le choix, je dois poursuivre le montage. Je me débrouiller au fablab pour en découper une nouvelle si je trouve les dimensions sur le site. (Je ne me suis rendu compte de cela qu’après qu’un ami m’ait signalé avec déjà eut ce problème d’oubli de film protecteur :) )

Je poursuis donc le montage.

On place l'écran, le contour hdmipi et la première structure

On place l’écran, le contour hdmipi et la première structure

La plaque est retournée, on y ajoute le contour avec marqué hdmipi derrière, puis on met la première structure en acrylique. On fixe le tout avec les vis de 3mm. Attention, il y a des vis de 2.5mm et de 3mm, ne pas se tromper comme moi, car les 2.5 servent ensuite pour fixer la carte hdmi. A chaque fois, il faut enlever la couche de protection, et essayer d’enlever la poussière sans laisser de traces de doigts.

On rajoute ensuite l’écran après avoir enlevé la couche de protection, on l’encastre avec la plus grosse partie en bas (côté signe HDMIPi).

L'écran mit en place

L’écran mit en place côté face

L'écran monté côté pile

L’écran monté côté pile

On rajoute ensuite la seconde structure en acrylique puis la structure transparente en gardant le trou du bon côté pour passer le câble de connexion.

Si tout va bien, retirer alors la plaque transparente pour monter dessus la carte et un raspberry pi.

La carte, le raspberry pi et leurs connexions.

La carte, le raspberry pi et leurs connexions.

La carte hdmi est fixée avec les 2 vis de 2.5mm avec, pour chaque vis, un écrou en plastique sous la carte et un au dessus pour le bloquer. Le rasbperry pi est lui aussi bloqué par 2 vis de 3mm. Pas besoin de d’écrou plastique pour le dessous, et un en plastique au dessus. Une fois bloqués, on connecte les 2 ports hdmi et les 2 ports usb et micro usb. On remet ensuite tout ça à l’arrière de l’écran.

On replace le tout derrière l'écran

On replace le tout derrière l’écran

On fixe ensuite le connecteur bleu dans son logement, en décalant un peu la fixation noire (voir la vidéo). Une fois le connecteur fixés, replacez le câble autant que possible sous la plaque transparente.

Le connecteur protégé sous la plaque

Le connecteur protégé sous la plaque

Quand tout est okay, rajoutez les écrous épais pour fixer le tout et montez la dernière structure en acrylique derrière. Utilisez alors les dernières vis pour fixer le tout.

L'arrière fixé

L’arrière fixé

Vous avez alors la possibilité de placer les supports de boutons à l’arrière, des pièces découpées pour s’ajuster au dessus des boutons avec une face collante pour rester en place. C’est assez pratique.

Tout est okay, il n’y a plus qu’à connecter la carte SD, un clavier usb ou quoi que ce soit, et de brancher l’alimentation. Et c’est bon !

Le premier lancement

Le premier lancement

Mon avis

Au final, je suis plutôt content de ce projet kickstarter. Toute les pièces sont d’assez bonne qualité et se montent facilement. La carte hdmipi est de bonne facture, et tout se positionne facilement. Seul le prix (104£ pour ce pack) fait un peu mal …

Je cherchais un moyen de déplacer facilement mon Pi, c’est le projet idéal vu qu’on se balade ainsi avec un écran de qualité, un pi protégé et sans que ce soit trop volumineux. On verra ensuite à l’utilisation ce que ça donne, mais ça à l’air assez costaud.

 

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

Vendredi, juillet 4 2014

Imprimante 3D : Montage partie 2

Sommaire

Hola,

Après avoir monté l’axe Y dans un premier temps, il faut désormais attaquer la phase suivante décrite dans le guide de montage de RepRap.org : L’axe X.

L’axe X est en fait l’Axe portant la tête d’impression chauffante et qui sera trimbalé sur le plateau. Cette partie est assez rapide comme vous pouvez le voir sur le tutoriel de reprap. Mais bien que rapide j’ai rencontré plusieurs problèmes gênants :

Un X end Idler incomplet

Cette pièce, dans la version rework de la Prusa I3 est censée permettre de fixer dessus un détecteur de fin de course. Hors dans la version imprimée que j’ai commandé, il n’y en a pas. Ce n’est pas catastrophique, mais il va du coup falloir que je le fixe d’une autre manière, sans doute via un point de colle.

Mon X end Idler et X end motor sont un peu différent du modèle affiché sur le site de reprap, mais ça semble faire l’affaire tout de même. On verra bien à la longue si ces pièces conviennent. Pour insérer les douilles à billes, j’ai du forcer avec un maillet, mais ça passe.

Un X Carriage mal fait

Cette pièce était chez moi mal imprimée. Un des coins à un peu sauté quand j’ai enfoncé une des douilles à billes (ce qui en soit n’est pas extrêmement grave vu que se sont surtout les attaches de serrage qui tiennent ça en place.  Par contre ce qui m’a le plus gêné, c’est que un des trous où passer les colliers de serrage n’était pas formé. Du coup, obligé d’y aller à la vrille pour créer à trou à cet en droit là.

Je pense qu’il faudrait revoir le modèle de cette pièce pour imprimer des trous un peu plus large pour les colliers de serrage afin d’éviter ce genre de problèmes.

 

Voici quelques photos de cette partie là :

 

Verso de l'axe X

Verso de l’axe X

Recto de l'axe X

Recto de l’axe X

La partie du holder qui a éclaté.

La partie du holder qui a éclaté.

 

L’axe X est monté, il n’y aura plus qu’à le fixer ensuite dans l’ensemble.

Retour à la première partie – Aller à la troisième partie

Jeudi, juillet 3 2014

Imprimante 3D : Montage partie 1

Sommaire :

Bonjour,

Comme annoncé, je me suis lancé la construction de mon imprimante 3D : la Prusa I3 Rework.

Je vais donc commencer au fur et à mesure le montage et vous dire ce qui va ou ne va pas.

J’ai reçu toutes les pièces plus rapidement que je pensais. Ebay m’annonçait souvent une livraison pour la première semaine de juillet, et au final je récupérais les livraisons une semaine plus tôt. Plutôt rapide donc, pour de la livraison chinoise. La plupart des petites pièces ont été commandées en chine (visserie principalement), le kit frame + pièces imprimées a été commandé en France, et le reste vient soit d’Espagne soit du Royaume Unis.

Montage de l’axe Y

L’ensemble des étapes à suivre pour ce montage est à lire sur le site de reprap : click.

Première étape, et déjà premier problème.

Le kit de visserie de base de la Prusa I3 Rework n’est pas compatible avec le cadre d’imprimante que j’ai acheté (en lot avec les pièces imprimées). Pour l’assemblage du plateau de support, il fallait 2 vis M3x14, mais vu l’épaisseur de mon cadre en bois, j’ai du passer au Castorama acheter des M3x20, là niquel. (j’ai testé du M3x18 mais c’était trop juste).

On passe ensuite à l’assemblage des parties transversales. Rien de bien compliqué en soit. Le plus « compliqué » est en fait de découper les barres de 1m achetées à Castorama (environ 5€ la barre de 1m) dans les portions requises. Ensuite il suffit de suivre les étapes en faisant juste attention à bien positionner les pièces imprimer. Je n’avais pas mis le butoir des pièces d’angle dans le bon sens, et j’ai du démonter pour corriger le problème. Rien de grâce, juste 5 minutes de perdu je pense.

Là où ça se complique un peu, c’est lors de l’assemblage des parties longitudinales. Les pièces imprimées commandées se révèlent vachement serrées les 2 tiges lisses 8x350mm. J’ai du forcer au marteau pour qu’elles puissent rentrer dans les butoirs prévus à cet effet. Du coup un des coins s’est fendu, mais rien de grave.

Voila le résultat de cette première partie du montage :

L'ensemble du plateau Y monté

L’ensemble du plateau Y monté

La fameuse fêlure après avoir forcé un peu trop

La fameuse fêlure après avoir forcé un peu trop

 

Retour à l’étape précédentePasser à l’étape suivante

Montage d’une imprimante 3D

Sommaire :

Ça y est !

J’ai fini par succomber. Depuis plusieurs mois, l’idée de me faire une imprimante 3D me trottait par la tête, et j’ai fini par lâcher prise et me décider : je me monte une imprimante 3D.

Après quelques recherches, j’ai opté pour le modèle suivant : une Prusa I3 Rework. Il s’agit de la 3 ème version du modèle open source : Prusa Mendel.

Une prusa i3 rework

Une prusa i3 rework

Pourquoi avoir choisi ce modèle ?

En premier lieu je voulais m’acheter une imprimante en kit ou montée pour ne pas me prendre trop la tête, et j’étais tombé sur celle là. Après des recherches, il semblait qu’elle soit assez courante et surtout, le site de reprap fournissait l’intégralité des données pour l’assembler. Le prix du kit que j’avais vu était de 600€. Lâcher autant ne me disait pas pour une première imprimante, du coup, j’ai relancé mes recherches, et j’ai pu trouver qu’il était possible de se la faire soit même pour environ 300€. Bingo !

Et ça tombe bien, le site de RepRap est remarquablement fait, car on y trouve notamment :

La liste de toutes les pièces nécessaires ainsi que toutes les étapes de l’assemblage.

Ma liste de cource

Grâce notamment au tuto de Iooner et à la liste du matériel publiée sur le site de reprap, j’ai pu rapidement me commander mes pièces à droite ou à gauche sur ebay.

Voici ma liste du matériel :

Printed parts lien ebay 65,00 €
Tiges lisses et filetés Castorama 25,00 €
Pinces clip lien ebay 2,25 €
Plateau chauffant lien ebay 7,88 €
Thermistance Commandé 1,99 €
Ramps lien ebay 20,00 €
Atmega lien ebay 10,64 €
stepstick lien ebay 13,31 €
Endstops lien ebay 9,60 €
Power supply lien ebay 35,00 €
Frame 0,00 €
Kit vis lien ebay 44,00 €
11 LM8UU lien ebay 14,64 €

Soit un total de 250€ ! Imbattable :)

Je vous dévoilerais au fur et à mesure de mon avance les problèmes que j’ai pu rencontrer. Au jour où j’écris cet article, j’ai reçu toutes les pièces nécessaires et je viens de commencer l’assemblage. La suite bientôt :)

- page 1 de 13