643 lines
21 KiB
Python
Executable File
643 lines
21 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import argparse
|
|
import logging
|
|
import queue
|
|
import sys
|
|
import time
|
|
import os
|
|
import json
|
|
import db
|
|
from collections import namedtuple
|
|
from itho_i2c import I2CMaster, I2CSlave
|
|
|
|
logger = logging.getLogger("stdout")
|
|
logger.setLevel(logging.INFO)
|
|
stdout_log_handler = logging.StreamHandler(sys.stdout)
|
|
stdout_log_handler.setFormatter(logging.Formatter("%(message)s"))
|
|
logger.addHandler(stdout_log_handler)
|
|
|
|
|
|
actions = {
|
|
"getnodeid": [0x90, 0xE0],
|
|
"getserial": [0x90, 0xE1],
|
|
"getdatatype": [0xA4, 0x00],
|
|
"getdatalog": [0xA4, 0x01],
|
|
"getsetting": [0xA4, 0x10],
|
|
"setsetting": [0xA4, 0x10],
|
|
"getmanual": [0x40, 0x30],
|
|
"setmanual": [0x40, 0x30],
|
|
"getcounters": [0x42, 0x10],
|
|
}
|
|
|
|
|
|
def parse_args():
|
|
parser = argparse.ArgumentParser(description="Itho WPU i2c master")
|
|
|
|
parser.add_argument(
|
|
"--action",
|
|
nargs="?",
|
|
required=True,
|
|
choices=list(actions.keys()) + ["getsettings"],
|
|
help="Execute an action",
|
|
)
|
|
parser.add_argument(
|
|
"--id",
|
|
nargs="?",
|
|
type=int,
|
|
help="Setting or manual identifier",
|
|
)
|
|
parser.add_argument(
|
|
"--value",
|
|
nargs="?",
|
|
help="Setting value",
|
|
)
|
|
parser.add_argument(
|
|
"--check",
|
|
default=True,
|
|
action=argparse.BooleanOptionalAction,
|
|
help="Enable/disable manual operation (used with --setmanual)",
|
|
)
|
|
parser.add_argument(
|
|
"--loglevel",
|
|
nargs="?",
|
|
choices=["debug", "info", "warning", "error", "critical"],
|
|
help="Loglevel",
|
|
)
|
|
parser.add_argument("--timestamp", action="store_true", help="Show timestamp in output")
|
|
parser.add_argument("--master-only", action="store_true", help="Only run I2C master")
|
|
parser.add_argument("--slave-only", action="store_true", help="Only run I2C slave")
|
|
parser.add_argument(
|
|
"--slave-timeout",
|
|
nargs="?",
|
|
type=int,
|
|
default=60,
|
|
help="Slave timeout in seconds when --slave-only",
|
|
)
|
|
parser.add_argument("--no-cache", action="store_true", help="Don't use local cache")
|
|
parser.add_argument(
|
|
"--export-to-influxdb",
|
|
action="store_true",
|
|
help="Export results to InfluxDB",
|
|
)
|
|
|
|
args = parser.parse_args()
|
|
return args
|
|
|
|
|
|
class IthoWPU:
|
|
def __init__(self, master_only, slave_only, slave_timeout, no_cache):
|
|
self.master_only = master_only
|
|
self.slave_only = slave_only
|
|
self.slave_timeout = slave_timeout
|
|
self._q = queue.Queue()
|
|
self.no_cache = no_cache
|
|
self.cache = IthoWPUCache()
|
|
self.nodeid = self.call("getnodeid")
|
|
self.datatype = self.call("getdatatype")
|
|
self.heatpump_db = db.sqlite("heatpump.sqlite")
|
|
|
|
def call(self, action, identifier=None, datatype=None, value=None, check=True):
|
|
if not self.no_cache:
|
|
response = self.cache.call(action.replace("get", ""))
|
|
if response is not None:
|
|
logger.debug(f"Response (from cache): {response}")
|
|
return response
|
|
|
|
response = None
|
|
|
|
if not self.master_only:
|
|
slave = I2CSlave(address=0x40, queue=self._q)
|
|
slave.set_callback()
|
|
if self.slave_only:
|
|
time.sleep(self.slave_timeout)
|
|
|
|
if not self.slave_only:
|
|
master = I2CMaster(address=0x41, bus=1, queue=self._q)
|
|
if action:
|
|
response = master.execute_action(action, identifier, datatype, value, check)
|
|
logger.debug(f"Response: {response}")
|
|
master.close()
|
|
|
|
if not self.master_only:
|
|
slave.close()
|
|
|
|
self.cache.set(action.replace("get", ""), response)
|
|
|
|
return response
|
|
|
|
def get_listversion_from_nodeid(self):
|
|
if self.nodeid is None:
|
|
return
|
|
return int(self.nodeid[10], 0)
|
|
|
|
def get_datalog_structure(self):
|
|
listversion = self.get_listversion_from_nodeid()
|
|
datalabel_version = self.heatpump_db.execute(
|
|
f"SELECT datalabel FROM versiebeheer WHERE version = {listversion}"
|
|
)[0]["datalabel"]
|
|
if datalabel_version is None or not type(datalabel_version) == int:
|
|
logger.error(f"Datalabel not found in database for version {listversion}")
|
|
return None
|
|
datalabel = self.heatpump_db.execute(
|
|
f"SELECT name, title, tooltip, unit FROM datalabel_v{datalabel_version} order by id"
|
|
)
|
|
|
|
if len(self.datatype[5:-1]) != len(datalabel):
|
|
logger.warning(
|
|
f"Number of datatype items ({len(self.datatype[5:-1])}) is not equal to "
|
|
f"the number of datalabels ({len(datalabel)}) in the database."
|
|
)
|
|
|
|
Field = namedtuple("Field", "index type label description")
|
|
|
|
datalog = []
|
|
index = 0
|
|
for dl, dt in zip(datalabel, self.datatype[5:-1]):
|
|
dt = int(dt, 0)
|
|
description = dl["title"].title()
|
|
if dl["unit"] is not None:
|
|
description = f"{description} ({dl['unit']})"
|
|
description = f"{description} ({dl['name'].lower()})"
|
|
datalog.append(Field(index, dt, dl["name"].lower(), description))
|
|
|
|
if dt in [0x0, 0x1, 0x2, 0xC, 0xF, 0x6C, 0x80, 0x81, 0x82, 0x8F]:
|
|
index = index + 1
|
|
elif dt in [0x10, 0x11, 0x12, 0x13, 0x14, 0x51, 0x90, 0x91, 0x92]:
|
|
index = index + 2
|
|
elif dt in [0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5]:
|
|
index = index + 4
|
|
else:
|
|
logger.error(f"Unknown data type for label {dl['name']}: {dt}")
|
|
return datalog
|
|
return datalog
|
|
|
|
def get_counters(self):
|
|
listversion = self.get_listversion_from_nodeid()
|
|
counters_version = self.heatpump_db.execute(
|
|
f"SELECT counters FROM versiebeheer WHERE version = {listversion}"
|
|
)[0]["counters"]
|
|
if counters_version is None or not type(counters_version) == int:
|
|
logger.error(f"Counters not found in database for version {listversion}")
|
|
return None
|
|
settings = self.heatpump_db.execute(
|
|
"SELECT id, name, title, tooltip, unit " + f"FROM counters_v{counters_version}"
|
|
)
|
|
return settings
|
|
|
|
def get_settings(self):
|
|
listversion = self.get_listversion_from_nodeid()
|
|
parameterlist_version = self.heatpump_db.execute(
|
|
f"SELECT parameterlist FROM versiebeheer WHERE version = {listversion}"
|
|
)[0]["parameterlist"]
|
|
if parameterlist_version is None or not type(parameterlist_version) == int:
|
|
logger.error(f"Parameterlist not found in database for version {listversion}")
|
|
return None
|
|
settings = self.heatpump_db.execute(
|
|
"SELECT id, name, min, max, def, title, description, unit "
|
|
+ f"FROM parameterlijst_v{parameterlist_version}"
|
|
)
|
|
return settings
|
|
|
|
def get_setting_by_id(self, settingid):
|
|
listversion = self.get_listversion_from_nodeid()
|
|
parameterlist_version = self.heatpump_db.execute(
|
|
f"SELECT parameterlist FROM versiebeheer WHERE version = {listversion}"
|
|
)[0]["parameterlist"]
|
|
if parameterlist_version is None or not type(parameterlist_version) == int:
|
|
logger.error(f"Parameterlist not found in database for version {listversion}")
|
|
return None
|
|
setting_details = self.heatpump_db.execute(
|
|
"SELECT name, min, max, def, title, description, unit "
|
|
+ f"FROM parameterlijst_v{parameterlist_version} WHERE id = {settingid}"
|
|
)
|
|
if len(setting_details) != 1:
|
|
return None
|
|
return setting_details[0]
|
|
|
|
def get_manual_by_id(self, manualid):
|
|
listversion = self.get_listversion_from_nodeid()
|
|
handbed_version = self.heatpump_db.execute(
|
|
f"SELECT handbed FROM versiebeheer WHERE version = {listversion}"
|
|
)[0]["handbed"]
|
|
if handbed_version is None or not type(handbed_version) == int:
|
|
logger.error(f"Handbed not found in database for version {listversion}")
|
|
return None
|
|
manual_details = self.heatpump_db.execute(
|
|
"SELECT name, min, max, def, title, tooltip, unit "
|
|
+ f"FROM handbed_v{handbed_version} WHERE id = {manualid}"
|
|
)
|
|
if len(manual_details) != 1:
|
|
return None
|
|
return manual_details[0]
|
|
|
|
|
|
class IthoWPUCache:
|
|
def __init__(self):
|
|
self._cache_file = "itho-wpu-cache.json"
|
|
self._cache_data = {
|
|
"nodeid": None,
|
|
"serial": None,
|
|
"datatype": None,
|
|
"schema_version": "1",
|
|
}
|
|
self._read_cache()
|
|
|
|
def _read_cache(self):
|
|
if not os.path.exists(self._cache_file):
|
|
logger.debug(f"Not loading cache file: {self._cache_file} does not exist")
|
|
return
|
|
with open(self._cache_file) as cache_file:
|
|
cache_data = json.load(cache_file)
|
|
logger.debug(f"Loading local cache: {json.dumps(cache_data)}")
|
|
for key in ["nodeid", "serial", "datatype"]:
|
|
if key in cache_data:
|
|
self._cache_data[key] = cache_data[key]
|
|
|
|
def _write_cache(self):
|
|
with open(self._cache_file, "w") as cache_file:
|
|
logger.debug(f"Writing to local cache: {json.dumps(self._cache_data)}")
|
|
json.dump(self._cache_data, cache_file)
|
|
|
|
def call(self, action):
|
|
if action not in ["nodeid", "serial", "datatype"]:
|
|
logger.debug(f"Cache for '{action}' is not supported")
|
|
return None
|
|
logger.debug(f"Reading '{action}' from local cache")
|
|
if self._cache_data[action] is None:
|
|
logger.debug(f"Action '{action}' is not present in local cache")
|
|
return self._cache_data[action]
|
|
|
|
def set(self, action, value):
|
|
if action not in ["nodeid", "serial", "datatype"]:
|
|
logger.debug(f"Cache for '{action}' is not supported")
|
|
return None
|
|
logger.debug(f"Writing '{action}' to local cache: {value}")
|
|
self._cache_data[action] = value
|
|
self._write_cache()
|
|
|
|
|
|
def is_messageclass_valid(action, response):
|
|
if int(response[1], 0) != actions[action][0] and int(response[2], 0) != actions[action][1]:
|
|
logger.error(
|
|
f"Response MessageClass != {actions[action][0]} {actions[action][1]} "
|
|
f"({action}), but {response[1]} {response[2]}"
|
|
)
|
|
return False
|
|
return True
|
|
|
|
|
|
def process_response(action, response, args, wpu):
|
|
if int(response[3], 0) != 0x01:
|
|
logger.error(f"Response MessageType != 0x01 (response), but {response[3]}")
|
|
return
|
|
if not is_messageclass_valid(action, response):
|
|
return
|
|
|
|
if action == "getdatalog":
|
|
measurements = process_datalog(response, wpu)
|
|
if args.export_to_influxdb:
|
|
from itho_export import export_to_influxdb
|
|
|
|
export_to_influxdb(action, measurements)
|
|
elif action == "getsetting":
|
|
process_setting(response, wpu)
|
|
elif action == "getmanual":
|
|
process_manual(response, wpu)
|
|
elif action == "getnodeid":
|
|
process_nodeid(response)
|
|
elif action == "getserial":
|
|
process_serial(response)
|
|
elif action == "getcounters":
|
|
process_counters(response, wpu)
|
|
|
|
|
|
def process_nodeid(response):
|
|
hardware_info = {
|
|
0: {
|
|
"name": "HCCP",
|
|
"type": {
|
|
13: "WPU",
|
|
15: "Autotemp",
|
|
},
|
|
}
|
|
}
|
|
manufacturergroup = (int(response[5], 0) << 8) + int(response[6], 0)
|
|
manufacturer = hardware_info[int(response[7], 0)]["name"]
|
|
hardwaretype = hardware_info[int(response[7], 0)]["type"][int(response[8], 0)]
|
|
productversion = int(response[9], 0)
|
|
listversion = int(response[10], 0)
|
|
|
|
logger.info(
|
|
f"ManufacturerGroup: {manufacturergroup}, Manufacturer: {manufacturer}, "
|
|
f"HardwareType: {hardwaretype}, ProductVersion: {productversion}, "
|
|
f"ListVersion: {listversion}"
|
|
)
|
|
|
|
|
|
def process_serial(response):
|
|
serial = (int(response[5], 0) << 16) + (int(response[6], 0) << 8) + int(response[7], 0)
|
|
logger.info(f"Serial: {serial}")
|
|
|
|
|
|
def process_counters(response, wpu):
|
|
counters = wpu.get_counters()
|
|
message = response[5:]
|
|
for c in counters:
|
|
index = int(c["id"]) * 2
|
|
num = format_datatype(c["name"], message[index : index + 2], 0x10) # noqa: E203
|
|
|
|
logger.info(
|
|
"{}. {} ({}): {}{}".format(
|
|
int(c["id"]),
|
|
c["title"].title(),
|
|
c["name"].lower(),
|
|
num,
|
|
" " + c["unit"] if c["unit"] is not None else "",
|
|
)
|
|
)
|
|
|
|
|
|
def process_datalog(response, wpu):
|
|
datalog = wpu.get_datalog_structure()
|
|
message = response[5:]
|
|
measurements = {}
|
|
for d in datalog:
|
|
if d.type == 0x0 or d.type == 0xC:
|
|
length = 1
|
|
elif d.type == 0x10 or d.type == 0x12 or d.type == 0x90 or d.type == 0x92:
|
|
length = 2
|
|
elif d.type == 0x20:
|
|
length = 4
|
|
else:
|
|
logger.error(f"Unknown message type for datalog {d.label}: {d.type}")
|
|
num = format_datatype(d.label, message[d.index : d.index + length], d.type) # noqa: E203
|
|
logger.info(f"{d.description}: {num}")
|
|
measurements[d.label] = num
|
|
return measurements
|
|
|
|
|
|
def parse_setting(response, wpu):
|
|
message = response[5:]
|
|
|
|
settingid = int(message[17], 0)
|
|
setting = wpu.get_setting_by_id(settingid)
|
|
if setting is None:
|
|
logger.error(f"Setting '{settingid}' is invalid")
|
|
return
|
|
|
|
datatype = message[16]
|
|
value = format_datatype(setting["name"], message[0:4], datatype)
|
|
minimum = format_datatype(setting["name"], message[4:8], datatype)
|
|
maximum = format_datatype(setting["name"], message[8:12], datatype)
|
|
step = format_datatype(setting["name"], message[12:16], datatype)
|
|
|
|
return value, minimum, maximum, step
|
|
|
|
|
|
def process_setting(response, wpu):
|
|
message = response[5:]
|
|
|
|
settingid = int(message[17], 0)
|
|
setting = wpu.get_setting_by_id(settingid)
|
|
if setting is None:
|
|
logger.error(f"Setting '{settingid}' is invalid")
|
|
return
|
|
|
|
value, minimum, maximum, step = parse_setting(response, wpu)
|
|
|
|
logger.info(
|
|
"{}. {}{}: {} (min: {}, max: {}, step: {})".format(
|
|
settingid,
|
|
setting["title"].title(),
|
|
f' ({setting["unit"]})' if setting["unit"] is not None else "",
|
|
value,
|
|
minimum,
|
|
maximum,
|
|
step,
|
|
)
|
|
)
|
|
|
|
|
|
def process_settings(wpu, args):
|
|
settings = wpu.get_settings()
|
|
for setting in settings:
|
|
response = wpu.call("getsetting", int(setting["id"]))
|
|
if response is not None:
|
|
process_response("getsetting", response, args, wpu)
|
|
|
|
|
|
def process_setsetting(wpu, args):
|
|
logger.info("Current setting:")
|
|
response = wpu.call("getsetting", int(args.id))
|
|
if response is None:
|
|
return
|
|
process_response("getsetting", response, args, wpu)
|
|
message = response[5:]
|
|
datatype = message[16]
|
|
|
|
if args.value is None:
|
|
value = input("Provide a new value: ")
|
|
else:
|
|
value = args.value
|
|
|
|
# TODO: add support for negative values
|
|
if float(value) < 0:
|
|
logger.error("Negative values are not supported yet.")
|
|
return
|
|
|
|
logger.debug(f"New setting datatype: {datatype}")
|
|
logger.debug(f"New setting (input): {value}")
|
|
normalized_value = int(value.replace(".", ""))
|
|
logger.debug(f"New setting (normalized): {normalized_value}")
|
|
hex_list_value = [hex(v) for v in list(normalized_value.to_bytes(4, byteorder="big"))]
|
|
logger.debug(f"New setting (hex): {hex_list_value}")
|
|
parsed_value = format_datatype(args.id, hex_list_value, datatype)
|
|
logger.debug(f"New setting (parsed): {parsed_value}")
|
|
|
|
_, minimum, maximum, _ = parse_setting(response, wpu)
|
|
if parsed_value < minimum or parsed_value > maximum:
|
|
logger.error(f"New value `{parsed_value}` is not between `{minimum}` and `{maximum}`")
|
|
return
|
|
|
|
sure = input(f"Setting `{args.id}` will be changed to `{parsed_value}`? [y/N] ")
|
|
if sure in ["y", "Y"]:
|
|
logger.info(f"Updating setting {args.id} to `{parsed_value}`")
|
|
else:
|
|
logger.error("Aborted")
|
|
return
|
|
|
|
response = wpu.call("setsetting", args.id, None, normalized_value)
|
|
if response is None:
|
|
return
|
|
process_response("getsetting", response, args, wpu)
|
|
|
|
|
|
def process_manual(response, wpu):
|
|
message = response[5:]
|
|
|
|
manualid = int(message[2], 0)
|
|
manual = wpu.get_manual_by_id(manualid)
|
|
if manual is None:
|
|
logger.error(f"Manual '{manualid}' is invalid")
|
|
return
|
|
|
|
datatype = message[3]
|
|
value = format_datatype(manual["name"], message[4:6], datatype)
|
|
|
|
logger.info(
|
|
"{}. {}{}: {}".format(
|
|
manualid,
|
|
manual["title"].title(),
|
|
f' ({manual["unit"]})' if manual["unit"] is not None else "",
|
|
value,
|
|
)
|
|
)
|
|
|
|
|
|
def process_setmanual(wpu, args):
|
|
logger.info("Current manual operation:")
|
|
response = wpu.call("getmanual", int(args.id))
|
|
if response is None:
|
|
return
|
|
process_response("getmanual", response, args, wpu)
|
|
message = response[5:]
|
|
datatype = message[3]
|
|
|
|
# TODO: check if Max Handbedieningstijd > 0
|
|
|
|
if args.value is None:
|
|
value = input("Provide a new value: ")
|
|
else:
|
|
value = args.value
|
|
|
|
# TODO: add support for negative values
|
|
if float(value) < 0:
|
|
logger.error("Negative values are not supported yet.")
|
|
return
|
|
|
|
logger.debug(f"New manual operation datatype: {datatype}")
|
|
logger.debug(f"New manual operation (input): {value}")
|
|
normalized_value = int(value.replace(".", ""))
|
|
logger.debug(f"New manual operation (normalized): {normalized_value}")
|
|
hex_list_value = [hex(v) for v in list(normalized_value.to_bytes(2, byteorder="big"))]
|
|
logger.debug(f"New manual operation (hex): {hex_list_value}")
|
|
parsed_value = format_datatype(args.id, hex_list_value, datatype)
|
|
logger.debug(f"New manual operation (parsed): {parsed_value}")
|
|
|
|
sure = input(f"Manual `{args.id}` will be changed to `{parsed_value}`? [y/N] ")
|
|
if sure in ["y", "Y"]:
|
|
logger.info(f"Updating manual operation {args.id} to `{parsed_value}`")
|
|
else:
|
|
logger.error("Aborted")
|
|
return
|
|
|
|
response = wpu.call("setmanual", args.id, int(datatype, 0), normalized_value, args.check)
|
|
|
|
|
|
def format_datatype(name, m, dt):
|
|
"""
|
|
Transform a list of bytes to a readable number based on the datatype.
|
|
|
|
:param str name: Name/label of the data
|
|
:param list[str] m: List of bytes in hexadecimal string format
|
|
:param dt: Datatype
|
|
:type dt: str or int
|
|
"""
|
|
|
|
num = None
|
|
if type(dt) is str:
|
|
dt = int(dt, 0)
|
|
|
|
if dt == 0x0 or dt == 0xC:
|
|
num = int(m[-1], 0)
|
|
elif dt == 0x1:
|
|
num = round(int(m[-1], 0) / 10, 1)
|
|
elif dt == 0x2:
|
|
num = round(int(m[-1], 0) / 100, 2)
|
|
elif dt == 0x10:
|
|
num = (int(m[-2], 0) << 8) + int(m[-1], 0)
|
|
elif dt == 0x12:
|
|
num = round((int(m[-2], 0) << 8) + int(m[-1], 0) / 100, 2)
|
|
elif dt == 0x13:
|
|
num = round((int(m[-2], 0) << 8) + int(m[-1], 0) / 1000, 3)
|
|
elif dt == 0x14:
|
|
num = round((int(m[-2], 0) << 8) + int(m[-1], 0) / 10000, 4)
|
|
elif dt == 0x80:
|
|
num = int(m[-1], 0)
|
|
if num >= 128:
|
|
num -= 256
|
|
elif dt == 0x81:
|
|
num = int(m[-1], 0)
|
|
if num >= 128:
|
|
num -= 256
|
|
num = round(num / 10, 1)
|
|
elif dt == 0x82:
|
|
num = int(m[-1], 0)
|
|
if num >= 128:
|
|
num -= 256
|
|
num = round(num / 100, 2)
|
|
elif dt == 0x8F:
|
|
num = int(m[-1], 0)
|
|
if num >= 128:
|
|
num -= 256
|
|
num = round(num / 1000, 3)
|
|
elif dt == 0x90:
|
|
num = (int(m[-2], 0) << 8) + int(m[-1], 0)
|
|
if num >= 32768:
|
|
num -= 65536
|
|
elif dt == 0x91:
|
|
num = (int(m[-2], 0) << 8) + int(m[-1], 0)
|
|
if num >= 32768:
|
|
num -= 65536
|
|
num = round(num / 10, 2)
|
|
elif dt == 0x92:
|
|
num = (int(m[-2], 0) << 8) + int(m[-1], 0)
|
|
if num >= 32768:
|
|
num -= 65536
|
|
num = round(num / 100, 2)
|
|
elif dt == 0x20:
|
|
num = (int(m[-4], 0) << 24) + (int(m[-3], 0) << 16) + (int(m[-2], 0) << 8) + int(m[-1], 0)
|
|
else:
|
|
logger.error(f"Unknown datatype for '{name}': 0x{dt:X}")
|
|
return num
|
|
|
|
|
|
def main():
|
|
args = parse_args()
|
|
|
|
if args.loglevel:
|
|
logger.setLevel(args.loglevel.upper())
|
|
logging.getLogger("itho_i2c").setLevel(args.loglevel.upper())
|
|
|
|
if args.timestamp:
|
|
stdout_log_handler.setFormatter(
|
|
logging.Formatter("%(asctime)-15s %(levelname)s: %(message)s")
|
|
)
|
|
|
|
if args.action in ["getsetting", "setsetting", "getmanual", "setmanual"] and args.id is None:
|
|
logger.error(f"`--id` is required with `--action {args.action}`")
|
|
return
|
|
|
|
wpu = IthoWPU(args.master_only, args.slave_only, args.slave_timeout, args.no_cache)
|
|
|
|
if args.action == "getsettings":
|
|
process_settings(wpu, args)
|
|
return
|
|
|
|
if args.action == "setsetting":
|
|
process_setsetting(wpu, args)
|
|
return
|
|
|
|
if args.action == "setmanual":
|
|
process_setmanual(wpu, args)
|
|
return
|
|
|
|
response = wpu.call(args.action, args.id)
|
|
if response is not None:
|
|
process_response(args.action, response, args, wpu)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|