Now got what sounds to me like the ideal project: should be simple enough but it teaches me important lessons about Pure data.

Been trying to create a basic chorder/harmonizer taking input from a MIDI keyboard or wind controller and outputting multiple notes to an external synth connected via MIDI as well. Later on, this project might end up with Pd-synthesized sounds, but my first need is for a simple tool which generates different chords based on incoming MIDI notes.

More specifically, the idea is to create something like the “Michael Brecker Effect”, based on something the sax player would do with his Akai EWI and Oberheim Xpander. Brecker would play melodic lines on his (monophonic) EWI and the Xpander would generate random chords under that. There are tools out there which do this but it’s probably best for me to create my own. Been using a tool which does something a bit different (using the incoming MIDI notes as chord roots instead of top notes) and it’s just too much fun. Creating my own chorder/harmonizer would allow me to appropriate the whole thing to my own context.

My sense is that much of this is really trivial, by Pd standards. Even surprised not to readily find multiple examples of just this thing. Maybe my search skills are off. But my understanding of Pure data is so fragmentary that it quickly gets me stuck.

Here’s where things stand at this point. Can easily generate a given chord type (say, a major chord) under any incoming note. Offset the [notein] MIDI note number by a certain amount does create an interval, obviously. And sending multiple numbers to [noteout] actually works. Quite neat. It even deals correctly with note off messages, which was somewhat surprising to me. So far, so good. Can play major chords on any note, which is already a fun effect for a monodic instrument (but something which is already possible for me to easily do).

Where things get really tricky really quickly is in generating different chord types for each incoming note. For instance, in a C major context, would like an incoming C or G to produce major chords, but an incoming D or E should produce minor chords. A non-scale incoming note could work as a passing tone (not producing a chord). Basically, each of the 12 notes in the 12TET octave would trigger a different set of notes.

Therein lies the rub. Triggering different events based on different notes is easy enough with [mod] and [select]. But, for some unobvious-to-me reason, sending those “mixed messages” breaks the whole thing. This is when note off messages stop being interpreted correctly (so: stuck notes). It’s also been impossible to produce passing tones (an offset of 0 for each voice doesn’t appear to have an effect).

It’s fairly clear to me that there’s a basic misunderstanding on my part. About many things. Like which inlet produces which results and how/when messages are interpreted. To my surprise, it sounds like Pd objects have memory, which is reset by closing the patch and opening it again.

Lots to learn!

At any rate, here’s my current attempt at making a chorder/harmonizer patch. Tried many different things leading to different problems. This version gives me stuck notes. Which is what got me stuck.

chorder.pd

Any help would be greatly appreciated!

Actually when you trigger a note your program sends out 7 notes:

• 1 - the note you actually played.

• 2 - the 3 notes coming out of the [+ ] objects, which are the note you played (in the hot inlet) summed to the last value you put into the right inlet (cold one).

• 3 - the 3 notes coming out of the [+ ] objects after the bang, which are the last value you put into the left inlet (the note you played) summed to the new value they received into the right inlet after [sel].

This is because you are using the note you played as a trigger for 3 different things, that are [noteout], [+ ]s and [mod 12]. You should avoid multiple connection when not needed and should be aware that every "number" you send acts both like a number and a bang. Also, be aware of the difference between cold and hot inlets, the first are just "memory", you put something in there and will remain there until the output is triggered, Usually this happens when something goes into the hot inlet, it may be a number, a symbol or a simple bang. Use the [trigger] object to force a bang into the hot inlet when you input something into the cold one.
I modified your patch and commented each solution, give it a look and everything will be clear

chorder-solution.pd

Did hope for a response to my convoluted query, at some point. But didn't even dare to dream for such an appropriate one. This is truly fantastic! Not only did you provide a working solution to my silly little issue, but you were able to patiently explain things and push me towards more learning. Without giving me any kind of grief or “attitude”. As a teacher, this touches me rather deeply. Sorry to go on about this but you actually just made my day!

As for the technical aspects.

You’re right about every count, of course. The hot/cold inlet distinction did appear on my radar but it hadn’t dawned on me that it might be among my mistakes (despite noticing the “memory” issue). In fact, had vaguely remembered something similar to what you describe in the math example, but didn’t follow that to its logical conclusion in the case of my MIDI notes.

Wasn’t aware of [trigger] (did see the [t b f] notation without knowing what it was). Makes a lot of sense, including the inclusion of an abbreviated bang. Since the extra notes are all triggering the addition, a bang isn’t needed in this case. (As you say, addition is commutative, which was my reason to use it instead of subtraction. Made things easier.)

Something which still isn’t so clear to me is why you used a [-12] object for the octave but a [-n( message for the other intervals. Get that the octave only takes one input and outputs directly to [noteout], but it’s not obvious to me what difference it might make.

But, overall, this was a thorough explanation of what was wrong in my patch and clear hints as to how to fully fix it.

Was able to complete the patch for major/minor/diminished triads. Then modified it to produce seventh chords.

chorder-7th.pd

Will try to generalise the patch and make it produce random chords within the scale. Sounds to me like your help was enough to get me “unstuck” and it might be possible for me to finish the project on my own.

Again, consider me indebted to you for your kind, thorough, and prompt help. If you ever need some help about ethnomusicology or anthropology, let me know!

-- Alex

Adapted the patch to work in harmonic minor mode and streamlined a bit by routing lists of intervals instead of connecting each wire individually.
harmo-chorder.pd

As there are only four types of seventh chords in the major mode, it does make things a bit clearer.
major-chorder.pd

Among my next steps is a generalization of the whole thing to work in different modes, and with different root notes. Not completely sure how to make that work but it should also help me in terms of randomizing chord selection.

Might also tweak voicings to fit a couple of concepts from classical harmony/counterpoint (avoiding parallel fifths, etc.). Eventually, it’d be great to choose a given voicing based on the preceding chord (for instance, the F in a G7 chord could resolve on the E in a C Major 7 chord). Should be doable, but will probably require more learning.

Something which should be relatively easy to tweak is to decrease the velocity of the inner voices, to emphasize the top part.

Another thing which will be quite fun is to produce sounds directly in Pd. Wavetable synth might be especially fitting for a wind controller. In that case, it should be easier to run it on a Raspberry Pi, without requiring an external synth. Would make for a very compact setup.

Been experiencing some issues with some scale notes not producing chords. In fact, Pd doesn’t show that incoming note, but it plays on my external synth. Probably an issue with my current MIDI setup (WX-11 wind controller hooked to a laptop which controls the iWavestation app on an iPad using MIDImux). In some ways, it makes for a bit more variety.

It’s a fun learning experience, so far. Been occasionally thinking about a project like this for some years, actually. But kept being too overwhelmed to take it on. Today’s experience really energized me.
Thanks, @shindeibrauns!!

(My major-chorder.pd patch in the previous post was the wrong one. Oops!)

Got the basic effect working. To an incoming note, the patch adds a parallel fifth and then two other notes with rotating offsets. So there are non-random but relatively unpredictable chords built around the incoming note. Cool! Makes for a really neat effect, especially with a bit of practice.

My main issue is sending note off messages. Tried different ways but since my thing cycles through, it “forgets” the previous note when it sends velocity zero.

“Solved” it with [makenote], which works well but is a bit different.

Will probably revisit this after learning more about Pd. Sounds like cyclone’s [flush] could help me. Or finding a way to “remember” the offset note.

In the meantime, will be able to play with this patch, using different patterns. Might try to reproduce it in Apple Mainstage’s JavaScript-based Scripter and/or in Sonic Pi (now that it can receive MIDI signals).

I've been working on a chord generator some weeks ago. As soon as I make the help file I'll publish it here in the "abstractions" section so check it out. Your feedback will be enough to pay me back

But still stuck on sending noteoff messages to a note after its number has changed. Maybe there’s something to do with a cold inlet, working as memory? Wait! Might have found part of the solution…

Followed the first two parts on the synth creation tutorial on Libre Music Production,

(The third and last part of the LMP tutorial has to do with filters and UI, so it shouldn’t have an answer to my noteoff issue.)

Through that tutorial, was able to make a simple polyphonic synth which takes MIDI in and outputs ADSR-enveloped notes to the DAC. So far, so good.

Added a fifth to the mix. Still works. No stuck note.

Then tried adding a third note which progressively goes up with a counter… Boom, noteoff problem again. It does make some sense: need to trigger a velocity of zero to the previous note, But this is where memory would come in handy.

Found part of a solution in using the right inlet of a [float] object,
libremusic-synth.pd

Now, the synth produces the correct effect, even with multiple incoming notes.

In fact, doing this with [poly] may bring us closer to the original effect created by Robby Kilgore on the Oberheim Xpander! Adding more polyphony than the notes which are produced internally, getting a rotation of notes… and a comeback of the noteoff problem.
libremusic-synth-rot.pd

So, getting closer, but my learning path is still winding around. Will search for known solutions, as it’s surely a common problem. Don’t necessarily want to go all the way to a minimal sequencer with [tabwrite] and [tabread], but it could be a solution and would have the added advantage of leaving a trace on which notes have been generated.

Will get it eventually!