viewit/OrcaSlicer-KX
5
1
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases 7 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

7
src/libslic3r/PrintConfig.hpp
View File

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

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

@@ -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<std::string> filament_id_set;
PresetBundle * preset_bundle = wxGetApp().preset_bundle;
std::ostringstream stream;
stream << std::fixed << std::setprecision(1) << obj->m_extder_data.extders[0].diameter;
stream << std::fixed << std::setprecision(1) << obj->m_extder_data.extders[0].current_nozzle_diameter;
std::string nozzle_diameter_str = stream.str();
std::set<std::string> printer_names = preset_bundle->get_printer_names_by_printer_type_and_nozzle(MachineObject::get_preset_printer_model_name(obj->printer_type), nozzle_diameter_str);
@@ -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<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);

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

@@ -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<std::string, wxColour> group_info;

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

@@ -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<std::string> filament_id_set;
std::set<std::string> printer_names;
std::ostringstream stream;
stream << std::fixed << std::setprecision(1) << obj->m_extder_data.extders[0].diameter;
stream << std::fixed << std::setprecision(1) << obj->m_extder_data.extders[0].current_nozzle_diameter;
std::string nozzle_diameter_str = stream.str();
for (auto printer_it = preset_bundle->printers.begin(); printer_it != preset_bundle->printers.end(); printer_it++) {
@@ -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};
for (int i = 0; i < nozzle_diameter_list.size(); i++) {
m_comboBox_nozzle_diameter->AppendString(wxString::Format("%1.1f mm", nozzle_diameter_list[i]));
if (abs(obj->m_extder_data.extders[0].diameter - nozzle_diameter_list[i]) < 1e-3) {
if (abs(obj->m_extder_data.extders[0].current_nozzle_diameter - nozzle_diameter_list[i]) < 1e-3) {
m_comboBox_nozzle_diameter->SetSelection(i);
}
}

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

@@ -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);

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

@@ -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;

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

@@ -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;

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

@@ -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<int>();
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<int>();
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<float>();
m_extder_data.extders[MAIN_NOZZLE_ID].temp = jj["nozzle_temper"].get<float>();
}
}
}
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<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) {
/*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<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>());
}
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<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,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<int>(), 0, 3);
m_extder_data.target_extder_id = get_flag_bits(nozzle["info"].get<int>(), 4, 3);
m_extder_data.total_extder_count = get_flag_bits(nozzle["info"].get<int>(), 8, 3);
m_nozzle_data = NozzleData();
m_nozzle_data.extder_exist = get_flag_bits(nozzle["exist"].get<int>(), 0, 16);
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 (int i = 0; i < m_extder_data.total_extder_count; i++) {
for (auto it = nozzle["info"].begin(); it != nozzle["info"].end(); it++) {
Nozzle nozzle_obj;
auto njon = it.value();
std::string type = njon["type"].get<std::string>();
nozzle_obj.id = njon["id"].get<int>();
Extder nozzle_obj;
std::string nozzle_id = std::to_string(i);
if (nozzle.contains(nozzle_id)) {
auto njon = nozzle[nozzle_id].get<json>();
nozzle_obj.type = DeviceManager::nozzle_type_conver(get_flag_bits(njon["info"].get<int>(), 0, 2));
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);
nozzle_obj.buffer_has_filament = get_flag_bits(njon["info"].get<int>(), 8);
nozzle_obj.flow_type = get_flag_bits(njon["info"].get<int>(), 9, 2);
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);
AmsSlot spre;
spre.ams_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 0, 8));
spre.slot_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 8, 8));
AmsSlot snow;
snow.ams_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 0, 8));
snow.slot_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 8, 8));
AmsSlot star;
star.ams_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 0, 8));
star.slot_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 8, 8));
nozzle_obj.spre = spre;
nozzle_obj.snow = snow;
nozzle_obj.star = star;
nozzle_obj.ams_stat = get_flag_bits(njon["stat"].get<int>(), 0, 15);
nozzle_obj.rfid_stat = get_flag_bits(njon["stat"].get<int>(), 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<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);
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);
for (auto it = extruder["info"].begin(); it != extruder["info"].end(); it++) {
Extder extder_obj;
auto njon = it.value();
extder_obj.id = njon["id"].get<int>();
extder_obj.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<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;
spre.slot_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 0, 8));
spre.ams_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 8, 8));
AmsSlot snow;
snow.slot_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 0, 8));
snow.ams_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 8, 8));
AmsSlot star;
star.slot_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 0, 8));
star.ams_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 8, 8));
extder_obj.nozzle_id = njon["hnow"].get<int>();
extder_obj.target_nozzle_id = njon["htar"].get<int>();
extder_obj.spre = spre;
extder_obj.snow = snow;
extder_obj.star = star;
extder_obj.ams_stat = get_flag_bits(njon["stat"].get<int>(), 0, 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);
}
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<std::string> diameter_set;
for (auto &nozzle : m_extder_data.extders) {
float diameter = nozzle.diameter;
float diameter = nozzle.current_nozzle_diameter;
std::ostringstream stream;
stream << std::fixed << std::setprecision(1) << diameter;
std::string nozzle_diameter_str = stream.str();
@@ -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),

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

@@ -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<Nozzle> nozzles;
};
struct Extder
{
std::string type; //0-hardened_steel 1-stainless_steel
float diameter = {0.4f}; // 0-0.2mm 1-0.4mm 2-0.6 mm3-0.8mm
int exist{0}; //0-Not Installed 1-Wrong extruder 2-No enablement 3-Enable
int id; // 0-right 1-left
int 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<int> 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<float>::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<std::string, AmsTray*> 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<std::string, AmsTray *> 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<std::tuple<std::string, uint64_t, uint64_t>> message_delay;
public:
enum LIGHT_EFFECT {
@@ -507,9 +537,6 @@ public:
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_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;

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

@@ -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<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) {
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<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;
/*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<int, float> 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<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);
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);

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

@@ -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<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_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;

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

@@ -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<ConfigOptionFloats>("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<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();
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) {

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

@@ -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);

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

@@ -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);

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

@@ -98,18 +98,14 @@ static bool is_same_nozzle_diameters(const DynamicPrintConfig &full_config, cons
try {
std::string nozzle_type;
const ConfigOptionEnum<NozzleType> * config_nozzle_type = full_config.option<ConfigOptionEnum<NozzleType>>("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<ConfigOptionFloats>("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))