Scanner Epson ET-4856 — Intégration Home Assistant & Paperless-ngx

Mise en place : 22 mars 2026
Dernière mise à jour : 29 juillet 2026 (v4 — recto-verso, exécution détachée, bouton RAZ)

1. Vue d'ensemble

L'imprimante Epson ET-4856 (identifiée comme ET-4850 ~~Series)~~Series) est pilotée en local via le protocole eSCL (AirScan/AirPrint) en ~~HTTPS.~~HTTPS, sans aucune dépendance au logiciel Epson. Un script bash exécuté depuis le container Home Assistant déclenche les scans et dépose les fichiers directement dans le répertoire consume de Paperless-ngx pour ingestion automatique (OCR + indexation).

Architecture

Bouton Dashboard HA (NSPanel)
    → script.scanner_epsonscanner_epson[_recto|_verso|_reset]
    → shell_command.epson_scanepson_scan[_recto|_verso]
    → epson_scan_launcher.sh   (détache le processus en arrière-plan)
    → epson_scan.sh            (scan eSCL, traitement PDF, notification API HA)
        → POST eSCL /ScanJobs (HTTPS:443) sur l'imprimante
        → GET /NextDocument → fichierPDF PDF(tout le lot ADF en un seul fichier)
        → GET /NextDocument (404) + DELETE → fermeture propre du job
        → /media/scans/ (= consume Paperless-ngx)Paperless)
    → Paperless ingère → OCR → indexation → archivage

Composants impliqués

Composant	Rôle	Emplacement
Epson ET-4856	Scanner (eSCL via HTTPS)	192.168.10.25:443
Home Assistant	Orchestration, dashboard, déclenchement	Container Docker sur Unraid
Paperless-ngx	Ingestion, OCR, indexation	Container Docker sur Unraid
epson_scan.sh	Script ~~bash~~principal de scan eSCL (v4)	/config/scripts/epson_scan.sh

epson_scan_launcher.sh Wrapper de mise en arrière-plan /config/scripts/epson_scan_launcher.sh epson_scan_reset.sh Réinitialisation (bourrage / blocage) /config/scripts/epson_scan_reset.sh

2. Protocole eSCL — Détails techniques

Découverte

Le scanner n'expose pas eSCL en HTTP (port 80). Il faut utiliser HTTPS sur le port 443 avec l'option -k de curl (certificat auto-signé SEIKO EPSON CORP.).

# Vérifier le statutStatut du scanner
curl -s -k https://192.168.10.25/eSCL/ScannerStatus

# VoirCapabilities les capabilitiescomplètes
curl -s -k https://192.168.10.25/eSCL/ScannerCapabilities

Côté interface web de l'imprimante, il n'y a aucune mention explicite d'eSCL : c'est le réglage AirPrint qui l'active (eSCL est le volet « scan » d'AirPrint). Le paramètre « Protocole Top Priority » (IPP / port9100) ne concerne que l'impression.

Capabilities du scanner

Paramètre	Vitre (Platen)	Chargeur (ADF)
Résolutions	100, 200, 300, 600, 1200 DPI	100, 200, 300, 600 DPI
Modes couleur	RGB24, Grayscale8, BlackAndWhite1	RGB24, Grayscale8, BlackAndWhite1
Formats sortie	PDF, JPEG	PDF, JPEG
Duplex matériel	N/A	Non supporté (~~SimplexInputCaps~~AdfSimplexInputCaps uniquement)
Capacité	1 page	50 feuilles max
Dimensions max	2550 x 3510 (≈A4)	2550 x 4200

Workflow⚠️ eSCLComportement (séquenceclé HTTP)de l'ET-4856 : un seul PDF par lot ADF

Contrairement à ce qu'on pourrait attendre, l'ET-4856 ne renvoie pas une page par appel à NextDocument. Un unique appel scanne tout le chargeur ADF et renvoie un PDF multi-pages complet. Toute logique de boucle « page par page » est donc inutile pour ce modèle — et c'était la cause d'un bug d'ordre des pages en recto-verso.

Séquence HTTP d'un scan

POST /eSCL/ScanJobs avec XML de paramètres → Réponse 201 + header Location ~~contenant~~= l'URL du job
GET {Location}/NextDocument → Télécharge le ~~fichier scanné~~PDF (~~PDF~~tout oule ~~JPEG)~~lot)
GET {Location}/NextDocument (~~2ème~~2^e appel) → Renvoie 404, signale la fin au scanner
DELETE {Location} → Libère le ~~job et remet~~job, le scanner repasse en Idle

~~⚠️ Important :~~ Sans les étapes 3 et 4, le scanner reste bloqué ensur ~~"Scan~~« enNumérisation ~~cours"~~» ~~sur~~à l'écran LCD.

Exemple de XML ScanSettings

<?xml version="1.0" encoding="UTF-8"?>
<scan:ScanSettings xmlns:pwg="http://www.pwg.org/schemas/2010/12/sm"
  xmlns:scan="http://schemas.hp.com/imaging/escl/2011/05/03">
  <pwg:Version>2.0</pwg:Version>
  <pwg:ScanRegions>
    <pwg:ScanRegion>
      <pwg:Width>2550</pwg:Width>
      <pwg:Height>3510</pwg:Height>
      <pwg:ContentRegionUnits>escl:ThreeHundredthsOfInches</pwg:ContentRegionUnits>
      <pwg:XOffset>0</pwg:XOffset>
      <pwg:YOffset>0</pwg:YOffset>
    </pwg:ScanRegion>
  </pwg:ScanRegions>
  <pwg:InputSource>Platen</pwg:InputSource>
  <scan:ColorMode>RGB24</scan:ColorMode>
  <scan:XResolution>300</scan:XResolution>
  <scan:YResolution>300</scan:YResolution>
  <pwg:DocumentFormat>application/pdf</pwg:DocumentFormat>
  <scan:Intent>Document</scan:Intent>
</scan:ScanSettings>

3. Contraintes de l'environnement HA (importantes)

3.1 — Container Alpine / BusyBox

Le container HA tourne sous Alpine Linux avec BusyBox. Les scripts évitent donc :

grep -P (Perl regex, non supporté) → remplacé par sed -n 's/.../p' stat → remplacé par wc -c heredoc cat << EOF pour le XML → chaîne dans une variable

3.2 — Timeout de 60 s des shell_command

Home Assistant tue tout shell_command après 60 secondes, sans possibilité de configurer ce délai. Un scan ADF de 5 feuilles recto-verso dépasse largement ce seuil : le processus était tué avant d'avoir pu fermer le job eSCL → imprimante bloquée sur « Numérisation », et aucune notification côté HA.

3.3 — Mode restreint des shell_command avec templates

Quand un shell_command contient des templates Jinja2 ({{ states(...) }}), HA l'exécute dans un environnement restreint où les opérateurs shell >, >>, |, ~ et & ne sont PAS interprétés — ils sont pris littéralement. Écrire nohup ... & directement dans le shell_command ne fonctionne donc pas.

Solution retenue : un script launcher intermédiaire. Le shell_command appelle simplement bash launcher.sh args (aucun opérateur), et c'est le launcher — exécuté dans un vrai bash sans restriction — qui fait le nohup ... &.

3.4 — Persistance de poppler-utils

pdfunite et pdfseparate (package poppler-utils) sont nécessaires pour le traitement PDF. Or apk add ne survit pas au redémarrage du container, et l'automation d'installation au démarrage s'est révélée non fiable (timing réseau, timeout de 60 s sur un téléchargement de ~200 Mo).

Solution retenue : copier les binaires et leurs librairies dans /config/poppler-persist/ (volume monté depuis Unraid, donc permanent), et pointer dessus via PATH / LD_LIBRARY_PATH en tête de epson_scan.sh.

# Copie initiale (à refaire uniquement si /config est réinitialisé)
docker exec homeassistant sh -c '
mkdir -p /config/poppler-persist
for pkg in poppler-utils poppler cairo pixman nss nspr libxrender openjpeg libheif-openjpeg; do
  apk info -L $pkg 2>/dev/null | while read f; do
    if [ -f "/$f" ]; then
      mkdir -p "/config/poppler-persist/$(dirname $f)"
      cp -n "/$f" "/config/poppler-persist/$f" 2>/dev/null
    fi
  done
done
find /config/poppler-persist -name "pdfunite" -o -name "pdfseparate"
'

4. Configuration du container Home Assistant

Volume monté

Le répertoire consume de Paperless est monté dans le container HA :

-v '/mnt/user/Sauvegarde_Jean-Michel/Documents_Importants/consume/':'/media/scans':'rw'

DépendanceJeton d'accès API Home Assistant

Comme le script tourne détaché, il notifie lui-même HA via l'API REST locale. Un jeton d'accès longue durée (créé depuis le profil utilisateur HA) est stocké dans /config/.ha_token :

~~poppler-utils~~

echo "LE_JETON" > /mnt/user/appdata/homeassistant/.ha_token
chmod 600 /mnt/user/appdata/homeassistant/.ha_token

# Vérification
docker exec homeassistant bash -c '
TOKEN=$(cat /config/.ha_token)
curl -s -o /dev/null -w "HTTP %{http_code}\n" \
  -H "Authorization: Bearer ${TOKEN}" http://localhost:8123/api/
'
# → doit renvoyer HTTP 200

Le ~~package~~script appelle ensuite poppler-utilsinput_boolean/turn_on|turn_off ~~(fournit~~et pdfunitepersistent_notification/create) pour tenir HA informé en fin de traitement, quelle que soit la durée du scan.

5. Les trois scripts

5.1 — epson_scan_launcher.sh

Wrapper minimal qui détache le scan du timeout HA. C'est lui qui est ~~nécessaire~~appelé ~~pour~~par ~~la fusion PDF multi-pages ADF. Comme le container HA est basé sur Alpine Linux (BusyBox), le package est perdu à chaque redémarrage.~~

~~Solution :~~ ~~Un script d'installation + une automation HA au démarrage.~~

~~Fichier :~~les /config/scripts/install_deps.shshell_command.

#!/bin/bash
apknohup addbash --no-cache/config/scripts/epson_scan.sh poppler-utils"$@" > /tmp/last_scan.log 2>/dev/null&1 &
disown
exit 0

~~Automation~~

5.2 :

~~dans~~ automations.yaml

- alias: "Install scanner dependencies"
  trigger:
    - trigger: homeassistant
      event: start
  action:
    - action: shell_command.install_deps

4. Script— epson_scan.sh (v2)

Emplacementv4)

/config/scripts/epson_scan.shParamètres ~~(dans~~positionnels ~~le container HA)~~
/mnt/user/appdata/homeassistant/scripts/epson_scan.sh ~~(côté Unraid)~~:

Paramètres

Position	Paramètre	Valeurs ~~possibles~~	Défaut
$1	Résolution	100, 200, 300, 600	300
$2	Source	Platen, Feeder	Platen
$3	Mode couleur	RGB24, Grayscale8, BlackAndWhite1	RGB24
$4	Format	pdf, jpeg	pdf
$5	Intent	Document, Photo, TextAndGraphic	Document
$6	Mode

simplex, recto, verso simplex $7 Nom document Texte libre (optionnel) scan_[date]

Comportement selon le mode :

~~Mode~~simplex ~~Vitre~~+ ~~(Platen)~~Platen : ~~Scanne~~scanne 1 ~~page,~~page ~~enregistre~~depuis ~~directement~~la vitre → PDF dans /media/scans/
~~Mode~~simplex ~~ADF~~+ ~~(Feeder)~~Feeder : ~~Boucle~~scanne ~~de scan page par page jusqu'à ce que~~tout le chargeur ~~soit~~→ ~~vide,~~PDF ~~puis~~multi-pages

~~fusionne~~recto ~~tous~~: ~~les~~scanne tout le chargeur, garde le PDF en attente dans /media/scans/.duplex_pending/, active input_boolean.scan_attente_verso verso : scanne tout le chargeur (pile retournée), éclate les deux PDF avec pdfseparate, intercale, fusionne avec pdfunite → un seul ~~via~~PDF pdfunite~~. Maximum 50 pages par sécurité.~~final

Codes de ~~retour~~sortie :

Succès : OK:/chemin/fichier.pdf:taille:N pages (exit 0)
Succès recto : RECTO_OK:N:Retournez la pile... (exit 0)

Erreur : ERREUR: description (exit 1)

Compatibilité5.3 BusyBox— epson_scan_reset.sh

LeFilet ~~container~~de HAsécurité, ~~utilise~~appelé ~~Alpine~~par ~~Linux~~le ~~avec~~bouton ~~BusyBox.~~RAZ. LeIl ~~script évite~~enchaîne :

1. greppkill -Pf epson_scan.sh — tue un scan encore en cours en arrière-plan

Parcourt tous les JobUri du ScannerStatus et les ferme (~~Perl~~GET regex)NextDocument + DELETE) Supprime le lot recto-verso en attente (.duplex_pending) Nettoie les fichiers temporaires (/tmp/scan_adf_*, /tmp/scan_headers_*) Remet scan_en_cours et scan_attente_verso à off via l'API HA Relit l'état final et envoie une notification récapitulative

Sortie type : RESET_OK:jobs_fermes=2:lot_duplex_nettoye=1:etat_scanner=Idle:etat_adf=ScannerAdfEmpty

6. Logique du recto-verso manuel

L'ADF ne gère pas le duplex matériel. Le recto-verso se fait donc en deux passages, avec retournement manuel de toute la pile.

Principe

Passage 1 (rectos) : l'ADF scanne les pages 1, 3, 5, 7...
[L'utilisateur retourne TOUTE la pile d'un bloc]
Passage 2 (versos) : l'ADF tire d'abord le verso de la DERNIÈRE feuille
                     → remplacépages scannées dans l'ordre 8, 6, 4, 2
Fusion : rectos en positions impaires (1,3,5,7)
         versos INVERSÉS en positions paires (2,4,6,8)
         → PDF final dans l'ordre 1,2,3,4,5,6,7,8 ✓

Implémentation (méthode robuste)

La manipulation de tableaux en shell BusyBox s'étant révélée peu fiable (premier essai : ordre 1-3-4-2 au lieu de 1-2-3-4), l'intercalage se fait par renommage positionnel puis tri alphabétique :

sedpdfseparate -nrecto_batch.pdf 's/→ r-001.pdf, r-002.pdf..../p' statpdfseparate verso_batch.pdf → v-001.pdf, v-002.pdf... Chaque recto i (ordre normal, sort) est copié en page_$((i*2+1)).pdf Chaque verso j (ordre inversé, sort -r) est copié en page_$((j*2+2)).pdf pdfunite $(ls page_*.pdf | sort) → ~~remplacé~~PDF ~~par~~final wc -c ~~heredoc~~ cat << EOF ~~pour~~dans le ~~XML~~bon ~~→ chaîne dans une variable~~ordre

Test en ligne de commande

# Scan vitre, 200 DPI, couleur, PDF
docker exec homeassistant bash /config/scripts/epson_scan.sh 200 Platen RGB24 pdf Document

# Scan ADF multi-pages, 300 DPI, niveaux de gris, PDF
docker exec homeassistant bash /config/scripts/epson_scan.sh 300 Feeder Grayscale8 pdf Document

5.7. Configuration Home Assistant

configuration.yaml — Sections ajoutées

Input selects (options de scan)

input_select:
  scan_source:
    name: Source de scan
    options: - ["Vitre"
      -, "Chargeur (ADF)"]
    initial: "Vitre"
    icon: mdi:scanner
  scan_resolution:
    name: Résolution
    options: - ["100"
      -, "200"
      -, "300"
      -, "600"]
    initial: "300"
    icon: mdi:resize
  scan_color:
    name: Mode couleur
    options: - ["Couleur"
      -, "Niveaux de gris"
      -, "Noir et blanc"]
    initial: "Couleur"
    icon: mdi:palette
  scan_format:
    name: Format de sortie
    options: - ["PDF"
      -, "JPEG"]
    initial: "PDF"
    icon: mdi:file-document

Input boolean (indicateur scan en cours)booleans

input_boolean:
  scan_en_cours:
    name: Scan en cours
    icon: mdi:progress-clock
  scan_attente_verso:
    name: En attente versos
    icon: mdi:rotate-3d-variant

Shell commands

⚠️ Aucun opérateur shell (>, &, |) dans ces lignes — voir §3.3. Elles appellent toutes le launcher.

shell_command:
  epson_scan: "bash /config/scripts/epson_scan.epson_scan_launcher.sh {{ states('input_select.scan_resolution') }} {{ 'Feeder' if states('input_select.scan_source') == 'Chargeur (ADF)' else 'Platen' }} {{ {'Couleur':'RGB24','Niveaux de gris':'Grayscale8','Noir et blanc':'BlackAndWhite1'}[states('input_select.scan_color')] }} {{ states('input_select.scan_format') | lower }} Document"Document install_deps:simplex"
  epson_scan_recto: "bash /config/scripts/install_deps.epson_scan_launcher.sh {{ states('input_select.scan_resolution') }} Feeder {{ {'Couleur':'RGB24','Niveaux de gris':'Grayscale8','Noir et blanc':'BlackAndWhite1'}[states('input_select.scan_color')] }} {{ states('input_select.scan_format') | lower }} Document recto"
  epson_scan_verso: "bash /config/scripts/epson_scan_launcher.sh {{ states('input_select.scan_resolution') }} Feeder {{ {'Couleur':'RGB24','Niveaux de gris':'Grayscale8','Noir et blanc':'BlackAndWhite1'}[states('input_select.scan_color')] }} {{ states('input_select.scan_format') | lower }} Document verso"
  epson_scan_reset: "bash /config/scripts/epson_scan_reset.sh"

Command line sensors (statutstatut)

~~scanner)~~

On utilise command_line plutôt que rest : le client HTTP Python de HA gère mal le certificat auto-signé de l'imprimante, même avec verify_ssl: false.

command_line:
  - sensor:
      name: "Epson Scanner Status"
      unique_id: epson_et4856_scanner_status
      icon: mdi:scanner
      command: "curl -s -k https://192.168.10.25/eSCL/ScannerStatus 2>/dev/null"
      scan_interval: 30
      value_template: >
        {% set matches = value | regex_findall('<pwg:State>(.*?)</pwg:State>') %}
        {% if matches %}
          {% set map = {'Idle':'Prêt','Processing':'En cours','Testing':'Test','Stopped':'Arrêté'} %}
          {{ map.get(matches[0], matches[0]) }}
        {% else %}
          Indisponible
        {% endif %}
  - sensor:
      name: "Epson ADF Status"
      unique_id: epson_et4856_adf_status
      icon: mdi:tray-full
      command: "curl -s -k https://192.168.10.25/eSCL/ScannerStatus 2>/dev/null"
      scan_interval: 30
      value_template: >
        {% set matches = value | regex_findall('<scan:AdfState>(.*?)</scan:AdfState>') %}
        {% if matches %}
          {% set map = {'ScannerAdfEmpty':'Vide','ScannerAdfLoaded':'Papier chargé','ScannerAdfJam':'Bourrage'} %}
          {{ map.get(matches[0], matches[0]) }}
        {% else %}
          Indisponible
        {% endif %}

scripts.yaml

~~Note~~Les : ~~On utilise~~ command_line ~~sensor au lieu de~~ rest ~~sensor car le client HTTP Python de~~scripts HA ~~gère~~sont ~~mal~~volontairement leminimalistes ~~certificat~~: ~~auto-signé~~ils deallument juste l'~~imprimante~~indicateur ~~malgré~~et lancent la commande. C'est verify_ssl:epson_scan.sh ~~false~~.qui, une fois réellement terminé, éteint les booléens et envoie la notification via l'API.

scripts.yaml — Script scanner

scanner_epson:
  alias: "Scanner un document"
  icon: mdi:scanner
  mode: single
  sequence:
    - action: input_boolean.turn_on
      target:
        entity_id: input_boolean.scan_en_cours
    - action: shell_command.epson_scan

response_variable:scanner_epson_recto:
  scan_resultalias: "Scanner rectos (duplex)"
  icon: mdi:file-document-multiple
  mode: single
  sequence:
    - action: input_boolean.turn_offturn_on
      target:
        entity_id: input_boolean.scan_en_cours
    - choose:action: -shell_command.epson_scan_recto

conditions:scanner_epson_verso:
  - condition: template
              value_template:alias: "{{Scanner scan_result.returncodeversos ==(duplex)"
  0icon: }}"mdi:file-document-check
  mode: single
  sequence:
    - action: persistent_notification.createinput_boolean.turn_on
      data:target:
        title:entity_id: "Scan terminé"
                message: >
                  Document scanné avec succès !
                  {{ scan_result.stdout }}
                notification_id: scan_resultinput_boolean.scan_en_cours
    - conditions:action: -shell_command.epson_scan_verso

condition:scanner_epson_reset:
  template
              value_template:alias: "{{Réinitialiser scan_result.returncodescanner"
  !=icon: 0mdi:restart-alert
  }}"mode: single
  sequence:
    - action: persistent_notification.create
              data:
                title: "Erreur de scan"
                message: >
                  Erreur lors du scan :
                  {{ scan_result.stderr }}
                notification_id: scan_resultshell_command.epson_scan_reset

6.8. Dashboard (onglet Scan)

~~L'onglet Scan se trouve~~Situé dans le dashboard lovelace.dashboard_roborock, onglet path: scan. ~~Il utilise~~Utilise les cards Mushroom ~~(mushroom-template-card, mushroom-select-card)~~ et state-switch (HACS) pour larester ~~cohérence visuelle~~cohérent avec le reste du dashboard. Layout compact vertical car affiché sur un NSPanel.

Composition

Ligne 1 : statut Scanner + statut Chargeur ADF (couleurs conditionnelles) Ligne 2 : selects Source + Résolution Ligne 3 : selects Couleur + Format Ligne 4 : les 3 boutons d'action côte à côte

Boutons

Bouton États Action Scanner Vert « Scanner » → Orange « Scan... » script.scanner_epson — respecte le select Source Recto-Verso Bleu « Recto-Verso » → Orange « Verso / Retournez » scanner_epson_recto puis scanner_epson_verso — force toujours l'ADF RAZ Rouge, fixe script.scanner_epson_reset

Le bouton Recto-Verso bascule automatiquement d'un état à l'autre selon input_boolean.scan_attente_verso, guidant l'utilisateur dans le workflow en 2 étapes.

Entités utilisées dans le dashboard

Entité	Rôle
sensor.epson_scanner_status	État du scanner (Prêt / En cours)
sensor.epson_adf_status	État du chargeur ~~ADF~~ (Vide / Papier ~~chargé)~~chargé / Bourrage)
input_select.scan_source	~~Choix~~ Vitre / Chargeur ADF (bouton Scanner uniquement)
input_select.scan_resolution	~~Choix résolution~~Résolution DPI
input_select.scan_color	~~Choix couleur~~Couleur / gris / N&B
input_select.scan_format	~~Choix~~ PDF / JPEG
input_boolean.scan_en_cours	Indicateur scan en cours
~~script.scanner_epson~~input_boolean.scan_attente_verso	~~Script~~Bascule ~~déclenché~~l'état du bouton Recto-Verso

script.scanner_epson[_recto|_verso|_reset] Scripts déclenchés par leles ~~bouton~~boutons

7.9. Dépannage

Le scanner reste bloqué sur « Numérisation » (écran LCD)

Le job eSCL n'a pas été fermé (scan interrompu, bourrage, processus tué). Appuyer sur le bouton RAZ du dashboard, ou en CLI :

docker exec homeassistant bash /config/scripts/epson_scan_reset.sh

Le scanner répond HTTP 503

Un job précédent est ~~resté~~encore ~~bloqué.~~actif. Vérifier lel'état, ~~statut~~puis ~~et attendre que~~lancer le ~~scanner passe en~~ Idle~~, ou éteindre/rallumer l'imprimante~~RAZ :

docker exec homeassistant curl -s -k https://192.168.10.25/eSCL/ScannerStatus | sed 's/>\n

LeRien scannern'arrive restedans bloquéPaperless

~~sur~~

"Scan

Diagnostic en ~~cours"~~4 ~~(écran~~étapes ~~LCD)~~:

Lejob n'a pas été fermé proprement. Le script v2 inclut la fermeture (GET NextDocument + DELETE), mais si un scan a été interrompu :

# Récupérer1. l'UUIDLe duscanner jobrépond-il en cours?
docker exec homeassistant curl -s -k https://192.168.10.25/eSCL/ScannerStatus | head -c 300

# Supprimer2. lepdfunite jobest-il manuellementaccessible (remplacer UUID)?
docker exec homeassistant curlls -sla /config/poppler-persist/usr/bin/pdfunite

# 3. Le processus tourne-t-il encore ?
docker exec homeassistant ps aux | grep epson_scan

# 4. Que dit le journal du dernier scan ?
docker exec homeassistant cat /tmp/last_scan.log

# 5. Un lot recto-verso resté en attente ?
docker exec homeassistant ls -kla -X DELETE "https://192.168.10.25/eSCL/ScanJobs/UUID-DU-JOB"media/scans/.duplex_pending/

pdfunite« notTimed foundout running command ... after: 60s » dans les logs HA

Le ~~package~~ poppler-utilsshell_command n'aappelle pas ~~été~~le ~~installé~~launcher aumais ~~démarrage.~~directement ~~Installer~~epson_scan.sh. ~~manuellement~~Vérifier :

docker exec homeassistant apk addgrep --no-cacheA poppler-utils4 "^shell_command:" /config/configuration.yaml

Chaque ligne epson_scan* doit appeler epson_scan_launcher.sh, sans nohup, sans >, sans & (voir §3.3).

« pdfunite: command not found » / fusion PDF échouée

Vérifier que ~~l'automation~~la ~~"Install~~copie ~~scanner~~persistante ~~dependencies"~~existe et que le script pointe dessus :

docker exec homeassistant ls -la /config/poppler-persist/usr/bin/
docker exec homeassistant head -12 /config/scripts/epson_scan.sh   # doit contenir les 2 export PATH/LD_LIBRARY_PATH

Si /config/poppler-persist/ est ~~active~~vide, etrefaire ~~sans~~la ~~erreur.~~copie initiale (voir §3.4).

grep:Ordre unrecognizeddes option:pages Pincorrect en recto-verso

Lescript

~~utilise~~ grep -P ~~(Perl regex) incompatible avec BusyBox.~~

Vérifier que le script v2 est bien ~~déployé~~en (v4 et utilise sedpdfseparate à:

place).

docker exec homeassistant head -53 /config/scripts/epson_scan.sh    # Doitdoit afficherindiquer "v2"v4

Sensor scanner "Indisponible" ou "unavailable"

~~Vérifier que curl fonctionne depuis le container :~~

docker exec homeassistant curlgrep -sc -k"pdfseparate" https://192.168.10.25/eSCL/ScannerStatusconfig/scripts/epson_scan.sh

Siça

~~répond~~

« dugrep: XMLunrecognized maisoption: leP sensor»

fonctionne

~~pas,~~

Script ~~vérifier~~obsolète utilisant grep -P, incompatible BusyBox. Redéployer la version v4.

Doublons dans scripts.yaml

Un cat >> lancé deux fois crée des clés dupliquées. HA les ~~logs~~signale en warning :

docker exec homeassistant grep -c "^scanner_epson" /config/scripts.yaml
docker exec homeassistant grep -i "command_line\|epson"duplicate key" /config/home-assistant.log | tail -105

TimeoutÉditions surde scanconfiguration ADF: multi-pagesprivilégier sed depuis l'hôte

Leshell_command

Deux HApièges arencontrés unà ~~timeout de~~ ~~60 secondes~~~~. En 300 DPI, chaque page prend ~10-15 secondes. Au-delà de ~4 pages, le timeout peut être atteint. Solutions~~répétition :

~~Réduire~~
docker exec homeassistant python3 << 'EOF' ne transmet pas le heredoc (il manque l'option -i) → la ~~résolution~~commande ~~(200~~semble ~~DPI)~~réussir mais ne fait rien
~~Passer~~ en
docker modeexec asynchrone... cat >> /config/fichier écrit sur l'hôte, pas dans le container (~~script~~la enredirection ~~background~~est +évaluée ~~notification~~par ~~webhook)~~le shell local)

→ Éditer directement les fichiers sous /mnt/user/appdata/homeassistant/ avec sed -i, puis vérifier avec docker exec homeassistant grep ....

8.10. Fichiers — Récapitulatif

Fichier (Unraid)	Fichier (container HA)	Rôle
.../~~mnt/user/appdata/~~homeassistant/scripts/epson_scan.sh	/config/scripts/epson_scan.sh	Script principal de scan ~~eSCL v2~~(v4)
.../~~mnt/user/appdata/~~homeassistant/scripts/~~install_deps.~~epson_scan_launcher.sh	/config/scripts/~~install_deps.~~epson_scan_launcher.sh	~~Installation~~Wrapper ~~poppler-utils au démarrage~~arrière-plan
.../~~mnt/user/appdata/~~homeassistant/scripts/epson_scan_reset.sh

/config/scripts/epson_scan_reset.sh Réinitialisation / RAZ .../homeassistant/.ha_token /config/.ha_token Jeton API HA (chmod 600) .../homeassistant/poppler-persist/ /config/poppler-persist/ pdfunite / pdfseparate persistants .../homeassistant/configuration.yaml /config/configuration.yaml ~~Config~~input_select, ~~HA (input_select,~~input_boolean, shell_command, ~~sensors)~~sensors .../~~mnt/user/appdata/~~homeassistant/scripts.yaml /config/scripts.yaml ~~Script~~Scripts HA ~~scanner_epson~~scanner_epson* .../homeassistant/.storage/lovelace.dashboard_roborock — Dashboard (onglet Scan) /mnt/user/~~appdata/homeassistant/automations.yaml~~ Sauvegarde.../~~config/automations.yaml~~ ~~Automation install_deps au démarrage~~ ~~/mnt/user/Sauvegarde_Jean-Michel/Documents_Importants/~~consume/ /media/scans/ ~~Répertoire~~Sortie dedes ~~sortie~~scans (= consume ~~Paperless)~~Paperless — /media/scans/.duplex_pending/ Lot recto-verso en attente (temporaire) — /tmp/last_scan.log Journal du dernier scan lancé

9.11. Historique des problèmes résolus

Symptôme Cause Correctif Aucune réponse sur http://IP/eSCL/... eSCL exposé en HTTPS uniquement Utiliser https:// + curl -k Boucle infinie / grep: unrecognized option: P BusyBox ne supporte pas grep -P Remplacé par sed -n 's/.../p' HTTP 503 au lancement Jobs fantômes d'un scan précédent Fermeture propre + bouton RAZ Imprimante bloquée sur « Numérisation » Job jamais fermé après téléchargement Ajout GET NextDocument (404) + DELETE Ordre des pages 1-3-4-2 en recto-verso Concaténation au lieu d'intercalage, versos non inversés pdfseparate + renommage positionnel + sort -r RECTO_OK:1 pour 2 feuilles L'ET-4856 renvoie tout le lot ADF en un seul PDF Suppression de la boucle page-par-page, comptage via pdfinfo Sensor scanner « unavailable » rest sensor + certificat auto-signé Bascule sur command_line sensor avec curl Fusion échouée après redémarrage HA apk add non persistant Copie dans /config/poppler-persist/ + PATH Blocage systématique sur gros lots (5 feuilles+) Timeout 60 s des shell_command HA Exécution détachée via launcher + notification API nohup ... & sans effet dans shell_command Mode restreint avec templates : > et & non interprétés Backgrounding déporté dans epson_scan_launcher.sh

12. Améliorations possibles

Trigger Telegram : ~~Déclencher~~déclencher un scan via commande ~~Telegram~~ bot Bouton Zigbee physique : ~~Bouton à côté de l'imprimante pour~~ scanner en un appui depuis l'imprimante Nommage depuis le dashboard : ~~Ajouter~~le script accepte déjà un 7^e paramètre (nom du document), mais l'ajout d'un champ input_text éditable dans une vue sections n'a pas abouti (~~non~~entité ~~résolu~~créée —en ~~incompatibilité~~YAML ~~avec~~= ~~les~~editable: vuesfalse ~~sections)~~; créée via l'UI = card invisible) ~~Mode asynchrone~~ ~~: Pour les gros lots ADF, lancer le script en background et notifier via webhook quand c'est terminé~~ Niveaux d'encre : ~~Intégration~~intégration HACS ha-epson-workforce — ~~vérifier~~tester http://192.168.10.25/PRESENTATION/HTML/TOP/PRTINFO.HTML ~~Duplex~~Barre ~~manuel~~de progression : ~~Workflow~~exploiter enImagesCompleted 2du ~~passes~~ScannerStatus ~~(recto~~pour ~~puis~~un ~~verso)~~sensor ~~avec~~de ~~interleaving~~progression ~~des~~pendant ~~pages~~le scan Détection de bourrage : automation sur sensor.epson_adf_status = « Bourrage » → notification + proposition de RAZ