def get_sensors(precision):
"""
get temp, pressure, humidity from the Sense HAT
:param precision: Decimal point round precision, e.g. with 3 the results will be 24.054. Default 2
:return: returns a data dictionary
"""
sense = SenseHat()
data = {}
data['temperature'] = round(sense.get_temperature(), precision)
data['pressure'] = round(sense.get_pressure(), precision)
data['humidity'] = round(sense.get_humidity(), precision)
data['temperature_h'] = round(sense.get_temperature_from_humidity(),
precision)
data['temperature_p'] = round(sense.get_temperature_from_pressure(),
precision)
magnetometer_raw = sense.get_compass_raw()
data['magnetometer_x'] = magnetometer_raw['x']
data['magnetometer_y'] = magnetometer_raw['y']
data['magnetometer_z'] = magnetometer_raw['z']
gyroscope_raw = sense.get_gyroscope_raw()
data['gyroscope_x'] = gyroscope_raw['x']
data['gyroscope_y'] = gyroscope_raw['y']
data['gyroscope_z'] = gyroscope_raw['z']
accelerometer_raw = sense.get_accelerometer_raw()
data['accelerometer_x'] = accelerometer_raw['x']
data['accelerometer_y'] = accelerometer_raw['y']
data['accelerometer_z'] = accelerometer_raw['z']
return data
class SenseHAT(Block, EnrichSignals):
imu = ObjectProperty(IMUsensor, title='IMU Sensor')
version = VersionProperty('0.1.0')
def __init__(self):
super().__init__()
self.hat = None
def configure(self, context):
super().configure(context)
self.hat = SenseHat()
self.hat.set_imu_config(
self.imu().accel(),
self.imu().compass(),
self.imu().gyro())
def process_signals(self, signals):
data = {}
if self.imu().accel():
data['accelerometer'] = self.hat.get_accelerometer_raw()
if self.imu().compass():
data['compass'] = self.hat.get_compass_raw()
if self.imu().gyro():
data['gyroscope'] = self.hat.get_gyroscope_raw()
outgoing_signals = []
for signal in signals:
outgoing_signals.append(self.get_output_signal(data, signal))
self.notify_signals(outgoing_signals)
def SenseHatData(conf, dataobj):
sense = SenseHat()
sense.clear()
zero_pressure = sense.get_pressure()
while not conf.shutdown:
# Adjust ground pressure in case of anomaly
if conf.state == "HALT":
zero_pressure = zero_pressure * .9 + sense.get_pressure() * .1
# Altimeter
data = dataobj.current_data
current_pressure = sense.get_pressure()
data["sensors"]["alt"] = get_altitude(
zero_pressure, sense.get_pressure(),
sense.get_temperature()) # meters
data["sensors"]["hum"] = sense.get_humidity() # %
data["sensors"]["temp"] = (sense.get_temperature() * 9 / 5) + 32 # F
data["sensors"]["pres"] = current_pressure
conf.data.add_dp(current_pressure - conf.data.last_pressure)
conf.data.last_pressure = current_pressure
# IMU
data["sensors"]["acc"] = sense.get_accelerometer_raw() # Gs
data["sensors"]["pitch"] = sense.get_accelerometer()[
"pitch"] # degrees
data["sensors"]["yaw"] = sense.get_accelerometer()["yaw"] # degrees
data["sensors"]["roll"] = sense.get_accelerometer()["roll"] # degrees
data["sensors"]["compass"] = sense.get_compass() # rad/sec
data["sensors"]["gyro"] = sense.get_gyroscope_raw() # rad/sec
data["sensors"]["mag"] = sense.get_compass_raw() # microteslas
def main():
sense = SenseHat()
sense.set_imu_config(True, True, True)
gyro = sense.get_gyroscope_raw()
acc = sense.get_accelerometer_raw()
comp = sense.get_compass_raw()
temp = sense.temp
humidity = sense.humidity
pressure = sense.pressure
data = [{
"id": "gyro",
"values": [gyro['x'], gyro['y'], gyro['z']]
}, {
"id": "acc",
"values": [acc['x'], acc['y'], acc['z']]
}, {
"id": "comp",
"values": [comp['x'], comp['y'], comp['z']]
}, {
"id": "temp",
"values": [temp]
}, {
"id": "humidity",
"values": [humidity]
}, {
"id": "pressure",
"values": [pressure]
}]
print(json.dumps(data))
class SenseLogger:
def __init__(self):
self.sense = SenseHat()
self.filename = "./logs/Senselogg-" + str(datetime.now()) + ".csv"
self.file_setup(self.filename)
def write_line(self, line):
with open(self.filename, "a") as f:
f.write(line + "\n")
def log_data(self):
sense_data = self.get_sense_data()
line = ",".join(str(value) for value in sense_data)
self.write_line(line)
def file_setup(self, filename):
header = [
"datetime", "temp_h", "temp_p", "humidity", "pressure", "pitch",
"roll", "yaw", "mag_x", "mag_y", "mag_z", "accel_x", "accel_y",
"accel_z", "gyro_x", "gyro_y", "gyro_z"
]
with open(filename, "w") as f:
f.write(",".join(str(value) for value in header) + "\n")
def get_sense_data(self):
sense_data = []
sense_data.append(datetime.now())
sense_data.append(self.sense.get_temperature_from_humidity())
sense_data.append(self.sense.get_temperature_from_pressure())
sense_data.append(self.sense.get_humidity())
sense_data.append(self.sense.get_pressure())
o = self.sense.get_orientation()
yaw = o["yaw"]
pitch = o["pitch"]
roll = o["roll"]
sense_data.extend([pitch, roll, yaw])
mag = self.sense.get_compass_raw()
x = mag["x"]
y = mag["y"]
z = mag["z"]
sense_data.extend([x, y, z])
acc = self.sense.get_accelerometer_raw()
x = acc["x"]
y = acc["y"]
z = acc["z"]
sense_data.extend([x, y, z])
gyro = self.sense.get_gyroscope_raw()
x = gyro["x"]
y = gyro["y"]
z = gyro["z"]
sense_data.extend([x, y, z])
return sense_data
class SensePublisher:
def __init__(self):
self.sense = SenseHat()
self.sense.clear()
self.pub_humidity = rospy.Publisher('sensehat/humidity',
Float64,
queue_size=10)
self.pub_temperature = rospy.Publisher('sensehat/temperature',
Float64,
queue_size=10)
self.pub_pressure = rospy.Publisher('sensehat/pressure',
Float64,
queue_size=10)
self.pub_accelerometer = rospy.Publisher('sensehat/accelerometer',
Vector3,
queue_size=10)
self.pub_gyroscope = rospy.Publisher('sensehat/gyroscope',
Vector3,
queue_size=10)
self.pub_magnetometer = rospy.Publisher('sensehat/magnetometer',
Vector3,
queue_size=10)
self.pub_compass = rospy.Publisher('sensehat/compass',
Float64,
queue_size=10)
self.pub_stick = rospy.Publisher('sensehat/stick',
SenseInputEvent,
queue_size=10)
def publish(self):
self.pub_humidity.publish(self.sense.get_humidity())
self.pub_temperature.publish(self.sense.get_temperature())
self.pub_pressure.publish(self.sense.get_pressure())
acceleration = self.sense.get_accelerometer_raw()
self.pub_accelerometer.publish(
Vector3(acceleration['x'], acceleration['y'], acceleration['z']))
gyroscope = self.sense.get_gyroscope_raw()
self.pub_gyroscope.publish(
Vector3(gyroscope['x'], gyroscope['y'], gyroscope['z']))
compass = self.sense.get_compass_raw()
self.pub_magnetometer.publish(
Vector3(compass['x'], compass['y'], compass['z']))
self.pub_compass.publish(self.sense.get_compass())
stickEvents = self.sense.stick.get_events()
if len(stickEvents) > 0:
event = SenseInputEvent(stickEvents[-1].direction,
stickEvents[-1].action)
self.pub_stick.publish(event)
def turn_off(self):
self.sense.clear()
def run(self):
rospy.init_node('sense_hat', anonymous=True)
rate = rospy.Rate(10) # 10hz
while not rospy.is_shutdown():
self.publish()
rate.sleep()
class SenseLogger:
def __init__(self):
self.sense = SenseHat()
self.filename = "./logs/Senselogg-"+str(datetime.now())+".csv"
self.file_setup(self.filename)
def write_line(self, line):
with open(self.filename, "a") as f:
f.write(line + "\n")
def log_data(self):
sense_data = self.get_sense_data()
line = ",".join(str(value) for value in sense_data)
self.write_line(line)
def file_setup(self, filename):
header = ["datetime", "temp_h", "temp_p", "humidity", "pressure", "pitch",
"roll", "yaw", "mag_x", "mag_y", "mag_z",
"accel_x", "accel_y", "accel_z",
"gyro_x", "gyro_y", "gyro_z"]
with open(filename, "w") as f:
f.write(",".join(str(value) for value in header)+ "\n")
def get_sense_data(self):
sense_data = []
sense_data.append(datetime.now())
sense_data.append(self.sense.get_temperature_from_humidity())
sense_data.append(self.sense.get_temperature_from_pressure())
sense_data.append(self.sense.get_humidity())
sense_data.append(self.sense.get_pressure())
o = self.sense.get_orientation()
yaw = o["yaw"]
pitch = o["pitch"]
roll = o["roll"]
sense_data.extend([pitch, roll, yaw])
mag = self.sense.get_compass_raw()
x = mag["x"]
y = mag["y"]
z = mag["z"]
sense_data.extend([x, y, z])
acc = self.sense.get_accelerometer_raw()
x = acc["x"]
y = acc["y"]
z = acc["z"]
sense_data.extend([x, y, z])
gyro = self.sense.get_gyroscope_raw()
x = gyro["x"]
y = gyro["y"]
z = gyro["z"]
sense_data.extend([x, y, z])
return sense_data
class IMU:
def __init__(self):
self.sense = SenseHat()
self.sense.clear()
self.zero_pressure = self.sense.get_pressure()
def get_accelerometer():
return self.sense.get_accelerometer()
def get_compass():
return self.sense.get_compass()
def get_accerometer_raw():
return self.sense.get_accelerometer_raw()
def get_gyroscope_raw():
return self.sense.get_gyroscope_raw()
def get_compass_raw():
return self.sense.get_compass_raw()
class SenseHAT(Block, EnrichSignals):
env = ObjectProperty(EnvironmentalSensors,
title='Environmental Sensors',
order=0)
imu = ObjectProperty(IMUsensor, title='IMU Sensor', order=1)
version = VersionProperty('0.1.0')
def __init__(self):
super().__init__()
self.hat = None
def configure(self, context):
super().configure(context)
self.hat = SenseHat()
self.hat.set_imu_config(self.imu().accel(),
self.imu().compass(),
self.imu().gyro())
def process_signals(self, signals):
data = {}
if self.imu().accel():
data['accelerometer'] = self.hat.get_accelerometer_raw()
if self.imu().compass():
data['compass'] = self.hat.get_compass_raw()
if self.imu().gyro():
data['gyroscope'] = self.hat.get_gyroscope_raw()
if self.env().rh():
data['relative_humidity'] = self.hat.get_humidity()
if self.env().temp():
data['temperature_C'] = self.hat.get_temperature()
if self.env().press():
data['pressure_mbar'] = self.hat.get_pressure()
outgoing_signals = []
for signal in signals:
outgoing_signals.append(self.get_output_signal(data, signal))
self.notify_signals(outgoing_signals)
class SenseClient(object):
def __init__(self):
self.sense = SenseHat()
self.sense.clear()
self.sense.set_imu_config(True, True, True)
def getSensePoints(self, imperial_or_metric, bucket):
dt = datetime.now(tz=pytz.timezone('US/Pacific')).isoformat()
point = Point(measurement_name="sense")
point.time(time=dt)
# % relative
point.field("humidity", self.sense.get_humidity())
if imperial_or_metric == "imperial":
point.field(
"temperature_from_humidity",
convertCToF(self.sense.get_temperature_from_humidity()))
point.field(
"temperature_from_pressure",
convertCToF(self.sense.get_temperature_from_pressure()))
point.field("pressure", convertmbToPSI(self.sense.get_pressure()))
else:
point.field("temperature_from_humidity",
self.sense.get_temperature_from_humidity())
point.field("temperature_from_pressure",
self.sense.get_temperature_from_pressure())
point.field("pressure", self.sense.get_pressure())
point.field("orientation_radians",
self.sense.get_orientation_radians())
point.field("orientation_degress",
self.sense.get_orientation_degrees())
# magnetic intensity in microteslas
point.field("compass_raw", self.sense.get_compass_raw())
# rotational intensity in radians per second
point.field("gyroscope_raw", self.sense.get_gyroscope_raw())
# acceleration intensity in Gs
point.field("accelerometer_raw", self.sense.get_accelerometer_raw())
return [{"bucket": bucket, "point": point}]
def get_sense_data():
sense = SenseHat()
# Define list
sense_data = []
# Append sensor data
sense_data.append(sense.get_temperature_from_humidity())
sense_data.append(sense.get_temperature_from_pressure())
sense_data.append(sense.get_pressure())
sense_data.append(sense.get_humidity())
# Get orientation from sensor
yaw,pitch,roll = sense.get_orientation().values()
sense_data.extend([pitch,roll,yaw])
# Get magnetic field (compass)
mag_x,mag_y,mag_z = sense.get_compass_raw().values()
sense_data.extend([mag_x,mag_y,mag_z])
# Get accelerometer values
x,y,z = sense.get_accelerometer_raw().values()
sense_data.extend([x,y,z])
# Get Gyro values
gyro_x,gyro_y,gyro_z = sense.get_gyroscope_raw().values()
sense_data.extend([gyro_x,gyro_y,gyro_z])
# Add capture time
sense_data.append(datetime.now())
# Add precise time
sense_data.append(int(round(time.time()*1000)))
return sense_data
pwm.start(0)
drive1 = 0
drive2 = 0
motorPwm = 0
# GPIO.output(11, False) # Stop motor
# GPIO.output(12, False)
# pwm=GPIO.PWM(7, 100)
# pwm.start(0)
pwm.ChangeDutyCycle(100)
GPIO.output(7, True)
print("Running")
# for i in range(1,101):
for i in range(1,11):
gyroRaw = sense.get_gyroscope_raw()
accelRaw = sense.get_accelerometer_raw()
magRaw = sense.get_compass_raw()
temp = sense.get_temperature()
# drive_motor(100)
print("Stopping")
GPIO.output(12, False)
GPIO.output(11, False)
####
# Main game loop
####
prevUpdateTime = time.time() - startTime
sense.clear()
while True:
elapsedTime = time.time() - startTime
#!/usr/bin/python3 -u
import time
import quaternion
from madgwick import MadgwickAHRS
from sense_hat import SenseHat
heading = MadgwickAHRS()
sense = SenseHat()
while True:
gyro = [value for key, value in sense.get_gyroscope_raw().items()]
accel = [value for key, value in sense.get_accelerometer_raw().items()]
compass = [value for key, value in sense.get_compass_raw().items()]
heading.update(gyro, accel, compass)
ahrs = heading.quaternion.to_euler_angles()
roll = ahrs[0]
pitch = ahrs[1]
yaw = ahrs[2]
#(p,r,y) = heading.quaternion.to_euler_angles()
print(pitch, roll, yaw)
time.sleep(0.1)
SH_orientation_z = SH_orientation.get('z')
# Magnetometer data
#sense.set_imu_config(True,False,False)
time.sleep(0.01) # sleep for 10 ms after changing IMU configuration
SH_compass_north = sense.get_compass() # direction of magnetometer from North, in degrees
SH_compass_raw = sense.get_compass_raw() # magnetic intensity of x, y, z axes in microteslas
SH_compass_raw_x = SH_compass_raw.get('x')
SH_compass_raw_y = SH_compass_raw.get('y')
SH_compass_raw_z = SH_compass_raw.get('z')
# Gyro Data
#sense.set_imu_config(False,True,False)
time.sleep(0.01) # sleep for 10 ms after changing IMU configuration
#SH_gyro = sense.get_gyroscope() # orientation of pitch, roll, yaw axes in degrees
SH_gyro_raw = sense.get_gyroscope_raw() # rotational velocity of pitch, roll, yaw axes in radians per sec
SH_gyro_raw_x = SH_gyro_raw.get('x')
SH_gyro_raw_y = SH_gyro_raw.get('y')
SH_gyro_raw_z = SH_gyro_raw.get('z')
# Accelerometer data
#sense.set_imu_config(False,False,True)
time.sleep(0.01) # sleep for 10 ms after changing IMU configuration
#SH_accel = sense.get_accelerometer() # orientation of pitch, roll, yaw axes in degrees
SH_accel_raw = sense.get_accelerometer_raw() # acceleration intensity of pitch, roll, yaw axes in 'G's
SH_accel_raw_x = SH_accel_raw.get('x')
SH_accel_raw_y = SH_accel_raw.get('y')
SH_accel_raw_z = SH_accel_raw.get('z')
## Readings from the BMP180 installed in the sealed box
BMP_pressure = BMP_sensor.read_pressure() # value in Pascals
#gyro and accel
file = raw_input('Enter file name: ')
file = "./MotionCaptures/" + file + ".csv"
f = open(file, "w")
# Progress indicator
sense.set_pixel(0, 0, 0, 255, 0)
#green light to indicate ready
flag = True
while flag:
# take data measurements
accel = sense.get_accelerometer_raw()
orient = sense.get_gyroscope_raw()
# access variables
x = accel['x']
y = accel['y']
z = accel['z']
p = orient['x']
r = orient['y']
y = orient['z']
# write to CSV
f.write("{0},{1},{2},{3},{4},{5}\n".format(x, y, z, p, r, y))
#check for joystick event to stop gathering data
for event in sense.stick.get_events():
if event.action == ACTION_PRESSED:
#get pitch, roll and yaw orientation from gyro
o = sense.get_orientation()
gyro_pitch = o['pitch']
gyro_roll = o['roll']
gyro_yaw = o['yaw']
#get acceleration
acc_x, acc_y, acc_z = sense.get_accelerometer_raw().values()
acc_roll, acc_pitch, acc_yaw = sense.get_accelerometer().values()
#get magnetometer values
mag_x, mag_y, mag_z = sense.get_compass_raw().values()
compass = sense.get_compass()
#get gyro velocity
gyro_vel = sense.get_gyroscope_raw()
gyro_vel_x = gyro_vel['x']
gyro_vel_y = gyro_vel['y']
gyro_vel_z = gyro_vel['z']
#get humidity
humidity = sense.get_humidity()
#get temperature
temperature = sense.get_temperature()
#get pressure
pressure = sense.get_pressure()
if (datetime.now() > last_catch + timedelta(seconds=12)):
add_csv_data(
async def handle(self, context: RequestContext, responder: BaseResponder):
"""
Message handler logic for basic messages.
Args:
context: request context
responder: responder callback
"""
self._logger.debug(f"ReadSensorHandler called with context {context}")
assert isinstance(context.message, ReadSensor)
self._logger.info("Received read sensor: %s", context.message.sensors)
sensors = context.message.sensors
meta = {"sensors": sensors}
conn_mgr = ConnectionManager(context)
await conn_mgr.log_activity(
context.connection_record,
"read_sensor",
context.connection_record.DIRECTION_RECEIVED,
meta,
)
await responder.send_webhook(
"read_sensor",
{
"message_id": context.message._id,
"sensors": sensors,
"state": "received"
},
)
sense = SenseHat()
temperature = None
humidity = None
pressure = None
orientation = None
accelerometer = None
compass = None
gyroscope = None
stick_events = None
pixels = None
if "temperature" in sensors:
temperature = sense.get_temperature()
if "humidity" in sensors:
humidity = sense.get_humidity()
if "pressure" in sensors:
pressure = sense.get_pressure()
if "orientation" in sensors:
orientation = sense.get_orientation_degrees()
if "accelerometer" in sensors:
accelerometer = sense.get_accelerometer_raw()
if "compass" in sensors:
compass = sense.get_compass_raw()
if "gyroscope" in sensors:
gyroscope = sense.get_gyroscope_raw()
if "stick_events" in sensors:
stick_events = []
stick_event_objects = sense.stick.get_events()
for event in stick_event_objects:
event_dict = {}
event_dict['timestamp'] = event.timestamp
event_dict['direction'] = event.direction
event_dict['action'] = event.action
stick_events.append(event_dict)
if "pixels" in sensors:
pixels = sense.get_pixels()
reply_msg = SensorValue(temperature=temperature,
humidity=humidity,
pressure=pressure,
orientation=orientation,
accelerometer=accelerometer,
compass=compass,
gyroscope=gyroscope,
stick_events=stick_events,
pixels=pixels)
await responder.send_reply(reply_msg)
await conn_mgr.log_activity(
context.connection_record,
"sensor_value",
context.connection_record.DIRECTION_SENT,
{"content": "reply"},
)
print( sensehat.gamma )
print( "Humidity : %.4f %%rH" % sensehat.get_humidity( ) )
print( "Temp main: %.4f C" % sensehat.get_temperature( ) )
print( "Temp humd: %.4f C" % sensehat.get_temperature_from_humidity( ) )
print( "Temp prss: %.4f C" % sensehat.get_temperature_from_pressure( ) )
print( "Pressure : %.4f mb" % sensehat.get_pressure( ) ) # millibar
sensehat.set_imu_config( True , True , True )
print( "p: {pitch} , r: {roll} , y: {yaw}".format( **sensehat.get_orientation_radians( ) ) )
print( "p: {pitch} , r: {roll} , y: {yaw}".format( **sensehat.get_orientation_degrees( ) ) )
print( "p: {pitch} , r: {roll} , y: {yaw}".format( **sensehat.get_orientation( ) ) )
print( "p: {pitch} , r: {roll} , y: {yaw}".format( **sensehat.get_gyroscope( ) ) )
print( "p: {pitch} , r: {roll} , y: {yaw}".format( **sensehat.get_accelerometer( ) ) )
print( "North: %s" % sensehat.get_compass( ) )
print( sensehat.get_compass_raw( ) )
print( "x: {x} , y: {y} , z: {z}".format( **sensehat.get_compass_raw( ) ) )
print( "x: %.4f" % sensehat.get_compass_raw( )['x']
+ " , y: %.4f" % sensehat.get_compass_raw( )['y']
+ " , Z: %.4f" % sensehat.get_compass_raw( )['z'] )
print( "x: %.4f" % sensehat.get_gyroscope_raw( )['x']
+ " , y: %.4f" % sensehat.get_gyroscope_raw( )['y']
+ " , Z: %.4f" % sensehat.get_gyroscope_raw( )['z'] )
print( "x: %.4f" % sensehat.get_accelerometer_raw( )['x']
+ " , y: %.4f" % sensehat.get_accelerometer_raw( )['y']
+ " , Z: %.4f" % sensehat.get_accelerometer_raw( )['z'] )
print time.strftime( "%Y-%m-%d %I:%M:%S %p %Z" , time.localtime( ) )
class Host(object):
def __init__(self,
rotation = 0,
low_light = False,
calibration = {},
smoothing = 0,
register_services = True,
environmental_publishing = False,
environmental_publishing_rate = 1,
imu_publishing = True,
#imu_publishing_mode = "get_gyroscope_rpy",
imu_publishing_mode = "get_sensor_msg",
imu_publishing_config = "1|1|1",
imu_publishing_rate = 0.01,
stick_publishing = False,
stick_sampling = 0.2):
"""Constructor method"""
#IMU_FRAME = rospy.get_param('~imu_frame', 'imu_link')
IMU_FRAME="imu_frame"
# Init sensor
self.sense = SenseHat()
self.sense.clear(0,0,0)
self.sense.set_rotation(rotation)
self.sense.low_light = low_light
self.measures = {
'humidity': self.sense.get_humidity,
'temperature_from_humidity': self.sense.get_temperature_from_humidity,
'temperature_from_pressure': self.sense.get_temperature_from_pressure,
'pressure': self.sense.get_pressure,
'compass': self.sense.get_compass,
}
# Init parameters
self.imu_publishing = imu_publishing
self.imu_publishing_mode = imu_publishing_mode
self.imu_publishing_rate = imu_publishing_rate
self.history = {}
for measure in self.measures:
self.history[measure] = collections.deque([], maxlen = smoothing if smoothing > 0 else None) if smoothing >= 0 else None
# Init Lock to serialize access to the LED Matrix
self.display_lock = Lock()
# Register publishers
if self.imu_publishing:
self.sense.set_imu_config(*[i=="1" for i in imu_publishing_config.split("|")])
self.imu_pub = rospy.Publisher("imu", Imu, queue_size=10)
rospy.loginfo("sensehat_ros initialized")
def __del__(self):
if self.sense:
self.sense.clear(0,0,0)
rospy.loginfo("sensehat_ros destroyed")
##############################################################################
# Private methods
##############################################################################
def _get_sensor_msg_imu(self, timestamp):
# 1 g-unit is equal to 9.80665 meter/square second. # Linear Acceleration
# 1° × pi/180 = 0.01745rad # Angular velocity # Gyro
gunit_to_mps_squ = 9.80665
msg = Imu()
msg.header.stamp = timestamp
msg.header.frame_id = IMU_FRAME
gyr = self.sense.get_gyroscope_raw()
acc = self.sense.get_accelerometer_raw()
msg.orientation.x = 0.0
msg.orientation.y = 0.0
msg.orientation.z = 0.0
msg.orientation.w = 0.0
msg.orientation_covariance = [-1, 0.0, 0.0, 0.0, 0, 0.0, 0.0, 0.0, 0]
#msg.angular_velocity.x = gyr['x'] * np.pi
msg.angular_velocity.x = round( gyr['x'] * ( np.pi / 180 ), 8 ) * (-1) # Inverted x axis
msg.angular_velocity.y = round( gyr['y'] * ( np.pi / 180 ), 8 )
msg.angular_velocity.z = round( gyr['z'] * ( np.pi / 180 ), 8 )
msg.angular_velocity_covariance = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
msg.linear_acceleration.x = round((acc['x'] * gunit_to_mps_squ), 8 ) * (-1) # Inverted x axis
msg.linear_acceleration.y = round((acc['y'] * gunit_to_mps_squ), 8 )
msg.linear_acceleration.z = round((acc['z'] * gunit_to_mps_squ), 8 )
#msg.linear_acceleration.x = np.radians( acc['x'] )
#msg.linear_acceleration.y = np.radians( acc['y'] )
#msg.linear_acceleration.z = np.radians( acc['z'] )
msg.linear_acceleration_covariance = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
return msg
def _publish_sensor_msg_imu(self, event):
imu = self._get_sensor_msg_imu(rospy.Time.now())
rospy.logdebug( "Publishing IMU" )
br = tf2_ros.TransformBroadcaster()
self.imu_pub.publish(imu)
##############################################################################
# Run
##############################################################################
def run(self):
if self.imu_publishing:
# Start publishing events
rospy.Timer(rospy.Duration(self.imu_publishing_rate), self._publish_sensor_msg_imu)
rospy.loginfo("sensehat_ros publishing Imu")
rospy.spin()
def start(self):
self.enable = True
self.imuPub = rospy.Publisher(self.robot_host + '/imu',
Imu,
queue_size=10)
self.imuRawPub = rospy.Publisher(self.robot_host + '/imu/raw',
Imu,
queue_size=10)
self.accelerometerPub = rospy.Publisher(self.robot_host +
'/imu/accelerometer',
Accelerometer,
queue_size=10)
self.accelerometerPitchPub = rospy.Publisher(
self.robot_host + '/imu/accelerometer/pitch', Pitch, queue_size=10)
self.accelerometerRollPub = rospy.Publisher(self.robot_host +
'/imu/accelerometer/roll',
Roll,
queue_size=10)
self.accelerometerYawPub = rospy.Publisher(self.robot_host +
'/imu/accelerometer/yaw',
Yaw,
queue_size=10)
self.accelerometerRawPub = rospy.Publisher(self.robot_host +
'/imu/accelerometer/raw',
Accelerometer,
queue_size=10)
self.accelerometerRawXPub = rospy.Publisher(self.robot_host +
'/imu/accelerometer/raw/x',
Float64,
queue_size=10)
self.accelerometerRawYPub = rospy.Publisher(self.robot_host +
'/imu/accelerometer/raw/y',
Float64,
queue_size=10)
self.accelerometerRawZPub = rospy.Publisher(self.robot_host +
'/imu/accelerometer/raw/z',
Float64,
queue_size=10)
self.gyroscopePub = rospy.Publisher(self.robot_host + '/imu/gyroscope',
Gyroscope,
queue_size=10)
self.gyroscopePitchPub = rospy.Publisher(self.robot_host +
'/imu/gyroscope/pitch',
Pitch,
queue_size=10)
self.gyroscopeRollPub = rospy.Publisher(self.robot_host +
'/imu/gyroscope/roll',
Roll,
queue_size=10)
self.gyroscopeYawPub = rospy.Publisher(self.robot_host +
'/imu/gyroscope/yaw',
Yaw,
queue_size=10)
self.gyroscopeRawPub = rospy.Publisher(self.robot_host +
'/imu/gyroscope/raw',
Gyroscope,
queue_size=10)
self.gyroscopeRawXPub = rospy.Publisher(self.robot_host +
'/imu/gyroscope/raw/x',
Float64,
queue_size=10)
self.gyroscopeRawYPub = rospy.Publisher(self.robot_host +
'/imu/gyroscope/raw/y',
Float64,
queue_size=10)
self.gyroscopeRawZPub = rospy.Publisher(self.robot_host +
'/imu/gyroscope/raw/z',
Float64,
queue_size=10)
self.magnetometerPub = rospy.Publisher(self.robot_host +
'/imu/magnetometer',
Magnetometer,
queue_size=10)
self.magnetometerRawPub = rospy.Publisher(self.robot_host +
'/imu/magnetometer/raw',
Orientation,
queue_size=10)
self.orientationPub = rospy.Publisher(self.robot_host +
'/imu/orientation',
Orientation,
queue_size=10)
self.orientationDegreePub = rospy.Publisher(self.robot_host +
'/imu/orientation/degrees',
Orientation,
queue_size=10)
self.orientationRadiansPub = rospy.Publisher(
self.robot_host + '/imu/orientation/radians',
Orientation,
queue_size=10)
self.orientationNorthPub = rospy.Publisher(self.robot_host +
'/imu/orientation/north',
Magnetometer,
queue_size=10)
sense = SenseHat()
while not rospy.is_shutdown():
accel_only = sense.get_accelerometer()
accel_raw = sense.get_accelerometer_raw()
gyro_only = sense.get_gyroscope()
gyro_raw = sense.get_gyroscope_raw()
north = sense.get_compass()
compass = sense.get_compass_raw()
orientation = sense.get_orientation()
orientation_deg = sense.get_orientation_degrees()
orientation_rad = sense.get_orientation_radians()
imu_msg = Imu()
imu_msg.header.stamp = rospy.Time.now()
imu_msg.header.frame_id = "/base_link"
imu_msg.linear_acceleration.x = accel_only['pitch']
imu_msg.linear_acceleration.y = accel_only['roll']
imu_msg.linear_acceleration.z = accel_only['yaw']
imu_msg.angular_velocity.x = gyro_only['pitch']
imu_msg.angular_velocity.y = gyro_only['roll']
imu_msg.angular_velocity.z = gyro_only['yaw']
imu_msg.orientation.x = orientation['pitch']
imu_msg.orientation.y = orientation['roll']
imu_msg.orientation.z = orientation['yaw']
imu_msg.orientation.w = 0
imu_msg.orientation_covariance = [
99999.9, 0.0, 0.0, 0.0, 99999.9, 0.0, 0.0, 0.0, 99999.9
]
imu_msg.angular_velocity_covariance = [
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
]
imu_msg.linear_acceleration_covariance = [
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
]
imu_raw_msg = Imu()
imu_raw_msg.header.stamp = rospy.Time.now()
imu_raw_msg.header.frame_id = "/base_link"
imu_raw_msg.linear_acceleration.x = accel_raw['x']
imu_raw_msg.linear_acceleration.y = accel_raw['y']
imu_raw_msg.linear_acceleration.z = accel_raw['z']
imu_raw_msg.angular_velocity.x = gyro_raw['x']
imu_raw_msg.angular_velocity.y = gyro_raw['y']
imu_raw_msg.angular_velocity.z = gyro_raw['z']
imu_raw_msg.orientation.x = compass['x']
imu_raw_msg.orientation.y = compass['y']
imu_raw_msg.orientation.z = compass['z']
imu_raw_msg.orientation.w = north
imu_raw_msg.orientation_covariance = [
99999.9, 0.0, 0.0, 0.0, 99999.9, 0.0, 0.0, 0.0, 99999.9
]
imu_raw_msg.angular_velocity_covariance = [
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
]
imu_raw_msg.linear_acceleration_covariance = [
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
]
accel_msg = Accelerometer()
accel_msg.header.stamp = rospy.Time.now()
accel_msg.header.frame_id = "/base_link"
accel_msg.x = accel_only['pitch']
accel_msg.y = accel_only['roll']
accel_msg.z = accel_only['yaw']
accel_pitch_msg = Pitch()
accel_pitch_msg.header.stamp = rospy.Time.now()
accel_pitch_msg.header.frame_id = "/base_link"
accel_pitch_msg.data = accel_only['pitch']
accel_roll_msg = Roll()
accel_roll_msg.header.stamp = rospy.Time.now()
accel_roll_msg.header.frame_id = "/base_link"
accel_roll_msg.data = accel_only['roll']
accel_yaw_msg = Yaw()
accel_yaw_msg.header.stamp = rospy.Time.now()
accel_yaw_msg.header.frame_id = "/base_link"
accel_yaw_msg.data = accel_only['yaw']
accel_raw_msg = Accelerometer()
accel_raw_msg.header.stamp = rospy.Time.now()
accel_raw_msg.header.frame_id = "/base_link"
accel_raw_msg.x = accel_raw['x']
accel_raw_msg.y = accel_raw['y']
accel_raw_msg.z = accel_raw['z']
accel_raw_x_msg = Float64()
accel_raw_x_msg.header.stamp = rospy.Time.now()
accel_raw_x_msg.header.frame_id = "/base_link"
accel_raw_x_msg.data = accel_raw['x']
accel_raw_y_msg = Float64()
accel_raw_y_msg.header.stamp = rospy.Time.now()
accel_raw_y_msg.header.frame_id = "/base_link"
accel_raw_y_msg.data = accel_raw['y']
accel_raw_z_msg = Float64()
accel_raw_z_msg.header.stamp = rospy.Time.now()
accel_raw_z_msg.header.frame_id = "/base_link"
accel_raw_z_msg.data = accel_raw['z']
gyro_msg = Gyroscope()
gyro_msg.header.stamp = rospy.Time.now()
gyro_msg.header.frame_id = "/base_link"
gyro_msg.x = gyro_only['pitch']
gyro_msg.y = gyro_only['roll']
gyro_msg.z = gyro_only['yaw']
gyro_pitch_msg = Pitch()
gyro_pitch_msg.header.stamp = rospy.Time.now()
gyro_pitch_msg.header.frame_id = "/base_link"
gyro_pitch_msg.data = gyro_only['pitch']
gyro_roll_msg = Roll()
gyro_roll_msg.header.stamp = rospy.Time.now()
gyro_roll_msg.header.frame_id = "/base_link"
gyro_roll_msg.data = gyro_only['roll']
gyro_yaw_msg = Yaw()
gyro_yaw_msg.header.stamp = rospy.Time.now()
gyro_yaw_msg.header.frame_id = "/base_link"
gyro_yaw_msg.data = gyro_only['yaw']
gyro_raw_msg = Gyroscope()
gyro_raw_msg.header.stamp = rospy.Time.now()
gyro_raw_msg.header.frame_id = "/base_link"
gyro_raw_msg.x = gyro_raw['x']
gyro_raw_msg.y = gyro_raw['y']
gyro_raw_msg.z = gyro_raw['z']
gyro_raw_x_msg = Float64()
gyro_raw_x_msg.header.stamp = rospy.Time.now()
gyro_raw_x_msg.header.frame_id = "/base_link"
gyro_raw_x_msg.data = gyro_raw['x']
gyro_raw_y_msg = Float64()
gyro_raw_y_msg.header.stamp = rospy.Time.now()
gyro_raw_y_msg.header.frame_id = "/base_link"
gyro_raw_y_msg.data = gyro_raw['y']
gyro_raw_z_msg = Float64()
gyro_raw_z_msg.header.stamp = rospy.Time.now()
gyro_raw_z_msg.header.frame_id = "/base_link"
gyro_raw_z_msg.data = gyro_raw['z']
north_msg = Magnetometer()
north_msg.header.stamp = rospy.Time.now()
north_msg.header.frame_id = "/base_link"
north_msg.north = north
compass_msg = Orientation()
compass_msg.header.stamp = rospy.Time.now()
compass_msg.header.stamp = rospy.Time.now()
compass_msg.x = compass['x']
compass_msg.y = compass['y']
compass_msg.z = compass['z']
orientation_msg = Orientation()
orientation_msg.header.stamp = rospy.Time.now()
orientation_msg.header.stamp = rospy.Time.now()
orientation_msg.x = orientation['pitch']
orientation_msg.y = orientation['roll']
orientation_msg.z = orientation['yaw']
orientation_degree_msg = Orientation()
orientation_degree_msg.header.stamp = rospy.Time.now()
orientation_degree_msg.header.stamp = rospy.Time.now()
orientation_degree_msg.x = orientation_deg['pitch']
orientation_degree_msg.y = orientation_deg['roll']
orientation_degree_msg.z = orientation_deg['yaw']
orientation_rad_msg = Orientation()
orientation_rad_msg.header.stamp = rospy.Time.now()
orientation_rad_msg.header.stamp = rospy.Time.now()
orientation_rad_msg.x = orientation_rad['pitch']
orientation_rad_msg.y = orientation_rad['roll']
orientation_rad_msg.z = orientation_rad['yaw']
rospy.loginfo(
"imu/accelerometer: p: {pitch}, r: {roll}, y: {yaw}".format(
**accel_only))
rospy.loginfo(
"imu/accelerometer/raw: x: {x}, y: {y}, z: {z}".format(
**accel_raw))
rospy.loginfo(
"imu/gyroscope: p: {pitch}, r: {roll}, y: {yaw}".format(
**gyro_only))
rospy.loginfo(
"imu/gyroscope/raw: x: {x}, y: {y}, z: {z}".format(**gyro_raw))
rospy.loginfo("imu/magnetometer: North: %s" % north)
rospy.loginfo(
"imu/magnetometer/raw: x: {x}, y: {y}, z: {z}".format(
**compass))
rospy.loginfo(
"imu/orientation: p: {pitch}, r: {roll}, y: {yaw}".format(
**orientation))
rospy.loginfo(
"imu/orientation/degrees: p: {pitch}, r: {roll}, y: {yaw}".
format(**orientation_deg))
rospy.loginfo(
"imu/orientation/radians: p: {pitch}, r: {roll}, y: {yaw}".
format(**orientation_rad))
rospy.loginfo("imu/orientation/north: North: %s" % north)
self.imuPub.publish(imu_msg)
self.imuRawPub.publish(imu_raw_msg)
self.accelerometerPub.publish(accel_msg)
self.accelerometerPitchPub.publish(accel_pitch_msg)
self.accelerometerRollPub.publish(accel_roll_msg)
self.accelerometerYawPub.publish(accel_yaw_msg)
self.accelerometerRawPub.publish(accel_raw_msg)
self.accelerometerRawXPub.publish(accel_raw_x_msg)
self.accelerometerRawYPub.publish(accel_raw_y_msg)
self.accelerometerRawZPub.publish(accel_raw_z_msg)
self.gyroscopePub.publish(gyro_msg)
self.gyroscopePitchPub.publish(gyro_pitch_msg)
self.gyroscopeRollPub.publish(gyro_roll_msg)
self.gyroscopeYawPub.publish(gyro_yaw_msg)
self.gyroscopeRawPub.publish(gyro_raw_msg)
self.gyroscopeRawXPub.publish(gyro_raw_x_msg)
self.gyroscopeRawYPub.publish(gyro_raw_y_msg)
self.gyroscopeRawZPub.publish(gyro_raw_z_msg)
self.magnetometerPub.publish(north_msg)
self.magnetometerRawPub.publish(compass_msg)
self.orientationPub.publish(orientation_msg)
self.orientationDegreePub.publish(orientation_degree_msg)
self.orientationRadiansPub.publish(orientation_rad_msg)
self.orientationNorthPub.publish(north_msg)
self.rate.sleep()
print(start)
if real_temp < 26.7 or real_temp > 18.3 or real_humidity < 70 or real_humidity > 40:
sense.set_pixels(happy_face)
if real_temp > 26.7 or real_temp < 18.3 or real_humidity > 70 or real_humidity < 40:
sense.set_pixels(sad_face)
acceleration = sense.get_accelerometer_raw()
AcX = acceleration["x"]
AcY = acceleration["y"]
AcZ = acceleration["z"]
gyroscope = sense.get_gyroscope_raw()
GyX = gyroscope["x"]
GyY = gyroscope["y"]
GyZ = gyroscope["z"]
if start == 54:
start = 0
magnetometer = sense.get_compass_raw()
MaX = magnetometer["x"]
MaY = magnetometer["y"]
MaZ = magnetometer["z"]
magnetometer_equation = sqrt(MaX * MaX + MaY * MaY + MaZ * MaZ)
"Time Stamp (Accelerometer), X (Degrees), Y (Degrees), Z (Degrees)\n")
# Get a start time for the test
start = time.time()
# Activate the gyro, disables the compass and accelerometer
sense.set_imu_config(False, True, False)
# Loop to write a bunch of the current pressure readings for the duration
# of the test
while time.time() - start < lengthOfTest:
# Retrieve the pressure from the SenseHat
pressure = sense.get_pressure() / 68.9476
# Retrieve the raw GYRO readings. This function returns a dictionary indexed with strings x, y, z.
# The values are floats representing rotational intensity of the axis in RADIANS PER SECOND.
rawGYRO = sense.get_gyroscope_raw()
gyro = sense.get_gyroscope()
rawAccel = sense.get_accelerometer_raw()
accel = sense.get_accelerometer()
now = time.time() - start
file.write(
str(now) + "," + str(pressure) + ",," + str(now) + "," +
str(rawGYRO.get("x")) + "," + str(rawGYRO.get("y")) + "," +
str(rawGYRO.get("z")) + ",," + str(now) + "," +
str(gyro.get("pitch")) + "," + str(gyro.get("roll")) + "," +
str(gyro.get("yaw")) + ",," + str(now) + "," + str(rawAccel.get("x")) +
"," + str(rawAccel.get("y")) + "," + str(rawAccel.get("z")) + ",," +
str(now) + "," + str(accel.get("pitch")) + "," +
str(accel.get("roll")) + "," + str(accel.get("yaw")) + '\n')
if GPIO.input(LEFT) == False:
Back() #If the left button (from the 4 button diamond shape arangement) is pressed the Back() function will run
if GPIO.input(RIGHT) == False:
Forwards() #If the right button is pressed then the Forwards() function will run
if GPIO.input(UP) == False:
Plus() #If the up button (the one at the top) is pressed then the Plus() function will run
if GPIO.input(DOWN) == False:
Less() #If the down button (the one at the bottom) is pressed then the Less() function will run
if GPIO.input(A) == False:
Prev() #If button A (the left button of the pair of buttons beneath the first 4) is pressed then the Prev() function will run
if GPIO.input(B) == False:
Next(1) #If button B (to the right of button A) is pressed then the Next(1) function will run
#shake routines to call prev and next
pitch, roll, yaw = sense.get_gyroscope_raw().values()
if yaw > threshold:
pitch = round(pitch, 1) #This sets the variable 'pitch' to the gyroscope measurement of pitch rounded to one place
roll = round(roll, 1) #This sets the variable 'roll' to the gyroscope measurement of roll rounded to one place
yaw = round(yaw, 1) #This sets the variable 'yaw' to the gyroscope measurement of yaw rounded to one place
print ("%s %s %s" % (pitch, roll, yaw))
sense.set_pixels(less)
Less() #If the MP3 Music Player is tilted right from a 90 degrees position with the screen facing the user the Less() function will run
if yaw < -threshold:
pitch = round(pitch, 1)
roll = round(roll, 1)
yaw = round(yaw, 1)
print ("%s %s %s" % (pitch, roll, yaw))
sense.set_pixels(plus)
Plus() #If the MP3 Music Player is tilted left from a 90 degrees position with the screen facing the user the Plus() function will run
#Could be used to replicate other functionality
start = time.time()
current = time.time()
i = 0
video = 0
#SET MAX LOG DURATION IN SECONDS
while (current-start) < 5:
current = time.time()
t = sense.get_temperature()
p = sense.get_pressure()
h = sense.get_humidity()
pitch, roll, yaw = sense.get_orientation().values()
xc, yc, zc = sense.get_compass_raw().values()
xg, yg, zg = sense.get_gyroscope_raw().values()
xa, ya, za = sense.get_accelerometer_raw().values()
f = open('./hat-log/hat.csv', 'a', os.O_NONBLOCK)
line = "%d, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f\n" % (1000*time.time(),t,p,h,pitch,roll,yaw,xc,yc,zc,xg,yg,zg,xa,ya,za)
f.write(line)
f.flush
f.close()
#set za threshold to the number of g you would expect at launch
if video == 0 and (za > 1.1 or za < -1.1):
video = 1
call(["./video", ""])
#print i
i = i+1
start = time.time()
current = time.time()
i = 0
video = 0
#SET MAX LOG DURATION IN SECONDS
while (current - start) < 5:
current = time.time()
t = sense.get_temperature()
p = sense.get_pressure()
h = sense.get_humidity()
pitch, roll, yaw = sense.get_orientation().values()
xc, yc, zc = sense.get_compass_raw().values()
xg, yg, zg = sense.get_gyroscope_raw().values()
xa, ya, za = sense.get_accelerometer_raw().values()
f = open('./hat-log/hat.csv', 'a', os.O_NONBLOCK)
line = "%d, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f\n" % (
1000 * time.time(), t, p, h, pitch, roll, yaw, xc, yc, zc, xg, yg, zg,
xa, ya, za)
f.write(line)
f.flush
f.close()
#set za threshold to the number of g you would expect at launch
if video == 0 and (za > 1.1 or za < -1.1):
video = 1
call(["./video", ""])
sense = SenseHat()
sense.set_imu_config(True, True, True)
# Python SenseHat API documentation:
# https://pythonhosted.org/sense-hat/api
# Roll is: angular x.
# Pitch is: angular y.
# Yaw is: angular z.
data_imu = {}
data_imu["gyro"] = sense.get_orientation_degrees(
) # Gets orientation (3-ang-axis) in [deg].
data_imu["acc"] = sense.get_accelerometer(
) # Gets orientation from the accelerometer (3-ang-axis) in [deg].
data_imu["gyror"] = sense.get_gyroscope_raw(
) # Gets angular velocity (3-axis) in [rad/s].
data_imu["mag"] = sense.get_compass() # Gets orientation to North in [deg].
data_imu["magr"] = sense.get_compass_raw(
) # Gets magnetic field (3-axis) in [µT].
data_imu["accr"] = sense.get_accelerometer_raw(
) # Gets acceleration (3-axis) in [g]'s.
data_env = {}
data_env["temph"] = sense.get_temperature_from_humidity(
) # Gets temperature from humidity sensor in [ºC].
data_env["tempp"] = sense.get_temperature_from_pressure(
) # Gets temperature from pressure sensor in [ºC].
data_env["pres"] = sense.get_pressure() # Gets pressure in [mbar].
data_env["hum"] = sense.get_humidity() # Gets relative humidity in [%].
cpu_temp = os.popen("vcgencmd measure_temp").readline()
data_env["tempcpu"] = float(cpu_temp.replace("temp=", "").replace("'C\n", ""))
class EasyAHRS:
def __init__(self,senseHatNum=1,timeInit=0):
#####
# Predetermined Mag Calibraton
####
# Sense Hat 1
# xBias = -30.02851629257202
# yBias = 7.201869010925293 +1.4395752679386042
# xSF = 0.6773587707778925
# ySF = 0.7209744740877911
# Sense Hat 2
self.xBias = 2.701296329498291
self.yBias = 19.79104995727539
self.xSF = 0.6955512793747712
self.ySF = 0.7164366008777275
#
# AHRS Smoothing filter time constant
self.tau = 1/200
self.rates = np.array([0.0,0.0,0.0])
self.accel = np.array([0.0,0.0,0.0])
self.mag = np.array([0.0,0.0,0.0])
self.att = np.array([0.0,00.0,0.0])
self.sense = SenseHat()
self.senseHatNum = senseHatNum
if timeInit>0:
self.startTime = timeInit
else:
self.startTime = time.time()
print("initialized {0}".format(self.senseHatNum))
def warmup(self):
print("Warming up ...")
for i in range(1,101):
gyroRaw = self.sense.get_gyroscope_raw()
accelRaw = self.sense.get_accelerometer_raw()
magRaw = self.sense.get_compass_raw()
temp = self.sense.get_temperature()
print("Warm up complete")
def align(self, alignSamples=100):
print("Aligning {0} Samples".format(alignSamples))
for i in range(1,alignSamples+1):
# elapsedTime = time.time() - startTime
gyroRaw = self.sense.get_gyroscope_raw()
accelRaw = self.sense.get_accelerometer_raw()
magRaw = self.sense.get_compass_raw()
temp = self.sense.get_temperature()
magRaw["x"] = self.xSF *(magRaw["x"] - self.xBias)
magRaw["y"] = self.ySF *(magRaw["y"] - self.yBias)
self.accel = self.accel + \
1/alignSamples*np.array([accelRaw["x"], accelRaw["y"],accelRaw["z"]])
self.rates = self.rates + \
1/alignSamples*np.array([gyroRaw["x"], gyroRaw["y"],gyroRaw["z"]])
self.mag = self.mag + \
1/alignSamples*np.array([magRaw["x"], magRaw["y"],magRaw["z"]])
print("Accel: ", self.accel)
print("Gyro: ", self.rates)
print("Mag: ", self.mag)
# Establish initial prich roll from averaged accel measures
self.att[1] = asin(-1*self.accel[0])
print("Pitch {0}".format(self.att[1]))
print("Pitch {0}".format(asin(-1*self.accel[0])))
self.att[0] = atan2(self.accel[1],1.0)
print(self.att)
Ca = self.euler2C(self.att[1],self.att[0],0.0)
print(Ca)
# Establish initial heading from horizontal mag measuremetns
magL = Ca.dot(self.mag.transpose())
self.att[2] = atan2(-1*magL[1],magL[0])
# Initialize Gyro, Accel, and Filtered to Level transitions
C_AL = self.euler2C(self.att[1],self.att[0],self.att[2])
C_GL = self.euler2C(self.att[1],self.att[0],self.att[2])
C_FL = self.euler2C(self.att[1],self.att[0],self.att[2])
# Initial Gyro bias is the average over sample period
self.gyroBias = self.rates
print("Align Attitude:")
print(self.att*degrees(1.0))
print("Align Gyro Bias")
print(self.gyroBias*degrees(1.0))
"""
" c2euler
" This routine converts a C matrix represention to euler representation
" Input: C matrix
" Output: pitch roll yaw
"""
def euler2C(self,pitch,roll,yaw):
C = np.zeros( (3,3) )
cTheta = cos(pitch)
sTheta = sin(pitch)
cPhi = cos(roll)
sPhi = sin(roll)
cPsi = cos(yaw)
sPsi = sin(yaw)
C[0,0] = cTheta*cPsi
C[0,1] = -1*cPhi*sPsi + sPhi*sTheta*cPsi
C[0,2] = sPhi*sPsi + cPhi*sTheta*cPsi
C[1,0] = cTheta*sPsi
C[1,1] = cPhi*cPsi + sPhi*sTheta*sPsi
C[1,2] = -sPhi*cPsi + cPhi*sTheta*sPsi
C[2,0] = -sTheta
C[2,1] = sPhi*cTheta
C[2,2] = cPhi*cTheta
return C
"""
" c2euler
" This routine converts a C matrix represention to euler representation
" Input: C matrix
" Output: pitch roll yaw
"""
def c2euler(self,C):
pitch = -1*asin(C[2,0])
yaw = atan2(C[1,0],C[0,0])
roll = atan2(C[2,1],C[2,2])
return (pitch,roll,yaw)
"""
" ortho_norm
" This routine ortho normalizes a C matrix
" Input: C matrix
" Output: Ortho normed C matrix
"""
def ortho_norm(self,C):
x = C[:,0]
y = C[:,1]
z = C[:,2]
e = x.transpose()
e = e.dot(y)
eScalar = e/2
xOrtho = x - e*y
yOrtho = y - e*x
zOrtho = np.cross(xOrtho,yOrtho)
xNorm = 0.5*(3 - xOrtho.transpose().dot(xOrtho))*xOrtho
yNorm = 0.5*(3 - yOrtho.transpose().dot(yOrtho))*yOrtho
zNorm = 0.5*(3 - zOrtho.transpose().dot(zOrtho))*zOrtho
Con = np.column_stack( (xNorm,yNorm,zNorm) )
return Con
def update(self):
r180 = radians(180)
nr180 = radians(-180)
r360 = radians(360)
deltaTheta = np.array([0, 0 , 0])
accumTheta = np.array([0, 0 , 0])
omega = np.array( [0, 0, 0] )
deltaC = np.ones( (3,3) )
prevTime = time.time() - startTime
# The stuff above should go somewhere else
elapsedTime = time.time() - self.startTime
gyroRaw = sense.get_gyroscope_raw()
accelRaw = sense.get_accelerometer_raw()
magRaw = sense.get_compass_raw()
temp = sense.get_temperature()
# logFile.write("0,{0},{x},{y},{z}\r\n".format(elapsedTime,**gyroRaw)) # rad/sec
# logFile.write("1,{0},{x},{y},{z}\r\n".format(elapsedTime,**accelRaw)) # Gs
# logFile.write("2,{0},{x},{y},{z}\r\n".format(elapsedTime,**magRaw)) # microT
# logFile.write("7,{0},{1}\r\n".format(elapsedTime,temp))
magRaw["x"] = xSF *(magRaw["x"] - xBias)
magRaw["y"] = ySF *(magRaw["y"] - yBias)
deltaTime = elapsedTime - prevTime
# print("0,{0},{x},{y},{z}".format(elapsedTime,**gyroRaw)) # rad/sec
# print("1,{0},{x},{y},{z}".format(elapsedTime,**accelRaw)) # Gs
# print("2,{0},{x},{y},{z}".format(elapsedTime,**magRaw))
# Accumplate Rates
omega = np.array( (gyroRaw["x"], gyroRaw["y"], gyroRaw["z"]) ) - gyroBias
deltaTheta = omega*deltaTime # Basic Integration
accumTheta = accumTheta + deltaTheta
# print("Dt {0} {1} {2}".format(degrees(accumTheta[0]),degrees(accumTheta[1]),degrees(accumTheta[2])))
# Form the deltaC matrix from the angular rotations
# Single taylor series with small angle assumption
deltaC[0,1] = -1*deltaTheta[2]
deltaC[0,2] = deltaTheta[1]
deltaC[1,0] = deltaTheta[2]
deltaC[1,2] = -1*deltaTheta[0]
deltaC[2,0] = -1*deltaTheta[1]
deltaC[2,1] = deltaTheta[0]
# Update the gyro and filter solution
C_GL = C_GL.dot(deltaC)
C_FL = C_FL.dot(deltaC)
# Determine the Accel Solution
accelPitch = asin(-1*accelRaw["x"])
accelRoll = atan2(accelRaw["y"],1.0)
accelMag = np.array([magRaw["x"], magRaw["y"],magRaw["z"]])
C_AL = euler2C(accelPitch,accelRoll,0.0)
# print(Ca)
magL = C_AL.dot(accelMag.transpose())
# print(magL)
yaw = atan2(-1*magL[1],magL[0])
C_AL = euler2C(accelPitch,accelRoll,yaw)
# Update the filtered solution with the data from the
# Accel based solution
(pf,rf,yf) = c2euler(C_FL)
pf = (1-tau)*pf + tau*accelPitch
rf = (1-tau)*rf + tau*accelRoll
ey = yf-yaw
if ey > r180:
ey = ey - r360
elif ey < -r180:
ey = ey + r360
yf = (1-tau)*yf + tau*(yf - ey)
if yf > r180:
yf = yf-r360
elif yf < -r180:
yf = yf+r360
C_FL = euler2C(pf,rf,yf)
# print("Att --> {0} {1} {2}".format(degrees(pf),degrees(rf),degrees(yf)))
prevTime = elapsedTime
# TODO write header
while True:
# Check for end time
now = datetime.now()
if now >= end_time:
logger.info(f'Finished run at {now}')
break
# Main loop
try:
orientation = sh.get_orientation_degrees()
compass = sh.get_compass()
compass_raw = sh.get_compass_raw()
gyro = sh.get_gyroscope()
gyro_raw = sh.get_gyroscope_raw()
accelerometer_raw = sh.get_accelerometer_raw()
camera.capture(debug_capture=True)
util.add_csv_data(csvfile, (
now,
sh.get_humidity(),
sh.get_temperature(),
sh.get_temperature_from_humidity(),
sh.get_temperature_from_pressure(),
sh.get_pressure(),
orientation['roll'],
orientation['pitch'],
orientation['yaw'],
compass,
compass_raw['x'],
def get_gyroscope_raw():
sense = SenseHat()
sense.set_imu_config(False, True, False) # Gyroscope only
return sense.get_gyroscope_raw()
from quat_rotate import qv_mult
import numpy as np
# Get data
sense = SenseHat()
previousTime = -1
ACCELEROMETER_DRIFT_WHEN_STATIONARY = 0.00000000001
samplePeriod = 1 / 256
posX = 0
posY = 0
posZ = 0
while True:
# Get sensor data and the current time
gyro = sense.get_gyroscope_raw() # deg/s
acc = sense.get_accelerometer_raw() # g's (1g = 9.81 m/s^2)
mag = sense.get_compass_raw() # microteslas (uT)
currentTime = time()
# Calculate the magnitude of acceleration
accMagnitude = sqrt((acc['x'] * acc['x']) + (acc['y'] * acc['y']) +
(acc['z'] * acc['z']))
# Use a high-pass filter to remove some noise
filterCutoff = 0.001
butterFilterB, butterFilterA = signal.butter(
1, (2 * filterCutoff) / (1 / samplePeriod), 'highpass')
accMagnitudeFiltered = signal.filtfilt(butterFilterB,
butterFilterA,
[accMagnitude, accMagnitude],
class DataWrite:
def __init__(self):
self.sense = SenseHat()
self.sense.set_imu_config(True, True, True)
def get_data(self):
"""Gets data from environmental sensors and IMU sensors
and formats it for writing to a CSV with time as the first item
"""
# get environmental data from the sensehat
def get_enviro():
"""Gets environmental data and formats it in the form:
pressure, temperature_pressure, temperature_humidity, humidity
"""
# Get readings from each sensor
pressure = self.sense.get_pressure()
temp_press = self.sense.get_temperature_from_pressure()
temp_humid = self.sense.get_temperature_from_humidity()
humidity = self.sense.get_humidity()
# Format the readings
enviro_results = [pressure, temp_press, temp_humid, humidity]
return enviro_results
# get IMU data from the sensehat
def get_imu():
"""Gets IMU data and formats it in the form:
accelX, accelY, accelZ, gyroX, gyroY, gyroZ, compassX, compassY, compassZ, orientationX, orientationY,
orientationZ
"""
# get raw data from IMU sensors
accelraw = self.sense.get_accelerometer_raw()
gyroraw = self.sense.get_gyroscope_raw()
compassraw = self.sense.get_compass_raw()
orientationraw = self.sense.get_orientation_degrees()
# Format raw data into a usable list
imu_results = [
accelraw['x'], accelraw['y'], accelraw['z'], gyroraw['x'],
gyroraw['y'], gyroraw['z'], compassraw['x'], compassraw['y'],
compassraw['z'], orientationraw['pitch'],
orientationraw['roll'], orientationraw['yaw']
]
return imu_results
# Get data from sensors and add time then append together
enviro_res = get_enviro()
imu_res = get_imu()
current_time = datetime.datetime.now().strftime(
"%d-%b-%Y (%H:%M:%S.%f)")
results = [current_time]
results.extend(enviro_res)
results.extend(imu_res)
print(results)
return results
def write_data(self):
"""Writes data to data.csv in append mode as to not delete headers or previous data"""
with open('data.csv', 'a') as f:
writer = csv.writer(f)
writer.writerow(self.get_data())
class CiosRaspberryHat:
#
# Constructor
#
# url string WebsocketのURL
# channel_id string CiosのチャネルID
# access_token string Ciosのアクセストークン
#
def __init__(self, url, channel_id, access_token):
self.url = url
self.channel = channel_id
self.token = access_token
self.ws = 0
self.sense = SenseHat() # SenseHat インスタンス作成
self.sense.set_imu_config(True, True, True) # 加速度センサーの有効化
self.connectCount = 0
self.screen = "top"
#
# connection
#
# WebSocketへのコネクションを貼る
#
def connection(self):
try:
ws_url = self.url + "?" + "channel_id=" + self.channel + "&access_token=" + self.token
print("--------------- WebSocket Connection ---------------")
print("ConnectionURL: " + ws_url)
print("--------------- WebSocket Connection ---------------")
self.sense.show_letter("C", text_colour=[0, 255, 255])
self.ws = create_connection(ws_url)
except:
print("Websocket Connection Error...")
self.sense.show_letter("E", text_colour=[255, 0, 0])
self.errorReConnect()
return "error"
#
# getSensorData
#
# SenseHatからのデータを取得、JSON整形を行う
# return: Json String
#
def getSensorData(self):
try:
humidity = self.sense.get_humidity()
temp = self.sense.get_temperature()
pressure = self.sense.get_pressure()
orientation = self.sense.get_orientation_degrees()
compass = self.sense.get_compass_raw()
gyroscope = self.sense.get_gyroscope_raw()
accelerometer = self.sense.get_accelerometer_raw()
message = {
"humidity": humidity,
"temperature": temp,
"pressure": pressure,
"degrees_p": orientation["pitch"],
"degrees_r": orientation["roll"],
"degrees_y": orientation["yaw"],
"compass_x": compass["x"],
"compass_y": compass["y"],
"compass_z": compass["z"],
"gyroscope_x": gyroscope["x"],
"gyroscope_y": gyroscope["y"],
"gyroscope_z": gyroscope["z"],
"accelerometer_x": accelerometer["x"],
"accelerometer_y": accelerometer["y"],
"accelerometer_z": accelerometer["z"]
}
send_message = json.dumps(message)
return send_message
except:
print("getSensorData Error...")
self.ws.close()
self.sense.show_letter("E", text_colour=[255, 0, 0])
self.errorReConnect()
return "error"
#
# sendMessage
#
# message string 送信するメッセージ（Json形式）
#
def sendMessage(self, message):
try:
print("--------------- WebSocket Send Message ---------------")
print(message)
print("--------------- WebSocket Send Message ---------------")
self.ws.send(message)
except:
print("Websocket Send Error...")
self.ws.close()
self.sense.show_letter("E", text_colour=[255, 0, 0])
self.errorReConnect()
return "error"
#
# Error ReConnect WebSocket
#
# message string 送信するメッセージ（Json形式）
#
def errorReConnect(self):
try:
if self.connectCount > 0: # ErrorCount カウント数以上のエラーで停止
raise
self.connectCount += 1
for v in range(self.connectCount): # Error数に応じて、待機時間を追加
print("Wait ::: " + str(self.connectCount - v) + " sec")
time.sleep(1)
self.connection()
except:
print("Websocket connection Error count : " +
str(self.connectCount) + " Over")
self.sense.show_letter("E", text_colour=[255, 0, 0])
time.sleep(0.5)
self.sense.show_letter("E", text_colour=[0, 255, 0])
time.sleep(0.5)
self.sense.show_letter("E", text_colour=[0, 0, 255])
time.sleep(0.5)
self.sense.show_letter("E", text_colour=[255, 0, 0])
time.sleep(2)
self.sense.clear()
exit()
steps = 0
def sendRequest(url, paramas):
r = requests.post(url, headers={'identifier': getserial()}, data=paramas)
print(r)
while 1:
o = sense.get_orientation()
temp = sense.get_temperature()
humidity = sense.get_humidity()
acceleration = sense.get_accelerometer_raw()
gyrox = sense.get_gyroscope_raw()
x1 = abs(gyrox['x'])
x2 = abs(gyrox['y'])
x3 = abs(gyrox['z'])
x = acceleration['x']
y = acceleration['y']
z = acceleration['z']
if datetime.datetime.now() >= thirty:
# print("request : {0}".format(g))
try:
thread.start_new_thread(sendRequest,
('http://172.16.0.49:4242/informations', {
'temperature': temp,