Round clocks are so 20th century! Here's something a bit more post modern and obtuse.

I'll be showing you here another full design project, from idea to design to prototype. The object of our desire today is a linear clock, that is, one that has numerals arranged in a line rather than in a circle, and it'll fit very nicely into many homes and workplaces.

This is a working design process and this instructable will document the whole of it from beginning to end. I hope one day to market and produce the clock, but all the plans and parts are available to download or take from here, in case you'd prefer to do it yourself, or you can make an improved version.

The actual build (starting at step 3) shows an easy to make version, that uses a set of simple parts, and this is my prototype clock. It's the clock I assembled as a proof of concept. It's simple enough that you can probably put it together in an evening if you have the right bits, and substantial and useful enough to be worth spending time on. It uses easy to find parts, doesn't destroy them in the process, and doesn't require anything that's special. It is also forgiving of sloppy production.

Step 15 introduces a few experiments with refinements, and settles on a design.  This is really an instructable about design and prototyping.  I think that's interesting, so maybe you do too!

Step 1: Design Considerations and Background

Clocks are intriguing. Each one is an intoxicating concoction of machinery, engineering, mathematics, geometry and social programming.  They are complex in theory, yet effortless to interpret, and the various patterns and shapes made up by either the hands or the digits have significances that are personal to all of us.

I like an analogue clock.  For telling the time (I mean, as opposed to seeing how long to boil an egg) I think an analogue face more satisfyingly describes the nature of time.  The experience of time is such an elastic and personal thing, and an analogue face is more open to interpretation.

The are almost always round, however, and for designers, the clock is usually a fairly abstract graphical exercise in styling. I have always been interested in different analogues for time, other than the round face with the sweeping pointers erupting from a central spindle.  I like the idea that time can be measured with another kind of metamorphosis is appealing.  Maybe an object will change shape over the course of a day, or a balloon will be against the ceiling in the morning and gradually sink throughout the day.  Make it fall past a scale drawn on the wall and you have a rather elaborate clock.  Do without the scale on the wall, and the assembly still tells the time, but it is harder to be precise, and what metric exactly the device is showing becomes less obvious.  Sand timers and water clocks are the most common non-conventional clocks.  They suffer from a lack of precision in reading.

Step 2: Development - How It's Supposed to Go

Here's a selection of pages from my sketchbooks, showing the development of the design.  I actually spent a long time at an impasse, because there are so many different ways to make this work.

I gave myself a brief featuring the following MUSTs:
  • Low power - ideally no trailing wires / battery
  • Cheap enough to fit into a mainstream boutique's retail price range.
  • Same mechanism able to run horizontally or vertically.
  • Silent when not moving.
  • Lightweight - does not require special wall fixings.
  • Aesthetically neutral - open to styling and colour/material choices

I hummed and hawwed for so long, and eventually settled on a fairly simple mechanical design that uses a small solenoid as a latch to regulate the turning of a spring-loaded, snail-shaped cam.  This would be the driving input to the gear train that moves the indicators.

The timing source itself was to be made from a quartz clock movement - the part that sends a pulse every second.  There are lots of fancy-dan electronic solutions for this, with realtime clock ICs and radio clocks and things, but I went for a simple approach.  This keeps initial costs down, and is much more within my own sphere of understanding.

The clock would be battery powered to avoid trailing wires, and this is another reason for choosing a largely spring-driven system - so that high draw sections (solenoid / motors) are mostly turned off, and just needs a pulse every minute.

This is complex to manufacture however, so the design in this instructable is a simplified version using a microprocessor to drive some stepper motors.

Skip to step 15 to see what happened once I'd finished the prototype.

Step 3: The Final Design

The concept for this clock is that it uses the physical and graphical design vocabulary we instinctively understand and accept, but not in a configuration that we are familiar with. I hope to create an object that doesn't at first appear to be a clock, but could not conceivably be anything else but. It has all the properties of a standard analogue timekeeper (hands, numerals), but it is distorted into a shape that is surprising. It begs a question ("what happens when the hands reach the end?") and answers it in a very satisfying way.

It also doesn't look odd. I'm looking to make it complement a mainstream contemporary home, so it uses the colours and materials that are found there. The shape is unusual though, and brings to mind the illuminated slot and roving indicator of a manual radio tuning dial. In it's vertical form it makes me think of barometers or thermometers or other scientific equipment that makes it into the home.

Horizontally, it could stand alone hung on a wall, or more like, be used as a shelve or mantle-piece replacement. Turned vertically it is harder to place because we human beans are a lot less tuned to looking up and down than we are to looking from side to side. Vertically it needs a more sparse setting with a wall that's got a lot of vertical space available.

Step 4: Prototype Version - Introduction and Parts List

However, on my way to a finished design on paper, I was also constructing a prototype using parts I already had, to help test some ideas.

The purpose of this prototype is to get something working as quickly as possible.  Building the prototype will give me some good ideas about the complexity of the build and the length of time required.  This in turn gives me some pointers about how many different versions I have time to test.

This is how I made my prototype, and the things you'll need to cobble this together.  I used this set of pieces because it's what I came across first.  Other kinds will certainly work too.

  • I used foam core board (sometimes called kappaboard) to make my prototype.  It's light, glues easily, and is stiff and strong.  It's also easy to cut and not messy. Corrugated cardboard will also work handsomely.

The running gear:
  • 2x Curtain rails - I got a PVC one from John Lewis' for £7 ($11).  You need two pieces, each as long as you want your clock to be.  My prototype was 62.5cm long because I used a 125cm curtain rail sawn in two.
  • 4x sewing machine bobbins for the driving wheels - plastic ones are easier to work with, and cheaper.
  • 2x Pulleys for the non-driving end of the clock - I used these little pulley blocks I had, but sewing machine bobbins would be just as good probably.
  • Thread that is thick enough to be controllable, some thin elastic cord, some bits of balsa sheet or other light, thin, strong sheet that will slide OK in the channel of the curtain rail.

The brains:
  • Arduino with Adafruit Motorshield - This is definitely overkill, and I used this simply because I already had it and it works admirably. The stepping circuit on it's own is not complicated and if you have an Arduino compatible board that isn't otherwise gainfully employed, then it's quite easy to whip up a circuit using L293 ICs on breadboard that will drive a couple of stepper motors. Look at Tom Igoe's stepper pages, for circuits for driving steppers from an arduino. However, what the Motorshield gives is a good quality library that allows you to turn the motors off entirely. The simpler circuit does not do this so easily.
  • The logic/timing part of the code would be the same for all versions, but the interfacing code will be a little different.
  • Any Arduino compatible board will work fine as far as I know.
  • 2x Stepper motors.  I tested this will some dead cheap little steppers (referred to here) that have almost no torque and only 20 steps per revolution.  I paid next to nothing for them.  I also made a version with some good quality NEMA17 steppers with 400 steps per revolution.  I paid about £14 for each of those and they weighed a pound each. I ended up using the cheap small steppers.
  • In the Arduino code, modify the value "stepsPerRevolution" to reflect the kind of motor you have.
  • You'll also need a 6-9v DC power supply to run your microprocessor (arduino) when it's not tethered to the PC.

  • Knives mostly.  Foamcore has a tendency to "crumb" if you don't have a really sharp knife, so use a fresh, long blade and always make sure the blade is moving through the foamcore using a sawing, or slicing action rather than cleaving or chopping.
  • Adhesives - I've used anything I had around.  Superglue, hot melt glue, contact adhesive and gummed brown paper tape.
  • Soldering stuff, or screw terminals, and wire.

Step 5: Prototype Version - Assemble the Chassis

I'm making my clock face 10cm wide, so I've cut some panels of foamcore to size (100mm wide), and glued the curtain track onto them  The length isn't important - these ones are only this size because that's the longest sheet I had to cut them from  The gap in the middle isn't significant.  The glue I used is general purpose contact adhesive ("UHU All Purpose Adhesive") which sticks the PVC curtain track as well as anything does.  It does dissolve the polystyrene core of the foamcore board though, so be careful when you use it on the edges of boards.

Stick the edges of the track onto the faces of the board for best results.  Before glueing, make sure the tracks are straight, and bend them straight if they aren't.  Also cut some rectangles to fit in between the rails, to help them stay straight and to allow you to put some clamps (ie elastic bands) around while the glue dries.  Run your beads of glue along the card edges so as not to melt the foam too much.

Step 6: Prototype Version - Driving Bobbins

Stick two of the sewing bobbins together (faces keyed with sandpaper and then superglued): In operation, one of these will wind thread up, the other will let it out.  You might think that using just one bobbin, or a longer bobbin will work just as well, and you might be right.  A problem will occur when the two lines become crossed over each other however, and I wanted things to run as smoothly as possible.

Figure out a way to mount the bobbins directly to the shaft of your stepper.  I was lucky because my stepper has a little brass collar that fits exactly into the bobbin, and centres it right away.  I filled the core with hot melt glue and jammed it on.  Epoxy putty would be a solution for a stronger bond.   Remember to leave a little gap between the body of the motor and the bobbin so it turns freely - the thickness of a couple of sheets of paper would be enough, and you can draw a target on the paper to help centre the bobbins.

Wind a piece of thread a fair bit longer than your clock onto each bobbin, in opposite directions, keep the ends safe with a bit of blu tack.  You'll trim them to length later.

Step 7: Prototype Version - Mounting Motors

Line up your bobbin stack against the end of your chassis - you should arrange it so that a piece of thread wound around the top bobbin will cleanly enter the slot in your curtain rail.  It shouldn't touch the sides at all.

The thread will travel all the way down the slot, wrap around another idler wheel at the end, and then come back up and get wound onto the opposite side of the bobbin stack.

You'd be right to spot that this is a complicated way of making a loop.  If you have something with teeth (chain, timing belts) and the associated sprocketry, then you could use it instead.  I experimented with bead chain (like for winding roller blinds), but it was a little heavy and inflexible for these little stepper motors that I'm using.

So make a bracket to hold the motors.  Mine are small, and light, so are just friction-fit into two holes.  This has the benefit of leaving a bit of wiggle room, but has the problem of being easily pulled out of position by other forces (ie dropping it on the floor).  Use a knife with a long blade and a sawing action to cut intricate or internal shapes in foamcore board.

Step 8: Prototype Version - Idlers

There needs to be an idler wheel (non-powered pulley wheel) on the other end of the clock. This should be positioned so that one side is ready to receive the thread from the centre of the channel in the curtain rail.  So the thread will exit the driving bobbin, travel directly through the channel without touching the sides, and then cleanly wrap around the idler wheel.

The position of the return side of the thread isn't that important, except that it needs to have an unobstructed path through the whole length of the clock, and be able to cleanly wind around the take up bobbin.  I had to cut a few sections of my internal supports out to clear the path.

The angle I have these little pulley sheaves at is nothing special.  It might seem nice to have your thread loops travelling through both channels in the rail, one up and one down.  Well, it would be nice, you're right, but it'll also be a pain, and there is no advantage gained.

Step 9: Prototype Clock - Carriage and Indicators

Make a little sled out of balsa wood with two legs, to slide along the curtain rail.  Cut a notch in one of the legs to fasten the thread through, and that's that.  I made mine actually in the rail itself, rather than trying to make it, and then fit it in.  Though I admit I did slide it out once the glue had dried to butcher it a to get the next step to work...

Eventually you'll cut a couple of bits of cardboard or something to use as the pointers.

Now, the next bit is good, but needs a bit of skill and judgement.

Step 10: Prototype Clock - Threading!

The diameter of the driving bobbin changes depending on how much thread is on the bobbin - as more gets wound on then it gets thicker, and so the linear step size gets longer - that is, each step winds in more thread than the one before (because the thread is building up). In practice this means that the loop of thread gets slightly tighter as either one of the bobbins gets full.

To compensate for this variation (which is not big, but big enough to cause a problem), the two sides of the thread loop are joined by a piece of elastic. This puts enough tension on the thread to keep it in the groove while it's at it's most loose, and has enough stretch to take the strain when it's tight.

This is fiddly, and I did it like in the pictures:
  1. Make sure there is one full loops-worth of thread on each bobbin.  That is, each bobbin should have enough thread to stretch from the bobbin, round the idler, then up to the other bobbin.  Trim the thread so both sides are the same length.
  2. Wind half of the thread back onto the bobbin.  Leave the ends stretched out through there normal route - the ends should meet at the idler.
  3. Hold both ends in pinched fingers and move them along the length of the clock, winding the thread on and off the power bobbins, feeling how much difference in tension there is between the extremes and the centre of the travel.  This will give you an idea of how tight your elastic can be.  If there's hardly any difference (thin thread, or no overlap), then you don't need to leave much slack.  If there's lots of difference (thick thread/cord, lots of overlap) then you'll need plenty of slack.
  4. Tie inch long loops in both ends of the thread. The two pieces of thread should no longer meet. Cut a piece of elastic long enough to bridge the gap between both loops and tie a knot in one end.
  5. Tie one end of the elastic to the thread coming up from the idler (from the takeup bobbin).
  6. Move the thread through the clock again to see where the loose loop of thread needs to be tied to the elastic.  Tie a knot in the elastic, and then loop the thread onto it.  I hedged my bets (in the photos) by making a couple of knots so I could try different tensions easily. 
  7. The knot in the elastic should be enough of a kink to engage with the slot you cut in your little carriage.  You could glue it if you wanted, but I found that once the knot was tucked into the channel, it stayed put anyway.

Step 11: Prototype Version - Electronic Bits

Arduino Duemilanove board and an Adafruit Motorshield. Usually it's not recommended to use the same power supply for the motors as for the Arduino, but in this case the motors are so weedy that they don't draw much power anyway, so I've just set the jumper on the motorshield to use the arduino power supply.

It's straightforward.  I made some extension cables with some 4-pin headers because the steppers I have happen to already have little connectors fitted, and the wires on them are tiny and fragile anyway.

I can't give a good introduction to steppers here (not just because I don't know much about it myself), but roughly put:  Each stepper has two coils in it, and pulsing these two coils in a particular sequence and polarity (four steps) makes the rotor turn in a particular direction.  The two coils are separate in a bipolar stepper like I'm using, so I have four wires coming out of the motor.  (Actually I have five, because these are weird, but I just cut one of them.)  The exact motors I have here are the very same kind described in outstanding detail in this brilliant instructable.

Two of the wires will be connected to one of the coils, and the other two will be connected to the other coil.  Use a multimeter to check for continuity to figure out which.  Then connect one pair to output terminal 1 and 2 of one of the motorshield ports, and the other pair to 4 and 5. Unless you know the pinouts of your stepper, you might have got it right, or you might have the polarity of one of the coils switched. http://digital.ni.com/public.nsf/allkb/0AEE7B9AD4B3E04186256ACE005D833B has a little guide about it.

To test the program without having to wait a minute between each physical tick, change the millisPerSecond value in the program to 200  - this will run five times faster than usual.  You can also change stepSize which will modify how many steps the motor takes per tick.

Step 12: Prototype Version - Software

The software isn't complicated, but make sure you have the most recent version of Adafruit's own Motorshield driver.  There's a fix in it that is important for this code.

The code:
There is an internal time representation, consisting of three ints: currentSeconds, currentMinutes and currentHours.  This time is pre-set at start up and incremented while the program runs.

The main loop of the program makes a note of the start time, then continuously checks the current time to see if it's 1000 milliseconds later or not.  If it is, then it increments the internal clock time (doTick()) and hits a procedure to change the position of the indicators on the clock (renderTime()).

The procedure doTick() deals with incrementing seconds into minutes, and minutes into hours, and resetting those values when necessary.

The procedure renderTime() deals with converting the time in H:M:S into positions on the clock face, or more correctly, positions of the stepper.  The program has a concept of the current position of the indicators (preset on startup at 00:00 - the far left position), and uses this initial start position to decide whether to move the stepper forwards or backwards.

Using the internal time keeping of the Arduino is fairly dodgy ground (see this instructable for a good run down on why, and a possible solution).  There's lots of ways round this if it's important: The main Arduino pages have a few ways to make it accurate, as well as stuff about using the Time library.  I went for a more simple solution, given that it's a prototype (yes, that is my excuse for every time I make a hack).

I am using the AFMotor library for driving the steppers, because I am using the Adafruit motorshield.  If you run the steppers through another circuit, you can probably use the regular Arduino stepper libraries with minimal code chopping.  If you download the code, the file should be saved with a .pde on the end.  Not sure how to change the filename on instructables!

Step 13: Prototype Clock - Software Adaptations

Your stepper motors will be different to mine. To adapt it to your particular stepper motor, you should:

1. Change the statements that declare the motors:

AF_Stepper hourHand(20, 1); // hours
AF_Stepper minuteHand(20, 2); // minutes

at the top, and change the 20 to however many steps your particular motors take to do a full revolution. 200 steps is popular (1.8 degrees per step). If you have no documentation about your stepper, then experimentation is the only way forward, I'm sure you can figure out a way of doing it.

2. Change the stepsPerClock statement:

int stepsPerClock = 592;

This might be complicated, because it depends on the length of your clock, the number of steps per revolution of your motor and the diameter of your bobbins. There is a mathematical way of working it out, but I just measured how far 100 steps moved the carriage, then used that to calculate the total number of steps required to move the full length of the clock. Also remember that you need a bit of space for the carriage, so it doesn't fall out the end of the channel at either end.

3. Change the current time:
The start time is hard-coded in this version. The next version will allow you to increment the time with some buttons attached to the arduino.

int currentSeconds = 0;
int currentMinutes = 55;
int currentHours = 11;

means it's going to set itself to five-to-twelve once it's turned on. Again, there are smarter ways of doing this in the final version, but for this one, this is enough.

I usually set it for a minute in the future, then upload to the arduino and press reset when it's dead on. The pointers are a bit wobbly to notice a minute here or there anyway.

You should manually rewind the indicators back to zero when you reset or turn it on.

4. Change the speed of time!
For testing purposes, I run it five times real-time by setting the line to

int const millisPerSecond = 200;

Real time is 1000 milliseconds per second, so change it to 1000 when you actually want to keep time with it!

Step 14: Prototype Clock - Indicators and Faces and Finish!!

Test it by manually moving the carriages back to the start position (00:00) and then turning it on.  If you are using the Arduino IDE, then you'll be able to see the internal time being counted out using the serial port monitor, and at the turn of the minutes and the hours, then the motors should run and your battle station should be fully operational!

Well, I know it won't be quite that easy, but _that's the theory_!

Print or draw a face, and stick a couple of lightweight cardstock pointers on, and hay presto! Make sure the hands aren't level, or they'll catch on each other as they pass.

At this point you can also tidy it all up and stick some extra bits on so it'll stand up on a surface or can be hung up.  I'm sure it'd be easy enough to make up a case for it too, with the electronics tucked away inside.

Step 15: Towards a Production Model - Reality Check

My initial plans (sketched out in step 2) for the final production model are for a largely spring-driven machine, with a gear train to power both indicators from a single solenoid-actuated time source.

After building the prototype, I looked a bit askance at the extra complexity required by the production model, and decided that that particular battle was one for another day.  I decided to make a more realistic prototype to test a few other mechanisms.

I sawed a 2-metre aluminium curtain rail into two pieces to use for this version. I figured the metal would be more stable, given the longer length. In practice, it didn't make a significant difference. The painted surface was smoother and harder, so there is less friction, but there are parts that are not painted, and the transition between the two zones is rough, and a right pain to try and file smooth.  I'm not sure there's much benefit to using the metal, particularly if it's going to be enclosed anyway.

Step 16: Refinement #1 - Bead Chain Loops

I used bead chain from some roller blinds - they are supplied with a endless loop that is a metre long - that is, there's two metres of cord, forming a loop that is a metre stretched out, perfect for my metre-long bits of curtain rail.

Thing is, the blinds only come with one sprocket, so I modelled another, and had a few 3D printed, along with a couple of brackets, and some little carriages to run in the slots of the rails.  I used http://www.shapeways.com for my prints, but I've included the STLs here if you'd like them.  In an earlier stage of the project I did make a couple of sprockets from balsa.  They actually worked ok, but were predictably irregular.

Actually really pleased with this set up, they look great and were completely snag-free (hurray!).  As I suspected though, they were too heavy for these little motors to move. With a more torquey motor these would be ideal, and I suspect I might end up using them.  Certainly the neatest solution.

Step 17: Refinement #2. Thread and a Friction Drive

I reverted to using a loop of thread, along with my little steppers to get something working, though I tried a drive method using two meshing gears as a way of driving the thread, instead of the double bobbin.  This nicely avoids the problem of the varying bobbin diameter (as the thread layers up).

As with the pulleys, the gears were bought from Rapid. The brass tubes were K&S Metals products, bought from the local hobby shop.

I added a couple of little plastic guides cut from sheet polystyrene to keep the thread in line with the gears.

All very nice, and did work, but unfortunately very touchy.  Being friction-driven there's lots of room for slippage of the drive on the thread.  There's too many variables that can change over the lifetime of the clock, even if it could be properly tuned to begin with.   There are things I can do to improve that a little (use a grippier thread), but it'll never be quite good enough.  I suspect any friction drive will have this same problem.

Step 18: Refinement #3 - the Revenge of the Double Bobbin Technique

So, the final iteration for this instructable is actually the closest design to the prototype.  It uses the double bobbins, but positioned in a way to make the winding a little more even. And it is also pre-wound much more carefully so that one side fills at a more similar rate than the other empties.

It is still not as simple and as "closed-loop" as the bead chain system, but it is quiet and importantly, it works with these small steppers, which means it is light and cheap.  Design is about compromise, and these iterations are the whole point of making prototypes.  It is very rare indeed that designs drawn out on paper turn into perfect physical objects without a whole lot of shoehorning.

Step 19: Finished Article

Working in situ. I added some feet that are held in some general-purpose slots in the back of the clock. These slots could just as easily hold a piece of cord to hang the clock up. I'm not doing that bit yet because I think a case is more important.

Step 20: Finessing

I added the finished touches to this version by mounting the electronics to the back of the clock.  I strapped it to a bit of foamcore board and made some slots for that to go into on the back of the clock, in the same way as the legs are mounted.  This leaves the power as the only wire hanging out of it, the rest securely mounted and tucked up and out of the way.

For this you'll need:

The code has been modified so that the clock can be stopped and started with a button, and while it's stopped the time can be incremented manually with two extra buttons.  This uses Alexander Brevig's Button library.  This actually makes the clock usable in everyday life - you don't have to hook it up over USB to set the time!  Still have to reset the time every time it loses power, but hey ho.

It's the little things like that, taking the rough edges off that transforms a prototype, and interesting or curious diversion into a usable product.

The switches are connected to pin 2, pin 9 and pin 10, and the LED is on pin 13.  Each switch simply connects that pin to ground.  The pins have pull-up resistors already on them (built into the Arduino), so they will default to high (+5v) unless shorted to ground.  The software looks out for a switch between low (button depressed) and high (button released).  It does it's thing when the button is released.

I think this is pretty neat.

Step 21: Pointers

The carriages in the slide need to be able to hold the pointers at the right angle and distance from the face, and also need to hold the ends of the thread secure.  I first used just blu-tack to stick the thread and the cardboard pointer to the carriage.

A problem with using a simple bent-card pointer is that it's very hard to keep it bent at the correct angle - it wants to unfold, and when it does it catches on the other pointer when they pass by each other.

I made some new pointers and super-glued some pieces of solid wire onto them, so they stuck out at right angles, like prongs.  Then I secured them to the carriage by using a couple of pieces of the grippy plastic hooks from some command strip.  This turned out to hold the thread and the wires pretty securely, and once in, I could lightly bend the wires to position the pointers almost perfectly.

Step 22: Appraisal and Next Steps!

In step 2 I drew up the list of demands as follows:

Low power - ideally no trailing wires / battery: Failed on this one.  This current design uses an arduino and stepper motors.  The microprocessor on it's own can run ok on batteries for a little while, but with the steppers, it's only going to be good for a week I guess.  I am accepting this solution however, because it occurred to me that wires don't necessarily have to be the black plastic hanging out of a wall wart.  I anticipate a mains powered version of this clock in production would have a thin wire with a nice fibre woven sleeve, or a flat cable, like a speaker cable.  Batteries is still the dream of course, but it's for a non microprocessor/stepper combination I think.

Cheap enough to fit into a mainstream boutique's retail price range: SUCCESS!  I think anyway.  In response to a reader's comment, I totted up the cost of a hypothetical version of this clock using a simplified electronic design (ie discrete driver circuit) and it came out at about $40.  This could also be significantly reduced if parts were bought in bulk.  The design isn't very complicated to build so labour wouldn't be too much.  The case is not factored into that price however, and depending on fit and finish, it could conceivably be very expensive.  Also packaging should be thought about.

Anyway, say $60 cost = $120 wholesale = $200+ retail.  That's not too bad.  If I sold just direct then I could keep costs down.

Same mechanism able to run horizontally or vertically: SUCCESS!  This does not rely or use gravity in any stage, and the carriages and indicators are lightweight, so there is no impediment to running this clock in either orientation.

Silent when not moving: SUCCESS!  The motors are completely powered down between movements so there should be no buzzing or humming that might otherwise get amplified by the case/wall.  When it does move, it makes a noise from the carriages rattling in their grooves, but some patches of felt might help that.

Lightweight - does not require special wall fixings: SUCCESS!  Actually shot myself in the foot a bit by upgrading to using aluminium rails for this version.  It's heavier and doesn't really add anything.  Even so, still not too heavy to hang on a normal picture hook.  Of course a wooden case will change that, but even those need not be prohibitively strongly built.  I am leaning more to recommending that this clock sits on a surface anyway (like on a mantlepiece or across the top of  a bookshelf).

Aesthetically neutral - open to styling and colour/material choices: SUCCESS.  The reason I put this requirement in was so that I wouldn't produce some mechanism that was weird looking, or awkward to house.  Basically insisting that the clock can be cased in whatever I like, rather than having to have a big hole in the top for a wheel to pop out, or a space below for a pendulum or something. I copped out a bit here by not having a case to show, but I think it's clear that any kind of case would fit fine around this mechanism.

I'm happy with it, and it's ticking away on my desk as we speak.

There are a few extra modifications that are required to make this a product:


  • Use an endless loop of toothed / beaded chain instead of the double spools thread. This makes the diameter of the driving spool constant (the thread doesn't "layer") and have loose parts and tight parts. There is still slack to deal with, since the cord may stretch a little over it's lifetime, but a much shorter spring or piece of elastic can deal with that.
  • Use a discrete stepper driving circuit instead of the the Adafruit motorshield. The motorshield is very versatile, but overkill for what I need it for. I can probably make a more simple circuit using just the L293Ds and a couple of transistors, and that'll be a lot cheaper. Teamed with a less general-purpose version of the arduino, this will save a whole lot of money.
  • A indicator position detector at one end to allow it to self-calibrate on startup.
  • A better time source. There's a hundred different ways of doing this, but it's likely to be the time keeping IC from a quartz clock.

Those will be the tasks to focus on.  Some will be for product quality, others are for cost.  There's no point in having a perfect machine if it costs too much!

Thanks for reading my instructable!  I'd love to see if anybody else tries something like this, and I hope this 'ible has been some help.  Even if you don't follow the design I have gone with, it might be helpful to see what avenues have been already explored, and I hope the design process itself has been interesting.

Happy new year!
I absolutely love it mate, great work!
I made ​​a very interesting post from Thailand.
I love the linear design. Very unique. Have you ever tried running it vertically? Horizontal mounting seems like it would take up a lot of wall space. If it was mounted vertical it might fit into a design scheme a little easier. Vertical mounting would allow for a &quot;grandfather&quot; type enclosure, too. <br><br>keep up the &quot;out of the circle&quot; thinking. I love your brain. LOL<br>
The instructable includes a brief discussion of running it vertically, and in fact it was always designed to be run vertically, with a gravity drive. But I eventually turned it horizontal for the same reason as you suggest for turning it vertical! I struggled to think of many spaces, domestic spaces, that were tall and thin, and there's loads that are short and wide (mantelpieces, shelves), and I didn't want to have the bottom half of it behind a sofa or something. It can go either way though! just change the orientation of the numbers!
Thanks for the reply. I guess I should have read the entire 'ible, huh? I have a bad habit of skimming. LOL.
Ah... VERTICAL Linear Grandfather clock. I think you're on to something here.
Unbelievable! I know you've been told this a million times, but you should really look into mass production of this item! It's so futuristic-y... I love the fact that you took something that's been around for thousands of years (sun-dials count, right?), and revolutionized it. It's cooler than digital. and I can see it hanging on the wall in living rooms, behind couches and over mantles. Much cooler than the old boring circles. <br>You have a strange and invest-able idea here. It could go a long way. <br><br>But one must ask... What would a Grand-daddy Linear Clock look like? :) <br><br>Perfect instructable.
Hey thank you - so good of you to say so! I dismantled this one to try and make a &quot;cheaper&quot; version with more discrete parts and less pre-made bits, but really, electronics is not my strength, and I'm going to need some help with that. <br><br>So anyway it sat not working very well and I packed it all away to work on other things for a bit (because it's a bit depressing to be surrounded by non-working projects all the time), but I'm going to dig it out again and made a more robust version using the same mechanism as I've shown here. Because it's better to have something _working_ and not perfect, than have it not working at all!<br><br>I think a granddaddy linear clock would have to be like a huge T shape. Except that would look somewhat like a lifesize crucifix... so maybe not such a winner in the domestic environment. Have to do some work on that.<br><br>Thanks again!<br><br>Sandy
Super awesome idea. But is accuracy not a problem? Would it not lose a couple of seconds every time it has to reset back to 00:00? Or have you allowed for this time in your programming of the arduino?
Hi, thanks! The accuracy is a problem, but that's because the native accuracy of the arduino isn't very good over the very long term, rather than because of the rewind. <br><br>Like you say though, the code itself takes the rewind into account, because the time counter runs in the background even while the motors are doing stuff - they are always told to just display the current time.
Wow. This is awesome! Nicely done!
Thanks Tim, I'm very pleased with it. Working on a more robust / cheaper version now. Watch this space.
Nice 'ible Euphy, <br><br>I think you should add Seconds too, it would be zipping all over the place.<br><br>You should fix the filename of the sketch at step 12.
Thanks - the video near the end is running in seconds and minutes rather than minutes and hours... It's a bit of a boring video otherwise! Main reason for not doing seconds as well (apart from extra complexity and power considerations) is the rewinding noise every minute! <br> <br>I'm not sure I can fix the filename of the .pde in step 12 - unless I'm missing something?
&quot;unless I'm missing something?&quot;<br><br>Sorry I've yet to do an Instructable, so no idea how to rename it, the .tmp is annoying though.<br><br>Perhaps others know how? Anyone?<br><br>
I ended up just modifying the filename to a filename.pde.txt so at least instructables knew how to present it, and it's easier to take the .txt off than to change the whole name.
Very nice, I have been thinking about something similar, but have not gone beyond thinking. <br> <br>My idea, which you are welcome to is to: use a threaded rod with a captive nut to advance the pointer. It is easy to get rod up to about 3 feet, perhaps longer somewhere. It is also available in nylon. Just support it at both ends and put the nut on the indicator. The motor turns the rod. This gives potentially great force, but at low speed. No problems with layers of drive cord.
Thanks Russ, that was my initial plan idea actually, it's so obvious and would be so simple. I think the reason I decided against it eventually was that I thought it would be quite hard to get just tuned right, so there wasn't any binding or anything, and make it tolerant of haphazard construction. And because I wanted to use these cheap little motors without much torque, they'd have to be geared to drive the screw, and that'd make it hard to do the rewind fast.<br><br>In this case it probably doesn't matter too much, since as long as it takes less than a minute, it's ok, and it might be nice to have a serene slow rewind.<br><br>A development of that was the idea of using a lead screw like you say to drive the indicator forward, but have a spring-latch that disengages it from the screw when it's finished moving, and another spring or counterweight that quickly pulls it right back to the beginning. I was focussing on that kind of mechanism when I had a vertical clock in my head.<br><br>That kind of system would be especially suitable for a mains powered clock, like one that runs on the AC cycle. I love the idea of it slowly grinding away .. Almost like an electricity meter!
I might be your wife .. but I concur that this is very good indeed and its not been annoying at all to have you make this in our living room!
How embarrasking...
I really like this... well done
Looks like a nice idea! Good luck :)
Cheers mate!
Something linear based on this could work clock based dripper trackers or the liquid piston tracker. (For solar tracking on equatorial mount).<br>Thank you for this instructable.
Thanks, I enjoyed your pulser pump stuff!
I can see how its done, but I would be more inclined to buy a kit when and if it ever becomes available. Its a wonderfully elegant design.
Thanks - I actually intended this version (with the arduino and the steppers) to be the &quot;quick and dirty&quot; version, and a lower-energy, more mechanical version would be the elegant &quot;production&quot; version. But actually, after making this prototype, and then starting to make my finished version, it's been made clear that this design, with the fewest discrete parts as possible is by far the most simple way to do it. <br> <br>The aesthetic of it works regardless of how it's powered I guess. I don't like the idea of having a wire hanging out the bottom, which it would have to have if it was powered with the arduino - batteries aren't enough, or at least they wouldn't last for long. I could use those flat white cables and it might look ok, or a nice woven braided cable for an olde telephony or radiogram look. Actually that's a really good idea!
Very nice! Imma favorite this based solely on your sketches!!!
thanks RedBinary, I know the sketch interlude is a bit self indulgent, but I know I love looking through other peoples sketchbooks when I can, so maybe other people do too!
Freakin' cool! How could you invent such things?
Ha ha thanks! Just tinkering! Don't forget ideas are cheap - if you look around in your head there's hundreds just waiting to be picked. But it's very easy to dismiss them. It's good to have a reason to try and develop them (like this contest!) and show off!
LOOOOOVE IT !<br>always wanted to do one, especially linear !!<br><br>so for a noobie can i buy everything i need from what is mentioned in the comments?<br>and i see you used a stepping motor board and Arduino + stopper motors ..<br><br>and still under $40 ??<br><br><br>thanks
Thanks! The stepper&nbsp;driver board I used is a general-purpose motor shield and it's really good (adafruit motorshield - <a href="http://www.adafruit.com/index.php?main_page=product_info&products_id=81">http://www.adafruit.com/index.php?main_page=product_info&amp;products_id=81</a>) and I paid about $20 for it.&nbsp; It does everything you'd want in a motor project.&nbsp; But it's possible to make a more simple circuit that would do the same thing (drive two steppers) more cheaply, and that's what I've costed in the comment I left.&nbsp; It would be something like <a href="http://www.tigoe.net/pcomp/code/circuits/motors/stepper-motors">http://www.tigoe.net/pcomp/code/circuits/motors/stepper-motors</a>&nbsp;- scroll down to the &quot;bipolar stepper two-wire circuit&quot;.&nbsp; The expensive bit of the circuit are thet&nbsp;two&nbsp;L293D chips (~$3.50 each). The listing in the comments field was to show how cheap the whole thing could be if you wanted to pinch pennies, or if you were doing it for profit rather than pleasure - it'd be nowhere near as easy as the version I made, with the standard arduino and the motorshield, but it's certainly possible, and would be cheaper ... provided I didn't mess it up and have to do it all again!<br> <br> All in, I paid $30 for my arduino, and then $20 for the shield.
Very nice. Excellant example of turning theory in to useful application. <br>Adding to my Favorites
You need to produce this. It's beyond my DIY domain (I'm in the sewing and baking department) and I would definitely buy it. It's sleek and elegant without having that trendy, won't-be-cool-next-year look. Lovely idea.
Good job!
How does it go back to zero? With a circular clock it just goes around, but this reaches the end of the line. <br><br>Anyway, awesome concept. I would totally buy one of these!
Aha! Well that's the rub isn't it -&nbsp;<a href="https://www.instructables.com/id/Linear-Clock/step14/Prototype-clock-indicators-and-faces-and-finish/">https://www.instructables.com/id/Linear-Clock/step14/Prototype-clock-indicators-and-faces-and-finish/</a>&nbsp;has a video that show the return action. &nbsp;I think that's the interesting bit about the clock - it's the question that immediately springs to mind.<br> <br> Cheers!
I see. Thanks!
Thats really great, a wonderful example of mechanical engineering and innovative product design, I salute you.<br>I must admit though that before I saw the video I assumed the 'tape measure' would move and the needles would remain stationary, I only thought later about how you wont be able to represent three numbers for hours minutes and seconds with one rolling tape.<br>However the idea might still hold some merit, perhaps you might want to consider something like a moving tape reel for v2? It would be kind of like looking at one of those aeroplane compass displays!
Hi, thanks for your comments - I've seen a few examples of a moving ribbon type clock - there seems to be a few software versions of it (http://centaur.maths.qmw.ac.uk/Comp_Prob_Solving/Linear%20Clock.html is nice), and there's a tube station in London that has a linear ribbon type clock combines with a world map for showing world times (http://en.wikipedia.org/wiki/File:Picadillycircuslinearclock.jpg).<br><br>A variation is something like http://www.amazon.co.uk/Rotating-Pyramid-Design-Novelty-Clock/dp/B0047CM2QM<br><br>Having the needle still and the digits scroll by is neat, and like you say, I think if it were styled right (aviation style or something) it would look extra neat - but the odd proportions of it becomes unnecessary and I admit that's the interesting bit for me. <br><br>It wouldn't much different to a digital clock - you'd still need to read the numbers. Whereas the nice thing about an analogue face is that the positions of the hands mean something, even if there are no digits. They can be happy or sad, or neat, or untidy - the overall impression that you get from looking at the shape of the pointers on the whole face means something.<br><br>Maybe version 3!<br><br>Cheers!
Awesome- love it. I really like seeing the entire design process and the sketches are fantastic.
So how much would it cost to get one of these? Are you planning on making/selling them?
I replied to the wrong question (below) by saying how much it would cost to make one! <br> <br>To answer your question: For potential retail, I've been working on the basis of a retail price of around maybe &pound;100-&pound;120 ($140-$180 ish). <br> <br>That means wholesale price is between $65-$90, and so absolute cost to make needs to be about $30-$45. <br> <br>A kit or something could be a lot cheaper since it's just about assembling packages and there's much less worry about guarantees and returns and things.
I hope, once I've finished developing the production model, that I can do a bit of work on getting a quick / easy build process designed and then I'd love to sell them. <br> <br>The cost in parts of the prototype version was high because that's the nature of one-offs. The arduino side of it is the expensive bit, but the same circuit could be made up with an ardiuino clone and some bits, and a bit of chopping the code (which I've also realised I've forgotten to actually publish - will do that later). <br> <br>Ardweeny: $9.99 (http://www.solarbotics.com/products/kardw/) <br> <br>Motor driver circuit <br>2x L293s: $7.00 (http://www.solarbotics.com/products/l293d/) <br>2x NPN transistors: $0.30 <br> <br>Motors: <br>2x steppers: $1 (http://ryanschenk.com/2010/03/driving-a-040-stepper-with-arduino/) <br> <br>Hardware <br>PVC curtain rail: $10 <br>Sewing machine bobbins: $4 <br>Thread: $2 <br>Foamcore board: $6 <br> <br>Total: $40 ish. All of these things (except maybe the motors I guess) could be got cheaper in quantity. Of course that doesn't include labour, case, packaging, all the other stuff that's required for a product, but it's a start. The motor driver and the microcontroller are comparatively expensive, and somewhat over-complicated and over-powerful for what it's being used for, so I'm sure a simpler (less general purpose) circuit could bring the cost down another $10. <br> <br>Oh also forgot a power supply.
wow. very impressive. Its a little above my head, i must admit, but I love the thought that was poured into this 'structible. The idea of a linear clock has always fascinated me. Please let me know if you do, in fact, produce these for sale.<br>Great job.
This is so awesome!
I like it.<br><br>Thank you for the good job.<br>

About This Instructable




Bio: Like everyone, I like making things. I'm currently a computer programmer by trade, which I adore, but I like building physical things when I ... More »
More by Euphy:Polargraph Drawing Machine Linear Clock Mechanical expanding cardboard lamp - This way up! 
Add instructable to: