3DPrinting/Prusa-Firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #2274 from wavexx/fix_mesh_plan_buffer_line

Browse Source 
PFW-1028: Fix recovery from filament sensor checks / crash detect / power panic
This commit is contained in:
DRracer 2019-11-29 15:18:15 +01:00 committed by GitHub
commit 15bfb7013d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 239 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Firmware/Marlin.h
View File

@ -296,6 +296,7 @@ void setPwmFrequency(uint8_t pin, int val);
extern bool fans_check_enabled;
extern float homing_feedrate[];
extern bool axis_relative_modes[];
extern float feedrate;
extern int feedmultiply;
extern int extrudemultiply; // Sets extrude multiply factor (in percent) for all extruders
extern int extruder_multiply[EXTRUDERS]; // sets extrude multiply factor (in percent) for each extruder individually
@ -395,7 +396,7 @@ extern uint16_t gcode_in_progress;
extern LongTimer safetyTimer;
#define PRINT_PERCENT_DONE_INIT 0xff
#define PRINTER_ACTIVE (IS_SD_PRINTING || is_usb_printing || isPrintPaused || (custom_message_type == CustomMsg::TempCal) || saved_printing || (lcd_commands_type == LcdCommands::Layer1Cal) || card.paused || mmu_print_saved)
#define PRINTER_ACTIVE (IS_SD_PRINTING || is_usb_printing || isPrintPaused || (custom_message_type == CustomMsg::TempCal) || saved_printing || (lcd_commands_type == LcdCommands::Layer1Cal) || mmu_print_saved)
//! Beware - mcode_in_progress is set as soon as the command gets really processed,
//! which is not the same as posting the M600 command into the command queue

161
Firmware/Marlin_main.cpp
View File

@ -309,6 +309,8 @@ bool no_response = false;
uint8_t important_status;
uint8_t saved_filament_type;
#define SAVED_TARGET_UNSET (X_MIN_POS-1)
float saved_target[NUM_AXIS] = {SAVED_TARGET_UNSET, 0, 0, 0};
// save/restore printing in case that mmu was not responding
bool mmu_print_saved = false;
@ -329,7 +331,15 @@ float destination[NUM_AXIS] = { 0.0, 0.0, 0.0, 0.0};
// For tracing an arc
static float offset[3] = {0.0, 0.0, 0.0};
static float feedrate = 1500.0, next_feedrate, saved_feedrate;
// Current feedrate
float feedrate = 1500.0;
// Feedrate for the next move
static float next_feedrate;
// Original feedrate saved during homing moves
static float saved_feedrate;
// Determines Absolute or Relative Coordinates.
// Also there is bool axis_relative_modes[] per axis flag.
@ -373,8 +383,8 @@ bool saved_printing = false; //!< Print is paused and saved in RAM
static uint32_t saved_sdpos = 0; //!< SD card position, or line number in case of USB printing
uint8_t saved_printing_type = PRINTING_TYPE_SD;
static float saved_pos[4] = { 0, 0, 0, 0 };
//! Feedrate hopefully derived from an active block of the planner at the time the print has been canceled, in mm/min.
static float saved_feedrate2 = 0;
static uint16_t saved_feedrate2 = 0; //!< Default feedrate (truncated from float)
static int saved_feedmultiply2 = 0;
static uint8_t saved_active_extruder = 0;
static float saved_extruder_temperature = 0.0; //!< Active extruder temperature
static bool saved_extruder_under_pressure = false;
@ -3655,7 +3665,7 @@ void process_commands()
Set of internal PRUSA commands
PRUSA [ Ping | PRN | FAN | fn | thx | uvlo | fsensor_recover | MMURES | RESET | fv | M28 | SN | Fir | Rev | Lang | Lz | Beat | FR ]
PRUSA [ Ping | PRN | FAN | fn | thx | uvlo | MMURES | RESET | fv | M28 | SN | Fir | Rev | Lang | Lz | Beat | FR ]
- `Ping`
- `PRN` - Prints revision of the printer
@ -3663,7 +3673,6 @@ void process_commands()
- `fn` - Prints farm no.
- `thx`
- `uvlo`
- `fsensor_recover` - Filament sensor recover - restore print and continue
- `MMURES` - Reset MMU
- `RESET` - (Careful!)
- `fv` - ?
@ -3713,12 +3722,6 @@ void process_commands()
eeprom_update_byte((uint8_t*)EEPROM_UVLO,0);
enquecommand_P(PSTR("M24"));
}
#ifdef FILAMENT_SENSOR
else if (code_seen("fsensor_recover")) // PRUSA fsensor_recover
{
fsensor_restore_print_and_continue();
}
#endif //FILAMENT_SENSOR
else if (code_seen("MMURES")) // PRUSA MMURES
{
mmu_reset();
@ -4043,8 +4046,19 @@ if(eSoundMode!=e_SOUND_MODE_SILENT)
#endif
get_coordinates(); // For X Y Z E F
// When recovering from a previous print move, restore the originally
// calculated target position on the first USB/SD command. This accounts
// properly for relative moves
if ((saved_target[0] != SAVED_TARGET_UNSET) &&
((CMDBUFFER_CURRENT_TYPE == CMDBUFFER_CURRENT_TYPE_SDCARD) ||
(CMDBUFFER_CURRENT_TYPE == CMDBUFFER_CURRENT_TYPE_USB_WITH_LINENR)))
{
memcpy(destination, saved_target, sizeof(destination));
saved_target[0] = SAVED_TARGET_UNSET;
}
if (total_filament_used > ((current_position[E_AXIS] - destination[E_AXIS]) * 100)) { //protection against total_filament_used overflow
total_filament_used = total_filament_used + ((destination[E_AXIS] - current_position[E_AXIS]) * 100);
}
@ -5363,19 +5377,17 @@ if(eSoundMode!=e_SOUND_MODE_SILENT)
card.openFile(strchr_pointer + 4,true);
break;
//! ### M24 - Start SD print
//! ### M24 - Start/resume SD print
// ----------------------------------
case 24:
if (!card.paused)
if (isPrintPaused)
lcd_resume_print();
else
{
failstats_reset_print();
card.startFileprint();
starttime=_millis();
break;
//! ### M25 - Pause SD print
// ----------------------------------
case 25:
card.pauseSDPrint();
}
break;
//! ### M26 S\<index\> - Set SD index
@ -7232,18 +7244,26 @@ Sigma_Exit:
break;
#endif //FILAMENTCHANGEENABLE
//! ### M25 - Pause SD print
//! ### M601 - Pause print
//! ### M125 - Pause print (TODO: not implemented)
// -------------------------------
case 25:
case 601:
{
if (!isPrintPaused)
{
st_synchronize();
cmdqueue_pop_front(); //trick because we want skip this command (M601) after restore
lcd_pause_print();
}
}
break;
//! ### M602 - Resume print
// -------------------------------
case 602: {
if (isPrintPaused)
lcd_resume_print();
}
break;
@ -7251,7 +7271,7 @@ Sigma_Exit:
//! ### M603 - Stop print
// -------------------------------
case 603: {
lcd_print_stop();
Stop();
}
break;
@ -8342,7 +8362,6 @@ void clamp_to_software_endstops(float target[3])
void mesh_plan_buffer_line(const float &x, const float &y, const float &z, const float &e, const float &feed_rate, const uint8_t extruder) {
float dx = x - current_position[X_AXIS];
float dy = y - current_position[Y_AXIS];
float dz = z - current_position[Z_AXIS];
int n_segments = 0;
if (mbl.active) {
@ -8353,24 +8372,30 @@ void clamp_to_software_endstops(float target[3])
}
if (n_segments > 1) {
// In a multi-segment move explicitly set the final target in the plan
// as the move will be recalculated in it's entirety
float gcode_target[NUM_AXIS];
gcode_target[X_AXIS] = x;
gcode_target[Y_AXIS] = y;
gcode_target[Z_AXIS] = z;
gcode_target[E_AXIS] = e;
float dz = z - current_position[Z_AXIS];
float de = e - current_position[E_AXIS];
for (int i = 1; i < n_segments; ++ i) {
float t = float(i) / float(n_segments);
if (saved_printing || (mbl.active == false)) return;
plan_buffer_line(
current_position[X_AXIS] + t * dx,
plan_buffer_line(current_position[X_AXIS] + t * dx,
current_position[Y_AXIS] + t * dy,
current_position[Z_AXIS] + t * dz,
current_position[E_AXIS] + t * de,
feed_rate, extruder);
feed_rate, extruder, gcode_target);
if (waiting_inside_plan_buffer_line_print_aborted)
return;
}
}
// The rest of the path.
plan_buffer_line(x, y, z, e, feed_rate, extruder);
current_position[X_AXIS] = x;
current_position[Y_AXIS] = y;
current_position[Z_AXIS] = z;
current_position[E_AXIS] = e;
}
#endif // MESH_BED_LEVELING
@ -8390,10 +8415,10 @@ void prepare_move()
plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate*feedmultiply*(1./(60.f*100.f)), active_extruder);
#endif
}
if (waiting_inside_plan_buffer_line_print_aborted)
return;
for(int8_t i=0; i < NUM_AXIS; i++) {
current_position[i] = destination[i];
}
set_current_to_destination();
}
void prepare_arc_move(char isclockwise) {
@ -9115,9 +9140,7 @@ void bed_check(float x_dimension, float y_dimension, int x_points_num, int y_poi
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];
}
set_current_to_destination();
st_synchronize();
// printf_P(PSTR("X = %f; Y= %f \n"), current_position[X_AXIS], current_position[Y_AXIS]);
@ -9603,8 +9626,18 @@ void uvlo_()
if (sd_position < 0) sd_position = 0;
}
// Backup the feedrate in mm/min.
int feedrate_bckp = blocks_queued() ? (block_buffer[block_buffer_tail].nominal_speed * 60.f) : feedrate;
// save the global state at planning time
uint16_t feedrate_bckp;
if (blocks_queued())
{
memcpy(saved_target, current_block->gcode_target, sizeof(saved_target));
feedrate_bckp = current_block->gcode_feedrate;
}
else
{
saved_target[0] = SAVED_TARGET_UNSET;
feedrate_bckp = feedrate;
}
// After this call, the planner queue is emptied and the current_position is set to a current logical coordinate.
// The logical coordinate will likely differ from the machine coordinate if the skew calibration and mesh bed leveling
@ -9671,7 +9704,8 @@ void uvlo_()
eeprom_update_float((float*)(EEPROM_UVLO_CURRENT_POSITION + 4), current_position[Y_AXIS]);
eeprom_update_float((float*)EEPROM_UVLO_CURRENT_POSITION_Z , current_position[Z_AXIS]);
// Store the current feed rate, temperatures, fan speed and extruder multipliers (flow rates)
EEPROM_save_B(EEPROM_UVLO_FEEDRATE, &feedrate_bckp);
eeprom_update_word((uint16_t*)EEPROM_UVLO_FEEDRATE, feedrate_bckp);
EEPROM_save_B(EEPROM_UVLO_FEEDMULTIPLY, &feedmultiply);
eeprom_update_byte((uint8_t*)EEPROM_UVLO_TARGET_HOTEND, target_temperature[active_extruder]);
eeprom_update_byte((uint8_t*)EEPROM_UVLO_TARGET_BED, target_temperature_bed);
eeprom_update_byte((uint8_t*)EEPROM_UVLO_FAN_SPEED, fanSpeed);
@ -9683,6 +9717,11 @@ void uvlo_()
#endif
#endif
eeprom_update_word((uint16_t*)(EEPROM_EXTRUDEMULTIPLY), (uint16_t)extrudemultiply);
// Store the saved target
eeprom_update_float((float*)(EEPROM_UVLO_SAVED_TARGET+0*4), saved_target[X_AXIS]);
eeprom_update_float((float*)(EEPROM_UVLO_SAVED_TARGET+1*4), saved_target[Y_AXIS]);
eeprom_update_float((float*)(EEPROM_UVLO_SAVED_TARGET+2*4), saved_target[Z_AXIS]);
eeprom_update_float((float*)(EEPROM_UVLO_SAVED_TARGET+3*4), saved_target[E_AXIS]);
// Finaly store the "power outage" flag.
if(sd_print) eeprom_update_byte((uint8_t*)EEPROM_UVLO, 1);
@ -9931,10 +9970,17 @@ void recover_machine_state_after_power_panic(bool bTiny)
#endif
#endif
extrudemultiply = (int)eeprom_read_word((uint16_t*)(EEPROM_EXTRUDEMULTIPLY));
// 9) Recover the saved target
saved_target[X_AXIS] = eeprom_read_float((float*)(EEPROM_UVLO_SAVED_TARGET+0*4));
saved_target[Y_AXIS] = eeprom_read_float((float*)(EEPROM_UVLO_SAVED_TARGET+1*4));
saved_target[Z_AXIS] = eeprom_read_float((float*)(EEPROM_UVLO_SAVED_TARGET+2*4));
saved_target[E_AXIS] = eeprom_read_float((float*)(EEPROM_UVLO_SAVED_TARGET+3*4));
}
void restore_print_from_eeprom() {
int feedrate_rec;
int feedmultiply_rec;
uint8_t fan_speed_rec;
char cmd[30];
char filename[13];
@ -9942,9 +9988,12 @@ void restore_print_from_eeprom() {
char dir_name[9];
fan_speed_rec = eeprom_read_byte((uint8_t*)EEPROM_UVLO_FAN_SPEED);
EEPROM_read_B(EEPROM_UVLO_FEEDRATE, &feedrate_rec);
feedrate_rec = eeprom_read_word((uint16_t*)EEPROM_UVLO_FEEDRATE);
EEPROM_read_B(EEPROM_UVLO_FEEDMULTIPLY, &feedmultiply_rec);
SERIAL_ECHOPGM("Feedrate:");
MYSERIAL.println(feedrate_rec);
MYSERIAL.print(feedrate_rec);
SERIAL_ECHOPGM(", feedmultiply:");
MYSERIAL.println(feedmultiply_rec);
depth = eeprom_read_byte((uint8_t*)EEPROM_DIR_DEPTH);
@ -9985,9 +10034,11 @@ void restore_print_from_eeprom() {
enquecommand(cmd);
// Unretract.
enquecommand_P(PSTR("G1 E" STRINGIFY(2*default_retraction)" F480"));
// Set the feedrate saved at the power panic.
// Set the feedrates saved at the power panic.
sprintf_P(cmd, PSTR("G1 F%d"), feedrate_rec);
enquecommand(cmd);
sprintf_P(cmd, PSTR("M220 S%d"), feedmultiply_rec);
enquecommand(cmd);
if (eeprom_read_byte((uint8_t*)EEPROM_UVLO_E_ABS))
{
enquecommand_P(PSTR("M82")); //E axis abslute mode
@ -10139,16 +10190,21 @@ void stop_and_save_print_to_ram(float z_move, float e_move)
}
#endif
#if 0
saved_feedrate2 = feedrate; //save feedrate
#else
// Try to deduce the feedrate from the first block of the planner.
// Speed is in mm/min.
saved_feedrate2 = blocks_queued() ? (block_buffer[block_buffer_tail].nominal_speed * 60.f) : feedrate;
#endif
// save the global state at planning time
if (blocks_queued())
{
memcpy(saved_target, current_block->gcode_target, sizeof(saved_target));
saved_feedrate2 = current_block->gcode_feedrate;
}
else
{
saved_target[0] = SAVED_TARGET_UNSET;
saved_feedrate2 = feedrate;
}
planner_abort_hard(); //abort printing
memcpy(saved_pos, current_position, sizeof(saved_pos));
saved_feedmultiply2 = feedmultiply; //save feedmultiply
saved_active_extruder = active_extruder; //save active_extruder
saved_extruder_temperature = degTargetHotend(active_extruder);
@ -10226,7 +10282,6 @@ void restore_print_from_ram_and_continue(float e_move)
wait_for_heater(_millis(), saved_active_extruder);
heating_status = 2;
}
feedrate = saved_feedrate2; //restore feedrate
axis_relative_modes[E_AXIS] = saved_extruder_relative_mode;
float e = saved_pos[E_AXIS] - e_move;
plan_set_e_position(e);
@ -10249,6 +10304,10 @@ void restore_print_from_ram_and_continue(float e_move)
fans_check_enabled = true;
#endif
// restore original feedrate/feedmultiply _after_ restoring the extruder position
feedrate = saved_feedrate2;
feedmultiply = saved_feedmultiply2;
memcpy(current_position, saved_pos, sizeof(saved_pos));
memcpy(destination, current_position, sizeof(destination));
if (saved_printing_type == PRINTING_TYPE_SD) { //was sd printing
@ -10264,10 +10323,12 @@ void restore_print_from_ram_and_continue(float e_move)
else {
//not sd printing nor usb printing
}
SERIAL_PROTOCOLLNRPGM(MSG_OK); //dummy response because of octoprint is waiting for this
lcd_setstatuspgm(_T(WELCOME_MSG));
saved_printing_type = PRINTING_TYPE_NONE;
saved_printing = false;
waiting_inside_plan_buffer_line_print_aborted = true; //unroll the stack
}
void print_world_coordinates()

29
Firmware/cardreader.cpp
View File

@ -25,7 +25,6 @@ CardReader::CardReader()
sdpos = 0;
sdprinting = false;
cardOK = false;
paused = false;
saving = false;
logging = false;
autostart_atmillis=0;
@ -242,7 +241,6 @@ void CardReader::startFileprint()
if(cardOK)
{
sdprinting = true;
paused = false;
Stopped = false;
#ifdef SDCARD_SORT_ALPHA
//flush_presort();
@ -250,16 +248,6 @@ void CardReader::startFileprint()
}
}
void CardReader::pauseSDPrint()
{
if(sdprinting)
{
sdprinting = false;
paused = true;
}
}
void CardReader::openLogFile(const char* name)
{
logging = true;
@ -408,8 +396,6 @@ void CardReader::openFile(const char* name,bool read, bool replace_current/*=tru
SERIAL_ECHOLN(name);
}
sdprinting = false;
paused = false;
SdFile myDir;
const char *fname=name;
@ -492,7 +478,15 @@ uint32_t CardReader::getFileSize()
void CardReader::getStatus()
{
if(sdprinting){
if(sdprinting)
{
if (isPrintPaused) {
SERIAL_PROTOCOLLNPGM("SD print paused");
}
else if (saved_printing) {
SERIAL_PROTOCOLLNPGM("Print saved");
}
else {
SERIAL_PROTOCOL(longFilename);
SERIAL_PROTOCOLPGM("\n");
SERIAL_PROTOCOLRPGM(_N("SD printing byte "));////MSG_SD_PRINTING_BYTE
@ -505,11 +499,6 @@ void CardReader::getStatus()
SERIAL_PROTOCOL(itostr2(time%60));
SERIAL_PROTOCOLPGM("\n");
}
else if (paused) {
SERIAL_PROTOCOLLNPGM("SD print paused");
}
else if (saved_printing) {
SERIAL_PROTOCOLLNPGM("Print saved");
}
else {
SERIAL_PROTOCOLLNPGM("Not SD printing");

2
Firmware/cardreader.h
View File

@ -25,7 +25,6 @@ public:
void closefile(bool store_location=false);
void release();
void startFileprint();
void pauseSDPrint();
uint32_t getFileSize();
void getStatus();
void printingHasFinished();
@ -75,7 +74,6 @@ public:
bool logging;
bool sdprinting ;
bool cardOK ;
bool paused ;
char filename[13];
uint16_t modificationTime, modificationDate;
uint32_t cluster, position;

55
Firmware/cmdqueue.cpp
View File

@ -582,30 +582,8 @@ void get_command()
((serial_char == '#' || serial_char == ':') && comment_mode == false) ||
serial_count >= (MAX_CMD_SIZE - 1) || n==-1)
{
if(card.eof()){
SERIAL_PROTOCOLLNRPGM(_n("Done printing file"));////MSG_FILE_PRINTED
stoptime=_millis();
char time[30];
unsigned long t=(stoptime-starttime-pause_time)/1000;
pause_time = 0;
int hours, minutes;
minutes=(t/60)%60;
hours=t/60/60;
save_statistics(total_filament_used, t);
sprintf_P(time, PSTR("%i hours %i minutes"),hours, minutes);
SERIAL_ECHO_START;
SERIAL_ECHOLN(time);
lcd_setstatus(time);
card.printingHasFinished();
card.checkautostart(true);
if(card.eof()) break;
if (farm_mode)
{
prusa_statistics(6);
lcd_commands_type = LcdCommands::FarmModeConfirm;
}
}
if(serial_char=='#')
stop_buffering=true;
@ -663,6 +641,37 @@ void get_command()
else if(!comment_mode) cmdbuffer[bufindw+CMDHDRSIZE+serial_count++] = serial_char;
}
}
if(card.eof())
{
// file was fully buffered, but commands might still need to be planned!
// do *not* clear sdprinting until all SD commands are consumed to ensure
// SD state can be resumed from a saved printing state. sdprinting is only
// cleared by printingHasFinished after peforming all remaining moves.
if(!cmdqueue_calc_sd_length())
{
SERIAL_PROTOCOLLNRPGM(_n("Done printing file"));////MSG_FILE_PRINTED
stoptime=_millis();
char time[30];
unsigned long t=(stoptime-starttime-pause_time)/1000;
pause_time = 0;
int hours, minutes;
minutes=(t/60)%60;
hours=t/60/60;
save_statistics(total_filament_used, t);
sprintf_P(time, PSTR("%i hours %i minutes"),hours, minutes);
SERIAL_ECHO_START;
SERIAL_ECHOLN(time);
lcd_setstatus(time);
card.printingHasFinished();
card.checkautostart(true);
if (farm_mode)
{
prusa_statistics(6);
lcd_commands_type = LcdCommands::FarmModeConfirm;
}
}
}
#endif //SDSUPPORT
}

6
Firmware/eeprom.h
View File

@ -74,7 +74,7 @@ static_assert(sizeof(Sheets) == EEPROM_SHEETS_SIZEOF, "Sizeof(Sheets) is not EEP
#define EEPROM_UVLO_CURRENT_POSITION_Z (EEPROM_FILE_POSITION - 4) //float for current position in Z
#define EEPROM_UVLO_TARGET_HOTEND (EEPROM_UVLO_CURRENT_POSITION_Z - 1)
#define EEPROM_UVLO_TARGET_BED (EEPROM_UVLO_TARGET_HOTEND - 1)
#define EEPROM_UVLO_FEEDRATE (EEPROM_UVLO_TARGET_BED - 2)
#define EEPROM_UVLO_FEEDRATE (EEPROM_UVLO_TARGET_BED - 2) //uint16_t
#define EEPROM_UVLO_FAN_SPEED (EEPROM_UVLO_FEEDRATE - 1)
#define EEPROM_FAN_CHECK_ENABLED (EEPROM_UVLO_FAN_SPEED - 1)
#define EEPROM_UVLO_MESH_BED_LEVELING (EEPROM_FAN_CHECK_ENABLED - 9*2)
@ -204,9 +204,11 @@ static Sheets * const EEPROM_Sheets_base = (Sheets*)(EEPROM_SHEETS_BASE);
#define EEPROM_FSENSOR_PCB (EEPROM_SHEETS_BASE-1) // uint8
#define EEPROM_FSENSOR_ACTION_NA (EEPROM_FSENSOR_PCB-1) // uint8
#define EEPROM_UVLO_SAVED_TARGET (EEPROM_FSENSOR_ACTION_NA - 4*4) // 4 x float for saved target for all axes
#define EEPROM_UVLO_FEEDMULTIPLY (EEPROM_UVLO_SAVED_TARGET - 2) // uint16_t for feedmultiply
//This is supposed to point to last item to allow EEPROM overrun check. Please update when adding new items.
#define EEPROM_LAST_ITEM EEPROM_SHEETS_BASE
#define EEPROM_LAST_ITEM EEPROM_UVLO_FEEDMULTIPLY
// !!!!!
// !!!!! this is end of EEPROM section ... all updates MUST BE inserted before this mark !!!!!
// !!!!!

40
Firmware/fsensor.cpp
View File

@ -57,15 +57,8 @@ bool fsensor_enabled = true;
bool fsensor_watch_runout = true;
//! not responding - is set if any communication error occurred during initialization or readout
bool fsensor_not_responding = false;
//! printing saved
bool fsensor_printing_saved = false;
//! enable/disable quality meassurement
bool fsensor_oq_meassure_enabled = false;
//! as explained in the CHECK_FSENSOR macro: this flag is set to true when fsensor posts
//! the M600 into the command queue, which elliminates the hazard of having posted multiple M600's
//! before the first one gets read and started processing.
//! Btw., the IR fsensor could do up to 6 posts before the command queue managed to start processing the first M600 ;)
static bool fsensor_m600_enqueued = false;
//! number of errors, updated in ISR
uint8_t fsensor_err_cnt = 0;
@ -137,12 +130,19 @@ void fsensor_stop_and_save_print(void)
void fsensor_restore_print_and_continue(void)
{
printf_P(PSTR("fsensor_restore_print_and_continue\n"));
fsensor_watch_runout = true;
fsensor_err_cnt = 0;
fsensor_m600_enqueued = false;
restore_print_from_ram_and_continue(0); //XYZ = orig, E - no change
}
// fsensor_checkpoint_print cuts the current print job at the current position,
// allowing new instructions to be inserted in the middle
void fsensor_checkpoint_print(void)
{
printf_P(PSTR("fsensor_checkpoint_print\n"));
stop_and_save_print_to_ram(0, 0);
restore_print_from_ram_and_continue(0);
}
void fsensor_init(void)
{
#ifdef PAT9125
@ -565,8 +565,6 @@ void fsensor_enque_M600(){
printf_P(PSTR("fsensor_update - M600\n"));
eeprom_update_byte((uint8_t*)EEPROM_FERROR_COUNT, eeprom_read_byte((uint8_t*)EEPROM_FERROR_COUNT) + 1);
eeprom_update_word((uint16_t*)EEPROM_FERROR_COUNT_TOT, eeprom_read_word((uint16_t*)EEPROM_FERROR_COUNT_TOT) + 1);
enquecommand_front_P(PSTR("PRUSA fsensor_recover"));
fsensor_m600_enqueued = true;
enquecommand_front_P((PSTR("M600")));
}
@ -578,7 +576,7 @@ void fsensor_enque_M600(){
void fsensor_update(void)
{
#ifdef PAT9125
if (fsensor_enabled && fsensor_watch_runout && (fsensor_err_cnt > FSENSOR_ERR_MAX) && ( ! fsensor_m600_enqueued) )
if (fsensor_enabled && fsensor_watch_runout && (fsensor_err_cnt > FSENSOR_ERR_MAX))
{
bool autoload_enabled_tmp = fsensor_autoload_enabled;
fsensor_autoload_enabled = false;
@ -611,21 +609,17 @@ void fsensor_update(void)
err |= (fsensor_oq_er_sum > 2);
err |= (fsensor_oq_yd_sum < (4 * FSENSOR_OQ_MIN_YD));
if (!err)
{
printf_P(PSTR("fsensor_err_cnt = 0\n"));
fsensor_restore_print_and_continue();
}
else
{
fsensor_enque_M600();
fsensor_watch_runout = false;
}
fsensor_autoload_enabled = autoload_enabled_tmp;
fsensor_oq_meassure_enabled = oq_meassure_enabled_tmp;
if (!err)
printf_P(PSTR("fsensor_err_cnt = 0\n"));
else
fsensor_enque_M600();
}
#else //PAT9125
if (CHECK_FSENSOR && fsensor_enabled && ir_sensor_detected && ( ! fsensor_m600_enqueued) )
if (CHECK_FSENSOR && fsensor_enabled && ir_sensor_detected)
{
if(digitalRead(IR_SENSOR_PIN))
{ // IR_SENSOR_PIN ~ H
@ -670,7 +664,7 @@ void fsensor_update(void)
else
{
#endif //IR_SENSOR_ANALOG
fsensor_stop_and_save_print();
fsensor_checkpoint_print();
fsensor_enque_M600();
#if IR_SENSOR_ANALOG
}

2
Firmware/fsensor.h
View File

@ -21,6 +21,8 @@ extern bool fsensor_oq_meassure_enabled;
extern void fsensor_stop_and_save_print(void);
//! restore print - restore position and heatup to original temperature
extern void fsensor_restore_print_and_continue(void);
//! split the current gcode stream to insert new instructions
extern void fsensor_checkpoint_print(void);
//! @}
//! initialize

3
Firmware/mmu.cpp
View File

@ -382,8 +382,7 @@ void mmu_loop(void)
FDEBUG_PRINTF_P(PSTR("MMU => '%dok'\n"), mmu_finda);
//printf_P(PSTR("Eact: %d\n"), int(e_active()));
if (!mmu_finda && CHECK_FSENSOR && fsensor_enabled) {
fsensor_stop_and_save_print();
enquecommand_front_P(PSTR("PRUSA fsensor_recover")); //then recover
fsensor_checkpoint_print();
ad_markDepleted(mmu_extruder);
if (lcd_autoDepleteEnabled() && !ad_allDepleted())
{

36
Firmware/planner.cpp
View File

@ -659,15 +659,15 @@ float junction_deviation = 0.1;
// Add a new linear movement to the buffer. steps_x, _y and _z is the absolute position in
// mm. Microseconds specify how many microseconds the move should take to perform. To aid acceleration
// calculation the caller must also provide the physical length of the line in millimeters.
void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate, uint8_t extruder)
void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate, uint8_t extruder, const float* gcode_target)
{
// Calculate the buffer head after we push this byte
int next_buffer_head = next_block_index(block_buffer_head);
// If the buffer is full: good! That means we are well ahead of the robot.
// Rest here until there is room in the buffer.
if (block_buffer_tail == next_buffer_head) {
waiting_inside_plan_buffer_line_print_aborted = false;
if (block_buffer_tail == next_buffer_head) {
do {
manage_heater();
// Vojtech: Don't disable motors inside the planner!
@ -687,6 +687,29 @@ void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate
planner_update_queue_min_counter();
#endif /* PLANNER_DIAGNOSTICS */
// Prepare to set up new block
block_t *block = &block_buffer[block_buffer_head];
// Mark block as not busy (Not executed by the stepper interrupt, could be still tinkered with.)
block->busy = false;
// Set sdlen for calculating sd position
block->sdlen = 0;
// Save original destination of the move
if (gcode_target)
memcpy(block->gcode_target, gcode_target, sizeof(block_t::gcode_target));
else
{
block->gcode_target[X_AXIS] = x;
block->gcode_target[Y_AXIS] = y;
block->gcode_target[Z_AXIS] = z;
block->gcode_target[E_AXIS] = e;
}
// Save the global feedrate at scheduling time
block->gcode_feedrate = feedrate;
#ifdef ENABLE_AUTO_BED_LEVELING
apply_rotation_xyz(plan_bed_level_matrix, x, y, z);
#endif // ENABLE_AUTO_BED_LEVELING
@ -786,15 +809,6 @@ void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate
}
#endif
// Prepare to set up new block
block_t *block = &block_buffer[block_buffer_head];
// Set sdlen for calculating sd position
block->sdlen = 0;
// Mark block as not busy (Not executed by the stepper interrupt, could be still tinkered with.)
block->busy = false;
// Number of steps for each axis
#ifndef COREXY
// default non-h-bot planning

8
Firmware/planner.h
View File

@ -116,7 +116,10 @@ typedef struct {
unsigned long abs_adv_steps_multiplier8; // Factorised by 2^8 to avoid float
#endif
uint16_t sdlen;
// Save/recovery state data
float gcode_target[NUM_AXIS]; // Target (abs mm) of the original Gcode instruction
uint16_t gcode_feedrate; // Default and/or move feedrate
uint16_t sdlen; // Length of the Gcode instruction
} block_t;
#ifdef LIN_ADVANCE
@ -147,7 +150,7 @@ vector_3 plan_get_position();
/// The performance penalty is negligible, since these planned lines are usually maintenance moves with the extruder.
void plan_buffer_line_curposXYZE(float feed_rate, uint8_t extruder);
void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate, uint8_t extruder);
void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate, uint8_t extruder, const float* gcode_target = NULL);
//void plan_buffer_line(const float &x, const float &y, const float &z, const float &e, float feed_rate, const uint8_t &extruder);
#endif // ENABLE_AUTO_BED_LEVELING
@ -238,6 +241,7 @@ FORCE_INLINE bool planner_queue_full() {
// wait for the steppers to stop,
// update planner's current position and the current_position of the front end.
extern void planner_abort_hard();
extern bool waiting_inside_plan_buffer_line_print_aborted;
#ifdef PREVENT_DANGEROUS_EXTRUDE
void set_extrude_min_temp(float temp);

2
Firmware/ultralcd.cpp
View File

@ -4108,7 +4108,7 @@ void prusa_statistics(int _message, uint8_t _fil_nr) {
{
prusa_statistics_case0(15);
}
else if (isPrintPaused || card.paused)
else if (isPrintPaused)
{
prusa_statistics_case0(14);
}

5
Tests/PrusaStatistics_test.cpp
View File

@ -198,7 +198,7 @@ void prusa_statistics(int _message, uint8_t _fil_nr) {
SERIAL_ECHOLN("}");
status_number = 15;
}
else if (isPrintPaused || card.paused)
else if (isPrintPaused)
{
SERIAL_ECHO("{");
prusa_stat_printerstatus(14);
@ -490,7 +490,7 @@ void prusa_statistics(int _message, uint8_t _fil_nr) {
{
prusa_statistics_case0(15);
}
else if (isPrintPaused || card.paused)
else if (isPrintPaused)
{
prusa_statistics_case0(14);
}
@ -753,7 +753,6 @@ TEST_CASE("Prusa_statistics test", "[prusa_stats]")
SERIALS_RESET();
isPrintPaused = 0;
card.paused = 0;
IS_SD_PRINTING = 1;
old_code::prusa_statistics(test_codes[i],0);
new_code::prusa_statistics(test_codes[i],0);