class SenseHatThing(Thing):
"""A Thing which updates its measurement every few seconds."""
def __init__(self):
Thing.__init__(self, 'urn:dev:ops:my-sense-hat-1234', 'My Sense Hat',
['MultiLevelSensor'], 'A web connected sense hat')
self.sense = SenseHat()
self.sense.set_imu_config(False, True, False)
self.compass = Value(0.0)
self.add_property(
Property(self,
'compass',
self.compass,
metadata={
'title': 'Compass',
'type': 'number',
'description': 'Angle to North',
'unit': 'º',
'minimum': 0,
'maximum': 360,
'readOnly': True,
}))
logging.debug('starting the sensor update looping task')
self.timer = tornado.ioloop.PeriodicCallback(self.update_properties,
1000)
self.timer.start()
def update_properties(self):
compass = self.sense.get_compass()
logging.debug("update: compass=%s", compass)
self.compass.notify_of_external_update(compass)
def cancel_update_properties_task(self):
self.timer.stop()
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
class AlarmSensor(object):
def __init__(self):
'''
Constructor : Initializing Compass Sensor and Sensehat
and setting ubidots variables and topic's values
'''
self.sensehat = SenseHat()
self.waitInSec = 1
self.red = (255, 0, 0)
self.CompassSensorData = "Compass Sensor"
self.ubidots_Compass_Var = "/compasssensor" #ubidots device variable
self.ubidots_alert_actuator = '/alert' #ubidots actuator variable
self.ubidots_device = "/sos" #ubidots device name
self.ubidots_compass_topic = "/v1.6/devices" + self.ubidots_device + self.ubidots_Compass_Var
self.alert_topic = "/v1.6/devices" + self.ubidots_device + self.ubidots_alert_actuator
self.mqttClient = MqttClientConnectorNew.MqttClientConnectorNew()
self.motion = 0
self.setangle = 0
self.http = HTTPCompassPublisher.HTTPCompassPublisher()
'''Enabling the emulator
@param enableEmulator: Defaults to false; if true will enable emulator to run
'''
def setEnableEmulatorFlag(self, enableEmulator):
self.enableEmulator = enableEmulator
'''Running compass sensor
'''
def run(self):
while True:
if self.enableEmulator:
'''accepting compass value from SenseHat by setting IMU config,
converting it to a fix value to avoid the lag
and sending it to httpCompasspublisher to send over cloud
'''
self.sensehat.set_imu_config(True, False, False)
while True:
self.motion = self.sensehat.get_compass()
print("actual %s" % self.motion)
'''normal angle =200 and alert angle=150'''
if self.motion > 250 or self.motion < 80:
self.setangle = 150
print("alert angle %s" % self.setangle)
else:
self.setangle = 200
print(" normal angle %s" % self.setangle)
self.http.post(self.setangle) # posting data to cloud
sleep(0.5)
'''defining thread and its parameter.
the thread will execute run function
'''
def start(self): #
t = threading.Thread(target=self.run())
t.start()
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()
def _init_(self):
device_sensor = SenseHat()
self.device_id = 4
self.device_lon = random.uniform(-76.8, -77.2)
self.device_lat = random.uniform(38.75, 39.0)
self.device_last_time = time.time()
self.device_last_temp = device_sensor.get_gyroscope()
self.device_last_humidity = device_sensor.get_accelerometer()
self.device_last_mag = device_sensor.get_compass()
self.device_last_pressure = device_sensor.get_pressure()
return self
def get_direction():
sense = SenseHat()
heading = sense.get_compass()
if heading < 45 or heading >= 315:
return 'N'
elif heading < 135:
return 'E'
elif heading < 225:
return 'S'
else:
return 'W'
def root():
sense = SenseHat()
temp1 = sense.get_temperature()
temp2 = sense.get_temperature_from_pressure()
pressure = sense.get_pressure()
north = sense.get_compass()
accel_only = sense.get_accelerometer()
acc_raw = sense.get_accelerometer_raw()
temp = "Temp {:10.4f}".format(temp1) + " {:10.4f}".format(temp2)
other = "Pres {:10.4f}".format(pressure) + " Compas {:10.4f}".format(north)
acc1 = "p: {pitch}, r: {roll}, y: {yaw}".format(**accel_only)
acc2 = "x: {x}, y: {x}, z: {z}".format(**acc_raw)
print temp + "\n" + other + "\n" + acc1 + "\n" + acc2 + "\n"
def _init_(self):
device_sensor = SenseHat()
self.device_id = 1
self.device_lon = random.uniform(-76.8, -77.2)
self.device_lat = random.uniform(38.75, 39.0)
self.device_last_time = time.time()
self.device_last_temp = device_sensor.get_temperature()
self.device_last_humidity = device_sensor.get_humidity()
self.device_last_mag = device_sensor.get_compass()
self.device_last_pressure = device_sensor.get_pressure()
self.device_last_wind_speed = random.uniform(0.0, 20)
self.device_last_rain_guage = random.uniform(0.0, 10)
return self
def root():
sense = SenseHat()
temp1 = sense.get_temperature()
temp2 = sense.get_temperature_from_pressure()
pressure = sense.get_pressure()
north = sense.get_compass()
accel_only = sense.get_accelerometer()
acc_raw = sense.get_accelerometer_raw()
temp = "Temp {:10.4f}".format(temp1) + " {:10.4f}".format(temp2)
other = "Pres {:10.4f}".format(pressure) + " Compas {:10.4f}".format(north)
acc1 = "p: {pitch}, r: {roll}, y: {yaw}".format(**accel_only)
acc2 = "x: {x}, y: {x}, z: {z}".format(**acc_raw)
print temp + "\n" + other + "\n" + acc1 + "\n" + acc2 + "\n"
def show(self):
sense_hat = SenseHat()
degrees_from_north = sense_hat.get_compass()
direction = self.Direction.N
for direction, range in self.direction_ranges.items():
if self.isWithinRange(degrees_from_north, range):
direction = direction
break
degrees_180 = degrees_from_north if degrees_from_north <= 180 else degrees_from_north - 360
# print(degrees_from_north, direction.name, self.direction_colors[direction])
sense_hat.show_message("{} {:.1f}".format(direction.name, degrees_180),
text_colour=self.direction_colors[direction])
def sensehat(sensor):
from sense_hat import SenseHat
sense = SenseHat()
if (sensor == "mv_sensors"):
while True:
if (magnetometer == True):
sense.set_imu_config(True, False, False)
north = sense.get_compass()
print("direction {0:.1f}".format(north))
if (gyroscope == True):
sense.set_imu_config(False, True, False)
gyro_only = sense.get_gyroscope()
print("pitch: {pitch}".format(**sense.gyro))
print("yaw: {yaw}".format(**sense.gyro))
print("roll: {roll}".format(**sense.gyro))
if (accelerometer == True):
sense.set_imu_config(False, False, True)
raw = sense.get_accelerometer_raw()
print("ac_x: {x}".format(**raw))
print("ac_y: {y}".format(**raw))
print("ac_z: {z}".format(**raw))
elif (sensor == "temperature"):
for x in range(0, 3):
t1 = sense.get_temperature_from_humidity()
t2 = sense.get_temperature_from_pressure()
t = (t1 + t2) / 2
t_cpu = get_cpu_temp()
# calculates the real temperature compesating CPU heating
t_corr = t - ((t_cpu - t) / 1.6)
t_corr = get_smooth(t_corr)
mesurement = t_corr
elif (sensor == "humidity"):
#Approximating from Buck's formula Ha = Hm*(2.5-0.029*Tm)
temp = sense.get_temperature()
humidity = sense.get_humidity()
calchum = humidity * (2.5 - 0.029 * temp)
mesurement = calchum
elif (sensor == "pressure"):
mesurement = sense.get_pressure()
return mesurement
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()
def publishOtherInfo():
sense = SenseHat()
while True:
try:
# get temperature data
temp = sense.get_temperature()
temp = round(temp, 1)
publish('temperature', {'temperature': temp})
print('Temperature: ' + str(temp) + '; ')
# get humidity data
hum = sense.get_humidity()
hum = round(hum, 1)
publish('humidity', {'humidity': hum})
print('Humidity: ' + str(hum) + '; ')
# get pressure data
pre = sense.get_pressure()
pre = round(pre, 1)
publish('pressure', {'pressure': pre})
print('Pressure: ' + str(pre))
# get compass data
compass_north = sense.get_compass()
compass_north = round(compass_north, 1)
compass_data = sense.get_compass_raw()
m_x = compass_data['x']
m_x = round(m_x, 1)
m_y = compass_data['y']
m_y = round(m_y, 1)
m_z = compass_data['z']
m_z = round(m_z, 1)
publish('compass', {'north':compass_north,'m_x': m_x, 'm_y': m_y, 'm_z': m_z})
print('North: ' + str(compass_north) + ' Compass_x: ' + str(m_x) + ' Compass_y: ' + str(m_y) + ' Compass_z: ' + str(m_z) + '\n')
time.sleep(3)
except IOError:
print("IOError")
def runCompass():
led_loop = [4, 5, 6, 7, 15, 23, 31, 39, 47, 55, 63, 62, 61, 60, 59, 58, 57, 56, 48, 40, 32, 24, 16, 8, 0, 1, 2, 3]
sense = SenseHat()
sense.set_rotation(0)
sense.clear()
prev_x = 0
prev_y = 0
led_degree_ratio = len(led_loop) / 360.0
elapsed = time.time()
futureTime = time.time() + 60
#run the compass for 1 minute
while elapsed < futureTime:
elapsed = time.time()
try:
dir = sense.get_compass()
dir_inverted = 360 - dir # So LED appears to follow North
led_index = int(led_degree_ratio * dir_inverted)
offset = led_loop[led_index]
y = offset // 8 # row
x = offset % 8 # column
if x != prev_x or y != prev_y:
sense.set_pixel(prev_x, prev_y, 0, 0, 0)
sense.set_pixel(x, y, 0, 0, 255)
prev_x = x
prev_y = y
except (KeyboardInterrupt):
sense.clear()
sys.exit(0)
sense.clear()
def main():
# Query pisense
sense = SenseHat()
# Temperature
t = sense.get_temperature()
cpu_temp = str((str(subprocess.check_output("vcgencmd measure_temp", shell=True)).replace("temp=","")).replace("'C",""))
cpu_temp = float(re.findall("\d+\.\d+", cpu_temp)[0])
t_c = t - ((cpu_temp - t)/1.166) # calibrate according to CPU temp
t_c = round(((t_c/5.0)*9)+32,1) #farenheit
# Compass
compass = sense.get_compass()
# Humidity
h = sense.get_humidity()
h = round(h, 1)
# Barometric Pressure
p = round(sense.get_pressure(),2)
msg = "Euplotid says: Temp = {0}'F, Press = {1}Pa, Humidity = {2}%".format(t_c,p,h)
sense.show_message(msg, scroll_speed=0.02)
#create and save entry in DB
pisense_dbrow = piSenseRead(datetime.datetime.now(), p, t_c, h)
db.session.add(pisense_dbrow)
db.session.commit()
sense.clear()
# Configure CSV
csvfile = util.path_for_data(1)
logger.info(f'Logging to {csvfile}')
# 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'],
O, O, O, O, O, O, O, O,
O, X, X, O, O, X, X, O,
O, X, X, O, O, X, X, O,
O, O, O, O, O, O, O, O,
O, O, O, O, O, O, O, O,
O, X, O, O, O, O, X, O,
O, O, X, X, X, X, O, O,
O, O, O, X, X, O, O, O
]
while (1 == 1) :
print("%s Temperature" % sense.temp)
print("%s Temp - humidity sensor" % sense.get_temperature_from_humidity())
print("%s Temp - pressure sensor" % sense.get_temperature_from_pressure())
print("%s Pressure: in Millibars" % sense.get_pressure())
print("%s Humidity" % sense.get_humidity())
north = sense.get_compass()
print("%s Degrees to north" % north)
raw = sense.get_accelerometer_raw()
print("Acc intensity in Gs x: {x}, y: {y}, z: {z}".format(**raw))
m = '%.1f' % sense.temp
sense.show_message(m, text_colour=[255, 0, 0])
print("*********")
sense.set_pixels(question_mark)
time.sleep(1)
def update_mag(self):
device_sensor = SenseHat()
self.device_last_mag = device_sensor.get_compass()
self.device_last_time = time.time()
class PiSenseHat(object):
"""Raspberry Pi 'IoT Sense Hat API Driver Class'."""
# Constructor
def __init__(self):
self.sense = SenseHat()
# enable all IMU functions
self.sense.set_imu_config(True, True, True)
# pixel display
def set_pixel(self, x, y, color):
# red = (255, 0, 0)
# green = (0, 255, 0)
# blue = (0, 0, 255)
self.sense.set_pixel(x, y, color)
# clear pixel display
def clear_display(self):
self.sense.clear()
# Pressure
def getPressure(self):
return self.sense.get_pressure()
# Temperature
def getTemperature(self):
return self.sense.get_temperature()
# Humidity
def getHumidity(self):
return self.sense.get_humidity()
def getHumidityTemperature(self):
return self.sense.get_temperature_from_humidity()
def getPressureTemperature(self):
return self.sense.get_temperature_from_pressure()
def getOrientationRadians(self):
return self.sense.get_orientation_radians()
def getOrientationDegrees(self):
return self.sense.get_orientation_degrees()
# degrees from North
def getCompass(self):
return self.sense.get_compass()
def getAccelerometer(self):
return self.sense.get_accelerometer_raw()
def getEnvironmental(self):
sensors = {'name': 'sense-hat', 'environmental': {}}
return sensors
def getJoystick(self):
sensors = {'name': 'sense-hat', 'joystick': {}}
return sensors
def getInertial(self):
sensors = {'name': 'sense-hat', 'inertial': {}}
def getAllSensors(self):
sensors = {
'name': 'sense-hat',
'environmental': {},
'inertial': {},
'joystick': {},
'location': {}
} # add location
sensors['environmental']['pressure'] = {
'value': self.sense.get_pressure(),
'unit': 'mbar'
}
sensors['environmental']['temperature'] = {
'value': self.sense.get_temperature(),
'unit': 'C'
}
sensors['environmental']['humidity'] = {
'value': self.sense.get_humidity(),
'unit': '%RH'
}
accel = self.sense.get_accelerometer_raw()
sensors['inertial']['accelerometer'] = {
'x': accel['x'],
'y': accel['y'],
'z': accel['z'],
'unit': 'g'
}
orientation = self.sense.get_orientation_degrees()
sensors['inertial']['orientation'] = {
'compass': self.sense.get_compass(),
'pitch': orientation['pitch'],
'roll': orientation['roll'],
'yaw': orientation['yaw'],
'unit': 'degrees'
}
sensors['location']['lat'] = {
'value': 0
} # initialize these with 0 values to start
sensors['location']['lon'] = {'value': 0}
sensors['location']['alt'] = {'value': 0}
sensors['location']['sats'] = {'value': 0}
sensors['location']['speed'] = {'value': 0}
return sensors
e,
y,
y,
e,
e,
e,
]
# Send magnetometer and sensors information every second and 50 times
count = 0
while (count < 50):
# Publish Sensor info
mqttc.publish(MQTT_TOPIC1, MQTT_MSG1, qos=1)
# Magnetometer actions
north = sense.get_compass() # Get compass data
MQTT_MSG3 = "North: {0:.0f} Degree".format(north)
mqttc.publish(MQTT_TOPIC3, MQTT_MSG3, qos=1)
# Joystick action - show the direction on the display
for event in sense.stick.get_events():
MQTT_MSG2 = "The joystick was moving {}".format(event.direction)
if event.direction == 'left':
sense.set_pixels(left)
time.sleep(1)
sense.clear()
elif event.direction == 'right':
sense.set_pixels(right)
time.sleep(1)
sense.clear()
elif event.direction == 'up':
sense.set_pixels(up)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from sense_hat import SenseHat
from time import sleep
sh = SenseHat()
try:
while True:
north = sh.get_compass()
north = round( north, 1 )
print( "North = %s°" %(north) )
except KeyboardInterrupt:
print( "Exiting..." );
# 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", ""))
#!/usr/bin/python
import time
from sense_hat import SenseHat
sense = SenseHat()
while True:
compass = sense.get_compass()
print ("compass"), compass
print
time.sleep(0.1)
class PiSenseHat(object):
"""Raspberry Pi 'IoT Sense Hat API Driver Class'."""
# Constructor
def __init__(self):
self.sense = SenseHat()
# enable all IMU functions
self.sense.set_imu_config(True, True, True)
# pixel display
def set_pixel(self,x,y,color):
# red = (255, 0, 0)
# green = (0, 255, 0)
# blue = (0, 0, 255)
self.sense.set_pixel(x, y, color)
# clear pixel display
def clear_display(self):
self.sense.clear()
# Pressure
def getPressure(self):
return self.sense.get_pressure()
# Temperature
def getTemperature(self):
return self.sense.get_temperature()
# Humidity
def getHumidity(self):
return self.sense.get_humidity()
def getHumidityTemperature(self):
return self.sense.get_temperature_from_humidity()
def getPressureTemperature(self):
return self.sense.get_temperature_from_pressure()
def getOrientationRadians(self):
return self.sense.get_orientation_radians()
def getOrientationDegrees(self):
return self.sense.get_orientation_degrees()
# degrees from North
def getCompass(self):
return self.sense.get_compass()
def getAccelerometer(self):
return self.sense.get_accelerometer_raw()
def getEnvironmental(self):
sensors = {'name' : 'sense-hat', 'environmental':{}}
return sensors
def getJoystick(self):
sensors = {'name' : 'sense-hat', 'joystick':{}}
return sensors
def getInertial(self):
sensors = {'name' : 'sense-hat', 'inertial':{}}
def getAllSensors(self):
sensors = {'name' : 'sense-hat', 'environmental':{}, 'inertial':{}, 'joystick':{}}
sensors['environmental']['pressure'] = { 'value':self.sense.get_pressure(), 'unit':'mbar'}
sensors['environmental']['temperature'] = { 'value':self.sense.get_temperature(), 'unit':'C'}
sensors['environmental']['humidity'] = { 'value':self.sense.get_humidity(), 'unit': '%RH'}
accel = self.sense.get_accelerometer_raw()
sensors['inertial']['accelerometer'] = { 'x':accel['x'], 'y':accel['y'], 'z': accel['z'], 'unit':'g'}
orientation = self.sense.get_orientation_degrees()
sensors['inertial']['orientation'] = { 'compass':self.sense.get_compass(), 'pitch':orientation['pitch'], 'roll':orientation['roll'], 'yaw': orientation['yaw'], 'unit':'degrees'}
return sensors
class sensors():
def __init__(self):
self.pitch = 0
self.roll = 0
self.yaw = 0
self.heading = 10
self.temp = 0
self.humidity = 0
self.pressure = 0
self.ax = 0
self.ay = 0
self.az = 0
self.altitude = 0
self.send_timer=0
def joinDelimiter(self, arr):
tmp=[None]*len(arr)
for i in range(len(arr)):
tmp[i]=str(arr[i])
return ",".join(tmp)
def getRandomStrArr(self):
pitch = r.randint(3, 5)
roll = r.randint(3, 5)
yaw = r.randint(0, 2)
compass = r.randint(240, 241)
temp = r.randint(19, 20)
humidity = r.randint(43, 46)
pressure = r.randint(983, 985)
ax = 0.1
ay = 0.1
az = 0.1
altitude = 286
return self.joinDelimiter([pitch, roll, yaw, compass, temp, humidity, pressure, ax, ay, az, altitude])
def run(self):
# Comment if not running on RPI
self.sense = SenseHat()
self.sense.clear()
self.sense.set_imu_config(True, True, True)
while True:
self.temp = round(self.sense.get_temperature(), 1)
self.humidity = round(self.sense.get_humidity(), 1)
self.pressure = round(self.sense.get_pressure(), 1)
self.sense.set_imu_config(True, True, True)
orientation = self.sense.get_orientation()
pitch = orientation['pitch']
roll = orientation['roll']
yaw = orientation['yaw']
ax, ay, az = self.sense.get_accelerometer_raw().values()
self.heading = round(self.sense.get_compass(), 1)
if (pitch > 180):
pitch -= 360
self.pitch = round(pitch, 1)
self.roll = round(roll, 1)
self.yaw = round(yaw, 1)
self.ax = round(ax, 2)
self.ay = round(ay, 2)
self.az = round(az, 2)
self.altitude = round((288.15 / -0.0065) * ((self.pressure * 100 / 101325) ** (-(8.31432 * -0.0065) / (9.80665 * 0.0289644)) - 1),1)
"""
self.pitch = r.randint(3, 5)
self.roll = r.randint(3, 5)
self.yaw = r.randint(0, 2)
self.compass = r.randint(240, 241)
self.temp = r.randint(19, 20)
self.humidity = r.randint(43, 46)
self.pressure = r.randint(983, 985)
self.ax = 0.1
self.ay = 0.1
self.az = 0.1
self.altitude = 286
"""
# sensors must initialize
try:
t=time.time()
if(time.time()-self.send_timer>delays.BROWSER):
sensors_publisher.send_string("%s %s" % (topic.SENSOR_TOPIC, self.getString()))
self.send_timer=t
#print(time.time()-t)
except:
print("sensors error")
time.sleep(delays.SENSOR_REFRESH_DELAY)
def getString(self):
return self.joinDelimiter([self.pitch, self.roll, self.yaw, self.heading, self.temp, self.humidity, self.pressure, self.ax, self.ay,
self.az, self.altitude])
# Update values if instance not doint reading with run()
def setValues(self,string):
self.pitch, self.roll, self.yaw, self.heading, self.temp, self.humidity, \
self.pressure, self.ax, self.ay, self.az, self.altitude = [float(x) for x in string.split(',')]
if (self.roll > 180):
self.roll=round(self.roll - 360,1)
"--line",
help="print single line to screen",
action="store_true")
parser.add_argument("-o", "--outfile", help="append to file")
args = parser.parse_args()
fmt = "%Y-%m-%d %H:%M:%S %Z"
now = time.localtime()
sense = SenseHat()
temp = sense.get_temperature()
Fahrenheit = 9.0 / 5.0 * temp + 32
humidity = sense.get_humidity()
pressure = sense.get_pressure()
orientation = sense.get_orientation_degrees()
north = sense.get_compass()
sensedatafmt = "%s %.2fC %.2fF %.2frH %.2fmB"
sensedata = (time.strftime(fmt, now), temp, Fahrenheit, humidity, pressure)
def screenprint():
print("Time: %s" % time.strftime(fmt, now))
print("Temp: %.2f C" % temp)
print("Temp: %.2f F" % Fahrenheit)
print("Humidity: %.2f %%rH" % humidity)
print("Pressure: %.2f Millibars" % pressure)
print("Pitch: {pitch:.2f}, Roll: {roll:.2f}, Yaw: {yaw:.2f}".format(
**orientation))
print("North: %.2f" % north)
led_loop = [
4, 5, 6, 7, 15, 23, 31, 39, 47, 55, 63, 62, 61, 60, 59, 58, 57, 56, 48, 40,
32, 24, 16, 8, 0, 1, 2, 3
]
sense = SenseHat()
sense.set_rotation(0)
sense.clear()
prev_x = 0
prev_y = 0
led_degree_ratio = len(led_loop) / 360.0
while True:
dir = sense.get_compass()
dir_inverted = 360 - dir # So LED appears to follow North
led_index = int(led_degree_ratio * dir_inverted)
offset = led_loop[led_index]
y = offset // 8 # row
x = offset % 8 # column
if x != prev_x or y != prev_y:
sense.set_pixel(prev_x, prev_y, 0, 0, 0)
sense.set_pixel(x, y, 0, 0, 255)
prev_x = x
prev_y = y
class InputModule(AbstractInput):
""" A sensor support class that measures """
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__(input_dev,
testing=testing,
name=__name__)
self.sensor = None
if not testing:
self.initialize_input()
def initialize_input(self):
""" Initialize the Sense HAT sensor class """
from sense_hat import SenseHat
self.sensor = SenseHat()
def get_measurement(self):
""" Get measurements and store in the database """
if not self.sensor:
self.logger.error("Input not set up")
return
self.return_dict = copy.deepcopy(measurements_dict)
if self.is_enabled(0):
try:
self.value_set(0, self.sensor.get_temperature())
except Exception as e:
self.logger.error(
"Temperature (temperature sensor) read failure: {}".format(
e))
if self.is_enabled(1):
try:
self.value_set(1, self.sensor.get_temperature_from_humidity())
except Exception as e:
self.logger.error(
"Temperature (humidity sensor) read failure: {}".format(e))
if self.is_enabled(2):
try:
self.value_set(2, self.sensor.get_temperature_from_pressure())
except Exception as e:
self.logger.error(
"Temperature (pressure sensor) read failure: {}".format(e))
if self.is_enabled(3):
try:
self.value_set(3, self.sensor.get_humidity())
except Exception as e:
self.logger.error("Humidity read failure: {}".format(e))
if self.is_enabled(4):
try:
self.value_set(4, self.sensor.get_pressure())
except Exception as e:
self.logger.error("Pressure read failure: {}".format(e))
if self.is_enabled(5):
try:
self.value_set(5, self.sensor.get_compass())
except Exception as e:
self.logger.error("Compass read failure: {}".format(e))
if self.is_enabled(6) or self.is_enabled(7) or self.is_enabled(8):
magnetism = self.sensor.get_compass_raw()
if self.is_enabled(6):
try:
self.value_set(6, magnetism["x"])
except Exception as e:
self.logger.error(
"Compass raw x read failure: {}".format(e))
if self.is_enabled(7):
try:
self.value_set(7, magnetism["y"])
except Exception as e:
self.logger.error(
"Compass raw y read failure: {}".format(e))
if self.is_enabled(8):
try:
self.value_set(8, magnetism["z"])
except Exception as e:
self.logger.error(
"Compass raw z read failure: {}".format(e))
if self.is_enabled(9) or self.is_enabled(10) or self.is_enabled(11):
gyroscope = self.sensor.get_gyroscope()
if self.is_enabled(9):
try:
self.value_set(9, gyroscope["pitch"])
except Exception as e:
self.logger.error(
"Gyroscope pitch read failure: {}".format(e))
if self.is_enabled(10):
try:
self.value_set(10, gyroscope["roll"])
except Exception as e:
self.logger.error(
"Gyroscope roll read failure: {}".format(e))
if self.is_enabled(11):
try:
self.value_set(11, gyroscope["yaw"])
except Exception as e:
self.logger.error(
"Gyroscope yaw read failure: {}".format(e))
if self.is_enabled(12) or self.is_enabled(13) or self.is_enabled(14):
acceleration = self.sensor.get_accelerometer_raw()
if self.is_enabled(12):
try:
self.value_set(12, acceleration["x"])
except Exception as e:
self.logger.error(
"Acceleration x read failure: {}".format(e))
if self.is_enabled(13):
try:
self.value_set(13, acceleration["y"])
except Exception as e:
self.logger.error(
"Acceleration y read failure: {}".format(e))
if self.is_enabled(14):
try:
self.value_set(14, acceleration["z"])
except Exception as e:
self.logger.error(
"Acceleration z read failure: {}".format(e))
return self.return_dict
from sense_hat import SenseHat
sense = SenseHat()
while True:
bearing = sense.get_compass()
print('Bearing: {:.0f} to North'.format(bearing))
# Creation des threads
#thread_telemeter = tw.Telemeter(TRIG,ECHO)
myranger = rt.ranger_thread(pi, TRIG, ECHO, 0.3)
#thread_logger = l.Logger(sense, myranger)
# Lancement des threads
myranger.start()
#thread_logger.start()
try:
print("waiting initialization sensors")
time.sleep(2)
if ordre=="forward":
Duration=parameter
#front
cap=round(sense.get_compass(),0)
startcap=cap
t=time.time()
while time.time() < t+Duration:
ct.setcolor(sense,"forward")
mt.forwardto(sense,mymotors,LinearTolerance,cap,myranger)
mymotors.stop()
ct.setcolor(sense,"none")
time.sleep(1)
if ordre=="rotateby":
deg=parameter
#rotate 180
ct.setcolor(sense,"turningby")
mt.turnby(sense,mymotors,Tolerance,deg)
mymotors.stop()
#!/usr/bin/python
from sense_hat import SenseHat
sense = SenseHat()
while True:
print(sense.get_compass())
class sensors(Thread):
def __init__(self):
Thread.__init__(self)
self.daemon=True
self.pitch = 0
self.roll = 0
self.yaw = 0
self.compass= 10
self.temp = 0
self.humidity = 0
self.pressure = 0
self.ax = 0
self.ay = 0
self.az = 0
self.altitude = 0
# Comment if not running on RPI
self.sense = SenseHat()
self.sense.clear()
self.sense.set_imu_config(True, True, True)
def joinDelimiter(self, arr):
tmp=[None]*len(arr)
for i in range(len(arr)):
tmp[i]=str(arr[i])
return ",".join(tmp)
def getRandomStrArr(self):
pitch = r.randint(3, 5)
roll = r.randint(3, 5)
yaw = r.randint(0, 2)
compass = r.randint(240, 241)
temp = r.randint(19, 20)
humidity = r.randint(43, 46)
pressure = r.randint(983, 985)
ax = 0.1
ay = 0.1
az = 0.1
altitude = 286
return self.joinDelimiter([pitch, roll, yaw, compass, temp, humidity, pressure, ax, ay, az, altitude])
def run(self):
while True:
self.temp = round(self.sense.get_temperature(), 1)
self.humidity = round(self.sense.get_humidity(), 1)
self.pressure = round(self.sense.get_pressure(), 2)
self.sense.set_imu_config(True, True, True)
pitch, yaw, roll = self.sense.get_orientation().values()
ax, ay, az = self.sense.get_accelerometer_raw().values()
self.compass = round(self.sense.get_compass(), 2)
self.pitch = round(pitch, 2)
self.roll = round(roll, 2)
if (self.pitch > 180):
self.pitch -= 360
if (self.roll > 180):
self.roll -= 360
self.yaw = round(yaw, 2)
self.ax = round(ax, 2)
self.ay = round(ay, 2)
self.az = round(az, 2)
self.altitude = round((288.15 / -0.0065) * ((self.pressure * 100 / 101325) ** (-(8.31432 * -0.0065) / (9.80665 * 0.0289644)) - 1),2)
"""
self.pitch = r.randint(3, 5)
self.roll = r.randint(3, 5)
self.yaw = r.randint(0, 2)
self.compass = r.randint(240, 241)
self.temp = r.randint(19, 20)
self.humidity = r.randint(43, 46)
self.pressure = r.randint(983, 985)
self.ax = 0.1
self.ay = 0.1
self.az = 0.1
self.altitude = 286
"""
time.sleep(REFRESH_DELAY)
def getStrArr(self):
return self.joinDelimiter([self.pitch, self.roll, self.yaw, self.compass, self.temp, self.humidity, self.pressure, self.ax, self.ay,
self.az, self.altitude])
def getTuple(self):
return (self.getStrArr(),'')
camera.capture('photos/image%s.jpg' % (count - 1))
#enviornmental sensors
humidity = fedora.get_humidity()
temp = fedora.get_temperature()
temp_from_humidity = fedora.get_temperature_from_humidity()
temp_from_pressure = fedora.get_temperature_from_pressure()
pressure = fedora.get_pressure()
#get orientation
orientation = fedora.get_orientation()
orientation_pitch = orientation.get('pitch')
orientation_roll = orientation.get('roll')
orientation_yaw = orientation.get('yaw')
#get compass
compass = fedora.get_compass()
#get gyroscope
gyro = fedora.get_gyroscope()
gyro_pitch = gyro.get('pitch')
gyro_roll = gyro.get('roll')
gyro_yaw = gyro.get('yaw')
#get accelerometer
accelerometer = fedora.get_accelerometer()
accelerometer_pitch = accelerometer.get('pitch')
accelerometer_roll = accelerometer.get('roll')
accelerometer_yaw = accelerometer.get('yaw')
#write to csv
with open("atmosphere.csv", 'a') as atm:
print(
"************************ 1 second pass ******************************"
)
# Enabling Magnetometer (compass), Gyroscope and Accelerometer
sense.set_imu_config(True, True, True)
# Getting orientation data
orientation = sense.get_orientation()
orientationRadians = sense.get_orientation_radians()
orientationDegrees = sense.get_orientation_degrees()
# Getting magnetometer data
magnetometerRaw = sense.get_compass_raw()
magnetometerNorth = sense.get_compass()
# Getting gyroscope data
gyroscopeRaw = sense.get_gyroscope_raw()
gyroscope = sense.get_gyroscope()
# Getting accelerometer data
accelerometerRaw = sense.get_accelerometer_raw()
accelerometer = sense.get_accelerometer()
# Printing orientation data
print("**************** ORIENTATION DATA ***********************")
print("p: {pitch}, r: {roll}, y: {yaw}".format(**orientation))
print("p: {pitch}, r: {roll}, y: {yaw}".format(**orientationRadians))
print("p: {pitch}, r: {roll}, y: {yaw}".format(**orientationDegrees))
from sense_hat import SenseHat
import time
sh = SenseHat()
while True:
# 磁気センサの生データ。Dicitonary型
raw = sh.get_compass_raw()
x_val = round(float(raw['x']),2)
y_val = round(float(raw['y']),2)
z_val = round(float(raw['z']),2)
# 北からの位置を取得。加速度センサと磁気センサの値から計算している。範囲は0〜360、単位は度。0が北、180が南。
# 値はゆっくり変化していく、方位磁石のほうが精度が良い
north = sh.get_compass()
print("North: %s (x=%s, y=%s, z=%s)" %(north, x_val, y_val, z_val))
time.sleep(1)
SH_temp = sense.get_temperature() # value in degrees C
SH_pressure = sense.get_pressure() * 100 # convert output from millibars to Pascals for consistency
SH_humidity = sense.get_humidity() # % relative humidity
# Orientation
sense.set_imu_config(True,True,True) # Enable compass, gyro, and accelerometer
SH_orientation = sense.get_orientation() # orientation of pitch, roll, yaw axes in degrees
SH_orientation_x = SH_orientation.get('x')
SH_orientation_y = SH_orientation.get('y')
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
# The calibration program will produce the file RTIMULib.ini
# Copy it into the same folder as your Python code
led_loop = [4, 5, 6, 7, 15, 23, 31, 39, 47, 55, 63, 62, 61, 60, 59, 58, 57, 56, 48, 40, 32, 24, 16, 8, 0, 1, 2, 3]
sense = SenseHat()
sense.set_rotation(0)
sense.clear()
prev_x = 0
prev_y = 0
led_degree_ratio = len(led_loop) / 360.0
while True:
dir = sense.get_compass()
dir_inverted = 360 - dir # So LED appears to follow North
led_index = int(led_degree_ratio * dir_inverted)
offset = led_loop[led_index]
y = offset // 8 # row
x = offset % 8 # column
if x != prev_x or y != prev_y:
sense.set_pixel(prev_x, prev_y, 0, 0, 0)
sense.set_pixel(x, y, 0, 0, 255)
prev_x = x
prev_y = y
from sense_hat import SenseHat sense = SenseHat() humidity = round(sense.get_humidity(), 2) temp = round(sense.get_temperature(), 2) pressure = round(sense.get_pressure(), 2) north = round(sense.get_compass(), 2) print(humidity) print(temp) print(pressure) print(north)
# set the interval between each iteraction.
# The interval is configured to 0 by default
DATA_INTERVAL = 0
while True:
try:
# Blink a let before each sensor read
if DATA_INTERVAL > 0:
blink_led()
acceleration = sense.get_accelerometer_raw()
x = acceleration['x']
y = acceleration['y']
z = acceleration['z']
direction = sense.get_compass()
# create the message (JSON format)
payload = '{{ "timestamp": {}, "device_id": "{}", "accel_x":{}, "accel_y":{}, "accel_z":{}, "direction":{} }}'.format(
int(time.time()), device_id, x, y, z, direction)
# send the data to the Cloud
client.publish(_MQTT_TOPIC, payload, qos=1)
# Print the event (just for debugging)
print("{}\n".format(payload))
if DATA_INTERVAL > 0:
time.sleep(DATA_INTERVAL)
except KeyboardInterrupt:
# Stop the Googgle Cloud Client when CTRL+C was pressed
sh.set_pixels(locked_screen)
### unlock function ###
def unlock():
"""unlocking function"""
sh.set_pixels(unlocked_screen)
sleep(2)
sh.show_message("You have unlocked it!!")
### locks ###
while True:
if round(sh.get_humidity()) >= 50:
unlocked1 = True
if unlocked1 == True and round(int(sh.get_compass())):
unlocked2 = True
if unlocked2 == True and round(sh.get_temperature()) >= 26:
unlocked3 = True
if unlocked3 == True and round(int(sh.get_accelerometer()['roll'])) >= 57:
unlocked4 = True
unlock()
quit()
