Hi, Ive just been looking at the questions above and notice someone may have gear chart for screw cutting imperial & metric. Any chance you could send it to me or point me in the right direction. Thanks Ste

"Stephen Dixon" wrote in message
...
Hi, I've just been looking at the questions above and notice someone
may have gear chart for screw cutting imperial & metric. Any chance
you could send it to me or point me in the right direction. Thanks Ste

=========================================
http://www.lathes.co.uk/zyto/

You can figure out the gearing and make your own chart, as I did using
a spreadsheet which computes compound gear ratios and inch pitch to
metric modulus conversions, and provides many formatting options for
the chart printout.

The key is the pitch of the leadscrew. When the spindle and leadscrew
are geared 1:1 the lathe will duplicate the leadscrew pitch. For other
pitches the gear reduction (or increase) ratio equals the leadscrew to
desired pitch ratio, for example to cut 32 TPI with an 8 TPI leadscrew
the gear ratio is 1:4, such as 16 and 64 tooth gears, or 20 and 80, or
whatever you have that fits. 13 TPI would require 8x4=32 teeth at
spindle speed and 13x4=52 teeth at leadscrew speed. The leadscrew
turns and advances slower to cut finer pitches. British thread pitches
are mostly the same as US ones.

Lathe change gears traditionally used the 14-1/2 degree tooth pressure
angle which made the teeth easier to lay out by hand on a wooden
casting pattern, as the sine of that angle is 1/4. Modern power
transmission gears commonly have a stronger 20 degree pressure angle
and don't mesh correctly with 14-1/2 degree "change" gears.
https://www.bostongear.com/products/...s/change-gears

The inch-to-metric conversion is a fraction with 127 as the
denominator, corresponding to a 127 tooth gear, because 1.00000 inch =
25.40000 mm.

jsw

On Mon, 02 Mar 2020 12:26:59 -0800, Stephen Dixon wrote:

Hi, Ive just been looking at the questions above and notice someone may
have gear chart for screw cutting imperial & metric. Any chance you
could send it to me or point me in the right direction. Thanks Ste

As Jim Wilkins mentioned, you can make a spreadsheet. Or, look online
for program CHANGE by Marvin Klotz, and adaptations of it by others, eg
David Forsyth. It is worth looking those up so you can read Marvin's
comments about driving and driven gears, putting gears on banjo, etc.

Eg: "Sets of gears need only be placed with 'drivers' driving and driven
gears being driven. The actual order is not important, just select
pairs so that they fit on the banjo. So long as the correct ones are
driving, the ratio will be correct. Always cross check by threading
(just a surface scratch is needed) some scrap and measuring the pitch
if at all possible."

In pictures of Tyzack lathes, it looks like some models have four
change gears for setting the reduction ratio, so the program mentioned
above is applicable. Below is a somewhat simpler program, written in
Python 3. It accepts either an inch thread count or a metric thread
pitch (in micrometers), with numbers below 150 considered tpi and 150
or more as um. For example, the command ./gearset.py 1000
looks for gear sets to make a 1 mm pitch (1000 um) and after a few
milliseconds prints out:

Target is 25.4 tpi = 0.0394" = 1.0 mm
tpi: 25.422 = 0.9991 mm ABCD: 45 55 50 65
tpi: 25.455 = 0.9979 mm ABCD: 20 35 55 50
tpi: 25.333 = 1.0026 mm ABCD: 40 50 45 57
tpi: 25.319 = 1.0032 mm ABCD: 35 45 65 80

From that output, you would pick out which set you like best (or have).
You can modify the gears list in the second line of the program
to match whatever set of gears you actually have. The list there is
similar to the set that comes with mini-lathes from HF etc. (Note,
to look at the program, turn off line wrapping in your newsreader, or
in an editor remove extra line wraps and restore any that are missing.
Python syntax is sensitive to leading spaces.)

#!/usr/bin/env python3
gears = sorted([20,20,35,40,45,50,55,57,60,65,80,80])
from sys import argv; from itertools import combinations
rn = 0; pre = (-1,-1); candi = []
# Metric thread pitch gets entered times 1000, eg 500 means 0.5 mm
rn+=1; tpi = float(argv[rn]) if len(argv)rn else 16 # Desired threads
per inch
rn+=1; eps = float(argv[rn]) if len(argv)rn else 1 # Allowed error in
%
rn+=1; Lead = float(argv[rn]) if len(argv)rn else 16 # Effective Lead
Screw ratio
target = tpi if tpi150 else 25400/tpi
ftpi, itpi, mtpm = round(target,4), round(1/target,4), round(25.4/target,
4)
print (f'Target is {ftpi} tpi = {itpi}" = {mtpm} mm')
errmax = target*eps/100 # Convert % error to tpi error
for gdex in combinations(range(len(gears)),4):
gset = [gears[x] for x in gdex]
for b, d in combinations(gset,2):
b, d = min(b,d), max(b,d)
gtwo = gset[0:]; gtwo.remove(b); gtwo.remove(d)
a, c = gtwo; a, c = min(a,c), max(a,c)
t = Lead*(b/a)*(d/c); err = abs(t-target)
if errerrmax: candi.append((err, t, a,b,c,d))
for item in sorted(candi): # Remove duplicate candidates
if item==p candi.remove(item)
pre = item
for err,t,a,b,c,d in sorted(candi)[:4]: # Print best 4 candidates, if
any
print (f' tpi: {t:0.3f} = {25.4/t:0.4f} mm ABCD: {a:3} {b:3} {c:3}
{d:3}')



--
jiw

"James Waldby" wrote in message
...
On Mon, 02 Mar 2020 12:26:59 -0800, Stephen Dixon wrote:

Hi, I've just been looking at the questions above and notice
someone may
have gear chart for screw cutting imperial & metric. Any chance you
could send it to me or point me in the right direction. Thanks Ste

As Jim Wilkins mentioned, you can make a spreadsheet. Or, look
online
for program CHANGE by Marvin Klotz, and adaptations of it by others,
eg
David Forsyth. It is worth looking those up so you can read
Marvin's
comments about driving and driven gears, putting gears on banjo,
etc.

Eg: "Sets of gears need only be placed with 'drivers' driving and
driven
gears being driven. The actual order is not important, just select
pairs so that they fit on the banjo. So long as the correct ones are
driving, the ratio will be correct. Always cross check by threading
(just a surface scratch is needed) some scrap and measuring the
pitch
if at all possible."

In pictures of Tyzack lathes, it looks like some models have four
change gears for setting the reduction ratio, so the program
mentioned
above is applicable. Below is a somewhat simpler program, written
in
Python 3. It accepts either an inch thread count or a metric thread
pitch (in micrometers), with numbers below 150 considered tpi and
150
or more as um. For example, the command ./gearset.py 1000
looks for gear sets to make a 1 mm pitch (1000 um) and after a few
milliseconds prints out:

Target is 25.4 tpi = 0.0394" = 1.0 mm
tpi: 25.422 = 0.9991 mm ABCD: 45 55 50 65
tpi: 25.455 = 0.9979 mm ABCD: 20 35 55 50
tpi: 25.333 = 1.0026 mm ABCD: 40 50 45 57
tpi: 25.319 = 1.0032 mm ABCD: 35 45 65 80


That's a better approach than mine for a lathe with loose change
gears. I bought an abused South Bend Heavy 10 with the 70-speed
gearbox whose pitch settings I found by Net research and trial.

At the time I was doing optics which requires a somewhat different set
of metric moduli than nuts and bolts. I copied the metric modulus
formula into each pitch's block of cells, linked to a fixed cell
($col$row) containing the X/127 ratio, then tried different values for
X until I saw the fine pitches I wanted. 120/127 worked out better
than SB's 100/127.

The best answer was sending the work to a shop with a Hardinge HLV-H
after I'd figured out a practical design with my lathe and mill. It
was the proof-of-concept demo for a laser comm link between
spacecraft. I'd been assigned to the project as the electronic tech
and wanted to prove I could handle more design aspects of the job.

jsw

"James Waldby" wrote in message
...
...(Note,
to look at the program, turn off line wrapping in your newsreader,
or
in an editor remove extra line wraps and restore any that are
missing.
Python syntax is sensitive to leading spaces.)

https://notepad-plus-plus.org/

"James Waldby" wrote in message
...
On Mon, 02 Mar 2020 12:26:59 -0800, Stephen Dixon wrote:


Target is 25.4 tpi = 0.0394" = 1.0 mm
tpi: 25.422 = 0.9991 mm ABCD: 45 55 50 65
tpi: 25.455 = 0.9979 mm ABCD: 20 35 55 50
tpi: 25.333 = 1.0026 mm ABCD: 40 50 45 57
tpi: 25.319 = 1.0032 mm ABCD: 35 45 65 80


37 and 47 tooth gears fastened together give an almost exact metric
conversion ratio, and are smaller than the correct 127 tooth gear
which may not clear.

On Tue, 03 Mar 2020 12:34:41 -0500, Jim Wilkins wrote:
"James Waldby" wrote ...
Target is 25.4 tpi = 0.0394" = 1.0 mm
tpi: 25.422 = 0.9991 mm ABCD: 45 55 50 65
tpi: 25.455 = 0.9979 mm ABCD: 20 35 55 50
tpi: 25.333 = 1.0026 mm ABCD: 40 50 45 57
tpi: 25.319 = 1.0032 mm ABCD: 35 45 65 80


37 and 47 tooth gears fastened together give an almost exact metric
conversion ratio, and are smaller than the correct 127 tooth gear
which may not clear.

Yes, that has about 1/4 as much error as 45 55 50 65 has. Re the gear
size, I think the 80 tooth gears are the largest usable on a standard
mini-lathe, ie a 127 tooth gear won't fit it or similar lathes, so
that's an important point.

I've slightly modified the program (as below) so it's possible to tell it
extra gears one has, and also changed it to use nested for-loops, instead
of the combinations() calls that weren't saving any statements or time.

Command ./gearset.py 1000 1 16 8 37 47 32 127 now produces:

Target is 25.4 tpi = 0.0394" = 1.0 mm
tpi: 25.400 = 1.000000 mm ABCD: 20 20 80 127
tpi: 25.400 = 1.000000 mm ABCD: 32 20 50 127
tpi: 25.405 = 0.999787 mm ABCD: 32 40 37 47
tpi: 25.405 = 0.999787 mm ABCD: 37 47 40 50
tpi: 25.392 = 1.000307 mm ABCD: 35 47 55 65
tpi: 25.385 = 1.000606 mm ABCD: 32 55 65 60
tpi: 25.422 = 0.999126 mm ABCD: 45 55 50 65
tpi: 25.371 = 1.001126 mm ABCD: 35 37 40 60


#!/usr/bin/env python3
gears = [20,20,35,40,45,50,55,57,60,65,80,80]
from sys import argv
rn = 0; pre = (-1,-1); candi = []; nargs = len(argv)
# Metric thread pitch gets entered times 1000, eg 500 means 0.5 mm
rn+=1; tpi = float(argv[rn]) if nargsrn else 16 # Desired threads per inch
rn+=1; eps = float(argv[rn]) if nargsrn else 1 # Allowed error in %
rn+=1; Lead = float(argv[rn]) if nargsrn else 16 # Effective Lead Screw ratio
rn+=1; topN = int(argv[rn]) if nargsrn else 4 # Max number of candidates to show
while rn nargs-1: rn+=1; gears.append(int(argv[rn]))
gears.sort()
target = tpi if tpi150 else 25400/tpi
ftpi, itpi, mtpm = round(target,4), round(1/target,4), round(25.4/target,4)
print (f'Target is {ftpi} tpi = {itpi}" = {mtpm} mm')
errmax = target*eps/100 # Convert % error to tpi error
dexes = range(len(gears))
for da in dexes:
for dc in dexes[1+da:]:
for db in dexes:
if db==da or db==dc: continue
for dd in dexes[1+db:]:
if dd==da or dd==dc: continue
a,b,c,d = gears[da], gears[db], gears[dc], gears[dd]
t = Lead*(b/a)*(d/c); err = abs(t-target)
if errerrmax: candi.append((err, t, a,b,c,d))
for item in sorted(candi): # Remove duplicate candidates
if item==p candi.remove(item)
pre = item
for err,t,a,b,c,d in sorted(candi)[:topN]: # Print top candidates, if any
print (f' tpi: {t:0.3f} = {25.4/t:0.6f} mm ABCD: {a:3} {b:3} {c:3} {d:3}')

--
jiw

"James Waldby" wrote in message
...

I 'speak' Pascal, QBasic 4.5, assembly and some c, but not python. How
well does it interface with the intricacies of Windows? Can it talk to
a USB port or handle interrupts?
jsw

On Tue, 03 Mar 2020 17:12:10 -0500, Jim Wilkins wrote:
"James Waldby" ... wrote ...

I 'speak' Pascal, QBasic 4.5, assembly and some c, but not python. How
well does it interface with the intricacies of Windows? Can it talk to
a USB port or handle interrupts?

I don't have an MS Windows system of my own and have used Python only
a little on other people's systems. However, a goal of Python implementers
is to have complete cross-platform functionality. For example,
https://pypi.org/project/pyusb/ says "PyUSB offers easy USB devices
communication in Python. It should work without additional code in any
environment with ..." various requirements, like libusb and OpenUSB,
which are available for MS Windows, eg at https://zadig.akeo.ie.

For interrupts with Python, there's lots of detailed info related to
the Raspberry Pi. What I've seen re use on MS Windows is less technical,
eg https://www.reddit.com/r/Python/comments/33al25/python_interrupt_or_terminal_in_windows/
That reference doesn't refer to the probably-relevant `async` and `await`
keywords (as in async def, async for, async with) available for Python 3.5
and later. (See eg https://realpython.com/async-io-python/). Anyhow,
USB and serial IO typically work alike across platforms and I think don't
require as much knowledge of the programmer as multiprocessing does.

For the "interface with the intricacies of Windows" there's an OS module
that handles OS-specific details like file name and path rules.

For MS Windows XP, official Python organization support only goes up to
3.4. The link below has a little about dealing with async in that version.
https://stackoverflow.com/questions/37465816/async-with-in-python-3-4
For MS Windows 7 - 8 - 10, the latest version, 3.8.2, is available.

--
jiw