Merge pull request #66 from suchmememanyskill/dev

v1.5.0

.github/workflows/compile.yaml

@@ -57,7 +57,7 @@ jobs:
       url: ${{ steps.deployment.outputs.page_url }}
     runs-on: ubuntu-latest
     needs: build
-    if: (github.event_name == 'release' && github.event.action == 'created') || (github.event_name != 'pull_request' && github.ref == 'refs/heads/master')
+    if: github.event_name == 'release' && github.event.action == 'created'
     steps:
       - name: Print GitHub event name
         run: |

Build.md

@@ -0,0 +1,37 @@
+# Building
+
+## Running a developer build
+
+On every change made in this repository, [Github Actions](https://github.com/suchmememanyskill/CYD-Klipper/actions) automatically builds the firmware images for various screens. You can run one of these images as follows:
+
+#### Getting a firmware image
+0. Make sure you are logged into github
+1. Go to a [Github Actions](https://github.com/suchmememanyskill/CYD-Klipper/actions) build summary, then download the `firmware` Artifact.
+2. Open the firmware.zip archive you just downloaded, open the corresponding folder for your screen, then extract `merged_firmware.bin`
+
+This merged_firmware.bin file is a ready to flash image. Note that flashing this image does wipe your current configuration.
+
+#### Flashing merged_firmware.bin
+1. Download and extract [esptool](https://github.com/espressif/esptool/releases) to a new folder
+    - For windows, download `esptool-v4.7.0-win64.zip`
+2. Open a terminal window and navigate to this new folder containing esptool
+    - In windows, you can type cmd and press enter in the address bar in explorer to jump to the folder in cmd ![cmd](readme/cmd.jpg)
+3. Move `merged-firmware.bin` into this new folder
+4. Connect the display to your computer
+5. Execute the command `esptool write_flash 0x0 merged-firmware.bin`
+    - Don't forget to hold down the boot button on the display
+
+## Building via PlatformIO
+
+0. Install [Visual Studio Code](https://code.visualstudio.com/) and install the PlatformIO IDE plugin.
+1. Download the source code of CYD-Klipper
+    - This can be done via the `git clone https://github.com/suchmememanyskill/CYD-Klipper` command or via the green `<> Code` button on Github
+2. Open the CYD-Klipper folder inside the CYD-Klipper folder in Visual Studio Code
+3. Click on the Alien/Bug tab (PlatformIO) on the left
+4. Expand the folder/tab for your specific screen
+    - Entries with the suffix '-SD' are using the smartdisplay driver. Entries without this suffix are using a custom driver
+    - Usually, a custom driver is preferred over the smartdisplay driver
+5. Connect the display to your computer
+6. Click 'Upload and Monitor'
+    - This will start compiling the code, and after upload it to the display
+    - Don't forget to hold the boot button while flashing. The screen will flash when the firmware is attempted to be flashed

CYD-Klipper/.vscode/settings.json

@@ -12,6 +12,8 @@
         "algorithm": "cpp",
         "cstddef": "cpp",
         "functional": "cpp",
-        "*.tcc": "cpp"
+        "*.tcc": "cpp",
-    }
+        "cmath": "cpp"
+    },
+    "cmake.configureOnOpen": false
 }

CYD-Klipper/boards/esp32-2432S022C-smartdisplay.json

@@ -0,0 +1,126 @@
+{
+    "build": {
+      "arduino": {
+        "ldscript": "esp32_out.ld"
+      },
+      "core": "esp32",
+      "extra_flags": [
+        "'-D ARDUINO_ESP32_DEV'",
+        "'-D ESP32_2432S022C'",
+        "'-D LCD_WIDTH=240'",
+        "'-D LCD_HEIGHT=320'",
+        "'-D LVGL_BUFFER_PIXELS=(LCD_WIDTH*LCD_HEIGHT/8)'",
+        "'-D LVGL_BUFFER_MALLOC_FLAGS=(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT)'",
+        "'-D GPIO_BCKL=0'",
+        "'-D LCD_ST7789_I80'",
+        "'-D ST7789_I80_BUS_CONFIG_CLK_SRC=LCD_CLK_SRC_PLL160M'",
+        "'-D ST7789_I80_BUS_CONFIG_DC=16'",
+        "'-D ST7789_I80_BUS_CONFIG_WR=4'",
+        "'-D ST7789_I80_BUS_CONFIG_DATA_GPIO_D8=15'",
+        "'-D ST7789_I80_BUS_CONFIG_DATA_GPIO_D9=13'",
+        "'-D ST7789_I80_BUS_CONFIG_DATA_GPIO_D10=12'",
+        "'-D ST7789_I80_BUS_CONFIG_DATA_GPIO_D11=14'",
+        "'-D ST7789_I80_BUS_CONFIG_DATA_GPIO_D12=27'",
+        "'-D ST7789_I80_BUS_CONFIG_DATA_GPIO_D13=25'",
+        "'-D ST7789_I80_BUS_CONFIG_DATA_GPIO_D14=33'",
+        "'-D ST7789_I80_BUS_CONFIG_DATA_GPIO_D15=32'",
+        "'-D ST7789_I80_BUS_CONFIG_BUS_WIDTH=8'",
+        "'-D ST7789_I80_BUS_CONFIG_MAX_TRANSFER_BYTES=(LVGL_BUFFER_PIXELS * sizeof(lv_color_t))'",
+        "'-D ST7789_I80_BUS_CONFIG_PSRAM_TRANS_ALIGN=64'",
+        "'-D ST7789_I80_BUS_CONFIG_SRAM_TRANS_ALIGN=4'",
+        "'-D ST7789_IO_I80_CONFIG_CS_GPIO_NUM=17'",
+        "'-D ST7789_IO_I80_CONFIG_PCLK_HZ=12000000'",
+        "'-D ST7789_IO_I80_CONFIG_TRANS_QUEUE_DEPTH=10'",
+        "'-D ST7789_IO_I80_CONFIG_LCD_CMD_BITS=8'",
+        "'-D ST7789_IO_I80_CONFIG_LCD_PARAM_BITS=8'",
+        "'-D ST7789_IO_I80_CONFIG_DC_LEVELS_DC_IDLE_LEVEL=0'",
+        "'-D ST7789_IO_I80_CONFIG_DC_LEVELS_DC_CMD_LEVEL=0'",
+        "'-D ST7789_IO_I80_CONFIG_DC_LEVELS_DC_DUMMY_LEVEL=0'",
+        "'-D ST7789_IO_I80_CONFIG_DC_LEVELS_DC_DATA_LEVEL=1'",
+        "'-D ST7789_IO_I80_CONFIG_FLAGS_CS_ACTIVE_HIGH=0'",
+        "'-D ST7789_IO_I80_CONFIG_FLAGS_REVERSE_COLOR_BITS=0'",
+        "'-D ST7789_IO_I80_CONFIG_FLAGS_SWAP_COLOR_BYTES=0'",
+        "'-D ST7789_IO_I80_CONFIG_FLAGS_PCLK_ACTIVE_NEG=0'",
+        "'-D ST7789_IO_I80_CONFIG_FLAGS_PCLK_IDLE_LOW=0'",
+        "'-D ST7789_DEV_CONFIG_RESET_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D ST7789_DEV_CONFIG_COLOR_SPACE=ESP_LCD_COLOR_SPACE_RGB'",
+        "'-D ST7789_DEV_CONFIG_BITS_PER_PIXEL=16'",
+        "'-D ST7789_DEV_CONFIG_FLAGS_RESET_ACTIVE_HIGH=false'",
+        "'-D ST7789_DEV_CONFIG_VENDOR_CONFIG=NULL'",
+        "'-D ST7789_RD_GPIO=2'",
+        "'-D LCD_SWAP_XY=false'",
+        "'-D LCD_MIRROR_X=false'",
+        "'-D LCD_MIRROR_Y=false'",
+        "'-D BOARD_HAS_TOUCH'",
+        "'-D TOUCH_CST816S_I2C'",
+        "'-D CST816S_I2C_HOST=I2C_NUM_0'",
+        "'-D CST816S_I2C_CONFIG_SDA_IO_NUM=21'",
+        "'-D CST816S_I2C_CONFIG_SCL_IO_NUM=22'",
+        "'-D CST816S_I2C_CONFIG_SDA_PULLUP_EN=GPIO_PULLUP_ENABLE'",
+        "'-D CST816S_I2C_CONFIG_SCL_PULLUP_EN=GPIO_PULLUP_ENABLE'",
+        "'-D CST816S_I2C_CONFIG_MASTER_CLK_SPEED=400000'",
+        "'-D CST816S_I2C_CONFIG_CLK_FLAGS=0'",
+        "'-D CST816S_IO_I2C_CONFIG_DEV_ADDR=ESP_LCD_TOUCH_IO_I2C_CST816S_ADDRESS'",
+        "'-D CST816S_IO_I2C_CONFIG_CONTROL_PHASE_BYTES=1'",
+        "'-D CST816S_IO_I2C_CONFIG_DC_BIT_OFFSET=0'",
+        "'-D CST816S_IO_I2C_CONFIG_LCD_CMD_BITS=8'",
+        "'-D CST816S_IO_I2C_CONFIG_LCD_PARAM_BITS=0'",
+        "'-D CST816S_IO_I2C_CONFIG_FLAGS_DC_LOW_ON_DATA=false'",
+        "'-D CST816S_IO_I2C_CONFIG_FLAGS_DISABLE_CONTROL_PHASE=true'",
+        "'-D CST816S_TOUCH_CONFIG_X_MAX=LCD_WIDTH'",
+        "'-D CST816S_TOUCH_CONFIG_Y_MAX=LCD_HEIGHT'",
+        "'-D CST816S_TOUCH_CONFIG_RST_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D CST816S_TOUCH_CONFIG_INT_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D CST816S_TOUCH_CONFIG_LEVELS_RESET=0'",
+        "'-D CST816S_TOUCH_CONFIG_LEVELS_INTERRUPT=0'",
+        "'-D TOUCH_SWAP_XY=true'",
+        "'-D TOUCH_SWAP_X=false'",
+        "'-D TOUCH_SWAP_Y=false'",
+        "'-D BOARD_HAS_TF'",
+        "'-D TF_CS=5'",
+        "'-D TF_SPI_MOSI=23'",
+        "'-D TF_SPI_SCLK=18'",
+        "'-D TF_SPI_MISO=19'",
+        "'-D BOARD_HAS_SPEAK'",
+        "'-D SPEAK=26'",
+
+        "-DCYD_SCREEN_GAP_PX=8",
+        "-DCYD_SCREEN_MIN_BUTTON_HEIGHT_PX=35",
+        "-DCYD_SCREEN_MIN_BUTTON_WIDTH_PX=35",
+        "-DCYD_SCREEN_FONT=lv_font_montserrat_14",
+        "-DCYD_SCREEN_FONT_SMALL=lv_font_montserrat_10",
+        "-DCYD_SCREEN_SIDEBAR_SIZE_PX=40",
+        "-DCYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY=1",
+        "-DCYD_SCREEN_DISABLE_TOUCH_CALIBRATION=1",
+        "-DCYD_SCREEN_DISABLE_INVERT_COLORS=1"
+      ],
+      "f_cpu": "240000000L",
+      "f_flash": "40000000L",
+      "flash_mode": "dio",
+      "mcu": "esp32",
+      "variant": "esp32"
+    },
+    "connectivity": [
+      "wifi",
+      "bluetooth",
+      "ethernet",
+      "can"
+    ],
+    "debug": {
+      "openocd_board": "esp-wroom-32.cfg"
+    },
+    "frameworks": [
+      "arduino",
+      "espidf"
+    ],
+    "name": "esp32-2432S022C",
+    "upload": {
+      "flash_size": "4MB",
+      "maximum_ram_size": 327680,
+      "maximum_size": 4194304,
+      "require_upload_port": true,
+      "speed": 460800
+    },
+    "url": "https://www.aliexpress.com/item/1005006284154750.html",
+    "vendor": "Sunton"
+  }

CYD-Klipper/boards/esp32-2432S024C-smartdisplay.json

@@ -0,0 +1,122 @@
+{
+    "build": {
+      "arduino": {
+        "ldscript": "esp32_out.ld"
+      },
+      "core": "esp32",
+      "extra_flags": [
+        "'-D ARDUINO_ESP32_DEV'",
+        "'-D ESP32_2432S024C'",
+        "'-D LCD_WIDTH=240'",
+        "'-D LCD_HEIGHT=320'",
+        "'-D LVGL_BUFFER_PIXELS=(LCD_WIDTH*LCD_HEIGHT/4)'",
+        "'-D LVGL_BUFFER_MALLOC_FLAGS=(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT)'",
+        "'-D GPIO_BCKL=27'",
+        "'-D LCD_ILI9341_SPI'",
+        "'-D ILI9341_SPI_HOST=SPI2_HOST'",
+        "'-D ILI9341_SPI_DMA_CHANNEL=SPI_DMA_CH_AUTO'",
+        "'-D ILI9341_SPI_BUS_MOSI_IO_NUM=13'",
+        "'-D ILI9341_SPI_BUS_MISO_IO_NUM=12'",
+        "'-D ILI9341_SPI_BUS_SCLK_IO_NUM=14'",
+        "'-D ILI9341_SPI_BUS_QUADWP_IO_NUM=GPIO_NUM_NC'",
+        "'-D ILI9341_SPI_BUS_QUADHD_IO_NUM=GPIO_NUM_NC'",
+        "'-D ILI9341_SPI_BUS_MAX_TRANSFER_SZ=(LVGL_BUFFER_PIXELS*sizeof(lv_color16_t))'",
+        "'-D ILI9341_SPI_BUS_FLAGS=0'",
+        "'-D ILI9341_SPI_BUS_INTR_FLAGS=0'",
+        "'-D ILI9341_SPI_CONFIG_CS_GPIO_NUM=15'",
+        "'-D ILI9341_SPI_CONFIG_DC_GPIO_NUM=2'",
+        "'-D ILI9341_SPI_CONFIG_SPI_MODE=SPI_MODE0'",
+        "'-D ILI9341_SPI_CONFIG_PCLK_HZ=24000000'",
+        "'-D ILI9341_SPI_CONFIG_TRANS_QUEUE_DEPTH=10'",
+        "'-D ILI9341_SPI_CONFIG_LCD_CMD_BITS=8'",
+        "'-D ILI9341_SPI_CONFIG_LCD_PARAM_BITS=8'",
+        "'-D ILI9341_SPI_CONFIG_FLAGS_DC_AS_CMD_PHASE=false'",
+        "'-D ILI9341_SPI_CONFIG_FLAGS_DC_LOW_ON_DATA=false'",
+        "'-D ILI9341_SPI_CONFIG_FLAGS_OCTAL_MODE=false'",
+        "'-D ILI9341_SPI_CONFIG_FLAGS_LSB_FIRST=false'",
+        "'-D ILI9341_DEV_CONFIG_RESET_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D ILI9341_DEV_CONFIG_COLOR_SPACE=ESP_LCD_COLOR_SPACE_BGR'",
+        "'-D ILI9341_DEV_CONFIG_BITS_PER_PIXEL=16'",
+        "'-D ILI9341_DEV_CONFIG_FLAGS_RESET_ACTIVE_HIGH=false'",
+        "'-D ILI9341_DEV_CONFIG_VENDOR_CONFIG=NULL'",
+        "'-D LCD_SWAP_XY=false'",
+        "'-D LCD_MIRROR_X=true'",
+        "'-D LCD_MIRROR_Y=false'",
+        "'-D BOARD_HAS_TOUCH'",
+        "'-D TOUCH_CST816S_I2C'",
+        "'-D CST816S_I2C_HOST=I2C_NUM_0'",
+        "'-D CST816S_I2C_CONFIG_SDA_IO_NUM=33'",
+        "'-D CST816S_I2C_CONFIG_SCL_IO_NUM=32'",
+        "'-D CST816S_I2C_CONFIG_SDA_PULLUP_EN=GPIO_PULLUP_ENABLE'",
+        "'-D CST816S_I2C_CONFIG_SCL_PULLUP_EN=GPIO_PULLUP_ENABLE'",
+        "'-D CST816S_I2C_CONFIG_MASTER_CLK_SPEED=400000'",
+        "'-D CST816S_I2C_CONFIG_CLK_FLAGS=0'",
+        "'-D CST816S_IO_I2C_CONFIG_DEV_ADDR=ESP_LCD_TOUCH_IO_I2C_CST816S_ADDRESS'",
+        "'-D CST816S_IO_I2C_CONFIG_CONTROL_PHASE_BYTES=1'",
+        "'-D CST816S_IO_I2C_CONFIG_DC_BIT_OFFSET=0'",
+        "'-D CST816S_IO_I2C_CONFIG_LCD_CMD_BITS=8'",
+        "'-D CST816S_IO_I2C_CONFIG_LCD_PARAM_BITS=0'",
+        "'-D CST816S_IO_I2C_CONFIG_FLAGS_DC_LOW_ON_DATA=false'",
+        "'-D CST816S_IO_I2C_CONFIG_FLAGS_DISABLE_CONTROL_PHASE=true'",
+        "'-D CST816S_TOUCH_CONFIG_X_MAX=LCD_WIDTH'",
+        "'-D CST816S_TOUCH_CONFIG_Y_MAX=LCD_HEIGHT'",
+        "'-D CST816S_TOUCH_CONFIG_RST_GPIO_NUM=25'",
+        "'-D CST816S_TOUCH_CONFIG_INT_GPIO_NUM=21'",
+        "'-D CST816S_TOUCH_CONFIG_LEVELS_RESET=0'",
+        "'-D CST816S_TOUCH_CONFIG_LEVELS_INTERRUPT=0'",
+        "'-D TOUCH_SWAP_XY=true'",      
+        "'-D TOUCH_SWAP_X=false'",
+        "'-D TOUCH_SWAP_Y=false'",
+        "'-D BOARD_HAS_TF'",
+        "'-D TF_CS=5'",
+        "'-D TF_SPI_MOSI=23'",
+        "'-D TF_SPI_SCLK=18'",
+        "'-D TF_SPI_MISO=19'",
+        "'-D BOARD_HAS_RGB_LED'",
+        "'-D RGB_LED_R=4'",
+        "'-D RGB_LED_G=16'",
+        "'-D RGB_LED_B=17'",
+        "'-D BOARD_HAS_CDS'",
+        "'-D CDS=34'",
+        "'-D BOARD_HAS_SPEAK'",
+        "'-D SPEAK=26'",
+
+        "-DCYD_SCREEN_GAP_PX=8",
+        "-DCYD_SCREEN_MIN_BUTTON_HEIGHT_PX=35",
+        "-DCYD_SCREEN_MIN_BUTTON_WIDTH_PX=35",
+        "-DCYD_SCREEN_FONT=lv_font_montserrat_14",
+        "-DCYD_SCREEN_FONT_SMALL=lv_font_montserrat_10",
+        "-DCYD_SCREEN_SIDEBAR_SIZE_PX=40",
+        "-DCYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY=1",
+        "-DCYD_SCREEN_DISABLE_TOUCH_CALIBRATION=1"
+      ],
+      "f_cpu": "240000000L",
+      "f_flash": "40000000L",
+      "flash_mode": "dio",
+      "mcu": "esp32",
+      "variant": "esp32"
+    },
+    "connectivity": [
+      "wifi",
+      "bluetooth",
+      "ethernet",
+      "can"
+    ],
+    "debug": {
+      "openocd_board": "esp-wroom-32.cfg"
+    },
+    "frameworks": [
+      "arduino",
+      "espidf"
+    ],
+    "name": "esp32-2432S024C-SD",
+    "upload": {
+      "flash_size": "4MB",
+      "maximum_ram_size": 327680,
+      "maximum_size": 4194304,
+      "require_upload_port": true,
+      "speed": 460800
+    },
+    "url": "https://www.aliexpress.com/item/1005005865107357.html",
+    "vendor": "Sunton"
+  }

CYD-Klipper/boards/esp32-2432S028R.json

@@ -16,9 +16,6 @@
         "-DTFT_DC=2",
         "-DTFT_RST=-1",
         "-DLOAD_GCLD=1",
-        "-DLOAD_FONT2=1",
-        "-DLOAD_GFXFF=1",
-        "-DSMOOTH_FONT=1",
         "-DSPI_FREQUENCY=55000000",
         "-DSPI_READ_FREQUENCY=20000000",
         "-DSPI_TOUCH_FREQUENCY=2500000",

CYD-Klipper/boards/esp32-2432S028RV1-smartdisplay.json

@@ -0,0 +1,125 @@
+{
+    "build": {
+      "arduino": {
+        "ldscript": "esp32_out.ld"
+      },
+      "core": "esp32",
+      "extra_flags": [
+        "'-D ARDUINO_ESP32_DEV'",
+        "'-D ESP32_2432S028R'",
+        "'-D LCD_WIDTH=240'",
+        "'-D LCD_HEIGHT=320'",
+        "'-D LVGL_BUFFER_PIXELS=(LCD_WIDTH*LCD_HEIGHT/4)'",
+        "'-D LVGL_BUFFER_MALLOC_FLAGS=(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT)'",
+        "'-D GPIO_BCKL=21'",
+        "'-D LCD_ILI9341_SPI'",
+        "'-D ILI9341_SPI_HOST=SPI2_HOST'",
+        "'-D ILI9341_SPI_DMA_CHANNEL=SPI_DMA_CH_AUTO'",
+        "'-D ILI9341_SPI_BUS_MOSI_IO_NUM=13'",
+        "'-D ILI9341_SPI_BUS_MISO_IO_NUM=12'",
+        "'-D ILI9341_SPI_BUS_SCLK_IO_NUM=14'",
+        "'-D ILI9341_SPI_BUS_QUADWP_IO_NUM=GPIO_NUM_NC'",
+        "'-D ILI9341_SPI_BUS_QUADHD_IO_NUM=GPIO_NUM_NC'",
+        "'-D ILI9341_SPI_BUS_MAX_TRANSFER_SZ=(LVGL_BUFFER_PIXELS*sizeof(lv_color16_t))'",
+        "'-D ILI9341_SPI_BUS_FLAGS=0'",
+        "'-D ILI9341_SPI_BUS_INTR_FLAGS=0'",
+        "'-D ILI9341_SPI_CONFIG_CS_GPIO_NUM=15'",
+        "'-D ILI9341_SPI_CONFIG_DC_GPIO_NUM=2'",
+        "'-D ILI9341_SPI_CONFIG_SPI_MODE=SPI_MODE0'",
+        "'-D ILI9341_SPI_CONFIG_PCLK_HZ=24000000'",
+        "'-D ILI9341_SPI_CONFIG_TRANS_QUEUE_DEPTH=10'",
+        "'-D ILI9341_SPI_CONFIG_LCD_CMD_BITS=8'",
+        "'-D ILI9341_SPI_CONFIG_LCD_PARAM_BITS=8'",
+        "'-D ILI9341_SPI_CONFIG_FLAGS_DC_AS_CMD_PHASE=false'",
+        "'-D ILI9341_SPI_CONFIG_FLAGS_DC_LOW_ON_DATA=false'",
+        "'-D ILI9341_SPI_CONFIG_FLAGS_OCTAL_MODE=false'",
+        "'-D ILI9341_SPI_CONFIG_FLAGS_LSB_FIRST=false'",
+        "'-D ILI9341_DEV_CONFIG_RESET_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D ILI9341_DEV_CONFIG_COLOR_SPACE=ESP_LCD_COLOR_SPACE_BGR'",
+        "'-D ILI9341_DEV_CONFIG_BITS_PER_PIXEL=16'",
+        "'-D ILI9341_DEV_CONFIG_FLAGS_RESET_ACTIVE_HIGH=false'",
+        "'-D ILI9341_DEV_CONFIG_VENDOR_CONFIG=NULL'",
+        "'-D LCD_SWAP_XY=false'",
+        "'-D LCD_MIRROR_X=true'",
+        "'-D LCD_MIRROR_Y=false'",
+        "'-D BOARD_HAS_TOUCH'",
+        "'-D TOUCH_XPT2046_SPI'",
+        "'-D XPT2046_SPI_HOST=SPI3_HOST'",
+        "'-D XPT2046_SPI_DMA_CHANNEL=SPI_DMA_CH_AUTO'",      
+        "'-D XPT2046_SPI_BUS_MOSI_IO_NUM=32'",
+        "'-D XPT2046_SPI_BUS_MISO_IO_NUM=39'",
+        "'-D XPT2046_SPI_BUS_SCLK_IO_NUM=25'",
+        "'-D XPT2046_SPI_BUS_QUADWP_IO_NUM=GPIO_NUM_NC'",
+        "'-D XPT2046_SPI_BUS_QUADHD_IO_NUM=GPIO_NUM_NC'",
+        "'-D XPT2046_SPI_CONFIG_CS_GPIO_NUM=33'",
+        "'-D XPT2046_SPI_CONFIG_DC_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D XPT2046_SPI_CONFIG_SPI_MODE=SPI_MODE0'",
+        "'-D XPT2046_SPI_CONFIG_PCLK_HZ=2000000'",
+        "'-D XPT2046_SPI_CONFIG_TRANS_QUEUE_DEPTH=3'",
+        "'-D XPT2046_SPI_CONFIG_LCD_CMD_BITS=8'",
+        "'-D XPT2046_SPI_CONFIG_LCD_PARAM_BITS=8'",
+        "'-D XPT2046_SPI_CONFIG_FLAGS_DC_AS_CMD_PHASE=false'",
+        "'-D XPT2046_SPI_CONFIG_FLAGS_DC_LOW_ON_DATA=false'",
+        "'-D XPT2046_SPI_CONFIG_FLAGS_OCTAL_MODE=false'",
+        "'-D XPT2046_SPI_CONFIG_FLAGS_LSB_FIRST=false'",
+        "'-D XPT2046_TOUCH_CONFIG_X_MAX=LCD_WIDTH'",
+        "'-D XPT2046_TOUCH_CONFIG_Y_MAX=LCD_HEIGHT'",
+        "'-D XPT2046_TOUCH_CONFIG_RST_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D XPT2046_TOUCH_CONFIG_INT_GPIO_NUM=36'",
+        "'-D XPT2046_TOUCH_CONFIG_LEVELS_RESET=0'",
+        "'-D XPT2046_TOUCH_CONFIG_LEVELS_INTERRUPT=0'",
+        "'-D TOUCH_SWAP_XY=true'",
+        "'-D TOUCH_SWAP_X=true'",
+        "'-D TOUCH_SWAP_Y=false'",
+        "'-D BOARD_HAS_TF'",
+        "'-D TF_CS=5'",
+        "'-D TF_SPI_MOSI=23'",
+        "'-D TF_SPI_SCLK=18'",
+        "'-D TF_SPI_MISO=19'",
+        "'-D BOARD_HAS_RGB_LED'",
+        "'-D RGB_LED_R=4'",
+        "'-D RGB_LED_G=16'",
+        "'-D RGB_LED_B=17'",
+        "'-D BOARD_HAS_CDS'",
+        "'-D CDS=34'",
+        "'-D BOARD_HAS_SPEAK'",
+        "'-D SPEAK=26'",
+
+        "-DCYD_SCREEN_GAP_PX=8",
+        "-DCYD_SCREEN_MIN_BUTTON_HEIGHT_PX=35",
+        "-DCYD_SCREEN_MIN_BUTTON_WIDTH_PX=35",
+        "-DCYD_SCREEN_FONT=lv_font_montserrat_14",
+        "-DCYD_SCREEN_FONT_SMALL=lv_font_montserrat_10",
+        "-DCYD_SCREEN_SIDEBAR_SIZE_PX=40",
+        "-DCYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY=1"
+      ],
+      "f_cpu": "240000000L",
+      "f_flash": "40000000L",
+      "flash_mode": "dio",
+      "mcu": "esp32",
+      "variant": "esp32"
+    },
+    "connectivity": [
+      "wifi",
+      "bluetooth",
+      "ethernet",
+      "can"
+    ],
+    "debug": {
+      "openocd_board": "esp-wroom-32.cfg"
+    },
+    "frameworks": [
+      "arduino",
+      "espidf"
+    ],
+    "name": "esp32-2432S028Rv1-SD",
+    "upload": {
+      "flash_size": "4MB",
+      "maximum_ram_size": 327680,
+      "maximum_size": 4194304,
+      "require_upload_port": true,
+      "speed": 460800
+    },
+    "url": "https://www.aliexpress.com/item/1005004502250619.html",
+    "vendor": "Sunton"
+  }

CYD-Klipper/boards/esp32-2432S028RV2-smartdisplay.json

@@ -0,0 +1,125 @@
+{
+    "build": {
+      "arduino": {
+        "ldscript": "esp32_out.ld"
+      },
+      "core": "esp32",
+      "extra_flags": [
+        "'-D ARDUINO_ESP32_DEV'",
+        "'-D ESP32_2432S028Rv2'",
+        "'-D LCD_WIDTH=240'",
+        "'-D LCD_HEIGHT=320'",
+        "'-D LVGL_BUFFER_PIXELS=(LCD_WIDTH*LCD_HEIGHT/4)'",
+        "'-D LVGL_BUFFER_MALLOC_FLAGS=(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT)'",
+        "'-D GPIO_BCKL=21'",
+        "'-D LCD_ILI9341_SPI'",
+        "'-D ILI9341_SPI_HOST=SPI2_HOST'",
+        "'-D ILI9341_SPI_DMA_CHANNEL=SPI_DMA_CH_AUTO'",
+        "'-D ILI9341_SPI_BUS_MOSI_IO_NUM=13'",
+        "'-D ILI9341_SPI_BUS_MISO_IO_NUM=12'",
+        "'-D ILI9341_SPI_BUS_SCLK_IO_NUM=14'",
+        "'-D ILI9341_SPI_BUS_QUADWP_IO_NUM=GPIO_NUM_NC'",
+        "'-D ILI9341_SPI_BUS_QUADHD_IO_NUM=GPIO_NUM_NC'",
+        "'-D ILI9341_SPI_BUS_MAX_TRANSFER_SZ=(LVGL_BUFFER_PIXELS*sizeof(lv_color16_t))'",
+        "'-D ILI9341_SPI_BUS_FLAGS=0'",
+        "'-D ILI9341_SPI_BUS_INTR_FLAGS=0'",
+        "'-D ILI9341_SPI_CONFIG_CS_GPIO_NUM=15'",
+        "'-D ILI9341_SPI_CONFIG_DC_GPIO_NUM=2'",
+        "'-D ILI9341_SPI_CONFIG_SPI_MODE=SPI_MODE0'",
+        "'-D ILI9341_SPI_CONFIG_PCLK_HZ=24000000'",
+        "'-D ILI9341_SPI_CONFIG_TRANS_QUEUE_DEPTH=10'",
+        "'-D ILI9341_SPI_CONFIG_LCD_CMD_BITS=8'",
+        "'-D ILI9341_SPI_CONFIG_LCD_PARAM_BITS=8'",
+        "'-D ILI9341_SPI_CONFIG_FLAGS_DC_AS_CMD_PHASE=false'",
+        "'-D ILI9341_SPI_CONFIG_FLAGS_DC_LOW_ON_DATA=false'",
+        "'-D ILI9341_SPI_CONFIG_FLAGS_OCTAL_MODE=false'",
+        "'-D ILI9341_SPI_CONFIG_FLAGS_LSB_FIRST=false'",
+        "'-D ILI9341_DEV_CONFIG_RESET_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D ILI9341_DEV_CONFIG_COLOR_SPACE=ESP_LCD_COLOR_SPACE_BGR'",
+        "'-D ILI9341_DEV_CONFIG_BITS_PER_PIXEL=16'",
+        "'-D ILI9341_DEV_CONFIG_FLAGS_RESET_ACTIVE_HIGH=false'",
+        "'-D ILI9341_DEV_CONFIG_VENDOR_CONFIG=\"(ili9341_vendor_config_t[]){{.init_cmds=(ili9341_lcd_init_cmd_t[]){{.cmd=0xCF,.data=(uint8_t[]){0x00,0xC1,0x30},.data_bytes=3},{.cmd=0xED,.data=(uint8_t[]){0x64,0x03,0x12,0x81},.data_bytes=4},{.cmd=0xE8,.data=(uint8_t[]){0x85,0x00,0x78},.data_bytes=3},{.cmd=0xCB,.data=(uint8_t[]){0x39,0x2C,0x00,0x34,0x02},.data_bytes=5},{.cmd=0xF7,.data=(uint8_t[]){0x20},.data_bytes=1},{.cmd=0xEA,.data=(uint8_t[]){0x00,0x00},.data_bytes=2},{.cmd=0xC0,.data=(uint8_t[]){0x10},.data_bytes=1},{.cmd=0xC1,.data=(uint8_t[]){0x00},.data_bytes=1},{.cmd=0xC5,.data=(uint8_t[]){0x30,0x30},.data_bytes=2,},{.cmd=0xC7,.data=(uint8_t[]){0xB7},.data_bytes=1},{.cmd=0x3A,.data=(uint8_t[]){0x55},.data_bytes=1},{.cmd=0x36,.data=(uint8_t[]){0x08},.data_bytes=1},{.cmd=0xB1,.data=(uint8_t[]){0x00,0x1A},.data_bytes=2},{.cmd=0xB6,.data=(uint8_t[]){0x08,0x82,0x27},.data_bytes=3},{.cmd=0xF2,.data=(uint8_t[]){0x00},.data_bytes=1},{.cmd=0x26,.data=(uint8_t[]){0x01},.data_bytes=1},{.cmd=0xE0,.data=(uint8_t[]){0x0F,0x2A,0x28,0x08,0x0E,0x08,0x54,0xA9,0x43,0x0A,0x0F,0x00,0x00,0x00,0x00},.data_bytes=15},{.cmd=0xE1,.data=(uint8_t[]){0x00,0x15,0x17,0x07,0x11,0x06,0x2B,0x56,0x3C,0x05,0x10,0x0F,0x3F,0x3F,0x0F},.data_bytes=15},{.cmd=0x2B,.data=(uint8_t[]){0x00,0x00,0x01,0x3F},.data_bytes=4},{.cmd=0x2A,.data=(uint8_t[]){0x00,0x00,0x00,0xEF},.data_bytes=4},{.cmd=0x21},{.cmd=0x11,.delay_ms=120},{.cmd=0x29,.delay_ms=1}},.init_cmds_size=23}}\"'",
+        "'-D LCD_SWAP_XY=false'",
+        "'-D LCD_MIRROR_X=true'",
+        "'-D LCD_MIRROR_Y=false'",
+        "'-D BOARD_HAS_TOUCH'",
+        "'-D TOUCH_XPT2046_SPI'",
+        "'-D XPT2046_SPI_HOST=SPI3_HOST'",
+        "'-D XPT2046_SPI_DMA_CHANNEL=SPI_DMA_CH_AUTO'",      
+        "'-D XPT2046_SPI_BUS_MOSI_IO_NUM=32'",
+        "'-D XPT2046_SPI_BUS_MISO_IO_NUM=39'",
+        "'-D XPT2046_SPI_BUS_SCLK_IO_NUM=25'",
+        "'-D XPT2046_SPI_BUS_QUADWP_IO_NUM=GPIO_NUM_NC'",
+        "'-D XPT2046_SPI_BUS_QUADHD_IO_NUM=GPIO_NUM_NC'",
+        "'-D XPT2046_SPI_CONFIG_CS_GPIO_NUM=33'",
+        "'-D XPT2046_SPI_CONFIG_DC_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D XPT2046_SPI_CONFIG_SPI_MODE=SPI_MODE0'",
+        "'-D XPT2046_SPI_CONFIG_PCLK_HZ=2000000'",
+        "'-D XPT2046_SPI_CONFIG_TRANS_QUEUE_DEPTH=3'",
+        "'-D XPT2046_SPI_CONFIG_LCD_CMD_BITS=8'",
+        "'-D XPT2046_SPI_CONFIG_LCD_PARAM_BITS=8'",
+        "'-D XPT2046_SPI_CONFIG_FLAGS_DC_AS_CMD_PHASE=false'",
+        "'-D XPT2046_SPI_CONFIG_FLAGS_DC_LOW_ON_DATA=false'",
+        "'-D XPT2046_SPI_CONFIG_FLAGS_OCTAL_MODE=false'",
+        "'-D XPT2046_SPI_CONFIG_FLAGS_LSB_FIRST=false'",
+        "'-D XPT2046_TOUCH_CONFIG_X_MAX=LCD_WIDTH'",
+        "'-D XPT2046_TOUCH_CONFIG_Y_MAX=LCD_HEIGHT'",
+        "'-D XPT2046_TOUCH_CONFIG_RST_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D XPT2046_TOUCH_CONFIG_INT_GPIO_NUM=36'",
+        "'-D XPT2046_TOUCH_CONFIG_LEVELS_RESET=0'",
+        "'-D XPT2046_TOUCH_CONFIG_LEVELS_INTERRUPT=0'",
+        "'-D TOUCH_SWAP_XY=true'",
+        "'-D TOUCH_SWAP_X=true'",
+        "'-D TOUCH_SWAP_Y=false'",
+        "'-D BOARD_HAS_TF'",
+        "'-D TF_CS=5'",
+        "'-D TF_SPI_MOSI=23'",
+        "'-D TF_SPI_SCLK=18'",
+        "'-D TF_SPI_MISO=19'",
+        "'-D BOARD_HAS_RGB_LED'",
+        "'-D RGB_LED_R=4'",
+        "'-D RGB_LED_G=16'",
+        "'-D RGB_LED_B=17'",
+        "'-D BOARD_HAS_CDS'",
+        "'-D CDS=34'",
+        "'-D BOARD_HAS_SPEAK'",
+        "'-D SPEAK=26'",
+
+        "-DCYD_SCREEN_GAP_PX=8",
+        "-DCYD_SCREEN_MIN_BUTTON_HEIGHT_PX=35",
+        "-DCYD_SCREEN_MIN_BUTTON_WIDTH_PX=35",
+        "-DCYD_SCREEN_FONT=lv_font_montserrat_14",
+        "-DCYD_SCREEN_FONT_SMALL=lv_font_montserrat_10",
+        "-DCYD_SCREEN_SIDEBAR_SIZE_PX=40",
+        "-DCYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY=1"
+      ],
+      "f_cpu": "240000000L",
+      "f_flash": "40000000L",
+      "flash_mode": "dio",
+      "mcu": "esp32",
+      "variant": "esp32"
+    },
+    "connectivity": [
+      "wifi",
+      "bluetooth",
+      "ethernet",
+      "can"
+    ],
+    "debug": {
+      "openocd_board": "esp-wroom-32.cfg"
+    },
+    "frameworks": [
+      "arduino",
+      "espidf"
+    ],
+    "name": "esp32-2432S028Rv2-SD",
+    "upload": {
+      "flash_size": "4MB",
+      "maximum_ram_size": 327680,
+      "maximum_size": 4194304,
+      "require_upload_port": true,
+      "speed": 460800
+    },
+    "url": "https://www.aliexpress.com/item/1005004502250619.html",
+    "vendor": "Sunton"
+  }

CYD-Klipper/boards/esp32-2432S028RV3-smartdisplay.json

@@ -0,0 +1,125 @@
+{
+    "build": {
+      "arduino": {
+        "ldscript": "esp32_out.ld"
+      },
+      "core": "esp32",
+      "extra_flags": [
+        "'-D ARDUINO_ESP32_DEV'",
+        "'-D ESP32_2432S028Rv3'",
+        "'-D LCD_WIDTH=240'",
+        "'-D LCD_HEIGHT=320'",
+        "'-D LVGL_BUFFER_PIXELS=(LCD_WIDTH*LCD_HEIGHT/4)'",
+        "'-D LVGL_BUFFER_MALLOC_FLAGS=(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT)'",
+        "'-D GPIO_BCKL=21'",
+        "'-D LCD_ST7789_SPI'",
+        "'-D ST7789_SPI_HOST=SPI2_HOST'",
+        "'-D ST7789_SPI_DMA_CHANNEL=SPI_DMA_CH_AUTO'",
+        "'-D ST7789_SPI_BUS_MOSI_IO_NUM=13'",
+        "'-D ST7789_SPI_BUS_MISO_IO_NUM=GPIO_NUM_NC'",
+        "'-D ST7789_SPI_BUS_SCLK_IO_NUM=14'",
+        "'-D ST7789_SPI_BUS_QUADWP_IO_NUM=GPIO_NUM_NC'",
+        "'-D ST7789_SPI_BUS_QUADHD_IO_NUM=GPIO_NUM_NC'",
+        "'-D ST7789_SPI_BUS_MAX_TRANSFER_SZ=(LVGL_BUFFER_PIXELS*sizeof(lv_color16_t))'",
+        "'-D ST7789_SPI_BUS_FLAGS=0'",
+        "'-D ST7789_SPI_BUS_INTR_FLAGS=0'",
+        "'-D ST7789_SPI_CONFIG_CS_GPIO_NUM=15'",
+        "'-D ST7789_SPI_CONFIG_DC_GPIO_NUM=2'",
+        "'-D ST7789_SPI_CONFIG_SPI_MODE=SPI_MODE3'",
+        "'-D ST7789_SPI_CONFIG_PCLK_HZ=24000000'",
+        "'-D ST7789_SPI_CONFIG_TRANS_QUEUE_DEPTH=10'",
+        "'-D ST7789_SPI_CONFIG_LCD_CMD_BITS=8'",
+        "'-D ST7789_SPI_CONFIG_LCD_PARAM_BITS=8'",
+        "'-D ST7789_SPI_CONFIG_FLAGS_DC_AS_CMD_PHASE=false'",
+        "'-D ST7789_SPI_CONFIG_FLAGS_DC_LOW_ON_DATA=false'",
+        "'-D ST7789_SPI_CONFIG_FLAGS_OCTAL_MODE=false'",
+        "'-D ST7789_SPI_CONFIG_FLAGS_LSB_FIRST=false'",
+        "'-D ST7789_DEV_CONFIG_RESET_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D ST7789_DEV_CONFIG_COLOR_SPACE=ESP_LCD_COLOR_SPACE_RGB'",
+        "'-D ST7789_DEV_CONFIG_BITS_PER_PIXEL=16'",
+        "'-D ST7789_DEV_CONFIG_FLAGS_RESET_ACTIVE_HIGH=false'",
+        "'-D ST7789_DEV_CONFIG_VENDOR_CONFIG=NULL'",
+        "'-D LCD_SWAP_XY=false'",
+        "'-D LCD_MIRROR_X=false'",
+        "'-D LCD_MIRROR_Y=false'",
+        "'-D BOARD_HAS_TOUCH'",
+        "'-D TOUCH_XPT2046_SPI'",
+        "'-D XPT2046_SPI_HOST=SPI3_HOST'",
+        "'-D XPT2046_SPI_DMA_CHANNEL=SPI_DMA_CH_AUTO'",      
+        "'-D XPT2046_SPI_BUS_MOSI_IO_NUM=32'",
+        "'-D XPT2046_SPI_BUS_MISO_IO_NUM=39'",
+        "'-D XPT2046_SPI_BUS_SCLK_IO_NUM=25'",
+        "'-D XPT2046_SPI_BUS_QUADWP_IO_NUM=GPIO_NUM_NC'",
+        "'-D XPT2046_SPI_BUS_QUADHD_IO_NUM=GPIO_NUM_NC'",
+        "'-D XPT2046_SPI_CONFIG_CS_GPIO_NUM=33'",
+        "'-D XPT2046_SPI_CONFIG_DC_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D XPT2046_SPI_CONFIG_SPI_MODE=SPI_MODE0'",
+        "'-D XPT2046_SPI_CONFIG_PCLK_HZ=2000000'",
+        "'-D XPT2046_SPI_CONFIG_TRANS_QUEUE_DEPTH=3'",
+        "'-D XPT2046_SPI_CONFIG_LCD_CMD_BITS=8'",
+        "'-D XPT2046_SPI_CONFIG_LCD_PARAM_BITS=8'",
+        "'-D XPT2046_SPI_CONFIG_FLAGS_DC_AS_CMD_PHASE=false'",
+        "'-D XPT2046_SPI_CONFIG_FLAGS_DC_LOW_ON_DATA=false'",
+        "'-D XPT2046_SPI_CONFIG_FLAGS_OCTAL_MODE=false'",
+        "'-D XPT2046_SPI_CONFIG_FLAGS_LSB_FIRST=false'",
+        "'-D XPT2046_TOUCH_CONFIG_X_MAX=LCD_WIDTH'",
+        "'-D XPT2046_TOUCH_CONFIG_Y_MAX=LCD_HEIGHT'",
+        "'-D XPT2046_TOUCH_CONFIG_RST_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D XPT2046_TOUCH_CONFIG_INT_GPIO_NUM=36'",
+        "'-D XPT2046_TOUCH_CONFIG_LEVELS_RESET=0'",
+        "'-D XPT2046_TOUCH_CONFIG_LEVELS_INTERRUPT=0'",
+        "'-D TOUCH_SWAP_XY=true'",
+        "'-D TOUCH_SWAP_X=true'",
+        "'-D TOUCH_SWAP_Y=false'",
+        "'-D BOARD_HAS_TF'",
+        "'-D TF_CS=5'",
+        "'-D TF_SPI_MOSI=23'",
+        "'-D TF_SPI_SCLK=18'",
+        "'-D TF_SPI_MISO=19'",
+        "'-D BOARD_HAS_RGB_LED'",
+        "'-D RGB_LED_R=4'",
+        "'-D RGB_LED_G=16'",
+        "'-D RGB_LED_B=17'",
+        "'-D BOARD_HAS_CDS'",
+        "'-D CDS=34'",
+        "'-D BOARD_HAS_SPEAK'",
+        "'-D SPEAK=26'",
+        
+        "-DCYD_SCREEN_GAP_PX=8",
+        "-DCYD_SCREEN_MIN_BUTTON_HEIGHT_PX=35",
+        "-DCYD_SCREEN_MIN_BUTTON_WIDTH_PX=35",
+        "-DCYD_SCREEN_FONT=lv_font_montserrat_14",
+        "-DCYD_SCREEN_FONT_SMALL=lv_font_montserrat_10",
+        "-DCYD_SCREEN_SIDEBAR_SIZE_PX=40",
+        "-DCYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY=1"
+      ],
+      "f_cpu": "240000000L",
+      "f_flash": "40000000L",
+      "flash_mode": "dio",
+      "mcu": "esp32",
+      "variant": "esp32"
+    },
+    "connectivity": [
+      "wifi",
+      "bluetooth",
+      "ethernet",
+      "can"
+    ],
+    "debug": {
+      "openocd_board": "esp-wroom-32.cfg"
+    },
+    "frameworks": [
+      "arduino",
+      "espidf"
+    ],
+    "name": "esp32-2432S028Rv3-SD",
+    "upload": {
+      "flash_size": "4MB",
+      "maximum_ram_size": 327680,
+      "maximum_size": 4194304,
+      "require_upload_port": true,
+      "speed": 460800
+    },
+    "url": "https://www.aliexpress.com/item/1005004502250619.html",
+    "vendor": "Sunton"
+  }

CYD-Klipper/boards/esp32-2432S032C-smartdisplay.json

@@ -0,0 +1,125 @@
+{
+    "build": {
+      "arduino": {
+        "ldscript": "esp32_out.ld"
+      },
+      "core": "esp32",
+      "extra_flags": [
+        "'-D ARDUINO_ESP32_DEV'",
+        "'-D ESP32_2432S032C'",
+        "'-D LCD_WIDTH=240'",
+        "'-D LCD_HEIGHT=320'",
+        "'-D LVGL_BUFFER_PIXELS=(LCD_WIDTH*LCD_HEIGHT/4)'",
+        "'-D LVGL_BUFFER_MALLOC_FLAGS=(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT)'",
+        "'-D GPIO_BCKL=27'",
+        "'-D LCD_IPS'",
+        "'-D LCD_ST7789_SPI'",
+        "'-D ST7789_SPI_HOST=SPI2_HOST'",
+        "'-D ST7789_SPI_DMA_CHANNEL=SPI_DMA_CH_AUTO'",
+        "'-D ST7789_SPI_BUS_MOSI_IO_NUM=13'",
+        "'-D ST7789_SPI_BUS_MISO_IO_NUM=12'",
+        "'-D ST7789_SPI_BUS_SCLK_IO_NUM=14'",
+        "'-D ST7789_SPI_BUS_QUADWP_IO_NUM=GPIO_NUM_NC'",
+        "'-D ST7789_SPI_BUS_QUADHD_IO_NUM=GPIO_NUM_NC'",
+        "'-D ST7789_SPI_BUS_MAX_TRANSFER_SZ=(LVGL_BUFFER_PIXELS*sizeof(lv_color16_t))'",
+        "'-D ST7789_SPI_BUS_FLAGS=0'",
+        "'-D ST7789_SPI_BUS_INTR_FLAGS=0'",
+        "'-D ST7789_SPI_CONFIG_CS_GPIO_NUM=15'",
+        "'-D ST7789_SPI_CONFIG_DC_GPIO_NUM=2'",
+        "'-D ST7789_SPI_CONFIG_SPI_MODE=SPI_MODE3'",
+        "'-D ST7789_SPI_CONFIG_PCLK_HZ=24000000'",
+        "'-D ST7789_SPI_CONFIG_TRANS_QUEUE_DEPTH=10'",
+        "'-D ST7789_SPI_CONFIG_LCD_CMD_BITS=8'",
+        "'-D ST7789_SPI_CONFIG_LCD_PARAM_BITS=8'",
+        "'-D ST7789_SPI_CONFIG_FLAGS_DC_AS_CMD_PHASE=false'",
+        "'-D ST7789_SPI_CONFIG_FLAGS_DC_LOW_ON_DATA=false'",
+        "'-D ST7789_SPI_CONFIG_FLAGS_OCTAL_MODE=false'",
+        "'-D ST7789_SPI_CONFIG_FLAGS_LSB_FIRST=false'",
+        "'-D ST7789_DEV_CONFIG_RESET_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D ST7789_DEV_CONFIG_COLOR_SPACE=ESP_LCD_COLOR_SPACE_RGB'",
+        "'-D ST7789_DEV_CONFIG_BITS_PER_PIXEL=16'",
+        "'-D ST7789_DEV_CONFIG_FLAGS_RESET_ACTIVE_HIGH=false'",
+        "'-D ST7789_DEV_CONFIG_VENDOR_CONFIG=NULL'",
+        "'-D LCD_SWAP_XY=false'",
+        "'-D LCD_MIRROR_X=false'",
+        "'-D LCD_MIRROR_Y=false'",
+        "'-D BOARD_HAS_TOUCH'",
+        "'-D TOUCH_GT911_I2C'",
+        "'-D GT911_I2C_HOST=I2C_NUM_0'",
+        "'-D GT911_I2C_CONFIG_SDA_IO_NUM=33'",
+        "'-D GT911_I2C_CONFIG_SCL_IO_NUM=32'",
+        "'-D GT911_I2C_CONFIG_SDA_PULLUP_EN=GPIO_PULLUP_DISABLE'",
+        "'-D GT911_I2C_CONFIG_SCL_PULLUP_EN=GPIO_PULLUP_DISABLE'",
+        "'-D GT911_I2C_CONFIG_MASTER_CLK_SPEED=400000'",
+        "'-D GT911_I2C_CONFIG_CLK_FLAGS=I2C_SCLK_SRC_FLAG_FOR_NOMAL'",
+        "'-D GT911_IO_I2C_CONFIG_DEV_ADDR=ESP_LCD_TOUCH_IO_I2C_GT911_ADDRESS'",
+        "'-D GT911_IO_I2C_CONFIG_CONTROL_PHASE_BYTES=1'",
+        "'-D GT911_IO_I2C_CONFIG_DC_BIT_OFFSET=0'",
+        "'-D GT911_IO_I2C_CONFIG_LCD_CMD_BITS=16'",
+        "'-D GT911_IO_I2C_CONFIG_LCD_PARAM_BITS=0'",
+        "'-D GT911_IO_I2C_CONFIG_FLAGS_DC_LOW_ON_DATA=false'",
+        "'-D GT911_IO_I2C_CONFIG_FLAGS_DISABLE_CONTROL_PHASE=true'",
+        "'-D GT911_TOUCH_CONFIG_X_MAX=LCD_WIDTH'",
+        "'-D GT911_TOUCH_CONFIG_Y_MAX=LCD_HEIGHT'",
+        "'-D GT911_TOUCH_CONFIG_RST_GPIO_NUM=25'",
+        "'-D GT911_TOUCH_CONFIG_INT_GPIO_NUM=21'",
+        "'-D GT911_TOUCH_CONFIG_LEVELS_RESET=0'",
+        "'-D GT911_TOUCH_CONFIG_LEVELS_INTERRUPT=0'",
+        "'-D TOUCH_SWAP_XY=true'",
+        "'-D TOUCH_SWAP_X=false'",
+        "'-D TOUCH_SWAP_Y=false'",
+        "'-D BOARD_HAS_TF'",
+        "'-D TF_CS=5'",
+        "'-D TF_SPI_MOSI=23'",
+        "'-D TF_SPI_SCLK=18'",
+        "'-D TF_SPI_MISO=19'",
+        "'-D BOARD_HAS_RGB_LED'",
+        "'-D RGB_LED_R=4'",
+        "'-D RGB_LED_G=16'",
+        "'-D RGB_LED_B=17'",
+        "'-D BOARD_HAS_CDS'",
+        "'-D CDS=34'",
+        "'-D BOARD_HAS_SPEAK'",
+        "'-D SPEAK=26'",
+
+        "-DCYD_SCREEN_HEIGHT_PX=240",
+        "-DCYD_SCREEN_WIDTH_PX=320",
+        "-DCYD_SCREEN_GAP_PX=8",
+        "-DCYD_SCREEN_MIN_BUTTON_HEIGHT_PX=35",
+        "-DCYD_SCREEN_MIN_BUTTON_WIDTH_PX=35",
+        "-DCYD_SCREEN_FONT=lv_font_montserrat_14",
+        "-DCYD_SCREEN_FONT_SMALL=lv_font_montserrat_10",
+        "-DCYD_SCREEN_SIDEBAR_SIZE_PX=40",
+        "-DCYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY=1",
+        "-DCYD_SCREEN_DISABLE_TOUCH_CALIBRATION=1"
+      ],
+      "f_cpu": "240000000L",
+      "f_flash": "40000000L",
+      "flash_mode": "dio",
+      "mcu": "esp32",
+      "variant": "esp32"
+    },
+    "connectivity": [
+      "wifi",
+      "bluetooth",
+      "ethernet",
+      "can"
+    ],
+    "debug": {
+      "openocd_board": "esp-wroom-32.cfg"
+    },
+    "frameworks": [
+      "arduino",
+      "espidf"
+    ],
+    "name": "esp32-2432S032C-SD",
+    "upload": {
+      "flash_size": "4MB",
+      "maximum_ram_size": 327680,
+      "maximum_size": 4194304,
+      "require_upload_port": true,
+      "speed": 460800
+    },
+    "url": "https://www.aliexpress.com/item/1005006224494145.html",
+    "vendor": "Sunton"
+  }

CYD-Klipper/boards/esp32-3248S035C-smartdisplay.json

@@ -9,7 +9,9 @@
         "'-D ESP32_3248S035C'",
         "'-D LCD_WIDTH=320'",
         "'-D LCD_HEIGHT=480'",
-        "'-D BCKL=27'",
+        "'-D LVGL_BUFFER_PIXELS=(LCD_WIDTH*LCD_HEIGHT/4)'",
+        "'-D LVGL_BUFFER_MALLOC_FLAGS=(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT)'",
+        "'-D GPIO_BCKL=27'",
         "'-D LCD_ST7796_SPI'",
         "'-D ST7796_SPI_HOST=SPI2_HOST'",
         "'-D ST7796_SPI_DMA_CHANNEL=SPI_DMA_CH_AUTO'",
@@ -18,6 +20,9 @@
         "'-D ST7796_SPI_BUS_SCLK_IO_NUM=14'",
         "'-D ST7796_SPI_BUS_QUADWP_IO_NUM=GPIO_NUM_NC'",
         "'-D ST7796_SPI_BUS_QUADHD_IO_NUM=GPIO_NUM_NC'",
+        "'-D ST7796_SPI_BUS_MAX_TRANSFER_SZ=(LVGL_BUFFER_PIXELS*sizeof(lv_color16_t))'",
+        "'-D ST7796_SPI_BUS_FLAGS=0'",
+        "'-D ST7796_SPI_BUS_INTR_FLAGS=0'",
         "'-D ST7796_SPI_CONFIG_CS_GPIO_NUM=15'",
         "'-D ST7796_SPI_CONFIG_DC_GPIO_NUM=2'",
         "'-D ST7796_SPI_CONFIG_SPI_MODE=SPI_MODE0'",
@@ -39,13 +44,13 @@
         "'-D LCD_MIRROR_Y=false'",
         "'-D BOARD_HAS_TOUCH'",
         "'-D TOUCH_GT911_I2C'",
-        "'-D GT911_I2C_HOST=0'",
+        "'-D GT911_I2C_HOST=I2C_NUM_0'",
         "'-D GT911_I2C_CONFIG_SDA_IO_NUM=33'",
         "'-D GT911_I2C_CONFIG_SCL_IO_NUM=32'",
-        "'-D GT911_I2C_CONFIG_SDA_PULLUP_EN=GPIO_PULLUP_ENABLE'",
+        "'-D GT911_I2C_CONFIG_SDA_PULLUP_EN=GPIO_PULLUP_DISABLE'",
-        "'-D GT911_I2C_CONFIG_SCL_PULLUP_EN=GPIO_PULLUP_ENABLE'",
+        "'-D GT911_I2C_CONFIG_SCL_PULLUP_EN=GPIO_PULLUP_DISABLE'",
         "'-D GT911_I2C_CONFIG_MASTER_CLK_SPEED=400000'",
-        "'-D GT911_I2C_CONFIG_CLK_FLAGS=0'",
+        "'-D GT911_I2C_CONFIG_CLK_FLAGS=I2C_SCLK_SRC_FLAG_FOR_NOMAL'",
         "'-D GT911_IO_I2C_CONFIG_DEV_ADDR=ESP_LCD_TOUCH_IO_I2C_GT911_ADDRESS'",
         "'-D GT911_IO_I2C_CONFIG_CONTROL_PHASE_BYTES=1'",
         "'-D GT911_IO_I2C_CONFIG_DC_BIT_OFFSET=0'",
@@ -74,7 +79,16 @@
         "'-D BOARD_HAS_CDS'",
         "'-D CDS=34'",
         "'-D BOARD_HAS_SPEAK'",
-        "'-D SPEAK=26'"
+        "'-D SPEAK=26'",
+
+        "-DCYD_SCREEN_GAP_PX=10",
+        "-DCYD_SCREEN_MIN_BUTTON_HEIGHT_PX=45",
+        "-DCYD_SCREEN_MIN_BUTTON_WIDTH_PX=45",
+        "-DCYD_SCREEN_FONT=lv_font_montserrat_16",
+        "-DCYD_SCREEN_FONT_SMALL=lv_font_montserrat_12",
+        "-DCYD_SCREEN_SIDEBAR_SIZE_PX=50",
+        "-DCYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY=1",
+        "-DCYD_SCREEN_DISABLE_TOUCH_CALIBRATION=1"
       ],
       "f_cpu": "240000000L",
       "f_flash": "40000000L",

CYD-Klipper/boards/esp32-3248S035C-vertical.json

@@ -0,0 +1,66 @@
+{
+    "build": {
+      "arduino": {
+        "ldscript": "esp32_out.ld"
+      },
+      "core": "esp32",
+      "extra_flags": [
+        "-DUSER_SETUP_LOADED=1",
+        "-DST7796_DRIVER=1",
+        "-DTFT_BL=27",
+        "-DTFT_BACKLIGHT_ON=HIGH",
+        "-DTFT_MISO=12",
+        "-DTFT_MOSI=13",
+        "-DTFT_SCLK=14",
+        "-DTFT_CS=15",
+        "-DTFT_DC=2",
+        "-DTFT_RST=-1",
+        "-DLOAD_GCLD=1",
+        "-DSPI_FREQUENCY=80000000",
+        "-DSPI_READ_FREQUENCY=20000000",
+        "-DSPI_TOUCH_FREQUENCY=2500000",
+        "-DTOUCH_CS=-1",
+
+        "-DCYD_SCREEN_HEIGHT_PX=480",
+        "-DCYD_SCREEN_WIDTH_PX=320",
+        "-DCYD_SCREEN_GAP_PX=10",
+        "-DCYD_SCREEN_MIN_BUTTON_HEIGHT_PX=45",
+        "-DCYD_SCREEN_MIN_BUTTON_WIDTH_PX=45",
+        "-DCYD_SCREEN_FONT=lv_font_montserrat_16",
+        "-DCYD_SCREEN_FONT_SMALL=lv_font_montserrat_12",
+        "-DCYD_SCREEN_SIDEBAR_SIZE_PX=50",
+        "-DCYD_SCREEN_DRIVER_ESP32_3248S035C=1",
+        "-DCYD_SCREEN_DISABLE_TOUCH_CALIBRATION=1",
+        "-DCYD_SCREEN_VERTICAL=1",
+        "-DCYD_SCREEN_NO_TEMP_SCROLL=1"
+      ],
+      "f_cpu": "240000000L",
+      "f_flash": "40000000L",
+      "flash_mode": "dio",
+      "mcu": "esp32",
+      "variant": "esp32"
+    },
+    "connectivity": [
+      "wifi",
+      "bluetooth",
+      "ethernet",
+      "can"
+    ],
+    "debug": {
+      "openocd_board": "esp-wroom-32.cfg"
+    },
+    "frameworks": [
+      "arduino",
+      "espidf"
+    ],
+    "name": "esp32-3248S035C-V",
+    "upload": {
+      "flash_size": "4MB",
+      "maximum_ram_size": 327680,
+      "maximum_size": 4194304,
+      "require_upload_port": true,
+      "speed": 460800
+    },
+    "url": "https://www.aliexpress.com/item/1005004632953455.html",
+    "vendor": "Sunton"
+  }

CYD-Klipper/boards/esp32-3248S035C.json

@@ -16,9 +16,6 @@
         "-DTFT_DC=2",
         "-DTFT_RST=-1",
         "-DLOAD_GCLD=1",
-        "-DLOAD_FONT2=1",
-        "-DLOAD_GFXFF=1",
-        "-DSMOOTH_FONT=1",
         "-DSPI_FREQUENCY=80000000",
         "-DSPI_READ_FREQUENCY=20000000",
         "-DSPI_TOUCH_FREQUENCY=2500000",
@@ -27,8 +24,8 @@
         "-DCYD_SCREEN_HEIGHT_PX=320",
         "-DCYD_SCREEN_WIDTH_PX=480",
         "-DCYD_SCREEN_GAP_PX=10",
-        "-DCYD_SCREEN_MIN_BUTTON_HEIGHT_PX=40",
+        "-DCYD_SCREEN_MIN_BUTTON_HEIGHT_PX=45",
-        "-DCYD_SCREEN_MIN_BUTTON_WIDTH_PX=40",
+        "-DCYD_SCREEN_MIN_BUTTON_WIDTH_PX=45",
         "-DCYD_SCREEN_FONT=lv_font_montserrat_16",
         "-DCYD_SCREEN_FONT_SMALL=lv_font_montserrat_12",
         "-DCYD_SCREEN_SIDEBAR_SIZE_PX=50",

CYD-Klipper/boards/esp32-4827S043C-smartdisplay.json

@@ -0,0 +1,143 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld",
+      "partitions": "default_16MB.csv",
+      "memory_type": "qio_opi"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "'-D ARDUINO_ESP32S3_DEV'",
+      "'-D BOARD_HAS_PSRAM'",
+      "'-D ARDUINO_USB_MODE=1'",
+      "'-D ARDUINO_RUNNING_CORE=1'",
+      "'-D ARDUINO_EVENT_RUNNING_CORE=1'",
+      "'-D ARDUINO_USB_CDC_ON_BOOT=0'",
+      "'-D ESP32_4827S043C'",
+      "'-D LCD_WIDTH=480'",
+      "'-D LCD_HEIGHT=272'",
+      "'-D LVGL_BUFFER_PIXELS=(LCD_WIDTH*LCD_HEIGHT)'",
+      "'-D LVGL_BUFFER_MALLOC_FLAGS=(MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT)'",
+      "'-D GPIO_BCKL=2'",
+      "'-D LCD_ST7262_PAR'",
+      "'-D ST7262_PANEL_CONFIG_CLK_SRC=LCD_CLK_SRC_PLL160M'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_PCLK_HZ=(8*1000000)'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_H_RES=LCD_WIDTH'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_V_RES=LCD_HEIGHT'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_HSYNC_PULSE_WIDTH=4'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_HSYNC_BACK_PORCH=43'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_HSYNC_FRONT_PORCH=8'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_VSYNC_PULSE_WIDTH=4'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_VSYNC_BACK_PORCH=12'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_VSYNC_FRONT_PORCH=8'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_FLAGS_HSYNC_IDLE_LOW=true'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_FLAGS_VSYNC_IDLE_LOW=true'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_FLAGS_DE_IDLE_HIGH=false'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_FLAGS_PCLK_ACTIVE_NEG=true'",
+      "'-D ST7262_PANEL_CONFIG_TIMINGS_FLAGS_PCLK_IDLE_HIGH=false'",
+      "'-D ST7262_PANEL_CONFIG_DATA_WIDTH=16'",
+      "'-D ST7262_PANEL_CONFIG_SRAM_TRANS_ALIGN=4'",
+      "'-D ST7262_PANEL_CONFIG_PSRAM_TRANS_ALIGN=64'",
+      "'-D ST7262_PANEL_CONFIG_HSYNC_GPIO_NUM=39'",
+      "'-D ST7262_PANEL_CONFIG_VSYNC_GPIO_NUM=41'",
+      "'-D ST7262_PANEL_CONFIG_DE_GPIO_NUM=40'",
+      "'-D ST7262_PANEL_CONFIG_PCLK_GPIO_NUM=42'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_R0=8'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_R1=3'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_R2=46'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_R3=9'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_R4=1'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_G0=5'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_G1=6'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_G2=7'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_G3=15'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_G4=16'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_G5=4'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_B0=45'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_B1=48'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_B2=47'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_B3=21'",
+      "'-D ST7262_PANEL_CONFIG_DATA_GPIO_B4=14'",
+      "'-D ST7262_PANEL_CONFIG_DISP_GPIO_NUM=GPIO_NUM_NC'",
+      "'-D ST7262_PANEL_CONFIG_FLAGS_DISP_ACTIVE_LOW=false'",
+      "'-D ST7262_PANEL_CONFIG_FLAGS_RELAX_ON_IDLE=false'",
+      "'-D ST7262_PANEL_CONFIG_FLAGS_FB_IN_PSRAM=true'",
+      "'-D BOARD_HAS_TOUCH'",
+      "'-D TOUCH_GT911_I2C'",
+      "'-D GT911_I2C_HOST=I2C_NUM_0'",
+      "'-D GT911_I2C_CONFIG_SDA_IO_NUM=19'",
+      "'-D GT911_I2C_CONFIG_SCL_IO_NUM=20'",
+      "'-D GT911_I2C_CONFIG_SDA_PULLUP_EN=GPIO_PULLUP_DISABLE'",
+      "'-D GT911_I2C_CONFIG_SCL_PULLUP_EN=GPIO_PULLUP_DISABLE'",
+      "'-D GT911_I2C_CONFIG_MASTER_CLK_SPEED=400000'",
+      "'-D GT911_I2C_CONFIG_CLK_FLAGS=I2C_SCLK_SRC_FLAG_FOR_NOMAL'",
+      "'-D GT911_IO_I2C_CONFIG_DEV_ADDR=ESP_LCD_TOUCH_IO_I2C_GT911_ADDRESS'",
+      "'-D GT911_IO_I2C_CONFIG_CONTROL_PHASE_BYTES=1'",
+      "'-D GT911_IO_I2C_CONFIG_DC_BIT_OFFSET=0'",
+      "'-D GT911_IO_I2C_CONFIG_LCD_CMD_BITS=16'",
+      "'-D GT911_IO_I2C_CONFIG_LCD_PARAM_BITS=0'",
+      "'-D GT911_IO_I2C_CONFIG_FLAGS_DC_LOW_ON_DATA=false'",
+      "'-D GT911_IO_I2C_CONFIG_FLAGS_DISABLE_CONTROL_PHASE=true'",
+      "'-D GT911_TOUCH_CONFIG_X_MAX=LCD_WIDTH'",
+      "'-D GT911_TOUCH_CONFIG_Y_MAX=LCD_HEIGHT'",
+      "'-D GT911_TOUCH_CONFIG_RST_GPIO_NUM=38'",
+      "'-D GT911_TOUCH_CONFIG_INT_GPIO_NUM=18'",
+      "'-D GT911_TOUCH_CONFIG_LEVELS_RESET=0'",
+      "'-D GT911_TOUCH_CONFIG_LEVELS_INTERRUPT=0'",
+      "'-D TOUCH_SWAP_XY=false'",
+      "'-D TOUCH_SWAP_X=false'",
+      "'-D TOUCH_SWAP_Y=false'",
+      "'-D BOARD_HAS_TF'",
+      "'-D TF_CS=10'",
+      "'-D TF_SPI_MOSI=11'",
+      "'-D TF_SPI_SCLK=12'",
+      "'-D TF_SPI_MISO=13'",
+
+      "'-DCYD_SCREEN_HEIGHT_PX=272'",
+      "'-DCYD_SCREEN_WIDTH_PX=480'",
+      "-DROTATION_INVERTED=LV_DISP_ROT_180",
+      "-DROTATION_NORMAL=LV_DISP_ROT_NONE",
+      "'-DCYD_SCREEN_GAP_PX=10'",
+      "'-DCYD_SCREEN_MIN_BUTTON_HEIGHT_PX=35'",
+      "'-DCYD_SCREEN_MIN_BUTTON_WIDTH_PX=40'",
+      "'-DCYD_SCREEN_FONT=lv_font_montserrat_16'",
+      "'-DCYD_SCREEN_FONT_SMALL=lv_font_montserrat_12'",
+      "'-DCYD_SCREEN_SIDEBAR_SIZE_PX=50'",
+      "'-DCYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY=1'",
+      "'-DCYD_SCREEN_DISABLE_TOUCH_CALIBRATION=1'"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "hwids": [
+      [
+        "0x303A",
+        "0x1001"
+      ]
+    ],
+    "mcu": "esp32s3",
+    "variant": "esp32s3"
+  },
+  "connectivity": [
+    "wifi"
+  ],
+  "debug": {
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": [
+    "arduino",
+    "espidf"
+  ],
+  "name": "esp32-4827S043C-SD",
+  "upload": {
+    "flash_size": "16MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 16777216,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": true,
+    "require_upload_port": true,
+    "speed": 460800
+  },
+  "url": "https://www.aliexpress.com/item/1005004788147691.html",
+  "vendor": "Sunton"
+}

CYD-Klipper/boards/esp32-8048S043C-smartdisplay.json

@@ -0,0 +1,143 @@
+{
+    "build": {
+      "arduino": {
+        "ldscript": "esp32s3_out.ld",
+        "partitions": "default_16MB.csv",
+        "memory_type": "qio_opi"
+      },
+      "core": "esp32",
+      "extra_flags": [
+        "'-D ARDUINO_ESP32S3_DEV'",
+        "'-D BOARD_HAS_PSRAM'",
+        "'-D ARDUINO_USB_MODE=1'",
+        "'-D ARDUINO_RUNNING_CORE=1'",
+        "'-D ARDUINO_EVENT_RUNNING_CORE=1'",
+        "'-D ARDUINO_USB_CDC_ON_BOOT=0'",
+        "'-D ESP32_8048S043C'",
+        "'-D LCD_WIDTH=800'",
+        "'-D LCD_HEIGHT=480'",
+        "'-D LVGL_BUFFER_PIXELS=(LCD_WIDTH*LCD_HEIGHT)'",
+        "'-D LVGL_BUFFER_MALLOC_FLAGS=(MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT)'",
+        "'-D GPIO_BCKL=2'",
+        "'-D LCD_ST7262_PAR'",
+        "'-D ST7262_PANEL_CONFIG_CLK_SRC=LCD_CLK_SRC_PLL160M'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_PCLK_HZ=(12.5*1000000)'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_H_RES=LCD_WIDTH'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_V_RES=LCD_HEIGHT'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_HSYNC_PULSE_WIDTH=4'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_HSYNC_BACK_PORCH=8'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_HSYNC_FRONT_PORCH=8'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_VSYNC_PULSE_WIDTH=4'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_VSYNC_BACK_PORCH=8'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_VSYNC_FRONT_PORCH=8'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_FLAGS_HSYNC_IDLE_LOW=false'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_FLAGS_VSYNC_IDLE_LOW=false'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_FLAGS_DE_IDLE_HIGH=false'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_FLAGS_PCLK_ACTIVE_NEG=true'",
+        "'-D ST7262_PANEL_CONFIG_TIMINGS_FLAGS_PCLK_IDLE_HIGH=false'",
+        "'-D ST7262_PANEL_CONFIG_DATA_WIDTH=16'",
+        "'-D ST7262_PANEL_CONFIG_SRAM_TRANS_ALIGN=4'",
+        "'-D ST7262_PANEL_CONFIG_PSRAM_TRANS_ALIGN=64'",
+        "'-D ST7262_PANEL_CONFIG_HSYNC_GPIO_NUM=39'",
+        "'-D ST7262_PANEL_CONFIG_VSYNC_GPIO_NUM=41'",
+        "'-D ST7262_PANEL_CONFIG_DE_GPIO_NUM=40'",
+        "'-D ST7262_PANEL_CONFIG_PCLK_GPIO_NUM=42'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_R0=8'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_R1=3'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_R2=46'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_R3=9'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_R4=1'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_G0=5'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_G1=6'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_G2=7'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_G3=15'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_G4=16'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_G5=4'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_B0=45'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_B1=48'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_B2=47'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_B3=21'",
+        "'-D ST7262_PANEL_CONFIG_DATA_GPIO_B4=14'",
+        "'-D ST7262_PANEL_CONFIG_DISP_GPIO_NUM=GPIO_NUM_NC'",
+        "'-D ST7262_PANEL_CONFIG_FLAGS_DISP_ACTIVE_LOW=false'",
+        "'-D ST7262_PANEL_CONFIG_FLAGS_RELAX_ON_IDLE=false'",
+        "'-D ST7262_PANEL_CONFIG_FLAGS_FB_IN_PSRAM=true'",
+        "'-D BOARD_HAS_TOUCH'",
+        "'-D TOUCH_GT911_I2C'",
+        "'-D GT911_I2C_HOST=I2C_NUM_0'",
+        "'-D GT911_I2C_CONFIG_SDA_IO_NUM=19'",
+        "'-D GT911_I2C_CONFIG_SCL_IO_NUM=20'",
+        "'-D GT911_I2C_CONFIG_SDA_PULLUP_EN=GPIO_PULLUP_DISABLE'",
+        "'-D GT911_I2C_CONFIG_SCL_PULLUP_EN=GPIO_PULLUP_DISABLE'",
+        "'-D GT911_I2C_CONFIG_MASTER_CLK_SPEED=400000'",
+        "'-D GT911_I2C_CONFIG_CLK_FLAGS=I2C_SCLK_SRC_FLAG_FOR_NOMAL'",
+        "'-D GT911_IO_I2C_CONFIG_DEV_ADDR=ESP_LCD_TOUCH_IO_I2C_GT911_ADDRESS'",
+        "'-D GT911_IO_I2C_CONFIG_CONTROL_PHASE_BYTES=1'",
+        "'-D GT911_IO_I2C_CONFIG_DC_BIT_OFFSET=0'",
+        "'-D GT911_IO_I2C_CONFIG_LCD_CMD_BITS=16'",
+        "'-D GT911_IO_I2C_CONFIG_LCD_PARAM_BITS=0'",
+        "'-D GT911_IO_I2C_CONFIG_FLAGS_DC_LOW_ON_DATA=false'",
+        "'-D GT911_IO_I2C_CONFIG_FLAGS_DISABLE_CONTROL_PHASE=true'",
+        "'-D GT911_TOUCH_CONFIG_X_MAX=LCD_WIDTH'",
+        "'-D GT911_TOUCH_CONFIG_Y_MAX=LCD_HEIGHT'",
+        "'-D GT911_TOUCH_CONFIG_RST_GPIO_NUM=38'",
+        "'-D GT911_TOUCH_CONFIG_INT_GPIO_NUM=18'",
+        "'-D GT911_TOUCH_CONFIG_LEVELS_RESET=0'",
+        "'-D GT911_TOUCH_CONFIG_LEVELS_INTERRUPT=0'",
+        "'-D TOUCH_SWAP_XY=false'",
+        "'-D TOUCH_SWAP_X=false'",
+        "'-D TOUCH_SWAP_Y=false'",
+        "'-D BOARD_HAS_TF'",
+        "'-D TF_CS=10'",
+        "'-D TF_SPI_MOSI=11'",
+        "'-D TF_SPI_SCLK=12'",
+        "'-D TF_SPI_MISO=13'",
+
+        "-DCYD_SCREEN_HEIGHT_PX=480",
+        "-DCYD_SCREEN_WIDTH_PX=800",
+        "-DROTATION_INVERTED=LV_DISP_ROT_180",
+        "-DROTATION_NORMAL=LV_DISP_ROT_NONE",
+        "-DCYD_SCREEN_GAP_PX=15",
+        "-DCYD_SCREEN_MIN_BUTTON_HEIGHT_PX=60",
+        "-DCYD_SCREEN_MIN_BUTTON_WIDTH_PX=60",
+        "-DCYD_SCREEN_FONT=lv_font_montserrat_22",
+        "-DCYD_SCREEN_FONT_SMALL=lv_font_montserrat_16",
+        "-DCYD_SCREEN_SIDEBAR_SIZE_PX=70",
+        "-DCYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY=1",
+        "-DCYD_SCREEN_DISABLE_TOUCH_CALIBRATION=1"
+      ],
+      "f_cpu": "240000000L",
+      "f_flash": "80000000L",
+      "flash_mode": "qio",
+      "hwids": [
+        [
+          "0x303A",
+          "0x1001"
+        ]
+      ],
+      "mcu": "esp32s3",
+      "variant": "esp32s3"
+    },
+    "connectivity": [
+      "wifi"
+    ],
+    "debug": {
+      "openocd_target": "esp32s3.cfg"
+    },
+    "frameworks": [
+      "arduino",
+      "espidf"
+    ],
+    "name": "esp32-8048S043C-SD",
+    "upload": {
+      "flash_size": "16MB",
+      "maximum_ram_size": 327680,
+      "maximum_size": 16777216,
+      "use_1200bps_touch": true,
+      "wait_for_upload_port": true,
+      "require_upload_port": true,
+      "speed": 460800
+    },
+    "url": "https://www.aliexpress.com/item/1005006110360174.html",
+    "vendor": "Sunton"
+  }

CYD-Klipper/extract_commit.py

@@ -15,11 +15,17 @@ except:
     version = "Unknown"
 
 flag = "-D REPO_VERSION=\\\"" + version + "\\\""
+dev_flag = "-DREPO_DEVELOPMENT=1"
 print(f"Version: {version}")
 print(f"Flag: {flag}")
 
+flags = [flag]
+
+if ('(' in version):
+    flags.append(dev_flag)
+
 Import("env")
 
 env.Append(
-    BUILD_FLAGS=[flag]
+    BUILD_FLAGS=flags
 )

CYD-Klipper/platformio.ini

@@ -14,9 +14,10 @@ board = esp32dev
 framework = arduino
 monitor_speed = 115200
 lib_deps = 
-	https://github.com/suchmememanyskill/esp32-smartdisplay
+	https://github.com/suchmememanyskill/esp32-smartdisplay#9c1d737
 	bblanchon/ArduinoJson@^7.0.0
 	plageoj/UrlEncode@^1.0.1
+	erriez/ErriezCRC32 @ ^1.0.1
 monitor_filters = esp32_exception_decoder
 build_flags = 
 	-DLV_CONF_PATH="../../../../src/conf/lv_conf.h"
@@ -32,6 +33,7 @@ lib_deps =
 	https://github.com/PaulStoffregen/XPT2046_Touchscreen.git
 	bblanchon/ArduinoJson@^7.0.0
 	plageoj/UrlEncode@^1.0.1
+	erriez/ErriezCRC32 @ ^1.0.1
 
 [env:esp32-3248S035C]
 board = esp32-3248S035C
@@ -42,18 +44,39 @@ lib_deps =
 	https://github.com/OperatorB/gt911-arduino-fixed-reset.git
 	bblanchon/ArduinoJson@^7.0.0
 	plageoj/UrlEncode@^1.0.1
+	erriez/ErriezCRC32 @ ^1.0.1
 
-# Terribly slow. Only use for development
+[env:esp32-3248S035C-V]
-# [env:esp32-3248S035C-smartdisplay]
+board = esp32-3248S035C-vertical
-# board = esp32-3248S035C-smartdisplay
+lib_deps = 
-# build_flags = 
+	SPI
-# 	-DLV_CONF_PATH="../../../../src/conf/lv_conf.h"
+	https://github.com/suchmememanyskill/lvgl
-# 	-DCYD_SCREEN_HEIGHT_PX=320
+	https://github.com/Bodmer/TFT_eSPI.git
-# 	-DCYD_SCREEN_WIDTH_PX=480
+	https://github.com/OperatorB/gt911-arduino-fixed-reset.git
-# 	-DCYD_SCREEN_GAP_PX=10
+	bblanchon/ArduinoJson@^7.0.0
-# 	-DCYD_SCREEN_MIN_BUTTON_HEIGHT_PX=40
+	plageoj/UrlEncode@^1.0.1
-# 	-DCYD_SCREEN_MIN_BUTTON_WIDTH_PX=40
+	erriez/ErriezCRC32 @ ^1.0.1
-# 	-DCYD_SCREEN_FONT=lv_font_montserrat_16
+
-# 	-DCYD_SCREEN_FONT_SMALL=lv_font_montserrat_12
+[env:esp32-2432S024C-SD]
-# 	-DCYD_SCREEN_SIDEBAR_SIZE_PX=50
+board = esp32-2432S024C-smartdisplay
-# 	-DCYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY=1
+
+[env:esp32-2432S028Rv1-SD]
+board = esp32-2432S028RV1-smartdisplay
+
+[env:esp32-2432S028Rv2-SD]
+board = esp32-2432S028RV2-smartdisplay
+
+[env:esp32-2432S028Rv3-SD]
+board = esp32-2432S028RV3-smartdisplay
+
+[env:esp32-2432S032C-SD]
+board = esp32-2432S032C-smartdisplay
+
+[env:esp32-3248S035C-SD]
+board = esp32-3248S035C-smartdisplay
+
+[env:esp32-4827S043C-SD]
+board = esp32-4827S043C-smartdisplay
+
+[env:esp32-8048S043C-SD]
+board = esp32-8048S043C-smartdisplay

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,76 @@ 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];
+        }
+
+        write_global_config();
+        ESP.restart();
+    }    
+
+    write_global_config();
+}
+
+void load_global_config() 
+{
     global_config.version = CONFIG_VERSION;
     global_config.brightness = 255;
-    global_config.screenTimeout = 5;
+    global_config.screen_timeout = 5;
-    global_config.hotend_presets[0] = 0;
+    global_config.printer_config[0].hotend_presets[0] = 0;
-    global_config.hotend_presets[1] = 200;
+    global_config.printer_config[0].hotend_presets[1] = 200;
-    global_config.hotend_presets[2] = 240;
+    global_config.printer_config[0].hotend_presets[2] = 240;
-    global_config.bed_presets[0] = 0;
+    global_config.printer_config[0].bed_presets[0] = 0;
-    global_config.bed_presets[1] = 60;
+    global_config.printer_config[0].bed_presets[1] = 60;
-    global_config.bed_presets[2] = 70;
+    global_config.printer_config[0].bed_presets[2] = 70;
-    VerifyVersion();
+    verify_version();
     Preferences preferences;
     preferences.begin("global_config", true);
     preferences.getBytes("global_config", &global_config, sizeof(global_config));

CYD-Klipper/src/conf/global_config.h

@@ -3,7 +3,40 @@
 
 #include "lvgl.h"
 
-#define CONFIG_VERSION 4
+#define CONFIG_VERSION 5
+#define PRINTER_CONFIG_COUNT 8
+
+enum {
+    REMAINING_TIME_CALC_PERCENTAGE = 0,
+    REMAINING_TIME_CALC_INTERPOLATED = 1,
+    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[25];
+    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;
@@ -11,35 +44,30 @@ typedef struct _GLOBAL_CONFIG {
         unsigned int raw;
         struct {
             // Internal
-            bool screenCalibrated : 1;
+            bool screen_calibrated : 1;
-            bool wifiConfigured : 1;
+            bool wifi_configured : 1;
-            bool ipConfigured : 1;
 
             // External
-            bool lightMode : 1;
+            bool rotate_screen : 1;
-            bool invertColors : 1;
+            bool auto_ota_update : 1;
-            bool rotateScreen : 1;
+            bool multi_printer_mode : 1;
-            bool onDuringPrint : 1;
+            bool on_during_print : 1;
-            bool autoOtaUpdate : 1;
         };
     };
-    float screenCalXOffset;
-    float screenCalXMult;
-    float screenCalYOffset;
-    float screenCalYMult;
 
-    char wifiSSID[32];
+    PRINTER_CONFIG printer_config[PRINTER_CONFIG_COUNT];
-    char wifiPassword[64];
 
-    char klipperHost[64];
+    float screen_cal_x_offset;
-    unsigned short klipperPort;
+    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 char screen_timeout;
-
+    unsigned char printer_index;
-    unsigned short hotend_presets[3];
-    unsigned short bed_presets[3];
 } GLOBAL_CONFIG;
     
 typedef struct _COLOR_DEF {
@@ -51,8 +79,13 @@ typedef struct _COLOR_DEF {
 extern GLOBAL_CONFIG global_config;
 extern COLOR_DEF color_defs[];
 
-void WriteGlobalConfig();
+void write_global_config();
-void VerifyVersion();
+void verify_version();
-void LoadGlobalConfig();
+void load_global_config();
+
+PRINTER_CONFIG* get_current_printer_config();
+int get_printer_config_count();
+void set_printer_config_index(int index);
+int get_printer_config_free_index();
 
 #endif // !_GLOBAL_CONFIG_INIT

CYD-Klipper/src/conf/lv_conf.h

@@ -49,7 +49,7 @@
 #define LV_MEM_CUSTOM 0
 #if LV_MEM_CUSTOM == 0
     /*Size of the memory available for `lv_mem_alloc()` in bytes (>= 2kB)*/
-    #define LV_MEM_SIZE (32U * 1024U)          /*[bytes]*/
+    #define LV_MEM_SIZE (40U * 1024U)          /*[bytes]*/
 
     /*Set an address for the memory pool instead of allocating it as a normal array. Can be in external SRAM too.*/
     #define LV_MEM_ADR 0     /*0: unused*/
@@ -194,7 +194,7 @@
  *-----------*/
 
 /*Enable the log module*/
-#define LV_USE_LOG 1
+#define LV_USE_LOG 0
 #if LV_USE_LOG
 
     /*How important log should be added:
@@ -204,7 +204,7 @@
     *LV_LOG_LEVEL_ERROR       Only critical issue, when the system may fail
     *LV_LOG_LEVEL_USER        Only logs added by the user
     *LV_LOG_LEVEL_NONE        Do not log anything*/
-    #define LV_LOG_LEVEL LV_LOG_LEVEL_USER
+    #define LV_LOG_LEVEL LV_LOG_LEVEL_NONE
 
     /*1: Print the log with 'printf';
     *0: User need to register a callback with `lv_log_register_print_cb()`*/
@@ -242,8 +242,12 @@
  * Others
  *-----------*/
 
+#ifndef REPO_DEVELOPMENT
+    #define REPO_DEVELOPMENT 0
+#endif
+
 /*1: Show CPU usage and FPS count*/
-#define LV_USE_PERF_MONITOR 0
+#define LV_USE_PERF_MONITOR REPO_DEVELOPMENT
 #if LV_USE_PERF_MONITOR
     #define LV_USE_PERF_MONITOR_POS LV_ALIGN_BOTTOM_RIGHT
 #endif
@@ -332,7 +336,7 @@
 #define LV_FONT_MONTSERRAT_16 1
 #define LV_FONT_MONTSERRAT_18 0
 #define LV_FONT_MONTSERRAT_20 0
-#define LV_FONT_MONTSERRAT_22 0
+#define LV_FONT_MONTSERRAT_22 1
 #define LV_FONT_MONTSERRAT_24 0
 #define LV_FONT_MONTSERRAT_26 0
 #define LV_FONT_MONTSERRAT_28 1
@@ -497,7 +501,7 @@
 
 #define LV_USE_MSG 1
 
-#define LV_USE_CHART      0
+#define LV_USE_CHART      1
 
 #define LV_USE_COLORWHEEL 0
 
@@ -603,7 +607,7 @@
 #endif
 
 /*PNG decoder library*/
-#define LV_USE_PNG 0
+#define LV_USE_PNG 1
 
 /*BMP decoder library*/
 #define LV_USE_BMP 0
@@ -674,16 +678,16 @@
  ====================*/
 
 /*Show some widget. It might be required to increase `LV_MEM_SIZE` */
-#define LV_USE_DEMO_WIDGETS        1
+#define LV_USE_DEMO_WIDGETS        0
 #if LV_USE_DEMO_WIDGETS
 #define LV_DEMO_WIDGETS_SLIDESHOW  1
 #endif
 
 /*Demonstrate the usage of encoder and keyboard*/
-#define LV_USE_DEMO_KEYPAD_AND_ENCODER     1
+#define LV_USE_DEMO_KEYPAD_AND_ENCODER     0
 
 /*Benchmark your system*/
-#define LV_USE_DEMO_BENCHMARK   1
+#define LV_USE_DEMO_BENCHMARK   0
 
 /*Stress test for LVGL*/
 #define LV_USE_DEMO_STRESS      0

CYD-Klipper/src/core/data_setup.cpp

@@ -2,11 +2,13 @@
 #include "data_setup.h"
 #include "lvgl.h"
 #include "../conf/global_config.h"
-#include <HTTPClient.h>
 #include <ArduinoJson.h>
 #include <esp_task_wdt.h>
 #include "macros_query.h"
 #include <UrlEncode.h>
+#include "http_client.h"
+#include "../ui/ui_utils.h"
+#include "macros_query.h"
 
 const char *printer_state_messages[] = {
     "Error",
@@ -14,6 +16,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;
@@ -45,16 +48,8 @@ void unfreeze_render_thread(){
 void send_gcode(bool wait, const char *gcode)
 {
     Serial.printf("Sending gcode: %s\n", gcode);
-    char buff[256] = {};
-    sprintf(buff, "http://%s:%d/printer/gcode/script?script=%s", global_config.klipperHost, global_config.klipperPort, urlEncode(gcode).c_str());
-    HTTPClient client;
-    client.begin(buff);
-
-    if (!wait)
-    {
-        client.setTimeout(1000);
-    }
 
+    SETUP_HTTP_CLIENT_FULL("/printer/gcode/script?script=" + urlEncode(gcode), false, wait ? 5000 : 750);
     try
     {
         client.GET();
@@ -65,14 +60,62 @@ void send_gcode(bool wait, const char *gcode)
     }
 }
 
+int get_slicer_time_estimate_s()
+{
+    if (printer.state == PRINTER_STATE_IDLE)
+        return 0;
+    
+    delay(10);
+
+    SETUP_HTTP_CLIENT("/server/files/metadata?filename=" + urlEncode(printer.print_filename));
+
+    int httpCode = client.GET();
+
+    if (httpCode != 200) 
+        return 0;
+    
+    JsonDocument doc;
+    deserializeJson(doc, client.getStream());
+    int time_estimate_s = doc["result"]["estimated_time"];
+    Serial.printf("Got slicer time estimate: %ds\n", time_estimate_s);
+    return time_estimate_s;
+}
+
+void move_printer(const char* axis, float amount, bool relative) {
+    if (!printer.homed_axis || printer.state == PRINTER_STATE_PRINTING)
+        return;
+
+    char gcode[64];
+    const char* extra = (amount > 0) ? "+" : "";
+
+    bool absolute_coords = printer.absolute_coords;
+
+    if (absolute_coords && relative) {
+        send_gcode(true, "G91");
+    }
+    else if (!absolute_coords && !relative) {
+        send_gcode(true, "G90");
+    }
+
+    sprintf(gcode, "G1 %s%s%.3f F6000", axis, extra, amount);
+    send_gcode(true, gcode);
+
+    if (absolute_coords && relative) {
+        send_gcode(true, "G90");
+    }
+    else if (!absolute_coords && !relative) {
+        send_gcode(true, "G91");
+    }
+}
+
+int last_slicer_time_query = -15000;
+
 void fetch_printer_data()
 {
     freeze_request_thread();
-    char buff[256] = {};
+    PRINTER_CONFIG *config = get_current_printer_config();
-    sprintf(buff, "http://%s:%d/printer/objects/query?extruder&heater_bed&toolhead&gcode_move&virtual_sdcard&print_stats&webhooks&fan", global_config.klipperHost, global_config.klipperPort);
+    SETUP_HTTP_CLIENT("/printer/objects/query?extruder&heater_bed&toolhead&gcode_move&virtual_sdcard&print_stats&webhooks&fan&display_status")
-    HTTPClient client;
+
-    client.useHTTP10(true);
-    client.begin(buff);
     int httpCode = client.GET();
     delay(10);
     if (httpCode == 200)
@@ -96,7 +139,7 @@ void fetch_printer_data()
             {
                 printer_state = PRINTER_STATE_IDLE;
             }
-            else if (strcmp(state, "shutdown") == 0 && printer.state != PRINTER_STATE_ERROR)
+            else if ((strcmp(state, "shutdown") == 0 || strcmp(state, "error") == 0) && printer.state != PRINTER_STATE_ERROR)
             {
                 printer_state = PRINTER_STATE_ERROR;
             }
@@ -122,6 +165,7 @@ void fetch_printer_data()
                 printer.extruder_target_temp = status["extruder"]["target"];
                 bool can_extrude = status["extruder"]["can_extrude"];
                 printer.pressure_advance = status["extruder"]["pressure_advance"];
+                printer.smooth_time = status["extruder"]["smooth_time"];
                 printer.can_extrude = can_extrude == true;
             }
 
@@ -175,7 +219,11 @@ void fetch_printer_data()
 
                 const char *state = status["print_stats"]["state"];
 
-                if (strcmp(state, "printing") == 0)
+                if (state == nullptr)
+                {
+                    printer_state = PRINTER_STATE_ERROR;
+                }
+                else if (strcmp(state, "printing") == 0)
                 {
                     printer_state = PRINTER_STATE_PRINTING;
                 }
@@ -189,12 +237,44 @@ void fetch_printer_data()
                 }
             }
 
-            // TODO: make a call to /server/files/metadata to get more accurate time estimates
+            if (status.containsKey("display_status"))
-            // https://moonraker.readthedocs.io/en/latest/web_api/#server-administration
+            {
+                const char* message = status["display_status"]["message"];
+                lv_create_popup_message(message, 10000);
+            }
 
             if (printer.state == PRINTER_STATE_PRINTING && printer.print_progress > 0)
             {
-                printer.remaining_time_s = (printer.elapsed_time_s / printer.print_progress) - printer.elapsed_time_s;
+                float remaining_time_s_percentage = (printer.elapsed_time_s / printer.print_progress) - printer.elapsed_time_s;
+                float remaining_time_s_slicer = 0;
+
+                if (printer.slicer_estimated_print_time_s > 0)
+                {
+                    remaining_time_s_slicer = printer.slicer_estimated_print_time_s - printer.elapsed_time_s;
+                }
+
+                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 (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 (config->remaining_time_calc_mode == REMAINING_TIME_CALC_SLICER)
+                {
+                    printer.remaining_time_s = remaining_time_s_slicer;
+                }
+            }
+
+            if (printer.remaining_time_s < 0)
+            {
+                printer.remaining_time_s = 0;
+            }
+
+            if (printer.state == PRINTER_STATE_IDLE)
+            {
+                printer.slicer_estimated_print_time_s = 0;
             }
 
             lv_msg_send(DATA_PRINTER_DATA, &printer);
@@ -206,6 +286,13 @@ void fetch_printer_data()
             lv_msg_send(DATA_PRINTER_STATE, &printer);
         }
         
+        if (printer.state == PRINTER_STATE_PRINTING && millis() - last_slicer_time_query > 30000 && printer.slicer_estimated_print_time_s <= 0)
+        {
+            delay(10);
+            last_slicer_time_query = millis();
+            printer.slicer_estimated_print_time_s = get_slicer_time_estimate_s();
+        }
+
         unfreeze_render_thread();
     }
     else
@@ -216,6 +303,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, get_full_url("/printer/objects/query?webhooks&print_stats&virtual_sdcard", config), true, 1000);
+        freeze_request_thread();
+
+        int httpCode = client.GET();
+        delay(10);
+        if (httpCode == 200)
+        {
+            data[i].online = true;
+            data[i].power_devices = 0;
+            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 (data[i].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;
+                    }
+                }
+            }
+        }
+        else 
+        {
+            data[i].online = false;
+            data[i].power_devices = power_devices_count(config);
+            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
@@ -226,9 +401,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;
+            }
+        }
     }
 }
 
@@ -236,10 +418,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);
+    xTaskCreatePinnedToCore(data_loop_background, "data_loop_background", 5000, NULL, 2, &background_loop, 0);
 }

CYD-Klipper/src/core/data_setup.h

@@ -23,8 +23,8 @@ typedef struct _Printer {
     float elapsed_time_s;
     float remaining_time_s;
     float filament_used_mm;
-    char* print_filename; // 0 -> 1
+    char* print_filename; 
-    float print_progress;
+    float print_progress; // 0 -> 1
     float fan_speed; // 0 -> 1
     float gcode_offset[3];
     float speed_mult;
@@ -32,19 +32,31 @@ typedef struct _Printer {
     int total_layers;
     int current_layer;
     float pressure_advance;
+    float smooth_time;
     int feedrate_mm_per_s;
+    int slicer_estimated_print_time_s;
 } Printer;
 
+typedef struct _PrinterMinimal {
+    bool online;
+    unsigned char state;
+    float print_progress; // 0 -> 1
+    unsigned int power_devices;
+} 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();
 void send_gcode(bool wait, const char* gcode);
+void move_printer(const char* axis, float amount, bool relative);
 
 void freeze_request_thread();
 void unfreeze_request_thread();

CYD-Klipper/src/core/device/ESP32-2432S028R.cpp

@@ -1,6 +1,10 @@
 #ifdef CYD_SCREEN_DRIVER_ESP32_2432S028R
 #include "../screen_driver.h"
 
+#ifdef CYD_SCREEN_VERTICAL
+    #error "Vertical screen not supported with the ESP32_2432S028R driver"
+#endif
+
 #include <SPI.h>
 #include <TFT_eSPI.h>
 #include "../../conf/global_config.h"
@@ -25,71 +29,6 @@ static lv_color_t buf[CYD_SCREEN_HEIGHT_PX * CYD_SCREEN_WIDTH_PX / 10];
 
 TFT_eSPI tft = TFT_eSPI();
 
-TS_Point touchscreen_point()
-{
-    TS_Point p = touchscreen.getPoint();
-    p.x = round((p.x * global_config.screenCalXMult) + global_config.screenCalXOffset);
-    p.y = round((p.y * global_config.screenCalYMult) + global_config.screenCalYOffset);
-    return p;
-}
-
-void touchscreen_calibrate(bool force)
-{
-    if (global_config.screenCalibrated && !force)
-        {
-            return;
-        }
-
-    tft.fillScreen(TFT_BLACK);
-    tft.setCursor(20, 140);
-    tft.setTextColor(TFT_WHITE, TFT_BLACK);
-    tft.setTextSize(2);
-    tft.println("Calibrate Screen");
-
-    TS_Point p;
-    int16_t x1, y1, x2, y2;
-
-    while (touchscreen.touched())
-        ;
-    tft.drawFastHLine(0, 10, 20, ILI9341_WHITE);
-    tft.drawFastVLine(10, 0, 20, ILI9341_WHITE);
-    while (!touchscreen.touched())
-        ;
-    delay(50);
-    p = touchscreen.getPoint();
-    x1 = p.x;
-    y1 = p.y;
-    tft.drawFastHLine(0, 10, 20, ILI9341_BLACK);
-    tft.drawFastVLine(10, 0, 20, ILI9341_BLACK);
-    delay(500);
-
-    while (touchscreen.touched())
-        ;
-    tft.drawFastHLine(300, 230, 20, ILI9341_WHITE);
-    tft.drawFastVLine(310, 220, 20, ILI9341_WHITE);
-
-    while (!touchscreen.touched())
-        ;
-    delay(50);
-    p = touchscreen.getPoint();
-    x2 = p.x;
-    y2 = p.y;
-    tft.drawFastHLine(300, 230, 20, ILI9341_BLACK);
-    tft.drawFastVLine(310, 220, 20, ILI9341_BLACK);
-
-    int16_t xDist = 320 - 20;
-    int16_t yDist = 240 - 20;
-
-    global_config.screenCalXMult = (float)xDist / (float)(x2 - x1);
-    global_config.screenCalXOffset = 10.0 - ((float)x1 * global_config.screenCalXMult);
-
-    global_config.screenCalYMult = (float)yDist / (float)(y2 - y1);
-    global_config.screenCalYOffset = 10.0 - ((float)y1 * global_config.screenCalYMult);
-
-    global_config.screenCalibrated = true;
-    WriteGlobalConfig();
-}
-
 void screen_setBrightness(byte brightness)
 {
     // calculate duty, 4095 from 2 ^ 12 - 1
@@ -116,7 +55,7 @@ void screen_lv_touchRead(lv_indev_drv_t *indev_driver, lv_indev_data_t *data)
 {
     if (touchscreen.tirqTouched() && touchscreen.touched())
     {
-        TS_Point p = touchscreen_point();
+        TS_Point p = touchscreen.getPoint();
         data->state = LV_INDEV_STATE_PR;
         data->point.x = p.x;
         data->point.y = p.y;
@@ -128,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();
 
@@ -144,16 +83,12 @@ 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_screen_brightness();
     set_invert_display();
-
     touchscreen_spi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
     touchscreen.begin(touchscreen_spi);
 
-    touchscreen_calibrate(false);
-
     lv_disp_draw_buf_init(&draw_buf, buf, NULL, CYD_SCREEN_HEIGHT_PX * CYD_SCREEN_WIDTH_PX / 10);
 
     /*Initialize the display*/

CYD-Klipper/src/core/device/ESP32-3248S035C.cpp

@@ -1,4 +1,5 @@
 #ifdef CYD_SCREEN_DRIVER_ESP32_3248S035C
+#include "../screen_driver.h"
 
 #include "lvgl.h"
 #include <TAMC_GT911.h>
@@ -60,15 +61,21 @@ 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;
             }
             else
             {
+                #ifdef CYD_SCREEN_VERTICAL
+                    // I don't even want to know why this works...
+                    magicY = TOUCH_HEIGHT - tp.points[i].x;
+                    magicX = tp.points[i].y - 160;
+                #else
                     magicY = TOUCH_WIDTH - tp.points[i].x;
                     magicX = tp.points[i].y;
+                #endif
             }
 
             data->point.x = magicX;
@@ -79,7 +86,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])
@@ -102,24 +109,36 @@ void screen_setup()
 {
     // Initialize the touchscreen
     tp.begin();
-    tp.setRotation(ROTATION_NORMAL);
+    
     // Initialize LVGL
     lv_init();
     // Initialize the display
     tft.init();
     ledcSetup(0, 5000, 12);
     ledcAttachPin(TFT_BL, 0);
-    tft.setRotation(global_config.rotateScreen ? 3 : 1);
     tft.fillScreen(TFT_BLACK);
-    set_screen_brightness();
     set_invert_display();
     LED_init();
 
     lv_disp_draw_buf_init(&draw_buf, buf, NULL, TFT_WIDTH * TFT_HEIGHT / 10);
     static lv_disp_drv_t disp_drv;
     lv_disp_drv_init(&disp_drv);
+
+
+    #ifdef CYD_SCREEN_VERTICAL
+        disp_drv.hor_res = TFT_WIDTH;
+        disp_drv.ver_res = TFT_HEIGHT;
+        tp.setRotation(2);
+        tft.setRotation(global_config.rotate_screen ? 2 : 0);
+    #else
         disp_drv.hor_res = TFT_HEIGHT;
         disp_drv.ver_res = TFT_WIDTH;
+        
+        tft.setRotation(global_config.rotate_screen ? 3 : 1);
+        tp.setRotation(ROTATION_NORMAL);
+    #endif
+
+
     disp_drv.flush_cb = screen_lv_flush;
     disp_drv.draw_buf = &draw_buf;
     lv_disp_drv_register(&disp_drv);

CYD-Klipper/src/core/device/ESP32-smartdisplay.cpp

@@ -1,4 +1,3 @@
-
 #ifdef CYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY
 
 #include "../screen_driver.h"
@@ -7,26 +6,62 @@
 #include "lvgl.h"
 #include "../lv_setup.h"
 
-void touchscreen_calibrate(bool force)
+typedef void (*lv_disp_drv_t_flush_cb)(_lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p);
-{
+static lv_disp_drv_t_flush_cb original_screen_driver;
-    // TODO: Stubbed
-    return;
-}
 
 void screen_setBrightness(byte brightness)
 {
     smartdisplay_lcd_set_backlight(brightness / 255.0f);
 }
 
-void set_invert_display(){
+void set_invert_display()
-    // Stubbed
+{
+    lv_obj_invalidate(lv_scr_act());
 }
 
+void lv_screen_intercept(_lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p)
+{
+    if (get_current_printer_config()->invert_colors) {
+        uint32_t w = (area->x2 - area->x1 + 1);
+        uint32_t h = (area->y2 - area->y1 + 1);
+
+        for (int i = 0 ; i < w * h; i++){
+            color_p[i].full ^= 0xFFFF;
+        }
+    }
+
+    original_screen_driver(disp_drv, area, color_p);
+}
+
+
+#ifndef ROTATION_INVERTED
+    #ifdef CYD_SCREEN_VERTICAL
+        #define ROTATION_INVERTED LV_DISP_ROT_180
+    #else
+        #define ROTATION_INVERTED LV_DISP_ROT_270
+    #endif
+#endif
+
+#ifndef ROTATION_NORMAL 
+    #ifdef CYD_SCREEN_VERTICAL
+        #define ROTATION_NORMAL LV_DISP_ROT_NONE
+    #else
+        #define ROTATION_NORMAL LV_DISP_ROT_90
+    #endif
+#endif
+
 void screen_setup()
 {
     smartdisplay_init();
 
-    lv_disp_set_rotation(lv_disp_get_default(), (global_config.rotateScreen) ? LV_DISP_ROT_270 : LV_DISP_ROT_90);
+#ifndef CYD_SCREEN_DISABLE_INVERT_COLORS
+    if (original_screen_driver == NULL){
+        original_screen_driver = lv_disp_get_default()->driver->flush_cb;
+        lv_disp_get_default()->driver->flush_cb = lv_screen_intercept;
+    }
+#endif // CYD_SCREEN_DISABLE_INVERT_COLORS
+
+    lv_disp_set_rotation(lv_disp_get_default(), (global_config.rotate_screen) ? ROTATION_INVERTED : ROTATION_NORMAL);
 }
 
 #endif // CYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY

CYD-Klipper/src/core/files_query.cpp

@@ -2,9 +2,9 @@
 #include "files_query.h"
 #include "../conf/global_config.h"
 #include "data_setup.h"
-#include <HTTPClient.h>
 #include <ArduinoJson.h>
 #include <HardwareSerial.h>
+#include "http_client.h"
 
 // Always has +1 entry with a null'd name
 FILESYSTEM_FILE* last_query = NULL;
@@ -27,12 +27,8 @@ FILESYSTEM_FILE* get_files(int limit){
     std::list<FILESYSTEM_FILE> files;
 
     auto timer_request = millis();
-    char buff[256] = {};
+    SETUP_HTTP_CLIENT_FULL("/server/files/list", true, 5000);
-    sprintf(buff, "http://%s:%d/server/files/list", global_config.klipperHost, global_config.klipperPort);
+
-    HTTPClient client;
-    client.useHTTP10(true);
-    client.setTimeout(5000);
-    client.begin(buff);
     int httpCode = client.GET();
     auto timer_parse = millis();
 

CYD-Klipper/src/core/http_client.cpp

@@ -0,0 +1,29 @@
+#include "http_client.h"
+
+String get_full_url(String url_part, PRINTER_CONFIG * config)
+{
+    return "http://" + String(config->klipper_host) + ":" + String(config->klipper_port) + url_part;
+}
+
+String get_full_url(String 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)
+{
+    if (stream){
+        client.useHTTP10(true);
+    }
+
+    if (timeout > 0){
+        client.setTimeout(timeout);
+        client.setConnectTimeout(timeout);
+    }
+
+    client.begin(url);
+
+    if (get_current_printer_config()->auth_configured) {
+        client.addHeader("X-Api-Key", get_current_printer_config()->klipper_auth);
+    }
+}

CYD-Klipper/src/core/http_client.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <HTTPClient.h>
+#include "../conf/global_config.h"
+
+String get_full_url(String url_part);
+String get_full_url(String url_part, PRINTER_CONFIG * config);
+
+void configure_http_client(HTTPClient &client, String url, bool stream = true, int timeout = 1000);
+
+#define SETUP_HTTP_CLIENT(url_part) HTTPClient client; configure_http_client(client, get_full_url(url_part));
+
+#define SETUP_HTTP_CLIENT_FULL(url_part, stream, timeout) HTTPClient client; configure_http_client(client, get_full_url(url_part), stream, timeout);

CYD-Klipper/src/core/lv_setup.cpp

@@ -2,6 +2,7 @@
 #include "screen_driver.h"
 #include "../conf/global_config.h"
 #include "lvgl.h"
+#include "../ui/ui_utils.h"
 #include <Esp.h>
 
 #ifndef CPU_FREQ_HIGH
@@ -13,8 +14,158 @@
 
 typedef void (*lv_indev_drv_read_cb_t)(struct _lv_indev_drv_t * indev_drv, lv_indev_data_t * data);
 
-bool isScreenInSleep = false;
+bool is_screen_in_sleep = false;
-lv_timer_t *screenSleepTimer;
+lv_timer_t *screen_sleep_timer;
+lv_coord_t point[2] = {0};
+
+static lv_indev_drv_read_cb_t original_touch_driver = NULL;
+
+void lv_touch_intercept_calibration(lv_indev_drv_t *indev_driver, lv_indev_data_t *data) 
+{
+    original_touch_driver(indev_driver, data);
+
+    if (data->state == LV_INDEV_STATE_PR){
+        lv_coord_t local_point[] = {data->point.x, data->point.y};
+        while (data->state == LV_INDEV_STATE_PR){
+            original_touch_driver(indev_driver, data);
+            delay(20);    
+        }
+
+        point[0] = local_point[0];
+        point[1] = local_point[1];
+    }
+
+    data->state = LV_INDEV_STATE_REL;
+}
+
+void lv_touch_intercept(lv_indev_drv_t *indev_driver, lv_indev_data_t *data) 
+{
+    original_touch_driver(indev_driver, data);
+    
+    if (data->state == LV_INDEV_STATE_PR) {
+        if (is_screen_asleep()) {
+            while (data->state == LV_INDEV_STATE_PR) {
+                original_touch_driver(indev_driver, data);
+                delay(20);
+            }
+
+            data->state = LV_INDEV_STATE_REL;
+        }
+
+        screen_timer_wake();
+#ifndef CYD_SCREEN_DISABLE_TOUCH_CALIBRATION
+        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.screen_calibrated){
+        return;
+    }
+
+    lv_indev_t * display_driver = lv_indev_get_next(NULL);
+    display_driver->driver->read_cb = lv_touch_intercept_calibration;
+
+    lv_obj_clean(lv_scr_act());
+    lv_obj_clear_flag(lv_scr_act(), LV_OBJ_FLAG_SCROLLABLE);
+
+    lv_obj_t * label = lv_label_create(lv_scr_act());
+    lv_label_set_text(label, "Calibrate Screen");
+    lv_obj_align(label, LV_ALIGN_CENTER, 0, 0);
+
+    lv_obj_t * line_x = lv_line_create(lv_scr_act());
+    lv_obj_t * line_y = lv_line_create(lv_scr_act());
+
+    static lv_point_t line_points_x[] = { {0, 10}, {21, 10} };
+    static lv_point_t line_points_y[] = { {10, 0}, {10, 21} };
+
+    lv_line_set_points(line_x, line_points_x, 2);
+    lv_obj_set_style_line_width(line_x, 1, 0);
+    lv_line_set_points(line_y, line_points_y, 2);
+    lv_obj_set_style_line_width(line_y, 1, 0);
+
+#ifdef CYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY
+    lv_obj_align(line_x, LV_ALIGN_TOP_RIGHT, 1, 0);
+    lv_obj_align(line_y, LV_ALIGN_TOP_RIGHT, -10, 0);        
+#else
+    lv_obj_align(line_x, LV_ALIGN_TOP_LEFT, 0, 0);
+    lv_obj_align(line_y, LV_ALIGN_TOP_LEFT, 0, 0);
+#endif
+    
+    while (true){
+        lv_timer_handler();
+        lv_task_handler();
+
+        if (point[0] != 0 && point[1] != 0){
+            break;
+        }
+    }
+
+    delay(300);
+
+    lv_coord_t x1 = point[0];
+    lv_coord_t y1 = point[1];
+    point[0] = 0;
+    point[1] = 0;
+
+    lv_obj_del(line_x);
+    lv_obj_del(line_y);
+
+    line_x = lv_line_create(lv_scr_act());
+    line_y = lv_line_create(lv_scr_act());
+    lv_line_set_points(line_x, line_points_x, 2);
+    lv_line_set_points(line_y, line_points_y, 2);
+    lv_obj_set_style_line_width(line_x, 1, 0);
+    lv_obj_set_style_line_width(line_y, 1, 0);
+
+    
+#ifdef CYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY
+    lv_obj_align(line_x, LV_ALIGN_BOTTOM_LEFT, 0, -10);
+    lv_obj_align(line_y, LV_ALIGN_BOTTOM_LEFT, 0, 1);
+#else
+    lv_obj_align(line_x, LV_ALIGN_BOTTOM_RIGHT, 1, -10);
+    lv_obj_align(line_y, LV_ALIGN_BOTTOM_RIGHT, -10, 1);
+#endif
+
+    while (true){
+        lv_timer_handler();
+        lv_task_handler();
+
+        if (point[0] != 0 && point[1] != 0){
+            break;
+        }
+    }
+
+    lv_coord_t x2 = point[0];
+    lv_coord_t y2 = point[1];
+
+#ifdef CYD_SCREEN_DRIVER_ESP32_SMARTDISPLAY
+    int16_t xDist = CYD_SCREEN_HEIGHT_PX - 20;
+    int16_t yDist = CYD_SCREEN_WIDTH_PX - 20;
+#else
+    int16_t xDist = CYD_SCREEN_WIDTH_PX - 20;
+    int16_t yDist = CYD_SCREEN_HEIGHT_PX - 20;
+#endif
+
+    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.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.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.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.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()
 {
@@ -27,13 +178,13 @@ void set_screen_brightness()
 void screen_timer_wake()
 {
 #ifndef CYD_SCREEN_DISABLE_TIMEOUT
-    lv_timer_reset(screenSleepTimer);
+    lv_timer_reset(screen_sleep_timer);
 
-    if (!isScreenInSleep){
+    if (!is_screen_in_sleep){
         return;
     }
 
-    isScreenInSleep = false;
+    is_screen_in_sleep = false;
     set_screen_brightness();
 
     // Reset cpu freq
@@ -46,7 +197,7 @@ void screen_timer_sleep(lv_timer_t *timer)
 {
 #ifndef CYD_SCREEN_DISABLE_TIMEOUT
     screen_setBrightness(0);
-    isScreenInSleep = true;
+    is_screen_in_sleep = true;
 
     // Screen is off, no need to make the cpu run fast, the user won't notice ;)
     setCpuFrequencyMhz(CPU_FREQ_LOW);
@@ -56,85 +207,76 @@ void screen_timer_sleep(lv_timer_t *timer)
 
 void screen_timer_setup()
 {
-    screenSleepTimer = 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(screenSleepTimer);
+    lv_timer_pause(screen_sleep_timer);
 }
 
 void screen_timer_start()
 {
-    lv_timer_resume(screenSleepTimer);
+    lv_timer_resume(screen_sleep_timer);
 }
 
 void screen_timer_stop()
 {
-    lv_timer_pause(screenSleepTimer);
+    lv_timer_pause(screen_sleep_timer);
 }
 
 void screen_timer_period(unsigned int period)
 {
-    lv_timer_set_period(screenSleepTimer, period);
+    lv_timer_set_period(screen_sleep_timer, 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);
 }
 
-static lv_indev_drv_read_cb_t original_driver = NULL;
-
-void lv_touch_intercept(lv_indev_drv_t *indev_driver, lv_indev_data_t *data) 
-{
-    original_driver(indev_driver, data);
-
-    if (data->state == LV_INDEV_STATE_PR) {
-        if (is_screen_asleep()) {
-            while (data->state == LV_INDEV_STATE_PR) {
-                original_driver(indev_driver, data);
-                delay(20);
-            }
-
-            data->state = LV_INDEV_STATE_REL;
-        }
-
-        screen_timer_wake();
-    }
-}
-
 void lv_setup()
 {
-    screen_timer_setup();
+    set_screen_brightness();
-    screen_timer_start();
-    set_color_scheme();
-
-    if (original_driver != NULL)
-        return;
 
     lv_indev_t * display_driver = lv_indev_get_next(NULL);
-    original_driver = display_driver->driver->read_cb;
+
+    if (original_touch_driver == NULL) 
+    {
+        original_touch_driver = display_driver->driver->read_cb;
+    }
+
+    set_color_scheme();
+
+#ifndef CYD_SCREEN_DISABLE_TOUCH_CALIBRATION
+    lv_do_calibration();
+#endif // CYD_SCREEN_DISABLE_TOUCH_CALIBRATION
+
     display_driver->driver->read_cb = lv_touch_intercept;
+    
+    screen_timer_setup();
+    screen_timer_start();
+    lv_png_init();
 }
 
 bool is_screen_asleep()
 {
-    return isScreenInSleep;
+    return is_screen_in_sleep;
 }

CYD-Klipper/src/core/macros_query.cpp

@@ -1,24 +1,24 @@
 #include "lvgl.h"
 #include "macros_query.h"
 #include "./data_setup.h"
-#include <HTTPClient.h>
-#include "../conf/global_config.h"
 #include <ArduinoJson.h>
 #include <UrlEncode.h>
+#include "http_client.h"
 
 static char* macros[64] = {0};
 static int macros_count = 0;
 
 static char* power_devices[16] = {0};
 static bool power_device_states[16] = {0};
-static int power_devices_count = 0;
+static unsigned int stored_power_devices_count = 0;
 
-static void _macros_query_internal(){
+MACROSQUERY macros_query(PRINTER_CONFIG * config) 
-    String url = "http://" + String(global_config.klipperHost) + ":" + String(global_config.klipperPort) + "/printer/gcode/help";
+{
     HTTPClient client;
-    client.useHTTP10(true);
+    configure_http_client(client, get_full_url("/printer/gcode/help", config), true, 1000);
-    client.begin(url.c_str());
+
     int httpCode = client.GET();
+
     if (httpCode == 200){
         JsonDocument doc;
         deserializeJson(doc, client.getStream());
@@ -39,74 +39,132 @@ static void _macros_query_internal(){
                 macros[macros_count++] = macro;
             }
         }
+
+        return {(const char**)macros, (unsigned int)macros_count};
+    }
+    else {
+        return {NULL, 0};
     }
 }
 
-void _power_devices_query_internal(){
+MACROSQUERY macros_query() 
-    String url = "http://" + String(global_config.klipperHost) + ":" + String(global_config.klipperPort) + "/machine/device_power/devices";
+{
+    return macros_query(get_current_printer_config());
+}
+
+unsigned int macro_count(PRINTER_CONFIG * config) 
+{
     HTTPClient client;
-    client.useHTTP10(true);
+    configure_http_client(client, get_full_url("/printer/gcode/help", config), true, 1000);
-    client.setTimeout(500);
+
-    client.begin(url.c_str());
     int httpCode = client.GET();
+
+    if (httpCode == 200){
+        JsonDocument doc;
+        deserializeJson(doc, client.getStream());
+        auto result = doc["result"].as<JsonObject>();
+
+        unsigned int count = 0;
+
+        for (JsonPair i : result){
+            const char *value = i.value().as<String>().c_str();
+            if (strcmp(value, "CYD_SCREEN_MACRO") == 0) {
+                count++;
+            }
+        }
+
+        return count;
+    }
+    else {
+        return 0;
+    }
+}
+
+unsigned int macro_count() 
+{
+    return macro_count(get_current_printer_config());
+}
+
+POWERQUERY power_devices_query(PRINTER_CONFIG * config)
+{
+    HTTPClient client;
+    configure_http_client(client, get_full_url("/machine/device_power/devices", config), true, 1000);
+
+    int httpCode = client.GET();
+
     if (httpCode == 200){
         JsonDocument doc;
         deserializeJson(doc, client.getStream());
         auto result = doc["result"]["devices"].as<JsonArray>();
 
-        for (int i = 0; i < power_devices_count; i++){
+        for (int i = 0; i < stored_power_devices_count; i++){
             free(power_devices[i]);
         }
 
-        power_devices_count = 0;
+        stored_power_devices_count = 0;
 
         for (auto i : result){
             const char * device_name = i["device"];
             const char * device_state = i["status"];
-            power_devices[power_devices_count] = (char*)malloc(strlen(device_name) + 1);
+            power_devices[stored_power_devices_count] = (char*)malloc(strlen(device_name) + 1);
-            strcpy(power_devices[power_devices_count], device_name);
+            strcpy(power_devices[stored_power_devices_count], device_name);
-            power_device_states[power_devices_count] = strcmp(device_state, "on") == 0;
+            power_device_states[stored_power_devices_count] = strcmp(device_state, "on") == 0;
-            power_devices_count++;
+            stored_power_devices_count++;
         }
+
+        return {(const char**)power_devices, (const bool*)power_device_states, (unsigned int)stored_power_devices_count};
+    }
+    else {
+        return {NULL, NULL, 0};
     }
 }
 
-static void on_state_change(void * s, lv_msg_t * m) {
+POWERQUERY power_devices_query() 
-    if (printer.state == PRINTER_STATE_ERROR || printer.state == PRINTER_STATE_PAUSED){
+{
-        return;
+    return power_devices_query(get_current_printer_config());
-    }
-
-    _macros_query_internal();
-    _power_devices_query_internal();
 }
 
-bool set_power_state(const char* device_name, bool state) {
+unsigned int power_devices_count(PRINTER_CONFIG * config)
-    String url = "http://" + String(global_config.klipperHost) + ":" + String(global_config.klipperPort) + "/machine/device_power/device?device=" + urlEncode(device_name) + "&action=" + (state ? "on" : "off");
+{
     HTTPClient client;
-    client.useHTTP10(true);
+    configure_http_client(client, get_full_url("/machine/device_power/devices", config), true, 1000);
-    client.begin(url.c_str());
-    if (client.POST("") != 200)
-        return false;
 
-    for (int i = 0; i < power_devices_count; i++){
+    int httpCode = client.GET();
-        if (strcmp(power_devices[i], device_name) == 0){
+
-            power_device_states[i] = state;
+    if (httpCode == 200){
-            return true;
+        JsonDocument doc;
-        }
+        deserializeJson(doc, client.getStream());
+        auto result = doc["result"]["devices"].as<JsonArray>();
+
+        unsigned int count = 0;
+
+        for (auto i : result){
+            count++;
         }
 
-    return true;
+        return count;
+    }
+    else {
+        return 0;
+    }
 }
 
-MACROSQUERY macros_query() {
+unsigned int power_devices_count() 
-    return {(const char**)macros, (unsigned int)macros_count};
+{
+    return power_devices_count(get_current_printer_config());
 }
 
-POWERQUERY power_devices_query() {
+
-    return {(const char**)power_devices, (const bool*)power_device_states, (unsigned int)power_devices_count};
+
+bool set_power_state(const char* device_name, bool state, PRINTER_CONFIG * config) 
+{
+    HTTPClient client;
+    configure_http_client(client, get_full_url("/machine/device_power/device?device=" + urlEncode(device_name) + "&action=" + (state ? "on" : "off"), config), true, 1000);
+ 
+    return client.POST("") == 200;
 }
 
-void macros_query_setup(){
+bool set_power_state(const char* device_name, bool state) 
-    lv_msg_subscribe(DATA_PRINTER_STATE, on_state_change, NULL);
+{
-    on_state_change(NULL, NULL);
+    return set_power_state(device_name, state, get_current_printer_config());
 }

CYD-Klipper/src/core/macros_query.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "../conf/global_config.h"
+
 typedef struct {
     const char** macros;
     uint32_t count;
@@ -11,8 +13,13 @@ typedef struct {
     uint32_t count;
 } POWERQUERY;
 
+MACROSQUERY macros_query(PRINTER_CONFIG * config);
 MACROSQUERY macros_query();
+unsigned int macro_count(PRINTER_CONFIG * config);
+unsigned int macro_count();
+POWERQUERY power_devices_query(PRINTER_CONFIG * config);
 POWERQUERY power_devices_query();
-void macros_query_setup();
+unsigned int power_devices_count(PRINTER_CONFIG * config);
+unsigned int power_devices_count();
+bool set_power_state(const char* device_name, bool state, PRINTER_CONFIG * config);
 bool set_power_state(const char* device_name, bool state);
-void _power_devices_query_internal();

CYD-Klipper/src/core/screen_driver.h

@@ -1,7 +1,6 @@
 #pragma once
 // Adapted from https://github.com/xperiments-in/xtouch/blob/main/src/devices/2.8/screen.h
 
-void touchscreen_calibrate(bool force = false);
 void screen_setBrightness(unsigned char brightness);
 void screen_setup();
 void set_invert_display();

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");

CYD-Klipper/src/ui/gcode_img.cpp

@@ -0,0 +1,138 @@
+#include "gcode_img.h"
+#include "lvgl.h"
+#include "ui_utils.h"
+#include <Esp.h>
+#include <ArduinoJson.h>
+#include "../conf/global_config.h"
+#include "../core/http_client.h"
+
+static unsigned char * data_png = NULL;
+static char img_filename_path[256] = {0};
+static lv_img_dsc_t img_header = {0};
+
+bool has_128_128_gcode(const char* filename)
+{
+    if (filename == NULL){
+        Serial.println("No gcode filename");
+        return false;
+    }
+
+    SETUP_HTTP_CLIENT("/server/files/thumbnails?filename=" + String(filename));
+
+    int httpCode = 0;
+    try {
+        httpCode = client.GET();
+    }
+    catch (...){
+        Serial.println("Exception while fetching gcode img location");
+        return {0};
+    }
+
+    if (httpCode == 200)
+    {
+        String payload = client.getString();
+        JsonDocument doc;
+        deserializeJson(doc, payload);
+        auto result = doc["result"].as<JsonArray>();
+        const char* chosen_thumb = NULL;
+
+        for (auto file : result){
+            int width = file["width"];
+            int height = file["height"];
+            int size = file["size"];
+            const char* thumbnail = file["thumbnail_path"];
+
+            if (width != height || width != 32)
+                continue;
+
+            if (strcmp(thumbnail + strlen(thumbnail) - 4, ".png"))
+                continue;
+
+            chosen_thumb = thumbnail;
+            break;
+        }
+
+        if (chosen_thumb != NULL){
+            Serial.printf("Found 32x32 PNG gcode img at %s\n", filename);
+            strcpy(img_filename_path, chosen_thumb);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+lv_obj_t* draw_gcode_img()
+{
+    clear_img_mem();
+
+    if (img_filename_path[0] == 0){
+        Serial.println("No gcode img path");
+        return NULL;
+    }
+
+    SETUP_HTTP_CLIENT_FULL("/server/files/gcodes/" + String(img_filename_path), false, 2000);
+
+    int httpCode = 0;
+    try {
+        httpCode = client.GET();
+    }
+    catch (...){
+        Serial.println("Exception while fetching gcode img");
+        return NULL;
+    }
+
+    if (httpCode == 200)
+    {
+        size_t len = client.getSize();
+        if (len <= 0)
+        {
+            Serial.println("No gcode img data");
+            return NULL;
+        }
+
+        data_png = (unsigned char*)malloc(len + 1);
+        if (len != client.getStream().readBytes(data_png, len)){
+            Serial.println("Failed to read gcode img data");
+            clear_img_mem();
+            return NULL;
+        }
+
+        memset(&img_header, 0, sizeof(img_header));
+        img_header.header.w = 32;
+        img_header.header.h = 32;
+        img_header.data_size = len;
+        img_header.header.cf = LV_IMG_CF_RAW_ALPHA;
+        img_header.data = data_png;
+
+        lv_obj_t * img = lv_img_create(lv_scr_act());
+        lv_img_set_src(img, &img_header);
+
+        return img;
+    }
+
+    return NULL;
+}
+
+lv_obj_t* show_gcode_img(const char* filename)
+{
+    if (filename == NULL){
+        Serial.println("No gcode filename");
+        return NULL;
+    }
+
+    if (!has_128_128_gcode(filename)){
+        Serial.println("No 32x32 gcode img found");
+        return NULL;
+    }
+
+    return draw_gcode_img();
+}
+
+void clear_img_mem()
+{
+    if (data_png != NULL){
+        free(data_png);
+        data_png = NULL;
+    }
+}

CYD-Klipper/src/ui/gcode_img.h

@@ -0,0 +1,6 @@
+#pragma once
+#include "lvgl.h"
+
+lv_obj_t* show_gcode_img(const char* filename);
+bool has_128_128_gcode(const char* filename);
+void clear_img_mem();

CYD-Klipper/src/ui/ip_setup.cpp

@@ -6,8 +6,12 @@
 #include "ui_utils.h"
 #include "../core/macros_query.h"
 #include "panels/panel.h"
+#include "../core/http_client.h"
+#include "switch_printer.h"
+#include "macros.h"
 
 bool connect_ok = false;
+int prev_power_device_count = 0;
 lv_obj_t * hostEntry;
 lv_obj_t * portEntry;
 lv_obj_t * label = NULL;
@@ -29,20 +33,27 @@ static const lv_btnmatrix_ctrl_t kb_ctrl[] = {
 
 void ip_init_inner();
 
-bool verify_ip(){
+enum connection_status_t {
-    HTTPClient client;
+    CONNECT_FAIL = 0,
-    String url = "http://" + String(global_config.klipperHost) + ":" + String(global_config.klipperPort) + "/printer/info";
+    CONNECT_OK = 1,
+    CONNECT_AUTH_REQUIRED = 2,
+};
+
+connection_status_t verify_ip(){
+    SETUP_HTTP_CLIENT_FULL("/printer/info", true, 1000);
+
     int httpCode;
     try {
-        Serial.println(url);
-        client.setTimeout(500);
-        client.begin(url.c_str());
         httpCode = client.GET();
-        return httpCode == 200;
+
+        if (httpCode == 401)
+            return CONNECT_AUTH_REQUIRED;
+
+        return httpCode == 200 ? CONNECT_OK : CONNECT_FAIL;
     }
     catch (...) {
         Serial.println("Failed to connect");
-        return false;
+        return CONNECT_FAIL;
     }
 }
 
@@ -61,15 +72,22 @@ static void ta_event_cb(lv_event_t * e) {
     }
     else if (code == LV_EVENT_READY) 
     {
-        strcpy(global_config.klipperHost, lv_textarea_get_text(hostEntry));
+        strcpy(get_current_printer_config()->klipper_host, lv_textarea_get_text(hostEntry));
-        global_config.klipperPort = atoi(lv_textarea_get_text(portEntry));
+        get_current_printer_config()->klipper_port = atoi(lv_textarea_get_text(portEntry));
 
-        if (verify_ip())
+        connection_status_t status = verify_ip();
+        if (status == CONNECT_OK)
         {
-            global_config.ipConfigured = true;
+            get_current_printer_config()->ip_configured = true;
-            WriteGlobalConfig();
+            write_global_config();
             connect_ok = true;
         }
+        else if (status == CONNECT_AUTH_REQUIRED)
+        {
+            label = NULL;
+            get_current_printer_config()->ip_configured = true;
+            write_global_config();
+        }
         else
         {
             lv_label_set_text(label, "Failed to connect");
@@ -94,27 +112,13 @@ 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();
     }
 }
 
 static void power_devices_button(lv_event_t * e) {
-    lv_obj_t * panel = lv_create_empty_panel(lv_scr_act());
+    macros_draw_power_fullscreen();
-    lv_obj_set_style_bg_opa(panel, LV_OPA_COVER, 0); 
-    lv_layout_flex_column(panel);
-    lv_obj_set_size(panel, CYD_SCREEN_WIDTH_PX, CYD_SCREEN_HEIGHT_PX - CYD_SCREEN_GAP_PX);
-    lv_obj_align(panel, LV_ALIGN_TOP_LEFT, 0, CYD_SCREEN_GAP_PX);
-
-    lv_obj_t * button = lv_btn_create(panel);
-    lv_obj_set_size(button, CYD_SCREEN_WIDTH_PX - CYD_SCREEN_GAP_PX * 2, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
-    lv_obj_add_event_cb(button, destroy_event_user_data, LV_EVENT_CLICKED, panel);
-
-    lv_obj_t * label = lv_label_create(button);
-    lv_label_set_text(label, LV_SYMBOL_CLOSE " Close");
-    lv_obj_center(label);
-
-    macros_panel_add_power_devices_to_panel(panel, power_devices_query()); 
 }
 
 void redraw_connect_screen(){
@@ -137,7 +141,7 @@ void redraw_connect_screen(){
     lv_label_set_text(btn_label, "Reset");
     lv_obj_center(btn_label);
 
-    if (power_devices_query().count >= 1){
+    if (prev_power_device_count >= 1){
         lv_obj_t * power_devices_btn = lv_btn_create(button_row);
         lv_obj_add_event_cb(power_devices_btn, power_devices_button, LV_EVENT_CLICKED, NULL);
         lv_obj_set_height(power_devices_btn, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
@@ -146,10 +150,83 @@ void redraw_connect_screen(){
         lv_label_set_text(btn_label, "Power Devices");
         lv_obj_center(btn_label);
     }
+
+    draw_switch_printer_button();    
+}
+
+static bool auth_entry_done = false;
+
+static void keyboard_event_auth_entry(lv_event_t * e) {
+    lv_event_code_t code = lv_event_get_code(e);
+    lv_obj_t * ta = lv_event_get_target(e);
+    lv_obj_t * kb = (lv_obj_t *)lv_event_get_user_data(e);
+
+    if (code == LV_EVENT_READY) 
+    {
+        const char * txt = lv_textarea_get_text(ta);
+        int len = strlen(txt);
+        if (len > 0)
+        {
+            get_current_printer_config()->auth_configured = true;
+            strcpy(get_current_printer_config()->klipper_auth, txt);
+            write_global_config();
+            auth_entry_done = true;
+        }
+    }
+    else if (code == LV_EVENT_CANCEL)
+    {
+        auth_entry_done = true;
+    }
+}
+
+void handle_auth_entry(){
+    auth_entry_done = false;
+    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());
+    lv_obj_set_size(root, CYD_SCREEN_WIDTH_PX, CYD_SCREEN_HEIGHT_PX);
+    lv_layout_flex_column(root);
+
+    lv_obj_t * top_root = lv_create_empty_panel(root);
+    lv_obj_set_width(top_root, CYD_SCREEN_WIDTH_PX);
+    lv_layout_flex_column(top_root);
+    lv_obj_set_flex_grow(top_root, 1);
+    lv_obj_set_style_pad_all(top_root, CYD_SCREEN_GAP_PX, 0);
+
+    lv_obj_t * label = lv_label_create(top_root);
+    lv_label_set_text(label, "Enter API Key");
+    lv_obj_set_width(label, CYD_SCREEN_WIDTH_PX - CYD_SCREEN_GAP_PX * 2);
+
+    lv_obj_t * keyboard = lv_keyboard_create(root);
+    lv_obj_t * passEntry = lv_textarea_create(top_root);
+    lv_textarea_set_max_length(passEntry, 32);
+    lv_textarea_set_one_line(passEntry, true);
+
+    if (get_current_printer_config()->auth_configured)
+        lv_textarea_set_text(passEntry, get_current_printer_config()->klipper_auth);
+    else
+        lv_textarea_set_text(passEntry, "");
+
+    lv_obj_set_width(passEntry, CYD_SCREEN_WIDTH_PX - CYD_SCREEN_GAP_PX * 2);
+    lv_obj_add_event_cb(passEntry, keyboard_event_auth_entry, LV_EVENT_ALL, keyboard);
+    lv_obj_set_flex_grow(passEntry, 1);
+    
+
+    lv_keyboard_set_textarea(keyboard, passEntry);
+    lv_keyboard_set_map(keyboard, LV_KEYBOARD_MODE_USER_1, kb_map, kb_ctrl);
+    lv_keyboard_set_mode(keyboard, LV_KEYBOARD_MODE_USER_1);
+
+    while (!auth_entry_done) {
+        lv_timer_handler();
+        lv_task_handler();
+    }
+
+    redraw_connect_screen();
 }
 
 void ip_init_inner(){
-    if (global_config.ipConfigured) {
+    if (get_current_printer_config()->ip_configured) {
         redraw_connect_screen();
         return;
     }
@@ -203,6 +280,7 @@ int retry_count = 0;
 void ip_init(){
     connect_ok = false;
     retry_count = 0;
+    prev_power_device_count = 0;
 
     ip_init_inner();
 
@@ -211,18 +289,27 @@ 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){
-            connect_ok = verify_ip();
+            connection_status_t status = verify_ip();
+
+            connect_ok = status == CONNECT_OK;
             last_data_update_ip = millis();
             retry_count++;
+            if (label != NULL){
                 String retry_count_text = "Connecting to Klipper (Try " + String(retry_count + 1) + ")";
                 lv_label_set_text(label, retry_count_text.c_str());
+            }
 
-            _power_devices_query_internal();
+            if (status == CONNECT_AUTH_REQUIRED)
-            if (power_devices_query().count >= 1)
+                handle_auth_entry();
+
+            unsigned int power_device_count = power_devices_count();
+            if (power_device_count != prev_power_device_count) {
+                prev_power_device_count = power_device_count;
                 redraw_connect_screen();
             }
         }
+    }
 }
 
 void ip_ok(){

CYD-Klipper/src/ui/macros.cpp

@@ -0,0 +1,77 @@
+#include "macros.h"
+#include "ui_utils.h"
+#include <Esp.h>
+#include "../core/data_setup.h"
+
+PRINTER_CONFIG * curernt_config = NULL;
+
+static void btn_press(lv_event_t * e){
+    lv_obj_t * btn = lv_event_get_target(e);
+    const char* macro = (const char*)lv_event_get_user_data(e);
+    Serial.printf("Macro: %s\n", macro);
+    send_gcode(false, macro);
+}
+
+void macros_add_macros_to_panel(lv_obj_t * root_panel, MACROSQUERY query)
+{
+    for (int i = 0; i < query.count; i++){
+        const char* macro = query.macros[i];
+        lv_create_custom_menu_button(macro, root_panel, btn_press, "Run", (void*)macro);
+    }
+}
+
+static void power_device_toggle(lv_event_t * e)
+{
+    auto state = lv_obj_get_state(lv_event_get_target(e));
+    bool checked = (state & LV_STATE_CHECKED == LV_STATE_CHECKED);
+    const char* power_device_name = (const char*)lv_event_get_user_data(e);
+    Serial.printf("Power Device: %s, State: %d -> %d\n", power_device_name, !checked, checked);
+
+    if (curernt_config != NULL)
+        set_power_state(power_device_name, checked, curernt_config);
+}
+
+void macros_add_power_devices_to_panel(lv_obj_t * root_panel, POWERQUERY query)
+{
+    for (int i = 0; i < query.count; i++){
+        const char* power_device_name = query.power_devices[i];
+        const bool power_device_state = query.power_states[i];
+        lv_create_custom_menu_switch(power_device_name, root_panel, power_device_toggle, power_device_state, (void*)power_device_name);
+    }
+}
+
+void macros_set_current_config(PRINTER_CONFIG * config)
+{
+    curernt_config = config;
+}
+
+void macros_draw_power_fullscreen(PRINTER_CONFIG * config)
+{
+    macros_set_current_config(config);
+
+    lv_obj_t * parent = lv_create_empty_panel(lv_scr_act());
+    lv_obj_set_style_bg_opa(parent, LV_OPA_100, 0); 
+    lv_obj_align(parent, LV_ALIGN_TOP_RIGHT, 0, 0);
+    lv_obj_set_size(parent, CYD_SCREEN_WIDTH_PX, CYD_SCREEN_HEIGHT_PX);
+    lv_layout_flex_column(parent);
+
+    lv_obj_set_size(lv_create_empty_panel(parent), 0, 0);
+
+    auto width = CYD_SCREEN_WIDTH_PX - CYD_SCREEN_GAP_PX * 2;
+
+    lv_obj_t * btn = lv_btn_create(parent);
+    lv_obj_set_size(btn, width, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
+    lv_obj_add_event_cb(btn, destroy_event_user_data, LV_EVENT_CLICKED, parent);
+
+    lv_obj_t * label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_CLOSE " Close");
+    lv_obj_center(label);
+
+    POWERQUERY power = power_devices_query(config);
+    macros_add_power_devices_to_panel(parent, power);
+}
+
+void macros_draw_power_fullscreen()
+{
+    macros_draw_power_fullscreen(get_current_printer_config());
+}

CYD-Klipper/src/ui/macros.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "lvgl.h"
+#include "../core/macros_query.h"
+
+void macros_add_macros_to_panel(lv_obj_t * root_panel, MACROSQUERY query);
+void macros_add_power_devices_to_panel(lv_obj_t * root_panel, POWERQUERY query);
+void macros_set_current_config(PRINTER_CONFIG * config);
+void macros_draw_power_fullscreen(PRINTER_CONFIG * config);
+void macros_draw_power_fullscreen();

CYD-Klipper/src/ui/main_ui.cpp

@@ -8,92 +8,11 @@
 #include "panels/panel.h"
 #include "../core/macros_query.h"
 #include "../core/lv_setup.h"
-
+#include "switch_printer.h"
-char extruder_temp_buff[20];
+#include "macros.h"
-char bed_temp_buff[20];
-char position_buff[20];
-
-static void btn_click_restart(lv_event_t * e){
-    send_gcode(false, "RESTART");
-}
-
-static void btn_click_firmware_restart(lv_event_t * e){
-    send_gcode(false, "FIRMWARE_RESTART");
-}
-
-void error_ui_macros_open(lv_event_t * e){
-    lv_obj_t * panel = lv_create_empty_panel(lv_scr_act());
-    lv_obj_set_style_bg_opa(panel, LV_OPA_COVER, 0); 
-    lv_layout_flex_column(panel);
-    lv_obj_set_size(panel, CYD_SCREEN_WIDTH_PX, CYD_SCREEN_HEIGHT_PX - CYD_SCREEN_GAP_PX);
-    lv_obj_align(panel, LV_ALIGN_TOP_LEFT, 0, CYD_SCREEN_GAP_PX);
-
-    lv_obj_t * button = lv_btn_create(panel);
-    lv_obj_set_size(button, CYD_SCREEN_WIDTH_PX - CYD_SCREEN_GAP_PX * 2, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
-    lv_obj_add_event_cb(button, destroy_event_user_data, LV_EVENT_CLICKED, panel);
-
-    lv_obj_t * label = lv_label_create(button);
-    lv_label_set_text(label, LV_SYMBOL_CLOSE " Close");
-    lv_obj_center(label);
-
-    macros_panel_add_power_devices_to_panel(panel, power_devices_query());
-}
-
-void error_ui(){
-    lv_obj_clean(lv_scr_act());
-
-    lv_obj_t * panel = lv_create_empty_panel(lv_scr_act());
-    lv_layout_flex_column(panel);
-    lv_obj_set_size(panel, CYD_SCREEN_WIDTH_PX, CYD_SCREEN_HEIGHT_PX);
-    lv_obj_set_style_pad_all(panel, CYD_SCREEN_GAP_PX, 0);
-    lv_obj_set_flex_align(panel, LV_FLEX_ALIGN_SPACE_BETWEEN, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
-    
-    lv_obj_t * label;
-    label = lv_label_create(panel);
-    lv_label_set_text(label, LV_SYMBOL_WARNING " Printer is not ready");
-
-    label = lv_label_create(panel);
-    lv_label_set_text(label, printer.state_message);
-    lv_obj_set_width(label, CYD_SCREEN_WIDTH_PX - CYD_SCREEN_GAP_PX * 2);
-    lv_obj_clear_flag(label, LV_OBJ_FLAG_SCROLLABLE);
-    lv_label_set_long_mode(label, LV_LABEL_LONG_WRAP);
-
-    lv_obj_t * button_row = lv_create_empty_panel(panel);
-    lv_obj_set_size(button_row, CYD_SCREEN_WIDTH_PX - CYD_SCREEN_GAP_PX * 2, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
-    lv_layout_flex_row(button_row);
-
-    lv_obj_t * btn = lv_btn_create(button_row);
-    lv_obj_set_height(btn, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
-    lv_obj_add_event_cb(btn, btn_click_restart, LV_EVENT_CLICKED, NULL);
-    lv_obj_set_flex_grow(btn, 1);
-
-    label = lv_label_create(btn);
-    lv_label_set_text(label, "Restart");
-    lv_obj_center(label);
-
-    btn = lv_btn_create(button_row);
-    lv_obj_set_height(btn, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
-    lv_obj_add_event_cb(btn, btn_click_firmware_restart, LV_EVENT_CLICKED, NULL);
-    lv_obj_set_flex_grow(btn, 1);
-
-    label = lv_label_create(btn);
-    lv_label_set_text(label, "FW Restart");
-    lv_obj_center(label);
-
-    if (power_devices_query().count >= 1){
-        btn = lv_btn_create(button_row);
-        lv_obj_set_height(btn, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
-        lv_obj_add_event_cb(btn, error_ui_macros_open, LV_EVENT_CLICKED, NULL);
-        lv_obj_set_flex_grow(btn, 1);
-
-        label = lv_label_create(btn);
-        lv_label_set_text(label, "Devices");
-        lv_obj_center(label);
-    }
-}
 
 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();
     }
@@ -106,10 +25,10 @@ static void on_state_change(void * s, lv_msg_t * m){
     check_if_screen_needs_to_be_disabled();
     
     if (printer.state == PRINTER_STATE_ERROR){
-        error_ui();
+        nav_buttons_setup(PANEL_ERROR);
     }
     else {
-        nav_buttons_setup(0);
+        nav_buttons_setup(PANEL_PRINT);
     }
 }
 

CYD-Klipper/src/ui/nav_buttons.cpp

@@ -2,8 +2,9 @@
 #include "panels/panel.h"
 #include "../core/data_setup.h"
 #include "nav_buttons.h"
-#include <HTTPClient.h>
 #include "ui_utils.h"
+#include <stdio.h>
+#include "../conf/global_config.h"
 
 static lv_style_t nav_button_style;
 
@@ -57,29 +58,43 @@ static void update_printer_data_time(lv_event_t * e){
 }
 
 static void btn_click_files(lv_event_t * e){
-    nav_buttons_setup(0);
+    nav_buttons_setup(PANEL_PRINT);
 }
 
 static void btn_click_move(lv_event_t * e){
-    nav_buttons_setup(1);
+    nav_buttons_setup(PANEL_MOVE);
 }
 
 static void btn_click_extrude(lv_event_t * e){
-    nav_buttons_setup(2);
+    nav_buttons_setup(PANEL_TEMP);
 }
 
 static void btn_click_settings(lv_event_t * e){
-    nav_buttons_setup(3);
+    nav_buttons_setup(PANEL_SETTINGS);
 }
 
 static void btn_click_macros(lv_event_t * e){
-    nav_buttons_setup(4);
+    nav_buttons_setup(PANEL_MACROS);
+}
+
+static void btn_click_printer(lv_event_t * e){
+    nav_buttons_setup(PANEL_PRINTER);
+}
+
+static void btn_click_err(lv_event_t * e){
+    nav_buttons_setup(PANEL_ERROR);
 }
 
 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);
+
+#ifdef CYD_SCREEN_VERTICAL
+    lv_obj_set_height(btn, CYD_SCREEN_SIDEBAR_SIZE_PX);
+#else
     lv_obj_set_width(btn, CYD_SCREEN_SIDEBAR_SIZE_PX);
+#endif
+
     lv_obj_add_style(btn, &nav_button_style, 0);
     if (button_click != NULL)
         lv_obj_add_event_cb(btn, button_click, LV_EVENT_CLICKED, NULL);
@@ -101,10 +116,19 @@ void nav_buttons_setup(unsigned char active_panel){
     lv_obj_clear_flag(lv_scr_act(), LV_OBJ_FLAG_SCROLLABLE);
 
     lv_obj_t * root_panel = lv_create_empty_panel(lv_scr_act());
+
+#ifdef CYD_SCREEN_VERTICAL
+    lv_obj_set_size(root_panel, CYD_SCREEN_WIDTH_PX, CYD_SCREEN_SIDEBAR_SIZE_PX); 
+    lv_obj_align(root_panel, LV_ALIGN_BOTTOM_LEFT, 0, 0);
+    lv_layout_flex_row(root_panel, LV_FLEX_ALIGN_START, 0, 0);
+#else
     lv_obj_set_size(root_panel, CYD_SCREEN_SIDEBAR_SIZE_PX, CYD_SCREEN_HEIGHT_PX); 
     lv_obj_align(root_panel, LV_ALIGN_TOP_LEFT, 0, 0);
     lv_layout_flex_column(root_panel, LV_FLEX_ALIGN_START, 0, 0);
 
+#endif
+
+    if (printer.state != PRINTER_STATE_ERROR){
         // Files/Print
         create_button(LV_SYMBOL_COPY, "Idle", btn_click_files, update_printer_data_time, root_panel);
 
@@ -113,30 +137,50 @@ void nav_buttons_setup(unsigned char active_panel){
 
         // Extrude/Temp
         create_button(LV_SYMBOL_WARNING, "?/?", btn_click_extrude, update_printer_data_temp, root_panel);
+    }
+    else {
+        // Error UI
+        create_button(LV_SYMBOL_WARNING, "Error", btn_click_err, NULL, root_panel);
+    }
 
     // Macros
     create_button(LV_SYMBOL_GPS, "Macro", btn_click_macros, NULL, root_panel);
 
+    if (global_config.multi_printer_mode)
+    {
+        // Printers
+        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_HEIGHT_PX);
+    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);
 
     switch (active_panel){
-        case 0:
+        case PANEL_PRINT:
             print_panel_init(panel);
             break;
-        case 1:
+        case PANEL_MOVE:
             move_panel_init(panel);
             break;
-        case 2:
+        case PANEL_TEMP:
             temp_panel_init(panel);
             break;
-        case 3:
+        case PANEL_SETTINGS:
             settings_panel_init(panel);
             break;
-        case 4:
+        case PANEL_MACROS:
             macros_panel_init(panel);
             break;
+        case PANEL_STATS:
+            stats_panel_init(panel);
+            break;
+        case PANEL_PRINTER:
+            printer_panel_init(panel);
+            break;
+        case PANEL_ERROR:
+            error_panel_init(panel);
+            break;
     }
 
     lv_msg_send(DATA_PRINTER_DATA, &printer);

CYD-Klipper/src/ui/nav_buttons.h

@@ -1,2 +1,13 @@
+#pragma once
+
+#define PANEL_PRINT 0
+#define PANEL_MOVE 1
+#define PANEL_TEMP 2
+#define PANEL_SETTINGS 3
+#define PANEL_MACROS 4
+#define PANEL_STATS 5
+#define PANEL_PRINTER 6
+#define PANEL_ERROR 7
+
 void nav_buttons_setup(unsigned char active_panel);
 void nav_style_setup();

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);
     }

CYD-Klipper/src/ui/panels/error_panel.cpp

@@ -0,0 +1,53 @@
+#include "panel.h"
+#include "../../core/data_setup.h"
+#include "../ui_utils.h"
+
+static void btn_click_restart(lv_event_t * e){
+    send_gcode(false, "RESTART");
+}
+
+static void btn_click_firmware_restart(lv_event_t * e){
+    send_gcode(false, "FIRMWARE_RESTART");
+}
+
+void error_panel_init(lv_obj_t* panel) 
+{
+    lv_layout_flex_column(panel, LV_FLEX_ALIGN_SPACE_BETWEEN);
+    lv_obj_set_style_pad_all(panel, CYD_SCREEN_GAP_PX, 0);
+
+    lv_obj_t * label;
+    label = lv_label_create(panel);
+    lv_label_set_text(label, LV_SYMBOL_WARNING " Printer is not ready");
+
+    lv_obj_t * panel_with_text = lv_create_empty_panel(panel);
+    lv_layout_flex_column(panel_with_text, LV_FLEX_ALIGN_START);
+    lv_obj_set_flex_grow(panel_with_text, 1);
+    lv_obj_set_width(panel_with_text, CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2);
+
+    label = lv_label_create(panel_with_text);
+    lv_label_set_text(label, printer.state_message);
+    lv_obj_set_width(label, CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2);
+    lv_label_set_long_mode(label, LV_LABEL_LONG_WRAP);
+
+    lv_obj_t * button_row = lv_create_empty_panel(panel);
+    lv_obj_set_size(button_row, CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
+    lv_layout_flex_row(button_row);
+
+    lv_obj_t * btn = lv_btn_create(button_row);
+    lv_obj_set_height(btn, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
+    lv_obj_add_event_cb(btn, btn_click_restart, LV_EVENT_CLICKED, NULL);
+    lv_obj_set_flex_grow(btn, 1);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, "Restart");
+    lv_obj_center(label);
+
+    btn = lv_btn_create(button_row);
+    lv_obj_set_height(btn, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
+    lv_obj_add_event_cb(btn, btn_click_firmware_restart, LV_EVENT_CLICKED, NULL);
+    lv_obj_set_flex_grow(btn, 1);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, "FW Restart");
+    lv_obj_center(label);
+}

CYD-Klipper/src/ui/panels/macros_panel.cpp

@@ -1,90 +1,18 @@
-#include "lvgl.h"
+#include "../macros.h"
 #include "panel.h"
 #include "../nav_buttons.h"
 #include "../../core/data_setup.h"
-#include "../../core/macros_query.h"
 #include "../../conf/global_config.h"
 #include "../ui_utils.h"
 #include <HardwareSerial.h>
 
-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 btn_press(lv_event_t * e){
-    lv_obj_t * btn = lv_event_get_target(e);
-    const char* macro = (const char*)lv_event_get_user_data(e);
-    Serial.printf("Macro: %s\n", macro);
-    send_gcode(false, macro);
-}
-
 static void btn_goto_settings(lv_event_t * e){
-    nav_buttons_setup(3);
+    nav_buttons_setup(PANEL_SETTINGS);
-}
-
-void macros_panel_add_macros_to_panel(lv_obj_t * root_panel, MACROSQUERY query){
-    for (int i = 0; i < query.count; i++){
-        const char* macro = query.macros[i];
-        
-        lv_obj_t * panel = lv_create_empty_panel(root_panel);
-        lv_layout_flex_row(panel, LV_FLEX_ALIGN_END);
-        lv_obj_set_size(panel, CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 3, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
-
-        lv_obj_t * label = lv_label_create(panel);
-        lv_label_set_text(label, macro);
-        lv_label_set_long_mode(label, LV_LABEL_LONG_SCROLL_CIRCULAR);
-        lv_obj_set_flex_grow(label, 1);
-
-        lv_obj_t * btn = lv_btn_create(panel);
-        lv_obj_add_event_cb(btn, btn_press, LV_EVENT_CLICKED, (void*)macro);
-        lv_obj_set_height(btn, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
-
-        label = lv_label_create(btn);
-        lv_label_set_text(label, "Run");
-        lv_obj_center(label);
-
-        lv_obj_t * line = lv_line_create(root_panel);
-        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);
-    }
-}
-
-static void power_device_toggle(lv_event_t * e){
-    auto state = lv_obj_get_state(lv_event_get_target(e));
-    bool checked = (state & LV_STATE_CHECKED == LV_STATE_CHECKED);
-    const char* power_device_name = (const char*)lv_event_get_user_data(e);
-    Serial.printf("Power Device: %s, State: %d -> %d\n", power_device_name, !checked, checked);
-
-    set_power_state(power_device_name, checked);
-}
-
-void macros_panel_add_power_devices_to_panel(lv_obj_t * root_panel, POWERQUERY query){
-    for (int i = 0; i < query.count; i++){
-        const char* power_device_name = query.power_devices[i];
-        const bool power_device_state = query.power_states[i];
-        
-        lv_obj_t * panel = lv_create_empty_panel(root_panel);
-        lv_layout_flex_row(panel, LV_FLEX_ALIGN_END);
-        lv_obj_set_size(panel, CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 3, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
-
-        lv_obj_t * label = lv_label_create(panel);
-        lv_label_set_text(label, power_device_name);
-        lv_label_set_long_mode(label, LV_LABEL_LONG_SCROLL_CIRCULAR);
-        lv_obj_set_flex_grow(label, 1);
-
-        lv_obj_t * toggle = lv_switch_create(panel);
-        lv_obj_add_event_cb(toggle, power_device_toggle, LV_EVENT_VALUE_CHANGED, (void*)power_device_name);
-        lv_obj_set_size(toggle, CYD_SCREEN_MIN_BUTTON_WIDTH_PX * 2, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
-        if (power_device_state)
-            lv_obj_add_state(toggle, LV_STATE_CHECKED);
-
-        lv_obj_t * line = lv_line_create(root_panel);
-        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 macros_panel_init(lv_obj_t* panel) {
+    macros_set_current_config(get_current_printer_config());
+
     lv_obj_t * btn = lv_btn_create(panel);
     lv_obj_add_event_cb(btn, btn_goto_settings, LV_EVENT_CLICKED, NULL);
     lv_obj_set_size(btn, CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
@@ -104,10 +32,11 @@ void macros_panel_init(lv_obj_t* panel) {
     }
 
     lv_obj_t * root_panel = lv_create_empty_panel(panel);
-    lv_obj_set_size(root_panel, CYD_SCREEN_PANEL_WIDTH_PX, CYD_SCREEN_HEIGHT_PX - CYD_SCREEN_MIN_BUTTON_HEIGHT_PX - CYD_SCREEN_GAP_PX * 2); 
+    lv_obj_set_scrollbar_mode(root_panel, LV_SCROLLBAR_MODE_OFF);
+    lv_obj_set_size(root_panel, CYD_SCREEN_PANEL_WIDTH_PX, CYD_SCREEN_PANEL_HEIGHT_PX - CYD_SCREEN_MIN_BUTTON_HEIGHT_PX - CYD_SCREEN_GAP_PX * 2); 
     lv_obj_align(root_panel, LV_ALIGN_TOP_MID, 0, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX + CYD_SCREEN_GAP_PX * 2);
     lv_layout_flex_column(root_panel);
 
-    macros_panel_add_power_devices_to_panel(root_panel, power);
+    macros_add_power_devices_to_panel(root_panel, power);
-    macros_panel_add_macros_to_panel(root_panel, query);
+    macros_add_macros_to_panel(root_panel, query);
 }

CYD-Klipper/src/ui/panels/move_panel.cpp

@@ -1,48 +1,28 @@
 #include "lvgl.h"
 #include "panel.h"
 #include "../../core/data_setup.h"
+#include "../nav_buttons.h"
 #include "../ui_utils.h"
 #include <stdio.h>
 
 static bool last_homing_state = false;
 
-static void move_printer(const char* axis, float amount) {
-    if (!printer.homed_axis || printer.state == PRINTER_STATE_PRINTING)
-        return;
-
-    char gcode[64];
-    const char* extra = (amount > 0) ? "+" : "";
-
-    bool absolute_coords = printer.absolute_coords;
-
-    if (absolute_coords) {
-        send_gcode(true, "G91");
-    }
-
-    sprintf(gcode, "G1 %s%s%.1f F6000", axis, extra, amount);
-    send_gcode(true, gcode);
-
-    if (absolute_coords) {
-        send_gcode(true, "G90");
-    }
-}
-
 static void x_line_button_press(lv_event_t * e) {
     float* data_pointer = (float*)lv_event_get_user_data(e);
     float data = *data_pointer;
-    move_printer("X", data);
+    move_printer("X", data, true);
 }
 
 static void y_line_button_press(lv_event_t * e) {
     float* data_pointer = (float*)lv_event_get_user_data(e);
     float data = *data_pointer;
-    move_printer("Y", data);
+    move_printer("Y", data, true);
 }
 
 static void z_line_button_press(lv_event_t * e) {
     float* data_pointer = (float*)lv_event_get_user_data(e);
     float data = *data_pointer;
-    move_printer("Z", data);
+    move_printer("Z", data, true);
 }
 
 char x_pos_buff[12];
@@ -103,11 +83,16 @@ static void disable_steppers_click(lv_event_t * e) {
     send_gcode(true, "M18");
 } 
 
+static void switch_to_stat_panel(lv_event_t * e) {
+    lv_obj_t * panel = lv_event_get_target(e);
+    nav_buttons_setup(PANEL_STATS);
+}
+
 inline void root_panel_steppers_locked(lv_obj_t * root_panel){
     const auto width = CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2;
 
     lv_obj_t * panel = lv_create_empty_panel(root_panel);
-    lv_obj_set_size(panel, CYD_SCREEN_PANEL_WIDTH_PX, CYD_SCREEN_HEIGHT_PX);
+    lv_obj_set_size(panel, CYD_SCREEN_PANEL_WIDTH_PX, CYD_SCREEN_PANEL_HEIGHT_PX);
     lv_obj_set_style_pad_all(panel, CYD_SCREEN_GAP_PX, 0);
     lv_layout_flex_column(panel, LV_FLEX_ALIGN_SPACE_BETWEEN, 0, 0);
 
@@ -121,7 +106,7 @@ inline void root_panel_steppers_locked(lv_obj_t * root_panel){
     lv_obj_set_flex_grow(btn, 1);
 
     lv_obj_t * label = lv_label_create(btn);
-    lv_label_set_text(label, LV_SYMBOL_HOME "Home Axis");
+    lv_label_set_text(label, LV_SYMBOL_HOME "Home");
     lv_obj_center(label);
 
     btn = lv_btn_create(home_button_row);
@@ -130,7 +115,16 @@ inline void root_panel_steppers_locked(lv_obj_t * root_panel){
     lv_obj_set_flex_grow(btn, 1);
 
     label = lv_label_create(btn);
-    lv_label_set_text(label, LV_SYMBOL_EYE_CLOSE " Disable Step");
+    lv_label_set_text(label, LV_SYMBOL_EYE_CLOSE " Unlock");
+    lv_obj_center(label);
+
+    btn = lv_btn_create(home_button_row);
+    lv_obj_set_height(btn, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
+    lv_obj_add_event_cb(btn, switch_to_stat_panel, LV_EVENT_CLICKED, NULL);
+    lv_obj_set_flex_grow(btn, 1);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_EDIT " Params");
     lv_obj_center(label);
 
     for (int row = 0; row < 3; row++) {
@@ -161,7 +155,7 @@ inline void root_panel_steppers_locked(lv_obj_t * root_panel){
 
 inline void root_panel_steppers_unlocked(lv_obj_t * root_panel){
     lv_obj_t * panel = lv_create_empty_panel(root_panel);
-    lv_obj_set_size(panel, CYD_SCREEN_PANEL_WIDTH_PX, CYD_SCREEN_HEIGHT_PX);
+    lv_obj_set_size(panel, CYD_SCREEN_PANEL_WIDTH_PX, CYD_SCREEN_PANEL_HEIGHT_PX);
     lv_obj_set_style_pad_all(panel, CYD_SCREEN_GAP_PX, 0);
     lv_layout_flex_column(panel, LV_FLEX_ALIGN_CENTER);
 

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 macros_panel_add_power_devices_to_panel(lv_obj_t * panel, POWERQUERY query);
+void printer_panel_init(lv_obj_t* panel);
+void error_panel_init(lv_obj_t* panel);

CYD-Klipper/src/ui/panels/print_panel.cpp

@@ -4,9 +4,11 @@
 #include "../../core/files_query.h"
 #include "../../conf/global_config.h"
 #include <HardwareSerial.h>
-#include <HTTPClient.h>
 #include "../ui_utils.h"
 #include "../../core/lv_setup.h"
+#include "../gcode_img.h"
+#include "../../core/http_client.h"
+#include <UrlEncode.h>
 
 FILESYSTEM_FILE* selected_file = NULL;
 
@@ -14,29 +16,8 @@ static void btn_print_file(lv_event_t * e){
     lv_obj_t * panel = (lv_obj_t*)lv_event_get_user_data(e);
     lv_obj_del(panel);
 
-    char* buff = (char*)malloc(128 + (strlen(selected_file->name) * 3));
+    SETUP_HTTP_CLIENT("/printer/print/start?filename=" + urlEncode(selected_file->name));
-    sprintf(buff, "http://%s:%d/printer/print/start?filename=", global_config.klipperHost, global_config.klipperPort);
 
-    char* ptr = buff + strlen(buff);
-    int filename_length = strlen(selected_file->name);
-    for (int i = 0; i < filename_length; i++){
-        char c = selected_file->name[i];
-        if (c == ' '){
-            *ptr = '%';
-            ptr++;
-            *ptr = '2';
-            ptr++;
-            *ptr = '0';
-        } else {
-            *ptr = c;
-        }
-        ptr++;
-    }
-
-    *ptr = 0;
-
-    HTTPClient client;
-    client.begin(buff);
     int httpCode = client.POST("");
     Serial.printf("Print start: HTTP %d\n", httpCode);
 }
@@ -52,11 +33,11 @@ static void btn_print_file_verify(lv_event_t * e){
     lv_obj_set_size(panel, CYD_SCREEN_WIDTH_PX - CYD_SCREEN_GAP_PX * 4, CYD_SCREEN_HEIGHT_PX - CYD_SCREEN_GAP_PX * 3);
     lv_obj_align(panel, LV_ALIGN_CENTER, 0, 0);
 
-    lv_obj_t * label = lv_label_create(panel);
+    lv_obj_t * label_print_file = lv_label_create(panel);
-    lv_label_set_text(label, "Print File");
+    lv_label_set_text(label_print_file, "Print File");
-    lv_obj_align(label, LV_ALIGN_TOP_LEFT, 0, 0);
+    lv_obj_align(label_print_file, LV_ALIGN_TOP_LEFT, 0, 0);
 
-    label = lv_label_create(panel);
+    lv_obj_t * label = lv_label_create(panel);
     lv_label_set_text(label, selected_file->name);
     lv_obj_align(label, LV_ALIGN_CENTER, 0, -20);
     lv_obj_set_width(label, CYD_SCREEN_WIDTH_PX - CYD_SCREEN_GAP_PX * 10);
@@ -79,6 +60,20 @@ static void btn_print_file_verify(lv_event_t * e){
     label = lv_label_create(btn);
     lv_label_set_text(label, LV_SYMBOL_OK);
     lv_obj_center(label);
+
+    lv_obj_t* img = show_gcode_img(selected_file->name);
+
+    if (img != NULL){
+        lv_obj_set_parent(img, panel);
+        lv_obj_align(img, LV_ALIGN_TOP_LEFT, 0, 0);
+
+        lv_obj_t * text_center_panel = lv_create_empty_panel(panel);
+        lv_obj_set_size(text_center_panel, CYD_SCREEN_MIN_BUTTON_WIDTH_PX * 2, 32); 
+        lv_obj_align(text_center_panel, LV_ALIGN_TOP_LEFT, CYD_SCREEN_GAP_PX + 32, 0);
+
+        lv_obj_set_parent(label_print_file, text_center_panel);
+        lv_obj_align(label_print_file, LV_ALIGN_LEFT_MID, 0, 0);
+    }
 }
 
 void print_panel_init(lv_obj_t* panel){
@@ -87,11 +82,13 @@ void print_panel_init(lv_obj_t* panel){
         return;
     }
 
+    clear_img_mem();
+
     lv_obj_t * list = lv_list_create(panel);
     lv_obj_set_style_radius(list, 0, 0);
     lv_obj_set_style_border_width(list, 0, 0); 
     lv_obj_set_style_bg_opa(list, LV_OPA_TRANSP, 0); 
-    lv_obj_set_size(list, CYD_SCREEN_PANEL_WIDTH_PX, CYD_SCREEN_HEIGHT_PX);
+    lv_obj_set_size(list, CYD_SCREEN_PANEL_WIDTH_PX, CYD_SCREEN_PANEL_HEIGHT_PX);
     lv_obj_align(list, LV_ALIGN_CENTER, 0, 0);
 
     FILESYSTEM_FILE* files = get_files(25);

CYD-Klipper/src/ui/panels/printer_panel.cpp

@@ -0,0 +1,299 @@
+#include "panel.h"
+#include "../../conf/global_config.h"
+#include "../../core/data_setup.h"
+#include "../ui_utils.h"
+#include "../../core/lv_setup.h"
+#include <stdio.h>
+#include "../nav_buttons.h"
+#include "../../core/macros_query.h"
+#include "../switch_printer.h"
+#include "../macros.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_name_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];
+
+    lv_label_set_text(label, config->printer_name[0] == 0 ? config->klipper_host : config->printer_name);
+}
+
+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 (config == get_current_printer_config())
+    {
+        lv_label_set_text(label, "In Control");
+        return;
+    }
+
+    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))
+    {
+        char percentage_buffer[12];
+        sprintf(percentage_buffer, "%.2f%%", printer->print_progress * 100);
+        lv_label_set_text(label, percentage_buffer);
+    }
+    else 
+    {
+        lv_label_set_text(label, "-%");
+    }
+}
+
+static void update_printer_control_button_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->power_devices > 0)
+    {
+        lv_label_set_text(label, "Power");
+    }
+    else
+    {
+        lv_label_set_text(label, "Control");
+    }
+}
+
+static void btn_enable_delete(lv_event_t * e)
+{
+    lv_obj_t * btn = lv_event_get_target(e);
+    PRINTER_CONFIG * config = (PRINTER_CONFIG*)lv_event_get_user_data(e);
+
+    if (config == get_current_printer_config())
+    {
+        // Disable
+        lv_obj_add_state(btn, LV_STATE_DISABLED);
+    }
+    else 
+    {
+        // Enable
+        lv_obj_clear_state(btn, LV_STATE_DISABLED);
+    }
+}
+
+static void btn_enable_control(lv_event_t * e)
+{
+    lv_obj_t * btn = 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 (config == get_current_printer_config() || (!printer->online && printer->power_devices <= 0))
+    {
+        // Disable
+        lv_obj_add_state(btn, LV_STATE_DISABLED);
+
+    }
+    else
+    {
+        // Enable
+        lv_obj_clear_state(btn, LV_STATE_DISABLED);
+    }
+}
+
+PRINTER_CONFIG * keyboard_config = NULL;
+
+static void keyboard_callback(lv_event_t * e){
+    lv_obj_t * ta = lv_event_get_target(e);
+    lv_obj_t * kb = (lv_obj_t *)lv_event_get_user_data(e);
+    
+    const char * text = lv_textarea_get_text(ta);
+    strcpy(keyboard_config->printer_name, text);
+    write_global_config();
+    lv_msg_send(DATA_PRINTER_MINIMAL, NULL);
+}
+
+static void btn_printer_delete(lv_event_t * e)
+{
+    lv_obj_t * btn = lv_event_get_target(e);
+    PRINTER_CONFIG * config = (PRINTER_CONFIG*)lv_event_get_user_data(e);
+
+    if (config == get_current_printer_config())
+    {
+        return;
+    }
+
+    config->ip_configured = false;
+    write_global_config();
+
+    nav_buttons_setup(PANEL_PRINTER);
+}
+
+// TODO: Extract this from temp/print panel and combine
+static void btn_printer_rename(lv_event_t * e)
+{
+    keyboard_config = (PRINTER_CONFIG*)lv_event_get_user_data(e);
+    lv_create_keyboard_text_entry(keyboard_callback, LV_KEYBOARD_MODE_TEXT_LOWER, CYD_SCREEN_WIDTH_PX * 0.75, 24, keyboard_config->printer_name, false);
+}
+
+static void btn_printer_activate(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)
+    {
+        macros_draw_power_fullscreen(config);
+        return;
+    }
+
+    switch_printer(index);
+    lv_msg_send(DATA_PRINTER_MINIMAL, NULL);
+}
+
+static void btn_printer_add(lv_event_t * e)
+{
+    set_printer_config_index(get_printer_config_free_index());
+}
+
+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_obj_add_event_cb(label, update_printer_name_text, LV_EVENT_MSG_RECEIVED, config);
+    lv_msg_subsribe_obj(DATA_PRINTER_MINIMAL, label, config);
+    
+    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);
+    lv_obj_add_event_cb(btn, btn_enable_delete, LV_EVENT_MSG_RECEIVED, config);
+    lv_msg_subsribe_obj(DATA_PRINTER_MINIMAL, btn, 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);
+    lv_obj_add_event_cb(btn, btn_enable_control, LV_EVENT_MSG_RECEIVED, config);
+    lv_msg_subsribe_obj(DATA_PRINTER_MINIMAL, btn, config);
+
+    label = lv_label_create(btn);
+    lv_obj_center(label);
+    lv_obj_add_event_cb(label, update_printer_control_button_text, LV_EVENT_MSG_RECEIVED, config);
+    lv_msg_subsribe_obj(DATA_PRINTER_MINIMAL, label, config);
+
+    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, 0);
+    lv_obj_set_size(inner_panel, CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2, CYD_SCREEN_PANEL_HEIGHT_PX);
+    lv_layout_flex_column(inner_panel);
+    lv_obj_set_scrollbar_mode(inner_panel, LV_SCROLLBAR_MODE_OFF);
+
+    lv_obj_set_size(lv_create_empty_panel(inner_panel), 0, 0);
+
+    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);
+        }
+    }
+
+    // Add Printer Button
+    if (get_printer_config_free_index() != -1){
+        lv_obj_t * btn = lv_btn_create(inner_panel);
+        lv_obj_set_size(btn, CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
+        lv_obj_add_event_cb(btn, btn_printer_add, LV_EVENT_CLICKED, NULL);
+
+        lv_obj_t * label = lv_label_create(btn);
+        lv_label_set_text(label, "Add Printer");
+        lv_obj_center(label);
+    }
+
+    lv_obj_set_size(lv_create_empty_panel(inner_panel), 0, 0);
+
+    lv_msg_send(DATA_PRINTER_MINIMAL, NULL);
+}

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,49 +16,55 @@
 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;
+    get_current_printer_config()->invert_colors = checked;
-    WriteGlobalConfig();
+    write_global_config();
     set_invert_display();
 }
 
 static void reset_calibration_click(lv_event_t * e){
-    global_config.screenCalibrated = false;
+    global_config.screen_calibrated = false;
-    WriteGlobalConfig();
+    write_global_config();
     ESP.restart();
 }
 
 static void reset_wifi_click(lv_event_t * e){
-    global_config.wifiConfigured = false;
+    global_config.wifi_configured = false;
-    global_config.ipConfigured = false;
+    write_global_config();
-    WriteGlobalConfig();
+    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;
+    get_current_printer_config()->light_mode = checked;
-    WriteGlobalConfig();
+    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%";
-const char  brightness_options_values[] = { 255, 192, 128, 64 };
+const unsigned char  brightness_options_values[] = { 255, 192, 128, 64 };
 
 static void brightness_dropdown(lv_event_t * e){
     lv_obj_t * dropdown = lv_event_get_target(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";
@@ -66,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.rotate_screen = checked;
-    global_config.screenCalibrated = false;
+    global_config.screen_calibrated = false;
-    WriteGlobalConfig();
+    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){
@@ -95,158 +102,101 @@ 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;
+    global_config.auto_ota_update = checked;
-    WriteGlobalConfig();
+    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} };
+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(PANEL_SETTINGS);
+}
 
-void create_settings_widget(const char* label_text, lv_obj_t* object, lv_obj_t* root_panel, bool set_height = true){
+const char* estimated_time_options = "Percentage\nInterpolated\nSlicer";
-    lv_obj_t * panel = lv_create_empty_panel(root_panel);
-    lv_obj_set_size(panel, CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 3, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
 
-    lv_obj_t * label = lv_label_create(panel);
+static void estimated_time_dropdown(lv_event_t * e){
-    lv_label_set_text(label, label_text);
+    lv_obj_t * dropdown = lv_event_get_target(e);
-    lv_obj_align(label, LV_ALIGN_LEFT_MID, 0, 0);
+    get_current_printer_config()->remaining_time_calc_mode = lv_dropdown_get_selected(dropdown);
-
+    write_global_config();
-    lv_obj_set_parent(object, panel);
-    lv_obj_align(object, LV_ALIGN_RIGHT_MID, 0, 0);
-
-    if (set_height)
-        lv_obj_set_height(object, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
-
-    lv_obj_t * line = lv_line_create(root_panel);
-    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 settings_panel_init(lv_obj_t* panel){
     lv_obj_set_style_pad_all(panel, CYD_SCREEN_GAP_PX, 0);
     lv_layout_flex_column(panel);
+    lv_obj_set_scrollbar_mode(panel, LV_SCROLLBAR_MODE_OFF);
 
-    lv_obj_t * btn = lv_btn_create(panel);
+    if (global_config.multi_printer_mode)
-    lv_obj_add_event_cb(btn, reset_wifi_click, LV_EVENT_CLICKED, NULL);
+    {
+        lv_obj_t * label = lv_label_create(panel);
+        lv_label_set_text(label, "Printer Specific Settings");
+    }
 
-    lv_obj_t * label = lv_label_create(btn);
+    lv_create_custom_menu_dropdown("Estimated Time", panel, estimated_time_dropdown, estimated_time_options, get_current_printer_config()->remaining_time_calc_mode);
-    lv_label_set_text(label, "Restart");
+    lv_create_custom_menu_dropdown("Theme", panel, theme_dropdown, "Blue\nGreen\nGrey\nYellow\nOrange\nRed\nPurple", get_current_printer_config()->color_scheme);
-    lv_obj_center(label);
 
-    create_settings_widget("Configure WiFi", btn, panel);
+#ifndef CYD_SCREEN_DISABLE_INVERT_COLORS
+    lv_create_custom_menu_switch("Invert Colors", panel, invert_color_switch, get_current_printer_config()->invert_colors);
+#endif // CYD_SCREEN_DISABLE_INVERT_COLORS
 
-#ifndef CYD_SCREEN_DISABLE_TOUCH_CALIBRATION
+    lv_create_custom_menu_switch("Light Mode", panel, light_mode_switch, get_current_printer_config()->light_mode);
-    btn = lv_btn_create(panel);
+    lv_create_custom_menu_button("Configure IP", panel, reset_ip_click, "Restart");
-    lv_obj_add_event_cb(btn, reset_calibration_click, LV_EVENT_CLICKED, NULL);
 
-    label = lv_label_create(btn);
+    if (global_config.multi_printer_mode)
-    lv_label_set_text(label, "Restart");
+    {
-    lv_obj_center(label);
+        lv_obj_t * label = lv_label_create(panel);
+        lv_label_set_text(label, "\nGlobal Settings");
+    }
 
-    create_settings_widget("Calibrate Touch", btn, panel);
+#ifndef CYD_SCREEN_DISABLE_TIMEOUT
-#endif // CYD_SCREEN_DISABLE_TOUCH_CALIBRATION
+    lv_create_custom_menu_switch("Screen On During Print", panel, on_during_print_switch, global_config.on_during_print);
-
+#endif
-    lv_obj_t * toggle = lv_switch_create(panel);
-    lv_obj_set_width(toggle, CYD_SCREEN_MIN_BUTTON_WIDTH_PX * 2);
-    lv_obj_add_event_cb(toggle, invert_color_switch, LV_EVENT_VALUE_CHANGED, NULL);
-
-    if (global_config.invertColors)
-        lv_obj_add_state(toggle, LV_STATE_CHECKED);
-
-    create_settings_widget("Invert Colors", toggle, panel);
-
-
-    toggle = lv_switch_create(panel);
-    lv_obj_set_width(toggle, CYD_SCREEN_MIN_BUTTON_WIDTH_PX * 2);
-    lv_obj_add_event_cb(toggle, light_mode_switch, LV_EVENT_VALUE_CHANGED, NULL);
-
-    if (global_config.lightMode)
-        lv_obj_add_state(toggle, LV_STATE_CHECKED);
-
-    create_settings_widget("Light Mode", toggle, panel);
-
-    lv_obj_t * 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_obj_add_event_cb(dropdown, theme_dropdown, LV_EVENT_VALUE_CHANGED, NULL);
-
-    create_settings_widget("Theme", dropdown, panel);
-
-    dropdown = lv_dropdown_create(panel);
-    lv_dropdown_set_options(dropdown, brightness_options);
-    lv_obj_add_event_cb(dropdown, brightness_dropdown, LV_EVENT_VALUE_CHANGED, NULL);
 
+    int brightness_settings_index = 0;
     for (int i = 0; i < SIZEOF(brightness_options_values); i++){
         if (brightness_options_values[i] == global_config.brightness){
-            lv_dropdown_set_selected(dropdown, i);
+            brightness_settings_index = i;
             break;
         }
     }
 
-    create_settings_widget("Brightness", dropdown, panel);
+    lv_create_custom_menu_dropdown("Brightness", panel, brightness_dropdown, brightness_options, brightness_settings_index);
 
 #ifndef CYD_SCREEN_DISABLE_TIMEOUT
-    dropdown = lv_dropdown_create(panel);
+    int wake_timeout_settings_index = 0;
-    lv_dropdown_set_options(dropdown, wake_timeout_options);
-    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);
+            wake_timeout_settings_index = i;
             break;
         }
     }
 
-    create_settings_widget("Wake Timeout", dropdown, panel);
+    lv_create_custom_menu_dropdown("Wake Timeout", panel, wake_timeout_dropdown, wake_timeout_options, wake_timeout_settings_index);
 #endif
 
-    toggle = lv_switch_create(panel);
+    lv_create_custom_menu_switch("Rotate Screen", panel, rotate_screen_switch, global_config.rotate_screen);
-    lv_obj_set_width(toggle, CYD_SCREEN_MIN_BUTTON_WIDTH_PX * 2);
+    lv_create_custom_menu_switch("Multi Printer Mode", panel, multi_printer_switch, global_config.multi_printer_mode);
-    lv_obj_add_event_cb(toggle, rotate_screen_switch, LV_EVENT_VALUE_CHANGED, NULL);
+    lv_create_custom_menu_switch("Auto Update", panel, auto_ota_update_switch, global_config.auto_ota_update);
-
+    lv_create_custom_menu_label("Version", panel, REPO_VERSION "  ");
-    if (global_config.rotateScreen)
-        lv_obj_add_state(toggle, LV_STATE_CHECKED);
-    
-    create_settings_widget("Rotate Screen", toggle, panel);
-
-#ifndef CYD_SCREEN_DISABLE_TIMEOUT
-    toggle = lv_switch_create(panel);
-    lv_obj_set_width(toggle, CYD_SCREEN_MIN_BUTTON_WIDTH_PX * 2);
-    lv_obj_add_event_cb(toggle, on_during_print_switch, LV_EVENT_VALUE_CHANGED, NULL);
-
-    if (global_config.onDuringPrint)
-        lv_obj_add_state(toggle, LV_STATE_CHECKED);
-
-    create_settings_widget("Screen On During Print", toggle, panel);
-#endif
-
-    label = lv_label_create(panel);
-    lv_label_set_text(label, REPO_VERSION "  ");
-
-    create_settings_widget("Version", label, panel, false);
 
     if (ota_has_update()){
-        btn = lv_btn_create(panel);
+        lv_obj_t *btn = lv_btn_create(panel);
         lv_obj_add_event_cb(btn, btn_ota_do_update, LV_EVENT_CLICKED, NULL);
 
-        label = lv_label_create(btn);
+        lv_obj_t *label = lv_label_create(btn);
         lv_label_set_text_fmt(label, "Update to %s", ota_new_version_name().c_str());
         lv_obj_center(label);
 
-        create_settings_widget("Device", btn, panel);
+        lv_create_custom_menu_entry("Device", btn, panel);
     }
     else {
-        label = lv_label_create(panel);
+        lv_create_custom_menu_label("Device", panel, ARDUINO_BOARD "  ");
-        lv_label_set_text(label, ARDUINO_BOARD "  ");
-
-        create_settings_widget("Device", label, panel, false);
     }
 
-    toggle = lv_switch_create(panel);
+    #ifndef CYD_SCREEN_DISABLE_TOUCH_CALIBRATION
-    lv_obj_set_width(toggle, CYD_SCREEN_MIN_BUTTON_WIDTH_PX * 2);
+        lv_create_custom_menu_button("Calibrate Touch", panel, reset_calibration_click, "Restart");
-    lv_obj_add_event_cb(toggle, auto_ota_update_switch, LV_EVENT_VALUE_CHANGED, NULL);
+    #endif // CYD_SCREEN_DISABLE_TOUCH_CALIBRATION
 
-    if (global_config.autoOtaUpdate)
+    lv_create_custom_menu_button("Configure WiFi", panel, reset_wifi_click, "Restart");
-        lv_obj_add_state(toggle, LV_STATE_CHECKED);
-
-    create_settings_widget("Auto Update", toggle, panel);
 }

CYD-Klipper/src/ui/panels/stats_panel.cpp

@@ -36,19 +36,42 @@ static void set_zoffset_text(lv_event_t * e) {
     lv_label_set_text(label, data);
 }
 
+static void set_zoffset_text_ex(lv_event_t * e) {
+    lv_obj_t * label = lv_event_get_target(e);
+    char data[64];
+    sprintf(data, "Z Offset: %.03f, Z: %.03f", printer.gcode_offset[2], printer.position[2]);
+    lv_label_set_text(label, data);
+}
+
 static void set_zoffset(lv_event_t * e){
     char* offset = (char*)lv_event_get_user_data(e);
+
     char gcode[64];
-    sprintf(gcode, "SET_GCODE_OFFSET Z_ADJUST=%s", offset);
+    sprintf(gcode, "SET_GCODE_OFFSET Z_ADJUST=%s MOVE=1", offset);
     send_gcode(true, gcode);
 }
 
-const char* zoffsets[] = { "-0.005", "-0.01", "-0.025", "-0.05" };
+static void set_z(lv_event_t * e){
-const char* zoffsets_2[] = { "+0.005", "+0.01", "+0.025", "+0.05" };
+    void* ptr = lv_event_get_user_data(e);
+    float value = *(float *)(&ptr);
+
+    if (value < 0) {
+        send_gcode(true, "SET_GCODE_OFFSET Z=0 MOVE=1");
+        return;
+    }
+
+    move_printer("Z", value, false);
+}
+
+const char* zoffsets[] = { "-0.01", "-0.025", "-0.05", "-0.2" };
+const char* zoffsets_2[] = { "+0.01", "+0.025", "+0.05", "+0.2" };
+const char* zabs[] = { "Z=0", "Z=0.1", "Z=1", "Clear" };
+const float zabsvalues[] = { 0, 0.1f, 1.0f, -1.0f };
 
 lv_button_column_t zoffset_columns[] = {
     { set_zoffset, zoffsets, (const void**)zoffsets, 4},
-    { set_zoffset, zoffsets_2, (const void**)zoffsets_2, 4}
+    { set_zoffset, zoffsets_2, (const void**)zoffsets_2, 4},
+    { set_z, zabs, (const void**)zabsvalues, 4}
 };
 
 static void set_speed_mult_text(lv_event_t * e){
@@ -126,7 +149,7 @@ static void open_fan_speed_panel(lv_event_t * e){
 }
 
 static void open_zoffset_panel(lv_event_t * e){
-    lv_create_fullscreen_button_matrix_popup(lv_scr_act(), set_zoffset_text, zoffset_columns, 2);
+    lv_create_fullscreen_button_matrix_popup(lv_scr_act(), set_zoffset_text_ex, zoffset_columns, (printer.state == PRINTER_STATE_IDLE) ? 3 : 2);
     lv_msg_send(DATA_PRINTER_DATA, &printer);
 }
 
@@ -175,7 +198,7 @@ static void label_total_layers(lv_event_t * e){
 static void label_pressure_advance(lv_event_t * e){
     lv_obj_t * label = lv_event_get_target(e);
     char pressure_buff[32];
-    sprintf(pressure_buff, "%.3f", printer.pressure_advance);
+    sprintf(pressure_buff, "%.3f (%.2fs)", printer.pressure_advance, printer.smooth_time);
     lv_label_set_text(label, pressure_buff);
 }
 
@@ -202,22 +225,27 @@ void create_stat_text_block(lv_obj_t * root, const char* label, lv_event_cb_t va
 }
 
 void stats_panel_init(lv_obj_t* panel) {
-    auto panel_width = CYD_SCREEN_PANEL_WIDTH_PX / 2 - CYD_SCREEN_GAP_PX * 3;
+    auto panel_width = CYD_SCREEN_PANEL_WIDTH_PX / 2 - CYD_SCREEN_GAP_PX * 2;
 
     lv_obj_t * left_panel = lv_create_empty_panel(panel);
-    lv_obj_set_size(left_panel, panel_width, CYD_SCREEN_HEIGHT_PX - CYD_SCREEN_GAP_PX * 2);
+    lv_obj_set_size(left_panel, panel_width, CYD_SCREEN_PANEL_HEIGHT_PX - CYD_SCREEN_GAP_PX * 2);
     lv_layout_flex_column(left_panel);
     lv_obj_set_flex_align(left_panel, LV_FLEX_ALIGN_SPACE_BETWEEN, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
     lv_obj_align(left_panel, LV_ALIGN_TOP_LEFT, CYD_SCREEN_GAP_PX, CYD_SCREEN_GAP_PX);
+    lv_obj_clear_flag(left_panel, LV_OBJ_FLAG_SCROLLABLE);
 
     create_stat_text_block(left_panel, "Position:", label_pos);
+
+    if (printer.state != PRINTER_STATE_IDLE){
         create_stat_text_block(left_panel, "Filament Used:", label_filament_used_m);
         create_stat_text_block(left_panel, "Layer:", label_total_layers);
+    }
+
     create_stat_text_block(left_panel, "Pressure Advance:", label_pressure_advance);
     create_stat_text_block(left_panel, "Feedrate:", label_feedrate);
 
     lv_obj_t * right_panel = lv_create_empty_panel(panel);
-    lv_obj_set_size(right_panel, panel_width, CYD_SCREEN_HEIGHT_PX - CYD_SCREEN_GAP_PX * 2);
+    lv_obj_set_size(right_panel, panel_width, CYD_SCREEN_PANEL_HEIGHT_PX - CYD_SCREEN_GAP_PX * 2);
     lv_layout_flex_column(right_panel, LV_FLEX_ALIGN_CENTER);
     lv_obj_align(right_panel, LV_ALIGN_TOP_RIGHT, -1 * CYD_SCREEN_GAP_PX, CYD_SCREEN_GAP_PX);
     

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,16 +62,14 @@ static void update_temp_preset_label(lv_event_t * e){
 }
 
 void UpdateConfig(){
-    WriteGlobalConfig();
+    write_global_config();
     lv_msg_send(DATA_PRINTER_TEMP_PRESET, &printer);
 }
 
 static void keyboard_callback(lv_event_t * e){
-    lv_event_code_t code = lv_event_get_code(e);
     lv_obj_t * ta = lv_event_get_target(e);
     lv_obj_t * kb = (lv_obj_t *)lv_event_get_user_data(e);
 
-    if (code == LV_EVENT_READY) {
     const char * text = lv_textarea_get_text(ta);
 
     int temp = atoi(text);
@@ -91,68 +89,40 @@ 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;
     }
-    }
-
-    if(code == LV_EVENT_DEFOCUSED || code == LV_EVENT_CANCEL || code == LV_EVENT_READY) {
-        lv_keyboard_set_textarea(kb, NULL);
-        lv_obj_del(lv_obj_get_parent(kb));
-    }
-}
-
-static void show_keyboard(lv_event_t * e){
-    lv_obj_t * parent = lv_create_empty_panel(root_panel);
-    lv_obj_set_style_bg_opa(parent, LV_OPA_50, 0); 
-    lv_obj_set_size(parent, CYD_SCREEN_PANEL_WIDTH_PX, CYD_SCREEN_HEIGHT_PX);
-    lv_layout_flex_column(parent, LV_FLEX_ALIGN_SPACE_BETWEEN);
-
-    lv_obj_t * empty_panel = lv_create_empty_panel(parent);
-    lv_obj_set_flex_grow(empty_panel, 1);
-
-    lv_obj_t * ta = lv_textarea_create(parent);
-    lv_obj_t * keyboard = lv_keyboard_create(parent);
-
-    lv_obj_set_width(ta, CYD_SCREEN_PANEL_WIDTH_PX / 2);
-    lv_textarea_set_max_length(ta, 3);
-    lv_textarea_set_one_line(ta, true);
-    lv_textarea_set_text(ta, "");
-    lv_obj_add_event_cb(ta, keyboard_callback, LV_EVENT_ALL, keyboard);
-
-    lv_keyboard_set_mode(keyboard, LV_KEYBOARD_MODE_NUMBER);
-    lv_keyboard_set_textarea(keyboard, ta);
 }
 
 static void show_keyboard_with_hotend(lv_event_t * e){
     keyboard_target = TARGET_HOTEND;
-    show_keyboard(e);
+    lv_create_keyboard_text_entry(keyboard_callback);
 }
 
 static void show_keyboard_with_bed(lv_event_t * e){
     keyboard_target = TARGET_BED;
-    show_keyboard(e);
+    lv_create_keyboard_text_entry(keyboard_callback);
 }
 
 static void cooldown_temp(lv_event_t * e){
@@ -179,7 +149,7 @@ static void set_temp_via_preset(lv_event_t * e){
 
     if (edit_mode) {
         keyboard_target = (temp_target)target;
-        show_keyboard(e);
+        lv_create_keyboard_text_entry(keyboard_callback);
         return;
     }
 
@@ -207,22 +177,90 @@ static void btn_retract(lv_event_t * e){
     send_gcode(true, "G1 E-25 F300");
 }
 
-void temp_panel_init(lv_obj_t * panel){
+static void set_chart_range(lv_event_t * e) {
+    lv_obj_t * chart_obj = lv_event_get_target(e);
+    lv_chart_t * chart = (lv_chart_t *)chart_obj;
+    int max_temp = 0;
+    lv_chart_series_t * prev = NULL;
+    
+    do {
+        prev = lv_chart_get_series_next(chart_obj, prev);
+
+        if (prev != NULL)
+            for (int i = 0; i < chart->point_cnt; i++)
+                if (prev->y_points[i] > max_temp)
+                    max_temp = prev->y_points[i];
+        
+    } while (prev != NULL);
+
+    int range = ((max_temp + 49) / 50) * 50;
+
+    if (range < 100)
+        range = 100;
+
+    lv_chart_set_range(chart_obj, LV_CHART_AXIS_PRIMARY_Y, 0, range);
+}
+
+static void set_hotend_temp_chart(lv_event_t * e){
+    lv_obj_t * chart = lv_event_get_target(e);
+    lv_chart_series_t * series = (lv_chart_series_t *)lv_event_get_user_data(e);
+    lv_chart_set_next_value(chart, series, printer.extruder_temp);
+}
+
+static void set_hotend_target_temp_chart(lv_event_t * e){
+    lv_obj_t * chart = lv_event_get_target(e);
+    lv_chart_series_t * series = (lv_chart_series_t *)lv_event_get_user_data(e);
+    lv_chart_set_next_value(chart, series, printer.extruder_target_temp);
+}
+
+static void set_bed_temp_chart(lv_event_t * e){
+    lv_obj_t * chart = lv_event_get_target(e);
+    lv_chart_series_t * series = (lv_chart_series_t *)lv_event_get_user_data(e);
+    lv_chart_set_next_value(chart, series, printer.bed_temp);
+}
+
+static void set_bed_target_temp_chart(lv_event_t * e){
+    lv_obj_t * chart = lv_event_get_target(e);
+    lv_chart_series_t * series = (lv_chart_series_t *)lv_event_get_user_data(e);
+    lv_chart_set_next_value(chart, series, printer.bed_target_temp);
+}
+
+void create_charts(lv_obj_t * root)
+{
     const auto element_width = CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2;
-    root_panel = panel;
+    lv_obj_t * chart = lv_chart_create(root);
-    edit_mode = false;
+    lv_obj_set_size(chart, element_width - CYD_SCREEN_MIN_BUTTON_WIDTH_PX, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX * 3);
+    lv_chart_set_type(chart, LV_CHART_TYPE_LINE);
+    lv_chart_set_point_count(chart, 120);
+    lv_obj_set_style_size(chart, 0, LV_PART_INDICATOR);
+    lv_chart_set_axis_tick(chart, LV_CHART_AXIS_PRIMARY_Y, CYD_SCREEN_GAP_PX / 2, CYD_SCREEN_GAP_PX / 4, 4, 3, true, CYD_SCREEN_MIN_BUTTON_WIDTH_PX);
+    lv_chart_set_update_mode(chart, LV_CHART_UPDATE_MODE_SHIFT);
 
-    lv_obj_t * root_temp_panel = lv_create_empty_panel(panel);
+    lv_chart_series_t * ser1 = lv_chart_add_series(chart, lv_palette_main(LV_PALETTE_ORANGE), LV_CHART_AXIS_PRIMARY_Y);
-    lv_obj_set_size(root_temp_panel, CYD_SCREEN_PANEL_WIDTH_PX, LV_SIZE_CONTENT);
+    lv_chart_set_all_value(chart, ser1, printer.extruder_target_temp);
-    lv_obj_align(root_temp_panel, LV_ALIGN_TOP_RIGHT, 0, 0);
+    lv_chart_series_t * ser2 = lv_chart_add_series(chart, lv_palette_main(LV_PALETTE_RED), LV_CHART_AXIS_PRIMARY_Y);
-    lv_obj_set_style_pad_all(root_temp_panel, CYD_SCREEN_GAP_PX, 0);
+    lv_chart_set_all_value(chart, ser2, printer.extruder_temp);
-    lv_layout_flex_column(root_temp_panel);
+    lv_chart_series_t * ser3 = lv_chart_add_series(chart, lv_palette_main(LV_PALETTE_TEAL), LV_CHART_AXIS_PRIMARY_Y);
+    lv_chart_set_all_value(chart, ser3, printer.bed_target_temp);
+    lv_chart_series_t * ser4 = lv_chart_add_series(chart, lv_palette_main(LV_PALETTE_BLUE), LV_CHART_AXIS_PRIMARY_Y);
+    lv_chart_set_all_value(chart, ser4, printer.bed_temp);
 
+    lv_obj_add_event_cb(chart, set_hotend_target_temp_chart, LV_EVENT_MSG_RECEIVED, ser1);
+    lv_obj_add_event_cb(chart, set_hotend_temp_chart, LV_EVENT_MSG_RECEIVED, ser2);
+    lv_obj_add_event_cb(chart, set_bed_target_temp_chart, LV_EVENT_MSG_RECEIVED, ser3);
+    lv_obj_add_event_cb(chart, set_bed_temp_chart, LV_EVENT_MSG_RECEIVED, ser4);
+    lv_obj_add_event_cb(chart, set_chart_range, LV_EVENT_MSG_RECEIVED, NULL);
+    lv_msg_subscribe_obj(DATA_PRINTER_DATA, chart, NULL);
+}
+
+void create_temp_buttons(lv_obj_t * root, lv_obj_t * panel)
+{
+    const auto element_width = CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2;
     lv_obj_t * temp_rows[2] = {0};
     lv_obj_t * button_temp_rows[2] = {0};
 
     for (int tempIter = 0; tempIter < 2; tempIter++){
-        temp_rows[tempIter] = lv_create_empty_panel(root_temp_panel);
+        temp_rows[tempIter] = lv_create_empty_panel(root);
         lv_layout_flex_column(temp_rows[tempIter]);
         lv_obj_set_size(temp_rows[tempIter], element_width, LV_SIZE_CONTENT);
 
@@ -258,17 +296,49 @@ void temp_panel_init(lv_obj_t * panel){
         lv_label_set_text(label, "Set");
         lv_obj_center(label);
     }
+}
 
-    lv_obj_t * bottom_panel = lv_create_empty_panel(panel);
+void temp_panel_init(lv_obj_t * panel){
-    lv_obj_set_size(bottom_panel, element_width, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
+    const auto element_width = CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2;
-    lv_obj_align(bottom_panel, LV_ALIGN_BOTTOM_MID, 0, -1 * CYD_SCREEN_GAP_PX);
+    root_panel = panel;
-    lv_layout_flex_row(bottom_panel, LV_FLEX_ALIGN_SPACE_EVENLY);
+    edit_mode = false;
 
-    lv_obj_t * one_above_bottom_panel = lv_create_empty_panel(panel);
+    lv_obj_t * root_temp_panel = lv_create_empty_panel(panel);
+    lv_obj_set_size(root_temp_panel, CYD_SCREEN_PANEL_WIDTH_PX, CYD_SCREEN_PANEL_HEIGHT_PX);
+    lv_obj_align(root_temp_panel, LV_ALIGN_TOP_RIGHT, 0, 0);
+    lv_obj_set_style_pad_all(root_temp_panel, CYD_SCREEN_GAP_PX, 0);
+    lv_layout_flex_column(root_temp_panel);
+    lv_obj_set_flex_align(root_temp_panel, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_END, LV_FLEX_ALIGN_CENTER);
+    lv_obj_set_scrollbar_mode(root_temp_panel, LV_SCROLLBAR_MODE_OFF);
+
+    #ifndef CYD_SCREEN_NO_TEMP_SCROLL
+        create_charts(root_temp_panel);
+
+        lv_obj_t * single_screen_panel = lv_create_empty_panel(root_temp_panel);
+        lv_obj_set_size(single_screen_panel, element_width, CYD_SCREEN_PANEL_HEIGHT_PX - CYD_SCREEN_GAP_PX * 2 - CYD_SCREEN_GAP_PX / 2);
+        lv_layout_flex_column(single_screen_panel);
+    #else
+        lv_obj_clear_flag(root_temp_panel, LV_OBJ_FLAG_SCROLLABLE);
+        lv_obj_t * single_screen_panel = root_temp_panel;
+    #endif
+    
+    create_temp_buttons(single_screen_panel, panel);
+
+    #ifdef CYD_SCREEN_NO_TEMP_SCROLL
+        create_charts(single_screen_panel);
+    #else
+        lv_obj_t * gap = lv_create_empty_panel(single_screen_panel);
+        lv_obj_set_flex_grow(gap, 1);
+    #endif
+
+    lv_obj_t * one_above_bottom_panel = lv_create_empty_panel(single_screen_panel);
     lv_obj_set_size(one_above_bottom_panel, element_width, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
-    lv_obj_align(one_above_bottom_panel, LV_ALIGN_BOTTOM_MID, 0, -1 * CYD_SCREEN_MIN_BUTTON_HEIGHT_PX - CYD_SCREEN_GAP_PX * 2);
     lv_layout_flex_row(one_above_bottom_panel, LV_FLEX_ALIGN_SPACE_EVENLY);
 
+    lv_obj_t * bottom_panel = lv_create_empty_panel(single_screen_panel);
+    lv_obj_set_size(bottom_panel, element_width, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
+    lv_layout_flex_row(bottom_panel, LV_FLEX_ALIGN_SPACE_EVENLY);
+
     lv_obj_t * btn = lv_btn_create(bottom_panel);
     lv_obj_set_flex_grow(btn, 1);
     lv_obj_add_event_cb(btn, btn_extrude, LV_EVENT_CLICKED, NULL);
@@ -306,5 +376,6 @@ void temp_panel_init(lv_obj_t * panel){
     lv_label_set_text(label, "Edit Presets");
     lv_obj_center(label);
 
+    lv_obj_scroll_to_y(root_temp_panel, 9999, LV_ANIM_OFF);
     lv_msg_send(DATA_PRINTER_TEMP_PRESET, &printer);
 }

CYD-Klipper/src/ui/switch_printer.cpp

@@ -0,0 +1,93 @@
+#include "switch_printer.h"
+#include "lvgl.h"
+#include "../conf/global_config.h"
+#include "ui_utils.h"
+#include "../core/http_client.h"
+#include "../core/lv_setup.h"
+#include "../core/macros_query.h"
+#include "../core/screen_driver.h"
+
+void switch_printer(int index)
+{
+    set_printer_config_index(index);
+    set_color_scheme();
+    set_invert_display();
+}
+
+static void btn_switch_printer(lv_event_t *e){
+    lv_obj_t *btn = lv_event_get_target(e);
+    PRINTER_CONFIG * config = (PRINTER_CONFIG*)lv_event_get_user_data(e);
+    int index = config - global_config.printer_config;
+
+    switch_printer(index);
+
+    lv_obj_del(lv_obj_get_parent(lv_obj_get_parent(btn)));
+}
+
+void switch_printer_init() {
+    lv_obj_t * parent = lv_create_empty_panel(lv_scr_act());
+    lv_obj_set_style_bg_opa(parent, LV_OPA_100, 0); 
+    lv_obj_align(parent, LV_ALIGN_TOP_RIGHT, 0, 0);
+    lv_obj_set_size(parent, CYD_SCREEN_WIDTH_PX, CYD_SCREEN_HEIGHT_PX);
+    lv_layout_flex_column(parent);
+
+    lv_obj_set_size(lv_create_empty_panel(parent), 0, 0);
+
+    auto width = CYD_SCREEN_WIDTH_PX - CYD_SCREEN_GAP_PX * 2;
+
+    lv_obj_t * btn = lv_btn_create(parent);
+    lv_obj_set_size(btn, width, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
+    lv_obj_add_event_cb(btn, destroy_event_user_data, LV_EVENT_CLICKED, parent);
+
+    lv_obj_t * label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_CLOSE " Close");
+    lv_obj_center(label);
+
+    for (int i = 0; i < PRINTER_CONFIG_COUNT; i++){
+        PRINTER_CONFIG * config = &global_config.printer_config[i];
+        const char* printer_name = (config->printer_name[0] == 0) ? config->klipper_host : config->printer_name;
+
+        if (config == get_current_printer_config())
+        {
+            lv_create_custom_menu_label(printer_name, parent, "Active");
+            continue;
+        }
+
+        if (config->ip_configured) {
+            HTTPClient client;
+            configure_http_client(client, get_full_url("/printer/objects/query?webhooks&print_stats&virtual_sdcard", config), true, 1000);
+            
+
+            int httpCode = client.GET();
+            if (httpCode == 200)
+            {
+                lv_create_custom_menu_button(printer_name, parent, btn_switch_printer, "Switch", config);
+            }
+            else 
+            {
+                lv_create_custom_menu_label(printer_name, parent, "Offline");
+            }
+        }
+    }
+}
+
+static void show_switch_printer_screen(lv_event_t * e){
+    switch_printer_init();
+}
+
+void draw_switch_printer_button() 
+{
+    if (!global_config.multi_printer_mode)
+    {
+        return;
+    }
+
+    lv_obj_t * btn = lv_btn_create(lv_scr_act());
+    lv_obj_set_size(btn, CYD_SCREEN_MIN_BUTTON_WIDTH_PX, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
+    lv_obj_align(btn, LV_ALIGN_TOP_RIGHT, -CYD_SCREEN_GAP_PX, CYD_SCREEN_GAP_PX);
+    lv_obj_add_event_cb(btn, show_switch_printer_screen, LV_EVENT_CLICKED, NULL);
+
+    lv_obj_t * label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_HOME);
+    lv_obj_center(label);
+}

CYD-Klipper/src/ui/switch_printer.h

@@ -0,0 +1,5 @@
+#pragma once
+
+void switch_printer(int index);
+void switch_printer_init();
+void draw_switch_printer_button();

CYD-Klipper/src/ui/ui_utils.cpp

@@ -2,6 +2,7 @@
 #include "ui_utils.h"
 #include "../core/data_setup.h"
 #include "../core/lv_setup.h"
+#include <ErriezCRC32.h>
 
 lv_obj_t* lv_create_empty_panel(lv_obj_t* root) {
     lv_obj_t* panel = lv_obj_create(root); 
@@ -86,3 +87,164 @@ void lv_create_fullscreen_button_matrix_popup(lv_obj_t * root, lv_event_cb_t tit
         }
     }
 }
+
+void lv_keyboard_text_entry_close(lv_event_t * e){
+    lv_event_code_t code = lv_event_get_code(e);
+    lv_obj_t * ta = lv_event_get_target(e);
+    lv_obj_t * kb = (lv_obj_t *)lv_event_get_user_data(e);
+
+    if(code == LV_EVENT_DEFOCUSED || code == LV_EVENT_CANCEL || code == LV_EVENT_READY) 
+    {
+        lv_keyboard_set_textarea(kb, NULL);
+        lv_obj_del(lv_obj_get_parent(kb));
+    }
+}
+
+void lv_create_keyboard_text_entry(lv_event_cb_t keyboard_callback, lv_keyboard_mode_t keyboard_mode, lv_coord_t width, uint8_t max_length, const char* fill_text, bool contain_in_panel)
+{
+    lv_obj_t * parent = lv_create_empty_panel(lv_scr_act());
+    lv_obj_set_style_bg_opa(parent, LV_OPA_50, 0); 
+    lv_obj_align(parent, LV_ALIGN_TOP_RIGHT, 0, 0);
+    lv_layout_flex_column(parent, LV_FLEX_ALIGN_SPACE_BETWEEN);
+
+    if (contain_in_panel)
+    {
+        lv_obj_set_size(parent, CYD_SCREEN_PANEL_WIDTH_PX, CYD_SCREEN_PANEL_HEIGHT_PX);
+    }
+    else
+    {
+        lv_obj_set_size(parent, CYD_SCREEN_WIDTH_PX, CYD_SCREEN_HEIGHT_PX);
+    }
+
+    lv_obj_t * empty_panel = lv_create_empty_panel(parent);
+    lv_obj_set_flex_grow(empty_panel, 1);
+
+    lv_obj_t * ta = lv_textarea_create(parent);
+    lv_obj_t * keyboard = lv_keyboard_create(parent);
+
+    lv_obj_set_width(ta, width);
+    lv_textarea_set_max_length(ta, max_length);
+    lv_textarea_set_one_line(ta, true);
+    lv_textarea_set_text(ta, fill_text);
+    lv_obj_add_event_cb(ta, keyboard_callback, LV_EVENT_READY, keyboard);
+    lv_obj_add_event_cb(ta, lv_keyboard_text_entry_close, LV_EVENT_ALL, keyboard);
+
+    lv_keyboard_set_mode(keyboard, keyboard_mode);
+    lv_keyboard_set_textarea(keyboard, ta);
+}
+
+const static lv_point_t line_points[] = { {0, 0}, {(short int)((CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2) * 0.85f), 0} };
+
+void lv_create_custom_menu_entry(const char* label_text, lv_obj_t* object, lv_obj_t* root_panel, bool set_height)
+{
+    lv_obj_t * panel = lv_create_empty_panel(root_panel);
+    lv_layout_flex_row(panel, LV_FLEX_ALIGN_END);
+    lv_obj_set_size(panel, CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 3, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
+
+    lv_obj_t * label = lv_label_create(panel);
+    lv_label_set_text(label, label_text);
+    lv_label_set_long_mode(label, LV_LABEL_LONG_SCROLL_CIRCULAR);
+    lv_obj_set_flex_grow(label, 1);
+
+    lv_obj_set_parent(object, panel);
+
+    if (set_height)
+        lv_obj_set_height(object, CYD_SCREEN_MIN_BUTTON_HEIGHT_PX);
+
+    lv_obj_t * line = lv_line_create(root_panel);
+    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);
+}
+
+#define DROPDOWN_WIDTH CYD_SCREEN_MIN_BUTTON_WIDTH_PX * 3.75
+#define TOGGLE_WIDTH CYD_SCREEN_MIN_BUTTON_WIDTH_PX * 2
+
+void lv_create_custom_menu_button(const char *label_text, lv_obj_t* root_panel, lv_event_cb_t on_click, const char *btn_text, void * user_data)
+{
+    lv_obj_t * btn = lv_btn_create(lv_scr_act());
+    lv_obj_add_event_cb(btn, on_click, LV_EVENT_CLICKED, user_data);
+
+    lv_obj_t * label = lv_label_create(btn);
+    lv_label_set_text(label, btn_text);
+    lv_obj_center(label);
+
+    lv_create_custom_menu_entry(label_text, btn, root_panel, true);
+}
+
+void lv_create_custom_menu_switch(const char *label_text, lv_obj_t* root_panel, lv_event_cb_t on_toggle, bool state, void * user_data)
+{
+    lv_obj_t * toggle = lv_switch_create(lv_scr_act());
+    lv_obj_add_event_cb(toggle, on_toggle, LV_EVENT_VALUE_CHANGED, user_data);
+    lv_obj_set_width(toggle, TOGGLE_WIDTH);
+
+    if (state)
+        lv_obj_add_state(toggle, LV_STATE_CHECKED);
+
+    lv_create_custom_menu_entry(label_text, toggle, root_panel, true);
+}
+
+void lv_create_custom_menu_dropdown(const char *label_text, lv_obj_t *root_panel, lv_event_cb_t on_change, const char *options, int index, void * user_data)
+{
+    lv_obj_t * dropdown = lv_dropdown_create(lv_scr_act());
+    lv_dropdown_set_options(dropdown, options);
+    lv_dropdown_set_selected(dropdown, index);
+    lv_obj_set_width(dropdown, DROPDOWN_WIDTH);
+    lv_obj_add_event_cb(dropdown, on_change, LV_EVENT_VALUE_CHANGED, user_data);
+
+    lv_create_custom_menu_entry(label_text, dropdown, root_panel, true);
+}
+
+void lv_create_custom_menu_label(const char *label_text, lv_obj_t* root_panel, const char *text)
+{
+    lv_obj_t * label = lv_label_create(lv_scr_act());
+    lv_label_set_text(label, text);
+    lv_create_custom_menu_entry(label_text, label, root_panel, false);
+}
+
+uint32_t message_hash = 0;
+lv_timer_t* timer = NULL;
+
+void on_timer_destroy(lv_event_t * e)
+{
+    lv_timer_del(timer);
+    timer = NULL;
+}
+
+void timer_callback(lv_timer_t *timer)
+{
+    lv_obj_t * panel = (lv_obj_t *)timer->user_data;
+    lv_obj_del(panel);
+}
+
+void lv_create_popup_message(const char* message, uint16_t timeout_ms)
+{
+    if (message == nullptr || timer != NULL) 
+    {
+        return;
+    }
+
+    uint32_t new_hash = crc32String(message);
+
+    if (new_hash == message_hash) 
+    {
+        return;
+    }
+
+    message_hash = new_hash;
+
+    lv_obj_t* panel = lv_obj_create(lv_scr_act()); 
+    lv_obj_set_style_pad_all(panel, CYD_SCREEN_GAP_PX, CYD_SCREEN_GAP_PX);
+    lv_obj_set_size(panel, CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 2, LV_SIZE_CONTENT);
+    lv_layout_flex_column(panel, LV_FLEX_ALIGN_CENTER);
+    lv_obj_align(panel, LV_ALIGN_TOP_RIGHT, -CYD_SCREEN_GAP_PX, CYD_SCREEN_GAP_PX);
+    lv_obj_add_event_cb(panel, on_timer_destroy, LV_EVENT_DELETE, NULL);
+    lv_obj_set_style_border_color(panel, lv_color_hex(0xFF0000), 0);
+
+    lv_obj_t* label = lv_label_create(panel);
+    lv_label_set_text_fmt(label, "%s", message);
+    lv_obj_set_size(label, CYD_SCREEN_PANEL_WIDTH_PX - CYD_SCREEN_GAP_PX * 6, LV_SIZE_CONTENT);
+    lv_label_set_long_mode(label, LV_LABEL_LONG_WRAP);
+
+    timer = lv_timer_create(timer_callback, timeout_ms,  panel);
+}

CYD-Klipper/src/ui/ui_utils.h

@@ -1,15 +1,30 @@
 #pragma once
 
-#ifndef CYD_SCREEN_WIDTH_PX
+#ifdef CYD_SCREEN_VERTICAL
-#define CYD_SCREEN_WIDTH_PX LCD_HEIGHT
+    #ifndef CYD_SCREEN_WIDTH_PX
-#endif
+        #define CYD_SCREEN_WIDTH_PX LCD_WIDTH
+    #endif
 
-#ifndef CYD_SCREEN_HEIGHT_PX
+    #ifndef CYD_SCREEN_HEIGHT_PX
-#define CYD_SCREEN_HEIGHT_PX LCD_WIDTH
+        #define CYD_SCREEN_HEIGHT_PX LCD_HEIGHT
-#endif
+    #endif
 
-#define CYD_SCREEN_PANEL_WIDTH_PX \
+    #define CYD_SCREEN_PANEL_HEIGHT_PX \
+        (CYD_SCREEN_HEIGHT_PX - CYD_SCREEN_SIDEBAR_SIZE_PX)
+    #define CYD_SCREEN_PANEL_WIDTH_PX CYD_SCREEN_WIDTH_PX
+#else 
+    #ifndef CYD_SCREEN_WIDTH_PX
+        #define CYD_SCREEN_WIDTH_PX LCD_HEIGHT
+    #endif
+
+    #ifndef CYD_SCREEN_HEIGHT_PX
+        #define CYD_SCREEN_HEIGHT_PX LCD_WIDTH
+    #endif
+
+    #define CYD_SCREEN_PANEL_HEIGHT_PX CYD_SCREEN_HEIGHT_PX
+    #define CYD_SCREEN_PANEL_WIDTH_PX \
         (CYD_SCREEN_WIDTH_PX - CYD_SCREEN_SIDEBAR_SIZE_PX)
+#endif
 
 typedef struct {
     lv_event_cb_t event;
@@ -23,3 +38,10 @@ void lv_layout_flex_column(lv_obj_t* obj, lv_flex_align_t allign = LV_FLEX_ALIGN
 void lv_layout_flex_row(lv_obj_t* obj, lv_flex_align_t allign = LV_FLEX_ALIGN_START, lv_coord_t pad_column = CYD_SCREEN_GAP_PX, lv_coord_t pad_row = CYD_SCREEN_GAP_PX);
 void lv_create_fullscreen_button_matrix_popup(lv_obj_t * root, lv_event_cb_t title, lv_button_column_t* columns, int column_count);
 void destroy_event_user_data(lv_event_t * e);
+void lv_create_keyboard_text_entry(lv_event_cb_t keyboard_callback, lv_keyboard_mode_t keyboard_mode = LV_KEYBOARD_MODE_NUMBER, lv_coord_t width = CYD_SCREEN_PANEL_WIDTH_PX / 2, uint8_t max_length = 3, const char* fill_text = "", bool contain_in_panel= true);
+void lv_create_custom_menu_entry(const char* label_text, lv_obj_t* object, lv_obj_t* root_panel, bool set_height = true);
+void lv_create_custom_menu_button(const char *label_text, lv_obj_t* root_panel, lv_event_cb_t on_click, const char *btn_text, void * user_data = NULL);
+void lv_create_custom_menu_switch(const char *label_text, lv_obj_t* root_panel, lv_event_cb_t on_toggle, bool state, void * user_data = NULL);
+void lv_create_custom_menu_dropdown(const char *label_text, lv_obj_t *root_panel, lv_event_cb_t on_change, const char *options, int index, void * user_data = NULL);
+void lv_create_custom_menu_label(const char *label_text, lv_obj_t* root_panel, const char *text);
+void lv_create_popup_message(const char* message, uint16_t timeout_ms);

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;
+            global_config.wifi_configured = true;
-            strcpy(global_config.wifiPassword, txt);
+            strcpy(global_config.wifi_password, txt);
-            WriteGlobalConfig();
+            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){
+    if (global_config.wifi_configured){
-        WiFi.begin(global_config.wifiSSID, global_config.wifiPassword);
+        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()]);

README.md

@@ -22,6 +22,7 @@ A ESP32-2432S028R is required to run this project. You can find out where to buy
 - Extrude/Retract filament
 - Execute predefined gcode macros
 - Toggle Moonraker power devices
+- OTA updates
 
 ### Install
 
@@ -29,7 +30,13 @@ A ESP32-2432S028R is required to run this project. You can find out where to buy
 
 On initial install, all data should be wiped. On updates, data should be able to be kept without issues.
 
-There are no 'over the air' updates. Each update has to be applied manually.
+When there is an update available, a button in the settings will appear that can be pressed to update. If automatic updates are preferred, there is a toggle in the settings to automatically update. This will right after connecting to wifi update the screen.
+
+### Donate
+
+If you found this project helpful, please consider a donation [to my Ko-Fi](https://ko-fi.com/suchmememanyskill). It would help out a lot in the development of this project, due to the need to buy the screens. 
+
+Thank you!
 
 ### Screenshots
 (Quite literally shots of the screen. I'm sorry)

_site/index.html

@@ -24,7 +24,11 @@
     }
 
     .main a {
-      color: #F00;
+      color: #F44;
+    }
+
+    .install {
+      margin-bottom: 300px;
     }
 
     .install .iconify {
@@ -46,13 +50,22 @@
       document.getElementById("changelog-header-version").innerText += data.tag_name;
     }
 
+    function setInstallButton(esp){
+      document.getElementById("install-btn").innerHTML = `<esp-web-install-button manifest="https://suchmememanyskill.github.io/CYD-Klipper/${esp}.json"></esp-web-install-button>`;
+    }
+
+    function setInstallButtonDefault(){
+      setInstallButton("esp32-2432S028R")
+    }
+
     fetchChangelog();
+    window.onload = setInstallButtonDefault;
   </script>
 </head>
 
 <body>
   <section class="main">
-    <h2>CYD-Klipper <span class="iconify" data-icon="mdi-printer-3d" style="color: orange;"></span></h2>
+    <h2>CYD-Klipper <span class="iconify" data-icon="mdi-printer-3d" style="color: #F44;"></span></h2>
     <p>An implementation of a Klipper status display on an ESP32 + screen.<br>Uses Moonraker to fetch data.<br><a href="https://github.com/suchmememanyskill/CYD-Klipper">Source code is available on GitHub</a>.</p>
     
     <section class="changelog">
@@ -65,17 +78,24 @@
       <p>If you found this project helpful, please consider a donation to <a href="https://ko-fi.com/suchmememanyskill">my Ko-Fi</a>.<br>It would help out a lot in the development of this project, due to the need to buy the screens.<br>Thank you!</p>
     </section>
 
-    <section class="install">
+    <section class="issues">
-      <h3><span class="iconify" data-icon="mdi-download"></span> Install on ESP32-2432S028 (2.8" Resistive)</h3>
+      <h3><span class="iconify" data-icon="mdi-github" style="color: white; filter: drop-shadow(0 0 0.75rem gray);"></span> Report Issues</h3>
-      <p>Note: You may need to hold the 'BOOT' button on the device while pressing install.</p>
+      <p>If you experience any issues with this project, or any feature requests for the project, please report them on the <a href="https://github.com/suchmememanyskill/CYD-Klipper/issues">issues tab on Github</a>.</p>
-      <esp-web-install-button
-        manifest="https://suchmememanyskill.github.io/CYD-Klipper/esp32-2432S028R.json"></esp-web-install-button>
     </section>
+
     <section class="install">
-      <h3><span class="iconify" data-icon="mdi-download"></span> Install on ESP32-3248S035 (3.5" Capacitive)</h3>
+      <h3><span class="iconify" data-icon="mdi-download"></span> Install</h3>
-      <p>Note: You may need to hold the 'BOOT' button on the device while pressing install.</p>
+      <p>Select your device from the list below and click 'Connect'.<br>Note: You may need to hold the 'BOOT' button on the device while pressing install.<br>The 2.8" Resistive and 3.5" Capacitive models are best suited (in my opinion) for CYD-Klipper.</p>
-      <esp-web-install-button
+      <select id="select-install-btn" onchange="setInstallButton(getElementById('select-install-btn').value)">
-        manifest="https://suchmememanyskill.github.io/CYD-Klipper/esp32-3248S035C.json"></esp-web-install-button>
+        <option value="esp32-2432S024C-SD">ESP32-2432S024 (2.4" Capacitive)</option>
+        <option selected value="esp32-2432S028R">ESP32-2432S028 (2.8" Resistive)</option>
+        <option value="esp32-2432S032C-SD">ESP32-2432S032 (3.2" Capacitive)</option>
+        <option value="esp32-3248S035C">ESP32-3248S035 (3.5" Capacitive)</option>
+        <option value="esp32-3248S035C-V">ESP32-3248S035 (3.5" Capacitive) Vertical Orientation</option>
+        <option value="esp32-4827S043C-SD">ESP32-4827S043 (4.3" 480x270 Capacitive)</option>
+        <option value="esp32-8048S043C-SD">ESP32-8048S043 (4.3" 800x480 Capacitive)</option>
+      </select>
+      <span id="install-btn"></span>
     </section>
   </section>
 </body>

ci.py

@@ -1,6 +1,14 @@
 import subprocess, os, shutil, json
 
-CYD_PORTS = ["esp32-3248S035C", "esp32-2432S028R"]
+CYD_PORTS = [
+    "esp32-3248S035C", 
+    "esp32-2432S028R", 
+    "esp32-2432S032C-SD", 
+    "esp32-8048S043C-SD", 
+    "esp32-2432S024C-SD", 
+    "esp32-4827S043C-SD",
+    "esp32-3248S035C-V"
+]
 BASE_DIR = os.getcwd()
 
 def get_manifest(base_path : str, device_name : str):