Caractéristique d'un transistor bipolaire
1. Introduction
Ce document montre comment utiliser un convertisseur analogique-numérique pour tracer les courbes intensité-tension caractéristiques d'un transistor bipolaire. Une source de courant est utilisée pour contrôler le courant de base. La partie logicielle, en python, peut être utilisée avec différents convertisseurs.
2. Circuit de mesure
On s'intéresse à un transistor bipolaire NPN. Le circuit suivant permet d'obtenir ses caractéristiques.
Figure pleine pageLa source de courant impose un courant de base Ib. Elle est commandée par la tension S0 délivrée par une sortie du convertisseur numérique-analogique. La tensions S1 est fournie par une autre sortie numérique-analogique, par l'intermédiaire d'un suiveur à ampli-op (non représenté). Les entrées du convertisseur analogique-numérique E0,E2,E3 sont branchées comme indiqué sur la figure. On obtient ainsi la tension base-émetteur, le courant de collecteur et la tension collecteur-émetteur :
La source de courant commandée en tension est réalisée par le circuit suivant (avec deux ampli-op rail-to-rail) :
Figure pleine pageLe courant Is traversant la résistance de charge Rc est (relation approchée) :
On choisit R1=R2=47.5 kΩ (résistances à 1%). La tension S0 maximale étant de 5 volts, on choisit R3=47.5 kΩ de manière à faire varier le courant de sortie jusqu'à 100 μA.
Pour l'étude du transistor, la jonction base-émetteur est placée en série avec Rc, l'émetteur à la masse.
3. Étalonnage de la source de courant
L'étalonnage de la source de courant est faite avec Rc=47.75 kΩ (obtenue avec un ohmmètre de précision 0.9 % +1). La commande en tension et la mesure de la tension en sortie (aux bornes de Rc) sont faites avec le boitier LabJack U6.
import u6
import time
import numpy as np
from matplotlib.pyplot import *
sys = u6.U6()
n = 10
ve_array = np.zeros(n)
vs_array = np.zeros(n)
dve = 5.0/(n-1)
for k in range(n):
ve = k*dve
sys.writeRegister(5000,ve) # DAC0
time.sleep(0.1)
vs = sys.getAIN(1)
ve_array[k] = ve
vs_array[k] = vs
sys.writeRegister(5000,0.0)
sys.close()
Rc = 47.75 #kOhm
is_array = vs_array/Rc
figure(figsize=(6,6))
plot(ve_array,is_array)
xlabel("ve (V)")
ylabel("Is (mA)")
grid()
Figure pleine pageLa relation entre le courant de sortie et la tension de commande est bien linéaire. L'étalonnage consiste à déterminer la pente (en mA par volt) avec le dernier point :
pente = is_array[n-1]/ve_array[n-1]
4. Programme de commande
4.a. Classe générique
Le programme de commande est écrit en python. Il permet d'utiliser différents convertisseurs analogique-numérique.
Il se présente sous la forme d'une classe comportant des fonctions d'entrée-sortie génériques, qu'il faudra implémenter en fonction du convertisseur utilisé.
Les arguments du constructeur sont la pente du convertisseur tension-courant, le courant de base maximal en μA, la résistance Rc et les valeurs maximales des tensions délivrées par les convertisseurs numérique-analogique.
import time
import numpy as np
from matplotlib.pyplot import *
class CaracteristiqueTransistor:
def __init__(self,pente,Ib_max,Rc,S0_max,S1_max):
self.Ib_max = Ib_max
self.pente = pente
self.Rc = Rc
self.S0_max = S0_max
self.S1_max = S1_max
def sortie_s0(self,S0):
pass
def sortie_s1(self,S1):
pass
def entrees(self):
return [0.0,0.0,0.0,0.0]
La fonction suivante effectue le tracé de la caractéristique ib=f(Vbe). La tension S1 est réglée à sa valeur maximale de manière à être dans la zone de fonctionnement linéaire. Le nombre de points n0 est fourni en argument.
def base_emetteur(self,n0):
delta_Ib = self.Ib_max/(n0-1)
ib_array = np.zeros(n0)
Vbe_array = np.zeros(n0)
self.sortie_s1(self.S1_max)
for k in range(n0):
Ib = k*delta_Ib
self.sortie_s0(Ib/1000/self.pente)
[e0,e1,e2,e3] = self.entrees()
Vbe = e0
ib_array[k] = Ib
Vbe_array[k] = Vbe
xlabel("Vbe (V)")
ylabel("ib (muA)")
plot(Vbe_array,ib_array)
La fonction suivante trace les courbes ic=f(Vce) pour différentes valeurs du courant de base.
def collecteur_emetteur(self,delta_ib,n1):
nb = int(self.Ib_max/delta_ib)
Vce_array = np.zeros(n1)
ic_array = np.zeros(n1)
delta_S1 = self.S1_max/(n1-1)
xlabel("Vce (V)")
ylabel("ic (mA)")
for j in range(1,nb):
ib = j*delta_ib
epsilon = 0.01
self.sortie_s1(self.S1_max)
self.sortie_s0(ib/1000/self.pente)
for k in range(n1):
S1 = k*delta_S1
self.sortie_s1(S1)
[e0,e1,e2,e3] = self.entrees()
Vce = e2
ic = (e3-e2)/self.Rc*1e3
print("Vce = %f, ic = %f"%(Vce,ic))
Vce_array[k] = Vce
ic_array[k] = ic
plot(Vce_array,ic_array,label="ib = "+str(round(ib))+" muA")
4.b. Implémentation pour Labjack U6
Les boitiers de mesure LabJack peuvent être pilotés avec python, aussi bien sur MS Windows que sur Linux. La classe suivante hérite de la classe CaracteristiqueTransistor et définit les fonctions d'entrée-sortie pour le LabJack U6. Les tensions maximales pour les sorties sont de 5 volts. Lorsque les tensions lues en entrée présentent du bruit, il faut effectuer une moyenne sur plusieurs mesures. Ici 20 mesures sont faites pour obtenir une valeur.
from CaracteristiqueTransistor import CaracteristiqueTransistor
import u6
class TransistorLabjack(CaracteristiqueTransistor):
def __init__(self,pente,Ib_max,Rc):
CaracteristiqueTransistor.__init__(self,pente,Ib_max,Rc,5.0,5.0)
self.u6 = u6.U6()
self.np = 20
def fermer(self):
self.u6.close()
def sortie_s0(self,S0):
self.u6.writeRegister(5000,S0)
def sortie_s1(self,S1):
self.u6.writeRegister(5002,S1)
def entrees(self):
v = [0.0,0.0,0.0,0.0]
for k in range(self.np):
for i in range(4):
v[i] += self.u6.getAIN(i)
time.sleep(0.001)
return [v[0]/self.np,v[1]/self.np,v[2]/self.np,v[3]/self.np]
4.c. Implémentation pour SysamSP5
Le boitier de conversion Eurosmart SysamSP5 comporte deux sorties de convertisseur numérique-analogique, qui délivrent des tensions entre -10 et +10 volts. L'interface pour python est présentée dans CAN Eurosmart : interface pour python..
La classe suivante est dans le fichier caracteristiqueTransistorSP5.py.
from CaracteristiqueTransistor import CaracteristiqueTransistor
import pycan.main as pycan
class CaracteristiqueTransistorSP5(CaracteristiqueTransistor):
def __init__(self,pente,Ib_max,Rc,Rc):
CaracteristiqueTransistor.__init__(self,pente,Ib_max,Rc,10.0,10.0)
self.sp5 = pycan.Sysam("SP5")
self.sp5.config_entrees([0,1,2,3],[10.0,10.0,10.0,10.0])
self.sp5.activer_lecture([0,1,2,3])
self.np = 20
def fermer(self):
self.sp5.fermer()
def sortie_s0(self,S0):
self.sp5.ecrire(1,S0,0,0)
def sortie_s1(self,S1):
self.sp5.ecrire(0,0,1,S1)
def entrees(self):
v = [0.0,0.0,0.0,0.0]
for k in range(self.np):
u = self.sp5.lire()
for i in range(4):
v[i] += u[i]
time.sleep(0.001)
return [v[0]/self.np,v[1]/self.np,v[2]/self.np,v[3]/self.np]
5. Exemples
Le boitier Labjack U6 est utilisé. La résistance de collecteur est RC=100 Ω.
Le premier transistor étudié est un BC548, transistor de faible puissance pour l'amplification.
from matplotlib.pyplot import *
transistor = TransistorLabjack(pente,100.0,100)
figure(figsize=(10,6))
transistor.base_emetteur(100)
axis([0,1.0,-10,100])
title("BC548")
grid()
figA.pdf
figure(figsize=(10,6))
transistor.collecteur_emetteur(10.0,100)
axis([0,8,-5,30])
legend(loc="upper right")
title("BC548")
grid()
figB.pdf
La zone de fonctionnement pour Vce<0.25 V présente une forte augmentation du courant de collecteur : c'est la zone de saturation. Pour Vce>0.25 V, on est dans la zone de fonctionnement linéaire.
Pour balayer des valeurs de tension plus grandes, il faut augmenter la valeur maximale S1max. Cela peut se faire en plaçant un amplificateur de tension non inverseur en sortie du convertisseur (au lieu d'un simple suiveur).
transistor.fermer()
Le second exemple est un 2N2222, transistor utilisé plutôt pour la commutation.
from matplotlib.pyplot import *
transistor = TransistorLabjack(pente,100.0,100)
figure(figsize=(10,6))
transistor.base_emetteur(100)
axis([0,1.0,-10,100])
title("2N2222")
grid()
figC.pdf
figure(figsize=(10,6))
transistor.collecteur_emetteur(10.0,100)
axis([0,8,-5,30])
legend(loc="upper right")
title("2N2222")
grid()
figD.pdf
