forked from M-Labs/thermostat
289 lines
9.2 KiB
Python
289 lines
9.2 KiB
Python
import asyncio
|
|
import json
|
|
import logging
|
|
|
|
|
|
class CommandError(Exception):
|
|
pass
|
|
|
|
|
|
class StoppedConnecting(Exception):
|
|
pass
|
|
|
|
|
|
class Client:
|
|
def __init__(self):
|
|
self._reader = None
|
|
self._writer = None
|
|
self._connecting_task = None
|
|
self._command_lock = asyncio.Lock()
|
|
self._report_mode_on = False
|
|
self.timeout = None
|
|
|
|
async def start_session(self, host="192.168.1.26", port=23, timeout=None):
|
|
"""Start session to Thermostat at specified host and port.
|
|
Throws StoppedConnecting if disconnect was called while connecting.
|
|
Throws asyncio.TimeoutError if timeout was exceeded.
|
|
|
|
Example::
|
|
client = Client()
|
|
try:
|
|
await client.start_session()
|
|
except StoppedConnecting:
|
|
print("Stopped connecting")
|
|
"""
|
|
self._connecting_task = asyncio.create_task(
|
|
asyncio.wait_for(asyncio.open_connection(host, port), timeout)
|
|
)
|
|
self.timeout = timeout
|
|
try:
|
|
self._reader, self._writer = await self._connecting_task
|
|
except asyncio.CancelledError:
|
|
raise StoppedConnecting
|
|
finally:
|
|
self._connecting_task = None
|
|
|
|
await self._check_zero_limits()
|
|
|
|
def connecting(self):
|
|
"""Returns True if client is connecting"""
|
|
return self._connecting_task is not None
|
|
|
|
def connected(self):
|
|
"""Returns True if client is connected"""
|
|
return self._writer is not None
|
|
|
|
async def end_session(self):
|
|
"""End session to Thermostat if connected, cancel connection if connecting"""
|
|
if self._connecting_task is not None:
|
|
self._connecting_task.cancel()
|
|
|
|
if self._writer is None:
|
|
return
|
|
|
|
# Reader needn't be closed
|
|
self._writer.close()
|
|
await self._writer.wait_closed()
|
|
self._reader = None
|
|
self._writer = None
|
|
|
|
async def _check_zero_limits(self):
|
|
pwm_report = await self.get_pwm()
|
|
for pwm_channel in pwm_report:
|
|
for limit in ["max_i_neg", "max_i_pos", "max_v"]:
|
|
if pwm_channel[limit]["value"] == 0.0:
|
|
logging.warning(
|
|
"`{}` limit is set to zero on channel {}".format(
|
|
limit, pwm_channel["channel"]
|
|
)
|
|
)
|
|
|
|
async def _read_line(self):
|
|
# read 1 line
|
|
chunk = await asyncio.wait_for(
|
|
self._reader.readline(), self.timeout
|
|
) # Only wait for response until timeout
|
|
return chunk.decode("utf-8", errors="ignore")
|
|
|
|
async def _read_write(self, command):
|
|
self._writer.write(((" ".join(command)).strip() + "\n").encode("utf-8"))
|
|
await self._writer.drain()
|
|
|
|
return await self._read_line()
|
|
|
|
async def _command(self, *command):
|
|
async with self._command_lock:
|
|
# protect the read-write process from being cancelled midway
|
|
line = await asyncio.shield(self._read_write(command))
|
|
|
|
response = json.loads(line)
|
|
logging.debug(f"{command}: {response}")
|
|
if "error" in response:
|
|
raise CommandError(response["error"])
|
|
return response
|
|
|
|
async def _get_conf(self, topic):
|
|
result = [None, None]
|
|
for item in await self._command(topic):
|
|
result[int(item["channel"])] = item
|
|
return result
|
|
|
|
async def get_pwm(self):
|
|
"""Retrieve PWM limits for the TEC
|
|
|
|
Example::
|
|
[{'channel': 0,
|
|
'center': 'vref',
|
|
'i_set': {'max': 2.9802790335151985, 'value': -0.02002179650216762},
|
|
'max_i_neg': {'max': 3.0, 'value': 3.0},
|
|
'max_v': {'max': 5.988, 'value': 5.988},
|
|
'max_i_pos': {'max': 3.0, 'value': 3.0}},
|
|
{'channel': 1,
|
|
'center': 'vref',
|
|
'i_set': {'max': 2.9802790335151985, 'value': -0.02002179650216762},
|
|
'max_i_neg': {'max': 3.0, 'value': 3.0},
|
|
'max_v': {'max': 5.988, 'value': 5.988},
|
|
'max_i_pos': {'max': 3.0, 'value': 3.0}}
|
|
]
|
|
"""
|
|
return await self._get_conf("pwm")
|
|
|
|
async def get_pid(self):
|
|
"""Retrieve PID control state
|
|
|
|
Example::
|
|
[{'channel': 0,
|
|
'parameters': {
|
|
'kp': 10.0,
|
|
'ki': 0.02,
|
|
'kd': 0.0,
|
|
'output_min': 0.0,
|
|
'output_max': 3.0},
|
|
'target': 37.0},
|
|
{'channel': 1,
|
|
'parameters': {
|
|
'kp': 10.0,
|
|
'ki': 0.02,
|
|
'kd': 0.0,
|
|
'output_min': 0.0,
|
|
'output_max': 3.0},
|
|
'target': 36.5}]
|
|
"""
|
|
return await self._get_conf("pid")
|
|
|
|
async def get_steinhart_hart(self):
|
|
"""Retrieve Steinhart-Hart parameters for resistance to temperature conversion
|
|
|
|
Example::
|
|
[{'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 0},
|
|
{'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 1}]
|
|
"""
|
|
return await self._get_conf("s-h")
|
|
|
|
async def get_postfilter(self):
|
|
"""Retrieve DAC postfilter configuration
|
|
|
|
Example::
|
|
[{'rate': None, 'channel': 0},
|
|
{'rate': 21.25, 'channel': 1}]
|
|
"""
|
|
return await self._get_conf("postfilter")
|
|
|
|
async def get_fan(self):
|
|
"""Get Thermostat current fan settings"""
|
|
return await self._command("fan")
|
|
|
|
async def report(self):
|
|
"""Obtain one-time report on measurement values"""
|
|
return await self._command("report")
|
|
|
|
async def report_mode(self):
|
|
"""Start reporting measurement values
|
|
|
|
Example of yielded data::
|
|
{'channel': 0,
|
|
'time': 2302524,
|
|
'adc': 0.6199188965423515,
|
|
'sens': 6138.519310282602,
|
|
'temperature': 36.87032392655527,
|
|
'pid_engaged': True,
|
|
'i_set': 2.0635816680889123,
|
|
'vref': 1.494,
|
|
'dac_value': 2.527790834044456,
|
|
'dac_feedback': 2.523,
|
|
'i_tec': 2.331,
|
|
'tec_i': 2.0925,
|
|
'tec_u_meas': 2.5340000000000003,
|
|
'pid_output': 2.067581958092247}
|
|
"""
|
|
await self._command("report mode", "on")
|
|
self._report_mode_on = True
|
|
|
|
while self._report_mode_on:
|
|
async with self._command_lock:
|
|
line = await self._read_line()
|
|
if not line:
|
|
break
|
|
try:
|
|
yield json.loads(line)
|
|
except json.decoder.JSONDecodeError:
|
|
pass
|
|
|
|
await self._command("report mode", "off")
|
|
|
|
def stop_report_mode(self):
|
|
self._report_mode_on = False
|
|
|
|
async def set_param(self, topic, channel, field="", value=""):
|
|
"""Set configuration parameters
|
|
|
|
Examples::
|
|
await tec.set_param("pwm", 0, "max_v", 2.0)
|
|
await tec.set_param("pid", 1, "output_max", 2.5)
|
|
await tec.set_param("s-h", 0, "t0", 20.0)
|
|
await tec.set_param("center", 0, "vref")
|
|
await tec.set_param("postfilter", 1, 21)
|
|
|
|
See the firmware's README.md for a full list.
|
|
"""
|
|
if type(value) is float:
|
|
value = "{:f}".format(value)
|
|
if type(value) is not str:
|
|
value = str(value)
|
|
await self._command(topic, str(channel), field, value)
|
|
|
|
async def set_fan(self, power="auto"):
|
|
"""Set fan power"""
|
|
await self._command("fan", str(power))
|
|
|
|
async def set_fcurve(self, a=1.0, b=0.0, c=0.0):
|
|
"""Set fan curve"""
|
|
await self._command("fcurve", str(a), str(b), str(c))
|
|
|
|
async def power_up(self, channel, target):
|
|
"""Start closed-loop mode"""
|
|
await self.set_param("pid", channel, "target", value=target)
|
|
await self.set_param("pwm", channel, "pid")
|
|
|
|
async def save_config(self, channel=""):
|
|
"""Save current configuration to EEPROM"""
|
|
await self._command("save", str(channel))
|
|
|
|
async def load_config(self, channel=""):
|
|
"""Load current configuration from EEPROM"""
|
|
await self._command("load", str(channel))
|
|
if channel == "":
|
|
await self._read_line() # Read the extra {}
|
|
|
|
async def hw_rev(self):
|
|
"""Get Thermostat hardware revision"""
|
|
return await self._command("hwrev")
|
|
|
|
async def reset(self):
|
|
"""Reset the Thermostat
|
|
|
|
The client is disconnected as the TCP session is terminated.
|
|
"""
|
|
async with self._command_lock:
|
|
self._writer.write("reset\n".encode("utf-8"))
|
|
await self._writer.drain()
|
|
|
|
await self.end_session()
|
|
|
|
async def dfu(self):
|
|
"""Put the Thermostat in DFU update mode
|
|
|
|
The client is disconnected as the Thermostat stops responding to
|
|
TCP commands in DFU update mode. The only way to exit it is by
|
|
power-cycling.
|
|
"""
|
|
async with self._command_lock:
|
|
self._writer.write("dfu\n".encode("utf-8"))
|
|
await self._writer.drain()
|
|
|
|
await self.end_session()
|
|
|
|
async def ipv4(self):
|
|
"""Get the IPv4 settings of the Thermostat"""
|
|
return await self._command("ipv4")
|