unified_bed_leveling Class Reference

#include <ubl.h>

Collaboration diagram for unified_bed_leveling:

Public Member Functions
	unified_bed_leveling ()

Static Public Member Functions
static void	echo_name ()
static void	report_current_mesh ()
static void	report_state ()
static void	save_ubl_active_state_and_disable ()
static void	restore_ubl_active_state_and_leave ()
static void	display_map (const int) _O0
static mesh_index_pair	find_closest_mesh_point_of_type (const MeshPointType, const xy_pos_t &, const bool=false, MeshFlags *done_flags=nullptr) _O0
static mesh_index_pair	find_furthest_invalid_mesh_point () _O0
static void	reset ()
static void	invalidate ()
static void	set_all_mesh_points_to_value (const float value)
static void	adjust_mesh_to_mean (const bool cflag, const float value)
static bool	sanity_check ()
static void	G29 () _O0
static void	smart_fill_wlsf (const float &) _O2
static FORCE_INLINE void	set_z (const int8_t px, const int8_t py, const float &z)
static int8_t	cell_index_x (const float &x)
static int8_t	cell_index_y (const float &y)
static xy_int8_t	cell_indexes (const float &x, const float &y)
static xy_int8_t	cell_indexes (const xy_pos_t &xy)
static int8_t	closest_x_index (const float &x)
static int8_t	closest_y_index (const float &y)
static xy_int8_t	closest_indexes (const xy_pos_t &xy)
static FORCE_INLINE float	calc_z0 (const float &a0, const float &a1, const float &z1, const float &a2, const float &z2)
static float	z_correction_for_x_on_horizontal_mesh_line (const float &rx0, const int x1_i, const int yi)
static float	z_correction_for_y_on_vertical_mesh_line (const float &ry0, const int xi, const int y1_i)
static float	get_z_correction (const float &rx0, const float &ry0)
static float	get_z_correction (const xy_pos_t &pos)
static float	mesh_index_to_xpos (const uint8_t i)
static float	mesh_index_to_ypos (const uint8_t i)
static void	line_to_destination_cartesian (const feedRate_t &scaled_fr_mm_s, const uint8_t e)
static bool	mesh_is_valid ()

Static Public Attributes
static int8_t	storage_slot
static bed_mesh_t	z_values
static const float	_mesh_index_to_xpos [GRID_MAX_POINTS_X]
static const float	_mesh_index_to_ypos [GRID_MAX_POINTS_Y]
static volatile int	encoder_diff

Constructor & Destructor Documentation

unified_bed_leveling()

unified_bed_leveling::unified_bed_leveling

(

)

Member Function Documentation

echo_name()

static void unified_bed_leveling::echo_name ( )

static

report_current_mesh()

static void unified_bed_leveling::report_current_mesh ( )

static

report_state()

static void unified_bed_leveling::report_state ( )

static

save_ubl_active_state_and_disable()

static void unified_bed_leveling::save_ubl_active_state_and_disable ( )

static

restore_ubl_active_state_and_leave()

static void unified_bed_leveling::restore_ubl_active_state_and_leave ( )

static

display_map()

static void unified_bed_leveling::display_map ( const int  )

static

find_closest_mesh_point_of_type()

static mesh_index_pair unified_bed_leveling::find_closest_mesh_point_of_type ( const  MeshPointType, const xy_pos_t &  , const bool  = false, MeshFlags *  done_flags = nullptr  )

static

find_furthest_invalid_mesh_point()

static mesh_index_pair unified_bed_leveling::find_furthest_invalid_mesh_point ( )

static

reset()

static void unified_bed_leveling::reset ( )

static

invalidate()

static void unified_bed_leveling::invalidate ( )

static

set_all_mesh_points_to_value()

static void unified_bed_leveling::set_all_mesh_points_to_value ( const float  value )

static

adjust_mesh_to_mean()

static void unified_bed_leveling::adjust_mesh_to_mean ( const bool  cflag, const float  value  )

static

sanity_check()

static bool unified_bed_leveling::sanity_check ( )

static

G29()

static void unified_bed_leveling::G29 ( )

static

smart_fill_wlsf()

static void unified_bed_leveling::smart_fill_wlsf ( const float &  )

static

set_z()

static FORCE_INLINE void unified_bed_leveling::set_z ( const int8_t  px, const int8_t  py, const float &  z  )

static

{ z_values[px][py] = z; }

cell_index_x()

static int8_t unified_bed_leveling::cell_index_x ( const float &  x )

static

                                               {
      const int8_t cx = (x - (MESH_MIN_X)) * RECIPROCAL(MESH_X_DIST);
      return constrain(cx, 0, (GRID_MAX_POINTS_X) - 1);   // -1 is appropriate if we want all movement to the X_MAX
    }                                                     // position. But with this defined this way, it is possible

Here is the caller graph for this function:

cell_index_y()

static int8_t unified_bed_leveling::cell_index_y ( const float &  y )

static

                                               {
      const int8_t cy = (y - (MESH_MIN_Y)) * RECIPROCAL(MESH_Y_DIST);
      return constrain(cy, 0, (GRID_MAX_POINTS_Y) - 1);   // -1 is appropriate if we want all movement to the Y_MAX
    }                                                     // position. But with this defined this way, it is possible

Here is the caller graph for this function:

cell_indexes() [1/2]

static xy_int8_t unified_bed_leveling::cell_indexes ( const float &  x, const float &  y  )

static

                                                                         {
      return { cell_index_x(x), cell_index_y(y) };
    }

Here is the call graph for this function:

cell_indexes() [2/2]

static xy_int8_t unified_bed_leveling::cell_indexes ( const xy_pos_t &  xy )

static

{ return cell_indexes(xy.x, xy.y); }

Here is the call graph for this function:

Here is the caller graph for this function:

closest_x_index()

static int8_t unified_bed_leveling::closest_x_index ( const float &  x )

static

                                                  {
      const int8_t px = (x - (MESH_MIN_X) + (MESH_X_DIST) * 0.5) * RECIPROCAL(MESH_X_DIST);
      return WITHIN(px, 0, GRID_MAX_POINTS_X - 1) ? px : -1;
    }

Here is the caller graph for this function:

closest_y_index()

static int8_t unified_bed_leveling::closest_y_index ( const float &  y )

static

                                                  {
      const int8_t py = (y - (MESH_MIN_Y) + (MESH_Y_DIST) * 0.5) * RECIPROCAL(MESH_Y_DIST);
      return WITHIN(py, 0, GRID_MAX_POINTS_Y - 1) ? py : -1;
    }

Here is the caller graph for this function:

closest_indexes()

static xy_int8_t unified_bed_leveling::closest_indexes ( const xy_pos_t &  xy )

static

                                                                {
      return { closest_x_index(xy.x), closest_y_index(xy.y) };
    }

Here is the call graph for this function:

calc_z0()

static FORCE_INLINE float unified_bed_leveling::calc_z0 ( const float &  a0, const float &  a1, const float &  z1, const float &  a2, const float &  z2  )

static

                      z2   --|
            z0        |      |
             |        |      + (z2-z1)

z1 | | | —+----------—+-----—+– –| a1 a0 a2 |<—delta_a-------—>|

calc_z0 is the basis for all the Mesh Based correction. It is used to find the expected Z Height at a position between two known Z-Height locations.

It is fairly expensive with its 4 floating point additions and 2 floating point multiplications.

                                                                                                                           {
      return z1 + (z2 - z1) * (a0 - a1) / (a2 - a1);
    }

Here is the caller graph for this function:

z_correction_for_x_on_horizontal_mesh_line()

static float unified_bed_leveling::z_correction_for_x_on_horizontal_mesh_line ( const float &  rx0, const int  x1_i, const int  yi  )

static

z_correction_for_x_on_horizontal_mesh_line is an optimization for the case where the printer is making a vertical line that only crosses horizontal mesh lines.

                                                                                                                   {
      if (!WITHIN(x1_i, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(yi, 0, GRID_MAX_POINTS_Y - 1)) {
 
        if (DEBUGGING(LEVELING)) {
          if (WITHIN(x1_i, 0, GRID_MAX_POINTS_X - 1)) DEBUG_ECHOPGM("yi"); else DEBUG_ECHOPGM("x1_i");
          DEBUG_ECHOLNPAIR(" out of bounds in z_correction_for_x_on_horizontal_mesh_line(rx0=", rx0, ",x1_i=", x1_i, ",yi=", yi, ")");
        }
 
        // The requested location is off the mesh. Return UBL_Z_RAISE_WHEN_OFF_MESH or NAN.
        return (
          #ifdef UBL_Z_RAISE_WHEN_OFF_MESH
            UBL_Z_RAISE_WHEN_OFF_MESH
          #else
            NAN
          #endif
        );
      }
 
      const float xratio = (rx0 - mesh_index_to_xpos(x1_i)) * RECIPROCAL(MESH_X_DIST),
                  z1 = z_values[x1_i][yi];
 
      return z1 + xratio * (z_values[_MIN(x1_i, GRID_MAX_POINTS_X - 2) + 1][yi] - z1); // Don't allow x1_i+1 to be past the end of the array
                                                                                      // If it is, it is clamped to the last element of the
                                                                                      // z_values[][] array and no correction is applied.
    }

Here is the call graph for this function:

z_correction_for_y_on_vertical_mesh_line()

static float unified_bed_leveling::z_correction_for_y_on_vertical_mesh_line ( const float &  ry0, const int  xi, const int  y1_i  )

static

                                                                                                                 {
      if (!WITHIN(xi, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(y1_i, 0, GRID_MAX_POINTS_Y - 1)) {
 
        if (DEBUGGING(LEVELING)) {
          if (WITHIN(xi, 0, GRID_MAX_POINTS_X - 1)) DEBUG_ECHOPGM("y1_i"); else DEBUG_ECHOPGM("xi");
          DEBUG_ECHOLNPAIR(" out of bounds in z_correction_for_y_on_vertical_mesh_line(ry0=", ry0, ", xi=", xi, ", y1_i=", y1_i, ")");
        }
 
        // The requested location is off the mesh. Return UBL_Z_RAISE_WHEN_OFF_MESH or NAN.
        return (
          #ifdef UBL_Z_RAISE_WHEN_OFF_MESH
            UBL_Z_RAISE_WHEN_OFF_MESH
          #else
            NAN
          #endif
        );
      }
 
      const float yratio = (ry0 - mesh_index_to_ypos(y1_i)) * RECIPROCAL(MESH_Y_DIST),
                  z1 = z_values[xi][y1_i];
 
      return z1 + yratio * (z_values[xi][_MIN(y1_i, GRID_MAX_POINTS_Y - 2) + 1] - z1); // Don't allow y1_i+1 to be past the end of the array
                                                                                      // If it is, it is clamped to the last element of the
                                                                                      // z_values[][] array and no correction is applied.
    }

Here is the call graph for this function:

get_z_correction() [1/2]

static float unified_bed_leveling::get_z_correction ( const float &  rx0, const float &  ry0  )

static

This is the generic Z-Correction. It works anywhere within a Mesh Cell. It first does a linear interpolation along both of the bounding X-Mesh-Lines to find the Z-Height at both ends. Then it does a linear interpolation of these heights based on the Y position within the cell.

Check if the requested location is off the mesh. If so, and UBL_Z_RAISE_WHEN_OFF_MESH is specified, that value is returned.

                                                                      {
      const int8_t cx = cell_index_x(rx0), cy = cell_index_y(ry0); // return values are clamped
 
      /**
       * Check if the requested location is off the mesh.  If so, and
       * UBL_Z_RAISE_WHEN_OFF_MESH is specified, that value is returned.
       */
      #ifdef UBL_Z_RAISE_WHEN_OFF_MESH
        if (!WITHIN(rx0, MESH_MIN_X, MESH_MAX_X) || !WITHIN(ry0, MESH_MIN_Y, MESH_MAX_Y))
          return UBL_Z_RAISE_WHEN_OFF_MESH;
      #endif
 
      const float z1 = calc_z0(rx0,
                               mesh_index_to_xpos(cx), z_values[cx][cy],
                               mesh_index_to_xpos(cx + 1), z_values[_MIN(cx, GRID_MAX_POINTS_X - 2) + 1][cy]);
 
      const float z2 = calc_z0(rx0,
                               mesh_index_to_xpos(cx), z_values[cx][_MIN(cy, GRID_MAX_POINTS_Y - 2) + 1],
                               mesh_index_to_xpos(cx + 1), z_values[_MIN(cx, GRID_MAX_POINTS_X - 2) + 1][_MIN(cy, GRID_MAX_POINTS_Y - 2) + 1]);
 
      float z0 = calc_z0(ry0,
                         mesh_index_to_ypos(cy), z1,
                         mesh_index_to_ypos(cy + 1), z2);
 
      if (DEBUGGING(MESH_ADJUST)) {
        DEBUG_ECHOPAIR(" raw get_z_correction(", rx0);
        DEBUG_CHAR(','); DEBUG_ECHO(ry0);
        DEBUG_ECHOPAIR_F(") = ", z0, 6);
        DEBUG_ECHOLNPAIR_F(" >>>---> ", z0, 6);
      }
 
      if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN
        z0 = 0.0;      // in ubl.z_values[][] and propagate through the
                       // calculations. If our correction is NAN, we throw it out
                       // because part of the Mesh is undefined and we don't have the
                       // information we need to complete the height correction.
 
        if (DEBUGGING(MESH_ADJUST)) {
          DEBUG_ECHOPAIR("??? Yikes!  NAN in get_z_correction(", rx0);
          DEBUG_CHAR(',');
          DEBUG_ECHO(ry0);
          DEBUG_CHAR(')');
          DEBUG_EOL();
        }
      }
      return z0;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

get_z_correction() [2/2]

static float unified_bed_leveling::get_z_correction ( const xy_pos_t &  pos )

static

{ return get_z_correction(pos.x, pos.y); }

Here is the call graph for this function:

Here is the caller graph for this function:

mesh_index_to_xpos()

static float unified_bed_leveling::mesh_index_to_xpos ( const uint8_t  i )

static

                                                            {
      return i < GRID_MAX_POINTS_X ? pgm_read_float(&_mesh_index_to_xpos[i]) : MESH_MIN_X + i * (MESH_X_DIST);
    }

Here is the caller graph for this function:

mesh_index_to_ypos()

static float unified_bed_leveling::mesh_index_to_ypos ( const uint8_t  i )

static

                                                            {
      return i < GRID_MAX_POINTS_Y ? pgm_read_float(&_mesh_index_to_ypos[i]) : MESH_MIN_Y + i * (MESH_Y_DIST);
    }

Here is the caller graph for this function:

line_to_destination_cartesian()

static void unified_bed_leveling::line_to_destination_cartesian ( const feedRate_t &  scaled_fr_mm_s, const uint8_t  e  )

static

Here is the caller graph for this function:

mesh_is_valid()

static bool unified_bed_leveling::mesh_is_valid ( )

static

                                       {
      for (uint8_t x = 0; x < GRID_MAX_POINTS_X; x++)
        for (uint8_t y = 0; y < GRID_MAX_POINTS_Y; y++)
          if (isnan(z_values[x][y])) return false;
      return true;
    }

Member Data Documentation

storage_slot

int8_t unified_bed_leveling::storage_slot

static

z_values

bed_mesh_t unified_bed_leveling::z_values

static

_mesh_index_to_xpos

const float unified_bed_leveling::_mesh_index_to_xpos[GRID_MAX_POINTS_X]

static

_mesh_index_to_ypos

const float unified_bed_leveling::_mesh_index_to_ypos[GRID_MAX_POINTS_Y]

static

encoder_diff

volatile int unified_bed_leveling::encoder_diff

static