6 – Premiers pas

Schéma de montage

 

 

Quelques explications :

  • J’ai volontairement inversé le sens d’alimentation du moteur 2, puisqu’il est inversé physiquement sur le châssis.
  • J’utilise le régulateur de tension du module pour alimenter la partie logique du L298N. Il est également possible d’utiliser la sortie +5V du Raspberry Pi. Plus d’info ici.
  • Sur le L298N, l’état bas est entre -0.3V et 1.5V, l’état haut entre 2.3V et 7V, ce qui colle bien avec les sorties 3V du Raspberry Pi.
  • J’utilise la numération BCM des broches du Raspberry Pi. Ce guide est très pratique pour s’y retrouver et en savoir plus sur les GPIO.

 

 Raspberry Pi L298N Description
18 ENA Activation du moteur A. Peut être raccordé à une sortie PWM pour contrôler la vitesse de rotation
23 IN1 Sens du moteur A : 3V → Avant / GND → Arrière
24 IN2 Sens du moteur A : GND → Avant / 3V → Arrière
17 ENB Activation du moteur B. Peut être raccordé à une sortie PWM pour contrôler la vitesse de rotation
27 IN3 Sens du moteur B : 3V → Avant / GND → Arrière
22 IN4 Sens du moteur B : GND → Avant / 3V → Arrière
GND GND Pour avoir une masse commune (Sur le Raspberry, peut importe laquelle)
MOTOR A Sortie de puissance sur le moteur A
MOTOR B Sortie de puissance sur le moteur B
VMS/GND À raccorder sur l’alimentation de puissance. Attention au sens, sinon ça chauffe 😉
04 Led ou buzzer

 

Un peu de code

L’idée est d’écouter 3 boutons du contrôleur :

  • Gâchette droite : En avant
  • Gâchette gauche : En arrière
  • Joystick gauche : Rotation sur soi-même

Ces boutons sont analogiques, on peut récupérer une valeur entre 0 et 100%. Si plusieurs boutons sont pressés en même temps, on prend la direction de celui qui a la plus forte intensité.

 

On reprend la même arborescence de fichiers que pour les tests de la manette de xbox :

.
├── lib
│   ├── __init__.py        Vide
│   ├── xbox_read.py       Script de Zephod pour traiter les évenements
└── controller.py          Script principal

 

#!/usr/bin/python
# -*- coding:Utf-8 -*-

import RPi.GPIO as GPIO
import atexit
from lib import xbox_read
import time

# Evenement a la fermeture
def exit_handler():
    print 'Tchao blaireau !'
    gauche_pwm.stop()
    droite_pwm.stop()
    GPIO.output(MOTEUR_GAUCHE_AVANT_PIN, 0)
    GPIO.output(MOTEUR_GAUCHE_ARRIERE_PIN, 0)
    GPIO.output(MOTEUR_DROIT_AVANT_PIN, 0)
    GPIO.output(MOTEUR_DROIT_ARRIERE_PIN, 0)

atexit.register(exit_handler)

#-------------[ CABLAGE ]--------------------

MOTEUR_GAUCHE_PWM_PIN = 18
MOTEUR_GAUCHE_AVANT_PIN = 23
MOTEUR_GAUCHE_ARRIERE_PIN = 24
MOTEUR_DROIT_PWM_PIN = 17
MOTEUR_DROIT_AVANT_PIN = 27
MOTEUR_DROIT_ARRIERE_PIN = 22
LED_PIN = 04

#-------------[ INITIALISATION DES GPIOS ]--------------

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)

# Sens de sortie
GPIO.setup(MOTEUR_GAUCHE_PWM_PIN, GPIO.OUT)
GPIO.setup(MOTEUR_GAUCHE_AVANT_PIN, GPIO.OUT)
GPIO.setup(MOTEUR_GAUCHE_ARRIERE_PIN, GPIO.OUT)
GPIO.setup(MOTEUR_DROIT_PWM_PIN, GPIO.OUT)
GPIO.setup(MOTEUR_DROIT_AVANT_PIN, GPIO.OUT)
GPIO.setup(MOTEUR_DROIT_ARRIERE_PIN, GPIO.OUT)
GPIO.setup(LED_PIN, GPIO.OUT)

# Initialisation des PWM
gauche_pwm = GPIO.PWM(MOTEUR_GAUCHE_PWM_PIN, 100000) # Frequence 1 kHz
gauche_pwm.start(0)

droite_pwm = GPIO.PWM(MOTEUR_DROIT_PWM_PIN, 100000) # Frequence 1 kHz
droite_pwm.start(0)

# On commence en marche avant
GPIO.output(MOTEUR_GAUCHE_AVANT_PIN, 1) # ou GPIO.HIGH ou True
GPIO.output(MOTEUR_GAUCHE_ARRIERE_PIN, 0) # ou GPIO.LOW ou False
GPIO.output(MOTEUR_DROIT_AVANT_PIN, 1)
GPIO.output(MOTEUR_DROIT_ARRIERE_PIN, 0)

#-------------[ FONCTIONS ]---------------

vitesse_gauche_courante = 0
vitesse_droite_courante = 0

# Controle la pwm des moteurs en fonction de gauche et droit (de -100% a 100%)
def piloter_moteurs(gauche, droit):
    global vitesse_gauche_courante
    global vitesse_droite_courante
    
	# Contrôle des GPIOS => Sens des moteurs
    GPIO.output(MOTEUR_GAUCHE_AVANT_PIN, gauche >= 0)
    GPIO.output(MOTEUR_GAUCHE_ARRIERE_PIN, gauche < 0)
    GPIO.output(MOTEUR_DROIT_AVANT_PIN, droit >= 0)
    GPIO.output(MOTEUR_DROIT_ARRIERE_PIN, droit < 0)
    
	# Contrôle de la PWM => Vitesse des moteurs
    vitesse_gauche = float(abs(gauche))
    vitesse_droite = float(abs(droit))
    
    if (vitesse_gauche != vitesse_gauche_courante):
        gauche_pwm.ChangeDutyCycle(vitesse_gauche)
        vitesse_gauche_courante = vitesse_gauche
    
    if (vitesse_droite != vitesse_droite_courante):
        droite_pwm.ChangeDutyCycle(vitesse_droite)
        vitesse_droite_courante = vitesse_droite
        
    
#-------------[ ECOUTE DU CONTROLEUR ]--------------

rt_intensite = 0 # Gachette droite -> Marche avant
lt_intensite = 0 # Gachette gauche -> Marche arriere
x1_intensite = 0 # Joystick gauche -> Rotation

print 'En avant Guingamp !'

# En attente d'evenement du controleur
for event in xbox_read.event_stream(deadzone=12000):
    boutons = ['RT', 'LT', 'X1', 'A']
    
    if event.key in boutons:
        # MAJ des valeurs des boutons
        if event.key == 'RT': # De 0 a 255
            rt_intensite = event.value * 100 / 255 # en %
        
        if event.key == 'LT': # De 0 a 255
            lt_intensite = event.value * 100 / 255 # en %
            
        if event.key == 'X1': # De -32767 a 32767 
            x1_intensite = min(100, max(-100, event.value * 100 / 32767)) # Pour rester entre -100 et 100
                
        if event.key == 'A':
            GPIO.output(LED_PIN, event.value)
            
        # On choisit la direction avec la plus grande valeur
        directions = {
            'avant': rt_intensite,
            'droite': x1_intensite if x1_intensite >= 0 else 0,
            'arriere': lt_intensite,
            'gauche': -x1_intensite if x1_intensite < 0 else 0
        }
        direction = max(directions, key=directions.get)
        
        # On pilote les moteurs
        if direction == 'avant' :
            piloter_moteurs(rt_intensite, rt_intensite)
        if direction == 'droite' :
            piloter_moteurs(x1_intensite, -x1_intensite)
        if direction == 'arriere' :
            piloter_moteurs(-lt_intensite, -lt_intensite)
        if direction == 'gauche' :
            piloter_moteurs(x1_intensite, -x1_intensite)

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *