Walabot FX - Control de efectos de guitarra: 28 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:45

¡Controla tu efecto de guitarra favorito usando nada más que increíbles poses de guitarra!

Paso 1: ¡Cosas que necesitará

Componentes de hardware

Walabot - Walabot

Raspberry Pi - Raspberry Pi 3 Modelo B

Sunfounder LCD1602

SunFounder PCA9685 Servocontrolador PWM de 16 canales y 12 bits para Arduino y Raspberry Pi

Servo (genérico) Sin enlace

Clip de batería de 9V

Soporte de batería 4xAA

Pilas AA

Cables de puente (genéricos)

Interruptor de pie de acción de enclavamiento DPDT

Korg SDD3000-PDL

SO de software, aplicaciones y servicios en línea

Autodesk Fusion360:

Blynk:

Herramientas, etc

impresora 3d

Soldador

Paso 2: Resumen

¿Cómo sería controlar la expresión musical usando nada más que la posición de su guitarra en el espacio 3D? Bueno, prototipo de algo y averigüémoslo!

Paso 3: la idea básica

Quería poder controlar 3 parámetros de efectos en tiempo real, quería hacer esto usando cómo coloqué mi guitarra. Así que una cosa estaba clara, iba a necesitar algunas cosas.

• Un sensor que puede ver el espacio 3D
• Servos para girar las perillas
• Una pantalla LCD
• Un servocontrolador I2C
• Una frambuesa pi
• Para aprender Python

Paso 4: Walabot

¿Quieres ver a través de las paredes? ¿Sentir objetos en el espacio 3D? ¿Sentido si está respirando desde el otro lado de la habitación? ¡Pues estás de suerte!

El Walabot es una forma completamente nueva de detectar el espacio a tu alrededor usando un radar de baja potencia.

Esto iba a ser clave para este proyecto, podría tomar las coordenadas carteasan (X-Y-Z) de los objetos en el espacio 3D y mapearlos en las posiciones de los servos, cambiando cómo suena un efecto de guitarra, en tiempo real, sin tocar el pedal.

Ganar.

Puede encontrar más información sobre Walabot aquí.

Paso 5: Comenzando

Lo primero es lo primero, necesitará una computadora para conducir el Walabot, para este proyecto estoy usando una Raspberry Pi 3 (aquí se hace referencia a RPi) debido al WiFi incorporado y el empuje adicional general

Compré una tarjeta SD de 16GB con NOOBS preinstalado para mantener las cosas agradables y simples, y opté por instalar Raspian como mi sistema operativo Linux preferido.

(si no está familiarizado con cómo instalar Raspian, tómese un momento para leer un poco sobre esto)

De acuerdo, una vez que tenga Raspian ejecutándose en su RPi, hay algunos pasos de configuración que debe seguir para preparar las cosas para nuestro proyecto

Paso 6: Configuración de Raspberry Pi - 1

En primer lugar, asegúrese de estar ejecutando la última versión del Kernel y busque actualizaciones abriendo un shell de comandos y escribiendo

sudo apt-get update

sudo apt-get dist-upgrade

(se agrega sudo para garantizar que tenga privilegios administrativos, por ejemplo, las cosas funcionarán)

Esto puede tardar un poco en completarse, así que ve y tómate una buena taza de té.

Paso 7: Configuración de Raspberry Pi - 2

Necesita instalar el SDK de Walabot para RPi. Desde su navegador web RPi, vaya a https://www.walabot.com/gettingstarted y descargue el paquete de instalación de Raspberry Pi.

Desde un shell de comandos:

descargas de cd

sudo dpkg -I walabotSDK_RasbPi.deb

Paso 8: Configuración de Raspberry Pi - 3

Necesitamos comenzar a configurar el RPi para usar el bus i2c. Desde un shell de comandos:

sudo apt-get install python-smbus

sudo apt-get install i2c-tools

una vez hecho esto, debe agregar lo siguiente al archivo de módulos

Desde un shell de comandos:

sudo nano / etc / modules

agregue estas 2 cadenas en líneas separadas:

i2c-dev

i2c-bcm2708

Paso 9: Configuración de Raspberry Pi - 4

El Walabot consume bastante corriente, y también usaremos GPIO para controlar cosas, por lo que debemos configurarlas.

Desde un shell de comandos:

sudo nano /boot/config.txt

agregue las siguientes líneas al final del archivo:

safe_mode_gpio = 4

max_usb_current = 1

El RPi es una herramienta excelente para los creadores, pero está limitada en la corriente que puede enviar a Walabot. Por lo tanto, por qué estamos agregando una corriente máxima de 1Amp en lugar de los 500mA más estándar

Paso 10: Python

¿Por qué Python? bueno, ya que es muy fácil de codificar, rápido de ejecutar y hay muchos buenos ejemplos de Python disponibles. Nunca lo había usado antes y pronto estaba listo y funcionando en poco tiempo. Ahora el RPi está configurado para lo que queremos, el siguiente paso es configurar Python para tener acceso a la API de Walabot, interfaces LCD Servo

Paso 11: Para el Walabot

Desde un shell de comando

Instalación de sudo pip "/usr/share/walabot/python/WalabotAPI-1.0.21.zip"

Paso 12: para la interfaz servo

Desde un shell de comando

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

cd ~

clon de git

cd Adafruit_Python_PCA9685

instalación de sudo python setup.py

¿Por qué necesitamos utilizar un servocontrolador? Bueno, por un RPi por un par de razones.

1. La corriente consumida por un servo puede ser muy alta, y ese número aumenta cuanto más servos tiene (por supuesto). Si está conduciendo el servo directky desde un RPi, corre el riesgo de estropear su fuente de alimentación.

2. Los tiempos de PWM (Modulación de ancho de pulso) que controlan la posición de los servos son muy importantes. Como el RPi no usa un sistema operativo en tiempo real (puede haber interrupciones y demás), los tiempos no son precisos y pueden hacer que los servos se muevan nerviosamente. Un controlador dedicado permite un control preciso, pero también permite agregar hasta 16 servos, por lo que es ideal para la expansión.

Paso 13: para la pantalla LCD

abre tu navegador web RPi

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

descargar

github.com/daveyclk/SunFounder_SensorKit_…

Desde un shell de comandos:

sudo mkdir / usr / share / sunfounder

Usando el explorador gráfico, copie la carpeta python del archivo zip en su nueva carpeta sunfounder

La pantalla LCD se utiliza para indicar al usuario qué está sucediendo exactamente. Mostrar el proceso de configuración hasta los valores x, y y z que se asignan a cada servo

Paso 14: Blynk

Blynk es un brillante servicio de IoT que le permite crear una aplicación personalizada para controlar sus cosas. Parecía la solución perfecta para darme el control remoto del walabot para marcar realmente la configuración …

Un problema. Actualmente, Blynk no es compatible con la plataforma Python, maldito. ¡Pero no temas! ¡Pude encontrar un pequeño trabajo que permite el control remoto y la entrada de parámetros remota! es un poco hacky

El primer paso es descargar la aplicación Blynk de su tienda de aplicaciones favorita.

En segundo lugar, regístrese para obtener una cuenta

Una vez hecho esto, abra la aplicación y comience un nuevo proyecto, eligiendo Raspberry Pi 3 como hardware.

La aplicación le asignará un token de acceso (lo necesitará para ingresar su código)

Una vez que hayas hecho eso. deberá configurar la aplicación como se muestra en las imágenes. Así es como interactuará con el walabot.

Paso 15: Configuración de la aplicación Blynk

Paso 16: puede usar este código QR con la aplicación Blynk para clonar mi proyecto y ahorrarle tiempo

OK Ahora que la aplicación está completamente configurada, podemos configurar Python y el RPi para hablar con él a través de Internet. magia

Paso 17: Ejecución de Blynk con Raspberry Pi y uso de Blynk HTTPS para Python

En primer lugar, debe instalar el contenedor Blynk HTTPS para Python

Desde un shell de comandos:

sudo git clone

sudo pip instalar blynkapi

En segundo lugar, debe instalar el servicio Blynk en el RPi

Desde un shell de comandos:

clon de git

biblioteca cd blynk / linux

limpiar todo

para ejecutar el servicio blynk

sudo./blynk --token = YourAuthToken

Para asegurarse de que el servicio Blynk se ejecute en el inicio, debe modificar /etc/rc.local

haciendo

sudo nano /etc/rc.local

agrega esto al final

./blynk-library/linux/blynk --token = mi token &

(He incluido una copia de mi archivo /etc/rc.local en la sección de código como referencia)

Para probar que está funcionando, simplemente escriba

sudo /etc/rc.local start

El servicio Blynk ahora debería estar ejecutándose

Paso 18: Ejecutar automáticamente el script

Ahora que todo está configurado y configurado, y tenemos el código Python listo. podemos configurar las cosas para que se ejecuten automáticamente para que podamos deshacernos del teclado y los monitores

Hay algunas cosas que hacer

Cree un nuevo archivo de secuencia de comandos para ejecutar el programa Python

sudo nano guitareffect.sh

agrega estas líneas

#! / bin / sh

python /home/pi/GuitarEffectCLI.py

asegúrate de guardarlo

A continuación, debemos dar permiso al script para que se ejecute escribiendo

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

Y finalmente, necesitamos agregar este script al archivo /etc/rc.local con el que jugamos anteriormente.

Sudo nano /etc/rc.local

Agregar

/home/pi/guitareffect.sh &

asegúrese de incluir el "&", esto permite que la secuencia de comandos de Python se ejecute en segundo plano

¡Derecha! Esa es toda la configuración y el software ordenados, a continuación es el momento de conectar el hardware

Paso 19: El hardware

Primer prototipo de protoboard

Paso 20: Diseño de la caja

El gabinete fue diseñado y renderizado en el increíble Fusion360

Paso 21: Disparos de tripas

Paso 22: Disparos de montaje final

Paso 23: para fijar el Walabot al soporte

Use el disco de metal autoadhesivo que viene con el walabot para fijarlo en su lugar

Paso 24: Archivos STL de hardware para impresión 3D

Paso 25: Esquemas para conectar la cosa

Paso 26: Código

Utilice la secuencia de comandos de Python adjunta para su proyecto

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

# configurar GPIO usando la numeración de placas

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

token de autenticación #blynk

auth_token = "your_auth_token_here"

# Importe el módulo PCA9685 para el servocontrol.

importar Adafruit_PCA9685

#importar el módulo LCD desde la ubicación

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

# Inicialice el PCA9685 usando la dirección predeterminada (0x40).

pwm = Adafruit_PCA9685. PCA9685 ()

# objetos blynk

valores predeterminados = 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")

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

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

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

def LCDsetup ():

LCD1602.init (0x27, 1) # init (dirección esclava, luz de fondo)

def numMap (x, in_min, in_max, out_min, out_max): "" "utilizado para mapear las lecturas de walabot a la posición del servo" "" return int ((x- in_min) * (out_max - out_min) / (in_max - in_min) + out_min)

# use esto para redondear los datos brutos al valor asignado

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

# extrae el número de la cadena blynk devuelta

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

# Establezca la frecuencia en 60 Hz, buena para servos.

pwm.set_pwm_freq (60)

# Configurar valores predeterminados de longitudes de pulso de servo mínimas y máximas

SERVO_MIN = 175 # Longitud de pulso mínima de 4096 SERVO_MAX = 575 # Longitud de pulso máxima de 4096

# valores predeterminados de walabot

R_MAX = 60 R_MIN = 20 R_RES = 5

THETA_MAX = 20

THETA_RES = 5

PHI_MAX = 20

PHI_RES = 5

UMBRAL = 1

# variables para el cambio de blynk

on = "[u'1 ']"

clase Walabot:

def _init _ (yo):

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

def blynkConfig (yo mismo):

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

UMBRAL = Umbral.get_val ()

UMBRAL = númeroExtracto (UMBRAL) print ("Umbral =", UMBRAL)

de lo contrario: # si no hay nada de la aplicación blynk, cargue los valores predeterminados SERVO_MIN = 175 # Longitud mínima de pulso de 4096 SERVO_MAX = 575 # Longitud máxima de pulso de 4096

# valores predeterminados de walabot

R_MAX = 60 R_MIN = 20 R_RES = 5

THETA_MAX = 20

THETA_RES = 5

PHI_MAX = 20

PHI_RES = 5

UMBRAL = 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. SetArenaR (R_MIN, R_MAX, R_RES) self.wlbt. SetThreshold (THRESHOLD) excepto self.wlbt. WalabotError as err: if err.code! = 19: # 'WALABOT_INSTRUMENT_NOT_FOUND' raise err

def inicio (auto):

self.wlbt. Start ()

def calibrate (auto):

self.wlbt. StartCalibration ()

def get_targets (self):

self.wlbt. Trigger () devuelve self.wlbt. GetSensorTargets ()

def stop (auto):

self.wlbt. Stop ()

def desconectar (auto):

self.wlbt. Disconnect ()

def principal ():

flag = True check = "" LCDsetup () while flag: LCD1602.write (0, 0, 'Guitar') 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 () # comprobar si hay blynk botón de inicio presione if (GPIO.input (18) == 0): #check footswitch flag = False

LCD1602.write (0, 0, "OK! Hagámoslo")

LCD1602.write (0, 1, '') wlbt = Walabot () wlbt.blynkConfig () wlbt.connect () LCD1602.clear () si no wlbt.isConnected: LCD1602.write (0, 0, 'No conectado') más: LCD1602.write (0, 0, 'Conectado') time.sleep (2) wlbt.start () wlbt.calibrate () LCD1602.write (0, 0, 'Calibrando…..') time.sleep (3) LCD1602.write (0, 0, 'Iniciando Walabot')

appcheck = start_button.app_status () flag = True # reset flag para el programa principal

while flag: # usado para poner el efecto en espera (efectivamente)

if (appcheck == True): if (str (check)! = on): if (GPIO.input (18)! = 0): #check footswitch flag = False else: check = start_button.get_val () #check for botón de inicio presione appcheck = start_button.app_status ()

demás:

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

xval = 0

yval = 0 zval = 0 promedio = 2 delayTime = 0

objetivos = wlbt.get_targets ()

si len (objetivos)> 0:

para j en rango (promedio):

objetivos = wlbt.get_targets ()

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

imprimir (str (objetivos.xPosCm))

xval + = int (objetivos.xPosCm) yval + = int (objetivos.yPosCm) zval + = int (objetivos.zPosCm) time.sleep (delayTime) else: print ("sin objetivos") 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 / promedio

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 / promedio

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)

demás:

print ("sin objetivos") LCD1602.write (0, 0, "Apagando") LCD1602.write (0, 1, 'The Walabot') time.sleep (3) wlbt.stop () wlbt.disconnect ()

if _name_ == '_main_':

while True: main ()

para el guitareffect.sh

#! / bin / sh

cd / home / pi

sudo python GuitarEffectCLI.py

Una copia del archivo local de RC como referencia.

#! / bin / sh -e # # rc.local # # Este script se ejecuta al final de cada nivel de ejecución multiusuario. # Asegúrese de que el script "saldrá 0" en caso de éxito o cualquier otro valor # en caso de error. # # Para habilitar o deshabilitar este script simplemente cambie los # bits de ejecución. # # Por defecto, este script no hace nada.

# Imprime la dirección IP

_IP = $ (nombre de host -I) || verdadero si ["$ _IP"]; luego printf "Mi dirección IP es% s / n" "$ _IP" fi

./blynk-library/linux/blynk --token = "tu token va aquí" &

dormir 10 sudo /home/pi/guitareffect.sh y salir 0

Paso 27: Repositorios de Github para usar

Use esto para la pantalla LCD Sunfounder

github.com/daveyclk/SunFounder_SensorKit_f…

Use esto para el servocontrolador

github.com/daveyclk/Adafruit_Python_PCA968…

Use esto para el contenedor HTTPS de Blynk Python

github.com/daveyclk/blynkapi

Paso 28: Conclusión

Bueno, esta ha sido una curva de aprendizaje empinada, pero ha valido la pena.

Mis comida para llevar son

• Tuve que aprender Python … resulta que es as
• Conecté Python en Raspberry Pi con el servicio Blynk IoT. Esto no es compatible oficialmente, por lo que existen algunos límites para sus funciones. ¡Aún funciona muy bien!
• Resulta que el Walabot es ideal para la expresión musical. Lo usé en un Korg SDD3000, pero puedes usar el efecto que quieras

Pruébalo tú mismo. Esto no se limita a los efectos de guitarra, se puede utilizar con cualquier instrumento con cualquier efecto.

Finalista en el Concurso Raspberry Pi 2017