If you own a Bambu Lab printer, you probably already know the feeling. You start a print, walk away, and then spend the next two hours wondering if everything is going okay. Maybe you check Bambu Handy on your phone, or maybe you pull up the printer’s web interface, but neither of those options feel particularly quick. I wanted something I could glance at, something always on, always showing me exactly what my P2S was doing without reaching for my phone.
So I built one. Using an ESP32 Cheap Yellow Display, ESPHome, and the Bambu Lab HACS integration for Home Assistant, I put together a dedicated printer monitor that sits right on my desk. It costs between $10 and $20 in hardware, and it shows me print progress, temperatures, fan speeds, AMS status, and more across four swipeable pages. It can be a little fiddly to set up if you’ve never touched ESPHome’s LVGL support before, and the lack of PSRAM on this board means there are hard limits on what you can do, but for a print status display, it’s more than enough.
Interested in more maker-related content? We launched the XDA Maker Weekly newsletter featuring unique and original content you won’t find anywhere else on XDA. Get subscribed by modifying your newsletter preferences!
The Cheap Yellow Display is the perfect starting point
Easy to get, cheap to buy
The ESP32 “Cheap Yellow Display” actually refers to a number of different boards that are all quite similar but not the same. We’re using the ESP32-2432S028R, and the name doesn’t exactly roll off the tongue. Plus, given that there are different boards that are all quite similar, it’s just easier to call it the “Cheap Yellow Display,” or CYD. Either way, it’s one of those boards that punches well above its price, and it’ll set you back somewhere around $10 to $20.
This board has some pretty decent hardware, too, as you get an ESP32 with a 2.8-inch 320×240 ILI9341 TFT display and a resistive XPT2046 touchscreen. It’s not a high-resolution panel by any stretch, but for displaying text, icons, and status information, it gets the job done.
The big trade-off with the standard CYD, when it comes to projects involving graphics, is that it ships without PSRAM. That means you’re working with the ESP32’s built-in 520KB of SRAM, and once you start loading fonts, icons, and LVGL widgets, memory gets tight. You’re not going to be streaming your printer’s camera feed to this thing, and you won’t be rendering complex animations. But for a status dashboard with text labels, progress arcs, and temperature readouts, the memory budget is enough. I haven’t had a single crash or memory-related issue with my setup.
The board also includes an SD card slot, an RGB LED, and a built-in LDR, though I’m not using any of those for this project. The touch calibration can be a bit finicky when you first set it up, but you can calculate the right calibration values for your specific unit and have it work reliably.
Home Assistant ties it all together
Everything comes in to Home Assistant first
The ESP32 is just the screen. The part that actually matters is how the printer data gets there. The Bambu Lab HACS integration pulls in a ton of sensor data from your printer: print status, current stage, nozzle temperature, bed temperature, chamber temperature, fan speeds, AMS tray contents, layer counts, remaining time, speed profile, and a whole lot more. It connects to your printer either through Bambu’s cloud or directly over your local network.
Once those sensors exist in Home Assistant, ESPHome can subscribe to them directly through the Home Assistant API. Each sensor update triggers a lambda that formats the value and pushes it to an LVGL label on the display. There’s no polling, no delays, and it’s all event-driven. When my printer’s nozzle temperature changes, the display updates within a second or two.
I set up four pages on the display, each accessible through a nav bar at the bottom with Material Design Icons. The first page is the main status view with a progress arc, print status, task name, remaining time, layer count, and all three temperature readings. The second page breaks out the fan speeds and target temperatures. The third page shows AMS tray contents, humidity, and the active tray. Finally, the fourth page covers general printer info like WiFi signal, total usage hours, door state, and HMS error status.
ESPHome’s LVGL support makes it look better
It looks a lot more professional
If you’d tried to build something like this a couple of years ago with ESPHome, you’d have been stuck with the basic display rendering engine, drawing rectangles and text at fixed coordinates with no real widget system. It worked, but it wasn’t pretty, and it was painful to maintain. ESPHome’s LVGL integration changed that completely.
LVGL, or Light and Versatile Graphics Library, gives you proper widgets like arcs, progress bars, styled containers, and font rendering with anti-aliasing. My display uses cards with rounded corners, color-coded temperature sections, and a proper progress arc that fills as the print completes. It looks like a real product interface, rather than a hobbyist hack.
That said, there’s a pretty hefty learning curve. ESPHome’s LVGL documentation is still catching up to the feature set, and there are quirks. Getting the touchscreen calibration right in landscape mode took some trial and error, and understanding how LVGL’s coordinate system interacts with ESPHome’s transform settings isn’t immediately intuitive. I’ve been building devices with ESPHome and LVGL for nearly a year at this point, and I still get caught out by failed compilations due to my LVGL widgets.
The YAML can also get long. My configuration file is well over 800 lines, and most of that is just UI layout definitions. But once you understand the pattern, it’s really just repeating the same widget structures with different sensor bindings.
I also added some small touches that make it feel nicer to use. For example, the backlight dims after 60 seconds of inactivity and turns off entirely after five minutes, and tapping the screen wakes it back up instantly.
You don’t need to write any of this from scratch
It’s on GitHub
One of the reasons I wanted to share this project is that it’s really not that hard to replicate if you already have Home Assistant and a Bambu Lab printer. You need a Cheap Yellow Display board, the Bambu Lab HACS integration installed and configured, and ESPHome set up in Home Assistant. The full YAML configuration is available on my GitHub, so you don’t need to figure out the LVGL layout, sensor mappings, or touch calibration yourself. The 3D printed case that I’m using is from MBruneau on MakerWorld.
You will need to update the entity IDs in the YAML to match your own printer. The sensor names are generated by the Bambu Lab integration based on your printer’s serial number, so they’ll be different from mine. But the structure is all there. Swap out the entity IDs, flash it, and you should have a working display within minutes.
If you’re using a different Bambu Lab printer like the X1C, A1, or P1S, everything should still work as long as the HACS integration exposes the same sensors. The sensor names might differ slightly, but the approach is the same. And if you want to customize the layout, adding or removing widgets is easy enough once you understand how the LVGL YAML is structured.
Of course, there are alternatives out there. CYD-Klipper is a popular firmware that supports Bambu Lab printers and runs natively on the CYD without needing Home Assistant at all. It talks directly to the printer’s API. That’s a perfectly valid approach if you don’t want to run Home Assistant, but for me, having the printer data flow through Home Assistant means I can also use it in automations, notifications, and other dashboards. The ESP32 display is just one more way to view data that already exists in my smart home setup.
I’ve been running this for a few weeks now, and I find myself using it frequently. Having a dedicated, always-on screen that tells me exactly where my print is at, without touching my phone or opening a browser tab, is one of those things you don’t realize you wanted until you have it. For the price of the hardware, it’s hard to argue with. And that’s what I like most about the ESP32 ecosystem; you can nearly always build exactly the thing you need.
