Barcode Scanner Emulator
Lettori di codici a barre USB HID e seriali
Un lettore in emulazione tastiera USB HID digita il codice a barre decodificato nell'applicazione che ha il focus. Un lettore seriale USB espone un'interfaccia seriale, spesso come porta COM virtuale, e l'applicazione deve aprire quella porta e leggere i byte. USB è il cavo e il bus. HID e seriale sono modi diversi di presentare i dati.
Scegli l'interfaccia che l'applicazione riesce davvero a leggere. Un campo di cassa che accetta già la digitazione è un problema di emulazione tastiera. Un servizio che deve ricevere scansioni mentre nessun campo di testo ha il focus, o che deve tenere i byte del lettore separati dalla tastiera, è un problema seriale. Molti lettori ne offrono solo una. Alcuni possono passare dall'una all'altra. Il manuale di quel modello è l'elenco delle modalità che puoi testare.
La guida Emulazione tastiera HID spiega nel dettaglio il percorso delle pressioni. Come funzionano i lettori di codici a barre? tratta acquisizione e decodifica. Questa pagina confronta le due interfacce host e i test che spettano a ciascuna.
Che cos'è la modalità di emulazione tastiera USB HID?
In modalità tastiera USB HID il lettore si enumera come una tastiera. Il sistema operativo carica il proprio driver di tastiera normale. Dopo una decodifica, il lettore invia i caratteri come pressioni di tasti al controllo che ha il focus della tastiera. Un modulo web, un campo articolo del POS o una casella di testo desktop possono accettare quell'input senza codice specifico del lettore.
Il focus decide la destinazione. Se il campo previsto non ha il focus, i caratteri finiscono in un altro controllo oppure si perdono. Il lettore non fa clic e non sposta il puntatore.
Un suffisso configurato può seguire il payload. Enter invia molti moduli a campo singolo. Tab sposta il focus sul controllo successivo. Nessuno dei due tasti è garantito. Le scelte di suffisso sono trattate in Suffissi ENTER e TAB nei lettori di codici a barre.
Gli eventi tastiera ordinari non includono il produttore del lettore, il numero di serie né un indicatore che dica che i tasti sono arrivati da un lettore. I browser che implementano WebHID rifiutano comunque le interfacce tastiera, quindi una pagina non può aprire il dispositivo in emulazione e leggere i report HID grezzi.
Che cos'è la modalità seriale USB di un lettore di codici a barre?
In modalità seriale USB il lettore non digita. Espone un'interfaccia seriale su USB. Il sistema operativo di solito presenta quell'interfaccia come una porta COM virtuale: un nome COM su Windows, un dispositivo cu o tty su macOS, oppure un dispositivo ttyACM o ttyUSB su Linux. Il nome lo assegna il driver e può cambiare dopo che il lettore viene scollegato.
Una porta COM virtuale non è una porta RS-232 fisica. RS-232 è un'interfaccia elettrica, con il proprio connettore e i propri livelli di tensione, che un computer legge attraverso una UART. Il seriale USB usa un cavo USB. L'applicazione apre comunque una porta seriale e legge byte, ma il segnale sul filo è USB. Alcuni prodotti sono un vero lettore RS-232 più un adattatore da USB a seriale. Altri implementano USB CDC e non parlano mai RS-232. Tratta la porta che ti mostra il sistema operativo come il punto di integrazione e non dare per scontato che i dettagli elettrici coincidano.
L'applicazione apre la porta, legge il flusso di byte e decide dove un messaggio inizia e finisce. Un frame comune è il testo del codice a barre seguito da CR (0x0D), LF (0x0A), oppure CR e poi LF. Quel framing è un'impostazione del dispositivo, non una regola di USB. È possibile anche un byte di prefisso come STX. La guida Prefisso e suffisso nel lettore di codici a barre: guida completa separa quei byte dal tasto Enter che invia un lettore in emulazione tastiera.
La velocità in baud, i bit di dati, la parità e i bit di stop contano su una UART vera e su molti adattatori da USB a seriale. Una velocità sbagliata produce spazzatura invece di un errore chiaro. Alcuni dispositivi COM virtuali USB CDC ignorano la velocità in baud richiesta dall'host e consegnano comunque i byte. Non esiste un'impostazione unica che vada bene per ogni lettore seriale virtuale. Usa la velocità e il framing del manuale di quel modello, poi confermali con un codice a barre noto.
Il processo che tiene aperta la porta riceve i dati. Il focus della tastiera non sceglie la destinazione. Un altro programma che ha già la porta aperta blocca una seconda apertura. Scollegare il lettore toglie la porta. Ricollegarlo può creare un nome nuovo, e l'applicazione deve aprire di nuovo quella porta.
HID e seriale
| Caratteristica | Emulazione tastiera HID | Seriale USB |
|---|---|---|
| Consegna dei dati | Input in stile tastiera | Flusso di byte seriale |
| Focus dell'input richiesto | Sì. Le pressioni seguono il controllo con il focus | No. I byte vanno al processo che ha aperto la porta |
| Integrazione nel browser | Input ordinario ed eventi tastiera | Web Serial dove il browser la supporta, oppure software fuori dalla pagina |
| Controllo dell'applicazione | Limitato al comportamento della tastiera, al focus e ai suffissi | L'applicazione legge il flusso e lo inquadra |
| Identificazione del dispositivo | Non disponibile dagli eventi tastiera ordinari | Il sistema operativo può mostrare un nome di porta. Un'identità stabile dipende ancora dal driver |
| Configurazione | Impostazioni del lettore, inclusi suffisso e layout di tastiera | Impostazioni del lettore più le impostazioni di porta dell'host che il dispositivo usa davvero |
| Uso tipico | Moduli e inserimento articoli nel POS | Integrazioni dedicate che possiedono il dispositivo |
Questi sono i casi abituali. Un modello, un sistema operativo e un driver dati possono differire. Un lettore Bluetooth in modalità tastiera HID segue la colonna dell'emulazione a livello di applicazione. Bluetooth SPP segue la colonna seriale.
Come funzionano i lettori HID nelle applicazioni web
Una scansione in emulazione aggiorna l'elemento con il focus. I caratteri stampabili generano keydown e poi input. Enter e Tab generano keydown e non inseriscono un carattere in un campo di testo normale. event.key è "Enter" o "Tab" per quei tasti, e una stringa di un carattere per un carattere stampabile. event.code nomina il tasto fisico e può restare uguale quando un disallineamento del layout di tastiera cambia event.key.
L'ascoltatore sotto conferma il campo solo quando arriva Enter. Un lettore senza suffisso Enter lascia il testo nel campo.
const field = document.querySelector('#barcode')
if (!(field instanceof HTMLInputElement)) {
throw new Error('Barcode field was not found.')
}
field.addEventListener('keydown', (event) => {
if (event.key !== 'Enter') {
return
}
event.preventDefault()
const value = field.value.trim()
if (!value) {
return
}
console.log(value)
field.value = ''
})
Metti il focus su #barcode prima della scansione. preventDefault() impedisce a un modulo padre di inviare una seconda volta. Se il lettore invia Tab al posto, leggi il valore in quel keydown e lascia che il browser sposti il focus. Se non invia nessuno dei due, invia il campo da un pulsante o da un'altra azione esplicita. Una pausa nella digitazione è solo un'euristica della fine di una scansione.
Niente in quegli eventi identifica il dispositivo USB. Una persona, una macro o l'emulatore possono produrre la stessa sequenza. La validazione spetta al payload. Il percorso nel browser, inclusi Tab e un input vuoto, è in Come testare i lettori di codici a barre nelle applicazioni web.
Come funzionano i lettori seriali nelle applicazioni
Un'integrazione seriale apre una porta, legge i byte, li divide in messaggi e gestisce la scomparsa della porta. Sul desktop, quella è l'API seriale del sistema operativo o una libreria del produttore. In un browser, l'unica opzione integrata è la Web Serial API, e solo nei browser che la implementano.
Web Serial è disponibile nei browser basati su Chromium. Firefox e Safari non la forniscono. La pagina deve essere un contesto sicuro, cioè HTTPS o localhost. requestPort() deve partire da un gesto dell'utente, e l'utente deve scegliere la porta nella richiesta del browser. Un lettore in emulazione tastiera non compare in quell'elenco, perché non è un dispositivo seriale. Web Serial non può nemmeno vedere una porta seriale che il sistema operativo non ha esposto.
La velocità in baud dell'esempio è un punto di partenza che sostituisci con il valore del manuale. Il ciclo tratta CR o LF come la fine di un messaggio e consuma una coppia CRLF come un solo terminatore. Se il tuo lettore usa un frame diverso, questa divisione è sbagliata anche con la porta aperta.
<button id="open-serial" type="button">Open scanner port</button>
<p id="status" role="status"></p>
<script>
const button = document.querySelector('#open-serial')
const status = document.querySelector('#status')
function takeLine(buffer) {
const cr = buffer.indexOf('\r')
const lf = buffer.indexOf('\n')
const end = cr < 0 ? lf : lf < 0 ? cr : Math.min(cr, lf)
if (end < 0) {
return null
}
const line = buffer.slice(0, end).trim()
let rest = buffer.slice(end + 1)
if (buffer[end] === '\r' && rest.startsWith('\n')) {
rest = rest.slice(1)
}
return { line, rest }
}
button.addEventListener('click', async () => {
if (!('serial' in navigator)) {
status.textContent = 'This browser does not provide Web Serial.'
return
}
let port
try {
port = await navigator.serial.requestPort()
await port.open({ baudRate: 9600 })
} catch (error) {
status.textContent = 'The port was not opened.'
return
}
const reader = port.readable.getReader()
const decoder = new TextDecoder()
let buffer = ''
try {
while (true) {
const { value, done } = await reader.read()
if (done) {
break
}
buffer += decoder.decode(value, { stream: true })
let next = takeLine(buffer)
while (next) {
if (next.line) {
status.textContent = next.line
}
buffer = next.rest
next = takeLine(buffer)
}
}
} catch (error) {
status.textContent = 'The serial read stopped.'
} finally {
reader.releaseLock()
await port.close()
}
})
</script>
Il ciclo di lettura prosegue finché il flusso termina o la lettura fallisce. Scollegare il lettore di solito rifiuta la lettura. releaseLock() e close() vengono eseguiti in finally. Le porte già approvate per questa origine si possono elencare con navigator.serial.getPorts() senza mostrare di nuovo la richiesta. La prima approvazione richiede ancora l'utente.
Un'applicazione desktop segue la stessa idea con l'API seriale della piattaforma: aprire, leggere, inquadrare e riaprire quando il dispositivo torna. Questa pagina non inventa comandi del produttore. Se il lettore si aspetta un protocollo proprietario, quel protocollo è nella documentazione del produttore.
Qual è meglio: HID o seriale?
Nessuna modalità è migliore per ogni prodotto. Usa la modalità che il lettore offre davvero e la modalità che l'applicazione riesce a leggere.
Scegli HID quando
- L'applicazione accetta già l'input da tastiera in un campo con il focus.
- Vuoi che un modulo o una schermata POS funzionino senza codice del dispositivo.
- Il flusso di lavoro può garantire il focus prima di ogni scansione.
- Enter o Tab corrisponde al modo in cui quel modulo conferma o avanza.
Valuta il seriale quando
- Le scansioni devono arrivare mentre il focus è in una finestra di dialogo, su un pulsante o da nessuna parte.
- I byte del lettore devono restare separati dalla digitazione.
- L'applicazione può aprire una porta, inquadrare i messaggi e riprendersi quando il dispositivo viene scollegato.
- L'host può concedere il permesso a quella porta e nessun altro processo ne ha bisogno nello stesso momento.
Un lettore che si enumera solo come tastiera non si può passare al seriale via software sull'host. Conferma le modalità nel manuale prima di progettare l'integrazione.
Passare da HID a seriale
Alcuni lettori cambiano modalità quando leggi un codice a barre di configurazione dal manuale di quel produttore, oppure quando scrivi un profilo con l'utilità del produttore. Altri sono costruiti come una sola interfaccia e non hanno nulla da commutare.
Non esiste un codice a barre di configurazione che cambi ogni marca. Una sequenza stampata per un altro modello può non fare nulla, oppure lasciare il lettore in una modalità inattesa. Dopo ogni modifica, controlla che cosa mostra il sistema operativo: una tastiera, una porta COM o entrambe. Poi testa il percorso che usa la tua applicazione. La Guida alla configurazione del lettore di codici a barre descrive i gruppi di impostazioni abituali. Non sostituisce il manuale.
Testare un lettore HID
- Collega il lettore e conferma che è in emulazione tastiera. Un editor di testo deve ricevere caratteri quando un campo di quell'editor ha il focus.
- Apri il tester di input dei codici a barre.
- Fai clic su Start Test oppure sull'area di lettura. Diventa blu quando è pronto. La pagina non prende il focus da sola.
- Leggi un codice a barre di cui conosci già il payload.
- Confronta il valore catturato e il conteggio dei caratteri con quel payload.
- Leggi il suffisso: ENTER, TAB o None. Enter e Tab non fanno parte della stringa del codice a barre.
Il tester registra gli eventi tastiera che il browser può vedere. Non può leggere una porta seriale e non può identificare il dispositivo USB. Quando l'intervallo medio tra i caratteri è sotto 100 ms, segnala quel tempo. Il tempo non è un'identificazione dell'hardware. Per ogni keydown, inclusi key e code, usa il tester degli eventi tastiera. Un passaggio di QA più ampio è in Come testare l'input di un lettore di codici a barre.
Testare un lettore seriale
Il tester di input dei codici a barre non apre una porta COM. Un test seriale ha bisogno di un programma che possa aprire la porta esposta dal lettore.
- Conferma che il lettore è in una modalità seriale e che il sistema operativo elenca una porta quando è collegato. Scollegalo e verifica che la porta sparisca.
- Annota il nome della porta. È specifico del sistema operativo e può cambiare al collegamento successivo.
- Apri la porta da un'applicazione compatibile: un terminale seriale, la tua app desktop o l'esempio Web Serial qui sopra in un browser Chromium su HTTPS o localhost.
- Imposta velocità in baud, bit di dati, parità e bit di stop quando il manuale li specifica. Salta i valori inventati.
- Leggi un codice a barre noto.
- Confronta i byte o il testo decodificato con quel payload.
- Controlla il framing. Cerca un prefisso e CR, LF o CRLF dopo i dati, solo se è quello che ha configurato il manuale.
Se l'apertura della porta fallisce perché è occupata, chiudi l'altro programma che la tiene. Se il testo è spazzatura, le impostazioni di linea non corrispondono al dispositivo. Se la porta non compare mai, il lettore può essere ancora in modalità tastiera, il driver può mancare oppure l'utente del sistema potrebbe non essere autorizzato ad aprire i dispositivi seriali.
Problemi comuni
Il lettore funziona in un editor di testo e non nell'applicazione di destinazione. Il dispositivo sta digitando. La destinazione non ha il focus, oppure un ascoltatore di keydown scarta i tasti. Parti da Il lettore funziona in Notepad ma non nel POS.
Il lettore non digita in nessun campo di testo. Può essere in modalità seriale, spento o non sta leggendo il simbolo. Un lettore in modalità seriale non digita. Cerca una porta COM prima di diagnosticare il campo. Il lettore di codici a barre non funziona separa un lettore morto dall'interfaccia sbagliata.
La porta seriale manca. La modalità tastiera non crea una porta COM. Un driver assente, un cavo di sola ricarica o un lettore senza modalità seriale producono lo stesso sintomo. Osserva l'elenco dispositivi del sistema mentre colleghi il lettore.
La porta seriale è già in uso. Solo un processo può leggerla. Chiudi il terminale o l'altra copia dell'applicazione, poi riaprila.
Le impostazioni di comunicazione sono sbagliate. Velocità in baud, parità o bit di stop non corrispondenti sembrano caratteri a caso. Imposta i valori del manuale di quel modello, poi leggi di nuovo un codice noto.
ENTER o TAB non arrivano mai. È un'impostazione di suffisso dell'emulazione. Il tester di input segnala None. Vedi Al lettore di codici a barre manca ENTER e la guida dei suffissi collegata sopra. Un lettore seriale non invia il tasto Enter. Può inviare byte CR o LF al posto.
I caratteri sono sbagliati su un lettore in emulazione. Il layout di tastiera del lettore e quello del sistema operativo possono non coincidere. I byte seriali non vengono rimappati da quel layout. Vedi Layout di tastiera errato del lettore di codici a barre.
Il browser non riesce ad accedere al lettore. Un lettore in emulazione non comparirà nella richiesta di Web Serial. Firefox e Safari non hanno la Web Serial API. Una pagina che non è HTTPS o localhost non può usarla. L'utente può anche chiudere la richiesta della porta.
L'applicazione perde il lettore dopo che viene scollegato. Un lettore in emulazione torna come tastiera, e la scansione successiva richiede ancora il focus. Una porta seriale sparisce finché l'applicazione non apre la porta nuova. Il nome può non corrispondere al precedente.
Scenari di integrazione
Applicazioni web
L'emulazione tastiera si adatta a un input con il focus e agli eventi DOM ordinari. L'accesso seriale dentro la pagina significa Web Serial in un browser che la supporta, un contesto sicuro e una porta scelta dall'utente. Una pagina che deve supportare Firefox, Safari e chioschi non presidiati non può dipendere solo da Web Serial. Un aiutante locale può possedere la porta COM e inoltrare i codici a barre completi alla pagina. Quell'aiutante è software separato. La pagina non dovrebbe aspettarsi che un test in emulazione lo eserciti.
Sistemi POS
Un POS che mette il focus nel campo articolo e conferma con Enter è un'integrazione in emulazione. Un POS che deve leggere mentre una finestra modale è aperta, o che deve ignorare la tastiera, è un'integrazione seriale. Mescolarle produce scansioni nel campo sbagliato o scansioni che non arrivano mai. Abbina la modalità del lettore alla schermata che è davvero in servizio.
Applicazioni desktop
Un'app desktop può accettare l'input in emulazione nel controllo che ha il focus, oppure aprire la porta COM virtuale e tenere una sessione per la vita del processo. Il possesso della porta, la riconnessione e il framing fanno parte di quella sessione. Il focus no.
Automazione QA
Barcode Scanner Emulator digita un valore che scegli nell'applicazione con il focus e può inviare ENTER, TAB o nessun suffisso. Questo copre le regressioni dell'emulazione tastiera: focus, validazione e gestione del suffisso. Non crea una porta COM virtuale, non enumera dispositivi USB e non riproduce velocità in baud e framing. I test seriali hanno ancora bisogno di una porta seriale e di un lettore, oppure di un test double che scriva lo stesso framing di byte che la tua applicazione analizza.
Applicazioni chiosco
Un chiosco che usa l'input in emulazione deve tenere il campo di scansione focalizzato attraverso finestre di dialogo, salvaschermo e messaggi di errore. Un focus perso e la scansione successiva colpisce una scorciatoia o niente. Un chiosco che usa il seriale può leggere la porta senza quel focus, e deve conservare il permesso sul dispositivo e riaprire la porta dopo un'interruzione di corrente o uno strappo del cavo.
Dove si colloca Barcode Scanner Emulator
Barcode Scanner Emulator è un'app desktop per Windows, macOS e Linux. Riproduce il percorso di tastiera che usa un lettore in emulazione. Inserisci il testo, scegli un ritardo di digitazione e scegli un suffisso tra nessuno, ENTER o TAB. Una scorciatoia globale digita quel testo nell'applicazione con il focus.
Usalo per sviluppare e fare regressione dei moduli in stile HID quando il lettore non è sulla scrivania. Abbinalo al tester di input dei codici a barre per vedere il valore, i tasti di prefisso e il suffisso che il browser ha ricevuto.
Non emula un dispositivo seriale USB, una porta COM virtuale, un'enumerazione USB né una decodifica ottica. Quei comportamenti restano dell'hardware, o di un test double seriale che controlli tu.