

                             MusicBox Version 2.12PD

               COPYRIGHT (C) 1986 John Dunn, All Rights Reserved 
                 Entered into the Public Domain, March 20, 1988


     Use and copying of this software and documentation, and preparation
     of derivative works based upon this software and documentation are
     permitted.  Any distribution of this software or derivative works
     must comply with all applicable United States export control laws.

     This software is made available AS IS, and the author makes no
     warranty about the software, its performance, or its conformity to
     any specification.


    Table of Contents:

         Overview. . . . . . . . . . . . . . . . . . . . . . . . .  2
         Getting Started . . . . . . . . . . . . . . . . . . . . .  3
         MENU Commands . . . . . . . . . . . . . . . . . . . . . .  5
         General Information . . . . . . . . . . . . . . . . . . .  8
         Hexadecimal Numbers and Boolean Logic . . . . . . . . . . 11
         Tutorial. . . . . . . . . . . . . . . . . . . . . . . . . 14

         SWITCH Modules. . . . . . . . . . . . . . . . . . . . . . 20
         INDEX Modules . . . . . . . . . . . . . . . . . . . . . . 22
         MATH Modules. . . . . . . . . . . . . . . . . . . . . . . 25
         LOGIC Modules . . . . . . . . . . . . . . . . . . . . . . 27
         SEQUENCE Modules. . . . . . . . . . . . . . . . . . . . . 29
         MIX Modules . . . . . . . . . . . . . . . . . . . . . . . 32
         PROGRAM Modules . . . . . . . . . . . . . . . . . . . . . 34

         CLOCK Modules . . . . . . . . . . . . . . . . . . . . . . 36
         TRIGGER Modules . . . . . . . . . . . . . . . . . . . . . 41
         ONESHOT Modules . . . . . . . . . . . . . . . . . . . . . 44
         TEST Modules. . . . . . . . . . . . . . . . . . . . . . . 47
         RANDOM Modules. . . . . . . . . . . . . . . . . . . . . . 49
         PATTERN Modules . . . . . . . . . . . . . . . . . . . . . 53
         MIDI Modules. . . . . . . . . . . . . . . . . . . . . . . 57

         DISPLAY Modules . . . . . . . . . . . . . . . . . . . . . 62
         SLEW Modules. . . . . . . . . . . . . . . . . . . . . . . 64
         SAMPLE Modules. . . . . . . . . . . . . . . . . . . . . . 67
         BOUNDS Modules. . . . . . . . . . . . . . . . . . . . . . 69
         OCTAVE Modules. . . . . . . . . . . . . . . . . . . . . . 71
         SPECIAL Modules . . . . . . . . . . . . . . . . . . . . . 72
         SYSTEM Modules. . . . . . . . . . . . . . . . . . . . . . 75














                                    1



    ======================================================================
                                  OVERVIEW

         MusicBox was designed to be a flexible, open-ended working
    environment that is particularly suited to developing original
    material.  Although the software is capable of recording incoming
    MIDI data, it is not intended to be used as a MIDI recorder. MusicBox
    is compatible with conventional hardware and software sequencers, and
    works well with them.  But it is conceptionally different from them
    because it is a composition tool rather than a recording and
    arranging tool.

         While MusicBox is unlike anything currently available on the
    MIDI marketplace, it will be instantly recognizable to anyone who has
    used a modular synthesizer.  The program consists of an abbreviated
    menu, a multi-page workspace, and a "toolbox" of some 150 different
    computation functions, graphically represented as function "modules",
    complete with output and inputs.

         Like the big analog synthesizers, programming MusicBox is a
    matter of patching the outputs of modules to the inputs of other
    modules.  Unlike the analogs, there are no patchcords to fuss with,
    patches are automatically labeled as they are made, and since the
    computer is perfectly willing to make multiple copies of the modules,
    there are always enough of them.

         MusicBox is process oriented as opposed to the more traditional
    score or data orientation.  This means that rather than playing back
    notes that have been previously entered as a score or a MIDI
    recording, MusicBox calculates notes "on the fly".  Composing with
    MusicBox is an iterative process, of first making a simple "patch"
    (grouping of modules), then expanding it, refining it, and
    integrating it with other patches.

         Although MusicBox is designed as a MIDI output controller, it
    can be used for non-MIDI and even non-musical applications.  The
    chapter on "SPECIAL" modules describes tools that allow use of
    MusicBox as a non-specific process control program.

         MusicBox is not a particularly efficient approach for composing
    with a single instrument.  It is intended to be used with a large
    number of MIDI instruments playing simultaneously, such as a TX816
    rack.  In this context, MusicBox becomes both powerful and elegant,
    giving the composer the ability to quickly move from control of the
    overall sound of the electronic orchestra to an individual parameter
    of a single instrument.

         Like most musical instruments, MusicBox will allow subtle,
    interesting music only in proportion to the investment made in
    acquiring skill in its use.  It is not an easy instrument to learn.
    It is not possible to learn at all without reading the manual.  The
    most interesting modules are not intuitive, and many of the module
    icons are cryptic.  To make matters worse, the number values are in
    hexadecimal.  The good news is that once learned, MusicBox gives the
    composer a degree of control and agility in working with complex
    musical events that is simply not available with more conventional
    approaches.





                                    2



    ======================================================================
                             GETTING STARTED


    Hardware required:

         512K IBM-PC/XT/AT
         Color monitor
         Microsoft compatible mouse
         Roland MPU-401

    Computer:

         Any PC-compatible will work.  If very large compositions are
    intended, the extra speed of an AT gives added flexibility.  Must
    have 512K or more system memory.

    Color monitor:

         The EGA, or similar high resolution color display is by far the
    best choice.  While MusicBox will work with a CGA, many of these cards
    will produce objectionable "snow" due to the software's multiple fast
    screen updates.  A color monitor is absolutely necessary because the
    module functions are all color coded.

    Microsoft compatible mouse:

         Any mouse that includes a Microsoft compatible mouse driver and
    has two or more pushbuttons should work.  The Microsoft compatable
    mouse driver must be present for the program to run properly.  This
    is software that will have been supplied with your mouse.  If you
    use the Microsoft internal mouse card, set the jumper to location 3.

    Roland MPU-401:

        MusicBox will work fine with one MPU or compatable, but it also
    will support a second MPU, giving a total of 32 MIDI channels. The
    2nd MPU must be jumpered properly for the 2nd MPU port.  Remove MPU
    cover.  Cut jumper tracing to port 1, and solder in tracing to port
    2.  Only use one MPU-PC interface card.  Connect the MPU's in
    parallel to the one "D" connector at the computer card.  Use a ribbon
    cable with one "D" connector for the computer at one end and two "D"
    connectors for the MPUs at the other end, separated by a few inches.

    Software installation:

         After running the install program, INSTALL.COM, you should have
    a copy of MB.EXE, which is the MusicBox program.  This is normally
    the only file you need to run MusicBox.

         Before attempting to run MusicBox, be sure you have installed
    the Microsoft compatible driver for your mouse.  If this driver is
    not present MusicBox will not run.

         To make the task of learning MusicBox a little less formidable,
    you should initially run MB from a directory that contains the
    tutorial screen file TUTOR.SCR.  This is a overlay to the Page 0
    toolbox screen, with all but a few of the modules subdued.  If
    TUTOR.SCR is not in the current directory when MB is first run, the
    normal toolbox screen will appear.


                                    3




         From a directory that contains the file TUTOR.SCR, run MusicBox
    by typing "MB". Once MusicBox has signed on, you will be presented
    with a screen of 21 labeled blue boxes, and a square blue mouse
    cursor toward the center of the screen. Each box contains one or two
    white icons, and several dark grey icons.  Ignore the dark grey icons
    for now.  They are modules that have been inactivated by TUTOR. Thier
    icons remain onscreen to help in identifying the positions of the
    active modules.

         The Tutorial section of this manual contains step by step
    directions for four simple patches.  Try them out, then continue to
    work with the TUTOR overlay, referring all the while to the module
    documentation in the latter part of this manual.  By the time you
    have used each of the 32 modules in TUTOR, you will be ready to
    remove TUTOR.SCR from your working directory, and to tackle the full
    complement of over 150 MusicBox modules.













































                                    4



    ======================================================================
                                MENU COMMANDS

         MusicBox uses two sets of menus.  The working menu that is
    available on the left margin of all work pages and the file menu that
    is only on page 0.

    ----------------------------------------------------------------------
                           Working Menu Commands

    0-7       Change display page. With the EGA, all 8 pages are available,
              with the CGA, only pages 0-3 can be used.  The highlighted
              number indicates the current page number, the highlighted
              arrow indicates the page that will be switched to when
              mouse button #2 is pressed. Except for page 0, the module
              source page, all display pges are equal, and modules may be
              moved from page to page, even while running, without
              restriction.

    ESC       Escape from pending command.  This command will kill any
              pending (highlighted) command.  It may be used at any time.

    DEL       Delete a module.  Any module may be deleted at any time,
              even when other modules are connected to it.  To use,
              select DEL, then select the module to be deleted.  The
              module is actually "put to sleep", rather than deleted, so
              that other modules that are connected do not get confused
              (the last values of the deleted module will remain
              constant).  The module source icon on page 0 is marked with
              "X" to indicate that this module is available to be
              "reincarnated". Upon reincarnation, all values are reset to
              zero, but connections from other modules, if any, will
              remain intact. On page 0, DEL is used to delete files.
              Select, then select a file in the Name area. The selected
              file is deleted.

    SET       Write current workspace to the hidden temporary file. Used
              with REDO, which restores the workspace to the last SET, and 
              SWAP, which swaps the workspace to the last SET or SWAP.

    HLT       Halt modules, much as if an Alpha halt signal was given.
              (See SYSTEM chapter for info on the Alpha module.)  Select 
              again to continue. 

    OFF       Issue "All Notes Off" on all MIDI channels.  Also puts all
              channels in Omni-off/Poly-on mode.

    Measure Readout:  Display (in decimal) the current measure count.
              This is reset by the Hold input of Alpha module, described
              in the chapter on System modules.

    Elapsed Time:  Display (in seconds, in decimal) the elapsed time
              since the last Alpha module Hold.

    Decimal Readout:  When module input values are changed with the
              mouse, this readout changes to high intensity color and
              becomes a decimal readout of the module input, which is
              displayed at the module in hexadecimal.




                                    5



    Note Value Readout:  When module input values are changed with the
              mouse, this readout changes to high intensity color and
              becomes a note readout.  It assumes C major scale
              ascending, with Octave 5 = Middle C, which is MIDI value 3C
              hex, 60 decimal.

    Mute Flags:  The 16 numerals set/clear a 16 bit word that is
              accessible through the Mute Flag module, in the SPECIAL
              box. When a numeral is highlighted, its corresponding flag
              is TRUE. Although these flags can be used as general ON/OFF
              logic switches, they are optimized for controlling the MIDI
              Note Output module in the MIDI box.  Used as such, when the
              numerals are highlighted the modules are "on", allowing the
              them to pass MIDI data.  The colon separating each pair of
              numerals can be used to set/clear both at once.  Default
              operation is as a bank of mute switches, each time one of
              the numerals is selected by the mouse, its on/off state is
              reversed. Setting the Mute/Solo input of the Alpha module
              will change the action to solo switches: each time a
              numeral is selected, that flag is turned on, and all others
              are turned off.

    ----------------------------------------------------------------------
                              File Menu Commands

    QUIT      Exits MusicBox without saving the workspace. Double click.

    EXIT      Does an auto SAVE, then exits.  Double click.

    MPAB      Flags to load Module, Program, or Sequencer A or B data.
              Although the Save command only makes one file, the file is
              composed of the four sections given above.  All sections
              are always saved, but you can load selectivly by selecting
              the flags.  Only the sections that correspond to a
              highlighted letter will be loaded.  Default is all four
              flags ON and highlighted, entire workspace is loaded.

    SWAP      Swap current workspace with temporary file.

    REDO      Restore the current workspace with the temporary file.
              Current workspace is lost, temporary file is unchanged.

              Both SWAP and REDO are used in conjunction with the SET 
              command, which saves the current workspace to the (invisible) 
              temporary file.  Upon startup, MusicBox will do an auto SET, 
              so the first REDO, prior to a SET or SWAP will clear the 
              workspace.  If SWAP was used, a second SWAP will restore to
              the original workspace.  Both require double click.

    SAVE      Save the entire workspace, using the current filename and
              the current directory.  If a there is a name conflict, the
              old file will be renamed to PREVIOUS.  The old PREVIOUS, 
              if it exists, is overwritten.  Requires double click.

    TEMP      This is the current filename.  It is changed by selecting
              the area with the mouse, then writing the new name with
              the console keyboard.  Requires double click.





                                    6



    Path area changes directory and/or disk drive.  Select with the
              mouse, then use the console keyboard to type in a letter to
              change drive, a backlash and name to change directory, or
              a full pathname to change both.

    Name area is a directory of the MB files in the selected directory.
              Selecting any name with the mouse will load that file
              into the workspace.  The grey number is the remaining disk
              space expressed in MB files.  When 0, SAVE is disabled.





















































                                    7



    ======================================================================
                             GENERAL INFORMATION

    Mouse Control:

         All commands are initiated by positioning the mouse cursor over
    the area of interest, and pressing the LEFT mouse button.  The RIGHT
    mouse button is used only to swap display pages.

    Creating Modules:

         Select a module to be created by placing the mouse cursor over
    the white label on the page 0 source screen.  When the left mouse
    button is pressed and released the module will appear.  Pressing the
    button again causes it to disappear, to allow the modules to be
    examined without committing to create them.  With the module "on",
    switch to any page other than page 0, position the module as desired,
    and press the left button.  The module will be deposited, and is
    automatically activated.

    Moving Modules:

         Place the cursor over the white label of the module to be moved.
    Press and release the left button to "pick up" the module.  Drag the
    module to the new position, either on the current page or on another
    page (changing pages while dragging the module is permissible), press
    and release left button to deposit.

    Color Conventions:

         Each module is represented on page 0 by its white label icon and
    the current module number.  Up to 16 copies of a module may be
    created.  Modules are actually representations of assembly language
    functions which take any number of input parameters, and return only
    one output value.  Thus, modules have a variable number of inputs,
    but only one (or none) outputs.  Various parts of the modules are
    color coded:

         White:  Label and handle.  Use the label to pick up a module, to
               move it to a new position.

         Grey:  Module calculation priority.  Sometimes the order in
              which the modules are calculated is important.  For
              example, the MIDI output module should be the last module
              calculated for a given voice, or a double note may be
              heard.  Priority can be swapped by selecting the gray
              priority label (it will highlight to bright white), then
              selecting the priority label of any other module.

         Cyan:  Module output. Selecting the cyan output label will flag
              the module's output to be the next selected input.
              Selecting the output the a second time (double-clicking) 
              will highlight all inputs on all work pages that are 
              presently connected to that output.

         Blue:  Module input.  Input can be of two kinds, direct values
              or output from other modules.  If an input is selected
              while a module output is active (the output label will be
              highlighted), the input becomes connected to the flagged
              module's output.  The input will label itself with the


                                    8



              output module's label icon, and turn green to indicate that
              input is now from that module. If input is selected when
              there is no active module output, the input will highlight
              to bright blue, and left/right mouse movement will "dial
              in" the input value.  Releasing the mouse button removes
              the highlight, and "sets" the value.

         Yellow:  Yellow is used for information labeling, and is not
              affected by the mouse.

         Red:  Also used only for information.  Red is used like a panel
              light, usually to indicate a non-zero value.

         Magenta:  User input.  Similar to blue inputs, but can only be
              changed by direct input from the mouse.

    Logic State Conventions:

         Throughout MusicBox, numerical values also can be used as logical
    values, or as ON/OFF states.  The convention used is:

         zero         = Logical FALSE = switch/flag/state OFF
         any non-zero = Logical TRUE  = switch/flag/state ON

         Although Logical TRUE is anything other than zero, most modules
    that return a logic state will return 1 for TRUE.

    Output Icon Conventions:

         The yellow icon labels to the left of the cyan output values
    are either an arrow pointing left, or an equal sign. The left arrow
    implies the output is a value, usually in the range of 0 - FF hex.
    The equal sign implies the output is a Logical State, TRUE or FALSE.
    Modules with the equal sign output icon will also have a red diamond
    preceding the white label tag. This will become highlighted if the
    value is TRUE, and will be low intensity if the value is FALSE, much
    like a LED panel light.

























                                    9



    Input Icon Conventions:

         Many module inputs perform similar functions, which makes it
    possible to follow a standard set of conventions for input labeling.
    There are exceptions, and there are instances of similar but not
    identical input functions.  These will be identified in the
    individual module documentation.  As a general but not absolute rule,
    the following conventions apply:

         Value (right arrow): General value input.  This is usually the
              "main" input that will be worked upon in some way by the
              module.

         Clock (heart): Clock input.  The module will not calculate a new
              output until the next clock cycle.  A clock cycle is
              defined as a zero value (OFF) followed by any non-zero
              value (ON).  Once the ON is detected, the module will wait
              for an OFF value followed by another ON before performing
              the next output calculation.

         Strobe "!": Do it.  Same as the Clock input, but is usually more
              of a one-time action than a repeated cycle.

         Hold (check):  Reset/Hold input.  If the input is ON, the module
              will ignore further Clock inputs.  Many modules will also
              reset the output either to 0 or to the value at the ARROW
              input.  The Hold input of the Alpha module is a global
              hold, with non-zero causing all other active modules with a
              Hold input to act as if they had also received the Hold.

         Offset "+": Offset to value.  The value at this input will be
              added to the output.  The addition will wrap around. That
              is, if the sum is greater than the FF hex value limit, it
              will assume an imaginary limit of 1FF hex, with only the
              two least significant digits showing.  This means that the
              values 80 hex to FF hex can be seen as negative offsets.
              FF hex is equivalent to -1, FE hex to -2, and so on.

         Number "#": Often used as a "magic number" value.

         Count "c": Number of counts per cycle.  Usually used to divide
              down an internal or external clock.

         AND "&":  Logical AND.  The output will be ANDed with the value
              at this input.  Some modules will AND another input rather
              than the output.

         Scale "%": Scale the output with this value.  This is a
              hexadecimal percentage, with 80% hex equal to 50% decimal.
              40% hex is equal to 25% decimal, and C0% hex is equal to
              75% decimal.

         Write protect (omega): Used in modules that write to memory.
              Zero inhibits writing, usually acting as a Hold for the
              module. Set to non-zero to enable memory writes.







                                   10



    ======================================================================
                    HEXADECIMAL NUMBERS AND BOOLEAN LOGIC

         Module numerical values are expressed in hexadecimal.  Although
    this system appears foreign to the uninitiated, eventually it becomes
    far more helpful than if decimal numbers were used.  This is because
    many module functions employ Boolean logic functions, which are easy
    to visualize in hexadecimal, but very difficult to visualize in
    decimal for values greater than 8.  The modules employ Boolean logic
    because it works so well in the context of musical applications.

         It is a well known observation that some of the best computer
    programmers are musicians.  One reason for this may be that the
    language of music shares many characters with the language of
    computers.  The binary number system is central to silicon based
    computers.  It also happens to be at the heart of music notation.
    Quarter notes are double eighth notes, half of whole notes.  Octaves
    are exact doublings of pitch, and so on.  The hexadecimal numbering
    system is a power-of-two system, as such it is naturally suited to
    work with the computer's binary organization.  As such, it is also
    naturally suited to work with musical organization.

         Hexadecimal ("hex") is the same as decimal but with six more
    base digits. The hex digits are: 0 1 2 3 4 5 6 7 8 9 A B C D E F. In
    hexadecimal A is the same as decimal 10, B as 11, C as 12, D as 13, E
    as 14, and F as 15.  Hex 10 is equivalent to decimal 16.  The
    advantage of hexadecimal in dealing with binary numbers is that the
    hex digits 0 to F can be expressed with exactly four binary digits.
    As will be seen later, this is what makes Boolean logic easier to
    visualize in hex than in decimal.

         Decimal  Hex  Binary

              0    0    0000
              1    1    0001
              2    2    0010
              3    3    0011
              4    4    0100
              5    5    0101
              6    6    0110
              7    7    0111
              8    8    1000
              9    9    1001
              10   A    1010
              11   B    1011
              12   C    1100
              13   D    1101
              14   E    1110
              15   F    1111


         Boolean logic is a logical arithmetic that is very useful in
    describing logical process of almost any type, from digital circuits
    to legal documents.  Boolean digits are the logical states TRUE and
    FALSE.  In MusicBox, as in most computer applications, the binary
    digit ("bit") zero represents logical FALSE, and one represents
    logical TRUE.  Boolean logic can be applied to a number in a bit-wise
    fashon, or it can be applied to the number as a whole.  When applied
    to the whole number, zero is again logical FALSE, and any non-zero
    value is logical TRUE.


                                   11




         The four principal Boolean operators are OR, AND, XOR NOT.

         Boolean NOT is a unary (requires only one argument) function
    that simply reverses the truth of the argument.

         NOT 0     NOT 1
         -----     -----
             1         0

         NOT 1011 binary       NOT B hex     NOT 11 decimal
         ---------------       ---------     --------------
             0100 binary           4 hex          4 decimal


         NOT 1011 0101 binary  NOT B5 hex    NOT 181 decimal
         --------------------  ----------    ---------------
             0100 1010 binary      4A hex         74 decimal

         Note that the binary number 10110101 can be mapped into
    hexadecimal as 1011 0101 = B5.  The NOT of 1011 0101 is 0100 1010,
    which can be directly mapped to 0100 = 4, 1010 = A, therefor 4A.  No
    such direct mapping works for decimal.

         Boolean OR is a binary (requires two arguments) function that
    states if either of two values are TRUE, the result is TRUE.

              0         1         1         0
         OR   0    OR   1    OR   0    OR   1
         ------    ------    ------    ------
              0         1         1         1

             1011       B         1011 0101         B5
         OR  0101  OR   5    OR   1000 0110    OR   86
         --------  ------    --------------    -------
             1111       F         1011 0111         B7


         Boolean AND is a binary function that states if either of two
    values are FALSE, the result is FALSE.

              0         1         1         0
         AND  0    AND  1    AND  0    AND  1
         ------    ------    ------    ------
              0         1         0         0

             1011       B         1011 0101         B5
         AND 0101  AND  5    AND  1000 0110    AND  86
         --------  ------    --------------    -------
             0001       1         1000 0100         84

         Note that the AND function can be used as logical masking tape.
    The 0's in the bottom digit are the tape, forcing the result to 0,
    regardless of the truth of the top digit; while the 1's in the bottom
    digit acts as the unmasked area, passing through the top digit
    unchanged.  Because of this, one of the arguments in the AND function
    (it does not matter which one) is often referred to as a mask, and
    the AND function itself is sometimes called a masking function.




                                   12



         Boolean XOR (exclusive OR) is a binary function that states if
    the truth of the two arguments are identical, the result is FALSE; if
    the arguments are different, the result is TRUE.

              0         1         1         0
         XOR  0    XOR  1    XOR  0    XOR  1
         ------    ------    ------    ------
              0         0         1         1

             1011       B         1011 0101         B5
         XOR 0101  XOR  5    XOR  1000 0110    XOR  86
         --------  ------    --------------    -------
             1110       E         0011 0011         33

         Note that any argument XOR'd with itself is 0, any argument
    XOR'd with 0 passes through unchanged, and any argument XOR'd with 1
    passes through inverted.

             1011      1011      1011
         XOR 1011  XOR 0000  XOR 1111
         --------  --------  --------
             0000      1011      0100








































                                   13



    ======================================================================
                                TUTORIAL
    ----------------------------------------------------------------------
         This first attempt isn't much.  It just runs a random tone
    through the PC speaker.

         1.  Place the mouse cursor over the note icon in the first row
    and the first column (position 1,1) of the CLOCK box, which is the
    middle box on the left of the screen.  Depress and release the LEFT
    mouse button.  This will "pick up" the Note Clock module.  A copy of
    the module will replace the blue square as the mouse cursor.

         2.  Press the RIGHT mouse button to go to a work page.  The
    screen will appear blank except for the menu along the left side of
    the screen.

         3.  Move the Note Clock module with the mouse to a blank spot
    somewhere toward the left of the screen.  Press the LEFT mouse button
    to deposit and activate the module.

         4.  Press the RIGHT mouse button to return to Page 0.  Move the
    cursor to the box labeled  RANDOM, toward the center of the screen.
    Pick up the Random Number Generator module, position 1,1 of RANDOM,
    and deposit it on the workpage as before.

         5.  Dial in an offset to the Random module of 30 hex, 48
    decimal.  To do this, place the square mouse cursor over the blue
    number next to the yellow "+" input label at the bottom of the Random
    module.  Press the LEFT mouse cursor and release.  The cursor will
    disappear, and the blue numbers will be highlighted.

         6.  Now moving the mouse left or right will change the number.
    While you are setting the value, look at the menu area on the left
    of the screen.  A highlighted blue set of numbers, representing the
    decimal value you are dialing in will appear about halfway down the
    menu column, and a Note/Octave readout will appear just below that.

         7.  Move the mouse to the right until the number at the module
    reads 30. The decimal readout on the left of the screen will read 48.
    Press the LEFT mouse button. The input number will freeze at the last
    value, and will return to its normal dark blue, and the square blue
    mouse cursor will reappear.

         8. Dial in a limit to the Random module of 20 hex.  The limit
    input is the up arrow just above the offset input.

         9. Connect the Note Clock module output to the Random module's
    clock input.  To do this, first place the cursor over the cyan
    (turquoise) output value near the top of the Note Clock.  Press and
    release the LEFT mouse button. The numbers will hilight, indicating
    that the output of the Note Clock module is ready to be patched into
    the input of another module.

         10.  Move the cursor to the Random module.  Place the
    cursor over the blue number next to the yellow heart.  Press and
    release the LEFT mouse button.  The input will turn green and take on
    the label of the Note Clock module (a note icon and the number 0),
    and at the same time the highlighted output of the Note Clock module
    will return to normal.  The output of the Note Clock module is now



                                   14



    patched into the clock input of the Random module.  The Random module
    will now be producing a new output between 30 hex (the offset) and 50
    hex (offset+limit) at every tick of the Clock module.

         11.  Pick up the PC Speaker Output module, located in the SYSTEM
    box, row 2, column 3 (SYSTEM 2,3).  Deposit it somewhere near the
    Random module.

         12.  Connect the Note Clock output to the PC Speaker clock
    input, as before.  You should hear a steady beat of quarter notes at
    a tempo of about 120.

         13.  Connect the Random output to the PC Speaker value (arrow)
    input.  Now you should hear random tones.

         14.  Try altering the note value input and the sustain input of
    the Clock module, which are labeled with a note and an "s",
    respectively.  Also try changing the limit and offset inputs to the
    Random module.  You can turn the thing off by dialing a number into
    the hold (check) input of the Note Clock, or by the menu HLT command.










































                                   15



    ----------------------------------------------------------------------
         This next patch assumes a MIDI synthesizer connected to your
    computer and MPU.  It further assumes the synthesizer is set to
    receive on MIDI channel 1.  The patch will play an arpeggiated C
    Major chord, still random but slightly more controlled.

         1.  If the other patch is still on, get rid of it by selecting
    REDO (twice) from the Files Menu on page 0.

         2.  Fetch a Note Clock module (CLOCK 1,1), and Random module
    (RANDOM 1,1), as before.  Also as before, connect the Note Clock
    output to the Random clock (heart) input.

         3.  Set the limit (up-arrow) input to the Random module to 4.
    It should now be generating random numbers between 0 and 3.

         4.  Fetch a Switch/Sequencer module (SWITCH 1,3).  Into the
    inputs labeled "1", "2", and "3", dial the values 4, 7, and C hex.
    This gives the intervals in semitones of 0, 4, 7, and 12: a major
    triad.

         5.  Connect the Random output to the address "@" input of the
    Switch/Sequencer module.  This effectively translates the random
    numbers 0-3 to the interval numbers 0, 4, 7, and C hex.

         6.  Fetch a MIDI Note Output module (MIDI 1,1).  Activate it by
    setting the mute input (second blue input from top, looks something
    like "/o/") to 1.  Dial 30 hex (octave C4, 1 8ve below middle C) into
    one of the transpose "t" inputs.

         7.  Connect the Switch/Sequencer output to the first note value
    "A" input of the MIDI module, then connect the Note Clock output to
    the first note velocity "a" input.  At this point you should be
    getting a sound, but it will probably be very faint.  Even if there
    is no sound yet, go on to the next step.

         8.  Set the sustain "s" input of the Note Clock module to 80
    hex.  This gives a half on, half off cycle.  Set the velocity value
    "v" input to the Note Clock module to about 40 hex.  The sound should
    be ok now.  If not try a few different patches on your synth.

         9.  If you are not getting sound from your synth at this point,
    first check that you have made the MusicBox connections according to
    the steps given here.  If you are sure they are correct, check that
    your synth is functioning properly, and that it is properly connected
    to the computer through the MPU.  If all else fails, try running the
    install program again.  You might have forgotten to install it with
    MIDI output enabled.

         10.  Assuming you have sound, now make it a little more
    interesting.  First, speed up the clock from quarter notes to eighth
    notes by changing the note value (note label) input of the Note Clock
    from 3 to 4.









                                   16




         11.  Fetch the Dither Switch module (RANDOM 2,2).  Connect the
    Note Clock module output to the clock (heart) input.  Set the dither
    value "%" input to 40 hex, which is equivalent to 25%.  Set the value
    input to 18 hex, 24 decimal.  Now connect the Switch/Sequencer module
    output to the offset "+" input.  You can't hear it yet, but the
    Dither module is bumping the arpeggiated triad up two octaves 25% of
    the time.

         12.  Connect the output of the Dither module into the "A" input
    of the MIDI Note module.  This replaces the patch that was from the
    Switch/Sequencer.  It probably will sound awful.

         13.  What is happening, is the module calculation priority is
    out of order.  The MIDI Note Output module is seeing the Dither
    module output a full cycle AFTER it has already seen the Note Clock
    output. This causes it to play the note at the old pitch for the out
    of sync cycle, which gives a 64th note glitch.

        14.  Fix it by swapping priority with the Dither module.  Select
    the priority number (the grey number between the white label icon and
    the cyan output number) of the Dither module -- it will highlight to
    bright white, then select the priority of the MIDI module.  The
    priority numbers will swap, and the glitch will go away.  In general,
    you will want to have the MIDI Note Output module as the last in the
    calculation chain for a particular voice.

         16.  Set up to mute the module from the menu.  Fetch the Mute
    Flag module (SPECIAL 3,3).  Connect it to the mute input ("/o/") of
    the MIDI Note Output module.  The sound will stop.  Set the mute mask
    "&" input of the MIDI Note module to 1, and set the mask input of the
    Mute module to FF hex.  Now selecting the yellow mute switch "0" in
    the lower left of the menu will turn the voice on and off.

         17.  Save the patch by selecting SAVE from the page 0 File Menu.
    The file will be named TEMP, which is the default filename, and it
    will immediately show up in the file area below the File Menu.

         18.  If you saved the patch with the sound on, you can bring it
    up and running from DOS by running MB with the filename.  From the
    DOS command line, typing "MB TEMP".  MusicBox will come on, then
    load the file and play it.




















                                   17



    ----------------------------------------------------------------------
         This next patch assumes you have two MIDI synthesizers, or one
    synthesizer with two voices.  One voice is set to MIDI channel 1, the
    other to MIDI channel 2.  It will be a variation of the previous
    patch with the 2nd voice a delayed version of the first.  If you have
    a stereo setup, send one voice to the left speaker and one to the right.

         1.  Load the previous patch by selecting (twice) the name
    ("TEMP", unless you changed it) from the File Load area below the
    Page 0 File Menu.

         2.  Fetch the Echo module (SAMPLE 1,1).  Connect the Note Clock
    module output to the clock input.  Connect the Dither module output
    to the value (arrow) input.  The output should be the same as the
    Dither module output.

         3.  Fetch another MIDI Note Output module (MIDI 1,1).  Set the
    MIDI channel "c" input to 1 (if you have an instrument receiving on
    channel 2).  Note that MIDI channels are numbered from 1 to 16,
    whereas the funny numbers we use here are from 0 to F.

         4.  Set one of the transpose "t" inputs to 30 hex.  Set the mute
    mask "&" input to 2.  Connect the Mute module output to the mute
    "/o/" input.  Connect the Echo module output to the 1st note value
    "A" input.  Connect the Note Clock output to the 1st note velocity
    "a" input.

        5.  Set the Menu Mute switches 0 and 1 to ON (highlighted).
    There should be essentially the same sound coming from both voices.
    You can switch back and forth between the voices by turning one Menu
    Mute off, then selecting the colon between the two numbers.  One will
    go on while the other goes off.  When you get tired of this, set both
    voices ON.

         6.  Set the delay ">>" input of the Echo module to 5.  You
    should now be hearing an echoed pattern, most noticeable on the
    dithered octave kicks.

         7.  Fetch two MIDI Control Output modules (MIDI 2,1).  Set the
    MIDI channel "c" input of the 2nd module to 1.  Set the hold (check)
    input of both modules to 0.  You probably will hear a change in
    sound, as the module sends its default parameters out.

         8.  Select two Step Pushbutton modules (ONESHOT 3,3).  Connect
    the output of each into the corresponding program change "Pt" input
    of the MIDI Control modules.  Change patches on your synth by
    stepping the switches up and down.

        9.  Swap priority with the MIDI Note Output modules and the
    Step Pushbutton modules, to keep the MIDI output at the end of the
    calculation chain.

         10.  Save the patch.  First select the WHITE filename (should be
    "TEMP", unless you saved the previous patch under another name) in
    the File Menu area.  The area will go blank.  Type in the name of
    your choice, and press the Enter key.  With the mouse, select SAVE
    (twice).  The file now should appear in yellow in the Load area.





                                   18



    ---------------------------------------------------------------------
         And now for something completely different.  This is a simple
    little polyrhythm patch, right out of Schillinger.  Again, it assumes
    you have two MIDI synthesizers, or one synthesizer with two voices,
    with one set to MIDI channel 1, the other to MIDI channel 2.

         1.  If the workspace is not already clear, clear it with REDO.  
    Fetch the Mu Clock module (CLOCK 3,1).  Set the count "c" input to 6.

         2.  Fetch two Beat Pattern Generator modules (TRIGGER 2,1).
    Connect the Mu Clock output to the clock inputs.  Set the cycle "c"
    inputs of the first to 3, 5, 8, and C hex.  Set the second to 4, 6,
    7, and C hex.

         3.  Fetch the Mute Flag module (SPECIAL 3,3) and then fetch two
    MIDI Note Output modules (MIDI 1,1).  Set the channel "c" input of
    the 2nd Note module to 1.

         4.  Connect the Mute Flag module to the mute input ("/o/") of
    the MIDI Note Output module.  Set the mute mask "&" input of the MIDI
    Note modules to 1 and 2, respectively and set the mask input of the
    Mute module to FF hex.

         5.  Set the 1st note value "A" inputs of both MIDI modules to
    about 18 hex.  Set the velocity offsets "v" to about 60 hex.  Connect
    the Beat Pattern modules to the note velocity "a" inputs of the
    respective MIDI modules.

         6.  Turn on the sound with the menu mute flags, 0 & 1.

         7.  Play with it.































                                   19



    ======================================================================
                                SWITCH MODULES
    ----------------------------------------------------------------------
    16-input Switch/Sequencer                               SWITCH 1,1   w

    Purpose: Can act as an static value sequencer or an input switch,
       or both in combination.

    General:  One of 16 inputs, selected by the Address input, is
       sent to the output.  If inputs are set to values, this will
       act as a sequencer, if inputs are connected to other module
       outputs, it will act as a switch.  The currently selected
       input is indicated by a highlighted red label reminiscent of
       the old modular sequencer stage lights.

    Output:  Unchanged copy of the selected input.

    Address "@" input:  Selects one of the 16 inputs that is to be
       copied to the output. Numbers greater than 15 are rolled over,
       so that 16 selects the first  input, 17 selects the second, 33
       also selects the second, etc.

    Stage "0-F" inputs:  Value inputs, may be connected to any source.

    ----------------------------------------------------------------------
    8-input Switch/Sequencer                               SWITCH 1,2   x
    4-input Switch/Sequencer                               SWITCH 1,3   y
    2-input Switch/Sequencer                               SWITCH 1,4   z

    General:  Identical to 16-input version, but has fewer inputs.

    ----------------------------------------------------------------------
    2-input Switch                                         SWITCH 2,1 \D6
    2-input Switch with Offset                             SWITCH 2,2 \B7

    Purpose:  Switch between two inputs.

    Output:  An unmodified copy of the selected input.

    Switch "1/2" input:  Non-zero switches output source from input "1"
       to  input "2".

    Inputs "1" and "2":  Any value.

    Input "+":  Offset value to be added to output.

    ----------------------------------------------------------------------
    Toggle Switch                                          SWITCH 2,3 \C2

    Output:  An unmodified copy of the Value input, or 0.  The red
       diamond in the label will highlight if the output of the module is
       non-zero.

    Switch "<->" input: Non-zero will cause the Value input to pass
       through to the output; zero will set the output to zero,
       regardless of the Value input.

    Value "-->" input:  Any value.




                                   20



    ---------------------------------------------------------------------
    Toggle Switch with AND Gate                            SWITCH 2,4 \D1

    Output:  An unmodified copy of the Value input, or 0.  The red
       diamond in the label will highlight if the output of the module is
       non-zero.

    AND "&" inputs:  A Boolean AND function is performed with these two
       inputs.  A result of non-zero will cause the Value input to pass
       through to the output; a zero result will set the output to zero,
       regardless of the Value input.

    Value "-->" input:  Any value.

    ----------------------------------------------------------------------
    2-input Switch with AND Gate                           SWITCH 3,1   u
    2-input Switch with AND Gate and Offset                SWITCH 3,2   v

    Output:  An unmodified copy of the selected input.

    AND "&" inputs:  A Boolean AND function is performed with these two
       inputs.  A result of non-zero switches output source from input
       "a" to  input "b".

    Switch inputs "a" and "b":  Any value.

    Input "+" (2nd module only):  Offset value to be added to output.

    ----------------------------------------------------------------------
    Latest Change                                          SWITCH 3,3 \0C

    General:  Allow the latest changed input to pass through to the
       output.

    Output:  An unmodified copy of the last input that has changed.


    Inputs "a" - "h":  Any value.  These inputs are identical, except
       that the computer tests for a change starting with the first "a"
       input, and as soon as a changed input is detected, that value is
       sent to the output, and no further processing is done during that
       calculation cycle.  Thus, if all eight inputs changed at the same
       time, each output would be sent out over the next eight
       calculation cycles, starting with "a" and ending with "h".


















                                   21



    ======================================================================
                                INDEX MODULES


    Index modules count.  They differ in the sophistication in
    controlling how the counting is to be done.  While obvious uses of
    these modules is to address sequencers and switches, they are also
    useful for other things, such as timing or pattern generation.

    ----------------------------------------------------------------------
    I-index                                                 INDEX 1,1   I

    Purpose:  Simple increment/decrement by 1 counter.

    Output:   Count of 0-FF hex.

    Clock (heart) input:  Any non-zero after zero causes the current
       output value to be incremented (or decremented, if the Up/Down
       input is non-zero).

    Hold (check) input:  Non-zero sets output to zero, count starts when
       returned to zero.

    Up/Down "+/-" input:  Increment if zero, decrement if non-zero.

    ----------------------------------------------------------------------
    J-index                                                 INDEX 1,2   J

    Purpose:  Increment by N counter.

    Output:  Count of 0-FF hex.

    Clock (heart) input:  Any non-zero after zero causes the Offset input
      to be added to the current output value (or subtracted from it, if
      the Up/Down input is non-zero).

    Hold (check) input:  Non-zero sets output to zero, count starts when
       returned to zero.

    Offset "+" input:  Added to the current output each clock cycle.
       Thus, if it is 1, the module will increment by 1; if FF hex, it
       will decrement by 1, if 2 it will increment by 2, if FE hex it
       will decrement by 2, etc.

    ----------------------------------------------------------------------
    K-index                                                 INDEX 2,1   K

    Purpose:  Increment by N counter with upper limit.  Advantage over J-
       index is that an upper limit can be set (I-index and J-index
       rollover at FF hex with no option to set an upper limit).

    Output:  Count of 0 to upper limit (or upper limit to 0).

    Clock (heart) input:  Any non-zero after zero causes the Offset input
       to be added to the current output value (or subtracted from it, if
       the Up/Down input is non-zero).

    Hold (check) input:  Non-zero sets output to zero, count starts when
       returned to zero.



                                   22



    Offset "+" input:  Added/subtracted to the current output each clock
       cycle.

    Up/Down "+/-" input:  Add Offset if zero, subtract if non-zero.

    Count "#" input:  Sets upper limit.  This number is inclusive (if set
       to 8, the count will reach 8 and not stop at 7).

    ----------------------------------------------------------------------
    L-index                                                 INDEX 2,2   L

    Purpose:  Increment by N counter with both an upper and a lower limit.

    Output:  Count of lower limit to upper limit (or upper to lower).

    Clock (heart) input:  Any non-zero after zero causes the Offset input
       to be added to the current output value (or subtracted from it, if
       the Up/Down input is non-zero).

    Hold (check) input:  Non-zero sets output to zero, count starts when
       returned to zero.

    Offset "+" input:  Added/subtracted to the current output each clock
       cycle.

    Up/Down "+/-" input:  Add Offset if zero, subtract if non-zero.

    MAX (up arrow) input:  Sets upper limit.  This number is inclusive
       (if set to 8, the count will reach 8 and not stop at 7).

    MIN (down arrow) input:  Sets lower limit.  Inclusive.

    ----------------------------------------------------------------------
    M-index                                                 INDEX 3,1   M

    Purpose:  Increment by N counter, useful as a pattern (melody)
       generator, with both an upper and a lower limit, with automatic
       reset to 3/4 of the difference between the upper and lower limits
       when counting up and to 1/4 the difference when counting down.

    General:  This modules looks like the I-index, but it is different in
       three important ways.  The first is given above; the second is
       that the upper limit is actually one more than that what is set.
       This has consequences when the upper limit is set to FF hex. The
       third difference is that changing the Up/Down input will cause a
       change in value at the next clock instead of repeating the current
       count value at the next clock.

    Output:  Count of lower limit to upper limit-1 (or upper-1 to lower).

    Clock (heart) input:  Any non-zero after zero causes the Offset input
       to be added to the current output value (or subtracted from it, if
       the Up/Down input is non-zero).

    Hold (check) input:  Non-zero sets output to zero, count starts when
       returned to zero.

    Offset "+" input:  Added/subtracted to the current output each clock
       cycle.



                                   23



    Up/Down "+/-" input:  Add Offset if zero, subtract if non-zero.

    MAX (up arrow) input:  Sets upper limit.  This number is inclusive
       plus one (if set to 8, the count will stop at 9).

    MIN (down arrow) input:   Sets lower limit.  Inclusive.

    ----------------------------------------------------------------------
    N-index                                                 INDEX 3,2   N

    Purpose:  Increment/decrement by 1 counter with an expanded range of
    16 bits, (0 - 65535 decimal, 0 - FFFF hex), rather than the usual 8
    bit range of 0 - FF hex.

    Output:   Count value shifted right by shift input.

    Clock (heart) input:  Any non-zero after zero causes the current
       output value to be incremented.

    Hold (check) input:  Non-zero sets output to zero, count starts when
       returned to zero.

    Address "@" input:  Upon receiving a Reset strobe, the module will
       reset the low 8 bits of the output to this value.

    Page (paragraph-symbol) input:  Upon receiving a Reset strobe, the
       module will reset the high 8 bits of the output to this value.
       Some sequencers can address up to 65K. These use the Address value
       as a starting low order address, and the Page value as a starting
       high order address.  It can also be thought of as 256 runs (Page)
       of 256 bytes each (Address).

    Reset strobe "!" input:  Resets the output to the values in the
       Address and Page inputs. This input is active even when the Hold
       input is non-zero.

    Shift ">>" input:  Number of shifts to perform at the output.  Each
       left shift is the same as a division by 2.  A shift value of 8
       will return the Page count.

    ----------------------------------------------------------------------
    O-index                                                 INDEX 3,3   O

    Purpose: Simple increment counter with mask output.

    Output:  Count of 0-FF hex, logically ANDed with Mask input.

    Clock (heart) input: Any non-zero after zero causes the current
       output value to be incremented.

    Hold (check) input:  Non-zero sets output to zero, count starts when
       returned to zero.

    Mask "&" input:  Logically ANDed with index count, prior to output.








                                   24



    ======================================================================
                                 MATH MODULES

    ----------------------------------------------------------------------
    Add                                                      MATH 1,1   +

    Output: Sum of the 3 "+" inputs.

    Add "+" inputs:  Any value.  Note that overflow will wrap around,
       just as Offset inputs on other modules.

    ----------------------------------------------------------------------
    Add/Subtract                                             MATH 1,2 \F1
    Add/Subtract                                             MATH 1,3   -

    Note: These two modules are identical in function.

    Output: Sum of the 2 "+" inputs minus the "-" input.

    Add "+" inputs: Any value.

    Subtract "-" input: Any value.

    ----------------------------------------------------------------------
    Multiply/Divide                                          MATH 2,1   *

    Output:  Product of first two inputs, optionally divide by the third
       input.

    Multiply "*" inputs:  The 16 bit product of the two Multiply inputs
       is internally stored to allow accurate division by the third
       input. Only the least significant 8 bits (0-FF hex) are displayed.

    Divide (divide-symbol) input:  Integer division of the product of the
       first two inputs.  Fractions are truncated.  If the input is zero,
       no action is taken.

    ----------------------------------------------------------------------
    Scale                                                    MATH 2,2   %

    Output: Scaled input plus offset. 

    Value "-->" input: Value to be scaled.

    Scale "%" input:  The hexadecimal percentage of the value input that
       will be sent to the output, with 80% hex equal to 50% decimal.
       40% hex is equal to 25% decimal, and C0% hex is equal to 75%
       decimal.  Thus, 80 hex returns 1/2 of Value input, 40 hex returns
       1/4, C0 hex returns 3/4, etc.

    Offset "+" input:  Added to results of scaled value.

    ----------------------------------------------------------------------
    Modulus                                                  MATH 2,3   /

    Output: Remainder of Value input divided by Slash input.

    Value "-->" input:  Dividend.  Any value.

    Slash "/" input:  Divisor.  No action taken if zero.


                                   25




    ----------------------------------------------------------------------
    Left Shift                                               MATH 3,1 \AE

    Purpose:

    Output:  Value input shifted, then ANDed.

    Value "-->" input: Value to be shifted.

    Shift "<<" input:  Number of shifts to perform.  Each left shift is
       the same as a multiplication by 2. Since all displayed values are
       8 bit integers, values greater than 8 are meaningless, and are
       internally normalized to 0-7.

    Mask "&" input:  Shift results are logically ANDed with this value
       before being sent to the output.

    ----------------------------------------------------------------------
    Right Shift                                              MATH 3,2 \AF

    Output:  Value input shifted, then ANDed.

    Value "-->" input: Value to be shifted.

    Shift ">>" input:  Number of shifts to perform.  Each left shift is
       the same as a division by 2.  Since all displayed values are 8 bit
       integers, values greater than 8 are meaningless, and are
       internally normalized to 0-7.

    Mask "&" input:  Shift results are logically ANDed with this value
       before being sent to the output.

    ----------------------------------------------------------------------
    Power of Two                                             MATH 3,3   ^

    Output: Input to the power of two.

    Value "-->" input:  Exponent of 2^n operation.  Since all displayed
      values are 8 bit integers, values greater than 8 are meaningless,
      and are internally normalized to 0-7.





















                                   26



    ======================================================================
                               LOGIC MODULES

    ----------------------------------------------------------------------
    AND/XOR                                                 LOGIC 1,1   &

    Output:  Logical AND of the first two inputs XORd with the third.

    Boolean AND "&" inputs:  Any value.  Since a value ANDed with FF hex
       is itself, setting one of these to FF hex effectively disables the
       AND function, leaving the module as an XOR function only.

    XOR "x" input:  Any value.  Since a value XORd with 0 is itself,
       leaving this input at 0 effectively disables the XOR function,
       leaving the module as an AND function only.

    ----------------------------------------------------------------------
    AND/Offset                                              LOGIC 1,2 \91

    Output:  Logical AND of the first two inputs, added to the third.

    Boolean AND "&" inputs:  Any value.  The two inputs are logically
       ANDed.

    Offset "+" input:  Added to the current output.

    ----------------------------------------------------------------------
    OR                                                      LOGIC 1,3   |

    Output:  Logical OR of the three Value inputs.

    Value "-->" input: Any value

    ----------------------------------------------------------------------
    Mask and Left Shift                                     LOGIC 2,1 \A9

    Output:  Binary left shift of results of the two AND inputs, useful
       to isolate a bit (mask), then to shift it into place.

    Boolean AND "&" inputs:  A logical AND operation is performed on
       these two inputs, with the results going to the shift function.

    Shift "<<" input:  Number of shifts to perform.  Each left shift is
       the same as a multiplication by 2. Since all displayed values are
       8 bit integers, values greater than 8 are meaningless, and are
       internally normalized to 0-7.
















                                   27



    ---------------------------------------------------------------------
    Mask and Right Shift                                    LOGIC 2,2 \AA

    Output:  Binary right shift of results of the two AND inputs, useful
       to isolate a bit, then to shift it into place.

    Boolean AND "&" inputs:  A logical AND operation is performed on
       these two inputs, with the results going to the shift function.

    Shift ">>" input:  Number of shifts to perform.  Each left shift is
       the same as a division by 2.  Since all displayed values are 8 bit
       integers, values greater than 8 are meaningless, and are
       internally normalized to 0-7.

    ----------------------------------------------------------------------
    Identity                                                LOGIC 2,3   #

    Purpose:  Convenience module to display or echo an input.

    Output: Unmodified copy of input.

    Value "-->" input: Any value



    ----------------------------------------------------------------------
    NOT AND                                                 LOGIC 3,1 \ED

    Output:  Logical NOT (one's complement) of the first input followed
    by a logical AND with the second input.

    NOT (circle with slash) input:  Value to be logically inverted.

    AND input: Mask value.

    ----------------------------------------------------------------------
    Negate                                                  LOGIC 3,2 \A5

    Output: 2's complement (minus) of input.

    Value "-->" input: Any value

    ----------------------------------------------------------------------
    Identity with Decimal Readout                           LOGIC 3,3 \01

    Purpose:  Convenience module to display or echo an input.

    Output: Unmodified copy of input.

    Display output: Decimal representation of the input.

    Value "-->" input: Any value










                                   28



    ======================================================================
                               SEQUENCE MODULES

    Sequencers read or write values to/from specific memory locations, by
    either random or sequential access.  The modules are entirely
    general.  They can control note values, dynamics, timing, anything at
    all.  They can be run as individual sequencers, or ganged together to
    make multiple output sequencers.

    Usually, sequencers will be driven by one of the index modules, which
    in turn is driven by a clock module.  As is true of all modules, each
    sequencer has just one output. Multiple output sequencers can easily
    be built by driving several modules with the same index module.  The
    output of the module is always an unmodified copy of the memory cell
    at the given address (or address+offset), and can be any value from 0
    to FF hex.  All memory cells are initialized to 0, so stepping
    through a sequencer that has not been programmed will result in a
    steady output of 0.

    There are 8 sequencer modules, 4 that can address a 64K memory area,
    ("A" of MPAB in the page 0 menu) and 4 which address a 4K area ("B"
    of MPAB) as one of 16 blocks of 256 bytes.  The two memory areas, "A"
    and "B" are automatically saved whenever a "SAVE" command is given.
    Individual sequences can be loaded by setting and clearing
    appropriate "MPAB" flags.  See the "MENU" chapter for details.

    Sequencer memory area "A" is also used for system exclusive loads and
    dumps; area "B" at block 15 (F hex) is used as a buffer for incoming
    MIDI data.  Both memory areas may also used to display ASCII
    characters.  See the "MIDI", "SYSTEM", and "DISPLAY" chapters for 
    details these special usages.

    ----------------------------------------------------------------------
    64K Read/Write Sequencer                             SEQUENCE 1,1   P

    Purpose:  Read from or write to memory locations within the "A"
       memory block.

    Output:  Contents of addressed memory cell.

    Address "@" input:  Current read/write address.  Since input values
       are limited to 0-FF hex (0-255 decimal), this input can address
       256 memory locations.

    Page (paragraph symbol) input:  Current high address.  Since this
       sequencer can address up to 65K, it uses Address input as a
       low order address, and the Page input as a high order address.
       Can also be thought of as 256 runs (Page) of 256 bytes each
       (Address).

    Write enable (omega) input:  A non-zero value allows writing into
       (programming) the sequencer. When ON, the Value input is written
       into the memory cell addressed by Address and Page, when OFF
       (zero), the memory cell can be read. Be careful with this input,
       inadvertently setting it ON will clobber existing data.

    Value "-->" input:  Only meaningful while programming the module,
      this is the value that will be written to the currently addressed
      memory cell when the write enable input is non-zero.



                                   29



    Write mask "&" input:  Only meaningful while programming the module.
       Allows individual bits in a given memory cell to be written
       without affecting the other bits.  Only bits set ON at this input
       are written to the addressed memory cell, with the value of the
       bits taken from the Value input.  This input can be effectively
       disabled by setting it to FF hex (the default), all bits ON.  When
       set to zero, the input acts as a second write protect.

    ----------------------------------------------------------------------
    256-step Read/Write Sequencer                        SEQUENCE 1,2   p

    Purpose:  Read from or write to memory locations within the "B"
       memory block.

    Magenta User Input (just left of label tag):  Current 256-step run.
       There are 16 sequencer runs available.  This input is used to
       manually set the desired run, 0-F hex.

       Note that run 15 (F hex) is used by the MIDI Data Input module as
       an input buffer.  See chapter "SYSTEM" for details.

    Output:  Contents of addressed memory cell.

    Address "@" input:  Current read/write address.  Since input values
       are limited to 0-FF hex (0-255 decimal), this input can address
       256 memory locations.

    Write enable (omega) input:  A non-zero value allows writing into
       (programming) the sequencer. When ON, the Value input is written
       into the memory cell addressed by Address and Page, when OFF
       (zero), the memory cell can be read. Be careful with this input,
       inadvertently setting it ON will clobber existing data.

    Value "-->" input:  Only meaningful while programming the module,
      this is the value that will be written to the currently addressed
      memory cell when the write enable input is non-zero.

    Write mask "&" input:  Only meaningful while programming the module.
       Allows individual bits in a given memory cell to be written
       without affecting the other bits.  Only bits set ON at this input
       are written to the addressed memory cell, with the value of the
       bits taken from the Value input.  This input can be effectively
       disabled by setting it to FF hex (the default), all bits ON.  When
       set to zero, the input acts as a second write protect.


















                                   30



    ---------------------------------------------------------------------
    64K Read-only Sequencer                              SEQUENCE 2,1   Q
    64K Read-only Sequencer                              SEQUENCE 2,2   R
    64K Read-only Sequencer                              SEQUENCE 2,3   S

    Purpose:  Read from memory locations within the "A" memory block.

    Output:  Contents of addressed memory cell.

    Address "@" input:  Current read/write address.  Since input values
       are limited to 0-FF hex (0-255 decimal), this input can address
       256 memory locations.

    Page (paragraph symbol) input:  Current high address.  Since this
       sequencer can address up to 65K, it uses Address input as a
       low order address, and the Page input as a high order address.
       Can also be thought of as 256 runs (Page) of 256 bytes each
       (Address).

    Read Address Offset (up-down arrow) input:  Number of steps away from
       current address to read output data from. No effect when set to 0.

    ----------------------------------------------------------------------
    256-step Read-only Sequencer                         SEQUENCE 3,1   q
    256-step Read-only Sequencer                         SEQUENCE 3,2   r
    256-step Read-only Sequencer                         SEQUENCE 3,3   s

    Purpose:  Read from or write to memory locations within the "B"
       memory block.

    Magenta User Input (just left of label tag):  Current 256-step run.
       There are 16 sequencer runs available.  This input is used to
       manually set the desired run, 0-F hex.

    Output:  Contents of addressed memory cell.

    Address "@" input:  Current read/write address.  Since input values
       are limited to 0-FF hex (0-255 decimal), this input can address
       256 memory locations.

    Read Address Offset (up-down arrow) input:  Number of steps away from
       current address to read output data from. No effect when set to 0.




















                                   31



    ======================================================================
                                 MIX MODULES
    ----------------------------------------------------------------------
    Adder Switch (high nybble control)                        MIX 1,1   a
    Adder Switch (high nybble control)                        MIX 2,1   c

    Purpose: Switch and/or add offsets.  Optimized to be used with the
       Program module output.

    Output: Sum of all highlighted "+" inputs.

    Value "+" inputs: When highlighted, the value at these inputs are
       added and sent to the output.

    Switch input:  Selects which of the four "+" inputs will be active.
      The most significant 4 bits (high nybble: 10, 20, 30, 40 hex) at
      this input control which value inputs will be summed and sent to
      the output.  For example, 10 hex turns the first input on (the "+"
      will highlight, and the value will be sent to the output), 20 hex
      turns the 2nd input on, and 30 hex turns on both the 1st and the
      2nd inputs, causing the sum of the two to be sent to the output.

    ----------------------------------------------------------------------
    Adder Switch (low nybble control)                         MIX 1,2   b
    Adder Switch (low nybble control)                         MIX 2,2   d

    Purpose: Switch and/or add offsets.  Optimized to be used with the
       Program module output.

    Output: Sum of all highlighted "+" inputs.

    Value "+" inputs: When highlighted, the value at these inputs are
       added and sent to the output.

    Switch input:  Selects which of the four "+" inputs will be active.
      The least significant 4 bits (low nybble: 1, 2, 3, 4) at this input
      control which value inputs will be summed and sent to the output.
      For example, 1 turns the first input on (the "+" will highlight,
      and the value will be sent to the output), 2 turns the 2nd input
      on, and 3 turns on both the 1st and the 2nd inputs, causing the sum
      of the two to be sent to the output.

    ----------------------------------------------------------------------
    Adder Switch (shift nybble control)                       MIX 3,1   e
    Adder Switch (shift nybble control)                       MIX 3,2   f

    Purpose: Switch and/or add offsets.

    Output: Sum of all highlighted "+" inputs.

    Value "+" inputs: When highlighted, the value at these inputs are
       added and sent to the output.

    Switch input:  Selects which of the four "+" inputs will be active.

    Shift ">>" input:  Shift switch input right.  Setting this to 4 shifts
       the high 4 bits of the switch input to the low position.  Used to
       allow a single 8 bit value to control two Adder Switches.




                                   32



    ---------------------------------------------------------------------
    Adder Switch (8-input)                                    MIX 3,3 \F0

    Purpose: Switch and/or add offsets.

    Output: Sum of all highlighted "+" inputs.

    Value "+" inputs: When highlighted, the value at these inputs are
       added and sent to the output.

    Switch input:  Selects which of the eight "+' inputs will be active.

    ----------------------------------------------------------------------
    Sum                                                       MIX 1,3 \E4

    Output:  Sum of the 5 Value inputs, scaled and offset by the
       respective inputs.

    Value "-->" inputs:  Any value.  These inputs are added as 16 bit
       integers to avoid overflow.


    Scale "%" input:  Scale the 16 bit sum of the Value inputs with this
       value.  This is a hexadecimal percentage, with 80% (hex) equal to
       50% (decimal).  40% (hex) is equal to 25% (decimal), and C0% (hex)
       is equal to 75% (decimal).

    Offset "+" input:  Added to the current output.

    ----------------------------------------------------------------------
    Mixer                                                     MIX 2,3 \EE

    Output:  Sum of the 3 Value inputs, each scaled by their respective
       Scale input, and finally summed with the Offset input.

    Value "-->" inputs:  Any value.  The difference between the Mixer
       module and the Sum module, described above, is that the Mixer
       scales each input prior to adding it to the total, while the Sum
       module adds all five inputs, then scales the final result.

    Scale "%" inputs:  Scale the individual Value inputs with this value
       prior to adding them to the other scaled Value inputs.

    Offset "+" input:  Added to the current output.


















                                   33



    ======================================================================
                               PROGRAM MODULES

    This group of modules consists of one Program Sequencer module plus
    11 Stage Output modules.

    The Program Sequencer is the main sequencer for most musical
    applications.  It is a 256 step sequencer, with stages for 12
    simultaneous values.  Four of the stages can be faded from one value
    to the next, allowing smooth transitions between steps.

    Although set up as separate modules to get around the "one output per
    module" rule, the 11 Stage Output modules are really a continuation
    of the Program Sequencer.  The modules have only an output, no input.
    The output value corresponds to the Program Sequencer stage with the
    same letter name.

    ----------------------------------------------------------------------
    Program Sequencer                                     PROGRAM 1,1 \EA

    General:  The Program Sequencer works in close concert with the Alpha
       module. In particular, it is switched between programming mode and
       playing mode by the write protect (omega icon) input of the Alpha.
       When Alpha write-protect is non-zero, the Program module is in
       playing mode, otherwise it is in programming mode.  Also, the
       address "@" input of the Alpha module is the global address value
       for all active Program Sequencer modules.  Information on the
       Alpha module is in the "SYSTEM" chapter.

       Note that all inputs are magenta "user inputs" not the normal blue
       inputs.  This "user input only" setup is the result of the
       module's action as a programming module, rather than as a
       processing module.

    Buffers:  The module uses 4 different 12 byte data buffers.
          1. the output buffer, always displayed.
          2. the sequencer.
          3. the Undo buffer.
          4. the Save buffer.

       While playing, each time the sequencer steps, the stored values in
       all the stages are transferred to the output buffer.  The Undo
       buffer and the Save buffer are ignored.

       While programming, the output buffer contents can be copied into
       the Save buffer with the SAVE command, and the Save buffer
       contents can be transferred to the output buffer with RECALL.

       The Undo buffer is automatically filled, again only while
       programming.  Each time the sequencer step address is changed, the
       current output buffer contents are first stored into the Undo
       buffer, then the stored sequencer values are transferred to the
       output buffer. Selecting the STORE command will transfer the
       sequencer data to the Undo buffer (Undo contents are lost), then
       the output buffer is copied into the sequencer locations.  When an
       individual value is changed, that value in the current output
       buffer is first copied into the Undo buffer.  Selecting the UNDO
       command will always exchange the output buffer with the Undo
       buffer.  Thus, it possible to undo Undo.



                                   34



    Output:  Current sequencer address (step) for the module.

    Address "@":  The current sequencer address.  While playing, this
       value is stepped according to the value in the Measures input.
       When Measures reaches 0, the next address is set, and new
       sequencer values are brought in. While programming, "@" serves as
       a quick address locater.  This input is overridden by the Alpha
       module's Programmer Address input.

    Address End "e":  When playing, upon reaching this address, the
       sequencer will halt.  Ignored if it is equal to or less than the
       current address (leaving it at 0 disables).

    Undo "U":  Exchanges contents of the output buffer with the Undo
       buffer. Inhibited while playing.

    Store "!!":  Store contents of output buffer into the sequencer, with
       sequencer contents saved in the Undo buffer.  Inhibited when
       playing.

    Recall "R":  Transfer contents of Save buffer into the output buffer,
       with output buffer contents saved in the Undo buffer.  Inhibited
       when playing.

    Save "S":  Transfer contents of the output buffer into the Save
       buffer. Inhibited when playing.

    Measures to next stage "|":  This value is essentially the time
       control value.  While playing, it decrements after each measure
       until it reaches 0, then it bumps the sequencer address, which
       starts off the next event.  The actual time value of a measure is
       based on the Tempo and time signature values of the Alpha module.

    Stage outputs "X, Y, Z" and "A, B, C, D":  General output stages.
       Output goes to the corresponding Stage Output module.

    Stage outputs with slew "E/e" to "H/h":  These outputs are slewed.
       They all have a lower case slew rate label directly under the
       uppercase value label.  Slewing works by adding (or subtracting,
       depending on direction) a slew value to (from) the current value
       until it reaches the new value. The higher the slew rate value,
       the faster the slew, except that a slew rate of 0 means no slew.
       Output goes to the corresponding Stage Output module.

    ----------------------------------------------------------------------
    Stage Output Modules                   PROGRAM 1,2 to 3,4  X,Y,Z, A-H

    Magenta User Input (just left of label tag):  Must be set to
       corresponding Program Sequencer module number.  This is the number
       (0-F hex) that is part of the Program Sequencer module's label.
       Select with mouse, move cursor left or right to set.

    Output:  Value of current stage of corresponding Program Sequencer
       module and stage.








                                   35



    ======================================================================
                                CLOCK MODULES


         These modules generate timing pulses which in turn are used to
    trigger events throughout the rest of the modules.  Most of the time
    the output from the Clock modules will be sent to the "heart" input
    of function modules such as the Index modules.  It is important to
    realize that MusicBox operates on the MIDI 24 beat/quarter note
    standard.  This means that the computer will recalculate all active
    modules exactly 24 times for each quarter note, 12 times for each
    eighth note, etc.

         Since strobe -- or any other change of state -- requires 2
    cycles to be detected: one cycle for the "on" state and one cycle for
    the "off" state, it is easy to confuse the 24 clocks per quarter note
    standard with 12 on/off states per quarter note.  This is especially
    confusing when using clocks at their fastest rate, which would have
    to be 12 strobe cycles per quarter note.  Since most of the clocks
    will generate a strobe of only 1 cycle duration, the problem
    goes away when dealing with cycles of 3 and more.  As an aside, 3
    clock cycles corresponds to a thirty-second note, which is the
    fastest practical note duration.  Of course the number of clocks in a
    given note (3 for a 32nd, 6 for a 8th, etc.) have nothing whatsoever
    to do with the actual time duration of the note.  Tempo is set by the
    Alpha module and can range from as low as 6 quarter note beats per
    minute to as high as 256 beats per minute.

    ----------------------------------------------------------------------
    Note Clock                                              CLOCK 1,1 \0D
    Note Clock                                              CLOCK 1,2 \0E

    Purpose:  Main note-generating clocks.  The two modules are
       identical.  Two are given to allow up to 32 copies of the module,
       rather than the usual 16.

    Output:  Clock between a copy of the "v" (value) input, or 0.

    Hold (check) input:  When non-zero, output will hold at 0.  When
       released, the output will synchronize to the next non-zero Sync
       input.  Note that a Hold at the Alpha system module will act
       exactly like a hold at this input (as well as at the Hold input of
       all other modules), allowing all clocks to be held and sync'd with
       just the one Alpha Hold.

    Sync "S" input:  After a HLT, or a local or Alpha module Hold, the 
       clock will not resume until a non-zero value is detected at this 
       input.     Thus, clocks can be synced to other clocks, or to any 
       other event.  By leaving the sync at non-zero (the default), an 
       Alpha hold will cause all active clocks to sync to the system 
       measure start.











                                   36



    Note value (note) input:  Sets clock rate as a note duration time.
       Add 10 hex to flag triplets, 20 hex to flag dotted notes.

       Example:  3     = quarter note,
                13 hex = quarter note triplet,
                23 hex = dotted quarter note.

         input  note         clocks    clocks    clocks
         value  value        normal    triplet   dotted

         0    = Double whole  192       128        255 *
         1    = Whole note     96        64        144
         2    = Half note      48        32         72
         3    = Quarter note   24        16         36
         4    = Eighth note    12         8         18
         5    = Sixteenth       6         4          9
         6    = Thirty second   3         2          4 *
         7    = Sixty fourth    2 *       2 *        2 *

       * = not accurate representations.

    Sustain value "s" input:  Note on time as a hexadecimal percentage of
       total note duration, with 80% hex equal to 50% decimal. 40% hex is
       equal to 25% decimal, and C0% hex is equal to 75% decimal.  A
       value of 0 will give a note on time of 1 clock.

    Delay Offset "o" input:  Offset value of note start, in clocks.
       Although the Offset value is always a delay, it is possible to
       lead the note by giving offset values greater than half the note
       value.  Note that every time the offset value changes, the module
       is automatically re-sync'd to the sync pulse plus the delay.

    Velocity Value "v" input:  This value is sent to the module output at
       clock-on, at clock-off, the module output is set to zero.  The
       purpose of this input is to allow for the clock pulse to directly
       control the MIDI velocity input of the MIDI output module.  When
       the note clock output is used as a general ON/OFF flag, the value
       can be left at its default value of 1.  If this value is set to
       zero, it has the effect of holding the module off without
       resetting the sync.

    ----------------------------------------------------------------------
    Measure Clock                                           CLOCK 2,1 \B3

    Purpose:  To clock measure starts, with time offset into the measure.

    Output:  Strobe from 0 to 1 to 0, with the on-time lasting exactly
       one calculation cycle (1/24 of a quater note).


    Hold (check) input:  When non-zero, output will hold at 0.  When
       released, the output will synchronize to the next measure start,
       plus the given offset.  Note that a Hold at the Alpha system
       module will act exactly like a hold at this input.

    Delay Offset "o" input:  Offset value from measure start, in clocks.
       Although the offset value is always a delay, it is possible to
       lead the measure by giving offset values greater than half the
       measure value.



                                   37



    ----------------------------------------------------------------------
    Multiple Measure Clock                                  CLOCK 2,2 \BA

    Purpose:  Measures clock.  A good clock to trigger slow events.

    Output:  Strobe from 0 to 1 to 0, with the on-time lasting exactly
       one calculation cycle (1/24 of a quater note).

    Hold (check) input:  When non-zero, output will hold at 0.

    Measure Count "c" input:  Number of measures between strobes.  When
       set to 1, a strobe is generated at the start of each measure
       (measure timing & beats per measure are set by the Alpha module).
       When set to 2, a strobe is generated every 2nd measure; when set
       to FF hex, a strobe is generated at the start of every 255th
       measure, etc.  When set to 0, no strobe is generated.

    ----------------------------------------------------------------------
    Seconds Clock                                           CLOCK 2,3 \92

    Purpose:  Real-time clock.  Runs at an unchanging rate of one count
       per second.

    Output:  Seconds or minutes count, depending on "m" input.

    Display (yellow) output:  Decimal display of Output.

    Hold (check) input:  When set to non-zero, output will hold, when
       returned to zero, output goes to 0.

    Minutes flag "m" input:  Set output as follows:

       0 = direct send of seconds count, 0 - FF hex.
       1 = direct send of seconds count, 0 - 60 decimal.
       2 = direct send of minutes (seconds / 60).



























                                   38



    ----------------------------------------------------------------------
    Mu Clock                                                CLOCK 3,1 \E6

    Purpose: General purpose event clock, similar in operation to an
       analog LFO.  Changing values in the Count input will give
       accelrando or ritardando.

    Output: Strobe from 0 to 1 to 0, with the on-time lasting exactly one
       calculation cycle (1/24 of a quater note).

    Hold (check) input:  When non-zero, output will hold.  When returned
       to zero, the beat cycle will start at that moment, allowing the
       Hold input to also act as a sync input.

    Count "c" input: Number of clocks between strobes, with 1 the shortest
       duration, 255 the longest.  When 0, the clock is stopped.

    ---------------------------------------------------------------------
    Gamma Clock                                             CLOCK 3,2 \E7

    Purpose:  General purpose event clock.  A good clock to trigger fast
       events.  Also useful for generating leading or lagging beats.

    Output:  Strobe from 0 to 1 to 0, with the on-time lasting exactly
       one calculation cycle (1/24 of a quater note).

    Hold (check) input:  When non-zero, output will hold at 0. When
       returned to zero, the beat cycle will start at that moment, allowing
       the Hold input to also act as a sync input.

    Count "c" input:  Number of clocks between strobes, with 1 the
       shortest duration, 255 the longest.  When 0, the clock is stopped,
       when 1 it strobes every calculation cycle, with a complete on/off
       clock cycle occurring every two calculation cycles.  Since the
       on/off strobe cycle is only meaningful with a minimum of 2 beats,
       there is no pratical difference between a setting of 1 and of 2,
       and in fact it acts as if the minimum active setting was 2.

    Offset "o" input:  While the beat cycle is controlled by the Count
      input, above, the offset into the beat where the strobe will occur
      is set by this input.  When the Offset value is 0, the strobe will
      occur at the start of the beat; when 1, then it happens one clock
      after the start of the beat, and so on.  If the Offset input is set
      to a value equal to or greater than the Count input, the strobe
      occurs at the start of the beat, just as if it were set to 0.

















                                   39



    ----------------------------------------------------------------------
    Lambda Clock                                            CLOCK 3,3 \E2

    Purpose:  General clock/loop counter.  Simply counts calculation
       cycles (also called "loops", because the program loops back to the
       start after each cycle).  For each loop, the output of the clock
       is incremented by one.  When the count reaches FF hex (255
       decimal), it rolls over to 0.

    Output:  Count of 0-FF (hex), masked by the AND input.

    Hold (check) input:  When non-zero, output will hold at 0.

    Shift ">>" input:  Reduce the count period by powers of 2.  A value
       of 1 will reduce the period by 1/2, 2 by 1/4, 3 by 1/8, etc.
       Since the internal count register is 16 bits while only 8 bits can
       be displayed, shifting can also be used to count beyond the normal
       255 maximum (16 bits gives a maximum of 65,535).

    Mask "&" input:  Bit mask for output.  The value of the input is
       logically ANDed with the loop count prior to sending it to the
       output.  Thus, with the input set to 0, the output will remain 0,
       if the input is set to FF (hex), the output will count from 0 to
       FF, and repeat continuously.  Useful input values are powers of 2
       (1, 2, 4, 8, 10 hex, 20 hex, 40 hex, 80 hex), which will give
       clock ticks which half in frequency for each power of two.

       Note that one loop cycle is the same as one MIDI clock, but since
       the AND input wants to do things in powers of 2, and since the
       MIDI clock standard is 24 beats per quarter note (which works out
       to be powers of three), this module is usually not the best choice
       to directly generate note timing.

    ----------------------------------------------------------------------
    Beta Clock                                              CLOCK 3,4 \E1

    Purpose:  Real-time clock/loop counter, independent of the system
       Tempo setting of the Alpha module.  Runs at an unchanging rate
       some 580 counts/second.  For each clock tick, the output of the
       module is incremented by one. When the output reaches FF hex (255
       decimal), it rolls over to 0.

    Output:  Count of 0-FF (hex), masked by the AND input.

    Hold (check) input:  When non-zero, output will hold at 0.

    Shift ">>" input:  Reduce the count period by powers of 2.  A value
       of 1 will reduce the period by 1/2, 2 by 1/4, 3 by 1/8, etc.
       Since the internal count register is 16 bits while only 8 bits can
       be displayed, shifting can also be used to count beyond the normal
       255 maximum (16 bits gives a maximum of 65,535).

    Mask "&" input:  Bit mask for output.  The value of the input is
       logically ANDed with the tick count prior to sending it to the
       output.  Thus, with the input set to 0, the output will remain 0,
       if the input is set to FF (hex), the output will count from 0 to
       FF, and repeat continuously.





                                   40



    ======================================================================
                               TRIGGER MODULES
    ----------------------------------------------------------------------
    Synchronizer                                          TRIGGER 1,1 \EF

    Purpose:  Synchronize one clock event with another, or a random event
       with a clock cycle, or two random events with each other.

    Output:  Pulse (0 to 1 to 0) synchronized in time according the two
       inputs.

    Trigger "t" input:  A strobe at this input will cause an output pulse
       to be generated at the next Sync input.

    Sync "s" input:  Once a Trigger input is received, a strobe at this
       input will be produce a pulse at the output.  Normal usage is to
       patch a clock at this input, and a random pulse at the Trigger
       input. This will sync the random pulse to the clock.  Can also be
       used as a one-shot pulse generator by "loading" with the Trigger
       input, and "shooting" with the Sync input.

    ----------------------------------------------------------------------
    Flip-Flop                                             TRIGGER 1,2 \E9

    Output:  TRUE (1) or FALSE (0), depending on the last "s" or "r"
       input.

    Set "s" input:  Non-zero after zero will set the output to TRUE.

    Reset "r" input:  Non-zero after zero will set the output to FALSE.

    ----------------------------------------------------------------------
    Beat Pattern Generator                                TRIGGER 2,1 \9B

    Purpose:  Generate a beat pattern by the interference of up to four
       beat frequencies.

    Output:  Pulses (0 to 1 to 0) grouped in time according to Cycle
       inputs.

    Clock (heart) input:  Master clock for the module.  Output will be
       derived from and synchronized to this input.

    Hold (check) input:  When non-zero, output will hold at 0.  When
       released, the output will synchronize (all counts will start at
       the same time).

    Cycle "c" inputs:  The number of clock cycles to run before sending a
       pulse to the output.  Each of the four inputs are independent of
       the others, and are identical in function.  When an input value is
       0, that input is effectively disabled.  Note that whenever any
       Cycle input value is changed, all four cycle counts will be reset,
       causing the module to automatically resync.  Normally this is
       desirable because it gives a stable, known pattern for each
       setting.  When strange offsets to the beat pattern are desired,
       use the Beat Pattern Modulator, described below.






                                   41



    ----------------------------------------------------------------------
    Beat Pattern Modulator                                TRIGGER 2,2 \03

    Purpose:  Generate a beat pattern by the interference of up to four
       independent clock inputs.

    Output:  Pulses (0 to 1 to 0) grouped in time according to Cycle
       inputs.

    Hold (check) input:  When non-zero, output will hold at 0.

    Clock (heart) inputs:  Clock pulses at these inputs will be combined
       into a single pulse at any one calculation cycle, and sent out as
       an output strobe.  Each of the four inputs are independent of the
       others, and are identical in function.  Unused inputs are ignored.

    ----------------------------------------------------------------------
    Random Strobe                                         TRIGGER 2,3 \C1

    Purpose:  General purpose event trigger, with random dither.

    General:  This is the same as the Gamma Clock module, except it has a
       dithered strobe output.  Handy for generating polyrhythms.

    Output:  Strobe from 0 to 1 to 0, with the on-time lasting exactly
       one calculation cycle (1/24 of a quater note), with frequency set
       by the Count input, and probability set by the Dither input.

    Hold (check) input:  When non-zero, output will hold at 0. When
       returned to zero, the beat cycle will start at that moment,
       allowing the Hold input to also act as a sync input.

    Count "c" input:   Number of clocks between strobes, with 1 the
       shortest duration, 255 the longest.  When 0, the clock is stopped,
       when 1 it strobes every calculation cycle, with a complete on/off
       clock cycle occurring every two calculation cycles.  Since the
       on/off strobe cycle is only meaningful with a minimum of 2 beats,
       there is no pratical difference between a setting of 1 and of 2,
       and in fact it acts as if the minimum active setting was 2.

    Offset "o" input:  While the beat cycle is controlled by the Count
       input, above, the offset into the beat where the strobe will occur
       is set by this input.  When the Offset value is 0, the strobe will
       occur at the start of the beat; when 1, then it happens one clock
       after the start of the beat, and so on.  If the Offset input is set
       to a value equal to or greater than the Count input, the strobe
       occurs at the start of the beat, just as if it were set to 0.

    Dither "%" input:  The value at this input is compared to an
       internally generated random number in the range of 0-FF (hex).
       The effect of this is the higher the Dither value, the more often
       the output strobe will occur. If the value is 0, the strobe will
       be disabled; if 40 (hex), it will occur 1/4 of the time; if 80
       (hex), it will occur 1/2 of the time; if C0 (hex), it will occur
       3/4 of the time; if FF (hex) it will occur 255/256 of the time.







                                   42



    ----------------------------------------------------------------------
    Change Detector                                       TRIGGER 3,1 \0B

    Output:  TRUE pulse if the Value input has changed.  Pulse is active
       for one complete module calculation cycle, then returns to zero.

    Value "-->" input:  Any value.

    ----------------------------------------------------------------------
    Slope Detector                                        TRIGGER 3,2 \5C

    Output:  True (1) when the current value is greater than the
       preceding value (positive slope), False (0) when the current value
       is less than the preceding value (negative slope).  No change when
       the preceding value equals the current input.

    Value "-->" input: Any value.

    ----------------------------------------------------------------------
    Delta Test                                            TRIGGER 3,3 \A6

    Output:  TRUE (1) when the absolute difference between the current
       Value input and the last different Value input is equal to the
       Delta value input.

    Hold (check) input:  When non-zero, output will hold at 0.

    Delta value (delta) input:  Value that will be compared with the
       input delta.

    Octave normalize "o" input:  When non-zero, the input will be
       normalized to one octave (0-11), before it is compared with the
       Delta value.

    Input "-->":  Any changing value.



























                                   43



    ======================================================================
                               ONESHOT MODULES
    ----------------------------------------------------------------------
    Timer                                                 ONESHOT 1,1 \D9

    Purpose:  Signal an event after a given number of MIDI clocks, with
       optional delay.  Based on internal MIDI clock speed, which is
       dependent on the Tempo setting of the Alpha module.

    Output:  After an optional delay, goes from 0 to 1, then returns to 0
       again.

    Strobe "!" input:  A zero to non-zero transition starts the timer.
       Further inputs are ignored until the module completes its cycle.

    Delay "d" input:  Number of clocks delay, after the Strobe input is
       clocked, before output goes to 1.  When 0, there is no delay.

    Hold "h" input:  Number of clocks the pulse will remain on.  When 0,
       the output will not return to zero.  This is useful when used with
       the "d" input to control an event start that will never retrigger.

    ----------------------------------------------------------------------
    Clocked Timer                                         ONESHOT 1,2 \BE

    Purpose:  Signal an event after a given number of clock ticks, with
       optional delay.  Based on an external clock speed.

    Output:  After an optional delay, goes from 0 to 1, then returns to 0
       again.

    Clock (heart) input:  Any non-zero after zero will increment the
       internal counters.

    Strobe "!" input:  A zero to non-zero transition starts the timer.
       Further inputs are ignored until the module completes its cycle.

    Delay "d" input:  Number of clocks delay, after the Strobe input is
       clocked before output goes to 1.  When 0, there is no delay.

    Hold "h" input:  Number of clocks the pulse will remain on.  When 0,
       the output will not return to zero.  This is useful when used with
       the "d" input to control an event start that will never retrigger.



















                                   44



    ----------------------------------------------------------------------
    Absolute Timer                                        ONESHOT 2,1 \BC

    Purpose:  Signal an event after a given time setting, with optional
       delay.  One-shot timer based on the internal 580 ticks/second
       real-time clock speed, which is independent of the Tempo setting
       of the Alpha module.

    Output:  After an optional delay, goes from 0 to 1, then returns to 0
       again.

    Strobe "!" input:  A zero to non-zero transition starts the timer.
       Further inputs are ignored until the module completes its cycle.

    Delay "d" input:  Number of clocks delay, after the Strobe input is
       clocked, before output goes to 1.  When 0, there is no delay.

    Hold "h" input:  Number of clocks the pulse will remain on.  When 0,
       the output will not return to zero.  This is useful when used with
       the "d" input to control an event start that will never retrigger.

    Shift ">>" input:  Reduce the count period by powers of 2.  A value
       of 1 will reduce the period by 1/2, 2 by 1/4, 3 by 1/8, etc.

    ----------------------------------------------------------------------
    Seconds Timer                                         ONESHOT 2,2 \BD

    Purpose:  Signal an event after a given time setting, with optional
       delay.  One-shot timer based on the internal 1/second real-time
       clock speed, which is independent of the Tempo setting of the
       Alpha module.

    Output:  After an optional delay, goes from 0 to 1, then returns to 0
       again.

    Strobe "!" input:  A zero to non-zero transition starts the timer.
       Further inputs are ignored until the module completes its cycle.

    Delay "d" input:  Number of clocks delay, after the Strobe input is
       clocked, before output goes to 1.  When 0, there is no delay.

    Hold "h" input:  Number of clocks the pulse will remain on.  When 0,
       the output will not return to zero.  This is useful when used with
       the "d" input to control an event start that will never retrigger.

    Shift ">>" input:  Reduce the count period by powers of 2.  A value
       of 1 will reduce the period by 1/2, 2 by 1/4, 3 by 1/8, etc.















                                   45



    ----------------------------------------------------------------------
    Strobe Pushbutton                                     ONESHOT 3,1 \09

    Output: ON pulse, returning to OFF.

    Magenta User Input:  Clicking the left mouse button when the cursor
       is over magenta user input pad will change the output from 0 to 1
       for 1 calculation cycle, then return to 0.

    ----------------------------------------------------------------------
    Gate Pushbutton                                       ONESHOT 3,2 \E3

    Output: 0/1

    Magenta User Input:  Clicking the left mouse button when the cursor
       is over magenta user input pad will change the output from 0 to 1
       (or from 1 to 0).

    ----------------------------------------------------------------------
    Step Pushbutton                                       ONESHOT 3,3 \12

    Output: 0-FF (hex)

    Magenta User "#" Input:  This value is echoed to the output.

    Magenta User (up & down arrows) Input:  Clicking the left mouse
       button when the cursor is over the left side of the magenta input
       pad will increment the value at the output, the right side of the
       pad will decrement the output.

































                                   46



    ======================================================================
                                 TEST MODULES

    This group of modules will test for a particular condition, and
    report TRUE (output=1, red tag indicator highlighted) if the
    condition is met, and FALSE (output=0, red tag indicator not
    highlighted), if the condition is not met.

    ----------------------------------------------------------------------
    Zero?                                                    TEST 1,1 \07

    Output: TRUE if the Value input is zero, else FALSE.

    Value "-->" input: Any value.

    ----------------------------------------------------------------------
    Equal?                                                   TEST 1,2   =

    Output: TRUE if the two Value inputs are equal, else FALSE.

    Value "-->" inputs: Any value.

    ----------------------------------------------------------------------
    Different?                                               TEST 1,3 \A7

    Output: TRUE if the two Value inputs are not equal, else FALSE.

    Value "-->" inputs: Any value.

    ----------------------------------------------------------------------
    Greater?                                                 TEST 2,1   >

    Output:  TRUE if value input "a" is greater than value input "b",
       else FALSE.

    Value inputs "a" and "b":  Any value.

    ----------------------------------------------------------------------
    Less?                                                    TEST 2,2   <

    Output:  TRUE if value input "a" is less than value input "b", else
       FALSE.

    Value inputs "a" and "b":  Any value.

    ----------------------------------------------------------------------
    Within?                                                  TEST 2,3 \CA

    Output:  TRUE if Value input is within limits set by MAX input and
       MIN input, else FALSE.

    Value "-->" input: Any value.

    MAX (up arrow) input:  Upper limit of test condition, inclusive.

    MIN (down arrow) input: Lower limit of test condition, inclusive.






                                   47



    ----------------------------------------------------------------------
    True?                                                    TEST 3,1   "

    Output: TRUE if the Value input is non-zero, else FALSE.

    Value "-->" input: Any value.

    ----------------------------------------------------------------------
    Negative?                                                TEST 3,2 \A4

    Output:  True if the input value is greater than 7F hex, 127 decimal.
       Since all displayed values are in the range of 0-FF hex, values
       greater than 7F hex can be treated as negative numbers.  FF hex is
       equivalent to -1, FE hex to -2, and so on. The module also is
       useful for warning when an output value is beyond the legal MIDI
       range of 0-7F hex.

    Value "-->" input: Any value.

    ----------------------------------------------------------------------
    Bit Set                                                  TEST 3,3 \FE

    Purpose: Convert a zero/non-zero value to one of 8 individual bit
       positions in the output.

    Output:  8-bit value representing the ON/OFF state of the 8 Logic
       inputs.

    Logic "0" to "7" inputs:  From top to bottom, the zero/non-zero state
       of these inputs are translated to ON/OFF bits positioned from
       right to left in the 8 bit Output value.































                                   48



    ======================================================================
                                RANDOM MODULES
    ----------------------------------------------------------------------
    Random Number Generator                                RANDOM 1,1   ?

    Output:  A random number within set limits.  Uses a simple, fast
       algorithm to produce a uniformly distributed pseudo random value.

    Clock (heart) input:  Non-zero after zero will cause a new random
       number to be generated.

    Hold (check) input:  Non-zero resets the seed to the value at the
       Seed input, and holds output at that value.  If two modules have
       the same seed value, and they are given a hold pulse at the same
       time, they will then produce exactly the same string of random
       numbers.  This is also the effect of Alpha module Random Reset
       input.  However, the Alpha hold input simply freezes the output, 
       and does not generate a new seed.

    Seed "S" input:  The seed value for a new random number run.  The
       module is capable of producing 256 different random runs, one for
       each possible seed value of 0-FF hex.  After setting the new seed
       value, a Hold or a Alpha Random Reset is required put it into
       effect.  Note that for the module to produce a unique set of
       random numbers, it must be started with a unique seed. Conversely,
       two or more modules will have the same set of numbers if they are
       given the same seed value.

    Limit (up-arrow) input:  Set upper limit that can be generated.
       Exclusive: a setting of 8 will produce 0-7.

    Offset "+" input:  Added to the current output.






























                                   49



    ----------------------------------------------------------------------
    Up/Down Random Number Generator                        RANDOM 1,2 \A8

    Output:  A random number within set limits.  Uses program code as the
       random number source, allowing successive numbers to be accessed
       as a forward or backward run, at some sacrifice of uniformity in
       distribution.

    Clock (heart) input:  Non-zero after zero will cause a new random
       number to be generated.

    Hold (check) input:  Non-zero resets the seed to the value at the
       Seed input, and holds output at that value.  If two modules have
       the same seed value, and they are given a hold pulse at the same
       time, they will then produce exactly the same string of random
       numbers.  This is also the effect of Alpha module Random Reset
       input.  However, the Alpha Hold simply freezes the output, and
       does not generate a new seed.

    Seed "S" input:  The seed value for a new random number run.  The
       module is capable of producing 256 different random runs, one for
       each possible seed value of 0-FF hex.  After setting the new seed
       value, a Hold or a Alpha Random Reset is required put it into
       effect.  Note that for the module to produce a unique set of
       random numbers, it must be started with a unique seed. Conversely,
       two or more modules will have the same set of numbers if they are
       given the same seed value.

    Up/down "+/-" input:  Changing from zero to non-zero (or vice versa)
       changes the direction of the random number run, causing successive
       numbers to be repeated in an inverse run.

    Limit (up-arrow) input:  Set upper limit that can be generated.
       Exclusive: a setting of 8 will produce 0-7.

    ----------------------------------------------------------------------
    Random Logic                                           RANDOM 1,3 \AD

    Output:  TRUE (1) or FALSE (0) at 50% probability.

    Clock (heart) input:  Any non-zero after zero will cause a new output
       to be generated.




















                                   50



    ----------------------------------------------------------------------
    Dither Logic                                           RANDOM 2,1 \04

    Output:  TRUE (1) or FALSE (0), the probability of which is set by
       the Dither input.

    Clock (heart) input:  Any non-zero after zero will cause a new output
       to be generated.

    Dither "%" input:  The value at this input is compared to an
       internally generated random number in the range of 0-FF (hex).  If
       the the value is greater than the random number, the output will
       be TRUE, if less or equal it will be FALSE.  The effect of this is
       the higher the Dither value, the more often the output will be
       TRUE.  If the value is 0, the output will always be FALSE; if 40
       (hex), it will be TRUE 1/4 of the time; if 80 (hex), it will be
       TRUE 1/2 of the time; if C0 (hex), it will be TRUE 3/4 of the
       time; if FF (hex) it will be TRUE 255/256 of the time.

    ----------------------------------------------------------------------
    Dither Toggle Switch                                   RANDOM 2,2 \05

    Output:  A copy of the Value input or 0, the probability of which is
       set by the Dither input.

    Clock (heart) input:  Any non-zero after zero will cause a new output
       to be generated.

    Dither "%" input:  The value at this input is compared to an
       internally generated random number in the range of 0-FF (hex).  If
       the the value is greater than the random number, the output will
       be a copy of the Value input, if less or equal it will be 0.  A
       value of 20 (hex) will switch to the Value input 1/8 of the time,
       and to 0 7/8 of the time.

    Value "-->" input:  Any value.

    ----------------------------------------------------------------------
    Dither Switch                                          RANDOM 2,3 \06

    Output:  A copy of the value at input "a" or "b", the probability of
       which is set by the Dither input.

    Clock (heart) input:  Any non-zero after zero will cause a new output
       to be generated.

    Dither "%" input:  The value at this input is compared to an
       internally generated random number in the range of 0-FF (hex).  If
       the the value is greater than the random number, the output will
       be a copy of the "b" input, if less or equal it will be a copy of
       the "a" input.  A value of 40 (hex) will switch to the "a" input
       3/4 of the time, and to the "b" input 1/4 of the time.

    Value "a" and "b" inputs:  Any value.

    Offset "+" input:  Added to the current output.






                                   51



    ----------------------------------------------------------------------
    Odds Switch                                            RANDOM 3,1 \AC

    Output:  A copy of the value at input "a", "b", "c", or "d", with the
       odds of selecting a particular input geometrically decreasing.
       Odds of selecting the "a" input is 1:2, of "b" is 1:4, of "c" is
       1:8, of "d" is 1:16.

    Clock (heart) input:  Any non-zero after zero will cause a new input
       to be selected.

    Inputs "a", "b", "c", and "d":  Any value.

    Offset "+" input:  Added to the current output.

    ----------------------------------------------------------------------
    Odds Generator                                         RANDOM 3,2 \84

    Output:  One of the numbers 0-7 with the odds of generating a
       particular number geometrically decreasing.  Odds of producing 0
       is 1:2, of 1 is 1:4, of 2 is 1:8, .... , of 7 is 1:256.

    Clock input:  Any non-zero after zero will cause a new number to be
       generated.

    ----------------------------------------------------------------------
    Interference Pattern Dither                            RANDOM 3,3 \8E

    Purpose:  Generate a pattern by the interference of up to four
    independent dither inputs.

    Output:  Values of 0 - F (hex), weighted according to dither input
       values.

    Clock (heart) input:  Any non-zero after zero will cause a new output
       to be generated.

    Dither "%" inputs:  These four dither values each determine the
       frequency weighting of a bit position of the output value that
       will be on or off.  If only the first is used, the output pattern
       will be 0 - 1.  If the first two are used the pattern will be 0 -
       3, etc. When set to zero, the inputs are disabled.




















                                   52



    ======================================================================
                               PATTERN MODULES
    ----------------------------------------------------------------------
    Interval Generator                                    PATTERN 1,1   !
    Pattern  Generator                                    PATTERN 1,2 \13

    Purpose:  Generate a new pattern for the Chord Value Reader modules
       to read. The two modules are identical, except that the Interval
       Generator has one value input and three inputs that are offsets to
       the base value, where the Pattern Generator has four independent
       value inputs.

    Output:  Address of the base value, 0-3.  This is always 0 unless the
       Sort input is ON.  After a sort, it is sometimes useful to know
       where the base value went.

    Page (paragraph symbol) input:  These modules, plus the two Chord
       Value Reader modules and the Chord Value Writer module all use a
       group of sixteen four-byte memory cells as the data area. The Page
       input determines which of the 16 different chord groups is to be
       used.

    Base value "-->" input:  This input will go to the zeroth (base) cell
       in the chord group.

    Interval value ">>" inputs to Interval Generator:  These three inputs
      are each added to the Base value input, then they are sent to their
      respective locations in the chord group.

    Pattern value "-->" inputs to Pattern Generator:  These three inputs
       are each sent directly to their respective locations in the chord
       group.

    Octave normalize "o" flag input:  When non-zero, the four chord
       values will be normalized to the one octave range of 0 - 11.

    Offset "+" input:  This value is added to the four chord values.  If
       the octave normalize flag is non-zero, the offset value will be
       added AFTER normalizing.

    Sort "<->" flag input:  When non-zero, the four chord values will be
       sorted in ascending order prior to writing them to the chord group
       table.

    Octave fold "f" input:  Active when Sort flag is non-zero.  Sets the
       octave range within which the four chord values will be folded.  0
       sets a range of 0-11, 1 sets 0-23, 2 sets 0-35, etc.

    Write Strobe "!" input:  Non-zero after zero will cause a the
       currently paged four-value chord group to be written with the
       module's values.











                                   53



    ----------------------------------------------------------------------
    Chord Value Writer                                    PATTERN 1,3   @

    Purpose:  Allow writing to individual values of the chord table.

    Output:  Previous value.

    Page (paragraph symbol) input:  Set which of the 16 different chord
       groups is to be written to.

    Position "@" input:  Determines the position in the four-value chord
       table to which the input will be written.  Zero writes to the
       first value in the table, one writes to the second, etc.

    Value "-->" input:  This input will go to the addressed cell in the
       chord group.

    Octave normalize "o" flag input:  When non-zero, the input value will
       be normalized to the one octave range of 0 - 11.

    Offset "+" input:  This value is added to the input value prior to
       writing to the chord table.  If the octave normalize flag is non-
       zero, the offset value will be added AFTER normalizing.

    Write Strobe "!" input:  Non-zero after zero will cause the addressed
       chord table value to be replaced by the module's current value
       input. The previous chord table value is sent to the output.

    ----------------------------------------------------------------------
    Chord Value Reader                                    PATTERN 2,1 \80
    Chord Value Reader                                    PATTERN 2,2 \87

    Purpose:  Up to four modules can be used together to read chords, or
       single modules can be used to generate patterns. The two modules
       are identical.  Two are given to allow up to 32 copies of the
       module, rather than the usual 16.

    Clock (heart) input:  Any non-zero after zero will cause a new output
       to be generated.

    Page (paragraph symbol) input:  Set which of the 16 different chord
       groups is to be read from.

    Position/Order "@" input:  When the Sort input is zero, this input
       determines the position in the four-value chord table from which
       the output will be read.  Zero reads the first value in the table,
       one reads the second, etc.  When the Sort is non-zero, this input
       determines the ascending order that will be read.  Zero reads the
       lowest of the four values, one reads the next higher, etc.

    Sort "<->" flag input:  When non-zero, the module will determine the
       ascending order of the values in the chord table, and  send the
       value selected by the Order input to the output.  The actual
       position of the values in the chord table is unchanged.

    Offset "+" input:  This value is added to the output.






                                   54



    ----------------------------------------------------------------------
    Pattern Line Generator                                PATTERN 3,1   :

    Purpose:  Generate a pattern line for bass patterns, etc. by adding
       or subtracting an input value with the current output value.

    Output: Accumulated pattern value.

    Clock (heart) input:  Any non-zero after zero will cause a new output
       to be generated.

    Hold (check) input:  When non-zero, output will hold at its current
       setting, and the clock input is ignored.

    Reset "!" strobe:  Non-zero after zero causes the Start value input
       to be sent to the output.

    Start value "-->" input:  Value that starts the module after a reset,
       and the value that the module returns to when an overflow beyond
       the Range limit is detected.  Acts as a "center" to the pattern
       that will be generated.

    Range limit "#" value:  Sets the limit above and below the Start
       value.  When the output plus the next step exceeds this limit, the
       module automatically resets to the Start value.  Must be greater
       than zero for a pattern to be generated.

    Up/Down "+/-" input:  Add "+" input to the output if zero, subtract
       "-" input from the output if non-zero.

    Positive value "+" input:  Any value.

    Negative value "-" input:  Any value.

    ----------------------------------------------------------------------
    Tone Row Generator                                    PATTERN 3,2 \EC

    Purpose:  Produce a 12 note tone row.  The values are 0-11, non-
       repeating.  The order is randomized each time a Strobe input is
       given.

    Output:  Value of 0 - 11, as accessed by the Address input, and as
       ordered by the most recent Strobe.

    Address "@" input:  Values of 0-11 will address one of the 12 tone
       values in the tone row.  Values greater than 11 are normalized to
       the 0 - 11 range.

    Strobe "!" input:  Non-zero after zero will cause a new tone row to
    be generated.












                                   55



    ----------------------------------------------------------------------
    Interference Pattern Generator                        PATTERN 3,3 \8F

    Purpose:  Generate a pattern by the interference of up to four
       independent strobe inputs.

    Output:  Values of 0 - F (hex), according to Strobe input pattern.

    Clock (heart) input:  Any non-zero after zero will cause a new output
       to be generated.

    Strobe "!" inputs:  These four input strobes each determine a bit
       position of the output value that will be on or off.  If only the
       first is used, the output pattern will be 0 - 1.  If the first two
       are used the pattern will be 0 - 3, etc.















































                                   56



    ======================================================================
                                MIDI MODULES

    These modules typically go at the end of the computation loop
    (highest priority numbers). This is important because when the
    computer calculates a value after sending a previous value to the
    output, a glitch may be heard that is the result of the sound being
    delayed one MIDI clock cycle.

    As their function is to send data out of the computer, usually to a
    MIDI device (rather than to another module), most do not have the
    cyan module output display.

    ----------------------------------------------------------------------
    MIDI Note                                                MIDI 1,1   1
    MIDI Note                                                MIDI 1,2   2
    MIDI Note                                                MIDI 1,3   3
    MIDI Note                                                MIDI 1,4   4

    Purpose:  MIDI Key on/Key off output channel(s) for up to 4 notes at
       a time. The four modules are identical.  Two are given to allow up
       to 64 copies of the module, rather than the usual 16.

    Channel "c" input:  MIDI channel number.  If two MPU's are used, 32
       MIDI channels are possible, with 0-F hex going to MIDI channels 1-
       16 on the first MPU, and 10-1F hex going to MIDI channels 1-16 on
       the second MPU.

    Mute "/0/" and "&" inputs:  These two inputs are internally ANDed, if
       the result is non-zero, MIDI output is enabled, and the red dot in
       the label is highlighted; if zero, MIDI output is inhibited.  The
       input pair is optimized for usage with the Mute module, described
       in the chapter "SPECIAL".

    Transpose "t" inputs:  These two inputs are identical.  The values
       are summed and then added to each of the 4 Note value inputs prior
       to sending them to MIDI.  The obvious way to use this input is to
       transpose all the Note inputs by the same value.  A less obvious
       use is to set the Note inputs to base chord values (a major triad,
       for example would be 0, 4, and 7; a minor triad would be 0, 3, and
       7), then set the Velocity inputs as desired, then use the
       Transpose input to play chords.

    Velocity Offset "v" input:  This is similar to the Transpose input
       above, except that the value is added to the 4 Velocity inputs.
       Also, to avoid sending out notes with zero values from unused
       Note/Velocity inputs, the Velocity Offset only affects "in use"
       Velocity values.  It will not generate new notes by setting it to
       zero, then to some value.

    Key Release "r" input:  The velocity value sent with Key Off for each
       of the 4 Note inputs.  Most synthesizers ignore release velocity.










                                   57




    Inputs "A" to "D":  Keyboard note values.
    Inputs "a" to "d":  Keyboard velocity values.

       These 4 pairs of inputs allow the module to play up to 4 notes
       polyphonically.  (If more than 4 poly notes are needed, two or
       more modules may be given the same MIDI channel number.) The upper
       case inputs accept the MIDI note value of 0-7F hex, with 3C
       hex equivalent to Middle C.  The corresponding lower case inputs
       send polyphonic Key-on velocity.

       Note values are sent when changed. Velocity changes are ignored
       except zero transitions.  When Velocity = 0, a Key-off message is
       sent with the currently saved note and with the velocity taken
       fromn the "r" input; the first non-zero Velocity seen will send a
       Key-on message with the note value at the input, and the given
       velocity level. While Velocity stays non-zero, any change in note
       values will cause an immediate Key-off message with the old note,
       then a Key on message with the new note, and the latest Velocity
       value for that note.

       MIDI protocol requires that a key-on message be balanced by a
       corresponding key-off message (or key-on with velocity set to 0).
       To simplify the module's use, and to reduce the likelihood of
       producing a "stuck note", the module must handle key-on/key-off
       messages in an intelligent (for a computer) manner.

       This module applies the following rules to changes detected in the
       note and velocity value inputs:

         1.  If pitch changes, and velocity is zero, nothing happens.
         2.  If pitch changes, and velocity is non-zero, the preceding
             note value is sent with a key-off message, then the new
             note value is immediately sent with a key-on message and the
             currently set velocity value.
         3.  When the velocity input goes from zero to non-zero, a key-on
             message is sent with the current note and velocity values.
         4.  When the velocity input goes from non-zero to zero, a
             key-off message is sent for the currently sounding note.

       Translation:  If there is anything other than zero at the velocity
       input, a change in the note input will cause a new note to play.
       Changes in the velocity input of zero to non-zero (such as a clock
       would produce) will turn a note off and on.

    ----------------------------------------------------------------------
    MIDI Control Output                                      MIDI 2,1 \99
    MIDI Control Output                                      MIDI 2,2 \9A

    Purpose:  MIDI output module for various control messages.  Sends
       Patch Change, Aftertouch, Pitch Bend,  and 8 Control Change
       messages. All parameters are sent when changed. The two modules
       use different Control Change maps (see chapter "SYSTEM" for
       details), but otherwise are identical. Two are given to allow up
       to 32 copies of the module, rather than the usual 16.

    Channel "c" input:  MIDI channel number.  If two MPU's are used, 32
       MIDI channels are possible, with 0-F hex going to MIDI channels 1-
       16 on the first MPU, and 10-1F hex going to MIDI channels 1-16 on
       the second MPU.


                                   58




    Hold (check) input: If zero, MIDI output is enabled, and the red dot
       in the label is highlighted; if non-zero, MIDI output is inhibited.

    Program Change "Pt" input:  MIDI Program Number to be sent.

    Aftertouch "a" input:  Sends Channel Key Pressure (Aftertouch)
       message, followed by input value.  Note that this is the
       aftertouch message that affects all notes on that MIDI channel,
       not the individual key aftertouch message (which is generally not
       supported by synthesizer manufacturers).

    Pitch Bend "b" input:  Sends MIDI Pitch Bend Message. This input
       allows a range of 0 FF hex, with 80 hex as the midway setting (as
       seen on most synth Pitch Bend control wheels).

    Control Change "V", "M", "A-D", and "1-2" inputs:  Sends MIDI Control
       Change messages.  The actual Control Change number is set by one
       of the two the Control Map modules (see chapter on SYSTEM
       modules). Inputs "1" and "2" are for on/off values, they force all
       non-zero input values to 127 before sending them out to MIDI.

       Default Control Change message values, with Yamaha's names:

               V  =  7  =  Volume
               M  =  1  =  Modulation Wheel
               A  =  2  =  Breath Controller
               B  =  3  =  Unspecified
               C  =  4  =  Foot Controller
               D  =  5  =  Portamento Time
               1  =  64 =  Sustain Foot Switch
               2  =  65 =  Portamento Foot Switch

    ----------------------------------------------------------------------
    MIDI Program Change                                      MIDI 2,3 \9E

    Purpose:  Change MIDI Patch programs.  Supplement to Program Change
    input of the MIDI Control Output module.

    Output: MIDI Program Number.

    Channel "c" input:  MIDI channel number.  If two MPU's are used, 32
       MIDI channels are possible, with 0-F hex going to MIDI channels 1-
       16 on the first MPU, and 10-1F hex going to MIDI channels 1-16 on
       the second MPU.

    Delay (right-angle) input:  Ammount of delay after sending program
       change.  To avoid loosing data when controlling MIDI matrix
       switchers, the MIDI output buffer is cleared prior to sending the
       patch change, and a delay can be inserted after the message is
       sent. Each count delays for 1/580 second.  A value of 3-4 is
       usually sufficient.  No delay if set to 0 (the default).

    Strobe "!" input:  Non-zero after zero sends the message.

    Value "-->" input:  Patch Change value that will be sent upon strobe.
       ANDed with 7F hex to limit the value to the legal MIDI range.





                                   59



    ----------------------------------------------------------------------
    MIDI Control Change                                      MIDI 2,4 \98

    Purpose:  Send MIDI Control Change message, Control Number, and
       Control Value to a MIDI output channel.

    Strobe "!" input:  Any non-zero after zero will initiate a send.

    Channel "c" input:  MIDI channel number.  If two MPU's are used, 32
       MIDI channels are possible, with 0-F hex going to MIDI channels 1-
       16 on the first MPU, and 10-1F hex going to MIDI channels 1-16 on
       the second MPU.

    Number "#" input:  MIDI Control Number to be sent.  ANDed with 7F
       hex to limit the value to the legal MIDI range.

    Value "-->" input:  MIDI Control Value to be sent.  ANDed with 7F hex.

    ----------------------------------------------------------------------
    MIDI System Exclusive Send                               MIDI 3,1 \11

    Purpose:  Send MIDI System Exclusive data to MIDI output.  Can be
       used for large sends of program data, or for small program change
       sends.  Uses the 64K sequencer data area "A".

    Output:  After a data send, the output will contain the 16 bit
       address of the end of the send +1, which could be the next
       available data block.  If there is an error, the output will read
       "FFFF".  Note that the output is 16 bits, rather than the usual 8.
       Use the shift input to read the high (Page) part.

    Address "@" input:  Specify the starting address of the 64K sequencer
       data area "A" from which the MIDI data send will start.

    Page (paragraph symbol) input:  Specify the starting page of the 64K
       sequencer data area "A".

    Strobe "!" input:  Initiate the send.  Module output is set to "XX",
      and flashes while data is being sent. Data is sent until a MIDI EOX
      (F7 hex) is found in the data stream.

    Shift ">>" input:  Number of shifts to perform on output display.
       Each left shift is the same as a division by 2.  A shift value of
       8 will return the Page count.


















                                   60



    ----------------------------------------------------------------------
    MIDI System Exclusive Receive                            MIDI 3,2 \12

    Purpose:  Receive MIDI System Exclusive data from MIDI input.  Useful
       for receiving large dumps of program data.

    General:  This module is used in conjunction with the 64K sequencer
       data area "A", which is the data source for all System Exclusive
       receives.

    Output:  After a data receive, the output will contain the 16 bit
       address of the end of the receive +1, which could be the next
       available data block.  If there is an error, the output will read
       "FFFF".  Note that the output is 16 bits, rather than the usual 8.
       Use the shift input to read the high (Page) part.

    Address "@" input:  Specify the starting address of the 64K sequencer
       data area "A" that will receive the MIDI data.

    Page (paragraph symbol) input:  Specify the starting page of the 64K
       sequencer data area "A".

    Strobe "!" input:  Initiate the acceptance of a MIDI System Exclusive
       dump.  Module output is set to "XX", and flashes while data is
       being received.  Data is accepted until a MIDI EOX (F7 hex) is
       found in the data stream. If no EOX is detected after about 20
       seconds, the module will abort with an error.

    Shift ">>" input:  Number of shifts to perform on output display.
       Each left shift is the same as a division by 2.  A shift value of
       8 will return the Page count.


    ----------------------------------------------------------------------
    MIDI System Exclusive Short Send                         MIDI 3,3 \15

    Purpose:  Send a short System Exclusive message.  Ideal for such
       things as Voice Bank Change in the Yamaha FB01.

    Strobe "!" input:  Non-zero after zero initiates the send.

    Data "1-8" inputs:  System exclusive data area.  Up to 8 bytes can be
       sent.  If less than 8 bytes are to be sent, set the last byte to
       FF hex.  The status bytes (F0 hex to start and F7 hex to end) are
       sent by the module, so do NOT include them here.

















                                   61



    ======================================================================
                               DISPLAY MODULES
    ----------------------------------------------------------------------
    Linear Level Meter                                    DISPLAY 1,1 \97

    Purpose:  VU meter type display of two value inputs.  The two
       vertical bars will be highlighted in proportion to the values at
       the left and right inputs.  This meter responds linearly:  the
       highlighted portion of the bar goes up one notch for each
       increment in the input value.

    Level "l" and "r" inputs:  Level inputs for the left and right meter
       columns.

    Range (divide) input:  Left and right input values will be divided by
       this value before being displayed.

    ----------------------------------------------------------------------
    Exponential Level Meter                               DISPLAY 1,2 \96

    Purpose:  VU meter type display of two value inputs.  The two
       vertical bars will be highlighted in proportion to the values at
       the left and right inputs.  This meter responds exponentially:
       the highlighted portion of the bar goes up one notch for each
       doubling of the input value.

    Level "l" and "r" inputs:  Level inputs for the left and right meter
       columns.

    Range "*" input:  Left and right input values will be multiplied by
       this value before being displayed.

    ----------------------------------------------------------------------
    ASCII Character Display                               DISPLAY 2,1 \A0

    Value "-->" inputs:  Any value in one of the three inputs will be
       displayed as a as an ASCII/IBM graphics character.  The first
       input displays the character in the leftmost position, the next in
       the middle, the third in the right.  Modules may be grouped
       together to form chartcter strings.

    ----------------------------------------------------------------------
    ASCII Character Display from sequencer area "A"       DISPLAY 2,2 \86

    Address "@" input:  Step address in the 65K byte sequencer area "A" at
    which to display three sequential bytes as ASCII/IBM graphics
    characters.  The addressed input is displayed as the character in the
    leftmost position, the next in the middle, the third in the right.
    Modules may be grouped together to form chartcter strings.

    Page (paragraph symbol) input:  Page number (high address) for the
       character display.

    Address shift (up-down arrow) input:  Shifts the given address by the
       amount given at this input.  This allows modules to be ganged
       together, but to be addressed by only one source.  This shift will
       go across page boundaries.  It is useful, for example, for
       displaying voice names of a synthesizer voice dump.




                                   62



    ----------------------------------------------------------------------
    ASCII Character Display from sequencer area "B"       DISPLAY 2,3 \83

    Address "@" input:  Step address in the 256 byte sequencer at which
       to display three sequential bytes as ASCII/IBM graphics
       characters.  The addressed input is displayed as the character in
       the leftmost position, the next in the middle, the third in the
       right. Modules may be grouped together to form chartcter strings.

    Page (paragraph symbol) input:  Page number (high address) for the
       character display.  Valid Page numbers are 0-F hex.

    Address shift (up-down arrow) input:  Shifts the given address by the
       amount given at this input.  This allows modules to be ganged
       together, but to be addressed by only one source.

    ----------------------------------------------------------------------
    Decimal Display                                       DISPLAY 3,1   .

    Value "-->" input:  Any value will be displayed in decimal.

    ----------------------------------------------------------------------
    Note Display                                          DISPLAY 3,2 \D5

    Value "-->" input:  Any value will be displayed as a as a
       note+octave.  Assumes C major scale ascending, with Octave 5 =
       Middle C.

    ----------------------------------------------------------------------
    Binary Display                                        DISPLAY 3,3   ;

    Value "-->" input:  Any value will be converted to one of 8 bit
       positions and highlighted if the bit is on, lowlighted if the bit
       is off.




























                                   63



    ======================================================================
                                SLEW MODULES
    ----------------------------------------------------------------------
    Peak/Valley Generator with internal clock                SLEW 1,1   i
    Peak/Valley Generator with internal clock                SLEW 1,2   j

    Purpose:  Generate a smooth path (always steps by 1) toward a
       bounded, randomly selected target.  Optomized to produce moving
       note velocity values.

    Output:  Always one more or less than last output, depending on
       direction of travel and whether the target has been reached. Upon
       reaching the internally generated random target, the up/down
       direction reverses.

    Count "c" input: Number of clocks before the next output value is
       calculated.

    Range (up-arrow) input: internally generated target is limited to
       one less than this value.  One fourth of this value is then added
       to the output as an automatic offset.  For example, if the range
       is 10 hex, actual values will range from 4 to 13 hex.

    ----------------------------------------------------------------------
    Peak/Valley Generator                                    SLEW 2,1   k

    Purpose:  Generate a smooth path (always steps by 1) toward a
       bounded, randomly selected target.

    Output:  Always one more or less than last output, depending on
       direction of travel and whether the target has been reached. Upon
       reaching the internally generated random target, the up/down
       direction reverses.

    Clock (heart) input: Any non-zero after zero causes the current output
       value to be incremented/decremented.

    Hold (check) input:  Non-zero holds current output.

    Range (up-arrow) input: internally generated target is limited to
       one less than this value.

    Offset + input: Added to the output.

    ----------------------------------------------------------------------
    Peak/Valley Generator with arbitrary step size           SLEW 2,2   l

    Purpose:  Generate a slope with arbitrary step size toward a bounded,
       randomly selected target.

    Output:  Last output (less offset) plus/minus the value of the step
       size, depending on direction of travel and whether the target has
       been reached. Upon reaching the internally generated random
       target, the up/down direction reverses.

    Clock (heart) input: Any non-zero after zero causes the current output
       value to be incremented/decremented.

    Hold (check) input:  Non-zero holds current output.



                                   64



    Range (up-arrow) input: internally generated target is limited to
       one less than this value.

    Step Size "+/-" input:  Any value, although large numbers will
       normally be of little use.

    Offset + input: Added to the output.

    ----------------------------------------------------------------------
    Fast Slew                                                SLEW 3,1 \E5

    Purpose:  Slew from value "a" to value "b" at rate "r".  Generally
      used for fast slews that do not need to step sequentially through
      each of the intermediate values.

    General:  Whenever a change is detected in either the "a" or the "b"
       input, the module will set the output to the value at the "a"
       input, then, each calculation cycle, it will decrement the output
       at a rate determined by the formula below, until the output
       reaches the value that was in the "b" input at the time the module
       started slewing.

       To slew from one value to another like an analog lag processor,
       plug the output into tha "a" input, and the value to be slewed
       into the "b" input.  Whenever the "b" input changes, the output
       will slew from the last value at "b" to the new value.


    Formula:

         initialize:
              input (a) * rate (r) --> sum (internal)
              input --> output

         thereafter until sum/rate = target (b):
              sum - input + target --> sum
              sum/rate             --> output


    Output:  Slewed input, according to the above formula.

    Start "a" input:  Any value.

    Target "b" input:  Any value.

    Rate "r" input:  Any value, but useful values are dependent on the
       slew speed, and the magnitude of the difference between the start
       and target inputs.  Values below about 10 (hex) are seldom useful.

    ----------------------------------------------------------------------
    Slow Slew                                                SLEW 3,2 \EB

    Purpose:  Slew from value "a" to value "b", over a cycle time "t".
       Generally used for slower slews, or for slews that must step
       sequentially through each of the intermediate values.

    General:  Whenever a change is detected in either the "a" or the "b"
       input, the module will set the output to the value at the "a"
       input, then, each calculation cycle, it will decrement the output
       at a rate determined by the formula below, until the output


                                   65



       reaches the value that was in the "b" input at the time the module
       started slewing.

       To slew from one value to another like an analog lag processor,
       plug the output into tha "a" input, and the value to be slewed
       into the "b" input.  Whenever the "b" input changes, the output
       will slew from the last value at "b" to the new value.

    Formula:

         initialize:
              input (a) * 256 --> sum (internal)
              input --> output

         thereafter until sum/256 = target (b):
              at every nth cycle, determined by cycle time (t):
                   sum - input + target --> sum
                   sum/256              --> output

    Output:  Slewed input, according to the above formula.

    Start "a" input:  Any value.

    Target "b" input:  Any value.

    Time "t" input:  Any value, but values greater than about 10 (hex)
       are VERY slow.


    ----------------------------------------------------------------------
    Filter                                                   SLEW 3,3 \9F

    Output:  Average of last clocked 2, 4, 8, or 16 Value inputs,
       depending on current value of Filter input.

    Clock (heart) input:  Any non-zero after zero will cause the current
       value input to be averaged with the preceding inputs, and a new
       average will be sent to the Output.

    Filter "f" input:  Values of 0-3 (input is ANDed with 3) will set the
       number of inputs to be averaged to 2, 4, 8, or 16.  This is very
       similar to a Filter Cutoff input on an analog low pass filter, or
       the lag time on an analog lag processor: higher numbers will cause
       greater lag.

    Offset "+" input:  Added to the current output.
















                                   66



    ======================================================================
                                SAMPLE MODULES
    ----------------------------------------------------------------------
    Echo                                                   SAMPLE 1,1 \90

    Purpose:  This module is actually a special case of a sequencer,
       designed to write into one memory location while also reading from
       another location.  The difference between these locations is the
       amount of delay (in clocks) between the input value and output
       value.  Unlike the general sequencers, which allow specific
       addressing of any memory cell in their address range, the Echo
       module allows addressing of runs of 16 memory cells, with the
       exact cell in a particular run addressed by an internal index.
       Like all sequencers, no memory locations will be written if the
       Write Enable input is zero; it will merely loop thorugh the
       addressed 16 step run of previously stored data.

    Magenta User Input (just left of label tag):  Current 16-step run.
       There are 16 runs of 16 steps each.  This input is used to
       manually set the desired run, 0-F hex.  Defaults to the same run
       as the module number, so each module has a unique sequence storage
       area.  Can be changed for special effects.

    Output:  Copy of the memory cell addressed by the internal index plus
       the value at the Delay input ANDed with F hex to stay within the
       16 cell range.  Note that the output is fetched BEFORE writing a
       new value to memory, allowing a read/write of the same memory cell
       during the same clock tick.

    Clock (heart) input:  Any non-zero after zero will cause a new output
       to be generated, and if the write enable is non-zero will save the
       current Value input.

    Delay ">>" input:  Sets the negative offset from the current internal
       index that the module will read data from.  Since Value data is
       always written to the run at the current internal index, and is
       read at the internal index minus the value at the Delay input, the
       effect of this input is to control the number of clocks by which
       the output will lag the input.  Note that the run length is 16
       memory cells, therefore values over 15 (F hex) are normalized by
       ANDing them with F (hex).

    Write Enable (omega) input:  Any non-zero allows storing the Value
       input data into the run. Changing this input between non-zero and
       zero while it is playing has the effect of looping a previously
       tracked run of notes, and can often be used to good effect.

    Value "-->" input:  Value to be written when Write Enable is ON.
      With the Delay input set to zero and the Write Protect input set to
      non-zero, the output should track the Value input.  If it does not,
      it is likely that the priority number of the Delay module is not
      high enough, and it is detecting input from a module (with a higher
      priority number) that is being calculated only AFTER being stored
      by the Delay module. You can fix this by swapping a few priority
      numbers, or you can ignore it and allow the Delay input to be 1
      clock higher than it says.

    Offset "+" input:  Added to the current output.




                                   67




    ----------------------------------------------------------------------
    Delay                                                  SAMPLE 1,2 \D0

    Purpose:  Delays the output by a set number of MIDI clocks.

    Output:  A copy of the input, delayed up to 255 clock cycles.

    Value "-->" input:  Any value.

    Delay "c" input:  Number of MIDI clocks (calculation cycles) by which
       the output is to lag the input.  When 0, the input is simply
       echoed to the output.  When 1, the output will follow the input by
       1 MIDI clock, when FF (hex), the output will follow by 255 clocks.

    Offset "+" input:  Added to the current output.

    ----------------------------------------------------------------------
    Peak Hold                                              SAMPLE 2,1 \1E

    Output:  Highest value seen at the Value input since last Reset.

    Reset input:  Non-zero copies Value input to Output.

    Value "-->" input:  Any value.

    ----------------------------------------------------------------------
    Valley Hold                                            SAMPLE 2,2 \1F

    Output:  Lowest value seen at the Value input since last Reset.

    Reset input:  Non-zero copies Value input to Output.

    Value "-->" input:  Any value.

    ----------------------------------------------------------------------
    Sample and Hold                                        SAMPLE 3,1 \15

    Output:  Copy of Value input plus Offset input as set by the last
       Strobe or Track.

    Track "=" input:  Non-zero tracks current input; zero holds.

    Strobe "!" input: Non-zero after zero takes a new sample.

    Value "-->" input: Value to be sampled.

    Offset "+" input:  Added to sampled/tracked input.

    ----------------------------------------------------------------------
    Delta                                                  SAMPLE 3,2 \7F

    Output:  The absolute difference between the current Value input and
       the last different Value input.  Effect is to generate a constant
       rate of change (delta) when the Value input is changing, and to
       hold it at the last delta while the Value input remains constant.

    Value "-->" input:  Any value.




                                   68



    ======================================================================
                                BOUNDS MODULES
    ----------------------------------------------------------------------
    Maximum                                                BOUNDS 1,1 \18

    Output:  Copy of the greater of the two Value inputs.

    Value inputs:  Any values.

    ----------------------------------------------------------------------
    Minimum                                                BOUNDS 1,2 \19

    Output:  Copy of the lesser of the two Value inputs.

    Value inputs:  Any values.

    ----------------------------------------------------------------------
    Bounds                                                 BOUNDS 1,3 \17

    Output:  Copy of the Value input, bounded by the MAX and MIN inputs.

    MAX input: Sets upper bounds. Inclusive.

    MIN input: Sets lower bounds. Inclusive.

    ----------------------------------------------------------------------
    Quantize                                               BOUNDS 2,1 \FC

    Output:  Copy of the Match input that most nearly matches the Value
       input.

    Normalize (divide-symbol) input:  When not zero, quantizing is done
       on multiples of this value.  Setting to C hex, for example, will
       normalize to an octave.  When zero the input is disabled.

    Value "-->" input: Any value.

    Match inputs "a" - "h":  These eight inputs are set to values that
       will be matched with the Value input.  Can be used to good effect
       to force a random number to conform to a scale, or to transform
       one scale to another.  Note that the match is calculated starting
       with input "a", and in the event of a tie, the first match is
       used.  This means that if the Value input was 7, input "a" was 6,
       and input "b" was 8, and no other input was 7, the output would be
       6; however if input "a" was 8 and input "b" was 6, the output
       would be 8.

    ----------------------------------------------------------------------
    Sort                                                   BOUNDS 2,2 \1D

    Output:  One of the four inputs determined by the ascending order of
       the input values, as selected by the Order input.

    Order "@" input:  This input determines the ascending order of the
       inputs that will be read.  Zero reads the lowest of the four
       values, one reads the next higher, etc.

    Value inputs "a" - "d":  Any values, any order.




                                   69



    ----------------------------------------------------------------------
    Approximate Value                                      BOUNDS 3,1 \F7

    Output:  An approximate (within set limits) copy of the input.

    Value "-->" input:  The base value, which is approximately echoed at
       the output.  A change in this input will cause a new output to be
       generated.

    MAX (up arrow) input:  Set upper limit of approximation. Inclusive.

    MIN (down arrow) input:  Set lower limit of approximation. Inclusive.


















































                                   70



    ======================================================================
                                OCTAVE MODULES
    ----------------------------------------------------------------------
    Octave to Note                                         OCTAVE 1,1 \F8

    Output:  Note value of given octave plus offset.

    Octave value "-->" input:  Octave number to be translated into the
       note value.  Input is multiplied by 12 to give the note value.

    Offset "+" input:  Any value, added to the output.

    ----------------------------------------------------------------------
    Octave of Note                                         OCTAVE 1,2 \F6

    Output: Octave number of given note value.

    Note value "-->" input:  Note value to be translated into an octave
       number.  Input is divided by 12 to give the octave number.

    ----------------------------------------------------------------------
    Octave Normalize                                       OCTAVE 2,1 \A2

    Output:  Base note value of given note plus offset.

    Note value "-->" input:  Note value to be normalized to a base note
       range of 0 - 11. Input is multiplied by 12, and the remainder is
       returned as the base note value.

    Offset "+" input:  Any value, added to the output AFTER normalizing.

    ----------------------------------------------------------------------
    Note Fold                                              OCTAVE 2,2 \F4

    Output:  Note value of given note folded to within a given octave
       range, plus offset.

    Note value "-->" input:  Note value to be folded into a base octave
       range between 0 and the given octave fold range.

    Octave fold range "o" input:  Octave range that the note input will
       be translated to.  A value of 0 gives a note value of 0 - 11, 1
       gives a note value of 0 - 23, etc.

    Offset "+" input:  Any value, added to the output AFTER folding.

















                                   71



    ======================================================================
                               SPECIAL MODULES

    These modules allow MusicBox to interface with external input/ output
    ports, and with external programs.  Because they allow direct access
    to the computer internals, if they are used without knowing exactly
    what is going on, they will likely cause the computer to crash.

    ----------------------------------------------------------------------
    External Call                                         SPECIAL 1,1 \8A

    Purpose:  Allow MusicBox to control non-MIDI devices, or allow
       installation of custom functions.  Access to other programs is
       available through use of software interrupts.  Usually, the
       programs will be of the "terminate but stay resident" type, such
       as the Microsoft Mouse driver.

    Output:  Contents of flag register after the software interrupt.

    Strobe "!" input:  Non-zero after zero will trigger the module,
       transferring control from MusicBox to the external interrupt.

    Interrupt number "e" input:  The interrupt vector that will be called
       when strobed.

    Register "A" to "d" inputs:  CPU registers are loaded with these
       values prior to calling the interrupt.  Input "A" goes to AH, "a"
       to AL, "B" to BH, etc.


    ----------------------------------------------------------------------
    External Call Registers                               SPECIAL 1,2 \88

    Purpose:  Allow access to CPU registers after an external call.

    Output:  Value of selected register at last strobe.

    Strobe "!" input:  Non-zero after zero will cause the currently
       addressed register data to be sent to the output.

    Register select "r" input:  Select one of 8 CPU registers to be sent
       to the output:

         0 = AL    1 = AH
         2 = BL    3 = BH
         4 = CL    5 = CH
         6 = DL    7 = DH















                                   72



    ----------------------------------------------------------------------
    Outport                                               SPECIAL 2,1 \95

    Purpose:  Send a byte to the computer output port.

    Strobe "!" input:  Non-zero after zero will trigger the module,
       sending the byte at the value input out to the port addressed by
       the "P" and "p" inputs.

    Value "-->" input:  The value to be sent to the output port.

    Port address high "P" input:  Most significant byte of port address.

    Port address low "p" input:  Least significant byte of port address.


    ----------------------------------------------------------------------
    Inport                                                SPECIAL 2,2 \8D

    Purpose:  Fetch a byte from the computer input port.

    Output:  Most recent results of an input fetch from the port
       addressed by the "P" and "p" inputs.

    Strobe "!" input:  Non-zero after zero will trigger the module,
       fetching the byte to the output from the port addressed by the "P"
       and "p" inputs.

    Port address high "P" input:  Most significant byte of port address.

    Port address low "p" input:  Least significant byte of port address.

    ----------------------------------------------------------------------
    Peek                                                  SPECIAL 3,1   }

    Purpose: Fetch a byte from the computer memory.

    Output:  Most recent results of a memory fetch from the byte
       addressed by the "$", "P" and "@" inputs.

    Strobe "!" input:  Non-zero after zero will trigger the module,
       reading the byte from the memory location addressed by inputs "$",
       "P" and "@".

    Memory segment address "$" input: High byte of 8086 segment address
       used to address memory.  Low byte is forced to 0.  For example, to
       read from the Color Display Area, Segment address B800 (hex), set
       this input to "B8".

    Address high "P" input:  Most significant byte of memory address.

    Address low "@" input:  Least significant byte of memory address.










                                   73



    ----------------------------------------------------------------------
    Poke                                                  SPECIAL 3,2   {

    Purpose:  Write a byte to the computer memory.

    Value "-->" input:  The value to be written to the computer's memory.

    Strobe "!" input: as in Peek, but triggers a memory write rather than
       a memory read.

    Memory segment address "$" input: as in Peek.

    Address high "P" input:  as in Peek.

    Address low "@" input:  as in Peek.

    ----------------------------------------------------------------------
    Mute Flags                                            SPECIAL 3,3 \E8

    Purpose: Allow access to and program control of mute flags. Typically
       used as mute input to the MIDI Note module.

    Output:  8 bits of the 16 bit mute status, as positioned and selected
       by the Shift and Mask inputs.

    Mute "0" input:  Mute switches 0-7.  Last changed bit changes the
       switch.  Bits ON highlight the lower left screen MUTE switches.

    Mute "8" input: Mute switches 8-F, as above.

    Shift ">>" input:  Positions the 8 bit output to a window in the 16
       bit mute flags.  Set at 0 to read flags 0-7, at 8 for flags 8-F.

    Mask "&" input:  Allows individual flags to be isolated.  Bits set hi
       allow the flags to pass through.  Set to FF hex to disable.



























                                   74



    ======================================================================
                                SYSTEM MODULES

    System modules are unique in that there is only one copy made of each
    module.  The label has "$" after the icon rather than the module
    number to indicate that it is a system module.

    ----------------------------------------------------------------------
    Alpha Control Module                                   SYSTEM 1,1 \E0

    Purpose:  Controls several global functions, some of which are only
       distantly related.

    Output:  NZ when the HLT menu function is selected.

    Global Hold (check) input:  Reset and Hold for all modules with Hold
       inputs.  Allows all clocks, etc. to be held and sync'd with just
       the one Alpha Hold.  When zero, if in play mode, the Program
       modules will sequence.

    Global Program module address "@" input:  Change in value sets
       address parameter for all active Program modules.

    Mute/Solo "/o/" input:  Non-zero sets mute mode for menu mute flags,
       non-zero sets solo mode.

    Play/Program (omega) input:  Set Play/Program mode.  Non-zero puts
       Program modules in Program mode, zero puts them in Play mode.

    Beats per Measure "|" input:  This value and the value following will
       determine the "clocks per measure", which is used by the Measure
       clocks, the Note clocks, and (to determine the sequence rate) the
       Program module.

    Note value (note) input:  Note value for the system time signature.
       1 = whole, 2 = half, 3 = quarter, 4 = eighth, 5 = sixteenth, 6 =
       thirtysecond.

       This input plus the Beats per Measure input, above, are used like
       a standard time signature i.e., 3 in the Beats input and 3 (for a
       quarter note) in the note input would result in 3/4 time.

       The MIDI standard, which  calls for 24 ticks per quarter note, is
       used by MusicBox to set note and measure values; but the actual
       temporal resolution -- the time value of the ticks -- is set by
       the Tempo input, below.  It is important to realize that the
       "ticks" are actually calculation cycles.  That is, for every tick,
       MusicBox calculates new values for every active module. This means
       that for every quarter note, the modules are calculated 24 times;
       for every eighth note they are calculated 12 times, every
       sixteenth note, 6 times, etc.  This becomes important information
       when setting beat advances and retards, delay times, etc.

       Since for every quarter note, there are always 24 ticks; for every
       measure there are (ticks per note of the note value input) *
       (beats per measure value input) cycles. 

       For 4/4 time, the default, there are (Note value = 3 = quarter
       note = 24 ticks) * (beats per measure = 4) = 96 (60 hex) ticks per
       measure.


                                   75




    Tempo (diamond) input:  Sets tempo in quater notes per minute.  If
       the yellow time-overload indicator (below) is on, the tempo 
       becomes inaccurate.

       Timing is controlled by an internal real-time clock, which
       generates interrupts at the rate of some 580 times per second.
       The Tempo input allows the user to set the number of these
       interrupts that will occur between module calculation cycles
       ("ticks").  The effect is the same as setting a metronome. The
       default tempo is 120 (78 hex).  When set to FF hex, the computer
       will process the modules at maximum speed.

    Random number reset "?" input:  Non-zero holds all random number
       generators, and sets the seed to that value, or to the seed
       specified at the module.  The pattern of numbers generated is 
       repeatable and is dependent on the starting seed value.

    MIDI Sync "s" input:  Bit 0 sets MIDI output sync: if non-zero, a
       MIDI sync pulse is output.  Bit 1 sets MusicBox tempo to sync with
       an externally produced MIDI sync pulse.  Bit 1 or 2 inhibits
       normal sending of MIDI Active Sensing.

       MIDI sync is used for recording Midi data to an external sequencer
       from MusicBox.  If the external sequencer sync is set to "internal
       sync" (it is generating the MIDI sync), set the "s" value to 2,
       for MusicBox to accept MIDI sync instead of using its own internal
       timing for generating the tempo.

       If the external sequencer/recorder is set to "MIDI sync" (it wants
       to get its sync from MIDI), set the "s" value to 1 so that
       MusicBox will generate a MIDI sync signal.

    Halt "0" input:  Non-zero (except FF) in this input is the same as
       selecting the menu HLD command.  If this value is set to FF,
       MusicBox will exit to DOS, as if the QUIT command was selected.

    Indicator (yellow):  This number is the calculation cycles available
       before time-overload.  The greater the number, the more
       calculating time remains available.  The value will decrease
       either when more modules are added or when the Tempo is increased.
       When it reaches 0, the yellow indicator will highlight.
       Everything will continue to work ok, but timing values will no
       longer be absolute or accurate.

       When the Sync input is set to 2 (external MIDI sync), then the
       readout is simply a count of the incomming MIDI sync data.  It
       will appear as a rapidly counting index as the external sync is
       received.  

    ----------------------------------------------------------------------
    MIDI Real Time                                         SYSTEM 1,2 \9D

    Purpose:  Send and/or receive MIDI Real Time messages.  Most commonly
       used when saving MusicBox output to an external MIDI sequencer-
       recorder.  Most of these devices need a Start message in addition
       to the MIDI sync signal (set by the Alpha module).  MIDI Stop,
       Start, and Continue messages can be sent and received; Reset and
       Tune Request messages can be sent.



                                   76



    Output:  Bits 0, 1, and 2 correspond to Stop, Start and Continue
       messages being received at the MIDI data input.  These bits are
       latched; they can be cleared by the "!" input.

    S, G, C, R, and T inputs:  Transitions from zero to non-zero at these
       inputs will send MIDI System Real Time messages for Stop, Start
       (Go), Continue, Reset, and Tune request.  Note that when these
       messages are sent they may be passed through by the receiving
       device and be detected at the MIDI input of MusicBox, and echoed
       as bits set at the module output.

    Clear "!" input:  Transition from zero to non-zero resets the module
       output to zero.

    ----------------------------------------------------------------------
    MIDI Control Change Map                                SYSTEM 2,1 \94
    MIDI Control Change Map                                SYSTEM 2,2 \81

    Purpose:  Maps MIDI Control Change values to the 8 Control Change
       inputs of the corresponding Control Output module.

       Default Control Change numbers, with Yamaha's names:

               V  =  7  =  Volume
               M  =  1  =  Modulation Wheel
               A  =  2  =  Breath Controller
               B  =  3  =  Unspecified
               C  =  4  =  Foot Controller
               D  =  5  =  Portamento Time
               1  =  64 =  Sustain Foot Switch
               2  =  65 =  Portamento Foot Switch

    ----------------------------------------------------------------------
    PC Beep                                                SYSTEM 2,3 \0F

    Purpose:  Sound a tone on the PC speaker.

    Clock (heart) input:  Any non-zero after zero will sound the tone set
       by the Value input, zero will turn it off.

    Value "-->" input:  Any value may be sent, but pitch changes are
       meaningful only from about 20 hex to 60 hex.


    ----------------------------------------------------------------------
    Console Input                                          SYSTEM 3,1 \FB

    Purpose:  Allow access to console input.  This is normally the
       computer keyboard, but it may be a serial port or a file, if input
       is redirected when MusicBox was first loaded.  See DOS manual for
       further information on redirected i/o.

    Output: Most recent console character.  Bit 7 of the output goes high
       for one cycle whenever a new character is input.

    Hold (check) input:  When non-zero, input will not be read.






                                   77



    ----------------------------------------------------------------------
    MIDI Data Input                                        SYSTEM 3,2 \1A

    Purpose:  Allow access to incomming MIDI data stream.  The data
       stream is buffered in the s-sequencer memory area, and is accessed
       through those modules.  This module enables and disables the data
       flow, and indexes the incoming MIDI events.

    Output:  Address (in the F hex run of the "B" sequencer memory area)
       of the most recent incomming MIDI data.  Increments on each
       incomming MIDI data byte.

    Reset strobe "!" input:  Resets the write address to 0.

    Enable (omega) input:  When non-zero, the module will write incomming
       MIDI data to the sequencer memory addressed by the output index.
       When zero, the index will continue to increment with incoming
       data, but the module will not write to the sequencer memory.

    ----------------------------------------------------------------------
    Incoming Data Stream Select                            SYSTEM 3,2 \AB

    Purpose:  Inhibit/pass incomming MIDI data from either or both of the
       MPU's.  Also displays active incoming stream.

    Output:  Most recently active incomming data stream.  Bit 0 is MPU-1,
       bit 1 is MPU-2

    Hold (check) input:  Non-zero inhibits resetting of the output flags,
       causing the output to remain unchanged unless incoming data is
       from a different MPU.  If zero, the output will strobe with each
       new incoming data packet.

    Mask "&" input:  Bits 0 and 1 pass incoming data from MPU1 and MPU2
       respectively when set, and inhibit it when clear.  Default is 3,
       accept data from both MPU's.

    ----------------------------------------------------------------------
    MIDI Output Buffer Status                              SYSTEM 3,3 \F9

    Purpose:  Show MIDI output activity.

    Output:  TRUE when MIDI output buffer is not empty.  Effect is to
       flash when there is outgoing MIDI data.

    [end]
















                                   78












