dda.c/.h: move n and c back into the dda structure.

This is a preparation for starting a move from non-zero speeds,
which is needed for look-ahead. Keeping both variables in
move_state and doing the calculations in dda_start() is possible
in principle, but might not fit the tight time budget we have when
going from one movement to the next at high step rates.

To deal with this, we have to pre-calculate n and c, so we have
to move it back into the DDA structure. It was there a year ago
already, but moved into move_state to save RAM (move_state exists
only once, dda as often as there are movement queue entries).

dda.c

@@ -318,7 +318,9 @@ void dda_create(DDA *dda, TARGET *target, DDA *prev_dda) {
                  calculation. Make sure this does not happen.
          Note 4: Anyone trying to run their machine at 65535 mm/min > 1m/s is nuts
        */
-      if (target->F > 65534) target->F = 65534;
+      if (target->F > 65534)
+        target->F = 65534;
+
       // Note: this is inaccurate for several reasons:
       // - target->F isn't reverse-calculated from c_limit, so speed
       //   reductions due to slow axes are ignored.
@@ -328,6 +330,7 @@ void dda_create(DDA *dda, TARGET *target, DDA *prev_dda) {
       // equal or larger than the number of steps required for acceleration,
       // so we can use it when also limiting max speed according to c_limit.
       dda->rampup_steps = ACCELERATE_RAMP_LEN(target->F);
+
       // Quick hack: we do not do Z move joins as jerk on the Z axis is undesirable;
       // as the ramp length is calculated for XY, its incorrect for Z: apply the original
       // 'fix' to simply specify a large enough ramp for any speed.
@@ -342,6 +345,10 @@ void dda_create(DDA *dda, TARGET *target, DDA *prev_dda) {
       #ifdef LOOKAHEAD
         dda_join_moves(prev_dda, dda);
       #endif
+
+      dda->n = 0;
+      dda->c = C0;
+
 		#elif defined ACCELERATION_TEMPORAL
 			// TODO: limit speed of individual axes to MAXIMUM_FEEDRATE
 			// TODO: calculate acceleration/deceleration for each axis
@@ -425,8 +432,6 @@ void dda_start(DDA *dda) {
     move_state.endstop_stop = 0;
 		#ifdef ACCELERATION_RAMPING
 			move_state.step_no = 0;
-      move_state.n = 0;
-      move_state.c = C0;
 		#endif
 		#ifdef ACCELERATION_TEMPORAL
 		move_state.x_time = move_state.y_time = \
@@ -437,11 +442,7 @@ void dda_start(DDA *dda) {
 		dda->live = 1;
 
 		// set timeout for first step
-		#ifdef ACCELERATION_RAMPING
+    setTimer(dda->c >> 8);
-			setTimer(move_state.c >> 8);
-		#else
-      setTimer(dda->c >> 8);
-		#endif
 	}
 	// else just a speed change, keep dda->live = 0
 
@@ -618,7 +619,7 @@ void dda_step(DDA *dda) {
   if ((move_state.x_steps == 0 && move_state.y_steps == 0 &&
        move_state.z_steps == 0 && move_state.e_steps == 0)
     #ifdef ACCELERATION_RAMPING
-      || (move_state.endstop_stop && move_state.n == 0)
+      || (move_state.endstop_stop && dda->n == 0)
     #endif
       ) {
 		dda->live = 0;
@@ -636,11 +637,7 @@ void dda_step(DDA *dda) {
 	else
 		psu_timeout = 0;
 
-	#ifdef ACCELERATION_RAMPING
+  setTimer(dda->c >> 8);
-    setTimer(move_state.c >> 8);
-	#else
-		setTimer(dda->c >> 8);
-	#endif
 
 	// turn off step outputs, hopefully they've been on long enough by now to register with the drivers
 	// if not, too bad. or insert a (very!) small delay here, or fire up a spare timer or something.
@@ -786,20 +783,20 @@ void dda_clock() {
 
     recalc_speed = 0;
     if (move_step_no < dda->rampup_steps) {
-      move_state.n = move_step_no;
+      dda->n = move_step_no;
       recalc_speed = 1;
     }
     else if (move_step_no >= dda->rampdown_steps) {
-      move_state.n = dda->total_steps - move_step_no;
+      dda->n = dda->total_steps - move_step_no;
       recalc_speed = 1;
     }
     if (recalc_speed) {
-      if (move_state.n == 0)
+      if (dda->n == 0)
         move_c = C0;
       else
         // Explicit formula: sqrt(n + 1) - sqrt(n),
         // approximation here: 1 / (2 * sqrt(n)).
-        move_c = ((C0 >> 8) * int_inv_sqrt(move_state.n)) >> 5;
+        move_c = ((C0 >> 8) * int_inv_sqrt(dda->n)) >> 5;
 
       if (move_c < dda->c_min) {
         // We hit max speed not always exactly.
@@ -816,7 +813,7 @@ void dda_clock() {
 
       // Write results.
       ATOMIC_START
-        move_state.c = move_c;
+        dda->c = move_c;
       ATOMIC_END
     }
   #endif

dda.h

@@ -72,10 +72,6 @@ typedef struct {
 	#ifdef ACCELERATION_RAMPING
 	/// counts actual steps done
 	uint32_t					step_no;
-	/// time until next step
-	uint32_t					c;
-	/// tracking variable
-	int32_t						n;
 	#endif
 	#ifdef ACCELERATION_TEMPORAL
 	uint32_t					x_time; ///< time of the last x step
@@ -136,9 +132,10 @@ typedef struct {
 
 	#ifdef ACCELERATION_REPRAP
 	uint32_t					end_c; ///< time between 2nd last step and last step
-	int32_t						n; ///< precalculated step time offset variable. At every step we calculate \f$c = c - (2 c / n)\f$; \f$n+=4\f$. See http://www.embedded.com/columns/technicalinsights/56800129?printable=true for full description
 	#endif
 	#ifdef ACCELERATION_RAMPING
+  /// precalculated step time offset variable
+  int32_t           n;
 	/// number of steps accelerating
 	uint32_t					rampup_steps;
 	/// number of last step before decelerating