def _read_data(self):
_time = time.time()
if self.MIN_SAMPLING_PERIOD > _time - self._time:
logger.debug(
'ignore call AM2315._read_data(): sampling is below 2s')
return
self._time = _time
logger.debug('call AM2315._read_data()')
self._wakeup()
try:
self._bus.write_i2c_block_data(self.addr, self.FC_READ_REG,
[0x00, 0x04])
time.sleep(0.0015)
vals = self._bus.read_i2c_block_data(self.addr, self.FC_READ_REG,
8)
fn_code, nbytes, hum_msb, hum_lsb, temp_msb, temp_lsb, crc_lsb, crc_msb = vals
hum = (hum_msb << 8) | hum_lsb
temp = (temp_msb << 8) | temp_lsb
crc_code = (crc_msb << 8) | crc_lsb
self._humidity = hum / 10.0
self._temperature = temp / 10.0
crc = self._compute_crc16(vals, 6)
crc_check = crc == crc_code
logger.debug('call AM2315._compute_crc16(data=%s, %s)=%s', vals, 6,
crc)
logger.debug('crc_code: %s, crc: %s, crc_check: %s', crc_code, crc,
crc_check)
except OSError as e:
logger.debug('AM2315 is probably not awake, OSError: %s', e)
def _read_calibration_data(self):
logger.debug('read calibration data')
dig_88_A1 = self._bus.read_i2c_block_data(self.addr, 0x88, 26)
dig_88_A1 = struct.unpack('<HhhHhhhhhhhhBB', bytearray(dig_88_A1))
(self.dig_T1, self.dig_T2, self.dig_T3, self.dig_P1, self.dig_P2,
self.dig_P3, self.dig_P4, self.dig_P5, self.dig_P6, self.dig_P7,
self.dig_P8, self.dig_P9, _, self.dig_H1) = dig_88_A1
dig_e1_e7 = self._bus.read_i2c_block_data(self.addr, 0xE1, 7)
self.dig_H2, self.dig_H3 = struct.unpack('<hB', bytearray(dig_e1_e7[:3]))
e4_sign = struct.unpack('<b', bytes([dig_e1_e7[3]]))[0]
self.dig_H4 = (e4_sign << 4) | (dig_e1_e7[4] & 0xF)
e6_sign = struct.unpack('<b', bytes([dig_e1_e7[5]]))[0]
self.dig_H5 = (e6_sign << 4) | (dig_e1_e7[4] >> 4)
self.dig_H6 = struct.unpack('<b', bytes([dig_e1_e7[6]]))[0]
keys = ['T1', 'T2', 'T3', 'P1', 'P2', 'P3', 'P4', 'P5', 'P6', 'P7', 'P8',
'P9', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6']
values = [self.dig_T1, self.dig_T2, self.dig_T3, self.dig_P1, self.dig_P2,
self.dig_P3, self.dig_P4, self.dig_P5, self.dig_P6, self.dig_P7,
self.dig_P8, self.dig_P9, self.dig_H1, self.dig_H2, self.dig_H3,
self.dig_H4, self.dig_H5, self.dig_H6]
self._calibration_data = dict(zip(keys, values))
for key, val in self._calibration_data.items():
logger.debug('%s=%s', key, val)
def _set_meas(self):
logger.debug('configure temperature and pressure osrs')
settings = 0
settings |= (self.osrs_t << 5)
settings |= (self.osrs_p << 2)
settings |= self.power_mode
self._bus.write_byte_data(self.addr, self.REG_CTRL_MEAS, settings)
def __init__(self, bus, addr=DEFAULT_ADDR):
super(MPL3115A2, self).__init__(bus, addr)
logger.debug('create MPL3115A2(addr=%s) object', addr)
self._mode = self.MODE_BAROMETER
self._raw = self.RAW
self._os = self.OS
self._rst = self.RST
self._ost = self.OST
self._sbyb = self.SBYB
settings = self._mode << 7
settings |= (self._raw << 6)
settings |= (self._os << 3)
settings |= (self._rst << 2)
settings |= (self._ost << 1)
settings |= self._sbyb
# enable data flags in PT_DATA_CFG
pt_data_cfg = (self.DREM << 2)
pt_data_cfg |= (self.PDEFE << 1)
pt_data_cfg |= self.TDEFE
self._bus.write_byte_data(self.addr, self.PT_DATA_CFG, pt_data_cfg)
# set settings
self._bus.write_byte_data(self.addr, self.CTRL_REG1, settings)
def _set_mode(self, mode):
self._mode = mode if mode in self._MODES else self.MODE_HRES
self._mode_data = self._MODES[self._mode]
cmd, _time = self._mode_data
logger.debug(
'set mode to %s, measurement cmd: %#04x, max measurement time: %ss',
self._mode, cmd, _time)
def read_temperature(self):
self._trigger_temperature_measurement()
logger.debug('read temperature data')
msb = self._bus.read_byte(self.addr)
lsb = self._bus.read_byte(self.addr)
tdata = (msb << 8) | lsb
temp = (tdata / 65536.0) * 165 - 40
return temp
def __init__(self, bus, addr=DEFAULT_ADDR):
super(MPL115A2, self).__init__(bus, addr)
logger.debug('create MPL115A2(addr=%s) object', addr)
self.dig_A0 = self.dig_B1 = self.dig_B2 = self.dig_C12 = 0.0
self._pressure = self._temperature = 0.0
self._calibration_data = {}
self._read_calibration_data()
def read_humidity(self):
self._trigger_humidity_measurement()
logger.debug('read humidity data')
msb = self._bus.read_byte(self.addr)
lsb = self._bus.read_byte(self.addr)
hdata = (msb << 8) | lsb
hum = (hdata / 65536.0) * 100
return hum
def read_humidity(self):
logger.debug('read humidity data')
self._bus.write_byte(self.addr, self.CMD_MEASURE_HUM)
time.sleep(0.05)
msb = self._bus.read_byte(self.addr)
lsb = self._bus.read_byte(self.addr)
data = (msb << 8) | lsb
hum = (125 * data) / 65536.0 - 6
return hum
def read_temperature(self):
logger.debug('read temperature data')
data = self._bus.read_word_data(self.addr, self.REG_TMP)
msb = data & 0x00ff
lsb = (data & 0xff00) >> 8
t0 = msb
t1 = (lsb & 0x80) >> 7
temperature = t0 + 0.5 * t1
return temperature
def read_temperature(self):
logger.debug('read temperature data')
self._bus.write_byte(self.addr, self.CMD_MEASURE_TEMP)
time.sleep(0.05)
msb = self._bus.read_byte(self.addr)
lsb = self._bus.read_byte(self.addr)
data = (msb << 8) | lsb
temp = (175.72 * data) / 65536.0 - 46.85
return temp
def _read_raw_temperature(self):
logger.debug('read temperature data')
self._bus.write_byte_data(self.addr, self.REG_CTRL_MEAS,
self.CTRL_READ_TEMP)
time.sleep(0.005)
msb, lsb = self._bus.read_i2c_block_data(self.addr, self.REG_OUT_MSB,
2)
adc_t = (msb << 8) | lsb
return adc_t
def _read_temperature_data(self, wait=False):
logger.debug('read temperature data')
if wait:
self._wait()
# the temperature value is representated as a Q8.4 fixed point
t_msb = self._bus.read_byte_data(self.addr, 0x04)
t_lsb = self._bus.read_byte_data(self.addr, 0x05)
t_data = ((t_msb << 8) | t_lsb) >> 4
return t_data / 16
def read_temperature(self):
# black magic temperature formula: http://forums.adafruit.com/viewtopic.php?f=25&t=34787
# thx @park
logger.debug('read temperature data')
self._bus.write_byte_data(self.addr, self.CMD_CONVERT, 0x00)
time.sleep(5 / 1000.0)
adc_t = self._read_adc_t()
t = adc_t * -0.1706 + 112.27
return t
def __init__(self, bus, addr=DEFAULT_ADDR):
super(BH1750, self).__init__(bus, addr)
logger.debug('create %s(addr=%#04x) object', self.__class__.__name__,
addr)
self._illuminance = 0.0
self._power_on()
self._mode = None
self._mode_data = None
self._set_mode(self.MODE_HRES)
self._reset()
def _read_pressure_data(self, wait=False):
logger.debug('read pressure data')
if wait:
self._wait()
# the pressure value is representated as a Q18.2 fixed point
p_msb = self._bus.read_byte_data(self.addr, 0x01)
p_csb = self._bus.read_byte_data(self.addr, 0x02)
p_lsb = self._bus.read_byte_data(self.addr, 0x03)
p_data = (p_msb << 16 | (p_csb << 8) | p_lsb) >> 4
return p_data / 4
def read_pressure(self):
logger.debug('read pressure data')
self._bus.write_byte_data(self.addr, self.CMD_CONVERT, 0x00)
time.sleep(5 / 1000.0)
adc_t = self._read_adc_t()
msb, lsb = self._bus.read_i2c_block_data(self.addr, self.REG_PADC, 2)
adc_p = ((msb << 8) | lsb) >> 6
p_comp = self.dig_A0 + (
self.dig_B1 + self.dig_C12 * adc_t) * adc_p + self.dig_B2 * adc_t
return ((p_comp / 15.737) + 50.0) * 1000
def _read_illuminance_data(self):
self._trigger_measurement()
_, _time = self._mode_data
wait_s = 2 * _time
logger.debug('wait %ss before reading measurement data', wait_s)
time.sleep(wait_s)
logger.debug('read measurement data')
msb, lsb = self._bus.read_i2c_block_data(self.addr, 0x00, 2)
i_word = (msb << 8) | lsb
self._illuminance = i_word / 1.2
return self._illuminance
def read_temperature(self):
logger.debug('read temperature data')
data = self._bus.read_word_data(self.addr, self.REG_TMP)
msb = data & 0x00FF
lsb = (data & 0xFF00) >> 8
word = (msb << 8) | lsb
temperature = word & 0x0FFF
temperature /= 16.0
if word & 0x1000:
temperature -= 256
return temperature
def __init__(self, bus, addr=DEFAULT_ADDR):
super(HDC1008, self).__init__(bus, addr)
logger.debug('create HDC1008(addr=%s) object', addr)
self._temperature = self._humidity = 0.0
settings = 0
settings |= (self.RST << 15)
settings |= (self.HEAT << 13)
settings |= (self.MODE << 12)
settings |= (self.BTST << 11)
settings |= (self.TRES << 10)
settings |= (self.HRES << 8)
self._bus.write_word_data(self.addr, self.REG_CONFIG, settings)
def _read_raw_sensor_data(self):
logger.debug('read pressure data')
press_msb, press_lsb, press_xlsb = self._bus.read_i2c_block_data(
self.addr, self.REG_PRESS, 3)
logger.debug('read temperature data')
temp_msb, temp_lsb, temp_xlsb = self._bus.read_i2c_block_data(
self.addr, self.REG_TEMP, 3)
adc_p = (press_msb << 12) | (press_lsb << 4) | (press_xlsb >> 4)
adc_t = (temp_msb << 12) | (temp_lsb << 4) | (temp_xlsb >> 4)
return adc_p, adc_t
def _read_data(self):
self._trigger_measurement()
time.sleep(self.REP_HIGH_S)
logger.debug('read temperature and humidity data')
data = self._bus.read_i2c_block_data(self.addr, 0x00, 6)
t_msb, t_lsb, t_crc, h_msb, h_lsb, h_crc = data
t_word = (t_msb << 8) | t_lsb
h_word = (h_msb << 8) | h_lsb
self._temperature = self._compute_temperature_c(t_word)
self._humidity = self._compute_humidity(h_word)
return self._temperature, self._humidity
def __init__(self, bus, addr=DEFAULT_ADDR):
super(BMP085, self).__init__(bus, addr)
logger.debug('create %s(addr=%s) object', self.DRIVER_NAME.upper(),
addr)
self.dig_AC1 = self.dig_AC2 = self.dig_AC3 = self.dig_AC4 = \
self.dig_AC5 = self.dig_AC6 = self.dig_B1 = self.dig_B2 = \
self.dig_MB = self.dig_MC = self.dig_MD = 0
self.mode = self.MODE_STANDARD
self.id = self._read_id()
self._temperature = self._pressure = 0
self._calibration_data = {}
self._read_calibration_data()
def _read_calibration_data(self):
logger.debug('read calibration data')
calib_data = self._bus.read_i2c_block_data(self.addr, self.REG_A0, 8)
self.dig_A0, self.dig_B1, self.dig_B2, self.dig_C12 = struct.unpack(
'>hhhh', bytearray(calib_data))
self.dig_A0 /= 8.0
self.dig_B1 /= 8192.0
self.dig_B2 /= 16384.0
self.dig_C12 /= 16777216.0
keys = ['A0', 'B1', 'B2', 'C12']
values = [self.dig_A0, self.dig_B1, self.dig_B2, self.dig_C12]
self._calibration_data = dict(zip(keys, values))
for key, val in self._calibration_data.items():
logger.debug('%s=%s', key, val)
def _read_calibration_data(self):
logger.debug('read calibration data')
dig_AC1_MD = self._bus.read_i2c_block_data(self.addr, self.REG_AC1, 22)
dig_AC1_MD = struct.unpack('>hhhHHHhhhhh', bytearray(dig_AC1_MD))
(self.dig_AC1, self.dig_AC2, self.dig_AC3, self.dig_AC4, self.dig_AC5,
self.dig_AC6, self.dig_B1, self.dig_B2, self.dig_MB, self.dig_MC,
self.dig_MD) = dig_AC1_MD
keys = [
'AC1', 'AC2', 'AC3', 'AC4', 'AC5', 'AC6', 'B1', 'B2', 'MB', 'MC',
'MD'
]
self._calibration_data = dict(zip(keys, dig_AC1_MD))
for key, val in self._calibration_data.items():
logger.debug('%s=%s', key, val)
def _read_calibration_data(self):
logger.debug('read calibration data')
dig_88_A1 = self._bus.read_i2c_block_data(self.addr, 0x88, 26)
dig_88_A1 = struct.unpack('<HhhHhhhhhhhhBB', bytearray(dig_88_A1))
(self.dig_T1, self.dig_T2, self.dig_T3, self.dig_P1, self.dig_P2,
self.dig_P3, self.dig_P4, self.dig_P5, self.dig_P6, self.dig_P7,
self.dig_P8, self.dig_P9, _, self.dig_H1) = dig_88_A1
keys = [
'T1', 'T2', 'T3', 'P1', 'P2', 'P3', 'P4', 'P5', 'P6', 'P7', 'P8',
'P7', 'H1'
]
self._calibration_data = dict(zip(keys, dig_88_A1))
for key, val in self._calibration_data.items():
logger.debug('%s=%s', key, val)
def _read_raw_pressure(self):
logger.debug('read pressure data')
self._bus.write_byte_data(self.addr, self.REG_CTRL_MEAS,
self.CTRL_READ_PRESS + (self.mode << 6))
if self.mode == self.MODE_LOW:
time.sleep(0.005)
elif self.mode == self.MODE_HIGH:
time.sleep(0.014)
elif self.mode == self.MODE_ULTRA_HIGH:
time.sleep(0.026)
else:
time.sleep(0.008)
msb, lsb, xlsb = self._bus.read_i2c_block_data(self.addr,
self.REG_OUT_MSB, 3)
adc_p = ((msb << 16) + (lsb << 8) + xlsb) >> (8 - self.mode)
return adc_p
def __init__(self, bus, addr=DEFAULT_ADDR):
super(BMP280, self).__init__(bus, addr)
logger.debug('create BMP280(addr=%s) object', addr)
self.dig_T1 = self.dig_T2 = self.dig_T3 = self.dig_P1 = self.dig_P2 = \
self.dig_P3 = self.dig_P4 = self.dig_P5 = self.dig_P6 = \
self.dig_P7 = self.dig_P8 = self.dig_P9 = 0
self.t_fine = 0.0
self._temperature = self._humidity = self._pressure = 0.0
self._calibration_data = {}
self._read_calibration_data()
self.osrs_h = 1
self.osrs_t = 1
self.osrs_p = 1
self.power_mode = 3
self.filter = 0
self.t_sb = 5
self._set_settings()
self._set_config()
def _wakeup(self):
logger.debug('call AM2315._wakeup()')
try:
self._bus.write_byte(self.addr, 0x00)
logger.debug('AM2315 is awake')
except OSError as e:
logger.debug('AM2315 was not awake, but should be awake now')
def __init__(self, bus, addr=ADDR):
super(SI7021, self).__init__(bus, addr)
logger.debug('create SI7021(addr=%s) object', addr)
self._temperature = self._humidity = 0.0
