def open(self, devicenum, portlist): """Open an FT232R device with devicenum and initialize with the portlist""" if self.handle is not None: self.close() if devicenum is None: self._log("Opening first available device...") devices = d2xx.listDevices() available_device = False for num, serial in enumerate(devices): try: h = d2xx.open(num) h.close() available_device = True break except: pass if available_device: devicenum = num if devicenum is not None: self.handle = d2xx.open(devicenum) if self.handle is not None: self._log("Opened device %i" % devicenum) self.devicenum = devicenum self.portlist = portlist self.serial = self.handle.getDeviceInfo()['serial'] self._setBaudRate(DEFAULT_FREQUENCY) self._setSyncMode() self._purgeBuffers() return True else: return False
def init(): deviceDescriptions = d2xx.listDevices(d2xx.OPEN_BY_DESCRIPTION) deviceSerials = d2xx.listDevices(d2xx.OPEN_BY_SERIAL_NUMBER) for i, description in enumerate(deviceDescriptions): serial = deviceSerials[i] if description[:6] != "monome" and description[:2] != "mk": print "ignoring non-monome device id " + str(i) + ": " + description + " [" + serial + "]" continue device = d2xx.open(i) print "opened device id " + str(i) + ": " + description + " [" + serial + "]" type = description[7:] grids = 0 prefix = "/" + type initOscCallbacks(prefix) deviceInfo = { "description": description, "serial": deviceSerials[i], "prefix": prefix, "type": type, "device": device, "cable": "left", "offsetX": 0, "offsetY": 0, "tiltmode": 0, "grids": 0, } if debugMode == 1: print deviceInfo devices.insert(i, deviceInfo) clearHandler(prefix, "i", (0,), 0) thread = MonomeThread(deviceInfo, oscClient) thread.start() deviceInfo["thread"] = thread
def __init__(self, master): """ Start the GUI and the asynchronous threads. We are in the main (original) thread of the application, which will later be used by the GUI. We spawn a new thread for the worker. """ try: d = d2xx.open(0) d.purge(0) d.purge(1) d.resetPort() d.close() except: print 'resetport' self.master = master # Create the queue self.queue = Queue.Queue() # Set up the thread to do asynchronous I/O # More can be made if necessary self.running = 1 self.thread1 = threading.Thread(target=self.workerThread1) self.thread1.start() # Set up the GUI part self.gui = GuiPart(master, self.queue, self.endApplication, self.send) # Start the periodic call in the GUI to check if the queue contains # anything self.periodicCall()
def init(): deviceDescriptions = d2xx.listDevices(d2xx.OPEN_BY_DESCRIPTION) deviceSerials = d2xx.listDevices(d2xx.OPEN_BY_SERIAL_NUMBER) for i, description in enumerate(deviceDescriptions): serial = deviceSerials[i] if description[:6] != "monome" and description[:2] != "mk": print "ignoring non-monome device id " + str( i) + ": " + description + " [" + serial + "]" continue device = d2xx.open(i) print "opened device id " + str( i) + ": " + description + " [" + serial + "]" type = description[7:] grids = 0 prefix = "/" + type initOscCallbacks(prefix) deviceInfo = { 'description': description, 'serial': deviceSerials[i], 'prefix': prefix, 'type': type, 'device': device, 'cable': "left", 'offsetX': 0, 'offsetY': 0, 'tiltmode': 0, 'grids': 0 } if debugMode == 1: print deviceInfo devices.insert(i, deviceInfo) clearHandler(prefix, 'i', (0, ), 0) thread = MonomeThread(deviceInfo, oscClient) thread.start() deviceInfo['thread'] = thread
def __init__(self,port): #List of FTDI Devices Available devAvail = d2xx.listDevices() if not devAvail: print("Error - Check your Connection to FTDI Device") else: self.port=d2xx.open(port) print("Connection to Port %d established"%port)
def autodetect(self, core): return #Disabled in favor of FTDIJTAG module try: found = False try: import usb for bus in usb.busses(): for dev in bus.devices: if dev.idVendor == 0x0403 and dev.idProduct == 0x6001: try: handle = dev.open() manufacturer = handle.getString( dev.iManufacturer, 100).decode("latin1") product = handle.getString( dev.iProduct, 100).decode("latin1") serial = handle.getString( dev.iSerialNumber, 100).decode("latin1") if (manufacturer == "FTDI" and product == "FT232R USB UART") or ( manufacturer == "FPGA Mining LLC" and product == "X6500 FPGA Miner"): try: configuration = dev.configurations[0] interface = configuration.interfaces[ 0][0] handle.setConfiguration( configuration.value) handle.claimInterface( interface.interfaceNumber) handle.releaseInterface() handle.setConfiguration(0) found = True break except: pass except: pass if found: break except: pass if not found: try: import d2xx devices = d2xx.listDevices() for devicenum, serial in enumerate(devices): try: handle = d2xx.open(devicenum) handle.close() found = True break except: pass except: pass if found: core.add_worker(self(core)) except: pass
def __init__(self,port): #List of FTDI Devices Available devAvail = d2xx.listDevices() if not devAvail: print("Error - Check your Connection to FTDI Device") else: self.port=d2xx.open(port) self.port.resetDevice() dataToRead=self.port.getQueueStatus() while dataToRead: dataRBuff=self.port.read(dataToRead) dataToRead=self.port.getQueueStatus() print("Connection to Port %d established"%port)
def __init__(self, deviceid): import d2xx self.handle = None self.serial = deviceid devices = d2xx.listDevices() for devicenum, serial in enumerate(devices): if deviceid != "" and deviceid != serial: continue try: self.handle = d2xx.open(devicenum) self.serial = serial break except: pass if self.handle == None: raise Exception("Can not open the specified device") self.handle.setBaudRate(3000000)
def __init__(self, interface): # Switching between USB and RS232C interfaces if interface == "USB": import d2xx self.ctrlif = d2xx.open(0) else: # Here, interface is expected to be like "COM1" # In this case, port number for pySecial should be 0 import serial portNum = int(interface[3:]) - 1 try: self.ctrlif = serial.Serial(port=portNum, baudrate=19200,timeout=1) except serial.serialutil.SerialException: import sys sys.exit("Cannot open port: " + interface) self.cipher_list = rev1_cipher_list self.addr_list = rev1_addr_list
def workerThread1(self): """ This is where we handle the asynchronous I/O. For example, it may be a 'select()'. One important thing to remember is that the thread has to yield control. """ time.sleep(1) # cheat the program to let UI finish loading try: self.d = d2xx.open(0) self.d.setBaudRate(115200) self.d.setTimeouts(1, 0) except: self.queue.put("exit") self.running = 0 return buffer = '' try: while self.running: time.sleep(0.01) b = self.d.read(1) # if b == '': # continue # if not (ord(b) == 13 or (ord(b) in range(48, 58)) or (ord(b) in range(65, 91))): # print b # continue if b != '' and b != '\r': buffer += b if b == '\r': print "Receive:", buffer, len(buffer) self.queue.put(buffer) buffer = '' except: print 'Closed', sys.exc_info()[0] self.d.close()
def autodetect(self, core): return #Disabled in favor of FTDIJTAG module try: found = False try: import usb for bus in usb.busses(): for dev in bus.devices: if dev.idVendor == 0x0403 and dev.idProduct == 0x6001: try: handle = dev.open() manufacturer = handle.getString(dev.iManufacturer, 100).decode("latin1") product = handle.getString(dev.iProduct, 100).decode("latin1") serial = handle.getString(dev.iSerialNumber, 100).decode("latin1") if (manufacturer == "FTDI" and product == "FT232R USB UART") or (manufacturer == "FPGA Mining LLC" and product == "X6500 FPGA Miner"): try: configuration = dev.configurations[0] interface = configuration.interfaces[0][0] handle.setConfiguration(configuration.value) handle.claimInterface(interface.interfaceNumber) handle.releaseInterface() handle.setConfiguration(0) found = True break except: pass except: pass if found: break except: pass if not found: try: import d2xx devices = d2xx.listDevices() for devicenum, serial in enumerate(devices): try: handle = d2xx.open(devicenum) handle.close() found = True break except: pass except: pass if found: core.add_worker(self(core)) except: pass
def __init__(self, interface="USB"): # Switching between USB and RS232C interfaces if interface == "USB": import d2xx self.ctrlif = d2xx.open(0) # setTimeouts(Read timeout, write timeout) self.ctrlif.setTimeouts(5000, 5000) else: # Here, interface is expected to be like "COM1" # In this case, port number for pySecial should be 0 import serial portNum = int(interface[3:]) - 1 try: # Default baud rate is 19200. self.ctrlif = serial.Serial(port=portNum, baudrate=115200,timeout=1) except serial.serialutil.SerialException: import sys sys.exit("Cannot open port: " + interface) self.cipher_list = rev1_cipher_list self.addr_list = rev1_addr_list
def _mGetHandle(self): d = d2xx.listDevices() comindex = -1 counter = 0 if d != 0: for j in d: try: hl = d2xx.open(counter) a = hl.getComPortNumber() a = 'COM' + str(a) if self.sComPort == a: return hl hl.close() except Exception as e: self.logger.debug( 'Exception communicating with FTDI device (%s)' % str(e)) else: counter += 1 return
## ## ##ins.write('DATA:SOU CH1') ##ins.write('DATA:WIDTH 1') ##ins.write('DATA:ENC RPB') ##ins.write('DATA:STOP 10000') ## ##ymult=float(ins.query('WFMPRE:YMULT?')) ##yzero=float(ins.query('WFMPRE:YZERO?')) ##yoff=float(ins.query('WFMPRE:YOFF?')) ##xincr=float(ins.query('WFMPRE:XINCR?')) ##ins.write("ACQ:STATE ON") ####ins.write("ACQ:STOPA SEQ") d=d2xx.listDevices() h=d2xx.open(0) h.setBitMode(0xff,0x40) h.setUSBParameters(0x32000,0x320000) h.setLatencyTimer(3) h.purge() wr_cmd='01' rd_cmd='00' rd_data=[] ##rd_val=None key_raw='00000000000000000000000000000000' data_raw='0000000000000000000000000fffffff' key=key_raw[-1::-1] data=data_raw[-1::-1] for i in range(0,8):
# THE SOFTWARE. import d2xx import time def safe_read(handle, count): while handle.getQueueStatus() < count: time.sleep(1) print "Waiting to read..." return handle.read(count) print "Opening" handle = d2xx.open(0) handle.setBitMode(0x0F, 0) handle.setBitMode(0x0F, 4) handle.setBaudRate(3000000) print "Write and read?" handle.write("\x00" * 100) safe_read(handle, 100) handle.setBitMode(0x0F, 0) handle.setBitMode(0x0F, 1) print "Writing" CHUNK_SIZE = 4096 * 4 for i in range(16000000 / CHUNK_SIZE): print "Wrote: ", handle.write("\x00" * CHUNK_SIZE)
def open(lowByteValue=MASK.SPI_S, lowByteDirection=MASK.SPI_O): return Mpsse(d2xx.open(0), lowByteValue, lowByteDirection)
def open(lowByteValue = MASK.SPI_S, lowByteDirection = MASK.SPI_O): return Mpsse(d2xx.open(0), lowByteValue, lowByteDirection)
def main(self): if self.useftd2xx: import d2xx if not self.useftd2xx or self.takeover: import usb while True: try: for child in self.children: if child.dead: with self.statlock: stats = child.getstatistics(self.miner.collectstatistics(child.children)) self.children.remove(child) self.mhashes = self.mhashes + stats["mhashes"] self.jobsaccepted = self.jobsaccepted + stats["jobsaccepted"] self.accepted = self.accepted + stats["accepted"] self.rejected = self.rejected + stats["rejected"] self.invalid = self.invalid + stats["invalid"] boards = [] if self.useftd2xx: devices = d2xx.listDevices() for devicenum, serial in enumerate(devices): try: handle = d2xx.open(devicenum) handle.close() available = True except: available = False boards.append((serial, available)) else: for bus in usb.busses(): for dev in bus.devices: if dev.idVendor == 0x0403 and dev.idProduct == 0x6001: try: handle = dev.open() manufacturer = handle.getString(dev.iManufacturer, 100).decode("latin1") product = handle.getString(dev.iProduct, 100).decode("latin1") serial = handle.getString(dev.iSerialNumber, 100).decode("latin1") if (manufacturer == "FTDI" and product == "FT232R USB UART") or product == "X6500 FPGA Miner" or product == "X6500r3 FPGA Miner": try: configuration = dev.configurations[0] interface = configuration.interfaces[0][0] handle.setConfiguration(configuration.value) handle.claimInterface(interface.interfaceNumber) handle.releaseInterface() handle.setConfiguration(0) available = True except: available = False boards.append((serial, available)) except: pass for deviceid, available in boards: found = False for child in self.children: if child.deviceid == deviceid: found = True break if found: continue if not available and self.takeover: try: for bus in usb.busses(): if available: break for dev in bus.devices: if available: break if dev.idVendor == 0x0403 and dev.idProduct == 0x6001: handle = dev.open() manufacturer = handle.getString(dev.iManufacturer, 100).decode("latin1") product = handle.getString(dev.iProduct, 100).decode("latin1") serial = handle.getString(dev.iSerialNumber, 100).decode("latin1") if ((manufacturer == "FTDI" and product == "FT232R USB UART") or product == "X6500 FPGA Miner" or product == "X6500r3 FPGA Miner") and serial == deviceid: handle.reset() configuration = dev.configurations[0] interface = configuration.interfaces[0][0] handle.setConfiguration(configuration.value) handle.claimInterface(interface.interfaceNumber) handle.releaseInterface() handle.setConfiguration(0) handle.reset() available = True except: pass if available: config = { \ "deviceid": deviceid, \ "firmware": self.firmware, \ "jobinterval": self.jobinterval, \ "pollinterval": self.pollinterval, \ "useftd2xx": self.useftd2xx, \ "takeover": False, \ "uploadfirmware": self.uploadfirmware, \ "clockspeed": self.clockspeed, \ "errorwarning": self.errorwarning, \ "errorcritical": self.errorcritical, \ "tempwarning": self.tempwarning, \ "tempcritical": self.tempcritical, \ } self.children.append(worker.fpgamining.x6500.X6500Worker(self.miner, config, True)) except Exception as e: self.miner.log("Caught exception: %s\n" % e, "r") time.sleep(self.scaninterval)
import d2xx
def usbopen(): global usb usb = d2xx.open(twocan)
#!/usr/bin/python import os os.system('rmmod ftdi_sio') import d2xx devices = d2xx.listDevices() for devicenum, serial in enumerate(devices): try: h = d2xx.open(devicenum) h.close() isopen = True except: isopen = False print "%2d %s %s" % (devicenum, serial, '*' if isopen else '') print "* means this device is currently available"
# ---------- # import the PyUSB module import d2xx # list devices by description, returns tuple of attached devices description strings d = d2xx.listDevices(d2xx.OPEN_BY_DESCRIPTION) print d # list devices by serial, returns tuple of attached devices serial strings d = d2xx.listDevices() # implicit d2xx.OPEN_BY_SERIAL_NUMBER print d h = d2xx.open(0) print h # read eeprom print h.eeRead() # get queue status print h.getQueueStatus() # set RX/TX timeouts h.setTimeouts(1000, 1000) # write bytes (serial mode) print h.write("Hello world!\r\n") # read bytes (serial mode) print h.read(5)
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. import d2xx import time def safe_read(handle, count): while handle.getQueueStatus() < count: time.sleep(1) print "Waiting to read..." return handle.read(count) print "Opening" handle = d2xx.open(0) handle.setBitMode(0x0F, 0) handle.setBitMode(0x0F, 4) handle.setBaudRate(3000000) print "Write and read?" handle.write("\x00"*100) safe_read(handle, 100) handle.setBitMode(0x0F, 0) handle.setBitMode(0x0F, 1) print "Writing" CHUNK_SIZE = 4096*4 for i in range(16000000/CHUNK_SIZE):
def main(self): # Loop until we are shut down while not self.shutdown: if self.useftd2xx: import d2xx if not self.useftd2xx or self.settings.takeover: import usb try: boards = {} if self.useftd2xx: devices = d2xx.listDevices() for devicenum, serial in enumerate(devices): try: handle = d2xx.open(devicenum) handle.close() available = True except: availabale = False boards[serial] = available else: for bus in usb.busses(): for dev in bus.devices: if dev.idVendor == 0x0403 and dev.idProduct == 0x6001: try: handle = dev.open() manufacturer = handle.getString(dev.iManufacturer, 100).decode("latin1") product = handle.getString(dev.iProduct, 100).decode("latin1") serial = handle.getString(dev.iSerialNumber, 100).decode("latin1") if (manufacturer == "FTDI" and product == "FT232R USB UART") or (manufacturer == "FPGA Mining LLC" and product == "X6500 FPGA Miner"): try: configuration = dev.configurations[0] interface = configuration.interfaces[0][0] handle.setConfiguration(configuration.value) handle.claimInterface(interface.interfaceNumber) handle.releaseInterface() handle.setConfiguration(0) available = True except: available = False boards[serial] = available except: pass for serial in boards.keys(): if self.settings.blacklist: if serial in self.settings.boards: del boards[serial] else: if serial not in self.settings.board: del boards[serial] for serial, child in self.childmap.items(): if not serial in boards: try: self.core.log("%s: Shutting down worker %s...\n" % (self.settings.name, child.settings.name), 800) child.stop() except Exception as e: self.core.log("%s: Could not stop worker %s: %s\n" % (self.settings.name, child.settings.name, traceback.format_exc()), 100, "rB") childstats = child.get_statistics() fields = ["ghashes", "jobsaccepted", "jobscanceled", "sharesaccepted", "sharesrejected", "sharesinvalid"] for field in fields: self.stats[field] += childstats[field] try: self.child.destroy() except: pass del self.childmap[serial] try: self.children.remove(child) except: pass for serial, available in boards.items(): if serial in self.childmap: continue if not available and self.settings.takeover: try: for bus in usb.busses(): if available: break for dev in bus.devices: if available: break if dev.idVendor == 0x0403 and dev.idProduct == 0x6001: handle = dev.open() manufacturer = handle.getString(dev.iManufacturer, 100).decode("latin1") product = handle.getString(dev.iProduct, 100).decode("latin1") _serial = handle.getString(dev.iSerialNumber, 100).decode("latin1") if ((manufacturer == "FTDI" and product == "FT232R USB UART") or (manufacturer == "FPGA Mining LLC" and product == "X6500 FPGA Miner")) and _serial == serial: handle.reset() time.sleep(1) configuration = dev.configurations[0] interface = configuration.interfaces[0][0] handle.setConfiguration(configuration.value) handle.claimInterface(interface.interfaceNumber) handle.releaseInterface() handle.setConfiguration(0) handle.reset() time.sleep(1) available = True except: pass if available: child = X6500Worker(self.core) child.settings.name = "X6500 board " + serial child.settings.serial = serial fields = ["takeover", "useftd2xx", "uploadfirmware", "firmware", "initialspeed", "maximumspeed", "tempwarning", "tempcritical", "invalidwarning", "invalidcritical", "speedupthreshold", "jobinterval", "pollinterval"] for field in fields: child.settings[field] = self.settings[field] child.apply_settings() self.childmap[serial] = child self.children.append(child) try: self.core.log("%s: Starting up worker %s...\n" % (self.settings.name, child.settings.name), 800) child.start() except Exception as e: self.core.log("%s: Could not start worker %s: %s\n" % (self.settings.name, child.settings.name, traceback.format_exc()), 100, "rB") except: self.core.log("Caught exception: %s\n" % traceback.format_exc(), 100, "rB") with self.wakeup: self.wakeup.wait(self.settings.scaninterval)
def main(self): # Loop until we are shut down while not self.shutdown: if self.useftd2xx: import d2xx if not self.useftd2xx or self.settings.takeover: import usb try: boards = {} if self.useftd2xx: devices = d2xx.listDevices() for devicenum, serial in enumerate(devices): try: handle = d2xx.open(devicenum) handle.close() available = True except: availabale = False boards[serial] = available else: for bus in usb.busses(): for dev in bus.devices: if dev.idVendor == 0x0403 and dev.idProduct == 0x6001: try: handle = dev.open() manufacturer = handle.getString( dev.iManufacturer, 100).decode("latin1") product = handle.getString( dev.iProduct, 100).decode("latin1") serial = handle.getString( dev.iSerialNumber, 100).decode("latin1") if (manufacturer == "FTDI" and product == "FT232R USB UART" ) or (manufacturer == "FPGA Mining LLC" and product == "X6500 FPGA Miner"): try: configuration = dev.configurations[ 0] interface = configuration.interfaces[ 0][0] handle.setConfiguration( configuration.value) handle.claimInterface( interface.interfaceNumber) handle.releaseInterface() handle.setConfiguration(0) available = True except: available = False boards[serial] = available except: pass for serial in boards.keys(): if self.settings.blacklist: if serial in self.settings.boards: del boards[serial] else: if serial not in self.settings.board: del boards[serial] for serial, child in self.childmap.items(): if not serial in boards: try: self.core.log( "%s: Shutting down worker %s...\n" % (self.settings.name, child.settings.name), 800) child.stop() except Exception as e: self.core.log( "%s: Could not stop worker %s: %s\n" % (self.settings.name, child.settings.name, traceback.format_exc()), 100, "rB") childstats = child.get_statistics() fields = [ "ghashes", "jobsaccepted", "jobscanceled", "sharesaccepted", "sharesrejected", "sharesinvalid" ] for field in fields: self.stats[field] += childstats[field] try: self.child.destroy() except: pass del self.childmap[serial] try: self.children.remove(child) except: pass for serial, available in boards.items(): if serial in self.childmap: continue if not available and self.settings.takeover: try: for bus in usb.busses(): if available: break for dev in bus.devices: if available: break if dev.idVendor == 0x0403 and dev.idProduct == 0x6001: handle = dev.open() manufacturer = handle.getString( dev.iManufacturer, 100).decode("latin1") product = handle.getString( dev.iProduct, 100).decode("latin1") _serial = handle.getString( dev.iSerialNumber, 100).decode("latin1") if ((manufacturer == "FTDI" and product == "FT232R USB UART") or (manufacturer == "FPGA Mining LLC" and product == "X6500 FPGA Miner") ) and _serial == serial: handle.reset() time.sleep(1) configuration = dev.configurations[ 0] interface = configuration.interfaces[ 0][0] handle.setConfiguration( configuration.value) handle.claimInterface( interface.interfaceNumber) handle.releaseInterface() handle.setConfiguration(0) handle.reset() time.sleep(1) available = True except: pass if available: child = X6500Worker(self.core) child.settings.name = "X6500 board " + serial child.settings.serial = serial fields = [ "takeover", "useftd2xx", "uploadfirmware", "firmware", "initialspeed", "maximumspeed", "tempwarning", "tempcritical", "invalidwarning", "invalidcritical", "speedupthreshold", "jobinterval", "pollinterval" ] for field in fields: child.settings[field] = self.settings[field] child.apply_settings() self.childmap[serial] = child self.children.append(child) try: self.core.log( "%s: Starting up worker %s...\n" % (self.settings.name, child.settings.name), 800) child.start() except Exception as e: self.core.log( "%s: Could not start worker %s: %s\n" % (self.settings.name, child.settings.name, traceback.format_exc()), 100, "rB") except: self.core.log( "Caught exception: %s\n" % traceback.format_exc(), 100, "rB") with self.wakeup: self.wakeup.wait(self.settings.scaninterval)
def main(self): if self.useftd2xx: import d2xx if not self.useftd2xx or self.takeover: import usb while True: try: for child in self.children: if child.dead: with self.statlock: stats = child.getstatistics(self.miner.collectstatistics(child.children)) self.children.remove(child) self.mhashes = self.mhashes + stats["mhashes"] self.jobsaccepted = self.jobsaccepted + stats["jobsaccepted"] self.accepted = self.accepted + stats["accepted"] self.rejected = self.rejected + stats["rejected"] self.invalid = self.invalid + stats["invalid"] boards = [] if self.useftd2xx: devices = d2xx.listDevices() for devicenum, serial in enumerate(devices): try: handle = d2xx.open(devicenum) handle.close() available = True except: availabale = False boards.append((serial, available)) else: for bus in usb.busses(): for dev in bus.devices: if dev.idVendor == 0x0403 and dev.idProduct == 0x6001: try: handle = dev.open() manufacturer = handle.getString(dev.iManufacturer, 100).decode("latin1") product = handle.getString(dev.iProduct, 100).decode("latin1") serial = handle.getString(dev.iSerialNumber, 100).decode("latin1") if (manufacturer == "FTDI" and product == "FT232R USB UART") or (manufacturer == "FPGA Mining LLC" and product == "X6500 FPGA Miner"): try: configuration = dev.configurations[0] interface = configuration.interfaces[0][0] handle.setConfiguration(configuration.value) handle.claimInterface(interface.interfaceNumber) handle.releaseInterface() handle.setConfiguration(0) available = True except: available = False boards.append((serial, available)) except: pass for deviceid, available in boards: found = False for child in self.children: if child.deviceid == deviceid: found = True break if found: continue if not available and self.takeover: try: for bus in usb.busses(): if available: break for dev in bus.devices: if available: break if dev.idVendor == 0x0403 and dev.idProduct == 0x6001: handle = dev.open() manufacturer = handle.getString(dev.iManufacturer, 100).decode("latin1") product = handle.getString(dev.iProduct, 100).decode("latin1") serial = handle.getString(dev.iSerialNumber, 100).decode("latin1") if manufacturer == "FTDI" and product == "FT232R USB UART" and serial == deviceid: handle.reset() configuration = dev.configurations[0] interface = configuration.interfaces[0][0] handle.setConfiguration(configuration.value) handle.claimInterface(interface.interfaceNumber) handle.releaseInterface() handle.setConfiguration(0) handle.reset() available = True except: pass if available: config = { \ "deviceid": deviceid, \ "firmware": self.firmware, \ "jobinterval": self.jobinterval, \ "pollinterval": self.pollinterval, \ "useftd2xx": self.useftd2xx, \ "takeover": False, \ "uploadfirmware": self.uploadfirmware, \ "clockspeed": self.clockspeed, \ "errorwarning": self.errorwarning, \ "errorcritical": self.errorcritical, \ "tempwarning": self.tempwarning, \ "tempcritical": self.tempcritical, \ } self.children.append(worker.fpgamining.x6500.X6500Worker(self.miner, config, True)) except Exception as e: self.miner.log("Caught exception: %s\n" % e, "r") time.sleep(self.scaninterval)
def __init__(self, name, serial='UM245R', reset=False): """ Creates an interface to Raymond's RF Multiplexer, allowing each RF relais to be switched on or off. The manual overide switch should be in the down position, thereby turining the LED off. The LED then indicates if any of the relais are switched on. Note that 8 bits can be set, but currently only relays 1-5 are connected. Requires pyusb package (http://bleyer.org/pyusb/), and the FTDI usb drivers (http://www.ftdichip.com/Drivers/D2XX.htm) installed. Arguments: - serial: FTDI serial id. To see available devices, run: import d2xx for i in d2xx.createDeviceInfoList(): print d2xx.getDeviceInfoDetail(i) """ Instrument.__init__(self, name) self._serial = serial self.add_parameter('state', type=types.IntType, flags=Instrument.FLAG_GETSET, minval=0, maxval=255) self.add_function('set_state_bitstring') self.add_function('get_state_bitstring') self.add_function('turn_on_relay') self.add_function('turn_off_relay') self.add_function('toggle_relay') self.add_function('get_dev') dev_list_len = d2xx.createDeviceInfoList() dev_id = -1 for i in range(dev_list_len): dev_info = d2xx.getDeviceInfoDetail(i) if dev_info['serial'] == self._serial: dev_id = i break if dev_id == -1: error_str = 'Device address serial {} not found in device list'.format( self._serial) logging.error(error_str) raise Exception(error_str) self._dev = d2xx.open(dev_id) self._dev.setBitMode(0xFF, 1) #BitBangMode! self._state = 0 # override from config cfg_fn = os.path.abspath( os.path.join(qt.config['ins_cfg_path'], name + '.cfg')) if not os.path.exists(cfg_fn): _f = open(cfg_fn, 'w') _f.write('') _f.close() self.ins_cfg = config.Config(cfg_fn) self.load_cfg() self.save_cfg()