JP2011113304A - Display/control simulation system, programmable display for the same, and simulator device - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To specify a problem part in a macroblock in a short period of time without requiring effort, and to improve debugging efficiency of the macroblock as a result. <P>SOLUTION: A user sets one or more optional rows of a macroblock composed of a program of a plurality of rows as break points by a function of a macro viewer 32 and the set contents are stored as break position information 35. A macro execution part 21b in a display 1 side is configured to execute the program of the optional macroblock one row-by-one row, and before executing for each row, notifies a simulator 31 of the row number of the row or the like (S12), and after receiving an execution permission reply (S23), executes the program of the one row (S14). When the row of the notified row number is a break point, the simulator 31 temporarily stops the execution permission reply (S22 in S21: YES). <P>COPYRIGHT: (C)2011,JPO&INPIT

Description

  The present invention relates to a system having a simulator device related to a programmable display.

  2. Description of the Related Art Conventionally, for example, a display / control system configuration in which an external device such as a PLC (programmable logic controller) main body and a programmable display is connected is known. In such a system, the programmable display generally reads and displays data from the memory of the external device, or gives an arbitrary command to the external device by writing data to the memory of the external device. Controls the display content of the own screen and switches screens.

  The processing of the programmable display is performed using screen data downloaded by a basic program stored in advance. The screen data includes various macro data (macro blocks). The macro data (macro block) is, for example, a program that is associated with each item (switch, meter, button, etc.) arranged on the screen and executes processing according to this item. Or it is not matched with an item, For example, it is a program etc. which are performed regularly.

  In the display / control system, a personal computer or the like having a drawing editor (referred to as a drawing editor device) may be connected to the programmable display. The screen data is arbitrarily created by the user on the drawing editor device and downloaded to the programmable display.

  The programmable display device has a macro function as a function of performing an original arithmetic processing by the macro data. With this macro function, in addition to the arithmetic processing, the operation of the programmable display and the memory operation of the external device can be performed at an arbitrary timing. This macro function can be easily changed (customized) by changing the screen data (macro data). In this way, the macro data tends to be frequently used when it is desired to make the programmable display perform a complicated operation because it can be easily customized.

  Here, the screen data (including various types of macro data) is created by the user as described above, and of course there is a possibility that some kind of mistake may occur. There may be cases. Therefore, it is desirable to confirm the operation related to the macro data (program) in particular after creating new screen data and downloading it to the programmable display device before actually starting the operation.

  For this reason, it has been conventionally proposed to check the operation of screen data using a simulator device. This simulator device simulates the function / operation of an external device such as the PLC. This simulator device is often installed in the drawing editor device as one of the functions of the drawing editor device, but is not limited to this example.

  In any case, the simulator device is connected to the programmable display at least when the operation is confirmed, and operates as a pseudo external device while communicating with the programmable display. In addition, simulation results are displayed.

That is, the conventional simulator device has the following functions, for example.
First, it has a function of simulating the function / operation of an external device. This function responds / rewrites the external device memory (hereinafter referred to as “pseudo memory”) that is built on the simulator device in response to a memory read / write request from a programmable display, for example. Simulates external equipment.

  Further, it has a function of displaying the contents of the pseudo memory in a list during simulation and reading / writing the pseudo memory address arbitrarily designated by the user on the GUI on the simulator apparatus. Further, it has a function of incrementing / decrementing the unit / range / time arbitrarily specified with respect to the pseudo memory address arbitrarily specified by the user.

Here, for example, Patent Document 1 and Patent Document 2 present a method of simulating the operation in a programmable logic controller (hereinafter referred to as PLC).
According to the simulator device described above, the PLC debugging efficiency can be improved by simulating the PLC sequence.

Patent Document 3 discloses a general-purpose I / F between a programmable display and a simulator device, and a method for controlling a pseudo memory in the simulator device.
According to said simulator apparatus, operation | movement of a programmable display can be confirmed even if it does not connect the actual external apparatus by simulating an I / F part with a programmable display.

  Patent Document 4 discloses that a graphic operation panel (display device) is connected to a control host computer and a PLC, and performs a simulated PLC operation on the control host computer when screen data is executed. Is disclosed. Furthermore, it is also disclosed that screen data can be displayed and debugged on a control host computer in a stand-alone state without being connected to a graphic operation panel (display device).

  Further, Patent Document 5 discloses a simulation of display screen data of a display device using a display device simulator device and a PLC simulator device on a personal computer without using PLC display hardware. It is disclosed that it can be done.

  In this way, as a conventional simulator device, it is possible to realize stand-alone debugging by performing only the simulated operation of the PLC and connecting the display device to the actual machine, and performing the simulated operation of both the PLC and the display device. There is a type. In addition, regarding the simulation function of the operation of the display device, it may be called an emulation device that emulates the display device. In this description, it is assumed that such an emulation device is also included in the simulator device.

  Patent Document 6 discloses a display example of a simulation screen in connection with a simulator device.

JP-A-4-215105 JP-A-5-297915 Japanese Patent No. 3562833 JP 2001-75634 A JP 2006-155158 A JP-A-11-134218

  However, in the methods described in Patent Documents 1 to 3, the main purpose is to improve the debugging efficiency of the PLC, and the fact is that the improvement of the debugging efficiency of the macroblock is insufficient.

As described above, by changing the screen data (with various macro blocks attached), the macro function can be easily changed (customized), which is convenient.
However, on the other hand, in the conventional external device simulator device for a programmable display, there is a problem among various types of macro data when the customized macro data setting has some problem and the operation is not as desired by the user. Although it is easy to specify the macro data, there is a problem that it takes a lot of work to specify a problem (line) in the macro block. That is, there is a problem that the debugging efficiency of the macroblock is poor.

This will be described in more detail below.
First, arbitrary macro data (also referred to as a macro block) is a multi-line program list (for example, an example is shown later in FIG. 5) using macro commands such as “mov” and “Fill”. Each row includes, for example, the macro command and an execution target of the macro command (for example, a memory address to be read / written).

  Since the contents of the macroblock are arbitrarily created by the user, there is a possibility that a mistake will naturally occur. In addition, even if there is no mistake, there may be a case where the user does not operate as desired.

  In any case, even if some problem occurs, the entire macroblock does not have a problem, and most of them have a problem. Therefore, it is necessary to repair the problematic line by specifying the line in the macroblock consisting of a plurality of lines.

  Here, whether or not there is any problem is determined by the user. As described above, this has a function of displaying a list of simulated memories and their values as a function of the simulator device. The user can determine whether or not there is a problem by looking at the displayed memory value.

  However, this memory value can only be displayed as a result of processing execution in units of macroblocks. For example, if a macroblock consisting of 100 rows is taken as an example, the memory value as a result of executing all 100 rows is displayed.

  For this reason, even if it is found that there is a problem with this macroblock due to a determination reason such that this memory value is not the expected value, it has not been known which line in this macroblock has a problem. Thus, conventionally, for example, the problem described below has been performed to identify the problem line.

In other words, as described above, processing is executed in units of macroblocks, and processing cannot be stopped midway. Therefore, the content of the macroblock in question is corrected and the processing is executed to check the result (memory value). Was repeated. For example, in the case of the macroblock consisting of the above 100 lines, for example, first, on the drawing editor device, the user leaves the first line to the 10th line and the remaining (11th line to 100th line) is a deleted macroblock. create. Then, the created (corrected) macroblock is downloaded to the programmable display. Thereafter, a simulation is performed.

  In this example, when the modified macroblock is executed, only the first to the tenth lines are executed, and the result is reflected as a memory value. It can be determined whether or not there is a problem in the first to tenth lines.

  If there is no problem in the first line to the tenth line, a macro block consisting of only the first line to the 20th line is created and the same processing as the macro block in the first line to the tenth line is performed. Do. This is repeated up to the 100th line.

  In the above example, if it is determined that there is a problem in the macroblocks in the 1st to 20th lines, there is a problem in any of the 11th to 20th lines. Therefore, this time, a macro block is created and verified for each line. First, “corrected macroblocks” are sequentially created and verified, such as macroblocks from the first line to the eleventh line, and then the macroblocks from the first line to the twelfth line.

  The above-described macroblock correction method is an example, and is not limited to this example. For example, if you first create and verify the macroblocks in the first to 50th lines, you can see if there is a problem in the first half or the second half of the 100th line macroblock, and then narrow the target from there. A method is also conceivable. Alternatively, a method of verifying line by line from the beginning can be considered. That is, only the first line, the next one or two lines, and the next one to three lines may be increased one by one.

  Alternatively, instead of the regular method as described above, it is also conceivable that the debugging operator repeats trial and error such as inferring and verifying a suspected line by experience or intuition. However, it relied heavily on the experience and intuition of the debugging worker, and the work efficiency was poor. Alternatively, there is a method of inserting a patch command in the macro block, but this is also inefficient.

  In any case, in the past, in order to identify the problem part in the macro block with a problem, trial and error are repeated, the macro block is corrected one by one, and this is downloaded to the display unit for simulation. That was a very time-consuming work. For this reason, the work efficiency is poor, and the debugging work takes a very long time.

This problem occurs in the same way even in the case of a simulator device including an emulation device such as the above-mentioned Patent Documents 4 and 5.
An object of the present invention is to provide a function for temporarily stopping execution at an arbitrary timing during execution of an arbitrary macroblock in a simulator device for a programmable display, so that the problem in the macroblock can be quickly and easily saved. The object is to provide a display / control / simulation system, a programmable display device, a simulator device, and the like that can specify a location and thus can improve the debugging efficiency of a macroblock.

The display / control / simulation system of the present invention is a system in which a programmable display and a simulator device are connected, and the programmable display stores screen data accompanied by macro data composed of various macro blocks. Screen data storage means and processing corresponding to an arbitrary event using the screen data, and when executing the macro block program related to the processing, the line number is notified to the simulator device for each line And a processing execution means for executing the program on the line when execution permission is returned, and the simulator device stores the same macro data as the macro data stored in the screen data storage means. An arbitrary line of the macro block program of the macro data stored in the storage means Breakpoint setting support means for setting a breakpoint and storing the setting contents as break position information, and each time the line number is notified from the processing execution means, the break position information is referred to and the line It is determined whether or not the numbered line is the breakpoint. If it is not a breakpoint, the execution permission is returned, and if it is a breakpoint, the execution permission is not returned without returning the execution permission. And a macro execution control means for returning the execution permission when a predetermined instruction is issued thereafter.

  In the display / control / simulation system configured as described above, the simulator device further includes simulation result display means for displaying a simulation result in the execution resumption waiting state.

  According to the display / control / simulation system having the above configuration, it is possible to pause at the breakpoint line arbitrarily set by the user during execution of the macroblock. As a result, the simulation result up to the middle of the execution of the macroblock can be displayed, and the user can determine whether or not there is a problem in the processing up to the point of suspension by viewing this display.

  Conventionally, since the simulation result is displayed when the macroblock is executed to the end, if you want to display the simulation result up to the middle, modify the macroblock as described above. However, every time it is corrected, the corrected macroblock is transferred to the display unit, stored, and executed. This method eliminates the need for correction / transfer, so that troublesome points in the macroblock can be identified in a short time without any effort.

  According to the display / control / simulation system of the present invention, the programmable display device, the simulator device, and the like, it is troublesome by providing a function to temporarily stop execution at an arbitrary timing during execution of an arbitrary macroblock. Therefore, it is possible to identify a problem location in the macro block in a short time, thereby improving the debugging efficiency of the macro block.

It is a schematic block diagram of the display / control system of this example. It is a hardware block diagram of a programmable display. It is a software block diagram of the display / control system shown in FIG. It is a process flowchart figure of the display / control system of this example. It is a figure which shows an example of macro data. It is an example of the breakpoint setting screen by a macro viewer.

Embodiments of the present invention will be described below with reference to the drawings.
In FIG. 1, the schematic block diagram of the display / control system (PLC system containing a programmable display etc.) of this example is shown.

  In FIG. 1, the display / control system includes a programmable display 1, an external device 4 such as a programmable logic controller main body (hereinafter referred to as a PLC main body), and a drawing editor device 5.

  The PLC main body (external device 4) is connected to the programmable display 1 and various devices to be controlled (motor, temperature controller, etc.) as in the prior art. The PLC main body may be a general one, and will not be described in detail. However, as is well known, a general-purpose work memory and a memory for identifying each control information by a device name and an address, etc. It is generally realized by a control memory (referred to as a control memory) and a function (microcomputer) for controlling them.

Further, in this example, an example in which the function of the simulator device is installed in the drawing editor device 5 is used.
As described above, the programmable display device 1 is downloaded with screen data (various macroblocks attached) arbitrarily created on the drawing editor device 5 from the drawing editor device 5. The data is stored in a storage unit (memory or the like) in the display device 1. Then, the basic program in the display device 1 executes various processes using this screen data. At that time, for example, by executing macro data 26 (macro block) described later, data at a specific address in the control memory is read and displayed, or data is written at a specific address. The PLC main body controls the control target device (or the PLC main body itself) corresponding to this address based on the written data.

  The external device 4 may include not only the PLC main body but also a control target device. And the programmable display 1 displays the state of such an external device 4 by controlling a macro block, and controls the external device 4. FIG.

  The drawing editor device 5 is, for example, a personal computer or the like having a drawing editor function that allows the user to arbitrarily create screen data for the programmable display device 1. In this example, the drawing editor device 5 also has a function as a simulator device. The function as the simulator device has the above-described conventional function, but also has a new function described later. In addition to this example, a simulator device may be provided separately from the drawing editor device 5.

  The function of the conventional simulator device has already been described, and will not be described in detail here. However, if briefly described, for example, the memory in the drawing editor device 5 is used for the above-mentioned pseudo control. As a memory, the programmable display 1 is made to access this pseudo memory instead of the control memory. Then, the contents of the pseudo memory are read and displayed.

  The programmable display device 1 has a plurality of communication interfaces 2, and each communication line 3 is connected to each communication interface 2. The programmable display device 1 can communicate with the external device 4 and the drawing editor device 5 via each communication line 3. For example, the programmable display 1 is connected to the external device 4 via the communication interface 2 and the communication line 3, for example, by accessing the control memory and reading / writing data, The status of control and external device 4 can be displayed.

  An operation / display screen for allowing the user to perform such an operation (switch operation or the like) for controlling the external device 4 or for displaying a status is displayed on the display of the programmable display 1. This screen display is performed based on the screen data. Various item images (switches, lamps, graphs, numerical values, etc.) are displayed on the operation / display screen. The user touches the display position of a desired item image and executes a function (macroblock) pre-assigned to the item of the item image, thereby controlling the external device 4 and the like.

  Alternatively, regarding the graph, the numerical value, etc., even if the user does not operate, the data of the predetermined address in the control memory is read out by, for example, a macro block that is executed at a fixed cycle, so that the state of the external device 4 is graphed. Display / numerical value display.

The screen data is data that defines the operation of the programmable display such as what kind of display is to be performed, what kind of control is to be performed, and what kind of connection is being performed.
For example, when creating screen data in the drawing editor device 5, a component list including symbol images of various components such as a switch for receiving an operation by the user on the display 1 and a numerical display for displaying data is not shown. Is displayed on the screen data creation support screen. The user selects a desired part from these and places it at an arbitrary position on the support screen. Further, the user associates the device name and address (address in the control memory) of an arbitrary control target device with the arranged component. Each component is assigned a predetermined macroblock in advance. Alternatively, the user assigns an arbitrary macro block to each part. Further, the contents of the macroblock can be arbitrarily edited by the user, and further, for example, as described in the conventional problem, the macroblock of 100 rows can be corrected to 10 rows.

  The screen data created in this way is downloaded to the display 1. Then, as will be described later, the main body program 21, which is a basic program in the display 1, performs display / control processing using this screen data. Thereby, for example, regarding parts such as graphs and numerical values, the state of the external device 4 is automatically displayed in graphs / numerical values. For components such as switches, control processing corresponding to the component operated by the user is executed. In any case, a predetermined address in the control memory is accessed based on an address associated with each component, and the data is read / written.

Such display / control processing is realized by executing the macroblock.
A simulator device is provided in order to execute such processing of the display 1 in a pseudo manner without actually accessing the actual machine (PLC main body).

This method is related to the simulator device, and is not connected (accessed) to the external device 4 during the simulation operation. Therefore, the external device 4 will not be described further.
The simulation operation related to the simulator device of this example will be described later with reference to FIGS.

  FIG. 2 is a hardware configuration diagram of the programmable display 1. Note that the hardware configuration itself may be the same as the conventional one. The drawing editor device 5 may be a general general-purpose personal computer in terms of hardware, and is not illustrated or described here.

In FIG. 2, the programmable display device 1 includes a control unit 10, the communication interface 2, a touch panel 18 and a display 19.
The control unit 10 includes a graphic controller 11, a ROM 12, a RAM 13, a communication controller 14, a CPU 15, a touch panel controller 16, and the like, which are connected to an internal bus 17.

  The graphic controller 11 is connected to the display 19 and displays the operation / display screen, for example, on the display 19. The screen data of the operation / display screen is created on the drawing editor device 5 as described above and downloaded to the programmable display device 1 via the communication line 3, and stored in the ROM 12, for example. The

  The ROM 12 stores various programs (main program 21 and the like), the screen data, and the like. The ROM 12 is, for example, a readable / writable type (EEPROM, flash memory, etc.). The RAM 13 stores arbitrary various data (for example, device status data collected from the external device 4). The RAM 13 is basically used as a work memory.

  The communication controller 14 is connected to the communication interface 2 and realizes communication with the external device 4 and the drawing editor device 5 via the communication line 3 described above. The touch panel controller 16 is connected to the touch panel 18 and detects a user operation (such as a pressed position coordinate) on the touch panel 18.

  The CPU 15 is a central processing unit that controls the entire control unit 10. The CPU 15 realizes various processing functions of the programmable display 1 by reading and executing the various programs stored in the ROM 12, for example. These various processes include, for example, a process shown in FIG.

  As for the drawing editor device 5, the general-purpose personal computer includes, for example, a CPU, a hard disk, a memory, a user operation unit (keyboard, a mouse, etc.), a display, a communication interface, and the like as is well known. A predetermined application program or the like is stored in the hard disk or the like. The CPU implements the function as the conventional drawing editor and the function as the simulator device by reading and executing this program. In addition to the conventional functions described above, the functions as the simulator device include various functions described later (functions described with reference to FIG. 4).

FIG. 3 is a software configuration diagram of the display / control system shown in FIG.
First, the ROM 12 in the programmable display 1 stores various programs and various data shown in FIG. That is, various programs such as the illustrated main body program 21, communication program 22, and simulator communication program 23, and various data such as simulator operation determination information 24, screen data 25, and macro data 26 are stored in the ROM 12.

  The macro data 26 is the various macro data (various macro blocks) described in the above-described conventional and problems. Therefore, although not described in detail, an example is shown in FIG. 5 and will be described later. As already described, the macro data 26 is attached to the screen data 25.

  The screen data 25 is the screen data of the operation / display screen of the programmable display 1 as already described. Therefore, although not described in detail, for example, various items (switches, meters, lamps, buttons, etc.) are arranged at arbitrary positions on the screen. In addition, an arbitrary macroblock is associated with an arbitrary item. For example, taking a switch item as an example, when an arbitrary switch is turned ON / OFF by a user, a macro block corresponding to this switch is executed.

The main body program 21 is a basic program that realizes the entire operation of the programmable display device 1, and is a program related to basic functions such as display / input control, for example. For example, a display / control screen is displayed on the display 19 using the screen data 25. Then, the macro block is executed according to the item operation by the user on the display / control screen, or the macro block is executed at a fixed cycle. That is, every time an arbitrary event occurs, the macro block processing corresponding to this event is executed.

  In the figure, the communication selection unit 21a and the macro execution unit 21b among the various functions realized by the main body program 21 are shown. The macro execution unit 21b executes the macro block. In addition, the communication selection unit 21a selects a communication partner. The communication process with the selected communication partner is performed by executing the communication program 22 or the simulator communication program 23.

  Here, the communication program 22 and the simulator communication program 23 are programs related to communication control corresponding to a unique protocol for each connected model. That is, the communication program 22 is a program related to communication control corresponding to the external device 4. On the other hand, the simulator communication program 23 is a program related to communication control corresponding to the drawing editor device 5.

  For example, in the programmable display 1, the user can arbitrarily change the mode. In other words, the display device 1 has a normal mode in which the processing described above is performed by connecting to the external device 4, and a simulation mode in which a pseudo operation is performed by connecting to the drawing editor device 5 (simulator device). These modes can be selected.

  In the normal mode, the main body program 21 communicates with the external device 4 using the communication program 22. On the other hand, in the simulation mode, communication is performed using the simulator communication program 23. The mode selection result by the user is stored as the simulator operation determination information 24 shown in the figure, and the main body program 21 can recognize the current mode by referring to the simulator operation determination information 24.

  The main body program 21 and the communication programs 22 and 23 may be stored in advance in the programmable display 1 (at the time of shipment or the like), or the programmable display 1 from the drawing editor device 5 or the like at any time. It may be downloaded and stored. The programs 21, 22, 23 and the screen data 25 (including macro data 26) are stored in the ROM 12.

  As shown in FIG. 3, the drawing editor device (PC) 5 has programmable display drawing software 30. The programmable display drawing software 30 is stored in advance in a storage device (such as a hard disk) (not shown) in the drawing editor device 5. A CPU or the like (not shown) in the drawing editor device 5 reads and executes the application program, thereby realizing processing of various functional units such as the simulator 31, the macro viewer 32, and the communication processing unit 36 shown in the drawing. Although not shown, the screen data creation support function and the like described above are realized by the drawing software 30. As a result, the screen data creation support screen described above is displayed to allow the user to create arbitrary screen data (including macro data).

  In this example, the drawing editor device 5 has not only a drawing editor function but also a simulator device function. And as a function which comprises the simulator apparatus of this example, the simulator 31 of illustration, the macro viewer 32, and the communication process part 36 are shown.

Screen data (including macro data) arbitrarily created by the screen data creation support function is stored in the hard disk or the like, and these are the screen data 33 and macro data 34 shown in the figure. The screen data 33 and the macro data 34 are downloaded and stored in the programmable display 1 in accordance with a download instruction from the user. This is the illustrated screen data 25 and macro data 26.

  That is, the same data as the screen data 25 and macro data 26 held on the display 1 side is also held on the drawing editor device 5 side. As will be described later, in this method, the macro data 34 (various macro blocks) is used to allow the user to set an arbitrary breakpoint.

  The simulator 31 is a functional unit that realizes the function as the above-described simulator device, and basically executes the above-described existing simulation process. In this method, break position information 35 described later is used. A process (such as the process shown in FIG. 4) is executed. The programmable display 1 also executes the process of FIG. 4 and the like described later in cooperation with the process of the simulator 31.

  Further, the macro viewer 32 allows the user to set a breakpoint described later based on the macro data 34 and the like. Then, the break position information 35 is generated according to this setting. Details will be described later. The break position information 35 is stored in a hard disk or the like in the drawing editor device 5.

The macro viewer 32 and the simulator 31 (and the processing of the programmable display 1 linked to this) are the main features of this method.
Note that the simulator device of this example may be considered to be composed of a simulator 31 and a macro viewer 32.

FIG. 4 is a processing flowchart of the display / control system of this example. That is, it is a process flowchart diagram of the programmable display device 1 and the drawing editor device 5.
First, on the programmable display 1 side, the main body program 21 uses the screen data 25 to perform the above-described state display and control. Each time an arbitrary macro block is executed, the macro execution unit 21b executes the processing of the macro block.

  First, the macro execution unit 21b refers to the simulator operation determination information 24, and is currently in a normal operation (the normal mode) or is operating in conjunction with the simulator device (is the simulation mode)? Is determined (step S11).

  In the case of normal operation (not linked with the simulator device) (step S11, NO), existing general processing is performed. That is, according to the arbitrarily set timing, the execution target macroblock (consisting of a plurality of rows) is executed one by one in order from the first row of the macroblock (step S11, NO in step S14 and step S15) , NO loop processing), when the processing is executed up to the last line (step S15, YES), the processing of the macroblock is terminated. Then, for example, the process proceeds to processing of the next macroblock.

  In the figure, if the determination in step S15 is NO (if not yet executed to the last line), the process returns to step S11, but the present invention is not limited to this example, and the process may move to step S14.

On the other hand, in the simulation mode, that is, when operating in conjunction with the simulator device (step S11, YES), the first line of the macroblock is basically executed in the same manner as the normal operation according to the arbitrarily set timing. Will be executed one line at a time, starting with the simulator 31 of the drawing editor device 5 before executing the process (macro command, etc.) for each line. The block number and line number of the macro block are notified (step S12).

  The block number is an identification number assigned in advance to each macro block in order to identify each macro block. The line number indicates the number of the line from the beginning in the macroblock.

  The simulator 31 acquires macro block break position information 35 corresponding to the notified block number. Then, based on the break position information 35 and the notified line number, it is determined whether or not the line with the notified line number is a break target (step S21).

Here, the break position information 35 will be described.
As described above, the break position information 35 is created when the user arbitrarily sets a break point by the macro viewer 32.

  As described above, the drawing editor device 5 side holds the same data as the screen data 25 and macro data 26 held and executed on the programmable display device 1 side. That is, the screen data 33 and the macro data 34 are held.

  Accordingly, the macro viewer 32 which is one function (application) of the simulator device of the present example displays the contents of the macro block arbitrarily designated by the user at any time before the start of the simulation on the display of the drawing editor device 5, for example. To do. Or when the notification by said step S12 is received, the content of the macroblock of the notified block number is displayed. In any case, for example, the contents (all lines) of the macroblock are displayed in the breakpoint setting screen 40 as shown in FIG.

  Here, FIG. 5 shows an example of the macro data 34 (26). As shown, the macro data 34 (26) is composed of a plurality of macro blocks (1 to n). Each macro block is composed of a program of a plurality of lines (for example, a program statement using a macro command). In the example of the illustrated macroblock 1, the program has “m + 1” rows with row numbers “0” to “m”.

  For example, the macro viewer 32 displays a breakpoint setting screen 40 shown in FIG. 6 on the display. The breakpoint setting screen 40 displays the contents (program list) of an arbitrary macroblock. In the illustrated example, the contents of the macro block 1 shown in FIG. 5 are displayed.

  The user can designate an arbitrary “line” in the program list of the displayed macroblock on the breakpoint setting screen 40. For example, it can be specified by clicking the display position of a desired “line” by operating the mouse.

  Also, on the breakpoint setting screen 40, three types of operation buttons, a “breakpoint setting” button 41, a “breakpoint release” button 42, and an “execute” button 43 are displayed.

When the user wants to set a desired “line” as a breakpoint, the user first designates the desired “line” as described above, and then operates the “set breakpoint” button 41. This setting result is reflected in the break position information 35 by the macro viewer 32. The break position information 35 stores, for example, the line number of “line” set as the breakpoint for the macroblock in association with the block number of each macroblock.

Here, the breakpoint indicates a position (line) at which execution of the macroblock is temporarily stopped.
On the breakpoint setting screen 40, a display is made so that the user can recognize the “line” set as the breakpoint. In the illustrated example, a black circle is displayed on the left side of the set “row”. In the illustrated example, it can be seen that the third line (line number = 2) is set as a breakpoint. The number of lines set as breakpoints is only one in the illustrated example, but a plurality of lines may be set as breakpoints. In extreme cases, it is possible to set all lines as breakpoints.

  In addition, when the user wants to cancel (cancel) the setting of an arbitrary line in the “line” set as a breakpoint, the user has designated a desired “line” in the set “line”. Thereafter, the “breakpoint release” button 42 is operated. As a result, the black circle display of this “line” disappears, and the line number of this “line” is deleted in the break position information 35.

  The breakpoint setting screen 40 can be displayed by activating the macro viewer 32 at any time by the user, but is automatically displayed when the simulator 31 is operating (during the execution of the process of FIG. 4). The The user may set the breakpoint for an arbitrary macro block in advance on the breakpoint setting screen 40, or may set a breakpoint during the simulation operation. During the simulation operation, the contents of the macro block having the block number notified in step S12 are basically displayed on the breakpoint setting screen 40.

  Although not shown in FIG. 6, if the contents are displayed on the breakpoint setting screen 40 during execution of an arbitrary macroblock, the user can know how many lines have been executed. Some kind of display may be performed.

Now, the description returns to the flowchart of FIG.
As described above, with regard to the description of step S21, the setting of the break point and the break position information 35 corresponding to this setting have been described with reference to FIGS. According to this description, the process of step S21 is performed by referring to the break point information regarding the macro block having the notified block number in the break position information 35. That is, as described above, the line numbers of one or more “lines” set as breakpoints are registered, and it is determined whether or not the notified line numbers are included therein.

  For example, in the example shown in FIG. 6, the line number = “2” is registered for the macro block 1 in the break position information 35, so that the macro block being executed on the display unit 1 side is the macro block 1. If there is, the determination in step S21 is YES when the line number notified by the process of step S12 is “2”.

  Initially, since the line number ('0') of the first line is notified, the determination in step S21 is NO and a predetermined reply is made to the macro execution unit 21b of the display 1 (step S23). Here, it is assumed that execution permission is returned.

After performing the notification in step S12, the macro execution unit 21b of the display device 1 is in an execution permission waiting state (standby state) (step S13). Then, when execution permission is returned in step S23 (step S13, YES), the processing of “row” notified in step S12 is executed (step S14). Initially, the processing of the first line is executed.

  When the execution of step S14 is completed, it is determined whether or not the executed “row” is the last row (step S15). If it is the last line (step S15, YES), this process is terminated. If it is not the last line (step S15, NO), the process returns to step S11. In addition, although it returns to step S11 in the figure, you may make it return to step S12.

  In step S12, the simulator 31 is notified of the line number of the next “line” to be executed. Since the line number = “1” is notified this time, in the above example, the determination in step S21 is NO, and the same processing as in the case where the line number = “0” is executed.

  Subsequently, when the line number = '2' is notified, in the above example, the determination in step S21 is now YES, and a macro execution restart waiting state is entered (step S22). When the user operates the “execute” button 43 on the breakpoint setting screen 40, the process proceeds to step S23. In this case as well, execution permission is returned in step S23.

  Here, in the macro execution resumption waiting state in step S22, the simulator device displays the contents of the pseudo memory on the display by the above-described conventional existing function (therefore, not specifically illustrated or described). The user can determine whether or not the macro is performing the expected operation by checking the contents of the pseudo memory in the simulation apparatus in a list display. That is, the user can determine whether or not there is an abnormality in the processing up to the breakpoint.

  In the above example, if the user determines that there is an abnormality, in the line executed so far (in this example, in the two lines of line numbers = '0' to '1'), there is a problem line Will exist. As a result, the user sets all the two lines, for example, line numbers = '0' to '1', as breakpoints by the function of the macro viewer 32. Then, the user causes the macroblock to be sequentially executed again from the first row, for example, by performing a predetermined operation on the display 1 side. As a result, the line having a problem can be identified.

  On the other hand, the user operates the “execute” button 43 when it is determined that there is no problem in the confirmation work. As a result, the macro execution resumption waiting state in step S22 is released, and the execution permission is returned in step S23, whereby the processing of the row with the row number = '2' is executed on the display 1 side. In the fourth and subsequent rows, the above-described processing is executed for each row until the processing of the last row is executed. Although not shown in FIG. 6, if there are breakpoint lines after the fourth line, the execution is temporarily stopped and the user makes an abnormality determination based on the list display.

  Although not shown in FIG. 6, a “step execution” button (not shown) may be further provided on the breakpoint setting screen 40. In this case, the user operates either the “execute” button 43 or the “step execute” button when determining that the user should resume in the macro execution resumption waiting state in step S22.

  When the “step execution” button is operated, the simulator device sets a breakpoint for the line next to the notified line, and then performs the reply process in step S23. . Thus, regardless of the setting contents by the user, the determination in step S21 is always YES even in the next line, and the macro execution is temporarily stopped.

  In this way, by providing the “step execution” button, the user operates the “step execution” button when he / she finds a part that seems to have a problem during debugging (judging based on experience and intuition). This makes it possible to verify this part intensively.

  As described above, according to this method, a user can find a problematic line in a macroblock simply by performing an operation of setting one or more arbitrary lines as a breakpoint in advance or during debugging. Thus, it is possible to realize a correction work (debugging work) and to perform an efficient debugging work. As a result, the time required for the debugging work can be shortened as compared with the prior art. In addition, it is possible to reduce the user's debugging work load.

Such a time reduction effect of the present technique will be described below using a specific example.
Here, for example, a macroblock consisting of 100 rows is taken as an example, and it is assumed that there is some problem on the 100th row.

In the case of this example, in the conventional system, the debugging work is performed by the following procedure, for example.
The macro block modification → screen transfer → confirmation is repeated from the 1st to the 100th lines.

  That is, as already described with an example in the conventional problem, in the drawing editor device 5, the user corrects the contents of the macroblock. The correction method may be various as described above, but here, for the sake of easy understanding, a method of verifying line by line from the first line is taken as an example. Therefore, here, the macroblock is first modified so that the contents of the macroblock are only the first line, the next is modified to be only the first and second lines, and the next is only the first to third lines. Modify to be This is repeated until the problem line is found. However, as described above, there is a problem in the 100th line in this example. Therefore, it does not end until a macroblock consisting of 1 to 100 lines is created and verified. Become.

  In practice, it is often the case that a problem is first extracted from a plurality of macroblocks, and then a problem line is identified for each problematic macroblock. Conceivable. In other words, if the operation of the original macroblock (consisting of 100 lines) is confirmed, it is considered that there are many cases where debugging work for specifying the problem line is performed because there is an abnormality. Therefore, in the above example, it can be estimated that there is a problem in the 100th line when it is confirmed that there is no abnormality by creating and verifying a macroblock consisting of 1 to 99 lines. However, since this is an estimation, it is assumed here that the problem line cannot be identified until a macroblock consisting of 1 to 100 lines is created and verified.

  Then, as already described in the conventional problem, each time the macroblock is corrected, the corrected macroblock is downloaded (transferred) to the programmable display 1 and the macroblock held on the programmable display 1 side is updated. Let Then, in the programmable display 1, this macro block is executed.

  Then, when the macro block is executed to the end, the user can refer to the execution result by displaying a list of the contents of the pseudo memory, so that it is confirmed whether or not there is a problem. If there is no problem, the macroblock is corrected and the transfer, execution and confirmation are performed again.

Here, it is assumed that the time required for the macroblock correction, screen transfer, and confirmation is as follows.
(A) Screen drawing (macroblock correction): 20 seconds (b) Screen transfer: 20 seconds (c) Operation check: 20 seconds Therefore, in this example, the time required for debugging work (until the problem line is specified here) Time) is as follows.

((A) + (b) + (c)) × 100 (line) = 6000 seconds (about 100 minutes)
On the other hand, according to the system of this example, (a) screen drawing and (b) screen transfer are not required, and only (c) time required for operation check and time required for breakpoint setting are required. In the case of the above example, all lines are set as breakpoints. Alternatively, only the first line may be set with a breakpoint, and the “step execution” button may be operated during debugging. In either method, the operation is confirmed line by line from the top line. Especially in the case of the above example, it is not necessary to consider where to set the line to be a breakpoint, and the setting is completed by specifying the first line or all lines, so the time required for the setting work can be extremely short (for example, Tens of seconds).

(C) The time required for the operation check is the same as the conventional time.
In other words, the time required for checking the operation for each line by executing the macro step is 20 seconds.
20 seconds x 100 lines = 2000 seconds (approximately 33 minutes)
It becomes. Even if the time required for the setting work is added to this, it takes a very short time (approximately 1/3) compared with the conventional method (100 minutes).

As described above, since screen drawing and screen transfer are not required, work efficiency is greatly improved, and time required for debugging work can be greatly shortened (about 1/3).
It is considered that the effect of improving work efficiency (time reduction) is further increased when the size of the screen data is large or as the number of lines in the macroblock / the number of macroblocks increases.

  In addition, the example described above is based on the assumption that a programmable display device uses a real machine, but a PLC or the like does not use a real machine and performs a pseudo operation on a personal computer using a simulator device. It is not limited to examples.

  As described above, in the prior art, the function / operation of the programmable display is realized in a pseudo manner on a personal computer or the like. In other words, there has conventionally been an emulation device that emulates the operation of a programmable display. As described above, it has been conventionally known that the screen data of the programmable display device is debugged by operating both the simulator device and the emulator device on a personal computer or the like.

  This method can be applied to such a configuration. In this case, although not shown in FIG. 3, the programmable display screen drawing software 30 of the drawing editor device 5 is further provided with the functions of the emulator. Then, the emulator device and the simulator device perform cooperation processing to realize the debugging work described above. In this case, in addition to the conventional processing function, the emulation apparatus is further provided with a function of performing processing substantially similar to the processing of the macro execution unit 21b shown in FIG. Of course, in this case, since the simulator device and the emulator device are constructed on the same personal computer (drawing editor device 5), communication processing via the communication line 2 by the communication program is not necessary.

In this case, the process of step S11 according to the setting of the mode or the setting mode may or may not be performed. When the mode is set, the user sets it on the drawing editor device 5. For example, in the case where it is desired to operate the emulation apparatus alone without operating in cooperation with the simulator apparatus, the process in which the determination in step S11 is NO is executed by setting the normal mode.

  As described above, the present technique can be applied to any case of the case where the programmable display is an actual machine and the case of the emulation apparatus that simulates the operation thereof, and has the above-described effects.

  In the above display / control system, it is practical that the communication processing unit of the programmable display 1 has a general-purpose configuration that operates by switching to a unique communication program by an external device set in the drawing editor. Is. In this case, the interface between the main body program 21 and the communication program 22 is ideally a general-purpose common interface that does not depend on the communication protocol unique to the external device.

Finally, in the display / control system, what is related to the existing technology will be described below.
* Summary of conventional simulator function When confirming the operation of the display unit 1, a method of confirming the operation by connecting the display unit 1 and an actual external device (actual machine; external device 4), There has been proposed a method of confirming operation by connecting a display device and a simulator device (a simulator device configured by a personal computer or the like for simulating an external device (actual machine)). Further, a method of confirming the operation by linking an emulation device configured by a personal computer or the like and emulating a simulator software configured on the personal computer is conceivable.

  In the display / control system, cooperation between the display 1 and the external device 4 is established by a command performed via the communication line 3, and the control of the external device 4 is performed by operation of a device memory by the command. It can be considered that the external device does not need to be an actual device (external device 4) as long as it can be linked by a command performed via a communication line.

  Based on the above-described concept, the simulator device of the programmable display 1 prepares a simulated device memory and performs cooperation with the display 1 using a simulator-specific command. By doing in this way, the display 1 can be in a state in which an external device is connected in a pseudo manner so that the operation of the display 1 can be confirmed. The operation of the display unit 1 is mainly processing executed by the main body program 21 using the screen data 25, and the operation of the screen data is confirmed using a simulator device. In particular, the operation of each macro block associated with the screen data 25 is confirmed.

  For example, in the prior art, when the operation of the screen data is confirmed by the display 1 and the simulator device as shown in FIG. 3, the communication program 22 of the display 1 is switched to the communication program 23 for simulator communication, and the display 1 By changing the external device that communicates with the simulator device, the operation of the display 1 can be confirmed as if it is connected to the actual device (external device 4). When linked to the emulator device, the simulator software can easily communicate with both sides by switching the communication interface path when the simulator software communicates with the display 1 and when linked with the emulator. It has become.

Further, as already described, there has conventionally been GUI means for displaying / editing the contents of the pseudo memory constructed on the simulator device. Thereby, the user can determine whether or not there is an abnormality in the operation of the display by referring to the contents of the pseudo memory, or can easily change the contents of the pseudo memory.

  The simulator device analyzes what kind of pseudo memory is displayed based on the screen data file to be simulated and the screen actually displayed on the display unit, and displays a list of memory used on the screen. It also has a function.

Specific details of existing macro data (various macro blocks) are listed below.
The macro data is a part of the screen data as shown in FIG. 5, and has the same data in the programmable display and the simulator software. By executing various macro blocks, arithmetic processing, operation of a programmable display, memory operation of an external device, and the like can be performed at an arbitrary timing. A specific example of this arbitrary timing is shown below. In the following specific examples, various macro blocks (open macro, ON macro, etc.) are grouped as [screen], [switch], etc., for example. In some cases, a specific macroblock name is not shown and only a schematic explanation is given.

[screen]
-Open macro: Run once when the screen is displayed
-Close macro: Run once when switching screens
-Cycle macro: Repeated execution while the screen is displayed
[Multi-overlap]
-Open macro: Run once when multi-overlap is displayed
-Close macro: Run once when multi-overlap is turned off
[switch]
-ON macro: Run once when switch is pressed
-OFF macro: Run once when finger is released from switch
[Function switch]
-ON macro: Runs once when the function switch is pressed
-OFF macro: Runs once when the finger is released from the function switch
[Initial macro]
Execute macro of macro block once before starting communication with controller.

[Global Macro]
When the macro execution bit in the read area changes from 0 to 1 (edge), the macro block macro is executed once.

[Event timer macro]
Regardless of the screen being displayed, the macro block macro is always executed at every set time.
[Interval timer]
While the screen with the interval timer set is displayed, the timer starts according to the settings.

Every time the time is up, the macro block macro is executed.
[Macro mode]
While displaying a screen with the macro mode set, the macro is executed according to the setting memory status.

-ON macro: Executes when the memory bit changes from 0 to 1 (edge)
-OFF macro: Executes when the memory bit changes from 1 to 0 (edge)

1 Programmable Display 2 Communication Interface 3 Communication Line 4 External Device 5 Drawing Editor Device 10 Control Unit 11 Graphic Controller 12 ROM
13 RAM
14 Communication controller 15 CPU
16 Touch Panel Controller 17 Internal Bus 18 Touch Panel 19 Display 21 Main Program 21a Communication Selection Unit 21b Macro Execution Unit 22 Communication Program 23 Simulator Communication Program 24 Simulator Operation Determination Information 25 Screen Data 26 Macro Data 30 Programable Display Software 31 Simulator 32 Macro Viewer 33 Screen data 34 Macro data 35 Break position information 40 Breakpoint setting screen 41 “Breakpoint setting” button 42 “Breakpoint release” button 43 “Execute” button

Claims (6)

A system in which a programmable display and a simulator device are connected,
The programmable display is
Screen data storage means for storing screen data accompanied by macro data composed of various macro blocks;
When the process corresponding to an arbitrary event is executed using the screen data, and the macro block program is executed in connection with the process, the line number is notified to the simulator device for each line, and execution permission is returned. And a process execution means for executing the program of the line when
The simulator device
Storage means for storing the same macro data as the macro data stored in the screen data storage means;
Breakpoint setting support means for causing an arbitrary line of a macro block program of macro data stored in the storage means to be set as a breakpoint and storing the set content as break position information;
Each time there is a notification of the line number from the process execution means, it is determined whether or not the line with the line number is the breakpoint by referring to the break position information. Macro execution control means for returning execution permission and returning the execution permission when there is a predetermined instruction after returning to the execution resuming state without returning the execution permission if it is a breakpoint;
A display / control / simulation system characterized by comprising:   2. The display / control / simulation system according to claim 1, wherein the simulator device further includes a simulation result display means for displaying a simulation result in the execution resumption waiting state.   The macro execution control means, when there is step execution as the predetermined instruction, sets a line next to the line of the notified line number as a breakpoint and returns the execution permission. The display / control / simulation system according to claim 1 or 2, characterized in that:   The display / control / simulation system according to claim 1, wherein the programmable display device is an actual device of the programmable display device or an emulation device that emulates the operation of the actual device. The programmable display in a system in which a programmable display and a simulator device are connected,
Screen data storage means for storing screen data accompanied by macro data composed of various macro blocks;
When the process corresponding to an arbitrary event is executed using the screen data, and the macro block program is executed in connection with the process, the line number is notified to the simulator device for each line, and execution permission is returned. Processing execution means for executing the program of the line when
A programmable display device comprising: A simulator device in a system in which a programmable display and a simulator device are connected,
Storage means for storing the same macro data as the macro data stored on the programmable display side;
Breakpoint setting support means for causing an arbitrary line of a macro block program of macro data stored in the storage means to be set as a breakpoint and storing the set content as break position information;
Each time there is a notification of the line number of the line to be executed from the programmable display that is executing an arbitrary macroblock, whether or not the line with the line number is the breakpoint is referred to by referring to the break position information. If it is not a breakpoint, execution permission is returned to the programmable display, and if it is a breakpoint, the execution permission is not returned without returning the execution permission and a predetermined instruction is issued after that. Macro execution control means for returning the execution permission in the case of
A simulator apparatus comprising:

Images