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]))
