def read(self): try: measurement = mh_z19.read()['co2'] self.save_measurement(measurement) except TypeError: measurement = mh_z19.read_from_pwm()['co2'] self.save_measurement(measurement)
def setup_screen(screen): ssid = 'ERROR' hostapd_conf = open('/etc/hostapd/hostapd.conf', 'r') hostapd_conf_lines = hostapd_conf.readlines() for line in hostapd_conf_lines: if line.strip().startswith('ssid='): ssid = line.split('=')[1] break while True: new_reading = mh_z19.read()['co2'] store_new_CO2_read(new_reading) new_reading_color_code = 7 if new_reading <= 700 and new_reading < 1000: new_reading_color_code = 2 elif new_reading >= 1000 and new_reading <= 1400: new_reading_color_code = 3 elif new_reading > 1400: new_reading_color_code = 1 screen.print_at(' WiFi: ', 0, 1, 6, 2) screen.print_at('╔══════════════════╗', 0, 2, 7, 2) screen.print_at(' Red: ' + ssid, 0, 4, 2, 1) screen.print_at('╚══════════════════╝', 0, 6, 7, 2) screen.print_at(' Medición CO2: ', 0, 9, 6, 2) screen.print_at('╔══════════════════╗', 0, 10, 7, 2) screen.print_at(' ' + str(new_reading) + ' PPM', 0, 12, new_reading_color_code, 1) screen.print_at('╚══════════════════╝', 0, 14, 7, 2) screen.refresh() time.sleep(1)
def main(): TIME = getTime() SensorValueArr = [ TIME, LPG, METAN, PROPAN, CO, HYDROGEN, SMOKE, CO2, TEMP, HUM, FAILURE ] db = Database() com = comm.Cummunication() port = com.connect() dht22_sensor = dht22.DHT22() while (True): msg = com.read_message(port) val, msgID = com.getValue(msg) print("value:", val) print("type:", msgID) if msgID != 0: SensorValueArr[7] = mh_z19.read()["co2"] SensorValueArr[8] = dht22_sensor.read_dht(False) SensorValueArr[9] = dht22_sensor.read_dht(True) SensorValueArr[msgID] = val if SensorValueArr[1] >= LPG_LIMIT and SensorValueArr[2] >= METAN_LIMIT and \ SensorValueArr[3] >= PROPAN_LIMIT and SensorValueArr[4] >= CO_LIMIT and \ SensorValueArr[5] >= HYDROGEN_LIMIT and SensorValueArr[6] >=SMOKE_LIMIT and \ SensorValueArr[7] >= CO2_LIMIT and SensorValueArr[8] >= TEMP_LIMIT and SensorValueArr[9] >= HUM_LIMIT: SensorValueArr[10] = True if msgID == 6: msgID = 0 SensorValueArr[0] = getTime() db.prepare_data(SensorValueArr) db.send_data() print("Data sent...") print(SensorValueArr)
def main(): TIME = getTime() # Initialize time value SensorValueArr = [TIME, LPG, SMOKE, CO, CO2, TEMP, HUM, FAILURE] # Sensor arr keep all sensor data, time and failure data to send cloud. db = Database() com = comm.Cummunication() port = com.connect() dht22_sensor = dht22.DHT22() while(True): msg = com.read_message(port) val, msgID = com.getValue(msg) print ("value:", val) print("type:", msgID) if msgID != 0: # if the mqsensor data was read, other sensor's data will read. SensorValueArr[4] = mh_z19.read()["co2"] SensorValueArr[5] = dht22_sensor.read_dht(False) SensorValueArr[6] = dht22_sensor.read_dht(True) SensorValueArr[msgID] = val if SensorValueArr[1] >= LPG_LIMIT and SensorValueArr[2] >= SMOKE_LIMIT and \ SensorValueArr[3] >= CO_LIMIT and SensorValueArr[4] >= CO2_LIMIT and \ SensorValueArr[5] >= TEMP_LIMIT and SensorValueArr[6] >= HUM_LIMIT: # Check Sensor failure limits. SensorValueArr[7] = True if msgID == 3: # When All sensor data was read. The data will send cloud. msgID = 0 SensorValueArr[0] = getTime() db.prepare_data(SensorValueArr) db.send_data() print("Data sent...") print(SensorValueArr)
def loop(): while(True): temp_data = dht.readDHT11() sleep(20) co2_data=mh_z19.read() if (co2_data["co2"] > 0): print("co2 ok") i = urllib2.urlopen(baseURL + fieldCO2 + str(co2_data["co2"])) #this command later opens a url. The "+" arguments are additions to the base url. #"fieldTemp" leads to the right graph, while the "str(...)" string is the actual data i.read() #opening the stored function x i.close() #closing the function sleep(20) #the databse accepts new data every 15 seconds if (temp_data is dht.DHTLIB_OK): #read DHT11 and get a return value. Then determine whether data read is normal according to the return value. print("DHTLIB_OK!!") x = urllib2.urlopen(baseURL + fieldTEMP + str(dht.temperature)) #this command later opens a url. The "+" arguments are additions to the base url. #"fieldTemp" leads to the right graph, while the "str(...)" string is the actual data x.read() #opening the stored function x x.close() #closing the function sleep(20) #the databse accepts new data every 15 seconds if(dht.humidity < 100): y = urllib2.urlopen(baseURL + fieldHUM + str(dht.humidity)) y.read() y.close() print("Humidity : %.2f, \t Temperature : %.2f, \t CO2: %.2f \n"%(dht.humidity,dht.temperature,co2_data["co2"])) sleep(10) if(co2_data["co2"]<1000): #co2 < 1000ppm normal outdor level setColor(color_green) elif(co2_data["co2"]<2000): #co2: 1000-2000ppm level associated with complains of drowsiness and poor air setColor(color_orange) else: #co2: > 2000 level associated with headaches, sleepiness and poor concentration setColor(color_red) pwm_buzzer.ChangeDutyCycle(100)
def get_data_points(): opc_data = {} opc_data = alphasense.histogram() mhz19_data = mh_z19.read() # Get the five measurement values from the OPC sensor. pm1 = opc_data['PM_A'] pm2_5 = opc_data['PM_B'] pm10 = opc_data['PM_C'] temperature = opc_data['Temperature'] humidity = opc_data['Relative humidity'] # Get the CO2 measurement value from the MHZ19 sensor. try: co2 = mhz19_data['co2'] except: co2 = None print "ERROR: CO2 value could not be read" # Get a local timestamp timestamp = datetime.datetime.utcnow().isoformat() # Print out current readings to terminal print "****************************************" print "Timestamp: ", timestamp print "Temperature: {0}{1}C".format(round(temperature, 1), u'\u00b0'.encode('utf8')) print "Humidity: {0}%".format(round(humidity, 1)) print "PM 1.0: {0}{1}g/m{2}".format(round(pm1, 2), u'\u00B5'.encode('utf8'), u'\u00B3'.encode('utf8')) print "PM 2.5: {0}{1}g/m{2}".format(round(pm2_5, 2), u'\u00B5'.encode('utf8'), u'\u00B3'.encode('utf8')) print "PM 10.0: {0}{1}g/m{2}".format(round(pm10, 2), u'\u00B5'.encode('utf8'), u'\u00B3'.encode('utf8')) print "C0{0}: {1}ppm".format(u"\u2082".encode('utf8'), co2) print "****************************************" # Create InfluxDB datapoints datapoints = [{ "measurement": session, "tags": { "run_num": run_num }, "time": timestamp, "fields": { "temperaturevalue": temperature, "humidityvalue": humidity, "pm1value": pm1, "pm25value": pm2_5, "pm10value": pm10, "co2value": co2 } }] return datapoints
def getCo2(): out = mh_z19.read() if not "co2" in out: print("Initializing mh_z19.......") time.sleep(10) co2 = out['co2'] return co2
def obtain_co2(): try: val = mh_z19.read() except serial.SerialException as e: print("error", e) else: if val: CO2.set(val['co2']) else: failure_count.inc()
def read(): global ini try: if ini.get("mode", "run_mode") == "dummy": result = {"co2": 400} else: result = mh_z19.read() return result except: traceback.print_exc()
def main(): # DHT11 sensori dht11_sensor = Adafruit_DHT.DHT11 dht11_gpio = 17 sleep_time = 120 file_name = get_meas_file_name() meas_time = raw_input("Anna mittauksen aika tunteina: ") # Time to stop measure timestamp_start = datetime.now() timestamp_end = timestamp_start + timedelta(hours=int(meas_time)) # open file for results file = open(file_name, "w") file.write('date, time, temperature, humidity, co2\r\n') while True: # debug hum = 10 temp = 20 co2 = 400 # read dht11 sensor hum, temp = Adafruit_DHT.read_retry(dht11_sensor, dht11_gpio) # read MH_Z19 sensor co2 = mh_z19.read()["co2"] timestamp_now = datetime.now() time_left = int((timestamp_end - timestamp_now).total_seconds() / 60.0) # print data to screen and file time = datetime.now().strftime('%Y-%m-%d %H:%M') print( '{3} Temp={0:0.1f}*C Humidity={1:0.1f}% CO2={2}ppm time left (minutes)={4}' .format(temp, hum, co2, time, time_left)) time = datetime.now().strftime('%Y-%m-%d, %H:%M') #temp = int(temp) #hum = int(hum) file.write('{0},{1},{2},{3}\r\n'.format(time, int(temp), int(hum), co2)) # Check if time to quit if (timestamp_now > timestamp_end): break # break before next round sleep(sleep_time) file.close
def start_monitoring(): # dht and hmt senors dht_hmt_sensor = Adafruit_DHT.DHT22 humidity, temperature = Adafruit_DHT.read_retry(dht_hmt_sensor, 26) # co2 senors co2 = mh_z19.read() # timestamp current_milli_time = str(int(round(time.time() * 1000))) # lx senors bus.write_byte(__DEV_ADDR, __CMD_PWR_ON) bus.write_byte(__DEV_ADDR, __CMD_THRES2) time.sleep(0.2) res = bus.read_word_data(__DEV_ADDR, 0) res = ((res >> 8) & 0xff) | (res << 8) & 0xff00 lx = round(res / (2 * 1.2), 2) # if every hardware is working if humidity is not None and temperature is not None and co2 != "9": data = {} data['date'] = time.strftime('%Y%m%d', time.localtime(time.time())) data['time'] = time.strftime('%H:%M', time.localtime(time.time())) data['tmp'] = format(temperature, ".1f") data['hmt'] = format(humidity, ".1f") data['ppm'] = str(co2['co2']) data['lx'] = str(lx) data['ld'] = str(GPIO.input(21)) data['timestamp'] = current_milli_time # push to the sets current_sets.append(data) messages = { "time": data['time'], "tmp": data['tmp'], "hmt": data['hmt'], "ppm": data['ppm'], "lx": data['lx'], "ld": data['ld'], "date": data['date'], "timestamp": data['timestamp'], "device": str(DEVICE_ID), } print(messages) # save to local folder print(save_to_local_folder(data['date'], messages)) # post to remote server try: print(post_to_server(messages)) except: pass return
def measure(): global screenOn global lastPressed global oldLastPressed for i in range(6): now = datetime.now() co2 = mh_z19.read() measurements[now] = co2['co2'] print(measurements[now]) orderedMeasurements = collections.OrderedDict( sorted(measurements.items(), reverse=True)).values() minuteAgo = now - timedelta(minutes=1) recentMeasurements = { k: v for k, v in measurements.items() if k > minuteAgo } minuteAvg = sum(recentMeasurements.values()) / len( recentMeasurements.values()) minuteStd = numpy.std(numpy.array(recentMeasurements.values()), axis=0) if lastPressed != oldLastPressed: screenOn = not screenOn oldLastPressed = lastPressed if screenOn: device.show() with canvas(device) as draw: draw.rectangle(device.bounding_box, outline="white", fill="black") draw.text((5, 5), (str(co2['co2'])), fill="white") draw.text((33, 5), ('avg ' + str(minuteAvg) + "(" + str(int(round(minuteStd, 0))) + ")"), fill="white") draw.line((5, 20, 5, 55), fill="white") draw.line((5, 55, 120, 55), fill="white") for i, m in enumerate(orderedMeasurements[:115]): height = 55 - m / 29 height = max(min(55, height), 20) draw.point(((120 - i), height), fill="white") else: device.hide() time.sleep(10) with open('co2.csv', mode='w') as f: writer = csv.writer(f) for k, v in measurements.items(): writer.writerow([k, v])
def payload(self, __payload): try: __payload["deviceTime"] = int(time.time()) if (self.bme680 is not None): __payload["sensorType"] = "bme680" __payload["voc"] = "{0:.0f}".format(self.bme680.gas) __payload["temperature"] = "{0:.1f}".format( self.bme680.temperature) __payload["humidity"] = "{0:.0f}".format(self.bme680.humidity) __payload["pressure"] = "{0:.0f}".format(self.bme680.pressure) __payload["altitude"] = "{0:.0f}".format(self.bme680.altitude) t = Temp(self.bme680.temperature, 'c') dewPoint = dew_point(temperature=t, humidity=self.bme680.humidity) __payload["dewPoint"] = "{0:.1f}".format(float(dewPoint)) elif (self.bme280 is not None): print("payload for BME280") __payload["sensorType"] = "bme280" __payload["temperature"] = "{0:.1f}".format( self.bme280.temperature) __payload["humidity"] = "{0:.0f}".format(self.bme280.humidity) __payload["pressure"] = "{0:.0f}".format(self.bme280.pressure) __payload["altitude"] = "{0:.0f}".format(self.bme280.altitude) t = Temp(self.bme280.temperature, 'c') dewPoint = dew_point(temperature=t, humidity=self.bme280.humidity) __payload["dewPoint"] = "{0:.1f}".format(float(dewPoint)) except: pass try: if (self.tsl is not None): __payload["lux"] = "{0:.0f}".format(self.tsl.lux) __payload["infrared"] = "{0:d}".format(self.tsl.infrared) __payload["visible"] = "{0:d}".format(self.tsl.visible) __payload["full_spectrum"] = "{0:d}".format( self.tsl.full_spectrum) except: pass try: drone.noSUDO() mhz19b = mh_z19.read() if mhz19b is not None: __payload["CO2"] = '{0:d}'.format(mhz19b['co2']) except: pass
async def main() -> None: """ Main loop :return: """ while True: print("Loop through sensors") mhz19_data = mh_z19.read() humidity, temperature = Adafruit_DHT.read_retry( CONFIG["ADAFRUIT_SENSOR_TYPE"], CONFIG["ADAFRUIT_SENSOR_PIN"]) print("Data received, packing") data = { "co2": mhz19_data["co2"], "temperature": temperature, "humidity": humidity, "time": datetime.datetime.now().timestamp(), } async with aiosqlite.connect(CONFIG["DB_PATH"]) as database: print("Writing to database") await database.execute( "INSERT INTO main.testimony VALUES (:co2,:temperature,:humidity,:time)", data, ) await database.commit() try: print(data) await send_to_socket(data, CONFIG["URL"]) except aiohttp.client_exceptions.ClientConnectorError: print("Socket not reachable") send_string = f"""CO2 level - {mhz19_data['co2']}.\ Temperature - {temperature}.\ Humidity - {humidity}""" print(send_string) print("Sleeping for {}".format(CONFIG["FREQUENCY"])) await asyncio.sleep(CONFIG["FREQUENCY"])
def measure(self): data = mh_z19.read(serial_console_untouched=True) return data
draw.text((180, 10),f"#: {len(rolling_co2_storage)}",(255,255,255),font=font_small) #draw.rectangle(((0, 40), (240, 42)), fill="white") if isinstance(ping('192.168.1.102'), float): draw.rectangle(((205,60), (230,85)), fill="green") else: draw.rectangle(((205,60), (230,85)), fill="red") sensor = Adafruit_DHT.DHT22 #GPIO.setmode(GPIO.BOARD) GPIO.setup(16, GPIO.IN, pull_up_down = GPIO.PUD_UP) humidity, temperature = Adafruit_DHT.read_retry(sensor, 16) draw.text((0, 220), f"t:{round(temperature, 1)}°C",(255, 255, 255), font=font_small) draw.text((80, 220), f"h:{round(humidity, 1)}%", (255, 255, 255), font=font_small) try: measurement = mh_z19.read()['co2'] if measurement == 500 and len(rolling_co2_storage) == 0: pass else: rolling_co2_storage.append(measurement) draw.text((0, 46),str(measurement) + " ppm", (255, 255, 255), font=font_big) draw.text((180, 220),"serial",(255,255,255),font=font_small) #draw.rectangle(((200, 50), (240, 90)), fill=get_color_for_value(measurement)) except TypeError: measurement = mh_z19.read_from_pwm()['co2'] if measurement == 500 and len(rolling_co2_storage) == 0: pass else: rolling_co2_storage.append(measurement) draw.text((0, 46),str(measurement) + " ppm", (255, 255, 255), font=font_big) draw.text((180, 220),"pwm",(255,255,255),font=font_small)
#!/usr/bin/python3 # pip3 install mh-z19 import mh_z19 print(mh_z19.read()) # not working because Bluetooth and serial have a conflict on Raspi3
import requests logging.basicConfig(filename='/tmp/venti-sensor2.log', level=logging.DEBUG) url = 'https://frozen-reef-90562.herokuapp.com/' #url='https://192.168.46.128:3000' proxies = { 'http': 'http://proxy.matsusaka.co.jp:12080', 'https': 'http://proxy.matsusaka.co.jp:12080' } #proxies = { # 'http': None, # 'https': None #} logging.info("VentiSensor Start.[{}]".format(url)) logging.info("VentiSensor Initialized.") while True: try: uploadData = mh_z19.read() print(uploadData) logging.info(uploadData) response = requests.post(url + '/addVentilation2/', json=uploadData, proxies=proxies) except Exception as e: logging.info(e) time.sleep(10)
def measure_co2(self): print("now, getting co2 by mh_z19") self.co2 = mh.read()
from datetime import datetime, timedelta from luma.core.interface.serial import i2c from luma.core.render import canvas from luma.oled.device import ssd1306, ssd1325, ssd1331, sh1106 serial = i2c(port=1, address=0x3C) device = ssd1306(serial, rotate=0) measurements = {} while True: for i in range(6): now = datetime.now() co2 = mh_z19.read() measurements[now] = co2['co2'] orderedMeasurements = collections.OrderedDict( sorted(measurements.items(), reverse=True)).values() minuteAgo = now - timedelta(minutes=1) recentMeasurements = { k: v for k, v in measurements.items() if k > minuteAgo } try: minuteAvg = sum(recentMeasurements.values()) / len( recentMeasurements.values()) minuteStd = numpy.std(numpy.array(recentMeasurements.values()), axis=0) except:
def main(self): """ Configure the logger and record the types of sensors that have been detected by the controller. """ self.logger.basicConfig = logging.basicConfig(format=self.format, filename='control.log', level=logging.INFO) self.logger.info('SYSTEM ONLINE') # Initialize the logging string for future use logging_str = 'Average retrieved temperature: ' + repr(0.00) # Log the types of sensors we have detected in the system for sen in self.sensors: self.logger.info('Detected %s sensors', str(sen)) # Calibrate current CO2 to 410ppm mh_z19.zero_point_calibration() while True: # Detect the sensors that are currently connected for i in range(0, len(self.sensors)): try: self.sensors[i].detect() self.num_sensors[i] = self.sensors[i].num_sensors except IOError: self.logger.info('Error detecting %s sensors', str(self.sensors[i])) try: # Open the sensor readings file and write current timestamp. self.logger.info('Opening sensors file for records') self.sensor_readings = codecs.open('sensors.csv', 'a', 'utf-8') self.sensor_readings.write(time.strftime("%Y/%m/%d %H:%M:%S", time.localtime())) # Read sensor data from all types of connected sensors. self.logger.info('Reading sensors from Pi') total_indoor = 0 total_readings = "" error_flag = 0 io_flag = 0 for sen in self.sensors: try: self.indoor, readings = sen.read() total_indoor += self.indoor total_readings += readings except (IOError, ZeroDivisionError): self.logger.info('Error reading a sensor.') error_flag += 1 io_flag = 1 # Read in error and reboot values for updates self.io_errors = codecs.open('io_error', 'r', 'utf-8') num_errors = int(self.io_errors.read()) self.io_errors.close() self.reboots = codecs.open('reboots', 'r', 'utf-8') num_reboots = int(self.reboots.read()) self.reboots.close() # If maximum reboots not reached, then reboot if (num_errors >= self.error_max and num_reboots < self.reboot_max): self.logger.info('Maximum I/O errors (%d);' + ' rebooting.', num_errors) self.io_errors = codecs.open('io_error', 'w') num_reboots += 1 self.io_errors.write('0') self.io_errors.close() self.reboots = codecs.open('reboots', 'w') self.reboots.write((str(num_reboots))) self.reboots.close() self.sensor_readings.close() proc = subprocess.Popen('reboot', stdout=subprocess.PIPE, shell=True) out, err = proc.communicate() # If maximum reboots reached, stay on elif num_reboots >= self.reboot_max: num_errors += 1 self.logger.info('Max reboots (%d) reached;' + ' I/O error #%d occurred', num_reboots, num_errors) self.io_errors = codecs.open('io_error', 'w') self.io_errors.write((str(num_errors))) self.io_errors.close() # If maximums not reached, record the error elif (num_reboots < self.reboot_max and num_errors < self.error_max): num_errors += 1 self.logger.info('I/O Error #%d occurred', num_errors) self.io_errors = codecs.open('io_error', 'w') self.io_errors.write((str(num_errors))) self.io_errors.close() # No I/O error detected this time -> reset counters if not io_flag: self.logger.info('No I/O error detected; ' + 'resetting number of errors and reboots') self.io_errors = codecs.open('io_error', 'w') self.io_errors.write('0') self.io_errors.close() self.reboots = codecs.open('reboots', 'w') self.reboots.write('0') self.reboots.close() self.logger.info('Detected indoor temp of %.2f', total_indoor / len(self.sensors)) # Log the individual readings if we have any sensor data if error_flag != len(self.sensors): self.sensor_readings.write(total_readings) self.logger.info('Reading CO2 data') try: # Read CO2 sensor data and log to file co2_val = mh_z19.read()['co2'] fmt_string = "," + str(co2_val) + "ppm" self.logger.info('Logging %d ppm to file', co2_val) self.sensor_readings.write(fmt_string) except TypeError: self.logger.info('Unable to read CO2 data') # Write a new line for the next reading interval self.sensor_readings.write('\n') # Close the sensor readings file self.sensor_readings.close() # Average temperature readings for accuracy self.indoor = total_indoor / len(self.sensors) # Round to three decimal places self.indoor = round(self.indoor, 3) self.logger.info('Retrieving outdoor temp from control tent') # Retrieve outdoor temp from the control tent and parse it out_proc = subprocess.Popen('sudo scp -o ConnectTimeout=10 pi@' + self.control_ip + self.control_dir, stdout=subprocess.PIPE, shell=True) out, err = out_proc.communicate() try: out_proc.terminate() except OSError: pass # Open retrieved file, read the line, convert and round. outdoor_temps = codecs.open('outdoor', 'r') temps = outdoor_temps.read().split(',') outdoor_temps.close() out_vals = [] # Initialize the logging string for future use # Remove any NULL characters received from the control tent # If any occur, remove them and still record that temperature for t in temps: try: out_vals.append(float(t)) except: valid_parts = [] for char in t: if char in string.printable: valid_parts.append(char) if len(valid_parts) > 0: joined = "".join(v for v in valid_parts) out_vals.append(float(joined)) # Convert the line to a list of floating point values out_list = list(map(float, out_vals)) # Compute the average of the outdoor temperature for comparison # If an error occurred in parsing the outdoor, use the previous reading if len(out_list) > 0: outdoor = sum(out_list) / len(out_list) else: start_point = logging_str.find(':') + 1 prev_outdoor = float(logging_str[start_point:]) outdoor = prev_outdoor self.outdoor = round(outdoor, 3) logging_str = 'Average retrieved temperature: ' + repr(self.outdoor) self.logger.info(logging_str) if self.indoor == 0 and self.outdoor == 0: # both sensors disconnected while running raise RuntimeError except RuntimeError as ex: # Exception occurred with sensor: notify via GUI self.indoor = 90 self.outdoor = 90 self.heater = "SENSOR" # Record exception information self.logger.info('%s', repr(sys.exc_info())) print((str(ex))) # If indoor temperature is below differential then # engage Stage 2 since the purge period and Stage 1 # won't be enough to maintain our differential if (self.indoor - self.outdoor < self.temperature_diff and self.indoor != 90 and self.outdoor != 90): self.heater = "ST2" GPIO.output(self.signal_pin, GPIO.HIGH) GPIO.output(self.stage_one_pin, GPIO.HIGH) GPIO.output(self.stage_two_pin, GPIO.HIGH) else: # Indoors >= outdoors -- turn off heater. if (self.indoor != 90 and self.outdoor != 90): self.heater = "OFF" GPIO.output(self.signal_pin, GPIO.LOW) GPIO.output(self.stage_one_pin, GPIO.LOW) GPIO.output(self.stage_two_pin, GPIO.LOW) self.logger.info('%.2f inside, %.2f outside, heater %s', self.indoor, self.outdoor, self.heater) # Sleep system until the next check cycle. time.sleep(self.check_interval)
def co2Concentration(self): r = mh_z19.read() if r is not None and 'co2' in r.keys(): return str(r['co2']) return None
#!/usr/bin/env python3 import mh_z19 from influxdb import InfluxDBClient homestats = InfluxDBClient(host='raspberrypi4bserver.local', database='homestats') points = [{ 'measurement': 'sensor', 'tags': { 'location': 'myRoom' }, 'fields': { 'co2': mh_z19.read()['co2'] } }] homestats.write_points(points)
def getco2(): out = mh_z19.read() V = getValue(str(out)) return V
def measure_data(sensor, pin): humidity, temperature = Adafruit_DHT.read(sensor, pin) co2 = mh_z19.read()["co2"] time = datetime.datetime.now() return {"humidity": humidity, "temperature": temperature, "co2": co2, "time": time}
import mh_z19 co2=mh_z19.read() print(mh_z19.read()) print(co2);
def start(self): print('## Sensing is Running ##') now_minute = datetime.datetime.now().minute start_minute = 0 if now_minute < 30: start_minute = 30 else: start_minute = 0 while True: try: co2_value = co2.read()['co2'] co_value = co.read() pm_values = pm.read() if self.fan_controller.is_auto_mode(): if self.fan_controller.is_on(): print('fan is on') if shared_data.datas.co2_safe >= co2_value \ and shared_data.datas.co_safe >= co_value \ and shared_data.datas.pm25_safe >= pm_values['pm2.5'] \ and shared_data.datas.pm10_safe >= pm_values['pm10']: print('@ try off') self.fan_controller.off() pass pass else: # is off print('fan is off') if shared_data.datas.co2_limit <= co2_value \ or shared_data.datas.co_limit <= co_value \ or shared_data.datas.pm25_limit <= pm_values['pm2.5'] \ or shared_data.datas.pm10_limit <= pm_values['pm10']: self.fan_controller.on() pass pass if self.fan_controller.is_auto_mode(): print('is auto mode') else: print('is not auto mode') #test begin print('co2: {}'.format(co2_value)) print('co: {}'.format(co_value)) #print('pm1.0: {}'.format(pm_values['pm1.0'])) print('pm2.5: {}'.format(pm_values['pm2.5'])) print('pm10: {}'.format(pm_values['pm10'])) print('') #test end shared_data.datas.set_sensing(pm_values['pm1.0'], pm_values['pm2.5'], co_value, co2_value) now_minute = datetime.datetime.now().minute if start_minute == now_minute: if start_minute == 0: start_minute = 30 pass else: start_minute = 0 pass self.db_controller.insert_sensing \ (pm10=pm_values['pm10'], \ pm25=pm_values['pm2.5'], \ co=co_value, co2=co2_value, log='') pass except: pass
import mh_z19 import time import paho.mqtt.client as mqtt while __name__ == '__main__': value = mh_z19.read() client = mqtt.Client() client.username_pw_set(username="******", password="******") client.connect("mqtt_ip", 1883, 60) client.publish("home/livingroom/co2", value["co2"]) time.sleep(60)
print("fine dust read success", flush=True) dust.save_data(buffer) dust_read_succeed = 1 dust_fail_count = 0 #print ("PM 2.5 : %s" % pm25_data, flush = True) #print ("PM 10.0 : %s" % pm10_data, flush = True) else: dust_read_succeed = 0 dust_fail_count += 1 print("finedust read fail", flush=True) #==============co2 sensor===== try: co2_data = mh_z19.read()['co2'] print("co2 read success") #print("co2: ",co2_data) co2_read_succeed = 1 co2_fail_count = 0 except: print("co2 read fail") co2_read_succeed = 0 co2_fail_count += 1 #moving average filter pm25_datas.append(pm25_data) dust_pm25_mean = round(mean(pm25_datas)) print("pm 2.5 average: ", dust_pm25_mean) dust_pm25_mean_list.append(dust_pm25_mean)
def main(self): """ Configure the logger and record the types of sensors that have been detected by the controller. """ self.logger.basicConfig = logging.basicConfig(format=self.format, filename='control.log', level=logging.INFO) self.logger.info('SYSTEM ONLINE') # Log the types of sensors we have detected in the system for sen in self.sensors: self.logger.info('Detected %s sensors', str(sen)) # Calibrate current CO2 to 410 ppm mh_z19.zero_point_calibration() while True: # Detect the sensors that are currently connected for i in range(0, len(self.sensors)): try: self.sensors[i].detect() self.num_sensors[i] = self.sensors[i].num_sensors except IOError: self.logger.info('Error detecting %s sensors', str(self.sensors[i])) try: # Open the sensor readings file and write current timestamp. self.logger.info('Opening sensors file for records') self.sensor_readings = codecs.open('sensors.csv', 'a', 'utf-8') self.sensor_readings.write( time.strftime("%Y/%m/%d %H:%M:%S", time.localtime())) # Read sensor data from all types of connected sensors. self.logger.info('Reading sensors from Pi') total_indoor = 0 total_readings = "" error_flag = 0 io_flag = 0 for sen in self.sensors: try: self.indoor, readings = sen.read() total_indoor += self.indoor total_readings += readings except (IOError, ZeroDivisionError): self.logger.info('Error reading a sensor.') error_flag += 1 io_flag = 1 # Read in error and reboot values for updates self.io_errors = codecs.open('io_error', 'r', 'utf-8') num_errors = int(self.io_errors.read()) self.io_errors.close() self.reboots = codecs.open('reboots', 'r', 'utf-8') num_reboots = int(self.reboots.read()) self.reboots.close() # If maximum reboots not reached, then reboot if (num_errors >= self.error_max and num_reboots < self.reboot_max): self.logger.info( 'Maximum I/O errors (%d);' + ' rebooting.', num_errors) self.io_errors = codecs.open('io_error', 'w') num_reboots += 1 self.io_errors.write('0') self.io_errors.close() self.reboots = codecs.open('reboots', 'w') self.reboots.write((str(num_reboots))) self.reboots.close() self.sensor_readings.close() proc = subprocess.Popen('reboot', stdout=subprocess.PIPE, shell=True) out, err = proc.communicate() # If maximum reboots reached, stay on elif num_reboots == self.reboot_max: num_errors += 1 self.logger.info( 'Max reboots (%d) reached;' + ' I/O error #%d occurred', num_reboots, num_errors) self.io_errors = codecs.open('io_error', 'w') self.io_errors.write((str(num_errors))) self.io_errors.close() # If maximums not reached, record the error elif (num_reboots < self.reboot_max and num_errors < self.error_max): num_errors += 1 self.logger.info('I/O Error #%d occurred', num_errors) self.io_errors = codecs.open('io_error', 'w') self.io_errors.write((str(num_errors))) self.io_errors.close() # No I/O error detected this time -> reset counters if not io_flag: self.logger.info('No I/O error detected; ' + 'resetting number of errors and reboots') self.io_errors = codecs.open('io_error', 'w') self.io_errors.write('0') self.io_errors.close() self.reboots = codecs.open('reboots', 'w') self.reboots.write('0') self.reboots.close() self.logger.info('Detected indoor temp of %.2f', total_indoor / len(self.sensors)) # Log the individual readings if we have any sensor data if error_flag != len(self.sensors): self.sensor_readings.write(total_readings) self.logger.info('Reading CO2 data') try: # Read CO2 sensor data and log to file co2_val = mh_z19.read()['co2'] fmt_string = "," + str(co2_val) + "ppm" self.logger.info('Logging %d ppm to file', co2_val) self.sensor_readings.write(fmt_string) except TypeError: self.logger.info('Unable to read CO2 data') # Write a new line for the next reading interval self.sensor_readings.write('\n') # Close the sensor readings file self.sensor_readings.close() # Average temperature readings for accuracy self.indoor = total_indoor / len(self.sensors) # Round to three decimal places self.indoor = round(self.indoor, 3) if self.indoor == 0: # sensors disconnected while running raise RuntimeError except RuntimeError as ex: # Exception occurred with sensors self.indoor = 90 self.heater = "SENSOR" # Record exception information self.logger.info('%s', repr(sys.exc_info())) print((str(ex))) # Immediately record outdoor temperature to file for control self.logger.info('Control: %d outside', self.indoor) self.logger.info('Recording temperature data to tent file %s', self.data_file) # Remove non-printable characters (NULL, etc) and first comma outdoor_record = "".join(temp for temp in total_readings[1:] if temp in string.printable) if self.indoor != 90: self.output_file = codecs.open(self.data_file, 'w', 'utf-8') self.output_file.write(outdoor_record) self.output_file.close() else: self.logger.info('Cannot read sensors. No temperature data.') time.sleep(self.check_interval)