JP6045986B2 - Software development support apparatus, software development support method, and software development support program - Google Patents

Description

  The present invention relates to a software development support apparatus, a software development support method, and a software development support program that support the development of software used by being incorporated in industrial equipment such as an inverter that controls driving of a motor.

  Conventionally, as a technology for developing software for use in industrial equipment such as inverters that control motor drive, based on a block diagram that describes the specifications of the software to be developed using multiple program elements In addition, a technique for automatically generating a source code of a program constituting the software in a predetermined computer language is known (for example, see Patent Document 1).

  A CPU (Central Processing Unit) included in a device to be incorporated is required to have real-time characteristics, but is not as high-performance as a CPU included in a recent personal computer and is not easily exchanged. For this reason, for the CPU included in the device to be embedded, there are restrictions on the memory capacity such as ROM (Read Only Memory) and RAM (Random Access Memory) connected to the CPU and the processing time of the CPU. Is common.

JP 2006-285480 A

  It can be easily determined when the compiler compiles the source code and generates the object file whether or not the above-mentioned CPU constraints are satisfied. On the other hand, whether or not the constraint on the processing time is satisfied requires information such as the processing capability of the CPU that executes the program when making the determination, and cannot be determined on the compiler side.

  Therefore, it is conceivable to calculate the processing time of the CPU that executes the program. In order to calculate the processing time of a CPU, it is necessary to actually operate a device to be incorporated provided with the CPU. However, in this case, there is a possibility that the device to be incorporated is operated under a situation where the calculation target program does not satisfy the restriction on the processing time of the CPU, and the device is put into an inappropriate operation state. There was a risk of it.

  The present invention has been made in view of the above, and when developing software to be incorporated into a device to be incorporated, software that enables development without causing the device to enter an inappropriate operating state It is an object to provide a development support apparatus, a software development support method, and a software development support program.

  In order to solve the above-described problems and achieve the object, a software development support apparatus according to the present invention is a software development support apparatus that supports development of software that is incorporated in a device to be embedded and operates a CPU included in the device. A compile unit that converts source code written in a predetermined computer language into machine language, and the number of instructions included in the machine language converted by the compile unit Accordingly, a processing time calculation unit that calculates a processing time when the CPU executes the program, and whether or not the CPU can execute the program based on the processing time calculated by the processing time calculation unit is determined. And a determination unit.

  The software development support apparatus according to the present invention further includes a CPU setting unit that sets a constraint processing time that gives a constraint on a processing time required for the CPU to execute the program in the above invention, and the determination unit includes the processing time By comparing the processing time calculated by the calculation unit with the constraint processing time set by the CPU setting unit, it is determined whether or not the CPU can execute the program.

The software development support device according to the present invention is the above invention, wherein the CPU setting unit is
The operation clock number of the CPU is further set, and the processing time calculation unit calculates a total execution clock number from all the extracted instruction numbers, and the total execution clock number and the operation clock number set by the CPU setting unit The processing time is calculated based on the above.

  The software development support apparatus according to the present invention provides a software development support apparatus according to the above invention, wherein when the determination unit determines that the CPU cannot execute the program, the processing of the program can be executed within the constraint processing time. It is further characterized by further comprising a dividing unit that divides the task.

  The software development support device according to the present invention is characterized in that, in the above-mentioned invention, the software development support device further includes a display unit for displaying the result determined by the determination unit and the result of division by the division unit.

  In the software development support device according to the present invention, in the above invention, the display unit displays a block diagram describing the specifications of the software using a plurality of program elements, and in the block diagram, the plurality of program elements Each of these is displayed so as to be identifiable as to which of the plurality of tasks is included.

  The software development support device according to the present invention is characterized in that, in the above invention, the software development support device further comprises a display unit for displaying a result determined by the determination unit.

  A software development support method according to the present invention is a software development support method performed by a software development support apparatus that supports development of software for operating a CPU included in a device to be incorporated into a device to be embedded. A source code of the source code, a compile step for reading the source code from a storage unit storing the source code described in a predetermined computer language and converting it into a machine language, and the number of instructions included in the machine language converted in the compile step A processing time calculation step for calculating a processing time when the CPU executes the program by extracting the CPU, and whether the CPU can execute the program based on the processing time calculated in the processing time calculation step A determination step for determining The features.

  A software development support program according to the present invention is a source code of a program constituting the software in a software development support apparatus that supports the development of software that is incorporated in a device to be embedded and operates a CPU included in the device. A compile step of reading the source code from a storage unit storing source code described in a predetermined computer language and converting it into a machine language, and extracting the number of instructions included in the machine language converted in the compile step A processing time calculating step for calculating a processing time when the CPU executes the program; a determining step for determining whether or not the CPU can execute the program based on the processing time calculated in the processing time calculating step; , Is executed.

  According to the present invention, in order to determine whether or not a CPU included in a device to be embedded can execute the program based on a processing time when the program is executed, software to be embedded in the device to be embedded is developed. In this case, development can be performed without causing the device to enter an inappropriate operating state.

FIG. 1 is a block diagram showing a functional configuration of a software development support apparatus according to an embodiment of the present invention. FIG. 2 is a diagram showing a configuration example of a display screen displayed by the display unit of the software development support apparatus according to the embodiment of the present invention. FIG. 3 is a diagram showing a display example of a pull-down menu of a CPU setting button on the display unit of the software development support apparatus according to the embodiment of the present invention. FIG. 4 is a diagram showing a display example of a pull-down menu of the compile button on the display unit of the software development support apparatus according to the embodiment of the present invention. FIG. 5 is a diagram showing a display example of a pull-down menu of a processing time confirmation button on the display unit of the software development support apparatus according to the embodiment of the present invention. FIG. 6 is a flowchart showing an outline of software development processing performed using the software development support apparatus according to the embodiment of the present invention. FIG. 7 is a diagram schematically showing a display example of a block diagram in the display unit of the software development support apparatus according to the embodiment of the present invention. FIG. 8 is a diagram illustrating an example (first example) of a display screen on which the display unit of the software development support apparatus according to the embodiment of the present invention displays the determination result. FIG. 9 is a diagram illustrating an example (second example) of a display screen on which the display unit of the software development support apparatus according to the embodiment of the present invention displays the determination result. FIG. 10 is a diagram illustrating an example of a display screen displayed on the display unit after the division unit divides the task in the software development support apparatus according to the embodiment of the present invention. FIG. 11 is a diagram illustrating an example of task management source code generated by the source code generation unit when the division unit divides a task in the software development support apparatus according to the embodiment of the present invention. FIG. 12 is a diagram illustrating an example of task management source code generated by the source code generation unit when the processing time satisfies the constraint condition in the software development support device according to the embodiment of the present invention. FIG. 13 is a diagram illustrating an example of a display screen displayed on the display unit after the division unit of the software development support apparatus according to the modification of the present embodiment divides the task. FIG. 14 is a block diagram showing a functional configuration of a software development support apparatus according to another embodiment of the present invention.

  DESCRIPTION OF EMBODIMENTS Hereinafter, embodiments for carrying out the present invention (hereinafter referred to as “embodiments”) will be described with reference to the accompanying drawings.

  FIG. 1 is a block diagram showing a functional configuration of a software development support apparatus according to an embodiment of the present invention. A software development support apparatus 1 shown in FIG. 1 is an apparatus that supports the development of software used by being incorporated in industrial equipment such as an inverter that controls driving of a motor. The software development support device 1 is configured using a control unit 2 that controls the overall operation of the device, a storage unit 3 that stores various types of information, and an interface such as a keyboard, a mouse, and a touch panel. And a display unit 5 having a display panel made of liquid crystal, organic EL (Electro Luminescence), or the like, and displaying various kinds of information.

  The control unit 2 includes a block diagram creation unit 21 that creates a block diagram that describes the specifications of the software to be developed based on information input from the input unit 4 with the program elements stored in the storage unit 3 as basic components, A source code generation unit 22 that generates a source code of a program according to a block diagram created by the block diagram creation unit 21, and a CPU setting unit 23 that sets a CPU (hereinafter referred to as a target CPU) included in a target device into which software is to be incorporated The target CPU performs processing at a fixed cycle based on the object file generated by the compiling unit 24 that generates the object file by converting the source code generated by the source code generating unit 22 into machine language. A processing time calculation unit 25 for calculating a processing time required for processing, A determination unit 26 that determines whether or not the processing time calculated by the time calculation unit 25 is a processing time that can be executed by the target CPU, and a process that can be executed by the target CPU as a result of the determination by the determination unit 26 When it is not time, it has the division part 27 which divides | segments the task in a program so that the constraints of target CPU may be satisfied.

  The block diagram creation unit 21 is software such as an editor. The user selects a program element with the input unit 4 while viewing the screen displayed on the display unit 5, and sets and inputs connection information between the selected program elements. Instructs drawing. The block diagram creation unit 21 stores the created block diagram in the storage unit 3 (a block diagram storage unit 32 described later).

  The source code generation unit 22 generates source code in a predetermined computer language such as C language in accordance with the block diagram created by the block diagram creation unit 21, and stores it in the storage unit 3 (source code storage unit 33 described later). To do. The source code generation unit 22 generates a source code of a task management function for managing tasks included in the program (hereinafter referred to as task management source code) and stores it in the source code storage unit 33.

  The CPU setting unit 23 stores, in the storage unit 3 (a CPU information storage unit 34 to be described later), CPU information that is set by using the target CPU clock number and the processing time limit value as constraint conditions, in addition to the target CPU type.

  The processing time calculation unit 25 extracts the number of machine language instructions from the object file generated by the compilation unit 24, and calculates the total number of execution clocks based on the number of execution clocks corresponding to the number of instructions. Thereafter, the processing time calculation unit 25 calculates the processing time using the calculated total number of execution clocks and the clock number set by the CPU setting unit 23, and stores the calculation result in the storage unit 3 (a processing time information storage unit 36 described later). ).

  The determination unit 26 compares the processing time calculated by the processing time calculation unit 25 with the constraint processing time that restricts the processing time set by the CPU setting unit 23, so that the target CPU can execute the program with the processing time. It is determined whether or not.

  When the processing time is larger than the constraint processing time as a result of the determination by the determination unit 26, the dividing unit 27 divides the program processing into a plurality of tasks that are executed at regular intervals, and stores the information of the divided source code in the storage unit 3 (The division information storage unit 37 described later) stores the information.

Hereinafter, an example of the dividing process performed by the dividing unit 27 will be specifically described.
The dividing unit 27 is a program element that is connected by a connection line until the constraint processing time of the target CPU is exceeded with reference to the program element at the last stage (or the first stage) among the program elements constituting the block diagram corresponding to the source code. Follow the steps to accumulate the processing time. Thereby, the program elements before the constraint processing time is exceeded are divided as one task. The dividing unit 27 executes the processing described here until the processing times of all program elements are accumulated.
As described above, since the dividing unit 27 divides the task in consideration of the processing order of the program elements, the processing time of each task can be prevented from exceeding the constraint processing time, and a logical failure occurs. Tasks can be divided in such a way that they are not allowed.

  When the dividing unit 27 performs the dividing process, if there are a plurality of program elements immediately before (or immediately after) the reference program element, any one processing time may be added up. All processing times may be integrated. Further, when there are a plurality of ways of dividing a task, the dividing unit 27 may preferentially select the one with a smaller number of divisions, or a standard when the processing time for each task is a population. You may make it select preferentially the method of a division | segmentation with a small deviation.

  The control unit 2 having the above functional configuration is realized by using a CPU or the like, and is connected to each component of the software development support apparatus 1 via a bus line. The control unit 2 reads out various types of information stored and stored in the storage unit 3 from the storage unit 3, thereby executing arithmetic processing related to the software development support method according to the present embodiment.

  Next, the functional configuration of the storage unit 3 will be described. The storage unit 3 includes a program element storage unit 31 that stores program elements, a block diagram storage unit 32 that stores a block diagram created by the block diagram creation unit 21, and source code and task management generated by the source code generation unit 22. A source code storage unit 33 for storing source code, a CPU information storage unit 34 for storing information on the target CPU set by the CPU setting unit 23, and an object file storage unit 35 for storing an object file generated by the compilation unit 24 The processing time information storage unit 36 stores information related to the processing time calculated by the processing time calculation unit 25, and the division information storage unit 37 stores division information including the result of dividing the program by the division unit 27.

  The storage unit 3 includes a ROM in which a software development support program according to the present embodiment, a program for starting a predetermined OS (Operating System), and the like are stored in advance, and a RAM in which calculation parameters and data of each process are stored. To be realized. The various programs described above can also be obtained by downloading via a communication network. The communication network here is realized by, for example, a local area network (LAN), a wide area network (WAN), a public line network, etc., and may be wired or wireless.

  Next, the functional configuration of the display unit 5 will be described. FIG. 2 is a diagram illustrating a configuration example of a display screen displayed by the display unit 5. In the display screen 100 shown in the figure, as a menu button that can be selected by the user via the input unit 4, a file button 101 for inputting various file operations in the block diagram, and selection of program elements constituting the block diagram are displayed. A program element selection button 102 to perform, a connection button 103 for setting connection between program elements, a source code generation button 104 for instructing creation of a source code based on a block diagram, a CPU setting button 105 for setting a target CPU, and a source code A compile button 106 for instructing compilation and a processing time confirmation button 107 for confirming the processing time and performing processing according to the confirmation result are displayed.

  The user selects and inputs an operation to be performed by the software development support apparatus 1 by clicking the mouse button after aligning the mouse pointer with the display position of the button corresponding to the desired operation using the mouse of the input unit 4. To do. Hereinafter, the operation of clicking the mouse button after aligning the mouse pointer is simply referred to as clicking.

  FIG. 3 is a diagram illustrating a display example of a pull-down menu of the CPU setting button 105. When the CPU setting button 105 is clicked, “CPU selection”, “CPU clock number”, and “CPU constraint processing time” are displayed as pull-down menus. Among these, when “CPU selection” is clicked, selectable target CPU types are displayed as a pull-down menu in a lower layer (not shown). On the other hand, a box for inputting the number of clocks is displayed in “CPU clock number”, and a box for inputting the processing time is displayed in “CPU constraint processing time”. The user inputs a desired number of clocks and constraint processing time into the corresponding boxes by the input unit 4. Information set using the CPU setting button 105 is stored in the CPU information storage unit 34 by the CPU setting unit 23.

  FIG. 4 is a diagram illustrating a display example of a pull-down menu of the compile button 106. When the compile button 106 is clicked, “Compile execution”, “Compilation result confirmation”, and “Compile setting” are displayed as pull-down menus.

  FIG. 5 is a diagram illustrating a display example of a pull-down menu of the processing time confirmation button 107. When the processing time confirmation button 107 is clicked, “processing time confirmation”, “task division execution”, “task management source code generation”, and “task management source code storage” are displayed as pull-down menus.

  The software development support apparatus 1 having the above functional configuration may be realized by using one computer or may be realized by using a plurality of computers. In the latter case, it is also possible to perform processing in cooperation with each other while transmitting and receiving data via a communication network. In addition, the computer here can be comprised by a general purpose personal computer, a server, etc. When the software development support apparatus 1 is configured by a client / server system including a plurality of computers via a communication network, the functions of the input unit 4 and the display unit 5 are provided in the client terminal, while the control unit 2 and It is good also as a structure which equips one or several server with the function of the memory | storage part 3. FIG.

  Next, software development processing performed using the software development support apparatus 1 will be described. FIG. 6 is a flowchart showing an outline of software development processing performed using the software development support apparatus 1. First, the block diagram creating unit 21 creates a block diagram based on the program elements and connection lines input via the input unit 4 by the user, and stores the created block diagram in the block diagram storage unit 32 (step S1). . The user uses the program element selection button 102 displayed on the display screen 100 shown in FIG. 2 to select a program element, and uses the connection button 103 to select a connection line that connects the program elements.

  FIG. 7 is a diagram schematically illustrating a display example of a block diagram on the display unit 5. A block diagram 201 displayed on the display screen 200 shown in the figure includes six program elements 211 to 216 and five connection lines 221 to 225 indicating connection relations between program elements. Each program element displays a function name and an identification ID. For example, the program element 211 has a function name A and an ID F001. In addition, an ID for identification is displayed on each connection line. For example, the ID of the connection line 221 is W001. In addition, you may add the figure which expresses a function concretely in the box of each program element.

  A more specific configuration of the block diagram 201 will be described. The block diagram 201 indicates that the processing proceeds from the left to the right of the display screen 200 as is apparent from the directions of the arrows of the connection lines 221 to 225. Two program elements 211 and 214 are provided in the foremost stage of the block diagram 201, while a program element 216 is provided in the last stage of the block diagram 201. In the block diagram 201, there are a process flow of program element 211 → program element 212 → program element 213 → program element 216 and a process flow of program element 214 → program element 215 → program element 216.

The program element 211 is connected to the program element 212 (function name: B, ID: F002) via a connection line 221 extending from itself.
The program element 212 is connected to the program element 213 (function name: C, ID: F003) via a connection line 222 (ID: W002) extending from itself.
The program element 213 is connected to the program element 216 (function name: F, ID: F006) via a connection line 223 (ID: W003) extending from itself.
The program element 214 (function name: D, ID: F004) is connected to the program element 215 (function name: E, ID: F005) via a connection line 224 (ID: W004) extending from itself.
The program element 215 is connected to the program element 216 via a connection line 225 (ID: W005) extending from itself.

  After step S1, the source code generation unit 22 generates source code corresponding to the block diagram created by the block diagram creation unit 21 according to the input of the source code generation instruction signal via the input unit 4 by the user, Store in the source code storage unit 33 (step S2). As described above, this source code is generated by a computer language such as C language.

  Subsequently, the CPU setting unit 23 performs setting input of the target CPU in accordance with the input through the input unit 4 by the user (step S3). After the user clicks the CPU setting button 105 to display a pull-down menu (see FIG. 3), the user selects the type of the target CPU and inputs the number of clocks and the constraint processing time through the input unit 4.

  Thereafter, the compiling unit 24 reads the source code from the source code storage unit 33 in response to the input of the compile instruction signal via the input unit 4 by the user, converts the read source code into a machine language, and converts the object file into Generate (step S4). When causing the software development support apparatus 1 to execute the compile processing, the user clicks the compile button 106 to display a pull-down menu, and then clicks “compile execution” (see FIG. 4). When the user confirms the compilation result, it is only necessary to click “Compilation Result Confirmation” in the pull-down menu shown in FIG. When the user confirms or changes the compile setting, the user may click the “compile setting” in the pull-down menu shown in FIG. 4 to display the setting screen and perform the setting.

  Subsequently, the processing time calculation unit 25 calculates the processing time of the generated object file in response to the input of the processing time calculation instruction signal by the user via the input unit 4, and the calculation result is stored in the processing time information storage unit 36. Store (step S5). Specifically, the processing time calculation unit 25 extracts the number of machine language instructions from the object file, calculates the total number of execution clocks corresponding to the number of instructions, and then calculates the total execution clock number and the CPU information storage unit 34. Is used to calculate the processing time. When causing the processing time calculation unit 25 to execute this processing, the user clicks the processing time confirmation button 107 to display a pull-down menu (see FIG. 5), and then clicks the “processing time confirmation” menu.

  Subsequently, the determination unit 26 determines whether the processing time satisfies the constraint condition by comparing the processing time calculated by the processing time calculation unit 25 with the constraint processing time stored in the CPU information storage unit 34. (Step S6). Specifically, when the processing time is smaller than the constraint processing time, the determination unit 26 determines that the processing time satisfies the constraint condition. On the other hand, when the processing time is equal to or greater than the constraint processing time, Judge that it does not meet.

  Then, the display part 5 displays the determination result of the determination part 26 (step S7). FIG. 8 is a diagram illustrating an example (first example) of a display screen on which the display unit 5 displays the determination result. In the display screen 300 shown in the figure, the block diagram 201 displays the number of instructions in the program elements 211 to 216 and the calculation result display boxes 231 to 236 of the processing time in association with each other.

Specifically, the calculation result display box 231 corresponding to the program element 211 displays the number of instructions 200 and the processing time 100 μs as the calculation results.
The calculation result display box 232 corresponding to the program element 212 displays the number of instructions 160 and the processing time of 80 μs.
The calculation result display box 233 corresponding to the program element 213 displays the number of instructions 80 and the processing time 40 μs.
In the calculation result display box 234 corresponding to the program element 214, the number of instructions 120 and the processing time 60 μs are displayed.
In the calculation result display box 235 corresponding to the program element 215, the number of instructions 100 and the processing time 50 μs are displayed.
In the calculation result display box 236 corresponding to the program element 216, the number of instructions 200 and the processing time 100 μs are displayed.

In the lower part of the display screen 300, a processing time analysis result table 301 representing processing time analysis results and constraint information 302 representing information related to the constraint conditions of the target CPU are displayed.
The processing time analysis result table 301 indicates the program elements for each task, the number of instructions corresponding to the program elements and the processing time, and the total processing time for each task (processing time for each task ID). In the processing time analysis result table 301, six program elements 211 to 216 are included in one task (task ID: 1), and processing time by task ID 430 μs is displayed. In addition, the total number of instructions 860 of the program elements 211 to 216 is also displayed.
The constraint information 302 includes a constraint processing time (500 μs), a task division number (1), and a determination result (OK). Among these, the determination result is a result determined by the determination unit 26 based on the comparison between the task ID processing time (430 μs) and the constraint processing time (500 μs). That is, as shown in the display screen 300, since the processing time for each task ID is shorter than the constraint processing time, the determination unit 26 determines that the processing time for each task ID as the processing time is a processing time that can be executed by the target CPU. .

  As the intermediate state in the middle of the transition of the display content on the display unit 5 from the display screen 100 to the display screen 300, calculation result display boxes 231 to 236 indicating the results calculated by the processing time calculation unit 25 in step S5 are displayed. The display unit 5 may display a display screen in a state where the processing time analysis result table 301 and the constraint information 302 are not displayed.

  FIG. 9 is a diagram illustrating an example (second example) of a display screen on which the display unit 5 displays the determination result. The display screen 400 shown in the figure is different from the display screen 300 described above (see FIG. 8) in the display contents of the constraint information 401. On the display screen 400, the constraint processing time included in the constraint information 401 is 200 μs, and the task ID processing time (430 μs) is longer than the constraint processing time. In this case, since the determination unit 26 determines that the processing time for each task ID cannot be executed by the target CPU, the determination result included in the constraint information 401 is displayed as “NG”.

  As a result of the determination by the determination unit 26, when the processing time of the target CPU does not satisfy the constraint condition (step S8: No), the dividing unit 27 executes the program according to the input of the division instruction via the input unit 4 by the user. The task is divided, and the division result is stored in the division information storage unit 37 (step S9). When causing the dividing unit 27 to execute this processing, the user clicks the processing time confirmation button 107 to display a pull-down menu (see FIG. 5), and then clicks the “execute task division” menu.

Thereafter, the display unit 5 displays the division result of the division unit 27 (step S10). FIG. 10 is a diagram illustrating an example of a display screen displayed on the display unit 5 after the division unit 27 divides the task. A display screen 410 shown in the figure shows a display example after the dividing unit 27 performs the dividing process in a state where the display unit 5 displays the display screen 400 shown in FIG. 9.
In FIG. 10, the processing time analysis result table 411 indicates that the six program elements 211 to 216 are divided into three tasks (task IDs: 1 to 3). Specifically, the processing time analysis result table 411 includes the program elements 211 and 212 as one task (task ID: 1), the program elements 213 and 214 as another task (task ID: 2), and the program element 215. 216 is a further task (task ID: 3), and the program is divided into three tasks.
Further, the processing time analysis result table 411 displays a task having a task ID of 2 in a mode (shaded) different from the other two tasks. For this reason, the user who has seen the processing time analysis result table 411 can clearly understand how to divide tasks.

  In the case shown in FIG. 10, by dividing the program task into three, the processing time for each task ID is 180 μs for the task ID = 1, 100 μs for the task ID = 2, and 100 μs for the task ID = 3. 150 μs, and the processing time for each task ID is shorter than the constraint processing time (200 μs) in all tasks. Therefore, in the constraint information 412, the determination result is displayed as “OK”.

  In the present embodiment, when the dividing unit 27 divides the task, the processing time is also determined. However, the determining unit 26 uses the result of dividing the task by the dividing unit 27 to target again. Whether or not the CPU can execute the program may be determined.

  In step S11 following step S10 described above, the source code generation unit 22 generates a task management source code in response to a task management source code generation instruction via the input unit 4 by the user, and the generated task management source The code is stored in the source code storage unit 33 (step S11). After this step S11, the software development support apparatus 1 ends a series of processes.

  The process of step S11 will be specifically described. When the task is divided in step S10, the source code generation unit 22 generates source code of a task management function that manages the divided task so that the process is performed for each divided task. When the source code generation unit 22 executes this processing, the user clicks the processing time confirmation button 107 to display a pull-down menu (see FIG. 5), and then clicks the “task management source code generation” menu. Thereafter, the user confirms the contents of the task management source code generated by the source code generation unit 22, and if there is no problem, click “save task management source code” displayed in the pull-down menu of the processing time confirmation button 107. Thus, the task management source code is stored in the source code storage unit 33. In step S11, after the source code generation unit 22 generates the task management source code, the generated task management source code is automatically stored in the source code storage unit 33 without waiting for an instruction from the user. May be.

  FIG. 11 is a diagram illustrating an example of task management source code generated by the source code generation unit 22 when the division unit 27 divides a task. The task management source code 500 shown in the figure is described using C language. Specifically, in the task management source code 500, the first task (case 0) is composed of program elements 211 (ID: F001) and 212 (ID: F002) with a switch statement, and the task ID is set to 1. The second task (case 1) is composed of program elements 213 (ID: F003) and 214 (ID: F004), the task ID is 2, and the third task (case 2) is program element 215 ( ID: F005) and 216 (ID: F006), and the task ID is set to 3.

  Here, the case where the processing time satisfies the constraint condition as a result of the determination by the determination unit 26 in step S8 (step S8: Yes) will be described. In this case, the software development support device 1 proceeds to step S11 (task management source code generation processing). FIG. 12 is a diagram illustrating an example of task management source code generated by the source code generation unit 22 in Step S11 when the processing time satisfies the constraint condition as a result of the determination by the determination unit 26. The task management source code 600 shown in the figure forms one task with six program elements 211 to 216 (ID: F001 to F006).

  When the dividing unit 27 divides the task, when the software is incorporated into the device to be incorporated, the source code is converted into an execution format for each task and incorporated.

  According to the embodiment of the present invention described above, the processing time when the target CPU executes the program is calculated, and whether or not the target CPU can execute the program constituting the software based on the processing time is determined. In order to make a determination, the target CPU need not be operated if the program does not satisfy the processing time constraint in the target CPU. Therefore, when developing software to be incorporated into a device to be incorporated, development can be performed without causing the device to enter an inappropriate operating state.

  Further, according to the present embodiment, when it is determined that one program cannot be executed by the target CPU, the processing of the program is divided into a plurality of tasks that can be processed within the restricted processing time. Therefore, software capable of reliably operating the target CPU within the restricted processing time can be developed.

  Further, according to the present embodiment, since the determination result is displayed on the display unit after determining whether or not the target CPU can execute the program, the user can clearly grasp the determination result.

  FIG. 13 is a diagram illustrating an example (second example) of a display screen displayed on the display unit 5 after the division unit 27 divides a task as a modification of the present embodiment. In the display screen 700 shown in the figure, in the block diagram 701, combinations of program elements for each divided task are clearly shown. Specifically, the closed region T1 surrounds the program elements 211 and 212 constituting the task with the task ID = 1, and the closed region T2 surrounds the program elements 213 and 214 constituting the task with the task ID = 2. The program elements 215 and 216 constituting the task with ID = 3 are displayed in a manner surrounded by the closed region T3. Here, the three closed regions T1 to T3 are closed regions that do not intersect each other. In this way, by clearly indicating the method of task division in the block diagram 701, the user can recognize the task division more easily and intuitively.

  Instead of specifying the combination of program elements for each task by enclosing it in a closed area, the color of the line of the program element box may be changed for each task, or the program element box may be different for each task. You may fill with.

Up to this point, the mode for carrying out the present invention has been described. However, the present invention should not be limited only by the above-described embodiment.
FIG. 14 is a block diagram showing a functional configuration of a software development support apparatus according to another embodiment of the present invention. The software development support apparatus 11 shown in the figure has the same functional configuration as that of the software development support apparatus 1 except that the control unit 12 does not have a division unit and the storage unit 13 does not have a division information storage unit. Have. In the software development support device 11, the determination unit 26 determines whether the processing time calculated by the processing time calculation unit 25 satisfies the constraint condition, and the display unit 5 displays the determination result (OK / NG). It has a function. According to such a software development support apparatus 11, the user can easily recognize whether or not the development object file satisfies the constraint condition.

  In the present invention, the software development support apparatus may not include the input unit and / or the display unit. In this case, a function similar to that of the above-described embodiment may be realized by connecting an external input device and / or display device to the software development support device.

  Further, in the present invention, for example, the target CPU may be set at a stage before creating a block diagram. In this case, when creating a block diagram, it is possible to prevent creation of a block diagram that does not satisfy the constraint conditions. Therefore, the user can create a block diagram while confirming the constraint conditions.

  In the present invention, the created block diagram can be applied to another target CPU. In this case, based on the information of the target CPU newly set by the CPU setting unit 23, the determination unit 26 may determine whether or not the program can be executed on the new target CPU.

  Further, the computer language applicable in the present invention is not limited to the C language, but a ladder language, a structured language (ST language), a UML (Unified Modeling Language), a BASIC, and the like applied to a PLC (Programmable Logic Controller). An assembly language or the like may be used.

  Further, the software development support program according to the present invention can be recorded on a computer-readable recording medium such as a hard disk, a flash memory, a CD-ROM, a DVD-ROM, or a flexible disk and widely distributed. The writing of the software development support program according to the present invention to the above-described recording medium may be performed when the recording medium is shipped as a product, or may be performed by downloading via a communication network.

  The order of the steps in the flowcharts referred to in this specification is merely an example, and can be changed without departing from the spirit of the present invention and logically consistent.

  Thus, the present invention can include various embodiments and the like not described herein, and various design changes and the like can be made without departing from the technical idea specified by the claims. It is possible to apply.

DESCRIPTION OF SYMBOLS 1,11 Software development support apparatus 2,12 Control part 3,13 Storage part 4 Input part 5 Display part 21 Block diagram preparation part 22 Source code generation part 23 CPU setting part 24 Compiling part 25 Processing time calculation part 26 Judgment part 27 Division | segmentation Unit 31 Program element storage unit 32 Block diagram storage unit 33 Source code storage unit 34 CPU information storage unit 35 Object file storage unit 36 Processing time information storage unit 37 Division information storage unit 100, 200, 300, 400, 410, 700 Display screen DESCRIPTION OF SYMBOLS 101 File button 102 Program element selection button 103 Connection button 104 Source code generation button 105 CPU setting button 106 Compile button 107 Processing time confirmation button 201,701 Block diagram 211,212,213,214,215,21 Program element 221, 222, 223, 224, 225 Connection line 231, 232, 233, 234, 235, 236 Calculation result display box 301, 411 Processing time analysis result table 302, 401, 412 Constraint information 500, 600 Task management source code T1, T2, T3 closed region

Claims (5)

In a software development support apparatus that supports the development of software that operates a CPU included in a device to be incorporated into the device to be embedded,
A compiling unit that converts source code written in a predetermined computer language into machine language, which is a source code of a program constituting the software;
A processing time calculating unit that calculates a processing time when the CPU executes the program by extracting the number of instructions included in the machine language converted by the compiling unit;
A CPU setting unit for setting a constraint processing time that gives a constraint on a processing time required for the CPU to execute the program;
A determination unit that determines whether the CPU can execute the program by comparing the processing time calculated by the processing time calculation unit and the constraint processing time set by the CPU setting unit;
An input unit that accepts input of information;
When the determination unit determines that the CPU cannot execute the program, the input unit inputs a division instruction that divides the processing of the program into a plurality of tasks that can be executed within the constraint processing time, respectively. A division unit that divides the processing of the program into the plurality of tasks,
A display unit for displaying the constraint processing time and a result determined by the determination unit;
Equipped with a,
The display unit
In a case where the determination result by the determination unit is NO, when the division unit performs processing, the software development support device displays the plurality of tasks in an identifiable manner as a result of division by the division unit . The CPU setting unit
Further setting the number of operating clocks of the CPU,
The processing time calculation unit
The total execution clock number is calculated from all the extracted numbers of instructions, and the processing time is calculated based on the total execution clock number and the operation clock number set by the CPU setting unit. software development support apparatus according to 1. The display unit
Displaying a block diagram describing the software specifications using a plurality of program elements, displaying the calculation result of the processing time calculation unit in association with each program element,
Each of the previous SL plurality of program element, a software development support system according to claim 1 or 2, characterized in that identifiably displayed or contained in any of the plurality of tasks. In a software development support method performed by a software development support apparatus that supports development of software that operates a CPU included in a device to be incorporated into the device to be embedded,
A compiling step of reading the source code from a storage unit that stores source code of a program constituting the software and described in a predetermined computer language, and converting the read source code into a machine language;
A processing time calculating step for calculating a processing time when the CPU executes the program by extracting the number of instructions included in the machine language converted in the compiling step;
Determining whether to allow the CPU to execute the program by comparing the processing time calculated in the processing time calculating step with a constraint processing time that imposes a constraint on a processing time required for the CPU to execute the program Steps,
A determination result display step for displaying the constraint processing time and the result determined in the determination step;
When it is determined in the determination step that the CPU cannot execute the program, and an input of a division instruction for dividing the program processing into a plurality of tasks that can be executed within the constraint processing time is received. A division step of dividing the processing of the program into the plurality of tasks;
In a case where the determination result of the determination step is NO, when the division step performs processing, a division result display step for displaying the plurality of tasks in an identifiable manner as a result of the division step division;
A software development support method characterized by comprising: In a software development support apparatus that supports the development of software that operates in the CPU included in the device to be incorporated into the device to be embedded,
A compiling step of reading the source code from a storage unit that stores source code of a program constituting the software and described in a predetermined computer language, and converting the read source code into a machine language;
A processing time calculating step for calculating a processing time when the CPU executes the program by extracting the number of instructions included in the machine language converted in the compiling step;
Determining whether to allow the CPU to execute the program by comparing the processing time calculated in the processing time calculating step with a constraint processing time that imposes a constraint on a processing time required for the CPU to execute the program Steps,
A determination result display step for displaying the constraint processing time and the result determined in the determination step;
When it is determined in the determination step that the CPU cannot execute the program, and an input of a division instruction for dividing the program processing into a plurality of tasks that can be executed within the constraint processing time is received. A division step of dividing the processing of the program into the plurality of tasks;
In a case where the determination result of the determination step is NO, when the division step performs processing, a division result display step for displaying the plurality of tasks in an identifiable manner as a result of the division step division;
A software development support program characterized by causing

Images