From c96ea0c7735c8b7a10ffde39fe240a195df8e0ca Mon Sep 17 00:00:00 2001 From: Markus Hitter Date: Tue, 17 May 2011 16:42:47 +0200 Subject: [PATCH] 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 | 22 ++++++++++---- config.gen3.h | 18 +++++++---- config.gen6.h | 21 ++++++++++--- config.gen7.h | 22 ++++++++++---- config.ramps-v1.2.h | 21 ++++++++++--- config.ramps-v1.3.h | 21 ++++++++++--- config.sanguinololu-v1.1.h | 20 +++++++++--- config.sanguinololu-v1.2.h | 20 +++++++++--- dda.c | 62 +++++++++++++++++++++++++++++++------- dda.h | 40 +++++++++++++++++++++--- dda_queue.c | 2 +- gcode_parse.c | 8 ++--- gcode_process.c | 13 +++++--- home.c | 18 +++++++---- 14 files changed, 236 insertions(+), 72 deletions(-) diff --git a/config.default.h b/config.default.h index 427f1f8..9628e1c 100644 --- a/config.default.h +++ b/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 -/// 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) -/// half-stepping doubles the number, quarter stepping requires * 4, etc. -/// valid range = 0.020 to 4194.303 -#define STEPS_PER_MM_X 320.000 +/** \def STEPS_PER_M + steps per meter ( = steps per mm * 1000 ) + + 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 STEPS_PER_M_X 320000 #define STEPS_PER_MM_Y 320.000 #define STEPS_PER_MM_Z 320.000 diff --git a/config.gen3.h b/config.gen3.h index 81f6ec4..78b6e03 100644 --- a/config.gen3.h +++ b/config.gen3.h @@ -45,16 +45,22 @@ */ #define HOST -/* - Values reflecting the gearing of your machine. - All numbers are fixed point integers, so no more than 3 digits to the right of the decimal point, please :-) +/** \def STEPS_PER_M + steps per meter ( = steps per mm * 1000 ) 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 diff --git a/config.gen6.h b/config.gen6.h index 73b5bca..0f0f427 100644 --- a/config.gen6.h +++ b/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 -// 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) -// The GEN6 board uses 1/8 microstepping, so multiply your values by 8. -#define STEPS_PER_MM_X (320.000*8) +/** \def STEPS_PER_M + steps per meter ( = steps per mm * 1000 ) + + 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 STEPS_PER_M_X (5000*8) #define STEPS_PER_MM_Y (320.000*8) #define STEPS_PER_MM_Z (200.000*8) diff --git a/config.gen7.h b/config.gen7.h index b4a771c..0e71914 100644 --- a/config.gen7.h +++ b/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 -/// 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) -/// half-stepping doubles the number, quarter stepping requires * 4, etc. -/// valid range = 0.020 to 4194.303 -#define STEPS_PER_MM_X 40.000 +/** \def STEPS_PER_M + steps per meter ( = steps per mm * 1000 ) + + 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 STEPS_PER_M_X 40000 #define STEPS_PER_MM_Y 40.000 #define STEPS_PER_MM_Z 320.000 diff --git a/config.ramps-v1.2.h b/config.ramps-v1.2.h index de235ce..af3fc96 100644 --- a/config.ramps-v1.2.h +++ b/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 -// 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) -// half-stepping doubles the number, quarter stepping requires * 4, etc. +/** \def STEPS_PER_M + steps per meter ( = steps per mm * 1000 ) + + 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) diff --git a/config.ramps-v1.3.h b/config.ramps-v1.3.h index 5b13fa8..c0a9a96 100644 --- a/config.ramps-v1.3.h +++ b/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 -// 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) -// half-stepping doubles the number, quarter stepping requires * 4, etc. +/** \def STEPS_PER_M + steps per meter ( = steps per mm * 1000 ) + + 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) diff --git a/config.sanguinololu-v1.1.h b/config.sanguinololu-v1.1.h index 63417d9..6806c5b 100644 --- a/config.sanguinololu-v1.1.h +++ b/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 -/// 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) +/** \def STEPS_PER_M + steps per meter ( = steps per mm * 1000 ) + + 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) diff --git a/config.sanguinololu-v1.2.h b/config.sanguinololu-v1.2.h index e139219..86e17ae 100644 --- a/config.sanguinololu-v1.2.h +++ b/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 -/// 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) +/** \def STEPS_PER_M + steps per meter ( = steps per mm * 1000 ) + + 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) diff --git a/dda.c b/dda.c index 9e68159..9a70e89 100644 --- a/dda.c +++ b/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 - //if (move_state.step_no % 10 /* 10, 100, ...*/ == 0) - // sersendf_P(PSTR("\r\nc %lu c_min %lu n %d"), dda->c, dda->c_min, move_state.n); + // raise this 10 for higher speeds to avoid flooding the serial line + //if (move_state.step_no % 10 /* 10, 50, 100, ...*/ == 0) + // 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; diff --git a/dda.h b/dda.h index 0e8d056..7a5f206 100644 --- a/dda.h +++ b/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); diff --git a/dda_queue.c b/dda_queue.c index 4d78bca..0d0113f 100644 --- a/dda_queue.c +++ b/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. diff --git a/gcode_parse.c b/gcode_parse.c index 76dbac4..26d9ab1 100644 --- a/gcode_parse.c +++ b/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; diff --git a/gcode_process.c b/gcode_process.c index 550153f..546cf0c 100644 --- a/gcode_process.c +++ b/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)) - next_target.target.X = X_MIN * STEPS_PER_MM_X; + if (next_target.target.X < X_MIN * 1000.) + next_target.target.X = X_MIN * 1000.; #endif #ifdef X_MAX - if (next_target.target.X > (X_MAX * STEPS_PER_MM_X)) - next_target.target.X = X_MAX * STEPS_PER_MM_X; + if (next_target.target.X > X_MAX * 1000.)) + 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; diff --git a/home.c b/home.c index 2dda161..bb9d6f1 100644 --- a/home.c +++ b/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;