Onduleur pour chauffage par induction

2.a. Principe

L'onduleur pleine onde ([1]) est réalisé autour d'un hacheur en pont complet comportant 4 interrupteurs. Le signal de commande des interrupteurs est un signal carré de rapport cyclique 1/2, dont la fréquence f est comprise entre 10 et 100 kHz.

La charge est un circuit RLC série, l'inductance L étant celle de la bobine destinée au chauffage. Le condensateur est choisi pour obtenir une fréquence de résonance en courant de plusieurs dizaines de kHz, et la fréquence du signal de commande est ajustée pour être au plus proche de cette fréquence de résonance.

Lorsque le signal de commande est au niveau haut, les interrupteurs I1 et I3 sont fermés alors que I2 et I4 sont ouverts. On a alors V_A=V_s et V_B=0. Lorsque le signal de commande est au niveau bas, les interrupteurs I1 et I3 sont ouverts alors que I2 et I4 sont fermés, et on a V_A=0 et V_B=V_s. Le circuit RLC est donc soumis à une tension alternée de fréquence f.

Ce hacheur est dit à 4 quadrants car il peut à la fois inverser la tension aux bornes de la charge et le courant circulant dans la charge.

Pour limiter l'amplitude du courant dans la bobine (l'alimentation doit rester en régulation de tension), on choisi convenablement la résistance R. En pratique, cela peut conduire à une forte dissipation par effet Joule dans cette résistance, ce qui n'est pas bon en terme d'efficacité du chauffage par induction. Une autre manière de réduire le courant est de décaler légèrement la fréquence du signal par rapport à la fréquence de résonance du circuit RLC.

2.b. Résonance du circuit RLC

On s'intéresse au courant dans la bobine lorsque la tension appliquée au circuit RLC est sinusoïdale, de fréquence f :

Voici le courant en fonction de la fréquence pour les valeurs de R,L et C que nous avons utilisées :

import numpy
from matplotlib.pyplot import *

R=7.0
L=0.25e-3
C=68e-9
Us=12.0
f0=1.0/(2*numpy.pi*numpy.sqrt(L*C))
Q = 1.0/R*numpy.sqrt(L/C)
def courant(f):
    w=2*numpy.pi*f
    return Us/(R+1j*L*w+1/(1j*C*w))
freq = numpy.linspace(start=10000,stop=200000,num=1000)
I=numpy.absolute(courant(freq))
figure()
plot(freq/1000,I)
xlabel("f (kHz)")
ylabel("I (A)")
axis([0,100,0,2])
grid()
                

print(f0)
--> 38600.74360041484

print(Q)
--> 8.6619866084404631

Pour une bobine donnée, on peut bien sûr augmenter la fréquence de résonance en réduisant la valeur de C. Pour le chauffage par induction, une plus haute fréquence est plus efficace d'une part parce que la force électromotrice dans l'induit augmente (à champ égal), d'autre part parce que la résistance de l'induit augmente (à cause de l'effet de peau).

Pour avoir le maximum de courant, on doit ajuster la fréquence du signal carré de commande à la fréquence de résonance f₀. La tension V_A-V_B appliquée au circuit RLC est aussi carrée (on suppose que la source est parfaitement régulée en tension). La première harmonique est celle de rang 3, à trois fois la fréquence de résonance. Un tracé en échelle log permet de mieux voir son atténuation :

figure()
plot(freq/1000,I)
xlabel("f (kHz)")
ylabel("I (A)")
yscale('log')
grid()
                   

Sur cet exemple, l'harmonique de rang 3 est réduite d'un facteur 20 environ par rapport au fondamental, ce qui permet d'obtenir un courant quasi sinusoïdal. Pour le chauffage par induction, il n'est pas important que le courant soit parfaitement sinusoïdal, mais pour une faire une étude expérimentale du chauffage, il est préférable d'avoir une forme quasi sinusoïdale. Par ailleurs, des hautes fréquences dans le champ de la bobine apportent des perturbations électromagnétiques dans l'environnement et sont donc à éviter.

La résistance R doit être choisie pour que le courant à la résonance ne dépasse pas le courant maximal que le générateur peut fournir en mode de stabilisation en tension. Nous avons utilisé une alimentation pouvant en principe fournir jusqu'à 3 A en continu pour une tension jusqu'à 30 V. La résistance de 7 Ω permet de limiter le courant de crête à 1,7 A lorsque la tension d'alimentation est de 12 V. Pour augmenter encore ce courant, on peut augmenter la tension d'alimentation.

Cette méthode d'alimentation n'est pas très efficace en terme de conversion d'énergie, puisque la résistance R dissipe une énergie importante. La valeur efficace du courant est ici de l'ordre de 1 A, soit une puissance dissipée dans la résistance de l'ordre de 10 W.

Une autre grandeur importante est la tension aux bornes du condensateur :

def tensionC(f):
    w=2*numpy.pi*f
    return Us/(1-L*C*w*w+1j*R*C*w)
uc = numpy.absolute(tensionC(freq))
figure()
plot(freq/1000,uc)
xlabel("f (kHz)")
ylabel("Uc (V)")
axis([0,100,0,150])
grid()
                         

L'amplitude de la tension aux bornes du condensateur atteint 100 V, ce qui est une conséquence du facteur de qualité élevé. Cette valeur de tension est au dessus de la limite de sécurité de 50 V pour les tensions alternatives 50 Hz. Il s'agit cependant d'une fréquence élevée, pour laquelle les dangers ne sont pas du tout les mêmes qu'à 50 Hz et sont encore mal connus. À cette fréquence, il y a probablement moins de risque d'électrisation profonde avec atteinte cardiaque, mais le risque de brûlure est augmenté. Quoi qu'il en soit, on ne doit pas toucher le circuit pendant son fonctionnement.

En présence d'un induit dans la bobine (la pièce métallique à chauffer), le schéma électrique doit être modifié. Une première approche consiste à placer une résistance en parallèle avec l'inductance, pour représenter les pertes par effet Joule dans l'induit :

Voyons comment les courbes de résonance sont modifiées :

Rp=500.0
def courantAvecInduit(f):
    w=2*numpy.pi*f
    return Us/(R+1.0/(1.0/(1j*L*w)+1.0/Rp)+1/(1j*C*w))
freq = numpy.linspace(start=10000,stop=200000,num=1000)
I=numpy.absolute(courantAvecInduit(freq))
figure()
plot(freq/1000,I)
xlabel("f (kHz)")
ylabel("I (A)")
axis([0,100,0,2])
grid()
                          

Nous avons choisi la valeur de la résistance Rp pour que le courant à la résonance soit réduit d'un facteur deux environ.

def tensionCavecInduit(f):
    w=2*numpy.pi*f
    return Us/(1+1j*C*w*1/(1/(1j*L*w)+1/Rp)+1j*R*C*w)
uc = numpy.absolute(tensionCavecInduit(freq))
figure()
plot(freq/1000,uc)
xlabel("f (kHz)")
ylabel("Uc (V)")
axis([0,100,0,150])
grid()
                          

La baisse du facteur de qualité rend la résonance plus large (et donc le réglage de la fréquence moins difficile). De plus, la tension aux bornes du condensateur est fortement réduite.

2.c. Réalisation

On utilise le pont MOSFET L6203 (ST microelectronics), prévu en principe pour alimenter un moteur mais qui convient bien à notre usage puisque la fréquence de découpage peut aller jusqu'à 100 kHz et le courant jusqu'à 4 A.

Voici son schéma interne :

Voici le schéma du montage complet :

La bobine L, le condensateur C et la résistance R sont branchées en série entre les bornes de sortie OUT1 et OUT2 du pont. La sortie D11 de l'arduino MEGA (D9 pour un UNO ou un YUN) pilote directement l'entrée IN1 du pont, et l'entrée IN2 via une porte NON.

L'alimentation utilisée doit être stabilisée en tension. Sa tension V_s doit être d'au moins 12 V pour que le pont fonctionne correctement.

Le circuit RLC est étudié au préalable en faible courant avec un GBF, ce qui permet d'accéder à sa fréquence de résonance en courant et donc à une estimation de la valeur de L. La bobine a une résistance interne de 0,6 Ω en continu.

Nous avons utilisé une résistance de puissance R=6,8 Ω de type radiateur (résistance bobinée).

Les expériences ci-dessous ont été réalisées avec un condensateur polyester ordinaire. Celui s'échauffe notablement et nous avons causé sa déterioration en tentant de réduire la résistance pour augmenter le courant. Le condensateur est en effet soumis à de fortes tensions, de l'ordre de 100 V en l'absence d'induit, et il faut donc utiliser un type de condensateur capable de supporter une tension AC de l'ordre de fréquence 50 kHz à ce niveau de tension. Il existe des gros condensateurs à film de polypropylène métallisé adaptés à cet usage (Kemet ou Epcos par exemple).

2.d. Programme arduino

Le programme arduino est chargé de programmer la génération du signal carré (signal PWM de rapport cyclique 1/2).

#include "Arduino.h"

#define ENABLE 10

uint32_t icr;
float period_pwm;
uint16_t diviseur[6] = {0,1,8,64,256,1024};
                

La fonction suivante programme le timer1 pour qu'il génère un signal PWM. La période est un flottant en microsecondes. Le rapport cyclique est un flottant entre 0 et 1.

void init_pwm_timer1_fixe(float period, float ratio) { // rapport cyclique fixe, period en 1/100 us
      char clockBits;
    TCCR1A = 0;
    TCCR1A |= (1 << COM1A1); //Clear OCnA/OCnB/OCnC on compare match, set OCnA/OCnB/OCnC at BOTTOM (non-inverting mode)
    TCCR1A |= (1 << COM1B1);
#if defined(__AVR_ATmega2560__) || defined(__AVR_ATmega32U4__)
    TCCR1A |= (1 << COM1C1);
#endif
    TCCR1B = 1 << WGM13; // phase and frequency correct pwm mode, top = ICR1
    int d = 1;
    icr = (F_CPU/1000000*period/2);
    while ((icr>0xFFFF)&&(d<6)) { // choix du diviseur d'horloge
        d++;
        icr = (F_CPU/1000000*period/2/diviseur[d]);
   } 
   clockBits = d;
   ICR1 = icr; // valeur maximale du compteur
   OCR1A = ratio*icr;
   TCNT1 = 0; // mise à zéro du compteur
   TCCR1B |= clockBits; // déclenchement du compteur
}
                  

La fonction setup configure en sortie les bornes D10 (ENABLE) et D11 ou D9 suivant le modèle d'arduino. La période du signal de commande est choisie (en microsecondes).

void setup() {
  Serial.begin(115200);
  pinMode(ENABLE,OUTPUT);
  digitalWrite(ENABLE,LOW);
  
#if defined(__AVR_ATmega2560__)
    pinMode(11,OUTPUT); // sortie PWM pour MEGA
#else
    pinMode(9,OUTPUT); // sortie PWM pour UNO
#endif
    period_pwm = 31.0; // en microsecondes
    init_pwm_timer1_fixe(period_pwm,0.5);
    digitalWrite(ENABLE,HIGH);
}
                   

La fonction loop est vide.

void loop() {
    
}
                     

4.a. Circuit de mesure

On ajoute au circuit précédent la mesure du courant efficace traversant la résistance R, qui est aussi le courant dans la bobine. On utilise pour cela un multiplicateur analogique AD633, qui permet d'obtenir le carré de la tension aux bornes de cette résistance. La tension obtenue subit un filtrage passe-bas qui permet de récupérer sa valeur moyenne pour une lecture sur l'entrée A0 de l'arduino.

Le multiplicateur doit être alimenté avec une double tension. Sa sortie est définie par :

On le cable pour obtenir en sortie W=(Ri)²/10. Avec une source de tension V_s=12 V et en se plaçant à la résonance, la tension de crête en sortie du multiplicateur atteint 10 V, ce qui justifie l'emploi d'une alimentation double d'au moins 12 V. Pour obtenir une valeur moyenne dans l'intervalle [0,5] V, le filtre RC passe-bas divise la tension par 2. La tension lue sur l'entrée A0 de l'arduino est donc :

La valeur efficace du courant est donc :

4.b. Programme arduino

On ajoute au programme précédent la lecture échantillonnée de l'entrée A0, avec calcul d'une moyenne. On définit dans l'entête la période d'échantillonnage en microsecondes et le nombre d'échantillons utilisés pour le calcul de la moyenne. La tension de référence AREF est lue au voltmètre sur la borne AREF de l'arduino. On précise aussi la résistance R et le rapport du diviseur de tension (filtre RC de sortie). Il faudra éventuellement modifier ce rapport pour que la tension sur A0 ne dépasse pas AREF (il suffit pour cela de changer la résistance R2)

#include "Arduino.h"

#define ENABLE 10
#define TE_MESURES 1000 // microsecondes
#define N_MESURES 250
#define AREF 4.85
#define RESISTANCE 6.8
#define DIVISEUR 2

uint32_t icr;
float period_pwm;
uint16_t diviseur[6] = {0,1,8,64,256,1024};
volatile uint32_t inter2;

float somme;
float moyenne;
float Ieff;
char reglage;
                

La fonction suivante programme le timer1 pour qu'il génère un signal PWM. La période est un flottant en microsecondes. Le rapport cyclique est un flottant entre 0 et 1.

void init_pwm_timer1_fixe(float period, float ratio) { // rapport cyclique fixe, period en 1/100 us
      char clockBits;
    TCCR1A = 0;
    TCCR1A |= (1 << COM1A1); //Clear OC1A on compare match when upcounting, set OC1A on compare match when downcounting
    TCCR1B = 1 << WGM13; // phase and frequency correct pwm mode, top = ICR1
    int d = 1;
    icr = (F_CPU/1000000*period/2);
    while ((icr>0xFFFF)&&(d<6)) { // choix du diviseur d'horloge
        d++;
        icr = (F_CPU/1000000*period/2/diviseur[d]);
   } 
   clockBits = d;
   ICR1 = icr; // valeur maximale du compteur
   OCR1A = ratio*icr;
   OCR1B = icr;
   TCNT1 = 0; // mise à zéro du compteur
   TCCR1B |= clockBits; // déclenchement du compteur
}
                  

La fonction suivante configure le timer2 pour qu'il génère des interruptions périodiques pour la lecture échantillonnée de l'entrée A0. La période est en microsecondes.

void timer2_init(uint32_t period) { // compteur 8 bits 
  TCCR2A = 0;
  TCCR2B = 0;
  TCCR2B |= (1 << WGM21); // mode CTC avec OCR0A pour le maximum 
  uint32_t top = (F_CPU/1000000*period);
  int clock = 1;
  while ((top > 0xFF)&&(clock<5)) {
    clock ++;
    top = (F_CPU/1000000*period/diviseur[clock]);
  }
  OCR2A = top; // période
  TIMSK2 = (1 << OCIE2A); // interruption lorsque TCNT0 = OCR0A
  inter2 = 0;
  TCCR2B |= clock;
}
                   

La fonction suivante initialise le convertisseur A/N :

void adc_init(uint8_t prescaler) {
  ADCSRA = 0;
  ADCSRA |= (1 << ADEN); 
  ADCSRA |= prescaler;
  ADMUX = 0b01000000 | 0; // voie 0 
  ADCSRB = 0;  
}
                   

Voici la fonction appelée lors des interruptions périodiques. Elle fait fonctionner le convertisseur A/N sur l'entrée A0 et met à jour la somme des valeurs de tension lues. Lorsque le nombre de mesure maximal est atteint, la valeur moyenne de la tension lue est mise à jour et l'intensité efficace est calculée.

ISR(TIMER2_COMPA_vect) {
    ADCSRA |= 0b01000000;
    while (ADCSRA & 0b01000000);
    float x = ((ADCL | (ADCH << 8))*AREF/1024);
    somme += x;
    inter2++;
    if (inter2==N_MESURES) {
      inter2 = 0;
      moyenne = somme/N_MESURES;
      Ieff = sqrt(moyenne*10*DIVISEUR)/RESISTANCE;
      somme = 0.0;
    }
}   
                   

Voici la fonction setup :

void setup() {
  Serial.begin(115200);
  pinMode(ENABLE,OUTPUT);
  digitalWrite(ENABLE,LOW);
  
#if defined(__AVR_ATmega2560__)
    pinMode(11,OUTPUT); // sortie PWM pour MEGA
#else
    pinMode(9,OUTPUT); // sortie PWM pour UNO
#endif
    period_pwm = 31.0; // en microsecondes
    somme = 0.0;
    inter2 = 0;
    adc_init(4);
    timer2_init(TE_MESURES);
    init_pwm_timer1_fixe(period_pwm,0.5);
    digitalWrite(ENABLE,HIGH);
    reglage = 1;
}
            

Voici un exemple de fonction loop qui effectue un balayage de la période et affiche sur la console série la période et le courant efficace :

void loop() {
    delay(3000);
    if (reglage) {
      for (period_pwm=20; period_pwm<30; period_pwm+=0.2) {
        init_pwm_timer1_fixe(period_pwm,0.5);
        delay(1000);
        Serial.println(String(period_pwm)+" "+String(Ieff));  
      }
    reglage = 0;  
    }
}
             

Le texte obtenu sur la console peut être copié puis collé dans un fichier texte pour exploitation ultérieure.

4.c. Tests

Voici les oscillographes de la tension en sortie du multiplicateur et en sortie du filtre RC pour une période de 25 μs, très proche de la résonance :

On remarque la valeur de crête d'environ 10 V. La sortie de l'AD633 sature à environ 12 V pour une alimentation de 15 V. Si cela se produit, il faut augmenter la tension d'alimentation positive. La tension en sortie du filtre RC est d'environ 2,5 V.

Voici ce qu'on obtient lorsqu'on séloigne de la résonance :

Le basculement du pont n'est plus synchrone avec le courant dans la bobine. On observe des pics de courant.

Voici la courbe obtenue en utilisant la fonction loop ci-dessus :

[T,I] = numpy.loadtxt("period-courant-20-30.txt",unpack=True)
figure()
plot(T,I,".-")
xlabel("T (us)")
ylabel("Ieff (A)")
grid()
axis([20,30,0,2])
                  

figure()
plot(1000.0/T,I,".-")
xlabel("f (kHz)")
ylabel("Ieff (A)")
grid()
axis([10,100,0,2])
                  

Voici la courbe obtenue lorsqu'un objet en acier (une cuiller) est placée dans la bobine :

[T1,I1] = numpy.loadtxt("period-courant-20-30-cuiller.txt")
figure()
plot(T,I,".-",label="vide")
plot(T1,I1,".-",label="cuiller")
xlabel("T (us)")
ylabel("Ieff (A)")
grid()
legend(loc="upper right")
axis([20,30,0,2])
                  

Le courant à la résonance est réduit d'un facteur 2, ce qui est une conséquence des pertes dans la bobine. De plus, la résonance est légèrement déplacée : la fréquence de résonance diminue à cause de l'augmentation de l'inductance causée par la présence de l'objet magnétique. La résonance est plus large car le facteur de qualité a baissé.

En présence d'un objet métallique, il est possible d'abaisser la résistance R pour augmenter le courant (et réduire les pertes dans la résistance). Voici le résultat avec la cuiller et R=1 Ω. La résistance R₂ en sortie du filtre RC est enlevée pour amener la division à 1.

[T2,I2] = numpy.loadtxt("period-courant-20-40-cuiller-R1.txt",unpack=True)
figure()
plot(T1,I1,".-",label="cuiller R=6.8")
plot(T2,I2,".-",label="cuiller R=1.0")
xlabel("T (us)")
ylabel("Ieff (A)")
grid()
legend(loc="upper right")
axis([20,35,0,2])
                  

La réduction de la résistance permet d'avoir un courant en présence de l'induit un peu plus fort, mais surtout il y a beaucoup moins de pertes dans la résistance.

Voici le résultat avec une grosse vis en fer :

[T3,I3] = numpy.loadtxt("period-courant-20-40-vis-R1.txt",unpack=True)
figure()
plot(T3,I3,".-",label="vis R=1.0")
xlabel("T (us)")
ylabel("Ieff (A)")
grid()
legend(loc="upper right")
axis([20,35,0,2])
                  

4.d. Conclusion

La configuration LC série a l'inconvénient d'obliger l'alimentation à fournir la totalité du courant traversant la bobine. La nécessité d'introduire la résistance R en série pour limiter ce courant (afin que l'alimentation reste en stabilisation de tension) introduit une dissipation importante dans le circuit. Pour cette configuration LC série, il est préférable de choisir une résistance R faible et de faire fonctionner le hacheur seulement en présence de l'induit.

5.a. Principe

Dans l'onduleur à circuit RLC série, la totalité du courant traversant la bobine est fournie par le pont, ce qui fait que la puissance réactive fournie par la source est très élevée, alors même que la puissance active (les pertes dans le circuit, y compris l'induit) est bien moins élevée. Pour les fours de forte puissance, il est préférable de réduire le courant délivré par le pont, relativement au courant traversant la bobine (Induction heating). Ce résultat est obtenu en plaçant le condensateur en parallèle avec la bobine. Il faut aussi ajouter une inductance L₁ en entrée. Ce dispositif est beaucoup plus difficile à mettre au point que le précédent, c'est pourquoi nous commençons par un hacheur deux quadrants (demi-pont). Dans ce cas, on doit ajouter aussi un condensateur C₁ de couplage AC pour enlever la composante continue. Voici le circuit considéré :

On a placé des résistances pour modéliser les pertes dans les bobines. L'induit possède une inductance L₂ et une résistance R₂.

Pour étudier ce circuit, on place une entrée sinusoïdale de force électromotrice E à la place du hacheur. Les trois intensités vérifient alors le système d'équations suivant, obtenu en écrivant les trois lois de maille :

5.b. Résonance du circuit RLC

On considère tout d'abord le circuit en l'absence d'induit (I₂=0).

Voici des fonctions python pour calculer le courant I dans la bobine de chauffage, la tension U à ses bornes, et le courant I₁ délivré par le pont.

def tensionBobine(Vs,L,C,L1,C1,r1,r,f):
    w=2*numpy.pi*f
    return Vs/(1+(1/(1j*C1*w)+1j*L1*w+r1)*(1j*C*w+1/(r+1/(1/(1j*L*w))))) 
    
def courantBobine(Vs,L,C,L1,C1,r1,r,f):
    w=2*numpy.pi*f
    return Vs/(1+(1/(1j*C1*w)+1j*L1*w+r1)*(1j*C*w+1/(r+1/(1/(1j*L*w)))))/(r+1/(1/(1j*L*w)))
    
def courantPont(Vs,L,C,L1,C1,r1,r,f):
    w=2*numpy.pi*f
    return Vs/(1/(1j*C1*w)+1j*L1*w+r1+1/(1j*C*w+1/(r+1/(1/(1j*L*w)))))
                 

Voici un exemple, avec les valeurs utilisées dans le dispositif décrit plus loin. Pour la modélisation, le plus difficile est d'évaluer correctement les résistances. Une mesure de la résistance en DC ne suffit pas, car l'effet de peau à cette fréquence augmente notablement la résistance.

Vs=12
L=3.4e-6
C=680e-9*2
C1=2e-6
L1=18e-6
r1=0.5
r=0.2
freq = numpy.logspace(start=4,stop=6,num=1000)
U = tensionBobine(Vs,L,C,L1,C1,r1,r,freq)
figure()
plot(freq/1000,numpy.absolute(U))
xlabel("f (kHz)")
ylabel("U (V)")
xscale('log')
grid()
                 

On s'intéresse à la seconde résonance, celle de plus haute fréquence.

freq = numpy.linspace(start=40000,stop=120000,num=500)
figure()
I = courantBobine(Vs,L,C,L1,C1,r1,r,freq)
I1 = courantPont(Vs,L,C,L1,C1,r1,r,freq)
plot(freq/1000,numpy.absolute(I),label="I")
plot(freq/1000,numpy.absolute(I1),label="I1")
xlabel("f (kHz)")
ylabel("I (A)")
legend(loc="upper left")
grid()
                 

À la résonance, le courant délivré par le pont est bien inférieur au courant dans la bobine. Voici l'effet d'une réduction de l'inductance L1

I = courantBobine(Vs,L,C,L1*0.7,C1,r1,r,freq)
I1 = courantPont(Vs,L,C,L1*0.7,C1,r1,r,freq)
figure() 
plot(freq/1000,numpy.absolute(I),label="I")
plot(freq/1000,numpy.absolute(I1),label="I1")
xlabel("f (kHz)")
ylabel("I (A)")
legend(loc="upper left")
grid()
                 

Le courant dans la bobine de chauffage est augmenté mais la compensation est moins bonne car le rapport I/I₁ a diminué. En pratique, il faut trouver un compromis entre un courant important dans la bobine et une bonne compensation de la puissance réactive.

Voyons la tension aux bornes de la bobine :

U=tensionBobine(Vs,L,C,L1,C1,r1,r,freq)
figure()
subplot(211)
plot(freq/1000,numpy.absolute(U))
xlabel("f (kHz)")
ylabel("U (V)")
grid()
subplot(212)
plot(freq/1000,numpy.angle(U)/numpy.pi)
xlabel("f (kHz)")
ylabel("phi/pi")
grid()
                 

On remarque que le déphasage entre la tension aux bornes de la bobine et la tension en sortie du pont passe de 0 à -π. Il est exactement égal à -π/2 à la résonance. Cette propriété pourra être exploitée pour ajuster la fréquence à la résonance par asservissement. Un détecteur de phase peut être réalisé en faisant la multiplication de la tension U par la tension de commande du pont, puis en effectuant un filtrage passe-bas. Il est ainsi possible de faire un asservissement (de type boucle à verouillage de phase) pour maintenir la fréquence de commande égale à la fréquence de résonance.

Voyons à présent l'effet de l'induit et le courant dans celui-ci. À cette fréquence, l'impédance de l'induit est essentiellement inductive.

import scipy.linalg
                 
def courants(Vs,L,C,L1,C1,r1,r,L2,r2,M,freq):
    w=2*numpy.pi*freq
    A = numpy.zeros((3,3),dtype=numpy.complex)
    B = numpy.array([Vs,0,0])
    A[0,0] = 1j*L*w+r
    A[0,1] = 1/(1j*C1*w)+1j*L1*w+r1
    A[0,2] = 1j*M*w
    A[1,0] = 1j*L*w+r+1/(1j*C*w)
    A[1,1] = -1/(1j*C*w)
    A[1,2] = 1j*M*w
    A[2,0] = 1j*M*w
    A[2,1] = 0
    A[2,2] = 1j*L2*w+r2
    x = scipy.linalg.solve(A,B)
    return (numpy.absolute(x[0]),numpy.absolute(x[1]),numpy.absolute(x[2]))
    
L2=1e-8
r2=1e-3
k=0.5
M=k*numpy.sqrt(L*L2)
N = 500
freq = numpy.linspace(start=40000,stop=120000,num=N)
I = numpy.zeros(N)
I1 = numpy.zeros(N)
I2 = numpy.zeros(N)
for n in range(N):
    (I[n],I1[n],I2[n]) = courants(Vs,L,C,L1,C1,r1,r,L2,r2,M,freq[n])
    
figure()
subplot(211)
plot(freq/1000,I,label="I")
plot(freq/1000,I1,label="I1")
xlabel("f (kHz)")
ylabel("I (A)")
legend(loc="upper left")
grid()
subplot(212)
plot(freq/1000,I2,label="I2")
xlabel("f (kHz)")
ylabel("I (A)")
legend(loc="upper left")
grid()
                 

La fréquence de résonance est augmentée. En réalité, il y a une augmentation de L à cause de la présence d'une pièce magnétique dans la bobine, et la fréquence de résonance est en fait abaissée en présence de l'induit. Le courant dans la bobine à la résonance est abaissé en présence de l'induit. Le rapport I/I₁ n'est pratiquement pas modifié.

Cette simulation nous permet d'explorer l'influence du diamètre du fil et du nombre de spires de la bobine. Supposons que l'on double le diamètre du fil et que l'on divise par 2 le nombre de spires (la longueur de la bobine reste identique). L'inductance L est divisée par 4. La division par 2 de la longueur de fil réduit la résistance d'un facteur 2. La section efficace du fil traversé par du courant est mutlipliée par 2 car l'effet de peau est important à cette fréquence. Il s'en suit une division de la résistance r de la bobine par 4. Pour garder la même fréquence de résonance, on doit multiplier les capacités par 4. L'inductance L₁ doit aussi être divisée par 4. Si le fil utilisé pour cette inductance est réduit, sa résistance est réduite d'un facteur 2 (on ne change pas le diamètre du fil).

M=k*numpy.sqrt(L/4*L2)
for n in range(N):
    (I[n],I1[n],I2[n]) = courants(Vs,L/4,C*4,L1/4,C1*4,r1/2,r/4,L2,r2,M,freq[n])
    
figure()
subplot(211)
plot(freq/1000,I,label="I")
plot(freq/1000,I1,label="I1")
xlabel("f (kHz)")
ylabel("I (A)")
legend(loc="upper left")
grid()
subplot(212)
plot(freq/1000,I2,label="I2")
xlabel("f (kHz)")
ylabel("I (A)")
legend(loc="upper left")
grid()
                    

On constate que l'augmentation du diamètre du fil de la bobine de chauffage (associée à une réduction du nombre de spires) a une influence très forte sur le courant dans la bobine et dans l'induit. Sur cette simulation, une augmentation d'un facteur 2 de ce diamètre conduit à une augmentation du courant d'un facteur 1,8, et donc à une puissance dissipée augmentée d'un facteur 3,2. Les valeurs précises de L₂ et r₂ dépendent de la forme et de la taille de l'induit, mais quels que soient ces valeurs on observe cette influence positive du diamètre du fil. Cela vient du fait que le maximum de la courbe de résonance est très sensible à la résistance. Lorsque celle-ci tend vers zéro, le courant maximal tend vers l'infini.

Pour faire un chauffage par induction de puissance, on a donc intérêt à réaliser la bobine avec un très gros câble, par exemple un tuyau de cuivre. La conduction se faisant sur une épaisseur de l'ordre du dixième de millimètre (pour 100 kHz), il n'est pas gênant que le conducteur soit creux. Dans les chauffages de très forte puissance, on peut d'ailleurs faire circuler de l'eau de refroidissement dans ce tuyau.

5.c. Mesure des courants

Afin de comparer les courants I et I₁, on place dans chaque branche une petite inductance avec un noyau en ferrite. Un petit enroulement secondaire permet de visualiser à l'oscilloscope une tesnion proportionnelle au courant.

Si M est l'inductance mutuelle entre les deux bobines enroulées sur le noyau, on a :

5.d. Réalisation

Voici le circuit avec le pont MOSFET L6203 et un circuit de mesure. Seule la sortie OUT1 du pont est utilisée.

La bobine de chauffage est réalisée avec un câble comportant 7 fils, de section 6 mm², enroulé en 10 spires sur un tube en PVC de diamètre 4 cm. Son inductance est L=3,4 μH (mesurée par résonance en circuit LC). Il s'agit d'un câble utilisé pour le branchement des fours domestiques, qui peut fonctionner sans risque jusqu'à 30 A.

La bobine de compensation qui fournit l'inductance L₁ est réalisée en enroulant entre 20 et 30 spires d'un fil multibrin de section 0,52 mm² sur un tube de 4 cm de diamètre. L'inductance L₁ peut être ajustée en enlevant ou en ajoutant des spires.

La capacité C=1,33 nF est réalisée avec deux condensateurs à film de polypropylène métallisé (condensateur de puissance MKP). Ces condensateurs doivent pouvoir travailler à haute fréquence et pour de forts courants. Le condensateur C1 est aussi à film de polypropylène.

Les deux bobines de mesure B1 et B2 sont réalisées avec 3 spires de 1 cm de diamètre d'un câble de section 1,5 mm². Un petit barreau en ferrite de diamètre 4 mm est placé dans chacune de ces bobines, avec un enroulement secondaire constitué de 9 spires de fil monobrin de 0,2 mm². La présence du noyau de ferrite donne à l'inductance de mesure B2 située en série avec la bobine de chauffage une valeur non négligeable par rapport à L, ce qui a pour effet d'abaisser la fréquence de résonance d'environ 10 kHz.

Les réglages se font en remplaçant la borne D11 de l'arduino par la sortie TTL d'un générateur de fonctions. La fréquence de résonance est à environ 80 kHz. Il y a aussi une résonance à plus basse fréquence, qu'il faut éviter car elle sollicite fortement l'alimentation. Les tensions à observer à l'oscilloscope sont :

• v₁ : égal au courant I₁ multiplié par une constante 1/a et déphasé de π/2.
• v₂ : égal au courant I multiplié par la constante 1/a et déphasé de π/2.
• v₃ : la tension aux bornes du condensateur (ou de la bobine), multipliée par D=3.3/13.3.
• v₄ : la tension en sortie du pont.
• v₅ : la tension aux bornes de la résistance R_s=0,2 Ω située à la base du pont, qui permet d'accéder directement au courant délivré par le pont. La comparaison avec la tension v₁ permet de déterminer la constante a.

Le circuit de mesure est constitué de trois multiplicateurs analogiques et de deux amplificateurs, le tout alimenté par une double tension -15/0/15. Le pont diviseur placé en parallèle avec la capacité C fournit DU(t) avec D=0,25 et U(t) la tension aux bornes de la bobine de chauffage.

Les trois multiplicateurs fournissent :

• La tension (Gv₂)²/10, pour la mesure du courant efficace I. G=1+100/33 est le gain de l'amplificateur.
• La tension (DU)²/10 pour la mesure de la tension efficace aux bornes de la bobine.
• Le produit de la tension du signal de commande par DU(t), pour mesurer l'écart à la résonance.

Ce dernier est envoyé vers un amplificateur passe-bas, qui permet d'obtenir sa valeur moyenne tout en ajoutant un décalage. La tension obtenue est envoyée sur l'entrée A2 de l'arduino. Le potentiomètre permet d'ajuster la tension sur l'entrée non inverseuse pour que la tension de sortie soit décalée d'une tension positive, afin de pouvoir être lue par le convertisseur A/N de l'arduino.

Les deux premières tensions sont positives et sont donc envoyées directement vers les entrées A0 et A1 via un filtre RC passe-bas, qui permet d'obtenir la valeur moyenne du carré, c'est-à-dire la valeur efficace.

On obtient ainsi sur les trois entrées de l'arduino :

• Sur A0, la moyenne du carré du courant I.
• Sur A1, la moyenne du carré de la tension U.
• Sur A2, la moyenne du produit du signal de commande par la tension U(t) aux bornes de la bobine. Cette moyenne mesure l'écart à la résonance car elle s'annule lorsque le déphasage entre les deux signaux est de -π/2. On a ainsi un détecteur de phase qui permettra de contrôler la fréquence pour qu'elle reste au voisinage de la résonance.

Deux boutons poussoir branchés sur les entrées D2 et D3 de l'arduino sont prévus pour modifier manuellement la fréquence.

Une thermistance CTN est vissée sur une petite plaque en acier afin de mesurer l'échauffement de celle-ci lorsqu'elle est placée dans la bobine. Le pont diviseur donne sur l'entrée A3 une tension qui augmente avec la température, de manière grossièrement linéaire. Le thermomètre ainsi réalisé est étalonné avec un thermomètre à thermocouple.

L'ensemble formé du condensateur C, des bobines de mesure, de la bobine L1 et du condensateur C1 est placé dans un boitier. La tension entre les deux bornes du condensateur peut atteindre 80 V (en l'absence d'induit). Il faut donc que cette partie du circuit soit inaccessible pendant l'utilisation. Par ailleurs, la masse du pont MOSFET (celle de l'alimentation) est reliée à la terre. La bobine de chauffage, située à l'extérieur du boitier, est directement vissée sur le bornier situé dans le boitier. Le courant dans la bobine et dans les fils de connexion du condensateur peut atteindre 25 A, sans induit et avec une alimentation de 25 V (situation que l'on évitera, mais que le fils de la bobine et les condensateurs supportent parfaitement). Le pont diviseur pour la tension U(t) est situé à l'intérieur du boitier.

5.e. Programme arduino

Le programme arduino effectue la lecture échantillonnée des trois entrées A0,A1,A2 et A3, répond aux actions sur les boutons poussoir, et affiche les grandeurs mesurées sur la console.

Dans l'entête, on définit la période d'échantillonnage et le nombre d'échantillons utilisés pour le calcul des différentes grandeurs (par moyennage). La tension AREF est lue au voltmètre sur la borne AREF de l'arduino.

#include "Arduino.h"

#define ENABLE 10
#define TE_MESURES 2000 // microsecondes
#define N_MESURES 500
#define AREF 4.97
#define VZERO_0 2.5
#define G_1 6.25e-3 // tension
#define G_0 1.62 //courant
#define A 6.5
#define TEREF 12.2
#define F_MOINS 2 // PE4
#define F_PLUS 3 // PE5

uint32_t icr;
float period_pwm,period_pwm_ref;
uint16_t diviseur[6] = {0,1,8,64,256,1024};
volatile uint32_t inter2;

float somme_0, somme_1, somme_2, somme_3;
char reglage,ajust;
float vzero_2;
float dephasage;
float Ueff;
float Ieff;
float Temp;
float temps;
char f_plus,f_moins;
                 

La fonction suivante déclenche le timer 1 pour qu'il génère un signal PWM de rapport cyclique fixe

void init_pwm_timer1_fixe(float period, float ratio) { // rapport cyclique fixe, period microseoncondes
      char clockBits;
    TCCR1A = 0;
    TCCR1A |= (1 << COM1A1); //Clear OC1A on compare match when upcounting, set OC1A on compare match when downcounting
    TCCR1B = 1 << WGM13; // phase and frequency correct pwm mode, top = ICR1
    int d = 1;
    icr = (F_CPU/1000000*period/2);
    while ((icr>0xFFFF)&&(d<6)) { // choix du diviseur d'horloge
        d++;
        icr = (F_CPU/1000000*period/2/diviseur[d]);
   } 
   clockBits = d;
   ICR1 = icr; // valeur maximale du compteur
   OCR1A = ratio*icr;
   OCR1B = icr;
   TCNT1 = 0; // mise à zéro du compteur
   TCCR1B |= clockBits; // déclenchement du compteur
}
                 

La fonction suivante programme le timer 2 pour qu'il génère des interruptions périodiques.

void timer2_init(uint32_t period) { // compteur 8 bits 
  TCCR2A = 0;
  TCCR2B = 0;
  TCCR2B |= (1 << WGM21); // mode CTC avec OCR0A pour le maximum 
  uint32_t top = (F_CPU/1000000*period);
  int clock = 1;
  while ((top > 0xFF)&&(clock<5)) {
    clock ++;
    top = (F_CPU/1000000*period/diviseur[clock]);
  }
  OCR2A = top; // période
  TIMSK2 = (1 << OCIE2A); // interruption lorsque TCNT0 = OCR0A
  inter2 = 0;
  TCCR2B |= clock;
}

                 

La fonction suivante initialise le convertisseur ADC :

void adc_init(uint8_t prescaler) {
  ADCSRA = 0;
  ADCSRA |= (1 << ADEN); 
  ADCSRA |= prescaler;
  
  ADCSRB = 0;  
}
                 

La fonction suivante est appelée lors des interruptions périodiques. Elle effectue la lecture des quatre entrées A0,A1,A2,A3, met à jour la somme pour chaque tension lue. Lorsque le nombre maximal d'échantillons est atteint, elle calcule le déphasage (l'écart à la résonance), la tension efficace, le courant efficace, et la température calculée à partir du pont diviseur contenant la thermistance. L'état des deux boutons poussoir est aussi consulté.

ISR(TIMER2_COMPA_vect) {
    ADMUX = 0b01000000 | 0; // voie 0 
    ADCSRA |= 0b01000000;
    while (ADCSRA & 0b01000000);
    float x0 = ((ADCL | (ADCH << 8))*AREF/1024);
    somme_0 += x0;
    ADMUX = 0b01000001 | 0; // voie 1 
    ADCSRA |= 0b01000000;
    while (ADCSRA & 0b01000000);
    float x1 = ((ADCL | (ADCH << 8))*AREF/1024);
    somme_1 += x1;
    ADMUX = 0b01000010 | 0; // voie 2
    ADCSRA |= 0b01000000;
    while (ADCSRA & 0b01000000);
    float x2 = ((ADCL | (ADCH << 8))*AREF/1024);
    somme_2 += x2;
    ADMUX = 0b01000011 | 0; // voie 3
    ADCSRA |= 0b01000000;
    while (ADCSRA & 0b01000000);
    float x3 = ((ADCL | (ADCH << 8)));
    somme_3 += x3;
    inter2++;
    
    if (inter2==N_MESURES) {
      inter2 = 0;
      dephasage = somme_2/N_MESURES-vzero_2;
      Ueff = sqrt((somme_1/N_MESURES)/G_1);
      Ieff = sqrt((somme_0/N_MESURES)/G_0)*A*period_pwm/TEREF;
      Temp = (somme_3/N_MESURES-155)*65.0/490+25.0;
      if (reglage) vzero_2 = somme_2/N_MESURES;
      somme_0 = somme_1 = somme_2 =  somme_3 = 0.0;
    }
#if defined(__AVR_ATmega2560__)
    if (PINE & (1<<PINE4)) {f_moins=1;f_plus=0;}
    if (PINE & (1<<PINE5)) {f_plus=1;f_moins=0;}
#else
   if (PIND & (1<<PIND2)) {f_moins=1;f_plus=0;}
   if (PIND & (1<<PIND3)) {f_plus=1;f_moins=0;}
#endif
}   
                   

La fonction setup programme la génération du signal PWM, avec une période initiale qui doit être proche de la période de résonance (à quelques microsecondes près). Avant que le pont ne soit activé (par son entrée ENABLE), la lecture du zéro de l'entrée A2 est effectuée. Cellui-ci est au préalable ajusté avec le potentiomètre à environ 2,5 V.

void setup() {
  Serial.begin(115200);
  pinMode(ENABLE,OUTPUT);
  digitalWrite(ENABLE,LOW);
  
#if defined(__AVR_ATmega2560__)
    pinMode(11,OUTPUT); // sortie PWM pour MEGA
    digitalWrite(11,LOW);
#else
    pinMode(9,OUTPUT); // sortie PWM pour UNO
    digitalWrite(9,LOW);
#endif
    pinMode(F_MOINS,INPUT);
    pinMode(F_PLUS,INPUT);
    period_pwm = period_pwm_ref = 11.8;// en microsecondes
    somme_0 = somme_1 = somme_2 = somme_3 = 0.0;
    inter2 = 0;
    adc_init(4);
    timer2_init(TE_MESURES);
    reglage=1;
    delay(3000);
    reglage=0;
    init_pwm_timer1_fixe(period_pwm,0.5);
    digitalWrite(ENABLE,HIGH);
    
    ajust=1;
    temps = 0;
    f_plus = f_moins = 0;
}
                    

La fonction loop affiche le résultat des mesures et fait l'ajustement de la période toutes les demi-secondes, en fonction du dernier bouton poussé. L'utilisateur doit maintenir un déphasage négatif (fréquence supérieure à celle de résonance) mais le plus proche possible de 0. L'incrément de la période est égal à 1/16 de microsecondes, la plus petite valeur possible compte tenu de la fréquence de l'horloge.

void loop() {
    delay(500);
    temps+= 0.5;
    if (f_plus) {
      period_pwm += 6.25e-2;
      f_plus=0;
    }
    if (f_moins) {
      period_pwm -= 6.25e-2;
      f_moins=0;
    }
    init_pwm_timer1_fixe(period_pwm,0.5);
    float R = Ueff/Ieff;
    Serial.println("t (s) = "+String(temps)+" period (us)= "+String(period_pwm)+" dephasage = "+String(dephasage)+" Ueff(V) = "+String(Ueff)+" Ieff(A) = "+String(Ieff)+ " R = "+String(R)+" T = "+String(Temp));

}
                      

Lorsqu'aucune charge n'est présente dans la bobine, il est préférable de maintenir un déphasage positif et assez grand (en valeur absolue) pour que la fréquence soit nettement supérieure à la fréquence de résonance. On peut aussi couper l'alimentation, si celle-ci possède un commutateur sur sa sortie. Lorsque la bobine est en résonance sans l'induit, les mesures de tension et de courant sont fausses car leur amplitude dépasse la gamme de mesure prévue.

5.f. Tests de l'onduleur

On commence par des tests sans induit, afin d'étalonner les bobines de mesure. On se place à une fréquence légèrement au dessus de la fréquence de résonance (pas au dessous), soit 82 kHz. La période est précisément T=12,2 μs. Voici la tension v₅ en sortie du pont (en bleu) et la tension v₃=DU(t) aux bornes de la bobine (en rouge), pour une tension d'alimentation V_s=12 V.

À la résonance, le courant dans la bobine est en phase avec la tension en sortie du pont, ce qui se devine sur le forme de la tension. La tension U(t) aux bornes de la bobine est donc en quadrature avec la tension en sortie du pont. La fréquence étant légèrement supérieure à la fréquence de résonance, le maximum de la tension a lieu juste après le basculement du pont. La tension en rouge doit être multipliée par 4 pour obtenir U(t); la valeur de crête est donc de 28 V.

Voici la tension v₄ aux bornes de la résistance R=0,2 Ω (en bleu) et la tension v₁ délivrée par l'enroulement secondaire de la bobine de mesure de I₁ :

La valeur efficace de la première est 0,471 V, soit un courant efficace I₁=2,35 A. La tension efficace aux bornes de la bobine de mesure étant V₁=0,359 V, on en déduit le facteur d'échelle 6,56 A/V pour la période de 12,2 ms. La tension v1 étant proportionnelle à la fréquence, le facteur d'échelle pour une fréquence f est :

Voici un autre enregistrement pour une tension d'alimentation V_s=25 V :

Le courant efficace est I₁=4,86 A et la tension efficace V₁=0,747 V, soit un facteur d'échelle de 6,5 A/V.

La figure suivante montre la tension v₂ (en bleu) avec la tension v₁ (en rouge), ce qui permet de comparer directement les courants I et I₁ :

Le rapport des valeurs efficaces donne le rapport des courant I/I₁=5. Il est possible d'augmenter ce rapport en augmentant la valeur de L₁, mais au prix d'une diminution du courant. Le courant efficace est ici I=11,4 A et la tension U=22 V, pour une tension d'alimentation V_s=12 V.

Pour une tension d'alimentation V_s=24 V, voici la tension v₂ de mesure de I (en bleu) et la tension v₃=DU (en rouge) :

On en déduit l'intensité efficace I=25 A et la tension efficace U=42 V. Pour ces valeurs, l'échauffement par effet Joule du câble est sensible, tout comme celui du pont MOSFET. On est d'ailleurs proche de la limite du courant délivrable par le pont (5 A). Il faudra donc éviter de rester plus de quelques secondes sans induit avec une alimentation à 24 V ou plus.

Voici les mêmes tensions lorsqu'un induit est présent (une barre en acier). La fréquence de résonance est légèrement abaissée. La période utilisée est T=12,45 μs.

Le courant efficace est I=9,5 A et la tension U=17,8 V.

Il est intéressant de comparer les courant I et I₁ en présence de l'induit :

Le rapport est I/I₁=3,8, ce qui est plus bas que sans l'induit. C'est une conséquence de l'augmentation de L due à la présence de l'induit ferromagnétique.

5.g. Test de chauffage

Le programme arduino fournit les mesures de tension et de courant efficace et permet d'ajuster la fréquence en appuyant sur les deux boutons poussoir. Pour cela, on doit augmenter ou réduire la fréquence afin que le déphasage reste proche de zéro, de préférence positif (fréquence légèrement supérieure à celle de résonance). Il affiche la température de l'induit, mesurée de manière sommaire avec la thermistance.

L'induit est une petite plaque en acier zingué sur laquelle la thermistance est vissée.

Pendant le fonctionnement, il est intéressant de suivre à l'oscilloscope la tension U(t) et le signal de commande. À la résonance, ces deux signaux sont en quadrature.

Afin d'obtenir un fichier CSV sur la console, nous avons remplacé la dernière ligne de la fonction loop par :

if (temps<300) Serial.println(String(temps)+" "+String(period_pwm)+" "+String(dephasage)+" "+String(Ueff)+" "+String(Ieff)+" "+String(Temp));
                 

La tension de l'alimentation est 30 V. La puissance totale fournie par l'alimentation pendant l'expérience est d'environ 30 W (d'après la tension et l'intensité affichées).

Voici la température en fonction du temps :

data = numpy.loadtxt("data-3.txt",unpack=True)
t=data[0]
T=data[5]

figure()
plot(t,T)
xlabel("t (s)")
ylabel("T (C)")
grid()
                   

Voici la tension U, le courant I (valeurs efficaces) et le déphasage au cours du temps :

phi = data[2]
Ueff=data[3]
Ieff=data[4]
figure()
subplot(311)
plot(t,Ueff)
xlabel("t (s)")
ylabel("Ueff (V)")
axis([0,100,0,30])
grid()
subplot(312)
plot(t,Ieff)
xlabel("t (s)")
ylabel("Ieff (A)")
axis([0,100,0,20])
grid()
subplot(313)
plot(t,phi)
xlabel("t (s)")
ylabel("phi")
axis([0,100,0,0.3])
grid()
                     

La fréquence est constante pendant l'expérience (80,3 kHz) mais la croissance du déphasage montre que la fréquence de résonance diminue légèrement au cours du temps. C'est probablement pour cette raison que le courant et la tension sont décroissants. La bobine s'échauffe notablement, probablement à cause du rayonnement thermique de l'induit. L'augmentation de la résistivité du cuivre peut expliquer la baisse de la fréquence de résonance. Pour maintenir le système au plus proche de la résonance, il faut agir sur la fréquence avec les boutons poussoir.

Nous avons fait un autre test avec un induit en fer sous la forme d'un tube creux de diamètre 15 mm, d'épaisseur 2 mm et de longueur 125 mm. Le chauffage est maintenu pendant 250 s avec une tension d'alimentation de 30 V. L'intensité efficace est I=5,9 A et la tension efficace U=11,7 V. L'alimentation délivre 21 W. La température, mesurée avec un thermocouple après coupure du chauffage, est de 95 degrés. Il faut en effet éviter de placer un thermocouple de type K dans la bobine pendant le chauffage car le nickel est ferromagnétique et s'échauffe donc directement.

6.a. Principe

L'utilisation d'un hacheur réversible en tension permet de multiplier par deux la tension appliquée au circuit LCL. Comme nous l'avons vu ci-dessus, il est important d'augmenter la tension pour augmenter la puissance de chauffage. Voici le schéma de principe avec un pont complet.

Les résistances de perte ne sont pas représentées. Il y a deux bobines de compensation identiques, d'inductance L₁. Le condensateur de couplage AC n'est plus nécessaire, à condition que le montage soit bien équilibré.

Ce montage en pont complet est en principe capable de délivrer deux fois plus de tension que le montage précédent, et donc quatre fois plus de puissance. Pour obtenir les mêmes caractéristiques que le montage en demi-pont, l'inductance L₁ doit être deux fois plus petite.

6.b. Réalisation

Les deux bobines L₁ sont constituées d'un enroulement de 23 à 25 spires sur un tube de diamètre 3 cm. L'une des bobines est en série avec la bobine B1 de mesure et devra donc avoir une inductance légèrement plus faible pour que le montage soit bien équilibré. On doit en effet éviter un courant continu dans la bobine, inutile pour le chauffage par induction.

Les deux tensions de part et d'autre de la bobine de chauffage sont divisées par deux résistances, avant d'être envoyées vers l'entrée différentielle du multiplicateur faisant la mesure de U efficace et de celui faisant le calcul du déphasage.

6.c. Test de l'onduleur

On commence par un test à vide (sans induit) pour une tension d'alimentation Vs=12 V. Voici la tension v₅ sur la sortie OUT1 du pont (en bleu) et la tension v₂ de la bobine de mesure du courant I (en rouge). La fréquence est ajustée pour être proche de la fréquence de résonance, à 80,2 kHz.

Le courant efficace déduit de v₂ est I=18,6 A. La tension U(t) ne peut pas être obtenue à l'oscilloscope sur une voie car elle est différentielle. Le programme arduino fournit la valeur efficace U=26 V.

Voici la tension v₂ pour la mesure de I (en bleu) et la tension v₃ pour la mesure de I₁ (en rouge) :

On voit que le courant I₁ en sortie du pont est bien moins élevé que le courant I dans la bobine. Le rapport des valeurs efficaces est I/I₁=7,2. On en déduit I₁=2,6 A. La puissance réactive est donc très bien compensée. Le courant de sortie de l'alimentation est 2,2 A.

Pour la même tension d'alimentation V_s=12 V, on place la plaque d'acier munie du thermomètre CTN. Voici la tension v₂ pour la mesure de I (en bleu) et la tension v₃ pour la mesure de I₁ (en rouge) :

Le courant efficace est I=6,4 A et le rapport I/I₁=3,4. Le rapport des courants est nettement moins élevé que sans induit. On pourrait augmenter ce rapport en augmentant L₁, mais au prix d'une diminution de I. Le plus important est que le courant délivré par le pont soit bien inférieur à sa limite (4 A). C'est bien le cas ici puisque I₁=1,9 A.

Pour ce même induit, on peut augmenter le courant en augmentant la tension d'alimentation. Voici le résultat pour V_s=24 V :

Le courant efficace est I=11,6 A, la tension efficace U=17,8 V. Le courant délivré par l'alimentation est 1,6 A, ce qui fait une puissance de 38 W. Le courant efficace délivré par le pont MOSFET est 3,4 A.

Pour comparaison avec le montage en demi-pont, un courant de 10 A est obtenu avec une tension d'alimentation de 20 V, alors qu'il faut une tension de 30 V pour atteindre le même courant avec le demi-pont.

6.d. Test de chauffage

On commence par un test avec la barre en acier munie de la thermistance. Le circuit L6203 est prévu pour délivrer jusqu'à 4 A efficace (avec un radiateur). Compte tenu du rapport I/I₁=3,4 pour cet induit, il ne faut pas dépasser I=14 A dans la bobine. La tension d'alimentation donnant ce courant est environ 28 V. On procède donc à V_s=27 V.

Voici la température en fonction du temps :

data = numpy.loadtxt("data-4.txt",unpack=True)
t=data[0]
T=data[5]

figure()
plot(t,T)
xlabel("t (s)")
ylabel("T (C)")
grid()
                   

Voici la tension U, le courant I (valeurs efficaces) et le déphasage au cours du temps :

phi = data[2]
Ueff=data[3]
Ieff=data[4]
figure()
subplot(311)
plot(t,Ueff)
xlabel("t (s)")
ylabel("Ueff (V)")
axis([0,100,0,30])
grid()
subplot(312)
plot(t,Ieff)
xlabel("t (s)")
ylabel("Ieff (A)")
axis([0,100,0,20])
grid()
subplot(313)
plot(t,phi)
xlabel("t (s)")
ylabel("phi")
axis([0,100,0,1.0])
grid()
                     

Le déphasage positif montre que la fréquence est au dessus de la fréquence de résonance. Bien que la fréquence soit parfaitement stable, le courant décroît au cours de l'échauffement. Le courant délivré par l'alimentation est 1,85 A, soit une puissance délivrée de 50 W.

Le test de chauffage du tube de fer avec une alimentation V_s=30 V conduit à une température de 120 degrés au bout de 120 s. Le courant efficace est I=9,3 A et la tension efficace U=14,8 V. La puissance délivrée par l'alimentation est 39 W. Le rapport des courants avec cet induit est I/I₁=2. Le courant sortant du pont est donc à la limite du maximum prévu pour le L6203.

Avec un induit en cuivre (tube ou fil), nous n'avons obtenu aucun échauffement notable au bout de plusieurs minutes. Le cuivre n'étant pas ferromagnétique, son chauffage par induction est possible mais beaucoup plus difficile à obtenir. En effet, le transfert d'énergie entre la bobine et l'induit est beaucoup plus faible s'il n'est pas ferromagnétique. Dans un matériau ferromagnétique, il y a une contribution des pertes par hystérésis à l'échauffement. En plaçant un barreau en ferrite (ferromagnétique mais très peu conducteur) dans la bobine, on constate qu'il s'échauffe, mais beaucoup moins qu'une pièce en fer de même dimension.