class RaspiI2cLogger(object):
def __init__(self):
self.i2c = SMBus(1)
self.address = 0x48
self.block = None
def is_address_exist(self):
try:
time.sleep(1)
self.block = self.i2c.read_i2c_block_data(self.address, 0x00, 2)
except OSError as e:
print("Oops... change address...")
if self.address == 0x48:
self.address = 0x49
print("change address to 0x49")
return False
elif self.address == 0x49:
self.address = 0x4b
print("change address to 0x4b")
return False
else:
self.address = 0x48
print("change address to 0x48")
return False
return True
def get_temperature(self):
iteration = 0
if self.is_address_exist():
val = self.block[0] << 8
val = val | self.block[1]
val = val >> 3
if (val >= 4096):
val = val - 8192
print("TEMPerature:" + str(val / 16.0))
return (val / 16.0)
else:
print("using invalid address")
iteration += 1
print(iteration)
return self.get_temperature()
def logging(self, time_interval=5):
while True:
print(self.get_temperature())
#for notifing to slack
#slack = slackweb.Slack(url=inifile.get("slack", "webhook_url"))
#slack.notify(text=str(val/16.0))
#attachments = []
#attachment = {"title": "raspi_temperature", "pretext": "location_1", "text": str(val/16.0)}
#attachments.append(attachment)
#slack.notify(attachments=attachments)
#time.sleep(1)
#time.sleep(599)
time.sleep(time_interval)
class I2C(object):
"""
This is just a wrapper around i2c. There are so many implementations.
"""
def __init__(self, address, bus=1):
self.i2c = SMBus(bus)
self.address = address
def __del__(self):
self.i2c.close()
def read8(self, reg):
b = self.i2c.read_byte_data(self.address, reg)
return b
def read_block(self, reg, size):
block = self.i2c.read_i2c_block_data(self.address, reg, size)
return block
def write_block(self, reg, data):
self.i2c.write_i2c_block_data(self.address, reg, data)
def write8(self, reg, data):
# print(hex(self.address), reg, data)
self.i2c.write_byte_data(self.address, reg, data)
def test_read(self):
res = []
res2 = []
res3 = []
bus = SMBus(1)
# Read bytes
for k in range(2):
x = bus.read_byte_data(80, k)
res.append(x)
self.assertEqual(len(res), 2, msg="Result array of incorrect length.")
# Read word
x = bus.read_word_data(80, 0)
res2.append(x & 255)
res2.append(x / 256)
self.assertEqual(len(res2), 2, msg="Result array of incorrect length.")
self.assertListEqual(res, res2, msg="Byte and word reads differ")
# Read block of N bytes
n = 2
x = bus.read_i2c_block_data(80, 0, n)
res3.extend(x)
self.assertEqual(len(res3), n, msg="Result array of incorrect length.")
self.assertListEqual(res, res3, msg="Byte and block reads differ")
bus.close()
def test_read(self):
res = []
res2 = []
res3 = []
bus = SMBus(1)
# Read bytes
for k in range(2):
x = bus.read_byte_data(80, k)
res.append(x)
self.assertEqual(len(res), 2, msg="Result array of incorrect length.")
# Read word
x = bus.read_word_data(80, 0)
res2.append(x & 255)
res2.append(x / 256)
self.assertEqual(len(res2), 2, msg="Result array of incorrect length.")
self.assertListEqual(res, res2, msg="Byte and word reads differ")
# Read block of N bytes
n = 2
x = bus.read_i2c_block_data(80, 0, n)
res3.extend(x)
self.assertEqual(len(res3), n, msg="Result array of incorrect length.")
self.assertListEqual(res, res3, msg="Byte and block reads differ")
bus.close()
def read_eeprom():
"""Return a class representing EEPROM contents, or none."""
try:
i2c = SMBus(1)
i2c.write_i2c_block_data(EEP_ADRESS, 0x00, [0x00])
return EPDType.from_bytes(i2c.read_i2c_block_data(0x50, 0, 29))
except IOError:
return None
class Tsl2561Sensor(RestoreEntity):
"""Representation of a Sensor."""
def __init__(self):
"""Initialize the sensor."""
self._state = None
self._bus = SMBus(1)
@property
def name(self):
"""Return the name of the sensor."""
return 'Luminosita'
@property
def state(self):
"""Return the state of the sensor."""
return self._state
@property
def unit_of_measurement(self):
"""Return the unit of measurement."""
return "lux"
def update(self):
"""Fetch new state data for the sensor."""
self._state = self._lightcheck()
def _lightcheck(self):
self._bus.write_byte(TSLaddr, 0x00 | TSLcmd, TSLon) #Power On
#Gain x1 at 402ms is the default so this line not required but change for different sensitivity
self._bus.write_byte(TSLaddr, 0x01 | TSLcmd,LowLong) #Gain x1 402ms
time.sleep(1) #give time sensor to settle
#Read Ch0 Word
data = self._bus.read_i2c_block_data(TSLaddr, chan0 | TSLcmd, 2)
#Read CH1 Word
data1 = self._bus.read_i2c_block_data(TSLaddr, chan1 | TSLcmd, 2)
# Convert the data to Integer
ch0 = data[1] * 256 + data[0]
ch1 = data1[1] * 256 + data1[0]
vResults = ch0-ch1 #get visable light results
self._bus.write_byte(TSLaddr, 0x00 | TSLcmd, TSLoff) #switch off
return str(vResults)
class MCP9808:
def __init__(self, bus, addr, resolution=0x03):
self.addr = addr
self.res = resolution
self.bus = SMBus(bus)
self.init()
# Initialise the MCP9808 with resolution for continuous readings
def init(self):
# Write config
config = [0x00, 0x00]
self.bus.write_i2c_block_data(self.addr, 0x01, config)
# Write resolution
if ((self.res > 0x03) or (self.res < 0)):
self.res = 0x03
self.bus.write_byte_data(self.addr, 0x08, self.res)
# Read Device ID/Revision register
rid = self.bus.read_byte_data(self.addr, 0x07)
tmp = self.bus.read_i2c_block_data(self.addr, 0x06, 2)
mid = ((tmp[0] & 0x1F) * 256) + tmp[1]
#print "Init MCP9808 Manufacurer ID: 0x{:04x}, Device ID: 0x{:02x}".format(mid, rid)
# Obtain temperature reading
def t_read(self):
# Final celcius temp
ctemp = 0.0
# Obtain temp reading in binary
tin = self.bus.read_i2c_block_data(self.addr, 0x05, 2)
bt = ((tin[0] & 0x1F) * 256) + tin[1]
# Check if two's comp
if (bt > 4095):
bt -= 8192
# Multiply by resolution
if (self.res == 0x00):
ctemp = bt * 0.5
elif (self.res == 0x01):
ctemp = bt * 0.25
elif (self.res == 0x02):
ctemp = bt * 0.125
elif (self.res == 0x03):
ctemp = bt * 0.0625
else:
ctemp = bt * 0.0625
# Round and format
return "{:.2f}".format(round(ctemp, 2))
class FlowSensor:
def __init__(self):
self.bus = SMBus(1)
@property
def data(self):
data = self.bus.read_i2c_block_data(0x07, 0, 2)
flow = ((data[0] << 8) + data[1]) / 1000 # LPM
return flow
class HTU21D:
def __init__(self, busno):
self.bus = SMBus(busno)
def read_temperature(self):
self.reset()
msb, lsb, crc = self.bus.read_i2c_block_data(I2C_ADDR,
CMD_TRIG_TEMP_HM, 3)
return -46.85 + 175.72 * (msb * 256 + lsb) / 65536
def read_humidity(self):
self.reset()
msb, lsb, crc = self.bus.read_i2c_block_data(I2C_ADDR,
CMD_TRIG_HUMID_HM, 3)
return -6 + 125 * (msb * 256 + lsb) / 65536.0
def reset(self):
self.bus.write_byte(I2C_ADDR, CMD_RESET)
class AMG88XX:
# AMG8833 specs
AMG8833_PIXEL_ARRAY_WIDTH = 8
AMG8833_PIXEL_ARRAY_HEIGHT = 8
AMG8833_PIXEL_TEMP_CONVERSION = 0.25
AMG8833_THERMISTOR_CONVERSION = 0.0625
AMG8833_MIN_TEMP = 22
AMG8833_MAX_TEMP = 32.0
def __init__(self, bus=1, address=0x69):
self._address = address
self._bus = SMBus(bus)
self.write(AMG88XX_PCTL, AMG88XX_NORMAL_MODE)
self.write(AMG88XX_RST, AMG88XX_INITIAL_RESET)
self.write_bit(AMG88XX_INTC, AMG88XX_INTEN_bit, AMG88XX_INT_DISABLED)
self.write_bit(AMG88XX_FPSC, AMG88XX_FPS_bit, AMG88XX_FPS_10)
# ----------------------------- I2C Utilites -----------------------------#
def write(self, register, data):
self._bus.write_byte_data(self._address, register, data)
time.sleep(0.0001)
def write_bit(self, register, bit, val):
bitmask = (val & 0b1) << bit
data = self._bus.read_byte_data(self._address, register)
data |= bitmask
self._bus.write_byte_data(self._address, register, data)
def read(self, register):
return self._bus.read_byte_data(self._address, register)
def read_bytes(self, register, num_bytes):
return self._bus.read_i2c_block_data(self._address, register, num_bytes)
# ------------------------------- AMG8833 --------------------------------#
def get_temperature(self):
"""Temperature of the sensor in Celsius"""
raw = (self.read(AMG88XX_TTHH << 8)) | self.read(AMG88XX_TTHL)
return _signed_12bit_to_float(raw) * self.AMG8833_THERMISTOR_CONVERSION
def get_pixels(self):
"""Temperature of each pixel across the sensor in Celsius.
Temperatures are stored in a two dimensional list where the first index is the row and
the second is the column. The first row is on the side closest to the writing on the
sensor."""
pixels = [[0] * self.AMG8833_PIXEL_ARRAY_WIDTH for _ in range(self.AMG8833_PIXEL_ARRAY_HEIGHT)]
for row in range(self.AMG8833_PIXEL_ARRAY_HEIGHT):
for col in range(self.AMG8833_PIXEL_ARRAY_WIDTH):
reg = AMG88XX_PIXEL_OFFSET + ((row * self.AMG8833_PIXEL_ARRAY_HEIGHT + col) << 1)
raw = self.read_bytes(reg, 2)
reading = raw[1] << 8 | raw[0]
pixels[row][col] = _twos_comp_to_float(reading) * self.AMG8833_PIXEL_TEMP_CONVERSION
return pixels
class VCNL4010:
"""Vishay VCNL4010 proximity and ambient light sensor."""
def __init__(self):
self._device = SMBus(1)
self.led_current = 20
self.frequency = FREQUENCY_390K625
self._write_u8(_VCNL4010_INTCONTROL, 0x08)
def _read_u8(self, address):
# Read an 8-bit unsigned value from the specified 8-bit address.
with SMBus(1) as self._device:
read = self._device.read_byte_data(_VCNL4010_I2CADDR_DEFAULT,
address)
return read
def _write_u8(self, address, val):
# Write an 8-bit unsigned value to the specified 8-bit address.
with SMBus(1) as self._device:
self._device.write_byte_data(_VCNL4010_I2CADDR_DEFAULT, address,
val)
def _read_u16BE(self, address):
with SMBus(1) as self._device:
read_block = self._device.read_i2c_block_data(
_VCNL4010_I2CADDR_DEFAULT, address, 2)
return (read_block[0] << 8) | read_block[1]
@property
def proximity(self):
"""The detected proximity of an object in front of the sensor. This
is a unit-less unsigned 16-bit value (0-65535) INVERSELY proportional
to the distance of an object in front of the sensor (up to a max of
~200mm). For example a value of 10 is an object farther away than a
value of 1000. Note there is no conversion from this value to absolute
distance possible, you can only make relative comparisons.
"""
# Clear interrupt.
status = self._read_u8(_VCNL4010_INTSTAT)
status &= ~0x80
self._write_u8(_VCNL4010_INTSTAT, status)
# Grab a proximity measurement.
self._write_u8(_VCNL4010_COMMAND, _VCNL4010_MEASUREPROXIMITY)
# Wait for result, then read and return the 16-bit value.
while True:
result = self._read_u8(_VCNL4010_COMMAND)
if result & _VCNL4010_PROXIMITYREADY:
highbyte = self._read_u8(0x87)
highbyte = format(highbyte, '08b')
lowbyte = self._read_u8(0x88)
lowbyte = format(lowbyte, '08b')
message = highbyte + lowbyte
return message
class MeasureLux():
def __init__(self):
self.lux = 0
# Define some constants from the datasheet
self.DEVICE = 0x23 # Default device I2C address
self.POWER_DOWN = 0x00 # No active state
self.POWER_ON = 0x01 # Power on
self.RESET = 0x07 # Reset data register value
# Start measurement at 4lx resolution. Time typically 16ms.
self.CONTINUOUS_LOW_RES_MODE = 0x13
# Start measurement at 1lx resolution. Time typically 120ms
self.CONTINUOUS_HIGH_RES_MODE_1 = 0x10
# Start measurement at 0.5lx resolution. Time typically 120ms
self.CONTINUOUS_HIGH_RES_MODE_2 = 0x11
# Start measurement at 1lx resolution. Time typically 120ms
# Device is automatically set to Power Down after measurement.
self.ONE_TIME_HIGH_RES_MODE_1 = 0x20
# Start measurement at 0.5lx resolution. Time typically 120ms
# Device is automatically set to Power Down after measurement.
self.ONE_TIME_HIGH_RES_MODE_2 = 0x21
# Start measurement at 1lx resolution. Time typically 120ms
# Device is automatically set to Power Down after measurement.
self.ONE_TIME_LOW_RES_MODE = 0x23
#bus = smbus.SMBus(0) # Rev 1 Pi uses 0
#self.bus = SMBus(1) # Rev 2 Pi uses 1
def convertToNumber(self, data):
# Simple function to convert 2 bytes of data
# into a decimal number. Optional parameter 'decimals'
# will round to specified number of decimal places.
# result=(data[1] + (256 * data[0])) / 1.2. window influence 고려하여 0.4 나누기로 수정
result = (data[1] + (256 * data[0])) / 0.51
return (result)
def readLight(self):
# Read data from I2C interface
self.bus = SMBus(1) # Rev 2 Pi uses 1
addr = self.DEVICE
data = self.bus.read_i2c_block_data(addr,
self.ONE_TIME_HIGH_RES_MODE_1, 2)
return self.convertToNumber(data)
def measureLux(self):
self.lux = int(self.readLight())
#print("측정된 조도 : " + format(self.lux,'.2f') + " lx")
#time.sleep(0.5)
return self.lux
if self.stop_threads:
raise CustomException.MeasureLuxTerminate
class Lidar_Lite():
def __init__(self, bus):
self.bus = SMBus(bus)
self.address = 0x62
self.distWriteReg = 0x00
self.distWriteVal = 0x04
self.distReadReg1 = 0x8f
self.distReadReg2 = 0x10
self.velWriteReg = 0x04
self.velWriteVal = 0x08
self.velReadReg = 0x09
self.updateTime = 0.005
"""
def connect(self, bus):
try:
self.bus = SMBus(bus)
time.sleep(0.5)
return 0
except:
return -1
"""
def writeAndWait(self, register, value):
self.bus.write_byte_data(self.address, register, value)
time.sleep(self.updateTime)
def readAndWait(self, register):
res = self.bus.read_byte_data(self.address, register)
time.sleep(self.updateTime)
return res
def readDistAndWait(self, register):
res = self.bus.read_i2c_block_data(self.address, register, 2)
time.sleep(self.updateTime)
return (res[0] << 8 | res[1])
def getDistance(self):
self.writeAndWait(self.distWriteReg, self.distWriteVal)
dist = self.readDistAndWait(self.distReadReg1)
return dist
def getVelocity(self):
self.writeAndWait(self.distWriteReg, self.distWriteVal)
self.writeAndWait(self.velWriteReg, self.velWriteVal)
vel = self.readAndWait(self.velReadReg)
return self.signedInt(vel)
def signedInt(self, value):
if value > 127:
return (256 - value) * (-1)
else:
return value
class I2CBus():
def __init__(self, I2C_bus_number, address):
self.bus = SMBus(I2C_bus_number)
self.address = address
def write_register(self, reg_address, device_address=None):
device_address = self.address
return self.bus.write_byte(device_address, reg_address)
def read_registers(self, reg_address, device_address=None):
device_address = self.address
return self.bus.read_i2c_block_data(device_address, reg_address, 6)
def getTempAndHumidityData():
import time
from smbus2 import SMBus
SHT31_ADDRESS = 0x45
bus = SMBus(1)
bus.write_i2c_block_data(SHT31_ADDRESS, 0x2C, [0x06])
time.sleep(0.25)
data = bus.read_i2c_block_data(SHT31_ADDRESS, 0x00, 6)
bus.close()
rawTemp = data[0] * 256 + data[1]
temp = -45 + (175 * rawTemp / 65535.0)
humidity = 100 * (data[3] * 256 + data[4]) / 65535.0
return temp, humidity
class Encoder:
def __init__(self, address, bus=1, invert=False):
self.bus = SMBus(bus)
self.address = address
self.invert = invert
self.resolution = ((math.pi*2)/2**14) # Define encoder angular resolution.
self.position = self.readPos() # Read position of encoder
self.angle = self.readAngle()
self.magnitude = self.readMagnitude()
def readPos(self):
pos = self.bus.read_i2c_block_data(self.address, 0xFE, 2) # Request data from registers 0xFE & 0xFF of the encoder
# Takes ~700 microseconds.
if not self.invert:
self.position = (pos[0] << 6) | pos[1] # Remove unused bits 6 & 7 from byte 0xFF creating 14 bit value
else:
self.position = (2**14)-((pos[0] << 6) | pos[1]) # Remove unused bits 6 & 7 from byte 0xFF creating 14 bit value & invert the value
return self.position # Return Raw encoder position (0 to 16384)
def readAngle(self):
self.readPos() # Read encoder position
self.angle = self.position * (360 / 2**14) # Scale values to get degrees
return self.angle # Return encoder angle (0 to 359.97802734375)
def readMagnitude(self):
magnitude = self.bus.read_i2c_block_data(self.address, 0xFC, 2) # Request data from registers 0xFC & 0xFD of the encoder
# Takes ~700 microseconds.
self.magnitude = (magnitude[0] << 6) | magnitude[1] # Remove unused bits 6 & 7 from byte 0xFD creating 14 bit value
return self.magnitude # Return encoder magnitude
def read_eeprom(i2c_bus=None):
"""Return a class representing EEPROM contents, or none."""
try:
if i2c_bus is None:
try:
from smbus2 import SMBus
except ImportError:
raise ImportError('This library requires the smbus2 module\nInstall with: sudo pip install smbus2')
i2c_bus = SMBus(1)
i2c_bus.write_i2c_block_data(EEP_ADDRESS, 0x00, [0x00])
return EPDType.from_bytes(i2c_bus.read_i2c_block_data(EEP_ADDRESS, 0, 29))
except IOError:
return None
class MAX11644(object):
def __init__(self, bus=_DEFAULT_BUS, address=_DEFAULT_ADDRESS, internal_reference=True,
v_ref_internal=_V_REF_INTERNAL):
# I2C bus object
self._i2c = SMBus(bus)
# added to avoid communication problems
time.sleep(1)
self._address = address
self._SETUP = 0x80
self._CONF = 0x00
if internal_reference:
self._SETUP = 0xD0
self._ref_volt = v_ref_internal
else:
self._SETUP = 0x82
self._ref_volt = _VDD
self._SETUP = (self._SETUP | 0x02) # internal clock, unipolar, no action
self._send_data_(self._SETUP)
def _send_data_(self, byte):
"""Send a byte to device"""
self._i2c.write_byte(self._address, byte)
time.sleep(0.1)
def _read_data(self, address):
"""Read 2 bytes from address address."""
data = self._i2c.read_i2c_block_data(self._address, address, 2)
return data
def get_value(self, channel=0):
"""Get Full scale value (12 bits)"""
if channel == 0:
self._CONF = 0x61
data = self._read_data(self._CONF)
elif channel == 1:
self._CONF = 0x63
data = self._read_data(self._CONF)
else:
raise Exception("Channel doesn't exist")
data = ((data[0] & 0x0F) << 8) | data[1]
return data
def convert_to_volt(self, value):
"""Convert Full scale value (12 bits) into volts"""
return self._ref_volt * value / 4096.
def get_voltage(self, channel=0, factor=1):
return self.convert_to_volt(self.get_value(channel) / factor)
def task(self):
t_voc = 99999
try:
bus = SMBus(I2CBUS)
bus.write_byte_data(self.I2Caddr, SGP30_MSB, SGP30_MEASURE)
time.sleep(0.02)
resp = bus.read_i2c_block_data(self.I2Caddr, 0, 6)
#read = i2c_msg.read( self.I2Caddr, 6 )
#bus.i2c_rdwr(read)
#resp = list(read)
bus.close()
# Only care about tVOC since eCO2 is just that
# bytes 0-2 are eCO2 + CRC8
# bytes 3-5 are tVOC + CRC8
temp = [resp[3], resp[4], resp[5]]
if (self.crc8(temp) == 0):
t_voc = (resp[3] << 8) | resp[4]
# maintain 1 minute moving average buffer
self.voc_buff[self.voc_ptr] = t_voc
# every 20 seconds write to file system
if (self.voc_ptr % 20 == 0):
# calculate current average voc value
# 60 samples per minute
avg_voc = 0
for i in range(SGP30_MAX):
avg_voc += self.voc_buff[i]
avg_voc /= SGP30_MAX_FLOAT
avg_voc = int(round(avg_voc))
print "sgp30.task() voc: %d avg: %d " % (t_voc, avg_voc)
f = open(self.FptrVoc, "w")
f.write("%d" % avg_voc)
f.close()
self.voc_ptr += 1
if self.voc_ptr >= SGP30_MAX:
self.voc_ptr = 0
except:
bus.close()
print "sgp30.task() failed"
# returning latest value, not average
return t_voc
def get_baseline(self):
try:
# eCO2 baseline word first + crc
# tVOC baseline word second + crc
# these two lists need to be in reverse order for setting baseline
bus = SMBus(I2CBUS)
bus.write_byte_data(self.I2Caddr, SGP30_MSB, SGP30_GET_BASE)
time.sleep(0.02)
# for some reason an extra null byte is needed to get data
resp = bus.read_i2c_block_data(self.I2Caddr, 0, 6)
# below doesn't work
#read = i2c_msg.read( selfI2Caddr, 6 )
#bus.i2c_rdwr(read)
#resp = list(read)
bus.close()
# Because there are two set of baselines we will just
# write them directly to the file-system instead of
# looking for changes
baseline_co2 = [resp[0], resp[1], resp[2]]
baseline_voc = [resp[3], resp[4], resp[5]]
if (self.crc8(baseline_co2) == 0):
# comma delimited output
#msg = str(baseline_co2).strip('[]')
bl = (resp[0] << 8) | resp[1]
f = open(self.FptrBaseC, "w")
f.write("%d" % bl)
f.close()
print "sgp30.get_baseline() co2: 0x%04x" % bl
if (self.crc8(baseline_voc) == 0):
# comma delimited output
#msg = str(baseline_voc).strip('[]')
bl = (resp[3] << 8) | resp[4]
f = open(self.FptrBaseV, "w")
f.write("%d" % bl)
f.close()
print "sgp30.get_baseline() voc: 0x%04x" % bl
except:
bus.close()
print "sgp30.get_baseline() failed"
class RaspberryI2c(I2c):
'''@brief version to actually use the I2C bus
'''
def __init__(self, bus_id):
'''@brief constructor
'''
super(RaspberryI2c, self).__init__(bus_id)
from smbus2 import SMBus
self._bus = SMBus(bus='/dev/i2c-%d' % bus_id)
def _write(self, address, register, data):
self._bus.write_i2c_block_data(address, register, data)
def _read(self, address, register, length):
return bytes(self._bus.read_i2c_block_data(address, register, length))
def _close(self):
self._bus.close()
def read_arduino(slave_addr, sensor_type):
try:
I2Cbus = SMBus(BUS)
# byte = convert_bytes_to_list(bytes(str(sensor_type), "utf-8"))
byte = int(sensor_type)
# I2Cbus.write_i2c_block_data(slave_addr, MEMORY_ADDR, byte)
I2Cbus.write_byte_data(slave_addr, MEMORY_ADDR, byte)
response = I2Cbus.read_i2c_block_data(slave_addr, MEMORY_ADDR,
BYTE_LEN)
# response = I2Cbus.read_byte_data(slave_addr, MEMORY_ADDR)
I2Cbus.close()
return "ok", int(bytearray(response).decode("utf-8", "ignore"))
# return "ok", response
except:
I2Cbus.close()
print("failed to retrieve data from arduino...")
print(traceback.format_exc())
return "error", traceback.format_exc()
class Device(object):
"""Class for communicating with an I2C device using the adafruit-pureio pure
python smbus library, or other smbus compatible I2C interface. Allows reading
and writing 8-bit, 16-bit, and byte array values to registers
on the device."""
def __init__(self, address, busnum):
"""Create an instance of the I2C device at the specified address on the
specified I2C bus number."""
self._address = address
self._bus = SMBus(busnum)
self._logger = logging.getLogger('Rover_log')
def writeByte(self, value):
"""Write an 8-bit value"""
value = value & 0xFF
self._bus.write_byte(self._address, register, value)
self._logger.debug("Wrote 0x%02X to register 0x%02X", value, register)
def write8(self, value, register=0):
"""Write an 8-bit value to the specified register. use register 0 if not needed"""
value = value & 0xFF
self._bus.write_byte_data(self._address, register, value)
self._logger.debug("Wrote 0x%02X to register 0x%02X", value, register)
def readU8(self, register=0):
"""Read an unsigned byte from the specified register. use 0 if egister is not needed"""
result = self._bus.read_byte_data(self._address, register) & 0xFF
self._logger.debug("Read 0x%02X from register 0x%02X", result,
register)
return result
def writeList(self, data, register=0):
"""Write bytes to the specified register. Use 0 if register is not needed"""
self._bus.write_i2c_block_data(self._address, register, data)
self._logger.debug("Wrote to register 0x%02X: %s", register, data)
def readList(self, length, register=0):
"""Read a length number of bytes from the specified register, use 0 if register is not needed. Results
will be returned as a bytearray."""
results = self._bus.read_i2c_block_data(self._address, register,
length)
self._logger.debug("Read the following from register 0x%02X: %s",
register, results)
return results
class LSM6:
"""
Usage is:
with LSM6() as imu:
"""
DS33_SA0_HIGH_ADDRESS = 0b1101011
DS33_SA0_LOW_ADDRESS = 0b1101010
def __init__(self):
self.bus = SMBus(1)
self.address = self.DS33_SA0_HIGH_ADDRESS # TODO: high address is assumed, SA0 connected to supply voltage
# Enable Accelerometer high performance mode, ODR = 1000, (+-2g)
self.bus.write_byte_data(self.address, RegAddr['CTRL1_XL'], 0x80)
# Enable Gyro high performance mode, ODR = 1000, (245 dps)
self.bus.write_byte_data(self.address, RegAddr['CTRL2_G'], 0x80)
# Enable auto increment
self.bus.write_byte_data(self.address, RegAddr['CTRL3_C'], 0x04)
def read_values(self):
"""
This function reads the IMUs measurements
Returns:
The sensors measurements in the following format
(Gyro X, Gyro Y, Gyro Z, Acceleration X, Acc Y, Acc Z)
"""
value_list = self.bus.read_i2c_block_data(
self.address, RegAddr['OUTX_L_G'],
RegAddr['OUTZ_H_XL'] - RegAddr['OUTX_L_G'])
value_list = [(value_list[i], value_list[i + 1])
for i in range(0, len(value_list), 2)]
value_list = list(map(_calc_value, value_list))
for i in range(3):
value_list[i] *= 4.375 # convert to MilliG
for i in range(3, 6):
value_list[i] *= 0.61 # convert to MilliDPS
return tuple(value_list)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, exc_traceback):
self.bus.close()
return True
def main():
# Initialize I2C (SMBus)
bus = SMBus(1)
arduino_addr = 0x7f
arduino_status = [-1 for i in range(10)]
while arduino_status[9] < 255:
try:
print("Requesting status: ", end='')
arduino_status = bus.read_i2c_block_data(arduino_addr, 0, 10)
#print(type(bus.read_byte(arduino_addr)))
except OSError:
print("OSError: Failed to read from specified peripheral")
print("status:", arduino_status)
sleep(10 // 1000) # Take a picture
class MPU6050:
def __init__(self,):
self.bus = SMBus(1)
self.address = 0x68
self.bus.write_byte_data(self.address, 0x6b, 0)
self.bus.write_byte_data(self.address, 26, 3)
def read_data(self,):
raw_data = self.bus.read_i2c_block_data(self.address, 0x3B, 14)
acc_x = (raw_data[0] << 8) + raw_data[1]
if acc_x >= 0x8000:
acc_x = -((65535 - acc_x) + 1)
acc_x = acc_x / 16384.0
acc_y = (raw_data[2] << 8) + raw_data[3]
if acc_y >= 0x8000:
acc_y = -((65535 - acc_y) + 1)
acc_y = acc_y / 16384.0
acc_z = (raw_data[4] << 8) + raw_data[5]
if acc_z >= 0x8000:
acc_z = -((65535 - acc_z) + 1)
acc_z = acc_z / 16384.0
z2 = acc_z * acc_z
x_rot = math.degrees(math.atan2(acc_y, math.sqrt((acc_x * acc_x) + z2)))
y_rot = -math.degrees(math.atan2(acc_x, math.sqrt((acc_y * acc_y) + z2)))
gyro_x = (raw_data[8] << 8) + raw_data[9]
if gyro_x >= 0x8000:
gyro_x = -((65535 - gyro_x) + 1)
gyro_x = gyro_x / 131.0
gyro_y = (raw_data[10] << 8) + raw_data[11]
if gyro_y >= 0x8000:
gyro_y = -((65535 - gyro_y) + 1)
gyro_y = gyro_y / 131.0
return -x_rot, y_rot, acc_z, -gyro_x, gyro_y
class JMOAB_ADC:
def __init__(self):
rospy.init_node('jmoab_ros_adc_node', anonymous=True)
rospy.loginfo("Start JMOAB-ROS-ADC node")
self.bus = SMBus(1)
self.adc_pub = rospy.Publisher("/jmoab_adc",
Float32MultiArray,
queue_size=10)
self.adc_array = Float32MultiArray()
rospy.loginfo("Publishing ADC values on /jmoab_adc topic")
self.loop()
rospy.spin()
def map(self, val, in_min, in_max, out_min, out_max):
m = (out_max - out_min) / (in_max - in_min)
out = m * (val - in_min) + out_min
return out
def convert2voltage(self, raw_list):
raw_list = np.asarray(raw_list)
voltage_array = self.map(raw_list, 0.0, 255.0, 0.0, 40.96)
return voltage_array
def loop(self):
rate = rospy.Rate(10)
while not rospy.is_shutdown():
raw = self.bus.read_i2c_block_data(0x71, 0x00, 6)
voltage_list = self.convert2voltage(raw)
self.adc_array.data = voltage_list
self.adc_pub.publish(self.adc_array)
rate.sleep()
class GDK101(object):
'''driver code for GDK101 gamma ray sensor'''
def __init__(self, busnum, addr):
self.bus = SMBus(busnum)
self.addr = addr
rc = self.reset()
if rc != 1: # reset failed
raise Exception('GKD101: failed to reset sensor')
def _readGKD101(self, cmd):
'''implement simple I²C interface of GDK101
- send command
- block-read two bytes
'''
self.bus.write_byte_data(self.addr, 0, cmd)
return self.bus.read_i2c_block_data(self.addr, 0, 2)
def reset(self):
d = self._readGKD101(CMD_reset)
return d[0]
def read1(self):
''' read 1 min average'''
d = self._readGKD101(CMD_readDose1)
return d[0] + d[1] / 100.
def read10(self):
''' read 10 min sliding average'''
d = self._readGKD101(CMD_readDose10)
return d[0] + d[1] / 100.
def version(self):
'''return firmware version'''
fw = self._readGKD101(CMD_firmware)
return str(fw[0] + fw[1] / 10.)
def close(self):
'''close bus'''
self.bus.close()
class I2C(object):
def __init__(self, bus_number, device_address):
self.smbus = SMBus(bus_number)
self.device_address = device_address
def set_bit(self,register, index):
read_value = np.uint8(self.smbus.read_byte_data(self.device_address, register))
bit_array = np.unpackbits(read_value)
bit_array[index*-1-1] = 1
self.smbus.write_byte_data(self.device_address,register, np.packbits(bit_array))
def clear_bit(self,register, index):
read_value = np.uint8(self.smbus.read_byte_data(self.device_address, register))
bit_array = np.unpackbits(read_value)
bit_array[index*-1-1] = 0
self.smbus.write_byte_data(self.device_address,register, np.packbits(bit_array))
def read_bit(self,register, index):
value = self.smbus.read_byte_data(device_address, register)
eight_bit = format(value, '08b')
return eight_bit[index*(-1)-1]
def write_byte(self,register, value):
self.smbus.write_byte_data(self.device_address,register, int(value))
def read_byte(self, register):
return self.smbus.read_byte_data(self.device_address,register)
def read_block(self,register, number_to_read):
return self.smbus.read_i2c_block_data(self.device_address, register, number_to_read)
def byte_array_to_float32(self,array):
return np.fromiter(array[::-1], dtype=np.uint8).view('<f4')
class I2C:
""" Represents the I2C connection and all its
functions necessary to create the communication
between the Arduino and the Raspberry Pi. """
def __init__(self, address, number_of_ldrs=2):
self.connector = SMBus(1)
self.SLAVE_ADDRESS = address
self.number_of_ldrs = number_of_ldrs
def get_arduino_data(self):
""" Fetchs the Arduino data transfered through I2C. """
return self.connector.read_i2c_block_data(self.SLAVE_ADDRESS, 1,
(self.number_of_ldrs * 2))
def get_ldr_values(self):
""" Gets the ldr values and validates it. """
brute_data = self.get_arduino_data()
ldr_values = convert_byte_to_integer(brute_data)
if not is_valid_ldr_list(ldr_values):
raise InvalidLDRListException
if not is_valid_ldr_data(ldr_values):
raise InvalidLDRListValuesException
return ldr_values
class InputModule(AbstractInput):
""" A sensor support class that monitors the MH-Z16's CO2 concentration """
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__()
self.logger = logging.getLogger("mycodo.inputs.mh_z16")
if not testing:
self.logger = logging.getLogger(
"mycodo.mh_z16_{id}".format(id=input_dev.unique_id.split('-')[0]))
self.interface = input_dev.interface
self.uart_location = input_dev.uart_location
if self.interface == 'UART':
import serial
# Check if device is valid
self.serial_device = is_device(self.uart_location)
if self.serial_device:
try:
self.ser = serial.Serial(self.serial_device, timeout=1)
except serial.SerialException:
self.logger.exception('Opening serial')
else:
self.logger.error(
'Could not open "{dev}". '
'Check the device location is correct.'.format(
dev=self.uart_location))
elif self.interface == 'I2C':
from smbus2 import SMBus
self.i2c_address = int(str(input_dev.i2c_location), 16)
self.i2c_bus = input_dev.i2c_bus
self.cmd_measure = [0xFF, 0x01, 0x9C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63]
self.IOCONTROL = 0X0E << 3
self.FCR = 0X02 << 3
self.LCR = 0X03 << 3
self.DLL = 0x00 << 3
self.DLH = 0X01 << 3
self.THR = 0X00 << 3
self.RHR = 0x00 << 3
self.TXLVL = 0X08 << 3
self.RXLVL = 0X09 << 3
self.i2c = SMBus(self.i2c_bus)
self.begin()
def get_measurement(self):
""" Gets the MH-Z16's CO2 concentration in ppmv via UART"""
return_dict = measurements_dict.copy()
co2 = None
if self.interface == 'UART':
if not self.serial_device: # Don't measure if device isn't validated
return None
self.ser.flushInput()
time.sleep(1)
self.ser.write(bytearray([0xff, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79]))
time.sleep(.01)
resp = self.ser.read(9)
if len(resp) != 0:
high = resp[2]
low = resp[3]
co2 = (high * 256) + low
elif self.interface == 'I2C':
self.write_register(self.FCR, 0x07)
self.send(self.cmd_measure)
try:
co2 = self.parse(self.receive())
except Exception:
co2 = None
return_dict[0]['value'] = co2
return return_dict
def begin(self):
try:
self.write_register(self.IOCONTROL, 0x08)
except IOError:
pass
self.write_register(self.FCR, 0x07)
self.write_register(self.LCR, 0x83)
self.write_register(self.DLL, 0x60)
self.write_register(self.DLH, 0x00)
self.write_register(self.LCR, 0x03)
@staticmethod
def parse(response):
checksum = 0
if len(response) < 9:
return None
for i in range(0, 9):
checksum += response[i]
if response[0] == 0xFF:
if response[1] == 0x9C:
if checksum % 256 == 0xFF:
return (response[2] << 24) + (response[3] << 16) + (response[4] << 8) + response[5]
return None
def read_register(self, reg_addr):
time.sleep(0.01)
return self.i2c.read_byte_data(self.i2c_address, reg_addr)
def write_register(self, reg_addr, val):
time.sleep(0.01)
self.i2c.write_byte_data(self.i2c_address, reg_addr, val)
def send(self, command):
if self.read_register(self.TXLVL) >= len(command):
self.i2c.write_i2c_block_data(self.i2c_address, self.THR, command)
def receive(self):
n = 9
buf = []
start = time.clock()
while n > 0:
rx_level = self.read_register(self.RXLVL)
if rx_level > n:
rx_level = n
buf.extend(self.i2c.read_i2c_block_data(self.i2c_address, self.RHR, rx_level))
n = n - rx_level
if time.clock() - start > 0.2:
break
return buf
class InputModule(AbstractInput):
"""
A sensor support class that measures the AM2320's humidity and temperature
and calculates the dew point
"""
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__()
self.setup_logger(testing=testing, name=__name__, input_dev=input_dev)
self.powered = False
self.sensor = None
self.i2c_address = 0x5C
if not testing:
from smbus2 import SMBus
self.device_measurements = db_retrieve_table_daemon(
DeviceMeasurements).filter(
DeviceMeasurements.device_id == input_dev.unique_id)
self.i2c_bus = input_dev.i2c_bus
self.power_output_id = input_dev.power_output_id
self.start_sensor()
self.sensor = SMBus(self.i2c_bus)
def get_measurement(self):
""" Gets the humidity and temperature """
self.return_dict = measurements_dict.copy()
temperature, humidity = self.read()
if self.is_enabled(0):
self.set_value(0, temperature)
if self.is_enabled(1):
self.set_value(1, humidity)
if (self.is_enabled(2) and self.is_enabled(0) and self.is_enabled(1)):
self.set_value(
2, calculate_dewpoint(self.get_value(0), self.get_value(1)))
if (self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1)):
self.set_value(
3,
calculate_vapor_pressure_deficit(self.get_value(0),
self.get_value(1)))
return self.return_dict
def read(self):
try:
self.sensor.write_i2c_block_data(self.i2c_address, 0x03,
[0x00, 0x04])
except OSError as e:
self.logger.error(e)
time.sleep(0.02)
blocks = self.sensor.read_i2c_block_data(self.i2c_address, 0, 6)
humidity = ((blocks[2] << 8) + blocks[3]) / 10.0
temperature = ((blocks[4] << 8) + blocks[5]) / 10.0
return temperature, humidity
def setup(self):
try:
self.sensor.write_i2c_block_data(self.i2c_address, 0x00, [])
except OSError as e:
self.logger.error(e)
time.sleep(0.1)
class InputModule(AbstractInput):
"""
A sensor support class that measures the AM2320's humidity and temperature
and calculates the dew point
"""
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__()
self.logger = logging.getLogger('mycodo.inputs.am2320')
self.powered = False
self.sensor = None
self.i2c_address = 0x5C
if not testing:
from smbus2 import SMBus
self.logger = logging.getLogger(
'mycodo.am2320_{id}'.format(
id=input_dev.unique_id.split('-')[0]))
self.device_measurements = db_retrieve_table_daemon(
DeviceMeasurements).filter(
DeviceMeasurements.device_id == input_dev.unique_id)
self.i2c_bus = input_dev.i2c_bus
self.power_output_id = input_dev.power_output_id
self.start_sensor()
self.sensor = SMBus(self.i2c_bus)
def get_measurement(self):
""" Gets the humidity and temperature """
return_dict = measurements_dict.copy()
temperature, humidity = self.read()
if self.is_enabled(0):
return_dict[0]['value'] = temperature
if self.is_enabled(1):
return_dict[1]['value'] = humidity
if (self.is_enabled(2) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[2]['value'] = calculate_dewpoint(
return_dict[0]['value'], return_dict[1]['value'])
if (self.is_enabled(3) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[3]['value'] = calculate_vapor_pressure_deficit(
return_dict[0]['value'], return_dict[1]['value'])
return return_dict
def read(self):
try:
self.sensor.write_i2c_block_data(
self.i2c_address, 0x03, [0x00, 0x04])
except OSError as e:
self.logger.error(e)
time.sleep(0.02)
blocks = self.sensor.read_i2c_block_data(self.i2c_address, 0, 6)
humidity = ((blocks[2] << 8) + blocks[3]) / 10.0
temperature = ((blocks[4] << 8) + blocks[5]) / 10.0
return temperature, humidity
def setup(self):
try:
self.sensor.write_i2c_block_data(self.i2c_address, 0x00, [])
except OSError as e:
self.logger.error(e)
time.sleep(0.1)
