Full guide to creating a HTD timing pulley in CAD (Fusion 360)

After having some trouble finding a clear guide on how to create the correct tooth profile for a HTD 5M timing pulley  I have decided to create my own. This method will also work for a HTD 3M or 8M pulley, just change the pitch accordingly.


Note: If you want a pulley with a standard number of teeth it is often easier to just modify a CAD file provided by online retailers (ie. Misumi) rather than trying to roll your own.


First a few notes about the HTD tooth profile. The correct profile courtesy of SDP-SI is shown below

HTD 5M Pulley specs

The belt has a 5mm pitch (peak to peak), a tooth height of 2.08 mm, a total belt thickness of 3.81 mm, a the tooth width is 3.05 mm, a radius of 1.49 mm and a valley radius of 0.43 mm. Note that the image below is one of many you will find online that shows an incorrect tooth profile! If you use the dimensions shown below to make the pulley in CAD it looks like that shown by SDP-SI with a flat valley.

A photo of a HTD 5M belt for comparison is shown below.


We now most of the information we need to construct the pulley.

To construct the pulley do the following:

  1. Select the number of grooves for your pulley. In this example we will choose 50 grooves.
  2. Refer to this handy timing pulley diameter calculator created by droftarts on his parametric pulley page on Thingiverse  and find the outside diameter for your selected number of teeth. In this example for 50 teeth thats 78.43 mm. This will be the diameter of the pulley if you were to measure it with a caliper.HTD OD.jpg
  3. In your cad software sketch a circle of this diameter1
  4. Calculate the diameter of your pulley if you were to measure it with a caliper valley to valley by subtracting two times the tooth height of 2.06 mm. For example: 78.43 – 2 * 2.06 = 74.31 mm. Sketch this second circle diameter of 74.31 mm.2.jpg
  5. Using a ‘2-point circle tool’ sketch a 3.05 mm circle at the top of your 74.31 mm diameter circle and fix it in place. This will form the valley of your tooth profile.346
  6. Now for the tooth valley. Create a circle with a radius 0.43 mm (0.86 mm diameter) and using the tangent tool attach its tangent to the outer 78.43 mm circle and the 3.05 mm diameter circle you just created as shown below. This will form your valley radius.5.jpg7.jpg
  7. Zooming back out we now need to sketch the tooth pitch. For our 50 groove pulley we will have a tooth every 7.2 degrees (360 degrees / 50 grooves = 7.2 degrees). Sketch a construction line 7.2 degrees away from your first circle with the origin as your point of rotation. In the example below the angle is measured from the horizontal and so becomes 90 – 7.2 = 82.8 degrees.8.jpg
  8. On this new line repeat steps 5 and 6 so that you have a full tooth profile as shown below.9.jpg
  9. In this second last step we use the centre point arc tool to sketch the inner circles of the pulley profile and finish it off with a single straight line segment be tween the two 0.86 mm dia circles. Note that in order to get the lines to meet exactly you may need to turn off grid snapping using the icon on the bottom of the window.12.jpg10.jpg11.jpg13With this done our pulley profile is now complete.
  10. In our final step we just need to repeat this profile 50 times to form our pulley. Select the lines as shown in the previous image, choose the ‘circular pattern’ tool from the sketch menu (not the create menu!), choose the origin as your point of rotation and set the quantity to your number of grooves which in this case is 50.



And thats it, your done! Now you can go create your own custom pulleys for all sorts of applications such as making custom 3D printed strain wave gears.

You may have noticed that the diameter of pulley valley is 3.05 mm and not the 2.98mm dia specified for the belt. This is ok since there must be some play between the tooth for it to engage properly.

An example of the end result after 3D printing with a 0.4mm nozzle is shown below.


You can find a copy of the CAD file on grabcad here.

Posted in 3D Design | Tagged , , , , , , , , , | Leave a comment

1kW Yaskawa servopack teardown and tuning process

This is a quick tear down of a Yaskawa servopack.

Model: SGDV-120A01A 200V 1kW (2012 Model)

Link to the datasheet here.

You can find the full album of images here.

This model of servopack can be configured either using the built in onscreen display or by using their free software over USB. Below is a screen cap of the configuration process for a 750W servopack.

If anyone happens to stumble  upon this post and your trying to get your motor to rotate make sure to check that the three phase leads to the motor are in the correct configuration. Big thanks to user Tecfacet for that one! This system does not self test at startup like an RC controller and so you must have the phases in the correct order or else the motor will shudder violently and throw a ‘current detection error’. To find the correct order just mark each of the there cables and the the 9 possible configurations or use the following:

U -> Red
V -> White
W -> Black

The motor shown in the video is a SGMJV-08ADC6S 200V 750W 2.39N.m rated. It also came paired with a 7:1 planetary reduction as shown in the video below. With this gearbox you can achieve a staggering 58.5 N.m momentary peak output!

This motor uses a 20 bit encoder giving 1048576 discrete ‘steps’. Below is a photo of the encoder with its dust cover removed.

_1190248.jpgThis level of positional accuracy is hard to fathom so here is some perspective: If you attach a mirror to the rotor and bounce a laser off it onto a wall some 20m away then a 5/1048576 positional change is still only just visible to the human eye at a calculated deviation of 0.12mm. Incredible!JPEG_20180210_174709.jpg

Even more impressive is that this level positional accuracy can be maintained even when I try and disturb the rotor by hand. The image below is from the free Yaskawa software. It is plotting in real time the encoder position. Notice that I am only able to move the rotor a few encoder counts (again, 1048576 per rotation) of its desired position.


Overall I am very impressed with the Yaskawa SGDV servopack series. Yes they are expensive but if you get a good deal second hand they are well worth the money for the right project.

Side note: If you are looking for an opensource motor controller that you can assemble your self to drive an industrial servo motor like the one shown above then I highly recommend you take a look at stmbl developed by Rene Hopf (AKA Crinq).



Posted in Electric Motors | Tagged , , , , , , | Leave a comment

Stepper motors or a BLDC servo motors? Which is better and when to use them.

Nema23 Stepper motor

Clearpath servo motors

Which is better, a stepper motor or a brushless DC (BLDC) servo motor like these from Teknic (Clearpath)?

The short answer: It depends on your application.

If you only need open-loop position control (no shaft position feedback), are on a tight budget, don’t require high shaft speeds (~600 RPM Max) and can get away with somewhat heavy and bulky motors then stepper motors are for you.

However, if you find you need closed-loop control (shaft position feedback), have more money to spend or need lots of torque in a small light weight package that can also operate at higher speeds then a BLDC servo motor is the way to go.

The slightly longer answer:

Generally speaking, anything you can do with a stepper motor you can also do with servo motor, only better. However this is not true the other way around. So why would you ever use a stepper motor?

  1. Stepper motors are super cheap.

Incredibly, you can now buy a four motor microcontroller+stepper driver kit and four stepper motors for less than $40 USD. The price for a single Clearpath motor starts at $254 and a Mechaduino servo (more later on these) comes in at $63 USD each.

  2. Open-loop stepper motors are much easier to control than a servo motor.

Simply tell a stepper motor how many steps to move and in what direction. Easy. Depending on the control electronics, a servo motors may also be used in a simple step/direction setup. However, to really make use of its performance careful tuning of its PID parameters under both static and dynamic conditions is needed. Granted, good control firmware can just about take care of this for you these days but it is still definitely something to consider if you are changing the loading which the motors are placed under on a regular basis (ie: different sized parts on an an XY table moving at high speeds) or if you ever decided to roll your own electronics and firmware.

3. High precision and high torque can achieved by stepper motors through gearing

Need 0.0375 degree per step output with 2.4 Nm of torque? Simply use x16 micro-stepping on a long body Nema 23 stepper motor with a 3:1 gear GT2 timing belt gear reduction. Even though this setup is more complicated than a single large servo, it is also much much cheaper.

4. Stepper motors can be converted to a servo motor but adding a rotary encoder.

Projects like Mechaduino have made it possible to turn a stepper motor into a servo motor in that you can have positional, velocity and torque control with sub 0.1 degree pointing capability. By knowing the shaft position it is then also possible to run a stepper motor at considerably higher speeds than would otherwise be possible.

So when should you use a dedicated servo motor?

When I say ‘dedicated servo motor’ I mean a servo motor that is designed from the ground up to be a servo motor, and not a modified stepper motor. The key difference being that a dedicated servo motor will generally not have pole plates with teeth (with each tooth acting like its own pole pair) and will generally have a lower winding inductance than a stepper motor of equal size.

You should use a dedicated servo motor when you require a high power density motor with closed loop control.

If you need a powerful motor in a small, lightweight frame that you can also precisely control then a servo motor is really your only option. For example, servo motors are almost exclusively used to drive industrial robotic arms as the amount of power (torque x angular speed = power) you can produce for a given motor size is considerably larger than an equivalent stepper motor.

Lets compare a Nema23 stepper motor from Pololu with a Hudson-series M-2310 Clearpath servo motor. Both motors have roughly the same frame size and yet the stepper is nearly twice the weight of the servo at 1.05 kg vs 0.63 kg while producing around 30 % less holding torque at 1.9 and 2.7 Nm respectively. However the real difference comes from the peak power produced by each type of motor. By using the torque torque curves from the stepper motor data sheet and assuming a simple linear reduction in torque for the servo motor to around 6000 RPM, 2000 RPM higher than its listed maximum speed of 4000 RPM  (I could not find a torque curve for Clearpath motors) we can compare the peak power produced by each motor.

Now we see that the output power of the servo is around three times that of the stepper motor with a maximum of ~350 W vs  the stepper motors ~120 W. The difference is even greater still when you consider that the open-loop stepper motors are rarely run at speeds greater than a few hundred RPM.

ServoVsStepper output poweV2r.jpg

This difference in output power is  due to the high number of poles (200 for 1.8 degree per step) found in a stepper motor that are needed o achieve its fine position control. This high number of pole pairs comes at the expense of maximum rotational speed and torque, greatly limiting the available power the motor can produce. Servo motors on the other hand are fundamentally no different to a BLDC motor.

The next step: Converting cheap and extremely powerful ‘hobby’ BLDC motors into servo motors with Odrive

Up until this point I have only discussed the Clearpath range of servo motors. However, they may soon be a considerably cheaper and yet more powerful alternative available thanks to Oskar Weigl‘s and his alpha release of a BLDC motor controller called  Odrive.

Odrive Robotics BLDC Servo Controller


The ODrive motor controller (currently in alpha) is a motor controller designed from the ground up to turn cheap BLDC motors used by RC hobbyists into powerful servo motors by coupling them with equally cheap (~8USD) rotary encoders.

Each ODrive controller board is capable of controlling two motors which are often smaller and lighter than a nema23 stepper motor but can be capable of producing many time the power and torque of even a clearpath servo motors. This is possible because these motors have been designed to be as powerful as possible at the expense of durability and efficiency. So while these motors are not suitable for industrial environments they could be of real interest to the DIY community.

The Odrive controller also has some interesting features such as the ability for regenerative-breaking. This is incredibly useful even outside of transportation applications as it makes it easy to safely remove unwanted power from your system during rapid deceleration without running it backwards through your power-supply, potentially damaging it. The Odrive is also designed to be powered in tandem with a hobby-grade Lithium polymer battery. This is also very important in order to achieve the full capabilities of these BLDC motors, which can have peak power draws in the multi-kW range. By using a high discharge Lipoly batter as a temporary energy store it becomes possible to draw the full 2 kW needed during rapid accelerations while still powering the whole system off a modest power supply.

However there are also drawbacks to adopting Odrive for your projects at this time (July 2017). Namely:

  • Features like step/direction commands are still in active development and so this system can not currently be used as a drop in replacement for your existing CNC controller like you can potentially do with Clearpath’s motors.
  • Intermittent, small volume production runs of the alpha boards translates to a high unit cost of around $100 USD for a board that can control two motors.
  • Limited documentation and discussion of how to get started makes this a project more suited to those users with prior experience in tinkering with firmware development.
  • A relatively small development community with Oskar himself doing, as far as I can tell, nearly all of the hardware and software development simultaneously means a slow release schedule is to be expected.

Still, if Odrive can successfully mature into an easy to use drop in replacement for stepper motors then there may finally be an affordable servomotor available for hobbyists that is also many time more powerful than a Clearpath servo.

I have obtained an alpha Odrive board and a few different BLDC motors to try with it and will be posting about my  findings in the next post.

Posted in Mendel Build | Tagged , , , , , , | 1 Comment

Modifying Marlin Firmware to work with a TandemB

In previous posts I built a prototype ‘TandemB’  which can be thought of as a 2D Delta printer in terms of its x and y-axis movement. This prototype could be moved about under its own power but that had no compatible firmware to drive it. In this post I cover the firmware modifications required to make the Tandem move using normal g-code commands. You can find a copy of this modified firmware here.

Modifying Marlin

Note: If you are considering doing any major modifications to firmware beyond just editing the config files I highly recommend exploring options other than the standard arduino code editor. I have been using the free community edition Visual Studio 2013 to view, modify and upload the firmware and it is a big improvement. Visual studio actively monitors the #define statements and then greys out any code that is not defined. ie: definitions that have been commented out. This makes skimming through the code much quicker as around 80% of what’s there is not in use for any one setup and so is greyed out. The tabs are also much easier to view, search and organise and I find the the compiling errors are simpler to find and diagnose. If you would like to use VS then you will also need VisualMicro for arduino support.

Marlin firmware was modified to work with my Tandem setup due to its compartmentalised nature and the fact that Craig Bossard had already started to make the very changes I needed. Craig would like to use scavenged flatbed scanner parts to build a 3D printer in the same manner as the Tandem and so had already been modifying Marlin to this end before I even started working on the Tandem idea. So thanks Craig for sending me a copy of you modified Marlin as it gave me a great starting point!

Craig’s idea was that rather than  re-writing a lot of code it would be far simpler to modify the existing Delta reverse kinematics. The required changes all take place in marlin.main.cpp.

The original Delta kinematic equations from marlin.main are shown below:

void recalc_delta_settings(float radius, float diagonal_rod)
delta_tower1_x= -SIN_60*radius; // front left tower
delta_tower1_y= -COS_60*radius;
delta_tower2_x= SIN_60*radius; // front right tower
delta_tower2_y= -COS_60*radius;
delta_tower3_x= 0.0; // back middle tower
delta_tower3_y= radius;
delta_diagonal_rod_2= sq(diagonal_rod);

void calculate_delta(float cartesian[3])
delta[X_AXIS] = sqrt(delta_diagonal_rod_2
– sq(delta_tower1_x-cartesian[X_AXIS])
– sq(delta_tower1_y-cartesian[Y_AXIS])
) + cartesian[Z_AXIS];
delta[Y_AXIS] = sqrt(delta_diagonal_rod_2
– sq(delta_tower2_x-cartesian[X_AXIS])
– sq(delta_tower2_y-cartesian[Y_AXIS])
) + cartesian[Z_AXIS];
delta[Z_AXIS] = sqrt(delta_diagonal_rod_2
– sq(delta_tower3_x-cartesian[X_AXIS])
– sq(delta_tower3_y-cartesian[Y_AXIS])
) + cartesian[Z_AXIS];

This code works off the delta tower definitions which is also located in marlin.main.cpp and is shown below:

#ifdef DELTA
float delta[3] = { 0, 0, 0 };
#define SIN_60 0.8660254037844386
#define COS_60 0.5
// these are the default values, can be overriden with M665
float delta_radius = DELTA_RADIUS;
float delta_tower1_x = -SIN_60 * delta_radius; // front left tower
float delta_tower1_y = -COS_60 * delta_radius;
float delta_tower2_x = SIN_60 * delta_radius; // front right tower
float delta_tower2_y = -COS_60 * delta_radius;
float delta_tower3_x = 0; // back middle tower
float delta_tower3_y = delta_radius;
float delta_diagonal_rod = DELTA_DIAGONAL_ROD;
float delta_diagonal_rod_2 = sq(delta_diagonal_rod);
float delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND;

Using the code above as a basis I constructed an excel spreadsheet that modeled the delta kinematics (copy here) so as to allow me to make changes to the equations and see the results in real time. Note that excel does not allow you to plot an xyz three dimensional scatter plot and so if you want to visualise the results you will need to use a third party program such as Origin Pro.

By removing one tower completely, and then redefining the z-axis to behave as the y-axis the changes were complete. A spreadsheet that models the tandem kinematics and plots the required carriage position can be found here.

The new kinematic equations in marlin for the tandem setup are shown below:

void recalc_delta_settings(float radius, float diagonal_rod)
delta_tower1_x = -radius; // front left tower
delta_tower2_x = radius; // front right tower
delta_diagonal_rod_2 = sq(diagonal_rod);

void calculate_delta(float cartesian[2])
delta[X_AXIS] = (sqrt(delta_diagonal_rod_2 – sq(delta_tower1_x – cartesian[X_AXIS])) + cartesian[Y_AXIS]);
delta[Y_AXIS] = sqrt(delta_diagonal_rod_2 – sq(delta_tower2_x – cartesian[X_AXIS])) + cartesian[Y_AXIS];
delta[Z_AXIS] = cartesian[Z_AXIS];

and the new tower definitions:

#ifdef DELTA
float delta[3] = { 0, 0, 0 };
#define SIN_60 0.8660254037844386
#define COS_60 0.5
// these are the default values, can be overriden with M665
float delta_radius = DELTA_RADIUS;
float delta_tower1_x = -delta_radius; // front left tower
float delta_tower2_x = delta_radius; // front right tower
float delta_diagonal_rod = DELTA_DIAGONAL_ROD;
float delta_diagonal_rod_2 = sq(delta_diagonal_rod);
float delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND;

For now I have left the homing code unchanged as it seems to be working fine. The only other changes were to configuration.h. Here the normal delta definitions are as follows:

// Center-to-center distance of the holes in the diagonal push rods.
#define DELTA_DIAGONAL_ROD 175.0 // mm

// Horizontal offset from middle of printer to smooth rod center. Adjust this to calibrate x-axis distance for tandem setup.
#define DELTA_SMOOTH_ROD_OFFSET 118.0 // mm

// Horizontal offset of the universal joints on the end effector.
#define DELTA_EFFECTOR_OFFSET 0.0 // mm

// Horizontal offset of the universal joints on the carriages.
#define DELTA_CARRIAGE_OFFSET 0.0 // mm

As there is no effector or carriage offset both of these values were set to zero. The DELTA_DIAGONAL_ROD distance was set to the length of the arms (175.0mm) and the DELTA_SMOOTH_ROD_OFFSET was originally set to half half the distance separating the smooth rods, just as you would in a normal delta. The result of these setting is shown below where an upscaled 40mm cube print is being dry run with a pen acting as a pen plotter.


Its clear that the cube outline is neither symmetrical or square.

In a norma Delta configuration each carriage has two parallel arms connecting it to the end effector in such a way that the resulting  parallelogram prevents the tool head from moving in any direction other than parallel to the print surface. For the TandemB setup only two arms in total are used and therefore no such parallelogram exists. It is because of this, and the fact the tool head is not directly positioned where the centre pivot is located, that we are seeing this curvature. The solution turned out to be as simple as adjusting the DELTA_SMOOTH_ROD_OFFSET from 118.0 down to 89.5 which was determined by trial and error but is something that should also be derivable mathematically. After this adjustment I can now trace cubes that are almost square.


Hopefully some fine tuning of the carriage homing positions and the tool head location is all thats now needed to make it perfect.

In the video below you can again see an upscaled ’40mm’ cube that has been stretched so as to fill the available build area and had the first layers removed so that the infill is now being drawn first.

Its far from perfect, but its a good start.

As expected, there is quite a lot of play in the z-axis (vertical) direction during rapid direction changes. This is not a problem when using a pen, as the pen acts to support itself as it pushes against the surface its drawing on. However, it will be a massive problem for a 3d printer and so needs to be addressed. I have a few ideas of how to solve this problem without reverting to the potentially much slower ‘TandemC’ design shown here and these ideas may even remove the need for any smooth rods in the whole design. More to come soon.

Posted in Tandem | Tagged , , , , , , , , , | 4 Comments

Construction of a TandemB Prototype

In a previous post I proposed the idea using an unconventional kinematic system to translation movements in the x and y axis. This idea, which was dubbed ‘Tandem’, is similar to that of a delta robot with the key difference being that rather than operating in three dimensions (X, Y and Z), it is restrained to only two (X and Y).  A mockup of the ‘TandemB’ style kinematic system  can be seen here. In this post I cover the construction of a ‘TandemB’ design which will be used for further experimentation.

CAD Drawings

The sketchup models shown previously (available here) were modified slightly and used as a basis for the design. The biggest change made was the addition of angled aluminum extrusion for the ‘arms’ as this simplified construction and is actually much lighter and stiffer than a 6mm stainless steel rod.

Sketchup Design

Each different part was arranged and dimensions added in order to make up a set up blueprints which were used for the construction.


The material chosen for construction was a 14mm thick hardwood plank simply because I happen to have this spare. Below you can see the parts needed for the x and y axis which were cut from this plank using hacksaw and then drilled out with a drill press. After a few iterations the parts came together fairly quickly.



Its interesting to note that other than the bearings, screws and M8 bolts, all the other metallic parts shown were scraped from old printers and pen plotters. I assembled the parts on a flat test board which I will use for now until I can work out the changes need to firmware to drive it correctly.


In more detail, the stepper motors are driven by a RAMPS 1.2 setup and have a 12mm spindle attached that moves a fine braided wire. This wire was also scrapped from a pen plotter. The wood screws shown below are just holding the stepper motor in place and allow for slight adjustments to its position and angle.


The wire spindles were turned down on a small lathe I have access to at work from 15mm aluminium bar stock. Each spindle then had two machine screws added to act as grub screws. I suppose something like these spindles could also be bought from an online store, but this was the fastest option available to me.


Freewheeling bearings that act as guides for the wires are located on posts at the opposite ends of  the board to the stepper motors.


The pivoting sections each slide on the smooth rods using two LM6UU bearings. In the original design I had these bearings sandwiched between two pieces of timber. However I quickly found that this restricted their movement too much, leading to jams. This was fixed by replacing the timber with an aluminium plate and using the cable tie method instead.


I had also only planned on using a single 608ZZ bearing for each pivot point. However, due to a large amount of play in the bearings when used in this way I ended up using two bearings for each pivot as this made the arms much more rigid. Thankfully, due to the timber being 14mm thick and the bearings being exactly 7mm thick, no changes were needed. With a total of six 608ZZ bearings the arms are now stiff enough that the ‘TandemC‘ design may not be required for use with a 3D printer. However, more testing is needed to tell for sure. The holes for the bearings came out slightly oversized after drilling and so rather than compressing the wood further with the screw, which risks it cracking, I added some electrical tape to each bearing to bring its outer diameter up to the right size. This is something I should also have done for the smooth rod mounts as they did end up cracking their holding posts.

Below is a view with the arm removed off its posts and flipped upside down. One smooth rod is longer than the other because they are only what I had on hand.


In order to test out the movement of the arms with the stepper motors I used a simple sketch written with the AccelStepper library. The sketch shown in the video below has the two axis moving to random positions at random speeds using something similar to the ‘Random.pde‘ example sketch.

Note that the AccelStepper library allows a maximum of 4000 steps per second for both axis combined and so I have had to use full stepping, as opposed to microstepping, in order to get a reasonable movement speed. This is far below the ~16,000 steps per second you would normally see with a RAMPS set up and leads to very noisy movements that are then made worse by the mounting board acting as a soundboard.

The next step is to now find a suitable firmware that I can modify in order to add the reverse kinematics described in the previous postMarlin firmware has been suggested as the simplest choice due to its level of segmentation, while Teacup has also been suggested due to the readability of its code. Unfortunately, after spending quite a few hours looking over the code for both I am no closer to understanding how either works due to my non-existent programing skills.

If anyone is able to help with adding ‘Tandem’ support to any RAMPS compatible firmware it would be greatly appreciated!

Posted in Tandem | Tagged , , , , , , | 6 Comments

Working in Tandem – Unconventional XY-axis layouts for 3D printing, laser cutting, CNC milling, engraving or pick and place.

Below I outline three separate concepts for moving in the X and Y plane with a specific emphasis on minimising the moving mass, maintaining high mechanical stiffness, reducing backlash and allowing two stepper motors to work in tandem. It is my hope that these concepts, or some variation of them, will make high accelerations possible in the X/Y plane without sacrificing positional accuracy.

Note: If anyone is aware of what the correct names are for these types of designs then please let me know by leaving a comment.

TandemA (Kite)

This first concept relies on the movement of two rods, jointed at an elbow by a bearing, having only four degrees of freedom: Translation forward and backwards and rotational yaw left and right. This movement style is inspired by polargraph drawing machines, but can also be thought of as one third of a Stewart platform.


An example of the movement available with this setup is shown in the video below which was made using Sketchup with the aid of the sketchyphysics plugin.

The build area (the area swept by the elbow where a tool would sit) is shown by the red filled section in the image above and has a shape that resembles a kite. The movement is brought about by the rotation of a gear on either of the two stationary stepper motors which pushes the a rod towards or away from a pivot point using a gear rack as shown by this close up image. If one rod is extended or retracted more than the other then this results in sideways movement or if both rods are extended or contracted together this a forward or backwards movement.

Advantages of TandemA

  • Like the CoreXY or Delta design, both motors can work in tandem to move the elbow joint in the conventional X/Y-axis directions. Only a specific movement through a given arc will use a single motor. In this case the shape of such an arc will be similar to the build area boundaries.
  • A high stiffness, low backlash mechanical arrangement should aid in maintaining accurate movements even with high acceleration.
  • The total moving mass for both axis is comprised of only the two rods with attached gear racks, one bearing and the tool of your choice (hot end, laser etc). This low moving mass will also allow for high acceleration without missing stepper motor steps.
  • Low parts count (3x 608ZZ bearings, 2x LM6UU linear bearings, 2x 6mm stainless rods and a cheap rack and pinion setup (or similar), and some brackets.

Disadvantages of TandemA

  • A relatively small and awkwardly shaped build area.
  • A large machine footprint relative to the build area.
  • The fast moving rods extending from the back of the machine would need to be enclosed to prevent injury.
  • Relies on computationally intensive movement calculations (square roots) for Atmel AVR based microcontrollers. However, this may be far less of a problem than that seen for delta based designs due to only operating in 2D.
  • Nonlinear deflection in the z-axis that depends on the extent of the arm extension. In other words, if you place a weight, such as an extruder or similar tool, at the end of a rod while that rod is supported from only the opposite end then it will bend (deflect) slightly. This becomes worse with longer arms or thinner rods. This point is explored further in the discussion.

If you would like to download a copy of this model, or just take a look at it in 3D without the need to install sketchup, then visit my 3D warehouse page. The Clipboard01 symbol allows for an interactive 3D fly-around view. Note that the models are a little rough around the edges and up-scaled (1mm = ~1cm) due to problems with small objects in sketchyphysics not working correctly.

TandemB (Shield)

This second concept can be thought of as a 2D cousin to the delta robot. Again, two rods are jointed at an elbow with a bearing. However, the ends of the rods furthest from the elbow stay a fixed distance apart and instead move forwards or backwards to allow the elbow to sweep the ‘shield’ shaped build area. Rather than a rack and pinion setup as used for TandemA, this setup would use a belt or wire pulley system. Although a threaded rod or lead screw setup would also work, the much larger moment of inertia of the rods would likely reduce the maximum acceleration rates achievable by a considerable amount.


Note that although the image above shows rods used for the ‘arms’, any shape or material will work provided it is stiff enough.

The video below again gives an example of the movement.

Advantages of TandemB

  • Again, both motors work in tandem to move the elbow joint in the conventional X/Y-axis directions with the exception of very specific arcs.
  • Reduced part count, moving mass and total belt length, which reduces backlash, over an equivalent (CoreXY or ultimaker style) movement system. Can be built with only two smooth rods if the arms are replaced with other materials.
  • Larger build area than TandemA and also does not suffer from the same non-linear flexing of its arms as they are at a fixed ‘extension’. Further discussion later.
  • Build area can be isolated from all stepper motors, allowing a high temperature enclosure to reducing warping when 3D printing.
  • Alternatively, the build area could be located in an unenclosed space away from the bulk of the machine for easy viewing, part extraction and extruder servicing.
  • Only two rods need to be aligned in parallel in total for both the X and Y-axis.
  • Both the X and Y-axis have the same steps/mm and mover linearly in the Y direction, simplifying calibration.

Disadvantages of TandemB

  • Relies on computationally intensive movement calculations for Atmel AVR based microcontrollers, but again, likely not as bad as a delta due to being in 2D.
  • Large horizontal footprint relative to actual build area.
  • Careful management of the Bowden cable/wire harness to the tool head is needed to prevent changes in the vertical (z-axis) loading and the resulting flex in the z-axis.
  • Possibility of the tool head oscillating in the Z-axis direction during rapid movements forwards and backwards. Further testing needed to see if this is really a problem.
  • Possibility of a high wear rates on the linear bearings. This will likely limit the total tool mass to laser cutting/engraving or 3D printing with a Bowden extruder system.

In order to overcome the last three problems outlined above there is a third option which sacrifices maximum acceleration speeds in exchange for rigidity in the z-axis.

TandemC (Box)

This design is the same as TandemB, but with the addition of a stiffening crossbar to prevent flexing in the Z axis direction. This crossbar reduces the available build area to the green square shown below and also requires that the smooth rods are lengthed.


TandemB mockup made in sketchup with sketchyphysics.

Advantages of TandemC

The same advantages as outlined for TandemB with the addition of:

  • Provided a large enough rod diameter is used, and if each axis was driven by a lead screw, then this setup could be rigid enough in the Z-axis for light milling duties and heavier tool heads than that possible with TandemB.

Disadvantages of TandemC

  •  Higher moving mass and part count than TandemB due to the addition of the crossbar, its linear bearings and mounts. The maximum acceleration will therefore be lower. There would also bow be a need for precisely parallel bars to prevent jamming, which is not true for TandemB.

Again, you can find a sketchup copy of these designs here.


Of the three ideas I think TandemA would be the most rigid in the X and Y plane and the most light weight, and therefore the fastest. However, as mentioned above it will also suffer from a deflection in the x-axis due to the bending of the rods and play in the linear bearings. Some back of the envelope calculations (end loaded cantilever beams) suggest that the deflection expected in Z axis at full extension for a 6mm diameter, 250mm long stainless steel rod is in the order of 0.5mm for a 250g load placed at its end. Needless to say this is quite large and does not even take into account the play in the linear bearings. Even if you increase the rod diameter to 10mm, which now makes them quite heavy, you would expect a deflection greater than 0.07mm. The problem only gets worse if you try to increase the already small build area by making the arms longer.

Solving this deflection problem is not as simple as adjusting the bed angle either as the deflection is not linear. It could be possible to adjust for this deflection by tieing the z-axis position in firmware to the level of arm extension or just by rotating the whole device by 90 degrees so that the arms do not need to fight gravity. However neither solution is idea. Therefore, this might limit the TandemA design to applications where tight tolerances in the Z axis are either not required (such as engravers?) or only where very light loads are placed on the rods. Really, testing is needed to know for sure.

Note that the same deflection problem exists for the TandemB design, but because the arms are at a fixed ‘extension’ once the tool hight is calibrated it should no longer be a problem.

Equations of motion

The equations of motion for TandemA design can be found here, as they should be the same as for the polargraph design. The maths the TandemB and Tandem C designs, which are both identical in this respect, are outlined below using the schimatic shown.

Tandem Setup


In order to move the ‘pivot tool’ to a given position ( x, y) , the movement required on the A and B side is described by the following equations:


Eq. of Motion.



Where the x-axis movements for A (Ax) and B (Bx) are irrelevant as they are fixed at a given distance apart while the y-axis movements are a result of the parallel bar separation distance (S, where q = 1/2*S), arm length (r) and desired x and y position.  I have made a spreadsheet where its possible to play around with the numbers and you can find that here.

I intend on building a TandemB to see just how stable it can be in the z-axis during rapid direction changes. If anyone has advice on how to implement the above motion equations into firmware that is compatible with RAMPS V1.2, or if you just have any other thoughts or comments regarding these concepts I would love to hear from you.

Posted in Tandem | Tagged , , , , , , , , , , , , , , , , , | 9 Comments

Bootstrapping a pen plotter to make a 3d printer

Back in 2010 I developed an intense interested in understanding and eventually building a 3D printer. This interest took me down the path of reading all the material available at the time and purchasing a RAMPS (V1.2) which I used to control a modified mantis made from parts found in disassembled printers with the eventual goal of turning it into a 3D printer. Although I came quite close to finishing this project I found that my my interests shifted when I moved out of home and started a full time PhD materials engineering. My ‘engineers itch’ was being more than satisfied by my day job and so this project has sat on the back burner for quite some time.

Now that I am approaching the end of my PhD and spending less time in the lab during the day I have decided to pick up where I left off. Unfortunately, the oversized mantis (dubbed the gunstrap) has long since been disassembled and thrown out. I do however still own a scientific pen plotter which I did a tear down on here and works quite well when controlled by RAMPS. The video below is this RAMPS powered pen plotter in action:

I had planned on replicating this pen plotter design to use as a 3d printer. Although I never found the time to undertake this project, it looks like a few others have adopted this design for their own printers. Note that this XY axis style has been used by 3d printer enthusiasts long before my pen plotter tear down.



Not having the time or parts to build one of the above printers I decided to use the pen plotter itself as the base for the XY axis of a 3d printer. The following photos show what I came up with.

The z-axis design is based on the common linear bearing with threaded rod design. The rods, stepper motor and aluminium plate are all donated from old laser printers. The pen plotter had its inner plate removed to allow for an extruder. Here it is setup for testing.


The heated build platform is heated by aluminium clad resistors that are thermally glued to the plate.


A dedicated 12V computer PSU is used to drive the heated build platform through a low on resistance FET. Total build platform power output is around 100W. enough to for ~90c.

The extruder hot end is machined from a single shafter of stainless steel based on hydraraptors ‘no compromise’ hot end design. Two enameled resistors are located in the hotend with a total output of 100W at 24v.

IMG_20150131_232116Another view of the hot end. The resistors are located in piece of machined aluminum which is grub screwed onto the stainless steel shaft.


This hotend is fed a 3mm PLA filament from a geared wades extruder via a PTFE tube. Here is the hotend attached to the plotter.


This whole setup was then mounted in a wooden frame.


Playing around with deisgn a few problems become apparent. The build area is severely restricted due to the way the hot end is placed. However the biggest problem is a lack of z-axis stability due to play in the x and y axis.


There is simply not enough support for the central spar as seen above.

I am currently thinking of stiffening this axis with a secondary plate and some additional bearings as shown with the layout below.


However this will require some more work. I have also since had some ideas for an unconventional X-Y axis layout that may be much more suited to 3d printing. More about that next post.

Posted in Mendel Build | 1 Comment