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()