def __init__(self, HEX_ADDRESS): self._address = HEX_ADDRESS try: i2c.read(self._address, 1) except OSError as error: raise SystemExit(error) else: i2c.write(self._address, bytearray([REG_ID])) ID = i2c.read(self._address, 1) if ord(ID) == SENSOR_ID: print("found BME280 sensor: [%s]" % hex(self._address)) print("sensor device ID is: [%s]" % hex(ord(ID))) else: print("another device at address [%s]!" % hex(self._address)) raise SystemExit()
def setDate(self, setDay, setMonth, setYear): writeBuf = bytearray(2) readBuf = bytearray(1) if setMonth is 4 or 6 or 9 or 11: if setDay >= 30: setDay = 30 if setMonth is 2 and setDay >= 29: leapYearCheck = setYear % 4 if leapYearCheck is 0: setDay = 29 else: setDay = 28 bcdDay = self.decToBcd(setDay) bcdMonths = self.decToBcd(setMonth) bcdYears = self.decToBcd(setYear) writeBuf[0] = 0x00 i2c.write(0x6F, writeBuf, False) readBuf = i2c.read(0x6F, 1, False) readCurrentSeconds = readBuf[0] writeBuf[0] = 0x00 writeBuf[1] = 0x00 i2c.write(0x6F, writeBuf, False) writeBuf[0] = 0x04 writeBuf[1] = bcdDay i2c.write(0x6F, writeBuf, False) writeBuf[0] = 0x05 writeBuf[1] = bcdMonths i2c.write(0x6F, writeBuf, False) writeBuf[0] = 0x06 writeBuf[1] = bcdYears i2c.write(0x6F, writeBuf, False) writeBuf[0] = 0x00 writeBuf[1] = 0x80 | readCurrentSeconds i2c.write(0x6F, writeBuf, False)
def i2cRead(self, reg, byte): writeBuf = bytearray(1) readBuf = bytearray(byte) writeBuf[0] = reg i2c.write(0x76, writeBuf, False) readBuf = i2c.read(0x76, byte, False) return readBuf
def read(self, readRequest): writeBuf = bytearray(1) readBuf = bytearray(7) writeBuf[0] = 0x00 i2c.write(0x6F, writeBuf, False) readBuf = i2c.read(0x6F, 7, False) currentSeconds = readBuf[0] currentMinutes = readBuf[1] currentHours = readBuf[2] currentWeekDay = readBuf[3] currentDay = readBuf[4] currentMonth = readBuf[5] currentYear = readBuf[6] if readRequest is "hours": valueRead = self.bcdToDec(currentHours, 0x10) elif readRequest is "minutes": valueRead = self.bcdToDec(currentMinutes, 0x70) elif readRequest is "seconds": valueRead = self.bcdToDec(currentSeconds, 0x70) elif readRequest is "day": valueRead = self.bcdToDec(currentDay, 0x30) elif readRequest is "month": valueRead = self.bcdToDec(currentMonth, 0x10) elif readRequest is "year": valueRead = self.bcdToDec(currentYear, 0xF0) return valueRead
def r_eval(seq, grp=-1): radio.config(channel=i2c.read(0x20, 1)[0] % 32) _send(b'%s\r%s' % (grp, seq), 0) for i in range(len(_res)): i, grp = _res[i].split(b'\r') _res[i] = (i, int(grp)) return tuple(_res)
def i2cRead(s, reg, byte): wBuf = bytearray(1) rBuf = bytearray(byte) wBuf[0] = reg i2c.write(0x76, wBuf, False) rBuf = i2c.read(0x76, byte, False) return rBuf
def configure_device(): # First place the device into standby mode, so it can be configured (CTRL_REG1 bit0 = 0) i2c.write(MMA8653_ADDR, bytes([MMA8653_CTRL_REG1, 0x00])) # CTRL_REG1 Fast read mode: bit 1 = 0 # bit 2 unused # Output Data Rate: bits 3-5 = 0b000 for 800Hz # Auto Sleep rate: bits 6-7 = 0b00 default to wake at 50Hz (unused feature) i2c.write(MMA8653_ADDR, bytes([MMA8653_CTRL_REG1, 0x00])) # CTRL_REG2 ACTIVE mode power scheme: bits 0-1: 0b10 (high resolution mode) # Auto-SLEEP enable: bit 2 = 0 (sleep disable) # SLEEP mode power scheme: bits 3-4 = 0b10 (high resolution mode) # bit 5 unused # Software Reset: bit 6 = 0 (nothing happens with 0, it resets with 1) # Self-Test Enable: bit 7 = 0 (disable) # Enable high precision mode. This consumes a bit more power, but still only 184 uA! i2c.write(MMA8653_ADDR, bytes([MMA8653_CTRL_REG2, 0x12])) # CTRL_REG3 is the Interrupt Control register, we can leave all defaults # CTRL_REG4 is the Interrupt Enable register, we can leave all defaults # CTRL_REG5 is the Interrupt Configuration register, we can leave all defaults # Configure for the selected g range, 0x00 = 2G i2c.write(MMA8653_ADDR, bytes([MMA8653_XYZ_DATA_CFG, 0x00])) # Activate the device (CTRL_REG1 bit0 = 1) i2c.write(MMA8653_ADDR, bytes([MMA8653_CTRL_REG1]), repeat=True) ctrl_reg1_value = i2c.read(MMA8653_ADDR, 1)[0] i2c.write(MMA8653_ADDR, bytes([MMA8653_CTRL_REG1, ctrl_reg1_value | 0x01]))
def check_device(): i2c.write(MMA8653_ADDR, bytes([MMA8653_WHOAMI]), repeat=True) read_data = i2c.read(MMA8653_ADDR, 1) if read_data[0] != MMA8653_WHOAMI_VALUE: raise Exception( 'Invalid WHO_AM_I value 0x{:02X}, expected 0x{:02X}'.format( read_data[0], MMA8653_WHOAMI_VALUE))
def read_z(): i2c.write(MMA8653_ADDR, bytes([MMA8653_OUT_Z_MSB]), repeat=True) result = i2c.read(MMA8653_ADDR, 1) # Unpack it as a signed char result = ustruct.unpack('b', result)[0] # Scale it to 0 to +/- 2000 return result * 16
def read_sensor(which_sensor, which_side): """ Reads the GiggleBot onboard sensors, light or line sensors. :param int which_sensor: Reads the light sensors :py:attr:`~gigglebot.LIGHT_SENSOR` (6), or the line sensors :py:attr:`~gigglebot.LINE_SENSOR` (5). Values are from **0** to **1023**. :param int which_side: Reads :py:attr:`~gigglebot.LEFT` (0), :py:attr:`~gigglebot.RIGHT` (1), or :py:attr:`~gigglebot.BOTH` (2) sensors. When reading both sensors, an array will be returned. :returns: Either an integer or an array of integers (right, then left). You can read the sensors this way: .. code:: right, left = read_sensor(LIGHT_SENSOR, BOTH) """ i2c.write(0x04, pack('B', which_sensor)) buf = i2c.read(0x04, 3) pack_into('>HH', _BUFFER, 0, 1023 - (buf[0] << 2 | ((buf[2] & 0xC0) >> 6)), 1023 - (buf[1] << 2 | ((buf[2] & 0x30) >> 4))) if which_side == LEFT: return unpack_from('>H', _BUFFER, 2)[0] elif which_side == RIGHT: return unpack_from('>H', _BUFFER, 0)[0] else: return unpack_from('>HH', _BUFFER)
def get_bin(): tmp = i2c.read(32, 1)[0] res, ptr = '', 1 for i in range(8): res += str(int(tmp & ptr > 0)) ptr *= 2 return res
def volt(): """ Returns the voltage level of the batteries. :returns: Voltage level of the batteries. """ i2c.write(0x04, b'\x04') return unpack('>H', i2c.read(0x04, 2))[0] / 1000.0
def readTime(self): i2c.write(self._addr, b'\x04') rdata = i2c.read(self._addr, 7) return (self._bcdToDec(rdata[6]) + 2000, self._bcdToDec(rdata[5]), self._bcdToDec(rdata[4]), DAYS_OF_WEEK[self._bcdToDec(rdata[3])], self._bcdToDec(rdata[2]), self._bcdToDec(rdata[1]), self._bcdToDec(rdata[0] & 0x7f))
def measure(self,cmd): value=0 if not self.isPreheated:self.preheated() i2c.write(self.addr,cmd) sleep(10) data=i2c.read(self.addr,4) for i in range(4):value+=data[i]<<(8*i) return value
def getRawData(self): if ticks_us() - self.lastSample > 10000: while (self.read(0xF3) & 0x08): t = ticks_us() while t - ticks_us() > 2: pass self.lastSample = ticks_us() i2c.write(BME280_ADDRESS, bytearray([0xF7])) self.currentRawData = i2c.read(BME280_ADDRESS, 8)
def getReg(self, reg): i2c.write(BMP280_I2C_ADDR, bytearray([reg])) t = i2c.read(BMP280_I2C_ADDR, 1) return t[0] # get two reg def get2Reg(self, reg): i2c.write(BMP280_I2C_ADDR, bytearray([reg])) t = i2c.read(BMP280_I2C_ADDR, 2) return t[0] + t[1]*256 def get(self): adc_T = (self.getReg(0xFA)<<12) + (self.getReg(0xFB)<<4) + (self.getReg(0xFC)>>4) var1 = (((adc_T>>3)-(self.dig_T1<<1))*self.dig_T2)>>11 var2 = (((((adc_T>>4)-self.dig_T1)*((adc_T>>4) - self.dig_T1))>>12)*self.dig_T3)>>14 t = var1+var2 self.T = ((t * 5 + 128) >> 8)/100 var1 = (t>>1) - 64000 var2 = (((var1>>2) * (var1>>2)) >> 11 ) * self.dig_P6 var2 = var2 + ((var1*self.dig_P5)<<1) var2 = (var2>>2)+(self.dig_P4<<16) var1 = (((self.dig_P3*((var1>>2)*(var1>>2))>>13)>>3) + (((self.dig_P2) * var1)>>1))>>18 var1 = ((32768+var1)*self.dig_P1)>>15 if var1 == 0: return # avoid exception caused by division by zero adc_P = (self.getReg(0xF7)<<12) + (self.getReg(0xF8)<<4) + (self.getReg(0xF9)>>4) p=((1048576-adc_P)-(var2>>12))*3125 if p < 0x80000000: p = (p << 1) // var1 else: p = (p // var1) * 2 var1 = (self.dig_P9 * (((p>>3)*(p>>3))>>13))>>12 var2 = (((p>>2)) * self.dig_P8)>>13 self.P = p + ((var1 + var2 + self.dig_P7) >> 4) return [self.T, self.P] # get Temperature in Celsius def getTemp(self): self.get() return self.T # get Pressure in Pa def getPress(self): self.get() return self.P # Calculating absolute altitude def getAltitude(self): return 44330*(1-(self.getPress()/101325)**(1/5.255)) # sleep mode def poweroff(self): self.setReg(0xF4, 0) # normal mode def poweron(self): self.setReg(0xF4, 0x2F)
def set_pwm(self, channel, on, off): if on is None or off is None: i2c.write(self.address, bytearray([0x06 + 4 * channel])) distance = i2c.read(self.address, 4) return ustruct.unpack('<HH', distance) i2c.write(self.address, bytearray([0x06 + 4 * channel, on & 0xFF])) i2c.write(self.address, bytearray([0x07 + 4 * channel, on >> 8])) i2c.write(self.address, bytearray([0x08 + 4 * channel, off & 0xFF])) i2c.write(self.address, bytearray([0x09 + 4 * channel, off >> 8]))
def getTemperature(self): i2c.write(I2CADR, bytearray([BME280_REG_TEMPDATA])) t = i2c.read(I2CADR,3) adc_T = (t[0]*65536 + t[1]*256 + t[2]) >> 4 t1 = (((adc_T >> 3) - (self.dig_T1 << 1)) * self.dig_T2) >> 11 t2 = (((((adc_T >> 4)-self.dig_T1)*((adc_T >> 4)-self.dig_T1)) >> 12)*self.dig_T3) >> 14 self.t_fine = t1 + t2 T = (self.t_fine * 5 + 128) >> 8 return T
def longitude(self): if self.coord_format == 'dd': i2c.write(SN01_ADDR, str(0xFD)) data = i2c.read(SN01_ADDR, 2) temp = ((data[0] << 8) | (data[1])) if (temp > 0 and temp < 10000): for x in range(temp): self.update(i2c.read(SN01_ADDR, 1)) decimal_degrees = self._longitude[0] + (self._longitude[1] / 60) return [decimal_degrees]
def _exe(s, b, l=0, r=0): try: i2c.write(s, b) if l: d = i2c.read(s, l) if not r: d = int.from_bytes(d, 'big') return d except: pass
def set_pwm(self, channel, on, off): """Sets a single PWM channel.""" if on is None or off is None: i2c.write(self.address, bytearray([LED0_ON_L+4*channel])) # write register we want to read from first data = i2c.read(self.address, 4) return ustruct.unpack('<HH', data) i2c.write(self.address, bytearray([LED0_ON_L+4*channel, on & 0xFF])) i2c.write(self.address, bytearray([LED0_ON_H+4*channel, on >> 8])) i2c.write(self.address, bytearray([LED0_OFF_L+4*channel, off & 0xFF])) i2c.write(self.address, bytearray([LED0_OFF_H+4*channel, off >> 8]))
def read(self, reg, num_bytes=1, signed=False, le=False): i2c.write(0x60, bytearray([reg])) n = 0 for x in reversed(i2c.read(0x60, num_bytes)): n <<= 8 n |= x if signed: mask = 2**((num_bytes * 8) - 1) n = -(n & mask) + (n & ~mask) collect() return n
def ReadTouch(self): readbytes = i2c.read(self.ADDRESS, 2) LSB = int(readbytes[0]) MSB = int(readbytes[1]) touched = ((MSB << 8) | LSB) for i in range(12): if touched & (1 << i): self.touchstates[i] = 1 else: self.touchstates[i] = 0
def read(self, cmd, d, rs): i2c.write(0x58, bytearray(cmd)) sleep(d) if not rs: return None cr = i2c.read(0x58, rs * 3) o = [] for i in range(rs): w = [cr[3 * i], cr[3 * i + 1]] c = cr[3 * i + 2] if self.g_crc(w) != c: raise RuntimeError('CRC Error') o.append(w[0] << 8 | w[1]) return o
def __init__(self, i2c, address = 0x40): self.address = address i2c.write(self.address, bytearray([0x00, 0x00])) i2c.write(self.address, bytearray([0x01, 0x04])) i2c.write(self.address, bytearray([0x00, 0x01])) sleep(5) i2c.write(self.address, bytearray([0x00])) mode1 = i2c.read(self.address, 1) mode1 = ustruct.unpack('<H', mode1)[0] mode1 = mode1 & ~0x10 # wake up (reset sleep) i2c.write(self.address, bytearray([0x00, mode1])) sleep(5)
def read(self, reg, num_bits=8, signed=False, le=False): i2c.write(BME280_ADDRESS, bytearray([reg])) b = bytearray(int(num_bits / 8)) b = i2c.read(BME280_ADDRESS, int(num_bits / 8)) n = 0 for x in reversed(b): n <<= 8 n |= x if signed: mask = 2**(num_bits - 1) n = -(n & mask) + (n & ~mask) return n
def __init__(self): i2c.init(freq=100000, sda=pin20, scl=pin19) writeBuf = bytearray(2) readBuf = bytearray(1) writeBuf[0] = 0x00 i2c.write(0x6F, writeBuf, False) readBuf = i2c.read(0x6F, 1, False) readCurrentSeconds = readBuf[0] writeBuf[0] = 0x07 writeBuf[1] = 0x43 i2c.write(0x6F, writeBuf, False) writeBuf[0] = 0x03 i2c.write(0x6F, writeBuf, False) readBuf = i2c.read(0x6F, 1, False) readWeekDayReg = readBuf[0] writeBuf[0] = 0x03 writeBuf[1] = 0x08 | readWeekDayReg i2c.write(0x6F, writeBuf, False) writeBuf[0] = 0x00 writeBuf[1] = 0x80 | readCurrentSeconds i2c.write(0x6F, writeBuf, False)
def __init__(self, i2c, address=0x41): self.address = address i2c.write(self.address, bytearray([0x00, 0x00])) self.set_all_pwm(0, 0) i2c.write(self.address, bytearray([0x01, 0x04])) i2c.write(self.address, bytearray([0x00, 0x01])) sleep(5) i2c.write(self.address, bytearray([0x00])) mode1 = i2c.read(self.address, 1) mode1 = ustruct.unpack('<H', mode1)[0] mode1 = mode1 & ~0x10 i2c.write(self.address, bytearray([0x00, mode1])) sleep(5)
def getReadings(self): measurementsBuf = bytearray(8) writeBuf = bytearray(1) writeBuf[0] = 0xF7 i2c.write(0x76, writeBuf, False) self.measurementsBuf = i2c.read(0x76, 8, False) self.adcRawPressure = ((self.measurementsBuf[0] << 12) | (self.measurementsBuf[1] << 4) | ((self.measurementsBuf[2] & 0xF0) >> 4)) self.adcRawTemperature = ((self.measurementsBuf[3] << 12) | (self.measurementsBuf[4] << 4) | ((self.measurementsBuf[5] & 0xF0) >> 4)) self.adcRawHumidity = ((self.measurementsBuf[6] << 8) | self.measurementsBuf[7]) var1 = (((self.adcRawTemperature >> 3) - (self.T1 << 1)) * self.T2) >> 11 var2 = (((((self.adcRawTemperature >> 4) - self.T1) * ( (self.adcRawTemperature >> 4) - self.T1)) >> 12) * self.T3) >> 14 self.temperatureCalculation = var1 + var2 self.temperatureReading = ( (self.temperatureCalculation * 5 + 128) >> 8) / 100 var1 = (self.temperatureCalculation >> 1) - 64000 var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * self.P6 var2 = var2 + ((var1 * self.P5) << 1) var2 = (var2 >> 2) + (self.P4 << 16) var1 = (((self.P3 * ((var1 >> 2) * (var1 >> 2)) >> 13) >> 3) + (((self.P2) * var1) >> 1)) >> 18 var1 = ((32768 + var1) * self.P1) >> 15 if var1 is 0: return self.pressureCalculation = ((1048576 - self.adcRawPressure) - (var2 >> 12)) * 3125 self.pressureCalculation = (self.pressureCalculation // var1) * 2 var1 = (self.P9 * (((self.pressureCalculation >> 3) * (self.pressureCalculation >> 3)) >> 13)) >> 12 var2 = ((self.pressureCalculation >> 2) * self.P8) >> 13 self.pressureReading = self.pressureCalculation + ( (var1 + var2 + self.P7) >> 4) var1 = self.temperatureCalculation - 76800 var2 = (((self.adcRawHumidity << 14) - (self.H4 << 20) - (self.H5 * var1)) + 16384) >> 15 var1 = var2 * (((((((var1 * self.H6) >> 10) * (( (var1 * self.H3) >> 11) + 32768)) >> 10) + 2097152) * self.H2 + 8192) >> 14) var2 = var1 - (((((var1 >> 15) * (var1 >> 15)) >> 7) * self.H1) >> 4) if var2 < 0: var2 = 0 if var2 > 419430400: var2 = 419430400 self.humidityReading = (var2 >> 12) // 1024
def __init__(self): sleep(40) i2c.write(I2CADR, bytearray([BME280_REG_CHIPID])) i = i2c.read(I2CADR,1) id = i[0] if id != BME280_ID: return i2c.write(I2CADR, bytearray([BME280_REG_DIG_T])) t = i2c.read(I2CADR,26) 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= unpack("<HhhHhhhhhhhhBB", t) i2c.write(I2CADR, bytearray([BME280_REG_DIG_H2])) h = i2c.read(I2CADR,7) self.dig_H2, self.dig_H3 = unpack("hB", h) hh = (h[3] * 16) + (h[4] & 0x0F) self.dig_H4 = hh if hh < 0x8000 else hh - 0x10000 hh = (h[5] * 16) + (h[4] >> 4) self.dig_H5 = hh if hh < 0x8000 else hh - 0x10000 self.dig_H6 = h[6] if h[6] < 0x80 else h[6] - 0x100 i2c.write(I2CADR, bytearray([BME280_REG_CONTROL_HUM, 0x02])) i2c.write(I2CADR, bytearray([BME280_REG_CONTROL, 0x37])) i2c.write(I2CADR, bytearray([BME280_REG_CONFIG, 0x70]))