Yes, the software (Candle) has user manual controls (jog Mode) and Gcode input field (vid below). Thus, can do it both ways and can write simple Gcode to automate it…
I use a Mac and found the Candle software for it (see the posted link to video). No doubt, Cande for Windows is mature, don’t know about Linux. But, can use other CNC control software, the stepper motor settings are posted many places on the net…
There seems to be quite a price difference between the “HOZLY” store on amazon and on Aliexpress.
I also have small CNC mill, built myself. I’ve looked at a lot of youtube vids of those cheap things, and also some bigger ones like the shapeoko and X-carve, and long ago I had some thoughts about buying such a machine, but then I decided the quality would not be sufficient and decided to build my own. For me, the absolute minimum are guides that have support over the full length. So no rods that are only supported at the ends. I built mine with SBR16 rails (Also round rods, but supported along their length).
If I were to buy a router, it would very likely be along the line of a Sorotec Compact Line:
BlackCoffe bought his machine as a toy, and that is exactly what I consider that level of machines. But I do acknowledge that toys can be fun to play with 
I have not milled PCB’s myself, but plan to do so at some time in the future. I will likely buy a bunch of the mills Blackcoffe recommended, at the moment my thinnest is 2mm.
@BlackCoffee Why do you run your tools at such low RPM? For tools of 1mm rpm should be 20k or more 40k rpm is also OK if your machine can handle it (Mine goes comfortably upto around 18k rpm.
I have not used Candle. I use GRBL (Now moved to GrblHAL on github) which runs on a microcontroller, and I use bCNC to send the code to the machine.
On my real mill, I run at 6500 rpm, but the CNOZ-3018-Pro has max of 1000 rpm, so, I adjust cutting parameters to those shown in previous post
Yes, not really bought as a Toy, bought mostly because I pointed some in the direction of this mill and figured I should try it myself. Sure, not as good a my real mill but, I’ve already made 10 PCB’s on it.
It does not use Rods for structure - look at the video
G-code is one of the oldest “programming languages” made, and it’s very simple, and yet powerful enough to still be used. It started in the “Late 1950ies”.
I mainly see it as a vehicle to get coordinates to a machine and it lacks a lot off features of modern languages, such as sensibly named variables, loops, real subroutines, etc. So I thought that I could better, and I wrote a library to be used with Python scripts that translates a Python program to G-Code.
And it works quite well. With it you can for example use the function "bhc( ), which stands for “bolt hole circle” and this generates a python list with coordinates for as many holes as you want on that circle, and you can use those coordinates to do “whatever your machine is capable off” on all those locations.
def bhc( xxx, yyy, radius, divisions, start_angle = 0, number_of_holes = None):
""" Return a list of points with centerpoints of a Bolt Hole Circle.
Each point in the list has: X, Y, Angle.
"""
points = [ ]
diff = 360 / divisions *pi/180 # Angular difference betwen points.
start_angle = start_angle * pi / 180
if type( number_of_holes) == int:
if number_of_holes < divisions:
divisions = number_of_holes
cnt = 0
while cnt < divisions:
angle = diff * cnt + start_angle
aaa = xxx + radius * cos( angle)
bbb = yyy + radius * sin( angle)
points.append( [ aaa, bbb, angle])
cnt += 1
return points
Of course it also has simple commands.
A lot of the simple commands are (almost) directly mapped to G-Code.
for example:
rpm( 4000)
emits the G-Code:
M03 S4000
For rapid movements I use:
rapid ( 34, 56)
Which translates to:
G0 X34 Y56
And for cutting I use:
cut ( 56, 78)
Which translates to:
G01 X56 Y78
Just as with G-code, when using coordinates in functions, you do not have to specify all coordinates.
for example:
cut ( zzz= -5)
cuts a hole to a depth of 5mm (“0” is usually used as the top of your work piece).
G-code can remember whether you use “mm” “inch” or other units, (It’s also just machine calibration).
But because movements in one direction are so common, I’ve also defined functions like “cutx()”, “cuty()” and “cutz()”.
If you’re curious and want to have a look at it, then get it here:
This is the library:
cnc.py (48.3 KB)
And here is a simple example program.
For a small project I neede some round wooden disk with a hole in the center and some pre-drilled holes for screws. The things were too simple to draw in a CAD program, generate the G-code etc, so it’s a perfect candidate for my little python lib.
in bCNC one of the disks look like:
The Python script using my library looks like:
from cnc import * # My own CNC lib thingie. Links to: /home/3TB_WD_Blue/projects/cnc/mimi/nc/cnc.py
from math import pi, sin, cos, tan
#=================================================================== Main( ).
init( "/home/paul/projects/cnc/000_AAA_Python.nc") # Default name for all progams?
comment("2021-02-26 Plier_Pot.")
# Holes for GND plate:
# Just some holes to screw these two plates together.
# (I only put Pz 3,5x16 screws in 4 of the 12 holes, the others are open.
Holes = bhc( 0, 0, 45, 12) # X, Y, Rad, n.
rpm( 18000)
feed( 800)
rapidz( 15)
# BHC for screws:
for hole in Holes:
rapid (hole[0], hole[1], 2)
drill( -7, 4, 5)
rapidz( 2)
# Inside hole and outside circumference for all (4x) round discs.
def go_disc():
cylinder( 0, 0, -7, 8.5, 4) # Inner hole, subtract mill radius.
rapidz( 2)
cylinder( 0, 0, -7, 54, 4) # Outside of round disc.
rapidz( 2)
go_disc( ) # Tab to make it a part of the function def, which "comments it out".
rapid( 0, 10, 15)
End_Of_Program( )
The output of my python program is just G-Code (with some comments) and is printed below.
Especially notes how a simple list from the bhc( ) function and a for loop generates 12 repetitions of 9 lines of G-Code (with different coordinates) for drilling the holes.
(/home/paul/projects/cnc/000_AAA_Python.nc)
G17 G21 G40 G49 G54 G90 G94 (End of init code.)
(2021-02-26 Plier_Pot.)
M03 S18000(rpm, cw.)
G04 P 375.0
F800
G0 Z15
G0 X45.0 Y0.0 Z2
(Drill_a: depth -7 peck_start 4 peck 5)
G01 Z-2
G04 P 0.1
G0 Z0
G0 Z-1.9
G01 Z-7
G04 P 0.1
G0 Z3
G0 Z2
G0 X38.971 Y22.5 Z2
(Drill_a: depth -7 peck_start 4 peck 5)
G01 Z-2
G04 P 0.1
G0 Z0
G0 Z-1.9
G01 Z-7
G04 P 0.1
G0 Z3
G0 Z2
G0 X22.5 Y38.971 Z2
(Drill_a: depth -7 peck_start 4 peck 5)
G01 Z-2
G04 P 0.1
G0 Z0
G0 Z-1.9
G01 Z-7
G04 P 0.1
G0 Z3
G0 Z2
G0 X0.0 Y45.0 Z2
(Drill_a: depth -7 peck_start 4 peck 5)
G01 Z-2
G04 P 0.1
G0 Z0
G0 Z-1.9
G01 Z-7
G04 P 0.1
G0 Z3
G0 Z2
G0 X-22.5 Y38.971 Z2
(Drill_a: depth -7 peck_start 4 peck 5)
G01 Z-2
G04 P 0.1
G0 Z0
G0 Z-1.9
G01 Z-7
G04 P 0.1
G0 Z3
G0 Z2
G0 X-38.971 Y22.5 Z2
(Drill_a: depth -7 peck_start 4 peck 5)
G01 Z-2
G04 P 0.1
G0 Z0
G0 Z-1.9
G01 Z-7
G04 P 0.1
G0 Z3
G0 Z2
G0 X-45.0 Y0.0 Z2
(Drill_a: depth -7 peck_start 4 peck 5)
G01 Z-2
G04 P 0.1
G0 Z0
G0 Z-1.9
G01 Z-7
G04 P 0.1
G0 Z3
G0 Z2
G0 X-38.971 Y-22.5 Z2
(Drill_a: depth -7 peck_start 4 peck 5)
G01 Z-2
G04 P 0.1
G0 Z0
G0 Z-1.9
G01 Z-7
G04 P 0.1
G0 Z3
G0 Z2
G0 X-22.5 Y-38.971 Z2
(Drill_a: depth -7 peck_start 4 peck 5)
G01 Z-2
G04 P 0.1
G0 Z0
G0 Z-1.9
G01 Z-7
G04 P 0.1
G0 Z3
G0 Z2
G0 X-0.0 Y-45.0 Z2
(Drill_a: depth -7 peck_start 4 peck 5)
G01 Z-2
G04 P 0.1
G0 Z0
G0 Z-1.9
G01 Z-7
G04 P 0.1
G0 Z3
G0 Z2
G0 X22.5 Y-38.971 Z2
(Drill_a: depth -7 peck_start 4 peck 5)
G01 Z-2
G04 P 0.1
G0 Z0
G0 Z-1.9
G01 Z-7
G04 P 0.1
G0 Z3
G0 Z2
G0 X38.971 Y-22.5 Z2
(Drill_a: depth -7 peck_start 4 peck 5)
G01 Z-2
G04 P 0.1
G0 Z0
G0 Z-1.9
G01 Z-7
G04 P 0.1
G0 Z3
G0 Z2
G0 X-8.5 Y0
G0 Z1
(Cylinder X0 Y0 Z-7 rad: 8.5 step: 4)
G02 X-8.5 Y0 Z-2 I8.5 J0
G02 X-8.5 Y0 Z-6 I8.5 J0
G02 X-8.5 Y0 Z-7 I8.5 J0
G02 X-8.5 Y0 Z-7 I8.5 J0
G0 Z2
G0 X-54 Y0
G0 Z1
(Cylinder X0 Y0 Z-7 rad: 54 step: 4)
G02 X-54 Y0 Z-2 I54 J0
G02 X-54 Y0 Z-6 I54 J0
G02 X-54 Y0 Z-7 I54 J0
G02 X-54 Y0 Z-7 I54 J0
G0 Z2
G0 X0 Y10 Z15
( End of Program: cleanup )
M05 ( Spindle off )
M30 ( End of program.)
The init (and exit) code normally appended to a G-code program are defined inside my cnc.py library.
I was not very familiar with G-code and I have also just a bit experience whith Python. So when I started this project, it was also a learning and I wrote lots of comments.
The whole thing also started as just an experiment, and I did not know what I wanted this language to do, so there may be some strange things in it. But it’s Python, and easy to adjust to your personal liking.
Have fun.
Personally, I don’t like Carbide bits this small as they seem to break too often. The Titanium coated bits do a better job (for me) on PCB’s.
Carbide might do well on metal but, I have a CNC mill in garage for that kind of work…
The bits that I use for milling out PCBs is one of these:
https://www.aliexpress.com/item/4000217275018.html?aff_fcid=ee6648e5f2064619a7a6e130e01edca0-1615325346169-05369-_sSETun&aff_fsk=_sSETun&aff_platform=link-c-tool&aff_trace_key=ee6648e5f2064619a7a6e130e01edca0-1615325346169-05369-_sSETun&tmLog=new_Detail
I did look (again).
@00:30 these are the rods I mean.
Those shiny steel rods (probably 16mm) are not stiff at all and bend far to easily because they are only supported at the ends.
I have used the TBR16 rails, which are supported over the whole length, and therefore they transmit the forces to the frame itself, which makes the whole machine a lot more ridgit. “My next machine” will have the square type of rails, just like the Sorotec I linked to earlier.
This topic was automatically closed 90 days after the last reply. New replies are no longer allowed.
