def __init__(self, mode):
self.i2c = pyb.I2C(1, pyb.I2C.MASTER)
self.addr = pyb.I2C.scan(self.i2c)
if self.i2c.is_ready(addr):
self.i2c.mem_write(mode, addr, op_reg)
pot = ADC(Pin('X11'))
mic = ADC(Pin('Y11'))
r_LED = LED(1)
g_LED = LED(2)
y_LED = LED(3)
b_LED = LED(4)
g_pitch = 0
# Configure X2:4, X7 as setting input pin - pull_up to receive switch settings
s0 = Pin('Y3', pyb.Pin.IN, pyb.Pin.PULL_UP)
s1 = Pin('X6', pyb.Pin.IN, pyb.Pin.PULL_UP)
# I2C connected to Y9, Y10 (I2C bus 2) and Y11 is reset low active
try:
i2c_2 = pyb.I2C(2, pyb.I2C.MASTER)
dev_list = i2c_2.scan()
oled = OLED_938(pinout={
'sda': 'Y10',
'scl': 'Y9',
'res': 'Y8'
},
height=64,
external_vcc=False,
i2c_devid=dev_list[0])
oled.poweron()
oled.init_display()
oled_ok = True
except:
print("\n*** OLED Display missing ***\n")
#
# This example shows the power of the OpenMV Cam to detect QR Codes
# using lens correction (see the qrcodes_with_lens_corr.py script for higher performance).
import sensor, image, time, pyb, ustruct
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time=2000)
sensor.set_auto_gain(False) # must turn this off to prevent image washout...
clock = time.clock()
text = "Hello World!\n"
data = ustruct.pack("<%ds" % len(text), text)
bus = pyb.I2C(2, pyb.I2C.SLAVE, addr=0x12)
bus.deinit()
bus = pyb.I2C(2, pyb.I2C.SLAVE, addr=0x12)
print("Waiting for Arduino...")
while (True):
clock.tick()
img = sensor.snapshot()
img.lens_corr(1.8) # strength of 1.8 is good for the 2.8mm lens.
for code in img.find_qrcodes():
img.draw_rectangle(code.rect(), color=(255, 0, 0))
#print(code)
lcode = code.payload()
print(code.payload())
if 'forward' in lcode.lower():
data = "forward\n"
# test of pyb stub file
import pyb
x = pyb.ADC
pyb.stop()
pyb.hard_reset()
i2c = pyb.I2C()
i2c.init('x')
c = pyb.CAN()
c.init()
import sys
sys.path.insert(1, "C:\\develop\\MyPython\\Stubber\\stubs\\esp32_LoBo_3_2_24")
sys.path
import pyb
from board import sys_config
#from hts221 import HTS221
from ism43362 import ISM43362
if 1 == 0:
i2c = pyb.I2C(sys_config['hts221']['i2c_bus'],
pyb.I2C.MASTER,
baudrate=100000)
hts221 = HTS221(i2c, sys_config['hts221']['i2c_addr'])
hts221.print_calib()
print("Humidity = %4.1f %%" % hts221.humidity())
print("Temperature = %2.1f C" % hts221.temperature())
if 1 == 0:
mag = LIS3MDL(i2c, sys_config['lis3mdl']['i2c_addr'])
x, y, z = mag.xyz()
print("Magnetic field = (%.3e, %.3e, %.3e) %s" % (x, y, z, mag.unit()))
#p = LPS25H(i2c, sys_config['lps25h']['i2c_addr'])
print("Pressure %5.3e %s, Height %.1f m, Temperature = %.1f C" %
(p.value(), p.unit(), p.height(), p.temperature()))
#dist = VL6180X(i2c, sys_config['vl6180x']['i2c_addr'])
val = dist.dev_id()
print("Distance sensor:")
print("\n".join([" %s: %s" % (k, v) for k, v in val.items()]))
print("Distance %.1f %s" % (dist.value(), dist.unit()))
wifi_com = pyb.SPI(sys_config['ism43362']['spi_bus'],
pyb.SPI.MASTER,
baudrate=1000000,
def __init__(self):
self.i2c = pyb.I2C(1, pyb.I2C.MASTER)
import pyb
# Touch keypad
import mpr121
keybd = mpr121.MPR121(pyb.I2C(1, pyb.I2C.MASTER))
keybd.debounce(3, 3)
for electr in range(4):
keybd.threshold(electr, 50, 30)
# LCD
lcd = pyb.LCD('X')
lcd.light(True)
# Test program
from math import cos, sin, pi, sqrt, atan2, asin, acos
d2r = pi / 180
def circle_intersection(circle1, circle2):
'''
@summary: calculates intersection points of two circles
@param circle1: tuple(x,y,radius)
@param circle2: tuple(x,y,radius)
@result: tuple of intersection points (which are (x,y) tuple)
'''
# return self.circle_intersection_sympy(circle1,circle2)
x1, y1, r1 = circle1
x2, y2, r2 = circle2
# http://stackoverflow.com/a/3349134/798588
dx, dy = x2 - x1, y2 - y1
d = sqrt(dx * dx + dy * dy)
def __init__(self, slave_addr=0x12, rate=100000): # private
self.__addr = slave_addr
self.__freq = rate
self.__i2c = pyb.I2C(2)
rpc_master.__init__(self)
self._stream_writer_queue_depth_max = 1
def __init__(self, slave_addr=0x12): # private
self.__addr = slave_addr
self.__i2c = pyb.I2C(2)
rpc_slave.__init__(self)
self._stream_writer_queue_depth_max = 1
#!/usr/bin/env python
#
# Main file for STM32F4DISCOVERY
#
import os
import sys
import pyb
from board import sys_config
from lps22hb import LPS22HB
i2c = pyb.I2C(sys_config['pmod']['p7']['i2c_bus'],
pyb.I2C.MASTER,
baudrate=100000)
sen = LPS22HB(i2c, 0x5C)
def __init__(self, bus=1, address=BMP180_I2CADDR, mode=BMP180_STANDARD):
self._mode = mode
self._address = address
self._bus = pyb.I2C(bus, pyb.I2C.MASTER)
# Load calibration values
self._load_calibration()
from pyb import I2C
import micropython
import ustruct
import utime
import bno055
#i2c = pyb.I2C(1, I2C.MASTER, baudrate = 115200)
#==============================================================================
# i2c.mem_write(0x0C, 0x28, 0x3D)
# utime.sleep_ms(10)
#
# status = i2c.mem_read(1,0x28,0x39)
# print(ustruct.unpack('b',status))
#
# error = i2c.mem_read(1,0x28,0x3A)
# print(ustruct.unpack('b',error))
#==============================================================================
imu = bno055.bno055(pyb.I2C(1, I2C.MASTER, baudrate=100000), 0x28)
while True:
# pitch = i2c.mem_read(2, 0x28, 0x1A)
# print(ustruct.unpack('<h',pitch))
# print(str(pitch) + '\n')
pitch = imu.get_euler_pitch()
roll = imu.get_euler_roll()
yaw = imu.get_euler_yaw()
print(str(pitch) + ',' + str(roll) + ',' + str(yaw) + '\n')
utime.sleep_ms(10)
def __init__(self):
self.bus = pyb.I2C(2, pyb.I2C.SLAVE, addr=0x12)
self.bus.deinit()
self.bus = pyb.I2C(2, pyb.I2C.SLAVE, addr=0x12)
import pyb
from board import config
from conf import conf
from time import sleep
rp = pyb.Pin('PE3', pyb.Pin.OUT_PP, pyb.Pin.PULL_NONE)
rp.high()
i2c = pyb.I2C(1, pyb.I2C.MASTER, baudrate=100000)
spi = pyb.SPI(2, pyb.SPI.MASTER, baudrate=600000, polarity=1, phase=1)
if conf==0:
from l3gd20 import L3GD20
from lsm303c import LSM303C
from mfx import MFX
cs_gyro = pyb.Pin('PD7', pyb.Pin.OUT_PP)
gyro = L3GD20(spi, cs_gyro)
# gyro.DEBUG = False
print("Gyro = (%7.2f %7.2f, %7.2f)" % gyro.xyz())
print("Temperature = %.1f C" % gyro.temperature())
cs_accel = pyb.Pin('PE0', pyb.Pin.OUT_PP, pyb.Pin.PULL_NONE)
cs_mag = pyb.Pin('PC0', pyb.Pin.OUT_PP, pyb.Pin.PULL_NONE)
mems = LSM303C(spi, cs_mag, cs_accel)
mems.bidi_mode()
mems.exists()
print("Accel = (%6.4f, %6.4f, %6.4f)" % mems.accel.xyz())
print("Mag = (%6.4f, %6.4f, %6.4f)" % (mems.mag.xyz()))
def __init__(self, aLoc):
self.i2c = pyb.I2C(aLoc, pyb.I2C.MASTER)
self._b1 = bytearray(1)
self.init()
#hardware platform: Brainpad
#Testing the onboard Oled
import pyb
import ssd1306
i2c=pyb.I2C(1,pyb.I2C.MASTER,baudrate=100000)
lcd=ssd1306.SSD1306_I2C(128,64,i2c)
lcd.text("The BrainPad",0,0)
lcd.text("From ",0,16)
lcd.text("GHI Electronics",0,32)
lcd.show()
def s0_pan_position(value):
s0_pan.pulse_width(
round(s0_lower_limit +
(max(min(value, 1000), 0) * s0_pan_conversion_factor)))
def s1_tilt_position(value):
s1_tilt.pulse_width(
round(s1_lower_limit +
(max(min(value, 1000), 0) * s1_tilt_conversion_factor)))
# Link Setup
bus = pyb.I2C(2, pyb.I2C.SLAVE, addr=i2c_address)
def write(data):
# Prepare the data to transmit first so we can do it quickly.
out_data = []
for i in range(0, len(data), 2):
out_data.append(data[i:i + 2])
# Disable interrupts so we can send all packets without gaps.
state = pyb.disable_irq()
for i in range(len(out_data)):
max_exceptions = 10
loop = True
while (loop):
try:
bus.send(out_data[i], timeout=1)
def __init__(self, bus): # Check existence and wake it
self._i2c = pyb.I2C(bus, pyb.I2C.MASTER)
devices = self._i2c.scan()
if not LM75_ADDR in devices:
raise OSError("No LM75 device detected")
self.wake()
# main.py -- put your code here!
from pyb import LCD, SPI, I2C
import math
import os
import sys
import random
import pyb
SPI(5, SPI.MASTER, 6000000)
lcd = LCD(0)
lcd.line(0x1c, 1, 1, 1)
led = pyb.LED(1)
i2c = pyb.I2C(3, pyb.I2C.MASTER)
t_pressed = 0
def mandelbrot():
# returns True if c, complex, is in the Mandelbrot set
#@micropython.native
def in_set(c):
z = 0
for i in range(40):
z = z * z + c
if abs(z) > 60:
return False
return True
lcd.line(0xffff, 1, 1, 1)
for u in range(230):
for v in range(310):
import pyb
pot = pyb.ADC('Y12')
hpctl = pyb.Pin('Y11')
hpctl.init(hpctl.OUT_PP)
hpctl.high()
i2c = pyb.I2C(2)
i2c.init(i2c.MASTER)
# Might do a 'try' here to make sure both i2c devices are working:
i2c.scan()
#> [26, 96]
# Set Headphone Amp chip registers:
i2c.mem_write(0xc0, 96, 1) # control register: enable both amplifier channels, activate stereo mode
i2c.mem_write(0x35, 96, 2) # volume register; unmute both channels, set gain to ~0dB
i2c.mem_write(0x00, 96, 3) # output tri-state register; set both channels to output mode
# Set codec registers:
# THe SSM2604 uses a register addressing scheme that does not map directly to the uPy
# mem_read / mem_write methods.
# There are a total of 11 9-bit registers (R0-R9 and R15) which are selected using a
# 7-bit address. Register writes are constructed using the 'send' method:
# i2c.send('0b<7-bit register address><9-bit register data>', 26)
# Register reads can use 'mem_read' but the register address must be multiplied by 2
# (or shifted 1 bit left, so the 7-bit address is left justified)
# The read should be for two bytes, and the 'bytes' object that is returned will be
# two bytes long with the LSB first
# Set up Codec for Pass-Through
i2c.send(b'\x00\x17', 26) # LEFT ADC INPUT GAIN, ADDRESS 0x00: unmute left ADC, input gain=0dB
i2c.send(b'\x02\x17', 26) # RIGHT ADC INPUT GAIN, ADDRESS 0x01: unmute right ADC, input gain=0dB
# R2 and R3 are reserved
# boot.py -- run on boot-up
# can run arbitrary Python, but best to keep it minimal
import pyb, os, micropython, time
# power hold
pwr = pyb.Pin("B15", pyb.Pin.OUT)
pwr.on()
# v1.5.3-rc99 - use odd rc for main firmware and even for debug
# so it's possible to upgrade from debug to main firmware.
# (rc99 is final version for production)
version = "<version:tag10>0100500399</version:tag10>"
# get i2c
i2c = pyb.I2C(1)
i2c.init()
# start measurements
if 112 in i2c.scan():
i2c.mem_write(0b00010000, 112, 0)
leds = [pyb.LED(i) for i in range(1, 5)]
# poweroff on button press
def pwrcb(e):
micropython.schedule(poweroff, 0)
# callback scheduled from the interrupt
def poweroff(_):
# make sure it disables power no matter what
def __init__(self, i2c_num, address=0x76):
# I2C 1 : SCL = X9, SDA = X10
# I2C 2 : SCL = Y9, SDA = Y10
self.i2c = pyb.I2C(i2c_num, pyb.I2C.MASTER)
self.addr = address
if not self.i2c.is_ready(self.addr):
raise ValueError('No I2C device on I2C bus ' + str(i2c_num) +
' at address ' + str(self.addr))
self.id = BME280.int_from_bytes(
self.i2c.mem_read(1, self.addr, self.ID_REG))
buf = bytearray(2)
# Read the compensation parameters
self.i2c.mem_read(buf, self.addr, BME280.DIG_T1)
self.dig_T1 = BME280.int_from_bytes(buf, "little")
self.i2c.mem_read(buf, self.addr, BME280.DIG_T2)
self.dig_T2 = BME280.int_from_bytes(buf, "little", signed=True)
self.i2c.mem_read(buf, self.addr, BME280.DIG_T3)
self.dig_T3 = BME280.int_from_bytes(buf, "little", signed=True)
self.i2c.mem_read(buf, self.addr, BME280.DIG_P1)
self.dig_P1 = BME280.int_from_bytes(buf, "little")
self.i2c.mem_read(buf, self.addr, BME280.DIG_P2)
self.dig_P2 = BME280.int_from_bytes(buf, "little", signed=True)
self.i2c.mem_read(buf, self.addr, BME280.DIG_P3)
self.dig_P3 = BME280.int_from_bytes(buf, "little", signed=True)
self.i2c.mem_read(buf, self.addr, BME280.DIG_P4)
self.dig_P4 = BME280.int_from_bytes(buf, "little", signed=True)
self.i2c.mem_read(buf, self.addr, BME280.DIG_P5)
self.dig_P5 = BME280.int_from_bytes(buf, "little", signed=True)
self.i2c.mem_read(buf, self.addr, BME280.DIG_P6)
self.dig_P6 = BME280.int_from_bytes(buf, "little", signed=True)
self.i2c.mem_read(buf, self.addr, BME280.DIG_P7)
self.dig_P7 = BME280.int_from_bytes(buf, "little", signed=True)
self.i2c.mem_read(buf, self.addr, BME280.DIG_P8)
self.dig_P8 = BME280.int_from_bytes(buf, "little", signed=True)
self.i2c.mem_read(buf, self.addr, BME280.DIG_P9)
self.dig_P9 = BME280.int_from_bytes(buf, "little", signed=True)
self.dig_H1 = BME280.int_from_bytes(
self.i2c.mem_read(1, self.addr, BME280.DIG_H1), "little")
self.i2c.mem_read(buf, self.addr, BME280.DIG_H2)
self.dig_H2 = BME280.int_from_bytes(buf, "little", signed=True)
self.dig_H3 = BME280.int_from_bytes(
self.i2c.mem_read(1, self.addr, BME280.DIG_H3), "little")
self.i2c.mem_read(buf, self.addr, BME280.DIG_H4)
self.dig_H4 = (buf[0] << 4) | (buf[1] & 0b1111)
self.i2c.mem_read(buf, self.addr, BME280.DIG_H5)
self.dig_H5 = (buf[1] << 4) | ((buf[0] >> 4) & 0b1111)
self.dig_H6 = BME280.int_from_bytes(self.i2c.mem_read(
1, self.addr, BME280.DIG_H6),
"little",
signed=True)
# Set humidity measurements with no oversampling
self.i2c.mem_write(BME280.OVRSAMP_1, self.addr, BME280.HUM_CTRL_REG)
# Set temperature and pressure measurements with no oversampling
buf = bytearray(1)
self.i2c.mem_read(buf, self.addr, BME280.MEAS_REG)
buf[0] &= ~(BME280.TEMP_MASK | BME280.PRESS_MASK)
buf[0] |= (BME280.OVRSAMP_1 << BME280.TEMP_CTRL) \
| (BME280.OVRSAMP_1 << BME280.PRESS_CTRL)
self.i2c.mem_write(buf, self.addr, BME280.MEAS_REG)
## physical connections (pyb - LSM9DS0):
## Y12 - CSG
## Y11 - CSXM
## MOSI(1) - SDA
## MISO(1) - SDOG and SDOXM
## SCK(1) - SCL
#spi = pyb.SPI(1, mode=pyb.SPI.MASTER, baudrate=328125)
#spi_g = pyb.Pin('Y12', pyb.Pin.OUT_PP)
#spi_xm = pyb.Pin('Y11', pyb.Pin.OUT_PP)
#lsm9ds0 = LSM9DS0(spi=spi, g_addr=spi_g, xm_addr=spi_xm, g_sens=500, a_sens=4, m_sens=12)
# I2C mode:
# physical connections (pyb - LSM9DS0):
# SDA(2) - SDA
# SCL(2) - SCL
i2c = pyb.I2C(2, mode=pyb.I2C.MASTER, baudrate=100000)
lsm9ds0 = LSM9DS0(i2c=i2c, g_sens=500, a_sens=4, m_sens=12)
g_id, xm_id = lsm9ds0.who_am_i()
print((g_id, xm_id)) # (b'\xd4', b'I')
pyb.delay(1000)
lsm9ds0.accel.set_sens(16)
while True:
print(lsm9ds0.accel.all())
mag_x = lsm9ds0.mag.x()
gyro_z = lsm9ds0.gyro.z()
pyb.delay(100)
# test pyb module on F405 MCUs
import os, pyb
if not "STM32F405" in os.uname().machine:
print("SKIP")
raise SystemExit
print(pyb.freq())
print(type(pyb.rng()))
# test HAL error specific to F405
i2c = pyb.I2C(2, pyb.I2C.CONTROLLER)
try:
i2c.recv(1, 1)
except OSError as e:
print(repr(e))
#init
import pyb, gc
# 1.0 open, 0.0 closed
w_status = 1
#0 early, 1 late, 2 night, 3 manual
w_mode = 3
w_times = [[(19, 0), (8, 0)], [(19, 0), (10, 0)], [(7, 0), (14, 30)]]
#hardware
i2c = pyb.I2C(2, pyb.I2C.MASTER)
i2c.mem_write(4, 90, 0x5e)
touch = i2c.mem_read(1, 90, 0)[0]
s_up = pyb.Servo(1)
s_down = pyb.Servo(2)
lcd = pyb.LCD('Y')
rtc = pyb.RTC()
led_b = pyb.LED(1)
led_2 = pyb.LED(2)
#calibration
s_up.angle(-12)
def use_btn_w_servo(servo, duration=18000, inverse=False):
if inverse:
end_pos = -30
else:
def task_motor():
''' Function which runs for Task 1, and controls how the motors will rotate. '''
control = controller.Controller(20, 50, .1, BALANCE_SET_POINT)
motor1 = motor.MotorDriver(pyb.Pin.board.PB4, pyb.Pin.board.PB5,
pyb.Pin.board.PA10, pyb.Timer(3))
encoder1 = encoder.Encoder(pyb.Pin.board.PB7, pyb.Pin.board.PB6,
pyb.Timer(4))
motor2 = motor.MotorDriver(pyb.Pin.board.PA1, pyb.Pin.board.PA0,
pyb.Pin.board.PC1, pyb.Timer(2))
encoder2 = encoder.Encoder(pyb.Pin.board.PC7, pyb.Pin.board.PC6,
pyb.Timer(8))
aye = pyb.I2C(1, pyb.I2C.MASTER)
accelo = acc.Acc(aye, 107)
filter0 = filter1.Filter(accelo)
state = BALANCE
while True:
x_theta = (filter0.updated_x() + THETA_OFFSET)
pwm = control.calculate(x_theta)
clear()
if state == BALANCE:
'''Include what will make this robot balance, accelo info and filters, motor duty cycle'''
control.set_setpoint(BALANCE_SET_POINT)
motor1.set_duty_cycle(pwm)
motor2.set_duty_cycle(pwm)
if (BACK_SENSOR == 1 or BLUETOOTH == "Forward"):
''' go forward'''
state = FORWARD
elif (FRONT_SENSOR == 1 or BLUETOOTH == "Backward"):
''' go backwards'''
state = BACKWARD
elif (RIGHT_SENSOR == 1 or BLUETOOTH == "TurnLeft"):
''' turn left'''
state = TURNLEFT
elif (LEFT_SENSOR == 1 or BLUETOOTH == "TurnRight"):
''' Turn right'''
state = TURNRIGHT
elif state == FORWARD:
''' Include what will make this robot move forward'''
control.set_setpoint(FRONT_SET_POINT)
motor1.set_duty_cycle(pwm)
motor2.set_duty_cycle(pwm)
if (FRONT_SENSOR == 1 or BLUETOOTH == "Backward"):
''' go backwards'''
state = BACKWARD
elif (RIGHT_SENSOR == 1 or BLUETOOTH == "TurnLeft"):
''' turn left'''
state = TURNLEFT
elif (LEFT_SENSOR == 1 or BLUETOOTH == "TurnRight"):
''' Turn right'''
state = TURNRIGHT
elif (BACK_SENSOR == 0):
state = BALANCE
elif state == BACKWARD:
''' Include what will make this robot move backwards'''
control.set_setpoint(FRONT_SET_POINT)
motor1.set_duty_cycle(pwm)
motor2.set_duty_cycle(pwm)
if (BACK_SENSOR == 1 or BLUETOOTH == "Forward"):
''' go forward'''
state = FORWARD
elif (RIGHT_SENSOR == 1 or BLUETOOTH == "TurnLeft"):
''' turn left'''
state = TURNLEFT
elif (LEFT_SENSOR == 1 or BLUETOOTH == "TurnRight"):
''' Turn right'''
state = TURNRIGHT
elif (FRONT_SENSOR == 0):
state = BALANCE
elif state == TURNLEFT:
''' Include what will make this robot turn left'''
control.set_setpoint(FRONT_SET_POINT)
motor1.set_duty_cycle(pwm)
motor2.set_duty_cycle(pwm)
if (BACK_SENSOR == 1 or BLUETOOTH == "Forward"):
''' go forward'''
state = FORWARD
elif (FRONT_SENSOR == 1 or BLUETOOTH == "Backward"):
''' go backwards'''
state = BACKWARD
elif (LEFT_SENSOR == 1 or BLUETOOTH == "TurnRight"):
''' Turn right'''
state = TURNRIGHT
elif (RIGHT_SENSOR == 0):
state = BALANCE
elif state == TURNRIGHT:
''' Include what will make this robot turn right'''
control.set_setpoint(FRONT_SET_POINT)
motor1.set_duty_cycle(pwm)
motor2.set_duty_cycle(pwm)
if (BACK_SENSOR == 1 or BLUETOOTH == "Forward"):
''' go forward'''
state = FORWARD
elif (FRONT_SENSOR == 1 or BLUETOOTH == "Backward"):
''' go backwards'''
state = BACKWARD
elif (RIGHT_SENSOR == 1 or BLUETOOTH == "TurnLeft"):
''' turn left'''
state = TURNLEFT
elif (LEFT_SENSOR == 0):
state = BALANCE
yield (state)
def __init__(self,id): self.accel_addr = 35 self.i2c = pyb.I2C(id) self.i2c.init(pyb.I2C.MASTER, baudrate=400000) print(self.i2c.scan())
def __init__(self, spi):
self.accel_addr = 80
self.i2c = pyb.I2C(spi)
self.i2c.init(pyb.I2C.MASTER, baudrate=400000)
print(self.i2c.scan())
-------------------------------------------------------
User's Program - put your code here
'''
import pyb
import gc
from pyb import Pin, Timer, LED
from oled_938 import OLED_938
from struct import unpack
# Constants
BLANK_LINE = " "
# Initialise OLED display
try:
oled_port = pyb.I2C('Y', pyb.I2C.MASTER)
if (not oled_port.scan()):
oled = None
else:
oled = OLED_938(pinout={
'sda': 'Y10',
'scl': 'Y9',
'res': 'Y8'
},
height=64,
external_vcc=False,
i2c_devid=61)
oled.poweron()
oled.init_display()
oled.draw_text(0, 0, "-- User's Program --")
oled.draw_text(0, 40, "-- Edit user.py --")
'''
def eulerAngles(self):
def angularVelocities(self):
'''
if __name__ == '__main__':
i = 0
'''
i2c = I2C(1, I2C.MASTER)
imu = IMU(i2c)
imu.mode(_NDOF_MODE)
'''
i2c = pyb.I2C(1, pyb.I2C.MASTER)
imu = IMU(i2c)
imu.setMode(_CONFIG_MODE)
imu.currentMode()
imu.setMode(_NDOF_MODE)
imu.read(1, _POWER_MODE)
imu.write(0x03, 0x76, 0xF4)
while i < 100:
print(imu.readTemp(1, _MSB_TEMP_REG))
print(imu.readTemp(1, _LSB_TEMP_REG))
print(imu.readTemp(1, _STAT_TEMP_REG))
i += 1
'''imu.calib()'''
'''
data = imu.read(1, 0x35)
acc_cal = int((data[0] >> 2) & 0b11)
