Tutorial 9: EnvCtl, ASR and VTrig pages

            Overview
            --------

            As we've covered K2000 programming,  we have seen some of
            the power of various modulators, and their ability to
            completely change a patch's sound.  In this tutorial, we
            will be looking at a few additional synthesis tools.  First,
            the EnvCtl page has controller mappings that will allow you
            to change the rate at which the standard envelopes (AMPENV,
            ENV2 and ENV3) will "run through" the attack, decay and
            release sections.  Next, the ASR page contains two
            "accessory" envelopes -- different from the standard
            envelopes in that they only contain attack and release
            segments, and have no level controls.  The ASR envelopes
            will often be used as "ramp controllers",  allowing another
            effect to gain depth over time.  Finally, the VTrig page
            controls two trigger-type modulation sources, depends solely
            on a user-defined velocity threshold.  This comes in very
            handy for controlling other modulators based on how hard the
            keys are hit.


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

            EnvCtl

            Over the course of the tutorials, we've become quite
            familiar with the envelopes available with the K2000
            synthesis engine.  However, in setting up and using
            envelopes, we did not discuss realtime control of the rates
            used for the envelope times.  While the depth of envelopes
            is easily controlled at the source (with the Depth control
            when using a Src1 control, or MinDpt and MaxDpt when using a
            Src2 control), we didn't discuss a way to impose changes to
            the rate of the envelope.  The EnvCtl page contains the
            control to do this.

            The EnvCtl page contains three distinct sections - controls
            for adjusting the Attack, Decay and Release segments of the
            standard envelopes (AmpEnv, Env2 and Env3).  The Attack
            section will control the three attack segments of the
            envelopes, while the Release section will control the three
            release segments.  Each segment has the ability to adjust
            the associated rate(s) using the following controls:

            Adjust:

            This is an overall adjustment for the rates.  Entered as a
            "multiplier", with a range from .018 to 50.000.  This means
            that the times can be adjusted from roughly fifty times





            slower, to fifty times faster without having to change the
            values of the envelopes themselves.

            Key Track:

            As we've seen before, key tracking allows us to have K2000
            parameters track the key number being played (actually the
            MIDI note number), and for this value to be used as a
            modifier.  In this instance, you can have the MIDI note
            number affect the envelope rates -- again, in a .018 to
            50.000 times range.

            Vel Track (Attack only):

            For the attack section, you can allow the key velocity to
            control the envelope attack rate.  This can be extremely
            useful for working with percussion samples, allowing you to
            create percussion and drum sounds that are very responsive
            to the velocity of the controller hits.  The allowed values
            are in the .018 to 50.000 range.

            Source and Depth:

            As with many other modulation destinations in the K2000, you
            can assign any modulation source to affect the envelope
            rates, and can determine the amount that the modulator will
            change the envelope rate.  Again, the depth range is .018 to
            50 times the original rates, while the source can be any
            modulation source in the available controls list -- MIDI
            controllers, LFO's, and others.

            There are a few "caveats" when using the EnvCtl system.
            First, changes made to the EnvCtl information affect all
            three main envelopes -- the AmpEnv, and Env 2 and 3.  This
            means that if, for example, you were using Env 2 for a ramp-
            up on a filter cutoff, while using Env 3 to force "timed"
            volume changes, you could not use the EnvCtl system to
            change only the filter cutoff.  EnvCtl would change the
            selected envelope sections across all envelopes, possibly
            messing up your "timed" changes.

            Also, the attack segment of the EnvCtl control system will
            not affect "Natural" envelopes.  Wazzat?  When you select an
            internal K2000 waveform for use in a patch, or change the
            AMPENV Mode: field to Natural, it will generate a "natural"
            envelope -- one that is directly related to the actual
            amplitude envelope of the originally sampled instrument.
            (Note:  there is no way to edit or modify the Natural
            envelopes --  you either like them or you don't!)  Since the
            natural envelope is supposed to be a detailed match to the
            original envelope, and since the attack of a sound is one of
            the most important aural clues to an instrument's nature,
            the K2000 will prevent the EnvCtl attack function from
            adjusting a natural envelope -- and potential wrecking a





            perfectly good sound.  For what it's worth, I don't exactly
            appreciate this, since I'd like total control over all
            possible envelopes.  However, this is really a small issue,
            and is easily ignored by not using natural envelopes.


            ASR Page

            As mentioned earlier, the K2000 provides a pair of
            "secondary" envelopes -- the ASR's.  ASR envelopes have a
            limited functionality;  basically, they provide ramps during
            the attack and release times of a MIDI note being played.
            Why do I call them ramps?  Well, because that's how they
            really operate.  If there is only one parameter for attack,
            the only effect can be a ramp to the maximum envelope level.
            Conversely, if there is only one parameter for release, all
            that can happen is a variation in the amount of time that it
            takes for the envelope to ramp back down to "zero".

            The ASR ramp controllers can be immensely useful -- for
            gradual pitch changes, filter ramps, or for modulating the
            depth of another modulator (when used as the DptCtl in a
            Src2: modulation set).  Modulating a modulator is wonderful
            - for example, you can make an ASR ramp affect the depth of
            a vibrato, providing expressive and "tasty" effects to stock
            synthesized sounds.  Because the ASR has a "delay" segment
            (basically, a timed delay before the ASR begins its attack
            ramp), you can get both more realistic or more radical
            modulations, depending on the amount of delay in use, and
            the modulation destination used.  For example, try using an
            ASR as both a filter and pitch modulation source, with a
            pretty long decay and attack time.  This gives a tone which
            is "stable" for a period of time, then goes nuts!

            Also, the ASR's are not affected by the setting in the
            EnvCtl page.  So, if you are going to be creating "time
            critical" decayed or ramped modulations, and you are going
            to be using EnvCtl modulation, you should take advantage of
            the ASR envelopes.  ASR2 is also affected by the Globals:
            field on the common page -- if Globals: is set ON, and
            ASR2's trigger is set to ON, it will begin to "fire" as soon
            as the program is selected, and will loop infinitely (if
            looping is enabled).

            There are two settings that drastically alter an ASR
            envelope's function:  the Trigger and Mode fields.  Trigger
            determines "what represents the start of the envelope".
            Unlike the standard envelopes, you can determine what
            triggers an ASR envelope -- an LFO, a key press, or the Mod
            Wheel.  The Mode field determines what the ASR envelope will
            do when the attack sections is completed.  The options are:





            Normal - the release section will begin immediately on
            completion of the attack -- there is no sustain segment to
            the envelope.

            Hold - the ASR control sustains at the 100% level until the
            trigger (key stroke, or whatever) is released.  This is
            really what I consider the "normal" operation of an ASR
            envelope.

            Repeat - When the attack segment of the ASR is complete, the
            release will immediately begin.  When the release segment is
            complete, the ASR will loop back to the beginning of the
            attack stage, and repeat.  This looping continues until the
            ASR's trigger is released.

            While there has been little discussion of the power of the
            K2000's ASRs, the patch runs will explore a number of unique
            uses for them, as well as their combination with other
            modulation sources.


            The VTrig page

            The VTrig page allows you to "roll your own" velocity
            switch, and use it as a modulation source.  Basically, it
            contains two selectable switches, with two parameters for
            each switch:

            VTrig Level : determines at what velocity the VTrig will
            switch between OFF and ON.  This is entered in the range of
            ppp to fff (very soft to very loud for you non-notation
            types), and is affected by the velocity curve that you are
            using on the K2000.

            VTrig Sense : determines whether the VTrig begins at ON or
            OFF; with Normal meaning that the VTrig begins at OFF, and
            will switch to ON, and Reversed representing the opposite
            (normally ON, switch to OFF).

            VTrigs, being switches (as opposed to continuous
            controllers) will most often be used as an on/off switch for
            other modulators.  The Patch Runs will examine this in more
            detail.

            And here are those Patch Runs ...






            Patch Run #1 : EnvCtl Experiments

            All of the patches in this tutorial will be prefaced with
            "[ddg] 09/nn", where nn represents that patch run associated
            with it.  The first patch, "[ddg] 09/01 Env1" is a horn
            patch that swells at low velocities, but "bites" harder
            with higher velocities.  Play a typical "horn" chord while
            varying the key velocity.  Notice the expressiveness this
            type of modulation gives the patch.

            Enter the patch editor and look at the AMPENV.  This is a
            typical slower attack envelope, and represents the envelope
            used when the velocity is at its lowest point.  Now, move to
            the EnvCtl page by hitting the [more>] key until the EnvCtl
            soft button is available, then pressing that button.  You
            will see a list of modulations for the various envelope
            stages.  In this case, I've used a VelTrk adjustment of 27
            times (27.000x),  which will cause the envelope attack
            segment to continuously vary, with the highest velocity
            reducing the attack time a great deal.  Adjust this
            parameter, as well as the Adjust: field, to see the effect
            of these parameters on the sound.

            Patch "[ddg] 09/01 Env2" is another one of my analog-ish
            patches, with a bawdy filter sound.  Play the sound while
            manipulating the DATA slider (or equivalent, for those of
            you with a rack-mount).  Note that this changes the
            "snappiness" of the sound.  Again, enter the patch editor,
            and look at the EnvCtl page.  In this case, I've set both
            the Attack and Decay sections to adjust their envelope
            segments to be modulated by the DATA controller (MIDI
            controller 8).  This is a case where a slider comes in real
            handy (versus a Mod Wheel or other controller), since you
            can find a sound you like, and leave the slider in place
            while playing that sound.

            One note:  in this instance, I've set the AMPENV to decay
            without any release level, so it is a "one shot", or non-
            sustaining note.  Not a problem for the tutorial, but you
            might choose to rely on Release levels and rates for most
            patches.

            With this patch, I'm using the EnvCtl page parameters to
            manipulate both the AMPENV (for the sound's audio levels) as
            well as ENV2, which is used for filter manipulation.  You
            should notice that the filter, as well as the amplitude,
            changes drastically as you manipulate the slider.  If you
            look at both envelopes, you will see that they are very
            similar.  This way, the effect of the EnvCtl changes will
            modify both envelopes similarly.  However, also note that
            there is no way to have the EnvCtl parameters affect only
            the AMPENV, without also affecting ENV2.  A limitation that
            is seldom difficult to work around, however.






            Finally, patch "[ddg] 09/01 Env3" is an example of key
            tracking of the EnvCtl controls.  This patch is a simple
            string-ish patch.  But as you go higher on the keyboard, you
            will find that the notes become subtly brighter and more
            staccato.  This is a function of the KeyTrk: field contents,
            which is set to 8.000x.  This gives a slight decrease in
            Attack and Release times for the sound, without making it
            un-musical.  Obviously, I find the EnvCtl functions to be
            extremely valuable in making "living, breathing" patches and
            sample manipulations.






            Patch Run #2:  ASR usage.

            ASR's, on the surface, just seem like limited envelopes.
            However, the K2000 has provided a number of features that
            make the ASR's very useful for certain types of
            applications.  Select patch "[ddg] 09/02 ASR1", and hold a
            chord.  This patch has a filter that "hits" after a few
            seconds.  This is a case where the "initial delay" of the
            ASR is put to use.  Enter the patch editor, and move to the
            ASR page.  ASR1 has its trigger set to ON,which will be at
            100% whenever a note is being sounded.  The Mode: field is
            set to Hold, which means that the ASR will not loop, but
            will hold its "sustain" state until the trigger is released
            (in this case, when the note is no longer being sustained or
            pressed).  Finally, the Delay field is set to 3.00 seconds,
            the delay time required before the filter hits.  At that
            point, the attack segment (which is almost immediate) will
            run, with the release segment running after the key is
            released.  Adjust some of the parameters (especially the
            Mode:, Delay: and Attack: fields) and listen to the result
            of the change.

            Patch "[ddg] 09/02 ASR2" is an example of an ASR being
            triggered by a MIDI continuous controller.  Play a note
            (this is a monophonic patch, so one note is all you get),
            and move the mod wheel slowly throughout its range.  At
            about the halfway point, a strong vibrato will swell in,
            then swell back out.  In this case, the mod wheel controls
            the triggering of the ASR, which is in turn controlling the
            vibrato.

            Again, enter the patch editor, and move to the ASR page.
            ASR1 is set to be triggered by the mod wheel, with the Mode:
            field set to Normal.  Whenever you are using a continuous
            controller as a trigger, it will "fire" the ASR once the
            controller reaches its halfway mark.  Hence, we've just
            turned the mod wheel into a big round switch!

            Also, in this patch, the Normal Mode is used, which has no
            sustain.  Once the attack segment is complete, the Release
            segment begins immediately.  This is really useful for "one
            shot" effects -- like a filter hit or pitch shift.  This
            patch also is an example of another principle,  the ASR
            ignoring the EnvCtl parameters.  If you adjust the Data
            Slider on your K2000 (or the equivalent controller for you
            rack-mounters),  you will notice that the attack stage of
            the amplitude and filter envelopes change drastically.
            However, if you adjust the mod wheel, you should notice no
            change to the speed at which the vibrato swells in and out.
            This is one of the times when you *have* to use an ASR --
            when the EnvCtl parameters are so radical that they would
            change the behavior of an effect.





            Select patch "[ddg] 09/03 ASR3" and hold down a key.  This
            is one of the ambient, Orb-style beep-bloop patches, with
            things swirling about the ether with its own sense of time.
            In this case, I'm using an LFO for its cyclical nature, but
            I'm also using two ASR's.  Why?  Because and ASR can be
            triggered by anything, where a normal envelope can only be
            triggered by a keypress.  Look at the ASR page, and see what
            I've done.  In this case, I have both ASR's triggered by
            LFO2 (a global LFO in this case).  When the LFO exceeds its
            halfway point, it will trigger both ASR's, which will send
            individual pulses to the AMP or filter data.  This is an
            example of ASR's providing functions the normal envelopes
            just can't touch.





            Patch Run 3: VTrig setup

            Patch "[ddg] 09/03 VTrig1" is a monosynth emulation that has
            a velocity sensitive tremolo.  Hit it hard, it trems ...
            softer it does not.  If you look at the AMP page, the SRC2
            control source is set to LFO1, but its depth is also
            controlled by VTrig1.  Move to the VTrig page, and note that
            VTrig1 is set to "turn on" at any velocity greater than f
            (moderately hard).  This type of VTrig usage is typical for
            many patches, and can add great expressiveness to a sound.

            Select patch "[ddg] 09/03 VTrig2" and hit a few chords at
            various velocities.  Note that the sound of the patch
            changes significantly at each velocity level.  Enter the
            patch editor and check the PITCH, F1 FRQ, F2 RES, AMP and
            EnvCtl pages.  You will see that I have VTrig modulation
            used on all of these.  Now, move to the VTrig page and check
            out the setup I've created.  First, I have VTrig 1 set up to
            as a normal trigger (meaning it is normally OFF), but set to
            trigger on any velocity above p (moderately soft).  VTrig 2
            is set to Reversed triggering (normally ON), with the
            trigger set to shut of at any velocity greater than f
            (moderately hard).  This layering of normal and reversed
            triggers gives a surprisingly varied response to the sound,
            and is useful for patches that need "pseudo random" velocity
            handling.






            That's all for this tutorial.  Hope it provided you with
            some new information.  If you want to get in touch with me,
            just send me e-mail at:

            ddg@wi.rr.com

            Thanks, and good-bye for now!