dda.c: move dda->*_steps and dda->*_counter into move_state as well.
Now we're easily back into business with an 8-line buffer queue on an '168.
This commit is contained in:
Markus Hitter
parent
ed77abba31
commit
47d8dedf24
74
dda.c
74
dda.c
|
|
@ -201,10 +201,10 @@ void dda_create(DDA *dda, TARGET *target) {
|
|||
// we end at the passed target
|
||||
memcpy(&(dda->endpoint), target, sizeof(TARGET));
|
||||
|
||||
dda->x_steps = dda->x_delta = labs(target->X - startpoint.X);
|
||||
dda->y_steps = dda->y_delta = labs(target->Y - startpoint.Y);
|
||||
dda->z_steps = dda->z_delta = labs(target->Z - startpoint.Z);
|
||||
dda->e_steps = dda->e_delta = labs(target->E - startpoint.E);
|
||||
dda->x_delta = labs(target->X - startpoint.X);
|
||||
dda->y_delta = labs(target->Y - startpoint.Y);
|
||||
dda->z_delta = labs(target->Z - startpoint.Z);
|
||||
dda->e_delta = labs(target->E - startpoint.E);
|
||||
|
||||
dda->x_direction = (target->X >= startpoint.X)?1:0;
|
||||
dda->y_direction = (target->Y >= startpoint.Y)?1:0;
|
||||
|
|
@ -255,9 +255,6 @@ void dda_create(DDA *dda, TARGET *target) {
|
|||
// bracket part of this equation in an attempt to avoid overflow: 60 * 16MHz * 5mm is >32 bits
|
||||
uint32_t move_duration = distance * (60 * F_CPU / startpoint.F);
|
||||
#else
|
||||
dda->x_counter = dda->y_counter = dda->z_counter = dda->e_counter =
|
||||
-(dda->total_steps >> 1);
|
||||
|
||||
// pre-calculate move speed in millimeter microseconds per step minute for less math in interrupt context
|
||||
// mm (distance) * 60000000 us/min / step (total_steps) = mm.us per step.min
|
||||
// note: um (distance) * 60000 == mm * 60000000
|
||||
|
|
@ -417,6 +414,9 @@ void dda_start(DDA *dda) {
|
|||
#endif
|
||||
|
||||
// initialise state variable
|
||||
move_state.x_counter = move_state.y_counter = move_state.z_counter = \
|
||||
move_state.e_counter = -(dda->total_steps >> 1);
|
||||
memcpy(&move_state.x_steps, &dda->x_delta, sizeof(uint32_t) * 4);
|
||||
#ifdef ACCELERATION_RAMPING
|
||||
move_state.step_no = 0;
|
||||
#endif
|
||||
|
|
@ -451,46 +451,46 @@ void dda_start(DDA *dda) {
|
|||
void dda_step(DDA *dda) {
|
||||
uint8_t did_step = 0;
|
||||
|
||||
if ((dda->x_steps) /* &&
|
||||
if ((move_state.x_steps) /* &&
|
||||
(x_max() != dda->x_direction) && (x_min() == dda->x_direction) */) {
|
||||
dda->x_counter -= dda->x_delta;
|
||||
if (dda->x_counter < 0) {
|
||||
move_state.x_counter -= dda->x_delta;
|
||||
if (move_state.x_counter < 0) {
|
||||
x_step();
|
||||
did_step = 1;
|
||||
dda->x_steps--;
|
||||
dda->x_counter += dda->total_steps;
|
||||
move_state.x_steps--;
|
||||
move_state.x_counter += dda->total_steps;
|
||||
}
|
||||
}
|
||||
|
||||
if ((dda->y_steps) /* &&
|
||||
if ((move_state.y_steps) /* &&
|
||||
(y_max() != dda->y_direction) && (y_min() == dda->y_direction) */) {
|
||||
dda->y_counter -= dda->y_delta;
|
||||
if (dda->y_counter < 0) {
|
||||
move_state.y_counter -= dda->y_delta;
|
||||
if (move_state.y_counter < 0) {
|
||||
y_step();
|
||||
did_step = 1;
|
||||
dda->y_steps--;
|
||||
dda->y_counter += dda->total_steps;
|
||||
move_state.y_steps--;
|
||||
move_state.y_counter += dda->total_steps;
|
||||
}
|
||||
}
|
||||
|
||||
if ((dda->z_steps) /* &&
|
||||
if ((move_state.z_steps) /* &&
|
||||
(z_max() != dda->z_direction) && (z_min() == dda->z_direction) */) {
|
||||
dda->z_counter -= dda->z_delta;
|
||||
if (dda->z_counter < 0) {
|
||||
move_state.z_counter -= dda->z_delta;
|
||||
if (move_state.z_counter < 0) {
|
||||
z_step();
|
||||
did_step = 1;
|
||||
dda->z_steps--;
|
||||
dda->z_counter += dda->total_steps;
|
||||
move_state.z_steps--;
|
||||
move_state.z_counter += dda->total_steps;
|
||||
}
|
||||
}
|
||||
|
||||
if (dda->e_steps) {
|
||||
dda->e_counter -= dda->e_delta;
|
||||
if (dda->e_counter < 0) {
|
||||
if (move_state.e_steps) {
|
||||
move_state.e_counter -= dda->e_delta;
|
||||
if (move_state.e_counter < 0) {
|
||||
e_step();
|
||||
did_step = 1;
|
||||
dda->e_steps--;
|
||||
dda->e_counter += dda->total_steps;
|
||||
move_state.e_steps--;
|
||||
move_state.e_counter += dda->total_steps;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -571,7 +571,7 @@ void dda_step(DDA *dda) {
|
|||
// if we could do anything at all, we're still running
|
||||
// otherwise, must have finished
|
||||
}
|
||||
else if (dda->x_steps == 0 && dda->y_steps == 0 && dda->z_steps == 0 && dda->e_steps == 0) {
|
||||
else if (move_state.x_steps == 0 && move_state.y_steps == 0 && move_state.z_steps == 0 && move_state.e_steps == 0) {
|
||||
dda->live = 0;
|
||||
// if E is relative reset it
|
||||
#ifndef E_ABSOLUTE
|
||||
|
|
@ -615,26 +615,26 @@ void update_position() {
|
|||
return;
|
||||
|
||||
if (dda->x_direction)
|
||||
current_position.X = dda->endpoint.X - dda->x_steps;
|
||||
current_position.X = dda->endpoint.X - move_state.x_steps;
|
||||
else
|
||||
current_position.X = dda->endpoint.X + dda->x_steps;
|
||||
current_position.X = dda->endpoint.X + move_state.x_steps;
|
||||
|
||||
if (dda->y_direction)
|
||||
current_position.Y = dda->endpoint.Y - dda->y_steps;
|
||||
current_position.Y = dda->endpoint.Y - move_state.y_steps;
|
||||
else
|
||||
current_position.Y = dda->endpoint.Y + dda->y_steps;
|
||||
current_position.Y = dda->endpoint.Y + move_state.y_steps;
|
||||
|
||||
if (dda->z_direction)
|
||||
current_position.Z = dda->endpoint.Z - dda->z_steps;
|
||||
current_position.Z = dda->endpoint.Z - move_state.z_steps;
|
||||
else
|
||||
current_position.Z = dda->endpoint.Z + dda->z_steps;
|
||||
current_position.Z = dda->endpoint.Z + move_state.z_steps;
|
||||
|
||||
#ifndef E_ABSOLUTE
|
||||
current_position.E = dda->e_steps;
|
||||
current_position.E = move_state.e_steps;
|
||||
#else
|
||||
if (dda->e_direction)
|
||||
current_position.E = dda->endpoint.E - dda->e_steps;
|
||||
current_position.E = dda->endpoint.E - move_state.e_steps;
|
||||
else
|
||||
current_position.E = dda->endpoint.E + dda->e_steps;
|
||||
current_position.E = dda->endpoint.E + move_state.e_steps;
|
||||
#endif
|
||||
}
|
||||
|
|
|
|||
32
dda.h
32
dda.h
|
|
@ -41,17 +41,17 @@ typedef struct {
|
|||
Parts of this struct are initialised only once per reboot, so make sure dda_step() leaves them with a value compatible to begin a new movement at the end of the movement. Other parts are filled in by dda_start().
|
||||
*/
|
||||
typedef struct {
|
||||
// // bresenham counters
|
||||
// int32_t x_counter; ///< counter for total_steps vs this axis
|
||||
// int32_t y_counter; ///< counter for total_steps vs this axis
|
||||
// int32_t z_counter; ///< counter for total_steps vs this axis
|
||||
// int32_t e_counter; ///< counter for total_steps vs this axis
|
||||
// bresenham counters
|
||||
int32_t x_counter; ///< counter for total_steps vs this axis
|
||||
int32_t y_counter; ///< counter for total_steps vs this axis
|
||||
int32_t z_counter; ///< counter for total_steps vs this axis
|
||||
int32_t e_counter; ///< counter for total_steps vs this axis
|
||||
|
||||
// // 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
|
||||
// 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
|
||||
|
||||
#ifdef ACCELERATION_RAMPING
|
||||
/// counts actual steps done
|
||||
|
|
@ -101,18 +101,6 @@ typedef struct {
|
|||
uint32_t z_delta; ///< number of steps on Z axis
|
||||
uint32_t e_delta; ///< number of steps on E axis
|
||||
|
||||
// bresenham counters
|
||||
int32_t x_counter; ///< counter for total_steps vs this axis, used for bresenham calculations.
|
||||
int32_t y_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.
|
||||
|
||||
// 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$
|
||||
uint32_t total_steps;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue