Polyrhythmic Tap Sequencer


#1

Tap Sequencer

See the demo for instructions

This is a looping tap sequencer which runs or records (or resets) over a specified range. A sync pulse starts playback or recording from minN to maxN. This is a wrapping sequencer—The max step can be greater than or less than the minimum, or they can be the same number.

At present, the output will be a 1 or a 0. A later version will save velocity info into the step. I just didn’t need it for this application, since I was triggering from Audulus button nodes. Triggering it with a MIDI key would make that feature potentially useful.

16-step tap sequencer w:controller DEMO 2.audulus (198.0 KB)

Project Utilizing the Tap Sequencer

Polyrhythmic Tap Sequencer

Lots going on here. I built a sequencer to use when practicing. Got carried away with a first stab at polyrhythm. Info is posted around the project on how to use. Basically, you set the beats per bar, tap out a tempo (or dial in via the alternate method), and start tapping “drum heads” to start the sequence. Alternatively, you can do a long press on the little reset patch (on the left), after setting the knob to all off, all on, or somewhere in between for random patterns, then add manual taps as desired.

You change the loop size and starting beat with the controller patches. The controllers issue a sync pulse that can resync everything if you change a loop property. This is optional, as the sequencer modules inside can be changed on the fly and continue in time, which works pretty well, musically. You might find your loops more interesting if you double the steps per loop, such as setting beats per measure to 10 if you’re doing 5/4 time.

I just added a clock doubler to put some faster fills in there.

I’ve gotten some really cool rhythms out of this. Think of it as a sort of rhythm Etch A Sketch. All steps are reset to off when you turn it on.

It’s been fun to play with. Maybe TOO fun. I will probably go back to my one loop version so I won’t waste more of my guitar practice time.

Note: The great drum sound synth and mixer are from the Audulus sample patches.

16-beat Tap Polyrhythmic Machine.audulus (2.0 MB)


#2

Really great work. I had a blast playing with this once I read and understood the directions.

What a great patch. Could you possibly make a tap note module? That would allow a melody to be latched.

Thanks for your effort.


#3

[Edit with a bit more info in the patch and a little bit better synth — it’s one I made that splits off the root (Hz) and produces intervals off the root to make chords or whatever]

I just did this afternoon! Thanks for the kind words. I love making musical things!

16-step tap sequencer w:controller DEMO MIDI 3 Param.audulus (718.1 KB)

This has version 2 of my sequencer, which allows any value to be stored, and which brings out the randomizing element so two can be auto filled with random values in an identical pattern. In this case, you auto fill with a 1sec or longer press of any MIDI key (the onboard buttons are left alone, since the sequencers should run in lock-step in this application.)

I used the scale quantizer to limit the preloading to whatever scale you want, then you can overwrite the loop at will from your MIDI keyboard. Now, setting the density to zero empties the steps as before (really just sets the freq to zero) but above that you get random amplitudes and tones (in the scale) with increasing density, up to 100%.

Enjoy!!


Random Source with Seed Knob
#4

#Drums/Tones Tap/MIDI combo
##with dead simple synth

Changes: The MIDI note you hold down to reset the MIDI sequencer sets the key of the random note sequence used to preset a pattern on long press. Major or minor scale selected with the button on the scale quantizer.
This uses the great Audulus - supplied scale quantizer.

You reset the drum sequencer and set the fill density separately from the MIDI sequencer. On the drum side, you still press and hold the reset button (or an isolated pad) for a second to reset/fill the sequence, In the MIDI side you hold a key on the keyboard.

I took away one drum loop from the original Polyrhythmic drum side because the processor load was killing my poor iPad.

16-beat Tap Polyrhythmic Drums n Tones.audulus (1.7 MB)


#5

I like the workflow :ok_hand:, but indeed this is a very cpu intensive patch :sweat:. If you could distill the tap and sample looping sequencer down to one minimal patch, what would it look like?:shushing_face:


#6

I’d rethink the “erase” idea and see about making the read parts do that duty. I’d probably keep the long-press functionality. It’s nice to be able to erase or refill an isolated sequencer without double buttons everywhere, although it’s kind of expensive.

Lots of pulse shaping and such I used to avoid race conditions. Again, expensive as it’s running a timer in every one. This was mainly the result of my laziness about analyzing the timing, just putting safety bumpers anywhere I got a queasy feeling. I think the long press is about equivalent to one half of a safety bumper duo, so losing some of those would be worth the effort.

Don


#7

Version 4: Simplified the resettable sample and holds I used in these sequencers to lose a bit of processor load.

16-Step Tap Sequencer V4.audulus (86.0 KB)

Tone-only Demo:

16-Step Tap Tone Sequencer DEMO.audulus (402.7 KB)

Full-up application, with drums and polyrhythm capability.

16-beat Tap Polyrhythmic Drums n Tones.audulus (1.7 MB)

Instructions are built in.

In essence: Tap in a tempo. Tap in some drum hits or long press individual drum heads to load random pattern (or fill all with a long press on the broken out fill all button) with fill density set by the knob near the drum heads.

To set up tones: Hit some notes on your MIDI keyboard to record to the tone sequencer, or long press a note to auto fill the sequencer with random tones in the key of the pressed MIDI note (major or minor scale is set by the button on the quantizer). Alternatively, fill the sequencer by a tap on the fill now button, using the last-pressed note on your keyboard. The tone sequencer has a separate fill density control, because (I feel at least) that dense tone fills sound better than dense drum fills. To each his/her own!

Note that the sequencer controllers are set to different loop lengths and sync points to demonstrate the use of this project to experiment with polyrhythms.

Also, although my latest sequencers now can record any number, including velocity values (and the tones sequencer does that), the drum sequencers in the project just record a 1 (full volume) drum hits. This is only because I don’t own any MIDI drum controllers. I’ll probably do one with velocity pretty soon.

Don


#8

Very nice! :cowboy_hat_face:. This is a resettable S&H I came up with a while back. The reset pulse interrupts the trigger, so it will reset even if the trigger is held high. I thought you might find it useful. resettable Sample and Hold.audulus (7.1 KB)


#9

Thanks! I’ll have to check out that sample n hold!


#10

Here’s the latest. I’ve always been fascinated by automation and music—using a little randomness to make it interesting and a little orderliness to make it hang together somewhat.

This has two tone loops—one that the user fills by pressing keys on the MIDI keyboard—the other one self-filling, with adjustable density, scale, and tone spread.

Two drum loops are still included, each with pads or self-filling, with its own same density parameter setting.

A timer with a linear display refills the drums and auto filling tone loop. You can set how many reps before changing the pattern.

A SOLO button latches the root (the last MIDI note hit before refilling the tone loop) to allow soloing over loop fillings without changing the root of the scale used to refill. When you turn off SOLO, the latest active MIDI note becomes the new root.

A big addition today was the expansion from the two scales offered by the quantizer, bringing it out as an input, with root note external as well as the quantized ones. The codes for the minor and major, as well as the 6 additional modes, selected via a mux.

A 2x clock is there to try double-time loops.

16-beat Tap Polyrhythmic Drums n Tones.audulus (2.0 MB)


#11

For some reason this is loading with white cords coming from a sample and hold node, which i kind of confusing since I thought they always load with a zero.


So I’m not sure if this is an audulus bug or if there is a 0 Hz value that’s being input into a logarithm somewhere.


#12

Hit any midi note. That may be the problem. It doesn’t auto load a root. Going in to work! Good luck! Will revisit tomorrow!


#13

I’m pretty sure that’s the problem. To run, you need to tap out a clock and hit a first note from your midi keyboard to be the root for the background loop. Hope that helps!


#14

I clamped the midi output node to prevent the negative infinity.


#15

Nice fix. Will implement on mine.


#16

Updated the write-up for latest.


#17

More playing around. My earlier mod to the existing quantizer had a fatal flaw, so I decided to try my hand at writing one. I think it’s a little expensive, processor-wise, compared to the Audulus one I had tried modifying. The Audulus seemed to use a very clever “nesting funnel coin sorter” method, which my poor brain was too dim to comprehend this week, alas.

16-beat Tap Polyrhythmic Drums n Tones.audulus (1.8 MB)

The new project uses my new quantizer patch. It also has a new scale selector, which uses up all the 16 scales my 2x8-bit internal MUX structure could hold. The Tonic-only scale is just the scale’s first note (aka the key for the scale), which is just the last midi note before the latest pattern fill happened or before the AUTO button was hit. (If you turn up spread all the way up to 36 half-steps, the Tonic-only scale in AUTO mode will fill the auto-fill sequencer with a random series of the root tone, falling randomly over three octaves, which can sound kind of cool against your own tap tones.)

A change to the SOLO button: It’s no longer called SOLO. It’s AUTO now. And it’s no longer a toggle button, but a momentary contact button with latching logic A light tells you the state. It always comes up in the off state now. You still have to hit some midi note to hear some tones from the auto-filling tone loop, but at least it won’t confuse you by being saved in the “pressed” state and coming up not ready to pass that note along for latching. Also, if you hit AUTO now without having pressed a midi key, the new setup outputs a random fill based on the selected scale, in the key of A (440, a “0” in “octave value” speak.) That’s because the random in-key fill is just the fill in the selected scale in the key of A (440), superimposed over the latched midi note. Such is the beauty of exponents.

I also made the user-filled tone loop its own controller, to allow polyrhythm of the tones as well as the drums. I combined the two drum loop outputs into one drum synth (saves processor, considering my quantizer is a bit of a hog.)

I hope this brings some fun your way.
Don


#18

I’m curious if you are talking about the “gateable” quantizer? You might look at the STS uQuant, which has an uncanny internal similarity at first glance.

I’m definitely looking forward to trying this patch out after aI take a quick nap.

edit: here is a little quantizer comparison:


quantizer comparison.audulus (617.9 KB)


#19

I built several different quantizers at one point. I was initially inspired by the Ornament and Crime eurorack module which has a pretty flexible quantizer as one of its many functions. It featured some non-well-tempered scales, so I needed to create an architecture that was flexible. The simplest approach to a well-tempered quantizer is to take a 1 per octave signal, multiply it by 12, take the floor() and divide it by 12. This is the approach taken by the chromatic quantizer in the library.


This is very lightweight, but has a number of drawbacks. Rather than outputting the note closest to the input, it outputs the closest note below the input. This can be improved by slightly changing the formula to floor(x*12+0.5)/12. This will result in outputting the note closest to the input value. The more significant drawbacks to this approach are that it does not allow one to exclude notes from the scale, and the intervals between the notes are all equal (well-tempered). For many uses, these limitations are outweighed by the high efficiency of the module and I often use this with sequencers, where the output of each step is fixed.
The next level of complexity is a well-tempered output where some notes can be excluded. This category includes the uQuant and many of the quantizers from the library as well as many others that have been posted. The challenge here is adjusting the logic of the quantizer to select the correct output note based on which notes are currently enabled as well as the input note. Again the simplest approach is to output the note below (or above) the input value, but I prefer to output the closest note although it requires a bit more computation. With the uQuant, in order to keep the unit compact, I chose to input the scale as a integer value which is converted to a binary pattern of notes internally. The quantizer unit itself could be used with any form of note selection. The heart of the quantizer is a module which takes an upper and lower value and an input and outputs the upper or lower value depending on which is closer to the input.

It takes the difference between the input and the upper and lower value, determines which is greater, and switches the output accordingly. Looking at it now, I realize that I could improve it slightly by substituting a crossfade node for the pair of multiply nodes.
The quantizer is a cascade of these modules driven by a set of crossfade nodes used as switches to select which notes are enabled. Then quantizer uses 0 as it’s first note which is typically A, so I included a scale root selector and transpose function to allow the use of different keys with the same input scale.
The most complex units are those that allow scales based on an arbitrary division of the octave. I developed a unit that allowed for scales up to 16 notes where each note value could be configured separately.
30%20AM
I also built a microtonal unit that went to 39 notes.
10%20AM
Needless to say these were rather more complex and CPU intensive. They use a similar approach to quantizing but allow for individual note values. I haven’t posted them on the new forum as yet since they’re rather CPU heavy and I rarely use them.


#20

Switched out the multiply nodes for a crossfade and reduced CPU usage. :cowboy_hat_face: “Less is more”