Emit max value of machine limit among used extruders

src/libslic3r/GCode.cpp

@@ -3941,51 +3941,75 @@ void GCode::print_machine_envelope(GCodeOutputStream &file, Print &print)
     const auto flavor = print.config().gcode_flavor.value;
     if ((flavor == gcfMarlinLegacy || flavor == gcfMarlinFirmware || flavor == gcfRepRapFirmware) &&
         print.config().emit_machine_limits_to_gcode.value == true) {
+
+        // Get all physical tool ids current print will use
+        std::unordered_set<unsigned int> used_extruders;
+        for (const auto& extruder : m_writer.extruders()) {
+            used_extruders.insert(extruder.extruder_id());
+        }
+
+        // Get the max limit value among used extruders
+        auto get_max_value = [&used_extruders](const std::string key, const ConfigOptionFloats& v) { 
+            unsigned int stride = 1;
+            if (printer_options_with_variant_2.count(key) > 0) {
+                stride = 2;
+            }
+
+            double value = std::numeric_limits<double>::lowest();
+            for (unsigned int extruder : used_extruders) {
+                value = std::max(value, v.values[extruder * stride]);
+            }
+
+            assert(value > std::numeric_limits<double>::lowest());
+            return value;
+        };
+#define MAX_LIMIT(OPT) get_max_value(#OPT, print.config().OPT)
+
         int factor = flavor == gcfRepRapFirmware ? 60 : 1; // RRF M203 and M566 are in mm/min
         file.write_format("M201 X%d Y%d Z%d E%d\n",
-            int(print.config().machine_max_acceleration_x.values.front() + 0.5),
+            int(MAX_LIMIT(machine_max_acceleration_x) + 0.5),
-            int(print.config().machine_max_acceleration_y.values.front() + 0.5),
+            int(MAX_LIMIT(machine_max_acceleration_y) + 0.5),
-            int(print.config().machine_max_acceleration_z.values.front() + 0.5),
+            int(MAX_LIMIT(machine_max_acceleration_z) + 0.5),
-            int(print.config().machine_max_acceleration_e.values.front() + 0.5));
+            int(MAX_LIMIT(machine_max_acceleration_e) + 0.5));
         file.write_format("M203 X%d Y%d Z%d E%d\n",
-            int(print.config().machine_max_speed_x.values.front() * factor + 0.5),
+            int(MAX_LIMIT(machine_max_speed_x) * factor + 0.5),
-            int(print.config().machine_max_speed_y.values.front() * factor + 0.5),
+            int(MAX_LIMIT(machine_max_speed_y) * factor + 0.5),
-            int(print.config().machine_max_speed_z.values.front() * factor + 0.5),
+            int(MAX_LIMIT(machine_max_speed_z) * factor + 0.5),
-            int(print.config().machine_max_speed_e.values.front() * factor + 0.5));
+            int(MAX_LIMIT(machine_max_speed_e) * factor + 0.5));
 
         // Now M204 - acceleration. This one is quite hairy thanks to how Marlin guys care about
         // Legacy Marlin should export travel acceleration the same as printing acceleration.
         // MarlinFirmware has the two separated.
         int travel_acc = flavor == gcfMarlinLegacy
-                       ? int(print.config().machine_max_acceleration_extruding.values.front() + 0.5)
+                       ? int(MAX_LIMIT(machine_max_acceleration_extruding) + 0.5)
-                       : int(print.config().machine_max_acceleration_travel.values.front() + 0.5);
+                       : int(MAX_LIMIT(machine_max_acceleration_travel) + 0.5);
         if (flavor == gcfRepRapFirmware)
             file.write_format("M204 P%d T%d ; sets acceleration (P, T), mm/sec^2\n",
-                int(print.config().machine_max_acceleration_extruding.values.front() + 0.5),
+                int(MAX_LIMIT(machine_max_acceleration_extruding) + 0.5),
                 travel_acc);
         else if (flavor == gcfMarlinFirmware)
             // New Marlin uses M204 P[print] R[retract] T[travel]
             file.write_format("M204 P%d R%d T%d ; sets acceleration (P, T) and retract acceleration (R), mm/sec^2\n",
-                int(print.config().machine_max_acceleration_extruding.values.front() + 0.5),
+                int(MAX_LIMIT(machine_max_acceleration_extruding) + 0.5),
-                int(print.config().machine_max_acceleration_retracting.values.front() + 0.5),
+                int(MAX_LIMIT(machine_max_acceleration_retracting) + 0.5),
-                int(print.config().machine_max_acceleration_travel.values.front() + 0.5));
+                int(MAX_LIMIT(machine_max_acceleration_travel) + 0.5));
         else
             file.write_format("M204 P%d R%d T%d\n",
-                int(print.config().machine_max_acceleration_extruding.values.front() + 0.5),
+                int(MAX_LIMIT(machine_max_acceleration_extruding) + 0.5),
-                int(print.config().machine_max_acceleration_retracting.values.front() + 0.5),
+                int(MAX_LIMIT(machine_max_acceleration_retracting) + 0.5),
                 travel_acc);
 
         assert(is_decimal_separator_point());
         file.write_format(flavor == gcfRepRapFirmware
             ? "M566 X%.2lf Y%.2lf Z%.2lf E%.2lf ; sets the jerk limits, mm/min\n"
             : "M205 X%.2lf Y%.2lf Z%.2lf E%.2lf ; sets the jerk limits, mm/sec\n",
-            print.config().machine_max_jerk_x.values.front() * factor,
+            MAX_LIMIT(machine_max_jerk_x) * factor,
-            print.config().machine_max_jerk_y.values.front() * factor,
+            MAX_LIMIT(machine_max_jerk_y) * factor,
-            print.config().machine_max_jerk_z.values.front() * factor,
+            MAX_LIMIT(machine_max_jerk_z) * factor,
-            print.config().machine_max_jerk_e.values.front() * factor);
+            MAX_LIMIT(machine_max_jerk_e) * factor);
 
         // New Marlin uses M205 J[mm] for junction deviation (only apply if it is > 0)
-        file.write_format(writer().set_junction_deviation(config().machine_max_junction_deviation.values.front()).c_str());
+        file.write_format(writer().set_junction_deviation(MAX_LIMIT(machine_max_junction_deviation)).c_str());
 
         // Orca: Override input shaping values
         if (print.config().input_shaping_emit.value && flavor != gcfMarlinLegacy) {
@@ -3998,6 +4022,7 @@ void GCode::print_machine_envelope(GCodeOutputStream &file, Print &print)
             }
         }
     }
+#undef MAX_LIMIT
 }
 
 // BBS

tests/fff_print/test_printgcode.cpp

@@ -18,6 +18,7 @@
 
 #include <algorithm>
 #include <boost/regex.hpp>
+#include <libslic3r/ModelArrange.hpp>
 #include <boost/filesystem.hpp>
 #include <fstream>
 #include <iterator>
@@ -304,3 +305,198 @@ TEST_CASE("Sequential printing follows model order", "[PrintGCode]")
 
     REQUIRE_THAT(first_object_peak_z, Catch::Matchers::WithinAbs(20.0, 0.3));
 }
+
+// Verify that emit_machine_limits_to_gcode emits the correct max value across
+// used extruders (regression for commit b4ee665: "Emit max value of machine
+// limit among used extruders").
+TEST_CASE("Machine envelope emits max limit among used extruders", "[PrintGCode][MachineEnvelope]")
+{
+    SECTION("Single extruder emits its configured values") {
+        const std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, {
+            { "emit_machine_limits_to_gcode", "1" },
+            { "gcode_flavor",                "marlin2" },
+            { "gcode_comments",              "1" },
+            { "machine_start_gcode",         "" },
+            { "layer_height",                "0.2" },
+            { "initial_layer_print_height",  "0.2" },
+            { "initial_layer_line_width",    "0" },
+            { "z_hop",                       "0" },
+            // stride-2 options: (normal, silent)
+            { "machine_max_acceleration_x",           "500,600" },
+            { "machine_max_acceleration_y",           "700,800" },
+            { "machine_max_acceleration_z",           "100,200" },
+            { "machine_max_acceleration_e",           "5000,6000" },
+            { "machine_max_acceleration_extruding",   "1200,1300" },
+            { "machine_max_acceleration_retracting",  "1400,1500" },
+            { "machine_max_acceleration_travel",      "1600,1700" },
+            // stride-2 options: (normal, silent)
+            { "machine_max_speed_x",  "100,100" },
+            { "machine_max_speed_y",  "110,110" },
+            { "machine_max_speed_z",  "10,10" },
+            { "machine_max_speed_e",  "50,50" },
+            { "machine_max_jerk_x",   "8,8" },
+            { "machine_max_jerk_y",   "9,9" },
+            { "machine_max_jerk_z",   "0.4,0.4" },
+            { "machine_max_jerk_e",   "5,5" },
+            { "machine_max_junction_deviation", "0.02,0.03" },
+        });
+
+        THEN("M201 uses the normal acceleration values") {
+            REQUIRE(gcode.find("M201 X500 Y700 Z100 E5000") != std::string::npos);
+        }
+        THEN("M203 uses the speed values") {
+            REQUIRE(gcode.find("M203 X100 Y110 Z10 E50") != std::string::npos);
+        }
+        THEN("M204 (Marlin 2) uses extruding / retracting / travel") {
+            REQUIRE(gcode.find("M204 P1200 R1400 T1600") != std::string::npos);
+        }
+        THEN("M205 uses the jerk values") {
+            REQUIRE(gcode.find("M205 X8.00 Y9.00 Z0.40 E5.00") != std::string::npos);
+        }
+        THEN("M205 J uses the junction deviation") {
+            REQUIRE(gcode.find("M205 J0.020") != std::string::npos);
+        }
+    }
+
+    SECTION("Legacy Marlin flavor emits correct format") {
+        const std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, {
+            { "emit_machine_limits_to_gcode", "1" },
+            { "gcode_flavor",                "marlin" },
+            { "gcode_comments",              "1" },
+            { "machine_start_gcode",         "" },
+            { "layer_height",                "0.2" },
+            { "initial_layer_print_height",  "0.2" },
+            { "initial_layer_line_width",    "0" },
+            { "z_hop",                       "0" },
+            // All machine limits must be provided — defaults are empty vectors.
+            { "machine_max_acceleration_x",           "500,600" },
+            { "machine_max_acceleration_y",           "500,600" },
+            { "machine_max_acceleration_z",           "500,600" },
+            { "machine_max_acceleration_e",           "5000,6000" },
+            { "machine_max_acceleration_extruding",   "1200,1300" },
+            { "machine_max_acceleration_retracting",  "1400,1500" },
+            { "machine_max_acceleration_travel",      "1600,1700" },
+            { "machine_max_speed_x",  "100,100" },
+            { "machine_max_speed_y",  "110,110" },
+            { "machine_max_speed_z",  "10,10" },
+            { "machine_max_speed_e",  "50,50" },
+            { "machine_max_jerk_x",   "8,8" },
+            { "machine_max_jerk_y",   "9,9" },
+            { "machine_max_jerk_z",   "0.4,0.4" },
+            { "machine_max_jerk_e",   "5,5" },
+            { "machine_max_junction_deviation", "0.02,0.03" },
+        });
+
+        THEN("Legacy Marlin: M204 travel_acc = extruding_acc") {
+            // gcfMarlinLegacy uses extruding acc for travel too
+            REQUIRE(gcode.find("M204 P1200 R1400 T1200") != std::string::npos);
+        }
+        THEN("Legacy Marlin: M205 uses mm/sec format") {
+            REQUIRE(gcode.find("M205 X8.00 Y9.00 Z0.40 E5.00") != std::string::npos);
+        }
+    }
+
+    SECTION("Multi extruder - max of used extruders is emitted") {
+        // Build config with 2 extruders that have *different* machine limits.
+        // Extruder 1 has higher values; the emitted G-code must use the max.
+        DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+
+        // Print basics
+        config.set_key_value("emit_machine_limits_to_gcode", new ConfigOptionBool(true));
+        config.set_key_value("gcode_flavor",                 new ConfigOptionEnum<GCodeFlavor>(gcfMarlinFirmware));
+        config.set_key_value("gcode_comments",               new ConfigOptionBool(true));
+        config.set_key_value("machine_start_gcode",          new ConfigOptionString(""));
+        config.set_key_value("layer_height",                 new ConfigOptionFloat(0.2));
+        config.set_key_value("initial_layer_print_height",   new ConfigOptionFloat(0.2));
+        config.set_key_value("initial_layer_line_width",     new ConfigOptionFloatOrPercent(0, false));
+        config.set_key_value("z_hop",                        new ConfigOptionFloats({0}));
+        // Print objects sequentially so each uses its own extruder without
+        // wipe-tower / tool-change complexity.
+        config.set_key_value("print_sequence",               new ConfigOptionEnum<PrintSequence>(PrintSequence::ByObject));
+
+        // 2 extruders
+        config.set_key_value("nozzle_diameter",          new ConfigOptionFloats({0.4, 0.4}));
+        config.set_key_value("printer_extruder_id",      new ConfigOptionInts({1, 2}));
+        config.set_key_value("printer_extruder_variant", new ConfigOptionStrings({"Direct Drive Standard", "Direct Drive Standard"}));
+        config.set_key_value("filament_diameter",        new ConfigOptionFloats({1.75, 1.75}));
+        config.set_key_value("filament_colour",          new ConfigOptionStrings({"#FF0000", "#00FF00"}));
+        config.set_key_value("filament_type",            new ConfigOptionStrings({"PLA", "PLA"}));
+        // filament_map maps filament slot index (1-based) → logical extruder ID (1-based).
+        // Default [1] maps everything to extruder 0. Need [1, 2] for two distinct extruders.
+        // fmmManual prevents auto-computation from overwriting the explicit mapping.
+        config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode", true)->value = fmmManual;
+        config.set_key_value("filament_map",             new ConfigOptionInts({1, 2}));
+        config.set_key_value("default_filament_colour",  new ConfigOptionStrings({"#FF0000", "#00FF00"}));
+        config.set_key_value("nozzle_temperature",       new ConfigOptionInts({210, 210}));
+        config.set_key_value("nozzle_temperature_range_low",  new ConfigOptionInts({190, 190}));
+        config.set_key_value("nozzle_temperature_range_high", new ConfigOptionInts({240, 240}));
+        // flush_volumes_matrix must be filament_count^2 * heads_count entries.
+        // 2 filaments * 2 * 1 head = 4 entries (all zero — flush volumes not tested here).
+        config.set_key_value("flush_multiplier",     new ConfigOptionFloats({1}));
+        config.set_key_value("flush_volumes_matrix", new ConfigOptionFloats({0, 0, 0, 0}));
+
+        // Machine limits: extruder 0 low, extruder 1 high
+        // Stride-2 (normal, silent pairs): e0_n, e0_s, e1_n, e1_s
+        config.set_key_value("machine_max_acceleration_x",          new ConfigOptionFloats({500, 0, 1000, 0}));
+        config.set_key_value("machine_max_acceleration_y",          new ConfigOptionFloats({700, 0, 1100, 0}));
+        config.set_key_value("machine_max_acceleration_z",          new ConfigOptionFloats({100, 0, 300, 0}));
+        config.set_key_value("machine_max_acceleration_e",          new ConfigOptionFloats({5000, 0, 8000, 0}));
+        config.set_key_value("machine_max_acceleration_extruding",  new ConfigOptionFloats({1200, 0, 2200, 0}));
+        config.set_key_value("machine_max_acceleration_retracting", new ConfigOptionFloats({1400, 0, 2400, 0}));
+        config.set_key_value("machine_max_acceleration_travel",     new ConfigOptionFloats({1600, 0, 2600, 0}));
+        config.set_key_value("machine_max_speed_x",  new ConfigOptionFloats({100, 0, 200, 0}));
+        config.set_key_value("machine_max_speed_y",  new ConfigOptionFloats({110, 0, 210, 0}));
+        config.set_key_value("machine_max_speed_z",  new ConfigOptionFloats({10, 0, 30, 0}));
+        config.set_key_value("machine_max_speed_e",  new ConfigOptionFloats({50, 0, 80, 0}));
+        config.set_key_value("machine_max_jerk_x",   new ConfigOptionFloats({8, 0, 12, 0}));
+        config.set_key_value("machine_max_jerk_y",   new ConfigOptionFloats({9, 0, 13, 0}));
+        config.set_key_value("machine_max_jerk_z",   new ConfigOptionFloats({0.4, 0, 0.6, 0}));
+        config.set_key_value("machine_max_jerk_e",   new ConfigOptionFloats({5, 0, 10, 0}));
+        config.set_key_value("machine_max_junction_deviation", new ConfigOptionFloats({0.02, 0, 0.05, 0}));
+
+        // Model: two objects assigned to different extruders
+        Model model;
+        auto* obj1 = model.add_object();
+        obj1->add_volume(mesh(TestMesh::cube_20x20x20));
+        obj1->add_instance();
+        // obj1 uses default extruder=1 (0-based index 0)
+
+        auto* obj2 = model.add_object();
+        obj2->add_volume(mesh(TestMesh::cube_20x20x20));
+        obj2->add_instance();
+        obj2->config.set_key_value("extruder", new ConfigOptionInt(2)); // 0-based index 1
+
+        Print print;
+        arrange_objects(model, InfiniteBed{},
+                        ArrangeParams{scaled(min_object_distance(config))});
+        for (auto* mo : model.objects) {
+            mo->ensure_on_bed();
+            print.auto_assign_extruders(mo);
+        }
+
+        print.apply(model, config);
+        print.validate();
+        print.set_status_silent();
+        print.process();
+
+        std::string gcode = Slic3r::Test::gcode(print);
+
+        THEN("M201 contains max (extruder 1's) acceleration values") {
+            REQUIRE(gcode.find("M201 X1000 Y1100 Z300 E8000") != std::string::npos);
+        }
+        THEN("M203 contains max speed values") {
+            REQUIRE(gcode.find("M203 X200 Y210 Z30 E80") != std::string::npos);
+        }
+        THEN("M204 contains max extruding / retracting / travel") {
+            REQUIRE(gcode.find("M204 P2200 R2400 T2600") != std::string::npos);
+        }
+        THEN("M205 contains max jerk values") {
+            REQUIRE(gcode.find("M205 X12.00 Y13.00 Z0.60 E10.00") != std::string::npos);
+        }
+        THEN("M205 J is clamped to m_max_junction_deviation (values.front())") {
+            // MAX_LIMIT returns 0.05, but set_junction_deviation clamps to
+            // m_max_junction_deviation which is set from values.front() (0.02).
+            REQUIRE(gcode.find("M205 J0.020") != std::string::npos);
+        }
+    }
+}