Tutorial 5: Basic Synth - Modulation with LFOs

            Overview
            --------

            Until now, we used either envelopes or physical controllers
            for modulating the various parameters in our synthesizer
            models.  However, almost every synthesizer has an additional
            modulator - the LFO.  The LFO is an crucial tool for the
            creation of advanced synth sounds - and is a part of many
            popular analog sounds.

            Technical Discussion
            --------------------

            LFO stands for Low Frequency Oscillator, and in many ways is
            similar to a standard Tone Oscillator:

               It has a selectable waveform.
               It can be set to a fixed frequency.
               The frequency can be affected by other modulators.

            There is one giant difference, however.  An LFO's frequency
            is typically limited to sub-audio speed - below 20 HZ (20
            cycles per second).  Since this is the case, it doesn't do
            much good to "listen" to the LFO, but it makes a great
            modulator.  How?

            Let's walk through an example.  We may have a nice ARP-like
            tone, with velocity-sensitivity and a smooth envelope.
            Makes a beautiful swelling lead sound.  However, when a long
            note is held, it just "sits there", with no real sonic
            movement.  How can we give this sound some animation?

            One option would be to use another envelope to adjust the
            filter. However, this has two problems.  First, the movement
            is typically static - the sound moves through the envelope,
            then "holds" at the sustain portion of the envelope until
            the key is released.  This can be solved (somewhat) by
            looping the envelope.

            Secondly, envelopes are made to move in straight lines, and
            over pre-defined times.  In this case, we probably want a
            smooth change, and maybe want to use the mod wheel to adjust
            the speed of effect -- something you can't do with an
            envelope.

            Finally, envelopes are "valuable".  There are only three
            ADSR envelopes available to a patch; with one always being
            used for the amplitude, one typically being used for
            filtering and only one available for all other modulations.
            If we can save that envelope for another modulation, we will
            have more patch flexibility.

            In this and other cases, a good alternative for envelopes is
            an LFO.  To use it for this patch, you could set the shape
            (waveform) of the LFO to a sine wave, control its speed with
            the mod wheel, and maybe even tie the depth of the effect to
            the filter envelope.  One of the big advantages to LFOs are
            that they are _always_ looping - no fiddling with segment
            loops to get the sound you desire.

            In our older analog synth model, you won't remember an LFO.
            Implementation of LFOs in analog synths differed
            considerably, and often were simply preset to certain
            functions.  With the K2000, we have the ability to use the
            LFO to control any modulated value - opening the doors for
            some real wild effects.  In the Patch Runs, we will explore
            LFOs, and seeing how they allow us to create vibrato,
            tremolo, sweep and even random functions.  While the
            availability of LFOs creates a more complex modulation
            matrix, the power available with LFOs will make almost any
            patch better...

            Like envelopes, LFOs are hard to visualize, but easy to
            hear.  Let's learn by doing .... in the Patch Runs!



            Patch Run #1: Pitch Modulation with LFOs

            This patch run uses the patches prefixed with "[ddg]05/01",
            and will show the basics of LFO handling.  Whenever you are
            working with a new modulator, the easiest way to hear the
            result is to modulate the pitch.  Because pitch changes are
            more obvious than volume or filter changes, modulating the
            pitch makes the modulation effect very (and sometimes
            painfully) easy to hear.

            Select patch "[ddg]05/01 lfo 1", and play a middle C.  You
            will notice the that patch is a simple sine wave, with the
            pitch sweeping about an octave each way. Enter the patch
            editor, and check out the PITCH page.    For this patch, I
            am using LFO1 to modulate the pitch via the SRC1 field, with
            a depth of 1200 cts (one octave).  Move to the LFO page by
            hitting the [MORE] soft key until the [LFO] option is displayed,
            then select it.  You will see a page with two LFOs available.
            LFO #1, which is the pitch modulator is using the TRIANGLE
            shape, is set to a minimum rate of .5 HZ (once every two
            seconds), and begins at phase of 0.  What do each of these
            mean?

            First, let's take a quick look at rates.  Now that you know
            what LFO modulation sounds like, understanding the rate
            values are a snap.  There are two rates - minimum and
            maximum values, and a controller used to vary between them.
            If you are going to have a set LFO rate, you would only set
            the MnRate parameter.  Move the cursor to the MnRate: field,
            and change it around.  In a music store demo, this is one of
            the knobs that everyone likes to play with.  In the hands of
            a good synthesist, this parameter is the gateway to
            heaven...

            Next, the wave shape.  The K2000 allows a number of shapes
            for the LFO, and each shape has a specific sound and use.
            As we discuss each shape, make the change to LFO 1, and
            listen to the change in pitch that is generated.

            SINE shapes
            The SINE waveshape is a smooth cycling shape, but has an
            increased exponential ramp-up, which slows down as you
            approach the minimum or maximum values.  The best way to
            "visualize" this is to check the K2000 Musician's Reference
            (chapter 20), and examine the chart.  SINE LFOs are real
            handy for filter modulation.  Also, because the LFO spends
            most of its time near the extremes, we will be using it for
            "chorusing" effects as well.  A POSITIVE SINE shape is
            similar to the SINE, but is scaled to values from 0% to
            100%.

            SQUARE shapes
            The SQUARE shape "pops" to 100%, stays a while, drops to -
            100%, stays there a while, then begins the next cycle.
            SQUARE shaped LFOs are typically used for two purposes -
            sound effects and for on/off signals.  In terms of sound
            effects, the SQUARE shape gives the "British Police Siren"
            effect -- "EEEaaaEEEaaa".  For on/off usage, the LFO can
            modulate the amplitude, providing full volume/no volume
            switching.  The POSITIVE SQUARE only jumps fro 0% to 100%.

            TRIANGLE shapes
            The TRIANGLE shape provides a smooth ramp to 100%, then an
            equally smooth ramp down to -100%, then a smooth ramp back
            to 0%.  This is one complete cycle.  SAW waveforms are often
            used for pitch modulation, since there is even movement
            throughout the LFO cycle, and there is no pause at any point
            of the "journey".  A POSITIVE TRIANGLE scales this movement
            to the range of 0% to 100%.

            SAWTOOTH shapes
            The RISING SAWTOOTH shape swells from 0% to 100%, drops to -
            100%, then swells to 0%.  This is one complete cycle.  The
            FALLING SAWTOOTH is a mirror image of this, falling first,
            then jumping up.  The SAWTOOTH shapes are also "effect-y"
            LFOs, and is particularly useful for filter and pitch
            swells, and vibrato/tremolo effects.  POSITIVE versions of
            these LFOs are also available.

            STEP shapes
            The stepped shaped take a different approach to oscillation
            - by moving to a number of discrete positions during each
            cycle.  The K2000 has 3-, 4-, 5-, 6-, 7-, 8-, 10- and 12
            step cycles.  These shapes are useful for timed events,
            pitch modulation and general mayhem.  POSITIVE versions of
            the LFOs are again available.


            Finally, a brief discussion of the PHASE value.  The phase
            value shows where in the LFO cycle the sound will start,
            based on its "phase angle".  Given that each of the LFO
            shapes has a "cycle", the phase value how far "into" the
            cycle you will start.  For single layer patches (everything
            we've been doing so far), this isn't so important.  However,
            compare the sound of patches "05/01 lfo2" and "05/01 lfo3",
            paying close attention to the starting pitch of each sound.
            These are identical, pitch modulated patches.  However, the
            phase starting point is different for each, allowing "05/01
            lfo3" to start at the lowest point of the sweep, rather than
            at the 0% point.  You should check out these patches in the
            patch editor, and play with the shape, speed and phase
            values until you are very comfortable with the effect of
            each.  You are limited to 0deg, 90deg, 180deg and 270deg -
            the four "quadrants" of the cycle.

            Finally, select patch "[ddg]05/01 lfo4".  This is another
            simple electric piano patch.  Move the mod wheel -- nothing
            happens.  What we'd like to have is a gentle vibrato (moving
            pitch) be activated as we move the pitch wheel. Enter the
            patch editor, and select the PITCH page.  Change the SRC2
            field value to LFO1.  This says that the pitch will be
            modulated by the first LFO (which I've set up for you).
            However, with the SRC2 field, we also have to define a depth
            modulator.  Set the DptSrc: to MWheel, the minimum value to
            0cts, and the max. value to 40cts.  Now play the patch, and
            move the mod wheel.  You should notice a gentle vibrato come
            in with the mod wheel, and intensify as the wheel is moved
            farther.  This is a very standard usage of the mod wheel for
            vibrato handling.

            Now, move back to the LFO page, and set a MxRate: value of
            9.00, and the RateCt controller to MWheel.  Moving the Data
            slider will now allow you to vary the rate of the vibrato
            for best effect.

            Again, I strongly suggest that you try other LFO shapes,
            speeds and controllers, so that you become very comfortable
            with the sound of the various LFO options.



            Patch Run #2: Filter Modulation


            Check out patch "[ddg]05/02 filt1".  Hold down a chord, and
            listen to the filter sweep.  This is a very popular sound.
            Let's take a look at how it was done.

            Enter the patch editor, and move to the [F1 FRQ] page.  This
            is the filter cutoff frequency setup, and you can see that
            I've set the SRC1: field to LFO1, and the Depth: field to a
            pretty high value.  Adjust the Depth: field, and listen to
            the results.  You should also examine the [F2 RES] page,
            just to understand why the filter sounds the way it does.

            Now, move to the [LFO] page, and move to LFO1's shape field.
            Try a few different waveshapes (I like to use the TRIANGLE,
            SINE and SAWTOOTH options) to change the effect of the
            filter sweep.  When you are done, exit the patch editor.

            Patch "[ddg]05/02 filt2" takes a little different approach.
            Hold down octaves notes at the low end of the keyboard.
            I've created this patch to emulate some of the
            "inconsistent" features of some analog synths.  Let's take a
            look at the patch parameters.

            In this case, I've set up two different LFOs - each using a
            different shape and speed.  Now, lets look at all of the
            places where the LFOs are used for modulation.  First, the
            PITCH pages uses LFO1 (the fast, TRIANGLE LFO) to vary the
            pitch slightly.  This gives an almost imperceptible pitch
            change based on the LFO's shape, and adds a bit of
            instability to the sound.

            Next, move to the [F1 FRQ] page.  You will notice that I am
            using LFO2 (the medium-speed 8-step one) to alter the filter
            cutoff over a +/- octave range.  This will give the
            "BOOPbeep" quality to the sound, and will be very
            mechanical.  But ... this is GOOD!  I like this types of
            thing, in a techno environment, for a little inspiration.

            If you listen closely, you should also be able to hear
            another change to the sound - a change in the "hollowness"
            or "emphasis" of the filter sound.  Anytime you can describe
            a modification with one of these words, you know resonance
            is at work.  Move to the [F2 RES] page, and look at the
            modulation I have in play.  I've got ENV2 modulating the
            resonance, moving the resonance value from 0db (the stock
            setting) to +24db (the maximum setting).  Remember, these
            modulations are additive, so the maximum result of a
            modulator on the resonance is the combination of the COARSE
            value *plus and minus* the maximum depth value.

            The final patch of this Run, "[ddg]05/02 amp1", is an
            example of a tremolo (moving volume) patch.  Play a simple
            legato line.  To understand what is going on, move to the
            [AMP] page.  We've not spent much time here, but you should
            be able to see where I've modulated the amplitude -- in the
            SRC1: area (again!).  This patch is an attempt at emulation
            of the "big surf guitar" sound that shows up every five
            years or so.  Play around with the LFO1 values, and with the
            SRC1 parameters in the AMP page.



            Patch Run #3: Additional Modulation Matrix Usage.

            Up to this point, we've applied the LFO modulators against
            the pitch, filter and amplitude.  In earlier tutorials, we
            used envelopes and physical  controllers to do the same
            thing.  Now, let's start cross-modulating.

            Huh???

            Some unique effects can be created by modulating one
            modulator with another. In upcoming tutorials, we will be
            working with FUNs, which provide absolute control of cross-
            modulation.  But, for simple cross-modulation, we can make
            fuller use of the SRC2: and DptCtl: fields.

            Select patch "[ddg]05/03 xmod1", and hold a chord.  Notice
            how a tremolo effect slowly builds, giving the sound
            "staying power" when held for a long time.  This is an
            effect that is often used to prevent pad sounds from seeming
            stale when held for 8 measures or more.  Take a look at the
            PITCH page in the patch editor.  In this case, I've got LFO1
            modulating pitch via the SRC2: value, while ENV2 is
            modulating the depth - from a minimum of 0ct (no depth) to a
            maximum of 30cts (a moderate vibrato). If you examine LFO1,
            you will see the good old SAW shape, at a 2Hz speed. Now,
            look at ENV2.  You can see that I've set up a slow ramp to
            100%, with a slight release drop.  Let's walk through what
            is happening:

            1. You hit a key.  The K2000 determines the key value.
            2. The K2000 examines the pitch parameters, and sees that
               the LFO if modulating the pitch.  The LFO is measured,
               and a "percentage at this time" is taken.
            3. The K2000 also sees that the depth is controlled by ENV2.
               ENV2 is measured, and a "percentage at this time" is
               determined.
            4. The K2000 sets the pitch using the following formula:
               Sample Pitch + (LFO1% * ENV2% * MaxDpt).  NOTE: This
               formula is over-simplified, and is more complex if a non-
               zero MinDpt: value is set.  However, it'll help you get
               started.
            5. After this is sounded, jump back to step #2, and repeat
               until the sound is completed.  The K2000 does this loop
               about 20 times per second!

            While this is a complicated explanation, I want you to get a
            feel for the interaction of the various modulators.  Let's
            try another one...

            Patch "[ddg]05/03 xmod2" is real corny - we are using
            modulators all over the place!  Hit a C3 note, and hold it
            for a while.  This would make any academic e-music professor
            happy - instant masters degree!  (Note to electronic music
            educators: I'm just kidding!)  Now, just what have we done?
            Well, here is the modulation matrix:

                                  A E E L L K V B M D
                                  M N N F F E E E O A
                                  P V V O O Y L N D T
                                  E         T C D   A
                                  N 1 2 1 2 R T E W
                                  V         K Y R
                                ______________________
            Tone Volume        |  A - - - - - - - - -
            Filter Cutoff      |  - - 2 X - - - - - -
            Cutoff SRC2 Depth  |  ------- off -------
            Filter Resonance   |  - - - - 2 - - - - -
            Res. SRC2 Depth    |  - - - X - - - - - -
            Pitch              |  - - - X 2 - - A - -
            Pitch SRC2 Depth   |  ------- on  -------

            Where: A   = Always
                   -   = Not connected
                   X   = Connected
                   2   = Connected to SRC2 (requires Depth Mod)

            First, to get the note to cycle on and off, an looped
            envelope is being used to control the amplitude (volume).
            Look at the AMPENV page; you can see that I've basically set
            up a "square wave", and caused the envelope to loop.
            Looped envelopes are very similar to LFOs,  with the
            exception that the rate cannot be changed.

            Next, examine the LFO page.  I again have two LFOs set up.
            The first is a stepped wave, and the second is a very fast
            sine wave.  LFO1 and LFO2 are used for pitch and filter
            modulation.  Move to the PITCH page.  I've got LFO1
            controlling the pitch as SRC1:, which provides the melody
            line. LFO3 is also used to slightly alter the pitch, via
            SRC2:.  Note that I'm using ON as the DptCtl:, which is the
            equivalent of _always_ using the MaxDpt amount as the depth.
            This will give a slightly inconsistent pitch, an effect you
            can see that I like!

            The filter had a pile of modulation.  The cutoff frequency
            is using LFO1, but with a negative depth.  Thus, the I'm
            starting at a "high" filter setting, and "reverse
            modulating" the filter by LFO2.  This allows us to use the
            same LFO for both pitch and filter, but have them affect
            each sound differently.  I also have ENV2 accenting the
            cutoff frequency, to get the sound filter rampup.

            Finally, move to the [F2 RES] page.  I'm using LFO2 to
            modulate the resonance, with the depth begin controlled by
            LFO1.  Big Fun!  Basically, I'm changing the resonance very
            fast (because of the LFO2 speed), but turning the depth
            parameter to a variety of values due to LFO1.  This is what
            gives the variant squelchy tone.



            As you are developing you own patches, keeping track of the
            modulation matrix is very important.  So, to help you
            program, here is the current Modulation Matrix:

                                  A E E L L K V B M D
                                  M N N F F E E E O A
                                  P V V O O Y L N D T
                                  E         T C D   A
                                  N 1 2 1 2 R T E W
                                  V         K Y R H
                                ______________________
            Tone Volume        |  A - - - - - - - - -
            Filter Cutoff      |  - - - - - - - - - -
            Cutoff SRC2 Depth  |  - - - - - - - - - -
            Filter Resonance   |  - - - - - - - - - -
            Res. SRC2 Depth    |  - - - - - - - - - -
            Pitch              |  - - - - - - - A - -
            Pitch SRC2 Depth   |  - - - - - - - - - -
            Amplitude          |  - - - - - - - - - -
            Amp SRC2 Depth     |  - - - - - - - - - -
            LFO 1 Rate         |  - - - - - - - - - -
            LFO 2 Rate         |  - - - - - - - - - -



            Tutorial 5 is complete, but Sarge Darwin sez:

                       BUILD SOME OF YOUR OWN PATCHES, PRIVATE!
                       I SAID, B-U-I-L-D YOUR OWN P-A-T-C-H-E-S!
                       THEN POST THEM TO THE FTP SITE, OK?
                       I CAN'T HEAR YOU!
                       I CAN'T HEAR YOU!

            OK, enough of the hard guy stuff.  If you need to contact
            me, I'm at:

               ddg@wi.rr.com

            Thanks for you attention, all of your kind e-mail, and for
            choosing a keyboard I can talk about!

            ;-)