Hack-micropython-L293D

Préambule

Le but de cette fiche est de vous initié à la mise en oeuvre des ponts-H.
Le plus populaire est le L293D, Pont-H de puissance moyenne (600mA) pouvant être utilisé à partir de n'importe quel microcontroleur.

Introduction

Il est possible d'activer la rotation d'un moteur à l'aide d'un relais ou d'un transistor.
L'inconvénient de l'option transistor (ou relais) est qu'il n'est possible de facilement contrôler le sens de rotation du moteur.

Certes, il est possible de concevoir un montage à base des relais permettant de réaliser un inverseur pour inverser la polarisation aux bornes du moteur.
Si cette option est techniquement réalisable et efficace, elle n'est ni élégante, ni économe en énergie et ne permet en aucun cas de contrôler la vitesse du moteur (à l'aide d'un signal PWM).

La solution réside dans l'utilisation d'un pont H. composant constitué de plusieurs transistors mais vendu pré-assemblé sous forme de circuit intégré.

Le pont H - Principe

Dans son principe de base, le pont H est un assemblage de 4 transistors (2 PNP et 2 NPN) monté de telle façon que le courant puisse passer soit dans un sens, soit dans l'autre au travers de la charge (un moteur continu par exemple).
En inversant le sens du courant dans le moteur, ce dernier changera de sens de rotation.

Source: Wikipedia

Dans le dessins ci-dessous, il est clairement visible que le moteur fonctionne dans un sens si Q3 et Q2 sont commutés

ET dans l'autre sens Q1 et Q4 sont commutés.

Attention au court-circuit !

Bien évidemment, ni Q3 et Q1, ni Q4 et Q2 ne peuvent jamais être commutés en même temps car cela provoque un court-circuit franc, qui qui détruirait probablement le pont-H, voir le module de régulation de l'alimentation.

Diodes anti-retour

Comme déjà précisé, un pont-H est constitué de transistors (symbolisés par des interrupteurs dans nos schémas de principe).

En règle générale, lorsque l'on utilise des relais ou moteurs avec un transistor, il faut protéger le transistor à avec une diode anti-retour.

La diode à pour but de renvoyer à la masse les surtensions induites par les effets transitoires (lors du déclenchement du bobinage d'un relais... ou bobinage du moteur).
Sans cette diode anti-retour (aussi dite "en roue libre"), le transistor ne survit pas bien longtemps.

Un pont-H étant constitué de transistor et un moteur étant le siège d'effets transitoire, les différents transistors doivent être protégés à l'aide de diode. Le schéma ci-dessous indique comment ces diodes sont placées sur le pont-H.

L293D et ses diodes anti-retour

Cet article se focalise sur le pont-H L293D.
Le L293D à la particularité de déjà contenir les diodes anti-retour.

Disposer des diodes à même le L293D est un avantage indéniable pour démarrer rapidement un projet.
Faite cependant attention, tous les Pont-H n'en sont pas équipés (ex: le L298 n'a pas de diode anti-retour)

Les pont-H et ses sources d'alimentation

A la base, un circuit pont-H est conçu pour pouvoir dissocier la logique de commande (basse tension) du circuit de puissance.

C'est super génial... parce qu'avec notre MicroPython, les 3.3V présente une tension bien trop basse pour propulser un moteur. Il faut donc pouvoir alimenter nos moteur avec une source d'alimentation de puissance.

Un pont-H dispose donc de deux sources d'alimentations:

1. Une source d'alimentation pour la logique du circuit. Elle est nommée VSS et nécessite généralement 5 Volts (Le minimum est 5V, le maximum est 36V).
2. Une source d'alimentation pour les moteurs. Elle est nommée VS et tolère des tensions nettement plus élevée (max 36V) que la source de tension VSS (logique de commande).

La masse est commune aux deux circuits.

Lorsque deux sources de tension sont utilisées il faut raccorder ensemble la masse (GND) de Pyboard et celle de l'alimentation externe.

Les masses doivent être commune entre les alimentations (de la PyBoard et du Pont-H).

Cette double source d'alimentation permet, par exemple, de commander des moteurs 12 Volts (VS=12v) à partir d'un microcontrôleur 5V (Logique de commande=VSS=+5v ou plus).

La bonne nouvelle, c'est que les signaux de commande sont compatibles TTL (et uniquement dans le sens microcontrôleur -> pont-H) et que vous pouvez donc commander le pont-H avec un microcontrôleur 3.3v comme Micropython PyBoard.

Dissocier les sources d'alimentation

Pouvoir dissocier VSS de VS ne présente pas seulement l'avantage de pouvoir utiliser des tensions différentes différentes pour la logique de commande et la puissance moteur mais permet surtout d'utiliser une source d'alimentation distincte pour la logique de commande (microcontrôleur + pont-H) et une autre source d'alimentation pour la propulsion moteur.

Bref, quand la tension baisse de trop sur alimentation moteur (parce que les piles sont à plat), votre microcontrôleur reste stable et fonctionnel (parce qu'il dispose de sa propre source d'alimentation).

C'est pas cool ça?

Peak Load / Stall Current

Justement, concernant le courant à fournir aux moteurs, il convient que celui-ci ne dépasse pas le maximum toléré par le pont-H.

Qui dit "courant" dit aussi "dissipation de chaleur". Comme tout composant électronique, le Pont-H choisit à un pouvoir de dissipation limité.

Si le courant est trop important, le pont-H chauffera de trop et rendra l'âme.

Pour vous aider dans votre démarche, les fiches technique des moteurs reprennent souvent une caractéristique nommée "peak load" (courant de pointe). Ce courant correspond à la charge maximale supportée par le moteur.

Une autre caractéristique moteur est le "stall current" qui correspond au courant de blocage, celui qui travers le moteur lorsque le son axe est bloqué! (ex: votre robot ne sait pas encore qu'il ne passera pas a travers le mur!). Ce courant de blocage est très important par rapport au courant de fonctionnement normal du moteur... suffisant important pour détruire un pont-H.

Présentation du L293D

Le L293D est un double pont-H, ce qui signifie qu'il est possible de l'utiliser pour commander quatre moteurs distincts (dans un seul sens) grâce à ses 4 canaux.
En raccordant les sorties de façon appropriées, il est possible de constituer deux pont-h qui permettent également de commande deux moteurs distincts, dans les deux sens et indépendamment l'un de l'autre.

“Le L293D un circuit intégré monolitique, à haut voltage, grand courant et 4 canaux.” Cela veut dire que ce circuit intégré peut être utilisé pour des moteurs DC alimentés jusqu'à 36 Volts (ce sont déjà des jolis petits moteurs). Le circuit peut fournir un maximum de 600mA par canal. Le L293D est aussi connu pour être un excellent Pont-H facile à mettre en pratique.

Avec deux signaux de commande Input 1 et Input 2 fournit par PyBoard (nous laissons volontairement Enable de côté, nous en parlerons un peu plus loin), il est possible d'inverser la direction du courant dans le pont-H et donc renverser le sens de rotation du moteur qui y est raccordé.
En utilisant différentes combinaisons de Input 1 et input 2 il devient possible de démarrer, Stopper ou Inverser le courant.

Brochage

Ci-dessous la configuration des broches du L293D et la table de la logique de commande.

Broche	Nom	Description
1	Enable 1	permet d'envoyer (ou pas) la tension sur les sorties du moteur via OUTPUT1 & OUTPUT2. ENABLE1 commande l'activation/désactivation du premier Pont-H. Si ENABLE1 = GND, le pont-H est déconnecté et le moteur ne fonctionne pas. Si ENABLE1 = VSS, le pont-H est connecté aux sorties et le moteur fonctionne dans un sens ou l'autre ou pas en fonction des tensions appliquée sur INPUT1 & INPUT2.
2	Input 1	Avec Input 2, sont les broches de commande du Pont-H Output1/Output2. Se raccorde a Arduino, permet de commander le sens du courant entre Output 1 et Output 2.
3	Output 1	Avec Output 2, seront les broches à raccorder à la charge (le moteur).
4	GND	Doit être raccorder à la masse (GND) de la source d'alimentation de puissance VS (ex: la borne négative de l'accumulateur +9.2v) et à la masse de la source d'alimentation de la logique "VSS" (donc GND Arduino). Si vous n'avez qu'une source d'alimentation pour le tout, c'est forcement plus simple.
5	GND
6	Output 2	Avec Output 1, seront les broches à raccorder à la charge (le moteur).
7	Input 2	Avec Input 1, sont les broches de commande du Pont-H Output1/Output2. Se raccorde a Arduino, permet de commander le sens du courant entre Output 1 et Output 2.
8	VS	Alimentation de puissance des moteurs. Par exemple, s'il s'agit d'une ancien véhicule téléguidé transformé, il s'agira de la borne positive de l'accumulateur (souvent +9.2v).
9	Enable 2	Commande l'activation du second pont-H constitué de Output3/Output4
10	Input 3	A utiliser conjointement avec Input 4 pour commander le pont-H Output3/Output4.
11	Output 3	Constitue une des deux sorties du second pont-H (Output3/Output4)
12	GND
13	GND
14	Output 4	Constitue une des deux sorties du second pont-H (Output3/Output4)
15	Input 4	A utiliser conjointement avec Input 3 pour commander le pont-H Output3/Output4.
16	VSS	Alimentation de la logique de commande (5V). A raccorder à la borne +5V d'Arduino (donc sur le régulateur d'Arduino).

Plus d'information dans la datasheet du L293D

Caractéristiques

Caractéristique	Valeur
Nbre de pont-H	2
Courant Max Régime continu	600mA ( x2 )
Courant de pointeMax < 2ms	1200mA
VS Max Alim moteur	36v
VSS Max Alim logique	7v
Nbre de Broche	16 DIP
Perte de tension	1.3 à 1.4v (typical)

Importance des broches "Enable"

Le premier pont-H est commandé par les broches Input 1 et Input 2 qui servent à indiquer le sens de passage du courant (donc le sens de rotation du moteur).

ENABLE 1 offre l'avantage de pouvoir moduler la vitesse du moteur en y appliquant un train d'onde PWM.
Il est ainsi possible de commander assez finement la vitesse d'un moteur DC avec 3 broches Arduino (sortie PWM).
La broche Enable 1 activera/désactivera le pont-H à la vitesse du signal PWM... et donc commandera le moteur par un train d'impulsion.

La broche ENABLE1 est raccordée à VSS si l'on ne désire pas réguler la vitesse du moteur.

Logique de commande Input

Enable 1	Input 1	Input 2	Fonction
High	Low	High	Tourne dans le sens horlogique
High	High	Low	tourne dans le sens anti-horlogique
High	Low	Low	Stop
High	High	High	Stop
Low	Non applicable	Non applicable	Stop
Low	Low	High	Stop! même si configuré pour tourner dans le sens horlogique
Low	High	Low	Stop! même si configuré pour tourner dans le sens anti-horlogique

Capacités de découplages

Lorsque l'on commande des moteurs, il est préférable d'utiliser quelques capactités dans votre circuit pour réguler, autant que possible, la puissance de charge aux moteurs et ainsi de stabiliser la tension en évitant les pointes de courant.

Si votre moteur est alimenté par Arduino et qu'Arduino reboot au démarrage du moteur, c'est que l'appel de courant (du moteur) est tellement élevé qu'il fait trop chuter la tension.
Il y a moyen de remédier à ce problème en plaçant une capacité qui fournira le surcroît d'énergie nécessaire au démarrage du moteur.

Une capacité de 10 microFarad sur la source d'alimentation est une valeur minimale.
A diverse occasion, j'ai eu l'occasion d'utiliser une capacité polarisée de 33µF ou 47µF.

Le montage présenté ci-dessous utilise d'ailleurs une capacité de 47µF.

Déparasitage moteur

Voici une petite astuce complémentaire déjà remarquée sur différentes voitures télécommandées.
La direction de voiture télécommandée est généralement contrôlée à l'aide d'un simple moteur DC.
Ces moteurs disposent généralement de capacités de déparasitages - des capacités ceramique 220nF multi-couche devrait être bon pour de petits moteurs.

Voici le schéma d'un tel montage:

Montage PyBoard

Une seule source d'alimentation

Dans l'exemple ci-dessous, nous allons utiliser un bloc-pile 4x1.5V (soit 6Volts) pour commander les moteurs (VSS) et la logique du L293D (VS).

Nous avons également ajouté un petit switch qui permet d'alimenter directement votre PyBoard (via Vin) avec le bloc-pile lorsque celui-ci n'est pas branché sur votre ordinateur (via la port USB).

Le montage utiliser plusieurs capacités de 200nF pour le découplage (et 47µF pour stabiliser l'alimentation).

Le moteur de droite est commandé comme suit:

• Input 1 = X6
• Input 2 = x5
• Enable 1 = X3 (pour signal PWM)

Le moteur de gauche est commandé comme suit:

• Input 3 = X7
• Input 4 = x8
• Enable 2 = X4 (pour signal PWM)

Classe HBridge

Voici le contenu de la classe HBridge qui permet de commander l'un des deux pont-H du L293D avec... en prime... le contrôle de la vitesse en PWM.

Relativement simple, vous pourrez efficacement commander vos deux moteurs (voyez les différent exemples proposés)

# Commande d'un pont-H L293D à l'aide de MicroPython PyBoard
#   http://shop.mchobby.be/product.php?id_product=155
# Voir Tutoriel 
#   http://wiki.mchobby.be/index.php?title=Hack-micropython-L293D
#
from pyb import delay, Timer

class HBridge:
    """ Control à H-Bridge. Also support PWM to control the speed (between 0 to 100%) """
    PWM_FREQ = 100  # Frequency 100 Hz
    (UNDEFINED,HALT,FORWARD,BACKWARD) = (-1, 0,1,2)

    def __init__( self, input_pins, pwm = None ):
        """:param input_pins: tuple with input1 and input 2 pins
           :param pwm: dic with pin, timer and channel """
        self.speed = 0
        self.state = HBridge.UNDEFINED
        
        # Init HBridge control pins
        self.p_input1 = pyb.Pin( input_pins[0], pyb.Pin.OUT_PP )
        self.p_input2 = pyb.Pin( input_pins[1], pyb.Pin.OUT_PP )

        # Init PWM Control for speed control (without PWM, the L293D's
        #   Enable pin must be place to HIGH level)
        self.has_pwm = (pwm != None)
        if self.has_pwm: 
            self._timer = pyb.Timer( pwm['timer'], freq=self.PWM_FREQ )
            self._channel = self._timer.channel( pwm['channel'], Timer.PWM, pin=pwm['pin'], pulse_width_percent=100 )

        self.halt()

    def set_speed( self, speed ):
        if not(0 <= speed <= 100):
            raise ValueError( 'invalid speed' )
        # Use PWM speed ?
        if self.has_pwm:
            self._channel.pulse_width_percent( speed )
            self.speed = speed
        else:
            # Non PWM
            self.speed = 0 if speed == 0 else 100
            if self.speed == 0 and self.state != HBridge.HALT:
                self.halt() # force motor to stop by manipulating input1 & input2
                
    
    def halt( self ):
        self.p_input1.low()
        self.p_input2.low()
        self.state = HBridge.HALT # Do not invert ...
        self.set_speed( 0 )       #    thoses 2 lines

    def forward(self, speed = 100 ):
        # reconfigure HBridge
        if self.state != HBridge.FORWARD :
            self.halt()
            self.p_input1.low()
            self.p_input2.high()
            self.state = HBridge.FORWARD
        # Set speed
        self.set_speed( speed )
        
    def backward(self, speed = 100 ):
        # reconfigure HBridge
        if self.state != HBridge.BACKWARD:
            self.halt()
            self.p_input1.high()
            self.p_input2.low()
            self.state = HBridge.BACKWARD
        # Set speed 
        self.set_speed( speed )
        

# Pont-H broches de commande Input 1 et Input 2
MOT1_PINS = ( pyb.Pin.board.X6, pyb.Pin.board.X5 )
# Commande PWM pont-H
MOT1_PWM = {'pin' : pyb.Pin.board.X3, 'timer' : 2, 'channel' : 3 }   

# Pont-H broches de commande Input 3 et Input 4
MOT2_PINS = ( pyb.Pin.board.X7, pyb.Pin.board.X8 )
# Commande PWM pont-H
MOT2_PWM = {'pin' : pyb.Pin.board.X4, 'timer' : 5, 'channel' : 4 }        

def test_bridge1_simple():
    """ Simply test the HBridge without speed control """
    h1 = HBridge( MOT1_PINS )
    print( "Forward" )
    h1.forward()
    delay( 3000 )
    print( "Halt" )
    h1.halt()
    delay( 3000 )
    print( "Backward" )
    h1.backward()
    delay( 3000 )
    print( "Halt" )
    h1.halt()
    print( "end." )

def test_bridge1_speed():
    """ Test the HBridge without speed control """
    h1 = HBridge( MOT1_PINS, MOT1_PWM )
    print( "Forward full speed" )
    h1.forward()
    delay( 3000 ) 
    print( "Forward half speed 50%" )
    h1.forward( 50 )
    delay( 3000 )
    print( "Forward 30% speed" )
    h1.forward( 30 )
    delay( 3000 )
    for the_speed in range( 10, 70, 10 ):
        print( "Backward at speed %i" % (100-the_speed) )
        h1.backward( 100-the_speed )
        delay( 1500 )
    h1.halt()

def test_two_bridges():
    """ Test the two H-Bridges of the L293D """
    h1 = HBridge( MOT1_PINS, MOT1_PWM )
    h2 = HBridge( MOT2_PINS, MOT2_PWM )
    # move the 2 motors forwards
    h1.forward( 70 )
    h2.forward( 70 )
    delay( 3000 )
    # Stop the 2 motors
    h1.halt()
    h2.halt()

def test_bridge2_simple():
    """ Test the two H-Bridges of the L293D """
    h2 = HBridge( MOT2_PINS )#, MOT2_PWM )
    print( "Forward full speed" )
    h2.forward()
    delay( 3000 )
    print( "Halt" )
    h2.halt()


test_bridge1_simple()
# test_bridge2_simple()
# test_bridge1_speed()  
# test_two_bridges()

Deux sources d'alimentation

Il est possible d'alimenter le moteur avec sa propre source de tension séparée de la source d'alimentation de la logique de contrôle (PyBoard et logique de contrôle du L293D).

...nous augmenterons cette partie du tutoriel dès que possible'...

Ou Acheter

Les produits suivants sont disponibles chez MC Hobby.

• Le L293D
• Le Moteur DC Hobbyiste
• Le Kit ARDX

Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : «  Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.

L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.