zexy's [oreceive] is also a dynamic receive. Always worth trying stuff yourself though!

That's rather ambitious indeed. I don't believe you'll be able to display the actual patch. Even if you want to only display knobs and other widgets, you'll have to code this interface yourself and control Pd, or have Pd control those, by sending values for these widgets via OSC.
If I understand what you describe, you want to create a graphical user interface to control a Pd patch, right? If this is so, then what I wrote about holds.
You could try to find some library (it would probably be Python or C++) that creates widgets for OLED displays, and use that together with OSC, but the API you'll use should support OSC communication.

A 200ms is probably a bit too long for what you need. 20ms should be OK for avoiding clicks.
For what you want to do, you probably need two buttons, one for starting and one for early stopping. The second one should first bang a "1, 0 20" message sent to a [line~], then bang a [del 20] object, to delay this bang by 20ms, and the [del 20] should bang a [t b b b] (use as many "b" here as you need) to restart the whole process of playing back a file (including banging the "0, 1 200" message).

@jyg it hasn't been digitally signed, so I guess that's why you get this error. Can't the object be installed with this error? Otherwise you can get the source and compile yourself https://github.com/alexdrymonitis/neuralnet

It's just an Multi-Layer Perceptron (MLP) - a dense feed-forward neural network. Each neuron sends its output to all neurons in the next layer. Each neuron in the next layer multiplies its of its inputs by a weight. The weighted inputs are summed and added to a bias value, then passed through the activation function of the layer (e.g. a sigmoid function to ensure everything remains between 0 and 1 and don't go to +/- infinity) and passed to all the neurons in the layer after that.
It's all in the C code. If you want to learn more about this though (in case you don't know), I recommend the "Neural Networks from Scratch in Python" book, which is where I initially translated Python code to C to create this object.

[neuralnet] does no FFT. You'll have to do all the FFT and IFFT after you get output from [neuralnet]. This object only enables you to create neural networks. What sort of data you'll use and how you'll prepare it is totally up to you.
From what I understand from your post, you should probably store your FFT spectra, and classify them according to the amplitude you mention. Then feed them together with the classes you have created to [neuralnet]. Does this make any sense?

If you are talking about evolution, then it's likely you need something like a recursive neural network (RNN), which [neuralnet] can't create (at least not yet). Unless this evolution you mention can be encapsulated in one snapshot. If it's spectral snapshots with a 256 bin resolution, and you need four of these snapshots to classify your data, then a network with 1024 inputs could worh with [neuralnet].
The MNIST dataset example (example 4) is a classification example. You should follow that to build your network structure (concerning activation functions, loss function, etc.).
With the current versino of the object you can also build autoencoders, which can be sort of good for compressing data. That being said, you could perhaps use an autoencoder and map the values in the latent space. The next version will hopefully include variational autoencoders (working on this), so that could also be an option.
As I don't know the structure of your data though, I don't think I can be of more help right now.

You can also try [neuralnet] which is built for creating (deep) neural networks.

How are you trying to open the port with [comport]? Did you send the "devices" message to it to see the available ports and their indexes in Pd's console?

Which libraries are these? Perhaps you need to first use [declare -lib libname] before trying to create one of its objects. This concerns single binary file libraries like zexy or Gem.

Since you're using the else library you can use [else/envgen~] combined with the function object. Check its help patch and the [pd function] subpatch that's in there.

@gentleclockdivider your approach is totally against netiquette, if you ever read any etiquette rules. Posting the same question to multiple channels just because you need an answer fast is just bad practice for a community member. @porres might sound a bit aggressive, but I do agree with him, and I guess you don't agree with me, still, basic netiquette is necessary in community fora. Also, @porres did not imply he is in any position of authority. He's just recommending a better community behaviour in Pd's channels.

@oid you're write about making all ramps go from 0 to 1, apply curvature, and then scale and offset to bring them to the desired range. I've done that too in a project of mine, but it's quite some more work. As you write, the approach above is probably good for most applications. I did this as a reply to @ddw_music's post.

@porres the Bela has only libPd and not an actual Pd installation. I agree that it's very outdated and an easier way to update Pd in the Bela is needed, but for now that's what we get.

@ddw_music I thought about it and it turns out that just squaring is not enough, even if you store the square root of the sustaing value. If you just square, the curve of the attack will be inversed (it will be exponential instead of logarithmic). You need some more logic to inverse the power you raise the amplitude to, depending on the direction of your signal. Here's a snapshot of my take.

[adsr] is an abstraction I have built. It stores the square root of the sustain value. What's important here is the logic underneath [vline~]. Here I'm using zexy's [z~ 1] to get the previous sample and compare it to the current one. If the current sample is smaller or equal to the previous one (the decay, sustain and release parts), then the envelope is raised to the 2nd power, otherwise, it is raised to 0.5.
This way, you can get the correct curvatures.

@ddw_music unless, you do square it, but set the sustain value through a [sqrt] first, so when squared, it gets to the correct value!

Check out this https://github.com/alexdrymonitis/filter_abstractions
both [omniFilter_abs~] and [multiFilter_abs~] can create a resonant lowpass filter. Getting note on and note off messages in Pd can be done with the [notein] object. Just create one and right-click on it, then click on help in the pop-up menu.
As for [mtof~], you're right, you need that to convert MIDI notes to frequencies. There's also a control-rate version, [mtof], without the tilde.

@ddw_music you can't really square the value in case it's a volume envelope, because that will square the sustain value as well, and that will reduce the actual value. I understand that squaring will create curves, but you need a more complex logic to get the curves but maintain the sustain value.

You need [text get]. Check [text]'s help patch, everything you need is there.

Gem is a one binary file library. You hane to import the lib before trying to create an object from it.
Try putting a [declare -path /path/to/Gem -lib Gem] object in your patch.