Projet Onduleur Triphasé #3: Commande Décalée

Objectifs

Savoir implémenter la commande décalée (deux techniques)
Savoir le schéma d’un onduleur triphasé
Savoir les caractéristiques d’un onduleur
Savoir choisir les transistors de la partie puissance
Savoir commander un onduleur triphasé
Savoir implémenter la commande d’un onduleur triphasé
Savoir augmenter les performances de son code & améliorer la fréquence maximale de l’onduleur
Etc.

Applications

Alimentation AC à partir d’une source DC (Alimentation à panneaux solaires, batteries, etc.)
Conversion de réseaux : Monophasé vers triphasé, monophasé vers un réseau polyphasé, etc.
Convertisseur de fréquence d’un réseau 50 Hz vers 60 Hz, 50 Hz vers 400 Hz, etc.
Variateur de vitesse des machines asynchrones
Etc.

Fonctionnement

Avant d’entamer la suite, veuillez consulter la partie Une et Deux du projet pour mieux comprendre le concept de la commande.

On reprend les chronogrammes de la commande symétrique abordée dans la section précédente dont chaque transistor est activé une demi période (3*60=180°). Pour la commande symétrique, les transistors dans un bras sont complémentaires. Durant la transition, on se retrouve avec deux transistors actifs en même temps. Ce mode de fonctionnement induit un micro-court-circuit de la source (batterie, alimentation DC, etc.). Par conséquent, dans le cas d’une batterie, on chauffe, réduit l’autonomie ainsi la durée de vie de la batterie, d’où l’importance de la commande décalée. Elle permet d’ajouter un déphasage à l’ouverture ou à la fermeture des transistors de telle manière à ne jamais avoir deux actifs en même temps.

Les signaux de la commande d’un bras ne sont pas complémentaires !

Les chronogrammes ci-dessous montrent la conversion de la commande symétrique vers la commande décalée des transistors T1 et T2 en utilisant un déphasage fixe de 30° (1/12 de la période). On constate a remise à zéros du T1 et T2 au début et à la fin de mi-période.

L’utilisation d’un déphasage de 30° (π/6) permet de supprimer l’harmonique 3.

Le codage de la commande symétrique nécessite 6 séquences par période (360/60 = 6). En revanche, la commande décalée, dans le cas d’un déphasage de 30°, on aura besoin de 12 séquences par période. Le tableau ci-dessous montre les 12 états des transistors T1 et T2. On constate que T1 (ou T2) est actif seulement pendant 4 cycles de 30° (4*30=120) qui correspond à 1/3 (1/2 période dans le cas de la commande symétrique). Par contre, avant la transition de T1 (ou T2), les deux transitons sont positionnés à zéros durant deux cycles !

Voir le tuto pour en savoir plus sur le codage de T3 à T6.

Cours onduleur triphasé

Voir les cours ci-dessous pour plus de détails théoriques concernant le fonctionnement ainsi les chronogrammes des tensions de l’onduleur.

Programme Arduino

La fonction SetCMD3()

La fonction permet de faire le codage séquentiel des 12 états des six transistors.

void SetCMD3( int *pins)
{
  static unsigned char I=0;  
  const bool Cmd[12][6]={
                        {0,1,1,0,0,0},
                        {0,0,1,0,0,1}, 
                        {0,0,1,0,0,1}, 
                        {1,0,0,0,0,1}, 
                        {1,0,0,0,0,1},
                        {1,0,0,1,0,0},
                        {1,0,0,1,0,0}, 
                        {0,0,0,1,1,0}, 
                        {0,0,0,1,1,0}, 
                        {0,1,0,0,1,0},
                        {0,1,0,0,1,0},
                        {0,1,1,0,0,0}, 
                        };
                        
  for (int i=0;i<6; i++) digitalWrite(pins[i], Cmd[I][i]); 
  I++; 
  if (I>=12)I=0;

  return 0; 
}

La fonction SetCMD4()

La fonction permet de faire le codage parallèle (plus rapide) des 12 états des six transistors.

void SetCMD4( int *pins)
{
  static unsigned char I=0;  
  const unsigned char Cmd[12]= {
                               B00011000,
                               B00001001, 
                               B00001001, 
                               B00100001, 
                               B00100001,
                               B00100100,
                               B00100100, 
                               B00000110, 
                               B00000110, 
                               B00010010,
                               B00010010,
                               B00011000
                               };

  PORTA=Cmd[I];
  I++; 
  if (I>=12)I=0;

  return 0; 
}

Programme complet

#define Tr11            22         // Transistor 1/Bras 1 
#define Tr12            23         // Transistor 2/Bras 1 
#define Tr21            24         // Transistor 1/Bras 2 
#define Tr22            25         // Transistor 2/Bras 2 
#define Tr31            26         // Transistor 1/Bras 3 
#define Tr32            27         // Transistor 2/Bras 3 

#define T0_us           333       // Période de l'onduleur (Symétrique) : T=6*T0 (µs)     
                                  // Période de l'onduleur (Décalée)    : T=12*T0 (µs)
                                   
int Trans[6];

void setup() 
{
  // Pinout 
  Trans[0]=Tr11; Trans[1]=Tr12;
  Trans[2]=Tr21; Trans[3]=Tr22;
  Trans[4]=Tr31; Trans[5]=Tr32;
  
  for (int i=0;i<6; i++) 
  {
    pinMode(Trans[i], OUTPUT);
    digitalWrite(Trans[i], LOW); 
  }
  // Ou bien: Init du port A en sortie 
  //DDRA =0xff; PORTA=0x00;

  Serial.begin(9600); 
}

void loop() 
{
  SetCMD4(Trans);
  //delayMicroseconds(T0_us); 
}







void SetCMD1( int *pins)
{
  static int I=0; 
  const bool Cmd[6][6]={{0,1,1,0,0,1}, 
                        {1,0,1,0,0,1}, 
                        {1,0,0,1,0,1},
                        {1,0,0,1,1,0}, 
                        {0,1,0,1,1,0}, 
                        {0,1,1,0,1,0}};
                        
  for (int i=0;i<6; i++) digitalWrite(pins[i], Cmd[I][i]); 
  I++; I%=6; 

  return 0; 
}





void SetCMD2( int *pins)
{
  static unsigned char I=0;  
  const unsigned char Cmd[6]={B00011001, 
                              B00101001, 
                              B00100101,
                              B00100110, 
                              B00010110, 
                              B00011010};

  PORTA=Cmd[I];
  I++; 
  
  //I%=6;             // Fréquence: + 
  //I=I*(I<6);        // Fréquence: ++
  if (I>=6)I=0;       // Fréquence: +++
  
  return 0; 
}



void SetCMD3( int *pins)
{
  static unsigned char I=0;  
  const bool Cmd[12][6]={
                        {0,1,1,0,0,0},
                        {0,0,1,0,0,1}, 
                        {0,0,1,0,0,1}, 
                        {1,0,0,0,0,1}, 
                        {1,0,0,0,0,1},
                        {1,0,0,1,0,0},
                        {1,0,0,1,0,0}, 
                        {0,0,0,1,1,0}, 
                        {0,0,0,1,1,0}, 
                        {0,1,0,0,1,0},
                        {0,1,0,0,1,0},
                        {0,1,1,0,0,0}, 
                        };
                        
  for (int i=0;i<6; i++) digitalWrite(pins[i], Cmd[I][i]); 
  I++; 
  if (I>=12)I=0;

  return 0; 
}


void SetCMD4( int *pins)
{
  static unsigned char I=0;  
  const unsigned char Cmd[12]= {
                               B00011000,
                               B00001001, 
                               B00001001, 
                               B00100001, 
                               B00100001,
                               B00100100,
                               B00100100, 
                               B00000110, 
                               B00000110, 
                               B00010010,
                               B00010010,
                               B00011000
                               };

  PORTA=Cmd[I];
  I++; 
  if (I>=12)I=0;

  return 0; 
}

On verra dans le prochain tuto la commande MLI (PWM) d’un onduleur triphasé. N’oublie pas un commentaire pour nous encourager et contribuer au développement du blog.