LatheEasyStep – experimental QtVCP macro for step-by-step lathe programming

this looks awesome

and yes i agree its massively missing in linuxcnc

i have been trying for ages to get native cam running and can't

i find on semiens and fagor controls i use the contour cycle about 90 percent of the time

everything else like facing and shamfers etc i don't use as i can just do it in the contour cycle.

and of course threading is usefull

though the built in threading cycles are not too bad for that

cheers

Andrew

Hi all,
here is a short update on the latest changes in LatheEasyStep:

Step list loading issue fixed
In some embedded QtVCP scenarios, the operation list stayed empty after loading a single step or a full program. The operation list binding is now more robust.

Safer retract/free-travel logic (lathe-specific)
Retracts are now context-aware per operation:

simultaneous X/Z where safe
groove/keyway: retract X out of material first, then Z
drilling/threading: retract Z clear first, then X
Current tool position relative to stock/chuck is now considered.
Extended chuck / no-go safety model
The program header now supports chuck-related parameters (size, workpiece type, clamping mode, profile) with automatic no-go zone calculation.

New machine/workshop profiles
Quick presets apply typical parameter combinations automatically (e.g. chuck + clamping mode + profile).

Preview improvements
The chuck safety area is now shown in the preview as a dedicated colored zone, including a legend entry.

Save/load extended
New header fields (chuck/profile/no-go/machine profile) are now properly persisted and restored.

As a bit of background on the chuck/no-go safety model:At work I requested a machine with a control that includes an integrated safety zone around the chuck (something I had seen on Heidenhain controls).
In the end, I was assigned a lathe with a Siemens control, and I’ve been very satisfied with it — it works well in practice and I can program effectively on it.However, the concept of having the chuck geometry considered in the motion/safety logic stayed in the back of my mind.
Since that idea seemed useful for safe at-the-machine programming, it eventually found its way into LatheEasyStep’s design.

Hi all,

another short update on LatheEasyStep:

I continued working on the embedded QtVCP startup behavior and focused on the panel initialization path.

On my machine, the startup time with the panel embedded in LinuxCNC was reduced from about 49 seconds down to about 11 seconds.

The main work was cleaning up the widget lookup/initialization path, removing expensive startup overhead, and limiting panel-related searches strictly to the panel itself instead of doing broader lookups.

The panel is now usable again immediately after startup on my system, which is a big improvement compared to the previous state.

I will continue cleaning up the code step by step, but this was an important milestone because the panel is now much more practical to use in everyday work.

Regards

Thanks for the update! We'd love to see how things are looking now. Maybe you could share a short video or a screen recording someday.

all the best

tom
 

Hello everyone,I wanted to give a small update on the current state of Lathe EasyStep.A lot has changed internally since my last post. While the panel may look similar at first glance, a large part of the project has been refactored and modularized. The original large Python files have been split into many smaller modules (G-code generation, preview, contour handling, persistence, tool logic, UI, etc.), making the codebase much easier to maintain and extend.At this point I consider the project to be at Version 0.7.0.Development is still ongoing, but over the last weeks the focus has been less on adding new features and more on improving the internal architecture, modularizing the code and refining the overall workflow. The goal was to build a solid foundation that will make future development easier and improve long-term maintainability.General workflowThe user interface is intentionally based on the workflow of conversational turning systems. Anyone who has worked with ShopTurn or similar conversational programming systems should feel familiar with the basic workflow.The Program tab is where all global settings are defined, for example:

• stock dimensions
• safety distances
• retract positions
• tool change and safety settings
• other program-wide parameters

After that, machining operations are created step by step using the corresponding tabs.Reusable machining stepsOne feature that was important to me is the ability to reuse operations.Every machining operation is stored as an individual Step file containing all parameters of that operation.For example, if I create a facing operation for 30 mm stock, I can later reuse exactly the same operation in another program without entering all parameters again.Over time this creates a small library of frequently used machining operations."Save Changes"A new Save Changes button has also been added.Instead of recreating programs from scratch, existing projects can now be edited and updated.Depending on what already exists, the application automatically updates

• the individual Step files,
• the complete program,
• and any previously generated G-code.

The graphical preview is rebuilt automatically as well.PreviewThe preview system has been improved considerably.Besides the existing side view, there is now an optional cross-section view. The section position can simply be moved with the mouse inside the side view, making it easy to inspect the generated geometry at any Z position.ContoursContours are created by entering coordinates, with the option to use either absolute or incremental values.Each contour receives its own name and can later be reused in any number of roughing operations.Inside the Roughing tab, the desired contour is selected, a tool is assigned and the remaining machining parameters are configured.Available operationsThe project currently supports, among others:

• Facing (roughing, finishing or both)
• Roughing using user-defined contours
• Thread cutting
• Grooving / Parting
• Drilling with different drilling strategies
• Keyway shaping (currently experimental)

Several common thread presets are already included, but all parameters can be modified as required.For parting operations it is also possible to define the X position where feed and spindle speed should be reduced, helping to make the final separation more controlled.Keyway shaping is currently still experimental. The preview already works, but I have not yet been able to validate it on a real machine.What's next?My next focus will most likely be the G-code generation itself. I am sure there is still room for improvements and additional machining strategies.Up to now, development has naturally been influenced by my own way of programming parts. This is exactly where feedback from other users would be very valuable.I'm especially interested in how other machinists or LinuxCNC users would approach certain operations. There is often more than one valid way to generate the same toolpath, and in some cases there may even be a better solution than the one I currently use.Constructive criticism, ideas and suggestions are always welcome.My own lathe is unfortunately still not fully assembled, so I have not yet been able to validate every feature on a real machine. That makes feedback from other LinuxCNC users even more valuable, especially from people who are willing to try the panel and share their experiences.I also hope to create a short video or a small series of screenshots soon, as I think the workflow is much easier to understand visually than from static images alone.

Quick development update

Over the past few weeks I've mainly been working on two areas that weren't reliable yet: internal machining and automatic thread reliefs.

Fixed internal roughing: The internal roughing cycle was in some cases producing a single, way-too-coarse cut instead of properly staged passes ("not really a cutting strategy"). Found the root cause and fixed it – now it produces even, multi-pass stepping just like external turning does.
Reworked DIN 76 thread reliefs: Previously only a simple rectangular pocket was generated. Now the actual DIN 76 profile is output (30° lead-in, tangential arcs, relief bottom, shoulder radius), using real values from the DIN 76-1 table instead of estimated widths. The relief is now correctly anchored to the end of the thread (not the end of the contour), and it now also works in the middle of a longer contour, not just at the very start or end.
Safer internal approach moves: When feeding into a bore, the tool now always moves axially to the clear retract plane first and only then feeds in radially – no more diagonal rapid moves straight through the bore.
Also fixed a few real LinuxCNC crashes along the way (e.g. tool nose compensation at the inside relief corner, a "Not monotonic" error with G71/G72 when a relief is spliced into the contour).
Important: All of this is currently only on the dev branch, not yet in the stable release. Not everything has been verified with a real dry run on the machine yet, but preview and generated code now look correct for the cases tested so far. As always: feedback, test cases, and criticism are welcome.