Initial release

2026-03-21 13:43:25 +00:00 · 2023-11-13 17:07:54 +01:00
parent e04e3204eb
commit c0651a50a7
38 changed files with 39 additions and 18 deletions
--- a/CYD-Klipper/.gitignore
+++ b/CYD-Klipper/.gitignore
@@ -0,0 +1,5 @@
+.pio
+.vscode/.browse.c_cpp.db*
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/ipch
--- a/CYD-Klipper/.vscode/extensions.json
+++ b/CYD-Klipper/.vscode/extensions.json
@@ -0,0 +1,10 @@
+{
+    // See http://go.microsoft.com/fwlink/?LinkId=827846
+    // for the documentation about the extensions.json format
+    "recommendations": [
+        "platformio.platformio-ide"
+    ],
+    "unwantedRecommendations": [
+        "ms-vscode.cpptools-extension-pack"
+    ]
+}
--- a/CYD-Klipper/.vscode/settings.json
+++ b/CYD-Klipper/.vscode/settings.json
@@ -0,0 +1,13 @@
+{
+    "files.associations": {
+        "array": "cpp",
+        "deque": "cpp",
+        "list": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "unordered_set": "cpp",
+        "vector": "cpp",
+        "string_view": "cpp",
+        "initializer_list": "cpp"
+    }
+}
--- a/CYD-Klipper/CMakeLists.txt
+++ b/CYD-Klipper/CMakeLists.txt
@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.16.0)
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(CYD-Klipper)
--- a/CYD-Klipper/include/README
+++ b/CYD-Klipper/include/README
@@ -0,0 +1,39 @@
+
+This directory is intended for project header files.
+
+A header file is a file containing C declarations and macro definitions
+to be shared between several project source files. You request the use of a
+header file in your project source file (C, C++, etc) located in `src` folder
+by including it, with the C preprocessing directive `#include'.
+
+```src/main.c
+
+#include "header.h"
+
+int main (void)
+{
+ ...
+}
+```
+
+Including a header file produces the same results as copying the header file
+into each source file that needs it. Such copying would be time-consuming
+and error-prone. With a header file, the related declarations appear
+in only one place. If they need to be changed, they can be changed in one
+place, and programs that include the header file will automatically use the
+new version when next recompiled. The header file eliminates the labor of
+finding and changing all the copies as well as the risk that a failure to
+find one copy will result in inconsistencies within a program.
+
+In C, the usual convention is to give header files names that end with `.h'.
+It is most portable to use only letters, digits, dashes, and underscores in
+header file names, and at most one dot.
+
+Read more about using header files in official GCC documentation:
+
+* Include Syntax
+* Include Operation
+* Once-Only Headers
+* Computed Includes
+
+https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html
--- a/CYD-Klipper/lib/README
+++ b/CYD-Klipper/lib/README
@@ -0,0 +1,46 @@
+
+This directory is intended for project specific (private) libraries.
+PlatformIO will compile them to static libraries and link into executable file.
+
+The source code of each library should be placed in a an own separate directory
+("lib/your_library_name/[here are source files]").
+
+For example, see a structure of the following two libraries `Foo` and `Bar`:
+
+|--lib
+|  |
+|  |--Bar
+|  |  |--docs
+|  |  |--examples
+|  |  |--src
+|  |     |- Bar.c
+|  |     |- Bar.h
+|  |  |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
+|  |
+|  |--Foo
+|  |  |- Foo.c
+|  |  |- Foo.h
+|  |
+|  |- README --> THIS FILE
+|
+|- platformio.ini
+|--src
+   |- main.c
+
+and a contents of `src/main.c`:
+```
+#include <Foo.h>
+#include <Bar.h>
+
+int main (void)
+{
+  ...
+}
+
+```
+
+PlatformIO Library Dependency Finder will find automatically dependent
+libraries scanning project source files.
+
+More information about PlatformIO Library Dependency Finder
+- https://docs.platformio.org/page/librarymanager/ldf.html
--- a/CYD-Klipper/platformio.ini
+++ b/CYD-Klipper/platformio.ini
@@ -0,0 +1,42 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env:esp32dev]
+platform = espressif32
+board = esp32dev
+framework = arduino
+monitor_speed = 115200
+lib_deps = 
+	SPI
+	lvgl/lvgl@^8.3.9
+	https://github.com/Bodmer/TFT_eSPI.git
+	https://github.com/PaulStoffregen/XPT2046_Touchscreen.git
+	bblanchon/ArduinoJson@^6.21.3
+build_flags = 
+	-DLV_CONF_PATH="../../../../src/conf/lv_conf.h"
+	-DUSER_SETUP_LOADED=1
+	-DILI9341_2_DRIVER=1
+	-DTFT_WIDTH=240
+	-DTFT_HEIGHT=320
+	-DTFT_BL=21
+	-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
+	-DLOAD_FONT2=1
+	-DLOAD_GFXFF=1
+	-DSMOOTH_FONT=1
+	-DSPI_FREQUENCY=55000000
+	-DSPI_READ_FREQUENCY=20000000
+	-DSPI_TOUCH_FREQUENCY=2500000
--- a/CYD-Klipper/sdkconfig.esp32dev
+++ b/CYD-Klipper/sdkconfig.esp32dev
--- a/CYD-Klipper/src/CMakeLists.txt
+++ b/CYD-Klipper/src/CMakeLists.txt
@@ -0,0 +1,6 @@
+# This file was automatically generated for projects
+# without default 'CMakeLists.txt' file.
+
+FILE(GLOB_RECURSE app_sources ${CMAKE_SOURCE_DIR}/src/*.*)
+
+idf_component_register(SRCS ${app_sources})
--- a/CYD-Klipper/src/conf/global_config.cpp
+++ b/CYD-Klipper/src/conf/global_config.cpp
@@ -0,0 +1,49 @@
+#include <Preferences.h>
+#include "global_config.h"
+#include "lvgl.h"
+
+GLOBAL_CONFIG global_config = {0};
+
+COLOR_DEF color_defs[] = {
+    {LV_PALETTE_BLUE, LV_PALETTE_RED},
+    {LV_PALETTE_GREEN, LV_PALETTE_PURPLE},
+    {LV_PALETTE_GREY, LV_PALETTE_CYAN},
+    {LV_PALETTE_YELLOW, LV_PALETTE_PINK},
+    {LV_PALETTE_ORANGE, LV_PALETTE_BLUE},
+    {LV_PALETTE_RED, LV_PALETTE_GREEN},
+    {LV_PALETTE_PURPLE, LV_PALETTE_GREY},
+};
+
+void WriteGlobalConfig() {
+    Preferences preferences;
+    preferences.begin("global_config", false);
+    preferences.putBytes("global_config", &global_config, sizeof(global_config));
+    preferences.end();
+}
+
+void VerifyVersion(){
+    Preferences preferences;
+    if (!preferences.begin("global_config", false))
+        return;
+    
+    GLOBAL_CONFIG config = {0};
+    preferences.getBytes("global_config", &config, sizeof(config));
+    Serial.printf("Config version: %d\n", config.version);
+    if (config.version != CONFIG_VERSION) {
+        Serial.println("Clearing Global Config");
+        preferences.clear();
+    }
+
+    preferences.end();
+}
+
+void LoadGlobalConfig() {
+    global_config.version = CONFIG_VERSION;
+    global_config.brightness = 255;
+    global_config.screenTimeout = 5;
+    VerifyVersion();
+    Preferences preferences;
+    preferences.begin("global_config", true);
+    preferences.getBytes("global_config", &global_config, sizeof(global_config));
+    preferences.end();
+}
--- a/CYD-Klipper/src/conf/global_config.h
+++ b/CYD-Klipper/src/conf/global_config.h
@@ -0,0 +1,50 @@
+#ifndef _GLOBAL_CONFIG_INIT
+#define _GLOBAL_CONFIG_INIT
+
+#include "lvgl.h"
+
+#define CONFIG_VERSION 2
+
+typedef struct _GLOBAL_CONFIG {
+    unsigned char version;
+    union {
+        unsigned char raw;
+        struct {
+            bool screenCalibrated : 1;
+            bool wifiConfigured : 1;
+            bool ipConfigured : 1;
+            bool lightMode : 1;
+            bool invertColors : 1;
+            bool rotateScreen : 1;
+            bool onDuringPrint : 1;
+        };
+    };
+    float screenCalXOffset;
+    float screenCalXMult;
+    float screenCalYOffset;
+    float screenCalYMult;
+
+    char wifiSSID[32];
+    char wifiPassword[64];
+
+    char klipperHost[64];
+    unsigned short klipperPort;
+    
+    unsigned char color_scheme;
+    unsigned char brightness;
+    unsigned char screenTimeout;
+} GLOBAL_CONFIG;
+    
+typedef struct _COLOR_DEF {
+    lv_palette_t primary_color;
+    lv_palette_t secondary_color;
+} COLOR_DEF;
+
+extern GLOBAL_CONFIG global_config;
+extern COLOR_DEF color_defs[];
+
+void WriteGlobalConfig();
+void VerifyVersion();
+void LoadGlobalConfig();
+
+#endif // !_GLOBAL_CONFIG_INIT
--- a/CYD-Klipper/src/conf/lv_conf.h
+++ b/CYD-Klipper/src/conf/lv_conf.h
@@ -0,0 +1,705 @@
+/**
+ * @file lv_conf.h
+ * Configuration file for v8.3.0-dev
+ */
+
+/*
+ * Copy this file as `lv_conf.h`
+ * 1. simply next to the `lvgl` folder
+ * 2. or any other places and
+ *    - define `LV_CONF_INCLUDE_SIMPLE`
+ *    - add the path as include path
+ */
+
+/* clang-format off */
+#if 1 /*Set it to "1" to enable content*/
+
+#ifndef LV_CONF_H
+#define LV_CONF_H
+
+#include <stdint.h>
+
+/*====================
+   COLOR SETTINGS
+ *====================*/
+
+/*Color depth: 1 (1 byte per pixel), 8 (RGB332), 16 (RGB565), 32 (ARGB8888)*/
+#define LV_COLOR_DEPTH 16
+
+/*Swap the 2 bytes of RGB565 color. Useful if the display has an 8-bit interface (e.g. SPI)*/
+#define LV_COLOR_16_SWAP 0
+
+/*Enable more complex drawing routines to manage screens transparency.
+ *Can be used if the UI is above another layer, e.g. an OSD menu or video player.
+ *Requires `LV_COLOR_DEPTH = 32` colors and the screen's `bg_opa` should be set to non LV_OPA_COVER value*/
+#define LV_COLOR_SCREEN_TRANSP 0
+
+/* Adjust color mix functions rounding. GPUs might calculate color mix (blending) differently.
+ * 0: round down, 64: round up from x.75, 128: round up from half, 192: round up from x.25, 254: round up */
+#define LV_COLOR_MIX_ROUND_OFS (LV_COLOR_DEPTH == 32 ? 0: 128)
+
+/*Images pixels with this color will not be drawn if they are chroma keyed)*/
+#define LV_COLOR_CHROMA_KEY lv_color_hex(0x00ff00)         /*pure green*/
+
+/*=========================
+   MEMORY SETTINGS
+ *=========================*/
+
+/*1: use custom malloc/free, 0: use the built-in `lv_mem_alloc()` and `lv_mem_free()`*/
+#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]*/
+
+    /*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*/
+    /*Instead of an address give a memory allocator that will be called to get a memory pool for LVGL. E.g. my_malloc*/
+    #if LV_MEM_ADR == 0
+        //#define LV_MEM_POOL_INCLUDE your_alloc_library  /* Uncomment if using an external allocator*/
+        //#define LV_MEM_POOL_ALLOC   your_alloc          /* Uncomment if using an external allocator*/
+    #endif
+
+#else       /*LV_MEM_CUSTOM*/
+    #define LV_MEM_CUSTOM_INCLUDE <stdlib.h>   /*Header for the dynamic memory function*/
+    #define LV_MEM_CUSTOM_ALLOC   malloc
+    #define LV_MEM_CUSTOM_FREE    free
+    #define LV_MEM_CUSTOM_REALLOC realloc
+#endif     /*LV_MEM_CUSTOM*/
+
+/*Number of the intermediate memory buffer used during rendering and other internal processing mechanisms.
+ *You will see an error log message if there wasn't enough buffers. */
+#define LV_MEM_BUF_MAX_NUM 16
+
+/*Use the standard `memcpy` and `memset` instead of LVGL's own functions. (Might or might not be faster).*/
+#define LV_MEMCPY_MEMSET_STD 0
+
+/*====================
+   HAL SETTINGS
+ *====================*/
+
+/*Default display refresh period. LVG will redraw changed areas with this period time*/
+#define LV_DISP_DEF_REFR_PERIOD 40      /*[ms]*/
+
+/*Input device read period in milliseconds*/
+#define LV_INDEV_DEF_READ_PERIOD 40     /*[ms]*/
+
+/*Use a custom tick source that tells the elapsed time in milliseconds.
+ *It removes the need to manually update the tick with `lv_tick_inc()`)*/
+#define LV_TICK_CUSTOM 1
+#if LV_TICK_CUSTOM
+    #define LV_TICK_CUSTOM_INCLUDE "Arduino.h"         /*Header for the system time function*/
+    #define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis())    /*Expression evaluating to current system time in ms*/
+#endif   /*LV_TICK_CUSTOM*/
+
+/*Default Dot Per Inch. Used to initialize default sizes such as widgets sized, style paddings.
+ *(Not so important, you can adjust it to modify default sizes and spaces)*/
+#define LV_DPI_DEF 130     /*[px/inch]*/
+
+/*=======================
+ * FEATURE CONFIGURATION
+ *=======================*/
+
+/*-------------
+ * Drawing
+ *-----------*/
+
+/*Enable complex draw engine.
+ *Required to draw shadow, gradient, rounded corners, circles, arc, skew lines, image transformations or any masks*/
+#define LV_DRAW_COMPLEX 1
+#if LV_DRAW_COMPLEX != 0
+
+    /*Allow buffering some shadow calculation.
+    *LV_SHADOW_CACHE_SIZE is the max. shadow size to buffer, where shadow size is `shadow_width + radius`
+    *Caching has LV_SHADOW_CACHE_SIZE^2 RAM cost*/
+    #define LV_SHADOW_CACHE_SIZE 0
+
+    /* Set number of maximally cached circle data.
+    * The circumference of 1/4 circle are saved for anti-aliasing
+    * radius * 4 bytes are used per circle (the most often used radiuses are saved)
+    * 0: to disable caching */
+    #define LV_CIRCLE_CACHE_SIZE 4
+#endif /*LV_DRAW_COMPLEX*/
+
+/*Default image cache size. Image caching keeps the images opened.
+ *If only the built-in image formats are used there is no real advantage of caching. (I.e. if no new image decoder is added)
+ *With complex image decoders (e.g. PNG or JPG) caching can save the continuous open/decode of images.
+ *However the opened images might consume additional RAM.
+ *0: to disable caching*/
+#define LV_IMG_CACHE_DEF_SIZE   0
+
+/*Number of stops allowed per gradient. Increase this to allow more stops.
+ *This adds (sizeof(lv_color_t) + 1) bytes per additional stop*/
+#define LV_GRADIENT_MAX_STOPS       2
+
+/*Default gradient buffer size.
+ *When LVGL calculates the gradient "maps" it can save them into a cache to avoid calculating them again.
+ *LV_GRAD_CACHE_DEF_SIZE sets the size of this cache in bytes.
+ *If the cache is too small the map will be allocated only while it's required for the drawing.
+ *0 mean no caching.*/
+#define LV_GRAD_CACHE_DEF_SIZE      0
+
+/*Allow dithering the gradients (to achieve visual smooth color gradients on limited color depth display)
+ *LV_DITHER_GRADIENT implies allocating one or two more lines of the object's rendering surface
+ *The increase in memory consumption is (32 bits * object width) plus 24 bits * object width if using error diffusion */
+#define LV_DITHER_GRADIENT      0
+#if LV_DITHER_GRADIENT
+    /*Add support for error diffusion dithering.
+     *Error diffusion dithering gets a much better visual result, but implies more CPU consumption and memory when drawing.
+     *The increase in memory consumption is (24 bits * object's width)*/
+    #define LV_DITHER_ERROR_DIFFUSION   0
+#endif
+
+/*Maximum buffer size to allocate for rotation.
+ *Only used if software rotation is enabled in the display driver.*/
+#define LV_DISP_ROT_MAX_BUF (10*1024)
+
+/*-------------
+ * GPU
+ *-----------*/
+
+/*Use STM32's DMA2D (aka Chrom Art) GPU*/
+#define LV_USE_GPU_STM32_DMA2D 0
+#if LV_USE_GPU_STM32_DMA2D
+    /*Must be defined to include path of CMSIS header of target processor
+    e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
+    #define LV_GPU_DMA2D_CMSIS_INCLUDE
+#endif
+
+/*Use NXP's PXP GPU iMX RTxxx platforms*/
+#define LV_USE_GPU_NXP_PXP 0
+#if LV_USE_GPU_NXP_PXP
+    /*1: Add default bare metal and FreeRTOS interrupt handling routines for PXP (lv_gpu_nxp_pxp_osa.c)
+    *   and call lv_gpu_nxp_pxp_init() automatically during lv_init(). Note that symbol SDK_OS_FREE_RTOS
+    *   has to be defined in order to use FreeRTOS OSA, otherwise bare-metal implementation is selected.
+    *0: lv_gpu_nxp_pxp_init() has to be called manually before lv_init()
+    */
+    #define LV_USE_GPU_NXP_PXP_AUTO_INIT 0
+#endif
+
+/*Use NXP's VG-Lite GPU iMX RTxxx platforms*/
+#define LV_USE_GPU_NXP_VG_LITE 0
+
+/*Use SDL renderer API*/
+#define LV_USE_GPU_SDL 0
+#if LV_USE_GPU_SDL
+    #define LV_GPU_SDL_INCLUDE_PATH <SDL2/SDL.h>
+    /*Texture cache size, 8MB by default*/
+    #define LV_GPU_SDL_LRU_SIZE (1024 * 1024 * 8)
+    /*Custom blend mode for mask drawing, disable if you need to link with older SDL2 lib*/
+    #define LV_GPU_SDL_CUSTOM_BLEND_MODE (SDL_VERSION_ATLEAST(2, 0, 6))
+#endif
+
+/*-------------
+ * Logging
+ *-----------*/
+
+/*Enable the log module*/
+#define LV_USE_LOG 1
+#if LV_USE_LOG
+
+    /*How important log should be added:
+    *LV_LOG_LEVEL_TRACE       A lot of logs to give detailed information
+    *LV_LOG_LEVEL_INFO        Log important events
+    *LV_LOG_LEVEL_WARN        Log if something unwanted happened but didn't cause a problem
+    *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
+
+    /*1: Print the log with 'printf';
+    *0: User need to register a callback with `lv_log_register_print_cb()`*/
+    #define LV_LOG_PRINTF 1
+
+    /*Enable/disable LV_LOG_TRACE in modules that produces a huge number of logs*/
+    #define LV_LOG_TRACE_MEM        1
+    #define LV_LOG_TRACE_TIMER      1
+    #define LV_LOG_TRACE_INDEV      1
+    #define LV_LOG_TRACE_DISP_REFR  1
+    #define LV_LOG_TRACE_EVENT      1
+    #define LV_LOG_TRACE_OBJ_CREATE 1
+    #define LV_LOG_TRACE_LAYOUT     1
+    #define LV_LOG_TRACE_ANIM       1
+
+#endif  /*LV_USE_LOG*/
+
+/*-------------
+ * Asserts
+ *-----------*/
+
+/*Enable asserts if an operation is failed or an invalid data is found.
+ *If LV_USE_LOG is enabled an error message will be printed on failure*/
+#define LV_USE_ASSERT_NULL          1   /*Check if the parameter is NULL. (Very fast, recommended)*/
+#define LV_USE_ASSERT_MALLOC        1   /*Checks is the memory is successfully allocated or no. (Very fast, recommended)*/
+#define LV_USE_ASSERT_STYLE         0   /*Check if the styles are properly initialized. (Very fast, recommended)*/
+#define LV_USE_ASSERT_MEM_INTEGRITY 0   /*Check the integrity of `lv_mem` after critical operations. (Slow)*/
+#define LV_USE_ASSERT_OBJ           0   /*Check the object's type and existence (e.g. not deleted). (Slow)*/
+
+/*Add a custom handler when assert happens e.g. to restart the MCU*/
+#define LV_ASSERT_HANDLER_INCLUDE <stdint.h>
+#define LV_ASSERT_HANDLER while(1);   /*Halt by default*/
+
+/*-------------
+ * Others
+ *-----------*/
+
+/*1: Show CPU usage and FPS count*/
+#define LV_USE_PERF_MONITOR 0
+#if LV_USE_PERF_MONITOR
+    #define LV_USE_PERF_MONITOR_POS LV_ALIGN_BOTTOM_RIGHT
+#endif
+
+/*1: Show the used memory and the memory fragmentation
+ * Requires LV_MEM_CUSTOM = 0*/
+#define LV_USE_MEM_MONITOR 0
+#if LV_USE_MEM_MONITOR
+    #define LV_USE_MEM_MONITOR_POS LV_ALIGN_BOTTOM_LEFT
+#endif
+
+/*1: Draw random colored rectangles over the redrawn areas*/
+#define LV_USE_REFR_DEBUG 0
+
+/*Change the built in (v)snprintf functions*/
+#define LV_SPRINTF_CUSTOM 0
+#if LV_SPRINTF_CUSTOM
+    #define LV_SPRINTF_INCLUDE <stdio.h>
+    #define lv_snprintf  snprintf
+    #define lv_vsnprintf vsnprintf
+#else   /*LV_SPRINTF_CUSTOM*/
+    #define LV_SPRINTF_USE_FLOAT 0
+#endif  /*LV_SPRINTF_CUSTOM*/
+
+#define LV_USE_USER_DATA 1
+
+/*Garbage Collector settings
+ *Used if lvgl is bound to higher level language and the memory is managed by that language*/
+#define LV_ENABLE_GC 0
+#if LV_ENABLE_GC != 0
+    #define LV_GC_INCLUDE "gc.h"                           /*Include Garbage Collector related things*/
+#endif /*LV_ENABLE_GC*/
+
+/*=====================
+ *  COMPILER SETTINGS
+ *====================*/
+
+/*For big endian systems set to 1*/
+#define LV_BIG_ENDIAN_SYSTEM 0
+
+/*Define a custom attribute to `lv_tick_inc` function*/
+#define LV_ATTRIBUTE_TICK_INC
+
+/*Define a custom attribute to `lv_timer_handler` function*/
+#define LV_ATTRIBUTE_TIMER_HANDLER
+
+/*Define a custom attribute to `lv_disp_flush_ready` function*/
+#define LV_ATTRIBUTE_FLUSH_READY
+
+/*Required alignment size for buffers*/
+#define LV_ATTRIBUTE_MEM_ALIGN_SIZE 1
+
+/*Will be added where memories needs to be aligned (with -Os data might not be aligned to boundary by default).
+ * E.g. __attribute__((aligned(4)))*/
+#define LV_ATTRIBUTE_MEM_ALIGN
+
+/*Attribute to mark large constant arrays for example font's bitmaps*/
+#define LV_ATTRIBUTE_LARGE_CONST
+
+/*Compiler prefix for a big array declaration in RAM*/
+#define LV_ATTRIBUTE_LARGE_RAM_ARRAY
+
+/*Place performance critical functions into a faster memory (e.g RAM)*/
+#define LV_ATTRIBUTE_FAST_MEM
+
+/*Prefix variables that are used in GPU accelerated operations, often these need to be placed in RAM sections that are DMA accessible*/
+#define LV_ATTRIBUTE_DMA
+
+/*Export integer constant to binding. This macro is used with constants in the form of LV_<CONST> that
+ *should also appear on LVGL binding API such as Micropython.*/
+#define LV_EXPORT_CONST_INT(int_value) struct _silence_gcc_warning /*The default value just prevents GCC warning*/
+
+/*Extend the default -32k..32k coordinate range to -4M..4M by using int32_t for coordinates instead of int16_t*/
+#define LV_USE_LARGE_COORD 0
+
+/*==================
+ *   FONT USAGE
+ *===================*/
+
+/*Montserrat fonts with ASCII range and some symbols using bpp = 4
+ *https://fonts.google.com/specimen/Montserrat*/
+#define LV_FONT_MONTSERRAT_8  0
+#define LV_FONT_MONTSERRAT_10 1
+#define LV_FONT_MONTSERRAT_12 0
+#define LV_FONT_MONTSERRAT_14 1
+#define LV_FONT_MONTSERRAT_16 0
+#define LV_FONT_MONTSERRAT_18 0
+#define LV_FONT_MONTSERRAT_20 0
+#define LV_FONT_MONTSERRAT_22 0
+#define LV_FONT_MONTSERRAT_24 0
+#define LV_FONT_MONTSERRAT_26 0
+#define LV_FONT_MONTSERRAT_28 1
+#define LV_FONT_MONTSERRAT_30 0
+#define LV_FONT_MONTSERRAT_32 0
+#define LV_FONT_MONTSERRAT_34 0
+#define LV_FONT_MONTSERRAT_36 0
+#define LV_FONT_MONTSERRAT_38 0
+#define LV_FONT_MONTSERRAT_40 0
+#define LV_FONT_MONTSERRAT_42 0
+#define LV_FONT_MONTSERRAT_44 0
+#define LV_FONT_MONTSERRAT_46 0
+#define LV_FONT_MONTSERRAT_48 0
+
+/*Demonstrate special features*/
+#define LV_FONT_MONTSERRAT_12_SUBPX      0
+#define LV_FONT_MONTSERRAT_28_COMPRESSED 0  /*bpp = 3*/
+#define LV_FONT_DEJAVU_16_PERSIAN_HEBREW 0  /*Hebrew, Arabic, Persian letters and all their forms*/
+#define LV_FONT_SIMSUN_16_CJK            0  /*1000 most common CJK radicals*/
+
+/*Pixel perfect monospace fonts*/
+#define LV_FONT_UNSCII_8  0
+#define LV_FONT_UNSCII_16 0
+
+/*Optionally declare custom fonts here.
+ *You can use these fonts as default font too and they will be available globally.
+ *E.g. #define LV_FONT_CUSTOM_DECLARE   LV_FONT_DECLARE(my_font_1) LV_FONT_DECLARE(my_font_2)*/
+#define LV_FONT_CUSTOM_DECLARE
+
+/*Always set a default font*/
+#define LV_FONT_DEFAULT &lv_font_montserrat_14
+
+/*Enable handling large font and/or fonts with a lot of characters.
+ *The limit depends on the font size, font face and bpp.
+ *Compiler error will be triggered if a font needs it.*/
+#define LV_FONT_FMT_TXT_LARGE 0
+
+/*Enables/disables support for compressed fonts.*/
+#define LV_USE_FONT_COMPRESSED 1
+
+/*Enable subpixel rendering*/
+#define LV_USE_FONT_SUBPX 0
+#if LV_USE_FONT_SUBPX
+    /*Set the pixel order of the display. Physical order of RGB channels. Doesn't matter with "normal" fonts.*/
+    #define LV_FONT_SUBPX_BGR 0  /*0: RGB; 1:BGR order*/
+#endif
+
+/*=================
+ *  TEXT SETTINGS
+ *=================*/
+
+/**
+ * Select a character encoding for strings.
+ * Your IDE or editor should have the same character encoding
+ * - LV_TXT_ENC_UTF8
+ * - LV_TXT_ENC_ASCII
+ */
+#define LV_TXT_ENC LV_TXT_ENC_UTF8
+
+/*Can break (wrap) texts on these chars*/
+#define LV_TXT_BREAK_CHARS " ,.;:-_"
+
+/*If a word is at least this long, will break wherever "prettiest"
+ *To disable, set to a value <= 0*/
+#define LV_TXT_LINE_BREAK_LONG_LEN 0
+
+/*Minimum number of characters in a long word to put on a line before a break.
+ *Depends on LV_TXT_LINE_BREAK_LONG_LEN.*/
+#define LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN 3
+
+/*Minimum number of characters in a long word to put on a line after a break.
+ *Depends on LV_TXT_LINE_BREAK_LONG_LEN.*/
+#define LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN 3
+
+/*The control character to use for signalling text recoloring.*/
+#define LV_TXT_COLOR_CMD "#"
+
+/*Support bidirectional texts. Allows mixing Left-to-Right and Right-to-Left texts.
+ *The direction will be processed according to the Unicode Bidirectional Algorithm:
+ *https://www.w3.org/International/articles/inline-bidi-markup/uba-basics*/
+#define LV_USE_BIDI 0
+#if LV_USE_BIDI
+    /*Set the default direction. Supported values:
+    *`LV_BASE_DIR_LTR` Left-to-Right
+    *`LV_BASE_DIR_RTL` Right-to-Left
+    *`LV_BASE_DIR_AUTO` detect texts base direction*/
+    #define LV_BIDI_BASE_DIR_DEF LV_BASE_DIR_AUTO
+#endif
+
+/*Enable Arabic/Persian processing
+ *In these languages characters should be replaced with an other form based on their position in the text*/
+#define LV_USE_ARABIC_PERSIAN_CHARS 0
+
+/*==================
+ *  WIDGET USAGE
+ *================*/
+
+/*Documentation of the widgets: https://docs.lvgl.io/latest/en/html/widgets/index.html*/
+
+#define LV_USE_ARC        1
+
+#define LV_USE_ANIMIMG    0
+
+#define LV_USE_BAR        1
+
+#define LV_USE_BTN        1
+
+#define LV_USE_BTNMATRIX  1
+
+#define LV_USE_CANVAS     1
+
+#define LV_USE_CHECKBOX   1
+
+#define LV_USE_DROPDOWN   1   /*Requires: lv_label*/
+
+#define LV_USE_IMG        1   /*Requires: lv_label*/
+
+#define LV_USE_LABEL      1
+#if LV_USE_LABEL
+    #define LV_LABEL_TEXT_SELECTION 0 /*Enable selecting text of the label*/
+    #define LV_LABEL_LONG_TXT_HINT 1  /*Store some extra info in labels to speed up drawing of very long texts*/
+#endif
+
+#define LV_USE_LINE       1
+
+#define LV_USE_ROLLER     1   /*Requires: lv_label*/
+#if LV_USE_ROLLER
+    #define LV_ROLLER_INF_PAGES 7 /*Number of extra "pages" when the roller is infinite*/
+#endif
+
+#define LV_USE_SLIDER     1   /*Requires: lv_bar*/
+
+#define LV_USE_SWITCH     1
+
+#define LV_USE_TEXTAREA   1   /*Requires: lv_label*/
+#if LV_USE_TEXTAREA != 0
+    #define LV_TEXTAREA_DEF_PWD_SHOW_TIME 1500    /*ms*/
+#endif
+
+#define LV_USE_TABLE      1
+
+/*==================
+ * EXTRA COMPONENTS
+ *==================*/
+
+/*-----------
+ * Widgets
+ *----------*/
+#define LV_USE_CALENDAR   0
+#if LV_USE_CALENDAR
+    #define LV_CALENDAR_WEEK_STARTS_MONDAY 0
+    #if LV_CALENDAR_WEEK_STARTS_MONDAY
+        #define LV_CALENDAR_DEFAULT_DAY_NAMES {"Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"}
+    #else
+        #define LV_CALENDAR_DEFAULT_DAY_NAMES {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
+    #endif
+
+    #define LV_CALENDAR_DEFAULT_MONTH_NAMES {"January", "February", "March",  "April", "May",  "June", "July", "August", "September", "October", "November", "December"}
+    #define LV_USE_CALENDAR_HEADER_ARROW 1
+    #define LV_USE_CALENDAR_HEADER_DROPDOWN 1
+#endif  /*LV_USE_CALENDAR*/
+
+#define LV_USE_MSG 1
+
+#define LV_USE_CHART      0
+
+#define LV_USE_COLORWHEEL 0
+
+#define LV_USE_IMGBTN     1
+
+#define LV_USE_KEYBOARD   1
+
+#define LV_USE_LED        0
+
+#define LV_USE_LIST       1
+
+#define LV_USE_MENU       0
+
+#define LV_USE_METER      0
+
+#define LV_USE_MSGBOX     0
+
+#define LV_USE_SPINBOX    0
+
+#define LV_USE_SPINNER    0
+
+#define LV_USE_TABVIEW    0
+
+#define LV_USE_TILEVIEW   0
+
+#define LV_USE_WIN        0
+
+#define LV_USE_SPAN       0
+#if LV_USE_SPAN
+    /*A line text can contain maximum num of span descriptor */
+    #define LV_SPAN_SNIPPET_STACK_SIZE 64
+#endif
+
+/*-----------
+ * Themes
+ *----------*/
+
+/*A simple, impressive and very complete theme*/
+#define LV_USE_THEME_DEFAULT 1
+#if LV_USE_THEME_DEFAULT
+
+    /*0: Light mode; 1: Dark mode*/
+    #define LV_THEME_DEFAULT_DARK 0
+
+    /*1: Enable grow on press*/
+    #define LV_THEME_DEFAULT_GROW 1
+
+    /*Default transition time in [ms]*/
+    #define LV_THEME_DEFAULT_TRANSITION_TIME 80
+#endif /*LV_USE_THEME_DEFAULT*/
+
+/*A very simple theme that is a good starting point for a custom theme*/
+#define LV_USE_THEME_BASIC 0
+
+/*A theme designed for monochrome displays*/
+#define LV_USE_THEME_MONO 0
+
+/*-----------
+ * Layouts
+ *----------*/
+
+/*A layout similar to Flexbox in CSS.*/
+#define LV_USE_FLEX 1
+
+/*A layout similar to Grid in CSS.*/
+#define LV_USE_GRID 0
+
+/*---------------------
+ * 3rd party libraries
+ *--------------------*/
+
+/*File system interfaces for common APIs */
+
+/*API for fopen, fread, etc*/
+#define LV_USE_FS_STDIO 0
+#if LV_USE_FS_STDIO
+    #define LV_FS_STDIO_LETTER '\0'     /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
+    #define LV_FS_STDIO_PATH ""         /*Set the working directory. File/directory paths will be appended to it.*/
+    #define LV_FS_STDIO_CACHE_SIZE  0   /*>0 to cache this number of bytes in lv_fs_read()*/
+#endif
+
+/*API for open, read, etc*/
+#define LV_USE_FS_POSIX 0
+#if LV_USE_FS_POSIX
+    #define LV_FS_POSIX_LETTER '\0'     /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
+    #define LV_FS_POSIX_PATH ""         /*Set the working directory. File/directory paths will be appended to it.*/
+    #define LV_FS_POSIX_CACHE_SIZE  0   /*>0 to cache this number of bytes in lv_fs_read()*/
+#endif
+
+/*API for CreateFile, ReadFile, etc*/
+#define LV_USE_FS_WIN32 0
+#if LV_USE_FS_WIN32
+    #define LV_FS_WIN32_LETTER  '\0'    /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
+    #define LV_FS_WIN32_PATH ""         /*Set the working directory. File/directory paths will be appended to it.*/
+    #define LV_FS_WIN32_CACHE_SIZE 0    /*>0 to cache this number of bytes in lv_fs_read()*/
+#endif
+
+/*API for FATFS (needs to be added separately). Uses f_open, f_read, etc*/
+#define LV_USE_FS_FATFS  0
+#if LV_USE_FS_FATFS
+    #define LV_FS_FATFS_LETTER '\0'     /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
+    #define LV_FS_FATFS_CACHE_SIZE 0    /*>0 to cache this number of bytes in lv_fs_read()*/
+#endif
+
+/*PNG decoder library*/
+#define LV_USE_PNG 0
+
+/*BMP decoder library*/
+#define LV_USE_BMP 0
+
+/* JPG + split JPG decoder library.
+ * Split JPG is a custom format optimized for embedded systems. */
+#define LV_USE_SJPG 0
+
+/*GIF decoder library*/
+#define LV_USE_GIF 0
+
+/*QR code library*/
+#define LV_USE_QRCODE 0
+
+/*FreeType library*/
+#define LV_USE_FREETYPE 0
+#if LV_USE_FREETYPE
+    /*Memory used by FreeType to cache characters [bytes] (-1: no caching)*/
+    #define LV_FREETYPE_CACHE_SIZE (16 * 1024)
+    #if LV_FREETYPE_CACHE_SIZE >= 0
+        /* 1: bitmap cache use the sbit cache, 0:bitmap cache use the image cache. */
+        /* sbit cache:it is much more memory efficient for small bitmaps(font size < 256) */
+        /* if font size >= 256, must be configured as image cache */
+        #define LV_FREETYPE_SBIT_CACHE 0
+        /* Maximum number of opened FT_Face/FT_Size objects managed by this cache instance. */
+        /* (0:use system defaults) */
+        #define LV_FREETYPE_CACHE_FT_FACES 0
+        #define LV_FREETYPE_CACHE_FT_SIZES 0
+    #endif
+#endif
+
+/*Rlottie library*/
+#define LV_USE_RLOTTIE 0
+
+/*FFmpeg library for image decoding and playing videos
+ *Supports all major image formats so do not enable other image decoder with it*/
+#define LV_USE_FFMPEG  0
+#if LV_USE_FFMPEG
+    /*Dump input information to stderr*/
+    #define LV_FFMPEG_AV_DUMP_FORMAT 0
+#endif
+
+/*-----------
+ * Others
+ *----------*/
+
+/*1: Enable API to take snapshot for object*/
+#define LV_USE_SNAPSHOT 0
+
+/*1: Enable Monkey test*/
+#define LV_USE_MONKEY   0
+
+/*1: Enable grid navigation*/
+#define LV_USE_GRIDNAV  0
+
+/*1: Enable lv_obj fragment*/
+#define LV_USE_FRAGMENT 0
+
+/*==================
+* EXAMPLES
+*==================*/
+
+/*Enable the examples to be built with the library*/
+#define LV_BUILD_EXAMPLES 0
+
+/*===================
+ * DEMO USAGE
+ ====================*/
+
+/*Show some widget. It might be required to increase `LV_MEM_SIZE` */
+#define LV_USE_DEMO_WIDGETS        1
+#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
+
+/*Benchmark your system*/
+#define LV_USE_DEMO_BENCHMARK   1
+
+/*Stress test for LVGL*/
+#define LV_USE_DEMO_STRESS      0
+
+/*Music player demo*/
+#define LV_USE_DEMO_MUSIC       0
+#if LV_USE_DEMO_MUSIC
+# define LV_DEMO_MUSIC_SQUARE       0
+# define LV_DEMO_MUSIC_LANDSCAPE    0
+# define LV_DEMO_MUSIC_ROUND        0
+# define LV_DEMO_MUSIC_LARGE        0
+# define LV_DEMO_MUSIC_AUTO_PLAY    0
+#endif
+
+/*--END OF LV_CONF_H--*/
+
+#endif /*LV_CONF_H*/
+
+#endif /*End of "Content enable"*/
--- a/CYD-Klipper/src/core/data_setup.cpp
+++ b/CYD-Klipper/src/core/data_setup.cpp
@@ -0,0 +1,182 @@
+
+#include "data_setup.h"
+#include "lvgl.h"
+#include "../conf/global_config.h"
+#include <HTTPClient.h>
+#include <ArduinoJson.h>
+
+const char *printer_state_messages[] = {
+    "Error",
+    "Idle",
+    "Printing"};
+
+Printer printer = {0};
+
+void send_gcode(bool wait, const char *gcode)
+{
+    char buff[256] = {};
+    sprintf(buff, "http://%s:%d/printer/gcode/script?script=%s", global_config.klipperHost, global_config.klipperPort, gcode);
+    HTTPClient client;
+    client.begin(buff);
+
+    if (!wait)
+    {
+        client.setTimeout(1000);
+    }
+
+    try
+    {
+        client.GET();
+    }
+    catch (...)
+    {
+        Serial.println("Failed to send gcode");
+    }
+}
+
+char filename_buff[512] = {0};
+
+void fetch_printer_data()
+{
+    char buff[256] = {};
+    sprintf(buff, "http://%s:%d/printer/objects/query?extruder&heater_bed&toolhead&gcode_move&virtual_sdcard&print_stats&webhooks", global_config.klipperHost, global_config.klipperPort);
+    HTTPClient client;
+    client.begin(buff);
+    int httpCode = client.GET();
+    if (httpCode == 200)
+    {
+        String payload = client.getString();
+        DynamicJsonDocument doc(4096);
+        deserializeJson(doc, payload);
+        auto status = doc["result"]["status"];
+        bool emit_state_update = false;
+        int printer_state = printer.state;
+
+        if (status.containsKey("webhooks"))
+        {
+            const char *state = status["webhooks"]["state"];
+            const char *message = status["webhooks"]["state_message"];
+
+            if (strcmp(state, "ready") == 0 && printer.state == PRINTER_STATE_ERROR)
+            {
+                printer_state = PRINTER_STATE_IDLE;
+            }
+            else if (strcmp(state, "shutdown") == 0 && printer.state != PRINTER_STATE_ERROR)
+            {
+                printer_state = PRINTER_STATE_ERROR;
+            }
+
+            if (printer.state_message == NULL || strcmp(printer.state_message, message))
+            {
+                if (printer.state_message != NULL)
+                {
+                    free(printer.state_message);
+                }
+
+                printer.state_message = (char *)malloc(strlen(message) + 1);
+                strcpy(printer.state_message, message);
+                emit_state_update = true;
+            }
+        }
+
+        if (printer_state != PRINTER_STATE_ERROR)
+        {
+            if (status.containsKey("extruder"))
+            {
+                printer.extruder_temp = status["extruder"]["temperature"];
+                printer.extruder_target_temp = status["extruder"]["target"];
+                bool can_extrude = status["extruder"]["can_extrude"];
+                printer.can_extrude = can_extrude == true;
+            }
+
+            if (status.containsKey("heater_bed"))
+            {
+                printer.bed_temp = status["heater_bed"]["temperature"];
+                printer.bed_target_temp = status["heater_bed"]["target"];
+            }
+
+            if (status.containsKey("toolhead"))
+            {
+                printer.position[0] = status["toolhead"]["position"][0];
+                printer.position[1] = status["toolhead"]["position"][1];
+                printer.position[2] = status["toolhead"]["position"][2];
+                const char *homed_axis = status["toolhead"]["homed_axes"];
+                printer.homed_axis = strcmp(homed_axis, "xyz") == 0;
+            }
+
+            if (status.containsKey("gcode_move"))
+            {
+                bool absolute_coords = status["gcode_move"]["absolute_coordinates"];
+                printer.absolute_coords = absolute_coords == true;
+            }
+
+            if (status.containsKey("virtual_sdcard"))
+            {
+                printer.print_progress = status["virtual_sdcard"]["progress"];
+            }
+
+            if (status.containsKey("print_stats"))
+            {
+                const char *filename = status["print_stats"]["filename"];
+                strcpy(filename_buff, filename);
+                printer.print_filename = filename_buff;
+                printer.elapsed_time_s = status["print_stats"]["print_duration"];
+                printer.filament_used_mm = status["print_stats"]["filament_used"];
+
+                const char *state = status["print_stats"]["state"];
+
+                if (strcmp(state, "printing") == 0)
+                {
+                    printer_state = PRINTER_STATE_PRINTING;
+                }
+                else if (strcmp(state, "paused") == 0)
+                {
+                    printer_state = PRINTER_STATE_PAUSED;
+                }
+                else if (strcmp(state, "complete") == 0 || strcmp(state, "cancelled") == 0 || strcmp(state, "standby") == 0)
+                {
+                    printer_state = PRINTER_STATE_IDLE;
+                }
+            }
+
+            // TODO: make a call to /server/files/metadata to get more accurate time estimates
+            // https://moonraker.readthedocs.io/en/latest/web_api/#server-administration
+
+            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;
+            }
+
+            lv_msg_send(DATA_PRINTER_DATA, &printer);
+        }
+
+        if (printer.state != printer_state || emit_state_update)
+        {
+            printer.state = printer_state;
+            lv_msg_send(DATA_PRINTER_STATE, &printer);
+        }
+    }
+    else
+    {
+        Serial.printf("Failed to fetch printer data: %d\n", httpCode);
+    }
+}
+
+long last_data_update = 0;
+const long data_update_interval = 1500;
+
+void data_loop()
+{
+    if (millis() - last_data_update < data_update_interval)
+        return;
+
+    last_data_update = millis();
+
+    fetch_printer_data();
+}
+
+void data_setup()
+{
+    printer.print_filename = filename_buff;
+    fetch_printer_data();
+}
--- a/CYD-Klipper/src/core/data_setup.h
+++ b/CYD-Klipper/src/core/data_setup.h
@@ -0,0 +1,37 @@
+#pragma once
+
+enum {
+    PRINTER_STATE_ERROR = 0,
+    PRINTER_STATE_IDLE = 1,
+    PRINTER_STATE_PRINTING = 2,
+    PRINTER_STATE_PAUSED = 3,
+};
+
+extern const char* printer_state_messages[];
+
+typedef struct _Printer {
+    unsigned char state;
+    char* state_message;
+    float extruder_temp;
+    float extruder_target_temp;
+    float bed_temp;
+    float bed_target_temp;
+    float position[3];
+    unsigned char can_extrude;
+    unsigned char homed_axis;
+    unsigned char absolute_coords;
+    float elapsed_time_s;
+    float remaining_time_s;
+    float filament_used_mm;
+    char* print_filename; // 0 -> 1
+    float print_progress;
+} Printer;
+
+extern Printer printer;
+
+#define DATA_PRINTER_STATE 1
+#define DATA_PRINTER_DATA 2
+
+void data_loop();
+void data_setup();
+void send_gcode(bool wait, const char* gcode);
--- a/CYD-Klipper/src/core/files_query.cpp
+++ b/CYD-Klipper/src/core/files_query.cpp
@@ -0,0 +1,63 @@
+#include <list>
+#include "files_query.h"
+#include "../conf/global_config.h"
+#include <HTTPClient.h>
+#include <ArduinoJson.h>
+#include <HardwareSerial.h>
+
+// Always has +1 entry with a null'd name
+FILESYSTEM_FILE* last_query = NULL;
+
+FILESYSTEM_FILE* get_files(){
+    if (last_query != NULL){
+        FILESYSTEM_FILE* current = last_query;
+
+        while (current->name != NULL){
+            free(current->name);
+            current += 1;
+        }
+
+        free(last_query);
+    }
+
+    std::list<FILESYSTEM_FILE> files;
+    char buff[256] = {};
+    sprintf(buff, "http://%s:%d/server/files/list", global_config.klipperHost, global_config.klipperPort);
+    HTTPClient client;
+    client.begin(buff);
+    int httpCode = client.GET();
+    int count = 0;
+    if (httpCode == 200){
+        String payload = client.getString();
+        DynamicJsonDocument doc(60000);
+        auto a = deserializeJson(doc, payload);
+        Serial.printf("JSON PARSE: %s\n", a.c_str());
+        auto result = doc["result"].as<JsonArray>();
+        for (auto file : result){
+            FILESYSTEM_FILE f = {0};
+            const char* path = file["path"];
+            f.name = (char*)malloc(strlen(path) + 1);
+            strcpy(f.name, path);
+            f.modified = file["modified"];
+            files.push_back(f);
+            count++;
+        }
+    }
+
+    //Serial.printf("Found %d files\n", count);
+    files.sort([](FILESYSTEM_FILE a, FILESYSTEM_FILE b){return a.modified < b.modified;});
+    files.reverse(); // TODO: Reverse is unneeded here, we can iterate backwards
+
+    size_t size = sizeof(FILESYSTEM_FILE) * (files.size() + 1);
+    FILESYSTEM_FILE* result = (FILESYSTEM_FILE*)malloc(size);
+    //Serial.printf("Allocated %d bytes\n", size);
+    last_query = result;
+    result[files.size()].name = NULL;
+
+    for (auto file : files){
+        *result = file;
+        result += 1;
+    }
+
+    return last_query;
+}
--- a/CYD-Klipper/src/core/files_query.h
+++ b/CYD-Klipper/src/core/files_query.h
@@ -0,0 +1,22 @@
+/*
+At some point it may be a fun challenge to try to implement a virtual folder structure, but not today.
+
+typedef struct _FILESYSTEM_FILE {
+    char* name;
+    char* parent_folder_name;
+    long level;
+} FILESYSTEM_FILE;
+
+typedef struct _FILESYSTEM_FOLDER {
+    char** files;
+    char* folder_path;
+    FILESYSTEM_FOLDER* folders;
+} FILESYSTEM_FOLDER;
+*/
+
+typedef struct _FILESYSTEM_FILE {
+    char* name;
+    float modified;
+} FILESYSTEM_FILE;
+
+FILESYSTEM_FILE* get_files();
--- a/CYD-Klipper/src/core/screen_driver.cpp
+++ b/CYD-Klipper/src/core/screen_driver.cpp
@@ -0,0 +1,230 @@
+#include "screen_driver.h"
+#include <SPI.h>
+#include <TFT_eSPI.h>
+#include "../conf/global_config.h"
+#include "lvgl.h"
+
+SPIClass touchscreen_spi = SPIClass(HSPI);
+XPT2046_Touchscreen touchscreen(XPT2046_CS, XPT2046_IRQ);
+
+uint32_t LV_EVENT_GET_COMP_CHILD;
+
+static lv_disp_draw_buf_t draw_buf;
+static lv_color_t buf[TFT_WIDTH * TFT_HEIGHT / 10];
+
+TFT_eSPI tft = TFT_eSPI();
+
+bool isScreenInSleep = false;
+lv_timer_t *screenSleepTimer;
+
+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 - 40;
+    int16_t yDist = 240 - 40;
+
+    global_config.screenCalXMult = (float)xDist / (float)(x2 - x1);
+    global_config.screenCalXOffset = 20.0 - ((float)x1 * global_config.screenCalXMult);
+
+    global_config.screenCalYMult = (float)yDist / (float)(y2 - y1);
+    global_config.screenCalYOffset = 20.0 - ((float)y1 * global_config.screenCalYMult);
+
+    global_config.screenCalibrated = true;
+    WriteGlobalConfig();
+}
+
+void screen_setBrightness(byte brightness)
+{
+    analogWrite(TFT_BL, brightness);
+}
+
+void set_screen_brightness()
+{
+    if (global_config.brightness < 32)
+        screen_setBrightness(255);
+    else
+        screen_setBrightness(global_config.brightness);
+}
+
+void screen_timer_wake()
+{
+    lv_timer_reset(screenSleepTimer);
+    isScreenInSleep = false;
+    set_screen_brightness();
+}
+
+void screen_timer_sleep(lv_timer_t *timer)
+{
+    screen_setBrightness(0);
+    isScreenInSleep = true;
+}
+
+void screen_timer_setup()
+{
+    screenSleepTimer = lv_timer_create(screen_timer_sleep, global_config.screenTimeout * 1000 * 60, NULL);
+    lv_timer_pause(screenSleepTimer);
+}
+
+void screen_timer_start()
+{
+    lv_timer_resume(screenSleepTimer);
+}
+
+void screen_timer_stop()
+{
+    lv_timer_pause(screenSleepTimer);
+}
+
+void screen_timer_period(uint32_t period)
+{
+    lv_timer_set_period(screenSleepTimer, period);
+}
+
+void set_screen_timer_period()
+{
+    screen_timer_period(global_config.screenTimeout * 1000 * 60);
+}
+
+void screen_lv_flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p)
+{
+    uint32_t w = (area->x2 - area->x1 + 1);
+    uint32_t h = (area->y2 - area->y1 + 1);
+
+    tft.startWrite();
+    tft.setAddrWindow(area->x1, area->y1, w, h);
+    tft.pushColors((uint16_t *)&color_p->full, w * h, true);
+    tft.endWrite();
+
+    lv_disp_flush_ready(disp);
+}
+
+void screen_lv_touchRead(lv_indev_drv_t *indev_driver, lv_indev_data_t *data)
+{
+
+    if (touchscreen.tirqTouched() && touchscreen.touched())
+    {
+        lv_timer_reset(screenSleepTimer);
+        // dont pass first touch after power on
+        if (isScreenInSleep)
+        {
+            screen_timer_wake();
+            while (touchscreen.touched())
+                ;
+            return;
+        }
+
+        TS_Point p = touchscreen_point();
+        data->state = LV_INDEV_STATE_PR;
+        data->point.x = p.x;
+        data->point.y = p.y;
+    }
+    else
+    {
+        data->state = LV_INDEV_STATE_REL;
+    }
+}
+
+void set_color_scheme(){
+    lv_disp_t *dispp = lv_disp_get_default();
+    lv_theme_t *theme = lv_theme_default_init(dispp, lv_palette_main(color_defs[global_config.color_scheme].primary_color), lv_palette_main(color_defs[global_config.color_scheme].secondary_color), !global_config.lightMode, LV_FONT_DEFAULT);
+    lv_disp_set_theme(dispp, theme);
+}
+
+void set_invert_display(){
+    tft.invertDisplay(global_config.invertColors);
+}
+
+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);
+
+    lv_init();
+
+    tft.init();
+    tft.setRotation(global_config.rotateScreen ? 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();
+
+    lv_disp_draw_buf_init(&draw_buf, buf, NULL, TFT_WIDTH * TFT_HEIGHT / 10);
+
+    /*Initialize the display*/
+    static lv_disp_drv_t disp_drv;
+    lv_disp_drv_init(&disp_drv);
+    disp_drv.hor_res = TFT_HEIGHT;
+    disp_drv.ver_res = TFT_WIDTH;
+    disp_drv.flush_cb = screen_lv_flush;
+    disp_drv.draw_buf = &draw_buf;
+    lv_disp_drv_register(&disp_drv);
+
+
+    /*Initialize the (dummy) input device driver*/
+    static lv_indev_drv_t indev_drv;
+    lv_indev_drv_init(&indev_drv);
+    indev_drv.type = LV_INDEV_TYPE_POINTER;
+    indev_drv.read_cb = screen_lv_touchRead;
+    lv_indev_drv_register(&indev_drv);
+
+    screen_timer_setup();
+    screen_timer_start();
+
+    /*Initialize the graphics library */
+    LV_EVENT_GET_COMP_CHILD = lv_event_register_id();
+    set_color_scheme();
+}
--- a/CYD-Klipper/src/core/screen_driver.h
+++ b/CYD-Klipper/src/core/screen_driver.h
@@ -0,0 +1,32 @@
+#pragma once
+// Adapted from https://github.com/xperiments-in/xtouch/blob/main/src/devices/2.8/screen.h
+
+#ifndef _SCREEN_DRIVER_INIT
+#define _SCREEN_DRIVER_INIT
+
+#include <XPT2046_Touchscreen.h>
+#include <TFT_eSPI.h>
+
+#define XPT2046_IRQ 36
+#define XPT2046_MOSI 32
+#define XPT2046_MISO 39
+#define XPT2046_CLK 25
+#define XPT2046_CS 33
+
+TS_Point touchscreen_point();
+void touchscreen_calibrate(bool force = false);
+void screen_setBrightness(byte brightness);
+void screen_timer_setup();
+void screen_timer_start();
+void screen_timer_stop();
+void screen_timer_period(uint32_t period);
+void set_color_scheme();
+void screen_setup();
+void set_invert_display();
+void screen_timer_wake();
+void set_screen_timer_period();
+void set_screen_brightness();
+
+extern TFT_eSPI tft;
+
+#endif // _SCREEN_DRIVER_INIT
--- a/CYD-Klipper/src/main.cpp
+++ b/CYD-Klipper/src/main.cpp
@@ -0,0 +1,62 @@
+#include "conf/global_config.h"
+#include "core/screen_driver.h"
+#include "ui/wifi_setup.h"
+#include "ui/ip_setup.h"
+#include "lvgl.h"
+#include "core/data_setup.h"
+#include "ui/main_ui.h"
+#include "ui/nav_buttons.h"
+
+static void event_handler(lv_event_t * e){
+    lv_event_code_t code = lv_event_get_code(e);
+
+    if(code == LV_EVENT_CLICKED) {
+        global_config.version = 0;
+        WriteGlobalConfig();
+        ESP.restart();
+    }
+}
+
+void setup() {
+    Serial.begin(115200);
+    Serial.println("Hello World");
+    LoadGlobalConfig();
+    screen_setup();
+    Serial.println("Screen init done");
+    
+    wifi_init();
+    ip_setup();
+    data_setup();
+
+    nav_style_setup();
+    main_ui_setup();
+
+    
+    
+    /*
+    lv_obj_clean(lv_scr_act());
+    
+    lv_obj_t * label;
+
+    lv_obj_t * btn1 = lv_btn_create(lv_scr_act());
+    lv_obj_add_event_cb(btn1, event_handler, LV_EVENT_CLICKED, NULL);
+    lv_obj_align(btn1, LV_ALIGN_CENTER, 0, 0);
+
+    label = lv_label_create(btn1);
+    lv_label_set_text(label, "Reset Configuration");
+    lv_obj_center(label);
+
+    lv_obj_t * slider = lv_slider_create(lv_scr_act());
+    lv_obj_set_width(slider, 200);
+    lv_obj_align(slider, LV_ALIGN_CENTER, 0, 40);
+    lv_slider_set_range(slider, 0, 100);
+    lv_slider_set_value(slider, 50, LV_ANIM_OFF);
+    */
+}
+
+void loop(){
+    wifi_ok();
+    data_loop();
+    lv_timer_handler();
+    lv_task_handler();
+}
--- a/CYD-Klipper/src/ui/ip_setup.cpp
+++ b/CYD-Klipper/src/ui/ip_setup.cpp
@@ -0,0 +1,101 @@
+#include "ip_setup.h"
+#include "../conf/global_config.h"
+#include "lvgl.h"
+#include <TFT_eSPI.h>
+#include <HTTPClient.h>
+
+bool connect_ok = false;
+lv_obj_t * ipEntry;
+lv_obj_t * portEntry;
+lv_obj_t * label = NULL;
+
+bool verify_ip(){
+    HTTPClient client;
+    String url = "http://" + String(global_config.klipperHost) + ":" + String(global_config.klipperPort) + "/printer/info";
+    int httpCode;
+    try {
+        Serial.println(url);
+        client.begin(url.c_str());
+        httpCode = client.GET();
+        return httpCode == 200;
+    }
+    catch (...) {
+        Serial.println("Failed to connect");
+        return false;
+    }
+}
+
+static void ta_event_cb(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_FOCUSED) {
+        lv_keyboard_set_textarea(kb, ta);
+        lv_obj_clear_flag(kb, LV_OBJ_FLAG_HIDDEN);
+    }
+    else if(code == LV_EVENT_DEFOCUSED) {
+        lv_keyboard_set_textarea(kb, NULL);
+        lv_obj_add_flag(kb, LV_OBJ_FLAG_HIDDEN);
+    }
+    else if (code == LV_EVENT_READY) 
+    {
+        strcpy(global_config.klipperHost, lv_textarea_get_text(ipEntry));
+        global_config.klipperPort = atoi(lv_textarea_get_text(portEntry));
+        bool result = verify_ip();
+        if (result)
+        {
+            global_config.ipConfigured = true;
+            WriteGlobalConfig();
+            connect_ok = true;
+        }
+        else
+        {
+            lv_label_set_text(label, "Failed to connect");
+        }
+    }
+}
+
+void ip_setup_inner(){
+    lv_obj_clean(lv_scr_act());
+
+    lv_obj_t * keyboard = lv_keyboard_create(lv_scr_act());
+    label = lv_label_create(lv_scr_act());
+    lv_label_set_text(label, "Enter Klipper IP and Port");
+    lv_obj_align(label, LV_ALIGN_TOP_LEFT, 10, 10 + 2);
+
+    ipEntry = lv_textarea_create(lv_scr_act());
+    lv_textarea_set_one_line(ipEntry, true);
+    lv_textarea_set_max_length(ipEntry, 63);
+    lv_textarea_set_text(ipEntry, "");
+    lv_obj_align(ipEntry, LV_ALIGN_TOP_LEFT, 10, 40);
+    lv_obj_add_event_cb(ipEntry, ta_event_cb, LV_EVENT_ALL, keyboard);
+    lv_obj_set_size(ipEntry, TFT_HEIGHT - 20 - 100, 60);
+
+    portEntry = lv_textarea_create(lv_scr_act());
+    lv_textarea_set_one_line(portEntry, true);
+    lv_textarea_set_max_length(portEntry, 5);
+    lv_textarea_set_text(portEntry, "80");
+    lv_obj_align(portEntry, LV_ALIGN_TOP_LEFT, TFT_HEIGHT - 20 - 80, 40);
+    lv_obj_add_event_cb(portEntry, ta_event_cb, LV_EVENT_ALL, keyboard);
+    lv_obj_set_size(portEntry, 90, 60);
+    
+    lv_keyboard_set_mode(keyboard, LV_KEYBOARD_MODE_NUMBER);
+    lv_keyboard_set_textarea(keyboard, ipEntry);
+}
+
+void ip_setup(){
+    connect_ok = false;
+
+    if (global_config.ipConfigured && verify_ip()){
+        return;
+    }
+
+    ip_setup_inner();
+
+    while (!connect_ok)
+    {
+        lv_timer_handler();
+        lv_task_handler();
+    }
+}
--- a/CYD-Klipper/src/ui/ip_setup.h
+++ b/CYD-Klipper/src/ui/ip_setup.h
@@ -0,0 +1 @@
+void ip_setup();
--- a/CYD-Klipper/src/ui/main_ui.cpp
+++ b/CYD-Klipper/src/ui/main_ui.cpp
@@ -0,0 +1,79 @@
+#include "main_ui.h"
+#include "../core/data_setup.h"
+#include "../conf/global_config.h"
+#include "../core/screen_driver.h"
+#include "lvgl.h"
+#include "nav_buttons.h"
+
+char extruder_temp_buff[20];
+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(){
+    lv_obj_clean(lv_scr_act());
+    
+    lv_obj_t * label;
+    label = lv_label_create(lv_scr_act());
+    lv_label_set_text(label, LV_SYMBOL_WARNING " Printer is not ready");
+    lv_obj_align(label, LV_ALIGN_TOP_LEFT, 10, 10);
+
+    label = lv_label_create(lv_scr_act());
+    lv_label_set_text(label, printer.state_message);
+    lv_obj_align(label, LV_ALIGN_TOP_LEFT, 10, 30);
+    lv_obj_set_size(label, TFT_HEIGHT - 20, TFT_WIDTH - 30);
+    lv_obj_clear_flag(label, LV_OBJ_FLAG_SCROLLABLE);
+    lv_label_set_long_mode(label, LV_LABEL_LONG_WRAP);
+
+    lv_obj_t * btn = lv_btn_create(lv_scr_act());
+    lv_obj_align(btn, LV_ALIGN_BOTTOM_LEFT, 10, -10);
+    lv_obj_set_size(btn, TFT_HEIGHT / 2 - 15, 30);
+    lv_obj_add_event_cb(btn, btn_click_restart, LV_EVENT_CLICKED, NULL);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, "Restart");
+    lv_obj_center(label);
+
+    btn = lv_btn_create(lv_scr_act());
+    lv_obj_align(btn, LV_ALIGN_BOTTOM_RIGHT, -10, -10);
+    lv_obj_set_size(btn, TFT_HEIGHT / 2 - 15, 30);
+    lv_obj_add_event_cb(btn, btn_click_firmware_restart, LV_EVENT_CLICKED, NULL);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, "Firmware Restart");
+    lv_obj_center(label);
+}
+
+void check_if_screen_needs_to_be_disabled(){
+    if (global_config.onDuringPrint && printer.state == PRINTER_STATE_PRINTING){
+        screen_timer_wake();
+        screen_timer_stop();
+    }
+    else {
+        screen_timer_start();
+    }  
+}
+
+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();
+    }
+    else {
+        nav_buttons_setup(0);
+    }
+}
+
+
+void main_ui_setup(){
+    lv_msg_subscribe(DATA_PRINTER_STATE, on_state_change, NULL);
+    on_state_change(NULL, NULL);
+}
--- a/CYD-Klipper/src/ui/main_ui.h
+++ b/CYD-Klipper/src/ui/main_ui.h
@@ -0,0 +1,2 @@
+void main_ui_setup();
+void check_if_screen_needs_to_be_disabled();
--- a/CYD-Klipper/src/ui/nav_buttons.cpp
+++ b/CYD-Klipper/src/ui/nav_buttons.cpp
@@ -0,0 +1,183 @@
+#include "lvgl.h"
+#include "panels/panel.h"
+#include "../core/data_setup.h"
+#include "nav_buttons.h"
+#include <HTTPClient.h>
+
+static lv_style_t nav_button_style;
+
+static char temp_buffer[10];
+static char z_pos_buffer[10];
+static char time_buffer[10];
+
+static lv_style_t nav_button_text_style;
+
+static void update_printer_data_z_pos(lv_event_t * e) {
+    lv_obj_t * label = lv_event_get_target(e);
+
+    sprintf(z_pos_buffer, "Z%.2f", printer.position[2]);
+    lv_label_set_text(label, z_pos_buffer);
+}
+
+static void update_printer_data_temp(lv_event_t * e) {
+    lv_obj_t * label = lv_event_get_target(e);
+
+    sprintf(temp_buffer, "%.0f/%.0f", printer.extruder_temp, printer.bed_temp);
+    lv_label_set_text(label, temp_buffer);
+}
+
+static void update_printer_data_time(lv_event_t * e){
+    lv_obj_t * label = lv_event_get_target(e);
+
+    if (printer.state == PRINTER_STATE_IDLE){
+        lv_label_set_text(label, "Idle");
+        return;
+    }
+
+    if (printer.state == PRINTER_STATE_PAUSED){
+        lv_label_set_text(label, "Paused");
+        return;
+    }
+
+    unsigned long time = printer.remaining_time_s;
+    unsigned long hours = time / 3600;
+    unsigned long minutes = (time % 3600) / 60;
+    unsigned long seconds = (time % 3600) % 60;
+
+    if (hours >= 10){
+        sprintf(time_buffer, "%luh", hours);
+    } else if (hours >= 1){
+        sprintf(time_buffer, "%luh%02lum", hours, minutes);
+    } else {
+        sprintf(time_buffer, "%lum", minutes);
+    }
+
+    lv_label_set_text(label, time_buffer);
+}
+
+static void btn_click_files(lv_event_t * e){
+    nav_buttons_setup(0);
+}
+
+static void btn_click_move(lv_event_t * e){
+    nav_buttons_setup(1);
+}
+
+static void btn_click_extrude(lv_event_t * e){
+    nav_buttons_setup(2);
+}
+
+static void btn_click_settings(lv_event_t * e){
+    nav_buttons_setup(3);
+}
+
+void nav_buttons_setup(unsigned char active_panel){
+    lv_obj_clean(lv_scr_act());
+    lv_obj_clear_flag(lv_scr_act(), LV_OBJ_FLAG_SCROLLABLE);
+    sprintf(temp_buffer, "%.0f/%.0f", printer.extruder_temp, printer.bed_temp);
+    sprintf(z_pos_buffer, "Z%.2f", printer.position[2]);
+
+    const int button_width = 40;
+    const int button_height = 60;
+    const int icon_text_spacing = 10;
+
+    // Files/Print
+    lv_obj_t * btn = lv_btn_create(lv_scr_act());
+    lv_obj_set_size(btn, button_width, button_height);
+    lv_obj_align(btn, LV_ALIGN_TOP_LEFT, 0, 0);
+    lv_obj_add_style(btn, &nav_button_style, 0);
+    lv_obj_add_event_cb(btn, btn_click_files, LV_EVENT_CLICKED, NULL);
+
+    lv_obj_t * label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_COPY);
+    lv_obj_align(label, LV_ALIGN_CENTER, 0, -1 * icon_text_spacing);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, "Idle");
+    lv_obj_align(label, LV_ALIGN_CENTER, 0, icon_text_spacing);
+    lv_obj_add_style(label, &nav_button_text_style, 0);
+    lv_obj_add_event_cb(label, update_printer_data_time, LV_EVENT_MSG_RECEIVED, NULL);
+    lv_msg_subsribe_obj(DATA_PRINTER_DATA, label, NULL);
+
+    // Move
+    btn = lv_btn_create(lv_scr_act());
+    lv_obj_set_size(btn, button_width, button_height);
+    lv_obj_align(btn, LV_ALIGN_TOP_LEFT, 0, button_height);
+    lv_obj_add_style(btn, &nav_button_style, 0);
+    lv_obj_add_event_cb(btn, btn_click_move, LV_EVENT_CLICKED, NULL);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_CHARGE);
+    lv_obj_align(label, LV_ALIGN_CENTER, 0, -1 * icon_text_spacing);
+    
+    label = lv_label_create(btn);
+    lv_label_set_text(label, z_pos_buffer);
+    lv_obj_align(label, LV_ALIGN_CENTER, 0, icon_text_spacing);
+    lv_obj_add_event_cb(label, update_printer_data_z_pos, LV_EVENT_MSG_RECEIVED, NULL);
+    lv_msg_subsribe_obj(DATA_PRINTER_DATA, label, NULL);
+    lv_obj_add_style(label, &nav_button_text_style, 0);
+
+    // Extrude/Temp
+    btn = lv_btn_create(lv_scr_act());
+    lv_obj_set_size(btn, button_width, button_height);
+    lv_obj_align(btn, LV_ALIGN_TOP_LEFT, 0, button_height * 2);
+    lv_obj_add_style(btn, &nav_button_style, 0);
+    lv_obj_add_event_cb(btn, btn_click_extrude, LV_EVENT_CLICKED, NULL);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_WARNING);
+    lv_obj_align(label, LV_ALIGN_CENTER, 0, -1 * icon_text_spacing);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, temp_buffer);
+    lv_obj_align(label, LV_ALIGN_CENTER, 0, icon_text_spacing);
+    lv_obj_add_event_cb(label, update_printer_data_temp, LV_EVENT_MSG_RECEIVED, NULL);
+    lv_msg_subsribe_obj(DATA_PRINTER_DATA, label, NULL);
+    lv_obj_add_style(label, &nav_button_text_style, 0);
+
+    // Settings
+    btn = lv_btn_create(lv_scr_act());
+    lv_obj_set_size(btn, button_width, button_height);
+    lv_obj_align(btn, LV_ALIGN_TOP_LEFT, 0, button_height * 3);
+    lv_obj_add_style(btn, &nav_button_style, 0);
+    lv_obj_add_event_cb(btn, btn_click_settings, LV_EVENT_CLICKED, NULL);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_SETTINGS);
+    lv_obj_align(label, LV_ALIGN_CENTER, 0, -1 * icon_text_spacing);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, "Screen");
+    lv_obj_align(label, LV_ALIGN_CENTER, 0, icon_text_spacing);
+    lv_obj_add_style(label, &nav_button_text_style, 0);
+
+    lv_obj_t * panel = lv_obj_create(lv_scr_act());
+    lv_obj_set_size(panel, TFT_HEIGHT - button_width, TFT_WIDTH);
+    lv_obj_align(panel, LV_ALIGN_TOP_RIGHT, 0, 0);
+    lv_obj_set_style_border_width(panel, 0, 0);
+    lv_obj_set_style_bg_opa(panel, LV_OPA_TRANSP, 0);
+    lv_obj_set_style_pad_all(panel, 0, 0);
+
+    switch (active_panel){
+        case 0:
+            print_panel_init(panel);
+            break;
+        case 1:
+            move_panel_init(panel);
+            break;
+        case 2:
+            temp_panel_init(panel);
+            break;
+        case 3:
+            settings_panel_init(panel);
+            break;
+    }
+}
+
+void nav_style_setup(){
+    lv_style_init(&nav_button_style);
+    lv_style_set_radius(&nav_button_style, 0);
+
+    lv_style_init(&nav_button_text_style);
+    lv_style_set_text_font(&nav_button_text_style, &lv_font_montserrat_10);
+}
--- a/CYD-Klipper/src/ui/nav_buttons.h
+++ b/CYD-Klipper/src/ui/nav_buttons.h
@@ -0,0 +1,2 @@
+void nav_buttons_setup(unsigned char active_panel);
+void nav_style_setup();
--- a/CYD-Klipper/src/ui/panels/move_panel.cpp
+++ b/CYD-Klipper/src/ui/panels/move_panel.cpp
@@ -0,0 +1,209 @@
+#include "lvgl.h"
+#include "panel.h"
+#include "../../core/data_setup.h"
+#include <TFT_eSPI.h>
+
+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");
+    }
+
+    const char * space = "%20";
+
+    sprintf(gcode, "G1%s%s%s%.1f%sF6000", space, axis, extra, amount, space);
+    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);
+}
+
+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);
+}
+
+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);
+}
+
+char x_pos_buff[12];
+
+static void x_pos_update(lv_event_t * e){
+    lv_obj_t * label = lv_event_get_target(e);
+    sprintf(x_pos_buff, "X: %.1f", printer.position[0]);
+    lv_label_set_text(label, x_pos_buff);
+}
+
+char y_pos_buff[12];
+
+static void y_pos_update(lv_event_t * e){
+    lv_obj_t * label = lv_event_get_target(e);
+    sprintf(y_pos_buff, "Y: %.1f", printer.position[1]);
+    lv_label_set_text(label, y_pos_buff);
+}
+
+char z_pos_buff[12];
+
+static void z_pos_update(lv_event_t * e){
+    lv_obj_t * label = lv_event_get_target(e);
+    sprintf(z_pos_buff, "Z: %.2f", printer.position[2]);
+    lv_label_set_text(label, z_pos_buff);
+}
+
+lv_event_cb_t button_callbacks[] = {x_line_button_press, y_line_button_press, z_line_button_press};
+lv_event_cb_t position_callbacks[] = {x_pos_update, y_pos_update, z_pos_update};
+
+const float xy_offsets[] = {-100, -10, -1, 1, 10, 100};
+const float z_offsets[] = {-25, -1, -0.1, 0.1, 1, 25};
+const float* offsets[] = {
+    xy_offsets,
+    xy_offsets,
+    z_offsets
+};
+
+const char* xy_offset_labels[] = {"-100", "-10", "-1", "+1", "+10", "+100"};
+const char* z_offset_labels[] = {"-25", "-1", "-0.1", "+0.1", "+1", "+25"};
+
+const char** offset_labels[] = {
+    xy_offset_labels,
+    xy_offset_labels,
+    z_offset_labels
+};
+
+static void home_button_click(lv_event_t * e) {
+    if (printer.state == PRINTER_STATE_PRINTING)
+        return;
+
+    send_gcode(false, "G28");
+} 
+
+static void disable_steppers_click(lv_event_t * e) {
+    if (printer.state == PRINTER_STATE_PRINTING)
+        return;
+
+    send_gcode(true, "M18");
+} 
+
+static void stepper_state_update(lv_event_t * e){
+    lv_obj_t * label = lv_event_get_target(e);
+    lv_label_set_text(label, printer.homed_axis ? LV_SYMBOL_HOME " Steppers locked" : LV_SYMBOL_EYE_CLOSE " Steppers unlocked");
+}
+
+void move_panel_init(lv_obj_t* panel){
+    lv_obj_clear_flag(panel, LV_OBJ_FLAG_SCROLLABLE);
+    const int button_size = 40;
+    const int button_size_vertical = 40;
+    const int button_padding = 2;
+    const int x_offset = 15;
+    int y_pos = 75;
+
+    auto panel_width = TFT_HEIGHT - 40;
+
+    lv_obj_t * home_button = lv_btn_create(panel);
+    lv_obj_align(home_button, LV_ALIGN_TOP_LEFT, 10, 5);
+    lv_obj_add_event_cb(home_button, home_button_click, LV_EVENT_CLICKED, NULL);
+    lv_obj_set_size(home_button, panel_width / 2 - 15, 30);
+
+    lv_obj_t * home_label = lv_label_create(home_button);
+    lv_label_set_text(home_label, LV_SYMBOL_HOME "Home Axis");
+    lv_obj_center(home_label);
+
+    lv_obj_t * disable_steppers_button = lv_btn_create(panel);
+    lv_obj_align(disable_steppers_button, LV_ALIGN_TOP_RIGHT, -10, 5);
+    lv_obj_add_event_cb(disable_steppers_button, disable_steppers_click, LV_EVENT_CLICKED, NULL);
+    lv_obj_set_size(disable_steppers_button, panel_width / 2 - 15, 30);
+
+    lv_obj_t * disable_steppers_label = lv_label_create(disable_steppers_button);
+    lv_label_set_text(disable_steppers_label, LV_SYMBOL_EYE_CLOSE "Disable Step");
+    lv_obj_center(disable_steppers_label);
+
+    lv_obj_t * label = lv_label_create(panel);
+    lv_label_set_text(label, "???");
+    lv_obj_align(label, LV_ALIGN_TOP_MID, 0, 40);
+    lv_obj_add_event_cb(label, stepper_state_update, LV_EVENT_MSG_RECEIVED, NULL);
+    lv_msg_subsribe_obj(DATA_PRINTER_DATA, label, NULL);
+
+    for (int i = 0; i < 3; i++) {
+        lv_obj_t * btn = lv_btn_create(panel);
+        lv_obj_set_size(btn, button_size, button_size_vertical);
+        lv_obj_align(btn, LV_ALIGN_TOP_LEFT, x_offset, y_pos);
+        lv_obj_add_event_cb(btn, button_callbacks[i], LV_EVENT_CLICKED, (void*)(offsets[i]));
+
+        lv_obj_t * label = lv_label_create(btn);
+        lv_label_set_text(label, offset_labels[i][0]);
+        lv_obj_center(label);
+
+        btn = lv_btn_create(panel);
+        lv_obj_set_size(btn, button_size, button_size_vertical);
+        lv_obj_align(btn, LV_ALIGN_TOP_LEFT, x_offset + (button_size + button_padding) * 1, y_pos);
+        lv_obj_add_event_cb(btn, button_callbacks[i], LV_EVENT_CLICKED, (void*)(offsets[i] + 1));
+
+        label = lv_label_create(btn);
+        lv_label_set_text(label, offset_labels[i][1]);
+        lv_obj_center(label);
+
+        btn = lv_btn_create(panel);
+        lv_obj_set_size(btn, button_size, button_size_vertical);
+        lv_obj_align(btn, LV_ALIGN_TOP_LEFT, x_offset + (button_size + button_padding) * 2, y_pos);
+        lv_obj_add_event_cb(btn, button_callbacks[i], LV_EVENT_CLICKED, (void*)(offsets[i] + 2));
+
+        label = lv_label_create(btn);
+        lv_label_set_text(label, offset_labels[i][2]);
+        lv_obj_center(label);
+
+        btn = lv_btn_create(panel);
+        lv_obj_set_size(btn, button_size, button_size_vertical);
+        lv_obj_align(btn, LV_ALIGN_TOP_LEFT, x_offset + (button_size + button_padding) * 3, y_pos);
+        lv_obj_add_event_cb(btn, button_callbacks[i], LV_EVENT_CLICKED, (void*)(offsets[i] + 3));
+
+        label = lv_label_create(btn);
+        lv_label_set_text(label, offset_labels[i][3]);
+        lv_obj_center(label);
+
+        btn = lv_btn_create(panel);
+        lv_obj_set_size(btn, button_size, button_size_vertical);
+        lv_obj_align(btn, LV_ALIGN_TOP_LEFT, x_offset + (button_size + button_padding) * 4, y_pos);
+        lv_obj_add_event_cb(btn, button_callbacks[i], LV_EVENT_CLICKED, (void*)(offsets[i] + 4));
+
+        label = lv_label_create(btn);
+        lv_label_set_text(label, offset_labels[i][4]);
+        lv_obj_center(label);
+
+        btn = lv_btn_create(panel);
+        lv_obj_set_size(btn, button_size, button_size_vertical);
+        lv_obj_align(btn, LV_ALIGN_TOP_LEFT, x_offset + (button_size + button_padding) * 5, y_pos);
+        lv_obj_add_event_cb(btn, button_callbacks[i], LV_EVENT_CLICKED, (void*)(offsets[i] + 5));
+        
+        label = lv_label_create(btn);
+        lv_label_set_text(label, offset_labels[i][5]);
+        lv_obj_center(label);
+
+        label = lv_label_create(panel);
+        lv_label_set_text(label, "???");
+        lv_obj_align(label, LV_ALIGN_TOP_LEFT, x_offset, y_pos - 15);\
+        lv_obj_add_event_cb(label, position_callbacks[i], LV_EVENT_MSG_RECEIVED, NULL);
+        lv_msg_subsribe_obj(DATA_PRINTER_DATA, label, NULL);
+
+        y_pos += 60;
+    }
+
+    lv_msg_send(DATA_PRINTER_DATA, &printer);
+}
--- a/CYD-Klipper/src/ui/panels/panel.h
+++ b/CYD-Klipper/src/ui/panels/panel.h
@@ -0,0 +1,9 @@
+#include "lvgl.h"
+
+#define SIZEOF(arr) (sizeof(arr) / sizeof(*arr))
+
+void settings_panel_init(lv_obj_t* panel);
+void temp_panel_init(lv_obj_t* panel);
+void print_panel_init(lv_obj_t* panel);
+void move_panel_init(lv_obj_t* panel);
+void progress_panel_init(lv_obj_t* panel);
--- a/CYD-Klipper/src/ui/panels/print_panel.cpp
+++ b/CYD-Klipper/src/ui/panels/print_panel.cpp
@@ -0,0 +1,88 @@
+#include "lvgl.h"
+#include "panel.h"
+#include "../../core/data_setup.h"
+#include "../../core/files_query.h"
+#include "../../conf/global_config.h"
+#include <HardwareSerial.h>
+#include <HTTPClient.h>
+
+FILESYSTEM_FILE* selected_file = NULL;
+
+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));
+    sprintf(buff, "http://%s:%d/printer/print/start?filename=%s", global_config.klipperHost, global_config.klipperPort, selected_file->name);
+    HTTPClient client;
+    client.begin(buff);
+    int httpCode = client.POST("");
+    Serial.printf("Print start: HTTP %d\n", httpCode);
+}
+
+static void btn_print_back(lv_event_t * e){
+    lv_obj_t * panel = (lv_obj_t*)lv_event_get_user_data(e);
+    lv_obj_del(panel);
+}
+
+static void btn_print_file_verify(lv_event_t * e){
+    lv_obj_t * btn = lv_event_get_target(e);
+    selected_file = (FILESYSTEM_FILE*)lv_event_get_user_data(e);
+    
+    lv_obj_t * panel = lv_obj_create(lv_scr_act());
+    lv_obj_set_size(panel, TFT_HEIGHT - 40, TFT_WIDTH - 30);
+    lv_obj_align(panel, LV_ALIGN_CENTER, 0, 0);
+
+    lv_obj_t * label = lv_label_create(panel);
+    lv_label_set_text(label, "Print File");
+    lv_obj_align(label, LV_ALIGN_TOP_LEFT, 0, 0);
+
+    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, TFT_HEIGHT - 90);
+    lv_label_set_long_mode(label, LV_LABEL_LONG_WRAP);
+
+    btn = lv_btn_create(panel);
+    lv_obj_align(btn, LV_ALIGN_BOTTOM_LEFT, 10, -10);
+    lv_obj_set_size(btn, 40, 40);
+    lv_obj_add_event_cb(btn, btn_print_back, LV_EVENT_CLICKED, panel);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_CLOSE);
+    lv_obj_center(label);
+
+    btn = lv_btn_create(panel);
+    lv_obj_align(btn, LV_ALIGN_BOTTOM_RIGHT, -10, -10);
+    lv_obj_set_size(btn, 40, 40);
+    lv_obj_add_event_cb(btn, btn_print_file, LV_EVENT_CLICKED, panel);
+    
+    label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_OK);
+    lv_obj_center(label);
+}
+
+void print_panel_init(lv_obj_t* panel){
+    if (printer.state == PRINTER_STATE_PRINTING || printer.state == PRINTER_STATE_PAUSED){
+        progress_panel_init(panel);
+        return;
+    }
+
+    auto panel_width = TFT_HEIGHT - 40;
+    auto panel_height_margin = TFT_WIDTH - 10;
+    auto panel_width_margin = panel_width - 10;
+
+    lv_obj_t * list = lv_list_create(panel);
+    lv_obj_set_size(list, panel_width_margin, panel_height_margin);
+    lv_obj_align(list, LV_ALIGN_CENTER, 0, 0);
+
+    FILESYSTEM_FILE* files = get_files();
+    int count = 0;
+    while (files->name != NULL && count <= 20){
+        lv_obj_t * btn = lv_list_add_btn(list, LV_SYMBOL_FILE, files->name);
+        lv_obj_add_event_cb(btn, btn_print_file_verify, LV_EVENT_CLICKED, (void*)files);
+
+        files += 1;
+        count++;
+    }
+}
--- a/CYD-Klipper/src/ui/panels/progress_panel.cpp
+++ b/CYD-Klipper/src/ui/panels/progress_panel.cpp
@@ -0,0 +1,122 @@
+#include "panel.h"
+#include "../../core/data_setup.h"
+#include <stdio.h>
+
+char time_buffer[12];
+
+char* time_display(unsigned long time){
+    unsigned long hours = time / 3600;
+    unsigned long minutes = (time % 3600) / 60;
+    unsigned long seconds = (time % 3600) % 60;
+    sprintf(time_buffer, "%02lu:%02lu:%02lu", hours, minutes, seconds);
+    return time_buffer;
+}
+
+static void progress_bar_update(lv_event_t* e){
+    lv_obj_t * bar = lv_event_get_target(e);
+    lv_bar_set_value(bar, printer.print_progress * 100, LV_ANIM_ON);
+}
+
+static void update_printer_data_elapsed_time(lv_event_t * e){
+    lv_obj_t * label = lv_event_get_target(e);
+    lv_label_set_text(label, time_display(printer.elapsed_time_s));
+}
+
+static void update_printer_data_remaining_time(lv_event_t * e){
+    lv_obj_t * label = lv_event_get_target(e);
+    lv_label_set_text(label, time_display(printer.remaining_time_s));
+}
+
+static void update_printer_data_percentage(lv_event_t * e){
+    lv_obj_t * label = lv_event_get_target(e);
+    char percentage_buffer[12];
+    sprintf(percentage_buffer, "%.2f%%", printer.print_progress * 100);
+    lv_label_set_text(label, percentage_buffer);
+}
+
+static void btn_click_stop(lv_event_t * e){
+    send_gcode(true, "CANCEL_PRINT");
+}
+
+static void btn_click_pause(lv_event_t * e){
+    send_gcode(true, "PAUSE");
+}
+
+static void btn_click_resume(lv_event_t * e){
+    send_gcode(true, "RESUME");
+}
+
+void progress_panel_init(lv_obj_t* panel){
+    auto panel_width = TFT_HEIGHT - 40;
+    auto panel_width_margin = panel_width - 30;
+
+    // Filename
+    lv_obj_t * label = lv_label_create(panel);
+    lv_label_set_text(label, printer.print_filename);
+    lv_obj_align(label, LV_ALIGN_CENTER, 0, -40);
+    lv_label_set_long_mode(label, LV_LABEL_LONG_SCROLL_CIRCULAR);
+    lv_obj_set_width(label, panel_width_margin);
+    
+    // Progress Bar
+    lv_obj_t * bar = lv_bar_create(panel);
+    lv_obj_align(bar, LV_ALIGN_CENTER, 0, 0);
+    lv_obj_set_size(bar, panel_width_margin, 20);
+    lv_obj_add_event_cb(bar, progress_bar_update, LV_EVENT_MSG_RECEIVED, NULL);
+    lv_msg_subsribe_obj(DATA_PRINTER_DATA, bar, NULL);
+
+    // Elapsed Time
+    label = lv_label_create(panel);
+    lv_label_set_text(label, "???");
+    lv_obj_align(label, LV_ALIGN_LEFT_MID, 10, 20);
+    lv_obj_add_event_cb(label, update_printer_data_elapsed_time, LV_EVENT_MSG_RECEIVED, NULL);
+    lv_msg_subsribe_obj(DATA_PRINTER_DATA, label, NULL);
+
+    // Remaining Time
+    label = lv_label_create(panel);
+    lv_label_set_text(label, "???");
+    lv_obj_align(label, LV_ALIGN_RIGHT_MID, -10, 20);
+    lv_obj_add_event_cb(label, update_printer_data_remaining_time, LV_EVENT_MSG_RECEIVED, NULL);
+    lv_msg_subsribe_obj(DATA_PRINTER_DATA, label, NULL);
+
+    // Percentage
+    label = lv_label_create(panel);
+    lv_label_set_text(label, "???");
+    lv_obj_align(label, LV_ALIGN_CENTER, 0, 20);
+    lv_obj_add_event_cb(label, update_printer_data_percentage, LV_EVENT_MSG_RECEIVED, NULL);
+    lv_msg_subsribe_obj(DATA_PRINTER_DATA, label, NULL);
+
+    // Stop Button
+    lv_obj_t * btn = lv_btn_create(panel);
+    lv_obj_align(btn, LV_ALIGN_BOTTOM_RIGHT, -10, -10);
+    lv_obj_set_size(btn, 40, 40);
+    lv_obj_add_event_cb(btn, btn_click_stop, LV_EVENT_CLICKED, NULL);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_STOP);
+    lv_obj_center(label);
+
+    // Resume Button
+    if (printer.state == PRINTER_STATE_PAUSED){
+        btn = lv_btn_create(panel);
+        lv_obj_align(btn, LV_ALIGN_BOTTOM_RIGHT, -60, -10);
+        lv_obj_set_size(btn, 40, 40);
+        lv_obj_add_event_cb(btn, btn_click_resume, LV_EVENT_CLICKED, NULL);
+
+        label = lv_label_create(btn);
+        lv_label_set_text(label, LV_SYMBOL_PLAY);
+        lv_obj_center(label);
+    }
+    // Pause Button
+    else {
+        btn = lv_btn_create(panel);
+        lv_obj_align(btn, LV_ALIGN_BOTTOM_RIGHT, -60, -10);
+        lv_obj_set_size(btn, 40, 40);
+        lv_obj_add_event_cb(btn, btn_click_pause, LV_EVENT_CLICKED, NULL);
+
+        label = lv_label_create(btn);
+        lv_label_set_text(label, LV_SYMBOL_PAUSE);
+        lv_obj_center(label);
+    }
+
+    lv_msg_send(DATA_PRINTER_DATA, &printer);
+}
--- a/CYD-Klipper/src/ui/panels/settings_panel.cpp
+++ b/CYD-Klipper/src/ui/panels/settings_panel.cpp
@@ -0,0 +1,200 @@
+#include "lvgl.h"
+#include "panel.h"
+#include "../../core/screen_driver.h"
+#include "../../conf/global_config.h"
+#include "../main_ui.h"
+
+static void invert_color_switch(lv_event_t * e){
+    auto state = lv_obj_get_state(lv_event_get_target(e));
+    bool checked = (state & LV_STATE_CHECKED == LV_STATE_CHECKED);
+    global_config.invertColors = checked;
+    WriteGlobalConfig();
+    set_invert_display();
+}
+
+static void reset_calibration_click(lv_event_t * e){
+    global_config.screenCalibrated = false;
+    WriteGlobalConfig();
+    ESP.restart();
+}
+
+static void reset_wifi_click(lv_event_t * e){
+    global_config.wifiConfigured = false;
+    global_config.ipConfigured = false;
+    WriteGlobalConfig();
+    ESP.restart();
+}
+
+static void light_mode_switch(lv_event_t * e){
+    auto state = lv_obj_get_state(lv_event_get_target(e));
+    bool checked = (state & LV_STATE_CHECKED == LV_STATE_CHECKED);
+    global_config.lightMode = checked;
+    WriteGlobalConfig();
+    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;
+    set_color_scheme();
+    WriteGlobalConfig();
+}
+
+const char* brightness_options = "100%\n75%\n50%\n25%";
+const 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();
+}
+
+const char* wake_timeout_options = "1m\n2m\n5m\n10m\n15m\n30m\n1h\n2h\n4h";
+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];
+    set_screen_timer_period();
+    WriteGlobalConfig();
+}
+
+static void rotate_screen_switch(lv_event_t* e){
+    auto state = lv_obj_get_state(lv_event_get_target(e));
+    bool checked = (state & LV_STATE_CHECKED == LV_STATE_CHECKED);
+    global_config.rotateScreen = checked;
+    global_config.screenCalibrated = false;
+    WriteGlobalConfig();
+    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;
+    check_if_screen_needs_to_be_disabled();
+    WriteGlobalConfig();
+}
+
+int y_offset = 0;
+const int y_element_size = 50;
+const int y_seperator_size = 1;
+const int y_seperator_x_padding = 50;
+const int panel_width = TFT_HEIGHT - 40;
+const int y_element_x_padding = 30;
+const static lv_point_t line_points[] = { {0, 0}, {panel_width - y_seperator_x_padding, 0} };
+
+void create_settings_widget(const char* label_text, lv_obj_t* object, lv_obj_t* root_panel){
+    lv_obj_t * panel = lv_obj_create(root_panel);
+    lv_obj_set_style_border_width(panel, 0, 0);
+    lv_obj_set_style_bg_opa(panel, LV_OPA_TRANSP, 0);
+    lv_obj_set_style_pad_all(panel, 0, 0);
+    lv_obj_align(panel, LV_ALIGN_TOP_MID, 0, y_offset);
+    lv_obj_set_size(panel, panel_width - y_element_x_padding, y_element_size);
+
+    lv_obj_t * line = lv_line_create(panel);
+    lv_line_set_points(line, line_points, 2);
+    lv_obj_set_style_line_width(line, y_seperator_size, 0);
+    lv_obj_set_style_line_color(line, lv_color_hex(0xAAAAAA), 0);
+    lv_obj_align(line, LV_ALIGN_BOTTOM_MID, 0, 0);
+
+    lv_obj_t * label = lv_label_create(panel);
+    lv_label_set_text(label, label_text);
+    lv_obj_align(label, LV_ALIGN_LEFT_MID, 0, 0);
+
+    lv_obj_set_parent(object, panel);
+    lv_obj_align(object, LV_ALIGN_RIGHT_MID, 0, 0);
+    y_offset += y_element_size;
+}
+
+void settings_panel_init(lv_obj_t* panel){
+    y_offset = 0;
+
+    lv_obj_t * btn = lv_btn_create(panel);
+    lv_obj_add_event_cb(btn, reset_wifi_click, LV_EVENT_CLICKED, NULL);
+
+    lv_obj_t * label = lv_label_create(btn);
+    lv_label_set_text(label, "Restart");
+    lv_obj_center(label);
+
+    create_settings_widget("Configure WiFi", btn, panel);
+
+    btn = lv_btn_create(panel);
+    lv_obj_add_event_cb(btn, reset_calibration_click, LV_EVENT_CLICKED, NULL);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, "Restart");
+    lv_obj_center(label);
+
+    create_settings_widget("Calibrate Touch", btn, panel);
+
+    lv_obj_t * toggle = lv_switch_create(panel);
+    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_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);
+
+    for (int i = 0; i < SIZEOF(brightness_options_values); i++){
+        if (brightness_options_values[i] == global_config.brightness){
+            lv_dropdown_set_selected(dropdown, i);
+            break;
+        }
+    }
+
+    create_settings_widget("Brightness", dropdown, panel);
+
+    dropdown = lv_dropdown_create(panel);
+    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){
+            lv_dropdown_set_selected(dropdown, i);
+            break;
+        }
+    }
+
+    create_settings_widget("Wake Timeout", dropdown, panel);
+
+    toggle = lv_switch_create(panel);
+    lv_obj_add_event_cb(toggle, rotate_screen_switch, LV_EVENT_VALUE_CHANGED, NULL);
+
+    if (global_config.rotateScreen)
+        lv_obj_add_state(toggle, LV_STATE_CHECKED);
+    
+    create_settings_widget("Rotate Screen", toggle, panel);
+
+    toggle = lv_switch_create(panel);
+    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);
+}
--- a/CYD-Klipper/src/ui/panels/temp_panel.cpp
+++ b/CYD-Klipper/src/ui/panels/temp_panel.cpp
@@ -0,0 +1,165 @@
+#include "lvgl.h"
+#include "panel.h"
+#include "../../core/data_setup.h"
+#include <HardwareSerial.h>
+
+// False: Hotend, True: Bed
+static bool hotend_or_bed = true;
+static char hotend_buff[40];
+static char bed_buff[40];
+
+static void update_printer_data_hotend_temp(lv_event_t * e){
+    lv_obj_t * label = lv_event_get_target(e);
+    sprintf(hotend_buff, "Hotend: %.0f C\nTarget: %.0f C", printer.extruder_temp, printer.extruder_target_temp);
+    lv_label_set_text(label, hotend_buff);
+}
+
+static void update_printer_data_bed_temp(lv_event_t * e){
+    lv_obj_t * label = lv_event_get_target(e);
+    sprintf(bed_buff, "Bed: %.0f C\nTarget: %.0f C", printer.bed_temp, printer.bed_target_temp);
+    lv_label_set_text(label, bed_buff);
+}
+
+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);
+        if (temp < 0 || temp > 500){
+            return;
+        }
+
+        Serial.printf("%d %s %d\n", hotend_or_bed, text, temp);
+        char gcode[64];
+        const char* space = "%20";
+
+        if (hotend_or_bed){
+            sprintf(gcode, "M140%sS%d", space, temp);
+        } else {
+            sprintf(gcode, "M104%sS%d", space, temp);
+        }
+
+        send_gcode(true, gcode);
+    }
+
+    if(code == LV_EVENT_DEFOCUSED || code == LV_EVENT_CANCEL || code == LV_EVENT_READY) {
+        lv_keyboard_set_textarea(kb, NULL);
+        lv_obj_del(kb);
+        lv_obj_del(ta);
+    }
+}
+
+static void show_keyboard(lv_event_t * e){
+    lv_obj_t * panel = (lv_obj_t *)lv_event_get_user_data(e);
+    lv_obj_t * keyboard = lv_keyboard_create(panel);
+    lv_obj_t * ta = lv_textarea_create(panel);
+    lv_obj_set_size(ta, 100, 30);
+    lv_obj_align(ta, LV_ALIGN_TOP_MID, 0, 40);
+    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){
+    hotend_or_bed = false;
+    show_keyboard(e);
+}
+
+static void show_keyboard_with_bed(lv_event_t * e){
+    hotend_or_bed = true;
+    show_keyboard(e);
+}
+
+static void cooldown_temp(lv_event_t * e){
+    if (printer.state == PRINTER_STATE_PRINTING){
+        return;
+    }
+    
+    send_gcode(true, "M104%20S0");
+    send_gcode(true, "M140%20S0");
+}
+
+static void btn_extrude(lv_event_t * e){
+    if (printer.state == PRINTER_STATE_PRINTING){
+        return;
+    }
+
+    send_gcode(true, "M83");
+    send_gcode(true, "G1%20E25%20F300");
+}
+
+static void btn_retract(lv_event_t * e){
+    if (printer.state == PRINTER_STATE_PRINTING){
+        return;
+    }
+
+    send_gcode(true, "M83");
+    send_gcode(true, "G1%20E-25%20F300");
+}
+
+void temp_panel_init(lv_obj_t* panel){
+    auto panel_width = TFT_HEIGHT - 40;
+    lv_obj_t * label = lv_label_create(panel);
+    lv_label_set_text(label, "Hotend");
+    lv_obj_align(label, LV_ALIGN_TOP_LEFT, 10, 10);
+    lv_obj_add_event_cb(label, update_printer_data_hotend_temp, LV_EVENT_MSG_RECEIVED, NULL);
+    lv_msg_subscribe_obj(DATA_PRINTER_DATA, label, NULL);
+
+    label = lv_label_create(panel);
+    lv_label_set_text(label, "Bed");
+    lv_obj_align(label, LV_ALIGN_TOP_LEFT, 10, 50);
+    lv_obj_add_event_cb(label, update_printer_data_bed_temp, LV_EVENT_MSG_RECEIVED, NULL);
+    lv_msg_subscribe_obj(DATA_PRINTER_DATA, label, NULL);
+
+    lv_obj_t * btn = lv_btn_create(panel);
+    lv_obj_align(btn, LV_ALIGN_TOP_RIGHT, -10, 10);
+    lv_obj_add_event_cb(btn, show_keyboard_with_hotend, LV_EVENT_CLICKED, panel);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, "Set");
+    lv_obj_center(label);
+
+    btn = lv_btn_create(panel);
+    lv_obj_align(btn, LV_ALIGN_TOP_RIGHT, -10, 50);
+    lv_obj_add_event_cb(btn, show_keyboard_with_bed, LV_EVENT_CLICKED, panel);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, "Set");
+    lv_obj_center(label);
+
+    btn = lv_btn_create(panel);
+    lv_obj_align(btn, LV_ALIGN_TOP_MID, 0, 90);
+    lv_obj_add_event_cb(btn, cooldown_temp, LV_EVENT_CLICKED, panel);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, "Cooldown");
+    lv_obj_center(label);
+
+    btn = lv_btn_create(panel);
+    lv_obj_align(btn, LV_ALIGN_BOTTOM_LEFT, 10, -5);
+    lv_obj_add_event_cb(btn, btn_extrude, LV_EVENT_CLICKED, NULL);
+    lv_obj_set_size(btn, panel_width / 2 - 15, 30);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_DOWN " Extrude");
+    lv_obj_center(label);
+
+    btn = lv_btn_create(panel);
+    lv_obj_align(btn, LV_ALIGN_BOTTOM_RIGHT, -10, -5);
+    lv_obj_add_event_cb(btn, btn_retract, LV_EVENT_CLICKED, NULL);
+    lv_obj_set_size(btn, panel_width / 2 - 15, 30);
+
+    label = lv_label_create(btn);
+    lv_label_set_text(label, LV_SYMBOL_UP " Retract");
+    lv_obj_center(label);
+
+    lv_msg_send(DATA_PRINTER_DATA, &printer);
+}
--- a/CYD-Klipper/src/ui/wifi_setup.cpp
+++ b/CYD-Klipper/src/ui/wifi_setup.cpp
@@ -0,0 +1,159 @@
+#include "lvgl.h"
+#include "wifi_setup.h"
+#include "../conf/global_config.h"
+
+#include "WiFi.h"
+void wifi_init_inner();
+
+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;
+        wifi_init_inner();
+    }
+}
+
+static void refresh_btn_event_handler(lv_event_t * e){
+    lv_event_code_t code = lv_event_get_code(e);
+
+    if(code == LV_EVENT_CLICKED) {
+        wifi_init_inner();
+    }
+}
+
+static void ta_event_cb(lv_event_t * e) {
+    lv_event_code_t code = lv_event_get_code(e);
+    lv_obj_t * ta = lv_event_get_target(e);
+
+    if (code == LV_EVENT_READY) 
+    {
+        const char * txt = lv_textarea_get_text(ta);
+        int len = strlen(txt);
+        if (len > 0)
+        {
+            global_config.wifiConfigured = true;
+            strcpy(global_config.wifiPassword, txt);
+            WriteGlobalConfig();
+            wifi_init_inner();
+        }
+    }
+    else if (code == LV_EVENT_CANCEL)
+    {
+        wifi_init_inner();
+    }
+}
+
+void wifi_pass_entry(const char* ssid){
+    lv_obj_clean(lv_scr_act());
+
+    lv_obj_t * label = lv_label_create(lv_scr_act());
+    lv_label_set_text(label, "Enter WiFi Password");
+    lv_obj_align(label, LV_ALIGN_TOP_LEFT, 10, 10 + 2);
+
+    lv_obj_t * passEntry = lv_textarea_create(lv_scr_act());
+    lv_textarea_set_one_line(passEntry, true);
+    lv_textarea_set_text(passEntry, "");
+    lv_obj_align(passEntry, LV_ALIGN_TOP_LEFT, 10, 40);
+    lv_obj_add_event_cb(passEntry, ta_event_cb, LV_EVENT_ALL, NULL);
+    lv_obj_set_size(passEntry, TFT_HEIGHT - 20, 60);
+
+    lv_obj_t * keyboard = lv_keyboard_create(lv_scr_act());
+    lv_keyboard_set_textarea(keyboard, passEntry);
+}
+
+static void wifi_btn_event_handler(lv_event_t * e){
+    lv_event_code_t code = lv_event_get_code(e);
+
+    if(code == LV_EVENT_CLICKED) {
+        delay(100);
+        char* ssid = (char*)e->user_data;
+        strcpy(global_config.wifiSSID, ssid);
+        Serial.println(ssid);
+        wifi_pass_entry(ssid);
+    }
+}
+
+
+void wifi_init_inner(){
+    WiFi.disconnect();
+
+    if (global_config.wifiConfigured){
+        WiFi.begin(global_config.wifiSSID, global_config.wifiPassword);
+        
+        lv_obj_clean(lv_scr_act());
+
+        lv_obj_t * label = lv_label_create(lv_scr_act());
+        lv_label_set_text(label, "Connecting to WiFi");
+        lv_obj_align(label, LV_ALIGN_CENTER, 0, 0);
+
+        lv_obj_t * resetBtn = lv_btn_create(lv_scr_act());
+        lv_obj_add_event_cb(resetBtn, reset_btn_event_handler, LV_EVENT_ALL, NULL);
+        lv_obj_align(resetBtn, LV_ALIGN_CENTER, 0, 40);
+
+        label = lv_label_create(resetBtn);
+        lv_label_set_text(label, "Reset");
+        lv_obj_center(label);
+
+        return;
+    } 
+
+    lv_obj_clean(lv_scr_act());
+
+    lv_obj_t * label = lv_label_create(lv_scr_act());
+    lv_label_set_text(label, "Scanning for networks...");
+    lv_obj_align(label, LV_ALIGN_CENTER, 0, 0);
+
+    lv_timer_handler();
+    lv_task_handler();
+    lv_refr_now(NULL);
+
+    int n = WiFi.scanNetworks();
+
+    lv_obj_clean(lv_scr_act());
+
+    lv_obj_t * refreshBtn = lv_btn_create(lv_scr_act());
+    lv_obj_add_event_cb(refreshBtn, reset_btn_event_handler, LV_EVENT_ALL, NULL);
+    lv_obj_align(refreshBtn, LV_ALIGN_TOP_RIGHT, -5, 5 - 1);
+
+    label = lv_label_create(refreshBtn);
+    lv_label_set_text(label, LV_SYMBOL_REFRESH);
+    lv_obj_center(label);
+
+    label = lv_label_create(lv_scr_act());
+    lv_label_set_text(label, "Select a network");
+    lv_obj_align(label, LV_ALIGN_TOP_LEFT, 10, 10 + 2);
+
+    lv_obj_t * list = lv_list_create(lv_scr_act());
+    lv_obj_align(list, LV_ALIGN_TOP_LEFT, 10, 40);
+    lv_obj_set_size(list, TFT_HEIGHT - 20, TFT_WIDTH - 40 - 5);
+
+    for (int i = 0; i < n; ++i) {
+        const char* ssid = WiFi.SSID(i).c_str();
+        int len = strlen(ssid);
+
+        if (len == 0)
+            continue;
+
+        const char* ssid_copy = (const char*)malloc(len + 1);
+        strcpy((char*)ssid_copy, ssid);
+        lv_obj_t * btn = lv_list_add_btn(list, LV_SYMBOL_WIFI, ssid_copy);
+        lv_obj_add_event_cb(btn, wifi_btn_event_handler, LV_EVENT_ALL, (void*)ssid_copy);
+    }
+}
+
+void wifi_init(){
+    WiFi.mode(WIFI_STA);
+    wifi_init_inner();
+
+    while (!global_config.wifiConfigured || WiFi.status() != WL_CONNECTED){
+        lv_timer_handler();
+        lv_task_handler();
+    }
+}
+
+void wifi_ok(){
+    if (WiFi.status() != WL_CONNECTED){
+        ESP.restart();
+    }
+}
--- a/CYD-Klipper/src/ui/wifi_setup.h
+++ b/CYD-Klipper/src/ui/wifi_setup.h
@@ -0,0 +1,2 @@
+void wifi_init();
+void wifi_ok();
--- a/CYD-Klipper/test/README
+++ b/CYD-Klipper/test/README
@@ -0,0 +1,11 @@
+
+This directory is intended for PlatformIO Test Runner and project tests.
+
+Unit Testing is a software testing method by which individual units of
+source code, sets of one or more MCU program modules together with associated
+control data, usage procedures, and operating procedures, are tested to
+determine whether they are fit for use. Unit testing finds problems early
+in the development cycle.
+
+More information about PlatformIO Unit Testing:
+- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html