# Advanced Delta Printer Calibration (tower position + individual diagonal rod)

## by dolpin, published

# Summary

This calibration object will help you to calibrate angle and size errors on your delta 3d printer

These errors are typically caused by tower position errors and different diagonal rod lengths.

This calibration object will show if your printer suffers from sizing and angle errors and the instructions will help to solve these errors.

My Achatz easyDelta printer had a 1 degree error in angles and over 1mm error in sizing in certain directions. This is caused by the towers not being positioned at a perfect 120 degree angle around the center, and small individual size errors between the rods.

First errors must be fixed on the printer itself, but on some printers this might not be possible.

I used a jig to glue the joints to the diagonal rods, but small errors (1/10 mm) result in bigger errors in the print.

The basic delta printer calibration steps are:

- calibrate the print bed on each tower position by adjusting the z-height for each carriage
- correct for bowl/dome shape by adjusting the DELTA_RADIUS parameter
- tune the print size by adjusting the DIAGONAL_ROD parameter

After the basic calibration you might experience that the actual print is not equal sized in all directions and the angles in all directions are not as they should be. Resulting in for instance trapezoid objects instead of square-angle objects.

The next calibration step is to detect these errors and calibrate your printer.

These errors are typically caused by tower misplacement and differences in diagonal rod length.

After calibrating the tower angles and individual diagonal rod lengths using the marlin firmware, I managed to achieve 0 degree angle error and a maximum of 0.1 mm size error in any direction in the print !

The calibration object is printed after the basic calibration. Print out the calibration sheet and use this sheet to measure the angles between the X-Y-Z towers. Use a slide caliper to measure the print size in the X-Y-Z tower direction and calibrate your printer in the Marlin firmware.

Check the instructions for the calibration steps and how to correct this.

# Print Settings

**Printer: ** Achatz easydelta remodeled

**Rafts: ** No

**Supports: ** No

**Resolution: ** 0.2mm with 0.4mm nozzle

**Notes: **

# Instructions

Print the calibration object in PLA with 0.2mm layer height and 30% infill using a slow print speed (max 30mm/s).

Do not use ABS as ABS shrinks (0.7%) when cooling.

The 3 towers on a common delta printer are 120 degrees apart at a certain distance from the center (0,0) .

The calibration object will show tower misplacement errors and differences between the diagonal rods to the x, y, z carriage.

Prerequisites

- Make sure your towers are square and rigid to the print bed. Use a square to ensure that the printbed is absolutely square to the towers
- Using an 3 point adjustable printbed will help to set the printbed square and adjust whenever necessary after the initial calibration
- Have adjustable endstops on each carriage and a accurate endstop switch (optical or switch without lever) mounted firmly to your frame/rod

carriage with adjustable z-height: http://www.thingiverse.com/thing:738217

rigid end stop holder: http://www.thingiverse.com/thing:642363

rigid easyDelta 3d printer towers: http://www.thingiverse.com/thing:746202

Instructions:

- make sure your towers are square to the print bed and rigid
- having adjustable endstops on each tower makes calibration easier
- calibrate your printer to the print bed by using the adjustable endstops and the DELTA_RADIUS parameter (marlin?: configuration.h) to correct for bowl/dome shape, see note below
- print the calibration object (normal or small version)
- measure the angles between the x,y,z tower markers using the calibration sheet (120 degree). The sum of the angles must be 360 degrees
- measure the print sizes in each tower direction using a sliding caliper (60mm)
- correct the angles and sizes in the marlin software, see below
- return to step 3 to check the calibration and recalibrate if required

The changes for the tower angles and individual rod length are done in the marlin_main.cpp (Marlin v1.0.2, see below for Marlin v1.1.0-RC2)

**Angle correction**

look for the definitions for COS_60 and SIN_60 and add definitions for 58, 59, 61 and 62 degree

```
# define SIN_58 0.8480480961564259
# define COS_58 0.5299192642332049
# define SIN_59 0.8571673007021122
# define COS_59 0.5150380749100542
# define SIN_60 0.8660254037844386
# define COS_60 0.5
# define SIN_61 0.8746197071393958
# define COS_61 0.4848096202463370
# define SIN_62 0.8829475928589269
# define COS_62 0.4694715627858907
```

On my printer the angle between x-y was 120, y-z was 121 and z-x was 119 degree.

Use the Z tower as a base and correct the tower position for the X and Y tower (see pictures for explanation):

- X-Z angle is 119: therefore change the tower 1 (x) angle in the firmware to 59 degree
- Y-Z angle is 121: therefore change the tower 2 (y) angle in the firmware to 61 degree

The towers angles is used in 2 different places in the marlin_main.cpp and you best can change at both places

```
delta_tower1_x= -SIN_59*delta_radius;
delta_tower1_y= -COS_59*delta_radius;
delta_tower2_x= SIN_61*delta_radius;
delta_tower2_y= -COS_61*delta_radius;
delta_tower3_x= 0.0;
delta_tower3_y= delta_radius;
```

**Size correction**

Measure the x,y,z leg on the printed object and note down the measurements. Use the measured size most near to the required size to correct the general print size using the DELTA_DIAGONAL_ROD value in the configuration.h. See the note below on how to correct this

Now recalculate the print size for the other measurements by subtracting the general error from the measured sizes and use these values to correct the diagonal rod for each individual rod.

Look for the next line in marlin_main.cpp (also defined in two different places in the marlin_main.cpp:

` float delta_diagonal_rod_2 = sq(delta_diagonal_rod); `

and add a squared diagonal rod definition for each rod including the size correction

```
float delta_diagonal_rod_2_x= sq(delta_diagonal_rod*(60.25/60));
float delta_diagonal_rod_2_y= sq(delta_diagonal_rod*(60.31/60));
float delta_diagonal_rod_2_z= sq(delta_diagonal_rod);
```

Look for the function: calculate_delta in the marlin_main.cpp file and replace the calculation with the code below:

```
delta[X_AXIS] = sqrt((delta_diagonal_rod_2_x)
- 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_y)
- 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_z)
- sq(delta_tower3_x-cartesian[X_AXIS])
- sq(delta_tower3_y-cartesian[Y_AXIS])
) + cartesian[Z_AXIS];'
```

I will use my measurements as an example:

- x size: 60.67mm
- y size: 60.73mm
- z size: 60.42mm

The z size is most accurate and therefore I used this measurement to correct the general DELTA_DIAGONAL_ROD (configuration.h)

`308.7 * (60.42/60) = 310.86 (this formula is not the correct way, but gives a good starting point)`

Then I recalculated the print size (z size should have 0 error now)

- x size: 60.67 - 0.42 = 60.25 mm
- y size: 60.73 - 0.42 = 60.31 mm
- z size: 60.42 - 0.42 = 60.00 mm

And I used the recalculated print size to correct each individual rod length

```
float delta_diagonal_rod_2_x= sq(delta_diagonal_rod*(60.25/60));
float delta_diagonal_rod_2_y= sq(delta_diagonal_rod*(60.31/60));
float delta_diagonal_rod_2_z= sq(delta_diagonal_rod);
```

note:

DELTA_RADIUS increase for dome shape and decrease for bowl shape. The center (0,0) height will remain the same and the height at the outer positions will increase/decrease

DIAGONAL_ROD increase if actual print size too big and decrease if too small. Use the following formula to correct the diagonal_rod value:

`new_diagonal_rod = diagonal_rod * (measured_print_size/required_print_size) `

**Marlin v1.0.2**

The above instructions are all based on the Marlin firmware. I used v1.0.2 when I made this instruction.

I recently tested with Marlin v1.1.0-RC3 which features the individual diagonal rod parameters, but lacks the tower angle correction. Also I get issues many new issues and therefore decided to stick to version 1.0.2.

## More from 3D Printing Tests

view more## Makes

View More## Liked By

View All## Tags

## License

## Give a Shout Out

#### File Name

#### Downloads

#### Size

# All Apps

3D Print your file with 3D Hubs, the world’s largest online marketplace for 3D printing services.

App Info Launch AppThis App connects Thingiverse with Makeprintable, a cloud-based mesh repair service that analyzes, validates and repairs most common mesh errors that can occur when preparing a 3D design file for p...

App Info Launch AppKiri:Moto is an integrated cloud-based slicer and tool-path generator for 3D Printing, CAM / CNC and Laser cutting. *** 3D printing mode provides model slicing and GCode output using built-in...

App Info Launch AppWith 3D Slash, you can edit 3d models like a stonecutter. A unique interface: as fun as a building game! The perfect tool for non-designers and children to create in 3D.

App Info Launch AppThe SQ function and pow(x,2) actually give the same result.

I based my procedure on an older version of Marlin, which is constantly evolving and changing.

For the later versions use a define: DELTA_DIAGONAL_ROD_TRIM_TOWER_1 / 2 / 3 to adjust each rod. These defines are usd in the marlin_main.cpp code.

Note that my procedure is not exact science but just an approximation. Nowadays better procedures are to be found on the internet, like: http://escher3d.com/pages/wizards/wizarddelta.php

hello need help please.

i got delta printer

using marlin 1.6.1 version

i have calibrated angles successfully and now trying to calibrate the diagonal rods per instructions and formula.

i can not locate

float delta_diagonal_rod_2 = sq(delta_diagonal_rod); in marlin_main.cpp

or may be you could direct me in other way please.

only my Y tower prints larger dimension by 0.5mm more. thank you.

great job by the way!!!

I can't figure out why but this method doesn't work for me... I follow the instructions carefully but I don't have good results with dimensions. Here's what I do:

I Print the calibration object.

Angles are ok, so I check the dimensions:

I get:

x = 59.16

y = 59.05

z = 59.57

so I adjust my diagonal rod with the most accurate axis (z):

old_diagonal_rod = 196

new_diagonal_rod = sqroot((196^2) * (59.57 / 60) = 195.2964038

I adjust the measures with the gap of z axis, so:

adusted x = 59.59

adjusted y = 59.48

adjusted z = 60

I use marlin 1.1rc3 so I define in configuraition.h:

define DELTA_DIAGONAL_ROD = 195.2964038

define DELTA_DIAGONAL_ROD_TRIM_TOWER_1 (DELTA_DIAGONAL_ROD*59.59/60 - DELTA_DIAGONAL_ROD)
define DELTA_DIAGONAL_ROD_TRIM_TOWER_2 (DELTA_DIAGONAL_ROD*59.48/60 - DELTA_DIAGONAL_ROD)

define DELTA_DIAGONAL_ROD_TRIM_TOWER_3 (DELTA_DIAGONAL_ROD*60/60 - DELTA_DIAGONAL_ROD)

I print a new calibration object expecting to obtain values really near 60 for all axes, instead I get:

x = 59.83

y = 59.59

z = 60.27

what am I doing wrong?

I've been having the same problems for a long time now trying to get my delta calibrated. I've gone as far as replacing my vertexes with milled aluminum ones instead of printed ones to eliminate frame issues.

For my printer, my measurements came out to:

x = 60.00

y = 60.18

z = 60.10

(multiple prints just to be sure)

My issue is that there is something like 3 different calculations going on in the instructions and comments on how to adjust the delta diagonal rod to calibrate all three towers. The original instructions were:

sqrt( (diagonal rod^2) * (print measurement/60) )

Using my Y tower as an example, that would calculate the Y diagonal rod at 300.45 - an adjustment of +0.45.

Then there i the further instructions using Marlin 1.1 RC2 to define the adjustments using

diagonal rod * (print measurement/60) - diagonal rod

Which would calculate the diagonal rod adjustment as +0.9, or a new diagonal rod of 300.9.

The newest formula from dolphin (thanks so much for your work getting this all assembled and your continuous help btw!) is

sqrt( print measurement^2 + diagonal rod^2 - 60^2 )

Which gives me 300.04, an adjustment of +0.04.

Now all three of these can't be correct. But here's the thing - none of them are work the way I expect. The best one, and the one that makes the most sense, is the last one (0.04). When I use that formula for my Y and Z towers, and enter in the adjustments for them in Marlin as DELTA_DIAGONAL_ROD_TRIM_TOWER_2 (0.04) and 3 (0.01) here's how the print measures:

x = 59.88

y = 60.01

z = 59.88

(again, multiple prints)

So yeah, y adjusts correctly, but somehow x drops by 0.12 without being adjusted, and z drops by 0.22, overshooting the goal by 0.12. If I try to then adjust x up, y increases and is no longer at 60. I've tried fresh firmware, switching motors, stiffer frame components, different electronics - at one point tried Repetier firmware instead - and I can't get all three towers to align. Either there is something wrong with my printer at an electronics/hardware/frame level that I can't find (prints flat, towers are straight, parallel to each other, as close to 90º from the print bed, belts are tight, motor drivers are adjusted), or Marlin isn't adjusting things in the way that I expect it to.

I'm willing to try just about anything at this point to get this printer calibrated. If anybody has something that might cause my delta to do this, let me know.

The more you came near the correct size, the worst the formula works.

Don't ask me why... I'm not a mathematician.

But be aware the fact that changing a tower value, it will reflect over other towers, because of the delta math design.

As an example, I've corrected x-2, y-1.8, z-1.4 to correct an x deviation of .56, and changed the radius by 3mm to compensate build plate convexity.

Indeed the corrections all influence eachother because of the delta algorithm. I tried to work it out but noticed that i just can't get it right. When calibrating the diagonal rod length for the object size, not only the deviation and original rod length should be taken into account, but indeed also the delat radius. For calibrating the individual rod length, it not only depends on the length of one rod, but al three influence eachother.

Ideally a spreadsheet would be great, were you insert the current defined rod and radius and the measurements from the calibration obect and will result in the new individual rod lengths. I tried to resolve this, but i am not able to.

I declare my calibration object to show the errors and deviations and give some advice on how this could be adjusted using a long iterative calibration process.

Last week it took me 6 calibration prints to get all dimensions in the directions of the towers within 0.1mm

The biggest one for me is the adjustment of the tower angle. This made my printer (btw mostly cnc milled) suddenly workable

no clue, your calculation checks out.

To resolve this, first only focus on the delta_diagonal_rod size, because as you notice the z value is also not correct after the correction, and this value is only corrected by the delta_diagonal_rod value.

I have just rebuilt my diagonal rods cause the stock ones were of different sizes.

I built them using a jig and they are pretty close to the size they should.... 196mm.

I don't know where to start now to calibrate my delta...

Maybe the clue to calibrate my printer is in the step: "calibrate the print bed on each tower position by adjusting the z-height for each carriage".

I thought this means that the spider must be at the same distance from the three axes... Is this correct? Or should I put the three axis carriages at the same height without looking at the spider position? (Ok in a perfect printer l should obtain both the things simultaneously, in my printer it doesn't happen).

I am just recalculating the way the diagonal_rod values are corrected. Originally I used a different calculation, but I changed this to the calculations as given by others. I think this is indeed still not correct.

I really have to look over the whole instructions again to make it super correct. But I need to free up some time.

A few things that can be off on a delta printer

frame:

- print bed not level and square to the towers
- towers not vertical (leaning in/out/sideways)
- towers not positioned exactly at 120 degrees apart
- steps/mm for the carriages

platform:

- diagonal rod size (average and individual)
- delta_radius (average and individual)

With my calibration object I try to correct

- the diagonal rod size, which alters the object size in general and in the directions of the towers individual
- the tower angular position, which results in printed object which are not for instance square in the x/y direction

What I would like to do:

- update the instructions for the latest marlin firmware
- check all the used calibration calculations
- create an overview off all possible errors in a delta printer, the effect of the error and how to correct
- add a calibration for individual delta_radius, this will eliminate the first layer thickness issues between the towers!

tips/help always welcome

I added a new picture to the object showing another way to calculate the diagonal rod size.

Hey Just trying to calibrate... Not 100% sure i understand the way marlin rc3 calculates the Trim Towers value

The angles i have gotten are:

XZ : 120

YZ : 119

XY : 121

Does that mean the following is correct?

#define DELTA_DIAGONAL_ROD_TRIM_TOWER_1 (DELTA_DIAGONAL_ROD * 60/60 - DELTA_DIAGONAL_ROD)

#define DELTA_DIAGONAL_ROD_TRIM_TOWER_2 (DELTA_DIAGONAL_ROD * 59/60 - DELTA_DIAGONAL_ROD)

#define DELTA_DIAGONAL_ROD_TRIM_TOWER_3 (DELTA_DIAGONAL_ROD * 60/60 - DELTA_DIAGONAL_ROD)

i tried to re calculate each individual rod but the arduino ide is saying that they are not defined! please help

this is the code

// Diagonal rod squared

# define DELTA_DIAGONAL_ROD_2 pow(DELTA_DIAGONAL_ROD,2)

float delta_diagonal_rod_2_x= sq(delta_diagonal_rod*(60.26/60));
float delta_diagonal_rod_2_z= sq(delta_diagonal_rod*(60.22/60));

float delta_diagonal_rod_2_y= sq(delta_diagonal_rod);

Hello bro!

I have developed also a calibration method based on the measurement of a printed object, and I would like to have some feedback, to check mistakes.

It worked wonderfully for me, I just applied some trigonometry and particularized the calculus for specific horizontal radious.

Here is the link, i would really appreciate your opinion.

http://www.thingiverse.com/thing:1212012

Impressive work !

I am just printing it to calibrate my new GEEETECH G2S PRO. As my printer has two extruders (one at {-13,0} the other at {13,0} ) i was wondering if one print would be sufficient or if I had to print with each of the extruders ?

Hi,

Mechanically it does not matter what the position is on the platform, which is suspended between the rods. However the firmware will translate the platform position after setting the offset position for the extruders in the firmware. I am unsure what the effect of translating the extruder position in the firmware will be on the calibration.

To rule out the extruder offset translation you could set the extruder offset temporarily to 0,0 for the active printing extruder. The calibration object will just be printed slighly off center, but it is still usable as normal

Maybe someone can help me out with this. I'm following the directions for calibrating print size and adjusting the delta_diagonal_rod values. My Kossel mini has a small print bed currently and can't fit the full size print, so I scaled the print down to 75% - meaning the distance between the blocks should be 45mm.

After printing, my measurements were:

X: 44.95

Y: 44.95

Z: 44.82

Previous delta_diagonal_rod was 215.4. Calculated new diagonal_rod as 215.28. Made the changes in marlin_main to add delta_diagonal_rod_2_x, y, and z. X and Y were left as sq(delta_diagonal_rod). Z was entered as sq(delta_diagonal_rod*(44.87/45)). calculate_delta function was updated to use the new numbers.

After updating the firmware and re-printing, my measurements are now:

X: 45.00

Y: 44.99

Z: 44.88-44.90

Z is still a full 0.1mm off. I was under the assumption that after making the adjustment, they should all be much closer than that. Is there something i'm missing here?

Might be that your towers are not square to each other and the printbed. Maybe your z tower is slightly tilting inward/outward, or the printbed is not square to towers. Otherwise I have no real clue, perhaps you can re-calibrate again using the re-print

Thanks for the suggestions. I realized late last night that I had another thing working against me - my default delta_diagonal_rod was stored in EEPROM throwing off my calculations. I fixed that and ran a few more tests but still didn't get to where I wanted to be. I wasn't sure what version of Marlin I was running (it's been a while) so i updated to the newest RC and made some progress. Still not there yet and I'm running a few more tests, but as a warning to everyone who ends up here: make sure when you make changes to your firmware that your EEPROM isn't overriding those changes!

It's fantastic ! My printer thanks to your design prints round cylinder ! Today I am going to drink a beer to your health !

Works great. Also works in Marlin 1.1 RC2. When i get home i'll post the parameters that i adjusted. I have an error margin on all towers of +-0,03 mm measured on this test object.

EDIT:

in marlin_main.cpp find float delta_diagonal_rod_2_tower_1 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_1);

There you can see that the 3 rods are already configurated. Tower 1 = X, 2 =Y, 3=Z.

in my case, i edited it like this:

float delta_diagonal_rod_2_tower_1 = sq(delta_diagonal_rod*(60.3/60) + delta_diagonal_rod_trim_tower_1);
float delta_diagonal_rod_2_tower_2 = sq(delta_diagonal_rod*(60.05/60) + delta_diagonal_rod_trim_tower_2);

float delta_diagonal_rod_2_tower_3 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_3);

Works a charm.

If I correctly understand from the Marlin code, in recent version (1.1.0-RC2) you can just define in Configuration.h:

#define DELTA_DIAGONAL_ROD_TRIM_TOWER_1 (DELTA_DIAGONAL_ROD*60.3/60 - DELTA_DIAGONAL_ROD)

#define DELTA_DIAGONAL_ROD_TRIM_TOWER_2 (DELTA_DIAGONAL_ROD*60.05/60 - DELTA_DIAGONAL_ROD)

#define DELTA_DIAGONAL_ROD_TRIM_TOWER_3 (DELTA_DIAGONAL_ROD*60/60 - DELTA_DIAGONAL_ROD) // Means zero :)

And no other firmware modification is needed anymore.

Also you can use "M665 A### B### C###" to modify these values on the fly.

The tower angles can be indirectly adjusted via DELTA_RADIUS_TRIM_TOWER_[1,2,3] defines.

Hello :)

I can't find theses define in the configuration.h file.

Does this mean I have to add them and not modify existing value ?

Thanks

Yes. These defines do not exist in configuration.h file by default. But they are used in the code. They are defined elsewhere as "0" if there is no definition in configuration.h file.

So, just define them in configuration.h file and these values be used.

Interesting issue. When I replace the calculate_delta function with the code you provided, the machine refuses to move. It'll home, but that's all it will do.

I already have the code below in place of the function. As I say however, when replacing it with yours, it doesn't work!

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];

The code you use is not the code from the instruction. The code is formatted wrongly by the webpage but I do notice that there i only one ( character after the sqrt function and the instruction shows two. Use only marlin v1.0.2 and follow the instructions carefully. There might be an error in my instructions as well but the code you posted is equal to the code in the instruction

When I run this through slic3r it tries to fill in the gap between X and Z. Just one layer. Rotating it fixes, but obviously this wont work.

no clue why that is, i checked the design and did not notice that a segment of the outer circle was made out of segments instead of a circle segment. I solved this and uploaded the stl. All works fine for me with slic3r, the model is watertight and flat on the surface.

The skp design file is included, which you may use for findgin the issue for you

Works with Repetier as well and is really helpful! This is the solution for round circles! Thanks a lot!

I tried this with great result. My circle are actually cirlces now.

There is one issue though. After doing this, my hot end get really low between the towers which is in front of the tower that I adjusted the diagonal rod length of.

I couldn't print anything big since it would crash into the bed.

Did you have this issue?

Good questions, i do not have this issue, but i only needed small corrections. I do need to work on the exact science about these corrections related to all possible errors in the printer geometry.

Did you do an accurate check on the angles and sizes after correction using the calibration object? Values should be within at least 0.5 degrees and 0.5mm otherwise you will not get an flat first layer as well.

Is your printbed flat? Also ensure that your printbed is square angled with the towers, you can use a big square angle to check.

I need to work out which kind of geometry errors there, how these are corrected using the calibration object and what result this gives. For example one rod pair is 5mm longer then the rest and corrected in the firmware. How does this effect the endstop position, height above the printbed etc ...

Adaption to Repetier-Firmware

If you have eeprom enabled you can do all the calibration without recompiling or changing the code.

For the angles just change the Alpha A/B/C values like you would change the angle in Marlin formula.

For the diagonal rod length correction change the Corr. diagonal A/B/C values in EEPROM. Here you do not enter a factor like the instuctions computes but the difference between the target diagonal length and the one you have set. Just think that the value you enter gets added to the nominal diagonal length.

If all changes are in one direction, reduce them by the mean value and add that to the nominal value.

Thanks

I printed the tool and my tower angles are spot on so no corrections required. For X, y and Z size I had some variance.

The target is 60mm and My rod length is 213 currently.

X=60.39 mm

Y=59.49 mm

Z=59.23 mm

So for correction on Repetier firmware all I have to is enter

Corr. diagonal A = 213 * (60.39/60) - 213 = 1.3845
Corr. diagonal B = 213 * (59.49/60) - 213 = - 1.8105

Corr. diagonal C = 213 * (59.23/60) - 213 = - 2.7335

In the EEPROM settings and not modify DELTA_DIAGONAL_ROD ?

Please Login to Comment