andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Make MBL a static class, use lookup for index-to-point conversion

pull/1/head
Scott Lahteine 8 years ago
parent
de9d2cddc3
commit
c9eb1d6ab7
4 changed files with 53 additions and 48 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      Marlin/Marlin_main.cpp
  2. 15
      Marlin/mesh_bed_leveling.cpp
  3. 76
      Marlin/mesh_bed_leveling.h
  4. 2
      Marlin/ultralcd.cpp

8
Marlin/Marlin_main.cpp
View File

@ -652,7 +652,7 @@ static bool send_ok[BUFSIZE];
#endif #endif
#if ENABLED(HOST_KEEPALIVE_FEATURE) #if ENABLED(HOST_KEEPALIVE_FEATURE)
static MarlinBusyState busy_state = NOT_BUSY; MarlinBusyState busy_state = NOT_BUSY;
static millis_t next_busy_signal_ms = 0; static millis_t next_busy_signal_ms = 0;
uint8_t host_keepalive_interval = DEFAULT_KEEPALIVE_INTERVAL; uint8_t host_keepalive_interval = DEFAULT_KEEPALIVE_INTERVAL;
#else #else
@ -3839,7 +3839,7 @@ inline void gcode_G28() {
// If there's another point to sample, move there with optional lift. // If there's another point to sample, move there with optional lift.
if (probe_index < (MESH_NUM_X_POINTS) * (MESH_NUM_Y_POINTS)) { if (probe_index < (MESH_NUM_X_POINTS) * (MESH_NUM_Y_POINTS)) {
mbl.zigzag(probe_index, px, py); mbl.zigzag(probe_index, px, py);
_mbl_goto_xy(mbl.get_probe_x(px), mbl.get_probe_y(py)); _mbl_goto_xy(mbl.index_to_xpos[px], mbl.index_to_ypos[py]);
#if HAS_SOFTWARE_ENDSTOPS #if HAS_SOFTWARE_ENDSTOPS
// Disable software endstops to allow manual adjustment // Disable software endstops to allow manual adjustment
@ -9649,14 +9649,14 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) {
const int8_t gcx = max(cx1, cx2), gcy = max(cy1, cy2); const int8_t gcx = max(cx1, cx2), gcy = max(cy1, cy2);
if (cx2 != cx1 && TEST(x_splits, gcx)) { if (cx2 != cx1 && TEST(x_splits, gcx)) {
COPY(end, destination); COPY(end, destination);
destination[X_AXIS] = LOGICAL_X_POSITION(mbl.get_probe_x(gcx)); destination[X_AXIS] = LOGICAL_X_POSITION(mbl.index_to_xpos[gcx]);
normalized_dist = (destination[X_AXIS] - current_position[X_AXIS]) / (end[X_AXIS] - current_position[X_AXIS]); normalized_dist = (destination[X_AXIS] - current_position[X_AXIS]) / (end[X_AXIS] - current_position[X_AXIS]);
destination[Y_AXIS] = MBL_SEGMENT_END(Y); destination[Y_AXIS] = MBL_SEGMENT_END(Y);
CBI(x_splits, gcx); CBI(x_splits, gcx);
} }
else if (cy2 != cy1 && TEST(y_splits, gcy)) { else if (cy2 != cy1 && TEST(y_splits, gcy)) {
COPY(end, destination); COPY(end, destination);
destination[Y_AXIS] = LOGICAL_Y_POSITION(mbl.get_probe_y(gcy)); destination[Y_AXIS] = LOGICAL_Y_POSITION(mbl.index_to_ypos[gcy]);
normalized_dist = (destination[Y_AXIS] - current_position[Y_AXIS]) / (end[Y_AXIS] - current_position[Y_AXIS]); normalized_dist = (destination[Y_AXIS] - current_position[Y_AXIS]) / (end[Y_AXIS] - current_position[Y_AXIS]);
destination[X_AXIS] = MBL_SEGMENT_END(X); destination[X_AXIS] = MBL_SEGMENT_END(X);
CBI(y_splits, gcy); CBI(y_splits, gcy);

15
Marlin/mesh_bed_leveling.cpp
View File

@ -26,7 +26,20 @@
mesh_bed_leveling mbl; mesh_bed_leveling mbl;
mesh_bed_leveling::mesh_bed_leveling() { reset(); } uint8_t mesh_bed_leveling::status;
float mesh_bed_leveling::z_offset,
mesh_bed_leveling::z_values[MESH_NUM_Y_POINTS][MESH_NUM_X_POINTS],
mesh_bed_leveling::index_to_xpos[MESH_NUM_X_POINTS],
mesh_bed_leveling::index_to_ypos[MESH_NUM_Y_POINTS];
mesh_bed_leveling::mesh_bed_leveling() {
for (uint8_t i = 0; i < MESH_NUM_X_POINTS; ++i)
index_to_xpos[i] = MESH_MIN_X + i * (MESH_X_DIST);
for (uint8_t i = 0; i < MESH_NUM_Y_POINTS; ++i)
index_to_ypos[i] = MESH_MIN_Y + i * (MESH_Y_DIST);
reset();
}
void mesh_bed_leveling::reset() { void mesh_bed_leveling::reset() {
status = MBL_STATUS_NONE; status = MBL_STATUS_NONE;

76
Marlin/mesh_bed_leveling.h
View File

@ -40,91 +40,83 @@
MBL_STATUS_REACTIVATE_BIT = 2 MBL_STATUS_REACTIVATE_BIT = 2
}; };
#define MESH_X_DIST ((MESH_MAX_X - (MESH_MIN_X))/(MESH_NUM_X_POINTS - 1)) #define MESH_X_DIST ((MESH_MAX_X - (MESH_MIN_X)) / (MESH_NUM_X_POINTS - 1))
#define MESH_Y_DIST ((MESH_MAX_Y - (MESH_MIN_Y))/(MESH_NUM_Y_POINTS - 1)) #define MESH_Y_DIST ((MESH_MAX_Y - (MESH_MIN_Y)) / (MESH_NUM_Y_POINTS - 1))
class mesh_bed_leveling { class mesh_bed_leveling {
public: public:
uint8_t status; // Has Mesh and Is Active bits static uint8_t status; // Has Mesh and Is Active bits
float z_offset; static float z_offset,
float z_values[MESH_NUM_Y_POINTS][MESH_NUM_X_POINTS]; z_values[MESH_NUM_Y_POINTS][MESH_NUM_X_POINTS],
index_to_xpos[MESH_NUM_X_POINTS],
index_to_ypos[MESH_NUM_Y_POINTS];
mesh_bed_leveling(); mesh_bed_leveling();
void reset(); static void reset();
static FORCE_INLINE float get_probe_x(const int8_t i) { return MESH_MIN_X + (MESH_X_DIST) * i; } static void set_z(const int8_t px, const int8_t py, const float &z) { z_values[py][px] = z; }
static FORCE_INLINE float get_probe_y(const int8_t i) { return MESH_MIN_Y + (MESH_Y_DIST) * i; }
void set_z(const int8_t px, const int8_t py, const float &z) { z_values[py][px] = z; }
bool active() const { return TEST(status, MBL_STATUS_ACTIVE_BIT); } static bool active() { return TEST(status, MBL_STATUS_ACTIVE_BIT); }
void set_active(const bool onOff) { onOff ? SBI(status, MBL_STATUS_ACTIVE_BIT) : CBI(status, MBL_STATUS_ACTIVE_BIT); } static void set_active(const bool onOff) { onOff ? SBI(status, MBL_STATUS_ACTIVE_BIT) : CBI(status, MBL_STATUS_ACTIVE_BIT); }
bool has_mesh() const { return TEST(status, MBL_STATUS_HAS_MESH_BIT); } static bool has_mesh() { return TEST(status, MBL_STATUS_HAS_MESH_BIT); }
void set_has_mesh(const bool onOff) { onOff ? SBI(status, MBL_STATUS_HAS_MESH_BIT) : CBI(status, MBL_STATUS_HAS_MESH_BIT); } static void set_has_mesh(const bool onOff) { onOff ? SBI(status, MBL_STATUS_HAS_MESH_BIT) : CBI(status, MBL_STATUS_HAS_MESH_BIT); }
bool reactivate() { bool b = TEST(status, MBL_STATUS_REACTIVATE_BIT); CBI(status, MBL_STATUS_REACTIVATE_BIT); return b; } static bool reactivate() { bool b = TEST(status, MBL_STATUS_REACTIVATE_BIT); CBI(status, MBL_STATUS_REACTIVATE_BIT); return b; }
void set_reactivate(const bool onOff) { onOff ? SBI(status, MBL_STATUS_REACTIVATE_BIT) : CBI(status, MBL_STATUS_REACTIVATE_BIT); } static void set_reactivate(const bool onOff) { onOff ? SBI(status, MBL_STATUS_REACTIVATE_BIT) : CBI(status, MBL_STATUS_REACTIVATE_BIT); }
inline void zigzag(const int8_t index, int8_t &px, int8_t &py) const { static inline void zigzag(const int8_t index, int8_t &px, int8_t &py) {
px = index % (MESH_NUM_X_POINTS); px = index % (MESH_NUM_X_POINTS);
py = index / (MESH_NUM_X_POINTS); py = index / (MESH_NUM_X_POINTS);
if (py & 1) px = (MESH_NUM_X_POINTS - 1) - px; // Zig zag if (py & 1) px = (MESH_NUM_X_POINTS - 1) - px; // Zig zag
} }
void set_zigzag_z(const int8_t index, const float &z) { static void set_zigzag_z(const int8_t index, const float &z) {
int8_t px, py; int8_t px, py;
zigzag(index, px, py); zigzag(index, px, py);
set_z(px, py, z); set_z(px, py, z);
} }
int8_t cell_index_x(const float &x) const { static int8_t cell_index_x(const float &x) {
int8_t cx = (x - (MESH_MIN_X)) * (1.0 / (MESH_X_DIST)); int8_t cx = (x - (MESH_MIN_X)) * (1.0 / (MESH_X_DIST));
return constrain(cx, 0, (MESH_NUM_X_POINTS) - 2); return constrain(cx, 0, (MESH_NUM_X_POINTS) - 2);
} }
int8_t cell_index_y(const float &y) const { static int8_t cell_index_y(const float &y) {
int8_t cy = (y - (MESH_MIN_Y)) * (1.0 / (MESH_Y_DIST)); int8_t cy = (y - (MESH_MIN_Y)) * (1.0 / (MESH_Y_DIST));
return constrain(cy, 0, (MESH_NUM_Y_POINTS) - 2); return constrain(cy, 0, (MESH_NUM_Y_POINTS) - 2);
} }
int8_t probe_index_x(const float &x) const { static int8_t probe_index_x(const float &x) {
int8_t px = (x - (MESH_MIN_X) + 0.5 * (MESH_X_DIST)) * (1.0 / (MESH_X_DIST)); int8_t px = (x - (MESH_MIN_X) + 0.5 * (MESH_X_DIST)) * (1.0 / (MESH_X_DIST));
return (px >= 0 && px < (MESH_NUM_X_POINTS)) ? px : -1; return (px >= 0 && px < (MESH_NUM_X_POINTS)) ? px : -1;
} }
int8_t probe_index_y(const float &y) const { static int8_t probe_index_y(const float &y) {
int8_t py = (y - (MESH_MIN_Y) + 0.5 * (MESH_Y_DIST)) * (1.0 / (MESH_Y_DIST)); int8_t py = (y - (MESH_MIN_Y) + 0.5 * (MESH_Y_DIST)) * (1.0 / (MESH_Y_DIST));
return (py >= 0 && py < (MESH_NUM_Y_POINTS)) ? py : -1; return (py >= 0 && py < (MESH_NUM_Y_POINTS)) ? py : -1;
} }
float calc_z0(const float &a0, const float &a1, const float &z1, const float &a2, const float &z2) const { static float calc_z0(const float &a0, const float &a1, const float &z1, const float &a2, const float &z2) {
const float delta_z = (z2 - z1) / (a2 - a1); const float delta_z = (z2 - z1) / (a2 - a1);
const float delta_a = a0 - a1; const float delta_a = a0 - a1;
return z1 + delta_a * delta_z; return z1 + delta_a * delta_z;
} }
float get_z(const float &x0, const float &y0 static float get_z(const float &x0, const float &y0
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
, const float &factor , const float &factor
#endif #endif
) const { ) {
int8_t cx = cell_index_x(x0), const int8_t cx = cell_index_x(x0), cy = cell_index_y(y0);
cy = cell_index_y(y0); const float z1 = calc_z0(x0, index_to_xpos[cx], z_values[cy][cx], index_to_xpos[cx + 1], z_values[cy][cx + 1]),
if (cx < 0 || cy < 0) return z_offset; z2 = calc_z0(x0, index_to_xpos[cx], z_values[cy + 1][cx], index_to_xpos[cx + 1], z_values[cy + 1][cx + 1]),
float z1 = calc_z0(x0, z0 = calc_z0(y0, index_to_ypos[cy], z1, index_to_ypos[cy + 1], z2);
get_probe_x(cx), z_values[cy][cx],
get_probe_x(cx + 1), z_values[cy][cx + 1]); return z_offset + z0
float z2 = calc_z0(x0, #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
get_probe_x(cx), z_values[cy + 1][cx], * factor
get_probe_x(cx + 1), z_values[cy + 1][cx + 1]); #endif
float z0 = calc_z0(y0, ;
get_probe_y(cy), z1,
get_probe_y(cy + 1), z2);
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
return z0 * factor + z_offset;
#else
return z0 + z_offset;
#endif
} }
}; };

2
Marlin/ultralcd.cpp
View File

@ -1437,7 +1437,7 @@ KeepDrawing:
// _manual_probe_xy runs the menu loop until the move is done // _manual_probe_xy runs the menu loop until the move is done
int8_t px, py; int8_t px, py;
mbl.zigzag(manual_probe_index, px, py); mbl.zigzag(manual_probe_index, px, py);
_manual_probe_xy(mbl.get_probe_x(px), mbl.get_probe_y(py)); _manual_probe_xy(mbl.index_to_xpos[px], mbl.index_to_ypos[py]);
// After the blocking function returns, change menus // After the blocking function returns, change menus
lcd_goto_screen(_lcd_level_bed_get_z); lcd_goto_screen(_lcd_level_bed_get_z);

Write Preview
Loading…
Cancel
Save