Slic3r::GCodeWriter Class Reference

#include <src/libslic3r/GCodeWriter.hpp>

Collaboration diagram for Slic3r::GCodeWriter:

Public Member Functions
	GCodeWriter ()
Extruder *	extruder ()
const Extruder *	extruder () const
std::string	extrusion_axis () const
void	apply_print_config (const PrintConfig &print_config)
void	set_extruders (std::vector< unsigned int > extruder_ids)
const std::vector< Extruder > &	extruders () const
std::vector< unsigned int >	extruder_ids () const
std::string	preamble ()
std::string	postamble () const
std::string	set_temperature (unsigned int temperature, bool wait=false, int tool=-1) const
std::string	set_bed_temperature (unsigned int temperature, bool wait=false)
std::string	set_print_acceleration (unsigned int acceleration)
std::string	set_travel_acceleration (unsigned int acceleration)
std::string	reset_e (bool force=false)
std::string	update_progress (unsigned int num, unsigned int tot, bool allow_100=false) const
bool	need_toolchange (unsigned int extruder_id) const
std::string	set_extruder (unsigned int extruder_id)
std::string	toolchange_prefix () const
std::string	toolchange (unsigned int extruder_id)
std::string	set_speed (double F, const std::string &comment=std::string(), const std::string &cooling_marker=std::string()) const
std::string	travel_to_xy (const Vec2d &point, const std::string &comment=std::string())
std::string	travel_to_xyz (const Vec3d &point, const std::string &comment=std::string())
std::string	travel_to_z (double z, const std::string &comment=std::string())
bool	will_move_z (double z) const
std::string	extrude_to_xy (const Vec2d &point, double dE, const std::string &comment=std::string())
std::string	retract (bool before_wipe=false)
std::string	retract_for_toolchange (bool before_wipe=false)
std::string	unretract ()
std::string	lift ()
std::string	unlift ()
Vec3d	get_position () const
double	get_zhop () const
void	update_position (const Vec3d &new_pos)
std::string	set_fan (unsigned int speed) const

Static Public Member Functions
static bool	supports_separate_travel_acceleration (GCodeFlavor flavor)
static std::string	set_fan (const GCodeFlavor gcode_flavor, bool gcode_comments, unsigned int speed)

Public Attributes
GCodeConfig	config
bool	multiple_extruders

Private Types
enum class	Acceleration { Travel , Print }

Private Member Functions
std::string	_travel_to_z (double z, const std::string &comment)
std::string	_retract (double length, double restart_extra, const std::string &comment)
std::string	set_acceleration_internal (Acceleration type, unsigned int acceleration)

Private Attributes
std::vector< Extruder >	m_extruders
std::string	m_extrusion_axis
bool	m_single_extruder_multi_material
Extruder *	m_extruder
unsigned int	m_last_acceleration = (unsigned int)(-1)
unsigned int	m_last_travel_acceleration = (unsigned int)(-1)
unsigned int	m_max_acceleration
unsigned int	m_max_travel_acceleration
unsigned int	m_last_bed_temperature
bool	m_last_bed_temperature_reached
double	m_lifted
Vec3d	m_pos = Vec3d::Zero()

Detailed Description

Member Enumeration Documentation

Acceleration

enum class Slic3r::GCodeWriter::Acceleration

strongprivate

Enumerator
Travel
Print

                            {
        Travel,
        Print
    };

Constructor & Destructor Documentation

GCodeWriter()

Slic3r::GCodeWriter::GCodeWriter ( )

inline

                  : 
        multiple_extruders(false), m_extrusion_axis("E"), m_extruder(nullptr),
        m_single_extruder_multi_material(false),
        m_last_acceleration(0), m_max_acceleration(0),
        m_last_bed_temperature(0), m_last_bed_temperature_reached(true), 
        m_lifted(0)
        {}

Member Function Documentation

_retract()

std::string Slic3r::GCodeWriter::_retract ( double  length, double  restart_extra, const std::string &  comment  )

private

{
    /*  If firmware retraction is enabled, we use a fake value of 1
        since we ignore the actual configured retract_length which 
        might be 0, in which case the retraction logic gets skipped. */
    if (this->config.use_firmware_retraction)
        length = 1;
    
    // If we use volumetric E values we turn lengths into volumes */
    if (this->config.use_volumetric_e) {
        double d = m_extruder->filament_diameter();
        double area = d * d * PI/4;
        length = length * area;
        restart_extra = restart_extra * area;
    }
    
    std::string gcode;
    if (auto [dE, emitE] = m_extruder->retract(length, restart_extra);  dE != 0) {
        if (this->config.use_firmware_retraction) {
            gcode = FLAVOR_IS(gcfMachinekit) ? "G22 ; retract\n" : "G10 ; retract\n";
        } else if (! m_extrusion_axis.empty()) {
            GCodeG1Formatter w;
            w.emit_e(m_extrusion_axis, emitE);
            w.emit_f(m_extruder->retract_speed() * 60.);
            w.emit_comment(this->config.gcode_comments, comment);
            gcode = w.string();
        }
    }
    
    if (FLAVOR_IS(gcfMakerWare))
        gcode += "M103 ; extruder off\n";
 
    return gcode;
}

References Slic3r::area(), config, Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_e(), Slic3r::GCodeFormatter::emit_f(), Slic3r::Extruder::filament_diameter(), FLAVOR_IS, Slic3r::gcfMachinekit, Slic3r::gcfMakerWare, Slic3r::length(), m_extruder, m_extrusion_axis, PI, Slic3r::Extruder::retract(), Slic3r::Extruder::retract_speed(), and Slic3r::GCodeFormatter::string().

Referenced by retract(), and retract_for_toolchange().

Here is the call graph for this function:

Here is the caller graph for this function:

_travel_to_z()

std::string Slic3r::GCodeWriter::_travel_to_z ( double  z, const std::string &  comment  )

private

{
    m_pos.z() = z;
 
    double speed = this->config.travel_speed_z.value;
    if (speed == 0.)
        speed = this->config.travel_speed.value;
    
    GCodeG1Formatter w;
    w.emit_z(z);
    w.emit_f(speed * 60.0);
    w.emit_comment(this->config.gcode_comments, comment);
    return w.string();
}

References config, Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_f(), Slic3r::GCodeFormatter::emit_z(), m_pos, and Slic3r::GCodeFormatter::string().

Referenced by lift(), travel_to_z(), and unlift().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_print_config()

void Slic3r::GCodeWriter::apply_print_config

(

const PrintConfig &

print_config

)

{
    this->config.apply(print_config, true);
    m_extrusion_axis = get_extrusion_axis(this->config);
    m_single_extruder_multi_material = print_config.single_extruder_multi_material.value;
    bool use_mach_limits = print_config.gcode_flavor.value == gcfMarlinLegacy
                        || print_config.gcode_flavor.value == gcfMarlinFirmware
                        || print_config.gcode_flavor.value == gcfRepRapFirmware;
    m_max_acceleration = static_cast<unsigned int>(std::round((use_mach_limits && print_config.machine_limits_usage.value == MachineLimitsUsage::EmitToGCode) ?
        print_config.machine_max_acceleration_extruding.values.front() : 0));
    m_max_travel_acceleration = static_cast<unsigned int>(std::round((use_mach_limits && print_config.machine_limits_usage.value == MachineLimitsUsage::EmitToGCode && supports_separate_travel_acceleration(print_config.gcode_flavor.value)) ?
        print_config.machine_max_acceleration_travel.values.front() : 0));
}

References config, Slic3r::EmitToGCode, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepRapFirmware, Slic3r::get_extrusion_axis(), m_extrusion_axis, m_max_acceleration, m_max_travel_acceleration, m_single_extruder_multi_material, and supports_separate_travel_acceleration().

Referenced by Slic3r::GCode::apply_print_config().

Here is the call graph for this function:

Here is the caller graph for this function:

extrude_to_xy()

std::string Slic3r::GCodeWriter::extrude_to_xy	(	const Vec2d &	point,
		double	dE,
		const std::string &	comment = std::string()
	)

{
    m_pos.x() = point.x();
    m_pos.y() = point.y();
 
    GCodeG1Formatter w;
    w.emit_xy(point);
    w.emit_e(m_extrusion_axis, m_extruder->extrude(dE).second);
    w.emit_comment(this->config.gcode_comments, comment);
    return w.string();
}

References config, Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_e(), Slic3r::GCodeFormatter::emit_xy(), Slic3r::Extruder::extrude(), m_extruder, m_extrusion_axis, m_pos, and Slic3r::GCodeFormatter::string().

Referenced by Slic3r::GCode::_extrude(), and Slic3r::Wipe::wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

extruder() [1/2]

Extruder * Slic3r::GCodeWriter::extruder ( )

inline

{ return m_extruder; }

References m_extruder.

Referenced by Slic3r::GCode::_do_export(), Slic3r::GCode::_extrude(), Slic3r::OozePrevention::_get_temp(), Slic3r::GCode::gcode_to_point(), Slic3r::need_wipe(), Slic3r::OozePrevention::post_toolchange(), Slic3r::OozePrevention::pre_toolchange(), Slic3r::GCode::process_layer(), Slic3r::GCode::retract(), Slic3r::GCode::set_extruder(), and Slic3r::Wipe::wipe().

Here is the caller graph for this function:

extruder() [2/2]

const Extruder * Slic3r::GCodeWriter::extruder ( ) const

inline

{ return m_extruder; }

References m_extruder.

extruder_ids()

std::vector< unsigned int > Slic3r::GCodeWriter::extruder_ids ( ) const

inline

                                                 { 
        std::vector<unsigned int> out; 
        out.reserve(m_extruders.size()); 
        for (const Extruder &e : m_extruders) 
            out.push_back(e.id()); 
        return out;
    }

References m_extruders.

Referenced by set_extruders().

Here is the caller graph for this function:

extruders()

const std::vector< Extruder > & Slic3r::GCodeWriter::extruders ( ) const

inline

{ return m_extruders; }

References m_extruders.

Referenced by Slic3r::CoolingBuffer::CoolingBuffer(), Slic3r::GCode::_do_export(), Slic3r::GCode::do_export(), Slic3r::GCode::PlaceholderParserIntegration::init(), Slic3r::GCode::placeholder_parser_process(), Slic3r::GCode::process_layer(), and Slic3r::GCode::PlaceholderParserIntegration::update_from_gcodewriter().

Here is the caller graph for this function:

extrusion_axis()

std::string Slic3r::GCodeWriter::extrusion_axis ( ) const

inline

{ return m_extrusion_axis; }

References m_extrusion_axis.

Referenced by Slic3r::GCode::_extrude().

Here is the caller graph for this function:

get_position()

Vec3d Slic3r::GCodeWriter::get_position ( ) const

inline

{ return m_pos; }

References m_pos.

Referenced by Slic3r::CoolingBuffer::CoolingBuffer(), Slic3r::GCode::_do_export(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::finalize(), and Slic3r::GCode::PlaceholderParserIntegration::update_from_gcodewriter().

Here is the caller graph for this function:

get_zhop()

double Slic3r::GCodeWriter::get_zhop ( ) const

inline

{ return m_lifted; }

References m_lifted.

Referenced by Slic3r::GCode::PlaceholderParserIntegration::init(), and Slic3r::GCode::PlaceholderParserIntegration::update_from_gcodewriter().

Here is the caller graph for this function:

lift()

std::string Slic3r::GCodeWriter::lift

(

)

{
    // check whether the above/below conditions are met
    double target_lift = 0;
    {
        double above = this->config.retract_lift_above.get_at(m_extruder->id());
        double below = this->config.retract_lift_below.get_at(m_extruder->id());
        if (m_pos.z() >= above && (below == 0 || m_pos.z() <= below))
            target_lift = this->config.retract_lift.get_at(m_extruder->id());
    }
    if (m_lifted == 0 && target_lift > 0) {
        m_lifted = target_lift;
        return this->_travel_to_z(m_pos.z() + target_lift, "lift Z");
    }
    return {};
}

References _travel_to_z(), config, Slic3r::Extruder::id(), m_extruder, m_lifted, and m_pos.

Referenced by Slic3r::GCode::retract().

Here is the call graph for this function:

Here is the caller graph for this function:

need_toolchange()

bool Slic3r::GCodeWriter::need_toolchange ( unsigned int  extruder_id ) const

inline

        { return m_extruder == nullptr || m_extruder->id() != extruder_id; }

References Slic3r::Extruder::id(), and m_extruder.

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), set_extruder(), Slic3r::GCode::set_extruder(), and Slic3r::WipeTowerIntegration::tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

postamble()

std::string Slic3r::GCodeWriter::postamble

(

)

const

{
    std::ostringstream gcode;
    if (FLAVOR_IS(gcfMachinekit))
          gcode << "M2 ; end of program\n";
    return gcode.str();
}

References FLAVOR_IS, and Slic3r::gcfMachinekit.

Referenced by Slic3r::GCode::_do_export().

Here is the caller graph for this function:

preamble()

std::string Slic3r::GCodeWriter::preamble

(

)

{
    std::ostringstream gcode;
    
    if (FLAVOR_IS_NOT(gcfMakerWare)) {
        gcode << "G21 ; set units to millimeters\n";
        gcode << "G90 ; use absolute coordinates\n";
    }
    if (FLAVOR_IS(gcfRepRapSprinter) ||
        FLAVOR_IS(gcfRepRapFirmware) ||
        FLAVOR_IS(gcfMarlinLegacy) ||
        FLAVOR_IS(gcfMarlinFirmware) ||
        FLAVOR_IS(gcfKlipper) ||
        FLAVOR_IS(gcfTeacup) ||
        FLAVOR_IS(gcfRepetier) ||
        FLAVOR_IS(gcfSmoothie))
    {
        if (this->config.use_relative_e_distances) {
            gcode << "M83 ; use relative distances for extrusion\n";
        } else {
            gcode << "M82 ; use absolute distances for extrusion\n";
        }
        gcode << this->reset_e(true);
    }
    
    return gcode.str();
}

References config, FLAVOR_IS, FLAVOR_IS_NOT, Slic3r::gcfKlipper, Slic3r::gcfMakerWare, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepetier, Slic3r::gcfRepRapFirmware, Slic3r::gcfRepRapSprinter, Slic3r::gcfSmoothie, Slic3r::gcfTeacup, and reset_e().

Referenced by Slic3r::GCode::preamble().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_e()

std::string Slic3r::GCodeWriter::reset_e

(

bool

force = false

)

{
    return
        FLAVOR_IS(gcfMach3) || FLAVOR_IS(gcfMakerWare) || FLAVOR_IS(gcfSailfish) || this->config.use_relative_e_distances ||
        (m_extruder != nullptr && ! m_extruder->reset_E() && ! force) || 
        m_extrusion_axis.empty() ?
        std::string{} :
        std::string("G92 ") + m_extrusion_axis + (this->config.gcode_comments ? "0 ; reset extrusion distance\n" : "0\n");
}

References config, FLAVOR_IS, Slic3r::gcfMach3, Slic3r::gcfMakerWare, Slic3r::gcfSailfish, m_extruder, m_extrusion_axis, and Slic3r::Extruder::reset_E().

Referenced by preamble(), Slic3r::GCode::retract(), toolchange(), and unretract().

Here is the call graph for this function:

Here is the caller graph for this function:

retract()

std::string Slic3r::GCodeWriter::retract

(

bool

before_wipe = false

)

{
    double factor = before_wipe ? m_extruder->retract_before_wipe() : 1.;
    assert(factor >= 0. && factor <= 1. + EPSILON);
    return this->_retract(
        factor * m_extruder->retract_length(),
        factor * m_extruder->retract_restart_extra(),
        "retract"
    );
}

References _retract(), EPSILON, m_extruder, Slic3r::Extruder::retract_before_wipe(), Slic3r::Extruder::retract_length(), and Slic3r::Extruder::retract_restart_extra().

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), and Slic3r::GCode::retract().

Here is the call graph for this function:

Here is the caller graph for this function:

retract_for_toolchange()

std::string Slic3r::GCodeWriter::retract_for_toolchange

(

bool

before_wipe = false

)

{
    double factor = before_wipe ? m_extruder->retract_before_wipe() : 1.;
    assert(factor >= 0. && factor <= 1. + EPSILON);
    return this->_retract(
        factor * m_extruder->retract_length_toolchange(),
        factor * m_extruder->retract_restart_extra_toolchange(),
        "retract for toolchange"
    );
}

References _retract(), EPSILON, m_extruder, Slic3r::Extruder::retract_before_wipe(), Slic3r::Extruder::retract_length_toolchange(), and Slic3r::Extruder::retract_restart_extra_toolchange().

Referenced by Slic3r::GCode::retract().

Here is the call graph for this function:

Here is the caller graph for this function:

set_acceleration_internal()

std::string Slic3r::GCodeWriter::set_acceleration_internal ( Acceleration  type, unsigned int  acceleration  )

private

{
    // Clamp the acceleration to the allowed maximum.
    if (type == Acceleration::Print && m_max_acceleration > 0 && acceleration > m_max_acceleration)
        acceleration = m_max_acceleration;
    if (type == Acceleration::Travel && m_max_travel_acceleration > 0 && acceleration > m_max_travel_acceleration)
        acceleration = m_max_travel_acceleration;
 
    // Are we setting travel acceleration for a flavour that supports separate travel and print acc?
    bool separate_travel = (type == Acceleration::Travel && supports_separate_travel_acceleration(this->config.gcode_flavor));
 
    auto& last_value = separate_travel ? m_last_travel_acceleration : m_last_acceleration ;
    if (acceleration == 0 || acceleration == last_value)
        return std::string();
    
    last_value = acceleration;
    
    std::ostringstream gcode;
    if (FLAVOR_IS(gcfRepetier))
        gcode << (separate_travel ? "M202 X" : "M201 X") << acceleration << " Y" << acceleration;
    else if (FLAVOR_IS(gcfRepRapFirmware) || FLAVOR_IS(gcfMarlinFirmware))
        gcode << (separate_travel ? "M204 T" : "M204 P") << acceleration;
    else
        gcode << "M204 S" << acceleration;
 
    if (this->config.gcode_comments) gcode << " ; adjust acceleration";
    gcode << "\n";
    
    return gcode.str();
}

References config, FLAVOR_IS, Slic3r::gcfMarlinFirmware, Slic3r::gcfRepetier, Slic3r::gcfRepRapFirmware, m_last_acceleration, m_last_travel_acceleration, m_max_acceleration, m_max_travel_acceleration, Print, supports_separate_travel_acceleration(), and Travel.

Referenced by set_print_acceleration(), and set_travel_acceleration().

Here is the call graph for this function:

Here is the caller graph for this function:

set_bed_temperature()

std::string Slic3r::GCodeWriter::set_bed_temperature	(	unsigned int	temperature,
		bool	wait = false
	)

{
    if (temperature == m_last_bed_temperature && (! wait || m_last_bed_temperature_reached))
        return std::string();
 
    m_last_bed_temperature = temperature;
    m_last_bed_temperature_reached = wait;
 
    std::string code, comment;
    if (wait && FLAVOR_IS_NOT(gcfTeacup)) {
        if (FLAVOR_IS(gcfMakerWare) || FLAVOR_IS(gcfSailfish)) {
            code = "M109";
        } else {
            code = "M190";
        }
        comment = "set bed temperature and wait for it to be reached";
    } else {
        code = "M140";
        comment = "set bed temperature";
    }
    
    std::ostringstream gcode;
    gcode << code << " ";
    if (FLAVOR_IS(gcfMach3) || FLAVOR_IS(gcfMachinekit)) {
        gcode << "P";
    } else {
        gcode << "S";
    }
    gcode << temperature << " ; " << comment << "\n";
    
    if (FLAVOR_IS(gcfTeacup) && wait)
        gcode << "M116 ; wait for bed temperature to be reached\n";
    
    return gcode.str();
}

References comment, FLAVOR_IS, FLAVOR_IS_NOT, Slic3r::gcfMach3, Slic3r::gcfMachinekit, Slic3r::gcfMakerWare, Slic3r::gcfSailfish, Slic3r::gcfTeacup, m_last_bed_temperature, and m_last_bed_temperature_reached.

Referenced by Slic3r::GCode::_print_first_layer_bed_temperature(), and Slic3r::GCode::process_layer().

Here is the caller graph for this function:

set_extruder()

std::string Slic3r::GCodeWriter::set_extruder ( unsigned int  extruder_id )

inline

        { return this->need_toolchange(extruder_id) ? this->toolchange(extruder_id) : ""; }

References need_toolchange(), and toolchange().

Here is the call graph for this function:

set_extruders()

void Slic3r::GCodeWriter::set_extruders

(

std::vector< unsigned int >

extruder_ids

)

{
    std::sort(extruder_ids.begin(), extruder_ids.end());
    m_extruders.clear();
    m_extruders.reserve(extruder_ids.size());
    for (unsigned int extruder_id : extruder_ids)
        m_extruders.emplace_back(Extruder(extruder_id, &this->config));
    
    /*  we enable support for multiple extruder if any extruder greater than 0 is used
        (even if prints only uses that one) since we need to output Tx commands
        first extruder has index 0 */
    this->multiple_extruders = (*std::max_element(extruder_ids.begin(), extruder_ids.end())) > 0;
}

References config, extruder_ids(), m_extruders, and multiple_extruders.

Referenced by Slic3r::GCode::set_extruders().

Here is the call graph for this function:

Here is the caller graph for this function:

set_fan() [1/2]

std::string Slic3r::GCodeWriter::set_fan ( const GCodeFlavor  gcode_flavor, bool  gcode_comments, unsigned int  speed  )

static

{
    std::ostringstream gcode;
    if (speed == 0) {
        switch (gcode_flavor) {
        case gcfTeacup:
            gcode << "M106 S0"; break;
        case gcfMakerWare:
        case gcfSailfish:
            gcode << "M127";    break;
        default:
            gcode << "M107";    break;
        }
        if (gcode_comments)
            gcode << " ; disable fan";
        gcode << "\n";
    } else {
        switch (gcode_flavor) {
        case gcfMakerWare:
        case gcfSailfish:
            gcode << "M126";    break;
        case gcfMach3:
        case gcfMachinekit:
            gcode << "M106 P" << 255.0 * speed / 100.0; break;
        default:
            gcode << "M106 S" << 255.0 * speed / 100.0; break;
        }
        if (gcode_comments) 
            gcode << " ; enable fan";
        gcode << "\n";
    }
    return gcode.str();
}

References Slic3r::gcfMach3, Slic3r::gcfMachinekit, Slic3r::gcfMakerWare, Slic3r::gcfSailfish, Slic3r::gcfTeacup, and Slic3r::gcode_flavor().

Referenced by Slic3r::GCode::_do_export(), Slic3r::CoolingBuffer::apply_layer_cooldown(), and set_fan().

Here is the call graph for this function:

Here is the caller graph for this function:

set_fan() [2/2]

std::string Slic3r::GCodeWriter::set_fan

(

unsigned int

speed

)

const

{
    return GCodeWriter::set_fan(this->config.gcode_flavor, this->config.gcode_comments, speed);
}

References config, and set_fan().

Here is the call graph for this function:

set_print_acceleration()

std::string Slic3r::GCodeWriter::set_print_acceleration ( unsigned int  acceleration )

inline

{ return set_acceleration_internal(Acceleration::Print, acceleration); }

References Print, and set_acceleration_internal().

Referenced by Slic3r::GCode::_extrude(), Slic3r::GCode::extrude_loop(), Slic3r::GCode::extrude_multi_path(), and Slic3r::GCode::extrude_path().

Here is the call graph for this function:

Here is the caller graph for this function:

set_speed()

std::string Slic3r::GCodeWriter::set_speed	(	double	F,
		const std::string &	comment = std::string(),
		const std::string &	cooling_marker = std::string()
	)		const

{
    assert(F > 0.);
    assert(F < 100000.);
 
    GCodeG1Formatter w;
    w.emit_f(F);
    w.emit_comment(this->config.gcode_comments, comment);
    w.emit_string(cooling_marker);
    return w.string();
}

References config, Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_f(), Slic3r::GCodeFormatter::emit_string(), Slic3r::F, and Slic3r::GCodeFormatter::string().

Referenced by Slic3r::GCode::_extrude(), and Slic3r::Wipe::wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

set_temperature()

std::string Slic3r::GCodeWriter::set_temperature	(	unsigned int	temperature,
		bool	wait = false,
		int	tool = -1
	)		const

{
    if (wait && (FLAVOR_IS(gcfMakerWare) || FLAVOR_IS(gcfSailfish)))
        return {};
    
    std::string code, comment;
    if (wait && FLAVOR_IS_NOT(gcfTeacup) && FLAVOR_IS_NOT(gcfRepRapFirmware)) {
        code = "M109";
        comment = "set temperature and wait for it to be reached";
    } else {
        if (FLAVOR_IS(gcfRepRapFirmware)) { // M104 is deprecated on RepRapFirmware
            code = "G10";
        } else {
            code = "M104";
        }
        comment = "set temperature";
    }
    
    std::ostringstream gcode;
    gcode << code << " ";
    if (FLAVOR_IS(gcfMach3) || FLAVOR_IS(gcfMachinekit)) {
        gcode << "P";
    } else {
        gcode << "S";
    }
    gcode << temperature;
    bool multiple_tools = this->multiple_extruders && ! m_single_extruder_multi_material;
    if (tool != -1 && (multiple_tools || FLAVOR_IS(gcfMakerWare) || FLAVOR_IS(gcfSailfish) || FLAVOR_IS(gcfRepRapFirmware)) ) {
        if (FLAVOR_IS(gcfRepRapFirmware)) {
            gcode << " P" << tool;
        } else {
            gcode << " T" << tool;
        }
    }
    gcode << " ; " << comment << "\n";
    
    if ((FLAVOR_IS(gcfTeacup) || FLAVOR_IS(gcfRepRapFirmware)) && wait)
        gcode << "M116 ; wait for temperature to be reached\n";
    
    return gcode.str();
}

References comment, FLAVOR_IS, FLAVOR_IS_NOT, Slic3r::gcfMach3, Slic3r::gcfMachinekit, Slic3r::gcfMakerWare, Slic3r::gcfRepRapFirmware, Slic3r::gcfSailfish, Slic3r::gcfTeacup, m_single_extruder_multi_material, and multiple_extruders.

Referenced by Slic3r::GCode::_print_first_layer_extruder_temperatures(), Slic3r::OozePrevention::post_toolchange(), Slic3r::OozePrevention::pre_toolchange(), Slic3r::GCode::process_layer(), and Slic3r::GCode::set_extruder().

Here is the caller graph for this function:

set_travel_acceleration()

std::string Slic3r::GCodeWriter::set_travel_acceleration ( unsigned int  acceleration )

inline

{ return set_acceleration_internal(Acceleration::Travel, acceleration); }

References set_acceleration_internal(), and Travel.

Referenced by Slic3r::GCode::travel_to().

Here is the call graph for this function:

Here is the caller graph for this function:

supports_separate_travel_acceleration()

bool Slic3r::GCodeWriter::supports_separate_travel_acceleration ( GCodeFlavor  flavor )

static

{
    return (flavor == gcfRepetier || flavor == gcfMarlinFirmware ||  flavor == gcfRepRapFirmware);
}

References Slic3r::gcfMarlinFirmware, Slic3r::gcfRepetier, and Slic3r::gcfRepRapFirmware.

Referenced by Slic3r::GCodeProcessor::apply_config(), apply_print_config(), set_acceleration_internal(), and Slic3r::GCode::travel_to().

Here is the caller graph for this function:

toolchange()

std::string Slic3r::GCodeWriter::toolchange

(

unsigned int

extruder_id

)

{
    // set the new extruder
  auto it_extruder = Slic3r::lower_bound_by_predicate(m_extruders.begin(), m_extruders.end(), [extruder_id](const Extruder &e) { return e.id() < extruder_id; });
    assert(it_extruder != m_extruders.end() && it_extruder->id() == extruder_id);
    m_extruder = &*it_extruder;
 
    // return the toolchange command
    // if we are running a single-extruder setup, just set the extruder and return nothing
    std::ostringstream gcode;
    if (this->multiple_extruders) {
        gcode << this->toolchange_prefix() << extruder_id;
        if (this->config.gcode_comments)
            gcode << " ; change extruder";
        gcode << "\n";
        gcode << this->reset_e(true);
    }
    return gcode.str();
}

References config, Slic3r::lower_bound_by_predicate(), m_extruder, m_extruders, multiple_extruders, reset_e(), and toolchange_prefix().

Referenced by set_extruder(), and Slic3r::GCode::set_extruder().

Here is the call graph for this function:

Here is the caller graph for this function:

toolchange_prefix()

std::string Slic3r::GCodeWriter::toolchange_prefix

(

)

const

{
    return FLAVOR_IS(gcfMakerWare) ? "M135 T" :
           FLAVOR_IS(gcfSailfish)  ? "M108 T" : "T";
}

References FLAVOR_IS, Slic3r::gcfMakerWare, and Slic3r::gcfSailfish.

Referenced by Slic3r::GCode::set_extruder(), and toolchange().

Here is the caller graph for this function:

travel_to_xy()

std::string Slic3r::GCodeWriter::travel_to_xy	(	const Vec2d &	point,
		const std::string &	comment = std::string()
	)

{
    m_pos.x() = point.x();
    m_pos.y() = point.y();
    
    GCodeG1Formatter w;
    w.emit_xy(point);
    w.emit_f(this->config.travel_speed.value * 60.0);
    w.emit_comment(this->config.gcode_comments, comment);
    return w.string();
}

References config, Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_f(), Slic3r::GCodeFormatter::emit_xy(), m_pos, and Slic3r::GCodeFormatter::string().

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::GCode::extrude_loop(), Slic3r::GCode::travel_to(), and travel_to_xyz().

Here is the call graph for this function:

Here is the caller graph for this function:

travel_to_xyz()

std::string Slic3r::GCodeWriter::travel_to_xyz	(	const Vec3d &	point,
		const std::string &	comment = std::string()
	)

{
    // FIXME: This function was not being used when travel_speed_z was separated (bd6badf).
    // Calculation of feedrate was not updated accordingly. If you want to use
    // this function, fix it first.
    std::terminate();
 
    /*  If target Z is lower than current Z but higher than nominal Z we
        don't perform the Z move but we only move in the XY plane and
        adjust the nominal Z by reducing the lift amount that will be 
        used for unlift. */
    if (!this->will_move_z(point.z())) {
        double nominal_z = m_pos.z() - m_lifted;
        m_lifted -= (point.z() - nominal_z);
        // In case that retract_lift == layer_height we could end up with almost zero in_m_lifted
        // and a retract could be skipped (https://github.com/prusa3d/PrusaSlicer/issues/2154
        if (std::abs(m_lifted) < EPSILON)
            m_lifted = 0.;
        return this->travel_to_xy(to_2d(point));
    }
    
    /*  In all the other cases, we perform an actual XYZ move and cancel
        the lift. */
    m_lifted = 0;
    m_pos = point;
    
    GCodeG1Formatter w;
    w.emit_xyz(point);
    w.emit_f(this->config.travel_speed.value * 60.0);
    w.emit_comment(this->config.gcode_comments, comment);
    return w.string();
}

References config, Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_f(), Slic3r::GCodeFormatter::emit_xyz(), EPSILON, m_lifted, m_pos, Slic3r::GCodeFormatter::string(), Slic3r::to_2d(), travel_to_xy(), and will_move_z().

Here is the call graph for this function:

travel_to_z()

std::string Slic3r::GCodeWriter::travel_to_z	(	double	z,
		const std::string &	comment = std::string()
	)

{
    /*  If target Z is lower than current Z but higher than nominal Z
        we don't perform the move but we only adjust the nominal Z by
        reducing the lift amount that will be used for unlift. */
    if (!this->will_move_z(z)) {
        double nominal_z = m_pos.z() - m_lifted;
        m_lifted -= (z - nominal_z);
        if (std::abs(m_lifted) < EPSILON)
            m_lifted = 0.;
        return {};
    }
    
    /*  In all the other cases, we perform an actual Z move and cancel
        the lift. */
    m_lifted = 0;
    return this->_travel_to_z(z, comment);
}

References _travel_to_z(), comment, EPSILON, m_lifted, m_pos, and will_move_z().

Referenced by Slic3r::GCode::_do_export(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::GCode::change_layer(), and Slic3r::GCode::preamble().

Here is the call graph for this function:

Here is the caller graph for this function:

unlift()

std::string Slic3r::GCodeWriter::unlift

(

)

{
    std::string gcode;
    if (m_lifted > 0) {
        gcode += this->_travel_to_z(m_pos.z() - m_lifted, "restore layer Z");
        m_lifted = 0;
    }
    return gcode;
}

References _travel_to_z(), m_lifted, and m_pos.

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), and Slic3r::GCode::unretract().

Here is the call graph for this function:

Here is the caller graph for this function:

unretract()

std::string Slic3r::GCodeWriter::unretract

(

)

{
    std::string gcode;
    
    if (FLAVOR_IS(gcfMakerWare))
        gcode = "M101 ; extruder on\n";
    
    if (auto [dE, emitE] = m_extruder->unretract(); dE != 0) {
        if (this->config.use_firmware_retraction) {
            gcode += FLAVOR_IS(gcfMachinekit) ? "G23 ; unretract\n" : "G11 ; unretract\n";
            gcode += this->reset_e();
        } else if (! m_extrusion_axis.empty()) {
            // use G1 instead of G0 because G0 will blend the restart with the previous travel move
            GCodeG1Formatter w;
            w.emit_e(m_extrusion_axis, emitE);
            w.emit_f(m_extruder->deretract_speed() * 60.);
            w.emit_comment(this->config.gcode_comments, " ; unretract");
            gcode += w.string();
        }
    }
    
    return gcode;
}

References config, Slic3r::Extruder::deretract_speed(), Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_e(), Slic3r::GCodeFormatter::emit_f(), FLAVOR_IS, Slic3r::gcfMachinekit, Slic3r::gcfMakerWare, m_extruder, m_extrusion_axis, reset_e(), Slic3r::GCodeFormatter::string(), and Slic3r::Extruder::unretract().

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::ProcessLayer::emit_custom_gcode_per_print_z(), and Slic3r::GCode::unretract().

Here is the call graph for this function:

Here is the caller graph for this function:

update_position()

void Slic3r::GCodeWriter::update_position

(

const Vec3d &

new_pos

)

{
    assert(this->m_lifted >= 0);
    const double nominal_z = m_pos.z() - m_lifted;
    m_lifted = new_pos.z() - nominal_z;
    if (m_lifted < - EPSILON)
        throw Slic3r::RuntimeError("Custom G-code reports negative Z-hop. Final Z position is below the print_z height.");
    // In case that retract_lift == layer_height we could end up with almost zero in_m_lifted
    // and a retract could be skipped (https://github.com/prusa3d/PrusaSlicer/issues/2154
    if (m_lifted < EPSILON)
        m_lifted = 0.;
    m_pos = new_pos;
}

References EPSILON, m_lifted, and m_pos.

Referenced by Slic3r::GCode::placeholder_parser_process().

Here is the caller graph for this function:

update_progress()

std::string Slic3r::GCodeWriter::update_progress	(	unsigned int	num,
		unsigned int	tot,
		bool	allow_100 = false
	)		const

{
    if (FLAVOR_IS_NOT(gcfMakerWare) && FLAVOR_IS_NOT(gcfSailfish))
        return {};
    
    unsigned int percent = (unsigned int)floor(100.0 * num / tot + 0.5);
    if (!allow_100) percent = std::min(percent, (unsigned int)99);
    
    std::ostringstream gcode;
    gcode << "M73 P" << percent;
    if (this->config.gcode_comments) gcode << " ; update progress";
    gcode << "\n";
    return gcode.str();
}

References config, FLAVOR_IS_NOT, floor(), Slic3r::gcfMakerWare, and Slic3r::gcfSailfish.

Referenced by Slic3r::GCode::_do_export(), and Slic3r::GCode::change_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

will_move_z()

bool Slic3r::GCodeWriter::will_move_z

(

double

z

)

const

{
    /* If target Z is lower than current Z but higher than nominal Z
        we don't perform an actual Z move. */
    if (m_lifted > 0) {
        double nominal_z = m_pos.z() - m_lifted;
        if (z >= nominal_z && z <= m_pos.z())
            return false;
    }
    return true;
}

References m_lifted, and m_pos.

Referenced by Slic3r::GCode::change_layer(), travel_to_xyz(), and travel_to_z().

Here is the caller graph for this function:

Member Data Documentation

config

GCodeConfig Slic3r::GCodeWriter::config

Referenced by _retract(), _travel_to_z(), apply_print_config(), extrude_to_xy(), Slic3r::GCode::PlaceholderParserIntegration::init(), lift(), Slic3r::GCode::placeholder_parser_process(), preamble(), reset_e(), set_acceleration_internal(), set_extruders(), set_fan(), set_speed(), toolchange(), travel_to_xy(), travel_to_xyz(), unretract(), Slic3r::GCode::PlaceholderParserIntegration::update_from_gcodewriter(), update_progress(), and Slic3r::Wipe::wipe().

m_extruder

Extruder* Slic3r::GCodeWriter::m_extruder

private

Referenced by _retract(), extrude_to_xy(), extruder(), extruder(), lift(), need_toolchange(), reset_e(), retract(), retract_for_toolchange(), toolchange(), and unretract().

m_extruders

std::vector<Extruder> Slic3r::GCodeWriter::m_extruders

private

Referenced by extruder_ids(), extruders(), set_extruders(), and toolchange().

m_extrusion_axis

std::string Slic3r::GCodeWriter::m_extrusion_axis

private

Referenced by _retract(), apply_print_config(), extrude_to_xy(), extrusion_axis(), reset_e(), and unretract().

m_last_acceleration

unsigned int Slic3r::GCodeWriter::m_last_acceleration = (unsigned int)(-1)

private

Referenced by set_acceleration_internal().

m_last_bed_temperature

unsigned int Slic3r::GCodeWriter::m_last_bed_temperature

private

Referenced by set_bed_temperature().

m_last_bed_temperature_reached

bool Slic3r::GCodeWriter::m_last_bed_temperature_reached

private

Referenced by set_bed_temperature().

m_last_travel_acceleration

unsigned int Slic3r::GCodeWriter::m_last_travel_acceleration = (unsigned int)(-1)

private

Referenced by set_acceleration_internal().

m_lifted

double Slic3r::GCodeWriter::m_lifted

private

Referenced by get_zhop(), lift(), travel_to_xyz(), travel_to_z(), unlift(), update_position(), and will_move_z().

m_max_acceleration

unsigned int Slic3r::GCodeWriter::m_max_acceleration

private

Referenced by apply_print_config(), and set_acceleration_internal().

m_max_travel_acceleration

unsigned int Slic3r::GCodeWriter::m_max_travel_acceleration

private

Referenced by apply_print_config(), and set_acceleration_internal().

m_pos

Vec3d Slic3r::GCodeWriter::m_pos = Vec3d::Zero()

private

Referenced by _travel_to_z(), extrude_to_xy(), get_position(), lift(), travel_to_xy(), travel_to_xyz(), travel_to_z(), unlift(), update_position(), and will_move_z().

m_single_extruder_multi_material

bool Slic3r::GCodeWriter::m_single_extruder_multi_material

private

Referenced by apply_print_config(), and set_temperature().

multiple_extruders

bool Slic3r::GCodeWriter::multiple_extruders

Referenced by Slic3r::GCode::set_extruder(), set_extruders(), set_temperature(), and toolchange().

---

The documentation for this class was generated from the following files:

• src/libslic3r/GCodeWriter.hpp
• src/libslic3r/GCodeWriter.cpp