v2 rc2

Dockerfile

@@ -11,6 +11,7 @@ RUN apk add git
 RUN apk add tzdata
 RUN apk add musl-utils
 RUN apk add xsel
+RUN apk add redis
 
 # set the working directory in the container
 WORKDIR /app
@@ -28,18 +29,18 @@ COPY GivTCP/ ./GivTCP
 COPY GivEnergy-Smart-Home-Display-givtcp/ ./GivEnergy-Smart-Home-Display-givtcp
 
 COPY startup.py startup.py
+COPY redis.conf redis.conf
 
 ENV NUMINVERTORS=1
 ENV INVERTOR_IP_1=""
 ENV NUMBATTERIES_1=1
-ENV MQTT_OUTPUT="True"
+ENV MQTT_OUTPUT=True
 ENV MQTT_ADDRESS="127.0.0.1"
 ENV MQTT_USERNAME=""
 ENV MQTT_PASSWORD=""
 ENV MQTT_TOPIC=""
 ENV MQTT_PORT=1883
 ENV LOG_LEVEL="Error"
-ENV DEBUG_FILE_LOCATION=""
 ENV PRINT_RAW=True
 ENV SELF_RUN=True
 ENV SELF_RUN_LOOP_TIMER=5
@@ -60,13 +61,15 @@ ENV NIGHTRATESTART="00:30"
 ENV TZ="Europe/London"
 ENV WEB_DASH=False
 ENV WEB_DASH_PORT=3000
+ENV CACHELOCATION="/config/GivTCP"
+ENV DATASMOOTHER="High"
 
 ENV SMARTTARGET=True
 ENV GEAPI=""
 ENV SOLCASTAPI=""
 ENV SOLCASTSITEID=""
 
 
-EXPOSE 6345 1883 3000
+EXPOSE 6345 1883 3000 6379 9181
 
 CMD ["python3", "/app/startup.py"]

GivTCP/REST.py

@@ -87,6 +87,26 @@ def setDischrgSlot2():
     payload = request.get_json(silent=True, force=True)
     return wr.setDischargeSlot2(payload)
 
+@giv_api.route('/tempPauseDischarge', methods=['POST'])
+def tmpPauseDischrg():
+    payload = request.get_json(silent=True, force=True)
+    return wr.tempPauseDischarge(payload)
+
+@giv_api.route('/tempPauseCharge', methods=['POST'])
+def tmpPauseChrg():
+    payload = request.get_json(silent=True, force=True)
+    return wr.tempPauseCharge(payload)
+
+@giv_api.route('/forceCharge', methods=['POST'])
+def frceChrg():
+    payload = request.get_json(silent=True, force=True)
+    return wr.forceCharge(payload)
+
+@giv_api.route('/forceExport', methods=['POST'])
+def frceExprt():
+    payload = request.get_json(silent=True, force=True)
+    return wr.forceExport(payload)
+
 @giv_api.route('/setBatteryMode', methods=['POST'])
 def setBattMode():
     payload = request.get_json(silent=True, force=True)

GivTCP/influx.py

@@ -4,24 +4,25 @@
 from logging.handlers import TimedRotatingFileHandler
 from settings import GiV_Settings
 
+logger = logging.getLogger("GivTCP_Influx_"+str(GiV_Settings.givtcp_instance))
+logging.basicConfig(format='%(asctime)s - %(name)s - [%(levelname)s] - %(message)s')
+formatter = logging.Formatter(
+    '%(asctime)s - %(name)s - [%(levelname)s] - %(message)s')
+if GiV_Settings.Debug_File_Location!="":
+    fh = TimedRotatingFileHandler(GiV_Settings.Debug_File_Location, when='D', interval=1, backupCount=7)
+    fh.setFormatter(formatter)
+    logger.addHandler(fh)
 if GiV_Settings.Log_Level.lower()=="debug":
-    if GiV_Settings.Debug_File_Location=="":
-        logging.basicConfig(level=logging.DEBUG, format="%(asctime)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler()])
-    else:
-        logging.basicConfig(level=logging.DEBUG, format="%(asctime)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler(),TimedRotatingFileHandler(GiV_Settings.Debug_File_Location, when='D', interval=1, backupCount=7)])
+    logger.setLevel(logging.DEBUG)
 elif GiV_Settings.Log_Level.lower()=="info":
-    if GiV_Settings.Debug_File_Location=="":
-        logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler()])
-    else:
-        logging.basicConfig(level=logging.DEBUG, format="%(asctime)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler(),TimedRotatingFileHandler(GiV_Settings.Debug_File_Location, when='D', interval=1, backupCount=7)])
+    logger.setLevel(logging.INFO)
+elif GiV_Settings.Log_Level.lower()=="critical":
+    logger.setLevel(logging.CRITICAL)
+elif GiV_Settings.Log_Level.lower()=="warning":
+    logger.setLevel(logging.WARNING)
 else:
-    if GiV_Settings.Debug_File_Location=="":
-        logging.basicConfig(level=logging.ERROR, format="%(asctime)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler()])
-    else:
-        logging.basicConfig(level=logging.ERROR, format="%(asctime)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler(),TimedRotatingFileHandler(GiV_Settings.Debug_File_Location, when='D', interval=1, backupCount=7)])
-
+    logger.setLevel(logging.ERROR)
 
-logger = logging.getLogger("GivTCP_Influx_"+str(GiV_Settings.givtcp_instance))
 
 class GivInflux():
 

GivTCP/mqtt.py

@@ -1,31 +1,13 @@
 # version 2022.01.21
 import paho.mqtt.client as mqtt
 import time
-import datetime
-import logging
-from logging.handlers import TimedRotatingFileHandler
+from GivLUT import GivLUT
 from settings import GiV_Settings
+import sys
 #from HA_Discovery import HAMQTT
 from givenergy_modbus.model.inverter import Model
 
-if GiV_Settings.Log_Level.lower()=="debug":
-    if GiV_Settings.Debug_File_Location=="":
-        logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(name)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler()])
-    else:
-        logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(name)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler(),TimedRotatingFileHandler(GiV_Settings.Debug_File_Location, when='D', interval=1, backupCount=7)])
-elif GiV_Settings.Log_Level.lower()=="info":
-    if GiV_Settings.Debug_File_Location=="":
-        logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler()])
-    else:
-        logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler(),TimedRotatingFileHandler(GiV_Settings.Debug_File_Location, when='D', interval=1, backupCount=7)])
-else:
-    if GiV_Settings.Debug_File_Location=="":
-        logging.basicConfig(level=logging.ERROR, format="%(asctime)s - %(name)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler()])
-    else:
-        logging.basicConfig(level=logging.ERROR, format="%(asctime)s - %(name)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler(),TimedRotatingFileHandler(GiV_Settings.Debug_File_Location, when='D', interval=1, backupCount=7)])
-
-
-logger = logging.getLogger("GivTCP_MQTT_"+str(GiV_Settings.givtcp_instance))
+logger = GivLUT.logger
 
 class GivMQTT():
 
@@ -57,19 +39,23 @@ def multi_MQTT_publish(rootTopic,array):   #Recieve multiple payloads with Topic
 
         if GivMQTT.MQTTCredentials:
             client.username_pw_set(GivMQTT.MQTT_Username,GivMQTT.MQTT_Password)
-        client.on_connect=GivMQTT.on_connect     			#bind call back function
-        client.loop_start()
-        logger.info ("Connecting to broker: "+ GivMQTT.MQTT_Address)
-        client.connect(GivMQTT.MQTT_Address,port=GivMQTT.MQTT_Port)
-        while not client.connected_flag:        			#wait in loop
-            logger.info ("In wait loop")
-            time.sleep(0.2)
-        for p_load in array:
-            payload=array[p_load]
-            logger.info('Publishing: '+rootTopic+p_load)
-            output=GivMQTT.iterate_dict(payload,rootTopic+p_load)   #create LUT for MQTT publishing
-            for value in output:
-                client.publish(value,output[value])
+        try:
+            client.on_connect=GivMQTT.on_connect     			#bind call back function
+            client.loop_start()
+            logger.info ("Connecting to broker: "+ GivMQTT.MQTT_Address)
+            client.connect(GivMQTT.MQTT_Address,port=GivMQTT.MQTT_Port)
+            while not client.connected_flag:        			#wait in loop
+                logger.info ("In wait loop")
+                time.sleep(0.2)
+            for p_load in array:
+                payload=array[p_load]
+                logger.info('Publishing: '+rootTopic+p_load)
+                output=GivMQTT.iterate_dict(payload,rootTopic+p_load)   #create LUT for MQTT publishing
+                for value in output:
+                    client.publish(value,output[value])
+        except:
+            e = sys.exc_info()
+            logger.error("Error connecting to MQTT Broker: " + str(e))
         client.loop_stop()                      			#Stop loop
         client.disconnect()
         return client

GivTCP/mqtt_client.py

@@ -1,33 +1,15 @@
-from logging import Logger
 import paho.mqtt.client as mqtt
-import time
-import sys
-import importlib
-import logging
-from logging.handlers import TimedRotatingFileHandler
-import settings
+import time, sys, importlib, time
+from os.path import exists
 from settings import GiV_Settings
 import write as wr
-sys.path.append(GiV_Settings.default_path)
-
-if GiV_Settings.Log_Level.lower()=="debug":
-    if GiV_Settings.Debug_File_Location=="":
-        logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(name)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler()])
-    else:
-        logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(name)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler(),TimedRotatingFileHandler(GiV_Settings.Debug_File_Location, when='D', interval=1, backupCount=7)])
-elif GiV_Settings.Log_Level.lower()=="info":
-    if GiV_Settings.Debug_File_Location=="":
-        logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler()])
-    else:
-        logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler(),TimedRotatingFileHandler(GiV_Settings.Debug_File_Location, when='D', interval=1, backupCount=7)])
-else:
-    if GiV_Settings.Debug_File_Location=="":
-        logging.basicConfig(level=logging.ERROR, format="%(asctime)s - %(name)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler()])
-    else:
-        logging.basicConfig(level=logging.ERROR, format="%(asctime)s - %(name)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler(),TimedRotatingFileHandler(GiV_Settings.Debug_File_Location, when='D', interval=1, backupCount=7)])
+import pickle, settings
+from GivLUT import GivQueue, GivLUT
+from pickletools import read_uint1
 
+sys.path.append(GiV_Settings.default_path)
 
-logger = logging.getLogger("GivTCP_MQTT_client_"+str(GiV_Settings.givtcp_instance))
+logger = GivLUT.logger
 
 if GiV_Settings.MQTT_Port=='':
     MQTT_Port=1883
@@ -59,50 +41,111 @@
 logger.info("Serial Number retrieved: "+GiV_Settings.serial_number)
 
 def on_message(client, userdata, message):
+    payload={}
     logger.info("MQTT Message Recieved: "+str(message.topic)+"= "+str(message.payload.decode("utf-8")))
     writecommand={}
     command=str(message.topic).split("/")[-1]
     if command=="setDischargeRate":
         writecommand['dischargeRate']=str(message.payload.decode("utf-8"))
-        result=wr.setDischargeRate(writecommand)
+        result=GivQueue.q.enqueue(wr.setDischargeRate,writecommand)
     elif command=="setChargeRate":
         writecommand['chargeRate']=str(message.payload.decode("utf-8"))
-        result=wr.setChargeRate(writecommand)
+        result=GivQueue.q.enqueue(wr.setChargeRate,writecommand)
     elif command=="enableChargeTarget":
         writecommand['state']=str(message.payload.decode("utf-8"))
-        result=wr.enableChargeTarget(writecommand)
+        result=GivQueue.q.enqueue(wr.enableChargeTarget,writecommand)
     elif command=="enableChargeSchedule":
         writecommand['state']=str(message.payload.decode("utf-8"))
-        result=wr.enableChargeSchedule(writecommand)
+        result=GivQueue.q.enqueue(wr.enableChargeSchedule,writecommand)
     elif command=="enableDishargeSchedule":
         writecommand['state']=str(message.payload.decode("utf-8"))
-        result=wr.enableDischargeSchedule(writecommand)
+        result=GivQueue.q.enqueue(wr.enableDischargeSchedule,writecommand)
     elif command=="enableDischarge":
         writecommand['state']=str(message.payload.decode("utf-8"))
-        result=wr.enableDischarge(writecommand)
+        result=GivQueue.q.enqueue(wr.enableDischarge,writecommand)
     elif command=="setChargeTarget":
         writecommand['chargeToPercent']=str(message.payload.decode("utf-8"))
-        result=wr.setChargeTarget(writecommand)
+        result=GivQueue.q.enqueue(wr.setChargeTarget,writecommand)
     elif command=="setBatteryReserve":
         writecommand['dischargeToPercent']=str(message.payload.decode("utf-8"))
-        result=wr.setBatteryReserve(writecommand)
+        result=GivQueue.q.enqueue(wr.setBatteryReserve,writecommand)
     elif command=="setBatteryMode":
         writecommand['mode']=str(message.payload.decode("utf-8"))
-        result=wr.setBatteryMode(writecommand)
+        result=GivQueue.q.enqueue(wr.setBatteryMode,writecommand)
     elif command=="setDateTime":
         writecommand['dateTime']=str(message.payload.decode("utf-8"))
-        result=wr.setDateTime(writecommand)
+        result=GivQueue.q.enqueue(wr.setDateTime,writecommand)
     elif command=="setShallowCharge":
         writecommand['val']=str(message.payload.decode("utf-8"))
-        result=wr.setShallowCharge(writecommand)
-    elif command=="setChargeSlot1":
-        result=wr.setChargeSlot1(message.payload)
-    elif command=="setChargeSlot2":
-        result=wr.setChargeSlot2(message.payload)
-    elif command=="setDischargeSlot1":
-        result=wr.setDischargeSlot1(message.payload)
-    elif command=="setDischargeSlot1":
-        result=wr.setDischargeSlot1(message.payload)
+        result=GivQueue.q.enqueue(wr.setShallowCharge,writecommand)
+    elif command=="setChargeStart1":
+        if exists(GivLUT.regcache):
+            with open(GivLUT.regcache, 'rb') as inp:
+                regCacheStack= pickle.load(inp)
+            multi_output=regCacheStack[4]
+            finish=multi_output['Timeslots']['Charge_end_time_slot_1']
+            payload['start']=message.payload.decode("utf-8")[:5]
+            payload['finish']=finish[:5]
+            result=GivQueue.q.enqueue(wr.setChargeSlot1,payload)
+    elif command=="setChargeEnd1":
+        if exists(GivLUT.regcache):
+            with open(GivLUT.regcache, 'rb') as inp:
+                regCacheStack= pickle.load(inp)
+            multi_output=regCacheStack[4]
+            start=multi_output['Timeslots']['Charge_start_time_slot_1']
+            payload['finish']=message.payload.decode("utf-8")[:5]
+            payload['start']=start[:5]
+            result=GivQueue.q.enqueue(wr.setChargeSlot1,payload)
+    elif command=="setDischargeStart1":
+        if exists(GivLUT.regcache):
+            with open(GivLUT.regcache, 'rb') as inp:
+                regCacheStack= pickle.load(inp)
+            multi_output=regCacheStack[4]
+            finish=multi_output['Timeslots']['Discharge_end_time_slot_1']
+            payload['start']=message.payload.decode("utf-8")[:5]
+            payload['finish']=finish[:5]
+            result=GivQueue.q.enqueue(wr.setDischargeSlot1,payload)
+    elif command=="setDischargeEnd1":
+        if exists(GivLUT.regcache):
+            with open(GivLUT.regcache, 'rb') as inp:
+                regCacheStack= pickle.load(inp)
+            multi_output=regCacheStack[4]
+            start=multi_output['Timeslots']['Discharge_start_time_slot_1']
+            payload['finish']=message.payload.decode("utf-8")[:5]
+            payload['start']=start[:5]
+            result=GivQueue.q.enqueue(wr.setDischargeSlot1,payload)
+    elif command=="setDischargeStart2":
+        if exists(GivLUT.regcache):
+            with open(GivLUT.regcache, 'rb') as inp:
+                regCacheStack= pickle.load(inp)
+            multi_output=regCacheStack[4]
+            finish=multi_output['Timeslots']['Discharge_end_time_slot_2']
+            payload['start']=message.payload.decode("utf-8")[:5]
+            payload['finish']=finish[:5]
+            result=GivQueue.q.enqueue(wr.setDischargeSlot2,payload)
+    elif command=="setDischargeEnd2":
+        if exists(GivLUT.regcache):
+            with open(GivLUT.regcache, 'rb') as inp:
+                regCacheStack= pickle.load(inp)
+            multi_output=regCacheStack[4]
+            start=multi_output['Timeslots']['Discharge_start_time_slot_2']
+            payload['finish']=message.payload.decode("utf-8")[:5]
+            payload['start']=start[:5]
+            result=GivQueue.q.enqueue(wr.setDischargeSlot2,payload)
+#            result=wr.setDischargeSlot2(payload)
+    elif command=="tempPauseDischarge":
+        writecommand=float(message.payload.decode("utf-8"))
+        result=GivQueue.q.enqueue(wr.tempPauseDischarge,writecommand)
+    elif command=="tempPauseCharge":
+        writecommand=float(message.payload.decode("utf-8"))
+        result=GivQueue.q.enqueue(wr.tempPauseCharge,writecommand)
+    elif command=="forceCharge":
+        writecommand=float(message.payload.decode("utf-8"))
+        result=GivQueue.q.enqueue(wr.forceCharge,writecommand)
+    elif command=="forceExport":
+        writecommand=float(message.payload.decode("utf-8"))
+        result=GivQueue.q.enqueue(wr.forceExport,writecommand)
+#        result=wr.forceExport(writecommand)
     #Do something with the result??
 
 def on_connect(client, userdata, flags, rc):