Category Archives: Astrophotography

Building a barn door mount, part 5: the finished device

Part 1, part 2, part 3 and part 4 of this series consider the electrical circuit construction, mathematics behind the drive mechanism, the control software code and construction diagrams. At this stage readers are probably wondering if the finished device will ever appear. This final part will answer that question via a short picture gallery.

Mount in closed position

To begin with consider a picture of the complete barn door mount in the initial closed position. This shows how it is attached to the tripod below the mount and how the camera connects above the mount. The power supply cable to the electronic control circuit box can also be seen
Barn door, closed position

Tripod head mounting

In the construction diagrams it was explained that the tripod head could not be attached directly to the upper panel of the mount. The adjustment handle for the tripod head needs to be able to rotate through 360 degrees. It was sufficient to place two small panels of wood beneath the tripod head to raise it up. The primary bolt going into the base of the tripod head is thus concealed inside the lower panel.
Tripod head mounting

Tripod captive nut

In the lower panel of the mount there is a captive nut embedded in the wood. A captive nut has three spikes which stick into the wood and prevent it from turning or otherwise coming loose. It is embedded in the panel from above so that the force exerted by the coupling to the tripod is actually pulling the nut into the wood. A good amount of epoxy resin ensures there’s absolutely no chance of this nut coming loose, which is good because it takes the entire load of the mount and camera.

Captive nut and tripod

Panel hinges

The two primary panels of the mount are connected with a piece of continuous “piano” hinge. Using a single continuous hinge rather than a couple of separate hinges avoids the problem of having to accurately align the two separate hinges.
Primary panel hinge

Threaded rod nut

The threaded rod passes through the pivoting part of the top panel. A small nut is recessed into this top panel and held in place with some epoxy resin. Care had to be taken to not get any epoxy on the thread of the embedded nut as that would have totally ruined the ability of the threaded rod to smoothly screw into it
Threaded rod and nut

Motor shaft flexible coupling

The pivoting part of the bottom panel has the motor attached. To enable the mount to be completely closed, the motor shaft and flexible coupling had to be recessed. This picture shows the flexible coupling attached to the motor shaft. The end of the threaded rod was squared off so that it can just slot into the coupling whereupon it is held by the tiny screws in the coupling. This makes it easy to remove the threaded rod when the mount is not in use.
Motor shaft flexible coupling

Motor mounting

As mentioned earlier, to allow the mount to be completely closed the motor shaft needs to be recessed slightly. Thus two small panels are added to the pivoting panel, attached with short bolts and thumbscrews. The holes through which the bolts pass are rectangular so that they panels can be adjusted horizontally to ensure the motor shaft can be accurately aligned with the pivot hinges. Also seen on the left is the edge of the electronic circuit box with two small switches sticking out. Through a bit of poor planning there was barely sufficient clearance for the switches with the box mounted in this location.
Stepper motor mounting

Pivot panel hinge blocks

The movable panels to which the motor and threaded rod are attached need to pivot smoothly as the mount opens. After a prolonged period of indecision the final approach was to make use of some simple plastic furniture fixing blocks. These are attached to both panels and then connected with a small bolt. Two plastics washers keep them separated to the requisite degree and ensure they can move with minimal friction.

Pivoting panel blocks

Pivoting motor panel

A further view of the pivoting motor panel from below
Stepper motor mounting panel

Threaded rod and motor

As the two primary panels open the two pivoting panels should remain parallel to each other as seen in this image. If they don’t remain parallel this indicates that the hinges and / or threaded rod were not correctly aligned with each other.
Pivoting panels and threaded rod

Electronic control box

The electronic control box had two strips of velcro attached to its lid, which are used to stick it to the mount, a simple but reasonably effective attachment.
Electronic control box

Mount from below

Viewed from below it is possible to see the tripod plate attached to the mount, the other velcro strips to which the control box is stuck and finally the pivoting motor panel
Mount viewed from below

Mount in open position

Finally to remind ourselves what the complete mount looks like, consider the mount in a partially open position, as it would be after tracking for 30 minutes or so.

Barn door, open positionThoughts on the construction & design

The more observant readers may have noticed something missing on the mount, specifically a means of aligning it with Polaris. Some people suggest it is possible to align by just visually sighting along the continuous hinge. It only takes one attempt to determine that this is a really unsatisfactory approach. An alternative idea is to attach a green laser pointer to the mount, aligned parallel with the hinge. This would certainly make it easier to visually align with Polaris but unfortunately living near the flight path into Heathrow airport means use of laser pointers is a pretty bad idea in general. Probably the better idea is to get a small gun sight or a red dot finder or some small finder scope. Thus far though I’ve not decided on which solution to go for. Since a big motivation for building a barn door is to keep the costs low, this needs to be taken into account when choosing an alignment method, lest it double the price of the parts !

As mentioned earlier, a mistake was made in positioning the captive nut used to attach the mount to the tripod, which left insufficient clearance for mounting the electronics control box. Also the positioning of the switches, power socket & USB socket on the electronics box was really poorly chosen. They should have all been positioned on the short edges of the box, rather than on the long edges.

The coupling of the motor shaft to the threaded rod was not entirely satisfactory. A flexible coupling seemed like a good idea to avoid undue stress on the apparatus, but in the event there is actually too much flexing in the coupling which means that the pivoting panels don’t always stay parallel to each other as the threaded rod rotates. A rigid coupling of the threaded rod & motor shaft would probably have worked better. As a hack I might attempt to bind the flexible coupling in tape and/or glue to make it less flexible and reduce the wobble in the panels.

Overall the project took a bit longer to complete than anticipated and cost more than is really necessary to build an effective barn door, due to cost of the electronics. As a person commenting on an earlier part in this series says, using a threaded rod would provide a much simpler design which could be powered with a simple fixed rate motor and no need for the arduino. A large part of the motivation (and fun) of the whole enterprise though was to actually learn about arduino programming and electrical circuit construction. In this respect it has been a very successful project, even if overkill for a barndoor. The arduino also has the capability to be used to correct for construction errors, meaning it was not necessary to be too accurate with the measuring of the mount, and could be extended in future to also automate triggering of the camera shutter for specific time periods.

Unfortunately a combination of other life commitments, awful weather in the first part of the year and heavy light pollution mean that I’ve not had much opportunity to actually use the completed barn door mount yet. It has just had a few simple tests to check that the electronics and mechanics were working correctly. In these tests I determined that the tripod I have for holding the mount is not very well suited to the job, as it has a head which freely moves in any of the 3 axis of rotation at once. This makes it a really pain to align the mount with Polaris. What is needed is a tripod which allows each of the 3 axis to be adjusted completely independently. As a result of this and lack of a good polar alignment method, it hasn’t been possible to get any decent pictures of the night sky using the mount yet, hence why none are shown here. Hopefully I’ll be able to put this right over the coming months at which point I’ll post them to demonstrate the mount capabilities.

Building a barn door mount, part 3: drive control software

Part 1 and part 2 of this series considered the electrical circuit construction and mathematics behind the drive mechanism respectively. There was a short demonstration of arduino code to drive the motor in part 1 but this did not attempt to do any kind of proper rate tracking since it was awaiting the mathematics in part 2. This part of the series of blog postings will thus consider the actual code required to do accurate rate tracking. For the impatient, the full working code is published under the GPL version 3 or later license at gitorious.

EDIT 2015/7/22: With gitorious going away, the code now lives at gitlab

Since the writing of part 1, a slight change was made to the usage of the two switches. The ON/ON switch, connected to analogue pin 3, is to be used to switch direction of rotation between forwards (moving with the earth’s rotation) and backwards (moving against the earth’s rotation). The ON/OFF/ON switch, connected to analogue pins 4 and 5, is to be used to control the mode of operation between automatic tracking, stopped and non-tracked high-speed. The idea of the latter mode is to allow the mount to be more quickly reset back to the starting position. For convenience the code defines constants for the analogue input and digital output pins based on their intended function

static const int pinOutStep = 9; // Arduino digital pin connected to EasyDriver step
static const int pinOutDirection = 8; // Arduino digital pin connected to EasyDriver direction

static const int pinInAutomatic = 4; // Arduino analogue pin connected to automatic mode switch
static const int pinInManual = 5; // Arduino analogue pin connected to manual mode switch
static const int pinInDirection = 3; // Arduino analogue pin connected to direction switch

The core design concept for the code is to have a finite state machine associated with the ON/OFF/ON switch. Rather than implement the finite state machine concept from scratch, it reuses the existing FiniteStateMachine module. Thus in order to compile the sample code, the ZIP file for this module must be downloaded and imported into the arduino project. The same is true of the AccelStepper library used for motor control. Since the switch has three positions, there are three states in the FSM declared as global variables. When declared, each state is provided with three callbacks, one to be invoked when the state is entered, one invoked on each tick while the state is active and one to be invoked when the state is left.

static State stateAuto = State(state_auto_enter, state_auto_update, state_auto_exit);
static State stateManual = State(state_manual_enter, state_manual_update, state_manual_update);
static State stateOff = State(state_off_enter, state_off_update, state_off_exit);
static FSM barndoor = FSM(stateOff);

The state machine is used to control the operation of the stepper motor object

static AccelStepper motor(AccelStepper::DRIVER,
                          pinOutStep,
                          pinOutDirection);

Off state

Starting off with the simplest, stateOff, there is only one callback that needs any logic in it. When entering the ‘off’ state the motor needs to stop turning:

void state_off_enter(void)
{
    motor.stop();
}

Manual running state

Moving on to the next, stateManual, there is again only one callback that needs any logic in it. On each tick while in this state the motor needs to be told to move a fixed amount in the correct direction. The code arbitrarily uses a speed of 5000 – this can obviously be changed to whatever suits. There is one safety measure built-in, when the mount is running in reverse, it should automatically stop when it gets to the completely closed position. Fortunately the AccelStepper library tracks how far the motor turns, so if we assume the mount was set to the completely closed position when first turned on, it is just a matter of checking whether the motor position is zero. As a future enhancement it would also be desirable to add an upper limit on the position because if the mount opens too far it’ll run off the end of the threaded rod and likely flap open causing any attached camera to bash against the tripod legs.

void state_manual_update(void)
{
    if (analogRead(pinInDirection) < 512) {
        motor.setSpeed(5000);
        motor.runSpeed();
    } else {
        if (motor.currentPosition() == 0) {
            motor.stop();
        } else {
            motor.setSpeed(-5000);
            motor.runSpeed();
        }
    }
}

Automatic tracking state

Finally, stateAuto, requires quite a lot more complicated code in its callbacks. At any given point in the time, the speed at which the threaded rod needs to turn is dependent on how far open the mount is. First of all, the code needs to know the position of the mount when automatic tracking started, bearing in mind there could have been arbitrary movement forwards or backwards when in manual mode. As noted before, the code assumes that the mount is in the completely closed position when the electronics are first powered on, which corresponds to motor step count of 0. Thus when entering the automatic tracking state, the position of the mount can be determined from the total number of motor steps. Given the step count, the mathematics from the previous blog post show how to calculate what this corresponds to in tracking time, so a function is defined to do this conversion:

long usteps_to_time(long usteps)
{
    return (long)(asin(usteps /
         (USTEPS_PER_ROTATION * THREADS_PER_CM * 2.0 * BASE_LEN_CM)) *
        SIDE_REAL_SECS / PI);
}

To record the state of the mount at the time automatic tracking begins, three global variables are defined

static long startPositionUSteps;
static long startPositionSecs;
static long startWallClockSecs;

These are initialized by calling another helper function, which also records the current wallclock time reported by the arduino runtime:

void start_tracking(void)
{
    startPositionUSteps = motor.currentPosition();
    startPositionSecs = usteps_to_time(startPositionUSteps);
    startWallClockSecs = millis() / 1000;
}

With the initial position determined, the next job is to determine the speed to move the mount. Since the tangent errors from the mechanical design are quite small, it is not necessary to change the speed on every tick of the arduino code – calculating in 15 seconds blocks is sufficiently accurate. The target for the next 15 second block will be recorded in three more global variables

static long targetWallClockSecs;
static long targetPositionSecs;
static long targetPositionUSteps;

The target wall clock time is just updated in increments of 15, but the target position tracking time is updated based on the delta between the start and target wall clock time. It would be possible to just update the target position tracking time in increments of 15 too, but by using the wallclock time delta, the code automatically accounts for any execution time overhead of the tracking code itself. A subtle difference, but worth doing. Once the target position tracking time is decided, the mathematics from part 1 once again show how to convert it back into a motor step count with a small helper function:

long time_to_usteps(long tsecs)
{
    return (long)(USTEPS_PER_ROTATION *
                  THREADS_PER_CM * 2.0 * BASE_LEN_CM *
                  sin(tsecs * PI / SIDE_REAL_SECS));
}

The three target variables are all updated by yet another helper function

void plan_tracking(void)
{
    targetWallClockSecs = targetWallClockSecs + 15;
    targetPositionSecs = startPositionSecs + (targetWallClockSecs - startWallClockSecs);
    targetPositionUSteps = time_to_usteps(targetPositionSecs);
}

With all these helper functions defined, it is possible to show what action is performed by the callback when entering the automatic tracking state. Specifically it will record the starting position and then plan the first 15 second block of tracking

void state_auto_enter(void)
{
    start_tracking();
    plan_tracking();
}

Now the automatic tracking state is ready to run, it is necessary to actually turn the motor. This is simply a matter of taking the remaining wall clock time for the current 15 second tracking block and the remaining motor steps to achieve the target position and then setting a constant speed on the motor to accomplish that target. The code to do this will recalculate speed on every tick in order to ensure smooth tracking throughout the 15 second block. Once again a helper function is declared to perform this calculation

void apply_tracking(long currentWallClockSecs)
{
    long timeLeft = targetWallClockSecs - currentWallClockSecs;
    long stepsLeft = targetPositionUSteps - motor.currentPosition();
    float stepsPerSec = (float)stepsLeft / (float)timeLeft;

    motor.setSpeed(stepsPerSec);
    motor.runSpeed();

With this final helper function it is possible to implement the callback for running the automatic tracking state. It simply has to apply the current tracking information and occasionally update the tracking target.

void state_auto_update(void)
{
    long currentWallClockSecs = millis() / 1000;

    if (currentWallClockSecs >= targetWallClockSecs) {
        plan_tracking();
    }

    apply_tracking(currentWallClockSecs);
}

Switching FSM states

With the code for operating each state defined, all that remains is to actually switch between the different states. This is done by writing the arduino main loop function to check the input pins which are connected to the operation switch.

void loop(void)
{
    if (analogRead(pinInAutomatic) < 512) {
        barndoor.transitionTo(stateAuto);
    } else if (analogRead(pinInManual) < 512) {
        barndoor.transitionTo(stateManual);
    } else {
        barndoor.transitionTo(stateOff);
    }

    barndoor.update();
}

Hardware specific constants

The actual speed of tracking depends on various constants that match the physical construction of the barn door mount. There are only 4 parameters that need to be figured out. The stepper motor will have a number of discrete steps to achieve one complete rotation. The code records this as the number of degrees per step, so if only the step count is known, simply divide that into 360, eg 360/200 == 1.8. The arduino EasyDriver board for controlling the stepper motor is very clever and can actually move the motors in smaller increments than they are officially designed for, currently 8 micro-steps. The next important parameter is the pitch of the threaded rod, which can be determined by just putting a ruler alongside the rod and counting the number of threads in one centimetre. The final piece of information is the distance between the centre of the hinge joining the two pieces of the mount, and the center of the threaded rod. This should be measured once the actual mount is constructed. All these values are defined in constants at the start of the code

static const float STEP_SIZE_DEG = 1.8;
static const float MICRO_STEPS = 8;
static const float THREADS_PER_CM = 8;
static const float BASE_LEN_CM = 30.5;

As mentioned earlier, all the code snippets shown in this blog post are taken from the complete functioning code available under the GPL version 3 or later license at gitorious. With that code compiled and uploaded to the arduino, the electronics are completed. The final part(s) of this blog series will thus focus on the mechanical construction of the mount.

Now read: part 4, construction diagrams.

Building a barn door mount, part 4: construction diagrams

Part 1, part 2 and part 3 of this series consider the electrical circuit construction, mathematics behind the drive mechanism, and the control software code. In this post it is time to consider the physical construction of the barn door mount. The logical diagram from part 1 should give a good idea of what the mechanical design will look like, so without further ado lets look at a set of diagrams that reflect the physical construction design that was actually done

First, looking at the top panel of the mount from above. On the right hand side of the panel, a square section was cut out and then re-attached to the main panel with a pair of pivots. These were actually furniture fixing blocks connected by a bolt and with nylon washers to act as spacers  between. In the center of the cut out is an M8 threaded nut, glued in place with epoxy resin, through which the threaded rod will rotate during operation. The alignment of the pivoting hinge and thread nut is crucial to allowing the cut out panel to pivot correctly. On the left hand side of the main panel is the tripod head for attaching the camera to the mount

Top panel from aboveThe tripod head attachment is better seen from the side view of the top panel. The tripod head could not be mounted directly to the main panel, because that would not allow sufficient clearance for the handle to be turned. So two small wooden panels were cut to raise the tripod head a couple of centimetres up from the panel. The tripod head is bolted to one of these small panels with a 3/8″ bolt, and both panels are then bolted down to the main panel using 3 bolts and wing nuts for easy release.

Top panel from side

Moving on to the bottom panel, as viewed from below. Again there is a square cut out panel attached to the main panel with a pair of pivoted bolts. On the left hand side there is a hole in which a 1/4″ captive nut is glued in place from above using epoxy resin. When the tripod is attached it will thus be trying to pull the capture nut through the board which is impossible, thus ensuring a strong connection. This is critical, because the entire weight / torsional load of the barn door mount will be on this captive nut. The pivoting panel has the stepper motor attached to it. The stepper motor is connected to the threaded rod using a flexible coupling nut. To enable the top and bottom panel to get to the 100% closed position, the coupling needs to be recessed somewhat, so the motor is not attached directly to the pivoting panel.

Bottom panel from below

The side view of the bottom panel shows the motor attachment more clearly. Two smaller pieces of wood are used as spacers, to which the stepper motor is attached using M3 machine bolts. These spacers are then attached to the main pivoting panel with a pair of M6 bolts and wing nuts for easy release.

Bottom panel from side

Finally, a length of continuous “piano hinge” is used to connect the top and bottom panels together on the left hand edge. The top and bottom panels are approx 35cm by 18cm each, and using 12mm thick plywood. The pivoting panels are approx 12cm square cut-outs. As noted in previous blog posts the exact dimensions aren’t critical, since the control software can be tuned to rotate at whatever rate is required for the final build dimensions.

The parts list for the construction was

  • Tripod head. (used a cheap Chinese Manfrotto knock-off “Manbilly”)
  • 1/4″ captive nut (to accept primary tripod in bottom panel)
  • 3/8″ bolt (to connect tripod head on top panel)
  • M6 machine screws (x2 for motor panel, x4 for pivot hinges and x3 for tripod head panel)
  • M6 wing-nuts (x2 for motor panel, x3 for tripod head panel)
  • M6 nuts (x4 for pivot hinges)
  • M6 nylon washers (x4 for pivot hinges)
  • M8 threaded rod 35cm length
  • M5xM8 flexible coupling (5mm x 8mm – see part 1)
  • Sheet of plywood (approx 100cm x 50cm x 12mm)

The cost of these parts will vary depending on what you’ve got handy in your toolbox already and whether you have a cheap DIY store locally. The most expensive part was the tripod head, hence why I used a cheap knockoff. The nuts & bolts were just a few pounds and the sheet of plywood was an off-cut from the local DIY store obtained for just a few pounds too.

Now read: part 5, the finished device.