The Pieces: The addition of velocity sensitivity to my Polysix builds upon many of the previous mods that I've done. The core enabler of this mod was the fact that I had already replaced the stock Polysix keybed (which does not transmit velocity information) with a new Fatar keybed that is both velocity and aftertouch sensitive. It's sweet. As shown below, in my modified Polysix, the data from the new keybed is fed to an Arduino Mega, which assigns each new note to one of the six voices in the Polysix. To modulate that voice in response to the note's velocity, I also feed the velocity information to my new "Velocity Processor", which then does the actual velocity-based modulation.
|My highly-modified Polysix. The newly-added "Velocity Processor" is highlighted in yellow.|
Velocity-Based Modulation: So what kind of velocity sensitivity did I implement? I chose to modulate the intensity of the filter envelope. As you heard in the demo, the intensity of the filter opening and closing gives a strong sense of articulation and dynamics. In a stock Polysix, the intensity is the same for all voices (as set by the "EG Int" knob). My goal was to dynamically change the envelope intensity based on how hard I hit the key. As shown below, I chose to attenuate the filter envelope based on the note velocity. At maximum velocity (MIDI 127), the envelope would be at its full intensity (as set by the "EG Int" knob, as before). At lower velocity values, the intensity would be progressively smaller. As a result, notes that I press hard should have a strong intensity and notes that I press lightly will soft intensity.
|Scaling the VCF Envelope Based on the Note Velocity|
Hardware Approach: After studying the Polysix schematic, and after figuring out how the VCF envelope multiplexing and how its associated addressing and synchronization works, I settled on the plan that I would manipulate the VCF envelopes in the multiplexed portion of its circuit. Being multiplexed, I only have one signal line to manipulate, instead of six individual signals (one for each voice). Sure, the signal on that one multiplexed line is changing very quickly (all six envelopes are time-sliced onto a single line), but I've already proved that a Teensy 3.1 plus a digital potentiometer can keep up just fine. So, my hardware plan was settled -- I'd insert my Velcoity Processor right after the VCF Multiplexer (IC24) on the Polysix's KLM-366 PCB.
Building It: In the Polysix, I was happy to see that IC24 is socketed, which means that you can pull out the chip and insert all sorts of fun new circuitry via the now-empty socket. And so that's exactly what I did. I took a piece of protoboard, soldered on the Teensy 3.1, the digipot, and IC24 itself. More details on the build are here. I then inserted the assembled protoboard into the empty IC24 socket. As you can see below, it's not too pretty. It's not complicated, it's just messy. Someone with more experience would certainly do this more cleanly.
|My "Velocity Processor" Installed in my Polysix. Lots of wires. Someone smarter than me could surely do it more cleanly.|
Arduino and Teensy Software: Hardware alone does not make this modification work. I also needed to write some software. For example, I needed to program the Teensy (my "Velocity Processor") to keep up with the multiplexing circuitry and to drive the digipot to properly attenuate the envelope signal. I also needed to expand the programming on the Arduino Mega (my replacement for the Polysix's "Key Assigner CPU") to properly route the velocity data from the keybed to the Velocity Processor. While this routing of the velocity data sounds straight-forward, the need to support the Arpeggitor modes made it more challenging (note that the velocity-sensitive arpeggiator leads to fun effects, like being able to make some notes feel accented...definitely a cool effect). In the end, the software writing went pretty smoothly. My latest code for both the Arduino and the Teensy are on my GitHub here.
First Trials and Tweaking: Once I got it all wired up and programmed, I started to play it. The velocity sensitivity really makes it more expressive. Velocity sensitivity also quickly exposes bad keyboard technique! I need practice! But, even with my poor technique, I felt that the velocity response wasn't quite right. So, I spent some time remapping the velocity values to create a custom response curve. Furthermore, to get a good electric piano/clav sound, I felt that I needed a little grit and compression in the sound. So, I added a drive circuit, which will be the subject of another post.
Playing It: Once I got it adjusted to my liking, I've had a lot of fun adjusting all of my traditional Polysix patches to best include the velocity capability. I started with the piano and clav sounds (as seen at the top of this post) because they our ears most expect velocity dynamics with these kinds of sound. Interestingly, though, even organ sounds (which are traditionally not velocity sensitive) can benefit from velocity dynamics. Hitting the keys a little harder, gives the organ more "pop!". You can here it this little carnie organ vamp:
Moving Forward: My next step is to continue to refine the interaction of the velocity with the other synth's features. For example, I'd like a way to turn off the velocity sensitivity so that the EG Int will work as it does in a stock Polysix. To do this, I simply need to wire up a switch, or re-purpose one of the switches already on the back of the synth. Also, I need to further tweak (and then write-up!) my drive circuit. It is critical for the velocity-sensitive piano/clav sounds, but I've found fun uses with other sounds, too. Finally, I also want to improve how the velocity interacts with the Unison and Chord Mem modes of the synth. It doesn't feel quite right yet. So there's lot's to do! But first, I've got some playing to do. :)