Barcode Scanner Emulator
Prefisso e suffisso nel lettore di codici a barre: guida completa
Un prefisso è un dato o una sequenza di controllo che un lettore di codici a barre invia prima del codice a barre decodificato. Un suffisso è ciò che invia dopo quel valore. Lo stesso modello si può impostare con prefissi e suffissi diversi, e un lettore seriale non li consegna come un lettore in emulazione tastiera.
Un prefisso del lettore di codici a barre viene inviato prima del valore decodificato. Un suffisso viene inviato dopo. Un lettore può produrre questa sequenza:
Prefisso: STX
Codice a barre: 123456789
Suffisso: ENTER
In un manuale, STX indica spesso il carattere di controllo, non le tre lettere S, T e X. Su un lettore in emulazione tastiera, ENTER è di solito il tasto Invio, non i due caratteri CR e LF inseriti in un campo di testo. Quello che ricevi dipende dal modello, dall'interfaccia e dall'applicazione. Nessuna impostazione vale per ogni apparecchio.
La guida Suffissi ENTER e TAB nei lettori di codici a barre resta sulla scelta e sulla risoluzione di quei due terminatori. Questa guida riguarda la cornice intorno al codice a barre: cosa viene prima, cosa viene dopo e come un'applicazione web deve leggere entrambi.
Che cos'è un prefisso del lettore di codici a barre?
Un prefisso è una sequenza configurata che il lettore trasmette prima del payload. Il payload è il testo decodificato dalla simbologia, per esempio 123456789. Il prefisso non fa parte di quella decodifica, salvo che il lettore sia stato impostato per aggiungerlo.
Usi comuni:
- Segnare l'inizio di un messaggio. I protocolli seriali e di terminale a volte inviano un carattere di controllo, spesso chiamato STX, così l'host sa che è iniziato un nuovo frame.
- Nominare la simbologia. Con l'identificatore di simbologia AIM attivo, un lettore può inviare un prefisso stampabile breve, come
]C1per Code 128 o]E0per EAN, prima delle cifre. L'applicazione può diramarsi su quell'identificatore. - Instradare l'input in software POS o di terminale più vecchio. Un codice fisso prima dei dati diceva all'host a quale campo o dispositivo apparteneva la lettura.
- Etichettare una postazione precisa. Due lettori possono ricevere prefissi stampabili diversi, così un registro mostra quale corsia ha inviato il codice.
Un prefisso stampabile è fatto di caratteri ordinari. Compaiono in un campo di testo all'inizio della stringa. Un prefisso di carattere di controllo, come STX (0x02), non sono le lettere S, T e X. Un lettore in emulazione tastiera può non riuscire a digitare quel carattere di controllo. Un lettore seriale può inviarlo come byte. Leggi il manuale del modello che hai prima di scrivere codice che si aspetta l'uno o l'altro.
Un prefisso non dimostra che un lettore ha prodotto l'input. Una persona, una macro o il Barcode Scanner Emulator possono digitare gli stessi caratteri. Tratta un prefisso come la cornice che hai configurato, poi valida il payload come qualsiasi altro input dell'utente.
Che cos'è un suffisso del lettore di codici a barre?
Un suffisso è una sequenza configurata inviata dopo il payload. Il compito abituale è dire all'applicazione che la lettura è finita, oppure spostare il focus. I lettori differiscono. Alcuni offrono Invio, Tab, CR, LF, CR+LF, una stringa personalizzata o niente. Alcuni ne offrono solo una o due.
ENTER. Il tasto Invio. In un browser è un evento di tastiera, event.key === "Enter". Non viene inserito in un campo di testo normale.
TAB. Il tasto Tab, event.key === "Tab". Il browser sposta il focus sul controllo successivo. Il tasto non viene inserito nel campo.
CR. Ritorno a capo, ASCII 0x0D. Su un'interfaccia seriale o di terminale può essere un byte reale dopo il payload. Su un'emulazione tastiera, un'impostazione chiamata CR o ritorno a capo di solito significa il tasto Invio. Il browser segnala comunque Invio. Il valore del campo non guadagna un carattere CR.
LF. Avanzamento di riga, ASCII 0x0A. È un carattere di controllo diverso da CR. Su un flusso seriale può essere un byte a sé. Un'emulazione tastiera non ha un tasto standard di avanzamento di riga come ha Invio e Tab. Non dare per scontato che una voce di menu chiamata LF digiti un carattere visibile o un secondo Invio.
CRLF. CR seguito da LF, i due byte 0x0D 0x0A. Alcuni host seriali e di terminale si aspettano quella coppia come fine riga. Un campo di testo del browser non memorizza quella coppia quando qualcuno preme Invio.
Caratteri personalizzati. Un suffisso stampabile come # o un codice breve viene digitato dopo il codice a barre, quindi entra nella stringa, salvo che l'applicazione lo tolga. Un carattere di controllo personalizzato segue la stessa divisione di STX: byte su una porta seriale, pressioni su un'emulazione e solo le pressioni che l'interfaccia tastiera può davvero inviare.
ENTER, CR e LF sono nomi affini di fine riga nei manuali. Non sono intercambiabili in ogni applicazione. Un lettore in emulazione, un lettore seriale, Notepad e un modulo web possono mostrare ciascuno un risultato diverso per un'impostazione con lo stesso nome.
Prefisso e suffisso
| Caratteristica | Prefisso | Suffisso |
|---|---|---|
| Posizione | Prima dei dati del codice a barre | Dopo i dati del codice a barre |
| Scopo | Segnare l'inizio o etichettare l'input | Segnare il completamento o attivare un'azione |
| Esempio | STX, oppure un identificatore AIM stampabile come ]C1 |
ENTER, TAB o un carattere stampabile come # |
| Uso comune | Incorniciare o identificare la lettura | Inviare un modulo o spostare il focus |
| In un campo di testo | I caratteri stampabili stanno all'inizio del valore | I caratteri stampabili stanno alla fine. Invio e Tab no |
| Identità | Un marcatore configurato che chiunque può digitare | Un marcatore configurato che chiunque può digitare |
Togli un prefisso o un suffisso personalizzato solo quando hai configurato esattamente quella sequenza e il record salvato non deve includerla. Lascia un identificatore AIM al suo posto finché l'applicazione non ha una regola per esso.
ENTER, TAB, CR e LF
Questi nomi compaiono sui fogli di configurazione. Il lato che riceve vede pressioni di tasto oppure byte, secondo l'interfaccia. La guida Emulazione tastiera HID descrive il percorso delle pressioni. Una porta seriale è un percorso diverso: l'applicazione legge byte e il focus non sceglie dove vanno.
ENTER
Su un lettore in emulazione tastiera, ENTER è il tasto Invio. Dentro un campo di testo di una riga, i browser attuali usano quel tasto per inviare il modulo che lo contiene. Una casella di ricerca può confermare la lettura su quell'evento. Un modulo con più campi può essere inviato prima che i campi successivi siano compilati. Chiama preventDefault() sull'evento submit, o sul keydown di Invio, quando la pagina deve tenere il valore e restare dov'è. Gestisci Invio in un solo punto. Un listener keydown e un listener submit che accettano entrambi la lettura la registrano due volte.
Alcuni lettori inviano NumPad Enter. event.key resta "Enter". event.code può essere "NumpadEnter" invece di "Enter". Prova event.key se entrambi i tasti devono confermare il campo.
La guida Suffissi ENTER e TAB nei lettori di codici a barre confronta quelle due scelte per POS e moduli web. Al lettore di codici a barre manca ENTER tratta un lettore che digita il codice a barre e poi si ferma.
TAB
TAB è il tasto Tab. Il browser sposta il focus dopo keydown. Leggi il campo in quel gestore keydown, finché ha ancora il focus, e lascia l'azione predefinita al suo posto quando il controllo successivo deve ricevere il cursore. preventDefault() tiene il focus sul campo attuale.
Maiusc+Tab è lo stesso tasto con Maiusc premuto. Un suffisso Tab del lettore è Tab senza Maiusc. Ignora event.shiftKey se chi usa la tastiera deve poter tornare indietro nel modulo.
CR
Il ritorno a capo porta il cursore all'inizio della riga in un terminale. Il byte è 0x0D. Un lettore seriale può accodare quel byte al payload. Un'impostazione di emulazione tastiera chiamata CR invia di solito il tasto Invio invece di inserire 0x0D nel testo. Premere Invio in un campo del browser non scrive un carattere CR in input.value.
Se l'host è un terminale o un programma in ascolto su una porta COM, cerca il byte. Se l'host è una pagina web, cerca event.key === "Enter".
LF
L'avanzamento di riga sposta il cursore del terminale di una riga in basso. Il byte è 0x0A. Alcuni host trattano LF da solo come l'a capo. Altri lo ignorano se prima non è arrivato CR. Un lettore in emulazione che elenca LF come suffisso può inviare un tasto che il sistema operativo non trasforma in a capo, oppure non inviare nulla che un campo di testo conservi. Cattura il tasto nel tester degli eventi tastiera prima di gestire un presunto LF nel codice dell'applicazione.
CRLF
CRLF è la sequenza di due controlli, prima CR e poi LF. I file di testo in stile Windows e molti dispositivi seriali la usano come un solo a capo. Una pagina di configurazione che indica un suffisso CRLF significa che il lettore proverà a inviare quella coppia dopo il payload sull'interfaccia che sta usando.
In un browser, premere Invio non produce una sequenza CRLF letterale dentro un campo di testo. Il modulo riceve un evento di tastiera. Un <textarea> può inserire un a capo quando l'utente preme Invio, e quell'a capo è il comportamento di modifica del browser, non la prova che il lettore abbia emesso i byte 0x0D 0x0A. Un lettore seriale può ricevere quei due byte e deve trattarli come terminatore solo se quel lettore è stato configurato per inviarli. Non togliere CR o LF dal mezzo di un payload che può contenerli.
Come prefissi e suffissi incidono sulle applicazioni web
Una lettura in emulazione tastiera è una raffica di pressioni nel controllo che ha il focus. La pagina non apre il lettore. Se il focus è su un altro campo, prefisso, codice a barre e suffisso finiscono tutti lì.
keydown scatta per ogni tasto, inclusi Invio e Tab, prima che il browser inserisca un carattere o sposti il focus. event.key è il carattere o il nome del tasto dopo che il sistema operativo ha applicato il layout di tastiera. I caratteri stampabili di prefisso e suffisso compaiono nel campo tramite l'evento input. Invio e Tab non compaiono.
Il listener qui sotto conferma il campo quando arriva Invio. Non aggiunge un suffisso che il lettore ha omesso. Se il lettore non invia Invio, il valore resta nel campo finché qualcos'altro non lo legge.
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 lettura. preventDefault() impedisce a un modulo antenato di inviare una seconda volta. Se il campo non è dentro un modulo e vuoi l'invio nativo, ometti preventDefault().
Senza suffisso, aspetta un'azione esplicita: un pulsante, un Invio successivo dell'operatore o il passo seguente del flusso. Un timer di inattività può trattare una pausa come la fine della lettura. Quel timer è un'euristica. Un lettore lento, un ritardo Bluetooth o chi digita in fretta possono cadere dal lato sbagliato. Preferisci un suffisso configurato quando il flusso ha bisogno di una fine certa.
Un prefisso stampabile noto si può togliere dopo aver letto il valore:
function withoutConfiguredPrefix(value, prefix) {
if (prefix && value.startsWith(prefix)) {
return value.slice(prefix.length)
}
return value
}
Passa solo il prefisso che hai configurato, per esempio ']C1'. Non togliere un numero arbitrario di caratteri da ogni lettura.
Per un modulo completo che gestisce anche Tab, un input vuoto e una seconda lettura, vedi Come testare i lettori di codici a barre nelle applicazioni web.
Come configurare prefissi e suffissi
Le impostazioni di prefisso e suffisso stanno sul lettore. I nomi dei tasti e il modo di cambiarli dipendono dal produttore. Non esiste un codice a barre di configurazione che funzioni su ogni marca, e questa guida non ne stampa uno.
Metodi tipici:
- Leggi un codice a barre di configurazione dal manuale di quel modello esatto. Il foglio è raggruppato per impostazione: suffisso, prefisso, layout di tastiera, simbologia.
- Usa il programma di configurazione del produttore, poi scrivi il risultato sul lettore via USB.
- Usa l'utilità di gestione dispositivi di quella linea di prodotto quando aggiorni molte unità.
Dopo una modifica, leggi un codice a barre noto e confronta il risultato con la descrizione, nel manuale, dell'impostazione scelta. Un ripristino di fabbrica di un'altra marca può lasciare il lettore invariato o metterlo in una modalità inattesa. La Guida alla configurazione del lettore di codici a barre riassume le impostazioni che di solito contano. Non sostituisce il manuale.
Il Barcode Scanner Emulator può digitare un valore che scegli e poi inviare ENTER, TAB o nessun suffisso. Metti un prefisso stampabile in quel valore quando devi esercitare la gestione del prefisso senza hardware. L'emulatore non emette una coppia di byte CR/LF seriali e non legge un'etichetta.
Come testare il comportamento di prefisso e suffisso
Usa un lettore in modalità tastiera, tastiera HID USB o tastiera HID Bluetooth.
- Collegalo e aspetta finché indica di avere alimentazione.
- 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.
- Leggi il valore acquisito e il numero di caratteri. I caratteri stampabili del prefisso o del suffisso sono dentro quella stringa. La riga Prefix riguarda i tasti con nome che arrivano prima del primo carattere, come un modificatore. Non estrae un prefisso digitato come
]C1dal testo del codice a barre. - Controlla il suffisso. Il tester segnala ENTER, TAB o None. Con Auto capture attivo, il risultato compare dopo Invio, Tab o una breve pausa quando i tasti si fermano. Disattiva Auto capture per tenere l'acquisizione finché premi Stop. Invio e Tab non fanno parte della stringa del codice a barre.
- Confronta quel risultato con la configurazione che intendevi. Poi apri il tester degli eventi tastiera e leggi di nuovo quando ti serve ogni
keydownin ordine, inclusikey,codee i tempi.
Il tester di input registra gli eventi di tastiera che il browser può vedere. Non può leggere una porta seriale, quindi non può mostrare CR o LF come byte grezzi. Una prova in emulazione non dimostra che cosa invierà un'impostazione seriale.
Risoluzione dei problemi
Il lettore non invia ENTER. Compare il codice a barre e il cursore resta nel campo. Il tester di input segnala None. Il suffisso è spento, oppure è impostato su qualcosa di diverso da Invio. Vedi Al lettore di codici a barre manca ENTER.
TAB sposta il focus in modo inatteso. Il lettore sta inviando il tasto Tab. Quello è il suffisso configurato. Usa Invio quando il modulo deve essere inviato, oppure leggi il valore sul keydown di Tab quando il flusso deve avanzare. I dettagli sono nella guida Suffissi ENTER e TAB nei lettori di codici a barre.
Il modulo viene inviato due volte. Il browser invia su Invio e un listener keydown accetta anche la lettura. Tieni un solo percorso di completamento e chiama preventDefault() sull'altro.
Un prefisso compare dentro il codice a barre. Un prefisso stampabile fa parte della stringa acquisita. Disattivalo sul lettore oppure togli quella sequenza esatta nell'applicazione. Un identificatore di simbologia attivo è una fonte comune di un ] iniziale e di altri due caratteri. Un prefisso di controllo che l'emulazione non può digitare mancherà, invece di essere visibile.
I caratteri sono sbagliati. Il layout del lettore e quello del sistema operativo possono non coincidere, e questo cambia i caratteri del prefisso e la punteggiatura mentre la lunghezza resta uguale. Vedi Layout di tastiera errato del lettore di codici a barre.
L'applicazione non vede mai la fine della lettura. Non c'è un suffisso e la pagina aspetta Invio. Aggiungi un suffisso adatto al modulo, oppure completa il valore con un'azione esplicita. Una stima sui tempi perderà alcune letture vere e accetterà un po' di digitazione.
CR/LF cambia da un'applicazione all'altra. Notepad inserisce una riga nuova quando riceve Invio. Un campo di testo web tiene il codice a barre e genera un evento di tasto. Un programma seriale può ricevere 0x0D, 0x0A o entrambi. Confronta l'interfaccia prima di cambiare il lettore. Se nessuna applicazione riceve caratteri, inizia da Il lettore di codici a barre non funziona.
Un passaggio più ampio su focus, letture ripetute e flussi POS è in Come testare l'input di un lettore di codici a barre.
Matrice di test
La colonna di configurazione è ciò che imposti sul lettore, o ciò che digiti con l'emulatore quando il caso è un suffisso di tastiera. Il comportamento atteso è ciò che l'applicazione deve fare. Un caso CRLF seriale non è lo stesso test di un tasto Invio in un browser.
| Configurazione | Comportamento atteso dell'applicazione |
|---|---|
| Nessun prefisso, nessun suffisso | Il valore del codice a barre viene ricevuto e non arriva alcun tasto di completamento. Il valore resta disponibile finché l'applicazione non lo legge. |
| Nessun prefisso, suffisso ENTER | L'applicazione riceve il tasto di completamento una volta e memorizza il payload senza un carattere di terminazione. |
| Nessun prefisso, suffisso TAB | Il focus può passare al controllo successivo. L'applicazione legge il valore prima di quello spostamento. |
| Prefisso stampabile personalizzato | I caratteri del prefisso compaiono prima dei dati decodificati. L'applicazione tiene o toglie quel prefisso esatto di proposito. |
| Suffisso stampabile personalizzato | I caratteri del suffisso compaiono dopo i dati decodificati. Invio e Tab sono tasti, quindi non compaiono nella stringa. |
| Sequenza CRLF | Un host seriale o di terminale elabora i byte CR e LF configurati. Un campo di testo del browser non ottiene quei byte da una pressione di Invio. |
Esegui le righe di tastiera sul lettore in emulazione e, se manca l'hardware, con le impostazioni ENTER, TAB e nessun suffisso dell'emulatore. Esegui la riga CRLF sull'interfaccia che deve trasportare quei byte. I risultati effettivi dipendono ancora da quell'interfaccia e dall'applicazione.