Détecteur d'inductance mutuelle

2.a. Mise en équation

Une bobine, d'inductance propre L₁ et de résistance r₁, associée à un condensateur de capacité C et à une résistance R, permet de constituer un filtre LC passe-bande, dont la tension d'entrée est V_e, la tension de sortie V_s. Un amplificateur à impédance d'entrée très grande permet de réaliser la fonction :

La fonction g doit présenter une décroissance de la pente comme indiqué sur la figure.

On s'intéresse tout d'abord à la réponse fréquentielle du filtre LC en calculant sa fonction de transfert H(f) :

import numpy as np
from matplotlib.pyplot import *
from numpy.fft import fft
from scipy.signal import blackman
from scipy.integrate import odeint

R=1000
C=1e-6
L1=47e-3
r1=8.5

f = np.linspace(400,1000,100000)
w = 2*np.pi*f
Y = 1j*C*w+1/(r1+1j*L1*w) # admittance bobine-condensateur
H = 1/(R*Y+1) # fonction de transfert du filtre
G = np.absolute(H)
phi = np.angle(H)
figure(figsize=(8,8))
subplot(211)
plot(f,G)
grid()
xlabel("f (Hz)")
ylabel("G")
subplot(212)
plot(f,phi)
grid()
xlabel("f (Hz)")
ylabel(r"$\phi$")
             

La fréquence d'oscillation du filtre en boucle avec un amplificateur à gain réel est la fréquence qui annule de déphasage :

f0 = f[np.argmin(np.absolute(phi))]
             

print(f0)
--> 733.561335613356

Si l'oscillateur était linéaire, la condition d'oscillation du système serait H(f)g=1. Il devrait avoir le gain :

Gmax = G.max()
g0 = 1/Gmax       
             

print(g0)
--> 1.179952096763931

Il est en réalité impossible de régler le gain exactement à cette valeur. On adopte donc une fonction de gain non linéaire avec un gain à faible tension supérieur à g₀. Pour la simulation, on utilise la fonction tangente hyperbolique :

def g(V): #amplificateur non linéaire
    return 1.4*np.tanh(V)

Vs = np.linspace(-2,2,1000)
Ve = g(Vs)
figure()
plot(Vs,Ve)
grid()
xlabel("Vs")
ylabel("Ve")
             

Lorsque la tension V_s est faible, le gain est supérieur à g₀ donc l'amplitude des oscillations est croissante. La réduction du gain effectif lorsque l'amplitude augmente permet de stabiliser l'amplitude des oscillations. Voici le tracé du gain effectif :

figure()
plot(Vs,Ve/Vs)
plot([-2,2],[g0,g0])
xlabel("Vs")
ylabel("Ve/Vs")
grid()
             

Effectuons la mise en équation du système, en prenant en compte la présence du circuit secondaire, qui est caractérisé par une inductance propre L₂ et une résistance r₂. L'inductance mutuelle est notée M.

Les inconnues sont V_e,V_s,i₁,i₂,i_c. Les 5 équations sont :

Après élimination de i_c et V_e et en définissant x=V_s, y=i₁ et z=i₂, on obtient le système d'équations :

Il s'agit d'un système algébro-différentiel que l'on peut mettre aisément sous la forme Y'=f(Y) :

2.b. Simulation

Voici une fonction qui effectue le calcul pour une durée T, un nombre de points N et une condition initiale Y0. Elle fait aussi l'analyse spectrale de x afin de déterminer la fréquence d'oscillation.

def integration(T,Y0,N,R,C,L1,r1,M,L2,r2,g):
    t = np.linspace(0,T,N)
    a=1/(R*C)
    b=L2/(L1*L2-M*M)
    c=r2*M/L2
    d=M/(L1*L2-M*M)
    e=L1*r2/(L1*L2-M*M)
    def systeme(Y,t):
        dY0 = a*(g(Y[0])-Y[0])-Y[1]/C
        dY1 = b*(Y[0]-r1*Y[1]-c*Y[2])
        dY2 = d*(Y[0]-r1*Y[1])-e*Y[2]
        return [dY0,dY1,dY2]
    Y = odeint(systeme,Y0,t,rtol=1e-6,atol=1e-6)
    x = Y[:,0]
    y = Y[:,1]
    z = Y[:,2]
    xe = x[N//2:N]
    xe = np.concatenate((xe*blackman(N//2),np.zeros(6*N//2)))
    Ne = len(xe)
    h = t[1]-t[0]
    spectre = np.absolute(fft(xe))*2.0/Ne/0.42
    freq = np.arange(Ne)*1/(Ne*h)
    f = freq[spectre[0:Ne//2].argmax()]
    return (t,x,y,z,freq,spectre,f)
              

Voyons tout d'abord la tension V_s en l'absence d'inductance mutuelle :

R=1000
C=1e-6
L1=47e-3
r1=8.5
M=0
L2=0.28e-3
r2=0.6

N=100000
T=1
Y0 = [0.01,0,0]
(t1,x1,y1,z1,freq1,spectre_x1,f1) = integration(T,Y0,N,R,C,L1,r1,M,L2,r2,g)
figure(figsize=(12,4))
subplot(211)
plot(t1,x1)
xlim(0,0.1)
grid()
ylabel("Vs")
subplot(212)
plot(t1,x1)
xlim(0.1,0.12)
xlabel("t (s)")
ylabel("Vs")
grid()
              

L'amplificateur non linéaire permet d'obtenir des oscillations dont l'amplitude tend vers une valeur constante. Bien sûr, l'amplitude obtenue dans cette simulation provient de la forme particulière de la courbe de gain. Ce qui nous importe ici est la fréquence de ces oscillations, qu'on obtient par analyse spectrale :

figure()
plot(freq1,spectre_x1)
xlabel("f (Hz)")
grid()
xlim(600,800)              
               

Le maximum nous donne la fréquence d'oscillation :

print(f1)
--> 733.4212371428571

que l'on peut comparer à la fréquence d'oscillation pour un amplificateur linéaire (fréquence qui annule le déphasage du filtre) :

print(f0)
--> 733.561335613356

Lorsqu'on augmente la précision des calculs, en réduisant la tolérance définie dans odeint et en augmentant le nombre de points du tracé du déphasage, on constate que l'écart entre ces deux valeurs se réduit, ce qui suggère que ces deux fréquences sont égales (bien que l'amplificateur ne soit pas linéaire).

Voyons l'influence de l'inductance mutuelle. On choisit l'inductance propre du circuit secondaire et sa résistance. L'inductance mutuelle maximale est $\sqrt{L_1{L}_2}$.

Mmax = np.sqrt(L1*L2)*0.999              
               

print(Mmax)
--> 0.0036240437580139675

M = 5e-4            
               

(t2,x2,y2,z2,freq2,spectre_x2,f2) = integration(T,Y0,N,R,C,L1,r1,M,L2,r2,g)
figure(figsize=(12,4))
subplot(211)
plot(t2,x2)
xlim(0,0.1)
grid()
ylabel("Vs")
subplot(212)
plot(t2,x2)
xlim(0.1,0.12)
xlabel("t (s)")
ylabel("Vs")
grid()             
               

figure()
plot(freq1,spectre_x1,label='M=0')
plot(freq2,spectre_x2,label='M=%0.2g'%M)
xlabel("f (Hz)")
legend(loc='upper left')
grid()
xlim(720,750)                
               

En présence du circuit secondaire, l'oscillation a une fréquence légèrement plus grande et une amplitude plus faible. Il s'agira de mesurer cette variation de fréquence au moyen d'une boucle à verrouillage de phase, ou bien avec un compteur numérique. Voyons l'influence du signe de l'inductance mutuelle :

(t3,x3,y3,z3,freq3,spectre_x3,f3) = integration(T,Y0,N,R,C,L1,r1,-M,L2,r2,g)
figure()
plot(freq1,spectre_x1,label='M=0')
plot(freq3,spectre_x3,label='M=-%0.2g'%M)
xlabel("f (Hz)")
legend(loc='upper left')
grid()
xlim(720,750) 
    

Il y a toujours augmentation de la fréquence, ce qui montre que le signe de l'inductance mutuelle n'est pas détectable.

Voici la fréquence d'oscillation en fonction de l'inductance mutuelle :

liste_M = np.linspace(0,2e-3,50)
liste_f = []
for M in liste_M:
    (t1,x1,y1,z1,freq1,spectre_x1,f1) = integration(T,Y0,N,R,C,L1,r1,M,L2,r2,g)
    liste_f.append(f1)

figure(figsize=(8,8))
subplot(211)
plot(np.array(liste_M)*1000,liste_f)
grid()
xlim(0,1)
ylim(720,760)
ylabel("f (Hz)")
subplot(212)
plot(np.array(liste_M)*1000,liste_f)
grid()
ylabel("f (Hz)")
xlabel("M (mH)")
            

La fréquence d'oscillation augmente avec l'inductance mutuelle. Si l'inductance mutuelle dépasse une certaine valeur, l'oscillateur ne fonctionne plus, comme le confirme l'exemple ci-dessous :

M=1.8e-3
(t2,x2,y2,z2,freq2,spectre_x2,f2) = integration(T,Y0,N,R,C,L1,r1,M,L2,r2,g)
figure(figsize=(12,4))
subplot(211)
plot(t2,x2)
xlim(0,0.1)
grid()
ylabel("Vs")
subplot(212)
plot(t2,x2)
xlim(0.1,0.12)
xlabel("t (s)")
ylabel("Vs")
grid()       
            

Cette valeur de l'inductance mutuelle (1.9 mH) est bien inférieure à la valeur maximale (3,6 mH) mais elle est assez grande pour conduire à un amortissement des oscillations. Pour obtenir des oscillations avec cette inductance mutuelle, il faut augmenter le gain de l'amplificateur :

def g(V): #amplificateur non linéaire
    return 1.9*np.tanh(V)
M=1.8e-3
(t2,x2,y2,z2,freq2,spectre_x2,f2) = integration(T,Y0,N,R,C,L1,r1,M,L2,r2,g)
figure(figsize=(12,4))
subplot(211)
plot(t2,x2)
xlim(0,0.1)
grid()
ylabel("Vs")
subplot(212)
plot(t2,x2)
xlim(0.1,0.12)
xlabel("t (s)")
ylabel("Vs")
grid()  
             

Il faudra donc ajuster le gain de l'amplificateur à un niveau assez élevé pour assurer l'oscillation dans le domaine d'inductance mutuelle à explorer.