Wav Trigger with banks

Hi folks, i wanted to split this out from the my build progress topic. What im aiming to do is to expand the capabilities of my Wav Trigger so that i can access banks of samples.


Got an arduino to act as a USB to TTL serial interface. Was able to trigger the tracks and everything from serial. To use an arduino to connect up to the wav trigger via serial, you just load up no code or connect RST to GND. That effectively makes the arduino a USB to TTL serial interface. Then you just hook up the wav trigger’s GND, 5v, TX, RX to the arduino’s. Note, unlike a normal connection where you would connect RX to TX and vise versa, you connect RX to RX and TX to TX in this scenario.


I got it to flash. The trick was to follow instructions and not ignore the IMMEDIATELY portion.


First step was to update the firmware, and thats finished.

Note to self, it would also be cool to try and get CV-able CPU mod to get pitch shifts.


Ok, with the new firmware it was actually really simple to configure triggers 15 and 16 to be bank down/up. Works like a charm, hopefully tomorrow ill have some nead stuff to show after the long process of loading this thing up with some samples. The WAV trigger will only play WAV files formatted as 16-bit, stereo, 44.1kHz. A lot of my samples are mono. Its 2021 and i got to say Audacity is still the best program for this kinda thing.


Cool, i got bankable samples for the WAV Trigger workin. Right now, im using 2 of the triggers to bank up and bank down, but i kinda want to see how much of a pain it would be to keep all 16 tirggers and send a bank up/down with serial.


I just ordered my wav trigger - so I will be watching this pretty close!

1 Like

Its lookin like you can totally control this guy with serial. The link below documents the serial control protocol.
WAV Trigger Online User Guide – robertsonics

I just realized though that my project as it is is purpose built for drums. With 14 voice poly, its actually very sensible to just use the 15-16 triggers to trigger the bank shifts and not need an additional nano in the build.

On that note, its also very likely i will buy another one to build a digital sampler with pitch shifts.

The idea is that you will have a midi serial interface with an arduino, which will translate the midi notes into serial control messages to the WAV trigger that maps to different sample rates. Each track could then be pitch controlled. I am thinking mellowtron and wavetable or even a proper sampler could be possible.


Sounds a lot like this:

1 Like

I dont think this project does what i was discussing. I was saying you could shift the pitch of the samples themselves, not trigger another track that contains a different sample of a different pitch. What i propose is more than a midi mod.

1 Like

Excuse my ignorance, but what is connecting by serial

Serial communication is data transmission. You send data one bit at a time (serially) over a bus. You just have to make sure both devices use the same protocol.

Baud Rate - how fast you send your data (bits per sec)

Not exclusive to serial is the idea of framing your data. This is so that the receiver can know what its lookin at, when it starts and ends or if there should be another data frame incoming etc. A common convention is to send data least significant bit first.

The hookup is generally pretty easy. The bus consists of two wires, TX and RX (Send and Receive). You normally connect the TX to RX on the other device, and RX to the TX of the other device.

So the idea would be to have an arduino receive a midi note input like C4 (middle C), and that would send a serial message that would say “play this sample which is C4 pitch”. Then, you can play another midi note C#4, and then before we send the “play the C4 pitch sample”, we send a message that shifts the sample rate and thus the playback speed by one semitone higher. The result would be that the original sample that was pitched C4 will then be pitch shifted to C#4.

So for example:

You start with a 2 byte Start of Message (SOM) header: 0xF0 0xAA.
1 byte indicating total number of bytes in message.
1 byte message code from 0x00 to 0x7F.
The message data itself.
End of Message (EOM) byte: 0x55.

If you wanted the wav trigger to send back the Version of firmware its running you would send the following bytes over serial:

0xF0 0xAA 0x05 0x01 0x55


  • 0xF0 0xAA = The SOM header. Will always be this.
  • 0x05 = The number of bytes in the message. This includes the SOM header and the EOM. Notice there are five groups of hex numbers. Each one is a byte.
  • 0x01 = GET_VERSION has a message code of 0x01. This informs the receiver what we wanted to do here.
  • 0x55 = The EOM or End of Message byte. It says we are done.

You shoot binary at it.




you all remind me why I’m a hammer swinger :rofl:

1 Like

If i end up doing this part of the project, i fully intend on explaining everything.


A short demo of cycling between two drum banks. Notice that the PREV and NEXT triggers control what bank I am using. This means you can sequence bank shifts as I show in the video.


So I spent today making some kits for the WAV trigger and made a script to take these kits i made and format them properly for the WAV trigger.

I give it inputs based on directory structure, this way you can order what types of samples will be assigned to each trigger.

Then, it will do all the needed conversions like sample rate, bit depth, and convert to stereo (it needs this for some reason), and dump the results with the proper naming convention. You get to keep your original bank/kit setup in the input directory so you can make changes to it, delete the files in the output directory and just re run the script.


This way, you can have a specific “kit” format that will keep all of your drum kit “banks” on your WAV trigger mapped correctly. The way i have this configured, i have the first 4 triggers be a bass drum, so no matter what bank is selected, the first 4 triggers will always be mapped to the bass drum.


Once I run the python script, the results are placed into the output directory. Notice that every 14 triggers, the same mapping is followed. The script also takes into account creating dummy WAV files for the trigger inputs 15 and 16 that are now used to trigger bank up and bank down.

Also, you can see the changes in format also take place:


So using the script, it was much easier to make more banks of drum kits.


If you want the script, or if you just want the executable, its found in my github:


Just starting to build this. @Caustic I have zero experience with working with a wav trigger so I apologize for all of this in advance. Is the basic build any different than in sams build video?

Being able to use multiple banks does seem incredibly useful. How difficult would it be to implement a button (or two) to cycle back and forth between banks?

1 Like

The build is the same as in sam’s video. Once you have that built lemme know and ill guide you through the bank switching part.

Sorry about not updating this thread. i have a terrible habit of switching to other projects lol. This would be a good excuse to finish. :slight_smile:


Oh dont worry, I’m great at bugging the crap out of people! XD


Has anyone considered putting protection on the plugs in any way shape or form? I know Sam said he wasnt worried about it, but I’m pretty accident prone and if its a matter of just adding one more component to each plug I am more than happy to do it.