Comment manipulation

December 17, 2014

I have searched an not found what I am looking for, close but no cigar

Is there a way to take a comment, parse it out to say 80 characters and break multiple lines of comment up in individual lines?

I am trying to use Group Comment to add set up notes to the header section of the file. I am getting the comment out where I where I want it but it runs on.....

right now I am adding a parenthesis to the end, hitting enter and adding parenthesis as needed.

I have found info to truncate but nothing that can break it up and create multiple lines

Can you help a brother out?

EX-wccprogrammer · December 17, 2014

The brksps function will break a string at any given point. Using the right logic, you can achieve what you desire.

Colin Gilchrist · December 17, 2014

Hi John,

Yes, you can use the string manipulation functions to get what you are after.

'strlen' = string length. You can get the length of a string (returns result to a numeric variable).

'brksps' = Break space. Breaks a string at a specified length. Input is a string, and an integer (location you want to break).

'strstr' = string to string. Searches a string for a substring value, and returns an integer value of the starting index location of the substring within the string.

December 18, 2014

Can anyone point me at what I am missing?

I am loading in a comment from Group Comment and trying to parse it down to 60 characters on each line

I have output the starting variable sinput_str, it is picking up the full comment but when I start to break it down I get nothing out of the holder string variables

pgroupcomm

      sinput_str = sgroupcomm
      length = strlen(sinput_str)  #Get length of string
      breakpasses = length/60
      if breakpasses < 0,
       [
          result = mprint(scomm_error)
	  scomm_error, e$ #Write error message to NC file
	  exitpost$
       ]
      while breakpasses > 0,
       [
          strtemp = brksps(60, sinput_str) # Break string
          strtemp = slin(counter1, str0)
          counter1 = counter1 + 1
          sinput_str = strtemp
          breakpasses = breakpasses - 1
       ]

length         : 0     #Length of string
breakpasses    : 0     #Calculate NUmber of break passes
counter1       : 0     #Counter for string
cnt_result     : 0     #Save result information         
sinput_str     : ""    #Imported String
strtemp        : ""    #Temp string holder

str0         :""     #Empty String 0-11 
str1        :""
str2        :""
str3        :""
str4        :""
str5        :""
str6        :""
str7        :""
str8        :""
str9        :""
str10        :""
str11        :""

EX-wccprogrammer · December 18, 2014

I would write it like this:

      if breakpasses > 1,
       [
          strtemp = brksps(60, sinput_str) # Break string
          str0 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str1 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str2 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str3 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str4 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str5 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str6 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str7 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str8 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str9 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str10 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str11 = "(" + strtemp + ")"
          pbld, *str0, e$
          pbld, *str1, e$
          pbld, *str2, e$ 
          pbld, *str3, e$
          pbld, *str4, e$
          pbld, *str5, e$
          pbld, *str6, e$ 
          pbld, *str7, e$
          pbld, *str8, e$
          pbld, *str9, e$
          pbld, *str10, e$ 
          pbld, *str11, e$ 
          str0 = "" 
          str1 = "" 
          str2 = ""
          str3 = "" 
          str4 = "" 
          str5 = "" 
          str6 = "" 
          str7 = "" 
          str8 = "" 
          str9 = "" 
          str10 = "" 
          str11 = "" 
       ]

crazy^millman · December 18, 2014

John, from what I have seen posted over the years about the different things going on you must use a buffer to send the information to. Then once you pull it out of the buffer you can then apply the above processes to it. Without the buffer the data in the NCI pulled into the PST is temporary and is lost. by using the buffers is acts like a vault holding everything in it to be used at a alter time when needed. Why the Tool table and other things you buffers to make it work correctly.

Colin will probably chime in and give a better explanation.

December 18, 2014

I would write it like this:

      if breakpasses > 1,
       [
          strtemp = brksps(60, sinput_str) # Break string
          str0 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str1 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str2 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str3 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str4 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str5 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str6 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str7 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str8 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str9 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str10 = "(" + strtemp + ")"
          strtemp = brksps(60, sinput_str) # Break string
          str11 = "(" + strtemp + ")"
          pbld, *str0, e$
          pbld, *str1, e$
          pbld, *str2, e$ 
          pbld, *str3, e$
          pbld, *str4, e$
          pbld, *str5, e$
          pbld, *str6, e$ 
          pbld, *str7, e$
          pbld, *str8, e$
          pbld, *str9, e$
          pbld, *str10, e$ 
          pbld, *str11, e$ 
          str0 = "" 
          str1 = "" 
          str2 = ""
          str3 = "" 
          str4 = "" 
          str5 = "" 
          str6 = "" 
          str7 = "" 
          str8 = "" 
          str9 = "" 
          str10 = "" 
          str11 = "" 
       ]

This is the whole test note

SO NOW THE QUESTION IS HOW MUCH INFORMATION CAN WE GET INTO THIS BOX BEFORE THE COMMENT WILL EXTEND OFF THE PAGE ABD CAUSE ISSUES,

Just plugged that in and got this

( THIS BOX BEFORE THE COMMENT WILL EXTEND OFF THE PAGE ABD CAUSE ISSUES,)

()

Dropping part of the comment.........

Buffers , ugh

crazy^millman · December 18, 2014

Buffers , ugh

Yes buffers the one things about pst I have never been able to wrap my brain around.

EX-wccprogrammer · December 18, 2014

Bear with me, I am slinging code on the fly without debugging. :blushing:

If you are using buffers, make sure that str0 - str11 are being passed into the buffer, so they can be retrieved.

Also, to prevent empty parentheses, place a little logic like this:

           if strtemp <> "", str1 = "(" + strtemp + ")"

do the same for all the str0 type variable assignments. HTH :cheers:

December 18, 2014

Bear with me, I am slinging code on the fly without debugging.

If you are using buffers, make sure that str0 - str11 are being passed into the buffer, so they can be retrieved.

Also, to prevent empty parentheses, place a little logic like this:
           if strtemp <> "", str1 = "(" + strtemp + ")" 
do the same for all the str0 type variable assignments. HTH

Nope, no buffers......yet

Hoping to avoid them, they give me migraines

PcRobotic · December 18, 2014

Hi John,

Yes, you can use the string manipulation functions to get what you are after.

'strlen' = string length. You can get the length of a string (returns result to a numeric variable).

'brksps' = Break space. Breaks a string at a specified length. Input is a string, and an integer (location you want to break).

'strstr' = string to string. Searches a string for a substring value, and returns an integer value of the starting index location of the substring within the string.

Is there away that I can ask a command to "AUTOMATICALLY" introduce another line if detecting an "ENTER KEY" has been used?

For example:

In WCS COMMENT - XY0 = CENTER OF STOCK (Enter key used here) Z0 = TOP OF STOCK (enter key used here) CHECK SURFACE PRIOR RUNNING EQUIPMENT

then it would look like this:

XY0 = CENTER OF STOCK

Z0 = TOP OF STOCK

CHECK SURFACE PRIOR RUNNING EQUIPMENT

Thank you.....

Colin Gilchrist · December 18, 2014

Is there away that I can ask a command to "AUTOMATICALLY" introduce another line if detecting an "ENTER KEY" has been used?

For example:

In WCS COMMENT - XY0 = CENTER OF STOCK (Enter key used here) Z0 = TOP OF STOCK (enter key used here) CHECK SURFACE PRIOR RUNNING EQUIPMENT

then it would look like this:

XY0 = CENTER OF STOCK

Z0 = TOP OF STOCK

CHECK SURFACE PRIOR RUNNING EQUIPMENT

Thank you.....

No. Because the "Enter Key" is not a standard ASCII output character. I usually use an odd character like the Tilde '~' or the Pipe character '|' as the separator, then you can use the string functions to break the lines.

John, I'll take a stab at it and see if I can give you something useful.

What post are you using? The Generic Haas 4X Mill Post for X8 had some improvements regarding comment output. I rewrote the comment handling in the post to be able to read the "max nc comment" field in the Control Definition, and then use that limit for shortening or truncating the comment. I will see about adding a 3rd comment mode (break comment strings) to that post logic, then put it up as an example....

December 18, 2014

No. Because the "Enter Key" is not a standard ASCII output character. I usually use an odd character like the Tilde '~' or the Pipe character '|' as the separator, then you can use the string functions to break the lines.

John, I'll take a stab at it and see if I can give you something useful.

What post are you using? The Generic Haas 4X Mill Post for X8 had some improvements regarding comment output. I rewrote the comment handling in the post to be able to read the "max nc comment" field in the Control Definition, and then use that limit for shortening or truncating the comment. I will see about adding a 3rd comment mode (break comment strings) to that post logic, then put it up as an example....

Colin, I did look through that, I saw what was going on with truncating the comments ,I couldn't really see how that was going to move me forward on it

I have a Gen 4 Axis Fanuc I am banging on, X8 flavor

PcRobotic · December 18, 2014

No. Because the "Enter Key" is not a standard ASCII output character. I usually use an odd character like the Tilde '~' or the Pipe character '|' as the separator, then you can use the string functions to break the lines.

John, I'll take a stab at it and see if I can give you something useful.

What post are you using? The Generic Haas 4X Mill Post for X8 had some improvements regarding comment output. I rewrote the comment handling in the post to be able to read the "max nc comment" field in the Control Definition, and then use that limit for shortening or truncating the comment. I will see about adding a 3rd comment mode (break comment strings) to that post logic, then put it up as an example....

Hi,

I looked for "max nc comment" and it said NOT FOUND in the .PST file. Is there another way I search for it? Thank you.

Colin Gilchrist · December 18, 2014

Hi,

I looked for "max nc comment" and it said NOT FOUND in the .PST file. Is there another way I search for it? Thank you.

Hi Steven,

My response about that was directed at John, not part of my response to you. I'm sorry if that wasn't clear.

This function is available in the Control Definition, not the post processor. From what I remember, on the new X8 Generic Haas 4X Mill post has this modified comment logic, so it isn't a surprise that you can't find it in your post processor. Unless you are using the post I mentioned, the code isn't in your post.

Thanks,

Colin

Colin Gilchrist · December 19, 2014

Hi John,

I modified a copy of the Generic Haas 4X Mill Post to include the logic to break a string into multiple separate comments, based on a comment length. Don't feel bad about not being able to figure this out, there are some tricks you've got to be aware of.

First, post processors output two different types of comments; comments that are generated internally inside the post processor, and comment strings that are passed from the NCI file. MP has an internal mechanism for comment handling, and that mechanism reads the "max nc comment" value that is set inside the Control Definition. When you set a limit of say "80" characters as your "max nc comment" value, MP will automatically truncate the comment to that value before the comment is output. That is the issue you were facing. You were passing a string that has 130+ characters, but MP was chopping off the characters that wouldn't fit, and not telling you about it.

The problem is that that "max nc character" value doesn't get applied to strings that are generated internally, inside the post. The issue where this usually comes up is long file paths. These are strings that are built inside the post processor, so there needed to be a way to control the output from both string sources.

So really, to be able to pass a long string for comment you've got to increase that max character limit in the Control Definition. That means to get the breaking to work, I had to create a user defined variable to take the place of the value in the CD. The max value the field will let you enter is '256' characters, so that is what I would use.

Once you get around that problem, the rest is fairly easy. (Not knowing about that behavior is enough to get you to tear your hair out.)

Now it is just a simple matter of setting up a counter variable, and using a while loop to break the string and output the sections. I added some extra logic to check the division of the string length, by the max output value. When you make the equation, the variable returned might have a remainder. We could test the value, and if the remainder is greater than .5, we could format the value (to get the rounded integer), and if less than .5, we could format (round down), then add "1" to the test. Instead, I used the 'int' function to get the number of "integer" breaks, and tested the fractional portion. If there is a remainder, I add a digit to the break counter.

comment_mode : 2     #0 = Truncate For comments that exceed Maximum Characters in NC comment
                     #0=Truncate
                     #1=Shorten
                     #2=Break output (you must set "max nc characters" in CD to 256, otherwise
                     #  MP will truncate the comment coming from the NCI file. Use internal
                     #  comm_brk_len value for controlling the string length. String length
                     #  is total number of characters, including the comment start/end characters
comm_brk_len : 80    #Length of output comment string, when 'comment_mode' is set to '2'

str_len       : 0     #Length of string
str_brk       : 0     #Calculate NUmber of break passes

sccomp_comm      : ""    #String to output cutter comp "type" string in ptooltable
sstock_left_comm : ""    #String to output "stock to leave" strings in ptooltable
scomm_out        : ""    #Return string for comment_fx function (pcomment_out)
scomm_fx_arg     : ""    #Comment temp string (always set 'scomm_fx_arg' before calling pcomment_out)
stemp1           : ""    #Temp string

pcomment$       #Output Comments
      scomm$ = ucase (scomm$)
      if gcode$ = 1005, scomm_fx_arg = scomm$, pcomment_out  #Manual entry - as comment
      if gcode$ = 1006, scomm$, e$                           #Manual entry - as code
      if gcode$ = 1007, sopen_prn, scomm$, sclose_prn        #Manual entry - as comment with move NO e$
      if gcode$ = 1026, scomm$                               #Manual entry - as code with move NO e$
      if gcode$ = 1008, scomm_fx_arg = scomm$, pcomment_out  #Operation comment
      if gcode$ = 1051, scomm_fx_arg = scomm$, pcomment_out  #Machine name
      if gcode$ = 1052, scomm_fx_arg = scomm$, pcomment_out  #Group comment
      if gcode$ = 1053, scomm_fx_arg = scomm$, pcomment_out  #Group name
      if gcode$ = 1054, scomm_fx_arg = scomm$, pcomment_out  #File Descriptor

pcomment_probe$ #Renishaw probe 'comment' output postblock
      scomm$, e$

pcomment_out #Check comment length, truncate/shorten if necessary
      comm_len = strlen(sopen_prn + sclose_prn) #Get length of comment begin and end strings
      if comment_mode < two,
        [
        scomm_out = comment_fx(maxnccomment$ - comm_len, scomm_fx_arg, comment_mode)
        sopen_prn, no_spc$, scomm_out, no_spc$, sclose_prn, e$ #Output truncated comment
        ]
      else, #Break comment into multiple lines of output. Must set 'max nc comment' length in CD to 256, so MP won't truncate the string
        [
        comm_brk_len = comm_brk_len - comm_len #subtract comment begin/end strings
        str_len = strlen(scomm_fx_arg) #Get length of comment string
        str_brk = int(str_len / comm_brk_len) #Get number of broken output strings
        if frac(str_len / comm_brk_len), str_brk = str_brk + one #Add one more output if not even division
        scomm_out = scomm_fx_arg #assign string to scomm_out
        while str_brk > zero, #Output broken comments
          [
          stemp1 = brksps(comm_brk_len, scomm_out) #Break string at specified position
          sopen_prn, no_spc$, scomm_out, no_spc$, sclose_prn, e$ #Output broken comment
          scomm_out = stemp1 #Set 'scomm_out' back to stemp1, so it can be broken again in while loop
          str_brk = str_brk - one #Decrement counter
          ]
        ]
        scomm_out = sblank #Reset scomm_out

You can check the full post processor modifications in the Zip to Go file.

Comment breaking test.Z2G

December 19, 2014

NICE!!!!

Colin tanks a ton, I'll take a peek at the full logic

Yeah, looking at this and what you've stated, there is definitely some stuff going on in MP that I was unaware was happening

I did notice this comment here

#Break comment into multiple lines of output. Must set 'max nc comment' length in CD to 256, so MP won't truncate the string

I am assuming that means that MP still has the internal 256 character limit when processing comments?

PcRobotic · December 19, 2014

No. Because the "Enter Key" is not a standard ASCII output character. I usually use an odd character like the Tilde '~' or the Pipe character '|' as the separator, then you can use the string functions to break the lines.

John, I'll take a stab at it and see if I can give you something useful.

What post are you using? The Generic Haas 4X Mill Post for X8 had some improvements regarding comment output. I rewrote the comment handling in the post to be able to read the "max nc comment" field in the Control Definition, and then use that limit for shortening or truncating the comment. I will see about adding a 3rd comment mode (break comment strings) to that post logic, then put it up as an example....

Hi Colin,

I'm still finding ways to separate lines whenever it detecting an "ENTER KEY". Is there any trick to do it? Thank you for your help.

crazy^millman · December 19, 2014

Hi John,

I modified a copy of the Generic Haas 4X Mill Post to include the logic to break a string into multiple separate comments, based on a comment length. Don't feel bad about not being able to figure this out, there are some tricks you've got to be aware of.

First, post processors output two different types of comments; comments that are generated internally inside the post processor, and comment strings that are passed from the NCI file. MP has an internal mechanism for comment handling, and that mechanism reads the "max nc comment" value that is set inside the Control Definition. When you set a limit of say "80" characters as your "max nc comment" value, MP will automatically truncate the comment to that value before the comment is output. That is the issue you were facing. You were passing a string that has 130+ characters, but MP was chopping off the characters that wouldn't fit, and not telling you about it.

The problem is that that "max nc character" value doesn't get applied to strings that are generated internally, inside the post. The issue where this usually comes up is long file paths. These are strings that are built inside the post processor, so there needed to be a way to control the output from both string sources.

So really, to be able to pass a long string for comment you've got to increase that max character limit in the Control Definition. That means to get the breaking to work, I had to create a user defined variable to take the place of the value in the CD. The max value the field will let you enter is '256' characters, so that is what I would use.

Once you get around that problem, the rest is fairly easy. (Not knowing about that behavior is enough to get you to tear your hair out.)

Now it is just a simple matter of setting up a counter variable, and using a while loop to break the string and output the sections. I added some extra logic to check the division of the string length, by the max output value. When you make the equation, the variable returned might have a remainder. We could test the value, and if the remainder is greater than .5, we could format the value (to get the rounded integer), and if less than .5, we could format (round down), then add "1" to the test. Instead, I used the 'int' function to get the number of "integer" breaks, and tested the fractional portion. If there is a remainder, I add a digit to the break counter.
comment_mode : 2     #0 = Truncate For comments that exceed Maximum Characters in NC comment
                     #0=Truncate
                     #1=Shorten
                     #2=Break output (you must set "max nc characters" in CD to 256, otherwise
                     #  MP will truncate the comment coming from the NCI file. Use internal
                     #  comm_brk_len value for controlling the string length. String length
                     #  is total number of characters, including the comment start/end characters
comm_brk_len : 80    #Length of output comment string, when 'comment_mode' is set to '2'

str_len       : 0     #Length of string
str_brk       : 0     #Calculate NUmber of break passes
sccomp_comm      : ""    #String to output cutter comp "type" string in ptooltable
sstock_left_comm : ""    #String to output "stock to leave" strings in ptooltable
scomm_out        : ""    #Return string for comment_fx function (pcomment_out)
scomm_fx_arg     : ""    #Comment temp string (always set 'scomm_fx_arg' before calling pcomment_out)
stemp1           : ""    #Temp string
pcomment$       #Output Comments
      scomm$ = ucase (scomm$)
      if gcode$ = 1005, scomm_fx_arg = scomm$, pcomment_out  #Manual entry - as comment
      if gcode$ = 1006, scomm$, e$                           #Manual entry - as code
      if gcode$ = 1007, sopen_prn, scomm$, sclose_prn        #Manual entry - as comment with move NO e$
      if gcode$ = 1026, scomm$                               #Manual entry - as code with move NO e$
      if gcode$ = 1008, scomm_fx_arg = scomm$, pcomment_out  #Operation comment
      if gcode$ = 1051, scomm_fx_arg = scomm$, pcomment_out  #Machine name
      if gcode$ = 1052, scomm_fx_arg = scomm$, pcomment_out  #Group comment
      if gcode$ = 1053, scomm_fx_arg = scomm$, pcomment_out  #Group name
      if gcode$ = 1054, scomm_fx_arg = scomm$, pcomment_out  #File Descriptor

pcomment_probe$ #Renishaw probe 'comment' output postblock
      scomm$, e$

pcomment_out #Check comment length, truncate/shorten if necessary
      comm_len = strlen(sopen_prn + sclose_prn) #Get length of comment begin and end strings
      if comment_mode < two,
        [
        scomm_out = comment_fx(maxnccomment$ - comm_len, scomm_fx_arg, comment_mode)
        sopen_prn, no_spc$, scomm_out, no_spc$, sclose_prn, e$ #Output truncated comment
        ]
      else, #Break comment into multiple lines of output. Must set 'max nc comment' length in CD to 256, so MP won't truncate the string
        [
        comm_brk_len = comm_brk_len - comm_len #subtract comment begin/end strings
        str_len = strlen(scomm_fx_arg) #Get length of comment string
        str_brk = int(str_len / comm_brk_len) #Get number of broken output strings
        if frac(str_len / comm_brk_len), str_brk = str_brk + one #Add one more output if not even division
        scomm_out = scomm_fx_arg #assign string to scomm_out
        while str_brk > zero, #Output broken comments
          [
          stemp1 = brksps(comm_brk_len, scomm_out) #Break string at specified position
          sopen_prn, no_spc$, scomm_out, no_spc$, sclose_prn, e$ #Output broken comment
          scomm_out = stemp1 #Set 'scomm_out' back to stemp1, so it can be broken again in while loop
          str_brk = str_brk - one #Decrement counter
          ]
        ]
        scomm_out = sblank #Reset scomm_out
You can check the full post processor modifications in the Zip to Go file.

Comment breaking test.Z2G

Colin, thanks for breaking out the secret decoder ring. I copied this and downloaded it to have for future reference. :unworthy:

December 19, 2014

Colin,

That got me exactly what I needed with some minor mods

THANK YOU!!!!!

Colin Gilchrist · December 19, 2014

Hi John,

You are very welcome. Glad it worked for you.

You asked about the MP internal string limit. The '256' character limit is actually imposed by the settings allowed in the Control Definition data entry field. In reality, that is an artificial limit imposed by the CD.

The actual "internal" limit for string length is set by Windows. (I think it is an Environmental Variable called "MAX_PATH"). I think with the 64-bit versions of windows, the value either 1024 or 2056 characters.

There is one other thing to be aware of if you are working with string characters in MP. I think there is an internal limit for the number of characters allowed on a single line inside the PST file. It is around 380 characters, if I remember correctly. We found that one because someone created a very long string concatenation line, that exceeded that limit. This was mostly due to excessively long variable names. Shortening up the variable name strings did the trick.

Colin Gilchrist · December 19, 2014

Colin, thanks for breaking out the secret decoder ring. I copied this and downloaded it to have for future reference. :unworthy:

Anytime Ron. If you run into challenges with buffers, you can always give me a call. I taught a class earlier this year for understanding Buffer Files.

December 19, 2014

(PROGRAMED BY JOHN PARIS ON 12 /19 /2014 AT 12:58 )

( PROGRAMED FOR 4 AXIS ROBODRILL )

( )

(SET UP INSTRUCTIONS: XY ZERO IS THE CENTER OF THE BLOCK, )

(Z ZERO IS THE TOP OF THE BLOCK -- STOCK SIZE IS 5" X 5" X)

( 1" - MATERIAL IS IS 6061 ALUMINUM - CYCLE TIME IS 12.30 )

(- PLEASE REPORT ANY DEVIATION TO ENGINEERING.)

( )

( TOOL - 1 3.00" INSERT CUTTER 6FLT FOR ALUMINUM )

( HANGOUT = 2.000" HOLDER = DEFAULT HOLDER )

( TOOL - 2 .250 3FLT 5/8 LOC DATAFLUTE RDS#3292 )

( HANGOUT = 1.100" HOLDER = ER-16-STUB-COM-C4C4-0016 )

( TOOL - 3 .250 EM WITH .060 RAD 3/4 LOC HARVEY#36260 RDS#1448 )

( HANGOUT = 1.100" HOLDER = ER-16-STUB-COM-C4C4-0016 )

( TOOL - 4 5/16 TaperMilL .187 TIP 15 DEG RDS #2882 )

( HANGOUT = 1.000" HOLDER = ER-16-STUB-COM-C4C4-0016 )

( TOOL - 5 .125 4FLR GARR EM .750 LOC RDS #3438 )

( HANGOUT = .800" HOLDER = ER-16-STUB-COM-C4C4-0016 )

( TOOL - 6 .03 CREM HARVEY #46030 RDS#3005 )

( HANGOUT = .800" HOLDER = ER-11-STUB-COM-C4C4-0011 )

( TOOL - 7 .0938 DEEM .19 LOC SGS-RDS#1028 )

( HANGOUT = .750" HOLDER = ER-11-STUB-COM-C4C4-0011 )

( TOOL - 8 .125 X 90 DEG CHAMFER MILL HARVEY #948645 RDS#TBD )

( HANGOUT = 1.000" HOLDER = ER-11-STUB-COM-C4C4-0011 )

( TOOL - 9 .125 BALL EM .5 LOC HARVEY#27908 RDS#1337 )

( HANGOUT = .800" HOLDER = ER-16-STUB-COM-C4C4-0016 )

( TOOL - 10 .250 BALL MILL TITAN 132944 RDS #1058 )

( HANGOUT = 1.000" HOLDER = ER-20-STUB-COM-C4C4-0020 )

( TOOL - 11 0.070 BALL MILL HARVEY #74370 RDS #1270 )

( HANGOUT = .800" HOLDER = ER-11-TECK )

Colin Gilchrist · December 19, 2014

Looks great John. Are you pulling the stickout from the Assembly definition?

December 19, 2014

Pulling it from parameter 20007

if prmcode$ = 20007,

[

tool_out_length = rparsngl(sparameter$, 3)

tool_hold_length = rparsngl(sparameter$, 7)

]

Sign In

Welcome to eMastercam

Comment manipulation

Recommended Posts

Guest

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Guest

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Guest

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Guest

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Guest

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Guest

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Guest

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Guest

Link to comment

Share on other sites

Link to comment

Share on other sites

Guest

Link to comment

Share on other sites

Join the conversation

Recently Browsing 0 members

Join us!

Useful Links

Legal

Follow us