Tags: posts polarity-music Bitwig Note-Grid Tutorial Beginners

Triggers, Sample and Hold, and Clock Quantizer Explained

Tutorial | Nov 06, 2023

In this video, I explain the concepts of device phase, triggers module, sample and hold, and clock quantizer in Bitwig Studio's grid. I demonstrate how the triggers module produces a binary signal and divides the device phase into equally spaced steps. I also showcase how the sample and hold module holds a signal's value until triggered, and how the clock quantizer synchronizes signals to a grid size, creating interesting rhythmic patterns.

You can watch the Video on Youtube - support me on Patreon

Questions & Answers

Maybe you dont watch the video, here are some important takeaways:

What modules are used in music production and how do they work in combination?

The modules used in music production include triggers, sample and hold, and clock quantizers. Triggers provide a binary signal for switching between on and off states, sample and hold holds a signal value as long as there is a trigger, and clock quantizers synchronize signals to a grid. These modules work together to create interesting patterns and rhythmic elements in music production.

How does the triggers module function in music production?

The triggers module takes the device phase, which can be divided into equally spaced steps, and uses it to create trigger events at specific intervals, such as quarter notes. The triggers module can be used to synchronize other modules and devices in the grid, allowing for precise timing and rhythmic control in music production.

What is the purpose of the sample and hold module in music production?

The sample and hold module is used to hold a signal value for as long as there is a trigger event. This is especially useful when working with notes or pitch values, as it ensures that the pitch remains consistent within a single note or gate event. The sample and hold module allows for precise control over the timing and duration of musical elements.

How does the clock quantizer module synchronize signals in music production?

The clock quantizer module delays trigger events until they align with a specific grid or clock signal. This allows for precise synchronization of rhythmic patterns and ensures that all events occur at the desired intervals. The clock quantizer is a powerful tool for creating complex rhythms and patterns in music production.


This is what im talking about in this video. The text is transcribed by AI, so it might not be perfect. If you find any mistakes, please let me know.
You can also click on the timestamps to jump to the right part of the video, which should be helpful.

[00:00:00] So this is a serious channel about music production and I want to take the opportunity of this video to answer a question
[00:00:06] I get a lot on this channel. So it goes like this
[00:00:09] Hey polarity, do you have a video where you go through the sample and hold?
[00:00:13] clock one ties
[00:00:15] triggers and other related modules like speaking to a child
[00:00:18] I find that that part is always really confusing when watching your tutorials don't really understand too well
[00:00:24] Why those modules are used in that order and what they actually do etc?
[00:00:29] I know I can watch separate module videos, but I don't really understand when they are used in the stack like that
[00:00:34] So it's more like about the combination of these modules and that's what I always tell people
[00:00:39] It's not really interesting to see these modules separated and explained separately
[00:00:45] You really want to know
[00:00:48] Basically how they work in combination
[00:00:51] So I want to use this video to explain that and it's not only important for using the grid
[00:00:57] Because we also have here a sample and hold as a modulator
[00:01:02] So we can also use this outside of the grid. So it's maybe not only interesting for
[00:01:06] grid usage and
[00:01:09] but it's
[00:01:11] It's easily or it's more easier explained
[00:01:14] Inside of grid in my opinion. So
[00:01:17] Let's hit stop and let's go to triggers
[00:01:21] Let's go to oscillator here or oscilloscope and watch what happens
[00:01:27] So the triggers module basically gives you a binary signal, which means the signal only
[00:01:33] switches between off or on states or zero and one
[00:01:37] Express in numbers
[00:01:40] When we use a readout here
[00:01:42] What is in the readout you can see we switch between zero and one all the time. It's a binary signal
[00:01:47] It's super simple and what this does here with the number four is basically divides the device phase into four equally steps
[00:01:55] So now the next question is probably what's what's the device phase, right?
[00:01:59] Vice phase is what you can choose on the left side here when you click on an empty space in the grid or you if you selected the
[00:02:06] Device in the chain itself and go to the inspector can see the vice phase. Here's the length exactly one bar
[00:02:12] Which means we divide one bar into four equally steps
[00:02:17] Which means this one gives you basically an on signal every time a quarter note happens. This makes sense
[00:02:24] So let's look at a device phase here by using a face in
[00:02:29] It looks like this
[00:02:32] It's proper signal. It's just a ramp signal going up if we put this here into the readout
[00:02:37] You can see it's just a number of load going up from zero to zero dot nine nine. It never reaches one
[00:02:43] It's the reason for that because you need to
[00:02:47] Express to sometimes in degrees and 360 degrees
[00:02:51] It's basically exactly like zero degrees, but I don't want to go into that
[00:02:54] But this is just a number going up. So with this number
[00:02:59] We always know that when this number is zero
[00:03:02] We are at the beginning of a bar and if this number is zero nine nine
[00:03:06] We are at the end of a bar and if this number is zero dot five
[00:03:09] We know exactly we're on the middle of a bar and this device phase is synchronized to your BPM and to your project
[00:03:17] so when we put this here into an separate window and we go here into the ranger and
[00:03:21] Maybe hit play
[00:03:23] You can see it three triggers here
[00:03:25] Because we hit play and we start at the beginning and the beginning is always the beginning of a bar of this arrangement
[00:03:31] Window here and which gives you always zero. So this is always zero
[00:03:36] This is zero dot nine nine then it starts over with zero and this is also zero dot nine nine and here in the middle
[00:03:42] We know at zero dot five. This is zero dot five, right?
[00:03:46] So we know exactly where we are inside of this transport by just looking at this device phase here and knowing
[00:03:54] What what kind of device phase length we are having chosen here or chosen here?
[00:03:59] So when we put this on two, I know exactly this is zero
[00:04:03] This is zero dot five and this is zero dot nine nine
[00:04:07] This makes sense because we have the device length of two bars. This is one bar. This is one bar
[00:04:14] so the ramp goes basically up from zero here up to
[00:04:17] Yeah, zero nine nine. Okay, we play we start here
[00:04:23] At the beginning we reset we start with zero if we go here to the middle, right?
[00:04:29] This is probably zero dot two five
[00:04:32] Hit play can see it restarts here
[00:04:35] If it's if it stopped you can see it still running
[00:04:39] We can control this also on the left side by using this checkbox free run when stopped we disable this
[00:04:45] You can see here basically device phase
[00:04:48] Just stays on one value at the moment here at zero dot zero one five
[00:04:53] We switch around you with the playhead. Let's say to this one here
[00:04:57] We go to zero dot five because this is exactly in the middle
[00:05:01] We have the device lay the device phase length of two bars and this is exactly in the middle
[00:05:05] So we are at zero dot five we choose here one
[00:05:09] Then we are at zero here. This is zero dot five as you can see here
[00:05:14] This is also zero dot five
[00:05:16] This is probably also zero
[00:05:20] Probably here at zero dots nine nine five. Okay, so we can use these numbers to determine where we are
[00:05:28] inside of the project
[00:05:30] kind of related on
[00:05:32] Yeah, relation to a bar
[00:05:35] And you can use the signal to synchronize modules inside of the grid in all kinds of different ways and
[00:05:41] Like I said the triggers module here uses an internal phase signal
[00:05:46] Use device phase to drive modules phase and this is in place just to make to make it easier for you
[00:05:54] So you can just use this and hook this up here and disable the pre-code
[00:05:59] So it's basically the same thing as just disabling or disconnecting this and use this
[00:06:03] It's just so you don't need an separate module
[00:06:06] But you can use a separate module because now with this you can hook up something in between here and can alter rate
[00:06:12] The signal in all kinds of different ways
[00:06:14] So let's say the phase signal is a ramp that goes up
[00:06:18] Let's use three run here again
[00:06:22] So it goes up again right from zero to zero dot nine and now we use here
[00:06:28] Let's say a band in here and then we
[00:06:31] Alter rate or change the device phase. It looks like this now. It's not really a ramp
[00:06:37] It's more like an arc and rounded ramp that goes up
[00:06:40] And when you look here at the numbers it goes fast at the beginning at the zero range and then it slows down at the end
[00:06:47] Exactly what we do basically with this band because fast here and then we slow down at the end
[00:06:55] So when you use this then for the triggers module here, you can see we play back fast at the beginning and then we slow down at the end
[00:07:03] and
[00:07:04] Then you use this trick us here. It still divides the device phase into four
[00:07:09] Not equally steps, but dependent on basically the space signal. You have a different outcome now. We trigger fast
[00:07:17] three times fast in the beginning and then you know the fourth is already
[00:07:21] Pretty slow and then it's never triggers again
[00:07:26] So we can alter basically how certain devices
[00:07:29] behave inside of grid when we just alter rate their face signal
[00:07:34] That's why we can switch off your basically the internal face signal and then can hook up here an external phase in and then use
[00:07:42] Something between to alter rate the signal. We can also use this here for let's say a
[00:07:48] Gates module it uses an internal phase signal
[00:07:53] And it just plays back here
[00:07:55] You can see pretty steadily and if you disable this it stops and if you use it to alter rate its signal
[00:08:00] It behaves exactly in the same way it plays back fast in the beginning and slowly at the end
[00:08:06] We can also do something like
[00:08:11] Reversed the signal you can reverse this here instead of bending it
[00:08:15] So now you can see it starts with
[00:08:19] 0.99 and then it goes down to zero so exactly the opposite way and
[00:08:23] Also, this device now behaves in the same way it plays backwards. It starts at the end and goes then
[00:08:30] You know to the first step
[00:08:32] And here you can also see the numbers going down from 0.99 down to zero
[00:08:39] So it's an interesting signal that it's used in all kinds of different modules inside of grid for instance
[00:08:45] Also the pictures module uses that
[00:08:48] This one here
[00:08:50] So you can use disable here the internal
[00:08:52] Playback or device phase then use the other rated one and now it plays also backwards
[00:08:58] And
[00:09:01] Because we use external signals here
[00:09:03] We can also say I want to play this, you know
[00:09:06] Exactly in this direction and I want to play with this in the opposite direction
[00:09:10] so you can change behaviors and playback behaviors and synchronization options inside of grid just by
[00:09:18] Alternating the phase signal and then using this all the rated phase signal for these devices that use this phase signal
[00:09:25] Like the triggers module here. Okay, so that's only to understand basically why the trigger module works
[00:09:32] How it works it just uses the device phase and then it sub divides this device phase into
[00:09:38] equally steps in this case here four steps you can also say
[00:09:42] 16 right 16 equally steps
[00:09:46] The device phase is exactly one ball long. So we divided one bar into 16 equally steps, which are just 16 nodes. Okay?
[00:09:55] Okay, this is how the triggers works now we have something like pitch like let's say
[00:10:02] Let's use a pitch value for instance, right this gives you a C
[00:10:09] C is exactly zero inside grid if you go up we go also up in number here and
[00:10:16] This also is just
[00:10:18] Float number inside of the grid. It's just you know a different format. It looks a bit different
[00:10:23] It works a bit differently, but it's just numbers basically
[00:10:26] Everything in the grid is just numbers most of the times between minus one and plus one
[00:10:31] so a4 is just plus
[00:10:34] 0.175 in numbers in the oscilloscope. It looks like this we can change here the pitch all the time
[00:10:41] Right we can move up and down
[00:10:45] And then we have maybe here a note on event right we want to trigger notes
[00:10:50] So let's say only four notes here for quarter notes and now we
[00:10:54] We change the pitch you can see we can change the pitch with within one on or off state
[00:11:03] So it's more like a band so when you have a note and play a note you usually want to stay that note on this pitch
[00:11:09] you don't want to
[00:11:12] Wobble around with the pitch right you won't don't want to change the pitch within one note on any note on event
[00:11:18] So we can use a sample and hold for that or I use it most of the times for that
[00:11:23] Because I don't want to change the pitch within one gate on if event or note on event
[00:11:31] I want to stay on this pitch for as long as the
[00:11:34] Event is high or the signal is high
[00:11:39] So we use a sample and hold for that looks like this and we put this on the signal
[00:11:44] We want to hold basic for as long as the trigger is one or high
[00:11:49] So now you can see here it samples basically the input of this
[00:11:53] Pitch module here and gives it out every time we trigger it. So every time we
[00:11:58] Go with the value of one into the sample and hold the sample and hold takes the value of this signal and
[00:12:06] Spits it out and holds it as long as this one spits out one. So now if I change here the pitch
[00:12:12] You can see we go up and down with the red line here
[00:12:16] but only
[00:12:18] When a trigger event occurs
[00:12:21] It's not like in between anymore. We take here. Let's say second one a
[00:12:28] Second oscilloscope and just take the raw input here
[00:12:34] Right, it looks completely different. Let's go to this this car
[00:12:38] So it's more or less like a stepped signal if you take this here to the second one
[00:12:45] Instead of this, you know
[00:12:50] Curve signal here we get basically a stepped signal but the sample and hold basically takes a signal and
[00:12:58] Samples it only when an event occurs here with a gate signal and holds it as long as the gate is high
[00:13:05] So simple as that. It's a very simple module all these modules inside the grid are very very simple and logical
[00:13:13] There's not much to it
[00:13:15] And you can combine them in all kinds of different ways. That's the interesting part about it
[00:13:21] So the big brother of the sample and hold is the clock quantizer
[00:13:27] It looks like this here and you can synchronize basically one signal to another signal
[00:13:33] So let's say we have here a second oscilloscope and we have a button
[00:13:39] and we can
[00:13:42] Push this button at any time at any point in time
[00:13:45] Right, and it's also just a binary signal. It's only off or on so zero or one and
[00:13:53] We want to synchronize this maybe to our project temple. So let's say you want to record exactly on the first bar
[00:14:00] you want to
[00:14:02] switch off certain devices exactly on a quarter note, right?
[00:14:06] We can do this with the clock quantizer. So we can say we want to quantize this button press here
[00:14:12] And you want to quantize it exactly to a quarter note because we have four nodes here, right?
[00:14:20] So now when we push the button here, so maybe let's say I'm using a tin you adjust to get a different color
[00:14:27] So let's say we push this button
[00:14:31] At any point in time this clock quantizer you're delay sit you can see this is where we push the button here and
[00:14:39] Yellow one is basically the output of the clock quantizer
[00:14:46] So the clock quantizer basically delays the on off switch until something happens on the clock signal this makes sense
[00:14:54] So it waits or samples the value basically and holds the value and delays it until something on the clock signal happens
[00:15:02] So it's kind of the big brother of the sample and hold in my opinion
[00:15:05] But not really because it also delays the signal
[00:15:10] So when you have here, maybe only two
[00:15:12] triggers each bar
[00:15:16] So it waits and then it also takes here basically the the next
[00:15:21] on state
[00:15:23] switch to the on state as
[00:15:25] switching it back off kind of
[00:15:28] So we can basically push the button here at any point in time
[00:15:34] but the clock quantizer make sure that it everything happens basically
[00:15:39] exactly on the grid or in synchronization with the
[00:15:44] Clock signal so this is how it works. So instead of using a button you can also use of course a different triggers module, right?
[00:15:53] and this triggers module has some
[00:15:56] Let's say some odd numbers here, maybe five
[00:16:00] Five divisions of a bar versus let's say eight divisions of a bar
[00:16:05] So on here some sometimes
[00:16:10] Something happens in between these triggers, right? So we can use a clock quantizer for that
[00:16:15] This is our clock and this is our signal here
[00:16:18] So we clock quantize basically these odd numbers here to these equally lump numbers and you can see here
[00:16:24] there's some
[00:16:26] strange stuff happening so the red ones is basically our
[00:16:30] five odd number trigger
[00:16:33] Sequence here and then the yellow one is the
[00:16:37] Synchronized version or the synchronized to our clock signal version here
[00:16:40] And it gives you kind of an interesting pattern something like that
[00:16:46] And you can maybe already imagine that if you use this kind of combination for some percussion sounds or some
[00:16:54] Rhythmic elements, it's yeah, it makes a great fit. That's why I'm using this your most of the times for
[00:17:02] These generative patches because you can create interesting patterns here and then you can modulate maybe to trigger value here
[00:17:09] But this clock quantizer basically makes
[00:17:12] Makes sure that everything is synchronized to a certain grid size and most of the times I go to 16 and old grid 16 nodes
[00:17:21] Then you can choose here some odd numbers and then you know, you get an interesting pattern out of this
[00:17:26] So yeah, this is basically the clock quantizer
[00:17:31] Also very simple module actually
[00:17:34] Sometimes it's hard to explain
[00:17:36] But if you see the practical examples of that, you can see how powerful this is in combination with other modules
[00:17:43] Okay, so this is how the device face the triggers module sample and hold and the clock quantizer works inside of the grid of
[00:17:51] Bitwig studio if you still have questions, then please let me know I do these videos all day
[00:17:56] And that's it for this video. Thanks for watching. Leave a like
[00:18:01] If you liked the video and subscribe to the channel. See you in the next one. Bye
[00:18:05] Bye.
[00:18:06] [BLANK_AUDIO]