IGBT Story !

[OrOoX]

Aller, petit sujet pour faire couler de l'encre et faire grincer des dents  


Du coup comme je suis un "récupère tout", j'avais récupéré 3 cartes inverter de clim mais j'en ai mis en kit
deux car je savais qu'elles ne me servirait pas en l'état, mais j'ai laissé "intacte" la dernière car elle ne gère
que le compresseur.

Intacte est un grand mot sachant que j'ai viré le CPU afin d'être sûr qu'il n'interfère pas avec mes plans au
moment de la mise sous tension, la carte avait été changée car la com était HS donc il était ptetre déjà cuicuit ^^


Donc déjà je me suis penché sur le fait de générer un signal 50Hz avec l'arduino sachant que la carte a besoin
que l'ont pilote les 6 mosfet de l'IGBT soit même, il y a pas mal d'exemple et codes sur la toile mais comme la plus
part n'était soit pas à jour, soit incompatible ou encore incompréhensible pour mon ptit cerveau et bah je me suis
fait ma propre version "simpliste" en me basant sur ce qui existe.


Du coup en terme de code ça donne ça, BiduleOhm va surement vomir mais bon  

Code :

int PinPos = 5;
int PinNeg = 11;

int i = 0;
int top_sinus = 0; // Détection niveau haut sinus
int low_sinus = 0; // Détection niveau bas sinus
int switch_pola = 0; // Switch polarité sinus
int delay_time = 1000; // Délai PWM en microns / 30Hz = 30 / 50Hz = 18 / 115Hz = 7


void setup() {
  Serial.begin(9600);

  pinMode(PinPos, OUTPUT);
  pinMode(PinNeg, OUTPUT);
 
}

void loop() {

  i = 0;
  if (switch_pola == 0)
  {
   
    if (top_sinus == 0)
    {
      while (i < 255)
      {
          i++;

          switch (i) {
            case 20:
              digitalWrite(PinPos, HIGH);
            break;
            case 30:
              digitalWrite(PinPos, LOW);
            break;           
            case 60:
              digitalWrite(PinPos,HIGH);
            break;
            case 90:
              digitalWrite(PinPos, LOW);
            break;
            case 120:
              digitalWrite(PinPos, HIGH);
            break;
            case 170:
              digitalWrite(PinPos, LOW);
            break;
            case 200:
              digitalWrite(PinPos, HIGH);
            break;
          }
         
          if (i == 255)
          {
            top_sinus = 1;
          }
          else {
            delayMicroseconds(delay_time);
          }
      }
    }
   
    if (top_sinus == 1)
    {
      while (i > 0)
      {
          i--;

          switch (i) {
            case 200:
              digitalWrite(PinPos, LOW);
            break;
            case 170:
              digitalWrite(PinPos, HIGH);
            break;
            case 120:
              digitalWrite(PinPos, LOW);
            break;
            case 90:
              digitalWrite(PinPos, HIGH);
            break;
            case 60:
              digitalWrite(PinPos, LOW);
            break;
            case 30:
              digitalWrite(PinPos, HIGH);
            break;
            case 20:
              digitalWrite(PinPos, LOW);
            break;
          }
         
          if (i == 0)
          {
            top_sinus = 0;
            switch_pola = 1;
          }
          else {
            delayMicroseconds(delay_time);
          }
      }
    }
  }
 
  else
  {
    if (low_sinus == 0)
    {
      while (i < 255)
      {
          i++;
         
          switch (i) {
            case 20:
              digitalWrite(PinNeg, HIGH);
            break;
            case 30:
              digitalWrite(PinNeg, LOW);
            break;           
            case 60:
              digitalWrite(PinNeg,HIGH);
            break;
            case 90:
              digitalWrite(PinNeg, LOW);
            break;
            case 120:
              digitalWrite(PinNeg, HIGH);
            break;
            case 170:
              digitalWrite(PinNeg, LOW);
            break;
            case 200:
              digitalWrite(PinNeg, HIGH);
            break;
          }
         
          if (i == 255)
          {
            low_sinus = 1;
          }
         
          delayMicroseconds(delay_time);
      }
    }
   
    if (low_sinus == 1)
    {
      while (i > 0)
      {
          i--;
         
          switch (i) {
            case 200:
              digitalWrite(PinNeg, LOW);
            break;
            case 170:
              digitalWrite(PinNeg, HIGH);
            break;
            case 120:
              digitalWrite(PinNeg, LOW);
            break;
            case 90:
              digitalWrite(PinNeg, HIGH);
            break;
            case 60:
              digitalWrite(PinNeg, LOW);
            break;
            case 30:
              digitalWrite(PinNeg, HIGH);
            break;
            case 20:
              digitalWrite(PinNeg, LOW);
            break;
          }
         
          if (i == 0)
          {
            low_sinus = 0;
            switch_pola = 0;
          }
 
          delayMicroseconds(delay_time);
      }
    }
  }
}

Ce code a l'avantage de fonctionner à basse comme haute fréquence en gardant des signaux propres contrairement à mes premiers essais,
j'ai par exemple descendu jusqu'à ~200Hz réel pour 1.4Khz enregistré à l'oscillo sur le PWM.

Faut que je vois pour l'optimiser avec des fonctions afin d'éviter les copier coller même si ça dérange pas spécialement.

Le code est "bloquant" avec les delay mais comme ça ne doit gérer que la fréquence du PWM c'est pas un soucis, en plus c'est vraiment
des micro tempo pour le coup ... Et en sortie ça donne ça


  ADS00002.jpg (Taille : 307.39 Ko / Téléchargements : 4)

Et avec deux LED et PN2222 pour simuler l'alternance :


  20200501_174237.jpg (Taille : 410.18 Ko / Téléchargements : 5)

Y'en a qui va me dire "Mais attends, tu nous parle de 6 mosfet et t'as que 2 signaux !", et bah ouais c'est le problème du code pour l'instant
il n'est pas capable de générer les 3 phases en même temps et sans utiliser la fonction analogWrite() ça risque d'être coton !
( Surtout sans faire du copier coller )



Ce sujet évoqué passons à l'électronique de puissance, comme je suis une bille et fainéant je vais donc utiliser la carte toute prête
dépouillé de son CPU pour la piloter directement.

Toutefois et pour ne pas changer les bonnes habitudes, je ne connais pas la référence de l'IGBT, il est en effet soudé et la référence prise
en sandwich entre celui-ci et le PCB et c'est une vrai merde à déssouder ...

Cependant je mise sur la chance de la série et vais donc partir sur le principe que c'est le même que les deux autres carte sachant que le
relai principal est un 20A et que l'IGBT a une intensité max de 25A !

Soit un PS22056 de chez Mitsubishi : https://www.mitsubishielectric-mesh.com/...2056_e.pdf

Je note cependant un problème, je ne distingue pas beaucoup d'info à part la fréquence max de 15Khz concernant le PWM ...


Et donc la carte :


  20200501_184531.jpg (Taille : 689.63 Ko / Téléchargements : 6)

A noter :
- Le gros bloc noir en bas à gauche est un relai qui coupe que 2 phases sur 3
- Au dessus un petit relai noir qui semble connecter le - des condos au neutre ( via une grosse résistance )
- L'alimentation 230V de la carte dont il faut absolument respecter la polarité sous peine d'envoyer la phase sur le - des condo
- 4 condos 850µF 400V branché en série ( 2 x 2 ) pour supporter la tension redressé du tri 400V

Il y a différents régulateurs de tension en 5, 12, 15 et 18V, dont une partie est alimenté directement par le transfo et dont
une des pistes possèdes à chaque fois une diode pour ne garder que la polarité positive visiblement ( redressage sauvage haha )


Et puis voilà pour l'instant, on verra demain si je me motive à brancher le 230V dans le bon sens

[neob]

Pense à filmer l'incendie

[OrOoX]

Pitetre que oui, Pitetre que non

[Kissagogo27]

un signal, des signals, c'est connu quoi ^^

[OrOoX]

Kissa Kissa ... T'es en forme dernièrement

[BiduleOhm]

T'as entendu parler des tableaux ? parce que ça t'éviterait tout le bazar des if et switch case et diviserait la longueur du code par 10...

Et accessoirement il règlerait aussi la moitié du pb d'avoir plusieurs phases (un seul et même tableau mais 3 indexs et tu en décales deux pour créer un déphasage de 120° entre chaque phase). L'autre moitié du pb est réglée en utilisant du code non bloquant...

Et accessoirement² ça faciliterait beaucoup l'indépendance entre l'amplitude, la fréquence du 50 Hz et la fréquence du PWM.

Perso je parie sur l'IGBT bien rôti après quelques secondes...

[OrOoX]

Ah voilà ce bon vieux râleur ! Tu t'es retenu avoue


Oui je connais les tableaux bien que je m'en soit jamais servi sur arduino jusqu'à présent, juste en php, certains codes de PWM l'utilisais
mais c'était couplé avec des modifications de timer avec les registres et autres et je comprenais nada ...

Une des versions que j'ai faite utilisait justement la fonction analogWrite() et des tempos non bloquante et j'avais également pensé à décaler
les valeurs comme tu l'indique mais pour une raison que j'ignore le résultat était catastrophique suivant les plages, par exemple à 60Hz le signal
était très propre mais plus je descendais et plus ça bouffait des trames, pourtant le code était pas bloquant ...


Et oui pour l'instant ce code ne peut gérer que la fréquence de sortie et non l'amplitude à cause des digitalWrite() mais pas bien compliqué
à changer, mais complètement bloquant pour démarrer un compresseur, l'IGBT va pas aimer taper du 200V / 10Hz

Après l'avantage d'une carte comme ça c'est que tu en fait ce que tu veux, aussi bien un vario à sortie mono / tri ou un onduleur mastoc.

[OrOoX]

Petite optimisation du code en cours, je m'étais penché dessus hier mais j'ai passé mon aprème
à rager, quand tu bosse pas dans de bonne condition tu fais d'la merde

Du coup ça donne ça pour l'instant :

Code :

// Attributions des pins PWM
int PinPosPh1 = 3; // Timer 2
int PinNegPh1 = 11; // Timer 2
int PinPosPh2 = 5; // Timer 0
int PinNegPh2 = 6; // Timer 0
int PinPosPh3 = 9; // Timer 1
int PinNegPh3 = 10; // Timer 1

int compteur = 0; // Compteur tableau "timing"
int switch_pola = 0; // Switch polarité sinus
int delay_timer = 5000; // Délai PWM en microns / 30Hz = 30 / 50Hz = 18 / 115Hz = 7
long unsigned timer_1 = 0;
float load_pwm = 1.0; // Facteur modulation valeur PWM

int timing_1[] = {0, 20, 60, 120, 160, 220, 255, 220, 160, 120, 60, 20, 0};
int timing_2[] = {120, 160, 220, 255, 220, 160, 120, 60, 20, 0, 0, 20, 60};
int timing_3[] = {220, 255, 220, 160, 120, 60, 20, 0, 0, 20, 60, 120, 160};

void setup() {
  //Serial.begin(9600);

  // Forçage à 0 sorties PWM
  char PinPWM[] = {'PinPosPh1', 'PinPosPh2', 'PinPosPh3', 'PinNegPh1', 'PinNegPh2', 'PinNegPh3'};
  for (int i = 0; i < 6; i++) {
    pinMode(PinPWM[i], OUTPUT);
    analogWrite(PinPWM[i], 0);
  }

  //TCCR0B = TCCR0B & 0b11111000 | 0x01; //Timer 0 (PWM pins 5 & 6)
  //TCCR1B = TCCR1B & 0b11111000 | 0x01; //Timer 1 (PWM pins 9 & 10)
  //TCCR2B = TCCR2B & 0b11111000 | 0x01; //Timer 2 (PWM pins 3 & 11)
}

void loop() {

  if (micros() >= timer_1)
  {
    int val_ph1 = timing_1[compteur] * load_pwm;
    //int val_ph2 = timing_2[compteur] * load_pwm;
    //int val_ph3 = timing_3[compteur] * load_pwm;

    switch(switch_pola) {
      case 0:
        analogWrite(PinPosPh1, val_ph1);
        //analogWrite(PinPosPh2, val_ph2);
        //analogWrite(PinPosPh3, val_ph3);
      break;
      case 1:
        analogWrite(PinNegPh1, val_ph1);
        //analogWrite(PinNegPh2, val_ph2);
        //analogWrite(PinNegPh3, val_ph3);
      break;
    }
       
    timer_1 = micros() + delay_timer;
    compteur++;
  }

  if (compteur == 13)
  {
    compteur = 0;

    switch(switch_pola) {
      case 0:
        switch_pola = 1;
      break;
      case 1:
        switch_pola = 0;
      break;
    }
  }
}

En soit ça marche pas mal mais l'utilisation de la tempo non bloquante me multiplie les trames et je vois pas trop comment supprimer
ce problème, plus je descend en fréquence et plus le problème est présent.

Ca m'oblige également à modifier les timer pour compenser le problème vu que ça fait monter le bouzin en fréquence ...


Si vous avez une idée 

Edit : Essai fait avec un delayMicroseconds() et même problème, d'un côté s'en ai pas un mais je trouve ça dérangeant perso ... x)

[BiduleOhm]

Si je devais deviner ce qu'il te faut c'est une fonction (ou idéalement une macro pour les perfs) pour passer de la valeur PWM à la valeur du timer étant donné qu'ils sont inversement proportionnels.

Et pourquoi 3 tableaux ? tu peux utiliser le même, t'as juste à rajouter un offset sur l'index de 2 des phases pour créer le déphasage.

Sinon c'est déjà beaucoup mieux en terme de propreté.

Tu peux le poster sur pastebin avec la coloration syntaxique du C ? parce que là debug en noir et blanc avec seulement 10 lignes affichées à la fois ça va pas le faire...

NB: je vois déjà que ça

Code :

switch(switch_pola) {
      case 0:
        switch_pola = 1;
      break;
      case 1:
        switch_pola = 0;
      break;
    }

Peut être remplacé par ça:

Code :

switch_pola = !switch_pola;

Et remplacer le premier switch(switch_pola) {...} par un simple if/else if(switch_pola) {...} histoire d'être sûr que çça marche et d'économiser des lignes en plus...

[OrOoX]

Je comprend pas comment tu veux faire la relation entre le pwm et le timer comme la valeur du pwm dépend de l'emplacement dans la trame
et que le timer est lié à la fréquence, donc théoriquement le timer est une valeur fixe à une fréquence fixe.

C'est justement le point au quel j'ai fait attention, ne pas modifier la période en modifiant l'amplitude avec le coef.


3 tableaux, une question de flemme pour les essais, je rectifie au fur et à mesure que ça fonctionne, au moins je suis sûr que ça
vient pas d'une mauvaise écrire de variable ou autre
( EDIT : Ah j'avais pas compris le coup de l'offset, c'est pas con mais incompatible avec mon compteur en l'état ^^ )


Pour Pastbin ouais c'est faisable, apparemment y'a moyen de le rajouter dans le MyCode, je regarde ça après.


Whoua la fonction raccourcie à mort pour le switch_pola, nice ! Et pour le deuxième, c'est ce que j'avais fait au début, j'ai voulu harmoniser  


Edit : balise Pastebin rajoutée

Code :

[pastebin]URL HTTPS[/pastebin]

[BiduleOhm]

Parce que tout est en dur dans ton code, faut vraiment que t'apprennes à faire du code plus flexible. Par ex là si tu veux changer la résolution du PWM ben faut changer la moitié du code à la main au ieu d'avoir juste à changer le tableau et une constante contenant la longueur du tableau.

Pourquoi 13 cases et non pas 12 pour le tableau ? parce que là 13 est divisble par quedal donc pour avoir 120° de déphasage tu vas galérer... et accessoirement ton sinus est pas vraiment un sinus à cause de ça.

Si si, c'est compatible, bon évidement le tableau de 13 arrange pas les choses, en supposant que tu passes à un tableau de 12 c'est très simple, ça:

Code :

int val_ph1 = timing_1[0][compteur] * load_pwm;
int val_ph2 = timing_1[1][compteur] * load_pwm;
int val_ph3 = timing_1[2][compteur] * load_pwm;

devient ça:

Code :

    byte arrayLength = 12;

Code :

int val_ph1 = timing_1[compteur] * load_pwm;
int val_ph2 = timing_1[(compteur + (arrayLength / 3)) % arrayLength] * load_pwm;
int val_ph3 = timing_1[(compteur + (2 * (arrayLength / 3))) % arrayLength] * load_pwm;

Et evidemment le triple tableau devient un tableau simple de 12 cases. Si tu veux opti un poil tu peux précalculer une seule fois (arrayLength / 3) et (2 * (arrayLength / 3)) avant loop() et tu les stockes dans deux constantes genre arrayLengthOneThird et arrayLengthTwoThird. Les modulos doivent être calculés à la volée vu qu'ils empêchent d'overflow donc les sors pas de la boucle.

Dans tous les cas pour être sûr que le déphasage soit de pile 120° il faut que la longueur du tableau soit un multiple de 3.

Accessoirement redéclarer les val_ph à chaque tour de boucle c'est moche et pas opti, tu devrais les déclarer en dehors de loop().

Enfin, tu devrais forcer les Pin...Ph complémentaires à 0 dans le if/else parce que là ils gardent juste la dernière valeur connue au changement de demi-alternance donc c'est moyen.

Concernant le timer vu que tu utilises analogueWrite ça simplifie 2-3 trucs (mais attention aux effets de bords de mélanger ton code avec le PWM de analogueWrite, t'as intérêt à vérifier à l'oscillo que le signal est correct, surtout si tu augmentes la fréquence parce qu'à un moment donné ça va aliaser...).

La valeur du timer est simplement liée à la longueur du tableau et la fréquence voulue et peut être calculée dès le départ avec un truc du genre: unsigned long timerDelay = (1000000 / freq) / (2 * arrayLength); avec byte freq = 50; pour 50Hz par ex. (nb: le timer est en µs).

Par ailleurs je remplacerais if (compteur == 13) par if (compteur >= 13) et vu que t'as censé avoir la constante tu devrais même utiliser if (compteur >= arrayLength). >= évite d'avoir le compteur qui par en cacahuète si jamais il saute le 13 (par ex à cause d'une erreur dans le code suite à une modif, ou même glitch de l'arduino, ça c'est déjà vu sur PC alors un arduino dans un milieu pollué d'IEM j'imagine pas...).

[OrOoX]

Merci pour ce gros pavé dans ma face  


Quand tu parle de changer la résolution, tu parle de modifier la grandeur d'impulsion ( 0 ... 255 ) ? Si oui dans mon cas c'est
la valeur load_pwm qui permet de la réduire, c'est barbare mais ça semble fonctionner sur les LED


Pour les 13 cases c'est pour avoir le 0 à la fin et donc supprimer le problème que tu évoque par la suite pour les sorties
qui gardent la dernière valeur en mémoire, je n'ai donc pas ce problème.


Top le code par contre je t'avoue ne pas tout comprendre, j'avais vu un truc similaire dans un des codes trouver sur le net
mais par exemple à quoi sert le % qui se promène ?

Je l'ai essayé après avoir mis à jours le tableau pour une ligne unique + 12 valeurs, il fonctionne mais je constate
sur la phase 2 et 3 une double alternances, elles ne font pas 0 ... 255 ... 0, voici dessous :


  20200503_184743.jpg (Taille : 554.3 Ko / Téléchargements : 0)

J'avais continué de travailler de mon côté sur ce point aussi après m'être rendu compte que l'alternance par phases n'existait pas et
j'en suis arrivé à une solution beaucoup moins optimisé que toi mais fonctionnelle :

Pour les autres points je vais travailler dessus mais par exemple la modification de la fréquence je comptais passer un par map() liée
à une entrée analogique en ayant repéré à l'avance les bonnes tempos entre 30 et 115Hz.

[BiduleOhm]

Non, je parle d'augmenter le nombre de cases du tableau pour avoir une approximation du sinus plus fine.

Ah, ben c'est super bof comme solution, et ça va t'empêcher d'avoir 120° entre les phases. Si tu veux vraiment garder cette solution alors retire une valeur pour avoir 12 cases (ou rajoutes-en 2 pour en avoir 15).

Attends tu codes sans savoir ce qu'est un modulo ? https://fr.wikipedia.org/wiki/Modulo_(op%C3%A9ration) en très raccourci il sort le reste d'une division entière; par exemple 7 % 3 == 1 Ici je l'utilise pour borner l'index entre 0 et la taille maximum du tableau, c'est un peu comme si je transformais le tableau en tableau circulaire, si jamais l'index dépasse il repart du début. C'est une application très courante du modulo, ptet bien la plus courante d'ailleurs.

J'ai pas vérifié mais si je devais deviner je dirais que tu t'es planté sur les offsets et/ou les conditions de tes compteurs et que donc tu pars en dehors du tableau. Et t'as pas besoin de doubler le tableau en longueur, ça sert à rien vu que les demi alternances sont les même.

[OrOoX]

Ah oki, de toute façon je pense que je vais devoir y passer à l'augmentation du nombre de valeurs si je veux avoir un truc propre.


Yeap je sais que c'est bof et c'est surement ce qui me cause des problèmes de phases et autres mais c'est la solution que j'avais trouvé sur le
coup pour que ça marche, après faut peaufiner tout ça, tu peux pas avoir ton code définitif dès le premier coup

Et oui je ne connaissais pas cette fonction, c'est la grande différence entre nous deux, moi je code uniquement pour le fun, pas pour le boulot
ou autres contrairement à toi et on a clairement pas les mêmes compétences dans ce domaine.

Et du coup ça explique surement le problème de double alternance, tu dis qu'elle repart de zéro si elle dépasse la valeur max, du coup si t'applique
un offset pour ces deux phases ça va forcément arriver et donc ne pas faire le tour complet nan ?


Edit : Zarb cette fonction modulo xD

[Kissagogo27]

heu blabla la doc c'est pas que pour les pros :p et le modulo on apprend a l'école

[BiduleOhm]

Ben en fait si, à 2-3 détails près tu peux avoir du code quasi correct du premier coup. Je t'ai déjà dit y'a longtemps, faire du code foireux et essayer de l'améliorer ensuite c'est pas une bonne idée, c'est comme faire de mauvaises fondations pour une maison et de vouloir les améliorer une fois la maison finie...

C'est pas une question pro/pas pro, le modulo je le connais depuis que j'ai commencé à coder quand j'étais encore au collège et j'étais loin de coder pour un job...

Non, il repart de zéro mais continu, comme un lorsqu'une variable overflow; 10 % 12 == 10, 11 % 12 == 11, 12 % 12 == 0, 13 % 12 == 1, 14 % 12 == 2, ...

[OrOoX]

Ah bah whai mai moi pré-apentissage a 15 an, moi dés bile, pa avoir fai ma 3 ième ! alor les mats
( Clin d'oeil à Sk' qui passait son temps à reprendre mes fautes )

Ok je sors, mais mon niveau en math & co, ahem ... Rattrapage, tout ça ( et franchement osef, je gagne plus qu'un bac+x qui bosse à macdo )


J'adopte aussi cette mentalité de faire bien dès le début mais entre des fondations en béton et un code que tu peux retaper disons que le niveau
d'élitisme n'est pas le même, les incidences non plus, si c'était pour un client je ne tiendrais pas le même discours.

C'est comme si je disais à un des miens "Oh bah c'est pas grave la fuite, tfaçon ça arrivera un jour ou l'autre".

Par contre le coup du modulo je comprend pas vraiment le délire, on dirait une soustraction inversée limite

[BiduleOhm]

Comme tu veux, mais sache que tu te compliques la vie et que tu perds du temps avec cette méthode.

Euh... tu sais ce qu'est une division ? tu sais ce qu'est un reste lors d'une division ? ben le modulo permet de calculer le reste. C'est pourtant pas compliqué (niveau primaire là quand même... )

[OrOoX]

Je suis née pour avoir une vie compliqué, j'y peux rien


Et oui je connais les calculs de bases, je suis pas demeuré à ce point non plus mais non à part les restes dans l'assiette je sais pas et
j'ai pas souvenir de l'avoir appris un jour d'ailleurs, faut dire que l'école c'était pas mon truc depuis le début ...

Enfin bref, on va pas débattre de mon cursus scolaire c'est pas le sujet

[OrOoX]

Bon bah du coup je m'y suis remis et j'ai un truc "potable" mais avec des problèmes haha, donc déjà tableau 15 valeurs comme
évoqué comme ça j'ai mon 0 de début et fin, j'ai également crée le déphasage de façon temporelle au lancement de la boucle,
je suis pas sur du déphasage car là c'est un peu du pifomètre vu que dès que j'utilise la com série ça décale tout ...

Un autre problème viens des timers, j'ai deux phases qui pulses à 12Khz ( Timer 1 et 2 ) et ~3Khz pour le Timer 0 et comme c'est
pas les mêmes diviseurs je pense que faire du tri avec une Uno n'est pas possible, doit falloir une méga.

Faut également que je fasse une fonction pour éviter le copier coller des 3 phases.