The wikis are now using the new authentication system.
If you did not migrate your account yet, visit https://idp-portal-info.suse.com/

SDB:Configurare gli scanner

Obiettivo

Vuoi configurare il tuo scanner.

Procedura

Per configurare uno scanner avvia il modulo Scanner di YaST. Il modulo Scanner di YaST è raggiungibile nel Centro di controllo di YaST, al percorso Hardware -> Scanner. Per maggiori informazioni puoi consultare la pagina su YaST/Modules/Scanner (in inglese) all'indirizzo http://old-en.opensuse.org/YaST/Modules/Scanner.

Gran parte degli scanner USB vengono configurati in modo completamenti automatico quando vengono collegati alla porta USB del computer, in modo tale che non vi è alcuna necessità di avviare il modulo Scanner di YaST.

La configurazione completamente automatizzata degli scanner USB viene effettuata per mezzo del file delle regole di udev /etc/udev/rules.d/56-sane-backends-autoconfig.rules, che è fornito nel pacchetto di openSUSE "sane-backends-autoconfig". Per i dettagli puoi leggere la descrizione del pacchetto appena citato (p.es. col comando "rpm -qi sane-backends-autoconfig"). Se invece non gradisci l'attivazione automatica dei driver per lo scanner, evita allora di installare questo pacchetto o rimuovilo nel caso in cui fosse già installato.

I paragrafi seguenti forniscono ulteriori informazioni riguardanti gli aspetti tecnici di fondo e la configurazione manuale.

Al fine di limitare la complessità di questo articolo, verranno considerati soltanto sugli scanner USB.

Le informazioni che non si applicano specificatamente agli scanner USB valgono anche per quelli SCSI e su porta parallela. Per gli scanner SCSI vedi "man sane-scsi". Per gli scanner connessi alla porta parallela, puoi consultare invece la pagina di man per il rispettivo backend (vedi la sezione "Backend di SANE" più sotto) e le informazioni nel manuale relative alle impostazioni per la porta parallela.

Concetti di base

"SANE Project" è il progetto che fornisce il software centrale per operare con gli scanner: http://www.sane-project.org/.

Il software del progetto SANE è costituito da "SANE-backends" (i backend di SANE) e da "SANE-frontends" (i frontend per SANE). In openSUSE, puoi trovare il software "SANE-backends" nel pacchetto "sane-backends".

I backend di SANE costituiscono i driver veri e propri per il controllo dell'hardware relativi ai vari tipi di scanner; si veda http://www.sane-project.org/sane-backends.html.

Un backend può essere in grado di supportare svariati modelli di scanner, se è possibile comunicare con i vari modelli in uno stesso modo. Tali modelli sono compatibili sono compatibili tra loro fino ad un certo punto, poiché sono in grado di capire lo stesso "linguaggio". A seconda del backend questo linguaggio può essere di diversi tipi:

  • È un tipo di linguaggio primitivo quando il backend deve scrivere direttamente determinati valori nel chip set che controlla l'effettiva unità di scansione all'interno dello scanner. I valori effettivamente scritti variano da modello a modello. Valori errati possono causare acquisizioni di qualità scadente o addirittura potrebbero danneggiare lo scanner. Esempi: i modelli che sono supportati dal backend "plustek".
  • Gli scanner ben costruiti sono dotati di un vero "linguaggio scanner" integrato al loro interno. Controllare tale tipologia di scanner è molto più facile oltreché molto più sicuro. Esempi: i modelli che sono supportati dal backend "epson2".

SANE è un acronimo che sta per "Scanner Access Now Easy". Per mezzo della libreria "libsane", SANE fornisce un'unica interfaccia API (application programming interface) standard, che consente alle applicazioni di avere un accesso uniformato ai vari modelli di scanner.

Le applicazioni che utilizzano un backend di SANE per accedere agli scanner vengono correntemente dette frontend per SANE o semplicemente frontend.

In aggiunta al frontend per SANE da riga di comando "scanimage", che è incluso nel software "SANE-backends", l'interfaccia universale rende possibile l'uso di altri frontend, come il frontend di tipo grafico XSane (si veda http://www.xsane.org/) che è fornito da openSUSE nel pacchetto "xsane".

Invece che accedere all'hardware dello scanner in modo diretto, un backend si serve del kernel, assieme a diversi sottosistemi, per trasmettere i dati all'hardware dello scanner. Per esempio, l'accesso ad uno scanner USB coinvolge i seguenti sottosistemi, in aggiunta al semplice kernel:

  • libusb (libreria per accedere ai dispositivi USB)
  • udev (imposta i permessi di accesso utente per accedere ai dispositivi USB)
  • moduli del kernel per accedere ai dispositivi USB.

Se non si tiene conto dei dettagli, in generale una pila (o stack) costituita da diversi strati (layer) deve essere in grado di funzionare nella sua interezza al fine di consentire agli utenti di accedere ad uno scanner USB da una applicazione:

Utente
  |
Applicazione (frontend utente per scanner)
  |
Backend di SANE (driver per scanner)
  |
libusb
  |
udev <-- plug-in per scanner USB
  |
moduli kernel USB
  |
hardware USB nella macchina
  |
connessione cavo USB (hub USB aggiuntivi se necessario)
  |
Scanner

Soltanto le parti "SANE backend (driver per scanner)" e "Applicazione (frontend utente per scanner)" formano ciò che si potrebbe definire "il software di acquisizione vero e proprio".

La capacità di operare da parte di tutti i livelli inferiori è una condizione necessaria per far sì che uno qualunque degli strati superiori sia in grado di operare (correttamente). Per questo i singoli livelli o sottosistemi verranno discussi partendo dal fondo a salire.

Scanner

Avvia il modulo Scanner di YaST per esaminare l'elenco dei modelli ivi incluso. Per fare questo non è necessario che tu abbia uno scanner connesso. Fai clic su "Aggiungi" e procedi come se dovessi configurare uno scanner immaginario. Seleziona il modello e il driver dall'elenco e fai clic su "Avanti" in modo tale che il modulo di YaST per gli scanner ti possa mostrare eventuali messaggi aggiuntivi riguardo a problemi noti e questioni ancora aperte. Al termine il driver selezionato verrà attivato. Quando non è connesso alcuno scanner l'unica cosa che avviene è che il driver cerca di rilevare automaticamente uno scanner, il che ovviamente in questo caso non andrà a buon fine.

Per vedere se un certo backend di SANE è reso disponibile per il tuo scanner, dalla versione di SANE installata sul tuo sistema, controlla il file /usr/share/doc/packages/sane-backends/sane-mfgs.html. Sei pregato di tenere presente che non è possibile assicurare l'accuratezza di quelle informazioni. Per esempio un produttore (vendor in inglese) potrebbe usare lo stesso nome del modello per differenti versioni di dispositivi, alcuni dei quali potrebbe non essere supportati (confronta per esempio le informazioni su "Artec/Ultima 2000").

In aggiunta puoi anche consultare la pagina http://www.sane-project.org/sane-mfgs.html per vedere se un backend di SANE è disponibile per il tuo modello di scanner. Le informazioni fornite in quel sito rappresentano lo stato più aggiornato del software SANE. Sei tuttavia sempre pregato di tenere presente che non è possibile assicurare l'accuratezza di quelle informazioni. È possibile che la versione di SANE inclusa nella tua versione openSUSE non supporti ancora il tuo scanner.

Il seguente elenco mostra quali modelli di scanner sono supportati (oppure non supportati), a che livello sono supportati e da quale backend della versione di SANE installata nel tuo sistema: /usr/share/doc/packages/sane-backends/sane-backends.html.

I file HTML citati qui sopra sono realizzati a partire dai file di descrizione per ogni backend: /usr/share/sane/descriptions/"backend".desc.

Il formato delle voci presenti è il seguente (i termini in inglese sono tradotti tra parentesi quadre per scopo illustrativo):

:mfg "Vendor [Produttore] A"

:model "Model [Modello] 1"
:interface [interfaccia] "USB"
:status [stato supporto] :complete [completo]

:model "Model 2"
:interface "SCSI"
:status :good [buono]

:mfg "Vendor B"

:model "Model X"
:interface "Parport" [PORTa PARallela]
:status :minimal [minimo]

:model "Model Y"
:interface "IEEE-1394"
:status :untested [non testato]

:model "Model Z"
:interface "Proprietary" [Proprietaria]
:status :unsupported [non supportato]

Un considerevole numero di scanner è supportato soltanto per mezzo di cosiddetti "external backend" (o backend "esterni"); si vedano i file /usr/share/doc/packages/sane/sane-backends/sane-mfgs-external.html e /usr/share/doc/packages/sane/sane-backends/sane-backends-external.html, inoltre per le informazioni più aggiornate al riguardo puoi consultare la pagina http://www.sane-project.org/lists/sane-backends-external.html.

I backend esterni non fanno parte del software "SANE-backends" proveniente dal SANE project. Di conseguenza i backend esterni non sono inclusi nel pacchetto "sane-backends".

Per ciascun backend esterno, il file di descrizione /usr/share/sane/descriptions-external/"backend".desc illustra quali sono i modelli di scanner supportati o non supportati a quale livello.

Alcuni scanner non funzionano se non viene inviato in upload un firmware opportuno (software all'interno dello scanner che controlla l'hardware del dispositivo) verso lo scanner al momento in cui esso viene "acceso" dal sistema. Per tali modelli particolari, avrai bisogno di ottenere il firmware adatto (chiedi al produttore dello scanner) e di configurare il backend affinché effettui l'upload del firmware nello scanner (vedi la sezione "Backend di SANE" più sotto). Poiché il firmware è concesso in licenza dal produttore del dispositivo, non ci è permesso distribuire il firmware con openSUSE, a meno che il produttore abbia reso il firmware disponibile per la distribuzione e ridistribuzione con una licenza libera. Con gli scanner normali il firmware è, invece, memorizzato in maniera permanente all'interno del dispositivo per cui uno scanner normale è pronto per essere usato non appena esso viene acceso, ovvero attivato dal sistema.

Se non è disponibile alcun backend di SANE per lo scanner (consulta http://www.sane-project.org/sane-backends.html#S-UNSUPPORTED e il file /usr/share/sane/descriptions/unsupported.desc), il dispositivo non può essere utilizzato con uno dei frontend comunemente usati (scanimage, xsane). Può darsi che esista altro software allo scopo (p.es., direttamente dal produttore - potresti chiedere al produttore riguardo un'eventuale disponibilità di un tale programma). Se non è così, allora il dispositivo non può essere utilizzato.

Cavo di connessione USB e hub USB aggiuntivi

Lunghezza massima dei cavi USB:

  • Cavi economici a bassa velocità di connessione, ovvero low-speed, (non di tipo avvolto e non schermati, vedi la pagina di Wikipedia sui cavi a coppie avvolte, non schermati): non più di 3 metri. Non adatti per elevate velocità di trasferimento dati (USB 2).
  • Cavi di elevata qualità e per il trasferimento veloce dei dati, ovvero di tipo full-speed e high-speed (cavi di tipo avvolto e schermati, vedi la pagina di Wikipedia sui cavi a coppie avvolte, schermati): non più di 5 metri.
  • Se viene interposto un hub (anche detto ripetitore) USB, la lunghezza massima consentita potrebbe essere inferiore, a seconda delle proprietà dei cavi e dell'hub.

Alcuni scanner non sono dotati di un alimentatore proprio, bensì ricavano la potenza necessaria (e corrente) dalla porta USB. Se il sottosistema USB del tuo computer non è in grado di fornire la potenza (ovvero la corrente) necessaria, uno scanner di questo tipo non potrà funzionare. In tal caso, prova a verificare se lo scanner funziona interponendo tra questo e il computer un hub USB dotato di alimentazione elettrica separata.

Hardware USB + moduli kernel USB + udev

Qui i dettagli cambiano da versione a versione. Un articolo incentrato sulla configurazione degli scanner non può descrivere tutti i dettagli relativi ai vari livelli più bassi. Fai riferimento alla documentazione specifica appropriata nel caso in cui si presentino problemi in qualcuna di queste aree.

Uno scanner USB collegato deve essere visualizzato dal seguente comando:

lsusb

(eseguilo sia come root che come utente normale) o, se il comando sopra non fosse disponibile, con :

/sbin/lsusb

Qualora nel risultato di questo comando non venga visualizzato il modello dello scanner connesso, il trasferimento dati tra la macchina e lo scanner non potrà essere effettuato dal momento che il kernel non è stato in grado di riconoscere il dispositivo USB oppure non sono stati caricati tutti i moduli USB del kernel necessari.

Per fare dei test sul sistema in caso di problemi, connetti lo scanner direttamente alla macchina come unico dispositivo USB (tranne la tastiera USB o il mouse USB, se ve ne sono). Riavvia quindi il sistema tenendo lo scanner accesso, ovvero collegato all'alimentazione elettrica. Normalmente, hotplug/udev assicura che i necessari moduli USB del kernel vengano caricati automaticamente. Immediatamente dopo il riavvio di sistema, esamina i messaggi del kernel relativi al sottosistema USB con

$ dmesg | grep -i usb

e cerca tutti i messaggi di errori che contengano parole come "error" o "fail".

Verifica se i moduli USB del kernel necessari per l'hardware USB della particolare macchina in uso sono stati caricati. Controlla se l'hardware USB della tua macchina (cioè il chipset dedicato al comparto USB) è supportato. Il comando "/sbin/lspci | grep -i usb" restituisce l'elenco dei controller USB; per informazioni visita http://www.linux-usb.org/.

Permessi di accesso allo scanner USB usando udev

Per questa parte i dettagli cambiano da versione a versione. Un articolo incentrato sulla configurazione degli scanner non può descrivere tutti i dettagli relativi ai vari livelli più bassi. Fai riferimento alla documentazione specifica appropriata nel caso in cui si presentino problemi in qualcuna di queste aree..

I backend hanno accesso agli scanner USB per mezzo di libusb. Questo ha luogo passando per /proc/bus/usb/xxx/yyy o tramite /sys/bus/usb/devices/, o ancora attraverso /dev/bus/usb/xxx/yyy (l'ubicazione reale è cambiata e cambia continuamente da versione a versione di kernel/udev/libusb/qualsiasicosa...) in cui xxx (bus ID, codice di identificazione del bus) e yyy (device ID, identificativo numerico del produttore) non sono in genere valori fissi.

A partire dal kernel 2.6, non viene usato alcun file di dispositivo di tipo statico (come /dev/usbscanner che era usato con il kernel 2.4) per effettuare l'accesso tramite libusb. Al contrario, le voci in /proc/bus/usb/ o /dev/bus/usb/ (o qualunque altra sia realmente la locazione per la versione corrente) vengono generate di nuovo ogni volta che il sistema viene avviato e, o in alternativa, tutte le volte che uno scanner viene scollegato e ricollegato alla presa USB (possibilmente anche quando uno scanner USB viene spento e poi di nuovo accesso). Di conseguenza, i permessi di accesso non si possono più impostare in maniera permanente, come di consueto con il tradizionale comando "chmod".

La migliore soluzione per rimediare a questo tipo di problemi in modo elegante è di utilizzare "saned", che è un servizio per la scansione attraverso una rete. Sul server il servizio saned viene impostato per l'avvio e lanciato per mezzo di xinetd. Sul client viene usato il meta-backend "net" per usare lo scanner attraverso la rete. Potrebbe servirti consultare "man saned" e "man sane-net". Utilizzando l'interfaccia di rete di loopback questo backend può essere usato anche nella macchina host locale. In questo caso server e client sono la stessa macchina, ovvero il "localhost". Per avere accesso ad uno scanner attraverso il servizio "saned" in esecuzione sulla macchina host locale (local host), puoi applicare le seguenti impostazioni:

  1. Assicurati che saned venga eseguito come root (impostazione predefinita in /etc/xinetd.d/sane-port)
  2. Consenti l'accesso da "localhost" in /etc/sane.d/saned.conf
  3. Specifica il server "localhost" in /etc/sane.d/net.conf
  4. Attiva il meta-backend "net" in /etc/sane.d/dll.conf

Nella configurazione degli scanner inclusa in YaST, puoi impostare una tale "Configurazione host locale" attraverso "Altro" e quindi "Scansione via rete...". Solitamente questa è la soluzione di ripiego più semplice quando si presentano problemi di accesso allo scanner per gli utenti normali. Un piccolo inconveniente è che i frontend di scansione (equivalentemente di acquisizione) per l'utente root rileveranno lo scanner due volte. Una volta direttamente come "backend:..." e una seconda duplicata tramite il meta-backend net meta-backend, come "net:localhost:backend:...".

Puoi limitare l'accesso ad alcuni utenti in /etc/sane.d/saned.users mediante l'uso di password specifiche per saned. Per tenere segrete le password assicurati che soltanto root abbia accesso in scrittura su quel file.

Per innalzare una protezione via firewall contro accessi indesiderati al demone saned, vedi le Impostazioni firewall per CUPS e SANE.

In alternativa puoi modificare le impostazioni per i permessi di accesso a udev:

udev è usato per impostare i permessi di lettura/scrittura per mezzo di ACL (per visualizzarli lancia il comando "getfacl /dev/bus/usb/<bus-number>/<device-number>") per il solo utente desktop normale che è correntemente connesso alla sessione locale (ovvero che ha fatto il login ad una sessione grafica con XDM/Kdm) in modo tale che l'utente desktop correntemente connesso alla sessione locale riceva permessi sufficienti per usare, come utente normale, l'unità di scansione.

Le regole di udev provenienti dal pacchetto sane-backends package si trovano in /etc/udev/rules.d/55-libsane.rules - consulta "man udev" per sapere come creare o modificare voci di quel tipo.

Per gli scanner nei dispositivi multifunzione HP è presente una complicazione particolare nelle regole di udev dal momento che i dispositivi multifunzione HP hanno delle regole di udev aggiuntive, fornite dal pacchetto hplip, in /etc/udev/rules.d/55-hpmud.rules, le quali vengono applicate prima delle regole di udev fornite dal pacchetto sane-backends package in /etc/udev/rules.d/55-libsane.rules, in modo tale che le voci in /etc/udev/rules.d/55-libsane.rules possano sovrascrivere le impostazioni in /etc/udev/rules.d/55-hpmud.rules.

Backend di SANE

Ciascun backend ha il proprio file di configurazione /etc/sane.d/"backend".conf e la sua pagina di manuale specifica: "man sane-backend" (sostituisci "backend" con il nome del rispettivo backend).

Uno dei backend ha un funzione speciale: il backend "dll" è un meta-backend (vedi http://www.sane-project.org/html/doc005.html). Il backend dll consente ad un unico frontend di accedere a più scanner per mezzo di altri backend. L'accesso ha luogo nel modo seguente:

                   user
                    |
                 frontend
                    |
     ------ meta-backend dll ------
    |                              |
backend_A                      backend_B
    |                              |
   ...                            ...
    |                              |
scanner A                      scanner B

Il meta-backend dll è sempre in posizione intermedia, anche quando c'è solo uno scanner.

I backend che verranno usati dal meta-backend dll devono essere attivati come descritto qui di seguito in /etc/sane.d/dll.conf, il file di configurazione per il meta-backend dll:

# SANE Dynamic library loader config
backend_A
backend_B
# backend_C

In questo esempio, vengono attivati i backend "backend_A" e "backend_B" mentre "backend_C" viene disabilitato.

Di norma dovrebbe essere sufficiente abilitare soltanto il backend appropriato in /etc/sane.d/dll.conf per fare sì che uno scanner USB sia pronto per l'utilizzo - a condizione che il sistema USB e il livello udev funzionino correttamente, che il backend rilevi automaticamente lo scanner USB e che lo scanner USB abbia un firmware integrato nell'hardware.

Se vengono attivati più backend contemporaneamente potrebbe verificarsi un conflitto tra i backend. Se è questo il caso, verifica se non ci sono problemi se provi ad attivare un solo backend alla volta. In tal modo puoi controllare se un certo backend non funziona del tutto o se il problema è meramente causato da un conflitto con un altro backend in particolare.

Potrebbero risultare necessarie delle modifiche manuali a /etc/sane.d/"backend".conf a seconda del modello di scanner, della modalità con cui è collegato (ad esempio, tramite USB o SCSI), e del rispettivo backend. In ogni caso, assicurati di leggere i commenti contenuti in /etc/sane.d/"backend".conf e la pagina di manuale per il rispettivo backend con "man sane-backend" (sostituisci "backend" con il nome del rispettivo backend).

Esempi:

Normalmente un backend rileva automaticamente gli scanner USB che supporta. Qualora ciò non si verifichi, sarà comunque possibile aggiungere a /etc/sane.d/"backend".conf una riga simile alla seguente:

usb 0xVVVV 0xMMMM

Basandoti sull'output di "lsusb", inserisci il codice ID esadecimale del produttore al posto di 0xVVVV e il codice ID esadecimale del modello al posto di 0xMMMM. Per alcuni backend la sintassi "usb 0xVVVV 0xMMMM" potrebbe essere diversa, o mancare del tutto, consulta la pagina di manuale (con il solito man) per il rispettivo backend.

Per gli scanner SCSI, inserisci una riga simile alla seguente per il file associato al dispositivo SCSI in /etc/sane.d/"backend".conf:

scsi /dev/sg0

Attenzione: un file di dispositivo SCSI errato potrebbe rendere il tuo sistema non più operativo!

Per gli scanner su porta parallela, inserisci manualmente una riga simile ad una delle seguenti nel file /etc/sane.d/"backend".conf:

ieee1284 parport0

(p.es. in /etc/sane.d/canon_pp.conf)

pio 0x378

(p.es. in /etc/sane.d/epson.conf)

device 0x378

oppure

parport0

(p.es. in /etc/sane.d/plustek_pp.conf) Attenzione: Una voce errata potrebbe rendere il tuo sistema non più operativo!

Per alcuni scanner, si deve fare l'upload nello scanner del firmware adatto. Dovrai ottenere il file del firmware appropriato (chiedi al produttore) e inserire il nome del file contenente il firmware in /etc/sane.d/"backend".conf. Attenzione: firmware incompatibile potrebbero danneggiare lo scanner!

Dato che un backend è solitamente compatibile con svariati modelli di scanner, le impostazioni predefinite devono riflettere il minimo comune denominatore di tutto i modelli supportati. Di conseguenza potresti avere interesse a ottimizzare le impostazioni per un particolare modello in /etc/sane.d/"backend".conf. Attenzione: impostazioni scorrette potrebbe danneggiare lo scanner!

Frontend

Per finalità di test, usa il frontend da riga di comando "scanimage" (vedi "man scanimage").

"scanimage -L" dovrebbe mostrare il tuo scanner. Se questo non avviene, allora SANE (più precisamente il backend) non è in grado di accedere allo scanner. Se "scanimage -L" visualizza lo scanner soltanto quando il comando viene eseguito dall'utente "root", allora solo root è in grado di accedere allo scanner, ma non un normale utente. In tal caso, il problema si trova a livello dei "Permessi di accesso allo scanner USB usando udev". Il risultato restituito da "scanimage -L" per uno scanner USB presente di solito il seguente formato

device 'backend-name:libusb:bus-ID:device-ID' ...

e per uno scanner SCSI

device 'backend-name:/dev/sg[0123...]' ...

Il formato di una reale stringa di dispositivo per SANE (per esempio: libusb:bus-ID:device-ID o /dev/sg[0123...]) dipende dallo specifico backend.

Il comando "scanimage -d Dispositivo >/tmp/image.pnm" ordina allo scanner di scandire un'immagine e salvarne il risultato nel file /tmp/image.pnm. Sostituisci "Dispositivo" con la stringa di SANE relativa al dispositivo, in accordo con l'output di "scanimage -L". Esempio:

$ scanimage -d backend:libusb:123:456 >/tmp/image.pnm

Il processo di scansione ha luogo con le impostazioni predefinite del rispettivo backend.

"scanimage -d Dispositivo -h" elenca tutta le opzioni disponibili. La prima parte elenca le opzioni generiche che non dipendono dal rispettivo backend. La seconda parte elenca le opzioni specifiche per il backend assieme ai valori, o all'intervallo di valori, ammessi e con le rispettive impostazioni predefinite racchiuse tra parentesi quadre. Esempio (traduzione di alcune parti utili del file tra parentesi graffe):

Options specific to device 'backend:libusb:123:456':	{opzioni specifiche del dispositivo}
  Scan Mode:
  --mode Gray|Color {tonalità di grigio|colore} [Color]
      Selects the scan mode.	{seleziona la modalità di scansione}
  --resolution 75..600dpi [150]
      Sets the resolution of the scanned image.	{imposta la risoluzione dell'immagine acquisita}
  Geometry:
  -l 0..216mm [0]
      Top-left x position of scan area.	{geometria: coordinata x (ordinata) dal vertice in alto a sinistra della superficie di scansione}
  -t 0..297mm [0]
      Top-left y position of scan area.	{geometria: coordinata y (ascissa) dal vertice in alto a sinistra della superficie di scansione}
  -x 0..216mm [216]
      Width of scan-area.	{larghezza della superficie di scansione}
  -y 0..297mm [297]
      Height of scan-area.	{altezza della superficie di scansione}

Per esempio, il comando per scandire una fotografia in bianco e nero di 10 x 15 cm con orientamento verticale (modalità ritratto) con risoluzione di 300 dpi (punti per pollice) potrebbe essere simile al seguente:

$ scanimage -d backend:libusb:123:456 --mode Gray --resolution 300 -x 100 -y 150 >photo.pnm

Scansione via rete

Supponi di avere uno scanner USB connesso ad una macchina host della rete (il "server") e di voler accedere a quel dispositivo da un altro host della rete (il "client").

Un requisito necessario è che sia già possibile lanciare una scansione funzionante senza problemi sul server.

Per fornire accesso addizionale allo scanner via rete, puoi servirti di "saned", un servizio per la scansione via rete. Sul server il demone saned viene impostato per l'avvio e lanciato per mezzo di xinetd. Sul client viene usato il meta-backend "net" per effettuare la scansione via rete. Vedi "man saned" e "man sane-net".

  1. Sul server imposta saned per essere avviato (imposta "disable = no" in /etc/xinetd.d/sane-port e avvia il demone xinetd)
  2. Sul server consenti l'accesso dal client in /etc/sane.d/saned.conf
  3. Sul client specifica il server in /etc/sane.d/net.conf
  4. Sul client abilita il meta-backend "net" in /etc/sane.d/dll.conf

Nella configurazione degli scanner inclusa in YaST, puoi impostare una tale configurazione attraverso "Altro" e quindi "Scansione via rete..."

Nota l'avviso di sicurezza mentre stai leggendo "man saned":

saned is not intended to be exposed to the internet
or other non-trusted networks.

(Trad.: saned non è pensato per essere accessibile da internet o da altre reti non fidate). Utilizza quindi un firewall che sia stato configurato in modo adeguato, consulta allora le Impostazioni firewall per CUPS e SANE.

La pila (o stack) riportata qui di seguito, e costituita da numerosi strati (anche chiamati layer). Essa deve essere in grado di funzionare nella sua interezza al fine di consentire agli utenti di accedere ad uno scanner USB, che è collegato ad un host remoto, a partire dalla workstation locale dell'utente, nella quale sarà in esecuzione l'applicazione utente:

Utente
  |
Applicazione (frontend)
  |
SANE net (meta-backend nel client)
  |
Interfaccia di rete del Client 
  |                             macchina client
Rete ==========================================
  |                             macchina server
Interfaccia di rete del Server
  |
SANE saned (meta-frontend per il backend)
  |
SANE backend (il vero driver usato per lo scanner)
  |
libusb
  |
Moduli USB del kernel
  |
Hardware USB nella macchina server
  |
Collegamento tramite cavo USB
  |
Scanner

Questo tipo di configurazione per la scansione via rete ha ragione di essere soltanto quando la workstation che fa da client sia inoltre collocata in prossimità dello scanner (in particolare quando sia il client che il server con lo scanner sono collocati nella medesima stanza).

Al contrario un dispositivo multifunzione con scanner e stampante di rete, dotato di tutte le funzionalità, viene solitamente impiegato in un modo diverso come "dispositivo indipendente di scansione su e-mail" in cui né un particolare software driver per lo scanner, né alcun software SANE sono chiamati in causa in alcun modo.

Normalmente è possibile eseguire una scansione direttamente su una fotocopiatrice (dispositivo con scanner + stampante) di rete professionale e specificare risoluzione di scansione, formato per il file di immagine (p.es. tiff, PDF, ...) e tutte le altre opzioni di scansione direttamente al dispositivo. In particolare, è possibile specificare l'indirizzo e-mail a cui il dispositivo dovrà inviare il file di immagine con la scansione, così da poter ricevere l'immagine della scansione sotto forma di allegato di posta, concordemente con il formato di file immagine che si era specificato.

Prima di acquistare una fotocopiatrice di rete, è opportuno che controlli attentamente che il particolare dispositivo supporti la "scansione su e-mail stand-alone" (senza nessun software aggiuntivo) e che il dispositivo fornisca un'interfaccia utente comoda da usare per il lavoro quotidiano.

Questo modo di operare è di solito molto più conveniente per l'utente dato che se si utilizzasse un backend di SANE sarebbe necessario specificare tutti i parametri di scansione dalla propria stazione di lavoro, usando un frontend per SANE.

Ma qualora la tua workstation si trovasse lontano del dispositivo di scansione di rete, dovresti spostarti fino allo scanner di rete per inserirvi il tuo foglio e lasciare un messaggio bene in vista sul network scanner con cui avvisi che lo stai correntemente usando in modo tale che agli altri non rimuovano il tuo foglio da scandire, quindi tornare alla tua workstation per specificare i parametri di scansione e avviare la scansione. Infine dovresti nuovamente spostarti fino al network scanner per recuperare il tuo foglio e rimuovere il tuo avviso e poi tornare alla tua postazione.

Localizzare i malfunzionamenti (Debugging)

Per scopi di debugging si rivelano utili i messaggi di debug dei vari layer in SANE e la modalità prolissa (output dettagliato) di "scanimage". Consulta "man sane-usb", "man sane-scsi", "man sane-dll", "man sane-backend" and "man scanimage". Sostituisci "backend" con il nome del rispettivo backend. Sostituisci "Dispositivo" o con il nome del rispettivo backend o con un dispositivo di SANE per esteso come "backend:libusb:123:456" (fai riferimento alla sezione "Frontend").

Esempi:

Esecuzione test senza messaggi di debug:

scanimage -d Dispositivo -v >/dev/null && echo OK || echo FAILED

Esecuzione test con soltanto i messaggi di debug del meta-backend "dll". Utile quando, per esempio, il meta-backend "dll" non è in grado di localizzare o caricare il vero backend, o più precisamente la libreria per i backend "/usr/lib[64]/sane/libsane-backend.so...":

export SANE_DEBUG_DLL=4
scanimage -d Dispositivo -v >/dev/null && echo OK || echo FAILED
unset SANE_DEBUG_DLL

Esecuzione test con soltanto i messaggi di debug del backend realmente in uso. Il valore per il debug dipende dal particolare backend, vedi "man sane-backend" (sostituisci "backend" con il nome del rispettivo backend):

export SANE_DEBUG_backend=128
scanimage -d Dispositivo -v >/dev/null && echo OK || echo FAILED
unset SANE_DEBUG_backend

Esecuzione test con soltanto i messaggi di debug del sistema USB (per quanto riguarda il sistema SCSI vedi "man sane-scsi"):

export SANE_DEBUG_SANEI_USB=128
scanimage -d Dispositivo -v >/dev/null && echo OK || echo FAILED
unset SANE_DEBUG_SANEI_USB

Sono possibili inoltre combinazioni dei casi precedenti, ma potrebbe risultare più difficile identificare gli errori dato che si otterranno troppi messaggi di debug in una sola volta:

export SANE_DEBUG_DLL=4
export SANE_DEBUG_backend=128
export SANE_DEBUG_SANEI_USB=128
scanimage -d Dispositivo -v >/dev/null && echo OK || echo FAILED
unset SANE_DEBUG_SANEI_USB
unset SANE_DEBUG_backend
unset SANE_DEBUG_DLL

Driver di terze parti per scanner

Un driver di terze parti è considerato software proprietario quando include almeno una parte che sia software proprietario - solitamente una libreria proprietaria, solo in formato binario, che può essere definita un "modulo".

Per il software proprietario nessuno, eccetto gli autori o il produttore del software proprietario, sono in grado di fornire qualsiasi tipo di aiuto o supporto, dato che nessuno - eccetto autori o produttore - sanno come realmente funziona il loro software proprietario.

In questo caso puoi soltanto contattare coloro da cui hai acquistato/ricevuto il software proprietario per qualunque aiuto e supporto.

Se il software driver dello scanner di terze parti non funziona in conformità con SANE puoi soltanto contattare coloro da cui hai ricevuto il driver suddetto per aiuto e supporto.

Se il driver di terze parti lavora in modo compatibile con SANE:

Il modulo Scanner di YaST2 non è in grado di supportare i driver di terze parti per scanner poiché non esiste una modalità prefissata in SANE per installare i driver di scansione di terze parti in modo tale che programmi per la configurazione generale degli scanner (come il modulo Scanner di YaST2) lo possano supportare.

Tuttavia il supporto per la configurazione generale degli scanner non è di solito necessario, dato che:

Fondamentalmente i software driver di terze parte per gli scanner compatibili con SANE durante l'installazione del software driver dovrebbero aggiungere il proprio nome del driver al file /etc/sane.d/dll.conf, in modo tale che il driver venga attivato e possa poi essere operativo, vedi "Backend di SANE" più sopra.

Dopo aver installato un driver scanner di terze parti che funziona in conformità con SANE, verifica che il suo nome del driver compaia in elenco in /etc/sane.d/dll.conf, così da abilitare il driver.

Dopo di ché controlla che "scanimage -L" (eseguilo come root e come utente normale) rilevi lo scanner, vedi "Frontend" più sopra.

Se il driver viene attivato tramite /etc/sane.d/dll.conf ma "scanimage -L" non rileva lo scanner quando lo esegui come root, allora è davvero il driver che non rileva lo scanner, il che significa che il driver non funziona.

Se "scanimage -L" rileva lo scanner quando lo esegui come root ma non lo rileva quando lo esegui come utente normale, allora vi è di solito un problema di permessi d'accesso, vedi la sezione sui "Permessi di accesso allo scanner USB usando udev" più sopra.

Non sarebbe molto utile se YaST supportasse i driver di scansione di terze parti, dato che tutto ciò che YaST potrebbe fare sarebbe attivare il driver in /etc/sane.d/dll.conf, ma YaST non più riparare un driver che è abilitato ma non funziona.

Se un driver di terze parti per uno scanner non funziona, puoi provare tu stesso a farne il debug, vedi "Localizzare i malfunzionamenti (Debugging)" più sopra o contatta coloro da cui hai ricevuto il driver di terze parti per aiuto e supporto aggiuntivi.

Ulteriori informazioni