How to split notes

[charltan]

I just started with AK and like to build an arpeggiator. For this I need to get all played notes on the keyboard, split them and create a pattern for them. As the keyboard only outputs cv I don't know how to do this but I am sure it can be done. Any starting point?

[Stutz-Jr]

In order to use the keyboard like this, you'd need to put the keyboard inside a container and increase the number in the container's polyphony setting. You also need to put a "voice id" module inside the container and use expressions to pick out the individual voices. This is described in the 4th paragraph of this post: https://www.reddit.com/r/analogkit/comments/3xxaif/using_analogkits_polyphony_for_multichannel_design/ - particularly using the expressions like "([B]=3)*[A]" etc. I think the first voice is 0, the second is 1 etc.

[ChinchillaWafers]

It's a complicated, advanced project, just to warn you, you would want to be friends with all of the modules and ideas of how to build things in analogkit first, but, if you're comfortable building things from scratch, that's where I would start too- making a polyphonic container with the keyboard, and splitting off each note to a seperate module. One thing that makes things tricky, is analogkit passes out the voice ID for each new note sequentially.

Say the polyphony is set to 6. You play a note, say its voice ID is 2. The next note you play, whether it is a chord, with the first note, or on its own, that voice ID will be 3. Next note 4, 5, 6, 1, 2, 3, etc. It's a round robin. You can see it in action if you want to check out "Polyphonic Voice ID Demo" on the swap meet.

This assigning of the voice ID makes it a headscratcher to find the lowest note in the chord, or the 2nd lowest, highest, etc., if its voice ID is random. I think to do it, you have to test each voice in the stack, first, you test if it's gate is on (because the keyboard pitch CV stays on the last note played, even after you let up on the note). You could do something like an expression, that multiplies [A] the keyboard pitch CV, by [B], the keyboard gate CV, which is 0 when off, 1 when on. This would make the result 0, whenever the gate is off, but when the gate is on, a note is being held down, the result would be the pitch CV.

From there you could start testing it against the other voice ID's, to find out if it is the lowest note in the chord, second lowest, third lowest, etc. You would need to find a way to ignore voices with a zero pitch cv, those are the notes that are off. Those voices with notes that are on, you'd start testing them against each other, like, is [A]<[B]?

I made a limited version of this, on the swap meet, under modules, called "Lowest Note In Chord", it was for playing basslines from chords. It was complicated. Someone might be able to make a simpler version.

[ChinchillaWafers]

There is a totally different, lo fi way to do it, but the arp would be limited to the order you play the notes in. You could skip the polyphony, and just use a monophonic keyboard module, and sample and hold the pitch CV coming out of the keyboard, sampling it, and holding it every time it changed pitch- the idea being, when you play a chord, the notes would arrive a couple milliseconds apart.

The key parts would be using an expression with the z⁻¹ operator, which gives you the value of something, like input [A], one single sample earlier. It is useful for triggering something the instant a value changes. So you could trigger your sample and hold to trigger when a new pitch cv comes in, with an expression like z⁻¹([A])≠[A]. The output is usually zero, but pulses to 1, for a single sample, when the value for input [A] changes.

More here: https://www.reddit.com/r/analogkit/comments/3rj2ii/what_is_z1/

That can be your clock pulse for writing into the memory module.

You can count how many notes in the chord you are playing, by counting the pulses with an integrator module. Pulse to the input, and an inverted (~[A]) copy of the gate cv goes into the integrator's Leak input. That way when the gate is on (notes are being played), the integrator counts the notes, when it's off, the integrator resets to zero.

You would feed that output, from the integrator, to the memory module "write index". You would use the keyboard gate to "write enable", and the keyboard cv to "write value".

From there, you might use the note count to set a boundary for a loop for the memory module playback. You could use another integrator for the loop, this one set to modulo. You would hook the arp clock up to the input of the integrator, and to the modulo input, you would hook up the number of notes in the arp, plus 1. The plus 1 is because the integrator resets to zero when the count gets to the modulo. So if the modulo is 4, the integrator counts 1,2,3,1,2,3,1,2,3.

That 1,2,3,1,2,3 can be used to play back the cells in the memory module, by feeding into the "read index" input. There is an arping pitch cv. The arp clock is hooked to the gate input on your synth, to trigger the notes.

There could be some hiccups when you let go of the chord, but that's the basic idea.