Une planche à pain vous permet de créer des circuits sans avoir à souder quoi que ce soit. C'est un excellent outil pour expérimenter l'électronique, mais cela peut être intimidant. Avoir un projet à construire peut vous aider à rester motivé pendant que vous apprenez.
Il existe plusieurs jeux simples qui font d'excellents projets pour débutants Raspberry Pi. Le jeu Simon est facile à démarrer. Simon est un jeu de mémoire dans lequel une série de lumières clignotent dans un ordre aléatoire, et le joueur doit se souvenir de la séquence. Au fur et à mesure que le joueur progresse, la longueur de la séquence augmente.
Pour commencer, vous aurez besoin des éléments suivants :
Vous pouvez utiliser n'importe quel Raspberry Pi pour ce projet, mais les modèles Pi Zero ne se connectent pas aussi facilement aux planches à pain sans quelques soudures. Quel que soit le modèle que vous utilisez, vous aurez également besoin d'une source d'alimentation, d'un moniteur, d'un clavier et d'une souris.
Si vous n'avez jamais configuré de Raspberry Pi auparavant, vous pouvez apprendre à tout préparer pour ce didacticiel dans le guide du débutant Raspberry Pi.
Vous allez écrire du code Python dans ce didacticiel et vous pouvez utiliser n'importe quel éditeur de texte pour l'écrire, mais vous trouverez peut-être un éditeur de code plus facile. Il y en a plusieurs déjà installés sur le Raspberry Pi OS, et Thonny est conçu pour être facile pour les débutants. Quel que soit celui que vous utilisez, vous devrez être en mesure d'enregistrer et d'exécuter votre code pour suivre ce didacticiel.
Si vous n'avez jamais utilisé de planche à pain auparavant, vous pouvez commencer par lire un tutoriel sur la planche à pain. Comprendre le fonctionnement d'une planche à pain vous aidera à comprendre comment créer des circuits.
Le Raspberry Pi possède deux rangées de broches d'entrée/sortie à usage général (GPIO). Ces broches vous permettent de connecter des composants à votre Raspberry Pi. Certaines broches envoient des informations, d'autres fournissent de l'énergie et certaines mettent vos appareils électroniques à la terre.
Nous allons commencer par ajouter une lumière LED à notre planche à pain. Si vous n'avez jamais travaillé avec des lumières LED sur une planche à pain auparavant, vous voudrez peut-être lire un didacticiel qui expliquera plus en détail son fonctionnement.
Commencez par connecter une broche GPIO à votre carte. Peu importe la broche, tant qu'il s'agit d'une broche GPIO et non d'une broche d'alimentation ou de masse. Ci-dessus se trouve un tableau des broches GPIO, qui vous aidera à déterminer quelle broche utiliser. Ce didacticiel utilise la broche numéro 18, qui est également étiquetée GPIO 24.
La broche fournira une certaine alimentation à la planche à pain et permettra au Raspberry Pi de communiquer avec les composants de la carte. Connectez ensuite la broche numéro 6 du Pi au rail de masse de la planche à pain. Cela mettra la carte à la terre et nous permettra de créer des circuits.
La puissance provenant du Raspberry est trop élevée pour connecter directement la LED. L'utilisation d'une résistance réduit le niveau de puissance et empêche la LED de s'éteindre. Connectez un côté de la résistance à la même ligne sur laquelle la broche GPIO est branchée et l'extrémité à l'autre côté de la planche à pain. Placez ensuite le côté positif de la LED après la résistance. L'extrémité négative de la LED peut être connectée directement au rail négatif. Le résultat final devrait ressembler au diagramme ci-dessus. Vérifiez soigneusement votre câblage et allumez votre Pi. La LED doit s'allumer.
Maintenant, vous avez créé un circuit à l'aide de votre Raspberry Pi que vous pouvez contrôler à l'aide de code.
Ce didacticiel vous guide pas à pas dans le code, mais si vous souhaitez vous référer au code fini à tout moment, il est disponible sur Pastebin.
À l'heure actuelle, l'alimentation va à la LED, mais nous voulons contrôler quand elle s'allume et s'éteint. Le code Python suivant nous permettra de parler au conseil.
importer RPi.GPIO en tant que GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(Faux)
rouge =18
GPIO.setup (rouge, GPIO.OUT)
Sortie GPIO (rouge, GPIO.LOW)
Les premières lignes mettent les choses en place. La bibliothèque Raspberry Pi GPIO est importée. Le comme GPIO nous permet simplement de nous référer à RPi.GPIO comme GPIO pour économiser un peu de frappe. Le mode de broche GPIO est défini sur BOARD . Vous n'êtes pas obligé d'utiliser ce paramètre, mais il peut être plus facile de se référer aux broches par leur ordre dans les lignes GPIO.
Enfin, nous définissons les avertissements sur faux. Cela arrêtera les avertissements inutiles.
Les trois lignes suivantes contrôlent la LED. La LED rouge est attachée à la broche GPIO 18. Au lieu de s'en souvenir, la variable rouge stockera l'emplacement. Ensuite, GPIO.setup indique à notre programme qu'il envoie des informations out au rouge épingler. Enfin, nous définissons le GPIO. sortie sur le rouge épingler à bas . Lorsque vous exécutez ce programme, le voyant s'éteint. Pour le réactiver, basculez GPIO.LOW sur GPIO.HIGH et relancez le programme.
Enregistrez le code et cliquez sur Exécuter pour le voir en action. S'il n'y a pas de bouton d'exécution dans votre éditeur de code, enregistrez-le et exécutez python myfilename.py dans la fenêtre du terminal. Vous devrez d'abord accéder au même répertoire que votre nouveau fichier Python. Consultez la feuille de triche Raspberry Pi si vous ne savez pas comment procéder.
Pour créer le jeu Simon, nous avons besoin de quatre lumières de couleurs différentes. Les mêmes étapes que vous avez utilisées pour configurer la LED rouge peuvent être utilisées pour configurer les trois autres. Votre câblage doit ressembler au schéma ci-dessous :
Votre code devrait ressembler à ceci :
importer RPi.GPIO en tant que GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(Faux)
rouge =18
jaune =22
vert =24
bleu =26
GPIO.setup (rouge, GPIO.OUT)
GPIO.setup (jaune, GPIO.OUT)
GPIO.setup(vert, GPIO.OUT)
GPIO.setup(bleu, GPIO.OUT)
Sortie GPIO (rouge, GPIO.HIGH)
Sortie GPIO (jaune, GPIO.HIGH)
Sortie GPIO (vert, GPIO.HIGH)
Sortie GPIO (bleu, GPIO.HIGH)
Une fois que vous avez testé les LED, définissez le GPIO.output à GPIO.LOW pour les éteindre à nouveau.
Bien que la couleur des fils que vous utilisez n'ait pas d'importance, essayez d'utiliser des couleurs qui ont du sens pour vous afin de faciliter la lecture du tableau. Par exemple, les fils noirs sont souvent utilisés pour les fils de terre. Dans ce circuit, vous voudrez peut-être faire correspondre la couleur du fil à la couleur de la lumière LED.
Commencez par ajouter un bouton à votre tableau. Le bouton devra être connecté à la fois à la terre et à une broche GPIO. Le circuit devrait ressembler à ceci :
Pour que le bouton contrôle une LED, nous devons ajouter à notre code. La configuration du bouton est similaire à la configuration d'une LED, sauf que la broche GPIO est définie comme une entrée et non comme une sortie. Ce code configure également la résistance pull-up interne sur le Pi, qui est nécessaire pour que le bouton se comporte correctement.
GPIO.setup(32, GPIO.IN, pull_up_down=GPIO.PUD_UP)
Nous avons maintenant besoin d'un code qui vérifie si le bouton a été enfoncé.
jeu =Vrai
pendant le jeu :
redButtonState =GPIO.entrée(32)
si redButtonState ==0 :
Sortie GPIO (rouge, GPIO.HIGH)
temps.sommeil(1)
Sortie GPIO (rouge, GPIO.LOW)
Nous voulons que notre programme continue à vérifier si un bouton est enfoncé, nous utilisons donc une boucle while . Parce que la boucle ne sera jamais fausse, elle continue de s'exécuter et de vérifier le bouton jusqu'à ce que nous terminions le programme manuellement en appuyant sur le bouton d'arrêt ou en utilisant le raccourci clavier Ctrl + c .
Ensuite, pour faciliter la référence à l'entrée que notre broche GPIO de bouton nous envoie, nous enregistrons ces informations dans la variable redButtonState . Si notre entrée de bouton passe à 0, nous savons que le bouton a été enfoncé.
Si le bouton est enfoncé, la LED rouge s'allume. Puis, après une seconde, la LED s'éteindra. Pour chronométrer cela, nous utilisons le time.sleep(1) une fonction. Pour que cela fonctionne, vous devrez importer l'heure bibliothèque en haut de votre script.
Une fois qu'un bouton fonctionne, vous pouvez en ajouter trois autres, un pour chaque LED. Votre code devrait ressembler à ceci :
importer au hasard
temps d'importation
importer RPi.GPIO en tant que GPIO
GPIO.setmode (GPIO.BOARD)
GPIO.setwarnings(Faux)
rouge =18
jaune =22
vert =24
bleu =26
GPIO.setup (rouge, GPIO.OUT)
GPIO.setup (jaune, GPIO.OUT)
GPIO.setup(vert, GPIO.OUT)
GPIO.setup(bleu, GPIO.OUT)
GPIO.setup(32, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(36, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(38, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(40, GPIO.IN, pull_up_down=GPIO.PUD_UP)
jeu =Vrai
pendant le jeu :
redButtonState =GPIO.entrée(32)
si redButtonState ==0 :
Sortie GPIO (rouge, GPIO.HIGH)
temps.sommeil(1)
Sortie GPIO (rouge, GPIO.LOW)
yellowButtonState =GPIO.input(36)
si yellowButtonState ==0 :
Sortie GPIO (jaune, GPIO.HIGH)
temps.sommeil(1)
Sortie GPIO (jaune, GPIO.LOW)
greenButtonState =GPIO.entrée(38)
si greenButtonState ==0 :
Sortie GPIO (vert, GPIO.HIGH)
temps.sommeil(1)
GPIO.sortie (vert, GPIO.LOW)
blueButtonState =GPIO.entrée(40)
si blueButtonState ==0 :
Sortie GPIO (bleu, GPIO.HIGH)
temps.sommeil(1)
Sortie GPIO (bleu, GPIO.LOW)
Votre tableau devrait ressembler à ceci :
Toute l'électronique est maintenant en place. Si vous rencontrez des problèmes, vérifiez votre code pour toute erreur. N'oubliez pas que vous pouvez télécharger le code complet depuis Pastebin si vous êtes bloqué !
Ce projet a déjà couvert toutes les bases que vous devez connaître pour commencer à utiliser une planche à pain. Mais transformer ces compétences en jeu montrera vraiment ce que vous pouvez faire !
Dans Simon, un joueur voit une série de lumières clignoter et doit se souvenir du motif. Il démarre facilement avec une seule lumière. Chaque niveau ajoute une lumière aléatoire au motif pour rendre le jeu plus difficile.
Cette étape est assez simple. Un tableau contiendra notre motif léger . Un deuxième tableau stockera les broches GPIO pour nos lumières . À chaque boucle de jeu, une nouvelle lumière aléatoire sera ajoutée à la fin du motif déployer. Nous utilisons le aléatoire. randint() fonction pour choisir un nombre entre 0 et 3, représentant les 4 LED.
modèle =[]
lumières =[rouge, jaune, vert, bleu]
pendant le jeu :
pattern.append(random.randint(0,3)) Ensuite, nous devons allumer les lumières pour montrer le motif.
pendant le jeu :
motif.append(aléatoire.randint(0,3))
pour x dans le motif :
Sortie GPIO (lumières [x], GPIO.HIGH)
temps.sommeil(1)
Sortie GPIO (lumières [x], GPIO.LOW)
temps.sleep(0.5)
Il est important de faire une pause entre deux feux. Cela permet de voir plus facilement si la même lumière est utilisée dos à dos dans le motif.
Ensuite, le jeu doit attendre que le joueur devine l'ordre des lumières. Le programme doit à la fois vérifier chaque lumière du motif et attendre que le joueur appuie sur un bouton. Cela nécessite des boucles imbriquées :
pour x dans le motif :
waitForInput =Vrai
en attendantForInput :
redButtonState =GPIO.entrée(32)
yellowButtonState =GPIO.input(36)
greenButtonState =GPIO.entrée(38)
blueButtonState =GPIO.entrée(40)
si redButtonState ==0 :
Sortie GPIO (rouge, GPIO.HIGH)
waitForInput =Faux
temps.sommeil(1)
Sortie GPIO (rouge, GPIO.LOW)
si yellowButtonState ==0 :
Sortie GPIO (jaune, GPIO.HIGH)
waitForInput =Faux
temps.sommeil(1)
Sortie GPIO (jaune, GPIO.LOW)
si greenButtonState ==0 :
Sortie GPIO (vert, GPIO.HIGH)
waitForInput =Faux
temps.sommeil(1)
GPIO.sortie (vert, GPIO.LOW)
si blueButtonState ==0 :
Sortie GPIO (bleu, GPIO.HIGH)
waitForInput =Faux
temps.sommeil(1)
Sortie GPIO (bleu, GPIO.LOW)
La plupart du code ci-dessus réutilise le code que nous avons écrit pour tester les boutons.
À partir de là, il est assez facile de vérifier si le joueur a entré le bon schéma. Chaque fois qu'ils appuient sur un bouton, le jeu peut vérifier s'il s'agit du bon bouton. Pour ce faire, ajoutez une autre instruction if à chaque entrée de bouton :
si redButtonState ==0 :
Sortie GPIO (rouge, GPIO.HIGH)
waitForInput =Faux
si x !=0 :
jeu =faux
temps.sommeil(1)
Sortie GPIO (rouge, GPIO.LOW)
La variablex de notre boucle for a le numéro de la prochaine lumière. La lumière LED rouge est en première position, ou numéro 0. Si le joueur a appuyé sur le bouton LED rouge lorsque nous avons un 0 dans notre modèle, il a raison ! Sinon, ils perdent la partie. Définition de la variable jeu à false arrêtera notre boucle de jeu et terminera le programme.
La création d'un jeu a ajouté beaucoup plus de code à ce projet que le simple ajout de LED et de boutons. Travailler à un projet final que vous pouvez montrer à vos amis et à votre famille peut vous aider à rester motivé.
Ce jeu est assez simple. Mettez-vous au défi d'améliorer la conception de base. Peut-être que les lumières pourraient clignoter si le joueur perd. Peut-être que vous voulez vous mettre au défi d'ajouter des sons au jeu. Votre imagination est la seule limite !
D'accord, ça et le matériel que vous avez sous la main.