Hey,
here are some updates from the project "6 Axis linear Delta".

The connected motors works well.

@tkln said in 6 Axis linear Delta:

M584 X0:4 Y1:5 Z2:6 E3; two motors for x, y, z connected to driver outputs

So the first test was successful and the 6 axis linear delta does exactly what a 3 axis linear delta should do.
My plan is that the Effector can tild 45° over a 300 mm Printbed.
Fun fact the diagonal Rod length is much much longer compared to a 3 axis linear delta to achieve the 45° tilt.

Now I have to separate the 6 motors.
-> My next step is to modify the kinematics for 6 Axis.
Does anyone here have any information and/or ideas?

Is it possible to modify the files (LinearDeltaKinematics.cpp, LinearDeltaKinematics.h) and add 3 axes or is it better to create a completely new kinematic?

• LinearDeltaKinematics.cpp GithubDuet3d
• LinearDeltaKinematics.h GithubDuet3d

Can I use the Denavit-Hartenberg transformation (DH Transformation) to build the Inverse Kinematic or doesn't the RepRapFirmware support it?

I'm happy about every idea and support

Is it correct that the only difference between G1 H1 and G1 H2 is that G1 takes Entsops into account?

I use a Delta with 6 axes. I would like to connect 2 axes with each other and then decouple these axes again using Gcode, is that possible?
The motors can be coupled to one another via M584. I would now like to do the homeing sequence with the coupled motors and then decouple the motors via a gcode command.

; Drives
M569 P0.0 S1                           ; physical drive 0.0 goes forwards
M569 P0.1 S0                           ; physical drive 0.1 goes backwards
M569 P0.2 S0                           ; physical drive 0.2 goes backwards
M569 P1.0 S1                           ; physical drive 1.0 goes forwards
M569 P1.1 S1                           ; physical drive 1.1 goes forwards
M569 P1.2 S1                           ; physical drive 1.2 goes forwards
M569 P121.0 S1                         ; physical drive 121.0 goes forwards
M569 P122.0 S1                         ; physical drive 121.0 goes forwards
M569 P123.0 S1                         ; physical drive 121.0 goes forwards
M569 P124.0 S1                         ; physical drive 121.0 goes forwards
M584 X0.0 Y0.1:0.2 Z1.0:1.1:1.2 E121.0:122.0:123.0:124.0 ; set drive mapping

@apak
Thank you for the solution.

@tkln
Solution: https://forum.duet3d.com/post/315912

Hello,
is it possible to move the axes of a Delta printer independently of the Cartesian coordinates? I mean that I enter a gcode command like G0 X10, by default it would now move 10 mm in the X direction and move the linear slides, but I would like to control the motors directly and say G? Motor_1 10 and then the motor moves 10 mm.
Is there a solution for this?

Best regards
Tim

@dc42
Okay, last question for today, it's getting late in Germany
Sorry for all the questions but I'm so excited to finally see the machines in action.
If I just want to test the 6-axis kinematics first, is it possible to create 6 axes with "Creating additional axes" and feed them with motor positions? I would then convert a Gcode with my 6-axis kinematics and then give the values to the Duet.
Is there a command that I do not control the ABCDEF axes using Cartesian coordinates (X10 Y10 Z5) but directly using steps (A5 B10 C10 D10 E100 F10)?
Is there anything against it?

@dc42
Ah the tip with the Rotary Delta helped me, thanks. Now I can compare a bit.

@dc42
I understand that would be the best option for clean and orderly documentation.
I would like to test my kinematics first and for that I would like to have only the most necessary things in the kinematics file and keep everything as short as possible. For that I would like to not add something like autocalibration etc. in the first place.

@dc42
Is it correct that machinePos[X_AXIS], machinePos[Y_AXIS], machinePos[Z_AXIS] calculates the Z coordinate of the linear slides?

// Calculate the Cartesian coordinates from the motor coordinates
void LinearDeltaKinematics::ForwardTransform(float Ha, float Hb, float Hc, float machinePos[XYZ_AXES]) const noexcept
{
	// Calculate RSUT such that x = (Uz + S)/Q, y = -(Rz + T)/Q
	const float R = ((Xbc * Ha) + (Xca * Hb) + (Xab * Hc)) * 2;
	const float U = ((Ybc * Ha) + (Yca * Hb) + (Yab * Hc)) * 2;

	// Note, Ka + Kb + Kc = 0 so we could calculate just two of them
	const float Ka = coreKa + (fsquare(Hc) - fsquare(Hb)),
				Kb = coreKb + (fsquare(Ha) - fsquare(Hc)),
				Kc = coreKc + (fsquare(Hb) - fsquare(Ha));

	const float S = Ka * towerY[DELTA_A_AXIS] + Kb * towerY[DELTA_B_AXIS] + Kc * towerY[DELTA_C_AXIS];
	const float T = Ka * towerX[DELTA_A_AXIS] + Kb * towerX[DELTA_B_AXIS] + Kc * towerX[DELTA_C_AXIS];

	const float A = fsquare(U) + fsquare(R) + Q2;
	const float minusHalfB =  Q2 * Ha
							+ Q * (U * towerX[DELTA_A_AXIS] - R * towerY[DELTA_A_AXIS])
							- (R * T + U * S);
	const float C = fsquare(towerX[DELTA_A_AXIS] * Q - S) + fsquare(towerY[DELTA_A_AXIS] * Q + T) + (fsquare(Ha) - D2[DELTA_A_AXIS]) * Q2;

	const float z = (minusHalfB - fastSqrtf(fsquare(minusHalfB) - A * C)) / A;
	machinePos[X_AXIS] = (U * z + S) / Q;
	machinePos[Y_AXIS] = -(R * z + T) / Q;
	machinePos[Z_AXIS] = z - ((machinePos[X_AXIS] * xTilt) + (machinePos[Y_AXIS] * yTilt));

@dc42

I have several questions about the LinearDeltaKinematics.h file.

1. Is it enough to change these things in this file UsualNumTowers and "Axis names used internally" + "Derived values" for my kinematic calculation?

static constexpr size_t UsualNumTowers = 3; 
-> static constexpr size_t UsualNumTowers = 6;```

	// Axis names used internally
	static constexpr size_t DELTA_A_AXIS = 0;
	static constexpr size_t DELTA_B_AXIS = 1;
	static constexpr size_t DELTA_C_AXIS = 2;
	static constexpr size_t DELTA_D_AXIS = 3;
	static constexpr size_t DELTA_E_AXIS = 4;
	static constexpr size_t DELTA_F_AXIS = 5;

2. Can i use SUPPORT_LINEAR_DELTA for my Six Axis Delta or do I have to change something there?