QIDITECH/QIDIStudio
1
0
Fork 0
mirror of https://github.com/QIDITECH/QIDIStudio.git synced 2026-02-07 12:21:50 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
6b46f9fd48c3821f85b1a25e125ef696bd46a003
QIDIStudio/src/slic3r/GUI/DeviceManager.hpp
QIDI TECH 5cdfef9f9e update slic3r
2025-09-17 12:32:36 +08:00

916 lines
32 KiB
C++
Raw Blame History

#ifndef slic3r_DeviceManager_hpp_
#define slic3r_DeviceManager_hpp_
#include <map>
#include <mutex>
#include <vector>
#include <string>
#include <memory>
#include <chrono>
#include <unordered_set>
#include <boost/thread.hpp>
#include <boost/nowide/fstream.hpp>
#include "nlohmann/json.hpp"
#include "libslic3r/ProjectTask.hpp"
#include "slic3r/Utils/json_diff.hpp"
#include "boost/bimap/bimap.hpp"
#include "CameraPopup.hpp"
#include "libslic3r/Calib.hpp"
#include "libslic3r/Utils.hpp"
#include "DeviceCore/DevDefs.h"
#include "DeviceCore/DevConfigUtil.h"
#include "DeviceCore/DevFirmware.h"
#include <wx/object.h>
#define USE_LOCAL_SOCKET_BIND 0
#define DISCONNECT_TIMEOUT 30000.f // milliseconds
#define PUSHINFO_TIMEOUT 15000.f // milliseconds
#define TIMEOUT_FOR_STRAT 20000.f // milliseconds
#define TIMEOUT_FOR_KEEPALIVE 5* 60 * 1000.f // milliseconds
#define REQUEST_PUSH_MIN_TIME 3000.f // milliseconds
#define REQUEST_START_MIN_TIME 15000.f // milliseconds
#define EXTRUSION_OMIT_TIME 20000.f // milliseconds
#define HOLD_TIMEOUT 10000.f // milliseconds
#define BED_TEMP_LIMIT 120
#define HOLD_COUNT_MAX 3
#define HOLD_COUNT_CAMERA 6
#define HOLD_TIME_3SEC 3 // 3 seconds
#define HOLD_TIME_6SEC 6 // 6 seconds
#define GET_VERSION_RETRYS 10
#define RETRY_INTERNAL 2000
#define START_SEQ_ID 20000
#define END_SEQ_ID 30000
#define SUBSCRIBE_RETRY_COUNT 5
using namespace nlohmann;
namespace Slic3r {
namespace GUI
{
class DeviceErrorDialog; // Previous definitions
}
class NetworkAgent;
enum ManualPaCaliMethod {
PA_LINE = 0,
PA_PATTERN,
};
#define UpgradeNoError 0
#define UpgradeDownloadFailed -1
#define UpgradeVerfifyFailed -2
#define UpgradeFlashFailed -3
#define UpgradePrinting -4
// Previous definitions
class DevAms;
class DevAmsTray;
class DevBed;
class DevConfig;
class DevCtrl;
class DevExtderSystem;
class DevFan;
class DevFilaSystem;
class DevPrintOptions;
class DevHMS;
class DevLamp;
class DevNozzleSystem;
class DeviceManager;
class DevStorage;
struct DevPrintTaskRatingInfo;
class MachineObject
{
private:
NetworkAgent * m_agent{nullptr};
DeviceManager* m_manager{ nullptr };
std::shared_ptr<int> m_token = std::make_shared<int>(1);
/* properties */
std::string dev_id;
std::string dev_name;
std::string dev_ip;
std::string access_code;
std::string user_access_code;
// type, time stamp, delay
std::vector<std::tuple<std::string, uint64_t, uint64_t>> message_delay;
/*parts*/
DevLamp* m_lamp;
DevExtderSystem* m_extder_system;
DevNozzleSystem* m_nozzle_system;
DevFilaSystem* m_fila_system;
DevFan* m_fan;
DevBed * m_bed;
DevStorage* m_storage;
/*Ctrl*/
DevCtrl* m_ctrl;
/*Print Options/Speed*/
DevPrintOptions* m_print_options;
/*HMS*/
DevHMS* m_hms_system;
/*Config*/
DevConfig* m_config;
public:
MachineObject(DeviceManager* manager, NetworkAgent* agent, std::string name, std::string id, std::string ip);
~MachineObject();
public:
enum ActiveState {
NotActive,
Active,
UpdateToDate
};
enum PrintOption {
PRINT_OP_AUTO_RECOVERY = 0,
PRINT_OP_MAX,
};
public:
/* static members and functions */
static inline int m_sequence_id = START_SEQ_ID;
/* properties */
std::string get_dev_name() const { return dev_name; }
void set_dev_name(std::string val) { dev_name = val; }
std::string get_dev_ip() const { return dev_ip; }
void set_dev_ip(std::string ip) { dev_ip = ip; }
std::string get_dev_id() const { return dev_id; }
void set_dev_id(std::string val) { dev_id = val; }
//y
std::string dev_url;
std::string dev_apikey;
float nozzle_diameter { 0.0f };
bool local_use_ssl_for_mqtt { true };
bool local_use_ssl_for_ftp { true };
std::string get_ftp_folder();
int subscribe_counter{3};
std::string dev_connection_type; /* lan | cloud */
std::string connection_type() const { return dev_connection_type; }
bool is_lan_mode_printer() { return dev_connection_type == "lan"; }
bool is_cloud_mode_printer() { return dev_connection_type == "cloud"; }
std::chrono::system_clock::time_point last_cloud_msg_time_;
std::chrono::system_clock::time_point last_lan_msg_time_;
bool HasRecentCloudMessage();
bool HasRecentLanMessage();
std::string dev_connection_name; /* lan | eth */
/*access code*/
bool has_access_right() const { return !get_access_code().empty(); }
std::string get_access_code() const;
void set_access_code(std::string code, bool only_refresh = true);
/*user access code*/
void set_user_access_code(std::string code, bool only_refresh = true);
void erase_user_access_code();
std::string get_user_access_code() const;
//PRINTER_TYPE printer_type = PRINTER_3DPrinter_UKNOWN;
std::string printer_type; /* model_id */
std::string get_show_printer_type() const;
PrinterSeries get_printer_series() const;
PrinterArch get_printer_arch() const;
std::string get_printer_ams_type() const;
wxString get_printer_type_display_str() const;
std::string get_auto_pa_cali_thumbnail_img_str() const;
// check printer device series
std::string get_printer_series_str() const;
static bool is_series_n(const std::string& series_str);
static bool is_series_p(const std::string& series_str);
static bool is_series_x(const std::string& series_str);
static bool is_series_o(const std::string& series_str);
bool is_series_n() const;
bool is_series_p() const;
bool is_series_x() const;
bool is_series_o() const;
void reload_printer_settings();
std::string get_printer_thumbnail_img_str() const;
std::string dev_product_name; // set by iot service, get /user/print
std::string bind_user_name;
std::string bind_user_id;
std::string bind_sec_link;
std::string bind_ssdp_version;
std::string bind_state; /* free | occupied */
bool is_avaliable() { return bind_state == "free"; }
time_t last_alive;
bool m_is_online;
bool m_lan_mode_connection_state{false};
bool m_set_ctt_dlg{ false };
void set_lan_mode_connection_state(bool state) {m_lan_mode_connection_state = state;};
bool get_lan_mode_connection_state() {return m_lan_mode_connection_state;};
void set_ctt_dlg( wxString text);
int parse_msg_count = 0;
int keep_alive_count = 0;
std::chrono::system_clock::time_point last_update_time; /* last received print data from machine */
std::chrono::system_clock::time_point last_utc_time; /* last received print data from machine */
std::chrono::system_clock::time_point last_keep_alive; /* last received print data from machine */
std::chrono::system_clock::time_point last_push_time; /* last received print push from machine */
std::chrono::system_clock::time_point last_request_push; /* last received print push from machine */
std::chrono::system_clock::time_point last_request_start; /* last received print push from machine */
bool device_cert_installed = false;
int m_active_state = 0; // 0 - not active, 1 - active, 2 - update-to-date
bool is_tunnel_mqtt = false;
//AmsTray vt_tray; // virtual tray
long ams_exist_bits = 0;
long tray_exist_bits = 0;
long tray_is_qdt_bits = 0;
long tray_read_done_bits = 0;
long tray_reading_bits = 0;
bool ams_air_print_status { false };
bool ams_support_virtual_tray { true };
time_t ams_user_setting_start = 0;
time_t ams_switch_filament_start = 0;
AmsStatusMain ams_status_main;
int ams_status_sub;
int ams_version = 0;
int extrusion_cali_hold_count = 0;
std::chrono::system_clock::time_point last_extrusion_cali_start_time;
int extrusion_cali_set_tray_id = -1;
std::chrono::system_clock::time_point extrusion_cali_set_hold_start;
std::string extrusion_cali_filament_name;
bool is_in_extrusion_cali();
bool is_extrusion_cali_finished();
/* AMS */
DevAms* get_curr_Ams();
DevAmsTray* get_curr_tray();
DevAmsTray* get_ams_tray(std::string ams_id, std::string tray_id);;
std::string get_filament_id(std::string ams_id, std::string tray_id) const;
std::string get_filament_type(const std::string& ams_id, const std::string& tray_id) const;
// parse amsStatusMain and ams_status_sub
void _parse_ams_status(int ams_status);
bool is_ams_unload();
bool can_unload_filament();
bool is_support_amx_ext_mix_mapping() const { return true;}
void get_ams_colors(std::vector<wxColour>& ams_colors);
/*extruder*/
bool is_main_extruder_on_left() const { return false; } // only means the extruder is on the left hand when extruder id is 0
bool is_multi_extruders() const;
int get_extruder_id_by_ams_id(const std::string& ams_id);
/* ams settings*/
bool IsDetectOnInsertEnabled() const;;
//bool IsDetectOnPowerupEnabled() const { return m_enable_detect_on_powerup; }
//bool IsDetectRemainEnabled() const { return m_enable_detect_remain; }
//bool IsAutoRefillEnabled() const { return m_enable_auto_refill; }
[[nodiscard]] bool is_nozzle_flow_type_supported() const { return is_enable_np; };
[[nodiscard]] wxString get_nozzle_replace_url() const;
/*online*/
bool online_rfid;
bool online_ahb;
int online_version = -1;
int last_online_version = -1;
/* temperature */
float chamber_temp;
float chamber_temp_target;
float frame_temp;
/* signals */
std::string wifi_signal;
std::string link_th;
std::string link_ams;
bool network_wired { false };
/* parts */
DevExtderSystem* GetExtderSystem() const { return m_extder_system; }
DevNozzleSystem* GetNozzleSystem() const { return m_nozzle_system;}
DevFilaSystem* GetFilaSystem() const { return m_fila_system;}
bool HasAms() const;
DevLamp* GetLamp() const { return m_lamp; }
DevFan* GetFan() const { return m_fan; }
DevBed * GetBed() const { return m_bed; };
DevStorage *GetStorage() const { return m_storage; }
DevCtrl* GetCtrl() const { return m_ctrl; } /* ctrl*/
DevHMS* GetHMS() const { return m_hms_system; } /* hms*/
DevConfig* GetConfig() const { return m_config; } /* config*/
DevPrintOptions* GetPrintOptions() const { return m_print_options; } /* print options */
DevPrintingSpeedLevel GetPrintingSpeedLevel() const; /* print speed */
/* upgrade */
bool upgrade_force_upgrade { false };
bool upgrade_new_version { false };
bool upgrade_consistency_request { false };
DevFirmwareUpgradingState upgrade_display_state;
int upgrade_display_hold_count = 0;
PrinterFirmwareType firmware_type; // engineer|production
PrinterFirmwareType lifecycle { PrinterFirmwareType::FIRMWARE_TYPE_PRODUCTION };
std::string upgrade_progress;
std::string upgrade_message;
std::string upgrade_status;
std::string upgrade_module;
std::string ams_new_version_number;
std::string ota_new_version_number;
std::string ahb_new_version_number;
int get_version_retry = 0;
DevFirmwareVersionInfo air_pump_version_info;
DevFirmwareVersionInfo laser_version_info;
DevFirmwareVersionInfo cutting_module_version_info;
DevFirmwareVersionInfo extinguish_version_info;
std::map<std::string, DevFirmwareVersionInfo> module_vers;
std::map<std::string, DevFirmwareVersionInfo> new_ver_list;
bool m_new_ver_list_exist = false;
int upgrade_err_code = 0;
std::vector<FirmwareInfo> firmware_list;
std::string get_firmware_type_str();
std::string get_lifecycle_type_str();
bool is_in_upgrading();
bool is_upgrading_avalable();
int get_upgrade_percent();
std::string get_ota_version();
bool check_version_valid();
wxString get_upgrade_result_str(int upgrade_err_code);
// key: ams_id start as 0,1,2,3
std::map<int, DevFirmwareVersionInfo> get_ams_version();
void clear_version_info();
void store_version_info(const DevFirmwareVersionInfo& info);
/* printing */
std::string print_type;
//float nozzle { 0.0f }; // default is 0.0f as initial value
bool is_220V_voltage { false };
int mc_print_stage;
int mc_print_sub_stage;
int mc_print_error_code;
int mc_print_line_number;
int mc_print_percent; /* left print progess in percent */
int mc_left_time; /* left time in seconds */
int last_mc_print_stage;
int m_home_flag = 0;
int hw_switch_state;
bool is_system_printing();
int print_error;
static std::string get_error_code_str(int error_code);
std::string get_print_error_str() const { return MachineObject::get_error_code_str(this->print_error); }
std::unordered_set<GUI::DeviceErrorDialog*> m_command_error_code_dlgs;
void add_command_error_code_dlg(int command_err);
int curr_layer = 0;
int total_layers = 0;
bool is_support_layer_num { false };
bool nozzle_blob_detection_enabled{ false };
time_t nozzle_blob_detection_hold_start = 0;
bool is_support_new_auto_cali_method{false};
int last_cali_version = -1;
int cali_version = -1;
float cali_selected_nozzle_dia { 0.0 };
// 1: record when start calibration in preset page
// 2: reset when start calibration in start page
// 3: save tray_id, filament_id, setting_id, and name, nozzle_dia
std::vector<CaliPresetInfo> selected_cali_preset;
float cache_flow_ratio { 0.0 };
bool cali_finished = true;
FlowRatioCalibrationType flow_ratio_calibration_type = FlowRatioCalibrationType::COMPLETE_CALIBRATION;
ManualPaCaliMethod manual_pa_cali_method = ManualPaCaliMethod::PA_LINE;
bool has_get_pa_calib_tab{ false };
bool request_tab_from_qds { false };
std::vector<PACalibResult> pa_calib_tab;
bool get_pa_calib_result { false };
std::vector<PACalibResult> pa_calib_results;
bool get_flow_calib_result { false };
std::vector<FlowRatioCalibResult> flow_ratio_results;
void reset_pa_cali_history_result()
{
has_get_pa_calib_tab = false;
pa_calib_tab.clear();
}
void reset_pa_cali_result() {
get_pa_calib_result = false;
pa_calib_results.clear();
}
void reset_flow_rate_cali_result() {
get_flow_calib_result = false;
flow_ratio_results.clear();
}
bool check_pa_result_validation(PACalibResult& result);
std::vector<int> stage_list_info;
int stage_curr = 0;
int m_push_count = 0;
int m_full_msg_count = 0; /*the full message count, there are full or diff messages from network*/
bool calibration_done { false };
bool is_axis_at_home(std::string axis);
bool is_filament_at_extruder();
wxString get_curr_stage();
int get_curr_stage_idx();
bool is_in_calibration();
bool is_calibration_running();
bool is_calibration_done();
void parse_state_changed_event();
void parse_home_flag(int flag);
/* printing status */
std::string print_status; /* enum string: FINISH, SLICING, RUNNING, PAUSE, INIT, FAILED */
int queue_number = 0;
std::string iot_print_status; /* iot */
int printing_speed_mag = 100;
int get_bed_temperature_limit();
bool is_filament_installed();
/* camera */
bool has_ipcam { false };
bool camera_recording { false };
bool camera_recording_when_printing { false };
bool camera_timelapse { false };
time_t camera_recording_ctl_start = 0;
int camera_timelapse_hold_count = 0;
int camera_resolution_hold_count = 0;
std::string camera_resolution = "";
std::vector<std::string> camera_resolution_supported;
bool xcam_first_layer_inspector { false };
time_t xcam_first_layer_hold_start = 0;
std::string local_rtsp_url;
std::string tutk_state;
enum LiveviewLocal {
LVL_None,
LVL_Disable,
LVL_Local,
LVL_Rtsps,
LVL_Rtsp
} liveview_local{ LVL_None };
enum LiveviewRemote {
LVR_None,
LVR_Tutk,
LVR_Agora,
LVR_TutkAgora
} liveview_remote{ LVR_None };
enum FileLocal {
FL_None,
FL_Local
} file_local{ FL_None };
enum FileRemote {
FR_None,
FR_Tutk,
FR_Agora,
FR_TutkAgora
} file_remote{ FR_None };
enum PlateMakerDectect : int
{
POS_CHECK = 1,
TYPE_POS_CHECK = 2,
};
enum DoorOpenCheckState : int
{
DOOR_OPEN_CHECK_DISABLE = 0,/*do nothing*/
DOOR_OPEN_CHECK_ENABLE_WARNING = 1,/*warning*/
DOOR_OPEN_CHECK_ENABLE_PAUSE_PRINT = 2,/*pause print*/
};
enum DeviceMode : unsigned int
{
DEVICE_MODE_FDM = 0x00000001,
DEVICE_MODE_LASER = 0x00000010,
DEVICE_MODE_CUT = 0x00000100,
};
bool file_model_download{false};
bool virtual_camera{false};
bool xcam_ai_monitoring{ false };
bool xcam_disable_ai_detection_display{false};
bool xcam_spaghetti_detection{false};
bool xcam_purgechutepileup_detection{false};
bool xcam_nozzleclumping_detection{false};
bool xcam_airprinting_detection{false};
time_t xcam_ai_monitoring_hold_start = 0;
std::string xcam_ai_monitoring_sensitivity;
std::string xcam_spaghetti_detection_sensitivity;
std::string xcam_purgechutepileup_detection_sensitivity;
std::string xcam_nozzleclumping_detection_sensitivity;
std::string xcam_airprinting_detection_sensitivity;
bool xcam_buildplate_marker_detector{ false };
time_t xcam_buildplate_marker_hold_start = 0;
bool xcam_auto_recovery_step_loss{ false };
bool xcam_allow_prompt_sound{ false };
bool xcam_filament_tangle_detect{ false };
time_t xcam_auto_recovery_hold_start = 0;
time_t xcam_prompt_sound_hold_start = 0;
time_t xcam_filament_tangle_detect_hold_start = 0;
// part skip
std::vector<int> m_partskip_ids;
/*target from Studio-SwitchBoard, default to INVALID_NOZZLE_ID if no switching control from PC*/
int targ_nozzle_id_from_pc = INVALID_EXTRUDER_ID;
//supported features
bool is_support_build_plate_marker_detect{false};
PlateMakerDectect m_plate_maker_detect_type{ POS_CHECK };
/*PA flow calibration is using in sending print*/
bool is_support_pa_calibration{false};
bool is_support_flow_calibration{false};
bool is_support_send_to_sdcard {false};
bool is_support_filament_backup{false};
bool is_support_timelapse{false};
bool is_support_update_remain{false};
int is_support_bed_leveling = 0;/*0: false; 1; on/off 2: auto/on/off*/
bool is_support_auto_recovery_step_loss{false};
bool is_support_ams_humidity {false};
bool is_support_prompt_sound{false};
bool is_support_filament_tangle_detect{false};
bool is_support_1080dpi {false};
bool is_support_cloud_print_only {false};
bool is_support_command_ams_switch{false};
bool is_support_mqtt_alive {false};
bool is_support_tunnel_mqtt{false};
bool is_support_motor_noise_cali{false};
bool is_support_wait_sending_finish{false};
bool is_support_user_preset{false};
bool is_support_nozzle_blob_detection{false};
bool is_support_air_print_detection{false};
bool is_support_agora{false};
bool is_support_upgrade_kit{false};
bool is_support_filament_setting_inprinting{false};
bool is_support_internal_timelapse { false };// fun[28], support timelapse without SD card
bool m_support_mqtt_homing { false };// fun[32]
bool is_support_brtc{false}; // fun[31], support tcp and upload protocol
bool is_support_ext_change_assist{false};
bool is_support_partskip{false};
// refine printer function options
bool is_support_spaghetti_detection{false};
bool is_support_purgechutepileup_detection{false};
bool is_support_nozzleclumping_detection{false};
bool is_support_airprinting_detection{false};
bool installed_upgrade_kit{false};
int bed_temperature_limit = -1;
/*nozzle temp range*/
std::vector<int> nozzle_temp_range;
/*temp temp range*/
std::vector<int> bed_temp_range;
/* machine mqtt apis */
int connect(bool use_openssl = true);
int disconnect();
json_diff print_json;
/* Project Task and Sub Task */
std::string project_id_;
std::string profile_id_;
std::string task_id_;
std::string subtask_id_;
std::string job_id_;
std::string last_subtask_id_;
QDTSliceInfo* slice_info {nullptr};
boost::thread* get_slice_info_thread { nullptr };
boost::thread* get_model_task_thread { nullptr };
/* job attr */
int jobState_ = 0;
/* key: sequence id, value: callback */
bool is_makeworld_subtask();
/* device type */
DeviceMode m_device_mode{ DEVICE_MODE_FDM };
inline bool is_fdm_type() const { return m_device_mode == DEVICE_MODE_FDM; }
int m_plate_index { -1 };
std::string m_gcode_file;
int gcode_file_prepare_percent = 0;
QDTSubTask* subtask_;
QDTModelTask *model_task { nullptr };
DevPrintTaskRatingInfo* rating_info { nullptr };
int request_model_result = 0;
bool get_model_mall_result_need_retry = false;
std::string obj_subtask_id; // subtask_id == 0 for sdcard
std::string subtask_name;
bool is_sdcard_printing();
bool is_timelapse();
bool is_recording_enable();
bool is_recording();
int get_liveview_remote();
int get_file_remote();
// y40 y59
MachineObject(std::string name);
MachineObject(std::string name, std::string url, std::string ip, std::string apikey = "");
MachineObject(NetworkAgent* agent, std::string name, std::string id, std::string ip);
std::string parse_version();
void parse_version_func();
bool is_studio_cmd(int seq);
/* quick check*/
bool canEnableTimelapse(wxString& error_message) const;
/* command commands */
int command_get_version(bool with_retry = true);
int command_request_push_all(bool request_now = false);
int command_pushing(std::string cmd);
int command_clean_print_error(std::string task_id, int print_error);
int command_clean_print_error_uiop(int print_error);
int command_set_printer_nozzle(std::string nozzle_type, float diameter);
int command_set_printer_nozzle2(int id, std::string nozzle_type, float diameter);
int command_get_access_code();
/* command upgrade */
int command_upgrade_confirm();
int command_consistency_upgrade_confirm();
int command_upgrade_firmware(FirmwareInfo info);
int command_upgrade_module(std::string url, std::string module_type, std::string version);
/* control apis */
int command_xyz_abs();
int command_auto_leveling();
int command_go_home();
int command_task_abort();
/* cancelled the job_id */
int command_task_partskip(std::vector<int> part_ids);
int command_task_cancel(std::string job_id);
int command_task_pause();
int command_task_resume();
int command_hms_idle_ignore(const std::string &error_str, int type);
int command_hms_resume(const std::string& error_str, const std::string& job_id);
int command_hms_ignore(const std::string& error_str, const std::string& job_id);
int command_hms_stop(const std::string &error_str, const std::string &job_id);
/* buzzer*/
int command_stop_buzzer();
/* temp*/
bool m_support_mqtt_bet_ctrl = false;
int command_set_bed(int temp);
int command_set_nozzle(int temp);
int command_set_nozzle_new(int nozzle_id, int temp);
int command_set_chamber(int temp);
int check_resume_condition();
// ams controls
//int command_ams_switch(int tray_index, int old_temp = 210, int new_temp = 210);
int command_ams_change_filament(bool load, std::string ams_id, std::string slot_id, int old_temp = 210, int new_temp = 210);
int command_ams_user_settings(int ams_id, bool start_read_opt, bool tray_read_opt, bool remain_flag = false);
int command_ams_switch_filament(bool switch_filament);
int command_ams_air_print_detect(bool air_print_detect);
int command_ams_calibrate(int ams_id);
int command_ams_filament_settings(int ams_id, int slot_id, std::string filament_id, std::string setting_id, std::string tray_color, std::string tray_type, int nozzle_temp_min, int nozzle_temp_max);
int command_ams_select_tray(std::string tray_id);
int command_ams_refresh_rfid(std::string tray_id);
int command_ams_refresh_rfid2(int ams_id, int slot_id);
int command_ams_control(std::string action);
int command_ams_drying_stop();
int command_start_extrusion_cali(int tray_index, int nozzle_temp, int bed_temp, float max_volumetric_speed, std::string setting_id = "");
int command_stop_extrusion_cali();
int command_extrusion_cali_set(int tray_index, std::string setting_id, std::string name, float k, float n, int bed_temp = -1, int nozzle_temp = -1, float max_volumetric_speed = -1);
// set printing speed
int command_set_printing_speed(DevPrintingSpeedLevel lvl);
//set prompt sound
int command_set_prompt_sound(bool prompt_sound);
//set fliament tangle detect
int command_set_filament_tangle_detect(bool fliament_tangle_detect);
// set print option
int command_set_printing_option(bool auto_recovery);
int command_nozzle_blob_detect(bool nozzle_blob_detect);
// axis string is X, Y, Z, E
bool m_support_mqtt_axis_control = false;
int command_axis_control(std::string axis, double unit = 1.0f, double input_val = 1.0f, int speed = 3000);
int command_extruder_control(int nozzle_id, double val);
// calibration printer
bool is_support_command_calibration();
int command_start_calibration(bool vibration, bool bed_leveling, bool xcam_cali, bool motor_noise, bool nozzle_cali, bool bed_cali);
// PA calibration
int command_start_pa_calibration(const X1CCalibInfos& pa_data, int mode = 0); // 0: automatic mode; 1: manual mode. default: automatic mode
int command_set_pa_calibration(const std::vector<PACalibResult>& pa_calib_values, bool is_auto_cali);
int command_delete_pa_calibration(const PACalibIndexInfo& pa_calib);
int command_get_pa_calibration_tab(const PACalibExtruderInfo& calib_info);
//w
int command_get_pa_calibration_tab(float nozzle_diameter, const std::string &filament_id);
int command_get_pa_calibration_result(float nozzle_diameter);
int commnad_select_pa_calibration(const PACalibIndexInfo& pa_calib_info);
// flow ratio calibration
int command_start_flow_ratio_calibration(const X1CCalibInfos& calib_data);
int command_get_flow_ratio_calibration_result(float nozzle_diameter);
// camera control
int command_ipcam_record(bool on_off);
int command_ipcam_timelapse(bool on_off);
int command_ipcam_resolution_set(std::string resolution);
int command_xcam_control(std::string module_name, bool on_off, std::string lvl = "");
//refine printer
int command_xcam_control_ai_monitoring(bool on_off, std::string lvl);
int command_xcam_control_spaghetti_detection(bool on_off, std::string lvl);
int command_xcam_control_purgechutepileup_detection(bool on_off, std::string lvl);
int command_xcam_control_nozzleclumping_detection(bool on_off, std::string lvl);
int command_xcam_control_airprinting_detection(bool on_off, std::string lvl);
int command_xcam_control_first_layer_inspector(bool on_off, bool print_halt);
int command_xcam_control_buildplate_marker_detector(bool on_off);
int command_xcam_control_auto_recovery_step_loss(bool on_off);
int command_xcam_control_allow_prompt_sound(bool on_off);
int command_xcam_control_filament_tangle_detect(bool on_off);
/* common apis */
inline bool is_local() { return !get_dev_ip().empty(); }
void set_bind_status(std::string status);
std::string get_bind_str();
bool can_print();
bool can_resume();
bool can_pause();
bool can_abort();
bool is_in_printing();
bool is_in_printing_pause() const;
bool is_in_prepare();
bool is_printing_finished();
bool is_core_xy();
void reset_update_time();
void reset();
static bool is_in_printing_status(std::string status);
void set_print_state(std::string status);
bool is_connected();
bool is_connecting();
void set_online_state(bool on_off);
bool is_online() { return m_is_online; }
bool is_info_ready(bool check_version = true) const;
bool is_security_control_ready() const;
bool is_camera_busy_off();
std::vector<std::string> get_resolution_supported();
std::vector<std::string> get_compatible_machine();
/* Msg for display MsgFn */
typedef std::function<void(std::string topic, std::string payload)> MsgFn;
int publish_json(const json& json_item, int qos = 0, int flag = 0) ;
int publish_json(const std::string& json_str, int qos = 0, int flag = 0) = delete;
int cloud_publish_json(std::string json_str, int qos = 0, int flag = 0);
int local_publish_json(std::string json_str, int qos = 0, int flag = 0);
int parse_json(std::string tunnel, std::string payload, bool key_filed_only = false);
int publish_gcode(std::string gcode_str);
void update_device_cert_state(bool ready);
static std::string setting_id_to_type(std::string setting_id, std::string tray_type);
QDTSubTask* get_subtask();
QDTModelTask* get_modeltask();
void set_modeltask(QDTModelTask* task);
void update_model_task();
void free_slice_info();
void update_slice_info(std::string project_id, std::string profile_id, std::string subtask_id, int plate_idx);
bool m_firmware_valid { false };
bool m_firmware_thread_started { false };
void get_firmware_info();
bool is_firmware_info_valid();
/*for more extruder*/
bool is_enable_np{ false };
bool is_enable_ams_np{ false };
/*vi slot data*/
std::vector<DevAmsTray> vt_slot;
DevAmsTray parse_vt_tray(json vtray);
/*get ams slot info*/
bool contains_tray(const std::string &ams_id, const std::string &tray_id) const;
DevAmsTray get_tray(const std::string &ams_id, const std::string &tray_id) const;/*use contains_tray() check first*/
/*for parse new info*/
bool check_enable_np(const json& print) const;
void parse_new_info(json print);
int get_flag_bits(std::string str, int start, int count = 1) const;
int get_flag_bits(int num, int start, int count = 1, int base = 10) const;
/* Device Filament Check */
struct FilamentData
{
std::set<std::string> checked_filament;
std::string printer_preset_name;
std::map<std::string, std::pair<int, int>> filament_list; // filament_id, pair<min temp, max temp>
};
std::map<std::string, FilamentData> m_nozzle_filament_data;
void update_filament_list();
void update_printer_preset_name();
void check_ams_filament_valid();
/* xcam door open check*/
bool support_door_open_check() const { return is_support_door_open_check;};
DoorOpenCheckState get_door_open_check_state() const { return xcam_door_open_check;};
void command_set_door_open_check(DoorOpenCheckState state);
/* xcam save remove print file to local*/
bool get_save_remote_print_file_to_storage() const { return xcam__save_remote_print_file_to_storage; };
void command_set_save_remote_print_file_to_storage(bool save);
private:
/* xcam door open check*/
bool is_support_door_open_check = false;
DoorOpenCheckState xcam_door_open_check = DoorOpenCheckState::DOOR_OPEN_CHECK_DISABLE;
time_t xcam_door_open_check_start_time = 0;
/* xcam save remove print file to local*/
bool xcam__save_remote_print_file_to_storage = false;
time_t xcam__save_remote_print_file_to_storage_start_time = 0;
};
// change the opacity
void change_the_opacity(wxColour& colour);
wxString get_stage_string(int stage);
}; // namespace Slic3r
#endif // slic3r_DeviceManager_hpp_
Reference in New Issue View Git Blame Copy Permalink