mesh_bed_leveling Class Reference

#include <mesh_bed_leveling.h>

Collaboration diagram for mesh_bed_leveling:

Public Member Functions
	mesh_bed_leveling ()

Static Public Member Functions
static void	report_mesh ()
static void	reset ()
static FORCE_INLINE bool	has_mesh ()
static void	set_z (const int8_t px, const int8_t py, const float &z)
static void	zigzag (const int8_t index, int8_t &px, int8_t &py)
static void	set_zigzag_z (const int8_t index, 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	probe_index_x (const float &x)
static int8_t	probe_index_y (const float &y)
static xy_int8_t	probe_indexes (const float &x, const float &y)
static xy_int8_t	probe_indexes (const xy_pos_t &xy)
static float	calc_z0 (const float &a0, const float &a1, const float &z1, const float &a2, const float &z2)
static float	get_z (const xy_pos_t &pos)
static void	line_to_destination (const feedRate_t &scaled_fr_mm_s, uint8_t x_splits=0xFF, uint8_t y_splits=0xFF)

Static Public Attributes
static float	z_offset
static float	z_values [GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y]
static float	index_to_xpos [GRID_MAX_POINTS_X]
static float	index_to_ypos [GRID_MAX_POINTS_Y]

Constructor & Destructor Documentation

mesh_bed_leveling()

mesh_bed_leveling::mesh_bed_leveling

(

)

Member Function Documentation

report_mesh()

static void mesh_bed_leveling::report_mesh ( )

static

reset()

static void mesh_bed_leveling::reset ( )

static

has_mesh()

static FORCE_INLINE bool mesh_bed_leveling::has_mesh ( )

static

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

set_z()

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

static

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

Here is the caller graph for this function:

zigzag()

static void mesh_bed_leveling::zigzag ( const int8_t  index, int8_t &  px, int8_t &  py  )

static

                                                                        {
    px = index % (GRID_MAX_POINTS_X);
    py = index / (GRID_MAX_POINTS_X);
    if (py & 1) px = (GRID_MAX_POINTS_X - 1) - px; // Zig zag
  }

Here is the caller graph for this function:

set_zigzag_z()

static void mesh_bed_leveling::set_zigzag_z ( const int8_t  index, const float &  z  )

static

                                                               {
    int8_t px, py;
    zigzag(index, px, py);
    set_z(px, py, z);
  }

Here is the call graph for this function:

cell_index_x()

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

static

                                             {
    int8_t cx = (x - (MESH_MIN_X)) * RECIPROCAL(MESH_X_DIST);
    return constrain(cx, 0, (GRID_MAX_POINTS_X) - 2);
  }

Here is the caller graph for this function:

cell_index_y()

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

static

                                             {
    int8_t cy = (y - (MESH_MIN_Y)) * RECIPROCAL(MESH_Y_DIST);
    return constrain(cy, 0, (GRID_MAX_POINTS_Y) - 2);
  }

Here is the caller graph for this function:

cell_indexes() [1/2]

static xy_int8_t mesh_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:

Here is the caller graph for this function:

cell_indexes() [2/2]

static xy_int8_t mesh_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:

probe_index_x()

static int8_t mesh_bed_leveling::probe_index_x ( const float &  x )

static

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

Here is the caller graph for this function:

probe_index_y()

static int8_t mesh_bed_leveling::probe_index_y ( const float &  y )

static

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

Here is the caller graph for this function:

probe_indexes() [1/2]

static xy_int8_t mesh_bed_leveling::probe_indexes ( const float &  x, const float &  y  )

static

                                                                        {
    return { probe_index_x(x), probe_index_y(y) };
  }

Here is the call graph for this function:

probe_indexes() [2/2]

static xy_int8_t mesh_bed_leveling::probe_indexes ( const xy_pos_t &  xy )

static

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

Here is the call graph for this function:

Here is the caller graph for this function:

calc_z0()

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

static

                                                                                                            {
    const float delta_z = (z2 - z1) / (a2 - a1),
                delta_a = a0 - a1;
    return z1 + delta_a * delta_z;
  }

Here is the caller graph for this function:

get_z()

static float mesh_bed_leveling::get_z ( const xy_pos_t &  pos )

static

    {
    #if DISABLED(ENABLE_LEVELING_FADE_HEIGHT)
      constexpr float factor = 1.0f;
    #endif
    const xy_int8_t ind = cell_indexes(pos);
    const float x1 = index_to_xpos[ind.x], x2 = index_to_xpos[ind.x+1],
                y1 = index_to_xpos[ind.y], y2 = index_to_xpos[ind.y+1],
                z1 = calc_z0(pos.x, x1, z_values[ind.x][ind.y  ], x2, z_values[ind.x+1][ind.y  ]),
                z2 = calc_z0(pos.x, x1, z_values[ind.x][ind.y+1], x2, z_values[ind.x+1][ind.y+1]);
 
    return z_offset + calc_z0(pos.y, y1, z1, y2, z2) * factor;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

line_to_destination()

static void mesh_bed_leveling::line_to_destination ( const feedRate_t &  scaled_fr_mm_s, uint8_t  x_splits = 0xFF, uint8_t  y_splits = 0xFF  )

static

Here is the caller graph for this function:

Member Data Documentation

z_offset

float mesh_bed_leveling::z_offset

static

z_values

float mesh_bed_leveling::z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y]

static

index_to_xpos

float mesh_bed_leveling::index_to_xpos[GRID_MAX_POINTS_X]

static

index_to_ypos

float mesh_bed_leveling::index_to_ypos[GRID_MAX_POINTS_Y]

static