JP2004164485A - Object directional working simulation device - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To attain an excellent maintaiability in a simulation program and to facilitate the correspondence among addition, alteration and deletion in the sorts of NC instructions corresponding to NC data in a device for simulating the NC data of a procedure type language. <P>SOLUTION: The simulation device is provided with an instruction unit object generation means 31 and a management means 32. The instruction unit object generation means 31 generates an instruction unit object 23 which is an object in each instruction of the NC data 6 by itself. The management means 32 provides an execution command to the generated instruction unit object 23. The instruction unit object 23 has the data of its own NC instruction sort, necessary specific attribute data and an execution method for performing simulation processing corresponding to its own NC instruction sort or the like in response to the execution command. <P>COPYRIGHT: (C)2004,JPO

Description

[0001]
TECHNICAL FIELD OF THE INVENTION
The present invention relates to an object-oriented processing simulation apparatus that simulates procedural language NC data for numerically controlling a sheet metal processing machine such as a punch press and other processing machines.
[0002]
[Prior art]
2. Description of the Related Art Conventionally, NC data for controlling a processing machine is simulated before actual processing, a processing state, tool interference, and the like are checked to prevent a trouble before it occurs.
In a general simulation method using the conventional C language, a character string processing is performed on one line of NC data, and after searching for an NC instruction, the processing is shifted to a function that is facilitated in advance, and an instruction specific within the function is performed. Was generally performed.
As a method of simulating object-oriented software, there is a method disclosed in Patent Document 1, but this is not a method of simulating procedural NC data.
[0003]
[Patent Document 1]
JP-A-9-22359
[0004]
[Problems to be solved by the invention]
However, the conventional simulation method has the following disadvantages.
a) If the number of NC instructions is enormous, the process of searching one line of NC data and determining and searching for a higher-level function to be shifted to the corresponding function becomes complicated.
b) A bug is induced when a new NC instruction branch is inserted, because the determination and search of the upper function becomes complicated.
c) Some NC instructions are not completed on a line, which complicates the processing of the upper-level function when the instruction extends over a plurality of lines.
d) Some NC instructions interfere with each other, and it is necessary to describe the processing related to the NC instructions in the processing of the upper function, which complicates the upper function.
e) When converting the NC instruction into another company's code, the branching / conversion processing by the upper-level function is required, which is complicated.
As a result, the processing is concentrated on a specific function, and the function becomes only a simple processing, resulting in an inefficient program. In addition, when adding, deleting, or changing a new NC instruction, it is necessary to pay maximum attention to the effect on other instructions, and a great deal of time is spent on debugging and test man-hours.
[0005]
An object of the present invention is to provide a machining simulation apparatus which is excellent in maintainability of a simulation program and can easily add, change, and delete types of NC commands corresponding to NC data.
Another object of the present invention is to provide an excellent maintainability even for a simulation of a punch press having various tools.
Still another object of the present invention is to provide a machining simulation program which is excellent in maintainability and can easily add, change, and delete types of NC commands corresponding to NC data.
[0006]
[Means for Solving the Problems]
An object-oriented machining simulation device (1) of the present invention is a device for simulating NC data (6) of a procedural language for numerically controlling a machining machine, and includes an instruction which is an object for each instruction of the NC data (6). An instruction unit object generating unit (31) for generating a unit object (23) and a managing unit (32) for giving an execution instruction to the generated instruction unit object (23) are provided.
The instruction unit object (23) is an execution method for performing a simulation process in accordance with its own NC instruction type and specific attribute data in response to the execution instruction in response to the execution command. And The specific attribute data need not be held unless otherwise specified.
The instruction unit object generating means (31) has an instruction type class (33) defined for each type of NC instruction. These instruction type classes (33) determine whether or not the passed NC instruction matches the type of the own NC instruction, and if they match, the instruction unit object (23) is used as an instance of the own class. Shall be generated.
It should be noted that the "instruction type class" referred to in this specification does not indicate one actual class, but generically indicates each class defined for each type of NC instruction.
[0007]
Since the machining simulation apparatus (1) having this configuration defines a single NC instruction as an object (23) in instruction units, not as a function, the processing simulation apparatus (1) can perform what kind of processing with what kind of instruction such as personality and behavior. It can be handled as a software component to know The instruction-based object generating means (31) has an instruction type class (33) defined for each type of NC instruction, and determines whether or not the instruction type matches its own NC instruction type. Therefore, it is possible to search for an instruction of its own from a huge number of NC instructions, generate its own, and give a self-pointer to an upper object (22) and the like, and perform complicated operations performed by the upper object (22). No initial processing is required, resulting in a very clean and highly independent program structure. At the time of executing the simulation, the management means (32) only needs to notify the "execution" to the instruction unit object (23). After that, each command unit object (23) judges by itself and performs all the simulation processing such as machining, tool change, movement, etc., as needed, independently.
[0008]
Therefore, the following advantages can be obtained.
a) Each instruction type class (33) autonomously searches for itself by the self-generated logic from the NC data file of the input data and creates itself as an instruction unit object (23) in the dynamic memory space. Dramatically improves maintainability.
b) The development of the simulation program can be concentrated on the creation of the instruction type class (33) of each instruction unit object (23) from the conventional processing procedure.
c) It is highly independent and can easily be added, changed, or deleted in units of the instruction type class (33) without affecting other source codes.
d) The conversion of the NC instruction to another company's format can be easily dealt with by defining each instruction type class (33).
[0009]
The present invention, when rearranged, is characterized in that it is a self-generated simulation device using object orientation. Normally, even when the object orientation is used, it is general that a higher-level object generates and holds a lower-level object. However, in the "self-generating type" of the present invention, a lower-order instruction unit object (more precisely, an instruction type class) determines whether or not it can generate itself, and if necessary, generates its own, This is a method of notifying a request to hold an object, and it is a completely independent method.
[0010]
In the present invention, when the processing machine is a punch press, tool data extracting means (34) for extracting data on the tool described as attribute data in the NC data (6) from the NC data (6); Tool type object generating means (35) for generating a tool type object (25) which is an object for each tool type in the extracted tool data.
The tool type object generating means (35) has data relating to the tool of the tool type and a drawing method for drawing the tool during the simulation processing. Among the command unit objects (23), the command unit object (23) of the tool command uses the drawing method of the tool type object (25) for the simulation processing in the execution method.
In a punch press, since various tools are used, drawing during simulation is complicated. However, even a simulation device of such a processing machine has excellent maintainability.
[0011]
An object-oriented machining simulation program according to the present invention is a program for simulating procedural language NC data for numerically controlling a machining machine, which can be executed by a computer, and includes the following procedures.
That is, from the NC data (6), a procedure for generating a plurality of NC1 line objects (22) having a character string for each predetermined section of the NC data (6) as data;
A procedure for generating an instruction unit object (23) which is an object for each instruction of the NC data possessed by the NC1 line object (22) as a lower object of the NC1 line object (22);
Sequentially giving an execution instruction to each generated instruction unit object (23).
The instruction unit object (23) is an execution method for performing a simulation process in accordance with its own NC instruction type and specific attribute data in response to the execution instruction in response to the execution command. And
The procedure for generating the instruction unit object (23) is as follows. According to each instruction type class (33) defined for each type of NC instruction, the NC instruction passed from the NC1 row object (22) is It is determined whether the instruction type matches the instruction type, and if the instruction type matches, the instruction unit object (23) is generated as an instance of its own class. This self-generation procedure may be performed in the process of generating the NC1 row object (22), or may be performed after the generation.
[0012]
BEST MODE FOR CARRYING OUT THE INVENTION
An embodiment of the present invention will be described with reference to the drawings. As shown in FIG. 2, the object-oriented machining simulation device 1 is a device for simulating NC data 6, and includes a hardware and operation system (not shown) of a computer 2 and a machining simulation serving as an application program. Program 3 The machining simulation program 3 is an object-oriented program, and is described in, for example, the C ++ language. The computer 2 includes an arithmetic control unit 4 including a central processing unit (CPU) and a storage unit 5, and the processing simulation program 3 is stored in a partial storage area of the storage unit 5. One or more NC data 6 is stored as a file or the like in another storage area of the storage means 5.
The NC data 6 is a procedural language program for numerically controlling a processing machine, and is described as a character string in which one command or a plurality of related commands are described in one line. Each NC instruction is described in an NC code of a predetermined format. The processing machine to be controlled by the NC data 6 is a sheet metal working machine such as a punch press or a laser machine, or a machine tool such as a lathe.
The machining simulation program 3 creates a hierarchically related object group 7 from the NC data 6 in a part of the storage area 5a of the storage means 5 and causes the object group 7 to execute a simulation process. The simulation result is displayed on the screen display device 8. The screen display device 8 includes a liquid crystal display device or a CRT. The computer 2 includes a keyboard, a mouse, and other input devices 9. Although the computer 2 is illustrated as a single computer, the computer 2 may be a group of a plurality of computers constituting a network.
[0013]
FIG. 3 shows a screen display example of the screen display device 8 at the time of simulation. In this example, an NC data screen 10, a simulation result display screen 11, and various information screens 12 are displayed as separate windows in the entire screen of the screen display device 8, and various software keys 13 are displayed. Have been. The NC data screen 10 displays the NC data 6 as a character string. On the simulation result display screen 11, a diagram such as a work completed state or a work being processed is displayed as a simulation result. The illustrated example is a simulation result example of the NC data 6 of the punch press, in which a diagram of each of the processed punch holes 14 is superimposed on a sheet metal work W as a material. The punch holes 14 form a continuous slit in this example, but the punch holes 14 are shown for each single punch. Further, a diagram of the work holder 15 that holds the work W in the punch press is also displayed. The software key 13 is a means for selecting an information type to be displayed on the various information screens 12, and is provided separately for machining information, tool information, NC information, performance information, and the like. The information displayed on the various information screen 12 includes, for example, a program number, a turret number, and a plate thickness of the NC data 6 as processing information. As the tool information, a tool number, a tool type, and the like of a tool arranged at a position corresponding to each turret number of the turret are displayed. As the NC information, a file update date and time of the NC data 6 is displayed. As the performance information, the number of simulations of the NC data 6 and the like are displayed.
[0014]
FIG. 1 is an explanatory diagram showing a conceptual configuration of the object-oriented machining simulation apparatus 1 and a hierarchical relationship between an object group 7 generated by the apparatus 1. First, each object will be described, and then the configuration of the processing simulation apparatus 1 will be described.
Each object of the object group 7 has data and a method that is a processing content. The object group 7 includes one uppermost NC data object 21, a plurality of NC1 row objects 22 under the NC data object 21, and one or a plurality of instruction unit objects 23 provided below each NC1 row object 22. Having. The NC data object 21 has the entire data of the file 6A of the NC data 6. The NC1 line object 22 is an object provided for each predetermined section such as one line of the NC data 6. The above-mentioned predetermined division is basically one line, but may be a plurality of lines depending on the type of the NC instruction. The instruction unit object 23 is an object provided for each NC instruction of each NC1 line object 22. When the NC1 line object 22 has only one NC instruction, one is provided. The same number of NC instructions are provided. The number of instruction unit objects 23 does not include a base class described later. The instruction unit object 23 is an object having an execution method for drawing a simulation, changing coordinates, and the like. The upper NC1 line object 22 and the NC data object 21 are objects provided for the purpose of generating and managing the instruction unit object 23. The instruction unit object 23 is of a self-generated type as described later.
[0015]
The object group 7 also has a tool data object 24 and a machining information object 26 as objects of the same hierarchy as the NC data object 21, and has a plurality of tool type objects 25 below the tool data object 24.
The tool data object 24 is an object having, as data, data extracted from the NC data 6 about the tool described as attribute data in the NC data 6. When the processing machine to be controlled by the NC data 6 is a turret-type punch press, as the data on the tool, data such as the tool number, the shape and size of the tool itself, and the turret number (the number of the location of the tool in the turret) ) And the number of the tool provided at the turret number.
The tool type object 25 is an object created for each tool, and has data such as a tool number, a shape, and a size of each tool, and tool drawing data to be displayed on a screen during simulation. The tool data object 24 and the tool type object 25 are unnecessary in the case of a processing machine that does not change tools (for example, a laser processing machine). Also, in the case of a processing machine that exchanges tools, data relating to tools does not necessarily need to be stored as an object, but may be stored as a simple data file. The tool type object 25 is of a self-generated type, as will be described later for the command unit object 23.
[0016]
The processing information object 26 is an object that has extracted data such as processing conditions described as attribute data in the NC data 6. In the case of a punch press, the processing conditions include a punch pressure, a nibbling pitch, and the like. The processing information object 26 does not necessarily need to be provided, and processing information such as processing conditions may be stored as a simple file.
The tool data object 24 and the machining information object 26 may be provided in a tool master file (not shown) provided separately from the NC data 6 when information such as other files not included in the NC data 6 is required for the simulation. ) Or the data of the automatic programming device that creates the NC data 6 may be obtained from those files or devices and held.
[0017]
FIG. 6 is a conceptual diagram of the structure of the NC1 line object 22. The NC1 line object 22 includes, as data, a character string of a predetermined section of the NC data 6 (hereinafter referred to as “NC1 line character string”) and an object pointer serving as information for identifying a storage location of the lower instruction unit object 23. Have. In addition, the data includes the line number of the NC1 line character string and information unique to the instruction of the NC1 line character string. In the case of a turret-type punch press, the unique information includes a turret number, the presence or absence of nibbling, and current position data. The turret type punch press of the combined laser / punch type includes information such as a mode for distinguishing between punching and laser processing.
The method of the NC1 line object 22 is provided with a transmission method for transmitting an execution command received from the upper NC data object 21. In this transmission method, an execution instruction is sequentially transmitted to each lower-order instruction unit object 23, and an execution instruction is transmitted to the next NC1 row object 22 by a completion response of the execution of each lower-order instruction unit object 23.
[0018]
FIG. 7 is a conceptual diagram of the structure of the instruction unit object 23. The instruction unit object 23 is provided for each NC instruction, and therefore has slightly different contents for each type of NC instruction. The instruction unit object 23 has, as data, the type of the NC instruction, a unique attribute of the NC instruction, and the pointer of the NC1 line object 22 described above. The NC command is described as a character string of an NC code, and in the case of a punch press, a T code as a tool command, an X code as a movement command in the X-axis direction, and a rotation angle of an index tool for rotation indexing. There are a C code which is a command, a REC code which is a command for sequentially punching a plurality of portions in a straight line with the same tool, and the like. As the specific attributes of the NC command, the turret number Tn which is the tool arrangement position of the turret 51 (FIG. 14A) for the T code, and the index tool 52 (FIG. 14C) for the C code. There is an angle θ. In the case of the REC code, there are data such as the direction (front, rear, left and right), the processing length L (FIG. (B)), the tool length a, the feed pitch p, and in the case of the X code, the movement amount x (FIG. There is. In addition to the data described above, the instruction unit object 23 has a code indicating the format of the NC data 6 and a precautionary note (for example, an incompatible NC instruction).
The instruction unit object 23 has a method for executing a predetermined simulation process in response to a given execution command. The execution method differs depending on the type of the NC command. For example, in the case of a punch command (such as a REC code), a drawing process is performed; in the case of a movement command (such as an X code), the current coordinate is changed; It is a method that performs processing such as turret index rotation.
[0019]
Although not shown, the NC data object 21 in FIG. 1 has the entire NC data 6 as the data as described above, and the method is an input of an execution command given from the input device 9 (FIG. 2) or the like. Has a method of giving an execution instruction to each NC1 line object 22 in accordance with.
[0020]
The configuration of the processing simulation apparatus 1 will be described with reference to FIG. The machining simulation apparatus 1 includes an instruction unit object generation unit 31 that generates an instruction unit object 23 that is an object for each instruction of the NC data 6, and a management unit 32 that gives an execution instruction to the generated instruction unit object 23. .
The instruction unit object generation means 31 has a plurality of instruction type classes 33 defined for each type of NC instruction. These instruction type classes 33 determine whether or not the passed NC instruction matches the type of the own NC instruction, and when they match, generate the instruction unit object 23 as an instance of the own class. is there. An instance is a class that has an entity. The instruction type classes 33 are provided by the number of types of NC instructions.
[0021]
The processing simulation device 1 further includes a tool data extracting unit 34, a tool type object generating unit 35, and a processing information object generating unit 36. The tool data extracting means 34 is means for extracting data on a tool described as attribute data in the NC data 6 from the NC data 6, and specifically, generates the tool data object 24. The tool type object generating unit 35 is a unit that generates the tool type object 25 that is an object for each tool type in the tool data extracted by the tool data extracting unit 34. In this example, the tool type object generating means 35 generates the tool type object 25 by the same method as the method of generating the command unit object 23. The tool type object 25 has data relating to the tool of the tool type and a drawing method for drawing the tool during the simulation processing. Among the command unit objects 23, the command unit object 23 of the tool command uses the drawing method of the tool type object 25 for the simulation processing in the execution method.
[0022]
FIG. 4 shows a specific example of the management unit 32 and the instruction unit object generation unit 31. The management unit 32 has a management unit 37 and an NC data object generation unit 38, and the NC data object generation unit 38 generates the NC data object 21 in FIG. In addition, the management unit 32 has a top-level object generation unit (not shown) that generates the tool data object 24 and the processing information object 26. The management unit 37 is a unit that performs processing or the like in response to an operator's input. The management unit 37 selects which NC data 6 to simulate, receives an instruction to start object creation, and is selected by the NC data object generation unit 38 and the like. The creation of the object group 7 of the NC data 6 is started. Further, a simulation execution command is transmitted to the created object group 7. This execution command is sequentially transmitted from the created NC data object 21 to lower-order objects.
[0023]
The instruction unit object generation means 31 has an NC1 line object generation unit 39 for generating the NC1 line object 22 and an instruction unit object generation unit 40 for generating the instruction unit object 23.
[0024]
As shown in FIG. 5, the NC1 line object generation unit 39 has one NC1 line class 41 in which a class is defined. The NC1 line object generation unit 39 gives data such as a one-line character string of the NC data 6 to the NC1 line class 41 as an argument or the like, and generates the NC1 line object 22 (FIG. 1) as an instance of the NC1 line class 41. is there. The NC1 line object generation unit 39 generates the NC1 line object 22 according to the management of the upper management unit 32 (FIG. 4). The NC1 line class 41 specifically has a method for performing the processing of the procedure shown in the flowchart in FIG.
[0025]
The instruction unit object generation unit 40 includes, as classes belonging to the instruction type class 33, an instruction type base class 33a which is a base class, and a class 33b for each of a plurality of instruction types defined as a derivative class of the instruction type base class 33a. Have. The classes 33b for each instruction type are provided by the number of instruction types. The "instruction type class 33" referred to in this specification is not an actual class, but a generic name of the instruction type base class 33a and its derivative classes 33b for each instruction type.
The instruction type base class 33a is a class having members common to the class 33b for each instruction type, and does not generate an instance of this class 33a. The class 33b for each instruction type defines data and methods that are different from the instruction type base class 33a, inherits all the data and methods of the instruction type base class 33a, and sets The method will have the added content.
[0026]
The class 33b for each instruction type has self-characteristic data as data, and has a self-identification function, a self-generated method, and an execution method as methods. The self-characteristic data is data indicating which NC instruction (for example, T code, X code, C code, REC code,...) Of the class 33b.
The self-identification function is a function for determining whether or not data passed as an argument matches data indicating self-characteristics.
The self-generated method is a method for generating the instruction unit object 23 as an instance having the content of NC data for the class 33b of the instruction type when it is determined by the self-identification function that the self-feature matches.
The execution method is the same as that described for the instruction unit object 23, and differs depending on the type of the NC instruction. Although the description will be duplicated, the execution method is, for example, drawing processing in the case of a class of a punch command (REC code or the like), change of current coordinates in the case of a class of a movement command (X code or the like), tool command (T code) In the case of class, it is a method that performs processing such as turret index rotation.
[0027]
As shown in FIG. 12, the self-identification functions of the class 33b for each instruction type are listed in one self-identification function table 42. The function name is a function name unique to each class by describing the class name and the function name together. The self-identification function table 42 is a static method function table.
[0028]
Next, a process of generating the object group 7 by the machining simulation apparatus 1 having the above configuration and a process of executing a simulation by the created object group will be described with reference to flowcharts of FIGS.
FIG. 8 shows the flow of the entire process. When the machining simulation program 5 is started by an operator's input (step S1), the file of the NC data 6 can be selected by the processing of the management means 32 (FIGS. 1 and 4). In this state, a file 6A of the desired NC data 6 is selected and an object creation command is input (S2). First, an NC data object 21 is generated (S3), and then each NC1 line object 22 is sequentially generated. (S4). In the process of generating each NC1 row object 22, an instruction unit object 23 belonging to a lower order is generated. In this way, a hierarchically structured object group 7 is generated. Note that the tool data object 24, the tool type object 25, and the machining information object 26 shown in FIG. The generation of these objects 25 and 26 may be performed before or after the generation of the NC1 line object 22, or may be performed simultaneously.
When the object group 7 is generated in this manner, the management unit 32 recognizes the completion of the generation and gives a simulation execution instruction. This execution command may be given by an operator's operation on the management means 32.
[0029]
FIG. 9 shows a process of creating the NC1 line object 22. The one-line character string is extracted from the NC data 6 held as the data of the NC data object 21 by the NC1 line object generation unit 39 in FIG. 5 and given as an argument to the NC1 line class 41 (step R1). As a result, an NC1 line object 22 is generated in which the NC1 line class 41 is an instance of the class, that is, a substantial object (R2). In the process of generating the NC1 line object 22, the instruction unit object 23 is self-generated by the lower-order instruction unit class 33b (FIG. 5), and the self-generated instruction unit object 23 is stored in the array of the NC1 line object 22. Add to element. Thereby, one NC1 line object 22 is completed.
Next, the line counter indicating the line number of the character string of the NC data 6 is decremented (or incremented) (R3), and it is determined whether or not the line is the last line (R4). If it is not the last line, the character string of the next one line of the NC data 6 is extracted, and the NC one-line object 22 is generated in the same manner as described above. By repeating such processing, the NC1 line object 22 is generated for all the lines of the NC data 6.
[0030]
FIG. 10 shows a procedure in which the NC1 row class 41 instructs the lower class 33b (FIG. 5) to self-generate the instruction unit object 23 in the generation process, and adds it to the array element.
To explain the outline first, self-generation is performed when the self-identification functions listed in the self-identification function table 42 (FIG. 12) are executed in order to make the corresponding class self-identify and match the self-characteristics. The self-identification function is a function provided individually for all the instruction types of the classes 33b. The self-identification function compares arguments and self-characteristics and identifies itself.
Description will be made in the order of steps. The method of the NC1 row class 41 initializes the array value of the self-identification function table 42 (FIG. 12) (step Q1), and reads the self-identification function of the corresponding array value (Q2). It is determined from the array value whether or not the table is at the end (Q3). If not at the end, the following processes Q4 to Q10 are performed. The following steps Q4 and Q5 are detailed processes, and will be described later. In step Q6, the read self-identification function is called.
[0031]
With this call, as shown in FIG. 11, in the instruction type class 33b having the self-identification function, the self-identification function is executed, and it is determined whether the NC instruction as an argument matches the self-characteristic (U2). ). If they do not match, a non-matching response is returned to the NC1 row class 41, and no object is generated. If they match, the instruction unit object 23 which is an instance of the class 33b of the instruction type is self-generated by the self-generating method of the class 33b, and a response of the match is returned to the NC1 row class 41.
To explain with a specific example, it is assumed that the read self-identification function is a tool instruction (T code) class self-identification function. In this case, the class of the tool command will execute its self-identification function. At this time, it is assumed that the character string of NC1 line is passed as an argument to the tool instruction class, and the instruction indicated by the character string is a movement command (X code) in the X direction. Then, the class of the tool command executing the self-identification function returns a mismatch response because the tool command as the self-feature does not match the movement command as the argument, and does not generate an object as an instance. If the argument is a tool command, since it matches the self-feature, the command unit object 23 which is an instance of the class of the tool command is generated, and a reply of the match is returned to the NC1 row class 41.
[0032]
In step Q7 of FIG. 10, the response returned from the instruction type class 33b is determined. If the response does not match the self-characteristic, the process proceeds to the next reading of the self-identification function (Q10, Q2). In the case of a response that matches the self-characteristic, the self-generated instruction unit object 23 is added to the array element held by the NC1 line object 22 (Q8), and the array value is initialized (Q9). Proceed to reading the self-identification function (Q2).
[0033]
Such processing is repeated up to the end self-identification function of the self-identification function table 42. Therefore, the NC1 line object 22 has the instruction unit object 23 corresponding to the argument.
To explain with a specific example, it is assumed that the NC command passed as an argument to the NC1 row class 41 is a tool command. In this case, the self-identification functions listed in the self-identification function table 42 are sequentially called, and the self-identification function is executed by the class 33b of the instruction type corresponding to the self-identification function. When the class 33b of the command type corresponding to is the class of the movement command, since it does not match the self-characteristic, a reply of mismatch is made and the next self-identification function is called. Assuming that the next self-identification function is also an NC command other than the tool command, for example, a C-axis command, a non-coincidence reply is made and the next self-identification function is called. In this manner, the self-identification functions of the self-identification function table 42 are sequentially called, and when the self-identification function of the tool instruction is called, the tool instruction as an argument matches the self-characteristic of the class 33b of the tool instruction. Then, the command unit object 23 of the class 33b of the tool command is self-generated. Further, the self-generated instruction unit object 23 is held as an array element in the NC1 row object 22 which is an instance of the NC1 row class 41.
[0034]
The processing of steps Q4 and Q5 in FIG. 10 shows processing for coping with a case where the NC1 line character string used as an argument includes a plurality of instructions. This will be described together with the specific example of FIG.
The NC1 line character string of the argument is “REC / 100” including an instruction “REC / 100”, an instruction “T0”, and an instruction “M0” as NC instructions. T0 M0 ". Here, the instruction such as “REC / 100” indicated by the NC code is a tentative code, and its content may be any.
In step Q4, when reading the previous self-identification function in the self-identification function table 42, if the instruction unit object 23 is self-generated as matching the self-feature, the character string of the self-generated instruction is used as an argument. Perform processing to subtract from As a result, in the example of FIG. 13, the remaining character string is “T0 M0 ", and two NC instructions remain. When one line of character string includes a plurality of NC instructions, self-identification and self-generation are performed from the earliest NC instruction in one line.
In step Q5, it is determined whether or not a character string remains, and if not, the process of the NC1 line class 41 is ended. In the example of FIG. 13, since the character string “T0M0” still remains, the processing is continued.
Next, when the instruction unit object 23 of the NC instruction of the character string "T0" is self-generated, the character string "T0" is subtracted in step Q4 of the next repetition process, and "M0" remains. When the instruction unit object 23 of the NC instruction of the character string “M0” is self-generated, the character string becomes 0, and the process of the NC1 line class 41 ends from step Q5.
In this way, the one-line character string is “REC / 100 T0 The NC1 row object 22 of “M0” has three instruction units of an instruction unit object 23 of “REC / 100”, an instruction unit object 23 of “T0”, and an instruction unit object 23 of “M0” as its array elements. The object 23 will be retained.
In this way, the self-generation of the instruction unit object 23 can be performed regardless of the number of instructions included in the one-line character string. When one NC character is included in one line of character string, the character string becomes 0 in the next repetition process when it is self-generated, and the processing ends there.
[0035]
The execution of the simulation, that is, the execution of the simulation after the generation of the object group 7 is performed when the completion of the generation of the object group 7 is recognized by the management unit 32 or when an operator or the like gives an execution command to the management unit 32. This is performed by the management means 32 giving an execution instruction. This execution instruction is transmitted from the NC data object 21 to the first NC1 row object 22 and transmitted to the first lower instruction unit object 23. The instruction unit object 23 returns the execution completion to the NC1 line object 22, and the NC1 line object 22 transmits the execution instruction to the next instruction unit object 23. If there is no next instruction unit object 23, an execution instruction is transmitted to the next NC1 line object 22. In this manner, the execution instructions are transmitted in the order in which the instruction unit objects 23 are generated.
Each instruction unit object 23 executes a unique execution method of the instruction unit object 23 according to an execution instruction. For example, drawing, movement of current coordinates, exchange of tools (index rotation of a turret), and the like are performed. As a result, a diagram of the execution result of the NC data 6 is displayed on the simulation result screen 11 of the screen display device 8 as shown in FIG. The operator can find a defect in the NC data 6 by looking at the contents displayed on the screen.
[0036]
Although not described in the above description, more specifically, for example, each NC1 line object 22 is, as a lower object, an object that is the instruction type base class 33a (FIG. 5) and one of its derivatives. Has one or more instruction unit objects 23 having instances of the instruction type class 33b as instances. When creating the object group, the instruction type base class 33a itself is not explicitly created, but the derived class 33b is declared to inherit properties from the base class. By the generation, it has the base class 33a. In the execution process, for example, first, an execution instruction is transmitted to the object of the instruction type base class 33a (FIG. 5), but the instruction type base class 33a has no specific contents of the execution method and does not perform a specific simulation process. .
[0037]
Since the machining simulation apparatus 1 is of a self-generating type using the object orientation and self-generates the instruction unit object 23, the machining simulation apparatus 1 is excellent in the maintainability of the simulation program 5 and has the NC instruction corresponding to the NC data 5. It is possible to easily add, change, and delete the types. For example, in response to the addition, change, or deletion of the NC instruction, only by adding, changing, or deleting the instruction type class 33b and the self-identification function of the self-identification function table 42, without taking any other effect. Can be.
[0038]
Although the above description has been made from the viewpoint of the processing simulation apparatus 1, the present invention can be regarded as the invention of the processing simulation program 5.
The machining simulation program 5 is a computer-executable program that simulates NC data 6 in a procedural language for numerically controlling a machining machine. And generating a plurality of NC1 line objects 22 having data as an instruction, and an instruction unit object 23 which is an object for each instruction of the NC data of the NC1 line object 22 as a lower object of these NC1 line objects 22. It includes a procedure and a procedure of sequentially giving an execution instruction to each generated instruction unit object 23.
The instruction unit object 23 includes data of its own NC instruction type, necessary specific attribute data, and an execution method for performing a simulation process according to its own NC instruction type and specific attribute data in response to the execution command. Have
The procedure for generating the instruction unit object 23 is to determine whether the NC instruction passed from the NC1 row object 22 matches the type of the own NC instruction by each instruction type class 33 defined for each type of the NC instruction. It is determined whether or not the instruction unit object 23 is generated as an instance of the own class if the two match.
In this embodiment, the procedure for generating the instruction unit object 23 is performed in the middle of the procedure for generating the NC1 row object 22, but may be performed after the generation of the NC1 row object 22.
[0039]
【The invention's effect】
The machining simulation apparatus according to the present invention is a self-generation type simulation apparatus using object orientation, and is configured to self-generate an instruction-based object. Therefore, the maintainability of a simulation program is excellent, and the type of NC instruction corresponding to NC data is excellent. Can be easily added, changed, and deleted.
When NC data of a punch press is used and a tool type object generation unit is provided, the maintenance performance is excellent even for a simulation of a punch press having various tools.
The machining simulation program according to the present invention is a self-generation type simulation program using object orientation, and is configured to self-generate an instruction unit object. Therefore, the machining simulation program is excellent in maintainability, and it is possible to add NC instruction types corresponding to NC data. Changes and deletions can be easily handled.
[Brief description of the drawings]
FIG. 1 is a conceptual configuration diagram showing a hierarchical relationship between an object-oriented machining simulation apparatus according to an embodiment of the present invention and a group of generated objects.
FIG. 2 is a schematic explanatory diagram of a hardware configuration example of the processing simulation apparatus.
FIG. 3 is an explanatory diagram of a screen example of a screen display device in the processing simulation device.
FIG. 4 is a block diagram of a conceptual configuration of a management unit and an instruction unit object generation unit of the processing simulation apparatus.
FIG. 5 is a detailed block diagram of a conceptual configuration of an instruction unit object generation unit of the processing simulation apparatus.
FIG. 6 is an explanatory diagram of a conceptual configuration of an NC1 line object.
FIG. 7 is an explanatory diagram of a conceptual configuration of an instruction unit object.
FIG. 8 is a flowchart showing an outline of the overall processing of the processing simulation apparatus.
FIG. 9 is a flowchart showing a generation process of the NC1 line object.
FIG. 10 is a flowchart showing a self-generation instruction to an instruction type class by the NC1 line object and a process of holding the formed object.
FIG. 11 is a flowchart of a self-generation process of an instruction type class.
FIG. 12 is an explanatory diagram of a self-identification function table.
FIG. 13 is an explanatory diagram of a process of subtracting a self-generated character string from a one-line character string.
FIG. 14 is an explanatory diagram of the configuration and operation of each part of the punch press.
[Explanation of symbols]
1. Processing simulation device
2. Computer
3. Machining simulation program
6 ... NC data
7… Object group
8 Screen display device
21: NC data object
22 NC1 line object
23 Instruction unit object
24 ... Tool data object
25 ... Tool type object
31 ... Instruction-based object generation means
32: Management means
33 ... Instruction type class
33a: Instruction type base class
33b: Class for each instruction type
34 ... Tool data extraction means
35 ... Tool type object generating means
36 Processing information object generating means
41… NC1 line class
42 self-identification function table

Claims (3)

An apparatus for simulating procedural language NC data for numerically controlling a processing machine,
An instruction unit object generating means for generating an instruction unit object which is an object for each instruction of the NC data;
Management means for giving an execution instruction to the generated instruction unit object,
The instruction unit object has data of its own NC instruction type, necessary specific attribute data, and an execution method for performing a simulation process according to its own NC instruction type and specific attribute data in response to the execution instruction. Things,
The instruction unit object generation means has an instruction type class defined for each type of NC instruction, and these instruction type classes determine whether the passed NC instruction matches the type of its own NC instruction. Is determined, and if it matches, the instruction unit object is generated as an instance of its own class.
Object-oriented machining simulation device. The processing machine is a punch press, a tool data extraction unit for extracting data on a tool described as attribute data in the NC data from the NC data, and an object for each tool type in the extracted tool data. A tool type object generating means for generating a tool type object, the tool type object generating means having data relating to the tool of the tool type and a drawing method for drawing the tool at the time of simulation processing; 2. The object-oriented machining simulation apparatus according to claim 1, wherein, among the unit objects, the instruction unit object of the tool instruction uses the drawing method of the tool type object for the simulation processing in the execution method. A computer-executable program for simulating procedural language NC data for numerically controlling a processing machine, comprising:
A procedure for generating a plurality of NC1 line objects having a character string for each predetermined section of the NC data as data from the NC data;
A procedure of generating an instruction unit object which is an object for each instruction of the NC data of the NC1 line object as a lower object of the NC1 line object;
Giving a sequential execution instruction to each generated instruction unit object,
The instruction unit object has data of its own NC instruction type, necessary specific attribute data, and an execution method for performing a simulation process according to its own NC instruction type and specific attribute data in response to the execution instruction. Things,
The procedure for generating the instruction unit object is to determine whether the NC instruction passed from the NC1 row object matches the type of the own NC instruction according to each instruction type class defined for each type of the NC instruction. Was determined, and when the values matched, the procedure was such that the instruction unit object was generated as an instance of the own class.
Object-oriented machining simulation program.

Images