Wind It Up

Automate a Tough Task

Bob Harper

Issue 6, December 2017

This article includes additional downloadable resources.
Please log in to access.

Log in

Winding coils is never easy. With a little creativity however, we can automate this task and make coil winding a little simpler!

Is a one-axis CNC machine possible? Well yes, but maybe I’m cheating, as I don’t count rotation of the job as an axis! Even the venerable “Eggbot” has two axes right? Well same question, rotation of the job is not counted in lathe work, nor rotation of the tool in milling, so the eggbot would also be a single axis; except the egg is sometimes stopped, or even turned backwards. By definition, a machine is a tool combining a number of parts that move in relation to one another, usually around or along an axis.


One of the projects we considered including this month has been deemed too difficult, due to one main component requiring some crafty hand-skills. That component was a simple coil of wire which, unfortunately, is not readily available off the shelf. The coil is nothing more than a roll of copper wire though, so you may well ask, “how difficult can it be?”

Having wound many thousands of turns of very thin wire to make a 15,000V transformer for neon lighting, I can tell you that the thought of having a machine do it is very appealing!

So here is my last minute, ad-hoc project for the avid coil winder. Yes, I know there are very few of you out there, many may be hams, others may be making pinball machines and the like; (interested?); and maybe a few others have always wanted to play with magnet projects but were afraid of the tediously obsessive craft of coil winding, by hand… for the remainder of you, I hope to clarify the process, and encourage you to look at what machine you can design, to perform a task important to you! When you do, please let us know because we here at DIYODE love to see what you - our readers - get up to!


When I wound coils in the 1970s, I was a Coil Winder. There were machines that could wind coils, but most relied on the human brain and dexterity of human hands to control the laying of turns. This device follows the same procedures, and could easily wind some, and maybe all of the coils I worked on - almost without human assistance.


A “coil” is wound onto a “bobbin” - or “coil former” - between the “cheeks” that form the sides or ends of the coil. The coil will have a calculated number of “turns” of an “enamel coated wire (ECW)” of a certain “gauge” or diameter (expressed in metric, thankfully). This is usually wound onto the bobbin in a number of “layers” which has so many “turns per layer”. This is a brief but sufficient introduction for a first timer, to the commonly used terms when it comes to coil winders.


The craft of the coil winder is to lay the turns in a very neat layer, side by side, without gaps, and definitely without crossovers. “Like eels in bed,” an elderly tradesman once told me. If they don’t lay side by side, and worse still if they crossover one another, we have a problem! Crossovers ruin the whole job as the crossed wires have a habit of snowballing into a giant cancerous lump on the coil. Also, the crossovers will eventually cause premature coil failure, because the wires rub together and take off the insulation and short out.


Note: The CAD program used here is OpenSCAD, which allows for solid geometry, using a text editor and some maths, to produce a 3D part, which can be saved as a 3D .stl file for 3D printing, or even for making on a CNC.

The machine we describe here simply rotates the bobbin on a shaft, at an adjustable speed of rotation, while accurately counting the number of rotations. This is a perfect job for a stepper motor, which can be rotated from one step at a time, to an upper speed of perhaps several hundred RPM if we engineered it fully; and it’s only limited by the switching speed of the motor controller and the thinking speed of the microprocessor.

The bobbin may be held in a chuck, or driven between centres. It is important that the bobbin doesn’t slip (i.e., NO spinning the wheels!).

For our small simple coil, as we intend to use in the future article, a common NEMA-17 from an old “InkMess” printer is perfect. No doubt, there are plenty of discarded messy printers out there. In order to KISS (“keep it simple, stupid”), we have used a coupling on the end of the motor shaft, and threaded for a bolt we intend to be the core of the coil.

The craft of the coil winder


The second stepper motor controls the position of the winding wire along the axis of the coil/bobbin. This would normally be called the X-axis, but since it is the only axis, we’ll simply call it the “Spooling Motor”, as it causes the wire to be laid in a spool rather than a rat’s nest.

The spooling motor positions the wire between two limits, essentially laying the wire from the left cheek of the bobbin (i.e., the left limit), along the width of the bobbin and right up to the right cheek (the right limit).

Some old mechanical winders used a gear mechanism to reverse the direction of the feed when either limit is reached. Newer (or less old) systems used a switch to change direction of the spooling motor, but they each took a lot of careful setting up; sometimes including changing gears or belts to synchronise the rotation with the feed speeds. The old machines were essentially mechanical, but usually driven by an electric motor.

Spooling motor


An Arduino UNO, or other microprocessor that can generate the two sets of three digital control signals for a stepper motor driver (i.e., enable, direction and step), or be programmed to drive an H-bridge directly, is all that is needed to drive the coil motor and the spool motor. The same processor board will most likely have enough pins to drive the two motors, via a motor driver shield.


The machine task is to lay one turn of wire, and move one wire’s diameter sideways, to lay the next turn of wire. But as the turns are best laid in a spiral, the spooling motor must travel at a speed of one wire’s diameter sideways, per turn of the coil. Hence the need for gears on old mechanical machines.


I know you are all excited to know that maths will, as always, help us make this work. The programming for the stepper motors is a ratio of spooling motor steps to winding motor steps. This just needs some thoughtful programming, but it’s the same as moving a diagonal direction in between the X-axis and Y-axis on any other CNC machine.

At the end of the bobbin, the spooling motor can simply change direction, and run the same number of turns back to the start of the previous layer. The cycle continues until the required number of turns, or layers, are completed. As with most programming, there is the simple way, and the best way; and the two do not normally turn out to be the same!


The simple way is intended for simple, or one off coils. The Arduino sketch can be programmed directly to do such a simple task, requiring no switches or LCD, or any feedback of limit switches; instead, allotting all responsibility to the programmer and machine designer. An example of such code for this one job is given here for reference and explanation. Of course, much depends on the stepper motor driver/shield you use. The software we used was on a Duinotech Motor Control shield, but it should also work on others, once configured. You will need to find out which pins do what, and whether you have a step/direction/enable style, or an H-bridge connection. If you prefer, it will work with a pair of ULN2003 ICs.


As the foundation layer is the chance for the (human) motor winder to make sure all is well, the first layer should be wound slower so as to enable inspection of the quality of the layer. It should be good enough for the (human) motor winder to declare “I couldn’t have done better myself!”

As in CNC practice, the spooling motor, and therefore the winding motor as well, should be slowed towards the end of each layer and accelerated smoothly into the next layer. The motors should also be started slowly, and also slowed at the end of the required number of turns or layers; partly so the wire doesn’t unravel if the supply spool continues to rotate under its own inertia.

The winding wire supply spool can be mounted on an axle with some drag to help avoid this happening, but it’s usually not an issue if the supply spool is small and light, as ours will be. Braking can be achieved by keeping the reel between felt or leather cheeks.


As the wire comes off the supply spool, commercial machines pass the wire through three optional processes. Firstly, if the spool of wire had been left out to become dusty, a felt or other material pad may be used to wipe any dust from the wire. Secondly, a wire straightener may be added to remove any kinks from the wire, including the curve created from being wrapped around the spool. Thirdly, you need it to pass through a tensioner to attempt to maintain an even pull from the wire on the bobbin back to the supply spool.

Finally, the essential task: the wire is guided to a position by a guide wheel, or commercially, a ruby-tipped guide tube. The ruby is a little too expensive for home brew, of course, so we’ll use a grooved plastic wheel instead!

All of this depends upon the size and shape of the wire, and of the coil being made. What works for one gauge of wire will break another, or the machine would be broken by large conductors.

The bottom line is... we are looking at a machine to do a specific job, and if it handles similar jobs then all is well. We make no suggestion of designing a universal coil winder, but maybe for another day.

The Build

Parts Required: AUS3D
2 x 250mm Aluminium V-Rail Extrusion 2600 Section VS2060-250
2 x NEMA17 Stepper Motors 27” Ounces or Better Stepper-34mm
1 x 5mm Coupling
1 x 5mm/M6 Flexible Curling Flex-coupler-5x8
1 x 8mm Trap Thread TR8x8-300mm
1 x M6 ID Bearing BB-608ZZ-10
1 x 8mm x 350 SR8-350
1 x 88 ID Lin Bearing LM8UU
1 x 8mm x 20 Spring
1 x 20 x 3 100mm Aluminium or Steel Strip
12 x M5 x 10mm Button Head or Pan Head Allen Screws VS1510
12 x M5 Slide/Slot Nut VS0150
3 x M3 Nuts Stainless Steel (25 piece pack) VS0155
3 x 6mm x 6mm M3 Metal Stand Off Bush
2 x 120mm M5 or M6 Allen Head Bolt
2 x M5 or M6 nuts to Suit
8 x M3 Washers
8 x M3 x 8mm Round or Hex Head Screws
8 x M3 x 12mm Round or Hex Head Screws
1 x M3 x 15mm Round or Hex Head Screws
1 x 3D Printed Nema17 Stepper Motor Mount (Wind Motor)
1 x 3D Printed Nema17 Stepper Motor Mount (Spool Motor)
1 x 3D Printed Nema17 Stepper Motor Mount (Lead Screw Bearing)
1 x 3D Printed Plastic Feed Block
3 x 3D Printed 200mm Guide Wheels


As we’re using a one-quarter-inch or M6 bolt as the bobbin for our coil, the simplest possible drive is to use a one-quarter-inch or 6mm inline coupling, with two grub screws. They are normally about 12mm diameter and 16mm long, but that’s plenty for the job at hand. If the stepper motor you choose has a one-quarter-inch/6mm shaft (i.e., a NEMA 23 type), then all good. The NEMA 17 motors we salvaged have a 5mm shaft, and 5mm couplers are also available, but harder to find. One end can be threaded for 6mm/one-quarter-inch with a cheap threading “tap”. If you haven’t used one before, I am sure there will be a description for newbies on the internet.

I used NEMA 17s simply because they were there! My penalty is that I had to find or make a coupling for the 5mm shafts. I could have packed the one-quarter-inch job with some 0.5mm shim ( i.e., thin aluminium/copper/tinplate or such), but with a lathe in my shed I turned one up, and another for the lead screw. Sorry, but it was just too tempting!

Mount one end of your coupling on the stepper motor, and the “bobbin” bolt in the other. The motor itself should be locked down and this can be accomplished in its most basic method - with a couple of zip ties - as it only has to remain still for one or maybe a few jobs. A little runout won’t cause any real problems, and the wire guide will have some give built in.

For the serious makers out there, who have access to a 3D printer, we have drawn up a set of plastic stepper motor mounts that can be screwed to a wooden base board, or even mounted on V-slot extrusion.

Finally, as I predict a few more projects to come that also require coils, I’m making one from almost all bought parts. The photo of the shiny all new parts machine, as compared to the prototype below may convince you to make your own. Chris from Aus3D has agreed to put together a bundle of the parts that I have used.

plastic stepper motor mounts


Using another one-quarter-inch or 6mm coupling, attach a long threaded bolt, or a piece of threaded rod to another stepper motor shaft. This motor should also be locked down, and a simple solution to both motors would be to clamp the two under another piece of MDF. My knock-up used wood screws to mount the plastic brackets to a leftover piece of laminated chip board. My high-tech version of the motor mounts are made to bolt to aluminium V-rail extrusions, using slot nuts and 5mm button head allen screws.

HINT: Collect old stepper motors to play with! There are a lot of them out there in all sorts of “recycle-ready” hardware, and most still work as good as new.

The threaded rod I got from a hardware store was really disappointing quality. The material was very soft and easily bent, and running my fingers along the threads detected variations in the diameter that were easily felt. Hopefully there are some better quality versions out there, as they’ll sure make it easier to get the machine running smoothly. For the “all new parts” coil winder, I used a polished, threaded 8mm trapazoid screw and matching turned nut. The difference was well worth the upgrade.

spool motor


All we need now is something to ride on that thread, and guide the wire into position so as to direct it to the exact position we want it to be wound. The wire passes over the first wheel, under the second, and over the third down to the coil.

Wire guide

Although optional, there is essentially a felt pad that the wire is pulled through to remove dust, and to provide some of the tension; as well as three pulley wheels that the wire passes over, under and over again, in order to apply a little more tension on the wire, and remove most kinks.

A good scrounger collects wheels, springs, screws and the like from old VCRs or cassette tape players (remember them?). Perhaps you can use toy car wheels, V-belt pulleys, or 3D-print some? Nylon is a good material but avoid any hard materials with sharp edges, as they may scratch the enamel insulation. That thin layer of enamel is usually good for 600V, as long as it’s not scratched.

The wire guide arm can be a length of plastic, aluminium, steel, or even wood, depending on your preferred technology. I like making swarf, so I choose metal (almost) every time! This time however, we decided on a 3D printed feed block so it’s easier to share, and a little less engineering is required. The block should be printed on its side with the holes vertical, so no support material is required.

The two holes should both be 6mm clearance for a 6mm rod, or one-quarter-inch for those still suffering from nostalgia. Both holes may need to be reamed out with a suitable drill bit. Do NOT use a high speed drill as the plastic will heat up and melt onto the drill. The idea is to take things easy, and hand ream the holes with a twist drill held in a chuck or vice, or vice grips - always being careful to keep the two holes as parallel as possible.

There are two recesses designed into the original STL model, which are the right shape and size for two 6mm steel nuts to be pressed in, to make the thread. A vice is a good way to squeeze the nuts into the hexagonal holes, but a same size bolt with a large washer can be used to pull one in. A smaller bolt that fits through the inside of the thread can be used to pull the other one in.

If they are too tight a fit, warm them up and they should go in without too much effort. Screw the threaded rod through both nuts, and tap the rod to help the nuts find a position where the rod turns easily. A little grease may help. The all-new version uses a different feed block to accomodate the M8x8 Lead Screw Nut. Both technology parts will be available online.

Of course without a 3D printer, avid woodworkers can make something similar in hardwood or MDF, while engineers can fit up a lump of aluminium; whatever your decision, you need to make your own. We also included a set of plastic guide wheels in the model, but curtain shops usually have some nice nylon wheels. You still have to supply your own metal arm - aluminium or steel preferred!

Note that the last wheel needs to run fairly consistent and true, as it is the one that guides the wire into place. For all three I used 6mm long by 6mm outside diameter, PCB non-threaded standoffs. Again, in hindsight I should have made the wheels the same width as the standoffs. That has also been fixed for the uploaded 3D files, which are 5.5mm thick. If they print out tight, either adjust the height in your slicer software, or print them out and sand down the non-shiny side.


We have provided the guts of the project, and we could design a special base and machined motor mounts, etc but we’ll leave this to you as we don’t know what you have on hand, and what you’re good at working with.


To begin with, we need a base for the project. In classic project fashion, I begun with a modern version of the classic breadboard, which really just refers to a piece of pine for old valve projects; but for the prototype I used an off-cut of laminated chipboard - because it was there! MDF or pine would have been a better choice for convenience and low cost.

Once the prototype was built however, I moved on to two 250mm lengths of 2060 V-rail extrusion from Aus3D. I could have used 2080 for more width, but I would have required a longer drill to join the two. The 2060 extrusions lay side by side, and I could have joined them quite effectively with a common end plate, but I didn't have any. So I cross-drilled both pieces carefully, 6mm diameter at exactly 25mm from each end.

The extrusions have a centre line already along the bottom of each V-slot, so marking is pretty easy. To have the best chance of the holes lining up, mark and drill from the joining faces of the extrusions so they line up best. Drill through the middle material all the way through. The drill therefore has to be at least as long as the extrusions are wide, and have enough to grip in the chuck. Otherwise I may have used 2080 myself.

The two extrusions are then bolted together. I used threaded rod, because I had it on hand, but a Hex or Cup head M6 bolt, at least 120mm active length, plus enough for the washer and nut can be used.

I counter-drilled the outside faces to allow a socket to fit over a nut to tighten them, but that required a larger drill than some may have access to, and drilling through the slot with anything but a feed-type bench drill with vice is not recommended as it will bite! So it is okay to simply use a washer and nut outside of the extrusion sides.

I completed the base by adding stick-on rubber feet to the bottom side, but perhaps you might prefer screw on feet; it's your choice.


Aluminium can take nasty bites out of bare skin, especially straight off the docking saw. I recommend an old wood plane, not a large one but a small hand plane often found at garage sales or markets, or even some hardware stores. I simply adjust the blade for a thin sliver and run the plan along each edge as about 45 degrees until I see about a 1mm wide chamfer along the edge. You might like to trim up the holes and slots of swarf as well, using a screwdriver blade, or scraper if you have one.


For the “must 3D print it” group, we have drawn up some motor mount brackets. There is also a model for the feed block and wheels, so you really can 3D print and assemble it all on an MDF base.

The motor brackets were printed off, and three versions were printed before "the one" was found. It has eight mounting holes, which allow it to be mounted on the MDF, or align with the slots of the extrusion, spaced 20mm apart centre to centre.

M5 x 12mm button head allen screws attach the brackets to the extrusion using slot nuts, also from Aus3D. The mounts can therefore, be slid along the slots then locked into place, as may be required for experimental winding of coils, and even helical antennas, or for UHF CB; or even possibly 2.4GHz phased arrays!

I had a 22mm bronze bush, which I used in a motor mount bracket for the screw far end, but the thread only needs a good guide - even plastic or wood - so the wire guide stays fairly level. In a moment of expected overkill, I ordered a 8mm lead screw and nut, mainly to see if the upgrade really is overkill, or useful. I’m happy to say, it resulted a big improvement.

The bronze bush fitted perfectly, requiring a little scraping out, but the fitting will depend on your 3D printer and its settings. An 8mm ball bearing from Aus3D is also 22mm outside diameter, fortuitously, and fits in the motor bracket as printed. With no sideways force, it should remain in place without fixing, but if it wanders a little drop of glue should do the trick.


Once again, we don’t intend to tell you to go out and buy a new Arduino, as almost any development style board with whatever microcontroller you have will do. I have an i8031 looking for a job - but that poor old fella might be better left in a box, as he’s an antique now!

stepper motor controllers

While my collection doesn't include one of every type of stepper motor driver in existence, I have quite a few, and enough to realise that you may have a favourite; and in fact, you may all have favourites that bare no commonality, except they hopefully connect to NEMA 17 motors of a suitable voltage (e.g., 12V, and have either four inputs for the four coils; or three inputs, Enable, Direction and Step; or at least the last two).

During development we built two different electronic configurations and wrote code for both. We initially used a dual motor shield and then we switched to a a pair of L298 H-Bridge boards. The code we present here is for the second configuration.

The code is being extended for a Freetronics CNCplot or Stepduino controller. The stepper motor example code from Freetronics was heavily tweaked for the initial setup, but was an excellent starting point. We'll put the final code up on the DIYODE website for you, but our L298 Driver is what we'll focus on as it can be easier to procure.

setup layout


The coil I wanted when I wrote this, which has since been changed, had a coil along 30mm of the bobbin. The wire was 0.4mm diameter meaning 30/0.4 = 75 turns. NOTE: This is a trap, the copper is a nominal 0.4mm diameter but the insulated wire is 0.44mm diameter (i.e., we only get 30/0.44 = 68 turns per layer. “I bin gypped!”).

The coil winder motor requires 200 steps per revolution, so 13,600 steps to move along one layer. There had to be a simpler way to do it, so we decided to work one revolution at a time, and count in steps, turns and layers. Meanwhile, the spooling motor (of the prototype) drives a 1mm pitch thread, and also makes 200 steps per revolution. So to go one wire width, 0.44mm, it needs to make 0.44 X 200 = 88 turns.

It occurs to me, and hopefully to you by now, that it’s easier to go one turn at a time, and turn around every 68 turns to make another layer, which is 14 in total. So every 200 steps of the winder motor requires 88 steps of the spooling motor.

For a fixed purpose, one-use program, I can simply do the 88 steps of the spool motor, making 2 steps of the winding motor for every spooling motor step. Then after (88 x 2 =) 176 winding motor steps, I will have moved the wire one whole wire width; but still have 24 steps to complete one revolution of the coil. In a nasty cheat, I make 24 more steps of the winding motor and call it one turn. Then I do the same for the whole layer, and call it one layer. If I do that another 13 times I have a coil. So the program becomes a nest of dumb “for-next” loops.

#include <Stepper.h>
// For the Project Coil...
const int TurnsPerLayer          = 67; 
// 67.5
const int Layers                 = 7; 
// 14 Layers = Layers/2 for L>R and R>L
const int StepsPerTurn           = 88; 
// Driven width of one wire.
const int StepsPerRev1           = 200;
const int StepsPerRev2           = 200;
const int stepsPerRevolution     = 200;  
// change this to fit the number of steps per 
//revolution for your motor
// initialise the stepper library on pins 8 through 11:
Stepper coilStepper(stepsPerRevolution,8, 9, 10, 11);
// initialise the stepper library on 
// pins 8 through 11:
Stepper spoolStepper(stepsPerRevolution,4, 5, 6, 7);
void setup() 
  // set the speed at 60 rpm:
} // End of Setup()

First we import the stepper library which is part of the standard Arduino setup. Next, we set a number of constants used in the code and initialise 2 'Stepper' objects.

In the loop() we issue step command to the spool motor and to the coil motor as required to build the coil to the spec's we have set.

void loop()
  for (int l = 0; l < Layers; l++)
    // Run this layer from left to right.
    for (int t = 0; t < TurnsPerLayer; t++) 
     // Run this layer from left to right.
       for (int spt = 0; spt < StepsPerTurn; spt++) 
       // Most of the turn is 2:1 winding ratio
        // step spool stepper one step
        // step coil stepper 2 steps
      int catchup = StepsPerRev1 - 2 * StepsPerTurn;
      // Lazy way to catch up. Should distribute this better.
      for (int j = 0; j < catchup; j++)  
        // step coil stepper 2 steps clockwise
    // Run this layer from right to left.
    for (int t = 0; t < TurnsPerLayer; t++) 
        for (int spt = 0; spt < StepsPerTurn; spt++)  
        // Most of the turn is 2:1 winding ratio
        // step spool stepper one step back
        // step coil stepper 2 steps
      int catchup = StepsPerRev1 - 2 * StepsPerTurn;
      // Lazy way to catch up. Should distribute this better.
      for (int j = 0; j < catchup; j++)     
        // step coil stepper 2 steps
} // End of loop()

This code does a right to left layer.


Of course, the simple answer doesn’t always satisfy us, so plans have begun for the next generation of our coil winder.

I would like to issue a G-code type command (used by CNC machines) or similar, or simply fill out the parameters on a Python screen, and let a Python script tell the coil winder what it’s job is.

The maths can be set up using Bresenham’s Algorithm, which you can read about on the DIYODE website. Our program, based on Besenham’s Algorithm part is complete. The console driven version is well under way but may not be complete before you read this. It will however be on the DIYODE website as soon as it is debugged.

The coil winder will also pop up from time to time, as it makes another coil for another project; so stay tuned!


For the project we have in mind, the coil is made on a M6 x 50mm (or one-quarter-inch x two-inch) bolt. The design of the coil is given in the article, but for a generic electromagnet for experiments, or simply playing with, we can use the same simple design.

First, you need to remember that electric wire on an iron bolt is likely to short out if you scratch the thin layer of high resistance enamel off the wire. ECW is typically rated at 600V, but modern winding wire may have “solder through insulation” meaning that with enough temperature the insulation becomes a flux. Good if that’s what you want; bad if your coil gets too hot! Either way, coils are normally made onto a bobbin, often made from plastic; we could 3D print a bobbin, but a simple method that has been used since Michael Faraday was playing with electromagnets, is made from paper and shellac - or varnish, if shellac is unavailable.


The cheeks will be made of cardboard, the same size as the end washers you have found. Try to get 20mm washers if you can find some. The good thing about a 6mm/one-quarter-inch bolt is that an office paper punch is about the right size to make a hole in the cardboard washer; you can use the back cover from an old (retired) notebook or such. Punch a few holes, at least the width of your washer apart, and cut them midway between the holes. Stack the cardboard disks on the threaded part of the bolt, with a steel washer either side, and a steel nut before and after. Tighten the nuts to clamp the cardboard tightly together. Make up six or more, and you can pick the best and keep the rest for another go later on.

Now carve, file, sand or chisel the cardboard washers round. We used a lathe and a specially sharpened tool, mainly to see if they came out any better, but a pair of scissors will do a good enough job.

Remove the washers from the bolt, lay them flat on some plastic, and soak them with shellac or thinned varnish, and then leave to dry. When they are dry enough to handle, put a steel washer on the bolt followed by a cardboard washer, and another, then the second steel washer and a nut. Spin the nut up to the end of the thread and then put another nut on behind it. Turn the first nut one turn back, and tighten the second nut up against it.


Begin by cutting a rectangle of paper the width of the bobbin, 30mm wide in my case, and long enough to wrap around the bolt twice. (Pi x D x 2 if you want an exact length!) Tightly wrap the paper around the bolt, and keep in place with a couple of clothes pegs or rubber bands. It’s best if the pegs are rubbed with a little oil first, so they don’t stick on the paper; but don’t put them back into the peg basket when you’re done. Not a good plan, socially!

Brush some shellac or varnish into the paper, and let it dry before removing the pegs or rubber bands. There may be some areas not covered but just as long as the paper remains in place for now, that’s what matters most.


Now that you have a bobbin drying, what other options did you have? Some bobbins come moulded from a factory, some are turned up on a lathe from nylon or special insulation materials, while some are made from a material very similar to a blank PCB - and for a larger bobbin, that option may be useful to remember.


Use a hole saw to make two or more washers from a piece of PCB material, preferably waste, or a failed PCB. Although we have two steel washers already on our bolt, it would still be a good idea to remove the copper from the PCB washers, as they form shorted turns and convert some of the EM field into heat, rather than the attractive force we want. So etch the PCB clean first if you can.

The steel washers will do the same but have a higher resistance, so we tend to forget about them. Technically we should saw a gap from outside of the washer to the hole in the centre, to break the shorted turns. The PCB washers would be put on the bolt, the same as the cardboard ones, and the paper could be glued on with epoxy resin or even super glue. Good luck at keeping your fingers off that lot!


To make the coil, the bobbin on which the wire is supplied needs to be placed on some form of axle so it doesn’t run off under the bench at some critical moment. The wire should come off the reel freely, and the reel should rotate freely on it’s axle.

Some jobs require the wire to be fed out of the bobbin through the cheek, or along a groove in the cheek. The winder may also prefer to join a length of hookup wire to the winding wire, so the joint is not seen outside of the coil.

However you mount the start of the winding, make sure the end is secure on the bobbin and the free end is not going to become tangled in the machinery.


Hopefully you have made some dummy runs without wire first, but once you’re set up and have double-checked everything, apply power to the Arduino and shield, and hopefully everything will run smoothly. Just be sure that you have a switch in the power wiring, and keep it handy. If you have to stop suddenly, remember that the Arduino will forget where it was, and your only option will be to wind the wire back onto the reel, and start over.