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

Les tensions S₀ et S₁ sont fournies par deux sorties de conversion numérique-analogique. Un suiveur à amplificateur opérationnel (non représenté) est placé entre chaque sortie et le circuit. Les 4 entrées de conversion analogique-numériques E₀,E₁,E₂,E₃ sont branchées comme indiqué sur la figure. On obtient ainsi le courant de base, la tension base-émetteur, le courant de collecteur et la tension collecteur-émetteur :

\begin{matrix} i_{b} = \frac{E_{1} - E_{0}}{R_{B}} \\ V_{b e} = E_{0} \\ i_{c} = \frac{E_{3} - E_{2}}{R_{C}} \\ V_{c e} = E_{2} \end{matrix}

Les tensions S₀ et S₁ varient entre 0 et respectivement S₀^max et S₁^max. La résistance R_B sert à polariser la jonction base-émetteur. Elle doit être choisie en fonction de S₀^max et du courant i_b^max souhaité (typiquement une centaine de micro-ampères). La résistance R_C doit être choisie en fonction de S₁^max et du courant i_c^max souhaité.

La première courbe à obtenir est i_b=f(V_be), qui dépend de la tension collecteur-émetteur V_ce. Lorsque V_ce est assez grande (typiquement quelques dizaines de volts), cette courbe ne dépend plus de V_ce : c'est la zone de fonctionnement linéaire du transistor. En fixant le courant de base i_b (dans la zone linéaire), on obtient une courbe i_c=g(V_ce). Il s'agit donc d'obtenir plusieurs courbes pour différents courants de base.

3. Programme de commande

3.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é.

La classe est dans le fichier CaracteristiqueTransistor.py.

import time
import numpy as np
from matplotlib.pyplot import *

class CaracteristiqueTransistor:
    def __init__(self,Rb,Rc,S0_max,S1_max):
        self.Rb = Rb
        self.Rc = Rc
        self.S0_max = S0_max
        self.S1_max = S1_max
        self.delai = 0.01
    def sortie_s0(self,S0):
        pass
    def sortie_s1(self,S1):
        pass
    def entree_e0(self):
        return 0.0
    def entree_e1(self):
        return 0.0
    def entree_e2(self):
        return 0.0
    def entree_e3(self):
        return 0.0

La fonction suivante permet d'obtenir le courant de base (en micro-ampères) pour une tension S₀ donnée :

    def i_base(self,s0):
        self.sortie_s0(s0)
        time.sleep(self.delai)
        e0 = self.entree_e0()
        e1 = self.entree_e1()
        ib = (e1-e0)/self.Rb*1e6
        return ib

La fonction suivante ajuste la tension S₀ pour obtenir un courant de base donné. Elle effectue une recherche de racine avec une tolérance epsilon, en utilisant la méthode de bissection (ou méthode de dichotomie).

    def reglage_ib(self,ib,umin,umax,epsilon):
        u1 = umin
        u2 = umax
        u = (u1+u2)/2
        y = self.i_base(u)-ib
        y2 = 1.0
        y1 = -1.0
        while abs(y) > epsilon:
            if y1*y < 0:
                u2 = u
                y2 = y
            else:
                u1 = u
                y1 = y
            u = (u1+u2)/2
            y = self.i_base(u)-ib
        return [u,y+ib]

La fonction suivante effectue le tracé de la caractéristique i_b=f(V_be). La tension S₁ 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_S0 = self.S0_max/(n0-1)
        ib_array = np.zeros(n0)
        Vbe_array = np.zeros(n0)
        self.sortie_s1(self.S1_max)
        for k in range(n0):
            S0 = k*delta_S0
            self.sortie_s0(S0)
            time.sleep(self.delai)
            e0 = self.entree_e0()
            e1 = self.entree_e1()
            Vbe = e0
            ib = (e1-e0)/self.Rb*1e6
            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 i_c=f(V_ce) pour différentes valeurs du courant de base. Comme le montage ne contrôle pas directement le courant de base, on se contente d'ajuster la tension S₀ pour que le courant de base ait la valeur voulue dans la zone de fonctionnement linéaire. La caractéristique obtenue n'est donc à courant de base constant dans la zone de saturation. delta_ib est l'incrément du courant de base, n1 le nombre de points des courbes. Le courant de base est ajusté avec S₁=S₁^max, ce qui assure d'être dans la zone de fonctionnement linéaire.

    def collecteur_emetteur(self,delta_ib,n1):
        ib_max = self.i_base(self.S0_max)
        ib_max = int(ib_max/10)*10
        nb = int(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(nb):
            ib = j*delta_ib
            epsilon = 0.01
            self.sortie_s1(self.S1_max)
            [s0,ib]=self.reglage_ib(ib,0.0,self.S0_max,epsilon)
            print("ib = %f"%ib)
            for k in range(n1):
                S1 = k*delta_S1
                self.sortie_s1(S1)
                time.sleep(self.delai)
                e2 = self.entree_e2()
                e3 = self.entree_e3()
                Vce = e2
                ic = (e3-e2)/self.Rc*1e3
                Vce_array[k] = Vce
                ic_array[k] = ic
            plot(Vce_array,ic_array,label="ib = "+str(round(ib))+" muA")

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

from CaracteristiqueTransistor import CaracteristiqueTransistor
import u6
class TransistorLabjack(CaracteristiqueTransistor):
    def __init__(self,Rb,Rc):
        CaracteristiqueTransistor.__init__(self,Rb,Rc,5.0,5.0)
        self.u6 = u6.U6()
    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 entree_e0(self):
        return self.u6.getAIN(0)
    def entree_e1(self):
        return self.u6.getAIN(1)
    def entree_e2(self):
        return self.u6.getAIN(2)
    def entree_e3(self):
        return self.u6.getAIN(3)

3.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,Rb,Rc):
        CaracteristiqueTransistor.__init__(self,Rb,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])
    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 entree_e0(self):
        x = self.sp5.lire()
        return x[0]
    def entree_e1(self):
        x = self.sp5.lire()
        return x[1]
    def entree_e2(self):
        x = self.sp5.lire()
        return x[2]
    def entree_e3(self):
        x = self.sp5.lire()
        return x[3]

4. Exemples

Le boitier Labjack U6 est utilisé. Les résistances sont R_B=47 kΩ et R_C=100 Ω.

Le premier transistor étudié est un BC548, transistor de faible puissance pour l'amplification.

from matplotlib.pyplot import *

transistor = TransistorLabjack(47000,100)
figure(figsize=(10,6))
transistor.base_emetteur(100)
axis([0,1.0,-10,100])
title("BC548")
grid()

figA.pdf

Lorsque la jonction base-émetteur est passante (V_be>0.6 V), la tension base-émetteur varie très peu (une fraction de volt). Le courant de base

i_{b} = \frac{S_{0} - V_{b e}}{R_{B}} (1)

est donc à peu près fixé par la tension S₀ lorsque celle-ci est de l'ordre de plusieurs volts.

figure(figsize=(10,6))
transistor.collecteur_emetteur(10,100)
axis([0,8,-5,25])
legend(loc="upper right")
title("BC548")
grid()

figB.pdf

La zone de fonctionnement pour V_ce<0.25 V présente une forte augmentation du courant de collecteur : c'est la zone de saturation. Pour V_ce>0.25 V, on est dans la zone de fonctionnement linéaire. Le courant de base qui légende les courbes est le courant de base dans la zone de fonctionnement linéaire. Dans la zone de saturation, le courant de base n'est pas tout à fait constant lorsque S₀ est constante.

Pour balayer des valeurs de tension plus grandes, il faut augmenter la valeur maximale S₁^max. 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(47000,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,100)
axis([0,8,-5,25])
legend(loc="upper right")
title("2N2222")
grid()

figD.pdf

transistor.fermer()