Tyzack lathe

=========================================

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.

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

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 tpi<150 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 err<errmax: candi.append((err, t, a,b,c,d)) for item in sorted(candi): # Remove duplicate candidates if item==pre: 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}')

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

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 nargs>rn else 16 # Desired threads per inch rn+=1; eps = float(argv[rn]) if nargs>rn else 1 # Allowed error in % rn+=1; Lead = float(argv[rn]) if nargs>rn else 16 # Effective Lead Screw ratio rn+=1; topN = int(argv[rn]) if nargs>rn else 4 # Max number of candidates to show while rn < nargs-1: rn+=1; gears.append(int(argv[rn])) gears.sort() target = tpi if tpi<150 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 err<errmax: candi.append((err, t, a,b,c,d)) for item in sorted(candi): # Remove duplicate candidates if item==pre: 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}')

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

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,

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 . 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 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 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. For MS Windows 7 - 8 - 10, the latest version, 3.8.2, is available.

I know it is a long time ago to reply. In answer to your question, I have a hobson H7 lathe and I have compared the tables to the zyto lathe gear set and they tally. The zyto is is a machine which I am rebuilding. I can email the tables if you wish. The ratio between the quill and the first driver after the tumbler are the same. Te zyto gears are the same DP as the hobson 20dp Regards Mike East

Hi tyzack hope you and yours are well. I know your post was a long time ago but I have just seen it while searching for information on the Hobson H7 lathe and how to use it as I have no experience with lathes. I thought it would possibly to turn a 180mm shaft to size how wrong can you be!! So hopefully you are willing to impart some much needed knowledge and wisdom