Jeu de vitesse de réaction – Instructions de montage

Les boutons et interrupteurs sont le pain et le beurre de l’informatique physique. Grâce au kit de jeu de vitesse de réaction, nous allons (espérons-le!) Vous enseigner l’électronique de base à l’aide d’interrupteurs et de résistances, et les bases du codage de fonctionnement physique avec le Raspberry Pi. Ceci est un tutoriel et un kit de bricolage pour les débutants, conçus pour démontrer l’un des nombreux projets simples, mais très cool, qui peuvent être complétés avec le Raspberry Pi!

Veuillez vous assurer que vous disposez d’un Rasbian OS à jour et d’une configuration de connexion Internet sur votre Raspberry Pi.

Le circuit

La base du kit de jeu de vitesse de réaction est d’avoir le Raspberry Pi détecter lorsque les boutons sont enfoncés. Pour ce faire, nous allons utiliser des configurations de résistance « pull-down » simples, ce qui entraîne un décalage de tension lorsque l’un des interrupteurs est enfoncé. Nous allons ensuite raccorder cela au Raspberry Pi d’une manière qui permet au Pi de détecter ce changement de tension.

Nous expliquerons cela en utilisant d’abord un seul commutateur, puis nous l’étendrons pour utiliser plusieurs commutateurs! Les commutateurs que nous utilisons dans ce projet sont bipolaires, normalement ouverts, de type momentané. Cela signifie qu’il a deux contacts de commutation qui ne sont pas connectés normalement. Lorsque vous appuyez sur le bouton, ils se connectent temporairement jusqu’à ce que le bouton soit relâché. Ils disposent également d’une LED, séparée du bouton, afin que nous puissions l’allumer lorsqu’il doit être pressé!

Nous allons utiliser trois broches GPIO sur le Pi:

1. La première broche fournira une tension de signal 3,3 V (Vcc)
2. Le second mettra à la terre le circuit 0V (GND)
3. Le troisième sera configuré comme une entrée (GPIO_IN), que nous utiliserons pour détecter le décalage de tension.

J’expliquerai comment ce circuit fonctionne en quelques étapes ci-dessous.

Les broches GPIO du Raspberry Pi peuvent, entre autres, être définies comme entrées ou sorties. En sortie, la broche émettra une tension ou un signal, selon la broche et les besoins de l’utilisateur. Lorsqu’une broche GPIO est définie sur entrée, elle se trouve et attend une entrée de tension ou de signal. Cependant, contrairement à une sortie, une entrée ne fournit aucune tension et n’a donc pas de niveau de tension distinct. Dans cet état, il est défini comme «flottant».

Dans un état flottant, la broche d’entrée n’a pas de « point de référence » pour juger si une tension qui la traverse est haute ou basse. C’est un problème pour nous car, pour que notre entrée fonctionne, nous en avons besoin pour pouvoir juger de la différence entre une haute et une basse tension, et savoir ensuite quand notre interrupteur a été enfoncé.

Imaginez que vous volez à l’intérieur d’un bâtiment sans fenêtres ni portes, juste des murs blancs tout autour. Lorsque vous flottez de haut en bas, comment savoir quel est le plafond et quel est le sol? Cette pièce pourrait être immense ou minuscule – vous ne savez toujours pas quelle fin était laquelle! À moins que quelqu’un ne vous donne un point de référence, par exemple une fenêtre pour voir le ciel à travers le plafond, vous ne le saurez pas!

Donc, nous devons donner à notre broche d’entrée une fenêtre, afin qu’il sache de haut en bas. TLa solution consiste à «lier» cette broche, à l’étalonner à une valeur de tension définie et à lui donner un point de référence. C’est là qu’interviennent nos résistances!

Dans le circuit ci-dessous, lorsque l’interrupteur est ouvert, notre GPIO_IN est connecté directement à GND via les résistances. Les résistances lient la tension de la broche d’entrée « vers le bas » à 0 V, par ex. résistances pull-down, lui donnant ainsi un point de référence défini de 0V ou « bas ».

Lorsque l’interrupteur est fermé, nous connectons notre broche directement à la ligne 3,3 V. Cela envoie un signal de 3,3 V à travers la broche d’entrée, ce qui définit notre point de référence «haut».

Ainsi, à travers ce circuit simple, nous avons deux « états » distincts. Faible, où la broche est connectée à 0 V, et élevée lorsque la broche est connectée à la ligne 3,3 V. Notre broche d’entrée ne flotte plus et ne peut être que dans l’un de ces deux états définis – il n’y a pas d’autre option! Grâce à ce processus, nous pouvons coder notre Raspberry Pi pour détecter quand l’état d’entrée est haut ou bas sur nos commutateurs et ensuite élaborer notre programme de jeu de réaction!

Ce processus de détection de hautes / basses tensions est essentiellement la base des états de calcul et de logique – c’est de là que viennent tous ces 0 et 1!

Notes annexes

• Alors pourquoi avez-vous besoin des résistances?
  • Comme nous connectons Vcc directement à GND, cela pourrait permettre à un courant dangereux de circuler (car il s’agit essentiellement d’un court-circuit), la grande résistance de 10k ™ garantit que seul un petit courant est tiré.
  • Il en va de même pour la résistance 1k ™. Cela limite le courant à GPIO_IN et garantit que nous ne brûlons pas notre broche.
• Pull-up, pull-down – quelle est la différence?
  • «Cela dépend essentiellement de ce que font les résistances et de l’endroit où elles tirent également le niveau logique des broches GPIO.
  • Dans un « pull-down », l’état logique est normalement tiré bas – comme ci-dessus, nous avons tiré notre broche d’entrée à 0V comme état standard
  • Dans un « pull-up », nous utilisons les résistances pour tirer l’état logique haut (se connectant normalement à une source de tension), et couper le circuit à 0V avec notre interrupteur.

Plus de commutateurs!

Comme nous avons maintenant appris les bases de la liaison des broches d’entrée, nous pouvons étendre notre circuit pour englober les cinq boutons dont nous avons besoin pour notre kit de jeu de vitesse de réaction! Bien sûr, il n’y a pas de véritable limite (sauf le nombre de broches d’entrée) au nombre de boutons ou de commutateurs que vous utilisez dans ce circuit.

Chaque petit circuit déroulant est connecté à une broche GPIO individuelle (6, 13, 19, 23, 24). De cette façon, nous sommes en mesure de détecter les pressions de boutons individuelles qui correspondent aux broches d’entrée GPIO distinctes:

Ajout de lumières

Nous allons utiliser les voyants LED de chaque interrupteur pour indiquer à l’utilisateur qu’il doit appuyer sur ce bouton. Pour cela, nous allons simplement connecter les LED du commutateur à des broches GPIO distinctes sur le Raspberry Pi, et définir les broches comme sorties!

Donc, si vous regardez le circuit ci-dessus, nous avons les 5 LED de nos 5 commutateurs, et chacun est connecté à une broche GPIO distincte (5, 12, 17, 22, 25), et chacun est également connecté à une masse commune .

Mettre ensemble

C’est le bit délicat! Nous devons maintenant prendre tout ce qui a été appris ci-dessus et l’appliquer à notre maquette. Le câblage peut devenir un peu désordonné, alors faites attention et vérifiez vos connexions.

Pour cette partie, vous voudrez utiliser le pack de fils de 200 mm M / M illustré ci-dessous. Vous aurez besoin d’environ 20 fils du pack, mais il y en a 40, donc si vous vous trompez, prenez simplement l’une des pièces de rechange!

Pour chaque fil: coupez, dénudez et étamez une extrémité et laissez l’autre extrémité avec le connecteur mâle. L’extrémité dénudée doit être soudée sur votre interrupteur, et le connecteur mâle sera branché sur votre planche à pain plus tard!

1. La première chose que nous devons faire est de souder du fil sur nos boutons LED. Vous remarquerez que le bouton a 4 broches. 2 de ces broches sont destinées au commutateur, les 2 autres à la LED. Si vous regardez de plus près, vous verrez que la paire de broches les plus rapprochées a un + et un -, ce sont vos broches LED.

   

2. Commencez par souder un fil rouge sur la broche + de la LED, et un fil noir sur la broche – de la LED

   

3. Maintenant, nous devons souder du fil sur les broches du commutateur. Les commutateurs n’ont pas de polarité, donc peu importe le fil que nous soudons sur quelle broche.

   

4. Une fois que vous avez fait cela pour les 5 interrupteurs, nous pouvons ensuite fixer les interrupteurs à la pièce supérieure en acrylique.

   

5. Chaque bouton doit avoir un anneau vissable attaché, commencez par les dévisser. Une fois l’anneau retiré, vous pouvez maintenant enfiler les fils dans un trou, puis revisser l’anneau de l’autre côté.

   

6. Faites cela pour chaque bouton. Nous devons maintenant noter le «numéro» de chaque commutateur. En commençant par le bouton en haut à gauche « numéro 1 » à « numéro 5 » dans un mouvement en forme de « Z ».

   

   

7. Maintenant, nous allons configurer la maquette avec nos résistances déroulantes. Pour ce faire, vous aurez besoin des composants suivants: planche à pain, cordonnier, 5x résistance 10K ™, 5x résistance 1K ™

   

8. Comme nous allons tout entasser sur une planche à pain demi-taille, je vous recommande de couper les pieds des résistances jusqu’à environ 1 cm de chaque côté, pour réduire les risques de court-circuit.
9. Commencez par placer le cordonnier sur la planche à pain. Assurez-vous que chaque rangée de broches sur le cordonnier va de chaque côté de la fente au milieu de la planche à pain, exactement comme ci-dessous. Assurez-vous que la broche 1 de 3,3 V du GPIO se trouve dans la rangée 1 de la maquette.

   

10. Nous pouvons maintenant placer les résistances sur la carte. En commençant par une résistance 10K ™, insérez une jambe dans la rangée a: 30et l’autre jambe dans le rail négatif. Maintenant, avec une résistance 1K ™, insérez une jambe dans la rangée b: 30et l’autre jambe en ligne b: 28. Il s’agit de nos paires de résistances déroulantes telles que conçues ci-dessus! Nous devons créer la même configuration pour les 5 commutateurs, par exemple 5 paires de résistances déroulantes. Voici la liste complète des résistances et où leurs broches doivent aller: (colonne de ligne, colonne de ligne) « – » = rail négatif « + » = rail positif. Il y a une photo à clarifier!

    10k ™ (a: 30, -)
    10k ™ (a: 27, -)
    10k ™ (a: 24, -)
    10k ™ (j: 30, -)
    10k ™ (j: 27, -)

    1k ™ (b: 30, b: 28)
    1k ™ (b: 27, b: 25)
    1k ™ (b: 24, b: 22)
    1k ™ (i: 30, i: 28)
    1k ™ (i: 27, i: 25)

    

11. Comme nous utilisons les deux côtés de la planche à pain, nous devons connecter à la fois les rails négatifs et les rails positifs. À l’aide d’un cavalier noir, branchez une extrémité du fil dans le rail négatif inférieur et l’autre extrémité dans le rail négatif supérieur. Peu importe la broche que vous utilisez, car ils sont tous connectés. De même pour le rail positif, à l’aide d’un cavalier rouge, connectez une extrémité au rail positif inférieur et l’autre extrémité au rail positif supérieur.

    

12. Maintenant, nous pouvons commencer à câbler les fils de l’interrupteur et les fils LED. Commençons par les commutateurs.
13. Nous allons commencer par ajouter des fils de liaison entre les résistances et le cordonnier. Nous devons numéroter chaque paire de résistances afin de nous assurer que nos commutateurs numérotés sont câblés dans la bonne broche GPIO.

    

14. Voici une liste des endroits où chaque paire doit être câblée:

    La paire 1 – a: 28 va à GPIO06
    Paire 2 – a: 25 va à GPIO13
    Paire 3 – a: 22 va à GPIO19
    La paire 4 – j: 28 va à GPIO23
    La paire 5 – j: 25 va à GPIO24

    

15. Nous devons également câbler les rails négatifs et positifs. Donc, à l’aide d’un cavalier rouge, branchez une extrémité dans la broche 3v3 du cordonnier et l’autre extrémité dans l’un des rails positifs. Ensuite, avec un cavalier noir, branchez une extrémité dans l’une des broches GND du cordonnier et l’autre extrémité dans l’un des rails négatifs.

    

16. Avec la planche à pain prête à commencer le câblage dans les commutateurs et les LED, nous allons la monter sur la plaque de base de la boîte, avec le Raspberry Pi. Nous allons commencer par monter le Raspberry Pi en premier. Insérez chaque vis en nylon dans les 4 trous de la plaque de base

    

17. Placer ensuite une entretoise sur chaque vis

    

18. Avec les entretoises en place, insérez le Raspberry Pi sur le dessus, en vous assurant que chaque vis passe dans les trous de montage du Pi. Assurez-vous que le côté du Pi qui a le connecteur d’alimentation est tourné vers l’extérieur, loin du centre de la plaque de base.

    

19. Avec le Pi en place, nous devons maintenant ajouter les écrous en nylon pour fixer le Pi en position. Remarque: Si vous allez utiliser un dongle nano wifi pour SSH sur votre Pi, il serait maintenant temps de le brancher sur le Pi.

    

20. Retournez le panneau inférieur pour que le Pi soit orienté vers le bas. Collez ensuite les 4 pieds en caoutchouc dans chacun des coins

    

21. Maintenant, nous pouvons maintenant monter la planche à pain. La planche à pain a un tampon collant sur la face inférieure, alors décollez le papier protecteur et placez la planche à pain à côté du côté GPIO du pi. Assurez-vous que les broches GPIO du Pi sont alignées avec le cordonnier de la planche à pain afin de ne pas avoir à tordre ou à plier le câble lors de la connexion. ASSUREZ-VOUS DE NE PAS COUVRIR LES FENTES DU PANNEAU LATÉRAL SUR LA PLAQUE DE BASE

    

22. Vient maintenant le bout du fil, le câblage des commutateurs et des LED. Nous allons commencer par les fils de l’interrupteur. Si vous vous souvenez, nous avons donné un numéro à nos commutateurs à l’étape 6 et nos paires de résistances à l’étape 14 – Nous allons maintenant les marier!
    Pour le commutateur 1, branchez l’un des fils dans le rail positif et l’autre fil dans la rangée c: 30 il est donc dans la même colonne que votre paire de résistances numéro 1.

    

    Faites de même avec les autres fils de l’interrupteur, en vous assurant que l’un des fils entre dans le rail positif et que l’autre va dans la même colonne que la paire de résistances appropriée.

    

    La polarité des fils de l’interrupteur n’est pas essentielle, par ex. ils peuvent être câblés dans les deux sens!

    Commutateur 1 – Fil blanc à c: 30, Fil gris au rail positif
    Interrupteur 2 – Fil blanc sur c: 27, Fil gris sur le rail positif
    Commutateur 3 – Fil blanc sur c: 24, Fil gris sur le rail positif
    Interrupteur 4 – Fil blanc à h: 30, Fil gris au rail positif
    Interrupteur 5 – Fil blanc à h: 27, Fil gris au rail positif

    

23. Une fois que les commutateurs sont connectés, il est temps de câbler les LED. N’oubliez pas le circuit que nous avons conçu ci-dessus, nous connectons la broche positive de la LED à une broche de sortie GPIO (que nous définirons comme sortie dans notre code), et d’autres doivent être câblés directement à la terre. Voici une liste des endroits où chaque LED doit être câblée:

    LED pour interrupteur 1 – Le fil rouge va à GPIO05, le fil noir au rail négatif
    LED pour interrupteur 2 – Le fil rouge va au GPIO12, le fil noir au rail négatif
    LED pour interrupteur 3 – Le fil rouge va au GPIO17, le fil noir au rail négatif
    LED pour interrupteur 4 – Le fil rouge va au GPIO22, le fil noir au rail négatif
    LED pour interrupteur 5 – Le fil rouge va au GPIO25, le fil noir au rail négatif

    Quel beau bordel électronique!

    

24. Une fois que tout est câblé, nous devons soigneusement brancher le câble ruban au cordonnier sur la planche à pain. Cela peut être un peu délicat avec tous ces fils partout. Faites juste attention à ne pas tirer de fils de la planche à pain lorsque vous faites cela.

    

25. Avec le câble ruban branché sur le cordonnier sur la planche à pain, nous devons maintenant le brancher sur le GPIO sur le Raspberry Pi. Il y a deux câbles inclus, court et long – vous pouvez choisir lequel utiliser!

    

26. Avec tout câblé, il est temps de construire le boîtier autour de notre fouillis de câbles! Commencez par les deux parois latérales (les deux pièces qui ont 4 bouchons d’extrusion) et insérez-les dans la plaque de base. Insérez-les en face des prises USB et de l’emplacement pour carte SD. C’est un bon point pour brancher votre carte SD, car l’accès sera limité sous peu!

    

    

27. Maintenant, nous pouvons insérer les murs avant et arrière. La paroi arrière est la pièce qui a une découpe pour le connecteur d’alimentation. Assurez-vous que cela va sur le côté qui a la prise d’alimentation sur le pi. Vous voudrez peut-être piquer tous les câbles dont vous avez besoin à travers les découpes maintenant, car l’accès à ces ports est difficile une fois que le sommet est enfilé! Notez s’il vous plaît. La version boutique de l’étui a des découpes pour les ports Micro-USB, HDMI, Composite et RJ45.

    

28. Maintenant, nous pouvons appuyer sur la plaque supérieure (avec nos boutons allumés) vers le bas pour compléter la boîte. Vous devrez peut-être replier le câble ruban vers le bas pour qu’il ne repousse pas la plaque supérieure.

    

29. C’est tout le matériel assemblé! Tout ce que nous devons faire maintenant est de nous connecter à notre Pi et de télécharger le script python pour lancer le jeu!
30. Alors, connectez-vous à votre Pi. Vous pouvez le faire via SSH ou via la méthode normale! Notez s’il vous plaît. Nous utilisons Raspian à partir de Terminal et avons une connexion Internet!
31. Nous devons maintenant télécharger le script python sur notre Raspberry Pi, vous pouvez le voir ici – https://github.com/modmypi/Reaction-Speed-Game/blob/master/start.py. Pour ce faire, nous devons utiliser la commande GitHub Clone suivante. Cette commande télécharge le référentiel Git dans votre répertoire actuel, dans ce cas le répertoire de base du Raspberry Pi. Vous pouvez changer cela ou créer un nouveau dossier si vous le souhaitez.

    git clone git: //github.com/modmypi/Reaction-Speed-Game

    

32. Nous devons maintenant rechercher le référentiel que nous venons de télécharger. Modifiez donc le répertoire dans le dossier Reaction-Speed-Game:

    cd Reaction-Speed-Game

    

33. Nous pouvons maintenant exécuter notre script Python! Pour démarrer le jeu, tapez simplement:

    sudo python start.py

    

1. Si tout a été correctement câblé, vous devriez voir le bouton central s’allumer. Pour démarrer le jeu, appuyez sur ce bouton! Vous verrez alors toutes les lumières compter vers le bas et s’éteindre une à une. Une fois que toutes les lumières se sont éteintes, soyez prêt à commencer à appuyer sur les boutons pendant qu’ils s’allument! Plus vite vous appuyez dessus, plus votre score sera élevé!

   C’est ça! Notre jeu de vitesse de réaction est maintenant entièrement fonctionnel, alors jouez!

Décomposer le code

Maintenant que nous avons fait tout le côté électronique, il est temps de plonger dans notre code Python. Si vous êtes nouveau dans le codage Python, cela peut sembler un peu intimidant, mais nous ferons de notre mieux pour expliquer chaque étape et comment vous pouvez l’utiliser pour modifier le script et personnaliser votre jeu!

Cliquez sur le lien ici pour afficher le script Python.

Les lignes qui commencent par le hachage « https://www.raspberryme.com/# » indiquent un commentaire et sont ignorées en Python. C’est un moyen d’ajouter des notes, des titres, des commentaires et des rappels à votre code. Vérifiez les hachages pendant que nous expliquons le code, car cela aidera à définir le but de chaque ligne!

La première étape consiste à importer nos bibliothèques Python. Nous allons utiliser quelques fonctions différentes dans notre script, et c’est là que nous les importons! Par exemple, la fonction « time » peut être utilisée pour faire attendre notre Pi entre les étapes de notre script.

# Ici, nous importons les bibliothèques et les fonctions que nous utiliserons dans notre script
importer sys
temps d’importation
importer atexit
importer au hasard
importer RPi.GPIO en tant que GPIO

Ensuite, nous devons définir notre numérotation des broches GPIO, soit la numérotation BOARD, soit la numérotation BCM. La numérotation BOARD fait référence à la numérotation physique des broches des en-têtes. La numérotation BCM fait référence aux numéros de canal sur la puce Broadcom. L’un ou l’autre fera l’affaire, mais je préfère personnellement la numérotation BCM.

# Définissez le mode de numérotation GPIO sur BCM
GPIO.setmode (GPIO.BCM)

Les tuples nous permettent de définir un tableau de variables, dans ce cas nos LED et interrupteurs. Les tuples ne peuvent pas être modifiés, ce qui les rend constants dans notre code. Nous pouvons y accéder et nous y référer plus tard dans notre code, soit comme le tuple dans son ensemble, soit comme une variable dans ce tuple.

# Définissez nos tuples
leds = (5,12,17,22,25)
commutateurs = (6,13,19,23,24)

Les variables sont utilisées pour définir des nombres et des mots que nous pouvons utiliser plus tard dans notre script. C’est simplement une façon ordonnée de définir les choses et nous donne une référence facile à utiliser dans notre code.

# Définir nos variables
random_number = -1
correct_button = False
incorrect_button = False
button_pressed = False
max_points = 10
déduction = 5

Ici, nous définissons certaines fonctions que notre script peut utiliser. De cette façon, au lieu d’écrire la fonction chaque fois qu’elle est requise, nous pouvons simplement appeler le nom de cette fonction – de cette façon, nous utilisons une seule ligne de code, plutôt que d’écrire la fonction entière chaque fois qu’elle est requise.

# Définissez certaines fonctions que notre script utilisera
Bouton def Appuyez sur (canal):
# Cette fonction est appelée chaque fois qu’un bouton est enfoncé, si le bouton enfoncé est le même que le bouton qui est allumé, nous définissons la variable « correct_button » sur True, sinon nous définissons la variable « incorrect_button » sur True.
global correct_button, incorrect_button, button_pressed
# Nous devons définir certaines variables sur global afin que cette fonction puisse changer leur valeur.
imprimer (« bouton appuyé% s »)% canal
button_pressed = True
si le canal == change[random_number]:
correct_button = True
autre:
incorrect_button = True

def exit ():
# Cette fonction est appelée lorsque nous quittons notre script, en utilisant Ctrl + C et réinitialise les broches GPIO.
imprimer (« GPIO Clean Up! »)
GPIO.cleanup ()

Comme nous pouvons quitter notre script Python à tout moment en utilisant la commande Ctrl + C, nous devons nous assurer que les broches GPIO sont correctement réinitialisées. En effet, les configurations de broches persisteront à moins que la fonction GPIO.cleanup ne soit terminée. Ici, nous disons à notre script d’exécuter la fonction « exit », chaque fois que le script se termine.

# Ceci indique à notre script d’utiliser la « exit () » sans cela, notre fonction « exit () » ne serait jamais appelée.
atexit.register (sortie)

Un petit débogage de nos tuples pour nous assurer que nous avons le même nombre de LED et de commutateurs définis.

# Vérifiez que nous avons défini la même quantité de LED que les interrupteurs
si len (leds) == len (interrupteurs):
max = (len (leds) – 1)
autre:
print (« Il n’y a pas le même nombre de LED que les INTERRUPTEURS »)
sortie()

Nous devons maintenant configurer nos broches GPIO en tant qu’entrées ou sorties.

Pour nos commutateurs, nous les configurons comme entrées. «Détection de front montant» signifie que cette entrée recherche un changement d’état d’un signal électrique de BAS à HAUT (front montant). Si vous vous souvenez de notre circuit, nos commutateurs sont attachés BAS, et lorsque le bouton est enfoncé, il ira HAUT – Nous devons détecter cela! La 3ème ligne appelle la fonction « buttonPress » que nous avons définie précédemment.

# Parcourez nos commutateurs pour les configurer
fo