Siemens 840D CNC Training

Siemens CNC Training from Bleier CNC Training

2012-01-09T20:30:00.000-08:00

Email me BleierCNCTraining@gmail.com or call me (847) 917-8145 if I can be of service to you

I offer to combine seminars with machine side training with your programmer and operator to put the machine through its paces. Ideally we will do a commercial part.

The following are some of my recent events:

1. Assisted a small shop to get acquainted with the Siemens 810D on a a recent purchase of a used Hardinge 3-axis VMC. The user, who was familiar with Fanuc and Fadal, needed a few tips to get started with Siemens. Helped another user of a previously owned Fadal VMC wrangle its 840D with 802 front end to success.

2. Performed the NAS acceptance testing (cone frustum, circle/diamond/square, hole operations and power test) on an 840D retrofit of a G&L horizontal boring machine. Configured the machine to conform to the shop’s process. Trained the operators. As the first person to put the machine through its paces I discovered and worked with the retrofitter to fix incorrect direction of rotation of orientation axes, problems with block search, faulty tool pocket positions of the box-type magazine and the need to fine tweak the vector settings for the 5-axis transformation.

3. Trained the smart operator (programmer-operator) of a large, second hand 840C (note “C”) mill-turn machine. Worked through dozens of problems to discover how to use the machine to machine a highly contoured drive shaft with a bolt pattern on one end and a spline on the other.

4. Trained the programmer and operator of a large 5-axis router. Loaded standard cycles and measuring cycles and wrote measuring routines. Went through the process from start to finish by actually machining a typical job. Simultaneously the programmer modified his post to accommodate our discoveries. Our goal was to turn operations over to general purpose factory workers whose modest need for training could be accomplished by the operator I trained.

5. The user purchased an R&D laser machine in Europe for a highly discounted price and brought the machine to the U.S. The builder’s U.S. affiliate was not able to provide training on this one-off, odd ball machine.

6. The user’s 5-axis in-house retrofit was doing a contour in herky-jerky motion. Worked with the programmer to experiment with different ways to post the program. Discovered if we used the old ways of 5D/G93 we got much improved performance.

7. The machine tool builder’s installation personnel did wham-bam thank-you-ma’am training on a complicated 5-sided machine with a nutating head and left for the airport to return to the old country. I showed the user how to set work zero and use Cycle800 to machine on a swivel plane in the process of doing an actual part that we could send out for inspection.

8. Worked with the programmer to configure his post to output code that we determined worked well on the machine. The key was spending time at the machine doing a typical commercial job to understand the best way to use the machine. Should we use CompCad? If so, what compressor tolerance to optimize cycle time and surface finish while achieving dimensional tolerance?

9. The user of a multi-spindle machine wanted an analysis of the master program that orchestrated the machine as a whole in order to determine if the machine could be programmed for shorter cycle time. While there, did seminar for the operators and programmers of user’s other 840D machines.

Email me BleierCNCTraining@gmail.com or call me (847) 917-8145 if I can be of service to you

Turn Mill with 840D / Multi-Spindle Turning with 840D

2010-09-01T18:01:00.000-07:00

The machine below was a joy. It has live spindles (any station on the turret), attachments heads and a Y-axis for true 3-axis milling on the OD. The turret can be removed and replaced with a big boring bar to do operations deep into the ID of the work.

A right angle attachment fits into a turret pocket just like any tool and redirects the tool axis parallel with the turning centerline. The geometry of the attachment is set in the base registers of the D-code so that the preset lengths of the tools are still valid. The TRANSMIT function (Transformation Milling into Turning) of the 840D makes milling on the face of the workpiece programmable in an XY plane. In this case the Y-axis is a virtual axis that does not map to the Y-servo axis. The Y-servo axis has to be kept in its neutral position for TRANSMIT machining.

From time to time I get my hands on a multi-spindle turning machine (photo below).

Multi-Spindle CNC machines are made easy by Channel CNC. Channel CNC is a concept that Siemens pioneered in the mid-1980’s. A Channel CNC is many independent CNCs in a common hardware/software configuration and serviced by a common operator interface and PLC, the latter for machine control generally. Each channel has its own spindle and axes and its own part program. Each channel does its own independent path interpolation. The machine of the photo has 10 channels. Channel 1 is the master channel that orchestrates the selection of programs in the other channels, when they start, when they wait, when they resume and the like. This is called "program coordination" and the program coordination commands are part of the G-code language (described in the so-called Job Planning manual).

Cycle800, Nutating Heads & Swivel Plane Machining

2010-06-21T15:59:00.000-07:00

We can put the G17 XYZ system on the inclined plane of the figure above, orient the G17 system so that its Z-axis is normal to the plane and translate again to put the G17 XYZ origin at the point where the centerline of the pocket intersects the plane. If we have a nutating head (or a forked head or any number of orientation schemes for that matter) we can normalize the tool axis to the plane (put them at right angles)and program the face and pocket as if they are in the XY plane of a simple vertical mill.

Knowing the orientation angles to normalize the tool axis can be a challenge with some orientation schemes such as the nutating head. For example, the rotary positions of a 22 ½ degree nutating head are C71.468 A39.886 to normalize to the 15 degree plane of the figure.

Cycle800 does the transformation that calculates the orientation angles and actually commands the orientation axes to these angular positions. It also translates, rotates and translates again (if required) the G17 system so that when it is done the machine and control are ready to read-in and process G-code blocks that are identical to blocks for simple vertical bed mills.

Another way to imagine swivel plane machining is to imagine that the workpiece is frozen in space and you have miraculous strength. With two hands you grasp the machine, carry it to the workpiece and orient the machine so that a drill in the spindle points normal to any plane. In other words, you use your physical power to swivel the machine around the workpiece. You call out to the programmer, "Now you can program drilling operations in the plane normal to the tool axis like any ordinary 2 1/2 axis operation." The realistic equivalent of this fantasy is done by designing into the machine the means to orient just the tool (or work or some combination of work and tool), translating and orienting the G17 XYZ system and provisioning the CNC with transformation functions. This having been done, Cycle800 is the means to turn over to the user the use of this capability
To be clear, the capability is the ability to do 2 1/2 axis machining on a swivel plane in a way that allows the operator to make changes (say to Cycle81) the same way he would do changes when the plane is not a swivel plane. (All standard cycles and measuring cycles are in the G17 XYZ system or the G18 ZXY system or the G19 YZX system).

Definition of Swivel Plane:

Drilling into an inclined (same as compound plane) is ultimately a vectored move of the XYZ machine [servo] axes. It can be programmed as a 2 ½ axis machining operation when the G17 XYZ system is translated and rotated so its XY plane is in the drilling plane. The drilling plane is what this article calls a swivel plane because rotary axes are required to normalize the tool axis to the G17 XY plane.

Not all rotary axes are machine [servo] axes and when the operator loosens bolts and nudges the head that carries the quill to a desired angle, the rotary axis he positions is called a manual axis. Cycle800 knows to prompt the operator for a manual axis. However, we will assume our machine has servo rotary axes.

The transformation for static orientation is called Tcarr (Tool Carrier [transformation]). Tcarr is the poor man's Traori (Transformation [for] Orientation) for aerospace 5-axis contouring where the tool orientation changes along the path. Tcarr is a standard option. It is there, in the 840D when it leaves the Siemens factory and it was put there without the machine tool builder paying extra for it. However, it is not strictly free to the end user since the machine tool builder has to invest engineering time to configure it to his machine's orientation scheme.

The machine tool builder (MTB) can use Cycle800 to do the configuration, but this is not the subject of this posting. Rather, this posting seeks to explain the parameters of Cycle800 for the user of the machine to do swivel plane machining.

The Cycle800 Parameters:

_FR “1” is retract on Z to a clearance position. “2” is retract on Z first and then X & Y. “4” is retract on the tool axis to the software limit. “5” is retract an incremental displacement on the tool axis. “0” is do not retract.

The machine tool builder (MTB) sets retraction positions in the tcarr data block in variables 38, 39 and 40 discussed in the section “The Swivel Head Data Block”.
Cycle800 calls up a subroutine named ToolCarr where the retraction code exists.

_TC The given name of the tcarr data block. Also called the swivel plane data block. These data blocks are numbered 1, 2, 3, etc., but they also have a name given to them by the machine tool builder. He could name them for the Presidents of the United States if he wishes but typically he will name them Head_1, Head_2, etc.

The Machining Cycles manual says the names are limited to 20 characters but the PROC line in Cycle800 defines _TC as a 32 character string variable.

Only one data block is needed if your machine has permanently attached rotary axes for swivel plane machining. Programming blank quotes for _TC or programming “0” with the quotes is sufficient for Cycle800 to pick this data block although if the data block has a name, the name can be used.

_ST “0”/new and “1”/additive are whether the coordinate system translations and rotations specified in the Cycle800 call block begin at the origin of the G54 system (or the one your use) or whether they start at the origin of a coordinate system that has already been translated and rotated from the G54 system.

A “new” Cycle800 call does the equivalent of Trans+aRot+aTrans in this order written to a system frame created by Siemens to support swivel plane machining. This system frame is distinct from the Programmable frame.
An “additive” call does the equivalent of aTrans+aRot+aTrans, also not stored in the Programmable frame variable.
The Programmable frame is not unaffected by a Cycle800 call. The Programmable frame is zeroed by a “new” call. It is not zeroed by an “additive” call.

_MODE There are many schemes to specify the coordinate rotations to place the XYZ geometry system in the swivel plane. Most commonly, axis by axis rotation is the scheme. The first rotation is around any one of X, Y or Z. The second rotation is around one of the other two axes in the new system created by the first rotation. Two rotations are sufficient to fully define a swivel plane

As an example: The first rotation could be around the X axis of the G54 system. The second rotation could be around the Y-axis of the system created by the first rotation around X. The

_MODE code for this is the decimal number 57 (for the machine of this explanation)
If you are parameterizing the Cycle with cycle support screens, cycle support determines the decimal code from the information you entered in the screen. If you want to understand more about the decimal code, read on.

In the XYZ system there are 6 permutations of X, Y and Z. A decimal number is used to encode a binary number code that specifies the order of axes.
“00” is the code for axis by axis. “01” is the code for X. “10” is the code for Y and “11” is the code for Z. “27” is “00 01 10 00” in decimal.

XYZ 00 01 10 11 B = 27 D. 1st around Z, 2nd around the new Y.
XZY 00 01 11 10 B = 30 D. 1st around Y, 2nd around the new Z.
YXZ 00 10 01 11 B = 39 D. 1st around Z, 2nd around the new X.
YZX 00 10 11 01 B = 45 D. 1st around X, 2nd around the new Z.
ZXY 00 11 01 11 B = 54 D. 1st around Y, 2nd around the new X
ZYX. 00 11 10 11 B = 57 D. 1st around X, 2nd around the new Y

When _MODE is 39, this means that the G54 system is rotated around Z first, and if a second rotation is required, this rotation is around X of the system created by the first rotation.
In the Cycle800 support screen, you are asked to specify the 1st and 2nd axes and the rotation in degrees. The support screen converts your input into the appropriate decimal number.

_X0, _Y0, _Z0 Since a “new” Cycle800 call cancels the Programmable frame, _X0, _Y0 and _Z0 are a translation from the active member of the G54 group.

If the call is additive, these parameters would most often be set to zero (because why would you not have folded them into the previous “new” call?).

A “new” Cycle800 call with non-zero values assigned to some or all of _X0, _Y0 and _Z0 is called the first translation.

_A, _B, _C These parameters are for an additive coordinate system rotation. _A around the X-axis, _B around the Y-axis and _C around the Z-axis.

Here is a pop test: Why would you not always include a rotation in a “new” Cycle800 call? After all, it takes a rotation to define a swivel plane.
Here is the answer: Cycle800 activates the compensation functions to account for the geometry of the attachment head and this compensation is required even when the swivel axes are in their neutral positions.

_X1, _Y1, _Z1 An additive translation after the rotation.

_DIR You parameterize Cycle800 to translate and rotate the coordinate system. The Cycle has to figure out the swivel position to normalize the tool and surface. There are usually two solutions. You tell the cycle what solution to use by setting a 1 or -1 to _Dir.
It is not likely that you will know ahead of time the _Dir = 1 solution. Still, program a “1” and if this doesn’t seem right in actual practice, change it to a -1.

_FR_I In the early software editions of Cycle800 Siemens did not provide a means to specify an incremental retraction on the tool axis to a safe place to command a new orientation. This was added to Cycle800 from SW 6.5 on up. (At the time of this writing, SW 7.x is the latest.) So, if the MTB commissions Cycle800 to retract along the tool axis, the user can specify with _FR_I the incremental retraction distance.

_LOG_ON Lets not worry about this parameter. It is not even mentioned in the Cycles manual.

Example:

The example faces the top of the rectangular block of the figure. It then faces the swivel plane and finally, it does the circular pocket.

In the example, Head_Call() is a head change macro subroutine. Tool_Call() is the tool change macro subroutine. These macros are written by the machine tool builder and taught to his end user. Lets assume that Tool_Call retracts the head to a safe position, swivels the rotary axes to the tool change orientation and commands the tool change.

%_N_CYCLE800_EXAMPLE_MPF
;$PATH=/_N_WKS_DIR/_N_TEST_PROGRAMS_WPD
N05 Cycle800( ) ;to start with a clean slate
N10 Head_Call(3) ;command head change to head 3
N15 Tool_Call(1492) ;T1492 is the face mill
N20 G94 G54 G90 G70 G64 S1500 M3 M8
N25 Cycle800(1, “Head_3”, 0, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1)
N30 Cycle71()
N35 M5 M9
N40 Cycle800(1, “Head_3”, 0, 57, 25, 0, 0, -15, 0, 0, 0, 0, 0, 1) ; new translation followed by rotation
N45 S1500 M3 M8
N50 Cycle71()
N55 Tool_Call(1156) ;T1156 is end mill
N60 Cycle800(1, “Head_3”, 1, 57, 0, 0, 0, 0, 0, 0, 40, 30, 0, 1) ;additive translation in the plane
N65 S5000 M3 M8
N70 Pocket4()
N80 Cycle800( )
N85 M5 M9 M30

In the real world the top surface might be faced with the vertical head. While the vertical head is the standard against which the other heads are compared, some machine tool builders assign a tcarr data block to it to account for its own imperfections as a standard. The equivalent in tool setting would be, suppose there is a constant discrepancy between set tools and their actual cutting length.

Explanation of Individual Blocks:

N05 A safety block to make sure the Cycle800 frame variables are nulled.

N10 Only your MTB can tell you how to program a head change. However, a macro subroutine is typical of 5-sided machines. In the old days before the 840D, Siemens CNC used “L” for subroutines. If your machine uses L for macro subroutines, now you know that these subroutine names have a history.

N15 Tool changes are machine specific. Only your MTB can tell you how to program a tool change.

N20 Most of these G-codes are default except G54. G500 is probably the default for the G54 group.

N25 This Cycle800 call will position the swivel axes to their neutral position and activate head compensation. This block may not be necessary since very likely compensation was activated in the head change macro subroutine. The “27” means the order of rotation is first around Z and second around Y. However, since all the rotational angles are zero, no coordinate system rotation happens. Also, work zero stays at G54 since the first translation and second translation parameters are zero.

N30 Calls the facing cycle to face the top surface of the block.

N35 Turns off spindle and coolant

N40 A new Cycle800 call to translate and rotate the coordinate system and swivel the rotary axes.

N45 Turns on spindle and coolant

N50 Face down to the swivel plane.

N55 Tool_Call for an end mill. We assume that Tool_Call turns off the spindle and coolant, retracts the head to the tool change position and swivels to position the spindle for the tool change.

N60 This is a not-new Cycle800 call. This means the 40 and 30 are additive translations in the swivel plane to the center of the pocket.

N65 Spindle speed, etc., for pocketing

N70 Calls the pocketing cycle for roughing out the pocket

N75 Finishes the pocket

N80 Cycle800( ) is the D0 for head compensation. It may not be wise to cancel compensation at this time.

N85 Spindle off. Coolant off

N90 End of Program and Reset of program execution

The not-so-good graphic above shows a shows a translation (top left) followed by a rotation (middle right) followed by an additive translation (bottom left). If we were to program this directly the blocks would be as follows:

N1776 Trans Y-19.2929 ;(20 - 1*cos(45))
N1778 aRot X45
N1780 aTrans Z-0.5

Following this we would have to program an orientation of the tool axis and activate a transformation (Tcarr or Traori). This is all done by Cycle800.

The not-so-good photo above shows me and my coolant brothers making chips on a HBM with a nutating head. If it weren't for Cycle800 we would not be happy campers.

If you are a machine tool builder you know that there is so much more to Cycle800 than its user dimension. Contact me if you want my notes on it all. In the meantime, I will show you the vector diagram of the geometric description of a particular nutating head required for the Tcarr data structure $TC_CARRn[1] to $TC_CARRn[65]. The diagram is for a horizontal boring machine and the orientation shown is the neutral position.

V1 and V2 are the directions of the 1st and 2nd orientation axes. S is the direction of the spindle.

I3 is on the line of the spindle axis to the point where the direction line of the 2nd rotary axis intersects it.

I2 is the vector from the tip of I3 to the point where the directions of V1 and V2 intersect.

I1 closes the vector diagram because in the exampe of the diagram, the tool reference point and the head reference point coincide have been picked to coincide. If you had a second or more attachment heads, it is not likely that you would be able to pick this was and the vector diagram becomes more involved.

Continuous Path Modes G64 and G642

2009-08-26T05:00:00.000-07:00

The photo is a shadow graph of two parts side by side. The corner on the right was cut with G64. The one on the left with G642.

This comparison was made after one of Siemens experienced specialists in servo optimization had done his best to get rid of the instability in the servos (they were hydraulic servos). We increased the overload factor from 1.20 to 1.80 (to give the CNC 80% of the linear acceleration to use for lateral acceleration) and this made a difference (photo not shown). However, the dramatic difference was when we asked the CNC to insert a b-spline at the corner. This is what G642 does. It inserts a b-spline block at the corner and the CNC interpolates the spline path. We tightened up the tolerance that the spline can depart from the corner (photo not shown) and we got a very tight, smooth corner.

G64 slows down the axes as they enter a corner so that it can be taken at the prescribed lateral acceleration set as a percentage of the linear acceleration of the axes. Strangely, increasing this to 80% made improvements which is counter-intuitive, but still, the instability of the axes dominated the corner transition. The instability was still there with G642 but it was not provoked into acting up when the CNC had a nice, smooth curve to interpolate at the corner.

G64/G642 can be compared to a car's changing direction by 90 degrees at the corner of an intersection versus driving a banked 90 degree curve. Clearly, the banked curve does not challenge the suspension system as agressively as the sharp turn and thus, any tendency to instability is reduced.

Exact Stop Mode G60 / Exact Stop Check G601 & G602

2009-08-26T04:44:00.000-07:00

G60 G601 is exact stop with fine in-position check
G60 G602 is exact stop with coarse in-position check
G60 G603 is exact stop without in-position check

G60 tells the CNC to decelerate the axes to a stop at block boundaries. G601, G602 and G603 define conditions that must be met before the CNC moves on and begins to execute the next motion block.

You would program G60 when you want sharp corners. You would program G60 (or G09) in drilling because you want the tool to get to final depth before the drill pulls out.

Following error - the difference between the actual position of the axes and the commanded position - is a property of CNC's proportional position control. When the CNC gets to the block end point in its processing of the geometric data, the axes are shy of this position by following error.

-------------------------------------------------------------

G60 is the modal exact stop mode and G09 is the non-modal exact stop mode.

G60 is the default member of group 10 that includes G60, G64 and G642 to G644.

G09 is in group 11.

You can change the G60 default to G64 by putting a "2" in MD 20150 $MC_Gcode_Reset_Value[9]. (The index is one less than the group number.) Put in a "3" and you have changed the default to G642.

It is important to know that exact stop is one thing and exact stop check is another, subordinate thing. We will see that not all exact stops require an exact stop check.

G60 is like driving a car and having to stop at ever intersection and at every point where the road blends from a straight away into a curve and vice versa.

In the exact stop mode the axes are decelerated by the CNC as they approach the block end point so at least in the mind of the CNC they are stopped (at stand still) when they get to this point. If asked, the numerical control does an in-position check and if the axes are within a prescribed tolerance of the end point the CNC moves on and begins execution of the next block.

Following error is the primary reason the axes could be out of the in-position tolerance when the CNC has consumed the interpolation function of the current block. However, before discussing following error, lets clarify how we ask the CNC to do an in-position check and the in-position tolerance.

There are two in-position tolerances called coarse and fine. These tolerances are set in the following machine data:

MD36000 $MA_Stop_Limit_Coarse
MD36010 $MA_Stop_Limit_Fine

The coarse default is 0.0016" (0.04 mm).
The fine default is 0.0004"

There is also MD36012 $MA_Stop_Limit_Factor (default is "1") that one expects is a scale factor on the coarse and fine in-position tolerances although the Siemens manual does not say this explicitly.

(The problem with the manuals not saying what they mean explicity in the technical language of science and technology - mathematics - is that the same text explanation could apply to any number of situations when words are not chosen carefully and when the writer does not know the cultural and technical sensibilities of his readers.)

If in fact, Stop_Limit_Factor is a scale, if this MD is set to "2", the in-position tolerances is double. This could be useful when machining workpieces that are at the upper end in mass for the specifications of the machine provided inspection can accept the consequences of a larger in-position tolerance.

G60 G601 commands the CNC to do an exact stop fine in-position check.

G60 G602 commands the CNC to do an exact stop coarse in-position check.

There is also G60 G603. G603 is a cancelation of exact stop check. G603 does not do an in-position check following deceleration of the axes to commanded stand still. Rather, after the CNC has consumed the interpolation function of the current block, it begins consuming the interpolation function of the next block.

G603 could result in a rolling stop which would be similar to G602 with very large in-position tolerances because residual following error keeps the axes moving.

Following error is a servo concept. The CNC samples the interpolation function on a time grid to issue incremental setpoints to the position servos. The servo algorithm used by CNC is proportional position control.

If you read a massively heavy volume on control theory you will find near-nothing on proportional control because is it so basic that authors feel it is spontaneously understood. With proportional control, in order to get go, there must be a difference between where the controller has commanded the position servo to be and where the position servo actually is at. This difference is called following error. Internally, within the position control loop, the velocity command to the servo drives is . . .

velocity_command = position_control_gain * following_error

(Clearly the position control gain has to have dimensions of per time since velocity is length over time. Per time is called inverse time and it is usually inverse seconds. A gain of "1" is 16.67 inverse seconds. A gain of "1" produces 0.0010 inch of following error at 1 inch/minute feedrate. There is 0.100" following error at 100 in/min. High gains result in less following error but high gains require more rigid axes which is one reason high speed machines are more expensive.)

When the rate at which the position control loop receives position feedback is equal to the rate at which the CNC issues new position commands, the following error remains constant. Once the CNC has consumed the interpolation function of the current block it no longer issues incremental position setpoints, not until it can move on and begine to consume the interpolation function of the next block. However, there is still following error in the system and this following error results in a velocity command. It is like pulling a wagon with a bunji cord. The stretch in the cord is the following error of this system. When you stop walking, there is still stretch. However, wait a bit, and the stretch will cause the wagon to come along until there is no stretch (maybe a little because of friction but lets assume there is none).

When the position control gain is low and the feedrate is high the following error is considerable. This is why, if you cannot tolerate large corner contours due to following error, first you want the CNC to command the axes to a stop at the block end point and even then, you want to make sure that the residual following error has been worked out so that it is not just in the mind of the CNC that the axes are at their end point but they actually are at their end point. The latter is what the end position check is all about.

Some CNC workers have problems with an exact stop check that is not exactly exact. Get over it. We do not machine to exactness. We machine to tolerance.

Continuous Path Control & Look Ahead

2009-08-25T06:05:00.000-07:00

G64 turns on Look Ahead and so does any one of G641 to G645. These preparatory functions are called continuous path control.

Continuous path control is a broadly defined concept that includes Look Ahead and a number of functions that are subordinate to it. However, Continuous Path Control and Look Ahead are the same thing from the point of view of the programmer and operator.

Look Ahead seeks to achieve a smooth, continuous velocity along the interpolated path, trying as much as possible to hold the velocity constant at the programmed feedrate without exceeding the dynamic limits of the axes. When the dynamic limits would exceed the programmed feedrate the axes have to slow down much like a car slows down to take a turn at an unprotected intersection.

To continue with the car analogy, Look Ahead can be compared to driving a winding road in hill country with radar vision. Since you can see ahead you do not have to stop to see if the road is washed out over the next hill.

Look Ahead is turned off with G60. G60 is called the exact stop mode. It is like stopping for stop signs at every intersection.

Continuous path control needs Look Ahead to do its thing. Its thing is to smooth corners while keeping the path velocity as close to the programmed feedrate as possible. In the main, it accomplishes this by inserting rounding blocks at corners and by limiting velocity and acceleration so the axes do not flutter at block transitions.

The rounding blocks that span the corner to "connect" two contour elements smoothly are akin to the wedges used by picture framers to hold the corners together. These wedges are called splines. Thus, spline is my prefered term for the inserted rounding block that connects two contour elements. Coincidently, the contour of the rounding block is a polynomial produced by the 840D's b-spline algorithm. Thus it is more correct to talk about inserting a spline block at corners as opposed to a rounding block since the inserted path is not the arc of a circle. However, Siemens documentaion calls them rounding blocks and so will I.

Back to G64 & G641 - G645 and Overload Factor versus Compressor Tolerance . . .

The Overload Factor is a machine data setting. It is used by the 840D to limit the step change in velocity at a corner. I will discuss the vector diagram later that illustrated how there can be a step change in velocity at a point while the velocity remains constant. For the time being . . .

If the step change at the programmed feedrate exceeds the maximum allowable step change of the Overload Factor equation (discussed later), the 840D decelerates into the corner so that when the tool enters the corner the servos can accomplish the step change and thus, the change in direction, in one period of the interpolation cycle.

The formal Siemens documentation does not say that the corner is actually commanded to be taken in one cycle. To compound the matter, the one cycle change in direction cannot be conclusively inferred from the definition of the Overload Factor because at other places in the documentation Siemens implies that a rounding block is inserted in the corner. My attempts to get clarification on this have not addressed the contradictory nature of the documentation. Thus, when I write that with G64, corner smoothing is a consequence of residual following error I am not 100% confident that this tells the whole story.

Uncertainty with regards to G64's precise behavior is not a burning issue for most programmers. However, for people who seek to be problem solvers, an in-depth understanding of any detail of CNC is often a lever to understand other details that don't have a legacy of practice to give us confidence that it works even if we do not fully understand why.

There is no uncertainty in the documentation with regards to the 3-digit G64x and especially G642, the one must used. Corner smoothing is achieved by inserting a rounding block between two blocks whose intersection is a corner. The block must pass within the Compressor Tolerance of the corner point. Like the Overload Factor, the Compressor Tolerance is a machine data setting that I discuss in my post on Cycle832. I also discuss the Compressor Tolerance in my Directory of Terms. If you have the wherewithal to read my posts you should definitely email me BleierCNCTrainin@gmail.com for an e-copy.

You would typically use G64 for 2 ½ machining and G642 for high speed kellering and 5-axis aerospace contouring. Your machine tool builder may advise you differently since there are slight differences between individuals of the 3-digit group.

Siemens recommends you use G642 with CompCurv and CompCad. This recommendation needs elaboration since CompCurv/CompCad are themselves smoothing functions. So, here we go . . .

CompCurv/CompCad are b-spline algorithms that act on short G01 blocks to produce one polynomial block out of a sequence of G01 blocks (typically 5 to 10 G01 blocks in the sequence). This one block blends tangentially with the the polynomial block produces by the next sequence of G01 blocks and on and on. As a consequence of this tangential blending there are no corners. However, there can be corners when the algorithm temporarily suspends doing its thing at an intersection point where the next block is very long or the next block is not a G01 block. In this case the intersection between the most recently produced polynomial block and the the next block could be a corner and G64/G642 (whichever you use) would do its thing at this corner and any subsequent corners until CompCurv/CompCad resume producing polynomial blocks.

By default, a long G01 block is longer than 20 mm (0.7874 inches).

The best recommendation regarding G64 or G642 (or another member of the 3-digit G-codes) should come from your machine tool builder because he is the one who knows how the servos were optimized.

If your machine tool builder is no longer in the picture, or heavens forbid, he doesn't know, you may be left with trial and error to discover what works best. In this case, you may find my additional discussion below useful.

---------------------

Newtonian mechanics is part of a deeper discussion of continuous path control since CNC moves masses. It moves masses with servos. Servo is about negative feedback to control the position, velocity and acceleration of masses. With regards to servos it is probably sufficient to say that servo optimization consumes some choices. For example, if your axes have been optimized with Feed Forward turned on, whether you machine with FFWON or FFWOF is a choice that has already been made; you must always machine in FFWON.

About G64 . . .

The people who developed the 840D decided that the Overload Factor would be used to limit velocity steps at corners when G64 is active.

To understand velocity steps we need to recall that velocity is a vector with magnitude and direction. With G64, only the direction changes at corners. However, even a directional change results in a change in velocity as illustrated in the vector diagram below where the length of arrows Vin and Vout is the same. The velocity change is the ΔV arrow.

If the feedrate into and out of an intersectional point at the corner of two linear blocks is 100 in/min, the magnitude of the change in velocity at a 90 degree corner is 141.4 in/min (the square root of the sum of the squares). This is a step change in velocity since it occurs at the point. Keep in mind that the 141.14 is not the velocity at the point but rather, the change in the velocity vector at the point.

ΔV is also called the velocity jump and velocity step.

ΔV is limited according to the following equation:

ΔV <= axis_acceleration * (overload_factor-1) * IPO where

axis_acceleration is the linear acceleration of the least dynamic axis of the axes involved in the path interpolation. The axial linear acceleration is in MD32300 $MN_MAX_AX_ACCEL.

overload_factor is a value set in machine data 32310 $MN_Max_Accel_Ovl_Factor

IPO is the period of the interpolation cycle

The interpolation cycle is called the IPO (pronounced with long ee-PO) and just as often IPO means the period of the cycle. Ball park periods are 2 milliseconds for high speed machines and 4 milliseconds for machines with serious ambitions for high speed. Lets suppose it is 4 milliseconds. Every 4 milliseconds the CNC samples the interpolation function to output an incremental set point to the position control servos.

We get acceleration when we divide both sides of the equation by IPO, and since IPO is a scalar, this acceleration is in the direction of the ΔV vector.

ΔV/IPO <= axis_acceleration * (overload_factor-1)

This acceleration - the consequence of a step increase in thrust impressed on the load through the drive linkages and originating from a rapid increase in torque from the motor - acts for one IPO.

The default setting for the Overload Factor is 1.2. In this case, the acceleration ΔV/IPO is 20% of the linear acceleration of the least dynamic axis.

To be sure, an infinite acceleration would be required for the direction to change at a point. However, the change can occur on a dime because a dime has a radius. The radius of the dime is the travel that can occur in the time of one IPO at the feedrate of the tool when it enters the dime.

[To my international readers, a dime is smaller in size than the U.S. penny. Its value is 1/10 of a dollar. In the U.S. we say that a car cannot stop on a dime.]

To return to the 100 in/min example, if the interpolation period is 4 milliseconds, the ΔV/IPO acceleration is 589.25 in/sec2. This is 1.53G since 1G is 386.0892 inches/sec2. If the corner is actually taken at a feedrate of 100 in/minute, the X and Y servos must be able to accelerate the X and Y axes at 1.08G and the CNC must be told that it can do its calculation on the assumption that the axes can accelerate/decelerate at 1.08G without going unstable.

If the axes cannot accelerate/decelerate simultaneously this quickly, the CNC must decelerate into the corner so that its velocity at the start of the interpolation cycle wherein the change in direction will occur is small enough so that ΔV of the equation is not exceeded.

The Siemens manual says that G64 takes corners at a constant velocity. This means the magnitude of the velocity out of the dime is equal to the magnitude into the dime. Having come out of the dime the axes accelerate back to the programmed feedrate.

To return to the acceleration of the vector diagram – ΔV/IPO – this acceleration is a consequence of the thrust generated by the servos. If linear motors are used, the thrust is generated directly by the interaction of magnetic fields. If rotary motors are used, mechanical linkages convert motor torque into thrust. Typical linkages are ball screw & ball nut and rack & pinion.

[The servo drives must be able to generate changes in linear motor thrust or rotary torque in much shorter time periods than the IPO. The torsion wave must be able to travel smoothly through the drive linkages.]

The acceleration – ΔV/IPO – is lateral acceleration. Lateral acceleration is sideways to the motion.

When you drive a car quickly along a tight radius, your inertia keeps you moving in a straight line. The door collides with you and pushes on you. This push is the force that produces the lateral acceleration that keeps you with the car. Of course, in a real world situation, some of the lateral force is from the contoured seat back, the seat belt and the static friction between your bottom and the seat. Still, if you go fast enough and the car stays on the curve these contributions may not be enough to prevent the door from smashing into you.

Physicists use the term centripetal acceleration for lateral acceleration. Your science teacher may have called it centrifugal acceleration. Your teacher was wrong. The force that keeps a mass on a curve is inward acting and centripetal is the term that names the acceleration that is a consequence of this.

Back to CNC axes . . . , the lateral acceleration is a fraction of the linear acceleration and this fraction is determined by the Overload Factor that has already been mentioned. An Overload Factor of 1.2 means that the limit on lateral acceleration is 20% of the linear acceleration of the least dynamic axis of the axes involved in the path interpolation. Thus, if the least dynamic axis is limited to 0.5G of linear acceleration, the lateral acceleration is limited to 0.1G.

However, ΔV is limited, not ΔV/IPO. The CNC uses the 0.1G to calculate an upper bound for feedrate and if this upper bound exceeds the programmed feedrate the CNC decelerates the axes into the corner so that when the last IPO of the interpolation function is due, the feedrate into the dime is <= the upper bound.

The Overload Factor is a machine data setting that is established when the servos are optimized. The factor is a compromise between cycle time and surface finish. If the factor is too high for the rigidity of the mechanical elements the axes will flutter at corners (same as saying "oscillate at corners") and this will be recorded in the surface finish. The Overload Factor can be higher for roughing if the flutter is not so severe that it degrades the mechanical rigidity of the linkages.

Ideally, the machine tool builder employs Cycle832 to set the Overload Factor for the mode of machining (roughing, semi-finishing, finishing).

The servos may be able to drive the tool into a change of direction that is greater than our example 0.1G. However, the mechanical linkages may not be able to withstand the inertial forces that this produces. In other words, the axes are not rigid enough. They will tend to flutter and degrade the surface finish. Engineers who do servo optimization have software tools that reside in the CNC to observe the behavior of the axes and determine an optimum value for the Overload Factor.

To repeat what has already been said, if the velocity step to take the the next corner exceeds the maximum velocity step derived from the Overload Factor, the CNC must decelerate the tool along the interpolated path as the tool approaches the corner so that when the interpolation cycle comes due to make the change in direction, the magnitude of the feedrate is reduced so that the velocity step stays within bounds.

If the Overload Factor is set to "1" the allowable step change in velocity is "0". In this case, the CNC must bring the path axes to a stop at corners and G64 appears the same as G60.

With regards to G64 at tangential intersections, the intersection between two blocks is not a corner when the geometric elements blend together tangentially such as a line meeting the arc of a circle tangentially. There is no step change in velocity at a tangential intersection so the Overload Factor is not at play here. However, there is a step in lateral acceleration since lateral acceleration is always required to achieve curved motion. Unless there is another scheme to limit this acceleration the servos get on with doing what they do without constraints. The shock of this step can cause flutter that gets recorded in the surface finish.

For the record, G643 employs the Overload Factor to limit lateral steps in acceleration at tangential intersections.

By the way, a linear acceleration of 0.5G is very dynamic. The upper limit on mechanical drive systems for small machine tools is roughly 2G but normally, accelerations of this magnitude require linear motors.

By the way again: A "G" is the acceleration of gravity at the Earth surface. It is 9.8067 meters/second per second. It is 32.1741 feet/second per second.

About G642 . . .

G642 does smoothing by inserting a rounding block (b-spline) at the corner. The path must pass within the so-called Compressor Tolerance of the corner. The easiest way to set the Compressor Tolerance is with Cycle832 discussed in another post.

Cycle997 to Measure Tooling Balls

2009-07-30T15:20:00.000-07:00

Cycle997 for 840D CNC by Siemens is a standard Siemens measuring cycle to probe tooling balls to find their ball centers. Cycle997 can probe three tooling balls and calculate an error frame that when added to the currently active frame will align the G54 system (or the one you use) to the workpiece as it sits translated, out of square and cocked in the work envelop of the machine.

The example of this post is from an aerospace shop where the workpiece came to our machine with 4 tooling balls with documentation regarding their ideal locations from a previous operation on a different machine. We indicated one of the balls with a mechanical probe and scratched a zero offset into G54.

The first Cycle997 in the program below measures this ball for more precise G54 determination.

The second Cycle997 measures 3 of the 4 balls to align G54 to the workpiece as it sits out of square and cocked in the work envelop of the machine.

In our first run of the program the probe missed a ball by a hair. We picked a different set of 3 and did fine. Alternatively, we could have fudged the diameter of the balls by making _setval slightly less than 0.5”.

%_N_Job1942_MPF
N05 T9999 M06 ;touch probe
N10 Jog_spin ;sub to jog spindle to turn on probe
N15 TRAORI
N20 G00 G70 G54 Z30 D1 ;establish an initial level
N25 _mvar=119 ;measure a single ball for G54 determination
N30 _setval=.5 ;diameter of tooling ball
N35 _setv[0]=-70.7904 _setv[1]=36.9768 _setv[2]=18.8512 ;ideal XYZ center of tooling ball
N40 _knum=1 ;correct G54
N45 _fa=10 ; cycle997 will position the probe 10 mm off of the touch point. The distance-to-go of the measurement infeed is 2*_fa. _fa always has mm units. Don’t ask why!
N50 _tsa=.3 ;_tsa is a tolerance. See explanation in text after the program
N55 _vms=10 ;the feedrate for the G01 measure move
N60 _nmsp=1 ;one hit at each location
N65 _prnum=1 ;the number assigned to the probe for calibration
N70 Cycle997 ;measure 1 ball for G54 determination
N75 _mvar=10119 ;code for 3-ball measurement for G54 correction
N80 _setv[0]=23.7217 _setv[1]=36.4123 _setv[2]=18.878;XYZ 1st ball
N85 _setv[3]=69.6605 _setv[4]=-35.4953 _setv[5]=27.6538 ;2nd ball
N90 _setv[6]=-70.7904 _setv[7]=36.9768 _setv[8]=18.8512 ;3rd ball
N95 _tnvl=.1 ;tolerance for sum of sides difference[1]
N100 _chbit[2]=0 ;collision monitor off. rapid between balls
N105 Cycle997 ;measure 3 balls for G54 alignment to workpiece
N110 Jog_spin ;turns off probe
N115 M30

The distance-to-go of the measurement infeed is 2*_fa. The cycle will alarm if the probe does not touch before over traveling the target by the _tsa distance.
[1] Each ball is at the vertex of a triangle. The sum of the sides of the ideal triangle and the actual triangle must not differ by more than the _tnvl amount or the cycle alarms.

Cycle971 for Tool Measurement

2009-07-30T15:03:00.000-07:00

Cycle971 for the 840D CNC is a standard Siemens Measuring Cycle that works in conjuntion with a tool probe to measure tool length and tool radius.

The program of this post was prepared and tested on a horizontal boring machine with an AC head to orient the tool. The program makes use of Cycle971 to measure the length of a drilling tool and the length or length & radius of a milling tool.

Tools that are defined in the drill family of cutters are measured for length with a stationary spindle.

Tools that are defined in the milling family of cutters are measured for length with a spinning spindle. If the Call is Meas_TL(1), the tool is measured for length and radius. By default the speeds and feeds are calculated by Cycle971.

Since the program is highly commented I will leave it to you to learn the technology from it. Keep in mind that the program is highly specific to the machine in question.

The program assumes you have set the D-code for the tool within a tolerance of 1/4th inch.

Good luck.

%_N_MEAS_TL_SPF
;$PATH=/_N_CUS_DIR
;Last edited 07/10/2009
N1 Proc Meas_TL(Bool Radius_Also, Real _myID, Bool Use_MFS) Save
;check that A & C rotary axes are at zero
N2 IF TRUNC(1000*$aa_im[C])<>0 AND TRUNC(1000*$aa_im[A])<>0
N3 Not_OK: MSG("Axes C or A - or both - are not at zero")
N4 G4 F3
N5 MSG("Reset & program C and A to zero.")
N6 G4 F3
N7 GOTOB Not_OK
N8 ENDIF
;Check for an active tool and D-code
N9 IF ($p_toolno==0)OR($p_tool==0)
N10 Not_OK: MSG("T-code not programmed or D-code is D0.")
N11 G4 F3 ;reset and program a T-code or D-code
N12 GOTOB Not_OK
N13 ENDIF
N14 $mn_g53_toolcorr = 0 ;so SUPA does not cancel the D-code
N15 Newconf ;to activate the machine data change
N16 IF $p_ad[1]==121 ;end mill with corner rounding
N17 _id=$p_ad[7]
N18 ELSE
N19 _id=_myID
N20 ENDIF
N21 M64 ;tool probe on
N22 G4 F3 ;delay for tool probe to turn on
N23 _speed[1]=75 ;feed for positioning in the XY plane
N24 _speed[2]=40 ;feed for positioning in the Z-axis
N25 _chbit[3]=0 ;wear monitor disabled for a 1st measurment
N26 _chbit[2]=1 ;collision monitoring on
N27 _chbit[17]=0 ;_speed[1] & [2] for positioning. _vms for measuring
N28 STOPRE
N29 IF ($P_AD[1]>=100)AND($P_AD[1]<200)>=200)AND($P_AD[1]<300) ;if drilling tool
N31 MSG("Measuring Length with Stationary Spindle")
N32 M5
N33 G00 SUPA X=(_tp[0,0]+_tp[0,1])/2 Y=((_tp[0,2]+_tp[0,3])/2)-2*$p_ad[6]
N34 SUPA Z=_TP[0,4]+1 D1
N35 _MVAR=1 ;measure tool with motionless spindle
N36 _MA=203 ;Offset in Y. Probe in Z
N37 _FA=12.7 ;stand off clearance. 0.5 inch in English.
N38 _TSA=0.501 ;Overtravel limit on the measurement move.
N39 _TZL=0 ;scatter range
N40 _TDIF=0.5 ;not applicable when _chbit[3]=0
N41 _PRNUM=1 ;use calibration data from row 0 of tool probe array
N42 _VMS=5.5;measure feedrate.
N43 _NMSP=2 ;make 2 measurements and average
;N39 _ID=_myID;additional centerline offset for tools with radius in D-code
N44 _EVNUM=0;no empirical value memory specified. No _mv correction
N45 STOPRE ;not necessary but some people like it for comfort
N46 MSG("Measuring Length with zero spindle speed for tools defined as type 1xx like drills, ball end mills, reamers, taps, etc.")
N47 Cycle971
N48 SUPA Z=_TP[0,4]+10
N49 ELSE
N50 Wrong_Tool: MSG("Tool not type 1xx or 2xx")
N51 G4 F5 ;tool not of the type that can be measured by this cycle
;reset to clear message
N52 GOTOB Wrong_Tool
N53 ENDIF
N54 GOTOF _n9999 ;
N55 Spin_On:;Measure tool length with spin turning
N56 IF NOT Use_MFS GOTOF Use_CM
N57 _chbit[12]=1 ;use _mfs values
N58 _mfs[0]=$p_s[1];most recent programmed speed
N59 _mfs[1]=$p_f ;most recently programmed feed
N60 _mfs[2]=1.25*$p_s[1];spindle speed for 2nd meas
N61 _mfs[3]=$p_f/10;feed for 2nd meas
N62 _mfs[4]=0;no 3rd meas
N63 _mfs[5]=0;feed for 3rd meas
N64 GOTOF Meas_Length:
N65 Use_CM: ;cycle calculates speeds, feeds
N66 _chbit[12]=0 ;Calculate F&S from _CM data
N67 _cm[0]=300 ;SFM feet/min
N68 _cm[1]=3000 ;upper limit on spindle speed
N69 _cm[2]=.075;in/min lower limit on feed
N70 _cm[3]=0.0005 ;measuring accuracy. measuring feed = spin_speed*_cm[3]
N71 _cm[4]=1.25 ;in/min upper limit on feed
N72 _cm[5]=4 ;spindle direction for measuring
N73 _cm[6]=1 ;feed factor 1
N74 _cm[7]=0 ;feed factor 2
N75 Meas_Length: G00 SUPA X=(_tp[0,0]+_tp[0,1])/2 Y=((_tp[0,2]+_tp[0,3])/2)-2*$p_ad[6]
N76 SUPA Z=_TP[0,4]+1 D1
N77 _MVAR=2;measure with spindle turning
N78 _MA=203 ;offset in Y, measure in Z
N79 _FA=12.7 ;the stand-off clearance. 0.5 inch in English.
N80 _TSA=0.5001 ;Overtravel limit on the measurement move.
N81 _TZL=0 ;scatter range
N82 _TDIF=0.5 ;no significance when _chbit[3]=0
N83 _PRNUM=1 ;calibration data fm row 0 of tool probe array
N84 _VMS=0 ;no significance since feedrate is calculated by cycle
N85 _NMSP=1 ;make 1 measurement
;N82 _ID=_myID ;additional offset in addition to radius
N86 _EVNUM=0;no empirical value memory specified. No _mv correction
N87 _chbit[3]=0 ; correction applied to tool geometry with resetting of wear
N88 MSG("Measuring Length of tools defined as milling of type 1xx with Spinning Spindle")
N89 Cycle971
N90 SUPA Z=_TP[0,4]+1
N91 Meas_Radius: ;measure tool radius with spin turning
N92 IF NOT Radius_Also GOTOF _n9999
N93 G01 F10 SUPA X=(_tp[0,0]+_tp[0,1])/2 Y=((_tp[0,2]+_tp[0,3])/2)-2*$p_ad[6]-.25
N94 SUPA Z=_TP[0,4]+1 D1
N95 _MVAR=2 ;measure with spindle turning
N96 _MA=2 ; measure radius in Y direction
N97 _FA=6.35 ;the stand off clearance. 0.25 inch in English.
N98 _TSA=0.2501 ;Overtravel limit on the measurement move.
N99 _TZL=0 ;scatter is zero
N100 _TDIF=0.25 ;no significance when _chbit[3]=0
N101 _PRNUM=1 ;calibration data fm row 0 of tool probe array
N102 _VMS=0 ;cycle calculates feedrate
N103 _NMSP=1 ;number of hits at single location
;N101 _ID=_myID ;no additional travel in the plunge move
N104 _EVNUM=0;no empirical value correction. No _mv correction
N105 MSG("Measure tool radius")
N106 Cycle971;measure tool radius
N107 _n9999: SUPA Z=_TP[0,4]+10 D1
N108 STOPRE
N109 m65
N110 RET

Cycle832 & Cyc_832T for High Speed Machining

2009-07-26T12:59:00.000-07:00

Cycle832 and its underling Cyc_832T are proffered by Siemens to bring transparency to programming technology functions for high speed machining.

The specialists who optimize the servos, and only the most experienced of them, are the ones who understand the full scope of preparatory functions and parameter settings for high speed machining. This understanding is custom packaged for a particular machine. It is passed to the final user as a canned cycle. The standard Siemens canned cycle for high speed machining is Cycle832. Cycle832 provides a structure for customization as well as enabling the specification of the essential preparatory functions that are intended for high speed machining.

The Cycle832 is written to receive two values from the call block. The first is the so-called compressor tolerance. The second is an integer whose places encode a particular choice of preparatory function.

Here is an example of Cycle832 parameterization from a large horizontal boring mill . . .

N1492 Cycle832(0.0005, 210101)

The first parameter is the compressor tolerance.

The second parameter is as follows

100 Thousands Place
0 for CompOff
1 for CompCad
2 for CompCurv
3 for BSPLINE

10 Thousands Place
0 for FFWOF SOFT
1 for FFWON SOFT
2 for FFWOF BRISK

Thousands Place
0 for G64
1 for G641
2 for G642

Hundreds Place
0 to cancel Traori
1 for Traori(1) (Traori by itself is Traori(1))
2 for Traori(2)

Tens place
Not used unless builder says otherwise

Units Place
0 to deselect high speed machining
1 to finish
2 to semi-finish
3 to rough

Cycle832 calls up Cyc_832T. Cyc_832T is where the machine tool builder embeds his values for the machine data that is associated with high speed machining. By interrogating the units digit he can have different settings for the different machining types.

Fortunately for the machine tool builder, Cycle832 and Cyc_832T are relatively easy to reverse engineer to understand how they are structured and where to embed special high speed machining know how.

Cycle832 and Cyc_832T are explained in the Cycle programming manual, the same manual where Cycle81 is explained. The manual explains Cycle832T, at least initially, from the perspective of the cycle support screen. This begs the questions, "Does Siemens expect that expertise with regards to high speed machining resides with the operator?" It cannot be with the operator. It has to be the programmer.

The programmer must be trained carefully and thoroughly by the machine tool builder and thereafter the programmer can apportion responsibility between him and the operator. If the matter is handled properly by the machine tool builder, near-nothing needs to be apportioned to the operator. In this case, cycle support for Cycle832 is strictly a way for him to identify the parametrization done by the programmer if he is so inclined.

With respect to the example shown earlier, CompCurv and G64 were selected. Siemens recommends G642 for corner smoothing but the user of the machine in question felt he got better results with G64. With regards to CompCad versus CompCurv, Siemens latest documentation suggests CompCurv be the first choice because CompCad is more demanding on microprocessor resources. In fact, when we used CompCad on the machine in question we got system alarms that implied the microprocessor was crying uncle. This is the first time I had seen this happen and I wonder if the problem was the program itself that was posted to infinitesimally small linear blocks for compatibility with another machine with a different vender’s CNC that did not have a compressor function. In addition, the programmer worked from a solid model that was generated from blueprints and not CAD files. I suspect the model was “noisy”.

CompCurv and CompCad are spline algorithms that generate 5th order polynomials. In addition, CompCad does acceleration smoothing.

Cycle832 resides in the standard cycles direction with Cycle81 and the other standard machining cycles. However, Cycle832 differs in two significant ways from machining cycles. First, Cycle832 is not about defining the geometry of a machining operation as is Cycle81. Rather it is about defining a set of technological conditions for proceeding with subsequent interpolation of the blocks of geometric data. Second, Siemens does not expect the machine tool builder to modify Cycle81, but for sure, Siemens expects the machine tool builder to modify Cycle832. Actually it is Cyc_832T that Siemens expects the builder to modify as has already been discussed.

At this point I will discuss the compressor tolerance since it is the first parameter of Cycle832.

If you are a follower of my posting, you know that the compressor tolerance is associated with G642 and with the compressor functions CompCad and CompCurv. You may also know that I am not a big fan of the term "compressor". CompCad and CompCurv are b-spline algorithms that act on sequences of linear blocks to interpolate a curve that is rendered as piecewise continuous parametric polynomial interpolation functions. The latter are the functions that are sampled on a time grid to output incremental setpoints to the position servos. I prefer to talk about CompCad and CompCurv this way because it leverages these algorithms to advance our understanding of CNC.

The fact that the algorithms present many small linear blocks to the sampling function as one big block is probably the origin of the term "compressor".

B-spline algorithms are not expected to interpolate points precisely but rather to come within a range of the points. The smaller the range the more precisely the algorithm reproduces the original spline from whence the points were posted. On the other hand, the smaller the range the more the algorithm consumes microprocessor resources and something has to give. The give is usually in feedrate.

So, the range is the so-called compressor tolerance.

The tolerance is set high for roughing and low for finishing. It is set in machine data. The tolerance could be set in machine data from the user's workpiece program using the system variable $ma_compress_pos_tol[axis address]. However, as a general rule, the user is not expected to write to machine data. So, the compressor tolerance is a parameter of Cycle832 and within the innards of Cycle832, values specified by the user are written to $ma_compress_pos_tol[axis address]. The compressor tolerance specified in the call to Cycle832 is for the linear axes X, Y and Z.

Siemens recommends that the compressor tolerance for rotary axes is 200 to 300 times the compressor tolerance for linear axes (8 to 12 times in millimeters). The actual setting depends on many factors that are known to the machine tool builder and the person who does the servo optimization. The machine tool builder embeds this number in Cyc_832T.

The compressor tolerance is also associated with G642. G642 inserts a b-spline smoothing block at corners. The spline must come within the compressor tolerance of the corner. When G642 is modal along with CompCAD/CompCurv, it only comes into play for smooth transitions into/out of blocks that are not acted upon by these algorithms. This includes all blocks that are not G01 blocks and all G01 blocks that are greater than a specified threshold (the default is 20mm/0.7874 inches).

Some CNC workers report better results when they use G64. G64 uses a different dynamic model to take corners. This model defines lateral acceleration as a percentage of linear acceleration. This percentage is called the overload factor. It is normally a value from 120 to 180. A value of 120 means the control can assume that a lateral acceleration of 20% of the linear acceleration will not destabilize the corner transition. The CNC slows down the feedrate as the tool approaches the corner so that the change in the velocity vector at the intersection can be taken in one period of the sampling rate (typically 2 to 4 milliseconds for a machine with high speed ambitions).

I have already mentioned the difference between CompCad and CompCurv. The Siemens manual recommends that you use CompCurv before resorting to CompCad because the latter is more demanding of computer resources. Both CompCad and CompCurv produce 5th order polynomials. CompCad does more acceleration smoothing than CompCurv. This could make a difference when you are seeking mirror perfect surface finishes.

Let it be said at this time, that high speed machining is not always high speeds and feeds. Rather, it implies the use of a set of preparatory functions and machine data items for smooth machining of curves and surfaces for accuracy, surface finish and cycle time. Siemens developed these functions to exploit high speed spindles – that in turn were developed to exploit high speed cutting materials – and their deployment in any case is considered “high speed” even when the machine is clearly not high speed.

A word of caution to users, retrofitters and machine tool builders . . . , it is not difficult to realize an 840D CNC servo platform for high speed 5-axis aerospace machining. Making this platform produce high quality parts is a horse of a different color. Even machine tool builders who have done 5-axis for years may not have the expertise to exploit the 840D. Fortunately, Siemens has world class experts in the U.S. (truly gold metal Olympians in their field) who can save the retrofitter or builder huge cost overruns when they are consulted early in the project.

Cycle84 Rigid Tapping

2009-06-14T01:24:00.000-07:00

Cycle84 for 840D CNC is illustrated in the program below where it peck taps with chip breakage. The infeed for each peck is 3/16 inch (0.1875). The retract for chip breakage is 1/16 inch (0.0625).

%_N_Peck_Rigid_Tap_MPF
;$PATH=/_N_WKS_DIR/_N_Examples_WPD
N05 T6 ;3/4-16 tap
N10 M6
N15 S300 M3
N20 G70 G54 G00 X0 Y0 Z1 D1
N25 CYCLE84(1,0,0.2,-1.5,,,3,,16,0,300,300,3,2,,1,.1875,.0625)
N30 G0 Supa Z0 D0 M5 ;return Z-axis to its machine zero position
N35 M30

Block N30 assumes Z-machine=0 is towards the far end of the Z axes' positive stroke. Supa means Supress All [frames]. For most applictions this means supress all zero offsets. (To be mathematically correct, it means to supress the orthogonal tansformation.) Supa is single shot. The G54 (or the one you use) is back in action after the supa block.

A parameter that gets its value from a location that is vacant is assigned a value of zero in the cycle.

The following is an explanation of the parameters.

RTP 1 Retract coordinate, also known as retract plane
RFP 0 Reference. Coordinate of plane of hole mouth
SDIS 0.2 Safety clearance. Tapping starts from SDIS above ref plane
DP -1.5 Final depth, absolute
DPR vacant Final depth relative to reference plane
DTB vacant Dwell at thread bottom
SDAC 3 Direction of rotating after the cycle has run
MPIT vacant Metric M-code of thread. M3 to M48
PIT 16 Thread specified as per _PTAB below
POSS 0 Spindle position for oriented spindle stop
SST 300 Spindle speed for tapping down to final depth
SST1 300 Spindle speed for reversing out of thread
_AXN 3 Typically 3 for the third axis (Z in G17)
_PTAB 2 Code for dimensions of PIT. 2 is code for threads per inch
_TECHNO Msc servo & in-position functions. Cycle uses defaults
_VARI 1 Variant of cycle. "1" means deep hole with chip breaking
_DAM 0.1875 Incremental infeed of each peck
_VERT 0.0625 Retraction for chip breaking

Siemens intends the reference plane to be the plane of the hole mouth. The cycle rapids the tool to the safety clearance above the reference plane. Tapping starts from this position. Reverse tapping ends at this position and then the tool rapids to the retract plane.

To edit values in the (value, value, . . . , value) structure, or simply to associate a value to its parameter, put the cursor on the block of the cycle call, press the Edit cycle soft key and get a conversational editing screen.

There exists a system variable that can be used in a cycle to check for vacants in the (value, value, . . . , value) structure. As said already, in the cycle subroutine, the local variable that maps to the vacant is assigned a value of zero. This system variable can check if it is zero because of a vacant or if a zero actually occupied its place between two commas.

Cycle83 Deep Hole Drilling

2009-06-14T01:23:00.000-07:00

Cycle83 for 840D CNC deep hole drilling (also known as peck drilling) is drilling with interruptions in the infeed for chip breakage and/or swarf removal.

The incremental infeed between interruptions is the peck.

The cycle is called with the (value, value, . . . , value) structure. One of these values is for the parameter VARI (variant). When VARI is assigned 0 the drill appears to hiccup at the bottom of each incremental infeed. This hiccup is a slight backing-off to break the chip. The tool then proceeds to drill the next incremental infeed. When VARI is 1 the drill pulls out of the hole (to the safety clearance) to sling off the chip. This also allows coolant to flush out the hole before the drill rapids back into the hole to continue drilling from a point above where it left off. This pull-out is what Siemens means by "swarf removal".

The most recent version of the cycle (as of Spring, 2004) has 17 cycle parameters. Any given deep hole machining operation uses a subset of these parameters.

As expected, Cycle83 drills down. It also drills up. Down drilling is the negative direction of the drilling axis. The cycle takes care to know the drilling direction from the retract plane relative to the reference plane.

The cycle accounts for digression. Digression acknowledges that the nature of deep hole drilling often requires that the next peck advances less into the work than the former peck. Digression is specified as an amount or as a factor. When the digression is an amount, say 0.1 inch, if the 1st peck drills out 1 inch of stock then the 2nd peck will drill out an additional 0.9 inches of stock for an accumulation of 1.9 inches of hole depth, the third peck an additional 0.8 inches, etc. When the calculated infeed for the next pass is less than the digression amount, the cycle makes the infeed equal to the digression amount.

The digression amount can also be set as a factor of the previous peck. If the 1st peck is 1 inch and the factor is 0.9 then the 2nd peck is 1*0.9 = 0.9. The third peck is 1*0.9*0.9 = 0.81. The infeed of the next peck is not allowed to be less than a value set in the parameter _MDEP.

When the cycle variant is 0 for hiccup, you can change the hiccup amount from its default of 1mm (1/25.4 inches) by assigning a non-zero positive value to _VRT. If _VRT is not assigned a value the cycles regards 0 as its value and it regards 0 as a command to use the 1mm default. When the cycle variant is 1 for pull-out, the programmer can control the return safety clearance when the drill rapids back into the hole with the parameter _DIS1.

If _DIS1 is not defined or if it is set to zero, the cycle calculates a return clearance based on the depth achieved in the most recent peck. The calculation uses the following function:

return clearance = 0.6mm when hole is between 0 and 30 mm
return clearance = 0.02*hole_depth when hole is between 30 mm and 350 mm
return clearance = 7mm (7/25/4 inches) when hole is greater than 350 mm

So, you see, if you do not specify a value for _DIS1 the return clearance becomes greater as drilling progresses to final depth. The function is quite arbitrary. It is a play on the numbers 3, 5 and 7. Maybe the writer of the cycle bet these numbers on the lottery on the day he wrote the function.

By default the cycle drills on the 3rd axis of the geometry system. This is the G17 XYZ system (or G18 ZXY or G19 YZX). You can override the default with the _AXN (geometry axis number) parameter. Be careful if you do. Tool length compensation acts on the applicate axis (the third axis of the triad). If you are drilling with a right angle head and your machine has not been commissioned with the tool carrier option you could be in Crash City. I prefer to rotate the G17 frame so that I am always drilling in the negative Z-direction. The physical axes actually doing the drilling might be X or Y but I program Z.

Since the G17 XYZ system can be translated and rotates so its XY is in a swivel plane with the Z pointing out of the plane, Cycle83 drills in 5-axes but there is nothing special about this because any 2 1/2 or 3 axis program will do the same.

Here are the cycle parameters:

CYCLE83 (RTP, RFP, SDIS, DP, DPR, FDEP, FDPR, DAM, DTB, DTS, FRF, VARI, _AXN, _MDEP, _VRT, _DTD, _DIS1)

__________________
RTP real Retract plane (absolute). The drill pulls out to the retract plane after reaching final depth. The use of “plane” does not have special significance. It is simply a coordinate on the drilling axis.
__________________
RFP real Reference plane (absolute). The coordinate in the drilling axis of the surface of the hole mouth. The direction from the retract plane to the reference plane determines if the drilling is down or up.
__________________
SDIS real Safety distance. The drill rapids from its initial level to a value that is the safety distance above the reference plane. It then feeds towards the reference plane and on to final depth.
__________________
DP real Final depth (absolute). The cycle drills to final depth in a sequence of incremental infeeds.
__________________
DPR real Final depth relative to reference plane. Assign a value to DP or DPR but not both. If you do the cycle uses DPR. DPR is programmed as a positive number.
__________________
FDEP real First depth (absolute). The first peck drills to this coordinate.
__________________
FDPR real First depth (relative to reference plane). Positive values only. Assign a value to FDEP or FDPR but not both.
__________________
DAM real Digression parameter.
Specify DAM > 0 for direct specification of the digression amount
Specify DAM < 0 digression factor. A value from -0.001 to -1. Note the minus sign.
__________________
DTB real Dwell time at the bottom of a peck for chip breaking Dwell time is in seconds when DTB > 0.
Dwell time is in revolutions when DTB < 0
__________________
DTS real Dwell time for swarf removal. When VARI = 1 (see below) the drill pulls out above the reference plane by the clearance and dwells for the DTS value to sling off chips. A positive DTS is seconds and a negative DTS is revolutions.
__________________
FRF real A feed factor that acts on the feedrate for the first peck only. This lower feedrate reduces the tendency for the drill to wander. The range is 0.001 <= FRF <=1. If set to less than 0.001 the cycle defaults to 0.001. If set greater than 1, the cycle defaults to 1.
__________________
VARI integer VARI = 0 for hick-up. VARI = 1 to pull out to sling off the chip (swarf removal)
__________________
_AXN integer To specify the geometry number of the drilling axis. If you do not specify an axis the cycles assumed the #3 geometry axis. _AXN = 1 for the #1 geometry axis (usually X) _AXN = 2 for the #2 geometry axis (usually Y) _AXN = 3 for the #3 geometry axis (usually Z)
__________________
_MDEP real Minimum incremental infeed of the next peck. Required when digression is set as a factor. Does not apply when DAM is >0 for direct specification of the digression amount.
__________________
_VRT real When VARI is set to “0” for hiccup, if _VRT is set to “0” the hiccup is 1mm or 1/25.4 inches. Otherwise the hiccup will be the value _VRT. _VRT should never be negative.
__________________
_DTD real Dwell time following the completion of the distance to go of the last peck, that is, the peck that achieves the final depth DP.

Dwell time is in seconds when DTB > 0.
Dwell time is in revolutions when DTB < 0.
__________________
_DISI: When _DIS1= 0 the cycle calculates a return clearance as a function of depth. Otherwise the return clearance is the value given to _DISI.
The _disi=0 function is …

clearance = 0.6 mm when hole is between 0 and 30 mm
clearance = 0.02*hole_depth when hole is between 30 and 350 mm
clearance = 7 mm when hole is deeper than 350 mm

__________________
Example Program: Drill a deep hole on Z-axis. No digression.

retract = 1
reference plane = 0 (surface of hole mouth)
safety clearance = 0.1
final depth = -3
absolute hole depth after first infeed = 0.5 (unsigned incremental from reference plane)

Parameters not assigned values resort to their defaults. trailing comas can be dropped.

%_N_Deep_Hole_w_Pull-Out_MPF
N10 T="Drill" M6
N15 S2000 M3 M8
N20 G00 G17 G64 G90 G70 G54 X ___ Y ___ F ___
N25 Cycle83(1, 0, 0.1, -3, , , 0.5) ;non modal call
N28 M30

Cycle81 Drilling

2009-06-14T01:21:00.000-07:00

Cycle81 is Siemens' machining [canned] cycle for shallow hole drilling.

Cycle81 is discussed extensively in this post since it is typical of Siemens standard machining [canned] cycles for hole operations. Also, this post leverages Cycle81 for a discussion on subroutine calls generally.

The standard cycles are macro subroutines. They are no different from macros you can write and store in the CST (Cycles Standard) directory. You can change them, but if you do, they are no longer standard.

If you want to change them, or replace them with your own drilling cycle, you should store your own cycles in the CUS (Cycles User) directory and leave the standard cycles as they are. You can even name your creation Cycle81.

To drill with your own Cycle81, unload the standard Cycle81 back from the user memory to the CST directory on the hard disk, load your Cycle81 and do a power-on-reset (NCK reset is sufficient). The power-on-reset causes a preprocessing of any newly loaded cycles.

Cycle81 drills on the 3rd axis. The 3rd axis (the applicate axis) is Z in the G17 system. The following is a review of the G17/G18/G19 geometry systems:

G17 X is #1 axis Y is #2 axis Z is infeed axis
G18 Z is #1 axis X is #2 axis Y is infeed axis
G19 Y is #1 axis Z is #2 axis X is infeed axis

Tool length compensation applies to the infeed axis.

Since the cycles function in the geometry system, and the geometry system can be at any linear translation and orientation relative to the machine [servo] system, the cycles can infeed on any tool axis as long as the 3rd axis (applicate axis) of the geometry frame is oriented to the tool axis. Thus, “Yes” is the answer to the question, can the standard machining cycles drill in 5-axis? However, as the previous sentences imply, it is not enough to point the tool into the drilling plane. You have to translate and rotate the geometry system so the 1st and 2nd axes are in the plane and the 3rd axis is normal to the plane and sticking out of the plane towards the spindle.

(You can write your own drilling cycle using the address MOVT for Move Tool. MOVT is an address for incremental displacements along the tool axis. A cycle that employs MOVT does not need the G17 system translated and rotated as discussed earlier.)

Here is an example that drills a hole at X0Y0. The hole mouth is in the Z0 plane. The final depth is Z-2 inches (absolute). The safety clearance is 0.1 inch. The retract plane is Z1 inch. The program positions the drill on the hole axis in X and Y and 2 inchs above the hole mouth.

%_N_Drill_Hole_MPF
T4 M6 ;1 inch drill
S2000 M6 M8
G0 G70 G90 G54 X0 Y0 Z2 D1 M8 F20
Cycle81(1,0,0.1,-2)
M5 M9
M30

The Cycle81 parameters are . . .

RTP 1” Retract plane
RFP 0” Reference plane. The drilling plane. The plane of the hole mouth
SDIS 0.1” Safety distance. Clearance from reference plane
DP -2.0” Final depth (absolute)
DPR vacant Final depth, relative from the reference plane

Cycle81 receives values from the (value, value, . . . , value) structure. Siemens does not have a word for this structure. Mathematicians might call it a tuple (from double, triple, etc.). I will call it the value structure. The value structure is a sequence of numbers, delimited by commas, that map to the cycle parameters.

Note that feedrate is not a cycle parameter. The feedrate is programmed before the cycle call.

The blocks prior to Cycle81 position the tool to a Z position. This Z position is known as the initial level. Normally it is the same as the retract level, but to clarify the distinction, it is Z2 in the example above. Cycle81 rapids [the tool] from the initial level to the safety clearance above the reference plane. It feeds to final depth in one continuous infeed. It does a G60 exact stop check at final depth. It rapids out to the retract level.

If you specify a value for DP you would specify 0 for DPR or leave the position vacant. If you specify DPR you would specify 0 or vacant for DP

In the following examples the retract plane is Z1, the reference plane is Z0, the safety clearance is 0.1 and the final depth (absolute) is Z-2

Example: Cycle81(1,0,0.1,-2) ;note that the 5th cycle parameter is simply left out
Example: Cycle81(1,0,0.1,,2) ;note that the 4th cycle parameter is simply left out.

The cycle evaluates the vector from the retract plane to the drilling plane to determine the direction of infeed. When the final depth is programmed absolutely, the cycle checks that the vector from the reference plane to final depth is in the same direction as the vector from the retract plane to the drilling plane, and if not, it alarms.

If you provide values for both DP and DPR the cycle checks that they are consistent and if not, it alarms.

SDIS and DPR are unsigned incremental values relative to the reference plane.

In the next example, the final depth is specified incrementally relative to the reference plane.

%_N_Drill_Hole_MPF
T4 M6 ;1 inch drill
S2000 M6 M8
G0 G54 X0 Y0 Z1 D1 M8 F20
Cycle81(1,0,0.1,,2)
M5 M9
M30

Note that the parameter for final depth (absolute) is left vacant. Also note that the final depth (relative) is not given a negative number. This is because the cycle uses the direction from the retract plane to the reference plane to know the drilling direction.

Here is an example that drills 2” into a reference plane at Z-1.

%_N_Drill_Hole_MPF
T4 M6 ;1 inch drill
S2000 M6 M8
G0 G54 X0 Y0 Z1 D1 M8 F20
Cycle81(1,-1,0.1,-3)
M5 M9
M30

Here is the same example with the final depth in incremental:

%_N_Drill_Hole_MPF
T4 M6 ;1 inch drill
S2000 M6 M8
G0 G54 X0 Y0 Z1 D1 M8 F20
Cycle81(1,-1,0.1,,2) ;hole depth incremental fm ref plane
M5 M9
M30

Note in the example below the mouth of the hole is still at Z-1 but the reference plane is taken the safety distance above the hole mouth in order to be Fanuc-like. Note that final depth (incremental) is 2.1.

%_N_Drill_Hole_MPF
T4 M6 ;1 inch drill
S2000 M6 M8
G0 G54 X0 Y0 Z1 D1 M8 F20
Cycle81(1,-0.9,0,,2.1)
M5 M9
M30

Assume there is 0.25” stock on the Z0 plane. The following example drills a zero depth hole to mill a pad:

%_N_Drill_Hole_MPF
T4 M6 ;1 inch drill
S2000 M6 M8
G0 G54 X0 Y0 Z1 D1 M8 F20
Cycle81(1,0.25.0.1,0)
M5 M9
M30

The following program is a modal call to do 5 holes on the line Y=0 with the first hole at X1:

%_N_Drill_Hole_MPF
N01T4 M6 ;1 inch drill
N02 S2000 M6 M8
N03 G0 G54 X0 Y0 Z1 D1 M8 F20
N04 Mcall Cycle81(1,0,0.1,-2)
N05 X1
N06 X2
N07 X3
N08 X4
N09 X5
N10 Mcall
N11 M5 M9
M30

In the true sense of modal behavior, the cycle of a modal call does not execute at X0. It executes at the end of motion blocks that occur after the cycle call. Mcall in a line by itself cancels the cycle call (like Fanuc's G80). The distance to go of the motion block can be zero as illustrated in the program below:

%_N_Drill_Hole_MPF
N01T4 M6 ;1 inch drill
N02 S2000 M6 M8
N03 G0 G54 X1 Y0 Z1 D1 M8 F20
N04 Mcall Cycle81(1,0,0.1,-2)
N05 X1 ;this “motion” block has zero distance-to-go
N06 X2
N07 X3
N08 X4
N09 X5
N10 Mcall
N11 M5 M9
M30

It is not possible to change cycle parameters between the cycle call and the cycle cancellation. For example, suppose the hole at X3 is an inch deeper:

%_N_Drill_Hole_MPF
N01T4 M6 ;1 inch drill
N02 S2000 M6 M8
N03 G0 G54 X0 Y0 Z1 D1 M8 F20
N04 Mcall Cycle81(1,0,0.1,-2)
N05 X1
N06 X2
N07 Mcall Cycle81(1,0,0.1,-3)
N08 X3
N09 Mcall Cycle81(1,0,0.1,-2)
N10 X4
N11 X5
N12 Mcall
N13 M5 M9
M30

You can use R-parameters in the value structure. For example . . .

%_N_Drill_Hole_MPF
T4 M6 ;1 inch drill
S2000 M6 M8
G0 G54 X0 Y0 Z1 D1 M8 F20
R0=1 R1=0 R2=0.1 R3=-2
Cycle81(R1,R2,R3,R4)
M5 M9
M30

This R-parameter example has significance to Siemens CNC workers who may recall that legacy Siemens CNC uses R-parameters to parameterize machining cycles.

You can assign local user defined variables to the value structure. For example . . .

%_N_Drill_Hole_MPF
Def real retract, reference, clearance, final_depth
T4 M6 ;1 inch drill
S2000 M6 M8
G0 G54 X0 Y0 Z1 D1 M8 F20
Retract=1 reference=0 clearance=0.1 final_depth=-2
Cycle81(retract,reference,clearance,final_depth)
M5 M9
M30

Variable names can be 32 characters long. The underscore is the only special character that can be used in a variable name. The variable name has to start with two alphas or an underscore and an alpha.

The variables retract, reference, clearance and final_depth are local variables. Local variables lose their existence at M30 or upon manual reset at any time when the program is running.

As the example shows - and the previous example with R-parameters - variables can be used as arguments to represent values in the value structure that are assigned to local variables of the cycle (although I have not illustrated the latter in this post). The local variables like retract and reference of the calling program cannot be read or written in the cycle. This is not true of R-parameters since they are global.

G500 , The Null Settable Zero Offset

2009-06-10T00:42:00.000-07:00

If we think of the 840D’s frame hierarchy as a tree, ground is machine zero, the tip of the trunk is base zero and branches that radiate from the tip of the trunk are settable zero offsets. A branch can grow a twig at its tip. This is the programmable zero offset. There is only one twig per branch but it can grow and grow. G500 can grow a twig also although G500 is a branch of zero length.

The trunk is made up of at least one offset called the Base Offset. Additional frames are available by machine data setting to be included in the trunk. The machine data item is MD 28081 Num_Base_Frames. When this item is set to “1”, the trunk is the sum of two base frames.

MD 28081 Num_Base_Frames defaults to “1” and by default also, this frame is reserved for the Scratch and Preset operations. (See DMD 9245 MA_Preset_FrameIDX).

If there is no additional base offset, when you specify G500 in the Scratch dialog box, the offset goes into the Base Offset. However, by default, as we have seen, there is an additional base offset, and also by default this offset is designated to receive the offset of the Scratch operation when G500 is specified in the Scratch dialog box. Otherwise if G54 is specified (or the one used), it receives the offset of the Scratch operation.

In a sense G500 is both the null settable zero offset and a statement in the Scratch dialog box that the scratched offset is not to go into one of G54, G55, etc.

When G500 is active, and assuming the programmable frame is null (for a zero length twig), base zero is work zero. In other words, work zero is the tip of the trunk.

If the base frames are null, all of them, there is no trunk. In this case G500 coincides with machine zero and our tree looks like a shrub with G54, G55, etc., radiating from the ground.

By coincidence G500 can appear to be the base offset, but even when this coincidence is true you are better off thinking of G500 as the null settable zero offset.

The Set Zero Frame
The additional base frame that is designated to receive the offset of the Scratch operation is called Set Zero. Set zero’s system variable is $p_setfr as in $P_SETFR=CTRANS(X,8.2334,Y,2.0077,Z,-3.069) which jambs the numbers X8.2334, Y2.0077 and Z-3.069 into the set zero frame variable. You can also display and edit the frame variables in the “Active WO & Compensation” screen in the Parameters area. So, Scratch and Preset are not the only way to write values to the set zero frame.
The numbers used in the paragraph above are from a machine whose machine coordinates of the bolster plate reference point were them. This bolster plate reference point was the centerline of the lower left bore where this bore’s centerline interested the plate’s top surface.

The bolster plate had on its surface a regular grid of locating bores. The fixture reference point for the next job was specified in the setup instructions to be X12 Y11 and Z1.75 from the bolster reference point. Since the program for the next job was in G500, we put these numbers in the Base Offset.
With regards to the offset from machine zero to the table reference point, we put these numbers in set zero.

(The machine tool builder should have defined machine zero at the bolster plate reference point but he didn’t. It is easy enough to do this after the fact. You would have to change the software limits and tool change position also and be prepared to stick around long enough to be sure there are no additional changes that otherwise will surface the minute you get home.)

The Frame Tree

2009-06-04T11:05:00.000-07:00

I was doing a seminar on 5-axis machining in Seattle one winter. I went outside during a break and saw a small tree that was stripped of its leaves and realized it could represent the 840D's sequence of frame variables.

Ground is machine zero. The trunk is base zero offset. Branching occurs at the tip of the trunk. Each branch is a settable zero offset. The twig off of the tip of a branch is a programmable zero offset (like Fanuc's "child" coordinate system). Work zero is the tip of the twig.

Normally the Base offset is zero. In this case we have a shrub with all branches radiating from ground.

My frame tree is highly simplified. The trunk is actually made up of several frame variables that support special functions. However, the only one you can set from the zero offset setting page is Base offset. The others are transparent and you do not know they exist even when you use the special function.

G500 is a zero length branch. A programmable twig can grow from this branch. Thus, it is not universally true that G500 puts work zero at base zero.

The graphic below is another representation of the frame sequence.

Frames and the Frame Variable Structure

2009-06-03T11:19:00.001-07:00

A frame is an XYZ rectangular system that is a member of the hierarchy of XYZ rectangular systems that culminate in work zero. Some of these systems require setting a machine data bit to be available for use. Some that are normally in play can be suppressed with a machine data bit. Otherwise, neither the machine tool builder nor the final user can create or eliminate members of the hierarchy. What they can do is enter values in the frame variables that accompany the XYZ systems of the hierarchy. This is what is happening when the operator enters numbers in the registers of the G54 setting page. The machine tool builder and final user can create frame variables that they can assign in whole or in part to an XYZ system of the hierarchy.

When the 840D was introduced in the 1990’s Siemens CNC workers confused the structure of the frame variable with the frame itself since the structure accounted for rotations, scales and mirrors as well as translations (offsets). However, even if the structure is translations only, there still exists the hierarchy of XYZ systems. In this respect, frames have been part of CNC for quite a long time but CNC workers did not need to be exposed to the lexicon of frame hierarchies since the structure was simple and there were only a few members of the hierarchy.

G54 and the 99 additional G-codes of its group illustrate that there are many more frame variables than there are XYZ systems in the hierarchy. The 100 frame variables of these G-codes are called settable zero offsets (SZO). Only one of them is allowed in the hierarchy at any given time and this is the one of the G-code that is active. The content of this active frame variable is the location and origin of an XYZ system relative to the XYZ system one notch down. The upper system is called the settable zero system (SZS) and the lower system is called the basic zero system in the Siemens manuals. Calling it basic and not base zero system may be a translation error since basic system is the generic term for the system that originates the hierarchy. Translation error aside, maybe it should be called the trunk zero system.

Before climbing trees, lets suppose for the sake of discussion that there is only one settable frame variable. This frame variable is associated with G54. Further, lets suppose that the only member of the frame hierarchy is this settable zero system (SZS). In this case, the work system is the SZS. The operator finds the location of this system by positioning the tool reference point to the desired work zero point and the numbers he sees in the machine system display of X, Y and Z are the numbers he puts in the X, Y and Z offset registers of the setting screen for G54. Programming G54 tells the CNC to consider the information in G54 frame variable (aka, the 01 settable zero offset) when the CNC convert work coordinates to machine coordinates as it must since the machine [servo] axes move the tool. Conversely, when you jog a machine axis, the CNC uses the information in the 01 settable zero offset to convert machine position to work position.

Our simplified frame hierarchy of a basic system (that is, machine system) and one frame can be represented with a stick in the ground. Ground is machine zero and the tip of the stick is work zero. A bush may be a better representation where many sticks radiate from the same ground point. One stick sparkles and this is the one of the active G-code.

A tree is closer to the actual frame hierarchy. The tip-top of the trunk is the origin of the base zero system. Branches radiate from this point to origins of settable zero systems. The programmer can create a twig off of the tip of the active branch. In the figure the twig is shown on the G54 branch. The tip of the twig is work zero.

The trunk is actually the composite of several frames. For more information see the Programming Manual Vol. II (Job Planning), Chapter 5 and the section on frame chaining. The trunk can be extended higher but there is only one trunk.

The twig can be extended further but it doesn’t branch.

Finally let be said that the user can create frame variables. These frame variables can be assigned to XYZ systems of the hierarchy but simply defining a frame variable does not create an XYZ systems.

Note 1: The figure at the beginning of this post shows a machine coordiante system and a basic coordinate system. This is because the figure - modified from a similar figure in the Siemens programming manual - accounts for both orthogonal and non-orthogonal machines. The typical machine is orthogonal and the atypical machine such as a tripod or other paraller kinematic arrangment of axes are far and few inbetween. For othogonal machines, the machine coordinate system is a right hand XYZ system. It becomes the basic system for the hierarchy. In other words, the displacement between MCS and BCS shrinks to zero in the figure. The MCS is the basic system and we call its origin "machine zero".

Note 2: In some of my earlier writing on frames, I tended to emphasize the frame variable structure rather than the hierarchical relationship between XYZ systems. The latter is key but the structure is important, of course. It has registers (aka, fields or variable elements) for translations, rotations, scales and mirrors.

Note 3: When the 840D is shipped from the Siemens factory, machine data is set for 5 settable zero offsets for G500, G54, . . . , G57. This number “5” can be changed to any integer up to 100 for a total of 100 frame variables for G500, G54, . . ., G57, G505, G506, . . . , G599.

Note 4: G58 is essentially the same as TRANS and G59 is a one time ATRANS. These G-code are for compatibility with former Sinumerik CNC systems by Siemens. Unless one is making a legacy program compatible to the 840D, a progressive programmer will let them fade into oblivion to be admired by denizens of memory lane.

Note 5: We have said that frames cannot be created or destroyed although some frames and unattached frame variables can be made to appear by machine data setting and some frames can be made to disappear by machine data setting. As the end user you are probably not going to be doing any of this setting. If you want a frame to “disappear” be sure that its individual variables are zero (or “1” in the case of the scale factor). When set thusly the frame is said to be null. Null is really the unity matrix like the number “1” is to the equality . . .

25 = 1*25

Note 6: The word “scalar” describes a stand alone variable or a variable that is a member of a structure. In the frame variable structure of the settable zero offset data file each element of the structure is a scalar.

Note 7: G500 is the first member of the settable zero offsets. I have always believed that Siemens intended G500 to be the null settable zero offset and thus set its registers to zero without possibility of change. With regards to the tree analogy of the frame hierarchy G500 would be a branch of zero length that can grow a twig. It is not clear to me that this is always understood by the editors of the Siemens programming manuals. Or maybe Siemens has given it non-null properties in subsequent developments.

Note 8: Test your knowledge. What does the following do?

$P_UIFR[2]= $P_UIFR[1]

It assigns G54 to G55.

Circle Diamond Square

2009-05-21T08:50:00.000-07:00

I suppose if I show you a program for the cone frustum I should show you my NAS 979 circle diamond square program. The following is my finishing program. It has been awhile since I ran this program but I believe the blank was 2 1/2 inches thick and I took work zero so that the top surface was Zwork=2.5. As I recall, the blank was 14"x14". I finished with a circle of 6.065 radius. There is nothing special about this radius other than if the inspector asked me to cut the part again I would have stock above the 6" dimension. The inspector was not concerned about the 6" dimension but rather, if I cut the circle at 6.065, the square was 12.130 on a side and the diamond was 8.5772.

%_N_FINISH_CDSQ_MPF
;$PATH=/_N_WKS_DIR/_N_CDSQ_WPD
N2 G0 Supa Z0 D0
N4 R0=6.065
N6 A0 C0
N8 M51;Clamp A
N10 M53;Clamp B
N12 T14 ;3” face mill
N14 M6
N16 S3000 M03 F20
;Face blank
N18 G0 G54 X-13 Y0 M8
TRANS Z-.010
N20 CYCLE71(3.5,2.51,0.2,2.5,-7,-7,14,14,0,0.1,2.4,0.25,0,20,12,0.1)
;Finish diamond
N20 G0 G64 X-13 Y0 D1
N22 Z=2.1875 ;root of diamond
N24 M8
N26 G01 F20
N28 G247 G41 G451 X=-R0 Y0 DISR=4
N30 X0 Y=R0
N32 X=R0 Y0
N34 X0 Y=-R0
N36 X=-R0 Y0
N38 G0
N40 G248 G40 X-13 Y0 DISR=4
N42 M00
;Finish circle
N44 G0 G64 X-13 Y0 D1
N46 M8
N48 Z1.875 ;root of circle
N50 G01 F20
N52 G247 G41 X=-R0 Y0 DISR=4
N54 G02 I=AC(0)J=AC(0)
N56 G0
N58 G248 G40 X-13 Y0 DISR=4
;Finish square
N62 G0 G64 X-13 Y0 D1
N64 Z1.5625 ;root of square
N66 G01 F20
N68 G41 G451 G247 X=-R0 Y0 DISR=4
N70 Y=R0
N72 X=R0
N74 Y=-R0
N76 X=-R0
N78 Y0
N80 G0
N82 G248 G40 X-13 Y0 DISR=4
;Ramp Cuts
N84 S3000 M3
N86 M8
;Corner 3 to 2 low to high
N88 G0 X-9.5 Y-11
N90 Z2.5
N92 G01 Z=.2933 F20
N94 Y9 Z.9917
N96 G0 Z5
N98 M00;
;Corner 2 to 1 high to low
N100 G0 X-9 Y9.5
N102 Z2.5
N104 G01 Z=.9917 F20
N106 X11 Z.2933
N108 G0 Z5.0
N110 G0 Supa Z0 D0 M5 M9
N112 M30

Finding G54 on a Swivel Plane

2009-05-21T08:17:00.000-07:00

The blank of the NAS 979 cone frustum of my previous post is a disk 2.5 inches thick and 10 inches in diameter. It comes to the machine with a 2 inch bore in the center. Work zero is taken at a point on the centerline so that the top surface is Z-work=2.5.

The blank is mounted on a right angle fixture that is rotated 20 degrees CCW around Y.

So, we need the machine coordinates of the work zero point of the mounted disk because these are the values we put in G54 (or the one we use).

We employed the principle that when the work coordinate system is coincident with the machine coordiante system - that is, there is no zero shift or orientation offset between them - the work coordinate display is the machine position of the tool tip when length and orientation compensation are considered.

This principle leads to the program below:

%_N_SET_UP_MPF
;$PATH=/_N_WKS_DIR/_N_CONE_FRUSTUM_WPD
N2 DEF INT _choice=3
;Set _choice to 1 for the first time the borehole is indicated for the fixture
;Set _choice to 2 after the 12 inch calibration tool is on the centerline and 2" from the surface
;Set _choice to 3 to use the G54 to position to the centerline
;
N4 T4 ; set 12+2.5+2=16.5 in D1 of T4
N6 M66
N8 D1 ;L1 set to 4.5
N9 TRAFOOF
N10 G0 C90 A20
N12 TRAORI
N14 CASE _choice OF 1 GOTOF First_Time 2 GOTOF Calc_G54 3 GOTOF Pos_w_G54 DEFAULT GOTOF mEnd99
;
N16 First_Time:
N18 TRAORI
N20 ROT Y20
N21 G0 A3=0 B3=0 C3=1 ;normalize tool axis to swivel plane
N22 G500
N24 M00;switch to jog and position 12 inch calibration tool on CL & 2 inches from face of blank.
N25 ;Reset or Cycle Start when done
N26 GOTOF mEnd99
;
N28 Calc_G54:
N30 TRAORI
N32 ROT Y0 ;not a typo
N33 G0 A3=0 B3=0 C3=1;normalize tool axis to swivel plane
N34 G500 ;all zero offsets from work zero to base zero must be zero
N36 STOPRE
;Write work coordinates to G54 (Yes! Work!)
N38 $P_UIFR[1]=CTRANS(X,$AA_IW[X],Y,$AA_IW[Y],Z,$AA_IW[Z])
N40 GOTOF mEnd99
;
N42 Pos_w_G54:
N44 TRAORI
N46 ROT Y20
N47 G0 A3=0 B3=0 C3=1 ;normalize tool axis to swivel plane
N48 G54 X0 Y0
N50 Z16.5 D0 ;Change Z to clear if necessary
N52 M00
N54 mEnd99:
N56 TRAFOOF
N58 M30

It is unlikely you will understand how to reproduce my process from what I have posted here, so for more information, please email BleierCNCTraining@gmail.com

The NAS 979 Cone Frustum

2009-05-21T07:10:00.000-07:00

I programmed the NAS 979 Cone Frustum for an 840D CNC machine directly in the G-code language using circular interpolation of the tool tip and vector interpolation of the tool orientation.

The program proves the 5-axis worthiness of a horizontal boring mill with CA kinematics that orient the tool.

The machining operation is side cutting. You will see that I make use of 3D cutter radius compensation. I also use the insertion depth parameter to achieve the tool axis displacement required by the standard.

I am grateful to the good Dr. M of Siemens for his notes on conical interpolation and so much more.

The full explanation of the program below is a bit much for a post so I will leave it to you to review the program and read the few notes that follow. You are welcome to email me for my long article on the subject.

%_N_Cone_Frustum_MPF
Def real b_radius=5.670 ;base radius to just skin cut top edge of raw blank
Def real o_hang=1.40, o_change=.4 ;overhang & change in overhang
N06 T=4 M6 ;2" combo end/side mill
N10 G0 SUPA Z0 D0
N12 G0 C90 A0 ;to have a start position
N14 TRAORI
N16 ROT Y10 ;Rotate G17 XYZ system into swivel plane
N18 G642 CUT3DC ORIWKS F16 S1250 M3
N20 G54 G0 X=b_radius+1 Y=b_radius/3 A3=-sin(15) B3=0 C3=cos(15)M8
N22 Z0 D1
N24 Approach: G01 G41 X=b_radius Y=0 ISD=o_hang A3=-sin(15) B3=0 C3=cos(15)
N26 South: G02 ORICONCW X=0 Y=-b_radius CR=b_radius ISD=o_hang-o_change A3=0 B3=sin(15) C3=cos(15) A6=0 B6=0 C6=1
N28 West: G02 X=-b_radius Y=0 CR=b_radius ISD=o_hang-2*o_change A3=sin(15) B3=0 C3=cos(15) A6=0 B6=0 C6=1
N30 North: G02 X=0 Y=b_radius CR=b_radius ISD=o_hang-o_change A3=0 B3=-sin(15) C3=cos(15) A6=0 B6=0 C6=1
N32 East: G02 X=b_radius Y=0 CR=b_radius ISD=o_hang A3=-sin(15) B3=0 C3=cos(15) A6=0 B6=0 C6=1 ;complete one rev
N34 Escape: ORIVECT G1 X=b_radius Y=-b_radius/3 ISD=o_hang A3=-sin(15) B3=0 C3=cos(15)
N36 G40 G0 X=b_radius+2 ;to cancel G41
N38 ROT
N40 TRAFOOF
N42 G0 SUPA Z0 D0 M3 M9
N44 M30

The program represents the geometry perfectly of a cone frustum using circular interpolation of the tool tip and conical interpolation of the tool vector. Conical interpolation is commanded with Oricon (Orientation [is] Conical). There is OriconCW and OriconCCW. A6, B6 & C6 are the direction vector of the cone axis from the base to the apex.

G642 inserts a b-spline smoothing block at non-tangential corners. CUT3DC enables 3D cutter radius compensation for side cutting. OriWKS commands orientation in the work coordiante system. ISD is the insertion depth for side cutting. By changing ISD the program achieves the 1" displacement on the tool axis required by the standard.

OriVect commands great circle interpolation of the tool vector. It is in the same modal G-code group as Oricon. Great circle is possible when the orientation at the beginning of a block, the linear path of the block and the orientation at the end of the block are in the same plane.

The concentricity of the cone cut by the program was 0.0015" and its roundness was 0.0005". The 15 degree angle was near perfect. The surface finish rivaled a ground part. These are good results for a large horizontal boring machine. Of course, when the CNC has perfect geometry to interpolate, any deviation from the nominal is a measure of the mechanical ability of the machine and the precision of the pivot length and joint offset measurements associated with compensation for orientation.

Email me at BleierCNCTraining@gmail.com for my full article on the cone frustum.

Traori & Nurbs

2009-05-21T07:00:00.000-07:00

Traori and nurbs often get lumped together in discussions of 5-axis aerospace machining as if they are two sides of the same coin. They are not. They are two coins.

Nurbs is a b-spline algorithm.

Traori is a compensation function associated with 5-axis aerospace contouring.

With regards to Traori, as the CNC directs the tool tip to interpolate a curve in XYZ space it simultaneously changes the orientation so that the tool axis interpolates the orientation vector (typically the surface normal). Traori anticipates that the change in orientation will swing the tool tip off the contour. Traori compensates for this by superimposing incremental displacements on the linear axes. This happens in real time, simultaneously, in the interpolation cycle, roughly 500 corrections per second, so the tool tip is driven back to the contour at the same rate it swings off of the contour. Thus, Traori holds the tool tip invariant to changes in orientation.

Traori stands for Transformation [for] Orientation.

Traori can be observed quite readily. MDI Traori with an active tool and jog one of the orientation axes. You will see the linear axes go into motion to hold the tool tip stationary. The rotation pivots around the tool tip (or tool center point whichever you set).

As I have already said, nurbs is a b-spline algorithm that interpolates a curve. The algorithm acts on the geometry of the part program to render piecewise continuous parametric polynomial interpolation functions. The CNC samples these functions on a time grid, typically every 2 milliseconds, to output incremental setpoints to the position control loops (to the servos). This latter is what it means to say that the CNC directs the servos to cause the tool to interpolate a curve in the work envelop of the machine.

Note the double instance of interpolation. The algorithm interpolates the geometry of the program blocks to produce functions that are sampled by the CNC to direct the cutting tool to interpolate a path in the work envelop of the machine.

Nurbs is a member of the same modal G-code group as G01. G01 creates a straight line interpolation function for every block. Nurbs creates an polynomial interpolation function across many blocks.

Now for the zinger . . .

No one I know posts to nurbs block format. Programmers are still converting design’s splines – produced by nurbs algorithms in their CAD workstations – to polylines and posting the vertexes to linear blocks. To the extent that workpiece programmers systematically use a spline algorithm they program CompCurv or CompCad ahead of the linear blocks. Both produce 5 degree polynomials. Siemens recommends using CompCurv unless you need the acceleration smoothings of CompCad.

CompCurv/CompCad are not members of Group 1 since they have to see G1 blocks. Still, CompCurv/CompCad employ a variant of the b-spline algorithm to render piecewise continuous parametric polynomials from the points of the linear blocks. The software of the CNC innards that sample this function cannot tell which b-spline algorithm produced it, the nurbs or the CompCurv/CompCad algorithm

Given that CNC workers tend not to understand interpolation algorithms and parametric polynomials, nurbs has becomes a catchword for polynomial methods generally. I suspect that when most CNC workers talk about nurbs they are not making reference to the nurbs of control points, weights and knots.

So, there you have it, while nurbs and Traori would be discussed in an 840D seminar on 5-axis aerospace contouring, they are two separate coins and not two sides of the same coin.

Spline Algorithms

2009-05-21T06:52:00.002-07:00

Suppose an artist has drawn a 2 dimensional figure of Mickey Mouse and turned it into a connect-the-dots exercise in a child's workbook.

The child reveals this figure by connecting the dots with straight lines. Connecting the dots in this manner is linear interpolation.

Suppose the child free hands a path through the dots to reveal a more realistic figure. Since the child's goal is to reproduce a shape he believes the artist had drawn originally, he can give himself less stringent rules like 1)the path can pass close to the points and 2)it can pass close to points and bend sharply if necessary.

By now the child has done linear interpolation and he has experimented with two kinds of spline interpolation, the first is akin to b-spline (roughly) and the second to a-spline.

It it unlikely that the child will free hand the spline path in one continuous stroke. He probably has a preferred stroke, like from lower left to upper right. So, he will position the sheet so he can start at point 0 and spline interpolate a few points that are on his preferred stroke. He will re-orient the sheet so he can interpolate the next few points with his preferred stroke, being careful to blend the new segment with the previous segment. When he is done, the complete path is the sum of pieces of the path.

The artist of the original Micky Mouse is the equivalent of today's computer aided designer. As the designer rolls and clicks his mouse, a computer algorithm lurks in the background to render a curve or surface. This is a spline algorithm and typically, a b-spline algorithm. So, when we talk about spline in the context of CAD/CAM/CNC we have in mind a computer algorithm.

The algorithm is a set of rules and the code to execute these rules that act on geometric data - acquired by rolling and clicking - to render a curve. It should be obvious that if we provide the CNC with the same algorithm used in design, then for any geometry file acquired in the design phase (and downloaded to the CNC), the CNC can reproduce the curve precisely.

The CNC's spline algorithm acts on the CAD geometry data. It renders the curve as a sequence of piecewise continuous parametric polynomial interpolation functions that it samples on a time grid to issue setpoints to the position servos. Like the child re-orienting the paper for the next stroke and ending the project with a piecewise continuous path, each parametric interpolation function is a piece of the total path. To be clear, the parametric interpolation function is not the algorithm; the function is produced by the algorithm acting on the geometric data it is given.

Interpolation

2009-05-21T06:52:00.001-07:00

CNC workers use the word "interpolation" in three ways.

1. Interpolation means to find a path that satisfies clearly stated geometric constraints like the path has to pass through a sequence of points. Linear interpolation is when straight lines interpolate the points.

2. Interpolation seeks to find points between known points. If the 8 ounce drink is 50 cents and the 16 ounce drink is a dollar you have done a linear interpolation if you think the 12 ounce drink is 75 cents.

3. Interpolation is the process of sampling a function on a time grid to output incremental setpoints to the position servos. The innards of the 840D create the interpolation function based on the active member of the no. 1 G-code group that includes G01, G02/G03, etc.

The term simultaneous interpolation suggests a number of interpolations occuring at the same time and often in synchrony with one another. An example is helical interpolation. The path interpolation is a circle in X and Y and simultaneously, the rise is a Z-axis interpolation. The helix is the combination of these two separate interpolations. It should be clear that simultaneous in the term simultaneous interpolation to suggest a path interpolation of 2 or more axes is not the correct use of simultaneous.

The 840D also does simultaneous interpolation of the orientation. This is commanded with the no. 51 G-code group that includes linear interpolation of the orientation (default), great circle interpolation and conical interpolation.

Interpolation has its legacy in mechanical drawing with its straight edges, compasses, dividers, French curves, sweeps, etc. Sweeps are template-like devices that clay sculptors use to blend and finish surfaces.

For more about interpolation, see my next post on spline algorithms.

The NC Concept: Then & Now

2009-05-21T06:50:00.000-07:00

This post is a continuation of the discussion why NC matters.

In the previous post I discussed that Siemens CNC development seems to be on a path to a high level language that nonethelss carries forward tape code.

CNC also carries forward the NC Concept. The NC Concept is the separation of programming from operations. CNC allows the NC Concept to be implemented more conveniently.

The machine shops were populated with both NC and CNC machines when I first started doing by-the-numbers machining. I was assigned to an NC. The programmer would walk the tape from his office to the machine. He would be at the machine when I ran the tape for the first time. If there were errors in the program or corrections to be made he would walk back to his office, edit the source code, punch a new tape and walk the tape back to the machine. Today, with CNC, the tape has been supplanted with a computer file. The computer file is the program. The programmer can edit this program at the machine given that the CNC has a text editor for just this purpose.

Test editing of the program file at the machine is only part of the story that has a significant political-economic dimension. Political-economics refers to the relationships between groups of people who are formed when capital and labor come together to manufacture things (or services, but we are interesed in things). The NC Concept spawned the programmer who typically works in a front office and the operator who works at the machine. It renders the skilled manual machinist an occupation of the past.

The professors and graduate students of the Servo Mechanisms Laboratory of the Massachusetts Institute of Technology in Boston who invented numerical control as we know it today were obviously not machinists. They believed in the perfect servo platform to faithfully interpolate a path. They believed that the program could be written without error in the front office from data available in machining handbooks. They regarded the operator as a temporary necessity to change parts, adjust cooland and rake chips until he could be replaced with a robot. This is the NC Concept that they presented to industry.

With some exceptions, this original NC Concept fell apart in practice as anyone who does stock removal could have anticipated. Machining is complex. There are so many variables that even if one can anticipate them, it is impossible to know ahead of time how they will interact with one another. An operator who does not think like an engineer can lock up a complex system in seconds.

The original NC Concept can be regarded as an early attempt at artificial intelligence although the practicioners did not think of it this way. However, as the Concept was tested in the crucible of actual practice . . . to be continued.

Tape Code: Why NC Still Matters

2009-05-21T04:04:00.000-07:00

NC is still relevant in the discussion of CNC since CNC carried forward NC's tape code. Tape code is the familiar G-codes, XYZ coordiante words, M-codes, etc. An alternative to tape code is a high level language of spoken words, abriviations and mnemonics.

An example of a high level "G-code" is the preparatory function TRAORI. TRAORI stands for Transformation [for] Orientation and it would be turned on if you are doing 5-axis tool center point programming. Another example is the b-spline algorithm CompCAD that stands for Compress CAD [data]. These preparatory functions have near-no legacy in tape code.

The developers of the 840D assigned spoken words, abriviations and mnemonics to new preparatory function. Their goal is to evolve from tape code to a high level language, and to faciliate this, the Siemens developers allowed for macro substitutions.

A macro substitution is a character string that stands-in for another character string. For example, if the first active block of your Main Program File (MPF) is Define Rapid as G0, you have created a high level substitition for the tape code G0. You can use Rapid in place of G0 or G00 anywhere in the program. Rapid is called a macro substitution. For the record, there are other ways to create macro substitutions so they appear as global substitutions to be used in any program without having to be defined in the program.

Also, for the record, Siemens 840D macro substitution should not be confused with Fanuc's User Macro. Siemens equivalent to User Macro is an integral part of the 840D's workpiece programming language. It is in the box, ready to rock, when the control leaves the Siemens factory. There is no order number or extra cost for it. Thus, there is no formal name for it, and for lack of a name, Siemens CNC workers dub it Cycles Language.

Subroutine calls are another step in the evolution to a high level language. A subroutine can have a high level name like Drill_Gap_Drill. You call the subroutine by programming its name in a block of its own.

So, high level seems to be where CNC is going, at least Siemens CNC, but it is not leaving tape code behind. There is nothing wrong with tape code.

The tape reader was the best technology available to read-in blocks of the workpiece program when NC was fist publically demonstrated in 1952. Tape code is the equivalent of a phonic alphabet with its 24 symbols versus a symbol for every word like written Chinese appears to me. Tape code is compact. A code like G0 does not take up as much lineal space on the tape as a high level word like Rapid. Within the innards of the CNC, tape code has to be interpreted and prepared for execution.

In the era of CNC before the explosion of computer technology brought forth by the personal computer phenomenon, the technology that enabled CNC simply could not deal with a high level language and still have time to direct the cutting tool to interpolate a path. Tape code, with its relatively small alphabet of G, X, Y, Z, M, T, D, etc., was manageable. Today, of course, with our microprocessors and inexpensive solid state memory, the technological innards of CNC can handle a large vocabulary of high level commands and still have the ability to outrun the best mechanical axes that engineers can design for user expectations of every higher feedrates.

Tape code has traction today because CNC plays in the commercial world. A guy buys a machine and he wants to be able to run his old programs on it. He wants downward compatibility. In addition he wants the benefits of new technology. But legacy and modernity are contradictory. So, how a CNC vender transitions his users to modernity is dicey without loosing them but yet providing them with the technology for a competitive advantage over users who use a different vender's CNC. Fanuc, it seems, has chosen not to rise to this challenge. Siemens, in my opinion, has handled the contradiction skillfully.

Authors Get CNC Wrong

2009-05-19T05:50:00.000-07:00

CNC is numerically directed interpolation of a cutting tool in the work envelop of a machine. This definition would not be found in text books and handbooks. To illustrate this, I will pick on Mr. Peter Smid, author of "CNC Programming Handbook".

Mr. Smid writes that many descriptions have been put forth over the years that he summarizes as following: "Numerical Control can be defined as an operation of machine tools by the means of specifically coded instructions to the machine control system."

Note that this definition does not incorporate the idea of interpolation, nor by-the-numbers, nor the separation of programming from operations.

Coded instructions are tape code. If we had a high level workpiece programming language that allowed GOO to be programmed with Rapid, it would still be CNC.

Sophisticated path interpolation characterizes CNC. However, Mr. Smid does not explain interpolation. The word does not appear in the index of his book.

The history of NC/CNC challenges the idea that instructions (coded or high level) alone can operate the machine. If it could, why do we have a HMI (Human/Machine Interface) and machine operators?

Mr. Smid writes that it is pointless for him to come up with his own definition of numerical control since so many authors before him have tried. Unfortunately, most of the authors of the past got it wrong.

Mr. Smid writes a good book but it is not so good that he starts with a badly construed definition of CNC.

It doesn’t matter to most CNC workers, the definition of numerical control. They come into an already existing process and find their place somewhat spontaneously. However, CNC is complex and if you exercise that extra dimension of problem solving - both technical problems and the role of people in the CAD/CAM/PP/CNC process - you need an understanding of the concept of CNC as distinct from the mass of detail that enables it.

Why Do We Call it CNC?

2009-05-19T05:46:00.000-07:00

The M.I.T. professors and graduate students who invented numerical control in the late 1940's and early 1950's were drinking wine in their lab one Saturday evening when they decided to call it Numerical Control. If I had been there I would have argued for Numerically Directed Interpolation because this is what it does, it directs the cutting tool to interpolate points in the work envelop of the machine. Alas, I was not old enough to drink back then. However, I was old enough to connect the dots of a workbook to reveal a figure.

The CNC gets its "dots" from a program. The program, stripped to its bare essentials, is a list of rectangular coordinates of the points to be interpolated by the tool tip (or tool center point whichever you program). In the old days this list was encoded on punched paper tape and read-in into the CNC via a tape reader. This is why some people refer to the program as the tape. Today, of course, the program is a PC text file that we download or copy/insert to the CNC and select for execution.

We need the program before we can machine the workpiece, and to be sure, the classical CNC concept is for the program to be prepared by a programmer working in a front office.

The programmer does not operate the machine. This is done by the machine operator. This separation of programming from operations is what we mean by the NC Concept.

Whether we call it NC or CNC hardly matters today since computer circuits and software have supplanted the director of the original NC and this has been the case for decades. On the other hand, history plays an important role in the explanation of CNC. The latest and greatest of an earlier time is a stepping stone to the latest and greatest of today. In this regard NC as distinct from CNC still matters, notwithstanding a few ancient machines that are still in production.

It is not clear why the Professors and graduate students settled on the name Numerical Control. While their minds may have been addled by wine - I wasn't there to really know - they may have had their eyes on a larger and more universal concept of control mediated with digital means.

Beyond the Clovis Point: A Critic of the CNC Lexicon

2009-05-15T16:50:00.000-07:00

Ever since I started my machining career some 30 years ago I have been critical of the popular explanation of CNC . The words and terms of the CNC lexicon did not link to the technical sensibilities I had acquired in school. As a result, it took me a long time to integrate my considerable technical knowledge with the shop floor.

Today, a young person with a strong technical education will be in a similar situation because the popular explanation is still inadequate. Our contemporary authors of CNC books write pages and pages that look impressive until you start reading carefully and realizing there is not much content. Often their text is a jumble of familiar CNC words and terms as if their random juxtaposition can suggest meaning (and sometimes it can).

One of the major stumbling blocks in the explanation of CNC is the name "computer numerical control". Having written about CNC for over 30 years - mostly for my one-on-one work with colleagues and clients - I can attest to the fact that you have to throw out this name in order to get to the heart of the technology which is numerically directed interpolation of a cutting tool in the work envelop of a machine tool.

Historically, the machine tool industry has not been characterized by excellence in documentation partly because words cannot substitute for hands-on learning at the machine doing commercial production. However, CNC is heads-on as well as hands-on. With regards to heads-on, there are ideas one should have in ones head that are not acquired in practice to be prepared to do CNC at a higher level than simple button pushing and chip raking. Examples are the definition of interpolation and an understanding of servo.

I carried my critic of the popular explanation of CNC into my Siemens employment where I argued that as long as we use the popular words and terms of CNC we end up describing a Fanuc (and not describing it very well). Maybe this is why after all this time CNC is not so well understood and the 840D even less.

This failure of language is reflected in vendor manuals. Even the improved Siemens documentation has not risen to the challenge of the 840D. It is marginally comprehensible to engineers with exceptionally developed academic dicipline to read through typos and misstatements, who leverage years of experience, and in addition, have tens of thousands of dollar's of simulation equipment at their side or they get to play on the real thing. Of course, documentation is subordinate to marketing and sales. Really, customers do not evaluate documentation when making their purchasing decisions. Their decisions are driven by price for margins in the short run. To do adequate documentation, Siemens needs a different accounting model that values the long term investment in developing a cadre of technical writers, grounded in scientific engineering, who actually experience their subject matter in the crucible of real world commercial production.

As for me, I leveraged my Siemens employment to become a technical writer like some software developers leverage their dreadful and boring day job to do open source projects. Siemens neither notices nor hardly cares that I have recast the explanation of CNC so people can take knowledge to the machine to solve problems.

Unable to learn conclusively from the manuals, CNC workers spend large amounts of time fiddling and fussing to confirm lessons that well crafted documentation can teach in seconds. While hands-on is essential to learning, an excessive reliance on practice is an inefficient way to learn scientific technology.

After all, we are not doing arts and crafts. We are not striking Clovis points out of flint anymore.

----------------------------

My "ain't it all so bad" begs the question, how do we get anything done?

The answer is we can be successful with the flop method of learning, like a fish out of water, if it lives long enough and flops enough, it might get back in the water. Thus, our superficial knowledge is often good enough to get the job done. After all, we can tell time without knowing how the clock works.

But, wouldn't any machinist want to know the history of the escapement when he looks into the back of a mechanical clock? Who invented it? Who made all those gears? What tools were used? How did the clock maker feel to be crafting a miniature of the cosmos as it was known back in the latter Middle Age in Europe.?

Siemens develops and manufactures CNC in an area of Germany that was renown for its beautiful clocks. The area was also a manufacturer of armour for the famed knights in shinning armour.

Given that clock works were the innards of the automatic machinery of the Middle Age and metal cutting is the object of CNC's attention, I couldn't help but ask my German colleagues when I visited on business if we were meeting on the former site of a smelter making iron or a battery making sheet metal or an artisan's shop crafting clocks. This possibility touched a cord in me to make the connection between then and what I do now. It gives me a sense of place and purpose.

We are all better workers when we understand what we do beyond the superficial. We become problem solvers.

I contend that the productivity improvements in the next ten years will come primarily from workers understanding more deeply what they are doing. It will come from workers catching up with the technology proffered by the 840D.

I encourage you to use the Siemens documentation, for by all means, not every section of every manual is worthy of my scorn, and to tell the truth, I have tweaked the tale a bit. Also, often my posts are a clarification of the documentation although I do not say so directly.