Fastest way to program a face on a cnc lathe !!!---------2022 Tech from the 1990s

[lshingleton]

O4512(FACE-REMOVAL)
G203 (Machine G code for Safe start position )
G00G90G18G21G40G80G99
G50S1500
T0202M8
()
M34
G00X150.0Z50.0M3G96S250
()
#509=32.0(START-DIA)
#508=2.0(Z-START-POINT)
#507=-28.0(Z-FINISH-POINT)
#506=-2.0(END-DIA)
()
#505=[#508-#507](CAL)
G00X[#509]Z[#508]
()
WHILE[#505NE0]DO1
()
G01W-1.0F.25
G01X[#506]
W1.0
G00X[#509]
W-1.0
#505=[#505-1]
END1
()

G203
M5P11
M30

Similar Threads:

• News SAVE THE DATE - SolidCAM World 2022 Virtual Summit - May 11, 2022!
• News SAVE THE DATE - SolidCAM World 2022 Virtual Summit - May 11, 2022!
• 1980s-1990s Kearney & Trecker CNC Horizontal mill
• 1990s Emco Maier CNC Lathe Compact 6 5cCollet PCTurn120
• fastest way to face mill

[deadlykitten]

if i may, there is a faster method for simple operations, that works at least on okuma machines : it's speed comes from the fact that it no longer requires wcs and tool initialization, but you simply move the machine in manual wherever needed, then choose face ( or whatever operation ) : it will automatically identify it's curent position & tool, then start from it, doing whatvere is needed

thus is possible to skip initializations for start up positions

i call such methods as "hovering"

[lshingleton]

Cut me a face that need 10mm taken of and is 250mm dia with 50mm bore ---Dept of cut 1mm per time and in ten mins chaneg that to 100mm straight face of 500mm od to 250 !!!!!!----------------This works on all the with least amount of input -------------PS Okuma or Fanuc pre made programs never were as fast and clumberson to change

[deadlykitten]

Ishingleton, your program is the way to do it; thus the classical macro that saves the day long live #500 ...

by using custom applications, is possible to shorten the inputs even more

try this :
... replace T0202 in your program with a method that can detect the active turret post and auto-assign the offset, thus make it work whatever the turret position
... remove the need to initialize #509 and #508 inside program, but read curent tool position automatically and start from there, regardless of it's position
... remove the need to initialize #507 by looping the program automatiicaly, and setting zero each time when a loop is completed
... remove the need to declare program origin before pushing cycle start, thus make it work regardless of curent machine z0/wcs

now, try to change feed ( or whatever else ) without opening the program file, or without using the feed overide button, but from a custom guy, designed for less keystrokes

just to give you a taste imagine what can be done futher more / kindly

[lshingleton]

I try to make programs for Basic CNC people but heyParameter write to and from and change the langauge on the screen no issue even getting past the 00 alarms ---------------Done all the rest many many yrs ago but like most after you leave they get deleted as know one understand them

[deadlykitten]

that's the fact with most macro programs : they are personal, non-transmisible

if someone asks for help, most of the times is about a generic macro ( like tool change, bar feeder, etc ) or an idea, like how to helix or to count parts

they are a measure of how much someone mastered the g-code, but after that, don't get too attached to them; is easier to write your own macro, rather than understand what someone else did with his; but even if you can do what others did, it is good to check others work, in order to see how they implement it, maybe see a new aproach/syntax, etc

i started to move away from the macros a few years ago, going for applications, starting with vba and so on

just like you said, most stuff is from the 90s ... today a few cosmetizations can be made, but background work has not changed

what can be done with a macro is a limited thing, but over it you can put a custom gui, to help with initializations, etc / kindly

[lshingleton]

For sure -------I worked for a company with over 10,000 CNC and many controls and everyone there own versions of tool life and easy NC code and to be honest put them aside yrs ago and just use tranferable programs like this over and over again -------Takecare and have more of these for OD removal and BCP but thats another day ----Software programing of the 1980s and Qbasic still stands the test of time lol

[Superman]

Qbasic..... you're starting to show those grey hairs

Next, you are going to mention 5.1/4" floppies how to punch the paper tapes.
Damb, forgot where I put the walking stick...

[lshingleton]

Lol yep and they are only learning IF/For/When/While/Case and think its all new stuff lmao

[deadlykitten]

is easy to get into macros with a bit of programing background, but is harder the other way arround

in other words, the g-code is the simplest language there

if early macros where formula driven movement, today macros can be anything but simple, especially with the addition of global/local/system variables ( having acces to XZSTMG arguments, axis loads, origins, offsets, etc), file asignment functions, cnc parameters controled from g-code, prompts that behave diferently in respect to operator input, real time variables and counters with precision up to 1ms, etc

to create fast a complex macro for a specific machine, then debug tools are needed, unless you are 100% sure that it will work; otherwise, if you intent to build a simple macro, like a face, etc, that needs to be edited to suit each cnc brand, then is needed a different approach, to avoid having to manually edit the code for each machine / kindly

[g-codeguy]

Cut me a face that need 10mm taken of and is 250mm dia with 50mm bore ---Dept of cut 1mm per time and in ten mins chaneg that to 100mm straight face of 500mm od to 250 !!!!!!----------------This works on all the with least amount of input -------------PS Okuma or Fanuc pre made programs never were as fast and clumberson to change

First, let me say that I enjoy Macro (variable) programming. I use variables a lot. I'll write a Macro B subprogram whenever feasible. I'm not familiar with that many lathes, but looking at your code it appears that you are programming for a Doosan. Does it have a Fanuc control?

Second, I don't see why you think working with a canned facing cycle like G72 (Fanuc) is cumbersome to change. Why is it harder to change values in the canned cycle than to change values in variables? Surely the necessity of typing a couple 'X' and 'Z' characters can't be that hard or time consuming.

Third, I've never had a G72 cycle as long as your assignment/While statement.

Now if you do a lot of parts requiring rough facing and need to save on memory, then write a subprogram and pass the necessary information to it with a G65 Call. This would also allow you to change DOC at will.

[lshingleton]

Its a Doosan and what do you think the G72 is running behind in the backgound really is ?

G65 is a very danagerous as it changes meaning of address in the control and it gets confused
By the time you think about a Roughing cycle this is changed and running already and was used long ago when on 6m and O controls memory was crictial
Have a good one

[g-codeguy]

Its a Doosan and what do you think the G72 is running behind in the backgound really is ?

G65 is a very danagerous as it changes meaning of address in the control and it gets confused
By the time you think about a Roughing cycle this is changed and running already and was used long ago when on 6m and O controls memory was crictial
Have a good one

First let me say that I would never knock someone for trying something different or wanting to learn something new. I'm an old fart that still enjoys learning new tricks. Having said that.....

I've never seen what the internal program looks like for a G72. Have you? Obviously the control has to look at the numbers that were input, do some math, and start machining. Fanuc uses Macro B programming, so it isn't a stretch to think the G72 cycle uses a Macro B subroutine for machining (which may or may not include While, GOTO and/or other statements. No doubt Fanuc's subroutine is a more complicated version than the one you posted. Or does it use an entirely different type of programming? I don't know. BTW, I don't notice any lag whatsoever using a G72 cycle.

Guess we will have to agree to disagree on which method is easier. It doesn't take long to type in the G72 values and the part contour needed (2 blocks for a simple face). My depth of cuts vary all over the place as stated in my other post....a simple change in the G72. I'm not programming at the lathe. Well...sometimes a very simple and short program, but for the vast majority of the time at my desk.

Before I forget let's talk about lack of memory. The G72 is built in and

G0X32.Z2.G96S250M3
G72W1.R.5
G72P11Q12F.25
N11G1Z-28.
N12X-2.

takes up less space and I don't see how it could be any simpler than that. The more cuts it takes, the more time is saved because the G72 as I wrote it doesn't withdraw as far as your While statement. In actuality this time savings wouldn't amount to squat, but there would be a fraction of savings.

G65...where to start? The control doesn't think so it can't get confused. It can't change the meaning of an address unless the writer changes it within the subprogram, and why would a person do that? Dangerous? I suppose it could be if the person changing the input values doesn't understand what the subprogram is doing. BUT that is what checks are for.

As deadlykitten said, "they are personal". As the programmer and the writer of the subprogram it is your responsibility to make sure not only that the correct data is input by the G65, but that the subprogram does checks and will cause the control to alarm if wrong data is used. Or if needed data was omitted.

Among G65 calls on single spindle lathes I use G65 for barstop, cut-off, and deep drilling. Previously I had several programs for the same part because different size material got used. If we ran out of 1.25 inch material, finishing the job with 1.5 inch material required a separate program which naturally needed to be tested for possible errors. (Yup, I can make mistakes and typing errors. )

So I wrote a short, simple subprogram that G65 passes values to. One of those passed values is stock size. Now one program will run any size material. The operator simply changes the value assigned to stock size. No need to test the program as it has already been running.

I also use G65 for picking up and cutting off on lathes with subspindles. It's another memory saver. One block per program calling up a subprogram that would have to be a part of every program otherwise. Of course our lathes have a lot of memory these days. We still have an old one that has very little memory. I'm sure memory could be increased, but isn't worth it to the company.

I've got a few other G65 call subprograms. Can make life much easier once the subprogram has been proven.

[deadlykitten]

I don't see how it could be any simpler than that.

programing part : no longer look at the g-code, but at the process of creating it

for example, i guess is ok if new code is generated faster than editing a macro, even if the new code size is way greater than the macro program size, or you don't even have to look for the new g-code anymore

---

machine usage part : no longer look at the g-code, but at the process of using it

for example, i guess is ok if you no longer need to switch to automatic, program select, enter ... thus new version loads automatically ( post initializations are faster )

for example, i guess is ok if you no longer need to set the wcs and call the tool, declare offset, etc ( pre initializations are faster )

---

final purpose is on shop floor, on demand adaptation, as easy&fast as possible

if in the 90s the answer was macro, today there are also other tools, and greater complexity can be adrresed

such new tools are :
... on cnc macro creation/debug helpers:
...... live table variables ( global, local )
...... system variables ( so macros, besides being formula/math driven, now can handle non-cuting/passive operations )
...... file asginemtn functions
...... time counters; those at 0.001 can really tell where a macro is loosing time
... os, api, so is easier to build a custom app, or to shorten some cnc procedures, or to by pass the control panel
... conection ( last night at 10pm, from home, i did a quick check on a machine )

kindly

ps : to clear doubts, i will show someday how to okuma face cut for now, i work on other things

[lshingleton]

Fanuc controls were based on Qbasic with machine language with printer port outputs and as i said the G72 and suff are just background tasks and restrictive .
The First NC i was programming was in 1982 at 17 yrs old so see a few in my time especially as lead launch manager for a company with over 10000 CNC machine of many different controls
Do as you wish and dont take it from me but i have seen machines crashed using a G65 that can change letter desingated values to meaning different things and did not reset them in the control -------Fanuc controls all have lags and issues especially using IF or For and many other ones as if you dont split with brackets they can miss the jump -------Fanuc also has an issue on all canned cycles but especillay tapping as it will just sit there and many hrs later its still sitting there missing something for what ever reason ----------Four deep loops with subs will lock the control and so many other things -------------------I can use this program on many machines even seimins by changing the macros to R values of Global or local variables --------------Canned cycles are not used in many of the factorys i go into now as they are restrictive and the newer Easy NC type stuff so much time wasted -----------Have a good one and keep on machining

[deadlykitten]

if you look at it, g-code is there for decades allready

profesional machines :
... arround 2000, okuma switched to windows based install for it's cnc software, thus opening the gate for pc applications
... arround 2015, okuma released api for it's cnc, thus opening the gate for aplications linked to the cnc, like probing, etc
... other brands, still don't run on operating systems, but some started to have applications runing ( like small gadgets, or conversational robot programings, etc )

not profesional, but still capable : there are linux based machines, thus the operating system is there

perhaps many others interesting things are there, but less common at this moment

a programmer should try to connect the dots faster / kindly

---Fanuc controls all have lags and issues especially using IF or For and many other ones as if you dont split with brackets they can miss the jump -------Fanuc also has an issue on all

hy ishinlegton i have no much experience with fanuc, but i heard such things about it like you say; one instant, a fanuc programer, with a few fanuc machines, said that his machines are a bit different, and he has to adapt for each one he really liked it, like, you know, making him angry

but also, i got good tips from fanuc guys, that higlighed some okuma procedured that simply waste too much time ...

[lshingleton]

Oh they all have Challanges lol -------------That program i have so so i could take it through different machines and control and basically it worked over and over again while pulling out yet another book on yet another control on how to do a roughing cycle is tiring at best
Every control you work on is to look at faults and crashes with an open mind on how to make it a simple fix to stop it happening again and we do learn from that
Funny how the old Qbasic system is still relavant in 2022 to be honest and everything just a different version of the same idea
Take care and keep at it and always new challanges

[deadlykitten]

Oh they all have Challanges lol

from same reason, i preffer linear/simple code over cycles; it really allows full control, and there are less things to worry about

Funny how the old Qbasic system is still relavant in 2022

indeed, is simple; when i 1st started, i saw how simple the expresions where; i can not say that is limited, because, onestly, for g-code, you don't need more

if you dig the actual okuma, you can find simple code, like in the d300win, or excel probing macros

bunch of many simple codes / in the end, is how you use them

---

you know, when i decided to go away from macros ? with time, those codes got more and more complex, hard to follow even for me, and a few years ago i was writing a macro to mill a hexagon, and it was really moving the machine high, not only simple cutting, a lot of logic in it, could decide what strategy to take, could generate code, pretty optimized ... and then i realized that i spend to much time g-coding it, thus i could do it faster in something like qbasic, thus, you know, programing it

the basic problem with g-code, when you try to push things, is that is slow to debug, and it really forces your mind to think in a different manner : for example, the basic bricks for macro are GOTO and N0001 N0002 labels, that simply don't exist inside a programing language; is way easier to code something complex in a programing software, rather then g-code ...

for example, if you know that some conditions have to be verified, then stacking them all togheter in g-code will be a mess ( not impossible ), while programing them may be a simple line

i just got an idea : what about a reversal tool ? to take a computer program and put it all in g-code ... haha

[g-codeguy]

I thought I was an old fart at 74, but you guys obviously have me beat. But then I didn't get into machining until middle age in 1985. I know nothing about Qbasic. I only program lathes. Four subprograms deep says 'mill' to me as I've never seen the need for that many on a lathe. If a bracket is missing, our Fanuc controls will alarm out. If dwell codes don't match, the control alarms out. Etc.

I don't understand deadlykitten's comments "no longer look at the g-code, but at the process of using it". How does one program a part without first thinking about the processes needed to machine it? What code do you use to machine parts if it isn't G-code?

You guys obviously have newer and higher tech lathes than I am used to.

I only know g-code programming. (Macro B programming still uses G-codes.) All the lathes where I work were already very old when I started. Every lathe in the shop (about 10) were replaced within the first 5 years of working there. We still have a couple Hardinge lathes purchased new around 1988.

We had a Windows based lathe for a couple years. Like 2 years and purchased new. Don't recall the name. Magna? I didn't like it. Apparently the shop owner didn't either as we normally run our machines until they fall apart. Then they get repaired and we run them again.

We've had the same Okuma lathe with an Okuma control for around 20 years. I dislike it. Probably because I am so used to Fanuc controls. Maybe the newer Okuma controls are much better. What a pain ours is simply to rerun an operation. Why is it necessary to be in Single Block mode to control rapid moves with the feed override dial? Sucky lathe.

At one time we had 30 lathes and 2 programmers. The other programmer handled 8 (including the Okuma) and I took care of the other 22. Have been the only lathe programmer since 2015 and we are down to 27 lathes...mostly barfeeds with subspindles. I use many of the G65 programs on all the Fanuc control lathes with no problem. Other than having to change IF statements to GOTO for 3 of the 34 (or so) year old lathes.

You guys are obviously higher on the pecking scale than I am. My job is to program parts in the most efficient way possible at the lowest cycle times possible. If the tang on a live tool breaks off because of how hard I am pushing the tool and the broken piece has to be removed from inside the turret, so be it. Owner doesn't care about anything but cycle time. He doesn't mind the machine being down or the cost of repairing it. If I program based on keeping the live tool in one piece, I get tasked about how long it takes to machine the part. Never mind that my milling operations done on a lathe are often faster than when done on a mill. Our mills aren't subjected to the same cycle time constraints. Rant over.

I've been using G65 for a good many years, and have never seen the situation Ishingleton describes. I'd like to see the subprogram that makes those kinds of changes. I still think it is programmer error, not machine error. I've never seen a lathe do something it wasn't instructed to do. Possibly my experience is too limited. I've only programmed, setup and ran Hardinge CHNCs and Conquests, Hitachi-Seiki, Mori Seiki, Nakamura, Daewoo/Doosan, Okuma, CMS, Takisawa, Star Swiss, old manual Harding lathes set up for CNC with Fagor controls, EMAGs, Eurotech and the previously mentioned unremembered Windows lathe. Possibly a couple other brands when I worked part-time at other shops.

You might think otherwise, but I have enjoyed reading your comments even if I didn't always understand what knowledge you were trying to impart.

[deadlykitten]

Four subprograms deep says 'mill' to me

hy g-codeguy i reached 7 nesting level, or deep, how you wanna call it; it was not allowed by the controller to go any futher

linear, simple code, is level 0, no nesting

a level 1 is when each operation is called from the main code

you may go deeper when there are variants for each operation, like, for example, operation 2 has 3 variants, so this will automatically add another level

more levels appear with complex codes :
... machining : there may be a lot of math, shared by different operations, like those that involve interpolated motion from linear & rotary axis
... non machining :
...... simple initializations : counters, checkings, data logs
...... machine miscelanous : like turret index, barfeed, atc, probing/skip
... mixed up, like both machining and miscelanous : for example, only last part, right before barfeeder loads a new bar, to be machined only partially ( thus the main program wil have to skip some operations, so there is a group that is always called, and another groups that is conditionally called in respect to barfeeder signal )

We've had the same Okuma lathe with an Okuma control for around 20 years. I dislike it. Probably because I am so used to Fanuc controls.

truth is that you may love the 1st cnc more than anything else for me, it happened to be okuma

i don't know how where the lathes back than, but i can say this :
... actual okuma lathes can run fanuc codes, thus they can change to fanuc language by parameter setting; doing so, they won't perform at best, because fanuc functions don't cover all okuma functions ( unoficial story is that fanuc is a child of okuma )
... okuma is close to benchmark, while fanuc is for mass release
... if you move from okuma to something else, more likely you will feel handcuffed, and partially paralized seems to be a joke, but it isn't
... just touch the keyboard of the okuma osp300 : it is built for a normal human, while fanucs keyboards are 1/2 ( cost reduction ) and omg

If the tang on a live tool breaks off because of how hard I am pushing the tool and the broken piece has to be removed from inside the turret

for example, such things can be avoided on okuma machine, because of it's load meters; such an option is default, while fanuc released it years later, less developed, and clients will have to pay for it

and, seems that few realize what this function does, simply because they don't see it in action and/or don't have the experience to buy it, and also, when they realize what benefit it may deliver, then it may be too late, generally after a severe crash isn't it ? or maybe, not even then

to give you an example, now there is a mass production setup, on an okuma and on some fanucs : drilling on fanuc allreay broked drills at 2000rpm, and okuma runs safe at 5000; same feed, in case it matters

main difference, is like being always atention and stresed near the machine, versus being relaxed far from it

Never mind that my milling operations done on a lathe are often faster than when done on a mill

yes, that's true for small parts, common tools, let's say up to 20mm, a lathe will beat a mill even on same cutting specs, simply because it accelerates faster and can index the tools faster

I've never seen a lathe do something it wasn't instructed to do.

i witness a mill hitting into part just because ?! after a power cycle, it went back to normal ....

Possibly my experience is too limited. I've only programmed, setup and ran Hardinge CHNCs and Conquests, Hitachi-Seiki, Mori Seiki, Nakamura, Daewoo/Doosan, Okuma, CMS, Takisawa, Star Swiss, old manual Harding lathes set up for CNC with Fagor controls, EMAGs, Eurotech and the previously mentioned unremembered Windows lathe.

so far, i avoided other brands, and only sticked to okuma, because i wished to know more about it, instead of doing the same thing in different manners; this is what i don't like about different brand lathes, they all do the same things, they are ISO g-code, but in the end, process implementation & panel operation is a bit diferent

i prefer okuma as it's complexity covers most other brands capabilites, while actually learning different brands, i think it maps your head in a strange way : it may seem to add experience, but in reality it consumes you; i don't wanna ofend anyone, maybe some just don't have a choice lucky me, i could choose ...

I thought I was an old fart at 7

I only know g-code programming. (Macro B programming still uses G-codes.)

Have been the only lathe programmer since 2015 and we are down to 27 lathes...mostly barfeeds with subspindles.

somewhre along the way, i decide to create a 2d programing software

if you wish, i will anounce you / kindly