Walabot FX - Contrôle des effets de guitare : 28 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:11

Contrôlez votre effet de guitare préféré en n'utilisant rien d'autre que des poses de guitare impressionnantes !

Étape 1: choses dont vous aurez besoin

Composants matériels

Walabot - Walabot

Raspberry Pi - Raspberry Pi 3 modèle B

Sunfounder LCD1602

Pilote de servomoteur SunFounder PCA9685 16 canaux 12 bits PWM pour Arduino et Raspberry Pi

Servo (générique) Pas de lien

Clip de batterie 9V

Support de 4 piles AA

Piles AA

Cavaliers (génériques)

Interrupteur au pied à action de verrouillage DPDT

Korg SDD3000-PDL

Systèmes d'exploitation logiciels, applications et services en ligne

Autodesk Fusion360 -

Blynk -

Outils etc

Imprimante 3D

Fer à souder

Étape 2: Résumé

Comment cela serait-il de contrôler l'expression musicale en utilisant uniquement la position de votre guitare dans l'espace 3D ? Eh bien, faisons un prototype de quelque chose et découvrons-le !

Étape 3: L'idée de base

Je voulais pouvoir contrôler 3 paramètres d'effets en temps réel, je voulais le faire en utilisant la façon dont j'ai positionné ma guitare. Donc une chose était claire, j'allais avoir besoin de quelques trucs.

• Un capteur capable de voir l'espace en 3D
• Servos pour tourner les boutons
• Un écran LCD
• Un pilote Servo I2C
• Un Raspberry Pi
• Pour apprendre Python

Étape 4: Walabot

Vous voulez voir à travers les murs ? Détecter des objets dans l'espace 3D ? Sentez-vous si vous respirez de l'autre côté de la pièce ? Eh bien, vous avez de la chance!

Le Walabot est une toute nouvelle façon de détecter l'espace autour de vous à l'aide d'un radar à faible puissance.

Cela allait être la clé de ce projet, je serais capable de prendre les coordonnées carteasan (X-Y-Z) d'objets dans l'espace 3D et de les mapper sur des positions d'asservissement modifiant le son d'un effet de guitare, en temps réel, sans toucher à la pédale.

Gagner.

Plus d'informations sur le Walabot peuvent être trouvées ici

Étape 5: Mise en route

Tout d'abord, vous aurez besoin d'un ordinateur pour piloter le Walabot, pour ce projet, j'utilise un Raspberry Pi 3 (ici en référence à RPi) en raison du WiFi intégré et du punch supplémentaire général

J'ai acheté une carte SD de 16 Go avec NOOBS préinstallé pour que les choses restent simples et agréables, et j'ai choisi d'installer Raspian comme système d'exploitation Linux de choix

(si vous ne savez pas comment installer Raspian, veuillez prendre un moment pour lire ceci un peu)

OK, une fois que vous avez exécuté Raspian sur votre RPi, il y a quelques étapes de configuration à suivre pour préparer les choses pour notre projet

Étape 6: Configuration du Raspberry Pi - 1

Tout d'abord, assurez-vous que vous exécutez la dernière version du noyau et vérifiez les mises à jour en ouvrant un shell de commande et en tapant

sudo apt-get mise à jour

sudo apt-get dist-upgrade

(sudo est ajouté pour vous assurer que vous avez des privilèges administratifs, par exemple, les choses fonctionneront)

Cela peut prendre un certain temps, alors allez-y et prenez une bonne tasse de thé.

Étape 7: Configuration du Raspberry Pi - 2

Vous devez installer le SDK Walabot pour RPi. À partir de votre navigateur Web RPi, accédez à https://www.walabot.com/gettingstarted et téléchargez le package d'installation Raspberry Pi.

Depuis un shell de commande:

téléchargements de CD

sudo dpkg -I walabotSDK_RasbPi.deb

Étape 8: Configuration du Raspberry Pi - 3

Nous devons commencer à configurer le RPi pour utiliser le bus i2c. À partir d'un shell de commande:

sudo apt-get installer python-smbus

sudo apt-get install i2c-tools

une fois cela fait, vous devez ajouter ce qui suit au fichier modules

Depuis un shell de commande:

sudo nano /etc/modules

ajoutez ces 2 chaînes sur des lignes séparées:

i2c-dev

i2c-bcm2708

Étape 9: Configuration du Raspberry Pi - 4

Le Walabot consomme pas mal de courant, et nous utiliserons également des GPIO pour contrôler les choses, nous devons donc les configurer.

Depuis un shell de commande:

sudo nano /boot/config.txt

ajoutez les lignes suivantes à la fin du fichier:

safe_mode_gpio=4

max_usb_current=1

Le RPi est un excellent outil pour les makers, mais il est limité dans le courant qu'il peut envoyer au Walabot. C'est pourquoi nous ajoutons un courant max de 1Amp plutôt que le 500mA plus standard

Étape 10: Python

Pourquoi Python ? eh bien, car c'est super facile à coder, rapide à démarrer et il y a plein de bons exemples python disponibles ! Je ne l'avais jamais utilisé auparavant et j'étais bientôt opérationnel en un rien de temps. Maintenant que le RPi est configuré pour ce que nous voulons, la prochaine étape consiste à configurer Python pour avoir accès à l'API Walabot, aux interfaces LCD Servo

Étape 11: Pour le Walabot

Depuis un shell de commande

Sudo pip install "/usr/share/walabot/python/WalabotAPI-1.0.21.zip"

Étape 12: Pour l'interface servo

Depuis un shell de commande

sudo apt-get install git build-essential python-dev

disque ~

git clone

cd Adafruit_Python_PCA9685

sudo python setup.py installer

Pourquoi avons-nous besoin d'utiliser un servomoteur ? Eh bien, pour un RPi, plusieurs raisons.

1. Le courant consommé par un servo peut être très élevé, et ce nombre augmente avec le nombre de servos (bien sûr). Si vous pilotez le servo directement depuis un RPi, vous risquez de faire exploser son alimentation

2. Les synchronisations du PWM (Pulse Width Modulation) qui contrôlent la position des servos sont très importantes. Comme le RPi n'utilise pas de système d'exploitation en temps réel (il peut y avoir des interruptions, etc.), les timings ne sont pas précis et peuvent faire trembler nerveusement les servos. Un pilote dédié permet un contrôle précis, mais permet également d'ajouter jusqu'à 16 servos, ce qui est idéal pour l'expansion.

Étape 13: Pour l'écran LCD

ouvrez votre navigateur Web RPi

www.sunfounder.com/learn/category/sensor-k…

Télécharger

github.com/daveyclk/SunFounder_SensorKit_…

Depuis un shell de commande:

sudo mkdir /usr/share/sunfounder

À l'aide de l'explorateur graphique, copiez le dossier python du fichier zip dans votre nouveau dossier sunfounder

L'écran LCD est utilisé pour demander à l'utilisateur ce qui se passe exactement. Affichage du processus de configuration jusqu'aux valeurs x, y et z mappées sur chaque servo

Étape 14: Blynk

Blynk est un service IoT génial qui vous permet de créer une application personnalisée pour contrôler vos affaires. Cela semblait être la solution parfaite pour me donner le contrôle à distance du walabot pour vraiment régler les paramètres…

Un problème. Blynk n'est actuellement pas pris en charge sur la plate-forme Python, bugger. Mais n'ayez crainte ! J'ai pu trouver une petite solution de contournement qui permet le contrôle à distance et la saisie de paramètres à distance ! c'est un peu bidon

la première étape consiste à télécharger l'application Blynk depuis votre app store préféré

Deuxièmement, créez un compte

Une fois cela fait, ouvrez l'application et démarrez un nouveau projet, en choisissant Raspberry Pi 3 comme matériel.

L'application vous attribuera un jeton d'accès (vous en aurez besoin pour saisir votre code)

Une fois que vous avez fait cela. vous devrez configurer l'application comme indiqué dans les images. C'est ainsi qu'il s'interfacera avec le walabot.

Étape 15: Configuration de l'application Blynk

Étape 16: Vous pouvez utiliser ce code QR avec l'application Blynk pour cloner mon projet et gagner du temps

OK Maintenant que l'application est configurée, nous pouvons configurer Python et le RPi pour lui parler sur Internet. la magie

Étape 17: Exécuter Blynk avec le Raspberry Pi et utiliser le Blynk HTTPS pour Python

Tout d'abord, vous devez installer le wrapper Blynk HTTPS pour Python

Depuis un shell de commande:

sudo git clone

sudo pip installer blynkapi

Deuxièmement, vous devez installer le service Blynk sur le RPi

Depuis un shell de commande:

git clone

cd blynk-library/linux

nettoyer tout

pour exécuter le service blynk

sudo./blynk --token=YourAuthToken

Pour vous assurer que le service Blynk s'exécute au démarrage, vous devez modifier le fichier /etc/rc.local

en faisant

sudo nano /etc/rc.local

ajoute ceci à la fin

./blynk-library/linux/blynk --token=mon jeton &

(j'ai inclus une copie de mon fichier /etc/rc.local dans la section code pour référence)

Pour tester son fonctionnement, tapez simplement

sudo /etc/rc.local start

Le service Blynk devrait maintenant être en cours d'exécution

Étape 18: Exécution automatique du script

Maintenant que tout est mis en place et configuré, et nous avons le code python prêt. nous pouvons configurer les choses pour qu'elles s'exécutent automatiquement afin que nous puissions abandonner le clavier et les moniteurs

Il y a quelques choses à faire

Créez un nouveau fichier de script pour exécuter le programme Python

sudo nano guitareffect.sh

ajouter ces lignes

#!/bin/sh

python /home/pi/GuitarEffectCLI.py

assurez-vous de l'enregistrer

Ensuite, nous devons donner au script l'autorisation de s'exécuter en tapant

Sudo chmod +x /home/pi/guitareffect.sh

Et enfin, nous devons ajouter ce script au fichier /etc/rc.local que nous avons bricolé plus tôt.

Sudo nano /etc/rc.local

Ajouter

/home/pi/guitareffect.sh &

assurez-vous d'inclure le "&" cela permet au script Python de s'exécuter en arrière-plan

Droit! C'est toute la configuration et le logiciel triés, ensuite il est temps de câbler le matériel

Étape 19: le matériel

Premier prototype de planche à pain

Étape 20: Conception de l'enceinte

Le boîtier a été conçu et rendu dans l'impressionnant Fusion360

Étape 21: Coups de cœur

Étape 22: Prises de vue de l'assemblage final

Étape 23: Pour fixer le Walabot au support

Utilisez le disque métallique autocollant fourni avec le walabot pour le fixer en place

Étape 24: Fichiers STL matériels pour l'impression 3D

Étape 25: Schémas de câblage de la chose

Étape 26: Coder

Utilisez le script Python joint pour votre projet

depuis _future_ import print_functiondepuis la plate-forme d'import sys depuis le système d'import os depuis blynkapi import Blynk import WalabotAPI import time import RPi. GPIO as GPIO

#configurer GPIO à l'aide de la numérotation des cartes

GPIO.setmode(GPIO. BOARD) GPIO.setup(18, GPIO. IN, pull_up_down = GPIO. PUD_UP)

#jeton d'authentification blynk

auth_token = "votre_auth_token_here"

# Importez le module PCA9685 pour l'asservissement.

importer Adafruit_PCA9685

#importer le module LCD de l'emplacement

from imp import load_source LCD1602 = load_source('LCD1602', '/usr/share/sunfounder/Python/LCD1602.py')

# Initialisez le PCA9685 en utilisant l'adresse par défaut (0x40).

pwm = Adafruit_PCA9685. PCA9685()

# blynk objets

defaults = Blynk(auth_token, pin = "V9") start_button = Blynk(auth_token, pin = "V3") Rmax = Blynk(auth_token, pin = "V0") Rmin = Blynk(auth_token, pin = "V1") Rres = Blynk(auth_token, pin = "V2")

ThetaMax = Blynk (auth_token, broche = "V4")

ThetaRes = Blynk(auth_token, pin = "V5")

PhiMax = Blynk (auth_token, broche = "V6")

PhiRes = Blynk (auth_token, broche = "V7")

Seuil = Blynk (auth_token, broche = "V8")

ServoMin = Blynk (auth_token, broche = "V10")

ServoMax = Blynk (auth_token, broche = "V11")

def LCDsetup():

LCD1602.init (0x27, 1) # init (adresse esclave, rétroéclairage)

def numMap(x, in_min, in_max, out_min, out_max): """ utilisé pour mapper les lectures du walabot à la position du servo """ return int((x- in_min) * (out_max - out_min) / (in_max - in_min) + out_min)

# utilisez ceci pour arrondir les données brutes à la valeur attribuée

def myRound(x, base=2): return int(base * round(float(x)/base))

# extrait le nombre de la chaîne blynk renvoyée

def numberExtract(val): val = str(val) return int(filter(str.isdigit, val))

# Réglez la fréquence sur 60 Hz, bon pour les servos.

pwm.set_pwm_freq(60)

# Configurer les valeurs par défaut des longueurs d'impulsions d'asservissement min et max

SERVO_MIN = 175 # Longueur d'impulsion min sur 4096 SERVO_MAX = 575 # Longueur d'impulsion max sur 4096

# valeurs par défaut de walabot

R_MAX = 60 R_MIN = 20 R_RES = 5

THETA_MAX = 20

THETA_RES = 5

PHI_MAX = 20

PHI_RES = 5

SEUIL = 1

# variables pour la commutation blynk

sur = "[u'1']"

classe Walabot:

def _init_(self):

self.wlbt = WalabotAPI self.wlbt. Init() self.wlbt. SetSettingsFolder() self.isConnected = False self.isTargets = False

def blynkConfig(self):

load_defaults = defaults.get_val() if str(load_defaults) == on: SERVO_MAX = ServoMax.get_val() SERVO_MAX = numberExtract(SERVO_MAX) print("Servo Max =", SERVO_MAX)

SERVO_MIN = ServoMin.get_val()

SERVO_MIN = numberExtract(SERVO_MIN) print("Servo MIN =", SERVO_MIN) R_MAX = Rmax.get_val() R_MAX = numberExtract(R_MAX) print("R max =", R_MAX)

R_MIN = Rmin.get_val()

R_MIN = nombreExtraire(R_MIN) print("R Min =", R_MIN)

R_RES = Rres.get_val()

R_RES = nombreExtrait(R_RES) print("R Res =", R_RES)

THETA_MAX = ThetaMax.get_val()

THETA_MAX = numberExtract(THETA_MAX) print("Theta Max =", THETA_MAX) THETA_RES = ThetaRes.get_val() THETA_RES = numberExtract(THETA_RES) print("Theta Res =", THETA_RES)

PHI_MAX = PhiMax.get_val()

PHI_MAX = nombreExtrait(PHI_MAX) print("Phi Max =", PHI_MAX) PHI_RES = PhiRes.get_val() PHI_RES = nombreExtrait(PHI_RES) print("Phi Res =", PHI_RES)

SEUIL = Seuil.get_val()

SEUIL = nombreExtraire(SEUIL) print("Seuil =", SEUIL)

else: # si rien dans l'application blynk, charger les valeurs par défaut SERVO_MIN = 175 # Longueur d'impulsion min sur 4096 SERVO_MAX = 575 # Longueur d'impulsion max sur 4096

# valeurs par défaut de walabot

R_MAX = 60 R_MIN = 20 R_RES = 5

THETA_MAX = 20

THETA_RES = 5

PHI_MAX = 20

PHI_RES = 5

SEUIL = 1

def connect(self): essayez: self.wlbt. ConnectAny() self.isConnected = True self.wlbt. SetProfile(self.wlbt. PROF_SENSOR) #self.wlbt. SetDynamicImageFilter(self.wlbt. FILTER_TYPE_MTI) self.wlbt. SetDynamicImageFilter (self.wlbt. FILTER_TYPE_NONE) #self.wlbt. SetDynamicImageFilter(self.wlbt. FILTER_TYPE_DERIVATIVE) self.wlbt. SetArenaTheta(-THETA_MAX, THETA_MAX, THETA_RES) self.wlbt. SetArenaPhi(-PHI_MAX, PHI_MAX, PHI_MAX, PHI_MAX, THETA_RES) SetArenaR(R_MIN, R_MAX, R_RES) self.wlbt. SetThreshold(THRESHOLD) sauf self.wlbt. WalabotError as err: if err.code != 19: # 'WALABOT_INSTRUMENT_NOT_FOUND' raise err

def start(self):

self.wlbt. Start()

def calibrer (auto):

self.wlbt. StartCalibration()

def get_targets(self):

self.wlbt. Trigger() renvoie self.wlbt. GetSensorTargets()

def stop(se):

self.wlbt. Stop()

def déconnecter (auto):

self.wlbt. Déconnecter()

def principal():

flag = True check = "" LCDsetup() tandis que flag: LCD1602.write(0, 0, 'Guitare') LCD1602.write(0, 1, 'Effect Control') time.sleep(2) LCD1602.write(0, 0, 'Press Start to ') LCD1602.write(0, 1, 'begin') time.sleep(2) if (str(check) == on): flag = False else: check = start_button.get_val() # vérifier le bouton de démarrage blynk appuyez sur if (GPIO.input (18) == 0): #check footswitch flag = False

LCD1602.write(0, 0, "OK! Faisons-le")

LCD1602.write(0, 1, ' ') wlbt = Walabot() wlbt.blynkConfig() wlbt.connect() LCD1602.clear() sinon wlbt.isConnected: LCD1602.write(0, 0, 'Non connecté ') sinon: LCD1602.write(0, 0, 'Connecté') time.sleep(2) wlbt.start() wlbt.calibrate() LCD1602.write(0, 0, 'Calibrage…..') time.sleep(3) LCD1602.write(0, 0, 'Démarrage de Walabot')

appcheck = start_button.app_status() flag = True # réinitialiser l'indicateur pour le programme principal

while flag: # utilisé pour mettre l'effet en veille (effectivement)

if (appcheck == True): if (str(check) != on): if (GPIO.input(18) != 0): #check footswitch flag = False else: check = start_button.get_val() #check for appuyez sur le bouton de démarrage appcheck = start_button.app_status()

autre:

if (GPIO.input(18) != 0): #check footswitch flag = False

xval = 0

yval = 0 zval = 0 moyenne = 2 delayTime = 0

cibles = wlbt.get_targets()

si len(cibles) > 0:

pour j dans la plage (moyenne):

cibles = wlbt.get_targets()

si len(cibles) > 0: print(len(cibles)) cibles = cibles[0]

print(str(cibles.xPosCm))

xval += int(targets.xPosCm) yval += int(targets.yPosCm) zval += int(targets.zPosCm) time.sleep(delayTime) else: print("pas de cibles") xval = xval/average

xval = numMap(xval, -60, 60, SERVO_MIN, SERVO_MAX)

xval = myRound(xval) si xval SERVO_MAX: xval = SERVO_MAX LCD1602.write(0, 0, 'x=' + str(xval) + ' ') pwm.set_pwm(0, 0, xval)

yval = yval/moyenne

yval = numMap(yval, -60, 60, SERVO_MIN, SERVO_MAX)

yval = myRound(yval) si yval SERVO_MAX: yval = SERVO_MAX LCD1602.write(0, 1, 'y=' + str(yval)) pwm.set_pwm(1, 0, yval)

zval = zval/moyenne

zval = numMap(zval, R_MIN, R_MAX, SERVO_MIN, SERVO_MAX)

zval = myRound(zval) si zval SERVO_MAX: zval = SERVO_MAX LCD1602.write(8, 1, 'z=' + str(zval)) pwm.set_pwm(2, 0, zval)

autre:

print("pas de cibles") LCD1602.write(0, 0, "Arrêt") LCD1602.write(0, 1, 'Le Walabot') time.sleep(3) wlbt.stop() wlbt.disconnect()

if _name_ == '_main_':

tandis que True: principal()

pour l'effet guitar.sh

#!/bin/sh

cd /accueil/pi

sudo python GuitarEffectCLI.py

Une copie du fichier local RC pour référence

#!/bin/sh -e# # rc.local # # Ce script est exécuté à la fin de chaque niveau d'exécution multi-utilisateur. # Assurez-vous que le script "quittera 0" en cas de succès ou toute autre valeur # en cas d'erreur. # # Afin d'activer ou de désactiver ce script, changez simplement les # bits d'exécution. # # Par défaut, ce script ne fait rien.

# Imprimer l'adresse IP

_IP=$(nom d'hôte -I) || true if ["$_IP"]; then printf "Mon adresse IP est %s\n" "$_IP" fi

./blynk-library/linux/blynk --token="votre jeton va ici" &

dormir 10 sudo /home/pi/guitareffect.sh & quitter 0

Étape 27: Dépôts Github à utiliser

Utilisez-le pour l'écran LCD Sunfounder

github.com/daveyclk/SunFounder_SensorKit_f…

Utilisez ceci pour le servomoteur

github.com/daveyclk/Adafruit_Python_PCA968…

Utilisez ceci pour le wrapper Blynk Python

github.com/daveyclk/blynkapi

Étape 28: Conclusion

Eh bien, cela a été une courbe d'apprentissage abrupte, mais cela en valait vraiment la peine.

Mes plats à emporter sont

• J'ai dû apprendre Python… il s'avère que c'est un as
• Interfacé le Python sur le Raspberry Pi avec le service Blynk IoT. Ce n'est pas officiellement pris en charge, il y a donc des limites à ses fonctions. Fonctionne toujours aussi bien !
• Il s'avère que le Walabot est idéal pour l'expression musicale. Je l'ai utilisé sur un Korg SDD3000, mais vous pouvez utiliser n'importe quel effet que vous aimez

Allez-y vous-même. Ce n'est pas limité aux effets de guitare, je peux être utilisé avec n'importe quel instrument avec n'importe quel effet.

Finaliste du concours Raspberry Pi 2017