diff --git a/src/libslic3r/GCode.cpp b/src/libslic3r/GCode.cpp index d1727c1c23..e9fc0e8be0 100644 --- a/src/libslic3r/GCode.cpp +++ b/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 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::lowest(); + for (unsigned int extruder : used_extruders) { + value = std::max(value, v.values[extruder * stride]); + } + + assert(value > std::numeric_limits::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(print.config().machine_max_acceleration_y.values.front() + 0.5), - int(print.config().machine_max_acceleration_z.values.front() + 0.5), - int(print.config().machine_max_acceleration_e.values.front() + 0.5)); + int(MAX_LIMIT(machine_max_acceleration_x) + 0.5), + int(MAX_LIMIT(machine_max_acceleration_y) + 0.5), + int(MAX_LIMIT(machine_max_acceleration_z) + 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(print.config().machine_max_speed_y.values.front() * factor + 0.5), - int(print.config().machine_max_speed_z.values.front() * factor + 0.5), - int(print.config().machine_max_speed_e.values.front() * factor + 0.5)); + int(MAX_LIMIT(machine_max_speed_x) * factor + 0.5), + int(MAX_LIMIT(machine_max_speed_y) * factor + 0.5), + int(MAX_LIMIT(machine_max_speed_z) * 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(print.config().machine_max_acceleration_travel.values.front() + 0.5); + ? int(MAX_LIMIT(machine_max_acceleration_extruding) + 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(print.config().machine_max_acceleration_retracting.values.front() + 0.5), - int(print.config().machine_max_acceleration_travel.values.front() + 0.5)); + int(MAX_LIMIT(machine_max_acceleration_extruding) + 0.5), + int(MAX_LIMIT(machine_max_acceleration_retracting) + 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(print.config().machine_max_acceleration_retracting.values.front() + 0.5), + int(MAX_LIMIT(machine_max_acceleration_extruding) + 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, - print.config().machine_max_jerk_y.values.front() * factor, - print.config().machine_max_jerk_z.values.front() * factor, - print.config().machine_max_jerk_e.values.front() * factor); + MAX_LIMIT(machine_max_jerk_x) * factor, + MAX_LIMIT(machine_max_jerk_y) * factor, + MAX_LIMIT(machine_max_jerk_z) * 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 diff --git a/tests/fff_print/test_printgcode.cpp b/tests/fff_print/test_printgcode.cpp index 7ac2f43231..f21e6c8b06 100644 --- a/tests/fff_print/test_printgcode.cpp +++ b/tests/fff_print/test_printgcode.cpp @@ -18,6 +18,7 @@ #include #include +#include #include #include #include @@ -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(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::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>("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); + } + } +}