New Functions and Restructuring

.gitmodules

@@ -22,3 +22,6 @@
 [submodule "garage_protocol"]
 	path = garage_protocol
 	url = https://git.mount-mockery.de/application/garage_protocol.git
+[submodule "helpers"]
+	path = helpers
+	url = https://git.mount-mockery.de/pylib/helpers.git

helpers

@@ -0,0 +1 @@
+Subproject commit 1819df790c0784473480dffe9aca8ca774d46343

rpi_envsens

@@ -1 +1 @@
-Subproject commit fd86c70c83f75bcbbfc60ed69a99252bd7fb62b9
+Subproject commit 5ffef8254a0a035bc11ccefbd19497dd3969ac10

smarthome.py

@@ -2,13 +2,13 @@
 # -*- coding: UTF-8 -*-
 #
 
-#TODO: Zyklischer reconnect versuch (ggf. inkl. herstellen der Schnittstelle für ein reconnect beim tcp_client)
-
 import config
-import rpi_envsens as envsens
+from rpi_envsens.dht import dht_22
+from rpi_envsens.bmp import bmp_180
 import garage_protocol
 import gui
 import logging
+import numbers
 import os
 import report
 import task
@@ -25,16 +25,32 @@ class WetationFrameProt(gui.Wetation):
     PROT_ID_IN = 1
     PROT_ID_OUT = 2
     ALL_PROT_IDS = [PROT_ID_GARAGE, PROT_ID_IN, PROT_ID_OUT, ]
-    SLOW_PROT_IDS = [PROT_ID_IN, PROT_ID_OUT, ]
+
-    FAST_PROT_IDS = [PROT_ID_GARAGE, ]
+    PROT_IPS = {
+        PROT_ID_GARAGE: config.server_garage_ip,
+        PROT_ID_IN: config.server_in_ip,
+        PROT_ID_OUT: config.server_out_ip,
+    }
+
+    PROT_PORTS = {
+        PROT_ID_GARAGE: config.server_garage_port,
+        PROT_ID_IN: config.server_in_port,
+        PROT_ID_OUT: config.server_out_port,
+    }
+
+    PROT_SECRETS = {
+        PROT_ID_GARAGE: config.server_garage_secret,
+        PROT_ID_IN: config.server_in_secret,
+        PROT_ID_OUT: config.server_out_secret,
+    }
     
-    REQUEST_MSGS = {
+    PROT_CLASSES = {
-        PROT_ID_GARAGE: [
+        PROT_ID_GARAGE: garage_protocol.my_base_protocol_tcp,
-            {
+        PROT_ID_IN: wetation_protocol.my_base_protocol_tcp,
-                'service_id': garage_protocol.my_base_protocol_tcp.SID_READ_REQUEST,
+        PROT_ID_OUT: wetation_protocol.my_base_protocol_tcp,
-                'data_id': garage_protocol.my_base_protocol_tcp.GATE_POSITION,
+    }
-            },
+
-        ],
+    REQUEST_MSGS_SLOW = {
         PROT_ID_IN: [
             {
                 'service_id': wetation_protocol.my_base_protocol_tcp.SID_READ_REQUEST,
@@ -49,160 +65,169 @@ class WetationFrameProt(gui.Wetation):
         ],
     }
 
+    REQUEST_MSGS_FAST = {
+        PROT_ID_GARAGE: [
+            {
+                'service_id': garage_protocol.my_base_protocol_tcp.SID_READ_REQUEST,
+                'data_id': garage_protocol.my_base_protocol_tcp.GATE_POSITION,
+            },
+        ],
+    }
+
 
     def __init__(self, *args, **kwds):
+        self.__min_temp_in__ = None
+        self.__min_temp_out__ = None
+        self.__max_temp_in__ = None
+        self.__max_temp_out__ = None
         self.__prot__ = {}
-        self.no_data = {
-            self.PROT_ID_GARAGE: self.update_gate_position,
-            self.PROT_ID_IN: self.update_current_env_data_in,
-            self.PROT_ID_OUT: self.update_current_env_data_out,
-        }
         gui.Wetation.__init__(self, *args, **kwds)
+        self.in_temperature_min.Bind(wx.EVT_LEFT_DOWN, self.reset_in_temp_minmax_evt)
+        self.in_temperature_max.Bind(wx.EVT_LEFT_DOWN, self.reset_in_temp_minmax_evt)
+        self.out_temperature_min.Bind(wx.EVT_LEFT_DOWN, self.reset_out_temp_minmax_evt)
+        self.out_temperature_max.Bind(wx.EVT_LEFT_DOWN, self.reset_out_temp_minmax_evt)
         self.ShowFullScreen(config.FULL_SCREEN)
 
         self.__init_communication__()
+
         self.__task_1s__ = task.periodic(1, self.__task_1s_callback__)
         self.__task_10s__ = task.periodic(10, self.__task_10s_callback__)
         self.__task_60s__ = task.periodic(60, self.__task_60s_callback__)
 
-    def __init_protocol__(self, prot_id, ip, port, prot_class, secret):
-        c_tcp = tcp_socket.tcp_client_stp(ip, port, rx_log_lvl=logging.DEBUG)
-        self.__prot__[prot_id] = prot_class(c_tcp, secret)
-        if config.server_garage_secret is not None:
-            self.__prot__[prot_id].authentificate()
-
     def __init_communication__(self):
         #
         # Start TCP-Clients
-        self.__init_protocol__(
+        for prot_id in self.ALL_PROT_IDS:
-            self.PROT_ID_GARAGE,
+            logger.debug('Initiating communication channel for prot_id %d', prot_id)
-            config.server_garage_ip,
+            c_tcp = tcp_socket.tcp_client_stp(self.PROT_IPS[prot_id], self.PROT_PORTS[prot_id], rx_log_lvl=logging.DEBUG)
-            config.server_garage_port,
+            self.__prot__[prot_id] = self.PROT_CLASSES[prot_id](c_tcp, secret=self.PROT_SECRETS[prot_id], auto_auth=True)
-            garage_protocol.my_base_protocol_tcp,
+            #
-            config.server_garage_secret
+            self.__prot__[prot_id].register_callback(None, None, self.__prot_resp_callbacks__, prot_id)
-        )
-        self.__prot__[self.PROT_ID_GARAGE].register_callback(garage_protocol.my_base_protocol_tcp.SID_READ_RESPONSE, None, self.__garage_data__)
 
-        self.__init_protocol__(
+    def __initiate_data_request__(self, rt, request_msgs):
-            self.PROT_ID_IN,
+        for prot_id in request_msgs:
-            config.server_in_ip,
+            for request_msg in request_msgs.get(prot_id, []):
-            config.server_in_port,
+                service_id = request_msg['service_id']
-            wetation_protocol.my_base_protocol_tcp,
+                data_id = request_msg['data_id']
-            config.server_in_secret
+                if self.__prot__[prot_id].connection_established():
-        )
+                    logger.debug('Sending data request for prot_id %d, service_id %d and data_id %d', prot_id, service_id, data_id)
-        self.__prot__[self.PROT_ID_IN].register_callback(wetation_protocol.my_base_protocol_tcp.SID_READ_RESPONSE, None, self.__in_data__)
+                    self.__prot__[prot_id].send(service_id, data_id, None)
-
+                else:
-        self.__init_protocol__(
+                    wx.CallAfter(self.__no_data__, prot_id, service_id + 1, data_id)
-            self.PROT_ID_OUT,
-            config.server_out_ip,
-            config.server_out_port,
-            wetation_protocol.my_base_protocol_tcp,
-            config.server_out_secret
-        )
-        self.__prot__[self.PROT_ID_OUT].register_callback(wetation_protocol.my_base_protocol_tcp.SID_READ_RESPONSE, None, self.__out_data__)
 
     def __task_1s_callback__(self, rt):
         # request data from fast prot ids
-        self.__initiate_data_request__(rt, self.FAST_PROT_IDS)
+        self.__initiate_data_request__(rt, self.REQUEST_MSGS_FAST)
         # set date and time
         wx.CallAfter(self.update_time)
 
     def __task_10s_callback__(self, rt):
         # request data from slow prot ids
-        self.__initiate_data_request__(rt, self.SLOW_PROT_IDS)
+        self.__initiate_data_request__(rt, self.REQUEST_MSGS_SLOW)
 
     def __task_60s_callback__(self, rt):
         # reconnect prots if needed
         for prot_id in self.ALL_PROT_IDS:
-            if not self.__prot__[prot_id].is_connected():
+            if not self.__prot__[prot_id].connected():
                 logger.debug("Trying to reconnect prot_id %d", prot_id)
                 self.__prot__[prot_id].reconnect()
 
-    def __initiate_data_request__(self, rt, prot_ids):
+    def __validate_response_data__(self, prot_id, service_id, data_id, data):
-        for prot_id in prot_ids:
+        rv = False
-            if self.__prot__[prot_id].is_connected():
+        if prot_id == self.PROT_ID_GARAGE:
-                for request_msg in self.REQUEST_MSGS.get(prot_id, []):
+            if service_id == garage_protocol.my_base_protocol_tcp.SID_READ_RESPONSE and data_id == garage_protocol.my_base_protocol_tcp.GATE_POSITION:
-                    service_id = request_msg['service_id']
+                rv = isinstance(data, numbers.Number)
-                    data_id = request_msg['data_id']
+            elif service_id == garage_protocol.my_base_protocol_tcp.SID_EXECUTE_RESPONSE and data_id == garage_protocol.my_base_protocol_tcp.OPEN_CLOSE_GATE:
-                    logger.debug('Sending data request for prot_id %d, service_id %d and data_id %d', prot_id, service_id, data_id)
+                if data is True:
-                    self.__prot__[prot_id].send(service_id, data_id, None)
+                    rv = True
-            else:
+        elif prot_id in [self.PROT_ID_IN, self.PROT_ID_OUT]:
-                logger.debug('Resetting GUI for prot_id %d', prot_id)
+            if service_id == wetation_protocol.my_base_protocol_tcp.SID_READ_RESPONSE and data_id == wetation_protocol.my_base_protocol_tcp.CURRENT_ENVDATA:
-                wx.CallAfter(self.no_data[prot_id], None)
+                rv = isinstance(data.get(dht_22.KEY_TEMPERATURE), numbers.Number) and isinstance(data.get(dht_22.KEY_HUMIDITY), numbers.Number) and isinstance(data.get(bmp_180.KEY_PRESSURE), numbers.Number)
+        if rv is False:
+            logger.warning("Validation failed for message: prot_id=%s, service_id=%s, data_id=%s, data=%s", repr(prot_id), repr(service_id), repr(data_id), repr(data))
+        return rv
 
-    def __in_data__(self, msg):
+    def __prot_resp_callbacks__(self, msg, prot_id):
-        return self.__env_data__(msg, self.PROT_ID_IN)
+        service_id = msg.get_service_id()
-
+        data_id = msg.get_data_id()
-    def __out_data__(self, msg):
+        data = msg.get_data()
-        return self.__env_data__(msg, self.PROT_ID_OUT)
+        if self.__validate_response_data__(prot_id, service_id, data_id, data):
-
+            wx.CallAfter(self.__data__, prot_id, service_id, data_id, data)
-    def __env_data__(self, msg, prot_id):
-        logger.debug('Received data for prot_id %d, service_id %d, data_id %d', prot_id, msg.get_service_id(), msg.get_data_id())
-        if msg.get_status() == wetation_protocol.my_base_protocol_tcp.STATUS_OKAY:
-            if msg.get_data_id() == wetation_protocol.my_base_protocol_tcp.CURRENT_ENVDATA:
-                if prot_id == self.PROT_ID_IN:
-                    wx.CallAfter(self.update_current_env_data_in, msg)
-                else:
-                    wx.CallAfter(self.update_current_env_data_out, msg)
-                return wetation_protocol.my_base_protocol_tcp.STATUS_OKAY, None
-            else:
-                logger.warning('Received unknown data for prot_id %d, service_id %d, data_id %d', self.PROT_ID_GARAGE, msg.get_service_id(), msg.get_data_id())
             return wetation_protocol.my_base_protocol_tcp.STATUS_OKAY, None
         else:
-            logger.error('Error, receiving environmental data! MSG_STATUS was %s with PROT_ID %d', garage_protocol.my_base_protocol_tcp.STATUS_NAMES.get(msg.get_status(), repr(msg.get_status())), prot_id)
+            wx.CallAfter(self.__no_data__, prot_id, service_id, data_id)
             return wetation_protocol.my_base_protocol_tcp.STATUS_SERVICE_OR_DATA_UNKNOWN, None
 
-    def __garage_data__(self, msg):
+    def __no_data__(self, prot_id, service_id, data_id):
-        logger.debug('Received data for prot_id %d, service_id %d, data_id %d', self.PROT_ID_GARAGE, msg.get_service_id(), msg.get_data_id())
+        if prot_id == self.PROT_ID_GARAGE:
-        if msg.get_status() == garage_protocol.my_base_protocol_tcp.STATUS_OKAY:
+            if service_id == garage_protocol.my_base_protocol_tcp.SID_READ_RESPONSE and data_id == garage_protocol.my_base_protocol_tcp.GATE_POSITION:
-            if msg.get_data_id() == garage_protocol.my_base_protocol_tcp.GATE_POSITION:
+                logger.debug('Resetting GUI for prot_id %d, service_id=%d, data_id=%d', prot_id, service_id, data_id)
-                wx.CallAfter(self.update_gate_position, msg)
+                self.heading_garage.Show(False)
+                self.gate_oc.Show(False)
+                self.gate_open.Show(False)
+                self.gate_position.Show(False)
+                self.gate_close.Show(False)
+                self.Layout()
+                return
+            elif service_id == garage_protocol.my_base_protocol_tcp.SID_EXECUTE_RESPONSE and data_id == garage_protocol.my_base_protocol_tcp.OPEN_CLOSE_GATE:
+                return
+        elif prot_id in [self.PROT_ID_IN, self.PROT_ID_OUT]:
+            if service_id == wetation_protocol.my_base_protocol_tcp.SID_READ_RESPONSE and data_id == wetation_protocol.my_base_protocol_tcp.CURRENT_ENVDATA:
+                logger.debug('Resetting GUI for prot_id %d, service_id=%d, data_id=%d', prot_id, service_id, data_id)
+                txt_temperature = '-.- °C'
+                txt_humidity = '-.- %'
+                txt_pressure = '- hPa'
+                if prot_id == self.PROT_ID_IN:
+                    self.in_temperature.SetLabel(txt_temperature)
+                    self.in_humidity.SetLabel(txt_humidity)
+                    self.in_pressure.SetLabel(txt_pressure)
+                else:
+                    self.out_temperature.SetLabel(txt_temperature)
+                    self.out_humidity.SetLabel(txt_humidity)
+                    self.out_pressure.SetLabel(txt_pressure)
+                self.Layout()
+                return
+        logger.warning("Unknown response with no valid data for prot_id %d, service_id=%d, data_id=%d", prot_id, service_id, data_id)
+
+    def __data__(self, prot_id, service_id, data_id, data):
+        if prot_id == self.PROT_ID_GARAGE:
+            if service_id == garage_protocol.my_base_protocol_tcp.SID_READ_RESPONSE and data_id == garage_protocol.my_base_protocol_tcp.GATE_POSITION:
+                self.heading_garage.Show(True)
+                self.gate_oc.Show(True)
+                self.gate_open.Show(True)
+                self.gate_position.Show(True)
+                self.gate_close.Show(True)
+                self.gate_position.SetValue(int(data * 100))
+                self.Layout()
                 return garage_protocol.my_base_protocol_tcp.STATUS_OKAY, None
-            else:
+            elif service_id == garage_protocol.my_base_protocol_tcp.SID_EXECUTE_RESPONSE and data_id == garage_protocol.my_base_protocol_tcp.OPEN_CLOSE_GATE:
-                logger.warning('Received unknown data for prot_id %d, service_id %d, data_id %d', self.PROT_ID_GARAGE, msg.get_service_id(), msg.get_data_id())
+                return garage_protocol.my_base_protocol_tcp.STATUS_OKAY, None
-        else:
+        elif prot_id in [self.PROT_ID_IN, self.PROT_ID_OUT]:
-            logger.error('Error, receiving garage data! MSG_STATUS was %s', garage_protocol.my_base_protocol_tcp.STATUS_NAMES.get(msg.get_status(), repr(msg.get_status())))
+            if service_id == wetation_protocol.my_base_protocol_tcp.SID_READ_RESPONSE and data_id == wetation_protocol.my_base_protocol_tcp.CURRENT_ENVDATA:
-            return garage_protocol.my_base_protocol_tcp.STATUS_SERVICE_OR_DATA_UNKNOWN, None
+                temp = data[dht_22.KEY_TEMPERATURE]
+                if prot_id == self.PROT_ID_IN:
+                    if self.__max_temp_in__ is None or temp > self.__max_temp_in__:
+                        self.__max_temp_in__ = temp
+                    if self.__min_temp_in__ is None or temp < self.__min_temp_in__:
+                        self.__min_temp_in__ = temp
+                    wx.CallAfter(self.update_current_env_data, data, self.in_temperature, self.in_humidity, self.in_pressure, self.in_temperature_min, self.in_temperature_max, self.__min_temp_in__, self.__max_temp_in__)
+                else:
+                    if self.__max_temp_out__ is None or temp > self.__max_temp_out__:
+                        self.__max_temp_out__ = temp
+                    if self.__min_temp_out__ is None or temp < self.__min_temp_out__:
+                        self.__min_temp_out__ = temp
+                    wx.CallAfter(self.update_current_env_data, data, self.out_temperature, self.out_humidity, self.out_pressure, self.out_temperature_min, self.out_temperature_max, self.__min_temp_out__, self.__max_temp_out__)
+                return wetation_protocol.my_base_protocol_tcp.STATUS_OKAY, None
+        logger.warning("Unknown response with valid data for prot_id %d, service_id=%d, data_id=%d", prot_id, service_id, data_id)
+        return wetation_protocol.my_base_protocol_tcp.STATUS_SERVICE_OR_DATA_UNKNOWN, None
 
-
+    def update_current_env_data(self, env_data, temperature, humidity, pressure, temperature_min, temperature_max, value_min, value_max):
-    def update_current_env_data_in(self, msg):
+        if isinstance(value_min, numbers.Number) and isinstance(value_max, numbers.Number):
-        if msg is None:
+            temperature_min.SetLabel('%.1f' % value_min)
-            temperature = '-.-'
+            temperature_max.SetLabel('%.1f' % value_max)
-            humidity = '-.-'
+        temperature.SetLabel('%.1f °C' % env_data[dht_22.KEY_TEMPERATURE])
-            pressure = '-'
+        humidity.SetLabel('%.1f %%' % env_data[dht_22.KEY_HUMIDITY])
-        else:
+        pressure.SetLabel('%.0f hPa' % env_data[bmp_180.KEY_PRESSURE])
-            env_data = msg.get_data()
-            temperature = '%.1f' % env_data[envsens.KEY_TEMPERATURE]
-            humidity = '%.1f' % env_data[envsens.KEY_HUMIDITY]
-            pressure = '%.0f' % env_data[envsens.KEY_PRESSURE]
-        self.in_temperature.SetLabel("%s °C" % temperature)
-        self.in_humidity.SetLabel("%s %%" % humidity)
-        self.in_pressure.SetLabel("%s hPa" % pressure)
-        self.Layout()
-
-    def update_current_env_data_out(self, msg):
-        if msg is None:
-            temperature = '-.-'
-            humidity = '-.-'
-            pressure = '-'
-        else:
-            env_data = msg.get_data()
-            temperature = "%.1f" % env_data[envsens.KEY_TEMPERATURE]
-            humidity = "%.1f" % env_data[envsens.KEY_HUMIDITY]
-            pressure = "%.0f" % env_data[envsens.KEY_PRESSURE]
-        self.out_temperature.SetLabel("%s °C" % temperature)
-        self.out_humidity.SetLabel("%s %%" % humidity)
-        self.out_pressure.SetLabel("%s hPa" % pressure)
-        self.Layout()
-
-    def update_gate_position(self, msg):
-        self.heading_garage.Show(msg is not None)
-        self.gate_oc.Show(msg is not None)
-        self.gate_open.Show(msg is not None)
-        self.gate_position.Show(msg is not None)
-        self.gate_close.Show(msg is not None)
-        if msg is not None:
-            self.gate_position.SetValue(msg.get_data() * 100)
         self.Layout()
 
     def update_time(self):
@@ -210,11 +235,27 @@ class WetationFrameProt(gui.Wetation):
         self.date.SetLabel(time.strftime("%d.%m.%Y"))
         self.Layout()
 
-    def gate_oc_evt(self, event):  # wxGlade: Wetation.<event_handler>
+    def gate_oc_evt(self, event):
         logger.debug("Gate open/close request")
         self.__prot__[self.PROT_ID_GARAGE].send(garage_protocol.my_base_protocol_tcp.SID_EXECUTE_REQUEST, garage_protocol.my_base_protocol_tcp.OPEN_CLOSE_GATE, None)
         event.Skip()
 
+    def reset_in_temp_minmax_evt(self, event):
+        self.__min_temp_in__ = None
+        self.__max_temp_in__ = None
+        self.in_temperature_min.SetLabel("-.- °C")
+        self.in_temperature_max.SetLabel("-.- °C")
+        self.Layout()
+        event.Skip()
+
+    def reset_out_temp_minmax_evt(self, event):
+        self.__min_temp_out__ = None
+        self.__max_temp_out__ = None
+        self.out_temperature_min.SetLabel("-.- °C")
+        self.out_temperature_max.SetLabel("-.- °C")
+        self.Layout()
+        event.Skip()
+
     def run(self):
         self.__task_1s__.run()
         self.__task_10s__.run()

socket_protocol

@@ -1 +1 @@
-Subproject commit f4a7f1e7a4156f397ee76bee01b0fdab88a727d1
+Subproject commit cd508340e390fc01ebdf81eae3b1e221aa1b658a

tcp_socket

@@ -1 +1 @@
-Subproject commit 3e6e74f976a1322d97f1d50480df133455486fd6
+Subproject commit d9bdc909e98f627fea4417d027ae5d9cb9e2ed81

wetation_protocol

@@ -1 +1 @@
-Subproject commit 53e4523c140b5f51dedb3b128048eb59c1a5da4c
+Subproject commit bc4808b313ecebba6511b82c801eeadd95e8a503