juli/OrcaSlicer
1
1
Fork 0
mirror of https://github.com/OrcaSlicer/OrcaSlicer.git synced 2026-09-28 03:11:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix crash when using old firmware

Browse Source
This commit is contained in:
Noisyfox
2025-05-24 18:37:35 +08:00
parent 0d61ae87ed
commit 65936b34c1
15 changed files with 374 additions and 284 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libslic3r/PrintConfig.hpp
+7
View File
@@ -299,6 +299,13 @@ static std::unordered_map<NozzleType, std::string>NozzleTypeEumnToStr = {
{NozzleType::ntBrass, "brass"} {NozzleType::ntBrass, "brass"}
}; };
static std::unordered_map<std::string, NozzleType>NozzleTypeStrToEumn = {
{"undefine", NozzleType::ntUndefine},
{"hardened_steel", NozzleType::ntHardenedSteel},
{"stainless_steel", NozzleType::ntStainlessSteel},
{"brass", NozzleType::ntBrass}
};
// BBS // BBS
enum PrinterStructure { enum PrinterStructure {
psUndefine=0, psUndefine=0,
src/slic3r/GUI/AMSMaterialsSetting.cpp
+5 -5
View File
@@ -542,7 +542,7 @@ void AMSMaterialsSetting::on_select_reset(wxCommandEvent& event) {
select_index_info.tray_id = tray_id; select_index_info.tray_id = tray_id;
select_index_info.ams_id = ams_id; select_index_info.ams_id = ams_id;
select_index_info.slot_id = slot_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.cali_idx = -1;
select_index_info.filament_id = selected_ams_id; select_index_info.filament_id = selected_ams_id;
CalibUtils::select_PA_calib_result(select_index_info); 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.tray_id = vt_tray;
select_index_info.ams_id = 255; // TODO: Orca hack select_index_info.ams_id = 255; // TODO: Orca hack
select_index_info.slot_id = 0; 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(); auto cali_select_id = m_comboBox_cali_result->GetSelection();
if (m_pa_profile_items.size() > 0 && cali_select_id >= 0) { 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.tray_id = cali_tray_id;
select_index_info.ams_id = ams_id; select_index_info.ams_id = ams_id;
select_index_info.slot_id = slot_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(); auto cali_select_id = m_comboBox_cali_result->GetSelection();
if (m_pa_profile_items.size() > 0 && cali_select_id > 0) { 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<std::string> filament_id_set; std::set<std::string> filament_id_set;
PresetBundle * preset_bundle = wxGetApp().preset_bundle; PresetBundle * preset_bundle = wxGetApp().preset_bundle;
std::ostringstream stream; 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::string nozzle_diameter_str = stream.str();
std::set<std::string> printer_names = preset_bundle->get_printer_names_by_printer_type_and_nozzle(MachineObject::get_preset_printer_model_name(obj->printer_type), nozzle_diameter_str); std::set<std::string> printer_names = preset_bundle->get_printer_names_by_printer_type_and_nozzle(MachineObject::get_preset_printer_model_name(obj->printer_type), nozzle_diameter_str);
@@ -1036,7 +1036,7 @@ void AMSMaterialsSetting::on_select_filament(wxCommandEvent &evt)
if (preset_bundle) { if (preset_bundle) {
std::ostringstream stream; std::ostringstream stream;
if (obj) 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::string nozzle_diameter_str = stream.str();
std::set<std::string> printer_names = preset_bundle->get_printer_names_by_printer_type_and_nozzle(MachineObject::get_preset_printer_model_name(obj->printer_type), std::set<std::string> printer_names = preset_bundle->get_printer_names_by_printer_type_and_nozzle(MachineObject::get_preset_printer_model_name(obj->printer_type),
nozzle_diameter_str); nozzle_diameter_str);
src/slic3r/GUI/AmsMappingPopup.cpp
+3 -1
View File
@@ -1407,7 +1407,9 @@ void AmsReplaceMaterialDialog::update_machine_obj(MachineObject* obj)
//creat group //creat group
int group_index = 0; 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); auto status_list = GetStatus(filam);
std::map<std::string, wxColour> group_info; std::map<std::string, wxColour> group_info;
src/slic3r/GUI/CaliHistoryDialog.cpp
+3 -3
View File
@@ -180,7 +180,7 @@ void HistoryWindow::on_device_connected(MachineObject* obj)
int selection = 1; int selection = 1;
for (int i = 0; i < nozzle_diameter_list.size(); i++) { for (int i = 0; i < nozzle_diameter_list.size(); i++) {
m_comboBox_nozzle_dia->AppendString(wxString::Format("%1.1f mm", nozzle_diameter_list[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; selection = i;
} }
} }
@@ -507,7 +507,7 @@ wxArrayString NewCalibrationHistoryDialog::get_all_filaments(const MachineObject
std::set<std::string> filament_id_set; std::set<std::string> filament_id_set;
std::set<std::string> printer_names; std::set<std::string> printer_names;
std::ostringstream stream; 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::string nozzle_diameter_str = stream.str();
for (auto printer_it = preset_bundle->printers.begin(); printer_it != preset_bundle->printers.end(); printer_it++) { 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<float, 4> nozzle_diameter_list = {0.2f, 0.4f, 0.6f, 0.8f}; static std::array<float, 4> nozzle_diameter_list = {0.2f, 0.4f, 0.6f, 0.8f};
for (int i = 0; i < nozzle_diameter_list.size(); i++) { for (int i = 0; i < nozzle_diameter_list.size(); i++) {
m_comboBox_nozzle_diameter->AppendString(wxString::Format("%1.1f mm", nozzle_diameter_list[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); m_comboBox_nozzle_diameter->SetSelection(i);
} }
} }
src/slic3r/GUI/CalibrationWizard.cpp
+1 -1
View File
@@ -497,7 +497,7 @@ void PressureAdvanceWizard::update(MachineObject* obj)
if (obj->cali_version != -1 && obj->cali_version != cali_version) { if (obj->cali_version != -1 && obj->cali_version != cali_version) {
cali_version = obj->cali_version; cali_version = obj->cali_version;
PACalibExtruderInfo cali_info; 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_extruder_id = false;
cali_info.use_nozzle_volume_type = false; cali_info.use_nozzle_volume_type = false;
CalibUtils::emit_get_PA_calib_infos(cali_info); CalibUtils::emit_get_PA_calib_infos(cali_info);
src/slic3r/GUI/CalibrationWizardCaliPage.cpp
+2 -2
View File
@@ -495,8 +495,8 @@ float CalibrationCaliPage::get_selected_calibration_nozzle_dia(MachineObject* ob
return obj->cali_selected_nozzle_dia; return obj->cali_selected_nozzle_dia;
// return default nozzle if nozzle diameter is set // 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) 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].diameter; return obj->m_extder_data.extders[0].current_nozzle_diameter;
// return 0.4 by default // return 0.4 by default
return 0.4; return 0.4;
src/slic3r/GUI/CalibrationWizardPresetPage.cpp
+1 -1
View File
@@ -1504,7 +1504,7 @@ void CalibrationPresetPage::init_with_machine(MachineObject* obj)
// set nozzle value from machine // set nozzle value from machine
bool nozzle_is_set = false; bool nozzle_is_set = false;
for (int i = 0; i < NOZZLE_LIST_COUNT; i++) { 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) { if (m_comboBox_nozzle_dia->GetCount() > i) {
m_comboBox_nozzle_dia->SetSelection(i); m_comboBox_nozzle_dia->SetSelection(i);
nozzle_is_set = true; nozzle_is_set = true;
src/slic3r/GUI/DeviceManager.cpp
+136 -42
View File
@@ -620,10 +620,13 @@ MachineObject::MachineObject(NetworkAgent* agent, std::string name, std::string
has_ipcam = true; // default true has_ipcam = true; // default true
m_extder_data.current_extder_id = 0; m_extder_data.current_extder_id = MAIN_NOZZLE_ID;
m_extder_data.target_extder_id = 0; m_extder_data.target_extder_id = MAIN_NOZZLE_ID;
m_extder_data.total_extder_count = 1; m_extder_data.total_extder_count = 1;
Extder nozzle; 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); 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<int>(); home_flag = jj["home_flag"].get<int>();
parse_status(home_flag); parse_status(home_flag);
} }
/*the param is invalid in np for Yeshu*/
if (jj.contains("hw_switch_state")) { if (jj.contains("hw_switch_state")) {
hw_switch_state = jj["hw_switch_state"].get<int>(); hw_switch_state = jj["hw_switch_state"].get<int>();
m_extder_data.extders[MAIN_NOZZLE_ID].ext_has_filament = hw_switch_state;
} }
if (jj.contains("mc_print_line_number")) { if (jj.contains("mc_print_line_number")) {
if (jj["mc_print_line_number"].is_string() && !jj["mc_print_line_number"].is_null()) 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.contains("nozzle_temper")) {
if (jj["nozzle_temper"].is_number()) { if (jj["nozzle_temper"].is_number()) {
if (m_extder_data.extders.size() == 1) { if (m_extder_data.extders.size() == 1) {
m_extder_data.extders[0].temp = jj["nozzle_temper"].get<float>(); m_extder_data.extders[MAIN_NOZZLE_ID].temp = jj["nozzle_temper"].get<float>();
} }
} }
} }
if (jj.contains("nozzle_target_temper")) { if (jj.contains("nozzle_target_temper")) {
if (jj["nozzle_target_temper"].is_number()) { if (jj["nozzle_target_temper"].is_number()) {
if (m_extder_data.extders.size() == 1) { if (m_extder_data.extders.size() == 1) {
m_extder_data.extders[0].target_temp = jj["nozzle_target_temper"].get<float>(); m_extder_data.extders[MAIN_NOZZLE_ID].target_temp = jj["nozzle_target_temper"].get<float>();
} }
} }
} }
@@ -3621,12 +3627,14 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
if (!key_field_only) { if (!key_field_only) {
/*get filam_bak*/ /*get filam_bak*/
try { try {
m_extder_data.extders[MAIN_NOZZLE_ID].filam_bak.clear();
if (jj.contains("filam_bak")) { if (jj.contains("filam_bak")) {
is_support_show_filament_backup = true; is_support_show_filament_backup = true;
filam_bak.clear();
if (jj["filam_bak"].is_array()) { if (jj["filam_bak"].is_array()) {
for (auto it = jj["filam_bak"].begin(); it != jj["filam_bak"].end(); it++) { for (auto it = jj["filam_bak"].begin(); it != jj["filam_bak"].end(); it++) {
filam_bak.push_back(it.value().get<int>()); const auto& filam_bak_val = it.value().get<int>();
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<std::string>()); nozzle_diameter = string_to_float(jj["nozzle_diameter"].get<std::string>());
} }
if (nozzle_diameter == 0.0f) {m_extder_data.extders[0].diameter = 0.4f;} if (nozzle_diameter == 0.0f) {m_extder_data.extders[MAIN_NOZZLE_ID].current_nozzle_diameter = 0.0f;}
else {m_extder_data.extders[0].diameter = round(nozzle_diameter * 10) / 10;} 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 { else {
if (jj["nozzle_type"].is_string()) { if (jj["nozzle_type"].is_string()) {
auto nozzle_type = jj["nozzle_type"].get<std::string>(); auto nozzle_type = jj["nozzle_type"].get<std::string>();
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,53 +5563,134 @@ void MachineObject::parse_new_info(json print)
} }
if (device.contains("nozzle")) { if (device.contains("nozzle")) {
json const& nozzle = device["nozzle"]; json const &nozzle = device["nozzle"];
m_extder_data = ExtderData(); m_nozzle_data = NozzleData();
m_extder_data.current_extder_id = get_flag_bits(nozzle["info"].get<int>(), 0, 3);
m_extder_data.target_extder_id = get_flag_bits(nozzle["info"].get<int>(), 4, 3); m_nozzle_data.extder_exist = get_flag_bits(nozzle["exist"].get<int>(), 0, 16);
m_extder_data.total_extder_count = get_flag_bits(nozzle["info"].get<int>(), 8, 3); m_nozzle_data.cut_exist = get_flag_bits(nozzle["exist"].get<int>(), 16, 16);
m_nozzle_data.state = get_flag_bits(nozzle["state"].get<int>(), 0, 4);
for (auto it = nozzle["info"].begin(); it != nozzle["info"].end(); it++) {
Nozzle nozzle_obj;
auto njon = it.value();
std::string type = njon["type"].get<std::string>();
nozzle_obj.id = njon["id"].get<int>();
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;
}
nozzle_obj.diameter = njon["diameter"].get<float>();
nozzle_obj.max_temp = njon["tm"].get<int>();
nozzle_obj.wear = njon["wear"].get<int>();
if (nozzle_obj.diameter == 0.0f) {nozzle_obj.diameter = 0.4f;}
m_nozzle_data.nozzles.push_back(nozzle_obj);
}
}
if (device.contains("extruder")) {
json const& extruder = device["extruder"];
auto extder_data = ExtderData();
extder_data.total_extder_count = get_flag_bits(extruder["state"].get<int>(), 0, 4);
for (int i = 0; i < m_extder_data.total_extder_count; i++) { extder_data.current_extder_id = get_flag_bits(extruder["state"].get<int>(), 4, 4);
extder_data.target_extder_id = get_flag_bits(extruder["state"].get<int>(), 8, 4);
Extder nozzle_obj; for (auto it = extruder["info"].begin(); it != extruder["info"].end(); it++) {
std::string nozzle_id = std::to_string(i); Extder extder_obj;
if (nozzle.contains(nozzle_id)) { auto njon = it.value();
auto njon = nozzle[nozzle_id].get<json>();
nozzle_obj.type = DeviceManager::nozzle_type_conver(get_flag_bits(njon["info"].get<int>(), 0, 2)); extder_obj.id = njon["id"].get<int>();
nozzle_obj.diameter = DeviceManager::nozzle_diameter_conver(get_flag_bits(njon["info"].get<int>(), 3, 3));
nozzle_obj.ext_has_filament = get_flag_bits(njon["info"].get<int>(), 7); extder_obj.filam_bak.clear();
nozzle_obj.buffer_has_filament = get_flag_bits(njon["info"].get<int>(), 8); is_support_show_filament_backup = njon.contains("filam_bak");
nozzle_obj.flow_type = get_flag_bits(njon["info"].get<int>(), 9, 2); if (is_support_show_filament_backup)
nozzle_obj.temp = get_flag_bits(njon["temp"].get<int>(), 0, 15); {
nozzle_obj.target_temp = get_flag_bits(njon["temp"].get<int>(), 16, 15); 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<int>();
extder_obj.filam_bak.emplace_back(filam_bak_val);
}
}
extder_obj.ext_has_filament = get_flag_bits(njon["info"].get<int>(), 1);
extder_obj.buffer_has_filament = get_flag_bits(njon["info"].get<int>(), 2);
extder_obj.nozzle_exist = get_flag_bits(njon["info"].get<int>(), 3);
extder_obj.temp = get_flag_bits(njon["temp"].get<int>(), 0, 16);
extder_obj.target_temp = get_flag_bits(njon["temp"].get<int>(), 16, 16);
AmsSlot spre; AmsSlot spre;
spre.ams_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 0, 8)); spre.slot_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 0, 8));
spre.slot_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 8, 8)); spre.ams_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 8, 8));
AmsSlot snow; AmsSlot snow;
snow.ams_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 0, 8)); snow.slot_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 0, 8));
snow.slot_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 8, 8)); snow.ams_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 8, 8));
AmsSlot star; AmsSlot star;
star.ams_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 0, 8)); star.slot_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 0, 8));
star.slot_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 8, 8)); star.ams_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 8, 8));
nozzle_obj.spre = spre; extder_obj.nozzle_id = njon["hnow"].get<int>();
nozzle_obj.snow = snow; extder_obj.target_nozzle_id = njon["htar"].get<int>();
nozzle_obj.star = star;
nozzle_obj.ams_stat = get_flag_bits(njon["stat"].get<int>(), 0, 15); extder_obj.spre = spre;
nozzle_obj.rfid_stat = get_flag_bits(njon["stat"].get<int>(), 16, 7); extder_obj.snow = snow;
extder_obj.star = star;
extder_obj.ams_stat = get_flag_bits(njon["stat"].get<int>(), 0, 16);
extder_obj.rfid_stat = get_flag_bits(njon["stat"].get<int>(), 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);
} }
m_extder_data.extders.push_back(nozzle_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 int MachineObject::get_flag_bits(std::string str, int start, int count) const
@@ -5705,7 +5799,7 @@ void MachineObject::update_printer_preset_name()
auto printer_model = MachineObject::get_preset_printer_model_name(this->printer_type); auto printer_model = MachineObject::get_preset_printer_model_name(this->printer_type);
std::set<std::string> diameter_set; std::set<std::string> diameter_set;
for (auto &nozzle : m_extder_data.extders) { for (auto &nozzle : m_extder_data.extders) {
float diameter = nozzle.diameter; float diameter = nozzle.current_nozzle_diameter;
std::ostringstream stream; std::ostringstream stream;
stream << std::fixed << std::setprecision(1) << diameter; stream << std::fixed << std::setprecision(1) << diameter;
std::string nozzle_diameter_str = stream.str(); 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()) { if (ams->nozzle < 0 || ams->nozzle >= m_extder_data.extders.size()) {
return; 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(); std::string nozzle_diameter_str = stream.str();
assert(nozzle_diameter_str.size() == 3); assert(nozzle_diameter_str.size() == 3);
if (m_nozzle_filament_data.find(nozzle_diameter_str) == m_nozzle_filament_data.end()) { 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; 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; continue;
} }
auto diameter = m_extder_data.extders[index].diameter; auto diameter = m_extder_data.extders[index].current_nozzle_diameter;
std::ostringstream stream; std::ostringstream stream;
stream << std::fixed << std::setprecision(1) << diameter; stream << std::fixed << std::setprecision(1) << diameter;
std::string nozzle_diameter_str = stream.str(); std::string nozzle_diameter_str = stream.str();
@@ -5840,7 +5934,7 @@ void MachineObject::check_ams_filament_valid()
std::string preset_setting_id; std::string preset_setting_id;
PresetBundle * preset_bundle = Slic3r::GUI::wxGetApp().preset_bundle; PresetBundle * preset_bundle = Slic3r::GUI::wxGetApp().preset_bundle;
std::ostringstream stream; 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(); 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( 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), this->printer_type),
src/slic3r/GUI/DeviceManager.hpp
+46 -17
View File
@@ -145,22 +145,49 @@ struct AmsSlot
std::string slot_id; 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<Nozzle> nozzles;
};
struct Extder struct Extder
{ {
std::string type; //0-hardened_steel 1-stainless_steel int id; // 0-right 1-left
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 ext_has_filament{0}; int ext_has_filament{0};
int buffer_has_filament{0}; int buffer_has_filament{0};
int flow_type{0};//0-common 1-high flow int nozzle_exist{0};
std::vector<int> filam_bak;// the refill filam
int temp{0}; int temp{0};
int target_temp{0}; int target_temp{0};
AmsSlot spre; //tray_pre
AmsSlot snow; //tray_now AmsSlot spre; // tray_pre
AmsSlot star; //tray_tar AmsSlot snow; // tray_now
int ams_stat{0}; ; AmsSlot star; // tray_tar
int rfid_stat{0}; ; 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 struct ExtderData
@@ -266,9 +293,11 @@ public:
#define INVALID_AMS_TEMPERATURE std::numeric_limits<float>::min() #define INVALID_AMS_TEMPERATURE std::numeric_limits<float>::min()
class Ams { class Ams
{
public: public:
Ams(std::string ams_id, int nozzle_id, int type_id) { Ams(std::string ams_id, int nozzle_id, int type_id)
{
id = ams_id; id = ams_id;
nozzle = nozzle_id; nozzle = nozzle_id;
type = type_id; type = type_id;
@@ -276,15 +305,15 @@ public:
std::string id; std::string id;
int left_dry_time = 0; int left_dry_time = 0;
int humidity = 5; int humidity = 5;
int humidity_raw = -1;// the percentage, -1 means invalid. eg. 100 means 100% int humidity_raw = -1; // the percentage, -1 means invalid. eg. 100 means 100%
float current_temperature = INVALID_AMS_TEMPERATURE; // the temperature float current_temperature = INVALID_AMS_TEMPERATURE; // the temperature
bool startup_read_opt{true}; bool startup_read_opt{true};
bool tray_read_opt{false}; bool tray_read_opt{false};
bool is_exists{false}; bool is_exists{false};
std::map<std::string, AmsTray*> trayList; std::map<std::string, AmsTray *> trayList;
int nozzle; int nozzle;
int type{1}; //0:dummy 1:ams 2:ams-lite 3:n3f 4:n3s int type{1}; // 0:dummy 1:ams 2:ams-lite 3:n3f 4:n3s
}; };
enum PrinterFirmwareType { enum PrinterFirmwareType {
@@ -380,6 +409,7 @@ private:
// type, time stamp, delay // type, time stamp, delay
std::vector<std::tuple<std::string, uint64_t, uint64_t>> message_delay; std::vector<std::tuple<std::string, uint64_t, uint64_t>> message_delay;
public: public:
enum LIGHT_EFFECT { enum LIGHT_EFFECT {
@@ -507,9 +537,6 @@ public:
std::string product_name; // set by iot service, get /user/print std::string product_name; // set by iot service, get /user/print
std::vector<int> filam_bak;
std::string bind_user_name; std::string bind_user_name;
std::string bind_user_id; std::string bind_user_id;
std::string bind_state; /* free | occupied */ std::string bind_state; /* free | occupied */
@@ -1045,6 +1072,7 @@ public:
bool is_enable_ams_np{ false }; bool is_enable_ams_np{ false };
ExtderData m_extder_data; ExtderData m_extder_data;
NozzleData m_nozzle_data;
/*vi slot data*/ /*vi slot data*/
AmsTray vt_tray; // virtual tray AmsTray vt_tray; // virtual tray
@@ -1053,6 +1081,7 @@ public:
/*for parse new info*/ /*for parse new info*/
bool check_enable_np(const json& print) const; bool check_enable_np(const json& print) const;
void parse_new_info(json print); 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(std::string str, int start, int count = 1) const;
int get_flag_bits(int num, int start, int count = 1, int base = 10) const; int get_flag_bits(int num, int start, int count = 1, int base = 10) const;
src/slic3r/GUI/PrintOptionsDialog.cpp
+77 -80
View File
@@ -439,8 +439,11 @@ bool PrintOptionsDialog::Show(bool show)
PrinterPartsDialog::PrinterPartsDialog(wxWindow* parent) PrinterPartsDialog::PrinterPartsDialog(wxWindow* parent)
: DPIDialog(parent, wxID_ANY, _L("Printer Parts"), wxDefaultPosition, wxDefaultSize, wxCAPTION | wxCLOSE_BOX) : DPIDialog(parent, wxID_ANY, _L("Printer Parts"), wxDefaultPosition, wxDefaultSize, wxCAPTION | wxCLOSE_BOX)
{ {
nozzle_type_map[0] = "hardened_steel"; nozzle_type_map[NozzleType::ntHardenedSteel] = _L("Hardened Steel");
nozzle_type_map[1] = "stainless_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[0] = 0.2;
nozzle_stainless_diameter_map[1] = 0.4; nozzle_stainless_diameter_map[1] = 0.4;
@@ -466,9 +469,12 @@ PrinterPartsDialog::PrinterPartsDialog(wxWindow* parent)
nozzle_type->SetForegroundColour(STATIC_TEXT_CAPTION_COL); nozzle_type->SetForegroundColour(STATIC_TEXT_CAPTION_COL);
nozzle_type->Wrap(-1); 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 = 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(nozzle_type_map[NozzleType::ntHardenedSteel]);
nozzle_type_checkbox->Append(_L("Hardened Steel")); nozzle_type_checkbox->Append(nozzle_type_map[NozzleType::ntStainlessSteel]);
nozzle_type_checkbox->SetSelection(0); nozzle_type_checkbox->SetSelection(0);
@@ -500,65 +506,76 @@ PrinterPartsDialog::PrinterPartsDialog(wxWindow* parent)
sizer->Add(line_sizer_nozzle_diameter, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(18)); sizer->Add(line_sizer_nozzle_diameter, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(18));
sizer->Add(0, 0, 0, wxTOP, FromDIP(24)); 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); SetSizer(sizer);
Layout(); Layout();
Fit(); Fit();
wxGetApp().UpdateDlgDarkUI(this); 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() PrinterPartsDialog::~PrinterPartsDialog()
{ {
nozzle_type_checkbox->Disconnect(wxEVT_COMBOBOX, wxCommandEventHandler(PrinterPartsDialog::set_nozzle_type), 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_diameter), 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) { int nozzle_id = MAIN_NOZZLE_ID;
return;
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<int, float> diameter_list;
if (type == "hardened_steel") {
diameter_list = nozzle_hard_diameter_map;
}
else if (type == "stainless_steel") {
diameter_list = nozzle_stainless_diameter_map;
}
nozzle_diameter_checkbox->Clear();
for (int i = 0; i < diameter_list.size(); i++)
{
nozzle_diameter_checkbox->Append(wxString::Format("%.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) { if (obj) {
try try {
{ auto nozzle_type = NozzleType::ntHardenedSteel;
auto nozzle_type = nozzle_type_map[nozzle_type_checkbox->GetSelection()]; auto nozzle_diameter = 0.4f;
auto nozzle_diameter = std::stof(nozzle_diameter_checkbox->GetStringSelection().ToStdString());
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<int, float> 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; nozzle_diameter = round(nozzle_diameter * 10) / 10;
obj->m_extder_data.extders[0].diameter = nozzle_diameter; /*if (!obj->is_enable_np)*/ {
obj->m_extder_data.extders[0].type = nozzle_type; 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->command_set_printer_nozzle(nozzle_type, nozzle_diameter); 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 (...) {} } catch (...) {}
} }
} }
@@ -578,51 +595,31 @@ bool PrinterPartsDialog::Show(bool show)
wxGetApp().UpdateDlgDarkUI(this); wxGetApp().UpdateDlgDarkUI(this);
CentreOnParent(); 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(); nozzle_diameter_checkbox->Clear();
if (type.empty()) { if (type == NozzleType::ntUndefine) {
nozzle_type_checkbox->SetValue(wxEmptyString); nozzle_type_checkbox->SetValue(wxEmptyString);
nozzle_diameter_checkbox->SetValue(wxEmptyString); nozzle_diameter_checkbox->SetValue(wxEmptyString);
} else {
nozzle_type_checkbox->Disable(); std::map<int, float> diameter_map;
nozzle_diameter_checkbox->Disable(); if (type == NozzleType::ntHardenedSteel) {
return DPIDialog::Show(show); diameter_map = nozzle_hard_diameter_map;
} } else if (type == NozzleType::ntStainlessSteel) {
else { diameter_map = nozzle_stainless_diameter_map;
nozzle_type_checkbox->Enable();
nozzle_diameter_checkbox->Enable();
} }
last_nozzle_type = type; for (int i = 0; i < diameter_map.size(); i++) {
nozzle_diameter_checkbox->Append(wxString::Format(_L("%.1f"), diameter_map[i]));
for (int i=0; i < nozzle_type_map.size(); i++) if (diameter == diameter_map[i]) {
{
nozzle_type_checkbox->Append( nozzle_type_map[i] );
if (nozzle_type_map[i] == type) {
nozzle_type_checkbox->SetSelection(i);
}
}
std::map<int, float> diameter_list;
if (type == "hardened_steel") {
diameter_list = nozzle_hard_diameter_map;
}
else if (type == "stainless_steel") {
diameter_list = nozzle_stainless_diameter_map;
}
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); nozzle_diameter_checkbox->SetSelection(i);
} }
} }
nozzle_type_checkbox->SetSelection(nozzle_type_selection_map[type]);
}
} }
return DPIDialog::Show(show); return DPIDialog::Show(show);
} }
src/slic3r/GUI/PrintOptionsDialog.hpp
+7 -3
View File
@@ -21,18 +21,22 @@ namespace Slic3r { namespace GUI {
class PrinterPartsDialog : public DPIDialog class PrinterPartsDialog : public DPIDialog
{ {
protected: protected:
wxWindowID ID_NOZZLE_TYPE_CHECKBOX_SINGLE;
wxWindowID ID_NOZZLE_DIAMETER_CHECKBOX_SINGLE;
MachineObject* obj{ nullptr }; MachineObject* obj{ nullptr };
ComboBox* nozzle_type_checkbox; ComboBox* nozzle_type_checkbox;
ComboBox* nozzle_diameter_checkbox; ComboBox* nozzle_diameter_checkbox;
std::string last_nozzle_type; std::string last_nozzle_type;
std::map<int, std::string> nozzle_type_map; std::map<NozzleType, wxString> nozzle_type_map;
std::map<NozzleType, int> nozzle_type_selection_map;
std::map<int, float> nozzle_stainless_diameter_map; std::map<int, float> nozzle_stainless_diameter_map;
std::map<int, float> nozzle_hard_diameter_map; std::map<int, float> nozzle_hard_diameter_map;
public: public:
PrinterPartsDialog(wxWindow* parent); PrinterPartsDialog(wxWindow* parent);
~PrinterPartsDialog(); ~PrinterPartsDialog();
void set_nozzle_type(wxCommandEvent& evt); void set_nozzle_data(wxCommandEvent& evt);
void set_nozzle_diameter(wxCommandEvent& evt);
void on_dpi_changed(const wxRect& suggested_rect) override; void on_dpi_changed(const wxRect& suggested_rect) override;
void update_machine_obj(MachineObject* obj_); void update_machine_obj(MachineObject* obj_);
bool Show(bool show) override; bool Show(bool show) override;
src/slic3r/GUI/SelectMachine.cpp
+43 -76
View File
@@ -2481,81 +2481,52 @@ bool SelectMachineDialog::is_blocking_printing(MachineObject* obj_)
return false; 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(); DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
if (!dev) return true; if (!dev) return false;
MachineObject* obj_ = dev->get_selected_machine(); 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<ConfigOptionFloats>("nozzle_diameter");
if (!opt_nozzle_diameters)
{
return false;
}
try try
{ {
PresetBundle* preset_bundle = wxGetApp().preset_bundle;
auto opt_nozzle_diameters = preset_bundle->printers.get_edited_preset().config.option<ConfigOptionFloats>("nozzle_diameter");
const ConfigOptionEnum<NozzleType>* nozzle_type = preset_bundle->printers.get_edited_preset().config.option<ConfigOptionEnum<NozzleType>>("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(); 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++) { for (auto i = 0; i < extruders.size(); i++) {
auto extruder = extruders[i] - 1; auto extruder = extruders[i] - 1;
preset_nozzle_diameters = float(opt_nozzle_diameters->get_at(extruder)); tag_nozzle_diameter = float(opt_nozzle_diameters->get_at(extruder));
if (preset_nozzle_diameters != obj_->m_extder_data.extders[0].diameter) { if (tag_nozzle_diameter != obj_->m_extder_data.extders[0].current_nozzle_diameter) {
is_same_nozzle_diameters = false; return false;
} }
} }
} }
catch (const std::exception&)
}
catch (...)
{ {
return false;
} }
//nozzle_type = preset_nozzle_type; return true;
nozzle_diameter = wxString::Format("%.2f", preset_nozzle_diameters).ToStdString();
return is_same_nozzle_diameters;
} }
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; auto printer_nozzle_hrc = Print::get_hrc_by_nozzle_type(extruder.current_nozzle_type);
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 preset_bundle = wxGetApp().preset_bundle; auto preset_bundle = wxGetApp().preset_bundle;
MaterialHash::iterator iter = m_materialList.begin(); MaterialHash::const_iterator iter = m_materialList.begin();
while (iter != m_materialList.end()) { while (iter != m_materialList.end()) {
Material* item = iter->second; Material* item = iter->second;
MaterialItem* m = item->item; 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)) { if (abs(filament_nozzle_hrc) > abs(printer_nozzle_hrc)) {
filament_type = m->m_material_name.ToStdString(); filament_type = m->m_material_name.ToStdString();
BOOST_LOG_TRIVIAL(info) << "filaments hardness mismatch: filament = " << filament_type << " printer_nozzle_hrc = " << printer_nozzle_hrc; BOOST_LOG_TRIVIAL(info) << "filaments hardness mismatch: filament = " << filament_type << " printer_nozzle_hrc = " << printer_nozzle_hrc;
is_same_nozzle_type = false; return 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);
} }
iter++; iter++;
} }
return is_same_nozzle_type; return true;
} }
bool SelectMachineDialog::is_same_printer_model() 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."))); 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; if (!obj_->m_extder_data.extders[0].current_nozzle_type != ntUndefine && (m_print_type == PrintFromType::FROM_NORMAL))
std::string filament_type; {
std::string tag_nozzle_type; float nozzle_diameter = 0;
if (!is_same_nozzle_diameters(nozzle_diameter))
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)) {
has_slice_warnings = true; has_slice_warnings = true;
// is_printing_block = true; # Removed to allow nozzle overrides (to support non-standard nozzles) // 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_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].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.") 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 + "\n " + nozzle_in_preset
@@ -2776,12 +2741,13 @@ void SelectMachineDialog::on_ok_btn(wxCommandEvent &event)
+ "\n", ConfirmBeforeSendInfo::InfoLevel::Warning)); + "\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; has_slice_warnings = true;
is_printing_block = 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)); 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"); return _L("Hardened Steel");
} }
else if (name == "stainless_steel") { else if (type == NozzleType::ntStainlessSteel) {
return _L("Stainless Steel"); return _L("Stainless Steel");
} }
return wxEmptyString; return _L("Unknown");
} }
void SelectMachineDialog::Enable_Auto_Refill(bool enable) void SelectMachineDialog::Enable_Auto_Refill(bool enable)
{ {
if (enable) { if (enable) {
src/slic3r/GUI/SelectMachine.hpp
+3 -3
View File
@@ -542,8 +542,8 @@ public:
void update_timelapse_enable_status(); void update_timelapse_enable_status();
bool is_same_printer_model(); bool is_same_printer_model();
bool is_blocking_printing(MachineObject* obj_); bool is_blocking_printing(MachineObject* obj_);
bool is_same_nozzle_diameters(std::string& tag_nozzle_type, std::string& nozzle_diameter); bool is_same_nozzle_diameters(float& tag_nozzle_diameter) const;
bool is_same_nozzle_type(std::string& filament_type, std::string& tag_nozzle_type); bool is_same_nozzle_type(const Extder& extruder, std::string& filament_type) const;
bool has_tips(MachineObject* obj); bool has_tips(MachineObject* obj);
bool is_timeout(); 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); 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); bool build_nozzles_info(std::string& nozzles_info);
PrintFromType get_print_type() {return m_print_type;}; 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); wxString format_text(wxString &m_msg);
wxWindow* create_ams_checkbox(wxString title, wxWindow* parent, wxString tooltip); wxWindow* create_ams_checkbox(wxString title, wxWindow* parent, wxString tooltip);
wxWindow* create_item_checkbox(wxString title, wxWindow* parent, wxString tooltip, std::string param); wxWindow* create_item_checkbox(wxString title, wxWindow* parent, wxString tooltip, std::string param);
src/slic3r/GUI/StatusPanel.cpp
+1 -1
View File
@@ -2587,7 +2587,7 @@ void StatusPanel::update_ams(MachineObject *obj)
if (obj->cali_version != -1 && last_cali_version != obj->cali_version) { if (obj->cali_version != -1 && last_cali_version != obj->cali_version) {
last_cali_version = obj->cali_version; last_cali_version = obj->cali_version;
PACalibExtruderInfo cali_info; 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_extruder_id = false;
cali_info.use_nozzle_volume_type = false; cali_info.use_nozzle_volume_type = false;
CalibUtils::emit_get_PA_calib_infos(cali_info); CalibUtils::emit_get_PA_calib_infos(cali_info);
src/slic3r/Utils/CalibUtils.cpp
+7 -17
View File
@@ -98,18 +98,14 @@ static bool is_same_nozzle_diameters(const DynamicPrintConfig &full_config, cons
try { try {
std::string nozzle_type; std::string nozzle_type;
const ConfigOptionEnum<NozzleType> * config_nozzle_type = full_config.option<ConfigOptionEnum<NozzleType>>("nozzle_type"); const ConfigOptionEnum<NozzleType> * config_nozzle_type = full_config.option<ConfigOptionEnum<NozzleType>>("nozzle_type");
if (config_nozzle_type->value == NozzleType::ntHardenedSteel) { nozzle_type = NozzleTypeEumnToStr[config_nozzle_type->value];
nozzle_type = "hardened_steel";
} else if (config_nozzle_type->value == NozzleType::ntStainlessSteel) {
nozzle_type = "stainless_steel";
}
auto opt_nozzle_diameters = full_config.option<ConfigOptionFloats>("nozzle_diameter"); auto opt_nozzle_diameters = full_config.option<ConfigOptionFloats>("nozzle_diameter");
if (opt_nozzle_diameters != nullptr) { if (opt_nozzle_diameters != nullptr) {
float preset_nozzle_diameter = opt_nozzle_diameters->get_at(0); 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_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 + 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"; "\n " + nozzle_in_printer + "\n";
@@ -127,21 +123,15 @@ static bool is_same_nozzle_type(const DynamicPrintConfig &full_config, const Mac
if (obj == nullptr) if (obj == nullptr)
return true; return true;
NozzleType nozzle_type = NozzleType::ntUndefine; NozzleType nozzle_type = obj->m_extder_data.extders[0].current_nozzle_type;
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;
}
int printer_nozzle_hrc = Print::get_hrc_by_nozzle_type(nozzle_type); int printer_nozzle_hrc = Print::get_hrc_by_nozzle_type(nozzle_type);
if (full_config.has("required_nozzle_HRC")) { if (full_config.has("required_nozzle_HRC")) {
int filament_nozzle_hrc = full_config.opt_int("required_nozzle_HRC", 0); int filament_nozzle_hrc = full_config.opt_int("required_nozzle_HRC", 0);
if (abs(filament_nozzle_hrc) > abs(printer_nozzle_hrc)) { 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; 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); 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"; error_msg += "\n";
MessageDialog msg_dlg(nullptr, error_msg, wxEmptyString, wxICON_WARNING | wxOK | wxCANCEL); 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 // 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; return true;
if (!is_same_nozzle_diameters(full_config, obj, error_msg)) if (!is_same_nozzle_diameters(full_config, obj, error_msg))