Audulus Fundamentals: Signal Type Values & Resolution/Rate

[espiegel123]

So no oversampling?

[biminiroad]

Not internal oversampling - if you want 192k sound, you’ll have to run the whole patch at 192k.

[ambian]

@biminiroad

Depends on your computer and its interface. The plugin also will run at your hosts’ sample rate, so you can set it in Ableton Live for example.

Got it. I’m familiar with the Audio MIDI Setup in Mac OS. You can see what I get in mine below (without plugging in an external interface).

So I could run Audulus at 96kHZ (on my laptop) if I’m okay with the CPU trade off?

@biminiroad

A unit delay forces Audulus to process things one sample at a time instead of in batches of ~300 samples. If you just have audio moving from one effect to another, processing in batches is fine. But there are some cases when you want Audulus to run in single-sample processing.

Unit Delay Examples.audulus (64.7 KB)

You might be getting confused with batches vs. single sample - every sample is still processed when being processed as batches - it’s not every 300th sample that is processed - It’s just not outputted one sample at a time unless you explicitly tell it to using a Unit Delay node.

I understood what you mean with the batches. I also glanced at the Uni Delay Examples (thanks for providing them!). I will have to return to looking at the z-1 Unite Delay node, when I am slightly deeper in the Audulus game.

@biminiroad

The only exception I can think of is this one, and it’s documented in the manual.

Awesome. Thanks!

@biminiroad

No - for example, an envelope won’t retrigger unless the gate resets to 0. It just rises to the height of the gate. If you stick a sine wave input to an envelope it won’t trigger because that the infinitesimally small moment in time where the sine wave touches 0 is unreadable at 44.1k sample rate.

So for all other purposes except when entering an envelope, a gate is always 0 or 1.

Envelope Examples.audulus (31.5 KB)

In summary: modulation signal coming from sine, triangle, saw waves hits the 0 point too quickly to trigger the reset? Does this mean I should only send modulation signal into envelope as a square wave output?

Btw, I understand what you meant about the gate height [less than 1 results in smaller amplitude] from your example. Thanks for showing it to me!

@biminiroad

But you have the option to do that when it’s necessary, and Audulus will algorithmically figure out which parts of your patch need to run at single sample and which can run in frames.

You mean that I trigger the single sample rate by using z-1 node? Then Audulus determines which part will be processed one sample at a time and the rest it does in frames? I understand this in theory. But I’ll have to revisit the z-1 node examples patch again when I know more of A to understand it in practice.

[RudigerMeyer]

That’s a pity

[ambian]

Btw I think that having an educational onboarding patch which explains + shows examples of the 4 different [expected] signal types in use will be incredibly beneficial to first time users. It would be the first thing I would like to see.

I might make it myself as my contribution to the onboarding part of the project :), but I’m also a bit slow rn… someone else could probably make it x10 faster than me… In any case if anyone volunteers to do this, I will work with them to make sure it has all the detail that would be helpful to a first time user wondering about these things.

P.S. A large chunk of my current “day job” consists of improving the usability of applications.

[stschoen]

You might find this useful:
https://discourse.audulus.com/t/the-audulus-expression-node/1496?u=stschoen

[espiegel123]

FWIW, if one doesn’t exist already, a ‘tutorial’ patch that summarizes (with simple examples) best practices for rounding, re-scaling (such as rescaling and stepping knobs) would probably be useful to a lot of people.

[biminiroad]

@ambian

In summary: modulation signal coming from sine, triangle, saw waves hits the 0 point too quickly to trigger the reset? Does this mean I should only send modulation signal into envelope as a square wave output?

You should use clock signals or other gate signals for envelope gate inputs. To modulate the parameters of the envelope, you can use whatever modulation signal you want.

Triangle, Saw, and Sine waves only hit 0 for an infinitesimally small period during their periods. Square hits 0 for longer, and that was just an illustration of it. In general it makes more sense to use a clock (which is basically a square LFO) to trigger envelopes.

@ambian

You mean that I trigger the single sample rate by using z-1 node? Then Audulus determines which part will be processed one sample at a time and the rest it does in frames? I understand this in theory.

Yes, but it’s only necessary when to get the result you want you need it to process like that. If something doesn’t work the way you expect it to, then z-1 might help, but if you don’t know what you’re doing, we can always help here on the forum. In general, when working at the level of modules, you won’t need it.

[biminiroad]

Yeah maybe at some point Taylor will reconsider, but he says it’s a really tough undertaking that would require a lot of time to figure out.

[biminiroad]

That would be great! We’re always looking for more user-created tutorials. Each example of the new modules in the library comes with 2-4 examples as well, so that should help.

https://discourse.audulus.com/t/audulus-3-library-reface/1455/180

If you go to that post and download the examples, they go along with the modules I’ve documented there.

@espiegel123

FWIW, if one doesn’t exist already, a ‘tutorial’ patch that summarizes (with simple examples) best practices for rounding, re-scaling (such as rescaling and stepping knobs) would probably be useful to a lot of people.

Rounding is easy:

Rounding.audulus (4.1 KB)

Rescaling is also easy - multiply by the range you want the knob to cover, and add whatever offset you want. If you want something that is -4 to 4, you multiply the knob by 8 and “add” -4.

“Stepping” would just be rounding the output of the knob into whatever range you want it to cover.

[stschoen]

The expression I use when I want a range of integer values from a knob is floor(k*maximum + 0.5) where maximum is the highest integer value I want. The 0.5 offsets the knob so the the maximum occurs before the knob reaches the very end. So floor(k*8+0.5) will give you a range of 0 - 8. If you need a range starting from a different value just add the offset at the end, floor(k*7+0.5)+1 gives you a 1 - 8 range.

[robertsyrett]

Yeah a scaling tutorial could be useful.

[espiegel123]

@biminiroad: i am pretty conversant in the scaling/rounding stuff. So, I am not mentioning this so much for myself as I know some folks that are daunted by even these seemingly simple things.

Rounding is an interesting thing in that in some situations, it isn’t obvious (unless you have done this a lot or are kinda mathy) when it is useful to floor it or ceiling it.

With some knob types (I use them as integer selectors instead of counters because that it is the only way to have the values persist between launches), for instance, I’ve recently realized that I should scale to a larger range than I want and then clamp the knob output to make it less annoying to get the value you want. So, if I want a knob to select 1 through 5, it can be useful to scale the knob’s output for 0 through 6 and then clamp that to 1 through 5 – as it allows you to get 1 and 5 without turning the knob to its extreme.

[ambian]

@biminiroad

Triangle, Saw, and Sine waves only hit 0 for an infinitesimally small period during their periods. Square hits 0 for longer, and that was just an illustration of it. In general it makes more sense to use a clock (which is basically a square LFO) to trigger envelopes.

This is clear. What is the easiest way to debug/measure the clock rate/bpm? My question is: if I have a signal alternating between 0 and 1, what is the easiest way for me to measure how many times it goes between 0 and 1 per minute? Also, is the full cycle (1 then 0) considered one beat or the half is (0 is a beat and 1 is a 2nd beat)?

@biminiroad

Yes, but it’s only necessary when to get the result you want you need it to process like that. If something doesn’t work the way you expect it to, then z-1 might help, but if you don’t know what you’re doing, we can always help here on the forum. In general, when working at the level of modules, you won’t need it.

Got it. Thanks!

@biminiroad

That would be great! We’re always looking for more user-created tutorials. Each example of the new modules in the library comes with 2-4 examples as well, so that should help.

I think I will make this tutorial for myself [as a kind of simplistic reminder/debugger for when I’m way deep and need a simple reference point] and post it here, so others can improve it.

I downloaded the examples that go with the docs. I will start going through some of them today.

[ambian]

ah also @biminiroad so it’s okay for me to run Audulus at 96kHZ on my Mac (as long as I’m okay with the CPU trade off)?

what about the “16-bit Integer” vs “24-bit Integer” vs “32-bit Float” (see screenshot above) << Audulus will work with any of them or… ?

[biminiroad]

@ambian

ah also @biminiroad so it’s okay for me to run Audulus at 96kHZ on my Mac (as long as I’m okay with the CPU trade off)?

Yep!

@ambian

what about the “16-bit Integer” vs “24-bit Integer” vs “32-bit Float” (see screenshot above) << Audulus will work with any of them or… ?

It should work with all of them. Audulus uses 32 bit float internally.

[biminiroad]

@ambian

This is clear. What is the easiest way to debug/measure the clock rate/bpm? My question is: if I have a signal alternating between 0 and 1, what is the easiest way for me to measure how many times it goes between 0 and 1 per minute? Also, is the full cycle (1 then 0) considered one beat or the half is (0 is a beat and 1 is a 2nd beat)?

BPM is beats per minute, and clocks operate at Hz speeds, so 1Hz = 1 beat per second = 60 beats per minute.

A beat is one full on/off cycle.

You can see a lot of translation modules under the building section:

[biminiroad]

@espiegel123

Rounding is an interesting thing in that in some situations, it isn’t obvious (unless you have done this a lot or are kinda mathy) when it is useful to floor it or ceiling it.

@stschoen showed me recently that you really only have to use floor(x) - check out the example I posted above.

As for building stuff in general and tutorials like this, I plan on making a building manual for Audulus after I get the module library done that illustrates common questions like this

[biminiroad]

@espiegel123

So, if I want a knob to select 1 through 5, it can be useful to scale the knob’s output for 0 through 6 and then clamp that to 1 through 5 – as it allows you to get 1 and 5 without turning the knob to its extreme.

The problem with that is if the knob is turned all the way down, you get 0 - 5 (that is, if it’s a problem for your application). The easiest way to do what you’re describing is do floor(x*range+0.999) - so in your case, floor(x*4+0.999)+1 to get 1-5.

If you want to dial in something with a large number of digits accurately, like 0-999, it helps to split up each place into a separate knob and combine them together (so dial in 100s, then 10s, then 1s, and those 3 numbers get summed together for final number).

[ambian]

Awesome. Thanks!