275 lines
12 KiB
C++
275 lines
12 KiB
C++
#include <catch2/catch.hpp>
|
|
|
|
#include <numeric>
|
|
#include <sstream>
|
|
|
|
#include "test_data.hpp" // get access to init_print, etc
|
|
|
|
#include "libslic3r/Config.hpp"
|
|
#include "libslic3r/GCode.hpp"
|
|
#include "libslic3r/GCodeReader.hpp"
|
|
#include "libslic3r/GCode/CoolingBuffer.hpp"
|
|
#include "libslic3r/libslic3r.h"
|
|
|
|
using namespace Slic3r;
|
|
|
|
std::unique_ptr<CoolingBuffer> make_cooling_buffer(
|
|
GCode &gcode,
|
|
const DynamicPrintConfig &config = DynamicPrintConfig{},
|
|
const std::vector<unsigned int> &extruder_ids = { 0 })
|
|
{
|
|
PrintConfig print_config;
|
|
print_config.apply(config, true); // ignore_nonexistent
|
|
gcode.apply_print_config(print_config);
|
|
gcode.set_layer_count(10);
|
|
gcode.writer().set_extruders(extruder_ids);
|
|
gcode.writer().set_extruder(0);
|
|
return std::make_unique<CoolingBuffer>(gcode);
|
|
}
|
|
|
|
SCENARIO("Cooling unit tests", "[Cooling]") {
|
|
const std::string gcode1 = "G1 X100 E1 F3000\n";
|
|
// 2 sec
|
|
const double print_time1 = 100. / (3000. / 60.);
|
|
const std::string gcode2 = gcode1 + "G1 X0 E1 F3000\n";
|
|
// 4 sec
|
|
const double print_time2 = 2. * print_time1;
|
|
|
|
auto config = DynamicPrintConfig::full_print_config_with({
|
|
// Default cooling settings.
|
|
{ "bridge_fan_speed", "100" },
|
|
{ "cooling", "1" },
|
|
{ "fan_always_on", "0" },
|
|
{ "fan_below_layer_time", "60" },
|
|
{ "max_fan_speed", "100" },
|
|
{ "min_print_speed", "10" },
|
|
{ "slowdown_below_layer_time", "5" },
|
|
// Default print speeds.
|
|
{ "bridge_speed", 60 },
|
|
{ "external_perimeter_speed", "50%" },
|
|
{ "first_layer_speed", 30 },
|
|
{ "gap_fill_speed", 20 },
|
|
{ "infill_speed", 80 },
|
|
{ "perimeter_speed", 60 },
|
|
{ "small_perimeter_speed", 15 },
|
|
{ "solid_infill_speed", 20 },
|
|
{ "top_solid_infill_speed", 15 },
|
|
{ "max_print_speed", 80 },
|
|
// Override for tests.
|
|
{ "disable_fan_first_layers", "0" }
|
|
});
|
|
|
|
WHEN("G-code block 3") {
|
|
THEN("speed is not altered when elapsed time is greater than slowdown threshold") {
|
|
// Print time of gcode.
|
|
const double print_time = 100. / (3000. / 60.);
|
|
//FIXME slowdown_below_layer_time is rounded down significantly from 1.8s to 1s.
|
|
config.set_deserialize_strict({ { "slowdown_below_layer_time", { int(print_time * 0.999) } } });
|
|
GCode gcodegen;
|
|
auto buffer = make_cooling_buffer(gcodegen, config);
|
|
std::string gcode = buffer->process_layer("G1 F3000;_EXTRUDE_SET_SPEED\nG1 X100 E1", 0, true);
|
|
bool speed_not_altered = gcode.find("F3000") != gcode.npos;
|
|
REQUIRE(speed_not_altered);
|
|
}
|
|
}
|
|
|
|
WHEN("G-code block 4") {
|
|
const std::string gcode_src =
|
|
"G1 X50 F2500\n"
|
|
"G1 F3000;_EXTRUDE_SET_SPEED\n"
|
|
"G1 X100 E1\n"
|
|
";_EXTRUDE_END\n"
|
|
"G1 E4 F400";
|
|
// Print time of gcode.
|
|
const double print_time = 50. / (2500. / 60.) + 100. / (3000. / 60.) + 4. / (400. / 60.);
|
|
config.set_deserialize_strict({ { "slowdown_below_layer_time", { int(print_time * 1.001) } } });
|
|
GCode gcodegen;
|
|
auto buffer = make_cooling_buffer(gcodegen, config);
|
|
std::string gcode = buffer->process_layer(gcode_src, 0, true);
|
|
THEN("speed is altered when elapsed time is lower than slowdown threshold") {
|
|
bool speed_is_altered = gcode.find("F3000") == gcode.npos;
|
|
REQUIRE(speed_is_altered);
|
|
}
|
|
THEN("speed is not altered for travel moves") {
|
|
bool speed_not_altered = gcode.find("F2500") != gcode.npos;
|
|
REQUIRE(speed_not_altered);
|
|
}
|
|
THEN("speed is not altered for extruder-only moves") {
|
|
bool speed_not_altered = gcode.find("F400") != gcode.npos;
|
|
REQUIRE(speed_not_altered);
|
|
}
|
|
}
|
|
|
|
WHEN("G-code block 1") {
|
|
THEN("fan is not activated when elapsed time is greater than fan threshold") {
|
|
config.set_deserialize_strict({
|
|
{ "fan_below_layer_time" , int(print_time1 * 0.88) },
|
|
{ "slowdown_below_layer_time" , int(print_time1 * 0.99) }
|
|
});
|
|
GCode gcodegen;
|
|
auto buffer = make_cooling_buffer(gcodegen, config);
|
|
std::string gcode = buffer->process_layer(gcode1, 0, true);
|
|
bool fan_not_activated = gcode.find("M106") == gcode.npos;
|
|
REQUIRE(fan_not_activated);
|
|
}
|
|
}
|
|
WHEN("G-code block 1 with two extruders") {
|
|
config.set_deserialize_strict({
|
|
{ "cooling", "1, 0" },
|
|
{ "fan_below_layer_time", { int(print_time2 + 1.), int(print_time2 + 1.) } },
|
|
{ "slowdown_below_layer_time", { int(print_time2 + 2.), int(print_time2 + 2.) } }
|
|
});
|
|
GCode gcodegen;
|
|
auto buffer = make_cooling_buffer(gcodegen, config, { 0, 1 });
|
|
std::string gcode = buffer->process_layer(gcode1 + "T1\nG1 X0 E1 F3000\n", 0, true);
|
|
THEN("fan is activated for the 1st tool") {
|
|
bool ok = gcode.find("M106") == 0;
|
|
REQUIRE(ok);
|
|
}
|
|
THEN("fan is disabled for the 2nd tool") {
|
|
bool ok = gcode.find("\nM107") > 0;
|
|
REQUIRE(ok);
|
|
}
|
|
}
|
|
WHEN("G-code block 2") {
|
|
THEN("slowdown is computed on all objects printing at the same Z") {
|
|
config.set_deserialize_strict({ { "slowdown_below_layer_time", int(print_time2 * 0.99) } });
|
|
GCode gcodegen;
|
|
auto buffer = make_cooling_buffer(gcodegen, config);
|
|
std::string gcode = buffer->process_layer(gcode2, 0, true);
|
|
bool ok = gcode.find("F3000") != gcode.npos;
|
|
REQUIRE(ok);
|
|
}
|
|
THEN("fan is not activated on all objects printing at different Z") {
|
|
config.set_deserialize_strict({
|
|
{ "fan_below_layer_time", int(print_time2 * 0.65) },
|
|
{ "slowdown_below_layer_time", int(print_time2 * 0.7) }
|
|
});
|
|
GCode gcodegen;
|
|
auto buffer = make_cooling_buffer(gcodegen, config);
|
|
// use an elapsed time which is < the threshold but greater than it when summed twice
|
|
std::string gcode = buffer->process_layer(gcode2, 0, true) + buffer->process_layer(gcode2, 1, true);
|
|
bool fan_not_activated = gcode.find("M106") == gcode.npos;
|
|
REQUIRE(fan_not_activated);
|
|
}
|
|
THEN("fan is activated on all objects printing at different Z") {
|
|
// use an elapsed time which is < the threshold even when summed twice
|
|
config.set_deserialize_strict({
|
|
{ "fan_below_layer_time", int(print_time2 + 1) },
|
|
{ "slowdown_below_layer_time", int(print_time2 + 1) }
|
|
});
|
|
GCode gcodegen;
|
|
auto buffer = make_cooling_buffer(gcodegen, config);
|
|
// use an elapsed time which is < the threshold but greater than it when summed twice
|
|
std::string gcode = buffer->process_layer(gcode2, 0, true) + buffer->process_layer(gcode2, 1, true);
|
|
bool fan_activated = gcode.find("M106") != gcode.npos;
|
|
REQUIRE(fan_activated);
|
|
}
|
|
}
|
|
}
|
|
|
|
SCENARIO("Cooling integration tests", "[Cooling]") {
|
|
GIVEN("overhang") {
|
|
auto config = Slic3r::DynamicPrintConfig::full_print_config_with({
|
|
{ "cooling", { 1 } },
|
|
{ "bridge_fan_speed", { 100 } },
|
|
{ "fan_below_layer_time", { 0 } },
|
|
{ "slowdown_below_layer_time", { 0 } },
|
|
{ "bridge_speed", 99 },
|
|
// internal bridges use solid_infil speed
|
|
{ "bottom_solid_layers", 1 },
|
|
// internal bridges use solid_infil speed
|
|
});
|
|
|
|
GCodeReader parser;
|
|
int fan = 0;
|
|
int fan_with_incorrect_speeds = 0;
|
|
int fan_with_incorrect_print_speeds = 0;
|
|
int bridge_with_no_fan = 0;
|
|
const double bridge_speed = config.opt_float("bridge_speed") * 60;
|
|
parser.parse_buffer(
|
|
Slic3r::Test::slice({ Slic3r::Test::TestMesh::overhang }, config),
|
|
[&fan, &fan_with_incorrect_speeds, &fan_with_incorrect_print_speeds, &bridge_with_no_fan, bridge_speed]
|
|
(Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line)
|
|
{
|
|
if (line.cmd_is("M106")) {
|
|
line.has_value('S', fan);
|
|
if (fan != 255)
|
|
++ fan_with_incorrect_speeds;
|
|
} else if (line.cmd_is("M107")) {
|
|
fan = 0;
|
|
} else if (line.extruding(self) && line.dist_XY(self) > 0) {
|
|
if (is_approx<double>(line.new_F(self), bridge_speed)) {
|
|
if (fan != 255)
|
|
++ bridge_with_no_fan;
|
|
} else {
|
|
if (fan != 0)
|
|
++ fan_with_incorrect_print_speeds;
|
|
}
|
|
}
|
|
});
|
|
THEN("bridge fan speed is applied correctly") {
|
|
REQUIRE(fan_with_incorrect_speeds == 0);
|
|
}
|
|
THEN("bridge fan is only turned on for bridges") {
|
|
REQUIRE(fan_with_incorrect_print_speeds == 0);
|
|
}
|
|
THEN("bridge fan is turned on for all bridges") {
|
|
REQUIRE(bridge_with_no_fan == 0);
|
|
}
|
|
}
|
|
GIVEN("20mm cube") {
|
|
auto config = Slic3r::DynamicPrintConfig::full_print_config_with({
|
|
{ "cooling", { 1 } },
|
|
{ "fan_below_layer_time", { 0 } },
|
|
{ "slowdown_below_layer_time", { 10 } },
|
|
{ "min_print_speed", { 0 } },
|
|
{ "start_gcode", "" },
|
|
{ "first_layer_speed", "100%" },
|
|
{ "external_perimeter_speed", 99 }
|
|
});
|
|
GCodeReader parser;
|
|
const double external_perimeter_speed = config.opt<ConfigOptionFloatOrPercent>("external_perimeter_speed")->value * 60;
|
|
std::vector<double> layer_times;
|
|
// z => 1
|
|
std::map<coord_t, int> layer_external;
|
|
parser.parse_buffer(
|
|
Slic3r::Test::slice({ Slic3r::Test::TestMesh::cube_20x20x20 }, config),
|
|
[&layer_times, &layer_external, external_perimeter_speed]
|
|
(Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line)
|
|
{
|
|
if (line.cmd_is("G1")) {
|
|
if (line.dist_Z(self) != 0) {
|
|
layer_times.emplace_back(0.);
|
|
layer_external[scaled<coord_t>(line.new_Z(self))] = 0;
|
|
}
|
|
double l = line.dist_XY(self);
|
|
if (l == 0)
|
|
l = line.dist_E(self);
|
|
if (l == 0)
|
|
l = line.dist_Z(self);
|
|
if (l > 0.) {
|
|
if (layer_times.empty())
|
|
layer_times.emplace_back(0.);
|
|
layer_times.back() += 60. * std::abs(l) / line.new_F(self);
|
|
}
|
|
if (line.has('F') && line.f() == external_perimeter_speed)
|
|
++ layer_external[scaled<coord_t>(self.z())];
|
|
}
|
|
});
|
|
THEN("slowdown_below_layer_time is honored") {
|
|
// Account for some inaccuracies.
|
|
const double slowdown_below_layer_time = config.opt<ConfigOptionInts>("slowdown_below_layer_time")->values.front() - 0.2;
|
|
size_t minimum_time_honored = std::count_if(layer_times.begin(), layer_times.end(),
|
|
[slowdown_below_layer_time](double t){ return t > slowdown_below_layer_time; });
|
|
REQUIRE(minimum_time_honored == layer_times.size());
|
|
}
|
|
THEN("slowdown_below_layer_time does not alter external perimeters") {
|
|
// Broken by Vojtech
|
|
// check that all layers have at least one unaltered external perimeter speed
|
|
// my $external = all { $_ > 0 } values %layer_external;
|
|
// ok $external, '';
|
|
}
|
|
}
|
|
}
|