Add layer change G-code, set more print variables

src/libslic3r/GCode.cpp

@@ -1451,7 +1451,9 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
     // How many times will be change_layer() called?
     // change_layer() in turn increments the progress bar status.
     m_layer_count = 0;
-    if (print.config().print_sequence == PrintSequence::ByObject) {
+    if (print.calib_params().mode == CalibMode::Calib_PA_Pattern) {
+        m_layer_count = CalibPressureAdvancePattern(this).num_layers();
+    } else if (print.config().print_sequence == PrintSequence::ByObject) {
         // Add each of the object's layers separately.
         for (auto object : print.objects()) {
             //BBS: fix the issue that total layer is not right
@@ -1896,7 +1898,70 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
                 gcode += pa_test.generate_test(params.start, params.step, std::llround(std::ceil((params.end - params.start) / params.step)));
         } else if (print.calib_params().mode == CalibMode::Calib_PA_Pattern) {
                 CalibPressureAdvancePattern pa_test(this);
-                gcode += pa_test.generate_test(params.start, params.end, params.step);
+                std::vector<std::string> gcode_layers = pa_test.generate_test(params.start, params.end, params.step);
+
+                m_max_layer_z = pa_test.max_layer_z();
+                coordf_t print_z;
+                bool first_layer;
+
+                for (int i = 0; i < gcode_layers.size(); ++i) {
+                    print_z = pa_test.layer_z()[i];
+
+                    first_layer = (i == 0);
+                    m_writer.set_is_first_layer(first_layer);
+
+                    // add tag for processor
+                    gcode += ";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Layer_Change) + "\n";
+                    // export layer z
+                    char buf[64];
+                    sprintf(buf, print.is_BBL_printer() ? "; Z_HEIGHT: %g\n" : ";Z:%g\n", print_z);
+                    gcode += buf;
+                    // export layer height
+                    float height = first_layer ? static_cast<float>(print_z) : static_cast<float>(print_z) - m_last_layer_z;
+                    sprintf(buf, ";%s%g\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height).c_str(), height);
+                    gcode += buf;
+                    // update caches
+                    m_last_layer_z = static_cast<float>(print_z);
+                    m_max_layer_z  = std::max(m_max_layer_z, m_last_layer_z);
+                    m_last_height = height;
+
+                    if (! print.config().before_layer_change_gcode.value.empty()) {
+                        DynamicConfig config;
+                        config.set_key_value("layer_num",   new ConfigOptionInt(m_layer_index + 1));
+                        config.set_key_value("layer_z",     new ConfigOptionFloat(print_z));
+                        config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
+                        gcode += this->placeholder_parser_process(
+                            "before_layer_change_gcode",
+                            print.config().before_layer_change_gcode.value,
+                            m_writer.extruder()->id(),
+                            &config
+                        ) + "\n";
+                    }
+                    
+                    gcode += m_writer.update_progress(++ m_layer_index, m_layer_count);
+                    m_nominal_z = print_z;
+
+                    if (! print.config().layer_change_gcode.value.empty()) {
+                        std::cout << "layer_change_gcode found" << std::endl;
+
+                        DynamicConfig config;
+                        config.set_key_value("layer_num",   new ConfigOptionInt(m_layer_index));
+                        config.set_key_value("layer_z",     new ConfigOptionFloat(print_z));
+                        std::cout << "DynamicConfig updated successfully" << std::endl;
+
+                        gcode += this->placeholder_parser_process(
+                            "layer_change_gcode",
+                            print.config().layer_change_gcode.value,
+                            m_writer.extruder()->id(),
+                            &config
+                        ) + "\n";
+                        std::cout << "returned from placeholder_parser_process" << std::endl;
+
+                        config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
+                    }
+
+                    gcode += gcode_layers[i];
+                }
         }
 
         file.write(gcode);

src/libslic3r/calib.cpp

@@ -289,7 +289,7 @@ std::string CalibPressureAdvanceLine::print_pa_lines(double start_x, double star
     return gcode.str();
 }
 
-std::string CalibPressureAdvancePattern::generate_test(double start_pa, double end_pa, double step_pa)
+std::vector<std::string> CalibPressureAdvancePattern::generate_test(double start_pa, double end_pa, double step_pa)
 {
     BoundingBoxf bed_ext = get_extents(mp_gcodegen->config().printable_area.values);
     
@@ -331,6 +331,16 @@ std::string CalibPressureAdvancePattern::generate_test(double start_pa, double e
     return print_pa_pattern(pattern_calc);
 }
 
+std::vector<double> CalibPressureAdvancePattern::layer_z() {
+    std::vector<double> layer_z;
+
+    for (int i = 0; i < m_num_layers; ++i) {
+        layer_z.push_back(m_height_first_layer + (i * m_height_layer));
+    }
+
+    return layer_z;
+}
+
 CalibPressureAdvancePattern::PatternSettings::PatternSettings() {
     GCode gc;
     const CalibPressureAdvancePattern cpap(&gc);
@@ -402,7 +412,7 @@ double CalibPressureAdvancePattern::object_size_x(int num_patterns)
 
 double CalibPressureAdvancePattern::object_size_y(double start_pa, double step_pa, int num_patterns)
 {
-    return 2 * std::sin(to_radians(m_corner_angle) / 2) * m_wall_side_length +
+    return 2 * (std::sin(to_radians(m_corner_angle) / 2) * m_wall_side_length) +
         max_numbering_height(start_pa, step_pa, num_patterns) +
         m_glyph_padding_vertical * 2 +
         line_width_anchor();
@@ -655,20 +665,23 @@ std::string CalibPressureAdvancePattern::draw_box(double min_x, double min_y, do
     return gcode.str();
 }
 
-std::string CalibPressureAdvancePattern::print_pa_pattern(PatternCalc& calc)
+std::vector<std::string> CalibPressureAdvancePattern::print_pa_pattern(PatternCalc& calc)
 {   
     auto& writer = mp_gcodegen->writer();
     std::stringstream gcode;
+    std::vector<std::string> gcode_layers;
 
     const DrawLineOptArgs draw_line_basic_settings;
     DrawLineOptArgs draw_line_opt_args;
     const DrawBoxOptArgs draw_box_basic_settings;
     DrawBoxOptArgs draw_box_opt_args;
 
-    gcode << writer.travel_to_z(m_height_first_layer, "Move to start layer height");
+    gcode << writer.travel_to_xyz(
-    gcode << move_to(Vec2d(calc.pattern_start_x, calc.pattern_start_y), "Move to start position");
+        Vec3d(calc.pattern_start_x, calc.pattern_start_y, m_height_first_layer),
+        "Move to start position"
+    );
 
-    writer.set_pressure_advance(calc.start_pa);
+    gcode << writer.set_pressure_advance(calc.start_pa);
 
     // create anchor and line numbering frame
     gcode << draw_box(
@@ -697,7 +710,22 @@ std::string CalibPressureAdvancePattern::print_pa_pattern(PatternCalc& calc)
             // set new fan speed after first layer
         }
 
-        gcode << writer.travel_to_z(m_height_first_layer + i * m_height_layer, "Move to layer height");
+        if (i > 0) {
+            gcode_layers.push_back(gcode.str());
+            std::stringstream().swap(gcode); // reset for next layer contents
+
+            Point last_pos = mp_gcodegen->last_pos();
+            std::stringstream comment;
+            comment << "move to next layer (" << i + 1 << ")";
+            gcode << writer.travel_to_xyz(
+                Vec3d(
+                    last_pos.x(),
+                    last_pos.y(),
+                    m_height_first_layer + (i * m_height_layer)
+                ),
+                comment.str()
+            );
+        }
 
         // line numbering
         if (i == 1) {
@@ -752,7 +780,7 @@ std::string CalibPressureAdvancePattern::print_pa_pattern(PatternCalc& calc)
 
         for (int j = 0; j < calc.num_patterns; ++j) {
             // increment pressure advance
-            writer.set_pressure_advance(calc.start_pa + (j * calc.step_pa));
+            gcode << writer.set_pressure_advance(calc.start_pa + (j * calc.step_pa));
 
             for (int k = 0; k < m_wall_count; ++k) {
                 to_x += std::cos(to_radians(m_corner_angle) / 2) * side_length;
@@ -786,8 +814,9 @@ std::string CalibPressureAdvancePattern::print_pa_pattern(PatternCalc& calc)
     }
 
     // set pressure advance back to start value
-    writer.set_pressure_advance(calc.start_pa);
+    gcode << writer.set_pressure_advance(calc.start_pa);
 
-    return gcode.str();
+    gcode_layers.push_back(gcode.str());
+    return gcode_layers;
 }
 } // namespace Slic3r

src/libslic3r/calib.hpp

@@ -111,16 +111,22 @@ public:
         
         m_glyph_padding_horizontal(1),
         m_glyph_padding_vertical(1)
-        { }
+        {
+            m_max_layer_z = m_height_first_layer + ((m_num_layers - 1) * m_height_layer);
+        }
     ;
     ~CalibPressureAdvancePattern() { };
 
-    std::string generate_test(
+    std::vector<std::string> generate_test(
         double start_pa = 0,
         double end_pa = 0.08,
         double step_pa = 0.005
     );
 
+    int& num_layers() { return m_num_layers; };
+    std::vector<double> layer_z();
+    double& max_layer_z() { return m_max_layer_z; }
+
 private:
     struct PatternCalc {
         PatternCalc(
@@ -239,13 +245,14 @@ private:
     std::string draw_line(double to_x, double to_y, DrawLineOptArgs opt_args = DrawLineOptArgs());
     std::string draw_box(double min_x, double min_y, double size_x, double size_y, DrawBoxOptArgs opt_args = DrawBoxOptArgs());
 
-    std::string print_pa_pattern(PatternCalc& calc);
+    std::vector<std::string> print_pa_pattern(PatternCalc& calc);
 
     double m_line_ratio;
     double m_extrusion_multiplier;
     int m_num_layers;
     double m_height_layer;
     double m_height_first_layer;
+    double m_max_layer_z;
     double m_speed_first_layer;
     double m_speed_perimeter;