JP5757098B2 - Program creation support apparatus and program creation support method - Google Patents

Description

  The present invention relates to an apparatus that supports creation of a program for a programmable controller, and more particularly to an apparatus that can support creation of a program for a programmable controller including a plurality of processors.

  The programmable controller program creation support device is a device for supporting creation and debugging of a program for a programmable controller by a user such as a system designer. In the following description and drawings, the programmable controller is also referred to as PLC.

  Regarding programming of a programmable controller, it is common to perform system development using a programming language that conforms to an international standard called IEC61131-3 (International Electrotechnical Commission) (Non-patent Document 1).

  FIG. 15 shows a software model defined in IEC61131-3. As shown in FIG. 15, in the conventional programmable controller program creation support apparatus, a programmable controller having a single processor is programmed to support one configuration, one resource, and a plurality of programs (see FIG. 15). 16).

  Furthermore, in recent years, a programmable controller including a plurality of processors and a shared memory shared between the processors as shown in FIG. 17 has been widespread. As a programmable controller program creation support apparatus including a plurality of processors, for example, Patent Document 1 discloses. There is a device as shown.

  The programmable controller program creation support device disclosed in Patent Document 1 is configured to assign a shared memory to a global variable that is a variable accessible from a plurality of programs when creating a program for a programmable controller having a plurality of processors. It was made to specify explicitly whether to allocate to the variable area of a processor.

JP 2008-198143 A

IEC61131-3

  However, since the shared memory can be read / written from any processor, the write area of each processor is usually determined so that erroneous memory overwrite by other processors does not occur.

  For this reason, global variables need to be allocated to the shared memory area of the processor that performs the writing. Therefore, whenever the program allocation to the processor is changed, the global variable declaration must also be changed, which is inconvenient for the user. It was a thing.

  Therefore, the present invention makes it possible for a user to use a program creation support apparatus or program creation support method for a programmable controller including a multi-CPU module having a plurality of processors and a shared memory in which an area is allocated to each processor. The purpose is to make it easy.

In order to solve the above-described problems, the programmable controller program creation support device of the present invention is
A program creation support apparatus for a programmable controller configured by a multi-CPU module including a plurality of processors and a shared memory in which an area is allocated to each processor,
Processing for displaying a dialog for a user to explicitly specify program allocation to the plurality of processors and storing a program allocation instruction by the user;
In the programmable controller, a process for displaying a dialog for the user to specify a declaration of a global variable that is a variable accessible from a plurality of programs, and storing the specification of the declaration of the global variable by the user;
A GUI part (Graphical User Interface part)
Determining whether the global variable is a read variable or a write variable for each program, and generating a global variable read / write attribute for each program;
A global variable allocation unit that allocates the global variable to the shared memory based on the program allocation instruction and the read / write attribute of the global variable;
Have
The global variable allocation unit is configured to allocate the global variable to a shared memory of a processor to which the program is allocated when the global variable used in the program has a write attribute.

The program creation support method of the present invention is a program creation support program for a programmable controller composed of a multi-CPU module having a plurality of processors and a shared memory to which an area is allocated for each processor. A method, wherein the computer includes a processing unit and a storage unit,
The processing unit is
Displaying a dialog for allowing a user to explicitly specify program allocation to each of the processors; storing program allocation instructions by the user in the storage unit;
In the programmable controller, a dialog for allowing the user to specify a declaration of a global variable that is a variable accessible from a plurality of programs is displayed, and the specification of the declaration of the global variable by the user is stored in the storage unit,
Based on a program assignment instruction and a global variable declaration specified by the user stored in the storage unit, an intermediate code and an intermediate program list are generated,
From the intermediate code and the intermediate program list, it is determined for each program whether the global variable is a read variable or a write variable, and a read / write table representing the read / write attribute of the global variable is generated for each program. And
Compile the intermediate code and intermediate program list and the read / write table said generated-out based on the read / write attribute of the program allocation instruction and the global variable, if the global variable has a writing attribute Machine code and final program list assigned to the shared memory of the processor to which the program is assigned the global variable,
Downloading the generated machine code to each processor based on the generated final program list.
It is characterized in that the creation of a program for a programmable controller is supported by performing processing.

  The user can declare a global variable without being conscious of program assignment to the processor, and can provide a program support apparatus or a program creation support method that is convenient for the user.

It is a figure which shows the structure of the program creation assistance apparatus for PLCs concerning embodiment of this invention. It is a figure which shows schematic structure of PLC and a multi CPU module. FIG. 3 is a diagram illustrating a schematic configuration of a shared memory and a read / write state with each processor. It is a figure which shows the flow in the case of creating one configuration in the PLC program creation support apparatus. It is a figure which shows the example of a display screen of the program creation assistance apparatus for PLC at the time of allocating the program allocated to each processor. It is a figure which shows an example of Dialog. It is a figure which shows an example when assignment of the program to each processor of PLC is completed. (A1) and (a2) are examples of programs, (b1) and (b2) are examples of intermediate codes, and (c1) and (c2) are examples of read / write tables. It is a figure explaining a global variable. It is a figure which shows an example of the description of the declaration of a global variable. FIG. 8A is a diagram showing an example of a list in which the tree structure of FIG. 7 is expanded, FIG. 8B is a diagram showing an example of a list divided for MAIN CPU, and FIG. 7C is a diagram divided for LOCAL CPU. It is a figure which shows an example of a list. It is a figure which shows the outline | summary until a machine code is produced | generated. It is a figure explaining the download process in the program creation assistance apparatus for PLC. It is a figure explaining the comparison process in the program creation assistance apparatus for PLC. It is a figure which shows the IEC61131-3 software model. It is a figure which shows an example of the conventional program creation assistance apparatus for PLC. It is a figure which shows the structural example of a multiprocessor programmable controller.

Embodiments of the present invention will be described below with reference to the drawings.
FIG. 1 shows the configuration of a programmable controller program creation support apparatus according to an embodiment of the present invention.

  The programmable controller program creation support apparatus 101 communicates with the programmable controller 102 via the communication interface 113 in the apparatus, and downloads, uploads, etc. a program such as a machine code.

FIG. 2 is a diagram illustrating a schematic configuration of the programmable controller 102 and a schematic configuration of the multi-CPU module.
In the programmable controller 102, one or more modules including at least a CPU module are connected to the base board 1021. Here, in the embodiment of the present invention, the CPU module 1022 is a multi-CPU module 1022.

  The multi-CPU module 1022 includes a first processor 1024, a second processor 1025, a baseboard communication interface 1027, a shared memory 1028, and a communication interface 1029, which are connected via a common bus. Here, in the present embodiment, the first processor 1024 functions as a MAIN CPU, and the second processor 1025 functions as a LOCAL CPU.

  The baseboard communication interface 1027 is an interface unit for exchanging various data and commands with other modules 1023 via the baseboard. Of course, another module 1023 is also provided. The shared memory 1028 is a memory that can be read and written by both the first processor 1024 and the second processor 1025. The communication interface 1029 is an interface unit for connecting to the programmable controller program creation support apparatus 101 and Ethernet (registered trademark). Each processor includes a CPU, a program memory, and a local memory.

  Here, in the shared memory 1028, as shown in FIG. 3, a first processor write area 1031 and a second processor write area 1032 are determined in advance. The first processor 1024 can freely read / write data in the first processor write area 1031 of the shared memory 1028, but can only read data in the second processor write area 1032, and cannot write data. is there. Similarly, the second processor 1025 can freely read / write data from / to the second processor write area 1032 of the shared memory 1028, but can only read from / write to the first processor write area 1031. Impossible.

  The other module 1023 in FIG. 2 is a module having an arbitrary function such as an I / O module or a communication module. Further, the multi-CPU module may include two or more processors.

  Here, the description returns to FIG. Although not shown, the programmable controller program creation support apparatus 101 is configured by an information processing apparatus (Personal Computer) including a processing unit such as a CPU and a memory such as a RAM. And the part which performs the process which produces | generates the program allocated to each processor of the programmable controller 102 of the program creation assistance apparatus 101 for programmable controllers is a program by memory | storage parts, such as processing part implement | achieved by CPU in the said information processing apparatus, and RAM. By being executed, it is realized as follows.

  That is, first, a GUI unit (Graphical User Interface unit) 103 that provides an interface for a user such as a system designer to create (describe) a program, and instructions from the user to the GUI unit 103 are displayed on a keyboard, An input unit 104 that transmits by mouse input, and an output unit 105 that outputs the output of the GUI unit 103 to an output device such as a display screen, a speaker, or a printer.

  The GUI unit 103 performs various processes for the user to create (describe) a program. The feature of this embodiment is that the user explicitly assigns the program to each processor on the programmable controller. A dialog for specifying a global variable, which is a variable that can be accessed from multiple programs in the programmable controller, and a process for storing a program assignment instruction specified by the user. Is displayed, and the process of storing the declaration of the global variable designated by the user is performed.

  Then, the programmable controller program creation support apparatus 101 according to the present embodiment generates intermediate code based on the global variable sheet 106 in which the program assignment to each processor specified by the user and the declaration of the global variable are described. The unit 107 generates an intermediate code 121 and a program list 122.

  Further, the global variable attribute generation unit 108 analyzes the intermediate code 121 to determine whether the global variable is a read variable or a write variable for each program, and creates a global variable read / write table 109 for each program.

  The global variable allocation unit 110 allocates global variables to the first processor write area 1031 and the second processor write area 1032 of the shared memory based on the read / write table 109.

  The machine code generation unit 111 generates a machine code 123 and a program list 124 from the intermediate code 121, the program list 122, and the variable allocation information from the global variable allocation unit 110.

  The machine code generation unit 111 compiles the generated intermediate code 121, the intermediate program list 122, and variable allocation information output from the global variable allocation unit 110 a plurality of times (for the number of processors). Generate machine code corresponding to the processor. When compiling, a plurality of machine codes may be generated for one processor.

  Further, the programmable controller program creation support apparatus 101 according to the present embodiment downloads the generated machine code 123 to each processor of the programmable controller based on the generated program list 124 via the communication interface 113. The unit 112 is provided.

  In addition, the programmable controller program creation support apparatus 101 according to the present embodiment creates a programmable controller program creation via the communication interface 113 for the machine code downloaded to the programmable controller 102 and the program list created by the programmable controller 102. An upload unit 114 for uploading to the support apparatus 101 is provided.

  The machine code 125 and the program list 126 uploaded by the upload unit 114 can be compared with the machine code 123 and the program list 124 downloaded from the programmable controller program creation support apparatus 101 by the comparison unit 115. By the comparison process of the comparison unit 115, it is possible to check whether the generated machine code is definitely downloaded at the time of download. Also, after the download, the program in the device and the program in the programmable controller 102 are updated as needed. Since comparison is possible, for example, when it is not known whether or not the program in the programmable controller program creation support apparatus 101 has been changed, confirmation can be performed.

  In the programmable controller program creation support apparatus 101 shown in FIG. 1, for example, the flow when a user sets a certain system configuration, that is, creates a new configuration is as shown in FIG.

  First, in S201, settings such as creating a new configuration name are performed. Next, a resource to be controlled is set in S202, and a task is set in S203. In S204, a POU (Program Organization Unit) is created, the POU is instantiated in S205, compiled in S206, and compiled into the programmable controller 102 in S207 to download the generated machine code. In step S208, debugging is performed.

Correspondence between the description of each process of the flow shown in FIG. 4 and each part of FIG. 1 described above is as follows.
In the task setting process in S203, the user designates a program (task) to be assigned to each processor of the programmable controller 102 to the GUI unit 103. Next, in the compilation of S206, the intermediate code generation unit 107 and the machine code generation unit 111 generate a program. Then, the download in step S207 is performed by the download unit 112.

Hereinafter, the processing of each part of the programmable controller program creation support device of the present embodiment will be described in more detail.
First, with reference to FIGS. 5, 6, and 7, a process of assigning a program to a processor of a programmable controller performed in the GUI unit 103 will be described.

  FIG. 5 shows a display screen example of the programmable controller program creation support apparatus when a program (task) is assigned to the processor. To assign a program to a TASK with a LOCAL CPU on the GUI, for example, as shown in FIG. An insert pop-up menu will then appear and you can select a program instance.

  Next, a dialog (dialog) as shown in FIG. 6 is displayed. When the user selects a program type to instantiate and sets a name, the program instance inserted in the portion showing the tree structure in FIG. 5 is displayed. .

  When the dialog shown in FIG. 6 is displayed and the user sets the program to be instantiated, the name of the task (program instance) with “L_” for the program (task) that the user wants to assign to the LOCAL CPU of the programmable controller. In addition, for a program (task) to be assigned to the MAIN CPU of the programmable controller, a task name (program instance) without “L_” is attached.

  That is, when the tree structure portion of FIG. 5 when assignment of the program to the processor of the programmable controller is completed is enlarged and displayed, it is as shown in FIG. That is, a program (task) that the user wants to assign to the LOCAL CPU has a name with “L_”, and a program (task) that the user wants to assign to the MAIN CPU has a name without “L_”. Yes.

  As shown in FIGS. 5 to 7, the GUI unit 103 displays a dialog (FIG. 6) for the user to explicitly specify the program assignment to each processor on the programmable controller, and is designated by the user. The program allocation instruction is stored (FIG. 7).

  Next, FIG. 8 (a1) and FIG. 8 (a2) are examples of the created program. 8A1 is a part of the program assigned to the MAIN CPU, and FIG. 8A2 is a part of the program assigned to the LOCAL CPU.

  Next, global variables that are accessible from a plurality of programs shown in FIG. 9 will be described. A global variable is a variable accessible from a plurality of programs in one resource. In the program creation support device, the global variable sheet having a tree structure shown in FIG. 7 is declared in conformity with IEC61131-3. Note that there is no global variable sheet for each of the MAIN CPU and the LOCAL CPU, and the declaration is made regardless of the global variable declaration for which CPU.

  Therefore, the programmable controller program creation support apparatus according to the present embodiment makes a declaration as shown in FIG. 10 without distinguishing which CPU variable declaration. That is, at the stage of the global variable sheet 106, the global variables C000 to C003 are not variable declarations for the MAIN CPU (first processor 1024) and the LOCAL CPU (second processor 1025). As shown in FIG. 10, the GUI unit 103 is input by a user and generates a global variable sheet 106.

  Next, generation processing (compilation) of a program downloaded to each processor based on program assignment specified by the user or global variable specification will be described.

  First, the tree structure shown in FIG. 7 is made into a list as shown in FIG. 11A (“program list 112” in FIG. 1) by the intermediate code generation unit 107. In FIG. 11A, “NPGI: 2” indicates the number of programs, and L_DEF and DEFAULT indicate task names. Since other symbols are not particularly relevant to the present invention, the description thereof is omitted. Further, the intermediate code generation unit 107 generates an intermediate code ('intermediate code 121' in FIG. 1) as shown in FIGS. 8 (b1) and 8 (b2). Here, the MAIN CPU intermediate code shown in FIG. 8 (b1) is an intermediate code generated from the MAIN CPU program shown in FIG. 8 (a1). Further, the LOCAL CPU intermediate code shown in FIG. 8 (b2) is an intermediate code generated from the LOCAL CPU program shown in FIG. 8 (a2).

  Next, the global variable attribute generation unit 108 analyzes the intermediate code 121 to determine whether the global variable is a read variable or a write variable for each program, and each program is shown in FIG. 8 (c1) and FIG. 8 (c2). A global variable read / write table ('read / write table 109' in FIG. 1) is created. Here, the MAIN CPU read / write table shown in FIG. 8C1 is a read / write table generated from the MAIN CPU intermediate code shown in FIG. 8B1. Further, the LOCAL CPU read / write table shown in FIG. 8 (c2) is a read / write table generated from the LOCAL CPU intermediate code shown in FIG. 8 (b2). Here, a variable with “O” in the “R” column is a variable to be read, and a variable with “O” in the “W” column is a variable to be written.

  Further, the global variable allocation unit 110 allocates global variables to the shared memory based on the read / write table 109. Specifically, a global variable that is a variable (a variable in which “O” is assigned to the “R” column of the read / write table) from the MAIN CPU read / write table shown in FIG. 8C1. C001 and C002 are assigned to the addresses of the first processor write area 1031 of the shared memory 1028. Furthermore, from the LOCAL CPU read / write table shown in FIG. 8 (c2), global variables C000 and C003, which are variables to be written (variables marked with “◯” in the “R” column of the read / write table). Is assigned to the address of the second processor write area 1032 of the shared memory 1028.

  Further, the list shown in FIG. 11A is divided by the machine code generation unit 109. This division is divided into a MAIN CPU list and a LOCAL CPU list using the task name as a keyword. FIG. 11B shows a list divided for the MAIN CPU, and FIG. 11C shows a list divided for the LOCAL CPU. The machine code generation unit 111 uses the variable allocation information from the global variable allocation unit 110, compiles the divided list, and generates a program list corresponding to each processor (CPU) and a machine code of the program.

FIG. 12 shows an outline until a machine code is generated.
That is, the list in FIG. 11A is divided into a list for MAIN CPU (FIG. 11B) and a list for LOCAL CPU (FIG. 11C) by the machine code generation unit 111, and is compiled. .

  The MAIN CPU program (FIG. 8 (a1)) and the LOCAL CPU program (FIG. 8 (a2)) are stored in the MAIN CPU intermediate source (FIG. 8 (b1)) and the LOCAL CPU by the machine code generator 111. An intermediate source (FIG. 8 (b2)) is generated. From the intermediate source for MAIN CPU (FIG. 8 (b1)) and the intermediate source for LOCAL CPU (FIG. 8 (b2)), the global variable attribute generation unit 108 uses the MAIN CPU read / write table (FIG. 8 (c1)) and LOCAL. A CPU read / write table (FIG. 8C2) is generated, and the global variable allocation unit 110 allocates global variables to the addresses of the shared memory.

  In the compiling process, compiling is performed for each CPU. In this case, compiling is performed twice. For example, a program list and machine code for MAIN CPU are generated by the first compilation, and a program list and machine code for LOCAL CPU are generated by the second compilation. Since there can be a plurality of programs associated with TASK, a plurality of machine codes can be generated by one compilation.

  Next, a process of downloading the machine code generated by the machine code generation unit 111 to the programmable controller (processing of the download unit 112) will be described. As shown in FIG. 13, the machine code is downloaded to each processor of the programmable controller based on the program list for each processor (CPU) simultaneously with the machine code.

  Next, the machine code / program list comparison process (the process of the comparison unit 115) will be described. As shown in FIG. 14, the machine code 125 downloaded in the programmable controller and the program list 126 created by the programmable controller are read out by the upload process of the upload unit 114 and held in the programmable controller program creation support device. The machine code 123 and the program list 124 are compared by the comparison unit 115.

  By the comparison processing as described above in the comparison unit 115, it is possible to confirm whether the generated program is definitely downloaded when downloading to the programmable controller, and after the download, support for creating a program for the programmable controller If the program in the device has been changed, the comparison results in a mismatch, so that the change can be confirmed.

  As described above, the programmable controller program creation support apparatus of the present invention has been described in detail. However, the present invention is not limited to the above description, and various other modifications can be made without departing from the scope of the present invention. It goes without saying that the configuration or shape can be made.

101 Program Controller for Programmable Controller 102 Programmable Controller 103 GUI Unit 104 Input Unit 105 Output Unit 106 Global Variable Sheet 107 Intermediate Code Generation Unit 108 Global Variable Attribute Generation Unit 109 Read / Write Table 110 Global Variable Allocation Unit 111 Machine Code Generation Unit 112 Download unit 113 Communication interface 114 Upload unit 115 Comparison unit 121 Intermediate code 122 Program list 123, 125 Machine code 124, 126 Program list

Claims (8)

A program creation support apparatus for a programmable controller configured by a multi-CPU module including a plurality of processors and a shared memory in which an area is allocated to each processor,
Processing for displaying a dialog for a user to explicitly specify program allocation to the plurality of processors and storing a program allocation instruction by the user;
In the programmable controller, a process for displaying a dialog for the user to specify a declaration of a global variable that is a variable accessible from a plurality of programs, and storing the specification of the declaration of the global variable by the user;
A GUI part (Graphical User Interface part)
Determining whether the global variable is a read variable or a write variable for each program, and generating a global variable read / write attribute for each program;
A global variable allocation unit that allocates the global variable to the shared memory based on the program allocation instruction and the read / write attribute of the global variable;
I have a,
The global variable allocation unit allocates the global variable to a shared memory of a processor to which the program is allocated when the global variable used in the program has a write attribute. apparatus. An intermediate code generation unit that generates an intermediate code and an intermediate program list based on a program allocation instruction by a user stored in the GUI unit;
Compile the generated intermediate code, intermediate program list, and read / write attribute of global variable, and store the global variable in the shared memory based on the program assignment instruction and the read / write attribute of the global variable A machine code generation unit for generating the assigned machine code and a final program list;
The program creation support device for a programmable controller according to claim 1, comprising: The machine code generation unit divides the intermediate program list into a form including only contents corresponding to each processor based on a task name in the intermediate program list, and the intermediate code and the divided list The program creation support apparatus for a programmable controller according to claim 2 , wherein a machine code and a final program list are generated. 3. The programmable controller program creation support apparatus according to claim 2 , wherein at least one of the machine codes is generated. The programmable controller program creation support apparatus according to claim 2 , further comprising a download unit that downloads the generated machine code to each processor based on the generated final program list. Furthermore, an upload unit that uploads the machine code downloaded to the processor to the programmable controller program creation support device;
A comparison unit that compares the uploaded machine code with the machine code in the programmable controller program creation support device;
The program creation support device for a programmable controller according to claim 5, comprising: A method for performing program creation support for a programmable controller configured by a multi-CPU module including a plurality of processors and a shared memory in which an area is allocated to each processor by a computer, the computer including a processing unit A storage unit,
The processing unit is
Displaying a dialog for allowing a user to explicitly specify program allocation to each of the processors; storing program allocation instructions by the user in the storage unit;
In the programmable controller, a dialog for allowing the user to specify a declaration of a global variable that is a variable accessible from a plurality of programs is displayed, and the specification of the declaration of the global variable by the user is stored in the storage unit,
Based on a program assignment instruction and a global variable declaration specified by the user stored in the storage unit, an intermediate code and an intermediate program list are generated,
From the intermediate code and the intermediate program list, it is determined for each program whether the global variable is a read variable or a write variable, and a read / write table representing the read / write attribute of the global variable is generated for each program. And
Compile the intermediate code and intermediate program list and the read / write table said generated-out based on the read / write attribute of the program allocation instruction and the global variable, if the global variable has a writing attribute Machine code and final program list assigned to the shared memory of the processor to which the program is assigned the global variable,
Downloading the generated machine code to each processor based on the generated final program list.
A program creation support method characterized in that a program creation support for a programmable controller is performed by performing processing. Furthermore, the machine code downloaded to each processor is uploaded,
8. The program creation support method according to claim 7, wherein the uploaded machine code is compared with the downloaded machine code.