def get_sense_hat_data():
sense_hat_data = {
'pressure': 993,
'temperature': 21,
'temperatureFromPressure': 21,
'humidity': 30,
'pitch': 0,
'roll': 0,
'yaw': 0,
'cpuTemp': 46
}
if not env.bool('IS_RASPBERRY_PI') or importlib.util.find_spec("sense_hat") is None:
return sense_hat_data
from sense_hat import SenseHat
sense = SenseHat()
sense_hat_data['pressure'] = sense.get_pressure()
sense_hat_data['temperature'] = sense.get_temperature()
sense_hat_data['temperatureFromPressure'] = sense.get_temperature_from_pressure()
sense_hat_data['humidity'] = sense.get_humidity()
sense_hat_data['pitch'] = sense.get_orientation()['pitch']
sense_hat_data['roll'] = sense.get_orientation()['roll']
sense_hat_data['yaw'] = sense.get_orientation()['yaw']
sense_hat_data['cpuTemp'] = get_cpu_temp()
return sense_hat_data
def tempCalibration():
# Get CPU temperature.
def get_cpu_temp():
res = os.popen("vcgencmd measure_temp").readline()
return float(res.replace("temp=", "").replace("'C\n", ""))
# Use moving average to smooth readings.
def get_smooth(x):
if not hasattr(get_smooth, "t"):
get_smooth.t = [x, x, x]
get_smooth.t[2] = get_smooth.t[1]
get_smooth.t[1] = get_smooth.t[0]
get_smooth.t[0] = x
return (get_smooth.t[0] + get_smooth.t[1] +
get_smooth.t[2]) / 3
sense = SenseHat()
t1 = sense.get_temperature_from_humidity()
t2 = sense.get_temperature_from_pressure()
t_cpu = get_cpu_temp()
h = sense.get_humidity()
p = sense.get_pressure()
# Calculates the real temperature compesating CPU heating.
t = (t1 + t2) / 2
t_corr = t - ((t_cpu - t) / 1.5)
t_corr = get_smooth(t_corr)
return t_corr
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
def get_readings():
sense = SenseHat()
humidity = sense.get_humidity()
temp_h = sense.get_temperature_from_humidity()
temp_p = sense.get_temperature_from_pressure()
pressure = sense.get_pressure()
return [humidity, temp_h, pressure, temp_p]
def get_data():
conn = sqlite3.connect(dbname)
curs = conn.cursor()
while True:
for row in curs.execute("SELECT * FROM Device"):
device_address = None
nearby_devices = bluetooth.discover_devices()
for mac_address in nearby_devices:
if row[1] == bluetooth.lookup_name(mac_address, timeout=5):
device_address = mac_address
break
if device_address is not None:
print("Hi {}! Your device ({}) has the MAC address: {}".format(
row[0], row[1], device_address))
sense = SenseHat()
get_cpu_temp = os.popen("vcgencmd measure_temp").readline()
cpu_temp = float(
get_cpu_temp.replace("temp=", "").replace("'C\n", ""))
temp_h = sense.get_temperature_from_humidity()
temp_p = sense.get_temperature_from_pressure()
avgtemp = (temp_h + temp_p) / 2
curr_temp = avgtemp - ((cpu_temp - avgtemp) / 1.5)
temp = round(curr_temp, 1)
humid = sense.get_humidity()
sense.show_message("Hi {}! Current Temp is {}*c".format(
row[0], temp),
scroll_speed=0.05)
sense.show_message("Current Humidity is {}%".format(
round(humid, 1), ),
scroll_speed=0.05)
else:
print("Looking for device...")
conn.close()
def readSensor(self): from sense_hat import SenseHat senseHat = SenseHat() self.humidity = senseHat.get_humidity() self.tempH = senseHat.get_temperature_from_humidity() self.pressure = senseHat.get_pressure() + PRESSURE_OFFSET self.tempP = senseHat.get_temperature_from_pressure() self.mesureTime = time.time()
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 Sensor :
def __init__(self) :
self.sensor_id = "sensor hat"
self.fileplace = 'tempplace.conf'
self.total_count = 0
self.device_file = "/dev/null"
self.sense = SenseHat()
self.place = self.readplacename()
def reinit(self) :
self.__init__()
def sensorid(self) :
return self.sensor_id
def total_count(self) :
return self.total_count
def placename(self):
return self.place
def setplacename(self, name):
self.place = setplace_db(name)
def readplacename(self):
self.place = getplace_db()
return self.place
def read_temp(self):
temp = "null"
tt = self.sense.get_temperature()
th = self.sense.get_temperature_from_humidity()
tf = self.sense.get_temperature_from_pressure()
tf = float(tt)
tf = tf - 10.0 # Fattore di correzione
tt = round(tt, 2)
tc = round(tf, 2)
th = round(th, 2)
tf = round(tf, 2)
self.total_count += 1
return str(tc)
def read_pressure(self):
p = self.sense.get_pressure()
p = round(p, 2)
self.total_count += 1
return str(p)
def read_humidity(self):
h = self.sense.get_humidity()
h = round(h, 2)
self.total_count += 1
return str(h)
def sensordebug(self):
return 'Sense Hat'
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
def __calibrateTemperature(self):
sense = SenseHat()
t1 = sense.get_temperature_from_humidity()
t2 = sense.get_temperature_from_pressure()
t_cpu = self.__getCPUTemperature()
t = (t1 + t2) / 2
t_corr = t - ((t_cpu - t) / 1.5)
t_corr = round(t_corr,1)
return t_corr
class Hat(object):
''' `sensed` sensor module for the Raspberry Pi Sense HAT. This
module returns a dictionary of all built in sensors. '''
def __init__(self, config: DotMap) -> None:
if config.sensed.test is not True:
from sense_hat import SenseHat
self.sense = SenseHat()
def get_data(self) -> dict:
# Environmental sensors
humid = self.sense.humidity
temp = self.sense.temperature
temp_h = self.sense.get_temperature_from_humidity()
temp_p = self.sense.get_temperature_from_pressure()
press = self.sense.pressure
# IMU (inertial measurement unit) sensors
orient_r = self.sense.orientation_radians
orient_d = self.sense.orientation
compass = self.sense.compass
compass_r = self.sense.compass_raw
gyro = self.sense.gyroscope
gyro_r = self.sense.gyroscope_raw
accel = self.sense.accelerometer
accel_r = self.sense.accelerometer_raw
return {'environment': {'humidity': humid,
'temperature': temp,
'temperature_h': temp_h,
'temperature_p': temp_p,
'pressure': press},
'imu': {'orientation_rad': orient_r,
'orientation_deg': orient_d,
'compass': compass,
'compass_r': compass_r,
'gyroscope': gyro,
'gyroscope_r': gyro_r,
'accelerometer': accel,
'accelerometer_raw': accel_r}}
def test(self) -> dict:
return {'environment': {'humidity': 1,
'temperature': 2,
'temperature_h': 3,
'temperature_p': 4,
'pressure': 5},
'imu': {'orientation_rad': 6,
'orientation_deg': 7,
'compass': 8,
'compass_r': 9,
'gyroscope': 10,
'gyroscope_r': 11,
'accelerometer': 12,
'accelerometer_raw': 13}}
def getInfoConfig():
sense = SenseHat()
info = {
"date": time.ctime(),
"temp": sense.temp,
"humidity": sense.humidity,
"temperature_from_humidity": sense.get_temperature_from_humidity(),
"temperature_from_pressure": sense.get_temperature_from_pressure(),
"pressure": sense.pressure
}
return json.dumps(info)
class _SenseHat:
def __init__(self, board_object, colour=""):
self.board = board_object
self.colour = colour
self.sense = SenseHat()
def magnetometer_on(self):
self.sense.set_imu_config(True, False, False) # gyroscope only
@property
def temp_c(self):
return (self.sense.get_temperature_from_humidity() +
self.sense.get_temperature_from_pressure())/2
@property
def pressure(self):
return self.sense.pressure
@property
def humidity(self):
return self.sense.humidity
def led_all(self, colour):
lcd = []
for i in range(0, 64):
lcd.append(colour)
self.sense.set_pixels(lcd)
def led_1(self, colour):
self.sense.set_pixel(0, 0, colour)
self.sense.set_pixel(0, 1, colour)
self.sense.set_pixel(1, 0, colour)
self.sense.set_pixel(1, 1, colour)
def led_2(self, colour):
self.sense.set_pixel(2, 2, colour)
self.sense.set_pixel(2, 3, colour)
self.sense.set_pixel(3, 2, colour)
self.sense.set_pixel(3, 3, colour)
def led_3(self, colour):
self.sense.set_pixel(4, 4, colour)
self.sense.set_pixel(4, 5, colour)
self.sense.set_pixel(5, 4, colour)
self.sense.set_pixel(5, 5, colour)
def led_4(self, colour):
self.sense.set_pixel(6, 6, colour)
self.sense.set_pixel(6, 7, colour)
self.sense.set_pixel(7, 6, colour)
self.sense.set_pixel(7, 7, colour)
def clear(self):
self.sense.clear()
class SenseHatSensor:
def __init__(self):
self.__sense = SenseHat()
def __tempFromHumiditySensor(self):
return self.__sense.get_temperature_from_humidity()
def __tempFromPressureSensor(self):
return self.__sense.get_temperature_from_pressure()
def getTemperature(self):
return ((self.__tempFromPressureSensor() + self.__tempFromHumiditySensor()) / 2)
def main():
sense = SenseHat()
tem_pressure = sense.get_temperature_from_pressure()
tem_humidity = sense.get_temperature_from_humidity()
tem = (tem_humidity + tem_pressure) / 2
hum = sense.get_humidity()
air = sense.get_pressure()
print json.dumps({
'temperature': tem,
'humidity': hum,
'air_pressure': air
})
def get_temp():
"""Reads current temperature from sensor"""
# Initialize SenseHat
sense = SenseHat()
temp = 0.0
# Check if last measurement exists, used to detect possible measurement error when call the sensor
last_temp = -100.0
if os.path.isfile(FILE_PATH):
last_temp_f = open(FILE_PATH, "r")
last_temp = float(last_temp_f.readline())
last_temp_f.close()
tries = 0 # If detected measurement error, tries counter to accept the measurement as valid
# Algorithm to adjust impact of the CPU temp on the temperature sensor readings
while abs(last_temp - temp) > ERROR_TRESHOLD and tries < TRIES:
# We need two continuous measures because first measurement uses to fail
p = sense.get_temperature_from_pressure()
h = sense.get_temperature_from_humidity()
p = sense.get_temperature_from_pressure()
h = sense.get_temperature_from_humidity()
# Calculates temperature
with CPUTemp() as cpu_temp:
c = cpu_temp.get_temperature()
temp = round(((p + h) / 2) - (c / 7), 1)
# Check if possible measurement error and wait 5 seconds to try again
if abs(last_temp - temp) > ERROR_TRESHOLD:
sleep(WAIT_SECONDS)
tries += 1
# If we did a wrong measurement, use the last measurement as current measurement
# (if last_temp == -100, first measure from reboot)
if (math.isnan(temp) or temp == 0.0
or abs(last_temp - temp) > ERROR_TRESHOLD) and last_temp != -100:
update_state(last_temp) # Save measurement and call API to update
return last_temp
update_state(temp) # Save measurement and call API to update
return temp
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):
sense = SenseHat()
sense.clear()
res = os.popen("vcgencmd measure_temp").readline()
temp_cpu = float(res.replace("temp=", "").replace("'C\n", ""))
t1 = sense.get_temperature_from_humidity()
t2 = sense.get_temperature_from_pressure()
temp = (t1 + t2) / 2
correctedTemp = temp - ((temp_cpu - temp) / 1.5)
self.__temperature = round(correctedTemp)
self.__humidity = round(sense.get_humidity())
def update(self):
"""Get the latest data from Sense HAT."""
from sense_hat import SenseHat
sense = SenseHat()
temp_from_h = sense.get_temperature_from_humidity()
temp_from_p = sense.get_temperature_from_pressure()
t_cpu = get_cpu_temp()
t_total = (temp_from_h + temp_from_p) / 2
t_correct = t_total - ((t_cpu - t_total) / 1.5)
t_correct = get_average(t_correct)
self.temperature = t_correct
self.humidity = sense.get_humidity()
self.pressure = sense.get_pressure()
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 read_data():
sense = SenseHat()
t1 = sense.get_temperature_from_humidity()
t2 = sense.get_temperature_from_pressure()
t_cpu = get_cpu_temp()
p = sense.get_pressure()
h = sense.get_humidity()
p = round(p, 1)
h = round(h, 1)
t = (t1 + t2) / 2
t_corr = t - ((t_cpu - t) / 1.5)
t_corr = round(t_corr, 1)
return t_corr, p, h
def update(self):
"""Get the latest data from Sense HAT."""
from sense_hat import SenseHat
sense = SenseHat()
temp_from_h = sense.get_temperature_from_humidity()
temp_from_p = sense.get_temperature_from_pressure()
t_cpu = get_cpu_temp()
t_total = (temp_from_h + temp_from_p) / 2
t_correct = t_total - ((t_cpu - t_total) / 1.5)
t_correct = get_average(t_correct)
self.temperature = t_correct
self.humidity = sense.get_humidity()
self.pressure = sense.get_pressure()
class SenseHatCollector():
""" This sets up a custom collector for the SenseHat """
def __init__(self, orientation=False):
self.sense = SenseHat()
self.orientation = orientation
@REQUEST_TIME.time()
def collect(self):
""" Collect our metrics from the SenseHat """
log.info('collecting metrics')
temperature = self.sense.get_temperature()
humidity = self.sense.get_humidity()
pressure = self.sense.get_pressure()
temperature_from_humidity = self.sense.get_temperature_from_humidity()
temperature_from_pressure = self.sense.get_temperature_from_pressure()
metric = Metric('rpi_sensehat', 'sensehat metric values', 'gauge')
metric.add_sample('rpi_sensehat_temperature',
value=temperature,
labels={'name': 'SenseHat Temperature'})
metric.add_sample(
'rpi_sensehat_temperature_from_humidity',
value=temperature_from_humidity,
labels={'name': 'SenseHat Temperature from humidity sensor'})
metric.add_sample(
'rpi_sensehat_temperature_from_pressure',
value=temperature_from_pressure,
labels={'name': 'SenseHat Temperature from pressure sensor'})
metric.add_sample('rpi_sensehat_humidity',
value=humidity,
labels={'name': 'SenseHat Humidity'})
metric.add_sample('rpi_sensehat_pressure',
value=pressure,
labels={'name': 'SenseHat Pressure'})
if self.orientation:
roll = self.sense.orientation['roll']
yaw = self.sense.orientation['yaw']
pitch = self.sense.orientation['pitch']
metric.add_sample('rpi_sensehat_roll',
value=roll,
labels={'name': 'SenseHat Roll'})
metric.add_sample('rpi_sensehat_yaw',
value=yaw,
labels={'name': 'SenseHat Yaw'})
metric.add_sample('rpi_sensehat_pitch',
value=pitch,
labels={'name': 'SenseHat Pitch'})
yield metric
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 main():
sense = SenseHat()
conditions = get_conditions()
if ('current_observation' not in conditions):
print "Error! Wunderground API call failed, check your STATE and CITY and make sure your Wunderground API key is valid!"
if 'error' in conditions['response']:
print "Error Type: " + conditions['response']['error']['type']
print "Error Description: " + conditions['response']['error']['description']
exit()
else:
print('Connected to Wunderground')
while True:
# -------------- Sense Hat --------------
#temp_c = sense.get_temperature()
#humidity = sense.get_humidity()
#pressure_mb = sense.get_pressure()
t1 = sense.get_temperature_from_humidity()
t2 = sense.get_temperature_from_pressure()
t_cpu = get_cpu_temp()
humidity = round(sense.get_humidity(),1)
p = round(sense.get_pressure(),1)
t = (t1+t2)/2
t_corr = t - ((t_cpu-t)/1.5)
t_corr = get_smooth(t_corr)
temp_f = round(1.8 * round(t_corr, 1) + 32)
# -------------- Wunderground --------------
conditions = get_conditions()
if ('current_observation' not in conditions):
print "Error! Wunderground API call failed. Skipping a reading then continuing ..."
else:
humidity_pct = conditions['current_observation']['relative_humidity']
o_humidity = float(humidity_pct.replace("%",""))
o_temp = float(conditions['current_observation']['temp_f'])
wind_mph = float(conditions['current_observation']['wind_mph'])
ts = calendar.timegm(time.gmtime())
print("temp=%.1f Outside Temp=%.1f Humidity%1f Outside Humidity=%.1f time=%.1f" % (temp_f, o_temp, humidity, o_humidity, ts))
sense.show_message("Temperature F: " + str(temp_f) + " Humidity: " + str( humidity))
delay_s = 14400
sensor_sn = '0000001'
topic = 'myrpi/' + sensor_sn
# write to AWS
msg1 = '"device_id": "{:s}", "timestamp":"{}", "inside temp": "{}", "outside temp": "{}"'.format(sensor_sn, ts, temp_f, o_temp)
msg2 = '"inside humidity":"{}", "outside humidity":"{}","wind":"{}"'.format(humidity, o_humidity, wind_mph)
msg = '{'+msg1+','+msg2+'}'
myMQTTClient.publish(topic, msg, 1)
topic = 'myrpi/' + sensor_sn
time.sleep(delay_s)
def update(self):
"""Get the latest data from Sense HAT."""
from sense_hat import SenseHat
sense = SenseHat()
temp_from_h = sense.get_temperature_from_humidity()
temp_from_p = sense.get_temperature_from_pressure()
t_cpu = get_cpu_temp()
t_total = (temp_from_h + temp_from_p) / 2
t_correct = t_total - ((t_cpu - t_total) / 1.5)
t_correct = get_average(t_correct)
self.temperature = t_correct
self.humidity = sense.get_humidity()
self.pressure = sense.get_pressure()
_LOGGER.debug('Throttle(MIN_TIME_BETWEEN_UPDATES)={}'.format(
MIN_TIME_BETWEEN_UPDATES))
def dump_sense_hat_data():
log('getting sense hat data')
sense = SenseHat()
sense.clear()
return {
'timestamp': datetime.utcnow().isoformat() + 'Z',
'provider': 'Sense Hat',
'humidity': sense.get_humidity(), # percent
'pressure': sense.get_pressure(), # millibars
'temperature': c_to_f(sense.get_temperature()),
'temperature_from_humidity':
c_to_f(sense.get_temperature_from_humidity()),
'temperature_from_pressure':
c_to_f(sense.get_temperature_from_pressure()),
}
def getSenseHatData():
sense = SenseHat()
t1 = sense.get_temperature_from_humidity()
t2 = sense.get_temperature_from_pressure()
temp_cpu = get_cpu_temp()
humidity = sense.get_humidity()
# calculates the real temperature compesating CPU heating
t = (t1+t2)/2
temp_corr = t - ((temp_cpu-t)/1.5)
temp_corr = get_smooth(temp_corr)
if temp_corr is not None:
temp_corr = round(temp_corr, 1)
if humidity is not None:
humidity = round(humidity, 1)
logData (temp_corr, humidity)
def get_temp_hum():
# Initialize the sensehat object
sense = SenseHat()
# Get the temperature
t1 = sense.get_temperature_from_humidity()
t2 = sense.get_temperature_from_pressure()
# Get the CPU temperature
t_cpu = environment.get_cpu_temp()
# Get humidity
h = sense.get_humidity()
#p = sense.get_pressure()
# Calculates the real temperature compesating CPU heating.
t = (t1 + t2) / 2
t_corr = t - ((t_cpu - t) / 1.5)
if environment.check_valid_data(t,h)==False:
return environment.get_temp_hum
return round(t_corr), round(h)
def temp():
sense = SenseHat()
sense.clear()
celcius = round(sense.get_temperature())
humidity = round(sense.get_humidity())
pressure = round(sense.get_pressure())
temp_from_pressure = round(sense.get_temperature_from_pressure())
climate = {
'temp': celcius,
'temp_from_pressure': temp_from_pressure,
'humidity': humidity,
'pressure': pressure
}
return render_template('temp.html',
title='Current climate',
climate=climate)
class SenseController:
def __init__(self):
self.sense = SenseHat()
def __enter__(self):
self.clear()
return self
def __exit__(self, type, value, traceback):
self.clear()
def clear(self):
self.sense.clear()
def get_data(self):
orientation_time = time.time()
orientation = self.sense.get_orientation_degrees()
compass_time = time.time()
compass = self.sense.get_compass_raw()
acceleration_time = time.time()
acceleration = self.sense.get_accelerometer_raw()
return [
# Environmental sensors
(time.time(), "humidity", self.sense.get_humidity()),
(time.time(), "pressure", self.sense.get_pressure()),
(time.time(), "temperature_from_humidity",
self.sense.get_temperature()),
(time.time(), "temperature_from_pressure",
self.sense.get_temperature_from_pressure()),
# IMU sensors
(orientation_time, "orientation.pitch", orientation['pitch']),
(orientation_time, "orientation.roll", orientation['roll']),
(orientation_time, "orientation.yaw", orientation['yaw']),
(compass_time, "compass.x", compass['x']),
(compass_time, "compass.y", compass['y']),
(compass_time, "compass.z", compass['z']),
(acceleration_time, "accelerometer.x", acceleration['x']),
(acceleration_time, "accelerometer.y", acceleration['y']),
(acceleration_time, "accelerometer.z", acceleration['z'])
]
def show_message(self, message):
self.sense.show_message(message, text_colour=[0, 64, 0])
def sensor_active(self):
sense = SenseHat()
sense.clear()
pressure = round(sense.get_pressure(), 2)
humidity = round(sense.get_humidity(), 2)
temp_humi = round(sense.get_temperature_from_humidity(), 2)
temp_press = round(sense.get_temperature_from_pressure(), 2)
orien = sense.get_orientation()
pitch = round(orien['pitch'], 3)
roll = round(orien['roll'], 3)
yaw = round(orien['yaw'], 3)
self.temp_lcd.display(temp_press)
self.humi_lcd.display(humidity)
self.pitch_lcd.display(pitch)
self.roll_lcd.display(roll)
self.yaw_lcd.display(yaw)
class TemperatureEventEmitter(EventEmitter):
def __init__(self, servers, topic, identifier):
EventEmitter.__init__(self, servers, topic)
self.contents = dict()
self.contents["id"] = identifier
self.event["@timestamp"] = datetime.utcnow()
self.event["data"] = self.contents
self.sense = SenseHat()
def update_event(self):
self.event["@timestamp"] = datetime.utcnow()
self.event["data"]["temperature"] = round( (self.sense.get_temperature_from_pressure()+self.sense.get_temperature_from_humidity())/2,1)
self.event["data"]["pressure"] = round(self.sense.get_pressure(),1)
self.event["data"]["humidity"] = round(self.sense.get_humidity(),1)
self.send()
def update(self):
"""Get the latest data from Sense HAT."""
sense = SenseHat()
temp_from_h = sense.get_temperature_from_humidity()
temp_from_p = sense.get_temperature_from_pressure()
t_total = (temp_from_h + temp_from_p) / 2
if self.is_hat_attached:
t_cpu = get_cpu_temp()
t_correct = t_total - ((t_cpu - t_total) / 1.5)
t_correct = get_average(t_correct)
else:
t_correct = get_average(t_total)
self.temperature = t_correct
self.humidity = sense.get_humidity()
self.pressure = sense.get_pressure()
def notify():
while True:
sense = SenseHat()
get_cpu_temp = os.popen("vcgencmd measure_temp").readline()
cpu_temp = float(get_cpu_temp.replace("temp=","").replace("'C\n",""))
temp_h = sense.get_temperature_from_humidity()
temp_p = sense.get_temperature_from_pressure()
avgtemp = (temp_h+temp_p)/2
curr_temp = avgtemp - ((cpu_temp-avgtemp)/1.5)
curr_temp = round(curr_temp, 1)
if curr_temp < 20:
send_notification_via_pushbullet("Notification", "The current temperature is " + str(curr_temp) + "*C, remember to bring a sweater!")
elif 20<= curr_temp <= 30:
send_notification_via_pushbullet("Notification", "The current temperature is " + str(curr_temp) + "*C, what a nice weather!")
else:
send_notification_via_pushbullet("Notification", "The current temperature is " + str(curr_temp) + "*C, wow it's hot today!")
time.sleep(60*60*4)
class Sense():
'''
This class has methods to connect and get sensor values
from SenseHat
'''
def __init__(self):
self.clearFlag = False
self.sens = SenseHat()
print("Sense Hat object successfully created")
def clear(self):
self.sens.clearFlag = True
def get_humidity(self):
return self.sens.get_humidity()
def get_temperature(self):
return self.sens.get_temperature_from_humidity()
def get_temperature_from_humidity(self):
return self.sens.get_temperature_from_humidity()
def get_temperature_from_pressure(self):
return self.sens.get_temperature_from_pressure()
def get_pressure(self):
return self.sens.get_pressure()
def show_letter(self, val):
self.sens.show_letter(val)
def get_light_intensity(self):
lit = 0
tim = random.randint(0, 24)
if (tim > 10 and tim < 16):
lit = random.randint(1075, 107527)
else:
lit = random.randint(0, 1075)
return lit
def show_message(self, msg):
self.sens.show_message(str(msg))
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
def get_current_data():
if(enable_sense_hat):
sense = SenseHat()
sense.clear()
t = sense.get_temperature()
p = sense.get_pressure()
h = sense.get_humidity()
tp = sense.get_temperature_from_pressure()
data = {
'temperature':str(round(t, 1)),
'pressure':str(round(p,1)),
'humidity':str(round(h,1)),
'temperatureP':str(round(tp,1)),
'datetime' : datetime.now()
}
else:
data = {
'temperature': 0,
'pressure':0,
'humidity':0,
'temperatureP':0,
'datetime' : datetime.now()
}
return data
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from sense_hat import SenseHat
from time import sleep
sh = SenseHat()
try:
while True:
th = sh.get_temperature()
tp = sh.get_temperature_from_pressure()
p = sh.get_pressure()
h = sh.get_humidity()
th = round( th, 1 )
tp = round( tp, 1 )
p = round( p, 1 )
h = round( h, 1 )
print( "Temp (H) = %s°C Temp (P) = %s°C Prsr = %smb Hmdt = %s%%" %(th,tp,p,h) )
sleep( 1 )
except KeyboardInterrupt:
print( "Exiting..." );
from evdev import InputDevice, ecodes,list_devices
from select import select
from geopy.geocoders import Nominatim
import forecastio
from sense_hat import SenseHat
from espeak import espeak
import os
import time
#Initialize Sense Hat
sense = SenseHat()
tFromHumidity = sense.get_temperature_from_humidity()
tFromPressure = sense.get_temperature_from_pressure()
print tFromHumidity*0.67
print tFromPressure
print sense.get_temperature()
print sense.get_pressure()
#Get latitude and longitude based on city and country
geolocator = Nominatim()
location = geolocator.geocode("<CITY COUNTRY>")
#Forcastio settings
api_key = "<FORECAST.IO API KEY>"
lat = location.latitude
lng = location.longitude
#Load forcast
forecast = forecastio.load_forecast(api_key, lat, lng, units="si")
currently = forecast.currently()
class DataCollector:
COLOR = [95, 189, 242]
TIME_FORMAT = '%Y-%m-%d:%H:%M'
field_names = ['date', 'temp', 'temp_press', 'humidity', 'pressure']
def __init__(self, filename, samples=3, sample_time=1, no_append=False):
self._filename = filename
self._no_append = no_append
self._sample_time = sample_time
self._samples = int(samples) if samples and (samples and 1 <= samples < 100) else 3
self._field_names = DataCollector.field_names + DataCollector.field_names + ['{}{}'.format(name, i) for name in
DataCollector.field_names for i in
range(self._samples)]
self._sense = SenseHat()
self._write_header()
self._sense.show_message("Start!", scroll_speed=0.2, text_colour=DataCollector.COLOR)
print("Collecting data at {}".format(strftime(DataCollector.TIME_FORMAT)), file=sys.stderr)
def _write_header(self):
if not exists(self._filename) or not isfile(self._filename):
with smart_open(self._filename, no_append=True) as f:
fcsv = csv.DictWriter(f, delimiter=',', fieldnames=self._field_names)
fcsv.writeheader()
f.flush()
def _get_sample(self):
# Check if samples and sample_time are realistic,else the script will take forever to produce data.
dt = self._sample_time if 1 <= self._sample_time < 3 else 1
temp_data = defaultdict(list)
for _ in range(self._samples):
temp_data['date'].append(time())
temp_data['humidity'].append(self._sense.humidity)
temp_data['temp'].append(self._sense.temperature)
temp_data['temp_press'].append(self._sense.get_temperature_from_pressure())
temp_data['pressure'].append(self._sense.pressure)
sleep(dt)
return temp_data
def _mean_sample(self, data_raw):
result_data = {}
for key, value in data_raw.items():
result_data[key] = mean(value)
return result_data
def _procces_raw(self, data_raw):
raw = {}
for key, value in data_raw.items():
for i in range(len(value)):
raw["{}{}".format(key, i)] = value[i]
return raw
def sample(self):
print("Start Sampling at {}".format(strftime(DataCollector.TIME_FORMAT + ':%S')), file=sys.stderr)
self._sense.show_message("Sample!", scroll_speed=0.075, text_colour=DataCollector.COLOR)
with smart_open(self._filename, no_append=self._no_append) as f:
fcsv = csv.DictWriter(f, delimiter=',', fieldnames=self._field_names)
raw_data = self._get_sample()
mean_data = self._mean_sample(raw_data)
mean_data.update(self._procces_raw(raw_data))
mean_data['date'] = strftime(DataCollector.TIME_FORMAT)
fcsv.writerow(mean_data)
f.flush()
def monitor(self, interval, max_intervals=-1):
"""
Collect sensor data with intervals in seconds. And if it has to stop after n intervals
set max_intervals.
:param interval: integer
:param max_intervals: integer
:return:
"""
# Check if interval is realistic,else the script will take forever to produce data.
# to exclude almost everlasting invervals the biggest interval is two days. default each hour.
dt = interval if interval and 1 <= interval < (2 * 24 * 60 * 60) else (15 * 60)
if self._no_append:
self._no_append = True
i = 0
while max_intervals < 0 or i < max_intervals:
self.sample()
sleep(interval)
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
question_mark = [
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)
class Reading:
def __init__(self):
# initialize sense hat
self.sense = SenseHat()
self.sense.clear()
def getReading(self):
# get temperature from humidity
t1 = self.sense.get_temperature_from_humidity()
# get temperature from pressure
t2 = self.sense.get_temperature_from_pressure()
# get cpu temperature
t_cpu = self.get_cpu_temp()
# average temperature from humidity and pressure
t = (t1+t2)/2
# normalize temperature with cpu temperature
t_corr = t - ((t_cpu-t)/1.5)
# smooth the normalization by averaging
t_corr = self.get_smooth(t_corr)
# get humidity
humidity = self.sense.get_humidity()
# get pressure
pressure = self.sense.get_pressure()
# return data for pushing into iot
return {
"deviceid": self.getserial(),
"humidity": humidity,
"pressure": pressure,
"temperature": t_corr,
"timestamp": int(round(time.time() * 1000)),
}
# code supplied from http://yaab-arduino.blogspot.com/2016/08/accurate-temperature-reading-sensehat.html
# get CPU temperature
def get_cpu_temp(self):
res = os.popen("vcgencmd measure_temp").readline()
t = float(res.replace("temp=","").replace("'C\n",""))
return(t)
# code supplied from http://yaab-arduino.blogspot.com/2016/08/accurate-temperature-reading-sensehat.html
# use moving average to smooth readings
def get_smooth(self, x):
smoothing = [x,x,x]
smoothing[2] =smoothing[1]
smoothing[1] = smoothing[0]
smoothing[0] = x
# average smoothing
xs = (smoothing[0]+smoothing[1]+smoothing[2])/3
return(xs)
# code supplied from https://www.raspberrypi-spy.co.uk/2012/09/getting-your-raspberry-pi-serial-number-using-python/
def getserial(self):
# Extract serial from cpuinfo file
cpuserial = "0000000000000000"
try:
f = open('/proc/cpuinfo','r')
for line in f:
if line[0:6]=='Serial':
cpuserial = line[10:26]
f.close()
except:
cpuserial = "ERROR000000000"
return cpuserial
acc_stinkness = 0
t = 0
i = 1
O = (0, 0, 0)
pixels = [O]*64
dry = False
stink = False
# Main Loop
while True:
try:
t = t+1
threshold_dry = 120*37/30
threshold_stinky = 180*1020/1000
temp = hat.get_temperature()
hum = hat.get_humidity()
temp_p = hat.get_temperature_from_pressure()
pressure = hat.get_pressure()
timestamp = datetime.now()
temp_mean = (temp+temp_p)/2
acc_dryness = acc_dryness + temp_mean/hum
acc_stinkness = acc_stinkness + pressure/1000
if (acc_dryness >= threshold_dry) & (dry==False):
color = (0, 255, 0)
dry = True
SUBJECT = "Perfect ND Status (BGSE IoT prototype)"
TO = "*****@*****.**"
FROM = "*****@*****.**"
text = "Dear client,\n \n Announcement: Your clothes are already dry, ready for you to pick up and nicely fold them. You have "+str(round(threshold_stinky-acc_stinkness))+"min to take them before they become too stinky to be worn. \n\n Please pick up them as soon as possible.\n\n Yours sincerely,\n PerfectND Communication Managers: Jose and Roger\n\n This message was created automatically from Raspberry Pi, thank you for trusting our company."
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os, csv, time
from sense_hat import SenseHat
sense = SenseHat()
# read sensor data
hum_temp ="{:.3f}".format(sense.get_temperature())
#sense.show_message("H:%s" % hum_temp)
pres_temp = "{:.3f}".format(sense.get_temperature_from_pressure())
#sense.show_message("P:%s" % pres_temp)
# save temp values into csv file
filePath =os.path.dirname(os.path.abspath(__file__))+ "/tempValues.csv"
print filePath
try:
f = open(filePath, "a")
writer = csv.writer(f)
# Check if file is empty and needs headline
if os.path.getsize(filePath) == 0:
print "File was empty, create header:"
headLine = ["Time","Temp from Hum-Sensor", "Temp from Preas-Sensor"]
print headLine
writer.writerow(headLine)
def execute(self):
sense = SenseHat()
temp = sense.get_temperature()-ADJUSTMENT
temp_hum = sense.get_temperature_from_humidity()-ADJUSTMENT
temp_pre = sense.get_temperature_from_pressure()-ADJUSTMENT
return dict(temp=temp, temp_hum=temp_hum, temp_pre=temp_pre)
mqttc.connect(awshost, awsport, keepalive=60)
mqttc.loop_start()
while True:
message = {}
device = {}
device['cpuTemperature'] = os.popen('vcgencmd measure_temp').readline().replace("temp=","").replace("'C\n","")
environment = {}
temp = {}
temp['basedOnHumidity'] = sense.get_temperature_from_humidity()
temp['basedOnPressure'] = sense.get_temperature_from_pressure()
environment['humidity'] = sense.get_humidity()
environment['pressure'] = sense.get_pressure()
environment['temperature'] = temp
message['device'] = device
message['environment'] = environment
jsonData = json.dumps(message)
if connflag == True:
mqttc.publish("environmentData", jsonData, qos=1)
print jsonData
sleep(10)
else:
#HUMIDITY 4
d=humidity = my_weather[0]['humidity']
#RAINFALL 5
e=rainfall = my_weather[0]['rainfall']
#AIRPRESSURE 6
a=air_pressure = my_weather[0]['air_pressure']
#GROUNDTEMP 1
c=ground_temp = my_weather[0]['ground_temp']
#AMBIENTTEMP 2
b=ambient_temp = my_weather[0]['ambient_temp']
f=((sense.get_temperature_from_humidity()+sense.get_temperature_from_pressure())/2)
i=0
def move_left (event):
if event.action=='pressed':
global i
i = i-1
print(i)
print(event)
def move_right (event):
if event.action=='pressed':
global i
i = i+1
print(i)
while True:
sense_data = get_sense_data()
if DELAY == 0:
log_data()
if len(batch_data) >= WRITE_FREQUENCY:
print("Writing to file..")
with open(filename,"a") as f:
for line in batch_data:
f.write(line + "\n")
batch_data = []
# also write to plotly
now = datetime.now()
temp = round(sense.get_temperature_from_pressure(), 5)
temp2 = round(sense.get_temperature_from_humidity(), 5)
point1 = {
'x' : str(now),
'y' : temp
}
plotly_stream1.write(point1)
point2 = {
'x' : str(now),
'y' : temp2
}
plotly_stream2.write(point2)
plotly_stream.close()
def main():
sense = SenseHat()
temp = sense.get_temperature()
print "temp_from_temperat:%s" % temp
print "temp_from_humidity:%s" % sense.get_temperature_from_humidity()
print "temp_from_pressure:%s" % sense.get_temperature_from_pressure()
def getTempValue(self):
sense = SenseHat()
temp = sense.get_temperature_from_pressure()
return str(temp)
#! /usr/bin/env python
from sense_hat import SenseHat
sense = SenseHat()
temp = sense.get_temperature_from_humidity()
print("Temperature from humidity sensor: %s C" % temp)
temp = sense.get_temperature_from_pressure()
print("Temperature from pressure sensor: %s C" % temp)
logging.error(err_str)
# Print to stanard out
print(err_str)
## Entry point.
try:
# Setup log
logging.basicConfig(filename=log_filename,
level=logging.ERROR)
# Access to sense hat library
sense = SenseHat()
# Pull all sensor readings
temperature = (sense.get_temperature() * 9/5) + 32
temperature_pressure = (sense.get_temperature_from_pressure() * 9/5)+32
humidity = sense.get_humidity()
pressure = sense.get_pressure()
# Get the current date and time
current_datetime = datetime.datetime.now()
# Attempt to connect to the mysql database
cnx = mysql.connector.connect(user='******', password='******',
host='127.0.0.1', database='wordpress')
cursor = cnx.cursor()
# Add measurements to the table
cursor.execute("INSERT INTO weather (temperature, temperature_pressure,"
" humidity, pressure, year, month, day, hour, minute, second) "
