JP2021072097A - Execution program, input support program, and code-reading robot - Google Patents

Abstract

To provide an execution program, an input support program and a code-reading robot, which reduce time and effort required to create software robots that operate efficiently.SOLUTION: An RPA execution program 121 of a code-reading robot makes a computer perform processes of: reading code data 124 created to allow a design drawing conforming to UML to be displayed; detecting a keyword included in the code data 124; calling an operation program 123 corresponding to the detected keyword; and executing the called operation program 123.SELECTED DRAWING: Figure 2

Description

Embodiments of the present invention relate to an execution program, an input support program, and a code-reading robot.

In recent years, RPA (Robotic Process Automation) has been attracting attention in order to improve the efficiency and automation of office work. RPA is realized, for example, by operating a software robot (also referred to as an RPA application) on a computer. A software robot is constructed based on, for example, a procedure in which a human operates a computer to perform a business.

Software robots are generally coded using, for example, RPA tools. In order to create a software robot that operates efficiently, it is desirable to design the operation performed by the software robot in detail before coding. However, when trying to design the operation in detail, for example, a design drawing is first created, and then coding is performed with reference to the created design drawing.

JP-A-2019-74889

As described above, when trying to create a software robot that operates efficiently, it takes time and effort to create a design drawing and then code while referring to the design drawing.

Therefore, the purpose is to reduce the time and effort required to create a software robot that operates efficiently.

The execution program according to the present invention causes a computer to execute a process of reading code data created so that a design drawing conforming to UML can be displayed and a process of executing an operation program corresponding to a keyword included in the code data. ..

Further, the input support program according to the present invention causes a computer to execute a process of supporting input of a keyword of an execution program that executes the code data when creating code data capable of displaying a design drawing in accordance with UML.

Further, the code-reading robot according to the present invention includes an execution program that causes a computer to execute an operation program corresponding to a keyword included in code data created so that a design drawing conforming to UML can be displayed.

FIG. 1 is a block diagram showing a functional configuration of the signal processing device according to the present embodiment. FIG. 2 is a diagram for explaining the operation of the RPA execution unit and the drawing unit shown in FIG. FIG. 3 is a diagram showing code data. FIG. 4 is a sequence diagram in which the code data shown in FIG. 3 is drawn by PlantUML. FIG. 5 is a diagram showing the transportation cost .xlsx used in FIGS. 3 and 4. FIG. 6 is a diagram showing a display example of a display device when the code reading type robot according to the present embodiment executes an operation. FIG. 7 is a diagram showing a display example of a display device when the code reading type robot according to the present embodiment executes an operation. FIG. 8 is a diagram showing a display example of a display device when the code reading type robot according to the present embodiment executes an operation. FIG. 9 is a diagram showing a display example of a display device when the code reading type robot according to the present embodiment executes an operation. FIG. 10 is a diagram showing a display example of a display device when the code reading type robot according to the present embodiment executes an operation. FIG. 11 is a diagram showing a display example of a display device when the code reading type robot according to the present embodiment executes an operation. FIG. 12 is a diagram showing some other examples of code data. FIG. 13 is a diagram showing some other examples of code data.

Hereinafter, embodiments will be described with reference to the drawings.

FIG. 1 is a block diagram showing an example of a functional configuration of the signal processing device 1 according to the present embodiment. The signal processing device 1 is realized by, for example, a personal computer, a server, or the like.

The signal processing device 1 shown in FIG. 1 includes, for example, a processing unit 11, a storage unit 12, an input interface 13, an output interface 14, and a communication interface 15. The processing unit 11, the storage unit 12, the input interface 13, the output interface 14, and the communication interface 15 are connected to each other so as to be able to communicate with each other via, for example, a bus.

The processing unit 11 is composed of, for example, a CPU (Central Processing Unit) and a RAM (Random Access Memory) used as a main storage device when the CPU executes processing. The CPU, for example, realizes various functions corresponding to the program by reading the program stored in the storage unit 12 into the RAM and executing the program.

The storage unit 12 is a so-called auxiliary storage device including an HDD (hard disk drive) for storing various information and a non-volatile storage circuit such as an SSD (solid state drive). The storage unit 12 may be a drive device or the like that reads and writes various information to and from a portable storage medium such as a CD-ROM, a DVD, and a flash memory.

The storage unit 12 stores a program according to the present embodiment, for example, an RPA execution program 121. The RPA execution program 121 is a program for executing the operation specified in the code data 124 based on the text-based code data 124. The RPA execution program 121 executes, for example, an operation program corresponding to a predetermined keyword included in the code data 124. The keyword may be defined by the RPA execution program 121, or may be defined by being stored in the storage unit 12. The keyword is, for example, textual information that can identify the action to be performed. Further, the keyword may be text information that can identify the referent. Further, the storage unit 12 stores a drawing program 122 for designing and drawing a design drawing with a text-based code. In the present embodiment, the design drawing represents, for example, a sequence diagram according to UML (Unified Modeling Language). The RPA execution program 121 may be understood as, for example, a program that extends the functions of the drawing program 122. Further, the storage unit 12 stores the operation program 123 associated with the preset keyword.

The operation program 123 is, for example, a program in which a simple single operation is defined, and is stored for each operation. The operation program 123 includes, for example, an operation program for displaying a data file on a screen, an operation program for accessing the Internet, an operation program for displaying a web screen, an operation program for extracting a predetermined value, and the like. An operation program for inputting a predetermined value, an operation program for clicking a predetermined position, an operation program for returning text information of a predetermined position to a data file, and / or an operation program for storing a data file, etc. included. The operation program 123 is not limited to these, and may include an operation program required for a desired software robot. The operation program 123 may be arbitrarily adjusted as needed.

The RPA execution program 121, the drawing program 122, the operation program 123, or a combination thereof is stored and distributed in, for example, a non-transient storage medium, and is read out from the non-transient storage medium. It may be installed in the storage unit 12. Further, the RPA execution program 121, the drawing program 122, the operation program 123, or any combination thereof may be downloaded from a predetermined server and installed in the storage unit 12, for example. Further, the RPA execution program 121, the drawing program 122, the operation program 123, or a combination thereof may be stored in advance in the storage unit 12.

Further, the storage unit 12 stores the code data 124. The code data 124 is text-based data. The code data 124 describes, for example, a design drawing for visualizing the operation of the software robot in a language in a format corresponding to the drawing program 122. Further, the code data 124 is described so as to include, for example, a control statement corresponding to the RPA execution program 121 and a keyword for executing the operation program 123. Software robots can also be referred to as, for example, event-driven applications. The code data 124 is created by the user, for example, and stored in the storage unit 12. The code data 124 may be stored in the storage unit 12 via a predetermined storage medium, or may be stored in the storage unit 12 via a predetermined server.

Further, the storage unit 12 stores input data 125 used as an input when the software robot executes an operation. The input data 125 may be provided together with the RPA execution program 121, or may be provided separately from the RPA execution program 121. In addition, the storage unit 12 stores the result data created by the operation of the software robot.

The input interface 13 is realized by, for example, a mouse, a keyboard, a touch panel on which instructions are input by touching the operation surface, and the like. The input interface 13 converts an input instruction from the operator into an electric signal, and outputs the electric signal to the processing unit 11. The input interface 13 is not limited to physical operation devices such as a mouse and a keyboard. The input interface 13 may include, for example, a receiving port that receives an electric signal input from an external input device.

The output interface 14 is realized by, for example, a display device, a printing device, or the like. As the display device, any display such as a liquid crystal display, an organic EL display, an LED display, a plasma display, and a CRT display can be used. The display device displays image data about the display target. The printing device is, for example, a printer. The printing device prints image data about the printing target on a predetermined sheet of paper. The output interface 14 is not limited to physical output devices such as display devices and printing devices. The output interface 14 may include, for example, a transmission port for transmitting image data to an external output device.

The communication interface 15 is realized by, for example, a circuit connected to a network. The communication interface 15 communicates with, for example, a predetermined server, another signal processing device, or the like via a network.

The processing unit 11 shown in FIG. 1 realizes a function corresponding to the program by executing the program stored in the storage unit 12. For example, the processing unit 11 realizes the functions of the RPA execution unit 111 and the drawing unit 112 by executing the program.

The processing unit 11 shown in FIG. 1 may be formed by combining a plurality of CPUs. That is, the RPA execution unit 111 and the drawing unit 112 shown in FIG. 1 may be realized, for example, by each CPU executing a program.

Further, the processing unit 11 may be formed by a dedicated hardware configuration having the functions of the RPA execution unit 111 and the drawing unit 112, respectively. Further, the processing unit 11 is an integrated circuit for a specific application (Application Specific Integrated Circuit: ASIC) incorporating a dedicated hardware circuit having the functions of the RPA execution unit 111 and the drawing unit 112, respectively, and a field programmable gate array. (Field Programmable Gate Array: FPGA), another complex programmable logic device (CPLD), or a simple programmable logic device (SPLD) may be formed.

The RPA execution unit 111 executes processing according to the code data 124 stored in the storage unit 12. For example, the RPA execution unit 111 executes the operation program 123 stored in the storage unit 12 based on the control statement and the keyword included in the code data 124.

The drawing unit 112 creates a design drawing based on the code data 124 stored in the storage unit 12. The drawing unit 112 causes, for example, a display device to display the created design drawing.

FIG. 2 is a schematic diagram for explaining the operation of the RPA execution unit 111 and the drawing unit 112 shown in FIG.

When creating the code data 124, for example, the user defines the requirements required of the software robot to be created. The user designs the functionality to meet the defined requirements. Then, the user creates the code data 124 in the language according to the drawing program 122 in order to visualize the detailed operation for realizing the designed function with the design drawing according to UML. Further, since the user executes the code data 124 using the RPA execution program 121, the user creates the code data 124 so as to include a control statement according to the RPA execution program 121 and a keyword for executing the operation program 123. To do. The control statement according to the RPA execution program 121 is, for example, the same as or associated with the control statement according to the drawing program 122. The user stores the created code data 124 in the storage unit 12.

When the code data 124 is created, the user inputs a visualization instruction of the design drawing based on the code data 124 via the input interface 13 of the signal processing device 1. When the visualization instruction is input, the processing unit 11 executes the drawing program 122 and functions as the drawing unit 112. The drawing unit 112 creates, for example, a sequence diagram as a design drawing based on the code data 124, and displays the created sequence diagram on the display device as the output interface 14.

The user confirms the operation of the software robot based on the displayed sequence diagram. The user modifies the text of the code data 124 if the sequence diagram needs to be modified. When the text is modified, the drawing unit 112 creates a sequence diagram based on the modified code data 124, and displays the created sequence diagram on the display device. The sequence diagram may be displayed in response to the visualization instruction of the sequence diagram based on the modified code data 124. The user repeats the modification and drawing of the code data 124 until a sequence diagram for the software robot that executes the desired operation is created.

The processing unit 11 functions as the RPA execution unit 111 according to an instruction from the user or a preset schedule. The RPA execution unit 111 reads the designated code data 124 from the storage unit 12 and executes processing according to the code data 124. For example, the RPA execution unit 111 calls the operation program 123 stored in the storage unit 12 based on the control statement and the keyword included in the code data 124. The RPA execution unit 111 executes the called operation program 123.

More specifically, for example, the RPA execution unit 111 reads the code data 124 line by line, and detects the control statement and / or the keyword written in the read line. The RPA execution unit 111 determines, for example, the execution subject or the object of the operation based on the detected keyword. Further, the RPA execution unit 111 reads the operation program 123 associated with the detected keyword from the storage unit 12, and executes the read operation program 123 based on the determined subject and object, the keyword, and the like. The RPA execution unit 111 reads the code data 124 according to the detected control statement, and repeats the process until the last line of the code data 124.

In this way, the code data 124 is read into the RPA execution program 121, and the RPA execution program 121 and the operation program 123 are executed to form a code reading robot as a software robot.

Next, the operation of the code-reading robot will be described in detail. In the following example, a case where, for example, PlantUML, which is an open source tool, is used as the drawing program 122 will be described as an example. In addition, it is not limited to PlantUML, and any drawing program 122 such as Visual studio code (registered trademark) may be used as long as a design drawing can be designed and drawn with a text-based code.

FIG. 3 is a diagram showing an example of code data 124 used in the following description. The code data 124 shown in FIG. 3 is a code for drawing a sequence diagram of a software robot that acquires transportation expenses and creates a file in which the acquired transportation expenses are written. The code data 124 is described in accordance with the language defined by PlantUML, and is stored in the storage unit 12, for example, as code data .pu. FIG. 4 is a sequence diagram in which the code data 124 shown in FIG. 3 is drawn by PlantUML.

In the description of FIGS. 3 and 4, the input data 125 is an Excel file named transportation cost .xlsx. Transportation cost .xlsx is stored in "C: \ app \ input", for example. FIG. 5 is a diagram showing an example of transportation cost .xlsx used in FIGS. 3 and 4. In the input data 125 shown in FIG. 5, records are registered for each column, and each record has items of date, boarding station, getting-off station, and transportation cost. Of these, the date and station name are entered in the date, boarding station, and getting-off station, respectively.

6 to 11 are schematic views showing a display example of a display device when the code reading robot according to the present embodiment executes an operation.

First, for example, as shown in FIG. 6, the code reading robot execution window 142 is displayed on the display screen 141. The user specifies the code data .pu from a predetermined storage folder, and throws the code data .pu into the execution window 142 by, for example, a drag-and-drop operation of the mouse. At this time, for example, the file name: "code data.pu" may be directly entered in the execution window 142 by using the keyboard. When the code data .pu is selected and the robot execution button 143 is pressed by the user, the RPA execution unit 111 starts operation.

For example, the RPA execution unit 111 reads the code data 124 shown in FIG. 3, and sets the code data .pu as the “Robot” as the execution subject based on the control statement of “box… actor… as Robot end box”. Further, the RPA execution unit 111 sets the transportation cost .xlsx stored in C: \ app \ input as "InputF" as the first object based on the control statement of "box ... partial ... as InputF end box". .. In addition, the RPA execution unit 111 sets the transportation cost input .xlsx stored in C: \ app \ output as "OnputF" as the second object based on the control statement of "box ... partial ... as OuputF end box". To do. In addition, the RPA execution unit 111 uses the transfer information accessed at https://transit.xxxx.co.jp as the third object "Web" based on the control statement of "box ... partial ... as Web end box". And. That is, in the RPA execution unit 111, the "Robot" as the execution subject has the transportation cost .xlsx ("InputF" as the first object), the transportation cost input .xlsx ("OnputF" as the second object), and / Or operates to execute processing for transfer information (“Web” as a third object).

The RPA execution unit 111 reads "Robot-> InputF: workbooks.open ()" of the code data 124, and acquires the operation object: "InputF" from the keyword before ":": "Robot-> InputF". .. The RPA execution unit 111 reads from the storage unit 12 an operation program for displaying a data file on the screen, which corresponds to the keyword: "workbooks.open ()" after ":". In addition, "Robot-> InputF" before ":" is a description in accordance with the rules of plantUML, and indicates that it is an instruction from Robot to InputF. “Workbooks.open ()” after “:” is a description defined as a keyword in the RPA execution program 121 according to the present embodiment. The RPA execution unit 111 executes the read operation program with "InputF", that is, the transportation cost .xlsx as the display target. As a result, the transportation cost .xlsx is displayed on the display screen 141 as shown in FIG.

The RPA execution unit 111 reads "Robot-> Web: ie start ()" of the code data 124, and acquires the object of operation: "Web" from the keyword: "Robot-> Web" before ":". The RPA execution unit 111 reads from the storage unit 12 an operation program for accessing the Internet using Internet Explorer (registered trademark) corresponding to the keyword: “ie activation ()” after “:”. The RPA execution unit 111 executes the read operation program using the “Web”, that is, the transfer information as the connection destination. This will allow you to access https://transit.xxxx.co.jp using Internet Explorer.

The RPA execution unit 111 reads "Web-> Web: DisplayStandby" of the code data 124, and acquires the object of operation: "Web" from the keyword: "Web->Web" before ":". The RPA execution unit 111 reads from the storage unit 12 an operation program for displaying the web screen after the screen transition, which corresponds to the keyword: "DisplayStandby" after the ":".
The RPA execution unit 111 executes the read operation program with the "Web", that is, the transfer information as the display target. As a result, the transfer information is displayed on the display screen 141 as shown in FIG.

The RPA execution unit 111 reads "Robot <-InputF: (black square) Values ← scope (Range [date] (2))" of the code data 124, and the keyword before ":": "Robot <-InputF" Object of action from: Get "Input F". The RPA execution unit 111 reads from the storage unit 12 an operation program for extracting a predetermined value corresponding to the keyword: “(black square) Values ← scope ()” after “:”. In this embodiment, (black square) Values represent variables. The RPA execution unit 111 executes the read operation program with the keyword: "Range [date] (2)" in the "InputF" determined as the object, that is, the transportation cost .xlsx, as the extraction target. As a result, "2" to "4", which are the lines in which the value is entered in the date of transportation cost .xlsx, are extracted as "(black square) Values".

The RPA execution unit 111 reads the code data 124 “loop (black square) X = MinRow ((black square) Values) to MaxRow ((black square) Values)… end”. The RPA execution unit 111 performs processing from loop to end based on the control statement of "loop (black square) X = MinRow ((black square) Values) to MaxRow ((black square) Values) ... end" (black). Repeat from the smallest row of (square) Values to the largest row of (black square) Values.

The RPA execution unit 111 reads "InputF-> Web: Range [boarding station] ((black square) X) → input (Name [from] (0))" of the code data 124, and the keyword before ":" : Get the object of operation from "InputF-> Web": "InputF" and "Web" and the direction of operation. The RPA execution unit 111 is an operation for inputting a predetermined value of a data file to a predetermined location on the web screen corresponding to the keyword: "_ ((black square) X) → input ()" after ":". The program is read from the storage unit 12. The RPA execution unit 111 inputs "InputF", that is, the character "(black square) X" of the keyword: "Range [boarding station]" in the transportation cost .xlsx. Then, the RPA execution unit 111 positions the position defined by the keyword: "Name [from] (0)" in accordance with "Web", that is, Javascript (registered trademark) of HTML (HyperText Markup Language) in the transfer guidance. The read operation program is executed as the input position. As a result, the station name of the first line: "Rokucho" in the "boarding station" of the transportation cost .xlsx is input to "departure" in the transfer guide.

The RPA execution unit 111 reads "InputF-> Web: Range [getting off station] ((black square) X) → input (Name [to] (0))" of the code data 124, and the keyword before ":" : Get the object of operation from "InputF-> Web": "InputF" and "Web" and the direction of operation. The RPA execution unit 111 is an operation for inputting a predetermined value of a data file to a predetermined location on the web screen corresponding to the keyword: "_ ((black square) X) → input ()" after ":". The program is read from the storage unit 12. The RPA execution unit 111 inputs "InputF", that is, the character "(black square) X" of the keyword: "Range [getting off station]" in the transportation cost .xlsx. Then, the RPA execution unit 111 executes the read operation program with the position defined by the keyword "Name [to] (0)" in accordance with HTML Javascript in the "Web", that is, the transfer guidance as the input position. To do. As a result, the station name of the first line: "Kamiyacho" in the "getting off station" of the transportation cost .xlsx is input to "arrival" in the transfer guide.

The RPA execution unit 111 reads "Robot-> Web: click (Id [searchModuleSubmit])" of the code data 124, and reads the operation object: "Web" from the keyword before ":": "Robot-> Web". get. The RPA execution unit 111 reads from the storage unit 12 an operation program for clicking a predetermined position on the web screen, which corresponds to the keyword: “click ()” after the “:”. The RPA execution unit 111 executes the read operation program with the target position defined by the keyword: "Id [searchModuleSubmit]" according to the HTML Javascript in the "Web", that is, the transfer guidance. As a result, the search button 144 in the transfer guidance is pressed.

The RPA execution unit 111 reads "Web-> Web: DisplayStandby" of the code data 124, and acquires the object of operation: "Web" from the keyword: "Web->Web" before ":". The RPA execution unit 111 reads from the storage unit 12 an operation program for displaying the web screen after the screen transition, which corresponds to the keyword: "DisplayStandby" after the ":".
The RPA execution unit 111 executes the read operation program with the "Web", that is, the transfer information as the display target. As a result, as shown in FIG. 9, the search button 144 is pressed, and the transfer information after the screen transition is displayed on the display screen 141.

The RPA execution unit 111 reads "Robot-> Web: click (ClassName [icnPriFare] (0) .parentElement.parentElement)" of the code data 124, and operates from the keyword before ":": "Robot-> Web". Object: Get the "Web". The RPA execution unit 111 reads from the storage unit 12 an operation program for clicking a predetermined position on the web screen, which corresponds to the keyword: “click ()” after the “:”. The RPA execution unit 111 reads out the "Web", that is, the position specified by the keyword "(ClassName [icnPriFare] (0) .parentElement.parentElement)" according to HTML Javascript in the transfer guidance as the target position. Execute the operation program. As a result, the price order tab 145 in the transfer guide shown in FIG. 9 is pressed.

The RPA execution unit 111 reads "Web-> Web: DisplayStandby" of the code data 124, and acquires the object of operation: "Web" from the keyword: "Web->Web" before ":". The RPA execution unit 111 reads from the storage unit 12 an operation program for displaying the web screen after the screen transition, which corresponds to the keyword: "DisplayStandby" after the ":".
The RPA execution unit 111 executes the read operation program with the "Web", that is, the transfer information as the display target. As a result, as shown in FIG. 10, the price order tab 145 is pressed, and the transfer information after the screen transition is displayed on the display screen 141.

The RPA execution unit 111 reads "InputF <-Web: Range [transportation cost] ((black square) X) ← Get (ClassName [mark] .innerText (* yen *))" of the code data 124, and ":" Earlier keywords: Get the object of action: "InputF" and "Web" from "InputF <-Web" and the direction of action. The RPA execution unit 111 is an operation for inputting text information at a predetermined position on the web screen into a data file corresponding to the keyword: "_ ((black square) X) ← Get ()" after ":". The program is read from the storage unit 12. The RPA execution unit 111 has a "Web", that is, a "circle" within the position defined by the keyword: "ClassName [mark] .innerText (* circle *)" according to HTML Javascript in the transfer guidance. The text that is included is the input target. Then, the RPA execution unit 111 executes the read operation program with "InputF", that is, the "(black square) X" field of the keyword: Range [transportation cost] in the transportation cost .xlsx as the input position. As a result, as shown in FIG. 10, the "442" yen in the transfer guidance route 1 is input as the value of the "transportation cost" of the transportation cost .xlsx.

The RPA execution unit 111 reads "Robot-> Web: click (tags [A] .href (https://transit.xxxx.co.jp/))" of the code data 124, and the keyword before ":" : Get the action object: "Web" from "Robot-> Web". The RPA execution unit 111 reads from the storage unit 12 an operation program for clicking a predetermined position on the web screen, which corresponds to the keyword: “click ()” after the “:”. The RPA execution unit 111 uses the position specified by the keyword: "tags [A]" as the input position, and the link destination: "https: // transit." Execute the read operation program with "xxxx.co.jp/" as the input target. As a result, the transition to the initial screen of the transfer guidance is made.

The RPA execution unit 111 reads "Web-> Web: DisplayStandby" of the code data 124, and acquires the object of operation: "Web" from the keyword: "Web-> Web" before ":". The RPA execution unit 111 reads from the storage unit 12 an operation program for displaying the web screen after the screen transition, which corresponds to the keyword: "DisplayStandby" after the ":". The RPA execution unit 111 executes the read operation program with the "Web", that is, the transfer information as the display target. As a result, the display of the transfer information on the display screen 141 returns to the display of the transfer guide shown in FIG.

The RPA execution unit 111 repeats the above process up to the maximum line of (black square) Values. FIG. 11 shows a display example of the display screen 141 after the processing is executed up to the maximum line in the transportation cost .xlsx, that is, the third line. In FIG. 11, the “508” yen on Route 1 displayed in the order of the boarding section “Rokucho → Shinagawa” is acquired as the value of the “transportation cost” of the transportation cost .xlsx.

The RPA execution unit 111 reads "Robot-> Web: ie.quit" of the code data 124, and acquires the object of operation: "Web" from the keyword: "Robot-> Web" before ":". The RPA execution unit 111 reads from the storage unit 12 an operation program for terminating the Internet connection using Internet Explorer, which corresponds to the keyword: "ie.quit" after ":". The RPA execution unit 111 executes the read operation program so as to terminate the connection to the "Web", that is, the transfer information. As a result, the Internet connection by Internet Explorer is terminated.

The RPA execution unit 111 reads "InputF-> OutputF: SaveAs ()" of the code data 124, and from the keyword before ":": "InputF-> OutputF", the object of operation: "InputF" and "OutputF". , Get the direction of movement. The RPA execution unit 111 reads from the storage unit 12 an operation program for saving a data file with a predetermined name in a predetermined location, which corresponds to the keyword: “SaveAs ()” after the “:”. The RPA execution unit 111 reads "InputF", that is, the transportation cost .xlsx in which the transportation cost is input, as "OutputF", that is, the transportation cost input .xlsx in C: \ app \ output. Execute the operation program. As a result, the transportation cost .xlsx in which the transportation cost is input is stored in C: \ app \ output as the transportation cost input .xlsx.

The RPA execution unit 111 reads "Robot-> OutputF: WorkBook.close ()" of the code data 124, and acquires the operation object: "OutputF" from the keyword: "Robot-> OutputF" before ":". .. The RPA execution unit 111 reads from the storage unit 12 an operation program for closing the displayed data file, which corresponds to the keyword: "WorkBook.close ()" after ":". The RPA execution unit 111 executes the read operation program for "OutputF", that is, the transportation expense input .xlsx. As a result, the transportation expense input .xlsx displayed on the display screen 141 is closed.

If there is an error in the code data 124, it is displayed that the execution cannot be performed because there is an error in the display screen 141.

As described above, in the present embodiment, the RPA execution unit 111 reads the code data 124 created so that the design drawing in accordance with UML can be displayed. Then, the RPA execution unit 111 executes an operation program corresponding to the keyword included in the code data 124. As a result, it is possible to directly execute the operation required for the software robot from the code data 124. That is, it is not necessary to code using the RPA tool while referring to the code data 124 and / or the design drawing (sequence diagram).

Further, if the code data 124 is created so that it can be executed by the RPA execution program 121, the design drawing will be created naturally. That is, it is possible to unify the standards of the design drawings. Since UML is certified in a wide area of the world, unifying with UML-compliant blueprints can be advantageous for later global expansion.

Further, since the code data 124 is text-based data, it is easy to modify. Further, since it is text-based, it is easy to compare the number of steps, the number of branches, etc. with the past design drawings, and it may be possible to automate the evaluation process of the design drawings.

Further, in the present embodiment, the RPA execution unit 111 detects the keyword included in the code data 124. Then, the RPA execution unit 111 calls the operation program 123 corresponding to the detected keyword, and executes the called operation program 123. Since the operation program 123 stored separately from the RPA execution program 121 is called, the RPA execution program 121 can be designed to be more general-purpose.

Further, in the present embodiment, the code data 124 is described in, for example, a language in a format corresponding to PlantUML, which is an open source tool. This makes it possible to inexpensively create code data 124 capable of displaying a UML-compliant design drawing.

Further, in the present embodiment, the control statement of the RPA execution program 121 and the control statement of PlantUML are at least associated with each other. As a result, the burden of creating the code data 124 is reduced.

In the present embodiment, the keywords supported by the RPA execution program 121 and the operation program 123 stored in the storage unit 12 are not limited to those described above. For example, in FIGS. 3 to 11, a code reading robot that acquires desired information from a website created using HTML and creates desired data, and an RPA execution program 121 used in the code reading robot. Was explained. However, the code-reading robot and the RPA execution program 121 according to the present embodiment may acquire information from other than the website and create desired data, for example. For example, information may be acquired by operating a predetermined application.

At this time, the RPA execution program 121 can detect, for example, a keyword for operating a predetermined application. Further, for example, the code data 124 may include the code shown in FIG. For example, the RPA execution unit 111 reads the code data 124 shown in FIG. 12, and uses the application .exe stored in C: \ app as an object based on the control statement of “box… partial… as winApp end box”. Let's say "winApp".

Further, the RPA execution unit 111 reads the code data 124 shown in FIG. 12 and based on the control statement of "box ... partial ... as button 1 ... partialicipant ... as button 2 ... partialicipant ... as button 3 ... partialicipant ... as button4 end box". Define button1 to button4 for clicking various buttons in the application.

Button1 is a button that refers to image data of a pre-registered image related to the button, for example, button .bmp, which is stored in C: \ app \ object. Button2 is a button that uses the window handle of Windows (registered trademark). In the example shown in FIG. 12, 65535 is set. Button3 is a button that uses the order of windows in Windows. Button4 is a button that uses the coordinates on the screen.

For example, when the RPA execution unit 111 reads "Robot-> winApp: exe start ()" shown in FIG. 12, it executes "winApp", that is, an operation program for starting the application.exe. During the execution of this "winApp", for example, "Robot-> winApp: click (button1)" shown in FIG. 12 is read. The RPA execution unit 111 detects the same display as the button .bmp stored in C: \ app \ object from the display screen, and clicks the detected button.

Further, during the execution of "winApp", for example, "Robot-> winApp: click (button2)" shown in FIG. 12 is read. The RPA execution unit 111 clicks on the window of the window handle: 65535.

Further, during the execution of "winApp", for example, "Robot-> winApp: click (button3)" shown in FIG. 12 is read. The RPA execution unit 111 clicks the window in the first order.

Further, during the execution of "winApp", for example, "Robot-> winApp: click (button4)" shown in FIG. 12 is read. The RPA execution unit 111 clicks the coordinates (x, y).

Also, button1 to button4 do not necessarily have to be defined. For example, as shown in FIG. 13, the click target may be described in "click ()".

The keyword corresponding to the RPA execution program 121 and the operation program 123 stored in the storage unit 12 may be arbitrarily adjusted according to the operation required of the software robot.

Further, in the above embodiment, the case where the code data 124 is executed by the RPA execution program 121 has been described as an example. However, the function of the RPA execution program 121 is not limited to the execution of the code data 124. For example, the RPA execution program 121 may include a function for checking an error in the code data 124. For example, a check button may be provided next to the robot execution button 143 of the execution window 142 shown in FIG. When the user wants to check the error about the code data 124, the user puts the desired code data .pu into the execution window 142 and presses the check button.

The RPA execution unit 111 reads the code of the code data .pu as text line by line, and compares, for example, the read control statement or keyword with the preset control statement and keyword. For example, according to FIG. 3, in the code of one line of the code data .pu, the code before ":" conforms to the plantUML format. The RPA execution unit 111 checks whether the code before ":" conforms to the description of plantUML. Further, in the code of one line of the code data .pu, the code after ":" is related to the keyword for calling the operation program 123. The RPA execution unit 111 checks whether or not the code after ":" matches the preset keyword. Further, the RPA execution unit 111 checks, for example, whether variables, classifiers, and the like are defined by "box" and the like. Further, the RPA execution unit 111 determines, for example, whether the number of "end boxes" is correct for "box", whether the number of "end" is correct for "loop", or for "alt / else". Check if the number of "ends" is correct. Further, the RPA execution unit 111 checks whether the value in parentheses of "Function ()" in the keyword is correctly acquired. Further, the RPA execution unit 111 checks whether or not there is an abnormality in the description position of "(black square) X". The RPA execution unit 111 outputs a check result based on the comparison. The check result includes, for example, pointing out a corrected part or reporting an error.

Since the RPA execution unit 111 has a function of checking the code data 124, it is possible to quickly inform the user of the presence or absence of an error.

Further, in the above embodiment, the case where the code data file is inserted into the execution window 142 of the code reading robot displayed on the display screen 141 by the drag and drop operation to execute the code reading robot has been described as an example. However, the execution of the code reading robot is not limited to the one based on the user operation.

For example, the processing unit 11 may have a function of an RPA management unit that manages the activation of the code reading type robot. For example, the RPA management unit reads the code data 124 from the storage unit 12 based on the schedule information stored in the storage unit 12, and causes the RPA execution unit 111 to execute the code data 124.

Further, the storage unit 12 according to the present embodiment may store the input support program, and the processing unit 11 may have the function of the input support unit by executing the input support program. The input support program may be stored and distributed in, for example, a non-transient storage medium, read from the non-transient storage medium, and installed in the storage unit 12. Further, the input support program may be downloaded from a predetermined server and installed in the storage unit 12, for example. Further, the input support program may be stored in the storage unit 12 in advance.

The input support unit assists the user in inputting the code when creating the code data 124. The input support unit is realized by, for example, a code snippet function or the like. For example, when the code is typed to some extent by the user, the input support unit corrects the typed code according to the defined character writing rules. In addition, the input support unit automatically inputs the remaining code based on the entered code and the defined writing rules. At this time, for example, only the parameter may be entered as a blank in the code. Further, the input support unit may compare the input code with the predetermined rule, and if there is a value that needs to be corrected, move the indicator to the position of the value.

Since the processing unit 11 has the function of the input support unit, the burden of creating the code data 124 according to the RPA execution program 121 can be reduced.

According to at least one embodiment described above, it is possible to reduce the time and effort required to create a software robot that operates efficiently.

The present invention is not limited to the above embodiment, and can be variously modified at the implementation stage without departing from the gist thereof. In addition, each embodiment may be carried out in combination as appropriate, and in that case, the combined effect can be obtained. Further, the above-described embodiment includes various inventions, and various inventions can be extracted by a combination selected from a plurality of disclosed constituent requirements. For example, even if some constituent requirements are deleted from all the constituent requirements shown in the embodiment, if the problem can be solved and the effect is obtained, the configuration in which the constituent requirements are deleted can be extracted as an invention.

1 ... Signal processing device 11 ... Processing unit 12 ... Storage unit 13 ... Input interface 14 ... Output interface 15 ... Communication interface 111 ... RPA execution unit 112 ... Drawing unit 121 ... RPA execution program 122 ... Drawing program 123 ... Operation program 124 ... Code Data 125 ... Input data 141 ... Display screen 142 ... Execution window 143 ... Robot execution button 144 ... Search button 145 ... Price order tab

Claims (11)

The process of reading the code data created so that the design drawing conforming to UML (Unified Modeling Language) can be displayed, and
An execution program that causes a computer to execute a keyword included in the code data and a process of executing the corresponding operation program. The process of detecting the keyword included in the read code data and
The execution program according to claim 1, wherein a computer executes a process of calling the operation program corresponding to the detected keyword. The computer is made to execute a process of detecting a control statement included in the code data.
The execution program according to claim 1 or 2, wherein the computer is made to execute the process of reading the code data according to the detected control statement. The execution program according to any one of claims 1 to 3, wherein the code data is described in a language in a format corresponding to a drawing program for drawing a design drawing in accordance with the UML. The code data is described in a language in a format corresponding to a drawing program for drawing a design drawing in accordance with the UML.
The execution program according to claim 3, wherein the control statement is at least associated with the control statement of the drawing program. The execution program according to claim 4 or 5, wherein the drawing program is PlantUML. The execution program according to any one of claims 1 to 6, wherein the computer is made to execute the process of checking the read code data. An input support program that causes a computer to execute a process that supports the input of keywords of an execution program that executes the code data when creating code data that can display a design drawing in accordance with UML (Unified Modeling Language). A code-reading robot equipped with an execution program that causes a computer to execute an operation program corresponding to a keyword included in code data created so that a design drawing conforming to UML (Unified Modeling Language) can be displayed. A plurality of the operation programs corresponding to a plurality of keywords included in the code data are provided.
The code-reading robot according to claim 9, wherein the execution program calls an operation program corresponding to a keyword included in the code data from the plurality of operation programs, and causes a computer to execute the called operation program. The code-reading robot according to claim 9 or 10, further comprising an input support program that causes the computer to execute a process of supporting the input of keywords of the execution program when creating the code data.

Images