Automated Dividing Head

Ellis Dividing Head
Ellis Dividing Head

A while back I picked up this Ellis dividing head from eBay. It was a very reasonable price considering I could spend upwards of $1k on a comparable unit. However, in the end you get what you pay for and this was no exception. Fortunately I like projects.

For the impatient types, there is a video below.

What’s a Dividing Head?

Looking through the spindle
Looking through the spindle

There’s lots of information out there about what dividing heads are and how to use them, but I’ll give a cursory explanation. A dividing head is a machinists’ fixture that mounts to a milling machine or drill press and holds a (usually circular) workpiece firmly enough to be machined or drilled. The workpiece mounts to a spindle that turns via a worm gear. A handle turns the worm gear and the workpiece rotates. The worm drive on the Ellis is a 40:1 ratio, so one full turn of the handle turns the spindle 1/40th of a revolution. Continue making 1 turn of the handle and you “divide” your workpiece into 40 segments. This is a handy way to drill a circular pattern of holes or cut teeth on a gear.

But what if you need a value other than 40 divisions? Well 10, 20, even 80 divisions are easy to figure out, but it gets complicated with values like say, 7. For this reason there is an “indexing” mechanism for keeping track of fractional turns of the handle. This mechanism is a pin attached to the handle that fits into holes in a round plate. Each plate will have several sets of holes, and there is a set of plates.

Unfortunately the Ellis only came with one plate, so I would have been limited by the number of divisions I could make. That wasn’t the only problem though…

“Un-boxing” and tear down

When I picked up the box in my entranceway the head nearly fell out of the bottom. It was packed with some paper, but weighing about 40lbs, it might as well have been rolling around alone in there. I got it upstairs and un-boxed. The first thing I noticed was how bone-dry it was. There was absolutely no oil inside, and the worm gear is meant to run in a bath of oil.

Everything was pretty stuck. I spent nearly an hour banging on a piece mounted to the spindle before I realized it was held on by 3 small recessed machine screws, not by the spindle threads as I thought. After all the banging, I realized I forgot to tighten the spindle brake so all the force was going directly to the worm gear. I did do a small bit of damage to the brass gear inside, evidenced by tiny slivers of yellow metal that fell out when I opened the top. Fortunately this gear is meant to wear a small amount which allows it to mesh with the precision ground worm. Tightening the worm into the brass gear and rotating reforms the gear, removes backlash, and restores the precision of the machine.

Dividing Head Spindle
Dividing Head Spindle
Fixture on spindle
Fixture on spindle

Next I attacked the base casting. I say attacked because it was quite a struggle. The head is supposed to rotate relative to the base so that you can use it vertically, horizontally or any angle in between. It appears that someone tightened the plate that holds it fixed so much that the cast iron was swaged. I was able to bang the head away from the base, again with minimal damage. I scraped and sanded the base to increase the diameter of the bore. I was finally able to get the head to seat in the bore. It’s a tight fit but allows the head to swivel with moderate effort.

swivel clamp plate
swivel clamp plate


Oil is an overlooked, super important subject. What most people don’t realize is most oil, regardless of the type, has lots of additives. Plain old motor oil for your car has detergents, anti-foaming agents, dispersants, and other agents added. One of the goals is to let the oil grab carbon particles and other combustion byproducts and hold them in suspension to be filtered out by the oil filter. Suspended particles in a gear box would be a bad thing, causing wear and tear on the gears, so gear oil is formulated to allow dirt and particles to fall out of suspension and stay at the bottom of the gear box until the oil is changed. There’s hydraulic oil, cutting oil, way oil…all have different additives for specific purposes.

The dividing head is essentially a gear box, so I needed gear oil. The problem is, most readily available gear oil is for modern cars and trucks that have very high pressures, and so they have EP or “extreme pressure” additives to keep the oil from being pressed out between the metal surfaces. That’s all well and good except some of these EP additives attack copper alloys. Add to this that some oils have anti-corrosion agents that can also attack yellow metals.

Gear oil is rated from GL-1 to GL-6. GL-6 is rated for the most severe conditions and has the most additives. GL-4 and GL-5 is what your local auto parts store carries. GL-1 is for light duty and is straight mineral oil without additives. GL-1 is what I needed, but it’s hard to find.

I spent lots of time looking at fine print on the back of containers. One day I was at a Tractor Supply store and saw a 2 gallon jug of “Ford Tractor Transmission Fluid”. I checked the fine print and it turned out to be “All Mineral” SAE90 GL-1 oil. Exactly what I had been looking for. The jug was the smallest (and only) size they had, a shame since I only needed a few ounces, but at $16 I couldn’t complain. With 2 gallons there’s a good chance this oil will be passed down to my kids.

Ford Tractor Transmission Fluid


With the dividing head unstuck and lubricated it was ready to use. Now while the indexing charts, changing of plates, and overall manual operation is romantic to someone like me who appreciates the old time craftsmanship and methodology of 19th century machinists, it’s just not efficient. Besides, I only had one plate so I would be limited with the divisions I could make. Here’s where I’ll finally get to the project at hand.

I immediately thought of using a stepper motor to advance the worm. I have a collection of steppers, so I grabbed one that looked like it would be suitable.

Bracket (front)
Bracket (front)
Bracket (back)
Bracket (back)

I designed the bracket by literally holding the stepper in one hand and a ruler in the other, and trying different locations around the dividing head. The bracket is two-piece with a sliding adjustment to tension a belt between the worm pulley and the stepper pulley. It was cut on my horizontal/vertical bandsaw and holes drilled on a 10″ craftsman drill press. I laid everything out with some cheap digital calipers. I could have used the machine shop at Artisan’s Asylum, but it wasn’t really necessary.


I didn’t need much torque because of the 40:1 advantage given by the worm gear. Still, this is a tightly meshed gear, so I wanted some additional advantage. I found a set of pulleys and timing belt at to give me an additional 3:1 gearing. This was the most expensive part of the project (around $30 shipped). I estimated the belt length required with the following formula:

Belt length notes
Belt length notes

When I got the belt it was spot-on. Almost exactly 3.5″ between pulley centers.

Let’s run some numbers now. The worm gear is 40:1. The pulleys give an extra 3:1. The stepper is 1.8-deg per step, or 200 steps per revolution. I chose to drive this bipolar motor with a half-stepping driver, so now I actually have 400 steps per revolution.

40 x 3 x 400 = 48,000 steps per spindle revolution.

This means I have a resolution of 360/48000 = 0.0075 degrees. Not too shabby. I’ll also note that since the worm is precision ground at 40:1, it effectively divides any inaccuracies in the stepper or pulleys by 40, so I do believe my final precision is a hundredth of a degree or better.

Control Unit

With the bracket, pulleys, belt and stepper mounted all I needed to do was build a control unit.

Here are the parts of the control box:

  • Transformer: 28v and 8v secondary taps
  • Unregulated DC board: supplies rectified power to the stepper driver
  • 5v regulated board:supplies power to microcontroller and logic circuits
  • Stepper Driver: an L297/L298 based driver, designed by
  • Control & Display board: the brains and user interface

The display/driver board based around a PIC 16F887. Here is the schematic.

click to view

The PORTB pins (RB0-RB3) go to the buttons. I broke out all pins of PORTD, though I only use 3 as outputs to ENABLE, DIRECTION, and STEP on the stepper controller. I may use the other 5 some time in the future


I had 6 7-segment displays, so that is what I used. I could have used an LCD easier, but I believe machine tools should have LED displays. I think it also made the final product feel more satisfying to use. With 6 digits I had to multiplex in order to drive them. I did this by illuminating one at a time, using the TIMER1 overflow interrupt to advance to the next digit.

void interrupt isr(void)
		TMR1L = timer1ResetL;			//reset TIMER1
		TMR1H = timer1ResetH;
		TMR1IF = 0;				//clear interrupt flag
		SELECT_DIGIT = 0x00;			//blank display to prevent ghosting
		if(currentDigit == 5){			//go to next digit
			currentDigit = 0;}
		DISPLAY_PINS = display[currentDigit];	//set up segments 
		SELECT_DIGIT = 0x01 << currentDigit;	//turn display on 
		INTF = 0;

timer1ResetL and timer1ResetH reset the timer upon overflow, so instead of going to 0, it will start over to a value closer to overflow. This allows me to set the time between interrupts, and so the time each digit is lit.

currentDigit is a global variable that keeps track of which digit is illuminated. display[] is a 6 character array that selects which segments to turn on for each digit. I recalculate the values each time the display needs to update, with the help of a map:

const char segmentMap[13] = {	0b11000000,	//0
				0b11111001,	//1
				0b10100100,	//2
				0b10110000,	//3
				0b10011001,	//4
				0b10010010,	//5
				0b10000010,	//6
				0b11111000,	//7
				0b10000000,	//8
				0b10011000,	//9
				0b10111111,	//-
				0b01111111,	//.
				0b10000110};    //E
Dividing function

I want to explain the way I advance through the divisions because there's something worthy to note.

To move I send a certain number of pulses to the stepper driver, which advances the motor one step per pulse. It seems trivial to just pulse n = STEPS_PER_REV / divisions. The problem is that we don't get nice integer numbers with most values for divisions. There are rounding errors that accumulate and by the time we get a full revolution, we may be off.

Here's the code I used instead:

	int	nextStep,

	float 	stepsPerDiv,
		idx = index,	
		divs = divisions;
	stepsPerDiv = STEPS_PER_REV / divs;
	currentStep = idx * stepsPerDiv;
	nextStep = (idx + 1.00)  * stepsPerDiv;
	moveSteps(nextStep - currentStep, FORWARD);

divisions and index are global variables. Divisions is self explanatory; index keeps track of where we are relative to the starting point. For instance, with 5 divisions, index rotates through 1, 2, 3, 4 and 0. 0 is home, 1 = 1/5 of the circle, 2 = 2/5, etc.

I do all the calculations with floats then assign the values to nextStep and currentStep. This throws a warning for implicit conversion to INT at compile time, but I expect it.

By calculating the # of steps to get to the next division, there is never a chance that the rounding error will accumulate. We may be off a step in either direction, but as we calculated above that equates to an accuracy of +/- 0.0075 degrees. This code also ensures that by the time we make a full revolution, we know we have taken exactly STEPS_PER_REV steps.

For the full source code, click here.

Video Walkthrough

Here's a video I shot to explain how it works. Excuse the poor lighting and focus, I'm using a cheap digital camera and I'm not really set up for taking videos.

Leave a Reply

Your email address will not be published. Required fields are marked *