从输入事件中读取条形码（Linux，C）
我有一个小程序，可以从/ dev / input / event4读取条形码。这是代码：
#include <sys/file.h>
#include <stdio.h>
#include <string.h>
#include <linux/input.h>
int main (int argc, char *argv[])
{
struct input_event ev;
int fd, rd;
//Open Device
if ((fd = open ("/dev/input/event4", O_RDONLY|O_NONBLOCK)) == -1){
printf ("not a vaild device.\n");
return -1;
}
while (1){
memset((void*)&ev, 0, sizeof(ev));
rd = read (fd, (void*)&ev, sizeof(ev));
if (rd <= 0){
printf ("rd: %d\n", rd);
sleep(1);
}
if(rd>0 && ev.value==0 && ev.type==1){
printf("type: %d, code: %d, value: %d, rd: %d\n", ev.type, ev.code, ev.value, rd);
}
}
return 0;
}
现在，我已经使用在线生成器（http://www.barcode-
generator.de/V2/de/index.jsp
）创建了一些条形码。条形码为：123456789和1234567890
扫描条形码时，我的programm输出为：
type: 1, code: 2, value: 0, rd: 16
type: 1, code: 3, value: 0, rd: 16
type: 1, code: 4, value: 0, rd: 16
type: 1, code: 5, value: 0, rd: 16
type: 1, code: 6, value: 0, rd: 16
type: 1, code: 7, value: 0, rd: 16
type: 1, code: 8, value: 0, rd: 16
type: 1, code: 9, value: 0, rd: 16
type: 1, code: 10, value: 0, rd: 16
type: 1, code: 28, value: 0, rd: 16
为123456789
和
type: 1, code: 28, value: 0, rd: 16
为1234567890
因此，不能正确识别10位条形码。
代码：28表示这是一个RETURN / ENTER，这是条形码的内部终止符，因此它直接来自扫描仪。
有谁能告诉我为什么？也许代码有问题？
再见安德烈
问题答案：
当您应该只考虑该事件read()的回报== sizeof ev，因为我们是从输入设备读取这里。如果返回零，则意味着不再发生任何事件（也许设备已分离？）。如果返回-1，请检查errno。如果read()返回任何其他值，则说明内核驱动程序已经崩溃了，您可以将其视为致命错误。
errno == EINTR是正常的（发生在传递信号时），这本身不是错误。它不应该在这里发生，但是忽略它（将其视为打ic，而不是错误）是非常安全的。
errno == EAGAIN``O_NONBLOCK在open()标记中使用时发生，并且尚无新事件可用。
绝对没有理由在O_NONBLOCK这里使用。它所做的是使你的代码浪费CPU周期，从返回的每秒几万次read()的调用只是返回-1用errno == EAGAIN。只需将其放下即可，以便read()将仅等待新事件到达并返回它。
请参阅我对input_event结构描述问题的回答。
总而言之，适用于ev_type == 1 == EV_KEY：
ev_value == 0：释放键（向上键）ev_value == 1：按下键（按下键）ev_value == 2：自动重复（自动重复键）ev_code == 1 == KEY_ESCev_code == 2 == KEY_1ev_code == 3 == KEY_2ev_code == 10 == KEY_9ev_code == 11 == KEY_0ev_code == 28 == KEY_ENTER
实际提供的设备的按键1 2 3 4 5 6 7 8 9 Enter。
（请注意，您只显示了按键释放事件；实际上，您应该分别看到两个，一个带有ev_value == 1，然后带有一个ev_value == 0，ev_code）。
我尝试过的一个中国人很好，尽管便宜。它具有一本手册，其中包含一些条形码，包括一些可以在条形码格式（和位数）之间切换的手册。我隐约记得使用两个条形码切换到另一种模式，并使用最小音量来发出哔声。即使分离后，它似乎仍保留设置。
这是我将使用哪种实施方式读取条形码的示例。我显然将条形码读取部分拆分为一个单独的文件。
以下代码专用于公共领域（在CC0下许可），因此可以随意使用它。没有任何形式的保证，所以不要怪我有任何破损。（欢迎进行任何错误修复；如果报告了错误，则将进行检查并包含在下面的代码中。建议在下面添加注释；每两天左右都会阅读所有答案中的注释。）
头文件barcode.h：
#ifndef BARCODE_H
#define BARCODE_H
#include <stdlib.h>
#include <signal.h>
/* This flags turns nonzero if any signal
* installed with install_done is caught.
*/
extern volatile sig_atomic_t done;
/* Install signals that set 'done'.
*/
int install_done(const int signum);
/* Barcode device description.
* Do not meddle with the internals;
* this is here only to allow you
* to allocate one statically.
*/
typedef struct {
int fd;
volatile int timeout;
timer_t timer;
} barcode_dev;
/* Close a barcode device.
* Returns 0 if success, nonzero errno error code otherwise.
*/
int barcode_close(barcode_dev *const dev);
/* Open a barcode device.
* Returns 0 if success, nonzero errno error code otherwise.
*/
int barcode_open(barcode_dev *const dev, const char *const device_path);
/* Read a barcode, but do not spend more than maximum_ms.
* Returns the length of the barcode read.
* (although at most length-1 characters are saved at the buffer,
* the total length of the barcode is returned.)
* errno is always set; 0 if success, error code otherwise.
* If the reading timed out, errno will be set to ETIMEDOUT.
*/
size_t barcode_read(barcode_dev *const dev,
char *const buffer, const size_t length,
const unsigned long maximum_ms);
#endif /* BARCODE_H */
以下barcode.c文件中的实现当前仅接受数字（0到1），但是添加任何其他必要的键（例如KEY_A到KEY_Z）应该很简单。当前的操作忽略了移位，控制等功能，因为据我所知，任何扫描仪都没有提供这些功能。它使用SIGRTMAX-0实时信号和每个条形码设备的自定义计时器来读取条形码，因此您需要将其链接到librt（-lrt）：
#define _POSIX_C_SOURCE 200809L
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <signal.h>
#include <time.h>
#include <linux/input.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
/* Link against the rt library; -lrt. */
#define UNUSED __attribute__((unused))
#define TIMEOUT_SIGNAL (SIGRTMAX-0)
/*
* done - flag used to exit program at SIGINT, SIGTERM etc.
*/
volatile sig_atomic_t done = 0;
static void handle_done(int signum UNUSED)
{
done = 1;
}
int install_done(const int signum)
{
struct sigaction act;
sigemptyset(&act.sa_mask);
act.sa_handler = handle_done;
act.sa_flags = 0;
if (sigaction(signum, &act, NULL) == -1)
return errno;
return 0;
}
/*
* Barcode input event device, and associated timeout timer.
*/
typedef struct {
int fd;
volatile int timeout;
timer_t timer;
} barcode_dev;
static void handle_timeout(int signum UNUSED, siginfo_t *info, void *context UNUSED)
{
if (info && info->si_code == SI_TIMER && info->si_value.sival_ptr)
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)
__atomic_add_fetch((int *)info->si_value.sival_ptr, 1, __ATOMIC_SEQ_CST);
#else
__sync_add_and_fetch((int *)info->si_value.sival_ptr, 1);
#endif
}
static int install_timeouts(void)
{
static int installed = 0;
if (!installed) {
struct sigaction act;
sigemptyset(&act.sa_mask);
act.sa_sigaction = handle_timeout;
act.sa_flags = SA_SIGINFO;
if (sigaction(TIMEOUT_SIGNAL, &act, NULL) == -1)
return errno;
installed = 1;
}
return 0;
}
int barcode_close(barcode_dev *const dev)
{
int retval = 0;
if (!dev)
return 0;
if (dev->fd != -1)
if (close(dev->fd) == -1)
retval = errno;
dev->fd = -1;
if (dev->timer)
if (timer_delete(dev->timer) == -1)
if (!retval)
retval = errno;
dev->timer = (timer_t)0;
/* Handle all pending TIMEOUT_SIGNALs */
while (1) {
struct timespec t;
siginfo_t info;
sigset_t s;
t.tv_sec = (time_t)0;
t.tv_nsec = 0L;
sigemptyset(&s);
if (sigtimedwait(&s, &info, &t) != TIMEOUT_SIGNAL)
break;
if (info.si_code != SI_TIMER || !info.si_value.sival_ptr)
continue;
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)
__atomic_add_fetch((int *)info.si_value.sival_ptr, 1, __ATOMIC_SEQ_CST);
#else
__sync_add_and_fetch((int *)info.si_value.sival_ptr, 1);
#endif
}
return errno = retval;
}
int barcode_open(barcode_dev *const dev, const char *const device_path)
{
struct sigevent event;
int fd;
if (!dev)
return errno = EINVAL;
dev->fd = -1;
dev->timeout = -1;
dev->timer = (timer_t)0;
if (!device_path || !*device_path)
return errno = EINVAL;
if (install_timeouts())
return errno;
do {
fd = open(device_path, O_RDONLY | O_NOCTTY | O_CLOEXEC);
} while (fd == -1 && errno == EINTR);
if (fd == -1)
return errno;
errno = 0;
if (ioctl(fd, EVIOCGRAB, 1)) {
const int saved_errno = errno;
close(fd);
return errno = (saved_errno) ? errno : EACCES;
}
dev->fd = fd;
memset(&event, 0, sizeof event);
event.sigev_notify = SIGEV_SIGNAL;
event.sigev_signo = TIMEOUT_SIGNAL;
event.sigev_value.sival_ptr = (void *)&(dev->timeout);
if (timer_create(CLOCK_REALTIME, &event, &dev->timer) == -1) {
const int saved_errno = errno;
close(fd);
return errno = (saved_errno) ? errno : EMFILE;
}
return errno = 0;
}
size_t barcode_read(barcode_dev *const dev,
char *const buffer, const size_t length,
const unsigned long maximum_ms)
{
struct itimerspec it;
size_t len = 0;
int status = ETIMEDOUT;
if (!dev || !buffer || length < 2 || maximum_ms < 1UL) {
errno = EINVAL;
return (size_t)0;
}
/* Initial timeout. */
it.it_value.tv_sec = maximum_ms / 1000UL;
it.it_value.tv_nsec = (maximum_ms % 1000UL) * 1000000L;
/* After elapsing, fire every 10 ms. */
it.it_interval.tv_sec = 0;
it.it_interval.tv_nsec = 10000000L;
if (timer_settime(dev->timer, 0, &it, NULL) == -1)
return (size_t)0;
/* Because of the repeated elapsing, it is safe to
* clear the timeout flag here. */
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR >= 7)
__atomic_store_n((int *)&(dev->timeout), 0, __ATOMIC_SEQ_CST);
#else
__sync_fetch_and_and((int *)&(dev->timeout), 0);
#endif
while (!dev->timeout) {
struct input_event ev;
ssize_t n;
int digit;
n = read(dev->fd, &ev, sizeof ev);
if (n == (ssize_t)-1) {
if (errno == EINTR)
continue;
status = errno;
break;
} else
if (n == sizeof ev) {
/* We consider only key presses and autorepeats. */
if (ev.type != EV_KEY || (ev.value != 1 && ev.value != 2))
continue;
switch (ev.code) {
case KEY_0: digit = '0'; break;
case KEY_1: digit = '1'; break;
case KEY_2: digit = '2'; break;
case KEY_3: digit = '3'; break;
case KEY_4: digit = '4'; break;
case KEY_5: digit = '5'; break;
case KEY_6: digit = '6'; break;
case KEY_7: digit = '7'; break;
case KEY_8: digit = '8'; break;
case KEY_9: digit = '9'; break;
default: digit = '\0';
}
/* Non-digit key ends the code, except at beginning of code. */
if (digit == '\0') {
if (!len)
continue;
status = 0;
break;
}
if (len < length)
buffer[len] = digit;
len++;
continue;
} else
if (n == (ssize_t)0) {
status = ENOENT;
break;
} else {
status = EIO;
break;
}
}
/* Add terminator character to buffer. */
if (len + 1 < length)
buffer[len + 1] = '\0';
else
buffer[length - 1] = '\0';
/* Cancel timeout. */
it.it_value.tv_sec = 0;
it.it_value.tv_nsec = 0;
it.it_interval.tv_sec = 0;
it.it_interval.tv_nsec = 0L;
(void)timer_settime(dev->timer, 0, &it, NULL);
errno = status;
return len;
}
这是一个示例程序example.c。您提供输入事件设备（我建议使用符号链接，/dev/input/by-id/或者/dev/input/by- path/如果您udev提供了符号链接，因为事件设备索引在内核版本和硬件启动之间可能不稳定），以及您愿意等待/直到下一个条形码的最大持续时间。
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <stdio.h>
#include <errno.h>
#include "barcode.h"
#define BARCODE_MAXLEN 1023
int main(int argc, char *argv[])
{
barcode_dev dev;
unsigned long ms;
int status, exitcode;
if (argc != 3 || !strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
fprintf(stderr, "\n");
fprintf(stderr, "Usage: %s [ -h | --help ]\n", argv[0]);
fprintf(stderr, " %s INPUT-EVENT-DEVICE IDLE-TIMEOUT\n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, "This program reads barcodes from INPUT-EVENT-DEVICE,\n");
fprintf(stderr, "waiting at most IDLE-TIMEOUT seconds for a new barcode.\n");
fprintf(stderr, "The INPUT-EVENT-DEVICE is grabbed, the digits do not appear as\n");
fprintf(stderr, "inputs in the machine.\n");
fprintf(stderr, "You can at any time end the program by sending it a\n");
fprintf(stderr, "SIGINT (Ctrl+C), SIGHUP, or SIGTERM signal.\n");
fprintf(stderr, "\n");
return EXIT_FAILURE;
}
if (install_done(SIGINT) ||
install_done(SIGHUP) ||
install_done(SIGTERM)) {
fprintf(stderr, "Cannot install signal handlers: %s.\n", strerror(errno));
return EXIT_FAILURE;
}
{
double value, check;
char dummy;
if (sscanf(argv[2], " %lf %c", &value, &dummy) != 1 || value < 0.001) {
fprintf(stderr, "%s: Invalid idle timeout value (in seconds).\n", argv[2]);
return EXIT_FAILURE;
}
ms = (unsigned long)(value * 1000.0);
check = (double)ms / 1000.0;
if (value < check - 0.001 || value > check + 0.001 || ms < 1UL) {
fprintf(stderr, "%s: Idle timeout is too long.\n", argv[2]);
return EXIT_FAILURE;
}
}
if (barcode_open(&dev, argv[1])) {
fprintf(stderr, "%s: Cannot open barcode input event device: %s.\n", argv[1], strerror(errno));
return EXIT_FAILURE;
}
while (1) {
char code[BARCODE_MAXLEN + 1];
size_t len;
if (done) {
status = EINTR;
break;
}
len = barcode_read(&dev, code, sizeof code, ms);
if (errno) {
status = errno;
break;
}
if (len < (size_t)1) {
status = ETIMEDOUT;
break;
}
printf("%zu-digit barcode: %s\n", len, code);
fflush(stdout);
}
if (status == EINTR) {
fprintf(stderr, "Signaled to exit. Complying.\n");
fflush(stderr);
exitcode = EXIT_SUCCESS;
} else
if (status == ETIMEDOUT) {
fprintf(stderr, "Timed out, no more barcodes.\n");
fflush(stderr);
exitcode = EXIT_SUCCESS;
} else {
fprintf(stderr, "Error reading input event device %s: %s.\n", argv[1], strerror(status));
fflush(stderr);
exitcode = EXIT_FAILURE;
}
if (barcode_close(&dev)) {
fprintf(stderr, "Warning: Error closing input event device %s: %s.\n", argv[1], strerror(errno));
fflush(stderr);
exitcode = EXIT_FAILURE;
}
return exitcode;
}
如您所见，它只是将条形码打印到标准输出（以及任何对标准错误的错误消息和警告）。要进行编译，我建议使用以下命令Makefile（缩进必须使用Tab，而不是空格）：
CC := gcc
CFLAGS := -Wall -Wextra -O2
LDFLAGS := -lrt
.PHONY: all clean
all: clean example
clean:
rm -f example *.o
%.o: %.c
$(CC) $(CFLAGS) -c $^
example: example.o barcode.o
$(CC) $(CFLAGS) $^ $(LDFLAGS) -o example
要进行编译，请创建上面列出的四个文件，然后运行
make clean example
例如运行
./example /dev/input/event4 5.0
将从中读取条形码/dev/input/event4，但会在Ctrl+
C（INT信号），HUP信号，TERM信号处退出，或者在5秒钟内没有条形码出现时退出。
请注意，如果在5秒钟之内只读取了部分条形码，我们确实会得到该部分（可以尝试读取其余部分），但是上面的示例程序将忽略该部分，仅显示超时。
有什么问题吗
-
我有一个物理条形码扫描仪插入我的设备，我试图使用它扫描条形码太小，相机无法聚焦。 在我的活动中，这些是我用来检查按键的2个函数，因为我假设它是作为硬件键盘处理的。 什么能让它通过？ 提前致谢
-
这是我在这里的第一个问题，所以我将尽可能与你相关。我对使用云视觉处理一些文档感兴趣，因为我需要OCR功能。我还碰巧需要读取条形码，我目前已经使用ZXing实现了这一点。 我在OCR中偶然发现了条形码块类型（https://cloud.google.com/vision/docs/reference/rest/v1/images/annotate#BlockType）但我没有成功地制作出这样一个块，
-
我正在构建一个基本的价格检查应用程序，可以扫描条形码并显示产品信息，并试图在内置条形码扫描仪的Android平板电脑上运行它。 扫描仪可以工作，如果我把一个文本框放在应用程序上并对其进行聚焦，我扫描的条形码就会写在上面--然而，如果应用程序不对文本框进行聚焦，我就无法捕捉输入（应用程序应该没有输入区域，只有图像和文本视图标签）。 我查看了重写KeyUp和KeyDown事件，但它们似乎是为捕获单个键
-
我需要阅读申请的条形码。我正在使用触发器条形码扫描仪。通讯是通过USB。 如你所知，条形码扫描仪的工作方式就像键盘一样。当设备读取条形码时，它试图将该值写入具有焦点的输入。用户按下触发器，条形码扫描器工作，直到条形码读取成功。然后它就会进入待机模式。理想的方式读取大量条形码。 在xml端添加了上面的行。 它检测EditText何时失去焦点。但我不能把它分配回来。我确保EditText在触摸模式下是
-
问题内容： 如果我有一些代码，例如 并且输入文件包含成对的行，我该如何做，以便仅导入每行的第一行？因此，换句话说，每条奇数行都只有？谢谢 问题答案： 您可能想考虑使用来简化奇数行（）的过滤。或者在另一种方法中，如果您使用的是JDK7，则可以使用该方法，并在迭代时再次过滤奇数。
-
//1.我正在尝试使用ZXingScannerView扫描器传递条形码值 //2。那么如果扫描的条形码等于recyclerview中的JSON//文件中的JSON条形码对象show item_name和cost,我的问题是扫描后没有显示任何东西 @override公共视图onCreateView（LayoutInflater inflater,ViewGroup container,Bundle