def __init__(self, drvsel, ps=True, als=True, address=DEFAULT_I2C_ADDR, clk=100000):
self.port = i2c.I2C(drvsel, address, clk)
self.port.start()
if ps:
self.configure_proximity_sensor(DEFAULT_PS_CONF1, DEFAULT_PS_CONF2, DEFAULT_PS_CONF3)
if als:
self.configure_ambient_light_sensor(DEFAULT_ALS_CONF)
def __init__(self, address):
self.address = address
self.lcd = i2c.I2C(address)
time.sleep(.2)
self.set_iocon(0x20) # turn of sequential increment on MCP23008
self.set_io(0x00) # set pins on MCP23008 to output
self.lcd_command(0x03) # start initialization of lcd as described in datasheet
time.sleep(0.005)
self.lcd_command(0x03)
time.sleep(0.0002)
self.lcd_command(0x03)
time.sleep(0.0002)
self.lcd_command(0x02)
time.sleep(.05)
self.lcd_command(0x28) # set 4 bit, 2 lines
self.lcd_command(0x08) # no shift, hide cursor
self.lcd_command(0x01) # clear display
self.lcd_command(0x06) # cursor increment - right
self.lcd_command(0x0F) # turn on display - no cursor
self.lcd_command(0x80) # DDRAM address
def _init_MPU9250(self, drvname, addr, clk):
if (addr != 0x68 and addr != 0x69):
raise ValueError
self.lockI2C.acquire()
self.mpu9250 = i2c.I2C(drvname, addr, clk)
try:
self.mpu9250.start()
except PeripheralError as e:
print(e)
# Check MPU9250 Who Am I Register
if (self.mpu9250.write_read(MPU9250_WHO_AM_I, n=1)[0] !=
MPU9250_WHOAMI):
raise ValueError
self.lockI2C.release()
# Set Clock source
self.set_clock_source(1)
# Set scales
self.set_accel_fullscale(2)
self.set_gyro_fullscale(2000)
# Set dlpf mode
self.set_dlpf_mode(0)
# Disable Sleep Mode
self.set_sleep_mode(False)
# Enable config magnetometer
self.lockI2C.acquire()
self.mpu9250.write_bytes(INT_PIN_CFG, 0x02)
self.lockI2C.release()
def _init_AK8963(self, drvname, addr, clk):
if (addr != 0x0C):
raise ValueError
self.lockI2C.acquire()
self.ak8963 = i2c.I2C(drvname, addr, clk)
try:
self.ak8963.start()
except PeripheralError as e:
print(e)
# Check AK8963 Who Am I Register
if (self.ak8963.write_read(AK8963_WHO_AM_I, n=1)[0] != AK8963_WHOAMI):
raise ValueError
# set power down mode
self.ak8963.write_bytes(AK8963_CNTL1, 0x00)
# set read FuseROM mode
self.ak8963.write_bytes(AK8963_CNTL1, 0x0F)
# read coef data
data = self.ak8963.write_read(AK8963_ASAX, n=3)
self.magXcoef = (data[0] - 128) / 256.0 + 1.0
self.magYcoef = (data[1] - 128) / 256.0 + 1.0
self.magZcoef = (data[2] - 128) / 256.0 + 1.0
self.lockI2C.release()
self.set_magneto_config()
def __init__(self, drvname, addr):
self.port = i2c.I2C(drvname, addr)
self.addr = addr
try:
self.port.start()
except PeripheralError as e:
print(e)
def __init__(self, addr=MPU6050_I2CADDR, clk=400000):
self.portI2C = i2c.I2C(
I2C0, addr
) #Declared port i2c ex. I2C0 on the board connected with 0x68, the i2c address of the sensor SDA on D25 n SCL on D26,
try:
self.portI2C.start()
print('initialized')
except Exception as e:
print(e)
self.setup()
def mpu6050Init(i2cPort=I2C0):
mpuPort = i2c.I2C(i2cPort, 0x68)
try:
mpuPort.start()
print("Mpu initialized")
mpuPort.write([0x6B, 0x80]) #dev reset
print("Mpu resetted")
mpuPort.write([0x6B, 0x00]) #wakes up mpu
print("Mpu init done")
return mpuPort
except PeripheralError as e:
print(e)
def init():
global portI2C
portI2C = i2c.I2C(
I2C0, 0x68
) #Declared port I2C0 on the board connected with 0x68, the i2c address of the sensor SDA on D25 n SCL on D26,
try:
portI2C.start()
print('initialized')
portI2C.write([0x6B, 0b10000000]) #dev reset
print('dev reset')
portI2C.write([0x6B, 0x00]) #Wake up MPU
print('done!')
except PeripheralError as e:
print(e)
def __init__(self, filename=None, debug_enable=False):
# check input filename
if filename == None:
self._assert('Incorrect filename!')
self.filename = filename
self.debug_enable = debug_enable
# create an empty dictionary
self.memtable = {}
if self.debug_enable:
self.logname = r"~test.log"
self.log = file(self.logname, 'w')
# load I2C Library
self.i2c = i2c.I2C()
# open Internal MemoryMap
self._open()
def __init__(self, nysa, urn, debug=False):
super(SFCamera, self).__init__(nysa, urn, debug)
#print "Camera URN : %s" % urn
i2c_urn = self.get_integration_references(self.urn)[0]
#print "i2c: URN: %s" % i2c_urn
self.i2c = i2c.I2C(nysa, i2c_urn, debug=debug)
self.i2c.enable_i2c(True)
self.i2c.enable_interrupt(True)
self.i2c.get_status()
self.i2c.set_speed_to_100khz()
self.reset_camera()
self.set_rgb_mode()
self.reset_counts()
time.sleep(.4)
row_count = self.read_row_count()
pixel_count = self.read_pixel_count()
size = row_count * pixel_count
self.width = pixel_count / 2
self.height = row_count
self.status = 0
try:
self.dma_reader = DMAReadController(
device=self,
mem_base0=0x00000000,
mem_base1=0x00100000,
size=size / 4,
reg_status=STATUS,
reg_base0=MEM_0_BASE,
reg_size0=MEM_0_SIZE,
reg_base1=MEM_1_BASE,
reg_size1=MEM_1_SIZE,
timeout=3,
finished0=STATUS_MEMORY_0_FINISHED,
finished1=STATUS_MEMORY_1_FINISHED,
empty0=STATUS_MEMORY_0_EMPTY,
empty1=STATUS_MEMORY_1_EMPTY)
except NysaDMAException as ex:
raise SFCameraError("Error initializing the DMA Reader: %s" %
str(ex))
def __init__(self, drvsel, address=0x48, clk=400000):
self.port = i2c.I2C(drvsel, address, clk)
self.odr = ODR_AVAILABLE["ODR_125mHz"]
self.resolution = STTS751_RES_12
self.low_th = 1
self.high_th = 50
self.int_enable = False
self.therm_limit = 0
self.therm_hyst_limit = 0
self.timeout = False
try:
self.port.start()
except PeripheralError as e:
print(e)
self.enable(self.odr, self.resolution)
self.set_low_temp_threshold(self.low_th)
self.set_high_temp_threshold(self.high_th)
self.set_event_interrupt(True)
self.set_timeout(False)
self.therm_limit = self._read(REG_THERM, 1)[0]
self.therm_hyst_limit = self._read(REG_THERM_HYSTERESIS, 1)[0]
def __init__(self, drvsel, int_pin, address=0x5F, clk=400000):
self.port = i2c.I2C(drvsel, address, clk)
self.H0_T0_OUT = 0
self.H1_T0_OUT = 0
self.T0_OUT = 0
self.T1_OUT = 0
self.T0_DegC_cal = 0.0
self.T1_DegC_cal = 0.0
self.H0_RH_cal = 0.0
self.H1_RH_cal = 0.0
self.int_pin = int_pin
try:
self.port.start()
except PeripheralError as e:
print(e)
pinMode(int_pin, INPUT)
self._write(0x10, 0x1B)
self._write(0x20, 0x85)
self._write(0x21, 0x00)
self._write(0x22, 0x00)
self._calibrate()
def __init__(self,
angle_fr=-135,
angle_to=135,
step=5,
outer=240,
inner=200,
min_t=15,
max_t=35,
shader=None,
camera=None):
self.angle_fr = angle_fr
self.angle_to = angle_to
self.step = step
self.outer = outer
self.inner = inner
self.mid = (outer + inner) / 2
self.min_t = min_t
self.max_t = max_t
gpio.setmode(gpio.BCM)
gpio.setwarnings(False)
gpio.setup(26, gpio.IN, pull_up_down=gpio.PUD_DOWN)
self.bus = i2c.I2C(2)
try:
self.bus.read(1, 0x5c)
self.bus.write([0x6e, 0b00001110], 0x5c)
self.bus.write([0x70, 0b00000000], 0x5c)
except:
print('Error: no touchscreen found')
tick_verts = []
dial_verts = []
# first make tick vertices
for x in range(self.angle_fr, self.angle_to, self.step):
(s, c) = (sin(radians(x)), cos(radians(x))
) # re-use for brevity below
tick_verts.extend([(self.inner * s, self.inner * c, 0.1),
(self.outer * s, self.outer * c, 0.1)])
dial_verts.append((self.mid * s, self.mid * c, 2.0))
if shader is None:
shader = pi3d.Shader('mat_flat')
if camera is None:
camera = pi3d.Camera(is_3d=False)
uv_shader = pi3d.Shader('uv_flat')
tex = pi3d.Texture('color_gradient.jpg')
self.ticks = pi3d.PolygonLines(camera=camera,
vertices=tick_verts,
strip=False,
line_width=5)
self.ticks.set_shader(shader)
self.ticks.set_alpha(0.8)
self.sensorticks = pi3d.PolygonLines(camera=camera,
vertices=tick_verts,
line_width=5,
strip=False)
self.sensorticks.set_shader(shader)
self.bline = pi3d.PolygonLines(camera=camera,
vertices=dial_verts,
line_width=40)
self.bline.set_textures([tex])
self.bline.set_alpha(0.8)
self.bline.set_shader(uv_shader)
self.bline.set_material((0.5, 0.5, 0.5))
self.dial = pi3d.PolygonLines(camera=camera,
vertices=dial_verts,
line_width=8)
self.dial.set_alpha(0.2)
self.dial.set_shader(shader)
font = pi3d.Font('opensans.ttf',
codepoints='0123456789.-°',
grid_size=5)
self.actval = pi3d.PointText(font,
camera,
max_chars=10,
point_size=100)
self.temp_block = pi3d.TextBlock(0,
0,
0.1,
0.0,
6,
justify=0.5,
text_format="0°",
size=0.79,
spacing="F",
space=0.02,
colour=(1.0, 1.0, 1.0, 1.0))
self.actval.add_text_block(self.temp_block)
self.dot2 = pi3d.Disk(radius=20, sides=20, z=0.1, rx=90, camera=camera)
self.dot2.set_shader(shader)
self.dot2.set_material((1, 1, 1))
self.dot2_alpha = 1.0
self.value = 25.0
self.sensorvalue = 18.0
degree = (self.angle_fr + (self.angle_to - self.angle_fr) *
(self.value - self.min_t) / (self.max_t - self.min_t))
self.x1 = self.mid * sin(radians(degree))
self.y1 = self.mid * cos(radians(degree))
def __init__(self, dev, base):
self.dac = i2c.I2C(dev, base + self.i2c_map['DAC'], 0x60)
self.ioexpander = i2c.I2C(dev, base + self.i2c_map['DAC'], 0x20)
'''
12 RFP circuits on 4 i2c buses. Slave address set by ADDR pin connection:
GND: 1001000
VDD: 1001001
SDA: 1001010 (not used)
SCL: 1001011
'''
self.rfp = []
self.rfp.append(i2c.I2C(dev, base + self.i2c_map['RFP_0'], 0x49))
self.rfp.append(i2c.I2C(dev, base + self.i2c_map['RFP_0'], 0x48))
self.rfp.append(i2c.I2C(dev, base + self.i2c_map['RFP_0'], 0x4B))
self.rfp.append(i2c.I2C(dev, base + self.i2c_map['RFP_1'], 0x49))
self.rfp.append(i2c.I2C(dev, base + self.i2c_map['RFP_1'], 0x48))
self.rfp.append(i2c.I2C(dev, base + self.i2c_map['RFP_1'], 0x4B))
self.rfp.append(i2c.I2C(dev, base + self.i2c_map['RFP_2'], 0x49))
self.rfp.append(i2c.I2C(dev, base + self.i2c_map['RFP_2'], 0x48))
self.rfp.append(i2c.I2C(dev, base + self.i2c_map['RFP_2'], 0x4B))
self.rfp.append(i2c.I2C(dev, base + self.i2c_map['RFP_3'], 0x49))
self.rfp.append(i2c.I2C(dev, base + self.i2c_map['RFP_3'], 0x48))
self.rfp.append(i2c.I2C(dev, base + self.i2c_map['RFP_3'], 0x4B))
def range_check(value):
if value > 100:
value = 100
elif value < 0:
value = 0
return value
screen = curses.initscr()
screen.refresh()
curses.cbreak()
screen.keypad(True)
value = 1
i2c = i2c.I2C()
pwm = controller.PWM()
v_min = v_max = 0
try:
screen.addstr('press any key to start')
key = 0
while (key != 27): #Escape key
key = screen.getch()
voltage = i2c.getVoltage()
if key == curses.KEY_UP:
value = value + 1
elif key == curses.KEY_RIGHT:
value = value + 10
def __init__(self, address):
"""
Sets the bus number and stores the address
"""
self.i2cfile = i2c.I2C(bus=I2C_BUS_NUM)
self.address = address
def my_init():
global port
port = i2c.I2C(I2C0, 0x40) #0x40 default address of htu21/sht21/si7021
port.start()
print('I2C PORT STARTED')
def setUp(self):
self.i2cdevice = i2c.I2C(1)
self.fr = None;
def write(self, bytes):
wasOpen = self._isOpen
if (not wasOpen):
self.open()
self.fw.write(bytes)
if (not wasOpen):
self.close()
def read(self, bytes):
wasOpen = self._isOpen
if (not wasOpen):
self.open()
string = self.fr.read(bytes)
if (not wasOpen):
self.close()
bytes = bytearray(string)
return bytes
if __name__ == "__main__":
import i2c
dev = i2c.I2C(0x49, 1)
dev.open()
dev.close()
data = dev.read(10)
print(data)
print(''.join('{:02x}'.format(x) for x in data))
