josh
/
Teacup_Firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

remove ACCELERATION_TEMPORAL, update current_position from main loop instead of step interrupt

This commit is contained in:
Michael Moon 2011-04-26 14:45:32 +10:00
parent e108ab2548
commit 03892894ed
3 changed files with 104 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
clock.c
View File

@ -64,5 +64,7 @@ void clock_10ms() {
ifclock(CLOCK_FLAG_250MS) { ifclock(CLOCK_FLAG_250MS) {
clock_250ms(); clock_250ms();
} }
update_position();
} }

255
dda.c
View File

@ -22,16 +22,6 @@
#include "heater.h" #include "heater.h"
#endif #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
#define UM_PER_STEP_Z 1000L / ((uint32_t) STEPS_PER_MM_Z)
/// micrometers per step E
#define UM_PER_STEP_E 1000L / ((uint32_t) STEPS_PER_MM_E)
/// step timeout /// step timeout
uint8_t steptimeout = 0; uint8_t steptimeout = 0;
@ -193,10 +183,10 @@ void dda_create(DDA *dda, TARGET *target) {
// we end at the passed target // we end at the passed target
memcpy(&(dda->endpoint), target, sizeof(TARGET)); memcpy(&(dda->endpoint), target, sizeof(TARGET));
dda->x_delta = labs(target->X - startpoint.X); dda->x_steps = dda->x_delta = labs(target->X - startpoint.X);
dda->y_delta = labs(target->Y - startpoint.Y); dda->y_steps = dda->y_delta = labs(target->Y - startpoint.Y);
dda->z_delta = labs(target->Z - startpoint.Z); dda->z_steps = dda->z_delta = labs(target->Z - startpoint.Z);
dda->e_delta = labs(target->E - startpoint.E); dda->e_steps = dda->e_delta = labs(target->E - startpoint.E);
dda->x_direction = (target->X >= startpoint.X)?1:0; dda->x_direction = (target->X >= startpoint.X)?1:0;
dda->y_direction = (target->Y >= startpoint.Y)?1:0; dda->y_direction = (target->Y >= startpoint.Y)?1:0;
@ -352,21 +342,6 @@ void dda_create(DDA *dda, TARGET *target) {
dda->c_min = c_limit; dda->c_min = c_limit;
dda->n = 1; dda->n = 1;
dda->ramp_state = RAMP_UP; dda->ramp_state = RAMP_UP;
#elif defined ACCELERATION_TEMPORAL
dda->x_counter = dda->x_step_interval = move_duration / dda->x_delta;
dda->y_counter = dda->y_step_interval = move_duration / dda->y_delta;
dda->z_counter = dda->z_step_interval = move_duration / dda->z_delta;
dda->e_counter = dda->e_step_interval = move_duration / dda->e_delta;
dda->c = dda->x_step_interval;
if (dda->y_step_interval < dda->c)
dda->c = dda->y_step_interval;
if (dda->z_step_interval < dda->c)
dda->c = dda->z_step_interval;
if (dda->e_step_interval < dda->c)
dda->c = dda->e_step_interval;
dda->c <<= 8;
#else #else
dda->c = (move_duration / target->F) << 8; dda->c = (move_duration / target->F) << 8;
if (dda->c < c_limit) if (dda->c < c_limit)
@ -379,10 +354,10 @@ void dda_create(DDA *dda, TARGET *target) {
// next dda starts where we finish // next dda starts where we finish
memcpy(&startpoint, target, sizeof(TARGET)); memcpy(&startpoint, target, sizeof(TARGET));
// if E is relative, reset it here // if E is relative, reset it here
#ifndef E_ABSOLUTE #ifndef E_ABSOLUTE
startpoint.E = 0; startpoint.E = 0;
#endif #endif
} }
/*! Start a prepared DDA /*! Start a prepared DDA
@ -450,115 +425,68 @@ void dda_step(DDA *dda) {
// called from interrupt context! keep it as simple as possible // called from interrupt context! keep it as simple as possible
uint8_t did_step = 0; uint8_t did_step = 0;
#ifdef ACCELERATION_TEMPORAL if ((dda->x_steps) /* &&
if (dda->x_counter <= 0) { (x_max() != dda->x_direction) && (x_min() == dda->x_direction) */) {
if ((current_position.X != dda->endpoint.X) /* && dda->x_counter -= dda->x_delta;
(x_max() != dda->x_direction) && (x_min() == dda->x_direction) */) { if (dda->x_counter < 0) {
x_step(); x_step();
if (dda->x_direction) did_step = 1;
current_position.X++; dda->x_steps--;
else // if (dda->x_direction)
current_position.X--; // current_position.X++;
} // else
dda->x_counter += dda->x_step_interval; // current_position.X--;
dda->x_delta--;
}
if (dda->y_counter <= 0) {
if ((current_position.Y != dda->endpoint.Y) /* &&
(y_max() != dda->y_direction) && (y_min() == dda->y_direction) */) {
y_step();
if (dda->y_direction)
current_position.Y++;
else
current_position.Y--;
}
dda->y_counter += dda->y_step_interval;
dda->y_delta--;
}
if (dda->z_counter <= 0) {
if ((current_position.Z != dda->endpoint.Z) /* &&
(z_max() != dda->z_direction) && (z_min() == dda->z_direction) */) {
z_step();
if (dda->z_direction)
current_position.Z++;
else
current_position.Z--;
}
dda->z_counter += dda->z_step_interval;
dda->z_delta--;
}
if (dda->e_counter <= 0) {
if ((current_position.E != dda->endpoint.E) /* &&
(e_max() != dda->e_direction) && (e_min() == dda->e_direction) */) {
e_step();
if (dda->e_direction)
current_position.E++;
else
current_position.E--;
}
dda->e_counter += dda->e_step_interval;
dda->e_delta--;
}
#else
if ((current_position.X != dda->endpoint.X) /* &&
(x_max() != dda->x_direction) && (x_min() == dda->x_direction) */) {
dda->x_counter -= dda->x_delta;
if (dda->x_counter < 0) {
x_step();
did_step = 1;
if (dda->x_direction)
current_position.X++;
else
current_position.X--;
dda->x_counter += dda->total_steps; dda->x_counter += dda->total_steps;
}
} }
}
if ((current_position.Y != dda->endpoint.Y) /* && if ((dda->y_steps) /* &&
(y_max() != dda->y_direction) && (y_min() == dda->y_direction) */) { (y_max() != dda->y_direction) && (y_min() == dda->y_direction) */) {
dda->y_counter -= dda->y_delta; dda->y_counter -= dda->y_delta;
if (dda->y_counter < 0) { if (dda->y_counter < 0) {
y_step(); y_step();
did_step = 1; did_step = 1;
if (dda->y_direction) dda->y_steps--;
current_position.Y++; // if (dda->y_direction)
else // current_position.Y++;
current_position.Y--; // else
// current_position.Y--;
dda->y_counter += dda->total_steps; dda->y_counter += dda->total_steps;
}
} }
}
if ((current_position.Z != dda->endpoint.Z) /* && if ((dda->z_steps) /* &&
(z_max() != dda->z_direction) && (z_min() == dda->z_direction) */) { (z_max() != dda->z_direction) && (z_min() == dda->z_direction) */) {
dda->z_counter -= dda->z_delta; dda->z_counter -= dda->z_delta;
if (dda->z_counter < 0) { if (dda->z_counter < 0) {
z_step(); z_step();
did_step = 1; did_step = 1;
if (dda->z_direction) dda->z_steps--;
current_position.Z++; // if (dda->z_direction)
else // current_position.Z++;
current_position.Z--; // else
// current_position.Z--;
dda->z_counter += dda->total_steps; dda->z_counter += dda->total_steps;
}
} }
}
if (current_position.E != dda->endpoint.E) { if (dda->e_steps) {
dda->e_counter -= dda->e_delta; dda->e_counter -= dda->e_delta;
if (dda->e_counter < 0) { if (dda->e_counter < 0) {
e_step(); e_step();
did_step = 1; did_step = 1;
if (dda->e_direction) dda->e_steps--;
current_position.E++; // if (dda->e_direction)
else // current_position.E++;
current_position.E--; // else
// current_position.E--;
dda->e_counter += dda->total_steps; dda->e_counter += dda->total_steps;
}
} }
#endif }
#if STEP_INTERRUPT_INTERRUPTIBLE #if STEP_INTERRUPT_INTERRUPTIBLE
// since we have sent steps to all the motors that will be stepping and the rest of this function isn't so time critical, // since we have sent steps to all the motors that will be stepping and the rest of this function isn't so time critical,
@ -613,32 +541,6 @@ void dda_step(DDA *dda) {
} }
dda->step_no++; dda->step_no++;
#endif #endif
#ifdef ACCELERATION_TEMPORAL
dda->c = dda->x_counter;
if (dda->y_counter < dda->c)
dda->c = dda->y_counter;
if (dda->z_counter < dda->c)
dda->c = dda->z_counter;
if (dda->e_counter < dda->c)
dda->c = dda->e_counter;
if (dda->x_delta)
dda->x_counter -= dda->c;
if (dda->y_delta)
dda->y_counter -= dda->c;
if (dda->z_delta)
dda->z_counter -= dda->c;
if (dda->e_delta)
dda->e_counter -= dda->c;
if (
(dda->x_delta > 0) ||
(dda->y_delta > 0) ||
(dda->z_delta > 0) ||
(dda->e_delta > 0))
did_step = 1;
dda->c <<= 8;
#endif
if (did_step) { if (did_step) {
// we stepped, reset timeout // we stepped, reset timeout
@ -647,12 +549,12 @@ void dda_step(DDA *dda) {
// if we could do anything at all, we're still running // if we could do anything at all, we're still running
// otherwise, must have finished // otherwise, must have finished
} }
else { else if (dda->x_steps == 0 && dda->y_steps == 0 && dda->z_steps == 0 && dda->e_steps == 0) {
dda->live = 0; dda->live = 0;
// if E is relative reset it // if E is relative reset it
#ifndef E_ABSOLUTE #ifndef E_ABSOLUTE
current_position.E = 0; current_position.E = 0;
#endif #endif
// linear acceleration code doesn't alter F during a move, so we must update it here // linear acceleration code doesn't alter F during a move, so we must update it here
// in theory, we *could* update F every step, but that would require a divide in interrupt context which should be avoided if at all possible // in theory, we *could* update F every step, but that would require a divide in interrupt context which should be avoided if at all possible
current_position.F = dda->endpoint.F; current_position.F = dda->endpoint.F;
@ -670,3 +572,32 @@ void dda_step(DDA *dda) {
// we also hope that we don't step before the drivers register the low- limit maximum speed if you think this is a problem. // we also hope that we don't step before the drivers register the low- limit maximum speed if you think this is a problem.
unstep(); unstep();
} }
/// update global current_position struct
void update_position() {
DDA *dda = &movebuffer[mb_tail];
if (dda->x_direction)
current_position.X = dda->endpoint.X - dda->x_steps;
else
current_position.X = dda->endpoint.X + dda->x_steps;
if (dda->y_direction)
current_position.Y = dda->endpoint.Y - dda->y_steps;
else
current_position.Y = dda->endpoint.Y + dda->y_steps;
if (dda->z_direction)
current_position.Z = dda->endpoint.Z - dda->z_steps;
else
current_position.Z = dda->endpoint.Z + dda->z_steps;
#ifndef E_ABSOLUTE
current_position.E = dda->e_steps;
#else
if (dda->e_direction)
current_position.E = dda->endpoint.E - dda->e_steps;
else
current_position.E = dda->endpoint.E + dda->e_steps;
#endif
}

19
dda.h
View File

@ -88,6 +88,12 @@ typedef struct {
int32_t z_counter; ///< counter for total_steps vs this axis, used for bresenham calculations. int32_t z_counter; ///< counter for total_steps vs this axis, used for bresenham calculations.
int32_t e_counter; ///< counter for total_steps vs this axis, used for bresenham calculations. int32_t e_counter; ///< counter for total_steps vs this axis, used for bresenham calculations.
// step counters
uint32_t x_steps; ///< number of steps on X axis
uint32_t y_steps; ///< number of steps on Y axis
uint32_t z_steps; ///< number of steps on Z axis
uint32_t e_steps; ///< number of steps on E axis
/// total number of steps: set to \f$\max(\Delta x, \Delta y, \Delta z, \Delta e)\f$ /// total number of steps: set to \f$\max(\Delta x, \Delta y, \Delta z, \Delta e)\f$
uint32_t total_steps; uint32_t total_steps;
@ -109,16 +115,6 @@ typedef struct {
/// keep track of whether we're ramping up, down, or plateauing /// keep track of whether we're ramping up, down, or plateauing
ramp_state_t ramp_state; ramp_state_t ramp_state;
#endif #endif
#ifdef ACCELERATION_TEMPORAL
/// time between steps on X axis
uint32_t x_step_interval;
/// time between steps on Y axis
uint32_t y_step_interval;
/// time between steps on Z axis
uint32_t z_step_interval;
/// time between steps on E axis
uint32_t e_step_interval;
#endif
} DDA; } DDA;
/* /*
@ -153,4 +149,7 @@ void dda_start(DDA *dda) __attribute__ ((hot));
// DDA takes one step (called from timer interrupt) // DDA takes one step (called from timer interrupt)
void dda_step(DDA *dda) __attribute__ ((hot)); void dda_step(DDA *dda) __attribute__ ((hot));
// update current_position
void update_position(void);
#endif /* _DDA_H */ #endif /* _DDA_H */