Les cours du BTS SIO

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Raspberry : utiliser la carte d'extension Motor Shield de SB Components ======
===== Ressources =====
  * Site de SB Component sur le Motot Shield : http://sb-components.co.uk/motor-shield.html
  * schéma de la carte Motor Shield : {{:isn:motor_shield_schematic.pdf|}}
  * Information sur le Pont-H L293D : https://wiki.mchobby.be/index.php?title=Pont-H_L293D

===== Présentation =====
La carte d'extension **Motor Shield** pour Raspberry Pi permet de contrôler : 
  * 4 **moteurs à courant continu** (DC) ou 2 **moteurs pas à pas** en utilisant le **Pont-H** de puissance moyenne (600mA) L293D qui a les caractéristiques et les fonctionnalités suivantes : 
    * fournir un **courant** de sortie jusqu'à **1A** et une tension maximale de **24 V**,
    * réaliser **l'inversion** de la polarisation aux bornes des moteurs,
    * contrôler la **vitesse** du moteur à l'aide d'un **signal PWM**. 
  * 2 **capteurs infrarouge** (IR),
  * un capteur à **ultrasons**.
{{ :isn:motorshield_01.png?nolink |}}

==== Branchement des moteurs ====
{{ :isn:motorshield_02.png?nolink |}}

==== GPIO utilisés pour les moteurs====
^Moteur^PWM^Avancer^Reculer^
|Moteur 1|17|GPIO 27|GPIO 22|
|Moteur 2|25|GPIO 24|GPIO 23|
|Moteur 3|10|GPIO 11|GPIO 09|
|Moteur 4|12|GPIO 07|GPIO 08|

==== GPIO utilisés pour les flèches====
^Flèche^GPIO^
|Avancer|16|
|Reculer|19|
|Droite|13|
|Gauche|26|
==== GPIO utilisés pour les capteurs====
^Capteur^Réception^Emission^
|IR 1|GPIO 04 (echo)| - |
|IR 2|GPIO 18 (echo)| - |
|Ultrasons|GPIO 6 (echo)|GPIO 5 (trigger)|

===== Gérer les moteurs =====
La **gestion** d'un moteur nécessite : 
  * de créer un **objet PWM** pour gérer la puissance du moteur
  * d'**utiliser conjointement** les deux GPIO pour définir le **sens de rotation** du moteur.

Exemple pour le moteur 1 :
<code python>
import RPi.GPIO as GPIO 
import time
 
# Utiliser la numérotation électronique du GPIO  
GPIO.setmode(GPIO.BCM) 
 
# définir les broches du GPIO à utiliser en sortie dans un tableau associatif
moteur1 = {"PWM":17, "Avancer":27, "Reculer":22}

# Configurer les broches en sortie
GPIO.setup(moteur1["PWM"], GPIO.OUT)
GPIO.setup(moteur1["Avancer"], GPIO.OUT)
GPIO.setup(moteur1["Reculer"], GPIO.OUT)
 
# creation d'un objet PWM appelé moteurPWM en précisant le numero de broche (moteur1["PWM"]) et la frequence (50Hz)
moteurPWM = GPIO.PWM(moteur1["PWM"], 50)
 
# demarrage du PWM avec un cycle a 0 : moteur arrêté off
moteurPWM.start(0)
 
# définir le rapport cyclique à 20 pour faire tourner le moteur 1 à 20% de sa puissance 
moteurPWM.ChangeDutyCycle(50)
 
# faire tourner le moteur dans un sens pendant 2 secondes
GPIO.output(moteur1["Avancer"],GPIO.HIGH)
GPIO.output(moteur1["Reculer"],GPIO.LOW)
time.sleep(2)
GPIO.output(moteur1["Avancer"],GPIO.LOW)
GPIO.output(moteur1["Reculer"],GPIO.LOW)
 
# Arreter le PWM
moteurPWM.stop()
 
# libérer le port du GPIO utilisé
GPIO.cleanup()
</code> 

===== Gérer les flèches à LED =====
Pour **activer** l'éclairage d'une flèche, il suffit :
  * de **définir** les broches concernées en **sortie**,
  * de mettre la sortie à l'**état haut** pour activer l'éclairage.
<code python>
import RPi.GPIO as GPIO
import time

# Utiliser la numerotation electronique du GPIO  
GPIO.setmode(GPIO.BCM)

# définir les broches du GPIO a utiliser en sortie dans un tableau associatif
fleche={"avancer":16, "reculer":19, "droite":13, "gauche":26}

# Configurer les broches en sortie
GPIO.setup(fleche["avancer"],GPIO.OUT)
GPIO.setup(fleche["reculer"],GPIO.OUT)
GPIO.setup(fleche["droite"],GPIO.OUT)
GPIO.setup(fleche["gauche"],GPIO.OUT)

print("Activer la flèche avancer pendant 1 seconde :")
GPIO.output(fleche["avancer"],GPIO.HIGH)
time.sleep(1)
GPIO.output(fleche["avancer"],GPIO.LOW)
time.sleep(1)

print("Activer la flèche reculer pendant 1 seconde :")
GPIO.output(fleche["reculer"],GPIO.HIGH)
time.sleep(1)
GPIO.output(fleche["reculer"],GPIO.LOW)
time.sleep(1)

print("Activer la flèche droite pendant 1 seconde :")
GPIO.output(fleche["droite"],GPIO.HIGH)
time.sleep(1)
GPIO.output(fleche["droite"],GPIO.LOW)
time.sleep(1)

print("Activer la flèche gauche pendant 1 seconde :")
GPIO.output(fleche["gauche"],GPIO.HIGH)
time.sleep(1)
GPIO.output(fleche["gauche"],GPIO.LOW)
time.sleep(1)

# libérer les ports du GPIO utilises
GPIO.cleanup()
</code>

===== Gérer le capteur à ultrasons =====
==== principe ====
Un émetteur d’ultrasons (Tx) envoie un train d’ondes sonores (8 impulsions à 40kHz) qui se réfléchissent sur un obstacle et reviennent vers un récepteur (Rx). Connaissant la vitesse du son dans l’air (environ 340 m/s) il suffit de diviser par 2 le temps mis par les ondes pour faire l’aller-retour et calcule alors la distance de l'obstacle.

{{ :isn:anim_ultrason.gif?nolink |}}

Pour en savoir plus : 
  * https://www.framboise314.fr/mesure-de-distance-par-ultrasons-avec-le-raspberry-pi/
  * http://espace-raspberry-francais.fr/Composants/Mesure-de-distance-avec-HC-SR04-Raspberry-Francais/

Pour **mesurer** la distance d'un obstacle on procède de la manière suivante :
  * on envoie sur l'entrée **Trig** du capteur HC-SR04 un train d'onde pendant un très bref instant de 10 micro secondes (0.00001 s),
  * DES QUE LE TRAIN EST EMIS, l'entrée **Echo** délivre une tensions de 5 v
  * dès que l'entrée **Echo** détecte le retour du train d'onde, l'entrée n'est plus à 5V.
<code python>
import RPi.GPIO as GPIO
import time

# Utiliser la numerotation electronique du GPIO  
GPIO.setmode(GPIO.BCM)

# définir les broches du GPIO a utiliser en sortie pour envoyer le train d'onde et en entrée pour la réception
ultrason={"envoi":5, "echo":6}

# Configurer les broches 
GPIO.setup(ultrason["envoi"],GPIO.OUT)
GPIO.setup(ultrason["echo"],GPIO.IN)

# fonction qui retourne la distance d'un obtacle
def distance():
    # generation du train d’ondes ultrasonores
    GPIO.output(ultrason["envoi"], GPIO.HIGH)
    time.sleep(0.00001)
    GPIO.output(ultrason["envoi"], GPIO.LOW)
    start = time.time()
    
    # boucler tant que l'entree n'est pas à l'etat haut 
    while GPIO.input(ultrason["echo"])==0:
       pass
    
    # enregistrement du temps de départ
    debutImpulsion= time.time()
    
    # boucler tant que l'entree n'est pas revenue à un etat bas 
    while GPIO.input(ultrason["echo"])==1:
       pass
    
    # enregistre le temps quand l'entree n'est plus à l'état haut 
    finImpulsion  = time.time()
    
    # calcul de la distance en cm arrondie à l'entier
    distance = round((finImpulsion - debutImpulsion) * 343*100/2,1)
    
    # renvoyer la valeur de la distance
    return distance

# lancer la fonction distance() jusqu'à l'appui d'une touche
while True:
   try:
      # lancement de la fonction distance() et affichage du résultat obtenu
      print(distance())
      
      # attendre 1 seconde avant de relancer la détermination de la distance
      time.sleep(1)
      
   except KeyboardInterrupt:
      # arreter le programme
      pass
    
# libérer les ports du GPIO utilises
GPIO.cleanup()</code>
==== Les activités ... ====
<WRAP center round info >
[[.:accueil|Je reviens à la liste des activités.]] 
</WRAP>