juham-automation 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

juham_automation/automation/spothintafi.py

@@ -0,0 +1,123 @@
+from datetime import datetime
+import time
+import json
+from typing import Any, Dict, Optional, cast
+from typing_extensions import override
+
+from masterpiece.mqtt import Mqtt, MqttMsg
+from juham_core import JuhamCloudThread, JuhamThread
+
+
+class SpotHintaFiThread(JuhamCloudThread):
+    """Thread running SpotHinta.fi.
+
+    Periodically fetches the spot electricity prices and publishes them
+    to  'spot' topic.
+    """
+
+    _spot_topic: str = ""
+    _url: str = ""
+    _interval: float = 12 * 3600
+
+    def __init__(self, client: Optional[Mqtt] = None) -> None:
+        super().__init__(client)
+        self._interval = 60
+
+    def init(self, topic: str, url: str, interval: float) -> None:
+        self._spot_topic = topic
+        self._url = url
+        self._interval = interval
+
+    @override
+    def make_weburl(self) -> str:
+        return self._url
+
+    @override
+    def update_interval(self) -> float:
+        return self._interval
+
+    @override
+    def process_data(self, rawdata: Any) -> None:
+        """Publish electricity price message to Juham topic.
+
+        Args:
+            rawdata (dict): electricity prices
+        """
+
+        super().process_data(rawdata)
+        data = rawdata.json()
+
+        spot = []
+        for e in data:
+            ts = time.mktime(time.strptime(e["DateTime"], "%Y-%m-%dT%H:%M:%S%z"))
+            hour = datetime.utcfromtimestamp(ts).strftime("%H")
+            h = {
+                "Timestamp": ts,
+                "hour": hour,
+                "Rank": e["Rank"],
+                "PriceWithTax": e["PriceWithTax"],
+            }
+            spot.append(h)
+        self.publish(self._spot_topic, json.dumps(spot), 1, True)
+        self.info(f"Spot electricity prices published for the next {len(spot)} days")
+
+
+class SpotHintaFi(JuhamThread):
+    """Spot electricity price for reading hourly electricity prices from
+    https://api.spot-hinta.fi site.
+    """
+
+    worker_thread_id = SpotHintaFiThread.get_class_id()
+    url = "https://api.spot-hinta.fi/TodayAndDayForward"
+    update_interval = 12 * 3600
+
+    def __init__(self, name: str = "rspothintafi") -> None:
+        super().__init__(name)
+        self.active_liter_lpm = -1
+        self.update_ts = None
+        self.spot_topic = self.make_topic_name("spot")
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        super().on_connect(client, userdata, flags, rc)
+        if rc == 0:
+            self.subscribe(self.spot_topic)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        if msg.topic == self.spot_topic:
+            em = json.loads(msg.payload.decode())
+            self.on_spot(em)
+        else:
+            super().on_message(client, userdata, msg)
+
+    def on_spot(self, m: dict[Any, Any]) -> None:
+        """Write hourly spot electricity prices to time series database.
+
+        Args:
+            m (dict): holding hourly spot electricity prices
+        """
+        pass
+
+    @override
+    def run(self) -> None:
+        self.worker = cast(SpotHintaFiThread, self.instantiate(self.worker_thread_id))
+        self.worker.init(self.spot_topic, self.url, self.update_interval)
+        super().run()
+
+    @override
+    def to_dict(self) -> Dict[str, Any]:
+        data: Dict[str, Any] = super().to_dict()
+        data["_spothintafi"] = {
+            "topic": self.spot_topic,
+            "url": self.url,
+            "interval": self.update_interval,
+        }
+        return data
+
+    @override
+    def from_dict(self, data: Dict[str, Any]) -> None:
+        super().from_dict(data)
+        if "_spothintafi" in data:
+            for key, value in data["_spothintafi"].items():
+                setattr(self, key, value)

juham_automation/automation/watercirculator.py

@@ -0,0 +1,159 @@
+from typing import Any
+from typing_extensions import override
+import json
+
+from masterpiece.mqtt import MqttMsg
+from juham_core import Juham
+from juham_core.timeutils import timestamp
+
+
+class WaterCirculator(Juham):
+    """Hot Water Circulation Automation
+
+    This system monitors motion sensor data to detect home occupancy.
+
+    - **When motion is detected**: The water circulator pump is activated, ensuring hot water is
+        instantly available when the tap is turned on.
+    - **When no motion is detected for a specified period (in seconds)**: The pump automatically
+        switches off to conserve energy.
+
+    Future improvement idea
+    ------------------------
+
+    In cold countries, such as Finland, energy conservation during the winter season may not be a priority.
+    In this case, an additional temperature sensor measuring the outside temperature could be used to determine whether
+    the circulator should be switched off at all. The circulating water could potentially act as an additional heating radiator.
+
+    Points to consider
+    ------------------
+
+    - Switching the pump on and off may affect its lifetime.
+    - Keeping the pump running with hot water could impact the lifespan of the pipes, potentially causing
+      corrosion due to constant hot water flow.
+
+    """
+
+    uptime = 60 * 60  # one hour
+    min_temperature = 37
+
+    def __init__(self, name: str, temperature_sensor: str) -> None:
+        super().__init__(name)
+
+        # input topics
+        self.motion_topic = self.make_topic_name("motion")  # motion detection
+        self.temperature_topic = self.make_topic_name(temperature_sensor)
+
+        # relay to be controlled
+        self.topic_power = self.make_topic_name("power")
+
+        # for the pump controlling logic
+        self.current_motion: bool = False
+        self.relay_started_ts: float = 0
+        self.water_temperature: float = 0
+        self.water_temperature_updated: float = 0
+        self.initialized = False
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        super().on_connect(client, userdata, flags, rc)
+        if rc == 0:
+            self.subscribe(self.motion_topic)
+            self.subscribe(self.temperature_topic)
+            # reset the relay to make sure the initial state matches the state of us
+            self.publish_relay_state(0)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        if msg.topic == self.temperature_topic:
+            m = json.loads(msg.payload.decode())
+            self.on_temperature_sensor(m, timestamp())
+        elif msg.topic == self.motion_topic:
+            m = json.loads(msg.payload.decode())
+            self.on_motion_sensor(m, timestamp())
+        else:
+            super().on_message(client, userdata, msg)
+
+    def on_temperature_sensor(self, m: dict[str, Any], ts_utc_now: float) -> None:
+        """Handle message from the hot water pipe temperature sensor.
+        Records the temperature and updates the water_temperature_updated attribute.
+
+        Args:
+            m (dict): temperature reading from the hot water blump sensor
+            ts_utc_now (float): _current utc time
+        """
+
+        self.water_temperature = m["temperature"]
+        self.water_temperature_updated = ts_utc_now
+        # self.info(
+        #    f"Temperature of circulating water updated to {self.water_temperature} C"
+        # )
+
+    def on_motion_sensor(self, m: dict[str, dict[str, Any]], ts_utc_now: float) -> None:
+        """Control the water cirulator bump.
+
+        Given message from the motion sensor consider switching the
+        circulator bump on.
+
+        Args:
+            msg (dict): directionary holding motion sensor data
+            ts_utc_now (float): current time stamp
+        """
+        sensor = m["sensor"]
+        vibration: bool = bool(m["vibration"])
+        motion: bool = bool(m["motion"])
+
+        if motion or vibration:
+            # self.debug(f"Life form detected in {sensor}")
+            # honey I'm home
+            if not self.current_motion:
+                if self.water_temperature > self.min_temperature:
+                    self.publish_relay_state(0)
+                    # self.debug(
+                    #    f"Circulator: motion detected but water warm already {self.water_temperature} > {self.min_temperature} C"
+                    # )
+                else:
+                    self.current_motion = True
+                    self.relay_started_ts = ts_utc_now
+                    self.publish_relay_state(1)
+                    self.initialized = True
+                    self.info(
+                        f"Circulator pump started, will run for {int(self.uptime / 60)} minutes "
+                    )
+            else:
+                self.publish_relay_state(1)
+                self.relay_started_ts = ts_utc_now
+                # self.debug(
+                #    f"Circulator pump has been running for {int(ts_utc_now - self.relay_started_ts)/60} minutes",
+                #    " ",
+                # )
+        else:
+            if self.current_motion or not self.initialized:
+                elapsed: float = ts_utc_now - self.relay_started_ts
+                if elapsed > self.uptime:
+                    self.publish_relay_state(0)
+                    self.info(
+                        f"Circulator  pump stopped, no motion in {int(elapsed/60)} minutes detected",
+                        "",
+                    )
+                    self.current_motion = False
+                    self.initialized = True
+                else:
+                    self.publish_relay_state(1)
+                    # self.debug(
+                    #    f"Circulator bump stop countdown {int(self.uptime - (ts_utc_now - self.relay_started_ts ))/60} min"
+                    # )
+            else:
+                self.publish_relay_state(0)
+                # self.debug(
+                #    f"Circulator bump off already, temperature {self.water_temperature} C",
+                #    "",
+                # )
+
+    def publish_relay_state(self, state: int) -> None:
+        """Publish power status.
+
+        Args:
+            state (int): 1 for on, 0 for off, as defined by Juham 'power' topic
+        """
+        heat = {"Unit": self.name, "Timestamp": timestamp(), "State": state}
+        self.publish(self.topic_power, json.dumps(heat), 1, False)

juham_automation/japp.py

@@ -1,55 +1,49 @@
-from masterpiece import Application
-from juham_core import Juham
-from juham_systemstatus import SystemStatus
-
-from .ts.forecast_ts import ForecastTs
-from .ts.power_ts import PowerTs
-from .ts.powerplan_ts import PowerPlanTs
-from .ts.powermeter_ts import PowerMeterTs
-from .ts.log_ts import LogTs
-from .ts.energycostcalculator_ts import EnergyCostCalculatorTs
-from .ts.electricityprice_ts import ElectricityPriceTs
-from .automation.spothintafi import SpotHintaFi
-from .automation.energycostcalculator import EnergyCostCalculator
-
-
-class JApp(Application):
-    """Juham home automation application base class. Registers new plugin
-    group 'juham' on which general purpose Juham plugins can be written on.
-    """
-
-    def __init__(self, name: str) -> None:
-        """Creates home automation application with the given name.
-        If --enable_plugins is False create hard coded configuration
-        by calling instantiate_classes() method.
-
-        Args:
-            name (str): name for the application
-        """
-        super().__init__(name, Juham(name))
-
-    def instantiate_classes(self) -> None:
-        """Instantiate automation classes .
-
-        Returns:
-            None
-        """
-        self.add(ForecastTs())
-        self.add(PowerTs())
-        self.add(PowerPlanTs())
-        self.add(PowerMeterTs())
-        self.add(LogTs())
-        self.add(SpotHintaFi())
-        self.add(EnergyCostCalculator())
-        self.add(EnergyCostCalculatorTs())
-        self.add(ElectricityPriceTs())
-
-        # install plugins
-        self.add(self.instantiate_plugin_by_name("SystemStatus"))
-        self.add(self.instantiate_plugin_by_name("VisualCrossing"))
-        self.add(self.instantiate_plugin_by_name("OpenWeatherMap"))
-
-    @classmethod
-    def register(cls) -> None:
-        """Register plugin group `juham`."""
-        Application.register_plugin_group("juham")
+from masterpiece import Application
+from juham_core import Juham
+
+from .ts import ForecastTs
+from .ts import PowerTs
+from .ts import PowerPlanTs
+from .ts import PowerMeterTs
+from .ts import LogTs
+from .ts import EnergyCostCalculatorTs
+from .ts import ElectricityPriceTs
+from .automation import SpotHintaFi
+from .automation import EnergyCostCalculator
+
+
+class JApp(Application):
+    """Juham home automation application base class. Registers new plugin
+    group 'juham' on which general purpose Juham plugins can be written on.
+    """
+
+    def __init__(self, name: str) -> None:
+        """Creates home automation application with the given name.
+        If --enable_plugins is False create hard coded configuration
+        by calling instantiate_classes() method.
+
+        Args:
+            name (str): name for the application
+        """
+        super().__init__(name, Juham(name))
+
+    def instantiate_classes(self) -> None:
+        """Instantiate automation classes .
+
+        Returns:
+            None
+        """
+        self.add(ForecastTs())
+        self.add(PowerTs())
+        self.add(PowerPlanTs())
+        self.add(PowerMeterTs())
+        self.add(LogTs())
+        self.add(SpotHintaFi())
+        self.add(EnergyCostCalculator())
+        self.add(EnergyCostCalculatorTs())
+        self.add(ElectricityPriceTs())
+
+    @classmethod
+    def register(cls) -> None:
+        """Register plugin group `juham`."""
+        Application.register_plugin_group("juham")

juham_automation/ts/__init__.py

@@ -0,0 +1,25 @@
+"""
+Description
+===========
+
+Juham - Juha's Ultimate Home Automation Timeseries 
+
+"""
+
+from .energycostcalculator_ts import EnergyCostCalculatorTs
+from .log_ts import LogTs
+from .power_ts import PowerTs
+from .powerplan_ts import PowerPlanTs
+from .powermeter_ts import PowerMeterTs
+from .electricityprice_ts import ElectricityPriceTs
+from .forecast_ts import ForecastTs
+
+__all__ = [
+    "EnergyCostCalculatorTs",
+    "ForecastTs",
+    "LogTs",
+    "PowerTs",
+    "PowerPlanTs",
+    "PowerMeterTs",
+    "ElectricityPriceTs",
+]

juham_automation/ts/electricityprice_ts.py

@@ -0,0 +1,47 @@
+from datetime import datetime
+import time
+import json
+from typing import Any, Dict, Optional, cast
+from typing_extensions import override
+
+from masterpiece.mqtt import Mqtt, MqttMsg
+from juham_core.timeutils import epoc2utc
+from juham_core import JuhamTs
+
+
+class ElectricityPriceTs(JuhamTs):
+    """Spot electricity price for reading hourly electricity prices from"""
+
+    def __init__(self, name: str = "electricityprice_ts") -> None:
+        super().__init__(name)
+
+        self.spot_topic = self.make_topic_name("spot")
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        super().on_connect(client, userdata, flags, rc)
+        if rc == 0:
+            self.subscribe(self.spot_topic)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        if msg.topic == self.spot_topic:
+            em = json.loads(msg.payload.decode())
+            self.on_spot(em)
+        else:
+            super().on_message(client, userdata, msg)
+
+    def on_spot(self, m: dict[Any, Any]) -> None:
+        """Write hourly spot electricity prices to time series database.
+
+        Args:
+            m (dict): holding hourlys spot electricity prices
+        """
+        for h in m:
+            point = (
+                self.measurement("spot")
+                .tag("hour", h["Timestamp"])
+                .field("value", h["PriceWithTax"])
+                .time(epoc2utc(h["Timestamp"]))
+            )
+            self.write(point)

juham_automation/ts/energycostcalculator_ts.py

@@ -0,0 +1,43 @@
+from typing import Any
+from typing_extensions import override
+import json
+
+from masterpiece.mqtt import MqttMsg
+
+from juham_core import JuhamTs
+from juham_core.timeutils import (
+    epoc2utc,
+    timestampstr,
+)
+
+
+class EnergyCostCalculatorTs(JuhamTs):
+    """The EnergyCostCalculator recorder."""
+
+    def __init__(self, name: str = "ecc_ts") -> None:
+        super().__init__(name)
+        self.topic_net_energy_balance = self.make_topic_name("net_energy_cost")
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        super().on_connect(client, userdata, flags, rc)
+        if rc == 0:
+            self.subscribe(self.topic_net_energy_balance)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        super().on_message(client, userdata, msg)
+        if msg.topic == self.topic_net_energy_balance:
+            m = json.loads(msg.payload.decode())
+            self.record_powerconsumption(m)
+
+    def record_powerconsumption(self, m: dict[str, Any]) -> None:
+        """Record powerconsumption
+
+        Args:
+            m (dict[str, Any]): to be recorded
+        """
+
+        self.write_point(
+            "energycost", {"site": m["name"]}, m, timestampstr(m["ts"])
+        )

juham_automation/ts/forecast_ts.py

@@ -0,0 +1,97 @@
+import json
+from typing import Any
+from typing_extensions import override
+
+from masterpiece.mqtt import MqttMsg
+from juham_core import JuhamTs
+from juham_core.timeutils import epoc2utc
+
+
+class ForecastTs(JuhamTs):
+    """Forecast database record.
+
+    This class listens the forecast topic and writes to the time series
+    database.
+    """
+
+    def __init__(self, name: str = "forecast_ts") -> None:
+        """Construct forecast record object with the given name."""
+        super().__init__(name)
+        self.forecast_topic = self.make_topic_name("forecast")
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        """Standard mqtt connect notification.
+
+        This method is called when the client connection with the MQTT
+        broker is established.
+        """
+        super().on_connect(client, userdata, flags, rc)
+        self.subscribe(self.forecast_topic)
+        self.debug(f"Subscribed to {self.forecast_topic}")
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        """Standard mqtt message notification method.
+
+        This method is called upon new arrived message.
+        """
+        if msg.topic == self.forecast_topic:
+            m = json.loads(msg.payload.decode())
+            self.on_forecast(m)
+        else:
+            super().on_message(client, userdata, msg)
+
+    def on_forecast(self, em: dict[Any, Any]) -> None:
+        """Handle weather forecast data. Writes the received hourly forecast
+        data to timeseries database.
+
+        Args:
+            em (dict): forecast
+        """
+
+        # List of fields you want to add
+        fields = [
+            "ts",
+            "day",
+            "solarradiation",
+            "solarenergy",
+            "cloudcover",
+            "snowdepth",
+            "uvindex",
+            "pressure",
+            "humidity",
+            "windspeed",
+            "winddir",
+            "temp",
+            "feels",
+        ]
+        days: int = 0
+        for m in em:
+            senderid: str = "unknown"
+            if "id" in m:
+                senderid = m["id"]
+            if not "hour" in m:
+                self.error(
+                    f"No hour key in forecast record from {senderid}, skipped", str(m)
+                )
+            else:
+                point = (
+                    self.measurement("forecast")
+                    .tag("hour", m.get("hour"))
+                    .tag("source", senderid)
+                    .field("hr", str(m["hour"]))
+                )
+                # Conditionally add each field
+                for field in fields:
+                    if field in m:
+                        if field == "day" or field == "ts":
+                            point = point.field(field, m[field])
+                        else:
+                            point = point.field(field, float(m[field]))
+                    point = point.time(epoc2utc(m["ts"]))
+                self.write(point)
+                days = days + 1
+        self.info(
+            f"Forecast from {senderid} for the next {days} days written to time series database"
+        )

juham_automation/ts/log_ts.py

@@ -0,0 +1,57 @@
+import json
+from typing import Any
+from typing_extensions import override
+
+from masterpiece.mqtt import MqttMsg
+from juham_core import JuhamTs
+from juham_core.timeutils import epoc2utc
+
+
+class LogTs(JuhamTs):
+    """Class recording application events, such as warnings and errors,
+    to time series database."""
+
+    def __init__(self, name: str = "log_ts") -> None:
+        """Creates mqtt client for recording log events to time series
+        database.
+
+        Args:
+            name (str): name for the client
+        """
+        super().__init__(name)
+        self.topic_name = self.make_topic_name("log")
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        """Connects the client to mqtt broker.
+
+        Args:
+            client (obj): client to be connected
+            userdata (any): caller specific data
+            flags (int): implementation specific shit
+
+        Returns:
+            rc (bool): True if successful
+        """
+        super().on_connect(client, userdata, flags, rc)
+        if rc == 0:
+            self.subscribe(self.topic_name)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        m = json.loads(msg.payload.decode())
+        ts = epoc2utc(m["Timestamp"])
+
+        point = (
+            self.measurement("log")
+            .tag("class", m["Class"])
+            .field("source", m["Source"])
+            .field("msg", m["Msg"])
+            .field("details", m["Details"])
+            .field("Timestamp", m["Timestamp"])
+            .time(ts)
+        )
+        try:
+            self.write(point)
+        except Exception as e:
+            self.log_message("Error", f"Cannot write log event {m['Msg']}", str(e))