def test(self):
url1 = environ.get('FTDI_DEVICE', 'ftdi:///1')
i2c1 = I2cController()
i2c1.configure(url1, frequency=100000)
url2 = '%s%d' % (url1[:-1], int(url1[-1]) + 1)
i2c2 = I2cController()
i2c2.configure(url2, frequency=100000)
port = i2c2.get_port(0x76)
print(port.read_from(0x00, 2))
print(port.read_from(0x00, 2))
def __init__(self, serial):
self.serial = serial + '(I2C)'
self._i2c = I2cController()
self._i2c.configure('ftdi://::' + serial + '/1', frequency=1000000)
self._device = None # type: I2cPort
self._gpio = None # type: I2cGpioPort
def ftdi_i2c(device='ftdi://::/1', address=0x3C):
"""
Bridges an `I²C <https://en.wikipedia.org/wiki/I%C2%B2C>`_ (Inter-Integrated
Circuit) interface over an FTDI USB device to provide :py:func:`data` and
:py:func:`command` methods.
:param device: A URI describing the location of the FTDI device. If ``None`` is
supplied (default), ``ftdi://::/1`` is used. See `pyftdi <https://pypi.python.org/pypi/pyftdi>`_
for further details of the naming scheme used.
:type device: string
:param address: I²C address, default: ``0x3C``.
:type address: int
:raises luma.core.error.DeviceAddressError: I2C device address is invalid.
.. versionadded:: 1.9.0
"""
from pyftdi.i2c import I2cController
try:
addr = int(str(address), 0)
except ValueError:
raise luma.core.error.DeviceAddressError(
'I2C device address invalid: {}'.format(address))
controller = I2cController()
controller.configure(device)
port = controller.get_port(addr)
serial = i2c(bus=__FTDI_WRAPPER_I2C(controller, port))
serial._managed = True
serial._i2c_msg_write = lambda address, data: (address, data)
return serial
def __init__(self, url):
try:
self.ftdi = Ftdi.create_from_url(url)
except UsbToolsError:
raise Error('no device found for URL %s' % url)
self.i2c = I2cController()
self.i2c.set_retry_count(1)
self.i2c.configure(url)
self.gpio = Device.GpioController(self.ftdi)
port = self.i2c.get_port(0x74)
self.buttons = []
self.rails = []
self.power = Device.I2cButton(port, "power", 0x7, 0x3, 4)
self.buttons.append(self.power)
self.reset = Device.I2cButton(port, "reset", 0x6, 0x2, 3)
self.buttons.append(self.reset)
self.recovery = Device.I2cButton(port, "recovery", 0x7, 0x3, 3)
self.buttons.append(self.recovery)
self.force = Device.GpioButton(self.gpio, 6, "force-off")
self.buttons.append(self.force)
self.eeprom = Device.Eeprom(self.ftdi)
self.core = Device.PowerRail(port, "core", 0x7, 0x1, 6)
self.rails.append(self.core)
self.cpu = Device.PowerRail(port, "cpu", 0x7, 0x1, 7)
self.rails.append(self.cpu)
def get_i2c_controller(id):
i2c = I2cController()
i2c.configure(f"ftdi://0x0403:0x6014:MT{id:04}/1")
# TODO: consider fixing https://github.com/eblot/pyftdi/blob/master/pyftdi/i2c.py:459 and then
# using the below line instead of the above one... if we find it's too slow as is, that is
# i2c.configure(f"ftdi://0x0403:0x6014:MT{id:04}/1", frequency=400_000)
return i2c
def setUp(self):
self._i2c = I2cController()
self._i2c.configure(self.url,
frequency=400e3,
clockstretching=False,
debug=False,
rdoptim=True)
def scan(self):
"""Open an I2c connection to a slave"""
url = environ.get('FTDI_DEVICE', 'ftdi://ftdi:4232h/2')
i2c = I2cController()
slaves = []
getLogger('pyftdi.i2c').setLevel(ERROR)
try:
i2c.set_retry_count(1)
i2c.configure(url)
for addr in range(i2c.HIGHEST_I2C_ADDRESS + 1):
port = i2c.get_port(addr)
try:
port.read(0)
slaves.append('X')
except I2cNackError:
slaves.append('.')
finally:
i2c.terminate()
columns = 16
row = 0
print(' {}'.format(''.join(' {:01X} '.format(col)
for col in range(columns))))
while True:
chunk = slaves[row:row + columns]
if not chunk:
break
print(' {:1X} {}'.format(row // columns, ' '.join(chunk)))
row += columns
def scan(url):
"""Open an I2c connection to a slave."""
i2c = I2cController()
slaves = []
getLogger('pyftdi.i2c').setLevel(ERROR)
try:
i2c.set_retry_count(1)
i2c.configure(url)
for addr in range(i2c.HIGHEST_I2C_ADDRESS + 1):
port = i2c.get_port(addr)
try:
port.read(0)
slaves.append('X')
except I2cNackError:
slaves.append('.')
finally:
i2c.terminate()
columns = 16
row = 0
print(' %s' % ''.join(' %01X ' % col for col in range(columns)))
while True:
chunk = slaves[row:row + columns]
if not chunk:
break
print(' %1X:' % (row // columns), ' '.join(chunk))
row += columns
def __init__(self, channel=1):
try:
ch_nr = int(channel)
channel = 'ftdi://ftdi:2232h/{}'.format(ch_nr)
except:
pass
self.i2c = I2cController()
self.i2c.configure(channel)
def __init__(self, *, frequency=400000, url='ftdi://ftdi:ft232h:1/1'):
# change GPIO controller to I2C
from pyftdi.i2c import I2cController
self._i2c = I2cController()
# self._i2c.configure('ftdi://ftdi:ft232h/1', frequency=frequency)
self._i2c.configure(url, frequency=frequency)
Pin.ft232h_gpio = self._i2c.get_gpio()
def __init__(self, *, frequency=400000):
# change GPIO controller to I2C
# pylint: disable=import-outside-toplevel
from pyftdi.i2c import I2cController
# pylint: enable=import-outside-toplevel
self._i2c = I2cController()
self._i2c.configure(get_ftdi_url(), frequency=frequency)
Pin.ft232h_gpio = self._i2c.get_gpio()
def __init_i2c_controller(self)->I2cController:
"""
Initiate the I2C controller
:param:
i2c:pyftdi.i2c.I2cController - I2C controller object
:return:
I2C object
"""
i2c=I2cController()
slave=i2c.configure('ftdi://ftdi:232h:FT2BZGR5/1')
return i2c
def __init__(self, control="one", pin_id=None):
# setup GPIO controller if not done yet
# use one provided by I2C as default
if not Pin.ft232h_gpio:
from pyftdi.i2c import I2cController
i2c = I2cController()
i2c.configure("ftdi://ftdi:ft232h:white/1")
Pin.ft232h_gpio = i2c.get_gpio()
Pin.controller_one = i2c.get_gpio()
i2c_second = I2cController()
i2c_second.configure("ftdi://ftdi:ft232h:black/1")
Pin.controller_two = i2c_second.get_gpio()
# check if pin is valid
if pin_id:
if Pin.ft232h_gpio.all_pins & 1 << pin_id == 0:
raise ValueError("Can not use pin {} as GPIO.".format(pin_id))
# ID is just bit position
if control == "one":
self.controller = Pin.controller_one
else:
self.controller = Pin.controller_two
self.id = pin_id
def __init__(self, pin_id=None):
# setup GPIO controller if not done yet
# use one provided by I2C as default
if not Pin.ft232h_gpio:
from pyftdi.i2c import I2cController
i2c = I2cController()
i2c.configure("ftdi:///1")
Pin.ft232h_gpio = i2c.get_gpio()
# check if pin is valid
if pin_id:
if Pin.ft232h_gpio.all_pins & 1 << pin_id == 0:
raise ValueError("Can not use pin {} as GPIO.".format(pin_id))
# ID is just bit position
self.id = pin_id
def __i2c_slave_port(self, i2c:I2cController=None)->I2cPort:
"""
Get slave port
:args:
i2c:pyftdi.i2c.I2cController - I2C controller object
:param:
slave:pyftdi.i2c.I2cPort -
:return:
slave port object
"""
slave = i2c.get_port(_MMA8451_DEFAULT_ADDRESS)
if slave.read_from(_MMA8451_REG_WHOAMI, 1)[0] != 0x1a:
raise RuntimeError('Failed to find MMA8451, check wiring!')
return slave
def open(self) -> None:
"""Opens io stream."""
try:
if os.getenv("IS_I2C_ENABLED") == "true":
device_name = "/dev/i2c-{}".format(self.bus)
self.io = io.open(device_name, "r+b", buffering=0)
elif os.getenv("IS_USB_I2C_ENABLED") == "true":
self.io = I2cController()
self.io.configure("ftdi://ftdi:232h/1") # type: ignore
else:
message = "Platform does not support i2c communication"
raise InitError(message)
except (PermissionError, I2cIOError, I2cNackError) as e:
message = "Unable to open device io: {}".format(device_name)
raise InitError(message, logger=self.logger) from e
def __i2c_slave_port(self, i2c: I2cController = None) -> I2cPort:
"""
Get slave port
:args:
i2c:pyftdi.i2c.I2cController - I2C controller object
:param:
slave:pyftdi.i2c.I2cPort -
:return:
slave port object
"""
try:
slave = i2c.get_port(AM2320_DEFAULT_ADDR)
except:
raise ValueError('Unable to get Port for %s' % AM2320_DEFAULT_ADDR)
return slave
def scan(cls, url: str, smb_mode: bool = True) -> None:
"""Scan an I2C bus to detect slave device.
:param url: FTDI URL
:param smb_mode: whether to use SMBbus restrictions or regular I2C
mode.
"""
i2c = I2cController()
slaves = []
getLogger('pyftdi.i2c').setLevel(ERROR)
try:
i2c.set_retry_count(1)
i2c.configure(url)
for addr in range(cls.HIGHEST_I2C_SLAVE_ADDRESS + 1):
port = i2c.get_port(addr)
if smb_mode:
try:
if addr in cls.SMB_READ_RANGE:
port.read(0)
slaves.append('R')
else:
port.write([])
slaves.append('W')
except I2cNackError:
slaves.append('.')
else:
try:
port.read(0)
slaves.append('R')
continue
except I2cNackError:
pass
try:
port.write([])
slaves.append('W')
except I2cNackError:
slaves.append('.')
finally:
i2c.terminate()
columns = 16
row = 0
print(' %s' % ''.join(' %01X ' % col for col in range(columns)))
while True:
chunk = slaves[row:row + columns]
if not chunk:
break
print(' %1X:' % (row // columns), ' '.join(chunk))
row += columns
def test(self):
url = environ.get('FTDI_DEVICE', 'ftdi:///1')
address = environ.get('I2C_ADDRESS', '0x50').lower()
addr = int(address, 16 if address.startswith('0x') else 10)
i2c = I2cController()
i2c.configure(url)
slave = i2c.get_port(addr)
gpio = i2c.get_gpio()
gpio.set_direction(0x0010, 0x0010)
gpio.write(0)
gpio.write(1 << 4)
gpio.write(0)
slave.write([0x12, 0x34])
gpio.write(0)
gpio.write(1 << 4)
gpio.write(0)
def __i2c_slave_port(self, i2c: I2cController = None) -> I2cPort:
"""
Get slave port
:args:
i2c:pyftdi.i2c.I2cController - I2C controller object
:param:
slave:pyftdi.i2c.I2cPort -
:return:
slave port object
"""
try:
slave = i2c.get_port(_INA219_DEFAULT_ADDRESS)
except:
print('Unable to get Port for %s' % _INA219_DEFAULT_ADDRESS)
exit(1)
return slave
def __init__(self, i2c_id=None, mode=MASTER, baudrate=None, frequency=400000):
if mode != self.MASTER:
raise NotImplementedError("Only I2C Master supported!")
_mode = self.MASTER
# change GPIO controller to I2C
# pylint: disable=import-outside-toplevel
from pyftdi.i2c import I2cController
# pylint: enable=import-outside-toplevel
self._i2c = I2cController()
if i2c_id is None:
self._i2c.configure(get_ft232h_url(), frequency=frequency)
else:
self._i2c.configure(get_ft2232h_url(i2c_id), frequency=frequency)
Pin.mpsse_gpio = self._i2c.get_gpio()
def activate_osx(self):
try:
self.i2c_device = I2cController()
self.i2c_device.configure('ftdi://ftdi:232h/1')
self.slave_device = self.i2c_device.get_port(int("60", 16))
self.slave_device.configure_register(bigendian=True, width=2)
except USBError:
usb_error = Factory.ErrorPopup()
usb_error.text = str(USBError)
usb_error.open()
except UsbToolsError:
usb_tool_error = Factory.ErrorPopup()
usb_tool_error.text = str(UsbToolsError)
usb_tool_error.open()
except I2cIOError:
i2c_io_error = Factory.ErrorPopup()
i2c_io_error.text = str(I2cIOError)
i2c_io_error.open()
def __init__(self, pin_id=None):
# setup GPIO controller if not done yet
# use one provided by I2C as default
if not Pin.ft232h_gpio:
# pylint: disable=import-outside-toplevel
from pyftdi.i2c import I2cController
# pylint: enable=import-outside-toplevel
i2c = I2cController()
i2c.configure(get_ftdi_url())
Pin.ft232h_gpio = i2c.get_gpio()
# check if pin is valid
if pin_id:
if Pin.ft232h_gpio.all_pins & 1 << pin_id == 0:
raise ValueError("Can not use pin {} as GPIO.".format(pin_id))
# ID is just bit position
self.id = pin_id
def plugin_init(config):
""" Initialise the plugin.
Args:
config: JSON configuration document for the plugin configuration category
Returns:
handle: JSON object to be used in future calls to the plugin
Raises:
"""
handle = copy.deepcopy(config)
i2c = I2cController()
i2c.set_retry_count(int(handle['i2cRetry']['value']))
i2c.configure(handle['i2cURL']['value'])
handle['am2315'] = am2315.AM2315(i2c)
handle['ina219'] = ina219.INA219(i2c)
handle['mma8451'] = mma8451.MMA8451(i2c)
handle['temperatureModCount'] = 0
handle['humidityModCount'] = 0
handle['currentModCount'] = 0
handle['accelerationModCount'] = 0
return handle
def plugin_init(config):
""" Initialise the plugin.
Args:
config: JSON configuration document for the plugin configuration category
Returns:
handle: JSON object to be used in future calls to the plugin
Raises:
"""
handle = copy.deepcopy(config)
# using wind_sensors/i2c.py
# handle['i2c']=i2c.I2CCommunication()
i2c = I2cController()
i2c.set_retry_count(int(handle['i2c_retry']['value']))
i2c.configure(handle['ftdi_url']['value'])
handle['am2315'] = am2315.AM2315(i2c)
handle['ina219'] = ina219.INA219(i2c)
handle['mma8451'] = mma8451.MMA8451(i2c)
return handle
if os.getenv("VIRTUAL_ENV") == None:
print("Please activate your virtual environment then re-run script")
exit(0)
# Ensure platform info is sourced
if os.getenv("PLATFORM") == None:
print("Please source your platform info then re-run script")
exit(0)
# Ensure platform is usb-to-i2c enabled
if os.getenv("IS_USB_I2C_ENABLED") != "true":
print("Platform is not usb-to-i2c enabled")
exit(0)
# Initialize i2c instance
i2c_controller = I2cController()
i2c_controller.configure("ftdi://ftdi:232h/1")
i2c_address = int(sys.argv[1])
print("Using I2C address {}".format(i2c_address))
# Get the device at that address
slave = i2c_controller.get_port(i2c_address)
# I2C command to write
LED_off = b"L,0"
cmd = LED_off
# Write to the device
print("Sending {}".format(cmd))
slave.write(cmd)
def test(self):
self._i2c = I2cController()
self._open()
self._read()
self._close()
def test(self):
self._i2c = I2cController()
self._open()
self._read_it()
self._write_it()
self._close()
def test(self):
self._i2c = I2cController()
url = environ.get('FTDI_DEVICE', 'ftdi:///1')
self._i2c.configure(url, clockstretching=True)
gpio = self._i2c.get_gpio()
self.assertRaises(I2cIOError, gpio.set_direction, 1 << 7, 0)
def test(self):
self._i2c = I2cController()
self._open()
self._execute_sequence()
self._execute_interleave()
self._close()
