def _close(self):
dev = self._dev
release_interface(dev, self._intNum)
dispose_resources(dev)
self._dev = None
# release 'Endpoints' objects for prevent undeleted 'Device' resource
self._epOut = self._epIn = None
def __del__(self):
"""Cleanup a PtpUsbTransport structure."""
try:
release_interface(self.__device, self.__usb_interface)
del self.__usb_handle
except:
pass
def cleanup():
print "Cleaning up"
stop_warning()
interface = 0
# release the device
util.release_interface(device_handle, interface)
# reattach the device to the OS kernel
device_handle.attach_kernel_driver(interface)
def releaseInterface(self):
r"""Release an interface previously claimed with claimInterface."""
util.release_interface(self.dev, self.__claimed_interface)
self.__claimed_interface = -1
def barcodeReaderThreat(self):
# import required libraries for barcode scanner
if self.OnRaspberry:
from usb import core as usb_core
from usb import util as usb_util
else:
from Functions.GPIOEmulator.ShotmachineIOEmulator import usb_core_emu
usb_core = usb_core_emu()
# make usb connection to scanner
#if self.EnableBarcodeScanner:
self.device = usb_core.find(idVendor=self.barcode_vencor_id, idProduct=self.barcode_product_id)
self.usbEndpointEmu = namedtuple("usbEndpointEmu", "bEndpointAddress wMaxPacketSize")
try:
while self.run:
# on raspberry, find actual scanner
if self.OnRaspberry:
if self.device is None:
# No scanner found
self.logger.error("No barcode scanner found, is it connected and turned on?")
connected = False
break
else:
# Found scanner, give it some time to start
connected = True
time.sleep(5)
if connected:
# claim the device and it's interface
configuration = self.device.get_active_configuration()
if self.device.is_kernel_driver_active(0):
# fisrt detach scanner from os before it can be claimed
self.device.detach_kernel_driver(0)
endpoint = self.device[0][(1, 0)][0]
self.device.set_configuration()
self.logger.info("Barcode reader ready, start scanning")
else:
# Barcode scanner in emulator mode
self.logger.info("Barcode scanner in emulation mode")
connected = True
endpoint = self.usbEndpointEmu(bEndpointAddress = None, wMaxPacketSize=None)
while self.run and connected and self.OnRaspberry:
# check usb connection for messages and convert to barcode
try:
data = self.device.read(endpoint.bEndpointAddress, endpoint.wMaxPacketSize)
read_string = ''.join(chr(e) for e in data)
try:
read_number = int(read_string)
except:
read_number = None
if read_number != None:
self.logger.info("Barcode scanned: " + str(read_number))
self.ToMainQueue.put("Barcode:" + str(read_number))
except usb_core.USBError as e:
# error in checking messsages from scanner
data = None
if e.errno == 110:
# timeout, just keep checking
continue
if e.errno == 19:
# Connection lost, try to reconnect
self.logger.warning("Connection to barode scanner lost, closed connection if software")
connected = False
break
while self.run and connected and not self.OnRaspberry:
# Emulator barcode scanner
try:
data = self.device.read(endpoint.bEndpointAddress, endpoint.wMaxPacketSize)
read_string = ''.join(chr(e) for e in data)
try:
read_number = int(read_string)
except:
read_number = None
if read_number != None:
self.logger.info("Barcode scanned: " + str(read_number))
self.ToMainQueue.put("Barcode:" + str(read_number))
except Exception as e:
if str(e) == 'Timeout':
continue
else:
self.logger.error("Warning in barcode reader: " + e)
raise
finally:
# close connection to barcode scanner on closing
if connected and self.OnRaspberry:
usb_util.release_interface(self.device, 0)
self.logger.info("Closed barcode scanner reader")
def releaseInterface(self):
r"""Release an interface previously claimed with claimInterface."""
util.release_interface(self.dev, self.__claimed_interface)
self.__claimed_interface = -1
def closePort(ifc):
# Release interface
util.release_interface(dev, ifc)
# So, to workaround the problem I'm trying to save and restore the TLS state # between the prototype invocation. This works fine with one exception. As soon as # you close the last file descriptor associated with a USB device, the kernel automatically # resets the device, effectively killing the established TLS state. # # This script helps to work around this last problem. It keeps an open descriptor which # prevents kernel from resetting the device configuration. It does not interfere with # the main process and does not hold the claim on the inface. It just sits there # doing nothing until you decide to quit. # # The same can be achived by running something like "read 4</dev/bus/usb/001/011" from # a command line, but in this case you need to figure out what is the current bus/device # number yourself. import usb.core from usb.util import claim_interface, release_interface from time import sleep dev = usb.core.find(idVendor=0x138a, idProduct=0x0097) # make sure we at least opened device descriptor claim_interface(dev, 0) sleep(0.2) # release the iface, but keep the device open release_interface(dev, 0) # sit here, until the user press enter raw_input()
