Walabot FX - Controle de efeito de guitarra: 28 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:40

Controle o seu efeito de guitarra favorito usando nada além de poses de guitarra incríveis!

Etapa 1: Coisas de que você precisa

Componentes de hardware

Walabot - Walabot

Raspberry Pi - Raspberry Pi 3 Modelo B

Sunfounder LCD1602

SunFounder PCA9685 16 canais 12 bits PWM servo driver para Arduino e Raspberry Pi

Servo (genérico) Sem link

Clipe de bateria 9V

Suporte de bateria 4xAA

Baterias AA

Fios de jumpers (genérico)

Botão de pedal de ação de travamento DPDT

Korg SDD3000-PDL

SOs de software, aplicativos e serviços online

Autodesk Fusion360 -

Blynk -

Ferramentas etc

impressora 3d

Ferro de solda

Etapa 2: Resumo

Como seria controlar a expressão musical usando nada além da posição de sua guitarra no espaço 3D? Bem, vamos prototipar algo e descobrir!

Etapa 3: A ideia básica

Eu queria ser capaz de controlar 3 parâmetros de efeito em tempo real, eu queria fazer isso usando como posicionei minha guitarra. Então, uma coisa estava certa, eu precisaria de algumas coisas.

• Um sensor capaz de ver o espaço 3D
• Servos para girar os botões
• Um display LCD
• Um driver I2C Servo
• Um Raspberry Pi
• Para aprender Python

Etapa 4: Walabot

Quer ver através das paredes? Sentir objetos no espaço 3D? Sente se você está respirando do outro lado da sala? Bem, você está com sorte!

O Walabot é uma maneira totalmente nova de detectar o espaço ao seu redor usando um radar de baixa potência.

Isso seria a chave para este projeto, eu seria capaz de pegar as combinações carteasan (X-Y-Z) de objetos no espaço 3D e mapeá-las para posições de servo mudando como um efeito de guitarra soa, em tempo real, sem tocar no pedal.

Vencer.

Mais informações sobre o Walabot podem ser encontradas aqui

Etapa 5: primeiros passos

Em primeiro lugar, você precisará de um computador para dirigir o Walabot, para este projeto estou usando um Raspberry Pi 3 (aqui referido no RPi) devido ao WiFi integrado e potência extra geral

Comprei um cartão SD de 16 GB com NOOBS pré-instalado para manter as coisas simples e agradáveis e optei por instalar o Raspian como meu sistema operacional Linux de escolha

(se você não está familiarizado com a instalação do Raspian, por favor, reserve um momento para ler um pouco sobre isso)

OK, uma vez que o Raspian está rodando em seu RPi, existem algumas etapas de configuração a serem executadas para deixar as coisas prontas para nosso projeto

Etapa 6: Configurando o Raspberry Pi - 1

Em primeiro lugar, certifique-se de que está executando a versão mais recente do Kernel e verifique se há atualizações abrindo um shell de comando e digitando

sudo apt-get update

sudo apt-get dist-upgrade

(sudo é adicionado para garantir que você tenha privilégios administrativos, por exemplo, o material funcionará)

Isso pode demorar um pouco para ser concluído, então vá e tome uma boa xícara de chá.

Etapa 7: Configurando o Raspberry Pi - 2

Você precisa instalar o Walabot SDK for RPi. No navegador da Web do RPi, acesse https://www.walabot.com/gettingstarted e baixe o pacote do instalador do Raspberry Pi.

Em um shell de comando:

downloads de cd

sudo dpkg -I walabotSDK_RasbPi.deb

Etapa 8: Configurando o Raspberry Pi - 3

Precisamos começar a configurar o RPi para usar o barramento i2c. A partir de um shell de comando:

sudo apt-get install python-smbus

sudo apt-get install i2c-tools

uma vez feito isso, você deve adicionar o seguinte ao arquivo de módulos

Em um shell de comando:

sudo nano / etc / modules

adicione estas 2 strings em linhas separadas:

i2c-dev

i2c-bcm2708

Etapa 9: Configurando o Raspberry Pi - 4

O Walabot atrai um pouco de corrente, e também usaremos GPIOs para controlar coisas, então precisamos configurá-los

Em um shell de comando:

sudo nano /boot/config.txt

adicione as seguintes linhas no final do arquivo:

safe_mode_gpio = 4

max_usb_current = 1

O RPi é uma excelente ferramenta para fabricantes, mas é limitado na corrente que pode enviar para o Walabot. Daí porque estamos adicionando uma corrente máxima de 1Amp em vez dos 500mA mais padrão

Etapa 10: Python

Por que Python? bem, como é super fácil de codificar, rápido para executar e há muitos bons exemplos de python disponíveis! Eu nunca tinha usado antes e logo estava pronto e funcionando. Agora que o RPi está configurado para o que queremos, o próximo passo é configurar o Python para ter acesso à API Walabot, interfaces Servo LCD

Etapa 11: para o Walabot

De um shell de comando

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

Etapa 12: para a interface servo

De um shell de comando

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

cd ~

git clone

cd Adafruit_Python_PCA9685

sudo python setup.py install

Por que precisamos usar um servo driver? Bem, por um RPi, algumas razões.

1. A corrente puxada por um servo pode ser muito alta, e esse número fica maior quanto mais servos você tiver (é claro). Se você estiver dirigindo o servo directky de um RPi, você corre o risco de explodir sua fonte de alimentação

2. Os tempos do PWM (modulação por largura de pulso) que controlam a posição dos servos são muito importantes. Como o RPi não usa um sistema operacional de tempo real (pode haver interrupções e outros), os tempos não são precisos e podem fazer os servos se contorcerem nervosamente. Um driver dedicado permite um controle preciso, mas também permite que até 16 servos sejam adicionados, então isso é ótimo para expansão.

Etapa 13: para o LCD

abra seu navegador RPi

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

download

github.com/daveyclk/SunFounder_SensorKit_…

Em um shell de comando:

sudo mkdir / usr / share / sunfounder

Usando o explorador gráfico, copie a pasta python do arquivo zip para sua nova pasta sunfounder

O LCD é usado para perguntar ao usuário o que exatamente está acontecendo. Mostrando o processo de configuração até os valores x, y e z sendo mapeados em cada servo

Etapa 14: Blynk

Blynk é um serviço IoT brilhante que permite criar um aplicativo personalizado para controlar suas coisas. Pareceu a solução perfeita para me dar o controle remoto do walabot para realmente discar as configurações …

Um problema. Blynk não é atualmente suportado na plataforma Python, bugger. Mas não tenha medo! Consegui encontrar uma pequena solução que permite o controle remoto e a entrada de parâmetros remotos! é um pouco hacky

o primeiro passo é baixar o aplicativo Blynk de sua loja de aplicativos favorita

Em segundo lugar, inscreva-se para uma conta

Feito isso, abra o aplicativo e inicie um novo projeto, escolhendo Raspberry Pi 3 como o hardware.

O aplicativo irá atribuir a você um token de acesso (você precisará dele para inserir seu código)

Depois de fazer isso. você precisará configurar o aplicativo conforme mostrado nas imagens. É assim que ele fará a interface com o walabot.

Etapa 15: Configurando o aplicativo Blynk

Etapa 16: você pode usar este código QR com o aplicativo Blynk para clonar meu projeto e economizar tempo

OK Agora que o aplicativo está todo configurado, podemos configurar o Python e o RPi para falar com ele pela internet. Magia

Etapa 17: executando o Blynk com o Raspberry Pi e usando o Blynk HTTPS para Python

Em primeiro lugar, você precisa instalar o wrapper Blynk HTTPS para Python

Em um shell de comando:

sudo git clone

sudo pip install blynkapi

Em segundo lugar, você precisa instalar o Blynk Service no RPi

Em um shell de comando:

git clone

cd blynk-library / linux

limpar tudo

para executar o serviço blynk

sudo./blynk --token = YourAuthToken

Para garantir que o serviço Blynk seja executado na inicialização, você precisa modificar o arquivo /etc/rc.local

fazendo

sudo nano /etc/rc.local

adicione isso no final

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

(incluí uma cópia do meu arquivo /etc/rc.local na seção de código para referência)

Para testar se está funcionando, basta digitar

sudo /etc/rc.local start

O serviço Blynk agora deve estar em execução

Etapa 18: Execução automática do script

Agora que tudo está definido e configurado, e temos o código Python pronto. podemos definir as coisas para execução automática para que possamos nos livrar do teclado e dos monitores

Existem algumas coisas a fazer

Crie um novo arquivo de script para executar o programa Python

sudo nano guitareffect.sh

adicione essas linhas

#! / bin / sh

python /home/pi/GuitarEffectCLI.py

certifique-se de salvá-lo

Em seguida, precisamos dar permissão ao script para ser executado digitando

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

E, finalmente, precisamos adicionar este script ao arquivo /etc/rc.local que corrigimos anteriormente.

Sudo nano /etc/rc.local

Adicionar

/home/pi/guitareffect.sh &

certifique-se de incluir o "&" isso permite que o script Python seja executado em segundo plano

Direito! Essa é toda a configuração e software classificado, em seguida, é hora de conectar o hardware

Etapa 19: O Hardware

Primeiro protótipo de breadboard

Etapa 20: Design do gabinete

A caixa foi projetada e renderizada no incrível Fusion360

Etapa 21: disparos de coragem

Etapa 22: Fotos da montagem final

Etapa 23: Fixar o Walabot no suporte

Use o disco de metal autoadesivo que vem com o walabot para fixá-lo no lugar

Etapa 24: Arquivos STL de hardware para impressão 3D

Etapa 25: Esquemas para conectar a coisa

Etapa 26: Código

Use o script Python anexado para o seu projeto

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

# configurar GPIO usando a numeração da placa

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

#blynk token de autenticação

auth_token = "your_auth_token_here"

# Importe o módulo PCA9685 para o controle servo.

import Adafruit_PCA9685

#import LCD module from location

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

# Inicialize o PCA9685 usando o endereço padrão (0x40).

pwm = Adafruit_PCA9685. PCA9685 ()

# objetos blynk

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

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

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

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

def LCDsetup ():

LCD1602.init (0x27, 1) # init (endereço do escravo, luz de fundo)

def numMap (x, in_min, in_max, out_min, out_max): "" "usado para mapear as leituras do walabot para a posição do servo" "" return int ((x- in_min) * (out_max - out_min) / (in_max - in_min) + out_min)

# use isso para arredondar os dados brutos para o valor atribuído

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

# extrai o número da string blynk retornada

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

# Defina a frequência para 60 Hz, bom para servos.

pwm.set_pwm_freq (60)

# Configure os padrões de comprimento de pulso de servo mínimo e máximo

SERVO_MIN = 175 # Comprimento mínimo de pulso de 4096 SERVO_MAX = 575 # Comprimento máximo de pulso de 4096

# valores padrão do walabot

R_MAX = 60 R_MIN = 20 R_RES = 5

THETA_MAX = 20

THETA_RES = 5

PHI_MAX = 20

PHI_RES = 5

LIMIAR = 1

# variáveis para comutação blynk

on = "[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 = 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)

THRESHOLD = Threshold.get_val ()

THRESHOLD = numberExtract (THRESHOLD) print ("Threshold =", THRESHOLD)

else: # se nada do blynk app, carregue os padrões SERVO_MIN = 175 # Comprimento mínimo de pulso de 4096 SERVO_MAX = 575 # Comprimento máximo de pulso de 4096

# valores padrão do walabot

R_MAX = 60 R_MIN = 20 R_RES = 5

THETA_MAX = 20

THETA_RES = 5

PHI_MAX = 20

PHI_RES = 5

LIMIAR = 1

def conectar (self): try: self.wlbt. ConnectAny () self.isConnected = True self.wlbt. SetProfile (self.wlbt. PROF_SENSOR) # self.wlbt. SetDynamicImageFilter (self.wlbt. FILTER_TYPE_MTI) self.wlbtamicImage (self.wlbt. FILTER_TYPE_NONE) # self.wlbt. SetDynamicImageFilter (self.wlbt. FILTER_TYPE_DERIVATIVE) self.wlbt. SetArenaTheta (-THETA_MAX, THETA_MAX, THETA_RES) self.wlMAP. Set. SetArenaR (R_MIN, R_MAX, R_RES) self.wlbt. SetThreshold (THRESHOLD) exceto self.wlbt. WalabotError como err: if err.code! = 19: # 'WALABOT_INSTRUMENT_NOT_FOUND' elevar err

def start (self):

self.wlbt. Start ()

def calibrate (self):

self.wlbt. StartCalibration ()

def get_targets (self):

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

def stop (self):

self.wlbt. Stop ()

desconexão por defeito (auto):

self.wlbt. Disconnect ()

def main ():

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 () # verifique se o botão de início do blynk foi pressionado se (GPIO.input (18) == 0): #check footswitch flag = False

LCD1602.write (0, 0, "OK! Vamos lá")

LCD1602.write (0, 1, '') wlbt = Walabot () wlbt.blynkConfig () wlbt.connect () LCD1602.clear () se não wlbt.isConnected: LCD1602.write (0, 0, 'Não conectado') else: 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 sinalizador para prog principal

enquanto sinalizador: # usado para colocar efeito em espera (efetivamente)

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ão iniciar pressione appcheck = start_button.app_status ()

outro:

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

xval = 0

yval = 0 zval = 0 média = 2 delayTime = 0

targets = wlbt.get_targets ()

se len (alvos)> 0:

para j no intervalo (média):

targets = wlbt.get_targets ()

se len (alvos)> 0: imprimir (len (alvos)) alvos = alvos [0]

imprimir (str (targets.xPosCm))

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

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

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

yval = yval / média

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 / média

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

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

outro:

print ("sem alvos") LCD1602.write (0, 0, "Desligando") LCD1602.write (0, 1, 'The Walabot') time.sleep (3) wlbt.stop () wlbt.disconnect ()

if _name_ == '_main_':

enquanto True: main ()

para o guitareffect.sh

#! / bin / sh

cd / home / pi

sudo python GuitarEffectCLI.py

Uma cópia do arquivo local RC para referência

#! / bin / sh -e # # rc.local # # Este script é executado no final de cada nível de execução multiusuário. # Certifique-se de que o script "sairá 0" em caso de sucesso ou qualquer outro valor # em caso de erro. # # Para habilitar ou desabilitar este script, basta alterar os # bits de execução. # # Por padrão, este script não faz nada.

# Imprima o endereço IP

_IP = $ (hostname -I) || verdadeiro se ["$ _IP"]; então printf "Meu endereço IP é% s / n" "$ _IP" fi

./blynk-library/linux/blynk --token = "seu token vai aqui" &

dormir 10 sudo /home/pi/guitareffect.sh e sair 0

Etapa 27: Repositórios Github para usar

Use para o LCD Sunfounder

github.com/daveyclk/SunFounder_SensorKit_f…

Use isso para o servo driver

github.com/daveyclk/Adafruit_Python_PCA968…

Use para o Blynk Python HTTPS Wrapper

github.com/daveyclk/blynkapi

Etapa 28: Conclusão

Bem, esta foi uma curva de aprendizado íngreme, mas valeu a pena.

Minha opinião é

• Tive que aprender Python … descobri que é ace
• Interface do Python no Raspberry Pi com o serviço Blynk IoT. Isso não é oficialmente suportado, então há alguns limites para suas funções. Ainda funciona muito bem!
• Acontece que o Walabot é ótimo para expressão musical. Eu usei em um Korg SDD3000, mas você pode usar qualquer efeito que quiser

Vá você mesmo. Isso não se limita aos efeitos de guitarra, posso ser usado com qualquer instrumento com qualquer efeito.

Vice-campeão no Raspberry Pi Contest 2017