Glad I found this one! Can be very valuable for a project I have in mind.
Long story short (for now): would you have insight on tweaking mscale so that it moves to a valid note instead of filtering it out?
Come to think of it… Based on your description, it might be a more specific issue having to do with my setup… I’m using a MIDI controller which sends legato notes. When I go from a valid note to one outside the scale, it just stops playing instead of moving up or down to a valid note.

I’m still very inexperienced with Pd so I’m having a difficult time understanding how the object does its magic. Which object does what? I’m outputting numbers everywhere to tell how things work. Really puzzled when it comes to the second [moses] object

It sounds like you’re splitting the incoming note’s “pitch class” (0–11) from the octave, you filter that using the list, and then you add back the octave to send out the note if it’s valid.
Is that right?

Now… how can I prevent the MIDI stream from cutting?

Been using the Pisound HAT for close to a year. Originally bought one (took a while to get to me), played with it for a while. Ordered a second one after realizing that it was a pretty important tool for me. (Paid for the fast shipping, second time around.)
One Pisound-based setup is focused on MODEP (MOD Emulation for Pisound). Used it on several occasions, including during a Drone Day jam recently. The other is more of a music-focused Raspbian install, with Sonic Pi as a key piece of the puzzle but some Pd patches here and there.

The Pisound has quite a bit going for it. Not the least expensive, and some might argue that other platforms can give you similar results for cheaper but… Blokas has done a great job to integrate things, hardware and software. Those knobs are quite convenient. Even the single button on it is quite useful. The community is small but healthy. And there’s a whole lot to be said about MODEP, given how “plug and play” it is. There aren’t that many LV2 plugins available, but it’s more than enough to have quite a bit of fun without having to set things up every time.
The “normal” Raspbian setup allows you to boot directly into a given Pd patch or switch them around using a USB key. Haven’t really played with that but that’s a pretty neat feature.

Now that MIDI Polyphonic Expression is part of the official spec (and that the documentation is available with a free membership in the MIDI Association), it might make sense to revisit this topic. Anyone has an update on ways to support full MPE?
Max7 already has decent support, especially for ROLI devices. One issue with Pd tends to be how to handle polyphony, so having a kind of tutorial might help.
Will check that rudimentary patch by @formuls. Sounds interesting.

It does sound nice, quite literally. The sound performance is very good and it greatly decreases latency. Which can really help with Pd on the Pi. The idea for “the button” is quite neat. Haven’t used a USB key to load patches but that’s also a neat idea.

Though Pd runs very smoothly on it, MODEP has become my favourite dimension of this HAT. It’s a way to host LV2 plugins and arrange them on pedalboards using patch cords (sounds familiar?). The interface (MOD UI) is through a web server. So you can use any device running a browser to change pedalboards. Tweakings knobs and such doesn’t work well on iOS, but it’s still really useful to run the device headless and have an iPad to change your “patches”.
Sure, it’s not the cheapest device around. Investing quite. bit of time, someone with soldering and coding skills can make a version of this with less money. Same thing can be said about the Organelle, the MOD Duo, etc.
But, as an integrated solution, Blokas pisound is really very neat.

Speaking of making a low-cost Organelle clone, anyone has insight?
Sounds like this project works with all the patches from the Critter & Guitari repo.
https://www.reddit.com/r/synthesizers/comments/5vlhfe/diy_critter_guitari_organelle/
There are some Pd externals on the C&G Github, but it sounds like they mostly use Pd Vanilla.

To me, the advantage of such a device is that the pre-made patches are supposed to just work. For instance, it sounds like their patches are polyphonic, which means less fiddling with poly.
From there, it could be easy to understand how the patches work. And the fact that Automatonism has some support can also prove useful.

So... Something like this could be particularly nice in teaching. Even if it’s on a breadboard with leads all tangled up.

Got a couple of Raspberry Pi boards with assorted sensors and actuators. Apart from a good audio HAT, it sounds like it wouldn’t take much to put one of these things together.

Thoughts?

@whale-av Thanks, David! Much easier to understand and it does work. Got the overall idea but not the actual patching.
Trying to focus on Vanilla without externals, in part to make it work on PdParty and/or MobMuPlat.
If it weren’t for that bug, oscparse would be fine for my needs (only UDP, not doing much with the messaging except getting the data into a slider).

Cheers!

--
Alex

@whale-av Hello David! Thanks for the reply. A bit confused about this, still.
So, here’s a message sent by TouchOSC:
list page4 multifader1 1 0.193394

My attempt at routing this…

         [oscparse]
|        [list trim]
|        [route page4]
|        [route multifader1]
|        [makefilename %d]
|        |
[route foo]

Getting the error:
makefilename: no method for '1'
Might have misunderstood the patching itself, though.
Here’s what it looks like in Pd.

Tried in 0.47.1, same issue.
Really strange, though. And it’s possible to change some addresses of OSC messages but routing by number can be particularly useful.

Ha!
Thanks for pointing this out! This issue was making me question things endlessly. Using Pd Vanilla 0.46.7 on macOS connected to TouchOSC. Using oscparse works well and route works as expected with symbols. But, in the Simple layout, TouchOSC begins most of its messages with page numbers so it was impossible for me to route them. Tried with another layout, which has sliders named without page numbers and it worked.
Phew!
Hope it’s been solved since then. (Thought my version was the latest and release notes since 0.46.7 don’t show anything about oscparse, but you never know.)

Played a bit with Automatonism. Really neat as an intro to Pd!
Did notice that Johan put several effects on there, including stuff like Bitcrush and Wavefold which affect the sound to make it dirtier. But it doesn’t really have one for overdrive/fuzz/distortion.
Maybe this will help?
https://guitarextended.wordpress.com/audio-effects-for-guitar-with-pure-data/
They do mention for the fuzz example that a more realistic one could be achieved with waveshaping (which is something Automatonism does do in some modules (at least in the Bandwidth limited oscillator). So, if you’re not getting the fuzz you want, you might find some answer there. But it’s probably a good idea to start mangling the sound with the existing “sound processors” modules. Don’t forget that you can send one into another for added complexity. Everything in Automatonism is at audio rate.
Sorry if this isn’t the straight answer you wanted. Surely, some Pd experts will have much better insight. Just wanted to chime in as it helps me in my own experimentations.
Oh, and this might be inspiring:

@WEIRD1 Just heard about Automatonism today and have yet to try it (afk at the moment). Surprised that there haven't been more posts about it here, already. Sounds like it'll bring several people to Pd.
Isn't there a module you could plug into the output of the drum sound generator? In his “synth recipes”, Johan demos some ways to radically change sounds. Did those help? Someone with more in-depth knowledge of Pd is likely to have an easy answer but one would expect Automatonism to have affordances for some of the main effects.

Didn’t do a good job explaining my issue. And sorry about forgetting the abstraction. Didn’t think about that.

My issue isn’t really related to the envelope, AFAIK. Had the same problem sending MIDI out (where the external synth dealt with the envelope). The idea is to have notes play as long as the key is pressed on a MIDI keyboard (or air is flowing through my wind controller). On key up (or breath stopping), some controllers send a velocity of 0 that Pd uses as “note off”. My intention is to finish the note when that happens. Works really well with [poly] when the voices remain the same. With or without the envelope. But my little rotating offset throws off [poly] and that’s when notes start hanging.

@whale-av Your idea of collecting incoming notes is pretty good but how is that done? Should it be [tabwrite] and [tabread]?

Thanks for the tutorial! It did help me gain further insight with [poly].

Still, there are situations in which it remains difficult to work with polyphonic MIDI. Especially when the notes change (at random or by calculations). Fairly easy to get “hanging notes” if [poly]’s voices get mixed up.

Here’s a patch which gets stuck notes with polyphonic input:
poly-hanging.pd

Poly does the right thing when it can keep track of the voices, but it doesn’t send the correct note off message if the voice has changed. Tried storing the note number in a [float] and banging it at note off. In that case, it does stop the note when the key is pressed again in the right order. But it’s still far from the desired outcome.

Eventually, this is part of a project to have rotating notes under an incoming melodic line (the “Michael Brecker Effect”). Funnily enough, it was based on polyphonic support by the Oberheim Xpander.

Been documenting my previous attempts elsewhere in the forums.

Any help would be appreciated!

Yet more progress!

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!

Ok! Getting somewhere.
voice-rotator.pd

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).

Haven’t gone back to my Pd (been experimenting with other things) but eventually got some technical details and the back story behind the “Michael Brecker Effect”. Turns out, those chords aren’t random but are made of notes which rotate. Makes more sense than purely random, especially in the context of the Oberheim Xpander.
The same musician who built those patches for Michael Brecker has since created a MIDI plugin version through Max and even some Arduino-based hardware.
Will try to reproduce his Max patch in Pd. Might eventually do a hardware version with Arduino or Raspberry Pi, but that might take longer.
Still useful to document all of this, just in case somebody else has similar ideas.

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

Made a bit of progress. Just in case it helps someone, here’s a few more details.

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!!

@shindeibrauns Wow. Just, wow. Thanks a ton! Owe you one.

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

Newbie alert! Been interested in Pd for quite a while, though long after hearing a lot about Max in college (ca. 1990). But my attempts to do anything in it were thwarted by many factors, including the lack of a clear plan. As is often the case, the most appropriate approach to learning a new language is to find a use for it.

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!