精华内容
下载资源
问答
  • 使用JS实时读取USB串口扫码枪数据,运行环境:龙芯+中标麒麟系统+火狐浏览器 NPAPI插件使用方法: HTML: <object id="plugin" type="application/htkyzplugin" width="0" height="0"></object> JS: ...
  • labview通过串口读取扫码枪扫码内容
  • labview通过串口读取扫码枪扫码内容
  • C# 扫码枪代码 包括USB和串口两种连接方式的集成和测试窗口
  • 基恩士SR-2000系列扫码枪使用说明书
  • Win7,VS2017,VB.net +Newland新大陆 USB扫码枪,测试并编译通过-->OK, USB-Hook钩子线程法、虚拟串口(串口)两种方式均测试OK,可扫带字母一维码、可扫带字母一维码、可扫带字母一维码重要内容三遍!!!。
  • 串口自动扫码枪demo,源码+测试工具,百分百成功
  • 在龙芯+中标系统中的浏览器插件,读取USB CDC串口扫码枪数据,使用C++开发的NPAIP插件
  • USB虚拟串口驱动程序,适用型号: 1300、1400、 1450、 1452、 1470、 1472、 1602、 1900、 1902、 1910i、 1911i、 1920i、1950、1952、 1980i、 1981i、3310、3320、 3800、3820、3820i、4800i、7120plus、7190、 ...
  • 霍尼韦尔1900 扫码枪 usb serial转串口驱动 ,根据电脑运行环境点击Install_x64.bat或Install_x86.bat
  • VS2015 串口扫码枪扫描二维码后从Access数据库读取相应信息并显示出来
  • 基恩士扫码枪说明书

    2019-01-26 13:15:43
    基恩士扫码枪sw-1000的说明书,安装、调整、通信、测试
  • MCGS:工业触摸屏读取USB串口扫描条码;
  • 博客讲解样例demo,欢迎下载!https://blog.csdn.net/luoqiang_sky/article/details/90676944
  • C# 串口编程,扫码枪使用

    千次阅读 2019-05-06 23:10:00
    一、串口通信简介 串行接口(串口)是一种可以将接受来自CPU的并行数据字符转换为连续的串行数据流发送出去,同时可将接受的串行数据流转换...尽管比按字节(byte)的并行通信慢,但是串口可以在使用一根线发送数据...

     

    一、串口通信简介

    串行接口(串口)是一种可以将接受来自CPU的并行数据字符转换为连续的串行数据流发送出去,同时可将接受的串行数据流转换为并行的数据字符供给CPU的器件。一般完成这种功能的电路,我们称为串行接口电路。

    串口通信(Serial Communications)的概念非常简单,串口按位(bit)发送和接收字节。尽管比按字节(byte)的并行通信慢,但是串口可以在使用一根线发送数据的同时用另一根线接收数据。串口通信最重要的参数是波特率、数据位、停止位和奇偶校验。对于两个进行通信的端口,这些参数必须匹配。

      1. 波特率:这是一个衡量符号传输速率的参数。指的是信号被调制以后在单位时间内的变化,即单位时间内载波参数变化的次数,如每秒钟传送960个字符,而每个字符格式包含10位(1个起始位,1个停止位,8个数据位),这时的波特率为960Bd,比特率为10位*960个/秒=9600bps。

      2. 数据位:这是衡量通信中实际数据位的参数。当计算机发送一个信息包,实际的数据往往不会是8位的,标准的值是6、7和8位。标准的ASCII码是0~127(7位),扩展的ASCII码是0~255(8位)。

      3. 停止位:用于表示单个包的最后几位。典型的值为1,1.5和2位。由于数据是在传输线上定时的,并且每一个设备有其自己的时钟,很可能在通信中两台设备间出现了小小的不同步。因此停止位不仅仅是表示传输的结束,并且提供计算机校正时钟同步的机会。

      4. 校验位:在串口通信中一种简单的检错方式。有四种检错方式:偶、奇、高和低。当然没有校验位也是可以的。

    二、C#串口编程类

    从.NET Framework 2.0开始,C#提供了SerialPort类用于实现串口控制。命名空间:System.IO.Ports。其中详细成员介绍参看MSDN文档。下面介绍其常用的字段、方法和事件。

      1. 常用字段:

    名称说明
    PortName获取或设置通信端口
    BaudRate获取或设置串行波特率
    DataBits获取或设置每个字节的标准数据位长度
    Parity获取或设置奇偶校验检查协议
    StopBits获取或设置每个字节的标准停止位数

     

     

     

     

     

     

    2. 常用方法:

    名称说明
    Close关闭端口连接,将 IsOpen 属性设置为 false,并释放内部 Stream 对象
    GetPortNames获取当前计算机的串行端口名称数组
    Open打开一个新的串行端口连接
    Read从 SerialPort 输入缓冲区中读取
    Write 将数据写入串行端口输出缓冲区

     

     

     

     

     

     

    3. 常用事件:

    名称说明
    DataReceived表示将处理 SerialPort 对象的数据接收事件的方法

     

     

     

    三、实现方法,本地计算机使用虚拟串口软件

    1、下载virtual serial port driver 虚拟软件,添加一对串口

    添加以后设备管理就会生成串口设备

     

    2、下载串口调试助手2.2,他会自动读取刚才生成的串口

     

     

    我这里使用com2串口发送数据,com1接收数据

     

    3、c#代码,设置窗口名称,这个是固定的

    serialPort1.PortName = comName;
    serialPort1.Open();

     

    4、获取com2发送过来的数据,com1接收发送过来的数据

     

     

     

     以上就实现了串口通信

     

    转载于:https://www.cnblogs.com/topguntopgun/p/10822852.html

    展开全文
  • 扫码枪扫描二维码,具体内容如下所示: 业务需求要将数据生成二维码,并用扫码枪扫出数据上传到服务端。 先上代码吧,之后再完善注意点 this.start = new Date().getTime() let code = '' let lastTime, nextTime...
  • 关于串口扫码枪通信问题 代码实现 //打开扫码枪代码 byte[] bt = new byte[3]; bt[0] = 0x31; bt[1] = 0x32; bt[2] = 0x0d; //关闭扫码枪代码 byte[] btc = new byte[3]; btc[0] = 0x31; btc[1] = 0x33;

    关于串口扫码枪通信问题

    利用串口助手进行调试

    代码实现

    //打开扫码枪代码
                byte[] bt = new byte[3];
                bt[0] = 0x31;
                bt[1] = 0x32;
                bt[2] = 0x0d;
    //关闭扫码枪代码
                byte[] btc = new byte[3];
                btc[0] = 0x31;
                btc[1] = 0x33;
                btc[2] = 0x0d;
    
    
    展开全文
  • 包括基恩士扫码枪使用手册、附C++代码实现网络通讯,通过网口与扫码枪通讯获取字符串。
  • 笔者最近接到了这样一个需求,需要对接扫码枪并获取扫码枪扫出来的值; 2.实现思路 2.1.构思 使用生产者消费者模式作为整体架构设计,生产者持续监听输入直到生成一个链接,然后将该链接放入一个阻塞队列中,消费者...

    1.前言

    笔者最近接到了这样一个需求,需要对接扫码枪并获取扫码枪扫出来的值;

    2.实现思路

    2.1.构思

    使用生产者消费者模式作为整体架构设计,生产者持续监听输入直到生成一个链接,然后将该链接放入一个阻塞队列中,消费者会不断从该阻塞队列中消费产品,若队列为空,则阻塞直至消费到产品;

    2.1.持续读取键盘缓冲区

    2.1.1.原理

    扫码枪默认模式是会将扫出来的值输出到键盘缓冲区中,这样就可以直接在文本框上打出来;
    通过观察得知,

    1. 计算机对于每一个字符并不是按照ASCII规则,而是按照其内部自定义的编码输出,因此需要对每一个字符进行转换,准换成标准ASCII;
    2. 计算机使用SHIFT区分大小写以及其他字符如 ",:,+,这类字符同大写一样,需要先按住SHIFT,因此可通过这个方式区分字符
      是否有经过SHIFT转义,且键盘中输出的字符默认全为大写;
    2.1.2.具体实现 (Java)
    //字符转换
    
    //若前一个字符是SHIFT,则需要转换
        private void initWithShiftCharacter() {
            particularKeyToLetterWithShift.put(192, '~');
            particularKeyToLetterWithShift.put(49, '!');
            particularKeyToLetterWithShift.put(50, '@');
            particularKeyToLetterWithShift.put(51, '#');
            particularKeyToLetterWithShift.put(52, '$');
            particularKeyToLetterWithShift.put(53, '%');
            particularKeyToLetterWithShift.put(54, '^');
            particularKeyToLetterWithShift.put(55, '&');
            particularKeyToLetterWithShift.put(56, '*');
            particularKeyToLetterWithShift.put(57, '(');
            particularKeyToLetterWithShift.put(48, ')');
            particularKeyToLetterWithShift.put(189, '_');
            particularKeyToLetterWithShift.put(187, '+');
            particularKeyToLetterWithShift.put(219, '{');
            particularKeyToLetterWithShift.put(221, '}');
            particularKeyToLetterWithShift.put(220, '|');
            particularKeyToLetterWithShift.put(186, ':');
            particularKeyToLetterWithShift.put(222, '"');
            particularKeyToLetterWithShift.put(188, '<');
            particularKeyToLetterWithShift.put(190, '>');
            particularKeyToLetterWithShift.put(191, '?');
        }
    
    //若前一个字符不是SHIFT,则无需转换
        private void initWithoutShiftCharacter() {
            particularKeyToLetterWithoutShift.put(189, '-');// - ok
            particularKeyToLetterWithoutShift.put(187, '=');
            particularKeyToLetterWithoutShift.put(219, '[');//{ ok
            particularKeyToLetterWithoutShift.put(221, ']');
            particularKeyToLetterWithoutShift.put(220, '\\');// \ ok
            particularKeyToLetterWithoutShift.put(186, ';');//: ok
            particularKeyToLetterWithoutShift.put(222, '\'');
            particularKeyToLetterWithoutShift.put(188, ',');
            particularKeyToLetterWithoutShift.put(190, '.');
            particularKeyToLetterWithoutShift.put(191, '/');
            particularKeyToLetterWithoutShift.put(107, '+');
            particularKeyToLetterWithoutShift.put(109, '-');
            particularKeyToLetterWithoutShift.put(106, '*');
            particularKeyToLetterWithoutShift.put(111, '/');
            particularKeyToLetterWithoutShift.put(110, '.');
            particularKeyToLetterWithoutShift.put((int) '\u008D', '-');
        }
    
    
    //开启服务
    private void startService() throws InterruptedException {
            logger.info("Barcode producer启动成功");
            BarcodeKeyboardListenerProducer listener = new BarcodeKeyboardListenerProducer();
            WinUser.LowLevelKeyboardProc lowLevelKeyboardProc = new WinUser.LowLevelKeyboardProc() {
                @Override
                public WinDef.LRESULT callback(int nCode, WinDef.WPARAM wparam, WinUser.KBDLLHOOKSTRUCT hook) {
                    if (nCode >= 0 && wparam.intValue() == WinUser.WM_KEYUP) {
                        int keyCode = hook.vkCode;
                        listener.onKey(keyCode);
                    }
                    return lib.CallNextHookEx(hhook, nCode, wparam, new WinDef.LPARAM(Pointer.nativeValue(hook.getPointer())));
                }
            };
            WinDef.HMODULE hmodule = Kernel32.INSTANCE.GetModuleHandle(null);
            hhook = lib.SetWindowsHookEx(WinUser.WH_KEYBOARD_LL, lowLevelKeyboardProc, hmodule, 0);
            WinUser.MSG msg = new WinUser.MSG();
            int result;
            while ((result = lib.GetMessage(msg, null, 0, 0)) != 0) {
                if (result == -1) {
                    logger.error("quit ,error in get message: " + result);
                    break;
                } else {
                    lib.TranslateMessage(msg);
                    lib.DispatchMessage(msg);
                }
            }
    
        }
    
    //监听键盘缓冲区的每一个字符
     // 160 = SHIFT
        //此处判断识别的为可显示的字符
        public void onKey(int keyCode) {
    //        logger.info(keyCode+" "+(char)keyCode);
            if (keyCode == SHIFT_VALUE) {
                IS_SHIFT = true;
                return;
            }
            if (barcode == null) {
                IS_SHIFT = false;
                barcode = new StringBuilder();
                start = System.currentTimeMillis();
            }
            long cost = System.currentTimeMillis() - start;
            if (cost > maxScanTime) {
                IS_SHIFT = false;
                barcode = new StringBuilder();
                start = System.currentTimeMillis();
            }
            if (isNumber(keyCode) && !IS_SHIFT) {
    //            logger.info("number:" + keyCode + " " + (char) keyCode);
            } else if (isUpperLetter(keyCode)) {
    //            logger.info("alpha:" + keyCode + " " + (char) keyCode);
                //默认字母小写
                keyCode = keyCode + 32;
                if (IS_SHIFT) {
                    keyCode = keyCode - 32;
                }
            } else if (keyCode != CODE_ENTER) {
    //            logger.info("other:" + keyCode + " " + (char) keyCode);
                keyCode = handleParticularCharacter(IS_SHIFT, keyCode);
            } else {
                //最终结果
                if (barcode.length() > barcodeMinLength && cost < maxScanTime) {
                    BarcodeBuffer.produce(barcode.toString());
                }
                barcode = new StringBuilder();
                return;
            }
            barcode.append((char) keyCode);
            //默认全部字符都是大写
            IS_SHIFT = false;
    //        logger.info(keyCode+" "+(char)keyCode);
        }
    
    
    2.1.3.具体实现 (Go)
    //字符转换
    func initWithoutShiftCharacter() {
    	particularKeyToLetterWithoutShift = make(map[uint32]uint32)
    	particularKeyToLetterWithoutShift[189] = '-' // - ok
    	particularKeyToLetterWithoutShift[187] = '='
    	particularKeyToLetterWithoutShift[219] = '[' //{ ok
    	particularKeyToLetterWithoutShift[221] = ']'
    	particularKeyToLetterWithoutShift[220] = '\\' // \ ok
    	particularKeyToLetterWithoutShift[186] = ';'  //: ok
    	particularKeyToLetterWithoutShift[222] = '\''
    	particularKeyToLetterWithoutShift[188] = ','
    	particularKeyToLetterWithoutShift[190] = '.'
    	particularKeyToLetterWithoutShift[191] = '/'
    	particularKeyToLetterWithoutShift[107] = '+'
    	particularKeyToLetterWithoutShift[109] = '-'
    	particularKeyToLetterWithoutShift[106] = '*'
    	particularKeyToLetterWithoutShift[111] = '/'
    	particularKeyToLetterWithoutShift[110] = '.'
    	//particularKeyToLetterWithoutShift[uint32('\u08D')] = '-'
    }
    
    func initWithShiftCharacter() {
    	particularKeyToLetterWithShift = make(map[uint32]uint32)
    	particularKeyToLetterWithShift[48] = ')'
    	particularKeyToLetterWithShift[49] = '!'
    	particularKeyToLetterWithShift[50] = '@'
    	particularKeyToLetterWithShift[51] = '#'
    	particularKeyToLetterWithShift[52] = '$'
    	particularKeyToLetterWithShift[53] = '%'
    	particularKeyToLetterWithShift[54] = '^'
    	particularKeyToLetterWithShift[55] = '&'
    	particularKeyToLetterWithShift[56] = '*'
    	particularKeyToLetterWithShift[57] = '('
    	particularKeyToLetterWithShift[189] = '_'
    	particularKeyToLetterWithShift[187] = '+'
    	particularKeyToLetterWithShift[219] = '{'
    	particularKeyToLetterWithShift[221] = '}'
    	particularKeyToLetterWithShift[220] = '|'
    	particularKeyToLetterWithShift[186] = ':'
    	particularKeyToLetterWithShift[222] = '"'
    	particularKeyToLetterWithShift[188] = '<'
    	particularKeyToLetterWithShift[190] = '>'
    	particularKeyToLetterWithShift[191] = '?'
    }
    
    
    //开启监听键盘缓冲区服务
    func StartProviderService() error {
    	log.Println("[INFO]start barcode provider service")
    	QuitProvider = false
    	if err := keyboard.Install(nil, KeyBoardChan); err != nil {
    		return err
    	}
    	defer keyboard.Uninstall()
    	signalChan := make(chan os.Signal, 1)
    	signal.Notify(signalChan, os.Interrupt)
    	for !QuitProvider {
    		select {
    		case <-signalChan:
    			log.Println("[INFO]stop barcode provider service~")
    			return nil
    		case k := <-KeyBoardChan:
    			if k.Message == types.WM_KEYDOWN {
    				handle(k.VKCode)
    			}
    			continue
    		}
    	}
    	log.Println("[INFO] stop barcode provider service=")
    	return nil
    }
    
    
    //监听每一个字符
    func handle(code types.VKCode) {
    	if code == types.VK_SHIFT || code == types.VK_LSHIFT || code == types.VK_RSHIFT {
    		IsShift = true
    		return
    	}
    	if barcode.Len() == 0 {
    		start = time.Now().UnixMilli()
    	}
    	cost := time.Now().UnixMilli() - start
    
    	if cost > maxScanTime {
    		IsShift = false
    		barcode = bytes.Buffer{}
    		start = time.Now().UnixMilli()
    	}
    	c := uint32(code)
    	if isNumber(c) && !IsShift {
    
    	} else if isUpperLetter(c) {
    		c = c + 32
    		if IsShift {
    			c = c - 32
    		}
    	} else if code != types.VK_RETURN {
    		c = handleParticularCharacter(c)
    	} else {
    		if barcode.Len() > barcodeMinLength && cost < maxScanTime {
    			//	fmt.Println(barcode.String())
    			Provide(barcode.String())
    		}
    		barcode = bytes.Buffer{}
    		return
    	}
    	e := recover()
    	if e != nil {
    		log.Println("Erorr transfer key->", c)
    	}
    	//	fmt.Println(barcode.String())
    	barcode.WriteByte(byte(c))
    	IsShift = false
    }
    
    
    2.1.4.不足之处

    通过大量测试,发现使用键盘缓冲区的方式会有卡顿现象,即如果我们将光标聚焦于文本处,那输出的字符会很顺畅,程序正常运行;但当我们不将光标放在文本或输入框中,发现监听的字符会产生混乱,因此效果不尽人意,因此舍弃该种思路;

    2.2.读取串口

    通过仔细阅读扫码枪说明书,发现其可以变成串口模式,即使用串口的方式,扫码枪会将解析出来的字符串输出到串口中,此时我们读取该串口中的内容即可;

    2.2.1.具体实现
    //开启服务,将串口读取方式变为阻塞读模式,即未读到值则一致阻塞;
    var S *serial.Port
    var c = &serial.Config{Name: COM, Baud: 9600 /*毫秒*/}
    var tmpS *serial.Port
    func StartProviderService() error {
    	//如果provider已经开启了,就不用再开了
    	if IsRunningProvider {
    		return nil
    	}
    	//若未开启
    	if S==nil{
    		S, _ = serial.OpenPort(c)
    	}
    	logs.Info("start Barcode provider service")
    	QuitProvider = false
    	IsRunningProvider = true
    	signalChan := make(chan os.Signal, 1)
    	signal.Notify(signalChan, os.Interrupt)
    	//该bonux的意义是因为经过测试发现若扫描二维码,会出现分2次获取值的情况,即若读取的值为 http://www.bilibili.com
    	//则第一次获得的值为h
    	//第二次获取的值为 ttp://bilibili.com
    	//因此需要手动拼接
    	bonux := ""
    	for true {
    		select {
    		case <-signalChan:
    			logs.Info("stop Barcode provider service~")
    			return nil
    		default:
    			b := make([]byte, 300)
    			S.Read(b)
    			if QuitProvider {
    				continue
    			}
    			Barcode = trimBytes(b)
    			if len(Barcode) <= 1 {
    				bonux = Barcode
    				continue
    			}
    			Barcode = strings.TrimSpace(bonux + Barcode)
    			Provide(Barcode)
    			Barcode = ""
    			bonux = ""
    		}
    	}
    	logs.Info("stop Barcode provider service=")
    	return nil
    }
    

    2.2.2.不足之处

    仅测试,大部分电脑都可以正常安装扫码枪的驱动,但有那么几台win7的系统竟然安装不上扫码枪的驱动,这就意味着要么可能需要手写驱动,获取扫码枪的输入…

    展开全文
  • DemoHQTvm_串口扫码是指_扫码枪源码_扫码枪_自助扫码枪_DEMO_源码.zip
  • DemoHQTvm_串口扫码是指_扫码枪源码_扫码枪_自助扫码枪_DEMO_源码.rar
  • 基于TCP通讯,连接基恩士扫码枪,发送指令触发扫码,增加异步重连机制,demo及源码都经过本人测试,程序可直接运行
  • 串口助手,可实现与扫码枪的通讯,亲测可用。 没有病毒 只要是TCP、IP协议都可以用他来进行沟通。
  • 引用串口类:System.IO.Ports.SerialPort 直接贴代码: ... /// 串口 扫描 /// public class ScanProvider { private SerialPort _serialPort; public ScanProvider(string portName, int b

    引用串口类:System.IO.Ports.SerialPort

    直接贴代码:

      /// <summary>
        /// 串口 扫描枪
        /// </summary>
        public class ScanProvider
        {
            private SerialPort _serialPort;
    
            public ScanProvider(string portName, int baudRate)
            {
                _serialPort = new SerialPort();
                this.RegisterSerialPort(portName, baudRate);
                _serialPort.DataReceived +=_serialPort_DataReceived;
            }
    
            #region Private Methods
    
            /// <summary>
            /// 注册串口
            /// </summary>
            /// <param name="portName">串口名</param>
            /// <param name="baudRate">波特率</param>
            private void RegisterSerialPort(string portName, int baudRate)
            {
                // 串口名
                _serialPort.PortName = portName;
                // 波特率
                _serialPort.BaudRate = baudRate;
                // 数据位
                _serialPort.DataBits = 8;
                // 停止位
                _serialPort.StopBits = System.IO.Ports.StopBits.One;
                // 无奇偶校验位
                _serialPort.Parity = System.IO.Ports.Parity.None;
            }
    
            #endregion
    
            #region Public 
    
            /// <summary>
            /// 是否处于打开状态
            /// </summary>
            public bool IsOpen
            {
                get
                {
                    return _serialPort != null && _serialPort.IsOpen;
                }
            }
    
            /// <summary>
            /// 打开串口
            /// </summary>
            /// <returns></returns>
            public bool Open()
            {
                if (_serialPort == null)
                    return this.IsOpen;
    
                if (_serialPort.IsOpen)
                    this.Close();
    
                _serialPort.Open();
    
                return this.IsOpen;
            }
    
            /// <summary>
            /// 关闭串口
            /// </summary>
            public void Close()
            {
                if (this.IsOpen)
                    _serialPort.Close();
            }
    
            /// <summary>
            /// 向串口内写入
            /// </summary>
            /// <param name="send">写入数据</param>
            /// <param name="offSet">偏移量</param>
            /// <param name="count">写入数量</param>
            public void Write(byte[] send, int offSet, int count)
            {
                if (this.IsOpen)
                {
                    _serialPort.Write(send, offSet, count);
                }
            }
    
            public void Dispose()
            {
                if (this._serialPort == null)
                    return;
                if (this._serialPort.IsOpen)
                    this.Close();
                this._serialPort.Dispose();
                this._serialPort = null;
            }
    
            #endregion
    
            void _serialPort_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
            {
                // 等待100ms,防止读取不全的情况
                Thread.Sleep(100);
                byte[] m_recvBytes = new byte[_serialPort.BytesToRead];//定义缓冲区大小
                int result = _serialPort.Read(m_recvBytes, 0, m_recvBytes.Length);//从串口读取数据
                if (result <= 0)
                    return;
                string strResult = Encoding.ASCII.GetString(m_recvBytes, 0, m_recvBytes.Length);//对数据进行转换
                _serialPort.DiscardInBuffer();
    
                if (this.DataReceived != null)
                    this.DataReceived(this, new SerialSortEventArgs() { Code = strResult });
            }
    
            public event EventHandler<SerialSortEventArgs> DataReceived;
    
            #region Static
    
            /// <summary>
            /// 获取可用串口名称
            /// </summary>
            /// <returns></returns>
            public static string[] GetComNames()
            {
                string[] names = null;
                try
                {
                    names = SerialPort.GetPortNames();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
                return names;
            }
    
            #endregion
        }
    
        public class SerialSortEventArgs
        {
            public string Code { get; set; }
        }

    应用:

        public partial class MainWindow : Window
        {
            ScanProvider _scanner;
    
            public MainWindow()
            {
                InitializeComponent();
                // 打开串口
                _scanner = new ScanProvider("COM1", 115200);
                // 打开串口
                if (_scanner.Open())
                    //关联事件处理程序
                    _scanner.DataReceived += _scanner_DataReceived;
            }
    
            void _scanner_DataReceived(object sender, SerialSortEventArgs e)
            {
                this.Dispatcher.BeginInvoke(new Action<string>((args) =>
                    {
                        this.txtIDCard.Text = args;
                    }), e.Code);
            }
        }

    其中波特率根据具体的扫码枪设定。

    我的扫码枪型号:ScanHome ST2200 。



    展开全文
  • 目前经过百度搜索的资料经过测试都不稳定,这是找到的最稳定有效的版本。代码易懂,方便修改。
  • 一个扫码枪遵循TCP协议,通过改代码即可获取扫码枪所扫描的信息;(有一个串口服务器); using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Net; using ...
  • 条码检测程序(VISA串口通讯扫码枪与PLC),扫码枪为呈现模式(持续扫码,可自行改为指令触发模式),扫码成功后写入文件,如文件内有此条码则不写入。PLC需写几条简单的程序控制电器元件,刚写好的程序,请笑纳,小...
  • 我这里想请教一个问题,怎么才能让扫码枪远距离传输和通信 由于每台服务器使用8个扫枪,目前使用扫码枪使用串口RS232链接,通过使用USB转RS232接头得到8个COM端口,但是远距离传输上,信号比较弱,然后到网上...
  • 平时用的最多的扫描通常只是一个简单的输入设备(好比键盘,鼠标), 另一头需要连接电脑, 用的 usb 或者串口. 扫描负责识别条码, 电脑收到后执行业务的逻辑. 有时候只是简单的数据采集工作, 数据传到服务器云端, 放...
  • 得利捷扫码枪 4430 USBCOM 驱动,使用labview工具USB转虚拟串口

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 551
精华内容 220
关键字:

串口扫码枪使用