From 3b7b49c62b88813e2685d7ffca52e511b4ac720c Mon Sep 17 00:00:00 2001
From: suchmememanyskill <38142618+suchmememanyskill@users.noreply.github.com>
Date: Thu, 7 Mar 2024 23:25:12 +0100
Subject: [PATCH] Split configuration; start printer panel

---
 CYD-Klipper/src/conf/global_config.cpp        |  80 +++++++--
 CYD-Klipper/src/conf/global_config.h          |  82 +++++----
 CYD-Klipper/src/core/data_setup.cpp           | 108 +++++++++++-
 CYD-Klipper/src/core/data_setup.h             |   8 +
 .../src/core/device/ESP32-2432S028R.cpp       |   6 +-
 .../src/core/device/ESP32-3248S035C.cpp       |   6 +-
 .../src/core/device/ESP32-smartdisplay.cpp    |   4 +-
 CYD-Klipper/src/core/http_client.cpp          |   7 +-
 CYD-Klipper/src/core/lv_setup.cpp             |  37 +++--
 CYD-Klipper/src/main.cpp                      |   2 +-
 CYD-Klipper/src/ui/ip_setup.cpp               |  30 ++--
 CYD-Klipper/src/ui/main_ui.cpp                |   2 +-
 CYD-Klipper/src/ui/nav_buttons.cpp            |  13 ++
 CYD-Klipper/src/ui/ota_setup.cpp              |   2 +-
 CYD-Klipper/src/ui/panels/panel.h             |   1 +
 CYD-Klipper/src/ui/panels/printer_panel.cpp   | 155 ++++++++++++++++++
 CYD-Klipper/src/ui/panels/settings_panel.cpp  |  96 +++++++----
 CYD-Klipper/src/ui/panels/temp_panel.cpp      |  26 +--
 CYD-Klipper/src/ui/wifi_setup.cpp             |  16 +-
 19 files changed, 533 insertions(+), 148 deletions(-)
 create mode 100644 CYD-Klipper/src/ui/panels/printer_panel.cpp

diff --git a/CYD-Klipper/src/conf/global_config.cpp b/CYD-Klipper/src/conf/global_config.cpp
index 7e86626..e717eee 100644
--- a/CYD-Klipper/src/conf/global_config.cpp
+++ b/CYD-Klipper/src/conf/global_config.cpp
@@ -14,14 +14,16 @@ COLOR_DEF color_defs[] = {
     {LV_PALETTE_PURPLE, 0, LV_PALETTE_GREY},
 };
 
-void WriteGlobalConfig() {
+void write_global_config()
+{
     Preferences preferences;
     preferences.begin("global_config", false);
     preferences.putBytes("global_config", &global_config, sizeof(global_config));
     preferences.end();
 }
 
-void VerifyVersion(){
+void verify_version()
+{
     Preferences preferences;
     if (!preferences.begin("global_config", false))
         return;
@@ -37,17 +39,73 @@ void VerifyVersion(){
     preferences.end();
 }
 
-void LoadGlobalConfig() {
+PRINTER_CONFIG* get_current_printer_config()
+{
+    return &global_config.printer_config[global_config.printer_index];
+}
+
+int get_printer_config_count()
+{
+    int count = 0;
+    for (int i = 0; i < PRINTER_CONFIG_COUNT; i++) {
+        if (global_config.printer_config[i].ip_configured)
+            count++;
+    }
+    return count;
+}
+
+int get_printer_config_free_index()
+{
+    for (int i = 0; i < PRINTER_CONFIG_COUNT; i++) {
+        if (!global_config.printer_config[i].ip_configured)
+            return i;
+    }
+    return -1;
+}
+
+void set_printer_config_index(int index)
+{
+    if (index < 0 || index >= PRINTER_CONFIG_COUNT)
+        return;
+
+    PRINTER_CONFIG* old_config = &global_config.printer_config[global_config.printer_index];
+    PRINTER_CONFIG* new_config = &global_config.printer_config[index];
+
+    global_config.printer_index = index;
+
+    if (!new_config->ip_configured){
+        new_config->raw = old_config->raw;
+        new_config->ip_configured = false;
+        new_config->auth_configured = false;
+
+        new_config->printer_name[0] = 0;
+        new_config->klipper_host[0] = 0;
+        new_config->klipper_auth[0] = 0;
+        new_config->klipper_port = 0;
+
+        new_config->color_scheme = old_config->color_scheme;
+
+        for (int i = 0; i < 3; i++){
+            new_config->hotend_presets[i] = old_config->hotend_presets[i];
+            new_config->bed_presets[i] = old_config->bed_presets[i];
+        }
+
+        ESP.restart();
+    }    
+}
+
+void load_global_config() 
+{
     global_config.version = CONFIG_VERSION;
     global_config.brightness = 255;
-    global_config.screenTimeout = 5;
-    global_config.hotend_presets[0] = 0;
-    global_config.hotend_presets[1] = 200;
-    global_config.hotend_presets[2] = 240;
-    global_config.bed_presets[0] = 0;
-    global_config.bed_presets[1] = 60;
-    global_config.bed_presets[2] = 70;
-    VerifyVersion();
+    global_config.screen_timeout = 5;
+    global_config.printer_config[0].hotend_presets[0] = 0;
+    global_config.printer_config[0].hotend_presets[1] = 200;
+    global_config.printer_config[0].hotend_presets[2] = 240;
+    global_config.printer_config[0].bed_presets[0] = 0;
+    global_config.printer_config[0].bed_presets[1] = 60;
+    global_config.printer_config[0].bed_presets[2] = 70;
+    verify_version();
     Preferences preferences;
     preferences.begin("global_config", true);
     preferences.getBytes("global_config", &global_config, sizeof(global_config));
diff --git a/CYD-Klipper/src/conf/global_config.h b/CYD-Klipper/src/conf/global_config.h
index 4ed198e..5a67a01 100644
--- a/CYD-Klipper/src/conf/global_config.h
+++ b/CYD-Klipper/src/conf/global_config.h
@@ -3,7 +3,8 @@
 
 #include "lvgl.h"
 
-#define CONFIG_VERSION 4
+#define CONFIG_VERSION 5
+#define PRINTER_CONFIG_COUNT 8
 
 enum {
     REMAINING_TIME_CALC_PERCENTAGE = 0,
@@ -11,47 +12,62 @@ enum {
     REMAINING_TIME_CALC_SLICER = 2,
 };
 
+typedef struct _PRINTER_CONFIG {
+    union {
+        unsigned int raw;
+        struct {
+            // Internal
+            bool ip_configured : 1;
+            bool auth_configured : 1;
+
+            // External
+            bool light_mode : 1;
+            bool invert_colors : 1;
+            unsigned char remaining_time_calc_mode : 2;
+        };
+    };
+
+    char printer_name[17];
+    char klipper_host[65];
+    char klipper_auth[33];
+    unsigned short klipper_port;
+    
+    unsigned char color_scheme;
+
+    unsigned short hotend_presets[3];
+    unsigned short bed_presets[3];
+} PRINTER_CONFIG;
+
 typedef struct _GLOBAL_CONFIG {
     unsigned char version;
     union {
         unsigned int raw;
         struct {
             // Internal
-            bool screenCalibrated : 1;
-            bool wifiConfigured : 1;
-            bool ipConfigured : 1;
+            bool screen_calibrated : 1;
+            bool wifi_configured : 1;
 
             // External
-            bool lightMode : 1;
-            bool invertColors : 1;
-            bool rotateScreen : 1;
-            bool onDuringPrint : 1;
-            bool autoOtaUpdate : 1;
-            unsigned char remaining_time_calc_mode : 2;
-
-            // Internal
-            bool auth_configured : 1;
+            bool rotate_screen : 1;
+            bool auto_ota_update : 1;
+            bool multi_printer_mode : 1;
+            bool on_during_print : 1;
         };
     };
-    float screenCalXOffset;
-    float screenCalXMult;
-    float screenCalYOffset;
-    float screenCalYMult;
 
-    char wifiSSID[32];
-    char wifiPassword[64];
+    PRINTER_CONFIG printer_config[PRINTER_CONFIG_COUNT];
 
-    char klipperHost[64];
-    unsigned short klipperPort;
+    float screen_cal_x_offset;
+    float screen_cal_x_mult;
+    float screen_cal_y_offset;
+    float screen_cal_y_mult;
+
+    char wifi_SSID[32];
+    char wifi_password[64];
     
-    unsigned char color_scheme;
     unsigned char brightness;
-    unsigned char screenTimeout;
-
-    unsigned short hotend_presets[3];
-    unsigned short bed_presets[3];
-
-    char klipper_auth[33];
+    unsigned char screen_timeout;
+    unsigned char printer_index;
 } GLOBAL_CONFIG;
     
 typedef struct _COLOR_DEF {
@@ -63,8 +79,12 @@ typedef struct _COLOR_DEF {
 extern GLOBAL_CONFIG global_config;
 extern COLOR_DEF color_defs[];
 
-void WriteGlobalConfig();
-void VerifyVersion();
-void LoadGlobalConfig();
+void write_global_config();
+void verify_version();
+void load_global_config();
+
+PRINTER_CONFIG* get_current_printer_config();
+int get_printer_config_count();
+void set_printer_config_index(int index);
 
 #endif // !_GLOBAL_CONFIG_INIT
\ No newline at end of file
diff --git a/CYD-Klipper/src/core/data_setup.cpp b/CYD-Klipper/src/core/data_setup.cpp
index d104ad3..c09743e 100644
--- a/CYD-Klipper/src/core/data_setup.cpp
+++ b/CYD-Klipper/src/core/data_setup.cpp
@@ -14,6 +14,7 @@ const char *printer_state_messages[] = {
     "Printing"};
 
 Printer printer = {0};
+PrinterMinimal *printer_minimal;
 int klipper_request_consecutive_fail_count = 0;
 char filename_buff[512] = {0};
 SemaphoreHandle_t freezeRenderThreadSemaphore, freezeRequestThreadSemaphore;
@@ -49,8 +50,7 @@ void send_gcode(bool wait, const char *gcode)
     SETUP_HTTP_CLIENT_FULL("/printer/gcode/script?script=" + urlEncode(gcode), false, wait ? 5000 : 750);
     try
     {
-        int result = client.GET();
-        Serial.printf("Send gcode result: %d\n", result);
+        client.GET();
     }
     catch (...)
     {
@@ -111,6 +111,7 @@ int last_slicer_time_query = -15000;
 void fetch_printer_data()
 {
     freeze_request_thread();
+    PRINTER_CONFIG *config = get_current_printer_config();
     SETUP_HTTP_CLIENT("/printer/objects/query?extruder&heater_bed&toolhead&gcode_move&virtual_sdcard&print_stats&webhooks&fan")
 
     int httpCode = client.GET();
@@ -247,15 +248,15 @@ void fetch_printer_data()
                     remaining_time_s_slicer = printer.slicer_estimated_print_time_s - printer.elapsed_time_s;
                 }
 
-                if (remaining_time_s_slicer <= 0 || global_config.remaining_time_calc_mode == REMAINING_TIME_CALC_PERCENTAGE)
+                if (remaining_time_s_slicer <= 0 || config->remaining_time_calc_mode == REMAINING_TIME_CALC_PERCENTAGE)
                 {
                     printer.remaining_time_s = remaining_time_s_percentage;
                 }
-                else if (global_config.remaining_time_calc_mode == REMAINING_TIME_CALC_INTERPOLATED)
+                else if (config->remaining_time_calc_mode == REMAINING_TIME_CALC_INTERPOLATED)
                 {
                     printer.remaining_time_s = remaining_time_s_percentage * printer.print_progress + remaining_time_s_slicer * (1 - printer.print_progress);
                 }
-                else if (global_config.remaining_time_calc_mode == REMAINING_TIME_CALC_SLICER)
+                else if (config->remaining_time_calc_mode == REMAINING_TIME_CALC_SLICER)
                 {
                     printer.remaining_time_s = remaining_time_s_slicer;
                 }
@@ -297,6 +298,94 @@ void fetch_printer_data()
     }
 }
 
+void fetch_printer_data_minimal()
+{
+    PrinterMinimal data[PRINTER_CONFIG_COUNT] = {0};
+
+    for (int i = 0; i < PRINTER_CONFIG_COUNT; i++){
+        PRINTER_CONFIG *config = &global_config.printer_config[i];
+
+        if (!config->ip_configured)
+        {
+            data[i].online = false;
+            continue;
+        }
+
+        delay(10);
+        HTTPClient client;
+        configure_http_client(client, "http://" + String(config->klipper_host) + ":" + String(config->klipper_port) + "/printer/objects/query?webhooks&print_stats&virtual_sdcard", true, 1000);
+        freeze_request_thread();
+
+        int httpCode = client.GET();
+        delay(10);
+        if (httpCode == 200)
+        {
+            data[i].online = true;
+            JsonDocument doc;
+            deserializeJson(doc, client.getStream());
+            auto status = doc["result"]["status"];
+
+            unfreeze_request_thread();
+
+            if (status.containsKey("webhooks"))
+            {
+                const char *state = status["webhooks"]["state"];
+
+                if (strcmp(state, "ready") == 0 && data[i].state == PRINTER_STATE_ERROR)
+                {
+                    data[i].state = PRINTER_STATE_IDLE;
+                }
+                else if (strcmp(state, "shutdown") == 0 && data[i].state != PRINTER_STATE_ERROR)
+                {
+                    data[i].state = PRINTER_STATE_ERROR;
+                }
+            }
+
+            if (printer_minimal->state != PRINTER_STATE_ERROR)
+            {
+                if (status.containsKey("virtual_sdcard"))
+                {
+                    data[i].print_progress = status["virtual_sdcard"]["progress"];
+                }
+
+                if (status.containsKey("print_stats"))
+                {
+                    const char *state = status["print_stats"]["state"];
+
+                    if (state == nullptr)
+                    {
+                        data[i].state = PRINTER_STATE_ERROR;
+                    }
+                    else if (strcmp(state, "printing") == 0)
+                    {
+                        data[i].state = PRINTER_STATE_PRINTING;
+                    }
+                    else if (strcmp(state, "paused") == 0)
+                    {
+                        data[i].state = PRINTER_STATE_PAUSED;
+                    }
+                    else if (strcmp(state, "complete") == 0 || strcmp(state, "cancelled") == 0 || strcmp(state, "standby") == 0)
+                    {
+                        data[i].state = PRINTER_STATE_IDLE;
+                    }
+                }
+            }
+
+            Serial.printf("Record: %d %f %d\n", data[i].online, data[i].print_progress, data[i].state);
+        }
+        else 
+        {
+            printer_minimal->online = false;
+            unfreeze_request_thread();
+        }
+    }
+
+    freeze_render_thread();
+    memcpy(printer_minimal, data, sizeof(PrinterMinimal) * PRINTER_CONFIG_COUNT);
+    lv_msg_send(DATA_PRINTER_MINIMAL, NULL);
+    unfreeze_render_thread();
+}
+
 void data_loop()
 {
     // Causes other threads that are trying to lock the thread to actually lock it
@@ -307,9 +396,16 @@ void data_loop()
 
 void data_loop_background(void * param){
     esp_task_wdt_init(10, true);
+    int loop_iter = 20;
     while (true){
         delay(data_update_interval);
         fetch_printer_data();
+        if (global_config.multi_printer_mode) {
+            if (loop_iter++ > 20){
+                fetch_printer_data_minimal();
+                loop_iter = 0;
+            }
+        }
     }
 }
 
@@ -317,9 +413,11 @@ TaskHandle_t background_loop;
 
 void data_setup()
 {
+    printer_minimal = (PrinterMinimal *)calloc(sizeof(PrinterMinimal), PRINTER_CONFIG_COUNT);
     semaphore_init();
     printer.print_filename = filename_buff;
     fetch_printer_data();
+
     macros_query_setup();
     freeze_render_thread();
     xTaskCreatePinnedToCore(data_loop_background, "data_loop_background", 5000, NULL, 0, &background_loop, 0);
diff --git a/CYD-Klipper/src/core/data_setup.h b/CYD-Klipper/src/core/data_setup.h
index d1a4224..f7071cb 100644
--- a/CYD-Klipper/src/core/data_setup.h
+++ b/CYD-Klipper/src/core/data_setup.h
@@ -37,12 +37,20 @@ typedef struct _Printer {
     int slicer_estimated_print_time_s;
 } Printer;
 
+typedef struct _PrinterMinimal {
+    bool online;
+    unsigned char state;
+    float print_progress; // 0 -> 1
+} PrinterMinimal;
+
 extern Printer printer;
+extern PrinterMinimal *printer_minimal;
 extern int klipper_request_consecutive_fail_count;
 
 #define DATA_PRINTER_STATE 1
 #define DATA_PRINTER_DATA 2
 #define DATA_PRINTER_TEMP_PRESET 3
+#define DATA_PRINTER_MINIMAL 4
 
 void data_loop();
 void data_setup();
diff --git a/CYD-Klipper/src/core/device/ESP32-2432S028R.cpp b/CYD-Klipper/src/core/device/ESP32-2432S028R.cpp
index e8a3f70..e38edec 100644
--- a/CYD-Klipper/src/core/device/ESP32-2432S028R.cpp
+++ b/CYD-Klipper/src/core/device/ESP32-2432S028R.cpp
@@ -67,14 +67,14 @@ void screen_lv_touchRead(lv_indev_drv_t *indev_driver, lv_indev_data_t *data)
 }
 
 void set_invert_display(){
-    tft.invertDisplay(global_config.invertColors);
+    tft.invertDisplay(get_current_printer_config()->invert_colors);
 }
 
 void screen_setup()
 {
     touchscreen_spi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
     touchscreen.begin(touchscreen_spi);
-    touchscreen.setRotation(global_config.rotateScreen ? 3 : 1);
+    touchscreen.setRotation(global_config.rotate_screen ? 3 : 1);
 
     lv_init();
 
@@ -83,7 +83,7 @@ void screen_setup()
     ledcSetup(0, 5000, 12);
     ledcAttachPin(21, 0);
 
-    tft.setRotation(global_config.rotateScreen ? 3 : 1);
+    tft.setRotation(global_config.rotate_screen ? 3 : 1);
     tft.fillScreen(TFT_BLACK);
     set_invert_display();
     touchscreen_spi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
diff --git a/CYD-Klipper/src/core/device/ESP32-3248S035C.cpp b/CYD-Klipper/src/core/device/ESP32-3248S035C.cpp
index fd39f00..22ea6d5 100644
--- a/CYD-Klipper/src/core/device/ESP32-3248S035C.cpp
+++ b/CYD-Klipper/src/core/device/ESP32-3248S035C.cpp
@@ -65,7 +65,7 @@ void screen_lv_touchRead(lv_indev_drv_t *indev_driver, lv_indev_data_t *data)
         {
             uint16_t magicX; // fix GT911 driver - orientation and handle rotation
             uint16_t magicY;
-            if (!global_config.rotateScreen)
+            if (!global_config.rotate_screen)
             {
                 magicY = tp.points[i].x;
                 magicX = TOUCH_HEIGHT - tp.points[i].y;
@@ -84,7 +84,7 @@ void screen_lv_touchRead(lv_indev_drv_t *indev_driver, lv_indev_data_t *data)
 
 void set_invert_display()
 {
-    tft.invertDisplay(global_config.invertColors);
+    tft.invertDisplay(get_current_printer_config()->invert_colors);
 }
 
 void set_LED_color(uint8_t rgbVal[3])
@@ -114,7 +114,7 @@ void screen_setup()
     tft.init();
     ledcSetup(0, 5000, 12);
     ledcAttachPin(TFT_BL, 0);
-    tft.setRotation(global_config.rotateScreen ? 3 : 1);
+    tft.setRotation(global_config.rotate_screen ? 3 : 1);
     tft.fillScreen(TFT_BLACK);
     set_invert_display();
     LED_init();
diff --git a/CYD-Klipper/src/core/device/ESP32-smartdisplay.cpp b/CYD-Klipper/src/core/device/ESP32-smartdisplay.cpp
index 3ca7b3a..4f723cf 100644
--- a/CYD-Klipper/src/core/device/ESP32-smartdisplay.cpp
+++ b/CYD-Klipper/src/core/device/ESP32-smartdisplay.cpp
@@ -21,7 +21,7 @@ void set_invert_display()
 
 void lv_screen_intercept(_lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p)
 {
-    if (global_config.invertColors) {
+    if (get_current_printer_config()->invert_colors) {
         uint32_t w = (area->x2 - area->x1 + 1);
         uint32_t h = (area->y2 - area->y1 + 1);
 
@@ -61,7 +61,7 @@ void screen_setup()
     }
 #endif // CYD_SCREEN_DISABLE_INVERT_COLORS
 
-    lv_disp_set_rotation(lv_disp_get_default(), (global_config.rotateScreen) ? ROTATION_INVERTED : ROTATION_NORMAL);
+    lv_disp_set_rotation(lv_disp_get_default(), (global_config.rotate_screen) ? ROTATION_INVERTED : ROTATION_NORMAL);
 }
 
 #endif // CYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY
\ No newline at end of file
diff --git a/CYD-Klipper/src/core/http_client.cpp b/CYD-Klipper/src/core/http_client.cpp
index fb135bf..42edba3 100644
--- a/CYD-Klipper/src/core/http_client.cpp
+++ b/CYD-Klipper/src/core/http_client.cpp
@@ -3,12 +3,11 @@
 
 String get_full_url(String url_part)
 {
-    return "http://" + String(global_config.klipperHost) + ":" + String(global_config.klipperPort) + url_part;
+    return "http://" + String(get_current_printer_config()->klipper_host) + ":" + String(get_current_printer_config()->klipper_port) + url_part;
 }
 
 void configure_http_client(HTTPClient &client, String url, bool stream, int timeout)
 {
-    Serial.println(url);
     if (stream){
         client.useHTTP10(true);
     }
@@ -20,7 +19,7 @@ void configure_http_client(HTTPClient &client, String url, bool stream, int time
 
     client.begin(url);
 
-    if (global_config.auth_configured) {
-        client.addHeader("X-Api-Key", global_config.klipper_auth);
+    if (get_current_printer_config()->auth_configured) {
+        client.addHeader("X-Api-Key", get_current_printer_config()->klipper_auth);
     }
 }
\ No newline at end of file
diff --git a/CYD-Klipper/src/core/lv_setup.cpp b/CYD-Klipper/src/core/lv_setup.cpp
index 880af74..6f446ca 100644
--- a/CYD-Klipper/src/core/lv_setup.cpp
+++ b/CYD-Klipper/src/core/lv_setup.cpp
@@ -54,14 +54,14 @@ void lv_touch_intercept(lv_indev_drv_t *indev_driver, lv_indev_data_t *data)
 
         screen_timer_wake();
 #ifndef CYD_SCREEN_DISABLE_TOUCH_CALIBRATION
-        data->point.x = round((data->point.x * global_config.screenCalXMult) + global_config.screenCalXOffset);
-        data->point.y = round((data->point.y * global_config.screenCalYMult) + global_config.screenCalYOffset);
+        data->point.x = round((data->point.x * global_config.screen_cal_x_mult) + global_config.screen_cal_x_offset);
+        data->point.y = round((data->point.y * global_config.screen_cal_y_mult) + global_config.screen_cal_y_offset);
 #endif // CYD_SCREEN_DISABLE_TOUCH_CALIBRATION
     }
 }
 
 void lv_do_calibration(){
-    if (global_config.screenCalibrated){
+    if (global_config.screen_calibrated){
         return;
     }
 
@@ -149,22 +149,22 @@ void lv_do_calibration(){
     int16_t yDist = CYD_SCREEN_HEIGHT_PX - 20;
 #endif
 
-    global_config.screenCalXMult = (float)xDist / (float)(x2 - x1);
-    global_config.screenCalXOffset = 10.0 - ((float)x1 * global_config.screenCalXMult);
+    global_config.screen_cal_x_mult = (float)xDist / (float)(x2 - x1);
+    global_config.screen_cal_x_offset = 10.0 - ((float)x1 * global_config.screen_cal_x_mult);
 
-    global_config.screenCalYMult = (float)yDist / (float)(y2 - y1);
-    global_config.screenCalYOffset = 10.0 - ((float)y1 * global_config.screenCalYMult);
+    global_config.screen_cal_y_mult = (float)yDist / (float)(y2 - y1);
+    global_config.screen_cal_y_offset = 10.0 - ((float)y1 * global_config.screen_cal_y_mult);
 
-    if (global_config.screenCalXMult == std::numeric_limits<float>::infinity() || global_config.screenCalYMult == std::numeric_limits<float>::infinity()){
+    if (global_config.screen_cal_x_mult == std::numeric_limits<float>::infinity() || global_config.screen_cal_y_mult == std::numeric_limits<float>::infinity()){
         Serial.println("Calibration failed, please try again");
         ESP.restart();
     }
 
-    global_config.screenCalibrated = true;
-    WriteGlobalConfig();
+    global_config.screen_calibrated = true;
+    write_global_config();
 
     lv_obj_clean(lv_scr_act());
-    Serial.printf("Calibration done: X*%.2f + %.2f, Y*%.2f + %.2f\n", global_config.screenCalXMult, global_config.screenCalXOffset, global_config.screenCalYMult, global_config.screenCalYOffset);
+    Serial.printf("Calibration done: X*%.2f + %.2f, Y*%.2f + %.2f\n", global_config.screen_cal_x_mult, global_config.screen_cal_x_offset, global_config.screen_cal_y_mult, global_config.screen_cal_y_offset);
 }
 
 void set_screen_brightness()
@@ -207,7 +207,7 @@ void screen_timer_sleep(lv_timer_t *timer)
 
 void screen_timer_setup()
 {
-    screen_sleep_timer = lv_timer_create(screen_timer_sleep, global_config.screenTimeout * 1000 * 60, NULL);
+    screen_sleep_timer = lv_timer_create(screen_timer_sleep, global_config.screen_timeout * 1000 * 60, NULL);
     lv_timer_pause(screen_sleep_timer);
 }
 
@@ -228,26 +228,27 @@ void screen_timer_period(unsigned int period)
 
 void set_screen_timer_period()
 {
-    screen_timer_period(global_config.screenTimeout * 1000 * 60);
+    screen_timer_period(global_config.screen_timeout * 1000 * 60);
 }
 
 void set_color_scheme()
 {
+    PRINTER_CONFIG *config = get_current_printer_config();
     lv_disp_t *dispp = lv_disp_get_default();
     lv_color_t main_color = {0};
-    COLOR_DEF color_def = color_defs[global_config.color_scheme];
+    COLOR_DEF color_def = color_defs[config->color_scheme];
 
-    if (color_defs[global_config.color_scheme].primary_color_light > 0){
+    if (color_defs[config->color_scheme].primary_color_light > 0){
         main_color = lv_palette_lighten(color_def.primary_color, color_def.primary_color_light);
     }
-    else if (color_defs[global_config.color_scheme].primary_color_light < 0) {
+    else if (color_defs[config->color_scheme].primary_color_light < 0) {
         main_color = lv_palette_darken(color_def.primary_color, color_def.primary_color_light * -1);
     }
     else {
-        main_color = lv_palette_main(color_defs[global_config.color_scheme].primary_color);
+        main_color = lv_palette_main(color_defs[config->color_scheme].primary_color);
     }
 
-    lv_theme_t *theme = lv_theme_default_init(dispp, main_color, lv_palette_main(color_def.secondary_color), !global_config.lightMode, &CYD_SCREEN_FONT);
+    lv_theme_t *theme = lv_theme_default_init(dispp, main_color, lv_palette_main(color_def.secondary_color), !config->light_mode, &CYD_SCREEN_FONT);
     lv_disp_set_theme(dispp, theme);
 }
 
diff --git a/CYD-Klipper/src/main.cpp b/CYD-Klipper/src/main.cpp
index e728bbe..776962f 100644
--- a/CYD-Klipper/src/main.cpp
+++ b/CYD-Klipper/src/main.cpp
@@ -13,7 +13,7 @@
 void setup() {
     Serial.begin(115200);
     Serial.println("Hello World");
-    LoadGlobalConfig();
+    load_global_config();
     screen_setup();
     lv_setup();
     Serial.println("Screen init done");
diff --git a/CYD-Klipper/src/ui/ip_setup.cpp b/CYD-Klipper/src/ui/ip_setup.cpp
index fbea738..d741fd4 100644
--- a/CYD-Klipper/src/ui/ip_setup.cpp
+++ b/CYD-Klipper/src/ui/ip_setup.cpp
@@ -69,21 +69,21 @@ static void ta_event_cb(lv_event_t * e) {
     }
     else if (code == LV_EVENT_READY) 
     {
-        strcpy(global_config.klipperHost, lv_textarea_get_text(hostEntry));
-        global_config.klipperPort = atoi(lv_textarea_get_text(portEntry));
+        strcpy(get_current_printer_config()->klipper_host, lv_textarea_get_text(hostEntry));
+        get_current_printer_config()->klipper_port = atoi(lv_textarea_get_text(portEntry));
 
         connection_status_t status = verify_ip();
         if (status == CONNECT_OK)
         {
-            global_config.ipConfigured = true;
-            WriteGlobalConfig();
+            get_current_printer_config()->ip_configured = true;
+            write_global_config();
             connect_ok = true;
         }
         else if (status == CONNECT_AUTH_REQUIRED)
         {
             label = NULL;
-            global_config.ipConfigured = true;
-            WriteGlobalConfig();
+            get_current_printer_config()->ip_configured = true;
+            write_global_config();
         }
         else
         {
@@ -109,7 +109,7 @@ static void reset_btn_event_handler(lv_event_t * e){
     lv_event_code_t code = lv_event_get_code(e);
 
     if(code == LV_EVENT_CLICKED) {
-        global_config.ipConfigured = false;
+        get_current_printer_config()->ip_configured = false;
         ip_init_inner();
     }
 }
@@ -176,9 +176,9 @@ static void keyboard_event_auth_entry(lv_event_t * e) {
         int len = strlen(txt);
         if (len > 0)
         {
-            global_config.auth_configured = true;
-            strcpy(global_config.klipper_auth, txt);
-            WriteGlobalConfig();
+            get_current_printer_config()->auth_configured = true;
+            strcpy(get_current_printer_config()->klipper_auth, txt);
+            write_global_config();
             auth_entry_done = true;
         }
     }
@@ -190,7 +190,7 @@ static void keyboard_event_auth_entry(lv_event_t * e) {
 
 void handle_auth_entry(){
     auth_entry_done = false;
-    global_config.klipper_auth[32] = 0;
+    get_current_printer_config()->klipper_auth[32] = 0;
     lv_obj_clean(lv_scr_act());
 
     lv_obj_t * root = lv_create_empty_panel(lv_scr_act());
@@ -212,8 +212,8 @@ void handle_auth_entry(){
     lv_textarea_set_max_length(passEntry, 32);
     lv_textarea_set_one_line(passEntry, true);
 
-    if (global_config.auth_configured)
-        lv_textarea_set_text(passEntry, global_config.klipper_auth);
+    if (get_current_printer_config()->auth_configured)
+        lv_textarea_set_text(passEntry, get_current_printer_config()->klipper_auth);
     else
         lv_textarea_set_text(passEntry, "");
 
@@ -235,7 +235,7 @@ void handle_auth_entry(){
 }
 
 void ip_init_inner(){
-    if (global_config.ipConfigured) {
+    if (get_current_printer_config()->ip_configured) {
         redraw_connect_screen();
         return;
     }
@@ -298,7 +298,7 @@ void ip_init(){
         lv_timer_handler();
         lv_task_handler();
 
-        if (!connect_ok && global_config.ipConfigured && (millis() - last_data_update_ip) > data_update_interval_ip){
+        if (!connect_ok && get_current_printer_config()->ip_configured && (millis() - last_data_update_ip) > data_update_interval_ip){
             connection_status_t status = verify_ip();
 
             connect_ok = status == CONNECT_OK;
diff --git a/CYD-Klipper/src/ui/main_ui.cpp b/CYD-Klipper/src/ui/main_ui.cpp
index a3194ee..8191d5c 100644
--- a/CYD-Klipper/src/ui/main_ui.cpp
+++ b/CYD-Klipper/src/ui/main_ui.cpp
@@ -93,7 +93,7 @@ void error_ui(){
 }
 
 void check_if_screen_needs_to_be_disabled(){
-    if (global_config.onDuringPrint && printer.state == PRINTER_STATE_PRINTING){
+    if (global_config.on_during_print && printer.state == PRINTER_STATE_PRINTING){
         screen_timer_wake();
         screen_timer_stop();
     }
diff --git a/CYD-Klipper/src/ui/nav_buttons.cpp b/CYD-Klipper/src/ui/nav_buttons.cpp
index 3a489ae..cf6a29f 100644
--- a/CYD-Klipper/src/ui/nav_buttons.cpp
+++ b/CYD-Klipper/src/ui/nav_buttons.cpp
@@ -4,6 +4,7 @@
 #include "nav_buttons.h"
 #include "ui_utils.h"
 #include <stdio.h>
+#include "../conf/global_config.h"
 
 static lv_style_t nav_button_style;
 
@@ -76,6 +77,10 @@ static void btn_click_macros(lv_event_t * e){
     nav_buttons_setup(4);
 }
 
+static void btn_click_printer(lv_event_t * e){
+    nav_buttons_setup(6);
+}
+
 void create_button(const char* icon, const char* name, lv_event_cb_t button_click, lv_event_cb_t label_update, lv_obj_t * root){
     lv_obj_t* btn = lv_btn_create(root);
     lv_obj_set_flex_grow(btn, 1);
@@ -131,6 +136,11 @@ void nav_buttons_setup(unsigned char active_panel){
     // Macros
     create_button(LV_SYMBOL_GPS, "Macro", btn_click_macros, NULL, root_panel);
 
+    if (global_config.multi_printer_mode)
+    {
+        create_button(LV_SYMBOL_HOME, "Printer", btn_click_printer, NULL, root_panel);
+    }
+
     lv_obj_t * panel = lv_create_empty_panel(lv_scr_act());
     lv_obj_set_size(panel, CYD_SCREEN_PANEL_WIDTH_PX, CYD_SCREEN_PANEL_HEIGHT_PX);
     lv_obj_align(panel, LV_ALIGN_TOP_RIGHT, 0, 0);
@@ -154,6 +164,9 @@ void nav_buttons_setup(unsigned char active_panel){
         case 5:
             stats_panel_init(panel);
             break;
+        case 6:
+            printer_panel_init(panel);
+            break;
     }
 
     lv_msg_send(DATA_PRINTER_DATA, &printer);
diff --git a/CYD-Klipper/src/ui/ota_setup.cpp b/CYD-Klipper/src/ui/ota_setup.cpp
index 9d69d5b..40f9398 100644
--- a/CYD-Klipper/src/ui/ota_setup.cpp
+++ b/CYD-Klipper/src/ui/ota_setup.cpp
@@ -85,7 +85,7 @@ void ota_init()
     Serial.printf("OTA Update Result: %d\n", result);
     update_available = result == ESP32OTAPull::UPDATE_AVAILABLE;
 
-    if (global_config.autoOtaUpdate && update_available)
+    if (global_config.auto_ota_update && update_available)
     {
         ota_do_update(true);
     }
diff --git a/CYD-Klipper/src/ui/panels/panel.h b/CYD-Klipper/src/ui/panels/panel.h
index d69910a..a18095c 100644
--- a/CYD-Klipper/src/ui/panels/panel.h
+++ b/CYD-Klipper/src/ui/panels/panel.h
@@ -10,4 +10,5 @@ void move_panel_init(lv_obj_t* panel);
 void progress_panel_init(lv_obj_t* panel);
 void macros_panel_init(lv_obj_t* panel);
 void stats_panel_init(lv_obj_t* panel);
+void printer_panel_init(lv_obj_t* panel);
 void macros_panel_add_power_devices_to_panel(lv_obj_t * panel, POWERQUERY query);
\ No newline at end of file
diff --git a/CYD-Klipper/src/ui/panels/printer_panel.cpp b/CYD-Klipper/src/ui/panels/printer_panel.cpp
new file mode 100644
index 0000000..c4ef1f8
--- /dev/null
+++ b/CYD-Klipper/src/ui/panels/printer_panel.cpp
@@ -0,0 +1,155 @@
+#include "panel.h"
+#include "../../conf/global_config.h"
+#include "../../core/data_setup.h"
+#include "../ui_utils.h"
+
+const char * printer_status[] = {
+    "Error",
+    "Idle",
+    "Printing",
+    "Paused"
+};
+
+const static lv_point_t line_points[] = { {0, 0}, {(short int)((CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2) * 0.85f), 0} };
+
+static void update_printer_status_text(lv_event_t * e) 
+{
+    lv_obj_t * label = lv_event_get_target(e);
+    PRINTER_CONFIG * config = (PRINTER_CONFIG*)lv_event_get_user_data(e);
+    int index = config - global_config.printer_config;
+    PrinterMinimal * printer = &printer_minimal[index];
+
+    if (!printer->online){
+        lv_label_set_text(label, "Offline");
+        return;
+    }
+
+    lv_label_set_text(label, printer_status[printer->state]);
+}
+
+static void update_printer_percentage_bar(lv_event_t * e)
+{
+    lv_obj_t * percentage = lv_event_get_target(e);
+    PRINTER_CONFIG * config = (PRINTER_CONFIG*)lv_event_get_user_data(e);
+    int index = config - global_config.printer_config;
+    PrinterMinimal * printer = &printer_minimal[index];
+
+    if (printer->online && (printer->state == PRINTER_STATE_PRINTING || printer->state == PRINTER_STATE_PAUSED)){
+        lv_bar_set_value(percentage, printer->print_progress * 100, LV_ANIM_OFF);
+    }
+    else {
+        lv_bar_set_value(percentage, 0, LV_ANIM_OFF);
+    }
+}
+
+static void update_printer_percentage_text(lv_event_t * e)
+{
+    lv_obj_t * label = lv_event_get_target(e);
+    PRINTER_CONFIG * config = (PRINTER_CONFIG*)lv_event_get_user_data(e);
+    int index = config - global_config.printer_config;
+    PrinterMinimal * printer = &printer_minimal[index];
+
+    if (printer->online && (printer->state == PRINTER_STATE_PRINTING || printer->state == PRINTER_STATE_PAUSED)){
+        lv_label_set_text_fmt(label, "%.2f%%", printer->print_progress * 100);
+    }
+    else {
+        lv_label_set_text(label, "-");
+    }
+}
+
+static void btn_printer_delete(lv_event_t * e)
+{
+
+}
+
+static void btn_printer_rename(lv_event_t * e)
+{
+
+}
+
+static void btn_printer_activate(lv_event_t * e)
+{
+
+}
+
+void create_printer_ui(PRINTER_CONFIG * config, lv_obj_t * root)
+{
+    int index = config - global_config.printer_config;
+    auto width = CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2;
+
+    lv_obj_t * data_row_name = lv_create_empty_panel(root);
+    lv_layout_flex_row(data_row_name, LV_FLEX_ALIGN_SPACE_BETWEEN);
+    lv_obj_set_size(data_row_name, width, LV_SIZE_CONTENT);
+
+    lv_obj_t * label = lv_label_create(data_row_name);
+    lv_label_set_text(label, config->printer_name[0] == 0 ? config->klipper_host : config->printer_name);
+    
+    label = lv_label_create(data_row_name);
+    lv_obj_add_event_cb(label, update_printer_status_text, LV_EVENT_MSG_RECEIVED, config);
+    lv_msg_subsribe_obj(DATA_PRINTER_MINIMAL, label, config);
+
+    lv_obj_t * progress_row = lv_create_empty_panel(root);
+    lv_layout_flex_row(progress_row);
+    lv_obj_set_size(progress_row, width, LV_SIZE_CONTENT);
+    
+    lv_obj_t * progress_bar = lv_bar_create(progress_row);
+    lv_obj_set_flex_grow(progress_bar, 1);
+    lv_obj_add_event_cb(progress_bar, update_printer_percentage_bar, LV_EVENT_MSG_RECEIVED, config);
+    lv_msg_subsribe_obj(DATA_PRINTER_MINIMAL, progress_bar, config);
+
+    label = lv_label_create(progress_row);
+    lv_obj_set_style_text_font(label, &CYD_SCREEN_FONT_SMALL, 0);
+    lv_obj_add_event_cb(label, update_printer_percentage_text, LV_EVENT_MSG_RECEIVED, config);
+    lv_msg_subsribe_obj(DATA_PRINTER_MINIMAL, label, config);
+
+    lv_obj_t * button_row = lv_create_empty_panel(root);
+    lv_layout_flex_row(button_row);
+    lv_obj_set_size(button_row, width, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
+
+    lv_obj_t * btn = lv_btn_create(button_row);
+    lv_obj_set_flex_grow(btn, 1);
+    lv_obj_add_event_cb(btn, btn_printer_delete, LV_EVENT_CLICKED, config);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_TRASH);
+    lv_obj_center(label);
+
+    btn = lv_btn_create(button_row);
+    lv_obj_set_flex_grow(btn, 2);
+    lv_obj_add_event_cb(btn, btn_printer_rename, LV_EVENT_CLICKED, config);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, "Rename");
+    lv_obj_center(label);
+
+    btn = lv_btn_create(button_row);
+    lv_obj_set_flex_grow(btn, 2);
+    lv_obj_add_event_cb(btn, btn_printer_activate, LV_EVENT_CLICKED, config);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, "Activate");
+    lv_obj_center(label);
+
+    lv_obj_t * line = lv_line_create(root);
+    lv_line_set_points(line, line_points, 2);
+    lv_obj_set_style_line_width(line, 1, 0);
+    lv_obj_set_style_line_color(line, lv_color_hex(0xAAAAAA), 0);
+}
+
+void printer_panel_init(lv_obj_t* panel) 
+{
+    lv_obj_t * inner_panel = lv_create_empty_panel(panel);
+    lv_obj_align(inner_panel, LV_ALIGN_TOP_LEFT, CYD_SCREEN_GAP_PX, CYD_SCREEN_GAP_PX);
+    lv_obj_set_size(inner_panel, CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2, CYD_SCREEN_PANEL_HEIGHT_PX - CYD_SCREEN_GAP_PX * 2);
+    lv_layout_flex_column(inner_panel);
+    lv_obj_set_scrollbar_mode(inner_panel, LV_SCROLLBAR_MODE_OFF);
+
+    for (int i = 0; i < PRINTER_CONFIG_COUNT; i++){
+        PRINTER_CONFIG * config = &global_config.printer_config[i];
+        if (config->ip_configured) {
+            create_printer_ui(&global_config.printer_config[i], inner_panel);
+        }
+    }
+
+    lv_msg_send(DATA_PRINTER_MINIMAL, NULL);
+}
\ No newline at end of file
diff --git a/CYD-Klipper/src/ui/panels/settings_panel.cpp b/CYD-Klipper/src/ui/panels/settings_panel.cpp
index 165679a..94411b2 100644
--- a/CYD-Klipper/src/ui/panels/settings_panel.cpp
+++ b/CYD-Klipper/src/ui/panels/settings_panel.cpp
@@ -7,6 +7,7 @@
 #include <Esp.h>
 #include "../../core/lv_setup.h"
 #include "../ota_setup.h"
+#include "../nav_buttons.h"
 
 #ifndef REPO_VERSION
     #define REPO_VERSION "Unknown"
@@ -15,39 +16,44 @@
 static void invert_color_switch(lv_event_t * e){
     auto state = lv_obj_get_state(lv_event_get_target(e));
     bool checked = (state & LV_STATE_CHECKED == LV_STATE_CHECKED);
-    global_config.invertColors = checked;
-    WriteGlobalConfig();
+    get_current_printer_config()->invert_colors = checked;
+    write_global_config();
     set_invert_display();
 }
 
 static void reset_calibration_click(lv_event_t * e){
-    global_config.screenCalibrated = false;
-    WriteGlobalConfig();
+    global_config.screen_calibrated = false;
+    write_global_config();
     ESP.restart();
 }
 
 static void reset_wifi_click(lv_event_t * e){
-    global_config.wifiConfigured = false;
-    global_config.ipConfigured = false;
-    global_config.auth_configured = false;
-    WriteGlobalConfig();
+    global_config.wifi_configured = false;
+    write_global_config();
+    ESP.restart();
+}
+
+static void reset_ip_click(lv_event_t * e){
+    get_current_printer_config()->ip_configured = false;
+    get_current_printer_config()->auth_configured = false;
+    write_global_config();
     ESP.restart();
 }
 
 static void light_mode_switch(lv_event_t * e){
     auto state = lv_obj_get_state(lv_event_get_target(e));
     bool checked = (state & LV_STATE_CHECKED == LV_STATE_CHECKED);
-    global_config.lightMode = checked;
-    WriteGlobalConfig();
+    get_current_printer_config()->light_mode = checked;
+    write_global_config();
     set_color_scheme();
 }
 
 static void theme_dropdown(lv_event_t * e){
     lv_obj_t * dropdown = lv_event_get_target(e);
     auto selected = lv_dropdown_get_selected(dropdown);
-    global_config.color_scheme = selected;
+    get_current_printer_config()->color_scheme = selected;
     set_color_scheme();
-    WriteGlobalConfig();
+    write_global_config();
 }
 
 const char* brightness_options = "100%\n75%\n50%\n25%";
@@ -58,7 +64,7 @@ static void brightness_dropdown(lv_event_t * e){
     auto selected = lv_dropdown_get_selected(dropdown);
     global_config.brightness = brightness_options_values[selected];
     set_screen_brightness();
-    WriteGlobalConfig();
+    write_global_config();
 }
 
 const char* wake_timeout_options = "1m\n2m\n5m\n10m\n15m\n30m\n1h\n2h\n4h";
@@ -67,26 +73,26 @@ const char  wake_timeout_options_values[] = { 1, 2, 5, 10, 15, 30, 60, 120, 240
 static void wake_timeout_dropdown(lv_event_t * e){
     lv_obj_t * dropdown = lv_event_get_target(e);
     auto selected = lv_dropdown_get_selected(dropdown);
-    global_config.screenTimeout = wake_timeout_options_values[selected];
+    global_config.screen_timeout = wake_timeout_options_values[selected];
     set_screen_timer_period();
-    WriteGlobalConfig();
+    write_global_config();
 }
 
 static void rotate_screen_switch(lv_event_t* e){
     auto state = lv_obj_get_state(lv_event_get_target(e));
     bool checked = (state & LV_STATE_CHECKED == LV_STATE_CHECKED);
-    global_config.rotateScreen = checked;
-    global_config.screenCalibrated = false;
-    WriteGlobalConfig();
+    global_config.rotate_screen = checked;
+    global_config.screen_calibrated = false;
+    write_global_config();
     ESP.restart();
 }
 
 static void on_during_print_switch(lv_event_t* e){
     auto state = lv_obj_get_state(lv_event_get_target(e));
     bool checked = (state & LV_STATE_CHECKED == LV_STATE_CHECKED);
-    global_config.onDuringPrint = checked;
+    global_config.on_during_print = checked;
     check_if_screen_needs_to_be_disabled();
-    WriteGlobalConfig();
+    write_global_config();
 }
 
 static void btn_ota_do_update(lv_event_t * e){
@@ -96,16 +102,24 @@ static void btn_ota_do_update(lv_event_t * e){
 static void auto_ota_update_switch(lv_event_t* e){
     auto state = lv_obj_get_state(lv_event_get_target(e));
     bool checked = (state & LV_STATE_CHECKED == LV_STATE_CHECKED);
-    global_config.autoOtaUpdate = checked;
-    WriteGlobalConfig();
+    global_config.auto_ota_update = checked;
+    write_global_config();
+}
+
+static void multi_printer_switch(lv_event_t* e){
+    auto state = lv_obj_get_state(lv_event_get_target(e));
+    bool checked = (state & LV_STATE_CHECKED == LV_STATE_CHECKED);
+    global_config.multi_printer_mode = checked;
+    write_global_config();
+    nav_buttons_setup(3);
 }
 
 const char* estimated_time_options = "Percentage\nInterpolated\nSlicer";
 
 static void estimated_time_dropdown(lv_event_t * e){
     lv_obj_t * dropdown = lv_event_get_target(e);
-    global_config.remaining_time_calc_mode = lv_dropdown_get_selected(dropdown);
-    WriteGlobalConfig();
+    get_current_printer_config()->remaining_time_calc_mode = lv_dropdown_get_selected(dropdown);
+    write_global_config();
 }
 
 const static lv_point_t line_points[] = { {0, 0}, {(short int)((CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2) * 0.85f), 0} };
@@ -152,6 +166,15 @@ void settings_panel_init(lv_obj_t* panel){
 
     create_settings_widget("Configure WiFi", btn, panel);
 
+    btn = lv_btn_create(panel);
+    lv_obj_add_event_cb(btn, reset_ip_click, LV_EVENT_CLICKED, NULL);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, "Restart");
+    lv_obj_center(label);
+
+    create_settings_widget("Configure IP", btn, panel);
+
 #ifndef CYD_SCREEN_DISABLE_TOUCH_CALIBRATION
     btn = lv_btn_create(panel);
     lv_obj_add_event_cb(btn, reset_calibration_click, LV_EVENT_CLICKED, NULL);
@@ -168,7 +191,7 @@ void settings_panel_init(lv_obj_t* panel){
     lv_obj_set_width(toggle, TOGGLE_WIDTH);
     lv_obj_add_event_cb(toggle, invert_color_switch, LV_EVENT_VALUE_CHANGED, NULL);
 
-    if (global_config.invertColors)
+    if (get_current_printer_config()->invert_colors)
         lv_obj_add_state(toggle, LV_STATE_CHECKED);
 
     create_settings_widget("Invert Colors", toggle, panel);
@@ -178,14 +201,14 @@ void settings_panel_init(lv_obj_t* panel){
     lv_obj_set_width(toggle, TOGGLE_WIDTH);
     lv_obj_add_event_cb(toggle, light_mode_switch, LV_EVENT_VALUE_CHANGED, NULL);
 
-    if (global_config.lightMode)
+    if (get_current_printer_config()->light_mode)
         lv_obj_add_state(toggle, LV_STATE_CHECKED);
 
     create_settings_widget("Light Mode", toggle, panel);
 
     dropdown = lv_dropdown_create(panel);
     lv_dropdown_set_options(dropdown, "Blue\nGreen\nGrey\nYellow\nOrange\nRed\nPurple");
-    lv_dropdown_set_selected(dropdown, global_config.color_scheme);
+    lv_dropdown_set_selected(dropdown, get_current_printer_config()->color_scheme);
     lv_obj_set_width(dropdown, DROPDOWN_WIDTH);
     lv_obj_add_event_cb(dropdown, theme_dropdown, LV_EVENT_VALUE_CHANGED, NULL);
 
@@ -212,7 +235,7 @@ void settings_panel_init(lv_obj_t* panel){
     lv_obj_add_event_cb(dropdown, wake_timeout_dropdown, LV_EVENT_VALUE_CHANGED, NULL);
 
     for (int i = 0; i < SIZEOF(wake_timeout_options_values); i++){
-        if (wake_timeout_options_values[i] == global_config.screenTimeout){
+        if (wake_timeout_options_values[i] == global_config.screen_timeout){
             lv_dropdown_set_selected(dropdown, i);
             break;
         }
@@ -226,14 +249,14 @@ void settings_panel_init(lv_obj_t* panel){
     lv_obj_set_width(dropdown, DROPDOWN_WIDTH);
     lv_obj_add_event_cb(dropdown, estimated_time_dropdown, LV_EVENT_VALUE_CHANGED, NULL);
 
-    lv_dropdown_set_selected(dropdown, global_config.remaining_time_calc_mode);
+    lv_dropdown_set_selected(dropdown, get_current_printer_config()->remaining_time_calc_mode);
     create_settings_widget("Estimated Time", dropdown, panel);
 
     toggle = lv_switch_create(panel);
     lv_obj_set_width(toggle, TOGGLE_WIDTH);
     lv_obj_add_event_cb(toggle, rotate_screen_switch, LV_EVENT_VALUE_CHANGED, NULL);
 
-    if (global_config.rotateScreen)
+    if (global_config.rotate_screen)
         lv_obj_add_state(toggle, LV_STATE_CHECKED);
     
     create_settings_widget("Rotate Screen", toggle, panel);
@@ -243,17 +266,26 @@ void settings_panel_init(lv_obj_t* panel){
     lv_obj_set_width(toggle, TOGGLE_WIDTH);
     lv_obj_add_event_cb(toggle, on_during_print_switch, LV_EVENT_VALUE_CHANGED, NULL);
 
-    if (global_config.onDuringPrint)
+    if (global_config.on_during_print)
         lv_obj_add_state(toggle, LV_STATE_CHECKED);
 
     create_settings_widget("Screen On During Print", toggle, panel);
 #endif
 
+    toggle = lv_switch_create(panel);
+    lv_obj_set_width(toggle, TOGGLE_WIDTH);
+    lv_obj_add_event_cb(toggle, multi_printer_switch, LV_EVENT_VALUE_CHANGED, NULL);
+
+    if (global_config.multi_printer_mode)
+        lv_obj_add_state(toggle, LV_STATE_CHECKED);
+    
+    create_settings_widget("Multi Printer Mode", toggle, panel);
+
     toggle = lv_switch_create(panel);
     lv_obj_set_width(toggle, TOGGLE_WIDTH);
     lv_obj_add_event_cb(toggle, auto_ota_update_switch, LV_EVENT_VALUE_CHANGED, NULL);
 
-    if (global_config.autoOtaUpdate)
+    if (global_config.auto_ota_update)
         lv_obj_add_state(toggle, LV_STATE_CHECKED);
 
     create_settings_widget("Auto Update", toggle, panel);
diff --git a/CYD-Klipper/src/ui/panels/temp_panel.cpp b/CYD-Klipper/src/ui/panels/temp_panel.cpp
index 7a866f1..2716677 100644
--- a/CYD-Klipper/src/ui/panels/temp_panel.cpp
+++ b/CYD-Klipper/src/ui/panels/temp_panel.cpp
@@ -36,17 +36,17 @@ static void update_printer_data_bed_temp(lv_event_t * e){
 static short get_temp_preset(int target){
     switch (target){
         case TARGET_HOTEND_CONFIG_1:
-            return global_config.hotend_presets[0];
+            return get_current_printer_config()->hotend_presets[0];
         case TARGET_HOTEND_CONFIG_2:
-            return global_config.hotend_presets[1];
+            return get_current_printer_config()->hotend_presets[1];
         case TARGET_HOTEND_CONFIG_3:
-            return global_config.hotend_presets[2];
+            return get_current_printer_config()->hotend_presets[2];
         case TARGET_BED_CONFIG_1:
-            return global_config.bed_presets[0];
+            return get_current_printer_config()->bed_presets[0];
         case TARGET_BED_CONFIG_2:
-            return global_config.bed_presets[1];
+            return get_current_printer_config()->bed_presets[1];
         case TARGET_BED_CONFIG_3:
-            return global_config.bed_presets[2];
+            return get_current_printer_config()->bed_presets[2];
         default:
             return -1;
     }
@@ -62,7 +62,7 @@ static void update_temp_preset_label(lv_event_t * e){
 }
 
 void UpdateConfig(){
-    WriteGlobalConfig();
+    write_global_config();
     lv_msg_send(DATA_PRINTER_TEMP_PRESET, &printer);
 }
 
@@ -91,27 +91,27 @@ static void keyboard_callback(lv_event_t * e){
                 send_gcode(true, gcode);
                 break;
             case TARGET_HOTEND_CONFIG_1:
-                global_config.hotend_presets[0] = temp;
+                get_current_printer_config()->hotend_presets[0] = temp;
                 UpdateConfig();
                 break;
             case TARGET_HOTEND_CONFIG_2:
-                global_config.hotend_presets[1] = temp;
+                get_current_printer_config()->hotend_presets[1] = temp;
                 UpdateConfig();
                 break;
             case TARGET_HOTEND_CONFIG_3:
-                global_config.hotend_presets[2] = temp;
+                get_current_printer_config()->hotend_presets[2] = temp;
                 UpdateConfig();
                 break;
             case TARGET_BED_CONFIG_1:
-                global_config.bed_presets[0] = temp;
+                get_current_printer_config()->bed_presets[0] = temp;
                 UpdateConfig();
                 break;
             case TARGET_BED_CONFIG_2:
-                global_config.bed_presets[1] = temp;
+                get_current_printer_config()->bed_presets[1] = temp;
                 UpdateConfig();
                 break;
             case TARGET_BED_CONFIG_3:
-                global_config.bed_presets[2] = temp;
+                get_current_printer_config()->bed_presets[2] = temp;
                 UpdateConfig();
                 break;
         }
diff --git a/CYD-Klipper/src/ui/wifi_setup.cpp b/CYD-Klipper/src/ui/wifi_setup.cpp
index 6bb3556..fb2e366 100644
--- a/CYD-Klipper/src/ui/wifi_setup.cpp
+++ b/CYD-Klipper/src/ui/wifi_setup.cpp
@@ -10,7 +10,7 @@ static void reset_btn_event_handler(lv_event_t * e) {
     lv_event_code_t code = lv_event_get_code(e);
 
     if(code == LV_EVENT_CLICKED) {
-        global_config.wifiConfigured = false;
+        global_config.wifi_configured = false;
         wifi_init_inner();
     }
 }
@@ -33,9 +33,9 @@ static void ta_event_cb(lv_event_t * e) {
         int len = strlen(txt);
         if (len > 0)
         {
-            global_config.wifiConfigured = true;
-            strcpy(global_config.wifiPassword, txt);
-            WriteGlobalConfig();
+            global_config.wifi_configured = true;
+            strcpy(global_config.wifi_password, txt);
+            write_global_config();
             wifi_init_inner();
         }
     }
@@ -79,7 +79,7 @@ static void wifi_btn_event_handler(lv_event_t * e){
     if(code == LV_EVENT_CLICKED) {
         delay(100);
         char* ssid = (char*)e->user_data;
-        strcpy(global_config.wifiSSID, ssid);
+        strcpy(global_config.wifi_SSID, ssid);
         Serial.println(ssid);
         wifi_pass_entry(ssid);
     }
@@ -89,8 +89,8 @@ void wifi_init_inner(){
     WiFi.disconnect();
     lv_obj_clean(lv_scr_act());
 
-    if (global_config.wifiConfigured){
-        WiFi.begin(global_config.wifiSSID, global_config.wifiPassword);
+    if (global_config.wifi_configured){
+        WiFi.begin(global_config.wifi_SSID, global_config.wifi_password);
         
         lv_obj_t * label = lv_label_create(lv_scr_act());
         lv_label_set_text(label, "Connecting to WiFi");
@@ -180,7 +180,7 @@ void wifi_init(){
     WiFi.mode(WIFI_STA);
     wifi_init_inner();
 
-    while (!global_config.wifiConfigured || WiFi.status() != WL_CONNECTED){
+    while (!global_config.wifi_configured || WiFi.status() != WL_CONNECTED){
         if (millis() - print_timer > print_freq){
             print_timer = millis();
             Serial.printf("WiFi Status: %s\n", errs[WiFi.status()]);