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

NEW:support new ext slot mapping 

jira:[support new mapping]

Change-Id: Iaf88f7bd57177df772a926ad162bd3b5a141327a
This commit is contained in:
tao wang 2024-06-24 17:35:38 +08:00 committed by lane.wei
parent 260a7202fc
commit 3b93bd2dd3
12 changed files with 523 additions and 432 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -462,7 +462,7 @@ void AMSMaterialsSetting::on_select_reset(wxCommandEvent& event) {
if (obj) { if (obj) {
// set filament // set filament
if (is_virtual_tray()) { if (is_virtual_tray()) {
obj->command_ams_filament_settings(255, VIRTUAL_TRAY_ID, ams_filament_id, ams_setting_id, std::string(col_buf), m_filament_type, nozzle_temp_min_int, nozzle_temp_max_int); obj->command_ams_filament_settings(255, VIRTUAL_TRAY_MAIN_ID, ams_filament_id, ams_setting_id, std::string(col_buf), m_filament_type, nozzle_temp_min_int, nozzle_temp_max_int);
} }
else if(m_is_third){ else if(m_is_third){
obj->command_ams_filament_settings(ams_id, tray_id, ams_filament_id, ams_setting_id, std::string(col_buf), m_filament_type, nozzle_temp_min_int, nozzle_temp_max_int); obj->command_ams_filament_settings(ams_id, tray_id, ams_filament_id, ams_setting_id, std::string(col_buf), m_filament_type, nozzle_temp_min_int, nozzle_temp_max_int);
@ -576,7 +576,7 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
// set filament // set filament
if (m_is_third) { if (m_is_third) {
if (is_virtual_tray()) { if (is_virtual_tray()) {
obj->command_ams_filament_settings(255, VIRTUAL_TRAY_ID, ams_filament_id, ams_setting_id, std::string(col_buf), m_filament_type, nozzle_temp_min_int, nozzle_temp_max_int); obj->command_ams_filament_settings(255, VIRTUAL_TRAY_MAIN_ID, ams_filament_id, ams_setting_id, std::string(col_buf), m_filament_type, nozzle_temp_min_int, nozzle_temp_max_int);
} }
else { else {
obj->command_ams_filament_settings(ams_id, tray_id, ams_filament_id, ams_setting_id, std::string(col_buf), m_filament_type, nozzle_temp_min_int, nozzle_temp_max_int); obj->command_ams_filament_settings(ams_id, tray_id, ams_filament_id, ams_setting_id, std::string(col_buf), m_filament_type, nozzle_temp_min_int, nozzle_temp_max_int);
@ -630,7 +630,7 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
CalibUtils::select_PA_calib_result(select_index_info); CalibUtils::select_PA_calib_result(select_index_info);
} }
else { else {
obj->command_extrusion_cali_set(VIRTUAL_TRAY_ID, "", "", k, n); obj->command_extrusion_cali_set(VIRTUAL_TRAY_MAIN_ID, "", "", k, n);
} }
} }
else { else {
@ -741,7 +741,7 @@ void AMSMaterialsSetting::on_clr_picker(wxMouseEvent &event)
bool AMSMaterialsSetting::is_virtual_tray() bool AMSMaterialsSetting::is_virtual_tray()
{ {
if (tray_id == VIRTUAL_TRAY_ID) if (tray_id == VIRTUAL_TRAY_MAIN_ID)
return true; return true;
return false; return false;
} }
@ -1126,44 +1126,19 @@ void AMSMaterialsSetting::on_select_filament(wxCommandEvent &evt)
} }
m_comboBox_cali_result->Set(items); m_comboBox_cali_result->Set(items);
if (tray_id == VIRTUAL_TRAY_ID) { if (tray_id == VIRTUAL_TRAY_MAIN_ID) {
if (from_printer && (*from_printer == 1)) { cali_select_idx = CalibUtils::get_selected_calib_idx(m_pa_profile_items,this->obj->vt_slot[0].cali_idx);
AmsTray selected_tray = this->obj->vt_tray; if (cali_select_idx >= 0) {
cali_select_idx = CalibUtils::get_selected_calib_idx(m_pa_profile_items, selected_tray.cali_idx);
if (cali_select_idx >= 0) {
m_comboBox_cali_result->SetSelection(cali_select_idx);
} else {
m_comboBox_cali_result->SetSelection(0);
}
}
else {
#ifdef __APPLE__
cali_select_idx = get_cali_index(m_comboBox_filament->GetValue().ToStdString());
#else
cali_select_idx = get_cali_index(m_comboBox_filament->GetLabel().ToStdString());
#endif
m_comboBox_cali_result->SetSelection(cali_select_idx); m_comboBox_cali_result->SetSelection(cali_select_idx);
} }
} }
else { else {
if (from_printer && (*from_printer == 1)) { Ams* selected_ams = this->obj->amsList[std::to_string(ams_id)];
Ams *selected_ams = this->obj->amsList[std::to_string(ams_id)]; if(!selected_ams) return;
if (!selected_ams) return; AmsTray* selected_tray = selected_ams->trayList[std::to_string(tray_id)];
AmsTray *selected_tray = selected_ams->trayList[std::to_string(tray_id)]; if(!selected_tray) return;
if (!selected_tray) return; cali_select_idx = CalibUtils::get_selected_calib_idx(m_pa_profile_items, selected_tray->cali_idx);
cali_select_idx = CalibUtils::get_selected_calib_idx(m_pa_profile_items, selected_tray->cali_idx); if (cali_select_idx >= 0) {
if (cali_select_idx >= 0) {
m_comboBox_cali_result->SetSelection(cali_select_idx);
} else {
m_comboBox_cali_result->SetSelection(0);
}
}
else {
#ifdef __APPLE__
cali_select_idx = get_cali_index(m_comboBox_filament->GetValue().ToStdString());
#else
cali_select_idx = get_cali_index(m_comboBox_filament->GetLabel().ToStdString());
#endif
m_comboBox_cali_result->SetSelection(cali_select_idx); m_comboBox_cali_result->SetSelection(cali_select_idx);
} }
} }

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

@ -296,12 +296,15 @@ void MaterialItem::doRender(wxDC& dc)
Bind(wxEVT_LEFT_DOWN, &AmsMapingPopup::on_left_down, this); Bind(wxEVT_LEFT_DOWN, &AmsMapingPopup::on_left_down, this);
#endif #endif
SetBackgroundColour(*wxWHITE); SetBackgroundColour(*wxWHITE);
m_sizer_main = new wxBoxSizer(wxVERTICAL); m_sizer_main = new wxBoxSizer(wxVERTICAL);
m_sizer_ams = new wxBoxSizer(wxHORIZONTAL); m_sizer_ams = new wxBoxSizer(wxHORIZONTAL);
m_sizer_ams_left = new wxBoxSizer(wxVERTICAL); m_sizer_ams_left = new wxBoxSizer(wxVERTICAL);
m_sizer_ams_right = new wxBoxSizer(wxVERTICAL); m_sizer_ams_right = new wxBoxSizer(wxVERTICAL);
m_sizer_ams_basket_left = new wxBoxSizer(wxVERTICAL);
m_sizer_ams_basket_right = new wxBoxSizer(wxVERTICAL);
auto title_panel = new wxPanel(this, wxID_ANY); auto title_panel = new wxPanel(this, wxID_ANY);
@ -322,14 +325,45 @@ void MaterialItem::doRender(wxDC& dc)
title_panel->Layout(); title_panel->Layout();
title_panel->Fit(); title_panel->Fit();
auto left_ams_title_text = new wxStaticText(this, wxID_ANY, _L("Left Ams")); m_left_marea_panel = new wxPanel(this);
auto right_ams_title_text = new wxStaticText(this, wxID_ANY, _L("Right Ams")); m_right_marea_panel = new wxPanel(this);
m_sizer_ams_left->Add(left_ams_title_text, 0, wxALIGN_CENTER, 0);
m_sizer_ams_right->Add(right_ams_title_text, 0, wxALIGN_CENTER, 0); /*left ext*/
m_left_extra_slot = new MappingItem(m_left_marea_panel);
m_sizer_ams->Add(m_sizer_ams_left, 0, wxEXPAND | wxALL, FromDIP(0)); m_left_extra_slot->m_ams_id = VIRTUAL_TRAY_DEPUTY_ID;
m_sizer_ams->Add(m_sizer_ams_right, 0, wxEXPAND | wxALL, FromDIP(0)); m_left_extra_slot->m_slot_id = 0;
m_left_extra_slot->SetSize(wxSize(FromDIP(48), FromDIP(60)));
m_left_extra_slot->SetMinSize(wxSize(FromDIP(48), FromDIP(60)));
m_left_extra_slot->SetMaxSize(wxSize(FromDIP(48), FromDIP(60)));
/*right ext*/
m_right_extra_slot = new MappingItem(m_right_marea_panel);
m_right_extra_slot->m_ams_id = VIRTUAL_TRAY_MAIN_ID;
m_right_extra_slot->m_slot_id = 0;
m_right_extra_slot->SetSize(wxSize(FromDIP(48), FromDIP(60)));
m_right_extra_slot->SetMinSize(wxSize(FromDIP(48), FromDIP(60)));
m_right_extra_slot->SetMaxSize(wxSize(FromDIP(48), FromDIP(60)));
m_sizer_ams_left->Add(create_split_sizer(m_left_marea_panel, _L("Left Ams")), 0, wxEXPAND, 0);
m_sizer_ams_left->Add(m_sizer_ams_basket_left, 0, wxEXPAND|wxTOP, FromDIP(8));
m_sizer_ams_left->Add(create_split_sizer(m_left_marea_panel, _L("External")), 0, wxEXPAND|wxTOP, FromDIP(8));
m_sizer_ams_left->Add(m_left_extra_slot, 0, wxEXPAND|wxTOP, FromDIP(8));
m_sizer_ams_right->Add(create_split_sizer(m_right_marea_panel, _L("Right Ams")), 0, wxEXPAND, 0);
m_sizer_ams_right->Add(m_sizer_ams_basket_right, 0, wxEXPAND|wxTOP, FromDIP(8));
m_sizer_ams_right->Add(create_split_sizer(m_right_marea_panel, _L("External")), 0, wxEXPAND|wxTOP, FromDIP(8));
m_sizer_ams_right->Add(m_right_extra_slot, 0, wxEXPAND|wxTOP, FromDIP(8));
m_left_marea_panel->SetSizer(m_sizer_ams_left);
m_right_marea_panel->SetSizer(m_sizer_ams_right);
m_sizer_ams->Add(m_left_marea_panel, 0, wxEXPAND, FromDIP(0));
m_sizer_ams->Add(0, 0, 0, wxEXPAND, FromDIP(15));
m_sizer_ams->Add(m_right_marea_panel, 0, wxEXPAND, FromDIP(0));
m_warning_text = new wxStaticText(this, wxID_ANY, wxEmptyString); m_warning_text = new wxStaticText(this, wxID_ANY, wxEmptyString);
@ -341,7 +375,7 @@ void MaterialItem::doRender(wxDC& dc)
m_warning_text->Wrap(FromDIP(248)); m_warning_text->Wrap(FromDIP(248));
m_sizer_main->Add(title_panel, 0, wxEXPAND | wxALL, FromDIP(2)); m_sizer_main->Add(title_panel, 0, wxEXPAND | wxALL, FromDIP(2));
m_sizer_main->Add(m_sizer_ams, 0, wxEXPAND | wxALL, FromDIP(2)); m_sizer_main->Add(m_sizer_ams, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(14));
m_sizer_main->Add(m_warning_text, 0, wxEXPAND | wxALL, FromDIP(6)); m_sizer_main->Add(m_warning_text, 0, wxEXPAND | wxALL, FromDIP(6));
SetSizer(m_sizer_main); SetSizer(m_sizer_main);
@ -357,6 +391,22 @@ void MaterialItem::doRender(wxDC& dc)
}); });
} }
wxBoxSizer* AmsMapingPopup::create_split_sizer(wxWindow* parent, wxString text)
{
wxBoxSizer* sizer_split_left_ams = new wxBoxSizer(wxHORIZONTAL);
auto left_ams_title_text = new Label(parent, text);
left_ams_title_text->SetFont(::Label::Body_13);
left_ams_title_text->SetForegroundColour(0x909090);
auto m_split_left_line = new wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
m_split_left_line->SetBackgroundColour(0xeeeeee);
m_split_left_line->SetMinSize(wxSize(-1, 1));
m_split_left_line->SetMaxSize(wxSize(-1, 1));
sizer_split_left_ams->Add(0, 0, 0, wxEXPAND, 0);
sizer_split_left_ams->Add(left_ams_title_text, 0, wxALIGN_CENTER, 0);
sizer_split_left_ams->Add(m_split_left_line, 1, wxALIGN_CENTER_VERTICAL, 0);
return sizer_split_left_ams;
}
wxString AmsMapingPopup::format_text(wxString &m_msg) wxString AmsMapingPopup::format_text(wxString &m_msg)
{ {
if (wxGetApp().app_config->get("language") != "zh_CN") { return m_msg; } if (wxGetApp().app_config->get("language") != "zh_CN") { return m_msg; }
@ -452,12 +502,14 @@ void AmsMapingPopup::update_ams_data_multi_machines()
Fit(); Fit();
} }
void AmsMapingPopup::update_ams_data(std::map<std::string, Ams*> amsList) void AmsMapingPopup::update(MachineObject* obj)
{ {
std::map<std::string, Ams *>::iterator ams_iter; BOOST_LOG_TRIVIAL(info) << "ams_mapping nozzle count " << obj->m_np_nozzle_data.nozzle.size();
BOOST_LOG_TRIVIAL(trace) << "ams_mapping total count " << amsList.size(); BOOST_LOG_TRIVIAL(info) << "ams_mapping total count " << obj->amsList.size();
if (!obj) {return;}
for (auto& ams_container : m_amsmapping_container_list) { for (auto& ams_container : m_amsmapping_container_list) {
ams_container->Destroy(); ams_container->Destroy();
} }
@ -466,7 +518,57 @@ void AmsMapingPopup::update_ams_data(std::map<std::string, Ams*> amsList)
m_amsmapping_container_sizer_list.clear(); m_amsmapping_container_sizer_list.clear();
m_mapping_item_list.clear(); m_mapping_item_list.clear();
for (ams_iter = amsList.begin(); ams_iter != amsList.end(); ams_iter++) { /*ext*/
if (obj->vt_slot.size() == 1) {
m_left_marea_panel->Hide();
m_right_extra_slot->Hide();
}
else if (obj->vt_slot.size() > 1) {
m_left_marea_panel->Show();
m_right_extra_slot->Show();
}
for (int i = 0; i < obj->vt_slot.size(); i++) {
AmsTray* tray_data = &obj->vt_slot[i];
TrayData td;
td.id = std::stoi(tray_data->id);
td.ams_id = std::stoi(tray_data->id);
td.slot_id = 0;
if (!tray_data->is_exists) {
td.type = EMPTY;
}
else {
if (!tray_data->is_tray_info_ready()) {
td.type = THIRD;
}
else {
td.type = NORMAL;
td.colour = AmsTray::decode_color(tray_data->color);
td.name = tray_data->get_display_filament_type();
td.filament_type = tray_data->get_filament_type();
td.ctype = tray_data->ctype;
for (auto col : tray_data->cols) {
td.material_cols.push_back(AmsTray::decode_color(col));
}
}
}
if (obj->vt_slot[i].id == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
m_right_extra_slot->send_win = send_win;
add_ext_ams_mapping(td, m_right_extra_slot);
}
else if (obj->vt_slot[i].id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
m_left_extra_slot->send_win = send_win;
add_ext_ams_mapping(td, m_left_extra_slot);
}
}
/*ams*/
for (std::map<std::string, Ams *>::iterator ams_iter = obj->amsList.begin(); ams_iter != obj->amsList.end(); ams_iter++) {
int ams_indx = atoi(ams_iter->first.c_str()); int ams_indx = atoi(ams_iter->first.c_str());
int ams_type = ams_iter->second->type; int ams_type = ams_iter->second->type;
@ -475,7 +577,7 @@ void AmsMapingPopup::update_ams_data(std::map<std::string, Ams*> amsList)
if (ams_type == 1) { if (ams_type == 1) {
auto sizer_mapping_list = new wxBoxSizer(wxHORIZONTAL); auto sizer_mapping_list = new wxBoxSizer(wxHORIZONTAL);
auto ams_mapping_item_container = new MappingContainer(this); auto ams_mapping_item_container = new MappingContainer(nozzle_id == 0? m_right_marea_panel:m_left_marea_panel);
ams_mapping_item_container->SetSizer(sizer_mapping_list); ams_mapping_item_container->SetSizer(sizer_mapping_list);
ams_mapping_item_container->Layout(); ams_mapping_item_container->Layout();
@ -491,7 +593,9 @@ void AmsMapingPopup::update_ams_data(std::map<std::string, Ams*> amsList)
AmsTray* tray_data = tray_iter->second; AmsTray* tray_data = tray_iter->second;
TrayData td; TrayData td;
td.id = ams_indx * AMS_TOTAL_COUNT + atoi(tray_data->id.c_str()); td.id = ams_indx * AMS_TOTAL_COUNT + atoi(tray_data->id.c_str());
td.ams_id = std::stoi(ams_iter->second->id);
td.slot_id = std::stoi(tray_iter->second->id);
if (!tray_data->is_exists) { if (!tray_data->is_exists) {
td.type = EMPTY; td.type = EMPTY;
@ -510,9 +614,6 @@ void AmsMapingPopup::update_ams_data(std::map<std::string, Ams*> amsList)
td.material_cols.push_back(AmsTray::decode_color(col)); td.material_cols.push_back(AmsTray::decode_color(col));
} }
} }
td.ams_id = std::stoi(ams_iter->second->id);
td.slot_id = std::stoi(tray_iter->second->id);
} }
tray_datas.push_back(td); tray_datas.push_back(td);
@ -520,26 +621,20 @@ void AmsMapingPopup::update_ams_data(std::map<std::string, Ams*> amsList)
ams_mapping_item_container->Show(); ams_mapping_item_container->Show();
add_ams_mapping(tray_datas, ams_mapping_item_container, sizer_mapping_list); add_ams_mapping(tray_datas, ams_mapping_item_container, sizer_mapping_list);
m_amsmapping_container_sizer_list.push_back(sizer_mapping_list); m_amsmapping_container_sizer_list.push_back(sizer_mapping_list);
m_amsmapping_container_list.push_back(ams_mapping_item_container); m_amsmapping_container_list.push_back(ams_mapping_item_container);
//main nozzle = right nozzle if (nozzle_id == 0) { //right slot
if (nozzle_id == 0) { m_sizer_ams_basket_right->Add(ams_mapping_item_container, 0, wxALIGN_CENTER, 0);
m_sizer_ams_right->Add(ams_mapping_item_container, 0, wxALIGN_CENTER, 0);
} }
else if (nozzle_id == 1) { else if (nozzle_id == 1) { //left slot
m_sizer_ams_left->Add(ams_mapping_item_container, 0, wxALIGN_CENTER, 0); m_sizer_ams_basket_left->Add(ams_mapping_item_container, 0, wxALIGN_CENTER, 0);
} }
//m_warning_text->Show(m_has_unmatch_filament); //m_warning_text->Show(m_has_unmatch_filament);
} }
} }
/*extra tray*/
Layout(); Layout();
Fit(); Fit();
} }
@ -589,26 +684,20 @@ std::vector<TrayData> AmsMapingPopup::parse_ams_mapping(std::map<std::string, Am
void AmsMapingPopup::add_ams_mapping(std::vector<TrayData> tray_data, wxWindow* container, wxBoxSizer* sizer) void AmsMapingPopup::add_ams_mapping(std::vector<TrayData> tray_data, wxWindow* container, wxBoxSizer* sizer)
{ {
sizer->Add(0,0,0,wxLEFT,FromDIP(6)); sizer->Add(0,0,0,wxLEFT,FromDIP(6));
for (auto i = 0; i < tray_data.size(); i++) { for (auto i = 0; i < tray_data.size(); i++) {
// set number
/* auto number = new wxStaticText(this, wxID_ANY, wxGetApp().transition_tridid(tray_data[i].id), wxDefaultPosition, wxDefaultSize, 0);
number->SetFont(::Label::Body_13);
number->SetForegroundColour(wxColour(0X6B, 0X6B, 0X6B));
number->Wrap(-1);*/
// set button // set button
MappingItem *m_mapping_item = new MappingItem(container); MappingItem *m_mapping_item = new MappingItem(container);
m_mapping_item->send_win = send_win;
m_mapping_item->m_ams_id = tray_data[i].ams_id; m_mapping_item->m_ams_id = tray_data[i].ams_id;
m_mapping_item->m_slot_id = tray_data[i].slot_id; m_mapping_item->m_slot_id = tray_data[i].slot_id;
m_mapping_item->set_tray_index(wxGetApp().transition_tridid(tray_data[i].id));
m_mapping_item->SetSize(wxSize(FromDIP(48), FromDIP(60)));
m_mapping_item->SetMinSize(wxSize(FromDIP(48), FromDIP(60)));
m_mapping_item->SetMaxSize(wxSize(FromDIP(48), FromDIP(60)));
m_mapping_item->SetSize(wxSize(FromDIP(68 * 0.7), FromDIP(100 * 0.6)));
m_mapping_item->SetMinSize(wxSize(FromDIP(68 * 0.7), FromDIP(100 * 0.6)));
m_mapping_item->SetMaxSize(wxSize(FromDIP(68 * 0.7), FromDIP(100 * 0.6)));
//m_mapping_item->SetCornerRadius(5);
m_mapping_item->SetFont(::Label::Body_12);
m_mapping_item_list.push_back(m_mapping_item); m_mapping_item_list.push_back(m_mapping_item);
if (tray_data[i].type == NORMAL) { if (tray_data[i].type == NORMAL) {
@ -646,14 +735,50 @@ void AmsMapingPopup::add_ams_mapping(std::vector<TrayData> tray_data, wxWindow*
}); });
} }
sizer->Add(0, 0, 0, wxRIGHT, FromDIP(6));
//sizer_mapping_item->Add(number, 0, wxALIGN_CENTER_HORIZONTAL, 0);
//sizer_mapping_item->Add(m_mapping_item, 0, wxALIGN_CENTER_HORIZONTAL, 0);
m_mapping_item->set_tray_index(wxGetApp().transition_tridid(tray_data[i].id));
sizer->Add(0,0,0,wxRIGHT,FromDIP(6));
sizer->Add(m_mapping_item, 0, wxTOP, FromDIP(1)); sizer->Add(m_mapping_item, 0, wxTOP, FromDIP(1));
} }
}
void AmsMapingPopup::add_ext_ams_mapping(TrayData tray_data, MappingItem* item)
{
// set button
if (tray_data.type == NORMAL) {
if (is_match_material(tray_data.filament_type)) {
item->set_data(tray_data.colour, tray_data.name, tray_data);
}
else {
item->set_data(wxColour(0xEE, 0xEE, 0xEE), tray_data.name, tray_data, true);
m_has_unmatch_filament = true;
}
item->Bind(wxEVT_LEFT_DOWN, [this, tray_data, item](wxMouseEvent& e) {
if (!is_match_material(tray_data.filament_type)) return;
item->send_event(m_current_filament_id);
Dismiss();
});
}
// temp
if (tray_data.type == EMPTY) {
item->set_data(wxColour(0xCE, 0xCE, 0xCE), "-", tray_data);
item->Bind(wxEVT_LEFT_DOWN, [this, tray_data,item](wxMouseEvent& e) {
item->send_event(m_current_filament_id);
Dismiss();
});
}
// third party
if (tray_data.type == THIRD) {
item->set_data(wxColour(0xCE, 0xCE, 0xCE), "?", tray_data);
item->Bind(wxEVT_LEFT_DOWN, [this, tray_data, item](wxMouseEvent& e) {
item->send_event(m_current_filament_id);
Dismiss();
});
}
item->set_tray_index(_L("Ext"));
} }
void AmsMapingPopup::OnDismiss() void AmsMapingPopup::OnDismiss()
@ -693,15 +818,17 @@ void AmsMapingPopup::paintEvent(wxPaintEvent &evt)
void MappingItem::send_event(int fliament_id) void MappingItem::send_event(int fliament_id)
{ {
auto number = wxGetApp().transition_tridid(m_tray_data.id);
wxCommandEvent event(EVT_SET_FINISH_MAPPING); wxCommandEvent event(EVT_SET_FINISH_MAPPING);
event.SetInt(m_tray_data.id); event.SetInt(m_tray_data.id);
wxString param = wxString::Format("%d|%d|%d|%d|%s|%d|%d|%d", m_coloul.Red(), m_coloul.Green(), m_coloul.Blue(), m_coloul.Alpha(), number, fliament_id, wxString param = wxString::Format("%d|%d|%d|%d|%s|%d|%d|%d", m_coloul.Red(), m_coloul.Green(), m_coloul.Blue(), m_coloul.Alpha(), m_tray_index, fliament_id,
m_tray_data.ams_id, m_tray_data.slot_id); m_tray_data.ams_id, m_tray_data.slot_id);
event.SetString(param); event.SetString(param);
event.SetEventObject(this->GetParent()->GetParent());
wxPostEvent(this->GetParent()->GetParent()->GetParent(), event); if (send_win) {
event.SetEventObject(send_win);
wxPostEvent(send_win, event);
}
} }
void MappingItem::msw_rescale() void MappingItem::msw_rescale()

21
src/slic3r/GUI/AmsMappingPopup.hpp
View File

@ -113,6 +113,7 @@ public:
void send_event(int fliament_id); void send_event(int fliament_id);
void set_tray_index(wxString t_index) {m_tray_index = t_index;}; void set_tray_index(wxString t_index) {m_tray_index = t_index;};
wxWindow*send_win{nullptr};
wxString m_tray_index; wxString m_tray_index;
wxColour m_coloul; wxColour m_coloul;
wxString m_name; wxString m_name;
@ -145,8 +146,9 @@ class AmsMapingPopup : public PopupWindow
{ {
public: public:
AmsMapingPopup(wxWindow *parent); AmsMapingPopup(wxWindow *parent);
~AmsMapingPopup(){}; ~AmsMapingPopup() {};
wxWindow* send_win{nullptr};
wxStaticText * m_warning_text{nullptr}; wxStaticText * m_warning_text{nullptr};
std::vector<std::string> m_materials_list; std::vector<std::string> m_materials_list;
std::vector<wxBoxSizer*> m_amsmapping_container_sizer_list; std::vector<wxBoxSizer*> m_amsmapping_container_sizer_list;
@ -160,16 +162,27 @@ public:
wxBoxSizer *m_sizer_ams{nullptr}; wxBoxSizer *m_sizer_ams{nullptr};
wxBoxSizer *m_sizer_ams_left{nullptr}; wxBoxSizer *m_sizer_ams_left{nullptr};
wxBoxSizer *m_sizer_ams_right{nullptr}; wxBoxSizer *m_sizer_ams_right{nullptr};
wxBoxSizer* m_sizer_ams_basket_left{ nullptr };
wxBoxSizer* m_sizer_ams_basket_right{ nullptr };
wxBoxSizer *m_sizer_list{nullptr}; wxBoxSizer *m_sizer_list{nullptr};
wxWindow *m_parent_item{nullptr}; wxWindow *m_parent_item{nullptr};
MappingItem* m_left_extra_slot{nullptr};
MappingItem* m_right_extra_slot{nullptr};
wxPanel* m_left_marea_panel;
wxPanel* m_right_marea_panel;
wxBoxSizer* create_split_sizer(wxWindow* parent, wxString text);
wxString format_text(wxString &m_msg); wxString format_text(wxString &m_msg);
void set_send_win(wxWindow* win) {send_win = win;};
void update_materials_list(std::vector<std::string> list); void update_materials_list(std::vector<std::string> list);
void set_tag_texture(std::string texture); void set_tag_texture(std::string texture);
void update_ams_data(std::map<std::string, Ams *> amsList); void update(MachineObject* obj);
void update_ams_data_multi_machines(); void update_ams_data_multi_machines();
void add_ams_mapping(std::vector<TrayData> tray_data, wxWindow* container, wxBoxSizer* sizer); void add_ams_mapping(std::vector<TrayData> tray_data, wxWindow* container, wxBoxSizer* sizer);
void set_current_filament_id(int id){m_current_filament_id = id;}; void add_ext_ams_mapping(TrayData tray_data, MappingItem* item);
void set_current_filament_id(int id) { m_current_filament_id = id; };
int get_current_filament_id(){return m_current_filament_id;}; int get_current_filament_id(){return m_current_filament_id;};
bool is_match_material(std::string material); bool is_match_material(std::string material);
void on_left_down(wxMouseEvent &evt); void on_left_down(wxMouseEvent &evt);

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

@ -1631,7 +1631,7 @@ void CalibrationPresetPage::init_with_machine(MachineObject* obj)
// init default for filament source // init default for filament source
// TODO if user change ams/ext, need to update // TODO if user change ams/ext, need to update
if ( !obj->has_ams() || (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_ID)) ) if ( !obj->has_ams() || (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_MAIN_ID)) )
{ {
m_ext_spool_radiobox->SetValue(true); m_ext_spool_radiobox->SetValue(true);
m_ams_radiobox->SetValue(false); m_ams_radiobox->SetValue(false);
@ -1679,8 +1679,8 @@ void CalibrationPresetPage::sync_ams_info(MachineObject* obj)
} }
// init virtual tray info // init virtual tray info
if (full_filament_ams_list.find(VIRTUAL_TRAY_ID) != full_filament_ams_list.end()) { if (full_filament_ams_list.find(VIRTUAL_TRAY_MAIN_ID) != full_filament_ams_list.end()) {
filament_ams_list[VIRTUAL_TRAY_ID] = full_filament_ams_list[VIRTUAL_TRAY_ID]; filament_ams_list[VIRTUAL_TRAY_MAIN_ID] = full_filament_ams_list[VIRTUAL_TRAY_MAIN_ID];
} }
@ -1883,14 +1883,14 @@ void CalibrationPresetPage::update_filament_combobox(std::string ams_id)
/* update virtual tray combo box*/ /* update virtual tray combo box*/
m_virtual_tray_comboBox->update_from_preset(); m_virtual_tray_comboBox->update_from_preset();
auto it = std::find_if(filament_ams_list.begin(), filament_ams_list.end(), [](auto& entry) { auto it = std::find_if(filament_ams_list.begin(), filament_ams_list.end(), [](auto& entry) {
return entry.first == VIRTUAL_TRAY_ID; return entry.first == VIRTUAL_TRAY_MAIN_ID;
}); });
if (it != filament_ams_list.end()) { if (it != filament_ams_list.end()) {
m_virtual_tray_comboBox->load_tray_from_ams(VIRTUAL_TRAY_ID, it->second); m_virtual_tray_comboBox->load_tray_from_ams(VIRTUAL_TRAY_MAIN_ID, it->second);
} }
else { else {
m_virtual_tray_comboBox->load_tray_from_ams(VIRTUAL_TRAY_ID, empty_config); m_virtual_tray_comboBox->load_tray_from_ams(VIRTUAL_TRAY_MAIN_ID, empty_config);
} }
if (filament_ams_list.empty()) if (filament_ams_list.empty())

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

@ -53,7 +53,7 @@ static wxString get_default_name(wxString filament_name, CalibMode mode){
static wxString get_tray_name_by_tray_id(int tray_id) static wxString get_tray_name_by_tray_id(int tray_id)
{ {
wxString tray_name; wxString tray_name;
if (tray_id == VIRTUAL_TRAY_ID) { if (tray_id == VIRTUAL_TRAY_MAIN_ID) {
tray_name = "Ext"; tray_name = "Ext";
} }
else { else {

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

@ -581,8 +581,7 @@ MachineObject::MachineObject(NetworkAgent* agent, std::string name, std::string
subtask_(nullptr), subtask_(nullptr),
model_task(nullptr), model_task(nullptr),
slice_info(nullptr), slice_info(nullptr),
m_is_online(false), m_is_online(false)
vt_tray(std::to_string(VIRTUAL_TRAY_ID))
{ {
m_agent = agent; m_agent = agent;
@ -637,6 +636,10 @@ MachineObject::MachineObject(NetworkAgent* agent, std::string name, std::string
printing_speed_lvl = PrintingSpeedLevel::SPEED_LEVEL_INVALID; printing_speed_lvl = PrintingSpeedLevel::SPEED_LEVEL_INVALID;
has_ipcam = true; // default true has_ipcam = true; // default true
auto vslot = AmsTray(std::to_string(VIRTUAL_TRAY_MAIN_ID));
vt_slot.push_back(vslot);
} }
MachineObject::~MachineObject() MachineObject::~MachineObject()
@ -755,8 +758,8 @@ Ams *MachineObject::get_curr_Ams()
AmsTray *MachineObject::get_curr_tray() AmsTray *MachineObject::get_curr_tray()
{ {
if (m_tray_now.compare(std::to_string(VIRTUAL_TRAY_ID)) == 0) { if (m_tray_now.compare(std::to_string(VIRTUAL_TRAY_MAIN_ID)) == 0) {
return &vt_tray; return &vt_slot[0];
} }
Ams* curr_ams = get_curr_Ams(); Ams* curr_ams = get_curr_Ams();
@ -1122,18 +1125,22 @@ bool MachineObject::is_valid_mapping_result(std::vector<FilamentInfo>& result, b
for (int i = 0; i < result.size(); i++) { for (int i = 0; i < result.size(); i++) {
// invalid mapping result // invalid mapping result
if (result[i].tray_id < 0) if (result[i].tray_id < 0) {
valid_ams_mapping_result = false; if (result[i].ams_id.empty() && result[i].slot_id.empty()) {
else {
int ams_id = result[i].tray_id / 4;
auto ams_item = amsList.find(std::to_string(ams_id));
if (ams_item == amsList.end()) {
result[i].tray_id = -1;
valid_ams_mapping_result = false; valid_ams_mapping_result = false;
}
}
else {
auto ams_item = amsList.find(result[i].ams_id);
if (ams_item == amsList.end()) {
if ( (result[i].ams_id != std::to_string(VIRTUAL_TRAY_MAIN_ID)) &&
(result[i].ams_id != std::to_string(VIRTUAL_TRAY_DEPUTY_ID))) {
result[i].tray_id = -1;
valid_ams_mapping_result = false;
}
} else { } else {
if (check_empty_slot) { if (check_empty_slot) {
int tray_id = result[i].tray_id % 4; auto tray_item = ams_item->second->trayList.find(result[i].slot_id);
auto tray_item = ams_item->second->trayList.find(std::to_string(tray_id));
if (tray_item == ams_item->second->trayList.end()) { if (tray_item == ams_item->second->trayList.end()) {
result[i].tray_id = -1; result[i].tray_id = -1;
valid_ams_mapping_result = false; valid_ams_mapping_result = false;
@ -1882,7 +1889,7 @@ int MachineObject::command_ams_switch(int tray_index, int old_temp, int new_temp
gcode = DeviceManager::load_gcode(printer_type, "ams_unload.gcode"); gcode = DeviceManager::load_gcode(printer_type, "ams_unload.gcode");
} }
else { else {
// include VIRTUAL_TRAY_ID // include VIRTUAL_TRAY_MAIN_ID
gcode = DeviceManager::load_gcode(printer_type, "ams_load.gcode"); gcode = DeviceManager::load_gcode(printer_type, "ams_load.gcode");
boost::replace_all(gcode, "[next_extruder]", std::to_string(tray_index)); boost::replace_all(gcode, "[next_extruder]", std::to_string(tray_index));
boost::replace_all(gcode, "[new_filament_temp]", std::to_string(new_temp)); boost::replace_all(gcode, "[new_filament_temp]", std::to_string(new_temp));
@ -2648,7 +2655,14 @@ void MachineObject::reset()
json empty_j; json empty_j;
print_json.diff2all_base_reset(empty_j); print_json.diff2all_base_reset(empty_j);
vt_tray.reset(); for (auto i = 0; i < vt_slot.size(); i++) {
vt_slot[i].reset();
if (i == 1) {
vt_slot.erase(vt_slot.begin() + 1);
}
}
subtask_ = nullptr; subtask_ = nullptr;
@ -4162,7 +4176,9 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
<< __FUNCTION__ << " " << __LINE__ << " stoi error and ams_id: " << ams_id << " tray_id" << tray_id; << __FUNCTION__ << " " << __LINE__ << " stoi error and ams_id: " << ams_id << " tray_id" << tray_id;
} }
} }
} }*/
} else { } else {
curr_tray->setting_id = ""; curr_tray->setting_id = "";
curr_tray->type = ""; curr_tray->type = "";
@ -4210,29 +4226,27 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
curr_tray->nozzle_temp_min = (*tray_it)["nozzle_temp_min"].get<std::string>(); curr_tray->nozzle_temp_min = (*tray_it)["nozzle_temp_min"].get<std::string>();
else else
curr_tray->nozzle_temp_min = ""; curr_tray->nozzle_temp_min = "";
if (curr_tray->setting_id.size() == 8 && curr_tray->setting_id[0] == 'P' && curr_tray->nozzle_temp_min != "" && curr_tray->nozzle_temp_max != "") {
if (m_checked_filament.find(vt_tray.setting_id) == m_checked_filament.end()) { /*need for optimization*/
need_checked_filament_id.insert(vt_tray.setting_id); /*if (curr_tray->nozzle_temp_min != "" && curr_tray->nozzle_temp_max != "") {
try { try {
std::string preset_setting_id; std::string preset_setting_id;
bool is_equation = preset_bundle->check_filament_temp_equation_by_printer_type_and_nozzle_for_mas_tray( 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), nozzle_diameter_str, curr_tray->setting_id, MachineObject::get_preset_printer_model_name(this->printer_type), nozzle_diameter_str, curr_tray->setting_id,
curr_tray->tag_uid, curr_tray->nozzle_temp_min, curr_tray->nozzle_temp_max, preset_setting_id); curr_tray->tag_uid, curr_tray->nozzle_temp_min, curr_tray->nozzle_temp_max, preset_setting_id);
if (!is_equation) { if (!is_equation) {
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ command_ams_filament_settings(std::stoi(ams_id), std::stoi(tray_id), curr_tray->setting_id, preset_setting_id,
<< " ams filament is not match min max temp and reset, ams_id: " << ams_id curr_tray->color, curr_tray->type,
<< " tray_id" << tray_id << "filament_id: " << curr_tray->setting_id; std::stoi(curr_tray->nozzle_temp_min),
command_ams_filament_settings(std::stoi(ams_id), std::stoi(tray_id), curr_tray->setting_id, preset_setting_id, std::stoi(curr_tray->nozzle_temp_max));
curr_tray->color, curr_tray->type,
std::stoi(curr_tray->nozzle_temp_min),
std::stoi(curr_tray->nozzle_temp_max));
}
continue;
} catch (...) {
BOOST_LOG_TRIVIAL(info) << "check fail and curr_tray ams_id" << ams_id << " curr_tray tray_id"<<tray_id;
} }
} catch (...) {
BOOST_LOG_TRIVIAL(info) << "check fail and curr_tray ams_id" << ams_id << " curr_tray tray_id"<<tray_id;
} }
} }*/
if (tray_it->contains("xcam_info")) if (tray_it->contains("xcam_info"))
curr_tray->xcam_info = (*tray_it)["xcam_info"].get<std::string>(); curr_tray->xcam_info = (*tray_it)["xcam_info"].get<std::string>();
else else
@ -4320,150 +4334,46 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
/* vitrual tray*/ /* vitrual tray*/
if (!key_field_only) { if (!key_field_only) {
try { try {
if (jj.contains("vt_tray")) { if (jj.contains("vir_slot") && jj["vir_slot"].is_array()) {
if (jj["vt_tray"].contains("id"))
vt_tray.id = jj["vt_tray"]["id"].get<std::string>();
auto curr_time = std::chrono::system_clock::now();
auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(curr_time - extrusion_cali_set_hold_start);
if (diff.count() > HOLD_TIMEOUT || diff.count() < 0
|| extrusion_cali_set_tray_id != VIRTUAL_TRAY_ID) {
if (jj["vt_tray"].contains("k"))
vt_tray.k = jj["vt_tray"]["k"].get<float>();
if (jj["vt_tray"].contains("n"))
vt_tray.n = jj["vt_tray"]["n"].get<float>();
}
ams_support_virtual_tray = true;
if (vt_tray.hold_count > 0) { for (auto it = jj["vir_slot"].begin(); it != jj["vir_slot"].end(); it++) {
vt_tray.hold_count--; auto vslot = parse_vt_tray(it.value().get<json>());
} else {
if (jj["vt_tray"].contains("tag_uid")) if (vslot.id == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
vt_tray.tag_uid = jj["vt_tray"]["tag_uid"].get<std::string>(); auto it = std::next(vt_slot.begin(), 0);
else if (it != vt_slot.end()) {
vt_tray.tag_uid = "0"; vt_slot[0] = vslot;
if (jj["vt_tray"].contains("tray_info_idx") && jj["vt_tray"].contains("tray_type")) {
vt_tray.setting_id = jj["vt_tray"]["tray_info_idx"].get<std::string>();
//std::string type = jj["vt_tray"]["tray_type"].get<std::string>();
std::string type = setting_id_to_type(vt_tray.setting_id, jj["vt_tray"]["tray_type"].get<std::string>());
if (vt_tray.setting_id == "GFS00") {
vt_tray.type = "PLA-S";
}
else if (vt_tray.setting_id == "GFS01") {
vt_tray.type = "PA-S";
} }
else { else {
vt_tray.type = type; vt_slot.push_back(vslot);
}
}
else if (vslot.id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
auto it = std::next(vt_slot.begin(), 1);
if (it != vt_slot.end()) {
vt_slot[1] = vslot;
} }
if (vt_tray.setting_id.size() == 8 && vt_tray.setting_id[0] == 'P' && else {
m_filament_list.find(vt_tray.setting_id) == m_filament_list.end()) { vt_slot.push_back(vslot);
if (m_checked_filament.find(vt_tray.setting_id) == m_checked_filament.end()) {
need_checked_filament_id.insert(vt_tray.setting_id);
wxColour color = *wxWHITE;
char col_buf[10];
sprintf(col_buf, "%02X%02X%02XFF", (int) color.Red(), (int) color.Green(), (int) color.Blue());
try {
BOOST_LOG_TRIVIAL(info) << "vt_tray.setting_id is not exist in filament_list and reset vt_tray and the filament_id is: " << vt_tray.setting_id;
this->command_ams_filament_settings(255, std::stoi(vt_tray.id), "", "", std::string(col_buf), "", 0, 0);
} catch (...) {
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << " stoi error and tray_id" << vt_tray.id;
}
}
} }
} }
else {
vt_tray.setting_id = "";
vt_tray.type = "";
}
if (jj["vt_tray"].contains("tray_sub_brands"))
vt_tray.sub_brands = jj["vt_tray"]["tray_sub_brands"].get<std::string>();
else
vt_tray.sub_brands = "";
if (jj["vt_tray"].contains("tray_weight"))
vt_tray.weight = jj["vt_tray"]["tray_weight"].get<std::string>();
else
vt_tray.weight = "";
if (jj["vt_tray"].contains("tray_diameter"))
vt_tray.diameter = jj["vt_tray"]["tray_diameter"].get<std::string>();
else
vt_tray.diameter = "";
if (jj["vt_tray"].contains("tray_temp"))
vt_tray.temp = jj["vt_tray"]["tray_temp"].get<std::string>();
else
vt_tray.temp = "";
if (jj["vt_tray"].contains("tray_time"))
vt_tray.time = jj["vt_tray"]["tray_time"].get<std::string>();
else
vt_tray.time = "";
if (jj["vt_tray"].contains("bed_temp_type"))
vt_tray.bed_temp_type = jj["vt_tray"]["bed_temp_type"].get<std::string>();
else
vt_tray.bed_temp_type = "";
if (jj["vt_tray"].contains("bed_temp"))
vt_tray.bed_temp = jj["vt_tray"]["bed_temp"].get<std::string>();
else
vt_tray.bed_temp = "";
if (jj["vt_tray"].contains("tray_color")) {
auto color = jj["vt_tray"]["tray_color"].get<std::string>();
vt_tray.update_color_from_str(color);
} else {
vt_tray.color = "";
}
if (jj["vt_tray"].contains("nozzle_temp_max"))
vt_tray.nozzle_temp_max = jj["vt_tray"]["nozzle_temp_max"].get<std::string>();
else
vt_tray.nozzle_temp_max = "";
if (jj["vt_tray"].contains("nozzle_temp_min"))
vt_tray.nozzle_temp_min = jj["vt_tray"]["nozzle_temp_min"].get<std::string>();
else
vt_tray.nozzle_temp_min = "";
if (vt_tray.setting_id.size() == 8 && vt_tray.setting_id[0] == 'P' && vt_tray.nozzle_temp_min != "" && vt_tray.nozzle_temp_max != "") {
if (m_checked_filament.find(vt_tray.setting_id) == m_checked_filament.end()) {
need_checked_filament_id.insert(vt_tray.setting_id);
try {
std::string preset_setting_id;
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), nozzle_diameter_str, vt_tray.setting_id, vt_tray.tag_uid,
vt_tray.nozzle_temp_min, vt_tray.nozzle_temp_max, preset_setting_id);
if (!is_equation) {
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << " vt_tray filament is not match min max temp and reset, filament_id: " << vt_tray.setting_id;
command_ams_filament_settings(255, std::stoi(vt_tray.id), vt_tray.setting_id, preset_setting_id, vt_tray.color, vt_tray.type,
std::stoi(vt_tray.nozzle_temp_min), std::stoi(vt_tray.nozzle_temp_max));
}
} catch (...) {
BOOST_LOG_TRIVIAL(info) << "check fail and vt_tray.id" << vt_tray.id;
}
}
}
if (jj["vt_tray"].contains("xcam_info"))
vt_tray.xcam_info = jj["vt_tray"]["xcam_info"].get<std::string>();
else
vt_tray.xcam_info = "";
if (jj["vt_tray"].contains("tray_uuid"))
vt_tray.uuid = jj["vt_tray"]["tray_uuid"].get<std::string>();
else
vt_tray.uuid = "0";
if (jj["vt_tray"].contains("cali_idx"))
vt_tray.cali_idx = jj["vt_tray"]["cali_idx"].get<int>();
else
vt_tray.cali_idx = -1;
vt_tray.cols.clear();
if (jj["vt_tray"].contains("cols")) {
if (jj["vt_tray"].is_array()) {
for (auto it = jj["vt_tray"].begin(); it != jj["vt_tray"].end(); it++) {
vt_tray.cols.push_back(it.value().get<std::string>());
}
}
}
if (jj["vt_tray"].contains("remain")) {
vt_tray.remain = jj["vt_tray"]["remain"].get<int>();
}
else {
vt_tray.remain = -1;
}
} }
} else {
}
else if (jj.contains("vt_tray")) {
auto main_slot = parse_vt_tray(jj.contains("vt_tray"));
main_slot.id = std::to_string(VIRTUAL_TRAY_MAIN_ID);
auto it = std::next(vt_slot.begin(), 0);
if (it != vt_slot.end()) {
vt_slot[0] = main_slot;
}
else {
vt_slot.push_back(main_slot);
}
}
else {
ams_support_virtual_tray = false; ams_support_virtual_tray = false;
is_support_extrusion_cali = false; is_support_extrusion_cali = false;
} }
@ -4529,16 +4439,16 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
if (jj.contains("tray_id")) { if (jj.contains("tray_id")) {
tray_id = jj["tray_id"].get<int>(); tray_id = jj["tray_id"].get<int>();
} }
if (ams_id == 255 && tray_id == VIRTUAL_TRAY_ID) { if (ams_id == 255 && tray_id == VIRTUAL_TRAY_MAIN_ID) {
BOOST_LOG_TRIVIAL(info) << "ams_filament_setting, parse tray info"; BOOST_LOG_TRIVIAL(info) << "ams_filament_setting, parse tray info";
vt_tray.nozzle_temp_max = std::to_string(jj["nozzle_temp_max"].get<int>()); vt_slot[0].nozzle_temp_max = std::to_string(jj["nozzle_temp_max"].get<int>());
vt_tray.nozzle_temp_min = std::to_string(jj["nozzle_temp_min"].get<int>()); vt_slot[0].nozzle_temp_min = std::to_string(jj["nozzle_temp_min"].get<int>());
vt_tray.color = jj["tray_color"].get<std::string>(); vt_slot[0].color = jj["tray_color"].get<std::string>();
vt_tray.setting_id = jj["tray_info_idx"].get<std::string>(); vt_slot[0].setting_id = jj["tray_info_idx"].get<std::string>();
//vt_tray.type = jj["tray_type"].get<std::string>(); //vt_tray.type = jj["tray_type"].get<std::string>();
vt_tray.type = setting_id_to_type(vt_tray.setting_id, jj["tray_type"].get<std::string>()); vt_slot[0].type = setting_id_to_type(vt_slot[0].setting_id, jj["tray_type"].get<std::string>());
// delay update // delay update
vt_tray.set_hold_count(); vt_slot[0].set_hold_count();
} else { } else {
auto ams_it = amsList.find(std::to_string(ams_id)); auto ams_it = amsList.find(std::to_string(ams_id));
if (ams_it != amsList.end()) { if (ams_it != amsList.end()) {
@ -4669,7 +4579,7 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
if (jj.contains("tray_id")) { if (jj.contains("tray_id")) {
try { try {
curr_tray_id = jj["tray_id"].get<int>(); curr_tray_id = jj["tray_id"].get<int>();
if (curr_tray_id == VIRTUAL_TRAY_ID) if (curr_tray_id == VIRTUAL_TRAY_MAIN_ID)
tray_id = curr_tray_id; tray_id = curr_tray_id;
else if (curr_tray_id >= 0 && curr_tray_id < 16){ else if (curr_tray_id >= 0 && curr_tray_id < 16){
ams_id = curr_tray_id / 4; ams_id = curr_tray_id / 4;
@ -4682,11 +4592,11 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
; ;
} }
} }
if (tray_id == VIRTUAL_TRAY_ID) { if (tray_id == VIRTUAL_TRAY_MAIN_ID) {
if (jj.contains("k_value")) if (jj.contains("k_value"))
vt_tray.k = jj["k_value"].get<float>(); vt_slot[0].k = jj["k_value"].get<float>();
if (jj.contains("n_coef")) if (jj.contains("n_coef"))
vt_tray.n = jj["n_coef"].get<float>(); vt_slot[0].n = jj["n_coef"].get<float>();
} else { } else {
auto ams_item = this->amsList.find(std::to_string(ams_id)); auto ams_item = this->amsList.find(std::to_string(ams_id));
if (ams_item != this->amsList.end()) { if (ams_item != this->amsList.end()) {
@ -4720,7 +4630,7 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
if (jj.contains("tray_id")) { if (jj.contains("tray_id")) {
try { try {
curr_tray_id = jj["tray_id"].get<int>(); curr_tray_id = jj["tray_id"].get<int>();
if (curr_tray_id == VIRTUAL_TRAY_ID) if (curr_tray_id == VIRTUAL_TRAY_MAIN_ID)
tray_id = curr_tray_id; tray_id = curr_tray_id;
else if (curr_tray_id >= 0 && curr_tray_id < 16) { else if (curr_tray_id >= 0 && curr_tray_id < 16) {
ams_id = curr_tray_id / 4; ams_id = curr_tray_id / 4;
@ -4732,10 +4642,10 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
; ;
} }
} }
if (tray_id == VIRTUAL_TRAY_ID) { if (tray_id == VIRTUAL_TRAY_MAIN_ID) {
if (jj.contains("cali_idx")) { if (jj.contains("cali_idx")) {
vt_tray.cali_idx = jj["cali_idx"].get<int>(); vt_slot[0].cali_idx = jj["cali_idx"].get<int>();
vt_tray.set_hold_count(); vt_slot[0].set_hold_count();
} }
} else { } else {
auto ams_item = this->amsList.find(std::to_string(ams_id)); auto ams_item = this->amsList.find(std::to_string(ams_id));
@ -5389,92 +5299,157 @@ std::string MachineObject::get_string_from_fantype(FanType type)
return ""; return "";
} }
void MachineObject::update_filament_list() AmsTray MachineObject::parse_vt_tray(json vtray)
{ {
PresetBundle *preset_bundle = Slic3r::GUI::wxGetApp().preset_bundle; auto vt_tray = AmsTray(std::to_string(VIRTUAL_TRAY_MAIN_ID));
// custom filament if (vtray.contains("id"))
std::map<std::string, std::pair<int, int>> filament_list; vt_tray.id = vtray["id"].get<std::string>();
for (auto &preset : preset_bundle->filaments()) { auto curr_time = std::chrono::system_clock::now();
if (preset.is_user() && preset.inherits() == "") { auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(curr_time - extrusion_cali_set_hold_start);
ConfigOption * printer_opt = const_cast<Preset&>(preset).config.option("compatible_printers"); if (diff.count() > HOLD_TIMEOUT || diff.count() < 0
ConfigOptionStrings *printer_strs = dynamic_cast<ConfigOptionStrings *>(printer_opt); || extrusion_cali_set_tray_id != VIRTUAL_TRAY_MAIN_ID) {
for (const std::string &printer_str : printer_strs->values) { if (vtray.contains("k"))
if (printer_str == m_printer_preset_name) { vt_tray.k = vtray["k"].get<float>();
ConfigOption *opt_min = const_cast<Preset &>(preset).config.option("nozzle_temperature_range_low"); if (vtray.contains("n"))
int min_temp = -1; vt_tray.n = vtray["n"].get<float>();
if (opt_min) { }
ConfigOptionInts *opt_min_ints = dynamic_cast<ConfigOptionInts *>(opt_min); ams_support_virtual_tray = true;
min_temp = opt_min_ints->get_at(0);
} if (vt_tray.hold_count > 0) {
ConfigOption *opt_max = const_cast<Preset &>(preset).config.option("nozzle_temperature_range_high"); vt_tray.hold_count--;
int max_temp = -1; }
if (opt_max) { else {
ConfigOptionInts *opt_max_ints = dynamic_cast<ConfigOptionInts *>(opt_max); if (vtray.contains("tag_uid"))
max_temp = opt_max_ints->get_at(0); vt_tray.tag_uid = vtray["tag_uid"].get<std::string>();
} else
filament_list[preset.filament_id] = std::make_pair(min_temp, max_temp); vt_tray.tag_uid = "0";
break; if (vtray.contains("tray_info_idx") && vtray.contains("tray_type")) {
vt_tray.setting_id = vtray["tray_info_idx"].get<std::string>();
//std::string type = vtray["tray_type"].get<std::string>();
std::string type = setting_id_to_type(vt_tray.setting_id, vtray["tray_type"].get<std::string>());
if (vt_tray.setting_id == "GFS00") {
vt_tray.type = "PLA-S";
}
else if (vt_tray.setting_id == "GFS01") {
vt_tray.type = "PA-S";
}
else {
vt_tray.type = type;
}
/*need for optimization*/
/*if (filament_list.find(vt_tray.setting_id) == filament_list.end()) {
wxColour color = *wxWHITE;
char col_buf[10];
sprintf(col_buf, "%02X%02X%02XFF", (int)color.Red(), (int)color.Green(), (int)color.Blue());
try {
BOOST_LOG_TRIVIAL(info) << "no filament_id in filament_list and reset vt_tray and the filament_id is: " << vt_tray.setting_id;
this->command_ams_filament_settings(255, std::stoi(vt_tray.id), "", "", std::string(col_buf), "", 0, 0);
}
catch (...) {
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << " stoi error and tray_id" << vt_tray.id;
}
}*/
}
else {
vt_tray.setting_id = "";
vt_tray.type = "";
}
if (vtray.contains("tray_sub_brands"))
vt_tray.sub_brands = vtray["tray_sub_brands"].get<std::string>();
else
vt_tray.sub_brands = "";
if (vtray.contains("tray_weight"))
vt_tray.weight = vtray["tray_weight"].get<std::string>();
else
vt_tray.weight = "";
if (vtray.contains("tray_diameter"))
vt_tray.diameter = vtray["tray_diameter"].get<std::string>();
else
vt_tray.diameter = "";
if (vtray.contains("tray_temp"))
vt_tray.temp = vtray["tray_temp"].get<std::string>();
else
vt_tray.temp = "";
if (vtray.contains("tray_time"))
vt_tray.time = vtray["tray_time"].get<std::string>();
else
vt_tray.time = "";
if (vtray.contains("bed_temp_type"))
vt_tray.bed_temp_type = vtray["bed_temp_type"].get<std::string>();
else
vt_tray.bed_temp_type = "";
if (vtray.contains("bed_temp"))
vt_tray.bed_temp = vtray["bed_temp"].get<std::string>();
else
vt_tray.bed_temp = "";
if (vtray.contains("tray_color")) {
auto color = vtray["tray_color"].get<std::string>();
vt_tray.update_color_from_str(color);
}
else {
vt_tray.color = "";
}
if (vtray.contains("nozzle_temp_max"))
vt_tray.nozzle_temp_max = vtray["nozzle_temp_max"].get<std::string>();
else
vt_tray.nozzle_temp_max = "";
if (vtray.contains("nozzle_temp_min"))
vt_tray.nozzle_temp_min = vtray["nozzle_temp_min"].get<std::string>();
else
vt_tray.nozzle_temp_min = "";
/*need for optimization*/
/*if (vt_tray.nozzle_temp_min != "" && vt_tray.nozzle_temp_max != "") {
try {
std::string preset_setting_id;
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), nozzle_diameter_str, vt_tray.setting_id, vt_tray.tag_uid,
vt_tray.nozzle_temp_min, vt_tray.nozzle_temp_max, preset_setting_id);
if (!is_equation) {
command_ams_filament_settings(255, std::stoi(vt_tray.id), vt_tray.setting_id, preset_setting_id, vt_tray.color, vt_tray.type,
std::stoi(vt_tray.nozzle_temp_min), std::stoi(vt_tray.nozzle_temp_max));
}
}
catch (...) {
BOOST_LOG_TRIVIAL(info) << "check fail and vt_tray.id" << vt_tray.id;
}
}*/
if (vtray.contains("xcam_info"))
vt_tray.xcam_info = vtray["xcam_info"].get<std::string>();
else
vt_tray.xcam_info = "";
if (vtray.contains("tray_uuid"))
vt_tray.uuid = vtray["tray_uuid"].get<std::string>();
else
vt_tray.uuid = "0";
if (vtray.contains("cali_idx"))
vt_tray.cali_idx = vtray["cali_idx"].get<int>();
else
vt_tray.cali_idx = -1;
vt_tray.cols.clear();
if (vtray.contains("cols")) {
if (vtray.is_array()) {
for (auto it = vtray.begin(); it != vtray.end(); it++) {
vt_tray.cols.push_back(it.value().get<std::string>());
} }
} }
} }
}
for (auto it = filament_list.begin(); it != filament_list.end(); it++) { if (vtray.contains("remain")) {
if (m_filament_list.find(it->first) != m_filament_list.end()) { vt_tray.remain = vtray["remain"].get<int>();
assert(it->first.size() == 8 && it->first[0] == 'P'); }
else {
if (it->second.first != m_filament_list[it->first].first) { vt_tray.remain = -1;
BOOST_LOG_TRIVIAL(info) << "old min temp is not equal to new min temp and filament id: " << it->first;
continue;
}
if (it->second.second != m_filament_list[it->first].second) {
BOOST_LOG_TRIVIAL(info) << "old max temp is not equal to new max temp and filament id: " << it->first;
continue;
}
m_filament_list.erase(it->first);
} }
} }
for (auto it = m_filament_list.begin(); it != m_filament_list.end(); it++) { return vt_tray;
m_checked_filament.erase(it->first);
}
m_filament_list = filament_list;
}
int MachineObject::get_flag_bits(std::string str, int start, int count)
{
int decimal_value = std::stoi(str, nullptr, 16);
int mask = 0;
for (int i = 0; i < count; i++) { mask += 1 << (start + i); }
int flag = (decimal_value & (mask)) >> start;
return flag;
}
int MachineObject::get_flag_bits(int num, int start, int count)
{
int decimal_value = num;
int mask = 0;
for (int i = 0; i < count; i++) { mask += 1 << (start + i); }
int flag = (decimal_value & (mask)) >> start;
return flag;
}
void MachineObject::update_printer_preset_name(const std::string &nozzle_diameter_str)
{
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << "start update preset_name";
auto preset_bundle = Slic3r::GUI::wxGetApp().preset_bundle;
if (!preset_bundle) return;
auto printer_set = preset_bundle->get_printer_names_by_printer_type_and_nozzle(MachineObject::get_preset_printer_model_name(this->printer_type), nozzle_diameter_str);
if (printer_set.size() > 0)
m_printer_preset_name = *printer_set.begin();
else
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << " update printer preset name failed ";
} }
bool DeviceManager::EnableMultiMachine = false; bool DeviceManager::EnableMultiMachine = false;

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

@ -37,7 +37,8 @@
#define HOLD_COUNT_CAMERA 6 #define HOLD_COUNT_CAMERA 6
#define GET_VERSION_RETRYS 10 #define GET_VERSION_RETRYS 10
#define RETRY_INTERNAL 2000 #define RETRY_INTERNAL 2000
#define VIRTUAL_TRAY_ID 254 #define VIRTUAL_TRAY_MAIN_ID 255
#define VIRTUAL_TRAY_DEPUTY_ID 254
#define START_SEQ_ID 20000 #define START_SEQ_ID 20000
#define END_SEQ_ID 30000 #define END_SEQ_ID 30000
#define SUBSCRIBE_RETRY_COUNT 5 #define SUBSCRIBE_RETRY_COUNT 5
@ -193,7 +194,7 @@ public:
return wxColour(ret[0], ret[1], ret[2], ret[3]); return wxColour(ret[0], ret[1], ret[2], ret[3]);
} }
std::string id; std::string id;
std::string tag_uid; // tag_uid std::string tag_uid; // tag_uid
std::string setting_id; // tray_info_idx std::string setting_id; // tray_info_idx
std::string filament_setting_id; // setting_id std::string filament_setting_id; // setting_id
@ -502,8 +503,7 @@ public:
/* ams properties */ /* ams properties */
std::map<std::string, Ams*> amsList; // key: ams[id], start with 0 std::map<std::string, Ams*> amsList; // key: ams[id], start with 0
AmsTray vt_tray; // virtual tray //AmsTray vt_tray; // virtual tray
std::vector<AmsTray> vt_trays; // virtual tray for new
long ams_exist_bits = 0; long ams_exist_bits = 0;
long tray_exist_bits = 0; long tray_exist_bits = 0;
long tray_is_bbl_bits = 0; long tray_is_bbl_bits = 0;
@ -1002,15 +1002,9 @@ public:
bool is_enable_np{ false }; bool is_enable_np{ false };
NozzleData m_np_nozzle_data; NozzleData m_np_nozzle_data;
/* Device Filament Check */ /*vi slot data*/
std::set<std::string> m_checked_filament; std::vector<AmsTray> vt_slot;
std::string m_printer_preset_name; AmsTray parse_vt_tray(json vtray);
std::map<std::string, std::pair<int, int>> m_filament_list; // filament_id, pair<min temp, max temp>
void update_filament_list();
int get_flag_bits(std::string str, int start, int count = 1);
int get_flag_bits(int num, int start, int count = 1);
void update_printer_preset_name(const std::string &nozzle_diameter_str);
}; };
class DeviceManager class DeviceManager

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

@ -469,7 +469,7 @@ void ExtrusionCalibration::on_click_cali(wxCommandEvent& event)
max_volumetric_speed = speed_opt->get_at(0); max_volumetric_speed = speed_opt->get_at(0);
if (bed_temp >= 0 && nozzle_temp >= 0 && max_volumetric_speed >= 0) { if (bed_temp >= 0 && nozzle_temp >= 0 && max_volumetric_speed >= 0) {
int curr_tray_id = ams_id * 4 + tray_id; int curr_tray_id = ams_id * 4 + tray_id;
if (tray_id == VIRTUAL_TRAY_ID) if (tray_id == VIRTUAL_TRAY_MAIN_ID)
curr_tray_id = tray_id; curr_tray_id = tray_id;
obj->command_start_extrusion_cali(curr_tray_id, nozzle_temp, bed_temp, max_volumetric_speed, it->setting_id); obj->command_start_extrusion_cali(curr_tray_id, nozzle_temp, bed_temp, max_volumetric_speed, it->setting_id);
return; return;
@ -597,7 +597,7 @@ void ExtrusionCalibration::on_click_save(wxCommandEvent &event)
// send command // send command
int curr_tray_id = ams_id * 4 + tray_id; int curr_tray_id = ams_id * 4 + tray_id;
if (tray_id == VIRTUAL_TRAY_ID) if (tray_id == VIRTUAL_TRAY_MAIN_ID)
curr_tray_id = tray_id; curr_tray_id = tray_id;
obj->command_extrusion_cali_set(curr_tray_id, setting_id, name, k, n, bed_temp, nozzle_temp, max_volumetric_speed); obj->command_extrusion_cali_set(curr_tray_id, setting_id, name, k, n, bed_temp, nozzle_temp, max_volumetric_speed);
Close(); Close();

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

@ -1667,7 +1667,7 @@ std::map<int, DynamicPrintConfig> Sidebar::build_filament_ams_list(MachineObject
std::map<int, DynamicPrintConfig> filament_ams_list; std::map<int, DynamicPrintConfig> filament_ams_list;
if (!obj) return filament_ams_list; if (!obj) return filament_ams_list;
auto vt_tray = obj->vt_tray; auto vt_tray = obj->vt_slot[0];
if (obj->ams_support_virtual_tray) { if (obj->ams_support_virtual_tray) {
DynamicPrintConfig vt_tray_config; DynamicPrintConfig vt_tray_config;
vt_tray_config.set_key_value("filament_id", new ConfigOptionStrings{ vt_tray.setting_id }); vt_tray_config.set_key_value("filament_id", new ConfigOptionStrings{ vt_tray.setting_id });
@ -1681,7 +1681,7 @@ std::map<int, DynamicPrintConfig> Sidebar::build_filament_ams_list(MachineObject
for (int i = 0; i < vt_tray.cols.size(); ++i) { for (int i = 0; i < vt_tray.cols.size(); ++i) {
vt_tray_config.opt<ConfigOptionStrings>("filament_multi_colors")->values.push_back(into_u8(wxColour("#" + vt_tray.cols[i]).GetAsString(wxC2S_HTML_SYNTAX))); vt_tray_config.opt<ConfigOptionStrings>("filament_multi_colors")->values.push_back(into_u8(wxColour("#" + vt_tray.cols[i]).GetAsString(wxC2S_HTML_SYNTAX)));
} }
filament_ams_list.emplace(VIRTUAL_TRAY_ID, std::move(vt_tray_config)); filament_ams_list.emplace(VIRTUAL_TRAY_MAIN_ID, std::move(vt_tray_config));
} }
auto list = obj->amsList; auto list = obj->amsList;

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

@ -1312,7 +1312,9 @@ SelectMachineDialog::SelectMachineDialog(Plater *plater)
m_statictext_ams_msg = new wxStaticText(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_CENTER_HORIZONTAL); m_statictext_ams_msg = new wxStaticText(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT);
m_statictext_ams_msg->SetMinSize(wxSize(FromDIP(600), -1));
m_statictext_ams_msg->SetMaxSize(wxSize(FromDIP(600), -1));
m_statictext_ams_msg->SetFont(::Label::Body_13); m_statictext_ams_msg->SetFont(::Label::Body_13);
m_statictext_ams_msg->Hide(); m_statictext_ams_msg->Hide();
@ -1512,7 +1514,7 @@ SelectMachineDialog::SelectMachineDialog(Plater *plater)
m_sizer_main->Add(m_filament_panel, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(15)); m_sizer_main->Add(m_filament_panel, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(15));
m_sizer_main->Add(m_sizer_filament_2extruder, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(15)); m_sizer_main->Add(m_sizer_filament_2extruder, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(15));
m_sizer_main->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(6)); m_sizer_main->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(6));
m_sizer_main->Add(m_statictext_ams_msg, 0, wxLEFT, 0); m_sizer_main->Add(m_statictext_ams_msg, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(15));
m_sizer_main->Add(0, 0, 0, wxTOP, FromDIP(16)); m_sizer_main->Add(0, 0, 0, wxTOP, FromDIP(16));
m_sizer_main->Add(sizer_split_options, 1, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(15)); m_sizer_main->Add(sizer_split_options, 1, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(15));
m_sizer_main->Add(m_sizer_options, 0, wxALIGN_CENTER_HORIZONTAL|wxLEFT| wxRIGHT, FromDIP(15)); m_sizer_main->Add(m_sizer_options, 0, wxALIGN_CENTER_HORIZONTAL|wxLEFT| wxRIGHT, FromDIP(15));
@ -2081,9 +2083,7 @@ void SelectMachineDialog::update_ams_status_msg(wxString msg, bool is_warning)
if (str_new != str_old) { if (str_new != str_old) {
if (m_statictext_ams_msg->GetLabel() != msg) { if (m_statictext_ams_msg->GetLabel() != msg) {
m_statictext_ams_msg->SetLabel(msg); m_statictext_ams_msg->SetLabel(msg);
m_statictext_ams_msg->SetMinSize(wxSize(FromDIP(400), -1)); m_statictext_ams_msg->Wrap(FromDIP(600));
m_statictext_ams_msg->SetMaxSize(wxSize(FromDIP(400), -1));
m_statictext_ams_msg->Wrap(FromDIP(400));
m_statictext_ams_msg->Show(); m_statictext_ams_msg->Show();
Layout(); Layout();
Fit(); Fit();
@ -4178,7 +4178,8 @@ void SelectMachineDialog::reset_and_sync_ams_list()
m_mapping_popup.set_parent_item(item); m_mapping_popup.set_parent_item(item);
m_mapping_popup.set_current_filament_id(extruder); m_mapping_popup.set_current_filament_id(extruder);
m_mapping_popup.set_tag_texture(materials[extruder]); m_mapping_popup.set_tag_texture(materials[extruder]);
m_mapping_popup.update_ams_data(obj_->amsList); m_mapping_popup.update(obj_);
m_mapping_popup.set_send_win(this);
m_mapping_popup.Popup(); m_mapping_popup.Popup();
} }
} }
@ -4607,7 +4608,7 @@ void SelectMachineDialog::set_default_from_sdcard()
m_mapping_popup.set_parent_item(item); m_mapping_popup.set_parent_item(item);
m_mapping_popup.set_current_filament_id(fo.id); m_mapping_popup.set_current_filament_id(fo.id);
m_mapping_popup.set_tag_texture(fo.type); m_mapping_popup.set_tag_texture(fo.type);
m_mapping_popup.update_ams_data(obj_->amsList); m_mapping_popup.update(obj_);
m_mapping_popup.Popup(); m_mapping_popup.Popup();
} }
} }

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

@ -2613,7 +2613,8 @@ void StatusPanel::update_ams(MachineObject *obj)
m_ams_control->show_auto_refill(true); m_ams_control->show_auto_refill(true);
} }
if (is_support_virtual_tray) m_ams_control->update_vams_kn_value(obj->vt_tray, obj);
if (is_support_virtual_tray) m_ams_control->update_vams_kn_value(obj->vt_slot[0], obj);
if (m_filament_setting_dlg) m_filament_setting_dlg->update(); if (m_filament_setting_dlg) m_filament_setting_dlg->update();
std::vector<AMSinfo> ams_info; std::vector<AMSinfo> ams_info;
@ -2637,11 +2638,11 @@ void StatusPanel::update_ams(MachineObject *obj)
std::string curr_ams_id = m_ams_control->GetCurentAms(); std::string curr_ams_id = m_ams_control->GetCurentAms();
std::string curr_can_id = m_ams_control->GetCurrentCan(curr_ams_id); std::string curr_can_id = m_ams_control->GetCurrentCan(curr_ams_id);
bool is_vt_tray = false; bool is_vt_tray = false;
if (obj->m_tray_tar == std::to_string(VIRTUAL_TRAY_ID)) if (obj->m_tray_tar == std::to_string(VIRTUAL_TRAY_MAIN_ID))
is_vt_tray = true; is_vt_tray = true;
// set segment 1, 2 // set segment 1, 2
if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_ID) ) { if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_MAIN_ID) ) {
m_ams_control->SetAmsStep(obj->m_ams_id, obj->m_tray_id, AMSPassRoadType::AMS_ROAD_TYPE_UNLOAD, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE); m_ams_control->SetAmsStep(obj->m_ams_id, obj->m_tray_id, AMSPassRoadType::AMS_ROAD_TYPE_UNLOAD, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
} }
else { else {
@ -2657,8 +2658,8 @@ void StatusPanel::update_ams(MachineObject *obj)
} }
// set segment 3 // set segment 3
if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_ID)) { if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
m_ams_control->SetExtruder(obj->is_filament_at_extruder(), true, obj->m_ams_id, obj->vt_tray.get_color()); m_ams_control->SetExtruder(obj->is_filament_at_extruder(), true, obj->m_ams_id, obj->vt_slot[0].get_color());
} else { } else {
m_ams_control->SetExtruder(obj->is_filament_at_extruder(), false, obj->m_ams_id, m_ams_control->GetCanColour(obj->m_ams_id, obj->m_tray_id)); m_ams_control->SetExtruder(obj->is_filament_at_extruder(), false, obj->m_ams_id, m_ams_control->GetCanColour(obj->m_ams_id, obj->m_tray_id));
} }
@ -2666,7 +2667,7 @@ void StatusPanel::update_ams(MachineObject *obj)
if (obj->ams_status_main == AMS_STATUS_MAIN_FILAMENT_CHANGE) { if (obj->ams_status_main == AMS_STATUS_MAIN_FILAMENT_CHANGE) {
update_filament_step(); update_filament_step();
if (obj->m_tray_tar == std::to_string(VIRTUAL_TRAY_ID) && (obj->m_tray_now != std::to_string(VIRTUAL_TRAY_ID) || obj->m_tray_now != "255")) { if (obj->m_tray_tar == std::to_string(VIRTUAL_TRAY_MAIN_ID) && (obj->m_tray_now != std::to_string(VIRTUAL_TRAY_MAIN_ID) || obj->m_tray_now != "255")) {
// wait to heat hotend // wait to heat hotend
if (obj->ams_status_sub == 0x02) { if (obj->ams_status_sub == 0x02) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_HEAT_NOZZLE, FilamentStepType::STEP_TYPE_VT_LOAD); m_ams_control->SetFilamentStep(FilamentStep::STEP_HEAT_NOZZLE, FilamentStepType::STEP_TYPE_VT_LOAD);
@ -2773,7 +2774,7 @@ void StatusPanel::update_ams(MachineObject *obj)
} }
bool is_curr_tray_selected = false; bool is_curr_tray_selected = false;
if (!curr_ams_id.empty() && !curr_can_id.empty() && (curr_ams_id != std::to_string(VIRTUAL_TRAY_ID)) ) { if (!curr_ams_id.empty() && !curr_can_id.empty() && (curr_ams_id != std::to_string(VIRTUAL_TRAY_MAIN_ID)) ) {
if (curr_can_id == obj->m_tray_now) { if (curr_can_id == obj->m_tray_now) {
is_curr_tray_selected = true; is_curr_tray_selected = true;
} }
@ -2793,7 +2794,7 @@ void StatusPanel::update_ams(MachineObject *obj)
is_curr_tray_selected = true; is_curr_tray_selected = true;
} }
} }
}else if (curr_ams_id == std::to_string(VIRTUAL_TRAY_ID)) { }else if (curr_ams_id == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
if (curr_ams_id == obj->m_tray_now) { if (curr_ams_id == obj->m_tray_now) {
is_curr_tray_selected = true; is_curr_tray_selected = true;
} }
@ -2868,7 +2869,7 @@ void StatusPanel::update_ams_control_state(bool is_curr_tray_selected)
enable[ACTION_BTN_LOAD] = true; enable[ACTION_BTN_LOAD] = true;
enable[ACTION_BTN_UNLOAD] = false; enable[ACTION_BTN_UNLOAD] = false;
} }
else if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_ID)) { else if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
enable[ACTION_BTN_LOAD] = false; enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = true; enable[ACTION_BTN_UNLOAD] = true;
} }
@ -2877,7 +2878,7 @@ void StatusPanel::update_ams_control_state(bool is_curr_tray_selected)
} }
else { else {
if (obj->is_in_printing() /*&& obj->can_resume() && obj->m_tray_now != std::to_string(VIRTUAL_TRAY_ID) */) { if (obj->is_in_printing() /*&& obj->can_resume() && obj->m_tray_now != std::to_string(VIRTUAL_TRAY_MAIN_ID) */) {
if (!obj->can_resume()) { if (!obj->can_resume()) {
enable[ACTION_BTN_LOAD] = false; enable[ACTION_BTN_LOAD] = false;
@ -2886,7 +2887,7 @@ void StatusPanel::update_ams_control_state(bool is_curr_tray_selected)
else { else {
if (obj->m_tray_now == "255") { if (obj->m_tray_now == "255") {
if ( m_ams_control->GetCurentAms() == std::to_string(VIRTUAL_TRAY_ID) ) { if ( m_ams_control->GetCurentAms() == std::to_string(VIRTUAL_TRAY_MAIN_ID) ) {
enable[ACTION_BTN_LOAD] = true; enable[ACTION_BTN_LOAD] = true;
enable[ACTION_BTN_UNLOAD] = false; enable[ACTION_BTN_UNLOAD] = false;
} }
@ -2895,8 +2896,8 @@ void StatusPanel::update_ams_control_state(bool is_curr_tray_selected)
enable[ACTION_BTN_UNLOAD] = false; enable[ACTION_BTN_UNLOAD] = false;
} }
} }
else if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_ID)) { else if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
if (m_ams_control->GetCurentAms() == std::to_string(VIRTUAL_TRAY_ID)) { if (m_ams_control->GetCurentAms() == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
enable[ACTION_BTN_LOAD] = false; enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = true; enable[ACTION_BTN_UNLOAD] = true;
} }
@ -3505,23 +3506,23 @@ void StatusPanel::on_ams_load_curr()
update_filament_step(); update_filament_step();
//virtual tray //virtual tray
if (curr_ams_id.compare(std::to_string(VIRTUAL_TRAY_ID)) == 0) { if (curr_ams_id.compare(std::to_string(VIRTUAL_TRAY_MAIN_ID)) == 0) {
int old_temp = -1; int old_temp = -1;
int new_temp = -1; int new_temp = -1;
AmsTray* curr_tray = &obj->vt_tray; AmsTray* curr_tray = &obj->vt_slot[0];
if (!curr_tray) return; if (!curr_tray) return;
try { try {
if (!curr_tray->nozzle_temp_max.empty() && !curr_tray->nozzle_temp_min.empty()) if (!curr_tray->nozzle_temp_max.empty() && !curr_tray->nozzle_temp_min.empty())
old_temp = (atoi(curr_tray->nozzle_temp_min.c_str()) + atoi(curr_tray->nozzle_temp_max.c_str())) / 2; old_temp = (atoi(curr_tray->nozzle_temp_min.c_str()) + atoi(curr_tray->nozzle_temp_max.c_str())) / 2;
if (!obj->vt_tray.nozzle_temp_max.empty() && !obj->vt_tray.nozzle_temp_min.empty()) if (!obj->vt_slot[0].nozzle_temp_max.empty() && !obj->vt_slot[0].nozzle_temp_min.empty())
new_temp = (atoi(obj->vt_tray.nozzle_temp_min.c_str()) + atoi(obj->vt_tray.nozzle_temp_max.c_str())) / 2; new_temp = (atoi(obj->vt_slot[0].nozzle_temp_min.c_str()) + atoi(obj->vt_slot[0].nozzle_temp_max.c_str())) / 2;
} }
catch (...) { catch (...) {
; ;
} }
obj->command_ams_switch(VIRTUAL_TRAY_ID, old_temp, new_temp); obj->command_ams_switch(VIRTUAL_TRAY_MAIN_ID, old_temp, new_temp);
} }
std::map<std::string, Ams*>::iterator it = obj->amsList.find(curr_ams_id); std::map<std::string, Ams*>::iterator it = obj->amsList.find(curr_ams_id);
@ -3561,7 +3562,7 @@ void StatusPanel::on_ams_load_curr()
void StatusPanel::on_ams_load_vams(wxCommandEvent& event) { void StatusPanel::on_ams_load_vams(wxCommandEvent& event) {
BOOST_LOG_TRIVIAL(info) << "on_ams_load_vams_tray"; BOOST_LOG_TRIVIAL(info) << "on_ams_load_vams_tray";
m_ams_control->SwitchAms(std::to_string(VIRTUAL_TRAY_ID)); m_ams_control->SwitchAms(std::to_string(VIRTUAL_TRAY_MAIN_ID));
on_ams_load_curr(); on_ams_load_curr();
if (m_print_error_dlg) { if (m_print_error_dlg) {
m_print_error_dlg->on_hide(); m_print_error_dlg->on_hide();
@ -3618,7 +3619,7 @@ void StatusPanel::on_filament_extrusion_cali(wxCommandEvent &event)
m_extrusion_cali_dlg->obj = obj; m_extrusion_cali_dlg->obj = obj;
std::string ams_id = m_ams_control->GetCurentAms(); std::string ams_id = m_ams_control->GetCurentAms();
std::string tray_id = m_ams_control->GetCurrentCan(ams_id); std::string tray_id = m_ams_control->GetCurrentCan(ams_id);
if (tray_id.empty() && ams_id.compare(std::to_string(VIRTUAL_TRAY_ID)) != 0) { if (tray_id.empty() && ams_id.compare(std::to_string(VIRTUAL_TRAY_MAIN_ID)) != 0) {
wxString txt = _L("Please select an AMS slot before calibration"); wxString txt = _L("Please select an AMS slot before calibration");
MessageDialog msg_dlg(nullptr, txt, wxEmptyString, wxICON_WARNING | wxOK); MessageDialog msg_dlg(nullptr, txt, wxEmptyString, wxICON_WARNING | wxOK);
msg_dlg.ShowModal(); msg_dlg.ShowModal();
@ -3630,8 +3631,8 @@ void StatusPanel::on_filament_extrusion_cali(wxCommandEvent &event)
// set ams_filament id is is bbl filament // set ams_filament id is is bbl filament
if (ams_id.compare(std::to_string(VIRTUAL_TRAY_ID)) == 0) { if (ams_id.compare(std::to_string(VIRTUAL_TRAY_MAIN_ID)) == 0) {
tray_id_int = VIRTUAL_TRAY_ID; tray_id_int = VIRTUAL_TRAY_MAIN_ID;
m_extrusion_cali_dlg->ams_filament_id = ""; m_extrusion_cali_dlg->ams_filament_id = "";
} }
else { else {
@ -3676,14 +3677,14 @@ void StatusPanel::on_filament_edit(wxCommandEvent &event)
std::string ams_id = m_ams_control->GetCurentAms(); std::string ams_id = m_ams_control->GetCurentAms();
int ams_id_int = 0; int ams_id_int = 0;
int tray_id_int = 0; int tray_id_int = 0;
if (ams_id.compare(std::to_string(VIRTUAL_TRAY_ID)) == 0) { if (ams_id.compare(std::to_string(VIRTUAL_TRAY_MAIN_ID)) == 0) {
tray_id_int = VIRTUAL_TRAY_ID; tray_id_int = VIRTUAL_TRAY_MAIN_ID;
m_filament_setting_dlg->ams_id = ams_id_int; m_filament_setting_dlg->ams_id = ams_id_int;
m_filament_setting_dlg->tray_id = tray_id_int; m_filament_setting_dlg->tray_id = tray_id_int;
wxString k_val; wxString k_val;
wxString n_val; wxString n_val;
k_val = wxString::Format("%.3f", obj->vt_tray.k); k_val = wxString::Format("%.3f", obj->vt_slot[0].k);
n_val = wxString::Format("%.3f", obj->vt_tray.n); n_val = wxString::Format("%.3f", obj->vt_slot[0].n);
m_filament_setting_dlg->Move(wxPoint(current_position_x, current_position_y)); m_filament_setting_dlg->Move(wxPoint(current_position_x, current_position_y));
m_filament_setting_dlg->Popup(wxEmptyString, wxEmptyString, wxEmptyString, wxEmptyString, k_val, n_val); m_filament_setting_dlg->Popup(wxEmptyString, wxEmptyString, wxEmptyString, wxEmptyString, k_val, n_val);
} else { } else {
@ -3757,18 +3758,23 @@ void StatusPanel::on_ext_spool_edit(wxCommandEvent &event)
if (obj) { if (obj) {
m_filament_setting_dlg->obj = obj; m_filament_setting_dlg->obj = obj;
try { try {
m_filament_setting_dlg->tray_id = VIRTUAL_TRAY_ID; m_filament_setting_dlg->tray_id = VIRTUAL_TRAY_MAIN_ID;
std::string sn_number; std::string sn_number;
std::string filament; std::string filament;
std::string temp_max; std::string temp_max;
std::string temp_min; std::string temp_min;
wxString k_val; wxString k_val;
wxString n_val; wxString n_val;
k_val = wxString::Format("%.3f", obj->vt_tray.k); k_val = wxString::Format("%.3f", obj->vt_slot[0].k);
n_val = wxString::Format("%.3f", obj->vt_tray.n); n_val = wxString::Format("%.3f", obj->vt_slot[0].n);
wxColor color = AmsTray::decode_color(obj->vt_tray.color); wxColor color = AmsTray::decode_color(obj->vt_slot[0].color);
m_filament_setting_dlg->ams_filament_id = obj->vt_tray.setting_id; m_filament_setting_dlg->ams_filament_id = obj->vt_slot[0].setting_id;
std::vector<wxColour> cols;
for (auto col : obj->vt_slot[0].cols) {
cols.push_back(AmsTray::decode_color(col));
}
m_filament_setting_dlg->set_ctype(obj->vt_slot[0].ctype);
if (m_filament_setting_dlg->ams_filament_id.empty()) { if (m_filament_setting_dlg->ams_filament_id.empty()) {
m_filament_setting_dlg->set_empty_color(color); m_filament_setting_dlg->set_empty_color(color);
@ -3776,13 +3782,13 @@ void StatusPanel::on_ext_spool_edit(wxCommandEvent &event)
else { else {
m_filament_setting_dlg->set_color(color); m_filament_setting_dlg->set_color(color);
} }
m_filament_setting_dlg->m_is_third = !MachineObject::is_bbl_filament(obj->vt_tray.tag_uid); m_filament_setting_dlg->m_is_third = !MachineObject::is_bbl_filament(obj->vt_slot[0].tag_uid);
if (!m_filament_setting_dlg->m_is_third) { if (!m_filament_setting_dlg->m_is_third) {
sn_number = obj->vt_tray.uuid; sn_number = obj->vt_slot[0].uuid;
filament = obj->vt_tray.sub_brands; filament = obj->vt_slot[0].sub_brands;
temp_max = obj->vt_tray.nozzle_temp_max; temp_max = obj->vt_slot[0].nozzle_temp_max;
temp_min = obj->vt_tray.nozzle_temp_min; temp_min = obj->vt_slot[0].nozzle_temp_min;
} }
m_filament_setting_dlg->Move(wxPoint(current_position_x,current_position_y)); m_filament_setting_dlg->Move(wxPoint(current_position_x,current_position_y));
@ -3809,8 +3815,8 @@ void StatusPanel::on_ams_refresh_rfid(wxCommandEvent &event)
} }
std::string curr_ams_id = m_ams_control->GetCurentAms(); std::string curr_ams_id = m_ams_control->GetCurentAms();
// do not support refresh rfid for VIRTUAL_TRAY_ID // do not support refresh rfid for VIRTUAL_TRAY_MAIN_ID
if (curr_ams_id.compare(std::to_string(VIRTUAL_TRAY_ID)) == 0) { if (curr_ams_id.compare(std::to_string(VIRTUAL_TRAY_MAIN_ID)) == 0) {
return; return;
} }
std::string curr_can_id = event.GetString().ToStdString(); std::string curr_can_id = event.GetString().ToStdString();
@ -3839,7 +3845,7 @@ void StatusPanel::on_ams_selected(wxCommandEvent &event)
{ {
if (obj) { if (obj) {
std::string curr_ams_id = m_ams_control->GetCurentAms(); std::string curr_ams_id = m_ams_control->GetCurentAms();
if (curr_ams_id.compare(std::to_string(VIRTUAL_TRAY_ID)) == 0) { if (curr_ams_id.compare(std::to_string(VIRTUAL_TRAY_MAIN_ID)) == 0) {
//update_ams_control_state(curr_ams_id, true); //update_ams_control_state(curr_ams_id, true);
return; return;
} else { } else {

6
src/slic3r/GUI/Widgets/AMSControl.cpp
View File

@ -2651,7 +2651,7 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons
m_panel_virtual->SetMaxSize(wxSize(AMS_CAN_LIB_SIZE.x + FromDIP(16), AMS_CANS_SIZE.y)); m_panel_virtual->SetMaxSize(wxSize(AMS_CAN_LIB_SIZE.x + FromDIP(16), AMS_CANS_SIZE.y));
m_vams_info.material_state = AMSCanType::AMS_CAN_TYPE_VIRTUAL; m_vams_info.material_state = AMSCanType::AMS_CAN_TYPE_VIRTUAL;
m_vams_info.can_id = wxString::Format("%d", VIRTUAL_TRAY_ID).ToStdString(); m_vams_info.can_id = wxString::Format("%d", VIRTUAL_TRAY_MAIN_ID).ToStdString();
auto vams_panel = new wxWindow(m_panel_virtual, wxID_ANY); auto vams_panel = new wxWindow(m_panel_virtual, wxID_ANY);
vams_panel->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR); vams_panel->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR);
@ -3516,7 +3516,7 @@ void AMSControl::SwitchAms(std::string ams_id)
{ {
if(ams_id == m_current_show_ams){return;} if(ams_id == m_current_show_ams){return;}
if (ams_id != std::to_string(VIRTUAL_TRAY_ID)) { if (ams_id != std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
if (m_current_show_ams != ams_id) { if (m_current_show_ams != ams_id) {
m_current_show_ams = ams_id; m_current_show_ams = ams_id;
m_extruder->OnAmsLoading(false); m_extruder->OnAmsLoading(false);
@ -3554,7 +3554,7 @@ void AMSControl::SwitchAms(std::string ams_id)
} }
if (!ready_selected) { if (!ready_selected) {
m_current_ams = std::to_string(VIRTUAL_TRAY_ID); m_current_ams = std::to_string(VIRTUAL_TRAY_MAIN_ID);
m_vams_lib->OnSelected(); m_vams_lib->OnSelected();
} }
else { else {