3DPrinting/PrusaSlicer-NonPlainar
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Time estimate emitted to gcode at requested interval

Browse source
This commit is contained in:
Enrico Turri 2018-06-27 15:35:47 +02:00
parent de28d4edeb
commit 7ff22b9413
8 changed files with 544 additions and 137 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
lib/Slic3r/GUI/Plater.pm
View file

@ -509,7 +509,10 @@ sub new {
fil_mm3 => L("Used Filament (mm³)"), fil_mm3 => L("Used Filament (mm³)"),
fil_g => L("Used Filament (g)"), fil_g => L("Used Filament (g)"),
cost => L("Cost"), cost => L("Cost"),
default_time => L("Estimated printing time (default mode)"), #==========================================================================================================================================
normal_time => L("Estimated printing time (normal mode)"),
# default_time => L("Estimated printing time (default mode)"),
#==========================================================================================================================================
silent_time => L("Estimated printing time (silent mode)"), silent_time => L("Estimated printing time (silent mode)"),
); );
while (my $field = shift @info) { while (my $field = shift @info) {
@ -1578,7 +1581,10 @@ sub on_export_completed {
$self->{"print_info_cost"}->SetLabel(sprintf("%.2f" , $self->{print}->total_cost)); $self->{"print_info_cost"}->SetLabel(sprintf("%.2f" , $self->{print}->total_cost));
$self->{"print_info_fil_g"}->SetLabel(sprintf("%.2f" , $self->{print}->total_weight)); $self->{"print_info_fil_g"}->SetLabel(sprintf("%.2f" , $self->{print}->total_weight));
$self->{"print_info_fil_mm3"}->SetLabel(sprintf("%.2f" , $self->{print}->total_extruded_volume)); $self->{"print_info_fil_mm3"}->SetLabel(sprintf("%.2f" , $self->{print}->total_extruded_volume));
$self->{"print_info_default_time"}->SetLabel($self->{print}->estimated_default_print_time); #==========================================================================================================================================
$self->{"print_info_normal_time"}->SetLabel($self->{print}->estimated_normal_print_time);
# $self->{"print_info_default_time"}->SetLabel($self->{print}->estimated_default_print_time);
#==========================================================================================================================================
$self->{"print_info_silent_time"}->SetLabel($self->{print}->estimated_silent_print_time); $self->{"print_info_silent_time"}->SetLabel($self->{print}->estimated_silent_print_time);
$self->{"print_info_fil_m"}->SetLabel(sprintf("%.2f" , $self->{print}->total_used_filament / 1000)); $self->{"print_info_fil_m"}->SetLabel(sprintf("%.2f" , $self->{print}->total_used_filament / 1000));
$self->{"print_info_box_show"}->(1); $self->{"print_info_box_show"}->(1);

157
xs/src/libslic3r/GCode.cpp
View file

@ -375,8 +375,15 @@ void GCode::do_export(Print *print, const char *path, GCodePreviewData *preview_
} }
fclose(file); fclose(file);
//#################################################################################################################
m_normal_time_estimator.post_process_remaining_times(path_tmp, 60.0f);
//#################################################################################################################
if (m_silent_time_estimator_enabled) if (m_silent_time_estimator_enabled)
GCodeTimeEstimator::post_process_elapsed_times(path_tmp, m_default_time_estimator.get_time(), m_silent_time_estimator.get_time()); //############################################################################################################3
m_silent_time_estimator.post_process_remaining_times(path_tmp, 60.0f);
// GCodeTimeEstimator::post_process_elapsed_times(path_tmp, m_default_time_estimator.get_time(), m_silent_time_estimator.get_time());
//############################################################################################################3
if (! this->m_placeholder_parser_failed_templates.empty()) { if (! this->m_placeholder_parser_failed_templates.empty()) {
// G-code export proceeded, but some of the PlaceholderParser substitutions failed. // G-code export proceeded, but some of the PlaceholderParser substitutions failed.
@ -408,30 +415,72 @@ void GCode::_do_export(Print &print, FILE *file, GCodePreviewData *preview_data)
PROFILE_FUNC(); PROFILE_FUNC();
// resets time estimators // resets time estimators
m_default_time_estimator.reset(); //#######################################################################################################################################################################
m_default_time_estimator.set_dialect(print.config.gcode_flavor); m_normal_time_estimator.reset();
m_default_time_estimator.set_acceleration(print.config.machine_max_acceleration_extruding.values[0]); m_normal_time_estimator.set_dialect(print.config.gcode_flavor);
m_default_time_estimator.set_retract_acceleration(print.config.machine_max_acceleration_retracting.values[0]); m_normal_time_estimator.set_remaining_times_enabled(false);
m_default_time_estimator.set_minimum_feedrate(print.config.machine_min_extruding_rate.values[0]); m_normal_time_estimator.set_acceleration(print.config.machine_max_acceleration_extruding.values[0]);
m_default_time_estimator.set_minimum_travel_feedrate(print.config.machine_min_travel_rate.values[0]); m_normal_time_estimator.set_retract_acceleration(print.config.machine_max_acceleration_retracting.values[0]);
m_default_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::X, print.config.machine_max_acceleration_x.values[0]); m_normal_time_estimator.set_minimum_feedrate(print.config.machine_min_extruding_rate.values[0]);
m_default_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::Y, print.config.machine_max_acceleration_y.values[0]); m_normal_time_estimator.set_minimum_travel_feedrate(print.config.machine_min_travel_rate.values[0]);
m_default_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::Z, print.config.machine_max_acceleration_z.values[0]); m_normal_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::X, print.config.machine_max_acceleration_x.values[0]);
m_default_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::E, print.config.machine_max_acceleration_e.values[0]); m_normal_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::Y, print.config.machine_max_acceleration_y.values[0]);
m_default_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::X, print.config.machine_max_feedrate_x.values[0]); m_normal_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::Z, print.config.machine_max_acceleration_z.values[0]);
m_default_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::Y, print.config.machine_max_feedrate_y.values[0]); m_normal_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::E, print.config.machine_max_acceleration_e.values[0]);
m_default_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::Z, print.config.machine_max_feedrate_z.values[0]); m_normal_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::X, print.config.machine_max_feedrate_x.values[0]);
m_default_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::E, print.config.machine_max_feedrate_e.values[0]); m_normal_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::Y, print.config.machine_max_feedrate_y.values[0]);
m_default_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::X, print.config.machine_max_jerk_x.values[0]); m_normal_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::Z, print.config.machine_max_feedrate_z.values[0]);
m_default_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::Y, print.config.machine_max_jerk_y.values[0]); m_normal_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::E, print.config.machine_max_feedrate_e.values[0]);
m_default_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::Z, print.config.machine_max_jerk_z.values[0]); m_normal_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::X, print.config.machine_max_jerk_x.values[0]);
m_default_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::E, print.config.machine_max_jerk_e.values[0]); m_normal_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::Y, print.config.machine_max_jerk_y.values[0]);
m_normal_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::Z, print.config.machine_max_jerk_z.values[0]);
m_normal_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::E, print.config.machine_max_jerk_e.values[0]);
std::cout << "Normal" << std::endl;
std::cout << "set_acceleration " << print.config.machine_max_acceleration_extruding.values[0] << std::endl;
std::cout << "set_retract_acceleration " << print.config.machine_max_acceleration_retracting.values[0] << std::endl;
std::cout << "set_minimum_feedrate " << print.config.machine_min_extruding_rate.values[0] << std::endl;
std::cout << "set_minimum_travel_feedrate " << print.config.machine_min_travel_rate.values[0] << std::endl;
std::cout << "set_axis_max_acceleration X " << print.config.machine_max_acceleration_x.values[0] << std::endl;
std::cout << "set_axis_max_acceleration Y " << print.config.machine_max_acceleration_y.values[0] << std::endl;
std::cout << "set_axis_max_acceleration Z " << print.config.machine_max_acceleration_z.values[0] << std::endl;
std::cout << "set_axis_max_acceleration E " << print.config.machine_max_acceleration_e.values[0] << std::endl;
std::cout << "set_axis_max_feedrate X " << print.config.machine_max_feedrate_x.values[0] << std::endl;
std::cout << "set_axis_max_feedrate Y " << print.config.machine_max_feedrate_y.values[0] << std::endl;
std::cout << "set_axis_max_feedrate Z " << print.config.machine_max_feedrate_z.values[0] << std::endl;
std::cout << "set_axis_max_feedrate E " << print.config.machine_max_feedrate_e.values[0] << std::endl;
std::cout << "set_axis_max_jerk X " << print.config.machine_max_jerk_x.values[0] << std::endl;
std::cout << "set_axis_max_jerk Y " << print.config.machine_max_jerk_y.values[0] << std::endl;
std::cout << "set_axis_max_jerk Z " << print.config.machine_max_jerk_z.values[0] << std::endl;
std::cout << "set_axis_max_jerk E " << print.config.machine_max_jerk_e.values[0] << std::endl;
// m_default_time_estimator.reset();
// m_default_time_estimator.set_dialect(print.config.gcode_flavor);
// m_default_time_estimator.set_acceleration(print.config.machine_max_acceleration_extruding.values[0]);
// m_default_time_estimator.set_retract_acceleration(print.config.machine_max_acceleration_retracting.values[0]);
// m_default_time_estimator.set_minimum_feedrate(print.config.machine_min_extruding_rate.values[0]);
// m_default_time_estimator.set_minimum_travel_feedrate(print.config.machine_min_travel_rate.values[0]);
// m_default_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::X, print.config.machine_max_acceleration_x.values[0]);
// m_default_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::Y, print.config.machine_max_acceleration_y.values[0]);
// m_default_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::Z, print.config.machine_max_acceleration_z.values[0]);
// m_default_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::E, print.config.machine_max_acceleration_e.values[0]);
// m_default_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::X, print.config.machine_max_feedrate_x.values[0]);
// m_default_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::Y, print.config.machine_max_feedrate_y.values[0]);
// m_default_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::Z, print.config.machine_max_feedrate_z.values[0]);
// m_default_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::E, print.config.machine_max_feedrate_e.values[0]);
// m_default_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::X, print.config.machine_max_jerk_x.values[0]);
// m_default_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::Y, print.config.machine_max_jerk_y.values[0]);
// m_default_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::Z, print.config.machine_max_jerk_z.values[0]);
// m_default_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::E, print.config.machine_max_jerk_e.values[0]);
//#######################################################################################################################################################################
m_silent_time_estimator_enabled = (print.config.gcode_flavor == gcfMarlin) && print.config.silent_mode; m_silent_time_estimator_enabled = (print.config.gcode_flavor == gcfMarlin) && print.config.silent_mode;
if (m_silent_time_estimator_enabled) if (m_silent_time_estimator_enabled)
{ {
m_silent_time_estimator.reset(); m_silent_time_estimator.reset();
m_silent_time_estimator.set_dialect(print.config.gcode_flavor); m_silent_time_estimator.set_dialect(print.config.gcode_flavor);
m_silent_time_estimator.set_remaining_times_enabled(false);
m_silent_time_estimator.set_acceleration(print.config.machine_max_acceleration_extruding.values[1]); m_silent_time_estimator.set_acceleration(print.config.machine_max_acceleration_extruding.values[1]);
m_silent_time_estimator.set_retract_acceleration(print.config.machine_max_acceleration_retracting.values[1]); m_silent_time_estimator.set_retract_acceleration(print.config.machine_max_acceleration_retracting.values[1]);
m_silent_time_estimator.set_minimum_feedrate(print.config.machine_min_extruding_rate.values[1]); m_silent_time_estimator.set_minimum_feedrate(print.config.machine_min_extruding_rate.values[1]);
@ -638,12 +687,14 @@ void GCode::_do_export(Print &print, FILE *file, GCodePreviewData *preview_data)
_writeln(file, buf); _writeln(file, buf);
} }
// before start gcode time estimation //#######################################################################################################################################################################
if (m_silent_time_estimator_enabled) // // before start gcode time estimation
{ // if (m_silent_time_estimator_enabled)
_write(file, m_default_time_estimator.get_elapsed_time_string().c_str()); // {
_write(file, m_silent_time_estimator.get_elapsed_time_string().c_str()); // _write(file, m_default_time_estimator.get_elapsed_time_string().c_str());
} // _write(file, m_silent_time_estimator.get_elapsed_time_string().c_str());
// }
//#######################################################################################################################################################################
// Write the custom start G-code // Write the custom start G-code
_writeln(file, start_gcode); _writeln(file, start_gcode);
@ -849,21 +900,34 @@ void GCode::_do_export(Print &print, FILE *file, GCodePreviewData *preview_data)
for (const std::string &end_gcode : print.config.end_filament_gcode.values) for (const std::string &end_gcode : print.config.end_filament_gcode.values)
_writeln(file, this->placeholder_parser_process("end_filament_gcode", end_gcode, (unsigned int)(&end_gcode - &print.config.end_filament_gcode.values.front()), &config)); _writeln(file, this->placeholder_parser_process("end_filament_gcode", end_gcode, (unsigned int)(&end_gcode - &print.config.end_filament_gcode.values.front()), &config));
} }
// before end gcode time estimation //#######################################################################################################################################################################
if (m_silent_time_estimator_enabled) // // before end gcode time estimation
{ // if (m_silent_time_estimator_enabled)
_write(file, m_default_time_estimator.get_elapsed_time_string().c_str()); // {
_write(file, m_silent_time_estimator.get_elapsed_time_string().c_str()); // _write(file, m_default_time_estimator.get_elapsed_time_string().c_str());
} // _write(file, m_silent_time_estimator.get_elapsed_time_string().c_str());
// }
//#######################################################################################################################################################################
_writeln(file, this->placeholder_parser_process("end_gcode", print.config.end_gcode, m_writer.extruder()->id(), &config)); _writeln(file, this->placeholder_parser_process("end_gcode", print.config.end_gcode, m_writer.extruder()->id(), &config));
} }
_write(file, m_writer.update_progress(m_layer_count, m_layer_count, true)); // 100% _write(file, m_writer.update_progress(m_layer_count, m_layer_count, true)); // 100%
_write(file, m_writer.postamble()); _write(file, m_writer.postamble());
// calculates estimated printing time // calculates estimated printing time
m_default_time_estimator.calculate_time(); //#######################################################################################################################################################################
m_normal_time_estimator.set_remaining_times_enabled(true);
m_normal_time_estimator.calculate_time();
// m_default_time_estimator.calculate_time();
//#######################################################################################################################################################################
if (m_silent_time_estimator_enabled) if (m_silent_time_estimator_enabled)
//#######################################################################################################################################################################
{
m_silent_time_estimator.set_remaining_times_enabled(true);
//#######################################################################################################################################################################
m_silent_time_estimator.calculate_time(); m_silent_time_estimator.calculate_time();
//#######################################################################################################################################################################
}
//#######################################################################################################################################################################
// Get filament stats. // Get filament stats.
print.filament_stats.clear(); print.filament_stats.clear();
@ -871,7 +935,10 @@ void GCode::_do_export(Print &print, FILE *file, GCodePreviewData *preview_data)
print.total_extruded_volume = 0.; print.total_extruded_volume = 0.;
print.total_weight = 0.; print.total_weight = 0.;
print.total_cost = 0.; print.total_cost = 0.;
print.estimated_default_print_time = m_default_time_estimator.get_time_dhms(); //#######################################################################################################################################################################
print.estimated_normal_print_time = m_normal_time_estimator.get_time_dhms();
// print.estimated_default_print_time = m_default_time_estimator.get_time_dhms();
//#######################################################################################################################################################################
print.estimated_silent_print_time = m_silent_time_estimator_enabled ? m_silent_time_estimator.get_time_dhms() : "N/A"; print.estimated_silent_print_time = m_silent_time_estimator_enabled ? m_silent_time_estimator.get_time_dhms() : "N/A";
for (const Extruder &extruder : m_writer.extruders()) { for (const Extruder &extruder : m_writer.extruders()) {
double used_filament = extruder.used_filament(); double used_filament = extruder.used_filament();
@ -892,7 +959,10 @@ void GCode::_do_export(Print &print, FILE *file, GCodePreviewData *preview_data)
print.total_extruded_volume = print.total_extruded_volume + extruded_volume; print.total_extruded_volume = print.total_extruded_volume + extruded_volume;
} }
_write_format(file, "; total filament cost = %.1lf\n", print.total_cost); _write_format(file, "; total filament cost = %.1lf\n", print.total_cost);
_write_format(file, "; estimated printing time (default mode) = %s\n", m_default_time_estimator.get_time_dhms().c_str()); //#######################################################################################################################################################################
_write_format(file, "; estimated printing time (normal mode) = %s\n", m_normal_time_estimator.get_time_dhms().c_str());
// _write_format(file, "; estimated printing time (default mode) = %s\n", m_default_time_estimator.get_time_dhms().c_str());
//#######################################################################################################################################################################
if (m_silent_time_estimator_enabled) if (m_silent_time_estimator_enabled)
_write_format(file, "; estimated printing time (silent mode) = %s\n", m_silent_time_estimator.get_time_dhms().c_str()); _write_format(file, "; estimated printing time (silent mode) = %s\n", m_silent_time_estimator.get_time_dhms().c_str());
@ -1462,12 +1532,14 @@ void GCode::process_layer(
_write(file, gcode); _write(file, gcode);
// after layer time estimation //#######################################################################################################################################################################
if (m_silent_time_estimator_enabled) // // after layer time estimation
{ // if (m_silent_time_estimator_enabled)
_write(file, m_default_time_estimator.get_elapsed_time_string().c_str()); // {
_write(file, m_silent_time_estimator.get_elapsed_time_string().c_str()); // _write(file, m_default_time_estimator.get_elapsed_time_string().c_str());
} // _write(file, m_silent_time_estimator.get_elapsed_time_string().c_str());
// }
//#######################################################################################################################################################################
} }
void GCode::apply_print_config(const PrintConfig &print_config) void GCode::apply_print_config(const PrintConfig &print_config)
@ -2126,7 +2198,10 @@ void GCode::_write(FILE* file, const char *what)
// writes string to file // writes string to file
fwrite(gcode, 1, ::strlen(gcode), file); fwrite(gcode, 1, ::strlen(gcode), file);
// updates time estimator and gcode lines vector // updates time estimator and gcode lines vector
m_default_time_estimator.add_gcode_block(gcode); //#######################################################################################################################################################################
m_normal_time_estimator.add_gcode_block(gcode);
// m_default_time_estimator.add_gcode_block(gcode);
//#######################################################################################################################################################################
if (m_silent_time_estimator_enabled) if (m_silent_time_estimator_enabled)
m_silent_time_estimator.add_gcode_block(gcode); m_silent_time_estimator.add_gcode_block(gcode);
} }

10
xs/src/libslic3r/GCode.hpp
View file

@ -133,7 +133,10 @@ public:
m_last_height(GCodeAnalyzer::Default_Height), m_last_height(GCodeAnalyzer::Default_Height),
m_brim_done(false), m_brim_done(false),
m_second_layer_things_done(false), m_second_layer_things_done(false),
m_default_time_estimator(GCodeTimeEstimator::Default), //############################################################################################################3
m_normal_time_estimator(GCodeTimeEstimator::Normal),
// m_default_time_estimator(GCodeTimeEstimator::Default),
//############################################################################################################3
m_silent_time_estimator(GCodeTimeEstimator::Silent), m_silent_time_estimator(GCodeTimeEstimator::Silent),
m_silent_time_estimator_enabled(false), m_silent_time_estimator_enabled(false),
m_last_obj_copy(nullptr, Point(std::numeric_limits<coord_t>::max(), std::numeric_limits<coord_t>::max())) m_last_obj_copy(nullptr, Point(std::numeric_limits<coord_t>::max(), std::numeric_limits<coord_t>::max()))
@ -293,7 +296,10 @@ protected:
std::pair<const PrintObject*, Point> m_last_obj_copy; std::pair<const PrintObject*, Point> m_last_obj_copy;
// Time estimators // Time estimators
GCodeTimeEstimator m_default_time_estimator; //############################################################################################################3
GCodeTimeEstimator m_normal_time_estimator;
// GCodeTimeEstimator m_default_time_estimator;
//############################################################################################################3
GCodeTimeEstimator m_silent_time_estimator; GCodeTimeEstimator m_silent_time_estimator;
bool m_silent_time_estimator_enabled; bool m_silent_time_estimator_enabled;

418
xs/src/libslic3r/GCodeTimeEstimator.cpp
View file

@ -12,15 +12,26 @@ static const float MMMIN_TO_MMSEC = 1.0f / 60.0f;
static const float MILLISEC_TO_SEC = 0.001f; static const float MILLISEC_TO_SEC = 0.001f;
static const float INCHES_TO_MM = 25.4f; static const float INCHES_TO_MM = 25.4f;
static const float DEFAULT_FEEDRATE = 1500.0f; // from Prusa Firmware (Marlin_main.cpp) //#######################################################################################################################################################################
static const float DEFAULT_ACCELERATION = 1500.0f; // Prusa Firmware 1_75mm_MK2 static const float NORMAL_FEEDRATE = 1500.0f; // from Prusa Firmware (Marlin_main.cpp)
static const float DEFAULT_RETRACT_ACCELERATION = 1500.0f; // Prusa Firmware 1_75mm_MK2 static const float NORMAL_ACCELERATION = 1500.0f; // Prusa Firmware 1_75mm_MK2
static const float DEFAULT_AXIS_MAX_FEEDRATE[] = { 500.0f, 500.0f, 12.0f, 120.0f }; // Prusa Firmware 1_75mm_MK2 static const float NORMAL_RETRACT_ACCELERATION = 1500.0f; // Prusa Firmware 1_75mm_MK2
static const float DEFAULT_AXIS_MAX_ACCELERATION[] = { 9000.0f, 9000.0f, 500.0f, 10000.0f }; // Prusa Firmware 1_75mm_MK2 static const float NORMAL_AXIS_MAX_FEEDRATE[] = { 500.0f, 500.0f, 12.0f, 120.0f }; // Prusa Firmware 1_75mm_MK2
static const float DEFAULT_AXIS_MAX_JERK[] = { 10.0f, 10.0f, 0.2f, 2.5f }; // from Prusa Firmware (Configuration.h) static const float NORMAL_AXIS_MAX_ACCELERATION[] = { 9000.0f, 9000.0f, 500.0f, 10000.0f }; // Prusa Firmware 1_75mm_MK2
static const float DEFAULT_MINIMUM_FEEDRATE = 0.0f; // from Prusa Firmware (Configuration_adv.h) static const float NORMAL_AXIS_MAX_JERK[] = { 10.0f, 10.0f, 0.4f, 2.5f }; // from Prusa Firmware (Configuration.h)
static const float DEFAULT_MINIMUM_TRAVEL_FEEDRATE = 0.0f; // from Prusa Firmware (Configuration_adv.h) static const float NORMAL_MINIMUM_FEEDRATE = 0.0f; // from Prusa Firmware (Configuration_adv.h)
static const float DEFAULT_EXTRUDE_FACTOR_OVERRIDE_PERCENTAGE = 1.0f; // 100 percent static const float NORMAL_MINIMUM_TRAVEL_FEEDRATE = 0.0f; // from Prusa Firmware (Configuration_adv.h)
static const float NORMAL_EXTRUDE_FACTOR_OVERRIDE_PERCENTAGE = 1.0f; // 100 percent
//static const float DEFAULT_FEEDRATE = 1500.0f; // from Prusa Firmware (Marlin_main.cpp)
//static const float DEFAULT_ACCELERATION = 1500.0f; // Prusa Firmware 1_75mm_MK2
//static const float DEFAULT_RETRACT_ACCELERATION = 1500.0f; // Prusa Firmware 1_75mm_MK2
//static const float DEFAULT_AXIS_MAX_FEEDRATE[] = { 500.0f, 500.0f, 12.0f, 120.0f }; // Prusa Firmware 1_75mm_MK2
//static const float DEFAULT_AXIS_MAX_ACCELERATION[] = { 9000.0f, 9000.0f, 500.0f, 10000.0f }; // Prusa Firmware 1_75mm_MK2
//static const float DEFAULT_AXIS_MAX_JERK[] = { 10.0f, 10.0f, 0.2f, 2.5f }; // from Prusa Firmware (Configuration.h)
//static const float DEFAULT_MINIMUM_FEEDRATE = 0.0f; // from Prusa Firmware (Configuration_adv.h)
//static const float DEFAULT_MINIMUM_TRAVEL_FEEDRATE = 0.0f; // from Prusa Firmware (Configuration_adv.h)
//static const float DEFAULT_EXTRUDE_FACTOR_OVERRIDE_PERCENTAGE = 1.0f; // 100 percent
//#######################################################################################################################################################################
static const float SILENT_FEEDRATE = 1500.0f; // from Prusa Firmware (Marlin_main.cpp) static const float SILENT_FEEDRATE = 1500.0f; // from Prusa Firmware (Marlin_main.cpp)
static const float SILENT_ACCELERATION = 1250.0f; // Prusa Firmware 1_75mm_MK25-RAMBo13a-E3Dv6full static const float SILENT_ACCELERATION = 1250.0f; // Prusa Firmware 1_75mm_MK25-RAMBo13a-E3Dv6full
@ -34,10 +45,12 @@ static const float SILENT_EXTRUDE_FACTOR_OVERRIDE_PERCENTAGE = 1.0f; // 100 perc
static const float PREVIOUS_FEEDRATE_THRESHOLD = 0.0001f; static const float PREVIOUS_FEEDRATE_THRESHOLD = 0.0001f;
static const std::string ELAPSED_TIME_TAG_DEFAULT = ";_ELAPSED_TIME_DEFAULT: "; //############################################################################################################3
static const std::string ELAPSED_TIME_TAG_SILENT = ";_ELAPSED_TIME_SILENT: "; //static const std::string ELAPSED_TIME_TAG_DEFAULT = ";_ELAPSED_TIME_DEFAULT: ";
//static const std::string ELAPSED_TIME_TAG_SILENT = ";_ELAPSED_TIME_SILENT: ";
static const std::string REMAINING_TIME_CMD = "M73"; //
//static const std::string REMAINING_TIME_CMD = "M73";
//############################################################################################################3
#if ENABLE_MOVE_STATS #if ENABLE_MOVE_STATS
static const std::string MOVE_TYPE_STR[Slic3r::GCodeTimeEstimator::Block::Num_Types] = static const std::string MOVE_TYPE_STR[Slic3r::GCodeTimeEstimator::Block::Num_Types] =
@ -93,8 +106,19 @@ namespace Slic3r {
return ::sqrt(value); return ::sqrt(value);
} }
//#################################################################################################################
GCodeTimeEstimator::Block::Time::Time()
: elapsed(-1.0f)
, remaining(-1.0f)
{
}
//#################################################################################################################
GCodeTimeEstimator::Block::Block() GCodeTimeEstimator::Block::Block()
: st_synchronized(false) : st_synchronized(false)
//#################################################################################################################
, g1_line_id(0)
//#################################################################################################################
{ {
} }
@ -159,6 +183,13 @@ namespace Slic3r {
trapezoid.decelerate_after = accelerate_distance + cruise_distance; trapezoid.decelerate_after = accelerate_distance + cruise_distance;
} }
//#################################################################################################################
void GCodeTimeEstimator::Block::calculate_remaining_time(float final_time)
{
time.remaining = (time.elapsed >= 0.0f) ? final_time - time.elapsed : -1.0f;
}
//#################################################################################################################
float GCodeTimeEstimator::Block::max_allowable_speed(float acceleration, float target_velocity, float distance) float GCodeTimeEstimator::Block::max_allowable_speed(float acceleration, float target_velocity, float distance)
{ {
// to avoid invalid negative numbers due to numerical imprecision // to avoid invalid negative numbers due to numerical imprecision
@ -217,6 +248,10 @@ namespace Slic3r {
_reset_time(); _reset_time();
_set_blocks_st_synchronize(false); _set_blocks_st_synchronize(false);
_calculate_time(); _calculate_time();
//#################################################################################################################
if (are_remaining_times_enabled())
_calculate_remaining_times();
//#################################################################################################################
#if ENABLE_MOVE_STATS #if ENABLE_MOVE_STATS
_log_moves_stats(); _log_moves_stats();
@ -265,82 +300,180 @@ namespace Slic3r {
#endif // ENABLE_MOVE_STATS #endif // ENABLE_MOVE_STATS
} }
std::string GCodeTimeEstimator::get_elapsed_time_string() //############################################################################################################3
{ // std::string GCodeTimeEstimator::get_elapsed_time_string()
calculate_time(); // {
switch (_mode) // calculate_time();
{ // switch (_mode)
default: // {
case Default: // default:
return ELAPSED_TIME_TAG_DEFAULT + std::to_string(get_time()) + "\n"; // case Default:
case Silent: // return ELAPSED_TIME_TAG_DEFAULT + std::to_string(get_time()) + "\n";
return ELAPSED_TIME_TAG_SILENT + std::to_string(get_time()) + "\n"; // case Silent:
} // return ELAPSED_TIME_TAG_SILENT + std::to_string(get_time()) + "\n";
} // }
// }
//
// bool GCodeTimeEstimator::post_process_elapsed_times(const std::string& filename, float default_time, float silent_time)
// {
// boost::nowide::ifstream in(filename);
// if (!in.good())
// throw std::runtime_error(std::string("Remaining times estimation failed.\nCannot open file for reading.\n"));
//
// std::string path_tmp = filename + ".times";
//
// FILE* out = boost::nowide::fopen(path_tmp.c_str(), "wb");
// if (out == nullptr)
// throw std::runtime_error(std::string("Remaining times estimation failed.\nCannot open file for writing.\n"));
//
// std::string line;
// while (std::getline(in, line))
// {
// if (!in.good())
// {
// fclose(out);
// throw std::runtime_error(std::string("Remaining times estimation failed.\nError while reading from file.\n"));
// }
//
// // this function expects elapsed time for default and silent mode to be into two consecutive lines inside the gcode
// if (boost::contains(line, ELAPSED_TIME_TAG_DEFAULT))
// {
// std::string default_elapsed_time_str = line.substr(ELAPSED_TIME_TAG_DEFAULT.length());
// float elapsed_time = (float)atof(default_elapsed_time_str.c_str());
// float remaining_time = default_time - elapsed_time;
// line = REMAINING_TIME_CMD + " P" + std::to_string((int)(100.0f * elapsed_time / default_time));
// line += " R" + _get_time_minutes(remaining_time);
//
// std::string next_line;
// std::getline(in, next_line);
// if (!in.good())
// {
// fclose(out);
// throw std::runtime_error(std::string("Remaining times estimation failed.\nError while reading from file.\n"));
// }
//
// if (boost::contains(next_line, ELAPSED_TIME_TAG_SILENT))
// {
// std::string silent_elapsed_time_str = next_line.substr(ELAPSED_TIME_TAG_SILENT.length());
// float elapsed_time = (float)atof(silent_elapsed_time_str.c_str());
// float remaining_time = silent_time - elapsed_time;
// line += " Q" + std::to_string((int)(100.0f * elapsed_time / silent_time));
// line += " S" + _get_time_minutes(remaining_time);
// }
// else
// // found horphaned default elapsed time, skip the remaining time line output
// line = next_line;
// }
// else if (boost::contains(line, ELAPSED_TIME_TAG_SILENT))
// // found horphaned silent elapsed time, skip the remaining time line output
// continue;
//
// line += "\n";
// fwrite((const void*)line.c_str(), 1, line.length(), out);
// if (ferror(out))
// {
// in.close();
// fclose(out);
// boost::nowide::remove(path_tmp.c_str());
// throw std::runtime_error(std::string("Remaining times estimation failed.\nIs the disk full?\n"));
// }
// }
//
// fclose(out);
// in.close();
//
// boost::nowide::remove(filename.c_str());
// if (boost::nowide::rename(path_tmp.c_str(), filename.c_str()) != 0)
// throw std::runtime_error(std::string("Failed to rename the output G-code file from ") + path_tmp + " to " + filename + '\n' +
// "Is " + path_tmp + " locked?" + '\n');
//
// return true;
// }
//############################################################################################################3
bool GCodeTimeEstimator::post_process_elapsed_times(const std::string& filename, float default_time, float silent_time) //#################################################################################################################
bool GCodeTimeEstimator::post_process_remaining_times(const std::string& filename, float interval)
{ {
boost::nowide::ifstream in(filename); boost::nowide::ifstream in(filename);
if (!in.good()) if (!in.good())
throw std::runtime_error(std::string("Remaining times estimation failed.\nCannot open file for reading.\n")); throw std::runtime_error(std::string("Remaining times export failed.\nCannot open file for reading.\n"));
std::string path_tmp = filename + ".times"; std::string path_tmp = filename + ".times";
FILE* out = boost::nowide::fopen(path_tmp.c_str(), "wb"); FILE* out = boost::nowide::fopen(path_tmp.c_str(), "wb");
if (out == nullptr) if (out == nullptr)
throw std::runtime_error(std::string("Remaining times estimation failed.\nCannot open file for writing.\n")); throw std::runtime_error(std::string("Remaining times export failed.\nCannot open file for writing.\n"));
std::string line; std::string time_mask;
while (std::getline(in, line)) switch (_mode)
{
default:
case Normal:
{
time_mask = "M73 P%s R%s\n";
break;
}
case Silent:
{
time_mask = "M73 Q%s S%s\n";
break;
}
}
unsigned int g1_lines_count = 0;
float last_recorded_time = _time;
std::string gcode_line;
while (std::getline(in, gcode_line))
{ {
if (!in.good()) if (!in.good())
{ {
fclose(out); fclose(out);
throw std::runtime_error(std::string("Remaining times estimation failed.\nError while reading from file.\n")); throw std::runtime_error(std::string("Remaining times export failed.\nError while reading from file.\n"));
} }
// this function expects elapsed time for default and silent mode to be into two consecutive lines inside the gcode // saves back the line
if (boost::contains(line, ELAPSED_TIME_TAG_DEFAULT)) gcode_line += "\n";
{ fwrite((const void*)gcode_line.c_str(), 1, gcode_line.length(), out);
std::string default_elapsed_time_str = line.substr(ELAPSED_TIME_TAG_DEFAULT.length());
float elapsed_time = (float)atof(default_elapsed_time_str.c_str());
float remaining_time = default_time - elapsed_time;
line = REMAINING_TIME_CMD + " P" + std::to_string((int)(100.0f * elapsed_time / default_time));
line += " R" + _get_time_minutes(remaining_time);
std::string next_line;
std::getline(in, next_line);
if (!in.good())
{
fclose(out);
throw std::runtime_error(std::string("Remaining times estimation failed.\nError while reading from file.\n"));
}
if (boost::contains(next_line, ELAPSED_TIME_TAG_SILENT))
{
std::string silent_elapsed_time_str = next_line.substr(ELAPSED_TIME_TAG_SILENT.length());
float elapsed_time = (float)atof(silent_elapsed_time_str.c_str());
float remaining_time = silent_time - elapsed_time;
line += " Q" + std::to_string((int)(100.0f * elapsed_time / silent_time));
line += " S" + _get_time_minutes(remaining_time);
}
else
// found horphaned default elapsed time, skip the remaining time line output
line = next_line;
}
else if (boost::contains(line, ELAPSED_TIME_TAG_SILENT))
// found horphaned silent elapsed time, skip the remaining time line output
continue;
line += "\n";
fwrite((const void*)line.c_str(), 1, line.length(), out);
if (ferror(out)) if (ferror(out))
{ {
in.close(); in.close();
fclose(out); fclose(out);
boost::nowide::remove(path_tmp.c_str()); boost::nowide::remove(path_tmp.c_str());
throw std::runtime_error(std::string("Remaining times estimation failed.\nIs the disk full?\n")); throw std::runtime_error(std::string("Remaining times export failed.\nIs the disk full?\n"));
} }
// add remaining time lines where needed
_parser.parse_line(gcode_line,
[this, &g1_lines_count, &last_recorded_time, &in, &out, &path_tmp, time_mask, interval](GCodeReader& reader, const GCodeReader::GCodeLine& line)
{
if (line.cmd_is("G1"))
{
++g1_lines_count;
for (const Block& block : _blocks)
{
if (block.g1_line_id == g1_lines_count)
{
if ((last_recorded_time == _time) || (last_recorded_time - block.time.remaining > interval))
{
char buffer[1024];
sprintf(buffer, time_mask.c_str(), std::to_string((int)(100.0f * block.time.elapsed / _time)).c_str(), _get_time_minutes(block.time.remaining).c_str());
fwrite((const void*)buffer, 1, ::strlen(buffer), out);
if (ferror(out))
{
in.close();
fclose(out);
boost::nowide::remove(path_tmp.c_str());
throw std::runtime_error(std::string("Remaining times export failed.\nIs the disk full?\n"));
}
last_recorded_time = block.time.remaining;
break;
}
}
}
}
});
} }
fclose(out); fclose(out);
@ -353,6 +486,7 @@ namespace Slic3r {
return true; return true;
} }
//#################################################################################################################
void GCodeTimeEstimator::set_axis_position(EAxis axis, float position) void GCodeTimeEstimator::set_axis_position(EAxis axis, float position)
{ {
@ -371,6 +505,25 @@ namespace Slic3r {
void GCodeTimeEstimator::set_axis_max_jerk(EAxis axis, float jerk) void GCodeTimeEstimator::set_axis_max_jerk(EAxis axis, float jerk)
{ {
//############################################################################################################3
if ((axis == X) || (axis == Y))
{
switch (_mode)
{
default:
case Normal:
{
jerk = std::min(jerk, NORMAL_AXIS_MAX_JERK[axis]);
break;
}
case Silent:
{
jerk = std::min(jerk, SILENT_AXIS_MAX_JERK[axis]);
break;
}
}
}
//############################################################################################################3
_state.axis[axis].max_jerk = jerk; _state.axis[axis].max_jerk = jerk;
} }
@ -494,6 +647,33 @@ namespace Slic3r {
return _state.e_local_positioning_type; return _state.e_local_positioning_type;
} }
//#################################################################################################################
bool GCodeTimeEstimator::are_remaining_times_enabled() const
{
return _state.remaining_times_enabled;
}
void GCodeTimeEstimator::set_remaining_times_enabled(bool enable)
{
_state.remaining_times_enabled = enable;
}
int GCodeTimeEstimator::get_g1_line_id() const
{
return _state.g1_line_id;
}
void GCodeTimeEstimator::increment_g1_line_id()
{
++_state.g1_line_id;
}
void GCodeTimeEstimator::reset_g1_line_id()
{
_state.g1_line_id = 0;
}
//#################################################################################################################
void GCodeTimeEstimator::add_additional_time(float timeSec) void GCodeTimeEstimator::add_additional_time(float timeSec)
{ {
_state.additional_time += timeSec; _state.additional_time += timeSec;
@ -515,13 +695,22 @@ namespace Slic3r {
set_dialect(gcfRepRap); set_dialect(gcfRepRap);
set_global_positioning_type(Absolute); set_global_positioning_type(Absolute);
set_e_local_positioning_type(Absolute); set_e_local_positioning_type(Absolute);
//#################################################################################################################
set_remaining_times_enabled(false);
//#################################################################################################################
switch (_mode) switch (_mode)
{ {
default: default:
case Default: //############################################################################################################3
case Normal:
// case Default:
//############################################################################################################3
{ {
_set_default_as_default(); //############################################################################################################3
_set_default_as_normal();
// _set_default_as_default();
//############################################################################################################3
break; break;
} }
case Silent: case Silent:
@ -567,6 +756,10 @@ namespace Slic3r {
set_axis_position(Z, 0.0f); set_axis_position(Z, 0.0f);
set_additional_time(0.0f); set_additional_time(0.0f);
//############################################################################################################3
reset_g1_line_id();
//############################################################################################################3
} }
void GCodeTimeEstimator::_reset_time() void GCodeTimeEstimator::_reset_time()
@ -579,22 +772,61 @@ namespace Slic3r {
_blocks.clear(); _blocks.clear();
} }
void GCodeTimeEstimator::_set_default_as_default() //############################################################################################################3
void GCodeTimeEstimator::_set_default_as_normal()
// void GCodeTimeEstimator::_set_default_as_default()
//############################################################################################################3
{ {
set_feedrate(DEFAULT_FEEDRATE); //############################################################################################################3
set_acceleration(DEFAULT_ACCELERATION); set_feedrate(NORMAL_FEEDRATE);
set_retract_acceleration(DEFAULT_RETRACT_ACCELERATION); set_acceleration(NORMAL_ACCELERATION);
set_minimum_feedrate(DEFAULT_MINIMUM_FEEDRATE); set_retract_acceleration(NORMAL_RETRACT_ACCELERATION);
set_minimum_travel_feedrate(DEFAULT_MINIMUM_TRAVEL_FEEDRATE); set_minimum_feedrate(NORMAL_MINIMUM_FEEDRATE);
set_extrude_factor_override_percentage(DEFAULT_EXTRUDE_FACTOR_OVERRIDE_PERCENTAGE); set_minimum_travel_feedrate(NORMAL_MINIMUM_TRAVEL_FEEDRATE);
set_extrude_factor_override_percentage(NORMAL_EXTRUDE_FACTOR_OVERRIDE_PERCENTAGE);
for (unsigned char a = X; a < Num_Axis; ++a) for (unsigned char a = X; a < Num_Axis; ++a)
{ {
EAxis axis = (EAxis)a; EAxis axis = (EAxis)a;
set_axis_max_feedrate(axis, DEFAULT_AXIS_MAX_FEEDRATE[a]); set_axis_max_feedrate(axis, NORMAL_AXIS_MAX_FEEDRATE[a]);
set_axis_max_acceleration(axis, DEFAULT_AXIS_MAX_ACCELERATION[a]); set_axis_max_acceleration(axis, NORMAL_AXIS_MAX_ACCELERATION[a]);
set_axis_max_jerk(axis, DEFAULT_AXIS_MAX_JERK[a]); set_axis_max_jerk(axis, NORMAL_AXIS_MAX_JERK[a]);
} }
std::cout << "Normal Default" << std::endl;
std::cout << "set_acceleration " << NORMAL_ACCELERATION << std::endl;
std::cout << "set_retract_acceleration " << NORMAL_RETRACT_ACCELERATION << std::endl;
std::cout << "set_minimum_feedrate " << NORMAL_MINIMUM_FEEDRATE << std::endl;
std::cout << "set_minimum_travel_feedrate " << NORMAL_MINIMUM_TRAVEL_FEEDRATE << std::endl;
std::cout << "set_axis_max_acceleration X " << NORMAL_AXIS_MAX_ACCELERATION[X] << std::endl;
std::cout << "set_axis_max_acceleration Y " << NORMAL_AXIS_MAX_ACCELERATION[Y] << std::endl;
std::cout << "set_axis_max_acceleration Z " << NORMAL_AXIS_MAX_ACCELERATION[Z] << std::endl;
std::cout << "set_axis_max_acceleration E " << NORMAL_AXIS_MAX_ACCELERATION[E] << std::endl;
std::cout << "set_axis_max_feedrate X " << NORMAL_AXIS_MAX_FEEDRATE[X] << std::endl;
std::cout << "set_axis_max_feedrate Y " << NORMAL_AXIS_MAX_FEEDRATE[Y] << std::endl;
std::cout << "set_axis_max_feedrate Z " << NORMAL_AXIS_MAX_FEEDRATE[Z] << std::endl;
std::cout << "set_axis_max_feedrate E " << NORMAL_AXIS_MAX_FEEDRATE[E] << std::endl;
std::cout << "set_axis_max_jerk X " << NORMAL_AXIS_MAX_JERK[X] << std::endl;
std::cout << "set_axis_max_jerk Y " << NORMAL_AXIS_MAX_JERK[Y] << std::endl;
std::cout << "set_axis_max_jerk Z " << NORMAL_AXIS_MAX_JERK[Z] << std::endl;
std::cout << "set_axis_max_jerk E " << NORMAL_AXIS_MAX_JERK[E] << std::endl;
// set_feedrate(DEFAULT_FEEDRATE);
// set_acceleration(DEFAULT_ACCELERATION);
// set_retract_acceleration(DEFAULT_RETRACT_ACCELERATION);
// set_minimum_feedrate(DEFAULT_MINIMUM_FEEDRATE);
// set_minimum_travel_feedrate(DEFAULT_MINIMUM_TRAVEL_FEEDRATE);
// set_extrude_factor_override_percentage(DEFAULT_EXTRUDE_FACTOR_OVERRIDE_PERCENTAGE);
//
// for (unsigned char a = X; a < Num_Axis; ++a)
// {
// EAxis axis = (EAxis)a;
// set_axis_max_feedrate(axis, DEFAULT_AXIS_MAX_FEEDRATE[a]);
// set_axis_max_acceleration(axis, DEFAULT_AXIS_MAX_ACCELERATION[a]);
// set_axis_max_jerk(axis, DEFAULT_AXIS_MAX_JERK[a]);
// }
//############################################################################################################3
} }
void GCodeTimeEstimator::_set_default_as_silent() void GCodeTimeEstimator::_set_default_as_silent()
@ -631,7 +863,10 @@ namespace Slic3r {
_time += get_additional_time(); _time += get_additional_time();
for (const Block& block : _blocks) //##########################################################################################################################
for (Block& block : _blocks)
// for (const Block& block : _blocks)
//##########################################################################################################################
{ {
if (block.st_synchronized) if (block.st_synchronized)
continue; continue;
@ -642,6 +877,9 @@ namespace Slic3r {
block_time += block.cruise_time(); block_time += block.cruise_time();
block_time += block.deceleration_time(); block_time += block.deceleration_time();
_time += block_time; _time += block_time;
//##########################################################################################################################
block.time.elapsed = _time;
//##########################################################################################################################
MovesStatsMap::iterator it = _moves_stats.find(block.move_type); MovesStatsMap::iterator it = _moves_stats.find(block.move_type);
if (it == _moves_stats.end()) if (it == _moves_stats.end())
@ -653,10 +891,23 @@ namespace Slic3r {
_time += block.acceleration_time(); _time += block.acceleration_time();
_time += block.cruise_time(); _time += block.cruise_time();
_time += block.deceleration_time(); _time += block.deceleration_time();
//##########################################################################################################################
block.time.elapsed = _time;
//##########################################################################################################################
#endif // ENABLE_MOVE_STATS #endif // ENABLE_MOVE_STATS
} }
} }
//#################################################################################################################
void GCodeTimeEstimator::_calculate_remaining_times()
{
for (Block& block : _blocks)
{
block.calculate_remaining_time(_time);
}
}
//#################################################################################################################
void GCodeTimeEstimator::_process_gcode_line(GCodeReader&, const GCodeReader::GCodeLine& line) void GCodeTimeEstimator::_process_gcode_line(GCodeReader&, const GCodeReader::GCodeLine& line)
{ {
PROFILE_FUNC(); PROFILE_FUNC();
@ -790,6 +1041,10 @@ namespace Slic3r {
void GCodeTimeEstimator::_processG1(const GCodeReader::GCodeLine& line) void GCodeTimeEstimator::_processG1(const GCodeReader::GCodeLine& line)
{ {
//############################################################################################################3
increment_g1_line_id();
//############################################################################################################3
// updates axes positions from line // updates axes positions from line
EUnits units = get_units(); EUnits units = get_units();
float new_pos[Num_Axis]; float new_pos[Num_Axis];
@ -808,6 +1063,9 @@ namespace Slic3r {
// fills block data // fills block data
Block block; Block block;
//############################################################################################################3
block.g1_line_id = get_g1_line_id();
//############################################################################################################3
// calculates block movement deltas // calculates block movement deltas
float max_abs_delta = 0.0f; float max_abs_delta = 0.0f;

67
xs/src/libslic3r/GCodeTimeEstimator.hpp
View file

@ -19,7 +19,10 @@ namespace Slic3r {
public: public:
enum EMode : unsigned char enum EMode : unsigned char
{ {
Default, //#######################################################################################################################################################################
Normal,
// Default,
//#######################################################################################################################################################################
Silent Silent
}; };
@ -77,6 +80,10 @@ namespace Slic3r {
float minimum_feedrate; // mm/s float minimum_feedrate; // mm/s
float minimum_travel_feedrate; // mm/s float minimum_travel_feedrate; // mm/s
float extrude_factor_override_percentage; float extrude_factor_override_percentage;
//#################################################################################################################
bool remaining_times_enabled;
unsigned int g1_line_id;
//#################################################################################################################
}; };
public: public:
@ -127,6 +134,15 @@ namespace Slic3r {
bool nominal_length; bool nominal_length;
}; };
//#################################################################################################################
struct Time
{
float elapsed;
float remaining;
Time();
};
//#################################################################################################################
#if ENABLE_MOVE_STATS #if ENABLE_MOVE_STATS
EMoveType move_type; EMoveType move_type;
@ -140,6 +156,10 @@ namespace Slic3r {
FeedrateProfile feedrate; FeedrateProfile feedrate;
Trapezoid trapezoid; Trapezoid trapezoid;
//#################################################################################################################
Time time;
unsigned int g1_line_id;
//#################################################################################################################
bool st_synchronized; bool st_synchronized;
@ -169,6 +189,10 @@ namespace Slic3r {
// Calculates this block's trapezoid // Calculates this block's trapezoid
void calculate_trapezoid(); void calculate_trapezoid();
//#################################################################################################################
void calculate_remaining_time(float final_time);
//#################################################################################################################
// Calculates the maximum allowable speed at this point when you must be able to reach target_velocity using the // Calculates the maximum allowable speed at this point when you must be able to reach target_velocity using the
// acceleration within the allotted distance. // acceleration within the allotted distance.
static float max_allowable_speed(float acceleration, float target_velocity, float distance); static float max_allowable_speed(float acceleration, float target_velocity, float distance);
@ -231,12 +255,25 @@ namespace Slic3r {
// Calculates the time estimate from the gcode contained in given list of gcode lines // Calculates the time estimate from the gcode contained in given list of gcode lines
void calculate_time_from_lines(const std::vector<std::string>& gcode_lines); void calculate_time_from_lines(const std::vector<std::string>& gcode_lines);
// Calculates the time estimate from the gcode lines added using add_gcode_line() or add_gcode_block() //############################################################################################################3
// and returns it in a formatted string // // Calculates the time estimate from the gcode lines added using add_gcode_line() or add_gcode_block()
std::string get_elapsed_time_string(); // // and returns it in a formatted string
// std::string get_elapsed_time_string();
//############################################################################################################3
// Converts elapsed time lines, contained in the gcode saved with the given filename, into remaining time commands //############################################################################################################3
static bool post_process_elapsed_times(const std::string& filename, float default_time, float silent_time); // // Converts elapsed time lines, contained in the gcode saved with the given filename, into remaining time commands
// static bool post_process_elapsed_times(const std::string& filename, float default_time, float silent_time);
//############################################################################################################3
//#################################################################################################################
// Process the gcode contained in the file with the given filename,
// placing in it new lines (M73) containing the remaining time, at the given interval in seconds
// and saving the result back in the same file
// This time estimator should have been already used to calculate the time estimate for the gcode
// contained in the given file before to call this method
bool post_process_remaining_times(const std::string& filename, float interval_sec);
//#################################################################################################################
// Set current position on the given axis with the given value // Set current position on the given axis with the given value
void set_axis_position(EAxis axis, float position); void set_axis_position(EAxis axis, float position);
@ -282,6 +319,15 @@ namespace Slic3r {
void set_e_local_positioning_type(EPositioningType type); void set_e_local_positioning_type(EPositioningType type);
EPositioningType get_e_local_positioning_type() const; EPositioningType get_e_local_positioning_type() const;
//#################################################################################################################
bool are_remaining_times_enabled() const;
void set_remaining_times_enabled(bool enable);
int get_g1_line_id() const;
void increment_g1_line_id();
void reset_g1_line_id();
//#################################################################################################################
void add_additional_time(float timeSec); void add_additional_time(float timeSec);
void set_additional_time(float timeSec); void set_additional_time(float timeSec);
float get_additional_time() const; float get_additional_time() const;
@ -305,7 +351,10 @@ namespace Slic3r {
void _reset_time(); void _reset_time();
void _reset_blocks(); void _reset_blocks();
void _set_default_as_default(); //############################################################################################################3
void _set_default_as_normal();
// void _set_default_as_default();
//############################################################################################################3
void _set_default_as_silent(); void _set_default_as_silent();
void _set_blocks_st_synchronize(bool state); void _set_blocks_st_synchronize(bool state);
@ -313,6 +362,10 @@ namespace Slic3r {
// Calculates the time estimate // Calculates the time estimate
void _calculate_time(); void _calculate_time();
//#################################################################################################################
void _calculate_remaining_times();
//#################################################################################################################
// Processes the given gcode line // Processes the given gcode line
void _process_gcode_line(GCodeReader&, const GCodeReader::GCodeLine& line); void _process_gcode_line(GCodeReader&, const GCodeReader::GCodeLine& line);

5
xs/src/libslic3r/Print.hpp
View file

@ -235,7 +235,10 @@ public:
PrintRegionPtrs regions; PrintRegionPtrs regions;
PlaceholderParser placeholder_parser; PlaceholderParser placeholder_parser;
// TODO: status_cb // TODO: status_cb
std::string estimated_default_print_time; //#######################################################################################################################################################################
std::string estimated_normal_print_time;
// std::string estimated_default_print_time;
//#######################################################################################################################################################################
std::string estimated_silent_print_time; std::string estimated_silent_print_time;
double total_used_filament, total_extruded_volume, total_cost, total_weight; double total_used_filament, total_extruded_volume, total_cost, total_weight;
std::map<size_t, float> filament_stats; std::map<size_t, float> filament_stats;

10
xs/src/libslic3r/PrintConfig.cpp
View file

@ -936,7 +936,10 @@ PrintConfigDef::PrintConfigDef()
def->sidetext = L("mm/s²"); def->sidetext = L("mm/s²");
def->min = 0; def->min = 0;
def->width = machine_limits_opt_width; def->width = machine_limits_opt_width;
def->default_value = new ConfigOptionFloats(1500., 1250.); //##################################################################################################################################
def->default_value = new ConfigOptionFloats{ 1500., 1250. };
// def->default_value = new ConfigOptionFloats(1500., 1250.);
//##################################################################################################################################
// M204 T... [mm/sec^2] // M204 T... [mm/sec^2]
def = this->add("machine_max_acceleration_retracting", coFloats); def = this->add("machine_max_acceleration_retracting", coFloats);
@ -946,7 +949,10 @@ PrintConfigDef::PrintConfigDef()
def->sidetext = L("mm/s²"); def->sidetext = L("mm/s²");
def->min = 0; def->min = 0;
def->width = machine_limits_opt_width; def->width = machine_limits_opt_width;
def->default_value = new ConfigOptionFloats(1500., 1250.); //##################################################################################################################################
def->default_value = new ConfigOptionFloats{ 1500., 1250. };
// def->default_value = new ConfigOptionFloats(1500., 1250.);
//##################################################################################################################################
def = this->add("max_fan_speed", coInts); def = this->add("max_fan_speed", coInts);
def->label = L("Max"); def->label = L("Max");

4
xs/xsp/Print.xsp
View file

@ -145,8 +145,8 @@ _constant()
%code%{ RETVAL = &THIS->skirt; %}; %code%{ RETVAL = &THIS->skirt; %};
Ref<ExtrusionEntityCollection> brim() Ref<ExtrusionEntityCollection> brim()
%code%{ RETVAL = &THIS->brim; %}; %code%{ RETVAL = &THIS->brim; %};
std::string estimated_default_print_time() std::string estimated_normal_print_time()
%code%{ RETVAL = THIS->estimated_default_print_time; %}; %code%{ RETVAL = THIS->estimated_normal_print_time; %};
std::string estimated_silent_print_time() std::string estimated_silent_print_time()
%code%{ RETVAL = THIS->estimated_silent_print_time; %}; %code%{ RETVAL = THIS->estimated_silent_print_time; %};