class Newport:
direction = 0xff # gpio direction byte
def __init__(self, address='ftdi://ftdi:232/1'):
self.gpio = GpioController()
self.state = None
self.address = address
def __del__(self):
self.disconnect()
def connect(self):
self.gpio.open_from_url(self.address, direction=self.direction)
self.state = self.gpio.read()
def disconnect(self):
self.gpio.close()
def on(self):
self.gpio.write(0x00)
self.state = self.gpio.read()
def off(self):
self.gpio.write(0xff)
self.state = self.gpio.read()
class LEDTest():
"""Test for LED on FT232H board"""
def __init__(self):
self._gpio = GpioController()
self._state = 0 # SW cache of the GPIO output lines
def pins(self):
print(self._gpio.direction)
def open(self, out_pins):
"""Open a GPIO connection, defining which pins are configured as
output and input"""
out_pins &= 0xFF
url = environ.get('FTDI_DEVICE', 'ftdi://ftdi:232h/1')
self._gpio.open_from_url(url, direction=out_pins)
def close(self):
"""Close the GPIO connection"""
self._gpio.close()
def get_gpio(self, line):
"""Retrieve the level of a GPIO input pin
:param line: specify which GPIO to read out.
:return: True for high-level, False for low-level
"""
value = self._gpio.read_port()
print(value)
return bool(value & (1 << line))
def set_gpio(self, line, on):
"""Set the level of a GPIO ouput pin.
:param line: specify which GPIO to madify.
:param on: a boolean value, True for high-level, False for low-level
"""
if on:
state = self._state | (1 << line)
else:
state = self._state & ~(1 << line)
self._commit_state(state)
def _commit_state(self, state):
"""Update GPIO outputs
"""
self._gpio.write_port(state)
# do not update cache on error
self._state = state
def test(self):
"""Check simple GPIO write and read sequence."""
gpio = GpioController()
# access to the virtual GPIO port
out_pins = 0xAA
gpio.configure('ftdi://:232h/1', direction=out_pins)
bus, address, iface = gpio.ftdi.usb_path
self.assertEqual((bus, address, iface), (4, 5, 0))
vftdi = self.loader.get_virtual_ftdi(bus, address)
gpio.write_port(0xF3)
self.assertEqual(vftdi.gpio, 0xAA & 0xF3)
vftdi.gpio = 0x0c
vio = gpio.read_port()
self.assertEqual(vio, (0xAA & 0xF3) | (~0xAA & 0x0c))
gpio.close()
class GpioTest(object):
"""
"""
def __init__(self):
self._gpio = GpioController()
self._state = 0 # SW cache of the GPIO output lines
def open(self, out_pins):
"""Open a GPIO connection, defining which pins are configured as
output and input"""
out_pins &= 0xFF
self._gpio.open(vendor=0x403, product=0x6011, interface=1,
direction=out_pins)
def close(self):
"""Close the GPIO connection"""
self._gpio.close()
def set_gpio(self, line, on):
"""Set the level of a GPIO ouput pin.
:param line: specify which GPIO to madify.
:param on: a boolean value, True for high-level, False for low-level
"""
if on:
state = self._state | (1 << line)
else:
state = self._state & ~(1 << line)
self._commit_state(state)
def get_gpio(self, line):
"""Retrieve the level of a GPIO input pin
:param line: specify which GPIO to read out.
:return: True for high-level, False for low-level
"""
value = self._gpio.read_port()
return bool(value & (1 << line))
def _commit_state(self, state):
"""Update GPIO outputs
"""
self._gpio.write_port(state)
# do not update cache on error
self._state = state
def _test_gpio(self):
"""Check simple GPIO write and read sequence."""
with open('pyftdi/tests/resources/ft232h.yaml', 'rb') as yfp:
self.loader.load(yfp)
gpio = GpioController()
# access to the virtual GPIO port
out_pins = 0xAA
gpio.configure('ftdi://:232h/1', direction=out_pins)
bus, address, iface = gpio.ftdi.usb_path
self.assertEqual((bus, address, iface), (4, 5, 0))
vftdi = self.loader.get_virtual_ftdi(bus, address)
vport = vftdi.get_port(1)
gpio.write_port(0xF3)
self.assertEqual(vport.gpio, 0xAA & 0xF3)
vport.gpio = 0x0c
vio = gpio.read_port()
self.assertEqual(vio, (0xAA & 0xF3) | (~0xAA & 0x0c))
gpio.close()
def test_baudrate(self):
"""Check simple GPIO write and read sequence."""
# load custom CBUS config, with:
# CBUS0: GPIO (gpio)
# CBUS1: GPIO (gpio)
# CBUS0: DRIVE1 (forced to high level)
# CBUS0: TXLED (eq. to highz for tests)
with open('pyftdi/tests/resources/ft230x_io.yaml', 'rb') as yfp:
self.loader.load(yfp)
gpio = GpioController()
# access to the virtual GPIO port
out_pins = 0xAA
gpio.configure('ftdi://:230x/1', direction=out_pins)
vftdi = self.loader.get_virtual_ftdi(1, 1)
vftdi.get_port(1)
baudrate = 1000000
gpio.set_frequency(baudrate)
gpio.close()
release_reset_and_wait()
print_any_serial()
return True
return False
return bitstring.BitString(
clock_in_clock_out(send_sequence.tobytes(), single_clk_pulse,
unexpected_output_action, serial_handler))
def read_challenge():
return send_and_receive(instigat)
def send_response(response_sequence):
return send_and_receive(response_sequence)
for rep in range(0, 100):
print("\n%d:" % rep)
challenge_sequence = read_challenge()
print("challenge: %s" % challenge_sequence.hex)
response_sequence = blanksss.copy()
print("response : %s" % response_sequence.hex)
result_sequence = send_response(response_sequence)
print("result : %s" % result_sequence.hex)
print_any_serial()
ser.close()
bitbang.close()
self.i2c_end()
return v
def i2c_read_from_reg(self, reg):
"""Reads a single byte from specified register.
:param reg: Register to be read.
:return: Byte that was read.
"""
v = self.i2c_write_address(0, self.address)
v &= self.i2c_write_byte(reg)
self.i2c_end()
v &= self.i2c_write_address(1, self.address)
byte = self.i2c_read_byte()
if not v:
print("Error")
self.i2c_end()
return byte
if __name__ == '__main__':
mask = 0x13 # in, in,in Out, In, In, out, out
gpio = GpioController()
gpio.open_from_url('ftdi://ftdi:4232h/1', mask)
port = I2CPort(gpio)
switch2 = I2CDevice(port, 0x71)
switch2.i2c_write_byte_to(0x04)
i = switch2.i2c_read_byte_from()
print("%x" % i)
gpio.close()
class PapilioOne(PyFTDIGPIOAdapter):
"""
A JTAG adapter for Papilio One devices ported to use PyFTDI python library instead of libftdi.
"""
#VID/PID constants.
VENDOR_ID = 0x0403
PRODUCT_ID = 0x6010
#Port-number constants.
TCK_PORT = 0
TDI_PORT = 1
TDO_PORT = 2
TMS_PORT = 3
DEFAULT_FREQ = int(1e6)
FTDI_URL = 'ftdi://0x{:04x}:0x{:04x}/1'.format(VENDOR_ID, PRODUCT_ID)
def __init__(self, serial_number=None, debug=False):
"""
Create a new instance of the Papilio One.
serial_number -- The serial number of the board to connect to, or None to use
the first available bitbangable FTDI. Use caution with this one!
NOTE: This is IGNORED.
"""
# Instead of using BitBangDevice(), use GpioController() from PyFTDI
self._gpio = GpioController()
# If FTDI_DEVICE environment variable, use it instead of self.FTDI_URL
url = environ.get('FTDI_DEVICE', self.FTDI_URL)
# Open the PyFTDI URL with outputs set as per set_up_jtag_port()
self._gpio.open_from_url(url, direction=self.set_up_jtag_port())
atexit.register(self.cleanup)
#Initiatialize the core JTAG subsystem.
super().__init__(self._gpio)
def cleanup(self):
print("Running PyFTDI GPIO cleanup...")
self._gpio.close()
def set_tck_period(self, period):
"""
Handle the settck virtual cable command which requests a certain TCK period. Return the actual period.
"""
#@@@# Modify to actually change frequency using PyFTDI functions.
## Actual Period depends on many factors since this tries to simply go as fast as it can. So nothing to set. Respond that it goes at 100 Hz or 10e6 ns
return int(1e9 // self.DEFAULT_FREQ)
def set_up_jtag_port(self):
direction = 0
direction |= (1 << self.TCK_PORT)
direction |= (1 << self.TDI_PORT)
direction |= (1 << self.TMS_PORT)
direction &= ~(1 << self.TDO_PORT)
return direction
def set_tms(self, value, commit=True):
"""
Specifies the value of the TMS port. Used by the parent class.
"""
self._set_bit(self.TMS_PORT, value, commit)
def set_tdi(self, value, commit=True):
"""
Specifies the value of the TDI port. Used by the parent class.
"""
self._set_bit(self.TDI_PORT, value, commit)
def set_tck(self, value, commit=True):
"""
Specifies the value of the TCK port. Used by the parent class.
"""
self._set_bit(self.TCK_PORT, value, commit)
def get_tdo(self):
"""
Reads the current value of the TDO port. Used by the parent class.
"""
return self._get_bit(self.TDO_PORT)
