Преглед на файлове

Clean up i2c encoder, sanitize serial

Scott Lahteine преди 5 години
родител
ревизия
e64b7a3ab2
променени са 2 файла, в които са добавени 24 реда и са изтрити 20 реда
  1. 22
    18
      Marlin/src/feature/I2CPositionEncoder.cpp
  2. 2
    2
      Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp

+ 22
- 18
Marlin/src/feature/I2CPositionEncoder.cpp Целия файл

@@ -162,15 +162,17 @@ void I2CPositionEncoder::update() {
162 162
       if (errIdx == 0) {
163 163
         // In order to correct for "error" but avoid correcting for noise and non-skips
164 164
         // it must be > threshold and have a difference average of < 10 and be < 2000 steps
165
-        if (ABS(error) > threshold * planner.settings.axis_steps_per_mm[encoderAxis] &&
166
-            diffSum < 10 * (I2CPE_ERR_ARRAY_SIZE - 1) && ABS(error) < 2000) { // Check for persistent error (skip)
165
+        if (ABS(error) > threshold * planner.settings.axis_steps_per_mm[encoderAxis]
166
+            && diffSum < 10 * (I2CPE_ERR_ARRAY_SIZE - 1)
167
+            && ABS(error) < 2000
168
+        ) {                              // Check for persistent error (skip)
167 169
           errPrst[errPrstIdx++] = error; // Error must persist for I2CPE_ERR_PRST_ARRAY_SIZE error cycles. This also serves to improve the average accuracy
168 170
           if (errPrstIdx >= I2CPE_ERR_PRST_ARRAY_SIZE) {
169 171
             float sumP = 0;
170 172
             LOOP_L_N(i, I2CPE_ERR_PRST_ARRAY_SIZE) sumP += errPrst[i];
171 173
             const int32_t errorP = int32_t(sumP * RECIPROCAL(I2CPE_ERR_PRST_ARRAY_SIZE));
172 174
             SERIAL_ECHO(axis_codes[encoderAxis]);
173
-            SERIAL_ECHOLNPAIR(" - err detected: ", errorP * planner.steps_to_mm[encoderAxis], "mm; correcting!");
175
+            SERIAL_ECHOLNPAIR(" : CORRECT ERR ", errorP * planner.steps_to_mm[encoderAxis], "mm");
174 176
             babystep.add_steps(encoderAxis, -LROUND(errorP));
175 177
             errPrstIdx = 0;
176 178
           }
@@ -189,7 +191,8 @@ void I2CPositionEncoder::update() {
189 191
     if (ABS(error) > I2CPE_ERR_CNT_THRESH * planner.settings.axis_steps_per_mm[encoderAxis]) {
190 192
       const millis_t ms = millis();
191 193
       if (ELAPSED(ms, nextErrorCountTime)) {
192
-        SERIAL_ECHOLNPAIR("Large error on ", axis_codes[encoderAxis], " axis. error: ", (int)error, "; diffSum: ", diffSum);
194
+        SERIAL_ECHO(axis_codes[encoderAxis]);
195
+        SERIAL_ECHOLNPAIR(" : LARGE ERR ", int(error), "; diffSum=", diffSum);
193 196
         errorCount++;
194 197
         nextErrorCountTime = ms + I2CPE_ERR_CNT_DEBOUNCE_MS;
195 198
       }
@@ -243,17 +246,14 @@ bool I2CPositionEncoder::passes_test(const bool report) {
243 246
 }
244 247
 
245 248
 float I2CPositionEncoder::get_axis_error_mm(const bool report) {
246
-  float target, actual, error;
247
-
248
-  target = planner.get_axis_position_mm(encoderAxis);
249
-  actual = mm_from_count(position);
250
-  error = actual - target;
251
-
252
-  if (ABS(error) > 10000) error = 0; // ?
249
+  const float target = planner.get_axis_position_mm(encoderAxis),
250
+              actual = mm_from_count(position),
251
+              diff = actual - target,
252
+              error = ABS(diff) > 10000 ? 0 : diff; // Huge error is a bad reading
253 253
 
254 254
   if (report) {
255 255
     SERIAL_ECHO(axis_codes[encoderAxis]);
256
-    SERIAL_ECHOLNPAIR(" axis target: ", target, ", actual: ", actual, ", error : ",error);
256
+    SERIAL_ECHOLNPAIR(" axis target=", target, "mm; actual=", actual, "mm; err=", error, "mm");
257 257
   }
258 258
 
259 259
   return error;
@@ -278,21 +278,25 @@ int32_t I2CPositionEncoder::get_axis_error_steps(const bool report) {
278 278
   //convert both 'ticks' into same units / base
279 279
   encoderCountInStepperTicksScaled = LROUND((stepperTicksPerUnit * encoderTicks) / encoderTicksPerUnit);
280 280
 
281
-  int32_t target = stepper.position(encoderAxis),
282
-          error = (encoderCountInStepperTicksScaled - target);
281
+  const int32_t target = stepper.position(encoderAxis);
282
+  int32_t error = encoderCountInStepperTicksScaled - target;
283 283
 
284 284
   //suppress discontinuities (might be caused by bad I2C readings...?)
285 285
   const bool suppressOutput = (ABS(error - errorPrev) > 100);
286 286
 
287
+  errorPrev = error;
288
+
287 289
   if (report) {
288 290
     SERIAL_ECHO(axis_codes[encoderAxis]);
289
-    SERIAL_ECHOLNPAIR(" axis target: ", target, ", actual: ", encoderCountInStepperTicksScaled, ", error : ", error);
290
-    if (suppressOutput) SERIAL_ECHOLNPGM("Discontinuity detected, suppressing error.");
291
+    SERIAL_ECHOLNPAIR(" axis target=", target, "; actual=", encoderCountInStepperTicksScaled, "; err=", error);
291 292
   }
292 293
 
293
-  errorPrev = error;
294
+  if (suppressOutput) {
295
+    if (report) SERIAL_ECHOLNPGM("!Discontinuity. Suppressing error.");
296
+    error = 0;
297
+  }
294 298
 
295
-  return (suppressOutput ? 0 : error);
299
+  return error;
296 300
 }
297 301
 
298 302
 int32_t I2CPositionEncoder::get_raw_count() {

+ 2
- 2
Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp Целия файл

@@ -1629,7 +1629,7 @@
1629 1629
           auto debug_pt = [](PGM_P const pre, const xy_pos_t &pos, const float &zadd) {
1630 1630
             d_from(); serialprintPGM(pre);
1631 1631
             DEBUG_ECHO_F(normed(pos, zadd), 6);
1632
-            DEBUG_ECHOLNPAIR_F("   Z error: ", zadd - get_z_correction(pos), 6);
1632
+            DEBUG_ECHOLNPAIR_F("   Z error = ", zadd - get_z_correction(pos), 6);
1633 1633
           };
1634 1634
           debug_pt(PSTR("1st point: "), probe_pt[0], normal.z * z1);
1635 1635
           debug_pt(PSTR("2nd point: "), probe_pt[1], normal.z * z2);
@@ -1638,7 +1638,7 @@
1638 1638
           DEBUG_ECHOLNPAIR_F("0 : ", normed(safe_homing_xy, 0), 6);
1639 1639
           d_from(); DEBUG_ECHOPGM("safe home with Z=");
1640 1640
           DEBUG_ECHOLNPAIR_F("mesh value ", normed(safe_homing_xy, get_z_correction(safe_homing_xy)), 6);
1641
-          DEBUG_ECHOPAIR("   Z error: (", Z_SAFE_HOMING_X_POINT, ",", Z_SAFE_HOMING_Y_POINT);
1641
+          DEBUG_ECHOPAIR("   Z error = (", Z_SAFE_HOMING_X_POINT, ",", Z_SAFE_HOMING_Y_POINT);
1642 1642
           DEBUG_ECHOLNPAIR_F(") = ", get_z_correction(safe_homing_xy), 6);
1643 1643
         #endif
1644 1644
       } // DEBUGGING(LEVELING)

Loading…
Отказ
Запис