.gitignore

@@ -1,4 +1,3 @@
 dist/
 build/
-__pycache__/
 greenhouse.egg-info/

greenhouse/__main__.py

@@ -7,44 +7,85 @@ import threading
 import time
 
 import RPi.GPIO as gpio
-from w1thermsensor import W1ThermSensor
+import paho.mqtt.client as mqtt
+import Adafruit_DHT
 
-SWITCH_ON_TEMP = 3.0
+SWITCH_ON_TEMP = 8.0
-SWITCH_OFF_TEMP = 5.0
+SWITCH_OFF_TEMP = 10.0
 
 log_level = logging.INFO
 LOG_FILE = "/var/log/greenhouse.log"
 LOG_FORMAT = "%(asctime)s %(levelname)s %(message)s"
 
-logging.basicConfig(format=LOG_FORMAT, level=log_level, filename=LOG_FILE)
+#logging.basicConfig(format=LOG_FORMAT, level=log_level, filename=LOG_FILE)
-#logging.basicConfig(format=LOG_FORMAT, level=log_level)
+logging.basicConfig(format=LOG_FORMAT, level=log_level)
 log = logging.getLogger('greenhouse')
 
+class EnvData(object):
+    def __init__(self):
+        self.stamp = datetime.datetime.fromtimestamp(0)
+        self.temperature = -273.15
+        self.humidity = -1.0
+        self.is_valid = False
+
 
 class EnvDataCollector(threading.Thread):
-    def __init__(self, name, update_interval=60):
+    def __init__(self, name, dht_pin, update_interval=60):
         super(EnvDataCollector, self).__init__()
         self.name = name
-        self.sensor = W1ThermSensor()
+        self.sensor = 22
+        self.dht_pin = dht_pin
         self.update_interval = update_interval
         self.run_condition = True
-        self.temperature = self.sensor.get_temperature()
+        self.data = EnvData()
-        self.stamp=datetime.datetime.now()
 
     def run(self):
         next_update = datetime.datetime.now()
         while self.run_condition:
             now = datetime.datetime.now()
             if now >= next_update:
-                self.temperature = self.sensor.get_temperature()
+                humidity, temperature = Adafruit_DHT.read(self.sensor, self.dht_pin)
-                self.stamp = now
+                if humidity is None or temperature is None:
+#                    log.info("%s: No data read - setting re-read intterval to 1s.", self.name)
+                    next_update = now + datetime.timedelta(seconds=10)
+                else:
+                    if humidity >= 0.0 and humidity <= 100.0 and temperature >= -273.15:
+                        self.data.temperature = temperature
+                        self.data.humidity = humidity
+                        self.data.stamp = now
+                        self.data.is_valid = True
                         next_update = now + datetime.timedelta(seconds=self.update_interval)
+#                        log.info("%s: Data read - setting re-read intterval to %ss.",
+#                                 self.name, self.update_interval)
+                    else:
+#                        log.info("%s: Invalid data read - setting re-read intterval to 1s.",
+#                                 self.name)
+                        next_update = now + datetime.timedelta(seconds=10)
             time.sleep(1)
 
     def stop(self):
         self.run_condition = False
         self.join()
 
+
+class MqttHandler(object):
+    def __init__(self, url, port, certificate):
+        self.url = url
+        self.port = port
+        self.certificate = certificate
+        self.client = mqtt.Client()
+        self.client.tls_set(certificate)
+        self.client.connect(url, port, 60)
+        self.client.loop_start()
+
+    def stop(self):
+        self.client.loop_stop()
+        self.client.disconnect()
+
+    def transmit(self, topic, message):
+        self.client.publish(topic, message, qos=2, retain=True)
+
+
 class Heat(object):
     def __init__(self, pin):
         self.pin = pin
@@ -58,38 +99,106 @@ class Heat(object):
     def off(self):
         gpio.output(self.pin, 1)
 
-def main():
+class Water(object):
-    green = EnvDataCollector("Greenhouse one")
+    def __init__(self, water_switch):
-    heat = Heat(26)
+        self.filename = "/var/log/relay_{}.state".format(water_switch)
-    heat.off()
-    heat_state = "off"
-    green.start()
 
+    def state(self):
+        res = [0, 0, 0]
+        with open(self.filename, "r") as f:
+            ctx = f.read().strip().split(" ")
+        return ctx[0], ctx[1], ctx[2]
+
+def main():
+    old_green = EnvDataCollector("Greenhouse one", 17)
+    old_heat = Heat(6)
+    old_heat.off()
+    old_heat_state = "off"
+    old_water = Water(1)
+    last_old_water_state = "off"
+    new_green = EnvDataCollector("Greenhouse two", 21)
+    new_water = Water(2)
+    last_new_water_state = "off"
+    old_green.start()
+    new_green.start()
+
+    mqtt_handler = MqttHandler("mqtt.blackfinn.de", 8883, "/etc/ssl/certs/DST_Root_CA_X3.pem")
     try:
+        # let first temperature/humidity collection happen.
+        time.sleep(5)
         next_update = datetime.datetime.now()
         while True:
             now = datetime.datetime.now()
+
+            # Water state
+            current_old_water_state = old_water.state()
+            if current_old_water_state[2] != last_old_water_state:
+                last_old_water_state = current_old_water_state[2]
+                msg = "{} {} {}".format(current_old_water_state[0], current_old_water_state[1], current_old_water_state[2])
+                mqtt_handler.transmit("outdoor/greenhouse/water", msg)
+
+            current_new_water_state = new_water.state()
+            if current_new_water_state[2] != last_new_water_state:
+                last_new_water_state = current_new_water_state[2]
+                msg = "{} {} {}".format(current_new_water_state[0], current_new_water_state[1], current_new_water_state[2])
+                mqtt_handler.transmit("outdoor/greenhouse-2/water", msg)
+
             if now >= next_update:
-                log.info("Temperature: %.1f", float(green.temperature))
+
-                if float(green.temperature) < SWITCH_ON_TEMP and heat_state == "off":
+                # 1) Check timestamp of last data collection. If data are older
-                    heat.on()
+                #    than 5 minutes the sensor isn't working anymore.
-                    heat_state = "on"
+                if old_green.data.is_valid and old_green.data.stamp + datetime.timedelta(minutes=5) >= now:
-                    log.info("Heat: switch %s", heat_state)
+                    msg = "{} {}".format(datetime.datetime.timestamp(old_green.data.stamp), old_green.data.temperature)
-                elif float(green.temperature) > SWITCH_OFF_TEMP and heat_state == "on":
+                    mqtt_handler.transmit("outdoor/greenhouse/temperature", msg)
-                    heat.off()
+                    log.info("%s: Temperature: %s", old_green.data.stamp.time(), old_green.data.temperature)
-                    heat_state = "off"
+                    msg = "{} {}".format(datetime.datetime.timestamp(old_green.data.stamp), old_green.data.humidity)
-                    log.info("Heat: switch %s", heat_state)
+                    mqtt_handler.transmit("outdoor/greenhouse/humidity", msg)
-                elif heat_state == "on":
+                    log.info("%s: Humidity: %s", old_green.data.stamp.time(), old_green.data.humidity)
+                    if old_green.data.temperature < SWITCH_ON_TEMP and old_heat_state == "off":
+                        old_heat.on()
+                        old_heat_state = "on"
+                        msg = "{} {}".format(time.time(), old_heat_state)
+                        mqtt_handler.transmit("outdoor/greenhouse/heat", msg)
+                        log.info("%s: Heat: switch %s", time.time(), old_heat_state)
+                    elif old_green.data.temperature > SWITCH_OFF_TEMP and old_heat_state == "on":
+                        old_heat.off()
+                        old_heat_state = "off"
+                        msg = "{} {}".format(time.time(), old_heat_state)
+                        mqtt_handler.transmit("outdoor/greenhouse/heat", msg)
+                        log.info("%s: Heat: switch %s", time.time(), old_heat_state)
+                    elif old_heat_state == "on":
                         # Do a power cycle to prevent auto-poweroff
-                    heat.off()
+                        log.info("%s: Heat init power cycle.", time.time())
+                        old_heat.off()
                         time.sleep(5)
-                    heat.on()
+                        old_heat.on()
+                        log.info("%s: Heat power cycle done.", time.time())
                     next_update = now + datetime.timedelta(minutes=5)
+                else:
+                    msg = "{} Error! Last valid DHT sensor data is from {}.".format(time.time(), old_green.data.stamp)
+                    mqtt_handler.transmit("outdoor/greenhouse/status", msg)
+                    log.error("%s: Error! Last valid DHT sensor data is from %s", time.time(), old_green.data.stamp)
+                    next_update = now + datetime.timedelta(seconds=5)
+
+                if new_green.data.is_valid and new_green.data.stamp + datetime.timedelta(minutes=5) >= now:
+                    msg = "{} {}".format(datetime.datetime.timestamp(new_green.data.stamp), new_green.data.temperature)
+                    mqtt_handler.transmit("outdoor/greenhouse-2/temperature", msg)
+                    log.info("%s: Temperature: %s", new_green.data.stamp.time(), new_green.data.temperature)
+                    msg = "{} {}".format(datetime.datetime.timestamp(new_green.data.stamp), new_green.data.humidity)
+                    mqtt_handler.transmit("outdoor/greenhouse-2/humidity", msg)
+                    log.info("%s: Humidity: %s", new_green.data.stamp.time(), new_green.data.humidity)
+                else:
+                    msg = "{} Error! Last valid DHT sensor data is from {}.".format(time.time(), new_green.data.stamp)
+                    mqtt_handler.transmit("outdoor/greenhouse-2/status", msg)
+                    log.error("%s: Error! Last valid DHT sensor data is from %s", time.time(), new_green.data.stamp)
+
             time.sleep(1)
     except KeyboardInterrupt:
         log.info("Shutting down...")
-        green.stop()
+        old_green.stop()
-        log.info("Done")
+        new_green.stop()
+        mqtt_handler.stop()
+        log.info("Exiting...")
 
 if __name__ == "__main__":
     sys.exit(main())