3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-07-26 16:13:58 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

NEW:support for dynamic configuration files

Browse source 
Change-Id: Iec433ca1f75f223af68c5103013ff47d1acf1678
(cherry picked from commit 40acd7f6b11e9b2b3403a84b4b7d4b70da5d0ed2)
This commit is contained in:
tao wang 2023-08-17 12:47:46 +08:00 • committed by Lane.Wei
parent 5e23f73866
commit 23079b23df
20 changed files with 569 additions and 433 deletions
Download patch file Download diff file Expand all files Collapse all files

548
src/slic3r/GUI/DeviceManager.cpp
View file

@ -344,14 +344,11 @@ std::string MachineObject::parse_printer_type(std::string type_str)
return "BL-P001";
} else if (type_str.compare("BL-P001") == 0) {
return type_str;
} else if (type_str.compare("BL-P003") == 0) {
return type_str;
} else {
return DeviceManager::parse_printer_type(type_str);
}
return "";
}
std::string MachineObject::get_preset_printer_model_name(std::string printer_type)
{
return DeviceManager::get_printer_display_name(printer_type);
@ -364,7 +361,7 @@ std::string MachineObject::get_preset_printer_thumbnail_img(std::string printer_
wxString MachineObject::get_printer_type_display_str()
{
std::string display_name = get_preset_printer_model_name(printer_type);
std::string display_name = get_preset_printer_model_name(printer_type);
if (!display_name.empty())
return display_name;
else
@ -385,7 +382,6 @@ std::string MachineObject::get_ftp_folder()
return DeviceManager::get_ftp_folder(printer_type);
}
std::string MachineObject::get_access_code()
{
if (get_user_access_code().empty())
@ -1351,8 +1347,7 @@ int MachineObject::get_bed_temperature_limit()
return 120;
}
} else {
int limit = BED_TEMP_LIMIT;
DeviceManager::get_bed_temperature_limit(printer_type, limit);
int limit = bed_temperature_limit < 0?BED_TEMP_LIMIT:bed_temperature_limit;
return limit;
}
return BED_TEMP_LIMIT;
@ -1411,92 +1406,6 @@ std::string MachineObject::parse_version()
void MachineObject::parse_version_func()
{
auto ota_version = module_vers.find("ota");
auto esp32_version = module_vers.find("esp32");
auto rv1126_version = module_vers.find("rv1126");
if (get_printer_series() == PrinterSeries::SERIES_X1) {
if (ota_version != module_vers.end()) {
if (ota_version->second.sw_ver.compare("01.01.01.00") <= 0) {
ams_support_remain = false;
ams_support_auto_switch_filament_flag = false;
is_xcam_buildplate_supported = false;
xcam_support_recovery_step_loss = false;
is_support_send_to_sdcard = false;
is_support_1080dpi = false;
is_support_ai_monitoring = false;
is_support_ams_humidity = false;
} else {
ams_support_remain = true;
ams_support_auto_switch_filament_flag = true;
is_xcam_buildplate_supported = true;
xcam_support_recovery_step_loss = true;
is_support_send_to_sdcard = true;
is_support_1080dpi = true;
is_support_ai_monitoring = true;
is_support_ams_humidity = true;
}
if (ota_version != module_vers.end()) {
if (firmware_type == PrinterFirmwareType::FIRMWARE_TYPE_PRODUCTION) {
local_use_ssl_for_mqtt = ota_version->second.sw_ver.compare("01.03.01.04") >= 0;
}
if (lifecycle == PrinterFirmwareType::FIRMWARE_TYPE_PRODUCTION) {
is_support_mqtt_alive = ota_version->second.sw_ver.compare("01.05.06.05") >= 0;
}
else if (lifecycle == PrinterFirmwareType::FIRMWARE_TYPE_ENGINEER) {
is_support_mqtt_alive = ota_version->second.sw_ver.compare("00.03.10.05") >= 0;
}
else {
is_support_mqtt_alive = ota_version->second.sw_ver.compare("01.05.06.05") >= 0;
}
is_support_tunnel_mqtt = (ota_version->second.sw_ver.compare("01.05.06.06") >= 0
|| (rv1126_version != module_vers.end() && rv1126_version->second.sw_ver.compare("00.00.21.20") >= 0));
}
}
} else if (printer_type == "C11") {
is_cloud_print_only = true;
if (ota_version != module_vers.end()) {
is_support_send_to_sdcard = ota_version->second.sw_ver.compare("01.02.00.00") >= 0;
is_support_ai_monitoring = ota_version->second.sw_ver.compare("01.02.99.00") >= 0;
is_support_tunnel_mqtt = (ota_version->second.sw_ver.compare("01.03.50.01") >= 0 ||
(esp32_version != module_vers.end() && esp32_version->second.sw_ver.compare("01.05.15.00") >= 0));
}
if (esp32_version != module_vers.end()) {
ams_support_auto_switch_filament_flag = esp32_version->second.sw_ver.compare("00.03.11.50") >= 0;
}
if (ota_version != module_vers.end()) {
if (lifecycle == PrinterFirmwareType::FIRMWARE_TYPE_PRODUCTION) {
is_support_mqtt_alive = ota_version->second.sw_ver.compare("01.03.50.01") >= 0;
}
else if (lifecycle == PrinterFirmwareType::FIRMWARE_TYPE_ENGINEER) {
is_support_mqtt_alive = ota_version->second.sw_ver.compare("00.06.03.51") >= 0;
}
else {
is_support_mqtt_alive = ota_version->second.sw_ver.compare("01.03.50.01") >= 0;
}
}
} else if (printer_type == "C12") {
is_support_ai_monitoring = true;
is_cloud_print_only = true;
if (ota_version != module_vers.end()) {
is_support_tunnel_mqtt = (ota_version->second.sw_ver.compare("01.03.50.01") >= 0 ||
(esp32_version != module_vers.end() && esp32_version->second.sw_ver.compare("01.05.15.00") >= 0));
if (lifecycle == PrinterFirmwareType::FIRMWARE_TYPE_PRODUCTION) {
is_support_mqtt_alive = ota_version->second.sw_ver.compare("01.03.50.01") >= 0;
}
else if (lifecycle == PrinterFirmwareType::FIRMWARE_TYPE_ENGINEER) {
is_support_mqtt_alive = ota_version->second.sw_ver.compare("00.06.03.51") >= 0;
}
else {
is_support_mqtt_alive = ota_version->second.sw_ver.compare("01.03.50.01") >= 0;
}
}
}
}
bool MachineObject::is_studio_cmd(int sequence_id)
@ -1736,6 +1645,14 @@ int MachineObject::command_set_nozzle(int temp)
int MachineObject::command_set_chamber(int temp)
{
std::string gcode_str = (boost::format("M141 S%1%\n") % temp).str();
try {
json j;
j["temp_control"] = "chamber_temp";
NetworkAgent* agent = GUI::wxGetApp().getAgent();
if (agent) agent->track_event("printer_control", j.dump());
}
catch (...) {}
return this->publish_gcode(gcode_str);
}
@ -1744,19 +1661,30 @@ int MachineObject::command_ams_switch(int tray_index, int old_temp, int new_temp
BOOST_LOG_TRIVIAL(trace) << "ams_switch to " << tray_index << " with temp: " << old_temp << ", " << new_temp;
if (old_temp < 0) old_temp = FILAMENT_DEF_TEMP;
if (new_temp < 0) new_temp = FILAMENT_DEF_TEMP;
int tray_id_int = tray_index;
std::string gcode = "";
if (tray_index == 255) {
gcode = DeviceManager::load_gcode(printer_type, "ams_unload.gcode");
} else {
// include VIRTUAL_TRAY_ID
gcode = DeviceManager::load_gcode(printer_type, "ams_load.gcode");
boost::replace_all(gcode, "[next_extruder]", std::to_string(tray_index));
boost::replace_all(gcode, "[new_filament_temp]", std::to_string(new_temp));
int result = 0;
//command
if (is_support_command_ams_switch) {
command_ams_change_filament(tray_index, old_temp, new_temp);
}
else {
std::string gcode = "";
if (tray_index == 255) {
gcode = DeviceManager::load_gcode(printer_type, "ams_unload.gcode");
}
else {
// include VIRTUAL_TRAY_ID
gcode = DeviceManager::load_gcode(printer_type, "ams_load.gcode");
boost::replace_all(gcode, "[next_extruder]", std::to_string(tray_index));
boost::replace_all(gcode, "[new_filament_temp]", std::to_string(new_temp));
}
result = this->publish_gcode(gcode);
}
return this->publish_gcode(gcode);
return result;
}
int MachineObject::command_ams_change_filament(int tray_id, int old_temp, int new_temp)
@ -2211,8 +2139,7 @@ int MachineObject::command_get_flow_ratio_calibration_result(float nozzle_diamet
int MachineObject::command_unload_filament()
{
if (get_printer_series() == PrinterSeries::SERIES_X1
&& !this->is_function_supported(PrinterFunction::FUNC_VIRTUAL_TYAY)) {
if (get_printer_series() == PrinterSeries::SERIES_X1 && !ams_support_virtual_tray) {
// fixed gcode file
json j;
j["print"]["command"] = "gcode_file";
@ -2220,10 +2147,7 @@ int MachineObject::command_unload_filament()
j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
return this->publish_json(j.dump());
}
else if (printer_type == "C11"
|| (get_printer_series() == PrinterSeries::SERIES_X1
&& this->is_function_supported(PrinterFunction::FUNC_VIRTUAL_TYAY))
) {
else if (printer_type == "C11" || (get_printer_series() == PrinterSeries::SERIES_X1 && ams_support_virtual_tray) ) {
std::string gcode = DeviceManager::load_gcode(printer_type, "ams_unload.gcode");
if (gcode.empty()) {
return -1;
@ -2438,7 +2362,6 @@ void MachineObject::reset()
print_status = "";
last_mc_print_stage = -1;
m_new_ver_list_exist = false;
m_is_support_show_bak = false;
extruder_axis_status = LOAD;
nozzle_diameter = 0.0f;
@ -2457,11 +2380,6 @@ void MachineObject::set_print_state(std::string status)
print_status = status;
}
std::vector<std::string> MachineObject::get_compatible_machine()
{
return DeviceManager::get_compatible_machine(printer_type);
}
int MachineObject::connect(bool is_anonymous, bool use_openssl)
{
if (dev_ip.empty()) return -1;
@ -2535,91 +2453,6 @@ bool MachineObject::is_function_supported(PrinterFunction func)
{
std::string func_name;
switch (func) {
case FUNC_MONITORING:
func_name = "FUNC_MONITORING";
break;
case FUNC_TIMELAPSE:
func_name = "FUNC_TIMELAPSE";
break;
case FUNC_RECORDING:
func_name = "FUNC_RECORDING";
break;
case FUNC_FIRSTLAYER_INSPECT:
func_name = "FUNC_FIRSTLAYER_INSPECT";
break;
case FUNC_AI_MONITORING:
parse_version_func();
if (!is_support_ai_monitoring)
return false;
func_name = "FUNC_AI_MONITORING";
break;
case FUNC_LIDAR_CALIBRATION:
func_name = "FUNC_LIDAR_CALIBRATION";
break;
case FUNC_BUILDPLATE_MARKER_DETECT:
parse_version_func();
if (!is_xcam_buildplate_supported)
return false;
func_name = "FUNC_BUILDPLATE_MARKER_DETECT";
break;
case FUNC_AUTO_RECOVERY_STEP_LOSS:
parse_version_func();
if (!xcam_support_recovery_step_loss)
return false;
func_name = "FUNC_AUTO_RECOVERY_STEP_LOSS";
break;
case FUNC_FLOW_CALIBRATION:
func_name = "FUNC_FLOW_CALIBRATION";
break;
case FUNC_AUTO_LEVELING:
func_name = "FUNC_AUTO_LEVELING";
break;
case FUNC_CHAMBER_TEMP:
func_name = "FUNC_CHAMBER_TEMP";
break;
case FUNC_PRINT_WITHOUT_SD:
func_name = "FUNC_PRINT_WITHOUT_SD";
break;
case FUNC_USE_AMS:
func_name = "FUNC_USE_AMS";
break;
case FUNC_ALTER_RESOLUTION:
func_name = "FUNC_ALTER_RESOLUTION";
break;
case FUNC_SEND_TO_SDCARD:
parse_version_func();
if (!is_support_send_to_sdcard)
return false;
func_name = "FUNC_SEND_TO_SDCARD";
break;
case FUNC_AUTO_SWITCH_FILAMENT:
parse_version_func();
if (!ams_support_auto_switch_filament_flag)
return false;
func_name = "FUNC_AUTO_SWITCH_FILAMENT";
break;
case FUNC_CHAMBER_FAN:
func_name = "FUNC_CHAMBER_FAN";
break;
case FUNC_AUX_FAN:
func_name = "FUNC_AUX_FAN";
break;
case FUNC_EXTRUSION_CALI:
if (!ams_support_virtual_tray)
return false;
func_name = "FUNC_EXTRUSION_CALI";
break;
case FUNC_PRINT_ALL:
func_name = "FUNC_PRINT_ALL";
break;
case FUNC_VIRTUAL_TYAY:
if (!ams_support_virtual_tray)
return false;
func_name = "FUNC_VIRTUAL_TYAY";
break;
case FUNC_FILAMENT_BACKUP:
func_name = "FUNC_FILAMENT_BACKUP";
break;
default:
return true;
}
@ -2631,10 +2464,9 @@ std::vector<std::string> MachineObject::get_resolution_supported()
return camera_resolution_supported;
}
bool MachineObject::is_support_print_with_timelapse()
std::vector<std::string> MachineObject::get_compatible_machine()
{
//TODO version check, set true by default
return true;
return DeviceManager::get_compatible_machine(printer_type);
}
bool MachineObject::is_camera_busy_off()
@ -2713,6 +2545,11 @@ int MachineObject::parse_json(std::string payload)
this->set_online_state(true);
if (m_active_state == NotActive) m_active_state = Active;
std::chrono::system_clock::time_point curr_time = std::chrono::system_clock::now();
auto diff1 = std::chrono::duration_cast<std::chrono::microseconds>(curr_time - last_update_time);
BOOST_LOG_TRIVIAL(info) << "interval = " << diff1.count();
/* update last received time */
last_update_time = std::chrono::system_clock::now();
@ -2814,6 +2651,7 @@ int MachineObject::parse_json(std::string payload)
}
} catch (...) {}
if (j.contains("print")) {
json jj = j["print"];
int sequence_id = 0;
@ -2828,6 +2666,166 @@ int MachineObject::parse_json(std::string payload)
}
}
}
//supported function
if (jj.contains("support_chamber_temp_edit")) {
if (jj["support_chamber_temp_edit"].is_boolean()) {
is_support_chamber_edit = jj["support_chamber_temp_edit"].get<bool>();
}
}
if (jj.contains("support_extrusion_cali")) {
if (jj["support_extrusion_cali"].is_boolean()) {
is_support_extrusion_cali = jj["support_extrusion_cali"].get<bool>();
}
}
if (jj.contains("support_first_layer_inspect")) {
if (jj["support_first_layer_inspect"].is_boolean()) {
is_support_first_layer_inspect = jj["support_first_layer_inspect"].get<bool>();
}
}
if (jj.contains("support_ai_monitoring")) {
if (jj["support_ai_monitoring"].is_boolean()) {
is_support_ai_monitoring = jj["support_ai_monitoring"].get<bool>();
}
}
if (jj.contains("support_lidar_calibration")) {
if (jj["support_lidar_calibration"].is_boolean()) {
is_support_lidar_calibration = jj["support_lidar_calibration"].get<bool>();
}
}
if (jj.contains("support_build_plate_marker_detect")) {
if (jj["support_build_plate_marker_detect"].is_boolean()) {
is_support_build_plate_marker_detect = jj["support_build_plate_marker_detect"].get<bool>();
}
}
if (jj.contains("support_flow_calibration")) {
if (jj["support_flow_calibration"].is_boolean()) {
is_support_flow_calibration = jj["support_flow_calibration"].get<bool>();
}
}
if (jj.contains("support_print_without_sd")) {
if (jj["support_print_without_sd"].is_boolean()) {
is_support_print_without_sd = jj["support_print_without_sd"].get<bool>();
}
}
if (jj.contains("support_print_all")) {
if (jj["support_print_all"].is_boolean()) {
is_support_print_all = jj["support_print_all"].get<bool>();
}
}
if (jj.contains("support_send_to_sd")) {
if (jj["support_send_to_sd"].is_boolean()) {
is_support_send_to_sdcard = jj["support_send_to_sd"].get<bool>();
}
}
if (jj.contains("support_aux_fan")) {
if (jj["support_aux_fan"].is_boolean()) {
is_support_aux_fan = jj["support_aux_fan"].get<bool>();
}
}
if (jj.contains("support_chamber_fan")) {
if (jj["support_chamber_fan"].is_boolean()) {
is_support_chamber_fan = jj["support_chamber_fan"].get<bool>();
}
}
if (jj.contains("support_filament_backup")) {
if (jj["support_filament_backup"].is_boolean()) {
is_support_filament_backup = jj["support_filament_backup"].get<bool>();
}
}
if (jj.contains("support_update_remain")) {
if (jj["support_update_remain"].is_boolean()) {
is_support_update_remain = jj["support_update_remain"].get<bool>();
}
}
if (jj.contains("support_auto_leveling")) {
if (jj["support_auto_leveling"].is_boolean()) {
is_support_auto_leveling = jj["support_auto_leveling"].get<bool>();
}
}
if (jj.contains("support_auto_recovery_step_loss")) {
if (jj["support_auto_recovery_step_loss"].is_boolean()) {
is_support_auto_recovery_step_loss = jj["support_auto_recovery_step_loss"].get<bool>();
}
}
if (jj.contains("support_ams_humidity")) {
if (jj["support_ams_humidity"].is_boolean()) {
is_support_ams_humidity = jj["support_ams_humidity"].get<bool>();
}
}
if (jj.contains("support_prompt_sound")) {
if (jj["support_prompt_sound"].is_boolean()) {
is_support_prompt_sound = jj["support_prompt_sound"].get<bool>();
}
}
if (jj.contains("support_1080dpi")) {
if (jj["support_1080dpi"].is_boolean()) {
is_support_1080dpi = jj["support_1080dpi"].get<bool>();
}
}
if (jj.contains("support_cloud_print_only")) {
if (jj["support_cloud_print_only"].is_boolean()) {
is_support_cloud_print_only = jj["support_cloud_print_only"].get<bool>();
}
}
if (jj.contains("support_command_ams_switch")) {
if (jj["support_command_ams_switch"].is_boolean()) {
is_support_command_ams_switch = jj["support_command_ams_switch"].get<bool>();
}
}
if (jj.contains("support_mqtt_alive")) {
if (jj["support_mqtt_alive"].is_boolean()) {
is_support_mqtt_alive = jj["support_mqtt_alive"].get<bool>();
}
}
if (jj.contains("support_tunnel_mqtt")) {
if (jj["support_tunnel_mqtt"].is_boolean()) {
is_support_tunnel_mqtt = jj["support_tunnel_mqtt"].get<bool>();
}
}
if (jj.contains("support_timelapse")) {
if (jj["support_timelapse"].is_boolean()) {
is_support_timelapse = jj["support_timelapse"].get<bool>();
}
}
if (jj.contains("nozzle_max_temperature")) {
if (jj["nozzle_max_temperature"].is_number_integer()) {
nozzle_max_temperature = jj["nozzle_max_temperature"].get<int>();
}
}
if (jj.contains("bed_temperature_limit")) {
if (jj["bed_temperature_limit"].is_number_integer()) {
bed_temperature_limit = jj["bed_temperature_limit"].get<int>();
}
}
if (jj.contains("command")) {
if (jj["command"].get<std::string>() == "push_status") {
m_push_count++;
@ -3116,7 +3114,7 @@ int MachineObject::parse_json(std::string payload)
/*get filam_bak*/
try {
if (jj.contains("filam_bak")) {
m_is_support_show_bak = true;
is_support_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++) {
@ -3125,7 +3123,7 @@ int MachineObject::parse_json(std::string payload)
}
}
else {
m_is_support_show_bak = false;
is_support_filament_backup = false;
}
}
catch (...) {
@ -3406,9 +3404,9 @@ int MachineObject::parse_json(std::string payload)
else {
if (jj["xcam"].contains("buildplate_marker_detector")) {
xcam_buildplate_marker_detector = jj["xcam"]["buildplate_marker_detector"].get<bool>();
is_xcam_buildplate_supported = true;
is_support_build_plate_marker_detect = true;
} else {
is_xcam_buildplate_supported = false;
is_support_build_plate_marker_detect = false;
}
}
}
@ -3861,6 +3859,7 @@ int MachineObject::parse_json(std::string payload)
}
} else {
ams_support_virtual_tray = false;
is_support_extrusion_cali = false;
}
}
catch (...) {
@ -5053,62 +5052,44 @@ void DeviceManager::load_last_machine()
json DeviceManager::function_table = json::object();
json DeviceManager::filaments_blacklist = json::object();
std::string DeviceManager::get_string_from_config(std::string type_str, std::string item)
{
std::string config_file = Slic3r::resources_dir() + "/printers/" + type_str + ".json";
std::ifstream json_file(config_file.c_str());
try {
json jj;
if (json_file.is_open()) {
json_file >> jj;
if (jj.contains("00.00.00.00")) {
json const& printer = jj["00.00.00.00"];
if (printer.contains(item)) {
return printer[item].get<std::string>();
}
}
}
}
catch (...) {}
return "";
}
std::string DeviceManager::parse_printer_type(std::string type_str)
{
if (DeviceManager::function_table.contains("printers")) {
for (auto printer : DeviceManager::function_table["printers"]) {
if (printer.contains("model_id") && printer["model_id"].get<std::string>() == type_str) {
if (printer.contains("printer_type")) {
return printer["printer_type"].get<std::string>();
}
}
}
}
return "";
return get_string_from_config(type_str, "printer_type");
}
std::string DeviceManager::get_printer_display_name(std::string type_str)
{
if (DeviceManager::function_table.contains("printers")) {
for (auto printer : DeviceManager::function_table["printers"]) {
if (printer.contains("model_id") && printer["model_id"].get<std::string>() == type_str) {
if (printer.contains("display_name")) {
return printer["display_name"].get<std::string>();
}
}
}
}
return "";
return get_string_from_config(type_str, "display_name");
}
std::string DeviceManager::get_ftp_folder(std::string type_str)
{
if (DeviceManager::function_table.contains("printers")) {
for (auto printer : DeviceManager::function_table["printers"]) {
if (printer.contains("model_id") && printer["model_id"].get<std::string>() == type_str) {
if (printer.contains("ftp_folder")) {
return printer["ftp_folder"].get<std::string>();
}
}
}
}
return "";
return get_string_from_config(type_str, "ftp_folder");
}
std::string DeviceManager::get_printer_thumbnail_img(std::string type_str)
{
if (DeviceManager::function_table.contains("printers")) {
for (auto printer : DeviceManager::function_table["printers"]) {
if (printer.contains("model_id") && printer["model_id"].get<std::string>() == type_str) {
if (printer.contains("printer_thumbnail_image")) {
return printer["printer_thumbnail_image"].get<std::string>();
}
}
}
}
return "";
return get_string_from_config(type_str, "printer_thumbnail_image");
}
bool DeviceManager::is_function_supported(std::string type_str, std::string function_name)
{
if (DeviceManager::function_table.contains("printers")) {
@ -5127,9 +5108,15 @@ bool DeviceManager::is_function_supported(std::string type_str, std::string func
std::vector<std::string> DeviceManager::get_resolution_supported(std::string type_str)
{
std::vector<std::string> resolution_supported;
if (DeviceManager::function_table.contains("printers")) {
for (auto printer : DeviceManager::function_table["printers"]) {
if (printer.contains("model_id") && printer["model_id"].get<std::string>() == type_str) {
std::string config_file = Slic3r::resources_dir() + "/printers/" + type_str + ".json";
std::ifstream json_file(config_file.c_str());
try {
json jj;
if (json_file.is_open()) {
json_file >> jj;
if (jj.contains("00.00.00.00")) {
json const& printer = jj["00.00.00.00"];
if (printer.contains("camera_resolution")) {
for (auto res : printer["camera_resolution"])
resolution_supported.emplace_back(res.get<std::string>());
@ -5137,39 +5124,30 @@ std::vector<std::string> DeviceManager::get_resolution_supported(std::string typ
}
}
}
catch (...) {}
return resolution_supported;
}
bool DeviceManager::get_bed_temperature_limit(std::string type_str, int &limit)
std::vector<std::string> DeviceManager::get_compatible_machine(std::string type_str)
{
bool result = false;
if (DeviceManager::function_table.contains("printers")) {
for (auto printer : DeviceManager::function_table["printers"]) {
if (printer.contains("model_id") && printer["model_id"].get<std::string>() == type_str) {
if (printer.contains("bed_temperature_limit")) {
limit = printer["bed_temperature_limit"].get<int>();
return true;
std::vector<std::string> compatible_machine;
std::string config_file = Slic3r::resources_dir() + "/printers/" + type_str + ".json";
std::ifstream json_file(config_file.c_str());
try {
json jj;
if (json_file.is_open()) {
json_file >> jj;
if (jj.contains("00.00.00.00")) {
json const& printer = jj["00.00.00.00"];
if (printer.contains("compatible_machine")) {
for (auto res : printer["compatible_machine"])
compatible_machine.emplace_back(res.get<std::string>());
}
}
}
}
return result;
}
bool DeviceManager::get_nozzle_max_temperature(std::string type_str, int& limit)
{
bool result = false;
if (DeviceManager::function_table.contains("printers")) {
for (auto printer : DeviceManager::function_table["printers"]) {
if (printer.contains("model_id") && printer["model_id"].get<std::string>() == type_str) {
if (printer.contains("nozzle_max_temperature")) {
limit = printer["nozzle_max_temperature"].get<int>();
return true;
}
}
}
}
return result;
catch (...) {}
return compatible_machine;
}
bool DeviceManager::load_functional_config(std::string config_file)
@ -5292,20 +5270,4 @@ std::string DeviceManager::load_gcode(std::string type_str, std::string gcode_fi
return "";
}
std::vector<std::string> DeviceManager::get_compatible_machine(std::string type_str)
{
std::vector<std::string> compatible_machine;
if (DeviceManager::function_table.contains("printers")) {
for (auto printer : DeviceManager::function_table["printers"]) {
if (printer.contains("model_id") && printer["model_id"].get<std::string>() == type_str) {
if (printer.contains("compatible_machine")) {
for (auto res : printer["compatible_machine"])
compatible_machine.emplace_back(res.get<std::string>());
}
}
}
}
return compatible_machine;
}
} // namespace Slic3r