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)