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 :)

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.

Continue reading

Moteur Stirling – réalisation d’un vilebrequin

Le premier vilebrequin que j’avais réalisé avais été prévu pour être vissé. Dans la pratique, ça s’est avéré infaisable, la maneton était trop petit pour être usiné correctement sans être déformé. J’avais donc fait un assemblage serré, mais les nombreux montages/démontages ont eu vites fait de rentre le jeu trop important pour être utilisable. Ca plus d’autres défauts sur l’original m’ont motivé à en refaire un, plus propre.

Je voulais rester sur des techniques relativement traditionnelles de fabrication (pas de cnc donc), je suis resté sur une fabrication entièrement au tour, en décomposant le vilebrequin en trois éléments : les 2 masselottes (et leurs axes, d’un seul tenant), et le maneton (l’élément de liaison central). Par contre, il me fallait cette fois une méthode d’assemblage qui reste très rigide et ne risque pas de bouger dans le temps. Je suis donc partis sur un assemblage par frettage.
L’idée du frettage est de refroidir la pièce que l’on va insérer pour la contracter, et de chauffer la pièce dans laquelle se fait l’insertion, pour la dilater. Les jeux mécaniques prévus font qu’il est impossible à température normale d’assembler les éléments.

De gauche à droite : le support d'assemblage, le réfrigérant, une masselotte, le maneton

De gauche à droite : le support d’assemblage, le réfrigérant, une masselotte, le maneton

Je passerais rapidement sur la réalisation des masselottes, usinage très classique au tour. La seule remarque est une épaisseur de 5/10eme en plus sur toutes les épaisseurs (voir plus loin le pourquoi). D’ailleurs, finalement, il vaut mieux prévoir un peu plus, 1mm ne semble pas gênant.
Sur les masselottes, côté maneton sont percé 2 trous de 8mm. ces trous ont deux utilité : ré-équilibrer la structure (là, j’ai fait au pif, pas bien ;)), et faire passer des piges (morceaux de stub usinés), afin de bien centrer lors de l’assemblage.

Ensuite, il faut usiner un support, dans lequel viens se loger notre première moitié de vilebrequin, ainsi que les deux piges.

Voilà comment va se présenter l'assemblage

Voilà comment va se présenter l’assemblage

Comme on le vois sur la photo, le maneton ne rentre pas dans la masselotte (pour la photo, il tiens juste sur les chanfreins). La première étape va donc consister à rendre solidaire ces deux pièces.

On va donc refroidir :

-50°c environ

-50°c environ

et chauffer :

On chauffe au rouge... Le chalumeau acétylène ça aide !

On chauffe au rouge… Le chalumeau acétylène ça aide !

Et voilà, y’a plus qu’à… sauf que j’étais un peu au dessus des côtes et ça ne rentre pas aussi facilement que ça le devrais. Un petit passage sous la presse, et c’est réglé (pas de photo, désolé j’avais besoin de mes deux mains là ;) ).

On va maintenant pouvoir passer à l’assemblage final. Placez les bielles sur le maneton (important !!! sinon, il faudra démonter tout ça et vive la galère), les piges pour bien centrer la seconde moité, et enfin la seconde masselotte. Vous devriez avoir quelque chose qui ressemble à ça :

Le montage avant frettage

Le montage avant frettage

Après avoir vérifié que le trou est bien aligné avec le maneton, surélevez la masselotte, réfrigérez le maneton, chauffez la masselotte (la partie fine au rouge), et assemblez avec une presse. Normalement, ça rentre comme dans du beurre.

Voilà, vous avez maintenant un beau vilebrequin en « un seul bloc » ou presque…

Le vilebrequin à la sortie du fretage

Le vilebrequin à la sortie du frettage

… oui, sauf qu’il ne tourne pas droit !! En effet, le maneton ne s’est pas forcément emmanché bien droit, le chauffage a déformé certaines parties, bref, c’est la cata, sauf que c’était prévu, d’où les 5/10eme de marge, car on va maintenant repasser tout ça au tour.

Pour avoir quelque chose de bien concentrique, je vais donc tourner entre pointes, les deux extrémités du vilebrequin ont été usinée avec un cône à 60° à cet effet. L’idée est donc de coincer ma pièce entre deux pointes tournantes, et de l’entraîner grâce à un « toc » pour pouvoir réusiner toutes les parties et avoir quelque chose de bien concentrique au final.

Le toc est une petite pièce que j’ai du fabriquer, une baque d’acier percée de part en part, une vis venant coincer l’axe du vilebrequin contre l’intérieur de la bague, une autre vis tordue venant se prendre dans les mors du tour pour entraîner tout ça.
Une photo valant mieux qu’un grand discours, voici à quoi ressemble mon toc :

Le toc

Le toc

Les bielles sont attachées avec du fil de fer pour ne pas gêner l’usinage. On va d’abord usiner un premier côté, puis retourner l’ensemble (en passant le toc de l’autre côté, et fixant les bielles de l’autre côté également).

Le montage prêt à être tourné

Le montage prêt à être tourné

Voilà, j’ai maintenant un beau vilebrequin qui tourne bien rond :) Il ne me reste plus qu’à ré-assembler tout ça, et voir ce que ça donne…

Critique – Le dernier théorème de Fermat, Simon Singh

Au bout de 3 jours de vacances, ayant épuisé les quelques livres que je m’était gardé sous le coude, me voilà errant dans les rayons d’une petite librairie périgourdine. En règle générale, je suis très science-fiction, mais le libraire avais ici pris soin de mettre en avant toutes sortes de thématiques,  dont une rayon « scientifique » bien achalandé. Après avoir longtemps hésité sur d’autres livres, j’arrêtai mon choix sur ce livre – Le dernier théorème de fermat – avec quelques appréhensions, me rappelant que mon niveau de maths n’avais jamais été bon, et que je ne gardais pas un souvenir enchanté de cette matière. Je m’attendais donc à devoir abandonner au bout de quelques pages, largué par le discourt.

Le dernier théorème de FermatLa première surprise, vient du style d’écriture. En effet, ce n’est pas un livre rempli de formules mathématiques comme on pourrait le craindre au premier abord (elles sont mêmes très limitées, ce qui s’avère presque frustrant par moments). Très didactique, l’auteur prend le temps d’expliquer les différentes notions, ainsi que le contexte historique. Plus qu’un voyage dans les mathématiques, c’est un voyage dans l’histoire des maths, depuis Pythagore jusqu’à nos jours, et il s’avère que ce voyage est passionnant !
Mais loin de se contenter de retracer l’historique des découvertes, l’auteur met en perspective la vie des différents mathématiciens avec leurs époques, les liens qui se formaient entre eux, et les conditions favorables aux découvertes majeures.
Et le pire, c’est que sans rien laisser paraître, des notions qui vous semblaient obscures, vont petit à petit vous sembler plus familières. Vous vous surprendrez à enfin comprendre en qui consiste le travail des mathématiciens travaillant sur la théorie des nombres !
Bref, à ma grande surprise, j’ai trouvé ce livre très bien fait, au point qu’il m’ait donné envie de me replonger dans les maths pour combler certaines lacunes ;)

Ps : pour ceux qui se poseraient la question, le théorème de Fermat est le suivant :
Prouver qu’il n’y a pas de nombres entiers non nuls x, y et z tels que :

xn + yn = zn,

dès que n est un entier strictement supérieur à 2.

 

Capteur optique de vitesse et sens de rotation (2)

Deuxième partie : de l’idée à la mise en oeuvre.

Passons donc, comme promis, à la construction de ce capteur de vitesse ET sens de rotation.

D’abord, dessiner le patron. Je choisis de faire 3 largeurs de franges sur 24 degrés selon le dessin suivant (Fig 4).

Patron du premier codeur

Fig. 4 : Patron du premier codeur

Les fronts « noirs » seront régulièrement répartis tous les 8° dans le sens trigo, cette répartition régulière pourra être la base de la mesure de vitesse, en se basant sur les fronts montants pour un sens de rotation, descendants pour l’autre sens. La première frange occultante aura 2° de large, la deuxième 4°, et la dernière 6°. Ceci répété 16 fois pour faire le tour. J’aurai donc une roue dentée à 48 créneaux par tour, ce qui suffit bien pour la précision dont j’ai besoin. Le premier prototype sera fait d’une roue dessinée sur l’ordinateur, imprimée sur un film transparent, découpée grâce aux petits ciseaux de couturière piqués à ma charmante épouse, et collée à nouveau sur un bouton de potentiomètre placé sur l’arbre moteur. Résultat nul : imprimante jet d’encre sur film transparent = pas du tout opaque, les variations de signal sont trop faibles. Je l’imprime sur du papier blanc, collé sur film plastique pour rigidifier, puis découpé aux ciseaux : c’est mieux au niveau du signal, mais mes découpes sont imprécises et les différences de largeurs de bandes sont trop irrégulières pour permettre une détection fiable du sens de rotation. C’est en plus très fragile. Néanmoins, le principe est validé : les créneaux obtenus à l’oscillo étant bien identifiables lorsque la fabrication des encoches est correcte (voir photo 5).

codeur-papier

Photo 5 : Codeur « papier »

Je construis un modèle STL, en réduisant un peu la résolution pour faciliter la fabrication (10 séries de 3 encoches sur 360° au lieu de 16)  et l’imprime sur une RepRap… mais le plastique est trop translucide et je ne peux pas augmenter l’épaisseur sinon elle ne passera plus dans la fourche !! De plus la précision de la Reprap est trop limite, et les bords pas nets car les fils de PLA (le plastique utilisé) bavent un peu… les durées différentes sont difficilement identifiables (illustration 6).

Mauvais signal avec la roue en PLA

Illustration 6 : Mauvais signal avec la roue en PLA

Tant pis, je passe à l’imprimante 3D Z-builder (flashage de résine UV par un vidéo projecteur) à laquelle j’ai aussi accès (merci Gi-Nova, et merci Christofer !) et obtiens enfin un modèle suffisamment précis, rigide, opaque… (illustration 7) qui va permettre de mesurer vitesse et sens de rotation de mes moteurs (vitesses variant de -120 à +120 tr/min).

Roue en résine photosensible

Illustration 7 : Roue en résine photosensible

Et voici la roue codeuse sur le système final en cours d’assemblage… (photo 8).

Roue codeuse en place

Photo 8 : Roue codeuse en place

Pour la partie logiciel :

Afin de compter de manière fiable les fronts, j’ai opté pour l’utilisation d’interruptions, une qui compte les fronts montants et enregistre leurs dates, une autre pour les fronts descendants. Sur l’Arduino, le plus simple et fiable que j’ai trouvé est d’utiliser 2 entrées différentes pour cela (et comme entre temps j’ai investi dans un MEGA, cela ne me pose plus de gros soucis ;-) ). Le programme principal calcule alors la largeur (durée) des créneaux par différence de dates, conserve toujours les 3 derniers créneaux, et fait les calculs lorsque le créneau détecté est plus grand que les 2 précédents.

Pour être précis, notons ces durées (délai entre front montant et front descendant) dt1, dt2, dt3 dans l’ordre d’apparition. Nous venons de dire que au moment où nous faisons le calcul de vitesse et de sens dt3 est supérieur à dt1 et dt2. Alors si dt1<dt2, le sens de rotation est direct, mais si dt1>dt2, le sens de rotation est indirect. Dans le sens direct, la fréquence des fronts montants est à peu près régulière et permet de calculer assez précisément la vitesse angulaire de la roue codeuse (nombre de fronts montants comptés, ramené au temps passé depuis le dernier calcul). Dans le sens indirect ce sont les fronts descendants qui sont réguliers.

Voili-voila. Si vous avez besoin d’un capteur de vitesse vous donnant le sens de rotation : Do It Yourself !

Phil.