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

DDA: store distance of each movement. 

This is required to calculate speeds of individual axes. So far only
in dda_find_crossing_speed(), but soon also in dda_join_moves().
This commit is contained in:
Markus Hitter 2013-11-30 23:53:39 +01:00
parent 1b5682c01a
commit 42ad12fba3
4 changed files with 16 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
dda.c
View File

@ -381,7 +381,8 @@ void dda_create(DDA *dda, TARGET *target) {
dda->rampdown_steps = dda->total_steps - dda->rampup_steps; dda->rampdown_steps = dda->total_steps - dda->rampup_steps;
#ifdef LOOKAHEAD #ifdef LOOKAHEAD
dda_find_crossing_speed(prev_dda, dda, distance); dda->distance = distance;
dda_find_crossing_speed(prev_dda, dda);
// TODO: this should become a reverse-stepping through the existing // TODO: this should become a reverse-stepping through the existing
// movement queue to allow higher speeds for short moves. // movement queue to allow higher speeds for short moves.
// dda_find_crossing_speed() is required only once. // dda_find_crossing_speed() is required only once.

1
dda.h
View File

@ -147,6 +147,7 @@ typedef struct {
// With the look-ahead functionality, it is possible to retain physical // With the look-ahead functionality, it is possible to retain physical
// movement between G1 moves. These variables keep track of the entry and // movement between G1 moves. These variables keep track of the entry and
// exit speeds between moves. // exit speeds between moves.
uint32_t distance;
uint32_t crossF; uint32_t crossF;
uint32_t F_start; uint32_t F_start;
uint32_t start_steps; ///< steps to reach F_start uint32_t start_steps; ///< steps to reach F_start

27
dda_lookahead.c
View File

@ -163,17 +163,14 @@ void dda_emergency_shutdown(PGM_P msg) {
* *
* \return dda->crossF * \return dda->crossF
*/ */
void dda_find_crossing_speed(DDA *prev, DDA *current, uint32_t curr_distance) { void dda_find_crossing_speed(DDA *prev, DDA *current) {
static uint32_t prev_distance;
uint32_t F, dv, speed_factor, max_speed_factor; uint32_t F, dv, speed_factor, max_speed_factor;
int32_t prevFx, prevFy, prevFz, prevFe; int32_t prevFx, prevFy, prevFz, prevFe;
int32_t currFx, currFy, currFz, currFe; int32_t currFx, currFy, currFz, currFe;
// Bail out if there's nothing to join (e.g. G1 F1500). // Bail out if there's nothing to join (e.g. G1 F1500).
if ( ! prev || prev->nullmove) { if ( ! prev || prev->nullmove)
prev_distance = curr_distance;
return; return;
}
// We always look at the smaller of both combined speeds, // We always look at the smaller of both combined speeds,
// else we'd interpret intended speed changes as jerk. // else we'd interpret intended speed changes as jerk.
@ -182,19 +179,20 @@ void dda_find_crossing_speed(DDA *prev, DDA *current, uint32_t curr_distance) {
F = current->endpoint.F; F = current->endpoint.F;
if (DEBUG_DDA && (debug_flags & DEBUG_DDA)) if (DEBUG_DDA && (debug_flags & DEBUG_DDA))
sersendf_P(PSTR("Distance: %lu, then %lu\n"), prev_distance, curr_distance); sersendf_P(PSTR("Distance: %lu, then %lu\n"),
prev->distance, current->distance);
// Find individual axis speeds. // Find individual axis speeds.
// int32_t muldiv(int32_t multiplicand, uint32_t multiplier, uint32_t divisor) // int32_t muldiv(int32_t multiplicand, uint32_t multiplier, uint32_t divisor)
prevFx = muldiv(prev->delta_um.X, F, prev_distance); prevFx = muldiv(prev->delta_um.X, F, prev->distance);
prevFy = muldiv(prev->delta_um.Y, F, prev_distance); prevFy = muldiv(prev->delta_um.Y, F, prev->distance);
prevFz = muldiv(prev->delta_um.Z, F, prev_distance); prevFz = muldiv(prev->delta_um.Z, F, prev->distance);
prevFe = muldiv(prev->delta_um.E, F, prev_distance); prevFe = muldiv(prev->delta_um.E, F, prev->distance);
currFx = muldiv(current->delta_um.X, F, curr_distance); currFx = muldiv(current->delta_um.X, F, current->distance);
currFy = muldiv(current->delta_um.Y, F, curr_distance); currFy = muldiv(current->delta_um.Y, F, current->distance);
currFz = muldiv(current->delta_um.Z, F, curr_distance); currFz = muldiv(current->delta_um.Z, F, current->distance);
currFe = muldiv(current->delta_um.E, F, curr_distance); currFe = muldiv(current->delta_um.E, F, current->distance);
if (DEBUG_DDA && (debug_flags & DEBUG_DDA)) if (DEBUG_DDA && (debug_flags & DEBUG_DDA))
sersendf_P(PSTR("prevF: %ld %ld %ld %ld\ncurrF: %ld %ld %ld %ld\n"), sersendf_P(PSTR("prevF: %ld %ld %ld %ld\ncurrF: %ld %ld %ld %ld\n"),
@ -272,7 +270,6 @@ void dda_find_crossing_speed(DDA *prev, DDA *current, uint32_t curr_distance) {
sersendf_P(PSTR("Cross speed reduction from %lu to %lu\n"), sersendf_P(PSTR("Cross speed reduction from %lu to %lu\n"),
F, current->crossF); F, current->crossF);
prev_distance = curr_distance;
return; return;
} }

2
dda_lookahead.h
View File

@ -43,7 +43,7 @@
#define MAX(a,b) (((a)>(b))?(a):(b)) #define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b)) #define MIN(a,b) (((a)<(b))?(a):(b))
void dda_find_crossing_speed(DDA *prev, DDA *current, uint32_t curr_distance); void dda_find_crossing_speed(DDA *prev, DDA *current);
void dda_join_moves(DDA *prev, DDA *current); void dda_join_moves(DDA *prev, DDA *current);
// Debug counters // Debug counters