Build Your Own Arduino-Based Rodin Coil Winding Machine

If the video player is not working, you can click on this alternative video link.

If you need some copper wire Rodin-coiled, you could always spend hours doing it by hand. Alternatively, you could use some basic components, and an Arduino Nano to have a machine do it for you.

What is there not to like? 

But first, you will need some parts and equipment before you get stuck in. 

Tools and parts needed

• Arduino Nano
• NEMA 17 stepper motor
• A4988-stepper motor driver module
• Nextion 2.8" HMI LCD screen
• 6mm acrylic sheet (clear)
• 1/2 inch (12 mm) thick plywood or MDF board
• 23/32 x 23/32 inch (20 x 20 mm) Aluminum Extrusion bar
• 23/32 by 1 and 37/64 inch (20 x 40 mm) Aluminum Extrusion bar
• 23/32 inch (20mm) steel rod
• Brackets
• M5 threaded rods
• Custom PCB board (or just use a sandwich board and connector wiring). 
• Steel rods
• Spool of thin copper wire
• Old plastic ballpoint pen
• Acrylic block
• Hollow metal cylinder
• 5/16 inch (8mm) flange bearing
• 13/64 inch (5mm) threaded rods
• Soldering kit
• Tube shrink wrapping
• Screwdriver set
• Mini lathe
• Electrical wires, resistors, and soldering gear
• Assorted PCB wire female connectors and male pins
• Protractor and pair of compasses
• A 3D printer, or ask a friend with one to help out
• Various 3D parts (models here)
• Arduino Code (can be found at the end of the article)
• Custom PCB board
• Table saw
• Jigsaw
• Various bolts and nuts

Step 1: Make the basic frame

The first step is to make the basic frame for the Rodin coil winding machine. To do this, grab your extrusion roads, measure, and cut down to size. Measure 4 equal lengths of 20 cm (7 and 7/8 inches) and cut using a table saw or hack saw.

Using your brackets, build the basic frame as shown below. 

Now, grab the two double thickness extrusion bars, and secure these to the frame also using brackets. 

Step 2: Create the Rodin winder mounting wheel

Now grab your plywood, or MDF, and cut out a suitably sized square piece large enough for the diameter of the Rodin winder wheel. Mark out the center, and draw a circle using a pair of compasses. 

Using a protractor, mark out intervals every 4 cm (1.5 inch) along its circumference for the positions of the Rodin winder. You will want 16 points in total. 

Cut out the wheel using a jigsaw, and clean up the cut edges as needed. Drill a hole through the very center, and also drill holes through each of the points around the wheel's perimeter. 

If needed, mount the wheel in a lathe, and trim down the edges to the required dimensions. 

Step 3: Make the mounting for the wheel

Take your steel rod, and mark out a length of about 2 and 6 cm (23/64 inches). Cut the length off using a Dremel or hacksaw. Secure the length into your mini lathe and machine an axle to hold the Rodin coiling wheel.

Drill a hole through the center of the axle as well the same diameter as the NEMA stepper motor's axle. Next, turn the length of the axle around, and cut off the rest of the full diameter section of the rod to leave a flange roughly 5 mm (13/64 inches) deep. 

Machine the cut end flat, and then drill two holes across the full diameter, as shown. 

Insert your mounting axle into the center of the wheel and then secure both to the axle of the stepper motor. 

Next, extend the holes from the wheel mounting axle into the wheel and bolt them firmly together. 

Step 4: Make the perspex stepper motor mounting plate

Next, grab your clear perspex, and measure out a length of 5 and 14 cm (33/64 inches) by 1 and 5 cm (31/32 inches). Cut out using your jigsaw.

Find the center of the piece, and mark out the mounting screw points for the NEMA stepper motor mounting points, as well as, four corner screw holes. Drill the holes, and cut another larger hole in the middle.

Mount the piece of fashioned perspex to the top of the double-width extruded rods on your previously completed frame. 

Next, mount the stepper motor to the perspex plate using suitably sized nuts and bolts. 

Step 6: Complete the wheel

Now, grab 12 number, 1 and 4 cm (37/64 inch) long bolts the same diameter as the perimeter holes on your Rodin winding wheel. Secure them into the holes using washers and bolts. 

Next, add a length of shrink-wrapping to each of the bolt teeth on the wheel. Use a hairdryer to heat shrink them into place, if needed.

Secure the wheel to the stepper motor mounting on the mainframe. 

Step 7: Make the main winding mechanism

Now, take two lengths of 8 mm (5/16 inch) steel rods and 4 flange mounts. Secure the mounts to the frame as shown below. 

Next, grab another piece of perspex and CNC machine two end plates to mount the second stepper motor and hold the threaded rod that will be controlled by the stepper motor in place on the frame. 

Mount the stepper motor to its perspex mounting. Now, feed the threaded rod through the perspex endplate, and secure it in place to the second stepper motor. 

Next, grab more perspex, nuts and bolts, steel rods, flanges, and your third stepper motor, and build the main winding head. No dimensions are given for any of the elements, so you will need to play it by ear when building the below. 

Step 8: Build the wire feeder and guiding stylus

Next grab an old ballpoint pen, a length of a narrow hollow cylinder, plastic tubing, and acrylic block, and make the main Rodin wire feeding nozzle as shown below. This will be used to feed and guide the wire around the pegs on the main wheel. 

Next, secure the acrylic block to the top plate of the winding head, and also fashion a cushioned wire feeder using some washers and felt pads. 

With that, the main mechanical parts are now complete. 

Step 9: Build the microelectronics

Next, grab your custom PCB and microelectronic components. Assemble and gather all the parts needed, and solder into place, as shown below. 

Also, insert the Arduino Nano, and stepper motor driver modules into their respective slots. 

Next, grab the LCD screen, and mount it within its 3D printed housing. Feed the wires through the back, and wire to the main PCB as needed. 

Mount the PCB to the rear of the double-width extruder rod section of the frame. Mount the LCD screen to the frame using a regular metal bracket. 

Next, wire up all the stepper motors to the PCB too.

Upload the code to the Nano as well. This can be found at the end of the guide. 

Step 10: Feed some copper wire into the machine, and fire her up

Next, feed some copper wire through the winding machine, as required. 

Secure the free end of the wire to one of the pegs on the winding wheel in preparation for the winding process. 

Lastly, power up the electronics, enter the settings required and let the winding machine do its thing. Now all that is left to do, is sit back and enjoy the rewards of your labor.

Arduino code

As promised, here is the Arduino code in full. Copy and upload to your Nano in full.  

#include
#include "BasicStepperDriver.h"
#include "MultiDriver.h"
#include "SyncDriver.h"

#define MOTOR_STEPS 200

#define MOTOR_X_RPM 30
#define MOTOR_Y_RPM 300
#define MOTOR_Z_RPM 30

#define STEP_X 2
#define STEP_Y 3
#define STEP_Z 4

#define DIR_X 5
#define DIR_Y 6
#define DIR_Z 7

#define EN 8

int Wait = 500;
int state = 0;
int val = 0;
int flag = 0;

// If microstepping is set externally, make sure this matches the selected mode
// 1=full step, 2=half step etc.
#define MICROSTEPS 8

// 2-wire basic config, microstepping is hardwired on the driver
// Other drivers can be mixed and matched but must be configured individually
BasicStepperDriver stepperX(MOTOR_STEPS, DIR_X, STEP_X);
BasicStepperDriver stepperY(MOTOR_STEPS, DIR_Y, STEP_Y);
BasicStepperDriver stepperZ(MOTOR_STEPS, DIR_Z, STEP_Z);

// Pick one of the two controllers below
// each motor moves independently, trajectory is a hockey stick
MultiDriver controller(stepperX, stepperY, stepperZ);
// OR
// synchronized move, trajectory is a straight line
//SyncDriver controller(stepperX, stepperY);

void setup() {

stepperX.begin(MOTOR_X_RPM, MICROSTEPS);
stepperY.begin(MOTOR_Y_RPM, MICROSTEPS);
stepperZ.begin(MOTOR_Z_RPM, MICROSTEPS);
pinMode(EN,OUTPUT);
digitalWrite(EN,LOW);

stepperX.rotate(-18.8);
delay(500);

Serial.begin(9600);
}

void loop() {

if (Serial.available()>0){
flag = 1;
delay(500
}

if (flag == 1){


if (state < 4){
stepperY.move(14700);
delay(Wait);
stepperX.rotate(60);
delay(Wait);
stepperY.move(-14700);
delay (Wait);
stepperX.rotate(-191.2);
delay(Wait);
stepperY.move(-14700);
delay (Wait);
stepperX.rotate(60);
delay(Wait);
stepperY.move(14700);
delay (Wait);
stepperX.rotate(-48.8);
delay(Wait);
state ++;
}

if (state == 4){
stepperY.move(14700);
delay(Wait);
stepperX.rotate(60);
delay(Wait);
stepperY.move(-14700);
delay (Wait);
stepperX.rotate(-191.2);
delay(Wait);
stepperY.move(-14700);
delay (Wait);
stepperX.rotate(60);
delay(Wait);
stepperY.move(14700);
delay (Wait);
stepperX.rotate(-48.8);
delay(Wait);
stepperY.move(14700);
delay (Wait);
stepperX.rotate(60);
delay(Wait);
stepperY.move(-14700);
delay (Wait);
stepperX.rotate(-191.2);
delay(Wait);
stepperZ.rotate(20);
delay(Wait);
stepperY.move(-14700);
delay (Wait);
stepperX.rotate(60);
delay(Wait);
stepperY.move(14700);

state=0;
}

}

}