Ein Service für einen headless Paperless-NGX Server, der darauf wartet, dass der Scanknopf an einem beliebigen Epson-Scanner im Netzwerk gedrückt wird, um dann vollautomatisch einen Scanvorgang zu starten und die Dokumente in das Paperless Consume-Verzeichnis zu übergeben.

Unser Chaos

Ständig suchten wir Unterlagen über alles Mögliche. Die Ordner und sinnlosen Stapel in Schubladen und Regalfächern wurden immer dicker und dicker, das Suchen dauerte länger und länger. Es war eine echte Katastrophe. Mit Paperless-NGX könnten wir unserer Papierflut Herr werden:

• Text in Dokumenten erkennen lassen (OCR)
• Per Volltextsuche schnell finden
• Regeln für automatische Ablage definieren
• Automatisch Tags und Korrespondenten zuordnen
• Dokumente zentral im Webbrowser verwalten
• Verschiedene Dateiformate verarbeiten
• Langzeitarchivierung ermöglichen (PDF/A)
• Korrespondenten (Kontakte) verwalten

Und es musste ein Dokumentenscanner her. Netzwerkfähig und schnell musste er sein.  Wir müssen die Unterlagen der vergangenen Jahre einscannen, dafür ist unser Canon Multifunktionsgerät viel zu langsam. Der kann zwar in ein Netzwerk scannen, aber die Bedienung ist einfach viel zu umständlich dafür. Nein, das Ding ist eine Qual für unser Projekt.

Es gibt Dokumentenscanner, die direkt von sich aus in ein Netzwerklaufwerk scannen können. Die haben allesamt ihren Preis und als wir kaufen wollten, war keiner im Angebot. Mein Favorit wäre Brother gewesen, die bieten einfach die besten Treiber an, auch nach vielen, vielen Jahren noch. Nur sind die auch nicht gerade billig.

Es gibt unzählige Dokumentenscanner am Markt. Preise so um die 500 bis 900 EUR. Klar, mit einem fetten Budget ist das kein Problem, haben wir aber nicht.

Die günstigsten, guten Geräte sind von Epson. Der Epson WorkForce ES-580W für rund 380 EUR bietet alles, was wir benötigen. Aber der ist immer noch zu teuer. Meine Schmerzgrenze lag bei 240 EUR, was aus meiner Sicht immer noch eine Menge Holz ist!

Es gab aber einen kleinen Bruder, der auf dem Papier fast alles ebenso gut konnte, wie der 580W, nur kein Display hat! Benötige ich nicht, mir reicht die WebGUI des Scanners aus! Dachte ich, zumindest.

Wir haben unseren Epson WorkForce ES-500W II direkt über Epson auf Ebay mit einigen Rabattgutscheinen für 269 EUR bekommen. Ob des guten Kurses, der versprochenen Netzwerkfähigkeit und der ausgezeichneten Rezensionen auf YouTube schlugen wir zu.

ES-500W II:

• Hohe Scangeschwindigkeit (35 Seiten/min)
• Beidseitig scannen in einem Durchgang (= 70 Seiten/min)
• 50 Blatt ADF
• Robuste Mechanik (bis 4.000 Scans/Tag)
• Erkennt Doppelblatteinzug (Ultraschallsensor)

Oh, Epson!

Epson bietet keine Unterstützung für Headless-Server, wie PaperlessNGX, an. Das funktioniert nur mit einem PC mit grafischem Betriebssystem wie macOS, Linux oder Windows im selben Netz. Darauf muss EpsonScan2 laufen und der User muss einen Scanbutton anklicken. Der Scanner schickt dann die Scans an den Desktop-PC, und der schiebt sie auf das Netzwerklaufwerk. Das versteht Epson dann unter „Netzwerkfähigkeit“. :-( Ich nenne es „umständlich“ und „unscharfes Werbeversprechen“.

Ich nahm mit dem deutschen Support Kontakt auf. Nein, die haben keine Lösung für mein Problem. Dokumentation der Netzwerkprotokolle haben sie auch nicht. Also musste ich selbst ran und ein Script erstellen.

Freies Wissen

Ich habe den Scanner am 02.04.2025 erhalten und erst am 13. Mai lief Eppascan das erste Mal durchgehend fehlerfrei. Es hat mich entschieden zu viel Zeit gekostet und das steht im kleinen Verhältnis zur Ersparnis beim Kauf des Scanners. Es war während der Entwicklung allerdings schon viel mächtiger. Leider verzettelte ich mich in Dingen wie der Modularität oder der Erkennung der Scanner im Netz. Ich hatte zig dedizierte Scripte und am Ende funktionierte vieles einfach nicht mehr zuverlässig und ich begann (immer wieder!) von vorn. Es war zwischenzeitlich so schlimm, dass ich bereits vom Script und der Fehlerbehebung träumte.

Komplizierte Lösungen zu finden, ist einfach. Ich lernte bereits zu meinen Commodore 64-Zeiten, dass am Ende nur simple Lösungen zum Ziel führen. Der Code muss verständlich, übersichtlich und wartbar sein.

Ich bin absoluter Anfänger auf diesem Gebiet, ohne die verschiedenen KIs und deren guten Erklärungen zu den verschiedenen Befehlen hätte ich dieses Script nie erstellt. Ich mag es nicht, Anleitungen zu lesen und Befehle auswendig zu lernen. Dafür habe ich auch nicht die Zeit. Und ich bin auch zu alt für die Lektüre von Manpages. :-) Ich wusste nur, was ich erreichen, welche Tools (Sane z.B.) ich benutzen und welche Lösungen (Button-Erkennung durch gesendete Pakete des Scanners) ich wollte. Gerade bei letzteren Punkten sind KIs schrecklich einfallslos.

Aber wie auch bei meinen 3D-Druck-Modellen bin ich der Überzeugung, dass Wissen frei sein muss. Die ganze Website basiert ja darauf! Niemand sollte für seine Projekte von Anfang an beginnen müssen! Auch ich habe meine Informationen aus freien Quellen im Netz zusammengetragen:

• Meine Recherchen wurden zu Anleitungen und zu den "Meine Gedanken über"-Artikeln
• Meine eigenen Modelle findet man kostenlos auf Thingiverse und Printables
• Der Hausblog dient als Informationsquelle für jeden, der ein Haus bauen oder sanieren will
• Meine Amazon-Rezensionen wurden zu Testberichten

Ich bin nun Softwareentwickler!

Na ja, jedenfalls habe ich nun ein eigenes Github-Repo. :-) Dort findet Ihr Eppascan. Das Script hat mich viel Zeit und viele Nerven gekostet. Aber es funktioniert nun richtig gut. Zumindest auf meinem Paperless-NGX-LXC unter Proxmox und mit meinem Epson ES-500W II.

Aber was ist denn jetzt Eppascan?

Eppascan

Epson Scanner Anbindung für Paperless-NGX auf einem Headless Server (Proxomox)

Beschreibung

Eppascan ist eine automatisierte Lösung zur nahtlosen Integration von Epson-Netzwerkscannern mit Paperless-NGX. Das System besteht aus zwei Komponenten:

1. eppascan.sh
   Ein Daemon-Skript, das auf einem Linux-Server kontinuierlich auf Epson-Scanner-Broadcasts im lokalen Netzwerk lauscht. Sobald ein Scanvorgang am Scanner per Knopfdruck ausgelöst wird, erkennt das Skript den Scanner, wartet optional auf die Initialisierung, startet einen automatischen Duplex-Scan aller Seiten im Einzug (ADF) und speichert die Scans direkt im Paperless-consume-Verzeichnis (/opt/paperless/consume). Status- und Fehlermeldungen werden mit Zeitstempel in eine Logdatei geschrieben.
2. eppascan-install
   Ein Installationsskript, das alle erforderlichen Pakete und Abhängigkeiten installiert, das Hauptskript an den richtigen Ort kopiert, die Systemdiensteinrichtung (systemd) übernimmt und die notwendigen Rechte setzt. Damit wird der Scan-Dienst automatisch beim Systemstart ausgeführt und ist sofort einsatzbereit.

Mit Eppascan werden Scanvorgänge direkt und effizient in den Paperless-Workflow integriert – ganz ohne manuelle Zwischenschritte oder zusätzliche Software.

Anleitung

Bitte beachten, dass es nach dem Drücken des Scanknopfs am Epson-Scanner etwa 15 Sekunden dauert, bis der eigentliche Scanvorgang beginnt. Bitte Geduld!

Der Ablauf ist wie folgt:

• Papier in den Einzug (ADF) einlegen.
• Der Scanner wacht auf, die WLAN-Symbole leuchten auf.
• Scanknopf drücken.
• Das orangefarbene Ausrufezeichen am Scanner leuchtet kurz auf und erlischt nach einigen Sekunden wieder.
• Erst danach startet der Scan und alle Seiten im ADF werden automatisch eingezogen und verarbeitet.

Ursache der Wartezeit:

Nach dem Drücken des Scanknopfs sucht der Scanner zunächst nach der originalen Epson Scan 2 Software im Netzwerk. Da diese in dieser Lösung nicht vorhanden ist, wartet der Scanner einen Moment und sendet dann erneut einen Broadcast. Während dieser Zeit reagiert er leider nicht auf Anfragen oder Befehle. Diese Verzögerung ist also technisch bedingt und leider nicht zu ändern..

Hinweis zur Konfiguration:

Die voreingestellte Wartezeit im Script beträgt 15 Sekunden. Sollte der Scanvorgang nicht zuverlässig starten (z.B. weil der Scanner nach dem Aufwachen noch nicht bereit ist), kann es sinnvoll sein, diesen Wert im Script (SCAN_INITIAL_DELAY) zu erhöhen.
Den Wert ggf. anpassen, falls der Scanner mehr Zeit zur Herstellung der Bereitschaft benötigt.

Dokumentation

Hinweis: Dieses Script wurde speziell für die Paperless-NGX Installation über die ProxmoxVE UserHelperScripts entwickelt und getestet. In dieser Umgebung wird das Scrpt als root ausgeführt, da tcpdump nur über diesen Account funktioniert.

1. Einleitung

Eppascan ist eine Open-Source-Lösung zur automatischen Integration von Epson-Netzwerkscannern (z.B. ES-500WII) mit Paperless-NGX. Das System besteht aus einem Daemon-Skript für den Scanbetrieb und einem Installationsskript für die einfache Einrichtung als Systemdienst. Nach der Installation werden Scanvorgänge am Scanner automatisch erkannt und die gescannten Dokumente direkt im consume-Verzeichnis von Paperless-NGX abgelegt.

2. Funktionsweise

1. Lauschen auf Scanner-Broadcasts: Das Hauptskript (eppascan.sh) überwacht das lokale Netzwerk auf spezielle Multicast-Broadcasts, die Epson-Scanner beim Drücken der Scan-Taste aussenden.
2. Automatischer Scanvorgang: Nach Erkennung eines Scannersignals wird ein Duplex-Scan aller Seiten im automatischen Dokumenteneinzug (ADF) gestartet. Die Scans werden als Bilddateien (JPEG) mit Zeitstempel im Zielordner gespeichert.
3. Direkte Integration in Paperless-NGX: Die Scan-Dateien landen im /opt/paperless/consume-Verzeichnis, von wo sie Paperless-NGX automatisch verarbeitet (Umwandlung in PDF, OCR, Sortierung etc.).
4. Automatischer Dienststart: Das Installationsskript (eppascan-install.sh) richtet das Hauptskript als Systemdienst (systemd) ein, sodass Eppascan nach jedem Neustart automatisch im Hintergrund läuft.

3. Voraussetzungen

• Ein Epson-Netzwerkscanner (getestet mit ES-500WII, andere Modelle mit rudimentärer Netzwerkfunktion, aber ohne Scan-to-Folder, sollten ebenfalls funktionieren). Der Scanner muss im Netzwerk angemeldet sein.
• Ein Linux-Server (Debian/Ubuntu empfohlen, Proxmox LXC getestet)
• Paperless-NGX installiert und konfiguriert (/opt/paperless/consume existiert und ist beschreibbar)
• Netzwerkzugriff zwischen Scanner und Server (gleiche Subnetz, Multicast erlaubt)
• Root-Rechte (wie bei Proxmox UserHelperScripts üblich)

4. Installation

1. Repository klonen

   git clone https://github.com/michael-hessi/Eppascan.git /tmp/Eppascan

2. Ins Verzeichnis wechseln und Installationsskript ausführbar machen

   cd /tmp/Eppascan 
   chmod +x eppascan_install.sh

3. Installationsskript ausführen

   ./eppascan_install.sh

Das Installationsskript erledigt automatisch folgendes:

• Installation benötigter Pakete (tcpdump, sane-utils)
• Kopieren des Hauptskripts nach /usr/local/bin/
• Anlegen und Aktivieren des systemd-Services
• Setzen der passenden Rechte

Fertig!
Nach der Installation läuft der Dienst automatisch im Hintergrund und startet nach jedem Neustart des Systems.

5. Konfiguration

Die wichtigsten Einstellungen befinden sich direkt im Skript eppascan.sh und können bei Bedarf vor der Installation angepasst werden:

Tipp: Für optimale OCR-Ergebnisse in Paperless-NGX empfiehlt sich eine Scanauflösung von mindestens 300 dpi und die Nutzung des Graustufenmodus.

6. Anpassung für andere Scanner oder Netzwerke

• Multicast-Adresse: Epson verwendet 239.255.255.253. Andere Hersteller nutzen ggf. andere Adressen (z.B. Brother: 239.255.255.250). Mit tcpdump -i eth0 igmp lässt sich die Adresse ermitteln.
• Backend: Das Skript nutzt standardmäßig das epsonds-Backend von SANE. Für andere Scanner ggf. epson2 oder ein passendes Backend wählen.

7. Fehlerbehebung

Fehlerbehebung

Eppascan-Log prüfen

Bei Problemen mit der Scanner-Erkennung oder dem Scanvorgang empfiehlt es sich, das Eppascan-Logfile zu überprüfen. Dieses enthält detaillierte Status- und Fehlermeldungen, die bei der Diagnose helfen.

cat /var/log/eppascan_scanimage_errors.log 

Oder für die letzten Zeilen:

tail -n 50 /var/log/eppascan_scanimage_errors.log

Das Logfile zeigt unter anderem:

• Erkennung des Scanners und dessen IP-Adresse
• Start und Abschluss von Scanvorgängen
• Fehlermeldungen bei Netzwerk- oder Scannerproblemen
• Hinweise auf mögliche Ursachen bei fehlgeschlagenen Scans

Tipp:
Sollte der Scan nicht starten oder abbrechen, zuerst einen Blick in das Logfile werfen. Die dortigen Meldungen geben meist einen klaren Hinweis auf die Ursache.

• Scanner wird nicht erkannt:
  – Die Multicast-Adresse mit tcpdump -i eth0 igmp prüfen.
  – Firewall-/Netzwerkregeln kontrollieren: UDP 3289 (ENPC), UDP 3702 (WS-Discovery), TCP 1865 (Netzwerkscan), TCP 445 (SMB)
  – Scanner und Server müssen im selben Subnetz sein.
• Scan bricht nach einer Seite ab:
  – ADF korrekt bestücken (Papierstau ausschließen).
  – SANE-Backend testen:
  
scanimage -L

• Dateien erscheinen nicht in Paperless-NGX:
  – Rechte für /opt/paperless/consume prüfen:
  chown -R paperless:paperless /opt/paperless/consume
  – Paperless-Consumer-Log prüfen:
  journalctl -u paperless-consumer -f

8. Deinstallation

• Den Installer aufrufen:
  
eppascan_install.sh

  Uninstall auswählen.

9. Referenzen

• ProxmoxVE UserHelperScripts: Paperless-NGX
• Paperless-NGX Scanner Docs
• Epson Port Configuration
• SANE epsonds Backend

Wie funktioniert der Scanbefehl mit Variablen in Bash?

Das war für mich als völliger Anfänger die absolut größte Hürde! Im Bash-Skript werden Variablen verwendet, um den Scanvorgang flexibel zu steuern. So kann man Einstellungen wie Auflösung, Modus oder Dateinamen dynamisch anpassen, ohne den Befehl jedes Mal ändern zu müssen.

timeout "${SCAN_TIMEOUT}s" scanimage \ --device-name="epsonds:net:$DETECTED_IP" \ --source "ADF Duplex" \ --resolution "$SCAN_RESOLUTION" \ --mode "$SCAN_MODE" \ --format "$SCAN_FORMAT" \ --batch="$SCAN_FULLPATH_PATTERN" \ --batch-count -1 \ 1>/dev/null \ 2> >(while read -r line; do log_eppascan "[scanimage] $line"; done) || true 

• timeout "${SCAN_TIMEOUT}s": Führt den Scan nur für die angegebene Zeit (in Sekunden) aus. Die Variable $SCAN_TIMEOUT wird von Bash durch ihren Wert ersetzt, z.B. timeout "60s". Das verhindert, dass bei einem Fehler der Daemon nicht mehr reagiert, sondern die Hauptschleife beendet.
• --device-name="epsonds:net:$DETECTED_IP": Die Variable $DETECTED_IP enthält die IP-Adresse des Scanners, die durch tcpdump ermittelt wurde. So kann das Script auf jeden Epson-Scanner im Netz reagieren.
• --resolution "$SCAN_RESOLUTION", --mode "$SCAN_MODE", --format "$SCAN_FORMAT", --batch="$SCAN_FULLPATH_PATTERN": Alle diese Optionen bekommen ihren Wert aus Variablen. In Bash werden Variablen in Anführungszeichen automatisch durch ihren Wert ersetzt, auch wenn sie Leerzeichen oder Sonderzeichen enthalten. "ADF Duplex" würde sonst einen scanimage-Exit-Code-9 verursachen.
• --batch-count -1: Sorgt dafür, dass alle Blätter im automatischen Einzug (ADF) gescannt werden. Das ist aber von der Firmware des Scanner abhängig und funktioniert eventuell nicht immer korrekt.
• 1>/dev/null: Die Standardausgabe (alles, was scanimage normalerweise anzeigt) wird verworfen. Das ist ja am Ende ein Service und soll keine CLI-Rückmeldungen geben.
• 2> >(while read -r line; do log_eppascan "[scanimage] $line"; done): Fehlerausgaben (stderr) werden Zeile für Zeile an eine eigene Funktion (log_eppascan) weitergeleitet. Das ist ein sogenannter Process Substitution. Damit erscheinen im Eppascan-Log auch die Fehlermeldungen von scanimage.
• || true: Selbst wenn der Scanbefehl fehlschlägt, läuft das Skript weiter und bricht nicht ab. Wichtig, damit der Dienst online bleibt.

Wichtig: In Bash werden Variablen mit $VARNAME beim Ausführen des Befehls durch ihren Wert ersetzt. Stehen sie in Anführungszeichen, werden auch Werte mit Leerzeichen korrekt übergeben.

Beispiel:
Angenommen, die Variablen sind so gesetzt:

 SCAN_TIMEOUT=60 DETECTED_IP=192.168.1.42 SCAN_RESOLUTION=300 SCAN_MODE=Gray SCAN_FORMAT=jpeg SCAN_FULLPATH_PATTERN="/opt/paperless/consume/scan_%03d.jpg" 

Dann wird Bash den Befehl so ausführen:

 timeout "60s" scanimage \ --device-name="epsonds:net:192.168.1.42" \ --source "ADF Duplex" \ --resolution "300" \ --mode "Gray" \ --format "jpeg" \ --batch="/opt/paperless/consume/scan_%03d.jpg" \ --batch-count -1 \ 1>/dev/null \ 2> >(while read -r line; do log_eppascan "[scanimage] $line"; done) || true 

Zusammengefasst:
Bash ersetzt Variablen beim Ausführen des Befehls automatisch durch ihre Werte. Es war mit wichtig, dass der Scanvorgang flexibel und leicht angepasst werden kann, ohne das Skript selbst zu ändern.

Die Scripte

Maximale Transparenz auch hier.

eppascan.sh

#!/usr/bin/env bash

# Eppascan – Epson Scanner Integration for Paperless-NGX, v0.1
#
# A service for a headless Paperless-NGX server that waits for the scan
# button on any networked Epson scanner to be pressed, to then
# automatically start a scan process and transfer the documents to the
# Paperless consume directory.
#
# Listens for Epson scanner broadcast and automatically scans all pages
# to /opt/paperless/consume
#
# Copyright (C) 2025 Michael Hessburg, www.hessburg.de
# License: GNU GPLv3 or later – see <http://www.gnu.org/licenses/>.

set -euo pipefail
IFS=$'\n\t'

# --- Configuration ---

NETWORK_INTERFACE="eth0"
MULTICAST_ADDR="239.255.255.253"
SCAN_INITIAL_DELAY=15
SCAN_TIMEOUT=300
SCAN_RESOLUTION="300"
SCAN_MODE="Gray"
SCAN_FORMAT="jpeg"
SCAN_OUTPUT_DIR="/opt/paperless/consume"
LOGFILE="/var/log/eppascan_scanimage_errors.log"

# --- Logging ---
log_eppascan() {
    echo "[$(date '+%Y-%m-%dT%H:%M:%S%z')] [EPPASCAN] $*" >> "$LOGFILE"
}

# --- Temp file & cleanup ---
TMP_TCPDUMP_OUTPUT=$(mktemp)
trap 'rm -f "$TMP_TCPDUMP_OUTPUT"; log_eppascan "Script terminated."; exit 0' SIGINT SIGTERM EXIT

log_eppascan "Script started. Listening on $NETWORK_INTERFACE for Epson scanner broadcasts."

# --- Main loop ---
while true; do
    : > "$TMP_TCPDUMP_OUTPUT"  # Clear the file using ':' (no-op)

    DETECTED_IP=""

    # Listen for IGMP packet (Epson broadcast)
    if ! tcpdump -i "$NETWORK_INTERFACE" -v igmp -l -c 1 > "$TMP_TCPDUMP_OUTPUT" 2>/dev/null; then
        log_eppascan "Warning: tcpdump failed on interface $NETWORK_INTERFACE."
        sleep 5
        continue
    fi

    # Check for multicast address and extract scanner IP
    if grep -q "$MULTICAST_ADDR" "$TMP_TCPDUMP_OUTPUT"; then
        DETECTED_IP=$(grep -oE '[0-9]{1,3}(\.[0-9]{1,3}){3}' "$TMP_TCPDUMP_OUTPUT" | head -n 1)
        log_eppascan "Detected scanner at $DETECTED_IP."
    else
        sleep 2
        continue
    fi

    if [[ -n "$DETECTED_IP" ]]; then
        log_eppascan "Waiting $SCAN_INITIAL_DELAY seconds for scanner initialization."
        sleep "$SCAN_INITIAL_DELAY"

        SCAN_FILENAME_BASE="scan_$(date +'%Y%m%d_%H%M%S')"
        SCAN_FULLPATH_PATTERN="$SCAN_OUTPUT_DIR/${SCAN_FILENAME_BASE}_%04d.$SCAN_FORMAT"

        log_eppascan "Starting scan to $SCAN_FULLPATH_PATTERN."

        timeout "${SCAN_TIMEOUT}s" scanimage \
            --device-name="epsonds:net:$DETECTED_IP" \
            --source "ADF Duplex" \
            --resolution "$SCAN_RESOLUTION" \
            --mode "$SCAN_MODE" \
            --format "$SCAN_FORMAT" \
            --batch="$SCAN_FULLPATH_PATTERN" \
            --batch-count -1 \
            1>/dev/null \
            2> >(while read -r line; do log_eppascan "[scanimage] $line"; done) || true

        log_eppascan "Scan process finished (errors, if any, are logged above)."
        sleep 5
    else
        log_eppascan "No scanner IP detected after IGMP packet. Retrying..."
        sleep 2
    fi

    sleep 2
done

eppascan_install.sh

#!/usr/bin/env bash

# Eppascan Installer & Maintenance Script
# Installs, repairs, or uninstalls the Eppascan daemon for Paperless (root only, suitable for LXC)
#
# Copyright (C) 2025 Michael Hessburg, www.hessburg.de
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.

set -euo pipefail

# --- Configuration ---
EPPASCAN_SCRIPT="eppascan.sh"                               # Name of the main script in current directory
EPPASCAN_TARGET="/usr/local/bin/eppascan.sh"                # Target path for the script
SERVICE_FILE="/etc/systemd/system/eppascan.service"     # Path for the systemd unit file
LOGFILE="/var/log/eppascan_scanimage_errors.log"        # Log file for Eppascan and scanimage errors

# --- Helper functions ---

# Print info message to terminal
info() {
    echo -e "3[1;32m[INFO]3[0m $*"
}

# Print warning message to terminal
warn() {
    echo -e "3[1;33m[WARN]3[0m $*"
}

# Print error message to terminal and exit
error() {
    echo -e "3[1;31m[ERROR]3[0m $*" >&2
    exit 1
}

# Check if script is run as root
require_root() {
    if [[ $EUID -ne 0 ]]; then
        error "This script must be run as root."
    fi
}

# Check if Eppascan is already installed
check_installed() {
    [[ -f "$EPPASCAN_TARGET" ]] && [[ -f "$SERVICE_FILE" ]]
}

# Install required packages if missing
install_dependencies() {
    info "Checking and installing required packages..."
    PKGS=(tcpdump sane-utils)
    for pkg in "${PKGS[@]}"; do
        if ! dpkg -s "$pkg" &>/dev/null; then
            info "Installing $pkg..."
            apt-get update
            apt-get install -y "$pkg"
        else
            info "$pkg is already installed."
        fi
    done
    # Verify scanimage is available
    if ! command -v scanimage &>/dev/null; then
        error "scanimage not found! Please check your SANE installation."
    fi
}

# Copy Eppascan script to target location
install_script() {
    info "Copying $EPPASCAN_SCRIPT to $EPPASCAN_TARGET..."
    cp "$EPPASCAN_SCRIPT" "$EPPASCAN_TARGET"
    chmod 755 "$EPPASCAN_TARGET"
}

# Ensure logfile exists and is writable
install_logfile() {
    info "Ensuring log file exists and is writable..."
    touch "$LOGFILE"
    chmod 644 "$LOGFILE"
}

# Create systemd service file and start service
install_service() {
    info "Creating systemd service file..."
    cat > "$SERVICE_FILE" <<EOF
[Unit]
Description=EPPASCAN Daemon
After=network.target

[Service]
Type=simple
ExecStart=$EPPASCAN_TARGET
Restart=always
User=root

[Install]
WantedBy=multi-user.target
EOF

    info "Reloading systemd daemon and enabling service..."
    systemctl daemon-reload
    systemctl enable eppascan.service
    systemctl restart eppascan.service
    info "Systemd service installed and started."
}

# Uninstall EPPASCAN completely
uninstall_all() {
    info "Stopping and disabling service..."
    systemctl stop eppascan.service || true
    systemctl disable eppascan.service || true
    info "Removing systemd service file..."
    rm -f "$SERVICE_FILE"
    info "Removing EPPASCAN script..."
    rm -f "$EPPASCAN_TARGET"
    info "Removing log file..."
    rm -f "$LOGFILE"
    systemctl daemon-reload
    info "EPPASCAN has been completely uninstalled."
}

# Repair existing installation
repair_install() {
    info "Repairing installation..."
    install_dependencies
    install_script
    install_logfile
    install_service
    info "Repair complete."
}

# User menu
main_menu() {
    echo "==============================="
    echo " EPPASCAN Installer/Maintenance "
    echo "==============================="
    if check_installed; then
        echo "EPPASCAN appears to be installed."
        echo "Choose an option:"
        echo "  [d] Uninstall EPPASCAN"
        echo "  [r] Repair/Reinstall EPPASCAN"
        echo "  [q] Quit"
        read -rp "Your choice: " CHOICE
        case "$CHOICE" in
            d|D) uninstall_all ;;
            r|R) repair_install ;;
            *) info "Aborted by user." ;;
        esac
    else
        echo "EPPASCAN is not installed. Starting fresh installation..."
        install_dependencies
        install_script
        install_logfile
        install_service
        info "Installation complete."
    fi
}

# --- Script execution ---

require_root

# Check if main script exists in current directory
if [[ ! -f "$EPPASCAN_SCRIPT" ]]; then
    error "EPPASCAN script $EPPASCAN_SCRIPT not found in current directory!"
fi

main_menu

Weitere Entwicklung

Es gab bereits ein einfaches Webend für die Änderung der Scaneinstellungen/Variablen. Das wird auch als Nächstes wiederkommen, aber im Moment will ich nun mein Script dafür nutzen, alle Dokumente einzuscannen.

Roadmap

• Dokumentenverarbeitung
  Dokumentenlängenerkennung, leere Dokumente verwerfen.
• Schnellerer Scanstart:
  Herausfinden, welche Antwort der Scanner vom Server erwartet, damit das orange Ausrufezeichen nicht erscheint, der Scanner währenddessen nicht bereit ist, der Scanvorgang schneller beginnt und damit die Wartezeit minimiert wird.
• Web-Frontend:
  • Alle Einstellungen sollen zentral in einer externen Konfigurationsdatei gespeichert und über das Web-Frontend bearbeitet werden können.
  • Vorgefertigte Scanprofile (wie "Standard", "Duplex", "Farbe") sowie die Möglichkeit, eigene Profile anzulegen und zu löschen.
  • Auswahl aus mehreren Zielordnern (Inbox-, bzw. Watchfolder) für gängige DMS und die Eingabe eines eigenen Pfads.
  • Anzeige eines temporären Weblogs mit Live-Infos zum aktuellen Scan (Status, Fortschritt), das nach Abschluss des Scans automatisch gelöscht wird.
  • Scan-Button für die indirekte Steuerung.
• Benachrichtigungen:
  Ich plane E-Mail- und MQTT-Benachrichtigungen, wenn der Scannerknopf erkannt wurde und mit dem Scan beginnt oder wenn Fehler auftreten.
• Scanner-Tasten:
  Verschiedene Scanprofile direkt über die Hardware-Tasten des Scanners zu starten.
• Herstellerübergreifende Unterstützung:
  Ziel ist es, neben Epson auch Scanner anderer Hersteller (z.B. Canon, Brother, HP) zu unterstützen.
• Was ich nicht plane:
  • Keine Benutzer- oder Rechteverwaltung im Web-Frontend (ausschließlich für den privaten Einsatz).
  • Keine Entwicklung von iOS- oder Android-Apps.

Feedback und neue Ideen sind jederzeit willkommen!

Tests

Einen ersten massiven Test habe ich durchgeführt. Der Scanner ist wirklich gut und hat ca. 150 Blatt in mehreren Schüben reibungslos verarbeitet. Darunter waren auch verschieden große, verschieden dicke und auch echt abgeranzte Blätter. Die Hardware ist also top!
Ich wüsste gar nicht, wie der schneller scannen sollte. 35 Seiten pro Minute halte ich für untertrieben!

Eppascan hat auch reibungslos funktioniert, auch wenn der Proxmox-Server durch Paperless-NGX und PaperlessAI mit einem lokalen LLM bis zum Anschlag ausgelastet war. Der i6100T benötigt für eine DIN-A4-Seite sicher vier oder fünf Minuten, aber das spielt ja nur bei Massen von neuen Dokumenten eine Rolle. Ich bin zufrieden und muss nicht direkt aufrüsten. Auch der RAM, aktuell nur 16 GB, bald aber 32 GB, reicht bisher locker!

Probleme gab es wirklich mit PaperlessAI. Die hatte Probleme sich mit dem Paperless-NGX zu verbinden. "Fehler 'JSON.parse: unexpected character' oder 'Failed to get own user ID' in den Logs von Paperless-AI deuteten auf eine fehlerhafte Paperless-NGX API-Verbindungseinstellung hin. Das Webend speicherte die Daten nicht korrekt in /opt/paperless-ai/data/.env. Ich habe per Hand in "http://192.168.141.40:8000/opt/" ändern müssen und den Usernamen "Admin" korrekt in "admin" ändern müssen. Danach lief es sofort.

Aber dazu habe ich schon einen Artikel begonnen.