Table des matières Python

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.

figureA.svgFigure pleine page

La 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) :

figureB.svgFigure pleine page

Le 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()
            
plotA.svgFigure pleine page

La 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.

CaracteristiqueTransistor.py
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()
            
figAfigA.pdf
figure(figsize=(10,6))
transistor.collecteur_emetteur(10.0,100)
axis([0,8,-5,30])
legend(loc="upper right")
title("BC548")
grid()
            
figBfigB.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()
            
figCfigC.pdf
figure(figsize=(10,6))
transistor.collecteur_emetteur(10.0,100)
axis([0,8,-5,30])
legend(loc="upper right")
title("2N2222")
grid()
            
figDfigD.pdf
Creative Commons LicenseTextes et figures sont mis à disposition sous contrat Creative Commons.