Tags: posts bitwig-guides Bitwig Grid-Module Tutorial

Bitwig Logic Modules - Practical Uses for Logic Operators in Modular Patching

Bitwig Guide | Aug 25, 2022

This video explains the logic modules in Bitwig Studio's Grid, focusing on their basic binary operations and how they can be creatively used in signal processing, sequencing, and audio manipulation. The presenter demonstrates essential modules like buttons, triggers, gate repeat, comparators, and logic gates, highlighting that their power comes from flexible combinations within patches rather than complexity. Practical examples show that while each module is simple on its own, their true potential shines in creative setups, enabling unique and unexpected results.

You can watch the Video on Youtube

Short Overview

In this video, I explore the logic modules in Bitwig Studio's Grid, explaining how they work and the different ways you can use them. I break down basic modules like buttons, triggers, and comparators, showing how they operate and how you can combine them for creative results. While some modules seem simple at first glance, their real power comes from using them in various contexts to achieve unique effects or functions in your patches. I also demonstrate practical examples, like generating square waves or switching between audio signals, to show just how versatile these basic building blocks can be.

Introduction

In this video, I explore the logic operators or modules in Bitwig Studio's Grid and discuss their functions, possible uses, and flexibility within modular music creation. I address a common request from viewers who ask for individual videos on each Grid module, explaining that while many Grid modules are simple enough to describe in a sentence, the real value comes from understanding the creative possibilities they unlock. My goal in this video is to demonstrate what you can do with the logic modules, show how they work, and highlight their potential for various use cases.

Basic Logic Modules: Buttons and Triggers

The simplest logic module is the button. It essentially outputs either a value of zero or plus one, no values in between. This binary approach makes these modules ideal for on/off, or true/false operations.

The Trigger Module

The trigger module is similar to the button but outputs only a short burst of the value one. Regardless of how long you hold the trigger, it stays at one only briefly. You can change the duration of this burst by using a gate length module.

The Gate Length Module

The gate length module allows you to control how long the trigger output remains at one. For example, you can set it to 100 milliseconds or reduce it further to 30 milliseconds to suit your needs. When combined with other logic modules, this becomes a utility tool to shape triggers and gates.

Repetition and Signal Conversion

Gate Repeat Module

By combining a button with a gate repeat module, you can create a repeating +1 output signal at intervals you define (like every 50 milliseconds), which looks and sounds like a square wave when sent to speakers.

Unipolar to Bipolar Conversion

Out-of-the-box, this setup produces a unipolar signal (zero to +1), but speakers need a full swing from -1 to +1. Using a unidobuy module, you convert the unipolar signal to bipolar, transforming it into a true square wave.

Audio and Logic Modularity

Bitwig’s Grid lets you mix audio and logic modules creatively. For example, you can use a logic gate for audio amplitude shaping (as with pulse waves in synthesizers), highlighting the flexibility and adaptability of these modules across signal types.

Time and Clock Modules

Clock Divide

The clock divide module splits a master clock signal into slower subdivisions. When the main clock signal completes a set cycle (say, eight steps), the module outputs a burst. There is also a reset function to restart counting at zero using an external trigger.

Clock Quantize

The clock quantize module ensures trigger signals line up perfectly with a reference clock. This is useful in musical contexts like synchronizing the start of a new sequencer pattern so it always begins on the beat, preventing off-grid timing slips.

Latching, Toggling, and State Handling

Sledge Module

The sledge module offers set, reset, and toggle functions. Triggering the bottom jack sets the output to one and keeps it there until the top jack is triggered, which resets it to zero. The middle jack toggles the current state. This is handy for managing toggling behaviors, even though it's often used as a utility in larger patches.

Comparator Modules

Some modules are designed to work with audio signals and function as comparators. Their red input jacks indicate they're best suited for audio rather than just logic signals.

These can be used for logic operations on audio signals, such as creating logic pulses whenever two LFOs (low-frequency oscillators) cross each other.

Classic Logic Gates

Truth tables are available for each to clarify their logical behavior.

Combining Modules for Creative Effects

These modules can be combined in infinite ways. For example, by connecting a sine wave and a sawtooth wave to two inputs of a comparator and then using the output to control a select module, you can create complex, hybrid waveforms by toggling rapidly between the two wave shapes based on their relative amplitudes.

Conclusion: Practical Use and Flexibility

While each Grid module may seem straightforward, their real power comes from creative combinations in context. I haven’t provided extensive real-world examples in this video, but as I create more instruments and patches in Bitwig Studio's Grid, I’ll give more detailed walkthroughs of how and why I use specific modules. For now, understanding these basics will help you unlock their full creative potential.

Final Thoughts

Thanks for watching. If you have questions or want more in-depth tutorials about specific modules, let me know. I aim to return with more advanced walkthroughs once I have practical use cases to share. Remember, while some Grid modules are simple in concept, the ways you use them are countless and can lead to highly sophisticated musical outcomes.

Full Video Transcription

This is what im talking about in this video. The text is transcribed by Whisper, 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.

Click to expand Transcription

[00:00:00] Hey, welcome back to another video.
[00:00:07] Today I want to talk about the logic operators or modules in Petvix Studio and in the grid.
[00:00:15] And I saw a lot of comments on Facebook and YouTube and someone on Patreon wrote me if
[00:00:22] I can do a video or a video for each module in the grid and I said most of the modules
[00:00:28] in the grid are basically pretty simple.
[00:00:31] You can describe that in a sentence.
[00:00:33] But what people want to know is what can you do with it.
[00:00:39] In this video I want to try out and try to explain what you can do with the logic modules
[00:00:47] and how they work.
[00:00:50] And if you have this button here, it's basically the simplest possible logic module you can
[00:00:58] have and it shows exactly what it's all about in these logic modules.
[00:01:03] It's about having a zero value or a plus one value, zero plus one.
[00:01:12] That's basically all about this.
[00:01:14] All these modules here are working in this type of value range.
[00:01:19] There's no in between and yeah, it's all about turning something on or off, so binary if you
[00:01:26] will.
[00:01:27] So the next module we have is this trigger module here and it does basically the same
[00:01:33] as the button where you can turn the value to one and zero at will.
[00:01:41] With this trigger module here, you have basically a short burst of value of one.
[00:01:46] So if you push this, you can see and if you try to hold it, it still raises only a short
[00:01:54] burst amount of time of the value of one.
[00:01:58] And when you use the skate length here and combine it with the trigger signal, you can
[00:02:04] change how long this burst is.
[00:02:09] Now we have 100 milliseconds here.
[00:02:15] So this is basically the function of the skate length module.
[00:02:22] And when we go back to our button here where we can choose to have value one as long as
[00:02:29] possible or as long as we want and then we go back to zero when we want, we can use this
[00:02:36] skate length here and turn this to a trigger.
[00:02:40] So we use a short amount of time, 30 milliseconds here and then it goes back to zero.
[00:02:49] So if I press this button, it goes on the value and then after 30 milliseconds it goes
[00:02:55] back to zero.
[00:02:59] That's all you can do with this skate length module, but when you combine it in the right
[00:03:05] order or in the right place in your patch, then you can do much more with it, of course.
[00:03:12] So it's more of a utility if you so want.
[00:03:16] So let's remove the wires here and let's use the skate repeat.
[00:03:23] Use it with a button and now we can choose to repeat our input signal, which is +1 and
[00:03:31] repeat it every 50 milliseconds and looks like this.
[00:03:37] You can change the length and it almost looks like a square wave and you can use this to
[00:03:51] output sound or you can basically forward directly to your audio out and I use an attenuate
[00:04:01] here to change the volume of it and let's hear.
[00:04:10] So it sounds like a square wave, but as you can see, we go from zero to +1, but if you
[00:04:20] send this to your speakers, your membrane of your speaker goes basically from the middle
[00:04:25] position to the outward position, so +1, but we need to go the full range.
[00:04:31] So swing it back in and back out.
[00:04:35] So we have to convert this signal, this unipolar signal to a bipolar signal and you can do
[00:04:43] this easily when you go to level here and use this unidobuy module.
[00:04:52] As you can see, now we have the full range and now we have a real square wave.
[00:05:04] So this is basically a conversion you have to do and you can convert of course back if
[00:05:11] you want or just remove all both of them.
[00:05:15] So now we used a logic signal as an audio output and this tells you that in the grid
[00:05:25] you can combine different type of signals and it doesn't matter.
[00:05:31] So for instance we generated our logic signal here with the button, but you can also go
[00:05:45] to oscillators here and use poles, remove this repeat here and use this or completely
[00:06:03] change the square wave of this oscillator with our logic here and use the gate length.
[00:06:14] So we use an audio input for a logic module and we get something different out and then
[00:06:23] we need to convert it of course to unipolar signal.
[00:06:43] So now this logic gate length module which is intended for logic values is used for audio
[00:06:52] amplitudes and with the gate length we can now do something like a pulse wave like you
[00:07:00] do on synthesizers.
[00:07:03] So this is now not a logic module anymore.
[00:07:09] So this is why it's hard to describe what you can do with most of the modules because
[00:07:13] you can use them in different circumstances and different contexts and it gives you so
[00:07:19] much different results and there's not only one single purpose for a module.
[00:07:26] So let's remove that and just stick to the logic category here and let's see what we
[00:07:33] have now.
[00:07:35] Let's remove this trigger and this button too and go to the clock divide.
[00:07:40] So and now for the clock divide we use again a button and the gate repeats so we have an
[00:07:49] ongoing signal and let's change the color and it's not possible.
[00:08:01] So let's go in the clock divide here and you can see we have now this number running and
[00:08:06] every time this number passes this bottom number here it goes back to zero and if you
[00:08:12] use a button and trigger this jack below you can reset.
[00:08:23] So as you can see it goes up to eight and then or seven and then goes back to zero again
[00:08:30] but when we push this button before it goes to zero again we can reset it to zero or actually
[00:08:38] use a trigger yes better.
[00:08:41] So every time I press this it resets to zero and the output is only one burst of the value
[00:08:51] of one when you reach the maximum number which is eight.
[00:09:06] So you can divide your signal into sub signals.
[00:09:14] So let's use maybe some kind of different moduli in between so we have a different color.
[00:09:26] So this is our the red is our original signal and the clock divide divides this signal into
[00:09:32] different sub signals and you can choose how much and when this happens.
[00:09:55] It's actually used to I think it's better to see.
[00:10:01] So the red one is our original signal generated by the gate repeat and then the clock divide
[00:10:07] is basically dividing this into a sub grid.
[00:10:23] So back to the logic and let's use the clock quantize here and the clock quantize is useful
[00:10:31] when you have a trigger signal and you want this trigger signal to start exactly on a
[00:10:39] specific point in time.
[00:10:42] So let's use I have to look at so we have to clock in at the bottom.
[00:10:52] So let's use this here and let's use this.
[00:11:00] So we have we see exactly what's happening and we have a trigger signal going into the
[00:11:07] top and now when I press this button here I use another one when I press this trigger
[00:11:20] button here you can see that it's different here than here.
[00:11:30] You can see it's basically synchronizes with our original gate repeat signal.
[00:11:38] Let's remove the clock divide so we see this better.
[00:11:45] So this is basically our grid and if I push this button here it waits until our clock
[00:11:53] signal synchronizes.
[00:12:05] This is basically useful when you are here in our sequencer and you start a sequence
[00:12:14] and this waits until a bar is over and then start exactly at the first beat so it's kind
[00:12:20] of that kind of thing.
[00:12:25] So with the clock quantize you can quantize a signal to an clock signal and you go with
[00:12:32] the clock signal in the bottom jack and your trigger signal goes in the top jack.
[00:12:44] Okay let's remove this.
[00:12:49] Now we have our gate repeat, gate length, clock quantize, clock divide, okay these and
[00:12:57] button and trigger these one we explained already.
[00:13:00] Now we have the sledge module here and this is easy to explain.
[00:13:09] Let's go in the bottom jack first.
[00:13:12] So when you trigger the bottom jack with the signal the output signal goes to one as you
[00:13:18] can see here and it stays at one.
[00:13:24] To bring it back to zero you have to use the top input to set it to zero as you can see
[00:13:32] here.
[00:13:34] So pretty easy right?
[00:13:36] The middle jack is basically a toggle where you can toggle the current state to the opposite
[00:13:43] one.
[00:13:44] At the moment we are at zero and we trigger this we go to one and now when we are at one
[00:13:50] we trigger this again we go back to zero.
[00:13:53] So it's basically a toggle.
[00:14:01] Also for itself it's not very useful but when you have a big patch and you need some kind
[00:14:09] of this logic somewhere then it's pretty useful.
[00:14:13] So this is also why it's hard to make tutorials about these modules because there are so many
[00:14:18] possibilities and outcomes and you can't explain every one of them.
[00:14:26] So let's remove this.
[00:14:28] Okay now we have all these first ones here explained.
[00:14:32] Now we have these comparable modules where we can compare different signals.
[00:14:39] And the first difference you notice is that we have now red inputs which means this is
[00:14:45] intended for audio signals.
[00:14:47] You can of course use it for logic signals too but it's more intended for audio signals.
[00:15:01] And this says comparator assessing if two signals are roughly equal.
[00:15:12] So we have now a signal going out because the input of the bottom and the top input
[00:15:18] are the same which is zero.
[00:15:22] And this is zero because these two inputs are different.
[00:15:27] Now it's the same again.
[00:15:28] So we have one going out.
[00:15:32] And this is more useful for when you have maybe some different audios going in here.
[00:15:53] And you maybe ask yourself why is the output so strange.
[00:15:58] And if we go into a different oscilloscope here, this is an input and this is an input.
[00:16:14] So you can see these two signals are not the same but at some point in time they are overlapping
[00:16:22] so we have here a minus one and we have here a minus one.
[00:16:26] And if they meet, then we have a signal going out.
[00:16:30] Okay, that's basically what this module does.
[00:16:35] It compares the two signals and when they are roughly the same, something is going out.
[00:16:42] A signal, a logic signal that says hey, now the signal is the same.
[00:16:50] I hope this is explained well.
[00:16:56] So you can basically create a logic signal with two audio signals by comparing them.
[00:17:04] And the rest of the modules are all the same.
[00:17:07] They're doing exactly the same stuff just with different types of comparisons.
[00:17:15] So we have here an assessing if one signal is either greater than or equal to another.
[00:17:24] So it's a different comparison but the function is basically the same.
[00:17:30] And at the end here we have this logic functions where you can input not audio signals but
[00:17:38] it's mainly purpose is logic inputs.
[00:17:44] So let's go with the trigger here.
[00:17:48] So this isn't easy, it's basically just outputting the opposite value as you input.
[00:17:57] So when I input one it outputs zero and if I input zero it outputs one.
[00:18:04] So this is basically the not module, pretty easy.
[00:18:08] Then we have the end and I have to use the button here.
[00:18:27] This is one and this is one then the output is also one.
[00:18:34] Something different than the output is zero.
[00:18:37] Basically when two of the input signals are one the output is also one, pretty simple.
[00:18:44] Let's exchange that for or, turn this off.
[00:18:50] The output is one when input one is one or output two is one or output one is one and
[00:19:04] output two is one then output is one.
[00:19:09] Isn't that simple?
[00:19:14] So you have at least one of the inputs at value one to have an outgoing signal of one.
[00:19:27] Pretty logic.
[00:19:30] When you exchange this for XOR which is roughly the same.
[00:19:37] So one output A is one, output B is one then output is zero not one.
[00:19:46] That's different between XOR and OR.
[00:19:50] When you have both of the inputs R at one then the output is zero, if you exchange this
[00:19:55] for OR then the output is one.
[00:20:01] So it's basically a bit, the constraints are a bit harder.
[00:20:07] So the description says logic gates seeking only one input to be true.
[00:20:13] So only one input signal needs to be true to have an outgoing signal of one.
[00:20:26] So and the rest of these modules here are exactly the same.
[00:20:32] So they have the same function only the comparison or the logic comparisons are different and
[00:20:39] yeah you can read what they actually do in the help here.
[00:20:46] And you can see there are also truth tables where you can see when you have an input of
[00:20:51] zero at A and zero at B then it outputs in one.
[00:20:54] If you have an input of one at A and zero at B it outputs one and so forth and so on.
[00:21:02] So it's even you even have a table where you can see what the output is when you are inputting
[00:21:09] different values.
[00:21:11] So I think this describes pretty much all the logic modules.
[00:21:16] I didn't describe what you can do with it so practical tips because I have none.
[00:21:23] But when I create some instruments in the future and I use one of these functions I will make
[00:21:31] of course an overview over my presets and why I used at some point some of the modules.
[00:21:38] But for now out of the blue describing what you can do with it I have no idea.
[00:21:46] Actually we can try and construct some use case and for instance we have logic here and
[00:21:55] we take this for instance and let's take two audio signals maybe a sine wave going in here
[00:22:05] and use a sine wave going in the second one and now we are comparing these two oscillators
[00:22:16] and this is comparator assessing if one signal is either greater than or equal to another.
[00:22:25] Then it outputs an logic signal of one.
[00:22:30] As you can see there are coming a lot of ones out of this module already and then we take
[00:22:37] a select module here and you can see we have an input for logic here at the top and when
[00:22:45] we are choosing this you can now see we switch between these two input jacks here.
[00:22:54] So it takes either one or the other input and now we go in with our oscillator here
[00:23:03] and let's use an oscilloscope so we can see what's going on.
[00:23:15] You can see we have a very strange waveform here going out because we switch between a
[00:23:24] sine wave and a sawtooth pretty fast on the base of this comparison modules here.
[00:23:35] So when one signal is basically greater or equal to the other signal then it switches
[00:23:43] the path to the different oscillator and we have now this pretty strange waveform going
[00:23:51] out so let's look what's going on here.
[00:23:58] This is sine wave and this is our sawtooth and when these two are compared and we use
[00:24:10] this for the switch then we have this outgoing signal here at the top so very strange one.
[00:24:18] Sounds like this.
[00:24:30] And let's maybe change this comparison module here to a different one.
[00:24:35] You can see the wave is changing.
[00:24:53] So this is maybe one use case where you can create a more complex wave form out of the
[00:25:02] select module and this comparison modules from the logic category here.
[00:25:11] So this is maybe how you can use it but there are lots of more of these use cases and that's
[00:25:19] just one of them.
[00:25:21] Yeah I think that's it for this video I hope I explained everything pretty well and made
[00:25:25] no errors or explained something wrong.
[00:25:30] And under this video asking questions and if you want to see some longer tutorials for
[00:25:34] some of the modules then yeah also write me and yeah when I do some instruments in the
[00:25:43] future in the grid I try to go over the patch and explain why I use some of the modules and
[00:25:51] how and I think that's a better approach to some of the grid modules and not like go over
[00:26:02] each of these modules and explain what you can do with it.
[00:26:05] I know Brian Ballman did a nice and very beloved series on YouTube where he goes over each
[00:26:15] device in Bitwig Studio but some of the devices of Bitwig are much more complex.
[00:26:21] So yeah more like a pretty distinctive use case for each of the devices so it's better
[00:26:27] to explain.
[00:26:28] But in the grid as I said most of the modules are pretty simple and easy to understand but
[00:26:35] you can use them in multiple ways and yeah.
[00:26:39] So thanks for watching and subscribe to the channel, subscribe on Patreon and I'll see
[00:26:46] you in the next video.
[00:26:47] Bye.
[00:26:48] .
[00:26:50] [Music]
[00:26:52] [Music]
[00:27:02] [Music]
[00:27:04] [BLANK_AUDIO]