Slic3r::DevFan Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DeviceCore/DevFan.h>

Collaboration diagram for Slic3r::DevFan:

Public Types
enum	FanType {   COOLING_FAN = 1 , BIG_COOLING_FAN = 2 , CHAMBER_FAN = 3 , EXHAUST_FAN ,   FILTER_FAN }

Public Member Functions
	DevFan (MachineObject *obj)
bool	is_at_heating_mode () const
bool	is_at_cooling_mode () const
void	SetSupportCoolingFilter (bool enable)
AirDuctData	GetAirDuctData ()
void	converse_to_duct (bool is_suppt_part_fun, bool is_suppt_aux_fun, bool is_suppt_cham_fun)
int	command_handle_response (const nlohmann::json &response)
int	command_control_fan (int fan_type, int val)
int	command_control_fan_new (int fan_id, int val)
int	command_control_air_duct (int mode_id, int submode, const CommandCallBack &cb)
void	ParseV1_0 (const nlohmann::json &print_json)
void	ParseV2_0 (const nlohmann::json &print_json)
void	ParseV3_0 (const nlohmann::json &print_json)
bool	GetSupportAirduct ()
bool	GetSupportAuxFanData ()
bool	GetSupportChamberFan ()
int	GetHeatBreakFanSpeed ()
int	GetCoolingFanSpeed ()
int	GetBigFan1Speed ()
int	GetBigFan2Speed ()
uint32_t	GetFanGear ()

Private Attributes
AirDuctData	m_air_duct_data
bool	is_support_aux_fan {false}
bool	is_support_chamber_fan {false}
bool	is_support_airduct {false}
int	heatbreak_fan_speed = 0
int	cooling_fan_speed = 0
int	big_fan1_speed = 0
int	big_fan2_speed = 0
uint32_t	fan_gear = 0
std::map< std::string, CommandCallBack >	m_callback_list
MachineObject *	m_owner = nullptr

Detailed Description

Member Enumeration Documentation

FanType

enum Slic3r::DevFan::FanType

Enumerator
COOLING_FAN
BIG_COOLING_FAN
CHAMBER_FAN
EXHAUST_FAN
FILTER_FAN

                 {//if have devPrinter , delete?
        COOLING_FAN     = 1,
        BIG_COOLING_FAN = 2,
        CHAMBER_FAN     = 3,
        EXHAUST_FAN,
        FILTER_FAN,
    };

Constructor & Destructor Documentation

DevFan()

Slic3r::DevFan::DevFan ( MachineObject * obj )

inline

: m_owner(obj){};

References m_owner.

Member Function Documentation

command_control_air_duct()

int Slic3r::DevFan::command_control_air_duct	(	int	mode_id,
		int	submode,
		const CommandCallBack &	cb )

{
    BOOST_LOG_TRIVIAL(info) << "MachineObject::command_control_air_duct, set air duct, d = " << mode_id;
    m_callback_list[std::to_string(m_owner->m_sequence_id)] = cb;
    json j;
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["command"]     = "set_airduct";
    j["print"]["modeId"]      = mode_id;
    j["print"]["submode"]     = submode;
 
    return m_owner->publish_json(j);
}

References m_callback_list, m_owner, and Slic3r::MachineObject::m_sequence_id.

command_control_fan()

int Slic3r::DevFan::command_control_fan	(	int	fan_type,
		int	val )

{
    // Orca: strip analytics telemetry
    std::string gcode = (boost::format("M106 P%1% S%2% \n") % (int) fan_type % (val)).str();
    return m_owner->publish_gcode(gcode);
}

References m_owner.

command_control_fan_new()

int Slic3r::DevFan::command_control_fan_new	(	int	fan_id,
		int	val )

{
    BOOST_LOG_TRIVIAL(info) << "New protocol of fan setting(set speed), fan_id = " << fan_id;
    json j;
    j["print"]["command"]     = "set_fan";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["fan_index"]   = fan_id;
 
    j["print"]["speed"] = val;
    BOOST_LOG_TRIVIAL(info) << "MachineObject::command_control_fan_val, set the speed of fan, fan_id = " << fan_id;
    return m_owner->publish_json(j);
}

References m_owner, and Slic3r::MachineObject::m_sequence_id.

command_handle_response()

int Slic3r::DevFan::command_handle_response

(

const nlohmann::json &

response

)

{
    if (!response.contains("sequence_id")) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ", error reponse.";
        return -1;
    }
 
    std::string reply = response["sequence_id"].get<std::string>();
    auto        it    = m_callback_list.find(reply);
    if (it != m_callback_list.end()) {
        if (it->second) it->second(response);
        m_callback_list.erase(it);
    }
    return 0;
}

References m_callback_list.

converse_to_duct()

void Slic3r::DevFan::converse_to_duct	(	bool	is_suppt_part_fun,
		bool	is_suppt_aux_fun,
		bool	is_suppt_cham_fun )

{
     m_air_duct_data.modes.clear();
     m_air_duct_data.parts.clear();
     m_air_duct_data.curren_mode = -1; // def mode
 
     if (is_suppt_part_fun) {
         AirParts part_fan;
         part_fan.type        = int(AirDuctType::AIR_FAN_TYPE);
         part_fan.id          = int(AIR_FUN::FAN_COOLING_0_AIRDOOR);
         part_fan.func        = int(AIR_FUN::FAN_COOLING_0_AIRDOOR);
         part_fan.state       = 0;
         part_fan.range_start = 0;
         part_fan.range_end   = 100;
         m_air_duct_data.parts.push_back(part_fan);
     }
 
     if (is_suppt_aux_fun) {
         AirParts aux_fan;
         aux_fan.type        = int(AirDuctType::AIR_FAN_TYPE);
         aux_fan.id          = int(AIR_FUN::FAN_REMOTE_COOLING_0_IDX);
         aux_fan.func        = int(AIR_FUN::FAN_REMOTE_COOLING_0_IDX);
         aux_fan.state       = 0;
         aux_fan.range_start = 0;
         aux_fan.range_end   = 100;
         m_air_duct_data.parts.push_back(aux_fan);
     }
 
     if (is_suppt_aux_fun) {
         AirParts chamber_fan;
         chamber_fan.type        = int(AirDuctType::AIR_FAN_TYPE);
         chamber_fan.id          = int(AIR_FUN::FAN_CHAMBER_0_IDX);
         chamber_fan.func        = int(AIR_FUN::FAN_CHAMBER_0_IDX);
         chamber_fan.state       = 0;
         chamber_fan.range_start = 0;
         chamber_fan.range_end   = 100;
         m_air_duct_data.parts.push_back(chamber_fan);
     }
}

References Slic3r::AIR_FAN_TYPE, Slic3r::FAN_CHAMBER_0_IDX, Slic3r::FAN_COOLING_0_AIRDOOR, Slic3r::FAN_REMOTE_COOLING_0_IDX, Slic3r::AirParts::func, Slic3r::AirParts::id, m_air_duct_data, Slic3r::AirParts::range_end, Slic3r::AirParts::range_start, Slic3r::AirParts::state, and Slic3r::AirParts::type.

GetAirDuctData()

AirDuctData Slic3r::DevFan::GetAirDuctData ( )

inline

{ return m_air_duct_data; };

References m_air_duct_data.

Referenced by Slic3r::GUI::FanControlPopupNew::update_fan_data(), and Slic3r::GUI::PrintOptionsDialog::update_purify_air_at_print_end().

Here is the caller graph for this function:

GetBigFan1Speed()

int Slic3r::DevFan::GetBigFan1Speed ( )

inline

{ return big_fan1_speed; }

References big_fan1_speed.

Referenced by Slic3r::GUI::FanControlPopupNew::update_fan_data().

Here is the caller graph for this function:

GetBigFan2Speed()

int Slic3r::DevFan::GetBigFan2Speed ( )

inline

{ return big_fan2_speed; }

References big_fan2_speed.

Referenced by Slic3r::GUI::FanControlPopupNew::update_fan_data().

Here is the caller graph for this function:

GetCoolingFanSpeed()

int Slic3r::DevFan::GetCoolingFanSpeed ( )

inline

{ return cooling_fan_speed; }

References cooling_fan_speed.

Referenced by Slic3r::GUI::FanControlPopupNew::update_fan_data().

Here is the caller graph for this function:

GetFanGear()

uint32_t Slic3r::DevFan::GetFanGear ( )

inline

{ return fan_gear; }

References fan_gear.

GetHeatBreakFanSpeed()

int Slic3r::DevFan::GetHeatBreakFanSpeed ( )

inline

{ return heatbreak_fan_speed; }

References heatbreak_fan_speed.

GetSupportAirduct()

bool Slic3r::DevFan::GetSupportAirduct ( )

inline

{ return is_support_airduct; };

References is_support_airduct.

GetSupportAuxFanData()

bool Slic3r::DevFan::GetSupportAuxFanData ( )

inline

{ return is_support_aux_fan; };

References is_support_aux_fan.

GetSupportChamberFan()

bool Slic3r::DevFan::GetSupportChamberFan ( )

inline

{ return is_support_aux_fan; };

References is_support_aux_fan.

is_at_cooling_mode()

bool Slic3r::DevFan::is_at_cooling_mode ( ) const

inline

{ return m_air_duct_data.curren_mode == AIR_DUCT_COOLING_FILT; };

References Slic3r::AIR_DUCT_COOLING_FILT, and m_air_duct_data.

is_at_heating_mode()

bool Slic3r::DevFan::is_at_heating_mode ( ) const

inline

{ return m_air_duct_data.curren_mode == AIR_DUCT_HEATING_INTERNAL_FILT; };

References Slic3r::AIR_DUCT_HEATING_INTERNAL_FILT, and m_air_duct_data.

ParseV1_0()

void Slic3r::DevFan::ParseV1_0

(

const nlohmann::json &

print_json

)

{
    if (print_json.contains("fan_gear")) {
        fan_gear          = print_json["fan_gear"].get<std::uint32_t>();
        big_fan2_speed    = (int) ((fan_gear & 0x00FF0000) >> 16);
        big_fan1_speed    = (int) ((fan_gear & 0x0000FF00) >> 8);
        cooling_fan_speed = (int) ((fan_gear & 0x000000FF) >> 0);
    } else {
        if (print_json.contains("cooling_fan_speed")) {
            cooling_fan_speed = stoi(print_json["cooling_fan_speed"].get<std::string>());
            cooling_fan_speed = round(floor(cooling_fan_speed / float(1.5)) * float(25.5));
        } else {
            cooling_fan_speed = 0;
        }
        if (print_json.contains("big_fan1_speed")) {
            big_fan1_speed = stoi(print_json["big_fan1_speed"].get<std::string>());
            big_fan1_speed = round(floor(big_fan1_speed / float(1.5)) * float(25.5));
        } else {
            big_fan1_speed = 0;
        }
        if (print_json.contains("big_fan2_speed")) {
            big_fan2_speed = stoi(print_json["big_fan2_speed"].get<std::string>());
            big_fan2_speed = round(floor(big_fan2_speed / float(1.5)) * float(25.5));
        } else {
            big_fan2_speed = 0;
        }
    }
 
    if (print_json.contains("heatbreak_fan_speed")) { heatbreak_fan_speed = stoi(print_json["heatbreak_fan_speed"].get<std::string>()); }
 
 
 
}

References big_fan1_speed, big_fan2_speed, cooling_fan_speed, fan_gear, and heatbreak_fan_speed.

ParseV2_0()

void Slic3r::DevFan::ParseV2_0

(

const nlohmann::json &

print_json

)

                                                   {
 
     if (print_json.contains("support_aux_fan")) {
        if (print_json["support_aux_fan"].is_boolean())
            is_support_aux_fan = print_json["support_aux_fan"].get<bool>();
     }
 
    if (print_json.contains("support_chamber_fan")) {
        if (print_json["support_chamber_fan"].is_boolean())
            is_support_chamber_fan = print_json["support_chamber_fan"].get<bool>();
    }
}

References is_support_aux_fan, and is_support_chamber_fan.

ParseV3_0()

void Slic3r::DevFan::ParseV3_0

(

const nlohmann::json &

print_json

)

{
    if (device.contains("airduct")) {
        is_support_airduct = true;
        m_air_duct_data.curren_mode = -1;
        m_air_duct_data.modes.clear();
        m_air_duct_data.parts.clear();
 
        const json &airduct = device["airduct"];
        if (airduct.contains("modeCur")) { m_air_duct_data.curren_mode = airduct["modeCur"].get<int>(); }
        if (airduct.contains("subMode")) { m_air_duct_data.m_sub_mode = airduct["subMode"].get<int>(); }
        if (airduct.contains("modeList") && airduct["modeList"].is_array()) {
            auto list = airduct["modeList"].get<std::vector<json>>();
 
            for (int i = 0; i < list.size(); ++i) {
                // only show 2 mode for o
                if (m_owner->is_series_o() && i >= 2) { break; }
 
                json    mode_json = list[i];
                AirMode mode;
                if (mode_json.contains("modeId")) mode.id = mode_json["modeId"].get<int>();
                if (mode_json.contains("ctrl")) {
                    for (auto it_mode_ctrl = mode_json["ctrl"].begin(); it_mode_ctrl != mode_json["ctrl"].end(); it_mode_ctrl++) {
                        mode.ctrl.push_back((*it_mode_ctrl).get<int>() >> 4);
                    }
                }
 
                if (mode_json.contains("off")) {
                    for (auto it_mode_off = mode_json["off"].begin(); it_mode_off != mode_json["off"].end(); *it_mode_off++) {
                        mode.off.push_back((*it_mode_off).get<int>() >> 4);
                    }
                }
 
                if (AIR_DUCT(mode.id) == AIR_DUCT::AIR_DUCT_EXHAUST) { continue; }
                m_air_duct_data.modes[mode.id] = mode;
            }
        }
 
        if (airduct.contains("parts") && airduct["parts"].is_array()) {
            for (auto it_part = airduct["parts"].begin(); it_part != airduct["parts"].end(); it_part++) {
                int state = (*it_part)["state"].get<int>();
                int range = (*it_part)["range"].get<int>();
 
                AirParts part;
                part.type        = m_owner->get_flag_bits((*it_part)["id"].get<int>(), 0, 4);
                part.id          = m_owner->get_flag_bits((*it_part)["id"].get<int>(), 4, 8);
                part.func        = (*it_part)["func"].get<int>();
                part.state       = m_owner->get_flag_bits(state, 0, 8);
                part.range_start = m_owner->get_flag_bits(range, 0, 16);
                part.range_end   = m_owner->get_flag_bits(range, 16, 16);
 
                m_air_duct_data.parts.push_back(part);
            }
        }
    }
 
}

References Slic3r::AIR_DUCT_EXHAUST, Slic3r::AirMode::ctrl, Slic3r::AirMode::id, is_support_airduct, m_air_duct_data, m_owner, Slic3r::AirMode::off, Slic3r::range(), and Slic3r::AirParts::type.

Here is the call graph for this function:

SetSupportCoolingFilter()

void Slic3r::DevFan::SetSupportCoolingFilter ( bool enable )

inline

{ m_air_duct_data.m_support_cooling_filter = enable; }

References m_air_duct_data.

Member Data Documentation

big_fan1_speed

int Slic3r::DevFan::big_fan1_speed = 0

private

Referenced by GetBigFan1Speed(), and ParseV1_0().

big_fan2_speed

int Slic3r::DevFan::big_fan2_speed = 0

private

Referenced by GetBigFan2Speed(), and ParseV1_0().

cooling_fan_speed

int Slic3r::DevFan::cooling_fan_speed = 0

private

Referenced by GetCoolingFanSpeed(), and ParseV1_0().

fan_gear

uint32_t Slic3r::DevFan::fan_gear = 0

private

Referenced by GetFanGear(), and ParseV1_0().

heatbreak_fan_speed

int Slic3r::DevFan::heatbreak_fan_speed = 0

private

Referenced by GetHeatBreakFanSpeed(), and ParseV1_0().

is_support_airduct

bool Slic3r::DevFan::is_support_airduct {false}

private

{false};

Referenced by GetSupportAirduct(), and ParseV3_0().

is_support_aux_fan

bool Slic3r::DevFan::is_support_aux_fan {false}

private

{false};

Referenced by GetSupportAuxFanData(), GetSupportChamberFan(), and ParseV2_0().

is_support_chamber_fan

bool Slic3r::DevFan::is_support_chamber_fan {false}

private

{false};

Referenced by ParseV2_0().

m_air_duct_data

AirDuctData Slic3r::DevFan::m_air_duct_data

private

Referenced by converse_to_duct(), GetAirDuctData(), is_at_cooling_mode(), is_at_heating_mode(), ParseV3_0(), and SetSupportCoolingFilter().

m_callback_list

std::map<std::string, CommandCallBack> Slic3r::DevFan::m_callback_list

private

Referenced by command_control_air_duct(), and command_handle_response().

m_owner

MachineObject* Slic3r::DevFan::m_owner = nullptr

private

Referenced by DevFan(), command_control_air_duct(), command_control_fan(), command_control_fan_new(), and ParseV3_0().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DeviceCore/DevFan.h
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DeviceCore/DevFan.cpp