I need to create several spools of enameled copper wire, each one rolled on a 3D printed bobbin and with a certain number of turns. In total, there will be several thousands of turns, and I want to count all turns without accidentally missing any or counting any twice, and therefore I need to construct a counting mechanism. The maximum number of turns for one bobbin will be 1500, so I need the counter to have four digits.
I will print the bobbin in many different sizes, so I designed it in OpenSCAD to be able to easily change its dimension. Here is a rendering of it:
This is my plan so far:
- I will attach the bobbin to an adapter (since not all bobbins have the same dimensions) that I will attach to an arm that passes through two holes, one on each side of the bobbin, and each hole is at the top of a leg. This will allow the arm to rotate around its own axis while being suspended in the air.
- I will attach a crank to the arm in order to be able to turn it.
- The spool the copper wire comes on will be mounted on something that can rotate but will have some amount of friction to it in order to create a tension in the wire so that the wire will be rolled on tightly to the bobbin. I haven't figured out completely how this should work yet.
- The turn counting mechanism is what feels like the most complicated part. There are already some counting mechanisms on Thingiverse, like these two, but using those are not that straightforward. They are not adapted to be attached to a shaft and would need to be reverse engineered. Besides, it is enough if each digit "changes" with a constant angular velocity (assuming that the crank is turned with a constant angular velocity) and not stands still waiting for a carriage from the next digit and then suddenly change. Reading the number from such a counter wouldn't be any bigger problem than reading the time from an analogue clock since it essentially behaves in the same way. I think this is even preferable since
- this may make the construction simpler and therefore more reliable since there will simply be a 1:10 (gear) reduction between each digit, and
- if all digits suddenly change at once, I suspect that might suddenly create a lot of friction in the system, which both makes the turning less smooth, and might even create a torque or a force on some part that is high enough to break that part; if instead each digit change with a constant angular velocity the forces in the system can be thought of as geometric series, which are constant and finite even for an infinite amount of digits and therefore won't suddenly increase and cause something to break. At least this makes a theoretical difference but maybe not a difference that is big enough in practice if the counter only has four digits.
Having said that, I may change the design if there is another design that seems simpler to make or more reliable.
My questions are:
- How should I construct this counting mechanism for it to be as simple yet reliable as possible? Is there any standard way of doing this sort of thing?
- Does this construction idea make sense or is there some considerably easier way to achieve the same thing (creating a spool and reliably keeping track or the number of turns)?