differential threads for extreme precision movement

I've been playing with different mechanical leveraging ideas
to be used both for direct movement of the table and as a
way to increase the resolution of rotary encoders
( see 11 Apr 2000 "motion-multiplying pulleys: linear to rotary encoder")

I was happy to see "A. G. Eckstein" <axtein@...>
is using a similar scheme (see his posting 06 Jul 2000) and described here:
http//:www.surfsouth.com/~axtein/dro/dro1/index.html

- - -

Well I came across another VERY interesting page at:
http://www.geocities.com/CapeCanaveral/Hall/4425/ Marvin W. Klotz

which has lots of (DOS) programs (source code & executables)
to aid the machinist. It is well worth your time to look it over.

One of the gems there is a description of "differential threads",
wherein various combinations of course and fine threads acting
together differentially, can create huge mechanical leverages
(or counts/rev for encoders).

This is great for us, because it may give us the capability of having
HUGE number of steps per inch of advancement. For example,
using a 180 step/rev stepper with at 10 microstep driver like the
Geckodrive (ie 1800 steps/rev), then using a 56 TPI course and a
Metric 56.444 TPI (ie 0.45 mm/thread), then you'd get 12,801,539
turns per inch, or an advance ratio of 7.81E-8 inch per step (0.000 000 0781 ").

A more usable example is using a 28 TPI with the above metric thread
to get 100012.493134 steps/inch (or approx 0.000 01" per step).

With such ratio's as these, there should be no requirement to use
pulleys to increase leverage, so the motor can direct drive the shaft.

There are of course some interesting "details", which I leave up to
the "sufficiently curious".

By using some of Marvin Klotz's thread tables and differential thread
formula:

pc = coarse pitch (tpi)
pf = fine pitch (tpi)
pe = effective pitch of differential thread (tpi)

(1/pe) = (1/pc) - (1/pf)

I whipped up a program to compute all the different ratios one could
expect from different thread combinations. The idea is to sort the output
and discover the proper combination to use to acheive a ratio near what
you desire.

- - - diffdug.c -----
BTW, I wrote this in about 20 minutes, so please overlook the style :)



// diffdug.c - by doug fortune, inspired by Marvin W. Klotz
// a Q&D program to calculate steps per inch in a
// differential thread-driven stepper motor setup
// computes Imperial and Metric combinations too
//
// usage: gcc diffdug.c -o diffdug ; ./diffdug | sort -n | less
//
// ex: 12801539.355469 7111.966309 30 : 56.000000 42 : 56.444447
// means using a 180 step/rev stepper with at 10 microstep driver (ie 1800 steps/rev)
// then using 56 TPI (Imperial index 30) course and a Metric 56.444 TPI (Metric index
// 42-40 == 2 which is 0.45 mm/thread, then you'd get 12,801,539 turns per inch
// or an advance ratio of 7.81E-8 inch per step (0.000 000 0781 ")
//
// a more reasonable combo would give approx 0.000 01" per step:
// 100012.493134 55.562496 22 : 28.000000 42 : 56.444447
// or using a 9.5 TPI and an 10 TP, an advance ratio of 0.000 002 924 " per step:
// 342000.000000 190.000000 9 : 9.500000 10 :
10.000000

#include <stdio.h>

int STEPS_PER_REV= 1800; // steps per revolution of the driver/motor
pair
// here 180 step/rev motor with 10 microstep driver

// Imperial threads TPI = Threads per Inch
float arrrayI[100] = { 4.5, 4.75, 5, 5.5, 6, 6.5, 7, 8, 9, 9.5,
10 , 11 ,12, 13 ,14, 16 ,18,19,20, 22,
24, 26 , 28, 32, 36, 38, 40, 44, 48, 52,
56, 64 , 72, 76, 80, 88, 96, 104, 112, 122 };
int magicI=40;

// Metric threads mm/thread
float arrrayM[100] = { 0.25, 0.3, 0.45, 0.5, 0.6,
0.75, 0.9, 1, 1.2, 1.25,
1.5,1.8, 2, 2.25, 2.4,
2.5, 3, 3.75, 4, 4.5,
4.8, 5, 6, 7.5 };
int magicM=25;

main()
{
int i, j, magic=magicI+magicM-1; // magic = number of elements in both
arrays
float val;

for(i = magicI, j = 0; j < magicM; i++, j++) // conversion to TPI

arrrayI[i] = 25.4 / arrrayM[j] ; // stuff it onto end
of arrrayI

// for( i = 0; i < magic; i++) check conversion of Metric to
Imperial TPI
// printf("%f \n", arrrayI[i]);
//exit(0);


for( i = 0; i < magic; i++) // dump out all possible
combinations
for( j = i+1; j < magic; j++) {
val =1.0/ ((1.0/arrrayI[i]) - (1.0/arrrayI[j])) ;
if( val < 0) val *= -1.0;

// steps/inch multiplier Imp Index, TPI, Met Index, TPI
printf("%f \t%f \t%2d : %f \t%2d : %f\n",
val*STEPS_PER_REV, val,
i, arrrayI[i], j, arrrayI[j] );
}

}