A second pass at my earth/moon orrery.

I’ve come to realize making something from scratch winds up building a bunch of prototypes as you both perfect the plans and figure out how to make the parts.

And in my case, while the plans may be great–my ability to machine parts is… shall we say questionable?

At any rate, I have a second pass at the Earth/Moon orrery.

A few observations about my design.

First, the gears don’t quite have the axle holes dead center. It’s not that I don’t own a set of mill center drills, which are useful for starting a hole at the exact spot you want it at (rather than trying to use a drill bit and getting a hole wherever the damned bit bends to), it’s that I forgot to use them when I made the center holes of the gears.

So I have to remember when cutting a gear to use the following steps, which I document here because someone else may find these useful. (I’d make a video, but I’d need to license the Benny Hill Yakety Sax music.)

1. Measure and cut the blank for the gear from 1/8th or 1/16th thick sheet metal. (I’m using aluminum because it’s cheaper than ruing hundreds of dollars of brass.) The blanks should be slightly bigger than (N+2)/32 inches (for 32P gears, which is the size I’m cutting) in diameter. (I made the mistake once of thinking “radius.” That wasn’t good.) The blank should be drawn around a divot in the center made with a hand punch.

2. Set up an arbor for the gear. Take a piece of aluminum rod close in diameter to the gear we’re cutting, mount and center on the lathe, and face the arbor. This causes the end of the arbor to be flat relative to the cutting surface we’re cutting on.

Note that all of this is taking place on the little Sherline, because one of the steps will completely screw up the center otherwise.

3. Attach the blank to the arbor. Using a center on the tail stock and a dash of superglue, superglue the gear blank to the arbor. Use the tail stock center to help center and push the gear blank on the arbor, and allow five to ten minutes for the glue to set.

4. Cut the gear blank. On the lathe, turn the blank to the desired diameter. For 32P gears, this is the Outer Diameter of the gear, and is (N+2)/32 inches in diameter for a gear with N teeth.

5. Using a mill center drill bit, start a center for the axle. This is the step I kept missing, and that caused my gears to be slightly off center. The end result is a tiny little divot at the exact center of the gear blank, which then can be used to drill a hole without having the drill bit wander too far off center.

6. Drill the center hole the desired diameter. Enough said. In the case of the orrery, I have to remember one of the 52-teeth gears has a center hole of 9mm. (At some point once I’ve perfected the plans, I’ll upload the instructions for making this device.)

7. Re-mount the gear blank on the mill. I assume the mill has been set up for cutting gears, with the appropriate cutter mounted on the cutting arbor, and the rotary table set up at a 90 degree angle. At this point you’ll need to then verify the gear cutter is centered in the gear to be cut.

8. Start cutting gears. What I’ve been doing–to great effect–is to center the gear across the cutter, so turning the Y axis knob in front slides the gear into the cutter. The moment I hear the tell-tale sign of the gear cutter starting to cut the gear, I note the depth on the knob (all my mills and lathes are marked in inches), rotate the X axis to get the gear out of the cutter, and turn the knob into the cutter 0.0625 inches. This is the desired depth of the teeth.

(We get 0.0625 inches from the observation that if the outer diameter of a gear grows by 2/32″ for a 32P gear, this means the inner diameter must shrink by a corresponding 2/32″ as well. This means the diameter difference between the outer and inner diameter differs by 4/32″–and the tooth depth, the delta of the radius–must be half that, or 2/32″. That is, the tooth depth is 2/32″ = 0.0625″. By listening for the cutting, my guess is that I’m cutting the teeth a hair wider and a hair deeper than needed. On the other hand, this works out fairly well, given that the final mechanism I built, pictured above, rotates pretty freely with center holes precisely at the locations my Kythera program predicted.)

Once the gear depth is set, lock the Y axis, and start cutting gears by turning the rotary table the desired amount and sliding the gear blank through the cutter using the X axis.

I don’t have any CNC motors attached to my mill, only to the rotary table–so this gets pretty boring pretty fast.

9. If all goes well, separate the blank from the arbor. The technique I’ve seen which works well is to use a blowtorch and heat up the gear blank until the superglue releases. Try not to do this on cement, because you can cause the imperfections in the cement to pop, throwing small bits of cement at your face.

The different gears that are supposed to be attached to each other, by the way, I simply superglued together. This is probably not a great long-term solution, but in the short term it works very well.

I think with a little better technique I can cut the gears and mount them and have a functioning orrery. But the last gear, the thing that rotates around showing the position of the moon–that leaves a whole lot to be desired.

Originally I had built a 14 tooth gear using 1/8th inch thick aluminum, and then cutting a separate component:

Moon mount

This I then superglued to the 14-pin tooth, and I cut the 6mm end with a 6mm thread, which I then screwed a cap on top that holds the pin that will eventually support the moon.

And this went… poorly.

The stupid part is that in retrospect this should have been cut as a pinion:

Moon pinion

And the moon should have been mounted not by screwing the top piece on, but by using a grub screw.

Well, in a few days I’ll go back to cutting parts and seeing if I can’t machine something better. Meanwhile, version 2 of my orrery prototype.

Announcing a new Quick Video: A Full Adder

When we used NPN transistors to build our logic gates, it implies they can be used for building bigger things. In this video I’ve built a full 1 bit adder from our second Introduction video, entirely from discrete transistors.

Build 8 of these–and you have an 8-bit adder.

The show notes include the complete circuit diagram.

So here’s the video.

And thanks for watching.

Finally, at long last, I got my two 52-tooth gears for my Orrery!

It took another couple of tries, and the trick for these gears was to get the outer diameter to within 0.002″. Further, it required depthing the teeth to 1/32″ == 0.625″ (the precise measurement of the depth of the teeth) rather than cutting them a hair deeper. And I’m suspicious the Sherline divider may not be stepping the precise number of steps–but I have no way to prove that, and usually when I think equipment has gone south, it’s actually user error.

(Since, as I’ve said several times before, I have no idea what I’m doing here.)

And how did I get the blanks cut to the right diameter?

On the Sherline lathe, of course.

Because in the middle of the night last night I had a brainwave. I realized you don’t have to cut with the cutters straight on; you can turn the cutter so that it cuts off the carriage. Meaning if the cutting head is turned, the pointy bit that does the cutting is not over the carriage. Each wheel is only 1/8th to 1/16th of an inch thick, so it doesn’t take much. And of course be aware that you can crash the carriage into the wheel.

But that gives me about 3 inches and change of useful circle cutting power now–and that implies gears of up to 100 teeth at 32P. (For bigger wheels I’ll need to do something different–but my goal here is to design my own Orreries, and nothing I’ve designed so far require more than 80-something teeth.)

Anyway, good news, everyone!

Tonight will be some TLC with OpenSCAD, designing a new harness for the gears (so I can test to see how well they spin), and soon cutting the harness out of aluminum.

No, I haven’t forgotten about the gear cutting. I just haven’t been having a lot of luck.

It probably doesn’t help that I have no idea what I’m doing. Though I do have all my fingers and toes. So there’s that.

So today, after getting the M3 to M2 adapter, the M2 to Sherline adapter, and hooking up the Sherline 4-jawed chuck to the larger 7″ lathe, I went to round the blanks and get them ready for gear cutting. (While gears smaller than about 32 teeth or so make sense cutting on the Sherline, anything bigger than about 48 teeth just cannot clear the carriage. (The distance is 0.9 inches or so, which means the maximum OD of a gear that can clear the carriage is 1.8″–which implies a 55 tooth gear. That’s because

Max Sherline OD

(The OD of a gear of N teeth with a pitch diameter of D is (N+2)/D.)

And while I have two gears that are 52 teeth, my ability to cut blanks sucks. Meaning what I get aren’t circular blanks; what I get are jaggedety things that will inevitably crash onto the carriage. Now I’m sure I can probably reorient the carriage on the Sherline to cut the bigger blanks–but I figured “hey, I have a larger lathe; let’s try that.”

And then I got the first gear, the one on the right in the photo above.

Notice anything about the gear?

Here, let me show you a more detailed image:

Detailed Image Gear 1

Yep, the teeth at the top are nice and pointy; the teeth at the bottom are flat. That’s because in the process of transferring the gear and mount from the adapter on the 7″ lathe to the mount for gear cutting, the center was not preserved.

So the teeth on the top of the image were cut deeper than the teeth on the bottom.


This is, by the way, when I pulled out the measuring jigs and discovered that my 7″ mini lathe wobbles. By about 0.005 inches. Combine that with the error in the M3-M2 adapter (roughly of the same magnitude), and that explains the error in the shape of the teeth.

I could bitch about “cheap Chinese crap,” as have many on the Internet–but let’s be serious: I don’t know what I’m doing. Blaming the equipment seems a little premature here. Certainly dismounting a jig from one thing and mounting it on another–unless it’s very expensive, precision equipment that has been carefully calibrated by someone who knows what they’re doing–is probably not going to go very well.

And that tells me not to assume the precision of the equipment I’m using, especially if I need to cut stuff to tolerances of 0.001 inches.

It also probably doesn’t help that I’m using soft aluminum, which, if breathed on strongly, will easily deform 0.005 inches on its own.

So plan two.

Mount the arbor on a four jaw chuck on the 7″ lathe, turn, drill the center, then place in the four jaw Sherline chuck. And yes, the moment you unmount anything from a chuck you will never get it centered again unless you use a lot of fiddling.

It took me an hour to get the wheel centered on the second 4 jaw chuck for turning. Because newbie.

(To be clear, it was centered to within 0.002 inches. Since the teeth are cut 0.0625 inches (2/32 inch) deep, I figured an error of around 3% on the depth of the teeth was acceptable for test purposes. Besides, I’ve been cutting my wheels a hair smaller.)

For centering purposes I used the stepper motor on the rotary table and went back and forth for what seemed like forever.

Then I switched modes on the stepper motor divider (without resetting the device by turning it off and on), and started cutting teeth. And got the gear in the top image on the left.

Noice the problem?

Here, let me zoom in:

Detail Image Gear 2

See what looks like half a tooth?

Well, it appears the stepper motor and wheel assembly turned around slightly more than 360° when rotating the circle. Which left me with a useless gear, since the teeth are not cut 360/52 ° per tooth, but slightly more.

And I don’t know if it is because my arbor slipped or because I mistreated the stepper motor/rotary plate. Certainly I should have reset the thing.

So I’m left with a few possible plans for cutting the larger gears.

One is to somehow mount the cutting bit on the smaller Sherline lathe so I can cut the wheels without them crashing into the carriage. Without the carriage there is easily several inches of clearance–meaning I could cut gears with nearly 100 teeth fairly easily.

Another possibility is to build some sort of mount which I can use to mount the Sherline 4 jaw chuck to the larger 7″ lathe and center everything with precision. I’ve ordered a 3/4 16 threaded rod and some hardware to try this option.

Another possibility is to revisit plan two, but make sure the stepper motor and divider have been properly reset by power cycling the whole thing and letting it rest for a few moments. However, I sort of suspect the problem was not the stepper but the possibility that the cutting forces on my arbor caused it to twist in the mount as I was cutting the teeth. After all, my arbor is, well, rather soft aluminum. And cutting teeth certainly is more force than breathing on it.

But all of that is for another day.

On the other hand, I now have a much greater understanding of the shape of the teeth for gears–and now that I’ve gained a superpower in doing animated visualizations, I think I can visualize the math behind the shape of the gear teeth.

That means I think I can also visualize the math for the inner teeth of a planetary gear.

And I may put that together in the following weeks–to help explain why the teeth of a gear are what they are, and so I can rework my Kythera app to do planetary and inner gears.

Wire forms.

So if you’ve been watching my Quick Videos you know I’ve been building a lot of circuits on prototype boards. I also took the liberty of 3D printing a couple of useful tools to help measure and bend wire.

The first on the left helps measure lengths of wire; each wire is measured in each groove 0.7″ longer than the number of holes (separated by 0.1″ in length) indicated on the scale. (That’s because the strippers I use to trim the hookup wire for my prototyping breadboard cuts around 0.35″ off the ends of each wire, so this allows the insulation to be precisely the right length.)

The second helps bend wires precisely by the number of 0.1″ lengths desired, and even has a small cylindrical impression for resistors:

Bending Resistors

All of the designs were created using OpenSCAD, and printed using a Form 2 Printer. The files can be downloaded from here: wireforms.zip

And now the second video has been released!

So, as promised, about a month later, the second video in my series of videos explaining how computers work from the ground up.

And I mean truly, the ground up; on a breadboard next to me I have a working 1-bit adder circuit made entirely out of 10KΩ resistors, 2N3904 transistors, a few LEDs and 330Ω resistors, and a few switches to demonstrate how it works. Of course once we get passed flip flops and tri-state gates I may not have enough transistors sitting around the house (or enough breadboard space) to actually wire these things up…

I’ve also created a separate channel for all of these videos, and have a playlist of my introduction videos. Once a month (give or take) I hope to add future videos that continue down this path until we have something that conceptually works.

Now as a footnote, the reason why the hands-on stuff is important to me goes to my finding an error in the first video, which caused me to rush out a new version of the first video in the series.

That’s because when I used the logic gates from the first video–well, nothing worked. And they didn’t work for reasons I explain in the re-cut video linked below.

I think it’s important to note all this, in large part because science.

Remember: the difference between science and screwing around is that in science, we document our results. And we confess our mistakes when we make them.

So here’s the first video in the series–re-edited and re-uploaded.

I confess to a mistake in the first video.

Of course one of the purposes of the “Introduction to Digital Computers” video series is to create a series of videos which describe how computers work from a transistor level–and starting with NPN transistors so in theory you could build this yourself.

Because the idea is that I want computers not to be this strange abstraction where below some level there are these theoretical things called “CMOS transistors” which we can’t lay our hands on or touch or feel.

I also based my abstraction of a transistor in part using the sets of equations derived from Balajee Seshadri’s explanation of a transistor starting with the idea of a resistor. The graph in the first video is mathematically derived from these equations, using certain resistor values and a transistor with a β of 100, like the 2N3904 transistor.

I even went through and built the gates, which is in a subsequent video.

But in the process of building a transistor array which can create a full adder circuit from 2N3904 transistors, I noticed a mistake in my video.

And I’m wrestling with how to fix this bug.

See, the entire explanation of a transistor relies on the following circuit:


Now this circuit has the nice property that it amplifies the input voltage Vin to the voltage Vout–but the output voltage is inverted from the input voltage. That is, the higher the input voltage, the lower the output voltage–as the transistor switches on, the voltage that would go to Vout goes to ground instead.

When you graph this, it looks something like this:

Canvas 1That is, as the input voltage (blue) ramps up, the transistor eventually switches on. This drives the current to ground, which causes the output voltage to descend more rapidly than the input voltage.

My error was to reverse this. Because I didn’t want to have to deal with inversion in the graph (because this is an introduction video, ‘natch), I flipped the circuit around and drew the following diagram:


But the graph is incorrect.

It turns out in the real world the behavior of the output when you flip the transistor and the resistor pair is not as graphed.


This was generated by iCurcit for the Macintosh, and it matches what I’ve seen on a voltmeter in the real world. The top (red) line indicates the input voltage. The bottom (yellow) line represents the output voltage with the circuit at the top.

And the purple line is the output voltage of the circuit I showed in the “Introduction to Digital Computers” video.

Essentially what happens is until the transistor hits it’s switching voltage (for the 2N3904, 0.7v), the output remains zero. Then when the transistor activates, the output current rises roughly at the same rate as the input voltage–to reach a maximum of around 4.3v assuming a 5v rail.

The best explanation I have for this is to think of a transistor as a gate across a sluice of water: the water pressure flowing to the base opens the gate allowing water to flow from the collector to the emitter. The water at the base then flows out the emitter. The problem is if you block the emitter, the water pressure at the base lowers (remember Voltage = Current * Resistance), which then causes the gate not to open as wide.

This leaves me with a dilemma, and I suspect what I’ll be doing is redoing all the animations for the video and posting a new version with the corrected graph. But it’s truly annoying I didn’t catch this before, and I apologize for the error.

Using an Arduino to verify your web site is running.

We’ve been having problems with our Internet connection, and I also maintain an e-commerce web site which I’d like to make sure is working correctly.

This quick little hack uses the following parts to periodically check that your web site is running:

Now if you look through the specifications for the Ethernet Shield you see it uses data pins 4, 10, 11, 12, and 13. Now data pins 0 and 1 are used during programming of the Arduino–so I went ahead and wired up my LEDs to pins 2, 3 and 5 on my prototype shield:


With this built on the prototype board, it’s easy to create a test sketch to verify the LEDs works correctly:

void setup() 
    pinMode(2, OUTPUT);
    pinMode(3, OUTPUT);
    pinMode(5, OUTPUT);
    digitalWrite(2, HIGH);
    digitalWrite(3, HIGH);
    digitalWrite(5, HIGH);

void loop() 

I sandwiched the Ethernet 2 shield between the Arduino and the custom LED shield before running the test sketch, just to make sure there was no interference between the Ethernet shield and our custom LEDs.

I used three colors: green means everything is going fine. Yellow means the web site could be reached, but the results returned from the web site were not what we expected. And red means the web site could not be reached.

We can do this by using the Ethernet client and by loading one of the pages off the web site.

Our final sketch works as follows:

/*  NetworkUp
 *      This sketch uses the Ethernet Shield 2 library and some custom hardware
 *  to ping a web site to determine if the web site is reachable and is up. This
 *  repeats for some user-defined period (in practice, about every 15 minutes).

#include <Ethernet2.h>

We need to set up some constants.

The constant INTERVAL is how often our sketch checks the server. The constant below is set to 15 minutes in milliseconds.

#define INTERVAL        900000  /* Every 15 minutes */

The Mac address of the board is located on a sticker on the back of the Ethernet board for newer boards; you need to replace the Mac address constant below with the one on the sticker.

byte mac[] = { 0x2C, 0xF7, 0xF1, 0x08, 0x1B, 0x28 };

And this is the server you’re monitoring. In my case, it’s a web site which sells collectable stock certificates:

char server[] = "hollinscertificates.com";

Next we need a secret string we are checking to see if it is on the web site. The idea here is that since you control the web contents, you can insert a secret string that the client scans for to make sure is present in the return response. This can be a string in the HTTP response header, or a comment in the HTML; all that is important is that if the string is not present, we turn on the yellow light.

And that allows us to investigate in case the web site page is gone (and we got a 404 error), or if our web site was hacked.

char validate[] = "<!-- A Secret Comment -->";

Next we define a number of globals:

EthernetClient client;     // The Ethernet Client
unsigned long nextTime;    // Time (in ms) to check the web
bool connectFlag;          // True if we've connected
bool successFlag;          // True if we found our validate string
byte valPos;               // Position as we scan our string.

Our setup entry point sets up the Ethernet shield. We use certain LED animations in order to help us debug where we are in the startup sequence. All three LEDs are on when the board first starts up and the Ethernet shield is getting its IP address from a DHCP server. Then the lights flash from green to red for a second (in order to provide us the required 1 second delay as the Ethernet board initializes).

We then set a few of our globals.

void setup() 
     *  Set red, green LEDs on.

    pinMode(2, OUTPUT);
    pinMode(3, OUTPUT);
    pinMode(5, OUTPUT);
    digitalWrite(2, HIGH);
    digitalWrite(3, HIGH);
    digitalWrite(5, HIGH);

     *  Try to initialize our Ethernet library

    if (Ethernet.begin(mac) == 0) {
         *  Something went wrong. Fast flash red LED.

        for (;;) {

     *  Quick animation. This also delays us 1 second to allow the Ethernet
     *  chip to come up.

    digitalWrite(2, LOW);
    digitalWrite(3, LOW);
    digitalWrite(5, LOW);


    nextTime = 0;
    connectFlag = false;

Our loop checks to see if it is time to connect to our server, and if so, opens a connection to port 80 and makes a request for our web page.

Client GET requests work by opening a TCP/IP connection and sending a block of text ending in a blank newline. Wikipedia has a very simple example of this. We send two additional parameters besides the “Host” parameter: we ask the connection to be closed when we’re done. And we let the back-end know our user agent name is “arduino-ethernet”; we can use this to filter out our requests from any back-end statistics.

Our connection is preceded by turning off all the LEDs; this gives a visual indication that we are talking to the back end:

void loop() 
     *  At the top of this loop try to get the home page for the
     *  specified web site.

    unsigned long t = millis();
    if (nextTime <= t) {
        digitalWrite(2, LOW);
        digitalWrite(3, LOW);
        digitalWrite(5, LOW);
        if (!client.connect(server,80)) {
             *  We have an error. Immediately light up red.
            digitalWrite(5, HIGH);      /* Error */
        } else {
            client.println("GET / HTTP/1.1");
            client.println("Host: hollinscertificates.com");
            client.println("User-Agent: arduino-ethernet");
            client.println("Connection: close");

            connectFlag = true;
            successFlag = false;
            valPos = 0;
        nextTime = millis() + INTERVAL;

Note two other things here. First, if we are unable to make the connection, we turn on the red LED. The assumption here is that for some reason we cannot reach the server–either the Internet is down, DNS is not working, or the back-end server is otherwise unreachable.

Second, if we do make the connection, we send our full request (including the blank line); the web server on the other hand listens to the text as it is sent, and a blank line triggers the response. (Think of a TCP/IP connection as a two-way simultaneous conversation; the sender and receiver can send data at the same time. So we need a convention to say “hey, I’m done talking”–and in the case of HTTP, for GET that’s the blank line.)

We then note that we made a successful connection, we haven’t found our match string yet, and we reset the match position to zero. We also note the next time we want to make a request.

Once we’ve made our connection, the field client.available() will be true if a character is waiting to be read. We scan the characters, matching against our magic string–and if we’ve read the entire string, we turn on the green LED and we set our success flag to true:

    if (client.available()) {
        char c = client.read();
        if (validate[valPos] == c) {
            if (validate[valPos] == 0) {
                successFlag = true;
                digitalWrite(2,HIGH);       /* Success */
        } else {
            valPos = 0;
            /* Catch special case where the mismatch is actually part of the substring */
            /* For example, if we want ABC, and we see ABABC, on the second A, we want */
            /* to actually advance by one. */
            if (validate[valPos] == c) ++valPos;

If we for some reason only get a partial match, we reset our scanner to the start.

We also check to see if the connection is closed. This happens when the web page has been completely served. (Recall we sent “Connection: close” above.)

If we don’t see the successFlag value set, we turn on the yellow LED. This indicates either there is a problem with the web page or the web page has been hacked.

    } else if (!client.connected() && connectFlag) {
        connectFlag = false;
        if (successFlag == false) {
            digitalWrite(3,HIGH);           /* Did not see our validation string */

There you go. A dedicated little circuit that can sit on your shelf, alerting you if there is a problem with your web page.

The complete source kit for the sketch can be found GitHub.

Another day, another four gears. And tales of woe.

So one downside of the superglue arbor is that you really need to clean up the end of the arbor holding your gear–and you need to apply enough glue to get the gear to stick to the arbor. More than once today I had wheels fall off the arbor–and that led to… well, complications.

I also learned the amount of space above the swing arm of a Sherline lathe is… perhaps slightly less than an inch? This means it’s okay for doing small parts–and in fact, is much better at very small parts than the gigantic “Mini Lathe” that I also have. And in the future when I need to machine set screw spacers for my 2mm rods, I’m definitely going to do it on the Sherline.

But I have two gears that have 52 teeth; the outer diameter is (52+2)/32 = 1.6875″. Which means it can’t be cut to the proper diameter on the Sherline, since I’ve been cutting the blanks just a hair larger.

A quick search of the Internet coughs up a 3/4″ 16 threaded end which fits the Sherline 4-jaw chuck on one end, and has a MT-2 tapered end to fit the MicroLux 7×16 mini lathe on the other.

The good news is that I should be able to duplicate my process flow for bigger gears, but just use a bigger lathe.

And if it turns out the Sherline mill is too small for bigger gears–I do have the MicroMark “Miniature” milling machine.

Though after spending time with the Sherline, it’s hard to see the relatively gigantic MicroMark lathe and mill as “miniature”…

And I have all the other gears for my Earth/Moon Orrery “proof of concept.”

I may still not quite know what I’m doing–but at least I got a gear.

So I drew and cut out several blanks from the 1/8th inch aluminum (and I confess I had to do this several times, by the last blank I was very close to the line) using a scroll saw and a jeweler’s blade.


I then perfected them on the Sherline Lathe to the correct diameter of (29+2)/32 inches, and drilled a 2.5mm hole in the middle.


I made two mistakes; the first was that I got the depth of the teeth wrong; I figured the depth of the teeth would be 4/32 inches–which is the difference between the outer diameter and the inner diameter, not the difference in the radius. (So the teeth should be 2/32 inches deep not 4/32 inches deep.)

Go back, make another blank.

Second mistake: the three jawed chuck (shown in the photos) can’t really hold the load during cutting. The gear and arbor got loose, screwing up the gear. Replace with 4 jawed chuck. Re-cut mounting arbor (since old one was trashed).

Go back, make another blank.

But finally, I got my 29 tooth gear. And it even meshes properly with a commercially purchased 32p gear I bought from SparkFun:

IMG 4578IMG 4581

Only 6 hours of my life, too!

(But now I know the process I think I can shorten the time somewhat…)

One down, 6 to go for my Earth/Moon orrery.