Mot-clé - expérimentation

Fil des billets - Fil des commentaires

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, mai 30 2014

Moteur Stirling, deuxième prototype 4/…

3-8/03 : 8h d’usinage et de FAO. Fabrication des brides de l’échangeur, ainsi que tu tube inox de l’échangeur. Ca n’aura pas été tout seul : les deux premières brides sont sorties sans problèmes, les deux suivantes ont en revanche été complètement voilées lors de l’usinage… Fraises usées ? Problème de matériau (pourtant même provenance…) ? Bref, un peu de surfaçage plus tard, je le retrouve bien plates, avec 1/10eme en moins sur l’épaisseur finale (mon brut était nettement plus épais, ce qui fait qu’au final, même après re-surfaçage, j’arrive pas loin de la côte…
Évidemment, je n’avais pas avec moi mes raccords cuivre, je n’ai donc pas encore pu braser les coudes sur les brides. En revanche, j’ai déjà brasé une bride sur le tube inox (inox sur inox donc), ça s’est plutôt bien passé :) (brasure argent). Cette partie nécessitant pas mal d’ajustement, j’ai hâte de l’avoir terminée, histoire de passer aux choses sérieuses !

19/03 : 3h d’usinage + FAO. Fabrication d’un montage pour fixer les masselottes pour l’usinage. Retour à l’alu, ça fait du bien après tout cet inox… Rien de bien compliqué sur le montage, j’en ai profité pour avancer la FAO des masselottes.

24/03 : 6h de travail. Une heure d’usinage environ, pour avancer les masselottes. Cette fois-ci, j’attaque les choses sérieuses, je fais le détourage et les perçages. Mis à part un foret cassé, tout s’est bien passé. Le gros du travail de la journée aura été de la plomberie : j’ai terminé les têtes de cylindres, avec la tuyauterie du régénérateur. C’était un peu le gros stress, car c’est le moment où je découvre si tout s’emboîte correctement, et si mes dimensions sont justes. Quelques petites frayeurs également au moment de braser, étant loin d’être expert, j’ai toujours peur de rater quelque chose (le chalumeau chauffe tellement qu’il peut trouer mon tube de cuivre sans problème !)
Au final ça s’est pas trop mal passé. Certaines brasures ne sont pas des modèles du genre, mais avec le volume d’inox à chauffer autour, pas forcément évident. En tous cas, ça a l’air étanche, ce qui est le but. Reste maintenant à trouver un moyen de nettoyer tout le noir laissé par cette opération.

Brasure de l'échangeur

Brasure de l’échangeur, avant nettoyage…

1 et 3/04 : 4h d’usinage. J’attaque les choses sérieuses : le volant d’inertie. C’est un gros morceau, pas particulièrement complexe (quoique), mais long à faire : un gros bloc d’inox à usiner, sans casser trop de trucs (donc en allant pas trop vite), avec pas mal de matière à enlever.
Pour le moment, je n’ai fait que les opérations intérieures, restera à faire le « détourage », opération qui s’annonce déjà compliquée…
Histoire de pimenter un peu un usinage qui se passait trop bien, le taraud que j’utilisai a cassé à la dernière opération (taraudage 6 sur 6 au total…). Bien évidemment, il est resté coincé dedans… Avec pour 200€ de brut d’inox, autant dire que j’ai bataillé un moment pour réussir à l’extraire (finalement en tappant (fort) dessus avec un marteau et une pointe à centrer… La pointe n’a pas aimé, mais j’ai sauvé les meubles, et le filletage s’est avéré récupérable malgré tout !)

4/4 : compliqué aujourd’hui ! Techniquement, 4h de travail, pour seulement 1h productive… En effet, en étant trop concentré sur ce que je voulais palper sur le centre d’usinage, j’en ai oublié de regarder ce qui se passait au dessus, et complètement abimé le carter du palpeur qui est venu s’écraser contre le haut de mon montage… Grosse grosse frayeur (ça vaut dans les 2-3000€, et surtout, il n’y en a qu’un, s’il casse, je bloque la machine pour tout le monde jusqu’à remplacement…).
Heureusement, après une série de mesure, ça a l’air d’être uniquement cosmétique, les pièces calibrées que nous avions pour comparer faisant toujours la même taille au centième près (ouf).
Histoire de continuer à me stresser, l’opération d’aujourd’hui consistait à percer le trou de blocage de mes masselottes (dernière opération) , mais je n’avais qu’un seul foret d’assez long pour cette opération, et il faisait…. 30cm de long !!! Autant vous dire, que j’ai serré les fesses avec celui-là, d’une part car la journée avais mal commencée, d’autre part parce que je n’avais qu’une seule chance !

Les masselottes montées sur l'arbre

Les masselottes montées sur l’arbre

 

12/05 : un peu de laissez-aller sur le compte rendu là… Du coups, je n’ai pas le compte exact du temps passé, mais une simple approximation, dans les 6h. J’ai enfin terminé le volant d’inertie. Il me restait à faire le contour externe et le clavetage. Pour le contour externe, dégrossissage au centre d’usinage, avec fraise ravageuse, par demi-sphères, ce qui permettait un serrage sur pince et donc de se passer d’un montage. Là encore, « un peu » de casse, avec deux fraises ravageuses cassées (diamètre 20 quand même !!). Après analyse et nouvel essai, il s’avère que j’avais voulu être trop prudent et prenait des passes trop petites, ce que ces fraises n’apprécient pas.
La finition de l’extérieur s’est faite au tour, ce qui a permis au passage d’avoir de jolis chanfreins. J’ai bien bataillé pour réussir à avoir une bonne concentricité (usinage des mors doux et tout…). Bref, au final, ça tourne (rond).

Dernière étape pour cette pièce : le clavetage. N’ayant pas de mortaiseuse, cette étape a été réalisée à la main, sur le tour, en utilisant l’outil à claveter comme un rabot, en enlevant la matière 1/10e de mm par 1/10e. C’est pas très rapide, mais ça marche.

Assemblage des pistons

Assemblage des pistons

26/05 au 28/05 : 1h d’usinage, et je commence l’assemblage :). Après avoir claveté le volant d’inertie, me restait les deux brides à claveter. Une fois le tout assemblé, il s’est avéré que mon arbre ne rentrait plus, il fallait ré-aléser. Malheureusement, je ne sais pas ce qui s’est passé (là je n’ai vraiment pas compris), mais mon alésage s’est fait légèrement de travers, ce qui fait que mon trou est maintenant oval d’un côté, avec 0.5mm de jeu… Je pourrais corriger en réusinant deux brides (qui servent notamment à ça), mais vu les délais je décide de laisser tel quel. Mon volant tourne légèrement voilé, mais rien de dramatique, et surtout, une fois la clavette mise, il ne bouge absolument pas.

Les débuts de l'assemblage

Les débuts de l’assemblage

Toutes les pièces ont maintenant été usinées (à l’exception de deux bagues en vermiculite qui le seront cette semaine, mais ne sont dans tous les cas pas obligatoires, je peux donc débuter l’assemblage. Ce dernier avance assez vite, j’ai déjà démonté/remonté l’ensemble en moins d’une journée pour modifier quelques paramètres. Il reste a faire les « petits » ajustements (longueur des arbres, angle des masselottes, etc…), et je pense pouvoir enfin tester la bête :)

 

 

Samedi, avril 12 2014

C’est bientôt Pâques…

Ceux qui me connaissent bien vous le diront, je suis un gourmand :p C’est pourquoi quand Greg a proposé d’organiser un atelier chocolat au sein du log, j’ai saisi l’opportunité :)
L’objectif de l’atelier : nous apprendre à travailler le chocolat, et réaliser nos propres oeufs en chocolat, et autres « bonbons » fourrés. De mon côté, j’avais déjà assisté à un premier atelier la semaine précédente, pendant lequel j’en avais profité pour faire des sucettes au chocolat en forme de moustaches, fourrées à la ganache chartreuse. Cette fois-ci, je me suis donc concentré sur la réalisation d’un « gros » oeuf :)
Pour les gourmands qui voudraient s’y essayer, voici un petit récapitulatif de ce qu’il faut (si j’ai bien tout retenu ;)), et de la façon de procéder.

Matériel nécessaire :

  • Une grande casserole (pour le bain marie)
  • Un petit bol en inox (cul-de-poule)
  • Un thermomètre (pas « obligatoire », mais pour débuter, c’est vraiment plus facile )
  • Un pinceau
  • Un moule demi-oeuf.
  • Une spatule métallique
  • Pistoles de chocolat (pour moi, c’était du chocolat au lait origine Ghana 40,5%)
  • Une bombe d’azote (réfrigérant rapide)

Contrairement à ce qu’on pourrais croire, le moule à œuf n’est pas en silicone, ou autre matériau souple, mais en polycarbonate bien rigide. En effet, le chocolat en refroidissant va se rétracter, et le demi-oeuf se démoulera tout seul.

Première étape : faire fondre le chocolat, au bain marie, en surveillant la température : il faut monter à 40-45° pour le chocolat au lait. Avec un thermomètre c’est facile, sans, ça correspond à un peu moins du seuil de douleur (précis comme indication, n’es-ce pas ;)). Attention à ne pas faire tomber d’eau dans le chocolat lors de cette étape (ni des suivantes), ce qui ferais coaguler ce dernier.

Ensuite, il va falloir tempérer le chocolat. Cette étape est nécessaire à la bonne cristallisation de votre chocolat, et vous permettra d’avoir un joli aspect brillant, exempt de traces blanches. Une fois votre chocolat à température (40-45°C), sortez le du bain marie et ajoutez un peu moins d’un tiers de pistoles à température ambiante (20%  de pistoles). Mélangez jusqu’à que tous les pistoles aient fondus. (S »ils disparaissent trop rapidement, rajoutez en un peu)

A l’aide du pinceau, appliquez généreusement du chocolat sur votre moule, en n’hésitant pas à déborder, et en ne laissant aucun trou ou zone transparente. Cette étape assurera un beau fini extérieur et l’absence de bulles en surface. Laissez prendre légèrement, et versez du chocolat fondu (hauteur d’une phalange) dans votre oeuf. Répartissez de manière homogène et laissez reposer un peu. Répétez l’opération encore une fois ou deux, puis videz l’excédent dans le cul-de-poule. Raclez les bords avec une spatule métallique. Mettez au frais.

Au bout de quelques minutes, retirez votre oeuf du frigidaire, et laissez le finir de cristalliser dans un coin assez frais (genre bord de fenêtre à l’ombre). Lorsque vous verrez un petit espace entre le moule et le bord de votre oeuf, il est prêt à être démoulé. Placez vous au dessus d’une surface dure (genre table), mettez la main sur le moule et renversez. S’il tombe tout seul, votre main le retiendra, sinon, tapotez légèrement le moule dur la table (en laissant la main dessous, hein !). S’il ne tombe toujours pas, n’insistez pas, laissez le prendre encore un peu. Attention, ne mettez pas les doigts sur la surface de l’œuf, vous y laisseriez des traces. Prenez le par l’intérieur.

Voilà, c’est démoulé, vous avez un premier demi-oeuf. Vous pouvez répéter l’opération pour avoir l’autre moitié. Faite refondre votre chocolat, et re-tempérez le avant car il a pris pendant ce temps.

Une fois vos deux moitiés d’œuf démoulées, refaite fondre un peu de chocolat et retempérez. Avec le pinceau, appliquez du chocolat sur le bord intérieur de l’œuf, en débordant sur la tranche. Répétez sur l’autre moitié, et assemblez. Vous pouvez maintenant vous servir de la bombe d’azote pour accélérer la prise sur la jonction.

Atelier chocolat

Atelier chocolat

Mon neuneuf à moi :)

Mon neuneuf à moi :)

ps : pas beaucoup de photos de « pendant », désolé, mais le chocolat, ça en met vraiment de partout ;)

Samedi, janvier 25 2014

Moteur Stirling, deuxième prototype 2/…

9/12 : 4h d’usinage. Réalisation de la tête du cylindre froid. Rien à dire, ce fut beaucoup plus facile que dans l’inox, malgré le fait que le brut faisait la même taille. Avec le laiton, ça ne m’a pas posé de soucis de prise de pièce. Du coups, le résultat est bien mieux ajusté que son équivalent inox. Bon, c’était purement esthétique pour l’inox, mais quand même…J’ai également réalisé le piston froid. Cette fois, pour ne pas pourrir l’atelier, j’ai attaché le tuyau de l’aspirateur au plus près de mon outil. Résultat : nickel ! Les seuls fois où il y en a eu un peu à côté, c’est quand je faisait des passes trop importantes, ou trop vite. Sinon, ça me faisait une jolie poussière bien fine, qui partait directement dans l’aspirateur. J’ai à peine eu à nettoyer le tour, c’est dire !

L'aspirateur pour usiner le graphite

L’aspirateur pour usiner le graphite

Je suis soulagé, les deux cylindres, et les deux pistons sont maintenant terminés (aux perçages près pour les têtes). Les jeux sont très bons, on sent une forte compression lorsque l’on bouche une extrémité et que l’on force le déplacement du piston.
(edit : le propriétaire de l’aspirateur s’est montré un peu moins enthousiaste sur ma méthode ;). Mais ça reste tout de même plus simple de nettoyer un aspirateur qu’un atelier complet…)

13/12 : 3h de FAO. J’ai avancé pas mal de pièces en FAO, il ne reste plus qu’à trouver du temps machine pour les réaliser. J’ai profité d’un petit créneau le soir pour lancer les perçages des bouchons (pour les solidariser aux cylindres). Temps d’usinage environ une heure, mais essentiellement du temps machine, j’avais mis des avances très lentes pour le perçage inox, histoire de ne pas casser de foret dans la pièce.

Petite photo de famille des pièces déjà usinées. On y vois les cylindres, un piston et le socle.

Petite photo de famille des pièces déjà usinées. On y vois les cylindres, un piston et le socle.

06/01 : 2h30 d’usinage sur centre. Réalisation des deux supports de cylindres verticaux. Pour réussi les deux supports, il aura fallu en faire 4 :( Une fraise cassé à la fin du contournage sur du second (alors que le premier s’était bien passé, mêmes paramètres), et casse d’un taraud dans le premier, lors du perçage des trous finaux (rageant à ce stade, merci à Alain pour sa patience, qui m’aura terminé la pièce en mon absence)

08/01 : 4h de FAO. les deux clamps auront demandé pas mal de réflexions et de galères pour arriver à un résultat utilisable. J’ai également terminé de découper mon brut d’alu à la scie sauteuse, promis, c’est la dernière fois que je fais ça comme ça, la prochaine fois, je prend les bruts à la bonne dimension. Au final, il va me manquer un peu de matière, dû aux deux pièces finalement assez importantes que j’aurais du refaire. Heureusement, c’est sur de l’alu, pas trop cher…

16/01 : 4h d’usinage plus retouches FAO. En fait, ça s’est fait en deux sessions, mais j’ai oublié de noter le jour précédent ;) Usinage des articulations des bielles. 4 pièces sur 6 sont terminées entièrement, les deux restantes en sont à 30%. Finalement, le plus difficile sur ces pièces reste de les tenir sans usiner les mors (on aura quand même un peu rayé la peinture…). En parallèle, je suis en train de regarder la faisabilité de faire le volant d’inertie en fonderie. Avantages : ça permet de faire une pièce plus jolie, et de faire ça en attendant que des créneaux sur le centre d’usinage se libèrent, inconvénients : pas sûr que le poids de la pièce finale soit suffisant, car je ne peux couler que de l’alu. Reste la possibilité de faire des inclusions pour lester tout ça, mais bonjour la galère à équilibrer. Bref, je regarde ce qui est faisable ou pas :)

Les bielles

Les bielles

22 et 24/01 : 5h d’usinage et FAO. Réalisation des pinces de serrages pour les culasses. Elles ne sont pas encore terminées mais déjà fonctionnelles (une dernière passe esthétique est encore nécessaire). 6 opérations d’usinages pour en venir à bout, et donc autant de travail FAO. Comme toujours, ce qui est long c’est de trouver le bon système pour caler la pièce, et l’ordre le plus logique pour les opérations. Petit à petit, je deviens autonome sur le centre d’usinage. Je fais les fichiers FAO, place les pièces correctement, fait les origines et relance les usinages. Alain est toujours là pour lancer le premier cycle histoire de vérifier qu’on ne va rien casser… Merci à lui!

Vendredi, décembre 27 2013

DIY – Générateur de Marx

C’est pas encore l’heure des bonnes résolutions, mais je renoue ici avec une de mes passion premières, un peu délaissée ces derniers temps : la haute tension.
Le montage auquel je me suis attaqué aujourd’hui est assez simple dans son fonctionnement, il s’agit d’un générateur de Marx, qui permet de multiplier une tension. L’avantage de ce montage, est qu’outre sa simplicité, la tension de sortie est directement proportionnelle au nombre d’étages mis en jeux (aux pertes près).

Générateur de Marx

Générateur de Marx

Le concept consiste à charger X condensateurs en parallèles, et les décharger en série. Pour arriver à un pareil résultat, on va utiliser des éclateurs. En effet, tant que la tension  aux bornes du condensateur ne dépasse pas une certaine tension, rien ne se passe, les condensateurs se chargent tranquillement, et la tension à leurs bornes augmente peu à peu.

Charge

Charge

 

Mais lorsque cette tension est atteinte, un arc électrique se produit sur l’éclateur, qui deviens ainsi conducteur.

Décharge. En bleu ciel, les arcs électriques

Décharge. En bleu ciel, les arcs électriques

(oui, désolé pour les couleurs un peu flashy, ça pique les yeux, je sais)
Pour que ça fonctionne (bien), il y a tout de même quelques paramètres importants à respecter. Déjà, il faut que la tension d’alimentation soit suffisamment élevée pour pouvoir produire un arc électrique, sinon les éclateurs ne fonctionneront pas. Ensuite, les résistances de charges. J’ai un peu galéré pour trouver des résistances correctes pour ce montage. Au début, j’étais partis avec des résistances couches carbone (les classiques), mais rapidement les arcs sont passés par le côté de la résistance, détruisant celles-ci. J’ai ensuite voulu utiliser des résistances de puissances en céramique. Mauvaise idée : elles ont été détruites en totalité sur un seul shoot. Je suspecte plus la déflagration d’avoir endommagé l’intérieur que la chauffe proprement dite car elles étaient sensées tenir plus que les couches carbone, ce qui n’aura pas été le cas ici. Finalement, j’ai utilisé des résistances bobinées de puissances, et après quelques dizaines de minutes de fonctionnement, tout à l’air en ordre de marche. Dernier point, la distance entre les éclateurs est relativement importante, c’est d’elle que dépendra la « tension de claquage »

Mon générateur de Marx

Mon générateur de Marx

Comme on peut le voir sur la photo, mon générateur est constitué de 6 étages, ce qui multiplie donc par 6 la tension d’entrée… En théorie. En effet, mes éclateurs étant difficiles à régler, ma tension de claquage est assez loin du maximum débité par mon alimentation. Au final, je dois arriver à une tension de 10Kv par condensateur, soit 60Kv en sortie.
Les éclateurs sont de simples fils de cuivre recourbés, passés au papier de verre pour enlever l’émail.

Le générateur en action

Le générateur en action. Le père Noël fait 12cm

Petit détail pour ceux qui serais tentés par l’expérience, et qu’il est difficile de rendre sur une photo : C’est extrêmement bruyant !! (genre mitraillette dans le salon)

Vendredi, décembre 6 2013

Moteur stirling Alpha, deuxième prototype

Ayant relevé tout un tas de défaut qui empêchaient le fonctionnement de mon premier moteur stirling, j’ai donc décidé de partir sur une seconde version améliorant les problèmes. Au final j’ai complètement changé le design, et suis partis sur un modèle à pistons parallèles (mais toujours alpha), car ils permettent plus de réglages. Je me suis largement inspiré d’un design trouvé sur internet, en apportant des corrections sur les points qui avaient posé problème à ses auteurs. Cette nouvelle version présente également un changement d’échelle par rapport à ma V1, mais finalement plus importante que ce que je m’imaginais à partir de la CAO. Comme pour le modèle précédent, je publierais les plans dès que mon modèle sera fonctionnel (s’il l’est), en y apportant les différentes corrections/modifications faites en cours de route.

Comme il s’agit d’un projet d’assez longue haleine, je vous met ça sous la forme d’une sorte de journal de bord. Cela vous permettra d’y voir la chronologie des étapes, et à moi de garder une trace des temps passés pour faire un bilan final. Histoire de ne pas polluer le blog avec un post a chaque étape, j’essaierais de grouper ça dans un post mensuel, sauf éventuellement sur des points techniques intéressants.

Vendredi 8 /11: Ebauche du piston chaud. 5h d’usinage, pour réduite un rond d’inox, diamètre 60 sur 200 de long, à un tube d’inox de diamètre intérieur 45… Reste à l’emmener à 50mm de diamètre interne, et reprendre légèrement le diamètre extérieur (0.2mm). La plupart des matériaux ont été achetés ou commandés, à l’exception du laiton.

Cylindre chaud

usinage du cylindre chaud

Mardi 12/11: Finition du cylindre chaud. 2h d’usinage. Cote interne au début du cylindre 49,635, cote à la fin 49,64 ce qui n’est pas mal sur 160mm de long avec des outils moyennement adaptés. Le piston est terminé, à l’exception des perçages.

le cylindre chaud : un peu plus gros que la v1 ;)

le cylindre chaud : un peu plus gros que la v1 ;)

Mercredi 13/11 : 2h d’usinage. Travail sur la tête de la culasse chaude. J’ai été trop léger sur la longueur du rond d’inox acheté. Résultat des courses, l’usinage est compliqué. J’ai atteint 1/100eme de précision sur la partie rentrant dans la culasse, en revanche, sur l’extérieur, j’ai été obligé de descendre en dessous de la côte (problème de concentricité car pas assez de matière pour la prise). Du coups la tête fait 0,5mm de diamètre en moins que la culasse. Pas super esthétique, mais aucune influence sur le fonctionnel. J’essaierais de faire mieux sur le piston froid.

Mercredi 20/11 : 1h d’usinage. Réalisation du piston chaud, en graphite. Alors le graphite à usiner, c’est du beurre, mais alors à nettoyer…. Donc, 1h pour réaliser la pièce, 3h pour nettoyer l’atelier ! Et dire qu’il m’en reste un autre a faire :’(

Lundi 25/11 : Ca y est, j’attaque le socle et les parties d’assemblages. L’usinage se fera au centre, j’ai donc du apprendre pas mal de choses sur la génération de code machine, et notamment la prise en main d’Esprit, qui n’est pas un modèle d’ergonomie ;) Merci encore à Alain pour ses précieux conseils.
Au total, il m’aura fallu 5 heures pour aboutir à une pièce à moitée usinée : les perçages et le surfaçage sont fait, mais il reste encore le contournage. Pour pouvoir le faire, je dois réaliser un support qui permettra de brider la pièce dans le centre d’usinage. Connaissant un peu mieux le logiciel maintenant, je pense gagner pas mal de temps sur les prochaines pièces !
Sinon, petite boulette en passant : à l’origine je pensais usiner mes pièces d’assemblage sur une fraiseuse « stratoconception ». Cette machine permet de disposer au mieux les différentes pièces, et de tout découper à partir d’une seule plaque de matière. (très pratique pour faire des meubles). Bien que pouvant théoriquement usiner de l’aluminium, j’avais négligé le problème de la lubrification, ce qui m’oblige à passer sur le centre d’usinage pour toutes les pièces d’assemblage, et pas seulement la base. Là où ça deviens moins drôle, c’est que le centre ne fonctionne pas de la même manière, et on travaille pièce par pièce avec des morceaux de taille adaptée… Me voilà donc avec ma scie sauteuse à redécouper ma plaque d’alu de 10mm…. J’en ai pour quelques heures !

Mercredi 27/11 : 3h d’usinage. Je viens de recevoir mon laiton. 15Kg de brut pour le cylindre froid (ouch !) J’ai passé deux heures sur le tour pour réaliser l’ébauche. Les ailettes de refroidissement sont terminées, et les diamètres extérieurs sont à +5mm pour pouvoir les reprendre aux mors doux quand j’aurais terminé l’intérieur.
Il me reste maintenant à creuser ça, quelques heures de travail en perspective.
Sinon j’ai profité d’un créneau machine ce matin pour usiner le support de bridage de ma base. Avec un peu de chance, je pourrais terminer cette partie vendredi.

L'ébauche du cylindre froid

L’ébauche du cylindre froid

Vendredi 29/11 : 5h d’usinage. Aujourd’hui, travail de finition du  cylindre froid. Objectif être le plus prêt de la cote internet du cylindre chaud. Résultat cylindre froid : 49.625mm, cylindre chaud 49,635. Plutôt pas mal :). Par contre, la fin de l’usinage s’est très mal passée : après avoir fait la passe de finition d’un côté du cylindre, j’ai voulu usiner les mors doux pour ne pas le marquer en usinant l’autre côté. Malheureusement, je n’avais pas assez de prise sur le mors doux, la pièce a été éjectée en cours d’usinage. Heureusement pas de blessure, mais la pièce a sérieusement reçu ! des entailles de 5mm apparaissent de chaque extrémités du cylindre. Après une heure de travail supplémentaire, au mors standard cette fois ci, temps pis pour les marques, j’ai réussi à rattraper le coups (heureusement, le côté le plus marqué était celui qui n’était pas terminé, et j’avais un surplus de matière suffisant). Au final, on voit une légère marque d’un côté, mais aucun impact sur le fonctionnement, et la marque est tout de même assez minime. J’ai eu chaud !!

Lundi  2/12 : 2h d’usinage. On continue le support du moteur au centre d’usinage. Le programme était fait, le support de bridage aussi, mais il aura fallu près de 2h pour en venir à bout. on a perdu pas mal de temps à trouver une bonne méthode pour brider la pièce. Les trous sur le côté, que je pensais faire à la perceuse à colonne ont finalement été réalisés au centre, taraudage compris : c’est assez impressionnant à voir faire !

Lundi, novembre 4 2013

Moteur Stirling Alpha… ben ça marche pas :(

Voilà, après avoir passé des dizaines et des dizaines d’heures à usiner différentes pièces, à en refaire certaines, même plusieurs fois, je dois tirer le triste constat que mon petit moteur ne marchera pas, sous sa forme actuelle.

Moteur Stirling Alpha

Moteur Stirling Alpha

En soit, c’est dommage, car comme tout projet sur lequel on passe beaucoup de temps, c’est toujours plus agréable de le voir aboutir sur quelque chose de fonctionnel. Mais d’un autre côté, les erreurs que j’ai commises m’ont bien apprises, probablement plus que si tout avais marchotté du premier coups.

J’abandonne l’idée de faire fonctionner celui-ci car un certain nombre de points de conception font qu’il ne sera pas possible de corriger certains défauts fatals, et certains paramètres nécessitent des ajustements compliqués à faire avec la version actuelle.

Moteur Stirling, vue intérieure

Moteur Stirling, vue intérieure

Voici les différentes erreurs que j’ai commises :

  • Echelle un peu trop petite, ce qui a empêché d’utiliser certaines pièces mécaniques qui auraient aidé (ex. roulements sur les bielles)
  • Trop de compression, et aucun moyen de régler celle-ci. Pour l’ajuster, il faudrait soit modifier l’angle entre les deux culasses (impossible sauf à tout refaire), soit raccourcir les bielles (vilebrequin construit pour être indémontable). Cette erreur est fatale.
  • Pas d’isolation thermique entre les culasses et le corps. Après coups, c’est vraiment stupide d’avoir oublié ça, sur un moteur basé sur la différence de température. Toujours est-il que sans cette isolation, les deux chambres finissent par se retrouver à une température trop proche pour un quelconque fonctionnement. Il s’agit là aussi d’une erreur fatale.
  • Pas de pied stable. C’est bête, mais le moteur a besoin d’être bien calé pour le lancer, et le pieds que j’avais fait à l’origine permettait une rotation du moteur autour de ce pied, ce qui était gênant pour lancer le volant d’inertie.
  • Assemblage des culasses par vissage, sur corps cylindrique : mauvaise idée. D’une part, ça complique l’assemblage, mais en plus si on vis à fond de filet, les tubes de liaisons (rigides) ne sont pas alignés.
  • Pistons en alu/culasses en laiton. Eh oui, les coefficients de dilatation n’étant pas les mêmes, ça risquait de coincer, ce que ça n’a pas manqué de faire. Bon, c’était facile à corriger, mais étant donné les autres problèmes bloquants, je ne me suis même pas embêté à le faire.

Vous l’aurez compris, je n’abandonne pas le morceau pour autant, une V2 est en cours, qui corrigera une les défauts constatés, et sera beaucoup plus modulable, de manière à corriger facilement d’autres erreurs à venir, et chercher différentes voies d’améliorations.
J’espère en tous cas que ma liste d’erreurs servira à ceux qui veulent se lancer dans l’aventure ! ;)

 

- page 1 de 3