Controlling a scanner from a linux device

In order to control a scanner from from a linux device. we need to have backend and a front end side.

Backend

This part will handle sending orders to the scanning device.

Example tasks:

• Finding available scanners on the current machine
• Ordering a scanner to take pictures
• Generating a hash from the picture's content
• Saving those pictures or sending them over the network

Frontend

This part will show you a UI that will give you the ability to control the scanner by communicating with the backend.

Example tasks:

• Draw a UI to control the scanner
• Send the orders to the backend based on user's choices

---

How to achieve this?

We can use the SANE library as a core solution to control scanners.

what is SANE?

The SANE library provides a common interface for a wide range of scanners, allowing software applications to communicate with them in a consistent way regardless of the specific make and model of the scanner. This makes it possible for developers to create software that works with a wide range of scanners without having to write custom drivers for each one.

SANE was originally developed for Linux, but it has been ported to other operating systems including macOS and Windows. It is widely used in open-source scanning applications such as XSane, Simple Scan, and GScan2PDF, as well as in commercial applications like Adobe Acrobat.

---

Options we can Integrate SANE library with

SANE can be integrated with a wide range of software options to give us the ability to control scanners

Hybrid (backend and frontend)

Tauri

Tauri is an open-source framework for building secure and performant native desktop applications using web technologies like HTML, CSS, and JavaScript. It is built with Rust.

We can create a desktop application that uses HTML, CSS, and JavaScript for the UI (frontend) part. and uses rust for the backend part in a single codebase.

The rust backend will catch the events from the frontend and will use the SANE library to control scanners.

Electron.js

ElectronJS is an open-source framework for building desktop applications using web technologies like HTML, CSS, and JavaScript. It allows developers to create cross-platform applications that can run on Windows, macOS, and Linux operating systems. ElectronJS is used by popular applications like Slack, Visual Studio Code, and Discord.

The nodejs backend will catch the events from the frontend and will use the SANE library to control the scanner.

Backend

Rust

We can control the scanner by installing the SANE crate.

use sane;

fn main() {
    // Connect to the SANE server
    let context = sane::init().unwrap();

    // Get a list of available scanners
    let devices = context.list_devices().unwrap();

    if devices.is_empty() {
        println!("No scanners available.");
        return;
    }

    // Use the first scanner in the list
    let scanner = &devices[0];

    // Open the scanner
    let handle = context.open_scanner(scanner).unwrap();

    // Set some options for the scanner
    handle.set_option("mode", "Color").unwrap();
    handle.set_option("resolution", "300").unwrap();

    // Scan the image
    let mut image = handle.start().unwrap();
    let image_data = image.read_image().unwrap();

    // Save the image to a file
    std::fs::write("scan.jpg", &image_data).unwrap();

    // Close the scanner
    handle.cancel().unwrap();
}

PHP

We can control the scanner by enabling the the SANE extention.

<?php
// Connect to the SANE server
$sane = new Sane;

// Get a list of available scanners
$devices = $sane->getDevices();

if (empty($devices)) {
    echo "No scanners available.";
    exit;
}

// Use the first scanner in the list
$scanner = $devices[0];

// Open the scanner
$handle = $sane->open($scanner);

// Set some options for the scanner
$sane->getOptionDescriptor($handle, 'mode')->setValue('Color');
$sane->getOptionDescriptor($handle, 'resolution')->setValue(300);

// Scan the image
$imageData = $sane->scan($handle);

// Save the image to a file
file_put_contents('scan.jpg', $imageData);

// Close the scanner
$sane->close($handle);
?>

NodeJS

There are also SANE library bindings for nodejs too.

const sane = require('sane');

// Connect to the SANE server
const context = sane.create();

// Get a list of available scanners
const devices = context.getDevices();

if (devices.length === 0) {
  console.log('No scanners available.');
  return;
}

// Use the first scanner in the list
const scanner = devices[0];

// Open the scanner
const handle = context.open(scanner);

// Set some options for the scanner
handle.setOption('mode', 'Color');
handle.setOption('resolution', 300);

// Scan the image
const image = handle.start();
const imageData = image.read();

// Save the image to a file
const fs = require('fs');
fs.writeFileSync('scan.jpg', imageData);

// Close the scanner
handle.cancel();

Frontend

javascript framework

We can use any javascript framework like react, vue, svelte or even vanilla js as a client that sends requests to the linux backend application.

---

Other tools we can use

scanimage

Scanimage is a command line tool built using the SANE library that allows users to control and configure a connected scanner from the command line. It can be used to initiate scans, adjust scan settings such as resolution, color mode, and page size, and save the resulting images in various file formats. Scanimage supports a wide range of image formats, including JPEG, PNG, TIFF, and PDF.

We can execute bash commands using any backend to control the scanner.