def pressure(self):
'''
Pressure in mbar.
'''
next(self.gauge)
self.temperature # Populate self.B5_raw
try:
MSB = unp('<h', self.MSB_raw)[0]
LSB = unp('<h', self.LSB_raw)[0]
XLSB = unp('<h', self.XLSB_raw)[0]
except:
return 0.0
UP = ((MSB << 16)+(LSB << 8)+XLSB) >> (8-self.oversample_setting)
B6 = self.B5_raw-4000
X1 = (self._B2*(B6**2/2**12))/2**11
X2 = self._AC2*B6/2**11
X3 = X1+X2
B3 = ((int((self._AC1*4+X3)) << self.oversample_setting)+2)/4
X1 = self._AC3*B6/2**13
X2 = (self._B1*(B6**2/2**12))/2**16
X3 = ((X1+X2)+2)/2**2
B4 = abs(self._AC4)*(X3+32768)/2**15
B7 = (abs(UP)-B3) * (50000 >> self.oversample_setting)
if B7 < 0x80000000:
pressure = (B7*2)/B4
else:
pressure = (B7/B4)*2
X1 = (pressure/2**8)**2
X1 = (X1*3038)/2**16
X2 = (-7357*pressure)/2**16
return pressure+(X1+X2+3791)/2**4
def parse_payload(self):
hp = deepcopy(self.hp)
header, pdu_type, data_len, packet_type = unp("!BBHB", hp[:5])
self.add_field("packet header", header, "s7 packet header", 1)
self.add_field("pdu type", pdu_type, "PDU type: " + S7_PDU_TYPE[int(pdu_type)], 1)
self.add_field("data len", data_len, "data from next byte minus last 4 bytes", 2)
self.add_field("packet type", packet_type, "packet type: " + S7_PACKET_TYPE[int(packet_type)], 1)
hp = self.shift_hp_data_left(self.hp)
# hp = hp[5:] # FIX IT EVERY TIME AFTER PARSNG NEW FIELD
reserved1, function_code, reserved2 = unp("!HHH", hp[:6])
self.add_field("reserved", reserved1, "reserved?", 2)
self.add_field("function code", function_code, "function code: " + S7_FUNCTION_CODE[int(function_code)], 2)
hp = self.shift_hp_data_left(self.hp)
self.add_field("reserved", reserved2, "reserved?", 2)
hp = self.shift_hp_data_left(self.hp)
data_sequence_number, = unp("!H", hp[:2])
self.add_field("data seq numb", data_sequence_number, "data sequnce number ?", 2)
hp = self.shift_hp_data_left(self.hp)
# process unknow data and packet footer
unparsed = unp("!%dB" % len(hp[:-4]), hp[:-4])
self.add_field("unparsed", unparsed, "unparsed/unknown data", len(unparsed))
footer = unp("!I", hp[-4:])[0]
self.add_field("packet footer", footer, "packet footer with pdu type", 4)
def pressure(self):
'''
Pressure in mbar.
'''
next(self.gauge)
self.temperature # Populate self.B5_raw
try:
MSB = unp('<h', self.MSB_raw)[0]
LSB = unp('<h', self.LSB_raw)[0]
XLSB = unp('<h', self.XLSB_raw)[0]
except:
return 0.0
UP = ((MSB << 16) + (LSB << 8) + XLSB) >> (8 - self.oversample_setting)
B6 = self.B5_raw - 4000
X1 = (self._B2 * (B6**2 / 2**12)) / 2**11
X2 = self._AC2 * B6 / 2**11
X3 = X1 + X2
B3 = ((int((self._AC1 * 4 + X3)) << self.oversample_setting) + 2) / 4
X1 = self._AC3 * B6 / 2**13
X2 = (self._B1 * (B6**2 / 2**12)) / 2**16
X3 = ((X1 + X2) + 2) / 2**2
B4 = abs(self._AC4) * (X3 + 32768) / 2**15
B7 = (abs(UP) - B3) * (50000 >> self.oversample_setting)
if B7 < 0x80000000:
pressure = (B7 * 2) / B4
else:
pressure = (B7 / B4) * 2
X1 = (pressure / 2**8)**2
X1 = (X1 * 3038) / 2**16
X2 = (-7357 * pressure) / 2**16
return pressure + (X1 + X2 + 3791) / 2**4
def parse_payload(self):
hp = deepcopy(self.hp)
header, pdu_type, data_len, packet_type = unp('!BBHB', hp[:5])
self.add_field('packet header', header, 's7 packet header', 1)
self.add_field('pdu type', pdu_type, 'PDU type: '+ S7_PDU_TYPE[int(pdu_type)], 1)
self.add_field('data len', data_len, 'data from next byte minus last 4 bytes', 2)
self.add_field('packet type', packet_type, 'packet type: '+ S7_PACKET_TYPE[int(packet_type)], 1)
hp = self.shift_hp_data_left(self.hp)
#hp = hp[5:] # FIX IT EVERY TIME AFTER PARSNG NEW FIELD
reserved1, function_code, reserved2 = unp('!HHH', hp[:6])
self.add_field('reserved', reserved1, 'reserved?', 2)
self.add_field('function code', function_code, 'function code: ' + S7_FUNCTION_CODE[int(function_code)], 2)
hp = self.shift_hp_data_left(self.hp)
self.add_field('reserved', reserved2, 'reserved?', 2)
hp = self.shift_hp_data_left(self.hp)
data_sequence_number, = unp('!H', hp[:2])
self.add_field('data seq numb', data_sequence_number, 'data sequnce number ?', 2)
hp = self.shift_hp_data_left(self.hp)
# process unknow data and packet footer
unparsed = unp('!%dB' % len(hp[:-4]), hp[:-4])
self.add_field('unparsed', unparsed, 'unparsed/unknown data', len(unparsed))
footer = unp('!I', hp[-4:])[0]
self.add_field('packet footer', footer, 'packet footer with pdu type', 4)
def parse_meta_event(tr_data, meta_start):
'''meta_start is after delta time
tr_data[meta_start+1] == '0xFF'
'''
d = tr_data[meta_start:] #might be in-efficient but meh
meta_e_type = None
e = None
e_extra = {}
end = None
meta_e_type = MetaEventType(int(d[1]))
if meta_e_type == MetaEventType.SequenceNum and d[2] == 0x02:
end = 4
e = MeSeqNum._make(unp('>H'), d[3:end])
elif meta_e_type == MetaEventType.Text:
pass
elif meta_e_type == MetaEventType.Copyright:
pass
elif meta_e_type == MetaEventType.SeqTrackName:
event_len, var_len = parse_delta(d, 2)
text_start = 2 + var_len
text_end = text_start + event_len
text_b = unp('>%is' % (event_len, ), d[text_start:text_end])[0]
text = str(text_b, 'ascii')
e = MeSeqTrackName._make((event_len, text))
end = text_end
pass
elif meta_e_type == MetaEventType.InstrumentName:
pass
#...
elif meta_e_type == MetaEventType.KkTrackStart and d[2] == 0x1:
end = 4
e = MeTrackStart._make(unp('>B', d[3:end]))
elif meta_e_type == MetaEventType.EndOfTrack and d[2] == 0x0:
end = 3
e = MeEndOfTrack()
elif meta_e_type == MetaEventType.SetTempo and d[2] == 0x03:
end = 6
e = MeSetTempo._make((unp_3b(d[3:end]), ))
elif meta_e_type == MetaEventType.TimeSig and d[2] == 0x04:
end = 7
e = MeTimeSig._make(unp('>BBBB', d[3:end]))
e_extra['time_sig'] = e.n / (2 ^ e.b)
elif meta_e_type == MetaEventType.KeySig and d[2] == 0x02:
end = 5
e = MeKeySig._make(unp('>BB', d[3:end]))
else:
print('unknown meta event')
print(meta_e_type, e, e_extra)
#print('kk:', d[:10])
return MetaEvent(meta_e_type, e, e_extra), (end + meta_start)
def pitch(self):
# Returns pitch angle in degrees based on x and c accelerations.
scale = (16384, 8192, 4096, 2048)
raw = self.get_accel_raw()
x = unp('>h', raw[0:2])[0] / scale[self._ar]
z = unp('>h', raw[4:6])[0] / scale[self._ar]
pitch = degrees(pi + atan2(-x, -z))
if (pitch >= 180) and (pitch <= 360):
pitch -= 360
return -pitch
def roll(self):
'''
Returns roll angle in degrees based on y and c accelerations.
'''
scale = (16384, 8192, 4096, 2048)
raw = self.get_accel_raw()
y = unp('>h', raw[2:4])[0] / scale[self._ar]
z = unp('>h', raw[4:6])[0] / scale[self._ar]
roll = degrees(pi + atan2(y, z)) - 180
return roll
def roll(self):
'''
Returns roll angle in degrees based on y and z accelerations.
'''
scale = (16384, 8192, 4096, 2048)
raw = self.get_accel_raw()
y = unp('>h', raw[2:4])[0]/scale[self._ar]
z = unp('>h', raw[4:6])[0]/scale[self._ar]
roll = degress(pi+atan2(-y,-z))
if (roll>=180) and (roll<=360):
roll-=360
return -roll
def pitch(self):
'''
Returns pitch angle in degrees based on x and z accelerations.
'''
scale = (16384, 8192, 4096, 2048)
raw = self.get_accel_raw()
x = unp('>h', raw[0:2])[0]/scale[self._ar]
z = unp('>h', raw[4:6])[0]/scale[self._ar]
pitch = degrees(pi+atan2(-x,-z))
if (pitch>=180) and (pitch<=360):
pitch-=360
return -pitch
def get_acc(self, xyz=None):
# Returns the accelerations on axis passed in arg. Pass xyz or every
# subset of this string. None defaults to xyz.
if xyz is None:
xyz = 'xyz'
scale = (16384, 8192, 4096, 2048)
raw = self.get_accel_raw()
axyz = {'x': unp('>h', raw[0:2])[0] / scale[self._ar],
'y': unp('>h', raw[2:4])[0] / scale[self._ar],
'z': unp('>h', raw[4:6])[0] / scale[self._ar]}
aout = []
for char in xyz:
aout.append(axyz[char])
return aout
def get_temperature(self):
self._bus.writeto(self._address, TRI_T_MEASURE_NO_HOLD)
sleep_ms(150)
origin_data = self._bus.readfrom(self._address, 2)
origin_value = unp('>h', origin_data)[0]
value = -46.85 + 175.72 * (origin_value / 65536)
return value
def get_relative_humidity(self):
self._bus.writeto(self._address, TRI_RH_MEASURE_NO_HOLD)
sleep_ms(150)
origin_data = self._bus.readfrom(self._address, 2)
origin_value = unp('>H', origin_data)[0]
value = -6 + 125 * (origin_value / 65536)
return value
def __init__(self, side_str=None, no_of_dev=None):
# choose wich i2c port to use
if side_str == 'X':
side = 1
elif side_str == 'Y':
side = 2
else:
print('pass either X or Y, defaulting to X')
side = 1
# choose wich sensor to use if two are connected
if no_of_dev is None:
print('pass either 1 or 2, defaulting to 1')
no_of_dev = 1
# create i2c object
self._mpu_i2c = pyb.I2C(side, pyb.I2C.MASTER)
self.mpu_addr = self._mpu_addr[no_of_dev-1]
self.mag_addr = self._mag_addr
self.chip_id = unp('>h', self._mpu_i2c.mem_read(1, self.mpu_addr, 0x75))[0]
self.timeout = 10
# wake it up
self.wake()
self.passthrough(False)
self.accel_range(3)
self._ar = self.accel_range()
self.gyro_range(3)
self._gr = self.gyro_range()
def get_SHT_temperature(self):
self._bus.writeto(self._address,TRI_T_MEASURE_NO_HOLD)
sleep_ms(150)
origin_data=self._bus.readfrom(self._address,2)
origin_value=unp('>h',origin_data)[0]
value=-46.85+175.72*(origin_value/65536)
return value
def get_SHT_relative_humidity(self):
self._bus.writeto(self._address,TRI_RH_MEASURE_NO_HOLD)
sleep_ms(150)
origin_data=self._bus.readfrom(self._address,2)
origin_value=unp('>H',origin_data)[0]
value=-6+125*(origin_value/65536)
return value
def get_gyro(self, xyz=None):
'''
Returns the turn rate on axis passed in arg in deg/s. Pass xyz or every
subset of this string. None defaults to xyz.
'''
if xyz is None:
xyz = 'xyz'
scale = (131, 65.5, 32.8, 16.4)
raw = self.get_gyro_raw()
gxyz = {'x': unp('>h', raw[0:2])[0]/scale[self._gr],
'y': unp('>h', raw[2:4])[0]/scale[self._gr],
'z': unp('>h', raw[4:6])[0]/scale[self._gr]}
gout = []
for char in xyz:
gout.append(gxyz[char])
return gout
def get_acc(self, xyz=None):
'''
Returns the accelerations on axis passed in arg. Pass xyz or every
subset of this string. None defaults to xyz.
'''
if xyz is None:
xyz = 'xyz'
scale = (16384, 8192, 4096, 2048)
raw = self.get_accel_raw()
axyz = {'x': unp('>h', raw[0:2])[0]/scale[self._ar],
'y': unp('>h', raw[2:4])[0]/scale[self._ar],
'z': unp('>h', raw[4:6])[0]/scale[self._ar]}
aout = []
for char in xyz:
aout.append(axyz[char])
return aout
def get_mag(self, xyz=None):
'''
Returns the compass data on axis passed in arg in uT. Pass xyz or every
subset of this string. None defaults to xyz.
'''
# TODO: Sensitivity Adjustment as described in page 59 of register map
if xyz is None:
xyz = 'xyz'
scale = 3.33198
raw = self.get_mag_raw()
mxyz = {'y': unp('<h', raw[0:2])[0]/scale,
'x': unp('<h', raw[2:4])[0]/scale,
'z': -unp('<h', raw[4:6])[0]/scale}
mout = []
for char in xyz:
mout.append(mxyz[char])
return mout
def get_SHT_relative_humidity(self):
self._bus.writeto(self._address, TRI_RH_MEASURE_NO_HOLD)
sleep_ms(150)
origin_data = self._bus.readfrom(self._address, 2)
origin_value = unp('>H', origin_data)[0]
value = -6 + 125 * (origin_value / 65536)
return value
#sht=SHT20(I2C(scl = Pin(22), sda = Pin(21), freq = 100000))
def get_SHT_relative_humidity(self):
self._bus.writeto(self._address, TRI_RH_MEASURE_NO_HOLD)
sleep_ms(150)
origin_data = self._bus.readfrom(self._address, 2)
origin_value = unp('>H', origin_data)[0]
value = -6 + 125 * (origin_value / 65536)
return value
#sht=SHT20(I2C(scl = Pin(22), sda = Pin(21), freq = 100000))
def parse_chunk(self):
i = 0
size = 14
self.header = HeaderChunk._make(unp('>4sLHHH', self.midi_data[:size]))
i += size
self.chunk_type = parse_chunk_type(self.header.chunk_type_b)
self.division_type, self.tpqn, self.fps = FileHeaderParser.get_division_info_(
self.header)
self.midi_format = MidiFormat(self.header.format)
def get_mag(self, xyz=None):
'''
Returns the compass data on axis passed in arg in uT. Pass xyz or every
subset of this string. None defaults to xyz.
'''
if xyz is None:
xyz = 'xyz'
scale = 3.33198
raw = self.get_mag_raw() # Note axis twiddling
mxyz = {
'y': unp('<h', raw[0:2])[0] * self.mag_correction[1] / scale,
'x': unp('<h', raw[2:4])[0] * self.mag_correction[0] / scale,
'z': -unp('<h', raw[4:6])[0] * self.mag_correction[2] / scale
}
mout = []
for char in xyz:
mout.append(mxyz[char])
return mout
def get_gyro(self, xyz=None):
'''
Returns the turn rate on axis passed in arg in deg/s. Pass xyz or every
subset of this string. None defaults to xyz.
'''
if xyz is None:
xyz = 'xyz'
scale = (131, 65.5, 32.8, 16.4)
raw = self.get_gyro_raw()
gxyz = {
'x': unp('>h', raw[0:2])[0] / scale[self._gr],
'y': unp('>h', raw[2:4])[0] / scale[self._gr],
'z': unp('>h', raw[4:6])[0] / scale[self._gr]
}
gout = []
for char in xyz:
gout.append(gxyz[char])
return gout
def sht20_temperature(i2c):
try:
i2c.writeto(SHT20_I2CADDR, TRI_T_MEASURE_NO_HOLD)
sleep_ms(150)
origin_data = i2c.readfrom(SHT20_I2CADDR, 2)
origin_value = unp('>h', origin_data)[0]
value = -46.85 + 175.72 * (origin_value / 65536)
except OSError as err:
print("sht20 temperature error: {0}".format(err))
return 0
return value
def sht20_relative_humidity(i2c):
try:
i2c.writeto(SHT20_I2CADDR, TRI_RH_MEASURE_NO_HOLD)
sleep_ms(150)
origin_data = i2c.readfrom(SHT20_I2CADDR, 2)
origin_value = unp('>H', origin_data)[0]
value = -6 + 125 * (origin_value / 65536)
except OSError as err:
print("sht20 humdity error: {0}".format(err))
return 0
return value
def get_gyro(self, xyz=None, use_radians=False):
'''
Returns the turn rate on axis passed in arg in deg/s or rad/s,
defaulting to degrees. Pass xyz or every
subset of this string. None defaults to xyz.
'''
if xyz is None:
xyz = 'xyz'
if use_radians:
scale = (7150, 3755, 1877.5, 938.75)
else:
scale = (131.0, 65.5, 32.8, 16.4)
raw = self.get_gyro_raw()
gxyz = {'x': unp('>h', raw[0:2])[0]/scale[self._gr],
'y': unp('>h', raw[2:4])[0]/scale[self._gr],
'z': unp('>h', raw[4:6])[0]/scale[self._gr]}
gout = []
for char in xyz:
gout.append(gxyz[char])
return gout
def temperature(self):
'''
Temperature in degree C.
'''
next(self.gauge)
try:
UT = unp('>h', self.UT_raw)[0]
except:
return 0.0
X1 = (UT - self._AC6) * self._AC5 / 2**15
X2 = self._MC * 2**11 / (X1 + self._MD)
self.B5_raw = X1 + X2
return (((X1 + X2) + 8) / 2**4) / 10
def temperature(self):
'''
Temperature in degree C.
'''
next(self.gauge)
try:
UT = unp('>h', self.UT_raw)[0]
except:
return 0.0
X1 = (UT-self._AC6)*self._AC5/2**15
X2 = self._MC*2**11/(X1+self._MD)
self.B5_raw = X1+X2
return (((X1+X2)+8)/2**4)/10
def get_pressure(self):
'''
Waits until the pressure measurement is finished, then returns the
pressure.
'''
self._get_B5()
if self._t_pressure_ready is None:
self.gauge_pressure()
while pyb.millis() <= self._t_pressure_ready:
pass
MSB = unp('<h', self._bmp_i2c.mem_read(1, self._bmp_addr, 0xF6))[0]
LSB = unp('<h', self._bmp_i2c.mem_read(1, self._bmp_addr, 0xF7))[0]
XLSB = unp('<h', self._bmp_i2c.mem_read(1, self._bmp_addr, 0xF8))[0]
UP = ((MSB << 16)+(LSB << 8)+XLSB) >> (8-self.oversample_sett)
B6 = self._B5-4000
X1 = (self._B2*(B6**2/2**12))/2**11
X2 = self._AC2*B6/2**11
X3 = X1+X2
B3 = ((int((self._AC1*4+X3)) << self.oversample_sett)+2)/4
X1 = self._AC3*B6/2**13
X2 = (self._B1*(B6**2/2**12))/2**16
X3 = ((X1+X2)+2)/2**2
B4 = abs(self._AC4)*(X3+32768)/2**15
B7 = (abs(UP)-B3) * (50000 >> self.oversample_sett)
if B7 < 0x80000000:
pressure = (B7*2)/B4
else:
pressure = (B7/B4)*2
X1 = (pressure/2**8)**2
X1 = (X1*3038)/2**16
X2 = (-7357*pressure)/2**16
self._t_pressure_ready = None
return pressure+(X1+X2+3791)/2**4
def parse_track_head(midi_data, track_h_start):
track_h_end = track_h_start + 8
track_h_bytes = midi_data[track_h_start:track_h_end]
track_h_parsed = unp('>4sL', track_h_bytes)
track_header = TrackHeader._make(track_h_parsed)
print('track header:', track_header)
#track data
track_start = track_h_end
track_end = track_start + track_header.len #track_end
tr_data = midi_data[track_start:track_end] #track body data
return track_header, tr_data
def parse_payload(self):
hp = deepcopy(self.hp)
header, pdu_type, data_len, packet_type = unp('!BBHB', hp[:5])
self.add_field('packet header', header, 's7 packet header', 1)
self.add_field('pdu type', pdu_type,
'PDU type: ' + S7_PDU_TYPE[int(pdu_type)], 1)
self.add_field('data len', data_len,
'data from next byte minus last 4 bytes', 2)
self.add_field('packet type', packet_type,
'packet type: ' + S7_PACKET_TYPE[int(packet_type)], 1)
hp = self.shift_hp_data_left(self.hp)
#hp = hp[5:] # FIX IT EVERY TIME AFTER PARSNG NEW FIELD
reserved1, function_code, reserved2 = unp('!HHH', hp[:6])
self.add_field('reserved', reserved1, 'reserved?', 2)
self.add_field(
'function code', function_code,
'function code: ' + S7_FUNCTION_CODE[int(function_code)], 2)
hp = self.shift_hp_data_left(self.hp)
self.add_field('reserved', reserved2, 'reserved?', 2)
hp = self.shift_hp_data_left(self.hp)
data_sequence_number, = unp('!H', hp[:2])
self.add_field('data seq numb', data_sequence_number,
'data sequnce number ?', 2)
hp = self.shift_hp_data_left(self.hp)
# process unknow data and packet footer
unparsed = unp('!%dB' % len(hp[:-4]), hp[:-4])
self.add_field('unparsed', unparsed, 'unparsed/unknown data',
len(unparsed))
footer = unp('!I', hp[-4:])[0]
self.add_field('packet footer', footer, 'packet footer with pdu type',
4)
def __init__(self, side_str=None, no_of_dev=None, disable_interrupts=None):
# choose which i2c port to use
if side_str == 'X':
side = 1
elif side_str == 'Y':
side = 2
else:
print('pass either X or Y, defaulting to X')
side = 1
# choose which sensor to use if two are connected
if no_of_dev is None:
print('pass either 1 or 2, defaulting to 1')
no_of_dev = 1
self.mag_ready = False # Magnetometer control: set by status check, read and cleared by get_mag_raw
self.timeout = 10
# create i2c object
self.disable_interrupts = False
self._mpu_i2c = pyb.I2C(side, pyb.I2C.MASTER)
self.mpu_addr = int(self._mpu_addr[no_of_dev - 1])
self.mag_addr = self._mag_addr
self.chip_id = int(unp('>h', self._read(1, 0x75, self.mpu_addr))[0])
# now apply user setting for interrupts
if disable_interrupts is True:
self.disable_interrupts = True
elif disable_interrupts is False:
self.disable_interrupts = False
else:
print('pass either True or False, defaulting to True')
self.disable_interrupts = True
# wake it up
self.wake()
self.passthrough(True) # Enable mag access from main I2C bus
self.mag_correction = (1.0, 1.0, 1.0)
try:
self.mag_correction = self._get_mag_corrections()
except OSError:
print(MPU9150._I2Cerror)
self.accel_range(3)
self._ar = self.accel_range()
self.gyro_range(3)
self._gr = self.gyro_range()
def __init__(self, side=1, disable_interrupts=False):
# create i2c object
self._timeout = 10
self.disable_interrupts = False
self._mpu_i2c = pyb.I2C(side, pyb.I2C.MASTER)
self.chip_id = int(unp('>h', self._read(1, 0x75, self.mpu_addr))[0])
# now apply user setting for interrupts
self.disable_interrupts = disable_interrupts
# wake it up
self.wake()
self.accel_range(1)
self._ar = self.accel_range()
self.gyro_range(0)
self._gr = self.gyro_range()
def get_temperature(self):
'''
Waits until the temperature measurement is finished, then returns the
temperature.
'''
if self._t_temperature_ready is None:
self.gauge_temperature()
while pyb.millis() <= self._t_temperature_ready:
pass
self._UT = unp('>h', self._bmp_i2c.mem_read(2, self._bmp_addr, 0xF6))[0]
X1 = (self._UT-self._AC6)*self._AC5/2**15
X2 = self._MC*2**11/(X1+self._MD)
self._t_temperature_ready = None
return (((X1+X2)+8)/2**4)/10
def sample_rate(self, rate=None):
'''
Returns the sample rate or sets it to the passed arg in Hz. Note that
not all sample rates are possible. Check the return value to see which
rate was actually set.
'''
gyro_rate = 8000 # Hz
# set rate
if rate is not None:
rate_div = int( gyro_rate/rate - 1 )
if rate_div > 255:
rate_div = 255
self._mpu_i2c.mem_write(rate_div, self.mpu_addr, 0x19)
# get rate
return gyro_rate/(unp('<H', self._mpu_i2c.mem_read(1, self.mpu_addr, 0x19))[0]+1)
def sample_rate(self, rate=None):
# Returns the sample rate or sets it to the passed arg in Hz. Note that
# not all sample rates are possible. Check the return value to see which
# rate was actually set.
gyro_rate = 8000 # Hz
# set rate
try:
if rate is not None:
rate_div = int(gyro_rate / rate - 1)
if rate_div > 255:
rate_div = 255
self._write(rate_div, 0x19, self.mpu_addr)
# get rate
rate = gyro_rate / (unp('<H', self._read(1, 0x19, self.mpu_addr))[0] + 1)
except OSError:
rate = None
return rate
def accel_range(self, accel_range=None):
# Returns the accelerometer range or sets it to the passed arg.
# Pass: 0 1 2 3
# for range +/-: 2 4 8 16 g
# set range
try:
if accel_range is None:
pass
else:
ar = (0x00, 0x08, 0x10, 0x18)
try:
self._write(ar[accel_range], 0x1C, self.mpu_addr)
except IndexError:
print('accel_range can only be 0, 1, 2 or 3')
# get range
ari = int(unp('<H', self._read(1, 0x1C, self.mpu_addr))[0] / 8)
except OSError:
ari = None
if ari is not None:
self._ar = ari
return ari
def gyro_range(self, gyro_range=None):
# Returns the gyroscope range or sets it to the passed arg.
# Pass: 0 1 2 3
# for range +/-: 250 500 1000 2000 degrees/second
# set range
try:
if gyro_range is None:
pass
else:
gr = (0x00, 0x08, 0x10, 0x18)
try:
self._write(gr[gyro_range], 0x1B, self.mpu_addr)
except IndexError:
print('gyro_range can only be 0, 1, 2 or 3')
# get range
gri = int(unp('<H', self._read(1, 0x1B, self.mpu_addr))[0] / 8)
except OSError:
gri = None
if gri is not None:
self._gr = gri
return gri
def sample_rate(self, rate=None):
"""
Returns the sample rate or sets it to the passed arg in Hz. Note that
not all sample rates are possible. Check the return value to see which
rate was actually set.
"""
gyro_rate = 8000 # Hz
# set rate
try:
if rate is not None:
rate_div = int(gyro_rate / rate - 1)
if rate_div > 255:
rate_div = 255
self._write(rate_div, 0x19, self.mpu_addr)
# get rate
rate = gyro_rate / (
unp('<H', self._read(1, 0x19, self.mpu_addr))[0] + 1)
except OSError:
rate = None
return rate
def accel_range(self, accel_range=None):
'''
Returns the accelerometer range or sets it to the passed arg.
Pass: 0 1 2 3
for range +/-: 2 4 8 16 g
'''
# set range
try:
if accel_range is None:
pass
else:
ar = (0x00, 0x08, 0x10, 0x18)
try:
self._write(ar[accel_range], 0x1C, self.mpu_addr)
except IndexError:
print('accel_range can only be 0, 1, 2 or 3')
# get range
ari = int(unp('<H', self._read(1, 0x1C, self.mpu_addr))[0]/8)
except OSError:
ari = None
if ari is not None:
self._ar = ari
return ari
def gyro_range(self, gyro_range=None):
'''
Returns the gyroscope range or sets it to the passed arg.
Pass: 0 1 2 3
for range +/-: 250 500 1000 2000 degrees/second
'''
# set range
try:
if gyro_range is None:
pass
else:
gr = (0x00, 0x08, 0x10, 0x18)
try:
self._write(gr[gyro_range], 0x1B, self.mpu_addr)
except IndexError:
print('gyro_range can only be 0, 1, 2 or 3')
# get range
gri = int(unp('<H', self._read(1, 0x1B, self.mpu_addr))[0]/8)
except OSError:
gri = None
if gri is not None:
self._gr = gri
return gri
def get_gz(self):
scale = (131.0, 65.5, 32.8, 16.4)
raw = self.get_gyro_raw()
gz = unp('>h', raw[4:6])[0] / scale[self._gr]
return gz
def is_s7(self):
return 0x72 == unp("!B", self.hp[:1])[0]
def __init__(self, side_str=None):
# choose which i2c port to use
if side_str == 'X':
side = 1
elif side_str == 'Y':
side = 2
else:
print('pass either X or Y, defaulting to Y')
side = 2
output=''
# create i2c obect
_bmp_addr = self._bmp_addr
self._bmp_i2c = pyb.I2C(side, pyb.I2C.MASTER)
self.chip_id = self._bmp_i2c.mem_read(2, _bmp_addr, 0xD0)
# read calibration data from EEPROM
self._AC1 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xAA))[0]
self._AC2 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xAC))[0]
self._AC3 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xAE))[0]
self._AC4 = unp('>H', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB0))[0]
self._AC5 = unp('>H', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB2))[0]
self._AC6 = unp('>H', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB4))[0]
self._B1 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB6))[0]
self._B2 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB8))[0]
self._MB = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xBA))[0]
self._MC = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xBC))[0]
self._MD = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xBE))[0]
# settings to be adjusted by user
self.oversample_setting = 3
self.baseline = 101325.0
# output raw
self.UT_raw = None
self.B5_raw = None
self.MSB_raw = None
self.LSB_raw = None
self.XLSB_raw = None
self.gauge = self.makegauge() # Generator instance
for _ in range(128):
next(self.gauge)
pyb.delay(1)
def unp_3b(x):
b1, b2, b3 = unp('>BBB', x)
return b1 << 16 | b2 << 8 | b3
def get_acc_values(self):
xa = unp('>h', self.mpu_i2c.mem_read(2, self._addr, MPU6050_RA_ACCEL_XOUT_H))[0] #get the accelerometer x values
ya = unp('>h', self.mpu_i2c.mem_read(2, self._addr, MPU6050_RA_ACCEL_YOUT_H))[0] #get the accelerometer y values
za = unp('>h', self.mpu_i2c.mem_read(2, self._addr, MPU6050_RA_ACCEL_ZOUT_H))[0] #get the accelerometer z values
return (xa, ya, za)
def get_gyro_values(self):
xg = unp('>h', self.mpu_i2c.mem_read(2, self._addr, MPU6050_RA_GYRO_XOUT_H))[0] #get the gyroscope x values
yg = unp('>h', self.mpu_i2c.mem_read(2, self._addr, MPU6050_RA_GYRO_YOUT_H))[0] #get the gyroscope y values
zg = unp('>h', self.mpu_i2c.mem_read(2, self._addr, MPU6050_RA_GYRO_ZOUT_H))[0] #get the gyroscope z values
return (xg, yg, zg)
def get_gy(self):
scale = (131.0, 65.5, 32.8, 16.4)
raw = self.get_gyro_raw()
gy = unp('>h', raw[2:4])[0]/scale[self._gr]
return gy
def is_s7(self):
return 0x72 == unp('!B', self.hp[:1])[0]
#!/usr/bin/env python2
# coding: utf-8
from struct import unpack as unp
import sys
for fname in sys.argv[1:]:
with open(fname, "rb") as f:
print "HEADER: " + fname
print unp("@3s", f.read(3))
print "version: "+str(unp("@c", f.read(1)))
print "header flage: "+str(unp("@c", f.read(1))) # 5
print "header size: "+str(unp(">I", f.read(4)))
print "??: "+str(unp(">i", f.read(4)))
print "metadata tag type: "+str(unp("@c", f.read(1))) # 14
# wait, what? big endian and padding at the beginning??
print "size of data-part: "+str(unp(">i", "\x00"+f.read(3)))
print "time stamp: "+str(unp(">i", f.read(3)+"\x00")) # why zero?
print "reserved: "+str(unp(">i", f.read(4)))
# we expect an AMF string:
print "AMF type: "+str(unp("c", f.read(1)))
length = unp(">H", f.read(2))[0]
print "AMF String: %s of length %s" % ((unp(">%ss" % length, f.read(length))), length)
#mixed array (hash) with size and string/type/data tuples
print "AMF type: "+str(unp("c", f.read(1)))
print "metadataCount: "+str(unp(">i", f.read(4)))
length = unp(">H", f.read(2))[0]
print "AMF String: %s of length %s" % ((unp(">%ss" % length, f.read(length))), length)
def is_s7(self):
return 0x72 == unp('!B', self.hp[:1])[0]
def __init__(self, side_str=None):
# choose which i2c port to use
if side_str == 'X':
side = 1
elif side_str == 'Y':
side = 2
else:
print('pass either X or Y, defaulting to Y')
side = 2
# create i2c obect
_bmp_addr = self._bmp_addr
self._bmp_i2c = pyb.I2C(side, pyb.I2C.MASTER)
self.chip_id = self._bmp_i2c.mem_read(2, _bmp_addr, 0xD0)
# read calibration data from EEPROM
self._AC1 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xAA))[0]
self._AC2 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xAC))[0]
self._AC3 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xAE))[0]
self._AC4 = unp('>H', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB0))[0]
self._AC5 = unp('>H', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB2))[0]
self._AC6 = unp('>H', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB4))[0]
self._B1 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB6))[0]
self._B2 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB8))[0]
self._MB = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xBA))[0]
self._MC = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xBC))[0]
self._MD = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xBE))[0]
# settings to be adjusted by user
self.oversample_sett = 0
self.temp_comp_sample_rate = 1
self.baseline = 101325
# priate attributes not to be used by user
self._t_temperature_ready = None
self._UT = None
self._t_pressure_ready = None
self._B5 = None
self._t_B5 = None
self._dt_B5 = 1000/self.temp_comp_sample_rate
self._UT = None
def get_temperature(self):
'''
Returns the temperature in degree C.
'''
return unp('>h', self.get_temperature_raw())[0] / 340 + 35
def __init__(self,
scl=Pin(5),
sda=Pin(4),
freq=100000,
baseline=101325.0,
oversample=3):
# create i2c obect
_bmp_addr = self._bmp_addr
self._bmp_i2c = machine.I2C(scl=scl, sda=sda, freq=freq)
self.chip_id = self._bmp_i2c.readfrom_mem(_bmp_addr, 0xD0, 2)
# read calibration data from EEPROM
self._AC1 = unp('>h', self._bmp_i2c.readfrom_mem(_bmp_addr, 0xAA,
2))[0]
self._AC2 = unp('>h', self._bmp_i2c.readfrom_mem(_bmp_addr, 0xAC,
2))[0]
self._AC3 = unp('>h', self._bmp_i2c.readfrom_mem(_bmp_addr, 0xAE,
2))[0]
self._AC4 = unp('>H', self._bmp_i2c.readfrom_mem(_bmp_addr, 0xB0,
2))[0]
self._AC5 = unp('>H', self._bmp_i2c.readfrom_mem(_bmp_addr, 0xB2,
2))[0]
self._AC6 = unp('>H', self._bmp_i2c.readfrom_mem(_bmp_addr, 0xB4,
2))[0]
self._B1 = unp('>h', self._bmp_i2c.readfrom_mem(_bmp_addr, 0xB6, 2))[0]
self._B2 = unp('>h', self._bmp_i2c.readfrom_mem(_bmp_addr, 0xB8, 2))[0]
self._MB = unp('>h', self._bmp_i2c.readfrom_mem(_bmp_addr, 0xBA, 2))[0]
self._MC = unp('>h', self._bmp_i2c.readfrom_mem(_bmp_addr, 0xBC, 2))[0]
self._MD = unp('>h', self._bmp_i2c.readfrom_mem(_bmp_addr, 0xBE, 2))[0]
# settings to be adjusted by user
self.oversample_setting = oversample
self.baseline = baseline
# output raw
self.UT_raw = None
self.B5_raw = None
self.MSB_raw = None
self.LSB_raw = None
self.XLSB_raw = None
self.gauge = self.makegauge() # Generator instance
for _ in range(128):
next(self.gauge)
time.sleep_ms(1)
def __init__(self, side_str=None):
# choose which i2c port to use
if side_str == 'X':
side = 1
elif side_str == 'Y':
side = 2
else:
print('pass either X or Y, defaulting to Y')
side = 2
# create i2c obect
_bmp_addr = self._bmp_addr
self._bmp_i2c = pyb.I2C(side, pyb.I2C.MASTER)
self.chip_id = self._bmp_i2c.mem_read(2, _bmp_addr, 0xD0)
# read calibration data from EEPROM
self._AC1 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xAA))[0]
self._AC2 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xAC))[0]
self._AC3 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xAE))[0]
self._AC4 = unp('>H', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB0))[0]
self._AC5 = unp('>H', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB2))[0]
self._AC6 = unp('>H', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB4))[0]
self._B1 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB6))[0]
self._B2 = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xB8))[0]
self._MB = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xBA))[0]
self._MC = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xBC))[0]
self._MD = unp('>h', self._bmp_i2c.mem_read(2, _bmp_addr, 0xBE))[0]
# settings to be adjusted by user
self.oversample_setting = 3
self.baseline = 101325.0
# output raw
self.UT_raw = None
self.B5_raw = None
self.MSB_raw = None
self.LSB_raw = None
self.XLSB_raw = None
self.gauge = self.makegauge() # Generator instance
for _ in range(128):
next(self.gauge)
pyb.delay(1)
# main.py -- put your code here!
import pyb
from pyb import I2C
from struct import unpack as unp
light = pyb.LED(4)
switch = pyb.Switch()
while True:
if switch():
pyb.delay(200)
light.on()
log = open('0:/log.csv', 'w')
i2c = I2C(2, I2C.MASTER)
i2c.mem_write(0, 0x68, 0x6B)
while not switch():
x = unp('>h', i2c.mem_read(2, 0x68, 0x3B))[0]
y = unp('>h', i2c.mem_read(2, 0x68, 0x3D))[0]
z = unp('>h', i2c.mem_read(2, 0x68, 0x3F))[0]
log.write('{},{},{}\n'.format(x,y,z))
log.close()
light.off()
pyb.delay(200)
