scanner - barcode java example

Implementación de Barcode Scanner en Java

Question

Buenos señores, tengo una pregunta. El proyecto escolar de Java en el que estoy trabajando actualmente requiere que tenga un escáner de código de barras USB como entrada externa para conectarme a mi computadora portátil. Realmente no compré el USB Scanner porque es bastante caro para un estudiante. Así que tengo que reunir pruebas de que este escáner funcionaría con mi programa.

¿Podría el escáner leer un código de barras (presumiblemente impreso en línea) y almacenarlo en una variable? Si es así, ¿es cierto que el evento de acción para la presión del escáner se leerá exactamente como una pulsación de tecla del teclado? Si es así, ¿cómo se vería la línea de código?

Además, si pudiera publicar sus experiencias con Barcode Scanners, o dar algún consejo, como qué escáner comprar, eso ayudaría mucho. ¡Aclamaciones!

Answer 1

El escáner bardcode que he usado actuó como un dispositivo de teclado (apareció como un dispositivo USB de teclado HID en el sistema operativo). Cuando se escaneó el código de barras, envió el código como si hubiera sido escrito. No se necesitaron API especiales para interactuar con él.

Answer 2

Me di cuenta de que esta era una vieja pregunta, pero pensé que agregaría una solución adicional para simular la entrada del Barcode Scanner. Esta solución solo funciona para simular la entrada del escáner como datos del teclado.

Como el escáner a menudo solo usa la entrada del teclado, podemos simular esto usando un script de AutoHotkey . A continuación se muestra un ejemplo de una secuencia de comandos:

#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

Simplemente reemplace [BC300013] y [BC200015] con la entrada esperada del escáner.

Answer 3

Recientemente tuve que implementar un sistema de escáner para interactuar con Java.

Utilicé el escáner de código de barras USB Honeywell Voyager MS9540 .

Como valor predeterminado, el escáner envió los datos directamente como entrada de teclado, no se requiere controlador.

Pero fue muy fácil hacer que este modelo interactuara directamente con Java en lugar de usar un gancho de teclado (para usar los códigos de barras como variables en Java, como mencionaste).

Este modelo tiene una configuración para emular un puerto serie, luego puede leer los datos escaneados utilizando el paquete javax.comm. Para mí, esto fue mucho mejor que un gancho de teclado para obtener los datos del código de barras porque el programa no necesita el foco antes de poder interpretar un escaneo (no me gustaría crear un gancho de teclado global).

Mi programa Java lee todas las entradas del puerto serie especificado y escribe el código de barras en una base de datos. También configuré el programa para pasar cualquier escaneo de código de barras no reconocido al teclado (cualquier código de barras que mi aplicación no creó - utilicé una firma distintiva en mis códigos de barras) esto fue así que funcionaría como un escáner de código de barras normal para cualquier otra aplicación que pudiera lee los códigos de barras del teclado.

Probablemente podría leer los datos directamente desde cualquier escáner USB (sin la emulación del puerto serie que tiene este modelo) haciendo un poco de codificación JNDI intensiva, pero no estaba dispuesto a tomarse el tiempo para descifrar el código nativo.

Para configurar este modelo en particular para la emulación de puertos serie, todo lo que hace es escanear un código de barras específico en this documento con el escáner que desea configurar. Es el código de barras titulado "Modo de emulación serial".

Este escáner requiere un controlador para emulación de puerto serie. Encontré las instrucciones de implementación y los controladores necesarios here (en la pestaña "software"). Descargue el paquete titulado: "Honeywell Scanning and Mobility (HSM) USB Serial Driver". El PDF titulado "Guía de inicio del controlador serie USB HSM" tenía las instrucciones.

Si no está familiarizado con la API de javax.comm. Lea la introducción en this ejemplo de Rick Proctor: le dice dónde obtener el tarro y dónde colocar los archivos (javax.comm no viene de serie con la mayoría de los paquetes de Java).

Estoy seguro de que hay otros modelos de escáneres que tienen emulación de puerto serie (no trabajo para Honeywell).

Aquí hay una versión algo despojada de mi clase de lector de código de barras:

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);
        }
    };    
}

Answer 4

Sé que es un hilo bastante viejo, pero la búsqueda puede llevarte allí.

Esto se puede tratar como una adición a la respuesta de Gerónimo:

Para el sistema operativo Linux no es necesario instalar controladores para escáneres de códigos de barras en el modo de emulación serial ya que hay soporte nativo para puertos seriales USB. Usamos varios tipos de escáneres Honeywell y todos funcionan de inmediato; los escáneres en emulación serial se muestran en nuestros sistemas como / dev / ttyACM0, / dev / ttyACM1, etc.

Recientemente hemos cambiado de javax.comm a jssc como una biblioteca java para puertos de interfaz de serie. Si recuerdo bien, en Windows 7 el sistema de 64 bits javax.comm la biblioteca no puede leer o escribir desde / a puerto serie y jssc tiene una API muy similar.