forked from M-Labs/kirdy
921 lines
36 KiB
Python
921 lines
36 KiB
Python
import socket
|
|
import json
|
|
import logging
|
|
import time
|
|
from threading import Thread
|
|
from aenum import StrEnum, NoAlias
|
|
import queue
|
|
import asyncio
|
|
|
|
class _dt(StrEnum):
|
|
ip_settings = "ip_settings"
|
|
temp_adc_filter = "temp_adc_filter"
|
|
f32 = "data_f32"
|
|
bool = "data_bool"
|
|
none = "None"
|
|
|
|
class State(StrEnum):
|
|
disconnected = "disconnected"
|
|
connected = "connected"
|
|
|
|
class CmdList:
|
|
class device(StrEnum, settings=NoAlias):
|
|
_target = "device_cmd"
|
|
SetIPSettings = _dt.ip_settings
|
|
SetPdFinGain = _dt.f32
|
|
SetPdTransconductance = _dt.f32
|
|
SetActiveReportMode = _dt.bool
|
|
GetStatusReport = _dt.none
|
|
GetSettingsSummary = _dt.none
|
|
Dfu = _dt.none
|
|
SaveFlashSettings = _dt.none
|
|
LoadFlashSettings = _dt.none
|
|
HardReset = _dt.none
|
|
|
|
class ld(StrEnum, settings=NoAlias):
|
|
_target = "laser_diode_cmd"
|
|
SetDefaultPowerOn = _dt.bool
|
|
PowerUp = _dt.none
|
|
PowerDown = _dt.none
|
|
LdTermsShort = _dt.none
|
|
LdTermsOpen = _dt.none
|
|
SetI = _dt.f32
|
|
SetPdResponsitivity = _dt.f32
|
|
SetPdDarkCurrent = _dt.f32
|
|
SetLdPwrLimit = _dt.f32
|
|
ClearAlarm = _dt.none
|
|
|
|
class thermostat(StrEnum, settings=NoAlias):
|
|
_target = "thermostat_cmd"
|
|
SetDefaultPowerOn = _dt.bool,
|
|
PowerUp = _dt.f32,
|
|
PowerDown = _dt.f32,
|
|
SetTecMaxV = _dt.f32,
|
|
SetTecMaxIPos = _dt.f32,
|
|
SetTecMaxINeg = _dt.f32,
|
|
SetTecIOut = _dt.f32,
|
|
SetTemperatureSetpoint = _dt.f32,
|
|
SetPidEngage = _dt.none,
|
|
SetPidDisEngage = _dt.none,
|
|
SetPidKp = _dt.f32,
|
|
SetPidKi = _dt.f32,
|
|
SetPidKd = _dt.f32,
|
|
SetPidOutMin = _dt.f32,
|
|
SetPidOutMax = _dt.f32,
|
|
ConfigTempAdcFilter = _dt.temp_adc_filter,
|
|
SetTempMonUpperLimit = _dt.f32,
|
|
SetTempMonLowerLimit = _dt.f32,
|
|
ClearAlarm = _dt.none,
|
|
SetShT0 = _dt.f32,
|
|
SetShR0 = _dt.f32,
|
|
SetShBeta = _dt.f32,
|
|
|
|
class FilterConfig:
|
|
class Sinc5Sinc1With50hz60HzRejection(StrEnum):
|
|
f27sps = "F27SPS"
|
|
f21sps = "F21SPS"
|
|
f20sps = "F20SPS"
|
|
f16sps = "F16SPS"
|
|
|
|
def _odr_type(self):
|
|
return "sinc5sinc1postfilter"
|
|
|
|
def _filter_type(self):
|
|
return "Sinc5Sinc1With50hz60HzRejection"
|
|
|
|
class Sinc5Sinc1(StrEnum):
|
|
f31250_0sps = "F31250_0SPS"
|
|
f15625_0sps = "F15625_0SPS"
|
|
f10417_0sps = "F10417_0SPS"
|
|
f5208_0sps = "F5208_0SPS"
|
|
f2597_0sps = "F2597_0SPS"
|
|
f1007_0sps = "F1007_0SPS"
|
|
f503_8sps = "F503_8SPS"
|
|
f381_0sps = "F381_0SPS"
|
|
f200_3sps = "F200_3SPS"
|
|
f100_2sps = "F100_2SPS"
|
|
f59_52sps = "F59_52SPS"
|
|
f49_68sps = "F49_68SPS"
|
|
f20_01sps = "F20_01SPS"
|
|
f16_63sps = "F16_63SPS"
|
|
f10_0sps = "F10_0SPS"
|
|
f5_0sps = "F5_0SPS"
|
|
f2_5sps = "F2_5SPS"
|
|
f1_25sps = "F1_25SPS"
|
|
|
|
def _odr_type(self):
|
|
return "sinc5sinc1odr"
|
|
|
|
def _filter_type(self):
|
|
return "Sinc5Sinc1"
|
|
|
|
class Sinc3(StrEnum):
|
|
f31250_0sps = "F31250_0SPS"
|
|
f15625_0sps = "F15625_0SPS"
|
|
f10417_0sps = "F10417_0SPS"
|
|
f5208_0sps = "F5208_0SPS"
|
|
f2597_0sps = "F2597_0SPS"
|
|
f1007_0sps = "F1007_0SPS"
|
|
f503_8sps = "F503_8SPS"
|
|
f381_0sps = "F381_0SPS"
|
|
f200_3sps = "F200_3SPS"
|
|
f100_2sps = "F100_2SPS"
|
|
f59_52sps = "F59_52SPS"
|
|
f49_68sps = "F49_68SPS"
|
|
f20_01sps = "F20_01SPS"
|
|
f16_63sps = "F16_63SPS"
|
|
f10_0sps = "F10_0SPS"
|
|
f5_0sps = "F5_0SPS"
|
|
f2_5sps = "F2_5SPS"
|
|
f1_25sps = "F1_25SPS"
|
|
|
|
def _odr_type(self):
|
|
return "sinc3odr"
|
|
|
|
def _filter_type(self):
|
|
return "Sinc3"
|
|
|
|
class Sinc3WithFineODR():
|
|
def __init__(self, rate):
|
|
assert rate >= 1.907465 and rate <= 31250
|
|
self.rate = float(rate)
|
|
|
|
def _odr_type(self):
|
|
return "sinc3fineodr"
|
|
|
|
def _filter_type(self):
|
|
return "Sinc3WithFineODR"
|
|
|
|
class InvalidDataType(Exception):
|
|
pass
|
|
|
|
class InvalidCmd(Exception):
|
|
pass
|
|
|
|
class Device:
|
|
def __init__(self, send_cmd_handler, send_raw_cmd_handler, read_msg_queue):
|
|
self._cmd = CmdList.device
|
|
self._send_cmd = send_cmd_handler
|
|
self._send_raw_cmd = send_raw_cmd_handler
|
|
self._read_msg_queue = read_msg_queue
|
|
|
|
def set_ip_settings(self, addr="192.168.1.128", port=1337, prefix_len=24, gateway="192.168.1.1"):
|
|
"""
|
|
After calling this fn, the ip settings are immediately saved into flash and will be effective on next reboot.
|
|
"""
|
|
try:
|
|
socket.inet_aton(addr)
|
|
socket.inet_aton(gateway)
|
|
except OSError:
|
|
raise InvalidDataType
|
|
|
|
addr = addr.split(".")
|
|
gateway = gateway.split(".")
|
|
|
|
if not(isinstance(port, int) and isinstance(prefix_len, int)):
|
|
raise InvalidDataType
|
|
|
|
return self._send_raw_cmd(
|
|
{
|
|
"device_cmd": "SetIPSettings",
|
|
"ip_settings": {
|
|
"addr": [int(x) for x in addr],
|
|
"port": port,
|
|
"prefix_len": prefix_len,
|
|
"gateway": [int(x) for x in gateway],
|
|
}
|
|
}
|
|
)
|
|
|
|
def set_active_report_mode(self, on):
|
|
"""
|
|
Set active report to be on. If it is on, Kirdy will send status report
|
|
to ALL client socket connections according to the temperature polling rate set.
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetActiveReportMode, on)
|
|
|
|
def set_pd_mon_fin_gain(self, gain):
|
|
"""
|
|
Configure the photodiode monitor final analog front-end stage gain
|
|
- gain: unitless
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetPdFinGain, gain)
|
|
|
|
def set_pd_mon_transconductance(self, transconductance):
|
|
"""
|
|
Configure the photodiode monitor transconductance
|
|
- transconductance: 1/Ohm
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetPdTransconductance, transconductance)
|
|
|
|
def get_status_report(self, sig=None):
|
|
"""
|
|
Get status of all peripherals in a json object
|
|
|
|
Example of yielded data::
|
|
{
|
|
'ts': 227657, # Relative Timestamp (ms)
|
|
'msg_type': 'Report' # Indicate it is a 'Report' json object
|
|
'laser': {
|
|
'pwr_on': False, # Laser Power is On (True/False)
|
|
'pwr_excursion': False, # Was Laser experienced an Overpowered Condition? (True/False)
|
|
'ld_i_set': 0.0, # Laser Diode Output Current (A)
|
|
'pd_i': 2.0000002e-06, # Internal Photodiode Monitor current (A)
|
|
'pd_pwr': None, # Power Readings from Internal Photodiode (W). Return None if pd_mon parameter(s) are not defined.
|
|
'term_50ohm': 'Is50Ohm' # Is the Low Frequency Modulation Input's Impedance 50 Ohm? (On/Off)
|
|
},
|
|
'thermostat': {
|
|
'pwr_on': False, # Tec Power is On (True/False)
|
|
'pid_engaged': False, # Is Pid_Engaged. If False, it is in Constant Current Mode (True/False)
|
|
'temp_mon_status': { # Temperature Monitor:
|
|
'status': 'Off', # (To be revised)
|
|
'over_temp_alarm': False # Was Laser Diode experienced an Overtemperature condition (True/False)
|
|
},
|
|
'temperature': 25.03344, # Temperature Readings (Degree Celsius)
|
|
'i_set': 0.0, # Tec Current Set by User/PID Controller(A)
|
|
'tec_i': 0.0024998188, # Tec Current Readings (A)
|
|
'tec_v': -0.00399971 # Tec Voltage Readings (V)
|
|
}
|
|
}
|
|
"""
|
|
if sig is None:
|
|
self._send_cmd(self._cmd._target, self._cmd.GetStatusReport, msg_type="Report", sig=sig)
|
|
return self._read_msg_queue()
|
|
else:
|
|
return self._send_cmd(self._cmd._target, self._cmd.GetStatusReport, msg_type="Report", sig=sig)
|
|
|
|
def get_settings_summary(self, sig=None):
|
|
"""
|
|
Get the current settings of laser and thermostat in a json object
|
|
|
|
{
|
|
'msg_type': 'Settings', # Indicate it is a 'Settings' json object
|
|
'laser': {
|
|
'default_pwr_on': False, # Power On Laser Diode at Startup
|
|
'ld_drive_current': { # Laser Diode Output Current(A)
|
|
'value': 0.0, # Value Set
|
|
'max': 0.3 # Max Value Settable
|
|
,
|
|
'pd_mon_params': { # Laser Diode Software Current Limit(A)
|
|
'responsitivity': None, # Value Set
|
|
'i_dark': 0.0 # Max Value Settable
|
|
,
|
|
'ld_pwr_limit': 0.0 # Laser Diode Power Limit(W)
|
|
'ld_terms_short: False # Is Laser Diode Terminals short? (True/False)
|
|
},
|
|
'thermostat': {
|
|
'default_pwr_on': True, # Power on Thermostat at Startup
|
|
'pid_engaged': True, # True: PID Control Mode | False Constant Current Mode
|
|
'temperature_setpoint': 25.0, # Temperature Setpoint (Degree Celsius)
|
|
'tec_settings': {
|
|
'i_set': { # Current TEC Current Set by PID Controller/User
|
|
'value': 0.04330516, # Value Set
|
|
'max': 1.0 # Max Value Settable
|
|
},
|
|
'max_v': { # Max Voltage Across Tec Terminals
|
|
'value': 4.990857, # Value Set
|
|
'max': 5.0 # Max Value Settable
|
|
},
|
|
'max_i_pos': { # Max Cooling Current Across Tec Terminals
|
|
'value': 0.99628574, # Value Set
|
|
'max': 1.0 # Max Value Settable
|
|
},
|
|
'max_i_neg': { # Max Heating Current Across Tec Terminals
|
|
'value': 0.99628574, # Value Set
|
|
'max': 1.0 # Max Value Settable
|
|
}
|
|
},
|
|
'pid_params': { # PID Controller Parameters
|
|
'kp': 0.15668282, # Proportional Gain
|
|
'ki': 0.0021359625, # Integral Gain
|
|
'kd': 0.8292545, # Derivative Gain
|
|
'output_min': -1.0, # Minimum Current Output (A)
|
|
'output_max': 1.0 # Maximum Current Output (A)
|
|
},
|
|
'temp_adc_settings': { # Temperature ADC Settings (Please read AD7172-2 Documentation)
|
|
'filter_type': 'Sinc5Sinc1With50hz60HzRejection', # Filter Types
|
|
'sinc5sinc1odr': None, # (Unused)
|
|
'sinc3odr': None, # (Unused)
|
|
'sinc5sinc1postfilter': None, # (Unused)
|
|
'sinc3fineodr': None, # (Unused)
|
|
'rate': 16.67 # ADC Sampling Rate (Hz)
|
|
},
|
|
'temp_mon_settings': { # Temperature Monitor Settings
|
|
'upper_limit': 40.0, # Temperature Upper Limit (Degree Celsius)
|
|
'lower_limit': 10.0 # Temperature Lower Limit (Degree Celsius)
|
|
},
|
|
'thermistor_params': { # Thermistor Steinhart-Hart equation parameters
|
|
't0': 25.0, # t0: Degree Celsius
|
|
'r0': 10000.0, # r0: Ohm
|
|
'b': 3900.0 # b: (unitless)
|
|
}
|
|
}
|
|
}
|
|
"""
|
|
if sig is None:
|
|
self._send_cmd(self._cmd._target, self._cmd.GetSettingsSummary, msg_type="Settings", sig=sig)
|
|
return self._read_msg_queue()
|
|
else:
|
|
return self._send_cmd(self._cmd._target, self._cmd.GetSettingsSummary, msg_type="Settings", sig=sig)
|
|
|
|
def dfu(self):
|
|
"""
|
|
Issuing this cmd will HARD RESET the device and
|
|
put Kirdy into Dfu mode for flashing firmware.
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.Dfu, hard_reset=True)
|
|
|
|
def save_current_settings_to_flash(self):
|
|
"""
|
|
Save the current laser diode and thermostat configurations into flash.
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SaveFlashSettings)
|
|
|
|
def restore_settings_from_flash(self):
|
|
"""
|
|
Restore the laser diode and thermostat settings from flash
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.LoadFlashSettings)
|
|
|
|
def hard_reset(self):
|
|
"""
|
|
Hard Reset Kirdy. The socket connection will be closed by Kirdy.
|
|
Laser diode power and Tec power will be turned off.
|
|
Kirdy will send out a json({'msg_type': 'HardReset'}) to all sockets indicating. The device is being reset.
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.HardReset, hard_reset=True)
|
|
|
|
class Laser:
|
|
def __init__(self, send_cmd_handler):
|
|
self._cmd = CmdList.ld
|
|
self._send_cmd = send_cmd_handler
|
|
|
|
def set_power_on(self, on):
|
|
"""
|
|
Power Up or Power Down laser diode. Powering up the Laser Diode resets the pwr_excursion status
|
|
- on (True/False)
|
|
"""
|
|
if on:
|
|
return self._send_cmd(self._cmd._target, self._cmd.PowerUp, None)
|
|
else:
|
|
return self._send_cmd(self._cmd._target, self._cmd.PowerDown, None)
|
|
|
|
def set_default_pwr_on(self, on):
|
|
"""
|
|
Set whether laser diode is powered up at Startup
|
|
- on (True/False)
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetDefaultPowerOn, on)
|
|
|
|
def set_ld_terms_short(self, short):
|
|
"""
|
|
Open/Short laser diode terminals.
|
|
- on (True/False)
|
|
"""
|
|
if short:
|
|
return self._send_cmd(self._cmd._target, self._cmd.LdTermsShort, None)
|
|
else:
|
|
return self._send_cmd(self._cmd._target, self._cmd.LdTermsOpen, None)
|
|
|
|
def set_i(self, i):
|
|
"""
|
|
Set laser diode output current: Max(0, Min(i_set, i_soft_limit))
|
|
- i: A
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetI, i)
|
|
|
|
def set_pd_mon_responsitivity(self, responsitivity):
|
|
"""
|
|
Configure the photodiode monitor responsitivity parameter
|
|
- responsitivity: A/W
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetPdResponsitivity, responsitivity)
|
|
|
|
def set_pd_mon_dark_current(self, dark_current):
|
|
"""
|
|
Configure the photodiode monitor dark current parameter
|
|
- dark_current: A
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetPdDarkCurrent, dark_current)
|
|
|
|
def set_ld_pwr_limit(self, pwr_limit):
|
|
"""
|
|
Set power limit for the power excursion monitor
|
|
If the calculated power with the params of pd_mon > pwr_limit,
|
|
overpower protection is triggered.
|
|
- pwr_limit: W
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetLdPwrLimit, pwr_limit)
|
|
|
|
def clear_alarm(self):
|
|
"""
|
|
Clear the power excursion monitor alarm
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.ClearAlarm)
|
|
|
|
class Thermostat:
|
|
def __init__(self, send_cmd_handler, send_raw_cmd_handler):
|
|
self._cmd = CmdList.thermostat
|
|
self._send_cmd = send_cmd_handler
|
|
self._send_raw_cmd = send_raw_cmd_handler
|
|
|
|
def set_power_on(self, on):
|
|
"""
|
|
Power up or power down thermostat
|
|
- Powering up the thermostat resets the pwr_excursion status
|
|
"""
|
|
if on:
|
|
return self._send_cmd(self._cmd._target, self._cmd.PowerUp, None)
|
|
else:
|
|
return self._send_cmd(self._cmd._target, self._cmd.PowerDown, None)
|
|
|
|
def set_default_pwr_on(self, on):
|
|
"""
|
|
Set whether thermostat is powered up at Startup
|
|
- on: (True/False)
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetDefaultPowerOn, on)
|
|
|
|
def set_tec_max_v(self, max_v):
|
|
"""
|
|
Set Tec Maximum Voltage Across the TEC Terminals
|
|
- max_v: V
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetTecMaxV, max_v)
|
|
|
|
def set_tec_max_cooling_i(self, max_i_pos):
|
|
"""
|
|
Set Tec maximum cooling current (Settable Range: 0.0 - 1.0)
|
|
- max_i_pos: A
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetTecMaxIPos, max_i_pos)
|
|
|
|
def set_tec_max_heating_i(self, max_i_neg):
|
|
"""
|
|
Set Tec maximum heating current (Settable Range: 0.0 - 1.0)
|
|
- max_i_neg: A
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetTecMaxINeg, max_i_neg)
|
|
|
|
def set_tec_i_out(self, i_out):
|
|
"""
|
|
Set Tec Output Current
|
|
This cmd is only effective in constant current control mode
|
|
or your newly set value will be overwritten by PID Controller Output
|
|
- i_out: A
|
|
"""
|
|
if isinstance(i_out, float):
|
|
return self._send_raw_cmd({"tec_set_i": i_out})
|
|
elif isinstance(i_out, int):
|
|
return self._send_raw_cmd({"tec_set_i": float(i_out)})
|
|
else:
|
|
raise InvalidDataType
|
|
|
|
def set_constant_current_control_mode(self):
|
|
"""
|
|
Disable PID Controller and output current can be controlled with set_tec_i_out() cmd.
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetPidDisEngage, None)
|
|
|
|
def set_temperature_setpoint(self, temperature):
|
|
"""
|
|
Set Temperature Setpoint for PID Controller. This parameter is not active in constant current control mode
|
|
- temperature: Degree Celsius
|
|
"""
|
|
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetTemperatureSetpoint, temperature)
|
|
|
|
def set_pid_control_mode(self):
|
|
"""
|
|
Enable PID Controller. Its PID Update Interval is controlled by the Temperature ADC polling rate.
|
|
Please refer to config_temp_adc_filter for the possible polling rate options
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetPidEngage, None)
|
|
|
|
def set_pid_kp(self, kp):
|
|
"""
|
|
Set Kp parameter for PID Controller
|
|
kp: (unitless)
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetPidKp, kp)
|
|
|
|
def set_pid_ki(self, ki):
|
|
"""
|
|
Set Ki parameter for PID Controller
|
|
ki: (unitless)
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetPidKi, ki)
|
|
|
|
def set_pid_kd(self, kd):
|
|
"""
|
|
Set Kd parameter for PID Controller
|
|
kd: (unitless)
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetPidKd, kd)
|
|
|
|
def set_pid_output_max(self, out_max):
|
|
"""
|
|
Set max output limit at the PID Output
|
|
- out_max: A
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetPidOutMax, out_max)
|
|
|
|
def set_pid_output_min(self, out_min):
|
|
"""
|
|
Set min output limit at the PID Output
|
|
- out_min: A
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetPidOutMin, out_min)
|
|
|
|
def set_temp_mon_upper_limit(self, upper_limit):
|
|
"""
|
|
Set Temperature Monitor Upper Limit Threshold. Exceeding the limit for too long
|
|
will force the TEC Controller, PID Controller and Laser Diode Power to Shutdown
|
|
- upper_limit: Degree Celsius
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetTempMonUpperLimit, upper_limit)
|
|
|
|
def set_temp_mon_lower_limit(self, lower_limit):
|
|
"""
|
|
Set Temperature Monitor Lower Limit Threshold. Exceeding the limit for too long
|
|
will force the TEC Controller, PID Controller and Laser Diode Power to Shutdown
|
|
- lower_limit: Degree Celsius
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetTempMonLowerLimit, lower_limit)
|
|
|
|
def clear_alarm(self):
|
|
"""
|
|
Clear the temperature monitor alarm
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.ClearAlarm)
|
|
|
|
def set_sh_t0(self, t0):
|
|
"""
|
|
Set t0 Steinhart-Hart parameter for the laser diode NTC
|
|
- t0: Degree Celsius
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetShT0, t0)
|
|
|
|
def set_sh_r0(self, r0):
|
|
"""
|
|
Set r0 Steinhart-Hart parameter for the laser diode NTC
|
|
- r0: Ohm
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetShR0, r0)
|
|
|
|
def set_sh_beta(self, beta):
|
|
"""
|
|
Set beta Steinhart-Hart parameter for the laser diode NTC
|
|
- beta: (unitless)
|
|
"""
|
|
return self._send_cmd(self._cmd._target, self._cmd.SetShBeta, beta)
|
|
|
|
def config_temp_adc_filter(self, filter_config):
|
|
"""
|
|
Configure the temperature adc filter type and sampling rate.
|
|
Please refer to AD7172 datasheet for the usage of various types of filter.
|
|
The actual temperature polling rate is bottlenecked by the processing speed of the MCU and
|
|
performs differently under different kinds of workload. Please verify the polling rate with
|
|
the timestamp.
|
|
"""
|
|
cmd = {}
|
|
cmd[self._cmd._target] = self._cmd.ConfigTempAdcFilter.name
|
|
if hasattr(filter_config, 'rate'):
|
|
cmd[self._cmd.ConfigTempAdcFilter] = {
|
|
"filter_type": filter_config._filter_type(),
|
|
filter_config._odr_type(): filter_config.rate,
|
|
}
|
|
else:
|
|
cmd[self._cmd.ConfigTempAdcFilter] = {
|
|
"filter_type": filter_config._filter_type(),
|
|
filter_config._odr_type(): filter_config,
|
|
}
|
|
|
|
return self._send_raw_cmd(cmd)
|
|
|
|
class Kirdy:
|
|
def __init__(self):
|
|
self.device = Device(self._send_cmd_handler, self._send_raw_cmd_handler, self._get_msg)
|
|
self.laser = Laser(self._send_cmd_handler)
|
|
self.thermostat = Thermostat(self._send_cmd_handler, self._send_raw_cmd_handler)
|
|
|
|
self._task_queue, self._msg_queue, self._int_msg_queue, self._report_queue = None, None, None, None
|
|
self._writer, self._reader = None, None
|
|
self._event_loop = None
|
|
|
|
self._lock = asyncio.Lock()
|
|
self._msg_queue_get_report = False
|
|
self._report_mode_on = False
|
|
|
|
# PyQt Signal
|
|
self._report_sig = None # Dict
|
|
self._connected_sig = None # Bool
|
|
|
|
def set_report_sig(self, sig):
|
|
"""
|
|
Connect a PyQt Signal to the active report output(dict)
|
|
"""
|
|
self._report_sig = sig
|
|
|
|
def set_connected_sig(self, sig):
|
|
"""
|
|
Connect a PyQt Signal to connection status(bool)
|
|
- True: Connection is established
|
|
- False: Connection is dropped
|
|
"""
|
|
self._connected_sig = sig
|
|
|
|
def start_session(self, host='192.168.1.128', port=1337, timeout=5.0, con_retry=5.0):
|
|
"""
|
|
Start Kirdy Connection Session.
|
|
A new thread is started to handle TCP connection and task execution in the background.
|
|
In case of disconnection, all the queued tasks are cleared and the thread retries TCP connection indefinitely.
|
|
|
|
- host: Kirdy's IP Address
|
|
- port: Kirdy's TCP Port
|
|
"""
|
|
if self._event_loop is None:
|
|
self._host, self._ctrl_port = host, port
|
|
self._timeout, self._con_retry = timeout, con_retry
|
|
|
|
self._event_loop = asyncio.new_event_loop()
|
|
self._thread = Thread(target=self._event_loop.run_forever)
|
|
self._thread.start()
|
|
asyncio.run_coroutine_threadsafe(self._handler(), self._event_loop)
|
|
return True
|
|
else:
|
|
logging.warning("Helper Thread has been started.")
|
|
return False
|
|
|
|
def end_session(self, block=False):
|
|
"""
|
|
Stop Kirdy's TCP connection and its associated thread.
|
|
"""
|
|
if self._event_loop is not None:
|
|
if block:
|
|
while not(self._task_queue.empty()):
|
|
pass
|
|
cancel_task = asyncio.run_coroutine_threadsafe(self._stop_handler(), self._event_loop)
|
|
while not(cancel_task.done()):
|
|
pass
|
|
self._thread.join()
|
|
self._writer = None
|
|
|
|
if self._connected_sig is not None:
|
|
self._connected_sig.emit(False)
|
|
|
|
def connecting(self):
|
|
"""
|
|
Return True if client is connecting
|
|
"""
|
|
return not self.connected() and self._event_loop is not None
|
|
|
|
def connected(self):
|
|
"""
|
|
Returns True if client is connected.
|
|
"""
|
|
return self._writer is not None
|
|
|
|
def get_report_stream(self):
|
|
"""
|
|
Start reporting device status in json object.
|
|
"""
|
|
if self.connected():
|
|
self._report_mode_on = True
|
|
|
|
self.device.set_active_report_mode(True)
|
|
|
|
while self._report_mode_on:
|
|
report = self._report_queue.get()
|
|
if isinstance(report, Exception):
|
|
raise report
|
|
yield report
|
|
|
|
self.device.set_active_report_mode(False)
|
|
else:
|
|
raise ConnectionError
|
|
|
|
def stop_report_mode(self):
|
|
self._report_mode_on = False
|
|
|
|
async def _sock_disconnection_handling(self):
|
|
# Reader needn't be closed
|
|
try:
|
|
self._writer.close()
|
|
await self._writer.wait_closed()
|
|
except:
|
|
# In Hard Reset/DFU cmd, Kirdy may close its socket first
|
|
pass
|
|
self._reader = None
|
|
self._writer = None
|
|
|
|
for i in range(self._msg_queue.maxsize):
|
|
if self._msg_queue.full():
|
|
self._msg_queue.get_nowait()
|
|
self._msg_queue.put_nowait(None)
|
|
|
|
for i in range(self._report_queue.maxsize):
|
|
if self._report_queue.full():
|
|
self._report_queue.get_nowait()
|
|
self._report_queue.put_nowait(None)
|
|
|
|
if self._connected_sig is not None:
|
|
self._connected_sig.emit(False)
|
|
|
|
async def _handler(self):
|
|
try:
|
|
state = State.disconnected
|
|
first_con = True
|
|
task = None
|
|
while True:
|
|
if state == State.disconnected:
|
|
try:
|
|
await self.__coninit(self._timeout)
|
|
read_response_fut = asyncio.run_coroutine_threadsafe(self._read_response_handler(), self._event_loop)
|
|
task = None
|
|
logging.debug("Connected")
|
|
|
|
# State Transition
|
|
state = State.connected
|
|
except (OSError, TimeoutError):
|
|
if first_con:
|
|
first_con = False
|
|
logging.warning("Cannot connect to %s:%d. Retrying in the background", self._host, self._ctrl_port)
|
|
await asyncio.sleep(self._con_retry)
|
|
|
|
elif state == State.connected:
|
|
try:
|
|
task = await self._task_queue.get()
|
|
if isinstance(task, Exception):
|
|
raise task
|
|
|
|
response = await asyncio.wait_for(task(), self._timeout)
|
|
if response is not None:
|
|
if response["msg_type"] != "Acknowledge":
|
|
self._msg_queue.put_nowait(response)
|
|
|
|
except (TimeoutError, ConnectionResetError):
|
|
logging.warning("Kirdy connection is dropped.")
|
|
first_con = True
|
|
read_response_fut.cancel()
|
|
await self._sock_disconnection_handling()
|
|
|
|
# State Transition
|
|
state = State.disconnected
|
|
|
|
except asyncio.exceptions.CancelledError:
|
|
logging.debug("Handler is canceling")
|
|
except:
|
|
logging.debug("Handler experienced an error. Exiting.", exc_info=True)
|
|
await self._sock_disconnection_handling()
|
|
if self._event_loop is not None:
|
|
self._event_loop.call_soon_threadsafe(self._event_loop.stop)
|
|
self._event_loop = None
|
|
|
|
async def _read_response_handler(self):
|
|
try:
|
|
while True:
|
|
if self._report_mode_on:
|
|
responses = await asyncio.wait_for(self._read_response(), 5.0)
|
|
else:
|
|
responses = await self._read_response()
|
|
for response in responses:
|
|
if response["msg_type"] == 'Report' and not self._msg_queue_get_report:
|
|
if self._report_sig is None:
|
|
if self._report_queue.full():
|
|
self._report_queue.get_nowait()
|
|
self._report_queue.put_nowait(response)
|
|
else:
|
|
self._report_sig.emit(response)
|
|
else:
|
|
if self._msg_queue_get_report:
|
|
async with self._lock:
|
|
self._msg_queue_get_report = False
|
|
if self._int_msg_queue.full():
|
|
logging.debug("_int_msg_queue is full")
|
|
self._int_msg_queue.get_nowait()
|
|
self._int_msg_queue.put_nowait(response)
|
|
except asyncio.exceptions.CancelledError:
|
|
logging.debug("Read Response Handler is canceling")
|
|
except TimeoutError:
|
|
logging.warning("Read active report response timeout")
|
|
if self._task_queue.full():
|
|
logging.debug("_int_msg_queue is full")
|
|
self._task_queue.get_nowait()
|
|
self._task_queue.put_nowait(TimeoutError())
|
|
except ConnectionResetError:
|
|
logging.warning("Connection Reset by peer")
|
|
if self._task_queue.full():
|
|
logging.debug("_int_msg_queue is full")
|
|
self._task_queue.get_nowait()
|
|
self._task_queue.put_nowait(ConnectionResetError())
|
|
except:
|
|
logging.warn("Read Response Handler experienced an error. Exiting.", exc_info=True)
|
|
|
|
if self._report_mode_on:
|
|
self._report_mode_on = False
|
|
self._report_queue.put_nowait(TimeoutError)
|
|
|
|
async def _stop_handler(self):
|
|
for task in asyncio.all_tasks():
|
|
task.cancel()
|
|
await asyncio.gather(*asyncio.all_tasks(), loop=self._event_loop)
|
|
|
|
async def __coninit(self, timeout):
|
|
self._task_queue = asyncio.Queue(maxsize=64)
|
|
self._int_msg_queue = asyncio.Queue(maxsize=4)
|
|
self._msg_queue = queue.Queue(maxsize=64)
|
|
self._report_queue = queue.Queue(maxsize=16)
|
|
|
|
self._reader, self._writer = await asyncio.wait_for(asyncio.open_connection(self._host, self._ctrl_port), timeout)
|
|
writer_sock = self._writer.get_extra_info("socket")
|
|
writer_sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
|
|
|
|
if self._connected_sig is not None:
|
|
self._connected_sig.emit(True)
|
|
|
|
async def _read_response(self, buffer_size=16384):
|
|
raw_response = b''
|
|
while len(raw_response) == 0:
|
|
# Ignore 0 size packet
|
|
raw_response = await self._reader.read(buffer_size)
|
|
response = raw_response.decode('utf-8', errors='ignore').split("\n")
|
|
response = response[:-1]
|
|
|
|
items = []
|
|
for item in response:
|
|
items.append(json.loads(item))
|
|
return items
|
|
|
|
def _get_msg(self):
|
|
msg = self._msg_queue.get()
|
|
return msg
|
|
|
|
def _send_raw_cmd_handler(self, cmd, msg_type="Acknowledge", sig=None):
|
|
if self.connected():
|
|
self._event_loop.call_soon_threadsafe(self._task_queue.put_nowait, lambda: self._send_raw_cmd(cmd, msg_type, sig=sig))
|
|
else:
|
|
raise ConnectionError
|
|
|
|
# If the cmd involves a cmd specific data type,
|
|
# checking is done separately within the functions being called
|
|
async def _send_raw_cmd(self, cmd, msg_type, sig=None):
|
|
if self.connected():
|
|
self._writer.write(bytes(json.dumps(cmd), "UTF-8"))
|
|
await self._writer.drain()
|
|
response = await self._int_msg_queue.get()
|
|
if response["msg_type"] == msg_type:
|
|
if sig is not None:
|
|
sig.emit(response)
|
|
return {"msg_type": "Acknowledge"}
|
|
return response
|
|
else:
|
|
raise InvalidCmd
|
|
else:
|
|
raise ConnectionError
|
|
|
|
def _send_cmd_handler(self, target, cmd, data=None, msg_type="Acknowledge", sig=None, hard_reset=False):
|
|
if self.connected():
|
|
if hard_reset:
|
|
while not(self._task_queue.empty()):
|
|
pass
|
|
self._event_loop.call_soon_threadsafe(self._task_queue.put_nowait, lambda: self._send_cmd(target, cmd, data, msg_type, sig=sig))
|
|
if hard_reset:
|
|
# Wait 1s for Kirdy to hard reset
|
|
time.sleep(1.0)
|
|
else:
|
|
raise ConnectionError
|
|
|
|
async def _send_cmd(self, target, cmd, data, msg_type, sig=None):
|
|
cmd_dict = {}
|
|
cmd_dict[target] = cmd.name
|
|
|
|
if cmd == _dt.f32:
|
|
if isinstance(data, float):
|
|
cmd_dict[cmd] = data
|
|
elif isinstance(data, int):
|
|
cmd_dict[cmd] = float(data)
|
|
elif cmd == _dt.bool:
|
|
if isinstance(data, bool):
|
|
cmd_dict[cmd] = data
|
|
else:
|
|
raise InvalidDataType
|
|
elif cmd == "None":
|
|
pass
|
|
|
|
if msg_type == 'Report':
|
|
async with self._lock:
|
|
self._msg_queue_get_report = True
|
|
|
|
self._writer.write(bytes(json.dumps(cmd_dict), "UTF-8"))
|
|
await self._writer.drain()
|
|
|
|
msg = await self._int_msg_queue.get()
|
|
if msg['msg_type'] == msg_type:
|
|
if sig is not None:
|
|
sig.emit(msg)
|
|
return {"msg_type": "Acknowledge"}
|
|
return msg
|
|
else:
|
|
raise InvalidCmd
|