JP3625914B2 - Arpeggiator - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to an arpeggiator that scans key pressing information and sequentially generates a plurality of performance information according to the scanning result.
[0002]
[Prior art]
Some conventional electronic musical instruments have a so-called arpeggiator function. The arpeggiator is a function that scans the key press information in order from the lowest pitch to the highest pitch, for example, and outputs the performance information sequentially according to the result.
[0003]
With this function, it is possible to realize an arpeggio performance that is difficult for a performer by a simple performance operation by simply pressing a plurality of keys simultaneously.
[0004]
[Problems to be solved by the invention]
However, the conventional arpeggiator scans the key pressing information at a certain fixed time interval and sequentially outputs performance information at the fixed time interval. There was a tendency to become musically unsavory.
[0005]
In addition, the characteristics of the musical sound, such as the duration of the musical sound and the volume of the musical sound, are uniform, and from this point of view, the arpeggio performance was not musical and tasteless. An object of the present invention is to provide an arpeggiator capable of performing a more musical arpeggio performance with a simple operation, which is impossible with a conventional arpeggiator.
[0006]
[Means for Solving the Problems]
The first arpeggiator of the present invention that achieves the above object is as follows.
(1-1) A key depression having a storage area corresponding to each of a plurality of keys and erasably writing key depression information indicating that the key has been depressed into a storage area corresponding to the depressed key. Information storage means;
(1-2) For each step of the rhythm, one step or a plurality of time intervals between a certain step and the next step following the step and the tone duration information of the musical sound at the step Rhythm pattern table storage means for storing a rhythm pattern table stored in each of the steps,
(1-3) The steps of the rhythm pattern table are sequentially referred to, and the storage area is scanned corresponding to the steps, and the key depression information detected by the scan and the scan of the rhythm pattern table And performance information generating means for generating performance information representing a musical sound based on both the pronunciation duration information recorded in the step corresponding to, at a timing according to the time interval recorded in the step,
The performance information generating means further generates performance information representing the changed musical sound based on information defining the degree of change in pronunciation duration.
[0007]
The second arpeggiator of the present invention that achieves the above object is
(2-1) A key depression having a storage area corresponding to each of a plurality of keys and erasably writing key depression information indicating that the key has been depressed into a storage area corresponding to the depressed key. Information storage means;
(2-2) For each step of the rhythm, a time interval between a certain step and the next step following the step is combined with the tone intensity information of the musical sound in the step, and one step or a plurality of steps A rhythm pattern table storage means for storing a rhythm pattern table stored in each step;
(2-3) Each step of the rhythm pattern table is sequentially referred to, and the storage area is scanned corresponding to each step, and the key depression information detected by the scan and the scan of the rhythm pattern table Performance information generating means for generating performance information representing a musical sound based on both of the pronunciation intensity information recorded in the step corresponding to, at a timing according to the time interval recorded in the step,
The performance information generating means further generates performance information representing a musical tone that has been changed based on information that defines the degree of change in pronunciation intensity.
[0008]
Here, it is preferable that the first arpeggiator of the present invention further includes an operator that generates information that defines the degree of change in the pronunciation duration according to the degree of operation.
[0009]
In the second arpeggiator of the present invention, it is preferable to include an operator that generates information that defines the degree of change in the pronunciation intensity according to the degree of operation.
[0010]
DETAILED DESCRIPTION OF THE INVENTION
Hereinafter, embodiments of the present invention will be described.
[0011]
FIG. 1 is a circuit configuration diagram of an embodiment of an arpeggiator of the present invention. Here, the CPU 10, the address bus 11 and the data bus 12 connected to the CPU 10, the RAM 13, the ROM 14, the panel 15, the clock timer 16 for notifying the CPU 10 of the generation of the clock, and data conforming to the MIDI standard are input. A data input terminal (MIDI IN) 17 and a data output terminal (MIDI OUT) 18 for outputting data compliant with the MIDI standard are provided.
[0012]
The ROM 14 is a read-only memory area, and stores a program executed by the CPU 10 and various tables referred to by the program. Details of the program and table will be described later. The RAM 13 is used as a working area for programs executed by the CPU 10. Here, the RAM 13 is backed up by a battery, and the memory contents at that time are saved even when the power is turned off. The contents of the memory will be described later.
[0013]
The panel 15 has an operation switch and a display, and can select a parameter independently and set a value for the parameter. The set value is stored in a memory in the RAM 13. FIG. 2 is a view showing the panel 15. In this panel, a rhythm pattern number (Rhythem Pattern #), a scan mode number (Scan Mode #), and a groove rate (Groove Rate) can be set.
[0014]
In the present embodiment, the rhythm pattern is a combination of sound generation timing, duration, and velocity coefficient patterns. The rhythm pattern setting operator 151 is composed of a pair of an operation button 151a for incrementing a value and an operation button 151b for decrementing the value. The values set by these operation buttons 151a and 151b are displayed on the display 151c. As described above, it is stored in the RAM 13.
[0015]
The scan mode refers to a set of scan methods for scanning key pressing information. Similarly to the rhythm pattern setting operation element 151, the scan mode setting operation element 152 is composed of a pair of an operation button 152a for incrementing a value and an operation button 151b for decrementing the value, and these operation buttons 151a and 151b are used. The set value is displayed on the display 152c and stored in the RAM 13.
[0016]
The groove rate determines the degree of so-called “groove”, and the groove rate setting operation element 153 is composed of a slider. When the slide button 153a is moved to the bottom, a value “0” is set in the groove rate parameter. When it is moved to the top, the value “100” is set in the groove rate parameter, and when set in the middle, a value between 0 and 100 is set according to the set position. This set value is stored in the RAM 13.
[0017]
Details of each parameter will be described later. Returning to FIG. 1, the description will be continued. The clock timer 16 generates a clock at a constant cycle, and notifies the CPU of the clock generation every time the clock is generated. In the present embodiment, the time for 96 clocks is determined as the quarter note production time, and the arpeggio tempo is determined by this clock cycle.
[0018]
For example, a keyboard 20 is connected to the data input terminal (MIDI IN) 17 as shown in the figure, and key depression (note-on) information and key release (note-off) information generated by playing the keyboard 20 are input. A hold pedal 21 is connected to the keyboard 20, and hold-on information and hold-off information (collectively referred to as hold information) generated by operating the hold pedal 21 are also MIDI data. As one type, it is input via the data input terminal 17.
[0019]
The CPU 10 receives key pressing information and key release information input from the data input terminal 17 to sequentially generate performance information for arpeggio performance, and outputs the performance information from the data output terminal 18 to the outside. For example, a sound source 30 is connected to the data output terminal 18 as shown in the figure, and the sound source 30 generates a musical sound signal based on the received performance information. The musical sound signal is emitted into space as a musical sound, for example, by a sound system including an amplifier, a speaker and the like built in the sound source 30 or connected to the sound source 30.
[0020]
In the following, various tables stored in the ROM, which are referred to by programs described later, will be described first, then various memories secured in the RAM will be described, and then the programs using these tables and memories will be described. To do. FIG. 3 is a diagram showing a basic pattern of the rhythm pattern table. In the rhythm pattern table, each step corresponds to each step of the rhythm, and each step includes a time interval (step time) between that step and the next step following that step. The duration of the rhythm sound (duration) and the velocity coefficient (Velo. Coef.) That defines the intensity of the rhythm sound at that step are recorded, and finally the size of the rhythm pattern table (number of steps) ; Step Size) is recorded. The memory capacity for one step is a total of 5 bytes including a step time of 2 bytes, a duration of 2 bytes, a velocity coefficient of 1 byte, and the number of steps is 1 byte. In the column of step time and duration, numerical values in units of the above-described clock (quarter note = 96 clocks) are recorded.
[0021]
A plurality of types of rhythm pattern tables are recorded in the ROM, and each rhythm pattern table is numbered. By operating the rhythm pattern setting operator 151 shown in FIG. 2 and setting the rhythm pattern number, the performer can select an arbitrary rhythm pattern table. Here, the rhythm pattern table and the number of steps thereof are written as RHY_XXX_TBL [n] and RHY_XXX_SIZE, respectively. XXX represents the name of the rhythm pattern table, and n in [n] is a step number (0 ≦ n <RHY_XXX_SIZE) in the rhythm pattern table.
[0022]
The step time, duration, and velocity coefficient recorded in the nth step of the rhythm pattern table name XXX are RHY_XXX_TBL [n]. stepTimeRHY_XXX_TBL [n]. durationRHY_XXX_TBL [n]. It is written as veloCoef.
[0023]
Next, each example of the rhythm pattern table will be described. FIG. 4 is a diagram showing a rhythm pattern table for quarter notes and the number of steps. This rhythm pattern table has a name “4” indicating that it is for a quarter note, and is represented as RHY — 4_TBL. RHY_4_TBL [0]. stepTime, RHY — 4_TBL [0]. duration, RHY — 4_TBL [0]. The veloCoef is 96 (number of quarter note clocks), 92 and 127, respectively. The number of steps is expressed as RHY — 4_SIZE. Since this rhythm pattern table RHY_4_TBL consists of only one step, the number of steps RHY_4_SIZE is “1”.
[0024]
The rhythm pattern table RHY_4_TBL and the rhythm pattern table RHY_XXX_TBL shown below are assigned different rhythm pattern numbers. The rhythm pattern number of the rhythm pattern table RHY_XXX_TBL shown in FIG. 4 is “0”. 5, 6, 7, 8, and 9 are for sixteenth notes (name: 16), waltz (shuffle), shuffle (shuffle), diminished (dim), and reggae (reggae), respectively. It is the figure which showed the rhythm pattern table and the number of steps for it. Rhythm pattern numbers are assigned 1, 2, 3, 4, and 5 in this order. Since these structures are clear from the above description, detailed description is omitted.
[0025]
FIG. 10 is a diagram showing a basic pattern of the scan mode table. In each step of the scan mode table, a number (scan function number; Scan Function #) of a method for scanning key pressing information (scan method) is recorded. The memory capacity for one step of this scan mode table is 1 byte, and the number of steps is also 1 byte.
[0026]
A plurality of types of scan mode tables are stored in the ROM 14, and the player can select an arbitrary scan mode table by operating the scan mode setting operator 152 shown in FIG. Here, the scan mode table and the number of steps thereof are expressed as SMODE_XXX_TBL [n] and SMODE_XXX_SIZE, respectively. XXX represents the name of the scan mode table, and n in [n] is a step number (0 ≦ n <SMODE_XXX_SIZE) in the scan mode table.
[0027]
Each scanning method (Scan Function) in this embodiment is as follows.
[0028]
(1) Ascending scan type Key pressing information is scanned from the lowest pitch to the highest pitch. Here, this is expressed as SCAN_U.
[0029]
(2) Down-scan method Scans from the highest pitch to the lowest pitch. Here, this is expressed as SCAN_D.
[0030]
(3) Ascending / descending scan method Scanning from the lowest pitch to the highest pitch, when the highest pitch is reached, this time, scanning from the highest pitch to the lowest pitch. Here, this is expressed as SCAN_UD.
[0031]
(4) Random scan method Scan at random. Here, this is expressed as SCAN_R.
[0032]
(5) Key-pressing order scanning method Scanning is performed in the order of key-pressing information input. Here, this is expressed as SCAN_O.
[0033]
(6) Chord scan method All currently pressed keys are scanned. Here, this is expressed as SCAN_C.
[0034]
(7) Lowest note scanning method Only the lowest note number (lowest note) of the currently pressed keys is scanned. Here, this is expressed as SCAN_B.
[0035]
(8) Highest sound scanning method Only the highest note number (highest sound) of the currently pressed keys is scanned. Here, this is expressed as SCAN_T.
[0036]
(9) Minimum sound removal ascending scan method Scanning from the lowest pitch to the highest pitch except the lowest tone. Here, this is expressed as SCAN_U_WO_B (Scam up without bass).
[0037]
(10) Random scan method without lowest sound Scans randomly except for the lowest sound. Here, this is expressed as SCAN_R_WO_B.
[0038]
(11) Minimum tone-free chord scanning method All the keys currently pressed are scanned except the lowest tone. Here, this is expressed as SCAN_C_WO_B.
[0039]
(12) Maximum sound removal scan method Except for the highest sound, scanning is performed from a lower pitch to a higher pitch. Here, this is expressed as SCAN_U_WO_T.
[0040]
Next, each example of the scan mode table is shown. FIG. 11 is a diagram showing a scan mode table for ascending scan and the number of steps. This scan mode table represents the name “UP” indicating that it is for upward scanning, and is represented as SMODE_UP_TBL. The number of steps is expressed as SMODE_UP_SIZE. Since this scan mode table SMODE_UP_TBL consists of only one step in which the ascending scan method SCAN_U is recorded, the step number SMODE_UP_SIZE is “1”. Each of the scan mode table SMODE_UP_TBL and each of the following scan mode tables SMODE_XXX_TBL is assigned a different scan mode number, and the scan mode number of the scan mode table SMODE_UP_TBL shown in FIG. 11 is “0”. .
[0041]
12, FIG. 13, FIG. 14, FIG. 15, FIG. 17, FIG. 17, FIG. 19, respectively, are for down scan (DOWN), up / down scan (UP_DW), random scan (RANDOM), and chord scan. FIG. 4 is a diagram showing scan mode tables and steps for use (CHORD), key-pressing order scan (ORDER), waltz (WALTZ), reggae (REGGAE), and shamisen (SHAMI).
[0042]
Scan mode numbers are assigned 1, 2, 3, 4, 5, 6, 7, and 8 in this order. Since these structures are clear from the above description, detailed description is omitted.
[0043]
Next, a memory in the RAM in which various parameter values are stored will be described.
[0044]
FIG. 20 is a diagram showing rhythm pattern parameters. This rhythm pattern parameter is a 1-byte memory, and the rhythm pattern number set by the operation of the rhythm pattern setting operation 151 of the panel 15 shown in FIG. 2 is stored in this memory. Here, this is expressed as PRM_RHYTHM.
[0045]
FIG. 21 is a diagram showing scan mode parameters. This scan mode parameter is also a 1-byte memory, and this memory stores a scan mode number set by operating the scan mode setting operator 152 of the panel 15 shown in FIG. Here, this is expressed as PRM_SMODE. FIG. 22 is a diagram showing the groove rate parameters. This groove rate parameter is also a 1-byte memory, in which the value of the groove rate set by the operation of the groove rate setting operator of the panel 15 shown in FIG. 2 is stored. The range of this value is 0 to 100 as described above. Here, this is expressed as PRM_GROOVE.
[0046]
FIG. 23 is a diagram illustrating a note buffer. This note buffer is an array of 128 bytes, and each 1 byte corresponds to each key (note number) of the keyboard 20 (see FIG. 1). Information indicating the key depression strength (note on velocity) is stored in an area corresponding to the note number in the key depression information. If the corresponding key has been released (note-off), or if the key has been pressed and released, “−1” is stored in that area.
[0047]
Here, each area of the note buffer is denoted as NOTEBUF [n]. n represents a note number. FIG. 24 is a diagram illustrating a play buffer. This play buffer is an array of 128 bytes, similar to the note buffer shown in FIG. 23, and each byte corresponds to each note number. However, unlike the note buffer shown in FIG. 23, this play buffer stores note-on velocity taking hold information into account. That is, when the hold pedal 21 connected to the keyboard 20 shown in FIG. 1 is stepped on, hold-on information is input via the data input terminal 17, and when the hold pedal 21 is released, the hold input 21 is released via the data input terminal 17. Although hold-off information is input, when hold-on information is received, key press information stored in the play buffer shown in FIG. 24 is prohibited from being erased until the hold-off information is received. When hold-off information is input, the contents of the note buffer at that time are copied to the play buffer, and thereafter, the play buffer always maintains the same contents as the note buffer unless hold-on information is input next time. When performing an arpeggio performance, this play buffer in which velocities taking hold information into consideration are arranged is scanned. Here, this play buffer area is denoted as PLAYBUF [n]. n represents a note number.
[0048]
FIG. 25 shows the current play note number buffer. The current play note number buffer is a 1-byte memory in which the note number of the current step during the arpeggio performance is stored. Here, this is expressed as CUR_NOTE. FIG. 26 is a diagram illustrating a hold buffer. This hold buffer is a 1-byte memory in which numerical hold information of 0 to 127 is stored. When the hold pedal 21 shown in FIG. 1 is operated, hold information represented by a numerical value of 0 to 127 corresponding to the operation amount is input from the data input terminal 17, and the hold information is stored in the hold buffer. Here, if this value is 64 or more, it is regarded as hold-on information, and if it is less than 64, it is regarded as hold-off information. Here, this is expressed as HOLD.
[0049]
FIG. 27 is a diagram illustrating an order buffer. This order buffer is an array of 16 steps in which 1 step consists of 2 bytes, and each step stores a note number and the velocity of the note number. In this order buffer, the note number of the key that was pressed and the velocity at the time of the key press are stored in the order in which the key was pressed. When the key was released, the note number and velocity of that key were deleted and rearranged to the top. It is. Here, this is expressed as ORDER [n]. n is a step number (n = 0-15). In particular, when only the note number of the nth step and only the velocity are indicated, ORDER [n]. note, ORDER [n]. Indicated as velo.
[0050]
FIG. 28 is a diagram illustrating an order write counter. This order write counter is a 1-byte memory. When the key depression information is received next time, the received key depression information is stored in this memory at the step number of the order buffer ORDER [] shown in FIG. A value indicating whether to store in is stored. Possible values of this order write counter are 0-16. 0 to 15 correspond to each step of the order buffer ORDER [], and 16 means that the order buffer ORDER [] is full. Here, this is expressed as ORDER_WR.
[0051]
FIG. 29 is a diagram illustrating an order position counter. This order position counter is a 1-byte memory. In this memory, the musical tone of the current step in the arpeggio performance is a musical tone corresponding to the step number of the order buffer ORDER [] shown in FIG. The indicated value is stored. Possible values of the order position counter are −1 to 15. 0 to 15 correspond to the respective steps of the order buffer ORDER [] shown in FIG. 27, and −1 represents the timing at which a series of steps of the arpeggio performance will be started (the timing at which the previous series of steps is completed). I mean. Here, this is expressed as CUR_ORDER.
[0052]
FIG. 30 is a diagram showing a rhythm pattern table position counter. This rhythm pattern table position counter is a 1-byte memory, and this memory is a pointer that points to a step in the currently selected rhythm pattern table (see the examples in FIGS. 3 and 4 to 9). . This pointer corresponds to the current rhythm step during the arpeggio performance. The value that this rhythm pattern table position counter can take is 0 or more and less than the number of steps RHY_XXX_SIZE of the currently selected rhythm pattern table. Here, this is expressed as CUR_RHY.
[0053]
FIG. 31 is a diagram showing a scan mode table position counter. This scan mode table position counter is a 1-byte memory, and is a pointer that points to a step in the currently selected scan mode table (see FIGS. 10 and 11 to 19). This pointer also corresponds to the current rhythm step during the arpeggio performance. Possible values of the scan mode table position counter are 0 or more and less than the number of steps SMODE_XXX_SIZE of the currently selected scan mode table. Here, this is expressed as CUR_SMODE.
[0054]
FIG. 32 is a diagram showing a clock counter. This clock counter is a 2-byte (16-bit) memory, and the value of this clock counter increases by “1” every time the clock timer 16 shown in FIG. 1 generates one clock. The range of the value of this clock counter is 0000h to FFFFh, and next to FFFFh returns to 0000h, and circulates indefinitely while the power is on. The arpeggio proceeds based on the increase in the clock value. Here, this is expressed as CLOCK.
[0055]
FIG. 33 is a diagram illustrating a next clock buffer. This next clock buffer is a 2-byte (16-bit) memory, and this memory stores the time of the next step of the arpeggio performance. That is, when CLOCK shown in FIG. 32 increases and reaches the value stored in the next clock buffer, key-on information is scanned and note-on data is transmitted. When the processing of one step is completed, the value of the next clock buffer is updated at the time of the next step. The range of values that the next clock buffer can take is 0000h to FFFFh. Here, this is expressed as NEXTCLK.
[0056]
FIG. 34 is a diagram illustrating a note-off reservation buffer. The note-off reservation buffer is an array of 3 bytes × 16, and in this note-off reservation buffer, a note number to be note-off and a timing to actually transmit it as note-off data are stored in pairs. . This transmission timing is represented by the value of CLOCK in FIG. When the CLOCK sequentially increases and reaches one of the transmission timings stored in the note-off reservation buffer, note-off data is transmitted for the note number stored in a pair with the transmission timing. Is done. '-1' is stored in an area where no valid data is stored in the note-off reservation buffer or an area where the note-off data has been transmitted.
[0057]
Here, this is expressed as OFFRSV [n]. n means the nth storage area of a pair of a note number and its transmission timing. In particular, when indicating the note number and transmission timing in OFFRSV [n], OFFRSV [n]. note, OFFRSV [n]. It is written as clock. FIG. 35 is a diagram showing an end flag. This end flag is composed of a 1-byte memory here, but may be composed of 1 bit due to the nature of the flag. This end flag takes a binary value of '0' and '1'. '0' indicates that scanning for the pronunciation of one step during the arpeggio performance has not been completed, and '1' It shows that the scanning for the sound generation of one step is completed. Here, this is expressed as END_FLG.
[0058]
FIG. 36 is a diagram showing a base note buffer. This base note buffer is a 1-byte memory, and the memory stores the note number of the lowest tone key among the keys being pressed in consideration of hold information. Here, this is expressed as LO. FIG. 37 is a diagram showing a top note buffer. This top note buffer is a 1-byte memory, in which the note number of the key of the highest tone among the keys being pressed with the hold information added is stored. Here, this is expressed as HI.
[0059]
In addition to the memories described above, there is a memory used as a work area. However, in order to suffice with a description of a program to be described later, a description of each memory other than those described here is omitted here. Hereinafter, a program executed by the CPU using the tables and memories described so far will be described.
[0060]
FIG. 38 is a flowchart of a general program that starts operating when the power is turned on and continues to operate until the power is turned off. When the power is turned on, first, predetermined initialization is performed (step 38_1). Thereafter, whether or not the clock generation is notified from the clock timer 16 (see FIG. 1) (step 38_2), the panel 15 (see FIG. 1). 1 (see FIG. 2) and any parameter has been edited (step 38_4), note-on data (key press information) is input (step 38_6), note-off data (key release information) ) Is input (step 38_8) and hold data (hold information) is input (step 38_10) is cyclically monitored sequentially, and each event is performed in each step 38_2, 38_4, 38_6, 38_8, 38_10. Is recognized, the clock processing (step 38_3) and the editing processing (step -Up 38_5), note-on process (step 38_7), note-off process (step 38_9), hold the data processing (step 38_11,38_12,38_13) is performed.
[0061]
In the hold data processing, first, a hold value is stored in HOLD (see FIG. 26) (step 38_11), and it is determined whether or not the hold value is 64 or more indicating hold-on (step 38_12). If it is 63 or less, hold-off processing is performed (step 38_13). FIG. 39 is a flowchart of the initialization processing routine. This initialization processing routine is executed in step 38_1 of the general program shown in FIG.
[0062]
In this initialization process, first, the order buffer ORDER [] (see FIG. 27) in which the velocities at the time of key depression are stored in the key depression order is cleared, and the storage pointer ORDER_WR (see FIG. 28) of the order buffer ORDER [] is stored. It is initialized to “0” (the head of ORDER []), and further, the order position counter CUR_ORDER (FIG. 29) is initialized to “−1” indicating that it is time to start a series of steps of the arpeggio performance. (Step 39_1).
[0063]
Next, a clock counter CLOCK (see FIG. 32) that counts the clock generated by the clock timer 16 (see FIG. 1) is initialized to “0” (step 39_2), and the timing for generating the next performance information is stored. The next clock buffer NEXTCLK (see FIG. 33) is also initialized to “0” (step 39_3). Furthermore, the note-off reservation buffer OFFRSV [] (see FIG. 34) storing the note number to be turned off and the timing at which the note is to be turned off is cleared (step 39_4), and the key arrangement of the keyboard 20 (see FIG. 1) The note buffer NOTEBUF [] (see FIG. 23) in which the velocity of the depressed key is stored is cleared (step 39_5), and the play buffer in which the velocity taking hold information into consideration is stored PLAYBUF [] (see FIG. 24) is cleared (step 39_6). Further, the hold buffer HOLD (see FIG. 26) in which the hold value is stored is cleared to “0” (step 39_7), and further, a reset scanner routine for resetting the scanner is executed (step 39_8).
[0064]
FIG. 40 is a flowchart of the reset scanner routine. The reset scanner routine is executed in step 39_8 of the initialization routine shown in FIG. Here, “−1” representing a vacancy is stored in the current play note number buffer CUR_NOTE (see FIG. 25) in which the note number currently being played by the arpeggio is stored, and the current value of the order buffer ORDER [] (see FIG. 27) is stored. The order position counter CUR_ORDER (refer to FIG. 29) indicating the step during the arpeggio performance also stores “−1” indicating empty, and further, the scan mode table position counter CUR_SMODE which is each pointer of the scan mode table and rhythm pattern table. (See FIG. 31), the rhythm pattern table position counter CUR_RHY (see FIG. 30) is initialized to “0” indicating the head. Further, a value obtained by adding 1 to the clock CLOCK (see FIG. 32) is stored in the next clock NEXTCLK (see FIG. 33). The reason why the value obtained by adding “1” to CLOCK is NEXTCLK is pronounced when NEXTCLK = CLOCK as described later (note-on data is transmitted), but CLOCK is incremented while this program is operating. This is to eliminate the possibility that the CLOCK exceeds the NEXTCLK indicating the sound generation start timing and the sound generation is not performed.
[0065]
In the reset scanner routine shown in FIG. 40, “0” indicating incomplete is further stored in an end flag END_FLG indicating whether or not the operation for sound generation in one step of the arpeggio performance being performed is incomplete. . FIG. 41 is a flowchart of the clock processing routine. This clock processing routine is executed in step 38_3 of the general program shown in FIG.
[0066]
In this clock processing routine, CLOCK (see FIG. 32) is first incremented (step 41_1). Next, OFFRSV [] (see FIG. 34) is searched to check whether there is note-off data to be transmitted at the current timing, and when there is note-off data to be transmitted at the current timing. The note-off data is transmitted (steps 41_2 to 41_8).
[0067]
Specifically, first, '0' is set to i (step 41_2), and OFFRSV [i]. Whether or not valid note-off data is stored in note (0 to 127) is checked (-1) (step 41_3). If '-1', i is incremented (step 41_7), and i is 16 The search is carried out until (step 41_8) is reached. When it is confirmed in step 41_3 that valid note-off data is stored, the process proceeds to step 41_4, and OFFRSV [i]. It is determined whether or not the clock is equal to the current CLOCK. If it is equal, the note-off data is transmitted as performance information (step 41_5), and OFFRSV [i]. Write “−1” to note (step 41_6).
[0068]
When the search for note-off data is completed, a process for finding note-on data to be transmitted is performed (steps 41_9 to 41_17). Specifically, first, it is determined whether or not the current CLOCK has reached NEXTCLK, that is, whether or not the timing at which note-on data should be transmitted has been reached (step 41_9), and when the timing has not yet been reached. It ends as it is.
[0069]
When NEXTCLK = CLOCK, the process proceeds to step 41_10, and a scan note-on routine for scanning key pressing information is executed (step 41_10). The details of this scan note-on routine will be described later. In this scan note-on routine, one of the note numbers to be transmitted is stored in NT. NT = -1 means that there is no note to be transmitted. If it is determined in step 41_11 that NT is not -1, that is, there is a note to be transmitted, the process proceeds to step 41_12 and a note-off reservation routine is executed. The details of this note-off reservation routine will be described later. In this note-off reservation routine, note-off data corresponding to the note-on data to be transmitted is stored in OFFRSV [] (see FIG. 34). Make an off-line reservation. When OFFRSV [] is full, “−1” indicating that note-off reservation cannot be made is stored in NT.
[0070]
In step 41_13, it is determined whether or not note-off reservation has been made by checking whether NT = -1. If note-off reservation is not possible, note-on data is not transmitted and the process returns to step 41_10 to be transmitted. Search for the next note-on data. When NT ≠ −1 in step 41_13, that is, when the note-off reservation is normally made, the process proceeds to step 41_14, and the velocity generation routine is executed. Details of the velocity generation routine will be described later. In this velocity generation routine, the velocity of note-on data to be transmitted is generated by an operation described later. Thereafter, the note-on data is transmitted in step 41_15, and the process returns to step 41_10 to search whether or not there is any note-on data to be transmitted at the current timing.
[0071]
When “−1” is stored in NT in step 41_10, that is, there is no note-on data to be transmitted at the current timing (or all note-on data to be transmitted at the current timing has been transmitted). In this case, the process proceeds to step 41_16 via step 41_11. In step 41_16, a next clock update routine is executed. The details of the next clock update routine will be described later. Here, the next timing of note-on data transmission is stored in NEXTCLK.
[0072]
Thereafter, the process proceeds to step 41_17, and the scanner update routine is executed. The scanner is updated by this scanner update routine. Details of this scanner update routine will also be described later. FIG. 42 is a flowchart of the scan note-on routine. This scan note-on routine is executed in step 41_10 of the clock processing routine of FIG.
[0073]
In this scan note-on routine, first, PRM_SMODE (see FIG. 21) in which a scan mode number is stored is referred to (step 42_1), and a scan mode table (FIG. 10, FIG. 10) corresponding to the scan mode number stored in the PRM_SMODE. The scan method (scan function number) SMODE_XXX_TBL [CUR_MODE] stored in the current step number CUR_SMODE in FIG. 11 to FIG. 19) is stored in the work area func (step 42_2). Then, depending on whether the scan function number stored in the func indicates SCAN_U, SCAN_D, SCAN_UD,..., SCAN_U_WO_T, respectively, the scan-up routine (step 42_4) and the scan-down routine (step 42_5), scan up / down routine (step 42_6),..., Scan up with out top routine (42_15) is executed.
[0074]
In the following, as representative examples, a scan-up routine (step 42_4), a scan order routine (step 42_8), a scan code routine (step 42_9), a scan base routine (step 42_10), a scan code with out base (step 42_14) Will be described. FIG. 43 is a flowchart of the scan-up routine. This scan-up routine is a routine for realizing the above-described ascending scan method.
[0075]
Here, first, it is determined whether END_FLG (see FIG. 35) is “1” or “0”, that is, whether or not the scanning for the sound generation for this one step has already been completed (step 43_1). If END_FLG = 1, that is, if the current scan has already been completed, the process proceeds to step 43_2, where “−1” is stored in NT and the process ends. However, when this scan-up routine is executed for the first time in this step, END_FLG = 0.
[0076]
When END_FLG is not “1” in step 43_1, the process proceeds to step 43_3, where it is determined whether or not there is any note-on data in PLAYBUF [] (see FIG. 24), and no note-on data exists. If it does not exist, there is no way of sounding, so the process proceeds to step 43_2, where "-1" is stored in NT and the process ends.
[0077]
When it is recognized that note-on information exists in PLAYBUF [], next, note-on data to be transmitted is scanned in accordance with the ascending scan method (steps 43_4 to 43_7). Specifically, since the note number of the note-on data transmitted immediately before is stored in CUR_NOTE (see FIG. 25), the CUR_NOTE is advanced to the next note number (step 43_4), and the note number is set to 128. When it reaches (step 43_5), “0” is stored in CUR_NOTE (step 43_6). Using the updated CUR_NOTE, whether or not valid velocity data is stored in PLAYBUF [CUR_NOTE]. It is determined (step 43_7). If PLAYBUF [CUR_NOTE] =-1, that is, no valid velocity data is stored there, the process proceeds to step 43_4, where CUR_NOTE is incremented again to find an area where the effective velocity of PLAYBUF [] is stored. Therefore, scanning is performed from the lowest pitch to the highest pitch.
[0078]
Thus, when PLAYBUF [] in which valid velocity data is stored is found, CUR_NOTE at that time is stored in NT (step 43_8), and velocity data of CUR_NOTE stored in PLAYBUF [NT] is stored. Is stored in VL (step 43_9), and in the ascending scan method, only one note-on data is transmitted in one step, so '1' indicating the end of scanning is stored in END_FLG (step 43_10).
[0079]
FIG. 44 is a flowchart of the scan order routine. This scan order routine is a routine for realizing the key pressing order scanning method described above. Steps 44_1 and 44_2 are the same as steps 43_1 and 43_2 of the scan-up routine shown in FIG. In step 44_3, it is checked whether ORDER_WR = 0. As described with reference to FIG. 28, ODER_WR is a pointer of ORDER [] (see FIG. 27) that stores key pressing information in the order of key pressing. ORDER WR = 0 means that ORDER [] is empty. This means that a key-pressed arpeggio performance cannot be performed, and also in this case, the process proceeds to step 44_2, where “−1” is stored in NT and the process ends.
[0080]
If it is determined in step 44_3 that ORDER_WR is not 0, that is, ORDER [] is not empty, the process proceeds to step 44_4, CUR_ORDER (see FIG. 29) is incremented, and CUR_ORDER exceeds the maximum step in which ORDER [] is written. (Step 44_5), if exceeded, 0 is stored in CUR_ORDER (step 44_6). Using the CUR_ORDER whose value has been advanced in this way, the note number ORDER [CUR_ORDER]. note is stored in NT (step 44_7), the velocity ORDER [CUR_ORDER]. velo is stored in VL (step 44_8). Also in this key pressing order scanning method, only one note-on data is transmitted in one step, and therefore, “1” indicating the end of scanning is stored in END_FLG (step 44_9).
[0081]
FIG. 45 shows a scan code routine program. This scan code routine is a routine for realizing the chord scanning method described above. Steps 45_1, 45_2, and 45_3 are the same as steps 43_1, 43_2, and 43_3 of the scan-up routine shown in FIG. In this step, when this scan code routine is called for the first time, “−1” is stored in CUR_NOTE. Therefore, in the loop of steps 45_4, 45_5 and 45_6, CUR_NOTE = 0 and Scan until CUR_NOTE = 127. In the middle of the scanning, if PLAYBUF [CUR_NOTE] finds that a value other than “−1”, that is, valid velocity data is stored, the process proceeds to step 45_7, where the note number CUR_NOTE is stored in NT, and VL The velocity data PLAYBUF [NT] of the note number is stored in (step 45_8), and this routine is temporarily exited.
[0082]
In the chord scan method, it is necessary to scan the entire area of PLAYBUF [] and transmit all the note-on data in which valid velocity data is stored. Therefore, when exiting this scan code routine before reaching CUR_NOTE ≧ 128, END_FLG Is not stored in '1'. When this scan code routine is exited, the scan note-on routine shown in FIG. 42 is also exited, and step 41_10 of the clock processing routine of FIG. 41 is exited. When NT is not -1, the process proceeds to steps 41_12, 41_13, 41_14, and 41_15 to transmit one note-on data, and returns to step 41_10 again, through the scan note-on routine of FIG. The 45 scan code routine is executed again. At that time, scanning is performed from the value CUR_NOTE next to CUR_NOTE when execution is started again, that is, when this routine is exited last time (step 45_4). If it is determined in step 45_5 that CUR_NOTE ≧ 128, that is, PLAYBUF [] has been scanned, the process proceeds to step 45_9, where “−1” is stored in NT, and further proceeds to step 45_10, where “1” is stored in END_FLG. Is stored.
[0083]
FIG. 46 shows a scan base routine program. This scan base routine is a routine for realizing the above-described lowest sound scanning method. Steps 46_1, 46_2, and 46_3 are the same as steps 43_1, 43_2, and 43_3 of the scan-up routine shown in FIG. In Step 46_4, the lowest sound LO (see FIG. 36) is stored in NT. The process of storing the lowest sound in the LO will be described later.
[0084]
In step 46_5, the velocity PLAYBUF [NT] of the lowest tone LO is stored in VL. In step 46_6, '1' is stored in END_FLG. This is because there is only one minimum sound. FIG. 47 is a program of a scan code with out base routine. This routine is a routine for realizing the above-described lowest tone-free chord scanning method.
[0085]
Steps 47_1, 47_2, and 47_3 are the same as steps 43_1, 43_2, and 43_3 of the scan-up routine shown in FIG. In step 47_4, it is determined whether PLAYBUF [] has only one note-on or a plurality of note-ons. If there is only one note-on, the lowest tone-free chord scanning method is originally In this case, it is assumed that the only note-on note number is transmitted, the process proceeds to step 47_5, the note number of the note is stored in NT, and the velocity PLAYBUF [NT] of the note number is set to VL. Store (step 47_6), and store '1' in END_FLG (step 47_7).
[0086]
If it is confirmed in step 47_4 that there are a plurality of note-on numbers, the process proceeds to step 47_8. In this step, when this scan code with out base routine is called for the first time, “−1” is stored in CUR_NOTE as in the case of the scan code routine shown in FIG. The process of storing “−1” in CUR_NOTE will be described later. Accordingly, here, scanning is sequentially performed from the lowest pitch to the highest pitch over the entire area of PLAYBUF []. The scanning procedure (steps 47_8 to 47_15) here is the same as the scanning procedure (steps 45_4 to 45_10) in the scan code routine shown in FIG. 45, but in step 47_11, whether or not CUR_NOTE is the minimum amount LO. The only difference is that the note-on is ignored for the lowest note. Detailed description is omitted. The processing for storing the lowest sound in LO will be described later.
[0087]
The scan up routine (step 42_4), scan order routine (step 42_8), scan code routine (step 42_9), scan base routine (42_10), scan code executed in the scan note on routine shown in FIG. The with-out base routine (step 42_13) has been described. Scan down routine (step 42_5), scan up / down routine (step 42_6), scan random routine (step 42_7), scan top routine (step 42_11), scan up with out base routine (step 42_12), scan random with out base routine (Step 42_13) and the scan-up with out-top routine (42_14) are the above-described descending scan method, ascending / descending scan method, random scan method, highest sound scan method, lowest sound removal up scan method, and lowest sound removal random method, respectively. This is a routine that realizes the scan method and the highest-tone-free ascending scan method, but it is obvious from the various routines described above (FIGS. 43 to 47). Illustration and description of the stomach is omitted.
[0088]
FIG. 48 shows a program for a note-off reservation routine. This note-off reservation routine is executed in step 41_12 of the clock processing routine shown in FIG. In this note-off reservation routine, OFFRSV [] (see FIG. 34) used for note-off reservation is searched to find an empty area, while the duration read from the rhythm pattern table, the step time, and the groove rate The duration is calculated according to the groove rate PRM_GROOVE set by the operation of the setting operator 153 (see FIG. 2), the note-off timing is obtained based on the duration, and the note-off timing is set to OFFRSV []. Note-off reservation is performed by setting the area.
[0089]
That is, first, i is set to '0' in step 48_1, and OFFRSV [i]. It is determined whether or not note = −1, that is, whether or not OFFRSV [i] is free. OFFRSV [i]. When not = −1, that is, when OFFRSV [i] is not empty, i is incremented (step 48_3), and it is determined whether i exceeds the size of the array of OFFRSV [] (step 48_4). ), If it is within the array, the process returns to step 48_2 and OFFRSV [i]. It is determined whether or not note = -1. This process is repeated, and when i = 16 is reached without finding a free area, the process proceeds to step 48_5, and “−1” indicating that OFFRSV [] is full is stored in NT, and the process ends.
[0090]
In step 48_2, OFFRSV [i]. note = −1, that is, when an empty area is found, the empty area OFFRSV [i]. In note, the note number NT obtained in step 41_10 of the clock processing routine of FIG. 41 is stored (step 48_6). Next, according to the rhythm pattern number PRM_RHYTHM (see FIG. 20) (step 48_7), the rhythm pattern table RHY_XXX_TBL [] (see FIG. 3 and each example of FIGS. 4 to 9) corresponding to the rhythm pattern number PRM_RHYTHM. The duration RHY_XXX_TBL [CUR_RHY].. Stored in the step of the current step number CUR_RHY (see FIG. 30). duration and step time RHY_XXX_TBL [CUR_RHY]. StepTime is read and stored in D1 and D2, respectively (step 48_8).
[0091]
In step 48_9, based on the duration D1, the step time D2, and the groove rate PRM_GROOVE (see FIG. 22), the duration DURATION of the note number is obtained by calculating DURATION = (D1-D2) × PRM_GROUP / 100 + D2.
[0092]
This calculation result is that when PRM_GROOVE = 0, DURATION = D2, that is, the same value as the step time, and gives a tenuto effect to the arpeggio performance. When PRM_GROOVE = 100, DURATION = D1, ie, rhythm pattern table The duration stored in RHY_XXX_TBL [] remains unchanged. If a short duration such as a staccato is stored in the rhythm pattern table RHY_XXX_TBL [], an arpeggio performance such as a staccato to an arpeggio performance such as a tenuto is operated by the operation of the groove rate setting operator 153 shown in FIG. The duration of each sound can be changed continuously. DURATION obtained in this way is added to CLOCK (see FIG. 32), and OFFRSV [i]. It is stored in clock (step 48_10).
[0093]
FIG. 49 is a flowchart of the velocity generation routine, and FIG. 50 is an explanatory diagram of the velocity generated by the velocity generation routine shown in FIG. The velocity generation routine shown in FIG. 49 is executed in step (41_14) of the clock processing routine shown in FIG. In the velocity generation routine shown in FIG. 49, the rhythm pattern number PRM_RHYTHM (see FIG. 20) is referred to (step 49_1), and the rhythm pattern table RHY_XXX_TBL (FIG. 3 and each of FIGS. 4 to 9) corresponding to the rhythm pattern number PRM_RHYTHM. The velocity coefficient RHY_XXX_TBL [CUR_RHY] .. of the current step CUR_RHY (see FIG. 38) of the example). The veloCoef is read and stored in the COEF (step 49_2). Thereafter, in step 49_3, the calculation of VL2 = VL × COEF / 127 is performed between the velocity coefficient COEF and the velocity VL generated by pressing the key, and in step 49_4, VL− (VL−VL2) × PRM_GROOVE / 100 is calculated, and the velocity obtained as a result of the calculation is stored again in VL.
[0094]
Here, as shown in FIG. 50, when the groove rate PRM_GROOVE set by the operation of the groove rate setting operator 153 shown in FIG. 2 is PRM_GROOVE = 0, the velocity stored in the rhythm pattern table RHY_XXX_TBL [] is used. If PRM_GROOVE = 100, (key press velocity × velocity coefficient) is used, and if the groove rate setting operator 153 is set in the middle, the key press velocity is adopted as it is. A velocity that continuously changes between the key velocity and (key-pressed velocity × velocity coefficient) is employed.
[0095]
By changing the groove rate in this way, the degree of so-called “nodding” can be changed. In step 41_14 of the clock processing routine of FIG. 41, the velocity is obtained as described above, and in step 41_15, note-on data with the velocity data thus obtained is transmitted.
[0096]
FIG. 51 is a flowchart of the next clock update routine. This next stock lock update routine is executed in step 41_16 of the clock processing routine shown in FIG. In this next clock update routine, first, the rhythm pattern number PRM_RHYTHM (see FIG. 20) is referred to, and the current step number CUR_RHY (see FIG. 30) of the rhythm pattern table RHY_XXX_TBL [] corresponding to the rhythm pattern number PRM_RHYTHM stored there. Step time RHY_XXX_TBL [CUR_RHY]. The stepTime is read and stored in STEP (step 51_2), and the STEP is added to CLOCK (see FIG. 32) and stored in NEXTCLK (see FIG. 33) (step 51_3). As a result, the next sound generation timing is set to NEXTCLK.
[0097]
52 and 53 are the first half and the second half of the flowchart of the scanner update routine, respectively. This scanner update routine is executed in step 41_17 of the clock processing routine shown in FIG. In this scanner update routine, first, “1” stored in END_FLG at the end of the previous scan of the note-on data is canceled and “0” is stored in END_FLG (step 52_1), and then the rhythm pattern. The current step CUR_RHY (see FIG. 30) of the table is updated (steps 52_2 to 52_6). Specifically, CUR_RHY is incremented in step 52_2, and then the rhythm pattern number PRM_RHYTHM (see FIG. 20) is referred to, and the number of steps RHY_XXX_SIZE in the rhythm pattern table corresponding to the rhythm pattern number PRM_RHYTHM is read and stored in SIZE. (Step 52_4), it is determined whether or not CUR_RHY ≦ SIZE, that is, whether or not the number of steps of the currently used rhythm pattern table RHY_XXX_TBL [] has been exceeded as a result of incrementing CUR_RHY (Step 52_2). If not, the process proceeds directly to step 52_7. If exceeded, the process returns to the first step by storing “0” in CUR_RHY, and then proceeds to step 52_7. .
[0098]
In steps 52_7 to 52_11, the current step CUR_SMODE (see FIG. 31) of the scan mode table is updated. That is, first, CUR_SMODE is incremented in step 52_7, and then the scan mode number PRM_SMODE (see FIG. 21) is referred to (step 52_8), and the step number SMODE_XXX_SIZE corresponding to the scan mode number PRM_MODE is read and SIZE is read. (Step 52_9), and when CUR_SMODE ≧ SIZE (step 52_10), CUR_SMODE is returned to the head (step 0) (step 52_11).
[0099]
Next, the process proceeds to step 53_1 shown in FIG. 53, the scan mode number PRM_SMODE (see FIG. 21) is referred to, and updated in steps 52_7 to 52_11 of FIG. 52 of the scan mode table SMODE_XXX_TBL [] corresponding to the scan mode number PRM_SMODE. The scan method (scan function number) SMODE_XXX_TBL [CUR_SMODE] of step CUR_SMODE is read and stored in func. In steps 53_3 and 53_4, it is determined whether or not func is the chord scan method SCAN_C, and whether or not it is the lowest chord scan method SCAN_C_WO_B. In the case of SCA_C or SCAN_C_WO_B, CUR_NOTE (see FIG. 25). '-1' is stored in. In the case of SCAN_C or SCAN_C_WO_B, by storing “−1” in CUR_NOTE, the region of PLAYBUF [] is scanned from the lower pitch to the higher pitch when scanning note-on data (FIG. 45, see FIG. 47). FIG. 54 is a flowchart of the edit routine. This edit routine is executed in step 38_5 of the general program shown in FIG. 38 when the panel (see FIG. 2) is operated.
[0100]
In step 54_1, it is determined whether or not the rhythm pattern has been changed. The rhythm pattern is changed by operating a rhythm pattern setting operator 151 shown in FIG. The rhythm pattern is changed by operating the rhythm pattern setting operator 151. In step 54_2, the new rhythm pattern number after the change is stored in PRM_RHYTHM (see FIG. 20), the process proceeds to step 52_3, the reset scanner routine (see FIG. 40) is executed, and the scanner is reset.
[0101]
In step 54_4, it is determined whether or not the scan mode has been changed. The scan mode is changed by operating the scan mode setting operator 152 shown in FIG. When the scan mode is changed by operating the scan mode setting operator 152, the new scan mode number after the change is stored in PRM_SMDE (see FIG. 21) in step 54_5, and the scanner is reset in step 52_3. Is done.
[0102]
In step 54_6, it is determined whether or not the groove rate has been changed. The change of the groove rate is performed by operating the groove rate setting operator 153 shown in FIG. When the groove rate is changed by operating the groove rate setting operation unit 153, the process proceeds to step 54_7, and a new value of the groove rate is stored in PRM_GROUP (see FIG. 22).
[0103]
FIG. 55 is a flowchart of the note-on processing routine. This note-on process is executed in step 38_7 of the general block program shown in FIG. 38 when note-on data is received. In step 55_1, the note number of the received note-on data is stored in NT, and the velocity is stored in VL. This velocity VL is stored in NOTEBUF [NT] (see FIG. 23) and PLAYBUF [NT] (see FIG. 24) (steps 55_2 and 55_3). Next, it is determined whether or not ORDER_WR (see FIG. 28) is at the 16th end. If it is less than 16, the key press order buffer ORDER [] (see FIG. 27) is empty, so ORDER [ORDER_WR]. note number NT is stored in note, and ORDER [ORDER_WR]. Velocity VL is stored in velo. In step 55_7, it is determined whether or not the note-on data input this time is the first note-on data received from the state where all the keys are released (note-off). Specifically, it is detected whether or not the effective velocity data stored in PLAYBUF [] is only one velocity stored at step 55_3. If it is the first note-on data, the process proceeds to step 55_8, and the scanner is reset. Thereafter, PLAYBUF [] is scanned to update the lowest sound LO and the highest sound HI (steps 55_9 and 55_10).
[0104]
FIG. 56 is a flowchart of the note-off process routine. This note-off processing routine is executed in step 38_9 of the general program shown in FIG. 38 when the note-off data is received. In step 56_1, the note number of the received note-off data is stored in NT, and '-1' indicating that valid data is not stored is stored in NOTEBUF [NT] (see FIG. 23) (step 56). 56_2). In step 56_3, it is determined whether or not HOLD (see FIG. 26) is less than 64 (hold-off). If hold-on (64 or more), the process ends. When hold-off (less than 64), “−1” is stored in PLAYBUF [NT] (see FIG. 24) (step 56_4), and the current note-off data from the key press order buffer ORDER [] (see FIG. 27). A delete order routine that deletes the note-on data corresponding to is executed (step 56_5), and a pack order routine that prepends the key pressing order buffer ORDER [] that has been deleted by the delete order routine is executed (step 56_5). Step 56_6). In steps 56_7 and 56_8, PLAYBUF [] is searched, and the lowest sound LO and the highest sound HI are updated.
[0105]
FIG. 57 is a flowchart of the delete order routine. This delete order routine is executed in step 56_5 of the note-off process routine shown in FIG. Here, ORDER [] (see FIG. 27) is searched, the presence of the note number NT of the note-off data is searched (steps 57_1 to 57_5), and when ORDER [i] = NT, ORDER [i]. note and ORDER [i]. -1 is stored in both velos. When NT is stored in a plurality of ORDER [i], “−1” is stored for all of them.
[0106]
FIG. 58 is a flowchart of the pack order routine. This pack order routine is executed in step 56_6 of the note-off process routine shown in FIG. Here, the key pressing order buffer ORDER [] is searched and left-justified so as to eliminate the area where “−1” is stored. Specifically, in step 58_1, the initial value “0” is stored in both i and j, and in step 58_2 ORDER [i]. It is checked whether “−1” is stored in the note. ORDER [i]. When valid data (that is, other than “−1”) is stored in “note”, the process proceeds to step 58_3 and ORDER [i]. note, ORDER [i]. velo is ORDER [j]. note, ORDER [j]. velo and j is incremented in step 58_4. Since the current step CUR_ORDER (see FIG. 29) in the key pressing order arpeggio performance needs to be changed as the order of ORDER [] is adjusted, it is checked in step 58_5 whether CUR_ORDER is i, and CUR_ORDER = i When j-1 is stored in CUR_ORDER (step 58_6). In step 58_7, i is incremented. In step 58_8, it is determined whether i is less than or equal to ORDER_WR (see FIG. 28). If i ≦ ORDER_WR, the process returns to step 58_2 to return ORDER [i]. It is checked whether or not note is “−1”.
[0107]
The pointer ORDER_WR (see FIG. 28) of ORDER [] needs to be changed as the ORDER [] is left-justified, and in step 58_9, j is stored in ORDER_WR. FIG. 59 is a flowchart of the hold-off process routine. This hold-off processing routine is executed in step 38_13 of the general program shown in FIG. 38 when hold data is received. When this hold-off processing routine is executed, it is known from the determination in step 38_12 in FIG. 38 that HOLD is less than 64 (hold-off).
[0108]
When the hold-off processing routine shown in FIG. 59 is executed, the NOTEBUF [] (see FIG. 23) that reflects the key depression and key release as it is, and the PLAYBUF [] that stores the key depression information including the hold information over the entire area. ] (See FIG. 24) (steps 59_1 to 59_4). Next, a remake order routine for reconstructing the key pressing order buffer ORDER [] (see FIG. 27) is executed (step 59_5). After ORDER [] is reconstructed, in steps 59_6 and 59_7, PLAYBUF [] is searched and the lowest sound LO and the highest sound HI are updated.
[0109]
FIG. 60 is a flowchart of the remake order routine. This remake order routine is executed in step 59_5 of the hold-off process routine shown in FIG. Here, in order to search PLAYBUF [] in order from the lowest pitch, the initial value “0” is first stored in NT (step 60_1).
[0110]
Next, PLAYBUF [NT] is read and stored in the VL (step 60_2), and whether or not the VL is “−1”, that is, valid velocity data is stored in PLAYBUF [NT] (other than −1). ) Or (-1). When VL = −1, the process proceeds to step 60_4, and a delete order routine (see FIG. 57) is executed. In this delete order routine, note-on data of note number NT is stored in ORDER []. (Specifically, store “−1”). In step 60_5, NT is incremented. In step 60_6, it is determined whether NT is less than 128. When NT is less than 128, the process returns to step 60_2 to read PLAYBUF [NT] for the new NT.
[0111]
In this way, the entire area of PLAYBUF [] is searched, and all the note numbers NT corresponding to PLAYBUF [NT] storing VL = −1 are deleted from ORDER []. Thereafter, in step 60_7, a pack order routine (see FIG. 29) is executed, and ORDER [] is left-justified so as to eliminate the area in which "-1" of ORDER [] is stored. As a result, ORDER [] is in a state in which the key pressing information is arranged in the key pressing order only for the currently pressed key.
[0112]
The arpeggiator in the present embodiment is configured as described above, and the rhythm pattern table (FIGS. 3 and 4) set by the rhythm pattern setting operation 151 and the scan mode setting operation 152 shown in FIG. -Refer to each example in FIG. 9) and a scan mode table (refer to each example in FIG. 10 and FIG. 11 to FIG. 19), and simultaneously press a plurality of keys or sequentially press and hold the keys. Or, it is possible to perform various arpeggio performances that are musically meaningful with a simple operation of storing the key depression by pressing the hold pedal. Further, by operating the groove rate operator 151 shown in FIG. 2, the degree of “nodding” can be easily changed.
[0113]
Next, another embodiment of the arpeggiator of the present invention will be described. However, in the following, illustration and description of parts common to the above-described embodiment will be omitted, and only the differences from the above-described embodiment will be illustrated and described. 61 is a diagram showing the velocity volume added to the panel of FIG. 2, and FIG. 62 is a velocity generation routine shown in FIG. 49 in the configuration in which the velocity volume shown in FIG. 61 is added to the panel shown in FIG. 5 is a flowchart of a velocity generation routine employed instead of
[0114]
In this embodiment, a velocity volume 154 as shown in FIG. 61 is added to the panel 15 (see FIG. 2). This velocity volume 154 can be rotated by pinching by hand. When it is fully rotated counterclockwise, it is “0”. When it is fully rotated clockwise, it is “127”. Are output and stored in VELOCITY_VOLUME in the RAM 13 (see FIG. 1). This VELOCITY_VOLUME is related to the generation of velocity data in an arpeggio performance, as will be described with reference to the flowchart of FIG.
[0115]
In the velocity generation routine shown in FIG. 62, the rhythm pattern number PRM_RHYTHM is referred to in the same manner as the velocity generation routine in FIG. 49 (step 62_1), and the rhythm pattern table PHY_XXX_TBL corresponding to the rhythm pattern number PRM_RHYTHM (FIGS. 3 and 4). ~ Velocity coefficient RHY_XXX_TBL [CUR_RHY] .. of current step CUR_RHY (see FIG. 38) of each example in FIG. The veloCoef is read and stored in the COEF (step 62_2).
[0116]
Thereafter, unlike the velocity generation routine shown in FIG. 49, it is determined whether or not VELOCITY_VOLUME = 0 (step 62_3). When VELOCITY_VOLUME = 0, the procedure is the same as the velocity generation routine of FIG. 49, and the process proceeds to step 62_5, where VL2 = VL × COEF / 127 between the velocity coefficient COEF and the velocity VL generated by the key depression. In step 62_6, calculation of VL− (VL−VL2) × PRM_GROOVE / 100 is performed, and the velocity obtained as a result of the calculation is stored in the VL again.
[0117]
On the other hand, if it is determined in step 62_3 that VELOCITY_VOLUME is not “0”, the flow proceeds to step 62_4, and the VELOCITY_VOLUME is stored in VL. That is, in this case, the velocity generated by the key depression is ignored, and VELOCITY_VOLUME set by the velocity volume 154 shown in FIG. 61 is adopted instead of the velocity generated by the key depression.
[0118]
Thus, if a fixed velocity is used instead of the key pressing velocity, an arpeggio performance having a certain strength can be realized regardless of the key pressing strength. That is, it is possible to perform a stable and reproducible arpeggio performance regardless of the performance state. FIG. 63 shows a style switch added to the panel of FIG. 2, and FIG. 64 shows an edit routine shown in FIG. 54 in a configuration in which the style switch shown in FIG. 63 is added to the panel shown in FIG. It is a flowchart of an edit routine adopted instead.
[0119]
The style switch 155 shown in FIG. 63 includes a plurality of (in this example, three) buttons 155a, 155b, and 155c for each genre. When the buttons 155a, 155b, and 155c are pressed, the waltz (WALTZ) and the reggae (REGGAE), respectively. ), A set of a rhythm pattern number and a scan mode number that matches the image of the shamisen (SHAMISEN) is selected.
[0120]
In the editing routine shown in FIG. 64, first, in step 64_1, it is determined whether or not the style has been changed by pressing any one of the buttons 155a, 155b, and 155c of the style switch 155 (see FIG. 63). When it is recognized that the style has been changed, according to the style after the change (step 64_2), in the case of waltz, PRM_RHYTHM (see FIG. 20) and PRM_SMODE (see FIG. 21) are set to “2” (see FIG. 6). (Refer to FIG. 17). In the case of reggae, “5” (refer to FIG. 9) and “7” (refer to FIG. 18) are stored in PRM_RHYTHM and PRM_SMODE, respectively. “1” (see FIG. 5) and “8” (see FIG. 19) are stored in PRM_RHYTHM and PRM_SMODE, respectively. The other steps 64_4 to 64_10 of the edit routine of FIG. 64 are the same as steps 54_1 to 54_7 of the edit routine shown in FIG.
[0121]
As described above, in this embodiment, for example, when the waltz button 154a is pressed, a rhythm pattern and a scan mode generally considered to be most suitable for the waltz are simultaneously selected and set. Therefore, the performer can select the style he / she wants to select with one touch without thinking about the combination of the rhythm pattern and the scan mode.
[0122]
In the above embodiment, the timbre used for the arpeggio performance is not particularly mentioned, but a timbre suitable for the performance of the style may be automatically selected corresponding to the selected style. For example, if a waltz or reggae style is selected, select the timbre of a musical instrument that is often used when playing waltz or reggae music. If a shamisen style is selected, select a shamisen timbre. You may make it do. In each of the above embodiments, hold information is input via the data input terminal 17 (see FIG. 1). However, a switch for switching and inputting hold-on information and hold-off information may be provided on the panel 15. Alternatively, the arpeggiator itself may be provided with a hold information generating pedal or a jack for connecting the pedal. In each of the above embodiments, the keyboard and the sound source are connected to the outside, but one or both of the keyboard and the sound source may be built in, or may be configured integrally. You may be able to do it.
[0123]
Further, in each of the above embodiments, only one groove rate setting operator 153 is provided, and the duration and velocity of each step of the arpeggio performance are determined by the groove rate PRM_GROUP set by the one groove rate setting operator 153. Although both are changed, it is not necessary to be able to change both of them, and even if only one of them can be changed, a change that is meaningful in terms of music is possible. Alternatively, in order to leave a finer adjustment to the performer, the single groove rate setting controller 153 can be configured to be operated by switching between duration change and velocity change, or for duration change. You may provide the two operation element by which the role was divided for the velocity change use.
[0124]
In each of the above embodiments, the step time, duration, and velocity coefficient are recorded as a set in each step of the rhythm pattern table. However, either step time only, duration only, or velocity only is recorded. The other two parties may use fixed values. Even if you have a deration-only table as a rhythm pattern table, you can perform not only simple arpeggio performances that are equally divided in time but also arpeggio performances of various rhythms. Even in this case, the effects of staccato and tenuto can be added independently for each step of the arpeggio performance. Even in this case, each step of the arpeggio performance can be strengthened and arpeggio performances with various accents can be realized. Of course, you may have a rhythm pattern table of any two of the above three parties.
[0125]
Also, regarding the rhythm pattern table, in order to have the above two or three rhythm pattern tables, the two or three rhythm pattern tables are independently provided (for example, a step time only table and a duration only table). The table may be divided into a table having only velocity), and may be used in combination according to the player's preference and performance style.
[0126]
Note that data of a type other than the step time, duration, and velocity coefficient may be stored as the type of data stored in the rhythm pattern table. For example, if timbre designation data is stored for each step, the timbre can be switched for each step, and a more sophisticated arpeggio performance is possible. In this case, this timbre is considered as a characteristic of the musical tone referred to in the present invention. Further, in each of the above embodiments, it has been described that the rhythm pattern table and the scan mode table are fixedly stored in the ROM 14 (see FIG. 1). However, instead of the ROM 14 or together with the ROM 14, the rhythm pattern table is stored in the RAM 13. Or a scan mode table may be set. In that case, a new rhythm pattern table or scan mode table is loaded from the outside, or an operator that can set the rhythm pattern table or scan mode table is arranged on the panel 15, and the player operates the operator. By operating, you can define a new rhythm pattern table or scan mode table and perform an arpeggio performance that is more suited to your taste.
[0127]
【The invention's effect】
As described above, according to the arpeggiator of the present invention, a more musical arpeggio performance can be performed with a simple operation.
[Brief description of the drawings]
FIG. 1 is a circuit configuration diagram of an embodiment of an arpeggiator of the present invention.
FIG. 2 is a diagram showing a configuration of a panel.
FIG. 3 is a diagram showing a basic pattern of a rhythm pattern table.
FIG. 4 is a diagram showing a rhythm pattern table for quarter notes and the number of steps thereof.
FIG. 5 is a diagram showing a rhythm pattern table for sixteenth notes and the number of steps thereof.
FIG. 6 is a diagram showing a rhythm pattern table for waltz and the number of steps thereof.
FIG. 7 is a diagram showing a rhythm pattern table for shuffle and its number of steps.
FIG. 8 is a diagram showing a rhythm pattern table for diminished and its number of steps.
FIG. 9 is a diagram showing a rhythm pattern table for reggae and the number of steps thereof.
FIG. 10 is a diagram showing a basic pattern of a scan mode table.
FIG. 11 is a diagram showing a scan mode table for ascending scan and its number of steps.
FIG. 12 is a diagram showing a scan mode table for descending scan and its steps.
FIG. 13 is a diagram showing a scan mode table for ascending / descending scan and its steps.
FIG. 14 is a diagram showing a scan mode table for random scan and its steps.
FIG. 15 is a diagram showing a scan mode table for chord scan and its steps.
FIG. 16 is a diagram showing a scan mode table for key pressing order scan and its steps.
FIG. 17 is a diagram showing a scan mode table for waltz and its steps.
FIG. 18 is a diagram showing a scan mode table for reggae and its steps.
FIG. 19 is a diagram showing a scan mode table for shamisen and its steps.
FIG. 20 is a diagram showing rhythm pattern parameters.
FIG. 21 is a diagram showing scan mode parameters.
FIG. 22 is a diagram showing groove rate parameters.
FIG. 23 is a diagram illustrating a note buffer.
FIG. 24 is a diagram illustrating a play buffer.
FIG. 25 is a diagram illustrating a current play note number buffer.
FIG. 26 is a diagram illustrating a hold buffer.
FIG. 27 is a diagram illustrating an order buffer.
FIG. 28 is a diagram illustrating an order write counter.
FIG. 29 is a diagram illustrating an order position counter.
FIG. 30 is a diagram illustrating a rhythm pattern table position counter.
FIG. 31 is a diagram showing a scan mode table position counter.
FIG. 32 is a diagram illustrating a clock counter.
FIG. 33 is a diagram illustrating a next clock buffer.
FIG. 34 is a diagram illustrating a note-off reservation buffer.
FIG. 35 is a diagram showing an end flag.
FIG. 36 is a diagram illustrating a base note buffer.
FIG. 37 is a diagram illustrating a top note buffer.
FIG. 38 is a flowchart of a general program.
FIG. 39 is a flowchart of an initialization processing routine.
FIG. 40 is a flowchart of a reset scanner routine.
FIG. 41 is a flowchart of a clock processing routine.
FIG. 42 is a flowchart of a scan note-on routine.
FIG. 43 is a flowchart of a scan-up routine.
FIG. 44 is a flowchart of a scan order routine.
FIG. 45 is a program of a scan code routine.
FIG. 46 is a program of a scan base routine.
FIG. 47 is a scan code with base program.
FIG. 48 is a program of a note-off reservation routine.
FIG. 49 is a flowchart of a velocity generation routine.
50 is an explanatory diagram of velocity generated by the velocity generation routine shown in FIG. 49. FIG.
FIG. 51 is a flowchart of a next clock update routine.
FIG. 52 is the first half of a flowchart of a scanner update routine.
FIG. 53 is the latter half of the flowchart of the scanner update routine.
FIG. 54 is a flowchart of an edit routine.
FIG. 55 is a flowchart of a note-on process routine.
FIG. 56 is a flowchart of a note-off process routine.
FIG. 57 is a flowchart of a delete order routine.
FIG. 58 is a flowchart of a pack order routine.
FIG. 59 is a flowchart of a hold-off process routine.
FIG. 60 is a flowchart of a remake order routine.
FIG. 61 is a diagram showing a velocity volume added to the panel of FIG. 2;
FIG. 62 is a flowchart of a velocity generation routine employed instead of the velocity generation routine shown in FIG.
63 is a view showing a style switch added to the panel of FIG. 2;
FIG. 64 is a flowchart of an edit routine employed instead of the edit routine shown in FIG.
[Explanation of symbols]
10 CPU
11 Address bus
12 Data bus
13 RAM
14 ROM
15 panels
16 clock timer
17 Data input terminal
18 Data output terminal
20 keys
21 pedals
30 sound sources
151 Rhythm pattern setting operator
152 Scan mode setting operator
153 Controller for setting the groove rate
154 Velocity Volume
155 style switch

Claims (4)

A key-pressing information storage unit that has a storage area corresponding to each of the plurality of keys and erasably writes key-pressing information indicating that the key has been pressed into a storage area corresponding to the key pressed;
For each step of the rhythm, a time interval between a step and the next step following the step is combined with the pronunciation duration information of the musical sound at the step, and stored in one step or each of a plurality of steps. A rhythm pattern table storage means for storing a rhythm pattern table comprising:
The steps in the rhythm pattern table are sequentially referred to, and the storage area is scanned corresponding to each step, and the key pressing information detected by the scanning and the step corresponding to the scan in the rhythm pattern table Performance information generating means for generating performance information representing a musical sound based on both of the recorded pronunciation duration information at a timing according to the time interval recorded in the step;
The arpeggiator characterized in that the performance information generating means further generates performance information representing a changed musical tone based on information defining the degree of change in pronunciation duration. A key-pressing information storage unit that has a storage area corresponding to each of the plurality of keys and erasably writes key-pressing information indicating that the key has been pressed into a storage area corresponding to the key pressed;
For each step of the rhythm, the time interval between a step and the next step following that step is combined with the tone intensity information of the musical sound at that step and stored in one step or each of a plurality of steps. Rhythm pattern table storage means for storing a rhythm pattern table comprising:
The steps in the rhythm pattern table are sequentially referred to, and the storage area is scanned corresponding to each step, and the key pressing information detected by the scanning and the step corresponding to the scan in the rhythm pattern table Performance information generating means for generating performance information representing a musical sound based on both the recorded pronunciation intensity information and a timing according to a time interval recorded in the step;
The arpeggiator characterized in that the performance information generating means further generates performance information representing a musical tone that has been changed based on information that defines the degree of change in pronunciation intensity. 2. The arpeggiator according to claim 1, further comprising an operator that generates information that defines a degree of change in the pronunciation duration according to the degree of operation. The arpeggiator according to claim 2, further comprising an operator that generates information that defines a degree of change in the pronunciation intensity according to a degree of operation.

Images