QIDITECH/QIDI_Q1_Pro
1
0
Fork 0
mirror of https://github.com/QIDITECH/QIDI_Q1_Pro.git synced 2026-01-30 23:48:43 +03:00
Code Issues Packages Projects Releases 7 Wiki Activity
Files
16e6ad674ba588ac49c5272032a259555dba1aa9
QIDI_Q1_Pro/src/event.cpp
CChen616 0ce78cc607 V4.4.19 update
2024-05-03 09:57:27 +08:00

3672 lines
126 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#include <iostream>
#include <set>
#include <stack>
#include <algorithm>
// #include <boost/algorithm/string.hpp>
#include <cstdio>
#include <memory>
#include <stdexcept>
#include <array>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <fstream>
#include <string>
#include <sstream>
#include <map>
#include "../include/KlippyGcodes.h"
#include "../include/send_msg.h"
#include "../include/event.h"
#include "../include/mks_printer.h"
#include "../include/mks_file.h"
#include "../include/mks_update.h"
#include "../include/mks_wpa_cli.h"
#include "../include/mks_test.h"
#include "../include/MakerbaseSerial.h"
#include "../include/MakerbaseClient.h"
#include "../include/MakerbaseShell.h"
#include "../include/MakerbasePanel.h"
#include "../include/MakerbaseParseIni.h"
#include "../include/MakerbaseWiFi.h"
#include "../include/MakerbaseNetwork.h"
#include "../include/ui.h"
#include "../include/send_jpg.h"
#include <nlohmann/json.hpp>
#define DEFAULT_DIR "gcodes/"
extern int tty_fd;
extern MakerbaseClient *ep;
extern bool gimage_is_showed;
extern bool simage_is_showed;
extern int current_page_id; // 当前页面的id号
extern int previous_page_id; // 上一页面的id号
extern int next_page_id; // 下一页面的id号
/* Printer Extern Varible*/
extern bool mks_led_status;
extern bool mks_beep_status;
extern bool mks_fila_status;
extern int mks_language_status;
extern int mks_extruder_target;
extern int mks_heater_bed_target;
extern int mks_hot_target;
extern std::string mks_babystep_value;
extern std::string mks_adxl_offset;
extern std::string mks_version_soc;
extern std::string mks_version_mcu;
extern std::string mks_version_ui;
extern std::string printer_webhooks_state;
extern std::string printer_webhooks_state_message;
extern std::string current_webhooks_state_message;
extern float printer_gcode_move_speed_factor;
float current_speed_factor = 0;
extern float printer_gcode_move_speed;
float current_extruder_factor = 0;
extern float printer_gcode_move_extrude_factor;
extern float printer_gcode_move_homing_origin[4]; // [X, Y, Z, E] - 返回应用于每个轴的“gcode 偏移”。例如，可以检查“Z”轴以确定通过“babystepping”应用了多少偏移量。
extern float printer_gcode_move_position[4];
extern float printer_gcode_move_gcode_position[4];
extern std::string printer_toolhead_homed_axes;
extern float printer_toolhead_print_time;
extern float printer_toolhead_extimated_print_time;
extern double printer_toolhead_position[4];
extern double printer_toolhead_axis_minimum[4];
extern double printer_toolhead_axis_maximum[4];
extern double x_position;
extern double y_position;
extern double z_position;
extern float e_position;
extern double gcode_z_position;
extern int printer_extruder_temperature;
int current_extruder_temperature = 0;
extern int printer_extruder_target;
int current_extruder_target = 0;
extern int printer_heater_bed_temperature;
int current_heater_bed_temperature = 0;
extern int printer_heater_bed_target;
int current_heater_bed_target = 0;
extern int printer_hot_temperature;
int current_hot_temperature = 0;
extern int printer_hot_target;
int current_hot_target = 0;
extern float printer_fan_speed;
extern float printer_heater_fan_speed;
extern float printer_heater_fan_my_nozzle_fan1_speed;
extern float printer_out_pin_fan0_value;
float current_out_pin_fan0_value = 0;
extern float printer_out_pin_fan3_value;
float current_out_pin_fan3_value =0;
extern float printer_out_pin_fan2_value;
float current_out_pin_fan2_value = 0;
extern float printer_out_pin_beep_value;
extern std::string printer_idle_timeout_state;
extern float printer_printing_time;
extern std::string printer_print_stats_filename;
extern float printer_print_stats_total_duration;
extern float printer_print_stats_print_duration;
extern float printer_print_stats_filament_used;
extern std::string printer_print_stats_state; // 这个状态很有用
extern std::string printer_print_stats_message; // error detected, error message
extern std::string printer_display_status_message;
extern int printer_display_status_progress;
extern float auto_level_dist;
extern bool auto_level_finished;
extern bool auto_level_enabled;
std::string str_manual_level_offset;
extern float manual_level_dist;
extern int manual_level_count;
extern bool manual_level_finished;
extern float printer_bed_mesh_mesh_min[2];
extern float printer_bed_mesh_mesh_max[2];
extern float printer_bed_mesh_profiles_mks_points[5][5];
extern float printer_bed_mesh_profiles_mks_mesh_params_tension;
extern float printer_bed_mesh_profiles_mks_mesh_params_mesh_x_pps;
extern std::string printer_bed_mesh_profiles_mks_mesh_params_algo;
extern float printer_bed_mesh_profiles_mks_mesh_params_min_x;
extern float printer_bed_mesh_profiles_mks_mesh_params_min_y;
extern float printer_bed_mesh_profiles_mks_mesh_params_x_count;
extern float printer_bed_mesh_profiles_mks_mesh_params_y_count;
extern float printer_bed_mesh_profiles_mks_mesh_params_mesh_y_pps;
extern float printer_bed_mesh_profiles_mks_mesh_params_max_x;
extern float printer_bed_mesh_profiles_mks_mesh_params_max_y;
extern float page_set_zoffset_x_y_position[16][2];
extern float page_set_zoffset_z_position[16];
extern bool fresh_page_set_zoffset_data;
extern bool refresh_page_auto_finish_data;
extern int page_set_zoffset_index;
// filament switch sensor fila
extern bool filament_switch_sensor_fila_filament_detected;
extern bool filament_switch_sensor_fila_enabled;
extern float printer_caselight_value;
extern int printer_pause_taget;
extern bool printer_pause_resume_is_paused;
extern float printer_set_offset;
extern float printer_z_offset;
extern float printer_intern_z_offset;
extern float printer_extern_z_offset;
extern float printer_move_dist;
extern int printer_filament_extruder_target;
extern int printer_filament_extruedr_dist;
// probe
extern float printer_probe_x_zoffset;
extern float printer_probe_y_zoffset;
extern float printer_probe_z_zoffset;
// printer info software version
extern std::string printer_info_software_version;
/* wifi */
extern std::string page_wifi_ssid_list[5];
extern int page_wifi_current_pages;
extern int page_wifi_ssid_list_pages;
extern std::string get_wifi_name;
/* 文件列表处理相关变量 */
// extern std::set<std::string> page_files_dirname_filename_list;
extern bool filelist_changed;
extern int page_files_pages;
extern int page_files_current_pages;
extern int page_files_folder_layers;
extern std::string page_files_previous_path;
extern std::string page_files_root_path;
extern std::string page_files_path;
extern std::string page_files_list_name[9]; // 文件列表显示文件名称
extern std::string page_files_list_show_name[9]; // 文件列表名称
extern std::string page_files_list_show_type[9]; // 文件类型: [f]或者[d]，或者[n]
extern std::stack<std::string> page_files_path_stack; // 路径栈
extern std::string page_files_root_path; // Klippy根目录
extern std::string page_files_previous_path; // 之前的路径
extern std::string page_files_path; // 文件所在路径
extern std::string page_files_print_files_path; // 要打印的文件路径
extern int file_metadata_estimated_time;
extern std::string file_metadata_filename;
extern float file_metadata_filament_total;
extern int file_metadata_object_height;
extern std::string file_metadata_filament_name;
extern std::string file_metadata_filament_type;
extern float file_metadata_filament_weight_total;
extern std::string file_metadata_gimage;
extern std::string file_metadata_simage;
extern int level_mode;
extern bool printing_keyboard_enabled;
// extern bool filament_keyboard_enabled;
extern bool auto_level_button_enabled;
extern bool manual_level_button_enabled;
extern bool show_preview_complete;
extern bool show_preview_gimage_completed;
/* 补偿值 */
float page_set_zoffset_number;
/* 共振补偿值 */
std::string page_syntony_shaper_freq_x = "";
std::string page_syntony_shaper_freq_y = "";
bool page_syntony_finished = false;
/* PID调节 */
bool page_pid_finished = false;
/* wifi */
extern struct mks_wifi_status_result_t status_result;
extern struct mks_wifi_status_t wpa_status;
std::string wifi_ip_address;
/* 打完关机 */
bool page_printing_shutdown_enable = false;
/* wifi键盘打开判断 */
extern bool printing_wifi_keyboard_enabled;
/* refresh about success*/
bool page_about_successed = false;
extern bool is_download_to_screen; // main.cpp 里面的变量
/* update page */
extern int filesize;
/* server history totals */
extern int total_jobs;
extern double total_time;
extern double total_print_time;
extern double total_filament_used;
/* 800个小时 */
int mks_total_printed_minutes;
/* 设置打印调平的目标温度 */
extern int level_mode_printing_extruder_target;
extern int level_mode_printing_heater_bed_target;
extern bool level_mode_printing_is_printing_level;
/* wifi 相关 */
std::string current_connected_ssid_name = "";
extern bool page_wifi_list_ssid_button_enabled[5];
// page print filament
extern bool page_print_filament_extrude_restract_button;
extern bool page_filament_extrude_button;
// oobe开箱引导
bool mks_oobe_enabled = false;
bool current_mks_oobe_enabled = false;
// 调平
bool start_pre_auto_level = false;
bool start_pre_manual_level = false;
bool all_level_saving = false;
extern bool mks_file_parse_finished;
// reset
// extern bool page_reset_to_about;
// 正在保存页面
bool is_refresh_page_saving = false;
std::string temp_idle_state = "";
// oobe
extern float oobe_printer_set_offset;
//extern std::string printed_file_path;
bool jump_to_print = false;
int printer_auto_level_heater_bed_target;
extern std::string filament_message;
bool printer_ready = false;
extern bool page_filament_unload_button;
extern bool printer_bed_leveling;
//4.4.1 CLL 耗材确认弹窗新增不再提示按钮
extern bool preview_pop_1_on;
extern bool preview_pop_2_on;
//4.4.1 CLL 修复断料检测与退料冲突bug
bool previous_filament_sensor_state = false;
//4.4.1 CLL 修改调平
std::string previous_zoffset;
//4.4.2 CLL 新增息屏功能
extern bool previous_caselight_value;
//4.4.2 CLL 修改调平不再需要设置zoffset值
bool step_1 = false;
bool step_2 = false;
bool step_3 = false;
bool step_4 = false;
//4.4.2 CLL 适配mates和霍尔耗材宽度探测器
bool filament_detected = true;
//4.4.2 CLL 文件列表新增本地、U盘切换按钮
extern std::string file_mode;
extern int manual_count;
float bed_offset;
extern std::string adjust_mode;
extern std::string set_mode;
extern bool move_fan_setting;
extern std::string thumbnail_path;
extern bool cache_clicked;
int unhomed_move_mode = 0; // CLL 用于保存上次按下的移动按钮，当触发需先归位操作时进行移动, 1(x up),2(x down),3(y up),4(y down),5(z up),6(z down)
// CLL 以下变量用于修复gcode响应函数和refresh函数之间的冲突(gcode响应函数需设置变量在refresh_page_show中统一改变页面，否则会产生冲突)
bool jump_to_move_pop_1 = false;
bool jump_to_move_pop_2 = false;
bool jump_to_detect_error = false;
bool jump_to_level_error = false;
bool jump_to_filament_pop_1 = false;
bool jump_to_print_low_temp = false;
bool jump_to_memory_warning = false;
bool jump_to_resume_print = false;
std::string error_message;
bool main_picture_detected = false; // CLL 此变量用于检测cache中图片是否存在
bool main_picture_refreshed = false; // CLL 此变量用于标记主页面图片是否已经刷新过，防止反复刷新
extern int load_target;
int connection_method; // CLL 此变量用于记录二维码是否是局域网刷新 0为局域网连接，1为互联网连接
std::map<int, Server_config> serverConfigs;
std::string selected_server;
int current_server_page;
int total_server_count;
std::string target_soc_version;
bool open_qr_refreshed = false; // CLL 第一次开机刷新时不使用脚本重新生成二维码图片
extern bool qr_refreshed;
bool open_reprint_asked = false; // CLL 开机后进入主页面发出检测断电续打指令
int mks_ethernet;
/* 更新页面处理 */
void refresh_page_show() {
// CLL 以下if检测函数为无条件跳转，其在改变为true之前已经经过函数判断(跳转页面前需将对应变量置为false,否则会陷入死循环)
if (jump_to_move_pop_1 == true) {
jump_to_move_pop_1 = false;
page_to(TJC_PAGE_MOVE_POP_1);
}
if (jump_to_move_pop_2 == true) {
switch (unhomed_move_mode)
{
case 1: // X_UP
ep->Send(json_run_a_gcode("SET_KINEMATIC_POSITION Z=150\nSET_KINEMATIC_POSITION X=150\nSET_KINEMATIC_POSITION Y=150\n"));
ep->Send(json_run_a_gcode("G91\nG1 X10 F3000\nG90\nM84\n"));
break;
case 2: // X_DOWN
ep->Send(json_run_a_gcode("SET_KINEMATIC_POSITION Z=150\nSET_KINEMATIC_POSITION X=150\nSET_KINEMATIC_POSITION Y=150\n"));
ep->Send(json_run_a_gcode("G91\nG1 X-10 F3000\nG90\nM84\n"));
break;
case 3: // Y_UP
ep->Send(json_run_a_gcode("SET_KINEMATIC_POSITION Z=150\nSET_KINEMATIC_POSITION X=150\nSET_KINEMATIC_POSITION Y=150\n"));
ep->Send(json_run_a_gcode("G91\nG1 Y10 F3000\nG90\nM84\n"));
break;
case 4: // Y_DOWN
ep->Send(json_run_a_gcode("SET_KINEMATIC_POSITION Z=150\nSET_KINEMATIC_POSITION X=150\nSET_KINEMATIC_POSITION Y=150\n"));
ep->Send(json_run_a_gcode("G91\nG1 Y-10 F3000\nG90\nM84\n"));
break;
case 5: // Z_UP
ep->Send(json_run_a_gcode("SET_KINEMATIC_POSITION Z=150\nSET_KINEMATIC_POSITION X=150\nSET_KINEMATIC_POSITION Y=150\n"));
ep->Send(json_run_a_gcode("G91\nG1 Z-10 F600\nG90\nM84\n"));
break;
case 6: // Z_DOWN
ep->Send(json_run_a_gcode("SET_KINEMATIC_POSITION Z=150\nSET_KINEMATIC_POSITION X=150\nSET_KINEMATIC_POSITION Y=150\n"));
ep->Send(json_run_a_gcode("G91\nG1 Z10 F600\nG90\nM84\n"));
break;
default:
break;
}
unhomed_move_mode = 0;
jump_to_move_pop_2 = false;
page_to(TJC_PAGE_MOVE_POP_2);
}
if (jump_to_detect_error == true) {
jump_to_detect_error = false;
page_to(TJC_PAGE_DETECT_ERROR);
send_cmd_txt(tty_fd, "t0", error_message);
}
if (jump_to_level_error == true) {
jump_to_level_error = false;
page_to(TJC_PAGE_LEVEL_ERROR);
}
if (jump_to_filament_pop_1 == true) {
jump_to_filament_pop_1 = false;
page_to(TJC_PAGE_FILAMENT_POP_1);
}
if (jump_to_print_low_temp == true) {
jump_to_print_low_temp = false;
page_to(TJC_PAGE_PRINT_LOW_TEMP);
}
if (jump_to_resume_print == true) {
jump_to_resume_print = false;
page_to(TJC_PAGE_RESUME_PRINT);
}
if (jump_to_memory_warning == true) {
jump_to_memory_warning = false;
page_to(TJC_PAGE_MEMORY_WARNING);
}
if (current_page_id != TJC_PAGE_PRINTING) {
switch (current_page_id)
{
case TJC_PAGE_PRINT_ZOFFSET:
break;
case TJC_PAGE_PRINT_FILAMENT:
break;
case TJC_PAGE_PRINT_STOP:
case TJC_PAGE_PRINT_NO_FILAMENT:
case TJC_PAGE_PRINT_NO_FILAMENT_2:
case TJC_PAGE_SHUTDOWN:
case TJC_PAGE_PRINT_STOPPING:
case TJC_PAGE_MOVE_POP_1:
case TJC_PAGE_GCODE_ERROR:
case TJC_PAGE_DETECT_ERROR:
case TJC_PAGE_RESET:
case TJC_PAGE_PREVIEW:
case TJC_PAGE_PREVIEW_POP_1:
case TJC_PAGE_PREVIEW_POP_2:
case TJC_PAGE_PRINTING_2:
case TJC_PAGE_FILAMENT_POP_2:
case TJC_PAGE_FILAMENT_POP_3:
break;
default:
if (printer_print_stats_state == "printing") {
if (printer_print_stats_filename != "") {
main_picture_detected = false;
main_picture_refreshed = false;
MKSLOG_BLUE("跳入到打印函数\n");
sleep(1);
get_file_estimated_time(printer_print_stats_filename);
sleep(1);
//4.4.2 CLL 新增息屏功能
if (previous_caselight_value == true) {
led_on_off();
previous_caselight_value = false;
}
jump_to_print = true;
printer_ready = false;
page_to(TJC_PAGE_PREVIEW);
break;
}
}
break;
}
}
if (current_page_id != TJC_PAGE_RESET) {
switch (current_page_id)
{
case TJC_PAGE_GCODE_ERROR:
case TJC_PAGE_DETECT_ERROR:
case TJC_PAGE_LEVEL_ERROR:
case TJC_PAGE_SHUTDOWN:
case TJC_PAGE_SERVICE:
case TJC_PAGE_LANGUAGE:
case TJC_PAGE_COMMON_SETTING:
case TJC_PAGE_SLEEP_MODE:
case TJC_PAGE_INTERNET:
case TJC_PAGE_WIFI_LIST:
case TJC_PAGE_WIFI_KB:
case TJC_PAGE_WIFI_CONNECT:
case TJC_PAGE_WIFI_FAILED:
case TJC_PAGE_WIFI_SUCCESS:
case TJC_PAGE_WIFI_SAVING:
case TJC_PAGE_UPDATE_FOUND:
case TJC_PAGE_UPDATE_NOT_FOUND:
case TJC_PAGE_UPDATING:
case TJC_PAGE_UPDATE_FINISH:
case TJC_PAGE_RESTORE_CONFIG:
case TJC_PAGE_SHOW_QR:
case TJC_PAGE_SERVER_SET:
case TJC_PAGE_UPDATE_MODE:
case TJC_PAGE_ONLINE_UPDATE:
case TJC_PAGE_SEARCH_SERVER:
break;
default:
// 喷头板断开的情况下跳到重启页面
if (printer_webhooks_state == "shutdown" || printer_webhooks_state == "error") {
if (printer_webhooks_state == "shutdown" && (current_page_id == TJC_PAGE_AUTO_MOVING || current_page_id == TJC_PAGE_OPEN_CALIBRATE)) {
break;
}
if (previous_caselight_value == true) {
led_on_off();
previous_caselight_value = false;
}
page_to(TJC_PAGE_RESET);
std::cout << "重启页面" << std::endl;
if (current_webhooks_state_message != printer_webhooks_state_message) {
current_webhooks_state_message = printer_webhooks_state_message;
std::string temp = printer_webhooks_state_message;
replace(temp.begin(), temp.end(), '\n', '.');
replace(temp.begin(), temp.end(), '\'', ' ');
replace(temp.begin(), temp.end(), '\"', ' ');
send_cmd_txt(tty_fd, "t0", temp);
}
}
break;
}
} else if (current_page_id == TJC_PAGE_RESET) {
if (printer_webhooks_state == "shutdown" || printer_webhooks_state == "error") {
if (current_webhooks_state_message != printer_webhooks_state_message) {
current_webhooks_state_message = printer_webhooks_state_message;
std::string temp = printer_webhooks_state_message;
replace(temp.begin(), temp.end(), '\n', '.');
replace(temp.begin(), temp.end(), '\'', ' ');
replace(temp.begin(), temp.end(), '\"', ' ');
send_cmd_txt(tty_fd, "t0", temp);
}
}
if (printer_webhooks_state == "ready") {
page_to(TJC_PAGE_SYS_OK);
}
}
switch (current_page_id)
{
case TJC_PAGE_MAIN:
refresh_page_main();
break;
case TJC_PAGE_PREVIEW:
refresh_page_preview();
break;
case TJC_PAGE_PRINTING:
case TJC_PAGE_PRINTING_2:
refresh_page_printing();
break;
case TJC_PAGE_PRINT_FILAMENT:
refresh_page_print_filament();
break;
case TJC_PAGE_MOVE:
refresh_page_move();
break;
case TJC_PAGE_PRINT_ZOFFSET:
refresh_page_printing_zoffset();
break;
case TJC_PAGE_AUTO_MOVING:
refresh_page_auto_moving();
break;
case TJC_PAGE_AUTO_FINISH:
refresh_page_auto_finish();
break;
case TJC_PAGE_SYNTONY_MOVE:
refresh_page_syntony_move();
break;
case TJC_PAGE_SYNTONY_FINISH:
// refresh_page_syntony_finish();
break;
case TJC_PAGE_PRINT_STOPPING:
refresh_page_stopping();
break;
case TJC_PAGE_PRE_BED_CALIBRATION:
refresh_page_auto_level();
break;
case TJC_PAGE_WIFI_LIST:
refresh_page_wifi_list_2();
break;
case TJC_PAGE_OPEN_FILAMENTVIDEO_2:
refresh_page_open_filament_video_2();
break;
case TJC_PAGE_ZOFFSET:
refresh_page_zoffset();
break;
case TJC_PAGE_AUTO_HEATERBED:
refresh_page_auto_heaterbed();
break;
case TJC_PAGE_OPEN_HEATERBED:
refresh_page_open_heaterbed();
break;
case TJC_PAGE_FILAMENT_POP_2:
case TJC_PAGE_FILAMENT_POP_3:
refresh_page_filament_pop();
break;
case TJC_PAGE_PREVIEW_POP_1:
case TJC_PAGE_PREVIEW_POP_2:
refresh_page_preview_pop();
break;
//4.4.2 CLL 文件列表新增本地、U盘切换按钮
case TJC_PAGE_FILE_LIST:
// refresh_page_files_list_2();
break;
case TJC_PAGE_BED_MOVING:
refresh_page_bed_moving();
break;
case TJC_PAGE_OPEN_CALIBRATE:
refresh_page_open_calibrate();
break;
case TJC_PAGE_COMMON_SETTING:
refresh_page_common_setting();
break;
case TJC_PAGE_FILAMENT_SET_FAN:
refresh_page_filament_set_fan();
break;
case TJC_PAGE_WIFI_KB:
refresh_page_wifi_keyboard();
break;
case TJC_PAGE_FILAMENT:
refresh_page_filament();
break;
case TJC_PAGE_SHOW_QR:
refresh_page_show_qr();
break;
case TJC_PAGE_SERVER_SET:
refresh_page_server_set();
break;
case TJC_PAGE_AUTO_UNLOAD:
refresh_page_auto_unload();
break;
default:
break;
}
}
void refresh_page_open_filament_video_2() {
if (printer_extruder_target == 0) {
send_cmd_pco(tty_fd, "t0", "65535");
send_cmd_pco(tty_fd, "n0", "65535");
send_cmd_picc(tty_fd, "b3", "9");
send_cmd_picc2(tty_fd, "b3", "25");
} else {
send_cmd_pco(tty_fd, "t0", "63488");
send_cmd_pco(tty_fd, "n0", "63488");
send_cmd_picc(tty_fd, "b3", "10");
send_cmd_picc2(tty_fd, "b3", "24");
}
send_cmd_txt(tty_fd, "t0", std::to_string(printer_extruder_temperature) + "/");
send_cmd_val(tty_fd, "n0", std::to_string(printer_extruder_target));
}
void refresh_page_wifi_keyboard() {
if (printing_wifi_keyboard_enabled == true) {
send_cmd_txt(tty_fd, "t0", get_wifi_name);
}
}
void refresh_page_syntony_finish() {
MKSLOG_BLUE("Printer ide_timeout state: %s", printer_idle_timeout_state.c_str());
MKSLOG_BLUE("Printer webhooks state: %s", printer_webhooks_state.c_str());
if (page_syntony_finished == false) {
page_syntony_finished = true;
all_level_saving = false;
}
if (printer_idle_timeout_state == "Ready" && printer_webhooks_state == "ready") {
MKSLOG_BLUE("Printer webhooks state: %s", printer_webhooks_state.c_str());
sleep(10);
system("sync"); // 保存好配置文件
all_level_saving = false;
init_mks_status(); // 重启后初始化之前保存的参数
sub_object_status();
get_object_status();
sleep(10);
page_to(TJC_PAGE_LEVEL_MODE);
MKSLOG_RED("从739行跳出去");
}
}
void refresh_page_auto_level() {
if (auto_level_dist == (float)0.01) {
send_cmd_picc(tty_fd, "b0", "113");
send_cmd_picc(tty_fd, "b1", "114");
send_cmd_picc(tty_fd, "b2", "114");
send_cmd_picc(tty_fd, "b3", "114");
send_cmd_picc2(tty_fd, "b0", "116");
send_cmd_picc2(tty_fd, "b1", "115");
send_cmd_picc2(tty_fd, "b2", "115");
send_cmd_picc2(tty_fd, "b3", "115");
} else if (auto_level_dist == (float)0.05) {
send_cmd_picc(tty_fd, "b0", "114");
send_cmd_picc(tty_fd, "b1", "113");
send_cmd_picc(tty_fd, "b2", "114");
send_cmd_picc(tty_fd, "b3", "114");
send_cmd_picc2(tty_fd, "b0", "115");
send_cmd_picc2(tty_fd, "b1", "116");
send_cmd_picc2(tty_fd, "b2", "115");
send_cmd_picc2(tty_fd, "b3", "115");
} else if (auto_level_dist == (float)0.1) {
send_cmd_picc(tty_fd, "b0", "114");
send_cmd_picc(tty_fd, "b1", "114");
send_cmd_picc(tty_fd, "b2", "113");
send_cmd_picc(tty_fd, "b3", "114");
send_cmd_picc2(tty_fd, "b0", "115");
send_cmd_picc2(tty_fd, "b1", "115");
send_cmd_picc2(tty_fd, "b2", "116");
send_cmd_picc2(tty_fd, "b3", "115");
} else if (auto_level_dist == (float)0.5) {
send_cmd_picc(tty_fd, "b0", "114");
send_cmd_picc(tty_fd, "b1", "114");
send_cmd_picc(tty_fd, "b2", "114");
send_cmd_picc(tty_fd, "b3", "113");
send_cmd_picc2(tty_fd, "b0", "115");
send_cmd_picc2(tty_fd, "b1", "115");
send_cmd_picc2(tty_fd, "b2", "115");
send_cmd_picc2(tty_fd, "b3", "116");
}
}
void refresh_page_stopping() {
MKSLOG_BLUE("Printer ide_timeout state: %s", printer_idle_timeout_state.c_str());
MKSLOG_BLUE("Printer webhooks state: %s", printer_webhooks_state.c_str());
if (printer_idle_timeout_state == "Ready") {
clear_previous_data();
sleep(5);
save_current_zoffset();
page_to(TJC_PAGE_MAIN);
}
}
void refresh_page_syntony_move() {
if (temp_idle_state != printer_idle_timeout_state) {
temp_idle_state = printer_idle_timeout_state;
MKSLOG_BLUE("Printer ide_timeout state: %s", printer_idle_timeout_state.c_str());
MKSLOG_BLUE("Printer webhooks state: %s", printer_webhooks_state.c_str());
}
if (step_1 == true) {
sleep(15);
page_to(TJC_PAGE_SYNTONY_FINISH);
step_1 = false;
}
}
void refresh_page_print_filament() {
send_cmd_txt(tty_fd, "t5", printer_print_stats_filename.substr(printer_print_stats_filename.rfind("/") +1 ));
if (printer_extruder_target == 0) {
send_cmd_pco(tty_fd, "t2", "65535");
send_cmd_picc(tty_fd, "b0", "63");
send_cmd_picc2(tty_fd, "b0", "64");
} else {
send_cmd_pco(tty_fd, "t2", "63488");
send_cmd_picc(tty_fd, "b0", "62");
send_cmd_picc2(tty_fd, "b0", "65");
}
send_cmd_val(tty_fd, "j0", std::to_string(printer_display_status_progress));
send_cmd_val(tty_fd, "n7", std::to_string(printer_display_status_progress));
send_cmd_txt(tty_fd, "t2", std::to_string(printer_extruder_temperature));
send_cmd_txt(tty_fd, "t3", std::to_string(printer_extruder_target));
send_cmd_txt(tty_fd, "t0", show_time((int)(printer_print_stats_print_duration)));
send_cmd_txt(tty_fd, "t1", show_time(get_cal_printing_time((int)(printer_print_stats_print_duration), file_metadata_estimated_time, printer_display_status_progress)));
if (printer_print_stats_state == "paused") {
printer_ready = true;
}
//4.4.2 CLL 适配mates和霍尔耗材宽度检测器
if (filament_detected == false) {
sleep(1);
printer_ready = false;
set_print_pause();
page_to(TJC_PAGE_PRINT_NO_FILAMENT);
}
if (printer_print_stats_state == "printing") {
if (printer_ready == true) {
printer_ready = false;
page_to(TJC_PAGE_PRINTING);
}
}
if (printer_print_stats_state == "standby") {
page_to(TJC_PAGE_PRINT_STOPPING);
}
if (printer_print_stats_state == "error") {
page_to(TJC_PAGE_GCODE_ERROR);
cancel_print();
clear_previous_data();
send_cmd_txt(tty_fd, "t0", "gcode error:" + error_message);
}
//4.4.2 CLL 长时间暂停使打印停止后会跳转页面
if (printer_idle_timeout_state == "Idle") {
ep->Send(json_run_a_gcode("G28\n"));
cancel_print();
}
}
void refresh_page_auto_finish() {
if ( printer_idle_timeout_state == "Idle" && printer_webhooks_state == "ready" ) {
auto_level_finished = true;
}
}
void refresh_page_auto_moving() {
send_cmd_txt(tty_fd, "t5", "(" + std::to_string(printer_heater_bed_temperature) + "/" + std::to_string(printer_heater_bed_target) + ")");
if (step_1 == true) {
send_cmd_picc(tty_fd, "q0", "109");
send_cmd_pco(tty_fd, "t1", "65535");
send_cmd_pco(tty_fd, "t0", "38066");
send_cmd_vis(tty_fd, "gm1", "0");
send_cmd_vis(tty_fd, "gm2", "1");
step_1 = false;
}
if (step_2 == true) {
send_cmd_picc(tty_fd, "q0", "110");
send_cmd_pco(tty_fd, "t2", "65535");
send_cmd_pco(tty_fd, "t1", "38066");
send_cmd_vis(tty_fd, "gm2", "0");
send_cmd_vis(tty_fd, "gm3", "1");
step_2 = false;
}
if (step_3 == true) {
send_cmd_picc(tty_fd, "q0", "111");
send_cmd_pco(tty_fd, "t3", "65535");
send_cmd_pco(tty_fd, "t2", "38066");
send_cmd_vis(tty_fd, "gm3", "0");
send_cmd_vis(tty_fd, "gm4", "1");
step_3 = false;
printer_idle_timeout_state = "Printing";
get_mks_heater_bed_target();
set_heater_bed_target(mks_heater_bed_target);
ep->Send(json_run_a_gcode("M190 S" + std::to_string(mks_heater_bed_target) + "\n"));
sleep(1);
ep->Send(json_run_a_gcode("M4027\n"));
}
if (step_4 == true) {
sleep(15);
page_to(TJC_PAGE_AUTO_FINISH);
step_4 = false;
}
}
void refresh_page_move() {
std::string x_pos = std::to_string(x_position);
x_pos = x_pos.substr(0, x_pos.find(".") + 2);
std::string y_pos = std::to_string(y_position);
y_pos = y_pos.substr(0, y_pos.find(".") + 2);
std::string z_pos = std::to_string(z_position);
z_pos = z_pos.substr(0, z_pos.find(".") + 2);
send_cmd_txt(tty_fd, "t0", x_pos);
send_cmd_txt(tty_fd, "t1", y_pos);
send_cmd_txt(tty_fd, "t2", z_pos);
// CLL 刷新所选择距离
if (printer_move_dist == (float)0.1) {
send_cmd_picc(tty_fd, "b0", "77");
send_cmd_picc2(tty_fd, "b0", "74");
send_cmd_picc(tty_fd, "b1", "76");
send_cmd_picc2(tty_fd, "b1", "75");
send_cmd_picc(tty_fd, "b2", "76");
send_cmd_picc2(tty_fd, "b2", "75");
} else if (printer_move_dist == (float)1.0) {
send_cmd_picc(tty_fd, "b0", "76");
send_cmd_picc2(tty_fd, "b0", "75");
send_cmd_picc(tty_fd, "b1", "77");
send_cmd_picc2(tty_fd, "b1", "74");
send_cmd_picc(tty_fd, "b2", "76");
send_cmd_picc2(tty_fd, "b2", "75");
} else if (printer_move_dist == (float)10) {
send_cmd_picc(tty_fd, "b0", "76");
send_cmd_picc2(tty_fd, "b0", "75");
send_cmd_picc(tty_fd, "b1", "76");
send_cmd_picc2(tty_fd, "b1", "75");
send_cmd_picc(tty_fd, "b2", "77");
send_cmd_picc2(tty_fd, "b2", "74");
}
}
void refresh_page_offset(float intern_zoffset) {
printer_intern_z_offset = intern_zoffset;
printer_z_offset = printer_intern_z_offset + printer_extern_z_offset;
}
void refresh_page_printing_zoffset() {
std::string z_offset = std::to_string(printer_gcode_move_homing_origin[2]);
std::string show_gcode_z = std::to_string(gcode_z_position);
z_offset = z_offset.substr(0, z_offset.find(".") + 4);
show_gcode_z = show_gcode_z.substr(0, show_gcode_z.find(".") + 4);
send_cmd_txt(tty_fd, "t4", printer_print_stats_filename.substr(printer_print_stats_filename.rfind("/") +1 ));
if (z_offset != mks_babystep_value) {
mks_babystep_value = z_offset;
set_mks_babystep(mks_babystep_value);
}
send_cmd_txt(tty_fd, "t2", show_gcode_z);
send_cmd_txt(tty_fd, "t3", z_offset);
send_cmd_txt(tty_fd, "t0", show_time((int)(printer_print_stats_print_duration)));
send_cmd_val(tty_fd, "n7", std::to_string(printer_display_status_progress));
send_cmd_txt(tty_fd, "t1", show_time(get_cal_printing_time((int)(printer_print_stats_print_duration), file_metadata_estimated_time, printer_display_status_progress)));
send_cmd_val(tty_fd, "j0", std::to_string(printer_display_status_progress));
if (printer_set_offset == (float)0.01) {
send_cmd_picc(tty_fd, "b1", std::to_string(57));
send_cmd_picc2(tty_fd, "b1", std::to_string(60));
send_cmd_picc(tty_fd, "b2", std::to_string(58));
send_cmd_picc2(tty_fd, "b2", std::to_string(59));
send_cmd_picc(tty_fd, "b3", std::to_string(58));
send_cmd_picc2(tty_fd, "b3", std::to_string(59));
send_cmd_picc(tty_fd, "b4", std::to_string(58));
send_cmd_picc2(tty_fd, "b4", std::to_string(59));
} else if (printer_set_offset == (float)0.05) {
send_cmd_picc(tty_fd, "b1", std::to_string(58));
send_cmd_picc2(tty_fd, "b1", std::to_string(59));
send_cmd_picc(tty_fd, "b2", std::to_string(57));
send_cmd_picc2(tty_fd, "b2", std::to_string(60));
send_cmd_picc(tty_fd, "b3", std::to_string(58));
send_cmd_picc2(tty_fd, "b3", std::to_string(59));
send_cmd_picc(tty_fd, "b4", std::to_string(58));
send_cmd_picc2(tty_fd, "b4", std::to_string(59));
} else if (printer_set_offset == (float)0.1) {
send_cmd_picc(tty_fd, "b1", std::to_string(58));
send_cmd_picc2(tty_fd, "b1", std::to_string(59));
send_cmd_picc(tty_fd, "b2", std::to_string(58));
send_cmd_picc2(tty_fd, "b2", std::to_string(59));
send_cmd_picc(tty_fd, "b3", std::to_string(57));
send_cmd_picc2(tty_fd, "b3", std::to_string(60));
send_cmd_picc(tty_fd, "b4", std::to_string(58));
send_cmd_picc2(tty_fd, "b4", std::to_string(59));
} else if (printer_set_offset == (float)0.5) {
send_cmd_picc(tty_fd, "b1", std::to_string(58));
send_cmd_picc2(tty_fd, "b1", std::to_string(59));
send_cmd_picc(tty_fd, "b2", std::to_string(58));
send_cmd_picc2(tty_fd, "b2", std::to_string(59));
send_cmd_picc(tty_fd, "b3", std::to_string(58));
send_cmd_picc2(tty_fd, "b3", std::to_string(59));
send_cmd_picc(tty_fd, "b4", std::to_string(57));
send_cmd_picc2(tty_fd, "b4", std::to_string(60));
}
if (printer_print_stats_state == "printing") {
printer_ready = true;
}
if (filament_switch_sensor_fila_enabled == true) {
if (filament_switch_sensor_fila_filament_detected == false) {
printer_ready = false;
set_print_pause();
page_to(TJC_PAGE_PRINT_NO_FILAMENT_2);
}
}
//4.4.2 CLL 适配mates与霍尔耗材宽度检测器
if (filament_detected == false) {
sleep(1);
printer_ready = false;
set_print_pause();
page_to(TJC_PAGE_PRINT_NO_FILAMENT);
}
if (printer_print_stats_state == "standby") {
page_to(TJC_PAGE_PRINT_STOPPING);
}
if (printer_print_stats_state == "paused") {
if (printer_ready == true) {
printer_ready = false;
page_to(TJC_PAGE_PRINT_FILAMENT);
}
}
if (printer_print_stats_state == "complete") {
std::string time_duration = show_time((int)(printer_print_stats_print_duration));
complete_print();
clear_previous_data();
sleep(5);
save_current_zoffset();
page_to(TJC_PAGE_PRINT_FINISH);
send_cmd_txt(tty_fd, "t1", time_duration);
}
if (printer_print_stats_state == "error") {
page_to(TJC_PAGE_GCODE_ERROR);
cancel_print();
clear_previous_data();
send_cmd_txt(tty_fd , "t0", "gcode error:" + error_message);
}
}
void refresh_page_printing() {
std::string z_offset = std::to_string(printer_gcode_move_homing_origin[2]);
z_offset = z_offset.substr(0, z_offset.find(".") + 4);
send_cmd_val(tty_fd, "j0", std::to_string(printer_display_status_progress));
send_cmd_val(tty_fd, "n7", std::to_string(printer_display_status_progress));
send_cmd_txt(tty_fd, "t2", show_time((int)(printer_print_stats_print_duration)));
send_cmd_txt(tty_fd, "t3", show_time(get_cal_printing_time((int)(printer_print_stats_print_duration), file_metadata_estimated_time, printer_display_status_progress)));
send_cmd_txt(tty_fd, "t4", printer_print_stats_filename.substr(printer_print_stats_filename.rfind("/") +1 ));
if (printing_keyboard_enabled == false) { // CLL 当未进入键盘时重复执行刷新函数
if (current_page_id == TJC_PAGE_PRINTING) {
// CLL 刷新风扇速率
send_cmd_val(tty_fd, "n4", std::to_string((int)(printer_out_pin_fan0_value * 100)));
send_cmd_val(tty_fd, "n5", std::to_string((int)(printer_out_pin_fan2_value * 100)));
send_cmd_val(tty_fd, "n6", std::to_string((int)(printer_out_pin_fan3_value * 100)));
send_cmd_txt(tty_fd, "t0", std::to_string(printer_extruder_temperature));
send_cmd_val(tty_fd, "n0", std::to_string(printer_extruder_target));
if (printer_extruder_target == 0) { // CLL 根据喷头是否加热改变按钮和数字颜色
send_cmd_pco(tty_fd, "t0", "65535");
send_cmd_picc(tty_fd, "b0", "53");
send_cmd_picc2(tty_fd, "b0", "51");
} else {
send_cmd_pco(tty_fd, "t0", "63488");
send_cmd_picc(tty_fd, "b0", "54");
send_cmd_picc2(tty_fd, "b0", "52");
}
send_cmd_txt(tty_fd, "t1", std::to_string(printer_heater_bed_temperature));
send_cmd_val(tty_fd, "n1", std::to_string(printer_heater_bed_target));
if (printer_heater_bed_target == 0) { // CLL 根据热床是否加热改变按钮和数字颜色
send_cmd_pco(tty_fd, "t1", "65535");
send_cmd_picc(tty_fd, "b1", "53");
send_cmd_picc2(tty_fd, "b1", "51");
} else {
send_cmd_pco(tty_fd, "t1", "63488");
send_cmd_picc(tty_fd, "b1", "54");
send_cmd_picc2(tty_fd, "b1", "52");
}
if (printer_caselight_value == 0) { // CLL 判断当前LED状态
send_cmd_picc(tty_fd, "b3", "53");
send_cmd_picc2(tty_fd, "b3", "52");
} else {
send_cmd_picc(tty_fd, "b3", "54");
send_cmd_picc2(tty_fd, "b3", "51");
}
send_cmd_val(tty_fd, "n2", std::to_string(printer_hot_target)); // CLL 获取热腔温度
send_cmd_txt(tty_fd, "t5", std::to_string(printer_hot_temperature));
if (printer_hot_target == 0) { // CLL 根据热床是否加热改变按钮和数字颜色
send_cmd_pco(tty_fd, "t5", "65535");
send_cmd_picc(tty_fd, "b7", "53");
send_cmd_picc2(tty_fd, "b7", "51");
} else {
send_cmd_pco(tty_fd, "t5", "63488");
send_cmd_picc(tty_fd, "b7", "54");
send_cmd_picc2(tty_fd, "b7", "52");
}
if (show_preview_gimage_completed == true) {
send_cmd_vis(tty_fd, "cp0", "1");
send_cmd_val(tty_fd, "v999", "1");
} else {
send_cmd_vis(tty_fd, "cp0", "0");
send_cmd_val(tty_fd, "v999", "0");
}
} else if (current_page_id == TJC_PAGE_PRINTING_2) {
send_cmd_txt(tty_fd, "t1", z_offset); //刷新zoffset值
if (current_speed_factor != printer_gcode_move_speed_factor) { // CLL 刷新移动速率
current_speed_factor = printer_gcode_move_speed_factor;
send_cmd_val(tty_fd, "n2", std::to_string((int)(round(printer_gcode_move_speed_factor * 100))));
}
if (current_extruder_factor != printer_gcode_move_extrude_factor) { // CLL 刷新挤出速率
current_extruder_factor = printer_gcode_move_extrude_factor;
send_cmd_val(tty_fd, "n3", std::to_string((int)(round(printer_gcode_move_extrude_factor * 100))));
}
}
}
if (printer_print_stats_state == "printing") {
printer_ready = true;
}
if (filament_switch_sensor_fila_enabled == true) {
if (filament_switch_sensor_fila_filament_detected == false) {
printer_ready = false;
set_print_pause();
page_to(TJC_PAGE_PRINT_NO_FILAMENT_2);
}
}
if (filament_detected == false) {
sleep(1);
printer_ready = false;
set_print_pause();
page_to(TJC_PAGE_PRINT_NO_FILAMENT);
}
if (printer_print_stats_state == "complete") {
std::string time_duration = show_time((int)(printer_print_stats_print_duration));
complete_print();
clear_previous_data();
sleep(5);
save_current_zoffset();
page_to(TJC_PAGE_PRINT_FINISH);
send_cmd_txt(tty_fd, "t1", time_duration);
}
if (printer_print_stats_state == "paused") {
if (printer_ready == true) {
printer_ready = false;
page_to(TJC_PAGE_PRINT_FILAMENT);
}
}
if (printer_print_stats_state == "standby") {
page_to(TJC_PAGE_PRINT_STOPPING);
}
if (printer_print_stats_state == "error") {
page_to(TJC_PAGE_GCODE_ERROR);
cancel_print();
clear_previous_data();
send_cmd_txt(tty_fd, "t0", "gcode error:" + error_message);
}
}
void clear_page_printing_arg() {
current_extruder_temperature = 0;
current_extruder_target = 0;
current_heater_bed_target = 0;
current_heater_bed_temperature = 0;
current_hot_target = 0;
current_hot_temperature = 0;
current_out_pin_fan0_value = 0;
current_out_pin_fan2_value = 0;
current_out_pin_fan3_value = 0;
current_speed_factor = 0;
current_extruder_factor = 0;
}
void refresh_page_preview() {
if (printer_bed_leveling == true) {
send_cmd_picc(tty_fd, "b2", "45");
send_cmd_picc2(tty_fd, "b2", "45");
}else {
send_cmd_picc(tty_fd, "b2", "46");
send_cmd_picc2(tty_fd, "b2", "46");
}
if (mks_file_parse_finished == true) {
if (show_preview_complete == false) {
//4.4.2 CLL 修改当前在预览图界面仅能看到文件名称
send_cmd_txt(tty_fd, "t0", file_metadata_filename.substr(file_metadata_filename.rfind("/") + 1));
if (file_metadata_estimated_time) {
send_cmd_txt(tty_fd, "t1", show_time(file_metadata_estimated_time));
} else {
send_cmd_txt(tty_fd, "t1", "-");
}
if (file_metadata_filament_weight_total) {
std::string temp = std::to_string(file_metadata_filament_weight_total);
send_cmd_txt(tty_fd, "t2", temp.substr(0, temp.find(".") + 2) + "g");
} else {
send_cmd_txt(tty_fd, "t2", "-");
}
if (file_metadata_filament_total) {
std::string temp = std::to_string(file_metadata_filament_total / 1000);
send_cmd_txt(tty_fd, "t3", temp.substr(0, temp.find(".") + 2) + "m");
} else {
send_cmd_txt(tty_fd, "t3", "-");
}
if (file_metadata_filament_type != "") {
send_cmd_txt(tty_fd, "t4", file_metadata_filament_type);
} else if (file_metadata_filament_name != ""){
send_cmd_txt(tty_fd, "t4", file_metadata_filament_name);
} else {
send_cmd_txt(tty_fd, "t4", "-");
}
bool path_found = false;
std::string picture_path;
if (jump_to_print == true) {
picture_path = "/.cache/.thumbs/" + printer_print_stats_filename.substr(printer_print_stats_filename.rfind("/") + 1, printer_print_stats_filename.rfind(".") - (printer_print_stats_filename.rfind("/") + 1));
} else if (cache_clicked == true) {
picture_path = page_files_path_stack.top() + "/.cache/.thumbs/" + file_metadata_filename.substr(file_metadata_filename.rfind("/") + 1, file_metadata_filename.rfind(".") - (file_metadata_filename.rfind("/") + 1));
cache_clicked = false;
} else {
picture_path = page_files_path_stack.top() + "/.thumbs/" + file_metadata_filename.substr(file_metadata_filename.rfind("/") + 1, file_metadata_filename.rfind(".") - (file_metadata_filename.rfind("/") + 1));
}
if (path_found == false) {
picture_path = picture_path.substr(1);
MKSLOG_RED("picture_path:%s", picture_path.c_str());
char relative_path[1024];
sprintf(relative_path, "/home/mks/gcode_files/%s-160x160.png", picture_path.c_str()); // CLL 先在目录下寻找168x168像素图片
MKSLOG("relative_path:%s", relative_path);
if (access(relative_path, F_OK) == 0) {
path_found = true;
picture_path = picture_path + "-160x160.png";
} else {
sprintf(relative_path, "/home/mks/gcode_files/%s-160x160.jpg",picture_path.c_str()); // CLL 再在目录下寻找32x32像素图片
if (access(relative_path, F_OK) == 0) {
path_found = true;
picture_path = picture_path + "-160x160.jpg";
}
}
}
MKSLOG_BLUE("图片路径:%s", picture_path.c_str());
if (picture_path == "") {
path_found = false;
}
if (path_found == true) {
// 刷小图
if (show_preview_gimage_completed == false) {
output_imgdata(picture_path, 160);
std::ifstream simage_infile("/home/mks/tjc");
if (!simage_infile) {
std::cerr << "无法打开文件 " << "/home/mks/tjc" << std::endl;
show_preview_complete = true;
return;
}
std::stringstream simage_buffer;
simage_buffer << simage_infile.rdbuf();
file_metadata_simage = simage_buffer.str();
simage_infile.close();
send_cmd_txt(tty_fd, "preview.cp0_text", "");
send_cmd_txt(tty_fd, "preview.add", "");
if (file_metadata_simage != "") {
send_cmd_baud(tty_fd, 921600);
usleep(50000);
set_option(tty_fd, 921600, 8, 'N', 1);
std::cout << "刷小图" << std::endl;
int num = 2048;
int len = file_metadata_simage.length();
int end = num;
std::string s;
for (int start = 0; start < len;) {
if (end > len) {
s = file_metadata_simage.substr(start, len - start);
send_cmd_txt(tty_fd, "add", s);
tcdrain(tty_fd);
send_cmd_txt_plus(tty_fd, "cp0_text", "cp0_text", "add");
tcdrain(tty_fd);
break;
}
s = file_metadata_simage.substr(start, num);
start = end;
end = end + num;
send_cmd_txt(tty_fd, "add", s);
tcdrain(tty_fd);
send_cmd_txt_plus(tty_fd, "cp0_text", "cp0_text", "add");
tcdrain(tty_fd);
// usleep(50000);
}
send_cmd_baud(tty_fd, 115200);
usleep(50000);
set_option(tty_fd, 115200, 8, 'N', 1);
}
// 刷大图
if (jump_to_print == false) {
// output_imgdata(thumbnail_path, 168);
std::ifstream infile("/home/mks/tjc"); // 打开文件
if (!infile) {
std::cerr << "无法打开文件 " << "/home/mks/tjc" << std::endl;
show_preview_complete = true;
return;
}
std::stringstream buffer;
buffer << infile.rdbuf();
file_metadata_gimage = buffer.str();
infile.close();
send_cmd_baud(tty_fd, 921600);
usleep(50000);
set_option(tty_fd, 921600, 8, 'N', 1);
send_cmd_cp_close(tty_fd, "preview.cp0");
if (file_metadata_gimage != "") {
std::cout << "刷大图" << std::endl;
// std::cout << "图片字符串的大小为: " << file_metadata_gimage.length() << std::endl;
// std::cout << "图片的字节大小为：" << file_metadata_gimage.size() << std::endl;
int num = 2048;
int len = file_metadata_gimage.length();
int end = num;
std::string g;
// int i = 0;
for (int start = 0; start < len;) {
if (end > len) {
g = file_metadata_gimage.substr(start, len - start);
// std::cout << "字串" << i << ":" << s << std::endl;
tcdrain(tty_fd);
send_cmd_cp_image(tty_fd, "cp0", g);
break;
}
g = file_metadata_gimage.substr(start, num);
start = end;
end = end + num;
// std::cout << "字串" << i << ":" << s << std::endl;
// i++;
tcdrain(tty_fd);
send_cmd_cp_image(tty_fd, "cp0", g);
// usleep(50000);
}
}
send_cmd_baud(tty_fd, 115200);
usleep(50000);
set_option(tty_fd, 115200, 8, 'N', 1);
bed_leveling_switch(true);
}
show_preview_gimage_completed = true;
}
}
if (show_preview_gimage_completed == true) {
send_cmd_vis(tty_fd, "cp0", "1");
} else {
send_cmd_vis(tty_fd, "cp0", "0");
}
show_preview_complete = true;
if (jump_to_print == true) {
//printed_file_path = "/" + printer_print_stats_filename;
check_filament_type();
jump_to_print = false;
}
}
}
}
void refresh_page_main() {
send_cmd_val(tty_fd, "n0", std::to_string(printer_extruder_temperature));
send_cmd_val(tty_fd, "n1", std::to_string(printer_heater_bed_temperature));
send_cmd_val(tty_fd, "n2", std::to_string(printer_hot_temperature));
if (detect_disk() == 0) { // CLL 是否已插入U盘
send_cmd_picc(tty_fd, "q1", "32");
} else {
send_cmd_picc(tty_fd, "q1", "33");
}
if (strcmp(status_result.wpa_state, "COMPLETED") == 0) { // CLL 是否已连接wifi
send_cmd_picc(tty_fd, "q0", "32");
} else {
send_cmd_picc(tty_fd, "q0", "33");
}
if (printer_caselight_value == 0) { // LED灯的logo
send_cmd_picc(tty_fd, "b0", "32");
send_cmd_picc2(tty_fd, "b0", "30");
} else {
send_cmd_picc(tty_fd, "b0", "33");
send_cmd_picc2(tty_fd, "b0", "31");
}
if (printer_out_pin_beep_value == 0) {
send_cmd_picc(tty_fd, "b1", "32");
send_cmd_picc2(tty_fd, "b1", "30");
} else {
send_cmd_picc(tty_fd, "b1", "33");
send_cmd_picc2(tty_fd, "b1", "31");
}
if (printer_extruder_target == 0) { // CLL 主页喷嘴是否加热刷新
send_cmd_pco(tty_fd, "n0", "65535");
send_cmd_picc(tty_fd, "b3", "32");
send_cmd_picc2(tty_fd, "b3", "30");
} else {
send_cmd_pco(tty_fd, "n0", "63488");
send_cmd_picc(tty_fd, "b3", "33");
send_cmd_picc2(tty_fd, "b3", "31");
}
if (printer_heater_bed_target == 0) { // CLL 主页热床按钮是否加热刷新
send_cmd_pco(tty_fd, "n1", "65535");
send_cmd_picc(tty_fd, "b4", "32");
send_cmd_picc2(tty_fd, "b4", "30");
} else {
send_cmd_pco(tty_fd, "n1", "63488");
send_cmd_picc(tty_fd, "b4", "33");
send_cmd_picc2(tty_fd, "b4", "31");
}
if (printer_hot_target == 0) { // CLL 主页热腔按钮是否加热刷新
send_cmd_pco(tty_fd, "n2", "65535");
send_cmd_picc(tty_fd, "b5", "32");
send_cmd_picc2(tty_fd, "b5", "30");
} else {
send_cmd_pco(tty_fd, "n2", "63488");
send_cmd_picc(tty_fd, "b5", "33");
send_cmd_picc2(tty_fd, "b5", "31");
}
// CLL 每次开机或打印后执行图片刷新
if (main_picture_refreshed == false) {
// CLL 获取文件信息
page_files_pages = 0;
page_files_current_pages = 0;
page_files_folder_layers = 0;
page_files_previous_path = "";
page_files_root_path = DEFAULT_DIR;
page_files_path = "";
refresh_page_files(page_files_current_pages);
if (page_files_list_show_type[0] == "[c]") {
send_cmd_txt(tty_fd, "t0", page_files_list_show_name[0]);
std::string picture_path = page_files_path + "/.cache/.thumbs/" + page_files_list_show_name[0].substr(0, page_files_list_show_name[0].rfind("."));
picture_path = picture_path.substr(1);
MKSLOG_RED("图片路径:%s", picture_path.c_str());
char relative_path[1024];
sprintf(relative_path, "/home/mks/gcode_files/%s-160x160.png", picture_path.c_str());
if (access(relative_path, F_OK) == 0) {
MKSLOG_RED("找到png图片");
send_cmd_pic(tty_fd, "b[0]", "29");
send_cmd_picc(tty_fd, "b6", "29");
send_cmd_picc2(tty_fd, "b6", "30");
send_cmd_vis(tty_fd, "cp0", "1");
refresh_files_list_picture(picture_path + "-160x160.png", 160, 0);
main_picture_detected = true;
} else {
sprintf(relative_path, "/home/mks/gcode_files/%s-160x160.jpg", picture_path.c_str());
if (access(relative_path, F_OK) == 0) {
MKSLOG_RED("找到jpg图片");
send_cmd_pic(tty_fd, "b[0]", "29");
send_cmd_picc(tty_fd, "b6", "29");
send_cmd_picc2(tty_fd, "b6", "30");
refresh_files_list_picture(picture_path + "-160x160.jpg", 160, 0);
main_picture_detected = true;
} else {
send_cmd_pic(tty_fd, "b[0]", "26");
send_cmd_picc(tty_fd, "b6", "26");
send_cmd_picc2(tty_fd, "b6", "31");
send_cmd_vis(tty_fd, "cp0", "0");
}
}
} else {
send_cmd_pic(tty_fd, "b[0]", "26");
send_cmd_picc(tty_fd, "b6", "26");
send_cmd_picc2(tty_fd, "b6", "31");
send_cmd_txt(tty_fd, "t0", "");
send_cmd_vis(tty_fd, "cp0", "0");
}
main_picture_refreshed = true;
}
// CLL 每次开机发送断电续打
if (open_reprint_asked == false) {
check_print_interrupted();
open_reprint_asked = true;
}
}
void refresh_page_files_list() {
send_cmd_vis(tty_fd, "q0", "0");
for (int i = 0; i < 4; i++) {
send_cmd_txt(tty_fd, "t" + std::to_string(i + 1), page_files_list_show_name[i]);
send_cmd_vis(tty_fd, "cp" + std::to_string(i), "0");
if (page_files_list_show_type[i] =="[c]") {
send_cmd_picc(tty_fd, "b" + std::to_string(i+1), "40");
send_cmd_picc2(tty_fd, "b" + std::to_string(i+1), "37");
send_cmd_vis(tty_fd, "q0", "1");
} else if (page_files_list_show_type[i] == "[d]") {
send_cmd_picc(tty_fd, "b" + std::to_string(i + 1), "41");
send_cmd_picc2(tty_fd, "b" + std::to_string(i + 1), "39");
} else if (page_files_list_show_type[i] == "[f]") {
send_cmd_picc(tty_fd, "b" + std::to_string(i + 1), "40");
send_cmd_picc2(tty_fd, "b" + std::to_string(i + 1), "37");
} else if (page_files_list_show_type[i] == "[n]") {
send_cmd_picc(tty_fd, "b" + std::to_string(i + 1), "34");
send_cmd_picc2(tty_fd, "b" + std::to_string(i + 1), "34");
}
}
//4.4.2 CLL 文件列表界面新增本地、U盘文件按钮
if (file_mode == "Local") {
send_cmd_picc(tty_fd, "b12", "35");
send_cmd_picc2(tty_fd, "b12", "37");
send_cmd_picc(tty_fd, "b13", "35");
send_cmd_picc2(tty_fd, "b13", "37");
} else if (file_mode == "USB") {
send_cmd_picc(tty_fd, "b12", "34");
send_cmd_picc2(tty_fd, "b12", "36");
send_cmd_picc(tty_fd, "b13", "34");
send_cmd_picc2(tty_fd, "b13", "36");
if (detect_disk() == -1) {
send_cmd_vis(tty_fd, "t0", "1");
}
} /* else if (file_mode == "NULL") {
send_cmd_picc(tty_fd, "b12", "34");
send_cmd_picc2(tty_fd, "b12", "36");
send_cmd_picc(tty_fd, "b13", "34");
send_cmd_picc2(tty_fd, "b13", "36");
send_cmd_vis(tty_fd, "t0", "1");
}
*/
if (page_files_current_pages == 0) {
send_cmd_picc(tty_fd, "b10", std::to_string(40));
send_cmd_picc2(tty_fd, "b10", std::to_string(39));
} else {
send_cmd_picc(tty_fd, "b10", std::to_string(41));
send_cmd_picc2(tty_fd, "b10", std::to_string(37));
}
if (page_files_current_pages == page_files_pages) {
send_cmd_picc(tty_fd, "b11", std::to_string(40));
send_cmd_picc2(tty_fd, "b11", std::to_string(39));
} else {
send_cmd_picc(tty_fd, "b11", std::to_string(41));
send_cmd_picc2(tty_fd, "b11", std::to_string(37));
}
if (page_files_folder_layers == 0 || (page_files_folder_layers == 1 && file_mode != "Local")) {
send_cmd_picc(tty_fd, "b0", std::to_string(40));
send_cmd_picc2(tty_fd, "b0", std::to_string(39));
} else {
send_cmd_picc(tty_fd, "b0", std::to_string(41));
send_cmd_picc2(tty_fd, "b0", std::to_string(37));
}
delete_small_jpg();
std::string picture_path;
for (int i = 0; i < 4; i++) { // CLL 其他控件刷新完后统一刷新图片
have_64_jpg[i] = false;
have_64_png_path[i].clear();
if (page_files_list_show_type[i] =="[c]" || page_files_list_show_type[i] == "[f]") {
if (page_files_list_show_type[i]== "[c]") {
picture_path = page_files_path + "/.cache/.thumbs/" + page_files_list_show_name[i].substr(0, page_files_list_show_name[i].rfind("."));
} else {
picture_path = page_files_path + "/.thumbs/" + page_files_list_show_name[i].substr(0, page_files_list_show_name[i].rfind("."));
}
picture_path = picture_path.substr(1);
MKSLOG_RED("图片路径:%s", picture_path.c_str());
char relative_path[1024];
sprintf(relative_path, "/home/mks/gcode_files/%s-112x112_QD.jpg", picture_path.c_str());
if (access(relative_path, F_OK) == 0) {
have_64_jpg[i] = true;
have_64_png_path[i] = picture_path + "-112x112_QD.jpg";
refresh_files_list_picture_2(picture_path + "-112x112_QD.jpg", 112, i);
} /* else {
sprintf(relative_path, "/home/mks/gcode_files/%s-32x32.png", picture_path.c_str());
if (access(relative_path, F_OK) == 0) {
have_64_jpg[i] = true;
have_64_png_path[i] = picture_path + "-32x32.png";
refresh_files_list_picture_2(picture_path + "-32x32.png", 112, i);
}
}
*/
}
}
}
void refresh_page_files(int pages) {
get_page_files_filelist(page_files_root_path + page_files_path);
set_page_files_show_list(pages);
}
/* 订阅内容处理 */
void sub_object_status() {
ep->Send(json_subscribe_to_printer_object_status(subscribe_objects_status()));
}
void get_object_status() {
ep->Send(json_query_printer_object_status(subscribe_objects_status()));
}
void get_file_estimated_time(std::string filename) {
ep->Send(json_get_gcode_metadata(filename));
}
void delete_file(std::string filepath) {
filelist_changed = false;
ep->Send(json_file_delete(filepath));
while (!filelist_changed);
}
void start_printing(std::string filepath) {
ep->Send(json_print_a_file(filepath));
}
void set_target(std::string heater, int target) {
ep->Send(json_run_a_gcode(set_heater_temp(heater, target)));
}
void set_extruder_target(int target) {
set_target("extruder", target);
}
void set_heater_bed_target(int target) {
set_target("heater_bed", target);
}
void set_hot_target(int target) {
ep->Send(json_run_a_gcode("M141 S" + std::to_string(target)));
}
void set_fan(int speed) {
ep->Send(json_run_a_gcode(set_fan_speed(speed)));
}
void set_fan0(int speed) {
ep->Send(json_run_a_gcode(set_fan0_speed(speed)));
}
void set_fan2(int speed) {
ep->Send(json_run_a_gcode(set_fan2_speed(speed)));
}
void set_fan3(int speed) {
ep->Send(json_run_a_gcode(set_fan3_speed(speed)));
}
void set_intern_zoffset(float offset) {
printer_set_offset = offset;
}
void set_zoffset(bool positive) {
// std::string command;
// if (positive) {
// command = "curl -s -X POST http://127.0.0.1:7125/printer/modifybabystep?ADJUST=" + std::to_string(printer_set_offset);
// } else {
// command = "curl -s -X POST http://127.0.0.1:7125/printer/modifybabystep?ADJUST=-" + std::to_string(printer_set_offset);
// }
// system(command.c_str());
if (positive == true) {
ep->Send(json_run_a_gcode("SET_GCODE_OFFSET Z_ADJUST=+" + std::to_string(printer_set_offset) + " MOVE=1"));
} else {
ep->Send(json_run_a_gcode("SET_GCODE_OFFSET Z_ADJUST=-" + std::to_string(printer_set_offset) + " MOVE=1"));
}
}
void set_move_dist(float dist) {
printer_move_dist = dist;
}
void set_printer_speed(int speed) {
std::cout << "Rate = " << std::to_string(speed) << std::endl;
ep->Send(json_run_a_gcode(set_speed_rate(std::to_string(speed))));
}
void set_printer_flow(int rate) {
ep->Send(json_run_a_gcode("M221 S" + (std::to_string(rate))));
}
std::string show_time(int seconds) {
return std::to_string((int)(seconds/3600)) + "h" + std::to_string((int)((seconds % 3600) / 60)) + "m";
}
void move_home() {
ep->Send(json_run_a_gcode("G28\n"));
}
void move_x_decrease() {
ep->Send(move(AXIS_X, "-" + std::to_string(printer_move_dist), 130));
unhomed_move_mode = 2;
}
void move_x_increase() {
ep->Send(move(AXIS_X, "+" + std::to_string(printer_move_dist), 130));
unhomed_move_mode = 1;
}
void move_y_decrease() {
ep->Send(move(AXIS_Y, "-" + std::to_string(printer_move_dist), 130));
unhomed_move_mode = 4;
}
void move_y_increase() {
ep->Send(move(AXIS_Y, "+" + std::to_string(printer_move_dist), 130));
unhomed_move_mode = 3;
}
void move_z_decrease() {
ep->Send(move(AXIS_Z, "-" + std::to_string(printer_move_dist), 10));
unhomed_move_mode = 5;
}
void move_z_increase() {
ep->Send(move(AXIS_Z, "+" + std::to_string(printer_move_dist), 10));
unhomed_move_mode = 6;
}
bool get_filament_detected() {
return filament_switch_sensor_fila_filament_detected;
}
bool get_filament_detected_enable() {
return filament_switch_sensor_fila_enabled;
}
bool get_print_pause_resume() {
return printer_pause_resume_is_paused;
}
void set_print_pause_resume() {
if (printer_pause_resume_is_paused == false) {
ep->Send(json_run_a_gcode("PAUSE"));
} else {
ep->Send(json_run_a_gcode("RESUME"));
}
}
void set_print_pause() {
ep->Send(json_run_a_gcode("PAUSE"));
}
void set_print_resume() {
ep->Send(json_run_a_gcode("RESUME"));
}
void cancel_print() {
printer_print_stats_filename = "";
system("curl -X POST http://127.0.0.1:7125/printer/breakmacro");
system("curl -X POST http://127.0.0.1:7125/printer/breakheater");
ep->Send(json_run_a_gcode("CANCEL_PRINT"));
int printed_minutes = get_cal_printed_time((int)(printer_print_stats_print_duration));
get_mks_total_printed_time();
mks_total_printed_minutes = mks_total_printed_minutes + printed_minutes;
std::cout << "@@@@@@ " << printed_minutes << std::endl;
set_mks_total_printed_time(mks_total_printed_minutes);
usleep(10000);
sdcard_reset_file();
}
void sdcard_reset_file() {
ep->Send(json_run_a_gcode("SDCARD_RESET_FILE"));
}
void set_auto_level_dist(float dist) {
MKSLOG_BLUE("SET");
auto_level_dist = dist;
}
void start_auto_level() {
step_1 = false;
step_2 = false;
step_3 = false;
step_4 = false;
if (start_pre_auto_level == false) {
printer_idle_timeout_state = "Printing";
}
page_to(TJC_PAGE_AUTO_MOVING);
set_heater_bed_target(mks_heater_bed_target);
ep->Send(json_run_a_gcode("M4029"));
}
//4.4.1 CLL 修改调平
void start_auto_level_dist(bool positive) {
if (positive == true) {
//ep->Send(json_run_a_gcode("TESTZ Z=" + std::to_string(auto_level_dist)));
ep->Send(json_run_a_gcode("SET_GCODE_OFFSET Z_ADJUST=" + std::to_string(auto_level_dist) + " MOVE=1"));
} else {
//ep->Send(json_run_a_gcode("TESTZ Z=-" + std::to_string(auto_level_dist)));
ep->Send(json_run_a_gcode("SET_GCODE_OFFSET Z_ADJUST=-" + std::to_string(auto_level_dist) + " MOVE=1"));
}
}
void set_filament_extruder_target(bool positive) {
get_mks_extruder_target();
printer_filament_extruder_target = mks_extruder_target;
if (positive == true) {
printer_filament_extruder_target += 3;
} else {
printer_filament_extruder_target -= 3;
}
if (printer_filament_extruder_target >= 350) {
printer_filament_extruder_target = 350;
}
if (printer_filament_extruder_target < 0) {
printer_filament_extruder_target = 0;
set_extruder_target(0);
set_mks_extruder_target(0);
} else {
set_extruder_target(printer_filament_extruder_target);
set_mks_extruder_target(printer_filament_extruder_target);
}
}
void set_print_filament_dist(float dist) {
printer_filament_extruedr_dist = dist;
}
void start_retract() {
ep->Send(json_run_a_gcode("M83\nG1 E-" + std::to_string(printer_filament_extruedr_dist) + " F300\n"));
}
void start_extrude() {
ep->Send(json_run_a_gcode("M83\nG1 E" + std::to_string(printer_filament_extruedr_dist) + " F300\n"));
}
std::string get_ip(std::string net) {
char result[MAX_FILE_LEN] = {0};
std::string cmd = "ifconfig " + net + " | awk 'NR==2{print $2}' | tr -d '\n\r'";
execute_cmd(cmd.data(), result);
return result;
}
void move_home_tips() {
jump_to_move_pop_2 = true;
}
void filament_tips() {
switch (current_page_id)
{
case TJC_PAGE_OPEN_FILAMENTVIDEO_3:
break;
case TJC_PAGE_PRINT_FILAMENT:
jump_to_print_low_temp = true;
break;
default:
jump_to_filament_pop_1 = true;
break;
}
}
void move_tips() {
jump_to_move_pop_1 = true;
if (current_page_id == TJC_PAGE_PRINTING || current_page_id == TJC_PAGE_PRINT_ZOFFSET || current_page_id == TJC_PAGE_PRINT_FILAMENT || current_page_id == TJC_PAGE_PRINTING_2) {
cancel_print();
}
}
void reset_klipper() {
ep->Send(json_run_a_gcode("RESTART\n"));
}
void reset_firmware() {
ep->Send(json_run_a_gcode("FIRMWARE_RESTART\n"));
}
void finish_print() {
sdcard_reset_file();
clear_cp0_image();
clear_page_preview();
show_preview_complete = false;
page_to(TJC_PAGE_MAIN);
}
void set_filament_sensor() {
std::cout << "filament_switch_sensor fila = " << filament_switch_sensor_fila_enabled << std::endl;
if (filament_switch_sensor_fila_enabled == 0) {
ep->Send(json_run_a_gcode("SET_FILAMENT_SENSOR SENSOR=fila ENABLE=1\n"));
mks_fila_status = true;
set_mks_fila_status();
} else {
ep->Send(json_run_a_gcode("SET_FILAMENT_SENSOR SENSOR=fila ENABLE=0\n"));
mks_fila_status = false;
set_mks_fila_status();
}
}
void motors_off() {
// ep->Send(json_run_a_gcode("M84\n"));
ep->Send(json_emergency_stop());
sleep(1);
ep->Send(json_run_a_gcode("FIRMWARE_RESTART\n")); // 电机解锁改为急停
}
void beep_on_off() {
if (printer_out_pin_beep_value == 0) {
ep->Send(json_run_a_gcode("beep_on"));
mks_beep_status = true;
set_mks_beep_status();
} else {
ep->Send(json_run_a_gcode("beep_off"));
mks_beep_status = false;
set_mks_beep_status();
}
}
void led_on_off() {
if (printer_caselight_value == 0) {
ep->Send(json_run_a_gcode("SET_PIN PIN=caselight VALUE=1"));
if (current_page_id != TJC_PAGE_SCREEN_SLEEP) {
mks_led_status = true;
set_mks_led_status();
}
} else {
ep->Send(json_run_a_gcode("SET_PIN PIN=caselight VALUE=0"));
if (current_page_id != TJC_PAGE_SCREEN_SLEEP){
mks_led_status = false;
set_mks_led_status();
}
}
}
void shutdown_mcu() {
system("echo \"SET_PIN PIN=pwc VALUE=0\" > /root/mcu_shutdown.txt");
ep->Send(json_run_a_gcode("SET_PIN PIN=pwc VALUE=0"));
}
void firmware_reset() {
ep->Send(json_run_a_gcode("FIRMWARE_RESTART\n"));
}
void go_to_page_power_off() {
page_to(TJC_PAGE_SHUTDOWN);
}
int get_mks_led_status() {
mksini_load();
mks_led_status = mksini_getboolean("led", "enable", 0);
mksini_free();
return mks_led_status;
}
void set_mks_led_status() {
mksini_load();
mksini_set("led", "enable", std::to_string(mks_led_status));
mksini_save();
mksini_free();
}
int get_mks_beep_status() {
mksini_load();
mks_beep_status = mksini_getboolean("beep", "enable", 0);
mksini_free();
return mks_beep_status;
}
void set_mks_beep_status() {
mksini_load();
mksini_set("beep", "enable", std::to_string(mks_beep_status));
mksini_save();
mksini_free();
system("sync");
}
void get_mks_language_status() {
mksini_load();
mks_language_status = mksini_getint("system", "language", 0);
mksini_free();
}
void set_mks_language_status() {
mksini_load();
mksini_set("system", "language", std::to_string(mks_language_status));
mksini_save();
mksini_free();
}
void get_mks_extruder_target() {
mksini_load();
mks_extruder_target = mksini_getint("target", "extruder", 200);
mksini_free();
}
void set_mks_extruder_target(int target) {
if (target != 0) {
mksini_load();
mksini_set("target", "extruder", std::to_string(target));
mksini_save();
mksini_free();
system("sync");
}
}
void get_mks_heater_bed_target() {
mksini_load();
mks_heater_bed_target = mksini_getint("target", "heaterbed", 40);
mksini_free();
}
void set_mks_heater_bed_target(int target) {
if (target != 0) {
mksini_load();
std::cout << "######## " << target << std::endl;
mksini_set("target", "heaterbed", std::to_string(target));
mksini_save();
mksini_free();
system("sync");
}
}
void get_mks_hot_target() {
mksini_load();
mks_hot_target = mksini_getint("target", "hot", 40);
mksini_free();
}
void set_mks_hot_target(int target) {
mksini_load();
std::cout << "######## " << target << std::endl;
mksini_set("target", "hot", std::to_string(target));
mksini_save();
mksini_free();
system("sync");
}
void filament_extruder_target() {
get_mks_extruder_target();
if (printer_extruder_target == 0) {
set_extruder_target(mks_extruder_target);
} else {
set_extruder_target(0);
}
}
void filament_heater_bed_target() {
get_mks_heater_bed_target();
if (0 == printer_heater_bed_target) {
set_heater_bed_target(mks_heater_bed_target);
} else {
set_heater_bed_target(0);
}
}
void filament_hot_target() {
get_mks_hot_target();
if (0 == printer_hot_target) {
set_hot_target(mks_hot_target);
} else {
set_hot_target(0);
}
}
void filament_fan0() {
if (printer_out_pin_fan0_value == 0) {
set_fan0(100);
} else {
set_fan0(0);
}
}
void filament_fan2() {
if (printer_out_pin_fan2_value == 0) {
set_fan2(100);
} else {
set_fan2(0);
}
}
void filament_fan3() {
if (printer_out_pin_fan3_value == 0) {
set_fan3(100);
} else {
set_fan3(0);
}
}
void go_to_reset() {
if (printer_webhooks_state == "shutdown") {
page_to(TJC_PAGE_RESET);
} else {
std::ifstream infile("/dev_info.txt");
if (!infile) {
std::cerr << "无法打开文件 " << "/dev_info.txt" << std::endl;
return;
}
std::stringstream buffer;
buffer << infile.rdbuf();
std::string machine_type = buffer.str();
infile.close();
machine_type = machine_type.substr(machine_type.find("@") + 1);
page_to(TJC_PAGE_SYS_OK);
std::cout << "machine_type:" << machine_type << std::endl;
send_cmd_txt(tty_fd, "t2", machine_type);
}
}
void go_to_network() {
if (detected_wlan0()) {
mks_wpa_cli_open_connection();
page_wifi_list_ssid_button_enabled[0] = false;
page_wifi_list_ssid_button_enabled[1] = false;
page_wifi_list_ssid_button_enabled[2] = false;
page_wifi_list_ssid_button_enabled[3] = false;
page_wifi_list_ssid_button_enabled[4] = false;
page_wifi_ssid_list_pages = 0;
page_wifi_current_pages = 0;
page_to(TJC_PAGE_WIFI_LIST);
//4.4.1 CLL 修复WiFi刷新
scan_ssid_and_show();
get_wlan0_status();
if (strcmp(status_result.wpa_state, "COMPLETED") == 0) {
current_connected_ssid_name = hex_to_utf8(status_result.ssid); // 如果已经连接wifi，获取wifi的名字
} else if (strcmp(status_result.wpa_state, "INACTIVE")) {
current_connected_ssid_name.clear(); // 如果没连接wifi，清除掉当前已连接wifi的名字
}
} else {
page_to(TJC_PAGE_INTERNET);
}
}
void scan_ssid_and_show() {
if (access("/var/run/wpa_supplicant/wlan0", F_OK) == 0){
get_wlan0_status();
mks_wpa_scan_scanresults();
get_ssid_list_pages();
page_wifi_current_pages = 0;
set_page_wifi_ssid_list(page_wifi_current_pages);
refresh_page_wifi_list();
} else {
page_to(TJC_PAGE_INTERNET);
}
}
void refresh_page_wifi_list() {
for (int i = 0; i < 5; i++) {
std::cout << "刷新的wifi: " << page_wifi_ssid_list[i] << std::endl;
if (0 == page_wifi_current_pages) {
if (0 == i) {
if (strcmp(status_result.wpa_state, "COMPLETED") == 0) {
send_cmd_txt(tty_fd, "t" + std::to_string(i+1), hex_to_utf8(status_result.ssid));
} else {
send_cmd_txt(tty_fd, "t" + std::to_string(i+1), page_wifi_ssid_list[i]);
}
} else {
send_cmd_txt(tty_fd, "t" + std::to_string(i+1), page_wifi_ssid_list[i]);
}
} else {
send_cmd_txt(tty_fd, "t" + std::to_string(i+1), page_wifi_ssid_list[i]);
}
MKSLOG_BLUE("%d/%d", page_wifi_current_pages + 1, page_wifi_ssid_list_pages);
if (page_wifi_current_pages == 0) {
if (strcmp(status_result.wpa_state, "COMPLETED") == 0) {
send_cmd_picc(tty_fd, "wifi1", "126");
send_cmd_picc2(tty_fd, "wifi1", "124");
page_wifi_list_ssid_button_enabled[0] = false;
} else {
send_cmd_picc(tty_fd, "wifi1", "125");
send_cmd_picc2(tty_fd, "wifi1", "123");
page_wifi_list_ssid_button_enabled[0] = true;
}
} else {
send_cmd_picc(tty_fd, "wifi1", "125");
send_cmd_picc2(tty_fd, "wifi1", "123");
page_wifi_list_ssid_button_enabled[0] = true;
}
if (page_wifi_ssid_list[i] == "") {
std::cout << "刷新为没有锁的图片" << std::endl;
send_cmd_picc(tty_fd, "wifi" + std::to_string(i + 1), "122");
send_cmd_picc2(tty_fd, "wifi" + std::to_string(i + 1), "122");
page_wifi_list_ssid_button_enabled[i] = false;
} else {
std::cout << "刷新为有锁的图片" << std::endl;
send_cmd_picc(tty_fd, "wifi" + std::to_string(i + 1), "125");
send_cmd_picc2(tty_fd, "wifi" + std::to_string(i + 1), "123");
page_wifi_list_ssid_button_enabled[i] = true;
}
if (page_wifi_ssid_list_pages == 0) {
send_cmd_picc(tty_fd, "b1", "126");
send_cmd_picc2(tty_fd, "b1", "123");
send_cmd_picc(tty_fd, "b2", "126");
send_cmd_picc2(tty_fd, "b2", "123");
} else {
if (page_wifi_current_pages == 0) {
send_cmd_picc(tty_fd, "b1", "126");
send_cmd_picc2(tty_fd, "b1", "123");
} else {
send_cmd_picc(tty_fd, "b1", "125");
send_cmd_picc2(tty_fd, "b1", "124");
}
if (page_wifi_current_pages == page_wifi_ssid_list_pages - 1) {
send_cmd_picc(tty_fd, "b2", "126");
send_cmd_picc2(tty_fd, "b2", "123");
} else {
send_cmd_picc(tty_fd, "b2", "125");
send_cmd_picc2(tty_fd, "b2", "124");
}
}
}
}
void refresh_page_wifi_list_2() {
send_cmd_txt(tty_fd, "t0", status_result.ip_address);
if (strcmp(status_result.wpa_state, "COMPLETED") == 0) {
} else if (strcmp(status_result.wpa_state, "INACTIVE")) {
}
}
void get_wifi_list_ssid(int index) {
get_wifi_name.clear();
get_wifi_name = page_wifi_ssid_list[index];
}
void set_print_filament_target() {
if (0 == printer_extruder_target) {
get_mks_extruder_target();
set_extruder_target(mks_extruder_target);
} else {
set_extruder_target(0);
}
}
void complete_print() {
if (page_printing_shutdown_enable == false) {
ep->Send(json_run_a_gcode("PRINT_END"));
} else {
ep->Send(json_run_a_gcode("PRINT_END_POWEROFF"));
}
int printed_minutes = get_cal_printed_time((int)(printer_print_stats_print_duration));
get_mks_total_printed_time();
mks_total_printed_minutes = mks_total_printed_minutes + printed_minutes;
std::cout << "@@@@@@ " << printed_minutes << std::endl;
set_mks_total_printed_time(mks_total_printed_minutes);
}
void back_to_main() {
clear_previous_data();
page_to(TJC_PAGE_MAIN);
}
void go_to_syntony_move() {
step_1 = false;
page_syntony_finished = false;
printer_idle_timeout_state = "Printing";
page_to(TJC_PAGE_SYNTONY_MOVE);
ep->Send(json_run_a_gcode("M901\n"));
}
void print_ssid_psk(char *psk) {
MKSLOG_RED("SSID is %s", get_wifi_name.c_str());
MKSLOG_RED("PSK is %s", psk);
mks_set_ssid(const_cast<char*>(get_wifi_name.c_str()));
mks_set_psk(psk);
}
void clear_page_preview() {
file_metadata_filename = "";
file_metadata_estimated_time = 0;
file_metadata_filament_weight_total = 0;
file_metadata_filament_name = "";
file_metadata_filament_type = "";
file_metadata_simage = "";
file_metadata_gimage = "";
}
void set_mks_babystep(std::string value) {
mksini_load();
mksini_set("babystep", "value", value);
mksini_save();
mksini_free();
system("sync");
}
void get_mks_babystep() {
mksini_load();
mks_babystep_value = mksini_getstring("babystep", "value", "0.000");
mks_adxl_offset = mksini_getstring("babystep", "adxl_offset", "0.000");
mksini_free();
}
void clear_cp0_image() {
send_cmd_cp_close(tty_fd, "preview.cp0");
send_cmd_txt(tty_fd, "preview.cp0_text", "");
send_cmd_txt(tty_fd, "preview.add", "");
show_preview_gimage_completed = false;
mks_file_parse_finished = false;
file_metadata_simage.clear();
file_metadata_gimage.clear();
}
void printer_set_babystep() {
get_mks_babystep();
ep->Send(json_run_a_gcode("SET_GCODE_OFFSET Z=" + mks_babystep_value + " MOVE=0"));
}
int get_mks_fila_status() {
mksini_load();
mks_fila_status = mksini_getboolean("fila", "enable", 0);
mksini_free();
return mks_fila_status;
}
void set_mks_fila_status() {
mksini_load();
mksini_set("fila", "enable", std::to_string(mks_fila_status));
mksini_save();
mksini_free();
system("sync");
}
void init_mks_status() {
get_mks_total_printed_time();
get_mks_babystep();
get_mks_connection_method();
get_mks_ethernet();
// 不再使用xindi获取zoffset
// printer_set_babystep();
/*
if (get_mks_beep_status() == 0) {
MKSLOG_RED("关闭蜂鸣器");
if (get_mks_led_status() == 0) {
MKSLOG_BLUE("关掉LED灯");
ep->Send(json_run_a_gcode("beep_off\nSET_PIN PIN=caselight VALUE=0\n"));
if (get_mks_fila_status() == 0) {
MKSLOG_BLUE("关掉断料检测");
ep->Send(json_run_a_gcode("beep_off\nSET_PIN PIN=caselight VALUE=0\nSET_FILAMENT_SENSOR SENSOR=fila ENABLE=0\n"));
} else {
MKSLOG_BLUE("打开断料检测");
ep->Send(json_run_a_gcode("beep_off\nSET_PIN PIN=caselight VALUE=0\nSET_FILAMENT_SENSOR SENSOR=fila ENABLE=1\n"));
}
} else {
MKSLOG_BLUE("打开LED灯");
ep->Send(json_run_a_gcode("beep_off\nSET_PIN PIN=caselight VALUE=1\n"));
if (get_mks_fila_status() == 0) {
MKSLOG_BLUE("关掉断料检测");
ep->Send(json_run_a_gcode("beep_off\nSET_PIN PIN=caselight VALUE=1\nSET_FILAMENT_SENSOR SENSOR=fila ENABLE=0\n"));
} else {
MKSLOG_BLUE("打开断料检测");
ep->Send(json_run_a_gcode("beep_off\nSET_PIN PIN=caselight VALUE=1\nSET_FILAMENT_SENSOR SENSOR=fila ENABLE=1\n"));
}
}
} else {
MKSLOG_RED("打开蜂鸣器");
if (get_mks_led_status() == 0) {
MKSLOG_BLUE("关掉LED灯");
ep->Send(json_run_a_gcode("beep_on\nSET_PIN PIN=caselight VALUE=0\n"));
if (get_mks_fila_status() == 0) {
MKSLOG_BLUE("关掉断料检测");
ep->Send(json_run_a_gcode("beep_on\nSET_PIN PIN=caselight VALUE=0\nSET_FILAMENT_SENSOR SENSOR=fila ENABLE=0\n"));
} else {
MKSLOG_BLUE("打开断料检测");
ep->Send(json_run_a_gcode("beep_on\nSET_PIN PIN=caselight VALUE=0\nSET_FILAMENT_SENSOR SENSOR=fila ENABLE=1\n"));
}
} else {
MKSLOG_BLUE("打开LED灯");
ep->Send(json_run_a_gcode("beep_on\nSET_PIN PIN=caselight VALUE=1\n"));
if (get_mks_fila_status() == 0) {
MKSLOG_BLUE("关掉断料检测");
ep->Send(json_run_a_gcode("beep_on\nSET_PIN PIN=caselight VALUE=1\nSET_FILAMENT_SENSOR SENSOR=fila ENABLE=0\n"));
} else {
MKSLOG_BLUE("打开断料检测");
ep->Send(json_run_a_gcode("beep_on\nSET_PIN PIN=caselight VALUE=1\nSET_FILAMENT_SENSOR SENSOR=fila ENABLE=1\n"));
}
}
}
*/
}
int detect_disk() {
if (access("/dev/sda", F_OK) == 0) {
if (access("/dev/sda1", F_OK) == 0) {
if (access("/home/mks/gcode_files/sda1", F_OK) != 0) {
system("/usr/bin/systemctl --no-block restart makerbase-automount@sda1.service");
sleep(1);
}
}
return 0;
} else {
return -1;
}
}
void set_printing_shutdown() {
if (page_printing_shutdown_enable == false) {
page_printing_shutdown_enable = true;
} else {
page_printing_shutdown_enable = false;
}
}
void mks_get_version() {
mksversion_load();
mks_version_soc = mksversion_soc("V1.1.1");
mks_version_mcu = mksversion_mcu("V0.10.0");
mks_version_ui = mksversion_ui("V1.1.1");
mksversion_free();
}
void wifi_save_config() {
page_to(TJC_PAGE_WIFI_SAVING);
mks_save_config();
sleep(2);
get_wlan0_status();
}
void disable_page_about_successed() {
page_about_successed = true;
}
void finish_tjc_update() {
if (access("/root/800_480.tft", F_OK) == 0) {
system("mv /root/800_480.tft /root/800_480.tft.bak; sync");
}
}
void filament_load() {
send_cmd_vis(tty_fd, "b2", "0");
send_cmd_vis(tty_fd, "t4", "1");
send_cmd_vis(tty_fd, "b3", "0");
send_cmd_picc(tty_fd, "q0", "194");
send_cmd_pco(tty_fd, "t0", "65535");
send_cmd_pco(tty_fd, "t3", "38066");
send_cmd_vis(tty_fd, "gm1", "0");
send_cmd_vis(tty_fd, "gm2", "1");
printer_idle_timeout_state = "Printing";
ep->Send(json_run_a_gcode("M109 S" + std::to_string(load_target) + "\n"));
ep->Send(json_run_a_gcode("M604\n"));
}
void filament_unload() {
// send_cmd_vis(tty_fd, "b2", "0");
// send_cmd_vis(tty_fd, "t4", "1");
// send_cmd_vis(tty_fd, "b3", "0");
// send_cmd_picc(tty_fd, "q0", "194");
// send_cmd_pco(tty_fd, "t0", "65535");
// send_cmd_pco(tty_fd, "t3", "38066");
// send_cmd_vis(tty_fd, "gm1", "0");
// send_cmd_vis(tty_fd, "gm2", "1");
printer_idle_timeout_state = "Printing";
ep->Send(json_run_a_gcode("M109 S" + std::to_string(load_target) + "\n"));
ep->Send(json_run_a_gcode("M603\n"));
}
int get_cal_printed_time(int print_time) {
int printed_time = 0;
printed_time = print_time / 60;
return printed_time;
}
int get_mks_total_printed_time() {
mksini_load();
mks_total_printed_minutes = mksini_getint("total", "time", 0);
mksini_free();
return mks_total_printed_minutes;
}
void set_mks_total_printed_time(int printed_time) {
mksini_load();
std::cout << "######## " << printed_time << std::endl;
mksini_set("total", "time", std::to_string(printed_time));
mksini_save();
mksini_free();
system("sync");
}
void get_total_time() {
ep->Send(json_get_job_totals());
}
void do_not_x_clear() {
set_mks_total_printed_time(36000);
}
void do_x_clear() {
set_mks_total_printed_time(0);
}
void level_mode_printing_set_target() {
set_heater_bed_target(level_mode_printing_heater_bed_target);
ep->Send(json_run_a_gcode("M190 S" + std::to_string(level_mode_printing_heater_bed_target)));
set_extruder_target(level_mode_printing_extruder_target);
ep->Send(json_run_a_gcode("M109 S" + std::to_string(level_mode_printing_extruder_target)));
}
void level_mode_printing_print_file() {
start_printing("LEVEL_PRINTING.gcode");
}
void update_finished_tips() {
// page_to(TJC_PAGE_UPDATE_FINISH);
sleep(5);
system("sync");
system("systemctl restart makerbase-client.service");
}
bool get_mks_oobe_enabled() {
mksini_load();
mks_oobe_enabled = mksini_getboolean("oobe", "enable", 0);
mksini_free();
return mks_oobe_enabled;
}
void set_mks_oobe_enabled(bool enable) {
mksini_load();
mksini_set("oobe", "enable", std::to_string(enable));
mksini_save();
mksini_free();
system("sync");
}
void move_motors_off() {
ep->Send(json_run_a_gcode("M84\n"));
}
void open_more_level_finish() {
init_mks_status();
// ep->Send(json_run_a_gcode("G28\n"));
set_mks_oobe_enabled(false); // 完成关闭OOBE的操作
get_object_status();
page_to(TJC_PAGE_MAIN);
}
void open_move_tip() {
ep->Send(json_run_a_gcode("G91\nG1 Z-100 F600\nG1 X-100 Y-100 F1200\nG90"));
}
void open_set_print_filament_target() {
if (0 == printer_extruder_target) {
get_mks_extruder_target();
set_extruder_target(mks_extruder_target);
} else {
set_extruder_target(0);
}
}
void open_start_extrude() {
ep->Send(json_run_a_gcode("M83\nG1 E20 F300\n"));
}
void open_calibrate_start() {
step_1 = false; // CLL 当该值为true表示打印机已完成平台和喷嘴位置初始化
step_2 = false; // CLL 当该值为true表示打印机已完成采集补偿值
step_3 = false; // CLL 当该值为true表示打印机已完成共振补偿
printer_idle_timeout_state = "Printing";
page_to(TJC_PAGE_OPEN_CALIBRATE);
ep->Send(json_run_a_gcode("M4028")); // printer.cfg中文件自定义gcode "M4028"
}
void close_mcu_port() {
ep->Send(json_run_a_gcode("CLOSE_MCU_PORT\n"));
}
void oobe_set_intern_zoffset(float offset) {
oobe_printer_set_offset = offset;
}
void oobe_set_zoffset(bool positive) {
if (positive == true) {
ep->Send(json_run_a_gcode("SET_GCODE_OFFSET Z_ADJUST=+" + std::to_string(oobe_printer_set_offset) + " MOVE=1"));
} else {
ep->Send(json_run_a_gcode("SET_GCODE_OFFSET Z_ADJUST=-" + std::to_string(oobe_printer_set_offset) + " MOVE=1"));
}
}
void refresh_page_zoffset() {
std::string temp[5][5];
for (int i = 0; i < printer_bed_mesh_profiles_mks_mesh_params_y_count; i++) {
if (i == 5) {
break;
}
for (int j = 0; j < printer_bed_mesh_profiles_mks_mesh_params_x_count; j++) {
if (j == 5) {
break;
}
temp[i][j] = std::to_string(printer_bed_mesh_profiles_mks_points[i][j]);
temp[i][j] = temp[i][j].substr(0, temp[i][j].find(".") + 3);
send_cmd_txt(tty_fd, "t" + std::to_string(5 * i + j), temp[i][j]);
}
}
}
void refresh_page_auto_heaterbed() {
send_cmd_txt(tty_fd, "t0", std::to_string(printer_heater_bed_temperature) + "/");
send_cmd_val(tty_fd, "n0", std::to_string(printer_heater_bed_target));
if (printer_heater_bed_target > 0) {
send_cmd_picc(tty_fd, "b2", "106");
send_cmd_picc2(tty_fd, "b2", "105");
send_cmd_pco(tty_fd, "t0", "63488");
send_cmd_pco(tty_fd, "n0", "63488");
} else {
send_cmd_picc(tty_fd, "b2", "107");
send_cmd_picc2(tty_fd, "b2", "104");
send_cmd_pco(tty_fd, "t0", "65535");
send_cmd_pco(tty_fd, "n0", "65535");
}
}
void set_auto_level_heater_bed_target(bool positive) {
get_mks_heater_bed_target();
printer_auto_level_heater_bed_target = mks_heater_bed_target;
if (positive == true) {
printer_auto_level_heater_bed_target += 3;
}else {
printer_auto_level_heater_bed_target -= 3;
}
if (printer_auto_level_heater_bed_target >120) {
printer_auto_level_heater_bed_target =120;
}
if (printer_auto_level_heater_bed_target < 0) {
printer_auto_level_heater_bed_target = 0;
}
set_heater_bed_target(printer_auto_level_heater_bed_target);
set_mks_heater_bed_target(printer_auto_level_heater_bed_target);
}
void detect_error() {
switch (current_page_id)
{
case TJC_PAGE_PRINTING:
case TJC_PAGE_PRINT_ZOFFSET:
case TJC_PAGE_PRINT_FILAMENT:
case TJC_PAGE_PRINTING_2:
case TJC_PAGE_GCODE_ERROR:
case TJC_PAGE_LEVEL_ERROR:
case TJC_PAGE_DETECT_ERROR:
case TJC_PAGE_UPDATING:
break;
case TJC_PAGE_OPEN_CALIBRATE:
case TJC_PAGE_AUTO_MOVING:
ep->Send(json_run_a_gcode("RESTART"));
jump_to_level_error = true;
break;
default:
if (printer_webhooks_state != "shutdown" && printer_webhooks_state != "error") {
//4.1.5 新增息屏功能
if (previous_caselight_value == true) {
led_on_off();
previous_caselight_value = false;
}
jump_to_detect_error = true;
}
break;
}
}
void clear_previous_data() {
sdcard_reset_file();
clear_cp0_image();
clear_page_preview();
show_preview_complete = false;
printing_keyboard_enabled = false;
}
void print_start() {
if (printer_bed_leveling == true) {
ep->Send(json_run_a_gcode("G31\n"));
} else {
ep->Send(json_run_a_gcode("G32\n"));
}
}
void open_heater_bed_up() {
page_to(TJC_PAGE_OPEN_FILAMENTVIDEO_1);
ep->Send(json_run_a_gcode("SET_KINEMATIC_POSITION Z=150\nSET_KINEMATIC_POSITION X=150\nSET_KINEMATIC_POSITION Y=150\n"));
ep->Send(json_run_a_gcode("G91\nG1 Z-30 F600\nG1 X-30 Y-30 F1200\nG90\nM84\n"));
}
void refresh_page_open_heaterbed() {
send_cmd_txt(tty_fd, "t0", std::to_string(printer_heater_bed_temperature) + "/");
send_cmd_val(tty_fd, "n0", std::to_string(printer_heater_bed_target));
if (printer_heater_bed_target > 0) {
send_cmd_picc(tty_fd, "b0", "18");
send_cmd_picc2(tty_fd, "b0", "14");
send_cmd_pco(tty_fd, "t0", "63488");
send_cmd_pco(tty_fd, "n0", "63488");
} else {
send_cmd_picc(tty_fd, "b0", "15");
send_cmd_picc2(tty_fd, "b0", "13");
send_cmd_pco(tty_fd, "t0", "65535");
send_cmd_pco(tty_fd, "n0", "65535");
}
}
void bed_leveling_switch(bool positive) {
if (positive == true) {
ep->Send(json_run_a_gcode("G31"));
printer_bed_leveling = true;
}
if (positive == false) {
ep->Send(json_run_a_gcode("G32"));
printer_bed_leveling = false;
}
}
void save_current_zoffset() {
std::string z_offset = std::to_string(printer_gcode_move_homing_origin[2]);
z_offset = z_offset.substr(0, z_offset.find(".") + 4);
switch (current_page_id)
{
case TJC_PAGE_AUTO_MOVING:
case TJC_PAGE_OPEN_CALIBRATE:
printer_idle_timeout_state = "Printing";
float z;
get_mks_babystep();
z = std::stof(mks_babystep_value) + std::stof(mks_adxl_offset);
if (z > -5 && z < 5) { // CLL 仅保存-5~5的zoffset值
mks_babystep_value = std::to_string(z);
set_mks_babystep(mks_babystep_value);
MKSLOG_RED("当前zoffset值保存为%s",mks_babystep_value.c_str());
}
break;
default:
if (z_offset != mks_babystep_value && z_offset.find("0.000") != -1) {
if (std::stof(z_offset) > -5 && std::stof(z_offset) < 5) {
mks_babystep_value = z_offset;
set_mks_babystep(mks_babystep_value);
MKSLOG_RED("当前zoffset值保存为:%s",mks_babystep_value.c_str());
}
}
break;
}
}
void refresh_page_filament_pop() {
send_cmd_txt(tty_fd, "t4", "(" + std::to_string(printer_extruder_temperature) + "/" + std::to_string(printer_extruder_target) + "℃)");
if (step_1 == true) {
step_1 = false;
send_cmd_picc(tty_fd, "q0", "195");
send_cmd_pco(tty_fd, "t1", "65535");
send_cmd_pco(tty_fd, "t0", "38066");
send_cmd_pco(tty_fd, "t4", "38066");
send_cmd_vis(tty_fd, "gm2", "0");
send_cmd_vis(tty_fd, "gm3", "1");
}
if (step_2 == true && printer_idle_timeout_state == "Ready") {
step_2 = false;
send_cmd_picc(tty_fd, "q0", "197");
send_cmd_pco(tty_fd, "t2", "65535");
send_cmd_pco(tty_fd, "t1", "38066");
send_cmd_vis(tty_fd, "b0", "1");
send_cmd_vis(tty_fd, "b1", "1");
send_cmd_vis(tty_fd, "gm3", "0");
}
}
void check_filament_type() {
std::string filament_type;
if (file_metadata_filament_type != "") {
filament_type = file_metadata_filament_type;
} else {
filament_type = file_metadata_filament_name;
}
std::transform(filament_type.begin(), filament_type.end(), filament_type.begin(), tolower);
MKSLOG_YELLOW("filament_type : %s",filament_type.c_str());
//4.4.1 CLL 耗材确认弹窗新增不再提示按钮
if ((filament_type.find("pla") != -1 || filament_type.find("petg") != -1) && preview_pop_1_on == true) {
page_to(TJC_PAGE_PREVIEW_POP_1);
}else if (filament_type.find("abs") != -1 && preview_pop_2_on == true) {
page_to(TJC_PAGE_PREVIEW_POP_2);
}else {
page_to(TJC_PAGE_PRINTING);
}
}
void refresh_page_preview_pop() {
//4.4.2 使mates与霍尔耗材宽度探测器适配
if (filament_detected == false) {
sleep(1);
set_print_pause();
page_to(TJC_PAGE_PRINT_NO_FILAMENT);
}
if (printer_print_stats_state == "standby") {
page_to(TJC_PAGE_PRINT_STOPPING);
}
if (printer_print_stats_state == "error") {
page_to(TJC_PAGE_GCODE_ERROR);
cancel_print();
clear_previous_data();
send_cmd_txt(tty_fd, "t0", "gcode error:" + error_message);
}
}
std::string replaceCharacters(const std::string& path, const std::string& searchChars, const std::string& replacement) {
std::string result = path;
for (char c : searchChars) {
std::size_t found = result.find(c);
while (found != std::string::npos) {
result.replace(found, 1, replacement);
found = result.find(c, found + replacement.length());
}
}
return result;
}
//4.4.2 使mates适配霍尔宽度检测器
void check_filament_width() {
if (filament_message.find("// Filament dia (measured mm):") != -1) {
float filament_width = std::stof(filament_message.substr(31));
MKSLOG("耗材宽度：%f",filament_width);
if (filament_width < 0.3){
filament_detected = false;
} else {
filament_detected = true;
}
} else if (filament_message.find("// Filament NOT present") != -1 || filament_message.find("echo: Filament run out") != -1) {
filament_detected = false;
}
}
//4.4.2 CLL 新增刷新文件列表函数
void refresh_page_files_list_2() {
if (file_mode == "USB") {
if (detect_disk() == -1) {
file_mode = "NULL";
page_to(TJC_PAGE_FILE_LIST);
page_files_pages = 0;
page_files_current_pages = 0;
page_files_folder_layers = 1;
page_files_previous_path = "";
page_files_root_path = "gcodes/";
page_files_path = "/sda1";
refresh_page_files(page_files_current_pages);
refresh_page_files_list();
get_object_status();
}
} else if (file_mode == "NULL") {
if (detect_disk() == 0) {
sleep(1);
file_mode ="USB";
page_to(TJC_PAGE_FILE_LIST);
page_files_pages = 0;
page_files_current_pages = 0;
page_files_folder_layers = 1;
page_files_previous_path = "";
page_files_root_path = "gcodes/";
page_files_path = "/sda1";
refresh_page_files(page_files_current_pages);
refresh_page_files_list();
get_object_status();
}
}
}
void go_to_update() {
get_mks_connection_method();
page_to(TJC_PAGE_UPDATE_MODE);
send_cmd_txt(tty_fd, "t1", mks_version_soc);
if (connection_method == 0)
send_cmd_vis(tty_fd, "b2", "0");
}
void restore_config() {
system("rm /home/mks/gcode_files/.cache/*");
main_picture_refreshed = false;
system("curl -X POST http://127.0.0.1:7125/server/history/reset_totals");
system("curl -X DELETE 'http://127.0.0.1:7125/server/history/job?all=true'");
system("cp /root/config.mksini /home/mks/klipper_config/config.mksini");
system("cp /home/mks/klipper_config/saved_variables.cfg.bak /home/mks/klipper_config/saved_variables.cfg");
ep->Send(json_run_a_gcode("SAVE_VARIABLE VARIABLE=z_offset VALUE=0"));
page_to(TJC_PAGE_MAIN);
}
void refresh_page_bed_moving() {
if (printer_idle_timeout_state == "Ready") {
if (manual_count == 3) {
page_to(TJC_PAGE_PRE_BED_CALIBRATION);
} else if (manual_count == -2) {
page_to(TJC_PAGE_BED_FINISH);
} else {
page_to(TJC_PAGE_BED_CALIBRATION);
}
}
}
void bed_calibrate() {
if (manual_count == 4) {
bed_offset = 0;
printer_idle_timeout_state = "Printing";
ep->Send(json_run_a_gcode("ABORT\n"));
ep->Send(json_run_a_gcode("M4030"));
page_to(TJC_PAGE_BED_MOVING);
}else if (manual_count == 3) {
printer_idle_timeout_state = "Printing";
ep->Send(json_run_a_gcode("G1 Z10 F600"));
ep->Send(json_run_a_gcode("BED_SCREWS_ADJUST\n"));
ep->Send(json_run_a_gcode("G1 Z" + std::to_string(bed_offset) + " F600\n"));
MKSLOG_BLUE("当前bed_offset:%f", bed_offset);
page_to(TJC_PAGE_BED_MOVING);
} else if (manual_count > 0) {
printer_idle_timeout_state = "Printing";
ep->Send(json_run_a_gcode("ACCEPT\n"));
ep->Send(json_run_a_gcode("G1 Z" + std::to_string(bed_offset) + " F600\n"));
page_to(TJC_PAGE_BED_MOVING);
} else if (manual_count == 0) {
ep->Send(json_run_a_gcode("ACCEPT\n"));
ep->Send(json_run_a_gcode("G1 Z10 F600\nG1 X0 Y0 F9000\n"));
init_mks_status();
page_to(TJC_PAGE_BED_FINISH);
} else {
ep->Send(json_run_a_gcode("G1 Z10 F600\n"));
page_to(TJC_PAGE_BED_FINISH);
}
manual_count--;
}
void bed_adjust(bool status) {
if (status == true) {
ep->Send(json_run_a_gcode("G91\nG1 Z" + std::to_string(-auto_level_dist) + " F600\nG90\n"));
bed_offset = bed_offset - auto_level_dist;
MKSLOG_BLUE("当前bed_offset:%f", bed_offset);
} else if (status == false) {
ep->Send(json_run_a_gcode("G91\nG1 Z" + std::to_string(auto_level_dist) + " F600\nG90\n"));
bed_offset = bed_offset + auto_level_dist;
MKSLOG_BLUE("当前bed_offset:%f", bed_offset);
}
}
void go_to_file_list() {
if (file_mode == "Local") {
page_to(TJC_PAGE_FILE_LIST);
page_files_pages = 0;
page_files_current_pages = 0;
page_files_folder_layers = 0;
page_files_previous_path = "";
page_files_root_path = DEFAULT_DIR;
page_files_path = "";
refresh_page_files(page_files_current_pages);
refresh_page_files_list();
get_object_status();
} else {
page_to(TJC_PAGE_FILE_LIST);
page_files_pages = 0;
page_files_current_pages = 0;
page_files_folder_layers = 1;
page_files_previous_path = "";
page_files_root_path = DEFAULT_DIR;
page_files_path = "/sda1";
refresh_page_files(page_files_current_pages);
refresh_page_files_list();
get_object_status();
}
}
void send_gcode(std::string command) {
ep->Send(json_run_a_gcode(command));
}
void refresh_page_open_calibrate() {
if (step_3 == true) {
step_3 = false;
system("sync"); // CLL 保存系统信息后跳转至装料页面
sleep(10);
get_object_status();
sub_object_status();
page_to(TJC_PAGE_OPEN_FILAMENTVIDEO_0);
}
if (step_2 == true && printer_webhooks_state == "ready") {
step_2 = false;
send_cmd_picc(tty_fd, "q0", "21");
send_cmd_pco(tty_fd, "t3", "65535");
sleep(5);
ep->Send(json_run_a_gcode("M901")); // CLL 平台调平完成后进行共振补偿
}
if (step_1 == true && printer_idle_timeout_state == "Ready") {
step_1 = false;
send_cmd_picc(tty_fd, "q0", "20");
send_cmd_pco(tty_fd, "t2", "65535");
get_mks_heater_bed_target();
set_heater_bed_target(mks_heater_bed_target);
ep->Send(json_run_a_gcode("M190 S" + std::to_string(mks_heater_bed_target) + "\n"));
sleep(5);
ep->Send(json_run_a_gcode("M4027")); // CLL 平台和喷嘴位置初始化完成后进行调平
}
}
void refresh_page_filament_set_fan() {
if (move_fan_setting == false) { // CLL 当检测到风扇滑块未被按下时执行刷新函数
send_cmd_val(tty_fd, "h0", std::to_string((int)(printer_out_pin_fan0_value * 100)));
send_cmd_val(tty_fd, "n0", std::to_string((int)(printer_out_pin_fan0_value * 100)));
send_cmd_val(tty_fd, "h1", std::to_string((int)(printer_out_pin_fan2_value * 100)));
send_cmd_val(tty_fd, "n1", std::to_string((int)(printer_out_pin_fan2_value * 100)));
send_cmd_val(tty_fd, "h2", std::to_string((int)(printer_out_pin_fan3_value * 100)));
send_cmd_val(tty_fd, "n2", std::to_string((int)(printer_out_pin_fan3_value * 100)));
if (printer_out_pin_fan0_value == 0) {
send_cmd_picc(tty_fd, "b0", "201");
send_cmd_picc2(tty_fd, "b0", "199");
} else {
send_cmd_picc(tty_fd, "b0", "202");
send_cmd_picc2(tty_fd, "b0", "200");
}
if (printer_out_pin_fan2_value == 0) {
send_cmd_picc(tty_fd, "b1", "201");
send_cmd_picc2(tty_fd, "b1", "199");
} else {
send_cmd_picc(tty_fd, "b1", "202");
send_cmd_picc2(tty_fd, "b1", "200");
}
if (printer_out_pin_fan3_value == 0) {
send_cmd_picc(tty_fd, "b2", "201");
send_cmd_picc2(tty_fd, "b2", "199");
} else {
send_cmd_picc(tty_fd, "b2", "202");
send_cmd_picc2(tty_fd, "b2", "200");
}
}
}
// CLL 记住上次进入调整页面时的选择
void go_to_adjust() {
if (adjust_mode == "Filament") {
page_to(TJC_PAGE_FILAMENT);
} else {
page_to(TJC_PAGE_MOVE);
}
}
void go_to_setting() {
if (set_mode == "Level_mode") {
page_to(TJC_PAGE_LEVEL_MODE);
} else {
page_to(TJC_PAGE_COMMON_SETTING);
}
}
void refresh_page_common_setting() {
current_mks_oobe_enabled = get_mks_oobe_enabled();
send_cmd_txt(tty_fd, "t7", mks_version_soc);
if (current_mks_oobe_enabled == false) {
send_cmd_picc(tty_fd, "b6", "137");
send_cmd_picc2(tty_fd, "b6", "135");
} else {
send_cmd_picc(tty_fd, "b6", "138");
send_cmd_picc2(tty_fd, "b6", "136");
send_cmd_txt(tty_fd, "t6", "开机引导");
}
}
// CLL 该函数用于执行导出日志操作
void print_log() {
if (detect_disk() == -1) {
page_to(TJC_PAGE_PRINT_LOG_F); // CLL 若U盘未插入，提示导出失败，请客户检查U盘插入
} else {
system("mkdir /home/mks/gcode_files/sda1/QD_Log");
system("bash -c 'cp /home/mks/klipper_logs/klippy.log* /home/mks/gcode_files/sda1/QD_Log/'");
system("bash -c 'cp /home/mks/klipper_logs/moonraker.log* /home/mks/gcode_files/sda1/QD_Log/'");
system("bash -c 'cp /home/mks/klipper_logs/auto_update.log* /home/mks/gcode_files/sda1/QD_Log/'");
system("bash -c 'cp /root/frp/frpc.log* /home/mks/gcode_files/sda1/QD_Log/'");
system("bash -c 'cp /root/frp/frpc.*.log /home/mks/gcode_files/sda1/QD_Log/'");
system("cp /root/frp/frpc.toml /home/mks/gcode_files/sda1/QD_Log/server.cfg");
page_to(TJC_PAGE_PRINT_LOG_S);
}
}
void refresh_files_list_picture(std::string path, int pixel, int i) {
file_metadata_simage.clear();
file_metadata_gimage.clear();
mks_file_parse_finished = false;
output_imgdata(path, pixel);
std::ifstream infile("/home/mks/tjc"); // 打开文件
if (!infile) {
std::cerr << "无法打开文件 " << "/home/mks/tjc" << std::endl;
show_preview_complete = true;
return;
}
std::stringstream buffer;
buffer << infile.rdbuf();
file_metadata_gimage = buffer.str();
infile.close();
send_cmd_baud(tty_fd, 921600);
//usleep(50000);
usleep(10000);
set_option(tty_fd, 921600, 8, 'N', 1);
send_cmd_cp_close(tty_fd, "cp"+std::to_string(i));
if (file_metadata_gimage != "") {
std::cout << "刷文件图" << std::endl;
int num = 2048;
int len = file_metadata_gimage.length();
int end = num;
std::string g;
for (int start = 0; start < len;) {
if (end > len) {
g = file_metadata_gimage.substr(start, len - start);
tcdrain(tty_fd);
send_cmd_cp_image(tty_fd, "cp" + std::to_string(i), g);
break;
}
g = file_metadata_gimage.substr(start, num);
start = end;
end = end + num;
tcdrain(tty_fd);
send_cmd_cp_image(tty_fd, "cp" + std::to_string(i), g);
}
}
send_cmd_baud(tty_fd, 115200);
//usleep(50000);
usleep(10000);
set_option(tty_fd, 115200, 8, 'N', 1);
send_cmd_vis(tty_fd, "cp" + std::to_string(i), "1");
}
std::string input_path;
int input_size;
bool start_path = false;
void refresh_files_list_picture_2(std::string path, int size, int i) {
input_path = path;
input_size = size;
begin_show_64_jpg = true;
}
int refresh_files_list_picture_3(const char *inputPath, int size, int i) {
return 0;
}
void refresh_page_filament() {
send_cmd_txt(tty_fd, "t0", std::to_string(printer_extruder_temperature));
send_cmd_val(tty_fd, "n0", std::to_string(printer_extruder_target));
send_cmd_txt(tty_fd, "t1", std::to_string(printer_heater_bed_temperature));
send_cmd_val(tty_fd, "n1", std::to_string(printer_heater_bed_target));
send_cmd_txt(tty_fd, "t2", std::to_string(printer_hot_temperature));
send_cmd_val(tty_fd, "n2", std::to_string(printer_hot_target));
if (printer_extruder_target > 0) {// CLL 根据喷头是否加热改变按钮显示状态
send_cmd_picc(tty_fd, "b2", "177");
send_cmd_picc2(tty_fd, "b2", "174");
send_cmd_picc(tty_fd, "b0", "177");
send_cmd_picc2(tty_fd, "b0", "174");
send_cmd_pco(tty_fd, "t0", "63488");
} else {
send_cmd_picc(tty_fd, "b2", "176");
send_cmd_picc2(tty_fd, "b2", "175");
send_cmd_picc(tty_fd, "b0", "176");
send_cmd_picc2(tty_fd, "b0", "175");
send_cmd_pco(tty_fd, "t0", "65535");
}
if (printer_heater_bed_target > 0) { // CLL 根据热床是否加热改变按钮显示状态
send_cmd_picc(tty_fd, "b3", "177");
send_cmd_picc2(tty_fd, "b3", "174");
send_cmd_picc(tty_fd, "b1", "177");
send_cmd_picc2(tty_fd, "b1", "174");
send_cmd_pco(tty_fd, "t1", "63488");
} else {
send_cmd_picc(tty_fd, "b3", "176");
send_cmd_picc2(tty_fd, "b3", "175");
send_cmd_picc(tty_fd, "b1", "176");
send_cmd_picc2(tty_fd, "b1", "175");
send_cmd_pco(tty_fd, "t1", "65535");
}
if (printer_hot_target > 0) {
send_cmd_picc(tty_fd, "b12", "177");
send_cmd_picc2(tty_fd, "b12", "174");
send_cmd_picc(tty_fd, "b13", "177");
send_cmd_picc2(tty_fd, "b13", "174");
send_cmd_pco(tty_fd, "t2", "63488");
} else {
send_cmd_picc(tty_fd, "b12", "176");
send_cmd_picc2(tty_fd, "b12", "175");
send_cmd_picc(tty_fd, "b13", "176");
send_cmd_picc2(tty_fd, "b13", "175");
send_cmd_pco(tty_fd, "t2", "65535");
}
if (printer_filament_extruedr_dist == 10) {
send_cmd_picc(tty_fd, "b9", "177");
send_cmd_picc2(tty_fd, "b9", "174");
send_cmd_picc(tty_fd, "b10", "176");
send_cmd_picc2(tty_fd, "b10", "175");
send_cmd_picc(tty_fd, "b11", "176");
send_cmd_picc2(tty_fd, "b11", "175");
} else if (printer_filament_extruedr_dist == 50) {
send_cmd_picc(tty_fd, "b9", "176");
send_cmd_picc2(tty_fd, "b9", "175");
send_cmd_picc(tty_fd, "b10", "177");
send_cmd_picc2(tty_fd, "b10", "174");
send_cmd_picc(tty_fd, "b11", "176");
send_cmd_picc2(tty_fd, "b11", "175");
} else if (printer_filament_extruedr_dist == 100) {
send_cmd_picc(tty_fd, "b9", "176");
send_cmd_picc2(tty_fd, "b9", "175");
send_cmd_picc(tty_fd, "b10", "176");
send_cmd_picc2(tty_fd, "b10", "175");
send_cmd_picc(tty_fd, "b11", "177");
send_cmd_picc2(tty_fd, "b11", "174");
}
}
void get_mks_connection_method() {
mksini_load();
connection_method = mksini_getint("app_connection", "method", 0);
mksini_free();
}
void set_mks_connection_method(int target) {
qr_refreshed = false;
mksini_load();
std::cout << "######## " << target << std::endl;
mksini_set("app_connection", "method", std::to_string(target));
mksini_save();
mksini_free();
system("sync");
}
void refresh_page_show_qr() {
if (mks_ethernet == 0) {
send_cmd_txt(tty_fd, "t0", status_result.ip_address);
send_cmd_picc(tty_fd, "b4", "268");
send_cmd_picc2(tty_fd, "b4", "214");
} else {
std::string local_ip = get_eth0_ip();
send_cmd_txt(tty_fd, "t0", local_ip);
send_cmd_picc(tty_fd, "b4", "269");
send_cmd_picc2(tty_fd, "b4", "215");
}
}
void go_to_showqr() {
std::string qrmessage;
get_mks_connection_method();
page_to(TJC_PAGE_SHOW_QR);
if (strcmp(status_result.wpa_state, "COMPLETED") == 0 || mks_ethernet) {
if (qr_refreshed == false) {
send_cmd_cp_close(tty_fd, "cp0");
if (open_qr_refreshed == true || access("/home/mks/qrcode/qrcode.jpg", F_OK) == -1)
qrmessage = run_python_code("python3 /home/mks/qrcode/qrcode_QD.py 176\n");
std::cout << "qrmessage:" << qrmessage << std::endl;
if (qrmessage.find("Missing or invalid") != -1) {
send_cmd_txt(tty_fd, "t4", qrmessage);
send_cmd_vis(tty_fd, "t4", "1");
} else if (qrmessage.find("No") != -1) {
send_cmd_vis(tty_fd, "t4", "1");
} else {
open_qr_refreshed = true;
refresh_files_list_picture("/home/mks/qrcode/qrcode.jpg", 176, 0);
qr_refreshed = true;
}
}
} else {
send_cmd_vis(tty_fd, "t4", "1");
send_cmd_cp_close(tty_fd, "cp0");
}
}
void get_mks_selected_server() {
mksini_load();
selected_server = mksini_getstring("app_server", "name", "");
mksini_free();
std::cout << selected_server << std::endl;
}
void go_to_server_set(int n) {
current_server_page = n;
total_server_count = 0;
serverConfigs.clear();
if (connection_method == 1 && strcmp(status_result.wpa_state, "COMPLETED") == 0) {
page_to(TJC_PAGE_SEARCH_SERVER);
update_server(0);
get_mks_selected_server();
get_mks_connection_method();
}
page_to(TJC_PAGE_SERVER_SET);
}
void updateServerConfig(std::vector<std::string> &lines, const Server_config &config)
{
for (size_t i = 0; i < lines.size(); ++i)
{
if (lines[i] == "[app_server]")
{
// 检查是否已经到达文件末尾
if (i + 1 < lines.size())
{
// 直接更新下一行，无需考虑空格数量
lines[i + 1] = "name = " + config.name;
return;
}
}
}
// 如果没有找到[app_server]节，就在文件末尾添加
lines.push_back("[app_server]");
lines.push_back("name = " + config.name);
}
void update_server(int choice)
{
// CLL 连接服务器获取json文件
if (choice == 0) {
// system("curl -s -S -L -o /root/frp/server_list.json http://www.aws.qidi3dprinter.com:5050/downloads/server_list.json");
get_mks_selected_server();
std::string server_for_command = selected_server.empty() ? "aws" : selected_server;
std::string command = "curl -s -S -L -o /root/frp/server_list.json http://www." + server_for_command + ".qidi3dprinter.com:5050/downloads/server_list.json";
std::cout << "Executing command: " << command << std::endl;
system(command.c_str());
} else {
qr_refreshed = false; // CLL 当choice不为0时，该函数用于切换服务器，需要重新刷新二维码
}
total_server_count = 0;
const std::string FRPC_CONFIG_PATH = "/root/frp/frpc.toml";
const std::string MKSCONFIG_PATH = "/home/mks/klipper_config/config.mksini";
const std::string SERVER_LIST_PATH = "/root/frp/server_list.json"; // JSON 文件路径
try {
// 读取 JSON 文件并解析为服务器配置
std::ifstream jsonFile(SERVER_LIST_PATH);
nlohmann::json serverList;
jsonFile >> serverList;
jsonFile.close();
for (const auto& item : serverList.items())
{
const std::string &key = item.key();
const auto &value = item.value();
int id = std::stoi(key);
Server_config config = {value["address"], value["name"]};
std::cout << id << ":" << config.name << std::endl;
serverConfigs[id] = config;
total_server_count++;
}
}
catch(const std::exception& e)
{
std::cerr << "fail_to_read:" << e.what() << '\n';
}
if (choice != 0) {
if (serverConfigs.find(choice) == serverConfigs.end())
{
std::cout << "Invalid choice. Please enter a valid option.\n";
return;
}
Server_config config = serverConfigs[choice];
// 停止frpc.service
std::cout << "Stopping frpc.service...\n";
system("sudo systemctl stop frpc.service");
// 更新frpc.toml
std::ifstream frpcIn(FRPC_CONFIG_PATH);
std::stringstream buffer;
buffer << frpcIn.rdbuf();
std::string content = buffer.str();
frpcIn.close();
size_t pos = content.find("serverAddr = ");
if (pos != std::string::npos)
{
size_t endPos = content.find('\n', pos);
content.replace(pos, endPos - pos, "serverAddr = \"" + config.address + "\"");
}
std::ofstream frpcOut(FRPC_CONFIG_PATH);
frpcOut << content;
frpcOut.close();
// 读取config.mksini到vector中
std::vector<std::string> lines;
std::ifstream mksIn(MKSCONFIG_PATH);
std::string line;
while (getline(mksIn, line))
{
lines.push_back(line);
}
mksIn.close();
// 更新app_server配置
updateServerConfig(lines, config);
// 将更新后的内容写回config.mksini
std::ofstream mksOut(MKSCONFIG_PATH);
for (const auto &outputLine : lines)
{
mksOut << outputLine << std::endl;
}
mksOut.close();
// 重启frpc.service
std::cout << "Starting frpc.service...\n";
system("sudo systemctl start frpc.service");
std::cout << "Configuration updated to " << config.name << " successfully.\n";
get_mks_selected_server();
}
}
void refresh_page_server_set() {
if (connection_method == 0 || strcmp(status_result.wpa_state, "COMPLETED") != 0) {
send_cmd_picc(tty_fd, "b2", "217");
send_cmd_picc2(tty_fd, "b2", "220");
send_cmd_vis(tty_fd, "t3", "1");
send_cmd_vis(tty_fd, "t0", "0");
send_cmd_vis(tty_fd, "b3", "0");
send_cmd_vis(tty_fd, "b4", "0");
send_cmd_vis(tty_fd, "b0", "0");
} else {
send_cmd_picc(tty_fd, "b2", "218");
send_cmd_picc2(tty_fd, "b2", "219");
send_cmd_vis(tty_fd, "t3", "0");
send_cmd_vis(tty_fd, "t0", "1");
send_cmd_vis(tty_fd, "b3", "1");
send_cmd_vis(tty_fd, "b4", "1");
send_cmd_vis(tty_fd, "b0", "1");
}
if (current_server_page == 0) {
send_cmd_picc(tty_fd, "b3", "218");
send_cmd_picc2(tty_fd, "b3", "219");
} else {
send_cmd_picc(tty_fd, "b3", "217");
send_cmd_picc2(tty_fd, "b3", "220");
}
if ((current_server_page + 1) * 4 >= total_server_count) {
send_cmd_picc(tty_fd, "b4", "218");
send_cmd_picc2(tty_fd, "b4", "219");
} else {
send_cmd_picc(tty_fd, "b4", "217");
send_cmd_picc2(tty_fd, "b4", "220");
}
for (int i = 0; i < 4; i++) {
if (i + current_server_page * 4 + 1 > total_server_count)
break;
send_cmd_txt(tty_fd, "t" + std::to_string(i + 5), serverConfigs[1 + i + current_server_page * 4].name);
if (selected_server == serverConfigs[1 + i + current_server_page * 4].name) {
std::cout << "selected_server:" << serverConfigs[i + 1 + current_server_page * 4].name << std::endl;
send_cmd_picc(tty_fd, "b" + std::to_string(i + 5), "217");
send_cmd_picc2(tty_fd, "b" + std::to_string(i + 5), "219");
} else {
std::cout << "unselected_server:" << serverConfigs[i + 1 + current_server_page * 4].name << std::endl;
send_cmd_picc(tty_fd, "b" + std::to_string(i + 5), "218");
send_cmd_picc2(tty_fd, "b" + std::to_string(i + 5), "220");
}
}
}
void local_update () {
ep->Send(json_get_klippy_host_information());
if (detect_update()) {
page_to(TJC_PAGE_UPDATE_FOUND);
} else {
page_to(TJC_PAGE_UPDATE_NOT_FOUND);
}
}
// CLL 此函数用于调用系统函数后接收返回值
std::string run_python_code(const char* cmd) {
std::array<char, 128> buffer;
std::string result;
std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd, "r"), pclose);
if (!pipe) {
throw std::runtime_error("popen() failed!");
}
while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
result += buffer.data();
}
return result;
}
void check_online_version() {
page_to(TJC_PAGE_SEARCH_SERVER);
if (connection_method == 0)
return;
target_soc_version = run_python_code("python3 /root/auto_update/version_check.py");
std::cout << "服务器版本:" << target_soc_version << std::endl;
if (target_soc_version.find("0") == 0) {
page_to(TJC_PAGE_UPDATE_MODE);
send_cmd_vis(tty_fd, "t2", "1");
send_cmd_vis(tty_fd, "t3", "0");
} else if (target_soc_version.find("-1") == 0) {
page_to(TJC_PAGE_UPDATE_MODE);
send_cmd_vis(tty_fd, "t3", "1");
send_cmd_vis(tty_fd, "t2", "0");
} else {
page_to(TJC_PAGE_ONLINE_UPDATE);
send_cmd_txt(tty_fd, "t1", mks_version_soc);
send_cmd_txt(tty_fd, "t2", target_soc_version);
updateini_load();
std::string cn_info = mksini_getstring("cn", "content", "NULL"); // CLL 获取中文更新说明
std::string ru_info = mksini_getstring("ru", "content", "NULL"); // CLL 获取俄语更新说明
std::string en_info = mksini_getstring("en", "content", "NULL"); // CLL 获取英语更新说明
std::string jp_info = mksini_getstring("jp", "content", "NULL"); // CLL 获取日语更新说明
std::string fr_info = mksini_getstring("fr", "content", "NULL"); // CLL 获取法语更新说明
std::string gr_info = mksini_getstring("gr", "content", "NULL"); // CLL 获取德语更新说明
std::string it_info = mksini_getstring("it", "content", "NULL"); // CLL 获取意大利语更新说明
std::string sp_info = mksini_getstring("sp", "content", "NULL"); // CLL 获取西班牙语更新说明
std::string kr_info = mksini_getstring("kr", "content", "NULL"); // CLL 获取韩语更新说明
std::string pr_info = mksini_getstring("pr", "content", "NULL"); // CLL 获取葡萄牙语更新说明
std::string ar_info = mksini_getstring("ar", "content", "NULL"); // CLL 获取阿拉伯语更新说明
std::string tr_info = mksini_getstring("tr", "content", "NULL"); // CLL 获取土耳其语更新说明
std::string hb_info = mksini_getstring("hb", "content", "NULL"); // CLL 获取希伯来语更新说明
send_cmd_txt(tty_fd, "t_cn", cn_info);
send_cmd_txt(tty_fd, "t_ru", ru_info);
send_cmd_txt(tty_fd, "t_en", en_info);
send_cmd_txt(tty_fd, "t_jp", jp_info);
send_cmd_txt(tty_fd, "t_fr", fr_info);
send_cmd_txt(tty_fd, "t_gr", gr_info);
send_cmd_txt(tty_fd, "t_it", it_info);
send_cmd_txt(tty_fd, "t_sp", sp_info);
send_cmd_txt(tty_fd, "t_kr", kr_info);
send_cmd_txt(tty_fd, "t_pr", pr_info);
send_cmd_txt(tty_fd, "t_ar", ar_info);
send_cmd_txt(tty_fd, "t_tr", tr_info);
send_cmd_txt(tty_fd, "t_hb", hb_info);
mksini_free();
}
}
void online_update() {
page_to(TJC_PAGE_UPDATING);
send_cmd_vis(tty_fd, "j0", "1");
send_cmd_vis(tty_fd, "t1", "1");
pthread_t recevice_progress_pthread;
pthread_create(&recevice_progress_pthread, NULL, recevice_progress_handle, NULL);
system("rm /home/mks/gcode_files/.cache/*\n");
system("python3 /root/auto_update/download_update.py\n");
// page_to(TJC_PAGE_UPDATE_FINISH);
system("sync\n");
system("systemctl restart makerbase-client\n");
}
// CLL 创建线程用于接收在线更新进度
void *recevice_progress_handle(void *arg) {
while(1) {
if (current_page_id == TJC_PAGE_UPDATING) {
progressini_load();
int update_progress = mksini_getint("progress", "value", update_progress);
std::string progress_name = mksini_getstring("filename", "name", progress_name);
mksini_free();
if (progress_name.find("Installing") == -1) {
send_cmd_txt(tty_fd, "t2", progress_name);
send_cmd_val(tty_fd, "j0", std::to_string(update_progress));
send_cmd_txt(tty_fd, "t1", std::to_string(update_progress) + "%");
} else {
page_to(TJC_PAGE_INSTALLING);
break;
}
}
}
return NULL;
}
void refresh_page_auto_unload() {
send_cmd_txt(tty_fd, "t4", "(" + std::to_string(printer_extruder_temperature) + "/" + std::to_string(printer_extruder_target) + "℃)");
if (step_1 == true) {
step_1 = false;
send_cmd_vis(tty_fd, "gm1", "0");
send_cmd_vis(tty_fd, "gm2", "1");
send_cmd_picc(tty_fd, "q0", "231");
send_cmd_pco(tty_fd, "t1", "65535");
send_cmd_pco(tty_fd, "t0", "38066");
}
if (step_2 == true) {
step_2 = false;
send_cmd_vis(tty_fd, "gm2", "0");
send_cmd_picc(tty_fd, "q0", "232");
send_cmd_pco(tty_fd, "t2", "65535");
send_cmd_pco(tty_fd, "t1", "38066");
send_cmd_vis(tty_fd, "b0", "1");
send_cmd_vis(tty_fd, "b1", "1");
}
}
int get_mks_ethernet() {
mksini_load();
mks_ethernet = mksini_getboolean("mks_ethernet", "enable", 0);
mksini_free();
return mks_ethernet;
}
void set_mks_ethernet(int target) {
std::cout << "设置以太网:" << target << std::endl;
mksini_load();
mksini_set("mks_ethernet", "enable", std::to_string(target));
mksini_save();
mksini_free();
mks_ethernet = target;
}
std::string hex_to_utf8(const std::string& hex) {
std::ostringstream utf8;
size_t i = 0;
while (i < hex.size()) {
if (i + 3 < hex.size() && hex[i] == '\\' && hex[i + 1] == 'x') {
std::string hex_byte = hex.substr(i + 2, 2);
int value;
std::istringstream(hex_byte) >> std::hex >> value;
utf8 << static_cast<char>(value);
i += 4;
} else {
utf8 << hex[i++];
}
}
return utf8.str();
}
void check_print_interrupted() {
std::ifstream infile("/home/mks/klipper_config/saved_variables.cfg");
if (!infile) {
std::cerr << "无法打开文件 " << "/home/mks/klipper_config/saved_variables.cfg" << std::endl;
return;
}
std::stringstream buffer;
buffer << infile.rdbuf();
std::string printer_variables = buffer.str();
infile.close();
std::string print_interrupted_status = printer_variables.substr(printer_variables.find("was_interrupted =") + 18, 5);
if (print_interrupted_status != "False") {
ep->Send(json_run_a_gcode("DETECT_INTERRUPTION\n"));
jump_to_resume_print = true;
}
}
Reference in New Issue View Git Blame Copy Permalink