Rasp-Hack-L298-Python

De MCHobby - Wiki
Aller à : navigation, rechercher

MCHobby investit du temps et de l'argent dans la réalisation de traduction et/ou documentation. C'est un travail long et fastidieux réalisé dans l'esprit Open-Source... donc gratuit et librement accessible.
SI vous aimez nos traductions et documentations ALORS aidez nous à en produire plus en achetant vos produits chez MCHobby.

Test

Le programme de test ZumoL298.py (voyez plus bas) reprend les quelques fonctions de tests suivantes:

	Avant()
	time.sleep( 5 )
	TournerDroite()
	time.sleep( 3 )
	Avant()
	time.sleep( 5 )
	TournerGauche()
	time.sleep( 3 )
	Arriere()
	time.sleep( 5 )
	Stop()

faisant respectivement les opérations suivantes: passer en marche avant, faire attendre le programme 5 secondes (pendant que la marche avant se poursuit), Touner à droite pendant 3 secondes, repasser en marche pendant 5 secondes, tournez à gauchhe pendant 3 secondes, passer en marche arrière pendant 5 seconde puis s'arrêter.

Ce qui produit le résultat suivant:


Cliquez ici pour accéder directement à la vidéo (YouTube)

Le code Complet

Voici le code au complet... que vous trouverez également dans ce fichier ZumoL298.py.

A la base, ce code est développé pour piloter un chassis Zumo avec un L298 et un Raspberry-Pi mais fonctionne également parfaitement avec de nombreux autres plateformes robotiques (voyez la vidéo en fin de tuto)

#!/usr/bin/env python
# -*- coding: latin-1 -*-

# ----------------------------------------------------------------------
#  ZumoL298.py - Contrôle d'un Pont-H L298 avec Raspberry-Pi
#  
#  Tutoriel complet: 
#     http://wiki.mchobby.be/index.php?title=Rasp-Hack-L298 
#
#  Initialement conçu pour le chassis Zumo 
#     http://shop.mchobby.be/product.php?id_product=447
#  Mais fonctionne parfaitement avec de nombreuses plateformes(cfr tuto)
# ----------------------------------------------------------------------
#  Ecrit par Meurisse D. pour MCHobby.be ( shop.mchobby.be )
#  Licence: CC-BY-SA  - MCHobby.be vente de kit et composant
# ----------------------------------------------------------------------

import RPi.GPIO as GPIO
import time
import sys

GPIO.setmode(GPIO.BCM)

#--- Cablage --------------------
MOTORA_IN1 = 25 # GPIO 25
MOTORA_IN2 = 24 # GPIO 24
MOTORA_ENABLE = 4 # GPIO 4 - Activation moteur A
MOTORB_IN3 = 23 # GPIO 23
MOTORB_IN4 = 18 # GPIO 18
MOTORB_ENABLE = MOTORA_ENABLE # aussi utiliser GPIO 4 pour commander moteur B

#--- Initialisation -------------
# GPIO.setwarnings(FALSE)
GPIO.setmode(GPIO.BCM)
GPIO.setup( MOTORA_IN1, GPIO.OUT )
GPIO.setup( MOTORA_IN2, GPIO.OUT )
GPIO.setup( MOTORB_IN3, GPIO.OUT )
GPIO.setup( MOTORB_IN4, GPIO.OUT )
GPIO.setup( MOTORA_ENABLE, GPIO.OUT )
if( MOTORB_ENABLE != MOTORA_ENABLE ):
	GPIO.setup( MOTORB_ENABLE, GPIO.OUT )

# Assure l'arret moteur
GPIO.setup( MOTORA_ENABLE, GPIO.LOW )
if( MOTORB_ENABLE != MOTORA_ENABLE ):
	GPIO.setup( MOTORB_ENABLE, GPIO.LOW )

# --- Controle du L298 --------------------------
# Sens de rotation du moteur
SENS_AVANT = 1
SENS_ARRIERE = 2
SENS_ARRET = 3

def Desactiver():
	""" Désactivation des pont-H """
	GPIO.output( MOTORA_ENABLE, GPIO.LOW )
	if( MOTORB_ENABLE != MOTORA_ENABLE ):
		GPIO.output( MOTORB_ENABLE, GPIO.LOW )

def Activer():
	""" Activation des pont-H """
	GPIO.output( MOTORA_ENABLE, GPIO.HIGH )
	if( MOTORB_ENABLE != MOTORA_ENABLE ):
		GPIO.output( MOTORB_ENABLE, GPIO.HIGH )

def MarcheMotorA( sens ):
	""" Controle le sens de Marche pour Moteur A """
	if( sens == SENS_AVANT ):
		GPIO.output( MOTORA_IN1, GPIO.HIGH )
		GPIO.output( MOTORA_IN2, GPIO.LOW )
	elif( sens == SENS_ARRIERE ):
		GPIO.output( MOTORA_IN1, GPIO.LOW )
		GPIO.output( MOTORA_IN2, GPIO.HIGH )
	elif( sens == SENS_ARRET ):
		GPIO.output( MOTORA_IN1, GPIO.LOW )
		GPIO.output( MOTORA_IN2, GPIO.LOW )

def MarcheMotorB( sens ):
	"""Controle le sens de Marche pour Moteur B """
	if( sens == SENS_AVANT ):
		GPIO.output( MOTORB_IN3, GPIO.HIGH )
		GPIO.output( MOTORB_IN4, GPIO.LOW )
	elif( sens == SENS_ARRIERE ):
		GPIO.output( MOTORB_IN3, GPIO.LOW )
		GPIO.output( MOTORB_IN4, GPIO.HIGH )
	elif( sens == SENS_ARRET ):
		GPIO.output( MOTORB_IN3, GPIO.LOW )
		GPIO.output( MOTORB_IN4, GPIO.LOW ) 

def Avant():
	""" Marche avant toute """
	print( "Marche Avant" )
	Desactiver()
	MarcheMotorA( SENS_AVANT )
	MarcheMotorB( SENS_AVANT )
	Activer()

def Arriere():
	""" Marche arrière toute """
	print( "Marche Arrière" )
	Desactiver()
	MarcheMotorA( SENS_ARRIERE )
	MarcheMotorB( SENS_ARRIERE )
	Activer()

def TournerDroite():
	""" Fait tourner à droite """
	print( "Tourner à droite" )
	Desactiver()
	MarcheMotorA( SENS_ARRIERE )
	MarcheMotorB( SENS_AVANT )
	Activer()

def TournerGauche():
	""" Fait tourner a gauche """
	print( "Tourner à gauche" )
	Desactiver()
	MarcheMotorA( SENS_AVANT )
	MarcheMotorB( SENS_ARRIERE )
	Activer()
		
def Stop():
	""" Arret """
	print( "Arret" )
	Desactiver()
	MarcheMotorA( SENS_ARRET )
	MarcheMotorB( SENS_ARRET )
	Activer()

if __name__ == '__main__':
	Avant()
	time.sleep( 5 )
	TournerDroite()
	time.sleep( 3 )
	Avant()
	time.sleep( 5 )
	TournerGauche()
	time.sleep( 3 )
	Arriere()
	time.sleep( 5 )
	Stop()

Exécuter le programme

Pour exécuter le script python, n'oubliez pas d'activer le flag (drapeau) d'exécution sur le fichier

chmod +x ZumoL298.py

Vous pourrez ensuite l'exécuter à l'aide de la commande

sudo ./ZumoL298.py

Sudo étant nécessaire pour permettre au script d'accéder librement au GPIO du Pi.

Comprendre le code

Voici quelques explications permettant de comprendre le fonctionnement interne du code. Nous allons donc nous penchez sur le contenu de la fonction Avant().

Une astuce technique

Avant de nous lancer dans le décorticage du code, nous allons nous attarder sur une petite astuce dont le but est d'économiser une broche du GPIO sur le Raspberry Pi.

Comme vous le noterez sur le montage, les broches ENA et ENB du pont-H sont raccordées sur la même broche GPIO.

Rasp-Hack L298-Wiring-00.jpg

ENA et ENB (EnableA et EnableB) servent respectivement à activer le Pont-H du monteur 1 (MotorA) et du moteur 2 (MotorB).

Nous avons délibérément choisit de commander les deux en même temps...

  • soit ils sont activés et bougent tous les deux (GPIO 4=ENA=ENB=HIGH)
  • soit ils sont désactivés et ne bougent pas (GPIO 4=ENA=ENB=LOW).

Notez que le sens de rotation (ou non rotation) d'un moteur activé dépend aussi de la configuration IN1,IN2 - IN3,IN4.

Inconvénient:

  • Il n'est pas possible de réaliser un virage avec une belle courbe (ce qui peut être obtenu en ralentissant un moteur par rapport à l'autre)

Avantages:

  • N'utilise qu'une broche du Raspberry-Pi pour activer les deux moteurs.
  • Permet de tourner sur place (ex: moteur droit en marche avant + moteur gauche en marche arrière puis activer les pont-H).
    Pratique pour un système à chenille ;-) mais aussi fonctionnel avec un robot sur roue.
  • Permet de moduler la vitesses des deux moteurs en appliquant un signal PWM sur la broche GPIO 4.
    Nécessite une modification de notre code d'exemple.

Fonction Avant()

def Avant():
	""" Marche avant toute """
	print( "Marche Avant" )
	Desactiver()
	MarcheMotorA( SENS_AVANT )
	MarcheMotorB( SENS_AVANT )
	Activer()

La fonction Avant() effectue les tâches suivantes:

  1. Desactiver() - Désactive les deux Pont-H (ENA=ENB=LOW), ce qui permet de modifier les signaux de commande IN1, IN2, IN3, IN4 en toute sérénité
  2. MarcheMotorA( SENS_AVANT ) - Active le sens de marche avant sur le premier moteur.
  3. MarcheMotorB( SENS_AVANT ) - Active le sens de marche avant sur le deuxième moteur.
  4. Activer() - Réactive les pont-H (ENA=ENB=HIGH)... ce qui active la marche avant

Fonction MarcheMotorA( sens )

Le seul but de cette fonction est de configurer l'état des broches IN1 et IN2 pour contrôler le sens de rotation du premier moteur (MotorA). Il ne restera plus qu'a activer le pont-H du moteur A pour que celui-ci tourne.

Elle accepte 3 sens de rotation:

  • SENS_AVANT - pour la marche avant
  • SENS_ARRIERE - pour la marche arrière
  • SENS_ARRET - pour que le moteur ne bouge plus (même si le pont H est réactivé)
def MarcheMotorA( sens ):
	""" Controle le sens de Marche pour Moteur A """
	if( sens == SENS_AVANT ):
		GPIO.output( MOTORA_IN1, GPIO.HIGH )
		GPIO.output( MOTORA_IN2, GPIO.LOW )
	elif( sens == SENS_ARRIERE ):
		GPIO.output( MOTORA_IN1, GPIO.LOW )
		GPIO.output( MOTORA_IN2, GPIO.HIGH )
	elif( sens == SENS_ARRET ):
		GPIO.output( MOTORA_IN1, GPIO.LOW )
		GPIO.output( MOTORA_IN2, GPIO.LOW ) 

Pas bien compliqué en fin de compte.

Fonction Activer(), Desactiver

Déjà mentionné plus haut, ces fonctions active et désactive les pont-H en manipulant le GPIO 4.

Le programme défini les constantes:

MOTORA_ENABLE = 4 # GPIO 4 - Activation moteur A
MOTORB_ENABLE = MOTORA_ENABLE # aussi utiliser GPIO 4 pour commander moteur B

A noter que les fonctions sont déjà prévue pour utiliser deux GPIO différents pour les signaux ENA et ENB du pont H, vous pourriez alors utiliser la définition suivante si vous en aviez besoin:

MOTORA_ENABLE = 4 # GPIO 4 - Activation moteur A
MOTORB_ENABLE = 22 # utiliser GPIO 22 pour commander le moteur B
def Desactiver():
	""" Désactivation des pont-H """
	GPIO.output( MOTORA_ENABLE, GPIO.LOW )
	if( MOTORB_ENABLE != MOTORA_ENABLE ):
		GPIO.output( MOTORB_ENABLE, GPIO.LOW )

def Activer():
	""" Activation des pont-H """
	GPIO.output( MOTORA_ENABLE, GPIO.HIGH )
	if( MOTORB_ENABLE != MOTORA_ENABLE ):
		GPIO.output( MOTORB_ENABLE, GPIO.HIGH )

Réalisée par Meurisse D pour MCHobby.be.

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.