Merge remote-tracking branch 'origin/master' into feature_slice_to_png

xs/src/libslic3r/GCode/WipeTowerPrusaMM.cpp

@@ -42,14 +42,32 @@ namespace PrusaMultiMaterial {
 class Writer
 {
 public:
-	Writer() : 
+	Writer(float layer_height, float line_width) :
 		m_current_pos(std::numeric_limits<float>::max(), std::numeric_limits<float>::max()),
 		m_current_z(0.f),
 		m_current_feedrate(0.f),
-		m_layer_height(0.f),
+		m_layer_height(layer_height),
 		m_extrusion_flow(0.f),
 		m_preview_suppressed(false),
-		m_elapsed_time(0.f) {}
+		m_elapsed_time(0.f),
+        m_default_analyzer_line_width(line_width)
+        {
+            // adds tag for analyzer:
+            char buf[64];
+            sprintf(buf, ";%s%f\n", GCodeAnalyzer::Height_Tag.c_str(), m_layer_height); // don't rely on GCodeAnalyzer knowing the layer height - it knows nothing at priming
+            m_gcode += buf;
+            sprintf(buf, ";%s%d\n", GCodeAnalyzer::Extrusion_Role_Tag.c_str(), erWipeTower);
+            m_gcode += buf;
+            change_analyzer_line_width(line_width);
+        }
+
+    Writer&              change_analyzer_line_width(float line_width) {
+            // adds tag for analyzer:
+            char buf[64];
+            sprintf(buf, ";%s%f\n", GCodeAnalyzer::Width_Tag.c_str(), line_width);
+            m_gcode += buf;
+            return *this;
+    }
 
 	Writer& 			 set_initial_position(const WipeTower::xy &pos) { 
 		m_start_pos = WipeTower::xy(pos,0.f,m_y_shift).rotate(m_wipe_tower_pos, m_wipe_tower_width, m_wipe_tower_depth, m_angle_deg);
@@ -62,9 +80,6 @@ public:
 	Writer&				 set_z(float z) 
 		{ m_current_z = z; return *this; }
 
-	Writer&				 set_layer_height(float layer_height)
-		{ m_layer_height = layer_height; return *this; }
-
 	Writer& 			 set_extrusion_flow(float flow)
 		{ m_extrusion_flow = flow; return *this; }
 		
@@ -80,8 +95,8 @@ public:
 	// Suppress / resume G-code preview in Slic3r. Slic3r will have difficulty to differentiate the various
 	// filament loading and cooling moves from normal extrusion moves. Therefore the writer
 	// is asked to suppres output of some lines, which look like extrusions.
-	Writer& 			 suppress_preview() { m_preview_suppressed = true; return *this; }
-	Writer& 			 resume_preview() { m_preview_suppressed = false; return *this; }
+	Writer& 			 suppress_preview() { change_analyzer_line_width(0.f); m_preview_suppressed = true; return *this; }
+	Writer& 			 resume_preview()   { change_analyzer_line_width(m_default_analyzer_line_width); m_preview_suppressed = false; return *this; }
 
 	Writer& 			 feedrate(float f)
 	{
@@ -126,11 +141,6 @@ public:
 			m_extrusions.emplace_back(WipeTower::Extrusion(WipeTower::xy(rot.x, rot.y), width, m_current_tool));			
 		}
 
-        // adds tag for analyzer
-        char buf[64];
-        sprintf(buf, ";%s%d\n", GCodeAnalyzer::Extrusion_Role_Tag.c_str(), erWipeTower);
-        m_gcode += buf;
-
 		m_gcode += "G1";
 		if (rot.x != rotated_current_pos.x) {
 			m_gcode += set_format_X(rot.x);     // Transform current position back to wipe tower coordinates (was updated by set_format_X)
@@ -197,7 +207,7 @@ public:
         do {
             ++i;
             if (i==4) i=0;
-            extrude(corners[i]);
+            extrude(corners[i], f);
         } while (i != index_of_closest);
         return (*this);
     }
@@ -390,6 +400,7 @@ private:
 	float		  m_wipe_tower_depth = 0.f;
 	float		  m_last_fan_speed = 0.f;
     int           current_temp = -1;
+    const float   m_default_analyzer_line_width;
 
 		std::string
 		set_format_X(float x)
@@ -479,10 +490,9 @@ WipeTower::ToolChangeResult WipeTowerPrusaMM::prime(
 	const float prime_section_width = std::min(240.f / tools.size(), 60.f);
 	box_coordinates cleaning_box(xy(5.f, 0.f), prime_section_width, 100.f);
 
-	PrusaMultiMaterial::Writer writer;
+	PrusaMultiMaterial::Writer writer(m_layer_height, m_perimeter_width);
 	writer.set_extrusion_flow(m_extrusion_flow)
 		  .set_z(m_z_pos)
-		  .set_layer_height(m_layer_height)
 		  .set_initial_tool(m_current_tool)
 		  .append(";--------------------\n"
 			 	  "; CP PRIMING START\n")
@@ -568,10 +578,9 @@ WipeTower::ToolChangeResult WipeTowerPrusaMM::tool_change(unsigned int tool, boo
 		(tool != (unsigned int)(-1) ? /*m_layer_info->depth*/wipe_area+m_depth_traversed-0.5*m_perimeter_width
                                     : m_wipe_tower_depth-m_perimeter_width));
 
-	PrusaMultiMaterial::Writer writer;
+	PrusaMultiMaterial::Writer writer(m_layer_height, m_perimeter_width);
 	writer.set_extrusion_flow(m_extrusion_flow)
 		.set_z(m_z_pos)
-		.set_layer_height(m_layer_height)
 		.set_initial_tool(m_current_tool)
 		.set_rotation(m_wipe_tower_pos, m_wipe_tower_width, m_wipe_tower_depth, m_wipe_tower_rotation_angle)
 		.set_y_shift(m_y_shift + (tool!=(unsigned int)(-1) && (m_current_shape == SHAPE_REVERSED && !m_peters_wipe_tower) ? m_layer_info->depth - m_layer_info->toolchanges_depth(): 0.f))
@@ -640,10 +649,9 @@ WipeTower::ToolChangeResult WipeTowerPrusaMM::toolchange_Brim(bool sideOnly, flo
 		m_wipe_tower_width,
 		m_wipe_tower_depth);
 
-	PrusaMultiMaterial::Writer writer;
+	PrusaMultiMaterial::Writer writer(m_layer_height, m_perimeter_width);
 	writer.set_extrusion_flow(m_extrusion_flow * 1.1f)
 		  .set_z(m_z_pos) // Let the writer know the current Z position as a base for Z-hop.
-		  .set_layer_height(m_layer_height)
 		  .set_initial_tool(m_current_tool)
   		  .set_rotation(m_wipe_tower_pos, m_wipe_tower_width, m_wipe_tower_depth, m_wipe_tower_rotation_angle)
 		  .append(";-------------------------------------\n"
@@ -697,11 +705,12 @@ void WipeTowerPrusaMM::toolchange_Unload(
 	float xl = cleaning_box.ld.x + 1.f * m_perimeter_width;
 	float xr = cleaning_box.rd.x - 1.f * m_perimeter_width;
 	
-	writer.append("; CP TOOLCHANGE UNLOAD\n");
-	
 	const float line_width = m_perimeter_width * m_filpar[m_current_tool].ramming_line_width_multiplicator;       // desired ramming line thickness
 	const float y_step = line_width * m_filpar[m_current_tool].ramming_step_multiplicator * m_extra_spacing; // spacing between lines in mm
 
+    writer.append("; CP TOOLCHANGE UNLOAD\n")
+          .change_analyzer_line_width(line_width);
+
 	unsigned i = 0;										// iterates through ramming_speed
 	m_left_to_right = true;								// current direction of ramming
 	float remaining = xr - xl ;							// keeps track of distance to the next turnaround
@@ -775,12 +784,14 @@ void WipeTowerPrusaMM::toolchange_Unload(
 		}
 	}
 	WipeTower::xy end_of_ramming(writer.x(),writer.y());
+    writer.change_analyzer_line_width(m_perimeter_width);   // so the next lines are not affected by ramming_line_width_multiplier
 
     // Pull the filament end to the BEGINNING of the cooling tube while still moving the print head
     float oldx = writer.x();
     float turning_point = (!m_left_to_right ? std::max(xl,oldx-15.f) : std::min(xr,oldx+15.f) ); // so it's not too far
     float xdist = std::abs(oldx-turning_point);
     float edist = -(m_cooling_tube_retraction+m_cooling_tube_length/2.f-42);
+
     writer.suppress_preview()
           .load_move_x(turning_point,-15    , 60.f * std::hypot(xdist,15)/15 * 83 )    // fixed speed after ramming
           .load_move_x(oldx         ,edist  , 60.f * std::hypot(xdist,edist)/std::abs(edist) * m_filpar[m_current_tool].unloading_speed )
@@ -959,10 +970,9 @@ WipeTower::ToolChangeResult WipeTowerPrusaMM::finish_layer()
 	// Otherwise the caller would likely travel to the wipe tower in vain.
 	assert(! this->layer_finished());
 
-	PrusaMultiMaterial::Writer writer;
+	PrusaMultiMaterial::Writer writer(m_layer_height, m_perimeter_width);
 	writer.set_extrusion_flow(m_extrusion_flow)
 		.set_z(m_z_pos)
-		.set_layer_height(m_layer_height)
 		.set_initial_tool(m_current_tool)
 		.set_rotation(m_wipe_tower_pos, m_wipe_tower_width, m_wipe_tower_depth, m_wipe_tower_rotation_angle)
 		.set_y_shift(m_y_shift - (m_current_shape == SHAPE_REVERSED && !m_peters_wipe_tower ? m_layer_info->toolchanges_depth() : 0.f))
@@ -1137,7 +1147,8 @@ void WipeTowerPrusaMM::save_on_last_wipe()
 // Resulting ToolChangeResults are appended into vector "result"
 void WipeTowerPrusaMM::generate(std::vector<std::vector<WipeTower::ToolChangeResult>> &result)
 {
-	if (m_plan.empty())	return;
+	if (m_plan.empty())
+            return;
 
     m_extra_spacing = 1.f;
 
@@ -1151,8 +1162,9 @@ void WipeTowerPrusaMM::generate(std::vector<std::vector<WipeTower::ToolChangeRes
 			make_wipe_tower_square();
 
     m_layer_info = m_plan.begin();
+    m_current_tool = (unsigned int)(-2); // we don't know which extruder to start with - we'll set it according to the first toolchange
 
-	std::vector<WipeTower::ToolChangeResult> layer_result;
+    std::vector<WipeTower::ToolChangeResult> layer_result;
 	for (auto layer : m_plan)
 	{
 		set_layer(layer.z,layer.height,0,layer.z == m_plan.front().z,layer.z == m_plan.back().z);
@@ -1166,8 +1178,11 @@ void WipeTowerPrusaMM::generate(std::vector<std::vector<WipeTower::ToolChangeRes
 		if (!m_peters_wipe_tower && m_layer_info->depth < m_wipe_tower_depth - m_perimeter_width)
 			m_y_shift = (m_wipe_tower_depth-m_layer_info->depth-m_perimeter_width)/2.f;
 
-		for (const auto &toolchange : layer.tool_changes)
+		for (const auto &toolchange : layer.tool_changes) {
+            if (m_current_tool == (unsigned int)(-2))
+                m_current_tool = toolchange.old_tool;
 			layer_result.emplace_back(tool_change(toolchange.new_tool, false));
+        }
 
 		if (! layer_finished()) {
             auto finish_layer_toolchange = finish_layer();

xs/src/libslic3r/GCode/WipeTowerPrusaMM.hpp

@@ -229,7 +229,7 @@ private:
 	bool m_print_brim = true;
 	// A fill-in direction (positive Y, negative Y) alternates with each layer.
 	wipe_shape   	m_current_shape = SHAPE_NORMAL;
-	unsigned int 	m_current_tool  = 0;
+	unsigned int 	m_current_tool;
     std::vector<std::vector<float>> wipe_volumes;
 
 	float           m_depth_traversed = 0.f; // Current y position at the wipe tower.

xs/src/libslic3r/GCodeSender.cpp

@@ -41,6 +41,7 @@ struct termios2 {
 
 //#define DEBUG_SERIAL
 #ifdef DEBUG_SERIAL
+#include <cstdlib>
 #include <fstream>
 std::fstream fs;
 #endif
@@ -52,7 +53,11 @@ namespace Slic3r {
 GCodeSender::GCodeSender()
     : io(), serial(io), can_send(false), sent(0), open(false), error(false),
       connected(false), queue_paused(false)
-{}
+{
+#ifdef DEBUG_SERIAL
+    std::srand(std::time(nullptr));
+#endif
+}
 
 GCodeSender::~GCodeSender()
 {
@@ -358,15 +363,23 @@ GCodeSender::on_read(const boost::system::error_code& error,
             // extract the first number from line
             boost::algorithm::trim_left_if(line, !boost::algorithm::is_digit());
             size_t toresend = boost::lexical_cast<size_t>(line.substr(0, line.find_first_not_of("0123456789")));
-            ++ toresend; // N is 0-based
-            if (toresend >= this->sent - this->last_sent.size() && toresend < this->last_sent.size()) {
+            
+#ifdef DEBUG_SERIAL
+            fs << "!! line num out of sync: toresend = " << toresend << ", sent = " << sent << ", last_sent.size = " << last_sent.size() << std::endl;
+#endif
+
+            if (toresend > this->sent - this->last_sent.size() && toresend <= this->sent) {
                 {
                     boost::lock_guard<boost::mutex> l(this->queue_mutex);
                     
+                    const auto lines_to_resend = this->sent - toresend + 1;
+#ifdef DEBUG_SERIAL
+            fs << "!! resending " << lines_to_resend << " lines" << std::endl;
+#endif
                     // move the unsent lines to priqueue
                     this->priqueue.insert(
                         this->priqueue.begin(),  // insert at the beginning
-                        this->last_sent.begin() + toresend - (this->sent - this->last_sent.size()) - 1,
+                        this->last_sent.begin() + this->last_sent.size() - lines_to_resend,
                         this->last_sent.end()
                     );
                     
@@ -477,8 +490,14 @@ GCodeSender::do_send()
     if (line.empty()) return;
     
     // compute full line
-    std::string full_line = "N" + boost::lexical_cast<std::string>(this->sent) + " " + line;
     ++ this->sent;
+#ifndef DEBUG_SERIAL
+    const auto line_num = this->sent;
+#else
+    // In DEBUG_SERIAL mode, test line re-synchronization by sending bad line number 1/4 of the time
+    const auto line_num = std::rand() < RAND_MAX/4 ? 0 : this->sent;
+#endif
+    std::string full_line = "N" + boost::lexical_cast<std::string>(line_num) + " " + line;
     
     // calculate checksum
     int cs = 0;
@@ -497,8 +516,9 @@ GCodeSender::do_send()
     this->last_sent.push_back(line);
     this->can_send = false;
     
-    if (this->last_sent.size() > KEEP_SENT)
-        this->last_sent.erase(this->last_sent.begin(), this->last_sent.end() - KEEP_SENT);
+    while (this->last_sent.size() > KEEP_SENT) {
+        this->last_sent.pop_front();
+    }
     
     // we can't supply boost::asio::buffer(full_line) to async_write() because full_line is on the
     // stack and the buffer would lose its underlying storage causing memory corruption

xs/src/libslic3r/GCodeSender.hpp

@@ -51,7 +51,7 @@ class GCodeSender : private boost::noncopyable {
     bool can_send;
     bool queue_paused;
     size_t sent;
-    std::vector<std::string> last_sent;
+    std::deque<std::string> last_sent;
     
     // this mutex guards log, T, B
     mutable boost::mutex log_mutex;

xs/src/libslic3r/PerimeterGenerator.cpp

@@ -243,7 +243,7 @@ void PerimeterGenerator::process()
                 perimeter_spacing / 2;
         // only apply infill overlap if we actually have one perimeter
         if (inset > 0)
-            inset -= this->config->get_abs_value("infill_overlap", inset + solid_infill_spacing / 2);
+            inset -= scale_(this->config->get_abs_value("infill_overlap", unscale(inset + solid_infill_spacing / 2)));
         // simplify infill contours according to resolution
         Polygons pp;
         for (ExPolygon &ex : last)

xs/src/libslic3r/PrintConfig.cpp

@@ -948,7 +948,7 @@ PrintConfigDef::PrintConfigDef()
     def->default_value = new ConfigOptionFloats { 10. };
 
     def = this->add("min_skirt_length", coFloat);
-    def->label = L("Minimum extrusion length");
+    def->label = L("Minimal filament extrusion length");
     def->tooltip = L("Generate no less than the number of skirt loops required to consume "
                    "the specified amount of filament on the bottom layer. For multi-extruder machines, "
                    "this minimum applies to each extruder.");

xs/src/libslic3r/libslic3r.h

@@ -14,7 +14,7 @@
 #include <boost/thread.hpp>
 
 #define SLIC3R_FORK_NAME "Slic3r Prusa Edition"
-#define SLIC3R_VERSION "1.40.0-alpha2"
+#define SLIC3R_VERSION "1.40.0"
 #define SLIC3R_BUILD "UNKNOWN"
 
 typedef int32_t coord_t;