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

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 2011-05-15 21:32:37 +02:00
parent ed77abba31
commit 47d8dedf24
2 changed files with 47 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
dda.c
View File

@ -201,10 +201,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_steps = dda->x_delta = labs(target->X - startpoint.X); dda->x_delta = labs(target->X - startpoint.X);
dda->y_steps = dda->y_delta = labs(target->Y - startpoint.Y); dda->y_delta = labs(target->Y - startpoint.Y);
dda->z_steps = dda->z_delta = labs(target->Z - startpoint.Z); dda->z_delta = labs(target->Z - startpoint.Z);
dda->e_steps = dda->e_delta = labs(target->E - startpoint.E); 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;
@ -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 // 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); uint32_t move_duration = distance * (60 * F_CPU / startpoint.F);
#else #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 // 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 // mm (distance) * 60000000 us/min / step (total_steps) = mm.us per step.min
// note: um (distance) * 60000 == mm * 60000000 // note: um (distance) * 60000 == mm * 60000000
@ -417,6 +414,9 @@ void dda_start(DDA *dda) {
#endif #endif
// initialise state variable // 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 #ifdef ACCELERATION_RAMPING
move_state.step_no = 0; move_state.step_no = 0;
#endif #endif
@ -451,46 +451,46 @@ void dda_start(DDA *dda) {
void dda_step(DDA *dda) { void dda_step(DDA *dda) {
uint8_t did_step = 0; uint8_t did_step = 0;
if ((dda->x_steps) /* && if ((move_state.x_steps) /* &&
(x_max() != dda->x_direction) && (x_min() == dda->x_direction) */) { (x_max() != dda->x_direction) && (x_min() == dda->x_direction) */) {
dda->x_counter -= dda->x_delta; move_state.x_counter -= dda->x_delta;
if (dda->x_counter < 0) { if (move_state.x_counter < 0) {
x_step(); x_step();
did_step = 1; did_step = 1;
dda->x_steps--; move_state.x_steps--;
dda->x_counter += dda->total_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) */) { (y_max() != dda->y_direction) && (y_min() == dda->y_direction) */) {
dda->y_counter -= dda->y_delta; move_state.y_counter -= dda->y_delta;
if (dda->y_counter < 0) { if (move_state.y_counter < 0) {
y_step(); y_step();
did_step = 1; did_step = 1;
dda->y_steps--; move_state.y_steps--;
dda->y_counter += dda->total_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) */) { (z_max() != dda->z_direction) && (z_min() == dda->z_direction) */) {
dda->z_counter -= dda->z_delta; move_state.z_counter -= dda->z_delta;
if (dda->z_counter < 0) { if (move_state.z_counter < 0) {
z_step(); z_step();
did_step = 1; did_step = 1;
dda->z_steps--; move_state.z_steps--;
dda->z_counter += dda->total_steps; move_state.z_counter += dda->total_steps;
} }
} }
if (dda->e_steps) { if (move_state.e_steps) {
dda->e_counter -= dda->e_delta; move_state.e_counter -= dda->e_delta;
if (dda->e_counter < 0) { if (move_state.e_counter < 0) {
e_step(); e_step();
did_step = 1; did_step = 1;
dda->e_steps--; move_state.e_steps--;
dda->e_counter += dda->total_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 // if we could do anything at all, we're still running
// otherwise, must have finished // 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; dda->live = 0;
// if E is relative reset it // if E is relative reset it
#ifndef E_ABSOLUTE #ifndef E_ABSOLUTE
@ -615,26 +615,26 @@ void update_position() {
return; return;
if (dda->x_direction) if (dda->x_direction)
current_position.X = dda->endpoint.X - dda->x_steps; current_position.X = dda->endpoint.X - move_state.x_steps;
else else
current_position.X = dda->endpoint.X + dda->x_steps; current_position.X = dda->endpoint.X + move_state.x_steps;
if (dda->y_direction) if (dda->y_direction)
current_position.Y = dda->endpoint.Y - dda->y_steps; current_position.Y = dda->endpoint.Y - move_state.y_steps;
else else
current_position.Y = dda->endpoint.Y + dda->y_steps; current_position.Y = dda->endpoint.Y + move_state.y_steps;
if (dda->z_direction) if (dda->z_direction)
current_position.Z = dda->endpoint.Z - dda->z_steps; current_position.Z = dda->endpoint.Z - move_state.z_steps;
else else
current_position.Z = dda->endpoint.Z + dda->z_steps; current_position.Z = dda->endpoint.Z + move_state.z_steps;
#ifndef E_ABSOLUTE #ifndef E_ABSOLUTE
current_position.E = dda->e_steps; current_position.E = move_state.e_steps;
#else #else
if (dda->e_direction) if (dda->e_direction)
current_position.E = dda->endpoint.E - dda->e_steps; current_position.E = dda->endpoint.E - move_state.e_steps;
else else
current_position.E = dda->endpoint.E + dda->e_steps; current_position.E = dda->endpoint.E + move_state.e_steps;
#endif #endif
} }

32
dda.h
View File

@ -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(). 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 { typedef struct {
// // bresenham counters // bresenham counters
// int32_t x_counter; ///< counter for total_steps vs this axis int32_t x_counter; ///< counter for total_steps vs this axis
// int32_t y_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 z_counter; ///< counter for total_steps vs this axis
// int32_t e_counter; ///< counter for total_steps vs this axis int32_t e_counter; ///< counter for total_steps vs this axis
// // step counters // step counters
// uint32_t x_steps; ///< number of steps on X axis uint32_t x_steps; ///< number of steps on X axis
// uint32_t y_steps; ///< number of steps on Y axis uint32_t y_steps; ///< number of steps on Y axis
// uint32_t z_steps; ///< number of steps on Z axis uint32_t z_steps; ///< number of steps on Z axis
// uint32_t e_steps; ///< number of steps on E axis uint32_t e_steps; ///< number of steps on E axis
#ifdef ACCELERATION_RAMPING #ifdef ACCELERATION_RAMPING
/// counts actual steps done /// counts actual steps done
@ -101,18 +101,6 @@ typedef struct {
uint32_t z_delta; ///< number of steps on Z axis uint32_t z_delta; ///< number of steps on Z axis
uint32_t e_delta; ///< number of steps on E 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$ /// 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;