MIDI Sound Designer With Randomizer Function

1. The Field of the Invention

The present invention relates generally to electronic musical systems, and more particularly, to such systems interfaced and controlled via the Musical Instrument Digital Interface (MIDI).

2. Background Information

For competitive differentiation, musicians seek new sounds. Sounds contain certain significant elements (pitch, amplitude, timbre, etc) analogous to colors (frequency, intensity, etc.). In a musical context, a musical sound is made up of certain elements; the combination of these sonic ingredients is how music is made.

As schematically illustrated in FIG. 1, a Total Sound (20) is a combination (18) of timbres (16). Timbre is the quality in sound that distinguishes one sound from another. Timbres (16) can be electronically synthesized using a combination (14) of waveforms (10) and waveform modifiers (12). New Total Sounds can be created by developing new waveforms and modifiers, new timbres, and/or by developing new timbral combinations.

Electronic synthesizers have introduced many new waveforms and waveform modifiers, thus leading to new timbres which lead to new Total Sounds. However, this process of developing new sounds has been difficult for musicians to apply. Developing new sounds has required creating and manipulating waveforms and modifiers which is tedious and too technically demanding for most musicians. In addition, each synthesizer has unique parameters for waveforms and modifiers, and each synthesizer manufacturer has its own operating system to program such parameters. The skills and knowledge required to develop new Total Sounds by this method is as particular as each synthesizer's parameters and operating system. Therefore, a need exists to create new Total Sounds independent of synthesizers' parameters or operating systems.

Another means of developing new Total Sounds is by uniquely combining individual timbres. This can be accomplished using MIDI to control multiple sound generators. MIDI has a standardized set of commands and parameters. The benefit of using MIDI is its portability, i.e., MIDI programming skills can be transported and applied to any MIDI Sound Generator and to any MIDI system.

MIDI is a hardware and software specification voluntarily adhered to by manufacturers of electronic musical instruments and other related products. MIDI is a control protocol whose primary function is to control one device from another device. For example the controlling device would instruct the slave device(s) to turn on a certain note at a desired level. For more information on MIDI, refer to the Detailed MIDI Specification 1.0 published by the MIDI Manufacturer's Association.

A MIDI electronic musical system typically includes a MIDI controller which controls a plurality of MIDI sound generators. Audio signals from the sound generators are combined and broadcast by a sound system to produce the audible Total Sound. Today's sophisticated MIDI controllers are typically menu driven. Although faster than manual control and adjustment of numerous function knobs, menu selection of a desired function may inhibit, rather than enhance, the creative flow of a musician.

A need thus exists for a MIDI controller which facilitates development of new Total Sounds, without inhibiting the musician's creativity.

The above described needs are satisfied, the limitations of the prior art overcome, and additional benefits achieved, in accordance with the principles of the present invention, through the provision of a MIDI controller having a randomizer function.

The present invention is premised upon the recognition that the most important elements in the construction of new Total Sounds are timbre, pitch, volume and dynamic response. The MIDI controller of the present invention assigns pseudorandom values to these elements to create new and unique sounds. The randomizing function of the present invention performs a form of high level additive synthesis, wherein entire timbres are uniquely combined to create new sounds.

The present invention provides a means to randomly develop timbral combinations, a means to select which elements are randomized, and a means to manually edit these and other elements to produce the desired Total Sound.

Accordingly, it is an object of the present invention to produce new and unique Total Sounds based on both random configuration of particular elements and configurations based on the user's options to combine only certain elements of choice and to create sound samples of these combinations to be heard, selected and retained in memory. The ability to choose only certain elements to be randomly configured by the system allows the user to guide the direction of the sound layers being created to produce those sounds desired, but in unique configurations that would be virtually impossible for the user to create because of the complexity of the interaction it would take with the individual sound generating sources.

According to the present invention, a MIDI controller with the randomizer function develops new sounds by pseudorandomly combining the four key elements in a timbral combination utilizing the industry standard MIDI protocol. The randomizer function frees the musician from the underlying technology enhancing the musician's creativity and allowing the musician to selectively guide the automatic generation of desired new Total Sounds.

These and other objects, features and advantages of the present invention will be more readily understood from the following detailed description of a preferred embodiment, when read in conjunction with the accompanying drawings.

FIG. 1 shows components of a Total Sound.

FIG. 2 depicts a typical MIDI electronic music system.

FIG. 3 presents a functional block diagram of a typical MIDI Sound Generator.

FIG. 4 is a functional block diagram of a MIDI Controller with Randomizer, constructed in accordance with the principles of the present invention.

FIG. 5 comprises a flowchart of the main program of the scanner of the MIDI controller.

FIG. 6 presents a basic flowchart of all subroutines in the processor of the MIDI controller.

FIG. 7 is a functional block diagram illustrating how the randomizer operates.

FIG. 8 is a flowchart illustrating a processor subroutine for a Timbre Change Event.

FIG. 9 depicts, in flowchart form, a processor subroutine for a Volume Change Event.

FIG. 10 is a flowchart illustrating a processor subroutine for a Note On Event.

FIG. 11 depicts, in flowchart form, a randomizer subroutine which randomizes pitch through the transposition.

FIG. 12 is a flowchart of a randomizer subroutine which randomizes dynamic response through the velocity amount.

For music performance applications, a MIDI electronic musical system, as shown in FIG. 2, typically includes a MIDI Source (22) which controls a plurality of MIDI Sound generators (24) via MIDI, and a sound system (26) through which the sound is heard. Typically the musician produces notes on the MIDI source. The MIDI source (22) then instructs certain MIDI sound generators (24) as to which timbre to use, which notes to play, the volume at which the notes are played, etc. The audio signal is amplified and heard through speakers of sound system 26.

FIG. 3 illustrates an electronic synthesizer that can be controlled via MIDI, and is commonly known in the field and referred to herein as a MIDI Sound Generator (24). A MIDI signal (46) emanates from the MIDI source and enters the MIDI Sound Generator through the MIDI IN port (28). The MIDI Sound Generator (24) contains an internal MIDI processor (30) which determines how to respond to the incoming MIDI commands.

MIDI sound generators are capable of changing timbres, playing notes, modifying notes, among other tasks, via MIDI. The configuration of waveform generators and modifiers changes for each timbre produced. Each timbre is stored and recalled from timbral memory (32).

When playing notes, each note starts in a Waveform Generator (34) and is modified by any number of Waveform Modifiers (36-40). The outputs are then summed (42) to produce the audio output (44). Waveforms are generated and modified through a variety of known technologies. Such MIDI sound generators are available from a variety of sources, including Yamaha and Ensoniq.

Referring again to FIG. 2, the MIDI signal for each MIDI sound generator (24) comes from a MIDI source (22). MIDI source (22) can be any device which generates MIDI data. MIDI controllers, synthesizers, sequencers, etc. are examples of MIDI sources commonly known in the field.

One common source of MIDI data is a MIDI Controller. A MIDI controller (51) constructed according to the principles of the present invention is illustrated in FIG. 4. The primary function of a MIDI Controller is to produce MIDI commands based on human input. MIDI Controllers have an input device to generate notes. The input used for notes is typically capable of determining the dynamic response of the notes. A typical device for producing note input is a keyboard (56), though other input devices may be used. Keyboards often use a dual contact method to discern the speed at which the key was struck, i.e. "Key Speed," which determines the dynamic response of the note. Methods of determining the dynamic response of notes, other than a dual contact keyboard, currently exist.

MIDI controller 51 includes a plurality of note modifiers (48) that produce continuous inputs which are A/D converted by A/D converter (50) and used as inputs by a scanner (54). Controller 51 also has numerous switch inputs (52) that are used as note modifiers and also to operate and program the apparatus through the scanner (54).

Scanner (54) is preferably implemented as a programmed microcontroller with RAM, ROM, A/D converter, timer and parallel ports. The primary function of scanner (54) is to generate Events based on changes on the inputs (48,52,56). When the scanner recognizes a change of state, it generates the proper Event based on the contents of an Element Memory (60) and writes the Event to an Event Compiler (58) which is typically a First-In-First-Out (FIFO) buffer.

An Event is a change of input state from which either MIDI commands will be generated, or an internal function is executed. Examples of Events are: Note On Event, Note Off Event, Timbre Change Event, Volume Change Event, Pitch Bend Event, etc.

The main routine of the scanner is shown in FIG. 5. The scanner sequentially checks each input for a change of state (Query 160). If no change was recognized, the routine loops back and checks again. If any notes changed state (Query 162), the main routine calls the note subroutine (164) which generates the appropriate note event(s), writes the event(s) to the Event Compiler (58), and then returns to the main routine. If any continuous inputs changed (Query 166), e.g. a knob was turned, the main routine calls the continuous input subroutine (168) which generates the appropriate event(s), writes the event(s) to the Event Compiler, and then returns to the main routine. If any switch inputs changed (Query 170), e.g. a switch went from open to close, the main routine then determines the function of the switch (172) based on the memory mapped address of the switch input. For switches that are used to formulate MIDI commands, the main routine calls the note modifier subroutine (174). In this subroutine, the appropriate events are generated, written to the Event Compiler (58), then operation is returned to the main routine. Examples of note modifier events include manually entered Timbre Change event, MIDI Switch Controller event, etc. For all other switches, the main routine calls the operating system switch subroutine (176). Such subroutines may record edited data into memory, change the contents of various displays, change an input's sensitivity, etc. These are functions that do not generate MIDI commands, and relate to the operating and programming of the apparatus. The main routine then loops back to the beginning.

Referring again to FIG. 4, another function of the scanner (54) is to edit the contents of Element Memory (60). Here, the scanner reads from and writes to Element Memory based on switch inputs (52).

An Element is a piece of data used to configure software switches, filters and operators in a Processor (62) of the MIDI controller. The Elements are stored in Element Memory (60). A complete set of elements comprises a Master Program. A plurality of Master Programs reside in Element Memory.

An operator is a software configured portion of Processor 62 which acts on incoming data to produce the desired output data. For example, a transpose operator adds 12 to the key number to shift up twelve semitones.

Processor (62) implements a series of subroutines which convert Events into MIDI commands. All of the subroutines have the same basic format as illustrated in FIG. 6.

The Processor retrieves the next Event from the Event Compiler (58). Processor (62) then executes the subroutine that corresponds to that Event. As shown in FIG. 6, initially the Processor checks if the first channel is enabled (Query 122). If disabled, operation skips to the next channel (Query 130). If the first channel is enabled, the Processor formulates the appropriate MIDI status byte (124), and all necessary MIDI data bytes (126), and then transmits the MIDI command (128) out of the MIDI OUT port. Operation then continues to the next channel (130). If the second channel is enabled (130), the appropriate MIDI status byte (132) and MIDI data bytes (134) are formulated and the MIDI command is transmitted (136). This procedure is repeated for the third and fourth channels as illustrated in the flow chart. The Processor can be implemented with a microcontroller, ROM, RAM and serial port, as is well known in the art. Conventional operation of the MIDI controller will now be described, with general reference to FIGS. 3 & 4.

To change the timbre(s) on the MIDI sound generators connected to the MIDI controller (51), the musician presses the appropriate switch(es). The scanner (54) recognizes the switch(es) and writes a Timbre Change Event onto the Event Compiler (58). The Processor (62) then transmits the appropriate MIDI Timbre Change (more commonly referred to as MIDI Program Change) command from the MIDI OUT port (66). The MIDI sound generators (24) receive the command through their respective MIDI IN ports (28), and retrieve the appropriate timbre from timbral memory (32). All subsequent notes played will have this new timbre.

The MIDI controller (51) is also capable of changing the volume levels of the MIDI sound generators connected to it. When the musician presses the appropriate switch(es) and/or changes the position of the appropriate continuous inputs, the scanner (54) generates the Volume Event and writes it to the Event Compiler (58). The Processor (62) then converts this event into the appropriate MIDI volume change commands which are transmitted from the MIDI OUT port (66). This command is used by the MIDI Sound Generators to determine the volume of all notes.

Whenever the musician plays a note on the keyboard (56), the scanner (54) determines which key was played, i.e. key number, then determines the key speed. With these two pieces of information, the scanner generates the Note On Event and writes it to the Event Compiler (58). The Processor (62) then converts this event into the appropriate MIDI Note On commands which are transmitted from the MIDI OUT port (66). This command is used by the MIDI Sound Generators to play notes.

The MIDI Note On command consists of a status byte and two data bytes. The first data byte is the note number from 0 to 127. This byte is used by the MIDI sound generators to determine the pitch of the note. The second data byte is the velocity amount. The MIDI sound generators use this byte to determine the dynamic response of the note.

One method of formulating the note number data byte is to use the key number as a base address. For example, the lowest key on the keyboard would have key number=0, the next key up from the lowest key would have key number=1, etc. The MIDI note number can then be computed by adding a transpose offset to the key number.

One method of formulating the velocity data byte is to use the key speed as an index into a look-up table. The dynamic response can be changed by changing look-up table index.

The presently preferred embodiment of the inventive apparatus is capable of producing four MIDI Note On commands for each Note On Event. The Processor uses Key Speed from the Event Compiler as an index into a look-up table that translates into MIDI Note Velocity values. The preferred embodiment has 32 entries in the look-up table in memory.

In accordance with the present invention, a Randomizer 64, is incorporated into MIDI controller 51 in order to facilitate the generation of new Total Sounds. This Randomizer takes into account what is believed to be the most important elements in the construction of new Total Sounds, these being timbre, pitch, volume and dynamic response, and assigns random (yet intelligible) values to these elements to create new and unique sounds that otherwise might not be possible.

The randomizer function performs a form of high level additive synthesis, where entire timbres (waveforms & modifiers) are uniquely combined to create new sounds. This is fulfilled through the MIDI standard protocol.

In addition to means to automatically randomly develop timbral combinations, the Randomizer includes means to select which elements are randomized, and a means to manually edit these and other elements to produce the desired Total Sound. The specifics of Randomizer implementation and operation will now be described.

To perform the Randomizer function, a Randomizer (64) is added to MIDI controller (51) of FIG. 4. The Randomizer is configured by the musician through switch inputs (52). Configuring the Randomizer basically means determining which elements to randomize and which to leave unaffected. The operation of the Randomizer is shown in greater detail in FIG. 7.

The Element Memory (60) configures the sixteen operators shown (78-84, 88-110). The notes from keyboard (56) and switch inputs (52) are scanned by the scanner (54) and the appropriate Events are written to the Event Compiler (58).

As an Event passes through the Processor (62), those operators needed for the particular event are switched in, and the event is converted into the appropriate MIDI commands by the operators, and then sent to the MIDI sound generators (68-74).

The musician individually selects which elements are to be randomized by effectively closing the switch that connects the appropriate operator to the Randomizer (64).

In the preferred embodiment with four channels, and each channel possessing 128 possible timbre numbers, 4 possible transpositions, 128 possible volume levels and 32 possible velocity responses, there would be 7.5*10.sup.22 possible combinations. It would take billions of years to generate all possible combinations. By sampling uncorrelated timbral combinations, the musician is subjected to a broader cross-section of possible combinations and, by changing the configuration of the Randomizer, can focus the field of timbral combinations toward the desired sound.

At the core of the Randomizer (64), is a Random Number Generator which preferably produces a 16-bit integer sequence X(n) based on the following formula:

X(1)=9

X(2)=11*remainder of (9/179)=11*9=99

X(3)=11*remainder of (99/179)=11*99=1089

X(4)=11*remainder of (1089/179)=11*15=165

X(n)=11*remainder of [X(n-1)/179]

where:

X(n) is a 16-bit number

X(1) refers to the first number in the sequence.

X(2) is the second number in the sequence. X(n) is the nth number and X(n+1) is the next number after X(n). The term "remainder of [X(n-1)/1791]" can also be written X(n-1)mod (179) and means the integer remainder that is leftover when the number X(n-1) is divided by 179.

X(n) is buffered in non-volatile memory so the random sequence is not interrupted when the system is rebooted. This pseudorandom sequence repeats after every 178 numbers are generated. There are a variety of methods available to generate pseudorandom sequences. Suitable software routines for this purpose are available and/or may be readily created by those skilled in the relevant art.

The random number generator described above produces 16-bit integers. When used by the timbre number operator, the random number is truncated to 7-bits or 3-bits. When used by the transpose operator, the random number is truncated to 2-bits. When used by the velocity operator, the random number is truncated to 5-bits. When used by the volume operator, the random number is truncated to 6-bits or 7-bits. The purpose of these different truncations are described hereinafter. Even though the random number generator produces a sequence that repeats every 178 numbers that are generated, the random number is further altered by truncation to produce even more random results.

Manipulating the four key elements of a timbral combination will produce a new Total Sound.

1. Timbre

Changing the timbre through MIDI is accomplished via the MIDI Timbre Change command. When a MIDI Sound Generator (24) recognizes this command, it activates the timbre associated with the Timbre Number embedded in the command. Up to 128 timbre numbers (0-127) are supported by this command; additional timbre numbers can be accessed through the MIDI bank select command.

The musician has two options when randomizing timbres. The first option allows all 128 timbre numbers to be available, which means one timbre between 0-127 will be chosen at random. Since the timbre number field is as wide as possible, this gives the musician the widest variance in timbral combinations which may be used as a source of new sounds. The second option allows the musician to choose any seven timbre numbers. The randomizer (64) then randomly chooses one of these seven timbres. Since the field is limited, the timbral combinations are focused in a certain direction. This is useful when the musician has a general idea of what type of sound is desired.

FIG. 8 shows a flowchart of the processor subroutine that handles the timbre change event. When the Processor (62) retrieves a timbre change event from the Event Compiler (58), it calls this subroutine. The Processor checks if the first channel is enabled (Query 180). If disabled, operation skips to the next channel (198). If the first channel is enabled, the subroutine determines whether timbres for this channel are to be randomized (Query 182). If not, operation skips to the next channel (198). If this element is to be randomized on the first channel, the Timbre Change Status Byte is formulated (184). The next random number is retrieved (186). If the musician selected (Query 188) all 128 possible timbre numbers, the random number is truncated to 7 bits (190) and the two-byte MIDI Timbre Change command is transmitted (192) where the timbre number is a random number from 0-127. Otherwise, the subroutine truncates the random number to 3 bits (194) and uses this to point into the list of 7 timbres to select one at random (196). The two-byte MIDI Timbre Change command is then transmitted.

The subroutine then moves to the second channel (198). This procedure continues for the second channel (198-214), third channel (216-232) and the fourth channel (234-250) before returning to the main program.

2. Volume

The dynamics of the Total Sound are characterized by the relative volume of the overall sound in the context of the music, and the relative volumes of the component timbres. MIDI can be used to control the Total Sound's volume and the volumes of each timbre through the MIDI Volume control command.

FIG. 9 shows a flowchart of the processor subroutine that handles the volume change event. When the Processor (62) retrieves a volume change event from the Event Compiler (58), it calls this subroutine. The Processor checks if the first channel is enabled (Query 260). If disabled, operation skips to the next channel (276). If the first channel is enabled, the subroutine determines whether this element for this channel is to be randomized (Query 262). If not, operation skips to the next channel (276). If this element is to be randomized on the first channel, the Volume Change Status Byte is formulated (264) and the first of two Volume Change Data bytes is formulated (265). The next random number is retrieved (266). If timbres are being randomized on this channel (Query 268), the random number is rounded off to a number between 64-127 (270) and the three-byte MIDI Volume Change command is transmitted (272). Otherwise, the random number is rounded off to a number between 32-127 (274) then transmitted (272).

The subroutine then moves to the second channel (276). This procedure continues for the second channel (276-290), third channel (292-306) and the fourth channel (308-320) before returning to the main program.

In the presently preferred embodiment, there are two volume ranges: 1) Limited range between 64-127 and 2) Wide range between 32-127. If timbres are being randomized, the volume levels will be close enough to hear all timbres but varied enough to make a noticeable difference in the overall sound. When timbres are not changing, the volumes can vary over a wider range for even greater differences in overall sound.

3. Pitch

The relative pitch of each component timbre affects the quality of the Total Sound. In MIDI, this can be controlled through the MIDI Note On command, by independently specifying the note number of each timbre for a given Total Sound note.

FIG. 10 illustrates how the MIDI Note On commands are generated. When the Processor (62) retrieves a Note On event from the Event Compiler (58), it calls this subroutine. The Processor initially checks if the first channel is enabled (Query 330). If disabled, operation skips to the next channel (344). If the first channel is enabled, the Processor formulates the MIDI Note On status byte (332). The Processor then retrieves the transpose amount (334) and computes the MIDI note number (336) by adding the transpose amount to the key number. The Processor then retrieves the velocity table address for the desired velocity response (338) and gets the velocity amount from the appropriate look-up table (340). The three-byte MIDI note on command is transmitted (342).

The subroutine then moves to the second channel (344). This procedure continues for the second channel (344-356), third channel (358-370) and the fourth channel (372-384) before returning the main program.

The randomizer changes the pitch by changing the transpose amount (of steps 334, 348, 362, 376). The randomizer has four possible transpose amounts, i.e. down one octave, no transpose, up one octave and up two octaves. The randomizer controls the pitch of the MIDI sound generators by offsetting the note number in the MIDI Note On command. The key number listed in the Event buffer is offset by a transpose amount.

The method used to change transpose amounts is illustrated in FIG. 11. When the Randomizer is activated, this subroutine is executed. If transpose amounts are enabled to be randomized on the first channel (Query 400), the Processor retrieves the next random number (402). This number is truncated to a 2-bit number then multiplied by 12 (404) to produce the transpose amount. The Transpose operator (88) of the first channel is updated with this new amount. The subroutine then continues to the second channel (408-414), third channel (41614 422) and the fourth channel (424-430).

4. Dynamics

MIDI can be used to control the Total Sound's dynamics through the MIDI Note On command, i.e. through the velocity portion of the command. The key speed is used as an index into a look-up table to retrieve the appropriate velocity amount. The preferred embodiment of this invention has 32 different velocity entries in the look-up table.

Changing the dynamic response of a timbre is implemented by changing the address to different velocity look-up tables. Indexing into look-up tables is a common method used in the field. FIG. 12 illustrates how the Randomizer changes the look-up table addresses. When the randomize function is activated, this subroutine is executed. The Processor determines whether or not velocity is to be randomized on the first channel (Query 450). If disabled, operation skips to the next channel (460). If the first channel is enabled, the next random number is retrieved (452) and truncated to 5 bits (454). The velocity table address is then formulated (456) and the velocity operator (104) of the first channel is updated with the new address.

The subroutine then continues in like manner for the second, third and fourth channels.

Examples of how the MIDI Controller with Randomizer might be used to create new Total Sounds will now be presented.

A musician would first choose how many MIDI sound generators (24) he would like to audition. Next he would choose which particular sound elements he wants to randomly combine as in FIG. 7 from each MIDI sound generator. These elements are timbre (78-84), Pitch (88-94), Volume (96-102) and Dynamic Response (104-110). The musician would then proceed to have the Randomizer (64) create random timbral combinations by randomly operating on the selected elements. He would then begin to hear timbral combinations with qualities unlike what each individual MIDI sound generator is capable of producing by itself. As he is sampling these timbral combinations, the musician has the ability to record and save any timbral combination produced by the Randomizer for use as is or for further refinement. For example he may discover a unique sound layer that has just the right timbre and pitch elements but would like to hear more volume and dynamic response variations than the Randomizer produced. At that point he could selectively eliminate timbre and pitch from being randomized. These elements would stay the same while variations were made with volume and dynamic response allowing the musician a more directed approach to his final timbral combination.

Suppose a musician is looking for a new and unique string section sound for his latest project. He would select the appropriate MIDI sound generators (24) then select string sounds from each. Then he would begin to audition Total Sound "snap shots", i.e. sound samplings, produced by the random combination of the elements: timbre, pitch, volume and dynamic response. As he hears these timbral combinations, he can record to memory those that fit his purpose. The configuration is directed by the original limiting of only string sounds to be combined from the MIDI sound generators.

From the foregoing description, it will be evident that a new and improved MIDI Controller has been developed which facilitates production of new Total Sounds. With the Randomizer function of the present invention, the musician can guide the creation of desired new sounds, unfettered by the technology. The prior art inhibitions on the musician's creativity are thus alleviated.

Although a preferred embodiment has been described in detail and depicted herein, it will be apparent to those skilled in this art that various modifications, substitutions, enhancements and other variations can be made without departing from the spirit of this invention. For example, the Randomizer function can be implemented in other MIDI sources and, accordingly, the term "MIDI Controller" should be construed as encompassing all MIDI data sources. In certain applications, it may be desirable to limit the transpose operator to one or two or some other number of octaves, or to transpose to 7th's or 5th's, etc. Similarly, velocity may be limited to a different number of indexes or look-up tables. The number of MIDI channels and/or MIDI sound generators can also vary. If the number of MIDI sound generators exceeds the number of MIDI channels of the MIDI controller, MIDI channel number could be considered a fifth element which could be randomized pursuant to the principles of the present invention. These and all other variations which fall within the true spirit of this invention are intended to be encompassed within the scope of the claims appended hereto.