def export_log(self, filepath):
"""
Tedious data aligning: The timestamps separate data series (time -> value) are rounded to whole seconds and
transfered into one dict (time -> 4values), to align the 4 data series. This dict is the used to generate a
csv file.
"""
def _work():
sorted_data = {}
for parameter, series in self.data.items():
for time, value in series:
timestamp = int(time.timestamp())
if timestamp not in sorted_data.keys():
sorted_data[timestamp] = {parameter: value}
else:
sorted_data[timestamp].update({parameter: value})
unit = self.units[self.mode]
with open(filepath, 'w+') as file:
file.write('UTC, Unix timestamp (s), Process Variable ({:s}), Output Power (%), Sensor Value ({:s})\n'.
format(unit, unit))
for timestamp, datapoint in sorted_data.items():
timestring = datetime.datetime.utcfromtimestamp(timestamp).strftime('%Y-%m-%dT%H:%M:%S')
power = datapoint['Power'] if 'Power' in datapoint.keys() else math.nan
controller_pv = datapoint['Controller PV'] if 'Controller PV' in datapoint.keys() else math.nan
sensor_pv = datapoint['Sensor PV'] if 'Sensor PV' in datapoint.keys() else math.nan
file.write('{:s}, {:d}, {:.1f}, {:.1f}, {:.1f}\n'.
format(timestring, timestamp, controller_pv, power, sensor_pv))
worker = Worker(_work)
self.pool.start(worker)
def get_sensor_status(self):
runtime = (datetime.datetime.now() - self.log_start_time).seconds if self.log_start_time else None
worker = Worker(self.sensor.get_sensor_value)
worker.signals.over.connect(lambda val: sendMessage('engine.answer.status',
status_values={'Sensor PV': (val, runtime)}))
if self.is_logging:
worker.signals.over.connect(lambda val, par='Sensor PV': self.add_log_data_point(data={par: val}))
self.pool.start(worker)
def set_pid_parameters(self, parameter, value):
function = {'P1': self.controller.set_pid_p, 'P2': self.controller.set_pid_p2, 'P3': self.controller.set_pid_p3,
'I1': self.controller.set_pid_i, 'I2': self.controller.set_pid_i2, 'I3': self.controller.set_pid_i3,
'D1': self.controller.set_pid_d, 'D2': self.controller.set_pid_d2, 'D3': self.controller.set_pid_d3,
'B23': self.controller.set_boundary_23, 'B12': self.controller.set_boundary_12,
'GS': self.controller.set_gain_scheduling, 'AS': self.controller.set_active_set}[parameter]
worker = Worker(lambda val=value: function(val))
self.pool.start(worker)
def get_controller_parameters(self):
for parameter, function in {'Setpoint': self.controller.get_target_setpoint,
'Power': self.controller.get_working_output,
'Rate': self.controller.get_rate,
'Mode': self.controller.get_control_mode}.items():
worker = Worker(function)
worker.signals.over.connect(lambda val, par=parameter: sendMessage('engine.answer.control_parameters',
control_parameters={par: val}))
self.pool.start(worker)
def get_pid_parameters(self):
for parameter, function in {'P1': self.controller.get_pid_p, 'P2': self.controller.get_pid_p2,
'P3': self.controller.get_pid_p3, 'I1': self.controller.get_pid_i,
'I2': self.controller.get_pid_i2, 'I3': self.controller.get_pid_i3,
'D1': self.controller.get_pid_d, 'D2': self.controller.get_pid_d2,
'D3': self.controller.get_pid_d3, 'B23': self.controller.get_boundary_23,
'B12': self.controller.get_boundary_12, 'AS': self.controller.get_active_set,
'GS': self.controller.get_gain_scheduling}.items():
worker = Worker(function)
worker.signals.over.connect(lambda val, par=parameter: sendMessage('engine.answer.pid_parameters',
pid_parameters={par: val}))
self.pool.start(worker)
def get_controller_status(self):
runtime = (datetime.datetime.now() - self.log_start_time).seconds if self.log_start_time else None
for parameter, function in {'Controller PV': self.controller.get_process_variable,
'Setpoint': self.controller.get_working_setpoint,
'Power': self.controller.get_working_output}.items():
worker = Worker(function)
worker.signals.over.connect(lambda val, par=parameter: sendMessage('engine.answer.status', status_values={
par: (val, runtime)}))
if self.is_logging:
worker.signals.over.connect(lambda val, par=parameter: self.add_log_data_point(data={par: val}))
self.pool.start(worker)
def set_rate(self, rate):
worker = Worker(lambda rat=rate: self.controller.set_rate(rat))
self.pool.start(worker)
def set_manual_output_power(self, power):
worker = Worker(lambda powr=power: self.controller.set_manual_output_power(powr))
self.pool.start(worker)
def set_target_setpoint(self, setpoint):
worker = Worker(lambda setp=setpoint: self.controller.set_target_setpoint(setp))
self.pool.start(worker)
def set_control_mode(self, mode):
function = self.controller.set_manual_mode if mode == 'Manual' else self.controller.set_automatic_mode
worker = Worker(function)
self.pool.start(worker)