This came up because of one of the aggravating things about using arduino (and I can only assume other scenarios where signals are being sent continuously) is that when you switch 2 toggles, say going from 1-on/2-off to 1-off/2-on you pass thru the intermediate 1-off/2-off state which Will in fact send a signal and register a result.
It got me thinking about what the two toggles are doing: Changing states.
So if you break it down, there are 8 state changes for two buttons (which is exemplified in "abs_8-way_toggle-eventmodel_sv") with each change being its own state, exs. 0>1=1, 1>0=2, etc.
One nice thing about that, is if you do it that way you can "trap" the pesky multiple state scenarios by adding a timer, which is evidenced in the "abs_14-way_toggle-eventmodel" so that if the change is made fast enough (i.e. below the threshold) it sends only 1 signal for 0>1>3=8, 1>0>2=12, etc. While if done slowly, 0>1=1, 1>3=4.
Why I like this, is that it means for any two toggles, there actually 14 states of being not just 4.
Hope you can find a use for it.
I REALLY enjoyed thinking about this. And it bore much technical fruit/ideas besides just this patch as outgrowths from making it.
Peace and goodwill toward all,
I see that the 1.poly.synth generates random notes to send to the synth.
So I thought I would be able to find online a repo of text files, with only notes, written out as pitch/velocity/duration combinations.
But at first glance, I have not been able to find such a thing.
Is it available? Do-able in some other fashion (linux) by outputting midi files to a stream or some such?
Thanks. Would like to be able specifically to have my program "read" Ode to Joy in this fashion and then while it plays I manipulate its sound by adjusting the parameters on my patch.
Thanks. Hope that helps make it clearer.
Am thinking I could send either a text file of note value combinations to my app in order to "play" music.
see there is a midiparse object but not clear how to send it a file, .mid or otherwise.
An example patch of say opening a file and sending its contents to a synth, ex. 1.ploy.synth, or even just makenote would be great.
Thanks, in advance.
Peace, love and music flowing thru us all,
Gotta let this go, so I can do some other things tonight so will share what i currently have...
What I did was (and its way easier I think than using Gem) was write a (bash) shell script which reads a (linux-only I'm afraid) right-clicked file, i.e. a *.pd file, which you then send-to the script and it outputs a (plant)uml diagram of the objects within the patch.
Actually it outputs 3 flowcharts: native objects, subpatches, and abstractions.
I (currently) am only able to identify "natives" as what i scraped together from the Help folder so it's really quite bare and does not include all the aliases. (If you wanna have a go at amending that it is at: (when unzipped) "/root/pd-externals/pd2plantuml/res/objectlist.txt".)
On the other hand, it could be amended relatively easily to also include all externals and filter similiarly for them.
So if you unzip the file below in your ~/pd-externals folder and then point a right-click event to: pd2plantuml.sh you should then able to output the mindmap which opens in your "defaultbrowser".
Couple of caveats: plantuml has a lot of reserved characters and the current version does not account for all but one of them, "~", so it may balk on certain file(names) and complex files do take a moment or two to generate.
Good will and love thru us all.
Feedback welcome as this was a pretty fun and relatively stressless endeavor.
I could REALLY use this.
Doesn't seem like it would be to hard...then again, for me, very much so, as I I do not know GEM hardly at all.
But my thinking is:
to read all the subpatches and abstractions for a branch (either open via the usual open file method or already open). Then draw them with connecting lines as either either squares or circles with their name inside.
Already done? (then pls send link or share patch)
Sometimes am intellectually challenged attempting to visualize my own patch 😀
As I mentioned in a previous post: "idea: "riding the wave"delay length triggered by env~ size (link http://forum.pdpatchrepo.info/topic/10557/idea-riding-the-wave-delay-length-triggered-by-env-size)", I had been wondering about controlling a delay line via the env~.
My idea had been to mimic the "power" of a wave (akin to what I have been suspecting we will do once we figure out how to harness the power of gravity waves): the larger the amplitude > the further the auditory "ripple" and the longer it lasts.
The abstraction below, pushdelay~, is my incarnation of that idea.
Much merriment thru you and yours.
-help (from the -help comments):
In this pushdelay~ abstraction the length of time on the delay line, as well as feedback, are driven by the amount of the env~, the larger the env~ the longer the delay time and more feedback there is.;
In "inter" (interval) mode, the abstraction takes the current delay time and sets a metro to that time;
opens a spigot and captures the maximum value for the env~ during that period then sets the next delay and metro times to that value.;
In "cont" mode, it sets the delay and feedback times continuously based on the envelope value.;
The relationship between the delay(x) and feedback(y) values can be set using the curve ctrl, either linear, convex (sinusoidal) or concave (also sinusoidal but inverted).;
Turning the abs either off|on starts the inital metro.;
If in "off" mode, the delay ctrl may be moved independently. However the feedback will still change the same way, mentioned above.
p.s. the original delay~ abs is from the DIY2 collection.
Was thinking about internal combustion engines and gravity waves and got to wondering about alternatives.
Example (pd version-"riding the wave"):
The length of a [delay~] line triggered by how far above a threshold the [env~] is.
at a set time interval, normalize the difference between env~ and 100 then break it into integers (* x, +.0.5, int) and put a timer on it so when the env~ value changes the delay time changes accordingly.
p.s. food for thought, will share what I find out later.
hope all is well with you and yours. ciao for now
(David and Pierre: This is very close to what I had in mind when I asked about playing an incoming stream backwards. It does as you suggested David, work backwards from the jump off point, via a delay. However it then passes that delay to a sample looper and both feeds it back on itself and is able to be controlled by either playing the speed forward or backward (like you would rotate turntables, tapes, etc. Would love to hear what you guys think. Peace and thanks, for the input. -Scott
p.s. visually I have the image of a leaf floating down a stream gyrating/rotating as it goes, but almost always going "downstream". Oh, also, maybe you guys and tell me if the "phase*" is even germane to the patch? Oh, and I think this abs is ideal for the 2-d expression pedal I have mentioned elsewhere. Will share what results once I try it out.)
The delayfb effect is from DIY2 and the looper~ is from parts I can not remember the source of which.
From the Help file:
audioflow~ is an audio patch which does the follow.;
It takes an incoming signal and sends it to a delay~.;
It then sends the vd~ read signal to a looper as well as the delayed signal to the outlet.;
When record is pressed on the looper a sample record begins recording the vd~ read line.;
It also is then sent to out.;
The direction either forward or back of the loop is controlled by the "vector". So negative speeds are played in reverse and positive speeds are played forward.;
The pitch of the loop may also be controlled.;
Not sure if this is even necessary but a further multiplier(-1 to 1) may be applied to the loop.;
The info: positional bar is not a control and only shows the speed and direction of the loop.;
Each channel, raw, delay, and loop, may be mixed using the gain controls.;
And an overall gain control is at the bottom.;
Notes: after you stop recording the loop begins to play automatically. And you can merely tap record again and play stops automatically and a new loop recording is begun.
Curious about this...
tabwrite continuously writes data left to right for a breadth of x samples right?
and tabread reads them left to right too, right.
so is there a way to invert the stream so tabread continuously plays/reads the output backwards for the same breadth?
...scratching head, considering Dreamland, and wondering.
Thanks, for yr input in advance.
Peace bearing fruit thru us all,
Not quite as musical as you might think. Or perhaps, "Musical Feet". (Tho truly don't know the song to which you refer):
The 2-d flightstick, is actually a surface: a flightstick with the handle removed, the shaft cut down, and a board inserted (see below).
Has had me thinking tho...
Now that I have invested in buttons&knobs, an arduino, and a pi, the next thing I really need to buy is an orangutan or chimp to test this darn thing.
And thanks for your input. Always comes back when I most need it: timely.