JPH0546584B2 - - Google Patents

Description

[Detailed Description of the Invention] [Industrial Application Field] The present invention provides a command control device, particularly an information processing system, in which a plurality of different types of commands are received via a serial data interface, by controlling a microprogram. The present invention relates to a command control device that appropriately processes each received character constituting these commands according to the type of the command and the reception order of the received character in the command.

[Conventional technology]

Generally, in an information processing system, the central processing unit (hereinafter referred to as master) plays the main role in the system.
However, in order to control the many auxiliary devices (hereinafter referred to as slaves) in the system, a transmission line for bit-serial transmission using balanced two wires (balanced pair) is established between the master and slave as shown in Figure 13. In many cases, these devices are connected in a round-trip manner, and various commands are transmitted from the master to the slave, and responses are transmitted from the slave to the master via such a transmission path.

On the slave side of such a system, each code (character) 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 a microprogram, the first
The order of this received character in the command is determined by sequentially determining whether it is the second received character or not, and then determining the order of this received character in the command. The type of this command is distinguished, and control is thereby directed to each received character processing routine for processing each received character.

[Problem that the invention seeks to solve]

However, according to such processing, the microprogram becomes configured as shown in the flowchart of FIG. Since the process starts with determining whether the received character 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 order, 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 orders. As more memory is occupied, processing speed also becomes slower.

Furthermore, if the number of characters in one command changes and it becomes longer, there is a problem in that it is necessary to add an additional microprogram for the judgment part to lead to the character processing routine.

It is an object of the present invention to provide a command control device which eliminates the above-mentioned conventional drawbacks.

[Means for solving problems]

The command control device of the present invention includes command data receiving means for receiving the command data from the transmission path, and transmitting a bit string supplied from the command data receiving means as one received character for each predetermined number of bits. a serial bit transmitting/receiving means; a received character buffer for sequentially storing the received characters sequentially transmitted from the serial bit transmitting/receiving means from a predetermined address; storage means each having an area for storing information indicating a storage location of a program routine according to the position of a character;
a first process that determines the type of the command data by checking the first character; and a first process that determines the type of the command data by checking the first character; and a second process of obtaining information indicating a storage location of the corresponding program routine from the storage means based on the determined command type and the position of each received character, and executing the program routine specified by the information; and processing means for performing the processing.

〔Example〕

Next, the present invention will be explained with reference to the drawings.

FIG. 1 is a block diagram for explaining one embodiment of the present invention.

This shows the details of one slave of the information processing system similar to that shown in FIG.
It includes a CPU 4, a program memory 5, and a control input/output port 6.

A command transmitted bit-serially from the master via the balanced pair transmission line 101 is received by the receiver 1 in the slave by taking the difference between the two balanced lines, and then sent to the serial bit receiving circuit. 3, the data is collected into one character of 8 bits each and supplied to the CPU 4.

That is, when the reception of one character is completed in the circuit 3, a data ready interrupt is issued to the CPU 4.

The CPU 4 reads the microprogram stored in the program memory 5 composed of ROM,
By executing this one after another, the operation of this slave is controlled, and it contains a RAM to be used as a work area.

In this work area, as shown in Figure 2,
A received character buffer 4A, a write pointer 4B for this received character buffer 4A, a read pointer 4C (second parameter, hereinafter referred to as POPPT) which is also a means for holding a character position within a command for this received character buffer 4A, and information regarding the command type. Command type word 4D (first parameter,
TYPE) and a status word 4E containing in each bit field various flags controlling the flow of the program.

In this embodiment, the reception character buffer 4A is a buffer whose address starts at address 40 (displayed in 2-digit hexadecimal) and has a capacity equal to the longest command length, and one address per address starts from address 40.
This is a buffer in which each received character in a byte structure is stored in order as it is received by the circuit 3.

Now, when the aforementioned data ready interrupt is issued from circuit 3, the interrupt processing routine for this data ready interrupt of the aforementioned microprogram is to output data for one character (8 bits) from circuit 3 in parallel. This is read out and stored in the address of the received character buffer 4A pointed to by the write pointer 4B, the write pointer 4B is updated to point to the next address, and the status word 4E is read out.
Set the receive bit (hereinafter RECSW) in “1”
Set to . Thus, each time the reception of bits for a new character is completed in circuit 3, this interrupt routine is activated, and each character of the received command is then directly transferred to this received character buffer 4.
They are stored in order in A.

On the other hand, the main routine of the microprogram is as shown in FIG.
It has a check loop for checking each bit of the status word 4E, and normally it uses this loop to monitor whether any bit of the status word 4E is set to "1".

Now, as mentioned above, when the received characters of the command begin to be stored in the received character buffer 4A,
When the receive bit (RECSW) of status word 4E is set to 1, which is identified by the main routine, the main routine executes a processing routine to process the received character.
Branches to REC and starts this processing routine REC.

The feature of this embodiment lies in the configuration of this processing routine REC for processing each received character.
In explaining this in detail below, the data format of the command used in this embodiment will first be explained.

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

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

Type 2 is 4 bytes long, and 1 byte is the command code (CNT), 2nd and 3rd bits, like type 1.
The byte consists of a 16-bit address (ADR) that specifies the number of the slave to which this command is directed, and the fourth byte consists of the horizontal parity (LRC), similar to type 1. It is used to convey commands that can be specified and distinguished only by the command code.

Type 3, like Type 2, specifies a slave with a specific number and also transmits a command including data, and the first byte contains the command code (CNT), second and third The byte is the address (ADR) similar to type 2, the 4th byte is the data length (DTL) that specifies the data length, the 5th byte and below are data (D ₁ to Dm), and the last byte is horizontal like the first two. Consisting of Parity (LRC),
This command is used to convey commands containing control data to a specified specific slave.

As mentioned above, the first byte (first character) common to each type is used for command data (CNT), but as shown in the figure, the upper 4 bits of this command code are used to , the command type of this command (that is, a value of 1, 2, or 3) is specified.

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.

Now, in this embodiment, the processing routine
REC operates as follows.

After the previously received command has been processed,
POPPT (read pointer 4C) and TYPE (command type word 4D) are each initialized, and POPPT is initialized to point to 40 (2-digit hexadecimal number), which is the storage address of the first character of received character buffer 4A. and TYPE is initialized to 0, whose value does not belong to any command type.

When this processing routine REC is entered, this TYPE
Perform a specific operation using the values of and POPPT,
A jump table access routine that is a jump table access processing means that jumps to an address in a jump table that is a jump table storage means that specifies the value of the calculation result is executed.

As shown in FIG. 5, this jump table access routine of this embodiment takes the value of POPPT into the accumulator (ACC), rotates it to the left by 2 bits, adds the value of TYPE to it, and jumps on. Accumulator JMP (ACC)
(The contents of POPPT itself remain unchanged).

This jump-on accumulator JMP (ACC)
This instruction specifies a jump to the address specified by the contents of the accumulator (ACC), but when POPPT and TYPE are initialized as described above, the two-digit value of POPPT is Rotating the hexadecimal number 40 to the left by 2 bits results in a two-digit hexadecimal number 01 as shown in Figure 6.
Adding the TYPE value of 00 will result in 01, and JMP
Executing (ACC) will jump to address 01.

Starting from address 01 of the program memory 5, a jump table as shown in FIG. 7 is stored.

This jump table, as mentioned above,
Take the result of the above-mentioned specific operation using the values of POPPT and TYPE on the accumulator (ACC),
In order to be able to jump to the required processing routine depending on the value of this ACC, a jump instruction to the corresponding processing routine can be executed as described above.
This table is stored at the address specified by ACC, and at address 01 of this jump table, a jump instruction to a command type setting routine, which is a command type setting processing means, starting from address _KT , which will be described later, is stored.

Therefore, the processing routine REC will next execute the command type setting routine starting from this K _T address via the jump table.

Now, this command type setting routine K _T is
Processing as shown in the flowchart of FIG. 8 is performed.

In other words, using the current POPPT value 40, the command code (CNT) of the first received character already stored at address 40 of the received character buffer 4A is
Read out the command type value from the upper 4 bits, and use this to rewrite the TYPE value. That is, depending on the command type 1, 2, or 3 of the received command, the value of TYPE is updated to 1, 2, or 3, respectively.

When this processing is completed, the command type setting routine K _T returns to the beginning of the processing routine REC. 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.
Since they each take a value of 1, 2, or 3, when 01 is added to these values and the above JMP (ACC) command is executed, the jump table will be changed depending on the actual command type of 1, 2, or 3, respectively. It jumps according to the jump command stored at address 02, 03 or 04 (FIG. 7).

Address 02 of the jump table stores a jump instruction to the received character processing routine _K11 , which is one of the received character processing means that processes the first character of a type 1 command, and address 03 of the jump table stores A jump instruction to the received character processing routine K ₂₁ that processes the first character of a type 2 command is stored, and the address of the jump table is stored.
04 stores a jump instruction to the received character processing routine _K31 that processes the first character of a type 3 command, so by executing this jump table access routine, the correct command will be processed regardless of the command type. It is possible to jump to a received character processing routine for the first character and execute this processing routine.

Now, these received character processing routines K ₁₁ , K ₂₁ ,
The end of _K31 specifies a jump to the all read pointer update routine K _P. As a result,
When the first character received character processing routine is completed, the program jumps to this routine K _P as shown in the flowchart of FIG. The second character address of the received character buffer 4A is updated to point to 41.

When this update process is completed, the read pointer update routine K _P returns to the beginning of the process routine REC.
Therefore, the jump table access routine described above is repeated again.

In this access routine, the process shown in the flowchart in Figure 5 described above is repeated, but this time the value of POPPT is 41, so POPPT
As shown in Figure 10, the value of the accumulator ACC is the value of the command type 1, 2, 2, etc.
3 take values of 06, 07, and 08, respectively. These addresses in the jump table (Figure 7) store jump instructions to the incoming character processing routines K ₁₂ , K ₂₂ and K ₃₂ that process the second character of each type, so the jump instructions are exactly the same as before. By executing the same jump table access routine, it is possible to jump to each received character processing routine that correctly processes the second character according to each command type.

In this way, when each of these received character processing routines is completed, the jump instruction to the above-mentioned read pointer update routine K _P is attached at the end of each of these routines, so the program passes through routine K _P again to POPPT. advances the value by one character and returns to the jump table access routine at the beginning of routine REC.

By repeating the program loop as described above, it is possible to correctly execute a received character processing routine for processing received characters of each rank for any type of command one after another.

Note that at the end of the received character processing routine for the last received character of each type, an end processing routine K _E
A jump instruction to jump is attached to the jump command, and this termination processing routine is as shown in Figure 11.
Set the TYPE and POPPT values to the initial values 0 and 40 described above, reset RECSW in status word 4E, and set EXCSW.
is set and returns to the main routine.

As a result, the program ends the processing routine REC, identifies the command addressed to itself by these processed received characters, and starts the next processing routine EXC, which executes the command addressed to itself.

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

In addition, in FIG. 11 and FIG. 12, the processing routines for processing the last received character are distinguished as K ₁₃ , K ₂₄ and K _3n , respectively.
These can also be unified as a routine for processing horizontal parity LRC.

As is clear from the above explanation, according to this embodiment, the parameter indicating the command type is
TYPE, a parameter POPPT that indicates the order of received characters, and a jump table are provided.
Stores 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 TYPE value and POPPT value, and When TYPE is set to a specific initial value and the storage address of the first received character of reception buffer 4A is set as the initial value to POPPT, the above-mentioned specific operation using these TYPE and POPPT initial values A jump instruction to the command type setting routine K _T that rewrites the value of TYPE to the value of the command type of the actual received character is stored at the address of the determined jump table.

The flow of the actual program is then
The core part of the processing routine REC is a jump table access routine that performs the above-mentioned specific calculation using the values of TYPE and POPPT and jumps to the jump table according to the calculation result.
This core part is configured to be used recursively and repeatedly. By adopting this processing configuration, all accesses to the received character processing routines that process received characters of each type and rank, including the command type setting routine K _T , can be accessed in the same way through the same jump table access routine. It is possible to do so in a 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 above-mentioned type setting routine _KT , and each received character processing At the end of the routine, POPPT
A jump instruction is attached to a read pointer update routine K _P that updates the value of by 1, and the program returns to the above-mentioned main part of the program via this routine K _P.

Furthermore, a jump instruction to the end processing routine K _E is attached at the end of the received character processing routine for the final character of the command, and this routine K _E
, the TYPE and POPPT values are set to the aforementioned initial values and the process returns to the main routine.

Note that a jump instruction to the error handling routine _KER is stored at an address that is normally not used in the jump table, 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 three, and a specific configuration is used for each type of command, but this is merely an example.

In addition, in the above explanation, the received character processing routines of each type and rank are all distinguished as different, but for example, routine K ₂₂ and routine K ₃₂ .
Generally, the same processing routine is used. In this case, it is clear that it is sufficient to store a jump instruction to the same processing routine at the corresponding address in the jump table.

Further, the specific calculations based on the values of TYPE and POPPT used in the jump table access routine are shown as an example, and there is no need to be limited thereto. For example, appropriate constants P, Q (including minus)
using.

(ACC)=P*(POPPT)+(TYPE)+Q You can also use calculations like:

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

In addition, POPPT (read pointer 4C) was used as a parameter to specify the order of received characters, but
Instead, a counter for counting the rank of characters may be separately provided and this value may be used.

Furthermore, at the end of the received character processing routine that processes the last received character of each type, an instruction to jump to the read pointer update routine K _P is attached as in other received character processing routines, and this causes POPPT to Advance the value by one character, access the jump table, and store a jump instruction to the termination processing routine K _E at the corresponding address in the jump table (the address corresponding to the next rank of the last received character of each type). According to
It is also possible to unify the jump address given at the end of all received character processing routines to routine _KP .

〔Effect of the invention〕

As described above, according to the present invention, a first parameter that holds information on the command type, a second parameter that holds information regarding the order of received characters in the command, and a jump table are provided, and the first A jump command to a received character processing routine that processes a received character of a type and rank corresponding to the values of each of these parameters at an address in the jump table that is separately specified by a specific operation of the parameter and the second parameter. , and further uses a specific initial value that is not included in the actual command type as the first parameter, and a specific initial value that specifies the order of the first received character 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 specific calculation. Then, as the actual processing flow, a core part of the program is provided that uses the first parameter and the second parameter to perform the above-mentioned specific calculation, and jumps to the jump table according to the calculation result. The flow of the program is from setting the command type for the first parameter with the first received character to all the received character processing routines that process each received character by recursively using and accessing this core part of the program. With this configuration, very efficient processing can be performed.

This allows all received characters to have the same processing time, and of course, if the received characters have the same rank but are of different types, they can jump to different character processing routines and perform different processing. In addition, even if the number of characters in a command changes, this can be easily handled by simply adding the contents of the jump table.The command control device has a simple and flexible microprogram structure. 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 configuration of the work area in the CPU 4 of this embodiment, and FIG. 3 is a micro block diagram of this embodiment. Figure 4 is a flowchart for explaining the main routine of the program, Figure 4 is a diagram for explaining the various command types and their configurations used in this embodiment, and Figure 5 is a diagram for explaining the jump table access routine used in this embodiment. Flowchart for explanation; FIG. 6 is a diagram 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; FIG. 8 is a diagram for explaining the jump table used in this embodiment. A flowchart for explaining the command type setting routine K _T used in this embodiment, FIG. 9 is a read pointer update routine
_KP is a flowchart, FIG. 10 is a diagram for explaining the results of specific calculations used in this embodiment, and FIG. 11 is a flowchart for explaining the termination processing routine K _E used in this embodiment. flowchart,
Figure 12 shows the processing routine REC used in this example.
A flowchart to explain the entire configuration of
Figure 13 is a diagram showing the configuration of an information processing system that transmits commands in bit serial format, and
FIG. 4 is a flowchart for explaining the configuration of a microprogram that performs conventional processing. In the figure, 1...Receiver, 2...Driver, 3...Serial bit transmitting/receiving circuit, 4...
CPU, 5...Program memory, 6...Control input/output port, 4A...Receiving character buffer, 4B
...Write pointer, 4C...Read pointer (POPPT), 4D...Command type word (TYPE), 4E...Status word.

Claims (1)

[Scope of Claims] 1. In a command control device that receives command data from a transmission line, the number of characters of which differs depending on the command type, and which includes information specifying the command type in the first character, and performs processing according to the command data. , command data receiving means for receiving the command data from the transmission path; serial bit transmitting/receiving means for transmitting the bit string supplied from the command data receiving means as one received character for every predetermined number of bits; a received character buffer that sequentially stores the received characters sequentially sent from the serial bit transmitting/receiving means from a predetermined address; and a received character buffer provided for each command type and processing according to the position of each character constituting the command data of each command type. storage means each having an area for storing information indicating a storage location of a program routine that performs the above; and determining the type of the command data by checking the first character of the command data stored in the received character buffer. and the command type determined in the first process and the position of each received character for the second and subsequent characters of the command data stored in the received character buffer. and processing means for performing a second process of obtaining information from the storage means indicating a storage location of the program routine that performs the corresponding process and executing the program routine specified by the information. Command control device.