def get_gases():
# variable = "oxidised"
unit1 = "kO"
data1 = gas.read_all()
data1 = data1.oxidising / 1000
data1_g = "{:.2f}".format(data1)
#display_text(variables[mode], data1, unit1)
# variable = "reduced"
unit2 = "kO"
data2 = gas.read_all()
data2 = data2.reducing / 1000
data2_g = "{:.2f}".format(data2)
#display_text(variables[mode], data2, unit2)
# variable = "nh3"
unit3 = "kO"
data3 = gas.read_all()
data3 = data3.nh3 / 1000
data3_g = "{:.2f}".format(data3)
#display_text(variables[mode], data3, unit3)
g = "Oxid: " + str(data1_g) + unit1 + ", Redu: " + str(data2_g) + unit2 + ", nh3: " + str(data3_g) + unit3
return g
def presMessage():
bme280: BME280 = BME280()
ltr559: LTR559 = LTR559()
cpu_temps = [get_cpu_temperature()] * 5
while(1):
time.sleep(1)
amps = noise.get_amplitudes_at_frequency_ranges([(20,20000)])
cpu_temp = get_cpu_temperature()
# Smooth out with some averaging to decrease jitter
cpu_temps = cpu_temps[1:] + [cpu_temp]
avg_cpu_temp = sum(cpu_temps) / float(len(cpu_temps))
raw_temp = bme280.get_temperature()
comp_temp = raw_temp - ((avg_cpu_temp - raw_temp) / factor)
sio.emit('psiresponse', bme280.get_pressure())
sio.emit('tempresponse', comp_temp)
sio.emit('humresponse', bme280.get_humidity())
sio.emit('lightresponse', ltr559.get_lux())
sio.emit('noiseresponse', amps[0])
co = gas.read_all()
co = co/1000
sio.emit('gasresponse', gas.read_all())
def gas(self):
gas_data = gas.read_all()
return {
'oxidising': gas_data.oxidising / 1000,
'reducing': gas_data.reducing / 1000,
'nh3': gas_data.nh3 / 1000
}
def get_data():
# get scd30 data
data_raw_scd30 = sensor_scd30.readMeasurement()
if (data_raw_scd30 == False):
exit(1)
[float_co2, float_T, float_rH] = data_raw_scd30
scd30_data["co2"] = float_co2
scd30_data["Temp"] = float_T
scd30_data["Hum"] = float_rH
# get enviro data
enviro_data["proximity"] = ltr559.get_proximity()
enviro_data["raw_temp"] = bme280.get_temperature()
enviro_data["pressure"] = bme280.get_pressure()
enviro_data["humidity"] = bme280.get_humidity()
enviro_data["light"] = ltr559.get_lux()
enviro_gas = gas.read_all()
enviro_data["ox"] = enviro_gas.oxidising / 1000
enviro_data["red"] = enviro_gas.reducing / 1000
enviro_data["nh3"] = enviro_gas.nh3 / 1000
# Outputs
# print(scd30_data)
# print(enviro_data)
# time.sleep(10)
data["enviro"] = enviro_data
data["scd30"] = scd30_data
return data
def read_values(self):
values = {}
cpu_temp = self.get_cpu_temperature()
raw_temp = self.bme280.get_temperature()
comp_temp = raw_temp - ((cpu_temp - raw_temp) / self.comp_factor)
values['temperature'] = round(comp_temp, 2)
values['pressure'] = round(self.bme280.get_pressure(), 2)
values['humidity'] = round(self.bme280.get_humidity(), 2)
data = gas.read_all()
values['oxidising'] = round(data.oxidising / 1000, 4)
values['reducing'] = round(data.reducing / 1000, 4)
values['nh3'] = round(data.nh3 / 1000, 4)
values['lux'] = round(ltr559.get_lux(), 2)
try:
pm_values = self.pms5003.read()
values['P2.5'] = pm_values.pm_ug_per_m3(2.5)
values['P10'] = pm_values.pm_ug_per_m3(10)
values['P1.0'] = pm_values.pm_ug_per_m3(1.0)
except ReadTimeoutError:
self.pms5003.reset()
pm_values = self.pms5003.read()
values['P2.5'] = pm_values.pm_ug_per_m3(2.5)
values['P10'] = pm_values.pm_ug_per_m3(10)
values['P1.0'] = pm_values.pm_ug_per_m3(1.0)
values['ts'] = time.time_ns()
return values
def data_read(): # function to take sensor inputs and store in list
print("Reading data from sensors...")
# begins by assigning the information for A and B to variables
# for A, read data from sensors
# for SGP30 a simple read
eco2_A = sgp30.eCO2
tvoc_A = (sgp30.TVOC) + 1
# enviroplus, gas readings taken to intermediary variable
enviro_readings = gas.read_all()
# specific reading taken from intermediary variable and assigned to specific variable
redu_A = enviro_readings.reducing
oxi_A = enviro_readings.oxidising
print("Reading data from API...")
# for B, information taken from API
eco2_B = float(aio.receive('eco2-b').value)
tvoc_B = (float(aio.receive('tvoc-b').value)) + 1
redu_B = float(aio.receive('redu-b').value)
oxi_B = float(aio.receive('oxi-b').value)
# once data retrieved, values added to lists for use at end of function
eco2_data_A.append(eco2_A)
tvoc_data_A.append(tvoc_A)
redu_data_A.append(redu_A)
oxi_data_A.append(oxi_A)
eco2_data_B.append(eco2_B)
tvoc_data_B.append(tvoc_B)
redu_data_B.append(redu_B)
oxi_data_B.append(oxi_B)
def test_gas_read_adc_str(GPIO, smbus):
from enviroplus import gas
gas._is_setup = False
gas.enable_adc(True)
gas.set_adc_gain(2.048)
assert 'ADC' in str(gas.read_all())
def get_gas_measurements():
now = datetime.utcnow()
line1 = now.strftime("%H%M%S")
size_x, size_y = draw.textsize(line1, font)
# text position
x = 0
y = 0
# Draw background rectangle and write text.
draw.rectangle((0, 0, 160, 80), back_colour)
draw.text((x, y), line1, font=font, fill=text_colour)
line2 = "gas"
size_x, size_y = draw.textsize(line2, font)
y += size_y
draw.text((x, y), line2, font=font, fill=text_colour)
disp.display(img)
# retrieve gas readings
gas_readings = gas.read_all()
return '{ "instant":"' + now.isoformat() + '"' + \
', "adc":' + str(gas_readings.adc) + \
', "nh3":' + str(gas_readings.nh3) + \
', "oxidised":' + str(gas_readings.oxidising) + \
', "reduced":' + str(gas_readings.reducing) + \
'}'
def output():
# Get Temperature, pressure and humidity
bus = SMBus(1)
bme280 = BME280(i2c_dev=bus)
cpu_temps = [get_cpu_temperature()] * 5
factor = 0.8
raw_temp = bme280.get_temperature()
cpu_temp = get_cpu_temperature()
cpu_temps = cpu_temps[1:] + [cpu_temp]
avg_cpu_temp = sum(cpu_temps) / float(len(cpu_temps))
compTemp = raw_temp - ((avg_cpu_temp - raw_temp) / factor)
pressure = bme280.get_pressure()
humidity = bme280.get_humidity()
# Get gases
gases = gas.read_all()
nh3 = gases.nh3
no2 = gases.oxidising
# Get light and proximity
light = ltr559.get_lux()
proxim = ltr559.get_proximity()
# Calculate current time as string
curTime = time.strftime("%d/%m/%y,%H:%M", time.localtime())
return compTemp, humidity, nh3, no2, light, proxim, pressure, curTime
def read_values(bme280, pms5003):
# Compensation factor for temperature
comp_factor = 2.25
values = {}
cpu_temp = get_cpu_temperature()
raw_temp = bme280.get_temperature() # float
comp_temp = raw_temp - ((cpu_temp - raw_temp) / comp_factor)
values["temperature"] = int(comp_temp)
values["pressure"] = round(
int(bme280.get_pressure() * 100), -1
) # round to nearest 10
values["humidity"] = int(bme280.get_humidity())
try:
pm_values = pms5003.read() # int
values["pm1"] = pm_values.pm_ug_per_m3(1)
values["pm25"] = pm_values.pm_ug_per_m3(2.5)
values["pm10"] = pm_values.pm_ug_per_m3(10)
except ReadTimeoutError:
pms5003.reset()
pm_values = pms5003.read()
values["pm1"] = pm_values.pm_ug_per_m3(1)
values["pm25"] = pm_values.pm_ug_per_m3(2.5)
values["pm10"] = pm_values.pm_ug_per_m3(10)
data = gas.read_all()
values["oxidised"] = int(data.oxidising / 1000)
values["reduced"] = int(data.reducing / 1000)
values["nh3"] = int(data.nh3 / 1000)
values["lux"] = int(ltr559.get_lux())
return values
def get_gases():
gases = {}
data = gas.read_all()
gases['oxidising'] = TWO_DEC.format(data.oxidising / 1000)
gases['reducing'] = TWO_DEC.format(data.reducing / 1000)
gases['nh3'] = TWO_DEC.format(data.nh3 / 1000)
return gases
def read_values():
values = {}
cpu_temp = get_cpu_temperature()
raw_temp = bme280.get_temperature()
raw_gas = gas.read_all()
comp_temp = raw_temp - ((cpu_temp - raw_temp) / comp_factor)
values["temperature"] = "{:.2f}".format(comp_temp)
values["pressure"] = "{:.2f}".format(bme280.get_pressure() * 100)
values["humidity"] = "{:.2f}".format(bme280.get_humidity())
values["reducing"] = "{:.2f}".format(raw_gas.reducing)
values["oxidising"] = "{:.2f}".format(raw_gas.oxidising)
values["nh3"] = "{:.2f}".format(raw_gas.nh3)
try:
pm_values = pms5003.read()
except ReadTimeoutError:
pms5003.reset()
pm_values = pms5003.read()
values["P0.3_air"] = str(pm_values.pm_per_1l_air(0.3))
values["P0.5_air"] = str(pm_values.pm_per_1l_air(0.5))
values["P1_air"] = str(pm_values.pm_per_1l_air(1))
values["P2.5_m3"] = str(pm_values.pm_ug_per_m3(2.5))
values["P10_m3"] = str(pm_values.pm_ug_per_m3(10))
values["time"] = time.time()
return values
def get_gases():
gas_data = gas.read_all()
data = {}
data["gas"] = {}
data["gas"]["ammonia"] = gas_data.nh3 / 1000
data["gas"]["carbon_monoxide"] = gas_data.reducing / 1000
data["gas"]["nitrogen_dioxide"] = gas_data.oxidising / 1000
return data
def CO():
co = 0.00
red = 0
gas_readings = gas.read_all()
red = gas_readings.reducing
red_ratio = (red / 74)
co = (((red_ratio)**-1.177) * 4.4638)
return co
def get_nh3(log=False):
# variable = "nh3"
unit = "kO"
data = gas.read_all()
data = data.nh3 / 1000
if log == True:
logging.info("nh3 {} {}".format(data, unit))
# display_text("nh3", data, unit)
return (data, unit)
def get_reduced(log=False):
# variable = "reduced"
unit = "kO"
data = gas.read_all()
data = data.reducing / 1000
if log == True:
logging.info("reduced {} {}".format(data, unit))
# display_text("reduced", data, unit)
return (data, unit)
def readGas():
sensor_values = gas.read_all()
output = {
"adc": sensor_values.adc,
"nh3": sensor_values.nh3,
"oxidising": sensor_values.oxidising,
"reducing": sensor_values.reducing
}
return jsonify(output)
def get_gas():
"""Get all gas readings"""
readings = gas.read_all()
OXIDISING.set(readings.oxidising)
OXIDISING_HIST.observe(readings.oxidising)
REDUCING.set(readings.reducing)
REDUCING_HIST.observe(readings.reducing)
NH3.set(readings.nh3)
NH3_HIST.observe(readings.nh3)
def get_measurement():
try:
data = gas.read_all()
oxidising = data.oxidising / 1000
reducing = data.reducing / 1000
nh3 = data.nh3 / 1000
local_data_gateway.post_metrics_update('gas', 'ok')
return oxidising, reducing, nh3
except Exception as exception:
logger.error(f'Unable to read from gas sensor due to {exception}')
local_data_gateway.post_metrics_update('gas', 'errors')
return 0, 0, 0
def read_data(time):
temperature = bme280.get_temperature()
pressure = bme280.get_pressure()
humidity = bme280.get_humidity()
lux = ltr559.get_lux()
if gas_sensor:
gases = gas.read_all()
oxi = round(gases.oxidising / 1000, 1)
red = round(gases.reducing / 1000)
nh3 = round(gases.nh3 / 1000)
else:
oxi = red = nh3 = 0
if particle_sensor:
while True:
try:
particles = pms5003.read()
break
except RuntimeError as e:
print("Particle read failed:", e.__class__.__name__)
if not run_flag:
raise e
pms5003.reset()
sleep(30)
pm100 = particles.pm_per_1l_air(10.0)
pm50 = particles.pm_per_1l_air(5.0) - pm100
pm25 = particles.pm_per_1l_air(2.5) - pm100 - pm50
pm10 = particles.pm_per_1l_air(1.0) - pm100 - pm50 - pm25
pm5 = particles.pm_per_1l_air(0.5) - pm100 - pm50 - pm25 - pm10
pm3 = particles.pm_per_1l_air(0.3) - pm100 - pm50 - pm25 - pm10 - pm5
else:
pm100 = pm50 = pm25 = pm10 = pm5 = pm3 = 0
record = {
'time': asctime(localtime(time)),
'temp': round(temperature, 1),
'humi': round(humidity, 1),
'pres': round(pressure, 1),
'lux': round(lux),
'oxi': oxi,
'red': red,
'nh3': nh3,
'pm03': pm3,
'pm05': pm5,
'pm10': pm10,
'pm25': pm25,
'pm50': pm50,
'pm100': pm100,
}
return record
def sensor_readings():
"""Get readings from each gas sensor on the MICS6814
Returns:
dict:
"""
all = gas.read_all()
readings = {
"oxidising": (all.oxidising / 1000.0) * unitregistryhandler.ureg.ppm,
"reducing": (all.reducing / 1000.0) * unitregistryhandler.ureg.ppm,
"nh3": (all.nh3 / 1000.0) * unitregistryhandler.ureg.ppm,
}
return readings
def generate_output(self):
self.output_dict['timestamp'] = time.time()
if self.__variables['temp']:
self.output_dict['temp_value'] = self.bme280.get_temperature()
self.output_dict['temp_unit'] = 'C'
if self.__variables['pressure']:
self.output_dict['pressure_value'] = self.bme280.get_pressure()
self.output_dict['pressure_unit'] = 'hPa'
if self.__variables['humidity']:
self.output_dict['humidity_value'] = self.bme280.get_humidity()
self.output_dict['humidity_unit'] = '%'
if self.__variables['light']:
proximity = ltr559.get_proximity()
if proximity < 10:
light_value = self.ltr559.get_lux()
else:
light_value = 1
self.output_dict['light_value'] = light_value
self.output_dict['light_unit'] = 'Lux'
if self.__variables['oxidised']:
self.output_dict['oxidised_value'] = gas.read_all().oxidising / 1000
self.output_dict['oxidised_unit'] = 'kO'
if self.__variables['reduced']:
self.output_dict['reduced_value'] = gas.read_all().reducing / 1000
self.output_dict['reduced_unit'] = 'kO'
if self.__variables['nh3']:
self.output_dict['nh3_value'] = gas.read_all().nh3 / 1000
self.output_dict['nh3_unit'] = 'kO'
if self.__variables['pm1']:
self.output_dict['pm1_value'] = float(self.pms5003.read().pm_ug_per_m3(1.0))
self.output_dict['pm1_unit'] = 'ug/m3'
if self.__variables['pm25']:
self.output_dict['pm25_value'] = float(self.pms5003.read().pm_ug_per_m3(2.5))
self.output_dict['pm25_unit'] = 'ug/m3'
if self.__variables['pm10']:
self.output_dict['pm10_value'] = float(self.pms5003.read().pm_ug_per_m3(10))
self.output_dict['pm10_unit'] = 'ug/m3'
return self.output_dict
def update_graph_gases(input_data):
try:
gases = gas.read_all()
value_red = gases.reducing / 1000
value_nh3 = gases.nh3 / 1000
value_oxi = gases.oxidising / 1000
except:
value_red = None
value_nh3 = None
value_oxi = None
Y_gas_red_nh3['values']['RED'].append(value_red)
Y_gas_red_nh3['values']['NH3'].append(value_nh3)
Y_gas_oxi['values']['OX'].append(value_oxi)
return (update_graph(X, Y_gas_red_nh3), update_graph(X, Y_gas_oxi))
def test_gas_read_all(GPIO, smbus):
from enviroplus import gas
gas._is_setup = False
result = gas.read_all()
assert type(result.oxidising) == float
assert int(result.oxidising) == 16641
assert type(result.reducing) == float
assert int(result.reducing) == 16727
assert type(result.nh3) == float
assert int(result.nh3) == 16813
assert "Oxidising" in str(result)
def read_values():
values = {}
# Weather
try:
cpu_temp = get_cpu_temperature()
values["cpu_temp"] = "{:.2f}".format(cpu_temp)
raw_temp = bme280.get_temperature()
values["raw_temp"] = "{:.2f}".format(raw_temp)
comp_temp = raw_temp - ((cpu_temp - raw_temp) / comp_factor)
values["comp_temp"] = "{:.2f}".format(comp_temp)
values["pressure"] = "{:.2f}".format(bme280.get_pressure() * 100)
values["humidity"] = "{:.2f}".format(bme280.get_humidity())
except:
pass
# Light
try:
values["light"] = "{:.2f}".format(bme280.get_lux())
except:
pass
# Gas
try:
gas_data = gas.read_all()
values["gas.oxidised"] = "{:.2f}".format(gas_data.oxidising / 1000)
values["gas.reducing"] = "{:.2f}".format(gas_data.reducing / 1000)
values["gas.nh3"] = "{:.2f}".format(gas_data.nh3 / 1000)
except:
pass
# Particles
try:
pm_values = pms5003.read()
values["pm.P1"] = str(pm_values.pm_ug_per_m3(1))
values["pm.P25"] = str(pm_values.pm_ug_per_m3(2.5))
values["pm.P10"] = str(pm_values.pm_ug_per_m3(10))
values["pm.per_1l_air_.3"] = str(pm_values.pm_per_1l_air(.3))
values["pm.per_1l_air_.5"] = str(pm_values.pm_per_1l_air(.5))
values["pm.per_1l_air_1"] = str(pm_values.pm_per_1l_air(1))
values["pm.per_1l_air_2.5"] = str(pm_values.pm_per_1l_air(2.5))
values["pm.per_1l_air_5"] = str(pm_values.pm_per_1l_air(5))
values["pm.per_1l_air_10"] = str(pm_values.pm_per_1l_air(10))
except ReadTimeoutError:
pms5003.reset()
pm_values = pms5003.read()
values["pm.P1"] = str(pm_values.pm_ug_per_m3(1))
values["pm.P25"] = str(pm_values.pm_ug_per_m3(2.5))
values["pm.P10"] = str(pm_values.pm_ug_per_m3(10))
return values
def take_readings(self):
gas_data = gas.read_all()
readings = {
"proximity": ltr559.get_proximity(),
"lux": ltr559.get_lux(),
"temperature": self.bme280.get_temperature(),
"pressure": self.bme280.get_pressure(),
"humidity": self.bme280.get_humidity(),
"gas/oxidising": gas_data.oxidising,
"gas/reducing": gas_data.reducing,
"gas/nh3": gas_data.nh3,
}
readings.update(self.latest_pms_readings)
return readings
def get_gas():
"""Get all gas readings"""
try:
readings = gas.read_all()
except (OSError, ValueError) as exception:
logging.warning(
"Failed to read gas sensor with error: {}".format(exception))
else:
OXIDISING.set(readings.oxidising)
OXIDISING_HIST.observe(readings.oxidising)
REDUCING.set(readings.reducing)
REDUCING_HIST.observe(readings.reducing)
NH3.set(readings.nh3)
NH3_HIST.observe(readings.nh3)
def get_gas():
"""Get all gas readings"""
try:
readings = gas.read_all()
OXIDISING.set(readings.oxidising)
OXIDISING_HIST.observe(readings.oxidising)
REDUCING.set(readings.reducing)
REDUCING_HIST.observe(readings.reducing)
NH3.set(readings.nh3)
NH3_HIST.observe(readings.nh3)
except IOError:
logging.error("Could not get gas readings. Resetting i2c.")
reset_i2c()
def get_gas():
unit = "kO"
data = gas.read_all()
try:
return {
"status": 200,
"unit": unit,
"oxidising": data.oxidising / 1000,
"reducing": data.reducing / 1000,
"nh3": data.nh3 / 1000,
}
except Exception as e:
return {
"status": 500,
"message": e,
}
def read_gas(self):
print("read_gas() started")
try:
while True:
measurements = gas.read_all()
if self.values.full():
self.values.get()
self.values.put(
GasMeasure(measurements.oxidising, measurements.reducing,
measurements.nh3, measurements.adc))
#print(f"Elementi in coda: {self.values.qsize()}")
#print(self.values.queue)
time.sleep(self.seconds_interval)
except:
print("Exception in read_gas()!")
raise
