JPS61138350A - Microprogram control device - Google Patents

Abstract

PURPOSE:To execute efficiently a processing by using a program base part recurrently and repeatedly from the setting of a command type to the 1st parameter up to a receiving character processing routine. CONSTITUTION:When the reception of one character has been completed by a serial bit transmitting/receiving circuit 3, a data ready interruption is generated in a CPU4. In the interruption processing routine of a microprogram for the data ready interruption, the 8-bit data for one character are read out in parallel from the circuit 3. The read-out data are stored in the address of a receiving character buffer pointed out by a writing point of the CPU4 and the writing pointer is updated so as to point out the succeeding address. Then, a receiving bit in a status word is set up to '1'. The interruption routine is driven every end of the bit reception of a new one character by the circuit 3 and respective character of the received command are successively stored in a receiving character buffer of the CPU4 as they are.

Description

DETAILED DESCRIPTION OF THE INVENTION [Industrial Field of Application] The present invention relates to a microprogram control device, particularly an information processing system, in which a plurality of different types of commands are received via a serial data interface, and which are controlled by a microprogram. The present invention relates to a microprogram control device that appropriately processes each received character constituting these commands depending on the type of the command and the reception order of the received character in the command.

[Conventional technology]

In general, in an information processing system, the central processing unit (hereinafter referred to as mask), which plays the main role in the system, uses a balanced pair of wires to control the many auxiliary devices (hereinafter referred to as slaves) in the system. As shown in Figure 13, a transmission line for bit-serial transmission is connected between the mask and the slave in a round-trip manner, and through this transmission line, commands from each module are transmitted from the mask to the slave, and commands from the slave to the mask are transmitted. In many cases, responses are broadcast.

On the slave side of such a system, each code (letter) constituting the transmitted command is received, and it is processed appropriately according to the order of the received characters in the command and the type of command, Microprogram processing is used to ensure that the transmitted commands can be correctly parsed.

Conventionally, when processing such microprograms, for each received character, it is necessary to determine from the beginning whether it is the first received character or the second received character. Each received character process is performed one after another in order to determine the rank of this received character in the command, and further distinguishes the type of this command for each received character, thereby performing processing on each received character. They are guided and controlled by routines.

[Problem that the invention seeks to solve]

However, according to such processing, the microprogram becomes structured as shown in the flowchart of FIG. Since the process starts with determining whether there is a received character, the later the received character is, the longer it takes to reach the received character processing routine for this received character, which slows down the processing speed. Furthermore, even if received characters have the same rank, the processing is different depending on the type of command, so a program part that performs type determination processing is necessarily required for each branch of the program where the received characters have different ranks. As more memory is occupied, processing speed also becomes slower.

Furthermore, if the number of characters in one command changes and becomes longer, there is a problem in that the microprogram in the judgment part that leads to the character processing routine must be retreated accordingly.

An object of the present invention is to provide a microprogram control device that eliminates the above-mentioned conventional drawbacks. In a microprogram-controlled serial data interface that receives command data in which the first character includes information @ specifying the command type, a first parameter holding information on the command type and a received character in the command a second parameter that holds information on the ranking of the first parameter, and a second parameter that stores the first parameter value and the second and a jump table that stores a jump command to a received character processing routine that processes the received character corresponding to the specified parameter value, and further includes a jump table that stores a jump command to a received character processing routine that processes the received character corresponding to the specified parameter value, and further specifies that the first parameter is not included in the existing command type. (initial value of)) If the second parameter takes the value of the information of the buffer address that stores the first received character, then the initial value of the jump table specified by the specific operation of both of them A jump command to a first parameter update processing routine for updating the value of the first parameter is stored in the address, and the desired value of the first parameter is set to the % redundancy before starting to receive each command. Set it to the initial value of the parameter of Peng 2 and set it to the value of the buffer address information to store the ``reception record @ 1st character received character t'', and when receiving the m1th character of each command, as described above. Using the initialized @1 parameter and the second parameter, a jump table access routine is executed to execute the jump command stored at the address of the jump table, which is added by 1 by calculating the l# foot of both. , This accesses the processing routine for the first parameter, and in this processing routine, the information on the command type included in the first character of the Mayuki reception is sent to the first parameter. Change the value to retain the information of this command type, and then use the above 5442 parameter and the updated first parameter to specify the penalty special addition operation of both by □. The jump table access J that executes the jump command stored at the address of the jump table
Ck-chin, thereby repeatedly accessing the received character processing routine that processes received characters of the command type, and changing the value of the second parameter for each access to the received character processing routine. Update.

,·· 〔Example〕 · Next, the present invention will be explained with reference to the drawings.

,・Figure 1 is a professional 1. diagram for explaining an embodiment of the present invention. It is an ivy diagram. ...This is the above p.
This figure shows details of one slave of the information processing system similar to that shown in FIG. 13, where receiver 1. Driver 2.
It includes a serial bit transmitting/receiving circuit 3, a CPU 4, a program memory 5, a control unit, and an output port.

The command transmitted bit-serially via the balanced pair transmission line 101 from the master and block is transmitted by the receiver 1 at the slave by taking the difference (gui differential) between the flat line and the #2 line. The data is received, and the bit serial transmitter/receiver circuit 3 collects the data into one character of 8 bits, , , and G, and supplies them to the CPU 4 .

In other words, when the reception of one character is completed in circuit 3,
A data ready interrupt is issued to the CPU 4. The CPU 4 controls the operation of this slave by reading out the microprogram stored in the program memory 5 consisting of the dM and executing it one after another. RAM for use as a work area
As shown in FIG.
A bladder outlet pointer 4C (second parameter, hereinafter referred to as POPPT) for A, and a command type word 4D (first parameter,
TYPE) and a status word 4E containing a series of flags in each bit field for controlling the flow of the program.

In this embodiment, the reception character buffer 4A is a buffer whose address starts from address 4.0 (displayed as a 2-digit hexadecimal number) and has a capacity equal to the longest command length. This is a buffer in which the received characters each having a 1-byte structure are sequentially stored in the address as they are received by the circuit 3.

Now, from circuit 3, when the aforementioned data ready interrupt is issued, the interrupt processing routine for this data ready interrupt of the aforementioned microprogram receives data for one character (8 bits) from circuit 3. This is stored in the address of the receive character buffer 4A pointed to by the write pointer 4B, the write pointer 4B is updated to point to the next address, and the receive bit in the status word 4E (hereinafter REC8W ) to 111. Thus, each time the bit reception for a new character is completed in circuit 3, this interrupt routine is activated.
The valley characters of the received command are then sequentially stored as they are in the four received character buffers.

On the other hand, the main routine of the microprogram, as shown in Figure 3, carries out a check loop that checks each bit of the status word 4E, and usually goes around this loop and checks any of the status words 4E. Watch for the bit to be set to 11@.

Now, as described above, when the received characters of the command begin to be stored in the received character buffer 4A, the receive bit (REC8W) of the status word 4E is set to 1, but when this is identified by the main routine, the main The routine branches to a processing routine FLEC for processing the received character and starts this processing routine Rc:C.

The feature of this embodiment lies in the structure of this processing routine REC for processing each received character.Below, in detailing this, we will first explain the data format of the command used in this embodiment. I will explain from.

The commands from the mask to the slave used in this embodiment consist of three types of commands, as shown in FIG.

Type 1 is 2 bytes long, 8g1 byte (first character) command code (CNT), second byte (second character) horizontal parity (LRC), system enable, system It is used as a broadcast type command that is transmitted simultaneously to all slaves in the system, such as disable.

Type 2 is 4 bytes long, and the first byte is a command code (CNT) like type 1, and the second byte is a 16-bit address (ADH) that specifies the number of the slave to which this command is directed. , the fourth byte is horizontal parity (LRC), similar to type 1. This command is used to specify a specific slave number in the system and transmit a command that can be distinguished only by the command code. used.

Type 3, like type 2, specifies a slave with a specific number and also transmits a command including data.
The first byte is the command code (CNT) like the previous two
, 2nd. The third byte is the same address as type 2 (AD
H), the 4th byte is the data length (DTL) that specifies the data length, the 5th byte and below are the data (D1 to Dm), and the last byte is the horizontal parity (LRC) like the previous two, and this command is used to convey commands, including control data, to a specific designated slave.

As mentioned above, the first byte (first character) of the command code (CNT) is commonly used for each type, but as shown in the figure, the top four of this command code
The command type of this command (one of the values 1, 2, or 3) is specified using the bit.

As described above, there are different types of commands, and it can be seen that different types generally require different processing even for received characters of the same rank (number) in the command.

This embodiment provides a means for efficiently doing this.

In this embodiment, the processing routine REC operates as follows.

When the last received command has been processed, POPP
T (continuation pointer 4C) and T, YPE (command type word 4D) are each initialized and POP
PT is initially set to point to 40 (2-digit hexadecimal number), which is the storage address of the first character in the receive character buffer 4A, and TYPE is set to OK so that its value does not map to any command type. has been done.

When entering this processing routine RFC, this TYPE and PO
A specific operation is executed using the value of PFT, and a jump table access routine is executed that jumps to the address in the jump table directly specified by the result of the operation.

This jump table access routine in this embodiment is as follows:
As shown in Figure 5, the value of POPPT is put into the achiemulator (Ace), rotated to the left by 2 bits, the value of TYPE is added to this, and the command of the jump-on achiemulator JMP (ACC) is executed. (POPFT itself, its contents remain unchanged) 0 This jump-on achiemulator JMP (ACC) command specifies a jump to the address specified by the contents of the achiemulator (ACC). , with POPPT and 'rypg initialized as described above, when the two-digit hexadecimal number 40 of the POPPT value is rotated to the left by two pits, the two-digit hexadecimal number 40 becomes the two-digit 16 as shown in Figure 6. The base number becomes 01, and when you add 00, which is the value of T Y P E, it becomes 01! 0. When JMP (ACC) is executed, a jump will be made to the address of the O1 location.

Now, from address 01 of program memory 5,
A jump table as shown in FIG. 7 is stored.

This jump table consists of POPPT and T as mentioned above.
As a result of the above-mentioned specific operation using the value of YPE, in order to make it possible to jump to the main processing routine using this ACCO value trap, This is a table that stores the jump command to the processing routine corresponding to 1 at the address specified by the ACC mentioned above, but at address 01 of this jump table, the jump command to the command type setting routine starting from address 〒, which will be described later, is stored in the table. The instructions are stored and vh.

Therefore, the processing routine REC then executes the OK? The command type setting routine will be executed starting from the address.

Now, in this command type setting routine, the processing shown in the flowchart of FIG. 8 is performed.
・That is, using the current POPPT value 40, read out the command code (CNT) of the first received character already stored in the address 40 of the 4 received character buffers, and select the command type from the top 4 bits. Take out the new value and use it to change the value of TYPE□ to V. i.e. 1.2.3 of the command type of the received command.
Depending on the value, the value of TYPE is updated to 1.2 or 3, respectively.

When this process is finished, the command type setting routine KtH
Return to the beginning of processing routines R and EC. Therefore, the jump table access routine described above will be executed again.

Now, in the jump table access routine, the process shown in the flowchart of FIG. , 01 is added to these values to obtain the above J
When the MP (ACC) command is executed, a jump is performed according to the jump command stored at address 02, 03, or 04 of the jump table (Figure 7), depending on the actual command type 1, 2, or 3, respectively. do.

Address 02 of the jump table stores a jump instruction to ■ in the received character processing routine that processes the first character of the type 1 command, and address 03 of the jump table stores the first character of the type 2 command. A jump instruction to the received character processing routine KtK that processes the type 3 command is stored at address 04 of the jump table. is stored, so by executing this jump table access routine, it is possible to jump to the correct first character received character processing routine and execute this processing routine regardless of the command type.

Now, to these incoming character processing routines...

At the end of K3, all d output pointer update routine K
Specifies a jump to P. As a result, when the first received character processing routine ends, the program executes this routine Kp as shown in the flowchart of FIG.
Jump to and spill pointer 4C, that is, POPPT
The value of POPPT is increased by 1, and POPPT is set to receive character buffer 4.
Update the address to point to 41, the second character of A.

When this brand new process is completed, the pointer update routine Kp
returns to the beginning of the processing routine yREC again.

Therefore, the jump table access routine described above is repeated again.

In this access routine, the process shown in the flowchart of FIG. 5 described above is repeated, but this time the value of POPPT is 41, so this value of POPPT and TY
The result of the above-mentioned specific calculation performed using the value of PE and K is shown in FIG.
,08. These addresses in the jump table (Figure 7) contain the incoming character processing routines that process the second character of each type! Since the jump hall commands for Kotodama and Nisango are stored in , by executing the same jump table access routine as before, the second character will be processed correctly according to each command type. You can jump to each incoming character processing routine.

In this way, when each of these received character processing routines is completed, the jump instruction to the above-mentioned start pointer update routine Kp is attached at the end of each of these routines, so the program goes back through routine KP and returns to POPP'.
Advance the value of r one character and return to the jump table access routine at the beginning of routine REC.

By refining the program loop as described above,
For any type of command, a received character processing routine that processes each rank of received characters can be executed correctly one after the other.

Furthermore, at the end of the received character processing routine for the last received character of each type, a jump instruction to jump to the end processing routine Kg is attached.This end processing routine is executed by inputting the value of TYPE and POPPT as shown in FIG. The values are set to 9, the above-mentioned initial value O, and 40, respectively, REC8W of status word 4E is reset, EXCSW is set, and the program returns to the main routine. As a result, the program Finish the processing routine REC,
Based on these processed received characters, it identifies the command addressed to itself and starts the next processing routine EXEC for executing the command addressed to itself.

FIG. 12 shows the overall structure of the processing routine REC described above as a flowchart.

Note that in FIGS. 11 and 12, Ki3. , , and K 3 m, but they may be unified as a routine for processing horizontal parity LRC.

As is clear from the above description, according to this embodiment, the parameter TYPE indicating the command type and the parameter PO1'PT indicating the IIIK position of the received character
and a jump table, and set the TYPE value and POP
A jump instruction to the received character processing routine that processes the received character corresponding to the jump table address determined by a specific operation using the PT value is stored, and a specific initial value not included in the command type is stored. TYP
E and set the storage address of the first received character of the receive buffer 4A in POPPT as its initial value, the address of the jump table determined by the above-mentioned specific calculation using these TYPE and initial values of POPPT,
A command to jump to the command type is stored in the command type setting routine that rewrites TYPE 111 to the value of the command type of the actual received character.

These TYPE and P
The jump 7-pull access routine that performs the above-mentioned specific operation using the value of OPPT and jumps to the jump table according to the result of the operation is the core part of the processing routine REC, and this core part is used recursively and repeatedly. Configure it to do so. By configuring processing in this way), all accesses to the received character processing routines that process received characters of each type, including the command type setting routine KTtl, can be made using the same jump table access routine. It can be done in the same format.

In order to realize such a processing flow, in this embodiment, a jump instruction to a direct jump table access routine is attached at the end of the type setting routine KT mentioned above, and each received character processing At the end of the routine, there is a jump instruction to the start pointer update routine Kp that updates the value of POPPT by 1, and returns to the core part of the program via this routine Kpf. ing.

Furthermore, a jump instruction to Σ is attached to the end processing routine of the received character processing routine for the last character of the command), and in this routine Km, the TYPE
and the value of POPPT is set to the above-mentioned initial value, and the process returns to the main routine.

Note that a jump instruction to the error handling routine KER is stored at an address in the jump table that is not normally used, so that processing is performed when an error occurs.

The above shows one embodiment of the present invention, and the present invention is not limited to the above embodiment.

For example, in this embodiment, the number of command types is set to 3, and a flea-type command (%) is used, but this is just one example.

In addition, in the above description, the received character processing routines for each type and rank are all distinguished as different, but for example, the same processing routine is generally used for routine 2 snow and routine 3°. In this case, it is clear that it is sufficient to store a jump instruction to one processing routine at the corresponding address in the jump table.

Also, TYP used for jump table access routine.
A specific operation using the values of E and POPPT is also an example, and there is no need to be limited to this. It is also possible to use an operation such as *(POPPT)+(TYPE)+Q.

Further, the initial value of TYPE does not necessarily need to be 0 if the value is different from the existing type. However, when TYPE takes this initial value and POPPT takes a specific initial value, the address of the result of a specific operation must be included in the jump table, and the jump table is used as a link to the necessary processing routine. In order to make the jump instructions distinguishable from each other and to make the structure as compact as possible, care must be taken in selecting the above-mentioned specific operations and the initial value of TYPE.

Also, POP is used as a parameter to specify the order of received characters.
Although FT (indulging pointer 4C) is used, instead of this, a counter for counting the rank of characters may be provided separately and this basket may be used.

Furthermore, the receiver 1 that processes the last received character of each type
At the end of the 6-character processing routine, there is also a start pointer update routine just like the other received character processing routines! Add a command to jump to, and this will cause POPPT's 111
The jump table is accessed by advancing one character further, and the termination processing routine y Kl heno jump instruction is stored in the corresponding address of the jump table (the address corresponding to the next side of the last received character of each type). However, it is also possible to uniformly address the jump address routine KP at the end of all received character processing routines.

〔Effect of the invention〕

As described above, according to the present invention, a first parameter that holds information about the command type, a second parameter that holds information about the order of received characters in the command, and a jump table are provided. A jump to a received character processing routine that processes received characters of the type and rank corresponding to the values of each of these parameters at addresses in the jump table, each of which is specified by a specific operation between the parameter and the second parameter. Store the command, and use a specific initial value that is not included in the actual command type as the first parameter, and an initial value specifying the rlII position of the first received character for blurring as the second parameter. A jump command to a command type setting routine that rewrites the value of the first parameter to the command type of the actual received character is stored at the address of the jump table specified by the above-described specific operation. Then, as the actual processing flow, we provide a core part of the program that performs the above-mentioned rough calculations on these first and second parameters, and jumps to the jump table according to the results of the calculations. As a flow, this core part of the program is accessed recursively from setting the command type for the first parameter according to the first received character to all the received character processing routines that process each received character. By configuring this, very efficient processing can be executed.

This allows all received characters to be processed in the same amount of time, and of course, if received characters of the same rank are of different types, a different character processing routine will be jumped to perform different processing. Microprogram control has a concise and flexible microprogram structure, and even if the number of characters in a command changes, it can be easily handled by simply adding the contents of the jump table. equipment can be provided.

[Brief explanation of the drawing]

FIG. 1 is a block diagram for explaining one embodiment of the present invention, FIG. 2 is a diagram for explaining the structure of the work area in the CPU 4 of this embodiment, and FIG. 3 is a block diagram for explaining an embodiment of the present invention. Flowchart for explaining the main routine of the program. Figure 4 is a diagram for explaining various command types and their configurations used in this embodiment. Figure 5 is for explaining the jump table access routine used in this embodiment. FIG. 6 is a flowchart for explaining the results of specific calculations used in this embodiment, FIG. 7 is a diagram for explaining the jump table used in this embodiment, and FIG. 8 is a diagram for explaining the jump table used in this embodiment. FIG. 9 is a flowchart for explaining the command type setting routine used in this embodiment, and FIG. 9 is a flowchart for explaining the bladder ejection pointer update routine Kp.
FIG. 10 is a diagram for explaining the results of specific calculations used in this embodiment, FIG. 11 is a flowchart for explaining the termination processing routine Kg used in this embodiment, and FIG.
Figure 13 is a flowchart for explaining the overall configuration of the processing routine RBC used in this embodiment, Figure 13 is a diagram showing the configuration of an information processing system that transmits commands bit serially, and Figure 14 is a conventional process. 2 is a flowchart for explaining the configuration of a microprogram that performs. In the figure, 1...Receiver, 2...
Driver, 3... Serial bit transmitting/receiving circuit,
4...CPU. 5...Program memory, 6...Control output port, 4A...Reception character buffer,
4B: Pledge pointer, 4C: Read pointer (POPPT), 4D: Command type word (TYPE), 4B: Status word. No. 1 Lead $ 2 圀 $ 5 Hollow Juka 2 Flash Sea〉 Budeburu No. 3 7 Zume 3 Diagram

Claims (1)

[Scope of Claims] A microprogram-controlled serial data interface that receives command data in which the number of characters differs depending on the command type and includes information specifying the command type in the first character of the command, comprising: information on the command type; a first parameter that holds information about the rank of the received character in the command; and a second parameter that holds information about the rank of the received character in the command; a current jump table for storing a jump command to a received character processing routine for processing a received character corresponding to the specification of the first parameter value and the second parameter value at the address specified by the first parameter value and the second parameter value; If the first parameter takes a specific initial value that is not included in the existing command type, and the second parameter takes the value of information on the buffer address that stores the first received character, A jump command to a first parameter update processing routine for updating the value of the first parameter is stored at an address in the jump table specified by the calculation of The value of the first parameter is set to the specific initial value, the value of the second parameter is set to the value of the information of the buffer address that stores the received character of the first character, and the first character of each command is a jump table access routine that executes a jump command stored at an address in the jump table specified by the specific calculation of both parameters using the first parameter and the second parameter that are initialized as described above upon reception of the jump table; , thereby accessing the first parameter update processing routine, and in this processing routine, using the command type information included in the first received character, the value of the first parameter is changed to the command type information. Then, using the second parameter and the updated first parameter, execute the jump command stored at the address of the jump table specified by the specific calculation of both. recursing to the jump table access routine to process the received character of the command type, thereby repeatedly accessing the received character processing routine that processes the received character of the command type, and updating the value of the second parameter each time the received character processing routine is accessed. A microprogram control device characterized by: