By William Kane | Manufacturing with Light (MWL)
When people start discussing a new laser cutting system, the conversation usually starts with the laser.
How much power do we need? Fiber or ultrafast? What wavelength? What spot size? What material thickness?
Those are important questions and should be worked out in an applications lab before anything else, but one thing I have learned over the years is that the laser source is only one part of the machine.
A great laser on a poorly designed motion system can still make bad parts. The same is true if the motion is excellent but laser timing is inconsistent, the operator interface is confusing, the CAM system is difficult to use, or the utilities and safety systems are treated as something to add later.
I tend to look at a laser cutting machine as a complete manufacturing system:
Motion + laser control + CAM + part programming + HMI + utilities + safety.
Here are some of the questions I think management should be asking before that new machine is designed or purchased.
“How fast does the machine really need to be?”
Maximum axis speed is one of the easiest specifications to put on a brochure.
It is not always the specification that determines production rate.
If we are making a long straight cut, the machine may have plenty of distance to accelerate to full speed. But many medical, electronics, and precision components contain small slots, holes, circles, corners, and repeating features.
On those parts, the machine may spend most of its time accelerating, decelerating, and changing direction.
That means feature size needs to be part of the motion-system sizing exercise.
A stage capable of an impressive top speed may never reach that speed while cutting a 0.5 mm feature.
For small features, I am often more interested in:
- acceleration capability,
- jerk capability,
- moving mass,
- mechanical stiffness,
- servo response,
- settling behavior,
- and how smoothly the controller transitions between path segments.
This is why I prefer sizing a machine using representative part geometry instead of simply asking, “How fast can the stage move?”
Give the controls engineer the smallest features, expected feed rates, moving mass, required tolerances, and cycle-time goals.
That gives us something meaningful to design around.
“If each axis is accurate, why does tuning matter so much?”
Because position accuracy and coordinated path accuracy are not the same thing.
An X axis can position very accurately by itself.
A Y axis can do the same.
But when we laser cut a circle, slot, or complicated contour, those axes have to move together.
If one axis responds slightly differently from the other, the result can be:
- an oval instead of a circle,
- rounded corners,
- wider slots,
- dimensional errors,
- or inconsistent kerf around the feature.
The faster we move, the more important this becomes.
Good mechanical design comes first. After that, the servo loops need to be properly tuned. That includes the normal position and velocity loops, appropriate feedforward, realistic acceleration and jerk, and attention to mechanical resonances.
Advanced algorithms can then help us go further.
ACS ServoBoost, for example, is designed to improve servo performance and disturbance rejection in precision motion systems [1]. But I would not use an advanced algorithm as a substitute for getting the basic machine right.
My rule is simple:
Tune the machine first. Then use the advanced tools to improve an already good system.
“What are algorithms like SmoothPath and ServoBoost actually doing for us?”
This is where modern motion control can make a noticeable difference.
A CAM system may generate a complex contour as hundreds or thousands of small line segments. If the controller simply treats each segment independently, those transitions can create velocity changes, vibration, and following error.
ACS SmoothPath is designed to create smooth coordinated contour motion from paths like these. It can be programmed through ACSPL+ or G-code and is specifically intended to reduce disturbances caused by discontinuities in CAD/CAM-generated paths [2].
SmoothPath improves the trajectory we are asking the machine to follow.
ServoBoost improves the ability of the servo system to follow that trajectory.
Those are two different problems.
Used properly, advanced trajectory generation and advanced servo control can help improve both part quality and throughput.
“How much encoder resolution do we need?”
That depends heavily on the application.
I would not specify the same feedback system for a general sheet-metal cutter that I would for a system making medical hypotubes, stents, or other micro-scale components.
One thing that is easy to forget is that encoder resolution is not the same thing as machine accuracy.
High encoder resolution does not automatically make a machine accurate. But the servo system cannot correct motion that it cannot measure. For very small features, I normally want the feedback resolution comfortably below the smallest motion or dimensional variation that matters to the process.
On linear stages, direct linear encoders can also be valuable because they measure the actual stage position rather than inferring it through a motor encoder and mechanical transmission.
Rotary tube cutting requires another level of thinking. For a rotary axis, I do not just want to know encoder counts per revolution. I want to know:
What does one encoder count represent at the surface of the tube?
The same angular resolution produces different linear displacement on a 1 mm tube than it does on a 10 mm tube. That is the number that matters to the cut.
“Why do we need G-code? Couldn’t the software just command the axes directly?”
It certainly could. But I have become a strong believer in keeping a CNC-style part-programming layer in machines that manufacture different parts.
G-code gives us a relatively simple, readable file describing the part process. The geometry, feed rates, lead-ins, process commands, laser commands, gas selections, and other part-specific information can travel with the part program instead of being buried inside the HMI application.
That gives us several benefits.
- A new part does not require rewriting the machine-control software.
- Programs can be generated offline.
- A technician can open the file and generally understand what the machine is trying to do.
- And most importantly, CAM software already understands how to generate this type of information.
ACS’s G-code support is particularly useful because it allows standard G- and M-code functionality to be combined with ACSPL+ machine programming. Machine builders can also create their own G- and M-codes for application-specific functions such as laser setup or other process controls [3].
To me, the right answer is not G-code or machine programming. It is G-code plus machine programming.
“Why do we need CAM software if we already have G-code?”
Because we do not want somebody manually programming thousands of small laser features. Writing a few lines of G-code by hand is useful during development. Production is different. That is where a laser-oriented CAM system becomes important.
CAGILA, for example, is specifically designed for laser, waterjet, and plasma CNC programming and includes CAD preparation, process sequencing, lead functions, CNC post-processing, simulation, and capabilities for both macro and micro processing [4].
The important point for management is that the CAM system and motion controller have different jobs.
CAM decides what path we want to cut. The motion controller determines how accurately and smoothly the physical machine follows that path.
Good CAM cannot fix a badly tuned machine. And the motion controller should not have to replace a capable CAM package.
“How tightly does the laser need to be connected to the motion?”
For simple applications, a digital output may be enough. Turn the laser on. Make the move. Turn the laser off.
But as features become smaller and speeds increase, we want the laser much more tightly synchronized with the trajectory.
Consider pulsed cutting. If the laser fires at a fixed frequency while the machine slows for a corner, the pulses get physically closer together on the material. Now we are putting more energy into a smaller area exactly where the machine is changing direction. That can affect kerf, heat input, edge quality, and consistency.
One way to deal with this is to synchronize laser pulses to distance traveled rather than simply elapsed time. The ACS Laser Control Interface, or LCI, is built around this type of integration. It supports position-based triggering, segment-based gating, fixed-distance pulsing, and velocity-dependent laser power control while coordinating with multi-axis motion [5].
That is a much different architecture than hoping a PLC output changes state at approximately the correct time. For demanding laser processing, I want motion and laser control designed together from the beginning.
“Do operators really need all these controls on the screen?”
No. And I think this is an area where engineers sometimes make machines harder to use than they need to be. The engineering team needs access to almost everything:
- servo parameters
- axis diagnostics
- scopes
- EtherCAT status
- laser setup
- G-code editing
- process variables
- calibration tools
- manual motion
- I/O, and troubleshooting information.
The production operator normally does not. A production operator usually needs answers to much simpler questions:
- Is the machine ready?
- What job is loaded?
- Is the correct program selected?
- Are the laser, gas, cooling water, air, extraction, motion system, and safety system ready?
- How many parts have been completed?
- Is there an alarm?
- Can I start, pause, stop, or recover the machine?
That can be a very simple screen. In some production environments, I think the best solution is actually two HMIs. The production HMI is intentionally simple. Large buttons. Clear machine status. Clear alarms. Part count. Current program. Maybe the current G-code block. Very little opportunity for an operator to accidentally change machine configuration.
The engineering interface is different. It is available only to technicians and engineers and contains the programming, tuning, configuration, diagnostic, and service tools needed to maintain the machine.
ACS supports host-side application development around SPiiPlus controllers, including .NET-based applications, so a custom production interface can be built separately from the full engineering environment [6].
That separation can make operator training much easier while still giving engineering the tools they need.
“What support systems do we need besides the laser?”
Quite a few.
A laser cutter is not just a laser and a motion stage. Depending on the process, we may also need:
- assist or process gas,
- pressure and flow regulation,
- cooling water,
- clean dry compressed air,
- fume extraction,
- filtration,
- optics and focus control,
- nozzle management,
- workholding,
- electrical distribution,
- machine I/O,
- part handling,
- vision,
- process monitoring,
- and sometimes water flowing through or around the workpiece.
These are not secondary details. They can directly affect the cut. If assist-gas pressure changes, the cut can change. If cooling-water temperature changes, the laser or optics may behave differently. If the air is contaminated, optics and mechanical components may suffer. If extraction is poor, contamination can accumulate inside the enclosure.
One lesson I have learned is that these systems should be included in the process specification from the beginning rather than appearing later on a miscellaneous-utilities list.
“Where does safety fit?”
At the beginning. Not during final commissioning. A laser cutting system needs a properly engineered safety architecture covering both the laser hazards and the normal hazards of machinery.
That can include the enclosure, doors and access panels, interlocks, emergency stops, beam containment, laser inhibit circuits, motion hazards, electrical hazards, compressed gas, pneumatics, cooling failures, fume extraction, maintenance access, and service modes.
The FDA notes that laser risk increases with laser classification and that the risks of laser exposure have to be managed [7]. OSHA also identifies engineering controls, restricted access, beam control, and appropriate protective measures as important parts of controlling workplace laser hazards [8].
There is also an important controls distinction: Process control is not safety control. A motion controller or laser interface may have commands that stop laser output. That does not automatically make those functions the machine’s safety system.
The safety system needs to come from a risk assessment and a properly engineered safety architecture. I also want as much commissioning as possible done with the actual beam disabled. We should prove the motion, laser timing signals, interlocks, I/O, part program, dry-run behavior, and recovery sequences before we start cutting material.
(U.S. Food and Drug Administration)
“So what are we really buying?”
Not a laser.
Not a motion controller.
Not CAM software.
Not an HMI.
We are building a laser manufacturing platform.
The motion system should be sized around the real parts and especially the smallest features. The feedback system should have resolution appropriate for the application. The servo system should be tuned for coordinated path accuracy, not simply point-to-point positioning.
Advanced motion algorithms such as SmoothPath and ServoBoost should be considered when the process benefits from them. The laser should be tightly synchronized with the trajectory when feature size and process consistency require it.
G-code should provide a practical part-programming layer, while a CAM package such as CAGILA generates those production programs from the CAD data.
Operators should have a simple interface designed around making parts.
Engineers and technicians should have a separate interface designed around programming, tuning, setup, and troubleshooting.
The gas, water, air, extraction, optics, workholding, and other support systems should all be engineered as part of the process.
And most importantly, the safety system needs to be designed as a system of its own.
After working around motion-control and laser systems for many years, that may be the biggest lesson I have taken away:
Good laser cutting does not come from one great component. It comes from getting a lot of systems to work together exceptionally well.
That is the conversation I would want engineers having before the purchase orders are written.
References
[1] ACS Motion Control — ServoBoost Advanced servo-control technology for improving tracking, settling, stability, and disturbance rejection. ACS ServoBoost
[2] ACS Motion Control — SmoothPath Advanced coordinated contour-motion generation for CAD/CAM-generated paths. ACS SmoothPath
[3] ACS Motion Control — G-Code Programming / GSP G-code support for laser processing, including custom G/M codes, ACSPL+ integration, XSEG, and SmoothPath. ACS G-Code Programming ACS SPiiPlus GSP Reference Guide
[4] CAM-Service GmbH — CAGILA CAM System CAD/CAM and CNC programming software for laser cutting and related processes. CAGILA CAM System
[5] ACS Motion Control — Laser Control Interface (LCI) Position-, velocity-, and motion-synchronized laser triggering and power control. ACS Laser Control Interface
[6] ACS Motion Control — ACSPL+ Programming and Host Libraries Overview of ACSPL+ and host-programming interfaces for SPiiPlus systems. ACSPL+ Programming Language
[7] U.S. Food and Drug Administration — Laser Products and Instruments Laser classifications and general laser-product safety information. FDA Laser Products and Instruments
[8] Occupational Safety and Health Administration — Laser Hazards Workplace laser-hazard recognition and control information. OSHA Laser Hazards