Published March 6, 2017 © CC BY-NC-SA

Walabot FX - Guitar Effect Control

Control your favourite guitar effect using nothing but awesome guitar poses.

IntermediateFull instructions provided2 days3,805

Best of Europe

Walabot - Power to the Makers

Things used in this project

Hardware components

Walabot Developer Pack

Raspberry Pi 3 Model B

Sunfounder LCD1602

SunFounder PCA9685 16 Channel 12 Bit PWM Servo Driver for Arduino and Raspberry Pi

Servos (Tower Pro MG996R)

9V Battery Clip

4xAA battery holder

AA Batteries

Jumper wires (generic)

DPDT Latching Action Foot Switch

Korg SDD3000-PDL

Software apps and online services

Autodesk Fusion

Blynk

Hand tools and fabrication machines

3D Printer (generic)

Soldering iron (generic)

Story

New Blynk app integration video demo added

sorry for the horrid orientation.. stupid iPhone

Full Demo

Abstract

What would it be like to control musical expression using nothing but the position of your guitar in 3D space? Well, let's protoype something and find out!

The Basic Idea

I wanted to be able to control 3 effect parameter in real time, I wanted to do this using how I positioned my guitar. So one thing was clear, I was going to need a few things.

A sensor that is able to to see 3D space

Servos to turn the knobs

An LCD display

An I2C Servo driver

A Raspberry Pi

To learn Python

Walabot

Want to see through walls? Sense objects in 3D space? Sense if you are breathing from across the room?

Well, you're in luck:

The Walabot is whole new way for sensing the space around you using low power radar.

This was going to be key to this project, i would be able to take the carteasan (X-Y-Z) coodinates of objects in 3D space, and map those to servo positions changing how a guitar effect sounds, in real time, without touching the pedal.

Win.

More information about the Walabot can be found here

Getting Started

First things first, you will need a computer to drive the Walabot, for this project i'm using a Raspberry Pi 3 (here in refered to at RPi) due to the built in WiFi and general extra oomph.

I bought a 16GB SD card with NOOBS preinstalled to keep things nice and simple, and opted to install Raspian as my Linux OS of choice

(if you are unfamiliar with how to install Raspian, please take a moment to have a little read of this)

OK, once you have got Raspian running on your RPi, there are a few configuration steps to take to get things ready for our project

1. Firstly make sure you are running the latest Kernel version and check for updates by opening a command shell and typing

sudo apt-get update
sudo apt-get dist-upgrade

(sudo is added to ensure you've got administrative privilages eg. stuff will work)

This may take a while to complete, so go and have a nice cup of tea.

2. You need to install the Walabot SDK for RPi. From your RPi web browser go to

h t t p s ://w a l a b o t .c o m /g e t t i n g -s t a r t e d and download the Raspberry Pi Installer Package.

From a command shell:

cd downloads
sudo dpkg -I walabotSDK_RasbPi.deb

3. we need to start configuring the RPi to use the i2c bus.

From a command shell:

sudo apt-get install python-smbus
sudo apt-get install i2c-tools

once this is done, you have to add the following to the modules file

From a command shell:

sudo nano /etc/modules

add these 2 strings on seperate lines:

i2c-dev 
i2c-bcm2708

4. The Walabot draws a fair bit of current, and we'll also use GPIO's to control stuff so we need to set these up

From a command shell:

sudo nano /boot/config.txt

add the following lines at the end of the file:

safe_mode_gpio=4
max_usb_current=1

The RPi is an excellent tool for makers, but it is limited in the current it can send to the Walabot. Hence why we're adding a 1Amp max current rather than the more standard 500mA

Python

Why Python? well, as it's super easy to code, fast to get running and there's loads of good python examples available! i'd never used it before and was soon up and running in no time.

Now the RPi is configured for what we want, the next step is to configure Python to have access to the Walabot API, LCD Servo interfaces.

For the Walabot

From a command shell

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

For the Servo Interface

From a command shell

sudo apt-get install git build-essential python-dev
cd ~
git clone https://github.com/adafruit/Adafruit_Python_PCA9685.git
cd Adafruit_Python_PCA9685
sudo python setup.py install

Why do we need to used a servo driver? Well, for an RPi a couple of reasons.

1. The current drawn by a servo can be very high, and that number gets larger the more servos you have (of course). If you're driving the servo directky from an RPi you run the risk of blowing it's power supply

2. Timings of the PWM (Pulse Width Modulation) that control the servos position are very important. As the RPi doesn't use a realtime OS (there may be interrupts and such) the timings a not accurate and can make the servos twitch nervously. A dedicated driver allows accurate control, but also allows for up to 16 servos to be added, so this is great for expansion.

For the LCD

Open your RPi web browser

https://www.sunfounder.com/learn/category/sensor-kit-v2-0-for-raspberry-pi-b-plus.html

download

https://github.com/daveyclk/SunFounder_SensorKit_for_RPi2/tree/master/Python/ *.*

From a command shell:

sudo mkdir /usr/share/sunfounder

Using the graphical explorer, copy the python folder out of the zip file into you new sunfounder folder.

The LCD is used to prompt the user as to what exactly is going on. Showing the process of configuration through to the x, y and z values being mapped onto each servo:

Blynk

http://www.blynk.cc/

Blynk is a brilliant IoT service that allows you to create a custom app to control your stuff. It seemed like the perfect solution to give me remote control of the walabot to really dial in the settings...

One problem. Blynk is not currently supported on the Python platform, bugger. But fear not! i was able to find a nice little work around that allows remote control and remote parameter input! it is a littl hacky, but hey, this is hackster right?!

First step is to download the Blynk app from your favourite app store.

Second, sign up for an account. Once that is done, open the app and start a new project, choosing Raspberry Pi 3 as the hardware. The app will allocate you an access token (you will need this to put in your code). Once you have done that. you will need to set up the app as shown in the images. This is how it will interface with the Walabot.

1 / 3 • Main Menu

All the Blynk slider and button settings:

1 / 12

You can use this code with the Blynk App to clone my project to save you time

OK Now that the app is all set up, we can configure Python and the RPi to talk to it over the internets. Magic

Firstly, you need to install the Blynk HTTPS wrapper for Python. From a command shell:

sudo git clone http://github.com/daveyclk/blynkapi.git
sudo pip install blynkapi

Secondly, you need to install the Blynk Service on the RPi. From a command shell:

git clone https://github.com/blynkkk/blynk-library.git
cd blynk-library/linux
make clean all target=raspberry

To run the Blynk service:

sudo ./blynk --token=YourAuthToken

To ensure the Blynk Service runs on start up you need to modify the /etc/rc.local by doing:

sudo nano /etc/rc.local

Add this at the end:

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

(I have included a cope of my /etc/rc.local file in the code section for reference). To test it's working simply type:

sudo /etc/rc.local start

The Blynk Service should now be running.

Autorunning the script

Now that this is all set up and configured, and we have the python code ready. we can set things to auto run so we can ditch the keyboard and monitors. There are a few things to do:

Create a new script file to run out Python Program

sudo nano guitareffect.sh

Add these lines:

#!/bin/sh
python /home/pi/GuitarEffectCLI.py

Make sure to save it. Next we need to give the script permission to run by typing

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

And finally, we need to add this script to the /etc/rc.local file that we tinkered with earlier.

Sudo nano /etc/rc.local

Add

/home/pi/guitareffect.sh &

Be sure to include the "&" this allows the Python Script to run in the background. Right! That's all the configuration and software sorted, next it's time to wire up the hardware

The Hardware

First Breadboard prototype:

The enclosure was designed and rendered in the awesome Fusion360:

1 / 6

Gut shots:

1 / 4

Final Assembly Shots:

1 / 4

added the self adhesive metal disk that came with the Walabot Pro to fix Walabot in place

Conclusion

Well this has been a steep learning curve, but has been so worth it.

My take aways are

I had to learn Python.. turns out it's ace

Interfaced the Python on the Raspberry Pi with the Blynk IoT service. This is not officially supported so there is some limits to it's functions. Still works great though!

It turns out the Walabot is great for musical expression. I used it on a Korg SDD3000, but you can use any effect you like

Have a go yourself. This isn't limited to guitar effects, i can be used with any instrument with any effect.

Schematics

Code

from __future__ import print_function
from sys import platform
from os import system
from blynkapi import Blynk
import WalabotAPI
import time
import RPi.GPIO as GPIO


#set up GPIO using Board Numbering
GPIO.setmode(GPIO.BOARD)
GPIO.setup(18, GPIO.IN, pull_up_down = GPIO.PUD_UP)

#blynk auth token
auth_token = "auth_token_here"

# Import the PCA9685 module for servo control.
import Adafruit_PCA9685

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

# Initialise the PCA9685 using the default address (0x40).
pwm = Adafruit_PCA9685.PCA9685()

# blynk objects
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")

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

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


def LCDsetup():
        LCD1602.init(0x27, 1)   # init(slave address, background light)

        
def numMap(x, in_min, in_max, out_min, out_max):
    """ used for mapping the walabot readings to servo position """    
    return int((x- in_min) * (out_max - out_min) / (in_max - in_min) + out_min)

# use this for rounding up the raw data to the assigned value
def myRound(x, base=2):
    return int(base * round(float(x)/base))

#extracts the number form the returned blynk string
def numberExtract(val):
    val = str(val)    
    return int(filter(str.isdigit, val))

# Set frequency to 60hz, good for servos.
pwm.set_pwm_freq(60)

# Configure min and max servo pulse lengths defaults
SERVO_MIN = 175 # Min pulse length out of 4096
SERVO_MAX = 575  # Max pulse length out of 4096

# walabot default values
R_MAX = 60
R_MIN = 20
R_RES = 5

THETA_MAX = 20
THETA_RES = 5

PHI_MAX = 20
PHI_RES = 5

THRESHOLD = 1

# variables for blynk switching
on = "[u'1']"


class Walabot:

    def __init__(self):
        self.wlbt = WalabotAPI
        self.wlbt.Init()
        self.wlbt.SetSettingsFolder()
        self.isConnected = False
        self.isTargets = False
        self.distance = lambda t: (t.xPosCm**2+t.yPosCm**2+t.zPosCm**2) ** 0.5
        
    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: # if nothing from blynk app, load defaults    
            SERVO_MIN = 175 # Min pulse length out of 4096
            SERVO_MAX = 575  # Max pulse length out of 4096

            # walabot default values
            R_MAX = 60
            R_MIN = 20
            R_RES = 5

            THETA_MAX = 20
            THETA_RES = 5

            PHI_MAX = 20
            PHI_RES = 5

            THRESHOLD = 1
            
    def connect(self):
        try:
            self.wlbt.ConnectAny()
            self.isConnected = True
            self.wlbt.SetProfile(self.wlbt.PROF_SENSOR)
            #self.wlbt.SetProfile(self.wlbt.PROF_TRACKER)            
            #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_RES)
            self.wlbt.SetArenaR(R_MIN, R_MAX, R_RES)
            self.wlbt.SetThreshold(THRESHOLD)
            
        except self.wlbt.WalabotError as err:
            if err.code != 19:  # 'WALABOT_INSTRUMENT_NOT_FOUND'
                raise err

    def start(self):
        self.wlbt.Start()

    def calibrate(self):
        self.wlbt.StartCalibration()

    def get_targets(self):
        self.wlbt.Trigger()
        #return self.wlbt.GetTrackerTargets()
        return self.wlbt.GetSensorTargets()

    def stop(self):
        self.wlbt.Stop()

    def disconnect(self):
        self.wlbt.Disconnect()
        self.wlbt.Clean()          
     

        


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()  #check for blynk start button press
            
            
        if (GPIO.input(18) == 0): #check footswitch
            flag = False
    

    LCD1602.write(0, 0, "OK! let's Do it ")
    LCD1602.write(0, 1, '                ')       
        
    wlbt = Walabot()
    wlbt.blynkConfig()
    wlbt.connect()
    LCD1602.clear()
    if not wlbt.isConnected:
        LCD1602.write(0, 0, 'Not Connected ')
    else:
        LCD1602.write(0, 0, 'Connected     ')
        time.sleep(2)
    wlbt.start()
    wlbt.calibrate()
    LCD1602.write(0, 0, 'Calibrating.....')
    time.sleep(3)
    LCD1602.write(0, 0, 'Starting Walabot')    

    
    appcheck = start_button.app_status()   
 
    flag = True # reset flag for main prog    

    while flag: # used to put effect in standby (effectively)
        if (appcheck == True):
            if (str(check) != on):
                if (GPIO.input(18) != 0): #check footswitch        
                    flag = False
            else:
                check = start_button.get_val()  #check for start button press
                appcheck = start_button.app_status() 

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



        xval = 0
        yval = 0
        zval = 0
                
        average = 1
        delayTime = 0

        targets = wlbt.get_targets()

        if len(targets) > 0:
            for j in range(average):

                targets = wlbt.get_targets()
                if len(targets) > 0:
                        
                    print(len(targets))
                    targets = targets[0]

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


            xval = numMap(xval, -60, 60, SERVO_MIN, SERVO_MAX)
            xval = myRound(xval)
            if xval < SERVO_MIN: # protect the servo
                xval = SERVO_MIN
            if xval > SERVO_MAX:
                xval = SERVO_MAX            
            LCD1602.write(0, 0, 'x=' + str(xval) + '           ')
            pwm.set_pwm(0, 0, xval)

            yval = yval/average

            yval = numMap(yval, -60, 60, SERVO_MIN, SERVO_MAX)
            yval = myRound(yval)
            if yval < SERVO_MIN: # protect the servo
                yval = SERVO_MIN
            if yval > SERVO_MAX:
                yval = SERVO_MAX            
            LCD1602.write(0, 1, 'y=' + str(yval))
            pwm.set_pwm(1, 0, yval)


            zval = zval/average    

            zval = numMap(zval, R_MIN, R_MAX, SERVO_MIN, SERVO_MAX)
            zval = myRound(zval)
            if zval < SERVO_MIN: # protect the servo
                zval = SERVO_MIN
            if zval > SERVO_MAX:
                zval = SERVO_MAX    
            LCD1602.write(8, 1, 'z=' + str(zval))
            pwm.set_pwm(2, 0, zval)
            

        else:    
            print("no targets")
    LCD1602.write(0, 0, "Shutting Down   ")
    LCD1602.write(0, 1, 'The Walabot     ')
    time.sleep(3)
    wlbt.stop()
    wlbt.disconnect()

if __name__ == '__main__':
    while True:
        main()

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.



# Print the IP address
_IP=$(hostname -I) || true
if [ "$_IP" ]; then
  printf "My IP address is %s\n" "$_IP"
fi 

./blynk-library/linux/blynk --token="you token goes here" &
sleep 10
sudo /home/pi/guitareffect.sh &
exit 0

Credits

Dave Clarke

14 projects • 83 followers

Industrial Designer, Maker of Things, Lover of Phi and all around nice guy

Comments

Awards

Best of Europe

Walabot - Power to the Makers

Walabot FX - Guitar Effect Control

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

New Blynk app integration video demo added

Full Demo

Abstract

The Basic Idea

Walabot

Getting Started

Python

Blynk

Autorunning the script

The Hardware

Conclusion

Custom parts and enclosures

Walabot FX enclosure STL files

Walabot FX design files

Walabot FX Servo Bracket

Walabot FX Servo Pot Adapter

Schematics

Walabot FX Wiring Diagram

Code

GuitarEffectCLI.py

guitareffect.sh

rc.local

LCD Python Lib

Servo Driver Python Lib

Blynk Python HTTP Wrapper

Credits

Dave Clarke

Comments

Awards

Embed the widget on your own site

Walabot FX - Guitar Effect Control

Walabot FX - Guitar Effect Control

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

New Blynk app integration video demo added

Full Demo

Abstract

The Basic Idea

Walabot

Getting Started

Python

Blynk

Autorunning the script

The Hardware

Conclusion

Custom parts and enclosures

Walabot FX enclosure STL files

Walabot FX design files

Walabot FX Servo Bracket

Walabot FX Servo Pot Adapter

Schematics

Walabot FX Wiring Diagram

Code

GuitarEffectCLI.py

guitareffect.sh

rc.local

LCD Python Lib

Servo Driver Python Lib

Blynk Python HTTP Wrapper

Credits

Dave Clarke

Comments

Awards

Related channels and tags