def _get_connection(self, connection_type, device_path):
if connection_type == 'usb_serial':
if device_path is not None:
return serial.Serial(device_path)
elif sys.argv[1] == 'uart':
# FT232H, D0 <-> PA9, USART1_TX
# FT232H, D1 <-> PA10, USART1_RX
return serial.Serial('/dev/ttyUSB0', baudrate=115200)
elif FT232H_ENABLED and sys.argv[1] == 'spi':
FT232H.use_FT232H()
self.ft232h = FT232H.FT232H()
# FT232H, D0 <-> PB13, SCK
# FT232H, D1 <-> PB15, MOSI
# FT232H, D2 <-> PB14, MISO
# FT232H, C8 <-> PB12, NSS
return FT232H.SPI(self.ft232h,
cs=8,
max_speed_hz=1000000,
mode=0,
bitorder=FT232H.MSBFIRST)
elif FT232H_ENABLED and sys.argv[1] == 'i2c':
# FT232H, D0, pullup <-> PB10, I2C2_SCL
# FT232H, D1 + D2 tied together, pullup <-> PB9, I2C2_SDA
FT232H.use_FT232H()
self.ft232h = FT232H.FT232H()
return FT232H.I2CDevice(self.ft232h, 0x15)
def i2c_scan():
if FT232H_ENABLED:
for address in range(127):
if address <= 7 or address >= 120:
continue
i2c = FT232H.I2CDevice(ft232h, address)
if i2c.ping():
print('Found I2C device at address 0x{0:02X}'.format(address))
def init_imu():
#check if the Accel/Mag is there
#-set i2c to point at accelerometer & Mag
i2c = FT232H.I2CDevice(ft232h, XM.ADDRESS)
check = i2c.readU8(XM.WHO_AM_I)
if check != XM.WHO_AM_I_OK:
print "ACCEL INIT FAIL..."
return 1
#check if the GYRO is there
#-set i2c to point at XM
i2c = FT232H.I2CDevice(ft232h, GYRO.ADDRESS)
check = i2c.readU8(GYRO.WHO_AM_I)
if check != GYRO.WHO_AM_I_OK:
print "GYRO INIT FAIL..."
return 1
#success!
return 0
def __init__(self, address=MAX2484_I2C_ADDR_DEFAULT, i2c=None, **kwargs):
"""initialize MAX2484 on the specified address, """
self._logger = logging.getLogger('MAX2484')
if i2c == None:
import Adafruit_GPIO.FT232H as FT232H
FT232H.use_FT232H()
ft232h = FT232H.FT232H()
self._device = FT232H.I2CDevice(ft232h, address, **kwargs)
self.roms = []
def configGyro(fullScale="245DPS"):
i2c = FT232H.I2CDevice(ft232h, GYRO.ADDRESS)
i2c.write8(GYRO.CTRL_REG1_G, 0x0F) #normal mode, all axes
#set gyro scale
scaleVal = GYRO.RANGE_G[fullScale]
regVal = 0x00 | scaleVal
i2c.write8(GYRO.CTRL_REG4_G, regVal)
print regVal
return 0
def __init__(self, i2cBus, address=SHT_ADDR):
self.address = address
# Initialise the I2C instance for the sensor -
# default is first FT232H instance but when muxing will be different
self._device = ft.I2CDevice(i2cBus, address)
time.sleep(0.002)
if not (self._device.ping()):
print("Problem accessing device at " + hex(address))
def __init__(self, address=MCP4725_I2C_ADDR_DEFAULT, i2c=None, debug = False, **kwargs):
"""initialize MCP4725 on the specified address, """
self._logger = logging.getLogger('MCP4725')
if i2c == None:
import Adafruit_GPIO.FT232H as FT232H
FT232H.use_FT232H()
ft232h = FT232H.FT232H()
self._device = FT232H.I2CDevice(ft232h, address, **kwargs)
self.address = address
self.debug = debug
def configAccel(rate="100HZ", fullScale="2G"):
#-set i2c to point at accelerometer & Mag
i2c = FT232H.I2CDevice(ft232h, XM.ADDRESS)
#set accel data to 100Hz and enable all axes
i2c.write8(XM.CTRL_REG1_XM, 0b01101111) #0x67) #0b01010111) #0b01100111)
#set the accel scale
scaleVal = XM.RANGE_A[fullScale]
regVal = 0x00 | scaleVal
i2c.write8(XM.CTRL_REG2_XM, regVal)
return 0
def run(self):
for address in range(127):
if address <= 7 or address >= 120:
continue
i2c = FT232H.I2CDevice(self.ft232h, address)
if i2c.ping():
self.count = self.count + 1
self.emit(SIGNAL('I2c_device_found(int)'), address)
self.emit(SIGNAL('I2c_device_found(int)'), self.count + 1000)
print("[*] Terminating I2C Scanner Thread ")
self.terminate()
def __init__(self, serial_no=None):
"""Constructor.
Args:
serial_no: str. The serial number of the FTDI adapter.
"""
# Temporarily disable FTDI serial drivers.
FT232H.use_FT232H()
# Find the first FT232H device.
self.ft232h_ = FT232H.FT232H(serial=serial_no)
# GPIO pin assignment.
self.ft232h_.setup(self.OUTPUT_ENABLE_PIN, GPIO.OUT)
self.ft232h_.setup(self.RESET_PIN, GPIO.OUT)
self.Reset()
# Create I2C devices for PCA9698.
self.i2c0_ = FT232H.I2CDevice(self.ft232h_, 0x20)
self.i2c1_ = FT232H.I2CDevice(self.ft232h_, 0x21)
self.i2c2_ = FT232H.I2CDevice(self.ft232h_, 0x22)
self.i2c3_ = FT232H.I2CDevice(self.ft232h_, 0x26)
self.i2c_ = [self.i2c0_, self.i2c1_, self.i2c2_, self.i2c3_]
self.booted = False
# Set output pins
self.i2c0_.write8(self.REG_IOC0, 0x00) # rs1[7:0]
self.i2c0_.write8(self.REG_IOC1, 0x00) # rs1[15:8]
self.i2c2_.write8(self.REG_IOC0, 0x00) # rs1[23:16]
self.i2c2_.write8(self.REG_IOC1, 0x00) # rs1[31:24]
self.i2c1_.write8(self.REG_IOC0, 0x00) # rs2[7:0]
self.i2c1_.write8(self.REG_IOC1, 0x00) # rs2[15:8]
self.i2c3_.write8(self.REG_IOC0, 0x00) # rs2[23:16]
self.i2c3_.write8(self.REG_IOC1, 0x00) # rs2[31:24]
# Set function pins.
self.i2c1_.write8(self.REG_IOC4, 0xf0) # f[3:0]
def configMag(rate="100HZ", fullScale="4GAUSS"):
#-set i2c to point at accelerometer & Mag
i2c = FT232H.I2CDevice(ft232h, XM.ADDRESS)
#set magnetometer to 100Hz
i2c.write8(XM.CTRL_REG5_XM, 0xF4)
#Range 4GAUSS
i2c.write8(XM.CTRL_REG6_XM, 0x20)
i2c.write8(XM.CTRL_REG7_XM, 0x00)
#set the accel scale
scaleVal = XM.RANGE_M[fullScale]
regVal = 0x00 | scaleVal
i2c.write8(XM.CTRL_REG2_XM, 0x00)
return 0
def getRotation(fullScale):
i2c = FT232H.I2CDevice(ft232h, GYRO.ADDRESS)
cal = GYRO.CAL_G[fullScale]
gx_L = i2c.readU8(0x28)
gx_H = i2c.readU8(0x29)
gy_L = i2c.readU8(0x2A)
gy_H = i2c.readU8(0x2B)
gz_L = i2c.readU8(0x2C)
gz_H = i2c.readU8(0x2D)
gx = np.int16(gx_L | (gx_H << 8)) * cal
gy = np.int16(gy_L | (gy_H << 8)) * cal
gz = np.int16(gz_L | (gz_H << 8)) * cal
return (gx, gy, gz)
def getMag(fullScale):
i2c = FT232H.I2CDevice(ft232h, XM.ADDRESS)
cal = XM.CAL_M[fullScale]
mx_L = i2c.readU8(0x08)
mx_H = i2c.readU8(0x09)
my_L = i2c.readU8(0x0A)
my_H = i2c.readU8(0x0B)
mz_L = i2c.readU8(0x0C)
mz_H = i2c.readU8(0x0D)
mx = np.int16(mx_L | (mx_H << 8)) * cal
my = np.int16(my_L | (my_H << 8)) * cal
mz = np.int16(mz_L | (mz_H << 8)) * cal
return (mx, my, mz)
def getAccel(fullScale):
i2c = FT232H.I2CDevice(ft232h, XM.ADDRESS)
cal = XM.CAL_A[fullScale]
ax_L = i2c.readU8(0x28)
ax_H = i2c.readU8(0x29)
ay_L = i2c.readU8(0x2A)
ay_H = i2c.readU8(0x2B)
az_L = i2c.readU8(0x2C)
az_H = i2c.readU8(0x2D)
ax = np.int16(ax_L | (ax_H << 8)) * cal
ay = np.int16(ay_L | (ay_H << 8)) * cal
az = np.int16(az_L | (az_H << 8)) * cal
return (ax, ay, az)
def __init__(self, slave_addr=0x68):
FT232H.use_FT232H()
self.ft232h = FT232H.FT232H()
self.init_gpio()
self.i2c = FT232H.I2CDevice(self.ft232h, slave_addr)
self.time_value = {
'sec': 0,
'min': 0,
'hour': 0,
'12hour': False,
'AM': False,
'date': 0,
'weekday': 1,
'month': 1,
'year': 2000
}
from Adafruit_GPIO import GPIO
# Temporarily disable FTDI serial drivers.
FT232H.use_FT232H()
# Find the first FT232H device.
ft232h = FT232H.FT232H()
ft232h.setup(12, GPIO.OUT)
ft232h.setup(13, GPIO.OUT)
ft232h.setup(14, GPIO.OUT)
ft232h.setup(15, GPIO.OUT)
ft232h.output(12, GPIO.HIGH)
ft232h.output(14, GPIO.HIGH)
ft232h.output(13, GPIO.LOW)
ft232h.output(15, GPIO.HIGH)
print 'Scanning all I2C bus addresses...'
# Enumerate all I2C addresses.
for address in range(127):
# Skip I2C addresses which are reserved.
if address <= 7 or address >= 120:
continue
# Create I2C object.
i2c = FT232H.I2CDevice(ft232h, address)
# Check if a device responds to this address.
if i2c.ping():
print 'Found I2C device at address 0x{0:02X}'.format(address)
print 'Done!'
def __init__(self, ft232h, address=0x18):
self.i2c = FT232H.I2CDevice(ft232h, address)
self.buffer = bytearray(6)
# Reboot
self.i2c.write8(_REG_CTRL5, 0x80)
time.sleep(0.01) # takes 5ms
# Enable all axes, normal mode.
self.i2c.write8(_REG_CTRL1, 0x07)
# Set 400Hz data rate.
self.data_rate = DATARATE_400_HZ
# High res & BDU enabled.
self.i2c.write8(_REG_CTRL4, 0x88)
# Enable ADCs.
self.i2c.write8(_REG_TEMPCFG, 0x80)
# Latch interrupt for INT1
self.i2c.write8(_REG_CTRL5, 0x08)
self.i2c.write8(0, 0)
self.i2c.write8(1, 0)
self.i2c.write8(2, 0)
self.i2c.write8(3, 0)
self.i2c.write8(4, 0)
self.i2c.write8(5, 0)
self.i2c.write8(6, 0)
self.i2c.write8(7, 255)
self.i2c.write8(8, 0)
self.i2c.write8(9, 125)
self.i2c.write8(10, 128)
self.i2c.write8(11, 32)
self.i2c.write8(12, 0)
self.i2c.write8(13, 192)
self.i2c.write8(14, 0)
self.i2c.write8(15, 51)
self.i2c.write8(16, 26)
self.i2c.write8(17, 78)
self.i2c.write8(18, 52)
self.i2c.write8(19, 33)
self.i2c.write8(20, 162)
self.i2c.write8(21, 32)
self.i2c.write8(22, 36)
self.i2c.write8(23, 33)
self.i2c.write8(24, 34)
self.i2c.write8(25, 161)
self.i2c.write8(26, 128)
self.i2c.write8(27, 132)
self.i2c.write8(28, 192)
self.i2c.write8(29, 0)
self.i2c.write8(30, 16)
self.i2c.write8(31, 128)
self.i2c.write8(32, 119)
self.i2c.write8(33, 0)
self.i2c.write8(34, 0)
self.i2c.write8(35, 136)
self.i2c.write8(36, 8)
self.i2c.write8(37, 0)
self.i2c.write8(38, 0)
self.i2c.write8(39, 255)
self.i2c.write8(40, 128)
self.i2c.write8(41, 254)
self.i2c.write8(42, 32)
self.i2c.write8(43, 1)
self.i2c.write8(44, 208)
self.i2c.write8(45, 60)
self.i2c.write8(46, 0)
self.i2c.write8(47, 32)
self.i2c.write8(48, 0)
self.i2c.write8(49, 0)
self.i2c.write8(50, 0)
self.i2c.write8(51, 0)
self.i2c.write8(52, 0)
self.i2c.write8(53, 0)
self.i2c.write8(54, 0)
self.i2c.write8(55, 0)
self.i2c.write8(56, 0)
self.i2c.write8(57, 0)
self.i2c.write8(58, 0)
self.i2c.write8(59, 0)
self.i2c.write8(60, 0)
self.i2c.write8(61, 0)
self.i2c.write8(62, 0)
self.i2c.write8(63, 0)
self.i2c.write8(64, 0)
self.i2c.write8(65, 0)
self.i2c.write8(66, 0)
self.i2c.write8(67, 0)
self.i2c.write8(68, 0)
self.i2c.write8(69, 0)
self.i2c.write8(70, 0)
self.i2c.write8(71, 0)
self.i2c.write8(72, 0)
self.i2c.write8(73, 0)
self.i2c.write8(74, 0)
self.i2c.write8(75, 0)
self.i2c.write8(76, 0)
self.i2c.write8(77, 0)
self.i2c.write8(78, 0)
self.i2c.write8(79, 0)
self.i2c.write8(80, 0)
self.i2c.write8(81, 0)
self.i2c.write8(82, 0)
self.i2c.write8(83, 0)
self.i2c.write8(84, 0)
self.i2c.write8(85, 0)
self.i2c.write8(86, 0)
self.i2c.write8(87, 0)
self.i2c.write8(88, 0)
self.i2c.write8(89, 0)
self.i2c.write8(90, 0)
self.i2c.write8(91, 0)
self.i2c.write8(92, 0)
self.i2c.write8(93, 0)
self.i2c.write8(94, 0)
self.i2c.write8(95, 0)
self.i2c.write8(96, 0)
self.i2c.write8(97, 0)
self.i2c.write8(98, 0)
self.i2c.write8(99, 0)
self.i2c.write8(100, 0)
self.i2c.write8(101, 0)
self.i2c.write8(102, 0)
self.i2c.write8(103, 0)
self.i2c.write8(104, 0)
self.i2c.write8(105, 0)
self.i2c.write8(106, 0)
self.i2c.write8(107, 0)
self.i2c.write8(108, 0)
self.i2c.write8(109, 0)
self.i2c.write8(110, 0)
self.i2c.write8(111, 0)
self.i2c.write8(112, 0)
self.i2c.write8(113, 0)
self.i2c.write8(114, 0)
self.i2c.write8(115, 0)
self.i2c.write8(116, 0)
self.i2c.write8(117, 0)
self.i2c.write8(118, 0)
self.i2c.write8(119, 0)
self.i2c.write8(120, 0)
self.i2c.write8(121, 0)
self.i2c.write8(122, 0)
self.i2c.write8(123, 0)
self.i2c.write8(124, 0)
self.i2c.write8(125, 0)
self.i2c.write8(126, 0)
self.i2c.write8(127, 0)
self.i2c.write8(128, 0)
self.i2c.write8(129, 0)
self.i2c.write8(130, 0)
self.i2c.write8(131, 0)
self.i2c.write8(132, 0)
self.i2c.write8(133, 0)
self.i2c.write8(134, 0)
self.i2c.write8(135, 255)
self.i2c.write8(136, 0)
self.i2c.write8(137, 249)
self.i2c.write8(138, 64)
self.i2c.write8(139, 186)
self.i2c.write8(140, 128)
self.i2c.write8(141, 39)
self.i2c.write8(142, 0)
self.i2c.write8(143, 51)
self.i2c.write8(144, 26)
self.i2c.write8(145, 78)
self.i2c.write8(146, 52)
self.i2c.write8(147, 33)
self.i2c.write8(148, 162)
self.i2c.write8(149, 32)
self.i2c.write8(150, 36)
self.i2c.write8(151, 33)
self.i2c.write8(152, 34)
self.i2c.write8(153, 161)
self.i2c.write8(154, 128)
self.i2c.write8(155, 132)
self.i2c.write8(156, 192)
self.i2c.write8(157, 0)
self.i2c.write8(158, 16)
self.i2c.write8(159, 128)
self.i2c.write8(160, 119)
self.i2c.write8(161, 0)
self.i2c.write8(162, 0)
self.i2c.write8(163, 136)
self.i2c.write8(164, 8)
self.i2c.write8(165, 0)
self.i2c.write8(166, 0)
self.i2c.write8(167, 255)
self.i2c.write8(168, 128)
self.i2c.write8(169, 254)
self.i2c.write8(170, 0)
self.i2c.write8(171, 1)
self.i2c.write8(172, 176)
self.i2c.write8(173, 60)
self.i2c.write8(174, 0)
self.i2c.write8(175, 32)
self.i2c.write8(176, 0)
self.i2c.write8(177, 0)
self.i2c.write8(178, 0)
self.i2c.write8(179, 0)
self.i2c.write8(180, 0)
self.i2c.write8(181, 0)
self.i2c.write8(182, 0)
self.i2c.write8(183, 0)
self.i2c.write8(184, 0)
self.i2c.write8(185, 0)
self.i2c.write8(186, 0)
self.i2c.write8(187, 0)
self.i2c.write8(188, 0)
self.i2c.write8(189, 0)
self.i2c.write8(190, 0)
self.i2c.write8(191, 0)
self.i2c.write8(192, 0)
self.i2c.write8(193, 0)
self.i2c.write8(194, 0)
self.i2c.write8(195, 0)
self.i2c.write8(196, 0)
self.i2c.write8(197, 0)
self.i2c.write8(198, 0)
self.i2c.write8(199, 0)
self.i2c.write8(200, 0)
self.i2c.write8(201, 0)
self.i2c.write8(202, 0)
self.i2c.write8(203, 0)
self.i2c.write8(204, 0)
self.i2c.write8(205, 0)
self.i2c.write8(206, 0)
self.i2c.write8(207, 0)
self.i2c.write8(208, 0)
self.i2c.write8(209, 0)
self.i2c.write8(210, 0)
self.i2c.write8(211, 0)
self.i2c.write8(212, 0)
self.i2c.write8(213, 0)
self.i2c.write8(214, 0)
self.i2c.write8(215, 0)
self.i2c.write8(216, 0)
self.i2c.write8(217, 0)
self.i2c.write8(218, 0)
self.i2c.write8(219, 0)
self.i2c.write8(220, 0)
self.i2c.write8(221, 0)
self.i2c.write8(222, 0)
self.i2c.write8(223, 0)
self.i2c.write8(224, 0)
self.i2c.write8(225, 0)
self.i2c.write8(226, 0)
self.i2c.write8(227, 0)
self.i2c.write8(228, 0)
self.i2c.write8(229, 0)
self.i2c.write8(230, 0)
self.i2c.write8(231, 0)
self.i2c.write8(232, 0)
self.i2c.write8(233, 0)
self.i2c.write8(234, 0)
self.i2c.write8(235, 0)
self.i2c.write8(236, 0)
self.i2c.write8(237, 0)
self.i2c.write8(238, 0)
self.i2c.write8(239, 0)
self.i2c.write8(240, 0)
self.i2c.write8(241, 0)
self.i2c.write8(242, 0)
self.i2c.write8(243, 0)
self.i2c.write8(244, 0)
self.i2c.write8(245, 0)
self.i2c.write8(246, 0)
self.i2c.write8(247, 0)
self.i2c.write8(248, 0)
self.i2c.write8(249, 0)
self.i2c.write8(250, 0)
self.i2c.write8(251, 0)
self.i2c.write8(252, 0)
self.i2c.write8(253, 0)
self.i2c.write8(254, 0)
self.i2c.write8(255, 0)
device_id = self._read_register_byte(_REG_WHOAMI)
if device_id != 0x33:
raise RuntimeError("Failed to find LIS3DH!")
def __init__(self, i2c, address=_DEFAULT_ADDRESS):
self.i2c = i2c
self.address = address
self.channels = [None]*8
self.tca_device = ft.I2CDevice(i2c, address)
def __init__(self, ft232h, address=224):
self.i2c = FT232H.I2CDevice(ft232h, 225 >> 1)
self.i2c.ping
self.start_sensor(address)
import Adafruit_GPIO.FT232H as FT232H
import time
# Temporarily disable FTDI serial drivers.
FT232H.use_FT232H()
# Find the first FT232H device.
ft232h = FT232H.FT232H()
# Create an I2C device at address 0x70.
i2c = FT232H.I2CDevice(ft232h, 0x30)
X_Axis_Register_DATAX0 = 0x00
X_Axis_Register_DATAX1 = 0x01
Inter_control_0 = 0x1b
while True:
i2c.write8(Inter_control_0, 1)
X0 = i2c.readU8(X_Axis_Register_DATAX0)
X1 = i2c.readU8(X_Axis_Register_DATAX1)
r = (X0 << 8) + X1
Gauss = (r / (65536.0) - 0.5) * 60.0
print("x1 =", X0, "x2 = ", X1)
print('The measurement is', Gauss)
time.sleep(0.2)
# print 'Scanning all I2C bus addresses...'
# # Enumerate all I2C addresses.
# for address in range(127):
# # Skip I2C addresses which are reserved.
# if address <= 7 or address >= 120:
# continue
# # Create I2C object.
# i2c = FT232H.I2CDevice(ft232h, address)
# # Check if a device responds to this address.
# if i2c.ping():
# print 'Found I2C device at address 0x{0:02X}'.format(address)
#
#
# print 'Done!'
gyro = FT232H.I2CDevice(ft232h,L3G_I2C_ADDR)
whoAmI = gyro.readU8(L3G_WHO_AM_I)
format(whoAmI,'02x')
print (bin(whoAmI))
gyro.write8(L3G_CTRL_REG2, 0x00)
gyro.write8(L3G_CTRL_REG3, 0x00)
gyro.write8(L3G_CTRL_REG4, 0x20)
gyro.write8(L3G_CTRL_REG5, 0x02)
gyro.write8(L3G_CTRL_REG1, 0x8F)
# xVal1 = gyro.readU8(L3G_OUT_X_L | READ)
# xVal2 = gyro.readU8(L3G_OUT_X_L+1 | READ)
#
# print bin(xVal1),",",bin(xVal2)
def i2c_write_test():
if FT232H_ENABLED:
i2c = FT232H.I2CDevice(ft232h, 0x15)
i2c.writeRaw8(0xED)
def __init__(self, slave_addr=0x27):
FT232H.use_FT232H()
self.ft232h = FT232H.FT232H()
self.init_gpio()
self.i2c = FT232H.I2CDevice(self.ft232h, slave_addr)
self.lcd_init()
def __init__(self, ft232h, address=112):
self.i2c = FT232H.I2CDevice(ft232h, 112)
#self.i2c.ping()
"""
#!/usr/bin/python2.7
import Adafruit_GPIO.FT232H as FT232H
from numpy import uint16
CHG_ADDR = 0x12
BAT_ADDR = 0x16
FT232H.use_FT232H()
ft232h = FT232H.FT232H()
chg = FT232H.I2CDevice(ft232h, CHG_ADDR >> 1, clock_hz=100000)
bat = FT232H.I2CDevice(ft232h, BAT_ADDR >> 1, clock_hz=10000)
# Bits Specs
class Bits:
def __init__(self, bitname, lsb=0, mask=0xFFFF, description='', option=''):
self.name = bitname
self.lsb = lsb
self.mask = mask
self.desc = description
self.opt = option
### Smart Battery Registers ###
class SB:
def __init__(self, name, address, unit=''):
self.name = name
self.addr = address
self.unit = unit
def i2c_read_test():
if FT232H_ENABLED:
i2c = FT232H.I2CDevice(ft232h, 0x15)
return i2c.readRaw8()
