Quand Elgato a annoncé sa nouvelle pédale Stream Deck, le monde des fabricants a déclaré : « Hé, je peux en fabriquer une pour moins d’argent ». Et avec ce cri de guerre nous avons atteint notre fidèle Framboise Pi Pico (dans notre cas KB2040 d’Adafruit) et ont pillé la boîte de commutateurs pour créer notre propre alternative.
La pédale Stream Deck d’Elgato est un contrôleur à trois pédales utilisé pour déclencher des actions pendant vos flux. Nous allons émuler cette fonctionnalité en utilisant trois commutateurs robustes, destinés aux pédales d’effets de guitare et un Raspberry Pi Pico exécutant CircuitPython d’Adafruit. Avec CircuitPython, nous pouvons créer un clavier USB et attribuer des frappes, voire des séquences entières de pressions à un seul bouton.
Une fois que nous aurons construit et codé notre pédale Pico, nous apprendrons à l’utiliser avec OBS, prêt pour notre prochain flux.
Pour ce projet, vous aurez besoin
Construire la pédale Pico
Le circuit de ce projet est extrêmement simple. Il utilise trois broches GPIO (2, 3 et 4) et une connexion de masse commune (GND). Nous connectons les boutons aux broches 2, 3 et 4, puis connectons chaque bouton à une broche GND différente sur le Pico. Toutes les broches GND se connectent à un seul GND, créant un point de référence commun.
Câblage et préparation du coffret
Avant d’entrer dans les détails, voici un mot sur la sécurité. La soudure est une grande compétence à apprendre, mais assurez-vous que vous portez une protection oculaire appropriée et que vous soudez dans un espace bien ventilé. Le perçage dans du plastique ou du métal produira des « copeaux », des fils et des morceaux de matériau percé. Portez des lunettes de protection et revérifiez vos positions avant de commencer l’exercice. Assurez-vous que le boîtier est fermement maintenu en place et percez toujours un avant-trou avant de percer des trous plus grands.
Nous avons choisi d’utiliser des commutateurs au pied momentanés, couramment utilisés dans les pédales de guitare. Ils sont conçus pour être estampés et ont donc les meilleures chances de survivre le plus longtemps. Le câblage est simple. Ils n’ont pas de polarité, ils établissent plutôt une connexion lorsqu’ils sont pressés. Dans ce projet, ils connectent un côté du commutateur à une broche GPIO, tirée vers le haut à l’aide des résistances internes du Pico à l’autre côté qui est connecté à la masse (GND). En appuyant sur le bouton, nous établissons la connexion entre les deux côtés, tirant la broche GPIO vers le bas et déclenchant une pression sur une touche.
Nous avons choisi une alternative à la soudure. Les bornes serties sont une méthode sans soudure qui utilise la friction pour maintenir les fils en place. Les sertissages maintiennent le fil à l’intérieur d’un manchon en plastique. Dans le manchon se trouve une borne en métal. Nous pressons le sertissage à l’aide d’un outil et cela verrouille le fil en place. La borne à sertir glisse ensuite sur les contacts de l’interrupteur. Les sertissages sont plus rapides et plus faciles que la soudure, mais ils représentent un coût supplémentaire.
Ces commutateurs doivent être sécurisés dans un boîtier approprié. En règle générale, nous utiliserions un boîtier en plastique, mais à moins de payer beaucoup d’argent, nous obtiendrons du plastique fragile. Des boîtiers en plastique ABS robustes peuvent être trouvés pour environ 10 $, mais nous avons opté pour un boîtier en aluminium, pour correspondre à l’esthétique industrielle et robuste de la pédale.
1. Mesurez trois points sur le couvercle de l’enceinte et percez un avant-trou pour chacun. Nous avons choisi le point mort du boîtier comme point de départ, puis mesuré 5 cm dans les deux sens à partir du centre. Avec le recul, nous nous serions déplacés plus loin, disons de 7 cm et nous aurions créé un triangle de points au lieu d’une ligne.
2. Déplacez-vous sur le côté de l’enceinte et percez un autre trou pilote pour le câble USB.
3. Passer à un foret plus grand et agrandir tous les trous. Fais le quelques fois avant de continuer.
4. Passer à un foret étagé puis agrandissez les trois trous du couvercle pour qu’ils correspondent au diamètre des boutons de la pédale. Dans notre cas, nous avions des commutateurs de 12 mm, nous avons donc utilisé un morceau de ruban adhésif pour identifier le pas sur le foret.
5. Utilisez une lime pour enlever les bords tranchants des trous.
6. Utilisez le foret étagé pour agrandir le trou pilote restant pour correspondre à la taille de la plus petite extrémité de votre câble USB.
sept. Limez le trou pour éliminer les arêtes vives. Ceci est important pour le câble USB car il frotte contre le trou et peut être endommagé.
8. Enfilez un câble USB approprié dans le trou, connectez-le à votre Pico et ajoutez un gros nœud pour soulager la tension. Le nœud réduira le risque de retrait accidentel du câble USB.
9. Sécurisez les fils des boutons à la borne à vis selon le schéma de circuit.
Vous devriez maintenant avoir les trois boutons connectés au Raspberry Pi Pico via la borne à vis. Ne fermez pas le couvercle tant que le code n’a pas été testé.
Installer CircuitPython et les bibliothèques
L’installation de CircuitPython est extrêmement simple et Adafruit a un guide fantastique sur la façon de procéder. Suivre Instructions d’Adafruit pour installer la dernière version.
Notre Raspberry Pi Pico apparaît maintenant comme un lecteur dans le gestionnaire de fichiers. Le lecteur s’appelle CIRCUITPY et nous y trouvons une série de fichiers et de dossiers. En ce moment, nous devons nous concentrer sur lib. Nous devons télécharger un fichier ZIP plein de bibliothèques et installer les fichiers corrects pour nos projets
1. Téléchargez le dernier ensemble de bibliothèques du site CircuitPython.
2. Extraire les fichiers sur votre bureau.
3. Copiez le dossier adafruit_hid à partir des fichiers extraits dans le dossier lib sur votre lecteur CIRCUITPY.
Codage de la pédale Pico
1. Ouvrez le fichier code.py trouvé à la racine du lecteur CIRCUITPY dans votre éditeur préféré.
2. Supprimer n’importe quel code dans le fichier.
3. Importez deux bibliothèques pour activer l’accès GPIO. La première carte est un moyen de base pour se connecter aux broches GPIO, la seconde fournit un moyen de contrôler l’état des broches.
import board
from digitalio import DigitalInOut, Direction, Pull
4. Importez quatre bibliothèques pour émuler un clavier et des frappes USB de disposition américaine.La bibliothèque USB HID ((Human Interface Device) permet à notre Pico de devenir un clavier. Les bibliothèques restantes configurent le clavier pour utiliser une disposition américaine et pour utiliser le code de touche pour envoyer des frappes.
import usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
from adafruit_hid.keycode import Keycode
5. Enfin, importez la bibliothèque de temps. Cette bibliothèque est utilisée pour ajouter une pause au code. Cela réduit le risque de double pression accidentelle (anti-rebond).
import time
6. Créez un objet clavier qui agira comme un HID USB.
keyboard = Keyboard(usb_hid.devices)
sept. Définissez la mise en page sur US.
keyboard_layout = KeyboardLayoutUS(keyboard)
8. Créez un nouvel objet, un, pour représenter le premier bouton de la pédale. Ce bouton est connecté à la broche 2 du Pico.
one = DigitalInOut(board.D2)
9. À l’aide d’un objet, définissez la broche comme entrée, et tirez la résistance interne vers le haut, de sorte que la broche soit haute (allumée) à 3,3 V.
one.direction = Direction.INPUT
one.pull = Pull.UP
dix. Répétez le processus pour une deuxième entrée. Cette fois, la variable doit être connecté à la broche 3.
two = DigitalInOut(board.D3)
two.direction = Direction.INPUT
two.pull = Pull.UP
11. Répétez l’opération pour une troisième entrée connectée à la broche 4.
three = DigitalInOut(board.D4)
three.direction = Direction.INPUT
three.pull = Pull.UP
12. Créer une variable, retarder, pour contenir la durée de pause de notre code. L’utilisation d’une variable permet d’ajuster facilement la durée en fonction de nos besoins.
delay = 0.5
13. Créer une boucle pour exécuter continuellement notre code.
while True:
14. Créez un test conditionnel qui vérifiera l’état du bouton un. S’il est enfoncé, le bouton connectera la broche GPIO, 2 (qui est True / HIGH), à la masse (GND) et changera l’état en False / LOW.
if one.value == False:
15. Ajouter une déclaration d’impression pour indiquer que la pression sur le bouton a été enregistrée. Il s’agit d’une étape de débogage qui peut être omise, mais nous trouvons utile de prouver que le code enregistre une presse car il élimine une chose à déboguer.
print("Button 1")
16. Envoyez une série d’appuis sur les touches. Dans notre cas, nous avons utilisé CTRL + ALT + A, mais vous pouvez changer cela en n’importe quelle touche que vous souhaitez et Adafruit a la liste de toutes les clés dont vous avez besoin.
keyboard.send(Keycode.CONTROL, Keycode.ALT, Keycode.A)
17. Relâchez les touches. En faisant cela sans délai, nous limitons la combinaison de touches à une seule pression de touche.
keyboard.release_all()
18. Ajoutez un délai pour réduire le risque d’appuyer plusieurs fois sur les touches.
time.sleep(delay)
19. Répétez le processus pour le deuxième bouton.
elif two.value == False:
print("Button 2")
keyboard.send(Keycode.CONTROL, Keycode.ALT, Keycode.B)
keyboard.release_all()
time.sleep(delay)
20. Répétez le processus pour le troisième bouton.
elif three.value == False:
print("Button 3")
keyboard.send(Keycode.CONTROL, Keycode.ALT, Keycode.C)
keyboard.release_all()
time.sleep(delay)
21. Ajoutez une autre condition pour imprimer « En attente d’appui sur le bouton » avec un court délai avant que la boucle ne se répète. La condition else est activée lorsqu’aucun bouton n’est enfoncé.
else:
print("Waiting for button press")
time.sleep(0.1)
Enregistrez le code sur votre Raspberry Pi Pico et CircuitPython rechargera et exécutera le code. Ne fermez pas l’affaire tout de suite !
Utilisation de la pédale Pico avec OBS
Open Broadcaster Software (OBS) est un remarquable outil de streaming gratuit. Avec OBS, nous pouvons diffuser en direct sur YouTube, Twitch et de nombreuses autres plateformes. Nous pouvons également enregistrer des vidéos pour un montage ultérieur. OBS utilise Scenes pour créer différents angles de caméra, screencasts et autres entrées vidéo.
Nous utilisons un certain nombre de scènes pour The Pi Cast, notre émission hebdomadaire Raspberry Pi. Nous avons une scène pour notre caméra frontale, une scène pour les caméras aériennes pour montrer un projet et une scène pour montrer un flux d’images ou de fiches techniques. Pour échanger des scènes, nous avons un clavier programmé pour se déplacer entre elles à l’aide de touches de raccourci. La pédale Pico peut être utilisée de la même manière. Vous devrez avoir déjà créé les scènes afin de créer des raccourcis clavier pour elles.
1. OBS ouvert et accédez aux paramètrestrouvé dans le coin inférieur droit.
2. Cliquez sur Raccourcis clavier.
3. Faites défiler jusqu’à la scène pour laquelle vous souhaitez ajouter un raccourci clavier. Dans notre exemple, nous allons à Face.
4. Cliquez sur la case noire pour passer à la scène.
5. Sur votre pédale, appuyez sur le bouton que vous souhaitez affecter à la scène. OBS se mettra à jour pour afficher cette pression sur le bouton.
6. Cliquez sur Appliquer et OK pour enregistrer le raccourci clavier.
sept. Répétez le processus pour les deux boutons supplémentaires.
Vous avez maintenant les boutons de votre pédale mappés sur OBS, prêts pour votre prochain flux. Vous pouvez maintenant vous déplacer en douceur d’une scène à l’autre sans toucher le clavier.
Liste complète des codes
import board
from digitalio import DigitalInOut, Direction, Pull
import usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
from adafruit_hid.keycode import Keycode
import time
keyboard = Keyboard(usb_hid.devices)
keyboard_layout = KeyboardLayoutUS(keyboard)
one = DigitalInOut(board.D2)
one.direction = Direction.INPUT
one.pull = Pull.UP
two = DigitalInOut(board.D3)
two.direction = Direction.INPUT
two.pull = Pull.UP
three = DigitalInOut(board.D4)
three.direction = Direction.INPUT
three.pull = Pull.UP
delay = 0.5
while True:
if one.value == False:
print("Button 1")
keyboard.send(Keycode.CONTROL, Keycode.ALT, Keycode.A)
keyboard.release_all()
time.sleep(delay)
elif two.value == False:
print("Button 2")
keyboard.send(Keycode.CONTROL, Keycode.ALT, Keycode.B)
keyboard.release_all()
time.sleep(delay)
elif three.value == False:
print("Button 3")
keyboard.send(Keycode.CONTROL, Keycode.ALT, Keycode.C)
keyboard.release_all()
time.sleep(delay)
else:
print("Waiting for button press")
time.sleep(0.1)