340 lines
11 KiB
Python
340 lines
11 KiB
Python
# -*- coding: utf-8 -*-
|
|
import json
|
|
from time import sleep
|
|
from typing import Any, Dict, List, Optional
|
|
from uuid import uuid4
|
|
|
|
import paho.mqtt.client as mqtt
|
|
|
|
from ..solar_types import DataName
|
|
from ..srne import Srne
|
|
from . import BaseConsumer
|
|
|
|
MAP_VALUES: Dict[DataName, Dict[str, Any]] = {
|
|
# DataName.BATTERY_VOLTAGE_MIN: {},
|
|
# DataName.BATTERY_VOLTAGE_MAX: {},
|
|
# DataName.CHARGE_MAX_CURRENT: {},
|
|
# DataName._DISCHARGE_MAX_CURRENT: {},
|
|
# DataName.CHARGE_MAX_POWER: {},
|
|
# DataName.DISCHARGE_MAX_POWER: {},
|
|
# DataName.CHARGE_AMP_HOUR: {},
|
|
# DataName.DISCHARGE_AMP_HOUR: {},
|
|
DataName.PRODUCTION_ENERGY: {
|
|
"unit": "Wh",
|
|
"type": "energy",
|
|
"state_class": "total_increasing",
|
|
},
|
|
DataName.CONSUMPTION_ENERGY: {
|
|
"unit": "Wh",
|
|
"type": "energy",
|
|
"state_class": "total_increasing",
|
|
},
|
|
# DataName.RUN_DAYS: {},
|
|
# DataName.DISCHARGE_COUNT: {},
|
|
# DataName.FULL_CHARGE_COUNT: {},
|
|
# DataName.TOTAL_CHARGE_AMP_HOURS: {},
|
|
# DataName.TOTAL_DISCHARGE_AMP_HOURS: {},
|
|
DataName.TOTAL_PRODUCTION_ENERGY: {
|
|
"unit": "Wh",
|
|
"type": "energy",
|
|
"state_class": "total_increasing",
|
|
"expiry": 180,
|
|
},
|
|
DataName.TOTAL_CONSUMPTION_ENERGY: {
|
|
"unit": "Wh",
|
|
"type": "energy",
|
|
"state_class": "total_increasing",
|
|
"expiry": 180,
|
|
},
|
|
#
|
|
DataName.BATTERY_CHARGE: {
|
|
"unit": "%",
|
|
"type": "battery",
|
|
"state_class": "measurement",
|
|
},
|
|
DataName.BATTERY_VOLTAGE: {
|
|
"unit": "V",
|
|
"type": "voltage",
|
|
"state_class": "measurement",
|
|
},
|
|
DataName.BATTERY_CURRENT: {
|
|
"unit": "A",
|
|
"type": "current",
|
|
"state_class": "measurement",
|
|
},
|
|
DataName.INTERNAL_TEMPERATURE: {
|
|
"unit": "°C",
|
|
"type": "temperature",
|
|
"state_class": "measurement",
|
|
},
|
|
DataName.BATTERY_TEMPERATURE: {
|
|
"unit": "°C",
|
|
"type": "temperature",
|
|
"state_class": "measurement",
|
|
},
|
|
DataName.LOAD_VOLTAGE: {
|
|
"unit": "V",
|
|
"type": "voltage",
|
|
"state_class": "measurement",
|
|
},
|
|
DataName.LOAD_CURRENT: {
|
|
"unit": "A",
|
|
"type": "current",
|
|
"state_class": "measurement",
|
|
},
|
|
DataName.LOAD_POWER: {
|
|
"unit": "W",
|
|
"type": "power",
|
|
"state_class": "measurement",
|
|
},
|
|
DataName.LOAD_ENABLED: {
|
|
"type": "outlet",
|
|
"platform": "switch",
|
|
},
|
|
DataName.PANEL_VOLTAGE: {
|
|
"unit": "V",
|
|
"type": "voltage",
|
|
"state_class": "measurement",
|
|
},
|
|
DataName.PANEL_CURRENT: {
|
|
"unit": "A",
|
|
"type": "current",
|
|
"state_class": "measurement",
|
|
},
|
|
DataName.PANEL_POWER: {"unit": "W", "type": "power", "state_class": "measurement"},
|
|
# DataName.LOAD_ENABLED: {},
|
|
DataName.CALCULATED_BATTERY_POWER: {
|
|
"unit": "W",
|
|
"type": "power",
|
|
"state_class": "measurement",
|
|
},
|
|
DataName.CALCULATED_PANEL_POWER: {
|
|
"unit": "W",
|
|
"type": "power",
|
|
"state_class": "measurement",
|
|
},
|
|
DataName.CALCULATED_LOAD_POWER: {
|
|
"unit": "W",
|
|
"type": "power",
|
|
"state_class": "measurement",
|
|
},
|
|
}
|
|
|
|
|
|
class MqttConsumer(BaseConsumer):
|
|
client: mqtt.Client
|
|
initialized: List[str]
|
|
srne: Srne
|
|
|
|
def __init__(self, settings: Dict[str, Any], srne: Srne) -> None:
|
|
self.initialized = []
|
|
|
|
super().__init__(settings, srne)
|
|
self.client = mqtt.Client(client_id=settings["client"]["id"], userdata=self)
|
|
self.client.on_connect = self.on_connect
|
|
self.client.on_message = self.on_message
|
|
self.client.on_disconnect = self.on_disconnect
|
|
self.client.on_connect_fail = self.on_connect_fail
|
|
# Will must be set before connecting!!
|
|
self.client.will_set(
|
|
f"{self.topic_prefix}/available", payload="offline", retain=True
|
|
)
|
|
while True:
|
|
try:
|
|
self.client.connect(
|
|
settings["client"]["host"],
|
|
settings["client"]["port"],
|
|
settings["client"]["keepalive"],
|
|
)
|
|
break
|
|
except OSError as err:
|
|
# Network is unreachable
|
|
if err.errno == 101:
|
|
pass
|
|
# Temporary failure in name resolution
|
|
elif err.errno == -3:
|
|
pass
|
|
else:
|
|
raise
|
|
print(err)
|
|
sleep(0.1)
|
|
|
|
def config(self, settings: Dict[str, Any]):
|
|
super().config(settings)
|
|
settings.setdefault("client", {})
|
|
settings["client"].setdefault("id", None)
|
|
settings["client"].setdefault("host", "")
|
|
settings["client"].setdefault("port", 1883)
|
|
settings["client"].setdefault("keepalive", 60)
|
|
|
|
if not settings.get("device_id"):
|
|
settings["device_id"] = str(uuid4())
|
|
|
|
settings.setdefault("prefix", "solarmppt")
|
|
|
|
settings.setdefault("discovery_prefix", "homeassistant")
|
|
|
|
@property
|
|
def topic_prefix(self):
|
|
return f"{self.settings['prefix']}/{self.srne.serial}"
|
|
|
|
def get_ha_config(
|
|
self,
|
|
id,
|
|
name,
|
|
unit: Optional[str] = None,
|
|
type: Optional[str] = None,
|
|
expiry: int = 90,
|
|
state_class: Optional[str] = None,
|
|
platform: str = "sensor",
|
|
):
|
|
assert state_class in [None, "measurement", "total", "total_increasing"]
|
|
|
|
res = {
|
|
"~": f"{self.topic_prefix}",
|
|
"unique_id": f"srne_{self.srne.serial}_{id}",
|
|
"object_id": f"srne_{self.srne.serial}_{id}", # Used for entity id
|
|
"availability_topic": "~/available",
|
|
"state_topic": f"~/{id}",
|
|
"name": name,
|
|
"device": {
|
|
"identifiers": [
|
|
self.srne.serial,
|
|
],
|
|
# TODO: Get charger serial and use for identifier instead
|
|
# See: https://www.home-assistant.io/integrations/sensor.mqtt/#device
|
|
# "via_device": self.settings["device_id"],
|
|
"suggested_area": "Solar panel",
|
|
"manufacturer": "SRNE Solar",
|
|
"model": self.srne.model,
|
|
"name": self.srne.name,
|
|
"sw_version": self.srne.version,
|
|
"via_device": self.settings["device_id"],
|
|
},
|
|
"force_update": True,
|
|
"expire_after": expiry,
|
|
}
|
|
|
|
if unit:
|
|
res["unit_of_meas"] = unit
|
|
if type:
|
|
res["dev_cla"] = type
|
|
if state_class:
|
|
res["state_class"] = state_class
|
|
if platform == "switch":
|
|
res["command_topic"] = f"{res['state_topic']}/set"
|
|
res["payload_on"] = True
|
|
res["payload_off"] = False
|
|
|
|
return res
|
|
|
|
# The callback for when the client receives a CONNACK response from the server.
|
|
@staticmethod
|
|
def on_connect(client: mqtt.Client, userdata: "MqttConsumer", flags, rc):
|
|
print("Connected with result code " + str(rc))
|
|
|
|
# Subscribing in on_connect() means that if we lose the connection and
|
|
# reconnect then subscriptions will be renewed.
|
|
# client.subscribe("$SYS/#")
|
|
client.publish(
|
|
f"{userdata.topic_prefix}/available", payload="online", retain=True
|
|
)
|
|
|
|
load_set_topic = f"{userdata.topic_prefix}/load_enabled/set"
|
|
client.message_callback_add(load_set_topic, userdata.on_load_switch)
|
|
client.subscribe(load_set_topic)
|
|
|
|
@staticmethod
|
|
def on_load_switch(
|
|
client: mqtt.Client, userdata: "MqttConsumer", message: mqtt.MQTTMessage
|
|
):
|
|
print(message)
|
|
print(message.info)
|
|
print(message.state)
|
|
print(message.payload)
|
|
payload = message.payload.decode().upper() in ("ON", "TRUE", "ENABLE", "YES")
|
|
if type(payload) is bool:
|
|
res = userdata.srne.enable_load(payload)
|
|
client.publish(
|
|
f"{userdata.topic_prefix}/load_enabled", payload=res, retain=True
|
|
)
|
|
else:
|
|
print(f"!!! Unknown payload for switch callback: {message.payload!r}")
|
|
|
|
@staticmethod
|
|
def on_connect_fail(client: mqtt.Client, userdata: "MqttConsumer"):
|
|
print(userdata.__class__.__name__, "on_connect_fail")
|
|
|
|
# The callback for when a PUBLISH message is received from the server.
|
|
@staticmethod
|
|
def on_message(client, userdata, msg):
|
|
print(msg.topic + " " + str(msg.payload))
|
|
|
|
@staticmethod
|
|
def on_disconnect(client: mqtt.Client, userdata: "MqttConsumer", rc, prop=None):
|
|
print(userdata.__class__.__name__, "on_disconnect", rc)
|
|
|
|
def poll(self):
|
|
res = self.client.loop(timeout=0.1, max_packets=5)
|
|
|
|
if res != mqtt.MQTT_ERR_SUCCESS:
|
|
print(self.__class__.__name__, "loop returned non-success:", res)
|
|
try:
|
|
sleep(1)
|
|
res = self.client.reconnect()
|
|
if res != mqtt.MQTT_ERR_SUCCESS:
|
|
print(self.__class__.__name__, "Reconnect failed:", res)
|
|
except (OSError, mqtt.WebsocketConnectionError) as err:
|
|
print(self.__class__.__name__, "Reconnect failed:", err)
|
|
|
|
return super().poll()
|
|
|
|
def write(self, data: Dict[str, Any]):
|
|
self.client.publish(f"{self.topic_prefix}/raw", payload=json.dumps(data))
|
|
|
|
for k, v in data.items():
|
|
if k in MAP_VALUES:
|
|
if k not in self.initialized:
|
|
km = MAP_VALUES[DataName(k)]
|
|
pretty_name = k.replace("_", " ").capitalize()
|
|
disc_prefix = self.settings["discovery_prefix"]
|
|
platform = km.get("platform", "sensor")
|
|
self.client.publish(
|
|
f"{disc_prefix}/{platform}/srne_{self.srne.serial}_{k}/config",
|
|
payload=json.dumps(self.get_ha_config(k, pretty_name, **km)),
|
|
retain=True,
|
|
)
|
|
self.initialized.append(k)
|
|
|
|
self.client.publish(f"{self.topic_prefix}/{k}", v, retain=True)
|
|
|
|
def exit(self):
|
|
self.client.publish(
|
|
f"{self.topic_prefix}/available", payload="offline", retain=True
|
|
)
|
|
|
|
while self.client.want_write():
|
|
self.client.loop_write(10)
|
|
|
|
self.client.disconnect()
|
|
return super().exit()
|
|
|
|
|
|
# Client(client_id="", clean_session=True, userdata=None,
|
|
# protocol=MQTTv311, transport="tcp")
|
|
|
|
# connect_srv(domain, keepalive=60, bind_address="")
|
|
# Connect to a broker using an SRV DNS lookup to obtain the broker address.
|
|
# Takes the following arguments:
|
|
# domain
|
|
# the DNS domain to search for SRV records.
|
|
# If None, try to determine the local domain name.
|
|
|
|
# client.will_set(topic, payload=None, qos=0, retain=False)
|
|
|
|
# Blocking call that processes network traffic, dispatches callbacks and
|
|
# handles reconnecting.
|
|
# Other loop*() functions are available that give a threaded interface and a
|
|
# manual interface.
|
|
|
|
# client.loop_forever()
|