Store distances in the TARGET structure always in micrometers.

This is a intrusive patch and for now, it's done for the X axis only.
To make comparison with the former approach easier ...

The advantages of this change:

- Converting from mm to steps in gcode_parse.c and back in dda.c
  wastes cycles and accuracy.

- In dda.c, UM_PER_STEP simply goes away, so distance calculations
  work now with STEPS_PER_MM > 500 just fine. 1/16 microstepping
  on threaded rods (Z axis) becomes possible.

- Distance calculations (feedrate, acceleration, ...) become much
  simpler.

- A wide range of STEPS_PER_M can now be handled at reasonable
  (4 decimal digit) accuracy with a simple macro. Formerly,
  we were limited to 500 steps/mm, now we can do 4'096 steps/mm
  and could easily raise this another digit.

Disadvantages:

- STEPS_PER_MM is gone in config.h, using STEPS_PER_M is required,
  because the preprocessor refuses to compare numbers with decimal
  points in them.

- The DDA has to store the position in steps anyways to avoid
  rounding errors.

config.default.h

@@ -48,12 +48,22 @@
 		All numbers are fixed point integers, so no more than 3 digits to the right of the decimal point, please :-)
 */
 
-/// calculate these values appropriate for your machine
+/** \def STEPS_PER_M
-/// for threaded rods, this is (steps motor per turn) / (pitch of the thread)
+	steps per meter ( = steps per mm * 1000 )
-/// for belts, this is (steps per motor turn) / (number of gear teeth) / (belt module)
+
-/// half-stepping doubles the number, quarter stepping requires * 4, etc.
+	calculate these values appropriate for your machine
-/// valid range = 0.020 to 4194.303
+
-#define	STEPS_PER_MM_X				320.000
+	for threaded rods, this is
+		(steps motor per turn) / (pitch of the thread) * 1000
+
+	for belts, this is
+		(steps per motor turn) / (number of gear teeth) / (belt module) * 1000
+
+	half-stepping doubles the number, quarter stepping requires * 4, etc.
+
+	valid range = 20 to 4'0960'000 (0.02 to 40960 steps/mm)
+*/
+#define	STEPS_PER_M_X					320000
 #define	STEPS_PER_MM_Y				320.000
 #define	STEPS_PER_MM_Z				320.000
 

config.gen3.h

@@ -45,16 +45,22 @@
 */
 #define	HOST
 
-/*
+/** \def STEPS_PER_M
-	Values reflecting the gearing of your machine.
+	steps per meter ( = steps per mm * 1000 )
-		All numbers are fixed point integers, so no more than 3 digits to the right of the decimal point, please :-)
 
 	calculate these values appropriate for your machine
-	for threaded rods, this is (steps motor per turn) / (pitch of the thread)
+
-	for belts, this is (steps per motor turn) / (number of gear teeth) / (belt module)
+	for threaded rods, this is
+		(steps motor per turn) / (pitch of the thread) * 1000
+
+	for belts, this is
+		(steps per motor turn) / (number of gear teeth) / (belt module) * 1000
+
 	half-stepping doubles the number, quarter stepping requires * 4, etc.
+
+	valid range = 20 to 4'0960'000 (0.02 to 40960 steps/mm)
 */
-#define	STEPS_PER_MM_X				320.000
+#define	STEPS_PER_M_X					320000
 #define	STEPS_PER_MM_Y				320.000
 #define	STEPS_PER_MM_Z				200.000
 

config.gen6.h

@@ -50,11 +50,22 @@
 		All numbers are fixed point integers, so no more than 3 digits to the right of the decimal point, please :-)
 */
 
-// calculate these values appropriate for your machine
+/** \def STEPS_PER_M
-// for threaded rods, this is (steps motor per turn) / (pitch of the thread)
+	steps per meter ( = steps per mm * 1000 )
-// for belts, this is (steps per motor turn) / (number of gear teeth) / (belt module)
+
-// The GEN6 board uses 1/8 microstepping, so multiply your values by 8.
+	calculate these values appropriate for your machine
-#define	STEPS_PER_MM_X				(320.000*8)
+
+	for threaded rods, this is
+		(steps motor per turn) / (pitch of the thread) * 1000
+
+	for belts, this is
+		(steps per motor turn) / (number of gear teeth) / (belt module) * 1000
+
+	half-stepping doubles the number, quarter stepping requires * 4, etc.
+
+	valid range = 20 to 4'0960'000 (0.02 to 40960 steps/mm)
+*/
+#define	STEPS_PER_M_X					(5000*8)
 #define	STEPS_PER_MM_Y				(320.000*8)
 #define	STEPS_PER_MM_Z				(200.000*8)
 

config.gen7.h

@@ -53,12 +53,22 @@
 		All numbers are fixed point integers, so no more than 3 digits to the right of the decimal point, please :-)
 */
 
-/// calculate these values appropriate for your machine
+/** \def STEPS_PER_M
-/// for threaded rods, this is (steps motor per turn) / (pitch of the thread)
+	steps per meter ( = steps per mm * 1000 )
-/// for belts, this is (steps per motor turn) / (number of gear teeth) / (belt module)
+
-/// half-stepping doubles the number, quarter stepping requires * 4, etc.
+	calculate these values appropriate for your machine
-/// valid range = 0.020 to 4194.303
+
-#define	STEPS_PER_MM_X				40.000
+	for threaded rods, this is
+		(steps motor per turn) / (pitch of the thread) * 1000
+
+	for belts, this is
+		(steps per motor turn) / (number of gear teeth) / (belt module) * 1000
+
+	half-stepping doubles the number, quarter stepping requires * 4, etc.
+
+	valid range = 20 to 4'0960'000 (0.02 to 40960 steps/mm)
+*/
+#define	STEPS_PER_M_X					40000
 #define	STEPS_PER_MM_Y				40.000
 #define	STEPS_PER_MM_Z				320.000
 

config.ramps-v1.2.h

@@ -50,16 +50,27 @@
 		All numbers are fixed point integers, so no more than 3 digits to the right of the decimal point, please :-)
 */
 
-// calculate these values appropriate for your machine
+/** \def STEPS_PER_M
-// for threaded rods, this is (steps motor per turn) / (pitch of the thread)
+	steps per meter ( = steps per mm * 1000 )
-// for belts, this is (steps per motor turn) / (number of gear teeth) / (belt module)
+
-// half-stepping doubles the number, quarter stepping requires * 4, etc.
+	calculate these values appropriate for your machine
+
+	for threaded rods, this is
+		(steps motor per turn) / (pitch of the thread) * 1000
+
+	for belts, this is
+		(steps per motor turn) / (number of gear teeth) / (belt module) * 1000
+
+	half-stepping doubles the number, quarter stepping requires * 4, etc.
+
+	valid range = 20 to 4'0960'000 (0.02 to 40960 steps/mm)
+*/
 #define MICROSTEPPING_X				16.0
 #define MICROSTEPPING_Y				16.0
 #define MICROSTEPPING_Z				16.0
 #define MICROSTEPPING_E				4.0
 
-#define	STEPS_PER_MM_X				(5.023*MICROSTEPPING_X)
+#define	STEPS_PER_M_X					(5023*MICROSTEPPING_X)
 #define	STEPS_PER_MM_Y				(5.023*MICROSTEPPING_Y)
 #define	STEPS_PER_MM_Z				(416.699*MICROSTEPPING_Z)
 

config.ramps-v1.3.h

@@ -50,16 +50,27 @@
 		All numbers are fixed point integers, so no more than 3 digits to the right of the decimal point, please :-)
 */
 
-// calculate these values appropriate for your machine
+/** \def STEPS_PER_M
-// for threaded rods, this is (steps motor per turn) / (pitch of the thread)
+	steps per meter ( = steps per mm * 1000 )
-// for belts, this is (steps per motor turn) / (number of gear teeth) / (belt module)
+
-// half-stepping doubles the number, quarter stepping requires * 4, etc.
+	calculate these values appropriate for your machine
+
+	for threaded rods, this is
+		(steps motor per turn) / (pitch of the thread) * 1000
+
+	for belts, this is
+		(steps per motor turn) / (number of gear teeth) / (belt module) * 1000
+
+	half-stepping doubles the number, quarter stepping requires * 4, etc.
+
+	valid range = 20 to 4'0960'000 (0.02 to 40960 steps/mm)
+*/
 #define MICROSTEPPING_X				16.0
 #define MICROSTEPPING_Y				16.0
 #define MICROSTEPPING_Z				16.0
 #define MICROSTEPPING_E				4.0
 
-#define	STEPS_PER_MM_X				(5.023*MICROSTEPPING_X)
+#define	STEPS_PER_M_X					(5023*MICROSTEPPING_X)
 #define	STEPS_PER_MM_Y				(5.023*MICROSTEPPING_Y)
 #define	STEPS_PER_MM_Z				(416.699*MICROSTEPPING_Z)
 

config.sanguinololu-v1.1.h

@@ -49,15 +49,27 @@
 		All numbers are fixed point integers, so no more than 3 digits to the right of the decimal point, please :-)
 */
 
-/// calculate these values appropriate for your machine
+/** \def STEPS_PER_M
-/// for threaded rods, this is (steps motor per turn) / (pitch of the thread)
+	steps per meter ( = steps per mm * 1000 )
-/// for belts, this is (steps per motor turn) / (number of gear teeth) / (belt module)
+
+	calculate these values appropriate for your machine
+
+	for threaded rods, this is
+		(steps motor per turn) / (pitch of the thread) * 1000
+
+	for belts, this is
+		(steps per motor turn) / (number of gear teeth) / (belt module) * 1000
+
+	half-stepping doubles the number, quarter stepping requires * 4, etc.
+
+	valid range = 20 to 4'0960'000 (0.02 to 40960 steps/mm)
+*/
 #define MICROSTEPPING_X				16.0
 #define MICROSTEPPING_Y				16.0
 #define MICROSTEPPING_Z				16.0
 #define MICROSTEPPING_E				4.0
 
-#define	STEPS_PER_MM_X				(5.023*MICROSTEPPING_X)
+#define	STEPS_PER_M_X					(5023*MICROSTEPPING_X)
 #define	STEPS_PER_MM_Y				(5.023*MICROSTEPPING_Y)
 #define	STEPS_PER_MM_Z				(416.699*MICROSTEPPING_Z)
 

config.sanguinololu-v1.2.h

@@ -49,15 +49,27 @@
 		All numbers are fixed point integers, so no more than 3 digits to the right of the decimal point, please :-)
 */
 
-/// calculate these values appropriate for your machine
+/** \def STEPS_PER_M
-/// for threaded rods, this is (steps motor per turn) / (pitch of the thread)
+	steps per meter ( = steps per mm * 1000 )
-/// for belts, this is (steps per motor turn) / (number of gear teeth) / (belt module)
+
+	calculate these values appropriate for your machine
+
+	for threaded rods, this is
+		(steps motor per turn) / (pitch of the thread) * 1000
+
+	for belts, this is
+		(steps per motor turn) / (number of gear teeth) / (belt module) * 1000
+
+	half-stepping doubles the number, quarter stepping requires * 4, etc.
+
+	valid range = 20 to 4'0960'000 (0.02 to 40960 steps/mm)
+*/
 #define MICROSTEPPING_X				16.0
 #define MICROSTEPPING_Y				16.0
 #define MICROSTEPPING_Z				16.0
 #define MICROSTEPPING_E				4.0
 
-#define	STEPS_PER_MM_X				(5.023*MICROSTEPPING_X)
+#define	STEPS_PER_M_X					(5023*MICROSTEPPING_X)
 #define	STEPS_PER_MM_Y				(5.023*MICROSTEPPING_Y)
 #define	STEPS_PER_MM_Z				(416.699*MICROSTEPPING_Z)
 

dda.c

@@ -24,6 +24,10 @@
 	#include	"heater.h"
 #endif
 
+#ifdef STEPS_PER_MM_X
+#error STEPS_PER_MM_X is gone, review your config.h and use STEPS_PER_M_X
+#endif
+
 /// step timeout
 volatile uint8_t	steptimeout = 0;
 
@@ -35,6 +39,10 @@ volatile uint8_t	steptimeout = 0;
 /// \brief target position of last move in queue
 TARGET startpoint __attribute__ ((__section__ (".bss")));
 
+/// \var startpoint_steps
+/// \brief target position of last move in queue, expressed in steps
+TARGET startpoint_steps __attribute__ ((__section__ (".bss")));
+
 /// \var current_position
 /// \brief actual position of extruder head
 /// \todo make current_position = real_position (from endstops) + offset from G28 and friends
@@ -174,10 +182,18 @@ void dda_init(void) {
 
 	#ifdef ACCELERATION_RAMPING
 		move_state.n = 1;
-		move_state.c = ((uint32_t)((double)F_CPU / sqrt((double)(STEPS_PER_MM_X * ACCELERATION)))) << 8;
+		move_state.c = ((uint32_t)((double)F_CPU / sqrt((double)(STEPS_PER_M_X * ACCELERATION / 1000.)))) << 8;
 	#endif
 }
 
+/*! Distribute a new startpoint to DDA's internal structures without any movement.
+
+	This is needed for example after homing or a G92. The new location must be in startpoint already.
+*/
+void dda_new_startpoint(void) {
+	um_to_steps_x(startpoint_steps.X, startpoint.X);
+}
+
 /*! CREATE a dda given current_position and a target, save to passed location so we can write directly into the queue
 	\param *dda pointer to a dda_queue entry to overwrite
 	\param *target the target position of this move
@@ -191,6 +207,7 @@ void dda_init(void) {
 	This algorithm is probably the main limiting factor to print speed in terms of firmware limitations
 */
 void dda_create(DDA *dda, TARGET *target) {
+	uint32_t	steps, x_delta_um /*, y_delta_um, z_delta_um, e_delta_um */;
 	uint32_t	distance, c_limit, c_limit_calc;
 
 	// initialise DDA to a known state
@@ -202,7 +219,12 @@ void dda_create(DDA *dda, TARGET *target) {
 	// we end at the passed target
 	memcpy(&(dda->endpoint), target, sizeof(TARGET));
 
-	dda->x_delta = labs(target->X - startpoint.X);
+	x_delta_um = (uint32_t)labs(target->X - startpoint.X);
+
+	um_to_steps_x(steps, target->X);
+	dda->x_delta = labs(steps - startpoint_steps.X);
+	startpoint_steps.X = steps;
+
 	dda->y_delta = labs(target->Y - startpoint.Y);
 	dda->z_delta = labs(target->Z - startpoint.Z);
 	dda->e_delta = labs(target->E - startpoint.E);
@@ -241,11 +263,11 @@ void dda_create(DDA *dda, TARGET *target) {
 
 		// since it's unusual to combine X, Y and Z changes in a single move on reprap, check if we can use simpler approximations before trying the full 3d approximation.
 		if (dda->z_delta == 0)
-			distance = approx_distance(dda->x_delta * UM_PER_STEP_X, dda->y_delta * UM_PER_STEP_Y);
+			distance = approx_distance(x_delta_um, dda->y_delta * UM_PER_STEP_Y);
 		else if (dda->x_delta == 0 && dda->y_delta == 0)
 			distance = dda->z_delta * UM_PER_STEP_Z;
 		else
-			distance = approx_distance_3(dda->x_delta * UM_PER_STEP_X, dda->y_delta * UM_PER_STEP_Y, dda->z_delta * UM_PER_STEP_Z);
+			distance = approx_distance_3(x_delta_um, dda->y_delta * UM_PER_STEP_Y, dda->z_delta * UM_PER_STEP_Z);
 
 		if (distance < 2)
 			distance = dda->e_delta * UM_PER_STEP_E;
@@ -279,7 +301,7 @@ void dda_create(DDA *dda, TARGET *target) {
 		// do this for each axis individually, as the combined speed of two or more axes can be higher than the capabilities of a single one.
 		c_limit = 0;
 		// check X axis
-		c_limit_calc = ( (dda->x_delta * (UM_PER_STEP_X * 2400L)) / dda->total_steps * (F_CPU / 40000) / MAXIMUM_FEEDRATE_X) << 8;
+		c_limit_calc = ((x_delta_um * 2400L) / dda->total_steps * (F_CPU / 40000) / MAXIMUM_FEEDRATE_X) << 8;
 		if (c_limit_calc > c_limit)
 			c_limit = c_limit_calc;
 		// check Y axis
@@ -357,8 +379,12 @@ void dda_create(DDA *dda, TARGET *target) {
 			dda->c_min = (move_duration / target->F) << 8;
 			if (dda->c_min < c_limit)
 				dda->c_min = c_limit;
+// This section is plain wrong, like in it's only half of what we need. This factor 960000 is dependant on STEPS_PER_MM.
 			// overflows at target->F > 65535; factor 16. found by try-and-error; will overshoot target speed a bit
-			dda->rampup_steps = target->F * target->F / (uint32_t)(STEPS_PER_MM_X * ACCELERATION / 16.);
+			dda->rampup_steps = target->F * target->F / (uint32_t)(STEPS_PER_M_X * ACCELERATION / 960000.);
+//sersendf_P(PSTR("rampup calc %lu\n"), dda->rampup_steps);
+			dda->rampup_steps = 100000; // replace mis-calculation by a safe value
+// End of wrong section.
 			if (dda->rampup_steps > dda->total_steps / 2)
 				dda->rampup_steps = dda->total_steps / 2;
 			dda->rampdown_steps = dda->total_steps - dda->rampup_steps;
@@ -627,11 +653,20 @@ void dda_step(DDA *dda) {
 			move_state.c = (int32_t)move_state.c - ((int32_t)(move_state.c * 2) / (int32_t)move_state.n);
 		}
 		move_state.step_no++;
+// Print the number of steps actually needed for ramping up
+// Needed for comparing the number with the one calculated in dda_create()
+//static char printed = 0;
+//if (printed == 0 && dda->c_min >= move_state.c) {
+//  sersendf_P(PSTR("speedup %lu steps\n"), move_state.step_no);
+//  printed = 1;
+//}
+//if (move_state.step_no < 3) printed = 0;
 
 		// debug ramping algorithm
-		// for very low speeds like 10 mm/min, only
+		// raise this 10 for higher speeds to avoid flooding the serial line
-		//if (move_state.step_no % 10 /* 10, 100, ...*/ == 0)
+		//if (move_state.step_no % 10 /* 10, 50, 100, ...*/ == 0)
-		//	sersendf_P(PSTR("\r\nc %lu  c_min %lu  n %d"), dda->c, dda->c_min, move_state.n);
+		//	sersendf_P(PSTR("\r\nc %lu  c_min %lu  n %ld"),
+		//	           move_state.c, dda->c_min, move_state.n);
 	#endif
 
 	// TODO: If we stop axes individually, could we home two or more axes at the same time?
@@ -690,9 +725,14 @@ void update_current_position() {
 	}
 	else if (dda->live) {
 		if (dda->x_direction)
-			current_position.X = dda->endpoint.X - move_state.x_steps;
+			// (STEPS_PER_M_X / 1000) is a bit inaccurate for low STEPS_PER_M numbers
+			current_position.X = dda->endpoint.X -
+			                     // should be: move_state.x_steps * 1000000 / STEPS_PER_M_X)
+			                     // but x_steps can be like 1000000 already, so we'd overflow
+			                     move_state.x_steps * 1000 / ((STEPS_PER_M_X + 500) / 1000);
 		else
-			current_position.X = dda->endpoint.X + move_state.x_steps;
+			current_position.X = dda->endpoint.X +
+			                     move_state.x_steps * 1000 / ((STEPS_PER_M_X + 500) / 1000);
 
 		if (dda->y_direction)
 			current_position.Y = dda->endpoint.Y - move_state.y_steps;

dda.h

@@ -5,9 +5,30 @@
 
 #include	"config.h"
 
+/*
+	micrometer to steps conversion
+
+	handle a few cases to avoid overflow while keeping reasonable accuracy
+	input is up to 20 bits, so we can multiply by 4096 at most
+*/
+#if	STEPS_PER_M_X >= 4096000
+	#define	um_to_steps_x(dest, src) \
+		do { dest = (src * (STEPS_PER_M_X / 10000L) + 50L) / 100L; } while (0)
+#elif	STEPS_PER_M_X >= 409600
+	#define	um_to_steps_x(dest, src) \
+		do { dest = (src * (STEPS_PER_M_X / 1000L) + 500L) / 1000L; } while (0)
+#elif	STEPS_PER_M_X >= 40960
+	#define	um_to_steps_x(dest, src) \
+		do { dest = (src * (STEPS_PER_M_X / 100L) + 5000L) / 10000L; } while (0)
+#elif	STEPS_PER_M_X >= 4096
+	#define	um_to_steps_x(dest, src) \
+		do { dest = (src * (STEPS_PER_M_X / 10L) + 50000L) / 100000L; } while (0)
+#else
+	#define	um_to_steps_x(dest, src) \
+		do { dest = (src * (STEPS_PER_M_X / 1L) + 500000L) / 1000000L; } while (0)
+#endif
+
 // Used in distance calculation during DDA setup
-/// micrometers per step X
-#define	UM_PER_STEP_X		1000L / ((uint32_t) STEPS_PER_MM_X)
 /// micrometers per step Y
 #define	UM_PER_STEP_Y		1000L / ((uint32_t) STEPS_PER_MM_Y)
 /// micrometers per step Z
@@ -25,7 +46,12 @@
 	types
 */
 
-// target is simply a point in space/time
+/**
+	\struct TARGET
+	\brief target is simply a point in space/time
+
+	X, Y, Z and E are in micrometers unless explcitely stated. F is in mm/min.
+*/
 typedef struct {
 	int32_t						X;
 	int32_t						Y;
@@ -59,7 +85,7 @@ typedef struct {
 	/// time until next step
 	uint32_t					c;
 	/// tracking variable
-	int16_t						n;
+	int32_t						n;
 	#endif
 
 	/// Endstop debouncing
@@ -139,6 +165,9 @@ extern volatile uint8_t steptimeout;
 /// startpoint holds the endpoint of the most recently created DDA, so we know where the next one created starts. could also be called last_endpoint
 extern TARGET startpoint;
 
+/// the same as above, counted in motor steps
+extern TARGET startpoint_steps;
+
 /// current_position holds the machine's current position. this is only updated when we step, or when G92 (set home) is received.
 extern TARGET current_position;
 
@@ -155,6 +184,9 @@ const uint8_t	msbloc (uint32_t v)																		__attribute__ ((const));
 // initialize dda structures
 void dda_init(void);
 
+// distribute a new startpoint
+void dda_new_startpoint(void);
+
 // create a DDA
 void dda_create(DDA *dda, TARGET *target);
 

dda_queue.c

@@ -147,7 +147,7 @@ void enqueue_home(TARGET *t, uint8_t endstop_check, uint8_t endstop_stop_cond) {
 			MEMORY_BARRIER();
 			SREG = save_reg;
 		}
-	}	
+	}
 }
 
 /// go to the next move.

gcode_parse.c

@@ -29,7 +29,6 @@
 	which is about the worst case we have. All other machines have a bigger build volume.
 */
 
-#define	STEPS_PER_M_X			((uint32_t) ((STEPS_PER_MM_X * 1000.0) + 0.5))
 #define	STEPS_PER_M_Y			((uint32_t) ((STEPS_PER_MM_Y * 1000.0) + 0.5))
 #define	STEPS_PER_M_Z			((uint32_t) ((STEPS_PER_MM_Z * 1000.0) + 0.5))
 #define	STEPS_PER_M_E			((uint32_t) ((STEPS_PER_MM_E * 1000.0) + 0.5))
@@ -38,7 +37,6 @@
 	mm -> inch conversion
 */
 
-#define	STEPS_PER_IN_X		((uint32_t) ((25.4 * STEPS_PER_MM_X) + 0.5))
 #define	STEPS_PER_IN_Y		((uint32_t) ((25.4 * STEPS_PER_MM_Y) + 0.5))
 #define	STEPS_PER_IN_Z		((uint32_t) ((25.4 * STEPS_PER_MM_Z) + 0.5))
 #define	STEPS_PER_IN_E		((uint32_t) ((25.4 * STEPS_PER_MM_E) + 0.5))
@@ -81,6 +79,8 @@ GCODE_COMMAND next_target		__attribute__ ((__section__ (".bss")));
 */
 extern const uint32_t powers[];  // defined in sermsg.c
 
+// TODO: When the new approach to pass distances in micrometers instead of step
+//       numbers stays, this should be replaced by a simplified version.
 /// convert a floating point input value into an integer with appropriate scaling.
 /// \param *df pointer to floating point structure that holds fp value to convert
 /// \param multiplicand multiply by this amount during conversion to integer
@@ -137,9 +137,9 @@ void gcode_parse_char(uint8_t c) {
 					break;
 				case 'X':
 					if (next_target.option_inches)
-						next_target.target.X = decfloat_to_int(&read_digit, STEPS_PER_IN_X, 0);
+						next_target.target.X = decfloat_to_int(&read_digit, 25400, 1);
 					else
-						next_target.target.X = decfloat_to_int(&read_digit, STEPS_PER_M_X, 1);
+						next_target.target.X = decfloat_to_int(&read_digit, 1000, 0);
 					if (DEBUG_ECHO && (debug_flags & DEBUG_ECHO))
 						serwrite_int32(next_target.target.X);
 					break;

gcode_process.c

@@ -9,6 +9,7 @@
 
 #include	"gcode_parse.h"
 
+#include	"dda.h"
 #include	"dda_queue.h"
 #include	"watchdog.h"
 #include	"delay.h"
@@ -77,12 +78,12 @@ void process_gcode_command() {
 
 	// implement axis limits
 	#ifdef	X_MIN
-		if (next_target.target.X < (X_MIN * STEPS_PER_MM_X))
+		if (next_target.target.X < X_MIN * 1000.)
-			next_target.target.X = X_MIN * STEPS_PER_MM_X;
+			next_target.target.X = X_MIN * 1000.;
 	#endif
 	#ifdef	X_MAX
-		if (next_target.target.X > (X_MAX * STEPS_PER_MM_X))
+		if (next_target.target.X > X_MAX * 1000.))
-			next_target.target.X = X_MAX * STEPS_PER_MM_X;
+			next_target.target.X = X_MAX * 1000.;
 	#endif
 	#ifdef	Y_MIN
 		if (next_target.target.Y < (Y_MIN * STEPS_PER_MM_Y))
@@ -301,6 +302,8 @@ void process_gcode_command() {
 					startpoint.Y = next_target.target.Y =
 					startpoint.Z = next_target.target.Z = 0;
 				}
+
+				dda_new_startpoint();
 				break;
 
 			case 161:
@@ -575,7 +578,7 @@ void process_gcode_command() {
 					queue_wait();
 				#endif
 				update_current_position();
-				sersendf_P(PSTR("X:%lq,Y:%lq,Z:%lq,E:%lq,F:%ld"), current_position.X * ((int32_t) UM_PER_STEP_X), current_position.Y * ((int32_t) UM_PER_STEP_Y), current_position.Z * ((int32_t) UM_PER_STEP_Z), current_position.E * ((int32_t) UM_PER_STEP_E), current_position.F);
+				sersendf_P(PSTR("X:%lq,Y:%lq,Z:%lq,E:%lq,F:%ld"), current_position.X, current_position.Y * ((int32_t) UM_PER_STEP_Y), current_position.Z * ((int32_t) UM_PER_STEP_Z), current_position.E * ((int32_t) UM_PER_STEP_E), current_position.F);
 				// newline is sent from gcode_parse after we return
 				break;
 

home.c

@@ -36,7 +36,7 @@ void home_x_negative() {
 	#if defined X_MIN_PIN
 		TARGET t = startpoint;
 
-		t.X = -1000*STEPS_PER_MM_X;
+		t.X = -1000000;
 		#ifdef SLOW_HOMING
 			// hit home soft
 			t.F = SEARCH_FEEDRATE_X;
@@ -48,7 +48,7 @@ void home_x_negative() {
 
 		#ifndef SLOW_HOMING
 			// back off slowly
-			t.X = +1000*STEPS_PER_MM_X;
+			t.X = +1000000;
 			t.F = SEARCH_FEEDRATE_X;
 			enqueue_home(&t, 0x1, 0);
 		#endif
@@ -56,10 +56,11 @@ void home_x_negative() {
 		// set X home
 		queue_wait(); // we have to wait here, see G92
 		#ifdef X_MIN
-			startpoint.X = next_target.target.X = (int32_t)(X_MIN * STEPS_PER_MM_X);
+			startpoint.X = next_target.target.X = (int32_t)(X_MIN * 1000.0);
 		#else
 			startpoint.X = next_target.target.X = 0;
 		#endif
+		dda_new_startpoint();
 	#endif
 }
 
@@ -71,7 +72,7 @@ void home_x_positive() {
 	#if defined X_MAX_PIN && defined X_MAX
 		TARGET t = startpoint;
 
-		t.X = +1000*STEPS_PER_MM_X;
+		t.X = +1000000;
 		#ifdef SLOW_HOMING
 			// hit home soft
 			t.F = SEARCH_FEEDRATE_X;
@@ -83,7 +84,7 @@ void home_x_positive() {
 
 		#ifndef SLOW_HOMING
 			// back off slowly
-			t.X = -1000*STEPS_PER_MM_X;
+			t.X = -1000000;
 			t.F = SEARCH_FEEDRATE_X;
 			enqueue_home(&t, 0x1, 0);
 		#endif
@@ -91,7 +92,8 @@ void home_x_positive() {
 		// set X home
 		queue_wait();
 		// set position to MAX
-		startpoint.X = next_target.target.X = (int32_t)(X_MAX * STEPS_PER_MM_X);
+		startpoint.X = next_target.target.X = (int32_t)(X_MAX * 1000.0);
+		dda_new_startpoint();
 		// go to zero
 		t.X = 0;
 		t.F = MAXIMUM_FEEDRATE_X;
@@ -128,6 +130,7 @@ void home_y_negative() {
 		#else
 			startpoint.Y = next_target.target.Y = 0;
 		#endif
+		dda_new_startpoint();
 	#endif
 }
 
@@ -160,6 +163,7 @@ void home_y_positive() {
 		queue_wait();
 		// set position to MAX
 		startpoint.Y = next_target.target.Y = (int32_t)(Y_MAX * STEPS_PER_MM_Y);
+		new_startpoint();
 		// go to zero
 		t.Y = 0;
 		t.F = MAXIMUM_FEEDRATE_Y;
@@ -196,6 +200,7 @@ void home_z_negative() {
 		#else
 			startpoint.Z = next_target.target.Z = 0;
 		#endif
+		dda_new_startpoint();
 		z_disable();
 	#endif
 }
@@ -229,6 +234,7 @@ void home_z_positive() {
 		queue_wait();
 		// set position to MAX
 		startpoint.Z = next_target.target.Z = (int32_t)(Z_MAX * STEPS_PER_MM_Z);
+		dda_new_startpoint();
 		// go to zero
 		t.Z = 0;
 		t.F = MAXIMUM_FEEDRATE_Z;