mozhe
/
BambuStudio
5
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

NEW:support new nozzle and extder data 

jira:[new nozzle data]

Change-Id: Ief37b42794ce1469163fcd8227431ec77957508e
This commit is contained in:
tao wang 2024-10-26 14:30:18 +08:00 committed by lane.wei
parent 28d0fc9bbe
commit db8ae4ccb3
15 changed files with 476 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/libslic3r/PrintConfig.hpp
View File

@ -263,6 +263,13 @@ static std::unordered_map<NozzleType, std::string>NozzleTypeEumnToStr = {
{NozzleType::ntBrass, "brass"}
};
static std::unordered_map<std::string, NozzleType>NozzleTypeStrToEumn = {
{"undefine", NozzleType::ntUndefine},
{"hardened_steel", NozzleType::ntHardenedSteel},
{"stainless_steel", NozzleType::ntStainlessSteel},
{"brass", NozzleType::ntBrass}
};
// BBS
enum PrinterStructure {
psUndefine=0,

10
src/slic3r/GUI/AMSMaterialsSetting.cpp
View File

@ -520,7 +520,7 @@ void AMSMaterialsSetting::on_select_reset(wxCommandEvent& event) {
else {
PACalibIndexInfo select_index_info;
select_index_info.tray_id = slot_id;
select_index_info.nozzle_diameter = obj->m_extder_data.extders[0].diameter;
select_index_info.nozzle_diameter = obj->m_extder_data.extders[0].current_nozzle_diameter;
select_index_info.cali_idx = -1;
select_index_info.filament_id = selected_ams_id;
CalibUtils::select_PA_calib_result(select_index_info);
@ -661,7 +661,7 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
if (obj->cali_version >= 0) {
PACalibIndexInfo select_index_info;
select_index_info.tray_id = vt_tray;
select_index_info.nozzle_diameter = obj->m_extder_data.extders[0].diameter;
select_index_info.nozzle_diameter = obj->m_extder_data.extders[0].current_nozzle_diameter;
auto cali_select_id = m_comboBox_cali_result->GetSelection();
if (m_pa_profile_items.size() > 0 && cali_select_id >= 0) {
@ -700,7 +700,7 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
if (obj->cali_version >= 0) {
PACalibIndexInfo select_index_info;
select_index_info.tray_id = cali_tray_id;
select_index_info.nozzle_diameter = obj->m_extder_data.extders[0].diameter;
select_index_info.nozzle_diameter = obj->m_extder_data.extders[0].current_nozzle_diameter;
auto cali_select_id = m_comboBox_cali_result->GetSelection();
if (m_pa_profile_items.size() > 0 && cali_select_id > 0) {
@ -863,7 +863,7 @@ void AMSMaterialsSetting::Popup(wxString filament, wxString sn, wxString temp_mi
std::set<std::string> filament_id_set;
PresetBundle * preset_bundle = wxGetApp().preset_bundle;
std::ostringstream stream;
stream << std::fixed << std::setprecision(1) << obj->m_extder_data.extders[0].diameter;
stream << std::fixed << std::setprecision(1) << obj->m_extder_data.extders[0].current_nozzle_diameter;
std::string nozzle_diameter_str = stream.str();
std::set<std::string> printer_names = preset_bundle->get_printer_names_by_printer_type_and_nozzle(MachineObject::get_preset_printer_model_name(obj->printer_type), nozzle_diameter_str);
@ -1035,7 +1035,7 @@ void AMSMaterialsSetting::on_select_filament(wxCommandEvent &evt)
if (preset_bundle) {
std::ostringstream stream;
if (obj)
stream << std::fixed << std::setprecision(1) << obj->m_extder_data.extders[0].diameter;
stream << std::fixed << std::setprecision(1) << obj->m_extder_data.extders[0].current_nozzle_diameter;
std::string nozzle_diameter_str = stream.str();
std::set<std::string> printer_names = preset_bundle->get_printer_names_by_printer_type_and_nozzle(MachineObject::get_preset_printer_model_name(obj->printer_type),
nozzle_diameter_str);

6
src/slic3r/GUI/CaliHistoryDialog.cpp
View File

@ -210,7 +210,7 @@ void HistoryWindow::on_device_connected(MachineObject* obj)
int selection = 1;
for (int i = 0; i < nozzle_diameter_list.size(); i++) {
m_comboBox_nozzle_dia->AppendString(wxString::Format("%1.1f mm", nozzle_diameter_list[i]));
if (abs(curr_obj->m_extder_data.extders[0].diameter - nozzle_diameter_list[i]) < 1e-3) {
if (abs(curr_obj->m_extder_data.extders[0].current_nozzle_diameter - nozzle_diameter_list[i]) < 1e-3) {
selection = i;
}
}
@ -615,7 +615,7 @@ wxArrayString NewCalibrationHistoryDialog::get_all_filaments(const MachineObject
std::set<std::string> filament_id_set;
std::set<std::string> printer_names;
std::ostringstream stream;
stream << std::fixed << std::setprecision(1) << obj->m_extder_data.extders[0].diameter;
stream << std::fixed << std::setprecision(1) << obj->m_extder_data.extders[0].current_nozzle_diameter;
std::string nozzle_diameter_str = stream.str();
for (auto printer_it = preset_bundle->printers.begin(); printer_it != preset_bundle->printers.end(); printer_it++) {
@ -759,7 +759,7 @@ NewCalibrationHistoryDialog::NewCalibrationHistoryDialog(wxWindow *parent, const
static std::array<float, 4> nozzle_diameter_list = {0.2f, 0.4f, 0.6f, 0.8f};
for (int i = 0; i < nozzle_diameter_list.size(); i++) {
m_comboBox_nozzle_diameter->AppendString(wxString::Format("%1.1f mm", nozzle_diameter_list[i]));
if (abs(obj->m_extder_data.extders[0].diameter - nozzle_diameter_list[i]) < 1e-3) {
if (abs(obj->m_extder_data.extders[0].current_nozzle_diameter - nozzle_diameter_list[i]) < 1e-3) {
m_comboBox_nozzle_diameter->SetSelection(i);
}
}

2
src/slic3r/GUI/CalibrationWizard.cpp
View File

@ -619,7 +619,7 @@ void PressureAdvanceWizard::update(MachineObject* obj)
if (obj->cali_version != -1 && obj->cali_version != cali_version) {
cali_version = obj->cali_version;
PACalibExtruderInfo cali_info;
cali_info.nozzle_diameter = obj->m_extder_data.extders[0].diameter;
cali_info.nozzle_diameter = obj->m_extder_data.extders[0].current_nozzle_diameter;
CalibUtils::emit_get_PA_calib_info(cali_info);
}
}

4
src/slic3r/GUI/CalibrationWizardCaliPage.cpp
View File

@ -500,8 +500,8 @@ float CalibrationCaliPage::get_selected_calibration_nozzle_dia(MachineObject* ob
return obj->cali_selected_nozzle_dia;
// return default nozzle if nozzle diameter is set
if (obj->m_extder_data.extders[0].diameter > 1e-3 && obj->m_extder_data.extders[0].diameter < 10.0f)
return obj->m_extder_data.extders[0].diameter;
if (obj->m_extder_data.extders[0].current_nozzle_diameter > 1e-3 && obj->m_extder_data.extders[0].current_nozzle_diameter < 10.0f)
return obj->m_extder_data.extders[0].current_nozzle_diameter;
// return 0.4 by default
return 0.4;

4
src/slic3r/GUI/CalibrationWizardPresetPage.cpp
View File

@ -1867,7 +1867,7 @@ void CalibrationPresetPage::init_with_machine(MachineObject* obj)
// set nozzle value from machine
bool nozzle_is_set = false;
for (int i = 0; i < NOZZLE_LIST_COUNT; i++) {
if (abs(obj->m_extder_data.extders[0].diameter - nozzle_diameter_list[i]) < 1e-3) {
if (abs(obj->m_extder_data.extders[0].current_nozzle_diameter - nozzle_diameter_list[i]) < 1e-3) {
if (m_comboBox_nozzle_dia->GetCount() > i) {
m_comboBox_nozzle_dia->SetSelection(i);
nozzle_is_set = true;
@ -1890,7 +1890,7 @@ void CalibrationPresetPage::init_with_machine(MachineObject* obj)
if (obj->is_multi_extruders()) {
for (int i = 0; i < m_comboBox_nozzle_volume_types.size(); ++i) {
m_comboBox_nozzle_volume_types[i]->Show();
m_comboBox_nozzle_volume_types[i]->SetSelection(obj->m_extder_data.extders[i].flow_type);
m_comboBox_nozzle_volume_types[i]->SetSelection(obj->m_extder_data.extders[i].current_nozzle_flow_type);
}
if (!obj->is_main_extruder_on_left() && m_main_extruder_on_left) {

181
src/slic3r/GUI/DeviceManager.cpp
View File

@ -2065,6 +2065,19 @@ int MachineObject::command_set_printer_nozzle(std::string nozzle_type, float dia
return this->publish_json(j.dump());
}
int MachineObject::command_set_printer_nozzle2(int id, std::string nozzle_type, float diameter, int flow)
{
nozzle_setting_hold_count = HOLD_COUNT_MAX * 2;
BOOST_LOG_TRIVIAL(info) << "command_set_printer_nozzle2, nozzle_type = " << nozzle_type << " diameter = " << diameter;
json j;
j["print"]["command"] = "set_nozzle";
j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
j["print"]["id"] = id;
j["print"]["type"] = "type";
j["print"]["diameter"] = diameter;
return this->publish_json(j.dump());
}
int MachineObject::command_set_work_light(LIGHT_EFFECT effect, int on_time, int off_time, int loops, int interval)
{
@ -3745,8 +3758,8 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
nozzle_diameter = string_to_float(jj["nozzle_diameter"].get<std::string>());
}
if (nozzle_diameter == 0.0f) {m_extder_data.extders[0].diameter = 0.4f;}
else {m_extder_data.extders[0].diameter = round(nozzle_diameter * 10) / 10;}
if (nozzle_diameter == 0.0f) {m_extder_data.extders[0].current_nozzle_diameter = 0.4f;}
else {m_extder_data.extders[0].current_nozzle_diameter = round(nozzle_diameter * 10) / 10;}
}
}
}
@ -3763,7 +3776,7 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
else {
if (jj["nozzle_type"].is_string()) {
auto nozzle_type = jj["nozzle_type"].get<std::string>();
m_extder_data.extders[0].type = nozzle_type;
m_extder_data.extders[0].current_nozzle_type = NozzleTypeStrToEumn[nozzle_type];
}
}
}
@ -5604,55 +5617,135 @@ void MachineObject::parse_new_info(json print)
heatbreak_fan_speed = get_flag_bits(device["fan"].get<int>(), 12, 3);
}
if (device.contains("extruder")) {
json const& nozzle = device["extruder"];
if (device.contains("nozzle")) {
json const &nozzle = device["nozzle"];
m_extder_data = ExtderData();
m_extder_data.total_extder_count = get_flag_bits(nozzle["state"].get<int>(), 0, 3);
m_extder_data.current_extder_id = get_flag_bits(nozzle["state"].get<int>(), 4, 3);
m_extder_data.target_extder_id = get_flag_bits(nozzle["state"].get<int>(), 8, 3);
m_nozzle_data = NozzleData();
m_nozzle_data.extder_exist = get_flag_bits(nozzle["exist"].get<int>(), 0, 15);
m_nozzle_data.cut_exist = get_flag_bits(nozzle["exist"].get<int>(), 16, 31);
m_nozzle_data.state = get_flag_bits(nozzle["state"].get<int>(), 0, 3);
for (int i = 0; i < m_extder_data.total_extder_count; i++) {
for (auto it = nozzle["info"].begin(); it != nozzle["info"].end(); it++) {
Nozzle nozzle_obj;
auto njon = it.value();
std::string type = njon["type"].get<std::string>();
nozzle_obj.id = njon["id"].get<int>();
Extder extder_obj;
if (type.length() >= 4) {
if (type.substr(0, 1) == std::string("H")) {
nozzle_obj.tool_type = NozzleToolType::H_TOOL;
}
else if (type.substr(0, 1) == std::string("C")) {
nozzle_obj.tool_type = NozzleToolType::C_TOOL;
}
std::string nozzle_id = std::to_string(i);
if (nozzle.contains(nozzle_id)) {
auto njon = nozzle[nozzle_id].get<json>();
if (type.substr(1, 1) == std::string("S")) {
nozzle_obj.nozzle_flow = NozzleFlowType::S_FLOW;
} else if (type.substr(1, 1) == std::string("H")) {
nozzle_obj.nozzle_flow = NozzleFlowType::H_FLOW;
}
extder_obj.type = DeviceManager::nozzle_type_conver(get_flag_bits(njon["info"].get<int>(), 0, 2));
extder_obj.diameter = DeviceManager::nozzle_diameter_conver(get_flag_bits(njon["info"].get<int>(), 3, 3));
extder_obj.ext_has_filament = get_flag_bits(njon["info"].get<int>(), 7);
extder_obj.buffer_has_filament = get_flag_bits(njon["info"].get<int>(), 8);
extder_obj.flow_type = get_flag_bits(njon["info"].get<int>(), 9, 2);
extder_obj.temp = get_flag_bits(njon["temp"].get<int>(), 0, 15);
extder_obj.target_temp = get_flag_bits(njon["temp"].get<int>(), 16, 15);
AmsSlot spre;
spre.ams_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 0, 8));
spre.slot_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 8, 8));
AmsSlot snow;
snow.ams_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 0, 8));
snow.slot_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 8, 8));
AmsSlot star;
star.ams_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 0, 8));
star.slot_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 8, 8));
extder_obj.spre = spre;
extder_obj.snow = snow;
extder_obj.star = star;
extder_obj.ams_stat = get_flag_bits(njon["stat"].get<int>(), 0, 15);
extder_obj.rfid_stat = get_flag_bits(njon["stat"].get<int>(), 16, 15);
if (type.substr(2, 2) == std::string("00")) {
nozzle_obj.nozzle_type = NozzleType::ntStainlessSteel;
} else if (type.substr(2, 2) == std::string("01")) {
nozzle_obj.nozzle_type = NozzleType::ntHardenedSteel;
}
}
nozzle_obj.diameter = njon["diameter"].get<float>();
nozzle_obj.max_temp = njon["tm"].get<int>();
nozzle_obj.wear = njon["wear"].get<int>();
if (nozzle_obj.diameter == 0.0f) {nozzle_obj.diameter = 0.4f;}
m_nozzle_data.nozzles.push_back(nozzle_obj);
}
}
if (device.contains("extruder")) {
json const& extruder = device["extruder"];
m_extder_data = ExtderData();
m_extder_data.total_extder_count = get_flag_bits(extruder["state"].get<int>(), 0, 3);
m_extder_data.current_extder_id = get_flag_bits(extruder["state"].get<int>(), 4, 3);
m_extder_data.target_extder_id = get_flag_bits(extruder["state"].get<int>(), 8, 3);
for (auto it = extruder["info"].begin(); it != extruder["info"].end(); it++) {
Extder extder_obj;
auto njon = it.value();
extder_obj.id = njon["id"].get<int>();
extder_obj.enable_change_nozzle= get_flag_bits(njon["info"].get<int>(), 0);
extder_obj.ext_has_filament = get_flag_bits(njon["info"].get<int>(), 1);
extder_obj.buffer_has_filament = get_flag_bits(njon["info"].get<int>(), 2);
extder_obj.nozzle_exist = get_flag_bits(njon["info"].get<int>(), 3);
extder_obj.temp = get_flag_bits(njon["temp"].get<int>(), 0, 15);
extder_obj.target_temp = get_flag_bits(njon["temp"].get<int>(), 16, 15);
AmsSlot spre;
spre.ams_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 0, 8));
spre.slot_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 8, 8));
AmsSlot snow;
snow.ams_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 0, 8));
snow.slot_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 8, 8));
AmsSlot star;
star.ams_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 0, 8));
star.slot_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 8, 8));
extder_obj.nozzle_id = njon["hnow"].get<int>();
extder_obj.target_nozzle_id = njon["htar"].get<int>();
extder_obj.spre = spre;
extder_obj.snow = snow;
extder_obj.star = star;
extder_obj.ams_stat = get_flag_bits(njon["stat"].get<int>(), 0, 15);
extder_obj.rfid_stat = get_flag_bits(njon["stat"].get<int>(), 16, 15);
//current nozzle info
if (extder_obj.nozzle_id == 0xff) {
extder_obj.current_nozzle_type = NozzleType::ntUndefine;
extder_obj.current_nozzle_diameter = 0.4f;
extder_obj.current_nozzle_flow_type = NozzleFlowType::NONE_FLOWTYPE;
} else {
for (auto i = 0; i < m_nozzle_data.nozzles.size(); i++) {
if (m_nozzle_data.nozzles[i].id == extder_obj.nozzle_id) {
extder_obj.current_nozzle_type = m_nozzle_data.nozzles[i].nozzle_type;
extder_obj.current_nozzle_diameter = m_nozzle_data.nozzles[i].diameter;
extder_obj.current_nozzle_flow_type = m_nozzle_data.nozzles[i].nozzle_flow;
}
}
}
m_extder_data.extders.push_back(extder_obj);
}
if (m_extder_data.extders.size() <= 0) {
// def data
m_extder_data.current_extder_id = 0;
m_extder_data.target_extder_id = 0;
m_extder_data.total_extder_count = 1;
Extder nozzle;
m_extder_data.extders.push_back(nozzle);
}
}
}
}
bool MachineObject::is_nozzle_data_invalid()
{
if (m_extder_data.extders.size() < m_extder_data.current_extder_id) { return false; }
if (m_extder_data.extders.size() != m_extder_data.total_extder_count) { return false; }
if (m_extder_data.extders[m_extder_data.current_extder_id].current_nozzle_type == NozzleType::ntUndefine ||
m_extder_data.extders[m_extder_data.current_extder_id].current_nozzle_diameter <= 0.0f ||
m_extder_data.extders[m_extder_data.current_extder_id].current_nozzle_flow_type == NozzleFlowType::NONE_FLOWTYPE) {
return false;
}
return true;
}
int MachineObject::get_flag_bits(std::string str, int start, int count)
{
try {
@ -5758,7 +5851,7 @@ void MachineObject::update_printer_preset_name()
auto printer_model = MachineObject::get_preset_printer_model_name(this->printer_type);
std::set<std::string> diameter_set;
for (auto &nozzle : m_extder_data.extders) {
float diameter = nozzle.diameter;
float diameter = nozzle.current_nozzle_diameter;
std::ostringstream stream;
stream << std::fixed << std::setprecision(1) << diameter;
std::string nozzle_diameter_str = stream.str();
@ -5793,7 +5886,7 @@ void MachineObject::check_ams_filament_valid()
if (ams->nozzle < 0 || ams->nozzle >= m_extder_data.extders.size()) {
return;
}
stream << std::fixed << std::setprecision(1) << m_extder_data.extders[ams->nozzle].diameter;
stream << std::fixed << std::setprecision(1) << m_extder_data.extders[ams->nozzle].current_nozzle_diameter;
std::string nozzle_diameter_str = stream.str();
assert(nozzle_diameter_str.size() == 3);
if (m_nozzle_filament_data.find(nozzle_diameter_str) == m_nozzle_filament_data.end()) {
@ -5852,13 +5945,13 @@ void MachineObject::check_ams_filament_valid()
BOOST_LOG_TRIVIAL(error) << " vt_tray id map for nozzle id is not exist, index is: " << index << " nozzle count" << m_extder_data.total_extder_count;
continue;
}
auto diameter = m_extder_data.extders[index].diameter;
auto diameter = m_extder_data.extders[index].current_nozzle_diameter;
std::ostringstream stream;
stream << std::fixed << std::setprecision(1) << diameter;
std::string nozzle_diameter_str = stream.str();
assert(nozzle_diameter_str.size() == 3);
if (m_nozzle_filament_data.find(nozzle_diameter_str) == m_nozzle_filament_data.end()) {
//assert(false);
assert(false);
continue;
}
auto &data = m_nozzle_filament_data[nozzle_diameter_str];
@ -5886,7 +5979,7 @@ void MachineObject::check_ams_filament_valid()
std::string preset_setting_id;
PresetBundle * preset_bundle = Slic3r::GUI::wxGetApp().preset_bundle;
std::ostringstream stream;
stream << std::fixed << std::setprecision(1) << m_extder_data.extders[0].diameter;
stream << std::fixed << std::setprecision(1) << m_extder_data.extders[0].current_nozzle_diameter;
std::string nozzle_diameter_str = stream.str();
bool is_equation = preset_bundle->check_filament_temp_equation_by_printer_type_and_nozzle_for_mas_tray(MachineObject::get_preset_printer_model_name(
this->printer_type),

66
src/slic3r/GUI/DeviceManager.hpp
View File

@ -141,6 +141,17 @@ enum AirDuctType {
AIR_DOOR_TYPE
};
enum NozzleFlowType{
NONE_FLOWTYPE,
S_FLOW,
H_FLOW
};
enum NozzleToolType {
NONE_TOOLTYPE,
H_TOOL,
C_TOOL
};
struct AmsSlot
{
@ -148,22 +159,51 @@ struct AmsSlot
std::string slot_id;
};
struct Nozzle
{
int id;
NozzleToolType tool_type; // H nozzle or Cut
NozzleFlowType nozzle_flow; // 0-common 1-high flow
NozzleType nozzle_type; // 0-stainless_steel 1-hardened_steel
float diameter = {0.4f}; // 0-0.2mm 1-0.4mm 2-0.6 mm3-0.8mm
int max_temp = 0;
int wear = 0;
};
struct NozzleData
{
int extder_exist; //0- none exist 1-exist
int cut_exist;
int state; //0-idle 1-checking
std::vector<Nozzle> nozzles;
};
struct Extder
{
std::string type; //0-hardened_steel 1-stainless_steel
float diameter = {0.4f}; // 0-0.2mm 1-0.4mm 2-0.6 mm3-0.8mm
int exist{0}; //0-Not Installed 1-Wrong extruder 2-No enablement 3-Enable
int id; // 0-right 1-left
int enable_change_nozzle{0};
int ext_has_filament{0};
int buffer_has_filament{0};
int flow_type{0};//0-common 1-high flow
int nozzle_exist{0};
int temp{0};
int temp{0};
int target_temp{0};
AmsSlot spre; //tray_pre
AmsSlot snow; //tray_now
AmsSlot star; //tray_tar
int ams_stat{0}; ;
int rfid_stat{0}; ;
AmsSlot spre; // tray_pre
AmsSlot snow; // tray_now
AmsSlot star; // tray_tar
int ams_stat{0};
int rfid_stat{0};
int nozzle_id; // nozzle id now
int target_nozzle_id; // target nozzle id
//current nozzle
NozzleType current_nozzle_type{NozzleType::ntUndefine}; // 0-hardened_steel 1-stainless_steel
float current_nozzle_diameter = {0.4f}; // 0-0.2mm 1-0.4mm 2-0.6 mm3-0.8mm
NozzleFlowType current_nozzle_flow_type{NozzleFlowType::NONE_FLOWTYPE};//0-common 1-high flow
};
struct ExtderData
@ -959,6 +999,7 @@ public:
int command_pushing(std::string cmd);
int command_clean_print_error(std::string task_id, int print_error);
int command_set_printer_nozzle(std::string nozzle_type, float diameter);
int command_set_printer_nozzle2(int id, std::string nozzle_type, float diameter, int flow);
int command_get_access_code();
@ -1098,7 +1139,9 @@ public:
/*for more extruder*/
bool is_enable_np{ false };
ExtderData m_extder_data;
NozzleData m_nozzle_data;
/*vi slot data*/
std::vector<AmsTray> vt_slot;
@ -1106,7 +1149,8 @@ public:
/*for parse new info*/
void parse_new_info(json print);
int get_flag_bits(std::string str, int start, int count = 1);
bool is_nozzle_data_invalid();
int get_flag_bits(std::string str, int start, int count = 1);
int get_flag_bits(int num, int start, int count = 1, int base = 10);
/* Device Filament Check */

6
src/slic3r/GUI/Plater.cpp
View File

@ -729,8 +729,8 @@ void Sidebar::priv::sync_extruder_list()
}
auto printer_tab = dynamic_cast<TabPrinter *>(wxGetApp().get_tab(Preset::TYPE_PRINTER));
printer_tab->set_extruder_volume_type(0, NozzleVolumeType(obj->m_extder_data.extders[1].flow_type));
printer_tab->set_extruder_volume_type(1, NozzleVolumeType(obj->m_extder_data.extders[0].flow_type));
printer_tab->set_extruder_volume_type(0, NozzleVolumeType(obj->m_extder_data.extders[1].current_nozzle_flow_type));
printer_tab->set_extruder_volume_type(1, NozzleVolumeType(obj->m_extder_data.extders[0].current_nozzle_flow_type));
int left_4 = 0, right_4 = 0, left_1 = 0, right_1 = 0;
for (auto ams : obj->amsList) {
// Main (first) extruder at right
@ -4699,7 +4699,7 @@ std::vector<size_t> Plater::priv::load_files(const std::vector<fs::path>& input_
const ConfigOption *opt = printer_preset.config.option("nozzle_diameter");
if (opt)
preset_nozzle_diameter = static_cast<const ConfigOptionFloatsNullable *>(opt)->values[0];
float machine_nozzle_diameter = obj->m_extder_data.extders[0].diameter;
float machine_nozzle_diameter = obj->m_extder_data.extders[0].current_nozzle_diameter;
std::string machine_type = obj->printer_type;
if (obj->is_support_upgrade_kit && obj->installed_upgrade_kit)

300
src/slic3r/GUI/PrintOptionsDialog.cpp
View File

@ -480,6 +480,15 @@ PrinterPartsDialog::PrinterPartsDialog(wxWindow* parent)
nozzle_type->SetForegroundColour(STATIC_TEXT_CAPTION_COL);
nozzle_type->Wrap(-1);
ID_NOZZLE_TYPE_CHECKBOX_SINGLE = wxNewId();
ID_NOZZLE_TYPE_CHECKBOX_LEFT = wxNewId();
ID_NOZZLE_TYPE_CHECKBOX_RIGHT = wxNewId();
ID_NOZZLE_DIAMETER_CHECKBOX_SINGLE = wxNewId();
ID_NOZZLE_DIAMETER_CHECKBOX_LEFT = wxNewId();
ID_NOZZLE_DIAMETER_CHECKBOX_RIGHT = wxNewId();
ID_NOZZLE_FLOW_CHECKBOX_LEFT = wxNewId();
ID_NOZZLE_FLOW_CHECKBOX_RIGHT = wxNewId();
nozzle_type_checkbox = new ComboBox(single_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(FromDIP(140), -1), 0, NULL, wxCB_READONLY);
nozzle_type_checkbox->Append(_L("Stainless Steel"));
nozzle_type_checkbox->Append(_L("Hardened Steel"));
@ -513,10 +522,6 @@ PrinterPartsDialog::PrinterPartsDialog(wxWindow* parent)
single_sizer->Add(line_sizer_nozzle_diameter, 0, wxALIGN_CENTER | wxLEFT | wxRIGHT, FromDIP(18));
single_sizer->Add(0, 0, 0, wxTOP, FromDIP(24));
nozzle_type_checkbox->Connect( wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_type), NULL, this );
nozzle_diameter_checkbox->Connect( wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_diameter), NULL, this );
single_panel->SetSizer(single_sizer);
single_panel->Layout();
single_panel->Fit();
@ -577,7 +582,7 @@ PrinterPartsDialog::PrinterPartsDialog(wxWindow* parent)
multiple_right_nozzle_type->SetMaxSize(wxSize(FromDIP(80), -1));
multiple_right_nozzle_type->SetForegroundColour(STATIC_TEXT_CAPTION_COL);
multiple_right_nozzle_type_checkbox = new ComboBox(multiple_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(FromDIP(140), -1), 0, NULL, wxCB_READONLY);
multiple_right_nozzle_type_checkbox = new ComboBox(multiple_panel, ID_NOZZLE_TYPE_CHECKBOX_RIGHT, wxEmptyString, wxDefaultPosition, wxSize(FromDIP(140), -1), 0, NULL, wxCB_READONLY);
multiple_right_nozzle_type_checkbox->Append(_L("Stainless Steel"));
multiple_right_nozzle_type_checkbox->Append(_L("Hardened Steel"));
multiple_right_nozzle_type_checkbox->SetSelection(0);
@ -629,57 +634,100 @@ PrinterPartsDialog::PrinterPartsDialog(wxWindow* parent)
single_panel->Hide();
wxGetApp().UpdateDlgDarkUI(this);
nozzle_type_checkbox->Connect(wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_data), NULL, this);
nozzle_diameter_checkbox->Connect(wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_data), NULL, this);
multiple_left_nozzle_type_checkbox->Connect(wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_data), NULL, this);
multiple_left_nozzle_diameter_checkbox->Connect(wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_data), NULL, this);
multiple_left_nozzle_flow_checkbox->Connect(wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_data), NULL, this);
multiple_right_nozzle_type_checkbox->Connect(wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_data), NULL, this);
multiple_right_nozzle_diameter_checkbox->Connect(wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_data), NULL, this);
multiple_right_nozzle_flow_checkbox->Connect(wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_data), NULL, this);
nozzle_type_checkbox->SetId(ID_NOZZLE_TYPE_CHECKBOX_SINGLE);
multiple_left_nozzle_type_checkbox->SetId(ID_NOZZLE_TYPE_CHECKBOX_LEFT);
multiple_right_nozzle_type_checkbox->SetId(ID_NOZZLE_TYPE_CHECKBOX_RIGHT);
nozzle_diameter_checkbox->SetId(ID_NOZZLE_DIAMETER_CHECKBOX_SINGLE);
multiple_left_nozzle_diameter_checkbox->SetId(ID_NOZZLE_DIAMETER_CHECKBOX_LEFT);
multiple_right_nozzle_diameter_checkbox->SetId(ID_NOZZLE_DIAMETER_CHECKBOX_RIGHT);
multiple_left_nozzle_flow_checkbox->SetId(ID_NOZZLE_FLOW_CHECKBOX_LEFT);
multiple_right_nozzle_flow_checkbox->SetId(ID_NOZZLE_FLOW_CHECKBOX_RIGHT);
}
PrinterPartsDialog::~PrinterPartsDialog()
{
nozzle_type_checkbox->Disconnect(wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_type), NULL, this);
nozzle_diameter_checkbox->Disconnect(wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_diameter), NULL, this);
nozzle_type_checkbox->Disconnect(wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_data), NULL, this);
nozzle_diameter_checkbox->Disconnect(wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_data), NULL, this);
}
void PrinterPartsDialog::set_nozzle_type(wxCommandEvent& evt)
void PrinterPartsDialog::set_nozzle_data(wxCommandEvent& evt)
{
auto type = nozzle_type_map[nozzle_type_checkbox->GetSelection()];
ComboBox* current_nozzle_type_combox = nullptr;
ComboBox* current_nozzle_diameter_combox = nullptr;
ComboBox* current_nozzle_flow_combox = nullptr;
if (type == last_nozzle_type) {
return;
int nozzle_id = 0;
if (evt.GetId() == ID_NOZZLE_TYPE_CHECKBOX_SINGLE) {
current_nozzle_type_combox = nozzle_type_checkbox;
current_nozzle_diameter_combox = nozzle_diameter_checkbox;
nozzle_id = 0;
} else if (evt.GetId() == ID_NOZZLE_TYPE_CHECKBOX_LEFT) {
current_nozzle_type_combox = multiple_left_nozzle_type_checkbox;
current_nozzle_diameter_combox = multiple_left_nozzle_type_checkbox;
current_nozzle_flow_combox = multiple_left_nozzle_flow_checkbox;
nozzle_id = 1;
} else if (evt.GetId() == ID_NOZZLE_TYPE_CHECKBOX_RIGHT) {
current_nozzle_type_combox = multiple_right_nozzle_type_checkbox;
current_nozzle_diameter_combox = multiple_right_nozzle_type_checkbox;
current_nozzle_flow_combox = multiple_right_nozzle_flow_checkbox;
nozzle_id = 0;
}
std::map<int, float> diameter_list;
if (type == "hardened_steel") {
diameter_list = nozzle_hard_diameter_map;
}
else if (type == "stainless_steel") {
diameter_list = nozzle_stainless_diameter_map;
}
nozzle_diameter_checkbox->Clear();
for (int i = 0; i < diameter_list.size(); i++)
{
nozzle_diameter_checkbox->Append(wxString::Format(_L("%.1f"), diameter_list[i]));
}
nozzle_diameter_checkbox->SetSelection(0);
//auto type = nozzle_type_map[current_nozzle_type->GetSelection()];
last_nozzle_type = type;
set_nozzle_diameter(evt);
}
//std::map<int, float> diameter_list;
//if (type == "hardened_steel") {
// diameter_list = nozzle_hard_diameter_map;
//}
//else if (type == "stainless_steel") {
// diameter_list = nozzle_stainless_diameter_map;
//}
void PrinterPartsDialog::set_nozzle_diameter(wxCommandEvent& evt)
{
if (obj) {
try
{
auto nozzle_type = nozzle_type_map[nozzle_type_checkbox->GetSelection()];
auto nozzle_diameter = std::stof(nozzle_diameter_checkbox->GetStringSelection().ToStdString());
nozzle_diameter = round(nozzle_diameter * 10) / 10;
obj->m_extder_data.extders[0].diameter = nozzle_diameter;
obj->m_extder_data.extders[0].type = nozzle_type;
//nozzle_diameter_checkbox->Clear();
//for (int i = 0; i < diameter_list.size(); i++)
//{
// nozzle_diameter_checkbox->Append(wxString::Format(_L("%.1f"), diameter_list[i]));
//}
//nozzle_diameter_checkbox->SetSelection(0);
obj->command_set_printer_nozzle(nozzle_type, nozzle_diameter);
}
catch (...) {}
if (obj && current_nozzle_type_combox && current_nozzle_diameter_combox) {
try {
auto nozzle_type = nozzle_type_map[current_nozzle_type_combox->GetSelection()];
auto nozzle_diameter = std::stof(current_nozzle_diameter_combox->GetStringSelection().ToStdString());
nozzle_diameter = round(nozzle_diameter * 10) / 10;
if (evt.GetId() == ID_NOZZLE_TYPE_CHECKBOX_SINGLE) {
obj->m_extder_data.extders[0].current_nozzle_diameter = nozzle_diameter;
obj->m_extder_data.extders[0].current_nozzle_type = NozzleTypeStrToEumn[nozzle_type];
} else if(evt.GetId() == ID_NOZZLE_TYPE_CHECKBOX_LEFT) {
obj->m_extder_data.extders[0].current_nozzle_diameter = nozzle_diameter;
obj->m_extder_data.extders[0].current_nozzle_type = NozzleTypeStrToEumn[nozzle_type];
} else if(evt.GetId() == ID_NOZZLE_TYPE_CHECKBOX_RIGHT){
obj->m_extder_data.extders[1].current_nozzle_diameter = nozzle_diameter;
obj->m_extder_data.extders[1].current_nozzle_type = NozzleTypeStrToEumn[nozzle_type];
}
if (!obj->is_enable_np) {
obj->command_set_printer_nozzle(nozzle_type, nozzle_diameter);
} else {
//obj->command_set_printer_nozzle2(nozzle_id, nozzle_type, nozzle_diameter);
}
} catch (...) {}
}
}
@ -703,13 +751,13 @@ bool PrinterPartsDialog::Show(bool show)
single_panel->Show();
multiple_panel->Hide();
auto type = obj->m_extder_data.extders[0].type;
auto diameter = obj->m_extder_data.extders[0].diameter;
auto type = obj->m_extder_data.extders[0].current_nozzle_type;
auto diameter = obj->m_extder_data.extders[0].current_nozzle_diameter;
nozzle_type_checkbox->Clear();
nozzle_diameter_checkbox->Clear();
if (type.empty()) {
/*if (type.empty()) {
nozzle_type_checkbox->SetValue(wxEmptyString);
nozzle_diameter_checkbox->SetValue(wxEmptyString);
@ -738,108 +786,108 @@ bool PrinterPartsDialog::Show(bool show)
for (int i = 0; i < diameter_list.size(); i++) {
nozzle_diameter_checkbox->Append(wxString::Format(_L("%.1f"), diameter_list[i]));
if (diameter_list[i] == diameter) { nozzle_diameter_checkbox->SetSelection(i); }
}
}*/
} else {
single_panel->Hide();
multiple_panel->Show();
//single_panel->Hide();
//multiple_panel->Show();
//left
auto type = obj->m_extder_data.extders[0].type;
auto diameter = obj->m_extder_data.extders[0].diameter;
auto flow_type = obj->m_extder_data.extders[0].flow_type;
////left
//auto type = obj->m_extder_data.extders[0].current_nozzle_type;
//auto diameter = obj->m_extder_data.extders[0].current_nozzle_diameter;
//auto flow_type = obj->m_extder_data.extders[0].current_nozzle_flow_type;
multiple_left_nozzle_type_checkbox->Clear();
multiple_left_nozzle_diameter_checkbox->Clear();
multiple_left_nozzle_flow_checkbox->Clear();
//multiple_left_nozzle_type_checkbox->Clear();
//multiple_left_nozzle_diameter_checkbox->Clear();
//multiple_left_nozzle_flow_checkbox->Clear();
if (type.empty()) {
multiple_left_nozzle_type_checkbox->SetValue(wxEmptyString);
multiple_left_nozzle_diameter_checkbox->SetValue(wxEmptyString);
multiple_left_nozzle_flow_checkbox->SetValue(wxEmptyString);
//if (type.empty()) {
// multiple_left_nozzle_type_checkbox->SetValue(wxEmptyString);
// multiple_left_nozzle_diameter_checkbox->SetValue(wxEmptyString);
// multiple_left_nozzle_flow_checkbox->SetValue(wxEmptyString);
multiple_left_nozzle_type_checkbox->Disable();
multiple_left_nozzle_diameter_checkbox->Disable();
multiple_left_nozzle_flow_checkbox->Disable();
return DPIDialog::Show(show);
} else {
multiple_left_nozzle_type_checkbox->Enable();
multiple_left_nozzle_diameter_checkbox->Enable();
multiple_left_nozzle_flow_checkbox->Enable();
}
// multiple_left_nozzle_type_checkbox->Disable();
// multiple_left_nozzle_diameter_checkbox->Disable();
// multiple_left_nozzle_flow_checkbox->Disable();
// return DPIDialog::Show(show);
//} else {
// multiple_left_nozzle_type_checkbox->Enable();
// multiple_left_nozzle_diameter_checkbox->Enable();
// multiple_left_nozzle_flow_checkbox->Enable();
//}
//last_nozzle_type = type;
////last_nozzle_type = type;
for (int i = 0; i < nozzle_type_map.size(); i++) {
multiple_left_nozzle_type_checkbox->Append(nozzle_type_map[i]);
if (nozzle_type_map[i] == type) { multiple_left_nozzle_type_checkbox->SetSelection(i); }
}
//for (int i = 0; i < nozzle_type_map.size(); i++) {
// multiple_left_nozzle_type_checkbox->Append(nozzle_type_map[i]);
// if (nozzle_type_map[i] == type) { multiple_left_nozzle_type_checkbox->SetSelection(i); }
//}
std::map<int, float> diameter_list;
if (type == "hardened_steel") {
diameter_list = nozzle_hard_diameter_map;
} else if (type == "stainless_steel") {
diameter_list = nozzle_stainless_diameter_map;
}
//std::map<int, float> diameter_list;
//if (type == "hardened_steel") {
// diameter_list = nozzle_hard_diameter_map;
//} else if (type == "stainless_steel") {
// diameter_list = nozzle_stainless_diameter_map;
//}
for (int i = 0; i < diameter_list.size(); i++) {
multiple_left_nozzle_diameter_checkbox->Append(wxString::Format(_L("%.1f"), diameter_list[i]));
if (diameter_list[i] == diameter) { multiple_left_nozzle_diameter_checkbox->SetSelection(i); }
}
//for (int i = 0; i < diameter_list.size(); i++) {
// multiple_left_nozzle_diameter_checkbox->Append(wxString::Format(_L("%.1f"), diameter_list[i]));
// if (diameter_list[i] == diameter) { multiple_left_nozzle_diameter_checkbox->SetSelection(i); }
//}
for (int i = 0; i < nozzle_flow_map.size(); i++) {
multiple_left_nozzle_flow_checkbox->Append(nozzle_flow_map[i]);
if (i == flow_type) { multiple_left_nozzle_flow_checkbox->SetSelection(i); }
}
//for (int i = 0; i < nozzle_flow_map.size(); i++) {
// multiple_left_nozzle_flow_checkbox->Append(nozzle_flow_map[i]);
// if (i == flow_type) { multiple_left_nozzle_flow_checkbox->SetSelection(i); }
//}
//right
type = obj->m_extder_data.extders[1].type;
diameter = obj->m_extder_data.extders[1].diameter;
flow_type = obj->m_extder_data.extders[1].flow_type;
////right
//type = obj->m_extder_data.extders[1].current_nozzle_type;
//diameter = obj->m_extder_data.extders[1].current_nozzle_diameter;
//flow_type = obj->m_extder_data.extders[1].current_nozzle_flow_type;
multiple_right_nozzle_type_checkbox->Clear();
multiple_right_nozzle_diameter_checkbox->Clear();
multiple_right_nozzle_flow_checkbox->Clear();
//multiple_right_nozzle_type_checkbox->Clear();
//multiple_right_nozzle_diameter_checkbox->Clear();
//multiple_right_nozzle_flow_checkbox->Clear();
if (type.empty()) {
multiple_right_nozzle_type_checkbox->SetValue(wxEmptyString);
multiple_right_nozzle_diameter_checkbox->SetValue(wxEmptyString);
multiple_right_nozzle_flow_checkbox->SetValue(wxEmptyString);
//if (type.empty()) {
// multiple_right_nozzle_type_checkbox->SetValue(wxEmptyString);
// multiple_right_nozzle_diameter_checkbox->SetValue(wxEmptyString);
// multiple_right_nozzle_flow_checkbox->SetValue(wxEmptyString);
multiple_right_nozzle_type_checkbox->Disable();
multiple_right_nozzle_diameter_checkbox->Disable();
multiple_right_nozzle_flow_checkbox->Disable();
return DPIDialog::Show(show);
} else {
multiple_right_nozzle_type_checkbox->Enable();
multiple_right_nozzle_diameter_checkbox->Enable();
multiple_right_nozzle_flow_checkbox->Enable();
}
// multiple_right_nozzle_type_checkbox->Disable();
// multiple_right_nozzle_diameter_checkbox->Disable();
// multiple_right_nozzle_flow_checkbox->Disable();
// return DPIDialog::Show(show);
//} else {
// multiple_right_nozzle_type_checkbox->Enable();
// multiple_right_nozzle_diameter_checkbox->Enable();
// multiple_right_nozzle_flow_checkbox->Enable();
//}
// last_nozzle_type = type;
//// last_nozzle_type = type;
for (int i = 0; i < nozzle_type_map.size(); i++) {
multiple_right_nozzle_type_checkbox->Append(nozzle_type_map[i]);
if (nozzle_type_map[i] == type) { multiple_right_nozzle_type_checkbox->SetSelection(i); }
}
//for (int i = 0; i < nozzle_type_map.size(); i++) {
// multiple_right_nozzle_type_checkbox->Append(nozzle_type_map[i]);
// if (nozzle_type_map[i] == type) { multiple_right_nozzle_type_checkbox->SetSelection(i); }
//}
diameter_list;
if (type == "hardened_steel") {
diameter_list = nozzle_hard_diameter_map;
} else if (type == "stainless_steel") {
diameter_list = nozzle_stainless_diameter_map;
}
//diameter_list;
//if (type == "hardened_steel") {
// diameter_list = nozzle_hard_diameter_map;
//} else if (type == "stainless_steel") {
// diameter_list = nozzle_stainless_diameter_map;
//}
for (int i = 0; i < diameter_list.size(); i++) {
multiple_right_nozzle_diameter_checkbox->Append(wxString::Format(_L("%.1f"), diameter_list[i]));
if (diameter_list[i] == diameter) { multiple_right_nozzle_diameter_checkbox->SetSelection(i); }
}
//for (int i = 0; i < diameter_list.size(); i++) {
// multiple_right_nozzle_diameter_checkbox->Append(wxString::Format(_L("%.1f"), diameter_list[i]));
// if (diameter_list[i] == diameter) { multiple_right_nozzle_diameter_checkbox->SetSelection(i); }
//}
for (int i = 0; i < nozzle_flow_map.size(); i++) {
multiple_right_nozzle_flow_checkbox->Append(nozzle_flow_map[i]);
if (i == flow_type) { multiple_right_nozzle_flow_checkbox->SetSelection(i); }
}
//for (int i = 0; i < nozzle_flow_map.size(); i++) {
// multiple_right_nozzle_flow_checkbox->Append(nozzle_flow_map[i]);
// if (i == flow_type) { multiple_right_nozzle_flow_checkbox->SetSelection(i); }
//}
}
Layout();
Fit();

14
src/slic3r/GUI/PrintOptionsDialog.hpp
View File

@ -21,6 +21,17 @@ namespace Slic3r { namespace GUI {
class PrinterPartsDialog : public DPIDialog
{
protected:
wxWindowID ID_NOZZLE_TYPE_CHECKBOX_SINGLE;
wxWindowID ID_NOZZLE_TYPE_CHECKBOX_LEFT;
wxWindowID ID_NOZZLE_TYPE_CHECKBOX_RIGHT;
wxWindowID ID_NOZZLE_DIAMETER_CHECKBOX_SINGLE;
wxWindowID ID_NOZZLE_DIAMETER_CHECKBOX_LEFT;
wxWindowID ID_NOZZLE_DIAMETER_CHECKBOX_RIGHT;
wxWindowID ID_NOZZLE_FLOW_CHECKBOX_LEFT;
wxWindowID ID_NOZZLE_FLOW_CHECKBOX_RIGHT;
MachineObject* obj{ nullptr };
ComboBox* nozzle_type_checkbox;
@ -46,8 +57,7 @@ protected:
public:
PrinterPartsDialog(wxWindow* parent);
~PrinterPartsDialog();
void set_nozzle_type(wxCommandEvent& evt);
void set_nozzle_diameter(wxCommandEvent& evt);
void set_nozzle_data(wxCommandEvent& evt);
void on_dpi_changed(const wxRect& suggested_rect) override;
void update_machine_obj(MachineObject* obj_);
bool Show(bool show) override;

112
src/slic3r/GUI/SelectMachine.cpp
View File

@ -2165,7 +2165,7 @@ bool SelectMachineDialog::can_hybrid_mapping(ExtderData data) {
for (auto it = data.extders.rbegin(); it != data.extders.rend(); it++){
//exist field is not updated, wait add
//if (it->exist < 3) return false;
std::string type_str = it->flow_type ? "Big Traffic" : "Normal";
std::string type_str = it->current_nozzle_flow_type ? "Big Traffic" : "Normal";
flow_type_of_machine.push_back(type_str);
}
//get the nozzle type of preset --> flow_types
@ -2211,24 +2211,49 @@ bool SelectMachineDialog::is_nozzle_type_match(ExtderData data) {
if (data.total_extder_count <= 1 || data.extders.size() <= 1 || !wxGetApp().preset_bundle)
return false;
//The default two extruders are left, right, but the order of the extruders on the machine is right, left.
std::vector<std::string>flow_type_of_machine;
for (auto it = data.extders.rbegin(); it != data.extders.rend(); it++) {
std::string str_flow = it->flow_type ? "Big Traffic" : "Normal";
flow_type_of_machine.push_back(str_flow);
//check nozzle used
auto used_filaments = wxGetApp().plater()->get_partplate_list().get_curr_plate()->get_used_extruders(); // 1 based
auto filament_maps = wxGetApp().plater()->get_partplate_list().get_curr_plate()->get_filament_maps(); // 1 based
std::map<int, std::string> used_extruders_flow;
std::vector<int> used_extruders; // 0 based
for (auto f : used_filaments) {
int filament_extruder = filament_maps[f - 1] - 1;
if (std::find(used_extruders.begin(), used_extruders.end(), filament_extruder) == used_extruders.end()) used_extruders.emplace_back(filament_extruder);
}
//get the nozzle type of preset --> flow_types
const Preset& current_printer = wxGetApp().preset_bundle->printers.get_selected_preset();
const Preset* base_printer = wxGetApp().preset_bundle->printers.get_preset_base(current_printer);
auto flow_data = wxGetApp().app_config->get_nozzle_volume_types_from_config(base_printer->name);
std::vector<string> flow_types;
boost::split(flow_types, flow_data, boost::is_any_of(","));
if (flow_types.size() <= 1 || flow_types.size() != flow_type_of_machine.size()) return false;
std::sort(used_extruders.begin(), used_extruders.end());
auto nozzle_volume_type_opt = dynamic_cast<const ConfigOptionEnumsGeneric *>(wxGetApp().preset_bundle->project_config.option("nozzle_volume_type"));
for (auto i = 0; i < used_extruders.size(); i++) {
if (nozzle_volume_type_opt) {
NozzleVolumeType nozzle_volume_type = (NozzleVolumeType) (nozzle_volume_type_opt->get_at(used_extruders[i]));
if (nozzle_volume_type == NozzleVolumeType::nvtNormal) { used_extruders_flow[used_extruders[i]] = "Normal";}
else {used_extruders_flow[used_extruders[i]] = "Big Traffic";}
}
}
vector<int> map_extruders = {1, 0};
// The default two extruders are left, right, but the order of the extruders on the machine is right, left.
std::vector<std::string> flow_type_of_machine;
for (auto it = data.extders.rbegin(); it != data.extders.rend(); it++) {
if (it->current_nozzle_flow_type == NozzleFlowType::H_FLOW) {
flow_type_of_machine.push_back("Big Traffic");
} else if (it->current_nozzle_flow_type == NozzleFlowType::S_FLOW){
flow_type_of_machine.push_back("Normal");
}
}
//Only when all preset nozzle types and machine nozzle types are exactly the same, return true.
for (int i = 0; i < flow_types.size(); i++) {
if (flow_types[i] != flow_type_of_machine[i]) return false;
for (std::map<int, std::string>::iterator it = used_extruders_flow.begin(); it!= used_extruders_flow.end(); it++) {
int target_machine_nozzle_id = map_extruders[it->first];
if (target_machine_nozzle_id <= flow_type_of_machine.size()) {
if (flow_type_of_machine[target_machine_nozzle_id] != used_extruders_flow[it->first]) {
return false;
}
}
}
return true;
}
@ -2428,6 +2453,11 @@ void SelectMachineDialog::show_status(PrintDialogStatus status, std::vector<wxSt
update_print_status_msg(msg_text, true, false);
Enable_Send_Button(false);
Enable_Refresh_Button(true);
} else if (status == PrintDialogStatus::PrintStatusNozzleDataInvalid) {
wxString msg_text = _L("Invalid nozzle information, please refresh or manually set nozzle information.");
update_print_status_msg(msg_text, true, false);
Enable_Send_Button(false);
Enable_Refresh_Button(true);
} else if (status == PrintDialogStatus::PrintStatusNozzleMatchInvalid) {
wxString msg_text = _L("Please check whether the nozzle type of the device is the same as the preset nozzle type.");
update_print_status_msg(msg_text, true, false);
@ -2639,7 +2669,7 @@ bool SelectMachineDialog::is_same_nozzle_diameters(std::string& tag_nozzle_type,
std::vector<std::string> machine_nozzle_types(obj_->m_extder_data.extders.size());
for (size_t idx = 0; idx < obj_->m_extder_data.extders.size(); ++idx)
machine_nozzle_types[idx] = obj_->m_extder_data.extders[idx].type;
machine_nozzle_types[idx] = obj_->m_extder_data.extders[idx].current_nozzle_type;
auto used_filaments = wxGetApp().plater()->get_partplate_list().get_curr_plate()->get_used_extruders(); // 1 based
auto filament_maps=wxGetApp().plater()->get_partplate_list().get_curr_plate()->get_filament_maps(); // 1 based
@ -2653,13 +2683,13 @@ bool SelectMachineDialog::is_same_nozzle_diameters(std::string& tag_nozzle_type,
std::sort(used_extruders.begin(), used_extruders.end());
// TODO [tao wang] : add idx mapping
tag_nozzle_type = obj_->m_extder_data.extders[0].type;
tag_nozzle_type = obj_->m_extder_data.extders[0].current_nozzle_type;
if (opt_nozzle_diameters != nullptr) {
for (auto i = 0; i < used_extruders.size(); i++) {
auto extruder = used_extruders[i];
preset_nozzle_diameters = float(opt_nozzle_diameters->get_at(extruder));
if (preset_nozzle_diameters != obj_->m_extder_data.extders[0].diameter) {
if (preset_nozzle_diameters != obj_->m_extder_data.extders[0].current_nozzle_diameter) {
is_same_nozzle_diameters = false;
}
}
@ -2687,15 +2717,7 @@ bool SelectMachineDialog::is_same_nozzle_type(std::string& filament_type, std::s
if (obj_ == nullptr) return true;
NozzleType nozzle_type = NozzleType::ntUndefine;
if (obj_->m_extder_data.extders[0].type == "stainless_steel") {
nozzle_type = NozzleType::ntStainlessSteel;
}
else if (obj_->m_extder_data.extders[0].type == "hardened_steel") {
nozzle_type = NozzleType::ntHardenedSteel;
}
NozzleType nozzle_type = obj_->m_extder_data.extders[0].current_nozzle_type;
auto printer_nozzle_hrc = Print::get_hrc_by_nozzle_type(nozzle_type);
auto preset_bundle = wxGetApp().preset_bundle;
@ -2713,7 +2735,7 @@ bool SelectMachineDialog::is_same_nozzle_type(std::string& filament_type, std::s
return is_same_nozzle_type;
}
else {
tag_nozzle_type = DeviceManager::nozzle_type_conver(obj_->m_extder_data.extders[0].type);
tag_nozzle_type = DeviceManager::nozzle_type_conver(obj_->m_extder_data.extders[0].current_nozzle_type);
}
iter++;
@ -2902,13 +2924,13 @@ void SelectMachineDialog::on_ok_btn(wxCommandEvent &event)
std::string filament_type;
std::string tag_nozzle_type;
if (!obj_->m_extder_data.extders[0].type.empty() && (m_print_type == PrintFromType::FROM_NORMAL)) {
if (!obj_->m_extder_data.extders[0].current_nozzle_type == NozzleType::ntUndefine && (m_print_type == PrintFromType::FROM_NORMAL)) {
if (!is_same_nozzle_diameters(tag_nozzle_type, nozzle_diameter)) {
has_slice_warnings = true;
is_printing_block = true;
wxString nozzle_in_preset = wxString::Format(_L("nozzle in preset: %s %s"),nozzle_diameter, "");
wxString nozzle_in_printer = wxString::Format(_L("nozzle memorized: %.1f %s"), obj_->m_extder_data.extders[0].diameter, "");
wxString nozzle_in_printer = wxString::Format(_L("nozzle memorized: %.1f %s"), obj_->m_extder_data.extders[0].current_nozzle_diameter, "");
confirm_text.push_back(ConfirmBeforeSendInfo(_L("Your nozzle diameter in sliced file is not consistent with memorized nozzle. If you changed your nozzle lately, please go to Device > Printer Parts to change settings.")
+ "\n " + nozzle_in_preset
@ -2919,9 +2941,9 @@ void SelectMachineDialog::on_ok_btn(wxCommandEvent &event)
if (!is_same_nozzle_type(filament_type, tag_nozzle_type)){
has_slice_warnings = true;
is_printing_block = true;
nozzle_diameter = wxString::Format("%.1f", obj_->m_extder_data.extders[0].diameter).ToStdString();
nozzle_diameter = wxString::Format("%.1f", obj_->m_extder_data.extders[0].current_nozzle_diameter).ToStdString();
wxString nozzle_in_preset = wxString::Format(_L("Printing high temperature material(%s material) with %s may cause nozzle damage"), filament_type, format_steel_name(obj_->m_extder_data.extders[0].type));
wxString nozzle_in_preset = wxString::Format(_L("Printing high temperature material(%s material) with %s may cause nozzle damage"), filament_type, format_steel_name(obj_->m_extder_data.extders[0].current_nozzle_type));
confirm_text.push_back(ConfirmBeforeSendInfo(nozzle_in_preset, ConfirmBeforeSendInfo::InfoLevel::Warning));
}
}
@ -2990,12 +3012,12 @@ void SelectMachineDialog::on_ok_btn(wxCommandEvent &event)
}
}
wxString SelectMachineDialog::format_steel_name(std::string name)
wxString SelectMachineDialog::format_steel_name(NozzleType type)
{
if (name == "hardened_steel") {
if (type == NozzleType::ntHardenedSteel) {
return _L("Hardened Steel");
}
else if (name == "stainless_steel") {
else if (type == NozzleType::ntStainlessSteel) {
return _L("Stainless Steel");
}
@ -3912,9 +3934,16 @@ void SelectMachineDialog::update_show_status()
size_t nozzle_nums = full_config.option<ConfigOptionFloatsNullable>("nozzle_diameter")->values.size();
//the nozzle type of preset and machine are different
if (nozzle_nums > 1 && !is_nozzle_type_match(obj_->m_extder_data)) {
show_status(PrintDialogStatus::PrintStatusNozzleMatchInvalid);
return;
if (nozzle_nums > 1) {
if (!obj_->is_nozzle_data_invalid()) {
show_status(PrintDialogStatus::PrintStatusNozzleDataInvalid);
return;
}
if (!is_nozzle_type_match(obj_->m_extder_data)) {
show_status(PrintDialogStatus::PrintStatusNozzleMatchInvalid);
return;
}
}
if (!m_mapping_popup.m_supporting_mix_print && nozzle_nums == 1)
@ -4510,13 +4539,6 @@ void SelectMachineDialog::reset_and_sync_ams_list()
}
}
/*if (extruders.size() <= 10) {
m_sizer_ams_mapping->SetCols(extruders.size());
}
else {
m_sizer_ams_mapping->SetCols(10);
}*/
if (use_double_extruder)
{
m_filament_left_panel->Show();

3
src/slic3r/GUI/SelectMachine.hpp
View File

@ -316,6 +316,7 @@ enum PrintDialogStatus {
PrintStatusAmsMappingU0Invalid,
PrintStatusAmsMappingMixInvalid,
PrintStatusNozzleMatchInvalid,
PrintStatusNozzleDataInvalid,
PrintStatusAmsMappingValid,
PrintStatusAmsMappingByOrder,
PrintStatusRefreshingMachineList,
@ -547,7 +548,7 @@ public:
bool is_nozzle_type_match(ExtderData data);
PrintFromType get_print_type() {return m_print_type;};
wxString format_steel_name(std::string name);
wxString format_steel_name(NozzleType type);
wxString format_text(wxString &m_msg);
wxWindow* create_ams_checkbox(wxString title, wxWindow* parent, wxString tooltip);
wxWindow* create_item_checkbox(wxString title, wxWindow* parent, wxString tooltip, std::string param);

2
src/slic3r/GUI/StatusPanel.cpp
View File

@ -2953,7 +2953,7 @@ void StatusPanel::update_ams(MachineObject *obj)
if (obj && (obj->last_cali_version != obj->cali_version)) {
last_cali_version = obj->cali_version;
PACalibExtruderInfo cali_info;
cali_info.nozzle_diameter = obj->m_extder_data.extders[0].diameter;
cali_info.nozzle_diameter = obj->m_extder_data.extders[0].current_nozzle_diameter;
CalibUtils::emit_get_PA_calib_info(cali_info);
}

16
src/slic3r/Utils/CalibUtils.cpp
View File

@ -115,7 +115,7 @@ static bool is_same_nozzle_diameters(const DynamicPrintConfig &full_config, cons
std::vector<float> machine_nozzle_diameters(obj->m_extder_data.extders.size());
for (size_t idx = 0; idx < obj->m_extder_data.extders.size(); ++idx)
machine_nozzle_diameters[idx] = obj->m_extder_data.extders[idx].diameter;
machine_nozzle_diameters[idx] = obj->m_extder_data.extders[idx].current_nozzle_diameter;
if (config_nozzle_diameters.size() != machine_nozzle_diameters.size()) {
wxString nozzle_in_preset = wxString::Format(_L("nozzle size in preset: %d"), config_nozzle_diameters.size());
@ -145,21 +145,15 @@ static bool is_same_nozzle_type(const DynamicPrintConfig &full_config, const Mac
if (obj == nullptr)
return true;
NozzleType nozzle_type = NozzleType::ntUndefine;
if (obj->m_extder_data.extders[0].type == "stainless_steel") {
nozzle_type = NozzleType::ntStainlessSteel;
} else if (obj->m_extder_data.extders[0].type == "hardened_steel") {
nozzle_type = NozzleType::ntHardenedSteel;
}
NozzleType nozzle_type = obj->m_extder_data.extders[0].current_nozzle_type;
int printer_nozzle_hrc = Print::get_hrc_by_nozzle_type(nozzle_type);
if (full_config.has("required_nozzle_HRC")) {
int filament_nozzle_hrc = full_config.opt_int("required_nozzle_HRC", 0);
if (abs(filament_nozzle_hrc) > abs(printer_nozzle_hrc)) {
BOOST_LOG_TRIVIAL(info) << "filaments hardness mismatch: printer_nozzle_hrc = " << printer_nozzle_hrc << ", filament_nozzle_hrc = " << filament_nozzle_hrc;
std::string filament_type = full_config.opt_string("filament_type", 0);
error_msg = wxString::Format(_L("*Printing %s material with %s may cause nozzle damage"), filament_type, to_wstring_name(obj->m_extder_data.extders[0].type));
error_msg = wxString::Format(_L("*Printing %s material with %s may cause nozzle damage"), filament_type, to_wstring_name(NozzleTypeEumnToStr[obj->m_extder_data.extders[0].current_nozzle_type]));
error_msg += "\n";
MessageDialog msg_dlg(nullptr, error_msg, wxEmptyString, wxICON_WARNING | wxOK | wxCANCEL);
@ -192,7 +186,7 @@ static bool check_nozzle_diameter_and_type(const DynamicPrintConfig &full_config
}
// P1P/S
if (obj->m_extder_data.extders[0].type.empty())
if (obj->m_extder_data.extders[0].current_nozzle_type = NozzleType::ntUndefine)
return true;
if (!is_same_nozzle_diameters(full_config, obj, error_msg))