Walabot FX - Sterowanie efektami gitarowymi: 28 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:34

Kontroluj swój ulubiony efekt gitarowy, używając tylko niesamowitych pozycji na gitarze!

Krok 1: Rzeczy, których będziesz potrzebować

Komponenty sprzętowe

Walabot - Walabot

Raspberry Pi - Raspberry Pi 3 Model B

Sunfounder LCD1602

SunFounder PCA9685 16-kanałowy 12-bitowy sterownik serwo PWM dla Arduino i Raspberry Pi

Serwo (ogólne) Brak linku

Zacisk akumulatora 9V

Uchwyt na 4 baterie AA

Baterie AA

Przewody połączeniowe (ogólne)

Przełącznik nożny z blokadą DPDT

Korg SDD3000-PDL

Systemy operacyjne, aplikacje i usługi online

Autodesk Fusion360 -

Blynk -

Narzędzia itp

drukarka 3d

Lutownica

Krok 2: Streszczenie

Jak by to było kontrolować ekspresję muzyczną za pomocą wyłącznie pozycji gitary w przestrzeni 3D? Cóż, stwórzmy prototyp i dowiedzmy się!

Krok 3: Podstawowa idea

Chciałem mieć możliwość kontrolowania 3 parametrów efektu w czasie rzeczywistym, chciałem to zrobić za pomocą tego, jak ustawiłem gitarę. Więc jedno było jasne, będę potrzebował kilku rzeczy.

• Czujnik, który jest w stanie zobaczyć przestrzeń 3D
• Serwa do obracania pokręteł
• Wyświetlacz LCD
• Sterownik serwo I2C
• Malinowa Pi
• Aby nauczyć się Pythona

Krok 4: Walabot

Chcesz widzieć przez ściany? Wyczuwać obiekty w przestrzeni 3D? Poczuj, czy oddychasz z drugiego końca pokoju? Cóż, masz szczęście!

Walabot to zupełnie nowy sposób wykrywania przestrzeni wokół ciebie za pomocą radaru o małej mocy.

To miało być kluczem do tego projektu, będę mógł wziąć współrzędne kartezjańskie (X-Y-Z) obiektów w przestrzeni 3D i przyporządkować je do pozycji serwomechanizmów, zmieniając brzmienie efektu gitarowego w czasie rzeczywistym, bez dotykania pedału.

Wygrać.

Więcej informacji o Walabot znajdziesz tutaj

Krok 5: Pierwsze kroki

Po pierwsze, będziesz potrzebować komputera do obsługi Walabota, w tym projekcie używam Raspberry Pi 3 (tutaj w odniesieniu do RPi) ze względu na wbudowane WiFi i ogólne dodatkowe oomph

Kupiłem kartę SD o pojemności 16 GB z preinstalowanym systemem NOOBS, aby wszystko było przyjemne i proste, i zdecydowałem się zainstalować Raspian jako mój wybrany system operacyjny Linux

(jeśli nie wiesz, jak zainstalować Raspian, poświęć chwilę, aby to trochę poczytać)

OK, po uruchomieniu Raspiana na swoim RPi, należy wykonać kilka czynności konfiguracyjnych, aby przygotować wszystko do naszego projektu

Krok 6: Konfiguracja Raspberry Pi - 1

Najpierw upewnij się, że korzystasz z najnowszej wersji jądra i sprawdź dostępność aktualizacji, otwierając powłokę poleceń i wpisując

aktualizacja sudo apt-get

sudo apt-get dist-upgrade

(sudo jest dodawane, aby zapewnić sobie uprawnienia administracyjne, np. rzeczy będą działać)

Może to trochę potrwać, więc idź i napij się dobrej herbaty.

Krok 7: Konfiguracja Raspberry Pi - 2

Musisz zainstalować pakiet Walabot SDK dla RPi. W przeglądarce internetowej RPi przejdź do https://www.walabot.com/gettingstarted i pobierz pakiet instalatora Raspberry Pi.

Z powłoki poleceń:

pobieranie płyt CD

sudo dpkg -I walabotSDK_RasbPi.deb

Krok 8: Konfiguracja Raspberry Pi - 3

Musimy zacząć konfigurować RPi do korzystania z magistrali i2c. Z powłoki poleceń:

sudo apt-get zainstaluj python-smbus

sudo apt-get zainstaluj i2c-tools

gdy to zrobisz, musisz dodać następujące elementy do pliku modułów

Z powłoki poleceń:

sudo nano /etc/moduły

dodaj te 2 ciągi w osobnych liniach:

i2c-dev

i2c-bcm2708

Krok 9: Konfiguracja Raspberry Pi - 4

Walabot pobiera sporo prądu, a my również użyjemy GPIO do kontrolowania rzeczy, więc musimy je skonfigurować

Z powłoki poleceń:

sudo nano /boot/config.txt

dodaj następujące wiersze na końcu pliku:

safe_mode_gpio=4

max_usb_current=1

RPi to doskonałe narzędzie dla producentów, ale jest ograniczone w prądzie, który może wysłać do Walabota. Dlatego dodajemy maksymalny prąd 1A zamiast bardziej standardowego 500mA?

Krok 10: Python

Dlaczego Python? cóż, ponieważ jest bardzo łatwy do kodowania, szybki do uruchomienia i dostępnych jest mnóstwo dobrych przykładów Pythona! nigdy wcześniej go nie używałem i wkrótce zacząłem działać. Teraz RPi jest skonfigurowane do tego, czego chcemy, następnym krokiem jest skonfigurowanie Pythona, aby miał dostęp do API Walabot, interfejsów LCD Servo

Krok 11: Dla Walabota

Z powłoki poleceń

Instalacja sudo pip „/usr/share/walabot/python/WalabotAPI-1.0.21.zip”

Krok 12: Dla interfejsu serwo

Z powłoki poleceń

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

cd ~

git klon

cd Adafruit_Python_PCA9685

sudo python setup.py zainstalować

Dlaczego potrzebujemy serwonapędu? Cóż, z RPi z kilku powodów.

1. Prąd pobierany przez serwo może być bardzo wysoki, a liczba ta rośnie, im więcej masz serw (oczywiście). Jeśli sterujesz serwomechanizmem directky z RPi, ryzykujesz wysadzenie jego zasilacza

2. Bardzo ważne są czasy PWM (Pulse Width Modulation), które kontrolują położenie serw. Ponieważ RPi nie używa systemu operacyjnego czasu rzeczywistego (mogą występować przerwania itp.), taktowanie nie jest dokładne i może powodować nerwowe drgania serw. Dedykowany sterownik umożliwia dokładną kontrolę, ale także pozwala na dodanie do 16 serwomechanizmów, więc jest to idealne rozwiązanie do rozbudowy.

Krok 13: Dla LCD

otwórz przeglądarkę internetową RPi

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

pobieranie

github.com/daveyclk/SunFounder_SensorKit_…

Z powłoki poleceń:

sudo mkdir /usr/share/sunfounder

Korzystając z eksploratora graficznego, skopiuj folder Pythona z pliku zip do nowego folderu sunfounder

Wyświetlacz LCD służy do informowania użytkownika o tym, co dokładnie się dzieje. Pokazanie procesu konfiguracji do wartości x, y i z mapowanych na każdy serwo

Krok 14: Blynk

Blynk to genialna usługa IoT, która pozwala tworzyć niestandardową aplikację do kontrolowania Twoich rzeczy. Wydawało się, że to idealne rozwiązanie, aby dać mi zdalne sterowanie walabotem, aby naprawdę wybrać ustawienia…

Jeden problem. Blynk nie jest obecnie obsługiwany na platformie Python, bugger. Ale nie bój się! udało mi się znaleźć fajną pracę, która umożliwia zdalne sterowanie i zdalne wprowadzanie parametrów! to trochę hacky

pierwszym krokiem jest pobranie aplikacji Blynk z ulubionego sklepu z aplikacjami

Po drugie, załóż konto

Gdy to zrobisz, otwórz aplikację i rozpocznij nowy projekt, wybierając Raspberry Pi 3 jako sprzęt.

Aplikacja przydzieli Ci token dostępu (będziesz go potrzebować do wpisania kodu)

Kiedy już to zrobisz. musisz skonfigurować aplikację, jak pokazano na obrazkach. W ten sposób będzie współpracował z walabotem.

Krok 15: Konfiguracja aplikacji Blynk

Krok 16: Możesz użyć tego kodu QR za pomocą aplikacji Blynk, aby sklonować mój projekt, aby zaoszczędzić czas

OK Teraz, gdy aplikacja jest już skonfigurowana, możemy skonfigurować Pythona i RPi, aby komunikowały się z nim przez internet. magia

Krok 17: Uruchamianie Blynk z Raspberry Pi i używanie Blynk HTTPS dla Pythona

Po pierwsze, musisz zainstalować wrapper Blynk HTTPS dla Pythona

Z powłoki poleceń:

klon sudo git

sudo pip zainstaluj blynkapi

Po drugie, musisz zainstalować usługę Blynk na RPi

Z powłoki poleceń:

klon git

cd blynk-library/linux

oczyść wszystko

uruchomić usługę blynk

sudo./blynk --token=TwójTokenAuth

Aby upewnić się, że usługa Blynk działa podczas uruchamiania, musisz zmodyfikować /etc/rc.local

wykonując

sudo nano /etc/rc.local

dodaj to na końcu

./blynk-library/linux/blynk --token=mój token &

(dołączyłem kopię mojego pliku /etc/rc.local w sekcji kodu w celach informacyjnych)

Aby sprawdzić, czy działa, po prostu wpisz

sudo /etc/rc.local start

Usługa Blynk powinna teraz działać

Krok 18: Automatyczne uruchamianie skryptu

Teraz, gdy wszystko jest już skonfigurowane i skonfigurowane, mamy gotowy kod Pythona. możemy ustawić automatyczne uruchamianie rzeczy, abyśmy mogli porzucić klawiaturę i monitory

Jest kilka rzeczy do zrobienia

Utwórz nowy plik skryptu, aby uruchomić program Python

sudo nano guitareffect.sh

dodaj te linie

#!/kosz/sz

python /home/pi/GuitarEffectCLI.py

pamiętaj, aby to zapisać

Następnie musimy zezwolić skryptowi na uruchomienie, wpisując

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

I na koniec musimy dodać ten skrypt do pliku /etc/rc.local, przy którym majstrowaliśmy wcześniej.

Sudo nano /etc/rc.local

Dodać

/home/pi/gitarareffect.sh &

pamiętaj, aby dołączyć „&”, dzięki czemu skrypt Pythona może działać w tle

Dobrze! To wszystko posortowana konfiguracja i oprogramowanie, następnie czas na okablowanie sprzętu

Krok 19: Sprzęt

Pierwszy prototyp płyty do krojenia chleba

Krok 20: Projekt obudowy

Obudowa została zaprojektowana i wyrenderowana w niesamowitym Fusion360

Krok 21: Odważne strzały

Krok 22: Ostateczne ujęcia montażowe

Krok 23: Mocowanie Walabota do stojaka

Użyj samoprzylepnego metalowego dysku dołączonego do walabota, aby go zamocować

Krok 24: Sprzętowe pliki STL do drukowania 3D

Krok 25: Schematy okablowania urządzenia

Krok 26: Kod

Użyj dołączonego skryptu Pythona do swojego projektu

from _future_ import print_functionfrom sys import platformy z os import systemu z blynkapi import Blynk import WalabotAPI import czasu import RPi. GPIO jako GPIO

#skonfiguruj GPIO za pomocą numeracji płytek

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

#blynk token uwierzytelniania

auth_token = "Twój_token_auth_tutaj"

# Zaimportuj moduł PCA9685 do sterowania serwo.

importuj Adafruit_PCA9685

#importuj moduł LCD z lokalizacji

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

# Zainicjuj PCA9685 używając domyślnego adresu (0x40).

pwm = Adafruit_PCA9685. PCA9685()

# blynk obiektów

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")

Próg = Blynk(auth_token, pin = "V8")

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

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

def Ustawienia LCD():

LCD1602.init (0x27, 1) # init (adres slave, podświetlenie)

def numMap(x, in_min, in_max, out_min, out_max): """ używane do mapowania odczytów walabota na pozycję serwa """ return int((x- in_min) * (out_max - out_min) / (in_max - in_min) + out_min)

# użyj tego do zaokrąglania surowych danych do przypisanej wartości

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

#pobiera liczbę ze zwróconego ciągu blynk

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

# Ustaw częstotliwość na 60 Hz, dobre dla serw.

pwm.set_pwm_freq(60)

# Skonfiguruj domyślną minimalną i maksymalną długość impulsu serwomechanizmu

SERVO_MIN = 175 # Minimalna długość impulsu z 4096 SERVO_MAX = 575 # Maksymalna długość impulsu z 4096

# wartości domyślne walabot

R_MAX = 60 R_MIN = 20 R_OZE = 5

THETA_MAX = 20

THETA_RES = 5

PHI_MAX = 20

PHI_OZ = 5

PRÓG = 1

# zmienne do przełączania blynka

on = "[u'1']"

klasa Walabot:

def _init_(self):

self.wlbt = WalabotAPI self.wlbt. Init() self.wlbt. SetSettingsFolder() self.isConnected = Fałsz self.isTargets = Fałsz

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 = numberExtract(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 = liczbaWyciąg(THETA_MAX) print("Theta Max =", THETA_MAX) THETA_RES = ThetaRes.get_val() THETA_RES = liczbaWyciąg(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)

PRÓG = Próg.get_val()

PRÓG = liczbaWyciąg(PRÓG) print("Próg =", PRÓG)

w przeciwnym razie: # jeśli nic z aplikacji blynk, załaduj domyślne SERVO_MIN = 175 # Minimalna długość impulsu z 4096 SERVO_MAX = 575 # Maksymalna długość impulsu z 4096

# wartości domyślne walabot

R_MAX = 60 R_MIN = 20 R_OZE = 5

THETA_MAX = 20

THETA_RES = 5

PHI_MAX = 20

PHI_OZ = 5

PRÓG = 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. SetDynamic (self.wlbt. FILTER_TYPE_NONE) #self.wlbt. SetDynamicImageFilter(self.wlbt. FILTER_TYPE_DERIVATIVE) self.wlbt. SetArenaTheta(-THETA_MAX, THETA_MAX, THETA_RES) self.wlbt. Set PHIPHI.w. Phi, self. SetArenaR(R_MIN, R_MAX, R_RES) self.wlbt. SetThreshold(PRÓG) z wyjątkiem self.wlbt. WalabotError jako błąd: jeśli err.code != 19: # 'WALABOT_INSTRUMENT_NOT_FOUND' podnieś błąd

def start(self):

self.wlbt. Start()

def kalibracja (własna):

self.wlbt. StartCalibration()

def get_targets(self):

self.wlbt. Trigger() return self.wlbt. GetSensorTargets()

def stop (własny):

self.wlbt. Stop()

def odłączyć (siebie):

self.wlbt. Disconnect()

zdefiniuj główne():

flag = True check = "" LCDsetup() while flag: LCD1602.write(0, 0, 'Guitar ') LCD1602.write(0, 1, 'Kontrola efektów') time.sleep(2) LCD1602.write(0, 0, 'Naciśnij Start, aby ') LCD1602.write(0, 1, 'begin') time.sleep(2) if (str(check) == on): flag = False else: check = start_button.get_val() # sprawdź przycisk blynk start naciśnij jeśli (GPIO.input(18) == 0): #check footswitch flag = False

LCD1602.write(0, 0, "OK! zróbmy to")

LCD1602.write(0, 1, ' ') wlbt = Walabot() wlbt.blynkConfig() wlbt.connect() LCD1602.clear() jeśli nie wlbt.isConnected: LCD1602.write(0, 0, 'Nie połączono ') else: LCD1602.write(0, 0, 'Połączono ') time.sleep(2) wlbt.start() wlbt.kalibracja() LCD1602.write(0, 0, 'Kalibracja…..') time.sleep(3) LCD1602.write(0, 0, 'Uruchamianie Walabota')

appcheck = start_button.app_status() flaga = prawda # flaga resetu dla głównego programu

flaga while: # używana do wprowadzenia efektu w stan czuwania (efektywnie)

if (appcheck == True): if (str(check) != on): if (GPIO.input(18) != 0): #check footswitch flag = False else: check = start_button.get_val() #check for przycisk start naciśnij appcheck = start_button.app_status()

w przeciwnym razie:

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

xval = 0

yval = 0 zval = 0 średnia = 2 delayTime = 0

cele = wlbt.get_targets()

jeśli len(cele) > 0:

dla j w zakresie (średnia):

cele = wlbt.get_targets()

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

print(str(targets.xPosCm))

xval += int(targets.xPosCm) yval += int(targets.yPosCm) zval += int(targets.zPosCm) time.sleep(delayTime) else: print("brak celów") xval = xval/średnia

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

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

yval = yval/średnia

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)

zwal = zwal/średnia

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)

w przeciwnym razie:

print("brak celów") LCD1602.write(0, 0, "Zamykanie ") LCD1602.write(0, 1, 'Walabot ') time.sleep(3) wlbt.stop() wlbt.disconnect()

if _name_ == '_main_':

podczas gdy prawda: main()

dla guitareffect.sh

#!/kosz/sz

cd /home/pi

sudo python GuitarEffectCLI.py

Kopia lokalnego pliku RC w celach informacyjnych

#!/bin/sh -e# # rc.local # # Ten skrypt jest wykonywany na końcu każdego poziomu pracy z wieloma użytkownikami. # Upewnij się, że skrypt "wyjdzie z 0" w przypadku powodzenia lub dowolnej innej wartości w przypadku błędu. # # Aby włączyć lub wyłączyć ten skrypt po prostu zmień wykonanie # bitów. # # Domyślnie ten skrypt nic nie robi.

# Wydrukuj adres IP

_IP=$(nazwa hosta -I) || prawda, jeśli ["$_IP"]; then printf "Mój adres IP to %s\n" "$_IP" fi

./blynk-library/linux/blynk --token="Twój token idzie tutaj" &

spać 10 sudo /home/pi/gitarareffect.sh i wyjść 0

Krok 27: Repozytoria Github do użycia

Użyj tego dla Sunfounder LCD

github.com/daveyclk/SunFounder_SensorKit_f…

Użyj tego dla serwonapędu

github.com/daveyclk/Adafruit_Python_PCA968…

Użyj tego dla Blynk Python HTTPS Wrapper

github.com/daveyclk/blynkapi

Krok 28: Wniosek

Cóż, to była stroma krzywa uczenia się, ale było warto.

Moje dania na wynos są

• Musiałem nauczyć się Pythona… okazuje się, że to as
• Połącz Pythona na Raspberry Pi z usługą Blynk IoT. Nie jest to oficjalnie obsługiwane, więc istnieją pewne ograniczenia jego funkcji. Mimo to działa świetnie!
• Okazuje się, że Walabot świetnie nadaje się do muzycznej ekspresji. Użyłem go na Korgu SDD3000, ale możesz użyć dowolnego efektu

Spróbuj sam. Nie ogranicza się to do efektów gitarowych, mogę być używany z dowolnym instrumentem z dowolnym efektem.

Drugie miejsce w konkursie Raspberry Pi 2017