klipper-build.sh

#!/usr/bin/env bash
# klipper-build.sh — Klipper-Firmware pro Board aus eigener Config bauen
#
# Idee: Klipper legt seine Kconfig-Auswahl normalerweise in ~/klipper/.config
# ab und baut nach ~/klipper/out/. Beides laesst sich per Make-Variable
# umbiegen:
#     KCONFIG_CONFIG  -> Pfad der Config-Datei
#     OUT             -> Build-Verzeichnis (MUSS auf / enden!)
# Damit bekommt jedes Board seine eigene Config und sein eigenes out-Dir,
# und ein Update ist "git pull" + "build all".
#
# Layout:
#   $CONFIG_DIR/<board>.config     Kconfig-Auswahl des Boards   (versionierbar)
#   $CONFIG_DIR/<board>.devices    USB-Pfade (/dev/serial/by-id/...), eine pro Zeile
#   $CONFIG_DIR/<board>.flash      optional: eigenes Flash-Kommando, $FW = Firmware
#   $BUILD_DIR/<board>/            Build-Output, klipper.bin/.uf2/.elf
#
# Ein "board" ist ein Board-TYP, nicht ein physisches Board: sechs baugleiche
# NHK36 teilen sich eine Config und eine Firmware und werden nur mehrfach
# geflasht -- je USB-Pfad aus <board>.devices.
#
# Nutzung:
#   ./klipper-build.sh new     <board>   neue Config anlegen (menuconfig)
#   ./klipper-build.sh menu    <board>   bestehende Config aendern
#   ./klipper-build.sh build   <board>   bauen
#   ./klipper-build.sh build   all       alle Boards bauen
#   ./klipper-build.sh flash   <board>   bauen + auf alle Geraete flashen
#   ./klipper-build.sh flash   all       alles bauen + flashen
#   ./klipper-build.sh usb               angeschlossene USB-MCUs auflisten
#   ./klipper-build.sh list              Boards anzeigen
#   ./klipper-build.sh status            Host- vs. Firmware-Version je Board
#   ./klipper-build.sh clean   <board>|all
#   ./klipper-build.sh version           Script-Version
#
# Umgebungsvariablen:
#   DRY_RUN=1        nichts flashen, nur zeigen was passieren wuerde
#   FLASH_METHOD=    auto (Standard) | katapult | make
#   BOOTLOADER_WAIT= Sekunden, die auf den Bootloader gewartet wird (20)

set -euo pipefail

SCRIPT_VERSION="1.0.0"

KLIPPER_DIR="${KLIPPER_DIR:-$HOME/klipper}"
CONFIG_DIR="${CONFIG_DIR:-$HOME/klipper_boards}"
BUILD_DIR="${BUILD_DIR:-$HOME/klipper_builds}"

die()  { echo "FEHLER: $*" >&2; exit 1; }
info() { echo -e "\033[1;36m==>\033[0m $*"; }

# "version" und "help" sollen auch ohne Klipper-Installation laufen
case "${1:-help}" in
    version|--version|-V|help|--help|-h) ;;
    *)
        [ -d "$KLIPPER_DIR" ] || die "Klipper-Verzeichnis nicht gefunden: $KLIPPER_DIR"
        mkdir -p "$CONFIG_DIR" "$BUILD_DIR"
        ;;
esac

cfg_of()   { echo "$CONFIG_DIR/$1.config"; }
out_of()   { echo "$BUILD_DIR/$1/"; }   # Trailing Slash ist Pflicht
flash_of() { echo "$CONFIG_DIR/$1.flash"; }
devs_of()  { echo "$CONFIG_DIR/$1.devices"; }

# Klipper-Dienst waehrend des Flashens anhalten (USB-Port ist sonst belegt)
KLIPPER_SERVICE="${KLIPPER_SERVICE:-klipper}"
svc() { sudo systemctl "$1" "$KLIPPER_SERVICE" 2>/dev/null || true; }

boards() {
    local f
    for f in "$CONFIG_DIR"/*.config; do
        [ -e "$f" ] || continue
        basename "$f" .config
    done
}

# make im Klipper-Dir mit board-spezifischen Variablen
kmake() {
    local board="$1"; shift
    make -C "$KLIPPER_DIR" \
        KCONFIG_CONFIG="$(cfg_of "$board")" \
        OUT="$(out_of "$board")" \
        "$@"
}

do_menu() {
    local board="$1"
    kmake "$board" menuconfig
    info "Config gespeichert: $(cfg_of "$board")"
}

do_build() {
    local board="$1" cfg out
    cfg="$(cfg_of "$board")"
    out="$(out_of "$board")"
    [ -f "$cfg" ] || die "Keine Config fuer '$board' ($cfg). Erst: $0 new $board"
    mkdir -p "$out"
    info "Board '$board': olddefconfig (neue Kconfig-Optionen uebernehmen)"
    kmake "$board" olddefconfig
    info "Board '$board': build -> $out"
    kmake "$board" -j"$(nproc)"
    echo "    Firmware: $(firmware_path "$board")"
}

firmware_path() {
    local out f
    out="$(out_of "$1")"
    for f in klipper.bin klipper.uf2 klipper.elf.hex klipper.elf; do
        if [ -f "$out$f" ]; then
            echo "$out$f"
            return 0
        fi
    done
    die "Keine Firmware-Datei in $out gefunden"
}

################ Flashen ueber Katapult
#
# Warum nicht einfach "make flash"? Klippers scripts/flash_usb.py schickt den
# 1200-Baud-Reset und ruft dann wait_path() -- das wartet 100 ms und prueft, ob
# der sysfs-Pfad existiert. Das ist aber noch der Pfad des ALTEN Klipper-
# Geraets. Hat sich das Board noch nicht abgemeldet, meldet wait_path faelsch-
# licherweise "Device reconnect", detect_canboot() liest die alte USB-VID/PID,
# erkennt Katapult NICHT und faellt auf dfu-util zurueck -> "No DFU capable USB
# device available", obwohl das Board brav in Katapult sitzt.
#
# Deshalb machen wir den Ablauf hier selbst und ohne Rennen:
#   1. Katapult-Geraet des Boards suchen (ueber die Chip-ID)
#   2. wenn keins da: per "flashtool.py -r" den Bootloader anfordern
#   3. aktiv pollen, bis das Katapult-Geraet auftaucht
#   4. mit flashtool.py flashen
# Nur wenn gar kein Katapult existiert, geht es klassisch ueber "make flash".

BOOTLOADER_WAIT="${BOOTLOADER_WAIT:-20}"
FLASH_METHOD="${FLASH_METHOD:-auto}"
DRY_RUN="${DRY_RUN:-0}"

# Kommando ausfuehren -- oder bei DRY_RUN nur zeigen
run() {
    if [ "$DRY_RUN" = "1" ]; then
        echo "    [dry-run] $*"
        return 0
    fi
    "$@"
}

flashtool() {
    local ft
    for ft in "$KLIPPER_DIR/lib/katapult/flashtool.py" \
              "$HOME/katapult/scripts/flashtool.py"; do
        if [ -f "$ft" ]; then
            echo "$ft"
            return 0
        fi
    done
    return 1
}

# python3, das pyserial hat (Katapult braucht es)
kat_python() {
    local p
    for p in python3 "$HOME/klippy-env/bin/python" "$HOME/katapult-env/bin/python3"; do
        if command -v "$p" >/dev/null 2>&1 && "$p" -c "import serial" 2>/dev/null; then
            echo "$p"; return 0
        fi
    done
    echo "python3"
}

# Chip-ID aus /dev/serial/by-id/usb-Klipper_rp2040_3232...8300-if00
chipid_of() { basename "$1" | sed -E 's/^.*_([^_]+)-if[0-9]+.*$/\1/'; }

# Das Katapult-Geraet zum selben Chip finden. Ueber die Chip-ID, damit bei
# sechs baugleichen NHK36 garantiert das richtige Board erwischt wird.
BYID="${BYID:-/dev/serial/by-id}"
kat_dev_of() {
    local chip="$1" f
    for f in "$BYID"/*"$chip"*; do
        [ -e "$f" ] || continue
        case "$(basename "$f")" in
            *[Kk]lipper*) continue ;;
            *) echo "$f"; return 0 ;;
        esac
    done
    return 1
}

wait_for_kat() {
    local chip="$1" waited=0 kat
    while [ "$waited" -lt "$BOOTLOADER_WAIT" ]; do
        sleep 1
        waited=$((waited + 1))
        if kat="$(kat_dev_of "$chip")"; then
            sleep 1   # udev/Rechte kurz nachziehen lassen
            echo "$kat"; return 0
        fi
    done
    return 1
}

# Weg A: direkt ueber Katapult -- umgeht flash_usb.py und damit das Rennen
flash_katapult() {
    local board="$1" dev="$2" fw chip kat ft py
    ft="$(flashtool)" || { info "Kein flashtool.py gefunden"; return 1; }
    fw="$(firmware_path "$board")"
    chip="$(chipid_of "$dev")"
    py="$(kat_python)"

    if kat="$(kat_dev_of "$chip")"; then
        info "Board sitzt bereits in Katapult: $(basename "$kat")"
    elif [ -e "$dev" ]; then
        info "Fordere Bootloader an (chip $chip)"
        run "$py" "$ft" -d "$dev" -r || true
        if [ "$DRY_RUN" = "1" ]; then
            echo "    [dry-run] warte auf Katapult, dann flashen"
            return 0
        fi
        if ! kat="$(wait_for_kat "$chip")"; then
            echo "    Katapult ist nach ${BOOTLOADER_WAIT}s nicht aufgetaucht." >&2
            return 1
        fi
        info "Katapult da: $(basename "$kat")"
    else
        return 1   # weder Klipper- noch Katapult-Geraet -> Weg B probieren
    fi

    run "$py" "$ft" -d "$kat" -f "$fw"
}

# Weg B: klassisch ueber "make flash", mit Warteschleife und zweitem Anlauf
# ueber den Bootloader (das ist der Ablauf aus v3, der bei dir laeuft)
flash_make() {
    local board="$1" dev="$2" chip kat bl
    chip="$(chipid_of "$dev")"

    if [ -e "$dev" ]; then
        if run kmake "$board" flash FLASH_DEVICE="$dev"; then
            return 0
        fi
        echo >&2
        info "Erster Versuch fehlgeschlagen -- warte ${BOOTLOADER_WAIT}s auf den Bootloader"
        sleep "$BOOTLOADER_WAIT"
    else
        info "$dev nicht da -- haengt das Board noch im Bootloader?"
    fi

    if kat="$(kat_dev_of "$chip")"; then
        info "Katapult gefunden: $(basename "$kat") -- zweiter Versuch"
        run kmake "$board" flash FLASH_DEVICE="$kat"
        return
    fi
    for bl in 0483:df11 1209:beba; do
        if lsusb -d "$bl" >/dev/null 2>&1; then
            info "DFU-Bootloader $bl aktiv -- zweiter Versuch"
            run kmake "$board" flash FLASH_DEVICE="$bl"
            return
        fi
    done

    echo "    FEHLER: weder $dev noch ein Bootloader fuer chip $chip gefunden." >&2
    echo "            Pruefen mit: lsusb   und   ls /dev/serial/by-id/" >&2
    return 1
}

flash_one() {
    local board="$1" dev="$2" ok=1
    case "$FLASH_METHOD" in
        make)     flash_make     "$board" "$dev" && ok=0 ;;
        katapult) flash_katapult "$board" "$dev" && ok=0 ;;
        auto)
            if flash_katapult "$board" "$dev"; then
                ok=0
            else
                info "Katapult-Weg nicht moeglich -- klassischer Weg"
                flash_make "$board" "$dev" && ok=0
            fi ;;
        *) die "Unbekannte FLASH_METHOD: $FLASH_METHOD (auto|katapult|make)" ;;
    esac
    [ "$ok" -eq 0 ] || return 1
    record_flash "$board" "$dev"
}

################ Versionsstand festhalten

# Version, die in die gebaute Firmware einkompiliert ist
built_version() {
    local out; out="$(out_of "$1")"
    [ -f "$out"klipper.dict ] || { echo "?"; return 0; }
    python3 -c "import json,sys;print(json.load(open(sys.argv[1])).get('version','?'))" \
        "$out"klipper.dict 2>/dev/null || echo "?"
}

host_version() {
    git -C "$KLIPPER_DIR" describe --tags --always --long --dirty 2>/dev/null || echo "?"
}

record_flash() {
    local board="$1" dev="$2" f chip
    [ "$DRY_RUN" = "1" ] && return 0
    chip="$(chipid_of "$dev")"
    f="$(out_of "$board").flashed"
    : > "$f.tmp"
    if [ -f "$f" ]; then
        grep -v "^$chip " "$f" >> "$f.tmp" || true
    fi
    mv "$f.tmp" "$f"
    echo "$chip $(built_version "$board") $(date '+%Y-%m-%d %H:%M')" >> "$f"
}

do_status() {
    local b f chip ver when line dev known=""
    echo "Klipper-Repo (Host): $(host_version)"
    echo
    printf '%-26s %-26s %s\n' "BOARD / CHIP-ID" "VERSION" "STAND"
    for b in $(boards); do
        printf '%-26s %-26s %s\n' "$b" "$(built_version "$b")" "(gebaut)"
        f="$(out_of "$b").flashed"
        while read -r dev; do
            chip="$(chipid_of "$dev")"
            known="$known $chip"
            ver="-- nie geflasht --"; when=""
            if [ -f "$f" ] && line="$(grep "^$chip " "$f" 2>/dev/null)"; then
                ver="$(echo "$line" | cut -d' ' -f2)"
                when="$(echo "$line" | cut -d' ' -f3-)"
            fi
            printf '  %-24s %-26s %s\n' "$chip" "$ver" "$when"
        done < <(device_list "$b")
    done
    echo
    echo "Nicht von diesem Script verwaltete USB-MCUs:"
    local found=0
    for f in "$BYID"/*; do
        [ -e "$f" ] || continue
        chip="$(chipid_of "$f")"
        case " $known " in *" $chip "*) continue ;; esac
        echo "    $(basename "$f")"
        found=1
    done
    [ "$found" -eq 1 ] || echo "    (keine)"
}

device_list() {
    local f; f="$(devs_of "$1")"
    [ -f "$f" ] || return 0
    grep -vE '^\s*(#|$)' "$f" || true
}

do_flash() {
    local board="$1" fl fw dev n=0; local -a devs
    do_build "$board"
    fl="$(flash_of "$board")"
    fw="$(firmware_path "$board")"

    if [ -f "$fl" ]; then
        info "Board '$board': eigenes Flash-Kommando ($fl)"
        FW="$fw" bash "$fl"
        return
    fi

    mapfile -t devs < <(device_list "$board")
    if [ "${#devs[@]}" -eq 0 ]; then
        if [ -z "${FLASH_DEVICE:-}" ]; then
            echo "    UEBERSPRUNGEN: weder $(devs_of "$board") noch FLASH_DEVICE gesetzt (Tipp: $0 usb)" >&2
            FAILED="${FAILED}${FAILED:+, }$board (kein Geraet)"
            return 0
        fi
        devs=("$FLASH_DEVICE")
    fi

    # Dienst IMMER wieder starten -- auch wenn ein Board scheitert oder der
    # Lauf mit Strg-C abgebrochen wird. Sonst bleibt der Drucker offline.
    info "Klipper-Dienst anhalten"
    svc stop
    trap 'info "Klipper-Dienst starten"; svc start' EXIT INT TERM

    for dev in "${devs[@]}"; do
        n=$((n + 1))
        info "Board '$board' [$n/${#devs[@]}]: flashe $dev"
        if ! flash_one "$board" "$dev"; then
            FAILED="${FAILED}${FAILED:+, }$board:$dev"
        fi
        sleep 3   # Board muss nach dem Reset erst wieder enumerieren
    done

    trap - EXIT INT TERM
    info "Klipper-Dienst starten"
    svc start
}

do_usb() {
    local f found=0
    info "Angeschlossene USB-MCUs ($BYID):"
    for f in "$BYID"/*; do
        [ -e "$f" ] || continue
        echo "    $f"
        found=1
    done
    [ "$found" -eq 1 ] || echo "    (keine gefunden)"
    echo
    echo "Diese Zeilen in $CONFIG_DIR/<board>.devices eintragen."
    echo "Die RP2040-Seriennummer kommt aus der Flash-Chip-ID -- jedes NHK36"
    echo "hat also dauerhaft seinen eigenen, stabilen Pfad."
}

for_each() {
    local fn="$1" arg="$2" b
    if [ "$arg" = "all" ]; then
        for b in $(boards); do "$fn" "$b"; done
    else
        "$fn" "$arg"
    fi
}

FAILED=""
cmd="${1:-help}"; arg="${2:-}"
case "$cmd" in
    new|menu|menuconfig)
        [ -n "$arg" ] || die "Board-Name fehlt"
        do_menu "$arg" ;;
    build)
        [ -n "$arg" ] || die "Board-Name oder 'all' fehlt"
        for_each do_build "$arg" ;;
    flash)
        [ -n "$arg" ] || die "Board-Name fehlt"
        for_each do_flash "$arg"
        [ -z "$FAILED" ] || die "Nicht geflasht: $FAILED" ;;
    usb)
        do_usb ;;
    status)
        do_status ;;
    version|--version|-V)
        echo "klipper-build.sh $SCRIPT_VERSION" ;;
    list)
        info "Boards in $CONFIG_DIR:"
        for b in $(boards); do
            printf '    %-14s %s Geraet(e)\n' "$b" "$(device_list "$b" | wc -l)"
        done ;;
    clean)
        [ -n "$arg" ] || die "Board-Name oder 'all' fehlt"
        if [ "$arg" = "all" ]; then
            rm -rf "${BUILD_DIR:?}"/*
        else
            rm -rf "$(out_of "$arg")"
        fi
        info "Build-Verzeichnis(se) geloescht (Configs bleiben erhalten)" ;;
    *)
        sed -n '2,38p' "$0" | sed 's/^# \{0,1\}//' ;;
esac