Generating G Code from MDI history log

Hi,

If like me, you spent a long time using manual mills and lathes before going to CNC, your work practices probably reflect this.

I tend to make simple parts just using MDI. Commands replacing hand wheel movements.
This is often far more time effective than writing a program.

The effectiveness reduces when you have to repeat sequences.
For instance recently, when drilling and tapping a series of unequally spaced holes,
first using centre drill, then first diameter drill bit, then second diameter bit then finally tapping clearance bit.
This does not easily lend itself to a G81 cycle.

I wrote this script to generate a program for the successive drilling stages from the commands I had entered for the first stage. You could do the same cutting and pasting directly from the MDI history, but this saves a lot of time.

To use, prior to commencement clear the MDI history (Ctrl M)
Then just enter the commands necessary for the first run through.

Then in a terminal, $ mdi2ngc /path/filename.ngc which will produce a .ngc file

If necessary edit the file to change values
(For instance I changed all lines G01 Z-5 F12 for G01 Z-20 F12 after centre drilling, so that the drill now broke through)
Then load the file and continue.

Does not do anything new, just makes life easier, adapt and enjoy.

Hi John

Yeah it could be a good way of doing it.

This job was making a reinforcing plate for an existing part, with hole centres transfer punched through.
I had to visually align a 60 degree centre with each centre pop to get the co-ordinates exact.

If there had not been so many holes, I could have just 'touched off' each hole in a different co-ordinate system as I have done in the past, which makes things ridiculously easy to code eg.
G54 G0 X0 YO
DRILL
G55 G0 X0 Y0
DRILL
G56 G0 X0 Y0
DRILL
..etc etc

I like 'one offs' , but they are real time consumers.

regards

An example of how to do something similar with axis, ngcgui, and a simple subroutine:

0) specify a subroutine in the ini file or load it from a "Custom"
tab (example attached for position.ngc)

1) Navigate to the position subroutine tab page and
enter "howmany" positions, and other routine entry values

2) Jog to the first position (having a pendant is useful)

3) On the "position" tab page:
put keyboard cursor in the x1 entry box
type "x" (enters current x position)
tab to y1 entry box
type ":y" (enters current y position)

(note: typing x,y,z,a,b,c,d enters the current coordinate value,
d means 2*x=current_diameter (eg for a lathe))

repeat 2) and 3) for remaining positions x2,y2, etc.

4) "Create Feature"

5) repeat 2-4 for additional features if needed

6a) "Finalize"
run the generated program

OR

6b) type Ctrl-a (toggle autosend)
"MakeFile"
save file with a unique name in a location of your choice to run later

The generated program will move to each position and pause (m0) I use this with a quill to manually drill holes at the positions.

With simple modifications, you could modify the subroutine to do anything else instead of pausing, like calling another subroutine.

oops, attached is the correct file for position.ngc

Notes, as written:
1) requires linuxcnc2.5
2) uses nc_files/ngcgui_lib/utilitysubs/move.ngcjj
3) uses nc_files/ngcgui_lib/mfiles/M110
4) scaling and rotating the points about the origin are simple modifications

Nice one Dewey,

The #<x1> = #<_move:x> threw me at first until I realised that #<_move:x> was a global declared in move.ngc and not a referencing notation I was unaware of !!

I think you might have prompted a 'build a better mousetrap' competition.
I'll have to give this some serious thought.

regards

An example of how to do something similar with axis, ngcgui, and a simple subroutine:

O.K. Dewey that is cool, everytime I turn around that ngcgui makes things faster and easier!
I will try that this weekend.
Thanks for sharing.

Rick G

"The #<x1> = #<_move:x> threw me at first until I realised that #<_move:x> was a global declared in move.ngc and not a referencing notation I was unaware of !!"

Yes, the general pattern for returning values from subroutines called by ngcgui subfiles is to return them as globals with a colon somewhere in the name. It is convenient to format the names as:

#<_nameofsubroutine:item_value>

as in:

#<_move:x>

It is good practice to immediately localize the return value, as in:
#<x1>=#<_move:x>

The only way to return multiple items from a subroutine is with globals. (I think the git-master version supports a return statement that can return a single item).

Using the colon in the name is important, it prevents ngcgui from interpreting the variable as a user input -- using globals as inputs to ngcgui is deprecated.