Implémentation du scanner de codes à barres sur Java [fermé]

J'ai récemment dû implémenter un système de scanner pour interagir avec java.

J'ai utilisé Honeywell Voyager MS9540 USB scanner de code à barres.

Par défaut, le scanner a envoyé les données directement en entrée clavier - aucun pilote requis.

Mais, il était très facile d'obtenir ce modèle d'interagir directement avec java plutôt que d'utiliser un hook clavier (pour utiliser les codes à barres comme des variables en java, comme vous l'avez mentionné).

Ce modèle a un paramètre pour émuler un port série, vous pouvez alors lire les données numérisées en utilisant le javax.paquet comm. Pour moi, c'était beaucoup mieux qu'un crochet de clavier pour obtenir les données de code-barres car le programme n'a pas besoin de la mise au point avant de pouvoir interpréter un scan (je ne voudrais pas créer un crochet de clavier global).

Mon programme java lit toutes les entrées du port série spécifié et écrit le code-barres dans une base de données. J'ai également configuré le programme pour passer toutes les analyses de codes à barres non reconnues au clavier (tout code à barres que mon application n'a pas créé-j'ai utilisé une signature distincte sur mes codes à barres) c'était pour qu'il fonctionne comme un scanner de codes à barres régulier pour toutes les autres applications qui pourraient lire des codes à barres à partir du clavier.

Vous pourriez probablement lire les données directement à partir de n'importe quel scanner USB (sans l'émulation de port série que ce modèle a) en faisant un codage JNI intensif mais je n'étais pas prêt à prendre le temps de travailler sur le code natif.

Pour configurer ce modèle particulier pour le port série émulation tout ce que vous faites est de scanner un code à barres spécifique dans ceci document avec le scanner que vous souhaitez configurer. C'est le code à barres intitulé "Mode d'émulation série".

Ce scanner nécessite un pilote pour l'émulation de port série. J'ai trouvé les instructions d'implémentation et les pilotes nécessairesici (sous l'onglet" logiciel"). Téléchargez le package intitulé: "Pilote série USB Honeywell Scanning and Mobility (HSM)". Le PDF intitulé " HSM USB Serial Guide de démarrage du conducteur " avait les instructions.

Si vous n'êtes pas familier avec le javax.api comm. Veuillez lire l'intro dans ceci exemple par Rick Proctor-il vous indique où obtenir le pot et où placer les fichiers (javax.comm n'est pas livré en standard avec la plupart des paquets java).

Je suis sûr qu'il existe d'autres modèles de scanner qui ont une émulation de port série (je ne travaille pas pour Honeywell).

Voici une version quelque peu allégée de mon code-barres classe de lecteur:

package scanhandler;


import java.awt.AWTException;
import java.awt.Robot;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Enumeration;
import java.util.Properties;
import java.util.TooManyListenersException;
import javax.comm.CommPortIdentifier;
import javax.comm.PortInUseException;
import javax.comm.SerialPort;
import javax.comm.SerialPortEvent;
import javax.comm.SerialPortEventListener;
import javax.comm.UnsupportedCommOperationException;

public class ScanHandler implements Runnable, SerialPortEventListener {

    private static CommPortIdentifier   myCommPortIdentifier;
    private static Enumeration          portList;
    private static String               TimeStamp;
    private static String               driverClass;
    private static String               connectionString;
    private static String               comPort;    

    private Connection                  myConnection;
    private InputStream                 myInputStream;
    private Robot                       myRobot;
    private SerialPort                  mySerialPort;
    private Thread                      myThread;


    public ScanHandler() {

        // open serial port
        try {
            TimeStamp = new java.util.Date().toString();
            mySerialPort = (SerialPort) myCommPortIdentifier.open("ComControl", 2000);
            //System.out.println(TimeStamp + ": " + myCommPortIdentifier.getName() + " opened for scanner input");
        } catch (PortInUseException e) {
            e.printStackTrace();
        }

        // get serial input stream
        try {
            myInputStream = mySerialPort.getInputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // add an event listener on the port
        try {
            mySerialPort.addEventListener(this);
        } catch (TooManyListenersException e) {
            e.printStackTrace();
        }
        mySerialPort.notifyOnDataAvailable(true);

        // set up the serial port properties
        try {
            mySerialPort.setSerialPortParams(9600,
                SerialPort.DATABITS_8,
                SerialPort.STOPBITS_1,
                SerialPort.PARITY_NONE);
            mySerialPort.setDTR(false);
            mySerialPort.setRTS(false);

        } catch (UnsupportedCommOperationException e) {
            e.printStackTrace();
        }

        // make a robot to pass keyboard data
        try {
            myRobot = new Robot();
        } catch (AWTException e) {
            e.printStackTrace();
        }

        // create the thread
        myThread = new Thread(this);
        myThread.start();
    }

    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {}
    }

    // on scan
    public void serialEvent(SerialPortEvent event) {

        if (event.getEventType() == SerialPortEvent.DATA_AVAILABLE) {

            StringBuilder myStringBuilder = new StringBuilder();
            int c;
            try {

                // append the scanned data onto a string builder
                while ((c = myInputStream.read()) != 10){
                   if (c != 13)  myStringBuilder.append((char) c);
                }               

                // send to keyboard buffer if it the barcode doesn't start with '5'
                if (myStringBuilder.charAt(0) != '5') {

                    for (int i = 0; i < myStringBuilder.length(); i++) {
                        myRobot.keyPress((int) myStringBuilder.charAt(i));
                        myRobot.keyRelease((int) myStringBuilder.charAt(i));
                    }

                // here's the scanned barcode as a variable!
                } else {
                    TimeStamp = new java.util.Date().toString();
                    System.out.println(TimeStamp + ": scanned input received:" + myStringBuilder.toString());                    
                }

                // close the input stream
                myInputStream.close();

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        // read ScanHandler properties
        Properties myProperties = new Properties();
        try {
            myProperties.load(new FileInputStream("config.properties"));
            comPort             = myProperties.getProperty("ScanHandler.comPort");
        } catch (IOException e) {
            e.printStackTrace();
        }              

        try {

            // get our pre-defined COM port
            myCommPortIdentifier = CommPortIdentifier.getPortIdentifier(comPort);
            ScanHandler reader = new ScanHandler();

        } catch (Exception e) {
            TimeStamp = new java.util.Date().toString();
            System.out.println(TimeStamp + ": " + comPort + " " + myCommPortIdentifier);
            System.out.println(TimeStamp + ": msg1 - " + e);
        }
    };    
}

Le scanner bardcode que j'ai utilisé a agi comme un périphérique clavier (il est apparu comme un périphérique USB clavier HID dans le système d'exploitation). Lorsque le code à barres a été scanné, il a envoyé le code comme s'il était tapé. Aucune API spéciale n'était nécessaire pour interagir avec elle.

Je sais que c'est un fil assez ancien mais la recherche peut vous y amener.

Cela peut être traité comme un ajout à la réponse de Geronimo:

Pour le système d'exploitation Linux, il n'est pas nécessaire d'installer des pilotes pour les scanners de codes à barres en mode d'émulation série car il existe un support natif pour les ports série USB. Nous utilisons plusieurs types de scanners Honeywell et tous fonctionnent hors de la boîte, ces scanners en émulation série montre dans nos systèmes comme / dev / ttyACM0,/dev / ttyACM1 etc.

Récemment, nous avons changé de javax.comm à jssc en tant que bibliothèque java pour interfacer les ports série. Si je me souviens bien, sous Windows 7 64bit système javax.la bibliothèque comm ne peut pas lire ou écrire depuis/vers le port série et jssc a une api très similaire.

Je me rends compte que c'était une vieille question mais j'ai pensé ajouter une solution supplémentaire pour simuler l'entrée du scanner de codes à barres. Cette solution ne fonctionne que pour simuler l'entrée du scanner en tant que données du clavier.

Puisque les scanners utilisent souvent simplement une entrée au clavier, nous pouvons simuler cela en utilisant un script AutoHotkey . Voici un exemple de script:

#NoEnv  ; Recommended for performance and compatibility with future AutoHotkey releases.
; #Warn  ; Enable warnings to assist with detecting common errors.
SendMode Input  ; Recommended for new scripts due to its superior speed and reliability.
SetWorkingDir %A_ScriptDir%  ; Ensures a consistent starting directory.

; Barcode 1
; Hotkey = ctrl + alt + 1
^!1::
    SendInput [BC200015]
Return

; Barcode 2
; Hotkey = ctrl + alt + 2
^!2::
    SendInput [BC300013]
Return

Remplacez simplement [BC300013] et [BC200015] par l'entrée de votre scanner attendue.