From db8ae4ccb3069347e1303de104302357bc352754 Mon Sep 17 00:00:00 2001 From: tao wang Date: Sat, 26 Oct 2024 14:30:18 +0800 Subject: [PATCH] NEW:support new nozzle and extder data jira:[new nozzle data] Change-Id: Ief37b42794ce1469163fcd8227431ec77957508e --- src/libslic3r/PrintConfig.hpp | 7 + src/slic3r/GUI/AMSMaterialsSetting.cpp | 10 +- src/slic3r/GUI/CaliHistoryDialog.cpp | 6 +- src/slic3r/GUI/CalibrationWizard.cpp | 2 +- src/slic3r/GUI/CalibrationWizardCaliPage.cpp | 4 +- .../GUI/CalibrationWizardPresetPage.cpp | 4 +- src/slic3r/GUI/DeviceManager.cpp | 181 ++++++++--- src/slic3r/GUI/DeviceManager.hpp | 66 +++- src/slic3r/GUI/Plater.cpp | 6 +- src/slic3r/GUI/PrintOptionsDialog.cpp | 300 ++++++++++-------- src/slic3r/GUI/PrintOptionsDialog.hpp | 14 +- src/slic3r/GUI/SelectMachine.cpp | 112 ++++--- src/slic3r/GUI/SelectMachine.hpp | 3 +- src/slic3r/GUI/StatusPanel.cpp | 2 +- src/slic3r/Utils/CalibUtils.cpp | 16 +- 15 files changed, 476 insertions(+), 257 deletions(-) diff --git a/src/libslic3r/PrintConfig.hpp b/src/libslic3r/PrintConfig.hpp index 0d41caa2f..ce2a14267 100644 --- a/src/libslic3r/PrintConfig.hpp +++ b/src/libslic3r/PrintConfig.hpp @@ -263,6 +263,13 @@ static std::unordered_mapNozzleTypeEumnToStr = { {NozzleType::ntBrass, "brass"} }; +static std::unordered_mapNozzleTypeStrToEumn = { + {"undefine", NozzleType::ntUndefine}, + {"hardened_steel", NozzleType::ntHardenedSteel}, + {"stainless_steel", NozzleType::ntStainlessSteel}, + {"brass", NozzleType::ntBrass} +}; + // BBS enum PrinterStructure { psUndefine=0, diff --git a/src/slic3r/GUI/AMSMaterialsSetting.cpp b/src/slic3r/GUI/AMSMaterialsSetting.cpp index ce8942ea9..f09c6e5f1 100644 --- a/src/slic3r/GUI/AMSMaterialsSetting.cpp +++ b/src/slic3r/GUI/AMSMaterialsSetting.cpp @@ -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 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 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 printer_names = preset_bundle->get_printer_names_by_printer_type_and_nozzle(MachineObject::get_preset_printer_model_name(obj->printer_type), nozzle_diameter_str); diff --git a/src/slic3r/GUI/CaliHistoryDialog.cpp b/src/slic3r/GUI/CaliHistoryDialog.cpp index 82a3de298..85823636a 100644 --- a/src/slic3r/GUI/CaliHistoryDialog.cpp +++ b/src/slic3r/GUI/CaliHistoryDialog.cpp @@ -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 filament_id_set; std::set 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 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); } } diff --git a/src/slic3r/GUI/CalibrationWizard.cpp b/src/slic3r/GUI/CalibrationWizard.cpp index e2c911128..99829d540 100644 --- a/src/slic3r/GUI/CalibrationWizard.cpp +++ b/src/slic3r/GUI/CalibrationWizard.cpp @@ -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); } } diff --git a/src/slic3r/GUI/CalibrationWizardCaliPage.cpp b/src/slic3r/GUI/CalibrationWizardCaliPage.cpp index ca93dbf75..a582359dd 100644 --- a/src/slic3r/GUI/CalibrationWizardCaliPage.cpp +++ b/src/slic3r/GUI/CalibrationWizardCaliPage.cpp @@ -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; diff --git a/src/slic3r/GUI/CalibrationWizardPresetPage.cpp b/src/slic3r/GUI/CalibrationWizardPresetPage.cpp index b8e15224f..15216e7fc 100644 --- a/src/slic3r/GUI/CalibrationWizardPresetPage.cpp +++ b/src/slic3r/GUI/CalibrationWizardPresetPage.cpp @@ -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) { diff --git a/src/slic3r/GUI/DeviceManager.cpp b/src/slic3r/GUI/DeviceManager.cpp index 798211b7a..2b85c0e67 100644 --- a/src/slic3r/GUI/DeviceManager.cpp +++ b/src/slic3r/GUI/DeviceManager.cpp @@ -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()); } - 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(); - 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(), 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(), 0, 3); - m_extder_data.current_extder_id = get_flag_bits(nozzle["state"].get(), 4, 3); - m_extder_data.target_extder_id = get_flag_bits(nozzle["state"].get(), 8, 3); + m_nozzle_data = NozzleData(); + m_nozzle_data.extder_exist = get_flag_bits(nozzle["exist"].get(), 0, 15); + m_nozzle_data.cut_exist = get_flag_bits(nozzle["exist"].get(), 16, 31); + m_nozzle_data.state = get_flag_bits(nozzle["state"].get(), 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(); + nozzle_obj.id = njon["id"].get(); - 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(); + 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(), 0, 2)); - extder_obj.diameter = DeviceManager::nozzle_diameter_conver(get_flag_bits(njon["info"].get(), 3, 3)); - extder_obj.ext_has_filament = get_flag_bits(njon["info"].get(), 7); - extder_obj.buffer_has_filament = get_flag_bits(njon["info"].get(), 8); - extder_obj.flow_type = get_flag_bits(njon["info"].get(), 9, 2); - extder_obj.temp = get_flag_bits(njon["temp"].get(), 0, 15); - extder_obj.target_temp = get_flag_bits(njon["temp"].get(), 16, 15); - - AmsSlot spre; - spre.ams_id = std::to_string(get_flag_bits(njon["spre"].get(), 0, 8)); - spre.slot_id = std::to_string(get_flag_bits(njon["spre"].get(), 8, 8)); - - AmsSlot snow; - snow.ams_id = std::to_string(get_flag_bits(njon["snow"].get(), 0, 8)); - snow.slot_id = std::to_string(get_flag_bits(njon["snow"].get(), 8, 8)); - - AmsSlot star; - star.ams_id = std::to_string(get_flag_bits(njon["star"].get(), 0, 8)); - star.slot_id = std::to_string(get_flag_bits(njon["star"].get(), 8, 8)); - - extder_obj.spre = spre; - extder_obj.snow = snow; - extder_obj.star = star; - extder_obj.ams_stat = get_flag_bits(njon["stat"].get(), 0, 15); - extder_obj.rfid_stat = get_flag_bits(njon["stat"].get(), 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(); + nozzle_obj.max_temp = njon["tm"].get(); + nozzle_obj.wear = njon["wear"].get(); + 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(), 0, 3); + m_extder_data.current_extder_id = get_flag_bits(extruder["state"].get(), 4, 3); + m_extder_data.target_extder_id = get_flag_bits(extruder["state"].get(), 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(); + + extder_obj.enable_change_nozzle= get_flag_bits(njon["info"].get(), 0); + extder_obj.ext_has_filament = get_flag_bits(njon["info"].get(), 1); + extder_obj.buffer_has_filament = get_flag_bits(njon["info"].get(), 2); + extder_obj.nozzle_exist = get_flag_bits(njon["info"].get(), 3); + extder_obj.temp = get_flag_bits(njon["temp"].get(), 0, 15); + extder_obj.target_temp = get_flag_bits(njon["temp"].get(), 16, 15); + + AmsSlot spre; + spre.ams_id = std::to_string(get_flag_bits(njon["spre"].get(), 0, 8)); + spre.slot_id = std::to_string(get_flag_bits(njon["spre"].get(), 8, 8)); + + AmsSlot snow; + snow.ams_id = std::to_string(get_flag_bits(njon["snow"].get(), 0, 8)); + snow.slot_id = std::to_string(get_flag_bits(njon["snow"].get(), 8, 8)); + + AmsSlot star; + star.ams_id = std::to_string(get_flag_bits(njon["star"].get(), 0, 8)); + star.slot_id = std::to_string(get_flag_bits(njon["star"].get(), 8, 8)); + + extder_obj.nozzle_id = njon["hnow"].get(); + extder_obj.target_nozzle_id = njon["htar"].get(); + + extder_obj.spre = spre; + extder_obj.snow = snow; + extder_obj.star = star; + extder_obj.ams_stat = get_flag_bits(njon["stat"].get(), 0, 15); + extder_obj.rfid_stat = get_flag_bits(njon["stat"].get(), 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 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), diff --git a/src/slic3r/GUI/DeviceManager.hpp b/src/slic3r/GUI/DeviceManager.hpp index df7ff5efa..146822032 100644 --- a/src/slic3r/GUI/DeviceManager.hpp +++ b/src/slic3r/GUI/DeviceManager.hpp @@ -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 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 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 */ diff --git a/src/slic3r/GUI/Plater.cpp b/src/slic3r/GUI/Plater.cpp index 7628a2012..3a258edb3 100644 --- a/src/slic3r/GUI/Plater.cpp +++ b/src/slic3r/GUI/Plater.cpp @@ -729,8 +729,8 @@ void Sidebar::priv::sync_extruder_list() } auto printer_tab = dynamic_cast(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 Plater::priv::load_files(const std::vector& input_ const ConfigOption *opt = printer_preset.config.option("nozzle_diameter"); if (opt) preset_nozzle_diameter = static_cast(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) diff --git a/src/slic3r/GUI/PrintOptionsDialog.cpp b/src/slic3r/GUI/PrintOptionsDialog.cpp index 95016e8ce..08b46e58e 100644 --- a/src/slic3r/GUI/PrintOptionsDialog.cpp +++ b/src/slic3r/GUI/PrintOptionsDialog.cpp @@ -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 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 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 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 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(); diff --git a/src/slic3r/GUI/PrintOptionsDialog.hpp b/src/slic3r/GUI/PrintOptionsDialog.hpp index f86075875..f75f01017 100644 --- a/src/slic3r/GUI/PrintOptionsDialog.hpp +++ b/src/slic3r/GUI/PrintOptionsDialog.hpp @@ -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; diff --git a/src/slic3r/GUI/SelectMachine.cpp b/src/slic3r/GUI/SelectMachine.cpp index 11fd0ee38..6047e91fb 100644 --- a/src/slic3r/GUI/SelectMachine.cpp +++ b/src/slic3r/GUI/SelectMachine.cpp @@ -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::vectorflow_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 used_extruders_flow; + std::vector 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 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(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 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 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::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 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("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(); diff --git a/src/slic3r/GUI/SelectMachine.hpp b/src/slic3r/GUI/SelectMachine.hpp index 09b7fe0a5..e15b4e528 100644 --- a/src/slic3r/GUI/SelectMachine.hpp +++ b/src/slic3r/GUI/SelectMachine.hpp @@ -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); diff --git a/src/slic3r/GUI/StatusPanel.cpp b/src/slic3r/GUI/StatusPanel.cpp index f46f25efe..7f99735f5 100644 --- a/src/slic3r/GUI/StatusPanel.cpp +++ b/src/slic3r/GUI/StatusPanel.cpp @@ -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); } diff --git a/src/slic3r/Utils/CalibUtils.cpp b/src/slic3r/Utils/CalibUtils.cpp index c88b1777e..50cc3d4d0 100644 --- a/src/slic3r/Utils/CalibUtils.cpp +++ b/src/slic3r/Utils/CalibUtils.cpp @@ -115,7 +115,7 @@ static bool is_same_nozzle_diameters(const DynamicPrintConfig &full_config, cons std::vector 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))