post modification


Results 1 to 3 of 3

Thread: post modification

  1. #1
    Registered
    Join Date
    Nov 2003
    Location
    canada P.Q.
    Posts
    93
    Downloads
    0
    Uploads
    0

    Default post modification

    with the post I actually use , if I generate a canned thread the code comes out
    as G76 X.. Z.. K.. D.. A.. F.. which is OK. F is the Lead
    If I generate a Long hand thread the generated code looks like
    G33 Z-1 F.05 F is the lead..which is wrong.

    For (G33 only) the letter of the lead should be K instead of F.
    I did try different solutions but did not find the solution..

    the modification should only change the prefix of the lead for thread generation..

    in my attempts it would be ok if my toolpath contained only threads..
    but if I added a linear move like G01 Z-1 F2 the output code for the feed would come out as K2 if i had just generated a Long hand thread(g33)
    I know it is not a big deal and that i can correct the generated code by hand
    but i am trying to understand how to modify a post...I look at it as a challenge...
    thanks for the help .
    the code is following
    pffr #Output feedrate, force

    if ipr_actv$ = zero, pfr_m
    else, pfr_l
    *feed

    pfr #Output feedrate
    if ipr_actv$ = zero, pfr_m
    else, pfr_l
    `feed


    pfr_m #Format feedrate for lathe


    result = nwadrs(strf, feed)
    result = newfs (17, feed)

    pfr_l #Format feedrate for mill
    if opcode$ = 104,
    [
    #Format feedrate for lathe thread

    result = nwadrs(strf, feed)
    result = newfs (19, feed)
    ]
    else,
    [
    result = nwadrs(strf, feed)
    result = newfs (18, feed)
    ]

    pscool #Coolant is separate code
    if cool_w_spd = zero, scoolant
    else,
    [ # 'cool_w_spd' mode is active - (1/10/2003)
    if coolant$ = zero, scoolant #Turn coolant OFF
    else,
    if prv_coolant$ = zero, scoolant #Turn coolant ON
    ]
    !coolant$

    pfscool #Coolant is separate code, force
    if cool_w_spd = zero, *scoolant
    !coolant$

    pcc_capture #Capture ends of canned turning path, stop output w/rough
    #Stop output in rough only lathe canned cycles
    #between rough and finish paths
    if cc_stop_fcc & rcc_flg$ = 6, no_nc_out$ = one
    #Capture vector for G73 cycle
    if rpd_typ$ = 6 & abs(lathecc) = two,
    [
    if rcc_flg$ = one, lcc_xcst = vequ (copy_x)
    if rcc_flg$ = three, lcc_xcend = vequ (copy_x)
    ]

    pcom_moveb #Common motion preparation routines, before
    pshft_map_xa
    pxyzcout
    ps_inc_calc

    ppos_cax_lin #Position C if from CL
    if (prv_pnt_at_zero) & c_axistype < three,
    [
    #Output to NC, C axis movement only - rapid deg/min
    sav_gcode = gcode$
    sav_feed = feed
    gcode$ = one
    if millcc = zero,
    [
    feed = maxfrdeg
    pbld, n$, psgcode, pfcout, pffr, e$
    ]
    else, pbld, n$, psgcode, pfcout, pfr, e$
    gcode$ = sav_gcode
    feed = sav_feed
    ]

    pcom_movea #Common motion preparation routines, after
    pcan2
    pe_inc_calc

    ppos_pnt_zero #Position C if from CL
    !pnt_at_zero
    pnt_at_zero = zero

    #Mill canned cycle output
    pmillccb #Cross/Face canned cycle code, before
    if c1_millcc = n1_millcc & n1_millcc & n1_gcode = 1000
    & cutpos2$ = three,
    [
    sav_cutpos2 = two
    cutpos2$ = two
    ]
    if cutpos2$ = one,
    [
    result = newfs(two, cabs)
    result = newfs(two, cinc)
    #Cross/Face canned cycle start code
    if abs(cuttype) = two,
    [
    #Face canned cycle start code, G112 (break ramp)
    pbld, n$, *sgfeed, *sgcode, *sg112, e$
    prv_xabs = c9k
    prv_xinc = c9k
    prv_cabs = c9k
    prv_cinc = c9k
    compok = one
    ]
    else,
    [
    #Cross canned cycle start code, G107
    pbld, n$, *sgcode, *sgfeed, *sg107, *crad, e$
    ]
    ]
    if cutpos2$ > zero & cutpos2$ < four,
    [
    #Change rapid to highest possible feedrate
    if gcode$ = zero,
    [
    gcode$ = one
    feed = maxfeedpm
    ]
    ]

    pmillcca #Cross/Face canned cycle code, after
    if cutpos2$ = three,
    [
    #Cross/Face canned cycle end code
    if abs(cuttype) = two, pbld, n$, *sg113, e$ #Face
    else, pbld, n$, *sg108, "C0.", e$ #Cross
    result = newfs(11, cabs)
    result = newfs(14, cinc)
    ]

    # --------------------------------------------------------------------------
    # Drilling
    # --------------------------------------------------------------------------
    pdrill0$ #Pre-drill postblock call
    if cuttype = five, #Don't allow 5 axis, rests at toolchange
    [
    usecandrill$ = zero
    usecanpeck$ = zero
    usecanchip$ = zero
    usecantap$ = zero
    usecanbore1$ = zero
    usecanbore2$ = zero
    usecanmisc1$ = zero
    usecanmisc2$ = zero
    ]
    else,
    [
    if abs(cuttype) < three, mdrl_dir = zero
    else, mdrl_dir = one
    x$ = xnci$
    y$ = ynci$
    z$ = refht$
    copy_x = vequ(x$)
    pshft_map_xa
    pxyzcout
    refht_x = vequ(xabs)
    z$ = depth$
    copy_x = vequ(x$)
    pshft_map_xa
    pxyzcout
    depth_x = vequ(xabs)
    z$ = zdrl$
    copy_x = vequ(x$)
    pshft_map_xa
    pxyzcout
    zdrl_x = vequ(xabs)
    z$ = initht$ #Initial is last
    copy_x = vequ(x$)
    pshft_map_xa
    pxyzcout
    initht_x = vequ(xabs)
    znci$ = initht$
    ps_inc_calc
    ]

    pdrlcommonb #Canned Drill Cycle common call, before
    if gcode$ = 81,
    [
    if drillcyc$ = three, drlgsel = fsg1 (-g_speed) + drillcyc$ * two #Tap
    else, drlgsel = fsg2 (dwell$) + drillcyc$ * two
    if initht$ <> refht$, drillref = zero
    else, drillref = one
    prv_refht_a = c9k
    prv_refht_i = c9k
    prv_dwell$ = zero
    ]
    if mdrl_dir = zero, #Set Z to depth
    [
    zia = fmtrnd(depth_z)
    zinc = zia - prv_zia
    ]
    else, #Set X to depth
    [
    xia = fmtrnd(depth_x)
    xinc = xia - prv_xia
    ]
    xabs = vequ (depth_x)
    comment$
    pcan

    pgdrlout #Drill Gcode output
    if mdrl_dir = zero, *sgdrillf
    else, *sgdrillc

    prdrlout #R drill position
    if mdrl_dir = zero, refht_a = refht_z
    else, refht_a = refht_x
    refht_i = refht$ - initht$
    if absinc$ = zero, refht_a, !refht_i
    else, refht_i, !refht_a

    ldrill$ #Canned drill cycle, lathe
    #Use this postblock to customize lathe drilling cycles 0 - 7
    pdrlcommonb
    "CUSTOMIZABLE DRILL CYCLE ", pfxout, pfyout, pfzout, e$
    pcom_movea

    lpeck$ #Canned peck drill cycle, lathe
    ldrill$

    lchpbrk$ #Canned chip break cycle, lathe
    gcode$ = zero
    prv_dwell$ = zero
    @dwell$
    comment$
    pcan
    pe_inc_calc
    xabs = vequ(refht_x)
    ps_inc_calc
    pcan1, pbld, n$, sgcode, pzout, strcantext,e$
    pe_inc_calc
    xabs = vequ(depth_x)
    ps_inc_calc
    if old_new_sw = one,
    [
    pbld, n$, *sg74, *peckclr$, e$
    result = nwadrs (strq, peck1$)
    ]
    else, result = nwadrs (strk, peck1$)
    pcan1, pbld, n$, *sg74, pfzout, *peck1$, pffr, strcantext, e$
    prv_gcode$ = -1
    if refht$ <> initht$,
    [
    gcode$ = zero
    xabs = vequ(refht_x)
    ps_inc_calc
    pe_inc_calc
    xabs = vequ(initht_x)
    ps_inc_calc
    pbld, n$, sgcode, pfzout, e$
    ]
    pcom_movea

    ltap$ #Canned tap cycle, lathe
    gcode$ = zero
    prv_dwell$ = zero
    @dwell$
    comment$
    pcan
    pe_inc_calc
    xabs = vequ(refht_x)
    ps_inc_calc
    pcan1, pbld, n$, sgcode, pzout, strcantext, e$
    pe_inc_calc
    xabs = vequ(depth_x)
    ps_inc_calc
    opcode$ = 104 #thread address from feedrate

    #andre pffr pour try
    pbld, n$, *sthdg32, pfzout, pffr, pnullstop, e$
    if dwell$, pdwell1
    pe_inc_calc
    xabs = vequ(refht_x)
    ps_inc_calc
    pswtchspin

    pbld, n$, *sthdg32, pfzout, *spindle_l, e$
    if dwell$, pdwell1
    prv_gcode$ = -1
    pbld, n$, pnullstop,e$
    pswtchspin
    if refht$ <> initht$,
    [
    gcode$ = zero
    pe_inc_calc
    xabs = vequ(initht_x)
    ps_inc_calc

    pbld, n$, sgcode, pfzout, *spindle_l, e$
    ]
    pbld, n$, spindle_l, e$
    opcode$ = 81 #Restore opcode
    pcom_movea

    lbore1$ #Canned bore #1 cycle, lathe
    ldrill$

    lbore2$ #Canned bore #2 cycle, lathe
    ldrill$

    lmisc1$ #Canned misc #1 cycle, lathe
    ldrill$

    lmisc2$ #Canned misc #2 cycle, lathe
    ldrill$

    mdrill$ #Canned drill cycle, mill
    pdrlcommonb
    pcan1, pbld, n$, *sgdrlref, pgdrlout, pxout, pyout, pzout,
    pcout, prdrlout, dwell$, pffr, strcantext, e$
    pcom_movea

    mpeck$ #Canned peck drill cycle, mill
    pdrlcommonb
    pcan1, pbld, n$, *sgdrlref, pgdrlout, pxout, pyout, pzout,
    pcout, prdrlout, *peck1$, dwell$, pffr, strcantext, e$
    pcom_movea

    mchpbrk$ #Canned chip break cycle, mill
    mpeck$

    mtap$ #Canned tap cycle, mill
    pdrlcommonb
    pcan1, pbld, n$, *sgdrlref, pgdrlout, pxout, pyout, pzout,
    pcout, prdrlout, pffr, strcantext, e$
    pcom_movea

    mbore1$ #Canned bore #1 cycle, mill
    mdrill$

    mbore2$ #Canned bore #2 cycle, mill
    mdrill$

    mmisc1$ #Canned misc #1 cycle, mill
    pdrlcommonb
    pcan1, pbld, n$, *sgdrlref, pgdrlout, pxout, pyout, pzout,
    pcout, prdrlout, *shftdrl$, dwell$, pffr, strcantext, e$
    pcom_movea

    mmisc2$ #Canned misc #2 cycle, mill

    mdrill_2$ #Canned drill cycle repeat, mill
    pdrlcommonb
    pcan1, pbld, n$, pxout, pyout, pzout, pcout, prdrlout,
    dwell$, pfr, strcantext, e$
    pcom_movea

    mpeck_2$ #Canned peck drill cycle repeat, mill
    mdrill_2$

    mchpbrk_2$ #Canned chip break cycle repeat, mill
    mdrill_2$

    mtap_2$ #Canned tap cycle repeat, mill
    mdrill_2$

    mbore1_2$ #Canned bore #1 cycle repeat, mill
    mdrill_2$

    mbore2_2$ #Canned bore #2 cycle repeat, mill
    mdrill_2$

    mmisc1_2$ #Canned misc #1 cycle repeat, mill
    mdrill_2$

    mmisc2_2$ #Canned misc #2 cycle repeat, mill
    mdrill_2$

    pdrlcst$ #Custom drill cycles 8 - 19 (user option)
    #Use this postblock to customize drilling cycles 8 - 19
    pdrlcommonb
    "CUSTOMIZABLE DRILL CYCLE ", pfxout, pfyout, pfzout, pfcout, e$
    pcom_movea

    pdrlcst_2$ #Custom drill cycles 8 - 19 (user option)
    #Use this postblock to customize drilling cycles 8 - 19
    pdrlcommonb
    "CUSTOMIZABLE DRILL CYCLE ", pfxout, pfyout, pfzout, pfcout, e$
    pcom_movea

    pcanceldc$ #Cancel drill cycle
    xabs = vequ (initht_x) #Position to return
    ps_inc_calc
    pe_inc_calc #Update to current location
    gcode$ = zero
    pcan
    pcan1, pbld, n$, sgcode, "G80", strcantext, e$
    pcan2

    # --------------------------------------------------------------------------
    # Version 9+ MiscOps Section
    # --------------------------------------------------------------------------
    #Miscellaneous Variables Common to all Miscops operations
    #Format as needed

    #Integers
    #miscops_mi1, miscops_mi2, miscops_mi3,
    #miscops_mi4, miscops_mi5, miscops_mi6,
    #miscops_mi7, miscops_mi8, miscops_mi9,
    #miscops_mi10

    #Reals
    #miscops_mr1, miscops_mr2, miscops_mr3,
    #miscops_mr4, miscops_mr5, miscops_mr6,
    #miscops_mr7, miscops_mr8, miscops_mr9,
    #miscops_mr10
    #
    # --------------------------------------------------------------------------
    #Format Assignments and Initializations
    # --------------------------------------------------------------------------
    fmt Z 2 stck_init_z$ #Initial Z position of the stock (900-902,904,905)
    fmt Z 2 stck_final_z$ #Final Z position of the stock (900-902,904,905)
    fmt Z 2 stck_chuk_st_z$ #Initial Z axis Chuck Position (900-903)
    fmt X 2 stck_chuk_st_x$ #Initial X axis Chuck Position (900-903)
    fmt Z 2 stck_chuk_end_z$ #Final Z axis Chuck Position (900-903)
    fmt X 2 stck_chuk_end_x$ #Final X axis Chuck Position (900-903)
    fmt W 3 stck_chuk_st_dz$ #Destination chuck Z axis reference position before transfer (900)
    fmt U 3 stck_chuk_st_dx$ #Destination chuck X axis reference position before transfer (900)
    fmt W 3 stck_chuk_end_dz$ #Destination chuck Z axis reference position after transfer (900)
    fmt U 3 stck_chuk_end_dx$ #Destination chuck X axis reference position after transfer (900)
    fmt Z 2 stck_clear$ #Stock clearance value for stock pull operation (902)
    fmt X 2 stck_tool_x$ #Tool X axis position for bar stop / puller (902)
    fmt Z 2 stck_grip$ #Grip length value for stock pull operation(902)

    fmt F 18 stck_adv_fr$ #Used with Lathe Stock Advance (Bar-Feed/Pull) function (NCI 902)
    fmt F 18 stck_appr_fr$ #Used with Lathe Stock Advance (Bar-Feed/Pull) function (NCI 902)

    #Flags
    stck_op$ : 0 #Stock advance operation method (902)
    #(0=Push stock,1=Push stock with Use Tool Stop option,2=Pull stock)
    stck_spindle$ : 0 #Active spindle with stock to transfer (900-902)
    #0=Left Spindle,1=Right Spindle
    clmp_op$ : 0 #The selected Operation mode: 0=Clamp,1=Un-clamp,2=Re-position (903)
    clmp_spindle$ : 0 #Active spindle for clamp/unclamp 0=Left Spindle,1=Right Spindle (903)
    tlstck_on$ : 0 #Retract or engage the tailstock (0=Retract,1=Engage) (904)

    toolend_flg : 1 #Flag to execute ptoolend sequence or not


    # --------------------------------------------------------------------------
    #Postblock Section -comments only!
    # --------------------------------------------------------------------------
    pstck_trans$ #NCI code = 900 available variables:
    #stck_spindle, stck_init_z, stck_final_z,
    #stck_chuk_st_z, stck_chuk_st_x,
    #stck_chuk_end_z, stck_chuk_end_x,
    #stck_chuk_st_dz, stck_chuk_st_dx,
    #stck_chuk_end_dz, stck_chuk_end_dx
    if toolchng <> two, ptoolend$
    toolend_flg = zero #Do not execute ptoolend again after xfer
    [
    !spaces$
    spaces$ = zero
    pbld, n$, "M00",e$
    if prv_spaces$ > 0, " ",e$
    if stck_spindle$ = 0, "(Xfer Part from Left Spindle)", e$
    if stck_spindle$ = 1, "(Xfer Part from Right Spindle)", e$
    spaces$ = prv_spaces$
    ]

    pstck_flip$ #NCI code = 901 available variables:
    #stck_spindle, stck_init_z, stck_final_z,
    #stck_chuk_st_z, stck_chuk_st_x,
    #stck_chuk_end_z, stck_chuk_end_x
    if toolchng <> two, ptoolend$
    toolend_flg = zero #Do not execute ptoolend again after xfer
    [
    !spaces$
    spaces$ = zero
    pbld, n$, "M00",e$
    if prv_spaces$ > 0, " ",e$
    "(Flip Stock)", e$
    spaces$ = prv_spaces$
    ]

    pstck_bar_fd$ #NCI code = 902 available variables:
    #stck_spindle, stck_op, stck_clear,
    #stck_grip, stck_init_z, stck_final_z,
    #stck_chuk_st_z, stck_chuk_st_x,
    #stck_chuk_end_z, stck_chuk_end_x,
    #stck_adv_fr, stck_appr_fr
    if stck_op$ <> 1, # if NOT using the 'Tool Stop option'
    [
    if toolchng <> two, ptoolend$
    toolend_flg = zero #Do not execute ptoolend again after xfer
    ]
    else,
    toolend_flg = one #DO execute ptoolend after xfer

    [
    !spaces$
    spaces$ = zero
    pbld, n$, "M00",e$
    if prv_spaces$ > 0, " ",e$
    if stck_op$ = 0, "(Push stock -",e$
    if stck_op$ = 1, "(Push stock with Use Tool Stop option -",e$
    if stck_op$ = 2, "(Pull stock -",e$
    if stck_spindle$ = 0, " from Left Spindle)", e$
    if stck_spindle$ = 1, " from Right Spindle)", e$
    spaces$ = prv_spaces$
    ]

    pchuck$ #NCI code = 903 available variables:
    #clmp_spindle, clmp_op, stck_chuk_st_z,
    #stck_chuk_st_x, stck_chuk_end_z, stck_chuk_end_x
    if clmp_op$ = two,
    [
    if toolchng <> two, ptoolend$
    toolend_flg = zero #Do not execute ptoolend again after xfer
    ]

    [
    !spaces$
    spaces$ = zero
    pbld, n$, "M00",e$
    if prv_spaces$ > 0, " ",e$
    if clmp_op$ = 0, "(Clamp -",e$
    if clmp_op$ = 1, "(Un-clamp -",e$
    if clmp_op$ = 2, "(Re-position -",e$
    if clmp_spindle$ = 0, " Left Spindle)", e$
    if clmp_spindle$ = 1, " Right Spindle)", e$
    spaces$ = prv_spaces$
    ]
    if clmp_op$ >= one, pchuck_unclamp
    if clmp_op$ = two, pbld, n$, *stck_chuk_end_z$, e$
    if clmp_op$ = zero | clmp_op$ = two, pchuck_clamp

    pchuck_clamp #user-defined postblock for chuck clamp
    if clmp_spindle$ = zero, "M10", e$
    if clmp_spindle$ = one, "M210", e$

    pchuck_unclamp #user-defined postblock for chuck unclamp
    if clmp_spindle$ = zero, "M11", e$
    if clmp_spindle$ = one, "M211", e$

    ptailstock$ #NCI code = 904 available variables:
    #tlstck_on, stck_init_z, stck_final_z
    if toolchng <> two, ptoolend$
    toolend_flg = zero #Do not execute ptoolend again after xfer
    [
    !spaces$
    spaces$ = zero
    pbld, n$, "M00",e$
    if prv_spaces$ > 0, " ",e$
    if tlstck_on$ = 0, pbld, "(Retract Tailstock)", e$
    if tlstck_on$ = 1, pbld, "(Engage Tailstock)", e$
    spaces$ = prv_spaces$
    ]

    psteadyrest$ #NCI code = 905 available variables:
    #stck_init_z, stck_final_z
    if toolchng <> two, ptoolend$
    toolend_flg = zero #Do not execute ptoolend again after xfer
    [
    !spaces$
    spaces$ = zero
    pbld, n$, "M00",e$
    if prv_spaces$ > 0, " ",e$
    "(Position Steadyrest)", e$
    spaces$ = prv_spaces$
    ]

    # --------------------------------------------------------------------------
    # Threading output
    # --------------------------------------------------------------------------
    pthread0$ #Pre-thread calculations
    # Calculate taper delta 'X' on Acceleration Clearance distance
    thdrdlt = (((thdx2$ - thdx3$) / (thdz1$ - thdz2$)) * thdzclr$)
    # Add to the original thread 'X' difference calculation
    thdrdlt = (thdrdlt + (thdx2$ - thdx3$)) * pl_ax_m0x
    thdang = rad2deg$ * thdangle$
    thd_dirx = (thdx2$ - thdx3$) * pl_ax_m0x
    thd_dirz = (thdz1$ - thdz2$) * pl_ax_m0z
    thd_vlen = thdlead$/ nstarts$
    thd_dirx = vsa (thd_vlen, thd_dirx)
    if fr_pos$, pthreadpull
    else, thdpull = zero

    pthreadpull #Pre-thread calculations
    if thdpulloff$/(fr_pos$*10) > 0.99,thdpull = 99
    else, thdpull = (thdpulloff$/(fr_pos$*10))*100

    pthdext$ #Calculation override for external thread
    #thddepth = thdlead * .61343 #Calc. thread depth
    #thdflat = thdlead * .1667 #Calc. thread flat

    pthdint$ #Calculation override for internal thread
    #thddepth = thdlead * .54127 #Calc. thread depth
    #thdflat = thdlead * .125 #Calc. thread flat

    pthdface$ #Calculation override for face thread
    #thddepth = thdlead * .61343 #Calc. thread depth
    #thdflat = thdlead * .1667 #Calc. thread flat

    pthrg32_1$ #G32 threading first
    comment$
    gcode$ = zero
    lrapid$

    pthrg32_2$ #G32 threading second
    gcode$ = zero
    lrapid$

    pthrg32_3$ #G32 threading third
    copy_x = vequ(x$)
    pcom_moveb
    #-------------------------------------------------------------------
    #andre la ligne qui suit output la ligne de code pour thread G33
    #-------------------------------------------------------------------



    pcan1, pbld, n$, sgfeed, *sthdgcode, pxout, pyout, pzout, pcout,pffr ,
    strcantext, e$
    pcom_movea
    prv_gcode$ = m_one

    pthrg32_4$ #G32 threading fourth
    gcode$ = zero
    lrapid$

    pthrg92_1$ #G92 threading
    if thdpass$ = one, pthrg92_11

    pthrg92_11 #G92 threading
    comment$
    gcode$ = zero
    lrapid$
    prv_feed = m_one
    prv_zabs = c9k
    prv_thdtype$ = m_one

    pthrg92_2$ #G92 threading

    pthrg92_3$ #G92 threading
    copy_x = vequ (x$)
    pcom_moveb
    pcan1, pbld, n$, sgfeed, sthdgcode, pfxout, pyout, pzout, pcout,
    [if thdrdlt & thdpass$ = one, *thdrdlt], pfr, strcantext, e$
    pcom_movea
    prv_gcode$ = m_one

    pthrg92_4$ #G92 threading

    pg32e$ #G32/G92 threading end
    gcode$ = zero
    lrapid$

    pthrg76_1$ #G76 threading start point
    gcode$ = zero
    lrapid$

    pg76$ #G76 threading
    comment$
    gcode$ = zero
    lrapid$
    sav_xa = vequ(copy_x)
    if thdface$ = zero, copy_x = thdx2$
    else, copy_z = thdx2$
    if thdface$ = zero, copy_z = thdz2$
    else, copy_x = thdz2$
    pcom_moveb
    nstart_cnt = zero
    while nstart_cnt < nstarts$, pg76nstart
    pcom_movea
    prv_gcode$ = -1
    copy_x = vequ(sav_xa)
    copy_x = copy_x + (thd_dirx * (nstarts$ - one))
    copy_z = copy_z + (thd_dirz * (nstarts$ - one))
    pcom_moveb
    pe_inc_calc
    !gcode$, !xabs, !yabs, !zabs, !xinc, !yinc, !zinc

    pg76nstart #G76 threading, for multiple starts
    if old_new_sw = zero, pg76old
    else, pg76new
    nstart_cnt = nstart_cnt + one
    if nstarts$ <> one & nstart_cnt <> nstarts$,
    pbld, n$, *sgcode, thd_dirx, thd_dirz, e$

    pg76old #G76 threading old style ce que turbocnc4 utilise

    #andre4 enleve ce qui est entre parentheses ( *thdrdlt) apres pfzout pour eliminer I0.

    pbld, n$, *sthdgcode, pfxout, pfzout, *thddepth$,
    *thdfirst$, *thdang, pffr, e$

    pg76new #G76 threading new style
    pbld, n$, *sthdgcode, *nspring$, *thdpull, *thdang, *thdlast$,
    *thdfinish$, e$
    pbld, n$, *sthdgcode, pfxout, pfzout, *thddepth$, *thdfirst$,
    *thdrdlt, pffr, e$

    Similar Threads:
    Andy


  2. #2
    Registered Mike Mattera's Avatar
    Join Date
    Mar 2006
    Location
    USA
    Posts
    1013
    Downloads
    0
    Uploads
    0

    Default

    Try changing strf to strk

    result = nwadrs(strf, feed)


    This is telling is what string to output for the feedrate
    strf string F
    strk string K

    Mike Mattera

    Tips For Manufacturing Training CD's, DVD's for Mastercam, SolidWorks, Inventor, G-Code Training & More
    http://www.tipsforcadcam.com


  3. #3
    Registered
    Join Date
    Nov 2003
    Location
    canada P.Q.
    Posts
    93
    Downloads
    0
    Uploads
    0

    Smile

    thanks for the help.it already had been tried..it would then screw up the feed
    letter of a linear move .would be K instead of F.

    I finally figured it out..I copied under an other name the section of code that
    G33 jumps to and i used strk in place of strf..now the change only affects
    the feed letter on a G33 ..Thanks to eveybody for the answers..

    Andy


Tags for this Thread

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •  


About CNCzone.com

    We are the largest and most active discussion forum for manufacturing industry. The site is 100% free to join and use, so join today!

Follow us on


Our Brands

post modification

post modification