Mot-clé - théorie

Fil des billets - Fil des commentaires

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

Mercredi, septembre 25 2013

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…

Jeudi, avril 25 2013

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.

 

Mardi, avril 23 2013

Capteur optique de vitesse et sens de rotation (1)

Bonjour à tous. Aujourd’hui, je ne suis là que pour ce petit édito, car j’ai le plaisir d’accueillir mon premier invité sur ce blog, à savoir Philippe, qui va vous présenter un sujet très bien documenté, et qui j’en suis sûr vous sera utile !

Hello, voici mon premier article dans l’esprit « DIY », soyez indulgents svp  ;-)

Merci aussi à Eric de me prêter une petite place dans son blog :-)

Dans le cadre de la fabrication d’un système mécanique à plusieurs arbres (un train épicycloïdal pour être précis), j’avais besoin de mesurer les vitesses de rotation de chacun d’eux… en fait la vitesse ET le sens de rotation. N’ayant pas trouvé ailleurs de système équivalent à celui que j’ai mis au point, je me dis que cela vaut le coup de partager cette idée avec les bricoleurs intéressés.

  1. Première partie : du besoin à l’idée.

Parmi les capteurs de vitesse (souvent capteurs de mouvement incrémentaux pour ce type de mesure) on trouve diverses techniques, parmi lesquelles des technologies magnétiques (sur certains compteurs de vitesse pour vélos par exemple) ou des solutions optiques sur lesquelles nous allons nous concentrer dans la suite.

Une solution simple pour construire un capteur de vitesse est d’utiliser une fourche optique (LED d’un côté + photo-transistor de l’autre) dans laquelle on fait passer un disque ajouré. Avec une fourche simple de ce type, connectée sur une entrée numérique d’un microcontrôleur, il est possible de compter un nombre d’impulsions par seconde et donc une vitesse de rotation en fonction du nombre de rainures disposées sur le disque codeur. J’ai donc commencé par effectuer quelques tests sur la base d’un cadran translucide de bouton de potentiomètre sur lequel j’ai collé des adhésifs radialement pour simuler des rainures radiales (photo 1). Une petite fourche et son électronique d’alimentation (récupérée sur un capteur de fin de course de Reprap, merci Pierrot), et me voici à mesurer la vitesse d’un petit moto-réducteur DC en comptant les interruptions sur une carte Arduino UNO. Petit gag (mais ça marche très bien quand même) : j’ai bien placé mon adhésif sur les 10 chiffres noirs du cadran de potentiomètre, mais l’adhésif n’est pas complètement opaque, et on voit donc passer sur l’oscillo les chiffres qui masquent le faisceau lumineux  plus efficacement que le scotch orange !

Photo 1 :

Codeur optique

Codeur optique – premier test

Il est aussi possible avec cette technologie de déterminer le sens de rotation… à condition d’ajouter un 2e photo-transistor judicieusement placé à côté du premier. Le signal optique reçu par le 2e transistor étant décalé temporellement par rapport au premier, on obtient des signaux en quadrature dont le sens de déphasage permet de déterminer le sens de rotation. Voir l’excellent site de « Rémy Sonelec » pour plus d’explications sur ce type de codeur :

http://www.sonelec-musique.com/electronique_theorie_encodeur_optique.html

Et sachez que la plupart d’entre vous (sauf peut-être les plus jeunes) ont utilisé pendant des heures ce genre de capteur, puisqu’il a équipé la grande majorité des souris à boules pendant des années (Photo 2).

Photo 2 :

Souris a boule : 2 photo-transistors

Souris a boule : 2 photo-transistors

(source : http://fr.wikiversity.org/wiki/Capteur/Capteur_de_position )

Inconvénient de cette technique à deux transistors : il faut doubler le nombre de photo-transistors (eh oui). En outre, plus il y a de capteurs = plus il y a d’entrées utilisées sur le micro-contrôleur… Or je prévoyais pour mon application de mesurer les vitesses de 3 moteurs, de piloter un afficheur LCD, ainsi que quelques autres éléments consommateurs de ports… incompatible avec l’Arduino UNO L. D’où la recherche d’une solution nécessitant un seul photo-transistor pour avoir la vitesse ET le sens de rotation d’un codeur optique… Comment faire ?? Eh bien appliquer ce que l’on enseigne aux élèves ingénieurs concepteurs de produits innovants : la méthode TRIZ ! Pour ceux qui ne connaissent pas voici un point de départ : http://www.triz40.com

Au-delà des 40 principes et des matrices de contradiction, TRIZ est aussi un état d’esprit, une manière de réfléchir. J’avoue donc que je n’ai pas passé en revue tous les tableaux fournis dans la méthode. Je trouve intéressant d’essayer de vous expliquer le raisonnement…

Ne voulant pas me palucher tous les tableaux et principes de Triz, j’ai donc simplement essayé d’utiliser un principe de générique de la méthode : « regarder le problème autrement, à l’envers, en séparant ou regroupant des éléments, en inversant ou permutant des paramètres… ». Voici en synthèse a posteriori ce que cela peut donner :

Les capteurs à fourche existants (souris, etc.) utilisent la séparation spatiale des récepteurs, qui sont fixes (2 photo-transistors) pour générer une séparation temporelle de 2 signaux. Mais je ne veux pas utiliser 2 récepteurs différents : contradiction. Que pourrait-on inverser ou permuter dans ce schéma, que pourrait-on regarder autrement ? Utiliser une « séparation temporelle » plutôt que spatiale ? Cela voudrait dire quoi ?… 

Ne pas travailler du côté du récepteur, mais du côté de l’émetteur ? Mais l’émetteur, c’est quoi ? La LED qui est émet la lumière ? Non, ce n’est pas elle qui génère le signal proportionnel à la vitesse de rotation : c’est la roue rainurée. à La roue pourrait-elle générer une variation temporelle du signal ? Ca voudrait dire des signaux irréguliers ? Bof, que pourrais-je en déduire ? Ou des signaux réguliers mais de durées différentes ? Et alors ? Poursuivons quand même : peut-être donc si je ne faisais pas des rainures toutes identiques… une large, une étroite,  une large, une étroite ? Les durées de 2 créneaux successifs seraient différentes. On revient à une décomposition spatiale (variation de largeur des rainures) pour générer une séparation temporelle, mais cette fois sur la roue au lieu du transistor. Non cela ne marche pas, j’aurai une alternance de signaux court-long-court-long quel que soit le sens de rotation. Aucun intérêt… ne jamais abandonner J … poursuivons… si 2 largeurs de rainures ne suffisent pas, mettons-en 3 ! Oui… avec une succession de rainures de largeurs 1 ;2 ;3 ;1 ;2 ;3 ;1… qui génère des signaux de 3 durées différentes ordonnées de même, la permutation des trois valeurs deviendra « impaire » lorsque le sens de rotation va changer :  1 ;3 ;2 ;1 ;3 ;2 ;1 ;3 ;… Je crois que c’est gagné !! Il suffira de regarder dans quel ordre passent les créneaux de différentes largeurs.

Concrètement, ceci s’est traduit par quelques nuits de réflexion, et quelques « gribouillis » sur le tableau blanc des enfants…

Premier croquis

Premier croquis du codeur à sens

Dans le prochain article… la mise en oeuvre pratique.

 

 

Vendredi, novembre 9 2012

DIY – Moteur magnétohydrodynamique

Ok, le terme est un peu barbare. Mais derrière ce nom se cache un système de propulsion sympa et relativement simple à expérimenter. Wikipedia nous explique que le fonctionnement est sensiblement identique à un moteur classique, à la différence près qu’on remplace la bobine par un fluide.
Concrètement, on fait passer un courant électrique dans un fluide (par exemple de l’eau salée),  ce qui va la « polariser », elle est ensuite attirée par des aimants permanents (ou des solenoids, ça marche aussi) situés un peu plus loin. Ce type de moteur a donc pour principal avantage de n’avoir aucune pièce mobile, donc peu de maintenance et bonne furtivité (Ceux qui ont vu à la poursuite d’octobre rouge se souviennent de la fameuse chenille)
Cela dit, une image (‘fin une vidéo plutôt) valant mieux qu’un long discours, voici un petit prototype maison. Il est constitué d’un support en plastique, sur lequel j’ai collé 2 rails en aluminium. Deux aimants permanents sont collés (leur simple attraction suffit) au dessus et au dessous des rails. Chaque rail est connecté à un pôle de l’alimentation, 12v, 3A maximum (je n’ai pas mesuré la consommation pendant le fonctionnement)


media

Là où ça peut devenir vraiment intéressant, c’est que ça ne marche pas qu’avec de l’eau, mais avec tout fluide… Ce qui inclue les plasmas, et rend donc ce type de moteurs utilisables en propulsion spatiale.

Essai de MHD à plasma

Bon, sur la photo du dessus, ça se voit pas bien, il aurais mieux valu une vidéo, mais l’arc électrique est bien « soufflé » :) J’essaye maintenant de générer des plasmas un peu plus conséquents histoire d’améliorer un peu le résultat, mais j’ai pour l’instant quelques petits problèmes de puissance… (bientôt réglés grâce à Baptiste et son transfo:) )

Mercredi, avril 11 2012

DIY – Détection de passage d’un élément métallique.

Il y a des fois des montages qui paraissent simple vu de loin, mais qui, une fois mis en application se révèlent être extrêmement tordus. C’est le cas de celui-là ;)

Dans le principe pourtant, rien de sorcier : un métal en mouvement dans une bobine génère un (faible) courant, qu’il suffit d’amplifier ensuite… Mais comme le laisse deviner mon introduction, c’est le « il suffit » qui pêche…
Le signal généré par le passage de l’élément est de l’ordre de 5mv, avec un courant ridiculement bas.
- Première tentative, l’ampli op. Mon premier étage arrive  bien à amplifier le signal, mais je n’arrive pas à dépasser un certain gain (en gros 10), quel que soit les valeurs des résistances choisies  (je n’ai d’ailleurs toujours pas vraiment compris pourquoi). Quoi qu’il en soit, je décide de réamplifier le signal ainsi obtenu dans une seconde porte de l’aop, et là….. rien ! Mais alors rien de rien, mon signal qui faisait maintenant 50mv, se retrouve à 0 :(

- Quelques recherches, demandes de conseils plus tard, on me conseille d’utiliser un amplificateur de mesure. Il s’agit en fait d’un montage à base d’AOP, disposant d’une très grande impédance d’entrée, et de 2 entrées différentielles sur lesquelles brancher ma bobine. Sur le papier, ça a l’air plutôt sympa pour faire ce que je cherche à faire. Un petit détail que je n’avais cependant pas prévu (et pourtant prévisible) est venu perturber tout ça : un AOP,quand ça amplifie beaucoup, ça entre facilement en oscillation, hors là, on amplifie « énormément » ! Résultat des courses, une bobine de plusieurs milihenry « pilotée » par un oscillateur…. bah ça donne un élévateur de tension. Et vu comme ça a réussit à faire griller mon alim stabilisée, il devais être plutôt efficace.
Après avoir réparer mon alim, j’ai préféré ne pas retenter l’expérience avec cette méthode, de peur de ne pas arriver à contrôler l’oscillation et de reproduire le même résultat.

- Finalement, c’est de Fabien que viendra le résultat. Il travaillais sur un amplificateur à transistor, et a donc eu l’idée d’utiliser son montage amplificateur ici. Les premiers essais ne furent pas non plus très fructueux, on avais de la même manière de grosses difficultés à amplifier correctement le signal, avant qu’on nous fasse remarquer (merci Laurent) que notre condensateur de liaison faisait un joli filtre passe haut avec la résistance un peu plus loin…
Du coups, il a suffit d’augmenter la valeur dudit condensateur, et les choses étaient déjà beaucoup plus « logiques » !

L’objectif du montage étant de « déclencher » quelque chose (un relais, une led, etc…) au passage de notre objet, il restait encore un peu de travail. Je pensais au début attaquer directement l’entrée d’un ne555 monté en monostable, mais l’impulsion ne suffisait pas à le déclencher. Il a donc fallu rajouter un étage comparateur de tension, qui permet d’avoir une impulsion franche et nette lorsque la tension issue de la bobine dépasse une tension de référence que nous avons fixé.

Détecteur de passage d'élément métallique

Détecteur de passage d'élément métallique

Et voilà ce que ça donne à l’oscillo :

Le résultat

En jaune, la sortie de l'étage d'amplification, en bleu, la sortie du comparateur de tension