From 65936b34c17bd6259cf1bb33d4b46fb7238767f7 Mon Sep 17 00:00:00 2001 From: Noisyfox Date: Sat, 24 May 2025 18:37:35 +0800 Subject: [PATCH] Fix crash when using old firmware --- src/libslic3r/PrintConfig.hpp | 7 + src/slic3r/GUI/AMSMaterialsSetting.cpp | 10 +- src/slic3r/GUI/AmsMappingPopup.cpp | 4 +- src/slic3r/GUI/CaliHistoryDialog.cpp | 6 +- src/slic3r/GUI/CalibrationWizard.cpp | 2 +- src/slic3r/GUI/CalibrationWizardCaliPage.cpp | 4 +- .../GUI/CalibrationWizardPresetPage.cpp | 2 +- src/slic3r/GUI/DeviceManager.cpp | 198 +++++++++++++----- src/slic3r/GUI/DeviceManager.hpp | 85 +++++--- src/slic3r/GUI/PrintOptionsDialog.cpp | 169 ++++++++------- src/slic3r/GUI/PrintOptionsDialog.hpp | 10 +- src/slic3r/GUI/SelectMachine.cpp | 129 +++++------- src/slic3r/GUI/SelectMachine.hpp | 6 +- src/slic3r/GUI/StatusPanel.cpp | 2 +- src/slic3r/Utils/CalibUtils.cpp | 24 +-- 15 files changed, 374 insertions(+), 284 deletions(-) diff --git a/src/libslic3r/PrintConfig.hpp b/src/libslic3r/PrintConfig.hpp index c8d1f6a218..62ca1da6d0 100644 --- a/src/libslic3r/PrintConfig.hpp +++ b/src/libslic3r/PrintConfig.hpp @@ -299,6 +299,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 2ebd8bf99a..db04cf5065 100644 --- a/src/slic3r/GUI/AMSMaterialsSetting.cpp +++ b/src/slic3r/GUI/AMSMaterialsSetting.cpp @@ -542,7 +542,7 @@ void AMSMaterialsSetting::on_select_reset(wxCommandEvent& event) { select_index_info.tray_id = tray_id; select_index_info.ams_id = ams_id; select_index_info.slot_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); @@ -666,7 +666,7 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event) select_index_info.tray_id = vt_tray; select_index_info.ams_id = 255; // TODO: Orca hack select_index_info.slot_id = 0; - 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) { @@ -707,7 +707,7 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event) select_index_info.tray_id = cali_tray_id; select_index_info.ams_id = ams_id; select_index_info.slot_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; auto cali_select_id = m_comboBox_cali_result->GetSelection(); if (m_pa_profile_items.size() > 0 && cali_select_id > 0) { @@ -870,7 +870,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); @@ -1036,7 +1036,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/AmsMappingPopup.cpp b/src/slic3r/GUI/AmsMappingPopup.cpp index 2feb54043d..bc1bc5ca84 100644 --- a/src/slic3r/GUI/AmsMappingPopup.cpp +++ b/src/slic3r/GUI/AmsMappingPopup.cpp @@ -1407,7 +1407,9 @@ void AmsReplaceMaterialDialog::update_machine_obj(MachineObject* obj) //creat group int group_index = 0; - for (int filam : m_obj->filam_bak) { + + const Extder& extder = m_obj->m_extder_data.extders[MAIN_NOZZLE_ID]; + for (int filam : extder.filam_bak) { auto status_list = GetStatus(filam); std::map group_info; diff --git a/src/slic3r/GUI/CaliHistoryDialog.cpp b/src/slic3r/GUI/CaliHistoryDialog.cpp index 2cc210c6c2..46a3eb4f4e 100644 --- a/src/slic3r/GUI/CaliHistoryDialog.cpp +++ b/src/slic3r/GUI/CaliHistoryDialog.cpp @@ -180,7 +180,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; } } @@ -507,7 +507,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++) { @@ -624,7 +624,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 7ebf076a87..7e8ff01de0 100644 --- a/src/slic3r/GUI/CalibrationWizard.cpp +++ b/src/slic3r/GUI/CalibrationWizard.cpp @@ -497,7 +497,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; cali_info.use_extruder_id = false; cali_info.use_nozzle_volume_type = false; CalibUtils::emit_get_PA_calib_infos(cali_info); diff --git a/src/slic3r/GUI/CalibrationWizardCaliPage.cpp b/src/slic3r/GUI/CalibrationWizardCaliPage.cpp index 9cd780ff97..927285c149 100644 --- a/src/slic3r/GUI/CalibrationWizardCaliPage.cpp +++ b/src/slic3r/GUI/CalibrationWizardCaliPage.cpp @@ -495,8 +495,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 207ba657d8..badb4a6945 100644 --- a/src/slic3r/GUI/CalibrationWizardPresetPage.cpp +++ b/src/slic3r/GUI/CalibrationWizardPresetPage.cpp @@ -1504,7 +1504,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; diff --git a/src/slic3r/GUI/DeviceManager.cpp b/src/slic3r/GUI/DeviceManager.cpp index 40254ce18e..adc7d57e14 100644 --- a/src/slic3r/GUI/DeviceManager.cpp +++ b/src/slic3r/GUI/DeviceManager.cpp @@ -620,10 +620,13 @@ MachineObject::MachineObject(NetworkAgent* agent, std::string name, std::string has_ipcam = true; // default true - m_extder_data.current_extder_id = 0; - m_extder_data.target_extder_id = 0; - m_extder_data.total_extder_count = 1; + m_extder_data.current_extder_id = MAIN_NOZZLE_ID; + m_extder_data.target_extder_id = MAIN_NOZZLE_ID; + m_extder_data.total_extder_count = 1; Extder nozzle; + nozzle.id = MAIN_NOZZLE_ID; + nozzle.nozzle_id = MAIN_NOZZLE_ID; + nozzle.target_nozzle_id = MAIN_NOZZLE_ID; m_extder_data.extders.push_back(nozzle); } @@ -3342,8 +3345,11 @@ int MachineObject::parse_json(std::string payload, bool key_field_only) home_flag = jj["home_flag"].get(); parse_status(home_flag); } + + /*the param is invalid in np for Yeshu*/ if (jj.contains("hw_switch_state")) { hw_switch_state = jj["hw_switch_state"].get(); + m_extder_data.extders[MAIN_NOZZLE_ID].ext_has_filament = hw_switch_state; } if (jj.contains("mc_print_line_number")) { if (jj["mc_print_line_number"].is_string() && !jj["mc_print_line_number"].is_null()) @@ -3516,14 +3522,14 @@ int MachineObject::parse_json(std::string payload, bool key_field_only) if (jj.contains("nozzle_temper")) { if (jj["nozzle_temper"].is_number()) { if (m_extder_data.extders.size() == 1) { - m_extder_data.extders[0].temp = jj["nozzle_temper"].get(); + m_extder_data.extders[MAIN_NOZZLE_ID].temp = jj["nozzle_temper"].get(); } } } if (jj.contains("nozzle_target_temper")) { if (jj["nozzle_target_temper"].is_number()) { if (m_extder_data.extders.size() == 1) { - m_extder_data.extders[0].target_temp = jj["nozzle_target_temper"].get(); + m_extder_data.extders[MAIN_NOZZLE_ID].target_temp = jj["nozzle_target_temper"].get(); } } } @@ -3621,12 +3627,14 @@ int MachineObject::parse_json(std::string payload, bool key_field_only) if (!key_field_only) { /*get filam_bak*/ try { + m_extder_data.extders[MAIN_NOZZLE_ID].filam_bak.clear(); + if (jj.contains("filam_bak")) { is_support_show_filament_backup = true; - filam_bak.clear(); if (jj["filam_bak"].is_array()) { for (auto it = jj["filam_bak"].begin(); it != jj["filam_bak"].end(); it++) { - filam_bak.push_back(it.value().get()); + const auto& filam_bak_val = it.value().get(); + m_extder_data.extders[MAIN_NOZZLE_ID].filam_bak.push_back(filam_bak_val); } } } @@ -3708,8 +3716,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[MAIN_NOZZLE_ID].current_nozzle_diameter = 0.0f;} + else { m_extder_data.extders[MAIN_NOZZLE_ID].current_nozzle_diameter = round(nozzle_diameter * 10) / 10;} } } } @@ -3726,7 +3734,12 @@ 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; + if (nozzle_type.empty()) { + m_extder_data.extders[MAIN_NOZZLE_ID].current_nozzle_type = NozzleType::ntUndefine; + } + else { + m_extder_data.extders[MAIN_NOZZLE_ID].current_nozzle_type = NozzleTypeStrToEumn[nozzle_type]; + } } } } @@ -5550,55 +5563,136 @@ void MachineObject::parse_new_info(json print) } if (device.contains("nozzle")) { - json const& nozzle = device["nozzle"]; + json const &nozzle = device["nozzle"]; - m_extder_data = ExtderData(); - m_extder_data.current_extder_id = get_flag_bits(nozzle["info"].get(), 0, 3); - m_extder_data.target_extder_id = get_flag_bits(nozzle["info"].get(), 4, 3); - m_extder_data.total_extder_count = get_flag_bits(nozzle["info"].get(), 8, 3); + m_nozzle_data = NozzleData(); + m_nozzle_data.extder_exist = get_flag_bits(nozzle["exist"].get(), 0, 16); + m_nozzle_data.cut_exist = get_flag_bits(nozzle["exist"].get(), 16, 16); + m_nozzle_data.state = get_flag_bits(nozzle["state"].get(), 0, 4); - 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 nozzle_obj; - - std::string nozzle_id = std::to_string(i); - if (nozzle.contains(nozzle_id)) { - auto njon = nozzle[nozzle_id].get(); - - nozzle_obj.type = DeviceManager::nozzle_type_conver(get_flag_bits(njon["info"].get(), 0, 2)); - nozzle_obj.diameter = DeviceManager::nozzle_diameter_conver(get_flag_bits(njon["info"].get(), 3, 3)); - nozzle_obj.ext_has_filament = get_flag_bits(njon["info"].get(), 7); - nozzle_obj.buffer_has_filament = get_flag_bits(njon["info"].get(), 8); - nozzle_obj.flow_type = get_flag_bits(njon["info"].get(), 9, 2); - nozzle_obj.temp = get_flag_bits(njon["temp"].get(), 0, 15); - nozzle_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)); - - nozzle_obj.spre = spre; - nozzle_obj.snow = snow; - nozzle_obj.star = star; - nozzle_obj.ams_stat = get_flag_bits(njon["stat"].get(), 0, 15); - nozzle_obj.rfid_stat = get_flag_bits(njon["stat"].get(), 16, 7); + if (type.length() >= 4) { + 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; + } + } else { + nozzle_obj.nozzle_type = NozzleType::ntUndefine; } - m_extder_data.extders.push_back(nozzle_obj); + 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"]; + + auto extder_data = ExtderData(); + extder_data.total_extder_count = get_flag_bits(extruder["state"].get(), 0, 4); + + + extder_data.current_extder_id = get_flag_bits(extruder["state"].get(), 4, 4); + extder_data.target_extder_id = get_flag_bits(extruder["state"].get(), 8, 4); + + 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.filam_bak.clear(); + is_support_show_filament_backup = njon.contains("filam_bak"); + if (is_support_show_filament_backup) + { + const json& filam_bak_items = njon["filam_bak"]; + for (const auto& filam_bak_item : filam_bak_items) + { + const auto& filam_bak_val = filam_bak_item.get(); + extder_obj.filam_bak.emplace_back(filam_bak_val); + } + } + + 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, 16); + extder_obj.target_temp = get_flag_bits(njon["temp"].get(), 16, 16); + + AmsSlot spre; + spre.slot_id = std::to_string(get_flag_bits(njon["spre"].get(), 0, 8)); + spre.ams_id = std::to_string(get_flag_bits(njon["spre"].get(), 8, 8)); + + AmsSlot snow; + snow.slot_id = std::to_string(get_flag_bits(njon["snow"].get(), 0, 8)); + snow.ams_id = std::to_string(get_flag_bits(njon["snow"].get(), 8, 8)); + + AmsSlot star; + star.slot_id = std::to_string(get_flag_bits(njon["star"].get(), 0, 8)); + star.ams_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, 16); + extder_obj.rfid_stat = get_flag_bits(njon["stat"].get(), 16, 16); + + //current nozzle info + if (extder_obj.nozzle_id == 0xff) { + extder_obj.current_nozzle_type = NozzleType::ntUndefine; + extder_obj.current_nozzle_diameter = 0.4f; + } 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_data.extders.push_back(extder_obj); + } + + if (extder_data.extders.size() <= 0) { + // def data + extder_data.current_extder_id = 0; + extder_data.target_extder_id = 0; + extder_data.total_extder_count = 1; + Extder nozzle; + extder_data.extders.push_back(nozzle); + } + + m_extder_data = extder_data; + } } } +bool MachineObject::is_nozzle_data_invalid() +{ + for (const auto &ext : m_extder_data.extders) + { + if (ext.current_nozzle_type == NozzleType::ntUndefine || + ext.current_nozzle_diameter <= 0.0f) { + return true; + } + } + + return false; +} + int MachineObject::get_flag_bits(std::string str, int start, int count) const { try { @@ -5705,7 +5799,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(); @@ -5746,7 +5840,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()) { @@ -5808,7 +5902,7 @@ 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(); @@ -5840,7 +5934,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[MAIN_NOZZLE_ID].diameter; + stream << std::fixed << std::setprecision(1) << m_extder_data.extders[MAIN_NOZZLE_ID].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 ba9dc58a17..654e4c9a88 100644 --- a/src/slic3r/GUI/DeviceManager.hpp +++ b/src/slic3r/GUI/DeviceManager.hpp @@ -145,22 +145,49 @@ struct AmsSlot std::string slot_id; }; +struct Nozzle +{ + int id; + 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 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}; + std::vector filam_bak;// the refill filam + + 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 }; struct ExtderData @@ -266,25 +293,27 @@ public: #define INVALID_AMS_TEMPERATURE std::numeric_limits::min() -class Ams { +class Ams +{ public: - Ams(std::string ams_id, int nozzle_id, int type_id) { - id = ams_id; + Ams(std::string ams_id, int nozzle_id, int type_id) + { + id = ams_id; nozzle = nozzle_id; - type = type_id; + type = type_id; } - std::string id; - int left_dry_time = 0; - int humidity = 5; - int humidity_raw = -1;// the percentage, -1 means invalid. eg. 100 means 100% - float current_temperature = INVALID_AMS_TEMPERATURE; // the temperature - bool startup_read_opt{true}; - bool tray_read_opt{false}; - bool is_exists{false}; - std::map trayList; + std::string id; + int left_dry_time = 0; + int humidity = 5; + int humidity_raw = -1; // the percentage, -1 means invalid. eg. 100 means 100% + float current_temperature = INVALID_AMS_TEMPERATURE; // the temperature + bool startup_read_opt{true}; + bool tray_read_opt{false}; + bool is_exists{false}; + std::map trayList; - int nozzle; - int type{1}; //0:dummy 1:ams 2:ams-lite 3:n3f 4:n3s + int nozzle; + int type{1}; // 0:dummy 1:ams 2:ams-lite 3:n3f 4:n3s }; enum PrinterFirmwareType { @@ -380,6 +409,7 @@ private: // type, time stamp, delay std::vector> message_delay; + public: enum LIGHT_EFFECT { @@ -507,9 +537,6 @@ public: std::string product_name; // set by iot service, get /user/print - std::vector filam_bak; - - std::string bind_user_name; std::string bind_user_id; std::string bind_state; /* free | occupied */ @@ -1045,6 +1072,7 @@ public: bool is_enable_ams_np{ false }; ExtderData m_extder_data; + NozzleData m_nozzle_data; /*vi slot data*/ AmsTray vt_tray; // virtual tray @@ -1053,6 +1081,7 @@ public: /*for parse new info*/ bool check_enable_np(const json& print) const; void parse_new_info(json print); + bool is_nozzle_data_invalid(); int get_flag_bits(std::string str, int start, int count = 1) const; int get_flag_bits(int num, int start, int count = 1, int base = 10) const; diff --git a/src/slic3r/GUI/PrintOptionsDialog.cpp b/src/slic3r/GUI/PrintOptionsDialog.cpp index 13d1e3ba8a..13d085468f 100644 --- a/src/slic3r/GUI/PrintOptionsDialog.cpp +++ b/src/slic3r/GUI/PrintOptionsDialog.cpp @@ -429,9 +429,9 @@ void PrintOptionsDialog::update_machine_obj(MachineObject *obj_) bool PrintOptionsDialog::Show(bool show) { - if (show) { + if (show) { wxGetApp().UpdateDlgDarkUI(this); - CentreOnParent(); + CentreOnParent(); } return DPIDialog::Show(show); } @@ -439,8 +439,11 @@ bool PrintOptionsDialog::Show(bool show) PrinterPartsDialog::PrinterPartsDialog(wxWindow* parent) : DPIDialog(parent, wxID_ANY, _L("Printer Parts"), wxDefaultPosition, wxDefaultSize, wxCAPTION | wxCLOSE_BOX) { - nozzle_type_map[0] = "hardened_steel"; - nozzle_type_map[1] = "stainless_steel"; + nozzle_type_map[NozzleType::ntHardenedSteel] = _L("Hardened Steel"); + nozzle_type_map[NozzleType::ntStainlessSteel] = _L("Stainless Steel"); + + nozzle_type_selection_map[NozzleType::ntHardenedSteel] = 0; + nozzle_type_selection_map[NozzleType::ntStainlessSteel] = 1; nozzle_stainless_diameter_map[0] = 0.2; nozzle_stainless_diameter_map[1] = 0.4; @@ -466,12 +469,15 @@ PrinterPartsDialog::PrinterPartsDialog(wxWindow* parent) nozzle_type->SetForegroundColour(STATIC_TEXT_CAPTION_COL); nozzle_type->Wrap(-1); + ID_NOZZLE_TYPE_CHECKBOX_SINGLE = wxNewId(); + ID_NOZZLE_DIAMETER_CHECKBOX_SINGLE = wxNewId(); + nozzle_type_checkbox = new ComboBox(this, 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")); + nozzle_type_checkbox->Append(nozzle_type_map[NozzleType::ntHardenedSteel]); + nozzle_type_checkbox->Append(nozzle_type_map[NozzleType::ntStainlessSteel]); nozzle_type_checkbox->SetSelection(0); - + line_sizer_nozzle_type->Add(nozzle_type, 0, wxALIGN_CENTER, 5); line_sizer_nozzle_type->Add(0, 0, 1, wxEXPAND, 5); line_sizer_nozzle_type->Add(nozzle_type_checkbox, 0, wxALIGN_CENTER, 5); @@ -500,65 +506,76 @@ PrinterPartsDialog::PrinterPartsDialog(wxWindow* parent) sizer->Add(line_sizer_nozzle_diameter, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(18)); 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 ); - SetSizer(sizer); Layout(); Fit(); 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); + + nozzle_type_checkbox->SetId(ID_NOZZLE_TYPE_CHECKBOX_SINGLE); + + nozzle_diameter_checkbox->SetId(ID_NOZZLE_DIAMETER_CHECKBOX_SINGLE); } 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; - if (type == last_nozzle_type) { - return; + int nozzle_id = MAIN_NOZZLE_ID; + + if (evt.GetId() == ID_NOZZLE_TYPE_CHECKBOX_SINGLE || + evt.GetId() == ID_NOZZLE_DIAMETER_CHECKBOX_SINGLE) { + current_nozzle_type_combox = nozzle_type_checkbox; + current_nozzle_diameter_combox = nozzle_diameter_checkbox; + nozzle_id = MAIN_NOZZLE_ID; } - 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("%.1f", diameter_list[i])); - } - nozzle_diameter_checkbox->SetSelection(0); - - - last_nozzle_type = type; - set_nozzle_diameter(evt); -} - -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; + try { + auto nozzle_type = NozzleType::ntHardenedSteel; + auto nozzle_diameter = 0.4f; - obj->command_set_printer_nozzle(nozzle_type, nozzle_diameter); - } - catch (...) {} + for (auto sm : nozzle_type_selection_map) { + if (sm.second == current_nozzle_type_combox->GetSelection()) { + nozzle_type = sm.first; + } + } + + + /*update nozzle diameter*/ + if (evt.GetId() == ID_NOZZLE_TYPE_CHECKBOX_SINGLE) { + nozzle_diameter_checkbox->Clear(); + std::map diameter_map; + if (nozzle_type == NozzleType::ntHardenedSteel) { + diameter_map = nozzle_hard_diameter_map; + } else if (nozzle_type == NozzleType::ntStainlessSteel) { + diameter_map = nozzle_stainless_diameter_map; + } + + for (int i = 0; i < diameter_map.size(); i++) { nozzle_diameter_checkbox->Append(wxString::Format(_L("%.1f"), diameter_map[i])); } + nozzle_diameter_checkbox->SetSelection(0); + } + + nozzle_diameter = std::stof(current_nozzle_diameter_combox->GetStringSelection().ToStdString()); + nozzle_diameter = round(nozzle_diameter * 10) / 10; + + /*if (!obj->is_enable_np)*/ { + if (current_nozzle_type_combox && current_nozzle_type_combox->IsShown() && current_nozzle_type_combox->GetValue().IsEmpty()) { return; } + if (current_nozzle_diameter_combox && current_nozzle_diameter_combox->IsShown() && current_nozzle_diameter_combox->GetValue().IsEmpty()) { return; } + obj->m_extder_data.extders[MAIN_NOZZLE_ID].current_nozzle_diameter = nozzle_diameter; + obj->m_extder_data.extders[MAIN_NOZZLE_ID].current_nozzle_type = nozzle_type; + obj->command_set_printer_nozzle(NozzleTypeEumnToStr[nozzle_type], nozzle_diameter); + } + } catch (...) {} } } @@ -578,50 +595,30 @@ bool PrinterPartsDialog::Show(bool show) wxGetApp().UpdateDlgDarkUI(this); CentreOnParent(); + auto type = obj->m_extder_data.extders[MAIN_NOZZLE_ID].current_nozzle_type; + auto diameter = obj->m_extder_data.extders[MAIN_NOZZLE_ID].current_nozzle_diameter; - auto type = obj->m_extder_data.extders[0].type; - auto diameter = obj->m_extder_data.extders[0].diameter; - - nozzle_type_checkbox->Clear(); nozzle_diameter_checkbox->Clear(); - if (type.empty()) { + if (type == NozzleType::ntUndefine) { nozzle_type_checkbox->SetValue(wxEmptyString); nozzle_diameter_checkbox->SetValue(wxEmptyString); - - nozzle_type_checkbox->Disable(); - nozzle_diameter_checkbox->Disable(); - return DPIDialog::Show(show); - } - else { - nozzle_type_checkbox->Enable(); - nozzle_diameter_checkbox->Enable(); - } - - last_nozzle_type = type; - - for (int i=0; i < nozzle_type_map.size(); i++) - { - nozzle_type_checkbox->Append( nozzle_type_map[i] ); - if (nozzle_type_map[i] == type) { - nozzle_type_checkbox->SetSelection(i); + } else { + std::map diameter_map; + if (type == NozzleType::ntHardenedSteel) { + diameter_map = nozzle_hard_diameter_map; + } else if (type == NozzleType::ntStainlessSteel) { + diameter_map = 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++) - { - nozzle_diameter_checkbox->Append( wxString::Format("%.1f", diameter_list[i])); - if (diameter_list[i] == diameter) { - nozzle_diameter_checkbox->SetSelection(i); + for (int i = 0; i < diameter_map.size(); i++) { + nozzle_diameter_checkbox->Append(wxString::Format(_L("%.1f"), diameter_map[i])); + if (diameter == diameter_map[i]) { + nozzle_diameter_checkbox->SetSelection(i); + } } + + nozzle_type_checkbox->SetSelection(nozzle_type_selection_map[type]); } } return DPIDialog::Show(show); diff --git a/src/slic3r/GUI/PrintOptionsDialog.hpp b/src/slic3r/GUI/PrintOptionsDialog.hpp index db55d12dcc..7450933a43 100644 --- a/src/slic3r/GUI/PrintOptionsDialog.hpp +++ b/src/slic3r/GUI/PrintOptionsDialog.hpp @@ -21,18 +21,22 @@ namespace Slic3r { namespace GUI { class PrinterPartsDialog : public DPIDialog { protected: + wxWindowID ID_NOZZLE_TYPE_CHECKBOX_SINGLE; + + wxWindowID ID_NOZZLE_DIAMETER_CHECKBOX_SINGLE; + MachineObject* obj{ nullptr }; ComboBox* nozzle_type_checkbox; ComboBox* nozzle_diameter_checkbox; std::string last_nozzle_type; - std::map nozzle_type_map; + std::map nozzle_type_map; + std::map nozzle_type_selection_map; std::map nozzle_stainless_diameter_map; std::map nozzle_hard_diameter_map; 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 93a4e6f19a..6151706deb 100644 --- a/src/slic3r/GUI/SelectMachine.cpp +++ b/src/slic3r/GUI/SelectMachine.cpp @@ -2462,8 +2462,8 @@ bool SelectMachineDialog::is_blocking_printing(MachineObject* obj_) if (m_print_type == PrintFromType::FROM_NORMAL) { PresetBundle* preset_bundle = wxGetApp().preset_bundle; source_model = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle); - - + + }else if (m_print_type == PrintFromType::FROM_SDCARD_VIEW) { if (m_required_data_plate_data_list.size() > 0) { source_model = m_required_data_plate_data_list[m_print_plate_idx]->printer_model_id; @@ -2481,81 +2481,52 @@ bool SelectMachineDialog::is_blocking_printing(MachineObject* obj_) return false; } -bool SelectMachineDialog::is_same_nozzle_diameters(std::string& tag_nozzle_type, std::string& nozzle_diameter) + +/**************************************************************//* + * @param tag_nozzle_type -- return the mismatch nozzle type + * @param tag_nozzle_diameter -- return the target nozzle_diameter but mismatch + * @return is same or not +/*************************************************************/ +bool SelectMachineDialog::is_same_nozzle_diameters(float &tag_nozzle_diameter) const { - bool is_same_nozzle_diameters = true; - - float preset_nozzle_diameters; - std::string preset_nozzle_type; - DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager(); - if (!dev) return true; + if (!dev) return false; MachineObject* obj_ = dev->get_selected_machine(); - if (obj_ == nullptr) return true; + if (obj_ == nullptr) return false; + + PresetBundle* preset_bundle = wxGetApp().preset_bundle; + auto opt_nozzle_diameters = preset_bundle->printers.get_edited_preset().config.option("nozzle_diameter"); + if (!opt_nozzle_diameters) + { + return false; + } try { - PresetBundle* preset_bundle = wxGetApp().preset_bundle; - auto opt_nozzle_diameters = preset_bundle->printers.get_edited_preset().config.option("nozzle_diameter"); - - const ConfigOptionEnum* nozzle_type = preset_bundle->printers.get_edited_preset().config.option>("nozzle_type"); - - if (nozzle_type->value == NozzleType::ntHardenedSteel) { - preset_nozzle_type = "hardened_steel"; - } - else if (nozzle_type->value == NozzleType::ntStainlessSteel) { - preset_nozzle_type = "stainless_steel"; - } - - tag_nozzle_type = obj_->m_extder_data.extders[0].type; - - auto extruders = wxGetApp().plater()->get_partplate_list().get_curr_plate()->get_used_extruders(); - if (opt_nozzle_diameters != nullptr) { - for (auto i = 0; i < extruders.size(); i++) { - auto extruder = extruders[i] - 1; - preset_nozzle_diameters = float(opt_nozzle_diameters->get_at(extruder)); - if (preset_nozzle_diameters != obj_->m_extder_data.extders[0].diameter) { - is_same_nozzle_diameters = false; - } + auto extruders = wxGetApp().plater()->get_partplate_list().get_curr_plate()->get_used_extruders(); + for (auto i = 0; i < extruders.size(); i++) { + auto extruder = extruders[i] - 1; + tag_nozzle_diameter = float(opt_nozzle_diameters->get_at(extruder)); + if (tag_nozzle_diameter != obj_->m_extder_data.extders[0].current_nozzle_diameter) { + return false; } } - } - catch (...) + catch (const std::exception&) { + return false; } - //nozzle_type = preset_nozzle_type; - nozzle_diameter = wxString::Format("%.2f", preset_nozzle_diameters).ToStdString(); - - return is_same_nozzle_diameters; + return true; } -bool SelectMachineDialog::is_same_nozzle_type(std::string& filament_type, std::string& tag_nozzle_type) +bool SelectMachineDialog::is_same_nozzle_type(const Extder& extruder, std::string& filament_type) const { - bool is_same_nozzle_type = true; - - DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager(); - if (!dev) return true; - - MachineObject* obj_ = dev->get_selected_machine(); - 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; - } - - auto printer_nozzle_hrc = Print::get_hrc_by_nozzle_type(nozzle_type); + auto printer_nozzle_hrc = Print::get_hrc_by_nozzle_type(extruder.current_nozzle_type); auto preset_bundle = wxGetApp().preset_bundle; - MaterialHash::iterator iter = m_materialList.begin(); + MaterialHash::const_iterator iter = m_materialList.begin(); while (iter != m_materialList.end()) { Material* item = iter->second; MaterialItem* m = item->item; @@ -2564,18 +2535,13 @@ bool SelectMachineDialog::is_same_nozzle_type(std::string& filament_type, std::s if (abs(filament_nozzle_hrc) > abs(printer_nozzle_hrc)) { filament_type = m->m_material_name.ToStdString(); BOOST_LOG_TRIVIAL(info) << "filaments hardness mismatch: filament = " << filament_type << " printer_nozzle_hrc = " << printer_nozzle_hrc; - is_same_nozzle_type = false; - tag_nozzle_type = "hardened_steel"; - return is_same_nozzle_type; - } - else { - tag_nozzle_type = DeviceManager::nozzle_type_conver(obj_->m_extder_data.extders[0].type); + return false; } iter++; } - return is_same_nozzle_type; + return true; } bool SelectMachineDialog::is_same_printer_model() @@ -2758,17 +2724,16 @@ void SelectMachineDialog::on_ok_btn(wxCommandEvent &event) confirm_text.push_back(ConfirmBeforeSendInfo(_L("There are some unknown filaments in the AMS mappings. Please check whether they are the required filaments. If they are okay, press \"Confirm\" to start printing."))); } - std::string nozzle_diameter; - 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 (!is_same_nozzle_diameters(tag_nozzle_type, nozzle_diameter)) { + if (!obj_->m_extder_data.extders[0].current_nozzle_type != ntUndefine && (m_print_type == PrintFromType::FROM_NORMAL)) + { + float nozzle_diameter = 0; + if (!is_same_nozzle_diameters(nozzle_diameter)) + { has_slice_warnings = true; // is_printing_block = true; # Removed to allow nozzle overrides (to support non-standard nozzles) - 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_preset = wxString::Format(_L("nozzle in preset: %.1f %s"),nozzle_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 @@ -2776,12 +2741,13 @@ void SelectMachineDialog::on_ok_btn(wxCommandEvent &event) + "\n", ConfirmBeforeSendInfo::InfoLevel::Warning)); } - if (!is_same_nozzle_type(filament_type, tag_nozzle_type)){ + std::string filament_type; + if (!is_same_nozzle_type(obj_->m_extder_data.extders[0], filament_type)) + { has_slice_warnings = true; is_printing_block = true; - nozzle_diameter = wxString::Format("%.1f", obj_->m_extder_data.extders[0].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)); } } @@ -2850,18 +2816,19 @@ 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"); } - return wxEmptyString; + return _L("Unknown"); } + void SelectMachineDialog::Enable_Auto_Refill(bool enable) { if (enable) { diff --git a/src/slic3r/GUI/SelectMachine.hpp b/src/slic3r/GUI/SelectMachine.hpp index 1b6c62b31e..a31623055f 100644 --- a/src/slic3r/GUI/SelectMachine.hpp +++ b/src/slic3r/GUI/SelectMachine.hpp @@ -542,8 +542,8 @@ public: void update_timelapse_enable_status(); bool is_same_printer_model(); bool is_blocking_printing(MachineObject* obj_); - bool is_same_nozzle_diameters(std::string& tag_nozzle_type, std::string& nozzle_diameter); - bool is_same_nozzle_type(std::string& filament_type, std::string& tag_nozzle_type); + bool is_same_nozzle_diameters(float& tag_nozzle_diameter) const; + bool is_same_nozzle_type(const Extder& extruder, std::string& filament_type) const; bool has_tips(MachineObject* obj); bool is_timeout(); int update_print_required_data(Slic3r::DynamicPrintConfig config, Slic3r::Model model, Slic3r::PlateDataPtrs plate_data_list, std::string file_name, std::string file_path); @@ -554,7 +554,7 @@ public: bool build_nozzles_info(std::string& nozzles_info); 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 9fe5ac1ff7..caf6750b1d 100644 --- a/src/slic3r/GUI/StatusPanel.cpp +++ b/src/slic3r/GUI/StatusPanel.cpp @@ -2587,7 +2587,7 @@ void StatusPanel::update_ams(MachineObject *obj) if (obj->cali_version != -1 && 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; cali_info.use_extruder_id = false; cali_info.use_nozzle_volume_type = false; CalibUtils::emit_get_PA_calib_infos(cali_info); diff --git a/src/slic3r/Utils/CalibUtils.cpp b/src/slic3r/Utils/CalibUtils.cpp index 73e9126ccd..c0629fa2f3 100644 --- a/src/slic3r/Utils/CalibUtils.cpp +++ b/src/slic3r/Utils/CalibUtils.cpp @@ -98,18 +98,14 @@ static bool is_same_nozzle_diameters(const DynamicPrintConfig &full_config, cons try { std::string nozzle_type; const ConfigOptionEnum * config_nozzle_type = full_config.option>("nozzle_type"); - if (config_nozzle_type->value == NozzleType::ntHardenedSteel) { - nozzle_type = "hardened_steel"; - } else if (config_nozzle_type->value == NozzleType::ntStainlessSteel) { - nozzle_type = "stainless_steel"; - } + nozzle_type = NozzleTypeEumnToStr[config_nozzle_type->value]; auto opt_nozzle_diameters = full_config.option("nozzle_diameter"); if (opt_nozzle_diameters != nullptr) { float preset_nozzle_diameter = opt_nozzle_diameters->get_at(0); - if (preset_nozzle_diameter != obj->m_extder_data.extders[0].diameter) { + if (preset_nozzle_diameter != obj->m_extder_data.extders[0].current_nozzle_diameter) { wxString nozzle_in_preset = wxString::Format(_L("nozzle in preset: %s %s"), wxString::Format("%.1f", preset_nozzle_diameter).ToStdString(), to_wstring_name(nozzle_type)); - wxString nozzle_in_printer = wxString::Format(_L("nozzle memorized: %.1f %s"), obj->m_extder_data.extders[0].diameter, DeviceManager::nozzle_type_conver(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, to_wstring_name(NozzleTypeEumnToStr[obj->m_extder_data.extders[0].current_nozzle_type])); error_msg = _L("Your nozzle diameter in preset is not consistent with memorized nozzle diameter. Did you change your nozzle lately?") + "\n " + nozzle_in_preset + "\n " + nozzle_in_printer + "\n"; @@ -127,21 +123,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); @@ -174,7 +164,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))