Modifications

Sauter à la navigation Sauter à la recherche

RASP-SENSE-HAT-ASTRO-PI-Bouton (voir la source)

Version du 25 octobre 2015 à 15:49

10 329 octets ajoutés ,  25 octobre 2015 à 15:49
aucun résumé de modification
Ligne 1 : Ligne 1 :  
{{RASP-SENSE-HAT-ASTRO-PI-NAV}}
 
{{RASP-SENSE-HAT-ASTRO-PI-NAV}}
   −
{{traduction}}
+
== Boutons de vols ==
 +
{{bloc-etroit|text=Le boîtier de vol de l'Astro Pi utilise le sense Hat ainsi que 6 boutons d'usage général, boutons que vous pourriez brancher sur le GPIO du Raspberry Pi. Cela demande quelques opérations de bricolages mais au final, vous auriez 6 boutons de plus branché sur votre Pi, des boutons que vous pourriez exploiter dans vos propres programmes.
    +
Il s'agit de simple bouton poussoir que l'on branche directement sur les broches du GPIO (dans un circuit pull-up): vous pouvez facilement recréer cette configuration en utilisant un breadboard, quelques boutons et du fils.}}
 +
 +
[[Fichier:RASP-SENSE-HAT-ASTRO-PI-Bouton-01.jpg]]
 +
 +
== Les éléments nécessaires ==
 +
Pour réaliser ce montage, vous aurez besoin des éléments suivants:
 +
* {{pl|90|un breadboard}}
 +
* 6 x {{pl|39|bouton tactiles}}
 +
* 14 x fils avec connecteur mâle vers femelle ({{pl|82|voyez notre assortiment multifonctionnel}})
 +
* {{pl|485|Un stacking header 40 broches}} (avec des broches longues)
 +
 +
Utilisez ce stacking header allongé pour monter le votre Hat Sense sur le Rasberry Pi (à la place de celui déjà monté sur le hat sense).
 +
 +
De sorte, les broches du GPIO dépassent de l'autre côté du sense hat... il sera alors possible de brancher les cables sur le haut du pinHeader.
 +
 +
== Le connecteur GPIO ==
 +
Les boutons sont raccordés sur les 6 dernières broches en bas du GPIO du Pi.
 +
 +
Voici comment les raccorder sur le connecteur GPIO.
 +
 +
[[Fichier:RASP-SENSE-HAT-ASTRO-PI-Bouton-02.png|480px]]
 +
 +
Note: l'orientation du diagramme des broches correspond aux broches de votre Pi avec le port USB et Ethernet placé vers le bas, et les rangées de broche du GPIO à main droite sur le Raspberry-Pi.
 +
 +
Cela signifie que cette configuration ne peut pas être utilisée si vous utilisez un ancien Raspberry A et/ou B. Si vous utilisez un ancien modèle, vous devrez choisir d'autres broches, mais aussi modifier les numéros de broches dans votre code.
 +
 +
Voici l'assignation des broches:
 +
* Les quatres boutons supérieurs:
 +
** Haut = UP: GPIO 26, broche 37
 +
** Bas = DOWN: GPIO 13, broche 33
 +
** Gauche = LEFT: GPIO 20, broche 38
 +
** Droite = RIGHT: GPIO 19, broche 35
 +
* La paire de bouton du bas
 +
** A (sur la gauche): GPIO 16, broche 36
 +
** B (sur la droite): GPIO: 21, broche 40
 +
 +
Si vous utilisez ces boutons pour réaliser votre projet alors vous aurez besoin de vous conformer a cet assignation de broche.
 +
 +
== Détecter un bouton ==
 +
Voici comment détecter la pression sur un bouton.
 +
 +
Les broches du GPIO peuvent être configurées comme entrée (''input'') ou sortie (''output'' en anglais). Le mode sortie (''output'') est utilisé si vous avez besoin de fournir de l'électricité à un périphérique tel qu'une LED ou un buzzer. Avec le mode en entrée (''input''), une broche du GPIO dispose d'une valeur que vous pouvez lire dans vos programmes. Si une tension est appliqué sur la broche, la lecture renvéra la valeur 1 ({{fname|HIGH}}, le niveau haut); Si la broche est connectée directement sur la masse (dit ''ground'' en anglais, donc sans tension), la lecture retournera la valeur 0 ({{fname|LOW}}, le niveau bas).
 +
 +
Le but est d'utiliser un bouton poussoir pour changer la tension (niveau haut / niveau bas) sur une broche du GPIO, nous permettant ainsi de lire le changement sur la broche à l'aide de notre programme.
 +
 +
Lorsqu'une broche du GPIO est en mode d'entrée (''Input'') sont état est dit 'flottant', signifiant que nous devons fixer par nous même son niveau logique (soit le niveau de tension haut ou niveau de tension bas). Dans notre cas de figure, cette état 'flottant' de la broche ne fait pas notre affaire car, justement, en état flottant la lecture n'est pas fiable... nous lirons des valeurs aléatoires entre {{fname|HIGH}} (haut) et {{fname|LOW}} (bas). Pour ce qui nous intéresse, nous avons besoin de savoir exactement si le bouton est enfoncé ou non. Nous avons donc besoin de forcer la tension soit au niveau {{fname|HIGH}} (haut) ou {{fname|LOW}} (bas) -ET- de changer cette tension uniquement si le bouton est pressé.
 +
 +
Le matériel de vol du boîtier Astro-Pi tous les boutons sont raccordé dans une configuration '''pull up''', ce qui signifie que la tension du GPIO est artificiellement placée au niveau haut ({{fname|HIGH}}) et que la tension est forcée au niveau bas ({{fname|LOW}}) lorsque le bouton est pressé.
 +
 +
[[fichier:RASP-SENSE-HAT-ASTRO-PI-Bouton-03.png]]
 +
 +
Dans le diagramme ci-dessus la tension de la broche GPIO est placée à 3.3 volts par l'intermédiaire d'une résistance de 10k ohm. La broche est donc toujours au niveau haut ({{fname|HIGH}}). Nous pouvons ensuite "brancher" la broche sur la masse à l'aide du bouton (en pressant dessus) et la tension de la broche passe alors à {{fname|LOW}} (niveau bas).
 +
 +
Par conséquent, le niveau haut ({{fname|HIGH}}) signifie que le bouton n'est pas enfoncé et le niveau bas ({{fname|LOW}}) signifie qu'il est enfoncé.
 +
 +
Nous avons de chance, le Raspberry Pi dispose de tout ce circuit en interne; nous pouvons activer le circuit "pull up" de la broche dans notre code (indépendamment pour chaque broche GPIO). Ce circuit "pull up" est tellement petit que nous ne pouvons pas le voir. Cool, nous pouvons nous en sortir avec juste avec quelques fils et il nous reste plus qu'à faire nos raccordements en fonction de nos désirs.
 +
 +
Tout ce qu'il nous reste à faire c'est de créer le circuit ci-dessus 6 fois... un fois pour chaue broche du GPIO.
 +
 +
== Branchement sur breadboard ==
 +
Le diagramme ci-dessous montre comment raccorder les 6 boutons sur un breadboard de façon à correspondre au boîtier de vol Astro-Pi. La couleur de fil n'a pas vraiment d'importance. Le numéro à côté de chaque bouton indique sur quelle broche du GPIO il faut connecter le bouton.
 +
 +
Chaque bouton doit avoir un côté branché sur la masse/GND de sorte à pouvoir ramener son potentiel du GPIO (au niveau haut, {{fname|HIGH}}) à la masse (donc niveau bas, {{fname|LOW}}) lorsque l'on presse sur le bouton.
 +
 +
[[fichier:RASP-SENSE-HAT-ASTRO-PI-Bouton-10.png]]
 +
 +
[[fichier:RASP-SENSE-HAT-ASTRO-PI-Bouton-11.png]]
 +
 +
== Détecter un bouton (dans le code) ==
 +
'''1.''' Ouvrir Python 3 dans une fenêtre terminal en tant que super utilisateur avec {{fname|sudo}} en tapant:
 +
 +
<nowiki>sudo idle3 &</nowiki>
 +
 +
'''2.''' Une fenêtre 'Python Shell' apparaîtra.
 +
 +
'''3.''' Sélectionnez le menu {{fname|File > New Window}} (''Fichier > Nouvelle fenêtre'').
 +
 +
Tapez le code suivant (ou faite un copier/collr):
 +
 +
<nowiki>import RPi.GPIO as GPIO
 +
import time
 +
from sense_hat import SenseHat
 +
 +
sense = SenseHat()
 +
 +
UP = 26    # Haut
 +
DOWN = 13  # bas
 +
LEFT = 20  # gauche
 +
RIGHT = 19  # droite
 +
A = 16
 +
B = 21 
 +
 +
running = True # Variable pour 'en_cours_d_execution'
 +
 +
# Fonction appelee lorsqu un bouton est active
 +
def button_pressed(button):
 +
    global running
 +
    global sense
 +
 +
    # Afficher le bouton (la broche GPIO activee)
 +
    print(button)
 +
    sense.show_message(str(button))
 +
 +
    # Bouton B: signaler l arret du programme
 +
    if button == B:
 +
        running = False
 +
 +
GPIO.setmode(GPIO.BCM)
 +
 +
# Configurer les broches en entree
 +
for pin in [UP, DOWN, LEFT, RIGHT, A, B]:
 +
    GPIO.setup(pin, GPIO.IN, GPIO.PUD_UP)
 +
 +
    # attacher un évenement sur le changement d etat
 +
    # d une broche GPIO. La fonction appelee est boutton_pressed
 +
    GPIO.add_event_detect(pin, GPIO.FALLING, callback=button_pressed, bouncetime=100)
 +
 +
# Le programme principale de fait rien... il attend
 +
# Tout se passe dans les événements
 +
while running:
 +
    time.sleep(1)
 +
 +
sense.show_message("Au revoir")</nowiki>
 +
 +
'''5.''' Sélectionnez {{fname|File > Save}} (''Fichier > Sauver'') et choisissez un nom de fichier pour votre programme.
 +
 +
'''6.''' Sélectionnez ensuite {{fname|Run > Run module}} (''Executer > Executer module'').
 +
 +
'''7.''' Ce programme se contente d'afficher la broche GPIO correspondante chaque fois qu'un bouton est pressé. Le programme se termine si vous pressez le bouton '''B''' (la paire du bas, à droite). Cela vous permet de savoir si branchements sont correctes avant d'aller plus loin.
 +
 +
'''8.''' Le code ci-dessus exécute la fonction {{fname|button_pressed}} chaque fois qu'un bouton est pressé. Cependant, il y a de nombreuses autres façons de détecter la pression des boutons dans vos programmes. Vous pourriez, par exemple, faire attendre votre programme jusqu'au moment où vous détectez la pression d'un bouton... puis exécuter l'action correspondante. Voici un exemple montrant comment réaliser cela avec le bouton '''UP''' (vers le haut):
 +
 +
<nowiki>import RPi.GPIO as GPIO
 +
from sense_hat import SenseHat
 +
 +
sense = SenseHat()
 +
 +
UP = 26    # Haut
 +
DOWN = 13  # bas
 +
LEFT = 20  # gauche
 +
RIGHT = 19 # droite
 +
A = 16    # bouton A
 +
B = 21    # bouton B
 +
 +
GPIO.setmode(GPIO.BCM)
 +
 +
# Definir les broche en entrée (avec option Pull-Up)
 +
for pin in [UP, DOWN, LEFT, RIGHT, A, B]:
 +
    GPIO.setup(pin, GPIO.IN, GPIO.PUD_UP)
 +
 +
sense.show_message("Presser UP/HAUT pour démarrer le programme")
 +
GPIO.wait_for_edge(UP, GPIO.FALLING)
 +
sense.show_message("Nous y voici!")</nowiki>
 +
 +
'''9.''' Vous pourriez aussi avoir besoin de savoir si le bouton est maintenu enfoncé et --peut-être-- faire quelque-chose s'il est maintenu enfoncé pendant plus de 3 secondes. Voici un autre exemple:
 +
 +
<nowiki>import RPi.GPIO as GPIO
 +
import time
 +
from sense_hat import SenseHat
 +
 +
sense = SenseHat()
 +
 +
UP = 26    # Haut
 +
DOWN = 13  # bas
 +
LEFT = 20  # gauche
 +
RIGHT = 19 # droite
 +
A = 16    # bouton A
 +
B = 21    # bouton B
 +
 +
GPIO.setmode(GPIO.BCM)
 +
 +
for pin in [UP, DOWN, LEFT, RIGHT, A, B]:
 +
    GPIO.setup(pin, GPIO.IN, GPIO.PUD_UP)
 +
 +
# attendre pendant HIGH / niveau haut / non pressé
 +
while GPIO.input(A) == GPIO.HIGH:
 +
    time.sleep(0.01)
 +
 +
# enregistrer l'heure au moment où le bouton a été pressé
 +
button_down_time = time.time()
 +
 +
held_down = False
 +
 +
# pendant que LOW / niveau bas / Pressé
 +
while GPIO.input(A) == GPIO.LOW:  # wait while LOW / pressed
 +
    time.sleep(0.01)
 +
 +
    # Y a t il plus de 3 secondes passée ?
 +
    if time.time() - button_down_time > 3:
 +
        held_down = True # indiquer que le bouton est pressé
 +
        break
 +
 +
if held_down:
 +
    print("maintenu pressé")
 +
    sense.show_message("Nous y voici!")
 +
else:
 +
    print("pas maintenu enfoncé")</nowiki>
 +
 +
Lorsque vous maintenez le bouton '''A''' enfoncé pendant 3 secondes, vous devriez voir le message "Nous y voici".
    
{{RASP-SENSE-HAT-ASTRO-PI-TRAILER}}
 
{{RASP-SENSE-HAT-ASTRO-PI-TRAILER}}
Admin
Bureaucrates, Administrateurs
29 917

modifications

Récupérée de « https://wiki.mchobby.be/index.php?title=Spécial:MobileDiff/16246...16304 »

Menu de navigation