New picing module for Spanish PVPC model

TWCManager.py

@@ -74,6 +74,7 @@
     "Status.MQTTStatus",
     "Pricing.aWATTarPricing",
     "Pricing.StaticPricing",
+    "Pricing.PVPCesPricing",
 ]
 
 # Enable support for Python Visual Studio Debugger

etc/twcmanager/config.json

@@ -423,7 +423,14 @@
                 "import": 0.20,
                 "export": 0.09
             }
+        },
+        "PVPCes": {
+            # Enable this module if you are a customer under PVPC in Spain
+            # You need to get a personal token from https://api.esios.ree.es/ 
+            "enabled": false,
+            "token": "xxx"
         }
+
     },
     "sources":{
         # This section is where we configure the various sources that we retrieve our generation and consumption

lib/TWCManager/Control/HTTPControl.py

@@ -661,6 +661,16 @@ def chargeScheduleDay(self, day):
         page += "<td>" + self.checkBox("flex"+suffix, 
                 today.get("flex", 0)) + "</td>"
         page += "<td>Flex Charge</td>"
+        if master.getPricingInAdvanceAvailable():
+            page += "<td>" + self.checkBox("cheaper"+suffix,
+                    today.get("cheaper", 0)) + "</td>"
+            page += "<td>Flex Cheaper</td>"
+            if not today.get("flex", 0):
+               page += "<td>" + self.optionList(self.hoursDurationList,
+                 {"name": "actualH"+suffix,
+                  "value": today.get("actualH", 1)}) + "</td>"
+               page += "<td>hours</td>"
+
         page += "</tr>"
         return page
 
@@ -709,11 +719,13 @@ def process_save_schedule(self):
                 master.settings["Schedule"][day] = {}
             master.settings["Schedule"][day]["enabled"] = ""
             master.settings["Schedule"][day]["flex"] = ""
+            master.settings["Schedule"][day]["cheaper"] = ""
+            master.settings["Schedule"][day]["actualH"] = ""
 
         # Detect schedule keys. Rather than saving them in a flat
         # structure, we'll store them multi-dimensionally
         fieldsout = self.fields.copy()
-        ct = re.compile(r'(?P<trigger>enabled|end|flex|start)(?P<day>.*?)ChargeTime')
+        ct = re.compile(r'(?P<trigger>enabled|end|flex|cheaper|actualH|start)(?P<day>.*?)ChargeTime')
         for key in self.fields:
             match = ct.match(key)
             if match:

lib/TWCManager/Pricing/PVPCesPricing.py

@@ -0,0 +1,189 @@
+from datetime import datetime
+from datetime import timedelta
+
+class PVPCesPricing:
+
+    import requests
+    import time
+
+    # https://www.esios.ree.es/es/pvpc publishes at 20:30CET eveyday the prices for next day
+    # There is no limitation to fetch prices as it's updated onces a day
+    cacheTime = 1
+    config = None
+    configConfig = None
+    configPvpc = None
+    exportPrice = 0
+    fetchFailed = False
+    importPrice = 0
+    lastFetch = 0
+    status = False
+    timeout = 10
+    headers = {}
+    todayImportPrice = {}
+
+    def __init__(self, master):
+
+        self.master = master
+        self.config = master.config
+        try:
+            self.configConfig = master.config["config"]
+        except KeyError:
+            self.configConfig = {}
+
+        try:
+            self.configPvpc = master.config["pricing"]["PVPCes"]
+        except KeyError:
+            self.configPvpc = {}
+
+        self.status = self.configPvpc.get("enabled", self.status)
+        self.debugLevel = self.configConfig.get("debugLevel", 0)
+
+        token=self.configPvpc.get("token")
+        if self.status:
+            self.headers = {
+                'Accept': 'application/json; application/vnd.esios-api-v1+json',
+                'Content-Type': 'application/json',
+                'Host': 'api.esios.ree.es',
+                'Cookie': '',
+            }
+            self.headers['Authorization']="Token token="+token
+
+        # Unload if this module is disabled or misconfigured
+        if not self.status:
+            self.master.releaseModule("lib.TWCManager.Pricing", self.__class__.__name__)
+            return None
+
+    def getExportPrice(self):
+
+        if not self.status:
+            self.master.debugLog(
+                10,
+                "$PVPCes",
+                "PVPCes	Pricing Module Disabled. Skipping getExportPrice",
+            )
+            return 0
+
+        # Perform updates if necessary
+        self.update()
+
+        # Return current export price
+        return float(self.exportPrice)
+
+    def getImportPrice(self):
+
+        if not self.status:
+            self.master.debugLog(
+                10,
+                "$PVPCes",
+                "PVPCes Pricing Module Disabled. Skipping getImportPrice",
+            )
+            return 0
+
+        # Perform updates if necessary
+        self.update()
+
+
+
+        # Return current import price
+        return float(self.importPrice)
+
+    def update(self):
+
+        # Fetch the current pricing data from the https://www.esios.ree.es/es/pvpc API
+        self.fetchFailed = False
+        now=datetime.now()
+        tomorrow=datetime.now() + timedelta(days=1)
+        if self.lastFetch == 0 or (now.hour < self.lastFetch.hour):
+            # Cache not  feched or was feched yesterday. Fetch values from API.
+            ini=str(now.year)+"-"+str(now.month)+"-"+str(now.day)+"T"+"00:00:00"
+            end=str(tomorrow.year)+"-"+str(tomorrow.month)+"-"+str(tomorrow.day)+"T"+"23:00:00"
+
+            url = "https://api.esios.ree.es/indicators/1014?start_date="+ini+"&end_date="+end
+
+            try:
+                r = self.requests.get(url,headers=self.headers, timeout=self.timeout)
+            except self.requests.exceptions.ConnectionError as e:
+                self.master.debugLog(
+                    4,
+                    "$PVPCes",
+                    "Error connecting to PVPCes API to fetch market pricing",
+                )
+                self.fetchFailed = True
+                return False
+
+            self.lastFetch= now 
+
+            try:
+                r.raise_for_status()
+            except self.requests.exceptions.HTTPError as e:
+                self.master.debugLog(
+                    4,
+                    "$PVPCes",
+                    "HTTP status "
+                    + str(e.response.status_code)
+                    + " connecting to PVPCes API to fetch market pricing",
+                )
+                return False
+
+            if r.json():
+                self.todayImportPrice=r.json()
+
+        if self.todayImportPrice:
+            try:
+               self.importPrice = float(
+                    self.todayImportPrice['indicator']['values'][now.hour]['value']
+               )
+               # Convert MWh price to KWh
+               self.importPrice = round(self.importPrice / 1000,5)
+
+            except (KeyError, TypeError) as e:
+               self.master.debugLog(
+                    4,
+                    "$PVPCes",
+                    "Exception during parsing PVPCes pricing",
+               )
+
+    def getCheapestStartHour(self,numHours,ini,end):
+        # Perform updates if necessary
+        self.update()
+
+        minPriceHstart=ini
+        if self.todayImportPrice:
+            try:
+               if end < ini:
+               # If the scheduled hours are bettween days we consider hours going from 0 to 47
+               # tomorrow 1am will be 25
+                  end = 24 + end
+
+               i=ini
+               minPrice=999999999
+               while i<=(end-numHours):
+                   j=0
+                   priceH=0
+                   while j<numHours:
+                       price =  float(self.todayImportPrice['indicator']['values'][i+j]['value'])
+
+                       priceH = priceH + price
+
+                       j=j+1
+                   if  priceH<minPrice:
+                       minPrice=priceH
+                       minPriceHstart=i
+                   i=i+1
+
+
+            except (KeyError, TypeError) as e:
+               self.master.debugLog(
+                    4,
+                    "$PVPCes",
+                    "Exception during cheaper pricing analice",
+               )
+
+            if minPriceHstart > 23:
+               minPriceHstart = minPriceHstart - 24
+
+        return minPriceHstart
+
+    def getPricingInAdvanceAvailable(self):
+        return True
+

lib/TWCManager/Pricing/StaticPricing.py

@@ -73,3 +73,7 @@ def getImportPrice(self):
         # Return current import price
         return float(self.importPrice)
 
+    def getPricingInAdvanceAvailable(self):
+        # For future implementation
+        return False
+

lib/TWCManager/Pricing/aWATTarPricing.py

@@ -118,4 +118,6 @@ def update(self):
                         "Exception during parsing aWATTar pricing",
                     )
 
+    def getPricingInAdvanceAvailable(self):
+        return False
 

lib/TWCManager/TWCMaster.py

@@ -106,8 +106,8 @@ def checkScheduledCharging(self):
 
         # Check if we're within the hours we must use scheduledAmpsMax instead
         # of nonScheduledAmpsMax
-        blnUseScheduledAmps = 0
         ltNow = time.localtime()
+        blnUseScheduledAmps = 0
         hourNow = ltNow.tm_hour + (ltNow.tm_min / 60)
         timeSettings = self.getScheduledAmpsTimeFlex()
         startHour = timeSettings[0]
@@ -145,6 +145,7 @@ def checkScheduledCharging(self):
                     and (daysBitmap & (1 << ltNow.tm_wday))
                 ):
                     blnUseScheduledAmps = 1
+
         return blnUseScheduledAmps
 
     def convertAmpsToWatts(self, amps):
@@ -269,6 +270,26 @@ def getPricing(self):
             self.exportPricingValues[module["name"]] = module["ref"].getExportPrice()
             self.importPricingValues[module["name"]] = module["ref"].getImportPrice()
 
+    def getPricingInAdvanceAvailable(self):
+        for module in self.getModulesByType("Pricing"):
+            if module["ref"].getPricingInAdvanceAvailable():
+               return True
+        return False
+
+    def getCheaperDayChargeTime(self,dayName):
+        return self.settings["Schedule"][dayName]["cheaper"]
+
+    def getActualHDayChargeTime(self,dayName):
+        return self.settings["Schedule"][dayName]["actualH"]
+
+    def getCheapestStartHour(self,numHours,ini,end):
+        # We take the latest modul data
+        cheapestStartHour = ini
+        for module in self.getModulesByType("Pricing"):
+             cheapestStartHour = module["ref"].getCheapestStartHour(numHours,ini,end)
+
+        return cheapestStartHour
+
     def getScheduledAmpsDaysBitmap(self):
         return self.settings.get("scheduledAmpsDaysBitmap", 0x7F)
 
@@ -289,9 +310,49 @@ def getScheduledAmpsMax(self):
         else:
             return 0
 
+    def getActualHscheduledAmps(self):
+        return int(self.settings.get("actualHscheduledAmps", -1))
+
     def getScheduledAmpsStartHour(self):
         return int(self.settings.get("scheduledAmpsStartHour", -1))
 
+
+
+    def getScheduledAmpsCheaperFlex(self, startHour, endHour, daysBitmap):
+        # adjust the charge start time to minimize the cost
+        if not self.getPricingInAdvanceAvailable():
+           return (startHour, endHour, daysBitmap)
+
+        daysNames = [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ]
+        ltNow = time.localtime()
+        hourNow = ltNow.tm_hour + (ltNow.tm_min / 60)
+        dayName = daysNames[ltNow.tm_wday+1]
+
+        if self.getCheaperDayChargeTime(dayName):
+           self.debugLog(10,"TWCMaster","getCheaperDayChargeTime True")
+           if self.getScheduledAmpsFlexStart():
+              #If flex start is active the actual charge duration will be taken from the flex period established 
+              if startHour < endHour:
+                 numHours = endHour-startHour
+              else:
+                 numHours = 24-startHour+endHour
+           else:
+              #If flex start is not active the actual charge duration s taken from the scheduled flex cheaper hours config 
+              numHours = self.getActualHDayChargeTime(dayName)
+              if numHours:
+                 numHours = numHours/3600
+
+           if numHours:
+              self.debugLog(10,"TWCMaster","numHours: "+str(numHours))
+              cheapestStartHour = self.getCheapestStartHour(numHours,startHour,endHour)
+              self.debugLog(10,"TWCMaster","cheapestStartHour: "+str(cheapestStartHour))
+              startHour = cheapestStartHour
+              endHour = startHour+numHours
+              if endHour >= 24:
+                 endHour = endHour - 24
+
+        return (startHour, endHour, daysBitmap)
+
     def getScheduledAmpsTimeFlex(self):
         startHour = self.getScheduledAmpsStartHour()
         days = self.getScheduledAmpsDaysBitmap()
@@ -325,7 +386,10 @@ def getScheduledAmpsTimeFlex(self):
                 # (if starting usually at 9pm and it calculates to start at 4am - it's already the next day)
                 if startHour < self.getScheduledAmpsDaysBitmap():
                     days = self.rotl(days, 7)
-        return (startHour, self.getScheduledAmpsEndHour(), days)
+
+        timeSettings = self.getScheduledAmpsCheaperFlex(startHour, self.getScheduledAmpsEndHour(), days)
+
+        return timeSettings
 
     def getScheduledAmpsEndHour(self):
         return self.settings.get("scheduledAmpsEndHour", -1)