Astrolabe cases

Two sets of friends are getting married, and as both couples are intellectually curious, I thought an astrolabe would be a nice gift.  But astrolabes alone require some kind of protection... so I decided to make cases for them.

I started from a block of black walnut cut from a tree we had taken down earlier this year.  Since I had previously split it, the wood had been drying all summer in the back yard.

Mostly, the woodworking needed for the boxes was nothing particularly special.  The steps I did were:

1. Rough cut the block of wood into blocks, each about 2 inches larger than my intended final size.  I used a chainsaw for this, and did the work outside.
2. Power planed the blocks so that the edges were square and partially smooth.  Since my power planer makes an enormous mess, I also did this outside.  (The chips from the chainsaw and power planer go in my compost...)
3. Using a large hand crosscut saw, I sliced off the lids of the boxes.  This is a somewhat delicate operation -- even though it requires lots of force -- as you must ensure that the cut is perfectly planar and parallel to (at least one of) the faces of the block.  I don't have a large enough power saw blade, so this is also a manual step!  In all honesty, this is a ripping operation, so I should have used a rip saw... but I don't have one.  My crosscut saw works well enough.
4. I did an initial sanding of the cut surfaces and did a little bit of squaring up of the other faces.
5. I recessed the parts of the box that receive the astrolabe.  This involved tracing the outline of a (disassembled) astrolabe to where the recess needed to go on both the base and the lid of the box.  I then used a router in 1/16" depth increments to cut the recess.  For the base, the recess is stepped since the thumb ring is supported in a more shallow recess than the rest of the astrolabe.  This also gives room for the pointers.  I also recessed the lid.
6. Power belt sanding.  Lots of it!  Starting with 60 grit, I got all faces parallel and square and cleaned off all the cut marks from the saws and planes.  I also rounded the edges where I wanted them round.  Then I repeated the whole process  with 80, 100, 150, and 180 grit.
7. Since I wanted a very fine finish, I then hand sanded the entire box with 220, 320, and 400 grit sandpaper.  Walnut will polish nicely with finer sandpaper if you're planning for an oil finish, but that wasn't necessary for this project.
8. Five coats of polyurethane with plenty of time for drying, and 400 grit hand sanding between each coat.  I made sure that the recesses were left unfinished, since I wanted to adhere a velvet lining.

I wanted to line the inside of the boxes with velvet to protect the astrolabe.  Since the cast acrylic I have been using recently for astrolabes is actually fairly sturdy, a velvet-lined box is surely overkill.  (I did accidentally drop my larger astrolabe, and that shattered the thumb ring.  Since super glue is actually an acrylic, it was a simple matter to fix the crack.  Super glue leaves a mostly invisible joint on acrylic and bonds almost instantly.)

Velvet is a fairly troublesome material for lining.  To make it adhere to a flat surface inside the box, you must support it.  The usual way this is done is to glue the velvet to a sheet of cardboard first, and then glue the cardboard to the box.  Since velvet frays badly, you need to roll the velvet around the back of the cardboard (a second gluing) so that no cut edges show.  Finally, since the boxes have a circular cutout to fit the astrolabe, I had to figure out how to manage that joint.

In the end, I glued the cardboard to the velvet, rolled and glued the edges, but left the circular bottom edge alone.  After the glue dried, I hand stitched the circular bottom edges together.  The result was a stiff velvet "cup" that fits tightly inside the box.

Once the velvet was glued in place, I added hinges and a front clasp.  While hinges and clasps aren't difficult to install, they require precision.  You must be especially careful since you don't want to harm the finish.  I held the box in the vice, but lined it with soft paper towel so that the finish wasn't marred by the vice.  I sharpened (under a microscope) my 1/16" drill bit before starting.  To install the tacks for the clasp, I didn't strike the tacks with the hammer directly, but rather used a recessed punch to ensure that I didn't slip and damage the finish.  When setting the tacks, I also held them in brass tweezers. 

Wooden equatorial sundial

I had a laser cut sundial in our garden, but it was destroyed.  No matter, it didn't work well in autumn.  I made a wooden replacement sundial.  Equatorial sundials are easy to lay out, since all of the hour lines are separated by 15 degrees.  You can quickly draw the plans directly on a piece of wood, as I did, with a compass and protractor.

One small point is that the dial itself will be semicircular.  To ensure that I got everything aligned first, I drilled the center of the circular arc. Even though the center will be cut out later, this way I can sight through the gnomon to ensure that everything is in alignment first.

Then I cut out the pieces,

and traced the hour lines.
 

To ensure that the hour lines are visible, I filed them into the dial.

I also woodburned them so that they are clearly visible. I also traced a vertical line so that I can install it on its mounting pole correctly.

Here is a test fit.

Once I was happy with a tight fit, I installed the gnomon, which is a 1/16" brass wire.

Finally, I put a single nail to join the two pieces.

And installed the completed sundial in the garden!

Fluidyne experiments

A fluidyne is a piston-driving heat engine whose only moving part consists of a column of fluid (usually water).  It is a kind of Stirling engine, and it seemed like a neat idea to try to make.  The initial design was invented by C. West, and is described in a nicely written report.

Rather than starting with the "easy" standard design, I tried making a 3-piston version described later in West's report, after describing his initial design.  Here's my rendition.

I did some analysis of this design.  My model sets a displacement for each piston (water column) and temperature for each cylinder (air column).  Half of each cylinder is hot, and half is cold.  The engine is driven into oscillation because the cylinder isn't centered between these two sides, so sometimes it's heating and sometimes it's cooling.  The weight of the pistons acts as restoring force, so assuming they're all of the same length, they have the same resonant frequency.  Surprisingly, the cross sectional area of the cylinders and the length of the cylinders doesn't matter in the analysis.

Here is a typical plot of running frequency as a function of the length of the pistons and temperature difference. 

The engine seems to stall below a certain temperature difference between hot and cold sides, and the stall temperature depends strongly on the coefficient of temperature flow into/out of the cylinders.

The way the engine is supposed to run is that you point a heat gun at the three copper tubes on one side.  These are the hot sides of the cylinders, while the others are cold.

The sad part is that while this engine runs beautifully in theory, I could not get mine to start.  Keeping the temperature of all cylinders the same is critical or the pistons get out of order, and even with that managed, it never started. 

Just to verify that I wasn't completely crazy, I decided to modify the plumbing to make a more standard single piston machine.

I didn't do the analysis of this engine, but it also seemed very unwilling to run unless I flooded the hot cylinders with the pistons. 

Under this condition, the tops of the pistons boiled, which raised the pressure substantially.  Since the water vapor then condensed on the other (cold) side, the piston didn't boil away completely! 

Just to make sure that the fluidyne plumbing wasn't superfluous, I disconnected the plumbing and flooded the hot cylinder on its own. 

Here is a video of this test. 

You can see the top surface of the cold side of the piston oscillating slightly, but much less than when plumbed.  So the fluidyne was "running", even though the boiling seemed very wrong, at least from the original report's description.

However, at this point I recalled reading a rather different design by Morris Dovey.  He described a simple prototype that seemed worth trying, at least by modifying the materials I had at hand.  Although he claims that his design does not depend on resonant frequencies to run, that is dubious at best.  Forced or loaded resonances can vary a bit from their natural frequencies anyway.

I disconnected most of the pipes, added the cold cylinder just hanging off to the side of the hot cylinder, and plugged the cold cylinder with a small screwdriver.

This machine really runs!

It even (sometimes) starts nicely...

But I ran into temperature problems all around, as the clear vinyl tubing is not really able to take the heat from the heat gun.  After a minute or so of running, the tubing invariably springs a leak and the machine stops.

I tried flipping the positions of the hot and cold cylinders -- basically just plugging the end of the hot cylinder and leaving a big air bubble below it -- but this did not work.  I have not done the analysis of Dovey's design to get a more analytical handle on its operating regimes, but it is still definitely a resonant device.  You can feel it try to start running once the heat is sufficient, which is a sure sign that there's a forced resonance.

Misadventures with an ESP-01 board (ESP8266 wifi module)

To add wifi capability to an electronics project, the ESP8266 chip is apparently a popular choice.  It is a microcontroller with a wireless ethernet stack built in.  We got three ESP-01 boards that feature this chip, an antenna, and some flash memory (1 MB).  They are very small!

The tutorials on this board are generally quite confusing, as you can incorporate it easily into a project of your choosing in many ways.  Many makers are familiar with the Arduino platform and are comfortable with its development tools, even though this isn't entirely necessary.  Also, there appears to be a tradition of "hello world = flashing LED" tutorials for Arduino.  This tradition extends to ESP-01 boards in a somewhat unfortunate way. 

The ESP-01 board ships with an old-school Hayes-modem "AT" command interface.  It talks to a host via serial at 115200 baud out of the box -- though with 3.3 V signaling instead of 5 V or RS-232 levels.  (Nearly everyone warns you that 5 V will kill the device, but that actually seems a bit suspect.  I imagine RS-232 levels would really toast it, though!)  In any case, if you hook up a serial terminal, you can talk AT commands and pretty easily connect the board to a nearby access point.  The commands are

AT+CWMODE_CUR=3
AT+CWJAP_CUR="<ssid>","<pwd>"

If you want to see what access points are visible, use

AT+CWMODE_CUR=3
AT+CWLAP

If you want to see what IP you've been assigned once connected, use

AT+CIFSR

The documentation for all the commands is located here. a nice short listing of commands is here.  It's essentially like a cross between old-school modem commands and sockets programming.

Since modern computers don't have a hardware serial port (and most old hardware serial ports don't support 115200 baud), you typically use a USB-to-serial converter.  There are many of these available -- I have several -- but for a quick hack you can coerce an Arduino into helping.  Actually, "coerce" is the right word, because what you do is hold the Arduino in a reset state (it's effectively disabled) while you hijack its USB-to-serial chip.  Here's the circuit that I used.  The resistors form a voltage divider that brings the Arduino's 5 V signaling down to 3.3 ish volts.  (It didn't make much of a difference when I hooked the RX lines directly together, though that is apparently ill-advised...) 

Since I am using an Arduino Mega held in reset, it seems that plenty of 3.3 V is available for the ESP-01, contrary to the many tutorials warning that a separate power supply is required.  I imagine you might have problems if you allow the Arduino to boot up.

OK, back to the unfortunate part of the story.  Since the tradition is to make an LED flash as your first project, there are many tutorials explaining how to make an ESP8266 flash an LED.  This involves -- naturally enough -- overwriting the flash memory with a program that simply toggles one of the GPIO pins.  However, this means that the modem firmware gets overwritten!  If you're a newbie (or even if you're not), this means that the ESP-01 board is now useless as a wifi dongle!  Putting the original firmware back is not exactly a trivial task.

I was faced with the task of reflashing 2 of the 3 ESP-01 boards we have.  (The remaining one was fortunately unharmed, so I was able to figure out how it was supposed to work!)

First of all, you need special software that understands how to flash memory on the board with the ESP8266 chip.  Fortunately, the right tool for the job is an open source python script esptool which has minimal dependencies.  Starting this up was no problem, and I started by re-using my existing circuit.  I figured that I would start by clearing the flash memory, since I already knew it to be useless...

$ python esptool.py --port /dev/ttyACM0 erase_flash

Sadly, this just hung while "connecting".  I hooked up my logic analyzer to the TX and RX lines, and was able to verify that data was getting transferred, so it looked like the chip was merely ignoring the commands.  After digging some more, I found that the right course of action was to ground the GPIO0 pin first.  This puts the ESP8266 chip into a "flash mode", which is required for programming it.  To start programming, you briefly pulse the RST pin to ground to reset the chip.  Then it happily started flashing the memory, or so I thought. 

However, as it turns out my board has a flash chip that doesn't like the default SPI settings.  Unfortunately, they appear to work just fine, and the files I flashed even verify correctly through esptool.  But they are wrong!  There are some dark words in Amazon reviews for the ESP-01 about defective boards, but that didn't seem to add up.  The boards were indeed talking -- I could watch the data transfer both directions on my logic analyzer -- so I didn't think they were defective. 

After a bit more poking, I found the solution.  The problem is that the default setting in epstool optimizes runtime, using the fastest protocol to write the flash.  Apparently this isn't supported by all flash chips, and it silently causes problems with some of them.  There's a detailed explanation of what's going on in the esptool documentation and on the Wikipedia page for the Serial Peripheral Interface. 

OK.

Let's flash the board correctly!

You can use the stock firmware, by following detailed instructions about the flash map in their documentation.  But there is also an enhanced version of the firmware that adds a few additional AT commands.  It's a little easier to flash the enhanced version since it's all in one contiguous block starting at address 0x00000 rather than several separate files flashed into different addresses, which is how the stock firmware is distributed.  In any case, the command to do the job is

$ python esptool.py --port /dev/ttyACM0 write_flash 0x00000 AiThinker_ESP8266_DIO_8M_8M_20160615_V1.5.4.bin --flash_mode dout

This set things right, and the boards once again respond to AT commands!

Morse code trainer

This is a quick weekend project.  I wanted something that would send random strings of characters in Morse code, grouped into sets of 3 or 4 at at time.  This little box has a power switch, a speaker, a knob for volume, and a knob for sending speed.  It's powered by a 9v battery, and is controlled by an Arduino Nano.  There's really not much else to it except for the code.

Violin sound pin setting tool

The sound pin in Zachary's violin was inadvertently knocked over.  There's a tool for fixing this problem, and it is not expensive.  However, it was also not available on short notice, so I made one.

The tool is a 1/8" steel rod set in a handle of rosewood.  To make the tip, I hammered the end of the rod into a spade shape, hardened it, and then ground it to a sharp flat blade.  I then bent the rod to fit the shape of the violin, which is a standard 4/4 size.  Afterwards, I polished the rod, oiled it slightly, and set it in the handle.  The handle was a short segment of a hard rose cane I had taken during pruning, and was shaped on the belt sander.

To use the tool, stab the sharp end into the sound pin (grainwise), carefully thread the pin and tool through the F-hole, and then carefully upright the pin just below the treble foot of the bridge. This took me a few tries, but it wasn't too demanding.  Just make sure the bridge is already mostly in place with the strings just barely tightened before you begin, otherwise uprighting the bridge will surely topple the sound pin. 

Clock 4 now runs with intermittent impulsing

"Intermittent" can be a problem, but not in this case!  Based on the numerous power budget calculations I've done, impulsing the pendulum in Clock 4 every minute is too much to ask.  After having gotten the escapement to impulse every period (2 seconds) reliably, with run times around 8 hours, it seemed like the right time to go back to trying to get the intermittent part working again.  Especially, the run times without intermittent escaping were limited by drive cord length -- I had a four fall pulley in place for the clock to run that long. 

Therefore, I added more deep cuts to the count wheel, now five in total.

This means that the escapement should be triggered every 30/5 = 6 pendulum periods, or every 12 seconds.  The pin wheel has 30 pins, so will then have a period of 12 seconds * 30 = 360 seconds = 6 minutes.  The pin wheel is driven through a 1:10 mesh for the drive wheel, so it should make a rotation every hour.  I can therefore drive the minute hand from the drive wheel, although it will run counter clockwise.

With some tuning, the Clock 4 runs with 8 lb of drive weight, directly driving a barrel of 1.2 inches.  The clock's run isn't perfect, as (1) the count wheel double counts immediately following an impulse and (2) sometimes this double-counting skips over an impulse.

But given these issues, Theodore measures the following periods in current configuration:

• 53 seconds for the count wheel

• 4 minutes 24 seconds for pin wheel

Given these measurements the drive barrel will make one rotation about every 44 minutes.  In that time, the weight will have dropped 3.7 inches. 

Thus the power consumed is:

3.7 inches / (12 in/ft)  * 8 lb / (44 min * (60 s/min)) = 9.4 * 10^(-4) ft lb / s = 1.28 mW