class TouchSlider():
left_button_press_flag = UNPRESSED
right_button_press_flag = UNPRESSED
def __init__(self, bus_num=1, addr=TOUCH_SENSOR_CY8C_DEFAULT_IIC_ADDR):
self.bus = Bus(bus_num)
self.addr = addr
def read_sensor_button_value(self):
button_value = self.bus.read_byte_data(self.addr, BUTTON_REG_ADDR)
return button_value
def read_sensor_slider_value(self):
slider_value = self.bus.read_byte_data(self.addr,
TOUCH_SLIDER_REG_ADDR)
return slider_value
def parse_and_print_result(self, button_value, slider_value):
'''
if(0 == button_value):
if(PRESSED == self.left_button_press_flag):
print("Left button is released")
self.left_button_press_flag = UNPRESSED
if(PRESSED == self.right_button_press_flag):
print("Right button is released")
self.right_button_press_flag = UNPRESSED
'''
if (0x01 == button_value & 0x1):
if (UNPRESSED == self.left_button_press_flag):
print("Left button is pressed")
self.left_button_press_flag = PRESSED
elif (0 == button_value & 0x1):
if (PRESSED == self.left_button_press_flag):
print("Left button is released")
self.left_button_press_flag = UNPRESSED
if (0x02 == button_value & 0x2):
if (UNPRESSED == self.right_button_press_flag):
print("Right button is pressed")
self.right_button_press_flag = PRESSED
elif (0 == button_value & 0x2):
if (PRESSED == self.right_button_press_flag):
print("Right button is released")
self.right_button_press_flag = UNPRESSED
if (0 != slider_value):
print("Slider is pressed,value is %s" % (slider_value))
def listen_sensor_status(self):
while True:
button_value = self.read_sensor_button_value()
slider_value = self.read_sensor_slider_value()
self.parse_and_print_result(button_value, slider_value)
time.sleep(.05)
class ADXL372(object):
def __init__(self, address=0x53, i2c=None):
self.address = address
self.bus = Bus(i2c)
print('ID: {}'.format(self.id))
self.reset()
self._timing_control = 0
self._power_control = 0
self._measurement_control = 0
self._sample_rate = 400
self._bandwidth = 200
self._mode = STANDBY_MODE
def read(self):
raw = self.bus.read_i2c_block_data(self.address, ADXL372_X_DATA_H, 6)
return self.xyz(raw)
def read_fifo(self, size):
data = []
while size > 32:
data.extend(
self.bus.read_i2c_block_data(self.address, ADXL372_FIFO_DATA,
32))
size -= 32
if size:
data.extend(
self.bus.read_i2c_block_data(self.address, ADXL372_FIFO_DATA,
size))
return data
def reset(self):
self.write_register(ADXL372_SRESET, 0x52)
def timing_control(self, sample_rate=400, wakeup_ms=52):
try:
sample_bits = ADXL372_SAMPLE_RATE.index(sample_rate)
wakeup_bits = ADXL372_WAKEUP_TIME.index(wakeup_ms)
except ValueError:
print('Supported sample rates: {}'.format(ADXL372_SAMPLE_RATE))
print('Supported wakeup time: {}'.format(ADXL372_WAKEUP_TIME))
raise ValueError('Invalid sample rate or wakeup time')
self._timing_control = (sample_bits << TIMING_ODR_POS) | (
wakeup_bits << TIMING_WUR_POS)
self._sample_rate = sample_rate
self.write_register(ADXL372_TIMING, self._timing_control)
def power_control(self, mode=0, low_pass_filter=0, high_pass_filter=0):
if mode not in ADXL372_OP_MODE:
raise ValueError('Invalid operating mode')
value = mode
if not low_pass_filter:
value |= 1 << 3
if not high_pass_filter:
value |= 1 << 2
self._mode = mode
self._power_control = value
self.write_register(ADXL372_POWER_CTL, value)
def measurement_control(self,
bandwidth=200,
low_noise=0,
linkloop=0,
autosleep=0):
try:
value = ADXL372_BANDWIDTH.index(bandwidth)
except ValueError:
print('Supported bandwidth: {}'.format(ADXL372_BANDWIDTH))
raise ValueError('Invalid bandwidth')
if low_noise:
value |= 1 << 3
if linkloop:
value |= linkloop << 4
if autosleep:
value |= 1 << 6
self._measurement_control = value
self.write_register(ADXL372_MEASURE, value)
def fifo_control(self, mode=FIFO_STREAMED, format=FIFO_XYZ, samples=0x80):
self.write_register(ADXL372_FIFO_SAMPLES, samples & 0xFF)
self.write_register(ADXL372_FIFO_CTL, ((samples >> 8) & 0x1) |
(mode << 1) | (format << 3))
@property
def sample_rate(self):
return self._sample_rate
@sample_rate.setter
def sample_rate(self, value):
self._sample_rate = value
try:
simple_bits = ADXL372_SAMPLE_RATE.index(value)
except ValueError:
print('Supported sample rates: {}'.format(ADXL372_SAMPLE_RATE))
raise ValueError('Invalid sample rate')
self._timing_control = (self._timing_control & TIMING_ODR_MASK) | (
simple_bits << TIMING_ODR_POS)
self.write_register(ADXL372_TIMING, self._timing_control)
@property
def bandwidth(self):
return self._bandwidth
@bandwidth.setter
def bandwidth(self, value):
if value in ADXL372_BANDWIDTH:
self._bandwidth = value
bandwidth_bits = ADXL372_BANDWIDTH.index(value)
self._measurement_control = (
self._measurement_control
& MEASURE_BANDWIDTH_MASK) | bandwidth_bits
else:
print('Supported bandwidth: {}'.format(ADXL372_BANDWIDTH))
raise ValueError('Invalid bandwidth')
@property
def mode(self):
return self._mode
@mode.setter
def mode(self, value):
if value in ADXL372_OP_MODE:
self._mode = value
self._power_control = (self._power_control
& PWRCTRL_OPMODE_MASK) | value
self.write_register(ADXL372_POWER_CTL, value)
else:
raise ValueError('Invalid operating mode')
@property
def samples_in_fifo(self):
data = self.bus.read_word_data(self.address, ADXL372_FIFO_ENTRIES_2)
return ((data & 0x3) << 8) | ((data >> 8) & 0xFF)
@property
def status(self):
return self.bus.read_word_data(self.address, ADXL372_STATUS_1)
@property
def id(self):
return self.bus.read_i2c_block_data(self.address, ADXL372_ADI_DEVID, 4)
def read_register(self, register):
return self.bus.read_byte_data(self.address, register)
def write_register(self, register, value):
self.bus.write_byte_data(self.address, register, value)
def update_register(self, register, mask, shift, value):
data = self.read_register(register)
data = (data & mask) | ((value << shift) & ~mask)
self.write_register(register, data)
def dump_registers(self):
registers = self.bus.read_i2c_block_data(self.address, 0x39,
0x43 - 0x39)
for register in registers:
print(hex(register))
def xyz(self, raw):
value = [0] * 3
for i in range(3):
value[i] = (raw[2 * i] << 4) | (raw[2 * i + 1] >> 4)
if value[i] & 0xF00:
value[i] = -((~value[i] & 0xFFF) + 1)
return value
class grove_si114x(object):
def __init__(self, address=SI114X_ADDR):
self.bus = Bus()
self.addr = address
self._logger = logging.getLogger('grove_si114x')
assert self.Begin(
), "Please check if the I2C device insert in I2C of Base Hat"
def __del__(self):
self._WriteByte(SI114X_COMMAND, SI114X_RESET)
time.sleep(0.1)
self.bus.close()
def __exit__(self):
self.bus.close()
#Init the si114x and begin to collect data
def Begin(self):
if self._ReadByte(SI114X_PART_ID) != 0X45:
return False
self.Reset()
#INIT
self.DeInit()
return True
#reset the si114x
#inclue IRQ reg, command regs...
def Reset(self):
self._WriteByte(SI114X_MEAS_RATE0, 0)
self._WriteByte(SI114X_MEAS_RATE1, 0)
self._WriteByte(SI114X_IRQ_ENABLE, 0)
self._WriteByte(SI114X_IRQ_MODE1, 0)
self._WriteByte(SI114X_IRQ_MODE2, 0)
self._WriteByte(SI114X_INT_CFG, 0)
self._WriteByte(SI114X_IRQ_STATUS, 0xFF)
self._WriteByte(SI114X_COMMAND, SI114X_RESET)
time.sleep(0.1)
self._WriteByte(SI114X_HW_KEY, 0x17)
time.sleep(0.1)
#default init
def DeInit(self):
#ENABLE UV reading
#these reg must be set to the fixed value
self._WriteByte(SI114X_UCOEFF0, 0x29)
self._WriteByte(SI114X_UCOEFF1, 0x89)
self._WriteByte(SI114X_UCOEFF2, 0x02)
self._WriteByte(SI114X_UCOEFF3, 0x00)
self.WriteParamData(
SI114X_CHLIST, SI114X_CHLIST_ENUV | SI114X_CHLIST_ENALSIR
| SI114X_CHLIST_ENALSVIS | SI114X_CHLIST_ENPS1)
#
#set LED1 CURRENT(22.4mA)(It is a normal value for many LED)
#
self.WriteParamData(SI114X_PS1_ADCMUX, SI114X_ADCMUX_LARGE_IR)
self._WriteByte(SI114X_PS_LED21, SI114X_LED_CURRENT_22MA)
self.WriteParamData(SI114X_PSLED12_SELECT,
SI114X_PSLED12_SELECT_PS1_LED1) #
#
#PS ADC SETTING
#
self.WriteParamData(SI114X_PS_ADC_GAIN, SI114X_ADC_GAIN_DIV1)
self.WriteParamData(SI114X_PS_ADC_COUNTER,
SI114X_ADC_COUNTER_511ADCCLK)
self.WriteParamData(
SI114X_PS_ADC_MISC,
SI114X_ADC_MISC_HIGHRANGE | SI114X_ADC_MISC_ADC_RAWADC)
#
#VIS ADC SETTING
#
self.WriteParamData(SI114X_ALS_VIS_ADC_GAIN, SI114X_ADC_GAIN_DIV1)
self.WriteParamData(SI114X_ALS_VIS_ADC_COUNTER,
SI114X_ADC_COUNTER_511ADCCLK)
self.WriteParamData(SI114X_ALS_VIS_ADC_MISC, SI114X_ADC_MISC_HIGHRANGE)
#
#IR ADC SETTING
#
self.WriteParamData(SI114X_ALS_IR_ADC_GAIN, SI114X_ADC_GAIN_DIV1)
self.WriteParamData(SI114X_ALS_IR_ADC_COUNTER,
SI114X_ADC_COUNTER_511ADCCLK)
self.WriteParamData(SI114X_ALS_IR_ADC_MISC, SI114X_ADC_MISC_HIGHRANGE)
#
#interrupt enable
#
self._WriteByte(SI114X_INT_CFG, SI114X_INT_CFG_INTOE)
self._WriteByte(SI114X_IRQ_ENABLE, SI114X_IRQEN_ALS)
#
#AUTO RUN
#
self._WriteByte(SI114X_MEAS_RATE0, 0xFF)
self._WriteByte(SI114X_COMMAND, SI114X_PSALS_AUTO)
#read param data
def ReadParamData(self, Reg):
self._WriteByte(SI114X_COMMAND, Reg | SI114X_QUERY)
return self._ReadByte(SI114X_RD)
#writ param data
def WriteParamData(self, Reg, Value):
#write Value into PARAMWR reg first
self._WriteByte(SI114X_WR, Value)
self._WriteByte(SI114X_COMMAND, Reg | SI114X_SET)
#SI114X writes value out to PARAM_RD,read and confirm its right
return self._ReadByte(SI114X_RD)
#Read Visible Value
@property
def ReadVisible(self):
return self._ReadHalfWord(SI114X_ALS_VIS_DATA0)
#Read IR Value
@property
def ReadIR(self):
return self._ReadHalfWord(SI114X_ALS_IR_DATA0)
#Read UV Value
#this function is a int value ,but the real value must be div 100
@property
def ReadUV(self):
return self._ReadHalfWord(SI114X_AUX_DATA0_UVINDEX0)
#Read Proximity Value
def ReadProximity(self, PSn):
return self._ReadHalfWord(PSn)
# read 8 bit data from Reg
def _ReadByte(self, Reg):
try:
read_data = self.bus.read_byte_data(self.addr, Reg)
except OSError:
raise OSError(
"Please check if the I2C device insert in I2C of Base Hat")
return read_data
# Write 8 bit data to Reg
def _WriteByte(self, Reg, Value):
try:
self.bus.write_byte_data(self.addr, Reg, Value)
except OSError:
raise OSError(
"Please check if the I2C device insert in I2C of Base Hat")
# read 16 bit data from Reg
def _ReadHalfWord(self, Reg):
try:
block = self.bus.read_i2c_block_data(self.addr, Reg, 2)
except OSError:
raise OSError(
"Please check if the I2C device insert in I2C of Base Hat")
read_data = (block[0] & 0xff) | (block[1] << 8)
return read_data
class DHT(object):
DHT_TYPE = {'DHT11': '11', 'DHT22': '22', 'DHT10': '10'}
DEFAULT_ADDR = 0x38
RESET_REG_ADDR = 0xba
MAX_CNT = 320
PULSES_CNT = 41
def __init__(self, dht_type, pin=12, bus_num=1):
if dht_type != self.DHT_TYPE['DHT11'] and dht_type != self.DHT_TYPE[
'DHT22'] and dht_type != self.DHT_TYPE['DHT10']:
print('ERROR: Please use 11|22|10 as dht type.')
exit(1)
self.dht_type = dht_type
if dht_type == self.DHT_TYPE['DHT10']:
self.bus = Bus(bus_num)
self.addr = self.DEFAULT_ADDR
self._dht10_init()
else:
self.pin = GPIO(pin, GPIO.OUT)
self._last_temp = 0.0
self._last_humi = 0.0
@property
def dht_type(self):
return self._dht_type
@dht_type.setter
def dht_type(self, type):
self._dht_type = type
######################## dht10 ############################
def _dht10_start_mess(self):
reg_set = [0x33, 0x00]
self.bus.write_i2c_block_data(self.addr, 0xac, reg_set)
def _dht10_reset(self):
self.bus.write_byte(self.addr, self.RESET_REG_ADDR)
def _dht10_set_system_cfg(self):
reg_set = [0x08, 0x00]
self.bus.write_i2c_block_data(self.addr, 0xe1, reg_set)
def _dht10_read_status(self):
return self.bus.read_byte_data(self.addr, 0)
def _dht10_init(self):
time.sleep(.5)
self._dht10_reset()
# delay is needed after reset
time.sleep(.3)
self._dht10_set_system_cfg()
status = self._dht10_read_status()
# we must check the calibrate flag, bit[3] : 1 for calibrated ok,0 for Not calibrated.
while status & 0x08 != 0x08:
print("try calibrated again!n\n")
self._dht10_reset()
time.sleep(.5)
self.bus.dth10_set_system_cfg()
status = self._dht10_read_status()
time.sleep(.5)
#########################################################
def _read(self):
if self.dht_type == self.DHT_TYPE['DHT10']:
t = 0
h = 0
self._dht10_start_mess()
time.sleep(.075)
# we must check the device busy flag, bit[7] : 1 for busy ,0 for idle.
while (self._dht10_read_status() & 0x80) != 0:
time.sleep(.5)
print("wait for device not busy")
from smbus2 import SMBus, i2c_msg, SMBusWrapper
with SMBusWrapper(1) as bus:
msg = i2c_msg.read(self.addr, 6)
data = bus.i2c_rdwr(msg)
data = list(msg)
t = (t | data[1]) << 8
t = (t | data[2]) << 8
t = (t | data[3]) >> 4
h = (h | data[3]) << 8
h = (h | data[4]) << 8
h = (h | data[5]) & 0xfffff
t = t * 100.0 / 1024 / 1024
h = h * 200.0 / 1024 / 1024 - 50
return t, h
# Send Falling signal to trigger sensor output data
# Wait for 20ms to collect 42 bytes data
else:
self.pin.dir(GPIO.OUT)
self.pin.write(1)
time.sleep(.2)
self.pin.write(0)
time.sleep(.018)
self.pin.dir(GPIO.IN)
# a short delay needed
for i in range(10):
pass
# pullup by host 20-40 us
count = 0
while self.pin.read():
count += 1
if count > self.MAX_CNT:
# print("pullup by host 20-40us failed")
return None, "pullup by host 20-40us failed"
pulse_cnt = [0] * (2 * self.PULSES_CNT)
fix_crc = False
for i in range(0, self.PULSES_CNT * 2, 2):
while not self.pin.read():
pulse_cnt[i] += 1
if pulse_cnt[i] > self.MAX_CNT:
# print("pulldown by DHT timeout %d" % i)
return None, "pulldown by DHT timeout %d" % i
while self.pin.read():
pulse_cnt[i + 1] += 1
if pulse_cnt[i + 1] > self.MAX_CNT:
# print("pullup by DHT timeout %d" % (i + 1))
if i == (self.PULSES_CNT - 1) * 2:
# fix_crc = True
# break
pass
return None, "pullup by DHT timeout %d" % i
total_cnt = 0
for i in range(2, 2 * self.PULSES_CNT, 2):
total_cnt += pulse_cnt[i]
# Low level ( 50 us) average counter
average_cnt = total_cnt / (self.PULSES_CNT - 1)
# print("low level average loop = %d" % average_cnt)
data = ''
for i in range(3, 2 * self.PULSES_CNT, 2):
if pulse_cnt[i] > average_cnt:
data += '1'
else:
data += '0'
data0 = int(data[0:8], 2)
data1 = int(data[8:16], 2)
data2 = int(data[16:24], 2)
data3 = int(data[24:32], 2)
data4 = int(data[32:40], 2)
if fix_crc and data4 != ((data0 + data1 + data2 + data3) & 0xFF):
data4 = data4 ^ 0x01
data = data[0:self.PULSES_CNT - 2] + ('1' if data4
& 0x01 else '0')
if data4 == ((data0 + data1 + data2 + data3) & 0xFF):
if self._dht_type == self.DHT_TYPE['DHT11']:
humi = int(data0)
temp = int(data2)
elif self._dht_type == self.DHT_TYPE['DHT22']:
humi = float(int(data[0:16], 2) * 0.1)
temp = float(
int(data[17:32], 2) * 0.2 * (0.5 - int(data[16], 2)))
else:
# print("checksum error!")
return None, "checksum error!"
return humi, temp
def read(self, retries=15):
for i in range(retries):
humi, temp = self._read()
if not humi is None:
break
if humi is None:
return self._last_humi, self._last_temp
self._last_humi, self._last_temp = humi, temp
return humi, temp
class GroveThermocoupleAmpMCP9600(object):
def __init__(self, address = 0x60):
self._addr = address
self._bus = Bus()
self._therm = THER_TYPE_K
self._junc = HOT_JUNCTION_REG_ADDR
self._junc_res = COLD_JUNC_RESOLUTION_0_625
def _read_version(self):
version = self._bus.read_i2c_block_data(self._addr,VERSION_ID_REG_ADDR,2)
return version
def _set_filt_coefficients(self,coefficients):
data = self._bus.read_byte_data(self._addr,THERM_SENS_CFG_REG_ADDR)
data = (data & 0xF8) | coefficients
self._bus.write_byte_data(self._addr,THERM_SENS_CFG_REG_ADDR,data)
def _set_cold_junc_resolution(self,junc_res):
data = self._bus.read_byte_data(self._addr,DEVICE_CFG_REG_ADDR)
data = (data & 0x7F) | junc_res
self._bus.write_byte_data(self._addr,DEVICE_CFG_REG_ADDR,data)
self._junc_res = junc_res
def _set_ADC_meas_resolution(self,res):
data = self._bus.read_byte_data(self._addr,DEVICE_CFG_REG_ADDR)
data = (data & 0x9F) | res
self._bus.write_byte_data(self._addr,DEVICE_CFG_REG_ADDR,data)
def _set_burst_mode_samp(self,samp):
data = self._bus.read_byte_data(self._addr,DEVICE_CFG_REG_ADDR)
data = (data & 0xE3) | samp
self._bus.write_byte_data(self._addr,DEVICE_CFG_REG_ADDR,data)
def _set_sensor_mode(self,mode):
data = self._bus.read_byte_data(self._addr,DEVICE_CFG_REG_ADDR)
data = (data & 0xFC) | mode
self._bus.write_byte_data(self._addr,DEVICE_CFG_REG_ADDR,data)
def get_config(self):
config1 = self._bus.read_byte_data(self._addr,DEVICE_CFG_REG_ADDR)
config2 = self._bus.read_byte_data(self._addr,THERM_SENS_CFG_REG_ADDR)
return config1, config2
def set_therm_type(self,therm_type):
therm_cfg_data = self._bus.read_byte_data(self._addr,THERM_SENS_CFG_REG_ADDR)
therm_cfg_data = (therm_cfg_data & 0x8F) | therm_type
self._bus.write_byte_data(self._addr,THERM_SENS_CFG_REG_ADDR,therm_cfg_data)
self._therm = therm_type
def set_junc_type(self, junc):
if not junc is None:
self._junc = junc
return self._junc
def set_config(self,
filter = FILT_OFF,
junc_res = COLD_JUNC_RESOLUTION_0_625,
adc_res = ADC_14BIT_RESOLUTION,
burst_smps = BURST_1_SAMPLE,
oper_mode = NORMAL_OPERATION
):
self._set_filt_coefficients(filter)
self._set_cold_junc_resolution(junc_res)
self._set_ADC_meas_resolution(adc_res)
self._set_burst_mode_samp(burst_smps)
self._set_sensor_mode(oper_mode)
return None
def read(self):
data = self._bus.read_word_data(self._addr, self._junc)
# Big endian -> little endian
data = socket.ntohs(data)
# print("RAW = 0x%X" % data)
# It's 16-bit 2's complement code
temperature = ctypes.c_short(data).value / 16.0
return temperature
class Tsl2561:
i2c = None
def __init__(self, bus=I2C_SMBUS, address=I2C_ADDRESS, debug=1, pause=0.8):
# assert(bus is not None)
# assert(address > 0b000111 and address < 0b1111000)
self.address = address
self.bus = Bus(bus)
self.pause = pause
self.debug = debug
self.gain = 0
self._bus = bus
self._addr = address
ambient = None
IR = None
self._ambient = 0
self._IR = 0
self._LUX = None
self._control(_POWER_UP)
self._partno_revision()
def _reverseByteOrder(self, data):
"""Reverses the byte order of an int (16-bit) or long (32-bit) value"""
# Courtesy Vishal Sapre
byteCount = len(hex(data)[2:].replace('L','')[::2])
val = 0
for i in range(byteCount):
val = (val << 8) | (data & 0xff)
data >>= 8
return val
def _read_byte(self, address):
command = _CMD | address
self.bus.read_byte_data(self.address, command)
def _read_word(self, address,little_endian=True):
try:
command = _CMD | address
result = self.bus.read_word_data(self.address, command)
if not little_endian:
result = ((result << 8) & 0xFF00) + (result >> 8)
if (self.debug):
print ("I2C: Device 0x{} returned 0x{} from reg 0x{}".format(self.address, result & 0xFFFF, reg))
return result
except IOError, err:
return self.errMsg()
def _write_byte(self, address, data):
command = _CMD | address
self.bus.write_byte_data(self.address, command, data)
def _write_word(self, address, data):
command = _CMD | _AUTO | address
data = [(data >> 8) & 0xFF, data & 0xFF]
self.bus.write_i2c_block_data(self.address, command, data)
def setGain(self, gain = 1):
""" Set the gain """
if (gain != self.gain):
if (gain==1):
cmd = _CMD | _REG_TIMING
value = 0x02
self._write_byte(cmd, value)
if (self.debug):
print ("Setting low gain")
else:
cmd = _CMD | _REG_TIMING
value = 0x12
self._write_byte(cmd, value)
if (self.debug):
print ("Setting high gain")
self.gain = gain # Safe gain for calculation
print('setGain...gian=',gain)
time.sleep(self.pause) # Pause for integration (self.pause must be bigger than integration time)
def readWord(self, reg):
""" Reads a word from the TSL2561 I2C device """
try:
wordval = self._read_word(reg)
print ('wordval=',wordval)
newval = self._reverseByteOrder(wordval)
print ('newval=',newval)
if (self.debug):
print("I2C: Device 0x{}: returned 0x{} from reg 0x{}".format(self._addr, wordval & 0xFFFF, reg))
return newval
except IOError:
print("Error accessing 0x{}: Chcekcyour I2C address".format(self._addr))
return -1
def readFull(self, reg = 0x8C):
""" Read visible + IR diode from the TSL2561 I2C device """
return self.readWord(reg)
def readIR(self, reg = 0x8E):
""" Reads only IR diode from the TSL2561 I2C device """
return self.readWord(reg)
def readLux(self, gain = 0):
""" Grabs a lux reading either with autoranging (gain=0) or with specific gain (1, 16) """
if (self.debug):
print ("gain=",gain)
if (gain == 1 or gain == 16):
self.setGain(gain) # Low/High Gain
ambient = self.readFull()
IR = self.readIR()
elif (gain == 0): # Auto gain
self.setGain(16) # First try highGain
ambient = self.readFull()
if (ambient < 65535):
IR = slef.readIR()
if (ambient >= 65535 or IR >= 65535): # Value(s) exeed(s) datarange
self.setGain(1) # Set low Gain
ambient = self.readFull()
IR = self.readIR()
# If either sensor is saturated, no acculate lux value can be achieved.
if (ambient == 0xffff or IR == 0xffff):
self._LUX = None
self._ambient = None
self._IR = None
return (self.ambient, self.IR, self._ambient, self._IR, self._LUX)
if (self.gain == 1):
self._ambient = 16 * ambient # Scale 1x to 16x
self._IR = 16 * IR
else:
self._ambient = 1 * ambient
if (self.debug):
print ("IR Result without scaling: ",IR)
print ("IR Result: ", self._IR)
print ("Ambient Result without scaling: ", ambient)
print ("Ambient Result: ", self._ambient)
if (self._ambient == 0):
# Sometimes, the channel 0 returns 0 when dark ...
self._LUX = 0.0
return (ambient, IR, self._ambient, self._IR, self._LUX)
ratio = (self._IR / float(self._ambient))
if (self.debug):
print ("ratio: ", ratio)
if ((ratio >= 0) and (ratio <= 0.52)):
self._LUX = (0.0315 * self._ambient) - (0.0593 * self._ambient * (ratio ** 1.4))
elif (ratio <= 0.65):
self._LUX = (0.0229 * self._ambient) - (0.0291 * self._IR)
elif (ratio <= 0.80):
self._LUX = (0.0157 * self._ambient) - (0.018 * self._IR)
elif (ratio <= 1.3):
self._LUX = (0.00338 * self._ambient) - (0.0026 * self._IR)
elif (ratio > 1.3):
self._LUX = 0
return (ambient, IR, self._ambient, self._IR, self._LUX)
def _control(self, params):
if (params == _POWER_UP):
print ("Power ON")
elif (params == _POWER_DOWN):
print ("Power OFF")
cmd = _CMD | _REG_CONTROL | params
self._write_byte(self._addr, cmd) # select command register and power on
time.sleep(0.4) # Wait for 400ms to power up or power down.
def _partno_revision(self):
""" Read Partnumber and revision of the sensor """
cmd = _CMD | _REG_ID
value = self._read_byte(cmd)
print ("value=",value)
part = str(value)[7:4]
if (part == "0000"):
PartNo = "TSL2560CS"
elif (part == "0001"):
PartNo = "TSL2561CS"
elif (part == "0100"):
PartNo = "TSL2560T/FN/CL"
else:
PartNo = "not TSL2560 or TSL2561"
RevNo = str(value)[3:0]
if (self.debug):
print ("response: ", value)
print ("PartNo = ", PartNo)
print ("RevNo = ", RevNo)
return (PartNo, RevNo)
class GroveI2cColorSensorV2:
"""Driver for Grove I2C Color Sensor (TCS34725)"""
def __init__(self, bus=None, address=0x29):
self.address = address
self.bus = Bus(bus)
self.awake = False
if self.id not in (0x44, 0x4D):
raise ValueError('Not find a Grove I2C Color Sensor V2')
self.set_integration_time(24)
self.set_gain(4)
def wakeup(self):
enable = self._read_byte(_ENABLE)
self._write_byte(_ENABLE, enable | _PON | _AEN)
time.sleep(0.0024)
self.awake = True
def sleep(self):
enable = self._read_byte(_ENABLE)
self._write_byte(_ENABLE, enable & ~_PON)
self.awake = False
def is_awake(self):
return self._read_byte(_ENABLE) & _PON
def set_wait_time(self, t):
pass
@property
def id(self):
return self._read_byte(_ID)
@property
def integration_time(self):
steps = 256 - self._read_byte(_ATIME)
return steps * 2.4
def set_integration_time(self, t):
"""Set the integration time of the sensor"""
if t < 2.4:
t = 2.4
elif t > 614.4:
t = 614.4
steps = int(t / 2.4)
self._integration_time = steps * 2.4
self._write_byte(_ATIME, 256 - steps)
@property
def gain(self):
"""The gain control. Should be 1, 4, 16, or 60.
"""
return _GAINS[self._read_byte(_CONTROL)]
def set_gain(self, gain):
if gain in _GAINS:
self._write_byte(_CONTROL, _GAINS.index(gain))
@property
def raw(self):
"""Read RGBC registers
return 16 bits red, green, blue and clear data
"""
if not self.awake:
self.wakeup()
while not self._valid():
time.sleep(0.0024)
data = tuple(
self._read_word(reg) for reg in (_RDATA, _GDATA, _BDATA, _CDATA))
return data
@property
def rgb(self):
"""Read the RGB color detected by the sensor. Returns a 3-tuple of
red, green, blue component values as bytes (0-255).
"""
r, g, b, clear = self.raw
if clear:
r = int(255 * r / clear)
g = int(255 * g / clear)
b = int(255 * b / clear)
else:
r, g, b = 0, 0, 0
return r, g, b
def _valid(self):
"""Check if RGBC is valid"""
return self._read_byte(_STATUS) & 0x01
def _read_byte(self, address):
command = _CMD | address
return self.bus.read_byte_data(self.address, command)
def _read_word(self, address):
command = _CMD | _AUTO | address
return self.bus.read_word_data(self.address, command)
def _write_byte(self, address, data):
command = _CMD | address
self.bus.write_byte_data(self.address, command, data)
def _write_word(self, address, data):
command = _CMD | _AUTO | address
data = [(data >> 8) & 0xFF, data & 0xFF]
self.bus.write_i2c_block_data(self.address, command, data)
