def read(self):
try:
sht_sensor = Sht(self.clock_pin, self.pin, voltage=self.voltage)
self._temperature = sht_sensor.read_t()
self._humidity = sht_sensor.read_rh()
except:
return None
def get_measurement(self):
""" Gets the humidity and temperature """
sht_sensor = Sht(self.clock_pin, self.pin, voltage=self.voltage)
temperature = sht_sensor.read_t()
humidity = sht_sensor.read_rh()
dew_point = sht_sensor.read_dew_point(temperature, humidity)
return dew_point, humidity, temperature
def read(self):
try:
sht_sensor = Sht(self.clock_pin, self.pin, voltage=self.voltage)
self._temperature = sht_sensor.read_t()
self._humidity = sht_sensor.read_rh()
self._dewpoint = sht_sensor.read_dew_point(self.temperature,
self.humidity)
except:
return 1
class InputModule(AbstractInput):
"""
A sensor support class that measures the SHT1x7x's humidity and temperature
and calculates the dew point
"""
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__()
self.logger = logging.getLogger("mycodo.inputs.sht1x_7x")
self._dew_point = None
self._humidity = None
self._temperature = None
if not testing:
from sht_sensor import Sht
from sht_sensor import ShtVDDLevel
self.logger = logging.getLogger("mycodo.sht1x_7x_{id}".format(
id=input_dev.unique_id.split('-')[0]))
self.device_measurements = db_retrieve_table_daemon(
DeviceMeasurements).filter(
DeviceMeasurements.device_id == input_dev.unique_id)
self.gpio = int(input_dev.gpio_location)
self.clock_pin = input_dev.clock_pin
sht_sensor_vdd_value = {
2.5: ShtVDDLevel.vdd_2_5,
3.0: ShtVDDLevel.vdd_3,
3.5: ShtVDDLevel.vdd_3_5,
4.0: ShtVDDLevel.vdd_4,
5.0: ShtVDDLevel.vdd_5
}
self.sht_voltage = sht_sensor_vdd_value[round(
float(input_dev.sht_voltage), 1)]
self.sht_sensor = Sht(self.clock_pin,
self.gpio,
voltage=self.sht_voltage)
def get_measurement(self):
""" Gets the humidity and temperature """
return_dict = measurements_dict.copy()
if self.is_enabled(0):
return_dict[0]['value'] = self.sht_sensor.read_t()
if self.is_enabled(1):
return_dict[1]['value'] = self.sht_sensor.read_rh()
if (self.is_enabled(2) and self.is_enabled(0) and self.is_enabled(1)):
return_dict[2]['value'] = calculate_dewpoint(
return_dict[0]['value'], return_dict[1]['value'])
if (self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1)):
return_dict[3]['value'] = calculate_vapor_pressure_deficit(
return_dict[0]['value'], return_dict[1]['value'])
return return_dict
class InputModule(AbstractInput):
"""
A sensor support class that measures the SHT1x7x's humidity and temperature
and calculates the dew point
"""
def __init__(self, input_dev, testing=False):
super().__init__(input_dev, testing=testing, name=__name__)
self.sensor = None
if not testing:
self.try_initialize()
def initialize(self):
from sht_sensor import Sht
from sht_sensor import ShtVDDLevel
sht_vdd = {
2.5: ShtVDDLevel.vdd_2_5,
3.0: ShtVDDLevel.vdd_3,
3.5: ShtVDDLevel.vdd_3_5,
4.0: ShtVDDLevel.vdd_4,
5.0: ShtVDDLevel.vdd_5
}
self.sensor = Sht(self.input_dev.pin_clock,
int(self.input_dev.gpio_location),
voltage=sht_vdd[round(
float(self.input_dev.sht_voltage), 1)])
def get_measurement(self):
"""Gets the humidity and temperature."""
if not self.sensor:
self.logger.error(
"Error 101: Device not set up. See https://kizniche.github.io/Mycodo/Error-Codes#error-101 for more info."
)
return
self.return_dict = copy.deepcopy(measurements_dict)
if self.is_enabled(0):
self.value_set(0, self.sensor.read_t())
if self.is_enabled(1):
self.value_set(1, self.sensor.read_rh())
if self.is_enabled(2) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(
2, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(
3,
calculate_vapor_pressure_deficit(self.value_get(0),
self.value_get(1)))
return self.return_dict
class InputModule(AbstractInput):
"""
A sensor support class that measures the SHT1x7x's humidity and temperature
and calculates the dew point
"""
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__(input_dev,
testing=testing,
name=__name__)
self._dew_point = None
self._humidity = None
self._temperature = None
if not testing:
from sht_sensor import Sht
from sht_sensor import ShtVDDLevel
self.gpio = int(input_dev.gpio_location)
self.pin_clock = input_dev.pin_clock
sht_sensor_vdd_value = {
2.5: ShtVDDLevel.vdd_2_5,
3.0: ShtVDDLevel.vdd_3,
3.5: ShtVDDLevel.vdd_3_5,
4.0: ShtVDDLevel.vdd_4,
5.0: ShtVDDLevel.vdd_5
}
self.sht_voltage = sht_sensor_vdd_value[round(
float(input_dev.sht_voltage), 1)]
self.sht_sensor = Sht(self.pin_clock,
self.gpio,
voltage=self.sht_voltage)
def get_measurement(self):
""" Gets the humidity and temperature """
self.return_dict = measurements_dict.copy()
if self.is_enabled(0):
self.value_set(0, self.sht_sensor.read_t())
if self.is_enabled(1):
self.value_set(1, self.sht_sensor.read_rh())
if (self.is_enabled(2) and self.is_enabled(0) and self.is_enabled(1)):
self.value_set(
2, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if (self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1)):
self.value_set(
3,
calculate_vapor_pressure_deficit(self.value_get(0),
self.value_get(1)))
return self.return_dict
class TempHumidity:
def __init__(self, name, data, clock):
self.name = name
self.sht = Sht(data, clock, voltage="5V")
def read(self):
temp = self.sht.read_t()
return {
"timestamp": get_timestamp(),
"sensor": self.name,
"temperature_c": temp,
"temperature_f": c2f(temp),
"humidity": self.sht.read_rh()
}
#--- Import Libraries
import os
import glob
import time
import datetime
from datetime import datetime
from datetime import date
from sht_sensor import Sht
filedate = date.today()
outfile = '/data/sht/' + str(filedate) + '-' + 'sht_rht.csv'
sht = Sht(21, 17)
with open(outfile, 'a') as f:
while True:
f.write(datetime.utcnow().isoformat() + ',' + str(sht.read_t()) + ',' +
str(sht.read_rh()) +
'\n') #write the data to a string and to the output file
#print 'Temperature', sht.read_t()
#print 'Relative Humidity', sht.read_rh()
time.sleep(10)
f.flush()
#DHT_PIN = 23 # GPIO nr
#DHT_SENSOR = Adafruit_DHT.DHT22
s2 = Sht(8, 11) #SCK,DATA
if __name__ == '__main__':
if len(sys.argv) > 1:
call = sys.argv[1].lower()
if call == 'temp':
temperature = None
while temperature == None:
try:
temperature = s2.read_t()
except ShtCRCCheckError:
temperature = None
if temperature == None:
time.sleep(1.5)
print(temperature)
elif call == 'hum':
humidity = None
while humidity == None:
try:
temp = s2.read_t()
humidity = s2.read_rh(temp)
except ShtCRCCheckError:
humidity = None
if humidity == None:
time.sleep(1.5)
print(humidity)
#DHT_PIN = 23 # GPIO nr
#DHT_SENSOR = Adafruit_DHT.DHT22
sensor = Sht(14, 4)
if __name__ == '__main__':
if len(sys.argv) > 1:
call = sys.argv[1].lower()
if call == 'temperature':
temperature = None
while temperature == None:
#_, temperature = Adafruit_DHT.read_retry(DHT_SENSOR, DHT_PIN)
temperature = sensor.read_t()
if temperature == None:
time.sleep(1.5)
print(temperature)
elif call == 'humidity':
humidity = None
while humidity == None:
#humidity, _ = Adafruit_DHT.read_retry(DHT_SENSOR, DHT_PIN)
temp = sensor.read_t()
humidity = sensor.read_rh(temp)
if humidity == None:
time.sleep(1.5)
print(humidity)
# elif call == 'pressure':
# sensor = BMP085.BMP085()
# print(sensor.read_pressure() / 100.0)
record_dur = input('How long do you want to record for (in seconds)?: ')
filename = 'y' + day + '_' + yr_name + '_' + record_dur + 's.pkl'
print('The file name will be: ' + filename)
path_to_datasaving = './data/'
# ========================================
# https://docs.microsoft.com/en-us/windows/iot-core/learn-about-hardware/pinmappings/pinmappingsrpi
volt_read = '3.5V' # Sht.VDDLevel.vdd_5v
print(volt_read)
# these numbers are the GPIO numbers, not the pin numbers !
yellow_clock_pin = 11
blue_data_pin = 17
sht = Sht(yellow_clock_pin, blue_data_pin, voltage=volt_read)
T_C = sht.read_t()
rh = sht.read_rh(T_C)
dew_point = sht.read_dew_point(T_C, rh)
print(T_C,rh,dew_point)
print('=================================')
print('======= RECORDING NOW! ==========')
print('=================================')
print('TIME...TEMP [C]...HUMIDITY [%]')
# ========================================
temp_ls = []
hum_ls = []
time_ls = []
time0 = time.time()
t_now=0.0
t_stop = float(record_dur)
#!/usr/bin/python from sht_sensor import Sht sht = Sht(4, 17) print "temp:", sht.read_t() print "rh:", sht.read_rh()
class SHT1x7xSensor(AbstractInput):
"""
A sensor support class that measures the SHT1x7x's humidity and temperature
and calculates the dew point
"""
def __init__(self, input_dev, testing=False):
super(SHT1x7xSensor, self).__init__()
self.logger = logging.getLogger("mycodo.inputs.sht1x_7x")
self._dew_point = None
self._humidity = None
self._temperature = None
if not testing:
from sht_sensor import Sht
from sht_sensor import ShtVDDLevel
self.logger = logging.getLogger(
"mycodo.inputs.sht1x_7x_{id}".format(id=input_dev.id))
self.location = int(input_dev.location)
self.clock_pin = input_dev.clock_pin
self.convert_to_unit = input_dev.convert_to_unit
sht_sensor_vdd_value = {
2.5: ShtVDDLevel.vdd_2_5,
3.0: ShtVDDLevel.vdd_3,
3.5: ShtVDDLevel.vdd_3_5,
4.0: ShtVDDLevel.vdd_4,
5.0: ShtVDDLevel.vdd_5
}
self.sht_voltage = sht_sensor_vdd_value[round(
float(input_dev.sht_voltage), 1)]
self.sht_sensor = Sht(self.clock_pin,
self.location,
voltage=self.sht_voltage)
def __repr__(self):
""" Representation of object """
return "<{cls}(dewpoint={dpt})(humidity={hum})(temperature={temp})>".format(
cls=type(self).__name__,
dpt="{0:.2f}".format(self._dew_point),
hum="{0:.2f}".format(self._humidity),
temp="{0:.2f}".format(self._temperature))
def __str__(self):
""" Return measurement information """
return "Dew Point: {dpt}, Humidity: {hum}, Temperature: {temp}".format(
dpt="{0:.2f}".format(self._dew_point),
hum="{0:.2f}".format(self._humidity),
temp="{0:.2f}".format(self._temperature))
def __iter__(self): # must return an iterator
""" SHT1x7xSensor iterates through live measurement readings """
return self
def next(self):
""" Get next measurement reading """
if self.read(): # raised an error
raise StopIteration # required
return dict(dewpoint=float('{0:.2f}'.format(self._dew_point)),
humidity=float('{0:.2f}'.format(self._humidity)),
temperature=float('{0:.2f}'.format(self._temperature)))
@property
def dew_point(self):
""" SHT1x7x dew point in Celsius """
if not self._dew_point: # update if needed
self.read()
return self._dew_point
@property
def humidity(self):
""" SHT1x7x relative humidity in percent """
if not self._humidity: # update if needed
self.read()
return self._humidity
@property
def temperature(self):
""" SHT1x7x temperature in Celsius """
if self._temperature is None: # update if needed
self.read()
return self._temperature
def get_measurement(self):
""" Gets the humidity and temperature """
self._dew_point = None
self._humidity = None
self._temperature = None
temperature = convert_units('temperature', 'celsius',
self.convert_to_unit,
self.sht_sensor.read_t())
humidity = self.sht_sensor.read_rh()
dew_point = self.sht_sensor.read_dew_point(temperature, humidity)
dew_point = convert_units('dewpoint', 'celsius', self.convert_to_unit,
dew_point)
return dew_point, humidity, temperature
def read(self):
"""
Takes a reading from the SHT1x7x and updates the self.dew_point,
self._humidity, and self._temperature values
:returns: None on success or 1 on error
"""
try:
(self._dew_point, self._humidity,
self._temperature) = self.get_measurement()
if self._dew_point is not None:
return # success - no errors
except Exception as e:
self.logger.exception(
"{cls} raised an exception when taking a reading: "
"{err}".format(cls=type(self).__name__, err=e))
return 1
def print_serial(self, buffer):
sht = Sht(3, 2)
s = datetime.datetime.now()
#self.n+=1
chksum = self.chksum_cal(buffer)
data = self.unpack_data(buffer)
a = data[self.DUST_PM1_0_CF1]
b = data[self.DUST_PM1_0_ATM]
c = data[self.DUST_PM2_5_CF1]
d = data[self.DUST_PM2_5_ATM]
e = data[self.DUST_PM10_0_CF1]
f = data[self.DUST_PM10_0_ATM]
g = data[self.DUST_AIR_0_3]
h = data[self.DUST_AIR_0_5]
i = data[self.DUST_AIR_1_0]
j = data[self.DUST_AIR_2_5]
k = data[self.DUST_AIR_5_0]
l = data[self.DUST_AIR_10_0]
#print(s,a,b,c,d,e,f,g,h,i,j,k,l)
self.input_parameter = [
d, round(sht.read_t(), 3),
round(sht.read_rh(), 3)
]
self.input_parameter = np.array([self.input_parameter])
self.input_parameter = scaler.transform(self.input_parameter)
# self.t+=[[model.predict(self.input_parameter),d,round(sht.read_t(),3),round(sht.read_rh(),3)]]
self.ai = float(model.predict(self.input_parameter))
#print(s,a,b,c,round(sht.read_t(),3),round(sht.read_rh(),3))
# print (data[self.DUST_PM1_0_CF1], data[self.DUST_PM1_0_ATM])
# print (data[self.DUST_PM2_5_CF1], data[self.DUST_PM2_5_ATM])
# print (data[self.DUST_PM10_0_CF1], data[self.DUST_PM10_0_ATM])
# print ("0.3um in 0.1L of air : %s" % (data[self.DUST_AIR_0_3]))
# print ("0.5um in 0.1L of air : %s" % (data[self.DUST_AIR_0_5]))
# print ("1.0um in 0.1L of air : %s" % (data[self.DUST_AIR_1_0]))
# print ("2.5um in 0.1L of air : %s" % (data[self.DUST_AIR_2_5]))
# print ("5.0um in 0.1L of air : %s" % (data[self.DUST_AIR_5_0]))
# print ("10.0um in 0.1L of air : %s" % (data[self.DUST_AIR_10_0]))
# print ("Reserved F : %s | Reserved B : %s" % (data[self.RESERVEDF],data[self.RESERVEDB]))
# print ("CHKSUM : %s | read CHKSUM : %s | CHKSUM result : %s" % (chksum, data[self.CHECKSUM], chksum == data[self.CHECKSUM]))
# print ("============================================================================")
self.n += 1
try:
ser6.write(serial.to_bytes([0x02, 0x52, 0x00, 0x00, 0x03]))
send1 = "0252000003"
#send1=int(send1,16)
#send1=send1.encode('utf-8')
#byteToRead1 = ser6.inWaiting()
s = ser6.readline()
s = str(s)
s = s.split(',')
print(s)
# gas=s[1]+","+s[2]+","+s[3]+","+s[4]+","+s[6]+","+s[7]+model.predict(self.input_parameter)+","+d+","+sht.read_t()+","+sht.read_rh()
# print(gas)
time_now = datetime.datetime.now()
self.send = str(
"AI PM 2.5 :" + str(round(self.ai, 2))
) + ", Raw PM 2.5 :" + str(round(d, 2)) + ", Temp :" + str(
round(sht.read_t(), 2)) + ", Humidity :" + str(
round(sht.read_rh(), 2)) + ", CO :" + str(
round(float(s[1]) / 1.2, 2)
) + ", SO2 :" + s[2] + ", H2S :" + s[3] + ", VOC: " + str(
round(float(s[4]) / 3.5,
2)) + ", NO2: " + s[6] + ", O3: " + s[7] + "\r\n"
self.send2 = str(time_now) + " , " + str(
"AI PM 2.5 :" + str(round(self.ai, 2))
) + ", Raw PM 2.5 :" + str(round(d, 2)) + ", Temp :" + str(
round(sht.read_t(), 2)) + ", Humidity :" + str(
round(sht.read_rh(), 2)) + ", CO :" + str(
round(float(s[1]) / 1.2, 2)
) + ", SO2 :" + s[2] + ", H2S :" + s[3] + ", VOC: " + str(
round(float(s[4]) / 3.5,
2)) + ", NO2: " + s[6] + ", O3: " + s[7]
#str(float(s[4])/0.01+float(s[7]))
self.send = self.send.encode('utf-8')
#time.sleep(10)
ser.write(self.send)
print(time_now)
# ser.write(s)
#ser.write(self.send)
#print(self.send)
#print(ser6.isOpen())
self.t += [[str(self.send2)]]
self.n += 1
ser6.write(serial.to_bytes([0x02, 0x53, 0x00, 0x00, 0x03]))
except:
print('connect error \n')
if self.n == 2:
print("it's start")
# if self.n==5:
# print(self.n)
# df=pd.DataFrame(self.t)
# path="/home/mems/Desktop/test/"+datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")+".csv"
# df.to_csv(path)
# print(self.n,"seconds _and save file")
if self.n % 100 == 0:
#print(self.n)
df = pd.DataFrame(self.t)
path = "/home/omni/Desktop/test2/" + datetime.datetime.now(
).strftime("%Y-%m-%d-%H-%M-%S") + ".csv"
df.to_csv(path)
#print(self.n,"seconds _and save file")
self.t = []
# Sends temperature and humidity data to Thingspeak from a SHT sensor connected to Raspberry # Requires sht-sensor library to be installed # Sends data in every 10 mins: # crontab -e # */10 * * * * /usr/bin/python /home/pi/sht_thingspeak.py # The connections are SCK pin: GPIO 21, DATA pin: GPIO 17 # tamasharasztosi, 2018 import sys import time import RPi.GPIO as GPIO from time import sleep from sht_sensor import Sht import urllib2 myAPI = "FILL_WITH_YOUR_API" sht = Sht(21, 18) # SCK pin: GPIO 21, DATA pin: GPIO 17 print 'Temperature', sht.read_t() print 'Relative Humidity', sht.read_rh() baseURL = 'https://api.thingspeak.com/update?api_key=FILL_WITH_YOUR_API' urllib2.urlopen(baseURL + "&field1=%s&field2=%s" % (sht.read_t(), sht.read_rh())).read()
broker_address = "m14.cloudmqtt.com"
port = 16207
user = "******"
password = "******"
client = mqttClient.Client("Python")
client.username_pw_set(user, password=password)
client.on_connect = on_connect()
client.connect(broker_address, port=port)
client.loop_start()
while Connected != True:
time.sleep(0.1)
try:
while True:
sht = Sht(24, 23)
temperature = float(sht.read_t())
humidity = float(sht.read_rh())
time.sleep(10)
client.publish("python/temperature", temperature)
client.publish("python/humidity", humidity)
except KeyboardInterrupt:
client.disconnect()
client.loop_stop()
#!/usr/bin/python3.4
# -*- coding: utf-8 -*-
import sys
import time
from sht_sensor import Sht
sht = Sht(21, 17)
while (1):
Temperature = sht.read_t()
Humidity = sht.read_rh()
dew_point = sht.read_dew_point(Temperature, Humidity)
#print ('Temperature........:', Temperature)
#print ('Relative Humidity..:', Humidity)
#print()
#print ('Temperature........: {0:0.2f}'.format(Temperature))
#print ('Relative Humidity..: {0:0.2f}'.format(Humidity))
print(
'Gradi {0:0.2f} °C Umidita {1:0.2f} % dew Point {2:0.2f}'.
format(Temperature, Humidity, dew_point))
time.sleep(1)
# https://github.com/kizniche/sht-sensor/blob/master/README.rst
# si deve lanciare con python3.4
# make sure sht15 sclk is set to low -- is required before power up
wiringpi.digitalWrite(sht_sck_pin, 0)
# power cycle sht_vcc_pin just in case
wiringpi.digitalWrite(sht_vcc_pin, 0)
time.sleep(3)
# open 3.3v power pin tow power up sht15 temp and humidity sensor... using phyiscal pin values (no "_g")
wiringpi.pinMode(sht_vcc_pin, 1)
wiringpi.digitalWrite(sht_vcc_pin, 1)
# identify the SHT15's "sck" and "data" pins (using GPIO numbering, i..e the "_g" values), and VDD input voltage
sht = Sht(sht_sck_pin, sht_data_pin, voltage='3.5V')
# loop that takes exactly 1 second to execute
i = 0
start = time.time()
while True:
i += 1
# Read SHT temp and RH
tempC = str(round(sht.read_t(), 2))
rh = str(round(sht.read_rh(), 2))
# Read datetime
dt = '%s' % datetime.datetime.now() #.strftime("%Y-%m-%d %H:%M:%S")
# Read tempC_pi
tempC_pi = os.popen('vcgencmd measure_temp').read()[5:9]
# Write to file
f = open(FILENAME, "a")
f.write(dt + "," + tempC_pi + "," + tempC + "," + rh + "\n")
f.close()
print(dt + "," + tempC_pi + "," + tempC + "," + rh)
time.sleep(i - (time.time() - start))
#!/usr/bin/python
import datetime
import time
from sht_sensor import Sht
sht = Sht(4, 17)
for x in range(0, 10):
temperature = sht.read_t()
humidity = sht.read_rh(temperature)
dew_point = sht.read_dew_point(temperature, humidity)
print "Temperature: %s" % temperature
print "Humidity: %s" % humidity
print "Dew Point: " % dew_point
time.sleep(2)
