motion_control.cpp 6.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148
  1. /*
  2. motion_control.c - high level interface for issuing motion commands
  3. Part of Grbl
  4. Copyright (c) 2009-2011 Simen Svale Skogsrud
  5. Copyright (c) 2011 Sungeun K. Jeon
  6. Grbl is free software: you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation, either version 3 of the License, or
  9. (at your option) any later version.
  10. Grbl is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. GNU General Public License for more details.
  14. You should have received a copy of the GNU General Public License
  15. along with Grbl. If not, see <http://www.gnu.org/licenses/>.
  16. */
  17. #include "Marlin.h"
  18. #include "stepper.h"
  19. #include "planner.h"
  20. // The arc is approximated by generating a huge number of tiny, linear segments. The length of each
  21. // segment is configured in settings.mm_per_arc_segment.
  22. void mc_arc(float *position, float *target, float *offset, uint8_t axis_0, uint8_t axis_1,
  23. uint8_t axis_linear, float feed_rate, float radius, uint8_t isclockwise, uint8_t extruder)
  24. {
  25. // int acceleration_manager_was_enabled = plan_is_acceleration_manager_enabled();
  26. // plan_set_acceleration_manager_enabled(false); // disable acceleration management for the duration of the arc
  27. float center_axis0 = position[axis_0] + offset[axis_0];
  28. float center_axis1 = position[axis_1] + offset[axis_1];
  29. float linear_travel = target[axis_linear] - position[axis_linear];
  30. float extruder_travel = target[E_AXIS] - position[E_AXIS];
  31. float r_axis0 = -offset[axis_0]; // Radius vector from center to current location
  32. float r_axis1 = -offset[axis_1];
  33. float rt_axis0 = target[axis_0] - center_axis0;
  34. float rt_axis1 = target[axis_1] - center_axis1;
  35. // CCW angle between position and target from circle center. Only one atan2() trig computation required.
  36. float angular_travel = atan2(r_axis0*rt_axis1-r_axis1*rt_axis0, r_axis0*rt_axis0+r_axis1*rt_axis1);
  37. if (angular_travel < 0) { angular_travel += 2*M_PI; }
  38. if (isclockwise) { angular_travel -= 2*M_PI; }
  39. float millimeters_of_travel = hypot(angular_travel*radius, fabs(linear_travel));
  40. if (millimeters_of_travel < 0.001) { return; }
  41. uint16_t segments = floor(millimeters_of_travel/MM_PER_ARC_SEGMENT);
  42. if(segments == 0) segments = 1;
  43. /*
  44. // Multiply inverse feed_rate to compensate for the fact that this movement is approximated
  45. // by a number of discrete segments. The inverse feed_rate should be correct for the sum of
  46. // all segments.
  47. if (invert_feed_rate) { feed_rate *= segments; }
  48. */
  49. float theta_per_segment = angular_travel/segments;
  50. float linear_per_segment = linear_travel/segments;
  51. float extruder_per_segment = extruder_travel/segments;
  52. /* Vector rotation by transformation matrix: r is the original vector, r_T is the rotated vector,
  53. and phi is the angle of rotation. Based on the solution approach by Jens Geisler.
  54. r_T = [cos(phi) -sin(phi);
  55. sin(phi) cos(phi] * r ;
  56. For arc generation, the center of the circle is the axis of rotation and the radius vector is
  57. defined from the circle center to the initial position. Each line segment is formed by successive
  58. vector rotations. This requires only two cos() and sin() computations to form the rotation
  59. matrix for the duration of the entire arc. Error may accumulate from numerical round-off, since
  60. all double numbers are single precision on the Arduino. (True double precision will not have
  61. round off issues for CNC applications.) Single precision error can accumulate to be greater than
  62. tool precision in some cases. Therefore, arc path correction is implemented.
  63. Small angle approximation may be used to reduce computation overhead further. This approximation
  64. holds for everything, but very small circles and large mm_per_arc_segment values. In other words,
  65. theta_per_segment would need to be greater than 0.1 rad and N_ARC_CORRECTION would need to be large
  66. to cause an appreciable drift error. N_ARC_CORRECTION~=25 is more than small enough to correct for
  67. numerical drift error. N_ARC_CORRECTION may be on the order a hundred(s) before error becomes an
  68. issue for CNC machines with the single precision Arduino calculations.
  69. This approximation also allows mc_arc to immediately insert a line segment into the planner
  70. without the initial overhead of computing cos() or sin(). By the time the arc needs to be applied
  71. a correction, the planner should have caught up to the lag caused by the initial mc_arc overhead.
  72. This is important when there are successive arc motions.
  73. */
  74. // Vector rotation matrix values
  75. float cos_T = 1-0.5*theta_per_segment*theta_per_segment; // Small angle approximation
  76. float sin_T = theta_per_segment;
  77. float arc_target[4];
  78. float sin_Ti;
  79. float cos_Ti;
  80. float r_axisi;
  81. uint16_t i;
  82. int8_t count = 0;
  83. // Initialize the linear axis
  84. arc_target[axis_linear] = position[axis_linear];
  85. // Initialize the extruder axis
  86. arc_target[E_AXIS] = position[E_AXIS];
  87. for (i = 1; i<segments; i++) { // Increment (segments-1)
  88. if (count < N_ARC_CORRECTION) {
  89. // Apply vector rotation matrix
  90. r_axisi = r_axis0*sin_T + r_axis1*cos_T;
  91. r_axis0 = r_axis0*cos_T - r_axis1*sin_T;
  92. r_axis1 = r_axisi;
  93. count++;
  94. } else {
  95. // Arc correction to radius vector. Computed only every N_ARC_CORRECTION increments.
  96. // Compute exact location by applying transformation matrix from initial radius vector(=-offset).
  97. cos_Ti = cos(i*theta_per_segment);
  98. sin_Ti = sin(i*theta_per_segment);
  99. r_axis0 = -offset[axis_0]*cos_Ti + offset[axis_1]*sin_Ti;
  100. r_axis1 = -offset[axis_0]*sin_Ti - offset[axis_1]*cos_Ti;
  101. count = 0;
  102. }
  103. // Update arc_target location
  104. arc_target[axis_0] = center_axis0 + r_axis0;
  105. arc_target[axis_1] = center_axis1 + r_axis1;
  106. arc_target[axis_linear] += linear_per_segment;
  107. arc_target[E_AXIS] += extruder_per_segment;
  108. if (min_software_endstops) {
  109. if (arc_target[X_AXIS] < X_HOME_POS) arc_target[X_AXIS] = X_HOME_POS;
  110. if (arc_target[Y_AXIS] < Y_HOME_POS) arc_target[Y_AXIS] = Y_HOME_POS;
  111. if (arc_target[Z_AXIS] < Z_HOME_POS) arc_target[Z_AXIS] = Z_HOME_POS;
  112. }
  113. if (max_software_endstops) {
  114. if (arc_target[X_AXIS] > X_MAX_LENGTH) arc_target[X_AXIS] = X_MAX_LENGTH;
  115. if (arc_target[Y_AXIS] > Y_MAX_LENGTH) arc_target[Y_AXIS] = Y_MAX_LENGTH;
  116. if (arc_target[Z_AXIS] > Z_MAX_LENGTH) arc_target[Z_AXIS] = Z_MAX_LENGTH;
  117. }
  118. plan_buffer_line(arc_target[X_AXIS], arc_target[Y_AXIS], arc_target[Z_AXIS], arc_target[E_AXIS], feed_rate, extruder);
  119. }
  120. // Ensure last segment arrives at target location.
  121. plan_buffer_line(target[X_AXIS], target[Y_AXIS], target[Z_AXIS], target[E_AXIS], feed_rate, extruder);
  122. // plan_set_acceleration_manager_enabled(acceleration_manager_was_enabled);
  123. }