stepcompress: Do all step rounding in C code

Commits f0cefebf and 8f331f08 changed the way the code determined what
steps to take on fractional steps.  Unfortunately, it was possible in
some situations for the C code to round differently from the python
code which could result in warnings and lost steps.

Change the code so that all fractional step handling is done in the C
code.  Implementing the step rounding logic in one location avoids any
conflicts.

In order to efficiently handle the step rounding in the C code, the C
code has also been extended to directly send the "set_next_step_dir"
command.

Signed-off-by: Kevin O'Connor <kevin@koconnor.net>

klippy/extruder.py

@@ -88,69 +88,58 @@ class PrinterExtruder:
                         # There is still only a decel phase (no retraction)
                         decel_d -= extra_decel_d
 
-        # Determine regular steps
-        forward_d = accel_d + cruise_d + decel_d
-        end_pos = start_pos + forward_d
+        # Prepare for steps
+        stepper_pos = self.stepper_pos
         inv_step_dist = self.stepper.inv_step_dist
-        new_step_pos = int(end_pos*inv_step_dist + 0.5)
-        if new_step_pos != self.stepper_pos:
-            steps = forward_d * inv_step_dist
-            step_offset = self.stepper_pos - start_pos * inv_step_dist + 0.5
-            self.stepper_pos = new_step_pos
-            sdir = 1
-            if steps < 0:
-                sdir = 0
-                steps = -steps
-                step_offset = 1. - step_offset
-            mcu_time, so = self.stepper.prep_move(move_time, sdir)
+        step_dist = self.stepper.step_dist
+        mcu_time, so = self.stepper.prep_move(move_time)
+        step_offset = stepper_pos - start_pos * inv_step_dist
 
-            move_step_d = forward_d / steps
-            inv_move_step_d = 1. / move_step_d
-
-            # Acceleration steps
+        # Acceleration steps
+        accel_multiplier = 2.0 * step_dist * inv_accel
+        if accel_d:
             #t = sqrt(2*pos/accel + (start_v/accel)**2) - start_v/accel
             accel_time_offset = start_v * inv_accel
             accel_sqrt_offset = accel_time_offset**2
-            accel_multiplier = 2.0 * move_step_d * inv_accel
-            accel_steps = accel_d * inv_move_step_d
-            step_offset = so.step_sqrt(
+            accel_steps = accel_d * inv_step_dist
+            count = so.step_sqrt(
                 mcu_time - accel_time_offset, accel_steps, step_offset
                 , accel_sqrt_offset, accel_multiplier)
+            stepper_pos += count
+            step_offset += count - accel_steps
             mcu_time += accel_t
-            # Cruising steps
+        # Cruising steps
+        if cruise_d:
             #t = pos/cruise_v
-            cruise_multiplier = move_step_d / cruise_v
-            cruise_steps = cruise_d * inv_move_step_d
-            step_offset = so.step_factor(
+            cruise_multiplier = step_dist / cruise_v
+            cruise_steps = cruise_d * inv_step_dist
+            count = so.step_factor(
                 mcu_time, cruise_steps, step_offset, cruise_multiplier)
+            stepper_pos += count
+            step_offset += count - cruise_steps
             mcu_time += cruise_t
-            # Deceleration steps
+        # Deceleration steps
+        if decel_d:
             #t = cruise_v/accel - sqrt((cruise_v/accel)**2 - 2*pos/accel)
             decel_time_offset = decel_v * inv_accel
             decel_sqrt_offset = decel_time_offset**2
-            decel_steps = decel_d * inv_move_step_d
-            so.step_sqrt(
+            decel_steps = decel_d * inv_step_dist
+            count = so.step_sqrt(
                 mcu_time + decel_time_offset, decel_steps, step_offset
                 , decel_sqrt_offset, -accel_multiplier)
-
-        # Determine retract steps
-        start_pos = end_pos
-        end_pos -= retract_d
-        new_step_pos = int(end_pos*inv_step_dist + 0.5)
-        if new_step_pos != self.stepper_pos:
-            steps = retract_d * inv_step_dist
-            step_offset = start_pos * inv_step_dist - self.stepper_pos + 0.5
-            self.stepper_pos = new_step_pos
-            mcu_time, so = self.stepper.prep_move(
-                move_time+accel_t+cruise_t+decel_t, 0)
-
-            move_step_d = retract_d / steps
-
-            # Acceleration steps
+            stepper_pos += count
+            step_offset += count - decel_steps
+            mcu_time += decel_t
+        # Retraction steps
+        if retract_d:
             #t = sqrt(2*pos/accel + (start_v/accel)**2) - start_v/accel
             accel_time_offset = retract_v * inv_accel
             accel_sqrt_offset = accel_time_offset**2
-            accel_multiplier = 2.0 * move_step_d * inv_accel
-            so.step_sqrt(mcu_time - accel_time_offset, steps, step_offset
-                         , accel_sqrt_offset, accel_multiplier)
-        self.extrude_pos = end_pos
+            accel_steps = -retract_d * inv_step_dist
+            count = so.step_sqrt(
+                mcu_time - accel_time_offset, accel_steps, step_offset
+                , accel_sqrt_offset, accel_multiplier)
+            stepper_pos += count
+
+        self.stepper_pos = stepper_pos
+        self.extrude_pos = start_pos + accel_d + cruise_d + decel_d - retract_d