Walabot FX - Controllo degli effetti per chitarra: 28 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:06

Controlla il tuo effetto chitarra preferito usando nient'altro che fantastiche pose di chitarra!

Passaggio 1: cose di cui avrai bisogno

Componenti hardware

Walabot - Walabot

Raspberry Pi - Raspberry Pi 3 Modello B

Sunfounder LCD1602

SunFounder PCA9685 Servo driver PWM a 16 canali a 12 bit per Arduino e Raspberry Pi

Servo (generico) Nessun collegamento

Clip per batteria 9V

Portabatterie 4xAA

Batterie AA

Cavi per ponticelli (generici)

Interruttore a pedale DPDT ad azione di bloccaggio

Korg SDD3000-PDL

Sistemi operativi software, app e servizi online

Autodesk Fusion360 -

Blynk -

Strumenti ecc

stampante 3d

Saldatore

Passaggio 2: astratto

Come sarebbe controllare l'espressione musicale usando nient'altro che la posizione della tua chitarra nello spazio 3D? Bene, prototipiamo qualcosa e scopriamolo!

Passaggio 3: l'idea di base

Volevo essere in grado di controllare 3 parametri degli effetti in tempo reale, volevo farlo usando come ho posizionato la mia chitarra. Quindi una cosa era chiara, avrei avuto bisogno di alcune cose.

• Un sensore in grado di vedere lo spazio 3D
• Servi per girare le manopole
• Un display LCD
• Un servo driver I2C
• Un lampone Pi
• Per imparare Python

Passaggio 4: Walabot

Vuoi vedere attraverso i muri? Oggetti di senso nello spazio 3D? Ha senso se stai respirando dall'altra parte della stanza? Bene, sei fortunato!

Il Walabot è un modo completamente nuovo per rilevare lo spazio intorno a te utilizzando un radar a bassa potenza.

Questa sarebbe stata la chiave di questo progetto, sarei stato in grado di prendere le coordinate carteasan (X-Y-Z) degli oggetti nello spazio 3D e mapparle in posizioni servo modificando il suono di un effetto chitarra, in tempo reale, senza toccare il pedale.

Vincita.

Maggiori informazioni sul Walabot possono essere trovate qui

Passaggio 5: iniziare

Per prima cosa, avrai bisogno di un computer per guidare il Walabot, per questo progetto sto usando un Raspberry Pi 3 (qui in riferimento a RPi) a causa del WiFi integrato e della marcia in più generale

Ho acquistato una scheda SD da 16 GB con NOOBS preinstallato per mantenere le cose semplici e piacevoli e ho scelto di installare Raspian come sistema operativo Linux preferito

(se non hai familiarità con come installare Raspian, prenditi un momento per leggere un po' di questo)

OK, una volta che Raspian è in esecuzione sul tuo RPi, ci sono alcuni passaggi di configurazione da eseguire per preparare le cose per il nostro progetto

Passaggio 6: configurazione del Raspberry Pi - 1

Innanzitutto assicurati di eseguire l'ultima versione del kernel e controlla gli aggiornamenti aprendo una shell di comando e digitando

sudo apt-get update

sudo apt-get dist-upgrade

(sudo viene aggiunto per assicurarti di avere privilegi amministrativi, ad es. le cose funzioneranno)

Potrebbe volerci un po' di tempo, quindi vai a bere una bella tazza di tè.

Passaggio 7: configurazione del Raspberry Pi - 2

Devi installare Walabot SDK per RPi. Dal tuo browser web RPi vai su https://www.walabot.com/gettingstarted e scarica il pacchetto di installazione Raspberry Pi.

Da una shell di comando:

download di cd

sudo dpkg -I walabotSDK_RasbPi.deb

Passaggio 8: configurazione del Raspberry Pi - 3

Dobbiamo iniziare a configurare l'RPi per utilizzare il bus i2c. Da una shell di comando:

sudo apt-get install python-smbus

sudo apt-get install i2c-tools

una volta fatto, devi aggiungere quanto segue al file dei moduli

Da una shell di comando:

sudo nano /etc/modules

aggiungi queste 2 stringhe su righe separate:

i2c-dev

i2c-bcm2708

Passaggio 9: configurazione del Raspberry Pi - 4

Il Walabot assorbe una discreta quantità di corrente e utilizzeremo anche i GPIO per controllare le cose, quindi dobbiamo configurarle

Da una shell di comando:

sudo nano /boot/config.txt

aggiungere le seguenti righe alla fine del file:

safe_mode_gpio=4

max_usb_current=1

L'RPi è uno strumento eccellente per i produttori, ma è limitato nella corrente che può inviare al Walabot. Ecco perché stiamo aggiungendo una corrente massima di 1 Amp anziché i 500 mA più standard

Passaggio 10: Python

Perché Python? bene, dato che è super facile da codificare, veloce da eseguire e ci sono un sacco di buoni esempi di Python disponibili! non l'avevo mai usato prima ed è stato subito installato e funzionante in pochissimo tempo. Ora l'RPi è configurato per quello che vogliamo, il passo successivo è configurare Python per avere accesso all'API Walabot, alle interfacce LCD Servo

Passaggio 11: per il Walabot

Da una shell dei comandi

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

Passaggio 12: per l'interfaccia servo

Da una shell dei comandi

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

cd ~

git clone

cd Adafruit_Python_PCA9685

sudo python setup.py install

Perché abbiamo bisogno di utilizzare un servo driver? Bene, per un RPi un paio di motivi.

1. La corrente assorbita da un servo può essere molto alta, e quel numero aumenta quanto più servo hai (ovviamente). Se stai guidando il servo direttamente da un RPi corri il rischio di far saltare l'alimentatore

2. I tempi del PWM (Pulse Width Modulation) che controllano la posizione dei servi sono molto importanti. Poiché l'RPi non utilizza un sistema operativo in tempo reale (potrebbero esserci interruzioni e simili) i tempi non sono precisi e possono far tremare nervosamente i servi. Un driver dedicato consente un controllo accurato, ma consente anche di aggiungere fino a 16 servi, quindi è ottimo per l'espansione.

Passaggio 13: per il display LCD

apri il tuo browser web RPi

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

Scarica

github.com/daveyclk/SunFounder_SensorKit_…

Da una shell di comando:

sudo mkdir /usr/share/fondatore del sole

Usando l'esploratore grafico, copia la cartella python dal file zip nella nuova cartella sunfounder

Il display LCD viene utilizzato per chiedere all'utente cosa sta succedendo esattamente. Mostrare il processo di configurazione fino ai valori x, yez mappati su ciascun servo

Passaggio 14: Blynk

Blynk è un brillante servizio IoT che ti consente di creare un'app personalizzata per controllare le tue cose. Mi sembrava la soluzione perfetta per darmi il controllo remoto del walabot per comporre davvero le impostazioni…

Un problema. Blynk non è attualmente supportato sulla piattaforma Python, bugger. Ma non temere! sono stato in grado di trovare un bel po 'di lavoro che consente il controllo remoto e l'immissione di parametri remoti! è un po' hacky

il primo passo è scaricare l'app Blynk dal tuo app store preferito

Secondo, registrati per un account

Fatto ciò, apri l'app e avvia un nuovo progetto, scegliendo Raspberry Pi 3 come hardware.

L'app ti assegnerà un token di accesso (ti servirà per inserire il codice)

Dopo averlo fatto. sarà necessario configurare l'app come mostrato nelle immagini. Ecco come si interfaccia con il walabot.

Passaggio 15: configurazione dell'app Blynk

Passaggio 16: puoi utilizzare questo codice QR con l'app Blynk per clonare il mio progetto e risparmiare tempo

OK Ora che l'app è stata configurata, possiamo configurare Python e l'RPi per parlare con esso su Internet. Magia

Passaggio 17: eseguire Blynk con Raspberry Pi e utilizzare Blynk HTTPS per Python

Innanzitutto, devi installare il wrapper HTTPS Blynk per Python

Da una shell di comando:

sudo git clone

sudo pip install blynkapi

In secondo luogo, è necessario installare il servizio Blynk su RPi

Da una shell di comando:

git clone

cd blynk-libreria/linux

pulisci tutto

per eseguire il servizio blynk

sudo./blynk --token=YourAuthToken

Per garantire che il servizio Blynk venga eseguito all'avvio, è necessario modificare /etc/rc.local

facendo

sudo nano /etc/rc.local

aggiungilo alla fine

./blynk-library/linux/blynk --token=il mio token &

(ho incluso una copia del mio file /etc/rc.local nella sezione del codice per riferimento)

Per verificare che funzioni, digita semplicemente

sudo /etc/rc.local start

Il servizio Blynk dovrebbe ora essere in esecuzione

Passaggio 18: esecuzione automatica dello script

Ora che tutto è impostato e configurato, e abbiamo il codice Python pronto. possiamo impostare le cose per l'esecuzione automatica in modo da poter abbandonare la tastiera e i monitor

Ci sono alcune cose da fare

Crea un nuovo file di script per eseguire il programma Python

sudo nano guitareffect.sh

aggiungi queste righe

#!/bin/sh

python /home/pi/GuitarEffectCLI.py

assicurati di salvarlo

Quindi dobbiamo dare il permesso allo script di funzionare digitando

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

E infine, dobbiamo aggiungere questo script al file /etc/rc.local con cui abbiamo armeggiato in precedenza.

Sudo nano /etc/rc.local

Aggiungere

/home/pi/guitareffect.sh &

assicurati di includere "&" questo consente allo script Python di essere eseguito in background

Destra! Questa è tutta la configurazione e il software ordinati, poi è il momento di cablare l'hardware

Passaggio 19: l'hardware

Primo prototipo di breadboard

Passaggio 20: progettazione dell'involucro

L'enclosure è stato progettato e reso nel fantastico Fusion360

Passo 21: Colpi di coraggio

Passaggio 22: scatti dell'assemblaggio finale

Passaggio 23: fissare il Walabot al supporto

Usa il disco metallico autoadesivo fornito con il walabot per fissarlo in posizione

Passaggio 24: file STL hardware per la stampa 3D

Passo 25: Schemi per il cablaggio della cosa

Passaggio 26: codice

Usa lo script Python allegato per il tuo progetto

from _future_ import print_functionfrom sys import platform from os import system from blynkapi import Blynk import WalabotAPI import time import RPi. GPIO as GPIO

#imposta GPIO usando la numerazione delle schede

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

Token di autenticazione #blynk

auth_token = "your_auth_token_qui"

# Importa il modulo PCA9685 per il servocontrollo.

import Adafruit_PCA9685

#importa il modulo LCD dalla posizione

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

# Inizializzare il PCA9685 utilizzando l'indirizzo predefinito (0x40).

pwm = Adafruit_PCA9685. PCA9685()

# oggetti blink

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, pin = "V4")

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

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

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

Soglia = Blynk(auth_token, pin = "V8")

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

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

def LCDsetup():

LCD1602.init(0x27, 1) # init(indirizzo slave, luce di sfondo)

def numMap(x, in_min, in_max, out_min, out_max): """ usato per mappare le letture del walabot alla posizione del servo """ return int((x- in_min) * (out_max - out_min) / (in_max - in_min) + out_min)

# usa questo per arrotondare i dati grezzi al valore assegnato

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

#estrae il numero dalla stringa blynk restituita

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

# Imposta la frequenza a 60hz, buona per i servi.

pwm.set_pwm_freq(60)

# Configura le lunghezze degli impulsi servo min e max predefinite

SERVO_MIN = 175 # Lunghezza minima dell'impulso su 4096 SERVO_MAX = 575 # Lunghezza massima dell'impulso su 4096

# valori predefiniti di walabot

R_MAX = 60 R_MIN = 20 R_RES = 5

THETA_MAX = 20

THETA_RES = 5

PHI_MAX = 20

PHI_RES = 5

SOGLIA = 1

# variabili per la commutazione blynk

su = "[u'1']"

classe Walabot:

def _init_(self):

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

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 = numeroEstratto(SERVO_MIN) print("Servo MIN =", SERVO_MIN) R_MAX = Rmax.get_val() R_MAX = numeroEstratto(R_MAX) print("R max =", R_MAX)

R_MIN = Rmin.get_val()

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

R_RES = Rres.get_val()

R_RES = numberExtract(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 = numberExtract(PHI_MAX) print("Phi Max =", PHI_MAX) PHI_RES = PhiRes.get_val() PHI_RES = numberExtract(PHI_RES) print("Phi Res =", PHI_RES)

SOGLIA = Soglia.get_val()

SOGLIA = numberExtract(THRESHOLD) print("Soglia =", SOGLIA)

altrimenti: # se nulla dall'app blynk, carica i valori predefiniti SERVO_MIN = 175 # Lunghezza minima dell'impulso su 4096 SERVO_MAX = 575 # Lunghezza massima dell'impulso su 4096

# valori predefiniti di walabot

R_MAX = 60 R_MIN = 20 R_RES = 5

THETA_MAX = 20

THETA_RES = 5

PHI_MAX = 20

PHI_RES = 5

SOGLIA = 1

def connect(self): try: 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_PHI.wl_RES. MAX) self.wlbt. SetArenaR(R_MIN, R_MAX, R_RES) self.wlbt. SetThreshold(THRESHOLD) tranne self.wlbt. WalabotError as err: if err.code != 19: # 'WALABOT_INSTRUMENT_NOT_FOUND' raise err

def inizio(auto):

self.wlbt. Start()

def calibrare (auto):

self.wlbt. StartCalibration()

def get_targets(self):

self.wlbt. Trigger() restituisce self.wlbt. GetSensorTargets()

def stop(self):

self.wlbt. Stop()

def disconnettersi (auto):

self.wlbt. Disconnetti()

def principale():

flag = True check = "" LCDsetup() while flag: LCD1602.write(0, 0, 'Guitar ') LCD1602.write(0, 1, 'Effect Control') time.sleep(2) LCD1602.write(0, 0, 'Premi Start per ') LCD1602.write(0, 1, 'begin ') time.sleep(2) if (str(check) == on): flag = False else: check = start_button.get_val() # controlla il pulsante di avvio blynk premi if (GPIO.input(18) == 0): #check flag footswitch = False

LCD1602.write(0, 0, "OK! Facciamolo")

LCD1602.write(0, 1, ' ') wlbt = Walabot() wlbt.blynkConfig() wlbt.connect() LCD1602.clear() se non wlbt.isConnected: LCD1602.write(0, 0, 'Non connesso') else: LCD1602.write(0, 0, 'Connesso') time.sleep(2) wlbt.start() wlbt.calibrate() LCD1602.write(0, 0, 'Calibrazione…..') time.sleep(3) LCD1602.write(0, 0, 'Avvio di Walabot')

appcheck = start_button.app_status() flag = True # resetta il flag per il programma principale

flag while: # usato per mettere effetto in standby (effettivamente)

if (appcheck == True): if (str(check) != on): if (GPIO.input(18) != 0): #check flag footswitch = False else: check = start_button.get_val() #check for pulsante di avvio premere appcheck = start_button.app_status()

altro:

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

xval = 0

yval = 0 zval = 0 media = 2 delayTime = 0

obiettivi = wlbt.get_targets()

se len(obiettivi) > 0:

per j nell'intervallo (media):

obiettivi = wlbt.get_targets()

if len(target) > 0: print(len(target)) target = target[0]

print(str(targets.xPosCm))

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

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

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

yval = yval/media

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

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

zval = zval/media

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

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

altro:

print("nessun obiettivo") LCD1602.write(0, 0, "Spegnimento") LCD1602.write(0, 1, 'The Walabot ') time.sleep(3) wlbt.stop() wlbt.disconnect()

if _name_ == '_main_':

mentre True: main()

per l'effetto chitarra.sh

#!/bin/sh

cd /home/pi

sudo python GuitarEffectCLI.py

Una copia del file locale RC per riferimento

#!/bin/sh -e# # rc.local # # Questo script viene eseguito alla fine di ogni runlevel multiutente. # Assicurati che lo script "uscirà da 0" in caso di successo o qualsiasi altro # valore in caso di errore. # # Per abilitare o disabilitare questo script basta cambiare i # bit di esecuzione. # # Di default questo script non fa nulla.

# Stampa l'indirizzo IP

_IP=$(nome host -I) || vero se ["$_IP"]; quindi printf "Il mio indirizzo IP è %s\n" "$_IP" fi

./blynk-library/linux/blynk --token="il tuo token va qui" &

sleep 10 sudo /home/pi/guitareffect.sh & exit 0

Passaggio 27: repository Github da utilizzare

Usa questo per il display LCD Sunfounder

github.com/daveyclk/SunFounder_SensorKit_f…

Usa questo per il servo driver

github.com/daveyclk/Adafruit_Python_PCA968…

Usa questo per il wrapper HTTPS Blynk Python

github.com/daveyclk/blynkapi

Passo 28: Conclusione

Bene, questa è stata una curva di apprendimento ripida, ma ne è valsa la pena.

I miei take away sono

• Ho dovuto imparare Python..si scopre che è un asso
• Interfacciato Python sul Raspberry Pi con il servizio Blynk IoT. Questo non è ufficialmente supportato, quindi ci sono alcuni limiti alle sue funzioni. Comunque funziona benissimo!
• Si scopre che il Walabot è ottimo per l'espressione musicale. L'ho usato su un Korg SDD3000, ma puoi usare qualsiasi effetto tu voglia

Prova tu stesso. Questo non è limitato agli effetti per chitarra, posso essere usato con qualsiasi strumento con qualsiasi effetto.

Secondo classificato al concorso Raspberry Pi 2017