def register(self):
# Registriere Temperatur
unique_id = "sensor.dht-{}.{}.c".format(
self._config.get("DHT/dev/type", "22"),
self._config.get("DHT/name", "DHT"))
self._temp_topic = self._config.get_autodiscovery_topic(
conf.autodisc.Component.SENSOR,
"{}_C".format(self._config.get("DHT/name", "DHT")),
conf.autodisc.SensorDeviceClasses.TEMPERATURE)
self._sensor_celsius = Sensor(self.__logger.getChild("Celsuis"),
self._plugin_manager,
"{}_C".format(
self._config.get("DHT/name", "DHT")),
SensorDeviceClasses.TEMPERATURE,
"°C",
unique_id=unique_id,
value_template="{{ value_json.now }}",
json_attributes=True)
self._sensor_celsius.register()
self._sensor_celsius.addFilter(
TooHighFilter(40.0, self.__logger.getChild("Celsius")))
self._sensor_celsius.addFilter(
RangedFilter(5.0, 5, self.__logger.getChild("Celsius")))
# Registriere Luftfeuchte
unique_id = "sensor.dht-{}.{}.rh".format(
self._config.get("DHT/dev/type", "22"),
self._config.get("DHT/name", "DHT"),
)
self._sensor_humidity = Sensor(self.__logger.getChild("Humidity"),
self._plugin_manager,
"{}_Rh".format(
self._config.get("DHT/name",
"DHT")),
SensorDeviceClasses.HUMIDITY,
"%",
unique_id=unique_id,
value_template="{{ value_json.now }}",
json_attributes=True)
self._sensor_humidity.register()
self._sensor_humidity.addFilter(
TooHighFilter(100.0, self.__logger.getChild("Humidity")))
self._sensor_humidity.addFilter(
RangedFilter(5.0, 5, self.__logger.getChild("Humidity")))
self._daily_job = schedule.every().day.at("00:01")
self._daily_job.do(lambda: self._reset_daily())
self._job = schedule.every(self._config.get("DHT/update_seconds",
60)).seconds
self._job.do(lambda: self.send_update())
def register(self):
self.__logger.debug("Sensoren für {} werden erstellt...".format(
self._paths))
for d in self._paths:
unique_id = "sensor.w1-{}.{}".format(d["i"], d["n"])
sensor = Sensor(self.__logger,
self._plugin_manager,
d["n"],
SensorDeviceClasses.TEMPERATURE,
"C",
unique_id=unique_id,
value_template="{{ value_json.now }}",
json_attributes=True,
ownOfflineTopic=True)
sensor.addFilter(TooHighFilter(500.0, self.__logger))
sensor.addFilter(
DeltaFilter(self._config["w1t/diff/{}".format(d["i"])],
self.__logger))
sensor.register()
d["d"] = sensor
self._daily_job = schedule.every().day.at("00:00")
self._daily_job.do(lambda: self._reset_daily())
self._job = schedule.every(60).seconds
self._job.do(lambda: self.send_update())
self.send_update()
def register(self):
t = ad.Topics.get_std_devInf()
n = self._config.get("name", "CPU Temp")
self._shed_Job = schedule.every(self._config.get("update_secs",
15)).seconds
self._shed_Job.do(self.send_update)
self._sensor = Sensor(self.__logger, self._plugin_manager, n,
SensorDeviceClasses.TEMPERATURE, "C")
self._sensor.register()
self._sensor.addFilter(
MinTimeElapsed.MinTimeElapsedFilter(5.0, self.__logger))
self._sensor.addFilter(DeltaFilter.DeltaFilter(2.25, self.__logger))
self._sensor.addFilter(
TooHighFilter.TooHighFilter(150.0, self.__logger))
def __init__(self, logger: Logger, pman: PluginManager,
serial: Connection) -> None:
super().__init__()
self._log = logger.getChild("MPPT")
self._pman = pman
self._vcserial = serial
self.battery_voltage = Sensor(
self._log,
self._pman,
"Batterie V",
Autodiscovery.SensorDeviceClasses.VOLTAGE,
measurement_unit="V",
device=self._vcserial._device,
value_template="{{value_json.v}}",
json_attributes=True)
self.battery_voltage.addFilter(
DeltaFilter(0.05, self._log.getChild("BAT_V")))
self.battery_current = Sensor(
self._log,
self._pman,
"Batterie (A)",
Autodiscovery.SensorDeviceClasses.CURRENT,
measurement_unit="A",
device=self._vcserial._device,
value_template="{{value_json.a}}",
json_attributes=True)
self.panel_voltage = Sensor(self._log,
self._pman,
"Panel (V)",
Autodiscovery.SensorDeviceClasses.VOLTAGE,
measurement_unit="V",
device=self._vcserial._device,
value_template="{{value_json.v}}",
json_attributes=True)
self.panel_voltage.addFilter(DeltaFilter(1, self._log.getChild("VPV")))
self.panel_power = Sensor(self._log,
self._pman,
"Panel (W)",
Autodiscovery.SensorDeviceClasses.POWER,
measurement_unit="W",
device=self._vcserial._device,
value_template="{{value_json.w}}",
json_attributes=True)
self.panel_power.addFilter(DeltaFilter(1, self._log.getChild("PPV")))
self.load = Sensor(self._log,
self._pman,
"Last",
Autodiscovery.SensorDeviceClasses.CURRENT,
measurement_unit="A",
device=self._vcserial._device,
value_template="{{value_json.a}}",
json_attributes=True)
self.load_enabled = BinarySensor(
self._log,
self._pman,
"Last",
Autodiscovery.BinarySensorDeviceClasses.POWER,
device=self._vcserial._device)
self.yield_total = Sensor(self._log,
self._pman,
"Gesammelt (total)",
Autodiscovery.SensorDeviceClasses.ENERGY,
measurement_unit="kWh",
device=self._vcserial._device,
value_template="{{value_json.kWh}}",
json_attributes=True)
self.yield_today = Sensor(self._log,
self._pman,
"Gesammelt (Heute)",
Autodiscovery.SensorDeviceClasses.ENERGY,
measurement_unit="kWh",
device=self._vcserial._device,
value_template="{{value_json.kWh}}",
json_attributes=True)
self.yield_yesterday = Sensor(self._log,
self._pman,
"Gesammelt (Gestern)",
Autodiscovery.SensorDeviceClasses.ENERGY,
measurement_unit="kWh",
device=self._vcserial._device,
value_template="{{value_json.kWh}}",
json_attributes=True)
self.max_power_today = Sensor(self._log,
self._pman,
"Maximal Strom (Heute)",
Autodiscovery.SensorDeviceClasses.POWER,
measurement_unit="W",
device=self._vcserial._device,
value_template="{{value_json.w}}",
json_attributes=True)
self.max_power_yesterday = Sensor(
self._log,
self._pman,
"Maximal Strom (Gestern)",
Autodiscovery.SensorDeviceClasses.POWER,
measurement_unit="W",
device=self._vcserial._device,
value_template="{{value_json.w}}",
json_attributes=True)
self.error = BinarySensor(
self._log,
self._pman,
"Fehler",
Autodiscovery.BinarySensorDeviceClasses.PROBLEM,
"",
device=self._vcserial._device,
value_template="{{value_json.is_error}}",
json_attributes=True)
self.state_of_operation = Sensor(
self._log,
self._pman,
"Status",
Autodiscovery.SensorDeviceClasses.GENERIC_SENSOR,
"",
device=self._vcserial._device)
self.mppt = Sensor(self._log,
self._pman,
"MPPT",
Autodiscovery.SensorDeviceClasses.GENERIC_SENSOR,
"",
device=self._vcserial._device)
class MPPT(CONST.VEDirectDevice):
_callbacks = {}
def __init__(self, logger: Logger, pman: PluginManager,
serial: Connection) -> None:
super().__init__()
self._log = logger.getChild("MPPT")
self._pman = pman
self._vcserial = serial
self.battery_voltage = Sensor(
self._log,
self._pman,
"Batterie V",
Autodiscovery.SensorDeviceClasses.VOLTAGE,
measurement_unit="V",
device=self._vcserial._device,
value_template="{{value_json.v}}",
json_attributes=True)
self.battery_voltage.addFilter(
DeltaFilter(0.05, self._log.getChild("BAT_V")))
self.battery_current = Sensor(
self._log,
self._pman,
"Batterie (A)",
Autodiscovery.SensorDeviceClasses.CURRENT,
measurement_unit="A",
device=self._vcserial._device,
value_template="{{value_json.a}}",
json_attributes=True)
self.panel_voltage = Sensor(self._log,
self._pman,
"Panel (V)",
Autodiscovery.SensorDeviceClasses.VOLTAGE,
measurement_unit="V",
device=self._vcserial._device,
value_template="{{value_json.v}}",
json_attributes=True)
self.panel_voltage.addFilter(DeltaFilter(1, self._log.getChild("VPV")))
self.panel_power = Sensor(self._log,
self._pman,
"Panel (W)",
Autodiscovery.SensorDeviceClasses.POWER,
measurement_unit="W",
device=self._vcserial._device,
value_template="{{value_json.w}}",
json_attributes=True)
self.panel_power.addFilter(DeltaFilter(1, self._log.getChild("PPV")))
self.load = Sensor(self._log,
self._pman,
"Last",
Autodiscovery.SensorDeviceClasses.CURRENT,
measurement_unit="A",
device=self._vcserial._device,
value_template="{{value_json.a}}",
json_attributes=True)
self.load_enabled = BinarySensor(
self._log,
self._pman,
"Last",
Autodiscovery.BinarySensorDeviceClasses.POWER,
device=self._vcserial._device)
self.yield_total = Sensor(self._log,
self._pman,
"Gesammelt (total)",
Autodiscovery.SensorDeviceClasses.ENERGY,
measurement_unit="kWh",
device=self._vcserial._device,
value_template="{{value_json.kWh}}",
json_attributes=True)
self.yield_today = Sensor(self._log,
self._pman,
"Gesammelt (Heute)",
Autodiscovery.SensorDeviceClasses.ENERGY,
measurement_unit="kWh",
device=self._vcserial._device,
value_template="{{value_json.kWh}}",
json_attributes=True)
self.yield_yesterday = Sensor(self._log,
self._pman,
"Gesammelt (Gestern)",
Autodiscovery.SensorDeviceClasses.ENERGY,
measurement_unit="kWh",
device=self._vcserial._device,
value_template="{{value_json.kWh}}",
json_attributes=True)
self.max_power_today = Sensor(self._log,
self._pman,
"Maximal Strom (Heute)",
Autodiscovery.SensorDeviceClasses.POWER,
measurement_unit="W",
device=self._vcserial._device,
value_template="{{value_json.w}}",
json_attributes=True)
self.max_power_yesterday = Sensor(
self._log,
self._pman,
"Maximal Strom (Gestern)",
Autodiscovery.SensorDeviceClasses.POWER,
measurement_unit="W",
device=self._vcserial._device,
value_template="{{value_json.w}}",
json_attributes=True)
self.error = BinarySensor(
self._log,
self._pman,
"Fehler",
Autodiscovery.BinarySensorDeviceClasses.PROBLEM,
"",
device=self._vcserial._device,
value_template="{{value_json.is_error}}",
json_attributes=True)
self.state_of_operation = Sensor(
self._log,
self._pman,
"Status",
Autodiscovery.SensorDeviceClasses.GENERIC_SENSOR,
"",
device=self._vcserial._device)
self.mppt = Sensor(self._log,
self._pman,
"MPPT",
Autodiscovery.SensorDeviceClasses.GENERIC_SENSOR,
"",
device=self._vcserial._device)
def register_entities(self):
self.battery_current.register()
self.battery_voltage.register()
self.error.register()
self.load.register()
self.load_enabled.register()
self.max_power_today.register()
self.max_power_yesterday.register()
self.panel_power.register()
self.panel_voltage.register()
self.state_of_operation.register()
self.yield_today.register()
self.yield_total.register()
self.yield_yesterday.register()
self.mppt.register()
self._callbacks["V"] = self.update_battery_voltage
self._callbacks["VPV"] = self.update_panel_voltage
self._callbacks["PPV"] = self.update_panel_power
self._callbacks["I"] = self.update_battery_current
self._callbacks["IL"] = self.update_load_current
self._callbacks["LOAD"] = self.update_load_state
self._callbacks["H19"] = self.update_yield_total
self._callbacks["H20"] = self.update_yield_today
self._callbacks["H21"] = self.update_max_power_today
self._callbacks["H22"] = self.update_yield_yesterday
self._callbacks["H23"] = self.update_max_power_yesterday
self._callbacks["ERR"] = self.update_ERROR
self._callbacks["CS"] = self.update_state_operation
self._callbacks["MPPT"] = self.update_mppt
self._vcserial.set_callbacks(self._callbacks)
def update_battery_voltage(self, mV: str):
mV = int(mV)
js = {"v": mV / 1000}
self.battery_voltage(js, keypath="v")
def update_panel_voltage(self, mV: str):
mV = int(mV)
js = {"v": mV / 1000}
self.panel_voltage(js, keypath="v")
def update_panel_power(self, w: str):
w = int(w)
js = {"w": w}
self.panel_power(js, keypath="w")
def update_battery_current(self, mA: str):
mA = int(mA)
js = {"a": mA / 1000}
self.battery_current(json.dumps(js))
def update_load_current(self, mA: str):
mA = int(mA)
js = {"a": mA / 1000}
self.load(json.dumps(js))
def update_load_state(self, on: str):
self.load_enabled.turnOnOff(on == "ON")
def update_yield_total(self, kWh: str):
kWh = float(kWh)
js = {"kWh": kWh * 0.01}
self.yield_total(json.dumps(js))
def update_yield_today(self, kWh: str):
kWh = float(kWh)
js = {"kWh": kWh * 0.01}
self.yield_today(json.dumps(js))
def update_max_power_today(self, w: str):
w = int(w)
js = {"w": w}
self.max_power_today(json.dumps(js))
def update_yield_yesterday(self, kWh: str):
kWh = float(kWh)
js = {"kWh": kWh * 0.01}
self.yield_yesterday(json.dumps(js))
def update_max_power_yesterday(self, w: str):
w = int(w)
js = {"w": w}
self.max_power_yesterday(json.dumps(js))
def update_ERROR(self, err: str):
err = int(err)
err_str = CONST.ERR[err]
js = {
"is_error": 0 if err_str == CONST.ERR[0] else 1,
"Errno": err,
"Fehler": err_str
}
self.error.turn(js)
def update_state_operation(self, state: str):
state = int(state)
self.state_of_operation(CONST.CS.get(state, "Unbekannt"))
def update_mppt(self, state: str):
if state == "0":
self.mppt("AUS")
elif state == "1":
self.mppt("Voltage or Current limited")
elif state == "2":
self.mppt("MPPT Tracker active")
def resend_entities(self):
self.battery_current.resend()
self.battery_voltage.reset()
self.error.reset()
self.load.reset()
self.load_enabled.reset()
self.max_power_today.reset()
self.max_power_yesterday.reset()
self.panel_power.reset()
self.panel_voltage.reset()
self.state_of_operation.reset()
self.yield_today.reset()
self.yield_total.reset()
self.yield_yesterday.reset()
self.mppt.reset()
class DHT22(PluginInterface):
_temp_topic = None
_rh_topic = None
_sensor_celsius: Sensor = None
_sensor_humidity: Sensor = None
def _reset_daily(self):
for i in ["°c", "rH%"]:
path_min = "DHT/stat/{}/min".format(i)
path_max = "DHT/stat/{}/max".format(i)
path_lmin = "DHT/stat/{}/lmin".format(i)
path_lmax = "DHT/stat/{}/lmax".format(i)
if self._config[path_min] == "RESET":
continue
elif self._config[path_max] == "RESET":
continue
current_min = self._config.get(path_min, "n/A")
current_max = self._config.get(path_max, "n/A")
self.__logger.debug("{} = {}".format(path_lmin, current_min))
self._config.sett(path_lmin, current_min)
self.__logger.debug("{} = {}".format(path_lmax, current_max))
self._config.sett(path_lmax, current_max)
self.__logger.debug("reset daily stats")
self._config[path_min] = "RESET"
self._config[path_max] = "RESET"
def __init__(self, client: mclient.Client, opts: conf.BasicConfig,
logger: logging.Logger, device_id: str):
self._config = opts
self.__client = client
self.__logger = logger.getChild("w1Temp")
self._prev_deg = [None, None]
self.dht = None
self._plugin_manager = None
if isinstance(self._config.get("DHT", None), list):
devices = self._config["DHT"]
self._config["DHT"] = {}
self._config["DHT/dev"] = devices
sensor_map = {
'11': Adafruit_DHT.DHT11,
'22': Adafruit_DHT.DHT22,
'2302': Adafruit_DHT.AM2302
}
self.dht = sensor_map.get(self._config.get("DHT/dev/type", "22"),
Adafruit_DHT.DHT22)
self.__lastTemp = 0.0
self.__ava_topic = device_id
def register(self):
# Registriere Temperatur
unique_id = "sensor.dht-{}.{}.c".format(
self._config.get("DHT/dev/type", "22"),
self._config.get("DHT/name", "DHT"))
self._temp_topic = self._config.get_autodiscovery_topic(
conf.autodisc.Component.SENSOR,
"{}_C".format(self._config.get("DHT/name", "DHT")),
conf.autodisc.SensorDeviceClasses.TEMPERATURE)
self._sensor_celsius = Sensor(self.__logger.getChild("Celsuis"),
self._plugin_manager,
"{}_C".format(
self._config.get("DHT/name", "DHT")),
SensorDeviceClasses.TEMPERATURE,
"°C",
unique_id=unique_id,
value_template="{{ value_json.now }}",
json_attributes=True)
self._sensor_celsius.register()
self._sensor_celsius.addFilter(
TooHighFilter(40.0, self.__logger.getChild("Celsius")))
self._sensor_celsius.addFilter(
RangedFilter(5.0, 5, self.__logger.getChild("Celsius")))
# Registriere Luftfeuchte
unique_id = "sensor.dht-{}.{}.rh".format(
self._config.get("DHT/dev/type", "22"),
self._config.get("DHT/name", "DHT"),
)
self._sensor_humidity = Sensor(self.__logger.getChild("Humidity"),
self._plugin_manager,
"{}_Rh".format(
self._config.get("DHT/name",
"DHT")),
SensorDeviceClasses.HUMIDITY,
"%",
unique_id=unique_id,
value_template="{{ value_json.now }}",
json_attributes=True)
self._sensor_humidity.register()
self._sensor_humidity.addFilter(
TooHighFilter(100.0, self.__logger.getChild("Humidity")))
self._sensor_humidity.addFilter(
RangedFilter(5.0, 5, self.__logger.getChild("Humidity")))
self._daily_job = schedule.every().day.at("00:01")
self._daily_job.do(lambda: self._reset_daily())
self._job = schedule.every(self._config.get("DHT/update_seconds",
60)).seconds
self._job.do(lambda: self.send_update())
def stop(self):
schedule.cancel_job(self._daily_job)
schedule.cancel_job(self._job)
def sendStates(self):
self.send_update(True)
def sendTemperature(self, degree, force):
new_temp = degree
if new_temp != self._prev_deg[0] or force:
ii = "°c"
path_min = "DHT/stat/{}/min".format(ii)
path_max = "DHT/stat/{}/max".format(ii)
path_lmin = "DHT/stat/{}/lmin".format(ii)
path_lmax = "DHT/stat/{}/lmax".format(ii)
cmin = self._config.get(path_min, "RESET")
cmax = self._config.get(path_max, "RESET")
if cmin == "RESET" or cmin == "n/A":
cmin = new_temp
elif cmin > new_temp:
cmin = new_temp
if cmax == "RESET" or cmax == "n/A":
cmax = new_temp
elif cmax < new_temp:
cmax = new_temp
self._config[path_min] = cmin
self._config[path_max] = cmax
js = {
"now": new_temp,
"Heute höchster Wert": cmax,
"Heute tiefster Wert": cmin,
"Gestern höchster Wert": self._config.get(path_lmax, "n/A"),
"Gestern tiefster Wert": self._config.get(path_lmin, "n/A")
}
if new_temp != -1000 and self._prev_deg == -1000:
self.__client.publish(self._temp_topic.ava_topic,
"online",
retain=True)
self._sensor_celsius(js, keypath="now")
elif new_temp != -1000:
self._sensor_celsius(js, keypath="now")
else:
self.__client.publish(self._temp_topic.ava_topic,
"offline",
retain=True)
self._prev_deg[0] = new_temp
def sendHumidity(self, rel_hum, force):
new_temp = rel_hum
if new_temp != self._prev_deg[1] or force:
ii = "rH%"
path_min = "DHT/stat/{}/min".format(ii)
path_max = "DHT/stat/{}/max".format(ii)
path_lmin = "DHT/stat/{}/lmin".format(ii)
path_lmax = "DHT/stat/{}/lmax".format(ii)
cmin = self._config.get(path_min, "RESET")
cmax = self._config.get(path_max, "RESET")
if cmin == "RESET" or cmin == "n/A":
cmin = new_temp
elif cmin > new_temp:
cmin = new_temp
if cmax == "RESET" or cmax == "n/A":
cmax = new_temp
elif cmax < new_temp:
cmax = new_temp
self._config[path_min] = cmin
self._config[path_max] = cmax
js = {
"now": new_temp,
"Heute höchster Wert": cmax,
"Heute tiefster Wert": cmin,
"Gestern höchster Wert": self._config.get(path_lmax, "n/A"),
"Gestern tiefster Wert": self._config.get(path_lmin, "n/A")
}
if new_temp != -1000 and self._prev_deg == -1000:
self.__client.publish(self._rh_topic.ava_topic,
"online",
retain=True)
self._sensor_humidity(js, keypath="now")
elif new_temp != -1000:
self._sensor_humidity(js, keypath="now")
else:
self.__client.publish(self._rh_topic.ava_topic,
"offline",
retain=True)
self._prev_deg[1] = new_temp
def send_update(self, force=False, insane=0):
humidity, temperature = Adafruit_DHT.read_retry(
self.dht, self._config.get("DHT/dev/pin", 22))
humidity = round(humidity, ndigits=1)
temperature = round(temperature, ndigits=1)
self.sendTemperature(temperature, force)
self.sendHumidity(humidity, force)
def set_pluginManager(self, pm):
self._plugin_manager = pm
class RaspberryPiCpuTemp:
_shed_Job = None
_sensor: Sensor
_plugin_manager: PluginManager
def __init__(self, client: mclient.Client, opts: conf.BasicConfig,
logger: logging.Logger, device_id: str):
self._config = conf.PluginConfig(opts, "rpiCPUtemp")
self.__client = client
self.__logger = logger.getChild("PiCpuTemp")
self._prev_deg = 0
if self._config.get("diff", None) is None:
self._config["diff"] = 1.5
self._callables = []
self._open_file()
def _open_file(self):
self._file = open("/sys/class/thermal/thermal_zone0/temp")
def add_temperature_call(self, call):
if callable(call):
self._callables.append(call)
def register(self):
t = ad.Topics.get_std_devInf()
n = self._config.get("name", "CPU Temp")
self._shed_Job = schedule.every(self._config.get("update_secs",
15)).seconds
self._shed_Job.do(self.send_update)
self._sensor = Sensor(self.__logger, self._plugin_manager, n,
SensorDeviceClasses.TEMPERATURE, "C")
self._sensor.register()
self._sensor.addFilter(
MinTimeElapsed.MinTimeElapsedFilter(5.0, self.__logger))
self._sensor.addFilter(DeltaFilter.DeltaFilter(2.25, self.__logger))
self._sensor.addFilter(
TooHighFilter.TooHighFilter(150.0, self.__logger))
def set_pluginManager(self, pm):
self._plugin_manager = pm
def stop(self):
schedule.cancel_job(self._shed_Job)
self._file.close()
def sendStates(self):
self.send_update(True)
@staticmethod
def get_temperatur_file(f):
data = f.read()
f.seek(0)
return round(int(data) / 1000, 1)
@staticmethod
def get_temperatur(p) -> float:
if os.path.isfile(p):
data = None
with open(p) as f:
data = f.read()
f.close()
if data is not None:
return round(int(data) / 1000, 2)
return -1000
def send_update(self, force=False):
try:
new_temp = self.get_temperatur_file(self._file)
except ValueError:
self._open_file()
return
for call in self._callables:
try:
call(new_temp)
except:
self.__logger.exception("Temperature callback error")
self._sensor(new_temp)