JPH10312202A - Programmable controller - Google Patents

Abstract

(57) [Summary] [PROBLEMS] In a data exchange process performed between a programmable controller and an option unit, even though parameters are hardly changed, parameters and commands that do not change are interpreted and executed one by one. Because of this, waste occurred. SOLUTION: A data exchange command stored in a shared memory 3 is transmitted to a CP of a programmable controller 1 in advance.
By compiling the object code into an executable object code and storing the object code in the object code storage area 7 inside the programmable controller, it is not necessary to interpret data exchange commands one by one during operation of the programmable controller. Can be performed in a short time, and a large amount of data can be transferred at a higher speed.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a programmable controller (hereinafter referred to as a PLC) for performing processing through a shared memory.
) And processing for data exchange between optional units.

[0002]

2. Description of the Related Art Conventionally, when data is exchanged between a programmable controller and an option unit, a necessary data exchange command system is determined in advance, and data exchange is performed via a shared memory accessible from both sides. I was going.

FIG. 2 shows a conventional example. A command storage area 11 and an entry point storage area 12 are provided inside the shared memory, and the option unit stores a command 13 for data exchange as necessary in the command storage area 11.
And the head address of the command is stored in the entry point storage area 12.

Thereafter, the access right of the shared memory is passed to the programmable controller, and the program controller waits for the execution of the command.

FIG. 3 is a flowchart showing the flow of processing on the programmable controller side. First, an entry point read pointer is initialized (step S21). Next, the contents of the entry point storage area 2 are read (step S22), and a data exchange command starting from the address indicated by the contents is read from the command storage area (step S23).

Then, the command is interpreted one by one based on a predetermined format (step S24),
Data exchange is performed between the programmable controller and the option unit (step S25), and the execution result of the command is written to the command storage area (step S25).
26).

Subsequently, the end code of the command is checked (step S27). If there is no end code, the process proceeds to step S23, where the command is interpreted and executed. When the end code is found, the entry point read pointer is updated (step S2).
8) It is checked whether all predetermined entry point storage areas have been scanned (step S29). If there is an entry point that has not been scanned, the process proceeds to step S22. If all the scans have been completed, the processing for the option unit ends (step S30), and the access right is passed to the option unit. On the option unit side, the command execution result is confirmed, and if necessary, processing for the command is performed.

[0008] By repeatedly executing the above series of processing, data exchange between the programmable controller and the option unit is performed.

[0009]

The main data exchange performed between the programmable controller and the option unit includes a data link function for sharing data between a plurality of programmable controllers in order to operate in cooperation with each other, and a programmable controller. There is a remote I / O function for arranging the I / O device at a place away from the main body.

In the case of the data link function, parameters are set, and in the case of the remote I / O function, I / O registration is performed so that various parameters (transfer format, transfer source address, transfer destination address, transfer destination address, Transfer destination byte number) is determined.

Once the control device is brought into the operating state, the programmable controller interprets and executes the commands one by one even though the setting is not basically changed during the operation of the programmable controller. Go cyclically.

Therefore, if the processing of cyclically interpreting and executing parameters and commands that do not change as described above can be reduced, a large amount of data can be exchanged at a higher speed.

[0013]

A compiling means for converting a data exchange command into an object code executable by a CPU of the programmable controller is provided outside a loop of a periodic operation of the programmable controller.

A storage area for storing the object code generated by the compiling means is provided in the programmable controller, and means for executing the object code is provided in a loop of the cyclic operation of the programmable controller to realize data exchange. I do.

A flag area for storing a compile request is provided in the shared memory, and a means for reading and determining the compile request flag is provided in the processing for the option unit, thereby changing the data exchange command during operation. If necessary, recompile the data exchange command.

With such a configuration, the data exchange command stored in the shared memory is compiled into an object code executable by the CPU of the programmable controller in advance and stored in the object code storage area inside the programmable controller. This eliminates the need to interpret data exchange commands one by one during operation of the programmable controller, allows data exchange with the optional unit to be performed in a short time, and realizes a large amount of data transfer at a higher speed.

[0017]

Embodiments of the present invention will be described below in detail with reference to the drawings. FIG. 1 is a block diagram of one embodiment of the present invention. 1 is a programmable controller, 2 is an optional unit, 3 is a shared memory accessible from the programmable controller and the optional unit, and 4 is an access control circuit for managing access rights.

In the shared memory 3, an entry point storage area 5 for storing a pointer of a data exchange command,
Data exchange command storage area 6 for storing commands, flag area 8 for storing compile requests from option units, data storage area 10 used for data transfer, etc.
Is provided.

In the programmable controller, CP
An object code storage area 7 for storing object code compiled in a format executable by U; a data storage area 9 to be requested to be exchanged from an option unit
Is provided.

FIG. 4 is an operation flowchart of the process according to the present invention. This shows a cyclic operation cycle of the programmable controller. First, the processing when the programmable controller is stopped will be described.

A process (OS process) relating to the system of the programmable controller is executed (step S1), and the operation state of the programmable controller is checked (step S2).

Since the programmable controller is stopped, the user I / F processing (step S6) of the peripheral device connected to the programmable controller is executed. Then, the operation of returning to the OS processing (step S1) is repeatedly executed.

Next, the operation when the state of the programmable controller changes from stop to operation will be described. At first, OS operation is performed in the same manner as the stopped operation (Step S).
1) Check the operation state of the programmable controller (step S2).

Since the programmable controller has changed from stopped to running, it compiles a data exchange command (step S3). Further, I / O processing is executed (step S4), and data is exchanged with the option unit by executing the compiled object code in the option unit processing (step S5). Next, the user I / F processing of the peripheral device is executed (step S6), and the operation state of the programmable controller is checked (step S7). Here, since the programmable controller is operating, the sequence calculation process (step S8) is executed, and the process returns to the OS process (step S1).

When the programmable controller is in operation, the command compile process (step S3) is not performed in the determination in step S2, unlike the above-described transition from stop to operation.

FIG. 5 is a flowchart showing the flow of processing relating to the compilation processing of the data exchange command.
First, the command start address is obtained from the entry point storage area 5 in the shared memory, and the command read pointer is initialized (step S11).

Next, a data exchange command is read using the pointer (step S12). The contents of the read command are analyzed (step S13), and an object code executable by the CPU of the programmable controller is generated (step S14).

The generated object code is stored in the object code storage area 7 in the programmable controller.
(Step S15). The command read pointer is updated to the next command position (step S1).
6), it is confirmed whether or not an end command is stored. If there is a subsequent command, the process returns to the command reading (step S12). If the command ends, the compile process ends.

In this embodiment, an example of the data link function and the remote I / O function has been described. However, when the same processing is repeatedly performed periodically, the processing can be speeded up by using the same method. Become.

[0030]

According to the present invention, the data exchange command stored in the shared memory is compiled into object code executable by the CPU of the programmable controller in advance, and stored in the object code storage area inside the programmable controller. By doing so, higher-speed data transfer can be realized as compared with a conventional interpreter system which interprets and executes commands one by one.

Further, by storing the object code in the programmable controller, a circuit free from various constraints and accessible at a higher speed can be constructed, and as a result, the execution speed of the object code is improved. However, the data exchange itself can be performed at a high speed.

[Brief description of the drawings]

FIG. 1 is a block diagram according to an embodiment of the present invention.

FIG. 2 is a diagram showing the structure of a conventional shared memory.

FIG. 3 is a flowchart showing a flow of processing of a conventional programmable controller.

FIG. 4 is a flowchart showing a flow of processing of a programmable controller according to the present invention.

FIG. 5 is a flowchart illustrating the flow of a command compilation process according to the present invention.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Programmable controller 2 Option unit 3 Shared memory 4 Access control circuit 5 Entry point storage area 6 Data exchange command storage area 7 Object code storage area 8 Flag area 9 Data storage area 10 Data storage area

Claims (2)

[Claims] A shared memory that is mutually accessible between a programmable controller and an option unit; an access control unit that controls access to the shared memory; a command storage area that stores a data exchange command between the units; Compiling means for converting a command into an object code in advance; an object code storage area for storing the object code; and execution means for executing the object code. Data exchange processing is performed by the execution means in a loop of a driving operation. A programmable controller, characterized in that: 2. A flag area for storing a compile request, and means for reading and judging the compile request flag. When a request for changing a data conversion command is issued in a loop of an operation operation, the compile means re-executes the command. 2. The method according to claim 1, wherein compiling is performed.
The programmable controller as described.