From 05961f7c98803a42871b8df855bfff6a102936c4 Mon Sep 17 00:00:00 2001 From: Noisyfox Date: Thu, 29 Feb 2024 11:22:16 +0800 Subject: [PATCH 1/2] The correct way of calculating the rate limit --- src/libslic3r/GCode/PressureEqualizer.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libslic3r/GCode/PressureEqualizer.cpp b/src/libslic3r/GCode/PressureEqualizer.cpp index 9eee893a1a0..06563ebb148 100644 --- a/src/libslic3r/GCode/PressureEqualizer.cpp +++ b/src/libslic3r/GCode/PressureEqualizer.cpp @@ -633,7 +633,7 @@ void PressureEqualizer::adjust_volumetric_rate(const size_t fist_line_idx, const } if (line.adjustable_flow) { - float rate_start = rate_end + rate_slope * line.time_corrected(); + float rate_start = sqrt(rate_end * rate_end + 2 * line.volumetric_extrusion_rate * line.dist_xyz() * rate_slope / line.feedrate()); if (rate_start < line.volumetric_extrusion_rate_start) { // Limit the volumetric extrusion rate at the start of this segment due to a segment // of ExtrusionType iRole, which will be extruded in the future. @@ -690,7 +690,7 @@ void PressureEqualizer::adjust_volumetric_rate(const size_t fist_line_idx, const } if (line.adjustable_flow) { - float rate_end = rate_start + rate_slope * line.time_corrected(); + float rate_end = sqrt(rate_start * rate_start + 2 * line.volumetric_extrusion_rate * line.dist_xyz() * rate_slope / line.feedrate()); if (rate_end < line.volumetric_extrusion_rate_end) { // Limit the volumetric extrusion rate at the start of this segment due to a segment // of ExtrusionType iRole, which was extruded before. From 773cba7cd37a13fa07ea53fed4e33a30b6ae6b20 Mon Sep 17 00:00:00 2001 From: Noisyfox Date: Thu, 29 Feb 2024 20:14:24 +0800 Subject: [PATCH 2/2] Add pressure equalizer in print by object mode --- src/libslic3r/GCode.cpp | 33 ++++++++++++++++++++++++++------- 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/src/libslic3r/GCode.cpp b/src/libslic3r/GCode.cpp index e9a85a1ea15..323d22a7c54 100644 --- a/src/libslic3r/GCode.cpp +++ b/src/libslic3r/GCode.cpp @@ -2815,7 +2815,7 @@ void GCode::process_layers( const auto generator = tbb::make_filter(slic3r_tbb_filtermode::serial_in_order, [this, &print, &tool_ordering, &print_object_instances_ordering, &layers_to_print, &layer_to_print_idx](tbb::flow_control& fc) -> LayerResult { if (layer_to_print_idx >= layers_to_print.size()) { - if ((!m_pressure_equalizer && layer_to_print_idx == layers_to_print.size()) || (m_pressure_equalizer && layer_to_print_idx == (layers_to_print.size() + 1))) { + if (layer_to_print_idx == layers_to_print.size() + (m_pressure_equalizer ? 1 : 0)) { fc.stop(); return {}; } else { @@ -2911,9 +2911,16 @@ void GCode::process_layers( size_t layer_to_print_idx = 0; const auto generator = tbb::make_filter(slic3r_tbb_filtermode::serial_in_order, [this, &print, &tool_ordering, &layers_to_print, &layer_to_print_idx, single_object_idx, prime_extruder](tbb::flow_control& fc) -> LayerResult { - if (layer_to_print_idx == layers_to_print.size()) { - fc.stop(); - return {}; + if (layer_to_print_idx >= layers_to_print.size()) { + if (layer_to_print_idx == layers_to_print.size() + (m_pressure_equalizer ? 1 : 0)) { + fc.stop(); + return {}; + } else { + // Pressure equalizer need insert empty input. Because it returns one layer back. + // Insert NOP (no operation) layer; + ++layer_to_print_idx; + return LayerResult::make_nop_layer_result(); + } } else { LayerToPrint &layer = layers_to_print[layer_to_print_idx ++]; print.set_status(80, Slic3r::format(_(L("Generating G-code: layer %1%")), std::to_string(layer_to_print_idx))); @@ -2930,12 +2937,20 @@ void GCode::process_layers( } const auto spiral_mode = tbb::make_filter(slic3r_tbb_filtermode::serial_in_order, [&spiral_mode = *this->m_spiral_vase.get(), &layers_to_print](LayerResult in)->LayerResult { + if (in.nop_layer_result) + return in; spiral_mode.enable(in.spiral_vase_enable); bool last_layer = in.layer_id == layers_to_print.size() - 1; return { spiral_mode.process_layer(std::move(in.gcode), last_layer), in.layer_id, in.spiral_vase_enable, in.cooling_buffer_flush }; }); + const auto pressure_equalizer = tbb::make_filter(slic3r_tbb_filtermode::serial_in_order, + [pressure_equalizer = this->m_pressure_equalizer.get()](LayerResult in) -> LayerResult { + return pressure_equalizer->process_layer(std::move(in)); + }); const auto cooling = tbb::make_filter(slic3r_tbb_filtermode::serial_in_order, [&cooling_buffer = *this->m_cooling_buffer.get()](LayerResult in)->std::string { + if (in.nop_layer_result) + return in.gcode; return cooling_buffer.process_layer(std::move(in.gcode), in.layer_id, in.cooling_buffer_flush); }); const auto output = tbb::make_filter(slic3r_tbb_filtermode::serial_in_order, @@ -2961,10 +2976,14 @@ void GCode::process_layers( }); // The pipeline elements are joined using const references, thus no copying is performed. - if (m_spiral_vase) - tbb::parallel_pipeline(12, generator & spiral_mode & cooling & fan_mover & output); + if (m_spiral_vase && m_pressure_equalizer) + tbb::parallel_pipeline(12, generator & spiral_mode & pressure_equalizer & cooling & fan_mover & output); + else if (m_spiral_vase) + tbb::parallel_pipeline(12, generator & spiral_mode & cooling & fan_mover & output); + else if (m_pressure_equalizer) + tbb::parallel_pipeline(12, generator & pressure_equalizer & cooling & fan_mover & output); else - tbb::parallel_pipeline(12, generator & cooling & fan_mover & output); + tbb::parallel_pipeline(12, generator & cooling & fan_mover & output); } std::string GCode::placeholder_parser_process(const std::string &name, const std::string &templ, unsigned int current_extruder_id, const DynamicConfig *config_override)