JP3505292B2 - Arpeggiator - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an arpeggiator which scans key depression information and sequentially generates a plurality of performance information according to the scanning result.

[0002]

2. Description of the Related Art Some conventional electronic musical instruments have a function called a so-called arpeggiator. With this arpeggiator, key press information is
For example, it is a function of sequentially scanning from the lowest pitch to the highest pitch, and sequentially outputting performance information according to the result.

With this function, it is possible to realize an arpeggio performance, which is difficult for the performer to perform originally, by a simple performance operation of simply pressing a plurality of keys at the same time. The conventional arpeggiator scans the key press information from the lowest pitch to the highest pitch (ascending scan method)
Not only that, scan method such as scanning from high pitch to low pitch (downward scan method), repeating rising and falling (upward / downward scan method), or scanning randomly (random scan method) Some have been adopted. Among the arpeggiators that employ these various scanning methods, there is one that has a so-called key-press order arpeggiator. The key-depression order arpeggiator scans the depressed keys in the order in which they are depressed and generates performance information in accordance with the result of the elapse of time. This allows you to play a simple melody.

Japanese Patent Publication No. 61-60439 discloses an example of the key pressing arpeggiator. In this document, key depression information is stored in a storage device in the order of key depression,
By reading the memory device in order, key-playing order arpeggio performance is realized. However, in the key press order arpeggiator disclosed herein, even when the key pressed is released, the key press information of the key is not deleted from the storage device, and therefore the arpeggio performance continues endlessly. . Further, when the number of keys pressed exceeds the capacity of the storage device, it returns to the beginning of the storage device and overwrites the old key pressing information and stores new key pressing information. Has been done.

Another example of the conventional arpeggiator is JP-4 / 8, a product of Roland Corporation. In this JP-4 / 8, as in the above-mentioned document, the key-depression information is stored in the memory device in the key-depression order and the memory device is read out in order to realize the key-depression order arpeggio performance. In addition, a hold switch is provided, and while the hold switch is being pressed, even if the key that was pressed is released, the key press information for that key is not deleted from the storage device, so the arpeggio performance continues without end. . However, if there is a new key press while the hold switch is being pressed, the key press information generated by the new key press is already released, even if the storage capacity of the storage device is large. Despite that, the oldest key depression information in the key depression information stored in the storage device is overwritten, and the key depression information stored until then is lost. It is configured.

On the other hand, in JP-4 / 8, when the hold switch is not pressed, the key pressing information of the released key is immediately deleted from the storage device and excluded from the arpeggio performance. Therefore, when the hold switch is not depressed, the arpeggio performance is stopped when all the depressed keys are released. In addition to the hold switch, the JP-4 / 8 is also provided with a jack for connecting a pedal that performs the same processing as the hold switch.

[0007]

The key-depression order arpeggiator disclosed in the above document is a process in which the key-depression information of a key that has been once depressed is not deleted from the storage device until it is replaced by a new key-depression. Therefore, there is a problem that the arpeggio performance cannot be stopped at an arbitrary timing intended by the performer. Further, when the number of key presses exceeds the capacity of the storage device, the key press order arpeggiator disclosed in the above document returns to the head of the storage device and overwrites the old key press information to generate new key press information. Since it is a process of rewriting, there is also a problem that there is a possibility that the key depression information that was supposed to be stored will be erased by an inadvertent operation.

On the other hand, in JP-4 / 8, the arpeggio performance can be stopped at an arbitrary timing by releasing all keys by performing the arpeggio performance without pressing the hold switch. However, this J
In P-4 / 8, if a new key is pressed even when the hold switch is not pressed and the hold switch is pressed, the key pressing information stored in the storage device is lost due to overwriting. As a result, the musical tone corresponding to the key depression of the same key cannot be included a plurality of times, resulting in a great limitation in the degree of freedom of the melody.

In view of the above circumstances, the present invention realizes a complicated keypress-order arpeggio performance in which one melody during keypress-order arpeggio performance can include musical tones corresponding to the same key many times. It is an object of the present invention to provide an arpeggiator capable of stopping the arpeggio performance at an arbitrary timing as well as being capable of performing the operation.

[0010]

The arpeggiator according to the present invention which achieves the above object, comprises: (1) a storage means having a predetermined storage capacity; and (2) a depressed key of a plurality of keys in the storage means. Key-depression information storage control means for storing key-depression information to be specified in order of key-depression (3) From the storage means, the key-release information is specified based on key-release information for specifying the released key of the plurality of keys. Key-depression information erasing means for erasing the key-depression information of the key corresponding to (4) receiving predetermined hold-on information, prohibiting the key-depression information erasing means from erasing the key-depression information from the storage means, Receiving the predetermined hold-off information, the prohibition of the key-depression information erasing means from erasing the key-depression information from the storage means is released, and the hold-off information is stored in the key-depression information erasing means from the storage means. Depressing the key that was pressed when the key was received Key-depression information holding means for erasing key-depression information excluding information (5) Equipped with performance information generation means for sequentially scanning the storage means and generating performance information representing musical tones based on the key-depression information detected by the scanning. An arpeggiator characterized by that.

In the arpeggiator of the present invention, the hold-on information prohibits the deletion of the key-depressing information from the storage means.
-4/8, in order to avoid the situation where old key depression information is lost by overwriting even though the memory capacity of the memory means is large, the key depression information by a new key depression is added to the memory means. You can do it. Therefore, according to the arpeggiator of the present invention, by pressing a certain key, releasing the key once, and then pressing the key again, the musical tone corresponding to the same key can be played at any desired number during one arpeggio performance. Can be included. Further, the arpeggiator of the present invention erases all the key-depression information excluding the key-depression information of the key being depressed from the storage means by the hold-off information, so that all keys are released after receiving the hold-off information. By doing so, or by receiving hold-off information with all keys released, the arpeggio performance can be stopped at any timing.

Here, the arpeggiator of the present invention is preferably provided with an operator that outputs hold-on information and hold-off information in response to an operation. In that case, the operator is further a pedal. preferable. When such an operator (preferably a pedal) is provided, the hold-on information and the hold-off information can be given as intended by the performer, and the arpeggio performance can be performed as the performer desires.

Alternatively, the arpeggiator of the present invention may be provided with a hold information input means for inputting hold-on information and hold-off information from the outside and passing it to the key-depression information holding means. In this case, it is convenient for a system in which a sequencer or a keyboard is externally attached and the key depression information is input from the sequencer or the keyboard.

Further, in the state in which the arpeggiator of the present invention receives the hold-on information, the key-depression information storage control unit stores key-depression information for specifying the key depressed in the storage unit having the predetermined storage capacity. Additional press key information storage for prohibiting storage of new key press information in the storage means in a state where the key press information is stored in the entire area of the storage means having the predetermined storage capacity. It is preferable that a prohibition means is provided. In this case, it is possible to prevent the key depression information, which should have been stored in the memory, from being erased by an inadvertent operation, and the player can perform the key depression operation for the key depression order arpeggio performance with peace of mind.

[0015]

BEST MODE FOR CARRYING OUT THE INVENTION Embodiments of the present invention will be described below. FIG. 1 is a circuit configuration diagram of an embodiment of the arpeggiator of the present invention. Here, the CPU 10, the address bus 11 and the data bus 12 are 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 the data conforming to the MIDI standard are input. A data input terminal (MIDI IN) 17, a data output terminal (MIDI O for outputting data compliant with the MIDI standard)
UT) 18 is provided.

The ROM 14 is a read-only memory area in which programs executed by the CPU 10 and various tables referred to by the programs are stored. Details of the programs and tables 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.

The panel 15 has operation switches and a display, and can independently select a parameter and set a value for the parameter. The set value is stored in the memory in the RAM 13. FIG. 2 is a diagram showing the panel 15. In this panel, the rhythm pattern number (Rhyt
hem Pattern #), scan mode number (S
can Mode #) and groove rate (Gro
ove Rate) can be set.

In the present embodiment, the rhythm pattern is a combination of patterns of tone generation timing, duration, and velocity coefficient. The rhythm pattern setting operator 151 is an operation button 15 for incrementing a value.
It is composed of a pair of 1a and an operation button 151b for decrementing the value, and the value set by these operation buttons 151a and 151b is displayed on the display 151c and stored in the RAM 13 as described above.

The scan mode is a set of scanning methods for scanning key pressing information. Similar to the rhythm pattern setting operator 151, the scan mode setting operator 152 has an operation button 152a for incrementing the value and an operation button 15 for decrementing the value.
1b and a pair of operation buttons 151a,
The value set in 151b is displayed on the display 152c and stored in the RAM 13.

The groove rate defines the degree of so-called "stickiness", and the groove rate setting operator 1
Reference numeral 53 is a slider, and its slide button 153a
Move to the bottom to set the groove rate parameter to a value of '0', and move to the top to set the groove rate parameter to a value of '100'. , A value between 0 and 100 is set. The set value is stored in the RAM 13.

Details of each parameter will be described later.
Returning to FIG. 1, the description will be continued. The clock timer 16 is
A clock is generated at a constant cycle, and every time the clock is generated, the CPU is notified of the clock generation. In the present embodiment, the time for 96 clocks is set as the sounding time of the quarter note, and the tempo of the albeggio is determined by this clock cycle.

A keyboard 20 is connected to the data input terminal (MIDI IN) 17, for example, as shown in FIG.
The key-depression (note-on) information and key-release (note-off) information generated by the performance of are input. Also, the keyboard 20
A hold pedal 21 is connected to the hold pedal 21. The hold-on information and hold-off information (these are collectively referred to as hold information) generated by operating the hold pedal 21 are also data input as a kind of MIDI data. It is input via the terminal 17.

The CPU 10 receives key depression information and key release information input from the data input terminal 17, sequentially generates performance information for arpeggio performance, and outputs the performance information to the outside from the data output terminal 18. To do. Data output terminal 1
A sound source 30 is connected to the sound source 8 as shown in the figure, for example, and the sound source 30 generates a musical tone signal based on the received performance information. The musical tone signal is emitted to the space as a musical tone by a sound system which is built in the sound source 30 or is connected to the sound source 30 and includes an amplifier and a speaker.

Hereinafter, various tables stored in the ROM, which are referred to by a program to be described later, will be described first, then various memories secured in the RAM will be described, and then these tables and memories will be used. The program will be described. 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 has a time interval (step time; Step Time) between the step and the next step following the step, and the step. The rhythm sound duration (duration) and the velocity coefficient (Velo. Coef.) That defines the pronunciation strength of the rhythm sound of the step are recorded, and finally, the size of the rhythm pattern table (the 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, and a velocity coefficient of 1 byte, and the number of steps is 1 byte. In the column of step time and duration, numerical values are recorded with the above-mentioned clock (quarter note = 96 clock) as a unit.

A plurality of types of this rhythm pattern table are recorded in the ROM, and each rhythm pattern table is numbered. The player can select an arbitrary rhythm pattern table by operating the rhythm pattern setting operator 151 shown in FIG. 2 and setting the rhythm pattern number. Here, the rhythm pattern table and the number of steps thereof are respectively RH
Y_XXX_TBL [n], RHY_XXX_SIZE
Is written. XXX represents the name of the rhythm pattern table, and n in [n] is the step number (0 ≦ n <RHY_XXX_S in the rhythm pattern table.
IZE).

The step time, duration, and velocity coefficient recorded in the nth step of the rhythm pattern table name XXX are RHY_XXX_TBL [n]. stepTime RHY_XXX_TBL [n]. duration RHY_XXX_TBL [n]. It is written as veloCoef.

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 thereof. This rhythm pattern table has a name of "4" indicating that it is for quarter notes and is represented as RHY_4_TBL. RHY_4_TBL [0]. stepTi
me, RHY_4_TBL [0]. duration,
RHY_4_TBL [0]. veloCoef is 96 (quarter note clock number), 92 and 127, respectively. The number of steps is written 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”.

This rhythm pattern table RHY_4_
TBL and rhythm pattern table RH shown below
Different rhythm pattern numbers are assigned to the Y_XXX_TBL, and the rhythm pattern number of the rhythm pattern table RHY_XXX_TBL shown in FIG. 4 is “0”. 5, FIG. 6, FIG. 7, FIG.
FIG. 9 shows sixteenth notes (name: 16), waltz (WALTZ), and shuffle (SHUFFLE), respectively.
For, diminished (DIM), reggae (REGGA
It is the figure which showed the rhythm pattern table for E) and its step number. The rhythm pattern numbers are in this order,
1, 2, 3, 4, and 5 are attached. Since these structures are clear from the above description, detailed description will be omitted.

FIG. 10 is a diagram showing a basic pattern of the scan mode table. In each step of the scan mode table, the number of the method (scan method) for scanning the key pressing information (scan function number; Scan)
Function #) 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.

This scan mode table is stored in the ROM 1
4 are stored in plural types, 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 SMODE_XXX_TBL, respectively.
[N] and SMODE_XXX_SIZE.
XXX represents the name of the scan mode table,
N of [n] is a step number (0 ≦ n <SMODE_XXX_SIZE) in the scan mode table.

Each scan method (Sc
an Function) is as follows. (1) Ascending scan method The key depression information is scanned from a lower pitch to a higher pitch. Here, this is described as SCAN_U.

(2) Downward scanning method Scanning is performed from a higher pitch to a lower pitch. Here, this is described as SCAN_D. (3) Ascending / descending scanning method Scanning is performed from a lower pitch to a higher pitch, and when the highest pitch is reached, scanning is performed from a higher pitch to a lower pitch. Here, this is referred to as SCAN_UD.

(4) Random scan method Scans randomly. Here, this is described as SCAN_R. (5) Key-depression order scanning method Scanning is performed in the order in which key-depression information is input. Here, this is SCA
Notated as N_O. (6) Chord scanning method All the keys currently pressed are scanned. Here, this is described as SCAN_C.

(7) Lowest tone scanning method Among the currently depressed keys, only the lowest note number (lowest tone) is scanned. Here, this is described as SCAN_B. (8) Highest tone scanning method Among the currently pressed keys, only the highest note number (highest tone) is scanned. Here, this is described as SCAN_T.

(9) Rising scan system without lowest tone Except for the lowest tone, scanning is performed from the lowest pitch to the highest pitch. Here, this is SCAN_U_WO_B (Sca
Mup without bass). (10) Random scan method without lowest tone Except for the lowest tone, scanning is performed randomly. Here, this is described as SCAN_R_WO_B.

(11) Scanning chord of lowest tone The system scans all the currently depressed keys except the lowest tone. Here, this is described as SCAN_C_WO_B. (12) Highest tone removal rising scan method Except for the highest tone, scanning is performed from the lowest pitch to the highest pitch. Here, this is described as SCAN_U_WO_T.

Next, examples of the scan mode table will be shown. FIG. 11 is a diagram showing a scan mode table for ascending scan and the number of steps thereof. This scan mode table represents the name “UP” indicating that the scan mode is for ascending scan, and SMODE_
Notated as UP_TBL. The number of steps is SMODE
It is written as _UP_SIZE. Since the scan mode table SMODE_UP_TBL consists of only one step in which the ascending scan method SCAN_U is recorded, the number of steps SMODE_UP_SIZE is “1”. This scan mode table SMODE
_UP_TBL and each scan mode table SMODE_XXX_TBL shown below are given different scan mode numbers, and the scan mode table SMODE_UP shown in FIG.
The scan mode number of _TBL is '0'.

12, FIG. 13, FIG. 14, FIG. 15, FIG.
6, FIG. 17, FIG. 18, and FIG. 19 are respectively for down scan (DOWN), up and down scan (UP_DW),
The scan mode table and its steps for random scan (RANDOM), chord scan (CHORD), keypress scan (ORDER), waltz (WALTZ), reggae (REGGAE), and shamisen (SHAMI) are shown. It is a figure.

The scan mode numbers are 1, 2 in this order.
2, 3, 4, 5, 6, 7, and 8 are attached. Since these structures are clear from the above description, detailed description will be omitted. Next, the memory in the RAM in which various parameter values are stored will be described. FIG. 20 is a diagram showing rhythm pattern parameters. The rhythm pattern parameter is a 1-byte memory, and the rhythm pattern number set by the operation of the rhythm pattern setting operator 151 of the panel 15 shown in FIG. 2 is stored in this memory. Here, this is described as PRM_RHYTHM.

FIG. 21 is a diagram showing scan mode parameters. This scan mode parameter is also a 1-byte memory, and the scan mode number set by the operation of the scan mode setting operator 152 of the panel 15 shown in FIG. 2 is stored in this memory. Here, this is described as PRM_SMODE. FIG. 22
FIG. 6 is a diagram showing a groove rate parameter. This groove rate parameter is also a 1-byte memory, and this memory stores the value of the blue blade set by the operation of the glue blade setting operator of the panel 15 shown in FIG. As described above, the range of this value is 0 to
100. Here, this is PRM_GROOVE
It is written as.

FIG. 23 is a diagram showing a note buffer. This note buffer is an array of 128 bytes, each 1 byte corresponds to each key (note number) of the keyboard 20 (see FIG. 1), and when the key depression information is received, the key depression information in the key depression information is received. Information (note-on velocity) indicating the key pressing strength is stored in the area corresponding to the note number in the key pressing information. If the corresponding key is released (note-off), or if the key has been pressed and released, "-1" is stored in that area.

Here, each area of the note buffer is referred to as NOTEBUF [n]. n represents a note number. FIG. 24 is a diagram showing a play buffer. This play buffer is an array of 128 bytes like the note buffer shown in FIG. 23, and each 1 byte corresponds to each note number. However, unlike the note buffer shown in FIG. 23, the play-on buffer stores note-on velocity with hold information added. 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-on information is input via the data input terminal 17. Although hold-off information is input, when hold-on information is received, deletion of the key-depression information stored in the play buffer shown in FIG. 24 is prohibited until the hold-off information is received.
When the hold-off information is input, the contents of the note buffer at that time are copied to the play buffer.
Unless the hold-on information is input next, the play buffer always maintains the same content as the note buffer. When playing an arpeggio, this play buffer in which velocities with hold information are arranged is scanned. Here, the area of this play buffer is described as PLAYBUF [n]. n represents a note number.

FIG. 25 is a diagram showing the current play note number buffer. This current play note number buffer is a 1-byte memory, and this memory stores the note number of the current step during the arpeggio performance. Here, this is described as CUR_NOTE. FIG. 26 is a diagram showing the hold buffer.
This hold buffer is a 1-byte memory in which hold information of numerical values 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 this hold buffer. Here, if this numerical 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 described as HOLD.

FIG. 27 is a diagram showing the order buffer. This order buffer is an array of 16 steps, each step consisting of 2 bytes, and a note number and the velocity of the note number are stored in each step. In this order buffer, the note number of the key that was pressed and the velocity at which the key was pressed are stored in the order in which the keys were pressed. Be done. Here, this is expressed as ORDER [n]. n is a step number (n = 0 to 15). In particular, when referring only to the note number of the nth step and only velocity,
RDER [n]. note, ORDER [n]. vel
It is written as o.

FIG. 28 is a diagram showing an order write counter. This order write counter is a 1-byte memory, and when the key press information is received next, the received key press information is stored in the order buffer of the order buffer ORDER [] shown in FIG. A value indicating whether to store in is stored. The possible values of this order write counter are 0 to 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 described as ORDER_WR.

FIG. 29 is a diagram showing an order position counter. This order position counter is a 1-byte memory, and the tone of the current step in the arpeggio performance is stored in the order buffer O shown in FIG.
A value indicating which number of steps of RDER [] the tone corresponds to is stored. Possible values of the order position counter are -1 to 15. 0 to 15 are shown in FIG.
Corresponding to each step of the order buffer ORDER [] shown in FIG. 7, -1 means a timing to start a series of steps of arpeggio performance (timing at which the previous series of steps is finished). Here, this is described as CUR_ORDER.

FIG. 30 shows the 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 FIGS. 3 and 4 to 9). .. This pointer corresponds to the current rhythm step during arpeggio performance. The possible value of the rhythm pattern table position counter is 0 or more and less than the number of steps RHY_XXX_SIZE of the currently selected rhythm pattern table. Here, this is described as CUR_RHY.

FIG. 31 shows the 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 FIG. 10 and each example of FIGS. 11 to 19). This pointer also corresponds to the current rhythm step during arpeggio performance. The possible value of the scan mode table position counter is 0 or more and less than the number of steps SMODE_XXX_SIZE of the currently selected scan mode table.
Here, this is referred to as CUR_SMODE.

FIG. 32 is a diagram showing a clock counter. The clock counter is a 2-byte (16-bit) memory, and the value of the clock counter is incremented 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 after FFFFh, it returns to 0000h and makes an infinite cycle while the power is on. The arpeggio progresses based on the increase in the value of this clock. Here, this is described as CLOCK.

FIG. 33 is a diagram showing the next clock buffer. This next clock buffer is a 2-byte (16-bit) memory, and the time of the next step of the arpeggio performance is stored in this memory. That is, when CLOCK shown in FIG. 32 increases and reaches the value stored in this next clock buffer, the key-depression information is scanned and the note-on data is transmitted. When the processing of one step is completed, the value of this next clock buffer is updated at the time of the next step. The range of values that this next clock buffer can take is 0000h.
~ FFFFh. Here, this is NEXTCLK
It is written as.

FIG. 34 is a diagram showing a note-off reservation buffer. The note-off reservation buffer is an array of 3 bytes × 16, and the note-off reservation buffer stores a note-number to be note-off and a timing at which the note-number should actually be transmitted as note-off data as a pair. . This transmission timing is represented by the value of CLOCK in FIG. CLOC
When K increases sequentially 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. To be done. Area in the note-off reservation buffer where valid data is not stored,
Alternatively, "-1" is stored in the area where the note-off data has been transmitted.

This is expressed as OFFRSV [n] here. n means the n-th storage area of the pair of note number and its transmission timing. Especially OFFRSV
[N] middle note number and OFFRSV [n]. note, OF
FRSV [n]. It is written as clock. FIG. 35 shows
It is a figure which shows an end flag. Although the end flag is composed of a 1-byte memory here, it may be composed of 1 bit due to the nature of the flag. This end flag takes a binary value of "0" and "1", and "0" indicates that scanning for the sounding of one step in the arpeggio performance is unfinished, and "1" is This indicates that scanning for sounding one step is completed. Here this is
Notated as END_FLG.

FIG. 36 is a diagram showing a base note buffer. This base note buffer is a 1-byte memory, and in this memory, the note number of the lowest note key among the keys being pressed with hold information is stored. Here, this is described as LO. FIG. 37 is a diagram showing the top note buffer. This top note buffer is a 1-byte memory, and the note number of the highest note key among the keys being pressed is stored in this memory. Here, this is described as HI.

In addition to the memories described above, there is a memory to be used as a work area. However, since the description of the program described later is sufficient, a description of the memories other than those described here one by one is omitted. To do. Below, using the table and memory described so far, the CPU
The program executed by will be described.

FIG. 38 is a flow chart of a general program which starts its operation when the power is turned on and continues its operation until the power is turned off. When the power is turned on, first, a predetermined initialization is performed (step 38_1), and 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) is operated to edit any parameter (step 38_4), and whether note-on data (key depression information) is input (step 38_).
6), whether note-off data (key release information) is input (step 38_8) and whether hold data (hold information) is input (step 38_10) are sequentially and cyclically monitored, and each step 38_2, 38_4
When it is recognized that each event has occurred in 38_6, 38_8, and 38_10, the clock processing (step 38_3) and the edit processing (step 38_) are performed, respectively.
5), note-on processing (step 38_7), note-off processing (step 38_9), and hold data processing (steps 38_11, 38_12, 38_13).

In the hold data processing, first, HOLD
The hold value is stored in (see FIG. 26) (step 38).
_11), and the hold value represents hold-on 6
It is determined whether it is 4 or more (step 38_1).
2) If the holdoff is 63 or less, the holdoff process is performed (step 38_13). FIG. 39
3 is a flowchart of an initialization processing routine. This initialization processing routine is executed in step 38_1 of the general program shown in FIG.

In this initialization processing, first, the order buffer ORDER in which the velocities at the time of key depression are stored in the key depression order.
[] (See FIG. 27) is cleared, and the storage pointer ORDER_WR (FIG. 2) of the order buffer ORDER [] is cleared.
8) is initialized to '0' (the beginning of ORDER []), and the order position counter CUR_ORD
ER (FIG. 29) represents the timing to start a series of steps of the arpeggio performance .'-
It is initialized to 1 '(step 39_1).

Next, the clock timer 16 (see FIG. 1)
Clock counter C that counts clocks generated in
LOCK (see FIG. 32) is initialized to '0' (step 39_2), and the next clock buffer NEXTCLK (FIG. 3) in which the timing of generation of the next performance information is stored.
3) is also initialized to '0' (step 39_).
3). Further, the note-off reservation buffer OFFRSV [] (see FIG. 34) that stores the note number to be note-off and the timing to note-off is cleared (step 39_4), and the keys of the keyboard 20 (see FIG. 1) are arranged. Note buffer NOTEBU which has an array corresponding to and stores the velocity of the depressed key
F [] (see FIG. 23) is cleared (step 39_).
5) Further, the play buffer PLAYBUF [] (see FIG. 24) in which the velocity including the hold information is stored is cleared (step 39_6). Further, a hold buffer HOLD (FIG. 26) in which a hold value is stored
Is reset to '0' (step 39_7), and the reset scanner routine for resetting the scanner is executed (step 39_8).

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, the current play note number buffer CU in which the note number currently playing the arpeggio is stored
'-1' indicating empty is stored in R_NOTE (see FIG. 25), and the order position counter CUR_ORDER (see FIG. 29) in the order buffer ORDER [] (see FIG. 27) indicating the step currently playing the arpesio, '-1' indicating empty is stored, and further,
Scan mode table position counter CUR_SMODE (see FIG. 31), which is each pointer of the scan mode table and rhythm pattern table, rhythm pattern table position counter CUR_RHY (FIG. 30)
(Reference) is initialized to '0' indicating the beginning. 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 value obtained by adding "1" to CLOCK is NEXT.
The reason for using CLK is that NEXTCLK =
It is sounded at the time of CLOCK (note-on data is transmitted), but CLOCK is incremented during the operation of this program, and CLOCK exceeds NEXTCLK indicating the sound generation start timing, and the sound is not generated. This is to eliminate the possibility of occurrence.

In the reset scanner routine shown in FIG. 40, an end flag E indicating whether the operation for sounding one step of the arpeggio performance being performed is unfinished or completed.
“0” indicating unfinished is stored in ND_FLG. Figure 4
1 is a flowchart of a clock processing routine.
This clock processing routine is executed in step 38_3 of the general program shown in FIG.

In this clock processing routine, first CL
OCK (see FIG. 32) is 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 if there is note-off data to be transmitted at the current timing, The note-off data is transmitted (steps 41_2 to 41)
_8).

Specifically, first, "0" is set to i (step 41_2), and OFFRSV [i]. Whether valid note-off data is stored in note (0 to 12)
7) Check whether or not (-1) (step 41_3), '-
In the case of 1 ', i is incremented (step 41_
7), the search is performed until i reaches 16 (step 41_8). If it is confirmed in step 41_3 that the valid note-off data is stored, the process proceeds to step 41_4, and OFFRSV [i]. clock is the current CLO
It is determined whether or not it is equal to CK, and if so, the note-off data is transmitted as performance information (step 41
_5), OFFRSV [i]. Of the area where the note-off data was stored. "-1" is written in "note" (step 41_6).

When the search for the note-off data is completed,
This time, a process of finding note-on data to be transmitted is performed (steps 41_9 to 41_17). Specifically, it is first determined whether or not the current CLOCK has reached NEXTCLK, that is, whether or not it has reached the timing at which note-on data should be transmitted (step 41_9), and if that timing has not yet been reached, It ends as it is.

When NEXTCLK = CLOCK, the routine proceeds to step 41_10, and the scan note-on routine for scanning the key depression information is executed (step 41_1).
0). Although 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 sent. 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 the note-off reservation routine is executed. Although details of this note-off reservation routine will also 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), so that Make an off reservation.
When OFFRSV [] is full, "-1" indicating that note-off reservation cannot be made is stored in NT.

At step 41_13, it is determined whether or not note-off reservation has been made by checking whether NT = -1. If note-off reservation cannot be made, note-on data is not transmitted and the process returns to step 41_10. The next note-on data to be transmitted is searched. When NT ≠ -1 in step 41_13, that is, when the note-off reservation is normally made, step 41_
Proceeding to 14, the velocity generation routine is executed. The details of this velocity generation routine will also be described later.
In this velocity generation routine, the velocity of the note-on data to be transmitted is generated by the calculation described later. After that, the note-on data is transmitted in step 41_15, the process returns to step 41_10, and a search is made as to whether or not there is more note-on data to be transmitted at the present timing.

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 the note-on data to be transmitted at the current timing is transmitted). If so, the process proceeds to step 41_16 via step 41_11. In step 41_16, the next clock update routine is executed. Although the details of this next clock update routine will be described later, here, the next timing of note-on data transmission is stored in NEXTCLK.

After that, the routine proceeds to step 41_17, where the scanner update routine is executed. This scanner update routine updates the scanner. The 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.

In this scan note-on routine, first, the PRM_SMO storing the scan mode number is stored.
The DE (see FIG. 21) is referred to (step 42_1),
The scan method (scan function number) SMODE_XXX_TBL stored in the current step number CUR_SMODE in the scan mode table (see FIG. 10 and each example in FIGS. 11 to 19) corresponding to the scan mode number stored in the PRM_SMODE.
[CUR_MODE] is stored in the work area func (step 42_2). Then, the scan function number stored in the func is SCAN_U, SC
AN_D, SCAN_UD, ..., SCAN_U_WO
, Scan up routine (step 42_5), scan up / down routine (step 42_6), ... (42_1
5) is executed.

In the following, as typical ones, 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 without base ( Step 42_14) will be described. Figure 43
3 is a flowchart of a scan-up routine.
This scan-up routine is a routine that realizes the above-described ascending scan method.

Here, first, END_FLG (FIG. 35).
Reference) is '1' or '0', that is, it is determined whether or not the scan for sounding one step this time has already been completed (step 43_1). If END_FLG = 1, that is, this time If the scan of has already finished,
The process proceeds to step 43_2, '-1' is stored in NT, and the process ends. However, when this scan-up routine is first executed in this step, END_FLG = 0
Is.

If END_FLG is not "1" in step 43_1, the process proceeds to step 43_3 and P
It is determined whether or not even one note-on data exists in LAYBUF [] (see FIG. 24). If no note-on data exists, it is impossible to sound, so the process proceeds to step 43_2 and NT ' -1 'is stored and the process ends.

When it is recognized that note-on information is present in PLAYBUF [], note-on data to be transmitted next is scanned according to the ascending scan method (steps 43_4 to 43_7). Specifically, CUR
_NOTE (see FIG. 25) stores the note number of the note-on data transmitted immediately before, so the C
Advance UR_NOTE to the next note number (step 4
3_4), when the note number reaches 128 (step 43_5), '0' is stored in CUR_NOTE (step 43_6), and the C updated in this way is stored.
Using UR_NOTE, PLAYBUF [CUR_N
It is determined whether or not valid velocity data is stored in [OTE] (step 43_7). PLAYBU
If F [CUR_NOTE] = − 1, that is, if valid velocity data is not stored therein, the process proceeds to step 43_4, CUR_NOTE is incremented again, and a region in which valid velocity of PLAYBUF [] is stored is found. Therefore, scanning is performed from the lowest pitch to the highest pitch.

In this way, when PLAYBUF [] in which valid velocity data is stored is found, CUR_NOTE at that time is stored in NT (step 43_8), and CUR_NOTE stored in PLAYBUF [NT]. Is stored in VL (step 43_9), and since only one note-on data is transmitted in one step in the ascending scan method, "1" indicating the end of scanning is stored in END_FLG (step 43_10).

FIG. 44 is a flow chart of the scan order routine. This scan order routine is a routine that realizes the above-described key pressing order scan method.
Steps 44_1 and 44_2 are the same as steps 43_1 and 43_2 of the scan-up routine shown in FIG. 43, and description thereof will be omitted. In step 44_3, ORD
It is checked whether ER_WR = 0. ODER_WR
As described with reference to FIG. 28, is a pointer of ORDER [] (see FIG. 27) that stores key depression information in the key depression order. When ORDER WR = 0, it means ORDE.
R [] is empty, which means that the arpeggio performance in the key-depression order cannot be performed. In this case as well, the routine proceeds to step 44_2, where "-1" is stored in NT and the processing ends.

ORDER_WR = 0 in step 44_3
Is not, that is, if it is determined that ORDER [] is not empty, the process proceeds to step 44_4 and CUR_ORDE
R (see FIG. 29) is incremented and CUR_OR
It is determined whether or not DER exceeds the maximum step in which ORDER [] is written (step 44_5), and if it exceeds, 0 is stored in CUR_ORDER (step 44_6). CUR whose value has been advanced in this way
Note number O to be pronounced next using _ORDER
RDER [CUR_ORDER]. note is stored in NT (step 44_7), and the velocity ORDER [CUR_ORDER]. velo is stored in VL (step 44_8). Even in this key press order scanning method, since only one note-on data is transmitted in one step, END_FLG is set to
"1" indicating the end of scanning is stored (step 44_).
9).

FIG. 45 shows a scan code routine program. This scan code routine is a routine that realizes the chord scanning method described above. Steps 45_1, 45_2 and 45_3 are steps 43_1, 43_2 and 4 of the scan-up routine shown in FIG.
It is similar to 3_3 and its description is omitted. In this step, when the scan code routine is called for the first time, “-1” is stored in CUR_NOTE, so that steps 45_4, 45_5, 4 are executed.
In the loop 5_6, it starts at CUR_NOTE = 0 and scans until CUR_NOTE = 127. During the scanning, if it is found that a value other than “−1”, that is, valid velocity data is stored in PLAYBUF [CUR_NOTE], the process proceeds to step 45_7 to store the note number CUR_NOTE in NT,
Velocity data PLAYB of the note number in VL
UF [NT] is stored (step 45_8), and this routine is temporarily exited.

In the chord scanning method, PLAYBU
Since it is necessary to scan the entire area of F [] and transmit all the note-on data in which valid velocity data is stored, when exiting this scan code routine before reaching CUR_NOTE ≧ 128, END_FLG is set to '1'. Not stored in. When this scan code routine is exited, the scan note-on routine shown in FIG. 42 is also exited, and step 41_ of the clock processing routine of FIG. 41 is executed.
I'm going through 10. When NT is not -1,
Steps 41_12, 41_13, 41_14, 41_
One note-on data is transmitted in 15 and the process returns to step 41_10 again to execute the scan code routine of FIG. 45 again via the scan note-on routine of FIG. 42. At that time, scanning is performed from the value CUR_NOTE next to CUR_NOTE when the execution is started again, that is, when the routine is exited last time (step 45_4). Step 45_
CUR_NOTE ≧ 128 in 5, ie PLA
When it is determined that the scanning of YBUF [] is completed, the process proceeds to step 45_9 to store "-1" in NT, and further proceeds to step 45_10 to store "1" in END_FLG.

FIG. 46 shows a scan base routine program. This scan-based routine is a routine that realizes the lowest tone scanning method described above. Steps 46_1, 46_2, 46_3 are steps 43_1, 43_2, of the scan-up routine shown in FIG.
Since it is similar to 43_3, description thereof will be omitted. Step 46
In _4, the lowest tone LO (see FIG. 36) is stored in NT. The process of storing the lowest note in the LO will be described later.

At step 46_5, the velocity PLAYBUF [NT] of the lowest note LO is stored in VL. Further, in step 46_6, END_FLG
"1" is stored in. This is because there is only one lowest note. FIG. 47 is a program of the scan code without base routine. This routine is a routine that realizes the above-described lowest chord scanning system.

Steps 47_1, 47_2, 47_3
Is step 4 of the scan-up routine shown in FIG.
It is similar to 3_1, 43_2, 43_3, and description thereof will be omitted. In step 47_4, it is determined whether the PLAYBUF [] has only one note-on number or a plurality of note-on numbers. Although it is not established, here, the note number of the only note-on 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. The data is stored (step 47_6), and '1' is stored in END_FLG (step 47_7).

When 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 within 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. Therefore, here, PLAYBUF []
Are sequentially scanned from the lowest pitch to the highest pitch. Scanning procedure here (steps 47_8-4)
7_15) 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, CUR_
The only difference is that it is determined whether NOTE is the minimum amount LO and that note-on is ignored when the note is the lowest note. Detailed description is omitted. The process of storing the lowest tone in LO will be described later.

In the above, the scan-up routine (step 42_4), the scan order routine (step 42_8), and the scan code routine (step 4) which are executed in the scan note-on routine shown in FIG.
2_9), scan base routine (42_10), scan code without base routine (step 4
2_13). 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 within base routine (step 42_12), scan random within base routine (Step 42_13), Scan Up Without Top Routine (42_14)
Is a routine that realizes the descending scan method, the ascending / descending scan method, the random scan method, the highest sound scan method, the lowest sound removal ascending scan method, the lowest sound removal random scan method, and the highest sound removal ascending scan method, respectively. However, the various routines described above (see FIG.
To FIG. 47), the illustration and description thereof will be omitted here.

FIG. 48 shows a program of the note-off reservation routine. This note-off reservation routine is shown in FIG.
The 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, step time, and groove rate read from the rhythm pattern table are searched. Setting operator 153
(See FIG. 2) The groove rate P set by the operation
The duration is calculated according to RM_GROOVE, the note-off timing is obtained based on the duration, and the note-off timing is OFFR.
A note-off reservation is made by setting an empty area of SV [].

That is, first, i is set to "0" in step 48_1 and turned off in step 48_2.
RSV [i]. It is determined whether note = −1, that is, whether OFFRSV [i] is empty. OFFRSV [i]. When notote = −1, that is, when OFFRSV [i] is not empty, i is incremented (step 48_3), i
Has exceeded the size of the array of OFFRSV [] (step 48_4). If it is within that array, the process returns to step 48_2 and the OFFRSV [i]. It is determined whether note = -1. Repeating this, when i = 16 is reached without finding a vacant area, the process proceeds to step 48_5 to store "-1" indicating that OFFRSV [] is full in NT and terminates.

OFFRSV in step 48_2
[I]. note = −1, that is, when a free area is found, the free area OFFRSV [i]. note
41, step 41_1 of the clock processing routine of FIG.
The note number NT obtained at 0 is stored (step 48_6). Then, the rhythm pattern number PRM_RH
According to YTHM (see FIG. 20) (step 48_)
7), the rhythm pattern table RHY_XXX_TB corresponding to the rhythm pattern number PRM_RHYTHM
Duration RHY_XXX_ stored in the step of the current step number CUR_RHY (see FIG. 30) of L [] (see FIG. 3 and each example of FIGS. 4 to 9).
TBL [CUR_RHY]. duration and step time RHY_XXX_TBL [CUR_RH
Y]. stepTime is read and D
1 and D2 (step 48_8).

At step 48_9, the duration D
1, step time D2, and groove rate PRM
Based on _GROVE (see FIG. 22), the duration DURATION of the note number is DURATION = (D1-D2) × PRM_GROO
It is obtained by calculating VE / 100 + D2.

The result of this calculation is PRM_GROOVE =
When 0, DURATION = D2, that is, the same value as the step time, giving a tenute-like effect to the arpeggio performance, and when PRM_GROOVE = 100, DURATION = D1, that is, stored in the rhythm pattern table RHY_XXX_TBL []. It remains the duration. If a short duration like staccato is stored in this rhythm pattern table RHY_XXX_TBL [], from the arpeggio performance like staccato to the arpeggio performance like tenuto by the operation of the glue blade setting operator 153 shown in FIG. , The duration of each sound can be changed continuously. DURATI obtained in this way
ON is added to CLOCK (see FIG. 32), and OF
FRSV [i]. Stored in clock (step 4)
8_10).

FIG. 49 is a flow chart of the velocity generation routine, and FIG. 50 is an explanatory diagram of velocities generated in the velocity generation routine shown in FIG. Figure 4
The velocity generation routine shown in FIG. 9 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 (FIGS. 3 and 4 to 9) corresponding to the rhythm pattern number PRM_RHYTHM. Velocity coefficient RHY_XXX_TBL [CUR of current step CUR_RHY (see FIG. 38))
_RHY]. veloCoef is read and COEF
(Step 49_2). Then, in step 49_3, the calculation of VL2 = VL × COEF / 127 is performed between the velocity coefficient COEF and the velocity VL generated by the key depression, and in step 49_4, VL− (VL-VL2) × PRM_GROOVE / 10
The calculation of 0 is performed, and the velocity obtained as a result of the calculation is stored again in VL.

Here, as shown in FIG. 50, the groove rate PRM_GROOVE set by the operation of the groove rate setting operator 153 shown in FIG. 2 is PRM_
When GROOVE = 0, rhythm pattern table RHY
Regardless of the velocity stored in _XXX_TBL [], the key depression velocity is adopted as it is, and PRM_G
When ROOVE = 100, (key depression velocity × velocity coefficient) is adopted, and when the glue blade setting operator 153 is set in the middle, key depression velocity and (key depression velocity × velocity) are set according to the position. coefficient)
A velocity that continuously changes between is adopted.

By changing the groove rate in this way, it is possible to change the degree of so-called "stickiness". Step 41_1 of the clock processing routine of FIG.
In 4, the velocity is obtained as described above, and in step 41_15, the note-on data with the velocity data thus obtained is transmitted.

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_RH
YTHM (see FIG. 20) is referred to, and the step time RHY_XXX_T stored in the step of 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 therein.
BL [CUR_RHY]. The stepTime is read and stored in STEP (step 51_2), and the CLO
The step is added to CK (see FIG. 32) and NEX
It is stored in TCLK (see FIG. 33) (step 51_).
3). As a result, the next sound generation timing is NEXTCL.
Set to K.

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, the value of "1" is stored in END_FLG at the end of the previous note-on data scan, and "0" is stored in END_FLG (step 52_1). The current step CUR_RHY (see FIG. 30) of the table is updated (steps 52_2 to 52_6). Specifically, in step 52_2, CUR_RHY is incremented, and then the rhythm pattern number PRM_RHYTH
M (see FIG. 20) is referred to and its rhythm pattern number P
The number of steps RHY_XXX_SIZE of the rhythm pattern table corresponding to RM_RHYTHM is read and S
Stored in IZE (step 52_4), CUR_RH
Whether Y ≦ SIZE, that is, CUR_RHY
Is incremented (step 52_2), and as a result, the rhythm pattern table RHY_XXX_T currently in use
It is determined whether or not the number of steps of BL [] has been exceeded. If the number of steps has not been exceeded, the process directly proceeds to step 52_7. , And proceeds to step 52_7.

In steps 52_7 to 52_11, the current step CUR_SMOD of the scan mode table is selected.
E (see FIG. 31) is updated. That is, first, CUR_SMODE is incremented in step 52_7, then the scan mode number PRM_SMODE (see FIG. 21) is referred to (step 52_8), and the step number SMODE_XXX_SIZ of the scan mode table corresponding to the scan mode number PRM_MODE.
E is read and stored in SIZE (step 52_
9) If CUR_SMODE ≧ SIZE (step 52_10), CUR_SMODE is returned to the beginning (step 0) (step 52_11).

Next, in step 53_1 shown in FIG. 53, the scan mode number PRM_SMODE (see FIG. 21) is referred to, and the scan mode number PRM_SM.
Scan mode table SMODE_ corresponding to ODE
Steps 52_7 to 5 of FIG. 52 of XXX_TBL []
Scan method (scan function number) SMODE of step CUR_SMODE updated in 2_11
_XXX_TBL [CUR_SMODE] is read and stored in func. Step 53_3, 53_
In 4, each of the func is a chord scanning method SCA.
It is determined whether or not it is N_C and whether or not it is the lowest tone chord scanning method SCAN_C_WO_B, and S
C for CA_C or SCAN_C_WO_B
'-1' is stored in UR_NOTE (see FIG. 25). In the case of SCAN_C or SCAN_C_WO_B, by storing “-1” in CUR_NOTE, the area of PLAYBUF [] is scanned from the lower pitch to the higher pitch when the note-on data is scanned (Fig. 45, see FIG. 47).

FIG. 54 is a flow chart 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. Step 54
In _1, it is determined whether the rhythm pattern has been changed. The rhythm pattern is changed by operating the rhythm pattern setting operator 151 shown in FIG. The rhythm pattern is changed by operating the rhythm pattern setting operator 151. Step 54_2
In PRM_RHYTHM (see FIG. 20), the new rhythm pattern number after change is stored, and the process proceeds to step 52_3 to execute the reset scanner routine (see FIG. 40) to reset the scanner.

In step 54_4, it is determined whether 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, in step 54_5, PRM_SMD
The new scan mode number after change is stored in E (see FIG. 21), and the scanner is reset in step 52_3.

In step 54_6, it is determined whether the groove rate has been changed. The groove rate is changed by operating the groove rate setting operator 153 shown in FIG. Groove rate setting operator 153
When the groove rate is changed by the operation of, the process proceeds to step 54_7 and PRM_GROVE (see FIG. 22)
The new value of the groove rate is stored in.

FIG. 55 is a flowchart of the note-on processing routine. This note-on processing is executed in step 38_7 of the general block program shown in FIG. 38 when the 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 NOTEBUF [N
T] (see FIG. 23) and PLAYBUF [NT] (see FIG. 24) (steps 55_2, 55_).
3). Next, it is determined whether or not ORDER_WR (see FIG. 28) is at the 16th end.
DER [ORDER_WR]. Note number NT is stored in note, and ORDER [ORDER_WR]. v
The velocity VL is stored in elo. Step 55_
At 7, it is determined whether or not all the note-on data input this time is the note-on data first received from the state where the key is released (note-off). That is, specifically, it is detected whether or not the valid velocity data stored in PLAYBUF [] is only one velocity stored this time in step 55_3. If it is the first note-on data, the process proceeds to step 55_8 to reset the scanner. Then PLA
YBUF [] is scanned, and the lowest tone LO and the highest tone HI are updated (steps 55_9, 55_10).

FIG. 56 is a flowchart of the note-off processing routine. This note-off processing routine is executed at 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 NOTEBUF [NT] (see FIG. 23).
In the reference), "-1" indicating that valid data is not stored is stored (step 56_2). In step 56_3, it is determined whether HOLD (see FIG. 26) is less than 64 (hold off), and hold on (6
(4 or more), the process ends. Hold off (6
(Less than 4), -1 is stored in PLAYBUF [NT] (see FIG. 24) (step 56_4), and the note-off data of this time is read from the key-depression order buffer ORDER [] (see FIG. 27). A delete order routine for deleting the note-on data is executed (step 56_).
5) Further, a pack order routine for moving the key depression order buffer ORDER [] deleted by the delete order routine to the left is executed (step 56_6).
In steps 56_7 and 56_8, PLAYBUF [] is searched to update the lowest note LO and the highest note HI.

FIG. 57 is a flowchart of the delete order routine. This delete order routine is step 56_5 of the note-off processing routine shown in FIG.
Run on. Here, ORDER [] (see FIG. 27)
Is searched for the existence of the note number NT of the note-off data (steps 57_1 to 57_5), and O
If RDER [i] = NT, then ORDER [i]. no
te and ORDER [i]. -1 is stored in both velo. When NT is stored in a plurality of ORDER [i] 's,'-1 'is stored for all of them.

FIG. 58 is a flow chart of the pack order routine. This pack order routine is shown in FIG.
This is executed in step 56_6 of the note-off processing routine shown in. Here, the key-depression order buffer ORDER [] is searched, and it is left-justified so as to eliminate the area where "-1" is stored. Specifically, in step 58_1, initial values “0” are stored in both i and j, and in step 58_2, ORDER [i]. to note'-
It is checked whether 1'is stored. ORDER
[I]. If valid data (i.e., other than "-1") is stored in "note", the process proceeds to step 58_3, where ORDER [i]. note, ORDER [i].
velo is respectively ORDER [j]. note,
ORDER [j]. posted to velo, step 58
In j, j is incremented. Since the current step CUR_ORDER (refer to FIG. 29) in the key-pressing order arpeggio performance needs to be changed in accordance with the justification of ORDER [], CUR_OR is performed in step 58_5.
Whether or not DER is i is checked, and when CUR_ORDER = i, j-1 is stored in CUR_ORDER (step 58_6). In step 58_7, i is incremented, and in step 58_8, i is incremented by ORDER_WR.
(See FIG. 28) It is determined whether or not the following, and i ≦ ORDER_
In the case of WR, the process returns to step 58_2 and the ORDER [i]. It is checked whether or not note is “−1”.

ORDER [] pointer ORDER_W
R (see FIG. 28) also needs to be changed in accordance with the justification of ORDER [], and in step 58_9, ORDER
J is stored in _WR. FIG. 59 is a flowchart of the hold-off processing routine. This hold-off processing routine is executed at step 38_13 of the general program shown in FIG. 38 when hold data is received. When this hold-off processing routine is executed, the HOL is determined by the determination in step 38_12 in FIG.
It is known that D is less than 64 (holdoff).

When the hold-off processing routine shown in FIG. 59 is executed, a NOTE reflecting the key press and key release as it is.
BUF [] (see FIG. 23) is a PLAYBU that stores key pressing information with hold information added over the entire area.
It is transcribed to F [] (see FIG. 24) (step 59_1).
~ 59_4). Next, the key depression order buffer ORDER []
A remake order routine for reconstructing (see FIG. 27) is executed (step 59_5). After the ORDER [] is reconstructed, in steps 59_6 and 59_7, P
LAYBUF [] is searched for the lowest note LO and the highest note H.
I is updated.

FIG. 60 is a flowchart of the remake order routine. This remake order routine is shown in Fig. 5.
Step 59_5 of the hold-off processing routine shown in FIG.
Run on. Here, in order to search PLAYBUF [] from the lowest pitch to the highest pitch, the initial value "0" is first stored in NT (step 60_1).

Then, PLAYBUF [NT] is read and stored in VL (step 60_2), and the VL is read.
Is "-1", that is, valid velocity data is stored in PLAYBUF [NT] (other than -1).
Whether or not (-1) is determined. When VL = −1, the process proceeds to step 60_4 and the delete order routine (FIG. 5).
7) is executed, and if the note-on data of the note number NT is stored in ORDER [] in this delete order routine, it is deleted (specifically, "-1" is stored). . NT is incremented in step 60_5, and NT is incremented in step 60_6.
It is determined whether it is less than 28, and when NT is less than 128, the process returns to step 60_2 and PLAYB for the new NT
UF [NT] is read.

In this way, the entire area of PLAYBUF [] is searched, and all note numbers NT corresponding to PLAYBUF [NT] storing VL = -1 are deleted from ORDER []. Then, step 60_
At 7, the pack order routine (see FIG. 29) is executed, and ORDER [] is justified so as to eliminate the area where "-1" of ORDER [] is stored. As a result, the ORDER [] is in a state in which the key depression information is arranged in the key depression order only for the key currently being depressed.

The arpeggiator according to the present embodiment is configured as described above, and has a rhythm pattern table (FIG. 3, FIG. 3, set by the rhythm pattern setting operator 151 and the scan mode setting operator 152 shown in FIG. 2). And each example of FIGS. 4 to 9) and the scan mode table (see each example of FIG. 10 and FIGS. 11 to 19), a plurality of keys are pressed simultaneously or sequentially. Various arpeggio performances that are musically significant can be performed by a simple operation of holding the keys or pressing the hold pedal to store the pressed keys. Further, the groove rate operator 151 shown in FIG.
By operating, you can easily change the degree of'Nori '.

Next, another embodiment of the arpeggiator of the present invention will be described. However, hereinafter, illustration and description of parts common to the above-described embodiment will be omitted, and only differences from the above-described embodiment will be illustrated and described. 61 is a diagram showing a velocity volume added to the panel of FIG. 2, and FIG. 62 is a velocity generation routine shown in FIG. 49 in a configuration in which the velocity volume shown in FIG. 61 is added to the panel shown in FIG. 6 is a flowchart of a velocity generation routine that is adopted instead of.

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 pinched and rotated by hand, fully rotated counterclockwise to '0', fully rotated clockwise to '127', depending on its position in the middle position. Value is output, and VELO in RAM 13 (see FIG. 1) is output.
It is stored in CITY_VOLUME. This VELOC
ITY_VOLUME is involved in the generation of velocity data in an arpeggio performance, as described in the flowchart of FIG.

In the velocity generation routine shown in FIG. 62, the rhythm pattern number PRM_RHYTHM is referred to (step 62_1) as in the velocity generation routine of FIG. 49, and the rhythm pattern number PRM_RHY is referenced.
Rhythm pattern table PHY_XX corresponding to THM
X_TBL (see FIG. 3 and each example of FIG. 4 to FIG. 9) at the current step CUR_RHY (see FIG. 38) velocity coefficient RHY_XXX_TBL [CUR_RHY]. v
eloCoef is read and stored in COEF (step 62_2).

Then, unlike the velocity generation routine shown in FIG. 49, it is determined whether VELOCITY_VOLUME = 0 (step 62_3). VELOCI
In the case of TY_VOLUME = 0, it is similar to the velocity generation routine of FIG. 49, 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. Calculation is performed, and in step 62_6, VL- (VL-VL2) * PRM_GROVE / 10
0 is calculated, and the velocity obtained as a result of the calculation is stored in VL again.

On the other hand, in step 62_3, VEL
If it is determined that OCITY_VOLUME is not "0", the process 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 the VEL set by the velocity volume 154 shown in FIG. 61 is used instead of the velocity generated by the key depression.
OCITY_VOLUME is adopted. in this way,
By using a fixed velocity instead of the key-pressing velocity, it is possible to achieve an arbeggio performance with a certain strength 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 is a view showing a style switch added to the panel of FIG. 2, and FIG. 64 is shown in FIG. 54 in a configuration where the style switch shown in FIG. 63 is added to the panel shown in FIG. It is a flow chart of an edit routine adopted instead of an edit routine. The style switch 155 shown in FIG. 63 has a plurality of (3 in this example) buttons 155a, 155b, 1 for each genre.
55c, each button 155a, 155b, 155
When c is pressed, a set of a rhythm pattern number and a scan mode number, which match the images of waltz, reggae and shamisen, respectively, is selected.

In the edit routine shown in FIG. 64, first, in step 64_1, the style switch 15
Button 155a, 155 of any one of 5 (see FIG. 63)
It is determined whether or not the style has been changed by pressing b or 155c. When it is recognized that the style has been changed (step 64_2), in the case of waltz, PRM_RHYTHM (see FIG. 20) and PRM_SMODE (see FIG. 21) are each set to '2' (see FIG. 6). , (6) (see FIG. 17) are stored, and in the case of reggae, PRM_RHYTHM, PRM
_SMODE is '5' (see FIG. 9) and '7' respectively
(See FIG. 18) is stored, and PRM_R in the case of shamisen
“1” (see FIG. 5) and “8” (see FIG. 19) are stored in HYTHM and PRM_SMODE, respectively. FIG. 64
Other steps 64_4 to 64_ of the edit routine of
10 is step 5 of the edit routine shown in FIG.
Since it is similar to 4_1 to 54_7, description thereof will be omitted.

As described above, in this embodiment, when the waltz button 154a is pressed, for example, the rhythm pattern and scan mode generally considered to be most suitable for waltz are simultaneously selected and set. Therefore, the performer can select his / her desired style with one touch without considering the combination of the rhythm pattern and the scan mode one by one.

Although the tone color used for the arpeggio performance is not particularly mentioned in the above embodiment, the tone color suitable for the performance of the style may be automatically selected corresponding to the selected style. . For example, if the waltz or reggae style is selected, select the tone of the instrument that is often used to play waltz or reggae songs, and if the shamisen style is selected, select the shamisen tone. You may do it. In each of the above embodiments, the hold information is the data input terminal 17
(Refer to FIG. 1), but the panel 15 may be provided with a switch for selectively inputting hold-on information and hold-off information, or the arpeggiator itself may be provided with a pedal for generating hold information, or its pedal connection. May be equipped with a jack. Further, in each of the above-described 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 integrally formed. You may allow it.

Further, in each of the above embodiments, only one groove rate setting operator 153 is provided, and the duration of each step of the arpeggio performance is adjusted by the groove rate PRM_GROOVE set by the one groove rate setting operator 153. Although both the velocity and the velocity are changed, it is not necessary to have a configuration capable of changing both of them, and even if only one of them can be changed, it is possible to make a meaningful change in music. Alternatively, in order to entrust the performer with more delicate adjustment, the one groove rate setting operator 153 may be configured to be operated by switching between duration change and velocity change. It is also possible to provide two operators whose roles are shared for changing the velocity.

Further, in each of the above-mentioned embodiments, each of the steps of the rhythm pattern table is recorded as a set of step time, duration, and velocity coefficient. However, only step time, only duration, or only velocity is recorded. It is also possible to have any one of the rhythm pattern tables of, and the other two use fixed values. Even if you have a table with only step times as the rhythm pattern table, you can play not only simple arpeggios that are equally divided in time, but also arpeggios with various rhythms, and you have a table with only the rhythm. Even if you do, the effects of staccato and tenuto can be added independently for each step of the arpeggio performance, so you can add a variety of rhythm nuances and articulations, and have a table with only velocity coefficients. Even in such a case, the strength of each step of the arpeggio performance can be added and the arpeggio performance of various accents can be realized, and each arpeggio performance having a musical meaning can be realized. Of course, the rhythm pattern table of any two of the above three may be held.

Regarding the rhythm pattern table, when the above-mentioned two-way or three-way rhythm pattern table is provided, the two-way or three-way rhythm pattern table is independently provided (for example, a table only for step time and only duration). And a velocity-only table), and they may be used in combination depending on the player's preference and playing style.

The types of data stored in the rhythm pattern table include step time, duration,
Data of a type other than the velocity coefficient may be stored. For example, if the tone color designation data is stored for each step, the tone color can be switched for each step, and a more advanced arpeggio performance can be performed. 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, the rhythm pattern table and the scan mode table are RO
Although it has been described that it is fixedly stored in the M14 (see FIG. 1), a rhythm pattern table or a scan mode table may be placed in the RAM 13 instead of the ROM 14 or together with the ROM 14. In this 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 performer operates the operator. By operating, you can define a new rhythm pattern table or scan mode table, and perform arpeggio performance more suited to your taste.

[0122]

As described above, according to the arpeggiator of the present invention, a musical tone corresponding to the same key can be included many times in one melody during key-pressing order arpeggio performance, and a complicated pressing is possible. A key-order arpeggio performance can be realized, and the arpeggio performance can be stopped at any timing.

[Brief description of 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 the number of steps thereof.

FIG. 8 is a diagram showing a rhythm pattern table for diminishing and the number of steps thereof.

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 the number of steps thereof.

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 scanning 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 scanning and its steps.

FIG. 16 is a diagram showing a scan mode table for a key-press 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 a groove rate parameter.

FIG. 23 is a diagram showing a note buffer.

FIG. 24 is a diagram showing a play buffer.

FIG. 25 is a diagram showing a current play note number buffer.

FIG. 26 is a diagram showing a hold buffer.

FIG. 27 is a diagram showing an order buffer.

FIG. 28 is a diagram showing an order write counter.

FIG. 29 is a diagram showing an order position counter.

FIG. 30 is a diagram showing a rhythm pattern table position counter.

FIG. 31 is a diagram showing a scan mode table position counter.

FIG. 32 is a diagram showing a clock counter.

FIG. 33 is a diagram showing a next clock buffer.

FIG. 34 is a diagram showing a note-off reservation buffer.

FIG. 35 is a diagram showing an end flag.

FIG. 36 is a diagram showing a base note buffer.

FIG. 37 is a diagram showing 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 scan code routine program.

FIG. 46 is a program of a scan base routine.

FIG. 47 is a program of a scan code without base routine.

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 velocities generated by the velocity generation routine shown in FIG. 49.

FIG. 51 is a flowchart of a next clock update routine.

FIG. 52 is the first half of the flowchart of the 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 processing routine.

FIG. 56 is a flowchart of a note-off processing 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 processing routine.

FIG. 60 is a flowchart of a remake order routine.

FIG. 61 is a view showing a velocity volume added to the panel of FIG. 2.

62 is a flowchart of a velocity generation routine adopted instead of the velocity generation routine shown in FIG. 49. FIG.

FIG. 63 is a view showing a style switch added to the panel of FIG. 2.

64 is a flow chart of an edit routine adopted instead of the edit routine shown in FIG. 54.

[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 keyboards 21 pedals 30 sound sources 151 Rhythm pattern setting control 152 Scan Mode Setting Operator 153 Groove rate setting control 154 Velocity Volume 155 style switch

─────────────────────────────────────────────────── ─── Continuation of the front page (56) References JP-A-6-51773 (JP, A) JP-A-57-8596 (JP, A) Actual development S56-145093 (JP, U) JP-B-61- 60439 (JP, B1) (58) Fields investigated (Int.Cl. ⁷ , DB name) G10H 1/00-7/12

Claims (2)

(57) [Claims] 1. A storage unit having a predetermined storage capacity, and a key-depression information storage control unit that stores key-depression information that specifies a depressed key of a plurality of keys in the key-depression order in the storage unit. Key-depression information erasing means for erasing the key-depression information of the key corresponding to the key-release information from the storage means based on the key-release information for identifying the released key of the plurality of keys. Upon receipt of hold-on information, the key-depression information erasing means prohibits erasing of the key-depression information from the storage means, and when predetermined hold-off information is received, the key-depression information erasing means causes the storage means to delete the key-depression information from the storage means. Of the key depression information is released, and the key depression information erasing means receives the key depression information excluding the key depression information of the key depressed at the time of receiving the hold-off information from the storage means. The key pressing information holding means for erasing and the storage means are sequentially Arpeggiator that 査, and is characterized in that a performance information generating means for generating performance information representing a tone based on the key depression information detected by the scanning. 2. When the hold-on information is received, the key-depression information storage control unit additionally stores key-depression information for specifying a key depressed in the storage unit having the predetermined storage capacity in the key-depression order. Continuing, the key press information excess storage prohibiting means for prohibiting storage of new key press information in the storage means in a state where key press information is stored in the entire area of the storage means of the predetermined storage capacity is provided. The arpeggiator according to claim 1, wherein: