{
  "cc1": {
    "nozzle": {{ states('sensor.centauri_carbon_nozzle_temperature_2') | float(0) | round(1) }},
    "bed": {{ states('sensor.centauri_carbon_bed_temperature_2') | float(0) | round(1) }},
    "pct": {{ states('sensor.centauri_carbon_percent_complete_2') | float(0) | round(0) | int }},
    "status": "{{ states('sensor.centauri_carbon_print_status_2') }}",
    "remaining": "{{ states('sensor.centauri_carbon_remaining_print_time_2') }}"
  },
  "cc2": {     
"nozzle": {{ states('sensor.centauri_carbon_nozzle_temperature_2') | float(0) | round(1) }},
    "bed": {{ states('sensor.centauri_carbon_bed_temperature_2') | float(0) | round(1) }},
    "pct": {{ states('sensor.centauri_carbon_percent_complete_2') | float(0) | round(0) | int }},
    "status": "{{ states('sensor.centauri_carbon_print_status_2') }}",
    "remaining": "{{ states('sensor.centauri_carbon_remaining_print_time_2') }}"
 },
  "bbl": {     
"nozzle": {{ states('sensor.a1_nozzle_temperature') | float(0) | round(1) }},
    "bed": {{ states('sensor.a1_bed_temperature') | float(0) | round(1) }},
    "pct": {{ states('sensor.a1_percent_complete') | float(0) | round(0) | int }},
    "status": "{{ states('sensor.a1_print_progress') }}",
    "remaining": "{{ states('sensor.a1_remaining_time') }}"
 },
}

CIRCUITPY_WIFI_SSID = "your_wifi_ssid"

CIRCUITPY_WIFI_PASSWORD = "your_wifi_password"

HA_HOST = "192.168.1.xxx"

HA_PORT = "8123"

HA_TOKEN = "your_long_lived_token_here"

 

POLL_INTERVAL  = 20   # seconds between HA data fetches

CYCLE_INTERVAL = 4    # seconds between printer slides

FLASH_RATE     = 0.4  # seconds per flash toggle for error/paused dot

# code.py — 3D Printer Status Display

# Adafruit Matrix Portal M4 + 64x32 RGB Matrix

# Polls Home Assistant REST API for printer status

# Travis's print farm: CC1, CC2, Bambu A1

 

import time

import json

import board

import busio

import displayio

import terminalio

import supervisor

from digitalio import DigitalInOut

from adafruit_matrixportal.matrix import Matrix

from adafruit_esp32spi import adafruit_esp32spi

import adafruit_connection_manager

import adafruit_requests

 

# ── CONFIG ────────────────────────────────────────────────────

import os

WIFI_SSID     = os.getenv("CIRCUITPY_WIFI_SSID")

WIFI_PASS     = os.getenv("CIRCUITPY_WIFI_PASSWORD")

HA_HOST       = os.getenv("HA_HOST")

HA_PORT       = os.getenv("HA_PORT")

HA_TOKEN      = os.getenv("HA_TOKEN")

 

POLL_INTERVAL  = 20    # seconds between HA fetches

CYCLE_INTERVAL = 4     # seconds between printer slides

FLASH_RATE     = 0.4   # seconds per flash toggle for error dot

 

# Printer display names (keep short — pixel font is tiny)

PRINTER_NAMES = ["CC1", "CC2", "A1 "]

full_names    = ["CENTAURI 1", "CENTAURI 2", "BAMBU A1  "]

 

# Status string normalization

# Maps whatever HA returns → our internal state

def normalize_status(raw):

    r = str(raw).lower().strip()

 

    # Active / in-progress states → show as printing (red dot)

    if r in (

        "printing", "running", "busy", "slicing",   # generic

        "homing", "dropping", "lifting",             # Centauri motion states

        "file_checking", "recovery", "printing_recovery",  # Centauri recovery

        "loading", "preheating", "leveling",         # Centauri prep states

    ):

        return "printing"

 

    # Interrupted / needs attention → show as error (flashing yellow dot)

    if r in (

        "pausing", "paused",                         # Centauri pause states

        "stopping",                                  # Centauri mid-stop

        "pause", "error", "failed",                  # generic

    ):

        return "error"

 

    # Print finished — bed needs clearing before next print

    if r in (

        "complete", "stopped",                       # Centauri end states

        "finish", "finished",                        # Bambu end states

    ):

        return "complete"

 

    # Truly idle / not running

    if r in (

        "idle", "standby",                           # normal idle

        "offline", "unknown", "unavailable",

        "none", "0.0", "0", "",

    ):

        return "idle"

 

    # Bambu-specific active stages

    if r in ("prepare", "auto_bed_leveling", "heatbed_preheating",

             "xyz_calibrate", "nozzle_temperature_calibration",

             "initial_estimate", "cleaning_nozzle_tip",

             "scanning_bed_surface", "first_layer_inspection",

             "downloading"):

        return "printing"

 

    # Numeric fallback

    try:

        code = int(r)

        if code == 0:

            return "idle"

        if 1 <= code <= 3:

            return "printing"

        if code >= 4:

            return "error"

    except ValueError:

        pass

 

    return "idle"

 

# ── DISPLAY SETUP ─────────────────────────────────────────────

matrix = Matrix(width=64, height=32, bit_depth=4)

display = matrix.display

display.rotation = 0

 

# Pixel access for drawing

import rgbmatrix

import framebufferio

import adafruit_pixel_framebuf as pixel_framebuf  # not available on M4 — use displayio

 

# We'll use a raw bitmap + palette approach for full pixel control

from displayio import Bitmap, Palette, TileGrid, Group

 

# Build a 64x32 bitmap (8-bit palette indices)

bmp = Bitmap(64, 32, 64)   # 64 colors max in palette

 

# Build palette — we'll use specific indices for our color set

# Index 0 = black (background), always

palette = Palette(64)

palette[0]  = 0x000000  # black / off

 

# Status dot colors

palette[1]  = 0x00CC22  # green  — idle

palette[2]  = 0xCC2200  # red    — printing

palette[3]  = 0xFFCC00  # yellow — error/paused (flashed in software)

palette[4]  = 0x000000  # yellow-off (flash off state)

 

# Text colors

palette[5]  = 0x4488FF  # blue   — title / header

palette[6]  = 0xFFFFFF  # white  — printer name

palette[7]  = 0xAAAAAA  # grey   — labels

palette[8]  = 0x447744  # dim green — idle text

palette[9]  = 0xFF8800  # orange — nozzle temp

palette[10] = 0xFF4444  # red    — bed temp

palette[11] = 0xCCCCCC  # light grey — temp values

palette[12] = 0xCC4400  # dark orange — progress bar fill

palette[13] = 0x222222  # dark grey — progress bar background

palette[14] = 0xFFCC00  # yellow — pct text / error text

palette[15] = 0x334466  # dim blue — divider lines

palette[16] = 0x00AA88  # teal   — remaining time

palette[17] = 0x666666  # mid grey — mini summary text

palette[18] = 0x555555  # darker grey — page indicator inactive

palette[19] = 0xFFFFFF  # white  — page indicator active

palette[20] = 0x0088FF  # blue   — complete dot

 

root_group = Group()

tg = TileGrid(bmp, pixel_shader=palette, x=0, y=0)

root_group.append(tg)

display.root_group = root_group

 

# ── TINY PIXEL FONT (3×5) ─────────────────────────────────────

# Each char: list of 5 rows, each row is a 3-bit integer (MSB=left)

FONT = {

    ' ': [0,0,0,0,0],

    'A': [2,5,7,5,5],  # 010,101,111,101,101

    'B': [6,5,6,5,6],

    'C': [3,4,4,4,3],

    'D': [6,5,5,5,6],

    'E': [7,4,6,4,7],

    'F': [7,4,6,4,4],

    'G': [3,4,7,5,3],

    'H': [5,5,7,5,5],

    'I': [7,2,2,2,7],

    'J': [1,1,1,5,2],

    'K': [5,5,6,5,5],

    'L': [4,4,4,4,7],

    'M': [5,7,7,5,5],

    'N': [5,7,7,5,5],

    'O': [2,5,5,5,2],

    'P': [6,5,6,4,4],

    'Q': [2,5,5,7,3],

    'R': [6,5,6,5,5],

    'S': [3,4,2,1,6],

    'T': [7,2,2,2,2],

    'U': [5,5,5,5,2],

    'V': [5,5,5,2,2],

    'W': [5,5,7,7,5],

    'X': [5,5,2,5,5],

    'Y': [5,5,2,2,2],

    'Z': [7,1,2,4,7],

    '0': [2,5,5,5,2],

    '1': [2,6,2,2,7],

    '2': [2,1,2,4,7],

    '3': [6,1,2,1,6],

    '4': [5,5,7,1,1],

    '5': [7,4,6,1,6],

    '6': [3,4,6,5,2],

    '7': [7,1,2,2,2],

    '8': [2,5,2,5,2],

    '9': [2,5,3,1,6],

    '.': [0,0,0,0,4],

    ':': [0,4,0,4,0],

    '%': [5,1,2,4,5],

    '/': [1,1,2,4,4],

    '-': [0,0,7,0,0],

    '+': [0,2,7,2,0],

    '°': [2,5,2,0,0],

    'm': [0,0,5,7,5],

    'h': [4,4,6,5,5],

    's': [0,0,3,2,6],

    'i': [0,2,0,2,2],

    'd': [1,1,3,5,3],

    'l': [6,2,2,2,7],

    'e': [0,2,5,6,3],

    'n': [0,0,6,5,5],

    'g': [0,3,5,3,1],

    'r': [0,0,5,6,4],

    'p': [0,0,6,5,6],

    'f': [0,3,2,6,2],

    'u': [0,0,5,5,3],

    't': [2,7,2,2,1],

    'a': [0,2,3,5,3],

    'c': [0,0,3,4,3],

    'k': [4,5,6,5,5],

    'o': [0,0,2,5,2],

    'w': [0,5,5,7,5],

    'x': [0,5,2,5,5],

    'z': [0,7,2,4,7],

    'b': [4,4,6,5,6],

    'y': [0,5,5,3,6],

    'v': [0,5,5,2,2],

    'j': [0,1,0,1,6],

    'q': [0,3,5,3,5],

}

 

def draw_char(ch, x, y, color_idx):

    """Draw a single 3×5 character at pixel (x,y) using palette index."""

    rows = FONT.get(ch.upper(), FONT.get(ch, FONT[' ']))

    for row_idx, row_bits in enumerate(rows):

        py = y + row_idx

        if py < 0 or py >= 32:

            continue

        for col in range(3):

            px_val = (row_bits >> (2 - col)) & 1

            px = x + col

            if px < 0 or px >= 64:

                continue

            if px_val:

                bmp[px, py] = color_idx

            # Don't clear — caller should clear the area first

 

def draw_text(text, x, y, color_idx):

    """Draw a string. Returns ending x position."""

    cx = x

    for ch in text:

        draw_char(ch, cx, y, color_idx)

        cx += 4  # 3px char + 1px gap

    return cx

 

def draw_text_centered(text, y, color_idx, width=64):

    total_w = len(text) * 4 - 1

    x = max(0, (width - total_w) // 2)

    draw_text(text, x, y, color_idx)

 

def clear_rect(x, y, w, h):

    """Fill a rect with black (index 0)."""

    for py in range(y, min(y + h, 32)):

        for px in range(x, min(x + w, 64)):

            bmp[px, py] = 0

 

def clear_all():

    for i in range(64 * 32):

        bmp[i % 64, i // 64] = 0

 

def draw_hline(y, x0=0, x1=63, color_idx=15):

    for x in range(x0, x1 + 1):

        if 0 <= y < 32:

            bmp[x, y] = color_idx

 

def draw_dot(x, y, color_idx):

    """Draw a 3×3 filled square dot."""

    for dy in range(3):

        for dx in range(3):

            px2 = x + dx

            py2 = y + dy

            if 0 <= px2 < 64 and 0 <= py2 < 32:

                bmp[px2, py2] = color_idx

 

def draw_progress_bar(x, y, w, h, pct, fill_idx=12, bg_idx=13):

    fill = max(0, min(w, int(w * pct / 100)))

    for py in range(y, y + h):

        for px in range(x, x + w):

            bmp[px, py] = fill_idx if px < x + fill else bg_idx

 

def dot_color_idx(status):

    if status == "printing":

        return 2   # red

    if status == "error":

        return 3   # yellow

    if status == "complete":

        return 20  # blue

    return 1       # green — idle

 

def format_remaining(raw):

    """Format remaining time string from HA. Returns e.g. '1h23m', '45m', '--'"""

    try:

        mins = float(str(raw).strip())

        if mins <= 0:

            return "--"

        h = int(mins // 60)

        m = int(mins % 60)

        if h > 0:

            return f"{h}h{m:02d}m"

        return f"{m}m"

    except (ValueError, TypeError):

        return "--"

 

def format_temp(val):

    """Convert F to C and format for display, e.g. 284°F → '140'"""

    try:

        f = float(val)

        c = (f - 32) * 5 / 9

        return str(int(c))

    except (ValueError, TypeError):

        return "---"

 

# ── DRAW ROUTINES ─────────────────────────────────────────────

 

def draw_all_idle(printers):

    """All printers idle — show all 3 on one static screen."""

    clear_all()

    draw_text("3D PRINTERS", 2, 1, 5)  # blue title

    draw_hline(8, color_idx=15)

 

    rows = [11, 18, 25]

    for i, p in enumerate(printers):

        y = rows[i]

        status = normalize_status(p.get("status", "idle"))

        dot_idx = dot_color_idx(status)

        draw_dot(1, y, dot_idx)

        draw_text(PRINTER_NAMES[i], 7, y, 6)      # white name

        if status == "idle":

            draw_text("IDLE", 23, y, 8)            # dim green

        elif status == "complete":

            draw_text("DONE", 23, y, 20)           # blue

        elif status == "error":

            draw_text("ERR", 23, y, 14)            # yellow

        else:

            pct = p.get("pct", 0)

            draw_text(f"{pct}%", 23, y, 12)        # orange-ish

 

 

def draw_printer_slide(printer, name, status, flash_state, page_idx):

    """Draw the full-screen slide for one printer while it's cycling."""

    clear_all()

 

    # Header row: dot + printer name

    dot_idx = dot_color_idx(status)

    draw_dot(1, 1, dot_idx)

    draw_text(name, 7, 1, 6)   # white

 

    draw_hline(7, color_idx=15)

 

    if status == "idle":

        # Vertically centered in the space below the header divider (rows 8-23)

        draw_text_centered("IDLE", 11, 8)       # dim green

        draw_text_centered("NO PRINT", 18, 7)   # grey

 

    elif status == "complete":

        # Print done — prompt user to remove print

        draw_text_centered("COMPLETED", 11, 20)   # blue

        draw_text_centered("REMOVE PRINT", 19, 7) # grey

 

    elif status == "error":

        # Temps still shown, PAUSED/ERROR label instead of bar

        nozzle = format_temp(printer.get("nozzle", 0))

        bed    = format_temp(printer.get("bed", 0))

 

        draw_text("NOZ", 1, 9, 9)        # orange label

        draw_text(f"{nozzle}", 15, 9, 11) # grey value

        draw_text("°", 15 + len(nozzle)*4, 9, 11)

 

        draw_text("BED", 1, 16, 10)       # red label

        draw_text(f"{bed}", 15, 16, 11)

        draw_text("°", 15 + len(bed)*4, 16, 11)

 

        draw_hline(23, color_idx=15)

        # Show specific interrupted state text

        raw_status = str(printer.get("status", "")).lower().strip()

        if raw_status == "stopping":

            draw_text_centered("STOPPING", 25, 14)

        elif raw_status == "pausing":

            draw_text_centered("PAUSING", 25, 14)

        else:

            draw_text_centered("PAUSED", 25, 14)  # yellow

 

    else:

        # Printing — show nozzle, bed, progress bar, pct, remaining

        nozzle  = format_temp(printer.get("nozzle", 0))

        bed     = format_temp(printer.get("bed", 0))

        pct     = int(printer.get("pct", 0))

        rem     = format_remaining(printer.get("remaining", 0))

 

        # Nozzle temp — row 9

        draw_text("NOZ", 1, 9, 9)         # orange

        draw_text(f"{nozzle}°", 15, 9, 11)

 

        # Bed temp — row 16

        draw_text("BED", 1, 16, 10)       # red-ish

        draw_text(f"{bed}°", 15, 16, 11)

 

        # Remaining time — right side

        draw_text(rem, 38, 9, 16)        # teal

 

        draw_hline(23, color_idx=15)

 

        # Progress bar — rows 25-27

        draw_progress_bar(1, 25, 44, 3, pct)

 

        # Percentage — right of bar

        pct_str = f"{pct}%"

        draw_text(pct_str, 47, 25, 14)   # yellow

 

    # Page indicator dots — bottom right (shows which printer we're on)

    page_x = [57, 59, 61]

    for i in range(3):

        bmp[page_x[i], 31] = 19 if i == page_idx else 18

 

 

def draw_idle_group_slide(idle_indices, printers):

    """One consolidated slide showing all currently-idle printers stacked at top,

    with NO PRINT centred in the remaining space below."""

    clear_all()

 

    # Pack idle printer names starting at y=1, 8px apart

    row_ys = [1, 9, 17]

 

    for slot, idx in enumerate(idle_indices):

        y = row_ys[slot]

        p = printers[idx]

        status = normalize_status(p.get("status", "idle"))

        dot_idx = dot_color_idx(status)

        draw_dot(1, y, dot_idx)

        draw_text(full_names[idx], 7, y, 6)   # white printer name

 

    # Divider just below the last idle entry

    divider_y = row_ys[len(idle_indices) - 1] + 7

    if divider_y < 30:

        draw_hline(divider_y, color_idx=15)

 

    # "NO PRINT" centred in the remaining space below the divider

    remaining_top = divider_y + 1

    remaining_mid = remaining_top + (31 - remaining_top) // 2 - 2

    if remaining_mid + 5 <= 31:

        draw_text_centered("NO PRINT", remaining_mid, 7)  # grey

 

 

# ── WIFI + HTTP SETUP ─────────────────────────────────────────

 

def init_wifi():

    esp32_cs   = DigitalInOut(board.ESP_CS)

    esp32_ready = DigitalInOut(board.ESP_BUSY)

    esp32_reset = DigitalInOut(board.ESP_RESET)

    spi = busio.SPI(board.SCK, board.MOSI, board.MISO)

    esp = adafruit_esp32spi.ESP_SPIcontrol(spi, esp32_cs, esp32_ready, esp32_reset)

 

    pool = adafruit_connection_manager.get_radio_socketpool(esp)

    ssl_ctx = adafruit_connection_manager.get_radio_ssl_context(esp)

    requests = adafruit_requests.Session(pool, ssl_ctx)

 

    print("Connecting to WiFi...")

    while not esp.is_connected:

        try:

            esp.connect_AP(WIFI_SSID, WIFI_PASS)

        except RuntimeError as e:

            print(f"WiFi error: {e}, retrying...")

            time.sleep(2)

    print(f"Connected! IP: {esp.pretty_ip(esp.ip_address)}")

    return requests

 

# Jinja2 template to POST to HA — kept as a plain string

HA_TEMPLATE = """{

  "cc1": {

    "nozzle": {{ states('sensor.centauri_carbon_nozzle_temperature_2') | float(0) | round(1) }},

    "bed": {{ states('sensor.centauri_carbon_bed_temperature_2') | float(0) | round(1) }},

    "pct": {{ states('sensor.centauri_carbon_percent_complete_2') | float(0) | round(0) | int }},

    "status": "{{ states('sensor.centauri_carbon_print_status_2') }}",

    "remaining": "{{ states('sensor.centauri_carbon_remaining_print_time_2') }}"

  },

  "cc2": {

    "nozzle": {{ states('sensor.centauri_carbon_nozzle_temperature') | float(0) | round(1) }},

    "bed": {{ states('sensor.centauri_carbon_bed_temperature') | float(0) | round(1) }},

    "pct": {{ states('sensor.centauri_carbon_percent_complete') | float(0) | round(0) | int }},

    "status": "{{ states('sensor.centauri_carbon_print_status') }}",

    "remaining": "{{ states('sensor.centauri_carbon_remaining_print_time') }}"

  },

  "bbl": {

    "nozzle": {{ states('sensor.a1_03919c450701743_nozzle_temperature') | float(0) | round(1) }},

    "bed": {{ states('sensor.a1_03919c450701743_bed_temperature') | float(0) | round(1) }},

    "pct": {{ states('sensor.a1_03919c450701743_print_progress') | float(0) | round(0) | int }},

    "status": "{{ 'complete' if is_state('input_boolean.bambu_a1_print_complete', 'on') else states('sensor.a1_03919c450701743_print_status') }}",

    "stage": "{{ states('sensor.a1_03919c450701743_current_stage') }}",

    "remaining": "{{ states('sensor.a1_03919c450701743_remaining_time') }}"

  }

}"""

 

def fetch_printer_data(requests_session):

    url = f"http://{HA_HOST}:{HA_PORT}/api/template"

    headers = {

        "Authorization": f"Bearer {HA_TOKEN}",

        "Content-Type": "application/json",

    }

    payload = json.dumps({"template": HA_TEMPLATE})

    try:

        resp = requests_session.post(url, headers=headers, data=payload, timeout=10)

        raw = resp.text

        resp.close()

        data = json.loads(raw)

        # Bambu complete state is handled by the HA template via input_boolean.

        # current_stage="idle" override still applies as a fallback.

        bbl = data["bbl"]

        bbl_stage = str(bbl.get("stage", "")).lower().strip()

        if bbl_stage == "idle" and str(bbl.get("status","")).lower() not in ("complete", "finish"):

            bbl["status"] = "idle"

        return [data["cc1"], data["cc2"], bbl]

    except Exception as e:

        print(f"Fetch error: {e}")

        return None

 

 

# ── MAIN LOOP ─────────────────────────────────────────────────

 

def main():

    # Show startup message while connecting

    clear_all()

    draw_text_centered("CONNECTING", 10, 5)

    draw_text_centered("TO WIFI", 17, 7)

 

    requests_session = init_wifi()

 

    # Initial data fetch

    printers = [

        {"nozzle": 0, "bed": 0, "pct": 0, "status": "idle", "remaining": "0"},

        {"nozzle": 0, "bed": 0, "pct": 0, "status": "idle", "remaining": "0"},

        {"nozzle": 0, "bed": 0, "pct": 0, "status": "idle", "remaining": "0"},

    ]

 

    last_fetch   = 0

    last_cycle   = 0

    last_flash   = 0

    current_page = 0

    flash_state  = True

 

    # Dirty-flag tracking — only redraw when something actually changes

    last_drawn_page     = -1

    last_drawn_statuses = []

    last_drawn_pcts     = []

    last_drawn_flash    = None

    last_drawn_all_idle = None

    needs_redraw        = True  # always draw once on startup

 

    while True:

        now = time.monotonic()

 

        # ── Fetch from HA every POLL_INTERVAL seconds

        if now - last_fetch >= POLL_INTERVAL:

            result = fetch_printer_data(requests_session)

            if result:

                if result != printers:

                    printers = result

                    needs_redraw = True

            last_fetch = now

 

        # ── Compute current state

        statuses     = [normalize_status(p.get("status", "idle")) for p in printers]

        any_error    = any(s == "error" for s in statuses)

        any_printing = any(s == "printing" for s in statuses)

        all_idle     = all(s == "idle" for s in statuses)

        current_pcts = [p.get("pct", 0) for p in printers]

 

        # ── Build slide list:

        #    - One slide per printing/error printer (in order: CC1, CC2, A1)

        #    - One consolidated idle slide at the end if any printers are idle

        idle_indices    = [i for i, s in enumerate(statuses) if s == "idle"]

        active_indices  = [i for i, s in enumerate(statuses) if s != "idle"]

        # slides is a list of: printer_index (int) or "idle" sentinel

        slides = active_indices + (["idle"] if idle_indices else [])

        if not slides:

            slides = ["idle"]  # shouldn't happen but safe fallback

        num_slides = len(slides)

 

        # ── Advance page every CYCLE_INTERVAL seconds

        if now - last_cycle >= CYCLE_INTERVAL:

            new_page = (current_page + 1) % num_slides

            if new_page != current_page:

                current_page = new_page

                needs_redraw = True

            last_cycle = now

 

        # Keep current_page in bounds if slide count changed (e.g. print finished)

        if current_page >= num_slides:

            current_page = 0

            needs_redraw = True

 

        # ── Flash toggle — only fires when an error is actually present

        # Updates ONLY the 3x3 dot pixels in place — no full redraw

        if any_error and now - last_flash >= FLASH_RATE:

            flash_state = not flash_state

            last_flash  = now

            # Find which slide is currently showing and update just its dot

            if not all_idle:

                slide = slides[current_page] if current_page < len(slides) else None

                if slide is not None and slide != "idle":

                    if statuses[slide] == "error":

                        dot_idx = 3 if flash_state else 0  # yellow or black

                        draw_dot(1, 1, dot_idx)

                elif slide == "idle":

                    # Idle group slide — update dots for any error printers shown

                    row_ys = [1, 9, 17]

                    for slot, idx in enumerate(idle_indices):

                        if statuses[idx] == "error":

                            dot_idx = 3 if flash_state else 0

                            draw_dot(1, row_ys[slot], dot_idx)

            elif all_idle:

                # All-idle screen — update dots for any error printers

                rows = [11, 18, 25]

                for i, s in enumerate(statuses):

                    if s == "error":

                        dot_idx = 3 if flash_state else 0

                        draw_dot(1, rows[i], dot_idx)

 

        # ── Redraw if pct changed while printing

        if any_printing and current_pcts != last_drawn_pcts:

            needs_redraw = True

 

        # ── Skip draw if nothing changed

        if not needs_redraw:

            time.sleep(0.1)

            continue

 

        # ── Redraw ───────────────────────────────────────────────

        if all_idle:

            draw_all_idle(printers)

        else:

            slide = slides[current_page]

            if slide == "idle":

                draw_idle_group_slide(idle_indices, printers)

            else:

                p      = printers[slide]

                status = statuses[slide]

                name   = full_names[slide]

                draw_printer_slide(p, name, status, flash_state, slide)

 

        # Record what we just drew

        last_drawn_page     = current_page

        last_drawn_statuses = statuses[:]

        last_drawn_pcts     = current_pcts[:]

        last_drawn_flash    = flash_state

        last_drawn_all_idle = all_idle

        needs_redraw        = False

 

        time.sleep(0.05)  # brief yield after a draw

 

 

main()