Browse Source

Fix Horizontal and Vertical UBL optimization bug. (#6540)

* Fix Horizontal and Vertical optimization bug.

And drastically reduce the debug code foot print....

* Yeah Baby!

The debug print is going A - OK !
Roxy-3D 8 years ago
parent
commit
41e63bbb7c
1 changed files with 33 additions and 118 deletions
  1. 33
    118
      Marlin/ubl_motion.cpp

+ 33
- 118
Marlin/ubl_motion.cpp View File

@@ -1,3 +1,4 @@
1
+
1 2
 /**
2 3
  * Marlin 3D Printer Firmware
3 4
  * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
@@ -167,26 +168,6 @@
167 168
 
168 169
       float z0 = z1 + (z2 - z1) * yratio;
169 170
 
170
-      /**
171
-       * Debug code to use non-optimized get_z_correction() and to do a sanity check
172
-       * that the correct value is being passed to planner.buffer_line()
173
-       */
174
-      /*
175
-        z_optimized = z0;
176
-        z0 = ubl.get_z_correction(end[X_AXIS], end[Y_AXIS]);
177
-        if (fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized)) {
178
-        debug_current_and_destination(PSTR("FINAL_MOVE: z_correction()"));
179
-        if (isnan(z0)) SERIAL_ECHO(" z0==NAN  ");
180
-        if (isnan(z_optimized)) SERIAL_ECHO(" z_optimized==NAN  ");
181
-        SERIAL_ECHOPAIR("  end[X_AXIS]=", end[X_AXIS]);
182
-        SERIAL_ECHOPAIR("  end[Y_AXIS]=", end[Y_AXIS]);
183
-        SERIAL_ECHOPAIR("  z0=", z0);
184
-        SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
185
-        SERIAL_ECHOPAIR("  err=",fabs(z_optimized - z0));
186
-        SERIAL_EOL;
187
-        }
188
-      */
189
-
190 171
       z0 *= ubl.fade_scaling_factor_for_z(end[Z_AXIS]);
191 172
 
192 173
       /**
@@ -218,8 +199,8 @@
218 199
     const float dx = end[X_AXIS] - start[X_AXIS],
219 200
                 dy = end[Y_AXIS] - start[Y_AXIS];
220 201
 
221
-    const int left_flag = dx < 0.0 ? 1 : 0,
222
-              down_flag = dy < 0.0 ? 1 : 0;
202
+    const int left_flag = dx < 0.0 ? 1.0 : 0.0,
203
+              down_flag = dy < 0.0 ? 1.0 : 0.0;
223 204
 
224 205
     const float adx = left_flag ? -dx : dx,
225 206
                 ady = down_flag ? -dy : dy;
@@ -250,9 +231,8 @@
250 231
     const float m = dy / dx,
251 232
                 c = start[Y_AXIS] - m * start[X_AXIS];
252 233
 
253
-    const bool inf_normalized_flag = isinf(e_normalized_dist),
254
-               inf_m_flag = isinf(m);
255
-
234
+    const bool inf_normalized_flag=isinf(e_normalized_dist),
235
+               inf_m_flag=isinf(m);
256 236
     /**
257 237
      * This block handles vertical lines. These are lines that stay within the same
258 238
      * X Cell column. They do not need to be perfectly vertical. They just can
@@ -273,26 +253,6 @@
273 253
 
274 254
         float z0 = ubl.z_correction_for_x_on_horizontal_mesh_line(x, current_xi, current_yi);
275 255
 
276
-        /**
277
-         * Debug code to use non-optimized get_z_correction() and to do a sanity check
278
-         * that the correct value is being passed to planner.buffer_line()
279
-         */
280
-        /*
281
-          z_optimized = z0;
282
-          z0 = ubl.get_z_correction(x, next_mesh_line_y);
283
-          if (fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized)) {
284
-            debug_current_and_destination(PSTR("VERTICAL z_correction()"));
285
-          if (isnan(z0)) SERIAL_ECHO(" z0==NAN  ");
286
-            if (isnan(z_optimized)) SERIAL_ECHO(" z_optimized==NAN  ");
287
-          SERIAL_ECHOPAIR("  x=", x);
288
-          SERIAL_ECHOPAIR("  next_mesh_line_y=", next_mesh_line_y);
289
-          SERIAL_ECHOPAIR("  z0=", z0);
290
-          SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
291
-          SERIAL_ECHOPAIR("  err=",fabs(z_optimized-z0));
292
-          SERIAL_ECHO("\n");
293
-          }
294
-        */
295
-
296 256
         z0 *= ubl.fade_scaling_factor_for_z(end[Z_AXIS]);
297 257
 
298 258
         /**
@@ -314,13 +274,23 @@
314 274
          */
315 275
         if (y != start[Y_AXIS]) {
316 276
           if (!inf_normalized_flag) {
317
-            on_axis_distance = y - start[Y_AXIS];                               // we don't need to check if the extruder position
318
-            e_position = start[E_AXIS] + on_axis_distance * e_normalized_dist;  // is based on X or Y because this is a vertical move
277
+
278
+//          on_axis_distance = y - start[Y_AXIS];                               
279
+            on_axis_distance = use_x_dist ? x - start[X_AXIS] : y - start[Y_AXIS];
280
+
281
+//          on_axis_distance = use_x_dist ? next_mesh_line_x - start[X_AXIS] : y - start[Y_AXIS];
282
+//          on_axis_distance = use_x_dist ? x - start[X_AXIS] : next_mesh_line_y - start[Y_AXIS];
283
+
284
+//          on_axis_distance = use_x_dist ? next_mesh_line_x - start[X_AXIS] : y - start[Y_AXIS];
285
+//          on_axis_distance = use_x_dist ? x - start[X_AXIS] : next_mesh_line_y - start[Y_AXIS];
286
+
287
+
288
+            e_position = start[E_AXIS] + on_axis_distance * e_normalized_dist;  
319 289
             z_position = start[Z_AXIS] + on_axis_distance * z_normalized_dist;
320 290
           }
321 291
           else {
322
-            e_position = start[E_AXIS];
323
-            z_position = start[Z_AXIS];
292
+            e_position = end[E_AXIS];
293
+            z_position = end[Z_AXIS];
324 294
           }
325 295
 
326 296
           planner.buffer_line(x, y, z_position + z0 + ubl.state.z_offset, e_position, feed_rate, extruder);
@@ -354,30 +324,10 @@
354 324
       while (current_xi != cell_dest_xi + left_flag) {
355 325
         current_xi += dxi;
356 326
         const float next_mesh_line_x = LOGICAL_X_POSITION(pgm_read_float(&(ubl.mesh_index_to_xpos[current_xi]))),
357
-                    y = m * next_mesh_line_x + c;   // Calculate X at the next Y mesh line
327
+                    y = m * next_mesh_line_x + c;   // Calculate Y at the next X mesh line
358 328
 
359 329
         float z0 = ubl.z_correction_for_y_on_vertical_mesh_line(y, current_xi, current_yi);
360 330
 
361
-        /**
362
-         * Debug code to use non-optimized get_z_correction() and to do a sanity check
363
-         * that the correct value is being passed to planner.buffer_line()
364
-         */
365
-        /*
366
-          z_optimized = z0;
367
-          z0 = ubl.get_z_correction(next_mesh_line_x, y);
368
-          if (fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized)) {
369
-            debug_current_and_destination(PSTR("HORIZONTAL z_correction()"));
370
-          if (isnan(z0)) SERIAL_ECHO(" z0==NAN  ");
371
-            if (isnan(z_optimized)) SERIAL_ECHO(" z_optimized==NAN  ");
372
-          SERIAL_ECHOPAIR("  next_mesh_line_x=", next_mesh_line_x);
373
-          SERIAL_ECHOPAIR("  y=", y);
374
-          SERIAL_ECHOPAIR("  z0=", z0);
375
-          SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
376
-          SERIAL_ECHOPAIR("  err=",fabs(z_optimized-z0));
377
-          SERIAL_ECHO("\n");
378
-          }
379
-        */
380
-
381 331
         z0 *= ubl.fade_scaling_factor_for_z(end[Z_AXIS]);
382 332
 
383 333
         /**
@@ -399,13 +349,19 @@
399 349
          */
400 350
         if (x != start[X_AXIS]) {
401 351
           if (!inf_normalized_flag) {
402
-            on_axis_distance = x - start[X_AXIS];                               // we don't need to check if the extruder position
352
+
353
+//          on_axis_distance = x - start[X_AXIS];
354
+            on_axis_distance = use_x_dist ? x - start[X_AXIS] : y - start[Y_AXIS];
355
+
356
+//          on_axis_distance = use_x_dist ? next_mesh_line_x - start[X_AXIS] : y - start[Y_AXIS];
357
+//          on_axis_distance = use_x_dist ? x - start[X_AXIS] : next_mesh_line_y - start[Y_AXIS];
358
+
403 359
             e_position = start[E_AXIS] + on_axis_distance * e_normalized_dist;  // is based on X or Y because this is a horizontal move
404 360
             z_position = start[Z_AXIS] + on_axis_distance * z_normalized_dist;
405 361
           }
406 362
           else {
407
-            e_position = start[E_AXIS];
408
-            z_position = start[Z_AXIS];
363
+            e_position = end[E_AXIS];
364
+            z_position = end[Z_AXIS];
409 365
           }
410 366
 
411 367
           planner.buffer_line(x, y, z_position + z0 + ubl.state.z_offset, e_position, feed_rate, extruder);
@@ -453,27 +409,6 @@
453 409
         //
454 410
         float z0 = ubl.z_correction_for_x_on_horizontal_mesh_line(x, current_xi - left_flag, current_yi + dyi);
455 411
 
456
-        /**
457
-         * Debug code to use non-optimized get_z_correction() and to do a sanity check
458
-         * that the correct value is being passed to planner.buffer_line()
459
-         */
460
-        /*
461
-          z_optimized = z0;
462
-          z0 = ubl.get_z_correction(x, next_mesh_line_y);
463
-          if (fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized)) {
464
-            debug_current_and_destination(PSTR("General_1: z_correction()"));
465
-            if (isnan(z0)) SERIAL_ECHO(" z0==NAN  ");
466
-            if (isnan(z_optimized)) SERIAL_ECHO(" z_optimized==NAN  "); {
467
-              SERIAL_ECHOPAIR("  x=", x);
468
-            }
469
-            SERIAL_ECHOPAIR("  next_mesh_line_y=", next_mesh_line_y);
470
-            SERIAL_ECHOPAIR("  z0=", z0);
471
-            SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
472
-            SERIAL_ECHOPAIR("  err=",fabs(z_optimized-z0));
473
-            SERIAL_ECHO("\n");
474
-          }
475
-        */
476
-
477 412
         z0 *= ubl.fade_scaling_factor_for_z(end[Z_AXIS]);
478 413
 
479 414
         /**
@@ -491,8 +426,8 @@
491 426
           z_position = start[Z_AXIS] + on_axis_distance * z_normalized_dist;
492 427
         }
493 428
         else {
494
-          e_position = start[E_AXIS];
495
-          z_position = start[Z_AXIS];
429
+          e_position = end[E_AXIS];
430
+          z_position = end[Z_AXIS];
496 431
         }
497 432
         planner.buffer_line(x, next_mesh_line_y, z_position + z0 + ubl.state.z_offset, e_position, feed_rate, extruder);
498 433
         current_yi += dyi;
@@ -504,26 +439,6 @@
504 439
         //
505 440
         float z0 = ubl.z_correction_for_y_on_vertical_mesh_line(y, current_xi + dxi, current_yi - down_flag);
506 441
 
507
-        /**
508
-         * Debug code to use non-optimized get_z_correction() and to do a sanity check
509
-         * that the correct value is being passed to planner.buffer_line()
510
-         */
511
-        /*
512
-          z_optimized = z0;
513
-          z0 = ubl.get_z_correction(next_mesh_line_x, y);
514
-          if (fabs(z_optimized - z0) > .01 || isnan(z0) || isnan(z_optimized)) {
515
-          debug_current_and_destination(PSTR("General_2: z_correction()"));
516
-          if (isnan(z0)) SERIAL_ECHO(" z0==NAN  ");
517
-          if (isnan(z_optimized)) SERIAL_ECHO(" z_optimized==NAN  ");
518
-          SERIAL_ECHOPAIR("  next_mesh_line_x=", next_mesh_line_x);
519
-          SERIAL_ECHOPAIR("  y=", y);
520
-          SERIAL_ECHOPAIR("  z0=", z0);
521
-          SERIAL_ECHOPAIR("  z_optimized=", z_optimized);
522
-          SERIAL_ECHOPAIR("  err=",fabs(z_optimized-z0));
523
-          SERIAL_ECHO("\n");
524
-          }
525
-        */
526
-
527 442
         z0 *= ubl.fade_scaling_factor_for_z(end[Z_AXIS]);
528 443
 
529 444
         /**
@@ -541,8 +456,8 @@
541 456
           z_position = start[Z_AXIS] + on_axis_distance * z_normalized_dist;
542 457
         }
543 458
         else {
544
-          e_position = start[E_AXIS];
545
-          z_position = start[Z_AXIS];
459
+          e_position = end[E_AXIS];
460
+          z_position = end[Z_AXIS];
546 461
         }
547 462
 
548 463
         planner.buffer_line(next_mesh_line_x, y, z_position + z0 + ubl.state.z_offset, e_position, feed_rate, extruder);

Loading…
Cancel
Save