Over the last months we've been posting these #ReasonQuickTip videos on our social media channels and due to popular demand, we've now compiled them in one space. This YouTube playlist will be updated whenever a new #ReasonQuickTip gets posted so be sure to bookmark this page!
If you want to share your best tip with us, just tweet us or write to us on Facebook or Instagram! Maybe your tip will be our next video?
Discovering Reason is a series of articles created especially for people who have been using Reason for some time, yet can't help but feel they've only scratched the surface. While many of them were written for much older Reason versions, they're more retro or classic than out of date.
Reason's endless possibilities are not always obvious and there's a myriad of nifty tricks hidden in this open-ended production environment. We are creatures of habit, and it's easy to become lazy and get stuck in routines - routines which are often a heritage from other production environments that emphasise on quantity and diversity rather than flexibility and experimentalism.
The articles will assume that you have a fair amount of experience with Reason, and will not cover all the details of certain basic operations. Consult the Reason Operation Manual if you stumble upon something unfamiliar.
This tutorial discusses the concepts of control voltages (CVs) and Gates in Propellerhead's software. Of course, they're not really voltages because everything is happening within the software running on your PC or Mac. But the concepts are the same so, before going on to discuss how to use them, let's first take the time to understand where CVs and Gates came from, what they are, and what they do.
We'll begin by considering one of the most fundamental concepts in synthesis: there is no sound that you can define purely in terms of its timbre. Even if it seems to exhibit a consistent tone and volume, there must have been a moment when it began and a moment when it will end. This means that its loudness is contoured in some fashion. Likewise, it's probable that its tone is also evolving in some way. So let's start by considering an unvarying tone generated by an oscillator and make its output audible by playing it through a signal modifier — in this case, an amplifier – and then onwards to a speaker of some sort. We can represent this setup as figure 1.
Figure 1: A simple sound generator
Now imagine that the amplifier in figure 1 is your hi-fi amp, and that the volume knob is turned fully anticlockwise. Clearly, you will hear nothing. Next, imagine taking hold of the knob and rotating it clockwise and then fully anticlockwise again over the course of a few seconds. Obviously, you will hear the sound of the oscillator evolve from silence through a period of loudness and then back to silence again. In other words, your hand has acted as a controller, altering the action of the modifier and therefore changing when you hear even though the audio generated by the source has itself remained unchanged.
Twisting one or more knobs every time that you want to hear a note isn't a sensible way to go about things, so early synthesiser pioneers attempted to devise a method that would allow them to control their sources and modifiers electronically. They found that they could design circuits that responded in desirable ways if voltages were applied at certain points called control inputs. So, for example, an amplifier could be designed in such a way that that, when the voltage presented to its control input was 0V its gain was -∞dB (which you would normally call ‘zero', or ‘off') and when the voltage was, say, +10V, the amplifier provided its maximum gain. Thus the concepts of control voltages (CVs) and voltage-controlled amplifiers (VCAs) were born. (Figure 2.)
Figure 2: Shaping the output from the amplifier
The next thing that was needed was a mechanism to determine the magnitude of the control voltage so that notes could be shaped in a consistent and reproducible fashion. Developed in a number of different forms, this device was the contour generator, although many manufacturers have since called it (less accurately) an envelope generator, or “EG”. The most famous of these is called the ADSR; an acronym that stands for Attack/Decay/Sustain/Release. These names represent the four stages of the contour. Three of them - Attack, Decay, and Release - are measures of time, while the Sustain is a voltage level that is maintained for a period determined by... well, we'll come to that in a moment. (Figure 3.)
Figure 3: The ADSR contour generator
If we now connect this device to the VCA in figure 2 it should be obvious that the contour shapes the loudness of the note as time passes. (Figure 4.) But how do we trigger it?
Figure 4: Amplitude control using a triggered contour generator
Let's consider what happens at the moment that you press a key on a typical analogue monosynth. Many such synths generate three control voltages every time that you do so. The first determines the pitch of the sound produced, so we can replace the concept of the oscillator in figure 1 with that of the Voltage Controlled Oscillator (VCO). The second is called a Trigger. This is a short pulse that initiates the actions of devices such as contour generators. The third is a called a Gate. Like the Trigger, the Gate's leading edge can tell other circuits that you have pressed a key but, unlike the Trigger, its voltage is generated for the whole time that you keep the key depressed, which means that it can also tell those other circuits when you release the key. (Figure 5.)
Figure 5: Pitch CV, Trigger & Gate signals
If we now return to the contour generator it's clear that the Gate is important because it tells the ADSR how long to hold the Sustain level before entering the Release phase. This means that I can redraw figure 6 to show the ADSR being triggered and how the note's shape is influenced by the duration of the Gate. (Figure 6.)
Figure 6: Controlling the ADSR
It should now be obvious why we need timing signals, but why do we need two of them? There are many synthesisers that work with just a pitch CV and a Gate, but consider what happens when you hold one key down continuously (resulting in a continuous Gate) and press other keys, perhaps to create trills or some other musical effects. If there are no subsequent Triggers, the Gate holds the ADSR at the sustain level until you release all the keys so, after the first note, none of the subsequent ones are shaped correctly. This is called "single triggering". However, if a Trigger is generated every time that a note is pressed the contour generator is re-initiated whether or not a previous note is held, and subsequent notes are shaped as intended. ("Multi-triggering".)
Putting it all together
At this point, we have a VCO controlled by a pitch CV, plus an ADSR contour generator whose initiation and duration are controlled by a Trigger and a Gate. In principle, this is all that we need to programme and play a wide range of musically meaningful sounds, but let's now extend the model by adding a second ADSR and a voltage controlled low-pass filter (VC-LPF) to affect the brightness of the sound. Shown in figure 7 (in which the red lines are control signals of one form or another, and the black lines are audio signals) this is all we need for a basic synthesiser.
Figure 7: A basic voltage-controlled synthesiser
Of course, real synths embody a huge number of embellishments to these concepts, but we can ignore these. What's important here is to understand the differences between the three control signals and to be able to recognise one from another. However, this is not always as straightforward as it might seem. Imagine that you replace ADSR 2 in figure 7 with the triangle wave output from a low frequency oscillator. Now, instead of having an articulated note, you have one that exhibits tremolo. In other words, the oscillator's triangle wave is acting as a CV. But what happens if we simultaneously replace the Trigger in figure 7 with the pulse wave output from the same LFO? The LFO is now generating a stream of triggers that regularly reinitialise ADSR 1 to shape the brightness of the sound in a repeating fashion. As figure 8 shows, it's not WHAT generates a signal that determines whether it's a CV, Trigger or Gate, it's WHERE you apply that signal that counts.
Figure 8: An LFO acting simultaneously as a CV generator and a Trigger generator
Of course, oscillators, filters and amplifiers need not be affected only by pitch CVs, contour generators and LFOs. There are myriad other voltages that can be presented to their control inputs, including velocity, aftertouch and joystick CVs, the outputs from S&H generators and voltage processors, envelope followers, pitch-to-CV converters, and many more devices. Discussing these could form the basis of an entire series of tutorials, but at this point we have to take a different direction...
So far, we've only discussed how things affect other things within a single synthesiser, but CVs and Gates also make it possible for separate instruments to talk to one another. Take the simple example of an analogue sequencer driving a monosynth. In this case, the voltages generated by the synth's keyboard are replaced by those generated within the sequencer, which sends a stream of Gates to tell the synth when to play and how to articulate the notes, and a stream of CVs to tell it what pitches those notes should be. If you're lucky, the sequencer may even be capable of producing a second CV (usually called an Auxiliary CV) that can affect other aspects of the sound while the sequence is playing. (Figure 9.)
Figure 9: Connecting a synth and a sequencer
But that's not all because, with suitably equipped instruments capable of generating and receiving various control voltages, the CVs, Triggers and Gates generated by one synthesiser can control what happens on a second (or a third, or a fourth...). Furthermore, CVs generated by any of them can be mixed together (or not) and directed to control the actions of things such as effects units, sequencer controls, panning mixers and much more. (See figure 10.) It's simple, and can be wonderfully creative. The only problem is that, with a fistful of patch cables and a bit of imagination, you'll soon be on your way to creating a multi-coloured mess of electrical spaghetti.
Figure 10: Connecting multiple devices using CVs and Gates
CVs and Gates in Reason
You might be wondering what all of the above has to do with digital environments such as Reason or Record. The answer is that control signals do not have to be analogue voltages; there's no reason why CVs should not be represented digitally as streams of numbers, nor any reason why Triggers and Gates should not be represented as streams of Note On/Off messages. Furthermore, there's no reason why the human interface of a digital system need look like pages of computer code because it should be possible to represent the connections using graphical representations of cables, just as it's possible for softsynths to represent their parameter values using on-screen knobs and sliders.
Let's turn to Reason (or Record) and create instances of, say, Thor and Malström and then hit the TAB key to reveal their back panels. (Figure 11.)
Figure 11: The rear panels of Thor and Malström
If you've not looked at these before, you may be surprised to discover the wealth of control options that they offer. What's more, there's nothing arcane about them because, as postulated above, they are indeed represented in the form of CV & Gate inputs and outputs that allow you to interconnect all manner of disparate devices – not just the synthesisers, but the sequencers, effects units and other modules within the software – and make them do things that would not otherwise be possible.
Create an instance of the PH-90 Phaser and look at its rear panel... there are the frequency and rate CVs that I implied in figure 10. Create a Mixer and look at its rear panel... there are the level and pan CVs that I drew. Create a Spider CV merger and splitter... there's your CV Mixer. Create an RPG-8 arpeggiator or a Matrix sequencer... you'll find CVs, CVs everywhere!
At this point, it can be tempting to start connecting dozens of virtual cables, and you'll soon be on your way to that mass of multi-coloured spaghetti that I mentioned above. So, to conclude this tutorial and illustrate what we've learned, I'm going to discuss a simple audio example that uses just two auxiliary CVs, each of which is generated by one instance of the Matrix sequencer.
Like its inspirations from the 1970s, Matrix generates three control signals: a pitch CV (which Propellerhead calls a Note CV), a Gate, and an auxiliary CV called the Curve CV. If you create an instance of Matrix with Thor already in place, it will automatically connect its Note CV output to Thor's main CV input, and its Gate output to Thor's Gate input, ready for use. However, I'm also going to connect its Curve CV output to Thor's CV1 input (see figure 12) and, turning to the front of the rack, use the modulation matrix in Thor to direct CV1 to the Y-axis of the Formant Filter in my patch. (Figure 13.)
Figure 12 – Connecting Matrix and Thor
Figure 13: Adding interest to the sound by controlling the filter with the Matrix's auxiliary CV
I'm now ready to programme a short sequence. I'll use the Note CV to determine the notes played, and the Curve CV to determine the characteristics of the Formant filter in the patch for each note. The Gate will act just as on the analogue synths described above, controlling the ADSRs that shape the notes generated by Thor. Sound #1 demonstrates this sequence without the Curve CV connected:
While sound #2 demonstrates it with the Curve CV doing its thing:
Next, I've added this sequence to a backing sequence generated simultaneously using a second instance of Matrix, a second instance of Thor, plus Redrum and a few other bits and pieces. Again, I've recorded two versions – one with the Curve CV disconnected:
...and one with it connected .
Finally, I've used an instance of Spider plus the Curve CV in the second instance of Matrix to pan the pitched parts left/right/left while the sequence is playing, and (using a CV inverter) to pan the rhythm part right/left/right to create a cross-panning effect between the drums and the bass lines:
Once you start to experiment with your own sounds, sequences and effects, you'll soon find that CVs and Gates are superb tools, and you'll never get tired of finding out what happens when you ask this device to control some aspect of that device and make it do something weird'n'wonderful just to see what the results might be. The only caveat is that – even in a digital system – the multi-coloured spaghetti is never far away. (See figure 14.) Now it's time for you to cook some of your own.
Figure 14: Some of the connections that generated sound #5
Right, so... where were we? Oh yes, Spider CV Merger & Splitter, the other eight-legged freak in the Reason terrarium. Now, this is the evil twin of Spider Audio, and this one you have to handle with caution because the webs of cables that can build up around these things can become more or less impenetrable. While it may be tempting to try and be as economical as possible (for example, using both the split and the merge sections on a single unit), we encourage you to spread the burden across as many Spider CV units as possible - they are the most CPU friendly Reason units of all, and it's going to be a lot easier to track down the right cable if they aren't all on top of one another. And now, on with the show.
The first (and fairly obvious, but fun nonetheless) setup we'll try is all about stacking. Since a single Matrix unit can now play as many synths as the CPU can handle, you can build up sounds by using any mixture of Subtractor, Malström or NN-sampler sounds. If you run out of split outputs, just add another Spider CV unit to the chain. In the example filestakkabass.rns we've built a massive bass sound with two Malströms, one NN-XT and one Subtractor. For this you actually need four Spider C units; the Matrix has three outputs (Note, Gate, Curve) and since these need to be branched out into a total of twelve cables for four synths, you will need to link a few CV units together in order to serve all four. Check the example file, turn the rack around and see if you can follow that spider...
Mixer automation is something one will usually let a main sequencer track take care of - and that's great, it offers complete and minute control over all parameters. But sometimes you wish that automation itself could be automated, and thanks to the Spider CV split function this is possible - at least as far as channel Level and Pan is concerned. With the aid of a single Spider CV unit you can control the Level and Pan of three channels at once, and by linking multiple units together it's theoretically possible to control all fourteen channels, either all at once or through some customized sub-grouping scheme.
But let's not go nuts like in the picture here - let's stick with the three-channel idea for now. What we'll do first in this example -splittermix.rns - is create a 14:2 mixer and three Dr. REX. Then we'll create a Spider CV unit and route the split outputs A and B to level and pan, respectively, on the three active mixer channels. And then we'll create... a Matrix? No, been there, done that. Instead we'll use a Malström - not for its sound capacities, but because it features Modulators A and B, two excellent LFO-type modulation sources with a massive amount of crazy curves in store. Using Mod A for level and Mod B, we've got automation of Pan and Level covered, and since the Malström itself can be automated from its own track, the modulation curve types and rates can be changed during the song.
Hit play in the example file and hear this author haphazardly messing around with the settings, and remember that the only automation going on here is on the Malström track. The Malström comes highly recommended as a modulation source if you're looking for things you can't get out of the standard LFO waveforms and the Matrix is too aliased.
Another situation where the Merge functionality proves highly useful involves ReDrum. Right, we already know several ways of using CV for rhytmic modulation: You can use a Dr. REX and let the loop slices send gate signals. You can synchronize a unit's built-in LFO to MIDI. You can "borrow" the LFO from device and modulate another. You can use Matrix Gate and Curve data. So far, so good. But what if you want a ReDrum to do it? The thing with that is, ReDrum sports per-channel Gate outputs, so you can't have an external target modulated by the entire drum pattern, only by one drum at a time. Here's where Spider CV's merge function shines: You can take the Gate output of up to four ReDrum channels and merge them into one. And of course you can set up multiple Spider CV units to merge the Gate signals from all ten ReDrum channels. So let's try this:
Submerged.rns - In this example file, the idea is to merge two separate groups of ReDrum Gate signals and have them modulate one instrument each. We've got the drums, a bass and a pad-ish sound.
Now, having both the bass and the pad modulated exactly the same way will sound a little chunky, so here's what we'll do: We merge the bass drum and snare drum Gate signals and route these to the filter on the bass synth. For a secondary modulation source, we merge two of the hi-hat channels - this will provide the modulation pattern for the pad sound. Both the bass and the pad are run through ECF-42 filter units, and these are what the ReDrum will modulate. Having the bass filter retrigged each time a bass drum or snare hit occurs provides a nice tight groove at the bottom, and it gives a nice symmetry to have the high end percussion (the hi-hats) control the high end synths. In this particular example the ReDrum is doing its normal job as a sound device too, but this isn't a requirement of course - it can be silent and act only as a CV/Gate "puppetmaster".
You have to see it for yourself. You either love it or ignore it; there is a lot of ambiguity surrounding this particular Reason device. Without generalizing too much, it can perhaps be said that traditional keyboard players are the first to ask "What's that thing for anyway?"
The fact is that the Matrix can be most anything you want it to be, whether you're a keyboard virtuoso or a 'paint-by-numbers' kind of composer. Think of it as your trusty house elf, the one that performs tedious automation chores while you concentrate on more important things. Or, think of it as the bug in the electrical system - plug it into any of those mysterious CV/Gate connectors on the back panel and interesting and unpredictable things may happen.
The Matrix Reloaded
The reason we're kicking off the new Reason era - 2.5 - with an in-depth look at the Matrix, is that it just got a whole lot better. Thanks to the new Spider CV Splitter & Merger unit introduced in 2.5, the signals from a single Matrix unit can now multiply and spread like wildfire over the entire rack. How about two Subtractors and two Malströms playing the same bassline? Or volume automation of 16 synths at once? The sky is the limit. But before we board the rocket and cram the rack chock full of Matrix units, let's go over what the Matrix can do, device by device:
In Reason 1.0:
Mixer 14:2: Automation of Master Volume, Channel Level and Pan, per-channel (curve).
RV-7 Reverb: Automation of Decay (curve).
CF-101 Chorus/Flanger: : Automation of Delay and Rate (curve).
DDL-1 Delay: Automation of Pan and Feedback (curve).
PEQ-2 Parametric EQ: Automation of Frequency 1, Frequency 2 (curve).
PH-90 Phaser: Automation of Frequency and Rate (curve).
COMP-01 Compressor: No CV/Gate inputs.
D-11 Distortion: Automation of Amount (curve).
ECF-42 Filter: Automation of Frequency, Resonance (curve) and Envelope trig (gate).
Subtractor: Monophonic sequencing of notes (note, gate), automation of OSC Pitch, OSC Phase, FM Amount, Filter 1 and 2 Frequency and Resonance, Amp level, Mod Wheel (curve), Amp Envelope trig, Filter Envelope trig, Mod Envelope trig (gate).
NN-19: Monophonic sequencing of notes (note, gate), automation of OSC Pitch, Filter Cutoff and Resonance, Level, Mod Wheel (curve), Amp Envelope trig, Filter Envelope trig (gate).
Dr. REX: Automation of OSC Pitch, Filter Cutoff and Resonance, Level, Mod Wheel (curve), Amp Envelope trig, Filter Envelope trig (gate).
ReDrum: Sequencing of notes, per-channel (gate), automation of Pitch, per-channel (curve).
+ Reason 2.0:
Malström: Monophonic sequencing of notes (note, gate), automation of Pitch, Filter, Index, Shift, Level, Mod Amount, Mod Wheel (curve), Amp Envelope trig, Filter Envelope trig (gate).
NN-XT: Monophonic sequencing of notes (note, gate), automation of OSC Pitch, Filter Cutoff and Resonance, LFO1 Rate, Master Volume, Pan, Mod Wheel (curve), Amp Envelope trig, Mod Envelope trig (gate).
+ Reason 2.5:
BV-512 Vocoder: Automation of Hold (gate), Shift and individual Band levels (curve).
RV-7000 Advanced Reverb: Automation of Decay, HF Damp (curve) and Gate trig (gate).
Scream 4: Automation of Damage Control, Parameter 1 and 2, Scale (curve).
UN-16 Unison: Automation of Detune (curve).
Spider CV: Merge, split.
That's a total of 149 inputs just waiting for a Matrix connection - so what are we waiting for?
A few ma-tricks up the sleeve
Since creating Matrix patterns can be time consuming, it's a good idea to have a preset Matrix unit in your customized default song. Naturally, musical preset patterns might not be very useful but you can make lots of handy generic curve and gate patterns ready for instant access. Some basic ones, like this:
Tip: Hold down [Shift] while drawing, to draw continuous curves or note sequences
Curves like these are very handy for filter sweeps, pan automation, level automation and other things. If you keep these basic curves in mind and go back and read the above list of places to plug in the Matrix you're guaranteed to spot a dozen instant uses for them.
These curves only have to be drawn in one resolution, since you can easily change the speed by changing the time resolution of the pattern. In 1/32 mode, the above patterns play for one bar - change to 1/16 and the length will be two bars, 1/64 = half a bar, and so on.
Of course, you can also use Randomize Pattern and Alter Pattern. While randomized notes seldom produce a musically correct or appealing result, randomized curves and gates often turn out interesting and useful.
Using the new Spider CV module for merging two basic Matrix curves you can generate insane curve data by for example merging two identical curves played back at different speed!
Now for examples. First off, let's just let the Matrix flex its muscles in a simple yet effective "before and after" demonstration to show the profound effect that a little CV/gate injection can have on your sounds, even if you choose to play the actual notes from the keyboard and not the Matrix. History has shown that many Reason users overlook the power of the Matrix and of CV, and choose to limit their use of modulation sources to what each instrument offers.
In this example snippet we've taken a Matrix with a completely random pattern, split its signals through a Spider module and plugged it into virtually every available hole on one Malström and one Scream unit. Here's the little tune before it was fitted with a turbo: fuel.rns
One of the inherent annoyances with pattern-style programming of drum machines is that you need a new pattern for each tiny variation. But why not use Matrix units to create one big "multi-tasking" pattern sequencer with one independent layer for each ReDrum channel? There are many advantages to this method:
Pattern variations only need to occur on the involved sounds, the rest can play on independently (example: the snare drum Matrix can temporarily change to a snare roll pattern but the bass drum and hi-hat patterns remain unchanged)
Each drum channel can have its own individual time resolution (example: the hi-hat is programmed at 1/32 resolution in a 32-step pattern but the bass drum in 1/8 resolution in an 8-step pattern)
Velocity resolution is 1-127 instead of 1-3
Triggering drums only requires Gate signals from the Matrix so you can use the Curve part to control the pitch of the drum if you like
Instant visual representation of each individual drum pattern right inside the rack, no need to switch to Edit view
You can combine ReDrum pattern data with Matrix pattern data - you don't need ten Matrix units for each ReDrum instance, you only need them for ReDrum channels where lots of variations occur
In this example song we've used three ReDrum channels for bass drum, snare and hi-hat. The bass drum pattern is static while the snare and hihat patterns switch between two patterns each, while also using a different time resolution and pitch automation: multidrum.rns
The Return of the Dirty Trick
Remember "dirty trick 1" from the "Ask Dr. REX!" article? We're going to use this again to create a fake arpeggiator from a Matrix and a couple of synths. The idea is to turn the "Osc Pitch" knob next to the Osc Pitch input on the back panel of the instrument all the way to the right (value 127) which will "boost" the incoming CV so that it translates with 100% accuracy to semi-note values, allowing you to change the pitch with Note CV instead of Curve CV. This is not only more intuitive but it frees up the Curve CV so you can use it for other things.
Using a single Matrix we will control one Subtractor and one Malström, combining the Matrix data with MIDI note input. To do this we need to split the Matrix signal using a Spider CV Merger & Splitter. Here is the example file: digibubbles.rns
Now open the song and explore the signal paths. The Matrix is sending Note CV to the Spider module which splits the signal in two, sending one to each synth where it's boosted to map onto the chromatic scale. The Matrix is also sending Gate data, split by the Spider and sent to the Filter Env input of the Subtractor and the Filter (not Filter Env) CV input of the Malström, adding a rhythmic texture to both sounds. The Curve output from the Matrix, finally, is connected to the Filter 1 Freq CV input on the Subtractor. But wait, it's not making sounds yet(!). What you now need to do is feed each synth with MIDI notes. A single sustained note is all it takes, and the Matrix will play the melody based on that 'root note'. You can play any single note or chord you want and the Matrix will take care of the rest. The example file already has MIDI notes in place but you can mute the tracks and play your own notes to get an idea of what it's all about. If you need more variations on the pattern (such as major/minor scale alternatives) just copy the original Matrix pattern to another slot and change whatever you like.