Subversion Repositories MK-Marlin

/**

 * Marlin 3D Printer Firmware

 * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]

 *

 * Based on Sprinter and grbl.

 * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 *

 */

#include "MarlinConfig.h"

#if ENABLED(NOZZLE_CLEAN_FEATURE) || ENABLED(NOZZLE_PARK_FEATURE)

#include "nozzle.h"

#include "Marlin.h"

#include "point_t.h"

#if ENABLED(NOZZLE_CLEAN_FEATURE)

  /**

   * @brief Stroke clean pattern

   * @details Wipes the nozzle back and forth in a linear movement

   *

   * @param start point_t defining the starting point

   * @param end point_t defining the ending point

   * @param strokes number of strokes to execute

   */

  void Nozzle::stroke(const point_t &start, const point_t &end, const uint8_t &strokes) {

    #if ENABLED(NOZZLE_CLEAN_GOBACK)

      const float ix = current_position[X_AXIS], iy = current_position[Y_AXIS], iz = current_position[Z_AXIS];

    #endif

    // Move to the starting point

    do_blocking_move_to(start.x, start.y, start.z);

    // Start the stroke pattern

    for (uint8_t i = 0; i < (strokes >> 1); i++) {

      do_blocking_move_to_xy(end.x, end.y);

      do_blocking_move_to_xy(start.x, start.y);

    }

    #if ENABLED(NOZZLE_CLEAN_GOBACK)

      do_blocking_move_to(ix, iy, iz);

    #endif

  }

  /**

   * @brief Zig-zag clean pattern

   * @details Apply a zig-zag cleaning pattern

   *

   * @param start point_t defining the starting point

   * @param end point_t defining the ending point

   * @param strokes number of strokes to execute

   * @param objects number of triangles to do

   */

  void Nozzle::zigzag(const point_t &start, const point_t &end, const uint8_t &strokes, const uint8_t &objects) {

    const float diffx = end.x - start.x, diffy = end.y - start.y;

    if (!diffx || !diffy) return;

    #if ENABLED(NOZZLE_CLEAN_GOBACK)

      const float ix = current_position[X_AXIS], iy = current_position[Y_AXIS], iz = current_position[Z_AXIS];

    #endif

    do_blocking_move_to(start.x, start.y, start.z);

    const uint8_t zigs = objects << 1;

    const bool horiz = ABS(diffx) >= ABS(diffy);    // Do a horizontal wipe?

    const float P = (horiz ? diffx : diffy) / zigs;   // Period of each zig / zag

    const point_t *side;

    for (uint8_t j = 0; j < strokes; j++) {

      for (int8_t i = 0; i < zigs; i++) {

        side = (i & 1) ? &end : &start;

        if (horiz)

          do_blocking_move_to_xy(start.x + i * P, side->y);

        else

          do_blocking_move_to_xy(side->x, start.y + i * P);

      }

      for (int8_t i = zigs; i >= 0; i--) {

        side = (i & 1) ? &end : &start;

        if (horiz)

          do_blocking_move_to_xy(start.x + i * P, side->y);

        else

          do_blocking_move_to_xy(side->x, start.y + i * P);

      }

    }

    #if ENABLED(NOZZLE_CLEAN_GOBACK)

      do_blocking_move_to(ix, iy, iz);

    #endif

  }

  /**

   * @brief Circular clean pattern

   * @details Apply a circular cleaning pattern

   *

   * @param start point_t defining the middle of circle

   * @param strokes number of strokes to execute

   * @param radius radius of circle

   */

  void Nozzle::circle(const point_t &start, const point_t &middle, const uint8_t &strokes, const float &radius) {

    if (strokes == 0) return;

    #if ENABLED(NOZZLE_CLEAN_GOBACK)

      const float ix = current_position[X_AXIS], iy = current_position[Y_AXIS], iz = current_position[Z_AXIS];

    #endif

    do_blocking_move_to(start.x, start.y, start.z);

    for (uint8_t s = 0; s < strokes; s++)

      for (uint8_t i = 0; i < NOZZLE_CLEAN_CIRCLE_FN; i++)

        do_blocking_move_to_xy(

          middle.x + sin((RADIANS(360) / NOZZLE_CLEAN_CIRCLE_FN) * i) * radius,

          middle.y + cos((RADIANS(360) / NOZZLE_CLEAN_CIRCLE_FN) * i) * radius

        );

    // Let's be safe

    do_blocking_move_to_xy(start.x, start.y);

    #if ENABLED(NOZZLE_CLEAN_GOBACK)

      do_blocking_move_to(ix, iy, iz);

    #endif

  }

  /**

   * @brief Clean the nozzle

   * @details Starts the selected clean procedure pattern

   *

   * @param pattern one of the available patterns

   * @param argument depends on the cleaning pattern

   */

  void Nozzle::clean(const uint8_t &pattern, const uint8_t &strokes, const float &radius, const uint8_t &objects/*=0*/) {

    switch (pattern) {

      case 1:

        zigzag(NOZZLE_CLEAN_START_POINT, NOZZLE_CLEAN_END_POINT, strokes, objects);

        break;

      case 2:

        circle(NOZZLE_CLEAN_START_POINT, NOZZLE_CLEAN_CIRCLE_MIDDLE, strokes, radius);

        break;

      default:

        stroke(NOZZLE_CLEAN_START_POINT, NOZZLE_CLEAN_END_POINT, strokes);

    }

  }

#endif // NOZZLE_CLEAN_FEATURE

#if ENABLED(NOZZLE_PARK_FEATURE)

  constexpr float npp[] = NOZZLE_PARK_POINT;

  static_assert(COUNT(npp) == XYZ, "NOZZLE_PARK_POINT requires X, Y, and Z values.");

  void Nozzle::park(const uint8_t &z_action, const point_t &park/*=NOZZLE_PARK_POINT*/) {

    const float fr_xy = NOZZLE_PARK_XY_FEEDRATE, fr_z = NOZZLE_PARK_Z_FEEDRATE;

    switch (z_action) {

      case 1: // Go to Z-park height

        do_blocking_move_to_z(park.z, fr_z);

        break;

      case 2: // Raise by Z-park height

        do_blocking_move_to_z(MIN(current_position[Z_AXIS] + park.z, Z_MAX_POS), fr_z);

        break;

      default: // Raise to at least the Z-park height

        do_blocking_move_to_z(MAX(park.z, current_position[Z_AXIS]), fr_z);

    }

    do_blocking_move_to_xy(park.x, park.y, fr_xy);

  }

#endif // NOZZLE_PARK_FEATURE

#endif // NOZZLE_CLEAN_FEATURE || NOZZLE_PARK_FEATURE