JP4613003B2 - Source program conversion method - Google Patents

Description

The present invention relates to a source program conversion method for converting a source program in a text format into an executable program that can be read and executed by a computer.

  A machining program for operating a numerically controlled machining machine (NC device) is edited in a text format. In the source program, an operation type setting code, a target position setting code, and an operation speed setting code are provided as instruction codes. Etc. are recorded. In the NC device, these instruction codes are recognized and interpreted by a predetermined conversion unit and converted into a binary execution program, and then the execution program is executed to control the motor and the like.

  The machining program description method corresponds to the function of the conversion unit of the NC device. In addition to the method of describing one instruction code in one line, the method of describing a plurality of instruction codes in one line, the concept of the line, etc. There is also a method of writing instruction codes in succession.

  In the method of describing a plurality of instruction codes in one line, a processing unit corresponding to each instruction code is provided in the conversion unit of the NC device so that the processing unit can recognize that a plurality of instruction codes can be written together. (For example, refer to Patent Document 1).

  Also, in the method of writing instruction codes continuously without the concept of lines, the machining program is divided for each instruction code, and conversion is performed while recognizing whether the divided character strings can be written together. It is carried out.

JP-A-10-133726

  As mentioned above, machining programs are not compatible between NC machines, so when trying to port a predetermined machining program to another NC machine, the machining program must be re-run according to the specifications of the conversion unit in the NC machine at the transplant destination. Need to edit.

  In addition, in a method of describing a plurality of instruction codes in one line or a method of describing instruction codes continuously without a concept of lines, when a new instruction code not conventionally applied is applied, It is not only necessary to add a processing unit corresponding to the instruction code, but it is also necessary to change the processing unit corresponding to the conventional instruction code. Therefore, in order to add a new instruction code, an additional operation cannot be performed unless the user is familiar with the contents of the processing unit, and the operation itself takes time.

The present invention has been made in consideration of such problems . In addition to improving program compatibility , the application code can be simplified when a new instruction code is applied to a source program such as a machining program. An object of the present invention is to provide a source program conversion method that can be applied to the above.

The source program conversion method according to the present invention is a source program conversion method for converting a text source program including an instruction code and its argument into an executable program that can be read and executed by a computer. An instruction extraction step for extracting an instruction code by referring to a list in which an instruction code applied in advance and an argument subordinate to each instruction code are recorded while sequentially reading from the first character of a program character string group; and an instruction code When the instruction code extracted by the extraction means takes an argument, the argument extraction means refers to a location corresponding to the instruction code in the list and changes the instruction code from the character string following the instruction code. Argument extraction process to extract corresponding arguments and multiple instruction codes The instruction code extracted by the instruction code extracting means is converted together with the argument extracted by the argument extracting means by the instruction code exclusive converting means corresponding to the instruction code among the dedicated converting means, and executable executable code is obtained. A conversion step for generating, and an update step for setting the character string described next to the character string converted by the instruction code exclusive conversion means to be the first character of the character string group by the instruction code extraction means , The extraction step, the argument extraction step, the conversion step and the update step are repeatedly executed, and the argument extraction step sequentially examines the character string following the instruction code and sequentially extracts the argument, and the extracted character string and If the argument of the same character string has already extracted processed, characterized in that to terminate the extraction of the argument that corresponds to the instruction code at that point To.

Thus, by extracting the instruction code and argument while referring to the list, the compatibility of the program is improved, and when applying a new instruction code to the source program, the instruction code and argument are added to the list. What is necessary is just to carry out additional registration, and this instruction code can be applied simply. In addition, the instruction code and the argument can be accurately distinguished.

  Further, the list is divided into a first list in which instruction codes are recorded and a second list in which arguments dependent on each instruction code are recorded, so that new registration can be easily performed. Become.

Further, the instruction code dedicated conversion unit has a binary conversion unit that generates an execution code corresponding to each instruction code, and the instruction code dedicated conversion unit additionally registers a binary conversion unit corresponding to the instruction code. It should be possible. The argument extraction means is included in the instruction code dedicated conversion means, and the instruction code extraction means reads the characters following the instruction code extracted by referring to the list while sequentially reading from the first character of the character string group of the source program. You may make it pass a sequence group to the said instruction code exclusive conversion means. In the source program, an instruction code and an argument, and an argument may be separated by a space.

According to the source program conversion method of the present invention, when a new instruction code is applied to a source program such as a machining program, the instruction code can be easily applied. Thereby, for example, even a person who has not grasped the history of additional registration so far can add and apply a new instruction code easily and in a short time. In addition, program compatibility is improved.

Hereinafter, the source program conversion method according to the present invention will be described with reference to FIGS.

The source program conversion method according to the present embodiment is performed using, for example, the source program conversion system 10. As shown in FIG. 1, source over the scan program conversion system 10 includes a NC device 14 for numerical control processing unit 12, a machining program (source program) for operating the NC device 14 16, the first list 18 and the 2 has an editing terminal 22 for editing the list 20. The processing program 16, the first list 18, and the second list 20 are edited in a text format by the editor 24 of the editing terminal 22.

  The NC device 14 includes a memory 26 for recording the machining program 16, the first list 18 and the second list 20 transferred from the editing terminal 22 as a machining program 16a, a first list 18a and a second list 20a, and a first list. A conversion unit 30 that converts the machining program 16a into an execution program 28 with reference to 18a and the second list 20a, and an execution processing unit 32 that reads and executes the execution program 28 to operate the machining unit 12. The execution processing unit 32 processes the workpiece by operating a motor 36, a solenoid 37, and the like via an amplifier 34 and driving a tool, a table, or the like.

  The converting unit 30 sequentially reads a character string of a predetermined length from the processing program 16a, and an instruction code described in the character string read by the input unit 40 while referring to the first list 18a. The instruction code extracting unit 42 for identifying the type of the command and an argument corresponding to the type of the instruction code identified by the instruction code extracting unit 42 are extracted with reference to the second list 20a and converted into an executable binary format. A conversion processing unit (argument extraction means) 44. The conversion processing unit 44 includes binary conversion units 46a, 46b, 46c, 46d, 46e, and 46f corresponding to each instruction code.

  As shown in FIG. 2, the machining programs 16 and 16a are edited in a text format, and include instruction codes (“N”, “E”, “G00”, etc.) and arguments (“X100. 0 ”,“ Y200.0 ”, etc.) and comments.

  The instruction codes applicable in the NC device 14 are six instruction codes “G00”, “G01”, “G02”, “E”, “F”, and “N”. The argument can be omitted. The instruction code “G00” is converted by the binary conversion unit 46 a in the conversion processing unit 44. Similarly, the instruction codes “G01”, “G02”, “E”, “F”, and “N” are converted by the binary conversion units 46b, 46c, 46d, 46e, and 46f, respectively.

  As will be described later, a conversion unit corresponding to a new instruction code can be added to the conversion processing unit 44. For example, a binary conversion unit 46g corresponding to a new instruction code “G103” is added. Can be set.

  Actually, more instruction codes exist in the NC device 14, but only six typical instruction codes and a new instruction code “G103” will be described for easy understanding.

  The format of the machining program 16a that can be converted by the conversion unit 30 can describe a plurality of instruction codes in one line, and is allowed to be combined with other instruction codes for each instruction code or exclusive. It is prescribed whether or not. A plurality of instruction codes permitted to be written together can be described in one line. It is forbidden to describe exclusive instruction codes in one line, and it is possible to describe one or more instruction codes and one exclusive instruction code that are allowed to be written together.

  The instruction code “G00” is a non-interpolated positioning code and an exclusive instruction code. The arguments are “X”, “Y”, and “Z” as three-dimensional coordinates, and “A”, “B”, and “C” indicating the posture.

  The instruction code “G01” is a linear interpolation code and is an exclusive instruction code. The arguments are “X”, “Y”, “Z”, “A”, “B”, and “C”.

  The instruction code “G02” is a clockwise circular interpolation code and is an exclusive instruction code. The arguments are “X”, “Y”, “Z” and “R” as the radius of the arc.

  The instruction code “E” is a designation code for each axis speed, and writing with other instruction codes is permitted. There are no arguments.

  The instruction code “F” is an interpolation operation speed designation code, and writing with other instruction codes is permitted. There are no arguments.

  The instruction code “N” is a label number designation code, and is allowed to be written together with other instruction codes. There are no arguments. The instruction code “N” can be used as a branch destination corresponding to a predetermined branch instruction (so-called GO TO statement or the like).

For example, the description “N10” is an instruction for designating the label number “10”, and a corresponding numerical value is described immediately after “N”. The same applies to “F” and “N”. In addition, when the line number is assigned as No. 10 and each axis speed is moved to the position of X = 100.0 [mm] and Y = 200.0 [mm] as an operation at 100 [%],
"N10 G00 X100.0 Y200.0 E100"
May be described in one line.

  Some of these instructions are also defined in JIS B 6315-2 and ISO / DIS 6983-2.

  As shown in FIG. 3A, each instruction code is recorded in the first lists 18 and 18a.

  As shown in FIG. 4A, the dependent arguments are recorded for each instruction code in the second lists 20 and 20a. Among these, “−” indicating that there are no more arguments is recorded in the right column of the last argument column in the line of the instruction code having the argument. In addition, since the instruction codes “E”, “F”, and “N” have no dependent argument, “−” is recorded in the first column, indicating that there is no argument.

  By separately recording the instruction codes in the first list 18 and the arguments in the second list 20, the applied instruction codes and arguments are clarified and edited when a new instruction code is additionally registered as will be described later. Is easy.

Next, a procedure (source program conversion method) for converting the machining program 16 into the execution program 28 by the source program conversion system 10 configured as described above will be described with reference to FIGS. Of the processes shown in FIG. 5, steps S <b> 1 to S <b> 4 are processes mainly executed by the input unit 40, and steps S <b> 5 to S <b> 14 are processes mainly executed by the instruction code extraction unit 42. Further, the process illustrated in FIG. 6 is a process mainly executed by the binary conversion unit 46 a of the conversion processing unit 44.

  First, in step S <b> 1, the machining program 16 is edited by the editor 24 of the editing terminal 22. This editing operation is a so-called programming operation, and the machining program 16 is created and edited so that the NC device 14 can perform a predetermined operation. Further, it is assumed that the first list 18 and the second list 20 are created in advance as shown in FIGS. 3A and 4A.

  The processing program 16 is edited in a text format, and the first list 18 and the second list 20 are edited in a text format or a binary format.

  Next, in step S2, the machining program 16, the first list 18 and the second list 20 are transferred to the memory 26 of the NC device 14, and recorded as the machining program 16a, the first list 18a and the second list 20a.

  Next, in step S3, an open process for enabling the input unit 40 to access the machining program 16a in the memory 26 is performed by a predetermined conversion start instruction operation. It is assumed that the machining program 16a has been edited as shown in FIG.

  Furthermore, in step S4, the input unit 40 reads one line from the machining program 16a into a predetermined buffer. The processing in step S4 is controlled by a predetermined line pointer indicating a line in the machining program 16a so that each line can be read in order from the beginning each time it is executed.

  Next, in step S5, it is confirmed whether or not the read line is an “EOF” code indicating the end of the file. If the character string in the buffer is an “EOF” code, the process is terminated; otherwise, the process proceeds to step S6.

  In step S6, the comment character string is deleted from the character string in the buffer. That is, a character string in a range surrounded by parentheses “(” and closing parenthesis “)” is deleted including the parentheses, and a character string after the semicolon “;” in the line is deleted.

Thereby, for example, in the case of the character string in the first line of the machining program 16 (see FIG. 2), the character string “(move to the tap position of No. 10)” and the character string “; speed setting” are deleted. And
"G00 X100.0 Y200.0 E100"
Will remain in the buffer.

  In step S7, an instruction extraction pointer indicating the reading position is set at the head of the buffer. That is, in the case of the above character string, a predetermined instruction extraction pointer is set in the portion “G” which is the first character. The position of the instruction extraction pointer in the buffer is moved in the processing after step S8.

  Next, in step S8, the position of the instruction extraction pointer at that time is checked. If the instruction extraction pointer is at the end of the buffer, the process returns to step S4. Otherwise, the process proceeds to the next step S9. . When returning to step S4, the character string of the next line is sequentially read from the processing program 16a into the buffer, and the processing is continued for the character string.

  In step S9, a character string included between the position of the instruction extraction pointer at that time and the next space position is extracted as an instruction code. In the case of the above character string, the character string of the instruction code “G00” is initially extracted.

  In step S10, it is confirmed whether or not the character string indicating the extracted instruction code is in the first list 18a. If the character string exists in the first list 18a, the process proceeds to the next step S11. If the character string does not exist, a predetermined abnormality is displayed, and the process is terminated.

  In step S <b> 11, a predetermined binary conversion unit corresponding to the extracted instruction code is called from the conversion processing unit 44. Specifically, when the extracted instruction code is “G00”, the corresponding binary conversion unit 46a is called.

Next, in step S12, the called binary conversion unit is executed. At this time, the character string following the extracted instruction code is delivered to the binary conversion unit. That is, in the case of the above character string, “X100.0 Y200.0 E100” which is a character string following “G00”.
Is transferred to the binary conversion unit 46a. The processing in the binary conversion unit 46a will be described later.

Then, Oite to step S1 3, confirm the arguments that are recognized by the binary conversion unit, to move the instruction extraction pointer at the position of the next character following the string of the cited number in the buffer. That is, when the binary conversion unit 46a corresponding to the first instruction code “G00” in the character string is called, the argument is recognized as “X100.0 Y200.0”, and the instruction extraction pointer is It is set at the position of “E” which is the subsequent character.

  Furthermore, in step S14, it is confirmed whether or not an error has occurred during the processing in the binary conversion unit. If there is an error, a predetermined abnormality is displayed and the processing is terminated. In other cases, that is, in the case of normality, the process returns to step S8 to continue the process for the next character string in the buffer.

  In this way, the character strings described in the machining program 16a are sequentially read into the buffer line by line in steps S4 to S8, and the character strings in the buffer are decomposed in steps S9 to S14, so that the binary conversion units 46a to 46a. 46f can be sequentially converted into a binary format.

  Next, the processing of the binary conversion unit in step S12 will be described with reference to FIG. In this description, as a representative example, the binary conversion unit 46a corresponding to the instruction code “G00” in the binary conversion unit receives the character string “X100.0 Y200.0 E100” from the instruction code extraction unit 42. The case will be described.

  First, in step S101, an argument extraction pointer is set at the position of the first character “X” in the delivered character string.

  Next, in step S102, it is confirmed whether or not the corresponding instruction code “G00” takes an argument. Specifically, referring to the second list 20a, the line of the instruction code “G00” is referred to. If there is no character indicating an argument in this line and only the character “−” is recorded, the process proceeds to step S108. If a character string indicating an argument is recorded, the process proceeds to step S103.

  Further, instruction codes having no argument may not be registered in the second list 20a, and the process may move to step S108 when there is no corresponding character string when the second list 20a is referred to.

  Next, in step S103, the line “G00” in the second list 20a is referenced to check whether or not there is a character (eg, “X”) indicated by the argument extraction pointer at that time. When there is no corresponding character, the process proceeds to step S108, and when the character exists, the process proceeds to step S104.

  As described above, the instruction code “G00” can take six arguments “X”, “Y”, “Z”, “A”, “B”, and “C”. Any number of 6 or less may be used. For example, there may be no argument.

  In step S104, it is confirmed whether or not the character indicated by the argument extraction pointer at that time has already been processed. In other words, as will be described later, even if a certain argument is applied to the same character string as the predetermined instruction code, the character string existing at the beginning of the passed character string is identified as an argument, and The character string existing on the side can be identified as the next instruction code following “G00”.

  If the character indicated by the argument extraction pointer has already been processed, the process proceeds to step S108; otherwise, the process proceeds to step S105.

  In step S105, a character string indicating a numerical value included from the position of the argument extraction pointer at that time to the next space position is extracted and combined with the character indicated by the argument extraction pointer as numerical data indicated by the argument. recognize.

  Specifically, when the argument extraction pointer indicates “X”, the argument X is recognized as X = 100.0, and is recorded in a predetermined variable area (or a predetermined buffer) on the memory 26. In this case, it may be recorded as numerical data instead of the character string “100.0”.

  Next, in step S106, it is confirmed whether or not the numerical data recognized in step S105 is in a proper range defined in advance. If it is appropriate, the process proceeds to step S107. If it is not appropriate, a predetermined abnormality is displayed, and the process is terminated. If the numerical data is inappropriate, after a predetermined warning display is performed, the process may proceed to step S107 to continue.

  In step S107, an argument extraction pointer is set to the character next to the character string indicating the argument recognized up to that point and the numerical value attached to the argument. That is, for a character string “X” indicating an argument, after recognizing that X = 100.0, the argument extraction pointer is set at the position of the next character string “Y”. Thereafter, the process proceeds to step S102.

  In this way, by repeatedly performing steps S102 to S107, the argument corresponding to the instruction code “G00” is set to X = 100.0, Y = 200.X for the character string “X100.0 Y200.0 E100”. It can be recognized as 0. Thereafter, when the argument extraction pointer is set at the position of the character string “E”, it is recognized in step S103 that the character string “E” is not an argument, and the process proceeds to step S108.

  In step S108 (conversion means), “G00” is converted into a binary format by reflecting the number of arguments (0 to 6) recognized up to that point and the numerical data of each argument.

  The conversion here does not simply change the expression format of the character string “G00” into a binary format, but converts it into a format (ie, an execution code) that can be read and executed by the execution processing unit 32 in the NC device 14. Say. The converted code is written in a predetermined address order in the area where the execution program 28 is recorded.

  Thereafter, up to “X100.0 Y200.0” based on the position of the argument extraction pointer at this point in the character string “X100.0 Y200.0 E100” that has been delivered. The instruction code extraction unit 42 is notified that the character string “E100” that has been recognized has not yet been processed. Based on this notification, the instruction code extraction unit 42 moves the instruction extraction pointer in step S13.

  After the processing in step S108, the current processing in the binary conversion unit 46a, that is, the processing shown in FIG. Of course, when a plurality of character strings “G00” as instruction codes are described in the machining program 16a, the binary conversion unit 46a is called again.

  Although the processing of the binary conversion unit 46a corresponding to the instruction code “G00” has been described so far, the binary conversion unit is also used for the other instruction codes “G01”, “G02”, “E”, “F”, and “N”. The same processing is performed by 46b to 46f (see FIG. 1). The binary conversion units 46a to 46f may share portions corresponding to steps S101 to S107 in common and provide only portions corresponding to step S108 individually.

  In the above example, an example in which two instruction codes “G00” and “E100” are included in one line has been described. Similarly, when three or more instruction codes are included in one line. It can be processed.

  By the way, the instruction codes described in the machining program 16a are classified into operation instructions and non-operation instructions. The operation command is a command for actually operating an actuator such as the motor 36 or the solenoid 37, and the non-operation command is a command for parameter setting such as speed setting or feed setting, and does not involve actual operation. .

When describing in the machining program 16a by combining the motion command and the non-motion command, for example, setting the speed of each axis to 100 [%] and positioning to the coordinates of X = 100.0, Y = 200.0. ,
"G00 X100.0 Y200.0 E100"
And the description
“E100 G00 X100.0 Y200.0”
Both of the descriptions may be allowed.

  In such a case, the code converted in step S108 is not directly written in the area for recording the execution program 28, but once for the operation instruction recording area and the non-operation instruction recording area. The codes may be rearranged and recorded as the execution program 28 after the conversion to the entire processing program 16a (or a predetermined portion) is completed.

  The execution program 28 created by converting the machining program 16a by the above procedure is read and executed by the computer of the execution processing unit 32, and controls the motor 36, the solenoid 37, and the like via the amplifier 34.

  The above procedure may be a so-called compiler type conversion system in which the execution program 28 is executed once after the execution program 28 is created based on the machining program 16a, or the machining program 16a is executed as the execution program. It may be a so-called interpreter type conversion system in which the converted portion is immediately executed while being converted to 28.

  Next, a procedure for converting the machining program 16 into the execution program 28 when a new instruction code is applied to the machining program 16 will be described.

  The new instruction code described here is not applied conventionally and is expressed as “G103”. The instruction code “G103” is a code for setting a tap cycle, and is an exclusive instruction code. The argument includes “N” indicating the number of rotations of the tool, “F” indicating the pitch, It is assumed that “P” for timer setting can be taken.

Using this instruction code “G103”, “G103 N8 F0.8 P1.0 F600” is added to the machining program 16.
The case where the character string is described will be described below.

  In this case, “F0.8” at the head of the two character strings “F” is an argument of “G103” and indicates that the pitch is 0.8 [mm]. On the other hand, “F600” on the rear side is an instruction code different from “G103”, and indicates that the interpolation operation speed is 600 [mm / s]. “N8” is an argument of “G103”, which indicates that the number of rotations of the tool is 8, and is different from the instruction code “N”. “P1.0” is an argument of “G103” and indicates a timer function of 1.0 [s].

  When a new instruction code “G103” is described in the machining program 16 and the machining program 16 is converted into the execution program 28, the work shown in FIG. 7 is performed as a preparation.

  First, in step S201, a binary conversion unit 46g (see FIG. 1) for converting a new instruction code “G103” into a binary code is additionally registered in the conversion processing unit 44 (see FIG. 1). In this case, it is not necessary to change the other binary conversion units 46a to 46f and the instruction code extraction unit 42.

  The binary conversion unit 46g has basically the same configuration as the binary conversion unit 46a described with reference to FIG. 6, and the part corresponding to step S108 is different. That is, the binary conversion unit 46a converts the instruction code “G00” into the binary format, whereas the binary conversion unit 46g converts the instruction code “G103” into the binary format in the portion corresponding to step S108. In the following description, the binary conversion unit 46g will be described using the same step numbers as in FIG.

  Next, in step S202, a new instruction code “G103” is additionally registered in the first list 18 and updated (see FIG. 3B).

  Further, in step S203, the instruction code “G103” and its possible arguments “N”, “F”, and “P” are additionally registered in the second list 20 and updated (see FIG. 4B).

  For example, the editor 24 may be used for the additional registration with respect to the first list 18 and the second list 20.

  After completing the preparation up to step S203 in this way, the processing shown in FIGS. 5 and 6 is executed.

  In this case, in steps S9 and S10, it is possible to recognize that the character string “G103” is an instruction code by referring to the updated first list 18 (see FIG. 3B), and the first one character. Can be distinguished from “G00”, “G01”, and “G02” of other instruction codes having the same.

  Thereafter, in step S11, the binary conversion unit 46g corresponding to the instruction code “G103” is appropriately called, and the character string “N8 F0.8 P1.0 F600” following “G103” is converted into the binary conversion unit. Delivered to 46g.

  In the processing in the binary conversion unit 46g, it is possible to recognize that the character string “N” is an argument of “G103” by referring to the updated second list 20 (see FIG. 4B) in steps S102 and S103. Yes, and can be distinguished from the label number designation code “N”.

  Furthermore, in steps S105 and S106, by recognizing the character string “8” following the character string “N”, it becomes possible to recognize that N = 8, that is, the number of rotations of the tool is 8, and the instruction code The process for [N], which is the first argument of “G103”, ends.

  Next, in step S107, the argument extraction pointer is set at the top position of the two character strings “F”. Thereafter, as in the case of the character string “N”, it is recognized that F = 0.8, that is, the pitch is 0.8 [mm].

  Further, the argument extraction pointer is set at the position of the character string “P” and the same processing is performed to recognize the timer function of P = 1.0, that is, 1.0 [s].

  In this way, the arguments “N8”, “F0.8”, and “P1.0” that are subordinate to the new instruction code “G103” can be correctly recognized.

  Furthermore, in step S107, the argument extraction pointer is set at the rear position of the two character strings “F”, and the process proceeds to step S104 via step S103. In step S104, as described above, it is checked whether or not the character string “F” indicated by the argument extraction pointer at that time has been processed, but there are two character strings “F”. Since it is the rear side, it is determined that the processing has already been performed once, and the process proceeds to step S108.

  Accordingly, it is possible to correctly determine that the character string “F” on the rear side and “600” subsequent thereto are not arguments of the instruction code “G103” but are different next instruction codes.

  Thereafter, in step S108, each recognized argument and its numerical data are reflected to convert the new instruction code “G103” into a binary format.

  As described above, according to the source program conversion system 10 according to the present embodiment, when a new instruction code such as “G103” is used, the binary conversion unit 46g corresponding thereto is additionally registered in the conversion processing unit 44. In addition, the instruction code “G103” and its arguments “N”, “F”, and “P” may be additionally registered in the first list 18 and the second list 20. In this case, the other binary conversion units 46a to 46f and the instruction code extraction unit 42 are not affected and need not be corrected.

Next, in order to compare with the source program conversion method according to the present embodiment, a conventional technique will be described.

  In the prior art, among the character strings read into the buffer from the machining program 16a, “E”, “F”, which appears next from any of the characters “E”, “F”, “G” or “N”, The period up to “G” or “N” is recognized as one command. Therefore, when a new instruction code such as “G103” is defined as taking “F” or “N” as an argument, the instruction code cannot be distinguished from the argument as it is, It is necessary to provide a determination process.

  That is, it is necessary to add or change exception processing having the following meaning in a processing unit corresponding to the instruction code extraction unit 42 or a processing unit corresponding to the conversion processing unit 44.

  In other words, the exception processing in this case means “however, if the first character string of the portion to be carved is“ G103 ”,“ F ”and“ N ”for the first time are ignored”.

  In addition, such addition and change operations need to be performed every time a new instruction code is applied, and the processing unit corresponding to the instruction code extraction unit 42 becomes increasingly complicated. May cause human error. In addition, it becomes difficult for those who are not in charge of the addition and change operations to understand the processing structure. Furthermore, so-called version management becomes complicated.

On the other hand, according to the source program conversion method according to the present embodiment, the instruction code extraction unit 42 and the conversion processing unit 44 extract the instruction code while referring to the first list 18 and the second list 20. When this instruction code is applied, it is not necessary to change the instruction code extraction unit 42 or the binary conversion units 46a to 46f corresponding to the conventional instruction code. In this case, the instruction list itself and the argument are additionally registered in the first list 18 and the second list 20 in correspondence with the new instruction code, but this procedure is very easy and additionally registered. Even if the number increases, the basic structure of the first list 18 and the second list 20 does not change. Therefore, even a person who does not grasp the history of additional registration up to that point can easily apply a new instruction code in a short time.

As described above, according to the source program conversion method according to the present embodiment, when a new instruction code is applied to the machining programs 16 and 16a, the instruction code can be easily applied.

  In the above description, instruction codes for setting operations and conditions such as “E”, “G00”, and “G103” are illustrated as instruction codes. However, in addition to this, branch processing, arithmetic processing, and substitution processing are performed. Of course, it is applicable also about the instruction code regarding such as. For example, the registration data in the second list 20 has no argument, and the process in step S108 is replaced with a branch instruction, an operation instruction, and an assignment instruction, so that it can be applied to these processes. That is, the process shown in FIG. 6 is prepared for each instruction code, and can be created without being affected by the overall mechanism and other instruction processes.

Furthermore, the source program conversion method according to the present embodiment is not limited to the machining program 16 for controlling the NC device 14, but can be applied to other types of programs.

  In the above description, an example in which one instruction code “G103” is applied as a new instruction code has been described. However, the same procedure can be used when there are a plurality of new instruction codes. It is.

  Furthermore, in the above description, an example in which instruction codes and arguments are extracted with reference to the first list 18 and the second list 20 has been described. However, the second list 20 corresponds to the leftmost column in FIG. 4A. The portion to be used may also be used as the first list 18, and the first list 18 itself may be omitted.

  Although the execution program 28 has been described as being converted from one machining program 16, the machining program 16 may be composed of a plurality of files.

Of course, the source program conversion method according to the present invention is not limited to the above-described embodiment, and can take various configurations without departing from the gist of the present invention.

It is a block diagram of a source over the scan program conversion system. It is a figure which shows the content of the processing program. FIG. 3A is a diagram showing the contents of the first list, and FIG. 3B is a diagram showing the contents of the first list updated by additionally registering a new instruction code. FIG. 4A is a diagram showing the contents of the second list, and FIG. 4B is a diagram showing the contents of the second list updated by additionally registering a new instruction code. It is a flowchart which shows the procedure of the process which an input part and an instruction code extraction part perform. It is a flowchart which shows the procedure of the process which a binary conversion part performs. It is a flowchart which shows the procedure of the preparation at the time of applying a new instruction code.

Explanation of symbols

DESCRIPTION OF SYMBOLS 10 ... Source program conversion system 14 ... NC apparatus 16, 16a ... Machining program 18, 18a ... 1st list 20, 20a ... 2nd list 22 ... Editing terminal 24 ... Editor 26 ... Memory 28 ... Execution program 30 ... Conversion part 32 ... Execution processing unit 40 ... input unit 42 ... instruction code extraction unit 44 ... conversion processing units 46a to 46g ... binary conversion unit

Claims (5)

In a source program conversion method for converting a text source program including an instruction code and its argument into an executable program that can be read and executed by a computer,
The instruction code is extracted by referring to a list in which instruction codes applied in advance and arguments subordinate to each instruction code are recorded while sequentially reading from the first character of the character string group of the source program by the instruction code extracting means. An instruction extraction process to
When the instruction code extracted by the instruction code extraction means takes an argument, the argument extraction means refers to a location corresponding to the instruction code in the list, and the instruction code is extracted from a character string following the instruction code. An argument extraction step for extracting an argument corresponding to the code;
An instruction code extracted by the instruction code extracting means is converted together with an argument extracted by the argument extracting means by an instruction code dedicated converting means corresponding to the instruction code among a plurality of instruction code exclusive converting means, and executable. A conversion process for generating a simple executable code,
An update step in which the character string described next to the character string converted by the instruction code exclusive conversion means is used as the first character of the character string group by the instruction code extraction means ;
Have
Repeatedly executing the instruction extraction step, the argument extraction step, the conversion step and the update step ;
The argument extraction step sequentially examines a character string following the instruction code and sequentially extracts arguments. When an argument of the same character string as the extracted character string has already been extracted, the instruction code at that time is A source program conversion method characterized in that extraction of a corresponding argument is terminated . The source program conversion method according to claim 1 ,
The list includes a first list in which instruction codes are recorded;
A second list in which the dependent arguments are recorded for each instruction code;
A source program conversion method characterized in that the source program conversion method is divided into two. The source program conversion method according to claim 1 or 2 ,
The instruction code dedicated conversion means includes a binary conversion unit that generates an execution code corresponding to each instruction code,
A source program conversion method, wherein a binary conversion unit corresponding to an instruction code can be additionally registered in the instruction code dedicated conversion means. In the source program conversion method according to any one of claims 1 to 3 ,
The argument extraction means is included in the instruction code dedicated conversion means,
The instruction code extracting means passes the character string group following the instruction code extracted with reference to the list to the instruction code dedicated converting means while sequentially reading from the first character of the character string group of the source program. Source program conversion method. In the source program conversion method according to any one of claims 1 to 4 ,
A source program conversion method, wherein the source program is divided between an instruction code and an argument and between arguments by a space.

Images