def __init__(self, port, baud=115200): """ Initializes SCPI slave device from a given port. Port can either be an already initialized pyserial port or may be a string, specifiying the port to be used. Special name: hamegusb, this uses the HM2008 USB interface """ if ( type(port) is str): if (port == "hamegusb"): USB_PID_LIST.append(0xED72); self.__ser = Device(mode='b') else: # configure the serial connections (the parameters differs from device # to device you are connecting to) self.__ser = serial.Serial( port=port, baudrate=baud, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS ) else: self.__ser = port # Try at least an *IDN? command, if this fails # most likely nothing will work on the device at all. self.__device_id = self.query_string("*IDN?", 1); print "Found >>"+self.__device_id
def reset(self): if self.dev != None: del self.dev self.dev = None self.dev = Device(self.device_id, auto_detach=(platform.system() != "Windows")) self.setup()
def __init__(self, int_select): self.dev = Device(mode='b', interface_select = int_select, auto_detach=False, device_id = 'Dual RS232-HS' ) self.write_port_l = 0x80 self.read_port_l = 0x81 self.write_port_h = 0x82 self.read_port_h = 0x83 self.port_l = port(self.dev,self.write_port_l, self.read_port_l) self.port_h = port(self.dev,self.write_port_h, self.read_port_h)
def main(): d1 = Device(device_index=0) d2 = Device(device_index=1) for b in 9600, 38400, 115200: print("Testing {} baud".format(b)) d1.flush() d2.flush() print("Half duplex d1->d2...") test_half_duplex_transfer(d1, d2, baudrate=b) d1.flush() d2.flush() print("Half duplex d2->d1...") test_half_duplex_transfer(d2, d1, baudrate=b) d1.flush() d2.flush() print("Full duplex d1<=>d2...") test_full_duplex_transfer(d1, d2, baudrate=b)
def connect(self): self.target = Device(device_id=self.dev_id, interface_select=1) self.target.flush() time.sleep(0.01) BITMODE_SYNCFF = 0x40 SIO_RTS_CTS_HS = (0x1 << 8) self.target.ftdi_fn.ftdi_set_bitmode(0, BITMODE_SYNCFF) self.target.ftdi_fn.ftdi_setflowctrl(SIO_RTS_CTS_HS) self.target.flush()
def _connect(self): try: # Attempt to construct an FTDI Device self._dev = Device('MON001') # Reset the mode, then switch into serial FIFO self._dev.ftdi_fn.ftdi_set_bitmode(0xFF, 0x00) time.sleep(0.01) self._dev.ftdi_fn.ftdi_set_bitmode(0xFF, 0x40) # Set communication params self._dev.ftdi_fn.ftdi_set_latency_timer(5) self._dev.ftdi_fn.ftdi_setflowctrl(0) self._dev.ftdi_fn.ftdi_usb_purge_buffers() # Mark ourselves connected self.connected.emit(True) except FtdiError: pass
def __init__(self, queue): """Initialize the communication worker""" # call constructor of super class threading.Thread.__init__(self) # set queue self.queue = queue # set FTDI device for communication with iCEstick try: self.dev = Device(mode='b', interface_select=INTERFACE_B) # set baudrate self.dev.baudrate = self.BAUD_RATE except: global exit_flag print(fg.li_red + "[-] Could not connect to FTDI serial interface" + fg.rs) exit(1)
def compute(threadname): """ Compute the force """ dev = Device() dev.baudrate = 230400 lastupdate = pg.ptime.time() i = 0 while True: taille = HAPTICDEV.incommingsize() #FIFO.qsize() if taille >= 3: rec = HAPTICDEV.readarray(3)#bytearray(extract(FIFO, 3)) taille = taille - 3 if rec[0] != 5: while rec[0] != 5: rec = HAPTICDEV.readarray(1)#bytearray(extract(FIFO, 1)) taille = taille - 1 rec[1:2] = HAPTICDEV.readarray(2)#bytearray(extract(FIFO, 2)) taille = taille - 2 if rec[0] == 5: i += 1 angle = rec[1] + rec[2] * 256 if angle > 32767: angle -= 65536 degre = angle*360/20000 data = SHARED['data'] data[:-1] = data[1:] data[-1] = degre SHARED['data'] = data indexf = max(min(int((ANGLEMAX+degre)*RESANG), ANGLEMAX*RESANG*2-1), 0) forcenow = FORCE[indexf] forcenow = max(min(forcenow, 130), -130) HAPTICDEV.write(forcenow) SHARED['degre'] = degre SHARED['forcenow'] = forcenow if i >= COUNT: i = 0 now = pg.ptime.time() SHARED['fps'] = COUNT / (now - lastupdate) SHARED['taille'] = taille lastupdate = now
def __init__( self, name: str, device_id: str, sensor: common.sensor.BaseSensor, callback_func: Callable, log: logging.Logger, ) -> None: super().__init__( name=name, device_id=device_id, sensor=sensor, callback_func=callback_func, log=log, ) self.vcp: Device = Device( self.device_id, mode="t", encoding="ASCII", lazy_open=True, auto_detach=False, )
def __init__(self, fps, velocity_scale=200, dry_run=False, verbose=False): """ fps: the frames per second that set_multi_velocity must be called to keep smooth motion. velocity_scale: convert unitless range (-1, 1) to velocity in microseconds / second """ if not dry_run: self.dev = Device(mode='t') self.dev.baudrate = 9600 self.default_speed = 600 self.positions = self._home_position() self.fps = fps self.velocity_scale = velocity_scale # position scale is the velocity in (microseconds / second) / FPS to get # microseconds per frame self.position_scale = velocity_scale / self.fps self.dry_run = dry_run self.verbose = verbose
def __init__(self, start_offset=0, end_offset=5000, offset_step=1, duration_step=1, start_duration=1, end_duration=30, retries=2): """Initialize the glitcher""" # set FTDI device for communication with iCEstick self.dev = Device(mode='b', interface_select=INTERFACE_B) # set baudrate self.dev.baudrate = 115200 # set offset and duration steps self.offset_step = offset_step self.duration_step = duration_step self.start_offset = start_offset self.end_offset = end_offset self.start_duration = start_duration self.end_duration = end_duration self.retries = retries
def connect(self): self.target = Device(device_id=self.dev_id, interface_select=self.dev_iface)
import paho.mqtt.client as mqtt import json from pylibftdi import Device, USB_PID_LIST, USB_VID_LIST from config import MQTT_HOST USB_VID_LIST.append(0x1321) USB_PID_LIST.append(0x1001) dev = Device(mode='t') dev.baudrate = 57600 dev.open() def run_command(cmd): if cmd != '': dev.flush() print('TX: ' + cmd) dev.writelines(cmd + '\r') out = '' while out == '': out = dev.readline() print('RX: ' + out) def to_command(obj): cmds = [] for input in obj: cmd = 'xpgn(' + input + ',*)=' # print('Input: ' + input) # print(obj[input])
if (len(bytes) > 0): break time.sleep(0.1) print("Received", bytes) while (len(bytes) > 0): print(len(bytes)) msg, bytes = get_msg(bytes) if (msg): print(msg) translate(msg) if INPUT: input() with Device() as dev: dev.ftdi_fn.ftdi_set_bitmode(0xFF, 0x00) time.sleep(0.01) dev.ftdi_fn.ftdi_set_bitmode(0xFF, 0x40) dev.ftdi_fn.ftdi_set_latency_timer(5) dev.ftdi_fn.ftdi_setflowctrl(0) dev.ftdi_fn.ftdi_usb_purge_buffers() i1 = 0 if RANDOM: while True: i2 = random.randint(0, 255) i3 = random.randint(0, 255) print(i1, i2, i3)
def __init__(self): self.ser = Device(mode='b', lazy_open=True)
def __init__(self): self.device = Device()
def reset(self): if self.dev != None: del self.dev self.dev = None self.dev = Device(self.device_id)
#! /usr/bin/python import sys, os #import pylibftdi from pylibftdi import Driver, Device try: dev_list = Driver().list_devices() if len(dev_list) != 0: print "\n\nFollowing devices found: \n" for device_ in dev_list: print device_ dev = Device(device_id="FTZ17IRO", mode='b', interface_select=2) dev.open() tx_data = bytearray(range(0, 256)) dev.write(tx_data) rx_data = bytearray(dev.read(257))#, timeout = 0)) if len(rx_data) == 256 : print "\n\n[Test] Test 1 Passed: Sent 256 bytes of data, received 256 bytes of data" failed = False for i in range(256): if ((tx_data[i]+1)%256) != rx_data[i]: print "[Test] Test 2: Data verification failed! , tx_data : ", tx_data[i], " =/= rx_data : ", rx_data[i] failed = True
""" Script to test serial devices """ from pylibftdi import Device, Driver, INTERFACE_B #print Driver().list_devices() with Device(mode='t', interface_select=INTERFACE_B) as dev: dev.baudrate = 115200 # Send a read command to the board dev.write('R 0 4\r\n') result = "" while 1: # This is a non-blocking read (!!!) result += dev.read(1) print(repr(result))
import struct from slip import slip, unslip_from STYX_VID = 0x2a19 STYX_PID = 0x1007 USB_VID_LIST.clear() USB_VID_LIST.append(STYX_VID) USB_PID_LIST.clear() USB_PID_LIST.append(STYX_PID) R1 = 21660.0 R2 = 1469.0 with Device('MON001') as dev: dev.ftdi_fn.ftdi_set_bitmode(0xFF, 0x00) dev.ftdi_fn.ftdi_set_bitmode(0xFF, 0x40) dev.ftdi_fn.ftdi_set_latency_timer(2) dev.ftdi_fn.ftdi_setflowctrl(0) dev.ftdi_fn.ftdi_usb_purge_buffers() done = False # dev.write('\xC0\xA0\x00\x40\x00\x01\xC0') # while not done: # for i in range(0o2000): # msg = slip(b'\x01' + struct.pack('>H', i)) # dev.write(msg) # rx_bytes = b''
from pylibftdi import Device with Device(mode='t') as dev: dev.baudrate = 115200 dev.write('Hello World')
def midi_ftdi_dev(): from pylibftdi import Device d = Device() d.baudrate = 31250 return d
def connect(self): return Device(device_id=self.devID)