def __init__(self):
deva = ftdi.Device(interface_select=ftdi.INTERFACE_A)
deva.ftdi_fn.ftdi_set_bitmode(0x00, 0x00) # reset
deva.close()
self.dev = ftdi.Device(interface_select=ftdi.INTERFACE_B)
self.dev.ftdi_fn.ftdi_set_bitmode(0x00, 0x00) # reset
self.dev.ftdi_fn.ftdi_set_bitmode(0x03, 0x02) # MPSSE mode
self.set_spi_clock(500e3)
def test_read_timeout(self):
# on Linux, there is a strange bug that sets the timeout to zero.
# However, after sleep, with the FTDI device still plugged in *and
# used at least once*, the timeout kicks in and the effective
# timeout will be the 16 ms promised by a timeout inside the FTDI
# chip.
#
# Test that the timeout is 16 ms, not less. We expect to not see
# data, so the PMT voltages must be zero!
try:
device = pylibftdi.Device()
except pylibftdi.FtdiError:
self.skipTest("Device not found")
# Explicitly set latency timer. Apparently, that's possible, and it
# fixes the issue. Thanks @tomkooij!
device.ftdi_fn.ftdi_set_latency_timer(16)
device.flush()
t = []
for i in range(10):
t0 = time.time()
device.read(62)
t.append(time.time() - t0)
mean_t = sum(t) / len(t)
self.assertAlmostEqual(mean_t, 16e-3, delta=2e-3)
def __init__(self, serial_number=None, label=None):
"""Constructor
Args:
serial_number (str): S/N of the device
label (str): optional name of the device
"""
super(Controller, self).__init__()
dev = pylibftdi.Device(mode='b', device_id=serial_number)
dev.baudrate = 115200
def _checked_c(ret):
if not ret == 0:
raise Exception(dev.ftdi_fn.ftdi_get_error_string())
_checked_c(dev.ftdi_fn.ftdi_set_line_property(8, # number of bits
1, # number of stop bits
0 # no parity
))
time.sleep(50.0/1000)
dev.flush(pylibftdi.FLUSH_BOTH)
time.sleep(50.0/1000)
# skipping reset part since it looks like pylibftdi does it already
# this is pulled from ftdi.h
SIO_RTS_CTS_HS = (0x1 << 8)
_checked_c(dev.ftdi_fn.ftdi_setflowctrl(SIO_RTS_CTS_HS))
_checked_c(dev.ftdi_fn.ftdi_setrts(1))
self.serial_number = serial_number
self.label = label
self._device = dev
# some conservative limits
self.max_velocity = 0.3 # mm/s
self.max_acceleration = 0.3 # mm/s/s
# these define how encode count translates into position, velocity
# and acceleration. e.g. 1 mm is equal to 1 * self.position_scale
# these are set to None on purpose - you should never use this class
# as is.
self.position_scale = None
self.velocity_scale = None
self.acceleration_scale = None
# defines the linear, i.e. distance, range of the controller
# unit is in mm
self.linear_range = (0,10)
# whether or not sofware limit in position is applied
self.soft_limits = True
# the message queue are messages that are sent asynchronously. For
# example if we performed a move, and are waiting for move completed
# message, any other message received in the mean time are place in the
# queue.
self.message_queue = []
def open(self):
"""Open device.
Raises :class:`DeviceNotFoundError` if the device cannot be found.
Raises :class:`DeviceError` if the device cannot be opened.
"""
if self._device is None:
try:
logger.info("Initialising Ftdi device {} {}".format(self._device_description, self._device_index))
self._device = pylibftdi.Device(self._device_description,
interface_select=self._interface_select, device_index=self._device_index)
except pylibftdi.FtdiError as exc:
if "(-3)" in str(exc):
raise DeviceNotFoundError(str(exc))
else:
raise DeviceError(str(exc))
else:
# force default latency timer of 16 ms
# on some systems, this reverts to 0 ms if not set explicitly
self._device.ftdi_fn.ftdi_set_latency_timer(16)
self.closed = False
self.flush()
else:
return
def __init__(self):
self.device = ftdi.Device(mode='t', interface_select=ftdi.INTERFACE_B)
self.device.open()
self.lo = MAX2871()
self.source = MAX2871()
self.current_switches = None
self.current_att = None
def reset(self, enter_bsl=False):
del self.s
# Create a bitbang device to do the secret handshake
ctl = pylibftdi.BitBangDevice()
if enter_bsl:
# RTS (0x04) is TEST, CTS (0x08) is RST
ctl.direction = 0x0C # Drive pins
ctl.port = 0x00 # Drive all low
ctl.port = 0x04 # Set TEST
ctl.port = 0x00 # Clear
ctl.port = 0x04 # Set TEST
ctl.port = 0x0C # "Release" RST
ctl.port = 0x08 # "Release" TEST
ctl.direction = 0x00 # Release pins
else:
ctl.direction = 0x0C # Drive pins
ctl.port = 0x00 # Drive all low
ctl.port = 0x04 # "Release" RST
ctl.port = 0x0C # "Release" TEST
ctl.direction = 0x00 # Release pins
del ctl
# Create a simple serial port device for the BSL.
# N.B the even parity bit!
self.s = pylibftdi.Device()
if enter_bsl:
# 8 bits, even parity, 1 stop bit
self.s.ftdi_fn.ftdi_set_line_property(8, 0, 2)
else:
self.s.ftdi_fn.ftdi_set_line_property(8, 0, 0)
self.s.baudrate = 9600
self.s.flush()
def __init__(self, speed, mode, interface=None, **kwargs):
self.speed = speed
self.mode = mode
self.dev = pylibftdi.Device(interface_select=interface, **kwargs)
self._open()
def __init__(self, baud):
import pylibftdi
try:
handle = pylibftdi.Device()
handle.baudrate = baud
super(PyFTDIDriver, self).__init__(handle)
except pylibftdi.FtdiError:
raise
def init():
s = ftdi.Device(interface_select=PORT)
s.baudrate = BAUD
print(s.baudrate)
# if e == -1:
# print("Failed to set baudrate")
s.ftdi_fn.ftdi_set_latency_timer(1)
s.ftdi_fn.ftdi_set_line_property(8, 1, 0)
return s
def run(self):
import pylibftdi
try:
self.dev = pylibftdi.Device()#pylint: disable=W0201
self.dev.baudrate = 230400
except pylibftdi._base.FtdiError:
print('haptic device not found')
writing = Thread(target=self.write, args=("Thread-write",))
writing.start()
lecturing = Thread(target=self.lecture, args=("Thread-read",))
lecturing.start()
def ftdi_open(board_id, channel):
"""opens FTDI device function depending of the current OS"""
if OS == 'Linux':
return pylibftdi.Device(device_index=board_id, interface_select=channel + 1)
elif OS == 'Windows':
dev_list = ftdi.listDevices()
if channel:
i2c_channel = next(ind for ind, dev in enumerate(dev_list) if chr(dev[-1]) == 'B')
return ftdi.open(i2c_channel)
else:
gpio_channel = next(ind for ind, dev in enumerate(dev_list) if chr(dev[-1]) == 'A')
return ftdi.open(gpio_channel)
def __init__(self):
SYNCFF = 0x40
SIO_RTS_CTS_HS = (0x1 << 8)
self.device = ftdi.Device(mode='b', interface_select=ftdi.INTERFACE_A)
self.device.open()
self.device.ftdi_fn.ftdi_set_bitmode(0xff, SYNCFF)
self.device.ftdi_fn.ftdi_read_data_set_chunksize(0x10000)
self.device.ftdi_fn.ftdi_write_data_set_chunksize(0x10000)
self.device.ftdi_fn.ftdi_setflowctrl(SIO_RTS_CTS_HS)
self.device.flush()
self.pll = ADF4158()
self.fclk = 40e6
self.fpd_freq = self.fclk / 2
def open(self):
if (self.port == None):
print "opening first available ftdi device..."
else:
print "opening ftdi device with serial %s" % self.port
try:
self._ftdi_dev = pylibftdi.Device(
device_id=self.port,
mode='t',
interface_select=pylibftdi.INTERFACE_B)
except:
raise
self._reconfigurePort()
self._isOpen = True
def ftdi_open(board_id, channel, desc=None):
"""opens FTDI device function depending of the current OS"""
if OS == 'Linux':
return pylibftdi.Device(device_index=board_id,
interface_select=channel + 1)
elif OS == 'Windows':
add = desc.get('location')
dev_list = ftdi.listDevices()
dev_channel = None
for i, d in enumerate(dev_list):
if d != b'':
if chr(d[-1]) == chr(ord('A') + channel):
tmp_dev = ftdi.getDeviceInfoDetail(i)
if tmp_dev.get('location') == add + channel:
dev_channel = tmp_dev.get('index')
else:
pass
return ftdi.open(dev_channel)
def test_read_timeout(self):
# on Linux, there is a strange bug that sets the timeout to zero.
# However, after sleep, with the FTDI device still plugged in *and
# used at least once*, the timeout kicks in and the effective
# timeout will be the 16 ms promised by a timeout inside the FTDI
# chip.
#
# Test that the timeout is 16 ms, not less. We expect to not see
# data, so the PMT voltages must be zero!
device = pylibftdi.Device(DESCRIPTION)
device.flush()
t = []
for i in range(10):
t0 = time.time()
device.read(62)
t.append(time.time() - t0)
mean_t = sum(t) / len(t)
self.assertAlmostEqual(mean_t, 16e-3, delta=2e-3)
def main():
"""
Write the NEW_VID and NEW_PID to any detected FTDI device's eeprom.
"""
ftdi_dev = pylibftdi.Device(mode='t')
# read eeprom contents then parse
ftdi_dev.ftdi_fn.ftdi_read_eeprom()
ftdi_dev.ftdi_fn.ftdi_eeprom_decode()
# use library abstraction to get old vid/pid (rather than from the eeprom buffer)
old_vid = c_int()
ftdi_dev.ftdi_fn.ftdi_get_eeprom_value(VENDOR_ID_FIELD, byref(old_vid))
old_pid = c_int()
ftdi_dev.ftdi_fn.ftdi_get_eeprom_value(PRODUCT_ID_FIELD, byref(old_pid))
# set new values
ftdi_dev.ftdi_fn.ftdi_set_eeprom_value(VENDOR_ID_FIELD, NEW_VID)
ftdi_dev.ftdi_fn.ftdi_set_eeprom_value(PRODUCT_ID_FIELD, NEW_PID)
# rebuilt the eeprom image to write
ftdi_dev.ftdi_fn.ftdi_eeprom_build()
ftdi_dev.ftdi_fn.ftdi_write_eeprom()
# read back to verify
ftdi_dev.ftdi_fn.ftdi_read_eeprom()
ftdi_dev.ftdi_fn.ftdi_eeprom_decode()
new_vid = c_int()
ftdi_dev.ftdi_fn.ftdi_get_eeprom_value(VENDOR_ID_FIELD, byref(new_vid))
new_pid = c_int()
ftdi_dev.ftdi_fn.ftdi_get_eeprom_value(PRODUCT_ID_FIELD, byref(new_pid))
print "vid: 0x%x -> 0x%x" % (old_vid.value, new_vid.value)
print "pid: 0x%x -> 0x%x" % (old_pid.value, new_pid.value)
if (new_vid.value == NEW_VID and new_pid.value == NEW_PID):
print "done"
exit(0)
else:
print "could not verify new values!"
exit(-1)
def __init__(self, serial_num, obj, refresh=0, baudrate=115200):
# Name and type of the connection peer
self.name = ''
self.type = ''
self.object = obj
self.baudrate = baudrate
self.serial_num = serial_num
self.devpath = ''
if refresh > 0:
self._refresh = refresh
self.device = pylibftdi.Device(mode='b',
device_id=self.serial_num,
lazy_open=True)
self.device._baudrate = self.baudrate
self._updateTimer = LoopingCall(self.update)
self._updateTimer.start(self._refresh)
self._readTimer = LoopingCall(self.read)
self._readTimer.start(self._refresh / 10)
# the following will start a small daemon to monitor the connection and call ConnectionMade and ConnectionLost
# pyftdi doesn't seem to support this so this pyudev daemon is necessary
context = Context()
# find out whether device is already connected and if that is the case open ftdi connection
for device in context.list_devices(subsystem='usb'):
if device.get('ID_SERIAL_SHORT') == self.serial_num:
for ch in device.children:
if 'tty' not in ch.get('DEVPATH'):
self.devpath = ch.get('DEVPATH')
self.ConnectionMade()
cm = Monitor.from_netlink(context)
cm.filter_by(subsystem='usb')
observer = MonitorObserver(cm,
callback=self.ConnectionMCallBack,
name='monitor-observer')
observer.start()
def _initialize_serial_com(self):
'''Initialize the low-level serial com connection'''
self.resolved_port = self._resolve_port_name()
self.port_type = self._resolve_port_type()
if self.port_type == 'pyserial':
self._ready_port = self._ready_port_pyserial
import serial
self.serial_com = serial.Serial(self.resolved_port,
baudrate=self.baudrate,
timeout=self.timeout)
elif self.port_type == 'pylibftdi':
self._ready_port = self._ready_port_pylibftdi
import pylibftdi
self.serial_com = pylibftdi.Device(self.resolved_port)
elif self.port_type == 'test':
self._ready_port = self._ready_port_test
import test.test_larpix as test_lib
self.serial_com = test_lib.FakeSerialPort()
else:
raise ValueError('Port type must be either pyserial, pylibftdi, or test')
return
def burn(firmware_file):
f = pylibftdi.Device("HiSPARC III Master", interface_select=1)
# Select MPSSE mode (0x02)
# Direction is not used here, it doesn't seem to work.
# We'll set the direction explicitly later.
f.ftdi_fn.ftdi_set_bitmode(0, 0x02)
# Set clock frequency to 30 MHz (0x0000)
write(f, [TCK_DIVISOR, 0, 0])
# Disable divide clock frequency by 5
write(f, [DISABLE_CLK_DIV5])
# bits 0 and 1 are output that is, bits TCK/SK and TDI/DO, clock and
# data
write(f, [SET_BITS_LOW, 0, 0b11])
print_high_bits(f)
# pull nCONFIG (low byte bit 0) low
write(f, [SET_BITS_HIGH, 0, 1])
print_high_bits(f)
# pull nCONFIG (low byte bit 0) high
write(f, [SET_BITS_HIGH, 1, 1])
print_high_bits(f)
BUFSIZE = 64 * 1024
with open(os.path.expanduser(firmware_file), 'rb') as file:
while True:
xbuf = file.read(BUFSIZE)
if not xbuf:
break
LENGTH = len(xbuf) - 1
LENGTH_L = LENGTH & 0xff
LENGTH_H = LENGTH >> 8 & 0xff
write(f, [WRITE_BYTES_PVE_LSB, LENGTH_L, LENGTH_H])
write(f, xbuf)
print_high_bits(f)
def __init__(self, portNum=2):
#Now set up the real ports
self.port = ftdi.Device('USB-COM485 Plus2', interface_select=portNum)
self.port.ftdi_fn.ftdi_set_latency_timer(1)
# self.port.setTimeouts(3,3)
# self.port.setUSBParameters(64)
self.port.baudrate = 5000000
self.reset()
self.port.ftdi_fn.ftdi_usb_reset()
print(self.port)
self.num_errors = 0
self.send_flag = False
self.counter = 0
self.counter2 = 0
self.commands = {
0x12: self.sendPackage, #Data request
0x10: self.setSendFlag, #Start data transfer
0x11: self.setSendFlag, #Stop data transfer
0xE1: self.deac_transducer,
0xE2: self.deac_transducer,
0xE3: self.deac_transducer,
0xE4: self.deac_transducer,
0xE5: self.deac_transducer,
0xE6: self.deac_transducer,
0xF0: self.reset, #Full sensor reset
0xF1: self.reset_transducer,
0xF2: self.reset_transducer,
0xF3: self.reset_transducer,
0xF4: self.reset_transducer,
0xF5: self.reset_transducer,
0xF6: self.reset_transducer,
0xFA: self.reset_imu,
0xFB: self.reset_dac
}
self.crc8_table = crc.calculate_CRC8_table()
self.crc32_table = crc.calculate_CRC32_table()
def startFTDI(self, BAUD, HZ, PORT):
#Open connection to port
self.s = ftdi.Device(device_id='FT0NG8XX', interface_select=PORT)
self.s.baudrate = BAUD
self.s.ftdi_fn.ftdi_set_latency_timer(1)
self.s.ftdi_fn.ftdi_set_line_property(8, 1, 0)
#Generate byte message with sample rate
hz = toHex(HZ)
while not len(hz) == 4:
hz = '0' + hz
b = b'' + toStr([0x10, int(hz[:2], 16), int(hz[2:], 16)])
#Start timing, write, and read
self.startt = time.time()
self.s.write(b)
print('Started transmission')
sys.stdout.flush()
self.recState.data = 'Go'
self.statPublisher.publish(self.recState)
self.recState.data = 'Stop'
def __init__(self, serial_number=None):
super(Connection, self).__init__()
# this takes up to 2-3s:
dev = pylibftdi.Device(mode='b', device_id=serial_number)
dev.baudrate = 115200
def _checked_c(ret):
if not ret == 0:
raise Exception(dev.ftdi_fn.ftdi_get_error_string())
_checked_c(
dev.ftdi_fn.ftdi_set_line_property(
8, # number of bits
1, # number of stop bits
0 # no parity
))
time.sleep(50.0 / 1000)
dev.flush(pylibftdi.FLUSH_BOTH)
time.sleep(50.0 / 1000)
# skipping reset part since it looks like pylibftdi does it already
# this is pulled from ftdi.h
SIO_RTS_CTS_HS = (0x1 << 8)
_checked_c(dev.ftdi_fn.ftdi_setflowctrl(SIO_RTS_CTS_HS))
_checked_c(dev.ftdi_fn.ftdi_setrts(1))
# the message queue are messages that are sent asynchronously. For example
# if we performed a move, and are waiting for move completed message,
# any other message received in the mean time are place in the queue.
self.message_queue = []
self.serial_number = serial_number
self._device = dev
def __init__(self, ADC, encoding='latin1'):
"""Set up the FTDI object that represents the FPGA.
:param ADC: ADC object (see ADC module)
:param encoding: Encoding of the text data coming from the FTDI object
"""
SYNCFF = 0x40
SIO_RTS_CTS_HS = (0x1 << 8)
#self.device = ftdi.Device(mode='t', interface_select=ftdi.INTERFACE_A, encoding=encoding)
self.device = ftdi.Device(mode='b',
interface_select=ftdi.INTERFACE_A,
encoding=encoding)
#self.device.open() # Not needed if not lazy open
self.device.ftdi_fn.ftdi_set_bitmode(0xff, SYNCFF)
self.device.ftdi_fn.ftdi_read_data_set_chunksize(0x10000)
self.device.ftdi_fn.ftdi_write_data_set_chunksize(0x10000)
self.device.ftdi_fn.ftdi_setflowctrl(SIO_RTS_CTS_HS)
self.device.flush()
print("[INFO] FTDI baudrate:", self.device.baudrate)
self.pll = ADC # ADC and PLL are on the same clock
self.fclk = 40e6 # [Hz] Clock frequency
self.fpd_freq = self.fclk / 2
def __init__(self,
port=DEFAULT_PORT,
baud=DEFAULT_BAUD,
use_ftdi=False,
print_unhandled=False):
self.print_unhandled = print_unhandled
self.unhandled_bytes = 0
self.callbacks = {}
self.global_callbacks = []
if use_ftdi:
import pylibftdi
self.ser = pylibftdi.Device()
self.ser.baudrate = baud
else:
import serial
try:
self.ser = serial.Serial(port, baud, timeout=1)
except serial.SerialException:
print
print "Serial device '%s' not found" % port
print
print "The following serial devices were detected:"
print
for p in list_ports():
p_name, p_desc, _ = p
if p_desc == p_name:
print "\t%s" % p_name
else:
print "\t%s (%s)" % (p_name, p_desc)
sys.exit(1)
# Delay then flush the buffer to make sure the receive buffer starts empty.
time.sleep(0.5)
self.ser.flush()
self.lt = ListenerThread(self, print_unhandled)
self.lt.start()
def __init__(self, path, baud=3000000, portNum=1, rate=1500):
self.num_errors = 0
self.crc8_table = crc.calculate_CRC8_table()
self.crc32_table = crc.calculate_CRC32_table()
self.garbage_response = {
'differential': [0, 0, 0, 0, 0, 0],
'differential_raw': [0, 0, 0, 0, 0, 0],
'sum': [0, 0, 0, 0, 0, 0],
'sum_raw': [0, 0, 0, 0, 0, 0],
'imu': [0, 0, 0, 0],
'quaternion': [0, 0, 0, 0],
'saturated': [0, 0, 0, 0, 0, 0],
'temperature': 0,
'report_id': 'NA'
}
self.baud = baud
self.conti_read_flag = False
self.report_ids = {
0x01: 'Accelerometer',
0x02: 'Gyroscope',
0x04: 'Linear Acceleration',
0x05: 'Rotation Vector',
0x08: 'Game Rotation Vector'
}
#Find calibration matrix
self.calMatrix = np.eye(6)
self.filename = path + '/src/calibration.cal'
self.get_cal_matrix()
###Initialize serial port
try:
self.port = ftdi.Device('USB-COM485 Plus2',
interface_select=portNum)
except ftdi.FtdiError:
rospy.logerr('Failed to open port. Quitting...')
sys.exit(0)
self.port.ftdi_fn.ftdi_set_latency_timer(1)
self.port.ftdi_fn.ftdi_set_line_property(8, 1, 0)
self.port.baudrate = self.baud
self.portNum = portNum
rospy.loginfo('Opened port ' + str(self.portNum))
self.reset() #reset transmit and receive buffers
self.ab = {
2.5: (0x5DC000, 2.7304),
5: (0x5DC000, 2.7304),
10: (0x5DC000, 2.7304),
15: (0x3E8000, 1.8202),
25: (0x4B0000, 2.1843),
30: (0x3E8000, 1.8202),
50: (0x4B0000, 2.1843),
60: (0x3E8000, 1.8202),
100: (0x4B0000, 2.1843),
500: (0x3C0000, 1.7474),
1000: (0x3C0000, 1.7474),
2000: (0x3C0000, 1.7474),
3750: (0x400000, 1.8639),
7500: (0x400000, 1.8639),
15000: (0x400000, 1.8639),
30000: (0x400000, 1.8639)
}
self.inBuf = [False] * 6
self.adsGain = [1] * 6
self.adsRate = [30e3] * 6
self.vref = 2.5
self.OFC = [1] * 6
self.FSC = [1] * 6
###Set up ROS
self.sampleRate = rate
self.rate = rospy.Rate(self.sampleRate)
#queue_size limits the number of queued messages if a subscriber is reading too slowly
#Create publisher to write continuous data to topic using custom message type
self.force_data_pub = rospy.Publisher('force_data' + str(portNum),
SensorOutput,
queue_size=1)
#Listen to user commands and interrupt action to carry out the command
self.user_cmds = rospy.Service('user_command' + str(portNum), ByteSrv,
self.send_byte)
#Listen to user commands to dstart or stop continuous data transfer
self.run_flag = rospy.Subscriber('continuous_data_flag' + str(portNum),
FlagMsg, self.changeFlag)
#Service for reading and parsing one measurement
self.measure_srv = rospy.Service('poll' + str(portNum),
SensorOutputRequest, self.poll)
#Publisher for IMU Calibration
self.imu_cal_pub = rospy.Publisher('imu_calibration' + str(portNum),
KeyValue,
queue_size=1)
#Let all the topics start properly
rospy.sleep(1)
self.times = []
count = 0
##Run loop - do this forever in the background
while not rospy.is_shutdown():
self.rate.sleep()
if self.conti_read_flag == 1: #Continuous data transfer
#Wait for initialization bit and matching crc-4
if self.wait_for_packet(verbose=False):
parsed = self.found_init_byte()
try:
if parsed != None:
self.force_data_pub.publish(parsed)
count += 1
else:
rospy.logwarn('Error parsing data')
except rospy.ROSSerializationException:
rospy.logwarn(
"Error publishing. Serialization Exception caught. Continuing..."
)
elif self.conti_read_flag == 0 and count != 0: #Data transmission has just been stopped
rospy.loginfo('Stopping Continuous Data Transfer...')
self.port.write(
b'\x11\x00\x00\xC9'
) #11 is the byte command, C9 is the matching crc8
self.purge()
rospy.sleep(0.25)
timeout = 0
count = 0
while self.readBytes(1) != []:
self.port.write(b'\x11\x00\x00\xC9')
self.purge()
rospy.sleep(0.25)
timeout += 1
if timeout == 100:
rospy.logwarn(
'Failed to stop transmission. Please try again')
break
elif self.conti_read_flag == 2: #Calibrate IMU
self.calibrate_imu
self.port.close()
self.measure_srv.shutdown('Finished')
self.user_cmds.shutdown('Finished')
def __init__(self,hwser=None):
# add Thorlabs devices to USB_PID_LIST -> in the __init__.py script
#pylibftdi.USB_PID_LIST.append(0xfaf0)
# Get list of connected devices
devList = pylibftdi.Driver().list_devices()
# Find out how many serial devices are connected to the USB bus
numDevices = len(devList)
# # Check each device to see if either the serial number matches (if given) or the description string is recognized as valid for the class type
numMatchingDevices=0
for dev in range(numDevices):
detail = devList[dev]
if hwser!=None and detail[2]!="" and int(detail[2])==hwser:
# Get the first device which matches the serial number if given
numMatchingDevices+=1
self.device=device=pylibftdi.Device(mode='b',device_id=detail[2].decode())
break
elif hwser==None and (detail[1].decode() in self.deviceDescriptionStrings()):
# Get the first device which is valid for the given class if no hwser
numMatchingDevices+=1
if numMatchingDevices==1:
self.device=device=pylibftdi.Device(mode='b',device_id=detail[2].decode())
elif dev==numDevices-1 and numMatchingDevices==0:
# Raise an exception if no devices were found
if hwser!=None:
errorStr="Hardware serial number " + str(hwser) + " was not found"
else:
errorStr="No devices found matching class name " + type(self).__name__ + ". Expand the definition of CLASS_STRING_MAPPING if necessary"
raise DeviceNotFoundError(errorStr)
# Print a warning message if no serial given and multiple devices were found which matched the class type
if numMatchingDevices>1 and hwser==None:
print(str(numMatchingDevices)+" devices found matching " + type(self).__name__ + "; the first device was opened")
# Inititalize the device according to FTD2xx and APT requirements
device.baudrate = 115200
# Return exception if there is an error in ftdi function
def _checked_c(ret):
if not ret == 0:
raise Exception(device.ftdi_fn.ftdi_get_error_string())
_checked_c(device.ftdi_fn.ftdi_set_line_property( 8, # number of bits
1, # number of stop bits
0 # no parity
))
self.delay()
device.flush(pylibftdi.FLUSH_BOTH)
self.delay()
# Skip the reset part
# From ftdi.h
SIO_RTS_CTS_HS = (0x1 << 8)
_checked_c(device.ftdi_fn.ftdi_setflowctrl(SIO_RTS_CTS_HS))
_checked_c(device.ftdi_fn.ftdi_setrts(1))
# Check first 2 digits of serial number to see if it's normal type or card/slot type, and build self.channelAddresses as list of (chanID,destAddress) tuples
self.channelAddresses=[]
if device.device_id[0:2] in c.BAY_TYPE_SERIAL_PREFIXES:
# Get the device info
serNum,model,hwtype,firmwareVer,notes,hwVer,modState,numCh=self.query(c.MGMSG_HW_REQ_INFO,c.MGMSG_HW_GET_INFO,destID=c.RACK_CONTROLLER_ID)[-1]
# Check each bay to see if it's enabled and also request hardware info
for bay in range(numCh):
bayId=c.ALL_BAYS[bay]
self.writeMessage(c.MGMSG_HW_NO_FLASH_PROGRAMMING,destID=bayId)
if self.BayUsed(bay):
bayInfo=self.query(c.MGMSG_HW_REQ_INFO,c.MGMSG_HW_GET_INFO,destID=bayId)[-1]
self.channelAddresses.append((c.CHANNEL_1,bayId))
else:
# Otherwise just build a list of the channel numbers
self.writeMessage(c.MGMSG_HW_NO_FLASH_PROGRAMMING,destID=c.GENERIC_USB_ID)
try:
serNum,model,hwtype,firmwareVer,notes,hwVer,modState,numCh=self.query(c.MGMSG_HW_REQ_INFO,c.MGMSG_HW_GET_INFO,waitTime=c.INIT_QUERY_TIMEOUT)[-1]
except:
print('Device not responding, trying manual initialization')
numCh = 1
model = b'TCD001\x00\x00'
serNum = 00000000
notes = b'APT DC Motor Controller'
for channel in range(numCh):
self.channelAddresses.append((c.ALL_CHANNELS[channel],c.GENERIC_USB_ID))
for channel in range(len(self.channelAddresses)):
self.writeMessage(c.MGMSG_MOD_SET_CHANENABLESTATE,1,c.CHAN_ENABLE_STATE_ENABLED,c.RACK_CONTROLLER_ID)
self.EnableHWChannel(channel)
# Set the controller type
#print(model)
#input()
self.controllerType=model.split(b'\x00',1)[0].decode()
# Print a message saying we've connected to the device successfuly
print("Connected to %s device with serial number %d. Notes about device: %s"%(model.split(b'\x00',1)[0].decode(),serNum,notes.split(b'\x00',1)[0].decode()))
def __init__(self):
self.device = ftdi.Device(mode='t', interface_select=ftdi.INTERFACE_B)
self.device.open()
self.lo = MAX2871()
self.source = MAX2871()
sensor = Sensor(calMatrix)
# test all modules are working
cont = True
time.sleep(1)
sample = sensor.poll()
for cmmd in sample.sum:
if cmmd < 0.5:
cont = False
print('Sum Signal too low (' + str(cmmd) + 'V)')
sensor.disconnect()
if cont:
#Open connection to port
s = ftdi.Device(interface_select=PORT)
s.baudrate = BAUD
s.ftdi_fn.ftdi_set_latency_timer(1)
s.ftdi_fn.ftdi_set_line_property(8, 1, 0)
#Generate byte message with sample rate
hz = toHex(HZ)
#print(hz)
while not len(hz) == 4:
hz = '0' + hz
b = b'' + toStr([0x10, int(hz[:2], 16), int(hz[2:], 16)])
#Start timing, write, and read
startt = time.time()
s.write(b)
print('Started transmission')
def __init__(self, serial=None):
self.dev = pylibftdi.Device(device_id=serial)
def __init__(self, device_index=0):
self.device_index = int(device_index)
self.device = pylibftdi.Device(device_index=device_index,
interface_select=pylibftdi.INTERFACE_B)
self.device.baudrate = 115200
