From da2eaa6b09fae45ca5dcbd12dc928d5dd721ce2f Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Sat, 9 Dec 2017 05:11:22 -0600 Subject: [PATCH] Use array refs where possible --- Marlin/Marlin_main.cpp | 32 ++++++++++++++++---------------- Marlin/planner.cpp | 14 +++++++------- Marlin/planner.h | 8 ++++---- Marlin/ubl.h | 2 +- Marlin/ubl_motion.cpp | 4 ++-- 5 files changed, 30 insertions(+), 30 deletions(-) diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 5df216651..3ed0d723e 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -733,11 +733,11 @@ void get_cartesian_from_steppers(); void set_current_from_steppers_for_axis(const AxisEnum axis); #if ENABLED(ARC_SUPPORT) - void plan_arc(float target[XYZE], float* offset, uint8_t clockwise); + void plan_arc(const float (&cart)[XYZE], const float (&offset)[2], const bool clockwise); #endif #if ENABLED(BEZIER_CURVE_SUPPORT) - void plan_cubic_move(const float offset[4]); + void plan_cubic_move(const float (&offset)[4]); #endif void tool_change(const uint8_t tmp_extruder, const float fr_mm_s=0.0, bool no_move=false); @@ -1808,7 +1808,7 @@ static void clean_up_after_endstop_or_probe_move() { #elif ENABLED(Z_PROBE_ALLEN_KEY) - FORCE_INLINE void do_blocking_move_to(const float raw[XYZ], const float &fr_mm_s) { + FORCE_INLINE void do_blocking_move_to(const float (&raw)[XYZ], const float &fr_mm_s) { do_blocking_move_to(raw[X_AXIS], raw[Y_AXIS], raw[Z_AXIS], fr_mm_s); } @@ -8326,7 +8326,7 @@ void report_current_position() { #ifdef M114_DETAIL - void report_xyze(const float pos[XYZE], const uint8_t n = 4, const uint8_t precision = 3) { + void report_xyze(const float pos[], const uint8_t n = 4, const uint8_t precision = 3) { char str[12]; for (uint8_t i = 0; i < n; i++) { SERIAL_CHAR(' '); @@ -8337,7 +8337,7 @@ void report_current_position() { SERIAL_EOL(); } - inline void report_xyz(const float pos[XYZ]) { report_xyze(pos, 3); } + inline void report_xyz(const float pos[]) { report_xyze(pos, 3); } void report_current_position_detail() { @@ -12659,7 +12659,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { * For Unified Bed Leveling (Delta or Segmented Cartesian) * the ubl.prepare_segmented_line_to method replaces this. */ - inline bool prepare_kinematic_move_to(float rtarget[XYZE]) { + inline bool prepare_kinematic_move_to(const float (&rtarget)[XYZE]) { // Get the top feedrate of the move in the XY plane const float _feedrate_mm_s = MMS_SCALED(feedrate_mm_s); @@ -12968,9 +12968,9 @@ void prepare_move_to_destination() { * options for G2/G3 arc generation. In future these options may be GCode tunable. */ void plan_arc( - float raw[XYZE], // Destination position - float *offset, // Center of rotation relative to current_position - uint8_t clockwise // Clockwise? + const float (&cart)[XYZE], // Destination position + const float (&offset)[2], // Center of rotation relative to current_position + const bool clockwise // Clockwise? ) { #if ENABLED(CNC_WORKSPACE_PLANES) AxisEnum p_axis, q_axis, l_axis; @@ -12990,10 +12990,10 @@ void prepare_move_to_destination() { const float radius = HYPOT(r_P, r_Q), center_P = current_position[p_axis] - r_P, center_Q = current_position[q_axis] - r_Q, - rt_X = raw[p_axis] - center_P, - rt_Y = raw[q_axis] - center_Q, - linear_travel = raw[l_axis] - current_position[l_axis], - extruder_travel = raw[E_AXIS] - current_position[E_AXIS]; + rt_X = cart[p_axis] - center_P, + rt_Y = cart[q_axis] - center_Q, + linear_travel = cart[l_axis] - current_position[l_axis], + extruder_travel = cart[E_AXIS] - current_position[E_AXIS]; // CCW angle of rotation between position and target from the circle center. Only one atan2() trig computation required. float angular_travel = ATAN2(r_P * rt_Y - r_Q * rt_X, r_P * rt_X + r_Q * rt_Y); @@ -13001,7 +13001,7 @@ void prepare_move_to_destination() { if (clockwise) angular_travel -= RADIANS(360); // Make a circle if the angular rotation is 0 and the target is current position - if (angular_travel == 0 && current_position[p_axis] == raw[p_axis] && current_position[q_axis] == raw[q_axis]) + if (angular_travel == 0 && current_position[p_axis] == cart[p_axis] && current_position[q_axis] == cart[q_axis]) angular_travel = RADIANS(360); const float mm_of_travel = HYPOT(angular_travel * radius, FABS(linear_travel)); @@ -13101,7 +13101,7 @@ void prepare_move_to_destination() { } // Ensure last segment arrives at target location. - planner.buffer_line_kinematic(raw, fr_mm_s, active_extruder); + planner.buffer_line_kinematic(cart, fr_mm_s, active_extruder); // As far as the parser is concerned, the position is now == target. In reality the // motion control system might still be processing the action and the real tool position @@ -13113,7 +13113,7 @@ void prepare_move_to_destination() { #if ENABLED(BEZIER_CURVE_SUPPORT) - void plan_cubic_move(const float offset[4]) { + void plan_cubic_move(const float (&offset)[4]) { cubic_b_spline(current_position, destination, offset, MMS_SCALED(feedrate_mm_s), active_extruder); // As far as the parser is concerned, the position is now == destination. In reality the diff --git a/Marlin/planner.cpp b/Marlin/planner.cpp index 1d6ab073f..5287d5413 100644 --- a/Marlin/planner.cpp +++ b/Marlin/planner.cpp @@ -1455,18 +1455,18 @@ void Planner::_set_position_mm(const float &a, const float &b, const float &c, c ZERO(previous_speed); } -void Planner::set_position_mm_kinematic(const float position[NUM_AXIS]) { +void Planner::set_position_mm_kinematic(const float (&cart)[XYZE]) { #if PLANNER_LEVELING - float lpos[XYZ] = { position[X_AXIS], position[Y_AXIS], position[Z_AXIS] }; - apply_leveling(lpos); + float raw[XYZ] = { cart[X_AXIS], cart[Y_AXIS], cart[Z_AXIS] }; + apply_leveling(raw); #else - const float * const lpos = position; + const float (&raw)[XYZE] = cart; #endif #if IS_KINEMATIC - inverse_kinematics(lpos); - _set_position_mm(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], position[E_AXIS]); + inverse_kinematics(raw); + _set_position_mm(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], cart[E_AXIS]); #else - _set_position_mm(lpos[X_AXIS], lpos[Y_AXIS], lpos[Z_AXIS], position[E_AXIS]); + _set_position_mm(raw[X_AXIS], raw[Y_AXIS], raw[Z_AXIS], cart[E_AXIS]); #endif } diff --git a/Marlin/planner.h b/Marlin/planner.h index 24e5cbee8..a30aaacf2 100644 --- a/Marlin/planner.h +++ b/Marlin/planner.h @@ -352,7 +352,7 @@ class Planner { * as it will be given to the planner and steppers. */ static void apply_leveling(float &rx, float &ry, float &rz); - static void apply_leveling(float raw[XYZ]) { apply_leveling(raw[X_AXIS], raw[Y_AXIS], raw[Z_AXIS]); } + static void apply_leveling(float (&raw)[XYZ]) { apply_leveling(raw[X_AXIS], raw[Y_AXIS], raw[Z_AXIS]); } static void unapply_leveling(float raw[XYZ]); #else @@ -417,12 +417,12 @@ class Planner { * fr_mm_s - (target) speed of the move (mm/s) * extruder - target extruder */ - FORCE_INLINE static void buffer_line_kinematic(const float cart[XYZE], const float &fr_mm_s, const uint8_t extruder) { + FORCE_INLINE static void buffer_line_kinematic(const float (&cart)[XYZE], const float &fr_mm_s, const uint8_t extruder) { #if PLANNER_LEVELING float raw[XYZ] = { cart[X_AXIS], cart[Y_AXIS], cart[Z_AXIS] }; apply_leveling(raw); #else - const float * const raw = cart; + const float (&raw)[XYZE] = cart; #endif #if IS_KINEMATIC inverse_kinematics(raw); @@ -447,7 +447,7 @@ class Planner { #endif _set_position_mm(rx, ry, rz, e); } - static void set_position_mm_kinematic(const float position[NUM_AXIS]); + static void set_position_mm_kinematic(const float (&cart)[XYZE]); static void set_position_mm(const AxisEnum axis, const float &v); FORCE_INLINE static void set_z_position_mm(const float &z) { set_position_mm(Z_AXIS, z); } FORCE_INLINE static void set_e_position_mm(const float &e) { set_position_mm(AxisEnum(E_AXIS), e); } diff --git a/Marlin/ubl.h b/Marlin/ubl.h index b1d8ba3ea..05a22392c 100644 --- a/Marlin/ubl.h +++ b/Marlin/ubl.h @@ -319,7 +319,7 @@ return i < GRID_MAX_POINTS_Y ? pgm_read_float(&_mesh_index_to_ypos[i]) : MESH_MIN_Y + i * (MESH_Y_DIST); } - static bool prepare_segmented_line_to(const float rtarget[XYZE], const float &feedrate); + static bool prepare_segmented_line_to(const float (&rtarget)[XYZE], const float &feedrate); static void line_to_destination_cartesian(const float &fr, uint8_t e); #define _CMPZ(a,b) (z_values[a][b] == z_values[a][b+1]) diff --git a/Marlin/ubl_motion.cpp b/Marlin/ubl_motion.cpp index bb455ab9c..feded987d 100644 --- a/Marlin/ubl_motion.cpp +++ b/Marlin/ubl_motion.cpp @@ -470,7 +470,7 @@ // We don't want additional apply_leveling() performed by regular buffer_line or buffer_line_kinematic, // so we call buffer_segment directly here. Per-segmented leveling and kinematics performed first. - inline void _O2 ubl_buffer_segment_raw(const float raw[XYZE], const float &fr) { + inline void _O2 ubl_buffer_segment_raw(const float (&raw)[XYZE], const float &fr) { #if ENABLED(DELTA) // apply delta inverse_kinematics @@ -515,7 +515,7 @@ * Returns true if did NOT move, false if moved (requires current_position update). */ - bool _O2 unified_bed_leveling::prepare_segmented_line_to(const float rtarget[XYZE], const float &feedrate) { + bool _O2 unified_bed_leveling::prepare_segmented_line_to(const float (&in_target)[XYZE], const float &feedrate) { if (!position_is_reachable(rtarget[X_AXIS], rtarget[Y_AXIS])) // fail if moving outside reachable boundary return true; // did not move, so current_position still accurate