def _print_all(self):
for i in range(2):
if self._board_status[i]:
_print_gpio_registers(
I2C.get_i2c_device(self._gpio_addresses[i], self._bus))
_print_pwm_registers(
I2C.get_i2c_device(self._pwm_addresses[i], self._bus))
def get_i2c_device(address, i2c, i2c_bus):
"""
Helper method to get a device at the specified address from the I2C bus.
If no i2c bus is specified (i2c param is None) then the default I2C bus
for the platform will be used.
:param address:
i2c address to get the handle for
:type address:
hex
:param i2c:
GPIO i2c class, None to use the Adafruit_GPIO.I2C class
:param i2c_bus:
i2c bus number, passed to busnum, none to autodetect
:return:
i2c Address
"""
if i2c is not None:
return i2c.get_i2c_device(address)
else:
import Adafruit_GPIO.I2C as I2C
if i2c_bus is None:
return I2C.get_i2c_device(address)
else:
return I2C.get_i2c_device(address, busnum=i2c_bus)
def __init__(self,
width,
height,
rst,
gpio=1,
i2c_bus=1,
i2c_address=SSD1306_I2C_ADDRESS,
i2c=None):
self._i2c = None
self.width = width
self.height = height
self._pages = height // 8
self._buffer = [0] * (width * self._pages)
# Default to platform GPIO if not provided.
# Platform identification constants.
# UNKNOWN = 0
# RASPBERRY_PI = 1
self._gpio = gpio
# Setup reset pin.
self._rst = rst
if not self._rst is None:
self._gpio.setup(self._rst, GPIO.OUT)
if i2c_bus is None:
self._i2c = I2C.get_i2c_device(i2c_address)
else:
self._i2c = I2C.get_i2c_device(i2c_address, busnum=i2c_bus)
def __init__(self, busnum=None):
# Each feature is given a call name. Although The magnetometer and
# accelerometer use the same address, they've been given different
# names for clarity.
self.mag = I2C.get_i2c_device(self.LSM9DS0_MAG_ADDRESS, busnum)
self.accel = I2C.get_i2c_device(self.LSM9DS0_ACCEL_ADDRESS, busnum)
self.gyro = I2C.get_i2c_device(self.LSM9DS0_GYRO_ADDRESS, busnum)
# Magnetometer initialisation
self.mag.write8(
self.LSM9DS0_CTRL_REG5_XM,
0b11110000) # Temperature sensor enabled, high res mag, 50Hz
#Actually Chodge and I just disabled the temperature sensor... JK, it threw errors
self.mag.write8(self.LSM9DS0_CTRL_REG6_XM, 0b01100000) # +/- 12 gauss
self.mag.write8(self.LSM9DS0_CTRL_REG7_XM,
0b00000000) # Normal mode, continuous-conversion mode
# Accelerometer initialisation
self.accel.write8(self.LSM9DS0_CTRL_REG1_XM,
0b01100111) # 100Hz, XYZ enabled
self.accel.write8(self.LSM9DS0_CTRL_REG2_XM, 0b00000000) # +/- 2 g
#chodge and I made this the most sensitive it could be.
# Gyro initialisation
self.gyro.write8(self.LSM9DS0_CTRL_REG1_G,
0b00001111) # Normal power mode, XYZ enabled
self.gyro.write8(self.LSM9DS0_CTRL_REG4_G,
0b00000000) # Continuous update, 245 dps
def __init__(self, i2c_bus=None):
self._key_hit = False
self._hold_down = False
self._init_ok = False
Controller.available_pins = [self.TOUCH_RESET_PIN] + Controller.available_pins
Controller.available_pins = [self.TOUCH_CHANGE_PIN] + Controller.available_pins
self._reset_pin = Controller.alloc_pin(self.TOUCH_RESET_PIN, OUTPUT)
self._reset_pin.set()
self._change_pin = Controller.alloc_pin(self.TOUCH_CHANGE_PIN, INPUT, self._read_state, FALLING)
time.sleep(1)
if i2c_bus is None:
self._i2c = I2C.get_i2c_device(self.TOUCH_I2C_ADDRESS)
else:
self._i2c = I2C.get_i2c_device(self.TOUCH_I2C_ADDRESS, busnum=i2c_bus)
# write non-zero value to reset register
time.sleep(0.5)
self._i2c.write8(self.TOUCH_CMD_RESET, 0xff)
time.sleep(0.5)
chip_id = self._i2c.readU8(self.TOUCH_CMD_CHIP_ID)
time.sleep(0.5)
self._i2c.write8(self.TOUCH_CMD_CALIBRATE, 0xff)
while self._i2c.readU8(self.TOUCH_CMD_DETECTION_STATUS) & 0x80:
self.logger.debug("init: calibration in progress ...")
self._i2c.write8(self.TOUCH_CMD_MAX_ON_DURATION, 100)
if chip_id == self.TOUCH_CHIP_ID:
self._init_ok = True
self._i2c.write8(self.TOUCH_CMD_FAST_MAX_CAL_GUARD, 0x6)
time.sleep(0.1)
# increase sensitivity
for i in range(0, 7):
self._i2c.write8(self.TOUCH_CMD_NEGATIVE_TRESHOLD + i, 80)
time.sleep(0.1)
def _check_active_addresses(self, i, bus):
x, y = None, None
try:
self._gpio[i] = I2C.get_i2c_device(self._gpio_addresses[i], bus)
self._pwm[i] = I2C.get_i2c_device(self._pwm_addresses[i], bus)
x = self._gpio[i].readU8(0x00)
y = self._pwm[i].readU8(0x00)
except OSError:
self._gpio[i] = None
self._pwm[i] = None
self._board_status[i] = 0
finally:
if x is not None and y is not None:
self._board_status[i] = 1
self._gpio[i].write8(0x03, 0xE0)
self._gpio[i].write8(0x01, 0xE0)
x = self._pwm[i].readU8(0x00)
if x & 0x80 == 0x80:
self._pwm[i].write8(0x00, 0x80)
self._pwm[i].write8(0x00, 0x30)
prescaler = (round(25000000 /
(4096 * self._board_freq[i])) - 1) & 0xFF
self._pwm[i].write8(0xFE, prescaler)
self._pwm[i].write8(0x00, 0x20)
for z in range(2, 6):
self._pwm[i].write8(z, 0x00)
def __init__(self,
width,
height,
rst,
dc=None,
sclk=None,
din=None,
cs=None,
gpio=None,
spi=None,
i2c_bus=None,
i2c_address=SSD1306_I2C_ADDRESS,
i2c=None):
self._log = logging.getLogger('SOLED.SH1106Base')
self._spi = None
self._i2c = None
self.width = width
self.height = height
self._pages = height // 8
self._buffer = [0] * (width * self._pages)
# Default to platform GPIO if not provided.
self._gpio = gpio
if self._gpio is None:
self._gpio = GPIO.get_platform_gpio()
# RESET (RST/RES) Pin setup:
self._rst = rst
if not self._rst is None:
self._gpio.setup(self._rst, GPIO.OUT)
# Handle hardware SPI
if spi is not None:
self._log.debug('Using hardware SPI')
self._spi = spi
self._spi.set_clock_hz(8000000)
# Handle software SPI
elif sclk is not None and din is not None and cs is not None:
self._log.debug('Using software SPI')
self._spi = SPI.BitBang(self._gpio, sclk, din, None, cs)
# Handle hardware I2C
elif i2c is not None:
self._log.debug('Using hardware I2C with custom I2C provider.')
self._i2c = i2c.get_i2c_device(i2c_address)
else:
self._log.debug('Using hardware I2C with platform I2C provider.')
import Adafruit_GPIO.I2C as I2C
if i2c_bus is None:
self._i2c = I2C.get_i2c_device(i2c_address)
else:
self._i2c = I2C.get_i2c_device(i2c_address, busnum=i2c_bus)
# Initialize DC pin if using SPI.
if self._spi is not None:
if dc is None:
raise ValueError('DC pin must be provided when using SPI.')
self._dc = dc
self._gpio.setup(self._dc, GPIO.OUT)
def __init__(self, i2c_addr=None):
try:
if i2c_addr is None:
self._bus = I2C.get_i2c_device(ARDUINO_I2CADDR)
else:
self._bus = I2C.get_i2c_device(i2c_addr)
except Exception:
raise RuntimeError("Error getting I2C device address")
def get_i2c_device(self, address, i2c, i2c_bus):
if i2c is not None:
return i2c.get_i2c_device(address)
else:
import Adafruit_GPIO.I2C as I2C
if i2c_bus is None:
return I2C.get_i2c_device(address)
else:
return I2C.get_i2c_device(address, busnum=i2c_bus)
def __init__(
self,
width,
height,
rst,
dc=None,
sclk=None,
din=None,
cs=None,
gpio=None,
spi=None,
i2c_bus=None,
i2c_address=SSD1306_I2C_ADDRESS,
i2c=None,
):
self._log = logging.getLogger("Adafruit_SSD1306.SSD1306Base")
self._spi = None
self._i2c = None
self.width = width
self.height = height
self._pages = height / 8
self._buffer = [0] * (width * self._pages)
# Default to platform GPIO if not provided.
self._gpio = gpio
if self._gpio is None:
self._gpio = GPIO.get_platform_gpio()
# Setup reset pin.
self._rst = rst
self._gpio.setup(self._rst, GPIO.OUT)
# Handle hardware SPI
if spi is not None:
self._log.debug("Using hardware SPI")
self._spi = spi
self._spi.set_clock_hz(8000000)
# Handle software SPI
elif sclk is not None and din is not None and cs is not None:
self._log.debug("Using software SPI")
self._spi = SPI.BitBang(self._gpio, sclk, din, None, cs)
# Handle hardware I2C
elif i2c is not None:
self._log.debug("Using hardware I2C with custom I2C provider.")
self._i2c = i2c.get_i2c_device(i2c_address)
else:
self._log.debug("Using hardware I2C with platform I2C provider.")
import Adafruit_GPIO.I2C as I2C
if i2c_bus is None:
self._i2c = I2C.get_i2c_device(i2c_address)
else:
self._i2c = I2C.get_i2c_device(i2c_address, busnum=i2c_bus)
# Initialize DC pin if using SPI.
if self._spi is not None:
if dc is None:
raise ValueError("DC pin must be provided when using SPI.")
self._dc = dc
self._gpio.setup(self._dc, GPIO.OUT)
class SSD1306Base(object):
"""Base class for SSD1306-based OLED displays. Implementors should subclass
and provide an implementation for the _initialize function.
"""
def __init__(self, width, height, rst, dc=None, sclk=None, din=None, cs=None,
gpio=None, spi=None, i2c_bus=None, i2c_address=SSD1306_I2C_ADDRESS,
i2c=None, mcp_rst=None, mcp_address=None):
self._log = logging.getLogger('Adafruit_SSD1306.SSD1306Base')
self._spi = None
self._i2c = None
self.width = width
self.height = height
self._pages = height//8
self._buffer = [0]*(width*self._pages)
# Default to platform GPIO if not provided.
self._gpio = gpio
# Instantiate MCP if rst pin is in mcp.
if mcp_rst is not None and mcp_address is not None:
self.__mcp_rst = mcp_rst
self.__mcp = MCP.MCP23017(mcp_address, busnum=1)
self.__mcp.setup(self.__mcp_rst, MCP.GPIO.OUT)
if self._gpio is None:
self._gpio = GPIO.get_platform_gpio()
# Setup reset pin.
self._rst = rst
if not self._rst is None and (mcp_rst is None or mcp_address is None):
self._gpio.setup(self._rst, GPIO.OUT)
# Handle hardware SPI
if spi is not None:
self._log.debug('Using hardware SPI')
self._spi = spi
self._spi.set_clock_hz(8000000)
# Handle software SPI
elif sclk is not None and din is not None and cs is not None:
self._log.debug('Using software SPI')
self._spi = SPI.BitBang(self._gpio, sclk, din, None, cs)
# Handle hardware I2C
elif i2c is not None:
self._log.debug('Using hardware I2C with custom I2C provider.')
self._i2c = i2c.get_i2c_device(i2c_address)
else:
self._log.debug('Using hardware I2C with platform I2C provider.')
if i2c_bus is None:
self._i2c = I2C.get_i2c_device(i2c_address)
else:
self._i2c = I2C.get_i2c_device(i2c_address, busnum=i2c_bus)
# Initialize DC pin if using SPI.
if self._spi is not None:
if dc is None:
raise ValueError('DC pin must be provided when using SPI.')
self._dc = dc
self._gpio.setup(self._dc, GPIO.OUT)
def get_i2c_device(address, i2c, i2c_bus):
# Helper method to get a device at the specified address from the I2C bus.
# If no i2c bus is specified (i2c param is None) then the default I2C bus
# for the platform will be used.
if i2c is not None:
return i2c.get_i2c_device(address)
else:
import Adafruit_GPIO.I2C as I2C
if i2c_bus is None:
return I2C.get_i2c_device(address)
else:
return I2C.get_i2c_device(address, busnum=i2c_bus)
def get_i2c_device(address, i2c, i2c_bus):
# Helper method to get a device at the specified address from the I2C bus.
# If no i2c bus is specified (i2c param is None) then the default I2C bus
# for the platform will be used.
if i2c is not None:
return i2c.get_i2c_device(address)
else:
import Adafruit_GPIO.I2C as I2C
if i2c_bus is None:
return I2C.get_i2c_device(address)
else:
return I2C.get_i2c_device(address, busnum=i2c_bus)
def __init__(
self,
width,
height,
rst,
dc=None,
sclk=None,
din=None,
cs=None,
gpio=None,
i2c_bus=None,
i2c_address=SSD1306_I2C_ADDRESS,
i2c=None,
):
self._log = logging.getLogger("Adafruit_SSD1306.SSD1306Base")
self._i2c = None
self.width = width
self.height = height
self._pages = height // 8
self._buffer = [0] * (width * self._pages)
# Default to platform GPIO if not provided.
self._gpio = gpio
if self._gpio is None:
self._gpio = GPIO.get_platform_gpio()
# Setup reset pin.
self._rst = rst
if self._rst is not None:
self._gpio.setup(self._rst, GPIO.OUT)
# Handle hardware I2C
elif i2c is not None:
self._log.debug("Using hardware I2C with custom I2C provider.")
self._i2c = i2c.get_i2c_device(i2c_address)
else:
self._log.debug("Using hardware I2C with platform I2C provider.")
if i2c_bus is None:
self._i2c = I2C.get_i2c_device(i2c_address)
else:
self._i2c = I2C.get_i2c_device(i2c_address, busnum=i2c_bus)
# Initialize DC pin if using SPI.
if self._spi is not None:
if dc is None:
raise ValueError("DC pin must be provided when using SPI.")
self._dc = dc
self._gpio.setup(self._dc, GPIO.OUT)
def __init__(self, busnum=0, address=_FXOS8700_ADDRESS,
accel_range=ACCEL_RANGE_2G, **kwargs):
assert accel_range in (ACCEL_RANGE_2G, ACCEL_RANGE_4G, ACCEL_RANGE_8G)
self._accel_range = accel_range
#self._device = i2c_dev.I2CDevice(i2c, address)
self._device = I2C.get_i2c_device(address, busnum=0) #, kwargs)
# Check for chip ID value.
if self._read_u8(_FXOS8700_REGISTER_WHO_AM_I) != _FXOS8700_ID:
raise RuntimeError('Failed to find FXOS8700, check wiring!')
# Set to standby mode (required to make changes to this register)
self._write_u8(_FXOS8700_REGISTER_CTRL_REG1, 0)
if accel_range == ACCEL_RANGE_2G:
self._write_u8(_FXOS8700_REGISTER_XYZ_DATA_CFG, 0x00)
elif accel_range == ACCEL_RANGE_4G:
self._write_u8(_FXOS8700_REGISTER_XYZ_DATA_CFG, 0x01)
elif accel_range == ACCEL_RANGE_8G:
self._write_u8(_FXOS8700_REGISTER_XYZ_DATA_CFG, 0x02)
# High resolution
self._write_u8(_FXOS8700_REGISTER_CTRL_REG2, 0x02)
# Active, Normal Mode, Low Noise, 100Hz in Hybrid Mode
self._write_u8(_FXOS8700_REGISTER_CTRL_REG1, 0x15)
# Configure the magnetometer
# Hybrid Mode, Over Sampling Rate = 16
self._write_u8(_FXOS8700_REGISTER_MCTRL_REG1, 0x1F)
# Jump to reg 0x33 after reading 0x06
self._write_u8(_FXOS8700_REGISTER_MCTRL_REG2, 0x20)
def readfrom(device_addr, register):
try:
device = I2C.get_i2c_device(device_addr)
ans = device.readU8(register)
return ans
except IOError:
return "No Device Found"
def __init__(self, address=0x40, busnum=1, **kwargs):
# Setup I2C interface for the device.
self.device = I2C.get_i2c_device(address, busnum=busnum, **kwargs)
self.reset()
self.wake()
def __init__(self,
shunt_ohms,
max_expected_amps=None,
busnum=1,
address=__ADDRESS,
log_level=logging.ERROR):
"""Construct the class.
Pass in the resistance of the shunt resistor and the maximum expected
current flowing through it in your system.
Arguments:
shunt_ohms -- value of shunt resistor in Ohms (mandatory).
max_expected_amps -- the maximum expected current in Amps (optional).
address -- the I2C address of the INA219, defaults
to *0x40* (optional).
log_level -- set to logging.DEBUG to see detailed calibration
calculations (optional).
"""
if len(logging.getLogger().handlers) == 0:
# Initialize the root logger only if it hasn't been done yet by a
# parent module.
logging.basicConfig(level=log_level, format=self.__LOG_FORMAT)
self.logger = logging.getLogger(__name__)
self.logger.setLevel(log_level)
self._i2c = I2C.get_i2c_device(address=address, busnum=1)
self._shunt_ohms = shunt_ohms
self._max_expected_amps = max_expected_amps
self._min_device_current_lsb = self._calculate_min_current_lsb()
self._gain = None
self._auto_gain_enabled = False
def __init__(self, address, registers, **kwargs):
self.address = address
self.registers = registers
self._sensor = I2C.get_i2c_device(address=address, busnum=1, **kwargs)
self.enable()
self.bias = 0
self.variance = 0
def __init__(self, options={}):
self.options = core.mergeOptions(DEFAULT_OPTIONS, options)
self.device = I2C.get_i2c_device(self.options["address"])
self.value = {"uv": 0, "ir":0,"visible":0}
self.lastUpdate = time.time()
self._reset()
self._load_calibration()
def pca9548a_setup(pca9548a_channel):
"""
Set i2c multiplexer (pca9548a) channel
"""
pca9548a = I2C.get_i2c_device(PCA9548A_ADDR)
pca9548a.writeRaw8(pca9548a_channel)
time.sleep(0.1)
def __init__(self,
shunt_ohms,
max_expected_amps=None,
busnum=None,
address=__ADDRESS,
log_level=logging.ERROR):
""" Construct the class passing in the resistance of the shunt
resistor and the maximum expected current flowing through it in
your system.
Arguments:
shunt_ohms -- value of shunt resistor in Ohms (mandatory).
max_expected_amps -- the maximum expected current in Amps (optional).
address -- the I2C address of the INA219, defaults
to *0x40* (optional).
log_level -- set to logging.DEBUG to see detailed calibration
calculations (optional).
"""
logging.basicConfig(level=log_level, format=self.__LOG_FORMAT)
self._i2c = I2C.get_i2c_device(address=address, busnum=busnum)
self._shunt_ohms = shunt_ohms
self._max_expected_amps = max_expected_amps
self._min_device_current_lsb = self._calculate_min_current_lsb()
self._gain = None
self._auto_gain_enabled = False
def __init__(self,
busnum=0,
address=_FXAS21002C_ADDRESS,
gyro_range=GYRO_RANGE_250DPS):
assert gyro_range in (GYRO_RANGE_250DPS, GYRO_RANGE_500DPS,
GYRO_RANGE_1000DPS, GYRO_RANGE_2000DPS)
self._gyro_range = gyro_range
#self._device = i2c_dev.I2CDevice(i2c, address)
self._device = I2C.get_i2c_device(address, busnum=0) #, kwargs)
# Check for chip ID value.
if self._read_u8(_GYRO_REGISTER_WHO_AM_I) != _FXAS21002C_ID:
raise RuntimeError('Failed to find FXAS21002C, check wiring!')
ctrl_reg0 = 0x00
if gyro_range == GYRO_RANGE_250DPS:
ctrl_reg0 = 0x03
elif gyro_range == GYRO_RANGE_500DPS:
ctrl_reg0 = 0x02
elif gyro_range == GYRO_RANGE_1000DPS:
ctrl_reg0 = 0x01
elif gyro_range == GYRO_RANGE_2000DPS:
ctrl_reg0 = 0x00
# Reset then switch to active mode with 100Hz output
# Putting into standy doesn't work as the chip becomes instantly
# unresponsive. Perhaps CircuitPython is too slow to go into standby
# and send reset? Keep these two commented for now:
#self._write_u8(_GYRO_REGISTER_CTRL_REG1, 0x00) # Standby)
#self._write_u8(_GYRO_REGISTER_CTRL_REG1, (1<<6)) # Reset
self._write_u8(_GYRO_REGISTER_CTRL_REG0, ctrl_reg0) # Set sensitivity
self._write_u8(_GYRO_REGISTER_CTRL_REG1, 0x0E) # Active
time.sleep(0.1) # 60 ms + 1/ODR
def __init__(self, address=0x6a, debug=0, pause=0.8):
self.i2c = I2C.get_i2c_device(address)
self.address = address
# dataToWrite = 0
# dataToWrite |= 0x03
# dataToWrite |= 0x00
# dataToWrite |= 0x10
# self.i2c.write8(0X10, dataToWrite)
# [FSXL BW_XL 4 bits 0001]
dataToWrite = 0
dataToWrite |= 0x01 # 2g [FS_XL 00] sample 200HZ BW_XL [01]
dataToWrite |= 0x50 #208HZ sample
self.i2c.write8(0X10, dataToWrite)
# Settinggyro sensitivity to + / - 2000 deg /
dataToWrite = 0
#00: 250 dps; 01: 500 dps; 10: 1000 dps; 11: 2000 dps and sample it at 208HZ
dataToWrite |= 0x5E # 2g [FS_XL 00] sample 200HZ BW_XL [01]
self.i2c.write8(0X11, dataToWrite)
time.sleep(1)
self.gyro = {'y': 0, 'z': 0}
self.accel = {'x': 0, 'y': 0, 'z': 0}
self.balance_angle = 0
self.balance_gyro = 0
self.turn_gyro = 0
self.kalman = KalmanFilter()
def __init__(self,
shunt_ohms,
max_expected_amps=None,
busnum=None,
address=0x40,
log_level=logging.ERROR):
""" Construct the class passing in the resistance of the shunt
resistor and the maximum expected current flowing through it in
your system.
Arguments:
shunt_ohms -- value of shunt resistor in Ohms (mandatory).
max_expected_amps -- the maximum expected current in Amps (optional).
address -- the I2C address of the INA219, defaults
to *0x40* (optional).
log_level -- set to logging.DEBUG to see detailed calibration
calculations (optional).
"""
self._i2c = I2C.get_i2c_device(address=address, busnum=busnum)
self._shunt_ohms = shunt_ohms
self._max_expected_amps = max_expected_amps
self._min_device_current_lsb = self._calculate_min_current_lsb()
self._gain = None
self._auto_gain_enabled = False
self._voltage_range = None
try:
self._read_voltage_register()
except Exception:
raise RuntimeError("INA219 does not exist.")
def __init__(self,
address=None,
busnum=None,
integration_time=TSL2561_INTEGRATIONTIME_402MS,
gain=TSL2561_GAIN_1X,
autogain=False,
debug=False):
# Set default address and bus number if not given
if address is not None:
self.address = address
else:
self.address = TSL2561_ADDR_FLOAT
if busnum is None:
self.busnum = 1
self.i2c = I2C.get_i2c_device(self.address, busnum=busnum)
self.debug = debug
self.integration_time = integration_time
self.gain = gain
self.autogain = autogain
if self.integration_time == TSL2561_INTEGRATIONTIME_402MS:
self.delay_time = TSL2561_DELAY_INTTIME_402MS
elif self.integration_time == TSL2561_INTEGRATIONTIME_101MS:
self.delay_time = TSL2561_DELAY_INTTIME_101MS
elif self.integration_time == TSL2561_INTEGRATIONTIME_13MS:
self.delay_time = TSL2561_DELAY_INTTIME_13MS
self._begin()
def writeto(device_addr, register, value):
try:
device = I2C.get_i2c_device(device_addr)
device.write8(register, value)
return "Write Successful"
except IOError:
return "No Device found"
def __init__(self, address=VCNL4010_ADDRESS, busNumber=1):
""" Initialize the VCNL40xx sensor """
#queue controls access to interrupts
self.interrupt_queue = queue.Queue()
# Setup I2C interface for the device.
self._device = I2C.get_i2c_device(address, busNumber)
self.gpio_pin = 23 # default pin
self.reset()
def init_tca(self):
self.tca = I2C.get_i2c_device(address=0x70)
self.tca_select(0)
self.tca_select(1)
self.select_disp('all disp mobilize')
self.texts([1, 'f**k'])
def __init__(self, address=0x39, debug=0, pause=0.8):
self.i2c = I2C.get_i2c_device(address)
self.address = address
self.pause = pause
self.debug = debug
self.gain = 0 # no gain preselected
self.i2c.write8(0x80, 0x03) # enable the device
def __init__(self, options={}):
self.options = core.mergeOptions(DEFAULT_OPTIONS, options)
self.device = I2C.get_i2c_device(self.options["address"])
self.valueLock = threading.Lock()
self.value = {"pressure": 0, "temperature": 0}
self.lastUpdate = time.time()
self._setup()
def __init__(self, address=AM2315_I2CADDR, i2c=None, **kwargs):
# if i2c is None:
# import Adafruit_GPIO.I2C as I2C
# i2c = I2C
# self._device = i2c.get_i2c_device(address, **kwargs)
self._device = I2C.get_i2c_device(address, busnum=0, **kwargs)
self._logger = logging.getLogger('am2315.AM2315')
self.humidity = 0
self.temperature = 0
def address(self, value):
if (value < IQS5xx_DEFAULT_ADDRESS) or (value > IQS5xx_MAX_ADDRESS):
raise ValueError(
"Invalid I2C Address. Use something in the range [%x, %x]" %
(IQS5xx_DEFAULT_ADDRESS, IQS5xx_MAX_ADDRESS))
self.__address = value
self._device = i2c.get_i2c_device(value)
self._logger = logging.getLogger(
'IQS5xx.Address.{0:#0X}'.format(value))
def __init__(self, controller, timeout=1, address=AMG88xx_I2CADDR, bus=1, name="IR1"):
super().__init__()
self._controller = controller
controller.register_sensor(self, name)
self._timeout = timeout
self._run = False
self._active = False
self._name = name
self._device = I2C.get_i2c_device(address, busnum=bus)
def __init__(self, name, mplx_id, address=0x68):
power_mgmt_1 = 0x6b # register power management of IMU
self.name = name
self.mplx_id = mplx_id # plex ID of IMU
# MultiPlexer schlaten, um das Modul ansprechen zu koennen
self.i2c = Adafruit_I2C.get_i2c_device(address, busnum=2)
self.plexer.select(self.mplx_id)
time.sleep(.1)
# Power on of Acc
self.i2c.write8(power_mgmt_1, 0x00)
def __init__(self, width, height, rst, dc=None, sclk=None, din=None, cs=None, gpio=None,
spi=None, i2c_bus=None, i2c_address=SSD1306_I2C_ADDRESS,
i2c=None):
self._spi = None
self._i2c = None
self.width = width
self.height = height
self._pages = height // 8
self._buffer = [0] * width * self._pages
self._cursor = 0
# Default to platform GPIO if not provided.
self._gpio = gpio
if self._gpio is None:
self._gpio = GPIO.get_platform_gpio()
# Setup reset pin.
self._rst = rst
self._gpio.setup(self._rst, GPIO.OUT)
# Handle hardware SPI
if spi is not None:
self._spi = spi
self._spi.set_clock_hz(8000000)
# Handle software SPI
elif sclk is not None and din is not None and cs is not None:
self._spi = SPI.BitBang(self._gpio, sclk, din, None, cs)
# Handle hardware I2C
elif i2c is not None:
self._i2c = i2c.get_i2c_device(i2c_address)
else:
import Adafruit_GPIO.I2C as I2C
self._i2c = I2C.get_i2c_device(i2c_address) if i2c_bus is None else I2C.get_i2c_device(i2c_address,
busnum=i2c_bus)
# Initialize DC pin if using SPI.
if self._spi is not None:
if dc is None:
raise ValueError('DC pin must be provided when using SPI.')
self._dc = dc
self._gpio.setup(self._dc, GPIO.OUT)
def __init__(self, busnum=None):
# Each feature is given a call name. Although The magnetometer and
# accelerometer use the same address, they've been given different
# names for clarity.
self.mag = I2C.get_i2c_device(self.LSM9DS0_MAG_ADDRESS, busnum)
self.accel = I2C.get_i2c_device(self.LSM9DS0_ACCEL_ADDRESS, busnum)
self.gyro = I2C.get_i2c_device(self.LSM9DS0_GYRO_ADDRESS, busnum)
# Magnetometer initialisation
self.mag.write8(self.LSM9DS0_CTRL_REG5_XM, 0b11110000) # Temperature sensor enabled, high res mag, 50Hz
self.mag.write8(self.LSM9DS0_CTRL_REG6_XM, 0b01100000) # +/- 12 gauss
self.mag.write8(self.LSM9DS0_CTRL_REG7_XM, 0b00000000) # Normal mode, continuous-conversion mode
# Accelerometer initialisation
self.accel.write8(self.LSM9DS0_CTRL_REG1_XM, 0b01100111) # 100Hz, XYZ enabled
self.accel.write8(self.LSM9DS0_CTRL_REG2_XM, 0b00100000) # +/- 16 g
# Gyro initialisation
self.gyro.write8(self.LSM9DS0_CTRL_REG1_G, 0b00001111) # Normal power mode, XYZ enabled
self.gyro.write8(self.LSM9DS0_CTRL_REG4_G, 0b00110000) # Continuous update, 2000 dps
def __init__(self, gyro_dr=(LSM9DS0_GYRODR_95HZ | LSM9DS0_GYRO_CUTOFF_1), gyro_scale=LSM9DS0_GYROSCALE_245DPS, gyro_addr=LSM9DS0_GYRO_ADDR):
"""looks for the lsm9dso on i2c bus, and performs register configuration on it"""
self._sensor = i2c.get_i2c_device(gyro_addr)
#verify initialization by checking the who_am_i register
if not (self._sensor.readU8(LSM9DS0_REG_WHO_AM_I_G) == LSM9DS0_GYRO_ID):
#not the right device!
print "Could not initialize the gyro!"
#sys.exit()
self.start_capture()
self._config_gyro(gyro_scale, gyro_dr)
def __init__(self, address=0x6b, debug=0, pause=0.8):
self.i2c = I2C.get_i2c_device(address)
self.address = address
dataToWrite = 0 #Start Fresh!
dataToWrite |= 0x03 # set at 50hz, bandwidth
dataToWrite |= 0x00 # 2g accel range
dataToWrite |= 0x10 # 13hz ODR
self.i2c.write8(0X10, dataToWrite) #writeRegister(LSM6DS3_ACC_GYRO_CTRL2_G, dataToWrite);
accel_center_x = self.i2c.readS16(0X28)
accel_center_y = self.i2c.readS16(0x2A)
accel_center_z = self.i2c.readS16(0x2C)
def __init__(self, address=None, busnum=None,
integration_time=TSL2561_DELAY_INTTIME_402MS,
gain=TSL2561_GAIN_1X, autogain=False, debug=False):
if address is not None:
self.address = address
else:
self.address = TSL2561_ADDR_FLOAT
self.i2c = I2C.get_i2c_device(self.address, busnum=busnum)
self.debug = debug
self.integration_time = integration_time
self.gain = gain
self.autogain = autogain
self._begin()
def __init__(self, address=0x53, debug=0, pause=0.8):
self.i2c = I2C.get_i2c_device(address)
self.address = address
self.i2c.write8(0x2D, 0x08) #ADXL345_REG_POWER_CTL 0x2D
dataToWrite = 0 #Start Fresh!
dataToWrite |= 0b00
self.i2c.write8(0X31, dataToWrite) #ADXL345_REG_DATA_FORMAT 0x31 2g
dataToWrite = 0 #Start Fresh!
dataToWrite |= 0b0101
self.i2c.write8(0x2C, dataToWrite) #ADXL345_REG_DATA_FORMAT 0x31 2g
accel_center_x = self.i2c.readS16(0X32)
accel_center_y = self.i2c.readS16(0X34)
accel_center_z = self.i2c.readS16(0X36)
def __init__(self, accel_dr=LSM9DS0_ACCELDR_50HZ, mag_dr=LSM9DS0_MAGDR_50HZ, accel_range=LSM9DS0_ACCELRANGE_16G, mag_gain=LSM9DS0_MAGGAIN_2GAUSS, addr=LSM9DS0_ACCEL_ADDR):
"""setup for the accelerometer portion of the lsm9ds0"""
self._sensor = i2c.get_i2c_device(addr)
#verify initialization by checking the who_am_i register
if not (self._sensor.readU8(LSM9DS0_REG_WHO_AM_I_XM) == 0x49):
#not the right device!
print "Could not initialize the accelerometer!"
#sys.exit()
#turn on the 3 axis for both ones
self.start_capture()
#set read frequency
self._config_accel(accel_dr, accel_range)
self._config_magnetometer(mag_dr, mag_gain)
def __init__(self, ahrs, update_rate_hz, busnum=None, i2c_interface=None, **kwargs):
self.i2c = I2C.get_i2c_device(0x32, busnum, i2c_interface, **kwargs)
self.update_rate_hz = update_rate_hz
self.running = True
self.ahrs = ahrs
self.raw_data_update = GyroUpdate()
self.ahrs_update = AHRSUpdate()
self.ahrspos_update = AHRSPosUpdate()
self.board_id = BoardID()
self.board_state = BoardState()
self.last_sensor_timestamp = 0
self.last_update_time = 0.0
self.byte_count = 0
self.update_count = 0
def init():
'''
Clear the screen
'''
global i2c_bus
global image
global draw
global font
global fix_font
if i2c_bus == None:
i2c_bus = I2C.get_i2c_device(0x3C)
command(SSD1306_DISPLAYOFF) # 0xAE
command(SSD1306_SETDISPLAYCLOCKDIV) # 0xD5
command(0x80) # the suggested ratio 0x80
command(SSD1306_SETMULTIPLEX) # 0xA8
command(0x3F)
command(SSD1306_SETDISPLAYOFFSET) # 0xD3
command(0x0) # no offset
command(SSD1306_SETSTARTLINE | 0x0) # line #0
command(SSD1306_CHARGEPUMP) # 0x8D
command(0x14)
command(SSD1306_MEMORYMODE) # 0x20
command(0x00) # 0x0 act like ks0108
command(SSD1306_SEGREMAP | 0x1)
command(SSD1306_COMSCANDEC)
command(SSD1306_SETCOMPINS) # 0xDA
command(0x12)
command(SSD1306_SETCONTRAST) # 0x81
command(0xCF)
command(SSD1306_SETPRECHARGE) # 0xd9
command(0xF1)
command(SSD1306_SETVCOMDETECT) # 0xDB
command(0x40)
command(SSD1306_DISPLAYALLON_RESUME) # 0xA4
command(SSD1306_NORMALDISPLAY) # 0xA6
command(SSD1306_DISPLAYON)
image = Image.new('1', (WIDTH, HEIGHT))
draw = ImageDraw.Draw(image)
if fix_font:
font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf", 10)
else:
font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 9)
draw.rectangle((0, 0, WIDTH, HEIGHT), outline=0, fill=0)
off = 0xAE
invert = 0xA7
no_invert = 0xA6
vertical_flip = 0xC8
no_vertical_flip = 0xC0
all_on = 0xA5
no_all_on = 0xA4
set_brightness = 0x81
set_column = 0x21
set_page = 0x22
set_high_column = 0x00
set_low_column = 0x10
set_start_line = 0x40
set_vertical_offset = 0xD3 # the number of pixels to wrap picture down
port = I2C.get_i2c_device(address)
buffer = Image.new('1', (128, 64))
temp_buffer = Image.new('1', (128, 64))
console_buffer = Image.new('1', (128, 64))
draw = ImageDraw.Draw(buffer)
console_draw = ImageDraw.Draw(console_buffer)
font8 = ImageFont.truetype("Minecraftia.ttf", 8)
font16 = ImageFont.truetype("Minecraftia.ttf", 16)
font24 = ImageFont.truetype("Minecraftia.ttf", 24)
font = font8 # font to actually display with. can be changed to font8/16/24
font_size = 8
old_cursor_line = 0
def command(hex):
'''Sends hexadecimal value to OLED as a command eg. Oled.on.'''
#!/usr/bin/env python
import Adafruit_GPIO.I2C as i2c#Imports adafruit library for sensors
import requests # imports web library
from time import sleep, time # Imports time and sleep
requests.packages.urllib3.disable_warnings() # handles warnings from requests
address = 0x27 # Device Address
try:
device = i2c.get_i2c_device(address)# get device address
print('PI Temperature Sensor Running')
while True:
try:
read_results = device.readList(0,4)#read results
temp = (64.0*int(read_results[2])+int(read_results[3])/4)/(2**14-1)*165-40#Converts temp to C
hum = ((256.0*int(read_results[0])+int(read_results[1]))/(2**14-1)%1)*100# Gets humindity
#url = "http://178.62.91.44:3001/sensor/1?temp_value="+str(temp)+"&hum_value="+str(hum)+"&time="+str(int(time()))#declare uri template and format
url = "http://178.62.91.44:30002/sensor/1?value="+str(temp)+"&time="+str(int(time()))
r = requests.put(url,verify=False)#sends data to server via requests
print ('Sending Temp: ' + '%.2f'%round(temp,2)) #prints temp
sleep(60)#Update EveryMinute
#if r.status_code == 200:
# print ('Success')
except:
print('An Error Sending data has occurred, Check Server, Trying again in 30 seconds')
sleep(30)
except:
print("An Error Has Occured With the Sensor Configuration")
import time
import Adafruit_GPIO.I2C as i2c
import pynmea2
dev = i2c.get_i2c_device(busnum=2, address=0x42)
def read():
hi = dev.readU8(0x7d)
lo = dev.readU8(0x7e)
nbytes = (hi << 8) | lo
print('reading %d bytes' % nbytes)
return ''.join(chr(dev.readU8(0xff)) for i in range(nbytes))
def read2():
hi = dev.readU8(0x7d)
lo = dev.readU8(0x7e)
nbytes = (hi << 8) | lo
line = []
while 1:
b = dev.readU8(0xff)
if b == 0xff: break
c = chr(b)
if c == '\n': break
line.append(c)
return (nbytes, ''.join(line))
while 1:
nb, line = read2()
try:
msg = pynmea2.parse(line)
