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 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 I2CStepperMotor(StepperMotor):
__REG_GET_PID = 0x00
__REG_GET_VID = 0x01
__REG_GET_VER = 0x02
__REG_STP_EN = 0x1A
__REG_STP_DIS = 0x1B
__REG_STP_RUN = 0x1C
__REG_STP_INTERVAL = 0x1D
__REG_SEQ_LEN = 0x20
__REG_SEQ_XET = 0x21
__REG_SET_SPEED = 0x82
__REG_SET_FREQ = 0x84
__REG_SET_A = 0xA1
__REG_SET_B = 0xA5
__REG_SET_DIR = 0xAA
def __init__(self, arguments, address=0x0F):
super(I2CStepperMotor, self).__init__(arguments)
self._addr = address
self._bus = Bus()
self._ang_left = 0
self._load_seq(arguments["sequences"])
def __del__(self):
self.set_speed(0, 0)
pass
#Maps speed from 0-100 to 0-255
def _map_vals(self, value, leftMin, leftMax, rightMin, rightMax):
#http://stackoverflow.com/questions/1969240/mapping-a-range-of-values-to-another
# Figure out how 'wide' each range is
leftSpan = leftMax - leftMin
rightSpan = rightMax - rightMin
# Convert the left range into a 0-1 range (float)
valueScaled = float(value - leftMin) / float(leftSpan)
# Convert the 0-1 range into a value in the right range.
return int(rightMin + (valueScaled * rightSpan))
#Set motor speed
def set_speed(self, speed1=0, speed2=0):
s1 = self._map_vals(speed1, 0, 100, 0, 255)
s2 = self._map_vals(speed2, 0, 100, 0, 255)
self._bus.write_i2c_block_data(self._addr, self.__REG_SET_SPEED,
[s1, s2])
time.sleep(.02)
#Set motor direction
def set_dir(self, clock_wise1=True, clock_wise2=True):
dir1 = 0b10 if clock_wise1 else 0b01
dir2 = 0b10 if clock_wise2 else 0b01
dir = (dir2 << 2) | dir1
self._bus.write_i2c_block_data(self._addr, self.__REG_SET_DIR,
[dir, 0])
time.sleep(.02)
def _load_seq(self, seq):
length = len(seq)
self._bus.write_word_data(self._addr, self.__REG_SEQ_LEN, length)
for i in range(len(seq)):
self._bus.write_word_data(self._addr, self.__REG_SEQ_XET, seq[i])
def _enable(self, en):
cmd = self.__REG_STP_EN if en else self.__REG_STP_DIS
if en:
self.set_speed(self.DC_SPEED_MAX, self.DC_SPEED_MAX)
else:
self.set_speed(0, 0)
self._bus.write_i2c_block_data(self._addr, cmd, [self._dir, 0])
time.sleep(0.001)
def _speed(self, rpm):
self._dir = self._DIR_CLKWISE if rpm >= 0 else self._DIR_ANTI_CLKWISE
# absolute angle per second
aps = abs(rpm) * 360.0 / 60.0
# steps per second, include reductor ratio.
sps = self._angle2steps(aps)
period = int(1000000 / sps) # us
period = period // 10 # STP_INTERVAL, 10 us
# print("period = %d us" % (period * 10))
self._bus.write_word_data(self._addr, self.__REG_STP_INTERVAL, period)
time.sleep(0.001)
def _rotate(self, angle=None):
if not angle is None:
angle = abs(angle)
self._ang_left = angle
steps = self._angle2steps(angle)
# print("steps set = {}".format(steps))
self._bus.write_word_data(self._addr, self.__REG_STP_RUN, steps)
time.sleep(0.001)
return angle
while True:
# reading interface unstable when working
try:
steps = self._bus.read_word_data(self._addr,
self.__REG_STP_RUN)
# print("steps left = {}".format(steps))
ang_left = self._steps2angle(steps)
if ang_left > self._ang_left:
time.sleep(0.01)
continue
self._ang_left = ang_left
return ang_left
except IOError:
continue
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)
