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)
