def read_y():
i2c.write(MMA8653_ADDR, bytes([MMA8653_OUT_Y_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 and set orientation
return result * 16 * -1
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 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 oled_initialize():
for c in ([0xae], [0xa4], [0xd5, 0xf0], [0xa8, 0x3f], [0xd3, 0x00],
[0 | 0x0], [0x8d, 0x14], [0x20, 0x00], [0x21, 0, 127],
[0x22, 0, 63], [0xa0 | 0x1], [0xc8], [0xda, 0x12], [0x81, 0xcf],
[0xd9, 0xf1], [0xdb, 0x40], [0xa6], [0xd6, 1], [0xaf]):
i2c.write(OLED_ADDR, b'\x00' + bytearray(c))
def servo_write(self, Servo: Servos, degrees):
# sets the requested servo to the reguested angle.
# if the PCA has not yet been setup calls the initialisation routine
# @param Servo Which servo to set
# @param degrees the angle to set the servo to
if self.INITALISED is False:
self._secret_incantation(self)
buf = bytearray(2)
HighByte = False
PWMVal = degrees + 180
#deg100 = degrees * 100
#PWMVal100 = deg100 * self.SERVO_MULTIPLIER
#PWMVal = PWMVal100 / 10000
#PWMVal = PWMVal + self.SERVO_ZERO_OFFSET
#print(self.SERVO_ZERO_OFFSET)
#print(PWMVal)
if (PWMVal > 0xFF):
HighByte = True
buf[0] = Servo
buf[1] = int(PWMVal)
i2c.write(self.BOARD_1, buf, False)
if (HighByte):
buf[0] = Servo + 1
buf[1] = 0x01
else:
buf[0] = Servo + 1
buf[1] = 0x00
i2c.write(self.BOARD_1, buf, False)
def char(self, ch, x=0, y=0, c=1):
ind = x + y * 128 + 1
n = (min(127, max(ord(ch), 32)) - 32) * 5
for i in range(5):
screen[ind + i] = Font_5x7[n + i] if c else Font_5x7[n + i] ^ 0xFF
screen[ind + 5] = 0 if c else 0xFF
self.set_pos(x, y)
i2c.write(ADDR, b'\x40' + screen[ind:ind + 6])
def pixel(self, x, y, color=1):
page, shift_page = divmod(y, 8)
ind = x + page * 128 + 1
b = screen[ind] | (
1 << shift_page) if color else screen[ind] & ~(1 << shift_page)
screen[ind] = b
self.set_pos(x, page)
i2c.write(ADDR, bytearray([0x40, b]))
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 show(self):
self.cmd(SET_COL_ADDR)
self.cmd(0)
self.cmd(127)
self.cmd(SET_PAGE_ADDR)
self.cmd(0)
self.cmd(7)
i2c.write(0x3c, self.buffer)
def motor(Spin, Speed):
TM1 = int(Speed % 256)
TM2 = int(Speed / 256)
CH = (Spin - 1) * 4 + 8
CH1 = int((CH << 8) + TM1)
CH2 = int(((CH + 1) << 8) + TM2)
i2c.write(64, struct.pack('>H', CH1))
i2c.write(64, struct.pack('>H', CH2))
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 set_px(self, x, y, s, d=1):
p, sp = divmod(y, 8)
i = x * 2 + p * 128 + 1
b = self._s[i] | (1 << sp) if s else self._s[i] & ~(1 << sp)
pack_into(">BB", self._s, i, b, b)
if d:
self.set_pos(x, p)
i2c.write(0x3c, bytearray([0x40, b, b]))
def init():
i2c.init()
while not _ADDR in i2c.scan():
print("Crickit not found!")
time.sleep(1)
reg_buf[0] = 0x7F
reg_buf[1] = 0xFF
i2c.write(_ADDR, reg_buf)
def motor_stop(self, motor):
buffer = bytearray([motor, FORWARDS, 0])
try:
i2c.write(0x10, buffer)
except OSError:
display.show(Image.SAD)
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 show_bitmap(filename):
set_pos()
command([0xae])
with open(filename, 'rb') as my_file:
for i in range(0, 16):
i2c.write(ADDR, b'\x40' + my_file.read(64))
set_zoom(0)
command([0xaf])
def __init__(self): cmd = [ [0xAE],[0xA4],[0xD5, 0xF0],[0xA8, 0x3F],[0xD3, 0x00],[0 | 0x0],[0x8D, 0x14], [0x20, 0x00],[0x21, 0, 127],[0x22, 0, 63],[0xa0 | 0x1],[0xc8],[0xDA, 0x12], [0x81, 0xCF],[0xd9, 0xF1],[0xDB, 0x40],[0xA6],[0xd6, 1],[0xaf]] for c in cmd: i2c.write(self.ADDR, b'\x00' + bytearray(c)) self.clear_display()
def set_px(x, y, color, draw=1):
page, shift_page = divmod(y, 8)
ind = x * 2 + page * 128 + 1
b = screen[ind] | (
1 << shift_page) if color else screen[ind] & ~(1 << shift_page)
pack_into(">BB", screen, ind, b, b)
if draw:
set_pos(x, page)
i2c.write(0x3c, bytearray([0x40, b, b]))
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 __init__(self):
self._s = bytearray(513)
self._s[0] = 0x40
C = [[0xAE], [0xA4], [0xD5, 0xF0], [0xA8, 0x3F], [0xD3, 0x00],
[0 | 0x0], [0x8D, 0x14], [0x20, 0x00], [0x21, 0, 127],
[0x22, 0, 63], [0xa0 | 0x1], [0xc8], [0xDA, 0x12], [0x81, 0xCF],
[0xd9, 0xF1], [0xDB, 0x40], [0xA6], [0xd6, 1], [0xaf]]
for c in C:
i2c.write(0x3C, b'\x00' + bytearray(c))
def init(self, state=False):
self.writePin(0, state)
self.writePin(1, state)
self.writePin(2, state)
self.writePin(3, state)
self.writePin(4, state)
i2c.write(self.addr,
bytearray([PCA9554A_REG_CONFIG, PCA9554A_CONF_OUTPUT]))
return True
def clear_px(self, x, y):
x = 127 if x > 127 else x
y = 63 if y > 63 else y
page, shift_page = y >> 3, y % 8
ind = x + page * 128 + 1
screenPixel = (self.screen[ind] & ~ (1 << shift_page))
pack_into(">B", self.screen, ind, screenPixel)
self.set_pos(x, page)
i2c.write(self.ADDR, bytearray([0x40, screenPixel]))
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 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 _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 setPwm(self, channel, on, off):
if not (0 <= channel <= 15):
return
buf = [0] * 5
buf[0] = self.LED0_ON_L + 4 * channel
buf[1] = on & 0xFF
buf[2] = (on >> 8) & 0xFF
buf[3] = off & 0xFF
buf[4] = (off >> 8) & 0xFF
i2c.write(self.PCA9685_ADDRESS, bytes(buf))
def clear_px(self, x, y):
x = 63 if x > 63 else x
y = 31 if y > 31 else y
page, shift_page = y >> 3, y % 8
#page, shift_page = divmod(y, 8)
ind = x * 2 + page * 128 + 1
screenPixel = (self.screen[ind] & ~ (1 << shift_page))
pack_into(">B", self.screen, ind, screenPixel, screenPixel)
self.set_pos(x, page)
i2c.write(self.ADDR, bytearray([0x40, screenPixel, screenPixel]))
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 motor_run(self, motor, direction, speed):
speed = 255 if speed > 255 else speed
speed = 0 if speed < 0 else speed
buffer = bytearray([motor, direction, speed])
try:
i2c.write(0x10, buffer)
except OSError:
display.show(Image.SAD)
