Merge pull request #1607 from PavelSindler/7x7
7x7 mbl and switching mmu modes
This commit is contained in:
commit
c05561d6b1
18 changed files with 637 additions and 120 deletions
1
.gitignore
vendored
1
.gitignore
vendored
|
@ -50,3 +50,4 @@ Firmware/Doc
|
|||
/lang/textaddr.txt
|
||||
/build-env/
|
||||
/Firmware/Firmware.vcxproj
|
||||
/Firmware/Configuration_prusa_bckp.h
|
||||
|
|
|
@ -446,7 +446,9 @@ your extruder heater takes 2 minutes to hit the target on heating.
|
|||
// When enabled Marlin will send a busy status message to the host
|
||||
// every couple of seconds when it can't accept commands.
|
||||
//
|
||||
#ifndef HEATBED_ANALYSIS
|
||||
#define HOST_KEEPALIVE_FEATURE // Disable this if your host doesn't like keepalive messages
|
||||
#endif //HEATBED_ANALYSIS
|
||||
#define HOST_KEEPALIVE_INTERVAL 2 // Number of seconds between "busy" messages. Set with M113.
|
||||
|
||||
//LCD and SD support
|
||||
|
|
|
@ -21,6 +21,7 @@
|
|||
#include "Configuration.h"
|
||||
#include "pins.h"
|
||||
#include "Timer.h"
|
||||
extern int mbl_z_probe_nr;
|
||||
|
||||
#ifndef AT90USB
|
||||
#define HardwareSerial_h // trick to disable the standard HWserial
|
||||
|
@ -316,9 +317,9 @@ extern float retract_length_swap;
|
|||
extern float retract_recover_length_swap;
|
||||
#endif
|
||||
|
||||
#ifdef HOST_KEEPALIVE_FEATURE
|
||||
|
||||
extern uint8_t host_keepalive_interval;
|
||||
#endif
|
||||
|
||||
|
||||
extern unsigned long starttime;
|
||||
extern unsigned long stoptime;
|
||||
|
@ -402,13 +403,12 @@ extern void check_babystep();
|
|||
extern void long_pause();
|
||||
extern void crashdet_stop_and_save_print();
|
||||
|
||||
#ifdef DIS
|
||||
|
||||
#ifdef HEATBED_ANALYSIS
|
||||
void d_setup();
|
||||
float d_ReadData();
|
||||
void bed_analysis(float x_dimension, float y_dimension, int x_points_num, int y_points_num, float shift_x, float shift_y);
|
||||
|
||||
#endif
|
||||
void bed_check(float x_dimension, float y_dimension, int x_points_num, int y_points_num, float shift_x, float shift_y);
|
||||
#endif //HEATBED_ANALYSIS
|
||||
float temp_comp_interpolation(float temperature);
|
||||
void temp_compensation_apply();
|
||||
void temp_compensation_start();
|
||||
|
@ -448,7 +448,7 @@ extern void restore_print_from_ram_and_continue(float e_move);
|
|||
extern uint16_t print_time_remaining();
|
||||
extern uint8_t calc_percent_done();
|
||||
|
||||
#ifdef HOST_KEEPALIVE_FEATURE
|
||||
|
||||
|
||||
// States for managing Marlin and host communication
|
||||
// Marlin sends messages if blocked or busy
|
||||
|
@ -471,7 +471,6 @@ extern void host_keepalive();
|
|||
//extern MarlinBusyState busy_state;
|
||||
extern int busy_state;
|
||||
|
||||
#endif //HOST_KEEPALIVE_FEATURE
|
||||
|
||||
#ifdef TMC2130
|
||||
|
||||
|
|
|
@ -167,6 +167,7 @@ CardReader card;
|
|||
unsigned long PingTime = _millis();
|
||||
unsigned long NcTime;
|
||||
|
||||
int mbl_z_probe_nr = 3; //numer of Z measurements for each point in mesh bed leveling calibration
|
||||
|
||||
//used for PINDA temp calibration and pause print
|
||||
#define DEFAULT_RETRACTION 1
|
||||
|
@ -302,16 +303,9 @@ int fanSpeed=0;
|
|||
|
||||
bool cancel_heatup = false ;
|
||||
|
||||
#ifdef HOST_KEEPALIVE_FEATURE
|
||||
|
||||
int busy_state = NOT_BUSY;
|
||||
static long prev_busy_signal_ms = -1;
|
||||
uint8_t host_keepalive_interval = HOST_KEEPALIVE_INTERVAL;
|
||||
#else
|
||||
#define host_keepalive();
|
||||
#define KEEPALIVE_STATE(n);
|
||||
#endif
|
||||
|
||||
int busy_state = NOT_BUSY;
|
||||
static long prev_busy_signal_ms = -1;
|
||||
uint8_t host_keepalive_interval = HOST_KEEPALIVE_INTERVAL;
|
||||
|
||||
const char errormagic[] PROGMEM = "Error:";
|
||||
const char echomagic[] PROGMEM = "echo:";
|
||||
|
@ -1472,7 +1466,13 @@ void setup()
|
|||
if (eeprom_read_byte((uint8_t*)EEPROM_SD_SORT) == 255) {
|
||||
eeprom_write_byte((uint8_t*)EEPROM_SD_SORT, 0);
|
||||
}
|
||||
|
||||
//mbl_mode_init();
|
||||
mbl_settings_init();
|
||||
SilentModeMenu_MMU = eeprom_read_byte((uint8_t*)EEPROM_MMU_STEALTH);
|
||||
if (SilentModeMenu_MMU == 255) {
|
||||
SilentModeMenu_MMU = 1;
|
||||
eeprom_write_byte((uint8_t*)EEPROM_MMU_STEALTH, SilentModeMenu_MMU);
|
||||
}
|
||||
check_babystep(); //checking if Z babystep is in allowed range
|
||||
|
||||
#ifdef UVLO_SUPPORT
|
||||
|
@ -1697,12 +1697,14 @@ void serial_read_stream() {
|
|||
}
|
||||
}
|
||||
|
||||
#ifdef HOST_KEEPALIVE_FEATURE
|
||||
/**
|
||||
* Output a "busy" message at regular intervals
|
||||
* while the machine is not accepting commands.
|
||||
*/
|
||||
void host_keepalive() {
|
||||
#ifndef HOST_KEEPALIVE_FEATURE
|
||||
return;
|
||||
#endif //HOST_KEEPALIVE_FEATURE
|
||||
if (farm_mode) return;
|
||||
long ms = _millis();
|
||||
if (host_keepalive_interval && busy_state != NOT_BUSY) {
|
||||
|
@ -1727,7 +1729,7 @@ void host_keepalive() {
|
|||
}
|
||||
prev_busy_signal_ms = ms;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
// The loop() function is called in an endless loop by the Arduino framework from the default main() routine.
|
||||
// Before loop(), the setup() function is called by the main() routine.
|
||||
|
@ -4315,44 +4317,7 @@ if((eSoundMode==e_SOUND_MODE_LOUD)||(eSoundMode==e_SOUND_MODE_ONCE))
|
|||
}
|
||||
break;
|
||||
|
||||
#ifdef DIS
|
||||
case 77:
|
||||
{
|
||||
//! G77 X200 Y150 XP100 YP15 XO10 Y015
|
||||
//! for 9 point mesh bed leveling G77 X203 Y196 XP3 YP3 XO0 YO0
|
||||
//! G77 X232 Y218 XP116 YP109 XO-11 YO0
|
||||
|
||||
float dimension_x = 40;
|
||||
float dimension_y = 40;
|
||||
int points_x = 40;
|
||||
int points_y = 40;
|
||||
float offset_x = 74;
|
||||
float offset_y = 33;
|
||||
|
||||
if (code_seen('X')) dimension_x = code_value();
|
||||
if (code_seen('Y')) dimension_y = code_value();
|
||||
if (code_seen("XP")) { strchr_pointer+=1; points_x = code_value(); }
|
||||
if (code_seen("YP")) { strchr_pointer+=1; points_y = code_value(); }
|
||||
if (code_seen("XO")) { strchr_pointer+=1; offset_x = code_value(); }
|
||||
if (code_seen("YO")) { strchr_pointer+=1; offset_y = code_value(); }
|
||||
|
||||
bed_analysis(dimension_x,dimension_y,points_x,points_y,offset_x,offset_y);
|
||||
|
||||
} break;
|
||||
|
||||
#endif
|
||||
|
||||
case 79: {
|
||||
for (int i = 255; i > 0; i = i - 5) {
|
||||
fanSpeed = i;
|
||||
//delay_keep_alive(2000);
|
||||
for (int j = 0; j < 100; j++) {
|
||||
delay_keep_alive(100);
|
||||
|
||||
}
|
||||
printf_P(_N("%d: %d\n"), i, fan_speed[1]);
|
||||
}
|
||||
}break;
|
||||
|
||||
/**
|
||||
* G80: Mesh-based Z probe, probes a grid and produces a
|
||||
|
@ -4368,6 +4333,7 @@ if((eSoundMode==e_SOUND_MODE_LOUD)||(eSoundMode==e_SOUND_MODE_ONCE))
|
|||
*/
|
||||
|
||||
case 80:
|
||||
|
||||
#ifdef MK1BP
|
||||
break;
|
||||
#endif //MK1BP
|
||||
|
@ -4406,14 +4372,21 @@ if((eSoundMode==e_SOUND_MODE_LOUD)||(eSoundMode==e_SOUND_MODE_ONCE))
|
|||
nMeasPoints = 3;
|
||||
}
|
||||
}
|
||||
else {
|
||||
nMeasPoints = eeprom_read_byte((uint8_t*)EEPROM_MBL_POINTS_NR);
|
||||
}
|
||||
|
||||
uint8_t nProbeRetry = 3;
|
||||
if (code_seen('R')) {
|
||||
nProbeRetry = code_value_uint8();
|
||||
if (nProbeRetry > 10) {
|
||||
nProbeRetry = 3;
|
||||
nProbeRetry = 10;
|
||||
}
|
||||
}
|
||||
else {
|
||||
nProbeRetry = eeprom_read_byte((uint8_t*)EEPROM_MBL_PROBE_NR);
|
||||
}
|
||||
bool magnet_elimination = (eeprom_read_byte((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION) > 0);
|
||||
|
||||
bool temp_comp_start = true;
|
||||
#ifdef PINDA_THERMISTOR
|
||||
|
@ -4474,7 +4447,7 @@ if((eSoundMode==e_SOUND_MODE_LOUD)||(eSoundMode==e_SOUND_MODE_ONCE))
|
|||
|
||||
int XY_AXIS_FEEDRATE = homing_feedrate[X_AXIS] / 20;
|
||||
int Z_LIFT_FEEDRATE = homing_feedrate[Z_AXIS] / 40;
|
||||
bool has_z = (nMeasPoints == 3) && is_bed_z_jitter_data_valid(); //checks if we have data from Z calibration (offsets of the Z heiths of the 8 calibration points from the first point)
|
||||
bool has_z = is_bed_z_jitter_data_valid(); //checks if we have data from Z calibration (offsets of the Z heiths of the 8 calibration points from the first point)
|
||||
#ifdef SUPPORT_VERBOSITY
|
||||
if (verbosity_level >= 1) {
|
||||
has_z ? SERIAL_PROTOCOLPGM("Z jitter data from Z cal. valid.\n") : SERIAL_PROTOCOLPGM("Z jitter data from Z cal. not valid.\n");
|
||||
|
@ -4486,27 +4459,37 @@ if((eSoundMode==e_SOUND_MODE_LOUD)||(eSoundMode==e_SOUND_MODE_ONCE))
|
|||
// Get coords of a measuring point.
|
||||
uint8_t ix = mesh_point % nMeasPoints; // from 0 to MESH_NUM_X_POINTS - 1
|
||||
uint8_t iy = mesh_point / nMeasPoints;
|
||||
/*if (!mbl_point_measurement_valid(ix, iy, nMeasPoints, true)) {
|
||||
printf_P(PSTR("Skipping point [%d;%d] \n"), ix, iy);
|
||||
custom_message_state--;
|
||||
mesh_point++;
|
||||
continue; //skip
|
||||
}*/
|
||||
if (iy & 1) ix = (nMeasPoints - 1) - ix; // Zig zag
|
||||
if (nMeasPoints == 7) //if we have 7x7 mesh, compare with Z-calibration for points which are in 3x3 mesh
|
||||
{
|
||||
has_z = ((ix % 3 == 0) && (iy % 3 == 0)) && is_bed_z_jitter_data_valid();
|
||||
}
|
||||
float z0 = 0.f;
|
||||
if (has_z && (mesh_point > 0)) {
|
||||
uint16_t z_offset_u = eeprom_read_word((uint16_t*)(EEPROM_BED_CALIBRATION_Z_JITTER + 2 * (ix + iy * 3 - 1)));
|
||||
uint16_t z_offset_u = 0;
|
||||
if (nMeasPoints == 7) {
|
||||
z_offset_u = eeprom_read_word((uint16_t*)(EEPROM_BED_CALIBRATION_Z_JITTER + 2 * ((ix/3) + iy - 1)));
|
||||
}
|
||||
else {
|
||||
z_offset_u = eeprom_read_word((uint16_t*)(EEPROM_BED_CALIBRATION_Z_JITTER + 2 * (ix + iy * 3 - 1)));
|
||||
}
|
||||
z0 = mbl.z_values[0][0] + *reinterpret_cast<int16_t*>(&z_offset_u) * 0.01;
|
||||
//#if 0
|
||||
#ifdef SUPPORT_VERBOSITY
|
||||
if (verbosity_level >= 1) {
|
||||
SERIAL_ECHOLNPGM("");
|
||||
SERIAL_ECHOPGM("Bed leveling, point: ");
|
||||
MYSERIAL.print(mesh_point);
|
||||
SERIAL_ECHOPGM(", calibration z: ");
|
||||
MYSERIAL.print(z0, 5);
|
||||
SERIAL_ECHOLNPGM("");
|
||||
printf_P(PSTR("Bed leveling, point: %d, calibration Z stored in eeprom: %d, calibration z: %f \n"), mesh_point, z_offset_u, z0);
|
||||
}
|
||||
#endif // SUPPORT_VERBOSITY
|
||||
//#endif
|
||||
}
|
||||
|
||||
// Move Z up to MESH_HOME_Z_SEARCH.
|
||||
current_position[Z_AXIS] = MESH_HOME_Z_SEARCH;
|
||||
if((ix == 0) && (iy == 0)) current_position[Z_AXIS] = MESH_HOME_Z_SEARCH;
|
||||
else current_position[Z_AXIS] += 2.f / nMeasPoints; //use relative movement from Z coordinate where PINDa triggered on previous point. This makes calibration faster.
|
||||
plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], Z_LIFT_FEEDRATE, active_extruder);
|
||||
st_synchronize();
|
||||
|
||||
|
@ -4514,7 +4497,7 @@ if((eSoundMode==e_SOUND_MODE_LOUD)||(eSoundMode==e_SOUND_MODE_ONCE))
|
|||
current_position[X_AXIS] = BED_X(ix, nMeasPoints);
|
||||
current_position[Y_AXIS] = BED_Y(iy, nMeasPoints);
|
||||
|
||||
|
||||
//printf_P(PSTR("[%f;%f]\n"), current_position[X_AXIS], current_position[Y_AXIS]);
|
||||
|
||||
world2machine_clamp(current_position[X_AXIS], current_position[Y_AXIS]);
|
||||
#ifdef SUPPORT_VERBOSITY
|
||||
|
@ -4531,15 +4514,26 @@ if((eSoundMode==e_SOUND_MODE_LOUD)||(eSoundMode==e_SOUND_MODE_ONCE))
|
|||
// Go down until endstop is hit
|
||||
const float Z_CALIBRATION_THRESHOLD = 1.f;
|
||||
if (!find_bed_induction_sensor_point_z((has_z && mesh_point > 0) ? z0 - Z_CALIBRATION_THRESHOLD : -10.f, nProbeRetry)) { //if we have data from z calibration max allowed difference is 1mm for each point, if we dont have data max difference is 10mm from initial point
|
||||
kill_message = _T(MSG_BED_LEVELING_FAILED_POINT_LOW);
|
||||
printf_P(_T(MSG_BED_LEVELING_FAILED_POINT_LOW));
|
||||
break;
|
||||
}
|
||||
if (MESH_HOME_Z_SEARCH - current_position[Z_AXIS] < 0.1f) {
|
||||
kill_message = _i("Bed leveling failed. Sensor disconnected or cable broken. Waiting for reset.");////MSG_BED_LEVELING_FAILED_PROBE_DISCONNECTED c=20 r=4
|
||||
break;
|
||||
if (MESH_HOME_Z_SEARCH - current_position[Z_AXIS] < 0.1f) { //broken cable or initial Z coordinate too low. Go to MESH_HOME_Z_SEARCH and repeat last step (z-probe) again to distinguish between these two cases.
|
||||
|
||||
current_position[Z_AXIS] = MESH_HOME_Z_SEARCH;
|
||||
plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], Z_LIFT_FEEDRATE, active_extruder);
|
||||
st_synchronize();
|
||||
|
||||
if (!find_bed_induction_sensor_point_z((has_z && mesh_point > 0) ? z0 - Z_CALIBRATION_THRESHOLD : -10.f, nProbeRetry)) { //if we have data from z calibration max allowed difference is 1mm for each point, if we dont have data max difference is 10mm from initial point
|
||||
printf_P(_T(MSG_BED_LEVELING_FAILED_POINT_LOW));
|
||||
break;
|
||||
}
|
||||
if (MESH_HOME_Z_SEARCH - current_position[Z_AXIS] < 0.1f) {
|
||||
printf_P(PSTR("Bed leveling failed. Sensor disconnected or cable broken. Waiting for reset.\n"));
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (has_z && fabs(z0 - current_position[Z_AXIS]) > Z_CALIBRATION_THRESHOLD) { //if we have data from z calibration, max. allowed difference is 1mm for each point
|
||||
kill_message = _i("Bed leveling failed. Sensor triggered too high. Waiting for reset.");////MSG_BED_LEVELING_FAILED_POINT_HIGH c=20 r=4
|
||||
printf_P(PSTR("Bed leveling failed. Sensor triggered too high. Waiting for reset.\n"));
|
||||
break;
|
||||
}
|
||||
#ifdef SUPPORT_VERBOSITY
|
||||
|
@ -4693,8 +4687,43 @@ if((eSoundMode==e_SOUND_MODE_LOUD)||(eSoundMode==e_SOUND_MODE_ONCE))
|
|||
}
|
||||
// SERIAL_ECHOLNPGM("Bed leveling correction finished");
|
||||
if (nMeasPoints == 3) {
|
||||
mbl.upsample_3x3(); //bilinear interpolation from 3x3 to 7x7 points while using the same array z_values[iy][ix] for storing (just coppying measured data to new destination and interpolating between them)
|
||||
mbl.upsample_3x3(); //interpolation from 3x3 to 7x7 points using largrangian polynomials while using the same array z_values[iy][ix] for storing (just coppying measured data to new destination and interpolating between them)
|
||||
}
|
||||
/*
|
||||
SERIAL_PROTOCOLPGM("Num X,Y: ");
|
||||
SERIAL_PROTOCOL(MESH_NUM_X_POINTS);
|
||||
SERIAL_PROTOCOLPGM(",");
|
||||
SERIAL_PROTOCOL(MESH_NUM_Y_POINTS);
|
||||
SERIAL_PROTOCOLPGM("\nZ search height: ");
|
||||
SERIAL_PROTOCOL(MESH_HOME_Z_SEARCH);
|
||||
SERIAL_PROTOCOLLNPGM("\nMeasured points:");
|
||||
for (int y = MESH_NUM_Y_POINTS-1; y >= 0; y--) {
|
||||
for (int x = 0; x < MESH_NUM_X_POINTS; x++) {
|
||||
SERIAL_PROTOCOLPGM(" ");
|
||||
SERIAL_PROTOCOL_F(mbl.z_values[y][x], 5);
|
||||
}
|
||||
SERIAL_PROTOCOLPGM("\n");
|
||||
}
|
||||
*/
|
||||
if (nMeasPoints == 7 && magnet_elimination) {
|
||||
mbl_interpolation(nMeasPoints);
|
||||
}
|
||||
/*
|
||||
SERIAL_PROTOCOLPGM("Num X,Y: ");
|
||||
SERIAL_PROTOCOL(MESH_NUM_X_POINTS);
|
||||
SERIAL_PROTOCOLPGM(",");
|
||||
SERIAL_PROTOCOL(MESH_NUM_Y_POINTS);
|
||||
SERIAL_PROTOCOLPGM("\nZ search height: ");
|
||||
SERIAL_PROTOCOL(MESH_HOME_Z_SEARCH);
|
||||
SERIAL_PROTOCOLLNPGM("\nMeasured points:");
|
||||
for (int y = MESH_NUM_Y_POINTS-1; y >= 0; y--) {
|
||||
for (int x = 0; x < MESH_NUM_X_POINTS; x++) {
|
||||
SERIAL_PROTOCOLPGM(" ");
|
||||
SERIAL_PROTOCOL_F(mbl.z_values[y][x], 5);
|
||||
}
|
||||
SERIAL_PROTOCOLPGM("\n");
|
||||
}
|
||||
*/
|
||||
// SERIAL_ECHOLNPGM("Upsample finished");
|
||||
mbl.active = 1; //activate mesh bed leveling
|
||||
// SERIAL_ECHOLNPGM("Mesh bed leveling activated");
|
||||
|
@ -5812,7 +5841,6 @@ Sigma_Exit:
|
|||
if (code_seen('N'))
|
||||
gcode_LastN = code_value_long();
|
||||
break;
|
||||
#ifdef HOST_KEEPALIVE_FEATURE
|
||||
case 113: // M113 - Get or set Host Keepalive interval
|
||||
if (code_seen('S')) {
|
||||
host_keepalive_interval = (uint8_t)code_value_short();
|
||||
|
@ -5824,7 +5852,6 @@ Sigma_Exit:
|
|||
SERIAL_PROTOCOLLN("");
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
case 115: // M115
|
||||
if (code_seen('V')) {
|
||||
// Report the Prusa version number.
|
||||
|
@ -7158,7 +7185,66 @@ if((eSoundMode==e_SOUND_MODE_LOUD)||(eSoundMode==e_SOUND_MODE_ONCE))
|
|||
dcode_9(); break;
|
||||
case 10: //! D10 - XYZ calibration = OK
|
||||
dcode_10(); break;
|
||||
|
||||
#endif //DEBUG_DCODES
|
||||
#ifdef HEATBED_ANALYSIS
|
||||
case 80:
|
||||
{
|
||||
float dimension_x = 40;
|
||||
float dimension_y = 40;
|
||||
int points_x = 40;
|
||||
int points_y = 40;
|
||||
float offset_x = 74;
|
||||
float offset_y = 33;
|
||||
|
||||
if (code_seen('E')) dimension_x = code_value();
|
||||
if (code_seen('F')) dimension_y = code_value();
|
||||
if (code_seen('G')) {points_x = code_value(); }
|
||||
if (code_seen('H')) {points_y = code_value(); }
|
||||
if (code_seen('I')) {offset_x = code_value(); }
|
||||
if (code_seen('J')) {offset_y = code_value(); }
|
||||
printf_P(PSTR("DIM X: %f\n"), dimension_x);
|
||||
printf_P(PSTR("DIM Y: %f\n"), dimension_y);
|
||||
printf_P(PSTR("POINTS X: %d\n"), points_x);
|
||||
printf_P(PSTR("POINTS Y: %d\n"), points_y);
|
||||
printf_P(PSTR("OFFSET X: %f\n"), offset_x);
|
||||
printf_P(PSTR("OFFSET Y: %f\n"), offset_y);
|
||||
bed_check(dimension_x,dimension_y,points_x,points_y,offset_x,offset_y);
|
||||
}break;
|
||||
|
||||
case 81:
|
||||
{
|
||||
float dimension_x = 40;
|
||||
float dimension_y = 40;
|
||||
int points_x = 40;
|
||||
int points_y = 40;
|
||||
float offset_x = 74;
|
||||
float offset_y = 33;
|
||||
|
||||
if (code_seen('E')) dimension_x = code_value();
|
||||
if (code_seen('F')) dimension_y = code_value();
|
||||
if (code_seen("G")) { strchr_pointer+=1; points_x = code_value(); }
|
||||
if (code_seen("H")) { strchr_pointer+=1; points_y = code_value(); }
|
||||
if (code_seen("I")) { strchr_pointer+=1; offset_x = code_value(); }
|
||||
if (code_seen("J")) { strchr_pointer+=1; offset_y = code_value(); }
|
||||
|
||||
bed_analysis(dimension_x,dimension_y,points_x,points_y,offset_x,offset_y);
|
||||
|
||||
} break;
|
||||
|
||||
#endif //HEATBED_ANALYSIS
|
||||
#ifdef DEBUG_DCODES
|
||||
case 106: //D106 print measured fan speed for different pwm values
|
||||
{
|
||||
for (int i = 255; i > 0; i = i - 5) {
|
||||
fanSpeed = i;
|
||||
//delay_keep_alive(2000);
|
||||
for (int j = 0; j < 100; j++) {
|
||||
delay_keep_alive(100);
|
||||
|
||||
}
|
||||
printf_P(_N("%d: %d\n"), i, fan_speed[1]);
|
||||
}
|
||||
}break;
|
||||
|
||||
#ifdef TMC2130
|
||||
case 2130: //! D2130 - TMC2130
|
||||
|
@ -7961,7 +8047,7 @@ void check_babystep()
|
|||
lcd_update_enable(true);
|
||||
}
|
||||
}
|
||||
#ifdef DIS
|
||||
#ifdef HEATBED_ANALYSIS
|
||||
void d_setup()
|
||||
{
|
||||
pinMode(D_DATACLOCK, INPUT_PULLUP);
|
||||
|
@ -8011,6 +8097,199 @@ float d_ReadData()
|
|||
|
||||
}
|
||||
|
||||
void bed_check(float x_dimension, float y_dimension, int x_points_num, int y_points_num, float shift_x, float shift_y) {
|
||||
int t1 = 0;
|
||||
int t_delay = 0;
|
||||
int digit[13];
|
||||
int m;
|
||||
char str[3];
|
||||
//String mergeOutput;
|
||||
char mergeOutput[15];
|
||||
float output;
|
||||
|
||||
int mesh_point = 0; //index number of calibration point
|
||||
float bed_zero_ref_x = (-22.f + X_PROBE_OFFSET_FROM_EXTRUDER); //shift between zero point on bed and target and between probe and nozzle
|
||||
float bed_zero_ref_y = (-0.6f + Y_PROBE_OFFSET_FROM_EXTRUDER);
|
||||
|
||||
float mesh_home_z_search = 4;
|
||||
float measure_z_heigth = 0.2f;
|
||||
float row[x_points_num];
|
||||
int ix = 0;
|
||||
int iy = 0;
|
||||
|
||||
const char* filename_wldsd = "mesh.txt";
|
||||
char data_wldsd[x_points_num * 7 + 1]; //6 chars(" -A.BCD")for each measurement + null
|
||||
char numb_wldsd[8]; // (" -A.BCD" + null)
|
||||
#ifdef MICROMETER_LOGGING
|
||||
d_setup();
|
||||
#endif //MICROMETER_LOGGING
|
||||
|
||||
int XY_AXIS_FEEDRATE = homing_feedrate[X_AXIS] / 20;
|
||||
int Z_LIFT_FEEDRATE = homing_feedrate[Z_AXIS] / 40;
|
||||
|
||||
unsigned int custom_message_type_old = custom_message_type;
|
||||
unsigned int custom_message_state_old = custom_message_state;
|
||||
custom_message_type = CUSTOM_MSG_TYPE_MESHBL;
|
||||
custom_message_state = (x_points_num * y_points_num) + 10;
|
||||
lcd_update(1);
|
||||
|
||||
//mbl.reset();
|
||||
babystep_undo();
|
||||
|
||||
card.openFile(filename_wldsd, false);
|
||||
|
||||
/*destination[Z_AXIS] = mesh_home_z_search;
|
||||
//plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], Z_LIFT_FEEDRATE, active_extruder);
|
||||
|
||||
plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], Z_LIFT_FEEDRATE, active_extruder);
|
||||
for(int8_t i=0; i < NUM_AXIS; i++) {
|
||||
current_position[i] = destination[i];
|
||||
}
|
||||
st_synchronize();
|
||||
*/
|
||||
destination[Z_AXIS] = measure_z_heigth;
|
||||
plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], Z_LIFT_FEEDRATE, active_extruder);
|
||||
for(int8_t i=0; i < NUM_AXIS; i++) {
|
||||
current_position[i] = destination[i];
|
||||
}
|
||||
st_synchronize();
|
||||
/*int l_feedmultiply = */setup_for_endstop_move(false);
|
||||
|
||||
SERIAL_PROTOCOLPGM("Num X,Y: ");
|
||||
SERIAL_PROTOCOL(x_points_num);
|
||||
SERIAL_PROTOCOLPGM(",");
|
||||
SERIAL_PROTOCOL(y_points_num);
|
||||
SERIAL_PROTOCOLPGM("\nZ search height: ");
|
||||
SERIAL_PROTOCOL(mesh_home_z_search);
|
||||
SERIAL_PROTOCOLPGM("\nDimension X,Y: ");
|
||||
SERIAL_PROTOCOL(x_dimension);
|
||||
SERIAL_PROTOCOLPGM(",");
|
||||
SERIAL_PROTOCOL(y_dimension);
|
||||
SERIAL_PROTOCOLLNPGM("\nMeasured points:");
|
||||
|
||||
while (mesh_point != x_points_num * y_points_num) {
|
||||
ix = mesh_point % x_points_num; // from 0 to MESH_NUM_X_POINTS - 1
|
||||
iy = mesh_point / x_points_num;
|
||||
if (iy & 1) ix = (x_points_num - 1) - ix; // Zig zag
|
||||
float z0 = 0.f;
|
||||
/*destination[Z_AXIS] = mesh_home_z_search;
|
||||
//plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], Z_LIFT_FEEDRATE, active_extruder);
|
||||
|
||||
plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], Z_LIFT_FEEDRATE, active_extruder);
|
||||
for(int8_t i=0; i < NUM_AXIS; i++) {
|
||||
current_position[i] = destination[i];
|
||||
}
|
||||
st_synchronize();*/
|
||||
|
||||
|
||||
//current_position[X_AXIS] = 13.f + ix * (x_dimension / (x_points_num - 1)) - bed_zero_ref_x + shift_x;
|
||||
//current_position[Y_AXIS] = 6.4f + iy * (y_dimension / (y_points_num - 1)) - bed_zero_ref_y + shift_y;
|
||||
|
||||
destination[X_AXIS] = ix * (x_dimension / (x_points_num - 1)) + shift_x;
|
||||
destination[Y_AXIS] = iy * (y_dimension / (y_points_num - 1)) + shift_y;
|
||||
|
||||
mesh_plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], XY_AXIS_FEEDRATE/6, active_extruder);
|
||||
for(int8_t i=0; i < NUM_AXIS; i++) {
|
||||
current_position[i] = destination[i];
|
||||
}
|
||||
st_synchronize();
|
||||
|
||||
// printf_P(PSTR("X = %f; Y= %f \n"), current_position[X_AXIS], current_position[Y_AXIS]);
|
||||
|
||||
delay_keep_alive(1000);
|
||||
#ifdef MICROMETER_LOGGING
|
||||
|
||||
//memset(numb_wldsd, 0, sizeof(numb_wldsd));
|
||||
//dtostrf(d_ReadData(), 8, 5, numb_wldsd);
|
||||
//strcat(data_wldsd, numb_wldsd);
|
||||
|
||||
|
||||
|
||||
//MYSERIAL.println(data_wldsd);
|
||||
//delay(1000);
|
||||
//delay(3000);
|
||||
//t1 = millis();
|
||||
|
||||
//while (digitalRead(D_DATACLOCK) == LOW) {}
|
||||
//while (digitalRead(D_DATACLOCK) == HIGH) {}
|
||||
memset(digit, 0, sizeof(digit));
|
||||
//cli();
|
||||
digitalWrite(D_REQUIRE, LOW);
|
||||
|
||||
for (int i = 0; i<13; i++)
|
||||
{
|
||||
//t1 = millis();
|
||||
for (int j = 0; j < 4; j++)
|
||||
{
|
||||
while (digitalRead(D_DATACLOCK) == LOW) {}
|
||||
while (digitalRead(D_DATACLOCK) == HIGH) {}
|
||||
//printf_P(PSTR("Done %d\n"), j);
|
||||
bitWrite(digit[i], j, digitalRead(D_DATA));
|
||||
}
|
||||
//t_delay = (millis() - t1);
|
||||
//SERIAL_PROTOCOLPGM(" ");
|
||||
//SERIAL_PROTOCOL_F(t_delay, 5);
|
||||
//SERIAL_PROTOCOLPGM(" ");
|
||||
|
||||
}
|
||||
//sei();
|
||||
digitalWrite(D_REQUIRE, HIGH);
|
||||
mergeOutput[0] = '\0';
|
||||
output = 0;
|
||||
for (int r = 5; r <= 10; r++) //Merge digits
|
||||
{
|
||||
sprintf(str, "%d", digit[r]);
|
||||
strcat(mergeOutput, str);
|
||||
}
|
||||
|
||||
output = atof(mergeOutput);
|
||||
|
||||
if (digit[4] == 8) //Handle sign
|
||||
{
|
||||
output *= -1;
|
||||
}
|
||||
|
||||
for (int i = digit[11]; i > 0; i--) //Handle floating point
|
||||
{
|
||||
output *= 0.1;
|
||||
}
|
||||
|
||||
|
||||
//output = d_ReadData();
|
||||
|
||||
//row[ix] = current_position[Z_AXIS];
|
||||
|
||||
|
||||
|
||||
//row[ix] = d_ReadData();
|
||||
|
||||
row[ix] = output;
|
||||
|
||||
if (iy % 2 == 1 ? ix == 0 : ix == x_points_num - 1) {
|
||||
memset(data_wldsd, 0, sizeof(data_wldsd));
|
||||
for (int i = 0; i < x_points_num; i++) {
|
||||
SERIAL_PROTOCOLPGM(" ");
|
||||
SERIAL_PROTOCOL_F(row[i], 5);
|
||||
memset(numb_wldsd, 0, sizeof(numb_wldsd));
|
||||
dtostrf(row[i], 7, 3, numb_wldsd);
|
||||
strcat(data_wldsd, numb_wldsd);
|
||||
}
|
||||
card.write_command(data_wldsd);
|
||||
SERIAL_PROTOCOLPGM("\n");
|
||||
|
||||
}
|
||||
|
||||
custom_message_state--;
|
||||
mesh_point++;
|
||||
lcd_update(1);
|
||||
|
||||
}
|
||||
#endif //MICROMETER_LOGGING
|
||||
card.closefile();
|
||||
//clean_up_after_endstop_move(l_feedmultiply);
|
||||
|
||||
}
|
||||
|
||||
void bed_analysis(float x_dimension, float y_dimension, int x_points_num, int y_points_num, float shift_x, float shift_y) {
|
||||
int t1 = 0;
|
||||
int t_delay = 0;
|
||||
|
@ -8194,7 +8473,7 @@ void bed_analysis(float x_dimension, float y_dimension, int x_points_num, int y_
|
|||
card.closefile();
|
||||
clean_up_after_endstop_move(l_feedmultiply);
|
||||
}
|
||||
#endif
|
||||
#endif //HEATBED_ANALYSIS
|
||||
|
||||
void temp_compensation_start() {
|
||||
|
||||
|
|
|
@ -155,7 +155,11 @@
|
|||
#define EEPROM_MMU_LOAD_FAIL (EEPROM_MMU_LOAD_FAIL_TOT - 1) //uint8_t
|
||||
#define EEPROM_MMU_CUTTER_ENABLED (EEPROM_MMU_LOAD_FAIL - 1)
|
||||
#define EEPROM_UVLO_MESH_BED_LEVELING_FULL (EEPROM_MMU_CUTTER_ENABLED - 12*12*2) //allow 12 calibration points for future expansion
|
||||
|
||||
#define EEPROM_MBL_TYPE (EEPROM_UVLO_MESH_BED_LEVELING_FULL-1) //uint8_t for mesh bed leveling precision
|
||||
#define EEPROM_MBL_MAGNET_ELIMINATION (EEPROM_MBL_TYPE -1)
|
||||
#define EEPROM_MBL_POINTS_NR (EEPROM_MBL_MAGNET_ELIMINATION -1) //uint8_t number of points in one exis for mesh bed leveling
|
||||
#define EEPROM_MBL_PROBE_NR (EEPROM_MBL_POINTS_NR-1) //number of measurements for each point
|
||||
#define EEPROM_MMU_STEALTH (EEPROM_MBL_PROBE_NR-1)
|
||||
// !!!!!
|
||||
// !!!!! this is end of EEPROM section ... all updates MUST BE inserted before this mark !!!!!
|
||||
// !!!!!
|
||||
|
|
|
@ -936,6 +936,7 @@ static inline void update_current_position_z()
|
|||
}
|
||||
|
||||
// At the current position, find the Z stop.
|
||||
|
||||
inline bool find_bed_induction_sensor_point_z(float minimum_z, uint8_t n_iter, int
|
||||
#ifdef SUPPORT_VERBOSITY
|
||||
verbosity_level
|
||||
|
@ -966,15 +967,29 @@ inline bool find_bed_induction_sensor_point_z(float minimum_z, uint8_t n_iter, i
|
|||
#endif //TMC2130
|
||||
for (uint8_t i = 0; i < n_iter; ++ i)
|
||||
{
|
||||
// Move up the retract distance.
|
||||
current_position[Z_AXIS] += .5f;
|
||||
go_to_current(homing_feedrate[Z_AXIS]/60);
|
||||
// Move back down slowly to find bed.
|
||||
|
||||
current_position[Z_AXIS] += 0.2;
|
||||
float z_bckp = current_position[Z_AXIS];
|
||||
go_to_current(homing_feedrate[Z_AXIS]/60);
|
||||
// Move back down slowly to find bed.
|
||||
current_position[Z_AXIS] = minimum_z;
|
||||
go_to_current(homing_feedrate[Z_AXIS]/(4*60));
|
||||
// we have to let the planner know where we are right now as it is not where we said to go.
|
||||
update_current_position_z();
|
||||
if (! endstop_z_hit_on_purpose())
|
||||
//printf_P(PSTR("Zs: %f, Z: %f, delta Z: %f"), z_bckp, current_position[Z_AXIS], (z_bckp - current_position[Z_AXIS]));
|
||||
if (abs(current_position[Z_AXIS] - z_bckp) < 0.025) {
|
||||
//printf_P(PSTR("PINDA triggered immediately, move Z higher and repeat measurement\n"));
|
||||
current_position[Z_AXIS] += 0.5;
|
||||
go_to_current(homing_feedrate[Z_AXIS]/60);
|
||||
current_position[Z_AXIS] = minimum_z;
|
||||
go_to_current(homing_feedrate[Z_AXIS]/(4*60));
|
||||
// we have to let the planner know where we are right now as it is not where we said to go.
|
||||
update_current_position_z();
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (! endstop_z_hit_on_purpose())
|
||||
goto error;
|
||||
#ifdef TMC2130
|
||||
if (READ(Z_TMC2130_DIAG) != 0) goto error; //crash Z detected
|
||||
|
@ -984,7 +999,7 @@ inline bool find_bed_induction_sensor_point_z(float minimum_z, uint8_t n_iter, i
|
|||
// SERIAL_ECHOLNPGM("");
|
||||
float dz = i?abs(current_position[Z_AXIS] - (z / i)):0;
|
||||
z += current_position[Z_AXIS];
|
||||
// printf_P(PSTR(" Z[%d] = %d, dz=%d\n"), i, (int)(current_position[Z_AXIS] * 1000), (int)(dz * 1000));
|
||||
//printf_P(PSTR("Z[%d] = %d, dz=%d\n"), i, (int)(current_position[Z_AXIS] * 1000), (int)(dz * 1000));
|
||||
if (dz > 0.05) goto error;//deviation > 50um
|
||||
}
|
||||
current_position[Z_AXIS] = z;
|
||||
|
@ -2747,7 +2762,7 @@ void go_home_with_z_lift()
|
|||
current_position[Y_AXIS] = Y_MIN_POS+0.2;
|
||||
// Clamp to the physical coordinates.
|
||||
world2machine_clamp(current_position[X_AXIS], current_position[Y_AXIS]);
|
||||
go_to_current(homing_feedrate[X_AXIS]/60);
|
||||
go_to_current(homing_feedrate[X_AXIS]/20);
|
||||
// Third move up to a safe height.
|
||||
current_position[Z_AXIS] = Z_MIN_POS;
|
||||
go_to_current(homing_feedrate[Z_AXIS]/60);
|
||||
|
@ -3047,4 +3062,91 @@ void count_xyz_details(float (&distanceMin)[2]) {
|
|||
distanceMin[mesh_point] = (y - Y_MIN_POS_CALIBRATION_POINT_OUT_OF_REACH);
|
||||
}
|
||||
}
|
||||
/*
|
||||
e_MBL_TYPE e_mbl_type = e_MBL_OPTIMAL;
|
||||
|
||||
void mbl_mode_set() {
|
||||
switch (e_mbl_type) {
|
||||
case e_MBL_OPTIMAL: e_mbl_type = e_MBL_PREC; break;
|
||||
case e_MBL_PREC: e_mbl_type = e_MBL_FAST; break;
|
||||
case e_MBL_FAST: e_mbl_type = e_MBL_OPTIMAL; break;
|
||||
default: e_mbl_type = e_MBL_OPTIMAL; break;
|
||||
}
|
||||
eeprom_update_byte((uint8_t*)EEPROM_MBL_TYPE,(uint8_t)e_mbl_type);
|
||||
}
|
||||
|
||||
void mbl_mode_init() {
|
||||
uint8_t mbl_type = eeprom_read_byte((uint8_t*)EEPROM_MBL_TYPE);
|
||||
if (mbl_type == 0xFF) e_mbl_type = e_MBL_OPTIMAL;
|
||||
else e_mbl_type = mbl_type;
|
||||
}
|
||||
*/
|
||||
|
||||
void mbl_settings_init() {
|
||||
//3x3 mesh; 3 Z-probes on each point, magnet elimination on
|
||||
//magnet elimination: use aaproximate Z-coordinate instead of measured values for points which are near magnets
|
||||
if (eeprom_read_byte((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION) == 0xFF) {
|
||||
eeprom_update_byte((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION, 1);
|
||||
}
|
||||
if (eeprom_read_byte((uint8_t*)EEPROM_MBL_POINTS_NR) == 0xFF) {
|
||||
eeprom_update_byte((uint8_t*)EEPROM_MBL_POINTS_NR, 3);
|
||||
}
|
||||
mbl_z_probe_nr = eeprom_read_byte((uint8_t*)EEPROM_MBL_PROBE_NR);
|
||||
if (mbl_z_probe_nr == 0xFF) {
|
||||
mbl_z_probe_nr = 3;
|
||||
eeprom_update_byte((uint8_t*)EEPROM_MBL_PROBE_NR, mbl_z_probe_nr);
|
||||
}
|
||||
}
|
||||
|
||||
bool mbl_point_measurement_valid(uint8_t ix, uint8_t iy, uint8_t meas_points, bool zigzag) {
|
||||
//"human readable" heatbed plan
|
||||
//magnet proximity influence Z coordinate measurements significantly (40 - 100 um)
|
||||
//0 - measurement point is above magnet and Z coordinate can be influenced negatively
|
||||
//1 - we should be in safe distance from magnets, measurement should be accurate
|
||||
if ((ix >= meas_points) || (iy >= meas_points)) return false;
|
||||
|
||||
uint8_t valid_points_mask[7] = {
|
||||
//[X_MAX,Y_MAX]
|
||||
0b1111111,
|
||||
0b1111111,
|
||||
0b1110111,
|
||||
0b1111011,
|
||||
0b1110111,
|
||||
0b1111111,
|
||||
0b1111111,
|
||||
//[0,0]
|
||||
};
|
||||
if (meas_points == 3) {
|
||||
ix *= 3;
|
||||
iy *= 3;
|
||||
}
|
||||
if (zigzag) {
|
||||
if ((iy % 2) == 0) return (valid_points_mask[6 - iy] & (1 << (6 - ix)));
|
||||
else return (valid_points_mask[6 - iy] & (1 << ix));
|
||||
}
|
||||
else {
|
||||
return (valid_points_mask[6 - iy] & (1 << (6 - ix)));
|
||||
}
|
||||
}
|
||||
|
||||
void mbl_single_point_interpolation(uint8_t x, uint8_t y, uint8_t meas_points) {
|
||||
//printf_P(PSTR("x = %d; y = %d \n"), x, y);
|
||||
uint8_t count = 0;
|
||||
float z = 0;
|
||||
if (mbl_point_measurement_valid(x, y + 1, meas_points, false)) { z += mbl.z_values[y + 1][x]; /*printf_P(PSTR("x; y+1: Z = %f \n"), mbl.z_values[y + 1][x]);*/ count++; }
|
||||
if (mbl_point_measurement_valid(x, y - 1, meas_points, false)) { z += mbl.z_values[y - 1][x]; /*printf_P(PSTR("x; y-1: Z = %f \n"), mbl.z_values[y - 1][x]);*/ count++; }
|
||||
if (mbl_point_measurement_valid(x + 1, y, meas_points, false)) { z += mbl.z_values[y][x + 1]; /*printf_P(PSTR("x+1; y: Z = %f \n"), mbl.z_values[y][x + 1]);*/ count++; }
|
||||
if (mbl_point_measurement_valid(x - 1, y, meas_points, false)) { z += mbl.z_values[y][x - 1]; /*printf_P(PSTR("x-1; y: Z = %f \n"), mbl.z_values[y][x - 1]);*/ count++; }
|
||||
if(count != 0) mbl.z_values[y][x] = z / count; //if we have at least one valid point in surrounding area use average value, otherwise use inaccurately measured Z-coordinate
|
||||
//printf_P(PSTR("result: Z = %f \n\n"), mbl.z_values[y][x]);
|
||||
}
|
||||
|
||||
void mbl_interpolation(uint8_t meas_points) {
|
||||
for (uint8_t x = 0; x < meas_points; x++) {
|
||||
for (uint8_t y = 0; y < meas_points; y++) {
|
||||
if (!mbl_point_measurement_valid(x, y, meas_points, false)) {
|
||||
mbl_single_point_interpolation(x, y, meas_points);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
|
@ -6,10 +6,10 @@
|
|||
|
||||
#ifdef HEATBED_V2
|
||||
|
||||
#define BED_X0 (13.f - BED_ZERO_REF_X)
|
||||
#define BED_Y0 (10.4f - BED_ZERO_REF_Y)
|
||||
#define BED_Xn (216.f - BED_ZERO_REF_X)
|
||||
#define BED_Yn (202.4f - BED_ZERO_REF_Y)
|
||||
#define BED_X0 (2.f - BED_ZERO_REF_X) //1
|
||||
#define BED_Y0 (9.4f - BED_ZERO_REF_Y) //1
|
||||
#define BED_Xn (206.f - BED_ZERO_REF_X) //205
|
||||
#define BED_Yn (213.4f - BED_ZERO_REF_Y) //205
|
||||
|
||||
#else
|
||||
|
||||
|
@ -200,5 +200,17 @@ extern void babystep_reset();
|
|||
|
||||
extern void count_xyz_details(float (&distanceMin)[2]);
|
||||
extern bool sample_z();
|
||||
/*
|
||||
typedef enum
|
||||
{
|
||||
e_MBL_FAST, e_MBL_OPTIMAL, e_MBL_PREC
|
||||
} e_MBL_TYPE;
|
||||
*/
|
||||
//extern e_MBL_TYPE e_mbl_type;
|
||||
//extern void mbl_mode_set();
|
||||
//extern void mbl_mode_init();
|
||||
extern void mbl_settings_init();
|
||||
|
||||
extern bool mbl_point_measurement_valid(uint8_t ix, uint8_t iy, uint8_t meas_points, bool zigzag);
|
||||
extern void mbl_interpolation(uint8_t meas_points);
|
||||
#endif /* MESH_BED_CALIBRATION_H */
|
||||
|
|
|
@ -45,6 +45,7 @@ namespace
|
|||
WaitCmd, //!< wait for command response
|
||||
Pause,
|
||||
GetDrvError, //!< get power failures count
|
||||
SwitchMode //switch mmu between stealth and normal mode
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -183,12 +184,10 @@ bool check_for_ir_sensor()
|
|||
|
||||
static bool activate_stealth_mode()
|
||||
{
|
||||
#if defined (MMU_FORCE_STEALTH_MODE)
|
||||
#ifdef MMU_FORCE_STEALTH_MODE
|
||||
return true;
|
||||
#elif defined (SILENT_MODE_STEALTH)
|
||||
return (eeprom_read_byte((uint8_t*)EEPROM_SILENT) == SILENT_MODE_STEALTH);
|
||||
#else
|
||||
return false;
|
||||
return (eeprom_read_byte((uint8_t*)EEPROM_MMU_STEALTH) == 1);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -337,6 +336,11 @@ void mmu_loop(void)
|
|||
mmu_last_cmd = mmu_cmd;
|
||||
mmu_cmd = MmuCmd::None;
|
||||
}
|
||||
else if ((eeprom_read_byte((uint8_t*)EEPROM_MMU_STEALTH) != SilentModeMenu_MMU) && mmu_ready) {
|
||||
DEBUG_PRINTF_P(PSTR("MMU <= 'M%d'\n"), SilentModeMenu_MMU);
|
||||
mmu_printf_P(PSTR("M%d\n"), SilentModeMenu_MMU);
|
||||
mmu_state = S::SwitchMode;
|
||||
}
|
||||
else if ((mmu_last_response + 300) < _millis()) //request every 300ms
|
||||
{
|
||||
#ifndef IR_SENSOR
|
||||
|
@ -452,9 +456,22 @@ void mmu_loop(void)
|
|||
mmu_state = S::Idle;
|
||||
}
|
||||
else if ((mmu_last_request + MMU_CMD_TIMEOUT) < _millis())
|
||||
{ //resend request after timeout (5 min)
|
||||
{ //timeout 45 s
|
||||
mmu_state = S::Idle;
|
||||
}
|
||||
return;
|
||||
case S::SwitchMode:
|
||||
if (mmu_rx_ok() > 0)
|
||||
{
|
||||
DEBUG_PRINTF_P(PSTR("MMU => 'ok'\n"));
|
||||
eeprom_update_byte((uint8_t*)EEPROM_MMU_STEALTH, SilentModeMenu_MMU);
|
||||
mmu_state = S::Idle;
|
||||
}
|
||||
else if ((mmu_last_request + MMU_CMD_TIMEOUT) < _millis())
|
||||
{ //timeout 45 s
|
||||
mmu_state = S::Idle;
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -14,6 +14,12 @@
|
|||
#define SWI2C_SDA 20 //SDA on P3
|
||||
#define SWI2C_SCL 21 //SCL on P3
|
||||
|
||||
#ifdef MICROMETER_LOGGING
|
||||
#define D_DATACLOCK 24 //Y_MAX (green)
|
||||
#define D_DATA 30 //X_MAX (blue)
|
||||
#define D_REQUIRE 23 //Z_MAX (white)
|
||||
#endif //MICROMETER_LOGGING
|
||||
|
||||
|
||||
|
||||
#define X_STEP_PIN 37
|
||||
|
|
|
@ -888,9 +888,7 @@ void manage_heater()
|
|||
}
|
||||
#endif
|
||||
|
||||
#ifdef HOST_KEEPALIVE_FEATURE
|
||||
host_keepalive();
|
||||
#endif
|
||||
}
|
||||
|
||||
#define PGM_RD_W(x) (short)pgm_read_word(&x)
|
||||
|
|
|
@ -47,11 +47,13 @@ char longFilenameOLD[LONG_FILENAME_LENGTH];
|
|||
|
||||
|
||||
static void lcd_sd_updir();
|
||||
static void lcd_mesh_bed_leveling_settings();
|
||||
|
||||
int8_t ReInitLCD = 0;
|
||||
|
||||
|
||||
int8_t SilentModeMenu = SILENT_MODE_OFF;
|
||||
uint8_t SilentModeMenu_MMU = 1; //activate mmu unit stealth mode
|
||||
|
||||
int8_t FSensorStateMenu = 1;
|
||||
|
||||
|
@ -4520,6 +4522,14 @@ static void lcd_sound_state_set(void)
|
|||
Sound_CycleState();
|
||||
}
|
||||
|
||||
#ifndef MMU_FORCE_STEALTH_MODE
|
||||
static void lcd_silent_mode_mmu_set() {
|
||||
if (SilentModeMenu_MMU == 1) SilentModeMenu_MMU = 0;
|
||||
else SilentModeMenu_MMU = 1;
|
||||
//saving to eeprom is done in mmu_loop() after mmu actually switches state and confirms with "ok"
|
||||
}
|
||||
#endif //MMU_FORCE_STEALTH_MODE
|
||||
|
||||
static void lcd_silent_mode_set() {
|
||||
switch (SilentModeMenu) {
|
||||
#ifdef TMC2130
|
||||
|
@ -5303,6 +5313,21 @@ do\
|
|||
while (0)
|
||||
#endif //TMC2130
|
||||
|
||||
#ifndef MMU_FORCE_STEALTH_MODE
|
||||
#define SETTINGS_MMU_MODE \
|
||||
do\
|
||||
{\
|
||||
if (mmu_enabled)\
|
||||
{\
|
||||
if (SilentModeMenu_MMU == 0) MENU_ITEM_FUNCTION_P(_i("MMU Mode [Fast]"), lcd_silent_mode_mmu_set); \
|
||||
else MENU_ITEM_FUNCTION_P(_i("MMU Mode[Stealth]"), lcd_silent_mode_mmu_set); \
|
||||
}\
|
||||
}\
|
||||
while (0)
|
||||
#else //MMU_FORCE_STEALTH_MODE
|
||||
#define SETTINGS_MMU_MODE
|
||||
#endif //MMU_FORCE_STEALTH_MODE
|
||||
|
||||
#ifdef SDCARD_SORT_ALPHA
|
||||
#define SETTINGS_SD \
|
||||
do\
|
||||
|
@ -5337,6 +5362,29 @@ do\
|
|||
while (0)
|
||||
#endif // SDCARD_SORT_ALPHA
|
||||
|
||||
/*
|
||||
#define SETTINGS_MBL_MODE \
|
||||
do\
|
||||
{\
|
||||
switch(e_mbl_type)\
|
||||
{\
|
||||
case e_MBL_FAST:\
|
||||
MENU_ITEM_FUNCTION_P(_i("Mode [Fast]"),mbl_mode_set);\
|
||||
break; \
|
||||
case e_MBL_OPTIMAL:\
|
||||
MENU_ITEM_FUNCTION_P(_i("Mode [Optimal]"), mbl_mode_set); \
|
||||
break; \
|
||||
case e_MBL_PREC:\
|
||||
MENU_ITEM_FUNCTION_P(_i("Mode [Precise]"), mbl_mode_set); \
|
||||
break; \
|
||||
default:\
|
||||
MENU_ITEM_FUNCTION_P(_i("Mode [Optimal]"), mbl_mode_set); \
|
||||
break; \
|
||||
}\
|
||||
}\
|
||||
while (0)
|
||||
*/
|
||||
|
||||
#define SETTINGS_SOUND \
|
||||
do\
|
||||
{\
|
||||
|
@ -5384,6 +5432,9 @@ static void lcd_settings_menu()
|
|||
MENU_ITEM_FUNCTION_P(_i("Fans check [off]"), lcd_set_fan_check);////MSG_FANS_CHECK_OFF c=17 r=1
|
||||
|
||||
SETTINGS_SILENT_MODE;
|
||||
SETTINGS_MMU_MODE;
|
||||
|
||||
MENU_ITEM_SUBMENU_P(_i("Mesh bed leveling"), lcd_mesh_bed_leveling_settings);////MSG_MBL_SETTINGS c=18 r=1
|
||||
|
||||
#if defined (TMC2130) && defined (LINEARITY_CORRECTION)
|
||||
MENU_ITEM_SUBMENU_P(_i("Lin. correction"), lcd_settings_linearity_correction_menu);
|
||||
|
@ -6602,7 +6653,7 @@ static void lcd_tune_menu()
|
|||
}
|
||||
}
|
||||
#endif //TMC2130
|
||||
|
||||
SETTINGS_MMU_MODE;
|
||||
switch(eSoundMode)
|
||||
{
|
||||
case e_SOUND_MODE_LOUD:
|
||||
|
@ -6624,6 +6675,48 @@ static void lcd_tune_menu()
|
|||
MENU_END();
|
||||
}
|
||||
|
||||
static void mbl_magnets_elimination_set() {
|
||||
bool magnet_elimination = (eeprom_read_byte((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION) > 0);
|
||||
magnet_elimination = !magnet_elimination;
|
||||
eeprom_update_byte((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION, (uint8_t)magnet_elimination);
|
||||
}
|
||||
|
||||
static void mbl_mesh_set() {
|
||||
uint8_t mesh_nr = eeprom_read_byte((uint8_t*)EEPROM_MBL_POINTS_NR);
|
||||
if(mesh_nr == 3) mesh_nr = 7;
|
||||
else mesh_nr = 3;
|
||||
eeprom_update_byte((uint8_t*)EEPROM_MBL_POINTS_NR, mesh_nr);
|
||||
}
|
||||
|
||||
static void lcd_mesh_bed_leveling_settings()
|
||||
{
|
||||
|
||||
bool magnet_elimination = (eeprom_read_byte((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION) > 0);
|
||||
uint8_t points_nr = eeprom_read_byte((uint8_t*)EEPROM_MBL_POINTS_NR);
|
||||
|
||||
MENU_BEGIN();
|
||||
// leaving menu - this condition must be immediately before MENU_ITEM_BACK_P
|
||||
if (((menu_item == menu_line) && menu_clicked && (lcd_encoder == menu_item)) || menu_leaving)
|
||||
{
|
||||
eeprom_update_byte((uint8_t*)EEPROM_MBL_PROBE_NR, (uint8_t)mbl_z_probe_nr);
|
||||
}
|
||||
MENU_ITEM_BACK_P(_T(MSG_SETTINGS));
|
||||
if(points_nr == 3) MENU_ITEM_FUNCTION_P(_i("Mesh [3x3]"), mbl_mesh_set);
|
||||
else MENU_ITEM_FUNCTION_P(_i("Mesh [7x7]"), mbl_mesh_set);
|
||||
MENU_ITEM_EDIT_int3_P(_i("Z-probe nr."), &mbl_z_probe_nr, 1, 5);
|
||||
if (points_nr == 7) {
|
||||
if (magnet_elimination) MENU_ITEM_FUNCTION_P(_i("Magnets comp. [On]"), mbl_magnets_elimination_set);
|
||||
else MENU_ITEM_FUNCTION_P(_i("Magnets comp.[Off]"), mbl_magnets_elimination_set);
|
||||
}
|
||||
else menu_item_text_P(_i("Magnets comp.[N/A]"));
|
||||
MENU_END();
|
||||
/*if(menu_leaving)
|
||||
{
|
||||
eeprom_update_byte((uint8_t*)EEPROM_MBL_POINTS_NR, mbl_z_probe_nr);
|
||||
}*/
|
||||
//SETTINGS_MBL_MODE;
|
||||
}
|
||||
|
||||
static void lcd_control_temperature_menu()
|
||||
{
|
||||
#ifdef PIDTEMP
|
||||
|
|
|
@ -118,6 +118,7 @@ extern int farm_status;
|
|||
#endif
|
||||
|
||||
extern int8_t SilentModeMenu;
|
||||
extern uint8_t SilentModeMenu_MMU;
|
||||
|
||||
extern bool cancel_heatup;
|
||||
extern bool isPrintPaused;
|
||||
|
|
|
@ -290,10 +290,10 @@
|
|||
#define MBL_Z_STEP 0.01
|
||||
|
||||
// Mesh definitions
|
||||
#define MESH_MIN_X 35
|
||||
#define MESH_MAX_X 238
|
||||
#define MESH_MIN_X 24
|
||||
#define MESH_MAX_X 228
|
||||
#define MESH_MIN_Y 6
|
||||
#define MESH_MAX_Y 202
|
||||
#define MESH_MAX_Y 210
|
||||
|
||||
// Mesh upsample definition
|
||||
#define MESH_NUM_X_POINTS 7
|
||||
|
|
|
@ -291,10 +291,10 @@
|
|||
#define MBL_Z_STEP 0.01
|
||||
|
||||
// Mesh definitions
|
||||
#define MESH_MIN_X 35
|
||||
#define MESH_MAX_X 238
|
||||
#define MESH_MIN_X 24
|
||||
#define MESH_MAX_X 228
|
||||
#define MESH_MIN_Y 6
|
||||
#define MESH_MAX_Y 202
|
||||
#define MESH_MAX_Y 210
|
||||
|
||||
// Mesh upsample definition
|
||||
#define MESH_NUM_X_POINTS 7
|
||||
|
@ -505,4 +505,7 @@
|
|||
|
||||
#define MMU_IDLER_SENSOR_ATTEMPTS_NR 21 //max. number of attempts to load filament if first load failed; value for max bowden length and case when loading fails right at the beginning
|
||||
|
||||
//#define HEATBED_ANALYSIS //for meash bed leveling and heatbed analysis D-codes D80 and D81
|
||||
//#define MICROMETER_LOGGING //related to D-codes D80 and D81, currently works on MK2.5 only (MK3 board pin definitions missing)
|
||||
|
||||
#endif //__CONFIGURATION_PRUSA_H
|
||||
|
|
|
@ -290,10 +290,10 @@
|
|||
#define MBL_Z_STEP 0.01
|
||||
|
||||
// Mesh definitions
|
||||
#define MESH_MIN_X 35
|
||||
#define MESH_MAX_X 238
|
||||
#define MESH_MIN_X 24
|
||||
#define MESH_MAX_X 228
|
||||
#define MESH_MIN_Y 6
|
||||
#define MESH_MAX_Y 202
|
||||
#define MESH_MAX_Y 210
|
||||
|
||||
// Mesh upsample definition
|
||||
#define MESH_NUM_X_POINTS 7
|
||||
|
|
|
@ -291,10 +291,10 @@
|
|||
#define MBL_Z_STEP 0.01
|
||||
|
||||
// Mesh definitions
|
||||
#define MESH_MIN_X 35
|
||||
#define MESH_MAX_X 238
|
||||
#define MESH_MIN_X 24
|
||||
#define MESH_MAX_X 228
|
||||
#define MESH_MIN_Y 6
|
||||
#define MESH_MAX_Y 202
|
||||
#define MESH_MAX_Y 210
|
||||
|
||||
// Mesh upsample definition
|
||||
#define MESH_NUM_X_POINTS 7
|
||||
|
|
|
@ -400,10 +400,10 @@
|
|||
#define MBL_Z_STEP 0.01
|
||||
|
||||
// Mesh definitions
|
||||
#define MESH_MIN_X 35
|
||||
#define MESH_MAX_X 238
|
||||
#define MESH_MIN_X 24
|
||||
#define MESH_MAX_X 228
|
||||
#define MESH_MIN_Y 6
|
||||
#define MESH_MAX_Y 202
|
||||
#define MESH_MAX_Y 210
|
||||
|
||||
// Mesh upsample definition
|
||||
#define MESH_NUM_X_POINTS 7
|
||||
|
|
|
@ -400,10 +400,10 @@
|
|||
#define MBL_Z_STEP 0.01
|
||||
|
||||
// Mesh definitions
|
||||
#define MESH_MIN_X 35
|
||||
#define MESH_MAX_X 238
|
||||
#define MESH_MIN_X 24
|
||||
#define MESH_MAX_X 228
|
||||
#define MESH_MIN_Y 6
|
||||
#define MESH_MAX_Y 202
|
||||
#define MESH_MAX_Y 210
|
||||
|
||||
// Mesh upsample definition
|
||||
#define MESH_NUM_X_POINTS 7
|
||||
|
|
Loading…
Reference in a new issue