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