JP2008293138A - Software development support program and software development support method - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a software development support technique, capable of efficiently setting the variables of a monitoring object in debugging, or the like, of software. <P>SOLUTION: In a development tool 170 of the software development support device 100 for developing a mechanical word object 320 to be executed in a target machine 200, when collecting conditional information 350 defining a collection condition for a variable value 333 of the monitoring object variable is set by a condition monitoring function 174, a variable contained in a source code 310 under screen display is automatically selected as the monitoring object variable and is stored in monitoring object variable information 340. The monitoring object variable information 340 is set in an address list memory 253 of the target machine 200, and the variable value 333 is stored in a value-holding memory 252 when the collecting condition is established and is recovered to the software development support device 100, to be displayed together with the variable of the source code 310. <P>COPYRIGHT: (C)2009,JPO&INPIT

Description

  The present invention relates to a software development support technology, and more particularly to a technology effective when applied to a software debugging process.

  One of the debugging functions of the software development support tool is a condition monitor function. This function is a function for storing an address value to be monitored when a certain condition is satisfied and displaying the value at an arbitrary timing. The reason for debugging without stopping the program even if the condition is satisfied is that there are many states where the target machine cannot be stopped. For example, a site using a programmable logic controller (PLC) as a target machine.

  On the other hand, in the variable monitoring function, since data is periodically acquired from the target machine, the value when the condition is satisfied is not necessarily displayed. Therefore, when performing debugging, in order to confirm the logic of the program, a so-called condition monitoring function is required that holds a value at the time when a specific condition (hereinafter referred to as a sampling condition) is established.

  When executing the condition monitoring function, it is necessary to set the collection condition and the monitoring target address in the target machine in advance. When programming, the user directly described the address, the monitoring target address was specified within the address range.

  However, in order to increase the scale of software and improve development efficiency, the user programming has changed from the method of specifying by address to the method of specifying by variable. This is to improve the readability of debugging information such as variable values and improve development efficiency.

  For this reason, monitoring target designation methods have also been designated by variables (variable names) from addresses. The address of the variable is determined by the compiler when converting from source code to machine language object. Therefore, it is difficult to specify an address as a monitoring target, and the user specifies variables one by one.

  In order to hold the address value to be monitored, it is necessary to hold these values on the target machine side. However, due to restrictions such as the memory capacity of the target machine and the processing time for storing the address contents, there is an upper limit on the number of addresses that can be stored, and all variables that can be monitored cannot be registered as monitoring targets. Therefore, it is necessary to set the number of addresses to be monitored within the upper limit.

  As described above, the programming is changed from the address description to the variable name, the memory capacity of the target machine is increased, and the number of usable addresses is increased. Along with this, the number of variables to be monitored in debugging has also increased.

Therefore, there is a need for a technique for efficiently designating a variable to be monitored from among a number of variables in the source code.
In Patent Document 1, a table storing an address value corresponding to a label name described in an application program is written to a programmable logic controller in association with an executable file, and at the time of debugging, the executable file and the table are read. A technique for improving debugging efficiency by replacing an address value with a label name and displaying it is disclosed.

However, in the case of this patent document 1, the technical subject of specifying efficiently the variable of a monitoring object from many variables as mentioned above is not recognized.
On the other hand, Patent Document 2 discloses a technique in which a user program number, a step number, and a variable value are stored in a trace buffer each time a debug interrupt occurs, and the trace buffer value is read and displayed. However, even in the case of Patent Document 2, there is no recognition of the above-described technical problem of efficiently specifying a monitoring target variable from a large number of variables.
JP-A-11-338732 JP-A-7-334211

An object of the present invention is to provide a software development support technology capable of efficiently setting a variable to be monitored in software debugging or the like.
Another object of the present invention is to provide a software development support technique capable of performing efficient debugging without requiring a larger memory capacity than necessary for a target machine.

In the first aspect of the present invention, a machine language object executed on a target machine from a source code, and a correspondence relationship between a variable defined in the source code and address information of the variable in the machine language object are recorded. Processing to generate a variable address correspondence table;
Processing for extracting the variables from the source code and registering them as candidates for monitoring;
When a target to be actually monitored is selected from the monitoring target candidates, a process of registering the monitoring target candidate as a monitoring target;
In collecting the value of the variable to be monitored from the target machine, a process of registering a trigger condition as a collection condition;
Based on the variable address correspondence table, processing for specifying the address information to be monitored,
A process of transferring the machine language object and the collection condition and the address information to the target machine;
When the machine language object is executed on the target machine, the monitoring target value collected based on the collection condition is received from the target machine, and is associated with the variable based on the variable address correspondence table. Processing to display
A software development support program for causing a computer to execute the program is provided.

According to a second aspect of the present invention, in the software development support program according to the first aspect,
Provided is a software development support program for causing a computer to execute a process of registering all of the monitoring target candidates as the monitoring target when the monitoring target candidate is not designated from the monitoring target candidates.

According to a third aspect of the present invention, in the software development support program according to the first aspect or the second aspect,
Grouping the variables included in the function described in the source code, the variables displayed on the source code display screen at the time of registration of the collection conditions, or one or a plurality of the variables in advance, Provided is a software development support program for registering the variables included in a group as the monitoring target candidates.

According to a fourth aspect of the present invention, in the software development support program according to either the first aspect or the second aspect,
Furthermore, a software development support program is provided for causing the computer to execute processing for accepting setting of monitoring target valid / invalid for each unit of the registered monitoring target variable.

According to a fifth aspect of the present invention, in the software development support program according to any one of the first to fourth aspects,
The target machine provides a software development support program that is a programmable logic controller (PLC).

According to a sixth aspect of the present invention, a machine language object executed on a target machine from a source code, and a correspondence relationship between a variable defined in the source code and address information of the variable in the machine language object are recorded. Generating a variable address correspondence table;
Extracting the variables from the source code and registering them as candidates for monitoring;
Registering the monitoring target candidate as a monitoring target when a target to be actually monitored is selected from the monitoring target candidates;
In collecting the value of the monitored variable from the target machine, registering a trigger condition as a collection condition;
Identifying the address information to be monitored based on the variable address correspondence table;
Transferring the machine language object and the collection condition and the address information to the target machine;
When the machine language object is executed on the target machine, the monitoring target value collected based on the collection condition is received from the target machine, and is associated with the variable based on the variable address correspondence table. Step to display,
Software development support method including

According to a seventh aspect of the present invention, in the software development support method according to the sixth aspect,
Provided is a software development support method for registering all of the monitoring target candidates as the monitoring target when the monitoring target candidate is not designated from the monitoring target candidates.

According to an eighth aspect of the present invention, in the software development support method according to any one of the sixth aspect and the seventh aspect,
Provided is a software development support method for setting valid / invalid of a monitoring target for each unit for the registered monitoring target variable.

According to a ninth aspect of the present invention, in the software development support method according to the sixth aspect or the seventh aspect,
In the step of automatically registering the variable to be monitored, the variable included in the function described in the source code, or the variable displayed on the source code display screen when registering the sampling condition Alternatively, a software development support method for grouping one or a plurality of the variables in advance and registering the variables included in the group as candidates for the monitoring target is provided.

According to a tenth aspect of the present invention, in the software development support method according to any one of the sixth to ninth aspects,
The target machine provides a software development support method that is a programmable logic controller (PLC).

Manual registration of variables to be monitored at the time of debugging is a troublesome work. In the present invention, operability is improved so that variables can be registered efficiently.
When the user debugs, the collection condition is set across multiple source codes. Since source code is usually described for each function, variables to be monitored are registered in units of source code. However, since there is an upper limit for the number of variables to be monitored, if the upper limit is exceeded, it is necessary to reduce the number of variables to be monitored. Since it is inefficient to specify the variables to be monitored one by one, the present invention makes it possible to change the valid / invalid setting for each source code as necessary.

  The present invention can be applied to a development support tool operating on a computer. The development support tool has a program editing function, a compilation function, and a communication function. Further, it has a function of recording information for use by each function.

  The compiler function assigns variables to addresses that run on the actual target machine when compiling source code created by the user. The information is stored as a variable address correspondence table.

  When setting the collection conditions of the condition monitor, the user sets the collection conditions on the program editing function. In that case, a variable displayed on the screen is extracted by the program editing function, and the development support tool registers the extracted variable as a monitoring target variable candidate.

  The development support tool has a screen for displaying variables registered as candidates to the user as a list. This is because the variables before and after the user sets the collection conditions on the source code are often variables to be monitored by the user.

  There is an upper limit on the number of variables to be monitored. Therefore, it is necessary to keep the number of monitored variables within the upper limit. The development support tool has a screen that displays a list of candidate variables, and has a function that enables setting of valid / invalid as a monitoring target for each candidate variable on the screen (for example, a variable Check box before name to enable / disable). Further, candidate variables can be displayed for each unit (for example, variables are displayed in units of source code), and valid / invalid settings can be collectively performed for all displayed variables.

According to the present invention, it is possible to provide a software development support technology capable of efficiently setting a monitoring target variable in software debugging or the like.
In addition, it is possible to provide a software development support technology capable of performing efficient debugging without requiring a larger memory capacity than necessary for the target machine.

Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.
FIG. 1 is a block diagram showing the principle of a software development support apparatus for executing a software development support method according to an embodiment of the present invention, and FIG. 2 is a software development support apparatus and target according to an embodiment of the present invention. It is a conceptual diagram which shows the structural example of a machine.

As illustrated in FIG. 2, the programmable controller system of the present embodiment includes a software development support apparatus 100 and a target machine 200.
The software development support apparatus 100 is configured by a computer including a microprocessor 110, a main memory 120, an external storage device 130, a keyboard 141, a display 142, and a communication interface 150.

  An operating system 160 is installed in the main memory 120 as basic software, and the microprocessor 110 executes the operating system 160 to control the entire software development support apparatus 100.

In the case of the present embodiment, a development support tool 170 as software is mounted on the main memory 120.
The microprocessor 110 executes the development support tool 170 to perform various software development support processes as described below.

  That is, in the case of the present embodiment, the development support tool 170 includes a monitor function 171, a user interface function 172, a compile function 173, a condition monitor function 174, and a communication function 175 as illustrated in FIG. .

  As will be described later, the monitor function 171 uses the communication function 175 to read information on the variable value 333 corresponding to the address information 332 from the value holding memory 252 of the target machine 200 and display the value.

The user interface function 172 provides a function for editing the source code 310 and the like.
The compiling function 173 performs processing for converting the source code 310 into the machine language object 320 and processing for generating the variable-address correspondence table 330.

  The condition monitor function 174 receives a condition input from the user, performs a process of storing it in the collection condition information 350, and performs a process of automatically storing a monitoring target variable in the monitoring target variable information 340 as described later. .

The communication function 175 performs information communication with the target machine 200.
As illustrated in FIG. 2, the external storage device 130 holds a source code 310, a machine language object 320, a variable-address correspondence table 330, monitoring target variable information 340, and collection condition information 350 as files.

  The keyboard 141 and the display 142 are used for user input for controlling the software development support apparatus 100, editing of the source code 310, designation of variables to be monitored during debugging, designation of collection conditions, and the like.

The communication interface 150 executes information communication between the target machine 200 and the software development support apparatus 100 under the control of the communication function 175 described above.
FIG. 3 is a conceptual diagram illustrating a configuration example of the monitoring target variable information 340. The monitoring target variable information 340 includes a variable name 341 and a valid flag 342.

  The variable name 341 is a name given to the variable selected as the monitoring target. The valid flag 342 is a flag for temporarily validating or invalidating the selected variable name 341. This valid flag 342 is turned ON (valid) / OFF (invalid) by an operation of a valid / invalid check box 443 on a monitoring target variable list screen 440 described later.

As illustrated in FIG. 1, the collection condition information 350 is set with a collection condition 350 a that defines a trigger for collecting the variable value 333 of the monitored variable.
FIG. 4 is a conceptual diagram showing a configuration example of the variable-address correspondence table 330. The variable-address correspondence table 330 includes variable names 331 and address information 332.

  The variable name 341 is set to the variable name 341 described above. The address information 332 stores information such as “address address” that specifies the address position in the target machine 200. Therefore, the address information 332 corresponds to the address address of the variable name 331.

  On the other hand, the target machine 200 according to the present embodiment includes, for example, a programmable logic controller that controls industrial equipment. As illustrated in FIG. 2, the target machine 200 includes a general-purpose microcomputer 210, a system memory 220, a communication interface 230, and a nonvolatile memory 240.

The system memory 220 stores software and data executed by the general-purpose microcomputer 210.
The machine language object 320 received from the software development support apparatus 100 is stored in the nonvolatile memory 240.

  The communication interface 230 performs information communication with the software development support apparatus 100 via the general-purpose communication line 231. Note that the communication method between the software development support apparatus 100 and the target machine 200 is not limited to that via the general-purpose communication line 231, and may be, for example, wireless or a method via a storage medium.

  In addition, the communication interface 230 performs information communication with an unillustrated industrial device or the like that is a control target of the target machine 200 (user program 320A) that functions as a programmable logic controller via the controlled device communication line 232.

  The system memory 220 described above stores a user program 320A that is a combination of one or more machine language objects 320 stored in the non-volatile memory 240, and the user program 320A is executed by the general-purpose microcomputer 210 to be programmable. A desired function as a controller is realized.

  In this case, the system memory 220 stores programs such as a target management unit 250 and a condition determination unit 251 that manage the execution of the user program 320A and that debug the user program 320A in cooperation with the software development support apparatus 100. Has been.

Further, the system memory 220 stores a value management memory 252 and an address list memory 253 used by the target management unit 250, the condition determination unit 251.
The address list memory 253 stores one or a plurality of address information 332 corresponding to the monitoring target variable received from the monitoring function 171 of the software development support apparatus 100 and a corresponding collection condition 350a as described later. .

The value holding memory 252 records a value (variable value 333) stored in the address information 332 set in the address list memory 253 when the collection condition 350a is established.
Hereinafter, the operation at the time of debugging of the software development support apparatus 100 and the target machine 200 of the present embodiment will be described.

As described above, the development support tool 170 operates on the software development support apparatus 100 (see FIG. 2).
Next, as illustrated in FIG. 1, the development support tool 170 operates the monitor function 171, the user interface function 172 in which the user describes the source code 310, and the source code 310 created by the user on the target machine 200. A compiling function 173 for converting the machine language object 320 to be performed, a condition monitoring function 174 for setting monitoring target variable information 340 and collection condition information 350, and a communication function 175 for transmitting and receiving data between the development support tool 170 and the target machine 200. Contains.

  The monitor function 171 reads the information of the variable value 333 corresponding to the address information 332 from the value holding memory 252 of the target machine 200 using the communication function 175, and displays the value.

The source code 310 is converted into a machine language object 320 and a variable-address correspondence table 330 by the compilation function 173 of the development support tool 170.
The machine language object 320 is a collection of instructions that operate on the target machine 200, and one or a plurality of machine language objects 320 are combined to operate on the target machine 200 as a user program 320A.

  The variable-address correspondence table 330 is information on a correspondence relationship between a variable (variable name 331) described by the user on the source code 310 and the address information 332 assigned by the compilation function 173.

  The monitor function 171 displays the source code and variable values on the screen of the user interface function 172. FIG. 5 is a diagram showing an example of the monitor screen 410 displayed on the display 142 of the software development support apparatus 100 at this time.

The monitor screen 410 includes a source code display area 411, a variable value display area 412, and a sequence chart display area 413.
A source code 310 is displayed in the source code display area 411. This source code 310 is input by the user through the user interface function 172.

In the variable value display area 412, the variable value 333 read from the value holding memory 252 of the target machine 200 is displayed in a line corresponding to the variable in the source code display area 411.
That is, the variable value (variable value 333) is obtained from the variable address information table 332 created by the compile function 173 and is sent to the target management unit 250 of the target machine 200 via the communication function 175. Then, the address information 332 is notified and acquired by reading from the value holding memory 252. The acquired variable value 333 is displayed in the variable value display area 412 of the monitor screen 410 by the monitor function 171.

  In the case of the present embodiment, a sequence chart corresponding to a ladder program often used in PLC is displayed in the sequence chart display area 413 of the monitor screen 410. The machine language object 320 is programmed so as to realize a function equivalent to the ladder program described above on the target machine 200.

  By displaying the sequence chart display area 413 and the source code display area 411 simultaneously as in the monitor screen 410, the user can check the sequence chart and the source code 310 in association with each other.

  In the condition monitor function 174, the user inputs a collection condition from the monitor. FIG. 6 shows an example of a collection condition setting screen 430 that is an operation screen of the condition monitor function 174. The collection condition setting screen 430 is provided with input fields such as a condition input field 431 and a comparison data input field 432. Collection conditions set by the user using these input fields are stored in the collection condition information 350. In the example of FIG. 6, when the value of the variable reaches 100, the collection condition for collecting and storing the variable value 333 of the variable is satisfied.

As shown in FIG. 7, when the user performs an operation such as double-clicking on a target variable (here, cnt1) on the source code 310 in the source code display area 411, the condition monitoring function 174 that detects this is performed. Displays the collection condition setting screen 430 (see FIG. 6). At this time, a plurality of variables displayed on the source code in the source code display area 411 are registered in the monitoring target variable information 340.

  That is, in the case of the present embodiment, as an example, the condition monitor function 174 allows the user to double-click one of the variables or functions existing in the visible range of the source code displayed in the source code display area 411. When selected by the operation, all the variables included in the variable (function) and / or the function existing in the visible range are automatically registered in the monitoring target variable information 340.

The function is an example, and an arbitrary logical block name such as a subroutine name or a branch destination name may be used.
FIG. 8 shows an example of the monitoring target variable list screen 440. The monitoring target variable list screen 440 includes a variable display field 441 and an instance display field 442. Since cnt and cnt1 are displayed as variables on the source code in the source code display area 411 (see FIG. 7), these can be registered as variables to be monitored. An existing mechanism is used for the variable extraction technique. For example, a method of associating the position of the source code with a variable at the time of compilation, a method of parsing the displayed source code 310 and extracting a character string of the variable name 341, or the like is used.

  Since a variable that can be registered as a monitoring target has an upper limit, the upper limit is checked when the condition monitor function 174 is executed. If the upper limit is exceeded, an error warning message 449 or the like as illustrated in FIG. 9 is displayed on the monitoring target variable list screen 440, and a condition monitor that collects the variable value 333 of the variable based on the collection condition Can not be implemented.

  If it is within the upper limit, the condition monitor is executed. As a method of deleting the monitoring target variable, the deletion target variable is selected and deleted from the variable list on the monitoring target variable list screen 440 illustrated in FIG. In most cases, since the monitoring target variable changes for each source code, a list of variables is displayed for each screen as in the monitoring target variable list screen 440 of FIG. 10 so that all variables can be selected and deleted.

If a registered variable is deleted, a complicated operation for re-registering is required. Therefore, in order to improve operability, each registered variable is allowed to have a valid / invalid state.
For example, in the monitoring target variable list screen 440 illustrated in FIG. 10, a valid / invalid check box 443 is provided corresponding to the display position of each variable at the left end of the screen, and this valid / invalid check box 443 is checked. When it is, it indicates that it is valid, and when it is off, it indicates that it is invalid. In addition to the delete all button, buttons such as an all valid button 444 and an all invalid button 445 are added, and when these buttons are pressed, the valid / invalid state of each variable is changed. That is, the valid flag 342 of the monitoring target variable information 340 is set. Variables to be monitored are those in which the valid flag 342 is valid.

  The development support tool 170 acquires variable address information 332 from the monitored variable (variable name 331) using the variable-address correspondence table 330. The acquired address information 332 and collection condition information 350 are transmitted to the target machine 200 by the communication function 175.

The target machine 200 holds the information in the address list memory 253. The target machine 200 performs a condition satisfaction test by the condition determination unit 251 during execution of the machine language object 320 (the user program 320A configured by the machine language object 320). When the condition is satisfied, the value (variable value 333) at the monitoring target address in the user program 320A is stored from the address information 332 of the monitoring target variable set in the address list memory 253.

The monitor function 171 periodically monitors the state of the target machine 200, and reads data stored in the value holding memory 252 when the condition is satisfied.
The monitor function 171 displays information for distinguishing between normal display (display of values read from the target machine 200 periodically) and display when the condition is satisfied. For example, a character string (message 452) indicating that the condition is satisfied in the status bar 451 and the condition monitor is stopped as in the display example of the condition satisfaction display screen 450 illustrated in FIG. “Condition monitor is stopped”) is displayed.

  In the case of condition monitoring, values other than the addresses of variables registered as monitoring targets are undefined. Therefore, it is displayed on the screen that the values of the variables other than the registered values are indefinite. For example, a variable registered as a monitoring target displays a variable value 333, and other variables display “????” as an indefinite character string 414 as in the source code display screen 420 illustrated in FIG. indicate.

FIG. 13 is a diagram illustrating a series of cooperative operations at the time of debugging in the software development support apparatus 100 and the target machine 200 according to the present embodiment.
On the software development support apparatus 100 side, the user interface function 172 of the development support tool 170 creates / edits the source code 310 by receiving input from the user (step 601).

  Next, in accordance with an instruction from the user, the compiling function 173 generates a machine language object 320 and a variable-address correspondence table 330 from the source code 310 (step 602).

  Next, the condition monitoring function 174 accepts an instruction input from the user, sets the collection condition information 350, registers the monitoring target variable candidate linked to the setting, and the user selects the monitoring target from the candidates. If not, all candidates for monitoring are selected as monitoring targets (step 603).

  Then, the monitor function 171 of the development support tool 170 includes the machine language object 320, the collection condition information 350, and the address information 332 (address value in the machine language object 320) corresponding to the monitored variable (variable name 331). Is sent to the target machine 200 (step 604).

  The target management unit 250 of the target machine 200 stores the machine language object 320 received from the software development support apparatus 100 in the nonvolatile memory 240, and stores the collection condition information 350 and the address information 332 in the address list memory 253 (step 701). ).

  Thereafter, when the execution instruction of the user program 320A for debugging is transmitted from the software development support apparatus 100 side to the target machine 200 (step 605), the target management unit 250 of the target machine 200 that has received the instruction A user program 320A is generated from the machine language object 320 stored in the nonvolatile memory 240, loaded into the system memory 220, and the user program 320A is activated (step 702).

Then, the condition determination unit 251 determines whether or not the collection condition of the collection condition information 350 set in the address list memory 253 is satisfied while monitoring the execution state of the user program 320A (step 703). In this case, the address value (variable value 333) of the user program 320A corresponding to the address information 332 registered in the address list memory 253 is collected and stored in the value holding memory 252 (step 704).

  On the other hand, the development support tool 170 of the software development support apparatus 100 periodically inquires and monitors the target management unit 250 whether or not the collection condition information 350 is established in the target machine 200 (step 606).

  Similarly, the target management unit 250 of the target machine 200 monitors the presence / absence of a transfer instruction (step 606) of the variable value 333 from the software development support apparatus 100 side (step 705), and when the transfer instruction is detected. Transfers the pair information of the address information 332 and the variable value 333 stored in the value holding memory 252 to the monitor function 171 of the software development support apparatus 100 (step 706).

  Then, the monitor function 171 of the software development support apparatus 100 uses the variable information based on the address information 332 out of the pair information of the address information 332 and the variable value 333 sent from the target machine 200 side in Step 706 described above. The address correspondence table 330 is searched to identify the corresponding variable name 331, the condition satisfaction display screen 450 illustrated in FIG. 11 is displayed on the display 142, and the source code 310 displayed in the source code display area 411 is displayed. The variable value 333 is output to the variable value display area 412 at the position corresponding to the display line of the corresponding variable name 331.

Further, as described above, a message 452 is output to the status bar 451 of the condition establishment display screen 450 to distinguish it from the periodic display.
The target management unit 250 on the target machine 200 side monitors the completion of execution of the user program 320A (step 707), and notifies the development support tool 170 of the software development support apparatus 100 when the execution is completed (step 708).

  In the example of FIG. 13 described above, prior to the start of the user program 320A in the target machine 200, the address information 332 and the collection condition 350a are transferred to the target machine 200 side in advance and set in the address list memory 253. Although an example of performing debugging has been shown, the present invention is not limited thereto, and debugging can be performed by setting the address information 332 and the collection condition 350a in the target machine 200 at any time after the start of the user program 320A in the target machine 200.

Such an example is shown in the flowchart of FIG. Differences from FIG. 13 described above are as follows.
In other words, in the flowchart of FIG. 14, the software development support apparatus 100 transmits a machine language object 320 to the target machine 200 (step 604A), gives an execution command, and includes a user including the machine language object 320. After starting the execution of the program 320A (step 702) (step 605), the input of the sampling condition 350a is accepted from the keyboard 141 as needed (step 603A), and is transmitted to the target machine 200 together with the corresponding address information 332 ( Step 604B) is different from the flowchart of FIG. 13 described above in that debugging is performed in the address list memory 253.

  The flowchart of FIG. 14 has an advantage that debugging can be continued without interrupting execution of the user program 320A by changing the collection condition 350a and the like even during execution of the user program 320A in the target machine 200.

  As described above, in the software development support apparatus 100 of the present embodiment, when debugging the machine language object 320 (user program 320A) executed on the target machine 200 using the development support tool 170, for example, When the collection condition information 350 is set in the condition monitor function 174 of the development support tool 170, the variable of the source code 310 being displayed in the source code display area 411 is automatically registered as a monitoring target variable.

As a result, the usability of the development support tool 170 is remarkably improved as compared with the case where variables to be monitored are manually specified one by one.
Furthermore, if the amount of the source code 310 increases, it is necessary to verify the source code 310 at a plurality of locations. If the position of the source code 310 to be verified changes, it is also necessary to change the monitoring target variable. Therefore, the debugging efficiency of the user is improved by automatically registering the variable to be monitored as in the development support tool 170 of the present embodiment.

  Further, by sending the address information 332 of the variable to be monitored from the development support tool 170 of the software development support apparatus 100 to the target machine 200 and setting it in the address list memory 253, the target machine 200 can debug the user program 320A. Only the variable value 333 corresponding to the address information 332 set in the address list memory 253 needs to be stored in the value holding memory 252.

  Thereby, the capacity of the value holding memory 252 and the address list memory 253 can be saved as compared with the case where the values of many variables included in the user program 320A are comprehensively recorded in the trace memory or the like.

  That is, it is possible to efficiently debug the user program 320A including the machine language object 320 without requiring a larger memory capacity than necessary for the target machine 200.

Needless to say, the present invention is not limited to the configuration exemplified in the above-described embodiment, and various modifications can be made without departing from the spirit of the present invention.
For example, in the above-described embodiment, the programmable logic controller has been described as an example of the target machine. However, the present invention can be widely applied to debugging of software installed in a general information processing apparatus, a control device, or the like.

It is a block diagram which shows the principle of the software development assistance apparatus which implements the software development assistance method which is one embodiment of this invention. It is a conceptual diagram which shows the structural example of the software development assistance apparatus which is one embodiment of this invention, and a target machine. It is a conceptual diagram which shows the structural example of the monitoring object variable information used with the software development assistance apparatus which is one embodiment of this invention. It is a conceptual diagram which shows the structural example of the variable-address correspondence table used with the software development assistance apparatus which is one embodiment of this invention. It is a figure which shows an example of the monitor screen of the development assistance tool which is one embodiment of this invention. It is a figure which shows an example of the collection condition setting screen of the development assistance tool which is one embodiment of this invention. It is a figure which shows an example of the source code display screen of the development assistance tool which is one embodiment of this invention. It is a figure which shows an example of the monitoring object variable list screen of the development assistance tool which is one embodiment of this invention. It is a figure which shows an example of the monitoring object variable list screen at the time of the error generation of the development assistance tool which is one embodiment of this invention. It is a figure which shows an example of the monitoring object variable list screen of the development assistance tool which is one embodiment of this invention. It is a figure which shows an example of the display screen when the conditions of the development assistance tool which is one embodiment of this invention are satisfied. It is a figure which shows an example of the source code display screen of the development assistance tool which is one embodiment of this invention. It is a figure which shows the relationship of the cooperation operation | movement at the time of debugging in the software development assistance apparatus which is one embodiment of this invention, and a target machine. It is a figure which shows the modification of the relationship of the cooperation operation | movement at the time of debugging in the software development assistance apparatus which is one embodiment of this invention, and a target machine.

Explanation of symbols

DESCRIPTION OF SYMBOLS 100 Software development support apparatus 110 Microprocessor 120 Main memory 130 External storage device 141 Keyboard 142 Display 150 Communication interface 160 Operating system 170 Development support tool 171 Monitor function 172 User interface function 173 Compile function 174 Condition monitor function 175 Communication function 200 Target machine 210 General-purpose microcomputer 220 System memory 230 Communication interface 231 General-purpose communication line 232 Controlled device communication line 240 Non-volatile memory 250 Target management unit 251 Condition determination unit 252 Value holding memory 253 Address list memory 310 Source code 320 Machine language object 320A User program 330 Variable- Address correspondence table 331 Variable name 332 Add Less information 333 Variable value 340 Monitoring target variable information 341 Variable name 342 Valid flag 350 Collection condition information 350a Collection condition 410 Monitor screen 411 Source code display area 412 Variable value display area 413 Sequence chart display area 414 Undefined character string 420 Source code display screen 430 Collection condition setting screen 431 Condition input field 432 Comparison data input field 440 Monitoring target variable list screen 441 Variable display field 442 Instance display field 443 Valid / invalid check box 444 All valid button 445 All invalid button 449 Error warning message 450 When condition is satisfied Display screen 451 Status bar 452 Message

Claims (10)

Processing for generating a machine language object to be executed on a target machine from a source code, and a variable address correspondence table in which a correspondence relationship between a variable defined in the source code and address information of the variable in the machine language object is recorded; ,
Processing for extracting the variables from the source code and registering them as candidates for monitoring;
When a target to be actually monitored is selected from the monitoring target candidates, a process of registering the monitoring target candidate as a monitoring target;
In collecting the value of the variable to be monitored from the target machine, a process of registering a trigger condition as a collection condition;
Based on the variable address correspondence table, processing for specifying the address information to be monitored,
A process of transferring the machine language object and the collection condition and the address information to the target machine;
When the machine language object is executed on the target machine, the monitoring target value collected based on the collection condition is received from the target machine, and is associated with the variable based on the variable address correspondence table. Processing to display
A software development support program characterized by causing a computer to execute. The software development support program according to claim 1,
A software development support program for causing a computer to execute a process of registering all candidates for a monitoring target as the monitoring target when a target to be actually monitored is not designated from the monitoring target candidates. In the software development support program according to claim 1 or 2,
Grouping the variables included in the function described in the source code, the variables displayed on the source code display screen at the time of registration of the collection conditions, or one or a plurality of the variables in advance, A software development support program, wherein the variables included in a group are registered as candidates for the monitoring target. In the software development support program according to claim 1 or 2,
Further, a software development support program for causing the computer to execute a process of accepting the setting of valid / invalid of the monitoring target for each unit with respect to the registered monitoring target variable. In the software development support program according to any one of claims 1 to 4,
A software development support program, wherein the target machine is a programmable logic controller (PLC). Generating from a source code a machine language object to be executed on a target machine, and a variable address correspondence table in which a correspondence between a variable defined in the source code and address information of the variable in the machine language object is recorded; ,
Extracting the variables from the source code and registering them as candidates for monitoring;
Registering the monitoring target candidate as a monitoring target when a target to be actually monitored is selected from the monitoring target candidates;
In collecting the value of the monitored variable from the target machine, registering a trigger condition as a collection condition;
Identifying the address information to be monitored based on the variable address correspondence table;
Transferring the machine language object and the collection condition and the address information to the target machine;
When the machine language object is executed on the target machine, the monitoring target value collected based on the collection condition is received from the target machine, and is associated with the variable based on the variable address correspondence table. Step to display,
A software development support method comprising: The software development support method according to claim 6,
A software development support method, comprising: registering all of the monitoring target candidates as the monitoring target when an actual monitoring target is not designated from the monitoring target candidates. The software development support method according to any one of claims 6 and 7,
A software development support method comprising: setting valid / invalid of a monitoring target for each unit for the registered variable of the monitoring target. The software development support method according to any one of claims 6 and 7,
In the step of automatically registering the variable to be monitored, the variable included in the function described in the source code, or the variable displayed on the source code display screen when registering the sampling condition Or a software development support method, wherein one or a plurality of the variables are grouped in advance, and the variables included in the group are registered as candidates for the monitoring target. The software development support method according to any one of claims 6 to 9,
A software development support method, wherein the target machine is a programmable logic controller (PLC).